/*

** $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 LUA_OK: {  /* special case only for closing upvalues */

      setnilvalue(s2v(oldtop));  /* no error message */

      break;

    }

    default: {

      lua_assert(errorstatus(errcode));  /* real error */

      setobjs2s(L, oldtop, L->top.p - 1);  /* error message on current top */

      break;

    }

  }

  L->top.p = 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 = luaE_resetthread(L, errcode);  /* close all upvalues */

    if (g->mainthread->errorJmp) {  /* main thread has a handler? */

      setobjs2s(L, g->mainthread->top.p++, L->top.p - 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? */

        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;

  struct lua_longjmp lj;

  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;

  return lj.status;

}

/* }====================================================== */

/*

** {==================================================================

** Stack reallocation

** ===================================================================

*/

/*

** Change all pointers to the stack into offsets.

*/

static void relstack (lua_State *L) {

  CallInfo *ci;

  UpVal *up;

  L->top.offset = savestack(L, L->top.p);

  L->tbclist.offset = savestack(L, L->tbclist.p);

  for (up = L->openupval; up != NULL; up = up->u.open.next)

    up->v.offset = savestack(L, uplevel(up));

  for (ci = L->ci; ci != NULL; ci = ci->previous) {

    ci->top.offset = savestack(L, ci->top.p);

    ci->func.offset = savestack(L, ci->func.p);

  }

}

/*

** Change back all offsets into pointers.

*/

static void correctstack (lua_State *L) {

  CallInfo *ci;

  UpVal *up;

  L->top.p = restorestack(L, L->top.offset);

  L->tbclist.p = restorestack(L, L->tbclist.offset);

  for (up = L->openupval; up != NULL; up = up->u.open.next)

    up->v.p = s2v(restorestack(L, up->v.offset));

  for (ci = L->ci; ci != NULL; ci = ci->previous) {

    ci->top.p = restorestack(L, ci->top.offset);

    ci->func.p = restorestack(L, ci->func.offset);

    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)

/*

** Reallocate the stack to a new size, correcting all pointers into it.

** In ISO C, any pointer use after the pointer has been deallocated is

** undefined behavior. So, before the reallocation, all pointers are

** changed to offsets, and after the reallocation they are changed back

** to pointers. As during the reallocation the pointers are invalid, the

** reallocation cannot run emergency collections.

**

** 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;

  int oldgcstop = G(L)->gcstopem;

  lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE);

  relstack(L);  /* change pointers to offsets */

  G(L)->gcstopem = 1;  /* stop emergency collection */

  newstack = luaM_reallocvector(L, L->stack.p, oldsize + EXTRA_STACK,

                                   newsize + EXTRA_STACK, StackValue);

  G(L)->gcstopem = oldgcstop;  /* restore emergency collection */

  if (l_unlikely(newstack == NULL)) {  /* reallocation failed? */

    correctstack(L);  /* change offsets back to pointers */

    if (raiseerror)

      luaM_error(L);

    else return 0;  /* do not raise an error */

  }

  L->stack.p = newstack;

  correctstack(L);  /* change offsets back to pointers */

  L->stack_last.p = L->stack.p + newsize;

  for (i = oldsize + EXTRA_STACK; i < newsize + EXTRA_STACK; i++)

    setnilvalue(s2v(newstack + i)); /* erase new segment */

  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 = stacksize(L);

  if (l_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. */

    lua_assert(stacksize(L) == ERRORSTACKSIZE);

    if (raiseerror)

      luaD_throw(L, LUA_ERRERR);  /* error inside message handler */

    return 0;  /* if not 'raiseerror', just signal it */

  }

  else if (n < LUAI_MAXSTACK) {  /* avoids arithmetic overflows */

    int newsize = 2 * size;  /* tentative new size */

    int needed = cast_int(L->top.p - L->stack.p) + n;

    if (newsize > LUAI_MAXSTACK)  /* cannot cross the limit */

      newsize = LUAI_MAXSTACK;

    if (newsize < needed)  /* but must respect what was asked for */

      newsize = needed;

    if (l_likely(newsize <= LUAI_MAXSTACK))

      return luaD_reallocstack(L, newsize, raiseerror);

  }

  /* else 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");

  return 0;

}

/*

** Compute how much of the stack is being used, by computing the

** maximum top of all call frames in the stack and the current top.

*/

static int stackinuse (lua_State *L) {

  CallInfo *ci;

  int res;

  StkId lim = L->top.p;

  for (ci = L->ci; ci != NULL; ci = ci->previous) {

    if (lim < ci->top.p) lim = ci->top.p;

  }

  lua_assert(lim <= L->stack_last.p + EXTRA_STACK);

  res = cast_int(lim - L->stack.p) + 1;  /* part of stack in use */

  if (res < LUA_MINSTACK)

    res = LUA_MINSTACK;  /* ensure a minimum size */

  return res;

}

/*

** If stack size is more than 3 times the current use, reduce that size

** to twice the current use. (So, the final stack size is at most 2/3 the

** previous size, and half of its entries are empty.)

** As a particular case, if stack was handling a stack overflow and now

** it is not, 'max' (limited by LUAI_MAXSTACK) will be smaller than

** stacksize (equal to ERRORSTACKSIZE in this case), and so the stack

** will be reduced to a "regular" size.

*/

void luaD_shrinkstack (lua_State *L) {

  int inuse = stackinuse(L);

  int max = (inuse > LUAI_MAXSTACK / 3) ? LUAI_MAXSTACK : inuse * 3;

  /* if thread is currently not handling a stack overflow and its

     size is larger than maximum "reasonable" size, shrink it */

  if (inuse <= LUAI_MAXSTACK && stacksize(L) > max) {

    int nsize = (inuse > LUAI_MAXSTACK / 2) ? LUAI_MAXSTACK : inuse * 2;

    luaD_reallocstack(L, nsize, 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.p++;

}

/* }================================================================== */

/*

** 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.p);  /* preserve original 'top' */

    ptrdiff_t ci_top = savestack(L, ci->top.p);  /* idem for '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;

    }

    if (isLua(ci) && L->top.p < ci->top.p)

      L->top.p = ci->top.p;  /* protect entire activation register */

    luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */

    if (ci->top.p < L->top.p + LUA_MINSTACK)

      ci->top.p = L->top.p + 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.p = restorestack(L, ci_top);

    L->top.p = 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) {

  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;

    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' */

  }

}

/*

** 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.p - 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.p += delta;  /* if vararg, back to virtual 'func' */

    ftransfer = cast(unsigned short, firstres - ci->func.p);

    luaD_hook(L, LUA_HOOKRET, -1, ftransfer, nres);  /* call it */

    ci->func.p -= delta;

  }

  if (isLua(ci = ci->previous))

    L->oldpc = pcRel(ci->u.l.savedpc, ci_func(ci)->p);  /* set 'oldpc' */

}

