/* vi:set ts=8 sts=4 sw=4 noet:

*

* VIM - Vi IMproved by Bram Moolenaar

*

* Do ":help uganda" in Vim to read copying and usage conditions.

* Do ":help credits" in Vim to see a list of people who contributed.

* See README.txt for an overview of the Vim source code.

*/

/*

* ex_docmd.c: functions for executing an Ex command line.

*/

#include "vim.h"

static int quitmore = 0;

static int ex_pressedreturn = FALSE;

#ifndef FEAT_PRINTER

# define ex_hardcopy ex_ni

#endif

#ifdef FEAT_EVAL

static char_u *do_one_cmd(char_u **, int, struct condstack *, char_u *(*fgetline)(int, void *, int, int), void *cookie);

#else

static char_u *do_one_cmd(char_u **, int, char_u *(*fgetline)(int, void *, int, int), void *cookie);

static int if_level = 0; /* depth in :if */

#endif

static void free_cmdmod(void);

static void append_command(char_u *cmd);

static char_u *find_command(exarg_T *eap, int *full);

#ifndef FEAT_MENU

# define ex_emenu ex_ni

# define ex_menu ex_ni

# define ex_menutranslate ex_ni

#endif

static void ex_autocmd(exarg_T *eap);

static void ex_doautocmd(exarg_T *eap);

static void ex_bunload(exarg_T *eap);

static void ex_buffer(exarg_T *eap);

static void ex_bmodified(exarg_T *eap);

static void ex_bnext(exarg_T *eap);

static void ex_bprevious(exarg_T *eap);

static void ex_brewind(exarg_T *eap);

static void ex_blast(exarg_T *eap);

static char_u *getargcmd(char_u **);

static int getargopt(exarg_T *eap);

#ifndef FEAT_QUICKFIX

# define ex_make ex_ni

# define ex_cbuffer ex_ni

# define ex_cc ex_ni

# define ex_cnext ex_ni

# define ex_cbelow ex_ni

# define ex_cfile ex_ni

# define qf_list ex_ni

# define qf_age ex_ni

# define qf_history ex_ni

# define ex_helpgrep ex_ni

# define ex_vimgrep ex_ni

#endif

#if !defined(FEAT_QUICKFIX)

# define ex_cclose ex_ni

# define ex_copen ex_ni

# define ex_cwindow ex_ni

# define ex_cbottom ex_ni

#endif

#if !defined(FEAT_QUICKFIX) || !defined(FEAT_EVAL)

# define ex_cexpr ex_ni

#endif

static linenr_T get_address(exarg_T *, char_u **, cmd_addr_T addr_type, int skip, int silent, int to_other_file, int address_count);

static void get_flags(exarg_T *eap);

#if !defined(FEAT_PERL) \

|| !defined(FEAT_PYTHON) || !defined(FEAT_PYTHON3) \

|| !defined(FEAT_TCL) \

|| !defined(FEAT_RUBY) \

|| !defined(FEAT_LUA) \

|| !defined(FEAT_MZSCHEME)

# define HAVE_EX_SCRIPT_NI

static void ex_script_ni(exarg_T *eap);

#endif

static char *invalid_range(exarg_T *eap);

static void correct_range(exarg_T *eap);

#ifdef FEAT_QUICKFIX

static char_u *replace_makeprg(exarg_T *eap, char_u *p, char_u **cmdlinep);

#endif

static char_u *repl_cmdline(exarg_T *eap, char_u *src, int srclen, char_u *repl, char_u **cmdlinep);

static void ex_highlight(exarg_T *eap);

static void ex_colorscheme(exarg_T *eap);

static void ex_cquit(exarg_T *eap);

static void ex_quit_all(exarg_T *eap);

static void ex_close(exarg_T *eap);

static void ex_win_close(int forceit, win_T *win, tabpage_T *tp);

static void ex_only(exarg_T *eap);

static void ex_resize(exarg_T *eap);

static void ex_stag(exarg_T *eap);

static void ex_tabclose(exarg_T *eap);

static void ex_tabonly(exarg_T *eap);

static void ex_tabnext(exarg_T *eap);

static void ex_tabmove(exarg_T *eap);

static void ex_tabs(exarg_T *eap);

#if defined(FEAT_QUICKFIX)

