blob: c4732f704822023f51bc016c17a820a430bbcfea [file] [log] [blame]
Bram Moolenaar071d4272004-06-13 20:20:40 +00001/* vi:set ts=8 sts=4 sw=4:
2 *
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
22#ifdef FEAT_USR_CMDS
23typedef struct ucmd
24{
25 char_u *uc_name; /* The command name */
26 long_u uc_argt; /* The argument type */
27 char_u *uc_rep; /* The command's replacement string */
28 long uc_def; /* The default value for a range/count */
Bram Moolenaar071d4272004-06-13 20:20:40 +000029 int uc_compl; /* completion type */
Bram Moolenaar42b4dda2010-03-02 15:56:05 +010030# ifdef FEAT_EVAL
31 scid_T uc_scriptID; /* SID where the command was defined */
32# ifdef FEAT_CMDL_COMPL
Bram Moolenaar071d4272004-06-13 20:20:40 +000033 char_u *uc_compl_arg; /* completion argument if any */
Bram Moolenaar42b4dda2010-03-02 15:56:05 +010034# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +000035# endif
36} ucmd_T;
37
38#define UC_BUFFER 1 /* -buffer: local to current buffer */
39
Bram Moolenaar2c29bee2005-06-01 21:46:07 +000040static garray_T ucmds = {0, 0, sizeof(ucmd_T), 4, NULL};
Bram Moolenaar071d4272004-06-13 20:20:40 +000041
42#define USER_CMD(i) (&((ucmd_T *)(ucmds.ga_data))[i])
43#define USER_CMD_GA(gap, i) (&((ucmd_T *)((gap)->ga_data))[i])
44
45static void do_ucmd __ARGS((exarg_T *eap));
46static void ex_command __ARGS((exarg_T *eap));
Bram Moolenaar071d4272004-06-13 20:20:40 +000047static void ex_delcommand __ARGS((exarg_T *eap));
48# ifdef FEAT_CMDL_COMPL
49static char_u *get_user_command_name __ARGS((int idx));
50# endif
51
52#else
53# define ex_command ex_ni
54# define ex_comclear ex_ni
55# define ex_delcommand ex_ni
56#endif
57
58#ifdef FEAT_EVAL
Bram Moolenaar89d40322006-08-29 15:30:07 +000059static char_u *do_one_cmd __ARGS((char_u **, int, struct condstack *, char_u *(*fgetline)(int, void *, int), void *cookie));
Bram Moolenaar071d4272004-06-13 20:20:40 +000060#else
Bram Moolenaar89d40322006-08-29 15:30:07 +000061static char_u *do_one_cmd __ARGS((char_u **, int, char_u *(*fgetline)(int, void *, int), void *cookie));
Bram Moolenaar071d4272004-06-13 20:20:40 +000062static int if_level = 0; /* depth in :if */
63#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +000064static char_u *find_command __ARGS((exarg_T *eap, int *full));
65
66static void ex_abbreviate __ARGS((exarg_T *eap));
67static void ex_map __ARGS((exarg_T *eap));
68static void ex_unmap __ARGS((exarg_T *eap));
69static void ex_mapclear __ARGS((exarg_T *eap));
70static void ex_abclear __ARGS((exarg_T *eap));
71#ifndef FEAT_MENU
72# define ex_emenu ex_ni
73# define ex_menu ex_ni
74# define ex_menutranslate ex_ni
75#endif
76#ifdef FEAT_AUTOCMD
77static void ex_autocmd __ARGS((exarg_T *eap));
78static void ex_doautocmd __ARGS((exarg_T *eap));
79#else
80# define ex_autocmd ex_ni
81# define ex_doautocmd ex_ni
82# define ex_doautoall ex_ni
83#endif
84#ifdef FEAT_LISTCMDS
85static void ex_bunload __ARGS((exarg_T *eap));
86static void ex_buffer __ARGS((exarg_T *eap));
87static void ex_bmodified __ARGS((exarg_T *eap));
88static void ex_bnext __ARGS((exarg_T *eap));
89static void ex_bprevious __ARGS((exarg_T *eap));
90static void ex_brewind __ARGS((exarg_T *eap));
91static void ex_blast __ARGS((exarg_T *eap));
92#else
93# define ex_bunload ex_ni
94# define ex_buffer ex_ni
95# define ex_bmodified ex_ni
96# define ex_bnext ex_ni
97# define ex_bprevious ex_ni
98# define ex_brewind ex_ni
99# define ex_blast ex_ni
100# define buflist_list ex_ni
101# define ex_checktime ex_ni
102#endif
103#if !defined(FEAT_LISTCMDS) || !defined(FEAT_WINDOWS)
104# define ex_buffer_all ex_ni
105#endif
106static char_u *getargcmd __ARGS((char_u **));
107static char_u *skip_cmd_arg __ARGS((char_u *p, int rembs));
108static int getargopt __ARGS((exarg_T *eap));
109#ifndef FEAT_QUICKFIX
110# define ex_make ex_ni
Bram Moolenaar86b68352004-12-27 21:59:20 +0000111# define ex_cbuffer ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000112# define ex_cc ex_ni
113# define ex_cnext ex_ni
114# define ex_cfile ex_ni
115# define qf_list ex_ni
116# define qf_age ex_ni
117# define ex_helpgrep ex_ni
Bram Moolenaar86b68352004-12-27 21:59:20 +0000118# define ex_vimgrep ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000119#endif
120#if !defined(FEAT_QUICKFIX) || !defined(FEAT_WINDOWS)
121# define ex_cclose ex_ni
122# define ex_copen ex_ni
123# define ex_cwindow ex_ni
124#endif
Bram Moolenaar1e015462005-09-25 22:16:38 +0000125#if !defined(FEAT_QUICKFIX) || !defined(FEAT_EVAL)
126# define ex_cexpr ex_ni
127#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000128
129static int check_more __ARGS((int, int));
130static linenr_T get_address __ARGS((char_u **, int skip, int to_other_file));
Bram Moolenaardf177f62005-02-22 08:39:57 +0000131static void get_flags __ARGS((exarg_T *eap));
Bram Moolenaar85363ab2010-07-18 13:58:26 +0200132#if !defined(FEAT_PERL) \
133 || !defined(FEAT_PYTHON) || !defined(FEAT_PYTHON3) \
134 || !defined(FEAT_TCL) \
135 || !defined(FEAT_RUBY) \
136 || !defined(FEAT_LUA) \
137 || !defined(FEAT_MZSCHEME)
Bram Moolenaar7bb75552007-07-16 18:39:49 +0000138# define HAVE_EX_SCRIPT_NI
Bram Moolenaar071d4272004-06-13 20:20:40 +0000139static void ex_script_ni __ARGS((exarg_T *eap));
140#endif
141static char_u *invalid_range __ARGS((exarg_T *eap));
142static void correct_range __ARGS((exarg_T *eap));
Bram Moolenaard857f0e2005-06-21 22:37:39 +0000143#ifdef FEAT_QUICKFIX
144static char_u *replace_makeprg __ARGS((exarg_T *eap, char_u *p, char_u **cmdlinep));
145#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000146static char_u *repl_cmdline __ARGS((exarg_T *eap, char_u *src, int srclen, char_u *repl, char_u **cmdlinep));
147static void ex_highlight __ARGS((exarg_T *eap));
148static void ex_colorscheme __ARGS((exarg_T *eap));
149static void ex_quit __ARGS((exarg_T *eap));
150static void ex_cquit __ARGS((exarg_T *eap));
151static void ex_quit_all __ARGS((exarg_T *eap));
152#ifdef FEAT_WINDOWS
153static void ex_close __ARGS((exarg_T *eap));
Bram Moolenaarf740b292006-02-16 22:11:02 +0000154static void ex_win_close __ARGS((int forceit, win_T *win, tabpage_T *tp));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000155static void ex_only __ARGS((exarg_T *eap));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000156static void ex_resize __ARGS((exarg_T *eap));
157static void ex_stag __ARGS((exarg_T *eap));
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +0000158static void ex_tabclose __ARGS((exarg_T *eap));
Bram Moolenaar49d7bf12006-02-17 21:45:41 +0000159static void ex_tabonly __ARGS((exarg_T *eap));
Bram Moolenaar80a94a52006-02-23 21:26:58 +0000160static void ex_tabnext __ARGS((exarg_T *eap));
Bram Moolenaar80a94a52006-02-23 21:26:58 +0000161static void ex_tabmove __ARGS((exarg_T *eap));
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +0000162static void ex_tabs __ARGS((exarg_T *eap));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000163#else
164# define ex_close ex_ni
165# define ex_only ex_ni
166# define ex_all ex_ni
167# define ex_resize ex_ni
168# define ex_splitview ex_ni
169# define ex_stag ex_ni
Bram Moolenaar80a94a52006-02-23 21:26:58 +0000170# define ex_tabnext ex_ni
Bram Moolenaar80a94a52006-02-23 21:26:58 +0000171# define ex_tabmove ex_ni
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +0000172# define ex_tabs ex_ni
173# define ex_tabclose ex_ni
Bram Moolenaar49d7bf12006-02-17 21:45:41 +0000174# define ex_tabonly ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000175#endif
176#if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
177static void ex_pclose __ARGS((exarg_T *eap));
178static void ex_ptag __ARGS((exarg_T *eap));
179static void ex_pedit __ARGS((exarg_T *eap));
180#else
181# define ex_pclose ex_ni
182# define ex_ptag ex_ni
183# define ex_pedit ex_ni
184#endif
185static void ex_hide __ARGS((exarg_T *eap));
186static void ex_stop __ARGS((exarg_T *eap));
187static void ex_exit __ARGS((exarg_T *eap));
188static void ex_print __ARGS((exarg_T *eap));
189#ifdef FEAT_BYTEOFF
190static void ex_goto __ARGS((exarg_T *eap));
191#else
192# define ex_goto ex_ni
193#endif
194static void ex_shell __ARGS((exarg_T *eap));
195static void ex_preserve __ARGS((exarg_T *eap));
196static void ex_recover __ARGS((exarg_T *eap));
197#ifndef FEAT_LISTCMDS
198# define ex_argedit ex_ni
199# define ex_argadd ex_ni
200# define ex_argdelete ex_ni
201# define ex_listdo ex_ni
202#endif
203static void ex_mode __ARGS((exarg_T *eap));
204static void ex_wrongmodifier __ARGS((exarg_T *eap));
205static void ex_find __ARGS((exarg_T *eap));
Bram Moolenaardf177f62005-02-22 08:39:57 +0000206static void ex_open __ARGS((exarg_T *eap));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000207static void ex_edit __ARGS((exarg_T *eap));
208#if !defined(FEAT_GUI) && !defined(FEAT_CLIENTSERVER)
209# define ex_drop ex_ni
210#endif
211#ifndef FEAT_GUI
212# define ex_gui ex_nogui
213static void ex_nogui __ARGS((exarg_T *eap));
214#endif
215#if defined(FEAT_GUI_W32) && defined(FEAT_MENU) && defined(FEAT_TEAROFF)
216static void ex_tearoff __ARGS((exarg_T *eap));
217#else
218# define ex_tearoff ex_ni
219#endif
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +0000220#if (defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_GTK)) && defined(FEAT_MENU)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000221static void ex_popup __ARGS((exarg_T *eap));
222#else
223# define ex_popup ex_ni
224#endif
225#ifndef FEAT_GUI_MSWIN
226# define ex_simalt ex_ni
227#endif
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +0000228#if !defined(FEAT_GUI_MSWIN) && !defined(FEAT_GUI_GTK) && !defined(FEAT_GUI_MOTIF)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000229# define gui_mch_find_dialog ex_ni
230# define gui_mch_replace_dialog ex_ni
231#endif
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +0000232#if !defined(FEAT_GUI_GTK)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000233# define ex_helpfind ex_ni
234#endif
235#ifndef FEAT_CSCOPE
236# define do_cscope ex_ni
237# define do_scscope ex_ni
238# define do_cstag ex_ni
239#endif
240#ifndef FEAT_SYN_HL
241# define ex_syntax ex_ni
Bram Moolenaar860cae12010-06-05 23:22:07 +0200242# define ex_ownsyntax ex_ni
Bram Moolenaarf71a3db2006-03-12 21:50:18 +0000243#endif
244#ifndef FEAT_SPELL
Bram Moolenaarb765d632005-06-07 21:00:02 +0000245# define ex_spell ex_ni
Bram Moolenaar402d2fe2005-04-15 21:00:38 +0000246# define ex_mkspell ex_ni
Bram Moolenaarf417f2b2005-06-23 22:29:21 +0000247# define ex_spelldump ex_ni
Bram Moolenaar362e1a32006-03-06 23:29:24 +0000248# define ex_spellinfo ex_ni
Bram Moolenaara1ba8112005-06-28 23:23:32 +0000249# define ex_spellrepall ex_ni
Bram Moolenaar402d2fe2005-04-15 21:00:38 +0000250#endif
Bram Moolenaar55debbe2010-05-23 23:34:36 +0200251#ifndef FEAT_PERSISTENT_UNDO
252# define ex_rundo ex_ni
253# define ex_wundo ex_ni
254#endif
Bram Moolenaar0ba04292010-07-14 23:23:17 +0200255#ifndef FEAT_LUA
256# define ex_lua ex_script_ni
257# define ex_luado ex_ni
258# define ex_luafile ex_ni
259#endif
Bram Moolenaar325b7a22004-07-05 15:58:32 +0000260#ifndef FEAT_MZSCHEME
261# define ex_mzscheme ex_script_ni
262# define ex_mzfile ex_ni
263#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000264#ifndef FEAT_PERL
265# define ex_perl ex_script_ni
266# define ex_perldo ex_ni
267#endif
268#ifndef FEAT_PYTHON
269# define ex_python ex_script_ni
270# define ex_pyfile ex_ni
271#endif
Bram Moolenaarbd5e15f2010-07-17 21:19:38 +0200272#ifndef FEAT_PYTHON3
Bram Moolenaar368373e2010-07-19 20:46:22 +0200273# define ex_py3 ex_script_ni
Bram Moolenaarbd5e15f2010-07-17 21:19:38 +0200274# define ex_py3file ex_ni
275#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000276#ifndef FEAT_TCL
277# define ex_tcl ex_script_ni
278# define ex_tcldo ex_ni
279# define ex_tclfile ex_ni
280#endif
281#ifndef FEAT_RUBY
282# define ex_ruby ex_script_ni
283# define ex_rubydo ex_ni
284# define ex_rubyfile ex_ni
285#endif
286#ifndef FEAT_SNIFF
287# define ex_sniff ex_ni
288#endif
289#ifndef FEAT_KEYMAP
290# define ex_loadkeymap ex_ni
291#endif
292static void ex_swapname __ARGS((exarg_T *eap));
293static void ex_syncbind __ARGS((exarg_T *eap));
294static void ex_read __ARGS((exarg_T *eap));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000295static void ex_pwd __ARGS((exarg_T *eap));
296static void ex_equal __ARGS((exarg_T *eap));
297static void ex_sleep __ARGS((exarg_T *eap));
298static void do_exmap __ARGS((exarg_T *eap, int isabbrev));
299static void ex_winsize __ARGS((exarg_T *eap));
300#ifdef FEAT_WINDOWS
301static void ex_wincmd __ARGS((exarg_T *eap));
302#else
303# define ex_wincmd ex_ni
304#endif
Bram Moolenaar843ee412004-06-30 16:16:41 +0000305#if defined(FEAT_GUI) || defined(UNIX) || defined(VMS) || defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000306static void ex_winpos __ARGS((exarg_T *eap));
307#else
308# define ex_winpos ex_ni
309#endif
310static void ex_operators __ARGS((exarg_T *eap));
311static void ex_put __ARGS((exarg_T *eap));
312static void ex_copymove __ARGS((exarg_T *eap));
Bram Moolenaardf177f62005-02-22 08:39:57 +0000313static void ex_may_print __ARGS((exarg_T *eap));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000314static void ex_submagic __ARGS((exarg_T *eap));
315static void ex_join __ARGS((exarg_T *eap));
316static void ex_at __ARGS((exarg_T *eap));
317static void ex_bang __ARGS((exarg_T *eap));
318static void ex_undo __ARGS((exarg_T *eap));
Bram Moolenaar55debbe2010-05-23 23:34:36 +0200319#ifdef FEAT_PERSISTENT_UNDO
320static void ex_wundo __ARGS((exarg_T *eap));
321static void ex_rundo __ARGS((exarg_T *eap));
322#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000323static void ex_redo __ARGS((exarg_T *eap));
Bram Moolenaarc7d89352006-03-14 22:53:34 +0000324static void ex_later __ARGS((exarg_T *eap));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000325static void ex_redir __ARGS((exarg_T *eap));
326static void ex_redraw __ARGS((exarg_T *eap));
327static void ex_redrawstatus __ARGS((exarg_T *eap));
328static void close_redir __ARGS((void));
329static void ex_mkrc __ARGS((exarg_T *eap));
330static void ex_mark __ARGS((exarg_T *eap));
331#ifdef FEAT_USR_CMDS
332static char_u *uc_fun_cmd __ARGS((void));
Bram Moolenaar52b4b552005-03-07 23:00:57 +0000333static char_u *find_ucmd __ARGS((exarg_T *eap, char_u *p, int *full, expand_T *xp, int *compl));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000334#endif
335#ifdef FEAT_EX_EXTRA
336static void ex_normal __ARGS((exarg_T *eap));
337static void ex_startinsert __ARGS((exarg_T *eap));
338static void ex_stopinsert __ARGS((exarg_T *eap));
339#else
340# define ex_normal ex_ni
341# define ex_align ex_ni
342# define ex_retab ex_ni
343# define ex_startinsert ex_ni
344# define ex_stopinsert ex_ni
345# define ex_helptags ex_ni
Bram Moolenaarf95dc3b2005-05-22 22:02:25 +0000346# define ex_sort ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000347#endif
348#ifdef FEAT_FIND_ID
349static void ex_checkpath __ARGS((exarg_T *eap));
350static void ex_findpat __ARGS((exarg_T *eap));
351#else
352# define ex_findpat ex_ni
353# define ex_checkpath ex_ni
354#endif
355#if defined(FEAT_FIND_ID) && defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
356static void ex_psearch __ARGS((exarg_T *eap));
357#else
358# define ex_psearch ex_ni
359#endif
360static void ex_tag __ARGS((exarg_T *eap));
361static void ex_tag_cmd __ARGS((exarg_T *eap, char_u *name));
362#ifndef FEAT_EVAL
363# define ex_scriptnames ex_ni
364# define ex_finish ex_ni
365# define ex_echo ex_ni
366# define ex_echohl ex_ni
367# define ex_execute ex_ni
368# define ex_call ex_ni
369# define ex_if ex_ni
370# define ex_endif ex_ni
371# define ex_else ex_ni
372# define ex_while ex_ni
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000373# define ex_for ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000374# define ex_continue ex_ni
375# define ex_break ex_ni
376# define ex_endwhile ex_ni
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000377# define ex_endfor ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000378# define ex_throw ex_ni
379# define ex_try ex_ni
380# define ex_catch ex_ni
381# define ex_finally ex_ni
382# define ex_endtry ex_ni
383# define ex_endfunction ex_ni
384# define ex_let ex_ni
385# define ex_unlet ex_ni
Bram Moolenaar65c1b012005-01-31 19:02:28 +0000386# define ex_lockvar ex_ni
387# define ex_unlockvar ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000388# define ex_function ex_ni
389# define ex_delfunction ex_ni
390# define ex_return ex_ni
Bram Moolenaard812df62008-11-09 12:46:09 +0000391# define ex_oldfiles ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000392#endif
393static char_u *arg_all __ARGS((void));
394#ifdef FEAT_SESSION
395static int makeopens __ARGS((FILE *fd, char_u *dirnow));
Bram Moolenaarf13be0d2008-01-02 14:13:10 +0000396static int put_view __ARGS((FILE *fd, win_T *wp, int add_edit, unsigned *flagp, int current_arg_idx));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000397static void ex_loadview __ARGS((exarg_T *eap));
398static char_u *get_view_file __ARGS((int c));
Bram Moolenaareeefcc72007-05-01 21:21:21 +0000399static int did_lcd; /* whether ":lcd" was produced for a session */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000400#else
401# define ex_loadview ex_ni
402#endif
403#ifndef FEAT_EVAL
404# define ex_compiler ex_ni
405#endif
406#ifdef FEAT_VIMINFO
407static void ex_viminfo __ARGS((exarg_T *eap));
408#else
409# define ex_viminfo ex_ni
410#endif
411static void ex_behave __ARGS((exarg_T *eap));
412#ifdef FEAT_AUTOCMD
413static void ex_filetype __ARGS((exarg_T *eap));
414static void ex_setfiletype __ARGS((exarg_T *eap));
415#else
416# define ex_filetype ex_ni
417# define ex_setfiletype ex_ni
418#endif
419#ifndef FEAT_DIFF
Bram Moolenaar2df6dcc2004-07-12 15:53:54 +0000420# define ex_diffoff ex_ni
Bram Moolenaar071d4272004-06-13 20:20:40 +0000421# define ex_diffpatch ex_ni
422# define ex_diffgetput ex_ni
423# define ex_diffsplit ex_ni
424# define ex_diffthis ex_ni
425# define ex_diffupdate ex_ni
426#endif
427static void ex_digraphs __ARGS((exarg_T *eap));
428static void ex_set __ARGS((exarg_T *eap));
429#if !defined(FEAT_EVAL) || !defined(FEAT_AUTOCMD)
430# define ex_options ex_ni
431#endif
432#ifdef FEAT_SEARCH_EXTRA
433static void ex_nohlsearch __ARGS((exarg_T *eap));
434static void ex_match __ARGS((exarg_T *eap));
435#else
436# define ex_nohlsearch ex_ni
437# define ex_match ex_ni
438#endif
439#ifdef FEAT_CRYPT
440static void ex_X __ARGS((exarg_T *eap));
441#else
442# define ex_X ex_ni
443#endif
444#ifdef FEAT_FOLDING
445static void ex_fold __ARGS((exarg_T *eap));
446static void ex_foldopen __ARGS((exarg_T *eap));
447static void ex_folddo __ARGS((exarg_T *eap));
448#else
449# define ex_fold ex_ni
450# define ex_foldopen ex_ni
451# define ex_folddo ex_ni
452#endif
453#if !((defined(HAVE_LOCALE_H) || defined(X_LOCALE)) \
454 && (defined(FEAT_GETTEXT) || defined(FEAT_MBYTE)))
455# define ex_language ex_ni
456#endif
457#ifndef FEAT_SIGNS
458# define ex_sign ex_ni
459#endif
460#ifndef FEAT_SUN_WORKSHOP
461# define ex_wsverb ex_ni
462#endif
Bram Moolenaar009b2592004-10-24 19:18:58 +0000463#ifndef FEAT_NETBEANS_INTG
Bram Moolenaarb26e6322010-05-22 21:34:09 +0200464# define ex_nbclose ex_ni
Bram Moolenaar009b2592004-10-24 19:18:58 +0000465# define ex_nbkey ex_ni
Bram Moolenaarb26e6322010-05-22 21:34:09 +0200466# define ex_nbstart ex_ni
Bram Moolenaar009b2592004-10-24 19:18:58 +0000467#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000468
469#ifndef FEAT_EVAL
470# define ex_debug ex_ni
471# define ex_breakadd ex_ni
472# define ex_debuggreedy ex_ni
473# define ex_breakdel ex_ni
474# define ex_breaklist ex_ni
475#endif
476
477#ifndef FEAT_CMDHIST
478# define ex_history ex_ni
479#endif
480#ifndef FEAT_JUMPLIST
481# define ex_jumps ex_ni
482# define ex_changes ex_ni
483#endif
484
Bram Moolenaar05159a02005-02-26 23:04:13 +0000485#ifndef FEAT_PROFILE
486# define ex_profile ex_ni
487#endif
488
Bram Moolenaar071d4272004-06-13 20:20:40 +0000489/*
490 * Declare cmdnames[].
491 */
492#define DO_DECLARE_EXCMD
493#include "ex_cmds.h"
494
495/*
496 * Table used to quickly search for a command, based on its first character.
497 */
Bram Moolenaar2c29bee2005-06-01 21:46:07 +0000498static cmdidx_T cmdidxs[27] =
Bram Moolenaar071d4272004-06-13 20:20:40 +0000499{
500 CMD_append,
501 CMD_buffer,
502 CMD_change,
503 CMD_delete,
504 CMD_edit,
505 CMD_file,
506 CMD_global,
507 CMD_help,
508 CMD_insert,
509 CMD_join,
510 CMD_k,
511 CMD_list,
512 CMD_move,
513 CMD_next,
514 CMD_open,
515 CMD_print,
516 CMD_quit,
517 CMD_read,
518 CMD_substitute,
519 CMD_t,
520 CMD_undo,
521 CMD_vglobal,
522 CMD_write,
523 CMD_xit,
524 CMD_yank,
525 CMD_z,
526 CMD_bang
527};
528
529static char_u dollar_command[2] = {'$', 0};
530
531
532#ifdef FEAT_EVAL
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000533/* Struct for storing a line inside a while/for loop */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000534typedef struct
535{
536 char_u *line; /* command line */
537 linenr_T lnum; /* sourcing_lnum of the line */
538} wcmd_T;
539
540/*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000541 * Structure used to store info for line position in a while or for loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000542 * This is required, because do_one_cmd() may invoke ex_function(), which
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000543 * reads more lines that may come from the while/for loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000544 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000545struct loop_cookie
Bram Moolenaar071d4272004-06-13 20:20:40 +0000546{
547 garray_T *lines_gap; /* growarray with line info */
548 int current_line; /* last read line from growarray */
549 int repeating; /* TRUE when looping a second time */
550 /* When "repeating" is FALSE use "getline" and "cookie" to get lines */
551 char_u *(*getline) __ARGS((int, void *, int));
552 void *cookie;
553};
554
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000555static char_u *get_loop_line __ARGS((int c, void *cookie, int indent));
556static int store_loop_line __ARGS((garray_T *gap, char_u *line));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000557static void free_cmdlines __ARGS((garray_T *gap));
Bram Moolenaared203462004-06-16 11:19:22 +0000558
559/* Struct to save a few things while debugging. Used in do_cmdline() only. */
560struct dbg_stuff
561{
562 int trylevel;
563 int force_abort;
564 except_T *caught_stack;
565 char_u *vv_exception;
566 char_u *vv_throwpoint;
567 int did_emsg;
568 int got_int;
569 int did_throw;
570 int need_rethrow;
571 int check_cstack;
572 except_T *current_exception;
573};
574
575static void save_dbg_stuff __ARGS((struct dbg_stuff *dsp));
576static void restore_dbg_stuff __ARGS((struct dbg_stuff *dsp));
577
578 static void
579save_dbg_stuff(dsp)
580 struct dbg_stuff *dsp;
581{
582 dsp->trylevel = trylevel; trylevel = 0;
583 dsp->force_abort = force_abort; force_abort = FALSE;
584 dsp->caught_stack = caught_stack; caught_stack = NULL;
585 dsp->vv_exception = v_exception(NULL);
586 dsp->vv_throwpoint = v_throwpoint(NULL);
587
588 /* Necessary for debugging an inactive ":catch", ":finally", ":endtry" */
589 dsp->did_emsg = did_emsg; did_emsg = FALSE;
590 dsp->got_int = got_int; got_int = FALSE;
591 dsp->did_throw = did_throw; did_throw = FALSE;
592 dsp->need_rethrow = need_rethrow; need_rethrow = FALSE;
593 dsp->check_cstack = check_cstack; check_cstack = FALSE;
594 dsp->current_exception = current_exception; current_exception = NULL;
595}
596
597 static void
598restore_dbg_stuff(dsp)
599 struct dbg_stuff *dsp;
600{
601 suppress_errthrow = FALSE;
602 trylevel = dsp->trylevel;
603 force_abort = dsp->force_abort;
604 caught_stack = dsp->caught_stack;
605 (void)v_exception(dsp->vv_exception);
606 (void)v_throwpoint(dsp->vv_throwpoint);
607 did_emsg = dsp->did_emsg;
608 got_int = dsp->got_int;
609 did_throw = dsp->did_throw;
610 need_rethrow = dsp->need_rethrow;
611 check_cstack = dsp->check_cstack;
612 current_exception = dsp->current_exception;
613}
Bram Moolenaar071d4272004-06-13 20:20:40 +0000614#endif
615
616
617/*
618 * do_exmode(): Repeatedly get commands for the "Ex" mode, until the ":vi"
619 * command is given.
620 */
621 void
622do_exmode(improved)
623 int improved; /* TRUE for "improved Ex" mode */
624{
625 int save_msg_scroll;
626 int prev_msg_row;
627 linenr_T prev_line;
Bram Moolenaardf177f62005-02-22 08:39:57 +0000628 int changedtick;
629
630 if (improved)
631 exmode_active = EXMODE_VIM;
632 else
633 exmode_active = EXMODE_NORMAL;
634 State = NORMAL;
635
636 /* When using ":global /pat/ visual" and then "Q" we return to continue
637 * the :global command. */
638 if (global_busy)
639 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000640
641 save_msg_scroll = msg_scroll;
642 ++RedrawingDisabled; /* don't redisplay the window */
643 ++no_wait_return; /* don't wait for return */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000644#ifdef FEAT_GUI
645 /* Ignore scrollbar and mouse events in Ex mode */
646 ++hold_gui_events;
647#endif
648#ifdef FEAT_SNIFF
649 want_sniff_request = 0; /* No K_SNIFF wanted */
650#endif
651
652 MSG(_("Entering Ex mode. Type \"visual\" to go to Normal mode."));
653 while (exmode_active)
654 {
Bram Moolenaar7c626922005-02-07 22:01:03 +0000655#ifdef FEAT_EX_EXTRA
656 /* Check for a ":normal" command and no more characters left. */
657 if (ex_normal_busy > 0 && typebuf.tb_len == 0)
658 {
659 exmode_active = FALSE;
660 break;
661 }
662#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000663 msg_scroll = TRUE;
664 need_wait_return = FALSE;
665 ex_pressedreturn = FALSE;
666 ex_no_reprint = FALSE;
Bram Moolenaardf177f62005-02-22 08:39:57 +0000667 changedtick = curbuf->b_changedtick;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000668 prev_msg_row = msg_row;
669 prev_line = curwin->w_cursor.lnum;
670#ifdef FEAT_SNIFF
671 ProcessSniffRequests();
672#endif
673 if (improved)
674 {
675 cmdline_row = msg_row;
676 do_cmdline(NULL, getexline, NULL, 0);
677 }
678 else
679 do_cmdline(NULL, getexmodeline, NULL, DOCMD_NOWAIT);
680 lines_left = Rows - 1;
681
Bram Moolenaardf177f62005-02-22 08:39:57 +0000682 if ((prev_line != curwin->w_cursor.lnum
683 || changedtick != curbuf->b_changedtick) && !ex_no_reprint)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000684 {
Bram Moolenaardf177f62005-02-22 08:39:57 +0000685 if (curbuf->b_ml.ml_flags & ML_EMPTY)
686 EMSG(_(e_emptybuf));
687 else
Bram Moolenaar071d4272004-06-13 20:20:40 +0000688 {
Bram Moolenaardf177f62005-02-22 08:39:57 +0000689 if (ex_pressedreturn)
690 {
691 /* go up one line, to overwrite the ":<CR>" line, so the
Bram Moolenaar81870892007-11-11 18:17:28 +0000692 * output doesn't contain empty lines. */
Bram Moolenaardf177f62005-02-22 08:39:57 +0000693 msg_row = prev_msg_row;
694 if (prev_msg_row == Rows - 1)
695 msg_row--;
696 }
697 msg_col = 0;
698 print_line_no_prefix(curwin->w_cursor.lnum, FALSE, FALSE);
699 msg_clr_eos();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000700 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000701 }
Bram Moolenaardf177f62005-02-22 08:39:57 +0000702 else if (ex_pressedreturn && !ex_no_reprint) /* must be at EOF */
703 {
704 if (curbuf->b_ml.ml_flags & ML_EMPTY)
705 EMSG(_(e_emptybuf));
706 else
707 EMSG(_("E501: At end-of-file"));
708 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000709 }
710
711#ifdef FEAT_GUI
712 --hold_gui_events;
713#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000714 --RedrawingDisabled;
715 --no_wait_return;
716 update_screen(CLEAR);
717 need_wait_return = FALSE;
718 msg_scroll = save_msg_scroll;
719}
720
721/*
722 * Execute a simple command line. Used for translated commands like "*".
723 */
724 int
725do_cmdline_cmd(cmd)
726 char_u *cmd;
727{
728 return do_cmdline(cmd, NULL, NULL,
729 DOCMD_VERBOSE|DOCMD_NOWAIT|DOCMD_KEYTYPED);
730}
731
732/*
733 * do_cmdline(): execute one Ex command line
734 *
735 * 1. Execute "cmdline" when it is not NULL.
736 * If "cmdline" is NULL, or more lines are needed, getline() is used.
737 * 2. Split up in parts separated with '|'.
738 *
739 * This function can be called recursively!
740 *
741 * flags:
742 * DOCMD_VERBOSE - The command will be included in the error message.
743 * DOCMD_NOWAIT - Don't call wait_return() and friends.
744 * DOCMD_REPEAT - Repeat execution until getline() returns NULL.
745 * DOCMD_KEYTYPED - Don't reset KeyTyped.
746 * DOCMD_EXCRESET - Reset the exception environment (used for debugging).
747 * DOCMD_KEEPLINE - Store first typed line (for repeating with ".").
748 *
749 * return FAIL if cmdline could not be executed, OK otherwise
750 */
751 int
752do_cmdline(cmdline, getline, cookie, flags)
753 char_u *cmdline;
754 char_u *(*getline) __ARGS((int, void *, int));
755 void *cookie; /* argument for getline() */
756 int flags;
757{
758 char_u *next_cmdline; /* next cmd to execute */
759 char_u *cmdline_copy = NULL; /* copy of cmd line */
760 int used_getline = FALSE; /* used "getline" to obtain command */
761 static int recursive = 0; /* recursive depth */
762 int msg_didout_before_start = 0;
763 int count = 0; /* line number count */
764 int did_inc = FALSE; /* incremented RedrawingDisabled */
765 int retval = OK;
766#ifdef FEAT_EVAL
767 struct condstack cstack; /* conditional stack */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000768 garray_T lines_ga; /* keep lines for ":while"/":for" */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000769 int current_line = 0; /* active line in lines_ga */
770 char_u *fname = NULL; /* function or script name */
771 linenr_T *breakpoint = NULL; /* ptr to breakpoint field in cookie */
772 int *dbg_tick = NULL; /* ptr to dbg_tick field in cookie */
Bram Moolenaared203462004-06-16 11:19:22 +0000773 struct dbg_stuff debug_saved; /* saved things for debug mode */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000774 int initial_trylevel;
775 struct msglist **saved_msg_list = NULL;
776 struct msglist *private_msg_list;
777
778 /* "getline" and "cookie" passed to do_one_cmd() */
779 char_u *(*cmd_getline) __ARGS((int, void *, int));
780 void *cmd_cookie;
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000781 struct loop_cookie cmd_loop_cookie;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000782 void *real_cookie;
Bram Moolenaar05159a02005-02-26 23:04:13 +0000783 int getline_is_func;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000784#else
785# define cmd_getline getline
786# define cmd_cookie cookie
787#endif
788 static int call_depth = 0; /* recursiveness */
789
790#ifdef FEAT_EVAL
791 /* For every pair of do_cmdline()/do_one_cmd() calls, use an extra memory
792 * location for storing error messages to be converted to an exception.
Bram Moolenaarcf3630f2005-01-08 16:04:29 +0000793 * This ensures that the do_errthrow() call in do_one_cmd() does not
794 * combine the messages stored by an earlier invocation of do_one_cmd()
795 * with the command name of the later one. This would happen when
796 * BufWritePost autocommands are executed after a write error. */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000797 saved_msg_list = msg_list;
798 msg_list = &private_msg_list;
799 private_msg_list = NULL;
800#endif
801
802 /* It's possible to create an endless loop with ":execute", catch that
803 * here. The value of 200 allows nested function calls, ":source", etc. */
804 if (call_depth == 200)
805 {
806 EMSG(_("E169: Command too recursive"));
807#ifdef FEAT_EVAL
808 /* When converting to an exception, we do not include the command name
809 * since this is not an error of the specific command. */
810 do_errthrow((struct condstack *)NULL, (char_u *)NULL);
811 msg_list = saved_msg_list;
812#endif
813 return FAIL;
814 }
815 ++call_depth;
816
817#ifdef FEAT_EVAL
818 cstack.cs_idx = -1;
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000819 cstack.cs_looplevel = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000820 cstack.cs_trylevel = 0;
821 cstack.cs_emsg_silent_list = NULL;
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000822 cstack.cs_lflags = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000823 ga_init2(&lines_ga, (int)sizeof(wcmd_T), 10);
824
825 real_cookie = getline_cookie(getline, cookie);
826
827 /* Inside a function use a higher nesting level. */
Bram Moolenaar05159a02005-02-26 23:04:13 +0000828 getline_is_func = getline_equal(getline, cookie, get_func_line);
829 if (getline_is_func && ex_nesting_level == func_level(real_cookie))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000830 ++ex_nesting_level;
831
832 /* Get the function or script name and the address where the next breakpoint
833 * line and the debug tick for a function or script are stored. */
Bram Moolenaar05159a02005-02-26 23:04:13 +0000834 if (getline_is_func)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000835 {
836 fname = func_name(real_cookie);
837 breakpoint = func_breakpoint(real_cookie);
838 dbg_tick = func_dbg_tick(real_cookie);
839 }
840 else if (getline_equal(getline, cookie, getsourceline))
841 {
842 fname = sourcing_name;
843 breakpoint = source_breakpoint(real_cookie);
844 dbg_tick = source_dbg_tick(real_cookie);
845 }
846
847 /*
848 * Initialize "force_abort" and "suppress_errthrow" at the top level.
849 */
850 if (!recursive)
851 {
852 force_abort = FALSE;
853 suppress_errthrow = FALSE;
854 }
855
856 /*
857 * If requested, store and reset the global values controlling the
Bram Moolenaar89d40322006-08-29 15:30:07 +0000858 * exception handling (used when debugging). Otherwise clear it to avoid
859 * a bogus compiler warning when the optimizer uses inline functions...
Bram Moolenaar071d4272004-06-13 20:20:40 +0000860 */
Bram Moolenaarb4872942006-05-13 10:32:52 +0000861 if (flags & DOCMD_EXCRESET)
Bram Moolenaared203462004-06-16 11:19:22 +0000862 save_dbg_stuff(&debug_saved);
Bram Moolenaar89d40322006-08-29 15:30:07 +0000863 else
Bram Moolenaar7db5fc82010-05-24 11:59:29 +0200864 vim_memset(&debug_saved, 0, 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000865
866 initial_trylevel = trylevel;
867
868 /*
869 * "did_throw" will be set to TRUE when an exception is being thrown.
870 */
871 did_throw = FALSE;
872#endif
873 /*
874 * "did_emsg" will be set to TRUE when emsg() is used, in which case we
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000875 * cancel the whole command line, and any if/endif or loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000876 * If force_abort is set, we cancel everything.
877 */
878 did_emsg = FALSE;
879
880 /*
881 * KeyTyped is only set when calling vgetc(). Reset it here when not
882 * calling vgetc() (sourced command lines).
883 */
884 if (!(flags & DOCMD_KEYTYPED) && !getline_equal(getline, cookie, getexline))
885 KeyTyped = FALSE;
886
887 /*
888 * Continue executing command lines:
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000889 * - when inside an ":if", ":while" or ":for"
Bram Moolenaar071d4272004-06-13 20:20:40 +0000890 * - for multiple commands on one line, separated with '|'
891 * - when repeating until there are no more lines (for ":source")
892 */
893 next_cmdline = cmdline;
894 do
895 {
Bram Moolenaar05159a02005-02-26 23:04:13 +0000896#ifdef FEAT_EVAL
897 getline_is_func = getline_equal(getline, cookie, get_func_line);
898#endif
899
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000900 /* stop skipping cmds for an error msg after all endif/while/for */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000901 if (next_cmdline == NULL
902#ifdef FEAT_EVAL
903 && !force_abort
904 && cstack.cs_idx < 0
Bram Moolenaar05159a02005-02-26 23:04:13 +0000905 && !(getline_is_func && func_has_abort(real_cookie))
Bram Moolenaar071d4272004-06-13 20:20:40 +0000906#endif
907 )
908 did_emsg = FALSE;
909
910 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000911 * 1. If repeating a line in a loop, get a line from lines_ga.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000912 * 2. If no line given: Get an allocated line with getline().
913 * 3. If a line is given: Make a copy, so we can mess with it.
914 */
915
916#ifdef FEAT_EVAL
917 /* 1. If repeating, get a previous line from lines_ga. */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000918 if (cstack.cs_looplevel > 0 && current_line < lines_ga.ga_len)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000919 {
920 /* Each '|' separated command is stored separately in lines_ga, to
921 * be able to jump to it. Don't use next_cmdline now. */
922 vim_free(cmdline_copy);
923 cmdline_copy = NULL;
924
925 /* Check if a function has returned or, unless it has an unclosed
926 * try conditional, aborted. */
Bram Moolenaar05159a02005-02-26 23:04:13 +0000927 if (getline_is_func)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000928 {
Bram Moolenaar05159a02005-02-26 23:04:13 +0000929# ifdef FEAT_PROFILE
Bram Moolenaar371d5402006-03-20 21:47:49 +0000930 if (do_profiling == PROF_YES)
Bram Moolenaar05159a02005-02-26 23:04:13 +0000931 func_line_end(real_cookie);
932# endif
933 if (func_has_ended(real_cookie))
934 {
935 retval = FAIL;
936 break;
937 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000938 }
Bram Moolenaar05159a02005-02-26 23:04:13 +0000939#ifdef FEAT_PROFILE
Bram Moolenaar371d5402006-03-20 21:47:49 +0000940 else if (do_profiling == PROF_YES
Bram Moolenaar05159a02005-02-26 23:04:13 +0000941 && getline_equal(getline, cookie, getsourceline))
942 script_line_end();
943#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000944
945 /* Check if a sourced file hit a ":finish" command. */
946 if (source_finished(getline, cookie))
947 {
948 retval = FAIL;
949 break;
950 }
951
952 /* If breakpoints have been added/deleted need to check for it. */
953 if (breakpoint != NULL && dbg_tick != NULL
954 && *dbg_tick != debug_tick)
955 {
956 *breakpoint = dbg_find_breakpoint(
957 getline_equal(getline, cookie, getsourceline),
958 fname, sourcing_lnum);
959 *dbg_tick = debug_tick;
960 }
961
962 next_cmdline = ((wcmd_T *)(lines_ga.ga_data))[current_line].line;
963 sourcing_lnum = ((wcmd_T *)(lines_ga.ga_data))[current_line].lnum;
964
965 /* Did we encounter a breakpoint? */
966 if (breakpoint != NULL && *breakpoint != 0
967 && *breakpoint <= sourcing_lnum)
968 {
969 dbg_breakpoint(fname, sourcing_lnum);
970 /* Find next breakpoint. */
971 *breakpoint = dbg_find_breakpoint(
972 getline_equal(getline, cookie, getsourceline),
973 fname, sourcing_lnum);
974 *dbg_tick = debug_tick;
975 }
Bram Moolenaar05159a02005-02-26 23:04:13 +0000976# ifdef FEAT_PROFILE
Bram Moolenaar371d5402006-03-20 21:47:49 +0000977 if (do_profiling == PROF_YES)
Bram Moolenaar05159a02005-02-26 23:04:13 +0000978 {
979 if (getline_is_func)
980 func_line_start(real_cookie);
981 else if (getline_equal(getline, cookie, getsourceline))
982 script_line_start();
983 }
984# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000985 }
986
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000987 if (cstack.cs_looplevel > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000988 {
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000989 /* Inside a while/for loop we need to store the lines and use them
Bram Moolenaar071d4272004-06-13 20:20:40 +0000990 * again. Pass a different "getline" function to do_one_cmd()
991 * below, so that it stores lines in or reads them from
992 * "lines_ga". Makes it possible to define a function inside a
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +0000993 * while/for loop. */
994 cmd_getline = get_loop_line;
995 cmd_cookie = (void *)&cmd_loop_cookie;
996 cmd_loop_cookie.lines_gap = &lines_ga;
997 cmd_loop_cookie.current_line = current_line;
998 cmd_loop_cookie.getline = getline;
999 cmd_loop_cookie.cookie = cookie;
1000 cmd_loop_cookie.repeating = (current_line < lines_ga.ga_len);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001001 }
1002 else
1003 {
1004 cmd_getline = getline;
1005 cmd_cookie = cookie;
1006 }
1007#endif
1008
1009 /* 2. If no line given, get an allocated line with getline(). */
1010 if (next_cmdline == NULL)
1011 {
1012 /*
1013 * Need to set msg_didout for the first line after an ":if",
1014 * otherwise the ":if" will be overwritten.
1015 */
1016 if (count == 1 && getline_equal(getline, cookie, getexline))
1017 msg_didout = TRUE;
1018 if (getline == NULL || (next_cmdline = getline(':', cookie,
1019#ifdef FEAT_EVAL
1020 cstack.cs_idx < 0 ? 0 : (cstack.cs_idx + 1) * 2
1021#else
1022 0
1023#endif
1024 )) == NULL)
1025 {
1026 /* Don't call wait_return for aborted command line. The NULL
1027 * returned for the end of a sourced file or executed function
1028 * doesn't do this. */
1029 if (KeyTyped && !(flags & DOCMD_REPEAT))
1030 need_wait_return = FALSE;
1031 retval = FAIL;
1032 break;
1033 }
1034 used_getline = TRUE;
1035
1036 /*
1037 * Keep the first typed line. Clear it when more lines are typed.
1038 */
1039 if (flags & DOCMD_KEEPLINE)
1040 {
1041 vim_free(repeat_cmdline);
1042 if (count == 0)
1043 repeat_cmdline = vim_strsave(next_cmdline);
1044 else
1045 repeat_cmdline = NULL;
1046 }
1047 }
1048
1049 /* 3. Make a copy of the command so we can mess with it. */
1050 else if (cmdline_copy == NULL)
1051 {
1052 next_cmdline = vim_strsave(next_cmdline);
1053 if (next_cmdline == NULL)
1054 {
1055 EMSG(_(e_outofmem));
1056 retval = FAIL;
1057 break;
1058 }
1059 }
1060 cmdline_copy = next_cmdline;
1061
1062#ifdef FEAT_EVAL
1063 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001064 * Save the current line when inside a ":while" or ":for", and when
1065 * the command looks like a ":while" or ":for", because we may need it
1066 * later. When there is a '|' and another command, it is stored
1067 * separately, because we need to be able to jump back to it from an
1068 * :endwhile/:endfor.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001069 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001070 if (current_line == lines_ga.ga_len
1071 && (cstack.cs_looplevel || has_loop_cmd(next_cmdline)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001072 {
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001073 if (store_loop_line(&lines_ga, next_cmdline) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001074 {
1075 retval = FAIL;
1076 break;
1077 }
1078 }
1079 did_endif = FALSE;
1080#endif
1081
1082 if (count++ == 0)
1083 {
1084 /*
1085 * All output from the commands is put below each other, without
1086 * waiting for a return. Don't do this when executing commands
1087 * from a script or when being called recursive (e.g. for ":e
1088 * +command file").
1089 */
1090 if (!(flags & DOCMD_NOWAIT) && !recursive)
1091 {
1092 msg_didout_before_start = msg_didout;
1093 msg_didany = FALSE; /* no output yet */
1094 msg_start();
1095 msg_scroll = TRUE; /* put messages below each other */
1096 ++no_wait_return; /* dont wait for return until finished */
1097 ++RedrawingDisabled;
1098 did_inc = TRUE;
1099 }
1100 }
1101
1102 if (p_verbose >= 15 && sourcing_name != NULL)
1103 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00001104 ++no_wait_return;
Bram Moolenaar8b044b32005-05-31 22:05:58 +00001105 verbose_enter_scroll();
1106
Bram Moolenaar071d4272004-06-13 20:20:40 +00001107 smsg((char_u *)_("line %ld: %s"),
1108 (long)sourcing_lnum, cmdline_copy);
Bram Moolenaar8b044b32005-05-31 22:05:58 +00001109 if (msg_silent == 0)
1110 msg_puts((char_u *)"\n"); /* don't overwrite this */
1111
1112 verbose_leave_scroll();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001113 --no_wait_return;
1114 }
1115
1116 /*
1117 * 2. Execute one '|' separated command.
1118 * do_one_cmd() will return NULL if there is no trailing '|'.
1119 * "cmdline_copy" can change, e.g. for '%' and '#' expansion.
1120 */
1121 ++recursive;
1122 next_cmdline = do_one_cmd(&cmdline_copy, flags & DOCMD_VERBOSE,
1123#ifdef FEAT_EVAL
1124 &cstack,
1125#endif
1126 cmd_getline, cmd_cookie);
1127 --recursive;
1128
1129#ifdef FEAT_EVAL
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001130 if (cmd_cookie == (void *)&cmd_loop_cookie)
1131 /* Use "current_line" from "cmd_loop_cookie", it may have been
Bram Moolenaar071d4272004-06-13 20:20:40 +00001132 * incremented when defining a function. */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001133 current_line = cmd_loop_cookie.current_line;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001134#endif
1135
1136 if (next_cmdline == NULL)
1137 {
1138 vim_free(cmdline_copy);
1139 cmdline_copy = NULL;
1140#ifdef FEAT_CMDHIST
1141 /*
1142 * If the command was typed, remember it for the ':' register.
1143 * Do this AFTER executing the command to make :@: work.
1144 */
1145 if (getline_equal(getline, cookie, getexline)
1146 && new_last_cmdline != NULL)
1147 {
1148 vim_free(last_cmdline);
1149 last_cmdline = new_last_cmdline;
1150 new_last_cmdline = NULL;
1151 }
1152#endif
1153 }
1154 else
1155 {
1156 /* need to copy the command after the '|' to cmdline_copy, for the
1157 * next do_one_cmd() */
Bram Moolenaara7241f52008-06-24 20:39:31 +00001158 STRMOVE(cmdline_copy, next_cmdline);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001159 next_cmdline = cmdline_copy;
1160 }
1161
1162
1163#ifdef FEAT_EVAL
1164 /* reset did_emsg for a function that is not aborted by an error */
1165 if (did_emsg && !force_abort
1166 && getline_equal(getline, cookie, get_func_line)
1167 && !func_has_abort(real_cookie))
1168 did_emsg = FALSE;
1169
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001170 if (cstack.cs_looplevel > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001171 {
1172 ++current_line;
1173
1174 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001175 * An ":endwhile", ":endfor" and ":continue" is handled here.
1176 * If we were executing commands, jump back to the ":while" or
1177 * ":for".
1178 * If we were not executing commands, decrement cs_looplevel.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001179 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001180 if (cstack.cs_lflags & (CSL_HAD_CONT | CSL_HAD_ENDLOOP))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001181 {
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001182 cstack.cs_lflags &= ~(CSL_HAD_CONT | CSL_HAD_ENDLOOP);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001183
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001184 /* Jump back to the matching ":while" or ":for". Be careful
1185 * not to use a cs_line[] from an entry that isn't a ":while"
1186 * or ":for": It would make "current_line" invalid and can
1187 * cause a crash. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001188 if (!did_emsg && !got_int && !did_throw
1189 && cstack.cs_idx >= 0
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001190 && (cstack.cs_flags[cstack.cs_idx]
1191 & (CSF_WHILE | CSF_FOR))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001192 && cstack.cs_line[cstack.cs_idx] >= 0
1193 && (cstack.cs_flags[cstack.cs_idx] & CSF_ACTIVE))
1194 {
1195 current_line = cstack.cs_line[cstack.cs_idx];
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001196 /* remember we jumped there */
1197 cstack.cs_lflags |= CSL_HAD_LOOP;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001198 line_breakcheck(); /* check if CTRL-C typed */
1199
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001200 /* Check for the next breakpoint at or after the ":while"
1201 * or ":for". */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001202 if (breakpoint != NULL)
1203 {
1204 *breakpoint = dbg_find_breakpoint(
1205 getline_equal(getline, cookie, getsourceline),
1206 fname,
1207 ((wcmd_T *)lines_ga.ga_data)[current_line].lnum-1);
1208 *dbg_tick = debug_tick;
1209 }
1210 }
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001211 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001212 {
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001213 /* can only get here with ":endwhile" or ":endfor" */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001214 if (cstack.cs_idx >= 0)
Bram Moolenaarbb761a72005-01-06 23:19:09 +00001215 rewind_conditionals(&cstack, cstack.cs_idx - 1,
1216 CSF_WHILE | CSF_FOR, &cstack.cs_looplevel);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001217 }
1218 }
1219
1220 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001221 * For a ":while" or ":for" we need to remember the line number.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001222 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001223 else if (cstack.cs_lflags & CSL_HAD_LOOP)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001224 {
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001225 cstack.cs_lflags &= ~CSL_HAD_LOOP;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001226 cstack.cs_line[cstack.cs_idx] = current_line - 1;
1227 }
1228 }
1229
1230 /*
1231 * When not inside any ":while" loop, clear remembered lines.
1232 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001233 if (cstack.cs_looplevel == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001234 {
1235 if (lines_ga.ga_len > 0)
1236 {
1237 sourcing_lnum =
1238 ((wcmd_T *)lines_ga.ga_data)[lines_ga.ga_len - 1].lnum;
1239 free_cmdlines(&lines_ga);
1240 }
1241 current_line = 0;
1242 }
1243
1244 /*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001245 * A ":finally" makes did_emsg, got_int, and did_throw pending for
1246 * being restored at the ":endtry". Reset them here and set the
1247 * ACTIVE and FINALLY flags, so that the finally clause gets executed.
1248 * This includes the case where a missing ":endif", ":endwhile" or
1249 * ":endfor" was detected by the ":finally" itself.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001250 */
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001251 if (cstack.cs_lflags & CSL_HAD_FINA)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001252 {
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001253 cstack.cs_lflags &= ~CSL_HAD_FINA;
1254 report_make_pending(cstack.cs_pending[cstack.cs_idx]
1255 & (CSTP_ERROR | CSTP_INTERRUPT | CSTP_THROW),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001256 did_throw ? (void *)current_exception : NULL);
1257 did_emsg = got_int = did_throw = FALSE;
1258 cstack.cs_flags[cstack.cs_idx] |= CSF_ACTIVE | CSF_FINALLY;
1259 }
1260
1261 /* Update global "trylevel" for recursive calls to do_cmdline() from
1262 * within this loop. */
1263 trylevel = initial_trylevel + cstack.cs_trylevel;
1264
1265 /*
Bram Moolenaarc1762cc2007-05-10 16:56:30 +00001266 * If the outermost try conditional (across function calls and sourced
Bram Moolenaar071d4272004-06-13 20:20:40 +00001267 * files) is aborted because of an error, an interrupt, or an uncaught
1268 * exception, cancel everything. If it is left normally, reset
1269 * force_abort to get the non-EH compatible abortion behavior for
1270 * the rest of the script.
1271 */
1272 if (trylevel == 0 && !did_emsg && !got_int && !did_throw)
1273 force_abort = FALSE;
1274
1275 /* Convert an interrupt to an exception if appropriate. */
1276 (void)do_intthrow(&cstack);
1277#endif /* FEAT_EVAL */
1278
1279 }
1280 /*
1281 * Continue executing command lines when:
1282 * - no CTRL-C typed, no aborting error, no exception thrown or try
1283 * conditionals need to be checked for executing finally clauses or
1284 * catching an interrupt exception
1285 * - didn't get an error message or lines are not typed
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001286 * - there is a command after '|', inside a :if, :while, :for or :try, or
Bram Moolenaar071d4272004-06-13 20:20:40 +00001287 * looping for ":source" command or function call.
1288 */
1289 while (!((got_int
1290#ifdef FEAT_EVAL
1291 || (did_emsg && force_abort) || did_throw
1292#endif
1293 )
1294#ifdef FEAT_EVAL
1295 && cstack.cs_trylevel == 0
1296#endif
1297 )
1298 && !(did_emsg && used_getline
1299 && (getline_equal(getline, cookie, getexmodeline)
1300 || getline_equal(getline, cookie, getexline)))
1301 && (next_cmdline != NULL
1302#ifdef FEAT_EVAL
1303 || cstack.cs_idx >= 0
1304#endif
1305 || (flags & DOCMD_REPEAT)));
1306
1307 vim_free(cmdline_copy);
1308#ifdef FEAT_EVAL
1309 free_cmdlines(&lines_ga);
1310 ga_clear(&lines_ga);
1311
1312 if (cstack.cs_idx >= 0)
1313 {
1314 /*
1315 * If a sourced file or executed function ran to its end, report the
1316 * unclosed conditional.
1317 */
1318 if (!got_int && !did_throw
1319 && ((getline_equal(getline, cookie, getsourceline)
1320 && !source_finished(getline, cookie))
1321 || (getline_equal(getline, cookie, get_func_line)
1322 && !func_has_ended(real_cookie))))
1323 {
1324 if (cstack.cs_flags[cstack.cs_idx] & CSF_TRY)
1325 EMSG(_(e_endtry));
1326 else if (cstack.cs_flags[cstack.cs_idx] & CSF_WHILE)
1327 EMSG(_(e_endwhile));
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001328 else if (cstack.cs_flags[cstack.cs_idx] & CSF_FOR)
1329 EMSG(_(e_endfor));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001330 else
1331 EMSG(_(e_endif));
1332 }
1333
1334 /*
1335 * Reset "trylevel" in case of a ":finish" or ":return" or a missing
1336 * ":endtry" in a sourced file or executed function. If the try
1337 * conditional is in its finally clause, ignore anything pending.
1338 * If it is in a catch clause, finish the caught exception.
Bram Moolenaarbb761a72005-01-06 23:19:09 +00001339 * Also cleanup any "cs_forinfo" structures.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001340 */
1341 do
Bram Moolenaarbb761a72005-01-06 23:19:09 +00001342 {
1343 int idx = cleanup_conditionals(&cstack, 0, TRUE);
1344
Bram Moolenaar89e5d682005-01-17 22:06:23 +00001345 if (idx >= 0)
1346 --idx; /* remove try block not in its finally clause */
Bram Moolenaarbb761a72005-01-06 23:19:09 +00001347 rewind_conditionals(&cstack, idx, CSF_WHILE | CSF_FOR,
1348 &cstack.cs_looplevel);
1349 }
1350 while (cstack.cs_idx >= 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001351 trylevel = initial_trylevel;
1352 }
1353
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001354 /* If a missing ":endtry", ":endwhile", ":endfor", or ":endif" or a memory
1355 * lack was reported above and the error message is to be converted to an
Bram Moolenaar071d4272004-06-13 20:20:40 +00001356 * exception, do this now after rewinding the cstack. */
1357 do_errthrow(&cstack, getline_equal(getline, cookie, get_func_line)
1358 ? (char_u *)"endfunction" : (char_u *)NULL);
1359
1360 if (trylevel == 0)
1361 {
1362 /*
1363 * When an exception is being thrown out of the outermost try
1364 * conditional, discard the uncaught exception, disable the conversion
1365 * of interrupts or errors to exceptions, and ensure that no more
1366 * commands are executed.
1367 */
1368 if (did_throw)
1369 {
1370 void *p = NULL;
1371 char_u *saved_sourcing_name;
1372 int saved_sourcing_lnum;
1373 struct msglist *messages = NULL, *next;
1374
1375 /*
1376 * If the uncaught exception is a user exception, report it as an
1377 * error. If it is an error exception, display the saved error
1378 * message now. For an interrupt exception, do nothing; the
1379 * interrupt message is given elsewhere.
1380 */
1381 switch (current_exception->type)
1382 {
1383 case ET_USER:
Bram Moolenaar9c13b352005-05-19 20:53:52 +00001384 vim_snprintf((char *)IObuff, IOSIZE,
1385 _("E605: Exception not caught: %s"),
Bram Moolenaar071d4272004-06-13 20:20:40 +00001386 current_exception->value);
1387 p = vim_strsave(IObuff);
1388 break;
1389 case ET_ERROR:
1390 messages = current_exception->messages;
1391 current_exception->messages = NULL;
1392 break;
1393 case ET_INTERRUPT:
1394 break;
1395 default:
1396 p = vim_strsave((char_u *)_(e_internal));
1397 }
1398
1399 saved_sourcing_name = sourcing_name;
1400 saved_sourcing_lnum = sourcing_lnum;
1401 sourcing_name = current_exception->throw_name;
1402 sourcing_lnum = current_exception->throw_lnum;
1403 current_exception->throw_name = NULL;
1404
1405 discard_current_exception(); /* uses IObuff if 'verbose' */
1406 suppress_errthrow = TRUE;
1407 force_abort = TRUE;
1408
1409 if (messages != NULL)
1410 {
1411 do
1412 {
1413 next = messages->next;
1414 emsg(messages->msg);
1415 vim_free(messages->msg);
1416 vim_free(messages);
1417 messages = next;
1418 }
1419 while (messages != NULL);
1420 }
1421 else if (p != NULL)
1422 {
1423 emsg(p);
1424 vim_free(p);
1425 }
1426 vim_free(sourcing_name);
1427 sourcing_name = saved_sourcing_name;
1428 sourcing_lnum = saved_sourcing_lnum;
1429 }
1430
1431 /*
1432 * On an interrupt or an aborting error not converted to an exception,
1433 * disable the conversion of errors to exceptions. (Interrupts are not
1434 * converted any more, here.) This enables also the interrupt message
1435 * when force_abort is set and did_emsg unset in case of an interrupt
1436 * from a finally clause after an error.
1437 */
1438 else if (got_int || (did_emsg && force_abort))
1439 suppress_errthrow = TRUE;
1440 }
1441
1442 /*
1443 * The current cstack will be freed when do_cmdline() returns. An uncaught
1444 * exception will have to be rethrown in the previous cstack. If a function
1445 * has just returned or a script file was just finished and the previous
1446 * cstack belongs to the same function or, respectively, script file, it
1447 * will have to be checked for finally clauses to be executed due to the
1448 * ":return" or ":finish". This is done in do_one_cmd().
1449 */
1450 if (did_throw)
1451 need_rethrow = TRUE;
1452 if ((getline_equal(getline, cookie, getsourceline)
1453 && ex_nesting_level > source_level(real_cookie))
1454 || (getline_equal(getline, cookie, get_func_line)
1455 && ex_nesting_level > func_level(real_cookie) + 1))
1456 {
1457 if (!did_throw)
1458 check_cstack = TRUE;
1459 }
1460 else
1461 {
1462 /* When leaving a function, reduce nesting level. */
1463 if (getline_equal(getline, cookie, get_func_line))
1464 --ex_nesting_level;
1465 /*
1466 * Go to debug mode when returning from a function in which we are
1467 * single-stepping.
1468 */
1469 if ((getline_equal(getline, cookie, getsourceline)
1470 || getline_equal(getline, cookie, get_func_line))
1471 && ex_nesting_level + 1 <= debug_break_level)
1472 do_debug(getline_equal(getline, cookie, getsourceline)
1473 ? (char_u *)_("End of sourced file")
1474 : (char_u *)_("End of function"));
1475 }
1476
1477 /*
1478 * Restore the exception environment (done after returning from the
1479 * debugger).
1480 */
1481 if (flags & DOCMD_EXCRESET)
Bram Moolenaared203462004-06-16 11:19:22 +00001482 restore_dbg_stuff(&debug_saved);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001483
1484 msg_list = saved_msg_list;
1485#endif /* FEAT_EVAL */
1486
1487 /*
1488 * If there was too much output to fit on the command line, ask the user to
1489 * hit return before redrawing the screen. With the ":global" command we do
1490 * this only once after the command is finished.
1491 */
1492 if (did_inc)
1493 {
1494 --RedrawingDisabled;
1495 --no_wait_return;
1496 msg_scroll = FALSE;
1497
1498 /*
1499 * When just finished an ":if"-":else" which was typed, no need to
1500 * wait for hit-return. Also for an error situation.
1501 */
1502 if (retval == FAIL
1503#ifdef FEAT_EVAL
1504 || (did_endif && KeyTyped && !did_emsg)
1505#endif
1506 )
1507 {
1508 need_wait_return = FALSE;
1509 msg_didany = FALSE; /* don't wait when restarting edit */
1510 }
1511 else if (need_wait_return)
1512 {
1513 /*
1514 * The msg_start() above clears msg_didout. The wait_return we do
1515 * here should not overwrite the command that may be shown before
1516 * doing that.
1517 */
1518 msg_didout |= msg_didout_before_start;
1519 wait_return(FALSE);
1520 }
1521 }
1522
1523#ifndef FEAT_EVAL
1524 /*
1525 * Reset if_level, in case a sourced script file contains more ":if" than
1526 * ":endif" (could be ":if x | foo | endif").
1527 */
1528 if_level = 0;
1529#endif
1530
1531 --call_depth;
1532 return retval;
1533}
1534
1535#ifdef FEAT_EVAL
1536/*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001537 * Obtain a line when inside a ":while" or ":for" loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001538 */
1539 static char_u *
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001540get_loop_line(c, cookie, indent)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001541 int c;
1542 void *cookie;
1543 int indent;
1544{
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001545 struct loop_cookie *cp = (struct loop_cookie *)cookie;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001546 wcmd_T *wp;
1547 char_u *line;
1548
1549 if (cp->current_line + 1 >= cp->lines_gap->ga_len)
1550 {
1551 if (cp->repeating)
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001552 return NULL; /* trying to read past ":endwhile"/":endfor" */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001553
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001554 /* First time inside the ":while"/":for": get line normally. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001555 if (cp->getline == NULL)
1556 line = getcmdline(c, 0L, indent);
1557 else
1558 line = cp->getline(c, cp->cookie, indent);
Bram Moolenaard68071d2006-05-02 22:08:30 +00001559 if (line != NULL && store_loop_line(cp->lines_gap, line) == OK)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001560 ++cp->current_line;
1561
1562 return line;
1563 }
1564
1565 KeyTyped = FALSE;
1566 ++cp->current_line;
1567 wp = (wcmd_T *)(cp->lines_gap->ga_data) + cp->current_line;
1568 sourcing_lnum = wp->lnum;
1569 return vim_strsave(wp->line);
1570}
1571
1572/*
1573 * Store a line in "gap" so that a ":while" loop can execute it again.
1574 */
1575 static int
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001576store_loop_line(gap, line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001577 garray_T *gap;
1578 char_u *line;
1579{
1580 if (ga_grow(gap, 1) == FAIL)
1581 return FAIL;
1582 ((wcmd_T *)(gap->ga_data))[gap->ga_len].line = vim_strsave(line);
1583 ((wcmd_T *)(gap->ga_data))[gap->ga_len].lnum = sourcing_lnum;
1584 ++gap->ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001585 return OK;
1586}
1587
1588/*
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001589 * Free the lines stored for a ":while" or ":for" loop.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001590 */
1591 static void
1592free_cmdlines(gap)
1593 garray_T *gap;
1594{
1595 while (gap->ga_len > 0)
1596 {
1597 vim_free(((wcmd_T *)(gap->ga_data))[gap->ga_len - 1].line);
1598 --gap->ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001599 }
1600}
1601#endif
1602
1603/*
Bram Moolenaar89d40322006-08-29 15:30:07 +00001604 * If "fgetline" is get_loop_line(), return TRUE if the getline it uses equals
1605 * "func". * Otherwise return TRUE when "fgetline" equals "func".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001606 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001607 int
Bram Moolenaar89d40322006-08-29 15:30:07 +00001608getline_equal(fgetline, cookie, func)
1609 char_u *(*fgetline) __ARGS((int, void *, int));
Bram Moolenaar78a15312009-05-15 19:33:18 +00001610 void *cookie UNUSED; /* argument for fgetline() */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001611 char_u *(*func) __ARGS((int, void *, int));
1612{
1613#ifdef FEAT_EVAL
1614 char_u *(*gp) __ARGS((int, void *, int));
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001615 struct loop_cookie *cp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001616
Bram Moolenaar89d40322006-08-29 15:30:07 +00001617 /* When "fgetline" is "get_loop_line()" use the "cookie" to find the
Bram Moolenaarc1762cc2007-05-10 16:56:30 +00001618 * function that's originally used to obtain the lines. This may be
1619 * nested several levels. */
Bram Moolenaar89d40322006-08-29 15:30:07 +00001620 gp = fgetline;
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001621 cp = (struct loop_cookie *)cookie;
1622 while (gp == get_loop_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001623 {
1624 gp = cp->getline;
1625 cp = cp->cookie;
1626 }
1627 return gp == func;
1628#else
Bram Moolenaar89d40322006-08-29 15:30:07 +00001629 return fgetline == func;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001630#endif
1631}
1632
1633#if defined(FEAT_EVAL) || defined(FEAT_MBYTE) || defined(PROTO)
1634/*
Bram Moolenaar89d40322006-08-29 15:30:07 +00001635 * If "fgetline" is get_loop_line(), return the cookie used by the original
Bram Moolenaar071d4272004-06-13 20:20:40 +00001636 * getline function. Otherwise return "cookie".
1637 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001638 void *
Bram Moolenaar89d40322006-08-29 15:30:07 +00001639getline_cookie(fgetline, cookie)
Bram Moolenaar78a15312009-05-15 19:33:18 +00001640 char_u *(*fgetline) __ARGS((int, void *, int)) UNUSED;
Bram Moolenaar89d40322006-08-29 15:30:07 +00001641 void *cookie; /* argument for fgetline() */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001642{
1643# ifdef FEAT_EVAL
1644 char_u *(*gp) __ARGS((int, void *, int));
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001645 struct loop_cookie *cp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001646
Bram Moolenaar89d40322006-08-29 15:30:07 +00001647 /* When "fgetline" is "get_loop_line()" use the "cookie" to find the
Bram Moolenaarc1762cc2007-05-10 16:56:30 +00001648 * cookie that's originally used to obtain the lines. This may be nested
Bram Moolenaar071d4272004-06-13 20:20:40 +00001649 * several levels. */
Bram Moolenaar89d40322006-08-29 15:30:07 +00001650 gp = fgetline;
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00001651 cp = (struct loop_cookie *)cookie;
1652 while (gp == get_loop_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001653 {
1654 gp = cp->getline;
1655 cp = cp->cookie;
1656 }
1657 return cp;
1658# else
1659 return cookie;
1660# endif
1661}
1662#endif
1663
1664/*
1665 * Execute one Ex command.
1666 *
1667 * If 'sourcing' is TRUE, the command will be included in the error message.
1668 *
1669 * 1. skip comment lines and leading space
1670 * 2. handle command modifiers
1671 * 3. parse range
1672 * 4. parse command
1673 * 5. parse arguments
1674 * 6. switch on command name
1675 *
Bram Moolenaar89d40322006-08-29 15:30:07 +00001676 * Note: "fgetline" can be NULL.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001677 *
1678 * This function may be called recursively!
1679 */
1680#if (_MSC_VER == 1200)
1681/*
Bram Moolenaared203462004-06-16 11:19:22 +00001682 * Avoid optimisation bug in VC++ version 6.0
Bram Moolenaar071d4272004-06-13 20:20:40 +00001683 */
Bram Moolenaar281bdce2005-01-25 21:53:18 +00001684 #pragma optimize( "g", off )
Bram Moolenaar071d4272004-06-13 20:20:40 +00001685#endif
1686 static char_u *
1687do_one_cmd(cmdlinep, sourcing,
1688#ifdef FEAT_EVAL
1689 cstack,
1690#endif
Bram Moolenaar89d40322006-08-29 15:30:07 +00001691 fgetline, cookie)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001692 char_u **cmdlinep;
1693 int sourcing;
1694#ifdef FEAT_EVAL
1695 struct condstack *cstack;
1696#endif
Bram Moolenaar89d40322006-08-29 15:30:07 +00001697 char_u *(*fgetline) __ARGS((int, void *, int));
1698 void *cookie; /* argument for fgetline() */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001699{
1700 char_u *p;
1701 linenr_T lnum;
1702 long n;
1703 char_u *errormsg = NULL; /* error message */
1704 exarg_T ea; /* Ex command arguments */
1705 long verbose_save = -1;
Bram Moolenaar8e258a42009-07-09 13:55:43 +00001706 int save_msg_scroll = msg_scroll;
1707 int save_msg_silent = -1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001708 int did_esilent = 0;
Bram Moolenaar7171abe2004-10-11 10:06:20 +00001709#ifdef HAVE_SANDBOX
1710 int did_sandbox = FALSE;
1711#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001712 cmdmod_T save_cmdmod;
1713 int ni; /* set when Not Implemented */
1714
1715 vim_memset(&ea, 0, sizeof(ea));
1716 ea.line1 = 1;
1717 ea.line2 = 1;
1718#ifdef FEAT_EVAL
1719 ++ex_nesting_level;
1720#endif
1721
1722 /* when not editing the last file :q has to be typed twice */
1723 if (quitmore
1724#ifdef FEAT_EVAL
1725 /* avoid that a function call in 'statusline' does this */
Bram Moolenaar89d40322006-08-29 15:30:07 +00001726 && !getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001727#endif
1728 )
1729 --quitmore;
1730
1731 /*
1732 * Reset browse, confirm, etc.. They are restored when returning, for
1733 * recursive calls.
1734 */
1735 save_cmdmod = cmdmod;
1736 vim_memset(&cmdmod, 0, sizeof(cmdmod));
1737
Bram Moolenaarcbb37ad2006-08-16 15:04:21 +00001738 /* "#!anything" is handled like a comment. */
1739 if ((*cmdlinep)[0] == '#' && (*cmdlinep)[1] == '!')
1740 goto doend;
1741
Bram Moolenaar071d4272004-06-13 20:20:40 +00001742 /*
1743 * Repeat until no more command modifiers are found.
1744 */
1745 ea.cmd = *cmdlinep;
1746 for (;;)
1747 {
1748/*
1749 * 1. skip comment lines and leading white space and colons
1750 */
1751 while (*ea.cmd == ' ' || *ea.cmd == '\t' || *ea.cmd == ':')
1752 ++ea.cmd;
1753
1754 /* in ex mode, an empty line works like :+ */
1755 if (*ea.cmd == NUL && exmode_active
Bram Moolenaar89d40322006-08-29 15:30:07 +00001756 && (getline_equal(fgetline, cookie, getexmodeline)
1757 || getline_equal(fgetline, cookie, getexline))
Bram Moolenaardf177f62005-02-22 08:39:57 +00001758 && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001759 {
1760 ea.cmd = (char_u *)"+";
1761 ex_pressedreturn = TRUE;
1762 }
1763
1764 /* ignore comment and empty lines */
Bram Moolenaarf998c042007-11-20 11:31:26 +00001765 if (*ea.cmd == '"')
1766 goto doend;
1767 if (*ea.cmd == NUL)
Bram Moolenaardf177f62005-02-22 08:39:57 +00001768 {
1769 ex_pressedreturn = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001770 goto doend;
Bram Moolenaardf177f62005-02-22 08:39:57 +00001771 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001772
1773/*
1774 * 2. handle command modifiers.
1775 */
1776 p = ea.cmd;
1777 if (VIM_ISDIGIT(*ea.cmd))
1778 p = skipwhite(skipdigits(ea.cmd));
1779 switch (*p)
1780 {
1781 /* When adding an entry, also modify cmd_exists(). */
1782 case 'a': if (!checkforcmd(&ea.cmd, "aboveleft", 3))
1783 break;
1784#ifdef FEAT_WINDOWS
1785 cmdmod.split |= WSP_ABOVE;
1786#endif
1787 continue;
1788
1789 case 'b': if (checkforcmd(&ea.cmd, "belowright", 3))
1790 {
1791#ifdef FEAT_WINDOWS
1792 cmdmod.split |= WSP_BELOW;
1793#endif
1794 continue;
1795 }
1796 if (checkforcmd(&ea.cmd, "browse", 3))
1797 {
Bram Moolenaard812df62008-11-09 12:46:09 +00001798#ifdef FEAT_BROWSE_CMD
Bram Moolenaar071d4272004-06-13 20:20:40 +00001799 cmdmod.browse = TRUE;
1800#endif
1801 continue;
1802 }
1803 if (!checkforcmd(&ea.cmd, "botright", 2))
1804 break;
1805#ifdef FEAT_WINDOWS
1806 cmdmod.split |= WSP_BOT;
1807#endif
1808 continue;
1809
1810 case 'c': if (!checkforcmd(&ea.cmd, "confirm", 4))
1811 break;
1812#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
1813 cmdmod.confirm = TRUE;
1814#endif
1815 continue;
1816
1817 case 'k': if (checkforcmd(&ea.cmd, "keepmarks", 3))
1818 {
1819 cmdmod.keepmarks = TRUE;
1820 continue;
1821 }
Bram Moolenaard4755bb2004-09-02 19:12:26 +00001822 if (checkforcmd(&ea.cmd, "keepalt", 5))
1823 {
1824 cmdmod.keepalt = TRUE;
1825 continue;
1826 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001827 if (!checkforcmd(&ea.cmd, "keepjumps", 5))
1828 break;
1829 cmdmod.keepjumps = TRUE;
1830 continue;
1831
1832 /* ":hide" and ":hide | cmd" are not modifiers */
1833 case 'h': if (p != ea.cmd || !checkforcmd(&p, "hide", 3)
1834 || *p == NUL || ends_excmd(*p))
1835 break;
1836 ea.cmd = p;
1837 cmdmod.hide = TRUE;
1838 continue;
1839
1840 case 'l': if (checkforcmd(&ea.cmd, "lockmarks", 3))
1841 {
1842 cmdmod.lockmarks = TRUE;
1843 continue;
1844 }
1845
1846 if (!checkforcmd(&ea.cmd, "leftabove", 5))
1847 break;
1848#ifdef FEAT_WINDOWS
1849 cmdmod.split |= WSP_ABOVE;
1850#endif
1851 continue;
1852
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +00001853 case 'n': if (!checkforcmd(&ea.cmd, "noautocmd", 3))
1854 break;
1855#ifdef FEAT_AUTOCMD
1856 if (cmdmod.save_ei == NULL)
1857 {
Bram Moolenaarf193fff2006-04-27 00:02:13 +00001858 /* Set 'eventignore' to "all". Restore the
1859 * existing option value later. */
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +00001860 cmdmod.save_ei = vim_strsave(p_ei);
1861 set_string_option_direct((char_u *)"ei", -1,
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00001862 (char_u *)"all", OPT_FREE, SID_NONE);
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +00001863 }
1864#endif
1865 continue;
1866
Bram Moolenaar071d4272004-06-13 20:20:40 +00001867 case 'r': if (!checkforcmd(&ea.cmd, "rightbelow", 6))
1868 break;
1869#ifdef FEAT_WINDOWS
1870 cmdmod.split |= WSP_BELOW;
1871#endif
1872 continue;
1873
Bram Moolenaar7171abe2004-10-11 10:06:20 +00001874 case 's': if (checkforcmd(&ea.cmd, "sandbox", 3))
1875 {
1876#ifdef HAVE_SANDBOX
1877 if (!did_sandbox)
1878 ++sandbox;
1879 did_sandbox = TRUE;
1880#endif
1881 continue;
1882 }
1883 if (!checkforcmd(&ea.cmd, "silent", 3))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001884 break;
Bram Moolenaar8e258a42009-07-09 13:55:43 +00001885 if (save_msg_silent == -1)
1886 save_msg_silent = msg_silent;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001887 ++msg_silent;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001888 if (*ea.cmd == '!' && !vim_iswhite(ea.cmd[-1]))
1889 {
1890 /* ":silent!", but not "silent !cmd" */
1891 ea.cmd = skipwhite(ea.cmd + 1);
1892 ++emsg_silent;
1893 ++did_esilent;
1894 }
1895 continue;
1896
Bram Moolenaar80a94a52006-02-23 21:26:58 +00001897 case 't': if (checkforcmd(&p, "tab", 3))
1898 {
1899#ifdef FEAT_WINDOWS
Bram Moolenaar80a94a52006-02-23 21:26:58 +00001900 if (vim_isdigit(*ea.cmd))
1901 cmdmod.tab = atoi((char *)ea.cmd) + 1;
1902 else
Bram Moolenaar32466aa2006-02-24 23:53:04 +00001903 cmdmod.tab = tabpage_index(curtab) + 1;
Bram Moolenaar80a94a52006-02-23 21:26:58 +00001904 ea.cmd = p;
1905#endif
1906 continue;
1907 }
1908 if (!checkforcmd(&ea.cmd, "topleft", 2))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001909 break;
1910#ifdef FEAT_WINDOWS
1911 cmdmod.split |= WSP_TOP;
1912#endif
1913 continue;
1914
Bram Moolenaar8e258a42009-07-09 13:55:43 +00001915 case 'u': if (!checkforcmd(&ea.cmd, "unsilent", 3))
1916 break;
1917 if (save_msg_silent == -1)
1918 save_msg_silent = msg_silent;
1919 msg_silent = 0;
1920 continue;
1921
Bram Moolenaar071d4272004-06-13 20:20:40 +00001922 case 'v': if (checkforcmd(&ea.cmd, "vertical", 4))
1923 {
1924#ifdef FEAT_VERTSPLIT
1925 cmdmod.split |= WSP_VERT;
1926#endif
1927 continue;
1928 }
1929 if (!checkforcmd(&p, "verbose", 4))
1930 break;
1931 if (verbose_save < 0)
1932 verbose_save = p_verbose;
Bram Moolenaared203462004-06-16 11:19:22 +00001933 if (vim_isdigit(*ea.cmd))
1934 p_verbose = atoi((char *)ea.cmd);
1935 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001936 p_verbose = 1;
1937 ea.cmd = p;
1938 continue;
1939 }
1940 break;
1941 }
1942
1943#ifdef FEAT_EVAL
1944 ea.skip = did_emsg || got_int || did_throw || (cstack->cs_idx >= 0
1945 && !(cstack->cs_flags[cstack->cs_idx] & CSF_ACTIVE));
1946#else
1947 ea.skip = (if_level > 0);
1948#endif
1949
1950#ifdef FEAT_EVAL
Bram Moolenaar05159a02005-02-26 23:04:13 +00001951# ifdef FEAT_PROFILE
1952 /* Count this line for profiling if ea.skip is FALSE. */
Bram Moolenaar371d5402006-03-20 21:47:49 +00001953 if (do_profiling == PROF_YES && !ea.skip)
Bram Moolenaar05159a02005-02-26 23:04:13 +00001954 {
Bram Moolenaar89d40322006-08-29 15:30:07 +00001955 if (getline_equal(fgetline, cookie, get_func_line))
1956 func_line_exec(getline_cookie(fgetline, cookie));
1957 else if (getline_equal(fgetline, cookie, getsourceline))
Bram Moolenaar05159a02005-02-26 23:04:13 +00001958 script_line_exec();
1959 }
1960#endif
1961
Bram Moolenaar071d4272004-06-13 20:20:40 +00001962 /* May go to debug mode. If this happens and the ">quit" debug command is
1963 * used, throw an interrupt exception and skip the next command. */
1964 dbg_check_breakpoint(&ea);
1965 if (!ea.skip && got_int)
1966 {
1967 ea.skip = TRUE;
1968 (void)do_intthrow(cstack);
1969 }
1970#endif
1971
1972/*
1973 * 3. parse a range specifier of the form: addr [,addr] [;addr] ..
1974 *
1975 * where 'addr' is:
1976 *
1977 * % (entire file)
1978 * $ [+-NUM]
1979 * 'x [+-NUM] (where x denotes a currently defined mark)
1980 * . [+-NUM]
1981 * [+-NUM]..
1982 * NUM
1983 *
1984 * The ea.cmd pointer is updated to point to the first character following the
1985 * range spec. If an initial address is found, but no second, the upper bound
1986 * is equal to the lower.
1987 */
1988
1989 /* repeat for all ',' or ';' separated addresses */
1990 for (;;)
1991 {
1992 ea.line1 = ea.line2;
1993 ea.line2 = curwin->w_cursor.lnum; /* default is current line number */
1994 ea.cmd = skipwhite(ea.cmd);
1995 lnum = get_address(&ea.cmd, ea.skip, ea.addr_count == 0);
1996 if (ea.cmd == NULL) /* error detected */
1997 goto doend;
1998 if (lnum == MAXLNUM)
1999 {
2000 if (*ea.cmd == '%') /* '%' - all lines */
2001 {
2002 ++ea.cmd;
2003 ea.line1 = 1;
2004 ea.line2 = curbuf->b_ml.ml_line_count;
2005 ++ea.addr_count;
2006 }
2007 /* '*' - visual area */
2008 else if (*ea.cmd == '*' && vim_strchr(p_cpo, CPO_STAR) == NULL)
2009 {
2010 pos_T *fp;
2011
2012 ++ea.cmd;
2013 if (!ea.skip)
2014 {
2015 fp = getmark('<', FALSE);
2016 if (check_mark(fp) == FAIL)
2017 goto doend;
2018 ea.line1 = fp->lnum;
2019 fp = getmark('>', FALSE);
2020 if (check_mark(fp) == FAIL)
2021 goto doend;
2022 ea.line2 = fp->lnum;
2023 ++ea.addr_count;
2024 }
2025 }
2026 }
2027 else
2028 ea.line2 = lnum;
2029 ea.addr_count++;
2030
2031 if (*ea.cmd == ';')
2032 {
2033 if (!ea.skip)
2034 curwin->w_cursor.lnum = ea.line2;
2035 }
2036 else if (*ea.cmd != ',')
2037 break;
2038 ++ea.cmd;
2039 }
2040
2041 /* One address given: set start and end lines */
2042 if (ea.addr_count == 1)
2043 {
2044 ea.line1 = ea.line2;
2045 /* ... but only implicit: really no address given */
2046 if (lnum == MAXLNUM)
2047 ea.addr_count = 0;
2048 }
2049
2050 /* Don't leave the cursor on an illegal line (caused by ';') */
2051 check_cursor_lnum();
2052
2053/*
2054 * 4. parse command
2055 */
2056
2057 /*
2058 * Skip ':' and any white space
2059 */
2060 ea.cmd = skipwhite(ea.cmd);
2061 while (*ea.cmd == ':')
2062 ea.cmd = skipwhite(ea.cmd + 1);
2063
2064 /*
2065 * If we got a line, but no command, then go to the line.
2066 * If we find a '|' or '\n' we set ea.nextcmd.
2067 */
2068 if (*ea.cmd == NUL || *ea.cmd == '"' ||
2069 (ea.nextcmd = check_nextcmd(ea.cmd)) != NULL)
2070 {
2071 /*
2072 * strange vi behaviour:
2073 * ":3" jumps to line 3
2074 * ":3|..." prints line 3
2075 * ":|" prints current line
2076 */
2077 if (ea.skip) /* skip this if inside :if */
2078 goto doend;
Bram Moolenaardf177f62005-02-22 08:39:57 +00002079 if (*ea.cmd == '|' || (exmode_active && ea.line1 != ea.line2))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002080 {
2081 ea.cmdidx = CMD_print;
2082 ea.argt = RANGE+COUNT+TRLBAR;
2083 if ((errormsg = invalid_range(&ea)) == NULL)
2084 {
2085 correct_range(&ea);
2086 ex_print(&ea);
2087 }
2088 }
2089 else if (ea.addr_count != 0)
2090 {
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00002091 if (ea.line2 > curbuf->b_ml.ml_line_count)
2092 {
2093 /* With '-' in 'cpoptions' a line number past the file is an
2094 * error, otherwise put it at the end of the file. */
2095 if (vim_strchr(p_cpo, CPO_MINUS) != NULL)
2096 ea.line2 = -1;
2097 else
2098 ea.line2 = curbuf->b_ml.ml_line_count;
2099 }
2100
2101 if (ea.line2 < 0)
Bram Moolenaardf177f62005-02-22 08:39:57 +00002102 errormsg = (char_u *)_(e_invrange);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002103 else
2104 {
2105 if (ea.line2 == 0)
2106 curwin->w_cursor.lnum = 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002107 else
2108 curwin->w_cursor.lnum = ea.line2;
2109 beginline(BL_SOL | BL_FIX);
2110 }
2111 }
2112 goto doend;
2113 }
2114
2115 /* Find the command and let "p" point to after it. */
2116 p = find_command(&ea, NULL);
2117
2118#ifdef FEAT_USR_CMDS
2119 if (p == NULL)
2120 {
2121 if (!ea.skip)
2122 errormsg = (char_u *)_("E464: Ambiguous use of user-defined command");
2123 goto doend;
2124 }
2125 /* Check for wrong commands. */
2126 if (*p == '!' && ea.cmd[1] == 0151 && ea.cmd[0] == 78)
2127 {
2128 errormsg = uc_fun_cmd();
2129 goto doend;
2130 }
2131#endif
2132 if (ea.cmdidx == CMD_SIZE)
2133 {
2134 if (!ea.skip)
2135 {
2136 STRCPY(IObuff, _("E492: Not an editor command"));
2137 if (!sourcing)
2138 {
2139 STRCAT(IObuff, ": ");
2140 STRNCAT(IObuff, *cmdlinep, 40);
2141 }
2142 errormsg = IObuff;
2143 }
2144 goto doend;
2145 }
2146
2147 ni = (
2148#ifdef FEAT_USR_CMDS
2149 !USER_CMDIDX(ea.cmdidx) &&
2150#endif
Bram Moolenaar3ebc1e52007-07-05 07:54:17 +00002151 (cmdnames[ea.cmdidx].cmd_func == ex_ni
Bram Moolenaar7bb75552007-07-16 18:39:49 +00002152#ifdef HAVE_EX_SCRIPT_NI
2153 || cmdnames[ea.cmdidx].cmd_func == ex_script_ni
2154#endif
2155 ));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002156
2157#ifndef FEAT_EVAL
2158 /*
2159 * When the expression evaluation is disabled, recognize the ":if" and
2160 * ":endif" commands and ignore everything in between it.
2161 */
2162 if (ea.cmdidx == CMD_if)
2163 ++if_level;
2164 if (if_level)
2165 {
2166 if (ea.cmdidx == CMD_endif)
2167 --if_level;
2168 goto doend;
2169 }
2170
2171#endif
2172
Bram Moolenaar196b3b02008-06-20 16:51:41 +00002173 /* forced commands */
2174 if (*p == '!' && ea.cmdidx != CMD_substitute
2175 && ea.cmdidx != CMD_smagic && ea.cmdidx != CMD_snomagic)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002176 {
2177 ++p;
2178 ea.forceit = TRUE;
2179 }
2180 else
2181 ea.forceit = FALSE;
2182
2183/*
2184 * 5. parse arguments
2185 */
2186#ifdef FEAT_USR_CMDS
2187 if (!USER_CMDIDX(ea.cmdidx))
2188#endif
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00002189 ea.argt = (long)cmdnames[(int)ea.cmdidx].cmd_argt;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002190
2191 if (!ea.skip)
2192 {
2193#ifdef HAVE_SANDBOX
2194 if (sandbox != 0 && !(ea.argt & SBOXOK))
2195 {
2196 /* Command not allowed in sandbox. */
2197 errormsg = (char_u *)_(e_sandbox);
2198 goto doend;
2199 }
2200#endif
2201 if (!curbuf->b_p_ma && (ea.argt & MODIFY))
2202 {
2203 /* Command not allowed in non-'modifiable' buffer */
2204 errormsg = (char_u *)_(e_modifiable);
2205 goto doend;
2206 }
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00002207
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00002208 if (text_locked() && !(ea.argt & CMDWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002209# ifdef FEAT_USR_CMDS
2210 && !USER_CMDIDX(ea.cmdidx)
2211# endif
2212 )
2213 {
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00002214 /* Command not allowed when editing the command line. */
2215#ifdef FEAT_CMDWIN
2216 if (cmdwin_type != 0)
2217 errormsg = (char_u *)_(e_cmdwin);
2218 else
2219#endif
2220 errormsg = (char_u *)_(e_secure);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002221 goto doend;
2222 }
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002223#ifdef FEAT_AUTOCMD
Bram Moolenaar5555acc2006-04-07 21:33:12 +00002224 /* Disallow editing another buffer when "curbuf_lock" is set.
2225 * Do allow ":edit" (check for argument later).
2226 * Do allow ":checktime" (it's postponed). */
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002227 if (!(ea.argt & CMDWIN)
Bram Moolenaar5555acc2006-04-07 21:33:12 +00002228 && ea.cmdidx != CMD_edit
2229 && ea.cmdidx != CMD_checktime
Bram Moolenaar910f66f2006-04-05 20:41:53 +00002230# ifdef FEAT_USR_CMDS
2231 && !USER_CMDIDX(ea.cmdidx)
2232# endif
2233 && curbuf_locked())
2234 goto doend;
2235#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002236
2237 if (!ni && !(ea.argt & RANGE) && ea.addr_count > 0)
2238 {
2239 /* no range allowed */
2240 errormsg = (char_u *)_(e_norange);
2241 goto doend;
2242 }
2243 }
2244
2245 if (!ni && !(ea.argt & BANG) && ea.forceit) /* no <!> allowed */
2246 {
2247 errormsg = (char_u *)_(e_nobang);
2248 goto doend;
2249 }
2250
2251 /*
2252 * Don't complain about the range if it is not used
2253 * (could happen if line_count is accidentally set to 0).
2254 */
2255 if (!ea.skip && !ni)
2256 {
2257 /*
2258 * If the range is backwards, ask for confirmation and, if given, swap
2259 * ea.line1 & ea.line2 so it's forwards again.
2260 * When global command is busy, don't ask, will fail below.
2261 */
2262 if (!global_busy && ea.line1 > ea.line2)
2263 {
Bram Moolenaara5792f52005-11-23 21:25:05 +00002264 if (msg_silent == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002265 {
Bram Moolenaara5792f52005-11-23 21:25:05 +00002266 if (sourcing || exmode_active)
2267 {
2268 errormsg = (char_u *)_("E493: Backwards range given");
2269 goto doend;
2270 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002271 if (ask_yesno((char_u *)
2272 _("Backwards range given, OK to swap"), FALSE) != 'y')
Bram Moolenaara5792f52005-11-23 21:25:05 +00002273 goto doend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002274 }
2275 lnum = ea.line1;
2276 ea.line1 = ea.line2;
2277 ea.line2 = lnum;
2278 }
2279 if ((errormsg = invalid_range(&ea)) != NULL)
2280 goto doend;
2281 }
2282
2283 if ((ea.argt & NOTADR) && ea.addr_count == 0) /* default is 1, not cursor */
2284 ea.line2 = 1;
2285
2286 correct_range(&ea);
2287
2288#ifdef FEAT_FOLDING
2289 if (((ea.argt & WHOLEFOLD) || ea.addr_count >= 2) && !global_busy)
2290 {
2291 /* Put the first line at the start of a closed fold, put the last line
2292 * at the end of a closed fold. */
2293 (void)hasFolding(ea.line1, &ea.line1, NULL);
2294 (void)hasFolding(ea.line2, NULL, &ea.line2);
2295 }
2296#endif
2297
2298#ifdef FEAT_QUICKFIX
2299 /*
Bram Moolenaar86b68352004-12-27 21:59:20 +00002300 * For the ":make" and ":grep" commands we insert the 'makeprg'/'grepprg'
Bram Moolenaar071d4272004-06-13 20:20:40 +00002301 * option here, so things like % get expanded.
2302 */
Bram Moolenaard857f0e2005-06-21 22:37:39 +00002303 p = replace_makeprg(&ea, p, cmdlinep);
2304 if (p == NULL)
2305 goto doend;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002306#endif
2307
2308 /*
2309 * Skip to start of argument.
2310 * Don't do this for the ":!" command, because ":!! -l" needs the space.
2311 */
2312 if (ea.cmdidx == CMD_bang)
2313 ea.arg = p;
2314 else
2315 ea.arg = skipwhite(p);
2316
2317 /*
2318 * Check for "++opt=val" argument.
2319 * Must be first, allow ":w ++enc=utf8 !cmd"
2320 */
2321 if (ea.argt & ARGOPT)
2322 while (ea.arg[0] == '+' && ea.arg[1] == '+')
2323 if (getargopt(&ea) == FAIL && !ni)
2324 {
2325 errormsg = (char_u *)_(e_invarg);
2326 goto doend;
2327 }
2328
2329 if (ea.cmdidx == CMD_write || ea.cmdidx == CMD_update)
2330 {
2331 if (*ea.arg == '>') /* append */
2332 {
2333 if (*++ea.arg != '>') /* typed wrong */
2334 {
2335 errormsg = (char_u *)_("E494: Use w or w>>");
2336 goto doend;
2337 }
2338 ea.arg = skipwhite(ea.arg + 1);
2339 ea.append = TRUE;
2340 }
2341 else if (*ea.arg == '!' && ea.cmdidx == CMD_write) /* :w !filter */
2342 {
2343 ++ea.arg;
2344 ea.usefilter = TRUE;
2345 }
2346 }
2347
2348 if (ea.cmdidx == CMD_read)
2349 {
2350 if (ea.forceit)
2351 {
2352 ea.usefilter = TRUE; /* :r! filter if ea.forceit */
2353 ea.forceit = FALSE;
2354 }
2355 else if (*ea.arg == '!') /* :r !filter */
2356 {
2357 ++ea.arg;
2358 ea.usefilter = TRUE;
2359 }
2360 }
2361
2362 if (ea.cmdidx == CMD_lshift || ea.cmdidx == CMD_rshift)
2363 {
2364 ea.amount = 1;
2365 while (*ea.arg == *ea.cmd) /* count number of '>' or '<' */
2366 {
2367 ++ea.arg;
2368 ++ea.amount;
2369 }
2370 ea.arg = skipwhite(ea.arg);
2371 }
2372
2373 /*
2374 * Check for "+command" argument, before checking for next command.
2375 * Don't do this for ":read !cmd" and ":write !cmd".
2376 */
2377 if ((ea.argt & EDITCMD) && !ea.usefilter)
2378 ea.do_ecmd_cmd = getargcmd(&ea.arg);
2379
2380 /*
2381 * Check for '|' to separate commands and '"' to start comments.
2382 * Don't do this for ":read !cmd" and ":write !cmd".
2383 */
2384 if ((ea.argt & TRLBAR) && !ea.usefilter)
2385 separate_nextcmd(&ea);
2386
2387 /*
2388 * Check for <newline> to end a shell command.
Bram Moolenaardf177f62005-02-22 08:39:57 +00002389 * Also do this for ":read !cmd", ":write !cmd" and ":global".
2390 * Any others?
Bram Moolenaar071d4272004-06-13 20:20:40 +00002391 */
Bram Moolenaardf177f62005-02-22 08:39:57 +00002392 else if (ea.cmdidx == CMD_bang
2393 || ea.cmdidx == CMD_global
2394 || ea.cmdidx == CMD_vglobal
2395 || ea.usefilter)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002396 {
2397 for (p = ea.arg; *p; ++p)
2398 {
2399 /* Remove one backslash before a newline, so that it's possible to
2400 * pass a newline to the shell and also a newline that is preceded
2401 * with a backslash. This makes it impossible to end a shell
2402 * command in a backslash, but that doesn't appear useful.
2403 * Halving the number of backslashes is incompatible with previous
2404 * versions. */
2405 if (*p == '\\' && p[1] == '\n')
Bram Moolenaara7241f52008-06-24 20:39:31 +00002406 STRMOVE(p, p + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002407 else if (*p == '\n')
2408 {
2409 ea.nextcmd = p + 1;
2410 *p = NUL;
2411 break;
2412 }
2413 }
2414 }
2415
2416 if ((ea.argt & DFLALL) && ea.addr_count == 0)
2417 {
2418 ea.line1 = 1;
2419 ea.line2 = curbuf->b_ml.ml_line_count;
2420 }
2421
2422 /* accept numbered register only when no count allowed (:put) */
2423 if ( (ea.argt & REGSTR)
2424 && *ea.arg != NUL
2425#ifdef FEAT_USR_CMDS
2426 && valid_yank_reg(*ea.arg, (ea.cmdidx != CMD_put
2427 && USER_CMDIDX(ea.cmdidx)))
2428 /* Do not allow register = for user commands */
2429 && (!USER_CMDIDX(ea.cmdidx) || *ea.arg != '=')
2430#else
2431 && valid_yank_reg(*ea.arg, ea.cmdidx != CMD_put)
2432#endif
2433 && !((ea.argt & COUNT) && VIM_ISDIGIT(*ea.arg)))
2434 {
2435 ea.regname = *ea.arg++;
2436#ifdef FEAT_EVAL
2437 /* for '=' register: accept the rest of the line as an expression */
2438 if (ea.arg[-1] == '=' && ea.arg[0] != NUL)
2439 {
2440 set_expr_line(vim_strsave(ea.arg));
2441 ea.arg += STRLEN(ea.arg);
2442 }
2443#endif
2444 ea.arg = skipwhite(ea.arg);
2445 }
2446
2447 /*
2448 * Check for a count. When accepting a BUFNAME, don't use "123foo" as a
2449 * count, it's a buffer name.
2450 */
2451 if ((ea.argt & COUNT) && VIM_ISDIGIT(*ea.arg)
2452 && (!(ea.argt & BUFNAME) || *(p = skipdigits(ea.arg)) == NUL
2453 || vim_iswhite(*p)))
2454 {
2455 n = getdigits(&ea.arg);
2456 ea.arg = skipwhite(ea.arg);
Bram Moolenaar80a94a52006-02-23 21:26:58 +00002457 if (n <= 0 && !ni && (ea.argt & ZEROR) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002458 {
2459 errormsg = (char_u *)_(e_zerocount);
2460 goto doend;
2461 }
2462 if (ea.argt & NOTADR) /* e.g. :buffer 2, :sleep 3 */
2463 {
2464 ea.line2 = n;
2465 if (ea.addr_count == 0)
2466 ea.addr_count = 1;
2467 }
2468 else
2469 {
2470 ea.line1 = ea.line2;
2471 ea.line2 += n - 1;
2472 ++ea.addr_count;
2473 /*
2474 * Be vi compatible: no error message for out of range.
2475 */
2476 if (ea.line2 > curbuf->b_ml.ml_line_count)
2477 ea.line2 = curbuf->b_ml.ml_line_count;
2478 }
2479 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00002480
2481 /*
2482 * Check for flags: 'l', 'p' and '#'.
2483 */
2484 if (ea.argt & EXFLAGS)
2485 get_flags(&ea);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002486 /* no arguments allowed */
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00002487 if (!ni && !(ea.argt & EXTRA) && *ea.arg != NUL
Bram Moolenaara2031822006-03-07 22:29:51 +00002488 && *ea.arg != '"' && (*ea.arg != '|' || (ea.argt & TRLBAR) == 0))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002489 {
2490 errormsg = (char_u *)_(e_trailing);
2491 goto doend;
2492 }
2493
2494 if (!ni && (ea.argt & NEEDARG) && *ea.arg == NUL)
2495 {
2496 errormsg = (char_u *)_(e_argreq);
2497 goto doend;
2498 }
2499
2500#ifdef FEAT_EVAL
2501 /*
2502 * Skip the command when it's not going to be executed.
2503 * The commands like :if, :endif, etc. always need to be executed.
2504 * Also make an exception for commands that handle a trailing command
2505 * themselves.
2506 */
2507 if (ea.skip)
2508 {
2509 switch (ea.cmdidx)
2510 {
2511 /* commands that need evaluation */
2512 case CMD_while:
2513 case CMD_endwhile:
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00002514 case CMD_for:
2515 case CMD_endfor:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002516 case CMD_if:
2517 case CMD_elseif:
2518 case CMD_else:
2519 case CMD_endif:
2520 case CMD_try:
2521 case CMD_catch:
2522 case CMD_finally:
2523 case CMD_endtry:
2524 case CMD_function:
2525 break;
2526
2527 /* Commands that handle '|' themselves. Check: A command should
2528 * either have the TRLBAR flag, appear in this list or appear in
2529 * the list at ":help :bar". */
2530 case CMD_aboveleft:
2531 case CMD_and:
2532 case CMD_belowright:
2533 case CMD_botright:
2534 case CMD_browse:
2535 case CMD_call:
2536 case CMD_confirm:
2537 case CMD_delfunction:
2538 case CMD_djump:
2539 case CMD_dlist:
2540 case CMD_dsearch:
2541 case CMD_dsplit:
2542 case CMD_echo:
2543 case CMD_echoerr:
2544 case CMD_echomsg:
2545 case CMD_echon:
2546 case CMD_execute:
2547 case CMD_help:
2548 case CMD_hide:
2549 case CMD_ijump:
2550 case CMD_ilist:
2551 case CMD_isearch:
2552 case CMD_isplit:
Bram Moolenaard4755bb2004-09-02 19:12:26 +00002553 case CMD_keepalt:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002554 case CMD_keepjumps:
2555 case CMD_keepmarks:
2556 case CMD_leftabove:
2557 case CMD_let:
2558 case CMD_lockmarks:
Bram Moolenaar0ba04292010-07-14 23:23:17 +02002559 case CMD_lua:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002560 case CMD_match:
Bram Moolenaar325b7a22004-07-05 15:58:32 +00002561 case CMD_mzscheme:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002562 case CMD_perl:
2563 case CMD_psearch:
2564 case CMD_python:
Bram Moolenaar368373e2010-07-19 20:46:22 +02002565 case CMD_py3:
Bram Moolenaarb6590522010-07-21 16:00:43 +02002566 case CMD_python3:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002567 case CMD_return:
2568 case CMD_rightbelow:
2569 case CMD_ruby:
2570 case CMD_silent:
2571 case CMD_smagic:
2572 case CMD_snomagic:
2573 case CMD_substitute:
2574 case CMD_syntax:
Bram Moolenaara226a6d2006-02-26 23:59:20 +00002575 case CMD_tab:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002576 case CMD_tcl:
2577 case CMD_throw:
2578 case CMD_tilde:
2579 case CMD_topleft:
2580 case CMD_unlet:
2581 case CMD_verbose:
2582 case CMD_vertical:
2583 break;
2584
2585 default: goto doend;
2586 }
2587 }
2588#endif
2589
2590 if (ea.argt & XFILE)
2591 {
2592 if (expand_filename(&ea, cmdlinep, &errormsg) == FAIL)
2593 goto doend;
2594 }
2595
2596#ifdef FEAT_LISTCMDS
2597 /*
2598 * Accept buffer name. Cannot be used at the same time with a buffer
2599 * number. Don't do this for a user command.
2600 */
2601 if ((ea.argt & BUFNAME) && *ea.arg != NUL && ea.addr_count == 0
2602# ifdef FEAT_USR_CMDS
2603 && !USER_CMDIDX(ea.cmdidx)
2604# endif
2605 )
2606 {
2607 /*
2608 * :bdelete, :bwipeout and :bunload take several arguments, separated
2609 * by spaces: find next space (skipping over escaped characters).
2610 * The others take one argument: ignore trailing spaces.
2611 */
2612 if (ea.cmdidx == CMD_bdelete || ea.cmdidx == CMD_bwipeout
2613 || ea.cmdidx == CMD_bunload)
2614 p = skiptowhite_esc(ea.arg);
2615 else
2616 {
2617 p = ea.arg + STRLEN(ea.arg);
2618 while (p > ea.arg && vim_iswhite(p[-1]))
2619 --p;
2620 }
2621 ea.line2 = buflist_findpat(ea.arg, p, (ea.argt & BUFUNL) != 0, FALSE);
2622 if (ea.line2 < 0) /* failed */
2623 goto doend;
2624 ea.addr_count = 1;
2625 ea.arg = skipwhite(p);
2626 }
2627#endif
2628
2629/*
2630 * 6. switch on command name
2631 *
2632 * The "ea" structure holds the arguments that can be used.
2633 */
2634 ea.cmdlinep = cmdlinep;
Bram Moolenaar89d40322006-08-29 15:30:07 +00002635 ea.getline = fgetline;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002636 ea.cookie = cookie;
2637#ifdef FEAT_EVAL
2638 ea.cstack = cstack;
2639#endif
2640
2641#ifdef FEAT_USR_CMDS
2642 if (USER_CMDIDX(ea.cmdidx))
2643 {
2644 /*
2645 * Execute a user-defined command.
2646 */
2647 do_ucmd(&ea);
2648 }
2649 else
2650#endif
2651 {
2652 /*
2653 * Call the function to execute the command.
2654 */
2655 ea.errmsg = NULL;
2656 (cmdnames[ea.cmdidx].cmd_func)(&ea);
2657 if (ea.errmsg != NULL)
2658 errormsg = (char_u *)_(ea.errmsg);
2659 }
2660
2661#ifdef FEAT_EVAL
2662 /*
2663 * If the command just executed called do_cmdline(), any throw or ":return"
2664 * or ":finish" encountered there must also check the cstack of the still
2665 * active do_cmdline() that called this do_one_cmd(). Rethrow an uncaught
2666 * exception, or reanimate a returned function or finished script file and
2667 * return or finish it again.
2668 */
2669 if (need_rethrow)
2670 do_throw(cstack);
2671 else if (check_cstack)
2672 {
Bram Moolenaar89d40322006-08-29 15:30:07 +00002673 if (source_finished(fgetline, cookie))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002674 do_finish(&ea, TRUE);
Bram Moolenaar89d40322006-08-29 15:30:07 +00002675 else if (getline_equal(fgetline, cookie, get_func_line)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002676 && current_func_returned())
2677 do_return(&ea, TRUE, FALSE, NULL);
2678 }
2679 need_rethrow = check_cstack = FALSE;
2680#endif
2681
2682doend:
2683 if (curwin->w_cursor.lnum == 0) /* can happen with zero line number */
2684 curwin->w_cursor.lnum = 1;
2685
2686 if (errormsg != NULL && *errormsg != NUL && !did_emsg)
2687 {
2688 if (sourcing)
2689 {
2690 if (errormsg != IObuff)
2691 {
2692 STRCPY(IObuff, errormsg);
2693 errormsg = IObuff;
2694 }
2695 STRCAT(errormsg, ": ");
Bram Moolenaar6c964832007-12-09 18:38:35 +00002696 STRNCAT(errormsg, *cmdlinep, IOSIZE - STRLEN(IObuff) - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002697 }
2698 emsg(errormsg);
2699 }
2700#ifdef FEAT_EVAL
2701 do_errthrow(cstack,
2702 (ea.cmdidx != CMD_SIZE
2703# ifdef FEAT_USR_CMDS
2704 && !USER_CMDIDX(ea.cmdidx)
2705# endif
2706 ) ? cmdnames[(int)ea.cmdidx].cmd_name : (char_u *)NULL);
2707#endif
2708
2709 if (verbose_save >= 0)
2710 p_verbose = verbose_save;
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +00002711#ifdef FEAT_AUTOCMD
2712 if (cmdmod.save_ei != NULL)
2713 {
2714 /* Restore 'eventignore' to the value before ":noautocmd". */
Bram Moolenaar5e3cb7e2006-02-27 23:58:35 +00002715 set_string_option_direct((char_u *)"ei", -1, cmdmod.save_ei,
2716 OPT_FREE, SID_NONE);
Bram Moolenaarcdbac1e2005-12-11 21:27:22 +00002717 free_string_option(cmdmod.save_ei);
2718 }
2719#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002720
2721 cmdmod = save_cmdmod;
2722
Bram Moolenaar8e258a42009-07-09 13:55:43 +00002723 if (save_msg_silent != -1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002724 {
2725 /* messages could be enabled for a serious error, need to check if the
2726 * counters don't become negative */
Bram Moolenaarbecf4282009-09-30 11:24:36 +00002727 if (!did_emsg || msg_silent > save_msg_silent)
Bram Moolenaar8e258a42009-07-09 13:55:43 +00002728 msg_silent = save_msg_silent;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002729 emsg_silent -= did_esilent;
2730 if (emsg_silent < 0)
2731 emsg_silent = 0;
2732 /* Restore msg_scroll, it's set by file I/O commands, even when no
2733 * message is actually displayed. */
2734 msg_scroll = save_msg_scroll;
Bram Moolenaar77ab2802009-04-22 12:44:48 +00002735
2736 /* "silent reg" or "silent echo x" inside "redir" leaves msg_col
2737 * somewhere in the line. Put it back in the first column. */
2738 if (redirecting())
2739 msg_col = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002740 }
2741
Bram Moolenaar7171abe2004-10-11 10:06:20 +00002742#ifdef HAVE_SANDBOX
2743 if (did_sandbox)
2744 --sandbox;
2745#endif
2746
Bram Moolenaar071d4272004-06-13 20:20:40 +00002747 if (ea.nextcmd && *ea.nextcmd == NUL) /* not really a next command */
2748 ea.nextcmd = NULL;
2749
2750#ifdef FEAT_EVAL
2751 --ex_nesting_level;
2752#endif
2753
2754 return ea.nextcmd;
2755}
2756#if (_MSC_VER == 1200)
Bram Moolenaar281bdce2005-01-25 21:53:18 +00002757 #pragma optimize( "", on )
Bram Moolenaar071d4272004-06-13 20:20:40 +00002758#endif
2759
2760/*
Bram Moolenaarc5a1e802005-01-11 21:21:40 +00002761 * Check for an Ex command with optional tail.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002762 * If there is a match advance "pp" to the argument and return TRUE.
2763 */
Bram Moolenaarc5a1e802005-01-11 21:21:40 +00002764 int
Bram Moolenaar071d4272004-06-13 20:20:40 +00002765checkforcmd(pp, cmd, len)
Bram Moolenaarc5a1e802005-01-11 21:21:40 +00002766 char_u **pp; /* start of command */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002767 char *cmd; /* name of command */
2768 int len; /* required length */
2769{
2770 int i;
2771
2772 for (i = 0; cmd[i] != NUL; ++i)
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00002773 if (((char_u *)cmd)[i] != (*pp)[i])
Bram Moolenaar071d4272004-06-13 20:20:40 +00002774 break;
2775 if (i >= len && !isalpha((*pp)[i]))
2776 {
2777 *pp = skipwhite(*pp + i);
2778 return TRUE;
2779 }
2780 return FALSE;
2781}
2782
2783/*
2784 * Find an Ex command by its name, either built-in or user.
Bram Moolenaar52b4b552005-03-07 23:00:57 +00002785 * Start of the name can be found at eap->cmd.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002786 * Returns pointer to char after the command name.
Bram Moolenaar52b4b552005-03-07 23:00:57 +00002787 * "full" is set to TRUE if the whole command name matched.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002788 * Returns NULL for an ambiguous user command.
2789 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002790 static char_u *
2791find_command(eap, full)
2792 exarg_T *eap;
Bram Moolenaar78a15312009-05-15 19:33:18 +00002793 int *full UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002794{
2795 int len;
2796 char_u *p;
Bram Moolenaardf177f62005-02-22 08:39:57 +00002797 int i;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002798
2799 /*
2800 * Isolate the command and search for it in the command table.
Bram Moolenaar81870892007-11-11 18:17:28 +00002801 * Exceptions:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002802 * - the 'k' command can directly be followed by any character.
2803 * - the 's' command can be followed directly by 'c', 'g', 'i', 'I' or 'r'
2804 * but :sre[wind] is another command, as are :scrip[tnames],
2805 * :scs[cope], :sim[alt], :sig[ns] and :sil[ent].
Bram Moolenaardf177f62005-02-22 08:39:57 +00002806 * - the "d" command can directly be followed by 'l' or 'p' flag.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002807 */
2808 p = eap->cmd;
2809 if (*p == 'k')
2810 {
2811 eap->cmdidx = CMD_k;
2812 ++p;
2813 }
2814 else if (p[0] == 's'
Bram Moolenaar52b4b552005-03-07 23:00:57 +00002815 && ((p[1] == 'c' && p[2] != 's' && p[2] != 'r'
2816 && p[3] != 'i' && p[4] != 'p')
Bram Moolenaar071d4272004-06-13 20:20:40 +00002817 || p[1] == 'g'
2818 || (p[1] == 'i' && p[2] != 'm' && p[2] != 'l' && p[2] != 'g')
2819 || p[1] == 'I'
2820 || (p[1] == 'r' && p[2] != 'e')))
2821 {
2822 eap->cmdidx = CMD_substitute;
2823 ++p;
2824 }
2825 else
2826 {
2827 while (ASCII_ISALPHA(*p))
2828 ++p;
Bram Moolenaarb6590522010-07-21 16:00:43 +02002829 /* for python 3.x support ":py3", ":python3", ":py3file", etc. */
Bram Moolenaar55d5c032010-07-17 23:52:29 +02002830 if (eap->cmd[0] == 'p' && eap->cmd[1] == 'y')
Bram Moolenaarb6590522010-07-21 16:00:43 +02002831 while (ASCII_ISALNUM(*p))
2832 ++p;
Bram Moolenaarbd5e15f2010-07-17 21:19:38 +02002833
Bram Moolenaar071d4272004-06-13 20:20:40 +00002834 /* check for non-alpha command */
2835 if (p == eap->cmd && vim_strchr((char_u *)"@*!=><&~#", *p) != NULL)
2836 ++p;
2837 len = (int)(p - eap->cmd);
Bram Moolenaardf177f62005-02-22 08:39:57 +00002838 if (*eap->cmd == 'd' && (p[-1] == 'l' || p[-1] == 'p'))
2839 {
2840 /* Check for ":dl", ":dell", etc. to ":deletel": that's
2841 * :delete with the 'l' flag. Same for 'p'. */
2842 for (i = 0; i < len; ++i)
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00002843 if (eap->cmd[i] != ((char_u *)"delete")[i])
Bram Moolenaardf177f62005-02-22 08:39:57 +00002844 break;
2845 if (i == len - 1)
2846 {
2847 --len;
2848 if (p[-1] == 'l')
2849 eap->flags |= EXFLAG_LIST;
2850 else
2851 eap->flags |= EXFLAG_PRINT;
2852 }
2853 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002854
2855 if (ASCII_ISLOWER(*eap->cmd))
2856 eap->cmdidx = cmdidxs[CharOrdLow(*eap->cmd)];
2857 else
2858 eap->cmdidx = cmdidxs[26];
2859
2860 for ( ; (int)eap->cmdidx < (int)CMD_SIZE;
2861 eap->cmdidx = (cmdidx_T)((int)eap->cmdidx + 1))
2862 if (STRNCMP(cmdnames[(int)eap->cmdidx].cmd_name, (char *)eap->cmd,
2863 (size_t)len) == 0)
2864 {
2865#ifdef FEAT_EVAL
2866 if (full != NULL
2867 && cmdnames[(int)eap->cmdidx].cmd_name[len] == NUL)
2868 *full = TRUE;
2869#endif
2870 break;
2871 }
2872
2873#ifdef FEAT_USR_CMDS
2874 /* Look for a user defined command as a last resort */
2875 if (eap->cmdidx == CMD_SIZE && *eap->cmd >= 'A' && *eap->cmd <= 'Z')
2876 {
Bram Moolenaar52b4b552005-03-07 23:00:57 +00002877 /* User defined commands may contain digits. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002878 while (ASCII_ISALNUM(*p))
2879 ++p;
Bram Moolenaar52b4b552005-03-07 23:00:57 +00002880 p = find_ucmd(eap, p, full, NULL, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002881 }
2882#endif
Bram Moolenaar52b4b552005-03-07 23:00:57 +00002883 if (p == eap->cmd)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002884 eap->cmdidx = CMD_SIZE;
2885 }
2886
2887 return p;
2888}
2889
Bram Moolenaar52b4b552005-03-07 23:00:57 +00002890#ifdef FEAT_USR_CMDS
2891/*
2892 * Search for a user command that matches "eap->cmd".
2893 * Return cmdidx in "eap->cmdidx", flags in "eap->argt", idx in "eap->useridx".
2894 * Return a pointer to just after the command.
2895 * Return NULL if there is no matching command.
2896 */
2897 static char_u *
2898find_ucmd(eap, p, full, xp, compl)
2899 exarg_T *eap;
2900 char_u *p; /* end of the command (possibly including count) */
2901 int *full; /* set to TRUE for a full match */
2902 expand_T *xp; /* used for completion, NULL otherwise */
2903 int *compl; /* completion flags or NULL */
2904{
2905 int len = (int)(p - eap->cmd);
2906 int j, k, matchlen = 0;
2907 ucmd_T *uc;
2908 int found = FALSE;
2909 int possible = FALSE;
2910 char_u *cp, *np; /* Point into typed cmd and test name */
2911 garray_T *gap;
2912 int amb_local = FALSE; /* Found ambiguous buffer-local command,
2913 only full match global is accepted. */
2914
2915 /*
2916 * Look for buffer-local user commands first, then global ones.
2917 */
2918 gap = &curbuf->b_ucmds;
2919 for (;;)
2920 {
2921 for (j = 0; j < gap->ga_len; ++j)
2922 {
2923 uc = USER_CMD_GA(gap, j);
2924 cp = eap->cmd;
2925 np = uc->uc_name;
2926 k = 0;
2927 while (k < len && *np != NUL && *cp++ == *np++)
2928 k++;
2929 if (k == len || (*np == NUL && vim_isdigit(eap->cmd[k])))
2930 {
2931 /* If finding a second match, the command is ambiguous. But
2932 * not if a buffer-local command wasn't a full match and a
2933 * global command is a full match. */
2934 if (k == len && found && *np != NUL)
2935 {
2936 if (gap == &ucmds)
Bram Moolenaar52b4b552005-03-07 23:00:57 +00002937 return NULL;
Bram Moolenaar52b4b552005-03-07 23:00:57 +00002938 amb_local = TRUE;
2939 }
2940
2941 if (!found || (k == len && *np == NUL))
2942 {
2943 /* If we matched up to a digit, then there could
2944 * be another command including the digit that we
2945 * should use instead.
2946 */
2947 if (k == len)
2948 found = TRUE;
2949 else
2950 possible = TRUE;
2951
2952 if (gap == &ucmds)
2953 eap->cmdidx = CMD_USER;
2954 else
2955 eap->cmdidx = CMD_USER_BUF;
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00002956 eap->argt = (long)uc->uc_argt;
Bram Moolenaar52b4b552005-03-07 23:00:57 +00002957 eap->useridx = j;
2958
2959# ifdef FEAT_CMDL_COMPL
2960 if (compl != NULL)
2961 *compl = uc->uc_compl;
2962# ifdef FEAT_EVAL
2963 if (xp != NULL)
2964 {
2965 xp->xp_arg = uc->uc_compl_arg;
2966 xp->xp_scriptID = uc->uc_scriptID;
2967 }
2968# endif
2969# endif
2970 /* Do not search for further abbreviations
2971 * if this is an exact match. */
2972 matchlen = k;
2973 if (k == len && *np == NUL)
2974 {
2975 if (full != NULL)
2976 *full = TRUE;
2977 amb_local = FALSE;
2978 break;
2979 }
2980 }
2981 }
2982 }
2983
2984 /* Stop if we found a full match or searched all. */
2985 if (j < gap->ga_len || gap == &ucmds)
2986 break;
2987 gap = &ucmds;
2988 }
2989
2990 /* Only found ambiguous matches. */
2991 if (amb_local)
2992 {
2993 if (xp != NULL)
2994 xp->xp_context = EXPAND_UNSUCCESSFUL;
2995 return NULL;
2996 }
2997
2998 /* The match we found may be followed immediately by a number. Move "p"
2999 * back to point to it. */
3000 if (found || possible)
3001 return p + (matchlen - len);
3002 return p;
3003}
3004#endif
3005
Bram Moolenaar071d4272004-06-13 20:20:40 +00003006#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaared53fb92007-11-24 20:50:24 +00003007static struct cmdmod
3008{
3009 char *name;
3010 int minlen;
3011 int has_count; /* :123verbose :3tab */
3012} cmdmods[] = {
3013 {"aboveleft", 3, FALSE},
3014 {"belowright", 3, FALSE},
3015 {"botright", 2, FALSE},
3016 {"browse", 3, FALSE},
3017 {"confirm", 4, FALSE},
3018 {"hide", 3, FALSE},
3019 {"keepalt", 5, FALSE},
3020 {"keepjumps", 5, FALSE},
3021 {"keepmarks", 3, FALSE},
3022 {"leftabove", 5, FALSE},
3023 {"lockmarks", 3, FALSE},
Bram Moolenaarca9f9582008-09-18 10:44:28 +00003024 {"noautocmd", 3, FALSE},
Bram Moolenaared53fb92007-11-24 20:50:24 +00003025 {"rightbelow", 6, FALSE},
3026 {"sandbox", 3, FALSE},
3027 {"silent", 3, FALSE},
3028 {"tab", 3, TRUE},
3029 {"topleft", 2, FALSE},
Bram Moolenaar8e258a42009-07-09 13:55:43 +00003030 {"unsilent", 3, FALSE},
Bram Moolenaared53fb92007-11-24 20:50:24 +00003031 {"verbose", 4, TRUE},
3032 {"vertical", 4, FALSE},
3033};
3034
3035/*
3036 * Return length of a command modifier (including optional count).
3037 * Return zero when it's not a modifier.
3038 */
3039 int
3040modifier_len(cmd)
3041 char_u *cmd;
3042{
3043 int i, j;
3044 char_u *p = cmd;
3045
3046 if (VIM_ISDIGIT(*cmd))
3047 p = skipwhite(skipdigits(cmd));
Bram Moolenaaraf0167f2009-05-16 15:31:32 +00003048 for (i = 0; i < (int)(sizeof(cmdmods) / sizeof(struct cmdmod)); ++i)
Bram Moolenaared53fb92007-11-24 20:50:24 +00003049 {
3050 for (j = 0; p[j] != NUL; ++j)
3051 if (p[j] != cmdmods[i].name[j])
3052 break;
3053 if (!isalpha(p[j]) && j >= cmdmods[i].minlen
3054 && (p == cmd || cmdmods[i].has_count))
Bram Moolenaarcb4cef22008-03-16 15:04:34 +00003055 return j + (int)(p - cmd);
Bram Moolenaared53fb92007-11-24 20:50:24 +00003056 }
3057 return 0;
3058}
3059
Bram Moolenaar071d4272004-06-13 20:20:40 +00003060/*
3061 * Return > 0 if an Ex command "name" exists.
3062 * Return 2 if there is an exact match.
3063 * Return 3 if there is an ambiguous match.
3064 */
3065 int
3066cmd_exists(name)
3067 char_u *name;
3068{
3069 exarg_T ea;
3070 int full = FALSE;
3071 int i;
3072 int j;
Bram Moolenaarf3a67882006-05-05 21:09:41 +00003073 char_u *p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003074
3075 /* Check command modifiers. */
Bram Moolenaaraf0167f2009-05-16 15:31:32 +00003076 for (i = 0; i < (int)(sizeof(cmdmods) / sizeof(struct cmdmod)); ++i)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003077 {
3078 for (j = 0; name[j] != NUL; ++j)
3079 if (name[j] != cmdmods[i].name[j])
3080 break;
3081 if (name[j] == NUL && j >= cmdmods[i].minlen)
3082 return (cmdmods[i].name[j] == NUL ? 2 : 1);
3083 }
3084
Bram Moolenaara9587612006-05-04 21:47:50 +00003085 /* Check built-in commands and user defined commands.
3086 * For ":2match" and ":3match" we need to skip the number. */
3087 ea.cmd = (*name == '2' || *name == '3') ? name + 1 : name;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003088 ea.cmdidx = (cmdidx_T)0;
Bram Moolenaarf3a67882006-05-05 21:09:41 +00003089 p = find_command(&ea, &full);
3090 if (p == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003091 return 3;
Bram Moolenaara9587612006-05-04 21:47:50 +00003092 if (vim_isdigit(*name) && ea.cmdidx != CMD_match)
3093 return 0;
Bram Moolenaarf3a67882006-05-05 21:09:41 +00003094 if (*skipwhite(p) != NUL)
3095 return 0; /* trailing garbage */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003096 return (ea.cmdidx == CMD_SIZE ? 0 : (full ? 2 : 1));
3097}
3098#endif
3099
3100/*
3101 * This is all pretty much copied from do_one_cmd(), with all the extra stuff
3102 * we don't need/want deleted. Maybe this could be done better if we didn't
3103 * repeat all this stuff. The only problem is that they may not stay
3104 * perfectly compatible with each other, but then the command line syntax
3105 * probably won't change that much -- webb.
3106 */
3107 char_u *
3108set_one_cmd_context(xp, buff)
3109 expand_T *xp;
3110 char_u *buff; /* buffer for command string */
3111{
3112 char_u *p;
3113 char_u *cmd, *arg;
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003114 int len = 0;
3115 exarg_T ea;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003116#if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
3117 int compl = EXPAND_NOTHING;
3118#endif
3119#ifdef FEAT_CMDL_COMPL
3120 int delim;
3121#endif
3122 int forceit = FALSE;
3123 int usefilter = FALSE; /* filter instead of file name */
3124
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00003125 ExpandInit(xp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003126 xp->xp_pattern = buff;
3127 xp->xp_context = EXPAND_COMMANDS; /* Default until we get past command */
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003128 ea.argt = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003129
3130/*
3131 * 2. skip comment lines and leading space, colons or bars
3132 */
3133 for (cmd = buff; vim_strchr((char_u *)" \t:|", *cmd) != NULL; cmd++)
3134 ;
3135 xp->xp_pattern = cmd;
3136
3137 if (*cmd == NUL)
3138 return NULL;
3139 if (*cmd == '"') /* ignore comment lines */
3140 {
3141 xp->xp_context = EXPAND_NOTHING;
3142 return NULL;
3143 }
3144
3145/*
3146 * 3. parse a range specifier of the form: addr [,addr] [;addr] ..
3147 */
3148 cmd = skip_range(cmd, &xp->xp_context);
3149
3150/*
3151 * 4. parse command
3152 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003153 xp->xp_pattern = cmd;
3154 if (*cmd == NUL)
3155 return NULL;
3156 if (*cmd == '"')
3157 {
3158 xp->xp_context = EXPAND_NOTHING;
3159 return NULL;
3160 }
3161
3162 if (*cmd == '|' || *cmd == '\n')
3163 return cmd + 1; /* There's another command */
3164
3165 /*
3166 * Isolate the command and search for it in the command table.
3167 * Exceptions:
3168 * - the 'k' command can directly be followed by any character, but
Bram Moolenaard4755bb2004-09-02 19:12:26 +00003169 * do accept "keepmarks", "keepalt" and "keepjumps".
Bram Moolenaar071d4272004-06-13 20:20:40 +00003170 * - the 's' command can be followed directly by 'c', 'g', 'i', 'I' or 'r'
3171 */
3172 if (*cmd == 'k' && cmd[1] != 'e')
3173 {
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003174 ea.cmdidx = CMD_k;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003175 p = cmd + 1;
3176 }
3177 else
3178 {
3179 p = cmd;
3180 while (ASCII_ISALPHA(*p) || *p == '*') /* Allow * wild card */
3181 ++p;
3182 /* check for non-alpha command */
3183 if (p == cmd && vim_strchr((char_u *)"@*!=><&~#", *p) != NULL)
3184 ++p;
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003185 len = (int)(p - cmd);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003186
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003187 if (len == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003188 {
3189 xp->xp_context = EXPAND_UNSUCCESSFUL;
3190 return NULL;
3191 }
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003192 for (ea.cmdidx = (cmdidx_T)0; (int)ea.cmdidx < (int)CMD_SIZE;
Bram Moolenaar42b4dda2010-03-02 15:56:05 +01003193 ea.cmdidx = (cmdidx_T)((int)ea.cmdidx + 1))
3194 if (STRNCMP(cmdnames[(int)ea.cmdidx].cmd_name, cmd,
3195 (size_t)len) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003196 break;
3197
3198#ifdef FEAT_USR_CMDS
3199 if (cmd[0] >= 'A' && cmd[0] <= 'Z')
Bram Moolenaar071d4272004-06-13 20:20:40 +00003200 while (ASCII_ISALNUM(*p) || *p == '*') /* Allow * wild card */
3201 ++p;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003202#endif
3203 }
3204
3205 /*
3206 * If the cursor is touching the command, and it ends in an alpha-numeric
3207 * character, complete the command name.
3208 */
3209 if (*p == NUL && ASCII_ISALNUM(p[-1]))
3210 return NULL;
3211
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003212 if (ea.cmdidx == CMD_SIZE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003213 {
3214 if (*cmd == 's' && vim_strchr((char_u *)"cgriI", cmd[1]) != NULL)
3215 {
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003216 ea.cmdidx = CMD_substitute;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003217 p = cmd + 1;
3218 }
3219#ifdef FEAT_USR_CMDS
3220 else if (cmd[0] >= 'A' && cmd[0] <= 'Z')
3221 {
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003222 ea.cmd = cmd;
3223 p = find_ucmd(&ea, p, NULL, xp,
3224# if defined(FEAT_CMDL_COMPL)
3225 &compl
3226# else
3227 NULL
Bram Moolenaar071d4272004-06-13 20:20:40 +00003228# endif
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003229 );
Bram Moolenaarebefac62005-12-28 22:39:57 +00003230 if (p == NULL)
3231 ea.cmdidx = CMD_SIZE; /* ambiguous user command */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003232 }
3233#endif
3234 }
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003235 if (ea.cmdidx == CMD_SIZE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003236 {
3237 /* Not still touching the command and it was an illegal one */
3238 xp->xp_context = EXPAND_UNSUCCESSFUL;
3239 return NULL;
3240 }
3241
3242 xp->xp_context = EXPAND_NOTHING; /* Default now that we're past command */
3243
3244 if (*p == '!') /* forced commands */
3245 {
3246 forceit = TRUE;
3247 ++p;
3248 }
3249
3250/*
3251 * 5. parse arguments
3252 */
3253#ifdef FEAT_USR_CMDS
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003254 if (!USER_CMDIDX(ea.cmdidx))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003255#endif
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00003256 ea.argt = (long)cmdnames[(int)ea.cmdidx].cmd_argt;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003257
3258 arg = skipwhite(p);
3259
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003260 if (ea.cmdidx == CMD_write || ea.cmdidx == CMD_update)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003261 {
3262 if (*arg == '>') /* append */
3263 {
3264 if (*++arg == '>')
3265 ++arg;
3266 arg = skipwhite(arg);
3267 }
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003268 else if (*arg == '!' && ea.cmdidx == CMD_write) /* :w !filter */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003269 {
3270 ++arg;
3271 usefilter = TRUE;
3272 }
3273 }
3274
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003275 if (ea.cmdidx == CMD_read)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003276 {
3277 usefilter = forceit; /* :r! filter if forced */
3278 if (*arg == '!') /* :r !filter */
3279 {
3280 ++arg;
3281 usefilter = TRUE;
3282 }
3283 }
3284
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003285 if (ea.cmdidx == CMD_lshift || ea.cmdidx == CMD_rshift)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003286 {
3287 while (*arg == *cmd) /* allow any number of '>' or '<' */
3288 ++arg;
3289 arg = skipwhite(arg);
3290 }
3291
3292 /* Does command allow "+command"? */
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003293 if ((ea.argt & EDITCMD) && !usefilter && *arg == '+')
Bram Moolenaar071d4272004-06-13 20:20:40 +00003294 {
3295 /* Check if we're in the +command */
3296 p = arg + 1;
3297 arg = skip_cmd_arg(arg, FALSE);
3298
3299 /* Still touching the command after '+'? */
3300 if (*arg == NUL)
3301 return p;
3302
3303 /* Skip space(s) after +command to get to the real argument */
3304 arg = skipwhite(arg);
3305 }
3306
3307 /*
3308 * Check for '|' to separate commands and '"' to start comments.
3309 * Don't do this for ":read !cmd" and ":write !cmd".
3310 */
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003311 if ((ea.argt & TRLBAR) && !usefilter)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003312 {
3313 p = arg;
3314 /* ":redir @" is not the start of a comment */
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003315 if (ea.cmdidx == CMD_redir && p[0] == '@' && p[1] == '"')
Bram Moolenaar071d4272004-06-13 20:20:40 +00003316 p += 2;
3317 while (*p)
3318 {
3319 if (*p == Ctrl_V)
3320 {
3321 if (p[1] != NUL)
3322 ++p;
3323 }
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003324 else if ( (*p == '"' && !(ea.argt & NOTRLCOM))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003325 || *p == '|' || *p == '\n')
3326 {
3327 if (*(p - 1) != '\\')
3328 {
3329 if (*p == '|' || *p == '\n')
3330 return p + 1;
3331 return NULL; /* It's a comment */
3332 }
3333 }
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00003334 mb_ptr_adv(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003335 }
3336 }
3337
3338 /* no arguments allowed */
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003339 if (!(ea.argt & EXTRA) && *arg != NUL &&
Bram Moolenaar071d4272004-06-13 20:20:40 +00003340 vim_strchr((char_u *)"|\"", *arg) == NULL)
3341 return NULL;
3342
3343 /* Find start of last argument (argument just before cursor): */
3344 p = buff + STRLEN(buff);
3345 while (p != arg && *p != ' ' && *p != TAB)
3346 p--;
3347 if (*p == ' ' || *p == TAB)
3348 p++;
3349 xp->xp_pattern = p;
3350
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003351 if (ea.argt & XFILE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003352 {
Bram Moolenaar6529c102007-08-18 15:47:34 +00003353 int c;
3354 int in_quote = FALSE;
3355 char_u *bow = NULL; /* Beginning of word */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003356
3357 /*
3358 * Allow spaces within back-quotes to count as part of the argument
3359 * being expanded.
3360 */
3361 xp->xp_pattern = skipwhite(arg);
Bram Moolenaar6529c102007-08-18 15:47:34 +00003362 p = xp->xp_pattern;
3363 while (*p != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003364 {
Bram Moolenaar6529c102007-08-18 15:47:34 +00003365#ifdef FEAT_MBYTE
3366 if (has_mbyte)
3367 c = mb_ptr2char(p);
3368 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00003369#endif
Bram Moolenaar6529c102007-08-18 15:47:34 +00003370 c = *p;
3371 if (c == '\\' && p[1] != NUL)
3372 ++p;
3373 else if (c == '`')
Bram Moolenaar071d4272004-06-13 20:20:40 +00003374 {
3375 if (!in_quote)
3376 {
3377 xp->xp_pattern = p;
3378 bow = p + 1;
3379 }
3380 in_quote = !in_quote;
3381 }
Bram Moolenaar332fa0c2008-01-13 16:12:10 +00003382 /* An argument can contain just about everything, except
3383 * characters that end the command and white space. */
3384 else if (c == '|' || c == '\n' || c == '"' || (vim_iswhite(c)
Bram Moolenaar6529c102007-08-18 15:47:34 +00003385#ifdef SPACE_IN_FILENAME
Bram Moolenaar332fa0c2008-01-13 16:12:10 +00003386 && (!(ea.argt & NOSPC) || usefilter)
Bram Moolenaar6529c102007-08-18 15:47:34 +00003387#endif
Bram Moolenaar332fa0c2008-01-13 16:12:10 +00003388 ))
Bram Moolenaar6529c102007-08-18 15:47:34 +00003389 {
Bram Moolenaarcf5a5b82008-02-26 20:30:12 +00003390 len = 0; /* avoid getting stuck when space is in 'isfname' */
Bram Moolenaar6529c102007-08-18 15:47:34 +00003391 while (*p != NUL)
3392 {
3393#ifdef FEAT_MBYTE
3394 if (has_mbyte)
3395 c = mb_ptr2char(p);
3396 else
3397#endif
3398 c = *p;
Bram Moolenaardd87969c2007-08-21 13:07:12 +00003399 if (c == '`' || vim_isfilec_or_wc(c))
Bram Moolenaar6529c102007-08-18 15:47:34 +00003400 break;
3401#ifdef FEAT_MBYTE
3402 if (has_mbyte)
3403 len = (*mb_ptr2len)(p);
3404 else
3405#endif
3406 len = 1;
3407 mb_ptr_adv(p);
3408 }
3409 if (in_quote)
3410 bow = p;
3411 else
3412 xp->xp_pattern = p;
3413 p -= len;
3414 }
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00003415 mb_ptr_adv(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003416 }
3417
3418 /*
3419 * If we are still inside the quotes, and we passed a space, just
3420 * expand from there.
3421 */
3422 if (bow != NULL && in_quote)
3423 xp->xp_pattern = bow;
3424 xp->xp_context = EXPAND_FILES;
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003425
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00003426#ifndef BACKSLASH_IN_FILENAME
3427 /* For a shell command more chars need to be escaped. */
3428 if (usefilter || ea.cmdidx == CMD_bang)
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003429 {
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00003430 xp->xp_shell = TRUE;
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003431
3432 /* When still after the command name expand executables. */
3433 if (xp->xp_pattern == skipwhite(arg))
Bram Moolenaar5c5b0942007-05-06 12:07:59 +00003434 xp->xp_context = EXPAND_SHELLCMD;
Bram Moolenaar362e1a32006-03-06 23:29:24 +00003435 }
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00003436#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003437
3438 /* Check for environment variable */
3439 if (*xp->xp_pattern == '$'
3440#if defined(MSDOS) || defined(MSWIN) || defined(OS2)
3441 || *xp->xp_pattern == '%'
3442#endif
3443 )
3444 {
3445 for (p = xp->xp_pattern + 1; *p != NUL; ++p)
3446 if (!vim_isIDc(*p))
3447 break;
3448 if (*p == NUL)
3449 {
3450 xp->xp_context = EXPAND_ENV_VARS;
3451 ++xp->xp_pattern;
Bram Moolenaar21cf8232004-07-16 20:18:37 +00003452#if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
3453 /* Avoid that the assignment uses EXPAND_FILES again. */
Bram Moolenaara466c992005-07-09 21:03:22 +00003454 if (compl != EXPAND_USER_DEFINED && compl != EXPAND_USER_LIST)
Bram Moolenaar21cf8232004-07-16 20:18:37 +00003455 compl = EXPAND_ENV_VARS;
3456#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003457 }
3458 }
3459 }
3460
3461/*
3462 * 6. switch on command name
3463 */
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003464 switch (ea.cmdidx)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003465 {
Bram Moolenaarcc448b32010-07-14 16:52:17 +02003466 case CMD_find:
3467 case CMD_sfind:
3468 case CMD_tabfind:
3469 xp->xp_context = EXPAND_FILES_IN_PATH;
3470 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003471 case CMD_cd:
3472 case CMD_chdir:
3473 case CMD_lcd:
3474 case CMD_lchdir:
3475 if (xp->xp_context == EXPAND_FILES)
3476 xp->xp_context = EXPAND_DIRECTORIES;
3477 break;
3478 case CMD_help:
3479 xp->xp_context = EXPAND_HELP;
3480 xp->xp_pattern = arg;
3481 break;
3482
Bram Moolenaardf7b1ff2005-03-11 22:40:50 +00003483 /* Command modifiers: return the argument.
3484 * Also for commands with an argument that is a command. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00003485 case CMD_aboveleft:
Bram Moolenaardf7b1ff2005-03-11 22:40:50 +00003486 case CMD_argdo:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003487 case CMD_belowright:
3488 case CMD_botright:
3489 case CMD_browse:
Bram Moolenaardf7b1ff2005-03-11 22:40:50 +00003490 case CMD_bufdo:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003491 case CMD_confirm:
Bram Moolenaardf177f62005-02-22 08:39:57 +00003492 case CMD_debug:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003493 case CMD_folddoclosed:
3494 case CMD_folddoopen:
3495 case CMD_hide:
Bram Moolenaard4755bb2004-09-02 19:12:26 +00003496 case CMD_keepalt:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003497 case CMD_keepjumps:
3498 case CMD_keepmarks:
3499 case CMD_leftabove:
3500 case CMD_lockmarks:
3501 case CMD_rightbelow:
Bram Moolenaardf7b1ff2005-03-11 22:40:50 +00003502 case CMD_sandbox:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003503 case CMD_silent:
Bram Moolenaara226a6d2006-02-26 23:59:20 +00003504 case CMD_tab:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003505 case CMD_topleft:
3506 case CMD_verbose:
3507 case CMD_vertical:
Bram Moolenaardf7b1ff2005-03-11 22:40:50 +00003508 case CMD_windo:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003509 return arg;
3510
Bram Moolenaar4f688582007-07-24 12:34:30 +00003511#ifdef FEAT_CMDL_COMPL
3512# ifdef FEAT_SEARCH_EXTRA
Bram Moolenaar071d4272004-06-13 20:20:40 +00003513 case CMD_match:
3514 if (*arg == NUL || !ends_excmd(*arg))
3515 {
Bram Moolenaar4f688582007-07-24 12:34:30 +00003516 /* also complete "None" */
3517 set_context_in_echohl_cmd(xp, arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003518 arg = skipwhite(skiptowhite(arg));
3519 if (*arg != NUL)
3520 {
3521 xp->xp_context = EXPAND_NOTHING;
3522 arg = skip_regexp(arg + 1, *arg, p_magic, NULL);
3523 }
3524 }
3525 return find_nextcmd(arg);
Bram Moolenaar4f688582007-07-24 12:34:30 +00003526# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003527
Bram Moolenaar071d4272004-06-13 20:20:40 +00003528/*
3529 * All completion for the +cmdline_compl feature goes here.
3530 */
3531
3532# ifdef FEAT_USR_CMDS
3533 case CMD_command:
3534 /* Check for attributes */
3535 while (*arg == '-')
3536 {
3537 arg++; /* Skip "-" */
3538 p = skiptowhite(arg);
3539 if (*p == NUL)
3540 {
3541 /* Cursor is still in the attribute */
3542 p = vim_strchr(arg, '=');
3543 if (p == NULL)
3544 {
3545 /* No "=", so complete attribute names */
3546 xp->xp_context = EXPAND_USER_CMD_FLAGS;
3547 xp->xp_pattern = arg;
3548 return NULL;
3549 }
3550
3551 /* For the -complete and -nargs attributes, we complete
3552 * their arguments as well.
3553 */
3554 if (STRNICMP(arg, "complete", p - arg) == 0)
3555 {
3556 xp->xp_context = EXPAND_USER_COMPLETE;
3557 xp->xp_pattern = p + 1;
3558 return NULL;
3559 }
3560 else if (STRNICMP(arg, "nargs", p - arg) == 0)
3561 {
3562 xp->xp_context = EXPAND_USER_NARGS;
3563 xp->xp_pattern = p + 1;
3564 return NULL;
3565 }
3566 return NULL;
3567 }
3568 arg = skipwhite(p);
3569 }
3570
3571 /* After the attributes comes the new command name */
3572 p = skiptowhite(arg);
3573 if (*p == NUL)
3574 {
3575 xp->xp_context = EXPAND_USER_COMMANDS;
3576 xp->xp_pattern = arg;
3577 break;
3578 }
3579
3580 /* And finally comes a normal command */
3581 return skipwhite(p);
3582
3583 case CMD_delcommand:
3584 xp->xp_context = EXPAND_USER_COMMANDS;
3585 xp->xp_pattern = arg;
3586 break;
3587# endif
3588
3589 case CMD_global:
3590 case CMD_vglobal:
3591 delim = *arg; /* get the delimiter */
3592 if (delim)
3593 ++arg; /* skip delimiter if there is one */
3594
3595 while (arg[0] != NUL && arg[0] != delim)
3596 {
3597 if (arg[0] == '\\' && arg[1] != NUL)
3598 ++arg;
3599 ++arg;
3600 }
3601 if (arg[0] != NUL)
3602 return arg + 1;
3603 break;
3604 case CMD_and:
3605 case CMD_substitute:
3606 delim = *arg;
3607 if (delim)
3608 {
3609 /* skip "from" part */
3610 ++arg;
3611 arg = skip_regexp(arg, delim, p_magic, NULL);
3612 }
3613 /* skip "to" part */
3614 while (arg[0] != NUL && arg[0] != delim)
3615 {
3616 if (arg[0] == '\\' && arg[1] != NUL)
3617 ++arg;
3618 ++arg;
3619 }
3620 if (arg[0] != NUL) /* skip delimiter */
3621 ++arg;
3622 while (arg[0] && vim_strchr((char_u *)"|\"#", arg[0]) == NULL)
3623 ++arg;
3624 if (arg[0] != NUL)
3625 return arg;
3626 break;
3627 case CMD_isearch:
3628 case CMD_dsearch:
3629 case CMD_ilist:
3630 case CMD_dlist:
3631 case CMD_ijump:
3632 case CMD_psearch:
3633 case CMD_djump:
3634 case CMD_isplit:
3635 case CMD_dsplit:
3636 arg = skipwhite(skipdigits(arg)); /* skip count */
3637 if (*arg == '/') /* Match regexp, not just whole words */
3638 {
3639 for (++arg; *arg && *arg != '/'; arg++)
3640 if (*arg == '\\' && arg[1] != NUL)
3641 arg++;
3642 if (*arg)
3643 {
3644 arg = skipwhite(arg + 1);
3645
3646 /* Check for trailing illegal characters */
3647 if (*arg && vim_strchr((char_u *)"|\"\n", *arg) == NULL)
3648 xp->xp_context = EXPAND_NOTHING;
3649 else
3650 return arg;
3651 }
3652 }
3653 break;
3654#ifdef FEAT_AUTOCMD
3655 case CMD_autocmd:
3656 return set_context_in_autocmd(xp, arg, FALSE);
3657
3658 case CMD_doautocmd:
Bram Moolenaar73a9d7b2008-11-06 16:16:44 +00003659 case CMD_doautoall:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003660 return set_context_in_autocmd(xp, arg, TRUE);
3661#endif
3662 case CMD_set:
3663 set_context_in_set_cmd(xp, arg, 0);
3664 break;
3665 case CMD_setglobal:
3666 set_context_in_set_cmd(xp, arg, OPT_GLOBAL);
3667 break;
3668 case CMD_setlocal:
3669 set_context_in_set_cmd(xp, arg, OPT_LOCAL);
3670 break;
3671 case CMD_tag:
3672 case CMD_stag:
3673 case CMD_ptag:
Bram Moolenaarb8a7b562006-02-01 21:47:16 +00003674 case CMD_ltag:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003675 case CMD_tselect:
3676 case CMD_stselect:
3677 case CMD_ptselect:
3678 case CMD_tjump:
3679 case CMD_stjump:
3680 case CMD_ptjump:
Bram Moolenaarb5bf5b82004-12-24 14:35:23 +00003681 if (*p_wop != NUL)
3682 xp->xp_context = EXPAND_TAGS_LISTFILES;
3683 else
3684 xp->xp_context = EXPAND_TAGS;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003685 xp->xp_pattern = arg;
3686 break;
3687 case CMD_augroup:
3688 xp->xp_context = EXPAND_AUGROUP;
3689 xp->xp_pattern = arg;
3690 break;
3691#ifdef FEAT_SYN_HL
3692 case CMD_syntax:
3693 set_context_in_syntax_cmd(xp, arg);
3694 break;
3695#endif
3696#ifdef FEAT_EVAL
3697 case CMD_let:
3698 case CMD_if:
3699 case CMD_elseif:
3700 case CMD_while:
Bram Moolenaarb32ce2d2005-01-05 22:07:01 +00003701 case CMD_for:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003702 case CMD_echo:
3703 case CMD_echon:
3704 case CMD_execute:
3705 case CMD_echomsg:
3706 case CMD_echoerr:
3707 case CMD_call:
3708 case CMD_return:
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003709 set_context_for_expression(xp, arg, ea.cmdidx);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003710 break;
3711
3712 case CMD_unlet:
3713 while ((xp->xp_pattern = vim_strchr(arg, ' ')) != NULL)
3714 arg = xp->xp_pattern + 1;
3715 xp->xp_context = EXPAND_USER_VARS;
3716 xp->xp_pattern = arg;
3717 break;
3718
3719 case CMD_function:
3720 case CMD_delfunction:
3721 xp->xp_context = EXPAND_USER_FUNC;
3722 xp->xp_pattern = arg;
3723 break;
3724
3725 case CMD_echohl:
Bram Moolenaar4f688582007-07-24 12:34:30 +00003726 set_context_in_echohl_cmd(xp, arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003727 break;
3728#endif
3729 case CMD_highlight:
3730 set_context_in_highlight_cmd(xp, arg);
3731 break;
Bram Moolenaarf4580d82009-03-18 11:52:53 +00003732#ifdef FEAT_CSCOPE
3733 case CMD_cscope:
Bram Moolenaar7bfef802009-04-22 14:25:01 +00003734 case CMD_lcscope:
3735 case CMD_scscope:
3736 set_context_in_cscope_cmd(xp, arg, ea.cmdidx);
Bram Moolenaarf4580d82009-03-18 11:52:53 +00003737 break;
3738#endif
Bram Moolenaar3c65e312009-04-29 16:47:23 +00003739#ifdef FEAT_SIGNS
3740 case CMD_sign:
3741 set_context_in_sign_cmd(xp, arg);
3742 break;
3743#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003744#ifdef FEAT_LISTCMDS
3745 case CMD_bdelete:
3746 case CMD_bwipeout:
3747 case CMD_bunload:
3748 while ((xp->xp_pattern = vim_strchr(arg, ' ')) != NULL)
3749 arg = xp->xp_pattern + 1;
3750 /*FALLTHROUGH*/
3751 case CMD_buffer:
3752 case CMD_sbuffer:
3753 case CMD_checktime:
3754 xp->xp_context = EXPAND_BUFFERS;
3755 xp->xp_pattern = arg;
3756 break;
3757#endif
3758#ifdef FEAT_USR_CMDS
3759 case CMD_USER:
3760 case CMD_USER_BUF:
3761 if (compl != EXPAND_NOTHING)
3762 {
3763 /* XFILE: file names are handled above */
Bram Moolenaar52b4b552005-03-07 23:00:57 +00003764 if (!(ea.argt & XFILE))
Bram Moolenaar071d4272004-06-13 20:20:40 +00003765 {
3766# ifdef FEAT_MENU
3767 if (compl == EXPAND_MENUS)
3768 return set_context_in_menu_cmd(xp, cmd, arg, forceit);
3769# endif
3770 if (compl == EXPAND_COMMANDS)
3771 return arg;
3772 if (compl == EXPAND_MAPPINGS)
3773 return set_context_in_map_cmd(xp, (char_u *)"map",
3774 arg, forceit, FALSE, FALSE, CMD_map);
3775 while ((xp->xp_pattern = vim_strchr(arg, ' ')) != NULL)
3776 arg = xp->xp_pattern + 1;
3777 xp->xp_pattern = arg;
3778 }
3779 xp->xp_context = compl;
3780 }
3781 break;
3782#endif
3783 case CMD_map: case CMD_noremap:
3784 case CMD_nmap: case CMD_nnoremap:
3785 case CMD_vmap: case CMD_vnoremap:
3786 case CMD_omap: case CMD_onoremap:
3787 case CMD_imap: case CMD_inoremap:
3788 case CMD_cmap: case CMD_cnoremap:
Bram Moolenaar22b306f2010-07-25 13:50:33 +02003789 case CMD_lmap: case CMD_lnoremap:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003790 return set_context_in_map_cmd(xp, cmd, arg, forceit,
Bram Moolenaar22b306f2010-07-25 13:50:33 +02003791 FALSE, FALSE, ea.cmdidx);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003792 case CMD_unmap:
3793 case CMD_nunmap:
3794 case CMD_vunmap:
3795 case CMD_ounmap:
3796 case CMD_iunmap:
3797 case CMD_cunmap:
Bram Moolenaar22b306f2010-07-25 13:50:33 +02003798 case CMD_lunmap:
Bram Moolenaar071d4272004-06-13 20:20:40 +00003799 return set_context_in_map_cmd(xp, cmd, arg, forceit,
Bram Moolenaar22b306f2010-07-25 13:50:33 +02003800 FALSE, TRUE, ea.cmdidx);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003801 case CMD_abbreviate: case CMD_noreabbrev:
3802 case CMD_cabbrev: case CMD_cnoreabbrev:
3803 case CMD_iabbrev: case CMD_inoreabbrev:
3804 return set_context_in_map_cmd(xp, cmd, arg, forceit,
Bram Moolenaar22b306f2010-07-25 13:50:33 +02003805 TRUE, FALSE, ea.cmdidx);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003806 case CMD_unabbreviate:
3807 case CMD_cunabbrev:
3808 case CMD_iunabbrev:
3809 return set_context_in_map_cmd(xp, cmd, arg, forceit,
Bram Moolenaar22b306f2010-07-25 13:50:33 +02003810 TRUE, TRUE, ea.cmdidx);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003811#ifdef FEAT_MENU
3812 case CMD_menu: case CMD_noremenu: case CMD_unmenu:
3813 case CMD_amenu: case CMD_anoremenu: case CMD_aunmenu:
3814 case CMD_nmenu: case CMD_nnoremenu: case CMD_nunmenu:
3815 case CMD_vmenu: case CMD_vnoremenu: case CMD_vunmenu:
3816 case CMD_omenu: case CMD_onoremenu: case CMD_ounmenu:
3817 case CMD_imenu: case CMD_inoremenu: case CMD_iunmenu:
3818 case CMD_cmenu: case CMD_cnoremenu: case CMD_cunmenu:
3819 case CMD_tmenu: case CMD_tunmenu:
3820 case CMD_popup: case CMD_tearoff: case CMD_emenu:
3821 return set_context_in_menu_cmd(xp, cmd, arg, forceit);
3822#endif
3823
3824 case CMD_colorscheme:
3825 xp->xp_context = EXPAND_COLORS;
3826 xp->xp_pattern = arg;
3827 break;
3828
3829 case CMD_compiler:
3830 xp->xp_context = EXPAND_COMPILER;
3831 xp->xp_pattern = arg;
3832 break;
3833
Bram Moolenaar883f5d02010-06-21 06:24:34 +02003834 case CMD_ownsyntax:
Bram Moolenaar1587a1e2010-07-29 20:59:59 +02003835 xp->xp_context = EXPAND_OWNSYNTAX;
3836 xp->xp_pattern = arg;
3837 break;
3838
3839 case CMD_setfiletype:
Bram Moolenaar883f5d02010-06-21 06:24:34 +02003840 xp->xp_context = EXPAND_FILETYPE;
3841 xp->xp_pattern = arg;
3842 break;
3843
Bram Moolenaar071d4272004-06-13 20:20:40 +00003844#if (defined(HAVE_LOCALE_H) || defined(X_LOCALE)) \
3845 && (defined(FEAT_GETTEXT) || defined(FEAT_MBYTE))
3846 case CMD_language:
3847 if (*skiptowhite(arg) == NUL)
3848 {
3849 xp->xp_context = EXPAND_LANGUAGE;
3850 xp->xp_pattern = arg;
3851 }
3852 else
3853 xp->xp_context = EXPAND_NOTHING;
3854 break;
3855#endif
Bram Moolenaarf86f26c2010-02-03 15:14:22 +01003856#if defined(FEAT_PROFILE)
3857 case CMD_profile:
3858 set_context_in_profile_cmd(xp, arg);
3859 break;
3860#endif
Bram Moolenaar42b4dda2010-03-02 15:56:05 +01003861 case CMD_behave:
3862 xp->xp_context = EXPAND_BEHAVE;
3863 break;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003864
3865#endif /* FEAT_CMDL_COMPL */
3866
3867 default:
3868 break;
3869 }
3870 return NULL;
3871}
3872
3873/*
3874 * skip a range specifier of the form: addr [,addr] [;addr] ..
3875 *
3876 * Backslashed delimiters after / or ? will be skipped, and commands will
3877 * not be expanded between /'s and ?'s or after "'".
3878 *
Bram Moolenaardf177f62005-02-22 08:39:57 +00003879 * Also skip white space and ":" characters.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003880 * Returns the "cmd" pointer advanced to beyond the range.
3881 */
3882 char_u *
3883skip_range(cmd, ctx)
3884 char_u *cmd;
3885 int *ctx; /* pointer to xp_context or NULL */
3886{
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00003887 unsigned delim;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003888
Bram Moolenaardf177f62005-02-22 08:39:57 +00003889 while (vim_strchr((char_u *)" \t0123456789.$%'/?-+,;", *cmd) != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003890 {
3891 if (*cmd == '\'')
3892 {
3893 if (*++cmd == NUL && ctx != NULL)
3894 *ctx = EXPAND_NOTHING;
3895 }
3896 else if (*cmd == '/' || *cmd == '?')
3897 {
3898 delim = *cmd++;
3899 while (*cmd != NUL && *cmd != delim)
3900 if (*cmd++ == '\\' && *cmd != NUL)
3901 ++cmd;
3902 if (*cmd == NUL && ctx != NULL)
3903 *ctx = EXPAND_NOTHING;
3904 }
3905 if (*cmd != NUL)
3906 ++cmd;
3907 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00003908
3909 /* Skip ":" and white space. */
3910 while (*cmd == ':')
3911 cmd = skipwhite(cmd + 1);
3912
Bram Moolenaar071d4272004-06-13 20:20:40 +00003913 return cmd;
3914}
3915
3916/*
3917 * get a single EX address
3918 *
3919 * Set ptr to the next character after the part that was interpreted.
3920 * Set ptr to NULL when an error is encountered.
3921 *
3922 * Return MAXLNUM when no Ex address was found.
3923 */
3924 static linenr_T
3925get_address(ptr, skip, to_other_file)
3926 char_u **ptr;
3927 int skip; /* only skip the address, don't use it */
3928 int to_other_file; /* flag: may jump to other file */
3929{
3930 int c;
3931 int i;
3932 long n;
3933 char_u *cmd;
3934 pos_T pos;
3935 pos_T *fp;
3936 linenr_T lnum;
3937
3938 cmd = skipwhite(*ptr);
3939 lnum = MAXLNUM;
3940 do
3941 {
3942 switch (*cmd)
3943 {
3944 case '.': /* '.' - Cursor position */
3945 ++cmd;
3946 lnum = curwin->w_cursor.lnum;
3947 break;
3948
3949 case '$': /* '$' - last line */
3950 ++cmd;
3951 lnum = curbuf->b_ml.ml_line_count;
3952 break;
3953
3954 case '\'': /* ''' - mark */
3955 if (*++cmd == NUL)
3956 {
3957 cmd = NULL;
3958 goto error;
3959 }
3960 if (skip)
3961 ++cmd;
3962 else
3963 {
3964 /* Only accept a mark in another file when it is
3965 * used by itself: ":'M". */
3966 fp = getmark(*cmd, to_other_file && cmd[1] == NUL);
3967 ++cmd;
3968 if (fp == (pos_T *)-1)
3969 /* Jumped to another file. */
3970 lnum = curwin->w_cursor.lnum;
3971 else
3972 {
3973 if (check_mark(fp) == FAIL)
3974 {
3975 cmd = NULL;
3976 goto error;
3977 }
3978 lnum = fp->lnum;
3979 }
3980 }
3981 break;
3982
3983 case '/':
3984 case '?': /* '/' or '?' - search */
3985 c = *cmd++;
3986 if (skip) /* skip "/pat/" */
3987 {
3988 cmd = skip_regexp(cmd, c, (int)p_magic, NULL);
3989 if (*cmd == c)
3990 ++cmd;
3991 }
3992 else
3993 {
3994 pos = curwin->w_cursor; /* save curwin->w_cursor */
3995 /*
3996 * When '/' or '?' follows another address, start
3997 * from there.
3998 */
3999 if (lnum != MAXLNUM)
4000 curwin->w_cursor.lnum = lnum;
4001 /*
4002 * Start a forward search at the end of the line.
4003 * Start a backward search at the start of the line.
4004 * This makes sure we never match in the current
4005 * line, and can match anywhere in the
4006 * next/previous line.
4007 */
4008 if (c == '/')
4009 curwin->w_cursor.col = MAXCOL;
4010 else
4011 curwin->w_cursor.col = 0;
4012 searchcmdlen = 0;
4013 if (!do_search(NULL, c, cmd, 1L,
Bram Moolenaaraad86642008-03-10 20:34:59 +00004014 SEARCH_HIS | SEARCH_MSG, NULL))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004015 {
4016 curwin->w_cursor = pos;
4017 cmd = NULL;
4018 goto error;
4019 }
4020 lnum = curwin->w_cursor.lnum;
4021 curwin->w_cursor = pos;
4022 /* adjust command string pointer */
4023 cmd += searchcmdlen;
4024 }
4025 break;
4026
4027 case '\\': /* "\?", "\/" or "\&", repeat search */
4028 ++cmd;
4029 if (*cmd == '&')
4030 i = RE_SUBST;
4031 else if (*cmd == '?' || *cmd == '/')
4032 i = RE_SEARCH;
4033 else
4034 {
4035 EMSG(_(e_backslash));
4036 cmd = NULL;
4037 goto error;
4038 }
4039
4040 if (!skip)
4041 {
4042 /*
4043 * When search follows another address, start from
4044 * there.
4045 */
4046 if (lnum != MAXLNUM)
4047 pos.lnum = lnum;
4048 else
4049 pos.lnum = curwin->w_cursor.lnum;
4050
4051 /*
4052 * Start the search just like for the above
4053 * do_search().
4054 */
4055 if (*cmd != '?')
4056 pos.col = MAXCOL;
4057 else
4058 pos.col = 0;
4059 if (searchit(curwin, curbuf, &pos,
4060 *cmd == '?' ? BACKWARD : FORWARD,
Bram Moolenaaraad86642008-03-10 20:34:59 +00004061 (char_u *)"", 1L, SEARCH_MSG,
Bram Moolenaar76929292008-01-06 19:07:36 +00004062 i, (linenr_T)0, NULL) != FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004063 lnum = pos.lnum;
4064 else
4065 {
4066 cmd = NULL;
4067 goto error;
4068 }
4069 }
4070 ++cmd;
4071 break;
4072
4073 default:
4074 if (VIM_ISDIGIT(*cmd)) /* absolute line number */
4075 lnum = getdigits(&cmd);
4076 }
4077
4078 for (;;)
4079 {
4080 cmd = skipwhite(cmd);
4081 if (*cmd != '-' && *cmd != '+' && !VIM_ISDIGIT(*cmd))
4082 break;
4083
4084 if (lnum == MAXLNUM)
4085 lnum = curwin->w_cursor.lnum; /* "+1" is same as ".+1" */
4086 if (VIM_ISDIGIT(*cmd))
4087 i = '+'; /* "number" is same as "+number" */
4088 else
4089 i = *cmd++;
4090 if (!VIM_ISDIGIT(*cmd)) /* '+' is '+1', but '+0' is not '+1' */
4091 n = 1;
4092 else
4093 n = getdigits(&cmd);
4094 if (i == '-')
4095 lnum -= n;
4096 else
4097 lnum += n;
4098 }
4099 } while (*cmd == '/' || *cmd == '?');
4100
4101error:
4102 *ptr = cmd;
4103 return lnum;
4104}
4105
4106/*
Bram Moolenaardf177f62005-02-22 08:39:57 +00004107 * Get flags from an Ex command argument.
4108 */
4109 static void
4110get_flags(eap)
4111 exarg_T *eap;
4112{
4113 while (vim_strchr((char_u *)"lp#", *eap->arg) != NULL)
4114 {
4115 if (*eap->arg == 'l')
4116 eap->flags |= EXFLAG_LIST;
4117 else if (*eap->arg == 'p')
4118 eap->flags |= EXFLAG_PRINT;
4119 else
4120 eap->flags |= EXFLAG_NR;
4121 eap->arg = skipwhite(eap->arg + 1);
4122 }
4123}
4124
4125/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00004126 * Function called for command which is Not Implemented. NI!
4127 */
4128 void
4129ex_ni(eap)
4130 exarg_T *eap;
4131{
4132 if (!eap->skip)
4133 eap->errmsg = (char_u *)N_("E319: Sorry, the command is not available in this version");
4134}
4135
Bram Moolenaar7bb75552007-07-16 18:39:49 +00004136#ifdef HAVE_EX_SCRIPT_NI
Bram Moolenaar071d4272004-06-13 20:20:40 +00004137/*
4138 * Function called for script command which is Not Implemented. NI!
4139 * Skips over ":perl <<EOF" constructs.
4140 */
4141 static void
4142ex_script_ni(eap)
4143 exarg_T *eap;
4144{
4145 if (!eap->skip)
4146 ex_ni(eap);
4147 else
4148 vim_free(script_get(eap, eap->arg));
4149}
4150#endif
4151
4152/*
4153 * Check range in Ex command for validity.
4154 * Return NULL when valid, error message when invalid.
4155 */
4156 static char_u *
4157invalid_range(eap)
4158 exarg_T *eap;
4159{
4160 if ( eap->line1 < 0
4161 || eap->line2 < 0
4162 || eap->line1 > eap->line2
4163 || ((eap->argt & RANGE)
4164 && !(eap->argt & NOTADR)
4165 && eap->line2 > curbuf->b_ml.ml_line_count
4166#ifdef FEAT_DIFF
4167 + (eap->cmdidx == CMD_diffget)
4168#endif
4169 ))
4170 return (char_u *)_(e_invrange);
4171 return NULL;
4172}
4173
4174/*
4175 * Correct the range for zero line number, if required.
4176 */
4177 static void
4178correct_range(eap)
4179 exarg_T *eap;
4180{
4181 if (!(eap->argt & ZEROR)) /* zero in range not allowed */
4182 {
4183 if (eap->line1 == 0)
4184 eap->line1 = 1;
4185 if (eap->line2 == 0)
4186 eap->line2 = 1;
4187 }
4188}
4189
Bram Moolenaar748bf032005-02-02 23:04:36 +00004190#ifdef FEAT_QUICKFIX
4191static char_u *skip_grep_pat __ARGS((exarg_T *eap));
4192
4193/*
4194 * For a ":vimgrep" or ":vimgrepadd" command return a pointer past the
4195 * pattern. Otherwise return eap->arg.
4196 */
4197 static char_u *
4198skip_grep_pat(eap)
4199 exarg_T *eap;
4200{
4201 char_u *p = eap->arg;
4202
Bram Moolenaara37420f2006-02-04 22:37:47 +00004203 if (*p != NUL && (eap->cmdidx == CMD_vimgrep || eap->cmdidx == CMD_lvimgrep
4204 || eap->cmdidx == CMD_vimgrepadd
4205 || eap->cmdidx == CMD_lvimgrepadd
4206 || grep_internal(eap->cmdidx)))
Bram Moolenaar748bf032005-02-02 23:04:36 +00004207 {
Bram Moolenaar05159a02005-02-26 23:04:13 +00004208 p = skip_vimgrep_pat(p, NULL, NULL);
Bram Moolenaar748bf032005-02-02 23:04:36 +00004209 if (p == NULL)
4210 p = eap->arg;
Bram Moolenaar748bf032005-02-02 23:04:36 +00004211 }
4212 return p;
4213}
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004214
4215/*
4216 * For the ":make" and ":grep" commands insert the 'makeprg'/'grepprg' option
4217 * in the command line, so that things like % get expanded.
4218 */
4219 static char_u *
4220replace_makeprg(eap, p, cmdlinep)
4221 exarg_T *eap;
4222 char_u *p;
4223 char_u **cmdlinep;
4224{
4225 char_u *new_cmdline;
4226 char_u *program;
4227 char_u *pos;
4228 char_u *ptr;
4229 int len;
4230 int i;
4231
4232 /*
4233 * Don't do it when ":vimgrep" is used for ":grep".
4234 */
Bram Moolenaara37420f2006-02-04 22:37:47 +00004235 if ((eap->cmdidx == CMD_make || eap->cmdidx == CMD_lmake
4236 || eap->cmdidx == CMD_grep || eap->cmdidx == CMD_lgrep
4237 || eap->cmdidx == CMD_grepadd
4238 || eap->cmdidx == CMD_lgrepadd)
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004239 && !grep_internal(eap->cmdidx))
4240 {
Bram Moolenaara37420f2006-02-04 22:37:47 +00004241 if (eap->cmdidx == CMD_grep || eap->cmdidx == CMD_lgrep
4242 || eap->cmdidx == CMD_grepadd || eap->cmdidx == CMD_lgrepadd)
Bram Moolenaard857f0e2005-06-21 22:37:39 +00004243 {
4244 if (*curbuf->b_p_gp == NUL)
4245 program = p_gp;
4246 else
4247 program = curbuf->b_p_gp;
4248 }
4249 else
4250 {
4251 if (*curbuf->b_p_mp == NUL)
4252 program = p_mp;
4253 else
4254 program = curbuf->b_p_mp;
4255 }
4256
4257 p = skipwhite(p);
4258
4259 if ((pos = (char_u *)strstr((char *)program, "$*")) != NULL)
4260 {
4261 /* replace $* by given arguments */
4262 i = 1;
4263 while ((pos = (char_u *)strstr((char *)pos + 2, "$*")) != NULL)
4264 ++i;
4265 len = (int)STRLEN(p);
4266 new_cmdline = alloc((int)(STRLEN(program) + i * (len - 2) + 1));
4267 if (new_cmdline == NULL)
4268 return NULL; /* out of memory */
4269 ptr = new_cmdline;
4270 while ((pos = (char_u *)strstr((char *)program, "$*")) != NULL)
4271 {
4272 i = (int)(pos - program);
4273 STRNCPY(ptr, program, i);
4274 STRCPY(ptr += i, p);
4275 ptr += len;
4276 program = pos + 2;
4277 }
4278 STRCPY(ptr, program);
4279 }
4280 else
4281 {
4282 new_cmdline = alloc((int)(STRLEN(program) + STRLEN(p) + 2));
4283 if (new_cmdline == NULL)
4284 return NULL; /* out of memory */
4285 STRCPY(new_cmdline, program);
4286 STRCAT(new_cmdline, " ");
4287 STRCAT(new_cmdline, p);
4288 }
4289 msg_make(p);
4290
4291 /* 'eap->cmd' is not set here, because it is not used at CMD_make */
4292 vim_free(*cmdlinep);
4293 *cmdlinep = new_cmdline;
4294 p = new_cmdline;
4295 }
4296 return p;
4297}
Bram Moolenaar748bf032005-02-02 23:04:36 +00004298#endif
4299
Bram Moolenaar071d4272004-06-13 20:20:40 +00004300/*
4301 * Expand file name in Ex command argument.
4302 * Return FAIL for failure, OK otherwise.
4303 */
4304 int
4305expand_filename(eap, cmdlinep, errormsgp)
4306 exarg_T *eap;
4307 char_u **cmdlinep;
4308 char_u **errormsgp;
4309{
4310 int has_wildcards; /* need to expand wildcards */
4311 char_u *repl;
4312 int srclen;
4313 char_u *p;
4314 int n;
Bram Moolenaar63b92542007-03-27 14:57:09 +00004315 int escaped;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004316
Bram Moolenaar748bf032005-02-02 23:04:36 +00004317#ifdef FEAT_QUICKFIX
4318 /* Skip a regexp pattern for ":vimgrep[add] pat file..." */
4319 p = skip_grep_pat(eap);
4320#else
4321 p = eap->arg;
4322#endif
4323
Bram Moolenaar071d4272004-06-13 20:20:40 +00004324 /*
4325 * Decide to expand wildcards *before* replacing '%', '#', etc. If
4326 * the file name contains a wildcard it should not cause expanding.
4327 * (it will be expanded anyway if there is a wildcard before replacing).
4328 */
Bram Moolenaar748bf032005-02-02 23:04:36 +00004329 has_wildcards = mch_has_wildcard(p);
4330 while (*p != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004331 {
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004332#ifdef FEAT_EVAL
4333 /* Skip over `=expr`, wildcards in it are not expanded. */
4334 if (p[0] == '`' && p[1] == '=')
4335 {
4336 p += 2;
4337 (void)skip_expr(&p);
4338 if (*p == '`')
4339 ++p;
4340 continue;
4341 }
4342#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00004343 /*
4344 * Quick check if this cannot be the start of a special string.
4345 * Also removes backslash before '%', '#' and '<'.
4346 */
4347 if (vim_strchr((char_u *)"%#<", *p) == NULL)
4348 {
4349 ++p;
4350 continue;
4351 }
4352
4353 /*
4354 * Try to find a match at this position.
4355 */
Bram Moolenaar63b92542007-03-27 14:57:09 +00004356 repl = eval_vars(p, eap->arg, &srclen, &(eap->do_ecmd_lnum),
4357 errormsgp, &escaped);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004358 if (*errormsgp != NULL) /* error detected */
4359 return FAIL;
4360 if (repl == NULL) /* no match found */
4361 {
4362 p += srclen;
4363 continue;
4364 }
4365
Bram Moolenaard8b0cf12004-12-12 11:33:30 +00004366 /* Wildcards won't be expanded below, the replacement is taken
4367 * literally. But do expand "~/file", "~user/file" and "$HOME/file". */
4368 if (vim_strchr(repl, '$') != NULL || vim_strchr(repl, '~') != NULL)
4369 {
4370 char_u *l = repl;
4371
4372 repl = expand_env_save(repl);
4373 vim_free(l);
4374 }
4375
Bram Moolenaar63b92542007-03-27 14:57:09 +00004376 /* Need to escape white space et al. with a backslash.
4377 * Don't do this for:
4378 * - replacement that already has been escaped: "##"
4379 * - shell commands (may have to use quotes instead).
4380 * - non-unix systems when there is a single argument (spaces don't
4381 * separate arguments then).
4382 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004383 if (!eap->usefilter
Bram Moolenaar63b92542007-03-27 14:57:09 +00004384 && !escaped
Bram Moolenaar071d4272004-06-13 20:20:40 +00004385 && eap->cmdidx != CMD_bang
4386 && eap->cmdidx != CMD_make
Bram Moolenaara37420f2006-02-04 22:37:47 +00004387 && eap->cmdidx != CMD_lmake
Bram Moolenaar071d4272004-06-13 20:20:40 +00004388 && eap->cmdidx != CMD_grep
Bram Moolenaara37420f2006-02-04 22:37:47 +00004389 && eap->cmdidx != CMD_lgrep
Bram Moolenaar071d4272004-06-13 20:20:40 +00004390 && eap->cmdidx != CMD_grepadd
Bram Moolenaara37420f2006-02-04 22:37:47 +00004391 && eap->cmdidx != CMD_lgrepadd
Bram Moolenaar071d4272004-06-13 20:20:40 +00004392#ifndef UNIX
4393 && !(eap->argt & NOSPC)
4394#endif
4395 )
4396 {
4397 char_u *l;
4398#ifdef BACKSLASH_IN_FILENAME
4399 /* Don't escape a backslash here, because rem_backslash() doesn't
4400 * remove it later. */
4401 static char_u *nobslash = (char_u *)" \t\"|";
4402# define ESCAPE_CHARS nobslash
4403#else
4404# define ESCAPE_CHARS escape_chars
4405#endif
4406
4407 for (l = repl; *l; ++l)
4408 if (vim_strchr(ESCAPE_CHARS, *l) != NULL)
4409 {
4410 l = vim_strsave_escaped(repl, ESCAPE_CHARS);
4411 if (l != NULL)
4412 {
4413 vim_free(repl);
4414 repl = l;
4415 }
4416 break;
4417 }
4418 }
4419
4420 /* For a shell command a '!' must be escaped. */
4421 if ((eap->usefilter || eap->cmdidx == CMD_bang)
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00004422 && vim_strpbrk(repl, (char_u *)"!&;()<>") != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004423 {
4424 char_u *l;
4425
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00004426 l = vim_strsave_escaped(repl, (char_u *)"!&;()<>");
Bram Moolenaar071d4272004-06-13 20:20:40 +00004427 if (l != NULL)
4428 {
4429 vim_free(repl);
4430 repl = l;
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00004431 /* For a sh-like shell escape "!" another time. */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004432 if (strstr((char *)p_sh, "sh") != NULL)
4433 {
4434 l = vim_strsave_escaped(repl, (char_u *)"!");
4435 if (l != NULL)
4436 {
4437 vim_free(repl);
4438 repl = l;
4439 }
4440 }
4441 }
4442 }
4443
4444 p = repl_cmdline(eap, p, srclen, repl, cmdlinep);
4445 vim_free(repl);
4446 if (p == NULL)
4447 return FAIL;
4448 }
4449
4450 /*
4451 * One file argument: Expand wildcards.
4452 * Don't do this with ":r !command" or ":w !command".
4453 */
4454 if ((eap->argt & NOSPC) && !eap->usefilter)
4455 {
4456 /*
4457 * May do this twice:
4458 * 1. Replace environment variables.
4459 * 2. Replace any other wildcards, remove backslashes.
4460 */
4461 for (n = 1; n <= 2; ++n)
4462 {
4463 if (n == 2)
4464 {
4465#ifdef UNIX
4466 /*
4467 * Only for Unix we check for more than one file name.
4468 * For other systems spaces are considered to be part
4469 * of the file name.
4470 * Only check here if there is no wildcard, otherwise
4471 * ExpandOne() will check for errors. This allows
4472 * ":e `ls ve*.c`" on Unix.
4473 */
4474 if (!has_wildcards)
4475 for (p = eap->arg; *p; ++p)
4476 {
4477 /* skip escaped characters */
4478 if (p[1] && (*p == '\\' || *p == Ctrl_V))
4479 ++p;
4480 else if (vim_iswhite(*p))
4481 {
4482 *errormsgp = (char_u *)_("E172: Only one file name allowed");
4483 return FAIL;
4484 }
4485 }
4486#endif
4487
4488 /*
4489 * Halve the number of backslashes (this is Vi compatible).
4490 * For Unix and OS/2, when wildcards are expanded, this is
4491 * done by ExpandOne() below.
4492 */
4493#if defined(UNIX) || defined(OS2)
4494 if (!has_wildcards)
4495#endif
4496 backslash_halve(eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004497 }
4498
4499 if (has_wildcards)
4500 {
4501 if (n == 1)
4502 {
4503 /*
4504 * First loop: May expand environment variables. This
4505 * can be done much faster with expand_env() than with
4506 * something else (e.g., calling a shell).
4507 * After expanding environment variables, check again
4508 * if there are still wildcards present.
4509 */
4510 if (vim_strchr(eap->arg, '$') != NULL
4511 || vim_strchr(eap->arg, '~') != NULL)
4512 {
Bram Moolenaara1ba8112005-06-28 23:23:32 +00004513 expand_env_esc(eap->arg, NameBuff, MAXPATHL,
Bram Moolenaar9f0545d2007-09-26 20:36:32 +00004514 TRUE, TRUE, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004515 has_wildcards = mch_has_wildcard(NameBuff);
4516 p = NameBuff;
4517 }
4518 else
4519 p = NULL;
4520 }
4521 else /* n == 2 */
4522 {
4523 expand_T xpc;
4524
4525 ExpandInit(&xpc);
4526 xpc.xp_context = EXPAND_FILES;
4527 p = ExpandOne(&xpc, eap->arg, NULL,
4528 WILD_LIST_NOTFOUND|WILD_ADD_SLASH,
4529 WILD_EXPAND_FREE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004530 if (p == NULL)
4531 return FAIL;
4532 }
4533 if (p != NULL)
4534 {
4535 (void)repl_cmdline(eap, eap->arg, (int)STRLEN(eap->arg),
4536 p, cmdlinep);
4537 if (n == 2) /* p came from ExpandOne() */
4538 vim_free(p);
4539 }
4540 }
4541 }
4542 }
4543 return OK;
4544}
4545
4546/*
4547 * Replace part of the command line, keeping eap->cmd, eap->arg and
4548 * eap->nextcmd correct.
4549 * "src" points to the part that is to be replaced, of length "srclen".
4550 * "repl" is the replacement string.
4551 * Returns a pointer to the character after the replaced string.
4552 * Returns NULL for failure.
4553 */
4554 static char_u *
4555repl_cmdline(eap, src, srclen, repl, cmdlinep)
4556 exarg_T *eap;
4557 char_u *src;
4558 int srclen;
4559 char_u *repl;
4560 char_u **cmdlinep;
4561{
4562 int len;
4563 int i;
4564 char_u *new_cmdline;
4565
4566 /*
4567 * The new command line is build in new_cmdline[].
4568 * First allocate it.
4569 * Careful: a "+cmd" argument may have been NUL terminated.
4570 */
4571 len = (int)STRLEN(repl);
4572 i = (int)(src - *cmdlinep) + (int)STRLEN(src + srclen) + len + 3;
Bram Moolenaare1438bb2006-03-01 22:01:55 +00004573 if (eap->nextcmd != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004574 i += (int)STRLEN(eap->nextcmd);/* add space for next command */
4575 if ((new_cmdline = alloc((unsigned)i)) == NULL)
4576 return NULL; /* out of memory! */
4577
4578 /*
4579 * Copy the stuff before the expanded part.
4580 * Copy the expanded stuff.
4581 * Copy what came after the expanded part.
4582 * Copy the next commands, if there are any.
4583 */
4584 i = (int)(src - *cmdlinep); /* length of part before match */
4585 mch_memmove(new_cmdline, *cmdlinep, (size_t)i);
Bram Moolenaara3ffd9c2005-07-21 21:03:15 +00004586
Bram Moolenaar071d4272004-06-13 20:20:40 +00004587 mch_memmove(new_cmdline + i, repl, (size_t)len);
4588 i += len; /* remember the end of the string */
4589 STRCPY(new_cmdline + i, src + srclen);
4590 src = new_cmdline + i; /* remember where to continue */
4591
Bram Moolenaare1438bb2006-03-01 22:01:55 +00004592 if (eap->nextcmd != NULL) /* append next command */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004593 {
4594 i = (int)STRLEN(new_cmdline) + 1;
4595 STRCPY(new_cmdline + i, eap->nextcmd);
4596 eap->nextcmd = new_cmdline + i;
4597 }
4598 eap->cmd = new_cmdline + (eap->cmd - *cmdlinep);
4599 eap->arg = new_cmdline + (eap->arg - *cmdlinep);
4600 if (eap->do_ecmd_cmd != NULL && eap->do_ecmd_cmd != dollar_command)
4601 eap->do_ecmd_cmd = new_cmdline + (eap->do_ecmd_cmd - *cmdlinep);
4602 vim_free(*cmdlinep);
4603 *cmdlinep = new_cmdline;
4604
4605 return src;
4606}
4607
4608/*
4609 * Check for '|' to separate commands and '"' to start comments.
4610 */
4611 void
4612separate_nextcmd(eap)
4613 exarg_T *eap;
4614{
4615 char_u *p;
4616
Bram Moolenaar86b68352004-12-27 21:59:20 +00004617#ifdef FEAT_QUICKFIX
Bram Moolenaar748bf032005-02-02 23:04:36 +00004618 p = skip_grep_pat(eap);
4619#else
4620 p = eap->arg;
Bram Moolenaar86b68352004-12-27 21:59:20 +00004621#endif
4622
4623 for ( ; *p; mb_ptr_adv(p))
Bram Moolenaar071d4272004-06-13 20:20:40 +00004624 {
4625 if (*p == Ctrl_V)
4626 {
4627 if (eap->argt & (USECTRLV | XFILE))
4628 ++p; /* skip CTRL-V and next char */
4629 else
Bram Moolenaarb0db5692007-08-14 20:54:49 +00004630 /* remove CTRL-V and skip next char */
Bram Moolenaara7241f52008-06-24 20:39:31 +00004631 STRMOVE(p, p + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004632 if (*p == NUL) /* stop at NUL after CTRL-V */
4633 break;
4634 }
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004635
4636#ifdef FEAT_EVAL
4637 /* Skip over `=expr` when wildcards are expanded. */
Bram Moolenaardf177f62005-02-22 08:39:57 +00004638 else if (p[0] == '`' && p[1] == '=' && (eap->argt & XFILE))
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004639 {
4640 p += 2;
4641 (void)skip_expr(&p);
Bram Moolenaar69a7cb42004-06-20 12:51:53 +00004642 }
4643#endif
4644
Bram Moolenaar071d4272004-06-13 20:20:40 +00004645 /* Check for '"': start of comment or '|': next command */
4646 /* :@" and :*" do not start a comment!
4647 * :redir @" doesn't either. */
4648 else if ((*p == '"' && !(eap->argt & NOTRLCOM)
4649 && ((eap->cmdidx != CMD_at && eap->cmdidx != CMD_star)
4650 || p != eap->arg)
4651 && (eap->cmdidx != CMD_redir
4652 || p != eap->arg + 1 || p[-1] != '@'))
4653 || *p == '|' || *p == '\n')
4654 {
4655 /*
4656 * We remove the '\' before the '|', unless USECTRLV is used
4657 * AND 'b' is present in 'cpoptions'.
4658 */
4659 if ((vim_strchr(p_cpo, CPO_BAR) == NULL
4660 || !(eap->argt & USECTRLV)) && *(p - 1) == '\\')
4661 {
Bram Moolenaara7241f52008-06-24 20:39:31 +00004662 STRMOVE(p - 1, p); /* remove the '\' */
Bram Moolenaar071d4272004-06-13 20:20:40 +00004663 --p;
4664 }
4665 else
4666 {
4667 eap->nextcmd = check_nextcmd(p);
4668 *p = NUL;
4669 break;
4670 }
4671 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004672 }
Bram Moolenaar86b68352004-12-27 21:59:20 +00004673
Bram Moolenaar071d4272004-06-13 20:20:40 +00004674 if (!(eap->argt & NOTRLCOM)) /* remove trailing spaces */
4675 del_trailing_spaces(eap->arg);
4676}
4677
4678/*
4679 * get + command from ex argument
4680 */
4681 static char_u *
4682getargcmd(argp)
4683 char_u **argp;
4684{
4685 char_u *arg = *argp;
4686 char_u *command = NULL;
4687
4688 if (*arg == '+') /* +[command] */
4689 {
4690 ++arg;
4691 if (vim_isspace(*arg))
4692 command = dollar_command;
4693 else
4694 {
4695 command = arg;
4696 arg = skip_cmd_arg(command, TRUE);
4697 if (*arg != NUL)
4698 *arg++ = NUL; /* terminate command with NUL */
4699 }
4700
4701 arg = skipwhite(arg); /* skip over spaces */
4702 *argp = arg;
4703 }
4704 return command;
4705}
4706
4707/*
4708 * Find end of "+command" argument. Skip over "\ " and "\\".
4709 */
4710 static char_u *
4711skip_cmd_arg(p, rembs)
4712 char_u *p;
4713 int rembs; /* TRUE to halve the number of backslashes */
4714{
4715 while (*p && !vim_isspace(*p))
4716 {
4717 if (*p == '\\' && p[1] != NUL)
4718 {
4719 if (rembs)
Bram Moolenaara7241f52008-06-24 20:39:31 +00004720 STRMOVE(p, p + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004721 else
4722 ++p;
4723 }
Bram Moolenaar1cd871b2004-12-19 22:46:22 +00004724 mb_ptr_adv(p);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004725 }
4726 return p;
4727}
4728
4729/*
4730 * Get "++opt=arg" argument.
4731 * Return FAIL or OK.
4732 */
4733 static int
4734getargopt(eap)
4735 exarg_T *eap;
4736{
4737 char_u *arg = eap->arg + 2;
4738 int *pp = NULL;
4739#ifdef FEAT_MBYTE
Bram Moolenaar34b4daf2010-05-16 13:26:25 +02004740 int bad_char_idx;
Bram Moolenaar071d4272004-06-13 20:20:40 +00004741 char_u *p;
4742#endif
4743
4744 /* ":edit ++[no]bin[ary] file" */
4745 if (STRNCMP(arg, "bin", 3) == 0 || STRNCMP(arg, "nobin", 5) == 0)
4746 {
4747 if (*arg == 'n')
4748 {
4749 arg += 2;
4750 eap->force_bin = FORCE_NOBIN;
4751 }
4752 else
4753 eap->force_bin = FORCE_BIN;
4754 if (!checkforcmd(&arg, "binary", 3))
4755 return FAIL;
4756 eap->arg = skipwhite(arg);
4757 return OK;
4758 }
4759
Bram Moolenaar910f66f2006-04-05 20:41:53 +00004760 /* ":read ++edit file" */
4761 if (STRNCMP(arg, "edit", 4) == 0)
4762 {
4763 eap->read_edit = TRUE;
4764 eap->arg = skipwhite(arg + 4);
4765 return OK;
4766 }
4767
Bram Moolenaar071d4272004-06-13 20:20:40 +00004768 if (STRNCMP(arg, "ff", 2) == 0)
4769 {
4770 arg += 2;
4771 pp = &eap->force_ff;
4772 }
4773 else if (STRNCMP(arg, "fileformat", 10) == 0)
4774 {
4775 arg += 10;
4776 pp = &eap->force_ff;
4777 }
4778#ifdef FEAT_MBYTE
4779 else if (STRNCMP(arg, "enc", 3) == 0)
4780 {
4781 arg += 3;
4782 pp = &eap->force_enc;
4783 }
4784 else if (STRNCMP(arg, "encoding", 8) == 0)
4785 {
4786 arg += 8;
4787 pp = &eap->force_enc;
4788 }
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00004789 else if (STRNCMP(arg, "bad", 3) == 0)
4790 {
4791 arg += 3;
Bram Moolenaar34b4daf2010-05-16 13:26:25 +02004792 pp = &bad_char_idx;
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00004793 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004794#endif
4795
4796 if (pp == NULL || *arg != '=')
4797 return FAIL;
4798
4799 ++arg;
4800 *pp = (int)(arg - eap->cmd);
4801 arg = skip_cmd_arg(arg, FALSE);
4802 eap->arg = skipwhite(arg);
4803 *arg = NUL;
4804
4805#ifdef FEAT_MBYTE
4806 if (pp == &eap->force_ff)
4807 {
4808#endif
4809 if (check_ff_value(eap->cmd + eap->force_ff) == FAIL)
4810 return FAIL;
4811#ifdef FEAT_MBYTE
4812 }
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00004813 else if (pp == &eap->force_enc)
Bram Moolenaar071d4272004-06-13 20:20:40 +00004814 {
4815 /* Make 'fileencoding' lower case. */
4816 for (p = eap->cmd + eap->force_enc; *p != NUL; ++p)
4817 *p = TOLOWER_ASC(*p);
4818 }
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00004819 else
4820 {
4821 /* Check ++bad= argument. Must be a single-byte character, "keep" or
4822 * "drop". */
Bram Moolenaar34b4daf2010-05-16 13:26:25 +02004823 p = eap->cmd + bad_char_idx;
Bram Moolenaarb0bf8582005-12-13 20:02:15 +00004824 if (STRICMP(p, "keep") == 0)
4825 eap->bad_char = BAD_KEEP;
4826 else if (STRICMP(p, "drop") == 0)
4827 eap->bad_char = BAD_DROP;
4828 else if (MB_BYTE2LEN(*p) == 1 && p[1] == NUL)
4829 eap->bad_char = *p;
4830 else
4831 return FAIL;
4832 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00004833#endif
4834
4835 return OK;
4836}
4837
4838/*
4839 * ":abbreviate" and friends.
4840 */
4841 static void
4842ex_abbreviate(eap)
4843 exarg_T *eap;
4844{
4845 do_exmap(eap, TRUE); /* almost the same as mapping */
4846}
4847
4848/*
4849 * ":map" and friends.
4850 */
4851 static void
4852ex_map(eap)
4853 exarg_T *eap;
4854{
4855 /*
4856 * If we are sourcing .exrc or .vimrc in current directory we
4857 * print the mappings for security reasons.
4858 */
4859 if (secure)
4860 {
4861 secure = 2;
4862 msg_outtrans(eap->cmd);
4863 msg_putchar('\n');
4864 }
4865 do_exmap(eap, FALSE);
4866}
4867
4868/*
4869 * ":unmap" and friends.
4870 */
4871 static void
4872ex_unmap(eap)
4873 exarg_T *eap;
4874{
4875 do_exmap(eap, FALSE);
4876}
4877
4878/*
4879 * ":mapclear" and friends.
4880 */
4881 static void
4882ex_mapclear(eap)
4883 exarg_T *eap;
4884{
4885 map_clear(eap->cmd, eap->arg, eap->forceit, FALSE);
4886}
4887
4888/*
4889 * ":abclear" and friends.
4890 */
4891 static void
4892ex_abclear(eap)
4893 exarg_T *eap;
4894{
4895 map_clear(eap->cmd, eap->arg, TRUE, TRUE);
4896}
4897
4898#ifdef FEAT_AUTOCMD
4899 static void
4900ex_autocmd(eap)
4901 exarg_T *eap;
4902{
4903 /*
4904 * Disallow auto commands from .exrc and .vimrc in current
4905 * directory for security reasons.
4906 */
4907 if (secure)
4908 {
4909 secure = 2;
4910 eap->errmsg = e_curdir;
4911 }
4912 else if (eap->cmdidx == CMD_autocmd)
4913 do_autocmd(eap->arg, eap->forceit);
4914 else
4915 do_augroup(eap->arg, eap->forceit);
4916}
4917
4918/*
4919 * ":doautocmd": Apply the automatic commands to the current buffer.
4920 */
4921 static void
4922ex_doautocmd(eap)
4923 exarg_T *eap;
4924{
4925 (void)do_doautocmd(eap->arg, TRUE);
Bram Moolenaara3227e22006-03-08 21:32:40 +00004926 do_modelines(0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00004927}
4928#endif
4929
4930#ifdef FEAT_LISTCMDS
4931/*
4932 * :[N]bunload[!] [N] [bufname] unload buffer
4933 * :[N]bdelete[!] [N] [bufname] delete buffer from buffer list
4934 * :[N]bwipeout[!] [N] [bufname] delete buffer really
4935 */
4936 static void
4937ex_bunload(eap)
4938 exarg_T *eap;
4939{
4940 eap->errmsg = do_bufdel(
4941 eap->cmdidx == CMD_bdelete ? DOBUF_DEL
4942 : eap->cmdidx == CMD_bwipeout ? DOBUF_WIPE
4943 : DOBUF_UNLOAD, eap->arg,
4944 eap->addr_count, (int)eap->line1, (int)eap->line2, eap->forceit);
4945}
4946
4947/*
4948 * :[N]buffer [N] to buffer N
4949 * :[N]sbuffer [N] to buffer N
4950 */
4951 static void
4952ex_buffer(eap)
4953 exarg_T *eap;
4954{
4955 if (*eap->arg)
4956 eap->errmsg = e_trailing;
4957 else
4958 {
4959 if (eap->addr_count == 0) /* default is current buffer */
4960 goto_buffer(eap, DOBUF_CURRENT, FORWARD, 0);
4961 else
4962 goto_buffer(eap, DOBUF_FIRST, FORWARD, (int)eap->line2);
4963 }
4964}
4965
4966/*
4967 * :[N]bmodified [N] to next mod. buffer
4968 * :[N]sbmodified [N] to next mod. buffer
4969 */
4970 static void
4971ex_bmodified(eap)
4972 exarg_T *eap;
4973{
4974 goto_buffer(eap, DOBUF_MOD, FORWARD, (int)eap->line2);
4975}
4976
4977/*
4978 * :[N]bnext [N] to next buffer
4979 * :[N]sbnext [N] split and to next buffer
4980 */
4981 static void
4982ex_bnext(eap)
4983 exarg_T *eap;
4984{
4985 goto_buffer(eap, DOBUF_CURRENT, FORWARD, (int)eap->line2);
4986}
4987
4988/*
4989 * :[N]bNext [N] to previous buffer
4990 * :[N]bprevious [N] to previous buffer
4991 * :[N]sbNext [N] split and to previous buffer
4992 * :[N]sbprevious [N] split and to previous buffer
4993 */
4994 static void
4995ex_bprevious(eap)
4996 exarg_T *eap;
4997{
4998 goto_buffer(eap, DOBUF_CURRENT, BACKWARD, (int)eap->line2);
4999}
5000
5001/*
5002 * :brewind to first buffer
5003 * :bfirst to first buffer
5004 * :sbrewind split and to first buffer
5005 * :sbfirst split and to first buffer
5006 */
5007 static void
5008ex_brewind(eap)
5009 exarg_T *eap;
5010{
5011 goto_buffer(eap, DOBUF_FIRST, FORWARD, 0);
5012}
5013
5014/*
5015 * :blast to last buffer
5016 * :sblast split and to last buffer
5017 */
5018 static void
5019ex_blast(eap)
5020 exarg_T *eap;
5021{
5022 goto_buffer(eap, DOBUF_LAST, BACKWARD, 0);
5023}
5024#endif
5025
5026 int
5027ends_excmd(c)
5028 int c;
5029{
5030 return (c == NUL || c == '|' || c == '"' || c == '\n');
5031}
5032
5033#if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA) || defined(FEAT_EVAL) \
5034 || defined(PROTO)
5035/*
5036 * Return the next command, after the first '|' or '\n'.
5037 * Return NULL if not found.
5038 */
5039 char_u *
5040find_nextcmd(p)
5041 char_u *p;
5042{
5043 while (*p != '|' && *p != '\n')
5044 {
5045 if (*p == NUL)
5046 return NULL;
5047 ++p;
5048 }
5049 return (p + 1);
5050}
5051#endif
5052
5053/*
5054 * Check if *p is a separator between Ex commands.
5055 * Return NULL if it isn't, (p + 1) if it is.
5056 */
5057 char_u *
5058check_nextcmd(p)
5059 char_u *p;
5060{
5061 p = skipwhite(p);
5062 if (*p == '|' || *p == '\n')
5063 return (p + 1);
5064 else
5065 return NULL;
5066}
5067
5068/*
5069 * - if there are more files to edit
5070 * - and this is the last window
5071 * - and forceit not used
5072 * - and not repeated twice on a row
5073 * return FAIL and give error message if 'message' TRUE
5074 * return OK otherwise
5075 */
5076 static int
5077check_more(message, forceit)
5078 int message; /* when FALSE check only, no messages */
5079 int forceit;
5080{
5081 int n = ARGCOUNT - curwin->w_arg_idx - 1;
5082
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00005083 if (!forceit && only_one_window()
5084 && ARGCOUNT > 1 && !arg_had_last && n >= 0 && quitmore == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005085 {
5086 if (message)
5087 {
5088#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
5089 if ((p_confirm || cmdmod.confirm) && curbuf->b_fname != NULL)
5090 {
5091 char_u buff[IOSIZE];
5092
5093 if (n == 1)
5094 STRCPY(buff, _("1 more file to edit. Quit anyway?"));
5095 else
Bram Moolenaar9c13b352005-05-19 20:53:52 +00005096 vim_snprintf((char *)buff, IOSIZE,
Bram Moolenaar071d4272004-06-13 20:20:40 +00005097 _("%d more files to edit. Quit anyway?"), n);
5098 if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 1) == VIM_YES)
5099 return OK;
5100 return FAIL;
5101 }
5102#endif
5103 if (n == 1)
5104 EMSG(_("E173: 1 more file to edit"));
5105 else
5106 EMSGN(_("E173: %ld more files to edit"), n);
5107 quitmore = 2; /* next try to quit is allowed */
5108 }
5109 return FAIL;
5110 }
5111 return OK;
5112}
5113
5114#ifdef FEAT_CMDL_COMPL
5115/*
5116 * Function given to ExpandGeneric() to obtain the list of command names.
5117 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005118 char_u *
5119get_command_name(xp, idx)
Bram Moolenaar78a15312009-05-15 19:33:18 +00005120 expand_T *xp UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005121 int idx;
5122{
5123 if (idx >= (int)CMD_SIZE)
5124# ifdef FEAT_USR_CMDS
5125 return get_user_command_name(idx);
5126# else
5127 return NULL;
5128# endif
5129 return cmdnames[idx].cmd_name;
5130}
5131#endif
5132
5133#if defined(FEAT_USR_CMDS) || defined(PROTO)
5134static int uc_add_command __ARGS((char_u *name, size_t name_len, char_u *rep, long argt, long def, int flags, int compl, char_u *compl_arg, int force));
5135static void uc_list __ARGS((char_u *name, size_t name_len));
5136static int uc_scan_attr __ARGS((char_u *attr, size_t len, long *argt, long *def, int *flags, int *compl, char_u **compl_arg));
5137static char_u *uc_split_args __ARGS((char_u *arg, size_t *lenp));
5138static size_t uc_check_code __ARGS((char_u *code, size_t len, char_u *buf, ucmd_T *cmd, exarg_T *eap, char_u **split_buf, size_t *split_len));
5139
5140 static int
5141uc_add_command(name, name_len, rep, argt, def, flags, compl, compl_arg, force)
5142 char_u *name;
5143 size_t name_len;
5144 char_u *rep;
5145 long argt;
5146 long def;
5147 int flags;
5148 int compl;
5149 char_u *compl_arg;
5150 int force;
5151{
5152 ucmd_T *cmd = NULL;
5153 char_u *p;
5154 int i;
5155 int cmp = 1;
5156 char_u *rep_buf = NULL;
5157 garray_T *gap;
5158
Bram Moolenaar9c102382006-05-03 21:26:49 +00005159 replace_termcodes(rep, &rep_buf, FALSE, FALSE, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005160 if (rep_buf == NULL)
5161 {
5162 /* Can't replace termcodes - try using the string as is */
5163 rep_buf = vim_strsave(rep);
5164
5165 /* Give up if out of memory */
5166 if (rep_buf == NULL)
5167 return FAIL;
5168 }
5169
5170 /* get address of growarray: global or in curbuf */
5171 if (flags & UC_BUFFER)
5172 {
5173 gap = &curbuf->b_ucmds;
5174 if (gap->ga_itemsize == 0)
5175 ga_init2(gap, (int)sizeof(ucmd_T), 4);
5176 }
5177 else
5178 gap = &ucmds;
5179
5180 /* Search for the command in the already defined commands. */
5181 for (i = 0; i < gap->ga_len; ++i)
5182 {
5183 size_t len;
5184
5185 cmd = USER_CMD_GA(gap, i);
5186 len = STRLEN(cmd->uc_name);
5187 cmp = STRNCMP(name, cmd->uc_name, name_len);
5188 if (cmp == 0)
5189 {
5190 if (name_len < len)
5191 cmp = -1;
5192 else if (name_len > len)
5193 cmp = 1;
5194 }
5195
5196 if (cmp == 0)
5197 {
5198 if (!force)
5199 {
5200 EMSG(_("E174: Command already exists: add ! to replace it"));
5201 goto fail;
5202 }
5203
5204 vim_free(cmd->uc_rep);
Bram Moolenaar60f39ae2009-03-11 14:10:38 +00005205 cmd->uc_rep = NULL;
5206#if defined(FEAT_EVAL) && defined(FEAT_CMDL_COMPL)
5207 vim_free(cmd->uc_compl_arg);
5208 cmd->uc_compl_arg = NULL;
5209#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005210 break;
5211 }
5212
5213 /* Stop as soon as we pass the name to add */
5214 if (cmp < 0)
5215 break;
5216 }
5217
5218 /* Extend the array unless we're replacing an existing command */
5219 if (cmp != 0)
5220 {
5221 if (ga_grow(gap, 1) != OK)
5222 goto fail;
5223 if ((p = vim_strnsave(name, (int)name_len)) == NULL)
5224 goto fail;
5225
5226 cmd = USER_CMD_GA(gap, i);
5227 mch_memmove(cmd + 1, cmd, (gap->ga_len - i) * sizeof(ucmd_T));
5228
5229 ++gap->ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005230
5231 cmd->uc_name = p;
5232 }
5233
5234 cmd->uc_rep = rep_buf;
5235 cmd->uc_argt = argt;
5236 cmd->uc_def = def;
5237 cmd->uc_compl = compl;
5238#ifdef FEAT_EVAL
5239 cmd->uc_scriptID = current_SID;
5240# ifdef FEAT_CMDL_COMPL
5241 cmd->uc_compl_arg = compl_arg;
5242# endif
5243#endif
5244
5245 return OK;
5246
5247fail:
5248 vim_free(rep_buf);
5249#if defined(FEAT_EVAL) && defined(FEAT_CMDL_COMPL)
5250 vim_free(compl_arg);
5251#endif
5252 return FAIL;
5253}
5254
5255/*
5256 * List of names for completion for ":command" with the EXPAND_ flag.
5257 * Must be alphabetical for completion.
5258 */
5259static struct
5260{
5261 int expand;
5262 char *name;
5263} command_complete[] =
5264{
5265 {EXPAND_AUGROUP, "augroup"},
5266 {EXPAND_BUFFERS, "buffer"},
5267 {EXPAND_COMMANDS, "command"},
Bram Moolenaarf4580d82009-03-18 11:52:53 +00005268#if defined(FEAT_CSCOPE)
5269 {EXPAND_CSCOPE, "cscope"},
5270#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005271#if defined(FEAT_EVAL) && defined(FEAT_CMDL_COMPL)
5272 {EXPAND_USER_DEFINED, "custom"},
Bram Moolenaara466c992005-07-09 21:03:22 +00005273 {EXPAND_USER_LIST, "customlist"},
Bram Moolenaar071d4272004-06-13 20:20:40 +00005274#endif
5275 {EXPAND_DIRECTORIES, "dir"},
5276 {EXPAND_ENV_VARS, "environment"},
5277 {EXPAND_EVENTS, "event"},
5278 {EXPAND_EXPRESSION, "expression"},
5279 {EXPAND_FILES, "file"},
5280 {EXPAND_FUNCTIONS, "function"},
5281 {EXPAND_HELP, "help"},
5282 {EXPAND_HIGHLIGHT, "highlight"},
5283 {EXPAND_MAPPINGS, "mapping"},
5284 {EXPAND_MENUS, "menu"},
5285 {EXPAND_SETTINGS, "option"},
Bram Moolenaar362e1a32006-03-06 23:29:24 +00005286 {EXPAND_SHELLCMD, "shellcmd"},
Bram Moolenaar3c65e312009-04-29 16:47:23 +00005287#if defined(FEAT_SIGNS)
5288 {EXPAND_SIGN, "sign"},
5289#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005290 {EXPAND_TAGS, "tag"},
5291 {EXPAND_TAGS_LISTFILES, "tag_listfiles"},
5292 {EXPAND_USER_VARS, "var"},
5293 {0, NULL}
5294};
5295
5296 static void
5297uc_list(name, name_len)
5298 char_u *name;
5299 size_t name_len;
5300{
5301 int i, j;
5302 int found = FALSE;
5303 ucmd_T *cmd;
5304 int len;
5305 long a;
5306 garray_T *gap;
5307
5308 gap = &curbuf->b_ucmds;
5309 for (;;)
5310 {
5311 for (i = 0; i < gap->ga_len; ++i)
5312 {
5313 cmd = USER_CMD_GA(gap, i);
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00005314 a = (long)cmd->uc_argt;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005315
5316 /* Skip commands which don't match the requested prefix */
5317 if (STRNCMP(name, cmd->uc_name, name_len) != 0)
5318 continue;
5319
5320 /* Put out the title first time */
5321 if (!found)
5322 MSG_PUTS_TITLE(_("\n Name Args Range Complete Definition"));
5323 found = TRUE;
5324 msg_putchar('\n');
5325 if (got_int)
5326 break;
5327
5328 /* Special cases */
5329 msg_putchar(a & BANG ? '!' : ' ');
5330 msg_putchar(a & REGSTR ? '"' : ' ');
5331 msg_putchar(gap != &ucmds ? 'b' : ' ');
5332 msg_putchar(' ');
5333
5334 msg_outtrans_attr(cmd->uc_name, hl_attr(HLF_D));
5335 len = (int)STRLEN(cmd->uc_name) + 4;
5336
5337 do {
5338 msg_putchar(' ');
5339 ++len;
5340 } while (len < 16);
5341
5342 len = 0;
5343
5344 /* Arguments */
5345 switch ((int)(a & (EXTRA|NOSPC|NEEDARG)))
5346 {
5347 case 0: IObuff[len++] = '0'; break;
5348 case (EXTRA): IObuff[len++] = '*'; break;
5349 case (EXTRA|NOSPC): IObuff[len++] = '?'; break;
5350 case (EXTRA|NEEDARG): IObuff[len++] = '+'; break;
5351 case (EXTRA|NOSPC|NEEDARG): IObuff[len++] = '1'; break;
5352 }
5353
5354 do {
5355 IObuff[len++] = ' ';
5356 } while (len < 5);
5357
5358 /* Range */
5359 if (a & (RANGE|COUNT))
5360 {
5361 if (a & COUNT)
5362 {
5363 /* -count=N */
5364 sprintf((char *)IObuff + len, "%ldc", cmd->uc_def);
5365 len += (int)STRLEN(IObuff + len);
5366 }
5367 else if (a & DFLALL)
5368 IObuff[len++] = '%';
5369 else if (cmd->uc_def >= 0)
5370 {
5371 /* -range=N */
5372 sprintf((char *)IObuff + len, "%ld", cmd->uc_def);
5373 len += (int)STRLEN(IObuff + len);
5374 }
5375 else
5376 IObuff[len++] = '.';
5377 }
5378
5379 do {
5380 IObuff[len++] = ' ';
5381 } while (len < 11);
5382
5383 /* Completion */
5384 for (j = 0; command_complete[j].expand != 0; ++j)
5385 if (command_complete[j].expand == cmd->uc_compl)
5386 {
5387 STRCPY(IObuff + len, command_complete[j].name);
5388 len += (int)STRLEN(IObuff + len);
5389 break;
5390 }
5391
5392 do {
5393 IObuff[len++] = ' ';
5394 } while (len < 21);
5395
5396 IObuff[len] = '\0';
5397 msg_outtrans(IObuff);
5398
5399 msg_outtrans_special(cmd->uc_rep, FALSE);
Bram Moolenaar5b8d8fd2005-08-16 23:01:50 +00005400#ifdef FEAT_EVAL
5401 if (p_verbose > 0)
5402 last_set_msg(cmd->uc_scriptID);
5403#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00005404 out_flush();
5405 ui_breakcheck();
5406 if (got_int)
5407 break;
5408 }
5409 if (gap == &ucmds || i < gap->ga_len)
5410 break;
5411 gap = &ucmds;
5412 }
5413
5414 if (!found)
5415 MSG(_("No user-defined commands found"));
5416}
5417
5418 static char_u *
5419uc_fun_cmd()
5420{
5421 static char_u fcmd[] = {0x84, 0xaf, 0x60, 0xb9, 0xaf, 0xb5, 0x60, 0xa4,
5422 0xa5, 0xad, 0xa1, 0xae, 0xa4, 0x60, 0xa1, 0x60,
5423 0xb3, 0xa8, 0xb2, 0xb5, 0xa2, 0xa2, 0xa5, 0xb2,
5424 0xb9, 0x7f, 0};
5425 int i;
5426
5427 for (i = 0; fcmd[i]; ++i)
5428 IObuff[i] = fcmd[i] - 0x40;
5429 IObuff[i] = 0;
5430 return IObuff;
5431}
5432
5433 static int
5434uc_scan_attr(attr, len, argt, def, flags, compl, compl_arg)
5435 char_u *attr;
5436 size_t len;
5437 long *argt;
5438 long *def;
5439 int *flags;
5440 int *compl;
5441 char_u **compl_arg;
5442{
5443 char_u *p;
5444
5445 if (len == 0)
5446 {
5447 EMSG(_("E175: No attribute specified"));
5448 return FAIL;
5449 }
5450
5451 /* First, try the simple attributes (no arguments) */
5452 if (STRNICMP(attr, "bang", len) == 0)
5453 *argt |= BANG;
5454 else if (STRNICMP(attr, "buffer", len) == 0)
5455 *flags |= UC_BUFFER;
5456 else if (STRNICMP(attr, "register", len) == 0)
5457 *argt |= REGSTR;
5458 else if (STRNICMP(attr, "bar", len) == 0)
5459 *argt |= TRLBAR;
5460 else
5461 {
5462 int i;
5463 char_u *val = NULL;
5464 size_t vallen = 0;
5465 size_t attrlen = len;
5466
5467 /* Look for the attribute name - which is the part before any '=' */
5468 for (i = 0; i < (int)len; ++i)
5469 {
5470 if (attr[i] == '=')
5471 {
5472 val = &attr[i + 1];
5473 vallen = len - i - 1;
5474 attrlen = i;
5475 break;
5476 }
5477 }
5478
5479 if (STRNICMP(attr, "nargs", attrlen) == 0)
5480 {
5481 if (vallen == 1)
5482 {
5483 if (*val == '0')
5484 /* Do nothing - this is the default */;
5485 else if (*val == '1')
5486 *argt |= (EXTRA | NOSPC | NEEDARG);
5487 else if (*val == '*')
5488 *argt |= EXTRA;
5489 else if (*val == '?')
5490 *argt |= (EXTRA | NOSPC);
5491 else if (*val == '+')
5492 *argt |= (EXTRA | NEEDARG);
5493 else
5494 goto wrong_nargs;
5495 }
5496 else
5497 {
5498wrong_nargs:
5499 EMSG(_("E176: Invalid number of arguments"));
5500 return FAIL;
5501 }
5502 }
5503 else if (STRNICMP(attr, "range", attrlen) == 0)
5504 {
5505 *argt |= RANGE;
5506 if (vallen == 1 && *val == '%')
5507 *argt |= DFLALL;
5508 else if (val != NULL)
5509 {
5510 p = val;
5511 if (*def >= 0)
5512 {
5513two_count:
5514 EMSG(_("E177: Count cannot be specified twice"));
5515 return FAIL;
5516 }
5517
5518 *def = getdigits(&p);
5519 *argt |= (ZEROR | NOTADR);
5520
5521 if (p != val + vallen || vallen == 0)
5522 {
5523invalid_count:
5524 EMSG(_("E178: Invalid default value for count"));
5525 return FAIL;
5526 }
5527 }
5528 }
5529 else if (STRNICMP(attr, "count", attrlen) == 0)
5530 {
Bram Moolenaar32e7b2d2005-02-27 22:36:47 +00005531 *argt |= (COUNT | ZEROR | RANGE | NOTADR);
Bram Moolenaar071d4272004-06-13 20:20:40 +00005532
5533 if (val != NULL)
5534 {
5535 p = val;
5536 if (*def >= 0)
5537 goto two_count;
5538
5539 *def = getdigits(&p);
5540
5541 if (p != val + vallen)
5542 goto invalid_count;
5543 }
5544
5545 if (*def < 0)
5546 *def = 0;
5547 }
5548 else if (STRNICMP(attr, "complete", attrlen) == 0)
5549 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00005550 if (val == NULL)
5551 {
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00005552 EMSG(_("E179: argument required for -complete"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00005553 return FAIL;
5554 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00005555
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00005556 if (parse_compl_arg(val, (int)vallen, compl, argt, compl_arg)
5557 == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005558 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005559 }
5560 else
5561 {
5562 char_u ch = attr[len];
5563 attr[len] = '\0';
5564 EMSG2(_("E181: Invalid attribute: %s"), attr);
5565 attr[len] = ch;
5566 return FAIL;
5567 }
5568 }
5569
5570 return OK;
5571}
5572
Bram Moolenaara850a712009-01-28 14:42:59 +00005573/*
5574 * ":command ..."
5575 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005576 static void
5577ex_command(eap)
5578 exarg_T *eap;
5579{
5580 char_u *name;
5581 char_u *end;
5582 char_u *p;
5583 long argt = 0;
5584 long def = -1;
5585 int flags = 0;
5586 int compl = EXPAND_NOTHING;
5587 char_u *compl_arg = NULL;
5588 int has_attr = (eap->arg[0] == '-');
5589
5590 p = eap->arg;
5591
5592 /* Check for attributes */
5593 while (*p == '-')
5594 {
5595 ++p;
5596 end = skiptowhite(p);
5597 if (uc_scan_attr(p, end - p, &argt, &def, &flags, &compl, &compl_arg)
5598 == FAIL)
5599 return;
5600 p = skipwhite(end);
5601 }
5602
5603 /* Get the name (if any) and skip to the following argument */
5604 name = p;
5605 if (ASCII_ISALPHA(*p))
5606 while (ASCII_ISALNUM(*p))
5607 ++p;
5608 if (!ends_excmd(*p) && !vim_iswhite(*p))
5609 {
5610 EMSG(_("E182: Invalid command name"));
5611 return;
5612 }
5613 end = p;
5614
5615 /* If there is nothing after the name, and no attributes were specified,
5616 * we are listing commands
5617 */
5618 p = skipwhite(end);
5619 if (!has_attr && ends_excmd(*p))
5620 {
5621 uc_list(name, end - name);
5622 }
5623 else if (!ASCII_ISUPPER(*name))
5624 {
5625 EMSG(_("E183: User defined commands must start with an uppercase letter"));
5626 return;
5627 }
5628 else
5629 uc_add_command(name, end - name, p, argt, def, flags, compl, compl_arg,
5630 eap->forceit);
5631}
5632
5633/*
5634 * ":comclear"
Bram Moolenaar071d4272004-06-13 20:20:40 +00005635 * Clear all user commands, global and for current buffer.
5636 */
Bram Moolenaar0a5fe212005-06-24 23:01:23 +00005637 void
Bram Moolenaar071d4272004-06-13 20:20:40 +00005638ex_comclear(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +00005639 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005640{
5641 uc_clear(&ucmds);
5642 uc_clear(&curbuf->b_ucmds);
5643}
5644
5645/*
5646 * Clear all user commands for "gap".
5647 */
5648 void
5649uc_clear(gap)
5650 garray_T *gap;
5651{
5652 int i;
5653 ucmd_T *cmd;
5654
5655 for (i = 0; i < gap->ga_len; ++i)
5656 {
5657 cmd = USER_CMD_GA(gap, i);
5658 vim_free(cmd->uc_name);
5659 vim_free(cmd->uc_rep);
5660# if defined(FEAT_EVAL) && defined(FEAT_CMDL_COMPL)
5661 vim_free(cmd->uc_compl_arg);
5662# endif
5663 }
5664 ga_clear(gap);
5665}
5666
5667 static void
5668ex_delcommand(eap)
5669 exarg_T *eap;
5670{
5671 int i = 0;
5672 ucmd_T *cmd = NULL;
5673 int cmp = -1;
5674 garray_T *gap;
5675
5676 gap = &curbuf->b_ucmds;
5677 for (;;)
5678 {
5679 for (i = 0; i < gap->ga_len; ++i)
5680 {
5681 cmd = USER_CMD_GA(gap, i);
5682 cmp = STRCMP(eap->arg, cmd->uc_name);
5683 if (cmp <= 0)
5684 break;
5685 }
5686 if (gap == &ucmds || cmp == 0)
5687 break;
5688 gap = &ucmds;
5689 }
5690
5691 if (cmp != 0)
5692 {
5693 EMSG2(_("E184: No such user-defined command: %s"), eap->arg);
5694 return;
5695 }
5696
5697 vim_free(cmd->uc_name);
5698 vim_free(cmd->uc_rep);
5699# if defined(FEAT_EVAL) && defined(FEAT_CMDL_COMPL)
5700 vim_free(cmd->uc_compl_arg);
5701# endif
5702
5703 --gap->ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00005704
5705 if (i < gap->ga_len)
5706 mch_memmove(cmd, cmd + 1, (gap->ga_len - i) * sizeof(ucmd_T));
5707}
5708
Bram Moolenaar552f8a12007-03-08 17:12:08 +00005709/*
5710 * split and quote args for <f-args>
5711 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005712 static char_u *
5713uc_split_args(arg, lenp)
5714 char_u *arg;
5715 size_t *lenp;
5716{
5717 char_u *buf;
5718 char_u *p;
5719 char_u *q;
5720 int len;
5721
5722 /* Precalculate length */
5723 p = arg;
5724 len = 2; /* Initial and final quotes */
5725
5726 while (*p)
5727 {
Bram Moolenaar552f8a12007-03-08 17:12:08 +00005728 if (p[0] == '\\' && p[1] == '\\')
5729 {
5730 len += 2;
5731 p += 2;
5732 }
5733 else if (p[0] == '\\' && vim_iswhite(p[1]))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005734 {
5735 len += 1;
5736 p += 2;
5737 }
5738 else if (*p == '\\' || *p == '"')
5739 {
5740 len += 2;
5741 p += 1;
5742 }
5743 else if (vim_iswhite(*p))
5744 {
5745 p = skipwhite(p);
5746 if (*p == NUL)
5747 break;
5748 len += 3; /* "," */
5749 }
5750 else
5751 {
5752 ++len;
5753 ++p;
5754 }
5755 }
5756
5757 buf = alloc(len + 1);
5758 if (buf == NULL)
5759 {
5760 *lenp = 0;
5761 return buf;
5762 }
5763
5764 p = arg;
5765 q = buf;
5766 *q++ = '"';
5767 while (*p)
5768 {
Bram Moolenaar552f8a12007-03-08 17:12:08 +00005769 if (p[0] == '\\' && p[1] == '\\')
5770 {
5771 *q++ = '\\';
5772 *q++ = '\\';
5773 p += 2;
5774 }
5775 else if (p[0] == '\\' && vim_iswhite(p[1]))
Bram Moolenaar071d4272004-06-13 20:20:40 +00005776 {
5777 *q++ = p[1];
5778 p += 2;
5779 }
5780 else if (*p == '\\' || *p == '"')
5781 {
5782 *q++ = '\\';
5783 *q++ = *p++;
5784 }
5785 else if (vim_iswhite(*p))
5786 {
5787 p = skipwhite(p);
5788 if (*p == NUL)
5789 break;
5790 *q++ = '"';
5791 *q++ = ',';
5792 *q++ = '"';
5793 }
5794 else
5795 {
5796 *q++ = *p++;
5797 }
5798 }
5799 *q++ = '"';
5800 *q = 0;
5801
5802 *lenp = len;
5803 return buf;
5804}
5805
5806/*
5807 * Check for a <> code in a user command.
5808 * "code" points to the '<'. "len" the length of the <> (inclusive).
5809 * "buf" is where the result is to be added.
5810 * "split_buf" points to a buffer used for splitting, caller should free it.
5811 * "split_len" is the length of what "split_buf" contains.
5812 * Returns the length of the replacement, which has been added to "buf".
5813 * Returns -1 if there was no match, and only the "<" has been copied.
5814 */
5815 static size_t
5816uc_check_code(code, len, buf, cmd, eap, split_buf, split_len)
5817 char_u *code;
5818 size_t len;
5819 char_u *buf;
5820 ucmd_T *cmd; /* the user command we're expanding */
5821 exarg_T *eap; /* ex arguments */
5822 char_u **split_buf;
5823 size_t *split_len;
5824{
5825 size_t result = 0;
5826 char_u *p = code + 1;
5827 size_t l = len - 2;
5828 int quote = 0;
5829 enum { ct_ARGS, ct_BANG, ct_COUNT, ct_LINE1, ct_LINE2, ct_REGISTER,
5830 ct_LT, ct_NONE } type = ct_NONE;
5831
5832 if ((vim_strchr((char_u *)"qQfF", *p) != NULL) && p[1] == '-')
5833 {
5834 quote = (*p == 'q' || *p == 'Q') ? 1 : 2;
5835 p += 2;
5836 l -= 2;
5837 }
5838
Bram Moolenaar371d5402006-03-20 21:47:49 +00005839 ++l;
5840 if (l <= 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005841 type = ct_NONE;
Bram Moolenaar371d5402006-03-20 21:47:49 +00005842 else if (STRNICMP(p, "args>", l) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005843 type = ct_ARGS;
Bram Moolenaar371d5402006-03-20 21:47:49 +00005844 else if (STRNICMP(p, "bang>", l) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005845 type = ct_BANG;
Bram Moolenaar371d5402006-03-20 21:47:49 +00005846 else if (STRNICMP(p, "count>", l) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005847 type = ct_COUNT;
Bram Moolenaar371d5402006-03-20 21:47:49 +00005848 else if (STRNICMP(p, "line1>", l) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005849 type = ct_LINE1;
Bram Moolenaar371d5402006-03-20 21:47:49 +00005850 else if (STRNICMP(p, "line2>", l) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005851 type = ct_LINE2;
Bram Moolenaar371d5402006-03-20 21:47:49 +00005852 else if (STRNICMP(p, "lt>", l) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005853 type = ct_LT;
Bram Moolenaar371d5402006-03-20 21:47:49 +00005854 else if (STRNICMP(p, "reg>", l) == 0 || STRNICMP(p, "register>", l) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00005855 type = ct_REGISTER;
5856
5857 switch (type)
5858 {
5859 case ct_ARGS:
5860 /* Simple case first */
5861 if (*eap->arg == NUL)
5862 {
5863 if (quote == 1)
5864 {
5865 result = 2;
5866 if (buf != NULL)
5867 STRCPY(buf, "''");
5868 }
5869 else
5870 result = 0;
5871 break;
5872 }
5873
5874 /* When specified there is a single argument don't split it.
5875 * Works for ":Cmd %" when % is "a b c". */
5876 if ((eap->argt & NOSPC) && quote == 2)
5877 quote = 1;
5878
5879 switch (quote)
5880 {
5881 case 0: /* No quoting, no splitting */
5882 result = STRLEN(eap->arg);
5883 if (buf != NULL)
5884 STRCPY(buf, eap->arg);
5885 break;
5886 case 1: /* Quote, but don't split */
5887 result = STRLEN(eap->arg) + 2;
5888 for (p = eap->arg; *p; ++p)
5889 {
5890 if (*p == '\\' || *p == '"')
5891 ++result;
5892 }
5893
5894 if (buf != NULL)
5895 {
5896 *buf++ = '"';
5897 for (p = eap->arg; *p; ++p)
5898 {
5899 if (*p == '\\' || *p == '"')
5900 *buf++ = '\\';
5901 *buf++ = *p;
5902 }
5903 *buf = '"';
5904 }
5905
5906 break;
Bram Moolenaar552f8a12007-03-08 17:12:08 +00005907 case 2: /* Quote and split (<f-args>) */
Bram Moolenaar071d4272004-06-13 20:20:40 +00005908 /* This is hard, so only do it once, and cache the result */
5909 if (*split_buf == NULL)
5910 *split_buf = uc_split_args(eap->arg, split_len);
5911
5912 result = *split_len;
5913 if (buf != NULL && result != 0)
5914 STRCPY(buf, *split_buf);
5915
5916 break;
5917 }
5918 break;
5919
5920 case ct_BANG:
5921 result = eap->forceit ? 1 : 0;
5922 if (quote)
5923 result += 2;
5924 if (buf != NULL)
5925 {
5926 if (quote)
5927 *buf++ = '"';
5928 if (eap->forceit)
5929 *buf++ = '!';
5930 if (quote)
5931 *buf = '"';
5932 }
5933 break;
5934
5935 case ct_LINE1:
5936 case ct_LINE2:
5937 case ct_COUNT:
5938 {
5939 char num_buf[20];
5940 long num = (type == ct_LINE1) ? eap->line1 :
5941 (type == ct_LINE2) ? eap->line2 :
5942 (eap->addr_count > 0) ? eap->line2 : cmd->uc_def;
5943 size_t num_len;
5944
5945 sprintf(num_buf, "%ld", num);
5946 num_len = STRLEN(num_buf);
5947 result = num_len;
5948
5949 if (quote)
5950 result += 2;
5951
5952 if (buf != NULL)
5953 {
5954 if (quote)
5955 *buf++ = '"';
5956 STRCPY(buf, num_buf);
5957 buf += num_len;
5958 if (quote)
5959 *buf = '"';
5960 }
5961
5962 break;
5963 }
5964
5965 case ct_REGISTER:
5966 result = eap->regname ? 1 : 0;
5967 if (quote)
5968 result += 2;
5969 if (buf != NULL)
5970 {
5971 if (quote)
5972 *buf++ = '\'';
5973 if (eap->regname)
5974 *buf++ = eap->regname;
5975 if (quote)
5976 *buf = '\'';
5977 }
5978 break;
5979
5980 case ct_LT:
5981 result = 1;
5982 if (buf != NULL)
5983 *buf = '<';
5984 break;
5985
5986 default:
5987 /* Not recognized: just copy the '<' and return -1. */
5988 result = (size_t)-1;
5989 if (buf != NULL)
5990 *buf = '<';
5991 break;
5992 }
5993
5994 return result;
5995}
5996
5997 static void
5998do_ucmd(eap)
5999 exarg_T *eap;
6000{
6001 char_u *buf;
6002 char_u *p;
6003 char_u *q;
6004
6005 char_u *start;
Bram Moolenaar25648a52009-02-21 19:37:46 +00006006 char_u *end = NULL;
Bram Moolenaara850a712009-01-28 14:42:59 +00006007 char_u *ksp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006008 size_t len, totlen;
6009
6010 size_t split_len = 0;
6011 char_u *split_buf = NULL;
6012 ucmd_T *cmd;
6013#ifdef FEAT_EVAL
6014 scid_T save_current_SID = current_SID;
6015#endif
6016
6017 if (eap->cmdidx == CMD_USER)
6018 cmd = USER_CMD(eap->useridx);
6019 else
6020 cmd = USER_CMD_GA(&curbuf->b_ucmds, eap->useridx);
6021
6022 /*
6023 * Replace <> in the command by the arguments.
Bram Moolenaara850a712009-01-28 14:42:59 +00006024 * First round: "buf" is NULL, compute length, allocate "buf".
6025 * Second round: copy result into "buf".
Bram Moolenaar071d4272004-06-13 20:20:40 +00006026 */
6027 buf = NULL;
6028 for (;;)
6029 {
Bram Moolenaara850a712009-01-28 14:42:59 +00006030 p = cmd->uc_rep; /* source */
Bram Moolenaar60f39ae2009-03-11 14:10:38 +00006031 q = buf; /* destination */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006032 totlen = 0;
Bram Moolenaara850a712009-01-28 14:42:59 +00006033
6034 for (;;)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006035 {
Bram Moolenaara850a712009-01-28 14:42:59 +00006036 start = vim_strchr(p, '<');
6037 if (start != NULL)
6038 end = vim_strchr(start + 1, '>');
6039 if (buf != NULL)
6040 {
6041 ksp = vim_strchr(p, K_SPECIAL);
6042 if (ksp != NULL && (start == NULL || ksp < start || end == NULL)
6043 && ((ksp[1] == KS_SPECIAL && ksp[2] == KE_FILLER)
6044# ifdef FEAT_GUI
6045 || (ksp[1] == KS_EXTRA && ksp[2] == (int)KE_CSI)
6046# endif
6047 ))
6048 {
6049 /* K_SPECIAL han been put in the buffer as K_SPECIAL
6050 * KS_SPECIAL KE_FILLER, like for mappings, but
6051 * do_cmdline() doesn't handle that, so convert it back.
6052 * Also change K_SPECIAL KS_EXTRA KE_CSI into CSI. */
6053 len = ksp - p;
6054 if (len > 0)
6055 {
6056 mch_memmove(q, p, len);
6057 q += len;
6058 }
6059 *q++ = ksp[1] == KS_SPECIAL ? K_SPECIAL : CSI;
6060 p = ksp + 3;
6061 continue;
6062 }
6063 }
6064
6065 /* break if there no <item> is found */
6066 if (start == NULL || end == NULL)
6067 break;
6068
Bram Moolenaar071d4272004-06-13 20:20:40 +00006069 /* Include the '>' */
6070 ++end;
6071
6072 /* Take everything up to the '<' */
6073 len = start - p;
6074 if (buf == NULL)
6075 totlen += len;
6076 else
6077 {
6078 mch_memmove(q, p, len);
6079 q += len;
6080 }
6081
6082 len = uc_check_code(start, end - start, q, cmd, eap,
6083 &split_buf, &split_len);
6084 if (len == (size_t)-1)
6085 {
6086 /* no match, continue after '<' */
6087 p = start + 1;
6088 len = 1;
6089 }
6090 else
6091 p = end;
6092 if (buf == NULL)
6093 totlen += len;
6094 else
6095 q += len;
6096 }
6097 if (buf != NULL) /* second time here, finished */
6098 {
6099 STRCPY(q, p);
6100 break;
6101 }
6102
6103 totlen += STRLEN(p); /* Add on the trailing characters */
6104 buf = alloc((unsigned)(totlen + 1));
6105 if (buf == NULL)
6106 {
6107 vim_free(split_buf);
6108 return;
6109 }
6110 }
6111
6112#ifdef FEAT_EVAL
6113 current_SID = cmd->uc_scriptID;
6114#endif
6115 (void)do_cmdline(buf, eap->getline, eap->cookie,
6116 DOCMD_VERBOSE|DOCMD_NOWAIT|DOCMD_KEYTYPED);
6117#ifdef FEAT_EVAL
6118 current_SID = save_current_SID;
6119#endif
6120 vim_free(buf);
6121 vim_free(split_buf);
6122}
6123
6124# if defined(FEAT_CMDL_COMPL) || defined(PROTO)
6125 static char_u *
6126get_user_command_name(idx)
6127 int idx;
6128{
6129 return get_user_commands(NULL, idx - (int)CMD_SIZE);
6130}
6131
6132/*
6133 * Function given to ExpandGeneric() to obtain the list of user command names.
6134 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006135 char_u *
6136get_user_commands(xp, idx)
Bram Moolenaar78a15312009-05-15 19:33:18 +00006137 expand_T *xp UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006138 int idx;
6139{
6140 if (idx < curbuf->b_ucmds.ga_len)
6141 return USER_CMD_GA(&curbuf->b_ucmds, idx)->uc_name;
6142 idx -= curbuf->b_ucmds.ga_len;
6143 if (idx < ucmds.ga_len)
6144 return USER_CMD(idx)->uc_name;
6145 return NULL;
6146}
6147
6148/*
6149 * Function given to ExpandGeneric() to obtain the list of user command
6150 * attributes.
6151 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006152 char_u *
6153get_user_cmd_flags(xp, idx)
Bram Moolenaar78a15312009-05-15 19:33:18 +00006154 expand_T *xp UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006155 int idx;
6156{
6157 static char *user_cmd_flags[] =
6158 {"bang", "bar", "buffer", "complete", "count",
6159 "nargs", "range", "register"};
6160
Bram Moolenaaraf0167f2009-05-16 15:31:32 +00006161 if (idx >= (int)(sizeof(user_cmd_flags) / sizeof(user_cmd_flags[0])))
Bram Moolenaar071d4272004-06-13 20:20:40 +00006162 return NULL;
6163 return (char_u *)user_cmd_flags[idx];
6164}
6165
6166/*
6167 * Function given to ExpandGeneric() to obtain the list of values for -nargs.
6168 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006169 char_u *
6170get_user_cmd_nargs(xp, idx)
Bram Moolenaar78a15312009-05-15 19:33:18 +00006171 expand_T *xp UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006172 int idx;
6173{
6174 static char *user_cmd_nargs[] = {"0", "1", "*", "?", "+"};
6175
Bram Moolenaaraf0167f2009-05-16 15:31:32 +00006176 if (idx >= (int)(sizeof(user_cmd_nargs) / sizeof(user_cmd_nargs[0])))
Bram Moolenaar071d4272004-06-13 20:20:40 +00006177 return NULL;
6178 return (char_u *)user_cmd_nargs[idx];
6179}
6180
6181/*
6182 * Function given to ExpandGeneric() to obtain the list of values for -complete.
6183 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006184 char_u *
6185get_user_cmd_complete(xp, idx)
Bram Moolenaar78a15312009-05-15 19:33:18 +00006186 expand_T *xp UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006187 int idx;
6188{
6189 return (char_u *)command_complete[idx].name;
6190}
6191# endif /* FEAT_CMDL_COMPL */
6192
6193#endif /* FEAT_USR_CMDS */
6194
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00006195#if defined(FEAT_USR_CMDS) || defined(FEAT_EVAL) || defined(PROTO)
6196/*
6197 * Parse a completion argument "value[vallen]".
6198 * The detected completion goes in "*complp", argument type in "*argt".
6199 * When there is an argument, for function and user defined completion, it's
6200 * copied to allocated memory and stored in "*compl_arg".
6201 * Returns FAIL if something is wrong.
6202 */
6203 int
6204parse_compl_arg(value, vallen, complp, argt, compl_arg)
6205 char_u *value;
6206 int vallen;
6207 int *complp;
6208 long *argt;
6209 char_u **compl_arg;
6210{
6211 char_u *arg = NULL;
6212 size_t arglen = 0;
6213 int i;
6214 int valend = vallen;
6215
6216 /* Look for any argument part - which is the part after any ',' */
6217 for (i = 0; i < vallen; ++i)
6218 {
6219 if (value[i] == ',')
6220 {
6221 arg = &value[i + 1];
6222 arglen = vallen - i - 1;
6223 valend = i;
6224 break;
6225 }
6226 }
6227
6228 for (i = 0; command_complete[i].expand != 0; ++i)
6229 {
Bram Moolenaar482aaeb2005-09-29 18:26:07 +00006230 if ((int)STRLEN(command_complete[i].name) == valend
Bram Moolenaarbfd8fc02005-09-20 23:22:24 +00006231 && STRNCMP(value, command_complete[i].name, valend) == 0)
6232 {
6233 *complp = command_complete[i].expand;
6234 if (command_complete[i].expand == EXPAND_BUFFERS)
6235 *argt |= BUFNAME;
6236 else if (command_complete[i].expand == EXPAND_DIRECTORIES
6237 || command_complete[i].expand == EXPAND_FILES)
6238 *argt |= XFILE;
6239 break;
6240 }
6241 }
6242
6243 if (command_complete[i].expand == 0)
6244 {
6245 EMSG2(_("E180: Invalid complete value: %s"), value);
6246 return FAIL;
6247 }
6248
6249# if defined(FEAT_EVAL) && defined(FEAT_CMDL_COMPL)
6250 if (*complp != EXPAND_USER_DEFINED && *complp != EXPAND_USER_LIST
6251 && arg != NULL)
6252# else
6253 if (arg != NULL)
6254# endif
6255 {
6256 EMSG(_("E468: Completion argument only allowed for custom completion"));
6257 return FAIL;
6258 }
6259
6260# if defined(FEAT_EVAL) && defined(FEAT_CMDL_COMPL)
6261 if ((*complp == EXPAND_USER_DEFINED || *complp == EXPAND_USER_LIST)
6262 && arg == NULL)
6263 {
6264 EMSG(_("E467: Custom completion requires a function argument"));
6265 return FAIL;
6266 }
6267
6268 if (arg != NULL)
6269 *compl_arg = vim_strnsave(arg, (int)arglen);
6270# endif
6271 return OK;
6272}
6273#endif
6274
Bram Moolenaar071d4272004-06-13 20:20:40 +00006275 static void
6276ex_colorscheme(eap)
6277 exarg_T *eap;
6278{
Bram Moolenaare6850792010-05-14 15:28:44 +02006279 if (*eap->arg == NUL)
6280 {
6281#ifdef FEAT_EVAL
6282 char_u *expr = vim_strsave((char_u *)"g:colors_name");
6283 char_u *p = NULL;
6284
6285 if (expr != NULL)
6286 {
6287 ++emsg_off;
6288 p = eval_to_string(expr, NULL, FALSE);
6289 --emsg_off;
6290 vim_free(expr);
6291 }
6292 if (p != NULL)
6293 {
6294 MSG(p);
6295 vim_free(p);
6296 }
6297 else
6298 MSG("default");
6299#else
6300 MSG(_("unknown"));
6301#endif
6302 }
6303 else if (load_colors(eap->arg) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006304 EMSG2(_("E185: Cannot find color scheme %s"), eap->arg);
6305}
6306
6307 static void
6308ex_highlight(eap)
6309 exarg_T *eap;
6310{
6311 if (*eap->arg == NUL && eap->cmd[2] == '!')
6312 MSG(_("Greetings, Vim user!"));
6313 do_highlight(eap->arg, eap->forceit, FALSE);
6314}
6315
6316
6317/*
6318 * Call this function if we thought we were going to exit, but we won't
6319 * (because of an error). May need to restore the terminal mode.
6320 */
6321 void
6322not_exiting()
6323{
6324 exiting = FALSE;
6325 settmode(TMODE_RAW);
6326}
6327
6328/*
6329 * ":quit": quit current window, quit Vim if closed the last window.
6330 */
6331 static void
6332ex_quit(eap)
6333 exarg_T *eap;
6334{
6335#ifdef FEAT_CMDWIN
6336 if (cmdwin_type != 0)
6337 {
6338 cmdwin_result = Ctrl_C;
6339 return;
6340 }
6341#endif
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006342 /* Don't quit while editing the command line. */
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00006343 if (text_locked())
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006344 {
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00006345 text_locked_msg();
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006346 return;
6347 }
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006348#ifdef FEAT_AUTOCMD
6349 if (curbuf_locked())
6350 return;
6351#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006352
6353#ifdef FEAT_NETBEANS_INTG
6354 netbeansForcedQuit = eap->forceit;
6355#endif
6356
6357 /*
6358 * If there are more files or windows we won't exit.
6359 */
6360 if (check_more(FALSE, eap->forceit) == OK && only_one_window())
6361 exiting = TRUE;
6362 if ((!P_HID(curbuf)
6363 && check_changed(curbuf, p_awa, FALSE, eap->forceit, FALSE))
6364 || check_more(TRUE, eap->forceit) == FAIL
6365 || (only_one_window() && check_changed_any(eap->forceit)))
6366 {
6367 not_exiting();
6368 }
6369 else
6370 {
6371#ifdef FEAT_WINDOWS
6372 if (only_one_window()) /* quit last window */
6373#endif
6374 getout(0);
6375#ifdef FEAT_WINDOWS
6376# ifdef FEAT_GUI
6377 need_mouse_correct = TRUE;
6378# endif
6379 /* close window; may free buffer */
6380 win_close(curwin, !P_HID(curwin->w_buffer) || eap->forceit);
6381#endif
6382 }
6383}
6384
6385/*
6386 * ":cquit".
6387 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006388 static void
6389ex_cquit(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +00006390 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006391{
6392 getout(1); /* this does not always pass on the exit code to the Manx
6393 compiler. why? */
6394}
6395
6396/*
6397 * ":qall": try to quit all windows
6398 */
6399 static void
6400ex_quit_all(eap)
6401 exarg_T *eap;
6402{
6403# ifdef FEAT_CMDWIN
6404 if (cmdwin_type != 0)
6405 {
6406 if (eap->forceit)
6407 cmdwin_result = K_XF1; /* ex_window() takes care of this */
6408 else
6409 cmdwin_result = K_XF2;
6410 return;
6411 }
6412# endif
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006413
6414 /* Don't quit while editing the command line. */
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00006415 if (text_locked())
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006416 {
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00006417 text_locked_msg();
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006418 return;
6419 }
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006420#ifdef FEAT_AUTOCMD
6421 if (curbuf_locked())
6422 return;
6423#endif
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006424
Bram Moolenaar071d4272004-06-13 20:20:40 +00006425 exiting = TRUE;
6426 if (eap->forceit || !check_changed_any(FALSE))
6427 getout(0);
6428 not_exiting();
6429}
6430
Bram Moolenaard9967712006-03-11 21:18:15 +00006431#if defined(FEAT_WINDOWS) || defined(PROTO)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006432/*
6433 * ":close": close current window, unless it is the last one
6434 */
6435 static void
6436ex_close(eap)
6437 exarg_T *eap;
6438{
6439# ifdef FEAT_CMDWIN
6440 if (cmdwin_type != 0)
6441 cmdwin_result = K_IGNORE;
6442 else
6443# endif
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006444 if (!text_locked()
6445#ifdef FEAT_AUTOCMD
6446 && !curbuf_locked()
6447#endif
6448 )
Bram Moolenaarf740b292006-02-16 22:11:02 +00006449 ex_win_close(eap->forceit, curwin, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006450}
6451
Bram Moolenaard9967712006-03-11 21:18:15 +00006452# ifdef FEAT_QUICKFIX
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006453/*
6454 * ":pclose": Close any preview window.
6455 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006456 static void
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006457ex_pclose(eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006458 exarg_T *eap;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006459{
6460 win_T *win;
6461
6462 for (win = firstwin; win != NULL; win = win->w_next)
6463 if (win->w_p_pvw)
6464 {
Bram Moolenaarf740b292006-02-16 22:11:02 +00006465 ex_win_close(eap->forceit, win, NULL);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006466 break;
6467 }
6468}
Bram Moolenaard9967712006-03-11 21:18:15 +00006469# endif
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006470
Bram Moolenaarf740b292006-02-16 22:11:02 +00006471/*
6472 * Close window "win" and take care of handling closing the last window for a
6473 * modified buffer.
6474 */
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006475 static void
Bram Moolenaarf740b292006-02-16 22:11:02 +00006476ex_win_close(forceit, win, tp)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006477 int forceit;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006478 win_T *win;
Bram Moolenaarf740b292006-02-16 22:11:02 +00006479 tabpage_T *tp; /* NULL or the tab page "win" is in */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006480{
6481 int need_hide;
6482 buf_T *buf = win->w_buffer;
6483
6484 need_hide = (bufIsChanged(buf) && buf->b_nwindows <= 1);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006485 if (need_hide && !P_HID(buf) && !forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006486 {
Bram Moolenaard9967712006-03-11 21:18:15 +00006487# if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006488 if ((p_confirm || cmdmod.confirm) && p_write)
6489 {
6490 dialog_changed(buf, FALSE);
6491 if (buf_valid(buf) && bufIsChanged(buf))
6492 return;
6493 need_hide = FALSE;
6494 }
6495 else
Bram Moolenaard9967712006-03-11 21:18:15 +00006496# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006497 {
6498 EMSG(_(e_nowrtmsg));
6499 return;
6500 }
6501 }
6502
Bram Moolenaard9967712006-03-11 21:18:15 +00006503# ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00006504 need_mouse_correct = TRUE;
Bram Moolenaard9967712006-03-11 21:18:15 +00006505# endif
Bram Moolenaarf740b292006-02-16 22:11:02 +00006506
Bram Moolenaar071d4272004-06-13 20:20:40 +00006507 /* free buffer when not hiding it or when it's a scratch buffer */
Bram Moolenaarf740b292006-02-16 22:11:02 +00006508 if (tp == NULL)
6509 win_close(win, !need_hide && !P_HID(buf));
6510 else
6511 win_close_othertab(win, !need_hide && !P_HID(buf), tp);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006512}
6513
Bram Moolenaar071d4272004-06-13 20:20:40 +00006514/*
Bram Moolenaarf740b292006-02-16 22:11:02 +00006515 * ":tabclose": close current tab page, unless it is the last one.
6516 * ":tabclose N": close tab page N.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006517 */
6518 static void
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006519ex_tabclose(eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00006520 exarg_T *eap;
6521{
Bram Moolenaarf740b292006-02-16 22:11:02 +00006522 tabpage_T *tp;
6523
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006524# ifdef FEAT_CMDWIN
6525 if (cmdwin_type != 0)
6526 cmdwin_result = K_IGNORE;
6527 else
6528# endif
Bram Moolenaarf740b292006-02-16 22:11:02 +00006529 if (first_tabpage->tp_next == NULL)
Bram Moolenaar7e8fd632006-02-18 22:14:51 +00006530 EMSG(_("E784: Cannot close last tab page"));
Bram Moolenaarf740b292006-02-16 22:11:02 +00006531 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00006532 {
Bram Moolenaarf740b292006-02-16 22:11:02 +00006533 if (eap->addr_count > 0)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006534 {
Bram Moolenaarf740b292006-02-16 22:11:02 +00006535 tp = find_tabpage((int)eap->line2);
6536 if (tp == NULL)
6537 {
6538 beep_flush();
6539 return;
6540 }
Bram Moolenaar7e8fd632006-02-18 22:14:51 +00006541 if (tp != curtab)
Bram Moolenaarf740b292006-02-16 22:11:02 +00006542 {
6543 tabpage_close_other(tp, eap->forceit);
6544 return;
6545 }
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00006546 }
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006547 if (!text_locked()
6548#ifdef FEAT_AUTOCMD
6549 && !curbuf_locked()
6550#endif
6551 )
Bram Moolenaarf740b292006-02-16 22:11:02 +00006552 tabpage_close(eap->forceit);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006553 }
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006554}
6555
6556/*
6557 * ":tabonly": close all tab pages except the current one
6558 */
6559 static void
6560ex_tabonly(eap)
6561 exarg_T *eap;
6562{
6563 tabpage_T *tp;
6564 int done;
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006565
6566# ifdef FEAT_CMDWIN
6567 if (cmdwin_type != 0)
6568 cmdwin_result = K_IGNORE;
6569 else
6570# endif
6571 if (first_tabpage->tp_next == NULL)
6572 MSG(_("Already only one tab page"));
6573 else
6574 {
6575 /* Repeat this up to a 1000 times, because autocommands may mess
6576 * up the lists. */
6577 for (done = 0; done < 1000; ++done)
6578 {
6579 for (tp = first_tabpage; tp != NULL; tp = tp->tp_next)
6580 if (tp->tp_topframe != topframe)
6581 {
6582 tabpage_close_other(tp, eap->forceit);
6583 /* if we failed to close it quit */
6584 if (valid_tabpage(tp))
6585 done = 1000;
6586 /* start over, "tp" is now invalid */
6587 break;
6588 }
6589 if (first_tabpage->tp_next == NULL)
6590 break;
6591 }
6592 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00006593}
Bram Moolenaar071d4272004-06-13 20:20:40 +00006594
6595/*
Bram Moolenaarf740b292006-02-16 22:11:02 +00006596 * Close the current tab page.
6597 */
6598 void
6599tabpage_close(forceit)
6600 int forceit;
6601{
6602 /* First close all the windows but the current one. If that worked then
6603 * close the last window in this tab, that will close it. */
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00006604 if (lastwin != firstwin)
6605 close_others(TRUE, forceit);
Bram Moolenaarf740b292006-02-16 22:11:02 +00006606 if (lastwin == firstwin)
6607 ex_win_close(forceit, curwin, NULL);
6608# ifdef FEAT_GUI
6609 need_mouse_correct = TRUE;
6610# endif
6611}
6612
6613/*
6614 * Close tab page "tp", which is not the current tab page.
6615 * Note that autocommands may make "tp" invalid.
Bram Moolenaar7875acc2006-09-10 13:51:17 +00006616 * Also takes care of the tab pages line disappearing when closing the
6617 * last-but-one tab page.
Bram Moolenaarf740b292006-02-16 22:11:02 +00006618 */
6619 void
6620tabpage_close_other(tp, forceit)
6621 tabpage_T *tp;
6622 int forceit;
6623{
6624 int done = 0;
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006625 win_T *wp;
Bram Moolenaar7875acc2006-09-10 13:51:17 +00006626 int h = tabline_height();
Bram Moolenaarf740b292006-02-16 22:11:02 +00006627
6628 /* Limit to 1000 windows, autocommands may add a window while we close
6629 * one. OK, so I'm paranoid... */
6630 while (++done < 1000)
6631 {
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006632 wp = tp->tp_firstwin;
6633 ex_win_close(forceit, wp, tp);
Bram Moolenaarf740b292006-02-16 22:11:02 +00006634
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006635 /* Autocommands may delete the tab page under our fingers and we may
6636 * fail to close a window with a modified buffer. */
6637 if (!valid_tabpage(tp) || tp->tp_firstwin == wp)
Bram Moolenaarf740b292006-02-16 22:11:02 +00006638 break;
6639 }
Bram Moolenaar7875acc2006-09-10 13:51:17 +00006640
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00006641 redraw_tabline = TRUE;
Bram Moolenaar7875acc2006-09-10 13:51:17 +00006642 if (h != tabline_height())
6643 shell_new_rows();
Bram Moolenaarf740b292006-02-16 22:11:02 +00006644}
6645
6646/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00006647 * ":only".
6648 */
6649 static void
6650ex_only(eap)
6651 exarg_T *eap;
6652{
6653# ifdef FEAT_GUI
6654 need_mouse_correct = TRUE;
6655# endif
6656 close_others(TRUE, eap->forceit);
6657}
6658
6659/*
6660 * ":all" and ":sall".
Bram Moolenaard9967712006-03-11 21:18:15 +00006661 * Also used for ":tab drop file ..." after setting the argument list.
Bram Moolenaar071d4272004-06-13 20:20:40 +00006662 */
Bram Moolenaard9967712006-03-11 21:18:15 +00006663 void
Bram Moolenaar071d4272004-06-13 20:20:40 +00006664ex_all(eap)
6665 exarg_T *eap;
6666{
6667 if (eap->addr_count == 0)
6668 eap->line2 = 9999;
Bram Moolenaard9967712006-03-11 21:18:15 +00006669 do_arg_all((int)eap->line2, eap->forceit, eap->cmdidx == CMD_drop);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006670}
6671#endif /* FEAT_WINDOWS */
6672
6673 static void
6674ex_hide(eap)
6675 exarg_T *eap;
6676{
6677 if (*eap->arg != NUL && check_nextcmd(eap->arg) == NULL)
6678 eap->errmsg = e_invarg;
6679 else
6680 {
6681 /* ":hide" or ":hide | cmd": hide current window */
6682 eap->nextcmd = check_nextcmd(eap->arg);
6683#ifdef FEAT_WINDOWS
6684 if (!eap->skip)
6685 {
6686# ifdef FEAT_GUI
6687 need_mouse_correct = TRUE;
6688# endif
6689 win_close(curwin, FALSE); /* don't free buffer */
6690 }
6691#endif
6692 }
6693}
6694
6695/*
6696 * ":stop" and ":suspend": Suspend Vim.
6697 */
6698 static void
6699ex_stop(eap)
6700 exarg_T *eap;
6701{
6702 /*
6703 * Disallow suspending for "rvim".
6704 */
6705 if (!check_restricted()
6706#ifdef WIN3264
6707 /*
6708 * Check if external commands are allowed now.
6709 */
6710 && can_end_termcap_mode(TRUE)
6711#endif
6712 )
6713 {
6714 if (!eap->forceit)
6715 autowrite_all();
6716 windgoto((int)Rows - 1, 0);
6717 out_char('\n');
6718 out_flush();
6719 stoptermcap();
6720 out_flush(); /* needed for SUN to restore xterm buffer */
6721#ifdef FEAT_TITLE
6722 mch_restore_title(3); /* restore window titles */
6723#endif
6724 ui_suspend(); /* call machine specific function */
6725#ifdef FEAT_TITLE
6726 maketitle();
6727 resettitle(); /* force updating the title */
6728#endif
6729 starttermcap();
6730 scroll_start(); /* scroll screen before redrawing */
6731 redraw_later_clear();
6732 shell_resized(); /* may have resized window */
6733 }
6734}
6735
6736/*
6737 * ":exit", ":xit" and ":wq": Write file and exit Vim.
6738 */
6739 static void
6740ex_exit(eap)
6741 exarg_T *eap;
6742{
6743#ifdef FEAT_CMDWIN
6744 if (cmdwin_type != 0)
6745 {
6746 cmdwin_result = Ctrl_C;
6747 return;
6748 }
6749#endif
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006750 /* Don't quit while editing the command line. */
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00006751 if (text_locked())
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006752 {
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00006753 text_locked_msg();
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006754 return;
6755 }
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006756#ifdef FEAT_AUTOCMD
6757 if (curbuf_locked())
6758 return;
6759#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00006760
6761 /*
6762 * if more files or windows we won't exit
6763 */
6764 if (check_more(FALSE, eap->forceit) == OK && only_one_window())
6765 exiting = TRUE;
6766 if ( ((eap->cmdidx == CMD_wq
6767 || curbufIsChanged())
6768 && do_write(eap) == FAIL)
6769 || check_more(TRUE, eap->forceit) == FAIL
6770 || (only_one_window() && check_changed_any(eap->forceit)))
6771 {
6772 not_exiting();
6773 }
6774 else
6775 {
6776#ifdef FEAT_WINDOWS
6777 if (only_one_window()) /* quit last window, exit Vim */
6778#endif
6779 getout(0);
6780#ifdef FEAT_WINDOWS
6781# ifdef FEAT_GUI
6782 need_mouse_correct = TRUE;
6783# endif
6784 /* quit current window, may free buffer */
6785 win_close(curwin, !P_HID(curwin->w_buffer));
6786#endif
6787 }
6788}
6789
6790/*
6791 * ":print", ":list", ":number".
6792 */
6793 static void
6794ex_print(eap)
6795 exarg_T *eap;
6796{
Bram Moolenaardf177f62005-02-22 08:39:57 +00006797 if (curbuf->b_ml.ml_flags & ML_EMPTY)
6798 EMSG(_(e_emptybuf));
6799 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00006800 {
Bram Moolenaardf177f62005-02-22 08:39:57 +00006801 for ( ;!got_int; ui_breakcheck())
6802 {
6803 print_line(eap->line1,
6804 (eap->cmdidx == CMD_number || eap->cmdidx == CMD_pound
6805 || (eap->flags & EXFLAG_NR)),
6806 eap->cmdidx == CMD_list || (eap->flags & EXFLAG_LIST));
6807 if (++eap->line1 > eap->line2)
6808 break;
6809 out_flush(); /* show one line at a time */
6810 }
6811 setpcmark();
6812 /* put cursor at last line */
6813 curwin->w_cursor.lnum = eap->line2;
6814 beginline(BL_SOL | BL_FIX);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006815 }
6816
Bram Moolenaar071d4272004-06-13 20:20:40 +00006817 ex_no_reprint = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006818}
6819
6820#ifdef FEAT_BYTEOFF
6821 static void
6822ex_goto(eap)
6823 exarg_T *eap;
6824{
6825 goto_byte(eap->line2);
6826}
6827#endif
6828
6829/*
6830 * ":shell".
6831 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00006832 static void
6833ex_shell(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +00006834 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006835{
6836 do_shell(NULL, 0);
6837}
6838
6839#if (defined(FEAT_WINDOWS) && defined(HAVE_DROP_FILE)) \
6840 || (defined(FEAT_GUI_GTK) && defined(FEAT_DND)) \
Bram Moolenaar371baa92005-12-29 22:43:53 +00006841 || defined(FEAT_GUI_MSWIN) \
6842 || defined(FEAT_GUI_MAC) \
Bram Moolenaar071d4272004-06-13 20:20:40 +00006843 || defined(PROTO)
6844
6845/*
6846 * Handle a file drop. The code is here because a drop is *nearly* like an
6847 * :args command, but not quite (we have a list of exact filenames, so we
6848 * don't want to (a) parse a command line, or (b) expand wildcards. So the
6849 * code is very similar to :args and hence needs access to a lot of the static
6850 * functions in this file.
6851 *
6852 * The list should be allocated using alloc(), as should each item in the
6853 * list. This function takes over responsibility for freeing the list.
6854 *
Bram Moolenaar81870892007-11-11 18:17:28 +00006855 * XXX The list is made into the argument list. This is freed using
Bram Moolenaar071d4272004-06-13 20:20:40 +00006856 * FreeWild(), which does a series of vim_free() calls, unless the two defines
6857 * __EMX__ and __ALWAYS_HAS_TRAILING_NUL_POINTER are set. In this case, a
6858 * routine _fnexplodefree() is used. This may cause problems, but as the drop
6859 * file functionality is (currently) not in EMX this is not presently a
6860 * problem.
6861 */
6862 void
6863handle_drop(filec, filev, split)
6864 int filec; /* the number of files dropped */
6865 char_u **filev; /* the list of files dropped */
6866 int split; /* force splitting the window */
6867{
6868 exarg_T ea;
6869 int save_msg_scroll = msg_scroll;
6870
Bram Moolenaar05a7bb32006-01-19 22:09:32 +00006871 /* Postpone this while editing the command line. */
Bram Moolenaar2d3f4892006-01-20 23:02:51 +00006872 if (text_locked())
Bram Moolenaar071d4272004-06-13 20:20:40 +00006873 return;
Bram Moolenaar910f66f2006-04-05 20:41:53 +00006874#ifdef FEAT_AUTOCMD
6875 if (curbuf_locked())
6876 return;
6877#endif
Bram Moolenaarc236c162008-07-13 17:41:49 +00006878 /* When the screen is being updated we should not change buffers and
6879 * windows structures, it may cause freed memory to be used. */
6880 if (updating_screen)
6881 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00006882
6883 /* Check whether the current buffer is changed. If so, we will need
6884 * to split the current window or data could be lost.
6885 * We don't need to check if the 'hidden' option is set, as in this
6886 * case the buffer won't be lost.
6887 */
6888 if (!P_HID(curbuf) && !split)
6889 {
6890 ++emsg_off;
6891 split = check_changed(curbuf, TRUE, FALSE, FALSE, FALSE);
6892 --emsg_off;
6893 }
6894 if (split)
6895 {
6896# ifdef FEAT_WINDOWS
6897 if (win_split(0, 0) == FAIL)
6898 return;
6899# ifdef FEAT_SCROLLBIND
6900 curwin->w_p_scb = FALSE;
6901# endif
6902
6903 /* When splitting the window, create a new alist. Otherwise the
6904 * existing one is overwritten. */
6905 alist_unlink(curwin->w_alist);
6906 alist_new();
6907# else
6908 return; /* can't split, always fail */
6909# endif
6910 }
6911
6912 /*
6913 * Set up the new argument list.
6914 */
Bram Moolenaar86b68352004-12-27 21:59:20 +00006915 alist_set(ALIST(curwin), filec, filev, FALSE, NULL, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00006916
6917 /*
6918 * Move to the first file.
6919 */
6920 /* Fake up a minimal "next" command for do_argfile() */
6921 vim_memset(&ea, 0, sizeof(ea));
6922 ea.cmd = (char_u *)"next";
6923 do_argfile(&ea, 0);
6924
6925 /* do_ecmd() may set need_start_insertmode, but since we never left Insert
6926 * mode that is not needed here. */
6927 need_start_insertmode = FALSE;
6928
6929 /* Restore msg_scroll, otherwise a following command may cause scrolling
6930 * unexpectedly. The screen will be redrawn by the caller, thus
6931 * msg_scroll being set by displaying a message is irrelevant. */
6932 msg_scroll = save_msg_scroll;
6933}
6934#endif
6935
Bram Moolenaar071d4272004-06-13 20:20:40 +00006936/*
6937 * Clear an argument list: free all file names and reset it to zero entries.
6938 */
Bram Moolenaar15d0a8c2004-09-06 17:44:46 +00006939 void
Bram Moolenaar071d4272004-06-13 20:20:40 +00006940alist_clear(al)
6941 alist_T *al;
6942{
6943 while (--al->al_ga.ga_len >= 0)
6944 vim_free(AARGLIST(al)[al->al_ga.ga_len].ae_fname);
6945 ga_clear(&al->al_ga);
6946}
6947
6948/*
6949 * Init an argument list.
6950 */
6951 void
6952alist_init(al)
6953 alist_T *al;
6954{
6955 ga_init2(&al->al_ga, (int)sizeof(aentry_T), 5);
6956}
6957
6958#if defined(FEAT_WINDOWS) || defined(PROTO)
6959
6960/*
6961 * Remove a reference from an argument list.
6962 * Ignored when the argument list is the global one.
6963 * If the argument list is no longer used by any window, free it.
6964 */
6965 void
6966alist_unlink(al)
6967 alist_T *al;
6968{
6969 if (al != &global_alist && --al->al_refcount <= 0)
6970 {
6971 alist_clear(al);
6972 vim_free(al);
6973 }
6974}
6975
6976# if defined(FEAT_LISTCMDS) || defined(HAVE_DROP_FILE) || defined(PROTO)
6977/*
6978 * Create a new argument list and use it for the current window.
6979 */
6980 void
6981alist_new()
6982{
6983 curwin->w_alist = (alist_T *)alloc((unsigned)sizeof(alist_T));
6984 if (curwin->w_alist == NULL)
6985 {
6986 curwin->w_alist = &global_alist;
6987 ++global_alist.al_refcount;
6988 }
6989 else
6990 {
6991 curwin->w_alist->al_refcount = 1;
6992 alist_init(curwin->w_alist);
6993 }
6994}
6995# endif
6996#endif
6997
6998#if (!defined(UNIX) && !defined(__EMX__)) || defined(ARCHIE) || defined(PROTO)
6999/*
7000 * Expand the file names in the global argument list.
Bram Moolenaar86b68352004-12-27 21:59:20 +00007001 * If "fnum_list" is not NULL, use "fnum_list[fnum_len]" as a list of buffer
7002 * numbers to be re-used.
Bram Moolenaar071d4272004-06-13 20:20:40 +00007003 */
7004 void
Bram Moolenaar86b68352004-12-27 21:59:20 +00007005alist_expand(fnum_list, fnum_len)
7006 int *fnum_list;
7007 int fnum_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007008{
7009 char_u **old_arg_files;
Bram Moolenaar86b68352004-12-27 21:59:20 +00007010 int old_arg_count;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007011 char_u **new_arg_files;
7012 int new_arg_file_count;
7013 char_u *save_p_su = p_su;
7014 int i;
7015
7016 /* Don't use 'suffixes' here. This should work like the shell did the
7017 * expansion. Also, the vimrc file isn't read yet, thus the user
7018 * can't set the options. */
7019 p_su = empty_option;
7020 old_arg_files = (char_u **)alloc((unsigned)(sizeof(char_u *) * GARGCOUNT));
7021 if (old_arg_files != NULL)
7022 {
7023 for (i = 0; i < GARGCOUNT; ++i)
Bram Moolenaar86b68352004-12-27 21:59:20 +00007024 old_arg_files[i] = vim_strsave(GARGLIST[i].ae_fname);
7025 old_arg_count = GARGCOUNT;
7026 if (expand_wildcards(old_arg_count, old_arg_files,
Bram Moolenaar071d4272004-06-13 20:20:40 +00007027 &new_arg_file_count, &new_arg_files,
7028 EW_FILE|EW_NOTFOUND|EW_ADDSLASH) == OK
7029 && new_arg_file_count > 0)
7030 {
Bram Moolenaar86b68352004-12-27 21:59:20 +00007031 alist_set(&global_alist, new_arg_file_count, new_arg_files,
7032 TRUE, fnum_list, fnum_len);
7033 FreeWild(old_arg_count, old_arg_files);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007034 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007035 }
7036 p_su = save_p_su;
7037}
7038#endif
7039
7040/*
7041 * Set the argument list for the current window.
7042 * Takes over the allocated files[] and the allocated fnames in it.
7043 */
7044 void
Bram Moolenaar86b68352004-12-27 21:59:20 +00007045alist_set(al, count, files, use_curbuf, fnum_list, fnum_len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007046 alist_T *al;
7047 int count;
7048 char_u **files;
7049 int use_curbuf;
Bram Moolenaar86b68352004-12-27 21:59:20 +00007050 int *fnum_list;
7051 int fnum_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007052{
7053 int i;
7054
7055 alist_clear(al);
7056 if (ga_grow(&al->al_ga, count) == OK)
7057 {
7058 for (i = 0; i < count; ++i)
Bram Moolenaar15d0a8c2004-09-06 17:44:46 +00007059 {
7060 if (got_int)
7061 {
7062 /* When adding many buffers this can take a long time. Allow
7063 * interrupting here. */
7064 while (i < count)
7065 vim_free(files[i++]);
7066 break;
7067 }
Bram Moolenaar86b68352004-12-27 21:59:20 +00007068
7069 /* May set buffer name of a buffer previously used for the
7070 * argument list, so that it's re-used by alist_add. */
7071 if (fnum_list != NULL && i < fnum_len)
7072 buf_set_name(fnum_list[i], files[i]);
7073
Bram Moolenaar071d4272004-06-13 20:20:40 +00007074 alist_add(al, files[i], use_curbuf ? 2 : 1);
Bram Moolenaar15d0a8c2004-09-06 17:44:46 +00007075 ui_breakcheck();
7076 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007077 vim_free(files);
7078 }
7079 else
7080 FreeWild(count, files);
7081#ifdef FEAT_WINDOWS
7082 if (al == &global_alist)
7083#endif
7084 arg_had_last = FALSE;
7085}
7086
7087/*
7088 * Add file "fname" to argument list "al".
7089 * "fname" must have been allocated and "al" must have been checked for room.
7090 */
7091 void
7092alist_add(al, fname, set_fnum)
7093 alist_T *al;
7094 char_u *fname;
7095 int set_fnum; /* 1: set buffer number; 2: re-use curbuf */
7096{
7097 if (fname == NULL) /* don't add NULL file names */
7098 return;
7099#ifdef BACKSLASH_IN_FILENAME
7100 slash_adjust(fname);
7101#endif
7102 AARGLIST(al)[al->al_ga.ga_len].ae_fname = fname;
7103 if (set_fnum > 0)
7104 AARGLIST(al)[al->al_ga.ga_len].ae_fnum =
7105 buflist_add(fname, BLN_LISTED | (set_fnum == 2 ? BLN_CURBUF : 0));
7106 ++al->al_ga.ga_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007107}
7108
7109#if defined(BACKSLASH_IN_FILENAME) || defined(PROTO)
7110/*
7111 * Adjust slashes in file names. Called after 'shellslash' was set.
7112 */
7113 void
7114alist_slash_adjust()
7115{
7116 int i;
7117# ifdef FEAT_WINDOWS
7118 win_T *wp;
Bram Moolenaarf740b292006-02-16 22:11:02 +00007119 tabpage_T *tp;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007120# endif
7121
7122 for (i = 0; i < GARGCOUNT; ++i)
7123 if (GARGLIST[i].ae_fname != NULL)
7124 slash_adjust(GARGLIST[i].ae_fname);
7125# ifdef FEAT_WINDOWS
Bram Moolenaarf740b292006-02-16 22:11:02 +00007126 FOR_ALL_TAB_WINDOWS(tp, wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007127 if (wp->w_alist != &global_alist)
7128 for (i = 0; i < WARGCOUNT(wp); ++i)
7129 if (WARGLIST(wp)[i].ae_fname != NULL)
7130 slash_adjust(WARGLIST(wp)[i].ae_fname);
7131# endif
7132}
7133#endif
7134
7135/*
7136 * ":preserve".
7137 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007138 static void
7139ex_preserve(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +00007140 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007141{
Bram Moolenaar4399ef42005-02-12 14:29:27 +00007142 curbuf->b_flags |= BF_PRESERVED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007143 ml_preserve(curbuf, TRUE);
7144}
7145
7146/*
7147 * ":recover".
7148 */
7149 static void
7150ex_recover(eap)
7151 exarg_T *eap;
7152{
7153 /* Set recoverymode right away to avoid the ATTENTION prompt. */
7154 recoverymode = TRUE;
7155 if (!check_changed(curbuf, p_awa, TRUE, eap->forceit, FALSE)
7156 && (*eap->arg == NUL
7157 || setfname(curbuf, eap->arg, NULL, TRUE) == OK))
7158 ml_recover();
7159 recoverymode = FALSE;
7160}
7161
7162/*
7163 * Command modifier used in a wrong way.
7164 */
7165 static void
7166ex_wrongmodifier(eap)
7167 exarg_T *eap;
7168{
7169 eap->errmsg = e_invcmd;
7170}
7171
7172#ifdef FEAT_WINDOWS
7173/*
7174 * :sview [+command] file split window with new file, read-only
7175 * :split [[+command] file] split window with current or new file
7176 * :vsplit [[+command] file] split window vertically with current or new file
7177 * :new [[+command] file] split window with no or new file
7178 * :vnew [[+command] file] split vertically window with no or new file
7179 * :sfind [+command] file split window with file in 'path'
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00007180 *
7181 * :tabedit open new Tab page with empty window
7182 * :tabedit [+command] file open new Tab page and edit "file"
7183 * :tabnew [[+command] file] just like :tabedit
7184 * :tabfind [+command] file open new Tab page and find "file"
Bram Moolenaar071d4272004-06-13 20:20:40 +00007185 */
7186 void
7187ex_splitview(eap)
7188 exarg_T *eap;
7189{
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00007190 win_T *old_curwin = curwin;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007191# if defined(FEAT_SEARCHPATH) || defined(FEAT_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007192 char_u *fname = NULL;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007193# endif
7194# ifdef FEAT_BROWSE
Bram Moolenaar071d4272004-06-13 20:20:40 +00007195 int browse_flag = cmdmod.browse;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007196# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007197
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007198# ifndef FEAT_VERTSPLIT
Bram Moolenaar071d4272004-06-13 20:20:40 +00007199 if (eap->cmdidx == CMD_vsplit || eap->cmdidx == CMD_vnew)
7200 {
7201 ex_ni(eap);
7202 return;
7203 }
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007204# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007205
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007206# ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00007207 need_mouse_correct = TRUE;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007208# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007209
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007210# ifdef FEAT_QUICKFIX
Bram Moolenaar071d4272004-06-13 20:20:40 +00007211 /* A ":split" in the quickfix window works like ":new". Don't want two
Bram Moolenaar05bb9532008-07-04 09:44:11 +00007212 * quickfix windows. But it's OK when doing ":tab split". */
7213 if (bt_quickfix(curbuf) && cmdmod.tab == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007214 {
7215 if (eap->cmdidx == CMD_split)
7216 eap->cmdidx = CMD_new;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007217# ifdef FEAT_VERTSPLIT
Bram Moolenaar071d4272004-06-13 20:20:40 +00007218 if (eap->cmdidx == CMD_vsplit)
7219 eap->cmdidx = CMD_vnew;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007220# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007221 }
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007222# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007223
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007224# ifdef FEAT_SEARCHPATH
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00007225 if (eap->cmdidx == CMD_sfind || eap->cmdidx == CMD_tabfind)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007226 {
7227 fname = find_file_in_path(eap->arg, (int)STRLEN(eap->arg),
7228 FNAME_MESS, TRUE, curbuf->b_ffname);
7229 if (fname == NULL)
7230 goto theend;
7231 eap->arg = fname;
7232 }
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007233# ifdef FEAT_BROWSE
Bram Moolenaar071d4272004-06-13 20:20:40 +00007234 else
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007235# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007236# endif
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007237# ifdef FEAT_BROWSE
Bram Moolenaar071d4272004-06-13 20:20:40 +00007238 if (cmdmod.browse
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007239# ifdef FEAT_VERTSPLIT
Bram Moolenaar071d4272004-06-13 20:20:40 +00007240 && eap->cmdidx != CMD_vnew
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007241# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007242 && eap->cmdidx != CMD_new)
7243 {
Bram Moolenaar15bfa092008-07-24 16:45:38 +00007244# ifdef FEAT_AUTOCMD
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00007245 if (
Bram Moolenaar15bfa092008-07-24 16:45:38 +00007246# ifdef FEAT_GUI
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00007247 !gui.in_use &&
Bram Moolenaar15bfa092008-07-24 16:45:38 +00007248# endif
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00007249 au_has_group((char_u *)"FileExplorer"))
7250 {
7251 /* No browsing supported but we do have the file explorer:
7252 * Edit the directory. */
7253 if (*eap->arg == NUL || !mch_isdir(eap->arg))
7254 eap->arg = (char_u *)".";
7255 }
7256 else
Bram Moolenaar15bfa092008-07-24 16:45:38 +00007257# endif
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00007258 {
7259 fname = do_browse(0, (char_u *)_("Edit File in new window"),
Bram Moolenaar071d4272004-06-13 20:20:40 +00007260 eap->arg, NULL, NULL, NULL, curbuf);
Bram Moolenaar1d94f9b2005-08-04 21:29:45 +00007261 if (fname == NULL)
7262 goto theend;
7263 eap->arg = fname;
7264 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007265 }
7266 cmdmod.browse = FALSE; /* Don't browse again in do_ecmd(). */
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007267# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007268
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00007269 /*
7270 * Either open new tab page or split the window.
7271 */
7272 if (eap->cmdidx == CMD_tabedit
7273 || eap->cmdidx == CMD_tabfind
7274 || eap->cmdidx == CMD_tabnew)
7275 {
Bram Moolenaar8dff8182006-04-06 20:18:50 +00007276 if (win_new_tabpage(cmdmod.tab != 0 ? cmdmod.tab
7277 : eap->addr_count == 0 ? 0
7278 : (int)eap->line2 + 1) != FAIL)
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00007279 {
Bram Moolenaard2b66012008-01-09 19:30:36 +00007280 do_exedit(eap, old_curwin);
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00007281
7282 /* set the alternate buffer for the window we came from */
7283 if (curwin != old_curwin
7284 && win_valid(old_curwin)
7285 && old_curwin->w_buffer != curbuf
7286 && !cmdmod.keepalt)
7287 old_curwin->w_alt_fnum = curbuf->b_fnum;
7288 }
7289 }
7290 else if (win_split(eap->addr_count > 0 ? (int)eap->line2 : 0,
Bram Moolenaar071d4272004-06-13 20:20:40 +00007291 *eap->cmd == 'v' ? WSP_VERT : 0) != FAIL)
7292 {
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007293# ifdef FEAT_SCROLLBIND
Bram Moolenaar071d4272004-06-13 20:20:40 +00007294 /* Reset 'scrollbind' when editing another file, but keep it when
7295 * doing ":split" without arguments. */
7296 if (*eap->arg != NUL
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007297# ifdef FEAT_BROWSE
Bram Moolenaar071d4272004-06-13 20:20:40 +00007298 || cmdmod.browse
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007299# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007300 )
7301 curwin->w_p_scb = FALSE;
7302 else
7303 do_check_scrollbind(FALSE);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007304# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007305 do_exedit(eap, old_curwin);
7306 }
7307
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007308# ifdef FEAT_BROWSE
Bram Moolenaar071d4272004-06-13 20:20:40 +00007309 cmdmod.browse = browse_flag;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007310# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007311
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007312# if defined(FEAT_SEARCHPATH) || defined(FEAT_BROWSE)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007313theend:
7314 vim_free(fname);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007315# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007316}
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007317
7318/*
Bram Moolenaar80a94a52006-02-23 21:26:58 +00007319 * Open a new tab page.
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007320 */
7321 void
Bram Moolenaar80a94a52006-02-23 21:26:58 +00007322tabpage_new()
7323{
7324 exarg_T ea;
7325
7326 vim_memset(&ea, 0, sizeof(ea));
7327 ea.cmdidx = CMD_tabnew;
7328 ea.cmd = (char_u *)"tabn";
7329 ea.arg = (char_u *)"";
7330 ex_splitview(&ea);
7331}
7332
7333/*
7334 * :tabnext command
7335 */
7336 static void
7337ex_tabnext(eap)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007338 exarg_T *eap;
7339{
Bram Moolenaar32466aa2006-02-24 23:53:04 +00007340 switch (eap->cmdidx)
7341 {
7342 case CMD_tabfirst:
7343 case CMD_tabrewind:
7344 goto_tabpage(1);
7345 break;
7346 case CMD_tablast:
7347 goto_tabpage(9999);
7348 break;
7349 case CMD_tabprevious:
7350 case CMD_tabNext:
7351 goto_tabpage(eap->addr_count == 0 ? -1 : -(int)eap->line2);
7352 break;
7353 default: /* CMD_tabnext */
7354 goto_tabpage(eap->addr_count == 0 ? 0 : (int)eap->line2);
7355 break;
7356 }
Bram Moolenaar80a94a52006-02-23 21:26:58 +00007357}
7358
7359/*
7360 * :tabmove command
7361 */
7362 static void
7363ex_tabmove(eap)
7364 exarg_T *eap;
7365{
7366 tabpage_move(eap->addr_count == 0 ? 9999 : (int)eap->line2);
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007367}
7368
7369/*
7370 * :tabs command: List tabs and their contents.
7371 */
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007372 static void
7373ex_tabs(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +00007374 exarg_T *eap UNUSED;
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007375{
7376 tabpage_T *tp;
7377 win_T *wp;
7378 int tabcount = 1;
7379
7380 msg_start();
7381 msg_scroll = TRUE;
7382 for (tp = first_tabpage; tp != NULL && !got_int; tp = tp->tp_next)
7383 {
7384 msg_putchar('\n');
7385 vim_snprintf((char *)IObuff, IOSIZE, _("Tab page %d"), tabcount++);
7386 msg_outtrans_attr(IObuff, hl_attr(HLF_T));
7387 out_flush(); /* output one line at a time */
7388 ui_breakcheck();
7389
Bram Moolenaar030f0df2006-02-21 22:02:53 +00007390 if (tp == curtab)
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007391 wp = firstwin;
7392 else
7393 wp = tp->tp_firstwin;
7394 for ( ; wp != NULL && !got_int; wp = wp->w_next)
7395 {
Bram Moolenaar80a94a52006-02-23 21:26:58 +00007396 msg_putchar('\n');
7397 msg_putchar(wp == curwin ? '>' : ' ');
7398 msg_putchar(' ');
Bram Moolenaar49d7bf12006-02-17 21:45:41 +00007399 msg_putchar(bufIsChanged(wp->w_buffer) ? '+' : ' ');
7400 msg_putchar(' ');
Bram Moolenaar1d2ba7f2006-02-14 22:29:30 +00007401 if (buf_spname(wp->w_buffer) != NULL)
7402 STRCPY(IObuff, buf_spname(wp->w_buffer));
7403 else
7404 home_replace(wp->w_buffer, wp->w_buffer->b_fname,
7405 IObuff, IOSIZE, TRUE);
7406 msg_outtrans(IObuff);
7407 out_flush(); /* output one line at a time */
7408 ui_breakcheck();
7409 }
7410 }
7411}
7412
7413#endif /* FEAT_WINDOWS */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007414
7415/*
7416 * ":mode": Set screen mode.
7417 * If no argument given, just get the screen size and redraw.
7418 */
7419 static void
7420ex_mode(eap)
7421 exarg_T *eap;
7422{
7423 if (*eap->arg == NUL)
7424 shell_resized();
7425 else
7426 mch_screenmode(eap->arg);
7427}
7428
7429#ifdef FEAT_WINDOWS
7430/*
7431 * ":resize".
7432 * set, increment or decrement current window height
7433 */
7434 static void
7435ex_resize(eap)
7436 exarg_T *eap;
7437{
7438 int n;
7439 win_T *wp = curwin;
7440
7441 if (eap->addr_count > 0)
7442 {
7443 n = eap->line2;
7444 for (wp = firstwin; wp->w_next != NULL && --n > 0; wp = wp->w_next)
7445 ;
7446 }
7447
7448#ifdef FEAT_GUI
7449 need_mouse_correct = TRUE;
7450#endif
7451 n = atol((char *)eap->arg);
7452#ifdef FEAT_VERTSPLIT
7453 if (cmdmod.split & WSP_VERT)
7454 {
7455 if (*eap->arg == '-' || *eap->arg == '+')
7456 n += W_WIDTH(curwin);
7457 else if (n == 0 && eap->arg[0] == NUL) /* default is very wide */
7458 n = 9999;
7459 win_setwidth_win((int)n, wp);
7460 }
7461 else
7462#endif
7463 {
7464 if (*eap->arg == '-' || *eap->arg == '+')
7465 n += curwin->w_height;
7466 else if (n == 0 && eap->arg[0] == NUL) /* default is very wide */
7467 n = 9999;
7468 win_setheight_win((int)n, wp);
7469 }
7470}
7471#endif
7472
7473/*
7474 * ":find [+command] <file>" command.
7475 */
7476 static void
7477ex_find(eap)
7478 exarg_T *eap;
7479{
7480#ifdef FEAT_SEARCHPATH
7481 char_u *fname;
7482 int count;
7483
7484 fname = find_file_in_path(eap->arg, (int)STRLEN(eap->arg), FNAME_MESS,
7485 TRUE, curbuf->b_ffname);
7486 if (eap->addr_count > 0)
7487 {
7488 /* Repeat finding the file "count" times. This matters when it
7489 * appears several times in the path. */
7490 count = eap->line2;
7491 while (fname != NULL && --count > 0)
7492 {
7493 vim_free(fname);
7494 fname = find_file_in_path(NULL, 0, FNAME_MESS,
7495 FALSE, curbuf->b_ffname);
7496 }
7497 }
7498
7499 if (fname != NULL)
7500 {
7501 eap->arg = fname;
7502#endif
7503 do_exedit(eap, NULL);
7504#ifdef FEAT_SEARCHPATH
7505 vim_free(fname);
7506 }
7507#endif
7508}
7509
7510/*
Bram Moolenaardf177f62005-02-22 08:39:57 +00007511 * ":open" simulation: for now just work like ":visual".
7512 */
7513 static void
7514ex_open(eap)
7515 exarg_T *eap;
7516{
7517 regmatch_T regmatch;
7518 char_u *p;
7519
7520 curwin->w_cursor.lnum = eap->line2;
7521 beginline(BL_SOL | BL_FIX);
7522 if (*eap->arg == '/')
7523 {
7524 /* ":open /pattern/": put cursor in column found with pattern */
7525 ++eap->arg;
7526 p = skip_regexp(eap->arg, '/', p_magic, NULL);
7527 *p = NUL;
7528 regmatch.regprog = vim_regcomp(eap->arg, p_magic ? RE_MAGIC : 0);
7529 if (regmatch.regprog != NULL)
7530 {
7531 regmatch.rm_ic = p_ic;
7532 p = ml_get_curline();
7533 if (vim_regexec(&regmatch, p, (colnr_T)0))
Bram Moolenaara93fa7e2006-04-17 22:14:47 +00007534 curwin->w_cursor.col = (colnr_T)(regmatch.startp[0] - p);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007535 else
7536 EMSG(_(e_nomatch));
7537 vim_free(regmatch.regprog);
7538 }
7539 /* Move to the NUL, ignore any other arguments. */
7540 eap->arg += STRLEN(eap->arg);
7541 }
7542 check_cursor();
7543
7544 eap->cmdidx = CMD_visual;
7545 do_exedit(eap, NULL);
7546}
7547
7548/*
7549 * ":edit", ":badd", ":visual".
Bram Moolenaar071d4272004-06-13 20:20:40 +00007550 */
7551 static void
7552ex_edit(eap)
7553 exarg_T *eap;
7554{
7555 do_exedit(eap, NULL);
7556}
7557
7558/*
7559 * ":edit <file>" command and alikes.
7560 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007561 void
7562do_exedit(eap, old_curwin)
7563 exarg_T *eap;
7564 win_T *old_curwin; /* curwin before doing a split or NULL */
7565{
7566 int n;
7567#ifdef FEAT_WINDOWS
7568 int need_hide;
7569#endif
Bram Moolenaardf177f62005-02-22 08:39:57 +00007570 int exmode_was = exmode_active;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007571
7572 /*
7573 * ":vi" command ends Ex mode.
7574 */
7575 if (exmode_active && (eap->cmdidx == CMD_visual
7576 || eap->cmdidx == CMD_view))
7577 {
7578 exmode_active = FALSE;
7579 if (*eap->arg == NUL)
Bram Moolenaardf177f62005-02-22 08:39:57 +00007580 {
7581 /* Special case: ":global/pat/visual\NLvi-commands" */
7582 if (global_busy)
7583 {
7584 int rd = RedrawingDisabled;
7585 int nwr = no_wait_return;
7586 int ms = msg_scroll;
7587#ifdef FEAT_GUI
7588 int he = hold_gui_events;
7589#endif
7590
7591 if (eap->nextcmd != NULL)
7592 {
7593 stuffReadbuff(eap->nextcmd);
7594 eap->nextcmd = NULL;
7595 }
7596
7597 if (exmode_was != EXMODE_VIM)
7598 settmode(TMODE_RAW);
7599 RedrawingDisabled = 0;
7600 no_wait_return = 0;
7601 need_wait_return = FALSE;
7602 msg_scroll = 0;
7603#ifdef FEAT_GUI
7604 hold_gui_events = 0;
7605#endif
7606 must_redraw = CLEAR;
7607
7608 main_loop(FALSE, TRUE);
7609
7610 RedrawingDisabled = rd;
7611 no_wait_return = nwr;
7612 msg_scroll = ms;
7613#ifdef FEAT_GUI
7614 hold_gui_events = he;
7615#endif
7616 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007617 return;
Bram Moolenaardf177f62005-02-22 08:39:57 +00007618 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007619 }
7620
7621 if ((eap->cmdidx == CMD_new
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00007622 || eap->cmdidx == CMD_tabnew
7623 || eap->cmdidx == CMD_tabedit
Bram Moolenaar071d4272004-06-13 20:20:40 +00007624#ifdef FEAT_VERTSPLIT
7625 || eap->cmdidx == CMD_vnew
7626#endif
7627 ) && *eap->arg == NUL)
7628 {
Bram Moolenaar2a0449d2006-02-20 21:27:21 +00007629 /* ":new" or ":tabnew" without argument: edit an new empty buffer */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007630 setpcmark();
7631 (void)do_ecmd(0, NULL, NULL, eap, ECMD_ONE,
Bram Moolenaar701f7af2008-11-15 13:12:07 +00007632 ECMD_HIDE + (eap->forceit ? ECMD_FORCEIT : 0),
7633 old_curwin == NULL ? curwin : NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007634 }
7635 else if ((eap->cmdidx != CMD_split
7636#ifdef FEAT_VERTSPLIT
7637 && eap->cmdidx != CMD_vsplit
7638#endif
7639 )
7640 || *eap->arg != NUL
7641#ifdef FEAT_BROWSE
7642 || cmdmod.browse
7643#endif
7644 )
7645 {
Bram Moolenaar5555acc2006-04-07 21:33:12 +00007646#ifdef FEAT_AUTOCMD
7647 /* Can't edit another file when "curbuf_lock" is set. Only ":edit"
7648 * can bring us here, others are stopped earlier. */
7649 if (*eap->arg != NUL && curbuf_locked())
7650 return;
7651#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007652 n = readonlymode;
7653 if (eap->cmdidx == CMD_view || eap->cmdidx == CMD_sview)
7654 readonlymode = TRUE;
7655 else if (eap->cmdidx == CMD_enew)
7656 readonlymode = FALSE; /* 'readonly' doesn't make sense in an
7657 empty buffer */
7658 setpcmark();
7659 if (do_ecmd(0, (eap->cmdidx == CMD_enew ? NULL : eap->arg),
7660 NULL, eap,
7661 /* ":edit" goes to first line if Vi compatible */
7662 (*eap->arg == NUL && eap->do_ecmd_lnum == 0
7663 && vim_strchr(p_cpo, CPO_GOTO1) != NULL)
7664 ? ECMD_ONE : eap->do_ecmd_lnum,
7665 (P_HID(curbuf) ? ECMD_HIDE : 0)
7666 + (eap->forceit ? ECMD_FORCEIT : 0)
7667#ifdef FEAT_LISTCMDS
7668 + (eap->cmdidx == CMD_badd ? ECMD_ADDBUF : 0 )
7669#endif
Bram Moolenaar701f7af2008-11-15 13:12:07 +00007670 , old_curwin == NULL ? curwin : NULL) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007671 {
7672 /* Editing the file failed. If the window was split, close it. */
7673#ifdef FEAT_WINDOWS
7674 if (old_curwin != NULL)
7675 {
7676 need_hide = (curbufIsChanged() && curbuf->b_nwindows <= 1);
7677 if (!need_hide || P_HID(curbuf))
7678 {
Bram Moolenaarc0197e22004-09-13 20:26:32 +00007679# if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
7680 cleanup_T cs;
7681
7682 /* Reset the error/interrupt/exception state here so that
7683 * aborting() returns FALSE when closing a window. */
7684 enter_cleanup(&cs);
7685# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007686# ifdef FEAT_GUI
7687 need_mouse_correct = TRUE;
7688# endif
7689 win_close(curwin, !need_hide && !P_HID(curbuf));
Bram Moolenaarc0197e22004-09-13 20:26:32 +00007690
7691# if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
7692 /* Restore the error/interrupt/exception state if not
7693 * discarded by a new aborting error, interrupt, or
7694 * uncaught exception. */
7695 leave_cleanup(&cs);
7696# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00007697 }
7698 }
7699#endif
7700 }
7701 else if (readonlymode && curbuf->b_nwindows == 1)
7702 {
7703 /* When editing an already visited buffer, 'readonly' won't be set
7704 * but the previous value is kept. With ":view" and ":sview" we
7705 * want the file to be readonly, except when another window is
7706 * editing the same buffer. */
7707 curbuf->b_p_ro = TRUE;
7708 }
7709 readonlymode = n;
7710 }
7711 else
7712 {
7713 if (eap->do_ecmd_cmd != NULL)
7714 do_cmdline_cmd(eap->do_ecmd_cmd);
7715#ifdef FEAT_TITLE
7716 n = curwin->w_arg_idx_invalid;
7717#endif
7718 check_arg_idx(curwin);
7719#ifdef FEAT_TITLE
7720 if (n != curwin->w_arg_idx_invalid)
7721 maketitle();
7722#endif
7723 }
7724
7725#ifdef FEAT_WINDOWS
7726 /*
7727 * if ":split file" worked, set alternate file name in old window to new
7728 * file
7729 */
7730 if (old_curwin != NULL
7731 && *eap->arg != NUL
7732 && curwin != old_curwin
7733 && win_valid(old_curwin)
Bram Moolenaard4755bb2004-09-02 19:12:26 +00007734 && old_curwin->w_buffer != curbuf
7735 && !cmdmod.keepalt)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007736 old_curwin->w_alt_fnum = curbuf->b_fnum;
7737#endif
7738
7739 ex_no_reprint = TRUE;
7740}
7741
7742#ifndef FEAT_GUI
7743/*
7744 * ":gui" and ":gvim" when there is no GUI.
7745 */
7746 static void
7747ex_nogui(eap)
7748 exarg_T *eap;
7749{
7750 eap->errmsg = e_nogvim;
7751}
7752#endif
7753
7754#if defined(FEAT_GUI_W32) && defined(FEAT_MENU) && defined(FEAT_TEAROFF)
7755 static void
7756ex_tearoff(eap)
7757 exarg_T *eap;
7758{
7759 gui_make_tearoff(eap->arg);
7760}
7761#endif
7762
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +00007763#if (defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_GTK)) && defined(FEAT_MENU)
Bram Moolenaar071d4272004-06-13 20:20:40 +00007764 static void
7765ex_popup(eap)
7766 exarg_T *eap;
7767{
Bram Moolenaar97409f12005-07-08 22:17:29 +00007768 gui_make_popup(eap->arg, eap->forceit);
Bram Moolenaar071d4272004-06-13 20:20:40 +00007769}
7770#endif
7771
Bram Moolenaar071d4272004-06-13 20:20:40 +00007772 static void
7773ex_swapname(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +00007774 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007775{
7776 if (curbuf->b_ml.ml_mfp == NULL || curbuf->b_ml.ml_mfp->mf_fname == NULL)
7777 MSG(_("No swap file"));
7778 else
7779 msg(curbuf->b_ml.ml_mfp->mf_fname);
7780}
7781
7782/*
7783 * ":syncbind" forces all 'scrollbind' windows to have the same relative
7784 * offset.
7785 * (1998-11-02 16:21:01 R. Edward Ralston <eralston@computer.org>)
7786 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00007787 static void
7788ex_syncbind(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +00007789 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007790{
7791#ifdef FEAT_SCROLLBIND
7792 win_T *wp;
7793 long topline;
7794 long y;
7795 linenr_T old_linenr = curwin->w_cursor.lnum;
7796
7797 setpcmark();
7798
7799 /*
7800 * determine max topline
7801 */
7802 if (curwin->w_p_scb)
7803 {
7804 topline = curwin->w_topline;
7805 for (wp = firstwin; wp; wp = wp->w_next)
7806 {
7807 if (wp->w_p_scb && wp->w_buffer)
7808 {
7809 y = wp->w_buffer->b_ml.ml_line_count - p_so;
7810 if (topline > y)
7811 topline = y;
7812 }
7813 }
7814 if (topline < 1)
7815 topline = 1;
7816 }
7817 else
7818 {
7819 topline = 1;
7820 }
7821
7822
7823 /*
7824 * set all scrollbind windows to the same topline
7825 */
7826 wp = curwin;
7827 for (curwin = firstwin; curwin; curwin = curwin->w_next)
7828 {
7829 if (curwin->w_p_scb)
7830 {
7831 y = topline - curwin->w_topline;
7832 if (y > 0)
7833 scrollup(y, TRUE);
7834 else
7835 scrolldown(-y, TRUE);
7836 curwin->w_scbind_pos = topline;
7837 redraw_later(VALID);
7838 cursor_correct();
7839#ifdef FEAT_WINDOWS
7840 curwin->w_redr_status = TRUE;
7841#endif
7842 }
7843 }
7844 curwin = wp;
7845 if (curwin->w_p_scb)
7846 {
7847 did_syncbind = TRUE;
7848 checkpcmark();
7849 if (old_linenr != curwin->w_cursor.lnum)
7850 {
7851 char_u ctrl_o[2];
7852
7853 ctrl_o[0] = Ctrl_O;
7854 ctrl_o[1] = 0;
7855 ins_typebuf(ctrl_o, REMAP_NONE, 0, TRUE, FALSE);
7856 }
7857 }
7858#endif
7859}
7860
7861
7862 static void
7863ex_read(eap)
7864 exarg_T *eap;
7865{
Bram Moolenaardf177f62005-02-22 08:39:57 +00007866 int i;
7867 int empty = (curbuf->b_ml.ml_flags & ML_EMPTY);
7868 linenr_T lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +00007869
7870 if (eap->usefilter) /* :r!cmd */
7871 do_bang(1, eap, FALSE, FALSE, TRUE);
7872 else
7873 {
7874 if (u_save(eap->line2, (linenr_T)(eap->line2 + 1)) == FAIL)
7875 return;
7876
7877#ifdef FEAT_BROWSE
7878 if (cmdmod.browse)
7879 {
7880 char_u *browseFile;
7881
Bram Moolenaar7171abe2004-10-11 10:06:20 +00007882 browseFile = do_browse(0, (char_u *)_("Append File"), eap->arg,
Bram Moolenaar071d4272004-06-13 20:20:40 +00007883 NULL, NULL, NULL, curbuf);
7884 if (browseFile != NULL)
7885 {
7886 i = readfile(browseFile, NULL,
7887 eap->line2, (linenr_T)0, (linenr_T)MAXLNUM, eap, 0);
7888 vim_free(browseFile);
7889 }
7890 else
7891 i = OK;
7892 }
7893 else
7894#endif
7895 if (*eap->arg == NUL)
7896 {
7897 if (check_fname() == FAIL) /* check for no file name */
7898 return;
7899 i = readfile(curbuf->b_ffname, curbuf->b_fname,
7900 eap->line2, (linenr_T)0, (linenr_T)MAXLNUM, eap, 0);
7901 }
7902 else
7903 {
7904 if (vim_strchr(p_cpo, CPO_ALTREAD) != NULL)
7905 (void)setaltfname(eap->arg, eap->arg, (linenr_T)1);
7906 i = readfile(eap->arg, NULL,
7907 eap->line2, (linenr_T)0, (linenr_T)MAXLNUM, eap, 0);
7908
7909 }
7910 if (i == FAIL)
7911 {
7912#if defined(FEAT_AUTOCMD) && defined(FEAT_EVAL)
7913 if (!aborting())
7914#endif
7915 EMSG2(_(e_notopen), eap->arg);
7916 }
7917 else
Bram Moolenaardf177f62005-02-22 08:39:57 +00007918 {
7919 if (empty && exmode_active)
7920 {
7921 /* Delete the empty line that remains. Historically ex does
7922 * this but vi doesn't. */
7923 if (eap->line2 == 0)
7924 lnum = curbuf->b_ml.ml_line_count;
7925 else
7926 lnum = 1;
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +00007927 if (*ml_get(lnum) == NUL && u_savedel(lnum, 1L) == OK)
Bram Moolenaardf177f62005-02-22 08:39:57 +00007928 {
7929 ml_delete(lnum, FALSE);
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +00007930 if (curwin->w_cursor.lnum > 1
7931 && curwin->w_cursor.lnum >= lnum)
Bram Moolenaardf177f62005-02-22 08:39:57 +00007932 --curwin->w_cursor.lnum;
Bram Moolenaarcdcaa582009-07-09 18:06:49 +00007933 deleted_lines_mark(lnum, 1L);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007934 }
7935 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007936 redraw_curbuf_later(VALID);
Bram Moolenaardf177f62005-02-22 08:39:57 +00007937 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00007938 }
7939}
7940
Bram Moolenaarea408852005-06-25 22:49:46 +00007941static char_u *prev_dir = NULL;
7942
7943#if defined(EXITFREE) || defined(PROTO)
7944 void
7945free_cd_dir()
7946{
7947 vim_free(prev_dir);
Bram Moolenaara0174af2008-01-02 20:08:25 +00007948 prev_dir = NULL;
Bram Moolenaar60f39ae2009-03-11 14:10:38 +00007949
7950 vim_free(globaldir);
7951 globaldir = NULL;
Bram Moolenaarea408852005-06-25 22:49:46 +00007952}
7953#endif
7954
7955
Bram Moolenaar071d4272004-06-13 20:20:40 +00007956/*
7957 * ":cd", ":lcd", ":chdir" and ":lchdir".
7958 */
Bram Moolenaard089d9b2007-09-30 12:02:55 +00007959 void
Bram Moolenaar071d4272004-06-13 20:20:40 +00007960ex_cd(eap)
7961 exarg_T *eap;
7962{
Bram Moolenaar071d4272004-06-13 20:20:40 +00007963 char_u *new_dir;
7964 char_u *tofree;
7965
7966 new_dir = eap->arg;
7967#if !defined(UNIX) && !defined(VMS)
7968 /* for non-UNIX ":cd" means: print current directory */
7969 if (*new_dir == NUL)
7970 ex_pwd(NULL);
7971 else
7972#endif
7973 {
Bram Moolenaar8e8fe9b2009-03-11 14:37:32 +00007974#ifdef FEAT_AUTOCMD
7975 if (allbuf_locked())
7976 return;
7977#endif
Bram Moolenaardf177f62005-02-22 08:39:57 +00007978 if (vim_strchr(p_cpo, CPO_CHDIR) != NULL && curbufIsChanged()
7979 && !eap->forceit)
7980 {
Bram Moolenaar81870892007-11-11 18:17:28 +00007981 EMSG(_("E747: Cannot change directory, buffer is modified (add ! to override)"));
Bram Moolenaardf177f62005-02-22 08:39:57 +00007982 return;
7983 }
7984
Bram Moolenaar071d4272004-06-13 20:20:40 +00007985 /* ":cd -": Change to previous directory */
7986 if (STRCMP(new_dir, "-") == 0)
7987 {
7988 if (prev_dir == NULL)
7989 {
7990 EMSG(_("E186: No previous directory"));
7991 return;
7992 }
7993 new_dir = prev_dir;
7994 }
7995
7996 /* Save current directory for next ":cd -" */
7997 tofree = prev_dir;
7998 if (mch_dirname(NameBuff, MAXPATHL) == OK)
7999 prev_dir = vim_strsave(NameBuff);
8000 else
8001 prev_dir = NULL;
8002
8003#if defined(UNIX) || defined(VMS)
8004 /* for UNIX ":cd" means: go to home directory */
8005 if (*new_dir == NUL)
8006 {
8007 /* use NameBuff for home directory name */
8008# ifdef VMS
8009 char_u *p;
8010
8011 p = mch_getenv((char_u *)"SYS$LOGIN");
8012 if (p == NULL || *p == NUL) /* empty is the same as not set */
8013 NameBuff[0] = NUL;
8014 else
Bram Moolenaarb6356332005-07-18 21:40:44 +00008015 vim_strncpy(NameBuff, p, MAXPATHL - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008016# else
8017 expand_env((char_u *)"$HOME", NameBuff, MAXPATHL);
8018# endif
8019 new_dir = NameBuff;
8020 }
8021#endif
8022 if (new_dir == NULL || vim_chdir(new_dir))
8023 EMSG(_(e_failed));
8024 else
8025 {
8026 vim_free(curwin->w_localdir);
8027 if (eap->cmdidx == CMD_lcd || eap->cmdidx == CMD_lchdir)
8028 {
8029 /* If still in global directory, need to remember current
8030 * directory as global directory. */
8031 if (globaldir == NULL && prev_dir != NULL)
8032 globaldir = vim_strsave(prev_dir);
8033 /* Remember this local directory for the window. */
8034 if (mch_dirname(NameBuff, MAXPATHL) == OK)
8035 curwin->w_localdir = vim_strsave(NameBuff);
8036 }
8037 else
8038 {
8039 /* We are now in the global directory, no need to remember its
8040 * name. */
8041 vim_free(globaldir);
8042 globaldir = NULL;
8043 curwin->w_localdir = NULL;
8044 }
8045
8046 shorten_fnames(TRUE);
8047
8048 /* Echo the new current directory if the command was typed. */
Bram Moolenaarfcfbc672009-07-09 18:13:49 +00008049 if (KeyTyped || p_verbose >= 5)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008050 ex_pwd(eap);
8051 }
8052 vim_free(tofree);
8053 }
8054}
8055
8056/*
8057 * ":pwd".
8058 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00008059 static void
8060ex_pwd(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +00008061 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008062{
8063 if (mch_dirname(NameBuff, MAXPATHL) == OK)
8064 {
8065#ifdef BACKSLASH_IN_FILENAME
8066 slash_adjust(NameBuff);
8067#endif
8068 msg(NameBuff);
8069 }
8070 else
8071 EMSG(_("E187: Unknown"));
8072}
8073
8074/*
8075 * ":=".
8076 */
8077 static void
8078ex_equal(eap)
8079 exarg_T *eap;
8080{
8081 smsg((char_u *)"%ld", (long)eap->line2);
Bram Moolenaardf177f62005-02-22 08:39:57 +00008082 ex_may_print(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008083}
8084
8085 static void
8086ex_sleep(eap)
8087 exarg_T *eap;
8088{
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00008089 int n;
8090 long len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008091
8092 if (cursor_valid())
8093 {
8094 n = W_WINROW(curwin) + curwin->w_wrow - msg_scrolled;
8095 if (n >= 0)
8096 windgoto((int)n, curwin->w_wcol);
8097 }
Bram Moolenaar402d2fe2005-04-15 21:00:38 +00008098
8099 len = eap->line2;
8100 switch (*eap->arg)
8101 {
8102 case 'm': break;
8103 case NUL: len *= 1000L; break;
8104 default: EMSG2(_(e_invarg2), eap->arg); return;
8105 }
8106 do_sleep(len);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008107}
8108
8109/*
8110 * Sleep for "msec" milliseconds, but keep checking for a CTRL-C every second.
8111 */
8112 void
8113do_sleep(msec)
8114 long msec;
8115{
8116 long done;
8117
8118 cursor_on();
8119 out_flush();
8120 for (done = 0; !got_int && done < msec; done += 1000L)
8121 {
8122 ui_delay(msec - done > 1000L ? 1000L : msec - done, TRUE);
8123 ui_breakcheck();
8124 }
8125}
8126
8127 static void
8128do_exmap(eap, isabbrev)
8129 exarg_T *eap;
8130 int isabbrev;
8131{
8132 int mode;
8133 char_u *cmdp;
8134
8135 cmdp = eap->cmd;
8136 mode = get_map_mode(&cmdp, eap->forceit || isabbrev);
8137
8138 switch (do_map((*cmdp == 'n') ? 2 : (*cmdp == 'u'),
8139 eap->arg, mode, isabbrev))
8140 {
8141 case 1: EMSG(_(e_invarg));
8142 break;
8143 case 2: EMSG(isabbrev ? _(e_noabbr) : _(e_nomap));
8144 break;
8145 }
8146}
8147
8148/*
8149 * ":winsize" command (obsolete).
8150 */
8151 static void
8152ex_winsize(eap)
8153 exarg_T *eap;
8154{
8155 int w, h;
8156 char_u *arg = eap->arg;
8157 char_u *p;
8158
8159 w = getdigits(&arg);
8160 arg = skipwhite(arg);
8161 p = arg;
8162 h = getdigits(&arg);
8163 if (*p != NUL && *arg == NUL)
8164 set_shellsize(w, h, TRUE);
8165 else
8166 EMSG(_("E465: :winsize requires two number arguments"));
8167}
8168
8169#ifdef FEAT_WINDOWS
8170 static void
8171ex_wincmd(eap)
8172 exarg_T *eap;
8173{
8174 int xchar = NUL;
8175 char_u *p;
8176
8177 if (*eap->arg == 'g' || *eap->arg == Ctrl_G)
8178 {
8179 /* CTRL-W g and CTRL-W CTRL-G have an extra command character */
8180 if (eap->arg[1] == NUL)
8181 {
8182 EMSG(_(e_invarg));
8183 return;
8184 }
8185 xchar = eap->arg[1];
8186 p = eap->arg + 2;
8187 }
8188 else
8189 p = eap->arg + 1;
8190
8191 eap->nextcmd = check_nextcmd(p);
8192 p = skipwhite(p);
8193 if (*p != NUL && *p != '"' && eap->nextcmd == NULL)
8194 EMSG(_(e_invarg));
8195 else
8196 {
8197 /* Pass flags on for ":vertical wincmd ]". */
8198 postponed_split_flags = cmdmod.split;
Bram Moolenaard326ce82007-03-11 14:48:29 +00008199 postponed_split_tab = cmdmod.tab;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008200 do_window(*eap->arg, eap->addr_count > 0 ? eap->line2 : 0L, xchar);
8201 postponed_split_flags = 0;
Bram Moolenaard326ce82007-03-11 14:48:29 +00008202 postponed_split_tab = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008203 }
8204}
8205#endif
8206
Bram Moolenaar843ee412004-06-30 16:16:41 +00008207#if defined(FEAT_GUI) || defined(UNIX) || defined(VMS) || defined(MSWIN)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008208/*
8209 * ":winpos".
8210 */
8211 static void
8212ex_winpos(eap)
8213 exarg_T *eap;
8214{
8215 int x, y;
8216 char_u *arg = eap->arg;
8217 char_u *p;
8218
8219 if (*arg == NUL)
8220 {
Bram Moolenaar843ee412004-06-30 16:16:41 +00008221# if defined(FEAT_GUI) || defined(MSWIN)
8222# ifdef FEAT_GUI
Bram Moolenaar071d4272004-06-13 20:20:40 +00008223 if (gui.in_use && gui_mch_get_winpos(&x, &y) != FAIL)
Bram Moolenaar843ee412004-06-30 16:16:41 +00008224# else
8225 if (mch_get_winpos(&x, &y) != FAIL)
8226# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008227 {
8228 sprintf((char *)IObuff, _("Window position: X %d, Y %d"), x, y);
8229 msg(IObuff);
8230 }
8231 else
8232# endif
8233 EMSG(_("E188: Obtaining window position not implemented for this platform"));
8234 }
8235 else
8236 {
8237 x = getdigits(&arg);
8238 arg = skipwhite(arg);
8239 p = arg;
8240 y = getdigits(&arg);
8241 if (*p == NUL || *arg != NUL)
8242 {
8243 EMSG(_("E466: :winpos requires two number arguments"));
8244 return;
8245 }
8246# ifdef FEAT_GUI
8247 if (gui.in_use)
8248 gui_mch_set_winpos(x, y);
8249 else if (gui.starting)
8250 {
8251 /* Remember the coordinates for when the window is opened. */
8252 gui_win_x = x;
8253 gui_win_y = y;
8254 }
8255# ifdef HAVE_TGETENT
8256 else
8257# endif
Bram Moolenaar843ee412004-06-30 16:16:41 +00008258# else
8259# ifdef MSWIN
8260 mch_set_winpos(x, y);
8261# endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00008262# endif
8263# ifdef HAVE_TGETENT
8264 if (*T_CWP)
8265 term_set_winpos(x, y);
8266# endif
8267 }
8268}
8269#endif
8270
8271/*
8272 * Handle command that work like operators: ":delete", ":yank", ":>" and ":<".
8273 */
8274 static void
8275ex_operators(eap)
8276 exarg_T *eap;
8277{
8278 oparg_T oa;
8279
8280 clear_oparg(&oa);
8281 oa.regname = eap->regname;
8282 oa.start.lnum = eap->line1;
8283 oa.end.lnum = eap->line2;
8284 oa.line_count = eap->line2 - eap->line1 + 1;
8285 oa.motion_type = MLINE;
8286#ifdef FEAT_VIRTUALEDIT
8287 virtual_op = FALSE;
8288#endif
8289 if (eap->cmdidx != CMD_yank) /* position cursor for undo */
8290 {
8291 setpcmark();
8292 curwin->w_cursor.lnum = eap->line1;
8293 beginline(BL_SOL | BL_FIX);
8294 }
8295
8296 switch (eap->cmdidx)
8297 {
8298 case CMD_delete:
8299 oa.op_type = OP_DELETE;
8300 op_delete(&oa);
8301 break;
8302
8303 case CMD_yank:
8304 oa.op_type = OP_YANK;
8305 (void)op_yank(&oa, FALSE, TRUE);
8306 break;
8307
8308 default: /* CMD_rshift or CMD_lshift */
8309 if ((eap->cmdidx == CMD_rshift)
8310#ifdef FEAT_RIGHTLEFT
8311 ^ curwin->w_p_rl
8312#endif
8313 )
8314 oa.op_type = OP_RSHIFT;
8315 else
8316 oa.op_type = OP_LSHIFT;
8317 op_shift(&oa, FALSE, eap->amount);
8318 break;
8319 }
8320#ifdef FEAT_VIRTUALEDIT
8321 virtual_op = MAYBE;
8322#endif
Bram Moolenaardf177f62005-02-22 08:39:57 +00008323 ex_may_print(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008324}
8325
8326/*
8327 * ":put".
8328 */
8329 static void
8330ex_put(eap)
8331 exarg_T *eap;
8332{
8333 /* ":0put" works like ":1put!". */
8334 if (eap->line2 == 0)
8335 {
8336 eap->line2 = 1;
8337 eap->forceit = TRUE;
8338 }
8339 curwin->w_cursor.lnum = eap->line2;
Bram Moolenaardf177f62005-02-22 08:39:57 +00008340 do_put(eap->regname, eap->forceit ? BACKWARD : FORWARD, 1L,
8341 PUT_LINE|PUT_CURSLINE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008342}
8343
8344/*
8345 * Handle ":copy" and ":move".
8346 */
8347 static void
8348ex_copymove(eap)
8349 exarg_T *eap;
8350{
8351 long n;
8352
8353 n = get_address(&eap->arg, FALSE, FALSE);
8354 if (eap->arg == NULL) /* error detected */
8355 {
8356 eap->nextcmd = NULL;
8357 return;
8358 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00008359 get_flags(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008360
8361 /*
8362 * move or copy lines from 'eap->line1'-'eap->line2' to below line 'n'
8363 */
8364 if (n == MAXLNUM || n < 0 || n > curbuf->b_ml.ml_line_count)
8365 {
8366 EMSG(_(e_invaddr));
8367 return;
8368 }
8369
8370 if (eap->cmdidx == CMD_move)
8371 {
8372 if (do_move(eap->line1, eap->line2, n) == FAIL)
8373 return;
8374 }
8375 else
8376 ex_copy(eap->line1, eap->line2, n);
8377 u_clearline();
8378 beginline(BL_SOL | BL_FIX);
Bram Moolenaardf177f62005-02-22 08:39:57 +00008379 ex_may_print(eap);
8380}
8381
8382/*
8383 * Print the current line if flags were given to the Ex command.
8384 */
8385 static void
8386ex_may_print(eap)
8387 exarg_T *eap;
8388{
8389 if (eap->flags != 0)
8390 {
8391 print_line(curwin->w_cursor.lnum, (eap->flags & EXFLAG_NR),
8392 (eap->flags & EXFLAG_LIST));
8393 ex_no_reprint = TRUE;
8394 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008395}
8396
8397/*
8398 * ":smagic" and ":snomagic".
8399 */
8400 static void
8401ex_submagic(eap)
8402 exarg_T *eap;
8403{
8404 int magic_save = p_magic;
8405
8406 p_magic = (eap->cmdidx == CMD_smagic);
8407 do_sub(eap);
8408 p_magic = magic_save;
8409}
8410
8411/*
8412 * ":join".
8413 */
8414 static void
8415ex_join(eap)
8416 exarg_T *eap;
8417{
8418 curwin->w_cursor.lnum = eap->line1;
8419 if (eap->line1 == eap->line2)
8420 {
8421 if (eap->addr_count >= 2) /* :2,2join does nothing */
8422 return;
8423 if (eap->line2 == curbuf->b_ml.ml_line_count)
8424 {
8425 beep_flush();
8426 return;
8427 }
8428 ++eap->line2;
8429 }
Bram Moolenaar893eaab2010-07-10 17:51:46 +02008430 (void)do_join(eap->line2 - eap->line1 + 1, !eap->forceit, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008431 beginline(BL_WHITE | BL_FIX);
Bram Moolenaardf177f62005-02-22 08:39:57 +00008432 ex_may_print(eap);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008433}
8434
8435/*
8436 * ":[addr]@r" or ":[addr]*r": execute register
8437 */
8438 static void
8439ex_at(eap)
8440 exarg_T *eap;
8441{
8442 int c;
Bram Moolenaar60462872009-11-03 11:40:19 +00008443 int prev_len = typebuf.tb_len;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008444
8445 curwin->w_cursor.lnum = eap->line2;
8446
8447#ifdef USE_ON_FLY_SCROLL
8448 dont_scroll = TRUE; /* disallow scrolling here */
8449#endif
8450
8451 /* get the register name. No name means to use the previous one */
8452 c = *eap->arg;
8453 if (c == NUL || (c == '*' && *eap->cmd == '*'))
8454 c = '@';
Bram Moolenaard333d1e2006-11-07 17:43:47 +00008455 /* Put the register in the typeahead buffer with the "silent" flag. */
8456 if (do_execreg(c, TRUE, vim_strchr(p_cpo, CPO_EXECBUF) != NULL, TRUE)
8457 == FAIL)
Bram Moolenaardf177f62005-02-22 08:39:57 +00008458 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00008459 beep_flush();
Bram Moolenaardf177f62005-02-22 08:39:57 +00008460 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008461 else
8462 {
8463 int save_efr = exec_from_reg;
8464
8465 exec_from_reg = TRUE;
8466
8467 /*
8468 * Execute from the typeahead buffer.
Bram Moolenaar60462872009-11-03 11:40:19 +00008469 * Continue until the stuff buffer is empty and all added characters
8470 * have been consumed.
Bram Moolenaar071d4272004-06-13 20:20:40 +00008471 */
Bram Moolenaar60462872009-11-03 11:40:19 +00008472 while (!stuff_empty() || typebuf.tb_len > prev_len)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008473 (void)do_cmdline(NULL, getexline, NULL, DOCMD_NOWAIT|DOCMD_VERBOSE);
8474
8475 exec_from_reg = save_efr;
8476 }
8477}
8478
8479/*
8480 * ":!".
8481 */
8482 static void
8483ex_bang(eap)
8484 exarg_T *eap;
8485{
8486 do_bang(eap->addr_count, eap, eap->forceit, TRUE, TRUE);
8487}
8488
8489/*
8490 * ":undo".
8491 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00008492 static void
8493ex_undo(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +00008494 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008495{
Bram Moolenaard3667a22006-03-16 21:35:52 +00008496 if (eap->addr_count == 1) /* :undo 123 */
Bram Moolenaar730cde92010-06-27 05:18:54 +02008497 undo_time(eap->line2, FALSE, FALSE, TRUE);
Bram Moolenaard3667a22006-03-16 21:35:52 +00008498 else
8499 u_undo(1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008500}
8501
Bram Moolenaar55debbe2010-05-23 23:34:36 +02008502#ifdef FEAT_PERSISTENT_UNDO
Bram Moolenaar6df6f472010-07-18 18:04:50 +02008503 static void
Bram Moolenaar55debbe2010-05-23 23:34:36 +02008504ex_wundo(eap)
8505 exarg_T *eap;
8506{
8507 char_u hash[UNDO_HASH_SIZE];
8508
8509 u_compute_hash(hash);
8510 u_write_undo(eap->arg, eap->forceit, curbuf, hash);
8511}
8512
Bram Moolenaar6df6f472010-07-18 18:04:50 +02008513 static void
Bram Moolenaar55debbe2010-05-23 23:34:36 +02008514ex_rundo(eap)
8515 exarg_T *eap;
8516{
8517 char_u hash[UNDO_HASH_SIZE];
8518
8519 u_compute_hash(hash);
Bram Moolenaar6ed8ed82010-05-30 20:40:11 +02008520 u_read_undo(eap->arg, hash, NULL);
Bram Moolenaar55debbe2010-05-23 23:34:36 +02008521}
8522#endif
8523
Bram Moolenaar071d4272004-06-13 20:20:40 +00008524/*
8525 * ":redo".
8526 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00008527 static void
8528ex_redo(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +00008529 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008530{
8531 u_redo(1);
8532}
8533
8534/*
Bram Moolenaarc7d89352006-03-14 22:53:34 +00008535 * ":earlier" and ":later".
8536 */
Bram Moolenaarc7d89352006-03-14 22:53:34 +00008537 static void
8538ex_later(eap)
8539 exarg_T *eap;
8540{
8541 long count = 0;
8542 int sec = FALSE;
Bram Moolenaar730cde92010-06-27 05:18:54 +02008543 int file = FALSE;
Bram Moolenaarc7d89352006-03-14 22:53:34 +00008544 char_u *p = eap->arg;
8545
8546 if (*p == NUL)
8547 count = 1;
8548 else if (isdigit(*p))
8549 {
8550 count = getdigits(&p);
8551 switch (*p)
8552 {
8553 case 's': ++p; sec = TRUE; break;
8554 case 'm': ++p; sec = TRUE; count *= 60; break;
8555 case 'h': ++p; sec = TRUE; count *= 60 * 60; break;
Bram Moolenaar730cde92010-06-27 05:18:54 +02008556 case 'd': ++p; sec = TRUE; count *= 24 * 60 * 60; break;
8557 case 'f': ++p; file = TRUE; break;
Bram Moolenaarc7d89352006-03-14 22:53:34 +00008558 }
8559 }
8560
8561 if (*p != NUL)
8562 EMSG2(_(e_invarg2), eap->arg);
8563 else
Bram Moolenaar730cde92010-06-27 05:18:54 +02008564 undo_time(eap->cmdidx == CMD_earlier ? -count : count,
8565 sec, file, FALSE);
Bram Moolenaarc7d89352006-03-14 22:53:34 +00008566}
8567
8568/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00008569 * ":redir": start/stop redirection.
8570 */
8571 static void
8572ex_redir(eap)
8573 exarg_T *eap;
8574{
8575 char *mode;
8576 char_u *fname;
Bram Moolenaarca472992005-01-21 11:46:23 +00008577 char_u *arg = eap->arg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008578
8579 if (STRICMP(eap->arg, "END") == 0)
8580 close_redir();
8581 else
8582 {
Bram Moolenaarca472992005-01-21 11:46:23 +00008583 if (*arg == '>')
Bram Moolenaar071d4272004-06-13 20:20:40 +00008584 {
Bram Moolenaarca472992005-01-21 11:46:23 +00008585 ++arg;
8586 if (*arg == '>')
Bram Moolenaar071d4272004-06-13 20:20:40 +00008587 {
Bram Moolenaarca472992005-01-21 11:46:23 +00008588 ++arg;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008589 mode = "a";
8590 }
8591 else
8592 mode = "w";
Bram Moolenaarca472992005-01-21 11:46:23 +00008593 arg = skipwhite(arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008594
8595 close_redir();
8596
8597 /* Expand environment variables and "~/". */
Bram Moolenaarca472992005-01-21 11:46:23 +00008598 fname = expand_env_save(arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008599 if (fname == NULL)
8600 return;
8601#ifdef FEAT_BROWSE
8602 if (cmdmod.browse)
8603 {
8604 char_u *browseFile;
8605
Bram Moolenaar7171abe2004-10-11 10:06:20 +00008606 browseFile = do_browse(BROWSE_SAVE,
8607 (char_u *)_("Save Redirection"),
8608 fname, NULL, NULL, BROWSE_FILTER_ALL_FILES, curbuf);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008609 if (browseFile == NULL)
8610 return; /* operation cancelled */
8611 vim_free(fname);
8612 fname = browseFile;
8613 eap->forceit = TRUE; /* since dialog already asked */
8614 }
8615#endif
8616
8617 redir_fd = open_exfile(fname, eap->forceit, mode);
8618 vim_free(fname);
8619 }
8620#ifdef FEAT_EVAL
Bram Moolenaarca472992005-01-21 11:46:23 +00008621 else if (*arg == '@')
Bram Moolenaar071d4272004-06-13 20:20:40 +00008622 {
8623 /* redirect to a register a-z (resp. A-Z for appending) */
8624 close_redir();
Bram Moolenaarca472992005-01-21 11:46:23 +00008625 ++arg;
8626 if (ASCII_ISALPHA(*arg)
Bram Moolenaar071d4272004-06-13 20:20:40 +00008627# ifdef FEAT_CLIPBOARD
Bram Moolenaarca472992005-01-21 11:46:23 +00008628 || *arg == '*'
Bram Moolenaar9a51c6e2006-11-14 19:25:02 +00008629 || *arg == '+'
Bram Moolenaar071d4272004-06-13 20:20:40 +00008630# endif
Bram Moolenaarca472992005-01-21 11:46:23 +00008631 || *arg == '"')
Bram Moolenaar071d4272004-06-13 20:20:40 +00008632 {
Bram Moolenaarca472992005-01-21 11:46:23 +00008633 redir_reg = *arg++;
Bram Moolenaarc188b882007-10-19 14:20:54 +00008634 if (*arg == '>' && arg[1] == '>') /* append */
Bram Moolenaard9d30582005-05-18 22:10:28 +00008635 arg += 2;
Bram Moolenaarc188b882007-10-19 14:20:54 +00008636 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00008637 {
Bram Moolenaarc188b882007-10-19 14:20:54 +00008638 /* Can use both "@a" and "@a>". */
Bram Moolenaar2c29bee2005-06-01 21:46:07 +00008639 if (*arg == '>')
8640 arg++;
Bram Moolenaarc188b882007-10-19 14:20:54 +00008641 /* Make register empty when not using @A-@Z and the
8642 * command is valid. */
8643 if (*arg == NUL && !isupper(redir_reg))
8644 write_reg_contents(redir_reg, (char_u *)"", -1, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008645 }
Bram Moolenaardf177f62005-02-22 08:39:57 +00008646 }
8647 if (*arg != NUL)
8648 {
Bram Moolenaardf177f62005-02-22 08:39:57 +00008649 redir_reg = 0;
Bram Moolenaard9d30582005-05-18 22:10:28 +00008650 EMSG2(_(e_invarg2), eap->arg);
Bram Moolenaardf177f62005-02-22 08:39:57 +00008651 }
8652 }
8653 else if (*arg == '=' && arg[1] == '>')
8654 {
8655 int append;
8656
8657 /* redirect to a variable */
8658 close_redir();
8659 arg += 2;
8660
8661 if (*arg == '>')
8662 {
8663 ++arg;
8664 append = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008665 }
8666 else
Bram Moolenaardf177f62005-02-22 08:39:57 +00008667 append = FALSE;
8668
8669 if (var_redir_start(skipwhite(arg), append) == OK)
8670 redir_vname = 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008671 }
8672#endif
8673
8674 /* TODO: redirect to a buffer */
8675
Bram Moolenaar071d4272004-06-13 20:20:40 +00008676 else
Bram Moolenaarca472992005-01-21 11:46:23 +00008677 EMSG2(_(e_invarg2), eap->arg);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008678 }
Bram Moolenaar29b2d262006-09-10 19:07:28 +00008679
8680 /* Make sure redirection is not off. Can happen for cmdline completion
8681 * that indirectly invokes a command to catch its output. */
8682 if (redir_fd != NULL
8683#ifdef FEAT_EVAL
8684 || redir_reg || redir_vname
8685#endif
8686 )
8687 redir_off = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008688}
8689
8690/*
8691 * ":redraw": force redraw
8692 */
8693 static void
8694ex_redraw(eap)
8695 exarg_T *eap;
8696{
8697 int r = RedrawingDisabled;
8698 int p = p_lz;
8699
8700 RedrawingDisabled = 0;
8701 p_lz = FALSE;
8702 update_topline();
8703 update_screen(eap->forceit ? CLEAR :
8704#ifdef FEAT_VISUAL
8705 VIsual_active ? INVERTED :
8706#endif
8707 0);
8708#ifdef FEAT_TITLE
8709 if (need_maketitle)
8710 maketitle();
8711#endif
8712 RedrawingDisabled = r;
8713 p_lz = p;
8714
8715 /* Reset msg_didout, so that a message that's there is overwritten. */
8716 msg_didout = FALSE;
8717 msg_col = 0;
8718
8719 out_flush();
8720}
8721
8722/*
8723 * ":redrawstatus": force redraw of status line(s)
8724 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00008725 static void
8726ex_redrawstatus(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +00008727 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00008728{
8729#if defined(FEAT_WINDOWS)
8730 int r = RedrawingDisabled;
8731 int p = p_lz;
8732
8733 RedrawingDisabled = 0;
8734 p_lz = FALSE;
8735 if (eap->forceit)
8736 status_redraw_all();
8737 else
8738 status_redraw_curbuf();
8739 update_screen(
8740# ifdef FEAT_VISUAL
8741 VIsual_active ? INVERTED :
8742# endif
8743 0);
8744 RedrawingDisabled = r;
8745 p_lz = p;
8746 out_flush();
8747#endif
8748}
8749
8750 static void
8751close_redir()
8752{
8753 if (redir_fd != NULL)
8754 {
8755 fclose(redir_fd);
8756 redir_fd = NULL;
8757 }
8758#ifdef FEAT_EVAL
8759 redir_reg = 0;
Bram Moolenaardf177f62005-02-22 08:39:57 +00008760 if (redir_vname)
8761 {
8762 var_redir_stop();
8763 redir_vname = 0;
8764 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008765#endif
8766}
8767
8768#if defined(FEAT_SESSION) && defined(USE_CRNL)
8769# define MKSESSION_NL
8770static int mksession_nl = FALSE; /* use NL only in put_eol() */
8771#endif
8772
8773/*
8774 * ":mkexrc", ":mkvimrc", ":mkview" and ":mksession".
8775 */
8776 static void
8777ex_mkrc(eap)
8778 exarg_T *eap;
8779{
8780 FILE *fd;
8781 int failed = FALSE;
8782 char_u *fname;
8783#ifdef FEAT_BROWSE
8784 char_u *browseFile = NULL;
8785#endif
8786#ifdef FEAT_SESSION
8787 int view_session = FALSE;
8788 int using_vdir = FALSE; /* using 'viewdir'? */
8789 char_u *viewFile = NULL;
8790 unsigned *flagp;
8791#endif
8792
8793 if (eap->cmdidx == CMD_mksession || eap->cmdidx == CMD_mkview)
8794 {
8795#ifdef FEAT_SESSION
8796 view_session = TRUE;
8797#else
8798 ex_ni(eap);
8799 return;
8800#endif
8801 }
8802
8803#ifdef FEAT_SESSION
Bram Moolenaar8d594672009-07-01 18:18:57 +00008804 /* Use the short file name until ":lcd" is used. We also don't use the
8805 * short file name when 'acd' is set, that is checked later. */
Bram Moolenaareeefcc72007-05-01 21:21:21 +00008806 did_lcd = FALSE;
8807
Bram Moolenaar071d4272004-06-13 20:20:40 +00008808 /* ":mkview" or ":mkview 9": generate file name with 'viewdir' */
8809 if (eap->cmdidx == CMD_mkview
8810 && (*eap->arg == NUL
8811 || (vim_isdigit(*eap->arg) && eap->arg[1] == NUL)))
8812 {
8813 eap->forceit = TRUE;
8814 fname = get_view_file(*eap->arg);
8815 if (fname == NULL)
8816 return;
8817 viewFile = fname;
8818 using_vdir = TRUE;
8819 }
8820 else
8821#endif
8822 if (*eap->arg != NUL)
8823 fname = eap->arg;
8824 else if (eap->cmdidx == CMD_mkvimrc)
8825 fname = (char_u *)VIMRC_FILE;
8826#ifdef FEAT_SESSION
8827 else if (eap->cmdidx == CMD_mksession)
8828 fname = (char_u *)SESSION_FILE;
8829#endif
8830 else
8831 fname = (char_u *)EXRC_FILE;
8832
8833#ifdef FEAT_BROWSE
8834 if (cmdmod.browse)
8835 {
Bram Moolenaar7171abe2004-10-11 10:06:20 +00008836 browseFile = do_browse(BROWSE_SAVE,
Bram Moolenaar071d4272004-06-13 20:20:40 +00008837# ifdef FEAT_SESSION
8838 eap->cmdidx == CMD_mkview ? (char_u *)_("Save View") :
8839 eap->cmdidx == CMD_mksession ? (char_u *)_("Save Session") :
8840# endif
8841 (char_u *)_("Save Setup"),
8842 fname, (char_u *)"vim", NULL, BROWSE_FILTER_MACROS, NULL);
8843 if (browseFile == NULL)
8844 goto theend;
8845 fname = browseFile;
8846 eap->forceit = TRUE; /* since dialog already asked */
8847 }
8848#endif
8849
8850#if defined(FEAT_SESSION) && defined(vim_mkdir)
8851 /* When using 'viewdir' may have to create the directory. */
8852 if (using_vdir && !mch_isdir(p_vdir))
Bram Moolenaardf177f62005-02-22 08:39:57 +00008853 vim_mkdir_emsg(p_vdir, 0755);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008854#endif
8855
8856 fd = open_exfile(fname, eap->forceit, WRITEBIN);
8857 if (fd != NULL)
8858 {
8859#ifdef FEAT_SESSION
8860 if (eap->cmdidx == CMD_mkview)
8861 flagp = &vop_flags;
8862 else
8863 flagp = &ssop_flags;
8864#endif
8865
8866#ifdef MKSESSION_NL
8867 /* "unix" in 'sessionoptions': use NL line separator */
8868 if (view_session && (*flagp & SSOP_UNIX))
8869 mksession_nl = TRUE;
8870#endif
8871
8872 /* Write the version command for :mkvimrc */
8873 if (eap->cmdidx == CMD_mkvimrc)
8874 (void)put_line(fd, "version 6.0");
8875
8876#ifdef FEAT_SESSION
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +00008877 if (eap->cmdidx == CMD_mksession)
8878 {
8879 if (put_line(fd, "let SessionLoad = 1") == FAIL)
8880 failed = TRUE;
8881 }
8882
Bram Moolenaar071d4272004-06-13 20:20:40 +00008883 if (eap->cmdidx != CMD_mkview)
8884#endif
8885 {
8886 /* Write setting 'compatible' first, because it has side effects.
8887 * For that same reason only do it when needed. */
8888 if (p_cp)
8889 (void)put_line(fd, "if !&cp | set cp | endif");
8890 else
8891 (void)put_line(fd, "if &cp | set nocp | endif");
8892 }
8893
8894#ifdef FEAT_SESSION
8895 if (!view_session
8896 || (eap->cmdidx == CMD_mksession
8897 && (*flagp & SSOP_OPTIONS)))
8898#endif
8899 failed |= (makemap(fd, NULL) == FAIL
8900 || makeset(fd, OPT_GLOBAL, FALSE) == FAIL);
8901
8902#ifdef FEAT_SESSION
8903 if (!failed && view_session)
8904 {
8905 if (put_line(fd, "let s:so_save = &so | let s:siso_save = &siso | set so=0 siso=0") == FAIL)
8906 failed = TRUE;
8907 if (eap->cmdidx == CMD_mksession)
8908 {
8909 char_u dirnow[MAXPATHL]; /* current directory */
8910
8911 /*
8912 * Change to session file's dir.
8913 */
8914 if (mch_dirname(dirnow, MAXPATHL) == FAIL
8915 || mch_chdir((char *)dirnow) != 0)
8916 *dirnow = NUL;
8917 if (*dirnow != NUL && (ssop_flags & SSOP_SESDIR))
8918 {
8919 if (vim_chdirfile(fname) == OK)
8920 shorten_fnames(TRUE);
8921 }
8922 else if (*dirnow != NUL
8923 && (ssop_flags & SSOP_CURDIR) && globaldir != NULL)
8924 {
Bram Moolenaarc0b35652009-03-01 01:45:35 +00008925 if (mch_chdir((char *)globaldir) == 0)
Bram Moolenaarfe86f2d2008-11-28 20:29:07 +00008926 shorten_fnames(TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008927 }
8928
8929 failed |= (makeopens(fd, dirnow) == FAIL);
8930
8931 /* restore original dir */
8932 if (*dirnow != NUL && ((ssop_flags & SSOP_SESDIR)
8933 || ((ssop_flags & SSOP_CURDIR) && globaldir != NULL)))
8934 {
8935 if (mch_chdir((char *)dirnow) != 0)
8936 EMSG(_(e_prev_dir));
8937 shorten_fnames(TRUE);
8938 }
8939 }
8940 else
8941 {
Bram Moolenaarf13be0d2008-01-02 14:13:10 +00008942 failed |= (put_view(fd, curwin, !using_vdir, flagp,
8943 -1) == FAIL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00008944 }
8945 if (put_line(fd, "let &so = s:so_save | let &siso = s:siso_save")
8946 == FAIL)
8947 failed = TRUE;
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +00008948 if (put_line(fd, "doautoall SessionLoadPost") == FAIL)
8949 failed = TRUE;
Bram Moolenaar4770d092006-01-12 23:22:24 +00008950 if (eap->cmdidx == CMD_mksession)
8951 {
8952 if (put_line(fd, "unlet SessionLoad") == FAIL)
8953 failed = TRUE;
8954 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00008955 }
8956#endif
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +00008957 if (put_line(fd, "\" vim: set ft=vim :") == FAIL)
8958 failed = TRUE;
8959
Bram Moolenaar071d4272004-06-13 20:20:40 +00008960 failed |= fclose(fd);
8961
8962 if (failed)
8963 EMSG(_(e_write));
8964#if defined(FEAT_EVAL) && defined(FEAT_SESSION)
8965 else if (eap->cmdidx == CMD_mksession)
8966 {
8967 /* successful session write - set this_session var */
8968 char_u tbuf[MAXPATHL];
8969
8970 if (vim_FullName(fname, tbuf, MAXPATHL, FALSE) == OK)
8971 set_vim_var_string(VV_THIS_SESSION, tbuf, -1);
8972 }
8973#endif
8974#ifdef MKSESSION_NL
8975 mksession_nl = FALSE;
8976#endif
8977 }
8978
8979#ifdef FEAT_BROWSE
8980theend:
8981 vim_free(browseFile);
8982#endif
8983#ifdef FEAT_SESSION
8984 vim_free(viewFile);
8985#endif
8986}
8987
Bram Moolenaardf177f62005-02-22 08:39:57 +00008988#if ((defined(FEAT_SESSION) || defined(FEAT_EVAL)) && defined(vim_mkdir)) \
8989 || defined(PROTO)
8990 int
8991vim_mkdir_emsg(name, prot)
8992 char_u *name;
Bram Moolenaar78a15312009-05-15 19:33:18 +00008993 int prot UNUSED;
Bram Moolenaardf177f62005-02-22 08:39:57 +00008994{
8995 if (vim_mkdir(name, prot) != 0)
8996 {
8997 EMSG2(_("E739: Cannot create directory: %s"), name);
8998 return FAIL;
8999 }
9000 return OK;
9001}
9002#endif
9003
Bram Moolenaar071d4272004-06-13 20:20:40 +00009004/*
9005 * Open a file for writing for an Ex command, with some checks.
9006 * Return file descriptor, or NULL on failure.
9007 */
9008 FILE *
9009open_exfile(fname, forceit, mode)
9010 char_u *fname;
9011 int forceit;
9012 char *mode; /* "w" for create new file or "a" for append */
9013{
9014 FILE *fd;
9015
9016#ifdef UNIX
9017 /* with Unix it is possible to open a directory */
9018 if (mch_isdir(fname))
9019 {
9020 EMSG2(_(e_isadir2), fname);
9021 return NULL;
9022 }
9023#endif
9024 if (!forceit && *mode != 'a' && vim_fexists(fname))
9025 {
9026 EMSG2(_("E189: \"%s\" exists (add ! to override)"), fname);
9027 return NULL;
9028 }
9029
9030 if ((fd = mch_fopen((char *)fname, mode)) == NULL)
9031 EMSG2(_("E190: Cannot open \"%s\" for writing"), fname);
9032
9033 return fd;
9034}
9035
9036/*
9037 * ":mark" and ":k".
9038 */
9039 static void
9040ex_mark(eap)
9041 exarg_T *eap;
9042{
9043 pos_T pos;
9044
9045 if (*eap->arg == NUL) /* No argument? */
9046 EMSG(_(e_argreq));
9047 else if (eap->arg[1] != NUL) /* more than one character? */
9048 EMSG(_(e_trailing));
9049 else
9050 {
9051 pos = curwin->w_cursor; /* save curwin->w_cursor */
9052 curwin->w_cursor.lnum = eap->line2;
9053 beginline(BL_WHITE | BL_FIX);
9054 if (setmark(*eap->arg) == FAIL) /* set mark */
9055 EMSG(_("E191: Argument must be a letter or forward/backward quote"));
9056 curwin->w_cursor = pos; /* restore curwin->w_cursor */
9057 }
9058}
9059
9060/*
9061 * Update w_topline, w_leftcol and the cursor position.
9062 */
9063 void
9064update_topline_cursor()
9065{
9066 check_cursor(); /* put cursor on valid line */
9067 update_topline();
9068 if (!curwin->w_p_wrap)
9069 validate_cursor();
9070 update_curswant();
9071}
9072
9073#ifdef FEAT_EX_EXTRA
9074/*
9075 * ":normal[!] {commands}": Execute normal mode commands.
9076 */
9077 static void
9078ex_normal(eap)
9079 exarg_T *eap;
9080{
Bram Moolenaar071d4272004-06-13 20:20:40 +00009081 int save_msg_scroll = msg_scroll;
9082 int save_restart_edit = restart_edit;
9083 int save_msg_didout = msg_didout;
9084 int save_State = State;
9085 tasave_T tabuf;
9086 int save_insertmode = p_im;
9087 int save_finish_op = finish_op;
Bram Moolenaar38084112008-07-26 14:05:07 +00009088 int save_opcount = opcount;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009089#ifdef FEAT_MBYTE
9090 char_u *arg = NULL;
9091 int l;
9092 char_u *p;
9093#endif
9094
Bram Moolenaarc9b4b052006-04-30 18:54:39 +00009095 if (ex_normal_lock > 0)
9096 {
9097 EMSG(_(e_secure));
9098 return;
9099 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009100 if (ex_normal_busy >= p_mmd)
9101 {
9102 EMSG(_("E192: Recursive use of :normal too deep"));
9103 return;
9104 }
9105 ++ex_normal_busy;
9106
9107 msg_scroll = FALSE; /* no msg scrolling in Normal mode */
9108 restart_edit = 0; /* don't go to Insert mode */
9109 p_im = FALSE; /* don't use 'insertmode' */
9110
9111#ifdef FEAT_MBYTE
9112 /*
9113 * vgetc() expects a CSI and K_SPECIAL to have been escaped. Don't do
9114 * this for the K_SPECIAL leading byte, otherwise special keys will not
9115 * work.
9116 */
9117 if (has_mbyte)
9118 {
9119 int len = 0;
9120
9121 /* Count the number of characters to be escaped. */
9122 for (p = eap->arg; *p != NUL; ++p)
9123 {
9124# ifdef FEAT_GUI
9125 if (*p == CSI) /* leadbyte CSI */
9126 len += 2;
9127# endif
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00009128 for (l = (*mb_ptr2len)(p) - 1; l > 0; --l)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009129 if (*++p == K_SPECIAL /* trailbyte K_SPECIAL or CSI */
9130# ifdef FEAT_GUI
9131 || *p == CSI
9132# endif
9133 )
9134 len += 2;
9135 }
9136 if (len > 0)
9137 {
9138 arg = alloc((unsigned)(STRLEN(eap->arg) + len + 1));
9139 if (arg != NULL)
9140 {
9141 len = 0;
9142 for (p = eap->arg; *p != NUL; ++p)
9143 {
9144 arg[len++] = *p;
9145# ifdef FEAT_GUI
9146 if (*p == CSI)
9147 {
9148 arg[len++] = KS_EXTRA;
9149 arg[len++] = (int)KE_CSI;
9150 }
9151# endif
Bram Moolenaar0fa313a2005-08-10 21:07:57 +00009152 for (l = (*mb_ptr2len)(p) - 1; l > 0; --l)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009153 {
9154 arg[len++] = *++p;
9155 if (*p == K_SPECIAL)
9156 {
9157 arg[len++] = KS_SPECIAL;
9158 arg[len++] = KE_FILLER;
9159 }
9160# ifdef FEAT_GUI
9161 else if (*p == CSI)
9162 {
9163 arg[len++] = KS_EXTRA;
9164 arg[len++] = (int)KE_CSI;
9165 }
9166# endif
9167 }
9168 arg[len] = NUL;
9169 }
9170 }
9171 }
9172 }
9173#endif
9174
9175 /*
9176 * Save the current typeahead. This is required to allow using ":normal"
9177 * from an event handler and makes sure we don't hang when the argument
9178 * ends with half a command.
9179 */
9180 save_typeahead(&tabuf);
9181 if (tabuf.typebuf_valid)
9182 {
9183 /*
9184 * Repeat the :normal command for each line in the range. When no
9185 * range given, execute it just once, without positioning the cursor
9186 * first.
9187 */
9188 do
9189 {
Bram Moolenaar071d4272004-06-13 20:20:40 +00009190 if (eap->addr_count != 0)
9191 {
9192 curwin->w_cursor.lnum = eap->line1++;
9193 curwin->w_cursor.col = 0;
9194 }
9195
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00009196 exec_normal_cmd(
Bram Moolenaar071d4272004-06-13 20:20:40 +00009197#ifdef FEAT_MBYTE
9198 arg != NULL ? arg :
9199#endif
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00009200 eap->arg, eap->forceit ? REMAP_NONE : REMAP_YES, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009201 }
9202 while (eap->addr_count > 0 && eap->line1 <= eap->line2 && !got_int);
9203 }
9204
9205 /* Might not return to the main loop when in an event handler. */
9206 update_topline_cursor();
9207
9208 /* Restore the previous typeahead. */
9209 restore_typeahead(&tabuf);
9210
9211 --ex_normal_busy;
9212 msg_scroll = save_msg_scroll;
9213 restart_edit = save_restart_edit;
9214 p_im = save_insertmode;
9215 finish_op = save_finish_op;
Bram Moolenaar38084112008-07-26 14:05:07 +00009216 opcount = save_opcount;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009217 msg_didout |= save_msg_didout; /* don't reset msg_didout now */
9218
9219 /* Restore the state (needed when called from a function executed for
9220 * 'indentexpr'). */
9221 State = save_State;
9222#ifdef FEAT_MBYTE
9223 vim_free(arg);
9224#endif
9225}
9226
9227/*
Bram Moolenaar64969662005-12-14 21:59:55 +00009228 * ":startinsert", ":startreplace" and ":startgreplace"
Bram Moolenaar071d4272004-06-13 20:20:40 +00009229 */
9230 static void
9231ex_startinsert(eap)
9232 exarg_T *eap;
9233{
Bram Moolenaarfd371682005-01-14 21:42:54 +00009234 if (eap->forceit)
9235 {
9236 coladvance((colnr_T)MAXCOL);
9237 curwin->w_curswant = MAXCOL;
9238 curwin->w_set_curswant = FALSE;
9239 }
9240
Bram Moolenaara40c5002005-01-09 21:16:21 +00009241 /* Ignore the command when already in Insert mode. Inserting an
9242 * expression register that invokes a function can do this. */
9243 if (State & INSERT)
9244 return;
9245
Bram Moolenaar64969662005-12-14 21:59:55 +00009246 if (eap->cmdidx == CMD_startinsert)
9247 restart_edit = 'a';
9248 else if (eap->cmdidx == CMD_startreplace)
9249 restart_edit = 'R';
Bram Moolenaar071d4272004-06-13 20:20:40 +00009250 else
Bram Moolenaar64969662005-12-14 21:59:55 +00009251 restart_edit = 'V';
9252
9253 if (!eap->forceit)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009254 {
Bram Moolenaar325b7a22004-07-05 15:58:32 +00009255 if (eap->cmdidx == CMD_startinsert)
9256 restart_edit = 'i';
Bram Moolenaar071d4272004-06-13 20:20:40 +00009257 curwin->w_curswant = 0; /* avoid MAXCOL */
9258 }
9259}
9260
9261/*
9262 * ":stopinsert"
9263 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009264 static void
9265ex_stopinsert(eap)
Bram Moolenaaraf0167f2009-05-16 15:31:32 +00009266 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009267{
9268 restart_edit = 0;
9269 stop_insert_mode = TRUE;
9270}
9271#endif
9272
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00009273#if defined(FEAT_EX_EXTRA) || defined(FEAT_MENU) || defined(PROTO)
9274/*
9275 * Execute normal mode command "cmd".
9276 * "remap" can be REMAP_NONE or REMAP_YES.
9277 */
9278 void
9279exec_normal_cmd(cmd, remap, silent)
9280 char_u *cmd;
9281 int remap;
9282 int silent;
9283{
9284 oparg_T oa;
9285
9286 /*
9287 * Stuff the argument into the typeahead buffer.
9288 * Execute normal_cmd() until there is no typeahead left.
9289 */
9290 clear_oparg(&oa);
9291 finish_op = FALSE;
9292 ins_typebuf(cmd, remap, 0, TRUE, silent);
9293 while ((!stuff_empty() || (!typebuf_typed() && typebuf.tb_len > 0))
9294 && !got_int)
9295 {
9296 update_topline_cursor();
9297 normal_cmd(&oa, FALSE); /* execute a Normal mode cmd */
9298 }
9299}
9300#endif
9301
Bram Moolenaar071d4272004-06-13 20:20:40 +00009302#ifdef FEAT_FIND_ID
9303 static void
9304ex_checkpath(eap)
9305 exarg_T *eap;
9306{
9307 find_pattern_in_path(NULL, 0, 0, FALSE, FALSE, CHECK_PATH, 1L,
9308 eap->forceit ? ACTION_SHOW_ALL : ACTION_SHOW,
9309 (linenr_T)1, (linenr_T)MAXLNUM);
9310}
9311
9312#if defined(FEAT_WINDOWS) && defined(FEAT_QUICKFIX)
9313/*
9314 * ":psearch"
9315 */
9316 static void
9317ex_psearch(eap)
9318 exarg_T *eap;
9319{
9320 g_do_tagpreview = p_pvh;
9321 ex_findpat(eap);
9322 g_do_tagpreview = 0;
9323}
9324#endif
9325
9326 static void
9327ex_findpat(eap)
9328 exarg_T *eap;
9329{
9330 int whole = TRUE;
9331 long n;
9332 char_u *p;
9333 int action;
9334
9335 switch (cmdnames[eap->cmdidx].cmd_name[2])
9336 {
9337 case 'e': /* ":psearch", ":isearch" and ":dsearch" */
9338 if (cmdnames[eap->cmdidx].cmd_name[0] == 'p')
9339 action = ACTION_GOTO;
9340 else
9341 action = ACTION_SHOW;
9342 break;
9343 case 'i': /* ":ilist" and ":dlist" */
9344 action = ACTION_SHOW_ALL;
9345 break;
9346 case 'u': /* ":ijump" and ":djump" */
9347 action = ACTION_GOTO;
9348 break;
9349 default: /* ":isplit" and ":dsplit" */
9350 action = ACTION_SPLIT;
9351 break;
9352 }
9353
9354 n = 1;
9355 if (vim_isdigit(*eap->arg)) /* get count */
9356 {
9357 n = getdigits(&eap->arg);
9358 eap->arg = skipwhite(eap->arg);
9359 }
9360 if (*eap->arg == '/') /* Match regexp, not just whole words */
9361 {
9362 whole = FALSE;
9363 ++eap->arg;
9364 p = skip_regexp(eap->arg, '/', p_magic, NULL);
9365 if (*p)
9366 {
9367 *p++ = NUL;
9368 p = skipwhite(p);
9369
9370 /* Check for trailing illegal characters */
9371 if (!ends_excmd(*p))
9372 eap->errmsg = e_trailing;
9373 else
9374 eap->nextcmd = check_nextcmd(p);
9375 }
9376 }
9377 if (!eap->skip)
9378 find_pattern_in_path(eap->arg, 0, (int)STRLEN(eap->arg),
9379 whole, !eap->forceit,
9380 *eap->cmd == 'd' ? FIND_DEFINE : FIND_ANY,
9381 n, action, eap->line1, eap->line2);
9382}
9383#endif
9384
9385#ifdef FEAT_WINDOWS
9386
9387# ifdef FEAT_QUICKFIX
9388/*
9389 * ":ptag", ":ptselect", ":ptjump", ":ptnext", etc.
9390 */
9391 static void
9392ex_ptag(eap)
9393 exarg_T *eap;
9394{
9395 g_do_tagpreview = p_pvh;
9396 ex_tag_cmd(eap, cmdnames[eap->cmdidx].cmd_name + 1);
9397}
9398
9399/*
9400 * ":pedit"
9401 */
9402 static void
9403ex_pedit(eap)
9404 exarg_T *eap;
9405{
9406 win_T *curwin_save = curwin;
9407
9408 g_do_tagpreview = p_pvh;
Bram Moolenaar607a95ed2006-03-28 20:57:42 +00009409 prepare_tagpreview(TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009410 keep_help_flag = curwin_save->w_buffer->b_help;
9411 do_exedit(eap, NULL);
9412 keep_help_flag = FALSE;
9413 if (curwin != curwin_save && win_valid(curwin_save))
9414 {
9415 /* Return cursor to where we were */
9416 validate_cursor();
9417 redraw_later(VALID);
9418 win_enter(curwin_save, TRUE);
9419 }
9420 g_do_tagpreview = 0;
9421}
9422# endif
9423
9424/*
9425 * ":stag", ":stselect" and ":stjump".
9426 */
9427 static void
9428ex_stag(eap)
9429 exarg_T *eap;
9430{
9431 postponed_split = -1;
9432 postponed_split_flags = cmdmod.split;
Bram Moolenaard326ce82007-03-11 14:48:29 +00009433 postponed_split_tab = cmdmod.tab;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009434 ex_tag_cmd(eap, cmdnames[eap->cmdidx].cmd_name + 1);
9435 postponed_split_flags = 0;
Bram Moolenaard326ce82007-03-11 14:48:29 +00009436 postponed_split_tab = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009437}
9438#endif
9439
9440/*
9441 * ":tag", ":tselect", ":tjump", ":tnext", etc.
9442 */
9443 static void
9444ex_tag(eap)
9445 exarg_T *eap;
9446{
9447 ex_tag_cmd(eap, cmdnames[eap->cmdidx].cmd_name);
9448}
9449
9450 static void
9451ex_tag_cmd(eap, name)
9452 exarg_T *eap;
9453 char_u *name;
9454{
9455 int cmd;
9456
9457 switch (name[1])
9458 {
9459 case 'j': cmd = DT_JUMP; /* ":tjump" */
9460 break;
9461 case 's': cmd = DT_SELECT; /* ":tselect" */
9462 break;
9463 case 'p': cmd = DT_PREV; /* ":tprevious" */
9464 break;
9465 case 'N': cmd = DT_PREV; /* ":tNext" */
9466 break;
9467 case 'n': cmd = DT_NEXT; /* ":tnext" */
9468 break;
9469 case 'o': cmd = DT_POP; /* ":pop" */
9470 break;
9471 case 'f': /* ":tfirst" */
9472 case 'r': cmd = DT_FIRST; /* ":trewind" */
9473 break;
9474 case 'l': cmd = DT_LAST; /* ":tlast" */
9475 break;
9476 default: /* ":tag" */
9477#ifdef FEAT_CSCOPE
Bram Moolenaar7c94c262008-06-20 09:11:34 +00009478 if (p_cst && *eap->arg != NUL)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009479 {
9480 do_cstag(eap);
9481 return;
9482 }
9483#endif
9484 cmd = DT_TAG;
9485 break;
9486 }
9487
Bram Moolenaarb8a7b562006-02-01 21:47:16 +00009488 if (name[0] == 'l')
9489 {
9490#ifndef FEAT_QUICKFIX
9491 ex_ni(eap);
9492 return;
9493#else
9494 cmd = DT_LTAG;
9495#endif
9496 }
9497
Bram Moolenaar071d4272004-06-13 20:20:40 +00009498 do_tag(eap->arg, cmd, eap->addr_count > 0 ? (int)eap->line2 : 1,
9499 eap->forceit, TRUE);
9500}
9501
9502/*
Bram Moolenaar05bb9532008-07-04 09:44:11 +00009503 * Check "str" for starting with a special cmdline variable.
9504 * If found return one of the SPEC_ values and set "*usedlen" to the length of
9505 * the variable. Otherwise return -1 and "*usedlen" is unchanged.
9506 */
9507 int
9508find_cmdline_var(src, usedlen)
9509 char_u *src;
9510 int *usedlen;
9511{
9512 int len;
9513 int i;
Bram Moolenaar8f0b2d42009-05-16 14:41:10 +00009514 static char *(spec_str[]) = {
Bram Moolenaar05bb9532008-07-04 09:44:11 +00009515 "%",
9516#define SPEC_PERC 0
9517 "#",
9518#define SPEC_HASH 1
9519 "<cword>", /* cursor word */
9520#define SPEC_CWORD 2
9521 "<cWORD>", /* cursor WORD */
9522#define SPEC_CCWORD 3
9523 "<cfile>", /* cursor path name */
9524#define SPEC_CFILE 4
9525 "<sfile>", /* ":so" file name */
9526#define SPEC_SFILE 5
9527#ifdef FEAT_AUTOCMD
9528 "<afile>", /* autocommand file name */
9529# define SPEC_AFILE 6
9530 "<abuf>", /* autocommand buffer number */
9531# define SPEC_ABUF 7
9532 "<amatch>", /* autocommand match name */
9533# define SPEC_AMATCH 8
9534#endif
9535#ifdef FEAT_CLIENTSERVER
9536 "<client>"
9537# define SPEC_CLIENT 9
9538#endif
9539 };
Bram Moolenaar05bb9532008-07-04 09:44:11 +00009540
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00009541 for (i = 0; i < (int)(sizeof(spec_str) / sizeof(char *)); ++i)
Bram Moolenaar05bb9532008-07-04 09:44:11 +00009542 {
9543 len = (int)STRLEN(spec_str[i]);
9544 if (STRNCMP(src, spec_str[i], len) == 0)
9545 {
9546 *usedlen = len;
9547 return i;
9548 }
9549 }
9550 return -1;
9551}
9552
9553/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00009554 * Evaluate cmdline variables.
9555 *
9556 * change '%' to curbuf->b_ffname
9557 * '#' to curwin->w_altfile
9558 * '<cword>' to word under the cursor
9559 * '<cWORD>' to WORD under the cursor
9560 * '<cfile>' to path name under the cursor
9561 * '<sfile>' to sourced file name
9562 * '<afile>' to file name for autocommand
9563 * '<abuf>' to buffer number for autocommand
9564 * '<amatch>' to matching name for autocommand
9565 *
9566 * When an error is detected, "errormsg" is set to a non-NULL pointer (may be
9567 * "" for error without a message) and NULL is returned.
9568 * Returns an allocated string if a valid match was found.
9569 * Returns NULL if no match was found. "usedlen" then still contains the
9570 * number of characters to skip.
9571 */
9572 char_u *
Bram Moolenaar63b92542007-03-27 14:57:09 +00009573eval_vars(src, srcstart, usedlen, lnump, errormsg, escaped)
Bram Moolenaar071d4272004-06-13 20:20:40 +00009574 char_u *src; /* pointer into commandline */
Bram Moolenaar63b92542007-03-27 14:57:09 +00009575 char_u *srcstart; /* beginning of valid memory for src */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009576 int *usedlen; /* characters after src that are used */
9577 linenr_T *lnump; /* line number for :e command, or NULL */
9578 char_u **errormsg; /* pointer to error message */
Bram Moolenaar63b92542007-03-27 14:57:09 +00009579 int *escaped; /* return value has escaped white space (can
9580 * be NULL) */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009581{
9582 int i;
9583 char_u *s;
9584 char_u *result;
9585 char_u *resultbuf = NULL;
9586 int resultlen;
9587 buf_T *buf;
9588 int valid = VALID_HEAD + VALID_PATH; /* assume valid result */
9589 int spec_idx;
9590#ifdef FEAT_MODIFY_FNAME
9591 int skip_mod = FALSE;
9592#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00009593
9594#if defined(FEAT_AUTOCMD) || defined(FEAT_CLIENTSERVER)
9595 char_u strbuf[30];
9596#endif
9597
9598 *errormsg = NULL;
Bram Moolenaar63b92542007-03-27 14:57:09 +00009599 if (escaped != NULL)
9600 *escaped = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009601
9602 /*
9603 * Check if there is something to do.
9604 */
Bram Moolenaar05bb9532008-07-04 09:44:11 +00009605 spec_idx = find_cmdline_var(src, usedlen);
9606 if (spec_idx < 0) /* no match */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009607 {
9608 *usedlen = 1;
9609 return NULL;
9610 }
9611
9612 /*
9613 * Skip when preceded with a backslash "\%" and "\#".
9614 * Note: In "\\%" the % is also not recognized!
9615 */
9616 if (src > srcstart && src[-1] == '\\')
9617 {
9618 *usedlen = 0;
Bram Moolenaara7241f52008-06-24 20:39:31 +00009619 STRMOVE(src - 1, src); /* remove backslash */
Bram Moolenaar071d4272004-06-13 20:20:40 +00009620 return NULL;
9621 }
9622
9623 /*
9624 * word or WORD under cursor
9625 */
9626 if (spec_idx == SPEC_CWORD || spec_idx == SPEC_CCWORD)
9627 {
9628 resultlen = find_ident_under_cursor(&result, spec_idx == SPEC_CWORD ?
9629 (FIND_IDENT|FIND_STRING) : FIND_STRING);
9630 if (resultlen == 0)
9631 {
9632 *errormsg = (char_u *)"";
9633 return NULL;
9634 }
9635 }
9636
9637 /*
9638 * '#': Alternate file name
9639 * '%': Current file name
9640 * File name under the cursor
9641 * File name for autocommand
9642 * and following modifiers
9643 */
9644 else
9645 {
9646 switch (spec_idx)
9647 {
9648 case SPEC_PERC: /* '%': current file */
9649 if (curbuf->b_fname == NULL)
9650 {
9651 result = (char_u *)"";
9652 valid = 0; /* Must have ":p:h" to be valid */
9653 }
9654 else
9655#ifdef RISCOS
9656 /* Always use the full path for RISC OS if possible. */
9657 result = curbuf->b_ffname;
9658 if (result == NULL)
9659 result = curbuf->b_fname;
9660#else
9661 result = curbuf->b_fname;
9662#endif
9663 break;
9664
9665 case SPEC_HASH: /* '#' or "#99": alternate file */
9666 if (src[1] == '#') /* "##": the argument list */
9667 {
9668 result = arg_all();
9669 resultbuf = result;
9670 *usedlen = 2;
Bram Moolenaar63b92542007-03-27 14:57:09 +00009671 if (escaped != NULL)
9672 *escaped = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009673#ifdef FEAT_MODIFY_FNAME
9674 skip_mod = TRUE;
9675#endif
9676 break;
9677 }
9678 s = src + 1;
Bram Moolenaard812df62008-11-09 12:46:09 +00009679 if (*s == '<') /* "#<99" uses v:oldfiles */
9680 ++s;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009681 i = (int)getdigits(&s);
9682 *usedlen = (int)(s - src); /* length of what we expand */
9683
Bram Moolenaard812df62008-11-09 12:46:09 +00009684 if (src[1] == '<')
Bram Moolenaar071d4272004-06-13 20:20:40 +00009685 {
Bram Moolenaard812df62008-11-09 12:46:09 +00009686 if (*usedlen < 2)
9687 {
9688 /* Should we give an error message for #<text? */
9689 *usedlen = 1;
9690 return NULL;
9691 }
9692#ifdef FEAT_EVAL
9693 result = list_find_str(get_vim_var_list(VV_OLDFILES),
9694 (long)i);
9695 if (result == NULL)
9696 {
9697 *errormsg = (char_u *)"";
9698 return NULL;
9699 }
9700#else
9701 *errormsg = (char_u *)_("E809: #< is not available without the +eval feature");
Bram Moolenaar071d4272004-06-13 20:20:40 +00009702 return NULL;
Bram Moolenaard812df62008-11-09 12:46:09 +00009703#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00009704 }
9705 else
Bram Moolenaard812df62008-11-09 12:46:09 +00009706 {
9707 buf = buflist_findnr(i);
9708 if (buf == NULL)
9709 {
9710 *errormsg = (char_u *)_("E194: No alternate file name to substitute for '#'");
9711 return NULL;
9712 }
9713 if (lnump != NULL)
9714 *lnump = ECMD_LAST;
9715 if (buf->b_fname == NULL)
9716 {
9717 result = (char_u *)"";
9718 valid = 0; /* Must have ":p:h" to be valid */
9719 }
9720 else
9721 result = buf->b_fname;
9722 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009723 break;
9724
9725#ifdef FEAT_SEARCHPATH
9726 case SPEC_CFILE: /* file name under cursor */
Bram Moolenaard1f56e62006-02-22 21:25:37 +00009727 result = file_name_at_cursor(FNAME_MESS|FNAME_HYP, 1L, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009728 if (result == NULL)
9729 {
9730 *errormsg = (char_u *)"";
9731 return NULL;
9732 }
9733 resultbuf = result; /* remember allocated string */
9734 break;
9735#endif
9736
9737#ifdef FEAT_AUTOCMD
9738 case SPEC_AFILE: /* file name for autocommand */
9739 result = autocmd_fname;
Bram Moolenaarf6dad432008-09-18 19:29:58 +00009740 if (result != NULL && !autocmd_fname_full)
9741 {
9742 /* Still need to turn the fname into a full path. It is
9743 * postponed to avoid a delay when <afile> is not used. */
9744 autocmd_fname_full = TRUE;
9745 result = FullName_save(autocmd_fname, FALSE);
9746 vim_free(autocmd_fname);
9747 autocmd_fname = result;
9748 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00009749 if (result == NULL)
9750 {
9751 *errormsg = (char_u *)_("E495: no autocommand file name to substitute for \"<afile>\"");
9752 return NULL;
9753 }
Bram Moolenaara0174af2008-01-02 20:08:25 +00009754 result = shorten_fname1(result);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009755 break;
9756
9757 case SPEC_ABUF: /* buffer number for autocommand */
9758 if (autocmd_bufnr <= 0)
9759 {
9760 *errormsg = (char_u *)_("E496: no autocommand buffer number to substitute for \"<abuf>\"");
9761 return NULL;
9762 }
9763 sprintf((char *)strbuf, "%d", autocmd_bufnr);
9764 result = strbuf;
9765 break;
9766
9767 case SPEC_AMATCH: /* match name for autocommand */
9768 result = autocmd_match;
9769 if (result == NULL)
9770 {
9771 *errormsg = (char_u *)_("E497: no autocommand match name to substitute for \"<amatch>\"");
9772 return NULL;
9773 }
9774 break;
9775
9776#endif
9777 case SPEC_SFILE: /* file name for ":so" command */
9778 result = sourcing_name;
9779 if (result == NULL)
9780 {
9781 *errormsg = (char_u *)_("E498: no :source file name to substitute for \"<sfile>\"");
9782 return NULL;
9783 }
9784 break;
9785#if defined(FEAT_CLIENTSERVER)
9786 case SPEC_CLIENT: /* Source of last submitted input */
Bram Moolenaareb3593b2006-04-22 22:33:57 +00009787 sprintf((char *)strbuf, PRINTF_HEX_LONG_U,
9788 (long_u)clientWindow);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009789 result = strbuf;
9790 break;
9791#endif
9792 }
9793
9794 resultlen = (int)STRLEN(result); /* length of new string */
9795 if (src[*usedlen] == '<') /* remove the file name extension */
9796 {
9797 ++*usedlen;
9798#ifdef RISCOS
9799 if ((s = vim_strrchr(result, '/')) != NULL && s >= gettail(result))
9800#else
9801 if ((s = vim_strrchr(result, '.')) != NULL && s >= gettail(result))
9802#endif
9803 resultlen = (int)(s - result);
9804 }
9805#ifdef FEAT_MODIFY_FNAME
9806 else if (!skip_mod)
9807 {
9808 valid |= modify_fname(src, usedlen, &result, &resultbuf,
9809 &resultlen);
9810 if (result == NULL)
9811 {
9812 *errormsg = (char_u *)"";
9813 return NULL;
9814 }
9815 }
9816#endif
9817 }
9818
9819 if (resultlen == 0 || valid != VALID_HEAD + VALID_PATH)
9820 {
9821 if (valid != VALID_HEAD + VALID_PATH)
9822 /* xgettext:no-c-format */
9823 *errormsg = (char_u *)_("E499: Empty file name for '%' or '#', only works with \":p:h\"");
9824 else
9825 *errormsg = (char_u *)_("E500: Evaluates to an empty string");
9826 result = NULL;
9827 }
9828 else
9829 result = vim_strnsave(result, resultlen);
9830 vim_free(resultbuf);
9831 return result;
9832}
9833
9834/*
9835 * Concatenate all files in the argument list, separated by spaces, and return
9836 * it in one allocated string.
9837 * Spaces and backslashes in the file names are escaped with a backslash.
9838 * Returns NULL when out of memory.
9839 */
9840 static char_u *
9841arg_all()
9842{
9843 int len;
9844 int idx;
9845 char_u *retval = NULL;
9846 char_u *p;
9847
9848 /*
9849 * Do this loop two times:
9850 * first time: compute the total length
9851 * second time: concatenate the names
9852 */
9853 for (;;)
9854 {
9855 len = 0;
9856 for (idx = 0; idx < ARGCOUNT; ++idx)
9857 {
9858 p = alist_name(&ARGLIST[idx]);
9859 if (p != NULL)
9860 {
9861 if (len > 0)
9862 {
9863 /* insert a space in between names */
9864 if (retval != NULL)
9865 retval[len] = ' ';
9866 ++len;
9867 }
9868 for ( ; *p != NUL; ++p)
9869 {
9870 if (*p == ' ' || *p == '\\')
9871 {
9872 /* insert a backslash */
9873 if (retval != NULL)
9874 retval[len] = '\\';
9875 ++len;
9876 }
9877 if (retval != NULL)
9878 retval[len] = *p;
9879 ++len;
9880 }
9881 }
9882 }
9883
9884 /* second time: break here */
9885 if (retval != NULL)
9886 {
9887 retval[len] = NUL;
9888 break;
9889 }
9890
9891 /* allocate memory */
Bram Moolenaar5fd0ca72009-05-13 16:56:33 +00009892 retval = alloc((unsigned)len + 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009893 if (retval == NULL)
9894 break;
9895 }
9896
9897 return retval;
9898}
9899
9900#if defined(FEAT_AUTOCMD) || defined(PROTO)
9901/*
9902 * Expand the <sfile> string in "arg".
9903 *
9904 * Returns an allocated string, or NULL for any error.
9905 */
9906 char_u *
9907expand_sfile(arg)
9908 char_u *arg;
9909{
9910 char_u *errormsg;
9911 int len;
9912 char_u *result;
9913 char_u *newres;
9914 char_u *repl;
9915 int srclen;
9916 char_u *p;
9917
9918 result = vim_strsave(arg);
9919 if (result == NULL)
9920 return NULL;
9921
9922 for (p = result; *p; )
9923 {
9924 if (STRNCMP(p, "<sfile>", 7) != 0)
9925 ++p;
9926 else
9927 {
9928 /* replace "<sfile>" with the sourced file name, and do ":" stuff */
Bram Moolenaar63b92542007-03-27 14:57:09 +00009929 repl = eval_vars(p, result, &srclen, NULL, &errormsg, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00009930 if (errormsg != NULL)
9931 {
9932 if (*errormsg)
9933 emsg(errormsg);
9934 vim_free(result);
9935 return NULL;
9936 }
9937 if (repl == NULL) /* no match (cannot happen) */
9938 {
9939 p += srclen;
9940 continue;
9941 }
9942 len = (int)STRLEN(result) - srclen + (int)STRLEN(repl) + 1;
9943 newres = alloc(len);
9944 if (newres == NULL)
9945 {
9946 vim_free(repl);
9947 vim_free(result);
9948 return NULL;
9949 }
9950 mch_memmove(newres, result, (size_t)(p - result));
9951 STRCPY(newres + (p - result), repl);
9952 len = (int)STRLEN(newres);
9953 STRCAT(newres, p + srclen);
9954 vim_free(repl);
9955 vim_free(result);
9956 result = newres;
9957 p = newres + len; /* continue after the match */
9958 }
9959 }
9960
9961 return result;
9962}
9963#endif
9964
9965#ifdef FEAT_SESSION
Bram Moolenaarcba2ae52006-10-24 10:59:57 +00009966static int ses_winsizes __ARGS((FILE *fd, int restore_size,
9967 win_T *tab_firstwin));
Bram Moolenaar071d4272004-06-13 20:20:40 +00009968static int ses_win_rec __ARGS((FILE *fd, frame_T *fr));
9969static frame_T *ses_skipframe __ARGS((frame_T *fr));
9970static int ses_do_frame __ARGS((frame_T *fr));
9971static int ses_do_win __ARGS((win_T *wp));
9972static int ses_arglist __ARGS((FILE *fd, char *cmd, garray_T *gap, int fullname, unsigned *flagp));
9973static int ses_put_fname __ARGS((FILE *fd, char_u *name, unsigned *flagp));
9974static int ses_fname __ARGS((FILE *fd, buf_T *buf, unsigned *flagp));
9975
9976/*
9977 * Write openfile commands for the current buffers to an .exrc file.
9978 * Return FAIL on error, OK otherwise.
9979 */
9980 static int
9981makeopens(fd, dirnow)
9982 FILE *fd;
9983 char_u *dirnow; /* Current directory name */
9984{
9985 buf_T *buf;
9986 int only_save_windows = TRUE;
9987 int nr;
9988 int cnr = 1;
9989 int restore_size = TRUE;
9990 win_T *wp;
9991 char_u *sname;
9992 win_T *edited_win = NULL;
Bram Moolenaar18144c82006-04-12 21:52:12 +00009993 int tabnr;
Bram Moolenaarcba2ae52006-10-24 10:59:57 +00009994 win_T *tab_firstwin;
Bram Moolenaar3b1b6c62006-11-28 20:40:00 +00009995 frame_T *tab_topframe;
Bram Moolenaarf13be0d2008-01-02 14:13:10 +00009996 int cur_arg_idx = 0;
Bram Moolenaar383c6f52008-01-04 15:01:07 +00009997 int next_arg_idx = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00009998
9999 if (ssop_flags & SSOP_BUFFERS)
10000 only_save_windows = FALSE; /* Save ALL buffers */
10001
10002 /*
10003 * Begin by setting the this_session variable, and then other
10004 * sessionable variables.
10005 */
10006#ifdef FEAT_EVAL
10007 if (put_line(fd, "let v:this_session=expand(\"<sfile>:p\")") == FAIL)
10008 return FAIL;
10009 if (ssop_flags & SSOP_GLOBALS)
10010 if (store_session_globals(fd) == FAIL)
10011 return FAIL;
10012#endif
10013
10014 /*
10015 * Close all windows but one.
10016 */
10017 if (put_line(fd, "silent only") == FAIL)
10018 return FAIL;
10019
10020 /*
10021 * Now a :cd command to the session directory or the current directory
10022 */
10023 if (ssop_flags & SSOP_SESDIR)
10024 {
Bram Moolenaar482aaeb2005-09-29 18:26:07 +000010025 if (put_line(fd, "exe \"cd \" . escape(expand(\"<sfile>:p:h\"), ' ')")
10026 == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +000010027 return FAIL;
10028 }
10029 else if (ssop_flags & SSOP_CURDIR)
10030 {
10031 sname = home_replace_save(NULL, globaldir != NULL ? globaldir : dirnow);
10032 if (sname == NULL
Bram Moolenaar482aaeb2005-09-29 18:26:07 +000010033 || fputs("cd ", fd) < 0
10034 || ses_put_fname(fd, sname, &ssop_flags) == FAIL
10035 || put_eol(fd) == FAIL)
10036 {
10037 vim_free(sname);
Bram Moolenaar071d4272004-06-13 20:20:40 +000010038 return FAIL;
Bram Moolenaar482aaeb2005-09-29 18:26:07 +000010039 }
Bram Moolenaar071d4272004-06-13 20:20:40 +000010040 vim_free(sname);
10041 }
10042
10043 /*
Bram Moolenaar293ee4d2004-12-09 21:34:53 +000010044 * If there is an empty, unnamed buffer we will wipe it out later.
10045 * Remember the buffer number.
10046 */
10047 if (put_line(fd, "if expand('%') == '' && !&modified && line('$') <= 1 && getline(1) == ''") == FAIL)
10048 return FAIL;
10049 if (put_line(fd, " let s:wipebuf = bufnr('%')") == FAIL)
10050 return FAIL;
10051 if (put_line(fd, "endif") == FAIL)
10052 return FAIL;
10053
10054 /*
Bram Moolenaar071d4272004-06-13 20:20:40 +000010055 * Now save the current files, current buffer first.
10056 */
10057 if (put_line(fd, "set shortmess=aoO") == FAIL)
10058 return FAIL;
10059
10060 /* Now put the other buffers into the buffer list */
10061 for (buf = firstbuf; buf != NULL; buf = buf->b_next)
10062 {
10063 if (!(only_save_windows && buf->b_nwindows == 0)
10064 && !(buf->b_help && !(ssop_flags & SSOP_HELP))
10065 && buf->b_fname != NULL
10066 && buf->b_p_bl)
10067 {
10068 if (fprintf(fd, "badd +%ld ", buf->b_wininfo == NULL ? 1L
10069 : buf->b_wininfo->wi_fpos.lnum) < 0
10070 || ses_fname(fd, buf, &ssop_flags) == FAIL)
10071 return FAIL;
10072 }
10073 }
10074
10075 /* the global argument list */
10076 if (ses_arglist(fd, "args", &global_alist.al_ga,
10077 !(ssop_flags & SSOP_CURDIR), &ssop_flags) == FAIL)
10078 return FAIL;
10079
10080 if (ssop_flags & SSOP_RESIZE)
10081 {
10082 /* Note: after the restore we still check it worked!*/
10083 if (fprintf(fd, "set lines=%ld columns=%ld" , Rows, Columns) < 0
10084 || put_eol(fd) == FAIL)
10085 return FAIL;
10086 }
10087
10088#ifdef FEAT_GUI
10089 if (gui.in_use && (ssop_flags & SSOP_WINPOS))
10090 {
10091 int x, y;
10092
10093 if (gui_mch_get_winpos(&x, &y) == OK)
10094 {
10095 /* Note: after the restore we still check it worked!*/
10096 if (fprintf(fd, "winpos %d %d", x, y) < 0 || put_eol(fd) == FAIL)
10097 return FAIL;
10098 }
10099 }
10100#endif
10101
10102 /*
Bram Moolenaar18144c82006-04-12 21:52:12 +000010103 * May repeat putting Windows for each tab, when "tabpages" is in
10104 * 'sessionoptions'.
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010105 * Don't use goto_tabpage(), it may change directory and trigger
10106 * autocommands.
Bram Moolenaar071d4272004-06-13 20:20:40 +000010107 */
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010108 tab_firstwin = firstwin; /* first window in tab page "tabnr" */
Bram Moolenaar3b1b6c62006-11-28 20:40:00 +000010109 tab_topframe = topframe;
Bram Moolenaar18144c82006-04-12 21:52:12 +000010110 for (tabnr = 1; ; ++tabnr)
Bram Moolenaar071d4272004-06-13 20:20:40 +000010111 {
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010112 int need_tabnew = FALSE;
10113
Bram Moolenaar18144c82006-04-12 21:52:12 +000010114 if ((ssop_flags & SSOP_TABPAGES))
Bram Moolenaar071d4272004-06-13 20:20:40 +000010115 {
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010116 tabpage_T *tp = find_tabpage(tabnr);
10117
10118 if (tp == NULL)
10119 break; /* done all tab pages */
10120 if (tp == curtab)
Bram Moolenaar3b1b6c62006-11-28 20:40:00 +000010121 {
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010122 tab_firstwin = firstwin;
Bram Moolenaar3b1b6c62006-11-28 20:40:00 +000010123 tab_topframe = topframe;
10124 }
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010125 else
Bram Moolenaar3b1b6c62006-11-28 20:40:00 +000010126 {
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010127 tab_firstwin = tp->tp_firstwin;
Bram Moolenaar3b1b6c62006-11-28 20:40:00 +000010128 tab_topframe = tp->tp_topframe;
10129 }
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010130 if (tabnr > 1)
10131 need_tabnew = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +000010132 }
Bram Moolenaar071d4272004-06-13 20:20:40 +000010133
Bram Moolenaar18144c82006-04-12 21:52:12 +000010134 /*
10135 * Before creating the window layout, try loading one file. If this
10136 * is aborted we don't end up with a number of useless windows.
10137 * This may have side effects! (e.g., compressed or network file).
10138 */
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010139 for (wp = tab_firstwin; wp != NULL; wp = wp->w_next)
Bram Moolenaar18144c82006-04-12 21:52:12 +000010140 {
10141 if (ses_do_win(wp)
10142 && wp->w_buffer->b_ffname != NULL
10143 && !wp->w_buffer->b_help
10144#ifdef FEAT_QUICKFIX
10145 && !bt_nofile(wp->w_buffer)
10146#endif
10147 )
10148 {
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010149 if (fputs(need_tabnew ? "tabedit " : "edit ", fd) < 0
Bram Moolenaar18144c82006-04-12 21:52:12 +000010150 || ses_fname(fd, wp->w_buffer, &ssop_flags) == FAIL)
10151 return FAIL;
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010152 need_tabnew = FALSE;
Bram Moolenaar18144c82006-04-12 21:52:12 +000010153 if (!wp->w_arg_idx_invalid)
10154 edited_win = wp;
10155 break;
10156 }
10157 }
Bram Moolenaar071d4272004-06-13 20:20:40 +000010158
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010159 /* If no file got edited create an empty tab page. */
10160 if (need_tabnew && put_line(fd, "tabnew") == FAIL)
10161 return FAIL;
10162
Bram Moolenaar18144c82006-04-12 21:52:12 +000010163 /*
10164 * Save current window layout.
10165 */
10166 if (put_line(fd, "set splitbelow splitright") == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +000010167 return FAIL;
Bram Moolenaar3b1b6c62006-11-28 20:40:00 +000010168 if (ses_win_rec(fd, tab_topframe) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +000010169 return FAIL;
Bram Moolenaar18144c82006-04-12 21:52:12 +000010170 if (!p_sb && put_line(fd, "set nosplitbelow") == FAIL)
10171 return FAIL;
10172 if (!p_spr && put_line(fd, "set nosplitright") == FAIL)
10173 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +000010174
Bram Moolenaar18144c82006-04-12 21:52:12 +000010175 /*
10176 * Check if window sizes can be restored (no windows omitted).
10177 * Remember the window number of the current window after restoring.
10178 */
10179 nr = 0;
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010180 for (wp = tab_firstwin; wp != NULL; wp = W_NEXT(wp))
Bram Moolenaar18144c82006-04-12 21:52:12 +000010181 {
10182 if (ses_do_win(wp))
10183 ++nr;
10184 else
10185 restore_size = FALSE;
10186 if (curwin == wp)
10187 cnr = nr;
10188 }
Bram Moolenaar071d4272004-06-13 20:20:40 +000010189
Bram Moolenaar18144c82006-04-12 21:52:12 +000010190 /* Go to the first window. */
10191 if (put_line(fd, "wincmd t") == FAIL)
10192 return FAIL;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +000010193
Bram Moolenaar18144c82006-04-12 21:52:12 +000010194 /*
10195 * If more than one window, see if sizes can be restored.
10196 * First set 'winheight' and 'winwidth' to 1 to avoid the windows being
10197 * resized when moving between windows.
10198 * Do this before restoring the view, so that the topline and the
10199 * cursor can be set. This is done again below.
10200 */
10201 if (put_line(fd, "set winheight=1 winwidth=1") == FAIL)
10202 return FAIL;
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010203 if (nr > 1 && ses_winsizes(fd, restore_size, tab_firstwin) == FAIL)
Bram Moolenaar18144c82006-04-12 21:52:12 +000010204 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +000010205
Bram Moolenaar18144c82006-04-12 21:52:12 +000010206 /*
10207 * Restore the view of the window (options, file, cursor, etc.).
10208 */
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010209 for (wp = tab_firstwin; wp != NULL; wp = wp->w_next)
Bram Moolenaar18144c82006-04-12 21:52:12 +000010210 {
10211 if (!ses_do_win(wp))
10212 continue;
Bram Moolenaarf13be0d2008-01-02 14:13:10 +000010213 if (put_view(fd, wp, wp != edited_win, &ssop_flags,
10214 cur_arg_idx) == FAIL)
Bram Moolenaar18144c82006-04-12 21:52:12 +000010215 return FAIL;
10216 if (nr > 1 && put_line(fd, "wincmd w") == FAIL)
10217 return FAIL;
Bram Moolenaarf13be0d2008-01-02 14:13:10 +000010218 next_arg_idx = wp->w_arg_idx;
Bram Moolenaar18144c82006-04-12 21:52:12 +000010219 }
10220
Bram Moolenaarf13be0d2008-01-02 14:13:10 +000010221 /* The argument index in the first tab page is zero, need to set it in
10222 * each window. For further tab pages it's the window where we do
10223 * "tabedit". */
10224 cur_arg_idx = next_arg_idx;
10225
Bram Moolenaar18144c82006-04-12 21:52:12 +000010226 /*
10227 * Restore cursor to the current window if it's not the first one.
10228 */
10229 if (cnr > 1 && (fprintf(fd, "%dwincmd w", cnr) < 0
10230 || put_eol(fd) == FAIL))
10231 return FAIL;
10232
10233 /*
Bram Moolenaar18144c82006-04-12 21:52:12 +000010234 * Restore window sizes again after jumping around in windows, because
10235 * the current window has a minimum size while others may not.
10236 */
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010237 if (nr > 1 && ses_winsizes(fd, restore_size, tab_firstwin) == FAIL)
Bram Moolenaar18144c82006-04-12 21:52:12 +000010238 return FAIL;
10239
Bram Moolenaar18144c82006-04-12 21:52:12 +000010240 /* Don't continue in another tab page when doing only the current one
10241 * or when at the last tab page. */
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010242 if (!(ssop_flags & SSOP_TABPAGES))
Bram Moolenaar18144c82006-04-12 21:52:12 +000010243 break;
10244 }
10245
10246 if (ssop_flags & SSOP_TABPAGES)
10247 {
Bram Moolenaar18144c82006-04-12 21:52:12 +000010248 if (fprintf(fd, "tabnext %d", tabpage_index(curtab)) < 0
10249 || put_eol(fd) == FAIL)
10250 return FAIL;
10251 }
10252
Bram Moolenaar9c102382006-05-03 21:26:49 +000010253 /*
10254 * Wipe out an empty unnamed buffer we started in.
10255 */
10256 if (put_line(fd, "if exists('s:wipebuf')") == FAIL)
10257 return FAIL;
Bram Moolenaarf3a67882006-05-05 21:09:41 +000010258 if (put_line(fd, " silent exe 'bwipe ' . s:wipebuf") == FAIL)
Bram Moolenaar9c102382006-05-03 21:26:49 +000010259 return FAIL;
10260 if (put_line(fd, "endif") == FAIL)
10261 return FAIL;
10262 if (put_line(fd, "unlet! s:wipebuf") == FAIL)
10263 return FAIL;
10264
10265 /* Re-apply 'winheight', 'winwidth' and 'shortmess'. */
10266 if (fprintf(fd, "set winheight=%ld winwidth=%ld shortmess=%s",
10267 p_wh, p_wiw, p_shm) < 0 || put_eol(fd) == FAIL)
10268 return FAIL;
Bram Moolenaar071d4272004-06-13 20:20:40 +000010269
10270 /*
10271 * Lastly, execute the x.vim file if it exists.
10272 */
10273 if (put_line(fd, "let s:sx = expand(\"<sfile>:p:r\").\"x.vim\"") == FAIL
10274 || put_line(fd, "if file_readable(s:sx)") == FAIL
Bram Moolenaar42ba1262008-12-09 10:18:03 +000010275 || put_line(fd, " exe \"source \" . fnameescape(s:sx)") == FAIL
Bram Moolenaar071d4272004-06-13 20:20:40 +000010276 || put_line(fd, "endif") == FAIL)
10277 return FAIL;
10278
10279 return OK;
10280}
10281
10282 static int
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010283ses_winsizes(fd, restore_size, tab_firstwin)
Bram Moolenaar071d4272004-06-13 20:20:40 +000010284 FILE *fd;
10285 int restore_size;
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010286 win_T *tab_firstwin;
Bram Moolenaar071d4272004-06-13 20:20:40 +000010287{
10288 int n = 0;
10289 win_T *wp;
10290
10291 if (restore_size && (ssop_flags & SSOP_WINSIZE))
10292 {
Bram Moolenaarcba2ae52006-10-24 10:59:57 +000010293 for (wp = tab_firstwin; wp != NULL; wp = wp->w_next)
Bram Moolenaar071d4272004-06-13 20:20:40 +000010294 {
10295 if (!ses_do_win(wp))
10296 continue;
10297 ++n;
10298
10299 /* restore height when not full height */
10300 if (wp->w_height + wp->w_status_height < topframe->fr_height
10301 && (fprintf(fd,
10302 "exe '%dresize ' . ((&lines * %ld + %ld) / %ld)",
10303 n, (long)wp->w_height, Rows / 2, Rows) < 0
10304 || put_eol(fd) == FAIL))
10305 return FAIL;
10306
10307 /* restore width when not full width */
10308 if (wp->w_width < Columns && (fprintf(fd,
10309 "exe 'vert %dresize ' . ((&columns * %ld + %ld) / %ld)",
10310 n, (long)wp->w_width, Columns / 2, Columns) < 0
10311 || put_eol(fd) == FAIL))
10312 return FAIL;
10313 }
10314 }
10315 else
10316 {
10317 /* Just equalise window sizes */
10318 if (put_line(fd, "wincmd =") == FAIL)
10319 return FAIL;
10320 }
10321 return OK;
10322}
10323
10324/*
10325 * Write commands to "fd" to recursively create windows for frame "fr",
10326 * horizontally and vertically split.
10327 * After the commands the last window in the frame is the current window.
10328 * Returns FAIL when writing the commands to "fd" fails.
10329 */
10330 static int
10331ses_win_rec(fd, fr)
10332 FILE *fd;
10333 frame_T *fr;
10334{
10335 frame_T *frc;
10336 int count = 0;
10337
10338 if (fr->fr_layout != FR_LEAF)
10339 {
10340 /* Find first frame that's not skipped and then create a window for
10341 * each following one (first frame is already there). */
10342 frc = ses_skipframe(fr->fr_child);
10343 if (frc != NULL)
10344 while ((frc = ses_skipframe(frc->fr_next)) != NULL)
10345 {
10346 /* Make window as big as possible so that we have lots of room
10347 * to split. */
10348 if (put_line(fd, "wincmd _ | wincmd |") == FAIL
10349 || put_line(fd, fr->fr_layout == FR_COL
10350 ? "split" : "vsplit") == FAIL)
10351 return FAIL;
10352 ++count;
10353 }
10354
10355 /* Go back to the first window. */
10356 if (count > 0 && (fprintf(fd, fr->fr_layout == FR_COL
10357 ? "%dwincmd k" : "%dwincmd h", count) < 0
10358 || put_eol(fd) == FAIL))
10359 return FAIL;
10360
10361 /* Recursively create frames/windows in each window of this column or
10362 * row. */
10363 frc = ses_skipframe(fr->fr_child);
10364 while (frc != NULL)
10365 {
10366 ses_win_rec(fd, frc);
10367 frc = ses_skipframe(frc->fr_next);
10368 /* Go to next window. */
10369 if (frc != NULL && put_line(fd, "wincmd w") == FAIL)
10370 return FAIL;
10371 }
10372 }
10373 return OK;
10374}
10375
10376/*
10377 * Skip frames that don't contain windows we want to save in the Session.
10378 * Returns NULL when there none.
10379 */
10380 static frame_T *
10381ses_skipframe(fr)
10382 frame_T *fr;
10383{
10384 frame_T *frc;
10385
10386 for (frc = fr; frc != NULL; frc = frc->fr_next)
10387 if (ses_do_frame(frc))
10388 break;
10389 return frc;
10390}
10391
10392/*
10393 * Return TRUE if frame "fr" has a window somewhere that we want to save in
10394 * the Session.
10395 */
10396 static int
10397ses_do_frame(fr)
10398 frame_T *fr;
10399{
10400 frame_T *frc;
10401
10402 if (fr->fr_layout == FR_LEAF)
10403 return ses_do_win(fr->fr_win);
10404 for (frc = fr->fr_child; frc != NULL; frc = frc->fr_next)
10405 if (ses_do_frame(frc))
10406 return TRUE;
10407 return FALSE;
10408}
10409
10410/*
10411 * Return non-zero if window "wp" is to be stored in the Session.
10412 */
10413 static int
10414ses_do_win(wp)
10415 win_T *wp;
10416{
10417 if (wp->w_buffer->b_fname == NULL
10418#ifdef FEAT_QUICKFIX
10419 /* When 'buftype' is "nofile" can't restore the window contents. */
10420 || bt_nofile(wp->w_buffer)
10421#endif
10422 )
10423 return (ssop_flags & SSOP_BLANK);
10424 if (wp->w_buffer->b_help)
10425 return (ssop_flags & SSOP_HELP);
10426 return TRUE;
10427}
10428
10429/*
10430 * Write commands to "fd" to restore the view of a window.
10431 * Caller must make sure 'scrolloff' is zero.
10432 */
10433 static int
Bram Moolenaarf13be0d2008-01-02 14:13:10 +000010434put_view(fd, wp, add_edit, flagp, current_arg_idx)
Bram Moolenaar071d4272004-06-13 20:20:40 +000010435 FILE *fd;
10436 win_T *wp;
10437 int add_edit; /* add ":edit" command to view */
10438 unsigned *flagp; /* vop_flags or ssop_flags */
Bram Moolenaarf13be0d2008-01-02 14:13:10 +000010439 int current_arg_idx; /* current argument index of the window, use
10440 * -1 if unknown */
Bram Moolenaar071d4272004-06-13 20:20:40 +000010441{
10442 win_T *save_curwin;
10443 int f;
10444 int do_cursor;
Bram Moolenaarf95dc3b2005-05-22 22:02:25 +000010445 int did_next = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +000010446
10447 /* Always restore cursor position for ":mksession". For ":mkview" only
10448 * when 'viewoptions' contains "cursor". */
10449 do_cursor = (flagp == &ssop_flags || *flagp & SSOP_CURSOR);
10450
10451 /*
10452 * Local argument list.
10453 */
10454 if (wp->w_alist == &global_alist)
10455 {
10456 if (put_line(fd, "argglobal") == FAIL)
10457 return FAIL;
10458 }
10459 else
10460 {
10461 if (ses_arglist(fd, "arglocal", &wp->w_alist->al_ga,
10462 flagp == &vop_flags
10463 || !(*flagp & SSOP_CURDIR)
10464 || wp->w_localdir != NULL, flagp) == FAIL)
10465 return FAIL;
10466 }
10467
Bram Moolenaarf95dc3b2005-05-22 22:02:25 +000010468 /* Only when part of a session: restore the argument index. Some
10469 * arguments may have been deleted, check if the index is valid. */
Bram Moolenaar51f53df2010-06-26 05:25:54 +020010470 if (wp->w_arg_idx != current_arg_idx && wp->w_arg_idx < WARGCOUNT(wp)
Bram Moolenaarf95dc3b2005-05-22 22:02:25 +000010471 && flagp == &ssop_flags)
Bram Moolenaar071d4272004-06-13 20:20:40 +000010472 {
Bram Moolenaarf13be0d2008-01-02 14:13:10 +000010473 if (fprintf(fd, "%ldargu", (long)wp->w_arg_idx + 1) < 0
Bram Moolenaar071d4272004-06-13 20:20:40 +000010474 || put_eol(fd) == FAIL)
10475 return FAIL;
Bram Moolenaarf95dc3b2005-05-22 22:02:25 +000010476 did_next = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +000010477 }
10478
10479 /* Edit the file. Skip this when ":next" already did it. */
Bram Moolenaarf95dc3b2005-05-22 22:02:25 +000010480 if (add_edit && (!did_next || wp->w_arg_idx_invalid))
Bram Moolenaar071d4272004-06-13 20:20:40 +000010481 {
10482 /*
10483 * Load the file.
10484 */
10485 if (wp->w_buffer->b_ffname != NULL
10486#ifdef FEAT_QUICKFIX
10487 && !bt_nofile(wp->w_buffer)
10488#endif
10489 )
10490 {
10491 /*
10492 * Editing a file in this buffer: use ":edit file".
10493 * This may have side effects! (e.g., compressed or network file).
10494 */
10495 if (fputs("edit ", fd) < 0
10496 || ses_fname(fd, wp->w_buffer, flagp) == FAIL)
10497 return FAIL;
10498 }
10499 else
10500 {
10501 /* No file in this buffer, just make it empty. */
10502 if (put_line(fd, "enew") == FAIL)
10503 return FAIL;
10504#ifdef FEAT_QUICKFIX
10505 if (wp->w_buffer->b_ffname != NULL)
10506 {
10507 /* The buffer does have a name, but it's not a file name. */
10508 if (fputs("file ", fd) < 0
10509 || ses_fname(fd, wp->w_buffer, flagp) == FAIL)
10510 return FAIL;
10511 }
10512#endif
10513 do_cursor = FALSE;
10514 }
10515 }
10516
10517 /*
10518 * Local mappings and abbreviations.
10519 */
10520 if ((*flagp & (SSOP_OPTIONS | SSOP_LOCALOPTIONS))
10521 && makemap(fd, wp->w_buffer) == FAIL)
10522 return FAIL;
10523
10524 /*
10525 * Local options. Need to go to the window temporarily.
10526 * Store only local values when using ":mkview" and when ":mksession" is
10527 * used and 'sessionoptions' doesn't include "options".
10528 * Some folding options are always stored when "folds" is included,
10529 * otherwise the folds would not be restored correctly.
10530 */
10531 save_curwin = curwin;
10532 curwin = wp;
10533 curbuf = curwin->w_buffer;
10534 if (*flagp & (SSOP_OPTIONS | SSOP_LOCALOPTIONS))
10535 f = makeset(fd, OPT_LOCAL,
10536 flagp == &vop_flags || !(*flagp & SSOP_OPTIONS));
10537#ifdef FEAT_FOLDING
10538 else if (*flagp & SSOP_FOLDS)
10539 f = makefoldset(fd);
10540#endif
10541 else
10542 f = OK;
10543 curwin = save_curwin;
10544 curbuf = curwin->w_buffer;
10545 if (f == FAIL)
10546 return FAIL;
10547
10548#ifdef FEAT_FOLDING
10549 /*
10550 * Save Folds when 'buftype' is empty and for help files.
10551 */
10552 if ((*flagp & SSOP_FOLDS)
10553 && wp->w_buffer->b_ffname != NULL
Bram Moolenaarb1b715d2006-01-21 22:09:43 +000010554# ifdef FEAT_QUICKFIX
10555 && (*wp->w_buffer->b_p_bt == NUL || wp->w_buffer->b_help)
10556# endif
10557 )
Bram Moolenaar071d4272004-06-13 20:20:40 +000010558 {
10559 if (put_folds(fd, wp) == FAIL)
10560 return FAIL;
10561 }
10562#endif
10563
10564 /*
10565 * Set the cursor after creating folds, since that moves the cursor.
10566 */
10567 if (do_cursor)
10568 {
10569
10570 /* Restore the cursor line in the file and relatively in the
10571 * window. Don't use "G", it changes the jumplist. */
10572 if (fprintf(fd, "let s:l = %ld - ((%ld * winheight(0) + %ld) / %ld)",
10573 (long)wp->w_cursor.lnum,
10574 (long)(wp->w_cursor.lnum - wp->w_topline),
10575 (long)wp->w_height / 2, (long)wp->w_height) < 0
10576 || put_eol(fd) == FAIL
10577 || put_line(fd, "if s:l < 1 | let s:l = 1 | endif") == FAIL
10578 || put_line(fd, "exe s:l") == FAIL
10579 || put_line(fd, "normal! zt") == FAIL
10580 || fprintf(fd, "%ld", (long)wp->w_cursor.lnum) < 0
10581 || put_eol(fd) == FAIL)
10582 return FAIL;
10583 /* Restore the cursor column and left offset when not wrapping. */
10584 if (wp->w_cursor.col == 0)
10585 {
10586 if (put_line(fd, "normal! 0") == FAIL)
10587 return FAIL;
10588 }
10589 else
10590 {
10591 if (!wp->w_p_wrap && wp->w_leftcol > 0 && wp->w_width > 0)
10592 {
10593 if (fprintf(fd,
10594 "let s:c = %ld - ((%ld * winwidth(0) + %ld) / %ld)",
10595 (long)wp->w_cursor.col,
10596 (long)(wp->w_cursor.col - wp->w_leftcol),
10597 (long)wp->w_width / 2, (long)wp->w_width) < 0
10598 || put_eol(fd) == FAIL
10599 || put_line(fd, "if s:c > 0") == FAIL
10600 || fprintf(fd,
10601 " exe 'normal! 0' . s:c . 'lzs' . (%ld - s:c) . 'l'",
10602 (long)wp->w_cursor.col) < 0
10603 || put_eol(fd) == FAIL
10604 || put_line(fd, "else") == FAIL
10605 || fprintf(fd, " normal! 0%dl", wp->w_cursor.col) < 0
10606 || put_eol(fd) == FAIL
10607 || put_line(fd, "endif") == FAIL)
10608 return FAIL;
10609 }
10610 else
10611 {
10612 if (fprintf(fd, "normal! 0%dl", wp->w_cursor.col) < 0
10613 || put_eol(fd) == FAIL)
10614 return FAIL;
10615 }
10616 }
10617 }
10618
10619 /*
10620 * Local directory.
10621 */
10622 if (wp->w_localdir != NULL)
10623 {
10624 if (fputs("lcd ", fd) < 0
10625 || ses_put_fname(fd, wp->w_localdir, flagp) == FAIL
10626 || put_eol(fd) == FAIL)
10627 return FAIL;
Bram Moolenaareeefcc72007-05-01 21:21:21 +000010628 did_lcd = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +000010629 }
10630
10631 return OK;
10632}
10633
10634/*
10635 * Write an argument list to the session file.
10636 * Returns FAIL if writing fails.
10637 */
10638 static int
10639ses_arglist(fd, cmd, gap, fullname, flagp)
10640 FILE *fd;
10641 char *cmd;
10642 garray_T *gap;
10643 int fullname; /* TRUE: use full path name */
10644 unsigned *flagp;
10645{
10646 int i;
10647 char_u buf[MAXPATHL];
10648 char_u *s;
10649
10650 if (gap->ga_len == 0)
10651 return put_line(fd, "silent! argdel *");
10652 if (fputs(cmd, fd) < 0)
10653 return FAIL;
10654 for (i = 0; i < gap->ga_len; ++i)
10655 {
10656 /* NULL file names are skipped (only happens when out of memory). */
10657 s = alist_name(&((aentry_T *)gap->ga_data)[i]);
10658 if (s != NULL)
10659 {
10660 if (fullname)
10661 {
10662 (void)vim_FullName(s, buf, MAXPATHL, FALSE);
10663 s = buf;
10664 }
10665 if (fputs(" ", fd) < 0 || ses_put_fname(fd, s, flagp) == FAIL)
10666 return FAIL;
10667 }
10668 }
10669 return put_eol(fd);
10670}
10671
10672/*
10673 * Write a buffer name to the session file.
10674 * Also ends the line.
10675 * Returns FAIL if writing fails.
10676 */
10677 static int
10678ses_fname(fd, buf, flagp)
10679 FILE *fd;
10680 buf_T *buf;
10681 unsigned *flagp;
10682{
10683 char_u *name;
10684
10685 /* Use the short file name if the current directory is known at the time
Bram Moolenaareeefcc72007-05-01 21:21:21 +000010686 * the session file will be sourced.
10687 * Don't do this for ":mkview", we don't know the current directory.
10688 * Don't do this after ":lcd", we don't keep track of what the current
10689 * directory is. */
Bram Moolenaar071d4272004-06-13 20:20:40 +000010690 if (buf->b_sfname != NULL
10691 && flagp == &ssop_flags
Bram Moolenaareeefcc72007-05-01 21:21:21 +000010692 && (ssop_flags & (SSOP_CURDIR | SSOP_SESDIR))
Bram Moolenaar8d594672009-07-01 18:18:57 +000010693#ifdef FEAT_AUTOCHDIR
10694 && !p_acd
10695#endif
Bram Moolenaareeefcc72007-05-01 21:21:21 +000010696 && !did_lcd)
Bram Moolenaar071d4272004-06-13 20:20:40 +000010697 name = buf->b_sfname;
10698 else
10699 name = buf->b_ffname;
10700 if (ses_put_fname(fd, name, flagp) == FAIL || put_eol(fd) == FAIL)
10701 return FAIL;
10702 return OK;
10703}
10704
10705/*
10706 * Write a file name to the session file.
10707 * Takes care of the "slash" option in 'sessionoptions' and escapes special
10708 * characters.
10709 * Returns FAIL if writing fails.
10710 */
10711 static int
10712ses_put_fname(fd, name, flagp)
10713 FILE *fd;
10714 char_u *name;
10715 unsigned *flagp;
10716{
10717 char_u *sname;
10718 int retval = OK;
10719 int c;
10720
10721 sname = home_replace_save(NULL, name);
10722 if (sname != NULL)
10723 name = sname;
10724 while (*name != NUL)
10725 {
10726#ifdef FEAT_MBYTE
10727 {
10728 int l;
10729
Bram Moolenaar0fa313a2005-08-10 21:07:57 +000010730 if (has_mbyte && (l = (*mb_ptr2len)(name)) > 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +000010731 {
10732 /* copy a multibyte char */
10733 while (--l >= 0)
10734 {
10735 if (putc(*name, fd) != *name)
10736 retval = FAIL;
10737 ++name;
10738 }
10739 continue;
10740 }
10741 }
10742#endif
10743 c = *name++;
10744 if (c == '\\' && (*flagp & SSOP_SLASH))
10745 /* change a backslash to a forward slash */
10746 c = '/';
10747 else if ((vim_strchr(escape_chars, c) != NULL
10748#ifdef BACKSLASH_IN_FILENAME
10749 && c != '\\'
10750#endif
10751 ) || c == '#' || c == '%')
10752 {
10753 /* escape a special character with a backslash */
10754 if (putc('\\', fd) != '\\')
10755 retval = FAIL;
10756 }
10757 if (putc(c, fd) != c)
10758 retval = FAIL;
10759 }
10760 vim_free(sname);
10761 return retval;
10762}
10763
10764/*
10765 * ":loadview [nr]"
10766 */
10767 static void
10768ex_loadview(eap)
10769 exarg_T *eap;
10770{
10771 char_u *fname;
10772
10773 fname = get_view_file(*eap->arg);
10774 if (fname != NULL)
10775 {
Bram Moolenaar910f66f2006-04-05 20:41:53 +000010776 do_source(fname, FALSE, DOSO_NONE);
Bram Moolenaar071d4272004-06-13 20:20:40 +000010777 vim_free(fname);
10778 }
10779}
10780
10781/*
10782 * Get the name of the view file for the current buffer.
10783 */
10784 static char_u *
10785get_view_file(c)
10786 int c;
10787{
10788 int len = 0;
10789 char_u *p, *s;
10790 char_u *retval;
10791 char_u *sname;
10792
10793 if (curbuf->b_ffname == NULL)
10794 {
10795 EMSG(_(e_noname));
10796 return NULL;
10797 }
10798 sname = home_replace_save(NULL, curbuf->b_ffname);
10799 if (sname == NULL)
10800 return NULL;
10801
10802 /*
10803 * We want a file name without separators, because we're not going to make
10804 * a directory.
10805 * "normal" path separator -> "=+"
10806 * "=" -> "=="
10807 * ":" path separator -> "=-"
10808 */
10809 for (p = sname; *p; ++p)
10810 if (*p == '=' || vim_ispathsep(*p))
10811 ++len;
10812 retval = alloc((unsigned)(STRLEN(sname) + len + STRLEN(p_vdir) + 9));
10813 if (retval != NULL)
10814 {
10815 STRCPY(retval, p_vdir);
10816 add_pathsep(retval);
10817 s = retval + STRLEN(retval);
10818 for (p = sname; *p; ++p)
10819 {
10820 if (*p == '=')
10821 {
10822 *s++ = '=';
10823 *s++ = '=';
10824 }
10825 else if (vim_ispathsep(*p))
10826 {
10827 *s++ = '=';
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +000010828#if defined(BACKSLASH_IN_FILENAME) || defined(AMIGA) || defined(RISCOS) \
Bram Moolenaar071d4272004-06-13 20:20:40 +000010829 || defined(VMS)
10830 if (*p == ':')
10831 *s++ = '-';
10832 else
Bram Moolenaar071d4272004-06-13 20:20:40 +000010833#endif
Bram Moolenaarcef9dcc2005-12-06 19:50:41 +000010834 *s++ = '+';
Bram Moolenaar071d4272004-06-13 20:20:40 +000010835 }
10836 else
10837 *s++ = *p;
10838 }
10839 *s++ = '=';
10840 *s++ = c;
10841 STRCPY(s, ".vim");
10842 }
10843
10844 vim_free(sname);
10845 return retval;
10846}
10847
10848#endif /* FEAT_SESSION */
10849
10850/*
10851 * Write end-of-line character(s) for ":mkexrc", ":mkvimrc" and ":mksession".
10852 * Return FAIL for a write error.
10853 */
10854 int
10855put_eol(fd)
10856 FILE *fd;
10857{
10858 if (
10859#ifdef USE_CRNL
10860 (
10861# ifdef MKSESSION_NL
10862 !mksession_nl &&
10863# endif
10864 (putc('\r', fd) < 0)) ||
10865#endif
10866 (putc('\n', fd) < 0))
10867 return FAIL;
10868 return OK;
10869}
10870
10871/*
10872 * Write a line to "fd".
10873 * Return FAIL for a write error.
10874 */
10875 int
10876put_line(fd, s)
10877 FILE *fd;
10878 char *s;
10879{
10880 if (fputs(s, fd) < 0 || put_eol(fd) == FAIL)
10881 return FAIL;
10882 return OK;
10883}
10884
10885#ifdef FEAT_VIMINFO
10886/*
10887 * ":rviminfo" and ":wviminfo".
10888 */
10889 static void
10890ex_viminfo(eap)
10891 exarg_T *eap;
10892{
10893 char_u *save_viminfo;
10894
10895 save_viminfo = p_viminfo;
10896 if (*p_viminfo == NUL)
10897 p_viminfo = (char_u *)"'100";
10898 if (eap->cmdidx == CMD_rviminfo)
10899 {
Bram Moolenaard812df62008-11-09 12:46:09 +000010900 if (read_viminfo(eap->arg, VIF_WANT_INFO | VIF_WANT_MARKS
10901 | (eap->forceit ? VIF_FORCEIT : 0)) == FAIL)
Bram Moolenaar071d4272004-06-13 20:20:40 +000010902 EMSG(_("E195: Cannot open viminfo file for reading"));
10903 }
10904 else
10905 write_viminfo(eap->arg, eap->forceit);
10906 p_viminfo = save_viminfo;
10907}
10908#endif
10909
10910#if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG) || defined(PROTO)
Bram Moolenaar9c13b352005-05-19 20:53:52 +000010911/*
10912 * Make a dialog message in "buff[IOSIZE]".
Bram Moolenaarb765d632005-06-07 21:00:02 +000010913 * "format" must contain "%s".
Bram Moolenaar9c13b352005-05-19 20:53:52 +000010914 */
Bram Moolenaar071d4272004-06-13 20:20:40 +000010915 void
10916dialog_msg(buff, format, fname)
10917 char_u *buff;
10918 char *format;
10919 char_u *fname;
10920{
Bram Moolenaar071d4272004-06-13 20:20:40 +000010921 if (fname == NULL)
10922 fname = (char_u *)_("Untitled");
Bram Moolenaarb765d632005-06-07 21:00:02 +000010923 vim_snprintf((char *)buff, IOSIZE, format, fname);
Bram Moolenaar071d4272004-06-13 20:20:40 +000010924}
10925#endif
10926
10927/*
10928 * ":behave {mswin,xterm}"
10929 */
10930 static void
10931ex_behave(eap)
10932 exarg_T *eap;
10933{
10934 if (STRCMP(eap->arg, "mswin") == 0)
10935 {
10936 set_option_value((char_u *)"selection", 0L, (char_u *)"exclusive", 0);
10937 set_option_value((char_u *)"selectmode", 0L, (char_u *)"mouse,key", 0);
10938 set_option_value((char_u *)"mousemodel", 0L, (char_u *)"popup", 0);
10939 set_option_value((char_u *)"keymodel", 0L,
10940 (char_u *)"startsel,stopsel", 0);
10941 }
10942 else if (STRCMP(eap->arg, "xterm") == 0)
10943 {
10944 set_option_value((char_u *)"selection", 0L, (char_u *)"inclusive", 0);
10945 set_option_value((char_u *)"selectmode", 0L, (char_u *)"", 0);
10946 set_option_value((char_u *)"mousemodel", 0L, (char_u *)"extend", 0);
10947 set_option_value((char_u *)"keymodel", 0L, (char_u *)"", 0);
10948 }
10949 else
10950 EMSG2(_(e_invarg2), eap->arg);
10951}
10952
Bram Moolenaar42b4dda2010-03-02 15:56:05 +010010953#if defined(FEAT_CMDL_COMPL) || defined(PROTO)
10954/*
10955 * Function given to ExpandGeneric() to obtain the possible arguments of the
10956 * ":behave {mswin,xterm}" command.
10957 */
10958 char_u *
10959get_behave_arg(xp, idx)
10960 expand_T *xp UNUSED;
10961 int idx;
10962{
10963 if (idx == 0)
10964 return (char_u *)"mswin";
10965 if (idx == 1)
10966 return (char_u *)"xterm";
10967 return NULL;
10968}
10969#endif
10970
Bram Moolenaar071d4272004-06-13 20:20:40 +000010971#ifdef FEAT_AUTOCMD
10972static int filetype_detect = FALSE;
10973static int filetype_plugin = FALSE;
10974static int filetype_indent = FALSE;
10975
10976/*
10977 * ":filetype [plugin] [indent] {on,off,detect}"
10978 * on: Load the filetype.vim file to install autocommands for file types.
10979 * off: Load the ftoff.vim file to remove all autocommands for file types.
10980 * plugin on: load filetype.vim and ftplugin.vim
10981 * plugin off: load ftplugof.vim
10982 * indent on: load filetype.vim and indent.vim
10983 * indent off: load indoff.vim
10984 */
10985 static void
10986ex_filetype(eap)
10987 exarg_T *eap;
10988{
10989 char_u *arg = eap->arg;
10990 int plugin = FALSE;
10991 int indent = FALSE;
10992
10993 if (*eap->arg == NUL)
10994 {
10995 /* Print current status. */
10996 smsg((char_u *)"filetype detection:%s plugin:%s indent:%s",
10997 filetype_detect ? "ON" : "OFF",
10998 filetype_plugin ? (filetype_detect ? "ON" : "(on)") : "OFF",
10999 filetype_indent ? (filetype_detect ? "ON" : "(on)") : "OFF");
11000 return;
11001 }
11002
11003 /* Accept "plugin" and "indent" in any order. */
11004 for (;;)
11005 {
11006 if (STRNCMP(arg, "plugin", 6) == 0)
11007 {
11008 plugin = TRUE;
11009 arg = skipwhite(arg + 6);
11010 continue;
11011 }
11012 if (STRNCMP(arg, "indent", 6) == 0)
11013 {
11014 indent = TRUE;
11015 arg = skipwhite(arg + 6);
11016 continue;
11017 }
11018 break;
11019 }
11020 if (STRCMP(arg, "on") == 0 || STRCMP(arg, "detect") == 0)
11021 {
11022 if (*arg == 'o' || !filetype_detect)
11023 {
Bram Moolenaare5b8e3d2005-08-12 19:48:49 +000011024 source_runtime((char_u *)FILETYPE_FILE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +000011025 filetype_detect = TRUE;
11026 if (plugin)
11027 {
Bram Moolenaare5b8e3d2005-08-12 19:48:49 +000011028 source_runtime((char_u *)FTPLUGIN_FILE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +000011029 filetype_plugin = TRUE;
11030 }
11031 if (indent)
11032 {
Bram Moolenaare5b8e3d2005-08-12 19:48:49 +000011033 source_runtime((char_u *)INDENT_FILE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +000011034 filetype_indent = TRUE;
11035 }
11036 }
11037 if (*arg == 'd')
11038 {
11039 (void)do_doautocmd((char_u *)"filetypedetect BufRead", TRUE);
Bram Moolenaara3227e22006-03-08 21:32:40 +000011040 do_modelines(0);
Bram Moolenaar071d4272004-06-13 20:20:40 +000011041 }
11042 }
11043 else if (STRCMP(arg, "off") == 0)
11044 {
11045 if (plugin || indent)
11046 {
11047 if (plugin)
11048 {
Bram Moolenaare5b8e3d2005-08-12 19:48:49 +000011049 source_runtime((char_u *)FTPLUGOF_FILE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +000011050 filetype_plugin = FALSE;
11051 }
11052 if (indent)
11053 {
Bram Moolenaare5b8e3d2005-08-12 19:48:49 +000011054 source_runtime((char_u *)INDOFF_FILE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +000011055 filetype_indent = FALSE;
11056 }
11057 }
11058 else
11059 {
Bram Moolenaare5b8e3d2005-08-12 19:48:49 +000011060 source_runtime((char_u *)FTOFF_FILE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +000011061 filetype_detect = FALSE;
11062 }
11063 }
11064 else
11065 EMSG2(_(e_invarg2), arg);
11066}
11067
11068/*
11069 * ":setfiletype {name}"
11070 */
11071 static void
11072ex_setfiletype(eap)
11073 exarg_T *eap;
11074{
11075 if (!did_filetype)
11076 set_option_value((char_u *)"filetype", 0L, eap->arg, OPT_LOCAL);
11077}
11078#endif
11079
Bram Moolenaar071d4272004-06-13 20:20:40 +000011080 static void
11081ex_digraphs(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +000011082 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +000011083{
11084#ifdef FEAT_DIGRAPHS
11085 if (*eap->arg != NUL)
11086 putdigraph(eap->arg);
11087 else
11088 listdigraphs();
11089#else
11090 EMSG(_("E196: No digraphs in this version"));
11091#endif
11092}
11093
11094 static void
11095ex_set(eap)
11096 exarg_T *eap;
11097{
11098 int flags = 0;
11099
11100 if (eap->cmdidx == CMD_setlocal)
11101 flags = OPT_LOCAL;
11102 else if (eap->cmdidx == CMD_setglobal)
11103 flags = OPT_GLOBAL;
11104#if defined(FEAT_EVAL) && defined(FEAT_AUTOCMD) && defined(FEAT_BROWSE)
11105 if (cmdmod.browse && flags == 0)
11106 ex_options(eap);
11107 else
11108#endif
11109 (void)do_set(eap->arg, flags);
11110}
11111
11112#ifdef FEAT_SEARCH_EXTRA
11113/*
11114 * ":nohlsearch"
11115 */
Bram Moolenaar071d4272004-06-13 20:20:40 +000011116 static void
11117ex_nohlsearch(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +000011118 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +000011119{
11120 no_hlsearch = TRUE;
Bram Moolenaarf71a3db2006-03-12 21:50:18 +000011121 redraw_all_later(SOME_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +000011122}
11123
11124/*
Bram Moolenaare1438bb2006-03-01 22:01:55 +000011125 * ":[N]match {group} {pattern}"
Bram Moolenaar071d4272004-06-13 20:20:40 +000011126 * Sets nextcmd to the start of the next command, if any. Also called when
11127 * skipping commands to find the next command.
11128 */
11129 static void
11130ex_match(eap)
11131 exarg_T *eap;
11132{
11133 char_u *p;
Bram Moolenaar52d36c82007-08-11 14:00:30 +000011134 char_u *g = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +000011135 char_u *end;
11136 int c;
Bram Moolenaar6ee10162007-07-26 20:58:42 +000011137 int id;
Bram Moolenaare1438bb2006-03-01 22:01:55 +000011138
11139 if (eap->line2 <= 3)
Bram Moolenaar6ee10162007-07-26 20:58:42 +000011140 id = eap->line2;
Bram Moolenaare1438bb2006-03-01 22:01:55 +000011141 else
11142 {
11143 EMSG(e_invcmd);
11144 return;
11145 }
Bram Moolenaar071d4272004-06-13 20:20:40 +000011146
11147 /* First clear any old pattern. */
11148 if (!eap->skip)
Bram Moolenaar6ee10162007-07-26 20:58:42 +000011149 match_delete(curwin, id, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +000011150
11151 if (ends_excmd(*eap->arg))
11152 end = eap->arg;
11153 else if ((STRNICMP(eap->arg, "none", 4) == 0
11154 && (vim_iswhite(eap->arg[4]) || ends_excmd(eap->arg[4]))))
11155 end = eap->arg + 4;
11156 else
11157 {
11158 p = skiptowhite(eap->arg);
11159 if (!eap->skip)
Bram Moolenaar6ee10162007-07-26 20:58:42 +000011160 g = vim_strnsave(eap->arg, (int)(p - eap->arg));
Bram Moolenaar071d4272004-06-13 20:20:40 +000011161 p = skipwhite(p);
11162 if (*p == NUL)
11163 {
11164 /* There must be two arguments. */
11165 EMSG2(_(e_invarg2), eap->arg);
11166 return;
11167 }
11168 end = skip_regexp(p + 1, *p, TRUE, NULL);
11169 if (!eap->skip)
11170 {
11171 if (*end != NUL && !ends_excmd(*skipwhite(end + 1)))
11172 {
11173 eap->errmsg = e_trailing;
11174 return;
11175 }
Bram Moolenaar7e8fd632006-02-18 22:14:51 +000011176 if (*end != *p)
11177 {
11178 EMSG2(_(e_invarg2), p);
11179 return;
11180 }
Bram Moolenaar071d4272004-06-13 20:20:40 +000011181
11182 c = *end;
11183 *end = NUL;
Bram Moolenaar6ee10162007-07-26 20:58:42 +000011184 match_add(curwin, g, p + 1, 10, id);
11185 vim_free(g);
Bram Moolenaar910f66f2006-04-05 20:41:53 +000011186 *end = c;
Bram Moolenaar071d4272004-06-13 20:20:40 +000011187 }
11188 }
11189 eap->nextcmd = find_nextcmd(end);
11190}
11191#endif
11192
11193#ifdef FEAT_CRYPT
11194/*
11195 * ":X": Get crypt key
11196 */
Bram Moolenaar071d4272004-06-13 20:20:40 +000011197 static void
11198ex_X(eap)
Bram Moolenaar78a15312009-05-15 19:33:18 +000011199 exarg_T *eap UNUSED;
Bram Moolenaar071d4272004-06-13 20:20:40 +000011200{
Bram Moolenaar49771f42010-07-20 17:32:38 +020011201 if (get_crypt_method(curbuf) == 0 || blowfish_self_test() == OK)
Bram Moolenaar40e6a712010-05-16 22:32:54 +020011202 (void)get_crypt_key(TRUE, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +000011203}
11204#endif
11205
11206#ifdef FEAT_FOLDING
11207 static void
11208ex_fold(eap)
11209 exarg_T *eap;
11210{
11211 if (foldManualAllowed(TRUE))
11212 foldCreate(eap->line1, eap->line2);
11213}
11214
11215 static void
11216ex_foldopen(eap)
11217 exarg_T *eap;
11218{
11219 opFoldRange(eap->line1, eap->line2, eap->cmdidx == CMD_foldopen,
11220 eap->forceit, FALSE);
11221}
11222
11223 static void
11224ex_folddo(eap)
11225 exarg_T *eap;
11226{
11227 linenr_T lnum;
11228
11229 /* First set the marks for all lines closed/open. */
11230 for (lnum = eap->line1; lnum <= eap->line2; ++lnum)
11231 if (hasFolding(lnum, NULL, NULL) == (eap->cmdidx == CMD_folddoclosed))
11232 ml_setmarked(lnum);
11233
11234 /* Execute the command on the marked lines. */
11235 global_exe(eap->arg);
11236 ml_clearmarked(); /* clear rest of the marks */
11237}
11238#endif