mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-23 11:38:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

*: Replace did_throw checks with current_exception checks

Browse Source 
Removes obsolete did_throw after that.
This commit is contained in:
ZyX
2018-03-25 15:13:05 +03:00
parent 79b4b6fc86
commit 201a4ef11c
5 changed files with 209 additions and 246 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/nvim/api/private/helpers.c
View File

@@ -56,7 +56,6 @@ void try_enter(TryState *const tstate)
.private_msg_list = NULL, .private_msg_list = NULL,
.trylevel = trylevel, .trylevel = trylevel,
.got_int = got_int, .got_int = got_int,
.did_throw = did_throw,
.need_rethrow = need_rethrow, .need_rethrow = need_rethrow,
.did_emsg = did_emsg, .did_emsg = did_emsg,
}; };
@@ -64,7 +63,6 @@ void try_enter(TryState *const tstate)
current_exception = NULL; current_exception = NULL;
trylevel = 1; trylevel = 1;
got_int = false; got_int = false;
did_throw = false;
need_rethrow = false; need_rethrow = false;
did_emsg = false; did_emsg = false;
} }
@@ -85,7 +83,6 @@ bool try_leave(const TryState *const tstate, Error *const err)
assert(trylevel == 0); assert(trylevel == 0);
assert(!need_rethrow); assert(!need_rethrow);
assert(!got_int); assert(!got_int);
assert(!did_throw);
assert(!did_emsg); assert(!did_emsg);
assert(msg_list == &tstate->private_msg_list); assert(msg_list == &tstate->private_msg_list);
assert(*msg_list == NULL); assert(*msg_list == NULL);
@@ -94,7 +91,6 @@ bool try_leave(const TryState *const tstate, Error *const err)
current_exception = tstate->current_exception; current_exception = tstate->current_exception;
trylevel = tstate->trylevel; trylevel = tstate->trylevel;
got_int = tstate->got_int; got_int = tstate->got_int;
did_throw = tstate->did_throw;
need_rethrow = tstate->need_rethrow; need_rethrow = tstate->need_rethrow;
did_emsg = tstate->did_emsg; did_emsg = tstate->did_emsg;
return ret; return ret;
@@ -130,7 +126,7 @@ bool try_end(Error *err)
did_emsg = false; did_emsg = false;
if (got_int) { if (got_int) {
if (did_throw) { if (current_exception) {
// If we got an interrupt, discard the current exception // If we got an interrupt, discard the current exception
discard_current_exception(); discard_current_exception();
} }
@@ -149,7 +145,7 @@ bool try_end(Error *err)
if (should_free) { if (should_free) {
xfree(msg); xfree(msg);
} }
} else if (did_throw) { } else if (current_exception) {
api_set_error(err, kErrorTypeException, "%s", current_exception->value); api_set_error(err, kErrorTypeException, "%s", current_exception->value);
discard_current_exception(); discard_current_exception();
} }

1
src/nvim/api/private/helpers.h
View File

@@ -93,7 +93,6 @@ typedef struct {
const struct msglist *const *msg_list; const struct msglist *const *msg_list;
int trylevel; int trylevel;
int got_int; int got_int;
int did_throw;
int need_rethrow; int need_rethrow;
int did_emsg; int did_emsg;
} TryState; } TryState;

99
src/nvim/ex_docmd.c
View File

