diff options
Diffstat (limited to 'libs/liblua/src/ldo.c')
| -rw-r--r-- | libs/liblua/src/ldo.c | 350 |
1 files changed, 122 insertions, 228 deletions
diff --git a/libs/liblua/src/ldo.c b/libs/liblua/src/ldo.c index 7135079b12..4b55c31c2d 100644 --- a/libs/liblua/src/ldo.c +++ b/libs/liblua/src/ldo.c @@ -98,12 +98,11 @@ void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) { setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling")); break; } - case LUA_OK: { /* special case only for closing upvalues */ + case CLOSEPROTECT: { setnilvalue(s2v(oldtop)); /* no error message */ break; } default: { - lua_assert(errorstatus(errcode)); /* real error */ setobjs2s(L, oldtop, L->top - 1); /* error message on current top */ break; } @@ -119,13 +118,17 @@ l_noret luaD_throw (lua_State *L, int errcode) { } else { /* thread has no error handler */ global_State *g = G(L); - errcode = luaE_resetthread(L, errcode); /* close all upvalues */ + errcode = luaF_close(L, L->stack, errcode); /* close all upvalues */ + L->status = cast_byte(errcode); /* mark it as dead */ if (g->mainthread->errorJmp) { /* main thread has a handler? */ setobjs2s(L, g->mainthread->top++, L->top - 1); /* copy error obj. */ luaD_throw(g->mainthread, errcode); /* re-throw in main thread */ } else { /* no handler at all; abort */ if (g->panic) { /* panic function? */ + luaD_seterrorobj(L, errcode, L->top); /* assume EXTRA_STACK */ + if (L->ci->top < L->top) + L->ci->top = L->top; /* pushing msg. can break this invariant */ lua_unlock(L); g->panic(L); /* call panic function (last chance to jump out) */ } @@ -160,8 +163,9 @@ int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) { static void correctstack (lua_State *L, StkId oldstack, StkId newstack) { CallInfo *ci; UpVal *up; + if (oldstack == newstack) + return; /* stack address did not change */ L->top = (L->top - oldstack) + newstack; - L->tbclist = (L->tbclist - oldstack) + newstack; for (up = L->openupval; up != NULL; up = up->u.open.next) up->v = s2v((uplevel(up) - oldstack) + newstack); for (ci = L->ci; ci != NULL; ci = ci->previous) { @@ -177,35 +181,19 @@ static void correctstack (lua_State *L, StkId oldstack, StkId newstack) { #define ERRORSTACKSIZE (LUAI_MAXSTACK + 200) -/* -** Reallocate the stack to a new size, correcting all pointers into -** it. (There are pointers to a stack from its upvalues, from its list -** of call infos, plus a few individual pointers.) The reallocation is -** done in two steps (allocation + free) because the correction must be -** done while both addresses (the old stack and the new one) are valid. -** (In ISO C, any pointer use after the pointer has been deallocated is -** undefined behavior.) -** In case of allocation error, raise an error or return false according -** to 'raiseerror'. -*/ int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) { - int oldsize = stacksize(L); - int i; - StkId newstack = luaM_reallocvector(L, NULL, 0, - newsize + EXTRA_STACK, StackValue); + int lim = stacksize(L); + StkId newstack = luaM_reallocvector(L, L->stack, + lim + EXTRA_STACK, newsize + EXTRA_STACK, StackValue); lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE); - if (l_unlikely(newstack == NULL)) { /* reallocation failed? */ + if (unlikely(newstack == NULL)) { /* reallocation failed? */ if (raiseerror) luaM_error(L); else return 0; /* do not raise an error */ } - /* number of elements to be copied to the new stack */ - i = ((oldsize <= newsize) ? oldsize : newsize) + EXTRA_STACK; - memcpy(newstack, L->stack, i * sizeof(StackValue)); - for (; i < newsize + EXTRA_STACK; i++) - setnilvalue(s2v(newstack + i)); /* erase new segment */ + for (; lim < newsize; lim++) + setnilvalue(s2v(newstack + lim + EXTRA_STACK)); /* erase new segment */ correctstack(L, L->stack, newstack); - luaM_freearray(L, L->stack, oldsize + EXTRA_STACK); L->stack = newstack; L->stack_last = L->stack + newsize; return 1; @@ -218,7 +206,7 @@ int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) { */ int luaD_growstack (lua_State *L, int n, int raiseerror) { int size = stacksize(L); - if (l_unlikely(size > LUAI_MAXSTACK)) { + if (unlikely(size > LUAI_MAXSTACK)) { /* if stack is larger than maximum, thread is already using the extra space reserved for errors, that is, thread is handling a stack error; cannot grow further than that. */ @@ -234,7 +222,7 @@ int luaD_growstack (lua_State *L, int n, int raiseerror) { newsize = LUAI_MAXSTACK; if (newsize < needed) /* but must respect what was asked for */ newsize = needed; - if (l_likely(newsize <= LUAI_MAXSTACK)) + if (likely(newsize <= LUAI_MAXSTACK)) return luaD_reallocstack(L, newsize, raiseerror); else { /* stack overflow */ /* add extra size to be able to handle the error message */ @@ -309,8 +297,8 @@ void luaD_hook (lua_State *L, int event, int line, if (hook && L->allowhook) { /* make sure there is a hook */ int mask = CIST_HOOKED; CallInfo *ci = L->ci; - ptrdiff_t top = savestack(L, L->top); /* preserve original 'top' */ - ptrdiff_t ci_top = savestack(L, ci->top); /* idem for 'ci->top' */ + ptrdiff_t top = savestack(L, L->top); + ptrdiff_t ci_top = savestack(L, ci->top); lua_Debug ar; ar.event = event; ar.currentline = line; @@ -320,10 +308,8 @@ void luaD_hook (lua_State *L, int event, int line, ci->u2.transferinfo.ftransfer = ftransfer; ci->u2.transferinfo.ntransfer = ntransfer; } - if (isLua(ci) && L->top < ci->top) - L->top = ci->top; /* protect entire activation register */ luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */ - if (ci->top < L->top + LUA_MINSTACK) + if (L->top + LUA_MINSTACK > ci->top) ci->top = L->top + LUA_MINSTACK; L->allowhook = 0; /* cannot call hooks inside a hook */ ci->callstatus |= mask; @@ -345,40 +331,38 @@ void luaD_hook (lua_State *L, int event, int line, ** active. */ void luaD_hookcall (lua_State *L, CallInfo *ci) { - L->oldpc = 0; /* set 'oldpc' for new function */ - if (L->hookmask & LUA_MASKCALL) { /* is call hook on? */ - int event = (ci->callstatus & CIST_TAIL) ? LUA_HOOKTAILCALL - : LUA_HOOKCALL; + int hook = (ci->callstatus & CIST_TAIL) ? LUA_HOOKTAILCALL : LUA_HOOKCALL; + Proto *p; + if (!(L->hookmask & LUA_MASKCALL)) /* some other hook? */ + return; /* don't call hook */ + p = clLvalue(s2v(ci->func))->p; + L->top = ci->top; /* prepare top */ + ci->u.l.savedpc++; /* hooks assume 'pc' is already incremented */ + luaD_hook(L, hook, -1, 1, p->numparams); + ci->u.l.savedpc--; /* correct 'pc' */ +} + + +static StkId rethook (lua_State *L, CallInfo *ci, StkId firstres, int nres) { + ptrdiff_t oldtop = savestack(L, L->top); /* hook may change top */ + int delta = 0; + if (isLuacode(ci)) { Proto *p = ci_func(ci)->p; - ci->u.l.savedpc++; /* hooks assume 'pc' is already incremented */ - luaD_hook(L, event, -1, 1, p->numparams); - ci->u.l.savedpc--; /* correct 'pc' */ + if (p->is_vararg) + delta = ci->u.l.nextraargs + p->numparams + 1; + if (L->top < ci->top) + L->top = ci->top; /* correct top to run hook */ } -} - - -/* -** Executes a return hook for Lua and C functions and sets/corrects -** 'oldpc'. (Note that this correction is needed by the line hook, so it -** is done even when return hooks are off.) -*/ -static void rethook (lua_State *L, CallInfo *ci, int nres) { if (L->hookmask & LUA_MASKRET) { /* is return hook on? */ - StkId firstres = L->top - nres; /* index of first result */ - int delta = 0; /* correction for vararg functions */ int ftransfer; - if (isLua(ci)) { - Proto *p = ci_func(ci)->p; - if (p->is_vararg) - delta = ci->u.l.nextraargs + p->numparams + 1; - } ci->func += delta; /* if vararg, back to virtual 'func' */ ftransfer = cast(unsigned short, firstres - ci->func); luaD_hook(L, LUA_HOOKRET, -1, ftransfer, nres); /* call it */ ci->func -= delta; } if (isLua(ci = ci->previous)) - L->oldpc = pcRel(ci->u.l.savedpc, ci_func(ci)->p); /* set 'oldpc' */ + L->oldpc = pcRel(ci->u.l.savedpc, ci_func(ci)->p); /* update 'oldpc' */ + return restorestack(L, oldtop); } @@ -390,8 +374,8 @@ static void rethook (lua_State *L, CallInfo *ci, int nres) { void luaD_tryfuncTM (lua_State *L, StkId func) { const TValue *tm = luaT_gettmbyobj(L, s2v(func), TM_CALL); StkId p; - if (l_unlikely(ttisnil(tm))) - luaG_callerror(L, s2v(func)); /* nothing to call */ + if (unlikely(ttisnil(tm))) + luaG_typeerror(L, s2v(func), "call"); /* nothing to call */ for (p = L->top; p > func; p--) /* open space for metamethod */ setobjs2s(L, p, p-1); L->top++; /* stack space pre-allocated by the caller */ @@ -415,34 +399,27 @@ static void moveresults (lua_State *L, StkId res, int nres, int wanted) { case 1: /* one value needed */ if (nres == 0) /* no results? */ setnilvalue(s2v(res)); /* adjust with nil */ - else /* at least one result */ + else setobjs2s(L, res, L->top - nres); /* move it to proper place */ L->top = res + 1; return; case LUA_MULTRET: wanted = nres; /* we want all results */ break; - default: /* two/more results and/or to-be-closed variables */ + default: /* multiple results (or to-be-closed variables) */ if (hastocloseCfunc(wanted)) { /* to-be-closed variables? */ ptrdiff_t savedres = savestack(L, res); - L->ci->callstatus |= CIST_CLSRET; /* in case of yields */ - L->ci->u2.nres = nres; - luaF_close(L, res, CLOSEKTOP, 1); - L->ci->callstatus &= ~CIST_CLSRET; - if (L->hookmask) /* if needed, call hook after '__close's */ - rethook(L, L->ci, nres); - res = restorestack(L, savedres); /* close and hook can move stack */ - wanted = decodeNresults(wanted); + luaF_close(L, res, LUA_OK); /* may change the stack */ + res = restorestack(L, savedres); + wanted = codeNresults(wanted); /* correct value */ if (wanted == LUA_MULTRET) - wanted = nres; /* we want all results */ + wanted = nres; } break; } - /* generic case */ firstresult = L->top - nres; /* index of first result */ - if (nres > wanted) /* extra results? */ - nres = wanted; /* don't need them */ - for (i = 0; i < nres; i++) /* move all results to correct place */ + /* move all results to correct place */ + for (i = 0; i < nres && i < wanted; i++) setobjs2s(L, res + i, firstresult + i); for (; i < wanted; i++) /* complete wanted number of results */ setnilvalue(s2v(res + i)); @@ -451,21 +428,15 @@ static void moveresults (lua_State *L, StkId res, int nres, int wanted) { /* -** Finishes a function call: calls hook if necessary, moves current -** number of results to proper place, and returns to previous call -** info. If function has to close variables, hook must be called after -** that. +** Finishes a function call: calls hook if necessary, removes CallInfo, +** moves current number of results to proper place. */ void luaD_poscall (lua_State *L, CallInfo *ci, int nres) { - int wanted = ci->nresults; - if (l_unlikely(L->hookmask && !hastocloseCfunc(wanted))) - rethook(L, ci, nres); + if (L->hookmask) + L->top = rethook(L, ci, L->top - nres, nres); + L->ci = ci->previous; /* back to caller */ /* move results to proper place */ - moveresults(L, ci->func, nres, wanted); - /* function cannot be in any of these cases when returning */ - lua_assert(!(ci->callstatus & - (CIST_HOOKED | CIST_YPCALL | CIST_FIN | CIST_TRAN | CIST_CLSRET))); - L->ci = ci->previous; /* back to caller (after closing variables) */ + moveresults(L, ci->func, nres, ci->nresults); } @@ -524,7 +495,7 @@ CallInfo *luaD_precall (lua_State *L, StkId func, int nresults) { ci->top = L->top + LUA_MINSTACK; ci->func = func; lua_assert(ci->top <= L->stack_last); - if (l_unlikely(L->hookmask & LUA_MASKCALL)) { + if (L->hookmask & LUA_MASKCALL) { int narg = cast_int(L->top - func) - 1; luaD_hook(L, LUA_HOOKCALL, -1, 1, narg); } @@ -570,7 +541,7 @@ CallInfo *luaD_precall (lua_State *L, StkId func, int nresults) { static void ccall (lua_State *L, StkId func, int nResults, int inc) { CallInfo *ci; L->nCcalls += inc; - if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) + if (unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) luaE_checkcstack(L); if ((ci = luaD_precall(L, func, nResults)) != NULL) { /* Lua function? */ ci->callstatus = CIST_FRESH; /* mark that it is a "fresh" execute */ @@ -597,74 +568,27 @@ void luaD_callnoyield (lua_State *L, StkId func, int nResults) { /* -** Finish the job of 'lua_pcallk' after it was interrupted by an yield. -** (The caller, 'finishCcall', does the final call to 'adjustresults'.) -** The main job is to complete the 'luaD_pcall' called by 'lua_pcallk'. -** If a '__close' method yields here, eventually control will be back -** to 'finishCcall' (when that '__close' method finally returns) and -** 'finishpcallk' will run again and close any still pending '__close' -** methods. Similarly, if a '__close' method errs, 'precover' calls -** 'unroll' which calls ''finishCcall' and we are back here again, to -** close any pending '__close' methods. -** Note that, up to the call to 'luaF_close', the corresponding -** 'CallInfo' is not modified, so that this repeated run works like the -** first one (except that it has at least one less '__close' to do). In -** particular, field CIST_RECST preserves the error status across these -** multiple runs, changing only if there is a new error. -*/ -static int finishpcallk (lua_State *L, CallInfo *ci) { - int status = getcistrecst(ci); /* get original status */ - if (l_likely(status == LUA_OK)) /* no error? */ - status = LUA_YIELD; /* was interrupted by an yield */ - else { /* error */ - StkId func = restorestack(L, ci->u2.funcidx); - L->allowhook = getoah(ci->callstatus); /* restore 'allowhook' */ - luaF_close(L, func, status, 1); /* can yield or raise an error */ - func = restorestack(L, ci->u2.funcidx); /* stack may be moved */ - luaD_seterrorobj(L, status, func); - luaD_shrinkstack(L); /* restore stack size in case of overflow */ - setcistrecst(ci, LUA_OK); /* clear original status */ - } - ci->callstatus &= ~CIST_YPCALL; - L->errfunc = ci->u.c.old_errfunc; - /* if it is here, there were errors or yields; unlike 'lua_pcallk', - do not change status */ - return status; -} - - -/* -** Completes the execution of a C function interrupted by an yield. -** The interruption must have happened while the function was either -** closing its tbc variables in 'moveresults' or executing -** 'lua_callk'/'lua_pcallk'. In the first case, it just redoes -** 'luaD_poscall'. In the second case, the call to 'finishpcallk' -** finishes the interrupted execution of 'lua_pcallk'. After that, it -** calls the continuation of the interrupted function and finally it -** completes the job of the 'luaD_call' that called the function. In -** the call to 'adjustresults', we do not know the number of results -** of the function called by 'lua_callk'/'lua_pcallk', so we are -** conservative and use LUA_MULTRET (always adjust). +** Completes the execution of an interrupted C function, calling its +** continuation function. */ -static void finishCcall (lua_State *L, CallInfo *ci) { - int n; /* actual number of results from C function */ - if (ci->callstatus & CIST_CLSRET) { /* was returning? */ - lua_assert(hastocloseCfunc(ci->nresults)); - n = ci->u2.nres; /* just redo 'luaD_poscall' */ - /* don't need to reset CIST_CLSRET, as it will be set again anyway */ - } - else { - int status = LUA_YIELD; /* default if there were no errors */ - /* must have a continuation and must be able to call it */ - lua_assert(ci->u.c.k != NULL && yieldable(L)); - if (ci->callstatus & CIST_YPCALL) /* was inside a 'lua_pcallk'? */ - status = finishpcallk(L, ci); /* finish it */ - adjustresults(L, LUA_MULTRET); /* finish 'lua_callk' */ - lua_unlock(L); - n = (*ci->u.c.k)(L, status, ci->u.c.ctx); /* call continuation */ - lua_lock(L); - api_checknelems(L, n); - } +static void finishCcall (lua_State *L, int status) { + CallInfo *ci = L->ci; + int n; + /* must have a continuation and must be able to call it */ + lua_assert(ci->u.c.k != NULL && yieldable(L)); + /* error status can only happen in a protected call */ + lua_assert((ci->callstatus & CIST_YPCALL) || status == LUA_YIELD); + if (ci->callstatus & CIST_YPCALL) { /* was inside a pcall? */ + ci->callstatus &= ~CIST_YPCALL; /* continuation is also inside it */ + L->errfunc = ci->u.c.old_errfunc; /* with the same error function */ + } + /* finish 'lua_callk'/'lua_pcall'; CIST_YPCALL and 'errfunc' already + handled */ + adjustresults(L, ci->nresults); + lua_unlock(L); + n = (*ci->u.c.k)(L, status, ci->u.c.ctx); /* call continuation function */ + lua_lock(L); + api_checknelems(L, n); luaD_poscall(L, ci, n); /* finish 'luaD_call' */ } @@ -672,14 +596,18 @@ static void finishCcall (lua_State *L, CallInfo *ci) { /* ** Executes "full continuation" (everything in the stack) of a ** previously interrupted coroutine until the stack is empty (or another -** interruption long-jumps out of the loop). +** interruption long-jumps out of the loop). If the coroutine is +** recovering from an error, 'ud' points to the error status, which must +** be passed to the first continuation function (otherwise the default +** status is LUA_YIELD). */ static void unroll (lua_State *L, void *ud) { CallInfo *ci; - UNUSED(ud); + if (ud != NULL) /* error status? */ + finishCcall(L, *(int *)ud); /* finish 'lua_pcallk' callee */ while ((ci = L->ci) != &L->base_ci) { /* something in the stack */ if (!isLua(ci)) /* C function? */ - finishCcall(L, ci); /* complete its execution */ + finishCcall(L, LUA_YIELD); /* complete its execution */ else { /* Lua function */ luaV_finishOp(L); /* finish interrupted instruction */ luaV_execute(L, ci); /* execute down to higher C 'boundary' */ @@ -703,6 +631,28 @@ static CallInfo *findpcall (lua_State *L) { /* +** Recovers from an error in a coroutine. Finds a recover point (if +** there is one) and completes the execution of the interrupted +** 'luaD_pcall'. If there is no recover point, returns zero. +*/ +static int recover (lua_State *L, int status) { + StkId oldtop; + CallInfo *ci = findpcall(L); + if (ci == NULL) return 0; /* no recovery point */ + /* "finish" luaD_pcall */ + oldtop = restorestack(L, ci->u2.funcidx); + L->ci = ci; + L->allowhook = getoah(ci->callstatus); /* restore original 'allowhook' */ + status = luaF_close(L, oldtop, status); /* may change the stack */ + oldtop = restorestack(L, ci->u2.funcidx); + luaD_seterrorobj(L, status, oldtop); + luaD_shrinkstack(L); /* restore stack size in case of overflow */ + L->errfunc = ci->u.c.old_errfunc; + return 1; /* continue running the coroutine */ +} + + +/* ** Signal an error in the call to 'lua_resume', not in the execution ** of the coroutine itself. (Such errors should not be handled by any ** coroutine error handler and should not kill the coroutine.) @@ -733,10 +683,8 @@ static void resume (lua_State *L, void *ud) { lua_assert(L->status == LUA_YIELD); L->status = LUA_OK; /* mark that it is running (again) */ luaE_incCstack(L); /* control the C stack */ - if (isLua(ci)) { /* yielded inside a hook? */ - L->top = firstArg; /* discard arguments */ + if (isLua(ci)) /* yielded inside a hook? */ luaV_execute(L, ci); /* just continue running Lua code */ - } else { /* 'common' yield */ if (ci->u.c.k != NULL) { /* does it have a continuation function? */ lua_unlock(L); @@ -750,26 +698,6 @@ static void resume (lua_State *L, void *ud) { } } - -/* -** Unrolls a coroutine in protected mode while there are recoverable -** errors, that is, errors inside a protected call. (Any error -** interrupts 'unroll', and this loop protects it again so it can -** continue.) Stops with a normal end (status == LUA_OK), an yield -** (status == LUA_YIELD), or an unprotected error ('findpcall' doesn't -** find a recover point). -*/ -static int precover (lua_State *L, int status) { - CallInfo *ci; - while (errorstatus(status) && (ci = findpcall(L)) != NULL) { - L->ci = ci; /* go down to recovery functions */ - setcistrecst(ci, status); /* status to finish 'pcall' */ - status = luaD_rawrunprotected(L, unroll, NULL); - } - return status; -} - - LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs, int *nresults) { int status; @@ -787,8 +715,11 @@ LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs, api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs); status = luaD_rawrunprotected(L, resume, &nargs); /* continue running after recoverable errors */ - status = precover(L, status); - if (l_likely(!errorstatus(status))) + while (errorstatus(status) && recover(L, status)) { + /* unroll continuation */ + status = luaD_rawrunprotected(L, unroll, &status); + } + if (likely(!errorstatus(status))) lua_assert(status == L->status); /* normal end or yield */ else { /* unrecoverable error */ L->status = cast_byte(status); /* mark thread as 'dead' */ @@ -814,22 +745,22 @@ LUA_API int lua_yieldk (lua_State *L, int nresults, lua_KContext ctx, lua_lock(L); ci = L->ci; api_checknelems(L, nresults); - if (l_unlikely(!yieldable(L))) { + if (unlikely(!yieldable(L))) { if (L != G(L)->mainthread) luaG_runerror(L, "attempt to yield across a C-call boundary"); else luaG_runerror(L, "attempt to yield from outside a coroutine"); } L->status = LUA_YIELD; - ci->u2.nyield = nresults; /* save number of results */ if (isLua(ci)) { /* inside a hook? */ lua_assert(!isLuacode(ci)); - api_check(L, nresults == 0, "hooks cannot yield values"); api_check(L, k == NULL, "hooks cannot continue after yielding"); + ci->u2.nyield = 0; /* no results */ } else { if ((ci->u.c.k = k) != NULL) /* is there a continuation? */ ci->u.c.ctx = ctx; /* save context */ + ci->u2.nyield = nresults; /* save number of results */ luaD_throw(L, LUA_YIELD); } lua_assert(ci->callstatus & CIST_HOOKED); /* must be inside a hook */ @@ -839,45 +770,6 @@ LUA_API int lua_yieldk (lua_State *L, int nresults, lua_KContext ctx, /* -** Auxiliary structure to call 'luaF_close' in protected mode. -*/ -struct CloseP { - StkId level; - int status; -}; - - -/* -** Auxiliary function to call 'luaF_close' in protected mode. -*/ -static void closepaux (lua_State *L, void *ud) { - struct CloseP *pcl = cast(struct CloseP *, ud); - luaF_close(L, pcl->level, pcl->status, 0); -} - - -/* -** Calls 'luaF_close' in protected mode. Return the original status -** or, in case of errors, the new status. -*/ -int luaD_closeprotected (lua_State *L, ptrdiff_t level, int status) { - CallInfo *old_ci = L->ci; - lu_byte old_allowhooks = L->allowhook; - for (;;) { /* keep closing upvalues until no more errors */ - struct CloseP pcl; - pcl.level = restorestack(L, level); pcl.status = status; - status = luaD_rawrunprotected(L, &closepaux, &pcl); - if (l_likely(status == LUA_OK)) /* no more errors? */ - return pcl.status; - else { /* an error occurred; restore saved state and repeat */ - L->ci = old_ci; - L->allowhook = old_allowhooks; - } - } -} - - -/* ** Call the C function 'func' in protected mode, restoring basic ** thread information ('allowhook', etc.) and in particular ** its stack level in case of errors. @@ -890,11 +782,13 @@ int luaD_pcall (lua_State *L, Pfunc func, void *u, ptrdiff_t old_errfunc = L->errfunc; L->errfunc = ef; status = luaD_rawrunprotected(L, func, u); - if (l_unlikely(status != LUA_OK)) { /* an error occurred? */ + if (unlikely(status != LUA_OK)) { /* an error occurred? */ + StkId oldtop = restorestack(L, old_top); L->ci = old_ci; L->allowhook = old_allowhooks; - status = luaD_closeprotected(L, old_top, status); - luaD_seterrorobj(L, status, restorestack(L, old_top)); + status = luaF_close(L, oldtop, status); + oldtop = restorestack(L, old_top); /* previous call may change stack */ + luaD_seterrorobj(L, status, oldtop); luaD_shrinkstack(L); /* restore stack size in case of overflow */ } L->errfunc = old_errfunc; |