static void ex_pclose(exarg_T *eap);

static void ex_ptag(exarg_T *eap);

static void ex_pedit(exarg_T *eap);

#else

# define ex_pclose ex_ni

# define ex_ptag ex_ni

# define ex_pedit ex_ni

#endif

static void ex_hide(exarg_T *eap);

static void ex_stop(exarg_T *eap);

static void ex_exit(exarg_T *eap);

static void ex_print(exarg_T *eap);

#ifdef FEAT_BYTEOFF

static void ex_goto(exarg_T *eap);

#else

# define ex_goto ex_ni

#endif

static void ex_shell(exarg_T *eap);

static void ex_preserve(exarg_T *eap);

static void ex_recover(exarg_T *eap);

static void ex_mode(exarg_T *eap);

static void ex_wrongmodifier(exarg_T *eap);

static void ex_find(exarg_T *eap);

static void ex_open(exarg_T *eap);

#ifndef FEAT_GUI

# define ex_gui ex_nogui

static void ex_nogui(exarg_T *eap);

#endif

#if defined(FEAT_GUI_MSWIN) && defined(FEAT_MENU) && defined(FEAT_TEAROFF)

static void ex_tearoff(exarg_T *eap);

#else

# define ex_tearoff ex_ni

#endif

#if (defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_GTK) \

|| defined(FEAT_GUI_MACVIM) \

|| defined(FEAT_TERM_POPUP_MENU)) && defined(FEAT_MENU)

static void ex_popup(exarg_T *eap);

#else

# define ex_popup ex_ni

#endif

#ifndef FEAT_GUI_MSWIN

# define ex_simalt ex_ni

#endif

#if !(defined(FEAT_GUI_MSWIN) || defined(FEAT_GUI_GTK) || \

defined(FEAT_GUI_MOTIF) || defined(FEAT_GUI_MACVIM))

# define gui_mch_find_dialog ex_ni

# define gui_mch_replace_dialog ex_ni

#endif

#if !defined(FEAT_GUI_GTK)

# define ex_helpfind ex_ni

#endif

#ifndef FEAT_CSCOPE

# define ex_cscope ex_ni

# define ex_scscope ex_ni

# define ex_cstag ex_ni

#endif

#ifndef FEAT_SYN_HL

# define ex_syntax ex_ni

# define ex_ownsyntax ex_ni

#endif

#if !defined(FEAT_SYN_HL) || !defined(FEAT_PROFILE)

# define ex_syntime ex_ni

#endif

#ifndef FEAT_SPELL

# define ex_spell ex_ni

# define ex_mkspell ex_ni

# define ex_spelldump ex_ni

# define ex_spellinfo ex_ni

# define ex_spellrepall ex_ni

#endif

#ifndef FEAT_PERSISTENT_UNDO

# define ex_rundo ex_ni

# define ex_wundo ex_ni

#endif

#ifndef FEAT_LUA

# define ex_lua ex_script_ni

# define ex_luado ex_ni

# define ex_luafile ex_ni

#endif

#ifndef FEAT_MZSCHEME

# define ex_mzscheme ex_script_ni

# define ex_mzfile ex_ni

#endif

#ifndef FEAT_PERL

# define ex_perl ex_script_ni

# define ex_perldo ex_ni

#endif

#ifndef FEAT_PYTHON

# define ex_python ex_script_ni

# define ex_pydo ex_ni

# define ex_pyfile ex_ni

#endif

#ifndef FEAT_PYTHON3

# define ex_py3 ex_script_ni

# define ex_py3do ex_ni

# define ex_py3file ex_ni

#endif

#if !defined(FEAT_PYTHON) && !defined(FEAT_PYTHON3)

# define ex_pyx ex_script_ni

# define ex_pyxdo ex_ni

# define ex_pyxfile ex_ni

#endif

#ifndef FEAT_TCL

# define ex_tcl ex_script_ni

# define ex_tcldo ex_ni

# define ex_tclfile ex_ni

#endif

#ifndef FEAT_RUBY

# define ex_ruby ex_script_ni

# define ex_rubydo ex_ni

# define ex_rubyfile ex_ni

#endif

#ifndef FEAT_KEYMAP

# define ex_loadkeymap ex_ni

#endif

static void ex_swapname(exarg_T *eap);