@@ -133,7 +133,6 @@ struct dbg_stuff {
char_u *vv_throwpoint; char_u *vv_throwpoint;
int did_emsg; int did_emsg;
int got_int; int got_int;
int did_throw;
int need_rethrow; int need_rethrow;
int check_cstack; int check_cstack;
except_T *current_exception; except_T *current_exception;
@@ -165,12 +164,11 @@ static void save_dbg_stuff(struct dbg_stuff *dsp)
dsp->vv_exception = v_exception(NULL); dsp->vv_exception = v_exception(NULL);
dsp->vv_throwpoint = v_throwpoint(NULL); dsp->vv_throwpoint = v_throwpoint(NULL);
/* Necessary for debugging an inactive ":catch", ":finally", ":endtry" */ // Necessary for debugging an inactive ":catch", ":finally", ":endtry".
dsp->did_emsg = did_emsg; did_emsg = FALSE; dsp->did_emsg = did_emsg; did_emsg = false;
dsp->got_int = got_int; got_int = FALSE; dsp->got_int = got_int; got_int = false;
dsp->did_throw = did_throw; did_throw = FALSE; dsp->need_rethrow = need_rethrow; need_rethrow = false;
dsp->need_rethrow = need_rethrow; need_rethrow = FALSE; dsp->check_cstack = check_cstack; check_cstack = false;
dsp->check_cstack = check_cstack; check_cstack = FALSE;
dsp->current_exception = current_exception; current_exception = NULL; dsp->current_exception = current_exception; current_exception = NULL;
} }
@@ -184,7 +182,6 @@ static void restore_dbg_stuff(struct dbg_stuff *dsp)
(void)v_throwpoint(dsp->vv_throwpoint); (void)v_throwpoint(dsp->vv_throwpoint);
did_emsg = dsp->did_emsg; did_emsg = dsp->did_emsg;
got_int = dsp->got_int; got_int = dsp->got_int;
did_throw = dsp->did_throw;
need_rethrow = dsp->need_rethrow; need_rethrow = dsp->need_rethrow;
check_cstack = dsp->check_cstack; check_cstack = dsp->check_cstack;
current_exception = dsp->current_exception; current_exception = dsp->current_exception;
@@ -400,10 +397,6 @@ int do_cmdline(char_u *cmdline, LineGetter fgetline,
initial_trylevel = trylevel; initial_trylevel = trylevel;
/*
* "did_throw" will be set to TRUE when an exception is being thrown.
*/
did_throw = false;
current_exception = NULL; current_exception = NULL;
// "did_emsg" will be set to TRUE when emsg() is used, in which case we // "did_emsg" will be set to TRUE when emsg() is used, in which case we
// cancel the whole command line, and any if/endif or loop. // cancel the whole command line, and any if/endif or loop.
@@ -658,7 +651,7 @@ int do_cmdline(char_u *cmdline, LineGetter fgetline,
* not to use a cs_line[] from an entry that isn't a ":while" * not to use a cs_line[] from an entry that isn't a ":while"
* or ":for": It would make "current_line" invalid and can * or ":for": It would make "current_line" invalid and can
* cause a crash. */ * cause a crash. */
if (!did_emsg && !got_int && !did_throw if (!did_emsg && !got_int && !current_exception
&& cstack.cs_idx >= 0 && cstack.cs_idx >= 0
&& (cstack.cs_flags[cstack.cs_idx] && (cstack.cs_flags[cstack.cs_idx]
& (CSF_WHILE | CSF_FOR)) & (CSF_WHILE | CSF_FOR))
@@ -706,7 +699,7 @@ int do_cmdline(char_u *cmdline, LineGetter fgetline,
} }
/* /*
* A ":finally" makes did_emsg, got_int, and did_throw pending for * A ":finally" makes did_emsg, got_int and current_exception pending for
* being restored at the ":endtry". Reset them here and set the * being restored at the ":endtry". Reset them here and set the
* ACTIVE and FINALLY flags, so that the finally clause gets executed. * ACTIVE and FINALLY flags, so that the finally clause gets executed.
* This includes the case where a missing ":endif", ":endwhile" or * This includes the case where a missing ":endif", ":endwhile" or
@@ -716,8 +709,8 @@ int do_cmdline(char_u *cmdline, LineGetter fgetline,
cstack.cs_lflags &= ~CSL_HAD_FINA; cstack.cs_lflags &= ~CSL_HAD_FINA;
report_make_pending((cstack.cs_pending[cstack.cs_idx] report_make_pending((cstack.cs_pending[cstack.cs_idx]
& (CSTP_ERROR | CSTP_INTERRUPT | CSTP_THROW)), & (CSTP_ERROR | CSTP_INTERRUPT | CSTP_THROW)),
(did_throw ? (void *)current_exception : NULL)); current_exception);
did_emsg = got_int = did_throw = false; did_emsg = got_int = false;
current_exception = NULL; current_exception = NULL;
cstack.cs_flags[cstack.cs_idx] |= CSF_ACTIVE | CSF_FINALLY; cstack.cs_flags[cstack.cs_idx] |= CSF_ACTIVE | CSF_FINALLY;
} }
@@ -726,15 +719,14 @@ int do_cmdline(char_u *cmdline, LineGetter fgetline,
* within this loop. */ * within this loop. */
trylevel = initial_trylevel + cstack.cs_trylevel; trylevel = initial_trylevel + cstack.cs_trylevel;
/* // If the outermost try conditional (across function calls and sourced
* If the outermost try conditional (across function calls and sourced // files) is aborted because of an error, an interrupt, or an uncaught
* files) is aborted because of an error, an interrupt, or an uncaught // exception, cancel everything. If it is left normally, reset
* exception, cancel everything. If it is left normally, reset // force_abort to get the non-EH compatible abortion behavior for
* force_abort to get the non-EH compatible abortion behavior for // the rest of the script.
* the rest of the script. if (trylevel == 0 && !did_emsg && !got_int && !current_exception) {
*/ force_abort = false;
if (trylevel == 0 && !did_emsg && !got_int && !did_throw) }
force_abort = FALSE;
/* Convert an interrupt to an exception if appropriate. */ /* Convert an interrupt to an exception if appropriate. */
(void)do_intthrow(&cstack); (void)do_intthrow(&cstack);
@@ -749,11 +741,8 @@ int do_cmdline(char_u *cmdline, LineGetter fgetline,
* - there is a command after '|', inside a :if, :while, :for or :try, or * - there is a command after '|', inside a :if, :while, :for or :try, or
* looping for ":source" command or function call. * looping for ":source" command or function call.
*/ */
while (!((got_int while (!((got_int || (did_emsg && force_abort) || current_exception)
|| (did_emsg && force_abort) || did_throw && cstack.cs_trylevel == 0)
)
&& cstack.cs_trylevel == 0
)
&& !(did_emsg && !(did_emsg
/* Keep going when inside try/catch, so that the error can be /* Keep going when inside try/catch, so that the error can be
* deal with, except when it is a syntax error, it may cause * deal with, except when it is a syntax error, it may cause
@@ -775,7 +764,7 @@ int do_cmdline(char_u *cmdline, LineGetter fgetline,
* If a sourced file or executed function ran to its end, report the * If a sourced file or executed function ran to its end, report the
* unclosed conditional. * unclosed conditional.
*/ */
if (!got_int && !did_throw if (!got_int && !current_exception
&& ((getline_equal(fgetline, cookie, getsourceline) && ((getline_equal(fgetline, cookie, getsourceline)
&& !source_finished(fgetline, cookie)) && !source_finished(fgetline, cookie))
|| (getline_equal(fgetline, cookie, get_func_line) || (getline_equal(fgetline, cookie, get_func_line)
@@ -815,17 +804,16 @@ int do_cmdline(char_u *cmdline, LineGetter fgetline,
? (char_u *)"endfunction" : (char_u *)NULL); ? (char_u *)"endfunction" : (char_u *)NULL);
if (trylevel == 0) { if (trylevel == 0) {
/* // When an exception is being thrown out of the outermost try
* When an exception is being thrown out of the outermost try // conditional, discard the uncaught exception, disable the conversion
* conditional, discard the uncaught exception, disable the conversion // of interrupts or errors to exceptions, and ensure that no more
* of interrupts or errors to exceptions, and ensure that no more // commands are executed.
* commands are executed. if (current_exception) {
*/
if (did_throw) {
void *p = NULL; void *p = NULL;
char_u *saved_sourcing_name; char_u *saved_sourcing_name;
int saved_sourcing_lnum; int saved_sourcing_lnum;
struct msglist *messages = NULL, *next; struct msglist *messages = NULL;
struct msglist *next;
/* /*
* If the uncaught exception is a user exception, report it as an * If the uncaught exception is a user exception, report it as an
@@ -885,22 +873,22 @@ int do_cmdline(char_u *cmdline, LineGetter fgetline,
suppress_errthrow = TRUE; suppress_errthrow = TRUE;
} }
/* // The current cstack will be freed when do_cmdline() returns. An uncaught
* The current cstack will be freed when do_cmdline() returns. An uncaught // exception will have to be rethrown in the previous cstack. If a function
* exception will have to be rethrown in the previous cstack. If a function // has just returned or a script file was just finished and the previous
* has just returned or a script file was just finished and the previous // cstack belongs to the same function or, respectively, script file, it
* cstack belongs to the same function or, respectively, script file, it // will have to be checked for finally clauses to be executed due to the
* will have to be checked for finally clauses to be executed due to the // ":return" or ":finish". This is done in do_one_cmd().
* ":return" or ":finish". This is done in do_one_cmd(). if (current_exception) {
*/ need_rethrow = true;
if (did_throw) }
need_rethrow = TRUE;
if ((getline_equal(fgetline, cookie, getsourceline) if ((getline_equal(fgetline, cookie, getsourceline)
&& ex_nesting_level > source_level(real_cookie)) && ex_nesting_level > source_level(real_cookie))
|| (getline_equal(fgetline, cookie, get_func_line) || (getline_equal(fgetline, cookie, get_func_line)
&& ex_nesting_level > func_level(real_cookie) + 1)) { && ex_nesting_level > func_level(real_cookie) + 1)) {
if (!did_throw) if (!current_exception) {
check_cstack = TRUE; check_cstack = true;
}
} else { } else {
/* When leaving a function, reduce nesting level. */ /* When leaving a function, reduce nesting level. */
if (getline_equal(fgetline, cookie, get_func_line)) if (getline_equal(fgetline, cookie, get_func_line))
@@ -1480,10 +1468,11 @@ static char_u * do_one_cmd(char_u **cmdlinep,
} }
char_u *after_modifier = ea.cmd; char_u *after_modifier = ea.cmd;
ea.skip = did_emsg || got_int || did_throw || (cstack->cs_idx >= 0 ea.skip = (did_emsg
&& !(cstack->cs_flags[cstack-> || got_int
cs_idx] || current_exception
& CSF_ACTIVE)); || (cstack->cs_idx >= 0
&& !(cstack->cs_flags[cstack->cs_idx] & CSF_ACTIVE)));
/* Count this line for profiling if ea.skip is FALSE. */ /* Count this line for profiling if ea.skip is FALSE. */
if (do_profiling == PROF_YES && !ea.skip) { if (do_profiling == PROF_YES && !ea.skip) {

318
src/nvim/ex_eval.c
View File

@@ -45,22 +45,21 @@
* there or even outside the try conditional. Try conditionals may be nested. * there or even outside the try conditional. Try conditionals may be nested.
*/ */
/* // Configuration whether an exception is thrown on error or interrupt. When
* Configuration whether an exception is thrown on error or interrupt. When // the preprocessor macros below evaluate to FALSE, an error (did_emsg) or
* the preprocessor macros below evaluate to FALSE, an error (did_emsg) or // interrupt (got_int) under an active try conditional terminates the script
* interrupt (got_int) under an active try conditional terminates the script // after the non-active finally clauses of all active try conditionals have been
* after the non-active finally clauses of all active try conditionals have been // executed. Otherwise, errors and/or interrupts are converted into catchable
* executed. Otherwise, errors and/or interrupts are converted into catchable // exceptions, which terminate the script only if not caught. For user
* exceptions (did_throw additionally set), which terminate the script only if // exceptions, only current_exception is set. (Note: got_int can be set
* not caught. For user exceptions, only did_throw is set. (Note: got_int can // asynchronously afterwards by a SIGINT, so current_exception && got_int is not
* be set asynchronously afterwards by a SIGINT, so did_throw && got_int is not // a reliant test that the exception currently being thrown is an interrupt
* a reliant test that the exception currently being thrown is an interrupt // exception. Similarly, did_emsg can be set afterwards on an error in an
* exception. Similarly, did_emsg can be set afterwards on an error in an // (unskipped) conditional command inside an inactive conditional, so
* (unskipped) conditional command inside an inactive conditional, so did_throw // current_exception && did_emsg is not a reliant test that the exception
* && did_emsg is not a reliant test that the exception currently being thrown // currently being thrown is an error exception.) - The macros can be defined
* is an error exception.) - The macros can be defined as expressions checking // as expressions checking for a variable that is allowed to be changed during
* for a variable that is allowed to be changed during execution of a script. // execution of a script.
*/
// Values used for the Vim release. // Values used for the Vim release.
#define THROW_ON_ERROR true #define THROW_ON_ERROR true
@@ -68,6 +67,15 @@
#define THROW_ON_INTERRUPT true #define THROW_ON_INTERRUPT true
#define THROW_ON_INTERRUPT_TRUE #define THROW_ON_INTERRUPT_TRUE
// Don't do something after an error, interrupt, or throw, or when
// there is a surrounding conditional and it was not active.
#define CHECK_SKIP \
(did_emsg \
|| got_int \
|| current_exception \
|| (cstack->cs_idx > 0 \
&& !(cstack->cs_flags[cstack->cs_idx - 1] & CSF_ACTIVE)))
#define discard_pending_return(p) tv_free((typval_T *)(p)) #define discard_pending_return(p) tv_free((typval_T *)(p))
/* /*
@@ -94,7 +102,7 @@ static int cause_abort = FALSE;
*/ */
int aborting(void) int aborting(void)
{ {
return (did_emsg && force_abort) || got_int || did_throw; return (did_emsg && force_abort) || got_int || current_exception;
} }
/* /*
@@ -178,8 +186,9 @@ int cause_errthrow(char_u *mesg, int severe, int *ignore)
* currently throwing an exception, do nothing. The message text will * currently throwing an exception, do nothing. The message text will
* then be stored to v:errmsg by emsg() without displaying it. * then be stored to v:errmsg by emsg() without displaying it.
*/ */
if (((trylevel == 0 && !cause_abort) || emsg_silent) && !did_throw) if (((trylevel == 0 && !cause_abort) || emsg_silent) && !current_exception) {
return FALSE; return false;
}
/* /*
* Ignore an interrupt message when inside a try conditional or when an * Ignore an interrupt message when inside a try conditional or when an
@@ -208,12 +217,13 @@ int cause_errthrow(char_u *mesg, int severe, int *ignore)
* exception currently being thrown to prevent it from being caught. Just * exception currently being thrown to prevent it from being caught. Just
* execute finally clauses and terminate. * execute finally clauses and terminate.
*/ */
if (did_throw) { if (current_exception) {
/* When discarding an interrupt exception, reset got_int to prevent the // When discarding an interrupt exception, reset got_int to prevent the
* same interrupt being converted to an exception again and discarding // same interrupt being converted to an exception again and discarding
* the error exception we are about to throw here. */ // the error exception we are about to throw here.
if (current_exception->type == ET_INTERRUPT) if (current_exception->type == ET_INTERRUPT) {
got_int = FALSE; got_int = false;
}
discard_current_exception(); discard_current_exception();
} }
@@ -333,45 +343,44 @@ void do_errthrow(struct condstack *cstack, char_u *cmdname)
*/ */
int do_intthrow(struct condstack *cstack) int do_intthrow(struct condstack *cstack)
{ {
/* // If no interrupt occurred or no try conditional is active and no exception
* If no interrupt occurred or no try conditional is active and no exception // is being thrown, do nothing (for compatibility of non-EH scripts).
* is being thrown, do nothing (for compatibility of non-EH scripts). if (!got_int || (trylevel == 0 && !current_exception)) {
*/ return false;
if (!got_int || (trylevel == 0 && !did_throw)) }
return FALSE;
#ifdef THROW_TEST /* avoid warning for condition always true */ #ifdef THROW_TEST // avoid warning for condition always true
if (!THROW_ON_INTERRUPT) { if (!THROW_ON_INTERRUPT) {
/* // The interrupt aborts everything except for executing finally clauses.
* The interrupt aborts everything except for executing finally clauses. // Discard any user or error or interrupt exception currently being
* Discard any user or error or interrupt exception currently being // thrown.
* thrown. if (current_exception) {
*/
if (did_throw)
discard_current_exception();
} else
#endif
{
/*
* Throw an interrupt exception, so that everything will be aborted
* (except for executing finally clauses), until the interrupt exception
* is caught; if still uncaught at the top level, the script processing
* will be terminated then. - If an interrupt exception is already
* being thrown, do nothing.
*
*/
if (did_throw) {
if (current_exception->type == ET_INTERRUPT)
return FALSE;
/* An interrupt exception replaces any user or error exception. */
discard_current_exception(); discard_current_exception();
} }
if (throw_exception("Vim:Interrupt", ET_INTERRUPT, NULL) != FAIL) } else {
#endif
// Throw an interrupt exception, so that everything will be aborted
// (except for executing finally clauses), until the interrupt exception
// is caught; if still uncaught at the top level, the script processing
// will be terminated then. - If an interrupt exception is already
// being thrown, do nothing.
if (current_exception) {
if (current_exception->type == ET_INTERRUPT) {
return false;
}
// An interrupt exception replaces any user or error exception.
discard_current_exception();
}
if (throw_exception("Vim:Interrupt", ET_INTERRUPT, NULL) != FAIL) {
do_throw(cstack); do_throw(cstack);
} }
#ifdef THROW_TEST
}
#endif
return TRUE; return true;
} }
// Get an exception message that is to be stored in current_exception->value. // Get an exception message that is to be stored in current_exception->value.
@@ -565,8 +574,7 @@ void discard_current_exception(void)
// Note: all globals manipulated here should be saved/restored in // Note: all globals manipulated here should be saved/restored in
// try_enter/try_leave. // try_enter/try_leave.
current_exception = NULL; current_exception = NULL;
did_throw = FALSE; need_rethrow = false;
need_rethrow = FALSE;
} }
/* /*
@@ -795,15 +803,7 @@ void ex_if(exarg_T *eap)
++cstack->cs_idx; ++cstack->cs_idx;
cstack->cs_flags[cstack->cs_idx] = 0; cstack->cs_flags[cstack->cs_idx] = 0;
/* skip = CHECK_SKIP;
* Don't do something after an error, interrupt, or throw, or when there
* is a surrounding conditional and it was not active.
*/
skip = did_emsg || got_int || did_throw || (cstack->cs_idx > 0
&& !(cstack->cs_flags[cstack->
cs_idx -
1] &
CSF_ACTIVE));
bool error; bool error;
result = eval_to_bool(eap->arg, &error, &eap->nextcmd, skip); result = eval_to_bool(eap->arg, &error, &eap->nextcmd, skip);
@@ -854,15 +854,7 @@ void ex_else(exarg_T *eap)
int result; int result;
struct condstack *cstack = eap->cstack; struct condstack *cstack = eap->cstack;
/* skip = CHECK_SKIP;
* Don't do something after an error, interrupt, or throw, or when there is
* a surrounding conditional and it was not active.
*/
skip = did_emsg || got_int || did_throw || (cstack->cs_idx > 0
&& !(cstack->cs_flags[cstack->
cs_idx -
1] &
CSF_ACTIVE));
if (cstack->cs_idx < 0 if (cstack->cs_idx < 0
|| (cstack->cs_flags[cstack->cs_idx] || (cstack->cs_flags[cstack->cs_idx]
@@ -952,15 +944,7 @@ void ex_while(exarg_T *eap)
cstack->cs_flags[cstack->cs_idx] = cstack->cs_flags[cstack->cs_idx] =
eap->cmdidx == CMD_while ? CSF_WHILE : CSF_FOR; eap->cmdidx == CMD_while ? CSF_WHILE : CSF_FOR;
/* skip = CHECK_SKIP;
* Don't do something after an error, interrupt, or throw, or when
* there is a surrounding conditional and it was not active.
*/
skip = did_emsg || got_int || did_throw || (cstack->cs_idx > 0
&& !(cstack->cs_flags[cstack->
cs_idx -
1] &
CSF_ACTIVE));
if (eap->cmdidx == CMD_while) { if (eap->cmdidx == CMD_while) {
/* /*
* ":while bool-expr" * ":while bool-expr"
@@ -1233,8 +1217,6 @@ void do_throw(struct condstack *cstack)
cstack->cs_flags[idx] &= ~CSF_ACTIVE; cstack->cs_flags[idx] &= ~CSF_ACTIVE;
cstack->cs_exception[idx] = current_exception; cstack->cs_exception[idx] = current_exception;
} }
did_throw = TRUE;
} }
/* /*
@@ -1253,15 +1235,7 @@ void ex_try(exarg_T *eap)
cstack->cs_flags[cstack->cs_idx] = CSF_TRY; cstack->cs_flags[cstack->cs_idx] = CSF_TRY;
cstack->cs_pending[cstack->cs_idx] = CSTP_NONE; cstack->cs_pending[cstack->cs_idx] = CSTP_NONE;
/* skip = CHECK_SKIP;
* Don't do something after an error, interrupt, or throw, or when there
* is a surrounding conditional and it was not active.
*/
skip = did_emsg || got_int || did_throw || (cstack->cs_idx > 0
&& !(cstack->cs_flags[cstack->
cs_idx -
1] &
CSF_ACTIVE));
if (!skip) { if (!skip) {
/* Set ACTIVE and TRUE. TRUE means that the corresponding ":catch" /* Set ACTIVE and TRUE. TRUE means that the corresponding ":catch"
@@ -1353,8 +1327,9 @@ void ex_catch(exarg_T *eap)
* corresponding try block never got active (because of an inactive * corresponding try block never got active (because of an inactive
* surrounding conditional or after an error or interrupt or throw). * surrounding conditional or after an error or interrupt or throw).
*/ */
if (!did_throw || !(cstack->cs_flags[idx] & CSF_TRUE)) if (!current_exception || !(cstack->cs_flags[idx] & CSF_TRUE)) {
skip = TRUE; skip = true;
}
/* /*
* Check for a match only if an exception is thrown but not caught by * Check for a match only if an exception is thrown but not caught by
@@ -1413,10 +1388,10 @@ void ex_catch(exarg_T *eap)
} }
if (caught) { if (caught) {
/* Make this ":catch" clause active and reset did_emsg, got_int, /* Make this ":catch" clause active and reset did_emsg and got_int.
* and did_throw. Put the exception on the caught stack. */ * Put the exception on the caught stack. */
cstack->cs_flags[idx] |= CSF_ACTIVE | CSF_CAUGHT; cstack->cs_flags[idx] |= CSF_ACTIVE | CSF_CAUGHT;
did_emsg = got_int = did_throw = FALSE; did_emsg = got_int = false;
catch_exception((except_T *)cstack->cs_exception[idx]); catch_exception((except_T *)cstack->cs_exception[idx]);
/* It's mandatory that the current exception is stored in the cstack /* It's mandatory that the current exception is stored in the cstack
* so that it can be discarded at the next ":catch", ":finally", or * so that it can be discarded at the next ":catch", ":finally", or
@@ -1428,7 +1403,7 @@ void ex_catch(exarg_T *eap)
} }
// Discarding current_exceptions happens based on what is stored in // Discarding current_exceptions happens based on what is stored in
// cstack->cs_exception, *all* calls to discard_current_exception() are // cstack->cs_exception, *all* calls to discard_current_exception() are
// (and must be) guarded by did_throw which was already unset above. // (and must be) guarded by current_exception check.
current_exception = NULL; current_exception = NULL;
} else { } else {
/* /*
@@ -1488,7 +1463,7 @@ void ex_finally(exarg_T *eap)
* interrupt or throw) or for a ":finally" without ":try" or a multiple * interrupt or throw) or for a ":finally" without ":try" or a multiple
* ":finally". After every other error (did_emsg or the conditional * ":finally". After every other error (did_emsg or the conditional
* errors detected above) or after an interrupt (got_int) or an * errors detected above) or after an interrupt (got_int) or an
* exception (did_throw), the finally clause must be executed. * exception (current_exception), the finally clause must be executed.
*/ */
skip = !(cstack->cs_flags[cstack->cs_idx] & CSF_TRUE); skip = !(cstack->cs_flags[cstack->cs_idx] & CSF_TRUE);
@@ -1515,30 +1490,31 @@ void ex_finally(exarg_T *eap)
cleanup_conditionals(cstack, CSF_TRY, FALSE); cleanup_conditionals(cstack, CSF_TRY, FALSE);
/* /*
* Make did_emsg, got_int, did_throw pending. If set, they overrule * Make did_emsg, got_int, current_exception pending. If set, they
* a pending ":continue", ":break", ":return", or ":finish". Then * overrule a pending ":continue", ":break", ":return", or ":finish".
* we have particularly to discard a pending return value (as done * Then we have particularly to discard a pending return value (as done
* by the call to cleanup_conditionals() above when did_emsg or * by the call to cleanup_conditionals() above when did_emsg or
* got_int is set). The pending values are restored by the * got_int is set). The pending values are restored by the
* ":endtry", except if there is a new error, interrupt, exception, * ":endtry", except if there is a new error, interrupt, exception,
* ":continue", ":break", ":return", or ":finish" in the following * ":continue", ":break", ":return", or ":finish" in the following
* finally clause. A missing ":endwhile", ":endfor" or ":endif" * finally clause. A missing ":endwhile", ":endfor" or ":endif"
* detected here is treated as if did_emsg and did_throw had * detected here is treated as if did_emsg and current_exception had
* already been set, respectively in case that the error is not * already been set, respectively in case that the error is not
* converted to an exception, did_throw had already been unset. * converted to an exception, current_exception had already been unset.
* We must not set did_emsg here since that would suppress the * We must not set did_emsg here since that would suppress the
* error message. * error message.
*/ */
if (pending == CSTP_ERROR || did_emsg || got_int || did_throw) { if (pending == CSTP_ERROR || did_emsg || got_int || current_exception) {
if (cstack->cs_pending[cstack->cs_idx] == CSTP_RETURN) { if (cstack->cs_pending[cstack->cs_idx] == CSTP_RETURN) {
report_discard_pending(CSTP_RETURN, report_discard_pending(CSTP_RETURN,
cstack->cs_rettv[cstack->cs_idx]); cstack->cs_rettv[cstack->cs_idx]);
discard_pending_return(cstack->cs_rettv[cstack->cs_idx]); discard_pending_return(cstack->cs_rettv[cstack->cs_idx]);
} }
if (pending == CSTP_ERROR && !did_emsg) if (pending == CSTP_ERROR && !did_emsg) {
pending |= (THROW_ON_ERROR) ? CSTP_THROW : 0; pending |= (THROW_ON_ERROR ? CSTP_THROW : 0);
else } else {
pending |= did_throw ? CSTP_THROW : 0; pending |= (current_exception ? CSTP_THROW : 0);
}
pending |= did_emsg ? CSTP_ERROR : 0; pending |= did_emsg ? CSTP_ERROR : 0;
pending |= got_int ? CSTP_INTERRUPT : 0; pending |= got_int ? CSTP_INTERRUPT : 0;
assert(pending >= CHAR_MIN && pending <= CHAR_MAX); assert(pending >= CHAR_MIN && pending <= CHAR_MAX);
@@ -1551,14 +1527,15 @@ void ex_finally(exarg_T *eap)
* exception. When emsg() is called for a missing ":endif" or * exception. When emsg() is called for a missing ":endif" or
* a missing ":endwhile"/":endfor" detected here, the * a missing ":endwhile"/":endfor" detected here, the
* exception will be discarded. */ * exception will be discarded. */
if (did_throw && cstack->cs_exception[cstack->cs_idx] if (current_exception
!= current_exception) && cstack->cs_exception[cstack->cs_idx] != current_exception) {
internal_error("ex_finally()"); internal_error("ex_finally()");
} }
}
/* /*
* Set CSL_HAD_FINA, so do_cmdline() will reset did_emsg, * Set CSL_HAD_FINA, so do_cmdline() will reset did_emsg,
* got_int, and did_throw and make the finally clause active. * got_int, and current_exception and make the finally clause active.
* This will happen after emsg() has been called for a missing * This will happen after emsg() has been called for a missing
* ":endif" or a missing ":endwhile"/":endfor" detected here, so * ":endif" or a missing ":endwhile"/":endfor" detected here, so
* that the following finally clause will be executed even then. * that the following finally clause will be executed even then.
@@ -1593,7 +1570,7 @@ void ex_endtry(exarg_T *eap)
// made inactive by a ":continue", ":break", ":return", or ":finish" in // made inactive by a ":continue", ":break", ":return", or ":finish" in
// the finally clause. The latter case need not be tested since then // the finally clause. The latter case need not be tested since then
// anything pending has already been discarded. // anything pending has already been discarded.
skip = (did_emsg || got_int || did_throw skip = (did_emsg || got_int || current_exception
|| !(cstack->cs_flags[cstack->cs_idx] & CSF_TRUE)); || !(cstack->cs_flags[cstack->cs_idx] & CSF_TRUE));
if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY)) { if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY)) {
@@ -1610,12 +1587,13 @@ void ex_endtry(exarg_T *eap)
/* /*
* If an exception is being thrown, discard it to prevent it from * If an exception is being thrown, discard it to prevent it from
* being rethrown at the end of this function. It would be * being rethrown at the end of this function. It would be
* discarded by the error message, anyway. Resets did_throw. * discarded by the error message, anyway. Resets current_exception.
* This does not affect the script termination due to the error * This does not affect the script termination due to the error
* since "trylevel" is decremented after emsg() has been called. * since "trylevel" is decremented after emsg() has been called.
*/ */
if (did_throw) if (current_exception) {
discard_current_exception(); discard_current_exception();
}
} else { } else {
idx = cstack->cs_idx; idx = cstack->cs_idx;
@@ -1625,9 +1603,11 @@ void ex_endtry(exarg_T *eap)
* a finally clause, we need to rethrow it after closing the try * a finally clause, we need to rethrow it after closing the try
* conditional. * conditional.
*/ */
if (did_throw && (cstack->cs_flags[idx] & CSF_TRUE) if (current_exception
&& !(cstack->cs_flags[idx] & CSF_FINALLY)) && (cstack->cs_flags[idx] & CSF_TRUE)
rethrow = TRUE; && !(cstack->cs_flags[idx] & CSF_FINALLY)) {
rethrow = true;
}
} }
/* If there was no finally clause, show the user when debugging or /* If there was no finally clause, show the user when debugging or
@@ -1648,11 +1628,12 @@ void ex_endtry(exarg_T *eap)
if (got_int) { if (got_int) {
skip = TRUE; skip = TRUE;
(void)do_intthrow(cstack); (void)do_intthrow(cstack);
/* The do_intthrow() call may have reset did_throw or // The do_intthrow() call may have reset current_exception or
* cstack->cs_pending[idx].*/ // cstack->cs_pending[idx].
rethrow = FALSE; rethrow = false;
if (did_throw && !(cstack->cs_flags[idx] & CSF_FINALLY)) if (current_exception && !(cstack->cs_flags[idx] & CSF_FINALLY)) {
rethrow = TRUE; rethrow = true;
}
} }
} }
@@ -1714,28 +1695,32 @@ void ex_endtry(exarg_T *eap)
do_finish(eap, FALSE); do_finish(eap, FALSE);
break; break;
/* When the finally clause was entered due to an error, // When the finally clause was entered due to an error,
* interrupt or throw (as opposed to a ":continue", ":break", // interrupt or throw (as opposed to a ":continue", ":break",
* ":return", or ":finish"), restore the pending values of // ":return", or ":finish"), restore the pending values of
* did_emsg, got_int, and did_throw. This is skipped, if there // did_emsg, got_int, and current_exception. This is skipped, if there
* was a new error, interrupt, throw, ":continue", ":break", // was a new error, interrupt, throw, ":continue", ":break",
* ":return", or ":finish". in the finally clause. */ // ":return", or ":finish". in the finally clause.
default: default:
if (pending & CSTP_ERROR) if (pending & CSTP_ERROR) {
did_emsg = TRUE; did_emsg = true;
if (pending & CSTP_INTERRUPT) }
got_int = TRUE; if (pending & CSTP_INTERRUPT) {
if (pending & CSTP_THROW) got_int = true;
rethrow = TRUE; }
if (pending & CSTP_THROW) {
rethrow = true;
}
break; break;
} }
} }
if (rethrow) if (rethrow) {
/* Rethrow the current exception (within this cstack). */ // Rethrow the current exception (within this cstack).
do_throw(cstack); do_throw(cstack);
} }
} }
}
/* /*
* enter_cleanup() and leave_cleanup() * enter_cleanup() and leave_cleanup()
@@ -1763,33 +1748,33 @@ void enter_cleanup(cleanup_T *csp)
int pending = CSTP_NONE; int pending = CSTP_NONE;
/* /*
* Postpone did_emsg, got_int, did_throw. The pending values will be * Postpone did_emsg, got_int, current_exception. The pending values will be
* restored by leave_cleanup() except if there was an aborting error, * restored by leave_cleanup() except if there was an aborting error,
* interrupt, or uncaught exception after this function ends. * interrupt, or uncaught exception after this function ends.
*/ */
if (did_emsg || got_int || did_throw || need_rethrow) { if (did_emsg || got_int || current_exception || need_rethrow) {
csp->pending = (did_emsg ? CSTP_ERROR : 0) csp->pending = (did_emsg ? CSTP_ERROR : 0)
| (got_int ? CSTP_INTERRUPT : 0) | (got_int ? CSTP_INTERRUPT : 0)
| (did_throw ? CSTP_THROW : 0) | (current_exception ? CSTP_THROW : 0)
| (need_rethrow ? CSTP_THROW : 0); | (need_rethrow ? CSTP_THROW : 0);
/* If we are currently throwing an exception (did_throw), save it as /* If we are currently throwing an exception, save it as well. On an error
* well. On an error not yet converted to an exception, update * not yet converted to an exception, update "force_abort" and reset
* "force_abort" and reset "cause_abort" (as do_errthrow() would do). * "cause_abort" (as do_errthrow() would do). This is needed for the
* This is needed for the do_cmdline() call that is going to be made * do_cmdline() call that is going to be made for autocommand execution. We
* for autocommand execution. We need not save *msg_list because * need not save *msg_list because there is an extra instance for every call
* there is an extra instance for every call of do_cmdline(), anyway. * of do_cmdline(), anyway.
*/ */
if (did_throw || need_rethrow) if (current_exception || need_rethrow) {
csp->exception = current_exception; csp->exception = current_exception;
else { } else {
csp->exception = NULL; csp->exception = NULL;
if (did_emsg) { if (did_emsg) {
force_abort |= cause_abort; force_abort |= cause_abort;
cause_abort = FALSE; cause_abort = FALSE;
} }
} }
did_emsg = got_int = did_throw = need_rethrow = false; did_emsg = got_int = need_rethrow = false;
current_exception = NULL; current_exception = NULL;
/* Report if required by the 'verbose' option or when debugging. */ /* Report if required by the 'verbose' option or when debugging. */
@@ -1862,19 +1847,20 @@ void leave_cleanup(cleanup_T *csp)
force_abort = FALSE; force_abort = FALSE;
} }
/* // Restore the pending values of did_emsg, got_int, and current_exception.
* Restore the pending values of did_emsg, got_int, and did_throw. if (pending & CSTP_ERROR) {
*/ did_emsg = true;
if (pending & CSTP_ERROR) }
did_emsg = TRUE; if (pending & CSTP_INTERRUPT) {
if (pending & CSTP_INTERRUPT) got_int = true;
got_int = TRUE; }
if (pending & CSTP_THROW) if (pending & CSTP_THROW) {
need_rethrow = TRUE; /* did_throw will be set by do_one_cmd() */ need_rethrow = true; // current_exception will be set by do_one_cmd()
}
/* Report if required by the 'verbose' option or when debugging. */ // Report if required by the 'verbose' option or when debugging.
report_resume_pending(pending, report_resume_pending(
(pending & CSTP_THROW) ? (void *)current_exception : NULL); pending, ((pending & CSTP_THROW) ? (void *)current_exception : NULL));
} }
} }

9
src/nvim/globals.h
View File

@@ -317,17 +317,10 @@ EXTERN int do_profiling INIT(= PROF_NONE); /* PROF_ values */
/* /*
* The exception currently being thrown. Used to pass an exception to * The exception currently being thrown. Used to pass an exception to
* a different cstack. Also used for discarding an exception before it is * a different cstack. Also used for discarding an exception before it is
* caught or made pending. Only valid when did_throw is TRUE. * caught or made pending.
*/ */
EXTERN except_T *current_exception; EXTERN except_T *current_exception;
/*
* did_throw: An exception is being thrown. Reset when the exception is caught
* or as long as it is pending in a finally clause.
*/
// FIXME: Replace did_throw checks with current_exception checks.
EXTERN int did_throw INIT(= false);
/* /*
* need_rethrow: set to TRUE when a throw that cannot be handled in do_cmdline() * need_rethrow: set to TRUE when a throw that cannot be handled in do_cmdline()
* must be propagated to the cstack of the previously called do_cmdline(). * must be propagated to the cstack of the previously called do_cmdline().