/*

** Check whether 'func' has a '__call' metafield. If so, put it in the

** stack, below original 'func', so that 'luaD_precall' can call it. Raise

** an error if there is no '__call' metafield.

*/

static StkId tryfuncTM (lua_State *L, StkId func) {

  const TValue *tm;

  StkId p;

  checkstackGCp(L, 1, func);  /* space for metamethod */

  tm = luaT_gettmbyobj(L, s2v(func), TM_CALL);  /* (after previous GC) */

  if (l_unlikely(ttisnil(tm)))

    luaG_callerror(L, s2v(func));  /* nothing to call */

  for (p = L->top.p; p > func; p--)  /* open space for metamethod */

    setobjs2s(L, p, p-1);

  L->top.p++;  /* stack space pre-allocated by the caller */

  setobj2s(L, func, tm);  /* metamethod is the new function to be called */

  return func;

}

/*

** 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.

*/

l_sinline 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.p = res;

      return;

    case 1:  /* one value needed */

      if (nres == 0)   /* no results? */

        setnilvalue(s2v(res));  /* adjust with nil */

      else  /* at least one result */

        setobjs2s(L, res, L->top.p - nres);  /* move it to proper place */

      L->top.p = res + 1;

      return;

    case LUA_MULTRET:

      wanted = nres;  /* we want all results */

      break;

    default:  /* two/more results and/or to-be-closed variables */

      if (hastocloseCfunc(wanted)) {  /* to-be-closed variables? */

        L->ci->callstatus |= CIST_CLSRET;  /* in case of yields */

        L->ci->u2.nres = nres;

        res = luaF_close(L, res, CLOSEKTOP, 1);

        L->ci->callstatus &= ~CIST_CLSRET;

        if (L->hookmask) {  /* if needed, call hook after '__close's */

          ptrdiff_t savedres = savestack(L, res);

          rethook(L, L->ci, nres);

          res = restorestack(L, savedres);  /* hook can move stack */

        }

        wanted = decodeNresults(wanted);

        if (wanted == LUA_MULTRET)

          wanted = nres;  /* we want all results */

      }

      break;

  }

  /* generic case */

  firstresult = L->top.p - 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 */

    setobjs2s(L, res + i, firstresult + i);

  for (; i < wanted; i++)  /* complete wanted number of results */

    setnilvalue(s2v(res + i));

  L->top.p = res + wanted;  /* top points after the last result */

}