static void ex_syncbind(exarg_T *eap);

static void ex_read(exarg_T *eap);

static void ex_pwd(exarg_T *eap);

static void ex_equal(exarg_T *eap);

static void ex_sleep(exarg_T *eap);

static void ex_winsize(exarg_T *eap);

static void ex_wincmd(exarg_T *eap);

#if defined(FEAT_GUI) || defined(UNIX) || defined(VMS) || defined(MSWIN)

static void ex_winpos(exarg_T *eap);

#else

# define ex_winpos ex_ni

#endif

static void ex_operators(exarg_T *eap);

static void ex_put(exarg_T *eap);

static void ex_copymove(exarg_T *eap);

static void ex_submagic(exarg_T *eap);

static void ex_join(exarg_T *eap);

static void ex_at(exarg_T *eap);

static void ex_bang(exarg_T *eap);

static void ex_undo(exarg_T *eap);

#ifdef FEAT_PERSISTENT_UNDO

static void ex_wundo(exarg_T *eap);

static void ex_rundo(exarg_T *eap);

#endif

static void ex_redo(exarg_T *eap);

static void ex_later(exarg_T *eap);

static void ex_redir(exarg_T *eap);

static void ex_redrawstatus(exarg_T *eap);

static void ex_redrawtabline(exarg_T *eap);

static void close_redir(void);

static void ex_mark(exarg_T *eap);

static void ex_startinsert(exarg_T *eap);

static void ex_stopinsert(exarg_T *eap);

#ifdef FEAT_FIND_ID

static void ex_checkpath(exarg_T *eap);

static void ex_findpat(exarg_T *eap);

#else

# define ex_findpat ex_ni

# define ex_checkpath ex_ni

#endif

#if defined(FEAT_FIND_ID) && defined(FEAT_QUICKFIX)

static void ex_psearch(exarg_T *eap);

#else

# define ex_psearch ex_ni

#endif

static void ex_tag(exarg_T *eap);

static void ex_tag_cmd(exarg_T *eap, char_u *name);

#ifndef FEAT_EVAL

# define ex_break ex_ni

# define ex_breakadd ex_ni

# define ex_breakdel ex_ni

# define ex_breaklist ex_ni

# define ex_call ex_ni

# define ex_catch ex_ni

# define ex_compiler ex_ni

# define ex_const ex_ni

# define ex_continue ex_ni

# define ex_debug ex_ni

# define ex_debuggreedy ex_ni

# define ex_delfunction ex_ni

# define ex_echo ex_ni

# define ex_echohl ex_ni

# define ex_else ex_ni

# define ex_endfunction ex_ni

# define ex_endif ex_ni

# define ex_endtry ex_ni

# define ex_endwhile ex_ni

# define ex_eval ex_ni

# define ex_execute ex_ni

# define ex_finally ex_ni

# define ex_finish ex_ni

# define ex_function ex_ni

# define ex_if ex_ni

# define ex_let ex_ni

# define ex_lockvar ex_ni

# define ex_oldfiles ex_ni

# define ex_options ex_ni

# define ex_packadd ex_ni

# define ex_packloadall ex_ni

# define ex_return ex_ni

# define ex_scriptnames ex_ni

# define ex_throw ex_ni

# define ex_try ex_ni

# define ex_unlet ex_ni

# define ex_unlockvar ex_ni

# define ex_while ex_ni

#endif

#ifndef FEAT_SESSION

# define ex_loadview ex_ni

#endif

#ifndef FEAT_VIMINFO

# define ex_viminfo ex_ni

#endif

static void ex_behave(exarg_T *eap);

static void ex_filetype(exarg_T *eap);

static void ex_setfiletype(exarg_T *eap);

#ifndef FEAT_DIFF

# define ex_diffoff ex_ni

# define ex_diffpatch ex_ni

# define ex_diffgetput ex_ni

# define ex_diffsplit ex_ni

# define ex_diffthis ex_ni

# define ex_diffupdate ex_ni

#endif

static void ex_digraphs(exarg_T *eap);

static void ex_set(exarg_T *eap);

#ifdef FEAT_SEARCH_EXTRA

static void ex_nohlsearch(exarg_T *eap);

#else

# define ex_nohlsearch ex_ni

