blob: b504763dfccfe533bf821401e25509945788080e [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9
10/*
11 * ex_eval.c: functions for Ex command line for the +eval feature.
12 */
13
14#include "vim.h"
15
16#if defined(FEAT_EVAL) || defined(PROTO)
17
Bram Moolenaarddef1292019-12-16 17:10:33 +010018static char *get_end_emsg(cstack_T *cstack);
Bram Moolenaar071d4272004-06-13 20:20:40 +000019
20/*
21 * Exception handling terms:
22 *
23 * :try ":try" command \
24 * ... try block |
25 * :catch RE ":catch" command |
26 * ... catch clause |- try conditional
27 * :finally ":finally" command |
28 * ... finally clause |
29 * :endtry ":endtry" command /
30 *
31 * The try conditional may have any number of catch clauses and at most one
32 * finally clause. A ":throw" command can be inside the try block, a catch
33 * clause, the finally clause, or in a function called or script sourced from
34 * there or even outside the try conditional. Try conditionals may be nested.
35 */
36
37/*
38 * Configuration whether an exception is thrown on error or interrupt. When
39 * the preprocessor macros below evaluate to FALSE, an error (did_emsg) or
40 * interrupt (got_int) under an active try conditional terminates the script
41 * after the non-active finally clauses of all active try conditionals have been
42 * executed. Otherwise, errors and/or interrupts are converted into catchable
43 * exceptions (did_throw additionally set), which terminate the script only if
44 * not caught. For user exceptions, only did_throw is set. (Note: got_int can
Bram Moolenaar84a05ac2013-05-06 04:24:17 +020045 * be set asynchronously afterwards by a SIGINT, so did_throw && got_int is not
Bram Moolenaar071d4272004-06-13 20:20:40 +000046 * a reliant test that the exception currently being thrown is an interrupt
47 * exception. Similarly, did_emsg can be set afterwards on an error in an
48 * (unskipped) conditional command inside an inactive conditional, so did_throw
49 * && did_emsg is not a reliant test that the exception currently being thrown
50 * is an error exception.) - The macros can be defined as expressions checking
51 * for a variable that is allowed to be changed during execution of a script.
52 */
53#if 0
Bram Moolenaar217e1b82019-12-01 21:41:28 +010054// Expressions used for testing during the development phase.
Bram Moolenaar071d4272004-06-13 20:20:40 +000055# define THROW_ON_ERROR (!eval_to_number("$VIMNOERRTHROW"))
56# define THROW_ON_INTERRUPT (!eval_to_number("$VIMNOINTTHROW"))
57# define THROW_TEST
58#else
Bram Moolenaar217e1b82019-12-01 21:41:28 +010059// Values used for the Vim release.
Bram Moolenaar071d4272004-06-13 20:20:40 +000060# define THROW_ON_ERROR TRUE
Bram Moolenaaraf0167f2009-05-16 15:31:32 +000061# define THROW_ON_ERROR_TRUE
Bram Moolenaar071d4272004-06-13 20:20:40 +000062# define THROW_ON_INTERRUPT TRUE
Bram Moolenaaraf0167f2009-05-16 15:31:32 +000063# define THROW_ON_INTERRUPT_TRUE
Bram Moolenaar071d4272004-06-13 20:20:40 +000064#endif
65
Bram Moolenaar071d4272004-06-13 20:20:40 +000066/*
67 * When several errors appear in a row, setting "force_abort" is delayed until
68 * the failing command returned. "cause_abort" is set to TRUE meanwhile, in
69 * order to indicate that situation. This is useful when "force_abort" was set
70 * during execution of a function call from an expression: the aborting of the
71 * expression evaluation is done without producing any error messages, but all
72 * error messages on parsing errors during the expression evaluation are given
73 * (even if a try conditional is active).
74 */
75static int cause_abort = FALSE;
76
77/*
Bram Moolenaarccc18222007-05-10 18:25:20 +000078 * Return TRUE when immediately aborting on error, or when an interrupt
Bram Moolenaar071d4272004-06-13 20:20:40 +000079 * occurred or an exception was thrown but not caught. Use for ":{range}call"
80 * to check whether an aborted function that does not handle a range itself
81 * should be called again for the next line in the range. Also used for
82 * cancelling expression evaluation after a function call caused an immediate
83 * abort. Note that the first emsg() call temporarily resets "force_abort"
84 * until the throw point for error messages has been reached. That is, during
85 * cancellation of an expression evaluation after an aborting function call or
86 * due to a parsing error, aborting() always returns the same value.
Bram Moolenaar67a2deb2019-11-25 00:05:32 +010087 * "got_int" is also set by calling interrupt().
Bram Moolenaar071d4272004-06-13 20:20:40 +000088 */
89 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +010090aborting(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +000091{
92 return (did_emsg && force_abort) || got_int || did_throw;
93}
94
95/*
96 * The value of "force_abort" is temporarily reset by the first emsg() call
97 * during an expression evaluation, and "cause_abort" is used instead. It might
98 * be necessary to restore "force_abort" even before the throw point for the
99 * error message has been reached. update_force_abort() should be called then.
100 */
101 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100102update_force_abort(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000103{
104 if (cause_abort)
105 force_abort = TRUE;
106}
107
108/*
109 * Return TRUE if a command with a subcommand resulting in "retcode" should
110 * abort the script processing. Can be used to suppress an autocommand after
111 * execution of a failing subcommand as long as the error message has not been
112 * displayed and actually caused the abortion.
113 */
114 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100115should_abort(int retcode)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000116{
117 return ((retcode == FAIL && trylevel != 0 && !emsg_silent) || aborting());
118}
119
120/*
121 * Return TRUE if a function with the "abort" flag should not be considered
122 * ended on an error. This means that parsing commands is continued in order
123 * to find finally clauses to be executed, and that some errors in skipped
124 * commands are still reported.
125 */
126 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100127aborted_in_try(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000128{
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100129 // This function is only called after an error. In this case, "force_abort"
130 // determines whether searching for finally clauses is necessary.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000131 return force_abort;
132}
133
134/*
135 * cause_errthrow(): Cause a throw of an error exception if appropriate.
136 * Return TRUE if the error message should not be displayed by emsg().
137 * Sets "ignore", if the emsg() call should be ignored completely.
138 *
139 * When several messages appear in the same command, the first is usually the
140 * most specific one and used as the exception value. The "severe" flag can be
141 * set to TRUE, if a later but severer message should be used instead.
142 */
143 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100144cause_errthrow(
145 char_u *mesg,
146 int severe,
147 int *ignore)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000148{
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200149 msglist_T *elem;
150 msglist_T **plist;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000151
152 /*
Bram Moolenaar57657d82006-04-21 22:12:41 +0000153 * Do nothing when displaying the interrupt message or reporting an
154 * uncaught exception (which has already been discarded then) at the top
155 * level. Also when no exception can be thrown. The message will be
156 * displayed by emsg().
Bram Moolenaar071d4272004-06-13 20:20:40 +0000157 */
158 if (suppress_errthrow)
159 return FALSE;
160
161 /*
Bram Moolenaar57657d82006-04-21 22:12:41 +0000162 * If emsg() has not been called previously, temporarily reset
163 * "force_abort" until the throw point for error messages has been
164 * reached. This ensures that aborting() returns the same value for all
165 * errors that appear in the same command. This means particularly that
166 * for parsing errors during expression evaluation emsg() will be called
167 * multiply, even when the expression is evaluated from a finally clause
168 * that was activated due to an aborting error, interrupt, or exception.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000169 */
170 if (!did_emsg)
171 {
172 cause_abort = force_abort;
173 force_abort = FALSE;
174 }
175
176 /*
177 * If no try conditional is active and no exception is being thrown and
178 * there has not been an error in a try conditional or a throw so far, do
Bram Moolenaar57657d82006-04-21 22:12:41 +0000179 * nothing (for compatibility of non-EH scripts). The message will then
180 * be displayed by emsg(). When ":silent!" was used and we are not
181 * currently throwing an exception, do nothing. The message text will
182 * then be stored to v:errmsg by emsg() without displaying it.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000183 */
184 if (((trylevel == 0 && !cause_abort) || emsg_silent) && !did_throw)
185 return FALSE;
186
187 /*
188 * Ignore an interrupt message when inside a try conditional or when an
Bram Moolenaar57657d82006-04-21 22:12:41 +0000189 * exception is being thrown or when an error in a try conditional or
190 * throw has been detected previously. This is important in order that an
Bram Moolenaar071d4272004-06-13 20:20:40 +0000191 * interrupt exception is catchable by the innermost try conditional and
192 * not replaced by an interrupt message error exception.
193 */
194 if (mesg == (char_u *)_(e_interr))
195 {
196 *ignore = TRUE;
197 return TRUE;
198 }
199
200 /*
201 * Ensure that all commands in nested function calls and sourced files
202 * are aborted immediately.
203 */
204 cause_abort = TRUE;
205
206 /*
207 * When an exception is being thrown, some commands (like conditionals) are
208 * not skipped. Errors in those commands may affect what of the subsequent
209 * commands are regarded part of catch and finally clauses. Catching the
210 * exception would then cause execution of commands not intended by the
211 * user, who wouldn't even get aware of the problem. Therefor, discard the
212 * exception currently being thrown to prevent it from being caught. Just
213 * execute finally clauses and terminate.
214 */
215 if (did_throw)
216 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100217 // When discarding an interrupt exception, reset got_int to prevent the
218 // same interrupt being converted to an exception again and discarding
219 // the error exception we are about to throw here.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000220 if (current_exception->type == ET_INTERRUPT)
221 got_int = FALSE;
222 discard_current_exception();
223 }
224
225#ifdef THROW_TEST
226 if (!THROW_ON_ERROR)
227 {
228 /*
229 * Print error message immediately without searching for a matching
230 * catch clause; just finally clauses are executed before the script
231 * is terminated.
232 */
233 return FALSE;
234 }
235 else
236#endif
237 {
238 /*
239 * Prepare the throw of an error exception, so that everything will
240 * be aborted (except for executing finally clauses), until the error
241 * exception is caught; if still uncaught at the top level, the error
242 * message will be displayed and the script processing terminated
243 * then. - This function has no access to the conditional stack.
244 * Thus, the actual throw is made after the failing command has
245 * returned. - Throw only the first of several errors in a row, except
246 * a severe error is following.
247 */
248 if (msg_list != NULL)
249 {
250 plist = msg_list;
251 while (*plist != NULL)
252 plist = &(*plist)->next;
253
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200254 elem = ALLOC_CLEAR_ONE(msglist_T);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000255 if (elem == NULL)
256 {
257 suppress_errthrow = TRUE;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100258 emsg(_(e_outofmem));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000259 }
260 else
261 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100262 elem->msg = (char *)vim_strsave(mesg);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000263 if (elem->msg == NULL)
264 {
265 vim_free(elem);
266 suppress_errthrow = TRUE;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100267 emsg(_(e_outofmem));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000268 }
269 else
270 {
271 elem->next = NULL;
272 elem->throw_msg = NULL;
273 *plist = elem;
274 if (plist == msg_list || severe)
275 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100276 char *tmsg;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000277
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100278 // Skip the extra "Vim " prefix for message "E458".
Bram Moolenaar071d4272004-06-13 20:20:40 +0000279 tmsg = elem->msg;
280 if (STRNCMP(tmsg, "Vim E", 5) == 0
281 && VIM_ISDIGIT(tmsg[5])
282 && VIM_ISDIGIT(tmsg[6])
283 && VIM_ISDIGIT(tmsg[7])
284 && tmsg[8] == ':'
285 && tmsg[9] == ' ')
286 (*msg_list)->throw_msg = &tmsg[4];
287 else
288 (*msg_list)->throw_msg = tmsg;
289 }
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200290
291 // Get the source name and lnum now, it may change before
292 // reaching do_errthrow().
Bram Moolenaar4f25b1a2020-09-10 19:25:05 +0200293 elem->sfile = estack_sfile(ESTACK_NONE);
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200294 elem->slnum = SOURCING_LNUM;
Bram Moolenaare8c46602021-04-05 22:27:37 +0200295 elem->msg_compiling = estack_compiling;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000296 }
297 }
298 }
299 return TRUE;
300 }
301}
302
303/*
304 * Free a "msg_list" and the messages it contains.
305 */
306 static void
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200307free_msglist(msglist_T *l)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000308{
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200309 msglist_T *messages, *next;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000310
311 messages = l;
312 while (messages != NULL)
313 {
314 next = messages->next;
315 vim_free(messages->msg);
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200316 vim_free(messages->sfile);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000317 vim_free(messages);
318 messages = next;
319 }
320}
321
322/*
Bram Moolenaar9fee7d42013-11-28 17:04:43 +0100323 * Free global "*msg_list" and the messages it contains, then set "*msg_list"
324 * to NULL.
325 */
326 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100327free_global_msglist(void)
Bram Moolenaar9fee7d42013-11-28 17:04:43 +0100328{
329 free_msglist(*msg_list);
330 *msg_list = NULL;
331}
332
333/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000334 * Throw the message specified in the call to cause_errthrow() above as an
335 * error exception. If cstack is NULL, postpone the throw until do_cmdline()
336 * has returned (see do_one_cmd()).
337 */
338 void
Bram Moolenaarddef1292019-12-16 17:10:33 +0100339do_errthrow(cstack_T *cstack, char_u *cmdname)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000340{
341 /*
342 * Ensure that all commands in nested function calls and sourced files
343 * are aborted immediately.
344 */
345 if (cause_abort)
346 {
347 cause_abort = FALSE;
348 force_abort = TRUE;
349 }
350
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100351 // If no exception is to be thrown or the conversion should be done after
352 // returning to a previous invocation of do_one_cmd(), do nothing.
Bram Moolenaar4632d292006-11-28 17:36:37 +0000353 if (msg_list == NULL || *msg_list == NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000354 return;
355
356 if (throw_exception(*msg_list, ET_ERROR, cmdname) == FAIL)
357 free_msglist(*msg_list);
358 else
359 {
360 if (cstack != NULL)
361 do_throw(cstack);
362 else
363 need_rethrow = TRUE;
364 }
365 *msg_list = NULL;
366}
367
368/*
369 * do_intthrow(): Replace the current exception by an interrupt or interrupt
370 * exception if appropriate. Return TRUE if the current exception is discarded,
371 * FALSE otherwise.
372 */
373 int
Bram Moolenaarddef1292019-12-16 17:10:33 +0100374do_intthrow(cstack_T *cstack)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000375{
376 /*
377 * If no interrupt occurred or no try conditional is active and no exception
378 * is being thrown, do nothing (for compatibility of non-EH scripts).
379 */
380 if (!got_int || (trylevel == 0 && !did_throw))
381 return FALSE;
382
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100383#ifdef THROW_TEST // avoid warning for condition always true
Bram Moolenaar071d4272004-06-13 20:20:40 +0000384 if (!THROW_ON_INTERRUPT)
385 {
386 /*
387 * The interrupt aborts everything except for executing finally clauses.
388 * Discard any user or error or interrupt exception currently being
389 * thrown.
390 */
391 if (did_throw)
392 discard_current_exception();
393 }
394 else
395#endif
396 {
397 /*
398 * Throw an interrupt exception, so that everything will be aborted
399 * (except for executing finally clauses), until the interrupt exception
400 * is caught; if still uncaught at the top level, the script processing
401 * will be terminated then. - If an interrupt exception is already
402 * being thrown, do nothing.
403 *
404 */
405 if (did_throw)
406 {
407 if (current_exception->type == ET_INTERRUPT)
408 return FALSE;
409
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100410 // An interrupt exception replaces any user or error exception.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000411 discard_current_exception();
412 }
413 if (throw_exception("Vim:Interrupt", ET_INTERRUPT, NULL) != FAIL)
414 do_throw(cstack);
415 }
416
417 return TRUE;
418}
419
Bram Moolenaar071d4272004-06-13 20:20:40 +0000420/*
Bram Moolenaar9fee7d42013-11-28 17:04:43 +0100421 * Get an exception message that is to be stored in current_exception->value.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000422 */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100423 char *
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100424get_exception_string(
425 void *value,
Bram Moolenaar8a5883b2016-11-10 20:20:05 +0100426 except_type_T type,
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100427 char_u *cmdname,
428 int *should_free)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000429{
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100430 char *ret;
431 char *mesg;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000432 int cmdlen;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100433 char *p, *val;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000434
435 if (type == ET_ERROR)
436 {
Bram Moolenaar9ef00be2016-03-06 14:58:28 +0100437 *should_free = TRUE;
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200438 mesg = ((msglist_T *)value)->throw_msg;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000439 if (cmdname != NULL && *cmdname != NUL)
440 {
Bram Moolenaara93fa7e2006-04-17 22:14:47 +0000441 cmdlen = (int)STRLEN(cmdname);
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100442 ret = (char *)vim_strnsave((char_u *)"Vim(",
Bram Moolenaar71ccd032020-06-12 22:59:11 +0200443 4 + cmdlen + 2 + STRLEN(mesg));
Bram Moolenaar9fee7d42013-11-28 17:04:43 +0100444 if (ret == NULL)
445 return ret;
446 STRCPY(&ret[4], cmdname);
447 STRCPY(&ret[4 + cmdlen], "):");
448 val = ret + 4 + cmdlen + 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000449 }
450 else
451 {
Bram Moolenaar71ccd032020-06-12 22:59:11 +0200452 ret = (char *)vim_strnsave((char_u *)"Vim:", 4 + STRLEN(mesg));
Bram Moolenaar9fee7d42013-11-28 17:04:43 +0100453 if (ret == NULL)
454 return ret;
455 val = ret + 4;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000456 }
457
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100458 // msg_add_fname may have been used to prefix the message with a file
459 // name in quotes. In the exception value, put the file name in
460 // parentheses and move it to the end.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000461 for (p = mesg; ; p++)
462 {
463 if (*p == NUL
464 || (*p == 'E'
465 && VIM_ISDIGIT(p[1])
466 && (p[2] == ':'
467 || (VIM_ISDIGIT(p[2])
468 && (p[3] == ':'
469 || (VIM_ISDIGIT(p[3])
470 && p[4] == ':'))))))
471 {
Bram Moolenaar051b7822005-05-19 21:00:46 +0000472 if (*p == NUL || p == mesg)
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100473 STRCAT(val, mesg); // 'E123' missing or at beginning
Bram Moolenaar071d4272004-06-13 20:20:40 +0000474 else
475 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100476 // '"filename" E123: message text'
Bram Moolenaar071d4272004-06-13 20:20:40 +0000477 if (mesg[0] != '"' || p-2 < &mesg[1] ||
478 p[-2] != '"' || p[-1] != ' ')
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100479 // "E123:" is part of the file name.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000480 continue;
481
482 STRCAT(val, p);
483 p[-2] = NUL;
484 sprintf((char *)(val + STRLEN(p)), " (%s)", &mesg[1]);
485 p[-2] = '"';
486 }
487 break;
488 }
489 }
490 }
491 else
Bram Moolenaar9fee7d42013-11-28 17:04:43 +0100492 {
493 *should_free = FALSE;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100494 ret = value;
Bram Moolenaar9fee7d42013-11-28 17:04:43 +0100495 }
496
497 return ret;
498}
499
500
501/*
502 * Throw a new exception. Return FAIL when out of memory or it was tried to
503 * throw an illegal user exception. "value" is the exception string for a
504 * user or interrupt exception, or points to a message list in case of an
505 * error exception.
506 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100507 int
Bram Moolenaar8a5883b2016-11-10 20:20:05 +0100508throw_exception(void *value, except_type_T type, char_u *cmdname)
Bram Moolenaar9fee7d42013-11-28 17:04:43 +0100509{
510 except_T *excp;
511 int should_free;
512
513 /*
514 * Disallow faking Interrupt or error exceptions as user exceptions. They
515 * would be treated differently from real interrupt or error exceptions
516 * when no active try block is found, see do_cmdline().
517 */
518 if (type == ET_USER)
519 {
520 if (STRNCMP((char_u *)value, "Vim", 3) == 0
521 && (((char_u *)value)[3] == NUL || ((char_u *)value)[3] == ':'
522 || ((char_u *)value)[3] == '('))
523 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100524 emsg(_("E608: Cannot :throw exceptions with 'Vim' prefix"));
Bram Moolenaar9fee7d42013-11-28 17:04:43 +0100525 goto fail;
526 }
527 }
528
Bram Moolenaarc799fe22019-05-28 23:08:19 +0200529 excp = ALLOC_ONE(except_T);
Bram Moolenaar9fee7d42013-11-28 17:04:43 +0100530 if (excp == NULL)
531 goto nomem;
532
533 if (type == ET_ERROR)
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100534 // Store the original message and prefix the exception value with
535 // "Vim:" or, if a command name is given, "Vim(cmdname):".
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200536 excp->messages = (msglist_T *)value;
Bram Moolenaar9fee7d42013-11-28 17:04:43 +0100537
538 excp->value = get_exception_string(value, type, cmdname, &should_free);
539 if (excp->value == NULL && should_free)
540 goto nomem;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000541
542 excp->type = type;
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200543 if (type == ET_ERROR && ((msglist_T *)value)->sfile != NULL)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000544 {
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200545 msglist_T *entry = (msglist_T *)value;
546
547 excp->throw_name = entry->sfile;
548 entry->sfile = NULL;
549 excp->throw_lnum = entry->slnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000550 }
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200551 else
552 {
Bram Moolenaar4f25b1a2020-09-10 19:25:05 +0200553 excp->throw_name = estack_sfile(ESTACK_NONE);
Bram Moolenaar25e0f582020-05-25 22:36:50 +0200554 if (excp->throw_name == NULL)
555 excp->throw_name = vim_strsave((char_u *)"");
556 if (excp->throw_name == NULL)
557 {
558 if (should_free)
559 vim_free(excp->value);
560 goto nomem;
561 }
562 excp->throw_lnum = SOURCING_LNUM;
563 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000564
565 if (p_verbose >= 13 || debug_break_level > 0)
566 {
567 int save_msg_silent = msg_silent;
568
569 if (debug_break_level > 0)
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100570 msg_silent = FALSE; // display messages
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000571 else
572 verbose_enter();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000573 ++no_wait_return;
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000574 if (debug_break_level > 0 || *p_vfile == NUL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100575 msg_scroll = TRUE; // always scroll up, don't overwrite
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000576
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100577 smsg(_("Exception thrown: %s"), excp->value);
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100578 msg_puts("\n"); // don't overwrite this either
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000579
580 if (debug_break_level > 0 || *p_vfile == NUL)
581 cmdline_row = msg_row;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000582 --no_wait_return;
583 if (debug_break_level > 0)
584 msg_silent = save_msg_silent;
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000585 else
586 verbose_leave();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000587 }
588
589 current_exception = excp;
590 return OK;
591
592nomem:
593 vim_free(excp);
594 suppress_errthrow = TRUE;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100595 emsg(_(e_outofmem));
Bram Moolenaar071d4272004-06-13 20:20:40 +0000596fail:
597 current_exception = NULL;
598 return FAIL;
599}
600
601/*
602 * Discard an exception. "was_finished" is set when the exception has been
603 * caught and the catch clause has been ended normally.
604 */
605 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100606discard_exception(except_T *excp, int was_finished)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000607{
608 char_u *saved_IObuff;
609
Bram Moolenaar13656f02020-12-19 17:55:54 +0100610 if (current_exception == excp)
611 current_exception = NULL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000612 if (excp == NULL)
613 {
Bram Moolenaar95f09602016-11-10 20:01:45 +0100614 internal_error("discard_exception()");
Bram Moolenaar071d4272004-06-13 20:20:40 +0000615 return;
616 }
617
618 if (p_verbose >= 13 || debug_break_level > 0)
619 {
620 int save_msg_silent = msg_silent;
621
622 saved_IObuff = vim_strsave(IObuff);
623 if (debug_break_level > 0)
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100624 msg_silent = FALSE; // display messages
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000625 else
626 verbose_enter();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000627 ++no_wait_return;
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000628 if (debug_break_level > 0 || *p_vfile == NUL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100629 msg_scroll = TRUE; // always scroll up, don't overwrite
Bram Moolenaar051b7822005-05-19 21:00:46 +0000630 smsg(was_finished
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100631 ? _("Exception finished: %s")
632 : _("Exception discarded: %s"),
Bram Moolenaar071d4272004-06-13 20:20:40 +0000633 excp->value);
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100634 msg_puts("\n"); // don't overwrite this either
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000635 if (debug_break_level > 0 || *p_vfile == NUL)
636 cmdline_row = msg_row;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000637 --no_wait_return;
638 if (debug_break_level > 0)
639 msg_silent = save_msg_silent;
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000640 else
641 verbose_leave();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000642 STRCPY(IObuff, saved_IObuff);
643 vim_free(saved_IObuff);
644 }
645 if (excp->type != ET_INTERRUPT)
646 vim_free(excp->value);
647 if (excp->type == ET_ERROR)
648 free_msglist(excp->messages);
649 vim_free(excp->throw_name);
650 vim_free(excp);
651}
652
653/*
654 * Discard the exception currently being thrown.
655 */
656 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100657discard_current_exception(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000658{
Bram Moolenaarcae24be2017-07-10 22:12:10 +0200659 if (current_exception != NULL)
Bram Moolenaarcae24be2017-07-10 22:12:10 +0200660 discard_exception(current_exception, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000661 did_throw = FALSE;
662 need_rethrow = FALSE;
663}
664
665/*
666 * Put an exception on the caught stack.
667 */
Bram Moolenaar8a7d6542020-01-26 15:56:19 +0100668 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100669catch_exception(except_T *excp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000670{
671 excp->caught = caught_stack;
672 caught_stack = excp;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100673 set_vim_var_string(VV_EXCEPTION, (char_u *)excp->value, -1);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000674 if (*excp->throw_name != NUL)
675 {
676 if (excp->throw_lnum != 0)
Bram Moolenaar051b7822005-05-19 21:00:46 +0000677 vim_snprintf((char *)IObuff, IOSIZE, _("%s, line %ld"),
678 excp->throw_name, (long)excp->throw_lnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000679 else
Bram Moolenaar051b7822005-05-19 21:00:46 +0000680 vim_snprintf((char *)IObuff, IOSIZE, "%s", excp->throw_name);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000681 set_vim_var_string(VV_THROWPOINT, IObuff, -1);
682 }
683 else
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100684 // throw_name not set on an exception from a command that was typed.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000685 set_vim_var_string(VV_THROWPOINT, NULL, -1);
686
687 if (p_verbose >= 13 || debug_break_level > 0)
688 {
689 int save_msg_silent = msg_silent;
690
691 if (debug_break_level > 0)
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100692 msg_silent = FALSE; // display messages
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000693 else
694 verbose_enter();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000695 ++no_wait_return;
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000696 if (debug_break_level > 0 || *p_vfile == NUL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100697 msg_scroll = TRUE; // always scroll up, don't overwrite
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000698
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100699 smsg(_("Exception caught: %s"), excp->value);
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100700 msg_puts("\n"); // don't overwrite this either
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000701
702 if (debug_break_level > 0 || *p_vfile == NUL)
703 cmdline_row = msg_row;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000704 --no_wait_return;
705 if (debug_break_level > 0)
706 msg_silent = save_msg_silent;
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000707 else
708 verbose_leave();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000709 }
710}
711
712/*
713 * Remove an exception from the caught stack.
714 */
715 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100716finish_exception(except_T *excp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000717{
718 if (excp != caught_stack)
Bram Moolenaar95f09602016-11-10 20:01:45 +0100719 internal_error("finish_exception()");
Bram Moolenaar071d4272004-06-13 20:20:40 +0000720 caught_stack = caught_stack->caught;
721 if (caught_stack != NULL)
722 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100723 set_vim_var_string(VV_EXCEPTION, (char_u *)caught_stack->value, -1);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000724 if (*caught_stack->throw_name != NUL)
725 {
726 if (caught_stack->throw_lnum != 0)
Bram Moolenaar051b7822005-05-19 21:00:46 +0000727 vim_snprintf((char *)IObuff, IOSIZE,
Bram Moolenaar071d4272004-06-13 20:20:40 +0000728 _("%s, line %ld"), caught_stack->throw_name,
729 (long)caught_stack->throw_lnum);
730 else
Bram Moolenaar051b7822005-05-19 21:00:46 +0000731 vim_snprintf((char *)IObuff, IOSIZE, "%s",
732 caught_stack->throw_name);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000733 set_vim_var_string(VV_THROWPOINT, IObuff, -1);
734 }
735 else
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100736 // throw_name not set on an exception from a command that was
737 // typed.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000738 set_vim_var_string(VV_THROWPOINT, NULL, -1);
739 }
740 else
741 {
742 set_vim_var_string(VV_EXCEPTION, NULL, -1);
743 set_vim_var_string(VV_THROWPOINT, NULL, -1);
744 }
745
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100746 // Discard the exception, but use the finish message for 'verbose'.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000747 discard_exception(excp, TRUE);
748}
749
750/*
751 * Flags specifying the message displayed by report_pending.
752 */
753#define RP_MAKE 0
754#define RP_RESUME 1
755#define RP_DISCARD 2
756
757/*
758 * Report information about something pending in a finally clause if required by
759 * the 'verbose' option or when debugging. "action" tells whether something is
760 * made pending or something pending is resumed or discarded. "pending" tells
761 * what is pending. "value" specifies the return value for a pending ":return"
762 * or the exception value for a pending exception.
763 */
764 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100765report_pending(int action, int pending, void *value)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000766{
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100767 char *mesg;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000768 char *s;
769 int save_msg_silent;
770
771
772 switch (action)
773 {
774 case RP_MAKE:
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100775 mesg = _("%s made pending");
Bram Moolenaar071d4272004-06-13 20:20:40 +0000776 break;
777 case RP_RESUME:
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100778 mesg = _("%s resumed");
Bram Moolenaar071d4272004-06-13 20:20:40 +0000779 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100780 // case RP_DISCARD:
Bram Moolenaar071d4272004-06-13 20:20:40 +0000781 default:
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100782 mesg = _("%s discarded");
Bram Moolenaar071d4272004-06-13 20:20:40 +0000783 break;
784 }
785
786 switch (pending)
787 {
788 case CSTP_NONE:
789 return;
790
791 case CSTP_CONTINUE:
792 s = ":continue";
793 break;
794 case CSTP_BREAK:
795 s = ":break";
796 break;
797 case CSTP_FINISH:
798 s = ":finish";
799 break;
800 case CSTP_RETURN:
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100801 // ":return" command producing value, allocated
Bram Moolenaar071d4272004-06-13 20:20:40 +0000802 s = (char *)get_return_cmd(value);
803 break;
804
805 default:
806 if (pending & CSTP_THROW)
807 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100808 vim_snprintf((char *)IObuff, IOSIZE, mesg, _("Exception"));
Bram Moolenaar71ccd032020-06-12 22:59:11 +0200809 mesg = (char *)vim_strnsave(IObuff, STRLEN(IObuff) + 4);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000810 STRCAT(mesg, ": %s");
811 s = (char *)((except_T *)value)->value;
812 }
813 else if ((pending & CSTP_ERROR) && (pending & CSTP_INTERRUPT))
814 s = _("Error and interrupt");
815 else if (pending & CSTP_ERROR)
816 s = _("Error");
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100817 else // if (pending & CSTP_INTERRUPT)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000818 s = _("Interrupt");
819 }
820
821 save_msg_silent = msg_silent;
822 if (debug_break_level > 0)
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100823 msg_silent = FALSE; // display messages
Bram Moolenaar071d4272004-06-13 20:20:40 +0000824 ++no_wait_return;
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100825 msg_scroll = TRUE; // always scroll up, don't overwrite
Bram Moolenaarf9e3e092019-01-13 23:38:42 +0100826 smsg(mesg, s);
Bram Moolenaar217e1b82019-12-01 21:41:28 +0100827 msg_puts("\n"); // don't overwrite this either
Bram Moolenaar071d4272004-06-13 20:20:40 +0000828 cmdline_row = msg_row;
829 --no_wait_return;
830 if (debug_break_level > 0)
831 msg_silent = save_msg_silent;
832
833 if (pending == CSTP_RETURN)
834 vim_free(s);
835 else if (pending & CSTP_THROW)
836 vim_free(mesg);
837}
838
839/*
840 * If something is made pending in a finally clause, report it if required by
841 * the 'verbose' option or when debugging.
842 */
843 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100844report_make_pending(int pending, void *value)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000845{
846 if (p_verbose >= 14 || debug_break_level > 0)
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000847 {
848 if (debug_break_level <= 0)
849 verbose_enter();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000850 report_pending(RP_MAKE, pending, value);
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000851 if (debug_break_level <= 0)
852 verbose_leave();
853 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000854}
855
856/*
857 * If something pending in a finally clause is resumed at the ":endtry", report
858 * it if required by the 'verbose' option or when debugging.
859 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +0200860 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100861report_resume_pending(int pending, void *value)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000862{
863 if (p_verbose >= 14 || debug_break_level > 0)
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000864 {
865 if (debug_break_level <= 0)
866 verbose_enter();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000867 report_pending(RP_RESUME, pending, value);
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000868 if (debug_break_level <= 0)
869 verbose_leave();
870 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000871}
872
873/*
874 * If something pending in a finally clause is discarded, report it if required
875 * by the 'verbose' option or when debugging.
876 */
Bram Moolenaar5843f5f2019-08-20 20:13:45 +0200877 static void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100878report_discard_pending(int pending, void *value)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000879{
880 if (p_verbose >= 14 || debug_break_level > 0)
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000881 {
882 if (debug_break_level <= 0)
883 verbose_enter();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000884 report_pending(RP_DISCARD, pending, value);
Bram Moolenaar5c06f8b2005-05-31 22:14:58 +0000885 if (debug_break_level <= 0)
886 verbose_leave();
887 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000888}
889
890
891/*
Bram Moolenaar25e42232019-08-04 15:04:10 +0200892 * ":eval".
893 */
894 void
895ex_eval(exarg_T *eap)
896{
897 typval_T tv;
Bram Moolenaar5409f5d2020-06-24 18:37:35 +0200898 evalarg_T evalarg;
Bram Moolenaar25e42232019-08-04 15:04:10 +0200899
Bram Moolenaare6b53242020-07-01 17:28:33 +0200900 fill_evalarg_from_eap(&evalarg, eap, eap->skip);
Bram Moolenaar5409f5d2020-06-24 18:37:35 +0200901
Bram Moolenaarb171fb12020-06-24 20:34:03 +0200902 if (eval0(eap->arg, &tv, eap, &evalarg) == OK)
Bram Moolenaar25e42232019-08-04 15:04:10 +0200903 clear_tv(&tv);
Bram Moolenaarb7a78f72020-06-28 18:43:40 +0200904
905 clear_evalarg(&evalarg, eap);
Bram Moolenaar25e42232019-08-04 15:04:10 +0200906}
907
908/*
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +0200909 * Start a new scope/block. Caller should have checked that cs_idx is not
910 * exceeding CSTACK_LEN.
911 */
912 static void
913enter_block(cstack_T *cstack)
914{
915 ++cstack->cs_idx;
Bram Moolenaar0abc6e42021-02-26 22:21:23 +0100916 if (in_vim9script() && current_sctx.sc_sid > 0)
Bram Moolenaar8d739de2020-10-14 19:39:19 +0200917 {
918 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
919
920 cstack->cs_script_var_len[cstack->cs_idx] = si->sn_var_vals.ga_len;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200921 cstack->cs_block_id[cstack->cs_idx] = ++si->sn_last_block_id;
922 si->sn_current_block_id = si->sn_last_block_id;
Bram Moolenaar8d739de2020-10-14 19:39:19 +0200923 }
Bram Moolenaar3e492c22021-01-27 21:37:13 +0100924 else
925 {
926 // Just in case in_vim9script() does not return the same value when the
927 // block ends.
928 cstack->cs_script_var_len[cstack->cs_idx] = 0;
929 cstack->cs_block_id[cstack->cs_idx] = 0;
930 }
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +0200931}
932
933 static void
934leave_block(cstack_T *cstack)
935{
Bram Moolenaar8d739de2020-10-14 19:39:19 +0200936 if (in_vim9script() && SCRIPT_ID_VALID(current_sctx.sc_sid))
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +0200937 {
Bram Moolenaard7475482020-10-10 20:31:37 +0200938 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
Bram Moolenaar8d739de2020-10-14 19:39:19 +0200939 int i;
Bram Moolenaar39ca4122020-10-20 14:25:07 +0200940 int func_defined =
941 cstack->cs_flags[cstack->cs_idx] & CSF_FUNC_DEF;
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +0200942
Bram Moolenaar8d739de2020-10-14 19:39:19 +0200943 for (i = cstack->cs_script_var_len[cstack->cs_idx];
Bram Moolenaard7475482020-10-10 20:31:37 +0200944 i < si->sn_var_vals.ga_len; ++i)
Bram Moolenaar8d739de2020-10-14 19:39:19 +0200945 {
946 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + i;
Bram Moolenaard7475482020-10-10 20:31:37 +0200947
Bram Moolenaar39ca4122020-10-20 14:25:07 +0200948 // sv_name is set to NULL if it was already removed. This happens
949 // when it was defined in an inner block and no functions were
950 // defined there.
Bram Moolenaar8d739de2020-10-14 19:39:19 +0200951 if (sv->sv_name != NULL)
952 // Remove a variable declared inside the block, if it still
Bram Moolenaar39ca4122020-10-20 14:25:07 +0200953 // exists, from sn_vars and move the value into sn_all_vars
954 // if "func_defined" is non-zero.
955 hide_script_var(si, i, func_defined);
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +0200956 }
Bram Moolenaar8d739de2020-10-14 19:39:19 +0200957
958 // TODO: is this needed?
959 cstack->cs_script_var_len[cstack->cs_idx] = si->sn_var_vals.ga_len;
Bram Moolenaarfbbcd002020-10-15 12:46:44 +0200960
961 if (cstack->cs_idx == 0)
962 si->sn_current_block_id = 0;
963 else
964 si->sn_current_block_id = cstack->cs_block_id[cstack->cs_idx - 1];
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +0200965 }
966 --cstack->cs_idx;
967}
968
969/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000970 * ":if".
971 */
972 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +0100973ex_if(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000974{
975 int error;
976 int skip;
977 int result;
Bram Moolenaarddef1292019-12-16 17:10:33 +0100978 cstack_T *cstack = eap->cstack;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000979
980 if (cstack->cs_idx == CSTACK_LEN - 1)
Bram Moolenaar8930caa2020-07-23 16:37:03 +0200981 eap->errmsg = _("E579: :if nesting too deep");
Bram Moolenaar071d4272004-06-13 20:20:40 +0000982 else
983 {
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +0200984 enter_block(cstack);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000985 cstack->cs_flags[cstack->cs_idx] = 0;
986
987 /*
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +0200988 * Don't do something after an error, interrupt, or throw, or when
989 * there is a surrounding conditional and it was not active.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000990 */
991 skip = did_emsg || got_int || did_throw || (cstack->cs_idx > 0
992 && !(cstack->cs_flags[cstack->cs_idx - 1] & CSF_ACTIVE));
993
Bram Moolenaarb171fb12020-06-24 20:34:03 +0200994 result = eval_to_bool(eap->arg, &error, eap, skip);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000995
996 if (!skip && !error)
997 {
998 if (result)
999 cstack->cs_flags[cstack->cs_idx] = CSF_ACTIVE | CSF_TRUE;
1000 }
1001 else
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001002 // set TRUE, so this conditional will never get active
Bram Moolenaar071d4272004-06-13 20:20:40 +00001003 cstack->cs_flags[cstack->cs_idx] = CSF_TRUE;
1004 }
1005}
1006
1007/*
1008 * ":endif".
1009 */
1010 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001011ex_endif(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001012{
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02001013 cstack_T *cstack = eap->cstack;
1014
Bram Moolenaarfa984412021-03-25 22:15:28 +01001015 if (cmdmod_error())
1016 return;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001017 did_endif = TRUE;
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02001018 if (cstack->cs_idx < 0
1019 || (cstack->cs_flags[cstack->cs_idx]
Bram Moolenaar9becdf22020-10-10 21:33:48 +02001020 & (CSF_WHILE | CSF_FOR | CSF_TRY | CSF_BLOCK)))
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001021 eap->errmsg = _(e_endif_without_if);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001022 else
1023 {
1024 /*
1025 * When debugging or a breakpoint was encountered, display the debug
1026 * prompt (if not already done). This shows the user that an ":endif"
1027 * is executed when the ":if" or a previous ":elseif" was not TRUE.
1028 * Handle a ">quit" debug command as if an interrupt had occurred before
1029 * the ":endif". That is, throw an interrupt exception if appropriate.
1030 * Doing this here prevents an exception for a parsing error being
1031 * discarded by throwing the interrupt exception later on.
1032 */
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02001033 if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRUE)
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00001034 && dbg_check_skipped(eap))
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02001035 (void)do_intthrow(cstack);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001036
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02001037 leave_block(cstack);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001038 }
1039}
1040
1041/*
1042 * ":else" and ":elseif".
1043 */
1044 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001045ex_else(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001046{
1047 int error;
1048 int skip;
1049 int result;
Bram Moolenaarddef1292019-12-16 17:10:33 +01001050 cstack_T *cstack = eap->cstack;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001051
1052 /*
1053 * Don't do something after an error, interrupt, or throw, or when there is
1054 * a surrounding conditional and it was not active.
1055 */
1056 skip = did_emsg || got_int || did_throw || (cstack->cs_idx > 0
1057 && !(cstack->cs_flags[cstack->cs_idx - 1] & CSF_ACTIVE));
1058
1059 if (cstack->cs_idx < 0
Bram Moolenaar12805862005-01-05 22:16:17 +00001060 || (cstack->cs_flags[cstack->cs_idx]
Bram Moolenaar9becdf22020-10-10 21:33:48 +02001061 & (CSF_WHILE | CSF_FOR | CSF_TRY | CSF_BLOCK)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001062 {
1063 if (eap->cmdidx == CMD_else)
1064 {
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001065 eap->errmsg = _(e_else_without_if);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001066 return;
1067 }
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001068 eap->errmsg = _(e_elseif_without_if);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001069 skip = TRUE;
1070 }
1071 else if (cstack->cs_flags[cstack->cs_idx] & CSF_ELSE)
1072 {
1073 if (eap->cmdidx == CMD_else)
1074 {
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001075 eap->errmsg = _("E583: multiple :else");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001076 return;
1077 }
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001078 eap->errmsg = _("E584: :elseif after :else");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001079 skip = TRUE;
1080 }
1081
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001082 // if skipping or the ":if" was TRUE, reset ACTIVE, otherwise set it
Bram Moolenaar071d4272004-06-13 20:20:40 +00001083 if (skip || cstack->cs_flags[cstack->cs_idx] & CSF_TRUE)
1084 {
1085 if (eap->errmsg == NULL)
1086 cstack->cs_flags[cstack->cs_idx] = CSF_TRUE;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001087 skip = TRUE; // don't evaluate an ":elseif"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001088 }
1089 else
1090 cstack->cs_flags[cstack->cs_idx] = CSF_ACTIVE;
1091
1092 /*
1093 * When debugging or a breakpoint was encountered, display the debug prompt
1094 * (if not already done). This shows the user that an ":else" or ":elseif"
1095 * is executed when the ":if" or previous ":elseif" was not TRUE. Handle
1096 * a ">quit" debug command as if an interrupt had occurred before the
1097 * ":else" or ":elseif". That is, set "skip" and throw an interrupt
1098 * exception if appropriate. Doing this here prevents that an exception
1099 * for a parsing errors is discarded when throwing the interrupt exception
1100 * later on.
1101 */
1102 if (!skip && dbg_check_skipped(eap) && got_int)
1103 {
1104 (void)do_intthrow(cstack);
1105 skip = TRUE;
1106 }
1107
1108 if (eap->cmdidx == CMD_elseif)
1109 {
Bram Moolenaarb171fb12020-06-24 20:34:03 +02001110 result = eval_to_bool(eap->arg, &error, eap, skip);
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001111
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001112 // When throwing error exceptions, we want to throw always the first
1113 // of several errors in a row. This is what actually happens when
1114 // a conditional error was detected above and there is another failure
1115 // when parsing the expression. Since the skip flag is set in this
1116 // case, the parsing error will be ignored by emsg().
Bram Moolenaar071d4272004-06-13 20:20:40 +00001117 if (!skip && !error)
1118 {
1119 if (result)
1120 cstack->cs_flags[cstack->cs_idx] = CSF_ACTIVE | CSF_TRUE;
1121 else
1122 cstack->cs_flags[cstack->cs_idx] = 0;
1123 }
1124 else if (eap->errmsg == NULL)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001125 // set TRUE, so this conditional will never get active
Bram Moolenaar071d4272004-06-13 20:20:40 +00001126 cstack->cs_flags[cstack->cs_idx] = CSF_TRUE;
1127 }
1128 else
1129 cstack->cs_flags[cstack->cs_idx] |= CSF_ELSE;
1130}
1131
1132/*
Bram Moolenaar12805862005-01-05 22:16:17 +00001133 * Handle ":while" and ":for".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001134 */
1135 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001136ex_while(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001137{
1138 int error;
1139 int skip;
1140 int result;
Bram Moolenaarddef1292019-12-16 17:10:33 +01001141 cstack_T *cstack = eap->cstack;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001142
1143 if (cstack->cs_idx == CSTACK_LEN - 1)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001144 eap->errmsg = _("E585: :while/:for nesting too deep");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001145 else
1146 {
1147 /*
Bram Moolenaar12805862005-01-05 22:16:17 +00001148 * The loop flag is set when we have jumped back from the matching
1149 * ":endwhile" or ":endfor". When not set, need to initialise this
1150 * cstack entry.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001151 */
Bram Moolenaar12805862005-01-05 22:16:17 +00001152 if ((cstack->cs_lflags & CSL_HAD_LOOP) == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001153 {
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02001154 enter_block(cstack);
Bram Moolenaar12805862005-01-05 22:16:17 +00001155 ++cstack->cs_looplevel;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001156 cstack->cs_line[cstack->cs_idx] = -1;
1157 }
Bram Moolenaar522eefd2021-03-26 18:49:22 +01001158 else
1159 {
1160 if (in_vim9script() && SCRIPT_ID_VALID(current_sctx.sc_sid))
1161 {
1162 scriptitem_T *si = SCRIPT_ITEM(current_sctx.sc_sid);
1163 int i;
1164
1165 // Any variables defined in the previous round are no longer
1166 // visible.
1167 for (i = cstack->cs_script_var_len[cstack->cs_idx];
1168 i < si->sn_var_vals.ga_len; ++i)
1169 {
1170 svar_T *sv = ((svar_T *)si->sn_var_vals.ga_data) + i;
1171
1172 // sv_name is set to NULL if it was already removed. This
1173 // happens when it was defined in an inner block and no
1174 // functions were defined there.
1175 if (sv->sv_name != NULL)
1176 // Remove a variable declared inside the block, if it
1177 // still exists, from sn_vars.
1178 hide_script_var(si, i, FALSE);
1179 }
1180 cstack->cs_script_var_len[cstack->cs_idx] =
1181 si->sn_var_vals.ga_len;
1182 }
1183 }
Bram Moolenaar12805862005-01-05 22:16:17 +00001184 cstack->cs_flags[cstack->cs_idx] =
1185 eap->cmdidx == CMD_while ? CSF_WHILE : CSF_FOR;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001186
1187 /*
Bram Moolenaar12805862005-01-05 22:16:17 +00001188 * Don't do something after an error, interrupt, or throw, or when
1189 * there is a surrounding conditional and it was not active.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001190 */
1191 skip = did_emsg || got_int || did_throw || (cstack->cs_idx > 0
1192 && !(cstack->cs_flags[cstack->cs_idx - 1] & CSF_ACTIVE));
Bram Moolenaar12805862005-01-05 22:16:17 +00001193 if (eap->cmdidx == CMD_while)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001194 {
Bram Moolenaar12805862005-01-05 22:16:17 +00001195 /*
1196 * ":while bool-expr"
1197 */
Bram Moolenaarb171fb12020-06-24 20:34:03 +02001198 result = eval_to_bool(eap->arg, &error, eap, skip);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001199 }
1200 else
1201 {
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001202 void *fi;
1203 evalarg_T evalarg;
1204
Bram Moolenaar522eefd2021-03-26 18:49:22 +01001205 /*
1206 * ":for var in list-expr"
1207 */
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001208 CLEAR_FIELD(evalarg);
1209 evalarg.eval_flags = skip ? 0 : EVAL_EVALUATE;
1210 if (getline_equal(eap->getline, eap->cookie, getsourceline))
1211 {
1212 evalarg.eval_getline = eap->getline;
1213 evalarg.eval_cookie = eap->cookie;
1214 }
Bram Moolenaar12805862005-01-05 22:16:17 +00001215
Bram Moolenaar12805862005-01-05 22:16:17 +00001216 if ((cstack->cs_lflags & CSL_HAD_LOOP) != 0)
1217 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001218 // Jumping here from a ":continue" or ":endfor": use the
1219 // previously evaluated list.
Bram Moolenaarde8866b2005-01-06 23:24:37 +00001220 fi = cstack->cs_forinfo[cstack->cs_idx];
Bram Moolenaar12805862005-01-05 22:16:17 +00001221 error = FALSE;
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001222
1223 // the "in expr" is not used, skip over it
1224 skip_for_lines(fi, &evalarg);
Bram Moolenaar12805862005-01-05 22:16:17 +00001225 }
1226 else
1227 {
Bram Moolenaard4ab8072021-07-08 19:22:12 +02001228 long save_lnum = SOURCING_LNUM;
1229
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001230 // Evaluate the argument and get the info in a structure.
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001231 fi = eval_for_line(eap->arg, &error, eap, &evalarg);
Bram Moolenaarde8866b2005-01-06 23:24:37 +00001232 cstack->cs_forinfo[cstack->cs_idx] = fi;
Bram Moolenaard4ab8072021-07-08 19:22:12 +02001233
1234 // Errors should use the first line number.
1235 SOURCING_LNUM = save_lnum;
Bram Moolenaar12805862005-01-05 22:16:17 +00001236 }
1237
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001238 // use the element at the start of the list and advance
Bram Moolenaar12805862005-01-05 22:16:17 +00001239 if (!error && fi != NULL && !skip)
1240 result = next_for_item(fi, eap->arg);
1241 else
1242 result = FALSE;
1243
1244 if (!result)
1245 {
1246 free_for_info(fi);
Bram Moolenaarde8866b2005-01-06 23:24:37 +00001247 cstack->cs_forinfo[cstack->cs_idx] = NULL;
Bram Moolenaar12805862005-01-05 22:16:17 +00001248 }
Bram Moolenaarb7a78f72020-06-28 18:43:40 +02001249 clear_evalarg(&evalarg, eap);
Bram Moolenaar12805862005-01-05 22:16:17 +00001250 }
1251
1252 /*
1253 * If this cstack entry was just initialised and is active, set the
1254 * loop flag, so do_cmdline() will set the line number in cs_line[].
1255 * If executing the command a second time, clear the loop flag.
1256 */
1257 if (!skip && !error && result)
1258 {
1259 cstack->cs_flags[cstack->cs_idx] |= (CSF_ACTIVE | CSF_TRUE);
1260 cstack->cs_lflags ^= CSL_HAD_LOOP;
1261 }
1262 else
1263 {
1264 cstack->cs_lflags &= ~CSL_HAD_LOOP;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001265 // If the ":while" evaluates to FALSE or ":for" is past the end of
1266 // the list, show the debug prompt at the ":endwhile"/":endfor" as
1267 // if there was a ":break" in a ":while"/":for" evaluating to
1268 // TRUE.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001269 if (!skip && !error)
1270 cstack->cs_flags[cstack->cs_idx] |= CSF_TRUE;
1271 }
1272 }
1273}
1274
1275/*
1276 * ":continue"
1277 */
1278 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001279ex_continue(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001280{
1281 int idx;
Bram Moolenaarddef1292019-12-16 17:10:33 +01001282 cstack_T *cstack = eap->cstack;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001283
Bram Moolenaar12805862005-01-05 22:16:17 +00001284 if (cstack->cs_looplevel <= 0 || cstack->cs_idx < 0)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001285 eap->errmsg = _(e_continue);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001286 else
1287 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001288 // Try to find the matching ":while". This might stop at a try
1289 // conditional not in its finally clause (which is then to be executed
1290 // next). Therefor, inactivate all conditionals except the ":while"
1291 // itself (if reached).
Bram Moolenaar12805862005-01-05 22:16:17 +00001292 idx = cleanup_conditionals(cstack, CSF_WHILE | CSF_FOR, FALSE);
Bram Moolenaareb3593b2006-04-22 22:33:57 +00001293 if (idx >= 0 && (cstack->cs_flags[idx] & (CSF_WHILE | CSF_FOR)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001294 {
Bram Moolenaarde8866b2005-01-06 23:24:37 +00001295 rewind_conditionals(cstack, idx, CSF_TRY, &cstack->cs_trylevel);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001296
1297 /*
Bram Moolenaar12805862005-01-05 22:16:17 +00001298 * Set CSL_HAD_CONT, so do_cmdline() will jump back to the
Bram Moolenaar071d4272004-06-13 20:20:40 +00001299 * matching ":while".
1300 */
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001301 cstack->cs_lflags |= CSL_HAD_CONT; // let do_cmdline() handle it
Bram Moolenaar071d4272004-06-13 20:20:40 +00001302 }
1303 else
1304 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001305 // If a try conditional not in its finally clause is reached first,
1306 // make the ":continue" pending for execution at the ":endtry".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001307 cstack->cs_pending[idx] = CSTP_CONTINUE;
1308 report_make_pending(CSTP_CONTINUE, NULL);
1309 }
1310 }
1311}
1312
1313/*
1314 * ":break"
1315 */
1316 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001317ex_break(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001318{
1319 int idx;
Bram Moolenaarddef1292019-12-16 17:10:33 +01001320 cstack_T *cstack = eap->cstack;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001321
Bram Moolenaar12805862005-01-05 22:16:17 +00001322 if (cstack->cs_looplevel <= 0 || cstack->cs_idx < 0)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001323 eap->errmsg = _(e_break);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001324 else
1325 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001326 // Inactivate conditionals until the matching ":while" or a try
1327 // conditional not in its finally clause (which is then to be
1328 // executed next) is found. In the latter case, make the ":break"
1329 // pending for execution at the ":endtry".
Bram Moolenaar12805862005-01-05 22:16:17 +00001330 idx = cleanup_conditionals(cstack, CSF_WHILE | CSF_FOR, TRUE);
Bram Moolenaareb3593b2006-04-22 22:33:57 +00001331 if (idx >= 0 && !(cstack->cs_flags[idx] & (CSF_WHILE | CSF_FOR)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001332 {
1333 cstack->cs_pending[idx] = CSTP_BREAK;
1334 report_make_pending(CSTP_BREAK, NULL);
1335 }
1336 }
1337}
1338
1339/*
Bram Moolenaar12805862005-01-05 22:16:17 +00001340 * ":endwhile" and ":endfor"
Bram Moolenaar071d4272004-06-13 20:20:40 +00001341 */
1342 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001343ex_endwhile(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001344{
Bram Moolenaarddef1292019-12-16 17:10:33 +01001345 cstack_T *cstack = eap->cstack;
1346 int idx;
1347 char *err;
1348 int csf;
1349 int fl;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001350
Bram Moolenaarfa984412021-03-25 22:15:28 +01001351 if (cmdmod_error())
1352 return;
1353
Bram Moolenaar12805862005-01-05 22:16:17 +00001354 if (eap->cmdidx == CMD_endwhile)
1355 {
1356 err = e_while;
1357 csf = CSF_WHILE;
1358 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001359 else
1360 {
Bram Moolenaar12805862005-01-05 22:16:17 +00001361 err = e_for;
1362 csf = CSF_FOR;
1363 }
1364
1365 if (cstack->cs_looplevel <= 0 || cstack->cs_idx < 0)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001366 eap->errmsg = _(err);
Bram Moolenaar12805862005-01-05 22:16:17 +00001367 else
1368 {
1369 fl = cstack->cs_flags[cstack->cs_idx];
1370 if (!(fl & csf))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001371 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001372 // If we are in a ":while" or ":for" but used the wrong endloop
1373 // command, do not rewind to the next enclosing ":for"/":while".
Bram Moolenaar12805862005-01-05 22:16:17 +00001374 if (fl & CSF_WHILE)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001375 eap->errmsg = _("E732: Using :endfor with :while");
Bram Moolenaar12805862005-01-05 22:16:17 +00001376 else if (fl & CSF_FOR)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001377 eap->errmsg = _("E733: Using :endwhile with :for");
Bram Moolenaar3a3a7232005-01-17 22:16:15 +00001378 }
1379 if (!(fl & (CSF_WHILE | CSF_FOR)))
1380 {
1381 if (!(fl & CSF_TRY))
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001382 eap->errmsg = _(e_endif);
Bram Moolenaar12805862005-01-05 22:16:17 +00001383 else if (fl & CSF_FINALLY)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001384 eap->errmsg = _(e_endtry);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001385 // Try to find the matching ":while" and report what's missing.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001386 for (idx = cstack->cs_idx; idx > 0; --idx)
1387 {
Bram Moolenaar12805862005-01-05 22:16:17 +00001388 fl = cstack->cs_flags[idx];
1389 if ((fl & CSF_TRY) && !(fl & CSF_FINALLY))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001390 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001391 // Give up at a try conditional not in its finally clause.
1392 // Ignore the ":endwhile"/":endfor".
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001393 eap->errmsg = _(err);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001394 return;
1395 }
Bram Moolenaar12805862005-01-05 22:16:17 +00001396 if (fl & csf)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001397 break;
1398 }
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001399 // Cleanup and rewind all contained (and unclosed) conditionals.
Bram Moolenaar12805862005-01-05 22:16:17 +00001400 (void)cleanup_conditionals(cstack, CSF_WHILE | CSF_FOR, FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001401 rewind_conditionals(cstack, idx, CSF_TRY, &cstack->cs_trylevel);
1402 }
1403
1404 /*
1405 * When debugging or a breakpoint was encountered, display the debug
1406 * prompt (if not already done). This shows the user that an
Bram Moolenaar12805862005-01-05 22:16:17 +00001407 * ":endwhile"/":endfor" is executed when the ":while" was not TRUE or
1408 * after a ":break". Handle a ">quit" debug command as if an
1409 * interrupt had occurred before the ":endwhile"/":endfor". That is,
1410 * throw an interrupt exception if appropriate. Doing this here
1411 * prevents that an exception for a parsing error is discarded when
1412 * throwing the interrupt exception later on.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001413 */
1414 else if (cstack->cs_flags[cstack->cs_idx] & CSF_TRUE
1415 && !(cstack->cs_flags[cstack->cs_idx] & CSF_ACTIVE)
1416 && dbg_check_skipped(eap))
1417 (void)do_intthrow(cstack);
1418
Bram Moolenaar522eefd2021-03-26 18:49:22 +01001419 // Set loop flag, so do_cmdline() will jump back to the matching
1420 // ":while" or ":for".
Bram Moolenaar12805862005-01-05 22:16:17 +00001421 cstack->cs_lflags |= CSL_HAD_ENDLOOP;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001422 }
1423}
1424
Bram Moolenaar9becdf22020-10-10 21:33:48 +02001425/*
1426 * "{" start of a block in Vim9 script
1427 */
1428 void
1429ex_block(exarg_T *eap)
1430{
1431 cstack_T *cstack = eap->cstack;
1432
1433 if (cstack->cs_idx == CSTACK_LEN - 1)
1434 eap->errmsg = _("E579: block nesting too deep");
1435 else
1436 {
1437 enter_block(cstack);
1438 cstack->cs_flags[cstack->cs_idx] = CSF_BLOCK | CSF_ACTIVE | CSF_TRUE;
1439 }
1440}
1441
1442/*
1443 * "}" end of a block in Vim9 script
1444 */
1445 void
1446ex_endblock(exarg_T *eap)
1447{
1448 cstack_T *cstack = eap->cstack;
1449
1450 if (cstack->cs_idx < 0
1451 || (cstack->cs_flags[cstack->cs_idx] & CSF_BLOCK) == 0)
1452 eap->errmsg = _(e_endblock_without_block);
1453 else
1454 leave_block(cstack);
1455}
Bram Moolenaar071d4272004-06-13 20:20:40 +00001456
1457/*
1458 * ":throw expr"
1459 */
1460 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001461ex_throw(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001462{
1463 char_u *arg = eap->arg;
1464 char_u *value;
1465
1466 if (*arg != NUL && *arg != '|' && *arg != '\n')
Bram Moolenaarb171fb12020-06-24 20:34:03 +02001467 value = eval_to_string_skip(arg, eap, eap->skip);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001468 else
1469 {
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001470 emsg(_(e_argreq));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001471 value = NULL;
1472 }
1473
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001474 // On error or when an exception is thrown during argument evaluation, do
1475 // not throw.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001476 if (!eap->skip && value != NULL)
1477 {
1478 if (throw_exception(value, ET_USER, NULL) == FAIL)
1479 vim_free(value);
1480 else
1481 do_throw(eap->cstack);
1482 }
1483}
1484
1485/*
Bram Moolenaar269ec652004-07-29 08:43:53 +00001486 * Throw the current exception through the specified cstack. Common routine
1487 * for ":throw" (user exception) and error and interrupt exceptions. Also
1488 * used for rethrowing an uncaught exception.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001489 */
1490 void
Bram Moolenaarddef1292019-12-16 17:10:33 +01001491do_throw(cstack_T *cstack)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001492{
1493 int idx;
1494 int inactivate_try = FALSE;
1495
1496 /*
1497 * Cleanup and inactivate up to the next surrounding try conditional that
1498 * is not in its finally clause. Normally, do not inactivate the try
1499 * conditional itself, so that its ACTIVE flag can be tested below. But
1500 * if a previous error or interrupt has not been converted to an exception,
1501 * inactivate the try conditional, too, as if the conversion had been done,
Bram Moolenaar269ec652004-07-29 08:43:53 +00001502 * and reset the did_emsg or got_int flag, so this won't happen again at
1503 * the next surrounding try conditional.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001504 */
Bram Moolenaaraf0167f2009-05-16 15:31:32 +00001505#ifndef THROW_ON_ERROR_TRUE
Bram Moolenaar071d4272004-06-13 20:20:40 +00001506 if (did_emsg && !THROW_ON_ERROR)
1507 {
1508 inactivate_try = TRUE;
1509 did_emsg = FALSE;
1510 }
Bram Moolenaaraf0167f2009-05-16 15:31:32 +00001511#endif
1512#ifndef THROW_ON_INTERRUPT_TRUE
Bram Moolenaar071d4272004-06-13 20:20:40 +00001513 if (got_int && !THROW_ON_INTERRUPT)
1514 {
1515 inactivate_try = TRUE;
1516 got_int = FALSE;
1517 }
Bram Moolenaaraf0167f2009-05-16 15:31:32 +00001518#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001519 idx = cleanup_conditionals(cstack, 0, inactivate_try);
1520 if (idx >= 0)
1521 {
1522 /*
1523 * If this try conditional is active and we are before its first
Bram Moolenaar269ec652004-07-29 08:43:53 +00001524 * ":catch", set THROWN so that the ":catch" commands will check
1525 * whether the exception matches. When the exception came from any of
1526 * the catch clauses, it will be made pending at the ":finally" (if
1527 * present) and rethrown at the ":endtry". This will also happen if
1528 * the try conditional is inactive. This is the case when we are
1529 * throwing an exception due to an error or interrupt on the way from
1530 * a preceding ":continue", ":break", ":return", ":finish", error or
1531 * interrupt (not converted to an exception) to the finally clause or
1532 * from a preceding throw of a user or error or interrupt exception to
1533 * the matching catch clause or the finally clause.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001534 */
1535 if (!(cstack->cs_flags[idx] & CSF_CAUGHT))
1536 {
1537 if (cstack->cs_flags[idx] & CSF_ACTIVE)
1538 cstack->cs_flags[idx] |= CSF_THROWN;
1539 else
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001540 // THROWN may have already been set for a catchable exception
1541 // that has been discarded. Ensure it is reset for the new
1542 // exception.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001543 cstack->cs_flags[idx] &= ~CSF_THROWN;
1544 }
1545 cstack->cs_flags[idx] &= ~CSF_ACTIVE;
1546 cstack->cs_exception[idx] = current_exception;
1547 }
1548#if 0
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001549 // TODO: Add optimization below. Not yet done because of interface
1550 // problems to eval.c and ex_cmds2.c. (Servatius)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001551 else
1552 {
1553 /*
1554 * There are no catch clauses to check or finally clauses to execute.
1555 * End the current script or function. The exception will be rethrown
1556 * in the caller.
1557 */
1558 if (getline_equal(eap->getline, eap->cookie, get_func_line))
1559 current_funccal->returned = TRUE;
1560 elseif (eap->get_func_line == getsourceline)
1561 ((struct source_cookie *)eap->cookie)->finished = TRUE;
1562 }
1563#endif
1564
1565 did_throw = TRUE;
1566}
1567
1568/*
1569 * ":try"
1570 */
1571 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001572ex_try(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001573{
1574 int skip;
Bram Moolenaarddef1292019-12-16 17:10:33 +01001575 cstack_T *cstack = eap->cstack;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001576
Bram Moolenaarfa984412021-03-25 22:15:28 +01001577 if (cmdmod_error())
1578 return;
1579
Bram Moolenaar071d4272004-06-13 20:20:40 +00001580 if (cstack->cs_idx == CSTACK_LEN - 1)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001581 eap->errmsg = _("E601: :try nesting too deep");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001582 else
1583 {
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02001584 enter_block(cstack);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001585 ++cstack->cs_trylevel;
1586 cstack->cs_flags[cstack->cs_idx] = CSF_TRY;
1587 cstack->cs_pending[cstack->cs_idx] = CSTP_NONE;
1588
1589 /*
1590 * Don't do something after an error, interrupt, or throw, or when there
1591 * is a surrounding conditional and it was not active.
1592 */
1593 skip = did_emsg || got_int || did_throw || (cstack->cs_idx > 0
1594 && !(cstack->cs_flags[cstack->cs_idx - 1] & CSF_ACTIVE));
1595
1596 if (!skip)
1597 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001598 // Set ACTIVE and TRUE. TRUE means that the corresponding ":catch"
1599 // commands should check for a match if an exception is thrown and
1600 // that the finally clause needs to be executed.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001601 cstack->cs_flags[cstack->cs_idx] |= CSF_ACTIVE | CSF_TRUE;
1602
1603 /*
1604 * ":silent!", even when used in a try conditional, disables
1605 * displaying of error messages and conversion of errors to
1606 * exceptions. When the silent commands again open a try
1607 * conditional, save "emsg_silent" and reset it so that errors are
1608 * again converted to exceptions. The value is restored when that
1609 * try conditional is left. If it is left normally, the commands
1610 * following the ":endtry" are again silent. If it is left by
1611 * a ":continue", ":break", ":return", or ":finish", the commands
1612 * executed next are again silent. If it is left due to an
1613 * aborting error, an interrupt, or an exception, restoring
1614 * "emsg_silent" does not matter since we are already in the
1615 * aborting state and/or the exception has already been thrown.
1616 * The effect is then just freeing the memory that was allocated
1617 * to save the value.
1618 */
1619 if (emsg_silent)
1620 {
1621 eslist_T *elem;
1622
Bram Moolenaarc799fe22019-05-28 23:08:19 +02001623 elem = ALLOC_ONE(struct eslist_elem);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001624 if (elem == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001625 emsg(_(e_outofmem));
Bram Moolenaar071d4272004-06-13 20:20:40 +00001626 else
1627 {
1628 elem->saved_emsg_silent = emsg_silent;
1629 elem->next = cstack->cs_emsg_silent_list;
1630 cstack->cs_emsg_silent_list = elem;
1631 cstack->cs_flags[cstack->cs_idx] |= CSF_SILENT;
1632 emsg_silent = 0;
1633 }
1634 }
1635 }
1636
1637 }
1638}
1639
1640/*
1641 * ":catch /{pattern}/" and ":catch"
1642 */
1643 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001644ex_catch(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001645{
1646 int idx = 0;
1647 int give_up = FALSE;
1648 int skip = FALSE;
1649 int caught = FALSE;
1650 char_u *end;
1651 int save_char = 0;
1652 char_u *save_cpo;
1653 regmatch_T regmatch;
1654 int prev_got_int;
Bram Moolenaarddef1292019-12-16 17:10:33 +01001655 cstack_T *cstack = eap->cstack;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001656 char_u *pat;
1657
Bram Moolenaarfa984412021-03-25 22:15:28 +01001658 if (cmdmod_error())
1659 return;
1660
Bram Moolenaar071d4272004-06-13 20:20:40 +00001661 if (cstack->cs_trylevel <= 0 || cstack->cs_idx < 0)
1662 {
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001663 eap->errmsg = _(e_catch);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001664 give_up = TRUE;
1665 }
1666 else
1667 {
1668 if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY))
1669 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001670 // Report what's missing if the matching ":try" is not in its
1671 // finally clause.
Bram Moolenaar12805862005-01-05 22:16:17 +00001672 eap->errmsg = get_end_emsg(cstack);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001673 skip = TRUE;
1674 }
1675 for (idx = cstack->cs_idx; idx > 0; --idx)
1676 if (cstack->cs_flags[idx] & CSF_TRY)
1677 break;
Bram Moolenaar41978282021-07-04 14:47:30 +02001678 if (cstack->cs_flags[idx] & CSF_TRY)
1679 cstack->cs_flags[idx] |= CSF_CATCH;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001680 if (cstack->cs_flags[idx] & CSF_FINALLY)
1681 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001682 // Give up for a ":catch" after ":finally" and ignore it.
1683 // Just parse.
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001684 eap->errmsg = _("E604: :catch after :finally");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001685 give_up = TRUE;
1686 }
Bram Moolenaarde8866b2005-01-06 23:24:37 +00001687 else
Bram Moolenaar12805862005-01-05 22:16:17 +00001688 rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR,
1689 &cstack->cs_looplevel);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001690 }
1691
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001692 if (ends_excmd2(eap->cmd, eap->arg)) // no argument, catch all errors
Bram Moolenaar071d4272004-06-13 20:20:40 +00001693 {
1694 pat = (char_u *)".*";
1695 end = NULL;
1696 eap->nextcmd = find_nextcmd(eap->arg);
1697 }
1698 else
1699 {
1700 pat = eap->arg + 1;
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001701 end = skip_regexp_err(pat, *eap->arg, TRUE);
1702 if (end == NULL)
1703 give_up = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001704 }
1705
1706 if (!give_up)
1707 {
1708 /*
1709 * Don't do something when no exception has been thrown or when the
1710 * corresponding try block never got active (because of an inactive
1711 * surrounding conditional or after an error or interrupt or throw).
1712 */
1713 if (!did_throw || !(cstack->cs_flags[idx] & CSF_TRUE))
1714 skip = TRUE;
1715
1716 /*
1717 * Check for a match only if an exception is thrown but not caught by
1718 * a previous ":catch". An exception that has replaced a discarded
1719 * exception is not checked (THROWN is not set then).
1720 */
1721 if (!skip && (cstack->cs_flags[idx] & CSF_THROWN)
1722 && !(cstack->cs_flags[idx] & CSF_CAUGHT))
1723 {
Bram Moolenaar2c5ed4e2020-04-20 19:42:10 +02001724 if (end != NULL && *end != NUL
1725 && !ends_excmd2(end, skipwhite(end + 1)))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001726 {
Bram Moolenaar2d06bfd2020-07-23 17:16:18 +02001727 semsg(_(e_trailing_arg), end);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001728 return;
1729 }
1730
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001731 // When debugging or a breakpoint was encountered, display the
1732 // debug prompt (if not already done) before checking for a match.
1733 // This is a helpful hint for the user when the regular expression
1734 // matching fails. Handle a ">quit" debug command as if an
1735 // interrupt had occurred before the ":catch". That is, discard
1736 // the original exception, replace it by an interrupt exception,
1737 // and don't catch it in this try block.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001738 if (!dbg_check_skipped(eap) || !do_intthrow(cstack))
1739 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001740 // Terminate the pattern and avoid the 'l' flag in 'cpoptions'
1741 // while compiling it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001742 if (end != NULL)
1743 {
1744 save_char = *end;
1745 *end = NUL;
1746 }
1747 save_cpo = p_cpo;
Bram Moolenaare5a2dc82021-01-03 19:52:05 +01001748 p_cpo = empty_option;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001749 // Disable error messages, it will make current_exception
1750 // invalid.
Bram Moolenaar768ce242016-02-07 19:46:12 +01001751 ++emsg_off;
Bram Moolenaar150cc272007-08-01 13:47:46 +00001752 regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
Bram Moolenaar768ce242016-02-07 19:46:12 +01001753 --emsg_off;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001754 regmatch.rm_ic = FALSE;
1755 if (end != NULL)
1756 *end = save_char;
1757 p_cpo = save_cpo;
1758 if (regmatch.regprog == NULL)
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001759 semsg(_(e_invarg2), pat);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001760 else
1761 {
1762 /*
1763 * Save the value of got_int and reset it. We don't want
1764 * a previous interruption cancel matching, only hitting
1765 * CTRL-C while matching should abort it.
1766 */
1767 prev_got_int = got_int;
1768 got_int = FALSE;
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01001769 caught = vim_regexec_nl(&regmatch,
1770 (char_u *)current_exception->value, (colnr_T)0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001771 got_int |= prev_got_int;
Bram Moolenaar473de612013-06-08 18:19:48 +02001772 vim_regfree(regmatch.regprog);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001773 }
1774 }
1775 }
1776
1777 if (caught)
1778 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001779 // Make this ":catch" clause active and reset did_emsg, got_int,
1780 // and did_throw. Put the exception on the caught stack.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001781 cstack->cs_flags[idx] |= CSF_ACTIVE | CSF_CAUGHT;
1782 did_emsg = got_int = did_throw = FALSE;
1783 catch_exception((except_T *)cstack->cs_exception[idx]);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001784 // It's mandatory that the current exception is stored in the cstack
1785 // so that it can be discarded at the next ":catch", ":finally", or
1786 // ":endtry" or when the catch clause is left by a ":continue",
1787 // ":break", ":return", ":finish", error, interrupt, or another
1788 // exception.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001789 if (cstack->cs_exception[cstack->cs_idx] != current_exception)
Bram Moolenaar95f09602016-11-10 20:01:45 +01001790 internal_error("ex_catch()");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001791 }
1792 else
1793 {
1794 /*
1795 * If there is a preceding catch clause and it caught the exception,
1796 * finish the exception now. This happens also after errors except
1797 * when this ":catch" was after the ":finally" or not within
1798 * a ":try". Make the try conditional inactive so that the
1799 * following catch clauses are skipped. On an error or interrupt
1800 * after the preceding try block or catch clause was left by
1801 * a ":continue", ":break", ":return", or ":finish", discard the
1802 * pending action.
1803 */
1804 cleanup_conditionals(cstack, CSF_TRY, TRUE);
1805 }
1806 }
1807
1808 if (end != NULL)
1809 eap->nextcmd = find_nextcmd(end);
1810}
1811
1812/*
1813 * ":finally"
1814 */
1815 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001816ex_finally(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001817{
1818 int idx;
1819 int skip = FALSE;
1820 int pending = CSTP_NONE;
Bram Moolenaarddef1292019-12-16 17:10:33 +01001821 cstack_T *cstack = eap->cstack;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001822
Bram Moolenaarfa984412021-03-25 22:15:28 +01001823 if (cmdmod_error())
1824 return;
1825
Bram Moolenaar071d4272004-06-13 20:20:40 +00001826 if (cstack->cs_trylevel <= 0 || cstack->cs_idx < 0)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001827 eap->errmsg = _(e_finally);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001828 else
1829 {
1830 if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY))
1831 {
Bram Moolenaar12805862005-01-05 22:16:17 +00001832 eap->errmsg = get_end_emsg(cstack);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001833 for (idx = cstack->cs_idx - 1; idx > 0; --idx)
1834 if (cstack->cs_flags[idx] & CSF_TRY)
1835 break;
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001836 // Make this error pending, so that the commands in the following
1837 // finally clause can be executed. This overrules also a pending
1838 // ":continue", ":break", ":return", or ":finish".
Bram Moolenaar071d4272004-06-13 20:20:40 +00001839 pending = CSTP_ERROR;
1840 }
1841 else
1842 idx = cstack->cs_idx;
1843
1844 if (cstack->cs_flags[idx] & CSF_FINALLY)
1845 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001846 // Give up for a multiple ":finally" and ignore it.
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001847 eap->errmsg = _(e_finally_dup);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001848 return;
1849 }
Bram Moolenaarde8866b2005-01-06 23:24:37 +00001850 rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR,
Bram Moolenaar12805862005-01-05 22:16:17 +00001851 &cstack->cs_looplevel);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001852
1853 /*
1854 * Don't do something when the corresponding try block never got active
1855 * (because of an inactive surrounding conditional or after an error or
1856 * interrupt or throw) or for a ":finally" without ":try" or a multiple
1857 * ":finally". After every other error (did_emsg or the conditional
1858 * errors detected above) or after an interrupt (got_int) or an
1859 * exception (did_throw), the finally clause must be executed.
1860 */
1861 skip = !(cstack->cs_flags[cstack->cs_idx] & CSF_TRUE);
1862
1863 if (!skip)
1864 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001865 // When debugging or a breakpoint was encountered, display the
1866 // debug prompt (if not already done). The user then knows that the
1867 // finally clause is executed.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001868 if (dbg_check_skipped(eap))
1869 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001870 // Handle a ">quit" debug command as if an interrupt had
1871 // occurred before the ":finally". That is, discard the
1872 // original exception and replace it by an interrupt
1873 // exception.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001874 (void)do_intthrow(cstack);
1875 }
1876
1877 /*
1878 * If there is a preceding catch clause and it caught the exception,
1879 * finish the exception now. This happens also after errors except
1880 * when this is a multiple ":finally" or one not within a ":try".
1881 * After an error or interrupt, this also discards a pending
1882 * ":continue", ":break", ":finish", or ":return" from the preceding
1883 * try block or catch clause.
1884 */
1885 cleanup_conditionals(cstack, CSF_TRY, FALSE);
1886
1887 /*
1888 * Make did_emsg, got_int, did_throw pending. If set, they overrule
1889 * a pending ":continue", ":break", ":return", or ":finish". Then
1890 * we have particularly to discard a pending return value (as done
1891 * by the call to cleanup_conditionals() above when did_emsg or
1892 * got_int is set). The pending values are restored by the
1893 * ":endtry", except if there is a new error, interrupt, exception,
1894 * ":continue", ":break", ":return", or ":finish" in the following
Bram Moolenaar12805862005-01-05 22:16:17 +00001895 * finally clause. A missing ":endwhile", ":endfor" or ":endif"
1896 * detected here is treated as if did_emsg and did_throw had
1897 * already been set, respectively in case that the error is not
1898 * converted to an exception, did_throw had already been unset.
1899 * We must not set did_emsg here since that would suppress the
1900 * error message.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001901 */
1902 if (pending == CSTP_ERROR || did_emsg || got_int || did_throw)
1903 {
1904 if (cstack->cs_pending[cstack->cs_idx] == CSTP_RETURN)
1905 {
1906 report_discard_pending(CSTP_RETURN,
Bram Moolenaarfca34d62005-01-04 21:38:36 +00001907 cstack->cs_rettv[cstack->cs_idx]);
1908 discard_pending_return(cstack->cs_rettv[cstack->cs_idx]);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001909 }
1910 if (pending == CSTP_ERROR && !did_emsg)
1911 pending |= (THROW_ON_ERROR) ? CSTP_THROW : 0;
1912 else
1913 pending |= did_throw ? CSTP_THROW : 0;
1914 pending |= did_emsg ? CSTP_ERROR : 0;
1915 pending |= got_int ? CSTP_INTERRUPT : 0;
1916 cstack->cs_pending[cstack->cs_idx] = pending;
1917
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001918 // It's mandatory that the current exception is stored in the
1919 // cstack so that it can be rethrown at the ":endtry" or be
1920 // discarded if the finally clause is left by a ":continue",
1921 // ":break", ":return", ":finish", error, interrupt, or another
1922 // exception. When emsg() is called for a missing ":endif" or
1923 // a missing ":endwhile"/":endfor" detected here, the
1924 // exception will be discarded.
Bram Moolenaarde8866b2005-01-06 23:24:37 +00001925 if (did_throw && cstack->cs_exception[cstack->cs_idx]
1926 != current_exception)
Bram Moolenaar95f09602016-11-10 20:01:45 +01001927 internal_error("ex_finally()");
Bram Moolenaar071d4272004-06-13 20:20:40 +00001928 }
1929
1930 /*
Bram Moolenaar12805862005-01-05 22:16:17 +00001931 * Set CSL_HAD_FINA, so do_cmdline() will reset did_emsg,
Bram Moolenaard4755bb2004-09-02 19:12:26 +00001932 * got_int, and did_throw and make the finally clause active.
1933 * This will happen after emsg() has been called for a missing
Bram Moolenaar12805862005-01-05 22:16:17 +00001934 * ":endif" or a missing ":endwhile"/":endfor" detected here, so
1935 * that the following finally clause will be executed even then.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001936 */
Bram Moolenaar12805862005-01-05 22:16:17 +00001937 cstack->cs_lflags |= CSL_HAD_FINA;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001938 }
1939 }
1940}
1941
1942/*
1943 * ":endtry"
1944 */
1945 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01001946ex_endtry(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001947{
1948 int idx;
1949 int skip;
1950 int rethrow = FALSE;
1951 int pending = CSTP_NONE;
Bram Moolenaarfca34d62005-01-04 21:38:36 +00001952 void *rettv = NULL;
Bram Moolenaarddef1292019-12-16 17:10:33 +01001953 cstack_T *cstack = eap->cstack;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001954
Bram Moolenaarfa984412021-03-25 22:15:28 +01001955 if (cmdmod_error())
1956 return;
1957
Bram Moolenaar071d4272004-06-13 20:20:40 +00001958 if (cstack->cs_trylevel <= 0 || cstack->cs_idx < 0)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02001959 eap->errmsg = _(e_no_endtry);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001960 else
1961 {
1962 /*
1963 * Don't do something after an error, interrupt or throw in the try
1964 * block, catch clause, or finally clause preceding this ":endtry" or
1965 * when an error or interrupt occurred after a ":continue", ":break",
1966 * ":return", or ":finish" in a try block or catch clause preceding this
1967 * ":endtry" or when the try block never got active (because of an
1968 * inactive surrounding conditional or after an error or interrupt or
1969 * throw) or when there is a surrounding conditional and it has been
1970 * made inactive by a ":continue", ":break", ":return", or ":finish" in
1971 * the finally clause. The latter case need not be tested since then
1972 * anything pending has already been discarded. */
Bram Moolenaar41978282021-07-04 14:47:30 +02001973 skip = did_emsg || got_int || did_throw
1974 || !(cstack->cs_flags[cstack->cs_idx] & CSF_TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001975
1976 if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY))
1977 {
Bram Moolenaar12805862005-01-05 22:16:17 +00001978 eap->errmsg = get_end_emsg(cstack);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01001979 // Find the matching ":try" and report what's missing.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001980 idx = cstack->cs_idx;
1981 do
1982 --idx;
1983 while (idx > 0 && !(cstack->cs_flags[idx] & CSF_TRY));
Bram Moolenaar12805862005-01-05 22:16:17 +00001984 rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR,
1985 &cstack->cs_looplevel);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001986 skip = TRUE;
1987
1988 /*
1989 * If an exception is being thrown, discard it to prevent it from
1990 * being rethrown at the end of this function. It would be
1991 * discarded by the error message, anyway. Resets did_throw.
1992 * This does not affect the script termination due to the error
1993 * since "trylevel" is decremented after emsg() has been called.
1994 */
1995 if (did_throw)
1996 discard_current_exception();
1997 }
1998 else
1999 {
2000 idx = cstack->cs_idx;
2001
Bram Moolenaar41978282021-07-04 14:47:30 +02002002 if (in_vim9script()
2003 && (cstack->cs_flags[idx] & (CSF_CATCH|CSF_FINALLY)) == 0)
2004 {
2005 // try/endtry without any catch or finally: give an error and
2006 // continue.
2007 eap->errmsg = _(e_missing_catch_or_finally);
2008 }
2009
Bram Moolenaar071d4272004-06-13 20:20:40 +00002010 /*
2011 * If we stopped with the exception currently being thrown at this
2012 * try conditional since we didn't know that it doesn't have
2013 * a finally clause, we need to rethrow it after closing the try
2014 * conditional.
2015 */
2016 if (did_throw && (cstack->cs_flags[idx] & CSF_TRUE)
2017 && !(cstack->cs_flags[idx] & CSF_FINALLY))
2018 rethrow = TRUE;
2019 }
2020
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002021 // If there was no finally clause, show the user when debugging or
2022 // a breakpoint was encountered that the end of the try conditional has
2023 // been reached: display the debug prompt (if not already done). Do
2024 // this on normal control flow or when an exception was thrown, but not
2025 // on an interrupt or error not converted to an exception or when
2026 // a ":break", ":continue", ":return", or ":finish" is pending. These
2027 // actions are carried out immediately.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002028 if ((rethrow || (!skip
2029 && !(cstack->cs_flags[idx] & CSF_FINALLY)
2030 && !cstack->cs_pending[idx]))
2031 && dbg_check_skipped(eap))
2032 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002033 // Handle a ">quit" debug command as if an interrupt had occurred
2034 // before the ":endtry". That is, throw an interrupt exception and
2035 // set "skip" and "rethrow".
Bram Moolenaar071d4272004-06-13 20:20:40 +00002036 if (got_int)
2037 {
2038 skip = TRUE;
2039 (void)do_intthrow(cstack);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002040 // The do_intthrow() call may have reset did_throw or
2041 // cstack->cs_pending[idx].
Bram Moolenaar071d4272004-06-13 20:20:40 +00002042 rethrow = FALSE;
2043 if (did_throw && !(cstack->cs_flags[idx] & CSF_FINALLY))
2044 rethrow = TRUE;
2045 }
2046 }
2047
2048 /*
2049 * If a ":return" is pending, we need to resume it after closing the
2050 * try conditional; remember the return value. If there was a finally
2051 * clause making an exception pending, we need to rethrow it. Make it
2052 * the exception currently being thrown.
2053 */
2054 if (!skip)
2055 {
2056 pending = cstack->cs_pending[idx];
2057 cstack->cs_pending[idx] = CSTP_NONE;
2058 if (pending == CSTP_RETURN)
Bram Moolenaarfca34d62005-01-04 21:38:36 +00002059 rettv = cstack->cs_rettv[idx];
Bram Moolenaar071d4272004-06-13 20:20:40 +00002060 else if (pending & CSTP_THROW)
2061 current_exception = cstack->cs_exception[idx];
2062 }
2063
2064 /*
2065 * Discard anything pending on an error, interrupt, or throw in the
2066 * finally clause. If there was no ":finally", discard a pending
2067 * ":continue", ":break", ":return", or ":finish" if an error or
2068 * interrupt occurred afterwards, but before the ":endtry" was reached.
2069 * If an exception was caught by the last of the catch clauses and there
2070 * was no finally clause, finish the exception now. This happens also
2071 * after errors except when this ":endtry" is not within a ":try".
2072 * Restore "emsg_silent" if it has been reset by this try conditional.
2073 */
Bram Moolenaareb3593b2006-04-22 22:33:57 +00002074 (void)cleanup_conditionals(cstack, CSF_TRY | CSF_SILENT, TRUE);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002075
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02002076 leave_block(cstack);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002077 --cstack->cs_trylevel;
2078
2079 if (!skip)
2080 {
2081 report_resume_pending(pending,
Bram Moolenaarfca34d62005-01-04 21:38:36 +00002082 (pending == CSTP_RETURN) ? rettv :
Bram Moolenaar071d4272004-06-13 20:20:40 +00002083 (pending & CSTP_THROW) ? (void *)current_exception : NULL);
2084 switch (pending)
2085 {
2086 case CSTP_NONE:
2087 break;
2088
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002089 // Reactivate a pending ":continue", ":break", ":return",
2090 // ":finish" from the try block or a catch clause of this try
2091 // conditional. This is skipped, if there was an error in an
2092 // (unskipped) conditional command or an interrupt afterwards
2093 // or if the finally clause is present and executed a new error,
2094 // interrupt, throw, ":continue", ":break", ":return", or
2095 // ":finish".
Bram Moolenaar071d4272004-06-13 20:20:40 +00002096 case CSTP_CONTINUE:
2097 ex_continue(eap);
2098 break;
2099 case CSTP_BREAK:
2100 ex_break(eap);
2101 break;
2102 case CSTP_RETURN:
Bram Moolenaarfca34d62005-01-04 21:38:36 +00002103 do_return(eap, FALSE, FALSE, rettv);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002104 break;
2105 case CSTP_FINISH:
2106 do_finish(eap, FALSE);
2107 break;
2108
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002109 // When the finally clause was entered due to an error,
2110 // interrupt or throw (as opposed to a ":continue", ":break",
2111 // ":return", or ":finish"), restore the pending values of
2112 // did_emsg, got_int, and did_throw. This is skipped, if there
2113 // was a new error, interrupt, throw, ":continue", ":break",
2114 // ":return", or ":finish". in the finally clause.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002115 default:
2116 if (pending & CSTP_ERROR)
2117 did_emsg = TRUE;
2118 if (pending & CSTP_INTERRUPT)
2119 got_int = TRUE;
2120 if (pending & CSTP_THROW)
2121 rethrow = TRUE;
2122 break;
2123 }
2124 }
2125
2126 if (rethrow)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002127 // Rethrow the current exception (within this cstack).
Bram Moolenaar071d4272004-06-13 20:20:40 +00002128 do_throw(cstack);
2129 }
2130}
2131
2132/*
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002133 * enter_cleanup() and leave_cleanup()
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002134 *
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002135 * Functions to be called before/after invoking a sequence of autocommands for
2136 * cleanup for a failed command. (Failure means here that a call to emsg()
2137 * has been made, an interrupt occurred, or there is an uncaught exception
2138 * from a previous autocommand execution of the same command.)
2139 *
2140 * Call enter_cleanup() with a pointer to a cleanup_T and pass the same
2141 * pointer to leave_cleanup(). The cleanup_T structure stores the pending
2142 * error/interrupt/exception state.
2143 */
2144
2145/*
2146 * This function works a bit like ex_finally() except that there was not
2147 * actually an extra try block around the part that failed and an error or
2148 * interrupt has not (yet) been converted to an exception. This function
2149 * saves the error/interrupt/ exception state and prepares for the call to
2150 * do_cmdline() that is going to be made for the cleanup autocommand
2151 * execution.
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002152 */
2153 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002154enter_cleanup(cleanup_T *csp)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002155{
2156 int pending = CSTP_NONE;
2157
2158 /*
2159 * Postpone did_emsg, got_int, did_throw. The pending values will be
2160 * restored by leave_cleanup() except if there was an aborting error,
2161 * interrupt, or uncaught exception after this function ends.
2162 */
2163 if (did_emsg || got_int || did_throw || need_rethrow)
2164 {
2165 csp->pending = (did_emsg ? CSTP_ERROR : 0)
2166 | (got_int ? CSTP_INTERRUPT : 0)
2167 | (did_throw ? CSTP_THROW : 0)
2168 | (need_rethrow ? CSTP_THROW : 0);
2169
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002170 // If we are currently throwing an exception (did_throw), save it as
2171 // well. On an error not yet converted to an exception, update
2172 // "force_abort" and reset "cause_abort" (as do_errthrow() would do).
2173 // This is needed for the do_cmdline() call that is going to be made
2174 // for autocommand execution. We need not save *msg_list because
2175 // there is an extra instance for every call of do_cmdline(), anyway.
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002176 if (did_throw || need_rethrow)
Bram Moolenaarcae24be2017-07-10 22:12:10 +02002177 {
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002178 csp->exception = current_exception;
Bram Moolenaarcae24be2017-07-10 22:12:10 +02002179 current_exception = NULL;
2180 }
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002181 else
2182 {
2183 csp->exception = NULL;
2184 if (did_emsg)
2185 {
2186 force_abort |= cause_abort;
2187 cause_abort = FALSE;
2188 }
2189 }
2190 did_emsg = got_int = did_throw = need_rethrow = FALSE;
2191
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002192 // Report if required by the 'verbose' option or when debugging.
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002193 report_make_pending(pending, csp->exception);
2194 }
2195 else
2196 {
2197 csp->pending = CSTP_NONE;
2198 csp->exception = NULL;
2199 }
2200}
2201
2202/*
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002203 * See comment above enter_cleanup() for how this function is used.
2204 *
2205 * This function is a bit like ex_endtry() except that there was not actually
2206 * an extra try block around the part that failed and an error or interrupt
2207 * had not (yet) been converted to an exception when the cleanup autocommand
2208 * sequence was invoked.
2209 *
2210 * This function has to be called with the address of the cleanup_T structure
2211 * filled by enter_cleanup() as an argument; it restores the error/interrupt/
2212 * exception state saved by that function - except there was an aborting
2213 * error, an interrupt or an uncaught exception during execution of the
2214 * cleanup autocommands. In the latter case, the saved error/interrupt/
2215 * exception state is discarded.
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002216 */
2217 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002218leave_cleanup(cleanup_T *csp)
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002219{
2220 int pending = csp->pending;
2221
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002222 if (pending == CSTP_NONE) // nothing to do
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002223 return;
2224
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002225 // If there was an aborting error, an interrupt, or an uncaught exception
2226 // after the corresponding call to enter_cleanup(), discard what has been
2227 // made pending by it. Report this to the user if required by the
2228 // 'verbose' option or when debugging.
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002229 if (aborting() || need_rethrow)
2230 {
2231 if (pending & CSTP_THROW)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002232 // Cancel the pending exception (includes report).
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002233 discard_exception((except_T *)csp->exception, FALSE);
2234 else
2235 report_discard_pending(pending, NULL);
2236
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002237 // If an error was about to be converted to an exception when
2238 // enter_cleanup() was called, free the message list.
Bram Moolenaar4632d292006-11-28 17:36:37 +00002239 if (msg_list != NULL)
Bram Moolenaar9fee7d42013-11-28 17:04:43 +01002240 free_global_msglist();
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002241 }
2242
2243 /*
2244 * If there was no new error, interrupt, or throw between the calls
2245 * to enter_cleanup() and leave_cleanup(), restore the pending
2246 * error/interrupt/exception state.
2247 */
2248 else
2249 {
2250 /*
2251 * If there was an exception being thrown when enter_cleanup() was
2252 * called, we need to rethrow it. Make it the exception currently
2253 * being thrown.
2254 */
2255 if (pending & CSTP_THROW)
2256 current_exception = csp->exception;
2257
2258 /*
2259 * If an error was about to be converted to an exception when
2260 * enter_cleanup() was called, let "cause_abort" take the part of
2261 * "force_abort" (as done by cause_errthrow()).
2262 */
2263 else if (pending & CSTP_ERROR)
2264 {
2265 cause_abort = force_abort;
2266 force_abort = FALSE;
2267 }
2268
2269 /*
2270 * Restore the pending values of did_emsg, got_int, and did_throw.
2271 */
2272 if (pending & CSTP_ERROR)
2273 did_emsg = TRUE;
2274 if (pending & CSTP_INTERRUPT)
2275 got_int = TRUE;
2276 if (pending & CSTP_THROW)
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002277 need_rethrow = TRUE; // did_throw will be set by do_one_cmd()
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002278
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002279 // Report if required by the 'verbose' option or when debugging.
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002280 report_resume_pending(pending,
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002281 (pending & CSTP_THROW) ? (void *)current_exception : NULL);
Bram Moolenaarc0197e22004-09-13 20:26:32 +00002282 }
2283}
2284
2285
2286/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00002287 * Make conditionals inactive and discard what's pending in finally clauses
2288 * until the conditional type searched for or a try conditional not in its
Bram Moolenaarde8866b2005-01-06 23:24:37 +00002289 * finally clause is reached. If this is in an active catch clause, finish
2290 * the caught exception.
2291 * Return the cstack index where the search stopped.
Bram Moolenaar12805862005-01-05 22:16:17 +00002292 * Values used for "searched_cond" are (CSF_WHILE | CSF_FOR) or CSF_TRY or 0,
2293 * the latter meaning the innermost try conditional not in its finally clause.
2294 * "inclusive" tells whether the conditional searched for should be made
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02002295 * inactive itself (a try conditional not in its finally clause possibly find
Bram Moolenaar12805862005-01-05 22:16:17 +00002296 * before is always made inactive). If "inclusive" is TRUE and
2297 * "searched_cond" is CSF_TRY|CSF_SILENT, the saved former value of
2298 * "emsg_silent", if reset when the try conditional finally reached was
Bram Moolenaar84a05ac2013-05-06 04:24:17 +02002299 * entered, is restored (used by ex_endtry()). This is normally done only
Bram Moolenaar12805862005-01-05 22:16:17 +00002300 * when such a try conditional is left.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002301 */
2302 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002303cleanup_conditionals(
Bram Moolenaarddef1292019-12-16 17:10:33 +01002304 cstack_T *cstack,
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002305 int searched_cond,
2306 int inclusive)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002307{
2308 int idx;
2309 int stop = FALSE;
2310
2311 for (idx = cstack->cs_idx; idx >= 0; --idx)
2312 {
2313 if (cstack->cs_flags[idx] & CSF_TRY)
2314 {
2315 /*
2316 * Discard anything pending in a finally clause and continue the
2317 * search. There may also be a pending ":continue", ":break",
2318 * ":return", or ":finish" before the finally clause. We must not
2319 * discard it, unless an error or interrupt occurred afterwards.
2320 */
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00002321 if (did_emsg || got_int || (cstack->cs_flags[idx] & CSF_FINALLY))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002322 {
2323 switch (cstack->cs_pending[idx])
2324 {
2325 case CSTP_NONE:
2326 break;
2327
2328 case CSTP_CONTINUE:
2329 case CSTP_BREAK:
2330 case CSTP_FINISH:
2331 report_discard_pending(cstack->cs_pending[idx], NULL);
2332 cstack->cs_pending[idx] = CSTP_NONE;
2333 break;
2334
2335 case CSTP_RETURN:
2336 report_discard_pending(CSTP_RETURN,
Bram Moolenaarfca34d62005-01-04 21:38:36 +00002337 cstack->cs_rettv[idx]);
2338 discard_pending_return(cstack->cs_rettv[idx]);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002339 cstack->cs_pending[idx] = CSTP_NONE;
2340 break;
2341
2342 default:
2343 if (cstack->cs_flags[idx] & CSF_FINALLY)
2344 {
2345 if (cstack->cs_pending[idx] & CSTP_THROW)
2346 {
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002347 // Cancel the pending exception. This is in the
2348 // finally clause, so that the stack of the
2349 // caught exceptions is not involved.
Bram Moolenaar13656f02020-12-19 17:55:54 +01002350 discard_exception(
2351 (except_T *)cstack->cs_exception[idx],
Bram Moolenaar071d4272004-06-13 20:20:40 +00002352 FALSE);
2353 }
2354 else
2355 report_discard_pending(cstack->cs_pending[idx],
2356 NULL);
2357 cstack->cs_pending[idx] = CSTP_NONE;
2358 }
2359 break;
2360 }
2361 }
2362
2363 /*
2364 * Stop at a try conditional not in its finally clause. If this try
2365 * conditional is in an active catch clause, finish the caught
2366 * exception.
2367 */
2368 if (!(cstack->cs_flags[idx] & CSF_FINALLY))
2369 {
2370 if ((cstack->cs_flags[idx] & CSF_ACTIVE)
2371 && (cstack->cs_flags[idx] & CSF_CAUGHT))
2372 finish_exception((except_T *)cstack->cs_exception[idx]);
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002373 // Stop at this try conditional - except the try block never
2374 // got active (because of an inactive surrounding conditional
2375 // or when the ":try" appeared after an error or interrupt or
2376 // throw).
Bram Moolenaar071d4272004-06-13 20:20:40 +00002377 if (cstack->cs_flags[idx] & CSF_TRUE)
2378 {
2379 if (searched_cond == 0 && !inclusive)
2380 break;
2381 stop = TRUE;
2382 }
2383 }
2384 }
2385
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002386 // Stop on the searched conditional type (even when the surrounding
2387 // conditional is not active or something has been made pending).
2388 // If "inclusive" is TRUE and "searched_cond" is CSF_TRY|CSF_SILENT,
2389 // check first whether "emsg_silent" needs to be restored.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002390 if (cstack->cs_flags[idx] & searched_cond)
2391 {
2392 if (!inclusive)
2393 break;
2394 stop = TRUE;
2395 }
2396 cstack->cs_flags[idx] &= ~CSF_ACTIVE;
2397 if (stop && searched_cond != (CSF_TRY | CSF_SILENT))
2398 break;
2399
2400 /*
Bram Moolenaarccc18222007-05-10 18:25:20 +00002401 * When leaving a try conditional that reset "emsg_silent" on its
2402 * entry after saving the original value, restore that value here and
2403 * free the memory used to store it.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002404 */
2405 if ((cstack->cs_flags[idx] & CSF_TRY)
Bram Moolenaarf461c8e2005-06-25 23:04:51 +00002406 && (cstack->cs_flags[idx] & CSF_SILENT))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002407 {
2408 eslist_T *elem;
2409
2410 elem = cstack->cs_emsg_silent_list;
2411 cstack->cs_emsg_silent_list = elem->next;
2412 emsg_silent = elem->saved_emsg_silent;
2413 vim_free(elem);
2414 cstack->cs_flags[idx] &= ~CSF_SILENT;
2415 }
2416 if (stop)
2417 break;
2418 }
2419 return idx;
2420}
2421
2422/*
Bram Moolenaar12805862005-01-05 22:16:17 +00002423 * Return an appropriate error message for a missing endwhile/endfor/endif.
2424 */
Bram Moolenaarf9e3e092019-01-13 23:38:42 +01002425 static char *
Bram Moolenaarddef1292019-12-16 17:10:33 +01002426get_end_emsg(cstack_T *cstack)
Bram Moolenaar12805862005-01-05 22:16:17 +00002427{
2428 if (cstack->cs_flags[cstack->cs_idx] & CSF_WHILE)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02002429 return _(e_endwhile);
Bram Moolenaar12805862005-01-05 22:16:17 +00002430 if (cstack->cs_flags[cstack->cs_idx] & CSF_FOR)
Bram Moolenaar8930caa2020-07-23 16:37:03 +02002431 return _(e_endfor);
2432 return _(e_endif);
Bram Moolenaar12805862005-01-05 22:16:17 +00002433}
2434
2435
2436/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00002437 * Rewind conditionals until index "idx" is reached. "cond_type" and
2438 * "cond_level" specify a conditional type and the address of a level variable
2439 * which is to be decremented with each skipped conditional of the specified
2440 * type.
Bram Moolenaarde8866b2005-01-06 23:24:37 +00002441 * Also free "for info" structures where needed.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002442 */
Bram Moolenaarde8866b2005-01-06 23:24:37 +00002443 void
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002444rewind_conditionals(
Bram Moolenaarddef1292019-12-16 17:10:33 +01002445 cstack_T *cstack,
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002446 int idx,
2447 int cond_type,
2448 int *cond_level)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002449{
2450 while (cstack->cs_idx > idx)
2451 {
2452 if (cstack->cs_flags[cstack->cs_idx] & cond_type)
2453 --*cond_level;
Bram Moolenaarde8866b2005-01-06 23:24:37 +00002454 if (cstack->cs_flags[cstack->cs_idx] & CSF_FOR)
2455 free_for_info(cstack->cs_forinfo[cstack->cs_idx]);
Bram Moolenaarfcdc5d82020-10-10 19:07:09 +02002456 leave_block(cstack);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002457 }
2458}
2459
2460/*
2461 * ":endfunction" when not after a ":function"
2462 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00002463 void
Bram Moolenaar6e949782020-04-13 17:21:00 +02002464ex_endfunction(exarg_T *eap)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002465{
Bram Moolenaar6e949782020-04-13 17:21:00 +02002466 if (eap->cmdidx == CMD_enddef)
2467 emsg(_("E193: :enddef not inside a function"));
2468 else
2469 emsg(_("E193: :endfunction not inside a function"));
Bram Moolenaar071d4272004-06-13 20:20:40 +00002470}
2471
2472/*
Bram Moolenaar12805862005-01-05 22:16:17 +00002473 * Return TRUE if the string "p" looks like a ":while" or ":for" command.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002474 */
2475 int
Bram Moolenaar78c0b7d2016-01-30 15:52:46 +01002476has_loop_cmd(char_u *p)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002477{
Bram Moolenaared53fb92007-11-24 20:50:24 +00002478 int len;
2479
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002480 // skip modifiers, white space and ':'
Bram Moolenaared53fb92007-11-24 20:50:24 +00002481 for (;;)
2482 {
2483 while (*p == ' ' || *p == '\t' || *p == ':')
2484 ++p;
2485 len = modifier_len(p);
2486 if (len == 0)
2487 break;
2488 p += len;
2489 }
Bram Moolenaar12805862005-01-05 22:16:17 +00002490 if ((p[0] == 'w' && p[1] == 'h')
2491 || (p[0] == 'f' && p[1] == 'o' && p[2] == 'r'))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002492 return TRUE;
2493 return FALSE;
2494}
2495
Bram Moolenaar217e1b82019-12-01 21:41:28 +01002496#endif // FEAT_EVAL