blob: db7bb931f8fc412b43c0cc481c4e7bba9e3cdc36 [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);
112static void ex_stop(exarg_T *eap);
113static void ex_exit(exarg_T *eap);
114static void ex_print(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000115#ifdef FEAT_BYTEOFF
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100116static void ex_goto(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000117#else
118# define ex_goto ex_ni
119#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100120static void ex_shell(exarg_T *eap);
121static void ex_preserve(exarg_T *eap);
122static void ex_recover(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100123static void ex_mode(exarg_T *eap);
124static void ex_wrongmodifier(exarg_T *eap);
125static void ex_find(exarg_T *eap);
126static void ex_open(exarg_T *eap);
127static void ex_edit(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000128#ifndef FEAT_GUI
129# define ex_gui ex_nogui
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100130static void ex_nogui(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000131#endif
Bram Moolenaar4f974752019-02-17 17:44:42 +0100132#if defined(FEAT_GUI_MSWIN) && defined(FEAT_MENU) && defined(FEAT_TEAROFF)
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100133static void ex_tearoff(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000134#else
135# define ex_tearoff ex_ni
136#endif
Bram Moolenaar29a2c082018-03-05 21:06:23 +0100137#if (defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_GTK) \
138 || defined(FEAT_TERM_POPUP_MENU)) && defined(FEAT_MENU)
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100139static void ex_popup(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000140#else
141# define ex_popup ex_ni
142#endif
143#ifndef FEAT_GUI_MSWIN
144# define ex_simalt ex_ni
145#endif
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +0000146#if !defined(FEAT_GUI_MSWIN) && !defined(FEAT_GUI_GTK) && !defined(FEAT_GUI_MOTIF)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000147# define gui_mch_find_dialog ex_ni
148# define gui_mch_replace_dialog ex_ni
149#endif
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +0000150#if !defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000151# define ex_helpfind ex_ni
152#endif
153#ifndef FEAT_CSCOPE
Bram Moolenaard4db7712016-11-12 19:16:46 +0100154# define ex_cscope ex_ni
155# define ex_scscope ex_ni
156# define ex_cstag ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000157#endif
158#ifndef FEAT_SYN_HL
159# define ex_syntax ex_ni
Bram Moolenaar860cae12010-06-05 23:22:07 +0200160# define ex_ownsyntax ex_ni
Bram Moolenaarf71a3db2006-03-12 21:50:18 +0000161#endif
Bram Moolenaarf7512552013-06-06 14:55:19 +0200162#if !defined(FEAT_SYN_HL) || !defined(FEAT_PROFILE)
Bram Moolenaar8a7f5a22013-06-06 14:01:46 +0200163# define ex_syntime ex_ni
164#endif
Bram Moolenaarf71a3db2006-03-12 21:50:18 +0000165#ifndef FEAT_SPELL
Bram Moolenaarb765d632005-06-07 21:00:02 +0000166# define ex_spell ex_ni
Bram Moolenaar402d2fe2005-04-15 21:00:38 +0000167# define ex_mkspell ex_ni
Bram Moolenaarf417f2b2005-06-23 22:29:21 +0000168# define ex_spelldump ex_ni
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000169# define ex_spellinfo ex_ni
Bram Moolenaara1ba8112005-06-28 23:23:32 +0000170# define ex_spellrepall ex_ni
Bram Moolenaar402d2fe2005-04-15 21:00:38 +0000171#endif
Bram Moolenaar55debbe2010-05-23 23:34:36 +0200172#ifndef FEAT_PERSISTENT_UNDO
173# define ex_rundo ex_ni
174# define ex_wundo ex_ni
175#endif
Bram Moolenaar0ba04292010-07-14 23:23:17 +0200176#ifndef FEAT_LUA
177# define ex_lua ex_script_ni
178# define ex_luado ex_ni
179# define ex_luafile ex_ni
180#endif
Bram Moolenaar325b7a22004-07-05 15:58:32 +0000181#ifndef FEAT_MZSCHEME
182# define ex_mzscheme ex_script_ni
183# define ex_mzfile ex_ni
184#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000185#ifndef FEAT_PERL
186# define ex_perl ex_script_ni
187# define ex_perldo ex_ni
188#endif
189#ifndef FEAT_PYTHON
190# define ex_python ex_script_ni
Bram Moolenaard620aa92013-05-17 16:40:06 +0200191# define ex_pydo ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000192# define ex_pyfile ex_ni
193#endif
Bram Moolenaarbd5e15f2010-07-17 21:19:38 +0200194#ifndef FEAT_PYTHON3
Bram Moolenaar368373e2010-07-19 20:46:22 +0200195# define ex_py3 ex_script_ni
Bram Moolenaar3dab2802013-05-15 18:28:13 +0200196# define ex_py3do ex_ni
Bram Moolenaarbd5e15f2010-07-17 21:19:38 +0200197# define ex_py3file ex_ni
198#endif
Bram Moolenaarf42dd3c2017-01-28 16:06:38 +0100199#if !defined(FEAT_PYTHON) && !defined(FEAT_PYTHON3)
200# define ex_pyx ex_script_ni
201# define ex_pyxdo ex_ni
202# define ex_pyxfile ex_ni
203#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000204#ifndef FEAT_TCL
205# define ex_tcl ex_script_ni
206# define ex_tcldo ex_ni
207# define ex_tclfile ex_ni
208#endif
209#ifndef FEAT_RUBY
210# define ex_ruby ex_script_ni
211# define ex_rubydo ex_ni
212# define ex_rubyfile ex_ni
213#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000214#ifndef FEAT_KEYMAP
215# define ex_loadkeymap ex_ni
216#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100217static void ex_swapname(exarg_T *eap);
218static void ex_syncbind(exarg_T *eap);
219static void ex_read(exarg_T *eap);
220static void ex_pwd(exarg_T *eap);
221static void ex_equal(exarg_T *eap);
222static void ex_sleep(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100223static void ex_winsize(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100224static void ex_wincmd(exarg_T *eap);
Bram Moolenaar843ee412004-06-30 16:16:41 +0000225#if defined(FEAT_GUI) || defined(UNIX) || defined(VMS) || defined(MSWIN)
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100226static void ex_winpos(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000227#else
228# define ex_winpos ex_ni
229#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100230static void ex_operators(exarg_T *eap);
231static void ex_put(exarg_T *eap);
232static void ex_copymove(exarg_T *eap);
233static void ex_submagic(exarg_T *eap);
234static void ex_join(exarg_T *eap);
235static void ex_at(exarg_T *eap);
236static void ex_bang(exarg_T *eap);
237static void ex_undo(exarg_T *eap);
Bram Moolenaar55debbe2010-05-23 23:34:36 +0200238#ifdef FEAT_PERSISTENT_UNDO
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100239static void ex_wundo(exarg_T *eap);
240static void ex_rundo(exarg_T *eap);
Bram Moolenaar55debbe2010-05-23 23:34:36 +0200241#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100242static void ex_redo(exarg_T *eap);
243static void ex_later(exarg_T *eap);
244static void ex_redir(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100245static void ex_redrawstatus(exarg_T *eap);
Bram Moolenaare12bab32019-01-08 22:02:56 +0100246static void ex_redrawtabline(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100247static void close_redir(void);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100248static void ex_mark(exarg_T *eap);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100249static void ex_startinsert(exarg_T *eap);
250static void ex_stopinsert(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000251#ifdef FEAT_FIND_ID
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100252static void ex_checkpath(exarg_T *eap);
253static void ex_findpat(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000254#else
255# define ex_findpat ex_ni
256# define ex_checkpath ex_ni
257#endif
Bram Moolenaar4033c552017-09-16 20:54:51 +0200258#if defined(FEAT_FIND_ID) && defined(FEAT_QUICKFIX)
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100259static void ex_psearch(exarg_T *eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000260#else
261# define ex_psearch ex_ni
262#endif
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100263static void ex_tag(exarg_T *eap);
264static void ex_tag_cmd(exarg_T *eap, char_u *name);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000265#ifndef FEAT_EVAL
Bram Moolenaar1b1e9df2020-10-10 22:26:52 +0200266# define ex_block ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200267# define ex_break ex_ni
268# define ex_breakadd ex_ni
269# define ex_breakdel ex_ni
270# define ex_breaklist ex_ni
271# define ex_call ex_ni
272# define ex_catch ex_ni
273# define ex_compiler ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200274# define ex_continue ex_ni
275# define ex_debug ex_ni
276# define ex_debuggreedy ex_ni
Bram Moolenaar822ba242020-05-24 23:00:18 +0200277# define ex_defcompile ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200278# define ex_delfunction ex_ni
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100279# define ex_disassemble ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000280# define ex_echo ex_ni
281# define ex_echohl ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000282# define ex_else ex_ni
Bram Moolenaar1b1e9df2020-10-10 22:26:52 +0200283# define ex_endblock ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200284# define ex_endfunction ex_ni
285# define ex_endif ex_ni
286# define ex_endtry ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000287# define ex_endwhile ex_ni
Bram Moolenaare4ce8252019-08-04 15:30:16 +0200288# define ex_eval ex_ni
289# define ex_execute ex_ni
290# 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 Moolenaar071d4272004-06-13 20:20:40 +0000361#ifndef FEAT_JUMPLIST
362# define ex_jumps ex_ni
Bram Moolenaar2d358992016-06-12 21:20:54 +0200363# define ex_clearjumps ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000364# define ex_changes ex_ni
365#endif
366
Bram Moolenaar05159a02005-02-26 23:04:13 +0000367#ifndef FEAT_PROFILE
368# define ex_profile ex_ni
369#endif
Bram Moolenaare4f25e42017-07-07 11:54:15 +0200370#ifndef FEAT_TERMINAL
371# define ex_terminal ex_ni
372#endif
Bram Moolenaard4aa83a2019-05-09 18:59:31 +0200373#if !defined(FEAT_X11) || !defined(FEAT_XCLIPBOARD)
374# define ex_xrestore ex_ni
375#endif
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +0100376#if !defined(FEAT_PROP_POPUP)
Bram Moolenaar682725c2019-05-25 20:10:37 +0200377# define ex_popupclear ex_ni
378#endif
Bram Moolenaar05159a02005-02-26 23:04:13 +0000379
Bram Moolenaar071d4272004-06-13 20:20:40 +0000380/*
381 * Declare cmdnames[].
382 */
383#define DO_DECLARE_EXCMD
384#include "ex_cmds.h"
Bram Moolenaar6de5e122017-04-20 21:55:44 +0200385#include "ex_cmdidxs.h"
Bram Moolenaare5e0fbc2017-03-25 14:51:01 +0100386
Bram Moolenaar071d4272004-06-13 20:20:40 +0000387static char_u dollar_command[2] = {'$', 0};
388
389
390#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100391// Struct for storing a line inside a while/for loop
Bram Moolenaar071d4272004-06-13 20:20:40 +0000392typedef struct
393{
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100394 char_u *line; // command line
395 linenr_T lnum; // sourcing_lnum of the line
Bram Moolenaar071d4272004-06-13 20:20:40 +0000396} wcmd_T;
397
398/*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000399 * Structure used to store info for line position in a while or for loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000400 * This is required, because do_one_cmd() may invoke ex_function(), which
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000401 * reads more lines that may come from the while/for loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000402 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000403struct loop_cookie
Bram Moolenaar071d4272004-06-13 20:20:40 +0000404{
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100405 garray_T *lines_gap; // growarray with line info
406 int current_line; // last read line from growarray
407 int repeating; // TRUE when looping a second time
408 // When "repeating" is FALSE use "getline" and "cookie" to get lines
Bram Moolenaar20b23c62020-08-20 15:25:00 +0200409 char_u *(*getline)(int, void *, int, getline_opt_T);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000410 void *cookie;
411};
412
Bram Moolenaar20b23c62020-08-20 15:25:00 +0200413static char_u *get_loop_line(int c, void *cookie, int indent, getline_opt_T options);
Bram Moolenaarf28dbce2016-01-29 22:03:47 +0100414static int store_loop_line(garray_T *gap, char_u *line);
415static void free_cmdlines(garray_T *gap);
Bram Moolenaared203462004-06-16 11:19:22 +0000416
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100417// Struct to save a few things while debugging. Used in do_cmdline() only.
Bram Moolenaared203462004-06-16 11:19:22 +0000418struct dbg_stuff
419{
420 int trylevel;
421 int force_abort;
422 except_T *caught_stack;
423 char_u *vv_exception;
424 char_u *vv_throwpoint;
425 int did_emsg;
426 int got_int;
427 int did_throw;
428 int need_rethrow;
429 int check_cstack;
430 except_T *current_exception;
431};
432
Bram Moolenaared203462004-06-16 11:19:22 +0000433 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100434save_dbg_stuff(struct dbg_stuff *dsp)
Bram Moolenaared203462004-06-16 11:19:22 +0000435{
436 dsp->trylevel = trylevel; trylevel = 0;
437 dsp->force_abort = force_abort; force_abort = FALSE;
438 dsp->caught_stack = caught_stack; caught_stack = NULL;
439 dsp->vv_exception = v_exception(NULL);
440 dsp->vv_throwpoint = v_throwpoint(NULL);
441
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100442 // Necessary for debugging an inactive ":catch", ":finally", ":endtry"
Bram Moolenaared203462004-06-16 11:19:22 +0000443 dsp->did_emsg = did_emsg; did_emsg = FALSE;
444 dsp->got_int = got_int; got_int = FALSE;
445 dsp->did_throw = did_throw; did_throw = FALSE;
446 dsp->need_rethrow = need_rethrow; need_rethrow = FALSE;
447 dsp->check_cstack = check_cstack; check_cstack = FALSE;
448 dsp->current_exception = current_exception; current_exception = NULL;
449}
450
451 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100452restore_dbg_stuff(struct dbg_stuff *dsp)
Bram Moolenaared203462004-06-16 11:19:22 +0000453{
454 suppress_errthrow = FALSE;
455 trylevel = dsp->trylevel;
456 force_abort = dsp->force_abort;
457 caught_stack = dsp->caught_stack;
458 (void)v_exception(dsp->vv_exception);
459 (void)v_throwpoint(dsp->vv_throwpoint);
460 did_emsg = dsp->did_emsg;
461 got_int = dsp->got_int;
462 did_throw = dsp->did_throw;
463 need_rethrow = dsp->need_rethrow;
464 check_cstack = dsp->check_cstack;
465 current_exception = dsp->current_exception;
466}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000467#endif
468
Bram Moolenaar071d4272004-06-13 20:20:40 +0000469/*
470 * do_exmode(): Repeatedly get commands for the "Ex" mode, until the ":vi"
471 * command is given.
472 */
473 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100474do_exmode(
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100475 int improved) // TRUE for "improved Ex" mode
Bram Moolenaar071d4272004-06-13 20:20:40 +0000476{
477 int save_msg_scroll;
478 int prev_msg_row;
479 linenr_T prev_line;
Bram Moolenaar79518e22017-02-17 16:31:35 +0100480 varnumber_T changedtick;
Bram Moolenaardf177f62005-02-22 08:39:57 +0000481
482 if (improved)
483 exmode_active = EXMODE_VIM;
484 else
485 exmode_active = EXMODE_NORMAL;
486 State = NORMAL;
487
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100488 // When using ":global /pat/ visual" and then "Q" we return to continue
489 // the :global command.
Bram Moolenaardf177f62005-02-22 08:39:57 +0000490 if (global_busy)
491 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000492
493 save_msg_scroll = msg_scroll;
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100494 ++RedrawingDisabled; // don't redisplay the window
495 ++no_wait_return; // don't wait for return
Bram Moolenaar071d4272004-06-13 20:20:40 +0000496#ifdef FEAT_GUI
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100497 // Ignore scrollbar and mouse events in Ex mode
Bram Moolenaar071d4272004-06-13 20:20:40 +0000498 ++hold_gui_events;
499#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000500
Bram Moolenaar32526b32019-01-19 17:43:09 +0100501 msg(_("Entering Ex mode. Type \"visual\" to go to Normal mode."));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000502 while (exmode_active)
503 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100504 // Check for a ":normal" command and no more characters left.
Bram Moolenaar7c626922005-02-07 22:01:03 +0000505 if (ex_normal_busy > 0 && typebuf.tb_len == 0)
506 {
507 exmode_active = FALSE;
508 break;
509 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000510 msg_scroll = TRUE;
511 need_wait_return = FALSE;
512 ex_pressedreturn = FALSE;
513 ex_no_reprint = FALSE;
Bram Moolenaar95c526e2017-02-25 14:59:34 +0100514 changedtick = CHANGEDTICK(curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000515 prev_msg_row = msg_row;
516 prev_line = curwin->w_cursor.lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000517 if (improved)
518 {
519 cmdline_row = msg_row;
520 do_cmdline(NULL, getexline, NULL, 0);
521 }
522 else
523 do_cmdline(NULL, getexmodeline, NULL, DOCMD_NOWAIT);
524 lines_left = Rows - 1;
525
Bram Moolenaardf177f62005-02-22 08:39:57 +0000526 if ((prev_line != curwin->w_cursor.lnum
Bram Moolenaar95c526e2017-02-25 14:59:34 +0100527 || changedtick != CHANGEDTICK(curbuf)) && !ex_no_reprint)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000528 {
Bram Moolenaardf177f62005-02-22 08:39:57 +0000529 if (curbuf->b_ml.ml_flags & ML_EMPTY)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100530 emsg(_(e_emptybuf));
Bram Moolenaardf177f62005-02-22 08:39:57 +0000531 else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000532 {
Bram Moolenaardf177f62005-02-22 08:39:57 +0000533 if (ex_pressedreturn)
534 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100535 // go up one line, to overwrite the ":<CR>" line, so the
536 // output doesn't contain empty lines.
Bram Moolenaardf177f62005-02-22 08:39:57 +0000537 msg_row = prev_msg_row;
538 if (prev_msg_row == Rows - 1)
539 msg_row--;
540 }
541 msg_col = 0;
542 print_line_no_prefix(curwin->w_cursor.lnum, FALSE, FALSE);
543 msg_clr_eos();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000544 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000545 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100546 else if (ex_pressedreturn && !ex_no_reprint) // must be at EOF
Bram Moolenaardf177f62005-02-22 08:39:57 +0000547 {
548 if (curbuf->b_ml.ml_flags & ML_EMPTY)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100549 emsg(_(e_emptybuf));
Bram Moolenaardf177f62005-02-22 08:39:57 +0000550 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100551 emsg(_("E501: At end-of-file"));
Bram Moolenaardf177f62005-02-22 08:39:57 +0000552 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000553 }
554
555#ifdef FEAT_GUI
556 --hold_gui_events;
557#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000558 --RedrawingDisabled;
559 --no_wait_return;
560 update_screen(CLEAR);
561 need_wait_return = FALSE;
562 msg_scroll = save_msg_scroll;
563}
564
565/*
Bram Moolenaar4facea32019-10-12 20:17:40 +0200566 * Print the executed command for when 'verbose' is set.
567 * When "lnum" is 0 only print the command.
568 */
569 static void
570msg_verbose_cmd(linenr_T lnum, char_u *cmd)
571{
572 ++no_wait_return;
573 verbose_enter_scroll();
574
575 if (lnum == 0)
576 smsg(_("Executing: %s"), cmd);
577 else
578 smsg(_("line %ld: %s"), (long)lnum, cmd);
579 if (msg_silent == 0)
580 msg_puts("\n"); // don't overwrite this
581
582 verbose_leave_scroll();
583 --no_wait_return;
584}
585
586/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000587 * Execute a simple command line. Used for translated commands like "*".
588 */
589 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100590do_cmdline_cmd(char_u *cmd)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000591{
592 return do_cmdline(cmd, NULL, NULL,
593 DOCMD_VERBOSE|DOCMD_NOWAIT|DOCMD_KEYTYPED);
594}
595
596/*
Bram Moolenaar47a2abf2020-11-25 20:12:11 +0100597 * Execute the "+cmd" argument of "edit +cmd fname" and the like.
598 * This allows for using a range without ":" in Vim9 script.
599 */
600 int
601do_cmd_argument(char_u *cmd)
602{
603 return do_cmdline(cmd, NULL, NULL,
604 DOCMD_VERBOSE|DOCMD_NOWAIT|DOCMD_KEYTYPED|DOCMD_RANGEOK);
605}
606
607/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000608 * do_cmdline(): execute one Ex command line
609 *
610 * 1. Execute "cmdline" when it is not NULL.
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100611 * If "cmdline" is NULL, or more lines are needed, fgetline() is used.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000612 * 2. Split up in parts separated with '|'.
613 *
614 * This function can be called recursively!
615 *
616 * flags:
617 * DOCMD_VERBOSE - The command will be included in the error message.
618 * DOCMD_NOWAIT - Don't call wait_return() and friends.
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100619 * DOCMD_REPEAT - Repeat execution until fgetline() returns NULL.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000620 * DOCMD_KEYTYPED - Don't reset KeyTyped.
621 * DOCMD_EXCRESET - Reset the exception environment (used for debugging).
622 * DOCMD_KEEPLINE - Store first typed line (for repeating with ".").
623 *
624 * return FAIL if cmdline could not be executed, OK otherwise
625 */
626 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100627do_cmdline(
628 char_u *cmdline,
Bram Moolenaar66250c92020-08-20 15:02:42 +0200629 char_u *(*fgetline)(int, void *, int, getline_opt_T),
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100630 void *cookie, // argument for fgetline()
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100631 int flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000632{
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100633 char_u *next_cmdline; // next cmd to execute
634 char_u *cmdline_copy = NULL; // copy of cmd line
635 int used_getline = FALSE; // used "fgetline" to obtain command
636 static int recursive = 0; // recursive depth
Bram Moolenaar071d4272004-06-13 20:20:40 +0000637 int msg_didout_before_start = 0;
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100638 int count = 0; // line number count
639 int did_inc = FALSE; // incremented RedrawingDisabled
Bram Moolenaar071d4272004-06-13 20:20:40 +0000640 int retval = OK;
641#ifdef FEAT_EVAL
Bram Moolenaarddef1292019-12-16 17:10:33 +0100642 cstack_T cstack; // conditional stack
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100643 garray_T lines_ga; // keep lines for ":while"/":for"
644 int current_line = 0; // active line in lines_ga
Bram Moolenaard5053d02020-06-28 15:51:16 +0200645 int current_line_before = 0;
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100646 char_u *fname = NULL; // function or script name
647 linenr_T *breakpoint = NULL; // ptr to breakpoint field in cookie
648 int *dbg_tick = NULL; // ptr to dbg_tick field in cookie
649 struct dbg_stuff debug_saved; // saved things for debug mode
Bram Moolenaar071d4272004-06-13 20:20:40 +0000650 int initial_trylevel;
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200651 msglist_T **saved_msg_list = NULL;
Bram Moolenaar683581e2020-10-22 21:22:58 +0200652 msglist_T *private_msg_list = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000653
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100654 // "fgetline" and "cookie" passed to do_one_cmd()
Bram Moolenaar66250c92020-08-20 15:02:42 +0200655 char_u *(*cmd_getline)(int, void *, int, getline_opt_T);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000656 void *cmd_cookie;
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000657 struct loop_cookie cmd_loop_cookie;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000658 void *real_cookie;
Bram Moolenaar05159a02005-02-26 23:04:13 +0000659 int getline_is_func;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000660#else
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100661# define cmd_getline fgetline
Bram Moolenaar071d4272004-06-13 20:20:40 +0000662# define cmd_cookie cookie
663#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100664 static int call_depth = 0; // recursiveness
Bram Moolenaar2196bce2020-04-12 20:01:11 +0200665#ifdef FEAT_EVAL
Bram Moolenaare31ee862020-01-07 20:59:34 +0100666 ESTACK_CHECK_DECLARATION
Bram Moolenaar071d4272004-06-13 20:20:40 +0000667
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100668 // For every pair of do_cmdline()/do_one_cmd() calls, use an extra memory
669 // location for storing error messages to be converted to an exception.
670 // This ensures that the do_errthrow() call in do_one_cmd() does not
671 // combine the messages stored by an earlier invocation of do_one_cmd()
672 // with the command name of the later one. This would happen when
673 // BufWritePost autocommands are executed after a write error.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000674 saved_msg_list = msg_list;
675 msg_list = &private_msg_list;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000676#endif
677
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100678 // It's possible to create an endless loop with ":execute", catch that
679 // here. The value of 200 allows nested function calls, ":source", etc.
680 // Allow 200 or 'maxfuncdepth', whatever is larger.
Bram Moolenaarb094ff42017-01-02 16:16:39 +0100681 if (call_depth >= 200
682#ifdef FEAT_EVAL
683 && call_depth >= p_mfd
684#endif
685 )
Bram Moolenaar071d4272004-06-13 20:20:40 +0000686 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100687 emsg(_("E169: Command too recursive"));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000688#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100689 // When converting to an exception, we do not include the command name
690 // since this is not an error of the specific command.
Bram Moolenaarddef1292019-12-16 17:10:33 +0100691 do_errthrow((cstack_T *)NULL, (char_u *)NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000692 msg_list = saved_msg_list;
693#endif
694 return FAIL;
695 }
696 ++call_depth;
697
698#ifdef FEAT_EVAL
Bram Moolenaarce0370d2021-01-26 19:32:53 +0100699 CLEAR_FIELD(cstack);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000700 cstack.cs_idx = -1;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000701 ga_init2(&lines_ga, (int)sizeof(wcmd_T), 10);
702
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100703 real_cookie = getline_cookie(fgetline, cookie);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000704
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100705 // Inside a function use a higher nesting level.
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100706 getline_is_func = getline_equal(fgetline, cookie, get_func_line);
Bram Moolenaar05159a02005-02-26 23:04:13 +0000707 if (getline_is_func && ex_nesting_level == func_level(real_cookie))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000708 ++ex_nesting_level;
709
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100710 // Get the function or script name and the address where the next breakpoint
711 // line and the debug tick for a function or script are stored.
Bram Moolenaar05159a02005-02-26 23:04:13 +0000712 if (getline_is_func)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000713 {
714 fname = func_name(real_cookie);
715 breakpoint = func_breakpoint(real_cookie);
716 dbg_tick = func_dbg_tick(real_cookie);
717 }
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100718 else if (getline_equal(fgetline, cookie, getsourceline))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000719 {
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100720 fname = SOURCING_NAME;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000721 breakpoint = source_breakpoint(real_cookie);
722 dbg_tick = source_dbg_tick(real_cookie);
723 }
724
725 /*
726 * Initialize "force_abort" and "suppress_errthrow" at the top level.
727 */
728 if (!recursive)
729 {
730 force_abort = FALSE;
731 suppress_errthrow = FALSE;
732 }
733
734 /*
735 * If requested, store and reset the global values controlling the
Bram Moolenaar89d40322006-08-29 15:30:07 +0000736 * exception handling (used when debugging). Otherwise clear it to avoid
737 * a bogus compiler warning when the optimizer uses inline functions...
Bram Moolenaar071d4272004-06-13 20:20:40 +0000738 */
Bram Moolenaarb4872942006-05-13 10:32:52 +0000739 if (flags & DOCMD_EXCRESET)
Bram Moolenaared203462004-06-16 11:19:22 +0000740 save_dbg_stuff(&debug_saved);
Bram Moolenaar89d40322006-08-29 15:30:07 +0000741 else
Bram Moolenaara80faa82020-04-12 19:37:17 +0200742 CLEAR_FIELD(debug_saved);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000743
744 initial_trylevel = trylevel;
745
746 /*
747 * "did_throw" will be set to TRUE when an exception is being thrown.
748 */
749 did_throw = FALSE;
750#endif
751 /*
752 * "did_emsg" will be set to TRUE when emsg() is used, in which case we
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000753 * cancel the whole command line, and any if/endif or loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000754 * If force_abort is set, we cancel everything.
755 */
Bram Moolenaareeece9e2020-11-20 19:26:48 +0100756#ifdef FEAT_EVAL
757 did_emsg_cumul += did_emsg;
758#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000759 did_emsg = FALSE;
760
761 /*
762 * KeyTyped is only set when calling vgetc(). Reset it here when not
763 * calling vgetc() (sourced command lines).
764 */
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100765 if (!(flags & DOCMD_KEYTYPED)
766 && !getline_equal(fgetline, cookie, getexline))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000767 KeyTyped = FALSE;
768
769 /*
770 * Continue executing command lines:
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000771 * - when inside an ":if", ":while" or ":for"
Bram Moolenaar071d4272004-06-13 20:20:40 +0000772 * - for multiple commands on one line, separated with '|'
773 * - when repeating until there are no more lines (for ":source")
774 */
775 next_cmdline = cmdline;
776 do
777 {
Bram Moolenaar05159a02005-02-26 23:04:13 +0000778#ifdef FEAT_EVAL
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100779 getline_is_func = getline_equal(fgetline, cookie, get_func_line);
Bram Moolenaar05159a02005-02-26 23:04:13 +0000780#endif
781
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100782 // stop skipping cmds for an error msg after all endif/while/for
Bram Moolenaar071d4272004-06-13 20:20:40 +0000783 if (next_cmdline == NULL
784#ifdef FEAT_EVAL
785 && !force_abort
786 && cstack.cs_idx < 0
Bram Moolenaar05159a02005-02-26 23:04:13 +0000787 && !(getline_is_func && func_has_abort(real_cookie))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000788#endif
789 )
Bram Moolenaareeece9e2020-11-20 19:26:48 +0100790 {
791#ifdef FEAT_EVAL
792 did_emsg_cumul += did_emsg;
793#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000794 did_emsg = FALSE;
Bram Moolenaareeece9e2020-11-20 19:26:48 +0100795 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000796
797 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000798 * 1. If repeating a line in a loop, get a line from lines_ga.
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100799 * 2. If no line given: Get an allocated line with fgetline().
Bram Moolenaar071d4272004-06-13 20:20:40 +0000800 * 3. If a line is given: Make a copy, so we can mess with it.
801 */
802
803#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100804 // 1. If repeating, get a previous line from lines_ga.
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000805 if (cstack.cs_looplevel > 0 && current_line < lines_ga.ga_len)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000806 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100807 // Each '|' separated command is stored separately in lines_ga, to
808 // be able to jump to it. Don't use next_cmdline now.
Bram Moolenaard23a8232018-02-10 18:45:26 +0100809 VIM_CLEAR(cmdline_copy);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000810
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100811 // Check if a function has returned or, unless it has an unclosed
812 // try conditional, aborted.
Bram Moolenaar05159a02005-02-26 23:04:13 +0000813 if (getline_is_func)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000814 {
Bram Moolenaar05159a02005-02-26 23:04:13 +0000815# ifdef FEAT_PROFILE
Bram Moolenaar371d5402006-03-20 21:47:49 +0000816 if (do_profiling == PROF_YES)
Bram Moolenaar05159a02005-02-26 23:04:13 +0000817 func_line_end(real_cookie);
818# endif
819 if (func_has_ended(real_cookie))
820 {
821 retval = FAIL;
822 break;
823 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000824 }
Bram Moolenaar05159a02005-02-26 23:04:13 +0000825#ifdef FEAT_PROFILE
Bram Moolenaar371d5402006-03-20 21:47:49 +0000826 else if (do_profiling == PROF_YES
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100827 && getline_equal(fgetline, cookie, getsourceline))
Bram Moolenaar05159a02005-02-26 23:04:13 +0000828 script_line_end();
829#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000830
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100831 // Check if a sourced file hit a ":finish" command.
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100832 if (source_finished(fgetline, cookie))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000833 {
834 retval = FAIL;
835 break;
836 }
837
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100838 // If breakpoints have been added/deleted need to check for it.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000839 if (breakpoint != NULL && dbg_tick != NULL
840 && *dbg_tick != debug_tick)
841 {
842 *breakpoint = dbg_find_breakpoint(
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100843 getline_equal(fgetline, cookie, getsourceline),
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100844 fname, SOURCING_LNUM);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000845 *dbg_tick = debug_tick;
846 }
847
848 next_cmdline = ((wcmd_T *)(lines_ga.ga_data))[current_line].line;
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100849 SOURCING_LNUM = ((wcmd_T *)(lines_ga.ga_data))[current_line].lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000850
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100851 // Did we encounter a breakpoint?
Bram Moolenaar071d4272004-06-13 20:20:40 +0000852 if (breakpoint != NULL && *breakpoint != 0
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100853 && *breakpoint <= SOURCING_LNUM)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000854 {
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100855 dbg_breakpoint(fname, SOURCING_LNUM);
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100856 // Find next breakpoint.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000857 *breakpoint = dbg_find_breakpoint(
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100858 getline_equal(fgetline, cookie, getsourceline),
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100859 fname, SOURCING_LNUM);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000860 *dbg_tick = debug_tick;
861 }
Bram Moolenaar05159a02005-02-26 23:04:13 +0000862# ifdef FEAT_PROFILE
Bram Moolenaar371d5402006-03-20 21:47:49 +0000863 if (do_profiling == PROF_YES)
Bram Moolenaar05159a02005-02-26 23:04:13 +0000864 {
865 if (getline_is_func)
Bram Moolenaarb2049902021-01-24 12:53:53 +0100866 func_line_start(real_cookie, SOURCING_LNUM);
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100867 else if (getline_equal(fgetline, cookie, getsourceline))
Bram Moolenaar05159a02005-02-26 23:04:13 +0000868 script_line_start();
869 }
870# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000871 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000872#endif
873
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100874 // 2. If no line given, get an allocated line with fgetline().
Bram Moolenaar071d4272004-06-13 20:20:40 +0000875 if (next_cmdline == NULL)
876 {
877 /*
878 * Need to set msg_didout for the first line after an ":if",
879 * otherwise the ":if" will be overwritten.
880 */
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100881 if (count == 1 && getline_equal(fgetline, cookie, getexline))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000882 msg_didout = TRUE;
Bram Moolenaarbf55e142010-11-16 11:32:01 +0100883 if (fgetline == NULL || (next_cmdline = fgetline(':', cookie,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000884#ifdef FEAT_EVAL
885 cstack.cs_idx < 0 ? 0 : (cstack.cs_idx + 1) * 2
886#else
887 0
888#endif
Bram Moolenaar8242ebb2020-12-29 11:15:01 +0100889 , in_vim9script() ? GETLINE_CONCAT_CONTBAR
890 : GETLINE_CONCAT_CONT)) == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000891 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100892 // Don't call wait_return for aborted command line. The NULL
893 // returned for the end of a sourced file or executed function
894 // doesn't do this.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000895 if (KeyTyped && !(flags & DOCMD_REPEAT))
896 need_wait_return = FALSE;
897 retval = FAIL;
898 break;
899 }
900 used_getline = TRUE;
901
902 /*
903 * Keep the first typed line. Clear it when more lines are typed.
904 */
905 if (flags & DOCMD_KEEPLINE)
906 {
907 vim_free(repeat_cmdline);
908 if (count == 0)
909 repeat_cmdline = vim_strsave(next_cmdline);
910 else
911 repeat_cmdline = NULL;
912 }
913 }
914
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100915 // 3. Make a copy of the command so we can mess with it.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000916 else if (cmdline_copy == NULL)
917 {
918 next_cmdline = vim_strsave(next_cmdline);
919 if (next_cmdline == NULL)
920 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100921 emsg(_(e_outofmem));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000922 retval = FAIL;
923 break;
924 }
925 }
926 cmdline_copy = next_cmdline;
927
928#ifdef FEAT_EVAL
929 /*
Bram Moolenaard5053d02020-06-28 15:51:16 +0200930 * Inside a while/for loop, and when the command looks like a ":while"
931 * or ":for", the line is stored, because we may need it later when
932 * looping.
933 *
934 * When there is a '|' and another command, it is stored separately,
935 * because we need to be able to jump back to it from an
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000936 * :endwhile/:endfor.
Bram Moolenaard5053d02020-06-28 15:51:16 +0200937 *
938 * Pass a different "fgetline" function to do_one_cmd() below,
939 * that it stores lines in or reads them from "lines_ga". Makes it
940 * possible to define a function inside a while/for loop and handles
941 * line continuation.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000942 */
Bram Moolenaard5053d02020-06-28 15:51:16 +0200943 if ((cstack.cs_looplevel > 0 || has_loop_cmd(next_cmdline)))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000944 {
Bram Moolenaard5053d02020-06-28 15:51:16 +0200945 cmd_getline = get_loop_line;
946 cmd_cookie = (void *)&cmd_loop_cookie;
947 cmd_loop_cookie.lines_gap = &lines_ga;
948 cmd_loop_cookie.current_line = current_line;
949 cmd_loop_cookie.getline = fgetline;
950 cmd_loop_cookie.cookie = cookie;
951 cmd_loop_cookie.repeating = (current_line < lines_ga.ga_len);
952
953 // Save the current line when encountering it the first time.
954 if (current_line == lines_ga.ga_len
955 && store_loop_line(&lines_ga, next_cmdline) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000956 {
957 retval = FAIL;
958 break;
959 }
Bram Moolenaard5053d02020-06-28 15:51:16 +0200960 current_line_before = current_line;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000961 }
Bram Moolenaard5053d02020-06-28 15:51:16 +0200962 else
963 {
964 cmd_getline = fgetline;
965 cmd_cookie = cookie;
966 }
967
Bram Moolenaar071d4272004-06-13 20:20:40 +0000968 did_endif = FALSE;
969#endif
970
971 if (count++ == 0)
972 {
973 /*
974 * All output from the commands is put below each other, without
975 * waiting for a return. Don't do this when executing commands
976 * from a script or when being called recursive (e.g. for ":e
977 * +command file").
978 */
979 if (!(flags & DOCMD_NOWAIT) && !recursive)
980 {
981 msg_didout_before_start = msg_didout;
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100982 msg_didany = FALSE; // no output yet
Bram Moolenaar071d4272004-06-13 20:20:40 +0000983 msg_start();
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100984 msg_scroll = TRUE; // put messages below each other
985 ++no_wait_return; // don't wait for return until finished
Bram Moolenaar071d4272004-06-13 20:20:40 +0000986 ++RedrawingDisabled;
987 did_inc = TRUE;
988 }
989 }
990
Bram Moolenaar823654b2020-05-29 23:03:09 +0200991 if ((p_verbose >= 15 && SOURCING_NAME != NULL) || p_verbose >= 16)
Bram Moolenaar1a47ae32019-12-29 23:04:25 +0100992 msg_verbose_cmd(SOURCING_LNUM, cmdline_copy);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000993
994 /*
995 * 2. Execute one '|' separated command.
996 * do_one_cmd() will return NULL if there is no trailing '|'.
997 * "cmdline_copy" can change, e.g. for '%' and '#' expansion.
998 */
999 ++recursive;
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01001000 next_cmdline = do_one_cmd(&cmdline_copy, flags,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001001#ifdef FEAT_EVAL
1002 &cstack,
1003#endif
1004 cmd_getline, cmd_cookie);
1005 --recursive;
1006
1007#ifdef FEAT_EVAL
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001008 if (cmd_cookie == (void *)&cmd_loop_cookie)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001009 // Use "current_line" from "cmd_loop_cookie", it may have been
1010 // incremented when defining a function.
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001011 current_line = cmd_loop_cookie.current_line;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001012#endif
1013
1014 if (next_cmdline == NULL)
1015 {
Bram Moolenaard23a8232018-02-10 18:45:26 +01001016 VIM_CLEAR(cmdline_copy);
Bram Moolenaard7663c22019-08-06 21:59:57 +02001017
Bram Moolenaar071d4272004-06-13 20:20:40 +00001018 /*
1019 * If the command was typed, remember it for the ':' register.
1020 * Do this AFTER executing the command to make :@: work.
1021 */
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001022 if (getline_equal(fgetline, cookie, getexline)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001023 && new_last_cmdline != NULL)
1024 {
1025 vim_free(last_cmdline);
1026 last_cmdline = new_last_cmdline;
1027 new_last_cmdline = NULL;
1028 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001029 }
1030 else
1031 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001032 // need to copy the command after the '|' to cmdline_copy, for the
1033 // next do_one_cmd()
Bram Moolenaara7241f52008-06-24 20:39:31 +00001034 STRMOVE(cmdline_copy, next_cmdline);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001035 next_cmdline = cmdline_copy;
1036 }
1037
1038
1039#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001040 // reset did_emsg for a function that is not aborted by an error
Bram Moolenaar071d4272004-06-13 20:20:40 +00001041 if (did_emsg && !force_abort
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001042 && getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001043 && !func_has_abort(real_cookie))
Bram Moolenaareeece9e2020-11-20 19:26:48 +01001044 {
1045 // did_emsg_cumul is not set here
Bram Moolenaar071d4272004-06-13 20:20:40 +00001046 did_emsg = FALSE;
Bram Moolenaareeece9e2020-11-20 19:26:48 +01001047 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001048
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001049 if (cstack.cs_looplevel > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001050 {
1051 ++current_line;
1052
1053 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001054 * An ":endwhile", ":endfor" and ":continue" is handled here.
1055 * If we were executing commands, jump back to the ":while" or
1056 * ":for".
1057 * If we were not executing commands, decrement cs_looplevel.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001058 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001059 if (cstack.cs_lflags & (CSL_HAD_CONT | CSL_HAD_ENDLOOP))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001060 {
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001061 cstack.cs_lflags &= ~(CSL_HAD_CONT | CSL_HAD_ENDLOOP);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001062
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001063 // Jump back to the matching ":while" or ":for". Be careful
1064 // not to use a cs_line[] from an entry that isn't a ":while"
1065 // or ":for": It would make "current_line" invalid and can
1066 // cause a crash.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001067 if (!did_emsg && !got_int && !did_throw
1068 && cstack.cs_idx >= 0
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001069 && (cstack.cs_flags[cstack.cs_idx]
1070 & (CSF_WHILE | CSF_FOR))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001071 && cstack.cs_line[cstack.cs_idx] >= 0
1072 && (cstack.cs_flags[cstack.cs_idx] & CSF_ACTIVE))
1073 {
1074 current_line = cstack.cs_line[cstack.cs_idx];
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001075 // remember we jumped there
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001076 cstack.cs_lflags |= CSL_HAD_LOOP;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001077 line_breakcheck(); // check if CTRL-C typed
Bram Moolenaar071d4272004-06-13 20:20:40 +00001078
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001079 // Check for the next breakpoint at or after the ":while"
1080 // or ":for".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001081 if (breakpoint != NULL)
1082 {
1083 *breakpoint = dbg_find_breakpoint(
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001084 getline_equal(fgetline, cookie, getsourceline),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001085 fname,
1086 ((wcmd_T *)lines_ga.ga_data)[current_line].lnum-1);
1087 *dbg_tick = debug_tick;
1088 }
1089 }
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001090 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001091 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001092 // can only get here with ":endwhile" or ":endfor"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001093 if (cstack.cs_idx >= 0)
Bram Moolenaarbb761a72005-01-06 23:19:09 +00001094 rewind_conditionals(&cstack, cstack.cs_idx - 1,
1095 CSF_WHILE | CSF_FOR, &cstack.cs_looplevel);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001096 }
1097 }
1098
1099 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001100 * For a ":while" or ":for" we need to remember the line number.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001101 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001102 else if (cstack.cs_lflags & CSL_HAD_LOOP)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001103 {
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001104 cstack.cs_lflags &= ~CSL_HAD_LOOP;
Bram Moolenaard5053d02020-06-28 15:51:16 +02001105 cstack.cs_line[cstack.cs_idx] = current_line_before;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001106 }
1107 }
1108
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001109 // Check for the next breakpoint after a watchexpression
Bram Moolenaarc6f9f732018-02-11 19:06:26 +01001110 if (breakpoint != NULL && has_watchexpr())
1111 {
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001112 *breakpoint = dbg_find_breakpoint(FALSE, fname, SOURCING_LNUM);
Bram Moolenaarc6f9f732018-02-11 19:06:26 +01001113 *dbg_tick = debug_tick;
1114 }
1115
Bram Moolenaar071d4272004-06-13 20:20:40 +00001116 /*
1117 * When not inside any ":while" loop, clear remembered lines.
1118 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001119 if (cstack.cs_looplevel == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001120 {
1121 if (lines_ga.ga_len > 0)
1122 {
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001123 SOURCING_LNUM =
Bram Moolenaar071d4272004-06-13 20:20:40 +00001124 ((wcmd_T *)lines_ga.ga_data)[lines_ga.ga_len - 1].lnum;
1125 free_cmdlines(&lines_ga);
1126 }
1127 current_line = 0;
1128 }
1129
1130 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001131 * A ":finally" makes did_emsg, got_int, and did_throw pending for
1132 * being restored at the ":endtry". Reset them here and set the
1133 * ACTIVE and FINALLY flags, so that the finally clause gets executed.
1134 * This includes the case where a missing ":endif", ":endwhile" or
1135 * ":endfor" was detected by the ":finally" itself.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001136 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001137 if (cstack.cs_lflags & CSL_HAD_FINA)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001138 {
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001139 cstack.cs_lflags &= ~CSL_HAD_FINA;
1140 report_make_pending(cstack.cs_pending[cstack.cs_idx]
1141 & (CSTP_ERROR | CSTP_INTERRUPT | CSTP_THROW),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001142 did_throw ? (void *)current_exception : NULL);
1143 did_emsg = got_int = did_throw = FALSE;
1144 cstack.cs_flags[cstack.cs_idx] |= CSF_ACTIVE | CSF_FINALLY;
1145 }
1146
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001147 // Update global "trylevel" for recursive calls to do_cmdline() from
1148 // within this loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001149 trylevel = initial_trylevel + cstack.cs_trylevel;
1150
1151 /*
Bram Moolenaarc1762cc2007-05-10 16:56:30 +00001152 * If the outermost try conditional (across function calls and sourced
Bram Moolenaar071d4272004-06-13 20:20:40 +00001153 * files) is aborted because of an error, an interrupt, or an uncaught
1154 * exception, cancel everything. If it is left normally, reset
1155 * force_abort to get the non-EH compatible abortion behavior for
1156 * the rest of the script.
1157 */
1158 if (trylevel == 0 && !did_emsg && !got_int && !did_throw)
1159 force_abort = FALSE;
1160
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001161 // Convert an interrupt to an exception if appropriate.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001162 (void)do_intthrow(&cstack);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001163#endif // FEAT_EVAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00001164
1165 }
1166 /*
1167 * Continue executing command lines when:
1168 * - no CTRL-C typed, no aborting error, no exception thrown or try
1169 * conditionals need to be checked for executing finally clauses or
1170 * catching an interrupt exception
1171 * - didn't get an error message or lines are not typed
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001172 * - there is a command after '|', inside a :if, :while, :for or :try, or
Bram Moolenaar071d4272004-06-13 20:20:40 +00001173 * looping for ":source" command or function call.
1174 */
1175 while (!((got_int
1176#ifdef FEAT_EVAL
1177 || (did_emsg && force_abort) || did_throw
1178#endif
1179 )
1180#ifdef FEAT_EVAL
1181 && cstack.cs_trylevel == 0
1182#endif
1183 )
Bram Moolenaar00b8ae02012-08-23 18:43:10 +02001184 && !(did_emsg
1185#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001186 // Keep going when inside try/catch, so that the error can be
1187 // deal with, except when it is a syntax error, it may cause
1188 // the :endtry to be missed.
Bram Moolenaar00b8ae02012-08-23 18:43:10 +02001189 && (cstack.cs_trylevel == 0 || did_emsg_syntax)
1190#endif
1191 && used_getline
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001192 && (getline_equal(fgetline, cookie, getexmodeline)
1193 || getline_equal(fgetline, cookie, getexline)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001194 && (next_cmdline != NULL
1195#ifdef FEAT_EVAL
1196 || cstack.cs_idx >= 0
1197#endif
1198 || (flags & DOCMD_REPEAT)));
1199
1200 vim_free(cmdline_copy);
Bram Moolenaar00b8ae02012-08-23 18:43:10 +02001201 did_emsg_syntax = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001202#ifdef FEAT_EVAL
1203 free_cmdlines(&lines_ga);
1204 ga_clear(&lines_ga);
1205
1206 if (cstack.cs_idx >= 0)
1207 {
1208 /*
1209 * If a sourced file or executed function ran to its end, report the
1210 * unclosed conditional.
1211 */
1212 if (!got_int && !did_throw
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001213 && ((getline_equal(fgetline, cookie, getsourceline)
1214 && !source_finished(fgetline, cookie))
1215 || (getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001216 && !func_has_ended(real_cookie))))
1217 {
1218 if (cstack.cs_flags[cstack.cs_idx] & CSF_TRY)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001219 emsg(_(e_endtry));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001220 else if (cstack.cs_flags[cstack.cs_idx] & CSF_WHILE)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001221 emsg(_(e_endwhile));
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001222 else if (cstack.cs_flags[cstack.cs_idx] & CSF_FOR)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001223 emsg(_(e_endfor));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001224 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001225 emsg(_(e_endif));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001226 }
1227
1228 /*
1229 * Reset "trylevel" in case of a ":finish" or ":return" or a missing
1230 * ":endtry" in a sourced file or executed function. If the try
1231 * conditional is in its finally clause, ignore anything pending.
1232 * If it is in a catch clause, finish the caught exception.
Bram Moolenaarbb761a72005-01-06 23:19:09 +00001233 * Also cleanup any "cs_forinfo" structures.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001234 */
1235 do
Bram Moolenaarbb761a72005-01-06 23:19:09 +00001236 {
1237 int idx = cleanup_conditionals(&cstack, 0, TRUE);
1238
Bram Moolenaar89e5d682005-01-17 22:06:23 +00001239 if (idx >= 0)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001240 --idx; // remove try block not in its finally clause
Bram Moolenaarbb761a72005-01-06 23:19:09 +00001241 rewind_conditionals(&cstack, idx, CSF_WHILE | CSF_FOR,
1242 &cstack.cs_looplevel);
1243 }
1244 while (cstack.cs_idx >= 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001245 trylevel = initial_trylevel;
1246 }
1247
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001248 // If a missing ":endtry", ":endwhile", ":endfor", or ":endif" or a memory
1249 // lack was reported above and the error message is to be converted to an
1250 // exception, do this now after rewinding the cstack.
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001251 do_errthrow(&cstack, getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001252 ? (char_u *)"endfunction" : (char_u *)NULL);
1253
1254 if (trylevel == 0)
1255 {
Bram Moolenaar820d55a2020-10-10 15:05:23 +02001256 // Just in case did_throw got set but current_exception wasn't.
1257 if (current_exception == NULL)
1258 did_throw = FALSE;
1259
Bram Moolenaar071d4272004-06-13 20:20:40 +00001260 /*
1261 * When an exception is being thrown out of the outermost try
1262 * conditional, discard the uncaught exception, disable the conversion
1263 * of interrupts or errors to exceptions, and ensure that no more
1264 * commands are executed.
1265 */
1266 if (did_throw)
1267 {
Bram Moolenaar033135e2021-01-14 21:40:22 +01001268 char *p = NULL;
Bram Moolenaare8c46602021-04-05 22:27:37 +02001269 msglist_T *messages = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001270
1271 /*
1272 * If the uncaught exception is a user exception, report it as an
1273 * error. If it is an error exception, display the saved error
1274 * message now. For an interrupt exception, do nothing; the
1275 * interrupt message is given elsewhere.
1276 */
1277 switch (current_exception->type)
1278 {
1279 case ET_USER:
Bram Moolenaar9c13b352005-05-19 20:53:52 +00001280 vim_snprintf((char *)IObuff, IOSIZE,
1281 _("E605: Exception not caught: %s"),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001282 current_exception->value);
Bram Moolenaar033135e2021-01-14 21:40:22 +01001283 p = (char *)vim_strsave(IObuff);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001284 break;
1285 case ET_ERROR:
1286 messages = current_exception->messages;
1287 current_exception->messages = NULL;
1288 break;
1289 case ET_INTERRUPT:
1290 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001291 }
1292
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001293 estack_push(ETYPE_EXCEPT, current_exception->throw_name,
1294 current_exception->throw_lnum);
Bram Moolenaare31ee862020-01-07 20:59:34 +01001295 ESTACK_CHECK_SETUP
Bram Moolenaar071d4272004-06-13 20:20:40 +00001296 current_exception->throw_name = NULL;
1297
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001298 discard_current_exception(); // uses IObuff if 'verbose'
Bram Moolenaar071d4272004-06-13 20:20:40 +00001299 suppress_errthrow = TRUE;
1300 force_abort = TRUE;
1301
1302 if (messages != NULL)
1303 {
1304 do
1305 {
Bram Moolenaare8c46602021-04-05 22:27:37 +02001306 msglist_T *next = messages->next;
1307 int save_compiling = estack_compiling;
1308
1309 estack_compiling = messages->msg_compiling;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001310 emsg(messages->msg);
1311 vim_free(messages->msg);
Bram Moolenaar5fbf3bc2020-06-01 21:13:11 +02001312 vim_free(messages->sfile);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001313 vim_free(messages);
1314 messages = next;
Bram Moolenaare8c46602021-04-05 22:27:37 +02001315 estack_compiling = save_compiling;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001316 }
1317 while (messages != NULL);
1318 }
1319 else if (p != NULL)
1320 {
Bram Moolenaarb5443cc2019-01-15 20:19:40 +01001321 emsg(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001322 vim_free(p);
1323 }
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001324 vim_free(SOURCING_NAME);
Bram Moolenaare31ee862020-01-07 20:59:34 +01001325 ESTACK_CHECK_NOW
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001326 estack_pop();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001327 }
1328
1329 /*
1330 * On an interrupt or an aborting error not converted to an exception,
1331 * disable the conversion of errors to exceptions. (Interrupts are not
Bram Moolenaar2196bce2020-04-12 20:01:11 +02001332 * converted anymore, here.) This enables also the interrupt message
Bram Moolenaar071d4272004-06-13 20:20:40 +00001333 * when force_abort is set and did_emsg unset in case of an interrupt
1334 * from a finally clause after an error.
1335 */
1336 else if (got_int || (did_emsg && force_abort))
1337 suppress_errthrow = TRUE;
1338 }
1339
1340 /*
1341 * The current cstack will be freed when do_cmdline() returns. An uncaught
1342 * exception will have to be rethrown in the previous cstack. If a function
1343 * has just returned or a script file was just finished and the previous
1344 * cstack belongs to the same function or, respectively, script file, it
1345 * will have to be checked for finally clauses to be executed due to the
1346 * ":return" or ":finish". This is done in do_one_cmd().
1347 */
1348 if (did_throw)
1349 need_rethrow = TRUE;
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001350 if ((getline_equal(fgetline, cookie, getsourceline)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001351 && ex_nesting_level > source_level(real_cookie))
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001352 || (getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001353 && ex_nesting_level > func_level(real_cookie) + 1))
1354 {
1355 if (!did_throw)
1356 check_cstack = TRUE;
1357 }
1358 else
1359 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001360 // When leaving a function, reduce nesting level.
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001361 if (getline_equal(fgetline, cookie, get_func_line))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001362 --ex_nesting_level;
1363 /*
1364 * Go to debug mode when returning from a function in which we are
1365 * single-stepping.
1366 */
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001367 if ((getline_equal(fgetline, cookie, getsourceline)
1368 || getline_equal(fgetline, cookie, get_func_line))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001369 && ex_nesting_level + 1 <= debug_break_level)
Bram Moolenaarbf55e142010-11-16 11:32:01 +01001370 do_debug(getline_equal(fgetline, cookie, getsourceline)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001371 ? (char_u *)_("End of sourced file")
1372 : (char_u *)_("End of function"));
1373 }
1374
1375 /*
1376 * Restore the exception environment (done after returning from the
1377 * debugger).
1378 */
1379 if (flags & DOCMD_EXCRESET)
Bram Moolenaared203462004-06-16 11:19:22 +00001380 restore_dbg_stuff(&debug_saved);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001381
1382 msg_list = saved_msg_list;
Bram Moolenaar292b90d2020-03-18 15:23:16 +01001383
1384 // Cleanup if "cs_emsg_silent_list" remains.
1385 if (cstack.cs_emsg_silent_list != NULL)
1386 {
1387 eslist_T *elem, *temp;
1388
1389 for (elem = cstack.cs_emsg_silent_list; elem != NULL; elem = temp)
1390 {
1391 temp = elem->next;
1392 vim_free(elem);
1393 }
1394 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001395#endif // FEAT_EVAL
Bram Moolenaar071d4272004-06-13 20:20:40 +00001396
1397 /*
1398 * If there was too much output to fit on the command line, ask the user to
1399 * hit return before redrawing the screen. With the ":global" command we do
1400 * this only once after the command is finished.
1401 */
1402 if (did_inc)
1403 {
1404 --RedrawingDisabled;
1405 --no_wait_return;
1406 msg_scroll = FALSE;
1407
1408 /*
1409 * When just finished an ":if"-":else" which was typed, no need to
1410 * wait for hit-return. Also for an error situation.
1411 */
1412 if (retval == FAIL
1413#ifdef FEAT_EVAL
1414 || (did_endif && KeyTyped && !did_emsg)
1415#endif
1416 )
1417 {
1418 need_wait_return = FALSE;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001419 msg_didany = FALSE; // don't wait when restarting edit
Bram Moolenaar071d4272004-06-13 20:20:40 +00001420 }
1421 else if (need_wait_return)
1422 {
1423 /*
1424 * The msg_start() above clears msg_didout. The wait_return we do
1425 * here should not overwrite the command that may be shown before
1426 * doing that.
1427 */
1428 msg_didout |= msg_didout_before_start;
1429 wait_return(FALSE);
1430 }
1431 }
1432
Bram Moolenaar2a942252012-11-28 23:03:07 +01001433#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001434 did_endif = FALSE; // in case do_cmdline used recursively
Bram Moolenaar2a942252012-11-28 23:03:07 +01001435#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001436 /*
1437 * Reset if_level, in case a sourced script file contains more ":if" than
1438 * ":endif" (could be ":if x | foo | endif").
1439 */
1440 if_level = 0;
Bram Moolenaar2e18a122012-11-28 19:10:54 +01001441#endif
Bram Moolenaard4ad0d42012-11-28 17:34:48 +01001442
Bram Moolenaar071d4272004-06-13 20:20:40 +00001443 --call_depth;
1444 return retval;
1445}
1446
1447#ifdef FEAT_EVAL
1448/*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001449 * Obtain a line when inside a ":while" or ":for" loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001450 */
1451 static char_u *
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001452get_loop_line(int c, void *cookie, int indent, getline_opt_T options)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001453{
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001454 struct loop_cookie *cp = (struct loop_cookie *)cookie;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001455 wcmd_T *wp;
1456 char_u *line;
1457
1458 if (cp->current_line + 1 >= cp->lines_gap->ga_len)
1459 {
1460 if (cp->repeating)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001461 return NULL; // trying to read past ":endwhile"/":endfor"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001462
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001463 // First time inside the ":while"/":for": get line normally.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001464 if (cp->getline == NULL)
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001465 line = getcmdline(c, 0L, indent, options);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001466 else
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001467 line = cp->getline(c, cp->cookie, indent, options);
Bram Moolenaard68071d2006-05-02 22:08:30 +00001468 if (line != NULL && store_loop_line(cp->lines_gap, line) == OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001469 ++cp->current_line;
1470
1471 return line;
1472 }
1473
1474 KeyTyped = FALSE;
1475 ++cp->current_line;
1476 wp = (wcmd_T *)(cp->lines_gap->ga_data) + cp->current_line;
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001477 SOURCING_LNUM = wp->lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001478 return vim_strsave(wp->line);
1479}
1480
1481/*
1482 * Store a line in "gap" so that a ":while" loop can execute it again.
1483 */
1484 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001485store_loop_line(garray_T *gap, char_u *line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001486{
1487 if (ga_grow(gap, 1) == FAIL)
1488 return FAIL;
1489 ((wcmd_T *)(gap->ga_data))[gap->ga_len].line = vim_strsave(line);
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01001490 ((wcmd_T *)(gap->ga_data))[gap->ga_len].lnum = SOURCING_LNUM;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001491 ++gap->ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001492 return OK;
1493}
1494
1495/*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001496 * Free the lines stored for a ":while" or ":for" loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001497 */
1498 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001499free_cmdlines(garray_T *gap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001500{
1501 while (gap->ga_len > 0)
1502 {
1503 vim_free(((wcmd_T *)(gap->ga_data))[gap->ga_len - 1].line);
1504 --gap->ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001505 }
1506}
1507#endif
1508
1509/*
Bram Moolenaar89d40322006-08-29 15:30:07 +00001510 * If "fgetline" is get_loop_line(), return TRUE if the getline it uses equals
1511 * "func". * Otherwise return TRUE when "fgetline" equals "func".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001512 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001513 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001514getline_equal(
Bram Moolenaar66250c92020-08-20 15:02:42 +02001515 char_u *(*fgetline)(int, void *, int, getline_opt_T),
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001516 void *cookie UNUSED, // argument for fgetline()
Bram Moolenaar66250c92020-08-20 15:02:42 +02001517 char_u *(*func)(int, void *, int, getline_opt_T))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001518{
1519#ifdef FEAT_EVAL
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001520 char_u *(*gp)(int, void *, int, getline_opt_T);
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001521 struct loop_cookie *cp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001522
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001523 // When "fgetline" is "get_loop_line()" use the "cookie" to find the
1524 // function that's originally used to obtain the lines. This may be
1525 // nested several levels.
Bram Moolenaar89d40322006-08-29 15:30:07 +00001526 gp = fgetline;
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001527 cp = (struct loop_cookie *)cookie;
1528 while (gp == get_loop_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001529 {
1530 gp = cp->getline;
1531 cp = cp->cookie;
1532 }
1533 return gp == func;
1534#else
Bram Moolenaar89d40322006-08-29 15:30:07 +00001535 return fgetline == func;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001536#endif
1537}
1538
Bram Moolenaar071d4272004-06-13 20:20:40 +00001539/*
Bram Moolenaar89d40322006-08-29 15:30:07 +00001540 * If "fgetline" is get_loop_line(), return the cookie used by the original
Bram Moolenaar071d4272004-06-13 20:20:40 +00001541 * getline function. Otherwise return "cookie".
1542 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001543 void *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001544getline_cookie(
Bram Moolenaar66250c92020-08-20 15:02:42 +02001545 char_u *(*fgetline)(int, void *, int, getline_opt_T) UNUSED,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001546 void *cookie) // argument for fgetline()
Bram Moolenaar071d4272004-06-13 20:20:40 +00001547{
Bram Moolenaar13505972019-01-24 15:04:48 +01001548#ifdef FEAT_EVAL
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001549 char_u *(*gp)(int, void *, int, getline_opt_T);
Bram Moolenaard5053d02020-06-28 15:51:16 +02001550 struct loop_cookie *cp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001551
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001552 // When "fgetline" is "get_loop_line()" use the "cookie" to find the
1553 // cookie that's originally used to obtain the lines. This may be nested
1554 // several levels.
Bram Moolenaar89d40322006-08-29 15:30:07 +00001555 gp = fgetline;
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001556 cp = (struct loop_cookie *)cookie;
1557 while (gp == get_loop_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001558 {
1559 gp = cp->getline;
1560 cp = cp->cookie;
1561 }
1562 return cp;
Bram Moolenaar13505972019-01-24 15:04:48 +01001563#else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001564 return cookie;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001565#endif
Bram Moolenaar13505972019-01-24 15:04:48 +01001566}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001567
Bram Moolenaard5053d02020-06-28 15:51:16 +02001568#if defined(FEAT_EVAL) || defined(PROT)
1569/*
1570 * Get the next line source line without advancing.
1571 */
1572 char_u *
1573getline_peek(
Bram Moolenaar66250c92020-08-20 15:02:42 +02001574 char_u *(*fgetline)(int, void *, int, getline_opt_T) UNUSED,
Bram Moolenaard5053d02020-06-28 15:51:16 +02001575 void *cookie) // argument for fgetline()
1576{
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001577 char_u *(*gp)(int, void *, int, getline_opt_T);
Bram Moolenaard5053d02020-06-28 15:51:16 +02001578 struct loop_cookie *cp;
1579 wcmd_T *wp;
1580
1581 // When "fgetline" is "get_loop_line()" use the "cookie" to find the
1582 // cookie that's originally used to obtain the lines. This may be nested
1583 // several levels.
1584 gp = fgetline;
1585 cp = (struct loop_cookie *)cookie;
1586 while (gp == get_loop_line)
1587 {
1588 if (cp->current_line + 1 < cp->lines_gap->ga_len)
1589 {
1590 // executing lines a second time, use the stored copy
1591 wp = (wcmd_T *)(cp->lines_gap->ga_data) + cp->current_line + 1;
1592 return wp->line;
1593 }
1594 gp = cp->getline;
1595 cp = cp->cookie;
1596 }
1597 if (gp == getsourceline)
1598 return source_nextline(cp);
1599 return NULL;
1600}
1601#endif
1602
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001603
1604/*
1605 * Helper function to apply an offset for buffer commands, i.e. ":bdelete",
1606 * ":bwipeout", etc.
1607 * Returns the buffer number.
1608 */
1609 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001610compute_buffer_local_count(int addr_type, int lnum, int offset)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001611{
1612 buf_T *buf;
Bram Moolenaar4d84d932014-11-30 14:50:16 +01001613 buf_T *nextbuf;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001614 int count = offset;
1615
1616 buf = firstbuf;
1617 while (buf->b_next != NULL && buf->b_fnum < lnum)
1618 buf = buf->b_next;
1619 while (count != 0)
1620 {
Bram Moolenaar4d84d932014-11-30 14:50:16 +01001621 count += (offset < 0) ? 1 : -1;
1622 nextbuf = (offset < 0) ? buf->b_prev : buf->b_next;
1623 if (nextbuf == NULL)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001624 break;
Bram Moolenaar4d84d932014-11-30 14:50:16 +01001625 buf = nextbuf;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001626 if (addr_type == ADDR_LOADED_BUFFERS)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001627 // skip over unloaded buffers
Bram Moolenaar4d84d932014-11-30 14:50:16 +01001628 while (buf->b_ml.ml_mfp == NULL)
1629 {
1630 nextbuf = (offset < 0) ? buf->b_prev : buf->b_next;
1631 if (nextbuf == NULL)
1632 break;
1633 buf = nextbuf;
1634 }
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001635 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001636 // we might have gone too far, last buffer is not loadedd
Bram Moolenaar4d84d932014-11-30 14:50:16 +01001637 if (addr_type == ADDR_LOADED_BUFFERS)
1638 while (buf->b_ml.ml_mfp == NULL)
1639 {
1640 nextbuf = (offset >= 0) ? buf->b_prev : buf->b_next;
1641 if (nextbuf == NULL)
1642 break;
1643 buf = nextbuf;
1644 }
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001645 return buf->b_fnum;
1646}
1647
Bram Moolenaarb7316892019-05-01 18:08:42 +02001648/*
1649 * Return the window number of "win".
1650 * When "win" is NULL return the number of windows.
1651 */
Bram Moolenaarf240e182014-11-27 18:33:02 +01001652 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001653current_win_nr(win_T *win)
Bram Moolenaarf240e182014-11-27 18:33:02 +01001654{
1655 win_T *wp;
1656 int nr = 0;
1657
Bram Moolenaar29323592016-07-24 22:04:11 +02001658 FOR_ALL_WINDOWS(wp)
Bram Moolenaarf240e182014-11-27 18:33:02 +01001659 {
1660 ++nr;
1661 if (wp == win)
1662 break;
1663 }
1664 return nr;
1665}
1666
1667 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001668current_tab_nr(tabpage_T *tab)
Bram Moolenaarf240e182014-11-27 18:33:02 +01001669{
1670 tabpage_T *tp;
1671 int nr = 0;
1672
Bram Moolenaar29323592016-07-24 22:04:11 +02001673 FOR_ALL_TABPAGES(tp)
Bram Moolenaarf240e182014-11-27 18:33:02 +01001674 {
1675 ++nr;
1676 if (tp == tab)
1677 break;
1678 }
1679 return nr;
1680}
1681
Bram Moolenaar6e36b1c2020-07-17 20:47:51 +02001682 static int
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001683comment_start(char_u *p, int starts_with_colon UNUSED)
1684{
1685#ifdef FEAT_EVAL
1686 if (in_vim9script())
Bram Moolenaar93f82cb2020-12-12 21:25:56 +01001687 return p[0] == '#' && !starts_with_colon;
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001688#endif
1689 return *p == '"';
1690}
1691
Bram Moolenaarf240e182014-11-27 18:33:02 +01001692# define CURRENT_WIN_NR current_win_nr(curwin)
1693# define LAST_WIN_NR current_win_nr(NULL)
1694# define CURRENT_TAB_NR current_tab_nr(curtab)
1695# define LAST_TAB_NR current_tab_nr(NULL)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001696
Bram Moolenaar071d4272004-06-13 20:20:40 +00001697/*
1698 * Execute one Ex command.
1699 *
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01001700 * If "flags" has DOCMD_VERBOSE, the command will be included in the error
1701 * message.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001702 *
1703 * 1. skip comment lines and leading space
1704 * 2. handle command modifiers
Bram Moolenaar1c40a662014-11-27 16:38:11 +01001705 * 3. find the command
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001706 * 4. parse range
Bram Moolenaar1c40a662014-11-27 16:38:11 +01001707 * 5. Parse the command.
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001708 * 6. parse arguments
1709 * 7. switch on command name
Bram Moolenaar071d4272004-06-13 20:20:40 +00001710 *
Bram Moolenaar89d40322006-08-29 15:30:07 +00001711 * Note: "fgetline" can be NULL.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001712 *
1713 * This function may be called recursively!
1714 */
1715#if (_MSC_VER == 1200)
1716/*
Bram Moolenaared203462004-06-16 11:19:22 +00001717 * Avoid optimisation bug in VC++ version 6.0
Bram Moolenaar071d4272004-06-13 20:20:40 +00001718 */
Bram Moolenaar281bdce2005-01-25 21:53:18 +00001719 #pragma optimize( "g", off )
Bram Moolenaar071d4272004-06-13 20:20:40 +00001720#endif
1721 static char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001722do_one_cmd(
Bram Moolenaarddef1292019-12-16 17:10:33 +01001723 char_u **cmdlinep,
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01001724 int flags,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001725#ifdef FEAT_EVAL
Bram Moolenaarddef1292019-12-16 17:10:33 +01001726 cstack_T *cstack,
Bram Moolenaar071d4272004-06-13 20:20:40 +00001727#endif
Bram Moolenaar20b23c62020-08-20 15:25:00 +02001728 char_u *(*fgetline)(int, void *, int, getline_opt_T),
Bram Moolenaarddef1292019-12-16 17:10:33 +01001729 void *cookie) // argument for fgetline()
Bram Moolenaar071d4272004-06-13 20:20:40 +00001730{
Bram Moolenaarddef1292019-12-16 17:10:33 +01001731 char_u *p;
1732 linenr_T lnum;
1733 long n;
1734 char *errormsg = NULL; // error message
1735 char_u *after_modifier = NULL;
1736 exarg_T ea; // Ex command arguments
Bram Moolenaarddef1292019-12-16 17:10:33 +01001737 cmdmod_T save_cmdmod;
1738 int save_reg_executing = reg_executing;
1739 int ni; // set when Not Implemented
1740 char_u *cmd;
Bram Moolenaar6e36b1c2020-07-17 20:47:51 +02001741 int starts_with_colon = FALSE;
Bram Moolenaar83f37b92020-02-23 14:35:01 +01001742#ifdef FEAT_EVAL
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02001743 int may_have_range;
Bram Moolenaar39f3b142021-02-14 12:57:36 +01001744 int vim9script;
Bram Moolenaarb4bcea42020-10-28 13:53:50 +01001745 int did_set_expr_line = FALSE;
Bram Moolenaar83f37b92020-02-23 14:35:01 +01001746#endif
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01001747 int sourcing = flags & DOCMD_VERBOSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001748
Bram Moolenaara80faa82020-04-12 19:37:17 +02001749 CLEAR_FIELD(ea);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001750 ea.line1 = 1;
1751 ea.line2 = 1;
1752#ifdef FEAT_EVAL
1753 ++ex_nesting_level;
1754#endif
1755
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001756 // When the last file has not been edited :q has to be typed twice.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001757 if (quitmore
1758#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001759 // avoid that a function call in 'statusline' does this
Bram Moolenaar89d40322006-08-29 15:30:07 +00001760 && !getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaarb2c5a5a2013-02-14 22:11:39 +01001761#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001762 // avoid that an autocommand, e.g. QuitPre, does this
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01001763 && !getline_equal(fgetline, cookie, getnextac))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001764 --quitmore;
1765
1766 /*
1767 * Reset browse, confirm, etc.. They are restored when returning, for
1768 * recursive calls.
1769 */
1770 save_cmdmod = cmdmod;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001771
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001772 // "#!anything" is handled like a comment.
Bram Moolenaarcbb37ad2006-08-16 15:04:21 +00001773 if ((*cmdlinep)[0] == '#' && (*cmdlinep)[1] == '!')
1774 goto doend;
1775
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02001776/*
1777 * 1. Skip comment lines and leading white space and colons.
1778 * 2. Handle command modifiers.
1779 */
1780 // The "ea" structure holds the arguments that can be used.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001781 ea.cmd = *cmdlinep;
Bram Moolenaareffed932018-08-14 13:38:17 +02001782 ea.cmdlinep = cmdlinep;
1783 ea.getline = fgetline;
1784 ea.cookie = cookie;
1785#ifdef FEAT_EVAL
1786 ea.cstack = cstack;
Bram Moolenaar83f37b92020-02-23 14:35:01 +01001787 starts_with_colon = *skipwhite(ea.cmd) == ':';
Bram Moolenaar071d4272004-06-13 20:20:40 +00001788#endif
Bram Moolenaare1004402020-10-24 20:49:43 +02001789 if (parse_command_modifiers(&ea, &errormsg, &cmdmod, FALSE) == FAIL)
Bram Moolenaareffed932018-08-14 13:38:17 +02001790 goto doend;
Bram Moolenaar5661ed62020-10-24 17:19:16 +02001791 apply_cmdmod(&cmdmod);
Bram Moolenaar2379f872021-02-14 14:07:34 +01001792#ifdef FEAT_EVAL
Bram Moolenaar39f3b142021-02-14 12:57:36 +01001793 vim9script = in_vim9script();
Bram Moolenaar2379f872021-02-14 14:07:34 +01001794#endif
Bram Moolenaar7b668e82016-08-23 23:51:21 +02001795 after_modifier = ea.cmd;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001796
1797#ifdef FEAT_EVAL
1798 ea.skip = did_emsg || got_int || did_throw || (cstack->cs_idx >= 0
1799 && !(cstack->cs_flags[cstack->cs_idx] & CSF_ACTIVE));
1800#else
1801 ea.skip = (if_level > 0);
1802#endif
1803
Bram Moolenaar071d4272004-06-13 20:20:40 +00001804/*
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001805 * 3. Skip over the range to find the command. Let "p" point to after it.
1806 *
1807 * We need the command to know what kind of range it uses.
1808 */
1809 cmd = ea.cmd;
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001810#ifdef FEAT_EVAL
Bram Moolenaare88c8e82020-11-01 17:03:37 +01001811 // In Vim9 script a colon is required before the range. This may also be
1812 // after command modifiers.
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01001813 if (vim9script && (flags & DOCMD_RANGEOK) == 0)
Bram Moolenaare88c8e82020-11-01 17:03:37 +01001814 {
1815 may_have_range = FALSE;
1816 for (p = ea.cmd; p >= *cmdlinep; --p)
1817 {
1818 if (*p == ':')
1819 may_have_range = TRUE;
1820 if (p < ea.cmd && !VIM_ISWHITE(*p))
1821 break;
1822 }
1823 }
1824 else
1825 may_have_range = TRUE;
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02001826 if (may_have_range)
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001827#endif
Bram Moolenaar3bd8de42020-09-14 16:37:34 +02001828 ea.cmd = skip_range(ea.cmd, TRUE, NULL);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001829
1830#ifdef FEAT_EVAL
Bram Moolenaare88c8e82020-11-01 17:03:37 +01001831 if (vim9script && !may_have_range)
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001832 {
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02001833 if (ea.cmd == cmd + 1 && *cmd == '$')
1834 // should be "$VAR = val"
1835 --ea.cmd;
Bram Moolenaar2e2d7582021-03-03 21:22:41 +01001836 p = find_ex_command(&ea, NULL, lookup_scriptitem, NULL);
Bram Moolenaar36113e42020-11-02 21:08:47 +01001837 if (ea.cmdidx == CMD_SIZE)
1838 {
1839 char_u *ar = skip_range(ea.cmd, TRUE, NULL);
1840
1841 // If a ':' before the range is missing, give a clearer error
1842 // message.
1843 if (ar > ea.cmd)
1844 {
Bram Moolenaar6e2c2c52020-12-25 19:25:45 +01001845 semsg(_(e_colon_required_before_range_str), ea.cmd);
Bram Moolenaar36113e42020-11-02 21:08:47 +01001846 goto doend;
1847 }
1848 }
Bram Moolenaardf069ee2020-06-22 23:02:51 +02001849 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01001850 else
1851#endif
1852 p = find_ex_command(&ea, NULL, NULL, NULL);
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001853
Bram Moolenaar7feb35e2018-08-21 17:49:54 +02001854#ifdef FEAT_EVAL
1855# ifdef FEAT_PROFILE
1856 // Count this line for profiling if skip is TRUE.
1857 if (do_profiling == PROF_YES
1858 && (!ea.skip || cstack->cs_idx == 0 || (cstack->cs_idx > 0
1859 && (cstack->cs_flags[cstack->cs_idx - 1] & CSF_ACTIVE))))
1860 {
1861 int skip = did_emsg || got_int || did_throw;
1862
1863 if (ea.cmdidx == CMD_catch)
1864 skip = !skip && !(cstack->cs_idx >= 0
1865 && (cstack->cs_flags[cstack->cs_idx] & CSF_THROWN)
1866 && !(cstack->cs_flags[cstack->cs_idx] & CSF_CAUGHT));
1867 else if (ea.cmdidx == CMD_else || ea.cmdidx == CMD_elseif)
1868 skip = skip || !(cstack->cs_idx >= 0
1869 && !(cstack->cs_flags[cstack->cs_idx]
1870 & (CSF_ACTIVE | CSF_TRUE)));
1871 else if (ea.cmdidx == CMD_finally)
1872 skip = FALSE;
1873 else if (ea.cmdidx != CMD_endif
1874 && ea.cmdidx != CMD_endfor
1875 && ea.cmdidx != CMD_endtry
1876 && ea.cmdidx != CMD_endwhile)
1877 skip = ea.skip;
1878
1879 if (!skip)
1880 {
1881 if (getline_equal(fgetline, cookie, get_func_line))
1882 func_line_exec(getline_cookie(fgetline, cookie));
1883 else if (getline_equal(fgetline, cookie, getsourceline))
1884 script_line_exec();
1885 }
1886 }
1887# endif
1888
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001889 // May go to debug mode. If this happens and the ">quit" debug command is
1890 // used, throw an interrupt exception and skip the next command.
Bram Moolenaar7feb35e2018-08-21 17:49:54 +02001891 dbg_check_breakpoint(&ea);
1892 if (!ea.skip && got_int)
1893 {
1894 ea.skip = TRUE;
1895 (void)do_intthrow(cstack);
1896 }
1897#endif
1898
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001899/*
1900 * 4. parse a range specifier of the form: addr [,addr] [;addr] ..
Bram Moolenaar071d4272004-06-13 20:20:40 +00001901 *
1902 * where 'addr' is:
1903 *
1904 * % (entire file)
1905 * $ [+-NUM]
1906 * 'x [+-NUM] (where x denotes a currently defined mark)
1907 * . [+-NUM]
1908 * [+-NUM]..
1909 * NUM
1910 *
1911 * The ea.cmd pointer is updated to point to the first character following the
1912 * range spec. If an initial address is found, but no second, the upper bound
1913 * is equal to the lower.
1914 */
1915
Bram Moolenaar25190db2019-05-04 15:05:28 +02001916 // ea.addr_type for user commands is set by find_ucmd
Bram Moolenaar84c8e5a2015-01-14 15:47:36 +01001917 if (!IS_USER_CMDIDX(ea.cmdidx))
1918 {
1919 if (ea.cmdidx != CMD_SIZE)
1920 ea.addr_type = cmdnames[(int)ea.cmdidx].cmd_addr_type;
1921 else
1922 ea.addr_type = ADDR_LINES;
1923
Bram Moolenaar25190db2019-05-04 15:05:28 +02001924 // :wincmd range depends on the argument.
Bram Moolenaar164f3262015-01-14 21:22:01 +01001925 if (ea.cmdidx == CMD_wincmd && p != NULL)
1926 get_wincmd_addr_type(skipwhite(p), &ea);
Bram Moolenaar25190db2019-05-04 15:05:28 +02001927#ifdef FEAT_QUICKFIX
1928 // :.cc in quickfix window uses line number
1929 if ((ea.cmdidx == CMD_cc || ea.cmdidx == CMD_ll) && bt_quickfix(curbuf))
1930 ea.addr_type = ADDR_OTHER;
1931#endif
Bram Moolenaar84c8e5a2015-01-14 15:47:36 +01001932 }
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001933
Bram Moolenaar84c8e5a2015-01-14 15:47:36 +01001934 ea.cmd = cmd;
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001935#ifdef FEAT_EVAL
Bram Moolenaarc2af0af2020-08-23 21:06:02 +02001936 if (!may_have_range)
1937 ea.line1 = ea.line2 = default_address(&ea);
1938 else
Bram Moolenaar3d48e252020-07-15 14:15:52 +02001939#endif
1940 if (parse_cmd_address(&ea, &errormsg, FALSE) == FAIL)
1941 goto doend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001942
Bram Moolenaar071d4272004-06-13 20:20:40 +00001943/*
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01001944 * 5. Parse the command.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001945 */
1946
1947 /*
1948 * Skip ':' and any white space
1949 */
1950 ea.cmd = skipwhite(ea.cmd);
1951 while (*ea.cmd == ':')
1952 ea.cmd = skipwhite(ea.cmd + 1);
1953
1954 /*
1955 * If we got a line, but no command, then go to the line.
1956 * If we find a '|' or '\n' we set ea.nextcmd.
1957 */
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02001958 if (*ea.cmd == NUL || comment_start(ea.cmd, starts_with_colon)
1959 || (ea.nextcmd = check_nextcmd(ea.cmd)) != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001960 {
1961 /*
1962 * strange vi behaviour:
1963 * ":3" jumps to line 3
Bram Moolenaarb8554302021-02-15 21:30:30 +01001964 * ":3|..." prints line 3 (not in Vim9 script)
1965 * ":|" prints current line (not in Vim9 script)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001966 */
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001967 if (ea.skip) // skip this if inside :if
Bram Moolenaar071d4272004-06-13 20:20:40 +00001968 goto doend;
Bram Moolenaarb8554302021-02-15 21:30:30 +01001969 if ((*ea.cmd == '|' || (exmode_active && ea.line1 != ea.line2))
1970#ifdef FEAT_EVAL
1971 && !vim9script
1972#endif
1973 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00001974 {
1975 ea.cmdidx = CMD_print;
Bram Moolenaar8071cb22019-07-12 17:58:01 +02001976 ea.argt = EX_RANGE+EX_COUNT+EX_TRLBAR;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001977 if ((errormsg = invalid_range(&ea)) == NULL)
1978 {
1979 correct_range(&ea);
1980 ex_print(&ea);
1981 }
1982 }
1983 else if (ea.addr_count != 0)
1984 {
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00001985 if (ea.line2 > curbuf->b_ml.ml_line_count)
1986 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001987 // With '-' in 'cpoptions' a line number past the file is an
1988 // error, otherwise put it at the end of the file.
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00001989 if (vim_strchr(p_cpo, CPO_MINUS) != NULL)
1990 ea.line2 = -1;
1991 else
1992 ea.line2 = curbuf->b_ml.ml_line_count;
1993 }
1994
1995 if (ea.line2 < 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001996 errormsg = _(e_invrange);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001997 else
1998 {
1999 if (ea.line2 == 0)
2000 curwin->w_cursor.lnum = 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002001 else
2002 curwin->w_cursor.lnum = ea.line2;
2003 beginline(BL_SOL | BL_FIX);
2004 }
2005 }
2006 goto doend;
2007 }
2008
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002009 // If this looks like an undefined user command and there are CmdUndefined
2010 // autocommands defined, trigger the matching autocommands.
Bram Moolenaard5005162014-08-22 23:05:54 +02002011 if (p != NULL && ea.cmdidx == CMD_SIZE && !ea.skip
2012 && ASCII_ISUPPER(*ea.cmd)
2013 && has_cmdundefined())
2014 {
Bram Moolenaard5005162014-08-22 23:05:54 +02002015 int ret;
2016
Bram Moolenaar5a31b462014-08-23 14:16:20 +02002017 p = ea.cmd;
Bram Moolenaard5005162014-08-22 23:05:54 +02002018 while (ASCII_ISALNUM(*p))
2019 ++p;
Bram Moolenaar158ea172020-06-18 17:28:39 +02002020 p = vim_strnsave(ea.cmd, p - ea.cmd);
Bram Moolenaard5005162014-08-22 23:05:54 +02002021 ret = apply_autocmds(EVENT_CMDUNDEFINED, p, p, TRUE, NULL);
2022 vim_free(p);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002023 // If the autocommands did something and didn't cause an error, try
2024 // finding the command again.
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01002025 p = (ret
2026#ifdef FEAT_EVAL
2027 && !aborting()
Bram Moolenaard5005162014-08-22 23:05:54 +02002028#endif
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002029 ) ? find_ex_command(&ea, NULL, NULL, NULL) : ea.cmd;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01002030 }
Bram Moolenaard5005162014-08-22 23:05:54 +02002031
Bram Moolenaar071d4272004-06-13 20:20:40 +00002032 if (p == NULL)
2033 {
2034 if (!ea.skip)
Bram Moolenaard1510ee2021-01-04 16:15:58 +01002035 errormsg = _(e_ambiguous_use_of_user_defined_command);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002036 goto doend;
2037 }
Bram Moolenaarac9fb182019-04-27 13:04:13 +02002038 // Check for wrong commands.
Bram Moolenaar6f9a4762017-06-22 20:39:17 +02002039 if (*p == '!' && ea.cmd[1] == 0151 && ea.cmd[0] == 78
2040 && !IS_USER_CMDIDX(ea.cmdidx))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002041 {
2042 errormsg = uc_fun_cmd();
2043 goto doend;
2044 }
Bram Moolenaarac9fb182019-04-27 13:04:13 +02002045
Bram Moolenaar071d4272004-06-13 20:20:40 +00002046 if (ea.cmdidx == CMD_SIZE)
2047 {
2048 if (!ea.skip)
2049 {
2050 STRCPY(IObuff, _("E492: Not an editor command"));
2051 if (!sourcing)
Bram Moolenaar7b668e82016-08-23 23:51:21 +02002052 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002053 // If the modifier was parsed OK the error must be in the
2054 // following command
Bram Moolenaar7b668e82016-08-23 23:51:21 +02002055 if (after_modifier != NULL)
2056 append_command(after_modifier);
2057 else
2058 append_command(*cmdlinep);
2059 }
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002060 errormsg = (char *)IObuff;
Bram Moolenaar00b8ae02012-08-23 18:43:10 +02002061 did_emsg_syntax = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002062 }
2063 goto doend;
2064 }
2065
Bram Moolenaar958636c2014-10-21 20:01:58 +02002066 ni = (!IS_USER_CMDIDX(ea.cmdidx)
2067 && (cmdnames[ea.cmdidx].cmd_func == ex_ni
Bram Moolenaar7bb75552007-07-16 18:39:49 +00002068#ifdef HAVE_EX_SCRIPT_NI
2069 || cmdnames[ea.cmdidx].cmd_func == ex_script_ni
2070#endif
2071 ));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002072
2073#ifndef FEAT_EVAL
2074 /*
2075 * When the expression evaluation is disabled, recognize the ":if" and
2076 * ":endif" commands and ignore everything in between it.
2077 */
2078 if (ea.cmdidx == CMD_if)
2079 ++if_level;
2080 if (if_level)
2081 {
2082 if (ea.cmdidx == CMD_endif)
2083 --if_level;
2084 goto doend;
2085 }
2086
2087#endif
2088
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002089 // forced commands
Bram Moolenaar196b3b02008-06-20 16:51:41 +00002090 if (*p == '!' && ea.cmdidx != CMD_substitute
2091 && ea.cmdidx != CMD_smagic && ea.cmdidx != CMD_snomagic)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002092 {
2093 ++p;
2094 ea.forceit = TRUE;
2095 }
2096 else
2097 ea.forceit = FALSE;
2098
2099/*
Bram Moolenaarb7316892019-05-01 18:08:42 +02002100 * 6. Parse arguments. Then check for errors.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002101 */
Bram Moolenaar958636c2014-10-21 20:01:58 +02002102 if (!IS_USER_CMDIDX(ea.cmdidx))
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00002103 ea.argt = (long)cmdnames[(int)ea.cmdidx].cmd_argt;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002104
2105 if (!ea.skip)
2106 {
2107#ifdef HAVE_SANDBOX
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002108 if (sandbox != 0 && !(ea.argt & EX_SBOXOK))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002109 {
Bram Moolenaar8c62a082019-02-08 14:34:10 +01002110 // Command not allowed in sandbox.
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002111 errormsg = _(e_sandbox);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002112 goto doend;
2113 }
2114#endif
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002115 if (restricted != 0 && (ea.argt & EX_RESTRICT))
Bram Moolenaar8c62a082019-02-08 14:34:10 +01002116 {
2117 errormsg = _("E981: Command not allowed in rvim");
2118 goto doend;
2119 }
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002120 if (!curbuf->b_p_ma && (ea.argt & EX_MODIFY))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002121 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002122 // Command not allowed in non-'modifiable' buffer
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002123 errormsg = _(e_modifiable);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002124 goto doend;
2125 }
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00002126
Bram Moolenaar37394ff2020-07-25 19:38:18 +02002127 if (!IS_USER_CMDIDX(ea.cmdidx))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002128 {
Bram Moolenaar37394ff2020-07-25 19:38:18 +02002129#ifdef FEAT_CMDWIN
2130 if (cmdwin_type != 0 && !(ea.argt & EX_CMDWIN))
2131 {
2132 // Command not allowed in the command line window
2133 errormsg = _(e_cmdwin);
2134 goto doend;
2135 }
2136#endif
2137 if (text_locked() && !(ea.argt & EX_LOCK_OK))
2138 {
2139 // Command not allowed when text is locked
2140 errormsg = _(get_text_locked_msg());
2141 goto doend;
2142 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002143 }
Bram Moolenaar379fb762018-08-30 15:58:28 +02002144
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002145 // Disallow editing another buffer when "curbuf_lock" is set.
2146 // Do allow ":checktime" (it is postponed).
2147 // Do allow ":edit" (check for an argument later).
2148 // Do allow ":file" with no arguments (check for an argument later).
Bram Moolenaar8e1986e2020-08-06 22:11:06 +02002149 if (!(ea.argt & (EX_CMDWIN | EX_LOCK_OK))
Bram Moolenaar5555acc2006-04-07 21:33:12 +00002150 && ea.cmdidx != CMD_checktime
Bram Moolenaar379fb762018-08-30 15:58:28 +02002151 && ea.cmdidx != CMD_edit
2152 && ea.cmdidx != CMD_file
Bram Moolenaar958636c2014-10-21 20:01:58 +02002153 && !IS_USER_CMDIDX(ea.cmdidx)
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002154 && curbuf_locked())
2155 goto doend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002156
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002157 if (!ni && !(ea.argt & EX_RANGE) && ea.addr_count > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002158 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002159 // no range allowed
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002160 errormsg = _(e_norange);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002161 goto doend;
2162 }
2163 }
2164
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002165 if (!ni && !(ea.argt & EX_BANG) && ea.forceit) // no <!> allowed
Bram Moolenaar071d4272004-06-13 20:20:40 +00002166 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002167 errormsg = _(e_nobang);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002168 goto doend;
2169 }
2170
2171 /*
2172 * Don't complain about the range if it is not used
2173 * (could happen if line_count is accidentally set to 0).
2174 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002175 if (!ea.skip && !ni && (ea.argt & EX_RANGE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002176 {
2177 /*
2178 * If the range is backwards, ask for confirmation and, if given, swap
2179 * ea.line1 & ea.line2 so it's forwards again.
2180 * When global command is busy, don't ask, will fail below.
2181 */
2182 if (!global_busy && ea.line1 > ea.line2)
2183 {
Bram Moolenaara5792f52005-11-23 21:25:05 +00002184 if (msg_silent == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002185 {
Bram Moolenaara5792f52005-11-23 21:25:05 +00002186 if (sourcing || exmode_active)
2187 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002188 errormsg = _("E493: Backwards range given");
Bram Moolenaara5792f52005-11-23 21:25:05 +00002189 goto doend;
2190 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002191 if (ask_yesno((char_u *)
2192 _("Backwards range given, OK to swap"), FALSE) != 'y')
Bram Moolenaara5792f52005-11-23 21:25:05 +00002193 goto doend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002194 }
2195 lnum = ea.line1;
2196 ea.line1 = ea.line2;
2197 ea.line2 = lnum;
2198 }
2199 if ((errormsg = invalid_range(&ea)) != NULL)
2200 goto doend;
2201 }
2202
Bram Moolenaarb7316892019-05-01 18:08:42 +02002203 if ((ea.addr_type == ADDR_OTHER) && ea.addr_count == 0)
2204 // default is 1, not cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00002205 ea.line2 = 1;
2206
2207 correct_range(&ea);
2208
2209#ifdef FEAT_FOLDING
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002210 if (((ea.argt & EX_WHOLEFOLD) || ea.addr_count >= 2) && !global_busy
Bram Moolenaara3306952016-01-02 21:41:06 +01002211 && ea.addr_type == ADDR_LINES)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002212 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002213 // Put the first line at the start of a closed fold, put the last line
2214 // at the end of a closed fold.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002215 (void)hasFolding(ea.line1, &ea.line1, NULL);
2216 (void)hasFolding(ea.line2, NULL, &ea.line2);
2217 }
2218#endif
2219
2220#ifdef FEAT_QUICKFIX
2221 /*
Bram Moolenaar86b68352004-12-27 21:59:20 +00002222 * For the ":make" and ":grep" commands we insert the 'makeprg'/'grepprg'
Bram Moolenaar071d4272004-06-13 20:20:40 +00002223 * option here, so things like % get expanded.
2224 */
Bram Moolenaard857f0e2005-06-21 22:37:39 +00002225 p = replace_makeprg(&ea, p, cmdlinep);
2226 if (p == NULL)
2227 goto doend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002228#endif
2229
2230 /*
2231 * Skip to start of argument.
2232 * Don't do this for the ":!" command, because ":!! -l" needs the space.
2233 */
2234 if (ea.cmdidx == CMD_bang)
2235 ea.arg = p;
2236 else
2237 ea.arg = skipwhite(p);
2238
Bram Moolenaar379fb762018-08-30 15:58:28 +02002239 // ":file" cannot be run with an argument when "curbuf_lock" is set
2240 if (ea.cmdidx == CMD_file && *ea.arg != NUL && curbuf_locked())
2241 goto doend;
2242
Bram Moolenaar071d4272004-06-13 20:20:40 +00002243 /*
2244 * Check for "++opt=val" argument.
2245 * Must be first, allow ":w ++enc=utf8 !cmd"
2246 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002247 if (ea.argt & EX_ARGOPT)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002248 while (ea.arg[0] == '+' && ea.arg[1] == '+')
2249 if (getargopt(&ea) == FAIL && !ni)
2250 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002251 errormsg = _(e_invarg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002252 goto doend;
2253 }
2254
2255 if (ea.cmdidx == CMD_write || ea.cmdidx == CMD_update)
2256 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002257 if (*ea.arg == '>') // append
Bram Moolenaar071d4272004-06-13 20:20:40 +00002258 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002259 if (*++ea.arg != '>') // typed wrong
Bram Moolenaar071d4272004-06-13 20:20:40 +00002260 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002261 errormsg = _("E494: Use w or w>>");
Bram Moolenaar071d4272004-06-13 20:20:40 +00002262 goto doend;
2263 }
2264 ea.arg = skipwhite(ea.arg + 1);
2265 ea.append = TRUE;
2266 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002267 else if (*ea.arg == '!' && ea.cmdidx == CMD_write) // :w !filter
Bram Moolenaar071d4272004-06-13 20:20:40 +00002268 {
2269 ++ea.arg;
2270 ea.usefilter = TRUE;
2271 }
2272 }
2273
2274 if (ea.cmdidx == CMD_read)
2275 {
2276 if (ea.forceit)
2277 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002278 ea.usefilter = TRUE; // :r! filter if ea.forceit
Bram Moolenaar071d4272004-06-13 20:20:40 +00002279 ea.forceit = FALSE;
2280 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002281 else if (*ea.arg == '!') // :r !filter
Bram Moolenaar071d4272004-06-13 20:20:40 +00002282 {
2283 ++ea.arg;
2284 ea.usefilter = TRUE;
2285 }
2286 }
2287
2288 if (ea.cmdidx == CMD_lshift || ea.cmdidx == CMD_rshift)
2289 {
2290 ea.amount = 1;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002291 while (*ea.arg == *ea.cmd) // count number of '>' or '<'
Bram Moolenaar071d4272004-06-13 20:20:40 +00002292 {
2293 ++ea.arg;
2294 ++ea.amount;
2295 }
2296 ea.arg = skipwhite(ea.arg);
2297 }
2298
2299 /*
2300 * Check for "+command" argument, before checking for next command.
2301 * Don't do this for ":read !cmd" and ":write !cmd".
2302 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002303 if ((ea.argt & EX_CMDARG) && !ea.usefilter)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002304 ea.do_ecmd_cmd = getargcmd(&ea.arg);
2305
2306 /*
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002307 * Check for '|' to separate commands and '"' or '#' to start comments.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002308 * Don't do this for ":read !cmd" and ":write !cmd".
2309 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002310 if ((ea.argt & EX_TRLBAR) && !ea.usefilter)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002311 separate_nextcmd(&ea);
2312
2313 /*
2314 * Check for <newline> to end a shell command.
Bram Moolenaardf177f62005-02-22 08:39:57 +00002315 * Also do this for ":read !cmd", ":write !cmd" and ":global".
2316 * Any others?
Bram Moolenaar071d4272004-06-13 20:20:40 +00002317 */
Bram Moolenaardf177f62005-02-22 08:39:57 +00002318 else if (ea.cmdidx == CMD_bang
Bram Moolenaar67883b42017-07-27 22:57:00 +02002319 || ea.cmdidx == CMD_terminal
Bram Moolenaardf177f62005-02-22 08:39:57 +00002320 || ea.cmdidx == CMD_global
2321 || ea.cmdidx == CMD_vglobal
2322 || ea.usefilter)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002323 {
2324 for (p = ea.arg; *p; ++p)
2325 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002326 // Remove one backslash before a newline, so that it's possible to
2327 // pass a newline to the shell and also a newline that is preceded
2328 // with a backslash. This makes it impossible to end a shell
2329 // command in a backslash, but that doesn't appear useful.
2330 // Halving the number of backslashes is incompatible with previous
2331 // versions.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002332 if (*p == '\\' && p[1] == '\n')
Bram Moolenaara7241f52008-06-24 20:39:31 +00002333 STRMOVE(p, p + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002334 else if (*p == '\n')
2335 {
2336 ea.nextcmd = p + 1;
2337 *p = NUL;
2338 break;
2339 }
2340 }
2341 }
2342
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002343 if ((ea.argt & EX_DFLALL) && ea.addr_count == 0)
Bram Moolenaarc2af0af2020-08-23 21:06:02 +02002344 address_default_all(&ea);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002345
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002346 // accept numbered register only when no count allowed (:put)
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002347 if ( (ea.argt & EX_REGSTR)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002348 && *ea.arg != NUL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002349 // Do not allow register = for user commands
Bram Moolenaar958636c2014-10-21 20:01:58 +02002350 && (!IS_USER_CMDIDX(ea.cmdidx) || *ea.arg != '=')
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002351 && !((ea.argt & EX_COUNT) && VIM_ISDIGIT(*ea.arg)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002352 {
Bram Moolenaar85de2062011-05-05 14:26:41 +02002353#ifndef FEAT_CLIPBOARD
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002354 // check these explicitly for a more specific error message
Bram Moolenaar85de2062011-05-05 14:26:41 +02002355 if (*ea.arg == '*' || *ea.arg == '+')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002356 {
Bram Moolenaar99b12722019-01-14 20:16:40 +01002357 errormsg = _(e_invalidreg);
Bram Moolenaar85de2062011-05-05 14:26:41 +02002358 goto doend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002359 }
2360#endif
Bram Moolenaar958636c2014-10-21 20:01:58 +02002361 if (valid_yank_reg(*ea.arg, (ea.cmdidx != CMD_put
2362 && !IS_USER_CMDIDX(ea.cmdidx))))
Bram Moolenaar85de2062011-05-05 14:26:41 +02002363 {
2364 ea.regname = *ea.arg++;
2365#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002366 // for '=' register: accept the rest of the line as an expression
Bram Moolenaar85de2062011-05-05 14:26:41 +02002367 if (ea.arg[-1] == '=' && ea.arg[0] != NUL)
2368 {
Bram Moolenaarb4bcea42020-10-28 13:53:50 +01002369 set_expr_line(vim_strsave(ea.arg), &ea);
Bram Moolenaar85de2062011-05-05 14:26:41 +02002370 ea.arg += STRLEN(ea.arg);
Bram Moolenaarb4bcea42020-10-28 13:53:50 +01002371 did_set_expr_line = TRUE;
Bram Moolenaar85de2062011-05-05 14:26:41 +02002372 }
2373#endif
2374 ea.arg = skipwhite(ea.arg);
2375 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002376 }
2377
2378 /*
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002379 * Check for a count. When accepting a EX_BUFNAME, don't use "123foo" as a
Bram Moolenaar071d4272004-06-13 20:20:40 +00002380 * count, it's a buffer name.
2381 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002382 if ((ea.argt & EX_COUNT) && VIM_ISDIGIT(*ea.arg)
2383 && (!(ea.argt & EX_BUFNAME) || *(p = skipdigits(ea.arg)) == NUL
Bram Moolenaar1c465442017-03-12 20:10:05 +01002384 || VIM_ISWHITE(*p)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002385 {
2386 n = getdigits(&ea.arg);
2387 ea.arg = skipwhite(ea.arg);
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002388 if (n <= 0 && !ni && (ea.argt & EX_ZEROR) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002389 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002390 errormsg = _(e_zerocount);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002391 goto doend;
2392 }
Bram Moolenaarb7316892019-05-01 18:08:42 +02002393 if (ea.addr_type != ADDR_LINES) // e.g. :buffer 2, :sleep 3
Bram Moolenaar071d4272004-06-13 20:20:40 +00002394 {
2395 ea.line2 = n;
2396 if (ea.addr_count == 0)
2397 ea.addr_count = 1;
2398 }
2399 else
2400 {
2401 ea.line1 = ea.line2;
2402 ea.line2 += n - 1;
2403 ++ea.addr_count;
2404 /*
2405 * Be vi compatible: no error message for out of range.
2406 */
Bram Moolenaarb7316892019-05-01 18:08:42 +02002407 if (ea.line2 > curbuf->b_ml.ml_line_count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002408 ea.line2 = curbuf->b_ml.ml_line_count;
2409 }
2410 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00002411
2412 /*
2413 * Check for flags: 'l', 'p' and '#'.
2414 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002415 if (ea.argt & EX_FLAGS)
Bram Moolenaardf177f62005-02-22 08:39:57 +00002416 get_flags(&ea);
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002417 if (!ni && !(ea.argt & EX_EXTRA) && *ea.arg != NUL
2418 && *ea.arg != '"' && (*ea.arg != '|' || (ea.argt & EX_TRLBAR) == 0))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002419 {
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002420 // no arguments allowed but there is something
Bram Moolenaar2d06bfd2020-07-23 17:16:18 +02002421 errormsg = ex_errmsg(e_trailing_arg, ea.arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002422 goto doend;
2423 }
2424
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002425 if (!ni && (ea.argt & EX_NEEDARG) && *ea.arg == NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002426 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002427 errormsg = _(e_argreq);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002428 goto doend;
2429 }
2430
2431#ifdef FEAT_EVAL
2432 /*
2433 * Skip the command when it's not going to be executed.
2434 * The commands like :if, :endif, etc. always need to be executed.
2435 * Also make an exception for commands that handle a trailing command
2436 * themselves.
2437 */
2438 if (ea.skip)
2439 {
2440 switch (ea.cmdidx)
2441 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002442 // commands that need evaluation
Bram Moolenaar071d4272004-06-13 20:20:40 +00002443 case CMD_while:
2444 case CMD_endwhile:
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00002445 case CMD_for:
2446 case CMD_endfor:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002447 case CMD_if:
2448 case CMD_elseif:
2449 case CMD_else:
2450 case CMD_endif:
2451 case CMD_try:
2452 case CMD_catch:
2453 case CMD_finally:
2454 case CMD_endtry:
2455 case CMD_function:
Bram Moolenaarab55c682020-03-01 19:41:43 +01002456 case CMD_def:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002457 break;
2458
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002459 // Commands that handle '|' themselves. Check: A command should
2460 // either have the EX_TRLBAR flag, appear in this list or appear in
2461 // the list at ":help :bar".
Bram Moolenaar071d4272004-06-13 20:20:40 +00002462 case CMD_aboveleft:
2463 case CMD_and:
2464 case CMD_belowright:
2465 case CMD_botright:
2466 case CMD_browse:
2467 case CMD_call:
2468 case CMD_confirm:
Bram Moolenaar8f76e6b2019-11-26 16:50:30 +01002469 case CMD_const:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002470 case CMD_delfunction:
2471 case CMD_djump:
2472 case CMD_dlist:
2473 case CMD_dsearch:
2474 case CMD_dsplit:
2475 case CMD_echo:
2476 case CMD_echoerr:
2477 case CMD_echomsg:
2478 case CMD_echon:
Bram Moolenaara76b3152020-02-16 16:20:21 +01002479 case CMD_eval:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002480 case CMD_execute:
Bram Moolenaar7b668e82016-08-23 23:51:21 +02002481 case CMD_filter:
Bram Moolenaar30fd8202020-09-26 15:09:30 +02002482 case CMD_final:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002483 case CMD_help:
2484 case CMD_hide:
2485 case CMD_ijump:
2486 case CMD_ilist:
2487 case CMD_isearch:
2488 case CMD_isplit:
Bram Moolenaard4755bb2004-09-02 19:12:26 +00002489 case CMD_keepalt:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002490 case CMD_keepjumps:
2491 case CMD_keepmarks:
Bram Moolenaara939e432013-11-09 05:30:26 +01002492 case CMD_keeppatterns:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002493 case CMD_leftabove:
2494 case CMD_let:
2495 case CMD_lockmarks:
Bram Moolenaarcc4423a2019-11-26 17:05:00 +01002496 case CMD_lockvar:
Bram Moolenaar0ba04292010-07-14 23:23:17 +02002497 case CMD_lua:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002498 case CMD_match:
Bram Moolenaar325b7a22004-07-05 15:58:32 +00002499 case CMD_mzscheme:
Bram Moolenaar5803ae62014-03-23 16:04:02 +01002500 case CMD_noautocmd:
2501 case CMD_noswapfile:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002502 case CMD_perl:
2503 case CMD_psearch:
Bram Moolenaar368373e2010-07-19 20:46:22 +02002504 case CMD_py3:
Bram Moolenaarb6590522010-07-21 16:00:43 +02002505 case CMD_python3:
Bram Moolenaar30fd8202020-09-26 15:09:30 +02002506 case CMD_python:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002507 case CMD_return:
2508 case CMD_rightbelow:
2509 case CMD_ruby:
2510 case CMD_silent:
2511 case CMD_smagic:
2512 case CMD_snomagic:
2513 case CMD_substitute:
2514 case CMD_syntax:
Bram Moolenaara226a6d2006-02-26 23:59:20 +00002515 case CMD_tab:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002516 case CMD_tcl:
2517 case CMD_throw:
2518 case CMD_tilde:
2519 case CMD_topleft:
2520 case CMD_unlet:
Bram Moolenaarcc4423a2019-11-26 17:05:00 +01002521 case CMD_unlockvar:
Bram Moolenaar30fd8202020-09-26 15:09:30 +02002522 case CMD_var:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002523 case CMD_verbose:
2524 case CMD_vertical:
Bram Moolenaar12bde492011-06-13 01:19:56 +02002525 case CMD_wincmd:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002526 break;
2527
2528 default: goto doend;
2529 }
2530 }
2531#endif
2532
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002533 if (ea.argt & EX_XFILE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002534 {
2535 if (expand_filename(&ea, cmdlinep, &errormsg) == FAIL)
2536 goto doend;
2537 }
2538
Bram Moolenaar071d4272004-06-13 20:20:40 +00002539 /*
2540 * Accept buffer name. Cannot be used at the same time with a buffer
2541 * number. Don't do this for a user command.
2542 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002543 if ((ea.argt & EX_BUFNAME) && *ea.arg != NUL && ea.addr_count == 0
Bram Moolenaar958636c2014-10-21 20:01:58 +02002544 && !IS_USER_CMDIDX(ea.cmdidx))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002545 {
2546 /*
2547 * :bdelete, :bwipeout and :bunload take several arguments, separated
2548 * by spaces: find next space (skipping over escaped characters).
2549 * The others take one argument: ignore trailing spaces.
2550 */
2551 if (ea.cmdidx == CMD_bdelete || ea.cmdidx == CMD_bwipeout
2552 || ea.cmdidx == CMD_bunload)
2553 p = skiptowhite_esc(ea.arg);
2554 else
2555 {
2556 p = ea.arg + STRLEN(ea.arg);
Bram Moolenaar1c465442017-03-12 20:10:05 +01002557 while (p > ea.arg && VIM_ISWHITE(p[-1]))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002558 --p;
2559 }
Bram Moolenaar8071cb22019-07-12 17:58:01 +02002560 ea.line2 = buflist_findpat(ea.arg, p, (ea.argt & EX_BUFUNL) != 0,
Bram Moolenaar0c279bb2013-03-19 14:25:54 +01002561 FALSE, FALSE);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002562 if (ea.line2 < 0) // failed
Bram Moolenaar071d4272004-06-13 20:20:40 +00002563 goto doend;
2564 ea.addr_count = 1;
2565 ea.arg = skipwhite(p);
2566 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002567
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002568 // The :try command saves the emsg_silent flag, reset it here when
2569 // ":silent! try" was used, it should only apply to :try itself.
Bram Moolenaar5661ed62020-10-24 17:19:16 +02002570 if (ea.cmdidx == CMD_try && cmdmod.cmod_did_esilent > 0)
Bram Moolenaar2be57332018-02-13 18:05:18 +01002571 {
Bram Moolenaar5661ed62020-10-24 17:19:16 +02002572 emsg_silent -= cmdmod.cmod_did_esilent;
Bram Moolenaar2be57332018-02-13 18:05:18 +01002573 if (emsg_silent < 0)
2574 emsg_silent = 0;
Bram Moolenaar5661ed62020-10-24 17:19:16 +02002575 cmdmod.cmod_did_esilent = 0;
Bram Moolenaar2be57332018-02-13 18:05:18 +01002576 }
2577
Bram Moolenaar071d4272004-06-13 20:20:40 +00002578/*
Bram Moolenaar2be57332018-02-13 18:05:18 +01002579 * 7. Execute the command.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002580 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002581
Bram Moolenaar958636c2014-10-21 20:01:58 +02002582 if (IS_USER_CMDIDX(ea.cmdidx))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002583 {
2584 /*
2585 * Execute a user-defined command.
2586 */
2587 do_ucmd(&ea);
2588 }
2589 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00002590 {
2591 /*
Bram Moolenaarac9fb182019-04-27 13:04:13 +02002592 * Call the function to execute the builtin command.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002593 */
2594 ea.errmsg = NULL;
2595 (cmdnames[ea.cmdidx].cmd_func)(&ea);
2596 if (ea.errmsg != NULL)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02002597 errormsg = ea.errmsg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002598 }
2599
2600#ifdef FEAT_EVAL
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002601 // Set flag that any command was executed, used by ex_vim9script().
Bram Moolenaard3f8a9e2021-02-17 21:57:03 +01002602 // Not if this was a command that wasn't executed or :endif.
Bram Moolenaar16531552020-02-08 16:00:46 +01002603 if (getline_equal(ea.getline, ea.cookie, getsourceline)
Bram Moolenaard3f8a9e2021-02-17 21:57:03 +01002604 && current_sctx.sc_sid > 0
2605 && ea.cmdidx != CMD_endif
2606 && (cstack->cs_idx < 0
2607 || (cstack->cs_flags[cstack->cs_idx] & CSF_ACTIVE)))
Bram Moolenaar2b327002020-12-26 15:39:31 +01002608 SCRIPT_ITEM(current_sctx.sc_sid)->sn_state = SN_STATE_HAD_COMMAND;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01002609
Bram Moolenaar071d4272004-06-13 20:20:40 +00002610 /*
2611 * If the command just executed called do_cmdline(), any throw or ":return"
2612 * or ":finish" encountered there must also check the cstack of the still
2613 * active do_cmdline() that called this do_one_cmd(). Rethrow an uncaught
2614 * exception, or reanimate a returned function or finished script file and
2615 * return or finish it again.
2616 */
2617 if (need_rethrow)
2618 do_throw(cstack);
2619 else if (check_cstack)
2620 {
Bram Moolenaar89d40322006-08-29 15:30:07 +00002621 if (source_finished(fgetline, cookie))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002622 do_finish(&ea, TRUE);
Bram Moolenaar89d40322006-08-29 15:30:07 +00002623 else if (getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002624 && current_func_returned())
2625 do_return(&ea, TRUE, FALSE, NULL);
2626 }
2627 need_rethrow = check_cstack = FALSE;
2628#endif
2629
2630doend:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002631 if (curwin->w_cursor.lnum == 0) // can happen with zero line number
Bram Moolenaar6de5e122017-04-20 21:55:44 +02002632 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00002633 curwin->w_cursor.lnum = 1;
Bram Moolenaar6de5e122017-04-20 21:55:44 +02002634 curwin->w_cursor.col = 0;
2635 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002636
2637 if (errormsg != NULL && *errormsg != NUL && !did_emsg)
2638 {
2639 if (sourcing)
2640 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002641 if (errormsg != (char *)IObuff)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002642 {
2643 STRCPY(IObuff, errormsg);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002644 errormsg = (char *)IObuff;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002645 }
Bram Moolenaara6f4d612011-09-21 19:10:46 +02002646 append_command(*cmdlinep);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002647 }
2648 emsg(errormsg);
2649 }
2650#ifdef FEAT_EVAL
2651 do_errthrow(cstack,
Bram Moolenaar958636c2014-10-21 20:01:58 +02002652 (ea.cmdidx != CMD_SIZE && !IS_USER_CMDIDX(ea.cmdidx))
2653 ? cmdnames[(int)ea.cmdidx].cmd_name : (char_u *)NULL);
Bram Moolenaarb4bcea42020-10-28 13:53:50 +01002654
2655 if (did_set_expr_line)
2656 set_expr_line(NULL, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002657#endif
2658
Bram Moolenaare1004402020-10-24 20:49:43 +02002659 undo_cmdmod(&cmdmod);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002660 cmdmod = save_cmdmod;
Bram Moolenaar9a2c0912019-03-30 14:26:18 +01002661 reg_executing = save_reg_executing;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002662
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002663 if (ea.nextcmd && *ea.nextcmd == NUL) // not really a next command
Bram Moolenaar071d4272004-06-13 20:20:40 +00002664 ea.nextcmd = NULL;
2665
2666#ifdef FEAT_EVAL
2667 --ex_nesting_level;
Bram Moolenaarb171fb12020-06-24 20:34:03 +02002668 vim_free(ea.cmdline_tofree);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002669#endif
2670
2671 return ea.nextcmd;
2672}
2673#if (_MSC_VER == 1200)
Bram Moolenaar281bdce2005-01-25 21:53:18 +00002674 #pragma optimize( "", on )
Bram Moolenaar071d4272004-06-13 20:20:40 +00002675#endif
2676
Bram Moolenaar8930caa2020-07-23 16:37:03 +02002677static char ex_error_buf[MSG_BUF_LEN];
2678
2679/*
2680 * Return an error message with argument included.
2681 * Uses a static buffer, only the last error will be kept.
2682 * "msg" will be translated, caller should use N_().
2683 */
2684 char *
2685ex_errmsg(char *msg, char_u *arg)
2686{
2687 vim_snprintf(ex_error_buf, MSG_BUF_LEN, _(msg), arg);
2688 return ex_error_buf;
2689}
2690
Bram Moolenaar071d4272004-06-13 20:20:40 +00002691/*
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002692 * Check for an Ex command with optional tail.
2693 * If there is a match advance "pp" to the argument and return TRUE.
2694 * If "noparen" is TRUE do not recognize the command followed by "(".
2695 */
2696 static int
2697checkforcmd_opt(
2698 char_u **pp, // start of command
2699 char *cmd, // name of command
2700 int len, // required length
2701 int noparen)
2702{
2703 int i;
2704
2705 for (i = 0; cmd[i] != NUL; ++i)
2706 if (((char_u *)cmd)[i] != (*pp)[i])
2707 break;
2708 if (i >= len && !isalpha((*pp)[i])
2709 && (*pp)[i] != '_' && (!noparen || (*pp)[i] != '('))
2710 {
2711 *pp = skipwhite(*pp + i);
2712 return TRUE;
2713 }
2714 return FALSE;
2715}
2716
2717/*
2718 * Check for an Ex command with optional tail.
2719 * If there is a match advance "pp" to the argument and return TRUE.
2720 */
2721 int
2722checkforcmd(
2723 char_u **pp, // start of command
2724 char *cmd, // name of command
2725 int len) // required length
2726{
2727 return checkforcmd_opt(pp, cmd, len, FALSE);
2728}
2729
2730/*
2731 * Check for an Ex command with optional tail, not followed by "(".
2732 * If there is a match advance "pp" to the argument and return TRUE.
2733 */
2734 static int
2735checkforcmd_noparen(
2736 char_u **pp, // start of command
2737 char *cmd, // name of command
2738 int len) // required length
2739{
2740 return checkforcmd_opt(pp, cmd, len, TRUE);
2741}
2742
2743/*
Bram Moolenaareffed932018-08-14 13:38:17 +02002744 * Parse and skip over command modifiers:
2745 * - update eap->cmd
Bram Moolenaare1004402020-10-24 20:49:43 +02002746 * - store flags in "cmod".
Bram Moolenaareffed932018-08-14 13:38:17 +02002747 * - Set ex_pressedreturn for an empty command line.
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002748 * When "skip_only" is TRUE the global variables are not changed, except for
2749 * "cmdmod".
Bram Moolenaare1004402020-10-24 20:49:43 +02002750 * When "skip_only" is FALSE then undo_cmdmod() must be called later to free
2751 * any cmod_filter_regmatch.regprog.
Bram Moolenaar5661ed62020-10-24 17:19:16 +02002752 * Call apply_cmdmod() to get the side effects of the modifiers:
2753 * - Increment "sandbox" for ":sandbox"
2754 * - set p_verbose for ":verbose"
Bram Moolenaare1004402020-10-24 20:49:43 +02002755 * - set msg_silent for ":silent"
2756 * - set 'eventignore' to "all" for ":noautocmd"
Bram Moolenaareffed932018-08-14 13:38:17 +02002757 * Return FAIL when the command is not to be executed.
2758 * May set "errormsg" to an error message.
2759 */
2760 int
Bram Moolenaare1004402020-10-24 20:49:43 +02002761parse_command_modifiers(
2762 exarg_T *eap,
2763 char **errormsg,
2764 cmdmod_T *cmod,
2765 int skip_only)
Bram Moolenaareffed932018-08-14 13:38:17 +02002766{
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002767 char_u *p;
2768 int starts_with_colon = FALSE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002769
Bram Moolenaare1004402020-10-24 20:49:43 +02002770 CLEAR_POINTER(cmod);
Bram Moolenaareffed932018-08-14 13:38:17 +02002771
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002772 // Repeat until no more command modifiers are found.
Bram Moolenaareffed932018-08-14 13:38:17 +02002773 for (;;)
2774 {
Bram Moolenaareffed932018-08-14 13:38:17 +02002775 while (*eap->cmd == ' ' || *eap->cmd == '\t' || *eap->cmd == ':')
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002776 {
2777 if (*eap->cmd == ':')
2778 starts_with_colon = TRUE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002779 ++eap->cmd;
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002780 }
Bram Moolenaareffed932018-08-14 13:38:17 +02002781
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002782 // in ex mode, an empty line works like :+
Bram Moolenaareffed932018-08-14 13:38:17 +02002783 if (*eap->cmd == NUL && exmode_active
2784 && (getline_equal(eap->getline, eap->cookie, getexmodeline)
2785 || getline_equal(eap->getline, eap->cookie, getexline))
2786 && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
2787 {
2788 eap->cmd = (char_u *)"+";
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002789 if (!skip_only)
2790 ex_pressedreturn = TRUE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002791 }
2792
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002793 // ignore comment and empty lines
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02002794 if (comment_start(eap->cmd, starts_with_colon))
Bram Moolenaareffed932018-08-14 13:38:17 +02002795 return FAIL;
2796 if (*eap->cmd == NUL)
2797 {
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002798 if (!skip_only)
2799 ex_pressedreturn = TRUE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002800 return FAIL;
2801 }
2802
Bram Moolenaar3bd8de42020-09-14 16:37:34 +02002803 p = skip_range(eap->cmd, TRUE, NULL);
Bram Moolenaar17126b12021-01-07 22:03:02 +01002804
2805 // In Vim9 script a variable can shadow a command modifier:
2806 // verbose = 123
2807 // verbose += 123
2808 // silent! verbose = func()
2809 // verbose.member = 2
2810 // verbose[expr] = 2
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002811 // But not:
2812 // verbose [a, b] = list
Bram Moolenaar17126b12021-01-07 22:03:02 +01002813 if (in_vim9script())
2814 {
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002815 char_u *s, *n;
Bram Moolenaar17126b12021-01-07 22:03:02 +01002816
2817 for (s = p; ASCII_ISALPHA(*s); ++s)
2818 ;
Bram Moolenaar9e0f8832021-01-09 12:09:22 +01002819 n = skipwhite(s);
2820 if (vim_strchr((char_u *)".=", *n) != NULL
2821 || *s == '['
2822 || (*n != NUL && n[1] == '='))
Bram Moolenaar17126b12021-01-07 22:03:02 +01002823 break;
2824 }
2825
Bram Moolenaareffed932018-08-14 13:38:17 +02002826 switch (*p)
2827 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002828 // When adding an entry, also modify cmd_exists().
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002829 case 'a': if (!checkforcmd_noparen(&eap->cmd, "aboveleft", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002830 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002831 cmod->cmod_split |= WSP_ABOVE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002832 continue;
2833
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002834 case 'b': if (checkforcmd_noparen(&eap->cmd, "belowright", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002835 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002836 cmod->cmod_split |= WSP_BELOW;
Bram Moolenaareffed932018-08-14 13:38:17 +02002837 continue;
2838 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002839 if (checkforcmd_opt(&eap->cmd, "browse", 3, TRUE))
Bram Moolenaareffed932018-08-14 13:38:17 +02002840 {
2841#ifdef FEAT_BROWSE_CMD
Bram Moolenaare1004402020-10-24 20:49:43 +02002842 cmod->cmod_flags |= CMOD_BROWSE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002843#endif
2844 continue;
2845 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002846 if (!checkforcmd_noparen(&eap->cmd, "botright", 2))
Bram Moolenaareffed932018-08-14 13:38:17 +02002847 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002848 cmod->cmod_split |= WSP_BOT;
Bram Moolenaareffed932018-08-14 13:38:17 +02002849 continue;
2850
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002851 case 'c': if (!checkforcmd_opt(&eap->cmd, "confirm", 4, TRUE))
Bram Moolenaareffed932018-08-14 13:38:17 +02002852 break;
2853#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
Bram Moolenaare1004402020-10-24 20:49:43 +02002854 cmod->cmod_flags |= CMOD_CONFIRM;
Bram Moolenaareffed932018-08-14 13:38:17 +02002855#endif
2856 continue;
2857
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002858 case 'k': if (checkforcmd_noparen(&eap->cmd, "keepmarks", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002859 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002860 cmod->cmod_flags |= CMOD_KEEPMARKS;
Bram Moolenaareffed932018-08-14 13:38:17 +02002861 continue;
2862 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002863 if (checkforcmd_noparen(&eap->cmd, "keepalt", 5))
Bram Moolenaareffed932018-08-14 13:38:17 +02002864 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002865 cmod->cmod_flags |= CMOD_KEEPALT;
Bram Moolenaareffed932018-08-14 13:38:17 +02002866 continue;
2867 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002868 if (checkforcmd_noparen(&eap->cmd, "keeppatterns", 5))
Bram Moolenaareffed932018-08-14 13:38:17 +02002869 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002870 cmod->cmod_flags |= CMOD_KEEPPATTERNS;
Bram Moolenaareffed932018-08-14 13:38:17 +02002871 continue;
2872 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002873 if (!checkforcmd_noparen(&eap->cmd, "keepjumps", 5))
Bram Moolenaareffed932018-08-14 13:38:17 +02002874 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002875 cmod->cmod_flags |= CMOD_KEEPJUMPS;
Bram Moolenaareffed932018-08-14 13:38:17 +02002876 continue;
2877
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002878 case 'f': // only accept ":filter {pat} cmd"
Bram Moolenaareffed932018-08-14 13:38:17 +02002879 {
2880 char_u *reg_pat;
2881
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002882 if (!checkforcmd_noparen(&p, "filter", 4)
Bram Moolenaareffed932018-08-14 13:38:17 +02002883 || *p == NUL || ends_excmd(*p))
2884 break;
2885 if (*p == '!')
2886 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002887 cmod->cmod_filter_force = TRUE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002888 p = skipwhite(p + 1);
2889 if (*p == NUL || ends_excmd(*p))
2890 break;
2891 }
Bram Moolenaar1e624c92020-07-11 14:08:04 +02002892#ifdef FEAT_EVAL
Bram Moolenaarb074e8b2020-07-11 13:40:45 +02002893 // Avoid that "filter(arg)" is recognized.
Bram Moolenaar4f6b6ed2020-10-29 20:24:34 +01002894 if (in_vim9script() && !VIM_ISWHITE(p[-1]))
Bram Moolenaarb074e8b2020-07-11 13:40:45 +02002895 break;
Bram Moolenaar1e624c92020-07-11 14:08:04 +02002896#endif
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002897 if (skip_only)
2898 p = skip_vimgrep_pat(p, NULL, NULL);
2899 else
2900 // NOTE: This puts a NUL after the pattern.
2901 p = skip_vimgrep_pat(p, &reg_pat, NULL);
Bram Moolenaareffed932018-08-14 13:38:17 +02002902 if (p == NULL || *p == NUL)
2903 break;
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002904 if (!skip_only)
2905 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002906 cmod->cmod_filter_regmatch.regprog =
Bram Moolenaareffed932018-08-14 13:38:17 +02002907 vim_regcomp(reg_pat, RE_MAGIC);
Bram Moolenaare1004402020-10-24 20:49:43 +02002908 if (cmod->cmod_filter_regmatch.regprog == NULL)
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02002909 break;
2910 }
Bram Moolenaareffed932018-08-14 13:38:17 +02002911 eap->cmd = p;
2912 continue;
2913 }
2914
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002915 // ":hide" and ":hide | cmd" are not modifiers
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002916 case 'h': if (p != eap->cmd || !checkforcmd_noparen(&p, "hide", 3)
Bram Moolenaareffed932018-08-14 13:38:17 +02002917 || *p == NUL || ends_excmd(*p))
2918 break;
2919 eap->cmd = p;
Bram Moolenaare1004402020-10-24 20:49:43 +02002920 cmod->cmod_flags |= CMOD_HIDE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002921 continue;
2922
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002923 case 'l': if (checkforcmd_noparen(&eap->cmd, "lockmarks", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002924 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002925 cmod->cmod_flags |= CMOD_LOCKMARKS;
Bram Moolenaareffed932018-08-14 13:38:17 +02002926 continue;
2927 }
2928
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002929 if (!checkforcmd_noparen(&eap->cmd, "leftabove", 5))
Bram Moolenaareffed932018-08-14 13:38:17 +02002930 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002931 cmod->cmod_split |= WSP_ABOVE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002932 continue;
2933
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002934 case 'n': if (checkforcmd_noparen(&eap->cmd, "noautocmd", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002935 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002936 cmod->cmod_flags |= CMOD_NOAUTOCMD;
Bram Moolenaareffed932018-08-14 13:38:17 +02002937 continue;
2938 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002939 if (!checkforcmd_noparen(&eap->cmd, "noswapfile", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002940 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002941 cmod->cmod_flags |= CMOD_NOSWAPFILE;
Bram Moolenaareffed932018-08-14 13:38:17 +02002942 continue;
2943
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002944 case 'r': if (!checkforcmd_noparen(&eap->cmd, "rightbelow", 6))
Bram Moolenaareffed932018-08-14 13:38:17 +02002945 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002946 cmod->cmod_split |= WSP_BELOW;
Bram Moolenaareffed932018-08-14 13:38:17 +02002947 continue;
2948
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002949 case 's': if (checkforcmd_noparen(&eap->cmd, "sandbox", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002950 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002951 cmod->cmod_flags |= CMOD_SANDBOX;
Bram Moolenaareffed932018-08-14 13:38:17 +02002952 continue;
2953 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002954 if (!checkforcmd_noparen(&eap->cmd, "silent", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002955 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002956 cmod->cmod_flags |= CMOD_SILENT;
Bram Moolenaareffed932018-08-14 13:38:17 +02002957 if (*eap->cmd == '!' && !VIM_ISWHITE(eap->cmd[-1]))
2958 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002959 // ":silent!", but not "silent !cmd"
Bram Moolenaareffed932018-08-14 13:38:17 +02002960 eap->cmd = skipwhite(eap->cmd + 1);
Bram Moolenaare1004402020-10-24 20:49:43 +02002961 cmod->cmod_flags |= CMOD_ERRSILENT;
Bram Moolenaareffed932018-08-14 13:38:17 +02002962 }
2963 continue;
2964
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002965 case 't': if (checkforcmd_noparen(&p, "tab", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002966 {
Bram Moolenaar548e5982018-12-26 21:45:00 +01002967 if (!skip_only)
Bram Moolenaareffed932018-08-14 13:38:17 +02002968 {
Bram Moolenaar548e5982018-12-26 21:45:00 +01002969 long tabnr = get_address(eap, &eap->cmd,
2970 ADDR_TABS, eap->skip,
2971 skip_only, FALSE, 1);
2972 if (tabnr == MAXLNUM)
Bram Moolenaare1004402020-10-24 20:49:43 +02002973 cmod->cmod_tab = tabpage_index(curtab) + 1;
Bram Moolenaar548e5982018-12-26 21:45:00 +01002974 else
Bram Moolenaareffed932018-08-14 13:38:17 +02002975 {
Bram Moolenaar548e5982018-12-26 21:45:00 +01002976 if (tabnr < 0 || tabnr > LAST_TAB_NR)
2977 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002978 *errormsg = _(e_invrange);
Bram Moolenaar548e5982018-12-26 21:45:00 +01002979 return FAIL;
2980 }
Bram Moolenaare1004402020-10-24 20:49:43 +02002981 cmod->cmod_tab = tabnr + 1;
Bram Moolenaareffed932018-08-14 13:38:17 +02002982 }
Bram Moolenaareffed932018-08-14 13:38:17 +02002983 }
2984 eap->cmd = p;
2985 continue;
2986 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002987 if (!checkforcmd_noparen(&eap->cmd, "topleft", 2))
Bram Moolenaareffed932018-08-14 13:38:17 +02002988 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002989 cmod->cmod_split |= WSP_TOP;
Bram Moolenaareffed932018-08-14 13:38:17 +02002990 continue;
2991
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002992 case 'u': if (!checkforcmd_noparen(&eap->cmd, "unsilent", 3))
Bram Moolenaareffed932018-08-14 13:38:17 +02002993 break;
Bram Moolenaare1004402020-10-24 20:49:43 +02002994 cmod->cmod_flags |= CMOD_UNSILENT;
Bram Moolenaareffed932018-08-14 13:38:17 +02002995 continue;
2996
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01002997 case 'v': if (checkforcmd_noparen(&eap->cmd, "vertical", 4))
Bram Moolenaareffed932018-08-14 13:38:17 +02002998 {
Bram Moolenaare1004402020-10-24 20:49:43 +02002999 cmod->cmod_split |= WSP_VERT;
Bram Moolenaareffed932018-08-14 13:38:17 +02003000 continue;
3001 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01003002 if (checkforcmd_noparen(&eap->cmd, "vim9cmd", 4))
Bram Moolenaar39f3b142021-02-14 12:57:36 +01003003 {
3004 if (ends_excmd2(p, eap->cmd))
3005 {
3006 *errormsg =
3007 _(e_vim9cmd_must_be_followed_by_command);
3008 return FAIL;
3009 }
3010 cmod->cmod_flags |= CMOD_VIM9CMD;
3011 continue;
3012 }
Bram Moolenaarf49a1fc2021-03-27 22:20:21 +01003013 if (!checkforcmd_noparen(&p, "verbose", 4))
Bram Moolenaareffed932018-08-14 13:38:17 +02003014 break;
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003015 if (vim_isdigit(*eap->cmd))
Bram Moolenaare1004402020-10-24 20:49:43 +02003016 cmod->cmod_verbose = atoi((char *)eap->cmd);
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003017 else
Bram Moolenaare1004402020-10-24 20:49:43 +02003018 cmod->cmod_verbose = 1;
Bram Moolenaareffed932018-08-14 13:38:17 +02003019 eap->cmd = p;
3020 continue;
3021 }
3022 break;
3023 }
3024
3025 return OK;
3026}
3027
3028/*
Bram Moolenaarfa984412021-03-25 22:15:28 +01003029 * Return TRUE if "cmod" has anything set.
3030 */
3031 int
3032has_cmdmod(cmdmod_T *cmod)
3033{
3034 return cmod->cmod_flags != 0
3035 || cmod->cmod_split != 0
3036 || cmod->cmod_verbose != 0
3037 || cmod->cmod_tab != 0
3038 || cmod->cmod_filter_regmatch.regprog != NULL;
3039}
3040
3041/*
3042 * If Vim9 script and "cmdmod" has anything set give an error and return TRUE.
3043 */
3044 int
3045cmdmod_error(void)
3046{
3047 if (in_vim9script() && has_cmdmod(&cmdmod))
3048 {
3049 emsg(_(e_misplaced_command_modifier));
3050 return TRUE;
3051 }
3052 return FALSE;
3053}
3054
3055/*
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003056 * Apply the command modifiers. Saves current state in "cmdmod", call
3057 * undo_cmdmod() later.
3058 */
3059 void
3060apply_cmdmod(cmdmod_T *cmod)
3061{
3062#ifdef HAVE_SANDBOX
3063 if ((cmod->cmod_flags & CMOD_SANDBOX) && !cmod->cmod_did_sandbox)
3064 {
3065 ++sandbox;
3066 cmod->cmod_did_sandbox = TRUE;
3067 }
3068#endif
3069 if (cmod->cmod_verbose > 0)
3070 {
3071 if (cmod->cmod_verbose_save == 0)
3072 cmod->cmod_verbose_save = p_verbose + 1;
3073 p_verbose = cmod->cmod_verbose;
3074 }
3075
3076 if ((cmod->cmod_flags & (CMOD_SILENT | CMOD_UNSILENT))
3077 && cmod->cmod_save_msg_silent == 0)
Bram Moolenaare1004402020-10-24 20:49:43 +02003078 {
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003079 cmod->cmod_save_msg_silent = msg_silent + 1;
Bram Moolenaare1004402020-10-24 20:49:43 +02003080 cmod->cmod_save_msg_scroll = msg_scroll;
3081 }
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003082 if (cmod->cmod_flags & CMOD_SILENT)
3083 ++msg_silent;
3084 if (cmod->cmod_flags & CMOD_UNSILENT)
3085 msg_silent = 0;
3086
3087 if (cmod->cmod_flags & CMOD_ERRSILENT)
3088 {
3089 ++emsg_silent;
3090 ++cmod->cmod_did_esilent;
3091 }
3092
Bram Moolenaare1004402020-10-24 20:49:43 +02003093 if ((cmod->cmod_flags & CMOD_NOAUTOCMD) && cmod->cmod_save_ei == NULL)
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003094 {
3095 // Set 'eventignore' to "all".
3096 // First save the existing option value for restoring it later.
Bram Moolenaare1004402020-10-24 20:49:43 +02003097 cmod->cmod_save_ei = vim_strsave(p_ei);
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003098 set_string_option_direct((char_u *)"ei", -1,
3099 (char_u *)"all", OPT_FREE, SID_NONE);
3100 }
3101}
3102
3103/*
Bram Moolenaare1004402020-10-24 20:49:43 +02003104 * Undo and free contents of "cmod".
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02003105 */
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003106 void
Bram Moolenaare1004402020-10-24 20:49:43 +02003107undo_cmdmod(cmdmod_T *cmod)
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02003108{
Bram Moolenaare1004402020-10-24 20:49:43 +02003109 if (cmod->cmod_verbose_save > 0)
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003110 {
Bram Moolenaare1004402020-10-24 20:49:43 +02003111 p_verbose = cmod->cmod_verbose_save - 1;
3112 cmod->cmod_verbose_save = 0;
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003113 }
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003114
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003115#ifdef HAVE_SANDBOX
Bram Moolenaare1004402020-10-24 20:49:43 +02003116 if (cmod->cmod_did_sandbox)
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003117 {
3118 --sandbox;
Bram Moolenaare1004402020-10-24 20:49:43 +02003119 cmod->cmod_did_sandbox = FALSE;
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003120 }
3121#endif
3122
Bram Moolenaare1004402020-10-24 20:49:43 +02003123 if (cmod->cmod_save_ei != NULL)
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02003124 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003125 // Restore 'eventignore' to the value before ":noautocmd".
Bram Moolenaare1004402020-10-24 20:49:43 +02003126 set_string_option_direct((char_u *)"ei", -1, cmod->cmod_save_ei,
3127 OPT_FREE, SID_NONE);
3128 free_string_option(cmod->cmod_save_ei);
3129 cmod->cmod_save_ei = NULL;
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02003130 }
3131
Bram Moolenaarcaf73dc2020-10-26 21:39:13 +01003132 vim_regfree(cmod->cmod_filter_regmatch.regprog);
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003133
Bram Moolenaare1004402020-10-24 20:49:43 +02003134 if (cmod->cmod_save_msg_silent > 0)
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003135 {
3136 // messages could be enabled for a serious error, need to check if the
3137 // counters don't become negative
Bram Moolenaare1004402020-10-24 20:49:43 +02003138 if (!did_emsg || msg_silent > cmod->cmod_save_msg_silent - 1)
3139 msg_silent = cmod->cmod_save_msg_silent - 1;
3140 emsg_silent -= cmod->cmod_did_esilent;
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003141 if (emsg_silent < 0)
3142 emsg_silent = 0;
3143 // Restore msg_scroll, it's set by file I/O commands, even when no
3144 // message is actually displayed.
Bram Moolenaare1004402020-10-24 20:49:43 +02003145 msg_scroll = cmod->cmod_save_msg_scroll;
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003146
3147 // "silent reg" or "silent echo x" inside "redir" leaves msg_col
3148 // somewhere in the line. Put it back in the first column.
3149 if (redirecting())
3150 msg_col = 0;
Bram Moolenaar5661ed62020-10-24 17:19:16 +02003151
Bram Moolenaare1004402020-10-24 20:49:43 +02003152 cmod->cmod_save_msg_silent = 0;
3153 cmod->cmod_did_esilent = 0;
Bram Moolenaar47e7d702020-07-05 18:18:42 +02003154 }
Bram Moolenaar33c4dbb2018-08-14 16:06:16 +02003155}
3156
3157/*
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003158 * Parse the address range, if any, in "eap".
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02003159 * May set the last search pattern, unless "silent" is TRUE.
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003160 * Return FAIL and set "errormsg" or return OK.
3161 */
3162 int
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003163parse_cmd_address(exarg_T *eap, char **errormsg, int silent)
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003164{
3165 int address_count = 1;
3166 linenr_T lnum;
3167
3168 // Repeat for all ',' or ';' separated addresses.
3169 for (;;)
3170 {
3171 eap->line1 = eap->line2;
Bram Moolenaarc2af0af2020-08-23 21:06:02 +02003172 eap->line2 = default_address(eap);
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003173 eap->cmd = skipwhite(eap->cmd);
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02003174 lnum = get_address(eap, &eap->cmd, eap->addr_type, eap->skip, silent,
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003175 eap->addr_count == 0, address_count++);
3176 if (eap->cmd == NULL) // error detected
3177 return FAIL;
3178 if (lnum == MAXLNUM)
3179 {
3180 if (*eap->cmd == '%') // '%' - all lines
3181 {
3182 ++eap->cmd;
3183 switch (eap->addr_type)
3184 {
3185 case ADDR_LINES:
Bram Moolenaarb7316892019-05-01 18:08:42 +02003186 case ADDR_OTHER:
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003187 eap->line1 = 1;
3188 eap->line2 = curbuf->b_ml.ml_line_count;
3189 break;
3190 case ADDR_LOADED_BUFFERS:
3191 {
3192 buf_T *buf = firstbuf;
3193
3194 while (buf->b_next != NULL
3195 && buf->b_ml.ml_mfp == NULL)
3196 buf = buf->b_next;
3197 eap->line1 = buf->b_fnum;
3198 buf = lastbuf;
3199 while (buf->b_prev != NULL
3200 && buf->b_ml.ml_mfp == NULL)
3201 buf = buf->b_prev;
3202 eap->line2 = buf->b_fnum;
3203 break;
3204 }
3205 case ADDR_BUFFERS:
3206 eap->line1 = firstbuf->b_fnum;
3207 eap->line2 = lastbuf->b_fnum;
3208 break;
3209 case ADDR_WINDOWS:
3210 case ADDR_TABS:
3211 if (IS_USER_CMDIDX(eap->cmdidx))
3212 {
3213 eap->line1 = 1;
3214 eap->line2 = eap->addr_type == ADDR_WINDOWS
3215 ? LAST_WIN_NR : LAST_TAB_NR;
3216 }
3217 else
3218 {
3219 // there is no Vim command which uses '%' and
3220 // ADDR_WINDOWS or ADDR_TABS
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003221 *errormsg = _(e_invrange);
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003222 return FAIL;
3223 }
3224 break;
3225 case ADDR_TABS_RELATIVE:
Bram Moolenaar25190db2019-05-04 15:05:28 +02003226 case ADDR_UNSIGNED:
3227 case ADDR_QUICKFIX:
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003228 *errormsg = _(e_invrange);
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003229 return FAIL;
3230 case ADDR_ARGUMENTS:
3231 if (ARGCOUNT == 0)
3232 eap->line1 = eap->line2 = 0;
3233 else
3234 {
3235 eap->line1 = 1;
3236 eap->line2 = ARGCOUNT;
3237 }
3238 break;
Bram Moolenaar25190db2019-05-04 15:05:28 +02003239 case ADDR_QUICKFIX_VALID:
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02003240#ifdef FEAT_QUICKFIX
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003241 eap->line1 = 1;
Bram Moolenaar25190db2019-05-04 15:05:28 +02003242 eap->line2 = qf_get_valid_size(eap);
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003243 if (eap->line2 == 0)
3244 eap->line2 = 1;
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003245#endif
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02003246 break;
Bram Moolenaarb7316892019-05-01 18:08:42 +02003247 case ADDR_NONE:
3248 // Will give an error later if a range is found.
3249 break;
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003250 }
3251 ++eap->addr_count;
3252 }
3253 else if (*eap->cmd == '*' && vim_strchr(p_cpo, CPO_STAR) == NULL)
3254 {
3255 pos_T *fp;
3256
3257 // '*' - visual area
3258 if (eap->addr_type != ADDR_LINES)
3259 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003260 *errormsg = _(e_invrange);
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003261 return FAIL;
3262 }
3263
3264 ++eap->cmd;
3265 if (!eap->skip)
3266 {
3267 fp = getmark('<', FALSE);
3268 if (check_mark(fp) == FAIL)
3269 return FAIL;
3270 eap->line1 = fp->lnum;
3271 fp = getmark('>', FALSE);
3272 if (check_mark(fp) == FAIL)
3273 return FAIL;
3274 eap->line2 = fp->lnum;
3275 ++eap->addr_count;
3276 }
3277 }
3278 }
3279 else
3280 eap->line2 = lnum;
3281 eap->addr_count++;
3282
3283 if (*eap->cmd == ';')
3284 {
3285 if (!eap->skip)
3286 {
3287 curwin->w_cursor.lnum = eap->line2;
Bram Moolenaar0e717042020-04-27 19:29:01 +02003288 // Don't leave the cursor on an illegal line or column, but do
3289 // accept zero as address, so 0;/PATTERN/ works correctly.
3290 if (eap->line2 > 0)
3291 check_cursor();
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003292 }
3293 }
3294 else if (*eap->cmd != ',')
3295 break;
3296 ++eap->cmd;
3297 }
3298
3299 // One address given: set start and end lines.
3300 if (eap->addr_count == 1)
3301 {
3302 eap->line1 = eap->line2;
3303 // ... but only implicit: really no address given
3304 if (lnum == MAXLNUM)
3305 eap->addr_count = 0;
3306 }
3307 return OK;
3308}
3309
3310/*
Bram Moolenaara6f4d612011-09-21 19:10:46 +02003311 * Append "cmd" to the error message in IObuff.
3312 * Takes care of limiting the length and handling 0xa0, which would be
3313 * invisible otherwise.
3314 */
3315 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003316append_command(char_u *cmd)
Bram Moolenaara6f4d612011-09-21 19:10:46 +02003317{
3318 char_u *s = cmd;
3319 char_u *d;
3320
3321 STRCAT(IObuff, ": ");
3322 d = IObuff + STRLEN(IObuff);
3323 while (*s != NUL && d - IObuff < IOSIZE - 7)
3324 {
Bram Moolenaar13505972019-01-24 15:04:48 +01003325 if (enc_utf8 ? (s[0] == 0xc2 && s[1] == 0xa0) : *s == 0xa0)
Bram Moolenaara6f4d612011-09-21 19:10:46 +02003326 {
Bram Moolenaar13505972019-01-24 15:04:48 +01003327 s += enc_utf8 ? 2 : 1;
Bram Moolenaara6f4d612011-09-21 19:10:46 +02003328 STRCPY(d, "<a0>");
3329 d += 4;
3330 }
3331 else
3332 MB_COPY_CHAR(s, d);
3333 }
3334 *d = NUL;
3335}
3336
3337/*
Bram Moolenaar2e800952020-08-23 19:34:48 +02003338 * If "start" points "&opt", "&l:opt", "&g:opt" or "$ENV" return a pointer to
3339 * the name. Otherwise just return "start".
3340 */
3341 char_u *
3342skip_option_env_lead(char_u *start)
3343{
3344 char_u *name = start;
3345
3346 if (*start == '&')
3347 {
3348 if ((start[1] == 'l' || start[1] == 'g') && start[2] == ':')
3349 name += 3;
3350 else
3351 name += 1;
3352 }
3353 else if (*start == '$')
3354 name += 1;
3355 return name;
3356}
3357
3358/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00003359 * Find an Ex command by its name, either built-in or user.
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003360 * Start of the name can be found at eap->cmd.
Bram Moolenaar25190db2019-05-04 15:05:28 +02003361 * Sets eap->cmdidx and returns a pointer to char after the command name.
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003362 * "full" is set to TRUE if the whole command name matched.
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003363 *
3364 * If "lookup" is not NULL recognize expression without "eval" or "call" and
3365 * assignment without "let". Sets eap->cmdidx to the command while returning
3366 * "eap->cmd".
3367 *
Bram Moolenaar071d4272004-06-13 20:20:40 +00003368 * Returns NULL for an ambiguous user command.
3369 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003370 char_u *
3371find_ex_command(
3372 exarg_T *eap,
Bram Moolenaara494f562020-04-18 17:45:38 +02003373 int *full UNUSED,
Bram Moolenaar77b10ff2021-03-14 13:21:35 +01003374 int (*lookup)(char_u *, size_t, int cmd, cctx_T *) UNUSED,
Bram Moolenaara494f562020-04-18 17:45:38 +02003375 cctx_T *cctx UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003376{
3377 int len;
3378 char_u *p;
Bram Moolenaardf177f62005-02-22 08:39:57 +00003379 int i;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003380
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003381#ifdef FEAT_EVAL
3382 /*
3383 * Recognize a Vim9 script function/method call and assignment:
3384 * "lvar = value", "lvar(arg)", "[1, 2 3]->Func()"
3385 */
Bram Moolenaar0c6ceaf2020-02-22 18:36:32 +01003386 p = eap->cmd;
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003387 if (lookup != NULL)
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003388 {
Bram Moolenaar2e800952020-08-23 19:34:48 +02003389 char_u *pskip = skip_option_env_lead(eap->cmd);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003390
Bram Moolenaar83144542020-08-02 20:40:43 +02003391 if (vim_strchr((char_u *)"{('[\"@", *p) != NULL
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003392 || ((p = to_name_const_end(pskip)) > eap->cmd && *p != NUL))
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003393 {
Bram Moolenaar7cebe8b2021-01-23 14:22:16 +01003394 int oplen;
3395 int heredoc;
3396 char_u *swp = skipwhite(p);
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003397
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003398 if (
3399 // "(..." is an expression.
3400 // "funcname(" is always a function call.
3401 *p == '('
3402 || (p == eap->cmd
3403 ? (
Bram Moolenaar9becdf22020-10-10 21:33:48 +02003404 // "{..." is a dict expression or block start.
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003405 *eap->cmd == '{'
3406 // "'string'->func()" is an expression.
3407 || *eap->cmd == '\''
Bram Moolenaar10409562020-07-29 20:00:38 +02003408 // '"string"->func()' is an expression.
3409 || *eap->cmd == '"'
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003410 // "g:varname" is an expression.
3411 || eap->cmd[1] == ':'
3412 )
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003413 // "varname->func()" is an expression.
Bram Moolenaar7cebe8b2021-01-23 14:22:16 +01003414 : (*swp == '-' && swp[1] == '>')))
Bram Moolenaarb31be3f2020-07-20 22:37:44 +02003415 {
Bram Moolenaar9becdf22020-10-10 21:33:48 +02003416 if (*eap->cmd == '{' && ends_excmd(*skipwhite(eap->cmd + 1)))
3417 {
3418 // "{" by itself is the start of a block.
3419 eap->cmdidx = CMD_block;
3420 return eap->cmd + 1;
3421 }
Bram Moolenaarb31be3f2020-07-20 22:37:44 +02003422 eap->cmdidx = CMD_eval;
3423 return eap->cmd;
3424 }
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003425
Bram Moolenaar2b22b112020-09-14 18:35:18 +02003426 if (p != eap->cmd && (
3427 // "varname[]" is an expression.
3428 *p == '['
3429 // "varname.key" is an expression.
3430 || (*p == '.' && ASCII_ISALPHA(p[1]))))
3431 {
Bram Moolenaar68452172021-04-12 21:21:02 +02003432 char_u *after = eap->cmd;
Bram Moolenaar2b22b112020-09-14 18:35:18 +02003433
3434 // When followed by "=" or "+=" then it is an assignment.
Bram Moolenaar68452172021-04-12 21:21:02 +02003435 // Skip over the whole thing, it can be:
3436 // name.member = val
3437 // name[a : b] = val
3438 // name[idx] = val
3439 // name[idx].member = val
3440 // etc.
3441 eap->cmdidx = CMD_eval;
Bram Moolenaar2b22b112020-09-14 18:35:18 +02003442 ++emsg_silent;
Bram Moolenaarce2c5442020-11-28 21:21:17 +01003443 if (skip_expr(&after, NULL) == OK)
Bram Moolenaar68452172021-04-12 21:21:02 +02003444 {
Bram Moolenaarce2c5442020-11-28 21:21:17 +01003445 after = skipwhite(after);
Bram Moolenaar68452172021-04-12 21:21:02 +02003446 if (*after == '=' || (*after != NUL && after[1] == '=')
Bram Moolenaarce2c5442020-11-28 21:21:17 +01003447 || (after[0] == '.' && after[1] == '.'
3448 && after[2] == '='))
Bram Moolenaar68452172021-04-12 21:21:02 +02003449 eap->cmdidx = CMD_var;
3450 }
Bram Moolenaar2b22b112020-09-14 18:35:18 +02003451 --emsg_silent;
3452 return eap->cmd;
3453 }
3454
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003455 // "[...]->Method()" is a list expression, but "[a, b] = Func()" is
3456 // an assignment.
3457 // If there is no line break inside the "[...]" then "p" is
3458 // advanced to after the "]" by to_name_const_end(): check if a "="
3459 // follows.
3460 // If "[...]" has a line break "p" still points at the "[" and it
3461 // can't be an assignment.
3462 if (*eap->cmd == '[')
Bram Moolenaarb31be3f2020-07-20 22:37:44 +02003463 {
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003464 p = to_name_const_end(eap->cmd);
Bram Moolenaarda7c20c2020-11-30 21:12:19 +01003465 if (p == eap->cmd && *p == '[')
3466 {
3467 int count = 0;
3468 int semicolon = FALSE;
3469
3470 p = skip_var_list(eap->cmd, TRUE, &count, &semicolon, TRUE);
3471 }
3472 if (p == NULL || p == eap->cmd || *skipwhite(p) != '=')
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003473 {
3474 eap->cmdidx = CMD_eval;
3475 return eap->cmd;
3476 }
3477 if (p > eap->cmd && *skipwhite(p) == '=')
3478 {
Bram Moolenaar30fd8202020-09-26 15:09:30 +02003479 eap->cmdidx = CMD_var;
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003480 return eap->cmd;
3481 }
3482 }
3483
3484 // Recognize an assignment if we recognize the variable name:
3485 // "g:var = expr"
Bram Moolenaaraa1959b2021-04-15 22:13:39 +02003486 // "var = expr" where "var" is a variable name or we are skipping
3487 // (variable declaration might have been skipped).
Bram Moolenaar83144542020-08-02 20:40:43 +02003488 if (*eap->cmd == '@')
3489 p = eap->cmd + 2;
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003490 oplen = assignment_len(skipwhite(p), &heredoc);
3491 if (oplen > 0)
3492 {
3493 if (((p - eap->cmd) > 2 && eap->cmd[1] == ':')
3494 || *eap->cmd == '&'
3495 || *eap->cmd == '$'
3496 || *eap->cmd == '@'
Bram Moolenaaraa1959b2021-04-15 22:13:39 +02003497 || eap->skip
Bram Moolenaar77b10ff2021-03-14 13:21:35 +01003498 || lookup(eap->cmd, p - eap->cmd, TRUE, cctx) == OK)
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003499 {
Bram Moolenaar30fd8202020-09-26 15:09:30 +02003500 eap->cmdidx = CMD_var;
Bram Moolenaarb5ed2662020-07-28 22:38:37 +02003501 return eap->cmd;
3502 }
3503 }
3504
3505 // Recognize using a type for a w:, b:, t: or g: variable:
3506 // "w:varname: number = 123".
3507 if (eap->cmd[1] == ':' && *p == ':')
3508 {
3509 eap->cmdidx = CMD_eval;
Bram Moolenaarb31be3f2020-07-20 22:37:44 +02003510 return eap->cmd;
3511 }
Bram Moolenaard2ef6b32020-07-02 21:11:34 +02003512 }
Bram Moolenaar148be9b2021-02-02 21:33:52 +01003513
3514 // If it is an ID it might be a variable with an operator on the next
3515 // line, if the variable exists it can't be an Ex command.
3516 if (p > eap->cmd && ends_excmd(*skipwhite(p))
Bram Moolenaar77b10ff2021-03-14 13:21:35 +01003517 && (lookup(eap->cmd, p - eap->cmd, TRUE, cctx) == OK
Bram Moolenaar148be9b2021-02-02 21:33:52 +01003518 || (ASCII_ISALPHA(eap->cmd[0]) && eap->cmd[1] == ':')))
3519 {
3520 eap->cmdidx = CMD_eval;
3521 return eap->cmd;
3522 }
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003523 }
3524#endif
3525
Bram Moolenaar071d4272004-06-13 20:20:40 +00003526 /*
3527 * Isolate the command and search for it in the command table.
Bram Moolenaar81870892007-11-11 18:17:28 +00003528 * Exceptions:
Bram Moolenaar10b94212021-02-19 21:42:57 +01003529 * - The 'k' command can directly be followed by any character.
3530 * But it is not used in Vim9 script.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003531 * - the 's' command can be followed directly by 'c', 'g', 'i', 'I' or 'r'
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01003532 * but :sre[wind] is another command, as are :scr[iptnames],
Bram Moolenaar071d4272004-06-13 20:20:40 +00003533 * :scs[cope], :sim[alt], :sig[ns] and :sil[ent].
Bram Moolenaardf177f62005-02-22 08:39:57 +00003534 * - the "d" command can directly be followed by 'l' or 'p' flag.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003535 */
3536 p = eap->cmd;
3537 if (*p == 'k')
3538 {
3539 eap->cmdidx = CMD_k;
3540 ++p;
3541 }
3542 else if (p[0] == 's'
Bram Moolenaar204b93f2015-08-04 22:02:51 +02003543 && ((p[1] == 'c' && (p[2] == NUL || (p[2] != 's' && p[2] != 'r'
3544 && (p[3] == NUL || (p[3] != 'i' && p[4] != 'p')))))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003545 || p[1] == 'g'
3546 || (p[1] == 'i' && p[2] != 'm' && p[2] != 'l' && p[2] != 'g')
3547 || p[1] == 'I'
3548 || (p[1] == 'r' && p[2] != 'e')))
3549 {
3550 eap->cmdidx = CMD_substitute;
3551 ++p;
3552 }
3553 else
3554 {
3555 while (ASCII_ISALPHA(*p))
3556 ++p;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003557 // for python 3.x support ":py3", ":python3", ":py3file", etc.
Bram Moolenaar55d5c032010-07-17 23:52:29 +02003558 if (eap->cmd[0] == 'p' && eap->cmd[1] == 'y')
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003559 {
Bram Moolenaarb6590522010-07-21 16:00:43 +02003560 while (ASCII_ISALNUM(*p))
3561 ++p;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003562 }
3563 else if (*p == '9' && STRNCMP("vim9", eap->cmd, 4) == 0)
3564 {
Bram Moolenaardf749a22021-03-28 15:29:43 +02003565 // include "9" for "vim9*" commands; "vim9cmd" and "vim9script".
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003566 ++p;
3567 while (ASCII_ISALPHA(*p))
3568 ++p;
3569 }
Bram Moolenaarbd5e15f2010-07-17 21:19:38 +02003570
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003571 // check for non-alpha command
Bram Moolenaar9becdf22020-10-10 21:33:48 +02003572 if (p == eap->cmd && vim_strchr((char_u *)"@*!=><&~#}", *p) != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003573 ++p;
3574 len = (int)(p - eap->cmd);
Bram Moolenaardf177f62005-02-22 08:39:57 +00003575 if (*eap->cmd == 'd' && (p[-1] == 'l' || p[-1] == 'p'))
3576 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003577 // Check for ":dl", ":dell", etc. to ":deletel": that's
3578 // :delete with the 'l' flag. Same for 'p'.
Bram Moolenaardf177f62005-02-22 08:39:57 +00003579 for (i = 0; i < len; ++i)
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00003580 if (eap->cmd[i] != ((char_u *)"delete")[i])
Bram Moolenaardf177f62005-02-22 08:39:57 +00003581 break;
3582 if (i == len - 1)
3583 {
3584 --len;
3585 if (p[-1] == 'l')
3586 eap->flags |= EXFLAG_LIST;
3587 else
3588 eap->flags |= EXFLAG_PRINT;
3589 }
3590 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003591
Bram Moolenaare5e0fbc2017-03-25 14:51:01 +01003592 if (ASCII_ISLOWER(eap->cmd[0]))
3593 {
Bram Moolenaar6c0c1e82017-03-25 15:07:43 +01003594 int c1 = eap->cmd[0];
Bram Moolenaar94f82cb2019-07-24 22:30:27 +02003595 int c2 = len == 1 ? NUL : eap->cmd[1];
Bram Moolenaar6c0c1e82017-03-25 15:07:43 +01003596
Bram Moolenaare5e0fbc2017-03-25 14:51:01 +01003597 if (command_count != (int)CMD_SIZE)
3598 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01003599 iemsg(_("E943: Command table needs to be updated, run 'make cmdidxs'"));
Bram Moolenaare5e0fbc2017-03-25 14:51:01 +01003600 getout(1);
3601 }
3602
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003603 // Use a precomputed index for fast look-up in cmdnames[]
3604 // taking into account the first 2 letters of eap->cmd.
Bram Moolenaare5e0fbc2017-03-25 14:51:01 +01003605 eap->cmdidx = cmdidxs1[CharOrdLow(c1)];
3606 if (ASCII_ISLOWER(c2))
3607 eap->cmdidx += cmdidxs2[CharOrdLow(c1)][CharOrdLow(c2)];
3608 }
Bram Moolenaara494f562020-04-18 17:45:38 +02003609 else if (ASCII_ISUPPER(eap->cmd[0]))
3610 eap->cmdidx = CMD_Next;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003611 else
Bram Moolenaare5e0fbc2017-03-25 14:51:01 +01003612 eap->cmdidx = CMD_bang;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003613
3614 for ( ; (int)eap->cmdidx < (int)CMD_SIZE;
3615 eap->cmdidx = (cmdidx_T)((int)eap->cmdidx + 1))
3616 if (STRNCMP(cmdnames[(int)eap->cmdidx].cmd_name, (char *)eap->cmd,
3617 (size_t)len) == 0)
3618 {
3619#ifdef FEAT_EVAL
3620 if (full != NULL
3621 && cmdnames[(int)eap->cmdidx].cmd_name[len] == NUL)
3622 *full = TRUE;
3623#endif
3624 break;
3625 }
3626
Bram Moolenaar95388e32020-11-20 21:07:00 +01003627 // Not not recognize ":*" as the star command unless '*' is in
3628 // 'cpoptions'.
3629 if (eap->cmdidx == CMD_star && vim_strchr(p_cpo, CPO_STAR) == NULL)
3630 p = eap->cmd;
3631
Bram Moolenaarac9fb182019-04-27 13:04:13 +02003632 // Look for a user defined command as a last resort. Let ":Print" be
3633 // overruled by a user defined command.
Bram Moolenaara3e7b1f2010-11-10 19:00:01 +01003634 if ((eap->cmdidx == CMD_SIZE || eap->cmdidx == CMD_Print)
3635 && *eap->cmd >= 'A' && *eap->cmd <= 'Z')
Bram Moolenaar071d4272004-06-13 20:20:40 +00003636 {
Bram Moolenaarac9fb182019-04-27 13:04:13 +02003637 // User defined commands may contain digits.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003638 while (ASCII_ISALNUM(*p))
3639 ++p;
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003640 p = find_ucmd(eap, p, full, NULL, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003641 }
Bram Moolenaar1c0aa972020-12-16 21:43:54 +01003642 if (p == NULL || p == eap->cmd)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003643 eap->cmdidx = CMD_SIZE;
3644 }
3645
Bram Moolenaar373863e2020-09-26 17:20:53 +02003646 // ":fina" means ":finally" for backwards compatibility.
3647 if (eap->cmdidx == CMD_final && p - eap->cmd == 4)
3648 eap->cmdidx = CMD_finally;
3649
Bram Moolenaar2a3cd3a2020-12-13 19:22:27 +01003650#ifdef FEAT_EVAL
Bram Moolenaard1510ee2021-01-04 16:15:58 +01003651 if (eap->cmdidx < CMD_SIZE
3652 && in_vim9script()
Bram Moolenaarf8103f22020-12-25 17:36:27 +01003653 && !IS_WHITE_OR_NUL(*p) && *p != '\n' && *p != '!'
Bram Moolenaard1510ee2021-01-04 16:15:58 +01003654 && (eap->cmdidx < 0 ||
3655 (cmdnames[eap->cmdidx].cmd_argt & EX_NONWHITE_OK) == 0))
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003656 {
3657 semsg(_(e_command_not_followed_by_white_space_str), eap->cmd);
3658 eap->cmdidx = CMD_SIZE;
3659 }
Bram Moolenaar2a3cd3a2020-12-13 19:22:27 +01003660#endif
Bram Moolenaarb5b94802020-12-13 17:50:20 +01003661
Bram Moolenaar071d4272004-06-13 20:20:40 +00003662 return p;
3663}
3664
3665#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaared53fb92007-11-24 20:50:24 +00003666static struct cmdmod
3667{
3668 char *name;
3669 int minlen;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003670 int has_count; // :123verbose :3tab
Bram Moolenaared53fb92007-11-24 20:50:24 +00003671} cmdmods[] = {
3672 {"aboveleft", 3, FALSE},
3673 {"belowright", 3, FALSE},
3674 {"botright", 2, FALSE},
3675 {"browse", 3, FALSE},
3676 {"confirm", 4, FALSE},
Bram Moolenaar7b668e82016-08-23 23:51:21 +02003677 {"filter", 4, FALSE},
Bram Moolenaared53fb92007-11-24 20:50:24 +00003678 {"hide", 3, FALSE},
3679 {"keepalt", 5, FALSE},
3680 {"keepjumps", 5, FALSE},
3681 {"keepmarks", 3, FALSE},
Bram Moolenaara939e432013-11-09 05:30:26 +01003682 {"keeppatterns", 5, FALSE},
Bram Moolenaared53fb92007-11-24 20:50:24 +00003683 {"leftabove", 5, FALSE},
3684 {"lockmarks", 3, FALSE},
Bram Moolenaarca9f9582008-09-18 10:44:28 +00003685 {"noautocmd", 3, FALSE},
Bram Moolenaar5803ae62014-03-23 16:04:02 +01003686 {"noswapfile", 3, FALSE},
Bram Moolenaared53fb92007-11-24 20:50:24 +00003687 {"rightbelow", 6, FALSE},
3688 {"sandbox", 3, FALSE},
3689 {"silent", 3, FALSE},
3690 {"tab", 3, TRUE},
3691 {"topleft", 2, FALSE},
Bram Moolenaar8e258a42009-07-09 13:55:43 +00003692 {"unsilent", 3, FALSE},
Bram Moolenaared53fb92007-11-24 20:50:24 +00003693 {"verbose", 4, TRUE},
3694 {"vertical", 4, FALSE},
3695};
3696
3697/*
3698 * Return length of a command modifier (including optional count).
3699 * Return zero when it's not a modifier.
3700 */
3701 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003702modifier_len(char_u *cmd)
Bram Moolenaared53fb92007-11-24 20:50:24 +00003703{
3704 int i, j;
3705 char_u *p = cmd;
3706
3707 if (VIM_ISDIGIT(*cmd))
3708 p = skipwhite(skipdigits(cmd));
Bram Moolenaaraf0167f2009-05-16 15:31:32 +00003709 for (i = 0; i < (int)(sizeof(cmdmods) / sizeof(struct cmdmod)); ++i)
Bram Moolenaared53fb92007-11-24 20:50:24 +00003710 {
3711 for (j = 0; p[j] != NUL; ++j)
3712 if (p[j] != cmdmods[i].name[j])
3713 break;
Bram Moolenaar2d473ab2013-06-12 17:12:24 +02003714 if (!ASCII_ISALPHA(p[j]) && j >= cmdmods[i].minlen
Bram Moolenaared53fb92007-11-24 20:50:24 +00003715 && (p == cmd || cmdmods[i].has_count))
Bram Moolenaarcb4cef22008-03-16 15:04:34 +00003716 return j + (int)(p - cmd);
Bram Moolenaared53fb92007-11-24 20:50:24 +00003717 }
3718 return 0;
3719}
3720
Bram Moolenaar071d4272004-06-13 20:20:40 +00003721/*
3722 * Return > 0 if an Ex command "name" exists.
3723 * Return 2 if there is an exact match.
3724 * Return 3 if there is an ambiguous match.
3725 */
3726 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003727cmd_exists(char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003728{
3729 exarg_T ea;
3730 int full = FALSE;
3731 int i;
3732 int j;
Bram Moolenaarf3a67882006-05-05 21:09:41 +00003733 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003734
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003735 // Check command modifiers.
Bram Moolenaaraf0167f2009-05-16 15:31:32 +00003736 for (i = 0; i < (int)(sizeof(cmdmods) / sizeof(struct cmdmod)); ++i)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003737 {
3738 for (j = 0; name[j] != NUL; ++j)
3739 if (name[j] != cmdmods[i].name[j])
3740 break;
3741 if (name[j] == NUL && j >= cmdmods[i].minlen)
3742 return (cmdmods[i].name[j] == NUL ? 2 : 1);
3743 }
3744
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003745 // Check built-in commands and user defined commands.
3746 // For ":2match" and ":3match" we need to skip the number.
Bram Moolenaara9587612006-05-04 21:47:50 +00003747 ea.cmd = (*name == '2' || *name == '3') ? name + 1 : name;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003748 ea.cmdidx = (cmdidx_T)0;
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01003749 p = find_ex_command(&ea, &full, NULL, NULL);
Bram Moolenaarf3a67882006-05-05 21:09:41 +00003750 if (p == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003751 return 3;
Bram Moolenaara9587612006-05-04 21:47:50 +00003752 if (vim_isdigit(*name) && ea.cmdidx != CMD_match)
3753 return 0;
Bram Moolenaarf3a67882006-05-05 21:09:41 +00003754 if (*skipwhite(p) != NUL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003755 return 0; // trailing garbage
Bram Moolenaar071d4272004-06-13 20:20:40 +00003756 return (ea.cmdidx == CMD_SIZE ? 0 : (full ? 2 : 1));
3757}
Bram Moolenaar038e09e2021-02-06 12:38:51 +01003758
3759/*
3760 * "fullcommand" function
3761 */
3762 void
3763f_fullcommand(typval_T *argvars, typval_T *rettv)
3764{
3765 exarg_T ea;
3766 char_u *name = argvars[0].vval.v_string;
3767 char_u *p;
3768
3769 while (name[0] != NUL && name[0] == ':')
3770 name++;
3771 name = skip_range(name, TRUE, NULL);
3772
3773 rettv->v_type = VAR_STRING;
3774
3775 ea.cmd = (*name == '2' || *name == '3') ? name + 1 : name;
3776 ea.cmdidx = (cmdidx_T)0;
3777 p = find_ex_command(&ea, NULL, NULL, NULL);
3778 if (p == NULL || ea.cmdidx == CMD_SIZE)
3779 return;
3780
3781 rettv->vval.v_string = vim_strsave(IS_USER_CMDIDX(ea.cmdidx)
3782 ? get_user_commands(NULL, ea.useridx)
3783 : cmdnames[ea.cmdidx].cmd_name);
3784}
Bram Moolenaar071d4272004-06-13 20:20:40 +00003785#endif
3786
Bram Moolenaard0190392019-08-23 21:17:35 +02003787 cmdidx_T
3788excmd_get_cmdidx(char_u *cmd, int len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003789{
Bram Moolenaard0190392019-08-23 21:17:35 +02003790 cmdidx_T idx;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003791
Bram Moolenaard0190392019-08-23 21:17:35 +02003792 for (idx = (cmdidx_T)0; (int)idx < (int)CMD_SIZE;
3793 idx = (cmdidx_T)((int)idx + 1))
3794 if (STRNCMP(cmdnames[(int)idx].cmd_name, cmd, (size_t)len) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003795 break;
3796
Bram Moolenaard0190392019-08-23 21:17:35 +02003797 return idx;
3798}
Bram Moolenaar071d4272004-06-13 20:20:40 +00003799
Bram Moolenaard0190392019-08-23 21:17:35 +02003800 long
3801excmd_get_argt(cmdidx_T idx)
3802{
3803 return (long)cmdnames[(int)idx].cmd_argt;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003804}
3805
3806/*
Bram Moolenaaree8415b2018-08-10 23:13:12 +02003807 * Skip a range specifier of the form: addr [,addr] [;addr] ..
Bram Moolenaar071d4272004-06-13 20:20:40 +00003808 *
3809 * Backslashed delimiters after / or ? will be skipped, and commands will
3810 * not be expanded between /'s and ?'s or after "'".
3811 *
Bram Moolenaardf069ee2020-06-22 23:02:51 +02003812 * Also skip white space and ":" characters after the range.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003813 * Returns the "cmd" pointer advanced to beyond the range.
3814 */
3815 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003816skip_range(
3817 char_u *cmd,
Bram Moolenaar3bd8de42020-09-14 16:37:34 +02003818 int skip_star, // skip "*" used for Visual range
3819 int *ctx) // pointer to xp_context or NULL
Bram Moolenaar071d4272004-06-13 20:20:40 +00003820{
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00003821 unsigned delim;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003822
Bram Moolenaarcbf20fb2017-02-03 21:19:04 +01003823 while (vim_strchr((char_u *)" \t0123456789.$%'/?-+,;\\", *cmd) != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003824 {
Bram Moolenaarcbf20fb2017-02-03 21:19:04 +01003825 if (*cmd == '\\')
3826 {
3827 if (cmd[1] == '?' || cmd[1] == '/' || cmd[1] == '&')
3828 ++cmd;
3829 else
3830 break;
3831 }
3832 else if (*cmd == '\'')
Bram Moolenaar071d4272004-06-13 20:20:40 +00003833 {
3834 if (*++cmd == NUL && ctx != NULL)
3835 *ctx = EXPAND_NOTHING;
3836 }
3837 else if (*cmd == '/' || *cmd == '?')
3838 {
3839 delim = *cmd++;
3840 while (*cmd != NUL && *cmd != delim)
3841 if (*cmd++ == '\\' && *cmd != NUL)
3842 ++cmd;
3843 if (*cmd == NUL && ctx != NULL)
3844 *ctx = EXPAND_NOTHING;
3845 }
3846 if (*cmd != NUL)
3847 ++cmd;
3848 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00003849
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003850 // Skip ":" and white space.
Bram Moolenaardf177f62005-02-22 08:39:57 +00003851 while (*cmd == ':')
3852 cmd = skipwhite(cmd + 1);
3853
Bram Moolenaar3bd8de42020-09-14 16:37:34 +02003854 // Skip "*" used for Visual range.
3855 if (skip_star && *cmd == '*' && vim_strchr(p_cpo, CPO_STAR) == NULL)
3856 cmd = skipwhite(cmd + 1);
3857
Bram Moolenaar071d4272004-06-13 20:20:40 +00003858 return cmd;
3859}
3860
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02003861 static void
3862addr_error(cmd_addr_T addr_type)
3863{
3864 if (addr_type == ADDR_NONE)
3865 emsg(_(e_norange));
3866 else
3867 emsg(_(e_invrange));
3868}
3869
Bram Moolenaar071d4272004-06-13 20:20:40 +00003870/*
Bram Moolenaarc2af0af2020-08-23 21:06:02 +02003871 * Return the default address for an address type.
3872 */
3873 static linenr_T
3874default_address(exarg_T *eap)
3875{
3876 linenr_T lnum = 0;
3877
3878 switch (eap->addr_type)
3879 {
3880 case ADDR_LINES:
3881 case ADDR_OTHER:
3882 // Default is the cursor line number. Avoid using an invalid
3883 // line number though.
3884 if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
3885 lnum = curbuf->b_ml.ml_line_count;
3886 else
3887 lnum = curwin->w_cursor.lnum;
3888 break;
3889 case ADDR_WINDOWS:
3890 lnum = CURRENT_WIN_NR;
3891 break;
3892 case ADDR_ARGUMENTS:
3893 lnum = curwin->w_arg_idx + 1;
3894 if (lnum > ARGCOUNT)
3895 lnum = ARGCOUNT;
3896 break;
3897 case ADDR_LOADED_BUFFERS:
3898 case ADDR_BUFFERS:
3899 lnum = curbuf->b_fnum;
3900 break;
3901 case ADDR_TABS:
3902 lnum = CURRENT_TAB_NR;
3903 break;
3904 case ADDR_TABS_RELATIVE:
3905 case ADDR_UNSIGNED:
3906 lnum = 1;
3907 break;
3908 case ADDR_QUICKFIX:
3909#ifdef FEAT_QUICKFIX
3910 lnum = qf_get_cur_idx(eap);
3911#endif
3912 break;
3913 case ADDR_QUICKFIX_VALID:
3914#ifdef FEAT_QUICKFIX
3915 lnum = qf_get_cur_valid_idx(eap);
3916#endif
3917 break;
3918 case ADDR_NONE:
3919 // Will give an error later if a range is found.
3920 break;
3921 }
3922 return lnum;
3923}
3924
3925/*
Bram Moolenaar198cb662018-09-06 21:44:17 +02003926 * Get a single EX address.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003927 *
3928 * Set ptr to the next character after the part that was interpreted.
3929 * Set ptr to NULL when an error is encountered.
Bram Moolenaar198cb662018-09-06 21:44:17 +02003930 * This may set the last used search pattern.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003931 *
3932 * Return MAXLNUM when no Ex address was found.
3933 */
3934 static linenr_T
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01003935get_address(
3936 exarg_T *eap UNUSED,
3937 char_u **ptr,
Bram Moolenaar1b03a192019-12-08 17:08:29 +01003938 cmd_addr_T addr_type,
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02003939 int skip, // only skip the address, don't use it
3940 int silent, // no errors or side effects
3941 int to_other_file, // flag: may jump to other file
3942 int address_count UNUSED) // 1 for first address, >1 after comma
Bram Moolenaar071d4272004-06-13 20:20:40 +00003943{
3944 int c;
3945 int i;
3946 long n;
3947 char_u *cmd;
3948 pos_T pos;
3949 pos_T *fp;
3950 linenr_T lnum;
Bram Moolenaarf1d6ccf2014-12-08 04:16:44 +01003951 buf_T *buf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003952
3953 cmd = skipwhite(*ptr);
3954 lnum = MAXLNUM;
3955 do
3956 {
3957 switch (*cmd)
3958 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01003959 case '.': // '.' - Cursor position
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01003960 ++cmd;
3961 switch (addr_type)
3962 {
3963 case ADDR_LINES:
Bram Moolenaarb7316892019-05-01 18:08:42 +02003964 case ADDR_OTHER:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003965 lnum = curwin->w_cursor.lnum;
3966 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01003967 case ADDR_WINDOWS:
Bram Moolenaarf240e182014-11-27 18:33:02 +01003968 lnum = CURRENT_WIN_NR;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01003969 break;
3970 case ADDR_ARGUMENTS:
3971 lnum = curwin->w_arg_idx + 1;
3972 break;
3973 case ADDR_LOADED_BUFFERS:
Bram Moolenaarf1d6ccf2014-12-08 04:16:44 +01003974 case ADDR_BUFFERS:
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01003975 lnum = curbuf->b_fnum;
3976 break;
3977 case ADDR_TABS:
Bram Moolenaarf240e182014-11-27 18:33:02 +01003978 lnum = CURRENT_TAB_NR;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01003979 break;
Bram Moolenaarb7316892019-05-01 18:08:42 +02003980 case ADDR_NONE:
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02003981 case ADDR_TABS_RELATIVE:
Bram Moolenaar25190db2019-05-04 15:05:28 +02003982 case ADDR_UNSIGNED:
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02003983 addr_error(addr_type);
Bram Moolenaar2f72c702017-01-29 14:48:10 +01003984 cmd = NULL;
3985 goto error;
3986 break;
Bram Moolenaaraa23b372015-09-08 18:46:31 +02003987 case ADDR_QUICKFIX:
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02003988#ifdef FEAT_QUICKFIX
Bram Moolenaar25190db2019-05-04 15:05:28 +02003989 lnum = qf_get_cur_idx(eap);
3990#endif
3991 break;
3992 case ADDR_QUICKFIX_VALID:
3993#ifdef FEAT_QUICKFIX
Bram Moolenaaraa23b372015-09-08 18:46:31 +02003994 lnum = qf_get_cur_valid_idx(eap);
Bram Moolenaare906c502015-09-09 21:10:39 +02003995#endif
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02003996 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01003997 }
3998 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003999
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004000 case '$': // '$' - last line
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004001 ++cmd;
4002 switch (addr_type)
4003 {
4004 case ADDR_LINES:
Bram Moolenaarb7316892019-05-01 18:08:42 +02004005 case ADDR_OTHER:
Bram Moolenaar071d4272004-06-13 20:20:40 +00004006 lnum = curbuf->b_ml.ml_line_count;
4007 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004008 case ADDR_WINDOWS:
Bram Moolenaarf240e182014-11-27 18:33:02 +01004009 lnum = LAST_WIN_NR;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004010 break;
4011 case ADDR_ARGUMENTS:
4012 lnum = ARGCOUNT;
4013 break;
4014 case ADDR_LOADED_BUFFERS:
Bram Moolenaarf1d6ccf2014-12-08 04:16:44 +01004015 buf = lastbuf;
4016 while (buf->b_ml.ml_mfp == NULL)
4017 {
4018 if (buf->b_prev == NULL)
4019 break;
4020 buf = buf->b_prev;
4021 }
4022 lnum = buf->b_fnum;
4023 break;
4024 case ADDR_BUFFERS:
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004025 lnum = lastbuf->b_fnum;
4026 break;
4027 case ADDR_TABS:
Bram Moolenaarf240e182014-11-27 18:33:02 +01004028 lnum = LAST_TAB_NR;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004029 break;
Bram Moolenaarb7316892019-05-01 18:08:42 +02004030 case ADDR_NONE:
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004031 case ADDR_TABS_RELATIVE:
Bram Moolenaar25190db2019-05-04 15:05:28 +02004032 case ADDR_UNSIGNED:
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004033 addr_error(addr_type);
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004034 cmd = NULL;
4035 goto error;
4036 break;
Bram Moolenaaraa23b372015-09-08 18:46:31 +02004037 case ADDR_QUICKFIX:
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004038#ifdef FEAT_QUICKFIX
Bram Moolenaaraa23b372015-09-08 18:46:31 +02004039 lnum = qf_get_size(eap);
4040 if (lnum == 0)
4041 lnum = 1;
Bram Moolenaare906c502015-09-09 21:10:39 +02004042#endif
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004043 break;
Bram Moolenaar25190db2019-05-04 15:05:28 +02004044 case ADDR_QUICKFIX_VALID:
4045#ifdef FEAT_QUICKFIX
4046 lnum = qf_get_valid_size(eap);
4047 if (lnum == 0)
4048 lnum = 1;
4049#endif
4050 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004051 }
4052 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004053
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004054 case '\'': // ''' - mark
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004055 if (*++cmd == NUL)
4056 {
4057 cmd = NULL;
4058 goto error;
4059 }
4060 if (addr_type != ADDR_LINES)
4061 {
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004062 addr_error(addr_type);
Bram Moolenaarc0a37b92015-02-03 19:10:53 +01004063 cmd = NULL;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004064 goto error;
4065 }
4066 if (skip)
4067 ++cmd;
4068 else
4069 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004070 // Only accept a mark in another file when it is
4071 // used by itself: ":'M".
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004072 fp = getmark(*cmd, to_other_file && cmd[1] == NUL);
4073 ++cmd;
4074 if (fp == (pos_T *)-1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004075 // Jumped to another file.
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004076 lnum = curwin->w_cursor.lnum;
4077 else
4078 {
4079 if (check_mark(fp) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004080 {
4081 cmd = NULL;
4082 goto error;
4083 }
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004084 lnum = fp->lnum;
4085 }
4086 }
4087 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004088
4089 case '/':
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004090 case '?': // '/' or '?' - search
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004091 c = *cmd++;
4092 if (addr_type != ADDR_LINES)
4093 {
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004094 addr_error(addr_type);
Bram Moolenaarc0a37b92015-02-03 19:10:53 +01004095 cmd = NULL;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004096 goto error;
4097 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004098 if (skip) // skip "/pat/"
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004099 {
Bram Moolenaarf4e20992020-12-21 19:59:08 +01004100 cmd = skip_regexp(cmd, c, magic_isset());
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004101 if (*cmd == c)
4102 ++cmd;
4103 }
4104 else
4105 {
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02004106 int flags;
4107
4108 pos = curwin->w_cursor; // save curwin->w_cursor
4109
4110 // When '/' or '?' follows another address, start from
4111 // there.
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004112 if (lnum != MAXLNUM)
4113 curwin->w_cursor.lnum = lnum;
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02004114
4115 // Start a forward search at the end of the line (unless
4116 // before the first line).
4117 // Start a backward search at the start of the line.
4118 // This makes sure we never match in the current
4119 // line, and can match anywhere in the
4120 // next/previous line.
Bram Moolenaar8ada6aa2017-12-19 21:23:21 +01004121 if (c == '/' && curwin->w_cursor.lnum > 0)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004122 curwin->w_cursor.col = MAXCOL;
4123 else
4124 curwin->w_cursor.col = 0;
4125 searchcmdlen = 0;
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02004126 flags = silent ? 0 : SEARCH_HIS | SEARCH_MSG;
Bram Moolenaarc036e872020-02-21 21:30:52 +01004127 if (!do_search(NULL, c, c, cmd, 1L, flags, NULL))
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004128 {
4129 curwin->w_cursor = pos;
4130 cmd = NULL;
4131 goto error;
4132 }
4133 lnum = curwin->w_cursor.lnum;
4134 curwin->w_cursor = pos;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004135 // adjust command string pointer
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004136 cmd += searchcmdlen;
4137 }
4138 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004139
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004140 case '\\': // "\?", "\/" or "\&", repeat search
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004141 ++cmd;
4142 if (addr_type != ADDR_LINES)
4143 {
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02004144 addr_error(addr_type);
Bram Moolenaarc0a37b92015-02-03 19:10:53 +01004145 cmd = NULL;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004146 goto error;
4147 }
4148 if (*cmd == '&')
4149 i = RE_SUBST;
4150 else if (*cmd == '?' || *cmd == '/')
4151 i = RE_SEARCH;
4152 else
4153 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004154 emsg(_(e_backslash));
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004155 cmd = NULL;
4156 goto error;
4157 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004158
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004159 if (!skip)
4160 {
4161 /*
4162 * When search follows another address, start from
4163 * there.
4164 */
4165 if (lnum != MAXLNUM)
4166 pos.lnum = lnum;
4167 else
4168 pos.lnum = curwin->w_cursor.lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004169
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004170 /*
4171 * Start the search just like for the above
4172 * do_search().
4173 */
4174 if (*cmd != '?')
4175 pos.col = MAXCOL;
4176 else
4177 pos.col = 0;
Bram Moolenaarbd8539a2015-08-11 18:53:03 +02004178 pos.coladd = 0;
Bram Moolenaar5d24a222018-12-23 19:10:09 +01004179 if (searchit(curwin, curbuf, &pos, NULL,
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004180 *cmd == '?' ? BACKWARD : FORWARD,
Bram Moolenaar92ea26b2019-10-18 20:53:34 +02004181 (char_u *)"", 1L, SEARCH_MSG, i, NULL) != FAIL)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004182 lnum = pos.lnum;
4183 else
4184 {
4185 cmd = NULL;
4186 goto error;
4187 }
4188 }
4189 ++cmd;
4190 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004191
4192 default:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004193 if (VIM_ISDIGIT(*cmd)) // absolute line number
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004194 lnum = getdigits(&cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004195 }
4196
4197 for (;;)
4198 {
4199 cmd = skipwhite(cmd);
4200 if (*cmd != '-' && *cmd != '+' && !VIM_ISDIGIT(*cmd))
4201 break;
4202
4203 if (lnum == MAXLNUM)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004204 {
4205 switch (addr_type)
4206 {
4207 case ADDR_LINES:
Bram Moolenaarb7316892019-05-01 18:08:42 +02004208 case ADDR_OTHER:
4209 // "+1" is same as ".+1"
Bram Moolenaarf240e182014-11-27 18:33:02 +01004210 lnum = curwin->w_cursor.lnum;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004211 break;
4212 case ADDR_WINDOWS:
Bram Moolenaarf240e182014-11-27 18:33:02 +01004213 lnum = CURRENT_WIN_NR;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004214 break;
4215 case ADDR_ARGUMENTS:
4216 lnum = curwin->w_arg_idx + 1;
4217 break;
4218 case ADDR_LOADED_BUFFERS:
Bram Moolenaarf1d6ccf2014-12-08 04:16:44 +01004219 case ADDR_BUFFERS:
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004220 lnum = curbuf->b_fnum;
4221 break;
4222 case ADDR_TABS:
Bram Moolenaarf240e182014-11-27 18:33:02 +01004223 lnum = CURRENT_TAB_NR;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004224 break;
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004225 case ADDR_TABS_RELATIVE:
4226 lnum = 1;
4227 break;
Bram Moolenaaraa23b372015-09-08 18:46:31 +02004228 case ADDR_QUICKFIX:
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004229#ifdef FEAT_QUICKFIX
Bram Moolenaar25190db2019-05-04 15:05:28 +02004230 lnum = qf_get_cur_idx(eap);
4231#endif
4232 break;
4233 case ADDR_QUICKFIX_VALID:
4234#ifdef FEAT_QUICKFIX
Bram Moolenaaraa23b372015-09-08 18:46:31 +02004235 lnum = qf_get_cur_valid_idx(eap);
Bram Moolenaare906c502015-09-09 21:10:39 +02004236#endif
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004237 break;
Bram Moolenaarb7316892019-05-01 18:08:42 +02004238 case ADDR_NONE:
Bram Moolenaar25190db2019-05-04 15:05:28 +02004239 case ADDR_UNSIGNED:
4240 lnum = 0;
Bram Moolenaarb7316892019-05-01 18:08:42 +02004241 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01004242 }
4243 }
4244
Bram Moolenaar071d4272004-06-13 20:20:40 +00004245 if (VIM_ISDIGIT(*cmd))
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004246 i = '+'; // "number" is same as "+number"
Bram Moolenaar071d4272004-06-13 20:20:40 +00004247 else
4248 i = *cmd++;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004249 if (!VIM_ISDIGIT(*cmd)) // '+' is '+1', but '+0' is not '+1'
Bram Moolenaar071d4272004-06-13 20:20:40 +00004250 n = 1;
4251 else
4252 n = getdigits(&cmd);
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004253
4254 if (addr_type == ADDR_TABS_RELATIVE)
4255 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004256 emsg(_(e_invrange));
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004257 cmd = NULL;
4258 goto error;
4259 }
4260 else if (addr_type == ADDR_LOADED_BUFFERS
Bram Moolenaarf1d6ccf2014-12-08 04:16:44 +01004261 || addr_type == ADDR_BUFFERS)
Bram Moolenaarc0a37b92015-02-03 19:10:53 +01004262 lnum = compute_buffer_local_count(
4263 addr_type, lnum, (i == '-') ? -1 * n : n);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004264 else
Bram Moolenaarded27822017-01-02 14:27:34 +01004265 {
4266#ifdef FEAT_FOLDING
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004267 // Relative line addressing, need to adjust for folded lines
4268 // now, but only do it after the first address.
Bram Moolenaarded27822017-01-02 14:27:34 +01004269 if (addr_type == ADDR_LINES && (i == '-' || i == '+')
4270 && address_count >= 2)
4271 (void)hasFolding(lnum, NULL, &lnum);
4272#endif
4273 if (i == '-')
4274 lnum -= n;
4275 else
4276 lnum += n;
4277 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004278 }
4279 } while (*cmd == '/' || *cmd == '?');
4280
4281error:
4282 *ptr = cmd;
4283 return lnum;
4284}
4285
4286/*
Bram Moolenaarc2af0af2020-08-23 21:06:02 +02004287 * Set eap->line1 and eap->line2 to the whole range.
4288 * Used for commands with the EX_DFLALL flag and no range given.
4289 */
4290 static void
4291address_default_all(exarg_T *eap)
4292{
4293 eap->line1 = 1;
4294 switch (eap->addr_type)
4295 {
4296 case ADDR_LINES:
4297 case ADDR_OTHER:
4298 eap->line2 = curbuf->b_ml.ml_line_count;
4299 break;
4300 case ADDR_LOADED_BUFFERS:
4301 {
4302 buf_T *buf = firstbuf;
4303
4304 while (buf->b_next != NULL && buf->b_ml.ml_mfp == NULL)
4305 buf = buf->b_next;
4306 eap->line1 = buf->b_fnum;
4307 buf = lastbuf;
4308 while (buf->b_prev != NULL && buf->b_ml.ml_mfp == NULL)
4309 buf = buf->b_prev;
4310 eap->line2 = buf->b_fnum;
4311 }
4312 break;
4313 case ADDR_BUFFERS:
4314 eap->line1 = firstbuf->b_fnum;
4315 eap->line2 = lastbuf->b_fnum;
4316 break;
4317 case ADDR_WINDOWS:
4318 eap->line2 = LAST_WIN_NR;
4319 break;
4320 case ADDR_TABS:
4321 eap->line2 = LAST_TAB_NR;
4322 break;
4323 case ADDR_TABS_RELATIVE:
4324 eap->line2 = 1;
4325 break;
4326 case ADDR_ARGUMENTS:
4327 if (ARGCOUNT == 0)
4328 eap->line1 = eap->line2 = 0;
4329 else
4330 eap->line2 = ARGCOUNT;
4331 break;
4332 case ADDR_QUICKFIX_VALID:
4333#ifdef FEAT_QUICKFIX
4334 eap->line2 = qf_get_valid_size(eap);
4335 if (eap->line2 == 0)
4336 eap->line2 = 1;
4337#endif
4338 break;
4339 case ADDR_NONE:
4340 case ADDR_UNSIGNED:
4341 case ADDR_QUICKFIX:
4342 iemsg(_("INTERNAL: Cannot use EX_DFLALL with ADDR_NONE, ADDR_UNSIGNED or ADDR_QUICKFIX"));
4343 break;
4344 }
4345}
4346
4347
4348/*
Bram Moolenaardf177f62005-02-22 08:39:57 +00004349 * Get flags from an Ex command argument.
4350 */
4351 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004352get_flags(exarg_T *eap)
Bram Moolenaardf177f62005-02-22 08:39:57 +00004353{
4354 while (vim_strchr((char_u *)"lp#", *eap->arg) != NULL)
4355 {
4356 if (*eap->arg == 'l')
4357 eap->flags |= EXFLAG_LIST;
4358 else if (*eap->arg == 'p')
4359 eap->flags |= EXFLAG_PRINT;
4360 else
4361 eap->flags |= EXFLAG_NR;
4362 eap->arg = skipwhite(eap->arg + 1);
4363 }
4364}
4365
4366/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00004367 * Function called for command which is Not Implemented. NI!
4368 */
4369 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004370ex_ni(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004371{
4372 if (!eap->skip)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02004373 eap->errmsg =
4374 _("E319: Sorry, the command is not available in this version");
Bram Moolenaar071d4272004-06-13 20:20:40 +00004375}
4376
Bram Moolenaar7bb75552007-07-16 18:39:49 +00004377#ifdef HAVE_EX_SCRIPT_NI
Bram Moolenaar071d4272004-06-13 20:20:40 +00004378/*
4379 * Function called for script command which is Not Implemented. NI!
4380 * Skips over ":perl <<EOF" constructs.
4381 */
4382 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004383ex_script_ni(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004384{
4385 if (!eap->skip)
4386 ex_ni(eap);
4387 else
4388 vim_free(script_get(eap, eap->arg));
4389}
4390#endif
4391
4392/*
4393 * Check range in Ex command for validity.
4394 * Return NULL when valid, error message when invalid.
4395 */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004396 static char *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004397invalid_range(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004398{
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004399 buf_T *buf;
Bram Moolenaar25190db2019-05-04 15:05:28 +02004400
Bram Moolenaar071d4272004-06-13 20:20:40 +00004401 if ( eap->line1 < 0
4402 || eap->line2 < 0
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004403 || eap->line1 > eap->line2)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004404 return _(e_invrange);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004405
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004406 if (eap->argt & EX_RANGE)
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004407 {
Bram Moolenaarb7316892019-05-01 18:08:42 +02004408 switch (eap->addr_type)
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004409 {
4410 case ADDR_LINES:
Bram Moolenaarb7316892019-05-01 18:08:42 +02004411 if (eap->line2 > curbuf->b_ml.ml_line_count
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004412#ifdef FEAT_DIFF
4413 + (eap->cmdidx == CMD_diffget)
4414#endif
4415 )
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004416 return _(e_invrange);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004417 break;
4418 case ADDR_ARGUMENTS:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004419 // add 1 if ARGCOUNT is 0
Bram Moolenaarc0a37b92015-02-03 19:10:53 +01004420 if (eap->line2 > ARGCOUNT + (!ARGCOUNT))
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004421 return _(e_invrange);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004422 break;
4423 case ADDR_BUFFERS:
Bram Moolenaar00b0d6d2019-08-21 22:25:30 +02004424 // Only a boundary check, not whether the buffers actually
4425 // exist.
4426 if (eap->line1 < 1 || eap->line2 > get_highest_fnum())
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004427 return _(e_invrange);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004428 break;
4429 case ADDR_LOADED_BUFFERS:
4430 buf = firstbuf;
4431 while (buf->b_ml.ml_mfp == NULL)
4432 {
4433 if (buf->b_next == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004434 return _(e_invrange);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004435 buf = buf->b_next;
4436 }
4437 if (eap->line1 < buf->b_fnum)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004438 return _(e_invrange);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004439 buf = lastbuf;
4440 while (buf->b_ml.ml_mfp == NULL)
4441 {
4442 if (buf->b_prev == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004443 return _(e_invrange);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004444 buf = buf->b_prev;
4445 }
4446 if (eap->line2 > buf->b_fnum)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004447 return _(e_invrange);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004448 break;
4449 case ADDR_WINDOWS:
Bram Moolenaar8be63882015-01-14 11:25:05 +01004450 if (eap->line2 > LAST_WIN_NR)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004451 return _(e_invrange);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004452 break;
4453 case ADDR_TABS:
4454 if (eap->line2 > LAST_TAB_NR)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004455 return _(e_invrange);
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004456 break;
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004457 case ADDR_TABS_RELATIVE:
Bram Moolenaarb7316892019-05-01 18:08:42 +02004458 case ADDR_OTHER:
4459 // Any range is OK.
Bram Moolenaar2f72c702017-01-29 14:48:10 +01004460 break;
Bram Moolenaaraa23b372015-09-08 18:46:31 +02004461 case ADDR_QUICKFIX:
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004462#ifdef FEAT_QUICKFIX
Bram Moolenaar25190db2019-05-04 15:05:28 +02004463 // No error for value that is too big, will use the last entry.
4464 if (eap->line2 <= 0)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004465 return _(e_invrange);
Bram Moolenaare906c502015-09-09 21:10:39 +02004466#endif
Bram Moolenaar26f0cb12019-05-01 21:43:42 +02004467 break;
Bram Moolenaar25190db2019-05-04 15:05:28 +02004468 case ADDR_QUICKFIX_VALID:
4469#ifdef FEAT_QUICKFIX
4470 if ((eap->line2 != 1 && eap->line2 > qf_get_valid_size(eap))
4471 || eap->line2 < 0)
4472 return _(e_invrange);
4473#endif
4474 break;
4475 case ADDR_UNSIGNED:
4476 if (eap->line2 < 0)
4477 return _(e_invrange);
4478 break;
Bram Moolenaarb7316892019-05-01 18:08:42 +02004479 case ADDR_NONE:
4480 // Will give an error elsewhere.
4481 break;
Bram Moolenaar3ffc79a2015-01-07 15:57:17 +01004482 }
4483 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004484 return NULL;
4485}
4486
4487/*
4488 * Correct the range for zero line number, if required.
4489 */
4490 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004491correct_range(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004492{
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004493 if (!(eap->argt & EX_ZEROR)) // zero in range not allowed
Bram Moolenaar071d4272004-06-13 20:20:40 +00004494 {
4495 if (eap->line1 == 0)
4496 eap->line1 = 1;
4497 if (eap->line2 == 0)
4498 eap->line2 = 1;
4499 }
4500}
4501
Bram Moolenaar748bf032005-02-02 23:04:36 +00004502#ifdef FEAT_QUICKFIX
Bram Moolenaar748bf032005-02-02 23:04:36 +00004503/*
4504 * For a ":vimgrep" or ":vimgrepadd" command return a pointer past the
4505 * pattern. Otherwise return eap->arg.
4506 */
4507 static char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004508skip_grep_pat(exarg_T *eap)
Bram Moolenaar748bf032005-02-02 23:04:36 +00004509{
4510 char_u *p = eap->arg;
4511
Bram Moolenaara37420f2006-02-04 22:37:47 +00004512 if (*p != NUL && (eap->cmdidx == CMD_vimgrep || eap->cmdidx == CMD_lvimgrep
4513 || eap->cmdidx == CMD_vimgrepadd
4514 || eap->cmdidx == CMD_lvimgrepadd
4515 || grep_internal(eap->cmdidx)))
Bram Moolenaar748bf032005-02-02 23:04:36 +00004516 {
Bram Moolenaar05159a02005-02-26 23:04:13 +00004517 p = skip_vimgrep_pat(p, NULL, NULL);
Bram Moolenaar748bf032005-02-02 23:04:36 +00004518 if (p == NULL)
4519 p = eap->arg;
Bram Moolenaar748bf032005-02-02 23:04:36 +00004520 }
4521 return p;
4522}
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004523
4524/*
4525 * For the ":make" and ":grep" commands insert the 'makeprg'/'grepprg' option
4526 * in the command line, so that things like % get expanded.
4527 */
4528 static char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004529replace_makeprg(exarg_T *eap, char_u *p, char_u **cmdlinep)
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004530{
4531 char_u *new_cmdline;
4532 char_u *program;
4533 char_u *pos;
4534 char_u *ptr;
4535 int len;
4536 int i;
4537
4538 /*
4539 * Don't do it when ":vimgrep" is used for ":grep".
4540 */
Bram Moolenaara37420f2006-02-04 22:37:47 +00004541 if ((eap->cmdidx == CMD_make || eap->cmdidx == CMD_lmake
4542 || eap->cmdidx == CMD_grep || eap->cmdidx == CMD_lgrep
4543 || eap->cmdidx == CMD_grepadd
4544 || eap->cmdidx == CMD_lgrepadd)
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004545 && !grep_internal(eap->cmdidx))
4546 {
Bram Moolenaara37420f2006-02-04 22:37:47 +00004547 if (eap->cmdidx == CMD_grep || eap->cmdidx == CMD_lgrep
4548 || eap->cmdidx == CMD_grepadd || eap->cmdidx == CMD_lgrepadd)
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004549 {
4550 if (*curbuf->b_p_gp == NUL)
4551 program = p_gp;
4552 else
4553 program = curbuf->b_p_gp;
4554 }
4555 else
4556 {
4557 if (*curbuf->b_p_mp == NUL)
4558 program = p_mp;
4559 else
4560 program = curbuf->b_p_mp;
4561 }
4562
4563 p = skipwhite(p);
4564
4565 if ((pos = (char_u *)strstr((char *)program, "$*")) != NULL)
4566 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004567 // replace $* by given arguments
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004568 i = 1;
4569 while ((pos = (char_u *)strstr((char *)pos + 2, "$*")) != NULL)
4570 ++i;
4571 len = (int)STRLEN(p);
Bram Moolenaar51e14382019-05-25 20:21:28 +02004572 new_cmdline = alloc(STRLEN(program) + i * (len - 2) + 1);
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004573 if (new_cmdline == NULL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004574 return NULL; // out of memory
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004575 ptr = new_cmdline;
4576 while ((pos = (char_u *)strstr((char *)program, "$*")) != NULL)
4577 {
4578 i = (int)(pos - program);
4579 STRNCPY(ptr, program, i);
4580 STRCPY(ptr += i, p);
4581 ptr += len;
4582 program = pos + 2;
4583 }
4584 STRCPY(ptr, program);
4585 }
4586 else
4587 {
Bram Moolenaar51e14382019-05-25 20:21:28 +02004588 new_cmdline = alloc(STRLEN(program) + STRLEN(p) + 2);
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004589 if (new_cmdline == NULL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004590 return NULL; // out of memory
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004591 STRCPY(new_cmdline, program);
4592 STRCAT(new_cmdline, " ");
4593 STRCAT(new_cmdline, p);
4594 }
4595 msg_make(p);
4596
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004597 // 'eap->cmd' is not set here, because it is not used at CMD_make
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004598 vim_free(*cmdlinep);
4599 *cmdlinep = new_cmdline;
4600 p = new_cmdline;
4601 }
4602 return p;
4603}
Bram Moolenaar748bf032005-02-02 23:04:36 +00004604#endif
4605
Bram Moolenaar071d4272004-06-13 20:20:40 +00004606/*
4607 * Expand file name in Ex command argument.
Bram Moolenaar0abb4272019-06-15 16:06:00 +02004608 * When an error is detected, "errormsgp" is set to a non-NULL pointer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004609 * Return FAIL for failure, OK otherwise.
4610 */
4611 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004612expand_filename(
4613 exarg_T *eap,
4614 char_u **cmdlinep,
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01004615 char **errormsgp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004616{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004617 int has_wildcards; // need to expand wildcards
Bram Moolenaar071d4272004-06-13 20:20:40 +00004618 char_u *repl;
4619 int srclen;
4620 char_u *p;
4621 int n;
Bram Moolenaar63b92542007-03-27 14:57:09 +00004622 int escaped;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004623
Bram Moolenaar748bf032005-02-02 23:04:36 +00004624#ifdef FEAT_QUICKFIX
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004625 // Skip a regexp pattern for ":vimgrep[add] pat file..."
Bram Moolenaar748bf032005-02-02 23:04:36 +00004626 p = skip_grep_pat(eap);
4627#else
4628 p = eap->arg;
4629#endif
4630
Bram Moolenaar071d4272004-06-13 20:20:40 +00004631 /*
4632 * Decide to expand wildcards *before* replacing '%', '#', etc. If
4633 * the file name contains a wildcard it should not cause expanding.
4634 * (it will be expanded anyway if there is a wildcard before replacing).
4635 */
Bram Moolenaar748bf032005-02-02 23:04:36 +00004636 has_wildcards = mch_has_wildcard(p);
4637 while (*p != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004638 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004639#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004640 // Skip over `=expr`, wildcards in it are not expanded.
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004641 if (p[0] == '`' && p[1] == '=')
4642 {
4643 p += 2;
Bram Moolenaar683581e2020-10-22 21:22:58 +02004644 (void)skip_expr(&p, NULL);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004645 if (*p == '`')
4646 ++p;
4647 continue;
4648 }
4649#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004650 /*
4651 * Quick check if this cannot be the start of a special string.
4652 * Also removes backslash before '%', '#' and '<'.
4653 */
4654 if (vim_strchr((char_u *)"%#<", *p) == NULL)
4655 {
4656 ++p;
4657 continue;
4658 }
4659
4660 /*
4661 * Try to find a match at this position.
4662 */
Bram Moolenaar63b92542007-03-27 14:57:09 +00004663 repl = eval_vars(p, eap->arg, &srclen, &(eap->do_ecmd_lnum),
4664 errormsgp, &escaped);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004665 if (*errormsgp != NULL) // error detected
Bram Moolenaar071d4272004-06-13 20:20:40 +00004666 return FAIL;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004667 if (repl == NULL) // no match found
Bram Moolenaar071d4272004-06-13 20:20:40 +00004668 {
4669 p += srclen;
4670 continue;
4671 }
4672
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004673 // Wildcards won't be expanded below, the replacement is taken
4674 // literally. But do expand "~/file", "~user/file" and "$HOME/file".
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00004675 if (vim_strchr(repl, '$') != NULL || vim_strchr(repl, '~') != NULL)
4676 {
4677 char_u *l = repl;
4678
4679 repl = expand_env_save(repl);
4680 vim_free(l);
4681 }
4682
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004683 // Need to escape white space et al. with a backslash.
4684 // Don't do this for:
4685 // - replacement that already has been escaped: "##"
4686 // - shell commands (may have to use quotes instead).
4687 // - non-unix systems when there is a single argument (spaces don't
4688 // separate arguments then).
Bram Moolenaar071d4272004-06-13 20:20:40 +00004689 if (!eap->usefilter
Bram Moolenaar63b92542007-03-27 14:57:09 +00004690 && !escaped
Bram Moolenaar071d4272004-06-13 20:20:40 +00004691 && eap->cmdidx != CMD_bang
Bram Moolenaar071d4272004-06-13 20:20:40 +00004692 && eap->cmdidx != CMD_grep
4693 && eap->cmdidx != CMD_grepadd
Bram Moolenaarbf15b8d2017-06-04 20:43:48 +02004694 && eap->cmdidx != CMD_hardcopy
Bram Moolenaar67883b42017-07-27 22:57:00 +02004695 && eap->cmdidx != CMD_lgrep
4696 && eap->cmdidx != CMD_lgrepadd
4697 && eap->cmdidx != CMD_lmake
4698 && eap->cmdidx != CMD_make
4699 && eap->cmdidx != CMD_terminal
Bram Moolenaar071d4272004-06-13 20:20:40 +00004700#ifndef UNIX
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004701 && !(eap->argt & EX_NOSPC)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004702#endif
4703 )
4704 {
4705 char_u *l;
4706#ifdef BACKSLASH_IN_FILENAME
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004707 // Don't escape a backslash here, because rem_backslash() doesn't
4708 // remove it later.
Bram Moolenaar071d4272004-06-13 20:20:40 +00004709 static char_u *nobslash = (char_u *)" \t\"|";
4710# define ESCAPE_CHARS nobslash
4711#else
4712# define ESCAPE_CHARS escape_chars
4713#endif
4714
4715 for (l = repl; *l; ++l)
4716 if (vim_strchr(ESCAPE_CHARS, *l) != NULL)
4717 {
4718 l = vim_strsave_escaped(repl, ESCAPE_CHARS);
4719 if (l != NULL)
4720 {
4721 vim_free(repl);
4722 repl = l;
4723 }
4724 break;
4725 }
4726 }
4727
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004728 // For a shell command a '!' must be escaped.
Bram Moolenaar67883b42017-07-27 22:57:00 +02004729 if ((eap->usefilter || eap->cmdidx == CMD_bang
4730 || eap->cmdidx == CMD_terminal)
Bram Moolenaar31b7d382014-04-01 18:54:48 +02004731 && vim_strpbrk(repl, (char_u *)"!") != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004732 {
4733 char_u *l;
4734
Bram Moolenaar31b7d382014-04-01 18:54:48 +02004735 l = vim_strsave_escaped(repl, (char_u *)"!");
Bram Moolenaar071d4272004-06-13 20:20:40 +00004736 if (l != NULL)
4737 {
4738 vim_free(repl);
4739 repl = l;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004740 }
4741 }
4742
4743 p = repl_cmdline(eap, p, srclen, repl, cmdlinep);
4744 vim_free(repl);
4745 if (p == NULL)
4746 return FAIL;
4747 }
4748
4749 /*
4750 * One file argument: Expand wildcards.
4751 * Don't do this with ":r !command" or ":w !command".
4752 */
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004753 if ((eap->argt & EX_NOSPC) && !eap->usefilter)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004754 {
4755 /*
4756 * May do this twice:
4757 * 1. Replace environment variables.
4758 * 2. Replace any other wildcards, remove backslashes.
4759 */
4760 for (n = 1; n <= 2; ++n)
4761 {
4762 if (n == 2)
4763 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00004764 /*
4765 * Halve the number of backslashes (this is Vi compatible).
4766 * For Unix and OS/2, when wildcards are expanded, this is
4767 * done by ExpandOne() below.
4768 */
Bram Moolenaare7fedb62015-12-31 19:07:19 +01004769#if defined(UNIX)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004770 if (!has_wildcards)
4771#endif
4772 backslash_halve(eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004773 }
4774
4775 if (has_wildcards)
4776 {
4777 if (n == 1)
4778 {
4779 /*
4780 * First loop: May expand environment variables. This
4781 * can be done much faster with expand_env() than with
4782 * something else (e.g., calling a shell).
4783 * After expanding environment variables, check again
4784 * if there are still wildcards present.
4785 */
4786 if (vim_strchr(eap->arg, '$') != NULL
4787 || vim_strchr(eap->arg, '~') != NULL)
4788 {
Bram Moolenaara1ba8112005-06-28 23:23:32 +00004789 expand_env_esc(eap->arg, NameBuff, MAXPATHL,
Bram Moolenaar9f0545d2007-09-26 20:36:32 +00004790 TRUE, TRUE, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004791 has_wildcards = mch_has_wildcard(NameBuff);
4792 p = NameBuff;
4793 }
4794 else
4795 p = NULL;
4796 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004797 else // n == 2
Bram Moolenaar071d4272004-06-13 20:20:40 +00004798 {
4799 expand_T xpc;
Bram Moolenaarb40c2572019-10-19 21:01:05 +02004800 int options = WILD_LIST_NOTFOUND
4801 | WILD_NOERROR | WILD_ADD_SLASH;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004802
4803 ExpandInit(&xpc);
4804 xpc.xp_context = EXPAND_FILES;
Bram Moolenaar94950a92010-12-02 16:01:29 +01004805 if (p_wic)
4806 options += WILD_ICASE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004807 p = ExpandOne(&xpc, eap->arg, NULL,
Bram Moolenaar94950a92010-12-02 16:01:29 +01004808 options, WILD_EXPAND_FREE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004809 if (p == NULL)
4810 return FAIL;
4811 }
4812 if (p != NULL)
4813 {
4814 (void)repl_cmdline(eap, eap->arg, (int)STRLEN(eap->arg),
4815 p, cmdlinep);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004816 if (n == 2) // p came from ExpandOne()
Bram Moolenaar071d4272004-06-13 20:20:40 +00004817 vim_free(p);
4818 }
4819 }
4820 }
4821 }
4822 return OK;
4823}
4824
4825/*
4826 * Replace part of the command line, keeping eap->cmd, eap->arg and
4827 * eap->nextcmd correct.
4828 * "src" points to the part that is to be replaced, of length "srclen".
4829 * "repl" is the replacement string.
4830 * Returns a pointer to the character after the replaced string.
4831 * Returns NULL for failure.
4832 */
4833 static char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004834repl_cmdline(
4835 exarg_T *eap,
4836 char_u *src,
4837 int srclen,
4838 char_u *repl,
4839 char_u **cmdlinep)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004840{
4841 int len;
4842 int i;
4843 char_u *new_cmdline;
4844
4845 /*
4846 * The new command line is build in new_cmdline[].
4847 * First allocate it.
4848 * Careful: a "+cmd" argument may have been NUL terminated.
4849 */
4850 len = (int)STRLEN(repl);
4851 i = (int)(src - *cmdlinep) + (int)STRLEN(src + srclen) + len + 3;
Bram Moolenaare1438bb2006-03-01 22:01:55 +00004852 if (eap->nextcmd != NULL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004853 i += (int)STRLEN(eap->nextcmd);// add space for next command
Bram Moolenaar964b3742019-05-24 18:54:09 +02004854 if ((new_cmdline = alloc(i)) == NULL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004855 return NULL; // out of memory!
Bram Moolenaar071d4272004-06-13 20:20:40 +00004856
4857 /*
4858 * Copy the stuff before the expanded part.
4859 * Copy the expanded stuff.
4860 * Copy what came after the expanded part.
4861 * Copy the next commands, if there are any.
4862 */
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004863 i = (int)(src - *cmdlinep); // length of part before match
Bram Moolenaar071d4272004-06-13 20:20:40 +00004864 mch_memmove(new_cmdline, *cmdlinep, (size_t)i);
Bram Moolenaara3ffd9c2005-07-21 21:03:15 +00004865
Bram Moolenaar071d4272004-06-13 20:20:40 +00004866 mch_memmove(new_cmdline + i, repl, (size_t)len);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004867 i += len; // remember the end of the string
Bram Moolenaar071d4272004-06-13 20:20:40 +00004868 STRCPY(new_cmdline + i, src + srclen);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004869 src = new_cmdline + i; // remember where to continue
Bram Moolenaar071d4272004-06-13 20:20:40 +00004870
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004871 if (eap->nextcmd != NULL) // append next command
Bram Moolenaar071d4272004-06-13 20:20:40 +00004872 {
4873 i = (int)STRLEN(new_cmdline) + 1;
4874 STRCPY(new_cmdline + i, eap->nextcmd);
4875 eap->nextcmd = new_cmdline + i;
4876 }
4877 eap->cmd = new_cmdline + (eap->cmd - *cmdlinep);
4878 eap->arg = new_cmdline + (eap->arg - *cmdlinep);
4879 if (eap->do_ecmd_cmd != NULL && eap->do_ecmd_cmd != dollar_command)
4880 eap->do_ecmd_cmd = new_cmdline + (eap->do_ecmd_cmd - *cmdlinep);
4881 vim_free(*cmdlinep);
4882 *cmdlinep = new_cmdline;
4883
4884 return src;
4885}
4886
4887/*
4888 * Check for '|' to separate commands and '"' to start comments.
4889 */
4890 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004891separate_nextcmd(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004892{
4893 char_u *p;
4894
Bram Moolenaar86b68352004-12-27 21:59:20 +00004895#ifdef FEAT_QUICKFIX
Bram Moolenaar748bf032005-02-02 23:04:36 +00004896 p = skip_grep_pat(eap);
4897#else
4898 p = eap->arg;
Bram Moolenaar86b68352004-12-27 21:59:20 +00004899#endif
4900
Bram Moolenaar91acfff2017-03-12 19:22:36 +01004901 for ( ; *p; MB_PTR_ADV(p))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004902 {
4903 if (*p == Ctrl_V)
4904 {
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004905 if (eap->argt & (EX_CTRLV | EX_XFILE))
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004906 ++p; // skip CTRL-V and next char
Bram Moolenaar071d4272004-06-13 20:20:40 +00004907 else
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004908 // remove CTRL-V and skip next char
Bram Moolenaara7241f52008-06-24 20:39:31 +00004909 STRMOVE(p, p + 1);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004910 if (*p == NUL) // stop at NUL after CTRL-V
Bram Moolenaar071d4272004-06-13 20:20:40 +00004911 break;
4912 }
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004913
4914#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004915 // Skip over `=expr` when wildcards are expanded.
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004916 else if (p[0] == '`' && p[1] == '=' && (eap->argt & EX_XFILE))
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004917 {
4918 p += 2;
Bram Moolenaar683581e2020-10-22 21:22:58 +02004919 (void)skip_expr(&p, NULL);
Bram Moolenaarcaf73dc2020-10-26 21:39:13 +01004920 if (*p == NUL) // stop at NUL after CTRL-V
4921 break;
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004922 }
4923#endif
4924
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004925 // Check for '"': start of comment or '|': next command
4926 // :@" and :*" do not start a comment!
4927 // :redir @" doesn't either.
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02004928 else if ((*p == '"'
Bram Moolenaara26b9702020-04-18 19:53:28 +02004929#ifdef FEAT_EVAL
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02004930 && !in_vim9script()
4931#endif
4932 && !(eap->argt & EX_NOTRLCOM)
4933 && ((eap->cmdidx != CMD_at && eap->cmdidx != CMD_star)
4934 || p != eap->arg)
4935 && (eap->cmdidx != CMD_redir
4936 || p != eap->arg + 1 || p[-1] != '@'))
4937#ifdef FEAT_EVAL
4938 || (*p == '#'
4939 && in_vim9script()
Bram Moolenaarb8a92962020-08-20 18:02:47 +02004940 && !(eap->argt & EX_NOTRLCOM)
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02004941 && p > eap->cmd && VIM_ISWHITE(p[-1]))
Bram Moolenaara26b9702020-04-18 19:53:28 +02004942#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004943 || *p == '|' || *p == '\n')
4944 {
4945 /*
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004946 * We remove the '\' before the '|', unless EX_CTRLV is used
Bram Moolenaar071d4272004-06-13 20:20:40 +00004947 * AND 'b' is present in 'cpoptions'.
4948 */
4949 if ((vim_strchr(p_cpo, CPO_BAR) == NULL
Bram Moolenaar8071cb22019-07-12 17:58:01 +02004950 || !(eap->argt & EX_CTRLV)) && *(p - 1) == '\\')
Bram Moolenaar071d4272004-06-13 20:20:40 +00004951 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004952 STRMOVE(p - 1, p); // remove the '\'
Bram Moolenaar071d4272004-06-13 20:20:40 +00004953 --p;
4954 }
4955 else
4956 {
4957 eap->nextcmd = check_nextcmd(p);
4958 *p = NUL;
4959 break;
4960 }
4961 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004962 }
Bram Moolenaar86b68352004-12-27 21:59:20 +00004963
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004964 if (!(eap->argt & EX_NOTRLCOM)) // remove trailing spaces
Bram Moolenaar071d4272004-06-13 20:20:40 +00004965 del_trailing_spaces(eap->arg);
4966}
4967
4968/*
4969 * get + command from ex argument
4970 */
4971 static char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01004972getargcmd(char_u **argp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004973{
4974 char_u *arg = *argp;
4975 char_u *command = NULL;
4976
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004977 if (*arg == '+') // +[command]
Bram Moolenaar071d4272004-06-13 20:20:40 +00004978 {
4979 ++arg;
Bram Moolenaar3e451592014-04-02 14:22:05 +02004980 if (vim_isspace(*arg) || *arg == NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004981 command = dollar_command;
4982 else
4983 {
4984 command = arg;
4985 arg = skip_cmd_arg(command, TRUE);
4986 if (*arg != NUL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004987 *arg++ = NUL; // terminate command with NUL
Bram Moolenaar071d4272004-06-13 20:20:40 +00004988 }
4989
Bram Moolenaar217e1b82019-12-01 21:41:28 +01004990 arg = skipwhite(arg); // skip over spaces
Bram Moolenaar071d4272004-06-13 20:20:40 +00004991 *argp = arg;
4992 }
4993 return command;
4994}
4995
4996/*
4997 * Find end of "+command" argument. Skip over "\ " and "\\".
4998 */
Bram Moolenaard0190392019-08-23 21:17:35 +02004999 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005000skip_cmd_arg(
5001 char_u *p,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005002 int rembs) // TRUE to halve the number of backslashes
Bram Moolenaar071d4272004-06-13 20:20:40 +00005003{
5004 while (*p && !vim_isspace(*p))
5005 {
5006 if (*p == '\\' && p[1] != NUL)
5007 {
5008 if (rembs)
Bram Moolenaara7241f52008-06-24 20:39:31 +00005009 STRMOVE(p, p + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005010 else
5011 ++p;
5012 }
Bram Moolenaar91acfff2017-03-12 19:22:36 +01005013 MB_PTR_ADV(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005014 }
5015 return p;
5016}
5017
Bram Moolenaar333b80a2018-04-04 22:57:29 +02005018 int
5019get_bad_opt(char_u *p, exarg_T *eap)
5020{
5021 if (STRICMP(p, "keep") == 0)
5022 eap->bad_char = BAD_KEEP;
5023 else if (STRICMP(p, "drop") == 0)
5024 eap->bad_char = BAD_DROP;
5025 else if (MB_BYTE2LEN(*p) == 1 && p[1] == NUL)
5026 eap->bad_char = *p;
Bram Moolenaar75808492018-06-12 12:39:41 +02005027 else
5028 return FAIL;
5029 return OK;
Bram Moolenaar333b80a2018-04-04 22:57:29 +02005030}
5031
Bram Moolenaar071d4272004-06-13 20:20:40 +00005032/*
5033 * Get "++opt=arg" argument.
5034 * Return FAIL or OK.
5035 */
5036 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005037getargopt(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005038{
5039 char_u *arg = eap->arg + 2;
5040 int *pp = NULL;
Bram Moolenaar34b4daf2010-05-16 13:26:25 +02005041 int bad_char_idx;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005042 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005043
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005044 // ":edit ++[no]bin[ary] file"
Bram Moolenaar071d4272004-06-13 20:20:40 +00005045 if (STRNCMP(arg, "bin", 3) == 0 || STRNCMP(arg, "nobin", 5) == 0)
5046 {
5047 if (*arg == 'n')
5048 {
5049 arg += 2;
5050 eap->force_bin = FORCE_NOBIN;
5051 }
5052 else
5053 eap->force_bin = FORCE_BIN;
5054 if (!checkforcmd(&arg, "binary", 3))
5055 return FAIL;
5056 eap->arg = skipwhite(arg);
5057 return OK;
5058 }
5059
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005060 // ":read ++edit file"
Bram Moolenaar910f66f2006-04-05 20:41:53 +00005061 if (STRNCMP(arg, "edit", 4) == 0)
5062 {
5063 eap->read_edit = TRUE;
5064 eap->arg = skipwhite(arg + 4);
5065 return OK;
5066 }
5067
Bram Moolenaar071d4272004-06-13 20:20:40 +00005068 if (STRNCMP(arg, "ff", 2) == 0)
5069 {
5070 arg += 2;
5071 pp = &eap->force_ff;
5072 }
5073 else if (STRNCMP(arg, "fileformat", 10) == 0)
5074 {
5075 arg += 10;
5076 pp = &eap->force_ff;
5077 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005078 else if (STRNCMP(arg, "enc", 3) == 0)
5079 {
Bram Moolenaarb38e9ab2011-12-14 14:49:45 +01005080 if (STRNCMP(arg, "encoding", 8) == 0)
5081 arg += 8;
5082 else
5083 arg += 3;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005084 pp = &eap->force_enc;
5085 }
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00005086 else if (STRNCMP(arg, "bad", 3) == 0)
5087 {
5088 arg += 3;
Bram Moolenaar34b4daf2010-05-16 13:26:25 +02005089 pp = &bad_char_idx;
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00005090 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005091
5092 if (pp == NULL || *arg != '=')
5093 return FAIL;
5094
5095 ++arg;
5096 *pp = (int)(arg - eap->cmd);
5097 arg = skip_cmd_arg(arg, FALSE);
5098 eap->arg = skipwhite(arg);
5099 *arg = NUL;
5100
Bram Moolenaar071d4272004-06-13 20:20:40 +00005101 if (pp == &eap->force_ff)
5102 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00005103 if (check_ff_value(eap->cmd + eap->force_ff) == FAIL)
5104 return FAIL;
Bram Moolenaar333b80a2018-04-04 22:57:29 +02005105 eap->force_ff = eap->cmd[eap->force_ff];
Bram Moolenaar071d4272004-06-13 20:20:40 +00005106 }
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00005107 else if (pp == &eap->force_enc)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005108 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005109 // Make 'fileencoding' lower case.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005110 for (p = eap->cmd + eap->force_enc; *p != NUL; ++p)
5111 *p = TOLOWER_ASC(*p);
5112 }
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00005113 else
5114 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005115 // Check ++bad= argument. Must be a single-byte character, "keep" or
5116 // "drop".
Bram Moolenaar333b80a2018-04-04 22:57:29 +02005117 if (get_bad_opt(eap->cmd + bad_char_idx, eap) == FAIL)
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00005118 return FAIL;
5119 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005120
5121 return OK;
5122}
5123
Bram Moolenaar071d4272004-06-13 20:20:40 +00005124 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005125ex_autocmd(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005126{
5127 /*
Bram Moolenaar26d4b892018-07-04 22:26:28 +02005128 * Disallow autocommands from .exrc and .vimrc in current
Bram Moolenaar071d4272004-06-13 20:20:40 +00005129 * directory for security reasons.
5130 */
5131 if (secure)
5132 {
5133 secure = 2;
Bram Moolenaar8930caa2020-07-23 16:37:03 +02005134 eap->errmsg = _(e_curdir);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005135 }
5136 else if (eap->cmdidx == CMD_autocmd)
5137 do_autocmd(eap->arg, eap->forceit);
5138 else
5139 do_augroup(eap->arg, eap->forceit);
5140}
5141
5142/*
5143 * ":doautocmd": Apply the automatic commands to the current buffer.
5144 */
5145 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005146ex_doautocmd(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005147{
Bram Moolenaar60542ac2012-02-12 20:14:01 +01005148 char_u *arg = eap->arg;
5149 int call_do_modelines = check_nomodeline(&arg);
Bram Moolenaar1610d052016-06-09 22:53:01 +02005150 int did_aucmd;
Bram Moolenaar60542ac2012-02-12 20:14:01 +01005151
Bram Moolenaar1610d052016-06-09 22:53:01 +02005152 (void)do_doautocmd(arg, TRUE, &did_aucmd);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005153 // Only when there is no <nomodeline>.
Bram Moolenaar1610d052016-06-09 22:53:01 +02005154 if (call_do_modelines && did_aucmd)
Bram Moolenaar60542ac2012-02-12 20:14:01 +01005155 do_modelines(0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005156}
Bram Moolenaar071d4272004-06-13 20:20:40 +00005157
Bram Moolenaar071d4272004-06-13 20:20:40 +00005158/*
5159 * :[N]bunload[!] [N] [bufname] unload buffer
5160 * :[N]bdelete[!] [N] [bufname] delete buffer from buffer list
5161 * :[N]bwipeout[!] [N] [bufname] delete buffer really
5162 */
5163 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005164ex_bunload(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005165{
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01005166 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar815b76b2019-06-01 14:15:52 +02005167 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005168 eap->errmsg = do_bufdel(
5169 eap->cmdidx == CMD_bdelete ? DOBUF_DEL
5170 : eap->cmdidx == CMD_bwipeout ? DOBUF_WIPE
5171 : DOBUF_UNLOAD, eap->arg,
5172 eap->addr_count, (int)eap->line1, (int)eap->line2, eap->forceit);
5173}
5174
5175/*
5176 * :[N]buffer [N] to buffer N
5177 * :[N]sbuffer [N] to buffer N
5178 */
5179 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005180ex_buffer(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005181{
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01005182 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar815b76b2019-06-01 14:15:52 +02005183 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005184 if (*eap->arg)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02005185 eap->errmsg = ex_errmsg(e_trailing_arg, eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005186 else
5187 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005188 if (eap->addr_count == 0) // default is current buffer
Bram Moolenaar071d4272004-06-13 20:20:40 +00005189 goto_buffer(eap, DOBUF_CURRENT, FORWARD, 0);
5190 else
5191 goto_buffer(eap, DOBUF_FIRST, FORWARD, (int)eap->line2);
Bram Moolenaar9c8d9e12014-09-19 20:07:26 +02005192 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01005193 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005194 }
5195}
5196
5197/*
5198 * :[N]bmodified [N] to next mod. buffer
5199 * :[N]sbmodified [N] to next mod. buffer
5200 */
5201 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005202ex_bmodified(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005203{
5204 goto_buffer(eap, DOBUF_MOD, FORWARD, (int)eap->line2);
Bram Moolenaar9c8d9e12014-09-19 20:07:26 +02005205 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01005206 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005207}
5208
5209/*
5210 * :[N]bnext [N] to next buffer
5211 * :[N]sbnext [N] split and to next buffer
5212 */
5213 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005214ex_bnext(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005215{
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01005216 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar3029bcc2020-01-18 15:06:19 +01005217 return;
5218
Bram Moolenaar071d4272004-06-13 20:20:40 +00005219 goto_buffer(eap, DOBUF_CURRENT, FORWARD, (int)eap->line2);
Bram Moolenaar9c8d9e12014-09-19 20:07:26 +02005220 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01005221 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005222}
5223
5224/*
5225 * :[N]bNext [N] to previous buffer
5226 * :[N]bprevious [N] to previous buffer
5227 * :[N]sbNext [N] split and to previous buffer
5228 * :[N]sbprevious [N] split and to previous buffer
5229 */
5230 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005231ex_bprevious(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005232{
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01005233 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar3029bcc2020-01-18 15:06:19 +01005234 return;
5235
Bram Moolenaar071d4272004-06-13 20:20:40 +00005236 goto_buffer(eap, DOBUF_CURRENT, BACKWARD, (int)eap->line2);
Bram Moolenaar9c8d9e12014-09-19 20:07:26 +02005237 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01005238 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005239}
5240
5241/*
5242 * :brewind to first buffer
5243 * :bfirst to first buffer
5244 * :sbrewind split and to first buffer
5245 * :sbfirst split and to first buffer
5246 */
5247 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005248ex_brewind(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005249{
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01005250 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar3029bcc2020-01-18 15:06:19 +01005251 return;
5252
Bram Moolenaar071d4272004-06-13 20:20:40 +00005253 goto_buffer(eap, DOBUF_FIRST, FORWARD, 0);
Bram Moolenaar9c8d9e12014-09-19 20:07:26 +02005254 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01005255 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005256}
5257
5258/*
5259 * :blast to last buffer
5260 * :sblast split and to last buffer
5261 */
5262 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005263ex_blast(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005264{
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01005265 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar3029bcc2020-01-18 15:06:19 +01005266 return;
5267
Bram Moolenaar071d4272004-06-13 20:20:40 +00005268 goto_buffer(eap, DOBUF_LAST, BACKWARD, 0);
Bram Moolenaar9c8d9e12014-09-19 20:07:26 +02005269 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01005270 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005271}
Bram Moolenaar071d4272004-06-13 20:20:40 +00005272
Bram Moolenaar7a092242020-04-16 22:10:49 +02005273/*
5274 * Check if "c" ends an Ex command.
Bram Moolenaarb5b94802020-12-13 17:50:20 +01005275 * In Vim9 script does not check for white space before #.
Bram Moolenaar7a092242020-04-16 22:10:49 +02005276 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005277 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005278ends_excmd(int c)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005279{
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005280 int comment_char = '"';
5281
Bram Moolenaarfbda69b2020-04-13 15:06:53 +02005282#ifdef FEAT_EVAL
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005283 if (in_vim9script())
5284 comment_char = '#';
Bram Moolenaar7a092242020-04-16 22:10:49 +02005285#endif
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005286 return (c == NUL || c == '|' || c == comment_char || c == '\n');
Bram Moolenaar7a092242020-04-16 22:10:49 +02005287}
5288
5289/*
5290 * Like ends_excmd() but checks that a # in Vim9 script either has "cmd" equal
5291 * to "cmd_start" or has a white space character before it.
5292 */
5293 int
Bram Moolenaar21cfe502020-04-16 23:01:50 +02005294ends_excmd2(char_u *cmd_start UNUSED, char_u *cmd)
Bram Moolenaar7a092242020-04-16 22:10:49 +02005295{
5296 int c = *cmd;
5297
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005298 if (c == NUL || c == '|' || c == '\n')
5299 return TRUE;
Bram Moolenaar7a092242020-04-16 22:10:49 +02005300#ifdef FEAT_EVAL
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005301 if (in_vim9script())
Bram Moolenaara0399ef2021-03-20 15:00:01 +01005302 // # starts a comment, #{ might be a mistake, #{{ can start a fold
5303 return c == '#' && (cmd[1] != '{' || cmd[2] == '{')
Bram Moolenaar5c7a2992021-03-20 13:29:38 +01005304 && (cmd == cmd_start || VIM_ISWHITE(cmd[-1]));
Bram Moolenaarfbda69b2020-04-13 15:06:53 +02005305#endif
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02005306 return c == '"';
Bram Moolenaar071d4272004-06-13 20:20:40 +00005307}
5308
5309#if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA) || defined(FEAT_EVAL) \
5310 || defined(PROTO)
5311/*
5312 * Return the next command, after the first '|' or '\n'.
5313 * Return NULL if not found.
5314 */
5315 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005316find_nextcmd(char_u *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005317{
5318 while (*p != '|' && *p != '\n')
5319 {
5320 if (*p == NUL)
5321 return NULL;
5322 ++p;
5323 }
5324 return (p + 1);
5325}
5326#endif
5327
5328/*
Bram Moolenaar2256c992016-11-15 21:17:07 +01005329 * Check if *p is a separator between Ex commands, skipping over white space.
5330 * Return NULL if it isn't, the following character if it is.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005331 */
5332 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005333check_nextcmd(char_u *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005334{
Bram Moolenaar2256c992016-11-15 21:17:07 +01005335 char_u *s = skipwhite(p);
5336
5337 if (*s == '|' || *s == '\n')
5338 return (s + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005339 else
5340 return NULL;
5341}
5342
5343/*
5344 * - if there are more files to edit
5345 * - and this is the last window
5346 * - and forceit not used
5347 * - and not repeated twice on a row
5348 * return FAIL and give error message if 'message' TRUE
5349 * return OK otherwise
5350 */
5351 static int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005352check_more(
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005353 int message, // when FALSE check only, no messages
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005354 int forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005355{
5356 int n = ARGCOUNT - curwin->w_arg_idx - 1;
5357
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005358 if (!forceit && only_one_window()
Bram Moolenaar7b221172020-08-17 19:34:10 +02005359 && ARGCOUNT > 1 && !arg_had_last && n > 0 && quitmore == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005360 {
5361 if (message)
5362 {
5363#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
Bram Moolenaare1004402020-10-24 20:49:43 +02005364 if ((p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM))
5365 && curbuf->b_fname != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005366 {
Bram Moolenaard9462e32011-04-11 21:35:11 +02005367 char_u buff[DIALOG_MSG_SIZE];
Bram Moolenaar071d4272004-06-13 20:20:40 +00005368
Bram Moolenaarda6e8912018-08-21 15:12:14 +02005369 vim_snprintf((char *)buff, DIALOG_MSG_SIZE,
5370 NGETTEXT("%d more file to edit. Quit anyway?",
5371 "%d more files to edit. Quit anyway?", n), n);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005372 if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 1) == VIM_YES)
5373 return OK;
5374 return FAIL;
5375 }
5376#endif
Bram Moolenaarb5443cc2019-01-15 20:19:40 +01005377 semsg(NGETTEXT("E173: %d more file to edit",
5378 "E173: %d more files to edit", n), n);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005379 quitmore = 2; // next try to quit is allowed
Bram Moolenaar071d4272004-06-13 20:20:40 +00005380 }
5381 return FAIL;
5382 }
5383 return OK;
5384}
5385
Bram Moolenaar071d4272004-06-13 20:20:40 +00005386/*
5387 * Function given to ExpandGeneric() to obtain the list of command names.
5388 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005389 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005390get_command_name(expand_T *xp UNUSED, int idx)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005391{
5392 if (idx >= (int)CMD_SIZE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005393 return get_user_command_name(idx);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005394 return cmdnames[idx].cmd_name;
5395}
Bram Moolenaar071d4272004-06-13 20:20:40 +00005396
Bram Moolenaar071d4272004-06-13 20:20:40 +00005397 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005398ex_colorscheme(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005399{
Bram Moolenaare6850792010-05-14 15:28:44 +02005400 if (*eap->arg == NUL)
5401 {
5402#ifdef FEAT_EVAL
5403 char_u *expr = vim_strsave((char_u *)"g:colors_name");
5404 char_u *p = NULL;
5405
5406 if (expr != NULL)
5407 {
5408 ++emsg_off;
Bram Moolenaarb171fb12020-06-24 20:34:03 +02005409 p = eval_to_string(expr, FALSE);
Bram Moolenaare6850792010-05-14 15:28:44 +02005410 --emsg_off;
5411 vim_free(expr);
5412 }
5413 if (p != NULL)
5414 {
Bram Moolenaar32526b32019-01-19 17:43:09 +01005415 msg((char *)p);
Bram Moolenaare6850792010-05-14 15:28:44 +02005416 vim_free(p);
5417 }
5418 else
Bram Moolenaar32526b32019-01-19 17:43:09 +01005419 msg("default");
Bram Moolenaare6850792010-05-14 15:28:44 +02005420#else
Bram Moolenaar32526b32019-01-19 17:43:09 +01005421 msg(_("unknown"));
Bram Moolenaare6850792010-05-14 15:28:44 +02005422#endif
5423 }
5424 else if (load_colors(eap->arg) == FAIL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005425 semsg(_("E185: Cannot find color scheme '%s'"), eap->arg);
Bram Moolenaarf58d81a2019-01-28 20:19:05 +01005426
5427#ifdef FEAT_VTP
5428 else if (has_vtp_working())
5429 {
5430 // background color change requires clear + redraw
5431 update_screen(CLEAR);
5432 redrawcmd();
5433 }
5434#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005435}
5436
5437 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005438ex_highlight(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005439{
5440 if (*eap->arg == NUL && eap->cmd[2] == '!')
Bram Moolenaar32526b32019-01-19 17:43:09 +01005441 msg(_("Greetings, Vim user!"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00005442 do_highlight(eap->arg, eap->forceit, FALSE);
5443}
5444
5445
5446/*
5447 * Call this function if we thought we were going to exit, but we won't
5448 * (because of an error). May need to restore the terminal mode.
5449 */
5450 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005451not_exiting(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005452{
5453 exiting = FALSE;
5454 settmode(TMODE_RAW);
5455}
5456
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005457 static int
5458before_quit_autocmds(win_T *wp, int quit_all, int forceit)
5459{
5460 apply_autocmds(EVENT_QUITPRE, NULL, NULL, FALSE, wp->w_buffer);
5461
Bram Moolenaar34ba06b2019-10-20 22:27:10 +02005462 // Bail out when autocommands closed the window.
5463 // Refuse to quit when the buffer in the last window is being closed (can
5464 // only happen in autocommands).
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005465 if (!win_valid(wp)
5466 || curbuf_locked()
5467 || (wp->w_buffer->b_nwindows == 1 && wp->w_buffer->b_locked > 0))
5468 return TRUE;
5469
5470 if (quit_all || (check_more(FALSE, forceit) == OK && only_one_window()))
5471 {
5472 apply_autocmds(EVENT_EXITPRE, NULL, NULL, FALSE, curbuf);
Bram Moolenaar34ba06b2019-10-20 22:27:10 +02005473 // Refuse to quit when locked or when the window was closed or the
5474 // buffer in the last window is being closed (can only happen in
5475 // autocommands).
5476 if (!win_valid(wp) || curbuf_locked()
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005477 || (curbuf->b_nwindows == 1 && curbuf->b_locked > 0))
5478 return TRUE;
5479 }
5480
5481 return FALSE;
5482}
5483
Bram Moolenaar071d4272004-06-13 20:20:40 +00005484/*
Bram Moolenaarf240e182014-11-27 18:33:02 +01005485 * ":quit": quit current window, quit Vim if the last window is closed.
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005486 * ":{nr}quit": quit window {nr}
Bram Moolenaar4d14bac2019-10-20 21:15:15 +02005487 * Also used when closing a terminal window that's the last one.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005488 */
Bram Moolenaar4d14bac2019-10-20 21:15:15 +02005489 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005490ex_quit(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005491{
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005492 win_T *wp;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005493
Bram Moolenaar071d4272004-06-13 20:20:40 +00005494#ifdef FEAT_CMDWIN
5495 if (cmdwin_type != 0)
5496 {
5497 cmdwin_result = Ctrl_C;
5498 return;
5499 }
5500#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005501 // Don't quit while editing the command line.
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00005502 if (text_locked())
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00005503 {
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00005504 text_locked_msg();
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00005505 return;
5506 }
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005507 if (eap->addr_count > 0)
5508 {
Bram Moolenaarf240e182014-11-27 18:33:02 +01005509 int wnr = eap->line2;
5510
5511 for (wp = firstwin; wp->w_next != NULL; wp = wp->w_next)
5512 if (--wnr <= 0)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005513 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005514 }
5515 else
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005516 wp = curwin;
Bram Moolenaarf240e182014-11-27 18:33:02 +01005517
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005518 // Refuse to quit when locked.
Bram Moolenaar87ffb5c2017-10-19 12:37:42 +02005519 if (curbuf_locked())
5520 return;
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005521
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005522 // Trigger QuitPre and maybe ExitPre
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005523 if (before_quit_autocmds(wp, FALSE, eap->forceit))
Bram Moolenaar910f66f2006-04-05 20:41:53 +00005524 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005525
5526#ifdef FEAT_NETBEANS_INTG
5527 netbeansForcedQuit = eap->forceit;
5528#endif
5529
5530 /*
5531 * If there are more files or windows we won't exit.
5532 */
5533 if (check_more(FALSE, eap->forceit) == OK && only_one_window())
5534 exiting = TRUE;
Bram Moolenaarff930ca2017-10-19 17:12:10 +02005535 if ((!buf_hide(wp->w_buffer)
5536 && check_changed(wp->w_buffer, (p_awa ? CCGD_AW : 0)
Bram Moolenaar45d3b142013-11-09 03:31:51 +01005537 | (eap->forceit ? CCGD_FORCEIT : 0)
5538 | CCGD_EXCMD))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005539 || check_more(TRUE, eap->forceit) == FAIL
Bram Moolenaar027387f2016-01-02 22:25:52 +01005540 || (only_one_window() && check_changed_any(eap->forceit, TRUE)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005541 {
5542 not_exiting();
5543 }
5544 else
5545 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005546 // quit last window
5547 // Note: only_one_window() returns true, even so a help window is
5548 // still open. In that case only quit, if no address has been
5549 // specified. Example:
5550 // :h|wincmd w|1q - don't quit
5551 // :h|wincmd w|q - quit
Bram Moolenaara1f4cb92016-11-06 15:25:42 +01005552 if (only_one_window() && (ONE_WINDOW || eap->addr_count == 0))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005553 getout(0);
Bram Moolenaar2c33d7b2017-10-14 16:06:20 +02005554 not_exiting();
Bram Moolenaar4033c552017-09-16 20:54:51 +02005555#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00005556 need_mouse_correct = TRUE;
Bram Moolenaar4033c552017-09-16 20:54:51 +02005557#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005558 // close window; may free buffer
Bram Moolenaareb44a682017-08-03 22:44:55 +02005559 win_close(wp, !buf_hide(wp->w_buffer) || eap->forceit);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005560 }
5561}
5562
5563/*
5564 * ":cquit".
5565 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005566 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005567ex_cquit(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005568{
Bram Moolenaar1860bde2020-01-06 21:47:21 +01005569 // this does not always pass on the exit code to the Manx compiler. why?
5570 getout(eap->addr_count > 0 ? (int)eap->line2 : EXIT_FAILURE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005571}
5572
5573/*
5574 * ":qall": try to quit all windows
5575 */
5576 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005577ex_quit_all(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005578{
5579# ifdef FEAT_CMDWIN
5580 if (cmdwin_type != 0)
5581 {
5582 if (eap->forceit)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005583 cmdwin_result = K_XF1; // ex_window() takes care of this
Bram Moolenaar071d4272004-06-13 20:20:40 +00005584 else
5585 cmdwin_result = K_XF2;
5586 return;
5587 }
5588# endif
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00005589
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005590 // Don't quit while editing the command line.
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00005591 if (text_locked())
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00005592 {
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00005593 text_locked_msg();
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00005594 return;
5595 }
Bram Moolenaar12a96de2018-03-11 14:44:18 +01005596
5597 if (before_quit_autocmds(curwin, TRUE, eap->forceit))
Bram Moolenaar910f66f2006-04-05 20:41:53 +00005598 return;
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00005599
Bram Moolenaar071d4272004-06-13 20:20:40 +00005600 exiting = TRUE;
Bram Moolenaar027387f2016-01-02 22:25:52 +01005601 if (eap->forceit || !check_changed_any(FALSE, FALSE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005602 getout(0);
5603 not_exiting();
5604}
5605
Bram Moolenaar071d4272004-06-13 20:20:40 +00005606/*
5607 * ":close": close current window, unless it is the last one
5608 */
5609 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005610ex_close(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005611{
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005612 win_T *win;
5613 int winnr = 0;
Bram Moolenaar4033c552017-09-16 20:54:51 +02005614#ifdef FEAT_CMDWIN
Bram Moolenaar071d4272004-06-13 20:20:40 +00005615 if (cmdwin_type != 0)
Bram Moolenaar9bd1a7e2011-05-19 14:50:54 +02005616 cmdwin_result = Ctrl_C;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005617 else
Bram Moolenaar4033c552017-09-16 20:54:51 +02005618#endif
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01005619 if (!text_locked() && !curbuf_locked())
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005620 {
5621 if (eap->addr_count == 0)
5622 ex_win_close(eap->forceit, curwin, NULL);
Bram Moolenaar6d41c782018-06-06 09:11:12 +02005623 else
5624 {
Bram Moolenaar29323592016-07-24 22:04:11 +02005625 FOR_ALL_WINDOWS(win)
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005626 {
5627 winnr++;
5628 if (winnr == eap->line2)
5629 break;
5630 }
5631 if (win == NULL)
5632 win = lastwin;
5633 ex_win_close(eap->forceit, win, NULL);
5634 }
5635 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005636}
5637
Bram Moolenaar4033c552017-09-16 20:54:51 +02005638#ifdef FEAT_QUICKFIX
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005639/*
5640 * ":pclose": Close any preview window.
5641 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005642 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005643ex_pclose(exarg_T *eap)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005644{
5645 win_T *win;
5646
Bram Moolenaar79648732019-07-18 21:43:07 +02005647 // First close any normal window.
Bram Moolenaar29323592016-07-24 22:04:11 +02005648 FOR_ALL_WINDOWS(win)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005649 if (win->w_p_pvw)
5650 {
Bram Moolenaarf740b292006-02-16 22:11:02 +00005651 ex_win_close(eap->forceit, win, NULL);
Bram Moolenaar79648732019-07-18 21:43:07 +02005652 return;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005653 }
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01005654# ifdef FEAT_PROP_POPUP
Bram Moolenaar79648732019-07-18 21:43:07 +02005655 // Also when 'previewpopup' is empty, it might have been cleared.
Bram Moolenaarc7c5f102019-08-21 18:31:03 +02005656 popup_close_preview();
Bram Moolenaar79648732019-07-18 21:43:07 +02005657# endif
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005658}
Bram Moolenaar4033c552017-09-16 20:54:51 +02005659#endif
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005660
Bram Moolenaarf740b292006-02-16 22:11:02 +00005661/*
5662 * Close window "win" and take care of handling closing the last window for a
5663 * modified buffer.
5664 */
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005665 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005666ex_win_close(
5667 int forceit,
5668 win_T *win,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005669 tabpage_T *tp) // NULL or the tab page "win" is in
Bram Moolenaar071d4272004-06-13 20:20:40 +00005670{
5671 int need_hide;
5672 buf_T *buf = win->w_buffer;
5673
Bram Moolenaarcf844172020-06-26 19:44:06 +02005674 // Never close the autocommand window.
5675 if (win == aucmd_win)
5676 {
5677 emsg(_(e_autocmd_close));
5678 return;
5679 }
5680
Bram Moolenaar071d4272004-06-13 20:20:40 +00005681 need_hide = (bufIsChanged(buf) && buf->b_nwindows <= 1);
Bram Moolenaareb44a682017-08-03 22:44:55 +02005682 if (need_hide && !buf_hide(buf) && !forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005683 {
Bram Moolenaar4033c552017-09-16 20:54:51 +02005684#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
Bram Moolenaare1004402020-10-24 20:49:43 +02005685 if ((p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM)) && p_write)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005686 {
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02005687 bufref_T bufref;
5688
5689 set_bufref(&bufref, buf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005690 dialog_changed(buf, FALSE);
Bram Moolenaar7c0a2f32016-07-10 22:11:16 +02005691 if (bufref_valid(&bufref) && bufIsChanged(buf))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005692 return;
5693 need_hide = FALSE;
5694 }
5695 else
Bram Moolenaar4033c552017-09-16 20:54:51 +02005696#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005697 {
Bram Moolenaarf5be7cd2017-08-17 16:55:13 +02005698 no_write_message();
Bram Moolenaar071d4272004-06-13 20:20:40 +00005699 return;
5700 }
5701 }
5702
Bram Moolenaar4033c552017-09-16 20:54:51 +02005703#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00005704 need_mouse_correct = TRUE;
Bram Moolenaar4033c552017-09-16 20:54:51 +02005705#endif
Bram Moolenaarf740b292006-02-16 22:11:02 +00005706
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005707 // free buffer when not hiding it or when it's a scratch buffer
Bram Moolenaarf740b292006-02-16 22:11:02 +00005708 if (tp == NULL)
Bram Moolenaareb44a682017-08-03 22:44:55 +02005709 win_close(win, !need_hide && !buf_hide(buf));
Bram Moolenaarf740b292006-02-16 22:11:02 +00005710 else
Bram Moolenaareb44a682017-08-03 22:44:55 +02005711 win_close_othertab(win, !need_hide && !buf_hide(buf), tp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005712}
5713
Bram Moolenaar071d4272004-06-13 20:20:40 +00005714/*
Bram Moolenaardea25702017-01-29 15:18:10 +01005715 * Handle the argument for a tabpage related ex command.
5716 * Returns a tabpage number.
5717 * When an error is encountered then eap->errmsg is set.
5718 */
5719 static int
5720get_tabpage_arg(exarg_T *eap)
5721{
5722 int tab_number;
5723 int unaccept_arg0 = (eap->cmdidx == CMD_tabmove) ? 0 : 1;
5724
5725 if (eap->arg && *eap->arg != NUL)
5726 {
5727 char_u *p = eap->arg;
5728 char_u *p_save;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005729 int relative = 0; // argument +N/-N means: go to N places to the
5730 // right/left relative to the current position.
Bram Moolenaardea25702017-01-29 15:18:10 +01005731
5732 if (*p == '-')
5733 {
5734 relative = -1;
5735 p++;
5736 }
5737 else if (*p == '+')
5738 {
5739 relative = 1;
5740 p++;
5741 }
5742
5743 p_save = p;
5744 tab_number = getdigits(&p);
5745
5746 if (relative == 0)
5747 {
5748 if (STRCMP(p, "$") == 0)
5749 tab_number = LAST_TAB_NR;
Bram Moolenaar94f4ffa2020-08-10 19:21:15 +02005750 else if (STRCMP(p, "#") == 0)
5751 if (valid_tabpage(lastused_tabpage))
5752 tab_number = tabpage_index(lastused_tabpage);
5753 else
5754 {
5755 eap->errmsg = ex_errmsg(e_invargval, eap->arg);
5756 tab_number = 0;
5757 goto theend;
5758 }
Bram Moolenaardea25702017-01-29 15:18:10 +01005759 else if (p == p_save || *p_save == '-' || *p != NUL
5760 || tab_number > LAST_TAB_NR)
5761 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005762 // No numbers as argument.
Bram Moolenaar8930caa2020-07-23 16:37:03 +02005763 eap->errmsg = ex_errmsg(e_invarg2, eap->arg);
Bram Moolenaardea25702017-01-29 15:18:10 +01005764 goto theend;
5765 }
5766 }
5767 else
5768 {
5769 if (*p_save == NUL)
5770 tab_number = 1;
5771 else if (p == p_save || *p_save == '-' || *p != NUL
5772 || tab_number == 0)
5773 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005774 // No numbers as argument.
Bram Moolenaar8930caa2020-07-23 16:37:03 +02005775 eap->errmsg = ex_errmsg(e_invarg2, eap->arg);
Bram Moolenaardea25702017-01-29 15:18:10 +01005776 goto theend;
5777 }
5778 tab_number = tab_number * relative + tabpage_index(curtab);
5779 if (!unaccept_arg0 && relative == -1)
5780 --tab_number;
5781 }
5782 if (tab_number < unaccept_arg0 || tab_number > LAST_TAB_NR)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02005783 eap->errmsg = ex_errmsg(e_invarg2, eap->arg);
Bram Moolenaardea25702017-01-29 15:18:10 +01005784 }
5785 else if (eap->addr_count > 0)
5786 {
5787 if (unaccept_arg0 && eap->line2 == 0)
Bram Moolenaarc6251552017-01-29 21:42:20 +01005788 {
Bram Moolenaar8930caa2020-07-23 16:37:03 +02005789 eap->errmsg = _(e_invrange);
Bram Moolenaarc6251552017-01-29 21:42:20 +01005790 tab_number = 0;
5791 }
Bram Moolenaardea25702017-01-29 15:18:10 +01005792 else
5793 {
5794 tab_number = eap->line2;
Bram Moolenaar82a12462019-01-22 22:41:42 +01005795 if (!unaccept_arg0 && *skipwhite(*eap->cmdlinep) == '-')
Bram Moolenaardea25702017-01-29 15:18:10 +01005796 {
5797 --tab_number;
5798 if (tab_number < unaccept_arg0)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02005799 eap->errmsg = _(e_invrange);
Bram Moolenaardea25702017-01-29 15:18:10 +01005800 }
5801 }
5802 }
5803 else
5804 {
5805 switch (eap->cmdidx)
5806 {
5807 case CMD_tabnext:
5808 tab_number = tabpage_index(curtab) + 1;
5809 if (tab_number > LAST_TAB_NR)
5810 tab_number = 1;
5811 break;
5812 case CMD_tabmove:
5813 tab_number = LAST_TAB_NR;
5814 break;
5815 default:
5816 tab_number = tabpage_index(curtab);
5817 }
5818 }
5819
5820theend:
5821 return tab_number;
5822}
5823
5824/*
Bram Moolenaarf740b292006-02-16 22:11:02 +00005825 * ":tabclose": close current tab page, unless it is the last one.
5826 * ":tabclose N": close tab page N.
Bram Moolenaar071d4272004-06-13 20:20:40 +00005827 */
5828 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005829ex_tabclose(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005830{
Bram Moolenaarf740b292006-02-16 22:11:02 +00005831 tabpage_T *tp;
Bram Moolenaar2f72c702017-01-29 14:48:10 +01005832 int tab_number;
Bram Moolenaarf740b292006-02-16 22:11:02 +00005833
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005834# ifdef FEAT_CMDWIN
5835 if (cmdwin_type != 0)
5836 cmdwin_result = K_IGNORE;
5837 else
5838# endif
Bram Moolenaarf740b292006-02-16 22:11:02 +00005839 if (first_tabpage->tp_next == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01005840 emsg(_("E784: Cannot close last tab page"));
Bram Moolenaarf740b292006-02-16 22:11:02 +00005841 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00005842 {
Bram Moolenaar2f72c702017-01-29 14:48:10 +01005843 tab_number = get_tabpage_arg(eap);
5844 if (eap->errmsg == NULL)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00005845 {
Bram Moolenaar2f72c702017-01-29 14:48:10 +01005846 tp = find_tabpage(tab_number);
Bram Moolenaarf740b292006-02-16 22:11:02 +00005847 if (tp == NULL)
5848 {
5849 beep_flush();
5850 return;
5851 }
Bram Moolenaar7e8fd632006-02-18 22:14:51 +00005852 if (tp != curtab)
Bram Moolenaarf740b292006-02-16 22:11:02 +00005853 {
5854 tabpage_close_other(tp, eap->forceit);
5855 return;
5856 }
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01005857 else if (!text_locked() && !curbuf_locked())
Bram Moolenaar2f72c702017-01-29 14:48:10 +01005858 tabpage_close(eap->forceit);
5859 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005860 }
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005861}
5862
5863/*
5864 * ":tabonly": close all tab pages except the current one
5865 */
5866 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005867ex_tabonly(exarg_T *eap)
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005868{
5869 tabpage_T *tp;
5870 int done;
Bram Moolenaar2f72c702017-01-29 14:48:10 +01005871 int tab_number;
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005872
5873# ifdef FEAT_CMDWIN
5874 if (cmdwin_type != 0)
5875 cmdwin_result = K_IGNORE;
5876 else
5877# endif
5878 if (first_tabpage->tp_next == NULL)
Bram Moolenaar32526b32019-01-19 17:43:09 +01005879 msg(_("Already only one tab page"));
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005880 else
5881 {
Bram Moolenaar2f72c702017-01-29 14:48:10 +01005882 tab_number = get_tabpage_arg(eap);
5883 if (eap->errmsg == NULL)
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005884 {
Bram Moolenaar2f72c702017-01-29 14:48:10 +01005885 goto_tabpage(tab_number);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005886 // Repeat this up to a 1000 times, because autocommands may
5887 // mess up the lists.
Bram Moolenaar2f72c702017-01-29 14:48:10 +01005888 for (done = 0; done < 1000; ++done)
5889 {
5890 FOR_ALL_TABPAGES(tp)
5891 if (tp->tp_topframe != topframe)
5892 {
5893 tabpage_close_other(tp, eap->forceit);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005894 // if we failed to close it quit
Bram Moolenaar2f72c702017-01-29 14:48:10 +01005895 if (valid_tabpage(tp))
5896 done = 1000;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005897 // start over, "tp" is now invalid
Bram Moolenaar2f72c702017-01-29 14:48:10 +01005898 break;
5899 }
5900 if (first_tabpage->tp_next == NULL)
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005901 break;
Bram Moolenaar2f72c702017-01-29 14:48:10 +01005902 }
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005903 }
5904 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005905}
Bram Moolenaar071d4272004-06-13 20:20:40 +00005906
5907/*
Bram Moolenaarf740b292006-02-16 22:11:02 +00005908 * Close the current tab page.
5909 */
5910 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005911tabpage_close(int forceit)
Bram Moolenaarf740b292006-02-16 22:11:02 +00005912{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005913 // First close all the windows but the current one. If that worked then
5914 // close the last window in this tab, that will close it.
Bram Moolenaar459ca562016-11-10 18:16:33 +01005915 if (!ONE_WINDOW)
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00005916 close_others(TRUE, forceit);
Bram Moolenaar459ca562016-11-10 18:16:33 +01005917 if (ONE_WINDOW)
Bram Moolenaarf740b292006-02-16 22:11:02 +00005918 ex_win_close(forceit, curwin, NULL);
5919# ifdef FEAT_GUI
5920 need_mouse_correct = TRUE;
5921# endif
5922}
5923
5924/*
5925 * Close tab page "tp", which is not the current tab page.
5926 * Note that autocommands may make "tp" invalid.
Bram Moolenaar7875acc2006-09-10 13:51:17 +00005927 * Also takes care of the tab pages line disappearing when closing the
5928 * last-but-one tab page.
Bram Moolenaarf740b292006-02-16 22:11:02 +00005929 */
5930 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005931tabpage_close_other(tabpage_T *tp, int forceit)
Bram Moolenaarf740b292006-02-16 22:11:02 +00005932{
5933 int done = 0;
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005934 win_T *wp;
Bram Moolenaar7875acc2006-09-10 13:51:17 +00005935 int h = tabline_height();
Bram Moolenaarf740b292006-02-16 22:11:02 +00005936
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005937 // Limit to 1000 windows, autocommands may add a window while we close
5938 // one. OK, so I'm paranoid...
Bram Moolenaarf740b292006-02-16 22:11:02 +00005939 while (++done < 1000)
5940 {
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005941 wp = tp->tp_firstwin;
5942 ex_win_close(forceit, wp, tp);
Bram Moolenaarf740b292006-02-16 22:11:02 +00005943
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005944 // Autocommands may delete the tab page under our fingers and we may
5945 // fail to close a window with a modified buffer.
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005946 if (!valid_tabpage(tp) || tp->tp_firstwin == wp)
Bram Moolenaarf740b292006-02-16 22:11:02 +00005947 break;
5948 }
Bram Moolenaar7875acc2006-09-10 13:51:17 +00005949
Bram Moolenaar29323592016-07-24 22:04:11 +02005950 apply_autocmds(EVENT_TABCLOSED, NULL, NULL, FALSE, curbuf);
Bram Moolenaar29323592016-07-24 22:04:11 +02005951
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005952 redraw_tabline = TRUE;
Bram Moolenaar7875acc2006-09-10 13:51:17 +00005953 if (h != tabline_height())
5954 shell_new_rows();
Bram Moolenaarf740b292006-02-16 22:11:02 +00005955}
5956
5957/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00005958 * ":only".
5959 */
5960 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01005961ex_only(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005962{
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005963 win_T *wp;
5964 int wnr;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005965# ifdef FEAT_GUI
5966 need_mouse_correct = TRUE;
5967# endif
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01005968 if (eap->addr_count > 0)
5969 {
5970 wnr = eap->line2;
5971 for (wp = firstwin; --wnr > 0; )
5972 {
5973 if (wp->w_next == NULL)
5974 break;
5975 else
5976 wp = wp->w_next;
5977 }
5978 win_goto(wp);
5979 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005980 close_others(TRUE, eap->forceit);
5981}
5982
Bram Moolenaar071d4272004-06-13 20:20:40 +00005983 static void
Bram Moolenaar5e1e6d22017-01-02 17:26:00 +01005984ex_hide(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005985{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005986 // ":hide" or ":hide | cmd": hide current window
Bram Moolenaar2256c992016-11-15 21:17:07 +01005987 if (!eap->skip)
5988 {
Bram Moolenaar4033c552017-09-16 20:54:51 +02005989#ifdef FEAT_GUI
Bram Moolenaar2256c992016-11-15 21:17:07 +01005990 need_mouse_correct = TRUE;
Bram Moolenaar4033c552017-09-16 20:54:51 +02005991#endif
Bram Moolenaar2256c992016-11-15 21:17:07 +01005992 if (eap->addr_count == 0)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01005993 win_close(curwin, FALSE); // don't free buffer
Bram Moolenaar2256c992016-11-15 21:17:07 +01005994 else
5995 {
5996 int winnr = 0;
5997 win_T *win;
Bram Moolenaarf240e182014-11-27 18:33:02 +01005998
Bram Moolenaar2256c992016-11-15 21:17:07 +01005999 FOR_ALL_WINDOWS(win)
6000 {
6001 winnr++;
6002 if (winnr == eap->line2)
6003 break;
Bram Moolenaarb96a7f32014-11-27 16:22:48 +01006004 }
Bram Moolenaar2256c992016-11-15 21:17:07 +01006005 if (win == NULL)
6006 win = lastwin;
6007 win_close(win, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006008 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006009 }
6010}
6011
6012/*
6013 * ":stop" and ":suspend": Suspend Vim.
6014 */
6015 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006016ex_stop(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006017{
6018 /*
6019 * Disallow suspending for "rvim".
6020 */
Bram Moolenaarcea912a2016-10-12 14:20:24 +02006021 if (!check_restricted())
Bram Moolenaar071d4272004-06-13 20:20:40 +00006022 {
6023 if (!eap->forceit)
6024 autowrite_all();
Bram Moolenaar100118c2020-12-11 19:30:34 +01006025 apply_autocmds(EVENT_VIMSUSPEND, NULL, NULL, FALSE, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006026 windgoto((int)Rows - 1, 0);
6027 out_char('\n');
6028 out_flush();
6029 stoptermcap();
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006030 out_flush(); // needed for SUN to restore xterm buffer
Bram Moolenaar071d4272004-06-13 20:20:40 +00006031#ifdef FEAT_TITLE
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006032 mch_restore_title(SAVE_RESTORE_BOTH); // restore window titles
Bram Moolenaar071d4272004-06-13 20:20:40 +00006033#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006034 ui_suspend(); // call machine specific function
Bram Moolenaar071d4272004-06-13 20:20:40 +00006035#ifdef FEAT_TITLE
6036 maketitle();
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006037 resettitle(); // force updating the title
Bram Moolenaar071d4272004-06-13 20:20:40 +00006038#endif
6039 starttermcap();
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006040 scroll_start(); // scroll screen before redrawing
Bram Moolenaar071d4272004-06-13 20:20:40 +00006041 redraw_later_clear();
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006042 shell_resized(); // may have resized window
Bram Moolenaar100118c2020-12-11 19:30:34 +01006043 apply_autocmds(EVENT_VIMRESUME, NULL, NULL, FALSE, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006044 }
6045}
6046
6047/*
Bram Moolenaar12a96de2018-03-11 14:44:18 +01006048 * ":exit", ":xit" and ":wq": Write file and quite the current window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006049 */
6050 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006051ex_exit(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006052{
Bram Moolenaar461f2122020-07-28 20:25:47 +02006053#ifdef FEAT_EVAL
Bram Moolenaarae616492020-07-28 20:07:27 +02006054 if (not_in_vim9(eap) == FAIL)
6055 return;
Bram Moolenaar461f2122020-07-28 20:25:47 +02006056#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006057#ifdef FEAT_CMDWIN
6058 if (cmdwin_type != 0)
6059 {
6060 cmdwin_result = Ctrl_C;
6061 return;
6062 }
6063#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006064 // Don't quit while editing the command line.
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00006065 if (text_locked())
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006066 {
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00006067 text_locked_msg();
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006068 return;
6069 }
Bram Moolenaar12a96de2018-03-11 14:44:18 +01006070
6071 if (before_quit_autocmds(curwin, FALSE, eap->forceit))
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006072 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006073
6074 /*
6075 * if more files or windows we won't exit
6076 */
6077 if (check_more(FALSE, eap->forceit) == OK && only_one_window())
6078 exiting = TRUE;
6079 if ( ((eap->cmdidx == CMD_wq
6080 || curbufIsChanged())
6081 && do_write(eap) == FAIL)
6082 || check_more(TRUE, eap->forceit) == FAIL
Bram Moolenaar027387f2016-01-02 22:25:52 +01006083 || (only_one_window() && check_changed_any(eap->forceit, FALSE)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00006084 {
6085 not_exiting();
6086 }
6087 else
6088 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006089 if (only_one_window()) // quit last window, exit Vim
Bram Moolenaar071d4272004-06-13 20:20:40 +00006090 getout(0);
Bram Moolenaar2c33d7b2017-10-14 16:06:20 +02006091 not_exiting();
Bram Moolenaar071d4272004-06-13 20:20:40 +00006092# ifdef FEAT_GUI
6093 need_mouse_correct = TRUE;
6094# endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006095 // Quit current window, may free the buffer.
Bram Moolenaareb44a682017-08-03 22:44:55 +02006096 win_close(curwin, !buf_hide(curwin->w_buffer));
Bram Moolenaar071d4272004-06-13 20:20:40 +00006097 }
6098}
6099
6100/*
6101 * ":print", ":list", ":number".
6102 */
6103 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006104ex_print(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006105{
Bram Moolenaardf177f62005-02-22 08:39:57 +00006106 if (curbuf->b_ml.ml_flags & ML_EMPTY)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006107 emsg(_(e_emptybuf));
Bram Moolenaardf177f62005-02-22 08:39:57 +00006108 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00006109 {
Bram Moolenaardf177f62005-02-22 08:39:57 +00006110 for ( ;!got_int; ui_breakcheck())
6111 {
6112 print_line(eap->line1,
6113 (eap->cmdidx == CMD_number || eap->cmdidx == CMD_pound
6114 || (eap->flags & EXFLAG_NR)),
6115 eap->cmdidx == CMD_list || (eap->flags & EXFLAG_LIST));
6116 if (++eap->line1 > eap->line2)
6117 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006118 out_flush(); // show one line at a time
Bram Moolenaardf177f62005-02-22 08:39:57 +00006119 }
6120 setpcmark();
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006121 // put cursor at last line
Bram Moolenaardf177f62005-02-22 08:39:57 +00006122 curwin->w_cursor.lnum = eap->line2;
6123 beginline(BL_SOL | BL_FIX);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006124 }
6125
Bram Moolenaar071d4272004-06-13 20:20:40 +00006126 ex_no_reprint = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006127}
6128
6129#ifdef FEAT_BYTEOFF
6130 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006131ex_goto(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006132{
6133 goto_byte(eap->line2);
6134}
6135#endif
6136
6137/*
6138 * ":shell".
6139 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006140 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006141ex_shell(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006142{
6143 do_shell(NULL, 0);
6144}
6145
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006146#if defined(HAVE_DROP_FILE) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006147
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006148static int drop_busy = FALSE;
6149static int drop_filec;
6150static char_u **drop_filev = NULL;
6151static int drop_split;
6152static void (*drop_callback)(void *);
6153static void *drop_cookie;
6154
6155 static void
6156handle_drop_internal(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006157{
6158 exarg_T ea;
6159 int save_msg_scroll = msg_scroll;
6160
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006161 // Setting the argument list may cause screen updates and being called
6162 // recursively. Avoid that by setting drop_busy.
6163 drop_busy = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006164
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006165 // Check whether the current buffer is changed. If so, we will need
6166 // to split the current window or data could be lost.
6167 // We don't need to check if the 'hidden' option is set, as in this
6168 // case the buffer won't be lost.
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006169 if (!buf_hide(curbuf) && !drop_split)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006170 {
6171 ++emsg_off;
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006172 drop_split = check_changed(curbuf, CCGD_AW);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006173 --emsg_off;
6174 }
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006175 if (drop_split)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006176 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00006177 if (win_split(0, 0) == FAIL)
6178 return;
Bram Moolenaar3368ea22010-09-21 16:56:35 +02006179 RESET_BINDING(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006180
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006181 // When splitting the window, create a new alist. Otherwise the
6182 // existing one is overwritten.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006183 alist_unlink(curwin->w_alist);
6184 alist_new();
Bram Moolenaar071d4272004-06-13 20:20:40 +00006185 }
6186
6187 /*
6188 * Set up the new argument list.
6189 */
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006190 alist_set(ALIST(curwin), drop_filec, drop_filev, FALSE, NULL, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006191
6192 /*
6193 * Move to the first file.
6194 */
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006195 // Fake up a minimal "next" command for do_argfile()
Bram Moolenaara80faa82020-04-12 19:37:17 +02006196 CLEAR_FIELD(ea);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006197 ea.cmd = (char_u *)"next";
6198 do_argfile(&ea, 0);
6199
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006200 // do_ecmd() may set need_start_insertmode, but since we never left Insert
6201 // mode that is not needed here.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006202 need_start_insertmode = FALSE;
6203
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006204 // Restore msg_scroll, otherwise a following command may cause scrolling
6205 // unexpectedly. The screen will be redrawn by the caller, thus
6206 // msg_scroll being set by displaying a message is irrelevant.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006207 msg_scroll = save_msg_scroll;
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006208
6209 if (drop_callback != NULL)
6210 drop_callback(drop_cookie);
6211
6212 drop_filev = NULL;
6213 drop_busy = FALSE;
6214}
6215
6216/*
6217 * Handle a file drop. The code is here because a drop is *nearly* like an
6218 * :args command, but not quite (we have a list of exact filenames, so we
Bram Moolenaarb5443cc2019-01-15 20:19:40 +01006219 * don't want to (a) parse a command line, or (b) expand wildcards). So the
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006220 * code is very similar to :args and hence needs access to a lot of the static
6221 * functions in this file.
6222 *
6223 * The "filev" list must have been allocated using alloc(), as should each item
6224 * in the list. This function takes over responsibility for freeing the "filev"
6225 * list.
6226 */
6227 void
6228handle_drop(
6229 int filec, // the number of files dropped
6230 char_u **filev, // the list of files dropped
6231 int split, // force splitting the window
6232 void (*callback)(void *), // to be called after setting the argument
6233 // list
6234 void *cookie) // argument for "callback" (allocated)
6235{
6236 // Cannot handle recursive drops, finish the pending one.
6237 if (drop_busy)
6238 {
6239 FreeWild(filec, filev);
6240 vim_free(cookie);
6241 return;
6242 }
6243
6244 // When calling handle_drop() more than once in a row we only use the last
6245 // one.
6246 if (drop_filev != NULL)
6247 {
6248 FreeWild(drop_filec, drop_filev);
6249 vim_free(drop_cookie);
6250 }
6251
6252 drop_filec = filec;
6253 drop_filev = filev;
6254 drop_split = split;
6255 drop_callback = callback;
6256 drop_cookie = cookie;
6257
6258 // Postpone this when:
6259 // - editing the command line
6260 // - not possible to change the current buffer
6261 // - updating the screen
6262 // As it may change buffers and window structures that are in use and cause
6263 // freed memory to be used.
6264 if (text_locked() || curbuf_locked() || updating_screen)
6265 return;
6266
6267 handle_drop_internal();
6268}
6269
6270/*
6271 * To be called when text is unlocked, curbuf is unlocked or updating_screen is
6272 * reset: Handle a postponed drop.
6273 */
6274 void
6275handle_any_postponed_drop(void)
6276{
6277 if (!drop_busy && drop_filev != NULL
Bram Moolenaar6adb9ea2020-04-30 22:31:18 +02006278 && !text_locked() && !curbuf_locked() && !updating_screen)
Bram Moolenaar92d147b2018-07-29 17:35:23 +02006279 handle_drop_internal();
Bram Moolenaar071d4272004-06-13 20:20:40 +00006280}
6281#endif
6282
Bram Moolenaar071d4272004-06-13 20:20:40 +00006283/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006284 * ":preserve".
6285 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006286 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006287ex_preserve(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006288{
Bram Moolenaar4399ef42005-02-12 14:29:27 +00006289 curbuf->b_flags |= BF_PRESERVED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006290 ml_preserve(curbuf, TRUE);
6291}
6292
6293/*
6294 * ":recover".
6295 */
6296 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006297ex_recover(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006298{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006299 // Set recoverymode right away to avoid the ATTENTION prompt.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006300 recoverymode = TRUE;
Bram Moolenaar45d3b142013-11-09 03:31:51 +01006301 if (!check_changed(curbuf, (p_awa ? CCGD_AW : 0)
6302 | CCGD_MULTWIN
6303 | (eap->forceit ? CCGD_FORCEIT : 0)
6304 | CCGD_EXCMD)
6305
Bram Moolenaar071d4272004-06-13 20:20:40 +00006306 && (*eap->arg == NUL
6307 || setfname(curbuf, eap->arg, NULL, TRUE) == OK))
Bram Moolenaar99499b12019-05-23 21:35:48 +02006308 ml_recover(TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006309 recoverymode = FALSE;
6310}
6311
6312/*
6313 * Command modifier used in a wrong way.
6314 */
6315 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006316ex_wrongmodifier(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006317{
Bram Moolenaar451c2e32020-08-15 16:33:28 +02006318 eap->errmsg = _(e_invalid_command);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006319}
6320
Bram Moolenaar071d4272004-06-13 20:20:40 +00006321/*
6322 * :sview [+command] file split window with new file, read-only
6323 * :split [[+command] file] split window with current or new file
6324 * :vsplit [[+command] file] split window vertically with current or new file
6325 * :new [[+command] file] split window with no or new file
6326 * :vnew [[+command] file] split vertically window with no or new file
6327 * :sfind [+command] file split window with file in 'path'
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006328 *
6329 * :tabedit open new Tab page with empty window
6330 * :tabedit [+command] file open new Tab page and edit "file"
6331 * :tabnew [[+command] file] just like :tabedit
6332 * :tabfind [+command] file open new Tab page and find "file"
Bram Moolenaar071d4272004-06-13 20:20:40 +00006333 */
6334 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006335ex_splitview(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006336{
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006337 win_T *old_curwin = curwin;
Bram Moolenaar4033c552017-09-16 20:54:51 +02006338#if defined(FEAT_SEARCHPATH) || defined(FEAT_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006339 char_u *fname = NULL;
Bram Moolenaar4033c552017-09-16 20:54:51 +02006340#endif
6341#ifdef FEAT_BROWSE
Bram Moolenaar21cbe172020-10-13 19:08:24 +02006342 char_u dot_path[] = ".";
Bram Moolenaare1004402020-10-24 20:49:43 +02006343 int save_cmod_flags = cmdmod.cmod_flags;
Bram Moolenaar4033c552017-09-16 20:54:51 +02006344#endif
Bram Moolenaar39902a02018-06-21 22:10:08 +02006345 int use_tab = eap->cmdidx == CMD_tabedit
6346 || eap->cmdidx == CMD_tabfind
6347 || eap->cmdidx == CMD_tabnew;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006348
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01006349 if (ERROR_IF_ANY_POPUP_WINDOW)
Bram Moolenaar815b76b2019-06-01 14:15:52 +02006350 return;
6351
Bram Moolenaar4033c552017-09-16 20:54:51 +02006352#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00006353 need_mouse_correct = TRUE;
Bram Moolenaar4033c552017-09-16 20:54:51 +02006354#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006355
Bram Moolenaar4033c552017-09-16 20:54:51 +02006356#ifdef FEAT_QUICKFIX
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006357 // A ":split" in the quickfix window works like ":new". Don't want two
6358 // quickfix windows. But it's OK when doing ":tab split".
Bram Moolenaare1004402020-10-24 20:49:43 +02006359 if (bt_quickfix(curbuf) && cmdmod.cmod_tab == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006360 {
6361 if (eap->cmdidx == CMD_split)
6362 eap->cmdidx = CMD_new;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006363 if (eap->cmdidx == CMD_vsplit)
6364 eap->cmdidx = CMD_vnew;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006365 }
Bram Moolenaar4033c552017-09-16 20:54:51 +02006366#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006367
Bram Moolenaar4033c552017-09-16 20:54:51 +02006368#ifdef FEAT_SEARCHPATH
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006369 if (eap->cmdidx == CMD_sfind || eap->cmdidx == CMD_tabfind)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006370 {
6371 fname = find_file_in_path(eap->arg, (int)STRLEN(eap->arg),
6372 FNAME_MESS, TRUE, curbuf->b_ffname);
6373 if (fname == NULL)
6374 goto theend;
6375 eap->arg = fname;
6376 }
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006377# ifdef FEAT_BROWSE
Bram Moolenaar4033c552017-09-16 20:54:51 +02006378 else
6379# endif
6380#endif
6381#ifdef FEAT_BROWSE
Bram Moolenaare1004402020-10-24 20:49:43 +02006382 if ((cmdmod.cmod_flags & CMOD_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006383 && eap->cmdidx != CMD_vnew
Bram Moolenaar071d4272004-06-13 20:20:40 +00006384 && eap->cmdidx != CMD_new)
6385 {
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00006386 if (
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01006387# ifdef FEAT_GUI
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00006388 !gui.in_use &&
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01006389# endif
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00006390 au_has_group((char_u *)"FileExplorer"))
6391 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006392 // No browsing supported but we do have the file explorer:
6393 // Edit the directory.
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00006394 if (*eap->arg == NUL || !mch_isdir(eap->arg))
Bram Moolenaar21cbe172020-10-13 19:08:24 +02006395 eap->arg = dot_path;
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00006396 }
6397 else
6398 {
Bram Moolenaar39902a02018-06-21 22:10:08 +02006399 fname = do_browse(0, (char_u *)(use_tab
6400 ? _("Edit File in new tab page")
6401 : _("Edit File in new window")),
Bram Moolenaar071d4272004-06-13 20:20:40 +00006402 eap->arg, NULL, NULL, NULL, curbuf);
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00006403 if (fname == NULL)
6404 goto theend;
6405 eap->arg = fname;
6406 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006407 }
Bram Moolenaare1004402020-10-24 20:49:43 +02006408 cmdmod.cmod_flags &= ~CMOD_BROWSE; // Don't browse again in do_ecmd().
Bram Moolenaar4033c552017-09-16 20:54:51 +02006409#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006410
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006411 /*
6412 * Either open new tab page or split the window.
6413 */
Bram Moolenaar39902a02018-06-21 22:10:08 +02006414 if (use_tab)
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006415 {
Bram Moolenaare1004402020-10-24 20:49:43 +02006416 if (win_new_tabpage(cmdmod.cmod_tab != 0 ? cmdmod.cmod_tab
Bram Moolenaar8dff8182006-04-06 20:18:50 +00006417 : eap->addr_count == 0 ? 0
6418 : (int)eap->line2 + 1) != FAIL)
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006419 {
Bram Moolenaard2b66012008-01-09 19:30:36 +00006420 do_exedit(eap, old_curwin);
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006421
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006422 // set the alternate buffer for the window we came from
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006423 if (curwin != old_curwin
6424 && win_valid(old_curwin)
6425 && old_curwin->w_buffer != curbuf
Bram Moolenaare1004402020-10-24 20:49:43 +02006426 && (cmdmod.cmod_flags & CMOD_KEEPALT) == 0)
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006427 old_curwin->w_alt_fnum = curbuf->b_fnum;
6428 }
6429 }
6430 else if (win_split(eap->addr_count > 0 ? (int)eap->line2 : 0,
Bram Moolenaar071d4272004-06-13 20:20:40 +00006431 *eap->cmd == 'v' ? WSP_VERT : 0) != FAIL)
6432 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006433 // Reset 'scrollbind' when editing another file, but keep it when
6434 // doing ":split" without arguments.
Bram Moolenaare1004402020-10-24 20:49:43 +02006435 if (*eap->arg != NUL)
Bram Moolenaar3368ea22010-09-21 16:56:35 +02006436 RESET_BINDING(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006437 else
6438 do_check_scrollbind(FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006439 do_exedit(eap, old_curwin);
6440 }
6441
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006442# ifdef FEAT_BROWSE
Bram Moolenaare1004402020-10-24 20:49:43 +02006443 cmdmod.cmod_flags = save_cmod_flags;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006444# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006445
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006446# if defined(FEAT_SEARCHPATH) || defined(FEAT_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006447theend:
6448 vim_free(fname);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006449# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006450}
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006451
6452/*
Bram Moolenaar80a94a52006-02-23 21:26:58 +00006453 * Open a new tab page.
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006454 */
6455 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006456tabpage_new(void)
Bram Moolenaar80a94a52006-02-23 21:26:58 +00006457{
6458 exarg_T ea;
6459
Bram Moolenaara80faa82020-04-12 19:37:17 +02006460 CLEAR_FIELD(ea);
Bram Moolenaar80a94a52006-02-23 21:26:58 +00006461 ea.cmdidx = CMD_tabnew;
6462 ea.cmd = (char_u *)"tabn";
6463 ea.arg = (char_u *)"";
6464 ex_splitview(&ea);
6465}
6466
6467/*
6468 * :tabnext command
6469 */
6470 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006471ex_tabnext(exarg_T *eap)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006472{
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006473 int tab_number;
6474
Bram Moolenaar8cdbd5b2019-06-16 15:50:45 +02006475 if (ERROR_IF_POPUP_WINDOW)
Bram Moolenaar815b76b2019-06-01 14:15:52 +02006476 return;
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006477 switch (eap->cmdidx)
6478 {
6479 case CMD_tabfirst:
6480 case CMD_tabrewind:
6481 goto_tabpage(1);
6482 break;
6483 case CMD_tablast:
6484 goto_tabpage(9999);
6485 break;
6486 case CMD_tabprevious:
6487 case CMD_tabNext:
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006488 if (eap->arg && *eap->arg != NUL)
6489 {
6490 char_u *p = eap->arg;
6491 char_u *p_save = p;
6492
6493 tab_number = getdigits(&p);
6494 if (p == p_save || *p_save == '-' || *p != NUL
6495 || tab_number == 0)
6496 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006497 // No numbers as argument.
Bram Moolenaar8930caa2020-07-23 16:37:03 +02006498 eap->errmsg = ex_errmsg(e_invarg2, eap->arg);
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006499 return;
6500 }
6501 }
6502 else
6503 {
6504 if (eap->addr_count == 0)
6505 tab_number = 1;
6506 else
6507 {
6508 tab_number = eap->line2;
6509 if (tab_number < 1)
6510 {
Bram Moolenaar8930caa2020-07-23 16:37:03 +02006511 eap->errmsg = _(e_invrange);
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006512 return;
6513 }
6514 }
6515 }
6516 goto_tabpage(-tab_number);
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006517 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006518 default: // CMD_tabnext
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006519 tab_number = get_tabpage_arg(eap);
6520 if (eap->errmsg == NULL)
6521 goto_tabpage(tab_number);
Bram Moolenaar32466aa2006-02-24 23:53:04 +00006522 break;
6523 }
Bram Moolenaar80a94a52006-02-23 21:26:58 +00006524}
6525
6526/*
6527 * :tabmove command
6528 */
6529 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006530ex_tabmove(exarg_T *eap)
Bram Moolenaar80a94a52006-02-23 21:26:58 +00006531{
Bram Moolenaar40ce3a42015-04-21 18:08:39 +02006532 int tab_number;
Bram Moolenaar8cb8dca2012-07-06 18:27:39 +02006533
Bram Moolenaar2f72c702017-01-29 14:48:10 +01006534 tab_number = get_tabpage_arg(eap);
6535 if (eap->errmsg == NULL)
6536 tabpage_move(tab_number);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006537}
6538
6539/*
6540 * :tabs command: List tabs and their contents.
6541 */
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006542 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006543ex_tabs(exarg_T *eap UNUSED)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006544{
6545 tabpage_T *tp;
6546 win_T *wp;
6547 int tabcount = 1;
6548
6549 msg_start();
6550 msg_scroll = TRUE;
6551 for (tp = first_tabpage; tp != NULL && !got_int; tp = tp->tp_next)
6552 {
6553 msg_putchar('\n');
6554 vim_snprintf((char *)IObuff, IOSIZE, _("Tab page %d"), tabcount++);
Bram Moolenaar8820b482017-03-16 17:23:31 +01006555 msg_outtrans_attr(IObuff, HL_ATTR(HLF_T));
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006556 out_flush(); // output one line at a time
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006557 ui_breakcheck();
6558
Bram Moolenaar030f0df2006-02-21 22:02:53 +00006559 if (tp == curtab)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006560 wp = firstwin;
6561 else
6562 wp = tp->tp_firstwin;
6563 for ( ; wp != NULL && !got_int; wp = wp->w_next)
6564 {
Bram Moolenaar80a94a52006-02-23 21:26:58 +00006565 msg_putchar('\n');
6566 msg_putchar(wp == curwin ? '>' : ' ');
6567 msg_putchar(' ');
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006568 msg_putchar(bufIsChanged(wp->w_buffer) ? '+' : ' ');
6569 msg_putchar(' ');
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006570 if (buf_spname(wp->w_buffer) != NULL)
Bram Moolenaare1704ba2012-10-03 18:25:00 +02006571 vim_strncpy(IObuff, buf_spname(wp->w_buffer), IOSIZE - 1);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006572 else
6573 home_replace(wp->w_buffer, wp->w_buffer->b_fname,
6574 IObuff, IOSIZE, TRUE);
6575 msg_outtrans(IObuff);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006576 out_flush(); // output one line at a time
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006577 ui_breakcheck();
6578 }
6579 }
6580}
6581
Bram Moolenaar071d4272004-06-13 20:20:40 +00006582/*
6583 * ":mode": Set screen mode.
6584 * If no argument given, just get the screen size and redraw.
6585 */
6586 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006587ex_mode(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006588{
6589 if (*eap->arg == NUL)
6590 shell_resized();
6591 else
Bram Moolenaar3c71aec2020-01-17 19:32:20 +01006592 emsg(_(e_screenmode));
Bram Moolenaar071d4272004-06-13 20:20:40 +00006593}
6594
Bram Moolenaar071d4272004-06-13 20:20:40 +00006595/*
6596 * ":resize".
6597 * set, increment or decrement current window height
6598 */
6599 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006600ex_resize(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006601{
6602 int n;
6603 win_T *wp = curwin;
6604
6605 if (eap->addr_count > 0)
6606 {
6607 n = eap->line2;
6608 for (wp = firstwin; wp->w_next != NULL && --n > 0; wp = wp->w_next)
6609 ;
6610 }
6611
Bram Moolenaar44a2f922016-03-19 22:11:51 +01006612# ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00006613 need_mouse_correct = TRUE;
Bram Moolenaar44a2f922016-03-19 22:11:51 +01006614# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006615 n = atol((char *)eap->arg);
Bram Moolenaare1004402020-10-24 20:49:43 +02006616 if (cmdmod.cmod_split & WSP_VERT)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006617 {
6618 if (*eap->arg == '-' || *eap->arg == '+')
Bram Moolenaar9668cc52020-10-17 17:39:55 +02006619 n += wp->w_width;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006620 else if (n == 0 && eap->arg[0] == NUL) // default is very wide
Bram Moolenaar071d4272004-06-13 20:20:40 +00006621 n = 9999;
6622 win_setwidth_win((int)n, wp);
6623 }
6624 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00006625 {
6626 if (*eap->arg == '-' || *eap->arg == '+')
Bram Moolenaar9668cc52020-10-17 17:39:55 +02006627 n += wp->w_height;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006628 else if (n == 0 && eap->arg[0] == NUL) // default is very high
Bram Moolenaar071d4272004-06-13 20:20:40 +00006629 n = 9999;
6630 win_setheight_win((int)n, wp);
6631 }
6632}
Bram Moolenaar071d4272004-06-13 20:20:40 +00006633
6634/*
6635 * ":find [+command] <file>" command.
6636 */
6637 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006638ex_find(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006639{
6640#ifdef FEAT_SEARCHPATH
6641 char_u *fname;
6642 int count;
6643
6644 fname = find_file_in_path(eap->arg, (int)STRLEN(eap->arg), FNAME_MESS,
6645 TRUE, curbuf->b_ffname);
6646 if (eap->addr_count > 0)
6647 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006648 // Repeat finding the file "count" times. This matters when it
6649 // appears several times in the path.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006650 count = eap->line2;
6651 while (fname != NULL && --count > 0)
6652 {
6653 vim_free(fname);
6654 fname = find_file_in_path(NULL, 0, FNAME_MESS,
6655 FALSE, curbuf->b_ffname);
6656 }
6657 }
6658
6659 if (fname != NULL)
6660 {
6661 eap->arg = fname;
6662#endif
6663 do_exedit(eap, NULL);
6664#ifdef FEAT_SEARCHPATH
6665 vim_free(fname);
6666 }
6667#endif
6668}
6669
6670/*
Bram Moolenaardf177f62005-02-22 08:39:57 +00006671 * ":open" simulation: for now just work like ":visual".
6672 */
6673 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006674ex_open(exarg_T *eap)
Bram Moolenaardf177f62005-02-22 08:39:57 +00006675{
6676 regmatch_T regmatch;
6677 char_u *p;
6678
Bram Moolenaar65088802021-03-13 21:07:21 +01006679#ifdef FEAT_EVAL
6680 if (not_in_vim9(eap) == FAIL)
6681 return;
6682#endif
Bram Moolenaardf177f62005-02-22 08:39:57 +00006683 curwin->w_cursor.lnum = eap->line2;
6684 beginline(BL_SOL | BL_FIX);
6685 if (*eap->arg == '/')
6686 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006687 // ":open /pattern/": put cursor in column found with pattern
Bram Moolenaardf177f62005-02-22 08:39:57 +00006688 ++eap->arg;
Bram Moolenaarf4e20992020-12-21 19:59:08 +01006689 p = skip_regexp(eap->arg, '/', magic_isset());
Bram Moolenaardf177f62005-02-22 08:39:57 +00006690 *p = NUL;
Bram Moolenaarf4e20992020-12-21 19:59:08 +01006691 regmatch.regprog = vim_regcomp(eap->arg, magic_isset() ? RE_MAGIC : 0);
Bram Moolenaardf177f62005-02-22 08:39:57 +00006692 if (regmatch.regprog != NULL)
6693 {
6694 regmatch.rm_ic = p_ic;
6695 p = ml_get_curline();
6696 if (vim_regexec(&regmatch, p, (colnr_T)0))
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00006697 curwin->w_cursor.col = (colnr_T)(regmatch.startp[0] - p);
Bram Moolenaardf177f62005-02-22 08:39:57 +00006698 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01006699 emsg(_(e_nomatch));
Bram Moolenaar473de612013-06-08 18:19:48 +02006700 vim_regfree(regmatch.regprog);
Bram Moolenaardf177f62005-02-22 08:39:57 +00006701 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006702 // Move to the NUL, ignore any other arguments.
Bram Moolenaardf177f62005-02-22 08:39:57 +00006703 eap->arg += STRLEN(eap->arg);
6704 }
6705 check_cursor();
6706
6707 eap->cmdidx = CMD_visual;
6708 do_exedit(eap, NULL);
6709}
6710
6711/*
Bram Moolenaar59d8e562020-11-07 18:41:10 +01006712 * ":edit", ":badd", ":balt", ":visual".
Bram Moolenaar071d4272004-06-13 20:20:40 +00006713 */
6714 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006715ex_edit(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006716{
6717 do_exedit(eap, NULL);
6718}
6719
6720/*
Bram Moolenaar4b96df52020-01-26 22:00:26 +01006721 * ":edit <file>" command and alike.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006722 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006723 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006724do_exedit(
6725 exarg_T *eap,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006726 win_T *old_curwin) // curwin before doing a split or NULL
Bram Moolenaar071d4272004-06-13 20:20:40 +00006727{
6728 int n;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006729 int need_hide;
Bram Moolenaardf177f62005-02-22 08:39:57 +00006730 int exmode_was = exmode_active;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006731
Bram Moolenaar3c01c4a2020-02-01 23:04:24 +01006732 if ((eap->cmdidx != CMD_pedit && ERROR_IF_POPUP_WINDOW)
6733 || ERROR_IF_TERM_POPUP_WINDOW)
Bram Moolenaar815b76b2019-06-01 14:15:52 +02006734 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006735 /*
6736 * ":vi" command ends Ex mode.
6737 */
6738 if (exmode_active && (eap->cmdidx == CMD_visual
6739 || eap->cmdidx == CMD_view))
6740 {
6741 exmode_active = FALSE;
Bram Moolenaar158ea172020-06-18 17:28:39 +02006742 ex_pressedreturn = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006743 if (*eap->arg == NUL)
Bram Moolenaardf177f62005-02-22 08:39:57 +00006744 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006745 // Special case: ":global/pat/visual\NLvi-commands"
Bram Moolenaardf177f62005-02-22 08:39:57 +00006746 if (global_busy)
6747 {
6748 int rd = RedrawingDisabled;
6749 int nwr = no_wait_return;
6750 int ms = msg_scroll;
6751#ifdef FEAT_GUI
6752 int he = hold_gui_events;
6753#endif
6754
6755 if (eap->nextcmd != NULL)
6756 {
6757 stuffReadbuff(eap->nextcmd);
6758 eap->nextcmd = NULL;
6759 }
6760
6761 if (exmode_was != EXMODE_VIM)
6762 settmode(TMODE_RAW);
6763 RedrawingDisabled = 0;
6764 no_wait_return = 0;
6765 need_wait_return = FALSE;
6766 msg_scroll = 0;
6767#ifdef FEAT_GUI
6768 hold_gui_events = 0;
6769#endif
6770 must_redraw = CLEAR;
Bram Moolenaar9e2bcb52020-02-18 21:33:00 +01006771 pending_exmode_active = TRUE;
Bram Moolenaardf177f62005-02-22 08:39:57 +00006772
6773 main_loop(FALSE, TRUE);
6774
Bram Moolenaar9e2bcb52020-02-18 21:33:00 +01006775 pending_exmode_active = FALSE;
Bram Moolenaardf177f62005-02-22 08:39:57 +00006776 RedrawingDisabled = rd;
6777 no_wait_return = nwr;
6778 msg_scroll = ms;
6779#ifdef FEAT_GUI
6780 hold_gui_events = he;
6781#endif
6782 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006783 return;
Bram Moolenaardf177f62005-02-22 08:39:57 +00006784 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006785 }
6786
6787 if ((eap->cmdidx == CMD_new
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006788 || eap->cmdidx == CMD_tabnew
6789 || eap->cmdidx == CMD_tabedit
Bram Moolenaar4033c552017-09-16 20:54:51 +02006790 || eap->cmdidx == CMD_vnew) && *eap->arg == NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006791 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006792 // ":new" or ":tabnew" without argument: edit an new empty buffer
Bram Moolenaar071d4272004-06-13 20:20:40 +00006793 setpcmark();
6794 (void)do_ecmd(0, NULL, NULL, eap, ECMD_ONE,
Bram Moolenaar701f7af2008-11-15 13:12:07 +00006795 ECMD_HIDE + (eap->forceit ? ECMD_FORCEIT : 0),
6796 old_curwin == NULL ? curwin : NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006797 }
Bram Moolenaar4033c552017-09-16 20:54:51 +02006798 else if ((eap->cmdidx != CMD_split && eap->cmdidx != CMD_vsplit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006799 || *eap->arg != NUL
6800#ifdef FEAT_BROWSE
Bram Moolenaare1004402020-10-24 20:49:43 +02006801 || (cmdmod.cmod_flags & CMOD_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006802#endif
6803 )
6804 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006805 // Can't edit another file when "curbuf_lock" is set. Only ":edit"
6806 // can bring us here, others are stopped earlier.
Bram Moolenaar5555acc2006-04-07 21:33:12 +00006807 if (*eap->arg != NUL && curbuf_locked())
6808 return;
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01006809
Bram Moolenaar071d4272004-06-13 20:20:40 +00006810 n = readonlymode;
6811 if (eap->cmdidx == CMD_view || eap->cmdidx == CMD_sview)
6812 readonlymode = TRUE;
6813 else if (eap->cmdidx == CMD_enew)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006814 readonlymode = FALSE; // 'readonly' doesn't make sense in an
6815 // empty buffer
Bram Moolenaar3482be62020-11-27 11:00:38 +01006816 if (eap->cmdidx != CMD_balt && eap->cmdidx != CMD_badd)
6817 setpcmark();
Bram Moolenaar071d4272004-06-13 20:20:40 +00006818 if (do_ecmd(0, (eap->cmdidx == CMD_enew ? NULL : eap->arg),
6819 NULL, eap,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006820 // ":edit" goes to first line if Vi compatible
Bram Moolenaar071d4272004-06-13 20:20:40 +00006821 (*eap->arg == NUL && eap->do_ecmd_lnum == 0
6822 && vim_strchr(p_cpo, CPO_GOTO1) != NULL)
6823 ? ECMD_ONE : eap->do_ecmd_lnum,
Bram Moolenaareb44a682017-08-03 22:44:55 +02006824 (buf_hide(curbuf) ? ECMD_HIDE : 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006825 + (eap->forceit ? ECMD_FORCEIT : 0)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006826 // after a split we can use an existing buffer
Bram Moolenaar7b449342014-03-25 13:03:48 +01006827 + (old_curwin != NULL ? ECMD_OLDBUF : 0)
Bram Moolenaar59d8e562020-11-07 18:41:10 +01006828 + (eap->cmdidx == CMD_badd ? ECMD_ADDBUF : 0)
6829 + (eap->cmdidx == CMD_balt ? ECMD_ALTBUF : 0)
Bram Moolenaar701f7af2008-11-15 13:12:07 +00006830 , old_curwin == NULL ? curwin : NULL) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006831 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006832 // Editing the file failed. If the window was split, close it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006833 if (old_curwin != NULL)
6834 {
6835 need_hide = (curbufIsChanged() && curbuf->b_nwindows <= 1);
Bram Moolenaareb44a682017-08-03 22:44:55 +02006836 if (!need_hide || buf_hide(curbuf))
Bram Moolenaar071d4272004-06-13 20:20:40 +00006837 {
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01006838#if defined(FEAT_EVAL)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00006839 cleanup_T cs;
6840
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006841 // Reset the error/interrupt/exception state here so that
6842 // aborting() returns FALSE when closing a window.
Bram Moolenaarc0197e22004-09-13 20:26:32 +00006843 enter_cleanup(&cs);
Bram Moolenaar4033c552017-09-16 20:54:51 +02006844#endif
6845#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00006846 need_mouse_correct = TRUE;
Bram Moolenaar4033c552017-09-16 20:54:51 +02006847#endif
Bram Moolenaareb44a682017-08-03 22:44:55 +02006848 win_close(curwin, !need_hide && !buf_hide(curbuf));
Bram Moolenaarc0197e22004-09-13 20:26:32 +00006849
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01006850#if defined(FEAT_EVAL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006851 // Restore the error/interrupt/exception state if not
6852 // discarded by a new aborting error, interrupt, or
6853 // uncaught exception.
Bram Moolenaarc0197e22004-09-13 20:26:32 +00006854 leave_cleanup(&cs);
Bram Moolenaar4033c552017-09-16 20:54:51 +02006855#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006856 }
6857 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006858 }
6859 else if (readonlymode && curbuf->b_nwindows == 1)
6860 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01006861 // When editing an already visited buffer, 'readonly' won't be set
6862 // but the previous value is kept. With ":view" and ":sview" we
6863 // want the file to be readonly, except when another window is
6864 // editing the same buffer.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006865 curbuf->b_p_ro = TRUE;
6866 }
6867 readonlymode = n;
6868 }
6869 else
6870 {
6871 if (eap->do_ecmd_cmd != NULL)
Bram Moolenaar47a2abf2020-11-25 20:12:11 +01006872 do_cmd_argument(eap->do_ecmd_cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006873#ifdef FEAT_TITLE
6874 n = curwin->w_arg_idx_invalid;
6875#endif
6876 check_arg_idx(curwin);
6877#ifdef FEAT_TITLE
6878 if (n != curwin->w_arg_idx_invalid)
6879 maketitle();
6880#endif
6881 }
6882
Bram Moolenaar071d4272004-06-13 20:20:40 +00006883 /*
6884 * if ":split file" worked, set alternate file name in old window to new
6885 * file
6886 */
6887 if (old_curwin != NULL
6888 && *eap->arg != NUL
6889 && curwin != old_curwin
6890 && win_valid(old_curwin)
Bram Moolenaard4755bb2004-09-02 19:12:26 +00006891 && old_curwin->w_buffer != curbuf
Bram Moolenaare1004402020-10-24 20:49:43 +02006892 && (cmdmod.cmod_flags & CMOD_KEEPALT) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006893 old_curwin->w_alt_fnum = curbuf->b_fnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006894
6895 ex_no_reprint = TRUE;
6896}
6897
6898#ifndef FEAT_GUI
6899/*
6900 * ":gui" and ":gvim" when there is no GUI.
6901 */
6902 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006903ex_nogui(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006904{
Bram Moolenaar8930caa2020-07-23 16:37:03 +02006905 eap->errmsg = _(e_nogvim);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006906}
6907#endif
6908
Bram Moolenaar4f974752019-02-17 17:44:42 +01006909#if defined(FEAT_GUI_MSWIN) && defined(FEAT_MENU) && defined(FEAT_TEAROFF)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006910 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006911ex_tearoff(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006912{
6913 gui_make_tearoff(eap->arg);
6914}
6915#endif
6916
Bram Moolenaar29a2c082018-03-05 21:06:23 +01006917#if (defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_GTK) \
6918 || defined(FEAT_TERM_POPUP_MENU)) && defined(FEAT_MENU)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006919 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006920ex_popup(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006921{
Bram Moolenaar29a2c082018-03-05 21:06:23 +01006922# if defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_GTK)
6923 if (gui.in_use)
6924 gui_make_popup(eap->arg, eap->forceit);
6925# ifdef FEAT_TERM_POPUP_MENU
6926 else
6927# endif
6928# endif
6929# ifdef FEAT_TERM_POPUP_MENU
6930 pum_make_popup(eap->arg, eap->forceit);
6931# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006932}
6933#endif
6934
Bram Moolenaar071d4272004-06-13 20:20:40 +00006935 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006936ex_swapname(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006937{
6938 if (curbuf->b_ml.ml_mfp == NULL || curbuf->b_ml.ml_mfp->mf_fname == NULL)
Bram Moolenaar32526b32019-01-19 17:43:09 +01006939 msg(_("No swap file"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00006940 else
Bram Moolenaar32526b32019-01-19 17:43:09 +01006941 msg((char *)curbuf->b_ml.ml_mfp->mf_fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006942}
6943
6944/*
6945 * ":syncbind" forces all 'scrollbind' windows to have the same relative
6946 * offset.
6947 * (1998-11-02 16:21:01 R. Edward Ralston <eralston@computer.org>)
6948 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006949 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01006950ex_syncbind(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006951{
Bram Moolenaar071d4272004-06-13 20:20:40 +00006952 win_T *wp;
Bram Moolenaardedd1b02013-12-14 13:06:17 +01006953 win_T *save_curwin = curwin;
6954 buf_T *save_curbuf = curbuf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006955 long topline;
6956 long y;
6957 linenr_T old_linenr = curwin->w_cursor.lnum;
6958
6959 setpcmark();
6960
6961 /*
6962 * determine max topline
6963 */
6964 if (curwin->w_p_scb)
6965 {
6966 topline = curwin->w_topline;
Bram Moolenaar29323592016-07-24 22:04:11 +02006967 FOR_ALL_WINDOWS(wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006968 {
6969 if (wp->w_p_scb && wp->w_buffer)
6970 {
Bram Moolenaar375e3392019-01-31 18:26:10 +01006971 y = wp->w_buffer->b_ml.ml_line_count - get_scrolloff_value();
Bram Moolenaar071d4272004-06-13 20:20:40 +00006972 if (topline > y)
6973 topline = y;
6974 }
6975 }
6976 if (topline < 1)
6977 topline = 1;
6978 }
6979 else
6980 {
6981 topline = 1;
6982 }
6983
6984
6985 /*
Bram Moolenaardedd1b02013-12-14 13:06:17 +01006986 * Set all scrollbind windows to the same topline.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006987 */
Bram Moolenaar29323592016-07-24 22:04:11 +02006988 FOR_ALL_WINDOWS(curwin)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006989 {
6990 if (curwin->w_p_scb)
6991 {
Bram Moolenaardedd1b02013-12-14 13:06:17 +01006992 curbuf = curwin->w_buffer;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006993 y = topline - curwin->w_topline;
6994 if (y > 0)
6995 scrollup(y, TRUE);
6996 else
6997 scrolldown(-y, TRUE);
6998 curwin->w_scbind_pos = topline;
6999 redraw_later(VALID);
7000 cursor_correct();
Bram Moolenaar071d4272004-06-13 20:20:40 +00007001 curwin->w_redr_status = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007002 }
7003 }
Bram Moolenaardedd1b02013-12-14 13:06:17 +01007004 curwin = save_curwin;
7005 curbuf = save_curbuf;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007006 if (curwin->w_p_scb)
7007 {
7008 did_syncbind = TRUE;
7009 checkpcmark();
7010 if (old_linenr != curwin->w_cursor.lnum)
7011 {
7012 char_u ctrl_o[2];
7013
7014 ctrl_o[0] = Ctrl_O;
7015 ctrl_o[1] = 0;
7016 ins_typebuf(ctrl_o, REMAP_NONE, 0, TRUE, FALSE);
7017 }
7018 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007019}
7020
7021
7022 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007023ex_read(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007024{
Bram Moolenaardf177f62005-02-22 08:39:57 +00007025 int i;
7026 int empty = (curbuf->b_ml.ml_flags & ML_EMPTY);
7027 linenr_T lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007028
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007029 if (eap->usefilter) // :r!cmd
Bram Moolenaar071d4272004-06-13 20:20:40 +00007030 do_bang(1, eap, FALSE, FALSE, TRUE);
7031 else
7032 {
7033 if (u_save(eap->line2, (linenr_T)(eap->line2 + 1)) == FAIL)
7034 return;
7035
7036#ifdef FEAT_BROWSE
Bram Moolenaare1004402020-10-24 20:49:43 +02007037 if (cmdmod.cmod_flags & CMOD_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007038 {
7039 char_u *browseFile;
7040
Bram Moolenaar7171abe2004-10-11 10:06:20 +00007041 browseFile = do_browse(0, (char_u *)_("Append File"), eap->arg,
Bram Moolenaar071d4272004-06-13 20:20:40 +00007042 NULL, NULL, NULL, curbuf);
7043 if (browseFile != NULL)
7044 {
7045 i = readfile(browseFile, NULL,
7046 eap->line2, (linenr_T)0, (linenr_T)MAXLNUM, eap, 0);
7047 vim_free(browseFile);
7048 }
7049 else
7050 i = OK;
7051 }
7052 else
7053#endif
7054 if (*eap->arg == NUL)
7055 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007056 if (check_fname() == FAIL) // check for no file name
Bram Moolenaar071d4272004-06-13 20:20:40 +00007057 return;
7058 i = readfile(curbuf->b_ffname, curbuf->b_fname,
7059 eap->line2, (linenr_T)0, (linenr_T)MAXLNUM, eap, 0);
7060 }
7061 else
7062 {
7063 if (vim_strchr(p_cpo, CPO_ALTREAD) != NULL)
7064 (void)setaltfname(eap->arg, eap->arg, (linenr_T)1);
7065 i = readfile(eap->arg, NULL,
7066 eap->line2, (linenr_T)0, (linenr_T)MAXLNUM, eap, 0);
7067
7068 }
Bram Moolenaare13b9af2017-01-13 22:01:02 +01007069 if (i != OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007070 {
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01007071#if defined(FEAT_EVAL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007072 if (!aborting())
7073#endif
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007074 semsg(_(e_notopen), eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007075 }
7076 else
Bram Moolenaardf177f62005-02-22 08:39:57 +00007077 {
7078 if (empty && exmode_active)
7079 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007080 // Delete the empty line that remains. Historically ex does
7081 // this but vi doesn't.
Bram Moolenaardf177f62005-02-22 08:39:57 +00007082 if (eap->line2 == 0)
7083 lnum = curbuf->b_ml.ml_line_count;
7084 else
7085 lnum = 1;
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +00007086 if (*ml_get(lnum) == NUL && u_savedel(lnum, 1L) == OK)
Bram Moolenaardf177f62005-02-22 08:39:57 +00007087 {
Bram Moolenaarca70c072020-05-30 20:30:46 +02007088 ml_delete(lnum);
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +00007089 if (curwin->w_cursor.lnum > 1
7090 && curwin->w_cursor.lnum >= lnum)
Bram Moolenaardf177f62005-02-22 08:39:57 +00007091 --curwin->w_cursor.lnum;
Bram Moolenaarcdcaa582009-07-09 18:06:49 +00007092 deleted_lines_mark(lnum, 1L);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007093 }
7094 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007095 redraw_curbuf_later(VALID);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007096 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007097 }
7098}
7099
Bram Moolenaarea408852005-06-25 22:49:46 +00007100static char_u *prev_dir = NULL;
7101
7102#if defined(EXITFREE) || defined(PROTO)
7103 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007104free_cd_dir(void)
Bram Moolenaarea408852005-06-25 22:49:46 +00007105{
Bram Moolenaard23a8232018-02-10 18:45:26 +01007106 VIM_CLEAR(prev_dir);
7107 VIM_CLEAR(globaldir);
Bram Moolenaarea408852005-06-25 22:49:46 +00007108}
7109#endif
7110
Bram Moolenaarf4258302013-06-02 18:20:17 +02007111/*
Bram Moolenaar002bc792020-06-05 22:33:42 +02007112 * Get the previous directory for the given chdir scope.
7113 */
7114 static char_u *
7115get_prevdir(cdscope_T scope)
7116{
7117 if (scope == CDSCOPE_WINDOW)
7118 return curwin->w_prevdir;
7119 else if (scope == CDSCOPE_TABPAGE)
7120 return curtab->tp_prevdir;
7121 return prev_dir;
7122}
7123
7124/*
Bram Moolenaarf4258302013-06-02 18:20:17 +02007125 * Deal with the side effects of changing the current directory.
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007126 * When 'scope' is CDSCOPE_TABPAGE then this was after an ":tcd" command.
7127 * When 'scope' is CDSCOPE_WINDOW then this was after an ":lcd" command.
Bram Moolenaarf4258302013-06-02 18:20:17 +02007128 */
7129 void
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007130post_chdir(cdscope_T scope)
Bram Moolenaarf4258302013-06-02 18:20:17 +02007131{
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007132 if (scope != CDSCOPE_WINDOW)
Bram Moolenaar00aa0692019-04-27 20:37:57 +02007133 // Clear tab local directory for both :cd and :tcd
7134 VIM_CLEAR(curtab->tp_localdir);
Bram Moolenaard23a8232018-02-10 18:45:26 +01007135 VIM_CLEAR(curwin->w_localdir);
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007136 if (scope != CDSCOPE_GLOBAL)
Bram Moolenaarf4258302013-06-02 18:20:17 +02007137 {
Bram Moolenaar002bc792020-06-05 22:33:42 +02007138 char_u *pdir = get_prevdir(scope);
7139
7140 // If still in the global directory, need to remember current
7141 // directory as the global directory.
7142 if (globaldir == NULL && pdir != NULL)
7143 globaldir = vim_strsave(pdir);
7144
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007145 // Remember this local directory for the window.
Bram Moolenaarf4258302013-06-02 18:20:17 +02007146 if (mch_dirname(NameBuff, MAXPATHL) == OK)
Bram Moolenaar00aa0692019-04-27 20:37:57 +02007147 {
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007148 if (scope == CDSCOPE_TABPAGE)
Bram Moolenaar00aa0692019-04-27 20:37:57 +02007149 curtab->tp_localdir = vim_strsave(NameBuff);
7150 else
7151 curwin->w_localdir = vim_strsave(NameBuff);
7152 }
Bram Moolenaarf4258302013-06-02 18:20:17 +02007153 }
7154 else
7155 {
Bram Moolenaar002bc792020-06-05 22:33:42 +02007156 // We are now in the global directory, no need to remember its name.
Bram Moolenaard23a8232018-02-10 18:45:26 +01007157 VIM_CLEAR(globaldir);
Bram Moolenaarf4258302013-06-02 18:20:17 +02007158 }
7159
7160 shorten_fnames(TRUE);
7161}
7162
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007163/*
7164 * Change directory function used by :cd/:tcd/:lcd Ex commands and the
Bram Moolenaar95058722020-06-01 16:26:19 +02007165 * chdir() function.
7166 * scope == CDSCOPE_WINDOW: changes the window-local directory
7167 * scope == CDSCOPE_TABPAGE: changes the tab-local directory
7168 * Otherwise: changes the global directory
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007169 * Returns TRUE if the directory is successfully changed.
7170 */
7171 int
7172changedir_func(
7173 char_u *new_dir,
7174 int forceit,
7175 cdscope_T scope)
7176{
7177 char_u *tofree;
Bram Moolenaar002bc792020-06-05 22:33:42 +02007178 char_u *pdir = NULL;
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007179 int dir_differs;
7180 int retval = FALSE;
7181
Bram Moolenaar7cc96922020-01-31 22:41:38 +01007182 if (new_dir == NULL || allbuf_locked())
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007183 return FALSE;
7184
7185 if (vim_strchr(p_cpo, CPO_CHDIR) != NULL && curbufIsChanged() && !forceit)
7186 {
7187 emsg(_("E747: Cannot change directory, buffer is modified (add ! to override)"));
7188 return FALSE;
7189 }
7190
7191 // ":cd -": Change to previous directory
7192 if (STRCMP(new_dir, "-") == 0)
7193 {
Bram Moolenaar002bc792020-06-05 22:33:42 +02007194 pdir = get_prevdir(scope);
7195 if (pdir == NULL)
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007196 {
7197 emsg(_("E186: No previous directory"));
7198 return FALSE;
7199 }
Bram Moolenaar002bc792020-06-05 22:33:42 +02007200 new_dir = pdir;
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007201 }
7202
Bram Moolenaar002bc792020-06-05 22:33:42 +02007203 // Free the previous directory
7204 tofree = get_prevdir(scope);
7205
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007206 // Save current directory for next ":cd -"
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007207 if (mch_dirname(NameBuff, MAXPATHL) == OK)
Bram Moolenaar002bc792020-06-05 22:33:42 +02007208 pdir = vim_strsave(NameBuff);
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007209 else
Bram Moolenaar002bc792020-06-05 22:33:42 +02007210 pdir = NULL;
7211 if (scope == CDSCOPE_WINDOW)
7212 curwin->w_prevdir = pdir;
7213 else if (scope == CDSCOPE_TABPAGE)
7214 curtab->tp_prevdir = pdir;
7215 else
7216 prev_dir = pdir;
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007217
7218#if defined(UNIX) || defined(VMS)
7219 // for UNIX ":cd" means: go to home directory
7220 if (*new_dir == NUL)
7221 {
7222 // use NameBuff for home directory name
7223# ifdef VMS
7224 char_u *p;
7225
7226 p = mch_getenv((char_u *)"SYS$LOGIN");
7227 if (p == NULL || *p == NUL) // empty is the same as not set
7228 NameBuff[0] = NUL;
7229 else
7230 vim_strncpy(NameBuff, p, MAXPATHL - 1);
7231# else
7232 expand_env((char_u *)"$HOME", NameBuff, MAXPATHL);
7233# endif
7234 new_dir = NameBuff;
7235 }
7236#endif
Bram Moolenaar002bc792020-06-05 22:33:42 +02007237 dir_differs = new_dir == NULL || pdir == NULL
7238 || pathcmp((char *)pdir, (char *)new_dir, -1) != 0;
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007239 if (new_dir == NULL || (dir_differs && vim_chdir(new_dir)))
7240 emsg(_(e_failed));
7241 else
7242 {
7243 char_u *acmd_fname;
7244
7245 post_chdir(scope);
7246
7247 if (dir_differs)
7248 {
7249 if (scope == CDSCOPE_WINDOW)
7250 acmd_fname = (char_u *)"window";
7251 else if (scope == CDSCOPE_TABPAGE)
7252 acmd_fname = (char_u *)"tabpage";
7253 else
7254 acmd_fname = (char_u *)"global";
7255 apply_autocmds(EVENT_DIRCHANGED, acmd_fname, new_dir, FALSE,
7256 curbuf);
7257 }
7258 retval = TRUE;
7259 }
7260 vim_free(tofree);
7261
7262 return retval;
7263}
Bram Moolenaarea408852005-06-25 22:49:46 +00007264
Bram Moolenaar071d4272004-06-13 20:20:40 +00007265/*
Bram Moolenaar00aa0692019-04-27 20:37:57 +02007266 * ":cd", ":tcd", ":lcd", ":chdir" ":tchdir" and ":lchdir".
Bram Moolenaar071d4272004-06-13 20:20:40 +00007267 */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00007268 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007269ex_cd(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007270{
Bram Moolenaar2caad3f2018-12-16 15:38:02 +01007271 char_u *new_dir;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007272
7273 new_dir = eap->arg;
7274#if !defined(UNIX) && !defined(VMS)
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007275 // for non-UNIX ":cd" means: print current directory
Bram Moolenaar071d4272004-06-13 20:20:40 +00007276 if (*new_dir == NUL)
7277 ex_pwd(NULL);
7278 else
7279#endif
7280 {
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007281 cdscope_T scope = CDSCOPE_GLOBAL;
7282
7283 if (eap->cmdidx == CMD_lcd || eap->cmdidx == CMD_lchdir)
7284 scope = CDSCOPE_WINDOW;
7285 else if (eap->cmdidx == CMD_tcd || eap->cmdidx == CMD_tchdir)
7286 scope = CDSCOPE_TABPAGE;
7287
7288 if (changedir_func(new_dir, eap->forceit, scope))
Bram Moolenaardf177f62005-02-22 08:39:57 +00007289 {
Bram Moolenaar1063f3d2019-05-07 22:06:52 +02007290 // Echo the new current directory if the command was typed.
Bram Moolenaarfcfbc672009-07-09 18:13:49 +00007291 if (KeyTyped || p_verbose >= 5)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007292 ex_pwd(eap);
7293 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007294 }
7295}
7296
7297/*
7298 * ":pwd".
7299 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007300 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007301ex_pwd(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007302{
7303 if (mch_dirname(NameBuff, MAXPATHL) == OK)
7304 {
7305#ifdef BACKSLASH_IN_FILENAME
7306 slash_adjust(NameBuff);
7307#endif
Bram Moolenaar95058722020-06-01 16:26:19 +02007308 if (p_verbose > 0)
7309 {
7310 char *context = "global";
7311
7312 if (curwin->w_localdir != NULL)
7313 context = "window";
7314 else if (curtab->tp_localdir != NULL)
7315 context = "tabpage";
7316 smsg("[%s] %s", context, (char *)NameBuff);
7317 }
7318 else
7319 msg((char *)NameBuff);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007320 }
7321 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007322 emsg(_("E187: Unknown"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007323}
7324
7325/*
7326 * ":=".
7327 */
7328 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007329ex_equal(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007330{
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007331 smsg("%ld", (long)eap->line2);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007332 ex_may_print(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007333}
7334
7335 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007336ex_sleep(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007337{
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00007338 int n;
7339 long len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007340
7341 if (cursor_valid())
7342 {
7343 n = W_WINROW(curwin) + curwin->w_wrow - msg_scrolled;
7344 if (n >= 0)
Bram Moolenaar53f81742017-09-22 14:35:51 +02007345 windgoto((int)n, curwin->w_wincol + curwin->w_wcol);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007346 }
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00007347
7348 len = eap->line2;
7349 switch (*eap->arg)
7350 {
7351 case 'm': break;
7352 case NUL: len *= 1000L; break;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007353 default: semsg(_(e_invarg2), eap->arg); return;
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00007354 }
Bram Moolenaare2edc2e2021-01-16 20:21:23 +01007355
7356 // Hide the cursor if invoked with !
7357 do_sleep(len, eap->forceit);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007358}
7359
7360/*
7361 * Sleep for "msec" milliseconds, but keep checking for a CTRL-C every second.
Bram Moolenaare2edc2e2021-01-16 20:21:23 +01007362 * Hide the cursor if "hide_cursor" is TRUE.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007363 */
7364 void
Bram Moolenaare2edc2e2021-01-16 20:21:23 +01007365do_sleep(long msec, int hide_cursor)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007366{
Bram Moolenaar52953192019-08-16 10:27:13 +02007367 long done = 0;
Bram Moolenaar975b5272016-03-15 23:10:59 +01007368 long wait_now;
Bram Moolenaar52953192019-08-16 10:27:13 +02007369# ifdef ELAPSED_FUNC
7370 elapsed_T start_tv;
7371
7372 // Remember at what time we started, so that we know how much longer we
7373 // should wait after waiting for a bit.
7374 ELAPSED_INIT(start_tv);
7375# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007376
Bram Moolenaare2edc2e2021-01-16 20:21:23 +01007377 if (hide_cursor)
Bram Moolenaar09f067f2021-04-11 13:29:18 +02007378 cursor_sleep();
Bram Moolenaare2edc2e2021-01-16 20:21:23 +01007379 else
7380 cursor_on();
7381
Bram Moolenaarf45d7472018-09-30 18:22:26 +02007382 out_flush_cursor(FALSE, FALSE);
Bram Moolenaar52953192019-08-16 10:27:13 +02007383 while (!got_int && done < msec)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007384 {
Bram Moolenaar975b5272016-03-15 23:10:59 +01007385 wait_now = msec - done > 1000L ? 1000L : msec - done;
7386#ifdef FEAT_TIMERS
7387 {
7388 long due_time = check_due_timer();
7389
7390 if (due_time > 0 && due_time < wait_now)
7391 wait_now = due_time;
7392 }
7393#endif
Bram Moolenaarb9c31e72016-09-29 15:18:57 +02007394#ifdef FEAT_JOB_CHANNEL
Bram Moolenaar28e67e02019-08-15 23:05:49 +02007395 if (has_any_channel() && wait_now > 20L)
7396 wait_now = 20L;
7397#endif
7398#ifdef FEAT_SOUND
7399 if (has_any_sound_callback() && wait_now > 20L)
7400 wait_now = 20L;
Bram Moolenaarb9c31e72016-09-29 15:18:57 +02007401#endif
Bram Moolenaar975b5272016-03-15 23:10:59 +01007402 ui_delay(wait_now, TRUE);
Bram Moolenaar52953192019-08-16 10:27:13 +02007403
Bram Moolenaarb9c31e72016-09-29 15:18:57 +02007404#ifdef FEAT_JOB_CHANNEL
7405 if (has_any_channel())
7406 ui_breakcheck_force(TRUE);
7407 else
7408#endif
7409 ui_breakcheck();
Bram Moolenaar93c88e02015-09-15 14:12:05 +02007410#ifdef MESSAGE_QUEUE
Bram Moolenaar52953192019-08-16 10:27:13 +02007411 // Process the netbeans and clientserver messages that may have been
7412 // received in the call to ui_breakcheck() when the GUI is in use. This
7413 // may occur when running a test case.
Bram Moolenaar93c88e02015-09-15 14:12:05 +02007414 parse_queued_messages();
Bram Moolenaare3cc6d42011-10-20 21:58:34 +02007415#endif
Bram Moolenaar52953192019-08-16 10:27:13 +02007416
7417# ifdef ELAPSED_FUNC
7418 // actual time passed
7419 done = ELAPSED_FUNC(start_tv);
7420# else
7421 // guestimate time passed (will actually be more)
7422 done += wait_now;
7423# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007424 }
Bram Moolenaar1ebff3d2018-07-07 16:18:13 +02007425
7426 // If CTRL-C was typed to interrupt the sleep, drop the CTRL-C from the
7427 // input buffer, otherwise a following call to input() fails.
7428 if (got_int)
7429 (void)vpeekc();
Bram Moolenaar09f067f2021-04-11 13:29:18 +02007430
7431 if (hide_cursor)
7432 cursor_unsleep();
Bram Moolenaar071d4272004-06-13 20:20:40 +00007433}
7434
Bram Moolenaar071d4272004-06-13 20:20:40 +00007435/*
7436 * ":winsize" command (obsolete).
7437 */
7438 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007439ex_winsize(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007440{
7441 int w, h;
7442 char_u *arg = eap->arg;
7443 char_u *p;
7444
Bram Moolenaarf5a51162021-02-06 12:58:18 +01007445 if (!isdigit(*arg))
7446 {
7447 semsg(_(e_invarg2), arg);
7448 return;
7449 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007450 w = getdigits(&arg);
7451 arg = skipwhite(arg);
7452 p = arg;
7453 h = getdigits(&arg);
7454 if (*p != NUL && *arg == NUL)
7455 set_shellsize(w, h, TRUE);
7456 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007457 emsg(_("E465: :winsize requires two number arguments"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007458}
7459
Bram Moolenaar071d4272004-06-13 20:20:40 +00007460 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007461ex_wincmd(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007462{
7463 int xchar = NUL;
7464 char_u *p;
7465
7466 if (*eap->arg == 'g' || *eap->arg == Ctrl_G)
7467 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007468 // CTRL-W g and CTRL-W CTRL-G have an extra command character
Bram Moolenaar071d4272004-06-13 20:20:40 +00007469 if (eap->arg[1] == NUL)
7470 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007471 emsg(_(e_invarg));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007472 return;
7473 }
7474 xchar = eap->arg[1];
7475 p = eap->arg + 2;
7476 }
7477 else
7478 p = eap->arg + 1;
7479
7480 eap->nextcmd = check_nextcmd(p);
7481 p = skipwhite(p);
Bram Moolenaarf5be8cd2020-07-17 20:36:00 +02007482 if (*p != NUL && *p != (
7483#ifdef FEAT_EVAL
7484 in_vim9script() ? '#' :
7485#endif
7486 '"')
7487 && eap->nextcmd == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007488 emsg(_(e_invarg));
Bram Moolenaar12bde492011-06-13 01:19:56 +02007489 else if (!eap->skip)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007490 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007491 // Pass flags on for ":vertical wincmd ]".
Bram Moolenaare1004402020-10-24 20:49:43 +02007492 postponed_split_flags = cmdmod.cmod_split;
7493 postponed_split_tab = cmdmod.cmod_tab;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007494 do_window(*eap->arg, eap->addr_count > 0 ? eap->line2 : 0L, xchar);
7495 postponed_split_flags = 0;
Bram Moolenaard326ce82007-03-11 14:48:29 +00007496 postponed_split_tab = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007497 }
7498}
Bram Moolenaar071d4272004-06-13 20:20:40 +00007499
Bram Moolenaar843ee412004-06-30 16:16:41 +00007500#if defined(FEAT_GUI) || defined(UNIX) || defined(VMS) || defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007501/*
7502 * ":winpos".
7503 */
7504 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007505ex_winpos(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007506{
7507 int x, y;
7508 char_u *arg = eap->arg;
7509 char_u *p;
7510
7511 if (*arg == NUL)
7512 {
Bram Moolenaar843ee412004-06-30 16:16:41 +00007513# if defined(FEAT_GUI) || defined(MSWIN)
Bram Moolenaarafde13b2019-04-28 19:46:49 +02007514# ifdef VIMDLL
7515 if (gui.in_use ? gui_mch_get_winpos(&x, &y) != FAIL :
7516 mch_get_winpos(&x, &y) != FAIL)
7517# elif defined(FEAT_GUI)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007518 if (gui.in_use && gui_mch_get_winpos(&x, &y) != FAIL)
Bram Moolenaar843ee412004-06-30 16:16:41 +00007519# else
7520 if (mch_get_winpos(&x, &y) != FAIL)
7521# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007522 {
7523 sprintf((char *)IObuff, _("Window position: X %d, Y %d"), x, y);
Bram Moolenaar32526b32019-01-19 17:43:09 +01007524 msg((char *)IObuff);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007525 }
7526 else
7527# endif
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007528 emsg(_("E188: Obtaining window position not implemented for this platform"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007529 }
7530 else
7531 {
7532 x = getdigits(&arg);
7533 arg = skipwhite(arg);
7534 p = arg;
7535 y = getdigits(&arg);
7536 if (*p == NUL || *arg != NUL)
7537 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007538 emsg(_("E466: :winpos requires two number arguments"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007539 return;
7540 }
7541# ifdef FEAT_GUI
7542 if (gui.in_use)
7543 gui_mch_set_winpos(x, y);
7544 else if (gui.starting)
7545 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007546 // Remember the coordinates for when the window is opened.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007547 gui_win_x = x;
7548 gui_win_y = y;
7549 }
Bram Moolenaarafde13b2019-04-28 19:46:49 +02007550# if defined(HAVE_TGETENT) || defined(VIMDLL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007551 else
7552# endif
Bram Moolenaarafde13b2019-04-28 19:46:49 +02007553# endif
7554# if defined(MSWIN) && (!defined(FEAT_GUI) || defined(VIMDLL))
Bram Moolenaar843ee412004-06-30 16:16:41 +00007555 mch_set_winpos(x, y);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007556# endif
7557# ifdef HAVE_TGETENT
7558 if (*T_CWP)
7559 term_set_winpos(x, y);
7560# endif
7561 }
7562}
7563#endif
7564
7565/*
7566 * Handle command that work like operators: ":delete", ":yank", ":>" and ":<".
7567 */
7568 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007569ex_operators(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007570{
7571 oparg_T oa;
7572
7573 clear_oparg(&oa);
7574 oa.regname = eap->regname;
7575 oa.start.lnum = eap->line1;
7576 oa.end.lnum = eap->line2;
7577 oa.line_count = eap->line2 - eap->line1 + 1;
7578 oa.motion_type = MLINE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007579 virtual_op = FALSE;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007580 if (eap->cmdidx != CMD_yank) // position cursor for undo
Bram Moolenaar071d4272004-06-13 20:20:40 +00007581 {
7582 setpcmark();
7583 curwin->w_cursor.lnum = eap->line1;
7584 beginline(BL_SOL | BL_FIX);
7585 }
7586
Bram Moolenaard07c6e12013-11-21 14:21:40 +01007587 if (VIsual_active)
7588 end_visual_mode();
Bram Moolenaard07c6e12013-11-21 14:21:40 +01007589
Bram Moolenaar071d4272004-06-13 20:20:40 +00007590 switch (eap->cmdidx)
7591 {
7592 case CMD_delete:
7593 oa.op_type = OP_DELETE;
7594 op_delete(&oa);
7595 break;
7596
7597 case CMD_yank:
7598 oa.op_type = OP_YANK;
7599 (void)op_yank(&oa, FALSE, TRUE);
7600 break;
7601
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007602 default: // CMD_rshift or CMD_lshift
Bram Moolenaar6e707362013-06-14 19:15:58 +02007603 if (
Bram Moolenaar071d4272004-06-13 20:20:40 +00007604#ifdef FEAT_RIGHTLEFT
Bram Moolenaar6e707362013-06-14 19:15:58 +02007605 (eap->cmdidx == CMD_rshift) ^ curwin->w_p_rl
7606#else
7607 eap->cmdidx == CMD_rshift
Bram Moolenaar071d4272004-06-13 20:20:40 +00007608#endif
Bram Moolenaar6e707362013-06-14 19:15:58 +02007609 )
Bram Moolenaar071d4272004-06-13 20:20:40 +00007610 oa.op_type = OP_RSHIFT;
7611 else
7612 oa.op_type = OP_LSHIFT;
7613 op_shift(&oa, FALSE, eap->amount);
7614 break;
7615 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007616 virtual_op = MAYBE;
Bram Moolenaardf177f62005-02-22 08:39:57 +00007617 ex_may_print(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007618}
7619
7620/*
7621 * ":put".
7622 */
7623 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007624ex_put(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007625{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007626 // ":0put" works like ":1put!".
Bram Moolenaar071d4272004-06-13 20:20:40 +00007627 if (eap->line2 == 0)
7628 {
7629 eap->line2 = 1;
7630 eap->forceit = TRUE;
7631 }
7632 curwin->w_cursor.lnum = eap->line2;
Bram Moolenaarc3516f72020-09-08 22:45:35 +02007633 do_put(eap->regname, NULL, eap->forceit ? BACKWARD : FORWARD, 1L,
Bram Moolenaardf177f62005-02-22 08:39:57 +00007634 PUT_LINE|PUT_CURSLINE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007635}
7636
7637/*
7638 * Handle ":copy" and ":move".
7639 */
7640 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007641ex_copymove(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007642{
7643 long n;
7644
Bram Moolenaar491799b2020-08-01 19:23:43 +02007645#ifdef FEAT_EVAL
Bram Moolenaarf5a48012020-08-01 17:00:03 +02007646 if (not_in_vim9(eap) == FAIL)
7647 return;
Bram Moolenaar491799b2020-08-01 19:23:43 +02007648#endif
Bram Moolenaar50eb16c2018-09-15 15:42:40 +02007649 n = get_address(eap, &eap->arg, eap->addr_type, FALSE, FALSE, FALSE, 1);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007650 if (eap->arg == NULL) // error detected
Bram Moolenaar071d4272004-06-13 20:20:40 +00007651 {
7652 eap->nextcmd = NULL;
7653 return;
7654 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00007655 get_flags(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007656
7657 /*
7658 * move or copy lines from 'eap->line1'-'eap->line2' to below line 'n'
7659 */
7660 if (n == MAXLNUM || n < 0 || n > curbuf->b_ml.ml_line_count)
7661 {
Bram Moolenaar0acae7a2019-08-06 21:29:29 +02007662 emsg(_(e_invrange));
Bram Moolenaar071d4272004-06-13 20:20:40 +00007663 return;
7664 }
7665
7666 if (eap->cmdidx == CMD_move)
7667 {
7668 if (do_move(eap->line1, eap->line2, n) == FAIL)
7669 return;
7670 }
7671 else
7672 ex_copy(eap->line1, eap->line2, n);
7673 u_clearline();
7674 beginline(BL_SOL | BL_FIX);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007675 ex_may_print(eap);
7676}
7677
7678/*
7679 * Print the current line if flags were given to the Ex command.
7680 */
Bram Moolenaarfd3fe982014-04-01 17:49:44 +02007681 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007682ex_may_print(exarg_T *eap)
Bram Moolenaardf177f62005-02-22 08:39:57 +00007683{
7684 if (eap->flags != 0)
7685 {
7686 print_line(curwin->w_cursor.lnum, (eap->flags & EXFLAG_NR),
7687 (eap->flags & EXFLAG_LIST));
7688 ex_no_reprint = TRUE;
7689 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007690}
7691
7692/*
7693 * ":smagic" and ":snomagic".
7694 */
7695 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007696ex_submagic(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007697{
Bram Moolenaard93a7fc2021-01-04 12:42:13 +01007698 optmagic_T saved = magic_overruled;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007699
Bram Moolenaard93a7fc2021-01-04 12:42:13 +01007700 magic_overruled = eap->cmdidx == CMD_smagic
7701 ? OPTION_MAGIC_ON : OPTION_MAGIC_OFF;
Bram Moolenaar66e00142020-08-12 21:58:12 +02007702 ex_substitute(eap);
Bram Moolenaarf4e20992020-12-21 19:59:08 +01007703 magic_overruled = saved;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007704}
7705
7706/*
7707 * ":join".
7708 */
7709 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007710ex_join(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007711{
7712 curwin->w_cursor.lnum = eap->line1;
7713 if (eap->line1 == eap->line2)
7714 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007715 if (eap->addr_count >= 2) // :2,2join does nothing
Bram Moolenaar071d4272004-06-13 20:20:40 +00007716 return;
7717 if (eap->line2 == curbuf->b_ml.ml_line_count)
7718 {
7719 beep_flush();
7720 return;
7721 }
7722 ++eap->line2;
7723 }
Bram Moolenaard69bd9a2014-04-29 12:15:40 +02007724 (void)do_join(eap->line2 - eap->line1 + 1, !eap->forceit, TRUE, TRUE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007725 beginline(BL_WHITE | BL_FIX);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007726 ex_may_print(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007727}
7728
7729/*
7730 * ":[addr]@r" or ":[addr]*r": execute register
7731 */
7732 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007733ex_at(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007734{
7735 int c;
Bram Moolenaar60462872009-11-03 11:40:19 +00007736 int prev_len = typebuf.tb_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007737
7738 curwin->w_cursor.lnum = eap->line2;
Bram Moolenaar4930a762016-09-11 14:39:53 +02007739 check_cursor_col();
Bram Moolenaar071d4272004-06-13 20:20:40 +00007740
7741#ifdef USE_ON_FLY_SCROLL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007742 dont_scroll = TRUE; // disallow scrolling here
Bram Moolenaar071d4272004-06-13 20:20:40 +00007743#endif
7744
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007745 // get the register name. No name means to use the previous one
Bram Moolenaar071d4272004-06-13 20:20:40 +00007746 c = *eap->arg;
7747 if (c == NUL || (c == '*' && *eap->cmd == '*'))
7748 c = '@';
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007749 // Put the register in the typeahead buffer with the "silent" flag.
Bram Moolenaard333d1e2006-11-07 17:43:47 +00007750 if (do_execreg(c, TRUE, vim_strchr(p_cpo, CPO_EXECBUF) != NULL, TRUE)
7751 == FAIL)
Bram Moolenaardf177f62005-02-22 08:39:57 +00007752 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00007753 beep_flush();
Bram Moolenaardf177f62005-02-22 08:39:57 +00007754 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007755 else
7756 {
7757 int save_efr = exec_from_reg;
7758
7759 exec_from_reg = TRUE;
7760
7761 /*
7762 * Execute from the typeahead buffer.
Bram Moolenaar60462872009-11-03 11:40:19 +00007763 * Continue until the stuff buffer is empty and all added characters
7764 * have been consumed.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007765 */
Bram Moolenaar60462872009-11-03 11:40:19 +00007766 while (!stuff_empty() || typebuf.tb_len > prev_len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007767 (void)do_cmdline(NULL, getexline, NULL, DOCMD_NOWAIT|DOCMD_VERBOSE);
7768
7769 exec_from_reg = save_efr;
7770 }
7771}
7772
7773/*
7774 * ":!".
7775 */
7776 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007777ex_bang(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007778{
7779 do_bang(eap->addr_count, eap, eap->forceit, TRUE, TRUE);
7780}
7781
7782/*
7783 * ":undo".
7784 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007785 static void
Bram Moolenaarf1d25012016-03-03 12:22:53 +01007786ex_undo(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007787{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007788 if (eap->addr_count == 1) // :undo 123
Bram Moolenaar730cde92010-06-27 05:18:54 +02007789 undo_time(eap->line2, FALSE, FALSE, TRUE);
Bram Moolenaard3667a22006-03-16 21:35:52 +00007790 else
7791 u_undo(1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007792}
7793
Bram Moolenaar55debbe2010-05-23 23:34:36 +02007794#ifdef FEAT_PERSISTENT_UNDO
Bram Moolenaar6df6f472010-07-18 18:04:50 +02007795 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007796ex_wundo(exarg_T *eap)
Bram Moolenaar55debbe2010-05-23 23:34:36 +02007797{
7798 char_u hash[UNDO_HASH_SIZE];
7799
7800 u_compute_hash(hash);
7801 u_write_undo(eap->arg, eap->forceit, curbuf, hash);
7802}
7803
Bram Moolenaar6df6f472010-07-18 18:04:50 +02007804 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007805ex_rundo(exarg_T *eap)
Bram Moolenaar55debbe2010-05-23 23:34:36 +02007806{
7807 char_u hash[UNDO_HASH_SIZE];
7808
7809 u_compute_hash(hash);
Bram Moolenaar6ed8ed82010-05-30 20:40:11 +02007810 u_read_undo(eap->arg, hash, NULL);
Bram Moolenaar55debbe2010-05-23 23:34:36 +02007811}
7812#endif
7813
Bram Moolenaar071d4272004-06-13 20:20:40 +00007814/*
7815 * ":redo".
7816 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007817 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007818ex_redo(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007819{
7820 u_redo(1);
7821}
7822
7823/*
Bram Moolenaarc7d89352006-03-14 22:53:34 +00007824 * ":earlier" and ":later".
7825 */
Bram Moolenaarc7d89352006-03-14 22:53:34 +00007826 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007827ex_later(exarg_T *eap)
Bram Moolenaarc7d89352006-03-14 22:53:34 +00007828{
7829 long count = 0;
7830 int sec = FALSE;
Bram Moolenaar730cde92010-06-27 05:18:54 +02007831 int file = FALSE;
Bram Moolenaarc7d89352006-03-14 22:53:34 +00007832 char_u *p = eap->arg;
7833
7834 if (*p == NUL)
7835 count = 1;
7836 else if (isdigit(*p))
7837 {
7838 count = getdigits(&p);
7839 switch (*p)
7840 {
7841 case 's': ++p; sec = TRUE; break;
7842 case 'm': ++p; sec = TRUE; count *= 60; break;
7843 case 'h': ++p; sec = TRUE; count *= 60 * 60; break;
Bram Moolenaar730cde92010-06-27 05:18:54 +02007844 case 'd': ++p; sec = TRUE; count *= 24 * 60 * 60; break;
7845 case 'f': ++p; file = TRUE; break;
Bram Moolenaarc7d89352006-03-14 22:53:34 +00007846 }
7847 }
7848
7849 if (*p != NUL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007850 semsg(_(e_invarg2), eap->arg);
Bram Moolenaarc7d89352006-03-14 22:53:34 +00007851 else
Bram Moolenaar730cde92010-06-27 05:18:54 +02007852 undo_time(eap->cmdidx == CMD_earlier ? -count : count,
7853 sec, file, FALSE);
Bram Moolenaarc7d89352006-03-14 22:53:34 +00007854}
7855
7856/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00007857 * ":redir": start/stop redirection.
7858 */
7859 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007860ex_redir(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007861{
7862 char *mode;
7863 char_u *fname;
Bram Moolenaarca472992005-01-21 11:46:23 +00007864 char_u *arg = eap->arg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007865
Bram Moolenaarba768492016-07-08 15:32:54 +02007866#ifdef FEAT_EVAL
Bram Moolenaar79815f12016-07-09 17:07:29 +02007867 if (redir_execute)
Bram Moolenaar245a7cb2016-07-08 10:53:12 +02007868 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007869 emsg(_("E930: Cannot use :redir inside execute()"));
Bram Moolenaar245a7cb2016-07-08 10:53:12 +02007870 return;
7871 }
Bram Moolenaarba768492016-07-08 15:32:54 +02007872#endif
Bram Moolenaar245a7cb2016-07-08 10:53:12 +02007873
Bram Moolenaar071d4272004-06-13 20:20:40 +00007874 if (STRICMP(eap->arg, "END") == 0)
7875 close_redir();
7876 else
7877 {
Bram Moolenaarca472992005-01-21 11:46:23 +00007878 if (*arg == '>')
Bram Moolenaar071d4272004-06-13 20:20:40 +00007879 {
Bram Moolenaarca472992005-01-21 11:46:23 +00007880 ++arg;
7881 if (*arg == '>')
Bram Moolenaar071d4272004-06-13 20:20:40 +00007882 {
Bram Moolenaarca472992005-01-21 11:46:23 +00007883 ++arg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007884 mode = "a";
7885 }
7886 else
7887 mode = "w";
Bram Moolenaarca472992005-01-21 11:46:23 +00007888 arg = skipwhite(arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007889
7890 close_redir();
7891
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007892 // Expand environment variables and "~/".
Bram Moolenaarca472992005-01-21 11:46:23 +00007893 fname = expand_env_save(arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007894 if (fname == NULL)
7895 return;
7896#ifdef FEAT_BROWSE
Bram Moolenaare1004402020-10-24 20:49:43 +02007897 if (cmdmod.cmod_flags & CMOD_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007898 {
7899 char_u *browseFile;
7900
Bram Moolenaar7171abe2004-10-11 10:06:20 +00007901 browseFile = do_browse(BROWSE_SAVE,
7902 (char_u *)_("Save Redirection"),
Bram Moolenaarc36651b2018-04-29 12:22:56 +02007903 fname, NULL, NULL,
7904 (char_u *)_(BROWSE_FILTER_ALL_FILES), curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007905 if (browseFile == NULL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007906 return; // operation cancelled
Bram Moolenaar071d4272004-06-13 20:20:40 +00007907 vim_free(fname);
7908 fname = browseFile;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007909 eap->forceit = TRUE; // since dialog already asked
Bram Moolenaar071d4272004-06-13 20:20:40 +00007910 }
7911#endif
7912
7913 redir_fd = open_exfile(fname, eap->forceit, mode);
7914 vim_free(fname);
7915 }
7916#ifdef FEAT_EVAL
Bram Moolenaarca472992005-01-21 11:46:23 +00007917 else if (*arg == '@')
Bram Moolenaar071d4272004-06-13 20:20:40 +00007918 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007919 // redirect to a register a-z (resp. A-Z for appending)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007920 close_redir();
Bram Moolenaarca472992005-01-21 11:46:23 +00007921 ++arg;
7922 if (ASCII_ISALPHA(*arg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007923# ifdef FEAT_CLIPBOARD
Bram Moolenaarca472992005-01-21 11:46:23 +00007924 || *arg == '*'
Bram Moolenaar9a51c6e2006-11-14 19:25:02 +00007925 || *arg == '+'
Bram Moolenaar071d4272004-06-13 20:20:40 +00007926# endif
Bram Moolenaarca472992005-01-21 11:46:23 +00007927 || *arg == '"')
Bram Moolenaar071d4272004-06-13 20:20:40 +00007928 {
Bram Moolenaarca472992005-01-21 11:46:23 +00007929 redir_reg = *arg++;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007930 if (*arg == '>' && arg[1] == '>') // append
Bram Moolenaard9d30582005-05-18 22:10:28 +00007931 arg += 2;
Bram Moolenaarc188b882007-10-19 14:20:54 +00007932 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00007933 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007934 // Can use both "@a" and "@a>".
Bram Moolenaar2c29bee2005-06-01 21:46:07 +00007935 if (*arg == '>')
7936 arg++;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007937 // Make register empty when not using @A-@Z and the
7938 // command is valid.
Bram Moolenaarc188b882007-10-19 14:20:54 +00007939 if (*arg == NUL && !isupper(redir_reg))
7940 write_reg_contents(redir_reg, (char_u *)"", -1, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007941 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00007942 }
7943 if (*arg != NUL)
7944 {
Bram Moolenaardf177f62005-02-22 08:39:57 +00007945 redir_reg = 0;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007946 semsg(_(e_invarg2), eap->arg);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007947 }
7948 }
7949 else if (*arg == '=' && arg[1] == '>')
7950 {
7951 int append;
7952
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007953 // redirect to a variable
Bram Moolenaardf177f62005-02-22 08:39:57 +00007954 close_redir();
7955 arg += 2;
7956
7957 if (*arg == '>')
7958 {
7959 ++arg;
7960 append = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007961 }
7962 else
Bram Moolenaardf177f62005-02-22 08:39:57 +00007963 append = FALSE;
7964
7965 if (var_redir_start(skipwhite(arg), append) == OK)
7966 redir_vname = 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007967 }
7968#endif
7969
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007970 // TODO: redirect to a buffer
Bram Moolenaar071d4272004-06-13 20:20:40 +00007971
Bram Moolenaar071d4272004-06-13 20:20:40 +00007972 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01007973 semsg(_(e_invarg2), eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007974 }
Bram Moolenaar29b2d262006-09-10 19:07:28 +00007975
Bram Moolenaar217e1b82019-12-01 21:41:28 +01007976 // Make sure redirection is not off. Can happen for cmdline completion
7977 // that indirectly invokes a command to catch its output.
Bram Moolenaar29b2d262006-09-10 19:07:28 +00007978 if (redir_fd != NULL
7979#ifdef FEAT_EVAL
7980 || redir_reg || redir_vname
7981#endif
7982 )
7983 redir_off = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007984}
7985
7986/*
7987 * ":redraw": force redraw
7988 */
Bram Moolenaarfb1f6262016-01-31 20:24:32 +01007989 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01007990ex_redraw(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007991{
7992 int r = RedrawingDisabled;
7993 int p = p_lz;
7994
7995 RedrawingDisabled = 0;
7996 p_lz = FALSE;
Bram Moolenaarabc39ab2017-03-01 18:04:05 +01007997 validate_cursor();
Bram Moolenaar071d4272004-06-13 20:20:40 +00007998 update_topline();
Bram Moolenaarf7ff6e82014-03-23 15:13:05 +01007999 update_screen(eap->forceit ? CLEAR : VIsual_active ? INVERTED : 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008000#ifdef FEAT_TITLE
8001 if (need_maketitle)
8002 maketitle();
8003#endif
Bram Moolenaarafde13b2019-04-28 19:46:49 +02008004#if defined(MSWIN) && (!defined(FEAT_GUI_MSWIN) || defined(VIMDLL))
8005# ifdef VIMDLL
8006 if (!gui.in_use)
8007# endif
8008 resize_console_buf();
Bram Moolenaar78d21da2019-02-17 15:00:52 +01008009#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008010 RedrawingDisabled = r;
8011 p_lz = p;
8012
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008013 // Reset msg_didout, so that a message that's there is overwritten.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008014 msg_didout = FALSE;
8015 msg_col = 0;
8016
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008017 // No need to wait after an intentional redraw.
Bram Moolenaar56667a52013-07-17 11:54:28 +02008018 need_wait_return = FALSE;
8019
Bram Moolenaar071d4272004-06-13 20:20:40 +00008020 out_flush();
8021}
8022
8023/*
8024 * ":redrawstatus": force redraw of status line(s)
8025 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00008026 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008027ex_redrawstatus(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008028{
Bram Moolenaar071d4272004-06-13 20:20:40 +00008029 int r = RedrawingDisabled;
8030 int p = p_lz;
8031
8032 RedrawingDisabled = 0;
8033 p_lz = FALSE;
8034 if (eap->forceit)
8035 status_redraw_all();
8036 else
8037 status_redraw_curbuf();
Bram Moolenaarf7ff6e82014-03-23 15:13:05 +01008038 update_screen(VIsual_active ? INVERTED : 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008039 RedrawingDisabled = r;
8040 p_lz = p;
8041 out_flush();
Bram Moolenaar071d4272004-06-13 20:20:40 +00008042}
8043
Bram Moolenaare12bab32019-01-08 22:02:56 +01008044/*
8045 * ":redrawtabline": force redraw of the tabline
8046 */
8047 static void
8048ex_redrawtabline(exarg_T *eap UNUSED)
8049{
8050 int r = RedrawingDisabled;
8051 int p = p_lz;
8052
8053 RedrawingDisabled = 0;
8054 p_lz = FALSE;
8055
8056 draw_tabline();
8057
8058 RedrawingDisabled = r;
8059 p_lz = p;
8060 out_flush();
8061}
8062
Bram Moolenaar071d4272004-06-13 20:20:40 +00008063 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008064close_redir(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008065{
8066 if (redir_fd != NULL)
8067 {
8068 fclose(redir_fd);
8069 redir_fd = NULL;
8070 }
8071#ifdef FEAT_EVAL
8072 redir_reg = 0;
Bram Moolenaardf177f62005-02-22 08:39:57 +00008073 if (redir_vname)
8074 {
8075 var_redir_stop();
8076 redir_vname = 0;
8077 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008078#endif
8079}
8080
Bram Moolenaarf96ae0b2019-07-28 15:21:55 +02008081#if (defined(FEAT_SESSION) || defined(FEAT_EVAL)) || defined(PROTO)
Bram Moolenaardf177f62005-02-22 08:39:57 +00008082 int
Bram Moolenaarbd67aac2019-09-21 23:09:04 +02008083vim_mkdir_emsg(char_u *name, int prot UNUSED)
Bram Moolenaardf177f62005-02-22 08:39:57 +00008084{
8085 if (vim_mkdir(name, prot) != 0)
8086 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008087 semsg(_("E739: Cannot create directory: %s"), name);
Bram Moolenaardf177f62005-02-22 08:39:57 +00008088 return FAIL;
8089 }
8090 return OK;
8091}
8092#endif
8093
Bram Moolenaar071d4272004-06-13 20:20:40 +00008094/*
8095 * Open a file for writing for an Ex command, with some checks.
8096 * Return file descriptor, or NULL on failure.
8097 */
8098 FILE *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008099open_exfile(
8100 char_u *fname,
8101 int forceit,
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008102 char *mode) // "w" for create new file or "a" for append
Bram Moolenaar071d4272004-06-13 20:20:40 +00008103{
8104 FILE *fd;
8105
8106#ifdef UNIX
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008107 // with Unix it is possible to open a directory
Bram Moolenaar071d4272004-06-13 20:20:40 +00008108 if (mch_isdir(fname))
8109 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008110 semsg(_(e_isadir2), fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008111 return NULL;
8112 }
8113#endif
8114 if (!forceit && *mode != 'a' && vim_fexists(fname))
8115 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008116 semsg(_("E189: \"%s\" exists (add ! to override)"), fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008117 return NULL;
8118 }
8119
8120 if ((fd = mch_fopen((char *)fname, mode)) == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008121 semsg(_("E190: Cannot open \"%s\" for writing"), fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008122
8123 return fd;
8124}
8125
8126/*
8127 * ":mark" and ":k".
8128 */
8129 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008130ex_mark(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008131{
8132 pos_T pos;
8133
Bram Moolenaar10b94212021-02-19 21:42:57 +01008134#ifdef FEAT_EVAL
8135 if (not_in_vim9(eap) == FAIL)
8136 return;
8137#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008138 if (*eap->arg == NUL) // No argument?
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008139 emsg(_(e_argreq));
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008140 else if (eap->arg[1] != NUL) // more than one character?
Bram Moolenaar2d06bfd2020-07-23 17:16:18 +02008141 semsg(_(e_trailing_arg), eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008142 else
8143 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008144 pos = curwin->w_cursor; // save curwin->w_cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00008145 curwin->w_cursor.lnum = eap->line2;
8146 beginline(BL_WHITE | BL_FIX);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008147 if (setmark(*eap->arg) == FAIL) // set mark
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008148 emsg(_("E191: Argument must be a letter or forward/backward quote"));
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008149 curwin->w_cursor = pos; // restore curwin->w_cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00008150 }
8151}
8152
8153/*
8154 * Update w_topline, w_leftcol and the cursor position.
8155 */
8156 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008157update_topline_cursor(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008158{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008159 check_cursor(); // put cursor on valid line
Bram Moolenaar071d4272004-06-13 20:20:40 +00008160 update_topline();
8161 if (!curwin->w_p_wrap)
8162 validate_cursor();
8163 update_curswant();
8164}
8165
Bram Moolenaar071d4272004-06-13 20:20:40 +00008166/*
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008167 * Save the current State and go to Normal mode.
8168 * Return TRUE if the typeahead could be saved.
8169 */
8170 int
8171save_current_state(save_state_T *sst)
8172{
8173 sst->save_msg_scroll = msg_scroll;
8174 sst->save_restart_edit = restart_edit;
8175 sst->save_msg_didout = msg_didout;
8176 sst->save_State = State;
8177 sst->save_insertmode = p_im;
8178 sst->save_finish_op = finish_op;
8179 sst->save_opcount = opcount;
Bram Moolenaarcce713d2019-03-04 11:40:12 +01008180 sst->save_reg_executing = reg_executing;
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008181
Bram Moolenaar4324d872020-12-01 20:12:24 +01008182 msg_scroll = FALSE; // no msg scrolling in Normal mode
8183 restart_edit = 0; // don't go to Insert mode
8184 p_im = FALSE; // don't use 'insertmode'
Bram Moolenaar9b8d6222020-12-28 18:26:00 +01008185
Bram Moolenaara452b802020-12-01 21:47:59 +01008186 sst->save_script_version = current_sctx.sc_version;
Bram Moolenaar4324d872020-12-01 20:12:24 +01008187 current_sctx.sc_version = 1; // not in Vim9 script
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008188
8189 /*
8190 * Save the current typeahead. This is required to allow using ":normal"
8191 * from an event handler and makes sure we don't hang when the argument
8192 * ends with half a command.
8193 */
8194 save_typeahead(&sst->tabuf);
8195 return sst->tabuf.typebuf_valid;
8196}
8197
8198 void
8199restore_current_state(save_state_T *sst)
8200{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008201 // Restore the previous typeahead.
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008202 restore_typeahead(&sst->tabuf);
8203
8204 msg_scroll = sst->save_msg_scroll;
8205 restart_edit = sst->save_restart_edit;
8206 p_im = sst->save_insertmode;
8207 finish_op = sst->save_finish_op;
8208 opcount = sst->save_opcount;
Bram Moolenaarcce713d2019-03-04 11:40:12 +01008209 reg_executing = sst->save_reg_executing;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008210 msg_didout |= sst->save_msg_didout; // don't reset msg_didout now
Bram Moolenaar4324d872020-12-01 20:12:24 +01008211 current_sctx.sc_version = sst->save_script_version;
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008212
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008213 // Restore the state (needed when called from a function executed for
8214 // 'indentexpr'). Update the mouse and cursor, they may have changed.
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008215 State = sst->save_State;
8216#ifdef CURSOR_SHAPE
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008217 ui_cursor_shape(); // may show different cursor shape
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008218#endif
8219}
8220
8221/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00008222 * ":normal[!] {commands}": Execute normal mode commands.
8223 */
Bram Moolenaar20fb9f32016-01-30 23:20:33 +01008224 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008225ex_normal(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008226{
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008227 save_state_T save_state;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008228 char_u *arg = NULL;
8229 int l;
8230 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008231
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00008232 if (ex_normal_lock > 0)
8233 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008234 emsg(_(e_secure));
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00008235 return;
8236 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008237 if (ex_normal_busy >= p_mmd)
8238 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008239 emsg(_("E192: Recursive use of :normal too deep"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00008240 return;
8241 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008242
Bram Moolenaar071d4272004-06-13 20:20:40 +00008243 /*
8244 * vgetc() expects a CSI and K_SPECIAL to have been escaped. Don't do
8245 * this for the K_SPECIAL leading byte, otherwise special keys will not
8246 * work.
8247 */
8248 if (has_mbyte)
8249 {
8250 int len = 0;
8251
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008252 // Count the number of characters to be escaped.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008253 for (p = eap->arg; *p != NUL; ++p)
8254 {
Bram Moolenaar13505972019-01-24 15:04:48 +01008255#ifdef FEAT_GUI
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008256 if (*p == CSI) // leadbyte CSI
Bram Moolenaar071d4272004-06-13 20:20:40 +00008257 len += 2;
Bram Moolenaar13505972019-01-24 15:04:48 +01008258#endif
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00008259 for (l = (*mb_ptr2len)(p) - 1; l > 0; --l)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008260 if (*++p == K_SPECIAL // trailbyte K_SPECIAL or CSI
Bram Moolenaar13505972019-01-24 15:04:48 +01008261#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00008262 || *p == CSI
Bram Moolenaar13505972019-01-24 15:04:48 +01008263#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008264 )
8265 len += 2;
8266 }
8267 if (len > 0)
8268 {
Bram Moolenaar964b3742019-05-24 18:54:09 +02008269 arg = alloc(STRLEN(eap->arg) + len + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008270 if (arg != NULL)
8271 {
8272 len = 0;
8273 for (p = eap->arg; *p != NUL; ++p)
8274 {
8275 arg[len++] = *p;
Bram Moolenaar13505972019-01-24 15:04:48 +01008276#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00008277 if (*p == CSI)
8278 {
8279 arg[len++] = KS_EXTRA;
8280 arg[len++] = (int)KE_CSI;
8281 }
Bram Moolenaar13505972019-01-24 15:04:48 +01008282#endif
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00008283 for (l = (*mb_ptr2len)(p) - 1; l > 0; --l)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008284 {
8285 arg[len++] = *++p;
8286 if (*p == K_SPECIAL)
8287 {
8288 arg[len++] = KS_SPECIAL;
8289 arg[len++] = KE_FILLER;
8290 }
Bram Moolenaar13505972019-01-24 15:04:48 +01008291#ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00008292 else if (*p == CSI)
8293 {
8294 arg[len++] = KS_EXTRA;
8295 arg[len++] = (int)KE_CSI;
8296 }
Bram Moolenaar13505972019-01-24 15:04:48 +01008297#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008298 }
8299 arg[len] = NUL;
8300 }
8301 }
8302 }
8303 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008304
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008305 ++ex_normal_busy;
8306 if (save_current_state(&save_state))
Bram Moolenaar071d4272004-06-13 20:20:40 +00008307 {
8308 /*
8309 * Repeat the :normal command for each line in the range. When no
8310 * range given, execute it just once, without positioning the cursor
8311 * first.
8312 */
8313 do
8314 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00008315 if (eap->addr_count != 0)
8316 {
8317 curwin->w_cursor.lnum = eap->line1++;
8318 curwin->w_cursor.col = 0;
Bram Moolenaard5d37532017-03-27 23:02:07 +02008319 check_cursor_moved(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008320 }
8321
Bram Moolenaar13505972019-01-24 15:04:48 +01008322 exec_normal_cmd(arg != NULL
8323 ? arg
8324 : eap->arg, eap->forceit ? REMAP_NONE : REMAP_YES, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008325 }
8326 while (eap->addr_count > 0 && eap->line1 <= eap->line2 && !got_int);
8327 }
8328
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008329 // Might not return to the main loop when in an event handler.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008330 update_topline_cursor();
8331
Bram Moolenaara21a6a92017-09-23 16:33:50 +02008332 restore_current_state(&save_state);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008333 --ex_normal_busy;
Bram Moolenaareda73602014-11-05 09:53:23 +01008334 setmouse();
Bram Moolenaareda73602014-11-05 09:53:23 +01008335#ifdef CURSOR_SHAPE
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008336 ui_cursor_shape(); // may show different cursor shape
Bram Moolenaareda73602014-11-05 09:53:23 +01008337#endif
8338
Bram Moolenaar071d4272004-06-13 20:20:40 +00008339 vim_free(arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008340}
8341
8342/*
Bram Moolenaar64969662005-12-14 21:59:55 +00008343 * ":startinsert", ":startreplace" and ":startgreplace"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008344 */
8345 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008346ex_startinsert(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008347{
Bram Moolenaarfd371682005-01-14 21:42:54 +00008348 if (eap->forceit)
8349 {
Bram Moolenaar8d3b5102019-09-05 21:29:01 +02008350 // cursor line can be zero on startup
Bram Moolenaar09ca9322017-09-26 17:40:45 +02008351 if (!curwin->w_cursor.lnum)
8352 curwin->w_cursor.lnum = 1;
Bram Moolenaar8d3b5102019-09-05 21:29:01 +02008353 set_cursor_for_append_to_line();
Bram Moolenaarfd371682005-01-14 21:42:54 +00008354 }
Bram Moolenaareb58a242020-04-19 18:13:19 +02008355#ifdef FEAT_TERMINAL
8356 // Ignore this when running in an active terminal.
8357 if (term_job_running(curbuf->b_term))
8358 return;
8359#endif
Bram Moolenaarfd371682005-01-14 21:42:54 +00008360
Bram Moolenaar8d3b5102019-09-05 21:29:01 +02008361 // Ignore the command when already in Insert mode. Inserting an
8362 // expression register that invokes a function can do this.
Bram Moolenaara40c5002005-01-09 21:16:21 +00008363 if (State & INSERT)
8364 return;
8365
Bram Moolenaar64969662005-12-14 21:59:55 +00008366 if (eap->cmdidx == CMD_startinsert)
8367 restart_edit = 'a';
8368 else if (eap->cmdidx == CMD_startreplace)
8369 restart_edit = 'R';
Bram Moolenaar071d4272004-06-13 20:20:40 +00008370 else
Bram Moolenaar64969662005-12-14 21:59:55 +00008371 restart_edit = 'V';
8372
8373 if (!eap->forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008374 {
Bram Moolenaar325b7a22004-07-05 15:58:32 +00008375 if (eap->cmdidx == CMD_startinsert)
8376 restart_edit = 'i';
Bram Moolenaar8d3b5102019-09-05 21:29:01 +02008377 curwin->w_curswant = 0; // avoid MAXCOL
Bram Moolenaar071d4272004-06-13 20:20:40 +00008378 }
Bram Moolenaar957cf672020-11-12 14:21:06 +01008379
8380 if (VIsual_active)
8381 showmode();
Bram Moolenaar071d4272004-06-13 20:20:40 +00008382}
8383
8384/*
8385 * ":stopinsert"
8386 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00008387 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008388ex_stopinsert(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008389{
8390 restart_edit = 0;
8391 stop_insert_mode = TRUE;
Bram Moolenaarfd773e92016-04-02 19:39:16 +02008392 clearmode();
Bram Moolenaar071d4272004-06-13 20:20:40 +00008393}
Bram Moolenaar071d4272004-06-13 20:20:40 +00008394
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008395/*
8396 * Execute normal mode command "cmd".
8397 * "remap" can be REMAP_NONE or REMAP_YES.
8398 */
8399 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008400exec_normal_cmd(char_u *cmd, int remap, int silent)
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008401{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008402 // Stuff the argument into the typeahead buffer.
Bram Moolenaar25281632016-01-21 23:32:32 +01008403 ins_typebuf(cmd, remap, 0, TRUE, silent);
Bram Moolenaar586c70c2018-10-02 16:23:58 +02008404 exec_normal(FALSE, FALSE, FALSE);
Bram Moolenaar25281632016-01-21 23:32:32 +01008405}
Bram Moolenaar25281632016-01-21 23:32:32 +01008406
Bram Moolenaar25281632016-01-21 23:32:32 +01008407/*
8408 * Execute normal_cmd() until there is no typeahead left.
Bram Moolenaar586c70c2018-10-02 16:23:58 +02008409 * When "use_vpeekc" is TRUE use vpeekc() to check for available chars.
Bram Moolenaar25281632016-01-21 23:32:32 +01008410 */
8411 void
Bram Moolenaar586c70c2018-10-02 16:23:58 +02008412exec_normal(int was_typed, int use_vpeekc, int may_use_terminal_loop UNUSED)
Bram Moolenaar25281632016-01-21 23:32:32 +01008413{
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008414 oparg_T oa;
Bram Moolenaar905dd902019-04-07 14:21:47 +02008415 int c;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008416
Bram Moolenaar905dd902019-04-07 14:21:47 +02008417 // When calling vpeekc() from feedkeys() it will return Ctrl_C when there
8418 // is nothing to get, so also check for Ctrl_C.
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008419 clear_oparg(&oa);
8420 finish_op = FALSE;
Bram Moolenaar586c70c2018-10-02 16:23:58 +02008421 while ((!stuff_empty()
8422 || ((was_typed || !typebuf_typed()) && typebuf.tb_len > 0)
Bram Moolenaar905dd902019-04-07 14:21:47 +02008423 || (use_vpeekc && (c = vpeekc()) != NUL && c != Ctrl_C))
Bram Moolenaar586c70c2018-10-02 16:23:58 +02008424 && !got_int)
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008425 {
8426 update_topline_cursor();
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02008427#ifdef FEAT_TERMINAL
Bram Moolenaar655a82a2018-05-08 22:01:07 +02008428 if (may_use_terminal_loop && term_use_loop()
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02008429 && oa.op_type == OP_NOP && oa.regname == NUL
8430 && !VIsual_active)
8431 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008432 // If terminal_loop() returns OK we got a key that is handled
8433 // in Normal model. With FAIL we first need to position the
8434 // cursor and the screen needs to be redrawn.
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02008435 if (terminal_loop(TRUE) == OK)
8436 normal_cmd(&oa, TRUE);
8437 }
8438 else
8439#endif
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008440 // execute a Normal mode cmd
Bram Moolenaarb2ac14c2018-05-01 18:47:59 +02008441 normal_cmd(&oa, TRUE);
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008442 }
8443}
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00008444
Bram Moolenaar071d4272004-06-13 20:20:40 +00008445#ifdef FEAT_FIND_ID
8446 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008447ex_checkpath(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008448{
8449 find_pattern_in_path(NULL, 0, 0, FALSE, FALSE, CHECK_PATH, 1L,
8450 eap->forceit ? ACTION_SHOW_ALL : ACTION_SHOW,
8451 (linenr_T)1, (linenr_T)MAXLNUM);
8452}
8453
Bram Moolenaar4033c552017-09-16 20:54:51 +02008454#if defined(FEAT_QUICKFIX)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008455/*
8456 * ":psearch"
8457 */
8458 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008459ex_psearch(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008460{
8461 g_do_tagpreview = p_pvh;
8462 ex_findpat(eap);
8463 g_do_tagpreview = 0;
8464}
8465#endif
8466
8467 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008468ex_findpat(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008469{
8470 int whole = TRUE;
8471 long n;
8472 char_u *p;
8473 int action;
8474
8475 switch (cmdnames[eap->cmdidx].cmd_name[2])
8476 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008477 case 'e': // ":psearch", ":isearch" and ":dsearch"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008478 if (cmdnames[eap->cmdidx].cmd_name[0] == 'p')
8479 action = ACTION_GOTO;
8480 else
8481 action = ACTION_SHOW;
8482 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008483 case 'i': // ":ilist" and ":dlist"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008484 action = ACTION_SHOW_ALL;
8485 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008486 case 'u': // ":ijump" and ":djump"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008487 action = ACTION_GOTO;
8488 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008489 default: // ":isplit" and ":dsplit"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008490 action = ACTION_SPLIT;
8491 break;
8492 }
8493
8494 n = 1;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008495 if (vim_isdigit(*eap->arg)) // get count
Bram Moolenaar071d4272004-06-13 20:20:40 +00008496 {
8497 n = getdigits(&eap->arg);
8498 eap->arg = skipwhite(eap->arg);
8499 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008500 if (*eap->arg == '/') // Match regexp, not just whole words
Bram Moolenaar071d4272004-06-13 20:20:40 +00008501 {
8502 whole = FALSE;
8503 ++eap->arg;
Bram Moolenaarf4e20992020-12-21 19:59:08 +01008504 p = skip_regexp(eap->arg, '/', magic_isset());
Bram Moolenaar071d4272004-06-13 20:20:40 +00008505 if (*p)
8506 {
8507 *p++ = NUL;
8508 p = skipwhite(p);
8509
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008510 // Check for trailing illegal characters
Bram Moolenaarfaac4102020-04-20 17:46:14 +02008511 if (!ends_excmd2(eap->arg, p))
Bram Moolenaar8930caa2020-07-23 16:37:03 +02008512 eap->errmsg = ex_errmsg(e_trailing_arg, p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008513 else
8514 eap->nextcmd = check_nextcmd(p);
8515 }
8516 }
8517 if (!eap->skip)
8518 find_pattern_in_path(eap->arg, 0, (int)STRLEN(eap->arg),
8519 whole, !eap->forceit,
8520 *eap->cmd == 'd' ? FIND_DEFINE : FIND_ANY,
8521 n, action, eap->line1, eap->line2);
8522}
8523#endif
8524
Bram Moolenaar071d4272004-06-13 20:20:40 +00008525
Bram Moolenaar4033c552017-09-16 20:54:51 +02008526#ifdef FEAT_QUICKFIX
Bram Moolenaar071d4272004-06-13 20:20:40 +00008527/*
8528 * ":ptag", ":ptselect", ":ptjump", ":ptnext", etc.
8529 */
8530 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008531ex_ptag(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008532{
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008533 g_do_tagpreview = p_pvh; // will be reset to 0 in ex_tag_cmd()
Bram Moolenaar071d4272004-06-13 20:20:40 +00008534 ex_tag_cmd(eap, cmdnames[eap->cmdidx].cmd_name + 1);
8535}
8536
8537/*
8538 * ":pedit"
8539 */
8540 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008541ex_pedit(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008542{
8543 win_T *curwin_save = curwin;
8544
Bram Moolenaar3a2505c2020-03-09 16:40:41 +01008545 if (ERROR_IF_ANY_POPUP_WINDOW)
8546 return;
8547
Bram Moolenaar026587b2019-08-17 15:08:00 +02008548 // Open the preview window or popup and make it the current window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008549 g_do_tagpreview = p_pvh;
Bram Moolenaar576a4a62019-08-18 15:25:17 +02008550 prepare_tagpreview(TRUE, TRUE, FALSE);
Bram Moolenaar1b6d9c42019-08-05 21:52:04 +02008551
Bram Moolenaar026587b2019-08-17 15:08:00 +02008552 // Edit the file.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008553 do_exedit(eap, NULL);
Bram Moolenaar1b6d9c42019-08-05 21:52:04 +02008554
Bram Moolenaar071d4272004-06-13 20:20:40 +00008555 if (curwin != curwin_save && win_valid(curwin_save))
8556 {
Bram Moolenaar026587b2019-08-17 15:08:00 +02008557 // Return cursor to where we were
Bram Moolenaar071d4272004-06-13 20:20:40 +00008558 validate_cursor();
8559 redraw_later(VALID);
8560 win_enter(curwin_save, TRUE);
8561 }
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01008562# ifdef FEAT_PROP_POPUP
Bram Moolenaar1b6d9c42019-08-05 21:52:04 +02008563 else if (WIN_IS_POPUP(curwin))
8564 {
8565 // can't keep focus in popup window
8566 win_enter(firstwin, TRUE);
8567 }
8568# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008569 g_do_tagpreview = 0;
8570}
Bram Moolenaar4033c552017-09-16 20:54:51 +02008571#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008572
8573/*
8574 * ":stag", ":stselect" and ":stjump".
8575 */
8576 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008577ex_stag(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008578{
8579 postponed_split = -1;
Bram Moolenaare1004402020-10-24 20:49:43 +02008580 postponed_split_flags = cmdmod.cmod_split;
8581 postponed_split_tab = cmdmod.cmod_tab;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008582 ex_tag_cmd(eap, cmdnames[eap->cmdidx].cmd_name + 1);
8583 postponed_split_flags = 0;
Bram Moolenaard326ce82007-03-11 14:48:29 +00008584 postponed_split_tab = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008585}
Bram Moolenaar071d4272004-06-13 20:20:40 +00008586
8587/*
8588 * ":tag", ":tselect", ":tjump", ":tnext", etc.
8589 */
8590 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008591ex_tag(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008592{
8593 ex_tag_cmd(eap, cmdnames[eap->cmdidx].cmd_name);
8594}
8595
8596 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008597ex_tag_cmd(exarg_T *eap, char_u *name)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008598{
8599 int cmd;
8600
8601 switch (name[1])
8602 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008603 case 'j': cmd = DT_JUMP; // ":tjump"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008604 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008605 case 's': cmd = DT_SELECT; // ":tselect"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008606 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008607 case 'p': cmd = DT_PREV; // ":tprevious"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008608 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008609 case 'N': cmd = DT_PREV; // ":tNext"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008610 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008611 case 'n': cmd = DT_NEXT; // ":tnext"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008612 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008613 case 'o': cmd = DT_POP; // ":pop"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008614 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008615 case 'f': // ":tfirst"
8616 case 'r': cmd = DT_FIRST; // ":trewind"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008617 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008618 case 'l': cmd = DT_LAST; // ":tlast"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008619 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008620 default: // ":tag"
Bram Moolenaar071d4272004-06-13 20:20:40 +00008621#ifdef FEAT_CSCOPE
Bram Moolenaar7c94c262008-06-20 09:11:34 +00008622 if (p_cst && *eap->arg != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008623 {
Bram Moolenaard4db7712016-11-12 19:16:46 +01008624 ex_cstag(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008625 return;
8626 }
8627#endif
8628 cmd = DT_TAG;
8629 break;
8630 }
8631
Bram Moolenaarb8a7b562006-02-01 21:47:16 +00008632 if (name[0] == 'l')
8633 {
8634#ifndef FEAT_QUICKFIX
8635 ex_ni(eap);
8636 return;
8637#else
8638 cmd = DT_LTAG;
8639#endif
8640 }
8641
Bram Moolenaar071d4272004-06-13 20:20:40 +00008642 do_tag(eap->arg, cmd, eap->addr_count > 0 ? (int)eap->line2 : 1,
8643 eap->forceit, TRUE);
8644}
8645
8646/*
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008647 * Check "str" for starting with a special cmdline variable.
8648 * If found return one of the SPEC_ values and set "*usedlen" to the length of
8649 * the variable. Otherwise return -1 and "*usedlen" is unchanged.
8650 */
8651 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008652find_cmdline_var(char_u *src, int *usedlen)
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008653{
8654 int len;
8655 int i;
Bram Moolenaar8f0b2d42009-05-16 14:41:10 +00008656 static char *(spec_str[]) = {
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008657 "%",
8658#define SPEC_PERC 0
8659 "#",
Bram Moolenaar65f08472017-09-10 18:16:20 +02008660#define SPEC_HASH (SPEC_PERC + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008661 "<cword>", // cursor word
Bram Moolenaar65f08472017-09-10 18:16:20 +02008662#define SPEC_CWORD (SPEC_HASH + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008663 "<cWORD>", // cursor WORD
Bram Moolenaar65f08472017-09-10 18:16:20 +02008664#define SPEC_CCWORD (SPEC_CWORD + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008665 "<cexpr>", // expr under cursor
Bram Moolenaar65f08472017-09-10 18:16:20 +02008666#define SPEC_CEXPR (SPEC_CCWORD + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008667 "<cfile>", // cursor path name
Bram Moolenaar65f08472017-09-10 18:16:20 +02008668#define SPEC_CFILE (SPEC_CEXPR + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008669 "<sfile>", // ":so" file name
Bram Moolenaar65f08472017-09-10 18:16:20 +02008670#define SPEC_SFILE (SPEC_CFILE + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008671 "<slnum>", // ":so" file line number
Bram Moolenaar65f08472017-09-10 18:16:20 +02008672#define SPEC_SLNUM (SPEC_SFILE + 1)
Bram Moolenaara5d04232020-07-26 15:37:02 +02008673 "<stack>", // call stack
8674#define SPEC_STACK (SPEC_SLNUM + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008675 "<afile>", // autocommand file name
Bram Moolenaara5d04232020-07-26 15:37:02 +02008676#define SPEC_AFILE (SPEC_STACK + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008677 "<abuf>", // autocommand buffer number
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02008678#define SPEC_ABUF (SPEC_AFILE + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008679 "<amatch>", // autocommand match name
Bram Moolenaarf2bd8ef2018-03-04 18:08:14 +01008680#define SPEC_AMATCH (SPEC_ABUF + 1)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008681 "<sflnum>", // script file line number
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02008682#define SPEC_SFLNUM (SPEC_AMATCH + 1)
Bram Moolenaar90944302020-08-01 20:45:11 +02008683 "<SID>", // script ID: <SNR>123_
8684#define SPEC_SID (SPEC_SFLNUM + 1)
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008685#ifdef FEAT_CLIENTSERVER
8686 "<client>"
Bram Moolenaar90944302020-08-01 20:45:11 +02008687# define SPEC_CLIENT (SPEC_SID + 1)
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008688#endif
8689 };
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008690
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00008691 for (i = 0; i < (int)(sizeof(spec_str) / sizeof(char *)); ++i)
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008692 {
8693 len = (int)STRLEN(spec_str[i]);
8694 if (STRNCMP(src, spec_str[i], len) == 0)
8695 {
8696 *usedlen = len;
8697 return i;
8698 }
8699 }
8700 return -1;
8701}
8702
8703/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00008704 * Evaluate cmdline variables.
8705 *
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008706 * change "%" to curbuf->b_ffname
8707 * "#" to curwin->w_alt_fnum
8708 * "%%" to curwin->w_alt_fnum in Vim9 script
8709 * "<cword>" to word under the cursor
8710 * "<cWORD>" to WORD under the cursor
8711 * "<cexpr>" to C-expression under the cursor
8712 * "<cfile>" to path name under the cursor
8713 * "<sfile>" to sourced file name
8714 * "<stack>" to call stack
8715 * "<slnum>" to sourced file line number
8716 * "<afile>" to file name for autocommand
8717 * "<abuf>" to buffer number for autocommand
8718 * "<amatch>" to matching name for autocommand
Bram Moolenaar071d4272004-06-13 20:20:40 +00008719 *
8720 * When an error is detected, "errormsg" is set to a non-NULL pointer (may be
8721 * "" for error without a message) and NULL is returned.
8722 * Returns an allocated string if a valid match was found.
8723 * Returns NULL if no match was found. "usedlen" then still contains the
8724 * number of characters to skip.
8725 */
8726 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01008727eval_vars(
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008728 char_u *src, // pointer into commandline
8729 char_u *srcstart, // beginning of valid memory for src
8730 int *usedlen, // characters after src that are used
8731 linenr_T *lnump, // line number for :e command, or NULL
8732 char **errormsg, // pointer to error message
8733 int *escaped) // return value has escaped white space (can
8734 // be NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008735{
8736 int i;
8737 char_u *s;
8738 char_u *result;
8739 char_u *resultbuf = NULL;
8740 int resultlen;
8741 buf_T *buf;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008742 int valid = VALID_HEAD + VALID_PATH; // assume valid result
Bram Moolenaar071d4272004-06-13 20:20:40 +00008743 int spec_idx;
Bram Moolenaarfd249462018-07-28 16:14:30 +02008744 int tilde_file = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008745 int skip_mod = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008746 char_u strbuf[30];
Bram Moolenaar071d4272004-06-13 20:20:40 +00008747
8748 *errormsg = NULL;
Bram Moolenaar63b92542007-03-27 14:57:09 +00008749 if (escaped != NULL)
8750 *escaped = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008751
8752 /*
8753 * Check if there is something to do.
8754 */
Bram Moolenaar05bb9532008-07-04 09:44:11 +00008755 spec_idx = find_cmdline_var(src, usedlen);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008756 if (spec_idx < 0) // no match
Bram Moolenaar071d4272004-06-13 20:20:40 +00008757 {
8758 *usedlen = 1;
8759 return NULL;
8760 }
8761
8762 /*
8763 * Skip when preceded with a backslash "\%" and "\#".
8764 * Note: In "\\%" the % is also not recognized!
8765 */
8766 if (src > srcstart && src[-1] == '\\')
8767 {
8768 *usedlen = 0;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008769 STRMOVE(src - 1, src); // remove backslash
Bram Moolenaar071d4272004-06-13 20:20:40 +00008770 return NULL;
8771 }
8772
8773 /*
8774 * word or WORD under cursor
8775 */
Bram Moolenaar65f08472017-09-10 18:16:20 +02008776 if (spec_idx == SPEC_CWORD || spec_idx == SPEC_CCWORD
8777 || spec_idx == SPEC_CEXPR)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008778 {
Bram Moolenaar65f08472017-09-10 18:16:20 +02008779 resultlen = find_ident_under_cursor(&result,
8780 spec_idx == SPEC_CWORD ? (FIND_IDENT | FIND_STRING)
8781 : spec_idx == SPEC_CEXPR ? (FIND_IDENT | FIND_STRING | FIND_EVAL)
8782 : FIND_STRING);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008783 if (resultlen == 0)
8784 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008785 *errormsg = "";
Bram Moolenaar071d4272004-06-13 20:20:40 +00008786 return NULL;
8787 }
8788 }
8789
8790 /*
8791 * '#': Alternate file name
8792 * '%': Current file name
8793 * File name under the cursor
8794 * File name for autocommand
8795 * and following modifiers
8796 */
8797 else
8798 {
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008799 int off = 0;
8800
Bram Moolenaar071d4272004-06-13 20:20:40 +00008801 switch (spec_idx)
8802 {
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008803 case SPEC_PERC:
Bram Moolenaar39cb2da2020-12-27 17:35:18 +01008804#ifdef FEAT_EVAL
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008805 if (!in_vim9script() || src[1] != '%')
Bram Moolenaar39cb2da2020-12-27 17:35:18 +01008806#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008807 {
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008808 // '%': current file
8809 if (curbuf->b_fname == NULL)
8810 {
8811 result = (char_u *)"";
8812 valid = 0; // Must have ":p:h" to be valid
8813 }
8814 else
8815 {
8816 result = curbuf->b_fname;
8817 tilde_file = STRCMP(result, "~") == 0;
8818 }
8819 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008820 }
Bram Moolenaar39cb2da2020-12-27 17:35:18 +01008821#ifdef FEAT_EVAL
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008822 // "%%" alternate file
8823 off = 1;
Bram Moolenaar39cb2da2020-12-27 17:35:18 +01008824#endif
Bram Moolenaar9618a252020-12-27 19:18:03 +01008825 // FALLTHROUGH
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008826 case SPEC_HASH: // '#' or "#99": alternate file
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008827 if (off == 0 ? src[1] == '#' : src[2] == '%')
Bram Moolenaar071d4272004-06-13 20:20:40 +00008828 {
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008829 // "##" or "%%%": the argument list
Bram Moolenaar071d4272004-06-13 20:20:40 +00008830 result = arg_all();
8831 resultbuf = result;
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008832 *usedlen = off + 2;
Bram Moolenaar63b92542007-03-27 14:57:09 +00008833 if (escaped != NULL)
8834 *escaped = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008835 skip_mod = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008836 break;
8837 }
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008838 s = src + off + 1;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008839 if (*s == '<') // "#<99" uses v:oldfiles
Bram Moolenaard812df62008-11-09 12:46:09 +00008840 ++s;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008841 i = (int)getdigits(&s);
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008842 if (s == src + off + 2 && src[off + 1] == '-')
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008843 // just a minus sign, don't skip over it
Bram Moolenaarc312b8b2017-10-28 17:53:04 +02008844 s--;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008845 *usedlen = (int)(s - src); // length of what we expand
Bram Moolenaar071d4272004-06-13 20:20:40 +00008846
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008847 if (src[off + 1] == '<' && i != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008848 {
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008849 if (*usedlen < off + 2)
Bram Moolenaard812df62008-11-09 12:46:09 +00008850 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008851 // Should we give an error message for #<text?
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008852 *usedlen = off + 1;
Bram Moolenaard812df62008-11-09 12:46:09 +00008853 return NULL;
8854 }
8855#ifdef FEAT_EVAL
8856 result = list_find_str(get_vim_var_list(VV_OLDFILES),
8857 (long)i);
8858 if (result == NULL)
8859 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008860 *errormsg = "";
Bram Moolenaard812df62008-11-09 12:46:09 +00008861 return NULL;
8862 }
8863#else
Bram Moolenaar8e481e82019-01-15 20:07:48 +01008864 *errormsg = _("E809: #< is not available without the +eval feature");
Bram Moolenaar071d4272004-06-13 20:20:40 +00008865 return NULL;
Bram Moolenaard812df62008-11-09 12:46:09 +00008866#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008867 }
8868 else
Bram Moolenaard812df62008-11-09 12:46:09 +00008869 {
Bram Moolenaar4389f9c2020-12-27 16:55:11 +01008870 if (i == 0 && src[off + 1] == '<' && *usedlen > off + 1)
8871 *usedlen = off + 1;
Bram Moolenaard812df62008-11-09 12:46:09 +00008872 buf = buflist_findnr(i);
8873 if (buf == NULL)
8874 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008875 *errormsg = _("E194: No alternate file name to substitute for '#'");
Bram Moolenaard812df62008-11-09 12:46:09 +00008876 return NULL;
8877 }
8878 if (lnump != NULL)
8879 *lnump = ECMD_LAST;
8880 if (buf->b_fname == NULL)
8881 {
8882 result = (char_u *)"";
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008883 valid = 0; // Must have ":p:h" to be valid
Bram Moolenaard812df62008-11-09 12:46:09 +00008884 }
8885 else
Bram Moolenaar00136dc2018-07-25 21:19:13 +02008886 {
Bram Moolenaard812df62008-11-09 12:46:09 +00008887 result = buf->b_fname;
Bram Moolenaar00136dc2018-07-25 21:19:13 +02008888 tilde_file = STRCMP(result, "~") == 0;
8889 }
Bram Moolenaard812df62008-11-09 12:46:09 +00008890 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008891 break;
8892
8893#ifdef FEAT_SEARCHPATH
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008894 case SPEC_CFILE: // file name under cursor
Bram Moolenaard1f56e62006-02-22 21:25:37 +00008895 result = file_name_at_cursor(FNAME_MESS|FNAME_HYP, 1L, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008896 if (result == NULL)
8897 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008898 *errormsg = "";
Bram Moolenaar071d4272004-06-13 20:20:40 +00008899 return NULL;
8900 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008901 resultbuf = result; // remember allocated string
Bram Moolenaar071d4272004-06-13 20:20:40 +00008902 break;
8903#endif
8904
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008905 case SPEC_AFILE: // file name for autocommand
Bram Moolenaar071d4272004-06-13 20:20:40 +00008906 result = autocmd_fname;
Bram Moolenaarf6dad432008-09-18 19:29:58 +00008907 if (result != NULL && !autocmd_fname_full)
8908 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008909 // Still need to turn the fname into a full path. It is
8910 // postponed to avoid a delay when <afile> is not used.
Bram Moolenaarf6dad432008-09-18 19:29:58 +00008911 autocmd_fname_full = TRUE;
8912 result = FullName_save(autocmd_fname, FALSE);
8913 vim_free(autocmd_fname);
8914 autocmd_fname = result;
8915 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008916 if (result == NULL)
8917 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008918 *errormsg = _("E495: no autocommand file name to substitute for \"<afile>\"");
Bram Moolenaar071d4272004-06-13 20:20:40 +00008919 return NULL;
8920 }
Bram Moolenaara0174af2008-01-02 20:08:25 +00008921 result = shorten_fname1(result);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008922 break;
8923
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008924 case SPEC_ABUF: // buffer number for autocommand
Bram Moolenaar071d4272004-06-13 20:20:40 +00008925 if (autocmd_bufnr <= 0)
8926 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008927 *errormsg = _("E496: no autocommand buffer number to substitute for \"<abuf>\"");
Bram Moolenaar071d4272004-06-13 20:20:40 +00008928 return NULL;
8929 }
8930 sprintf((char *)strbuf, "%d", autocmd_bufnr);
8931 result = strbuf;
8932 break;
8933
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008934 case SPEC_AMATCH: // match name for autocommand
Bram Moolenaar071d4272004-06-13 20:20:40 +00008935 result = autocmd_match;
8936 if (result == NULL)
8937 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008938 *errormsg = _("E497: no autocommand match name to substitute for \"<amatch>\"");
Bram Moolenaar071d4272004-06-13 20:20:40 +00008939 return NULL;
8940 }
8941 break;
8942
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008943 case SPEC_SFILE: // file name for ":so" command
Bram Moolenaara5d04232020-07-26 15:37:02 +02008944 case SPEC_STACK: // call stack
Bram Moolenaar4f25b1a2020-09-10 19:25:05 +02008945 result = estack_sfile(spec_idx == SPEC_SFILE
8946 ? ESTACK_SFILE : ESTACK_STACK);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008947 if (result == NULL)
8948 {
Bram Moolenaara5d04232020-07-26 15:37:02 +02008949 *errormsg = spec_idx == SPEC_SFILE
8950 ? _("E498: no :source file name to substitute for \"<sfile>\"")
8951 : _("E489: no call stack to substitute for \"<stack>\"");
Bram Moolenaar071d4272004-06-13 20:20:40 +00008952 return NULL;
8953 }
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01008954 resultbuf = result; // remember allocated string
Bram Moolenaar071d4272004-06-13 20:20:40 +00008955 break;
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02008956
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008957 case SPEC_SLNUM: // line in file for ":so" command
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01008958 if (SOURCING_NAME == NULL || SOURCING_LNUM == 0)
Bram Moolenaar4dbbff52010-11-24 15:50:59 +01008959 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008960 *errormsg = _("E842: no line number to use for \"<slnum>\"");
Bram Moolenaar4dbbff52010-11-24 15:50:59 +01008961 return NULL;
8962 }
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01008963 sprintf((char *)strbuf, "%ld", SOURCING_LNUM);
Bram Moolenaar4dbbff52010-11-24 15:50:59 +01008964 result = strbuf;
8965 break;
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02008966
8967#ifdef FEAT_EVAL
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008968 case SPEC_SFLNUM: // line in script file
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01008969 if (current_sctx.sc_lnum + SOURCING_LNUM == 0)
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02008970 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01008971 *errormsg = _("E961: no line number to use for \"<sflnum>\"");
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02008972 return NULL;
8973 }
8974 sprintf((char *)strbuf, "%ld",
Bram Moolenaar1a47ae32019-12-29 23:04:25 +01008975 (long)(current_sctx.sc_lnum + SOURCING_LNUM));
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02008976 result = strbuf;
8977 break;
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02008978
Bram Moolenaar90944302020-08-01 20:45:11 +02008979 case SPEC_SID:
8980 if (current_sctx.sc_sid <= 0)
8981 {
8982 *errormsg = _(e_usingsid);
8983 return NULL;
8984 }
8985 sprintf((char *)strbuf, "<SNR>%d_", current_sctx.sc_sid);
8986 result = strbuf;
8987 break;
Bram Moolenaare4218b92020-08-01 21:11:38 +02008988#endif
Bram Moolenaar90944302020-08-01 20:45:11 +02008989
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02008990#ifdef FEAT_CLIENTSERVER
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008991 case SPEC_CLIENT: // Source of last submitted input
Bram Moolenaareb3593b2006-04-22 22:33:57 +00008992 sprintf((char *)strbuf, PRINTF_HEX_LONG_U,
8993 (long_u)clientWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008994 result = strbuf;
8995 break;
8996#endif
Bram Moolenaarf29c1c62018-09-10 21:05:02 +02008997
Bram Moolenaar9e0f6ec2017-05-16 09:36:54 +02008998 default:
Bram Moolenaar217e1b82019-12-01 21:41:28 +01008999 result = (char_u *)""; // avoid gcc warning
Bram Moolenaar9e0f6ec2017-05-16 09:36:54 +02009000 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009001 }
9002
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009003 resultlen = (int)STRLEN(result); // length of new string
9004 if (src[*usedlen] == '<') // remove the file name extension
Bram Moolenaar071d4272004-06-13 20:20:40 +00009005 {
9006 ++*usedlen;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009007 if ((s = vim_strrchr(result, '.')) != NULL && s >= gettail(result))
Bram Moolenaar071d4272004-06-13 20:20:40 +00009008 resultlen = (int)(s - result);
9009 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009010 else if (!skip_mod)
9011 {
Bram Moolenaar00136dc2018-07-25 21:19:13 +02009012 valid |= modify_fname(src, tilde_file, usedlen, &result, &resultbuf,
Bram Moolenaar071d4272004-06-13 20:20:40 +00009013 &resultlen);
9014 if (result == NULL)
9015 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009016 *errormsg = "";
Bram Moolenaar071d4272004-06-13 20:20:40 +00009017 return NULL;
9018 }
9019 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009020 }
9021
9022 if (resultlen == 0 || valid != VALID_HEAD + VALID_PATH)
9023 {
9024 if (valid != VALID_HEAD + VALID_PATH)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009025 // xgettext:no-c-format
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009026 *errormsg = _("E499: Empty file name for '%' or '#', only works with \":p:h\"");
Bram Moolenaar071d4272004-06-13 20:20:40 +00009027 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009028 *errormsg = _("E500: Evaluates to an empty string");
Bram Moolenaar071d4272004-06-13 20:20:40 +00009029 result = NULL;
9030 }
9031 else
9032 result = vim_strnsave(result, resultlen);
9033 vim_free(resultbuf);
9034 return result;
9035}
9036
9037/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00009038 * Expand the <sfile> string in "arg".
9039 *
9040 * Returns an allocated string, or NULL for any error.
9041 */
9042 char_u *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009043expand_sfile(char_u *arg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009044{
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009045 char *errormsg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009046 int len;
9047 char_u *result;
9048 char_u *newres;
9049 char_u *repl;
9050 int srclen;
9051 char_u *p;
9052
9053 result = vim_strsave(arg);
9054 if (result == NULL)
9055 return NULL;
9056
9057 for (p = result; *p; )
9058 {
9059 if (STRNCMP(p, "<sfile>", 7) != 0)
9060 ++p;
9061 else
9062 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009063 // replace "<sfile>" with the sourced file name, and do ":" stuff
Bram Moolenaar63b92542007-03-27 14:57:09 +00009064 repl = eval_vars(p, result, &srclen, NULL, &errormsg, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009065 if (errormsg != NULL)
9066 {
9067 if (*errormsg)
9068 emsg(errormsg);
9069 vim_free(result);
9070 return NULL;
9071 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009072 if (repl == NULL) // no match (cannot happen)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009073 {
9074 p += srclen;
9075 continue;
9076 }
9077 len = (int)STRLEN(result) - srclen + (int)STRLEN(repl) + 1;
9078 newres = alloc(len);
9079 if (newres == NULL)
9080 {
9081 vim_free(repl);
9082 vim_free(result);
9083 return NULL;
9084 }
9085 mch_memmove(newres, result, (size_t)(p - result));
9086 STRCPY(newres + (p - result), repl);
9087 len = (int)STRLEN(newres);
9088 STRCAT(newres, p + srclen);
9089 vim_free(repl);
9090 vim_free(result);
9091 result = newres;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009092 p = newres + len; // continue after the match
Bram Moolenaar071d4272004-06-13 20:20:40 +00009093 }
9094 }
9095
9096 return result;
9097}
Bram Moolenaar071d4272004-06-13 20:20:40 +00009098
Bram Moolenaar071d4272004-06-13 20:20:40 +00009099#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) || defined(PROTO)
Bram Moolenaar9c13b352005-05-19 20:53:52 +00009100/*
Bram Moolenaard9462e32011-04-11 21:35:11 +02009101 * Make a dialog message in "buff[DIALOG_MSG_SIZE]".
Bram Moolenaarb765d632005-06-07 21:00:02 +00009102 * "format" must contain "%s".
Bram Moolenaar9c13b352005-05-19 20:53:52 +00009103 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009104 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009105dialog_msg(char_u *buff, char *format, char_u *fname)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009106{
Bram Moolenaar071d4272004-06-13 20:20:40 +00009107 if (fname == NULL)
9108 fname = (char_u *)_("Untitled");
Bram Moolenaard9462e32011-04-11 21:35:11 +02009109 vim_snprintf((char *)buff, DIALOG_MSG_SIZE, format, fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009110}
9111#endif
9112
9113/*
9114 * ":behave {mswin,xterm}"
9115 */
9116 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009117ex_behave(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009118{
9119 if (STRCMP(eap->arg, "mswin") == 0)
9120 {
9121 set_option_value((char_u *)"selection", 0L, (char_u *)"exclusive", 0);
9122 set_option_value((char_u *)"selectmode", 0L, (char_u *)"mouse,key", 0);
9123 set_option_value((char_u *)"mousemodel", 0L, (char_u *)"popup", 0);
9124 set_option_value((char_u *)"keymodel", 0L,
9125 (char_u *)"startsel,stopsel", 0);
9126 }
9127 else if (STRCMP(eap->arg, "xterm") == 0)
9128 {
9129 set_option_value((char_u *)"selection", 0L, (char_u *)"inclusive", 0);
9130 set_option_value((char_u *)"selectmode", 0L, (char_u *)"", 0);
9131 set_option_value((char_u *)"mousemodel", 0L, (char_u *)"extend", 0);
9132 set_option_value((char_u *)"keymodel", 0L, (char_u *)"", 0);
9133 }
9134 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009135 semsg(_(e_invarg2), eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009136}
9137
Bram Moolenaar071d4272004-06-13 20:20:40 +00009138static int filetype_detect = FALSE;
9139static int filetype_plugin = FALSE;
9140static int filetype_indent = FALSE;
9141
9142/*
9143 * ":filetype [plugin] [indent] {on,off,detect}"
9144 * on: Load the filetype.vim file to install autocommands for file types.
9145 * off: Load the ftoff.vim file to remove all autocommands for file types.
9146 * plugin on: load filetype.vim and ftplugin.vim
9147 * plugin off: load ftplugof.vim
9148 * indent on: load filetype.vim and indent.vim
9149 * indent off: load indoff.vim
9150 */
9151 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009152ex_filetype(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009153{
9154 char_u *arg = eap->arg;
9155 int plugin = FALSE;
9156 int indent = FALSE;
9157
9158 if (*eap->arg == NUL)
9159 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009160 // Print current status.
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009161 smsg("filetype detection:%s plugin:%s indent:%s",
Bram Moolenaar071d4272004-06-13 20:20:40 +00009162 filetype_detect ? "ON" : "OFF",
9163 filetype_plugin ? (filetype_detect ? "ON" : "(on)") : "OFF",
9164 filetype_indent ? (filetype_detect ? "ON" : "(on)") : "OFF");
9165 return;
9166 }
9167
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009168 // Accept "plugin" and "indent" in any order.
Bram Moolenaar071d4272004-06-13 20:20:40 +00009169 for (;;)
9170 {
9171 if (STRNCMP(arg, "plugin", 6) == 0)
9172 {
9173 plugin = TRUE;
9174 arg = skipwhite(arg + 6);
9175 continue;
9176 }
9177 if (STRNCMP(arg, "indent", 6) == 0)
9178 {
9179 indent = TRUE;
9180 arg = skipwhite(arg + 6);
9181 continue;
9182 }
9183 break;
9184 }
9185 if (STRCMP(arg, "on") == 0 || STRCMP(arg, "detect") == 0)
9186 {
9187 if (*arg == 'o' || !filetype_detect)
9188 {
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01009189 source_runtime((char_u *)FILETYPE_FILE, DIP_ALL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009190 filetype_detect = TRUE;
9191 if (plugin)
9192 {
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01009193 source_runtime((char_u *)FTPLUGIN_FILE, DIP_ALL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009194 filetype_plugin = TRUE;
9195 }
9196 if (indent)
9197 {
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01009198 source_runtime((char_u *)INDENT_FILE, DIP_ALL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009199 filetype_indent = TRUE;
9200 }
9201 }
9202 if (*arg == 'd')
9203 {
Bram Moolenaar1610d052016-06-09 22:53:01 +02009204 (void)do_doautocmd((char_u *)"filetypedetect BufRead", TRUE, NULL);
Bram Moolenaara3227e22006-03-08 21:32:40 +00009205 do_modelines(0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009206 }
9207 }
9208 else if (STRCMP(arg, "off") == 0)
9209 {
9210 if (plugin || indent)
9211 {
9212 if (plugin)
9213 {
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01009214 source_runtime((char_u *)FTPLUGOF_FILE, DIP_ALL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009215 filetype_plugin = FALSE;
9216 }
9217 if (indent)
9218 {
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01009219 source_runtime((char_u *)INDOFF_FILE, DIP_ALL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009220 filetype_indent = FALSE;
9221 }
9222 }
9223 else
9224 {
Bram Moolenaar7f8989d2016-03-12 22:11:39 +01009225 source_runtime((char_u *)FTOFF_FILE, DIP_ALL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009226 filetype_detect = FALSE;
9227 }
9228 }
9229 else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009230 semsg(_(e_invarg2), arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009231}
9232
9233/*
Bram Moolenaar3e545692017-06-04 19:00:32 +02009234 * ":setfiletype [FALLBACK] {name}"
Bram Moolenaar071d4272004-06-13 20:20:40 +00009235 */
9236 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009237ex_setfiletype(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009238{
9239 if (!did_filetype)
Bram Moolenaar3e545692017-06-04 19:00:32 +02009240 {
9241 char_u *arg = eap->arg;
9242
9243 if (STRNCMP(arg, "FALLBACK ", 9) == 0)
9244 arg += 9;
9245
9246 set_option_value((char_u *)"filetype", 0L, arg, OPT_LOCAL);
9247 if (arg != eap->arg)
9248 did_filetype = FALSE;
9249 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009250}
Bram Moolenaar071d4272004-06-13 20:20:40 +00009251
Bram Moolenaar071d4272004-06-13 20:20:40 +00009252 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009253ex_digraphs(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009254{
9255#ifdef FEAT_DIGRAPHS
9256 if (*eap->arg != NUL)
9257 putdigraph(eap->arg);
9258 else
Bram Moolenaareae8ae12018-12-14 18:53:02 +01009259 listdigraphs(eap->forceit);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009260#else
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01009261 emsg(_("E196: No digraphs in this version"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00009262#endif
9263}
9264
Bram Moolenaar451fc7b2018-04-27 22:53:07 +02009265#if defined(FEAT_SEARCH_EXTRA) || defined(PROTO)
9266 void
9267set_no_hlsearch(int flag)
9268{
9269 no_hlsearch = flag;
9270# ifdef FEAT_EVAL
9271 set_vim_var_nr(VV_HLSEARCH, !no_hlsearch && p_hls);
9272# endif
9273}
9274
Bram Moolenaar071d4272004-06-13 20:20:40 +00009275/*
9276 * ":nohlsearch"
9277 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009278 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009279ex_nohlsearch(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009280{
Bram Moolenaar451fc7b2018-04-27 22:53:07 +02009281 set_no_hlsearch(TRUE);
Bram Moolenaarf71a3db2006-03-12 21:50:18 +00009282 redraw_all_later(SOME_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009283}
Bram Moolenaar071d4272004-06-13 20:20:40 +00009284#endif
9285
9286#ifdef FEAT_CRYPT
9287/*
9288 * ":X": Get crypt key
9289 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009290 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009291ex_X(exarg_T *eap UNUSED)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009292{
Bram Moolenaar3a0c9082014-11-12 15:15:42 +01009293 crypt_check_current_method();
Bram Moolenaar8f4ac012014-08-10 13:38:34 +02009294 (void)crypt_get_key(TRUE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009295}
9296#endif
9297
9298#ifdef FEAT_FOLDING
9299 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009300ex_fold(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009301{
9302 if (foldManualAllowed(TRUE))
9303 foldCreate(eap->line1, eap->line2);
9304}
9305
9306 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009307ex_foldopen(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009308{
9309 opFoldRange(eap->line1, eap->line2, eap->cmdidx == CMD_foldopen,
9310 eap->forceit, FALSE);
9311}
9312
9313 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01009314ex_folddo(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009315{
9316 linenr_T lnum;
9317
Bram Moolenaar4facea32019-10-12 20:17:40 +02009318# ifdef FEAT_CLIPBOARD
Bram Moolenaar6b1ee342014-08-06 18:17:11 +02009319 start_global_changes();
Bram Moolenaar4facea32019-10-12 20:17:40 +02009320# endif
Bram Moolenaar6b1ee342014-08-06 18:17:11 +02009321
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009322 // First set the marks for all lines closed/open.
Bram Moolenaar071d4272004-06-13 20:20:40 +00009323 for (lnum = eap->line1; lnum <= eap->line2; ++lnum)
9324 if (hasFolding(lnum, NULL, NULL) == (eap->cmdidx == CMD_folddoclosed))
9325 ml_setmarked(lnum);
9326
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009327 // Execute the command on the marked lines.
Bram Moolenaar071d4272004-06-13 20:20:40 +00009328 global_exe(eap->arg);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01009329 ml_clearmarked(); // clear rest of the marks
Bram Moolenaar4facea32019-10-12 20:17:40 +02009330# ifdef FEAT_CLIPBOARD
Bram Moolenaar6b1ee342014-08-06 18:17:11 +02009331 end_global_changes();
Bram Moolenaar4facea32019-10-12 20:17:40 +02009332# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00009333}
9334#endif
Bram Moolenaarf5291f32017-09-14 22:55:37 +02009335
Bram Moolenaar8a7d6542020-01-26 15:56:19 +01009336#if defined(FEAT_QUICKFIX) || defined(PROTO)
Bram Moolenaar39665952018-08-15 20:59:48 +02009337/*
9338 * Returns TRUE if the supplied Ex cmdidx is for a location list command
9339 * instead of a quickfix command.
9340 */
9341 int
9342is_loclist_cmd(int cmdidx)
9343{
Bram Moolenaar74c8be22018-08-23 22:51:40 +02009344 if (cmdidx < 0 || cmdidx >= CMD_SIZE)
Bram Moolenaar39665952018-08-15 20:59:48 +02009345 return FALSE;
9346 return cmdnames[cmdidx].cmd_name[0] == 'l';
9347}
9348#endif
9349
Bram Moolenaar4facea32019-10-12 20:17:40 +02009350#if defined(FEAT_TIMERS) || defined(PROTO)
Bram Moolenaarf5291f32017-09-14 22:55:37 +02009351 int
9352get_pressedreturn(void)
9353{
9354 return ex_pressedreturn;
9355}
9356
9357 void
9358set_pressedreturn(int val)
9359{
9360 ex_pressedreturn = val;
9361}
9362#endif