# define ex_match ex_ni

#endif

#ifdef FEAT_CRYPT

static void ex_X(exarg_T *eap);

#else

# define ex_X ex_ni

#endif

#ifdef FEAT_FOLDING

static void ex_fold(exarg_T *eap);

static void ex_foldopen(exarg_T *eap);

static void ex_folddo(exarg_T *eap);

#else

# define ex_fold ex_ni

# define ex_foldopen ex_ni

# define ex_folddo ex_ni

#endif

#if !(defined(HAVE_LOCALE_H) || defined(X_LOCALE))

# define ex_language ex_ni

#endif

#ifndef FEAT_SIGNS

# define ex_sign ex_ni

#endif

#ifndef FEAT_NETBEANS_INTG

# define ex_nbclose ex_ni

# define ex_nbkey ex_ni

# define ex_nbstart ex_ni

#endif

#ifndef FEAT_JUMPLIST

# define ex_jumps ex_ni

# define ex_clearjumps ex_ni

# define ex_changes ex_ni

#endif

#ifndef FEAT_PROFILE

# define ex_profile ex_ni

#endif

#ifndef FEAT_TERMINAL

# define ex_terminal ex_ni

#endif

#if !defined(FEAT_X11) || !defined(FEAT_XCLIPBOARD)

# define ex_xrestore ex_ni

#endif

#if !defined(FEAT_TEXT_PROP)

# define ex_popupclear ex_ni

#endif

#ifndef FEAT_GUI_MACVIM

# define ex_macaction ex_ni

# define ex_macmenu ex_ni

#endif

/*

* Declare cmdnames[].

*/

#define DO_DECLARE_EXCMD

#include "ex_cmds.h"

#include "ex_cmdidxs.h"

static char_u dollar_command[2] = {'$', 0};

#ifdef FEAT_EVAL

/* Struct for storing a line inside a while/for loop */

typedef struct

{

char_u *line; /* command line */

linenr_T lnum; /* sourcing_lnum of the line */

} wcmd_T;

/*

* Structure used to store info for line position in a while or for loop.

* This is required, because do_one_cmd() may invoke ex_function(), which

* reads more lines that may come from the while/for loop.

*/

struct loop_cookie

{

garray_T *lines_gap; /* growarray with line info */

int current_line; /* last read line from growarray */

int repeating; /* TRUE when looping a second time */

/* When "repeating" is FALSE use "getline" and "cookie" to get lines */

char_u *(*getline)(int, void *, int, int);

void *cookie;

};

static char_u *get_loop_line(int c, void *cookie, int indent, int do_concat);

static int store_loop_line(garray_T *gap, char_u *line);

static void free_cmdlines(garray_T *gap);

/* Struct to save a few things while debugging. Used in do_cmdline() only. */

struct dbg_stuff

{

int trylevel;

int force_abort;

except_T *caught_stack;

char_u *vv_exception;

char_u *vv_throwpoint;

int did_emsg;

int got_int;

int did_throw;

int need_rethrow;

int check_cstack;

except_T *current_exception;

};

static void

save_dbg_stuff(struct dbg_stuff *dsp)

{

dsp->trylevel = trylevel; trylevel = 0;

dsp->force_abort = force_abort; force_abort = FALSE;

dsp->caught_stack = caught_stack; caught_stack = NULL;

dsp->vv_exception = v_exception(NULL);

dsp->vv_throwpoint = v_throwpoint(NULL);

/* Necessary for debugging an inactive ":catch", ":finally", ":endtry" */

dsp->did_emsg = did_emsg; did_emsg = FALSE;

dsp->got_int = got_int; got_int = FALSE;

dsp->did_throw = did_throw; did_throw = FALSE;

dsp->need_rethrow = need_rethrow; need_rethrow = FALSE;

dsp->check_cstack = check_cstack; check_cstack = FALSE;

dsp->current_exception = current_exception; current_exception = NULL;

}

static void

restore_dbg_stuff(struct dbg_stuff *dsp)

{

suppress_errthrow = FALSE;

trylevel = dsp->trylevel;

force_abort = dsp->force_abort;

caught_stack = dsp->caught_stack;

(void)v_exception(dsp->vv_exception);

(void)v_throwpoint(dsp->vv_throwpoint);

did_emsg = dsp->did_emsg;

got_int = dsp->got_int;

did_throw = dsp->did_throw;

need_rethrow = dsp->need_rethrow;

check_cstack = dsp->check_cstack;

current_exception = dsp->current_exception;

}