/*

** 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.

*/

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);

  /* move results to proper place */

  moveresults(L, ci->func.p, 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) */

}

#define next_ci(L)  (L->ci->next ? L->ci->next : luaE_extendCI(L))

l_sinline CallInfo *prepCallInfo (lua_State *L, StkId func, int nret,

                                                int mask, StkId top) {

  CallInfo *ci = L->ci = next_ci(L);  /* new frame */

  ci->func.p = func;

  ci->nresults = nret;

  ci->callstatus = mask;

  ci->top.p = top;

  return ci;

}

/*

** precall for C functions

*/

l_sinline int precallC (lua_State *L, StkId func, int nresults,

                                            lua_CFunction f) {

  int n;  /* number of returns */

  CallInfo *ci;

  checkstackGCp(L, LUA_MINSTACK, func);  /* ensure minimum stack size */

  L->ci = ci = prepCallInfo(L, func, nresults, CIST_C,

                               L->top.p + LUA_MINSTACK);

  lua_assert(ci->top.p <= L->stack_last.p);

  if (l_unlikely(L->hookmask & LUA_MASKCALL)) {

    int narg = cast_int(L->top.p - 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);

  return n;

}

/*

** 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). Return the number of

** results, if it was a C function, or -1 for a Lua function.

*/

int luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func,

                                    int narg1, int delta) {

 retry:

  switch (ttypetag(s2v(func))) {

    case LUA_VCCL:  /* C closure */

      return precallC(L, func, LUA_MULTRET, clCvalue(s2v(func))->f);

    case LUA_VLCF:  /* light C function */

      return precallC(L, func, LUA_MULTRET, fvalue(s2v(func)));

    case LUA_VLCL: {  /* Lua function */

      Proto *p = clLvalue(s2v(func))->p;

      int fsize = p->maxstacksize;  /* frame size */

      int nfixparams = p->numparams;

      int i;

      checkstackGCp(L, fsize - delta, func);

      ci->func.p -= delta;  /* restore 'func' (if vararg) */

      for (i = 0; i < narg1; i++)  /* move down function and arguments */

        setobjs2s(L, ci->func.p + i, func + i);

      func = ci->func.p;  /* moved-down function */

      for (; narg1 <= nfixparams; narg1++)

        setnilvalue(s2v(func + narg1));  /* complete missing arguments */

      ci->top.p = func + 1 + fsize;  /* top for new function */

      lua_assert(ci->top.p <= L->stack_last.p);

      ci->u.l.savedpc = p->code;  /* starting point */

      ci->callstatus |= CIST_TAIL;

      L->top.p = func + narg1;  /* set top */

      return -1;

    }

    default: {  /* not a function */

      func = tryfuncTM(L, func);  /* try to get '__call' metamethod */

      /* return luaD_pretailcall(L, ci, func, narg1 + 1, delta); */

      narg1++;

      goto retry;  /* try again */

    }

  }

}

/*

** Prepares the call to a function (C or Lua). For C functions, also do

** the call. The function to be called is at '*func'.  The arguments

** are on the stack, right after the function.  Returns the CallInfo

** to be executed, if it was a Lua function. Otherwise (a C function)

** returns NULL, with all the results on the stack, starting at the

** original function position.

*/

CallInfo *luaD_precall (lua_State *L, StkId func, int nresults) {

 retry:

  switch (ttypetag(s2v(func))) {

    case LUA_VCCL:  /* C closure */

      precallC(L, func, nresults, clCvalue(s2v(func))->f);

      return NULL;

    case LUA_VLCF:  /* light C function */

      precallC(L, func, nresults, fvalue(s2v(func)));

      return NULL;

    case LUA_VLCL: {  /* Lua function */

      CallInfo *ci;

      Proto *p = clLvalue(s2v(func))->p;

      int narg = cast_int(L->top.p - func) - 1;  /* number of real arguments */

      int nfixparams = p->numparams;

      int fsize = p->maxstacksize;  /* frame size */

      checkstackGCp(L, fsize, func);

      L->ci = ci = prepCallInfo(L, func, nresults, 0, func + 1 + fsize);

      ci->u.l.savedpc = p->code;  /* starting point */

      for (; narg < nfixparams; narg++)

        setnilvalue(s2v(L->top.p++));  /* complete missing arguments */

      lua_assert(ci->top.p <= L->stack_last.p);

      return ci;

    }

    default: {  /* not a function */

      func = tryfuncTM(L, func);  /* try to get '__call' metamethod */

      /* return luaD_precall(L, func, nresults); */

      goto retry;  /* try again with metamethod */

    }

  }

}

