mirror of
https://github.com/lua/lua
synced 2024-11-26 14:51:21 +03:00
389116d8ab
Back to how it was, a coroutine does not unwind its stack in case of errors (and therefore do not close its to-be-closed variables). This allows the stack to be examined after the error. The program can use 'coroutine.kill' to close the variables. The function created by 'coroutine.wrap', however, closes the coroutine's variables in case of errors, as it is impossible to examine the stack any way.
821 lines
26 KiB
C
821 lines
26 KiB
C
/*
|
|
** $Id: ldo.c $
|
|
** Stack and Call structure of Lua
|
|
** See Copyright Notice in lua.h
|
|
*/
|
|
|
|
#define ldo_c
|
|
#define LUA_CORE
|
|
|
|
#include "lprefix.h"
|
|
|
|
|
|
#include <setjmp.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "lua.h"
|
|
|
|
#include "lapi.h"
|
|
#include "ldebug.h"
|
|
#include "ldo.h"
|
|
#include "lfunc.h"
|
|
#include "lgc.h"
|
|
#include "lmem.h"
|
|
#include "lobject.h"
|
|
#include "lopcodes.h"
|
|
#include "lparser.h"
|
|
#include "lstate.h"
|
|
#include "lstring.h"
|
|
#include "ltable.h"
|
|
#include "ltm.h"
|
|
#include "lundump.h"
|
|
#include "lvm.h"
|
|
#include "lzio.h"
|
|
|
|
|
|
|
|
#define errorstatus(s) ((s) > LUA_YIELD)
|
|
|
|
|
|
/*
|
|
** {======================================================
|
|
** Error-recovery functions
|
|
** =======================================================
|
|
*/
|
|
|
|
/*
|
|
** LUAI_THROW/LUAI_TRY define how Lua does exception handling. By
|
|
** default, Lua handles errors with exceptions when compiling as
|
|
** C++ code, with _longjmp/_setjmp when asked to use them, and with
|
|
** longjmp/setjmp otherwise.
|
|
*/
|
|
#if !defined(LUAI_THROW) /* { */
|
|
|
|
#if defined(__cplusplus) && !defined(LUA_USE_LONGJMP) /* { */
|
|
|
|
/* C++ exceptions */
|
|
#define LUAI_THROW(L,c) throw(c)
|
|
#define LUAI_TRY(L,c,a) \
|
|
try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; }
|
|
#define luai_jmpbuf int /* dummy variable */
|
|
|
|
#elif defined(LUA_USE_POSIX) /* }{ */
|
|
|
|
/* in POSIX, try _longjmp/_setjmp (more efficient) */
|
|
#define LUAI_THROW(L,c) _longjmp((c)->b, 1)
|
|
#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a }
|
|
#define luai_jmpbuf jmp_buf
|
|
|
|
#else /* }{ */
|
|
|
|
/* ISO C handling with long jumps */
|
|
#define LUAI_THROW(L,c) longjmp((c)->b, 1)
|
|
#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a }
|
|
#define luai_jmpbuf jmp_buf
|
|
|
|
#endif /* } */
|
|
|
|
#endif /* } */
|
|
|
|
|
|
|
|
/* chain list of long jump buffers */
|
|
struct lua_longjmp {
|
|
struct lua_longjmp *previous;
|
|
luai_jmpbuf b;
|
|
volatile int status; /* error code */
|
|
};
|
|
|
|
|
|
void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) {
|
|
switch (errcode) {
|
|
case LUA_ERRMEM: { /* memory error? */
|
|
setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */
|
|
break;
|
|
}
|
|
case LUA_ERRERR: {
|
|
setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
|
|
break;
|
|
}
|
|
case CLOSEPROTECT: {
|
|
setnilvalue(s2v(oldtop)); /* no error message */
|
|
break;
|
|
}
|
|
default: {
|
|
setobjs2s(L, oldtop, L->top - 1); /* error message on current top */
|
|
break;
|
|
}
|
|
}
|
|
L->top = oldtop + 1;
|
|
}
|
|
|
|
|
|
l_noret luaD_throw (lua_State *L, int errcode) {
|
|
if (L->errorJmp) { /* thread has an error handler? */
|
|
L->errorJmp->status = errcode; /* set status */
|
|
LUAI_THROW(L, L->errorJmp); /* jump to it */
|
|
}
|
|
else { /* thread has no error handler */
|
|
global_State *g = G(L);
|
|
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) */
|
|
}
|
|
abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
|
|
l_uint32 oldnCcalls = L->nCcalls - L->nci;
|
|
struct lua_longjmp lj;
|
|
lua_assert(L->nCcalls >= L->nci);
|
|
lj.status = LUA_OK;
|
|
lj.previous = L->errorJmp; /* chain new error handler */
|
|
L->errorJmp = &lj;
|
|
LUAI_TRY(L, &lj,
|
|
(*f)(L, ud);
|
|
);
|
|
L->errorJmp = lj.previous; /* restore old error handler */
|
|
L->nCcalls = oldnCcalls + L->nci;
|
|
return lj.status;
|
|
}
|
|
|
|
/* }====================================================== */
|
|
|
|
|
|
/*
|
|
** {==================================================================
|
|
** Stack reallocation
|
|
** ===================================================================
|
|
*/
|
|
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;
|
|
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) {
|
|
ci->top = (ci->top - oldstack) + newstack;
|
|
ci->func = (ci->func - oldstack) + newstack;
|
|
if (isLua(ci))
|
|
ci->u.l.trap = 1; /* signal to update 'trap' in 'luaV_execute' */
|
|
}
|
|
}
|
|
|
|
|
|
/* some space for error handling */
|
|
#define ERRORSTACKSIZE (LUAI_MAXSTACK + 200)
|
|
|
|
|
|
int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) {
|
|
int lim = L->stacksize;
|
|
StkId newstack = luaM_reallocvector(L, L->stack, lim, newsize, StackValue);
|
|
lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE);
|
|
lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK);
|
|
if (unlikely(newstack == NULL)) { /* reallocation failed? */
|
|
if (raiseerror)
|
|
luaM_error(L);
|
|
else return 0; /* do not raise an error */
|
|
}
|
|
for (; lim < newsize; lim++)
|
|
setnilvalue(s2v(newstack + lim)); /* erase new segment */
|
|
correctstack(L, L->stack, newstack);
|
|
L->stack = newstack;
|
|
L->stacksize = newsize;
|
|
L->stack_last = L->stack + newsize - EXTRA_STACK;
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*
|
|
** Try to grow the stack by at least 'n' elements. when 'raiseerror'
|
|
** is true, raises any error; otherwise, return 0 in case of errors.
|
|
*/
|
|
int luaD_growstack (lua_State *L, int n, int raiseerror) {
|
|
int size = L->stacksize;
|
|
int newsize = 2 * size; /* tentative new size */
|
|
if (unlikely(size > LUAI_MAXSTACK)) { /* need more space after extra size? */
|
|
if (raiseerror)
|
|
luaD_throw(L, LUA_ERRERR); /* error inside message handler */
|
|
else return 0;
|
|
}
|
|
else {
|
|
int needed = cast_int(L->top - L->stack) + n + EXTRA_STACK;
|
|
if (newsize > LUAI_MAXSTACK) /* cannot cross the limit */
|
|
newsize = LUAI_MAXSTACK;
|
|
if (newsize < needed) /* but must respect what was asked for */
|
|
newsize = needed;
|
|
if (unlikely(newsize > LUAI_MAXSTACK)) { /* stack overflow? */
|
|
/* add extra size to be able to handle the error message */
|
|
luaD_reallocstack(L, ERRORSTACKSIZE, raiseerror);
|
|
if (raiseerror)
|
|
luaG_runerror(L, "stack overflow");
|
|
else return 0;
|
|
}
|
|
} /* else no errors */
|
|
return luaD_reallocstack(L, newsize, raiseerror);
|
|
}
|
|
|
|
|
|
static int stackinuse (lua_State *L) {
|
|
CallInfo *ci;
|
|
StkId lim = L->top;
|
|
for (ci = L->ci; ci != NULL; ci = ci->previous) {
|
|
if (lim < ci->top) lim = ci->top;
|
|
}
|
|
lua_assert(lim <= L->stack_last);
|
|
return cast_int(lim - L->stack) + 1; /* part of stack in use */
|
|
}
|
|
|
|
|
|
void luaD_shrinkstack (lua_State *L) {
|
|
int inuse = stackinuse(L);
|
|
int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;
|
|
if (goodsize > LUAI_MAXSTACK)
|
|
goodsize = LUAI_MAXSTACK; /* respect stack limit */
|
|
/* if thread is currently not handling a stack overflow and its
|
|
good size is smaller than current size, shrink its stack */
|
|
if (inuse <= (LUAI_MAXSTACK - EXTRA_STACK) &&
|
|
goodsize < L->stacksize)
|
|
luaD_reallocstack(L, goodsize, 0); /* ok if that fails */
|
|
else /* don't change stack */
|
|
condmovestack(L,{},{}); /* (change only for debugging) */
|
|
luaE_shrinkCI(L); /* shrink CI list */
|
|
}
|
|
|
|
|
|
void luaD_inctop (lua_State *L) {
|
|
luaD_checkstack(L, 1);
|
|
L->top++;
|
|
}
|
|
|
|
/* }================================================================== */
|
|
|
|
|
|
/*
|
|
** Call a hook for the given event. Make sure there is a hook to be
|
|
** called. (Both 'L->hook' and 'L->hookmask', which trigger this
|
|
** function, can be changed asynchronously by signals.)
|
|
*/
|
|
void luaD_hook (lua_State *L, int event, int line,
|
|
int ftransfer, int ntransfer) {
|
|
lua_Hook hook = L->hook;
|
|
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);
|
|
ptrdiff_t ci_top = savestack(L, ci->top);
|
|
lua_Debug ar;
|
|
ar.event = event;
|
|
ar.currentline = line;
|
|
ar.i_ci = ci;
|
|
if (ntransfer != 0) {
|
|
mask |= CIST_TRAN; /* 'ci' has transfer information */
|
|
ci->u2.transferinfo.ftransfer = ftransfer;
|
|
ci->u2.transferinfo.ntransfer = ntransfer;
|
|
}
|
|
luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
|
|
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;
|
|
lua_unlock(L);
|
|
(*hook)(L, &ar);
|
|
lua_lock(L);
|
|
lua_assert(!L->allowhook);
|
|
L->allowhook = 1;
|
|
ci->top = restorestack(L, ci_top);
|
|
L->top = restorestack(L, top);
|
|
ci->callstatus &= ~mask;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Executes a call hook for Lua functions. This function is called
|
|
** whenever 'hookmask' is not zero, so it checks whether call hooks are
|
|
** active.
|
|
*/
|
|
void luaD_hookcall (lua_State *L, CallInfo *ci) {
|
|
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 = clLvalue(s2v(ci->func))->p;
|
|
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 */
|
|
}
|
|
if (L->hookmask & LUA_MASKRET) { /* is return hook on? */
|
|
int ftransfer;
|
|
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->previous))
|
|
L->oldpc = ci->previous->u.l.savedpc; /* update 'oldpc' */
|
|
return restorestack(L, oldtop);
|
|
}
|
|
|
|
|
|
/*
|
|
** Check whether __call metafield of 'func' is a function. If so, put
|
|
** it in stack below original 'func' so that 'luaD_call' can call
|
|
** it. Raise an error if __call metafield is not a function.
|
|
*/
|
|
void luaD_tryfuncTM (lua_State *L, StkId func) {
|
|
const TValue *tm = luaT_gettmbyobj(L, s2v(func), TM_CALL);
|
|
StkId p;
|
|
if (unlikely(!ttisfunction(tm)))
|
|
luaG_typeerror(L, s2v(func), "call");
|
|
for (p = L->top; p > func; p--)
|
|
setobjs2s(L, p, p-1);
|
|
L->top++; /* assume EXTRA_STACK */
|
|
setobj2s(L, func, tm); /* metamethod is the new function to be called */
|
|
}
|
|
|
|
|
|
/*
|
|
** Given 'nres' results at 'firstResult', move 'wanted' of them to 'res'.
|
|
** Handle most typical cases (zero results for commands, one result for
|
|
** expressions, multiple results for tail calls/single parameters)
|
|
** separated.
|
|
*/
|
|
static void moveresults (lua_State *L, StkId res, int nres, int wanted) {
|
|
StkId firstresult;
|
|
int i;
|
|
switch (wanted) { /* handle typical cases separately */
|
|
case 0: /* no values needed */
|
|
L->top = res;
|
|
return;
|
|
case 1: /* one value needed */
|
|
if (nres == 0) /* no results? */
|
|
setnilvalue(s2v(res)); /* adjust with nil */
|
|
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: /* multiple results (or to-be-closed variables) */
|
|
if (hastocloseCfunc(wanted)) { /* to-be-closed variables? */
|
|
ptrdiff_t savedres = savestack(L, res);
|
|
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;
|
|
}
|
|
break;
|
|
}
|
|
firstresult = L->top - nres; /* index of first result */
|
|
/* 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));
|
|
L->top = res + wanted; /* top points after the last result */
|
|
}
|
|
|
|
|
|
/*
|
|
** 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) {
|
|
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, ci->nresults);
|
|
}
|
|
|
|
|
|
|
|
#define next_ci(L) (L->ci = (L->ci->next ? L->ci->next : luaE_extendCI(L)))
|
|
|
|
|
|
/*
|
|
** Prepare a function for a tail call, building its call info on top
|
|
** of the current call info. 'narg1' is the number of arguments plus 1
|
|
** (so that it includes the function itself).
|
|
*/
|
|
void luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func, int narg1) {
|
|
Proto *p = clLvalue(s2v(func))->p;
|
|
int fsize = p->maxstacksize; /* frame size */
|
|
int nfixparams = p->numparams;
|
|
int i;
|
|
for (i = 0; i < narg1; i++) /* move down function and arguments */
|
|
setobjs2s(L, ci->func + i, func + i);
|
|
checkstackGC(L, fsize);
|
|
func = ci->func; /* moved-down function */
|
|
for (; narg1 <= nfixparams; narg1++)
|
|
setnilvalue(s2v(func + narg1)); /* complete missing arguments */
|
|
ci->top = func + 1 + fsize; /* top for new function */
|
|
lua_assert(ci->top <= L->stack_last);
|
|
ci->u.l.savedpc = p->code; /* starting point */
|
|
ci->callstatus |= CIST_TAIL;
|
|
L->top = func + narg1; /* set top */
|
|
}
|
|
|
|
|
|
/*
|
|
** Call a function (C or Lua). The function to be called is at *func.
|
|
** The arguments are on the stack, right after the function.
|
|
** When returns, all the results are on the stack, starting at the original
|
|
** function position.
|
|
*/
|
|
void luaD_call (lua_State *L, StkId func, int nresults) {
|
|
lua_CFunction f;
|
|
TValue *funcv = s2v(func);
|
|
switch (ttypetag(funcv)) {
|
|
case LUA_TCCL: /* C closure */
|
|
f = clCvalue(funcv)->f;
|
|
goto Cfunc;
|
|
case LUA_TLCF: /* light C function */
|
|
f = fvalue(funcv);
|
|
Cfunc: {
|
|
int n; /* number of returns */
|
|
CallInfo *ci;
|
|
checkstackp(L, LUA_MINSTACK, func); /* ensure minimum stack size */
|
|
ci = next_ci(L);
|
|
ci->nresults = nresults;
|
|
ci->callstatus = CIST_C;
|
|
ci->top = L->top + LUA_MINSTACK;
|
|
ci->func = func;
|
|
lua_assert(ci->top <= L->stack_last);
|
|
if (L->hookmask & LUA_MASKCALL) {
|
|
int narg = cast_int(L->top - func) - 1;
|
|
luaD_hook(L, LUA_HOOKCALL, -1, 1, narg);
|
|
}
|
|
lua_unlock(L);
|
|
n = (*f)(L); /* do the actual call */
|
|
lua_lock(L);
|
|
api_checknelems(L, n);
|
|
luaD_poscall(L, ci, n);
|
|
break;
|
|
}
|
|
case LUA_TLCL: { /* Lua function */
|
|
CallInfo *ci;
|
|
Proto *p = clLvalue(funcv)->p;
|
|
int narg = cast_int(L->top - func) - 1; /* number of real arguments */
|
|
int nfixparams = p->numparams;
|
|
int fsize = p->maxstacksize; /* frame size */
|
|
checkstackp(L, fsize, func);
|
|
ci = next_ci(L);
|
|
ci->nresults = nresults;
|
|
ci->u.l.savedpc = p->code; /* starting point */
|
|
ci->callstatus = 0;
|
|
ci->top = func + 1 + fsize;
|
|
ci->func = func;
|
|
for (; narg < nfixparams; narg++)
|
|
setnilvalue(s2v(L->top++)); /* complete missing arguments */
|
|
lua_assert(ci->top <= L->stack_last);
|
|
luaV_execute(L, ci); /* run the function */
|
|
break;
|
|
}
|
|
default: { /* not a function */
|
|
luaD_tryfuncTM(L, func); /* try to get '__call' metamethod */
|
|
luaD_call(L, func, nresults); /* now it must be a function */
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Similar to 'luaD_call', but does not allow yields during the call.
|
|
** If there is a stack overflow, freeing all CI structures will
|
|
** force the subsequent call to invoke 'luaE_extendCI', which then
|
|
** will raise any errors.
|
|
*/
|
|
void luaD_callnoyield (lua_State *L, StkId func, int nResults) {
|
|
incXCcalls(L);
|
|
if (getCcalls(L) >= LUAI_MAXCSTACK) /* possible stack overflow? */
|
|
luaE_freeCI(L);
|
|
luaD_call(L, func, nResults);
|
|
decXCcalls(L);
|
|
}
|
|
|
|
|
|
/*
|
|
** Completes the execution of an interrupted C function, calling its
|
|
** continuation function.
|
|
*/
|
|
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' */
|
|
}
|
|
|
|
|
|
/*
|
|
** 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). 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;
|
|
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, LUA_YIELD); /* complete its execution */
|
|
else { /* Lua function */
|
|
luaV_finishOp(L); /* finish interrupted instruction */
|
|
luaV_execute(L, ci); /* execute down to higher C 'boundary' */
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Try to find a suspended protected call (a "recover point") for the
|
|
** given thread.
|
|
*/
|
|
static CallInfo *findpcall (lua_State *L) {
|
|
CallInfo *ci;
|
|
for (ci = L->ci; ci != NULL; ci = ci->previous) { /* search for a pcall */
|
|
if (ci->callstatus & CIST_YPCALL)
|
|
return ci;
|
|
}
|
|
return NULL; /* no pending pcall */
|
|
}
|
|
|
|
|
|
/*
|
|
** 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);
|
|
luaF_close(L, oldtop, status); /* may change the stack */
|
|
oldtop = restorestack(L, ci->u2.funcidx);
|
|
luaD_seterrorobj(L, status, oldtop);
|
|
L->ci = ci;
|
|
L->allowhook = getoah(ci->callstatus); /* restore original 'allowhook' */
|
|
luaD_shrinkstack(L);
|
|
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.)
|
|
*/
|
|
static int resume_error (lua_State *L, const char *msg, int narg) {
|
|
L->top -= narg; /* remove args from the stack */
|
|
setsvalue2s(L, L->top, luaS_new(L, msg)); /* push error message */
|
|
api_incr_top(L);
|
|
lua_unlock(L);
|
|
return LUA_ERRRUN;
|
|
}
|
|
|
|
|
|
/*
|
|
** Do the work for 'lua_resume' in protected mode. Most of the work
|
|
** depends on the status of the coroutine: initial state, suspended
|
|
** inside a hook, or regularly suspended (optionally with a continuation
|
|
** function), plus erroneous cases: non-suspended coroutine or dead
|
|
** coroutine.
|
|
*/
|
|
static void resume (lua_State *L, void *ud) {
|
|
int n = *(cast(int*, ud)); /* number of arguments */
|
|
StkId firstArg = L->top - n; /* first argument */
|
|
CallInfo *ci = L->ci;
|
|
if (L->status == LUA_OK) { /* starting a coroutine? */
|
|
luaD_call(L, firstArg - 1, LUA_MULTRET);
|
|
}
|
|
else { /* resuming from previous yield */
|
|
lua_assert(L->status == LUA_YIELD);
|
|
L->status = LUA_OK; /* mark that it is running (again) */
|
|
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);
|
|
n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */
|
|
lua_lock(L);
|
|
api_checknelems(L, n);
|
|
}
|
|
luaD_poscall(L, ci, n); /* finish 'luaD_call' */
|
|
}
|
|
unroll(L, NULL); /* run continuation */
|
|
}
|
|
}
|
|
|
|
LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs,
|
|
int *nresults) {
|
|
int status;
|
|
lua_lock(L);
|
|
if (L->status == LUA_OK) { /* may be starting a coroutine */
|
|
if (L->ci != &L->base_ci) /* not in base level? */
|
|
return resume_error(L, "cannot resume non-suspended coroutine", nargs);
|
|
}
|
|
else if (L->status != LUA_YIELD)
|
|
return resume_error(L, "cannot resume dead coroutine", nargs);
|
|
if (from == NULL)
|
|
L->nCcalls = 1;
|
|
else /* correct 'nCcalls' for this thread */
|
|
L->nCcalls = getCcalls(from) - from->nci + L->nci + CSTACKCF;
|
|
if (L->nCcalls >= LUAI_MAXCSTACK)
|
|
return resume_error(L, "C stack overflow", nargs);
|
|
luai_userstateresume(L, nargs);
|
|
api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs);
|
|
status = luaD_rawrunprotected(L, resume, &nargs);
|
|
/* continue running after recoverable errors */
|
|
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' */
|
|
luaD_seterrorobj(L, status, L->top); /* push error message */
|
|
L->ci->top = L->top;
|
|
}
|
|
*nresults = (status == LUA_YIELD) ? L->ci->u2.nyield
|
|
: cast_int(L->top - (L->ci->func + 1));
|
|
lua_unlock(L);
|
|
return status;
|
|
}
|
|
|
|
|
|
LUA_API int lua_isyieldable (lua_State *L) {
|
|
return yieldable(L);
|
|
}
|
|
|
|
|
|
LUA_API int lua_yieldk (lua_State *L, int nresults, lua_KContext ctx,
|
|
lua_KFunction k) {
|
|
CallInfo *ci = L->ci;
|
|
luai_userstateyield(L, nresults);
|
|
lua_lock(L);
|
|
api_checknelems(L, nresults);
|
|
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;
|
|
if (isLua(ci)) { /* inside a hook? */
|
|
lua_assert(!isLuacode(ci));
|
|
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 */
|
|
lua_unlock(L);
|
|
return 0; /* return to 'luaD_hook' */
|
|
}
|
|
|
|
|
|
/*
|
|
** Call the C function 'func' in protected mode, restoring basic
|
|
** thread information ('allowhook', etc.) and in particular
|
|
** its stack level in case of errors.
|
|
*/
|
|
int luaD_pcall (lua_State *L, Pfunc func, void *u,
|
|
ptrdiff_t old_top, ptrdiff_t ef) {
|
|
int status;
|
|
CallInfo *old_ci = L->ci;
|
|
lu_byte old_allowhooks = L->allowhook;
|
|
ptrdiff_t old_errfunc = L->errfunc;
|
|
L->errfunc = ef;
|
|
status = luaD_rawrunprotected(L, func, u);
|
|
if (unlikely(status != LUA_OK)) { /* an error occurred? */
|
|
StkId oldtop = restorestack(L, old_top);
|
|
L->ci = old_ci;
|
|
L->allowhook = old_allowhooks;
|
|
status = luaF_close(L, oldtop, status);
|
|
oldtop = restorestack(L, old_top); /* previous call may change stack */
|
|
luaD_seterrorobj(L, status, oldtop);
|
|
luaD_shrinkstack(L);
|
|
}
|
|
L->errfunc = old_errfunc;
|
|
return status;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
** Execute a protected parser.
|
|
*/
|
|
struct SParser { /* data to 'f_parser' */
|
|
ZIO *z;
|
|
Mbuffer buff; /* dynamic structure used by the scanner */
|
|
Dyndata dyd; /* dynamic structures used by the parser */
|
|
const char *mode;
|
|
const char *name;
|
|
};
|
|
|
|
|
|
static void checkmode (lua_State *L, const char *mode, const char *x) {
|
|
if (mode && strchr(mode, x[0]) == NULL) {
|
|
luaO_pushfstring(L,
|
|
"attempt to load a %s chunk (mode is '%s')", x, mode);
|
|
luaD_throw(L, LUA_ERRSYNTAX);
|
|
}
|
|
}
|
|
|
|
|
|
static void f_parser (lua_State *L, void *ud) {
|
|
LClosure *cl;
|
|
struct SParser *p = cast(struct SParser *, ud);
|
|
int c = zgetc(p->z); /* read first character */
|
|
if (c == LUA_SIGNATURE[0]) {
|
|
checkmode(L, p->mode, "binary");
|
|
cl = luaU_undump(L, p->z, p->name);
|
|
}
|
|
else {
|
|
checkmode(L, p->mode, "text");
|
|
cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
|
|
}
|
|
lua_assert(cl->nupvalues == cl->p->sizeupvalues);
|
|
luaF_initupvals(L, cl);
|
|
}
|
|
|
|
|
|
int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
|
|
const char *mode) {
|
|
struct SParser p;
|
|
int status;
|
|
incnny(L); /* cannot yield during parsing */
|
|
p.z = z; p.name = name; p.mode = mode;
|
|
p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0;
|
|
p.dyd.gt.arr = NULL; p.dyd.gt.size = 0;
|
|
p.dyd.label.arr = NULL; p.dyd.label.size = 0;
|
|
luaZ_initbuffer(L, &p.buff);
|
|
status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
|
|
luaZ_freebuffer(L, &p.buff);
|
|
luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size);
|
|
luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size);
|
|
luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size);
|
|
decnny(L);
|
|
return status;
|
|
}
|
|
|
|
|