#endif

/*

* do_exmode(): Repeatedly get commands for the "Ex" mode, until the ":vi"

* command is given.

*/

void

do_exmode(

int improved) /* TRUE for "improved Ex" mode */

{

int save_msg_scroll;

int prev_msg_row;

linenr_T prev_line;

varnumber_T changedtick;

if (improved)

exmode_active = EXMODE_VIM;

else

exmode_active = EXMODE_NORMAL;

State = NORMAL;

/* When using ":global /pat/ visual" and then "Q" we return to continue

* the :global command. */

if (global_busy)

return;

save_msg_scroll = msg_scroll;

++RedrawingDisabled; /* don't redisplay the window */

++no_wait_return; /* don't wait for return */

#ifdef FEAT_GUI

/* Ignore scrollbar and mouse events in Ex mode */

++hold_gui_events;

#endif

msg(_("Entering Ex mode. Type \"visual\" to go to Normal mode."));

while (exmode_active)

{

/* Check for a ":normal" command and no more characters left. */

if (ex_normal_busy > 0 && typebuf.tb_len == 0)

{

exmode_active = FALSE;

break;

}

msg_scroll = TRUE;

need_wait_return = FALSE;

ex_pressedreturn = FALSE;

ex_no_reprint = FALSE;

changedtick = CHANGEDTICK(curbuf);

prev_msg_row = msg_row;

prev_line = curwin->w_cursor.lnum;

if (improved)

{

cmdline_row = msg_row;

do_cmdline(NULL, getexline, NULL, 0);

}

else

do_cmdline(NULL, getexmodeline, NULL, DOCMD_NOWAIT);

lines_left = Rows - 1;

if ((prev_line != curwin->w_cursor.lnum

|| changedtick != CHANGEDTICK(curbuf)) && !ex_no_reprint)

{

if (curbuf->b_ml.ml_flags & ML_EMPTY)

emsg(_(e_emptybuf));

else

{

if (ex_pressedreturn)

{

/* go up one line, to overwrite the ":<CR>" line, so the

* output doesn't contain empty lines. */

msg_row = prev_msg_row;

if (prev_msg_row == Rows - 1)

msg_row--;

}

msg_col = 0;

print_line_no_prefix(curwin->w_cursor.lnum, FALSE, FALSE);

msg_clr_eos();

}

}

else if (ex_pressedreturn && !ex_no_reprint) /* must be at EOF */

{

if (curbuf->b_ml.ml_flags & ML_EMPTY)

emsg(_(e_emptybuf));

else

emsg(_("E501: At end-of-file"));

}

}

#ifdef FEAT_GUI

--hold_gui_events;

#endif

--RedrawingDisabled;

--no_wait_return;

update_screen(CLEAR);

need_wait_return = FALSE;

msg_scroll = save_msg_scroll;

}

/*

* Print the executed command for when 'verbose' is set.

* When "lnum" is 0 only print the command.

*/

static void

msg_verbose_cmd(linenr_T lnum, char_u *cmd)

{

++no_wait_return;

verbose_enter_scroll();

if (lnum == 0)

smsg(_("Executing: %s"), cmd);

else

smsg(_("line %ld: %s"), (long)lnum, cmd);

if (msg_silent == 0)

msg_puts("\n"); // don't overwrite this

verbose_leave_scroll();

--no_wait_return;

}

/*

* Execute a simple command line. Used for translated commands like "*".

*/

int

do_cmdline_cmd(char_u *cmd)

{

return do_cmdline(cmd, NULL, NULL,

DOCMD_VERBOSE|DOCMD_NOWAIT|DOCMD_KEYTYPED);

}

/*

* do_cmdline(): execute one Ex command line

*

* 1. Execute "cmdline" when it is not NULL.

* If "cmdline" is NULL, or more lines are needed, fgetline() is used.

* 2. Split up in parts separated with '|'.

*

* This function can be called recursively!

*

* flags:

* DOCMD_VERBOSE - The command will be included in the error message.

* DOCMD_NOWAIT - Don't call wait_return() and friends.

* DOCMD_REPEAT - Repeat execution until fgetline() returns NULL.

* DOCMD_KEYTYPED - Don't reset KeyTyped.

* DOCMD_EXCRESET - Reset the exception environment (used for debugging).

* DOCMD_KEEPLINE - Store first typed line (for repeating with ".").

*

* return FAIL if cmdline could not be executed, OK otherwise

*/