/*

** Call a function (C or Lua) through C. 'inc' can be 1 (increment

** number of recursive invocations in the C stack) or nyci (the same

** plus increment number of non-yieldable calls).

** This function can be called with some use of EXTRA_STACK, so it should

** check the stack before doing anything else. 'luaD_precall' already

** does that.

*/

l_sinline void ccall (lua_State *L, StkId func, int nResults, l_uint32 inc) {

  CallInfo *ci;

  L->nCcalls += inc;

  if (l_unlikely(getCcalls(L) >= LUAI_MAXCCALLS)) {

    checkstackp(L, 0, func);  /* free any use of EXTRA_STACK */

    luaE_checkcstack(L);

  }

  if ((ci = luaD_precall(L, func, nResults)) != NULL) {  /* Lua function? */

    ci->callstatus = CIST_FRESH;  /* mark that it is a "fresh" execute */

    luaV_execute(L, ci);  /* call it */

  }

  L->nCcalls -= inc;

}

/*

** External interface for 'ccall'

*/

void luaD_call (lua_State *L, StkId func, int nResults) {

  ccall(L, func, nResults, 1);

}

/*

** Similar to 'luaD_call', but does not allow yields during the call.

*/

void luaD_callnoyield (lua_State *L, StkId func, int nResults) {

  ccall(L, func, nResults, nyci);

}

/*

** 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' */

    func = luaF_close(L, func, status, 1);  /* can yield or raise an error */

    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).

*/

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);

  }

  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).

*/

static void unroll (lua_State *L, void *ud) {

  CallInfo *ci;

  UNUSED(ud);

  while ((ci = L->ci) != &L->base_ci) {  /* something in the stack */

    if (!isLua(ci))  /* C function? */

      finishCcall(L, ci);  /* 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 */

}

/*

** 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.p -= narg;  /* remove args from the stack */

  setsvalue2s(L, L->top.p, 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.p - n;  /* first argument */

  CallInfo *ci = L->ci;

  if (L->status == LUA_OK)  /* starting a coroutine? */

    ccall(L, firstArg - 1, LUA_MULTRET, 0);  /* just call its body */

  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? */

      L->top.p = firstArg;  /* discard arguments */

      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 */

  }

}

/*

** 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;

  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->top.p - (L->ci->func.p + 1) == nargs)  /* no function? */

      return resume_error(L, "cannot resume dead coroutine", nargs);

  }

  else if (L->status != LUA_YIELD)  /* ended with errors? */

    return resume_error(L, "cannot resume dead coroutine", nargs);

  L->nCcalls = (from) ? getCcalls(from) : 0;

  if (getCcalls(L) >= LUAI_MAXCCALLS)

    return resume_error(L, "C stack overflow", nargs);

  L->nCcalls++;

  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 */

  status = precover(L, status);

  if (l_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.p);  /* push error message */

    L->ci->top.p = L->top.p;

  }

  *nresults = (status == LUA_YIELD) ? L->ci->u2.nyield

                                    : cast_int(L->top.p - (L->ci->func.p + 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;

  luai_userstateyield(L, nresults);

  lua_lock(L);

  ci = L->ci;

  api_checknelems(L, nresults);

  if (l_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");

  }

  else {

    if ((ci->u.c.k = k) != NULL)  /* is there a continuation? */

      ci->u.c.ctx = ctx;  /* save context */

    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' */

}

/*

** 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.

*/

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 (l_unlikely(status != LUA_OK)) {  /* an error occurred? */

    L->ci = old_ci;

    L->allowhook = old_allowhooks;

    status = luaD_closeprotected(L, old_top, status);

    luaD_seterrorobj(L, status, restorestack(L, old_top));

    luaD_shrinkstack(L);   /* restore stack size in case of overflow */

  }

  L->errfunc = old_errfunc;

  return status;

}