int

do_cmdline(

char_u *cmdline,

char_u *(*fgetline)(int, void *, int, int),

void *cookie, /* argument for fgetline() */

int flags)

{

char_u *next_cmdline; /* next cmd to execute */

char_u *cmdline_copy = NULL; /* copy of cmd line */

int used_getline = FALSE; /* used "fgetline" to obtain command */

static int recursive = 0; /* recursive depth */

int msg_didout_before_start = 0;

int count = 0; /* line number count */

int did_inc = FALSE; /* incremented RedrawingDisabled */

int retval = OK;

#ifdef FEAT_EVAL

struct condstack cstack; /* conditional stack */

garray_T lines_ga; /* keep lines for ":while"/":for" */

int current_line = 0; /* active line in lines_ga */

char_u *fname = NULL; /* function or script name */

linenr_T *breakpoint = NULL; /* ptr to breakpoint field in cookie */

int *dbg_tick = NULL; /* ptr to dbg_tick field in cookie */

struct dbg_stuff debug_saved; /* saved things for debug mode */

int initial_trylevel;

struct msglist **saved_msg_list = NULL;

struct msglist *private_msg_list;

/* "fgetline" and "cookie" passed to do_one_cmd() */

char_u *(*cmd_getline)(int, void *, int, int);

void *cmd_cookie;

struct loop_cookie cmd_loop_cookie;

void *real_cookie;

int getline_is_func;

#else

# define cmd_getline fgetline

# define cmd_cookie cookie

#endif

static int call_depth = 0; /* recursiveness */

#ifdef FEAT_EVAL

/* For every pair of do_cmdline()/do_one_cmd() calls, use an extra memory

* location for storing error messages to be converted to an exception.

* This ensures that the do_errthrow() call in do_one_cmd() does not

* combine the messages stored by an earlier invocation of do_one_cmd()

* with the command name of the later one. This would happen when

* BufWritePost autocommands are executed after a write error. */

saved_msg_list = msg_list;

msg_list = &private_msg_list;

private_msg_list = NULL;

#endif

/* It's possible to create an endless loop with ":execute", catch that

* here. The value of 200 allows nested function calls, ":source", etc.

* Allow 200 or 'maxfuncdepth', whatever is larger. */

if (call_depth >= 200

#ifdef FEAT_EVAL

&& call_depth >= p_mfd

#endif

)

{

emsg(_("E169: Command too recursive"));

#ifdef FEAT_EVAL

/* When converting to an exception, we do not include the command name

* since this is not an error of the specific command. */

do_errthrow((struct condstack *)NULL, (char_u *)NULL);

msg_list = saved_msg_list;

#endif

return FAIL;

}

++call_depth;

#ifdef FEAT_EVAL

cstack.cs_idx = -1;

cstack.cs_looplevel = 0;

cstack.cs_trylevel = 0;

cstack.cs_emsg_silent_list = NULL;

cstack.cs_lflags = 0;

ga_init2(&lines_ga, (int)sizeof(wcmd_T), 10);

real_cookie = getline_cookie(fgetline, cookie);

/* Inside a function use a higher nesting level. */

getline_is_func = getline_equal(fgetline, cookie, get_func_line);

if (getline_is_func && ex_nesting_level == func_level(real_cookie))

++ex_nesting_level;

/* Get the function or script name and the address where the next breakpoint

* line and the debug tick for a function or script are stored. */

if (getline_is_func)

{

fname = func_name(real_cookie);

breakpoint = func_breakpoint(real_cookie);

dbg_tick = func_dbg_tick(real_cookie);

}

else if (getline_equal(fgetline, cookie, getsourceline))

{

fname = sourcing_name;

breakpoint = source_breakpoint(real_cookie);

dbg_tick = source_dbg_tick(real_cookie);

}

/*

* Initialize "force_abort" and "suppress_errthrow" at the top level.

*/

if (!recursive)

{

force_abort = FALSE;

suppress_errthrow = FALSE;

}

/*

* If requested, store and reset the global values controlling the

* exception handling (used when debugging). Otherwise clear it to avoid

* a bogus compiler warning when the optimizer uses inline functions...

*/

if (flags & DOCMD_EXCRESET)

save_dbg_stuff(&debug_saved);

else

vim_memset(&debug_saved, 0, sizeof(debug_saved));

initial_trylevel = trylevel;

/*

* "did_throw" will be set to TRUE when an exception is being thrown.

*/

did_throw = FALSE;

#endif

/*

* "did_emsg" will be set to TRUE when emsg() is used, in which case we

* cancel the whole command line, and any if/endif or loop.

* If force_abort is set, we cancel everything.

*/

did_emsg = FALSE;

/*

* KeyTyped is only set when calling vgetc(). Reset it here when not

* calling vgetc() (sourced command lines).

*/

if (!(flags & DOCMD_KEYTYPED)

&& !getline_equal(fgetline, cookie, getexline))

KeyTyped = FALSE;

/*

* Continue executing command lines:

* - when inside an ":if", ":while" or ":for"

* - for multiple commands on one line, separated with '|'

* - when repeating until there are no more lines (for ":source")

*/

next_cmdline = cmdline;

do

{

#ifdef FEAT_EVAL

getline_is_func = getline_equal(fgetline, cookie, get_func_line);

#endif

/* stop skipping cmds for an error msg after all endif/while/for */

if (next_cmdline == NULL

#ifdef FEAT_EVAL

&& !force_abort

&& cstack.cs_idx < 0

&& !(getline_is_func && func_has_abort(real_cookie))

#endif

)

did_emsg = FALSE;

/*

* 1. If repeating a line in a loop, get a line from lines_ga.

* 2. If no line given: Get an allocated line with fgetline().

* 3. If a line is given: Make a copy, so we can mess with it.

*/

#ifdef FEAT_EVAL

/* 1. If repeating, get a previous line from lines_ga. */

if (cstack.cs_looplevel > 0 && current_line < lines_ga.ga_len)

{

/* Each '|' separated command is stored separately in lines_ga, to

* be able to jump to it. Don't use next_cmdline now. */

VIM_CLEAR(cmdline_copy);

/* Check if a function has returned or, unless it has an unclosed

* try conditional, aborted. */

if (getline_is_func)

{

# ifdef FEAT_PROFILE

if (do_profiling == PROF_YES)

func_line_end(real_cookie);

# endif

if (func_has_ended(real_cookie))

{

retval = FAIL;

break;

}

}

#ifdef FEAT_PROFILE

else if (do_profiling == PROF_YES

&& getline_equal(fgetline, cookie, getsourceline))

script_line_end();

#endif

/* Check if a sourced file hit a ":finish" command. */

if (source_finished(fgetline, cookie))

{

retval = FAIL;

break;

}

/* If breakpoints have been added/deleted need to check for it. */

if (breakpoint != NULL && dbg_tick != NULL

&& *dbg_tick != debug_tick)

{

*breakpoint = dbg_find_breakpoint(

getline_equal(fgetline, cookie, getsourceline),

fname, sourcing_lnum);

*dbg_tick = debug_tick;

}

next_cmdline = ((wcmd_T *)(lines_ga.ga_data))[current_line].line;

sourcing_lnum = ((wcmd_T *)(lines_ga.ga_data))[current_line].lnum;

/* Did we encounter a breakpoint? */

if (breakpoint != NULL && *breakpoint != 0

&& *breakpoint <= sourcing_lnum)

{

dbg_breakpoint(fname, sourcing_lnum);

/* Find next breakpoint. */

*breakpoint = dbg_find_breakpoint(

getline_equal(fgetline, cookie, getsourceline),

fname, sourcing_lnum);

*dbg_tick = debug_tick;

}

# ifdef FEAT_PROFILE

if (do_profiling == PROF_YES)

{

if (getline_is_func)

func_line_start(real_cookie);

else if (getline_equal(fgetline, cookie, getsourceline))

script_line_start();

}

# endif

}

if (cstack.cs_looplevel > 0)

{

/* Inside a while/for loop we need to store the lines and use them

* again. Pass a different "fgetline" function to do_one_cmd()

* below, so that it stores lines in or reads them from

* "lines_ga". Makes it possible to define a function inside a

* while/for loop. */

cmd_getline = get_loop_line;

cmd_cookie = (void *)&cmd_loop_cookie;

cmd_loop_cookie.lines_gap = &lines_ga;

cmd_loop_cookie.current_line = current_line;

cmd_loop_cookie.getline = fgetline;

cmd_loop_cookie.cookie = cookie;

cmd_loop_cookie.repeating = (current_line < lines_ga.ga_len);

}

else

{

cmd_getline = fgetline;

cmd_cookie = cookie;

}

#endif

/* 2. If no line given, get an allocated line with fgetline(). */

if (next_cmdline == NULL)

{

/*

* Need to set msg_didout for the first line after an ":if",

* otherwise the ":if" will be overwritten.

*/

if (count == 1 && getline_equal(fgetline, cookie, getexline))

msg_didout = TRUE;

if (fgetline == NULL || (next_cmdline = fgetline(':', cookie,

#ifdef FEAT_EVAL

cstack.cs_idx < 0 ? 0 : (cstack.cs_idx + 1) * 2

#else

0

#endif

, TRUE)) == NULL)

{

/* Don't call wait_return for aborted command line. The NULL

* returned for the end of a sourced file or executed function

* doesn't do this. */

if (KeyTyped && !(flags & DOCMD_REPEAT))

need_wait_return = FALSE;

retval = FAIL;

break;

}

used_getline = TRUE;

/*

* Keep the first typed line. Clear it when more lines are typed.

*/

if (flags & DOCMD_KEEPLINE)

{

vim_free(repeat_cmdline);

if (count == 0)

repeat_cmdline = vim_strsave(next_cmdline);

else

repeat_cmdline = NULL;

}

}

/* 3. Make a copy of the command so we can mess with it. */

else if (cmdline_copy == NULL)

{

next_cmdline = vim_strsave(next_cmdline);

if (next_cmdline == NULL)

{

emsg(_(e_outofmem));

retval = FAIL;

break;

}

}

cmdline_copy = next_cmdline;

#ifdef FEAT_EVAL

/*

* Save the current line when inside a ":while" or ":for", and when

* the command looks like a ":while" or ":for", because we may need it

* later. When there is a '|' and another command, it is stored

* separately, because we need to be able to jump back to it from an

* :endwhile/:endfor.

*/

if (current_line == lines_ga.ga_len

&& (cstack.cs_looplevel || has_loop_cmd(next_cmdline)))

{

if (store_loop_line(&lines_ga, next_cmdline) == FAIL)

{

retval = FAIL;

break;

}

}

did_endif = FALSE;

#endif

if (count++ == 0)

{

/*

* All output from the commands is put below each other, without

* waiting for a return. Don't do this when executing commands

* from a script or when being called recursive (e.g. for ":e

* +command file").

*/

if (!(flags & DOCMD_NOWAIT) && !recursive)

{

msg_didout_before_start = msg_didout;

msg_didany = FALSE; /* no output yet */

msg_start();

msg_scroll = TRUE; /* put messages below each other */

++no_wait_return; /* don't wait for return until finished */

++RedrawingDisabled;

did_inc = TRUE;

}

}

if (p_verbose >= 15 && sourcing_name != NULL)

msg_verbose_cmd(sourcing_lnum, cmdline_copy);

/*

* 2. Execute one '|' separated command.

* do_one_cmd() will return NULL if there is no trailing '|'.

* "cmdline_copy" can change, e.g. for '%' and '#' expansion.

*/

++recursive;

next_cmdline = do_one_cmd(&cmdline_copy, flags & DOCMD_VERBOSE,

#ifdef FEAT_EVAL

&cstack,

#endif

cmd_getline, cmd_cookie);

--recursive;

#ifdef FEAT_EVAL

if (cmd_cookie == (void *)&cmd_loop_cookie)

/* Use "current_line" from "cmd_loop_cookie", it may have been

* incremented when defining a function. */

current_line = cmd_loop_cookie.current_line;

#endif

if (next_cmdline == NULL)

{

VIM_CLEAR(cmdline_copy);

/*

* If the command was typed, remember it for the ':' register.