xref: /netbsd-src/external/mit/lua/dist/src/ldo.c (revision 82d56013d7b633d116a93943de88e08335357a7c)
1 /*	$NetBSD: ldo.c,v 1.9 2018/08/04 17:30:01 alnsn Exp $	*/
2 
3 /*
4 ** Id: ldo.c,v 2.157.1.1 2017/04/19 17:20:42 roberto Exp
5 ** Stack and Call structure of Lua
6 ** See Copyright Notice in lua.h
7 */
8 
9 #define ldo_c
10 #define LUA_CORE
11 
12 #include "lprefix.h"
13 
14 
15 #ifndef _KERNEL
16 #include <setjmp.h>
17 #include <stdlib.h>
18 #include <string.h>
19 #endif /* _KERNEL */
20 
21 #include "lua.h"
22 
23 #include "lapi.h"
24 #include "ldebug.h"
25 #include "ldo.h"
26 #include "lfunc.h"
27 #include "lgc.h"
28 #include "lmem.h"
29 #include "lobject.h"
30 #include "lopcodes.h"
31 #include "lparser.h"
32 #include "lstate.h"
33 #include "lstring.h"
34 #include "ltable.h"
35 #include "ltm.h"
36 #include "lundump.h"
37 #include "lvm.h"
38 #include "lzio.h"
39 
40 
41 
42 #define errorstatus(s)	((s) > LUA_YIELD)
43 
44 
45 /*
46 ** {======================================================
47 ** Error-recovery functions
48 ** =======================================================
49 */
50 
51 /*
52 ** LUAI_THROW/LUAI_TRY define how Lua does exception handling. By
53 ** default, Lua handles errors with exceptions when compiling as
54 ** C++ code, with _longjmp/_setjmp when asked to use them, and with
55 ** longjmp/setjmp otherwise.
56 */
57 #if !defined(LUAI_THROW)				/* { */
58 
59 #if defined(__cplusplus) && !defined(LUA_USE_LONGJMP)	/* { */
60 
61 /* C++ exceptions */
62 #define LUAI_THROW(L,c)		throw(c)
63 #define LUAI_TRY(L,c,a) \
64 	try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; }
65 #define luai_jmpbuf		int  /* dummy variable */
66 
67 #elif defined(LUA_USE_POSIX)				/* }{ */
68 
69 /* in POSIX, try _longjmp/_setjmp (more efficient) */
70 #define LUAI_THROW(L,c)		_longjmp((c)->b, 1)
71 #define LUAI_TRY(L,c,a)		if (_setjmp((c)->b) == 0) { a }
72 #define luai_jmpbuf		jmp_buf
73 
74 #else							/* }{ */
75 
76 /* ISO C handling with long jumps */
77 #define LUAI_THROW(L,c)		longjmp((c)->b, 1)
78 #define LUAI_TRY(L,c,a)		if (setjmp((c)->b) == 0) { a }
79 #define luai_jmpbuf		jmp_buf
80 
81 #endif							/* } */
82 
83 #endif							/* } */
84 
85 
86 
87 /* chain list of long jump buffers */
88 struct lua_longjmp {
89   struct lua_longjmp *previous;
90   luai_jmpbuf b;
91   volatile int status;  /* error code */
92 };
93 
94 
95 static void seterrorobj (lua_State *L, int errcode, StkId oldtop) {
96   switch (errcode) {
97     case LUA_ERRMEM: {  /* memory error? */
98       setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */
99       break;
100     }
101     case LUA_ERRERR: {
102       setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
103       break;
104     }
105     default: {
106       setobjs2s(L, oldtop, L->top - 1);  /* error message on current top */
107       break;
108     }
109   }
110   L->top = oldtop + 1;
111 }
112 
113 
114 l_noret luaD_throw (lua_State *L, int errcode) {
115   if (L->errorJmp) {  /* thread has an error handler? */
116     L->errorJmp->status = errcode;  /* set status */
117     LUAI_THROW(L, L->errorJmp);  /* jump to it */
118   }
119   else {  /* thread has no error handler */
120     global_State *g = G(L);
121     L->status = cast_byte(errcode);  /* mark it as dead */
122     if (g->mainthread->errorJmp) {  /* main thread has a handler? */
123       setobjs2s(L, g->mainthread->top++, L->top - 1);  /* copy error obj. */
124       luaD_throw(g->mainthread, errcode);  /* re-throw in main thread */
125     }
126     else {  /* no handler at all; abort */
127       if (g->panic) {  /* panic function? */
128         seterrorobj(L, errcode, L->top);  /* assume EXTRA_STACK */
129         if (L->ci->top < L->top)
130           L->ci->top = L->top;  /* pushing msg. can break this invariant */
131         lua_unlock(L);
132         g->panic(L);  /* call panic function (last chance to jump out) */
133       }
134       abort();
135     }
136   }
137 }
138 
139 
140 int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
141   unsigned short oldnCcalls = L->nCcalls;
142   struct lua_longjmp lj;
143   lj.status = LUA_OK;
144   lj.previous = L->errorJmp;  /* chain new error handler */
145   L->errorJmp = &lj;
146   LUAI_TRY(L, &lj,
147     (*f)(L, ud);
148   );
149   L->errorJmp = lj.previous;  /* restore old error handler */
150   L->nCcalls = oldnCcalls;
151   return lj.status;
152 }
153 
154 /* }====================================================== */
155 
156 
157 /*
158 ** {==================================================================
159 ** Stack reallocation
160 ** ===================================================================
161 */
162 static void correctstack (lua_State *L, TValue *oldstack) {
163   CallInfo *ci;
164   UpVal *up;
165   L->top = (L->top - oldstack) + L->stack;
166   for (up = L->openupval; up != NULL; up = up->u.open.next)
167     up->v = (up->v - oldstack) + L->stack;
168   for (ci = L->ci; ci != NULL; ci = ci->previous) {
169     ci->top = (ci->top - oldstack) + L->stack;
170     ci->func = (ci->func - oldstack) + L->stack;
171     if (isLua(ci))
172       ci->u.l.base = (ci->u.l.base - oldstack) + L->stack;
173   }
174 }
175 
176 
177 /* some space for error handling */
178 #define ERRORSTACKSIZE	(LUAI_MAXSTACK + 200)
179 
180 
181 void luaD_reallocstack (lua_State *L, int newsize) {
182   TValue *oldstack = L->stack;
183   int lim = L->stacksize;
184   lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE);
185   lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK);
186   luaM_reallocvector(L, L->stack, L->stacksize, newsize, TValue);
187   for (; lim < newsize; lim++)
188     setnilvalue(L->stack + lim); /* erase new segment */
189   L->stacksize = newsize;
190   L->stack_last = L->stack + newsize - EXTRA_STACK;
191   correctstack(L, oldstack);
192 }
193 
194 
195 void luaD_growstack (lua_State *L, int n) {
196   int size = L->stacksize;
197   if (size > LUAI_MAXSTACK)  /* error after extra size? */
198     luaD_throw(L, LUA_ERRERR);
199   else {
200     int needed = cast_int(L->top - L->stack) + n + EXTRA_STACK;
201     int newsize = 2 * size;
202     if (newsize > LUAI_MAXSTACK) newsize = LUAI_MAXSTACK;
203     if (newsize < needed) newsize = needed;
204     if (newsize > LUAI_MAXSTACK) {  /* stack overflow? */
205       luaD_reallocstack(L, ERRORSTACKSIZE);
206       luaG_runerror(L, "stack overflow");
207     }
208     else
209       luaD_reallocstack(L, newsize);
210   }
211 }
212 
213 
214 static int stackinuse (lua_State *L) {
215   CallInfo *ci;
216   StkId lim = L->top;
217   for (ci = L->ci; ci != NULL; ci = ci->previous) {
218     if (lim < ci->top) lim = ci->top;
219   }
220   lua_assert(lim <= L->stack_last);
221   return cast_int(lim - L->stack) + 1;  /* part of stack in use */
222 }
223 
224 
225 void luaD_shrinkstack (lua_State *L) {
226   int inuse = stackinuse(L);
227   int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;
228   if (goodsize > LUAI_MAXSTACK)
229     goodsize = LUAI_MAXSTACK;  /* respect stack limit */
230   if (L->stacksize > LUAI_MAXSTACK)  /* had been handling stack overflow? */
231     luaE_freeCI(L);  /* free all CIs (list grew because of an error) */
232   else
233     luaE_shrinkCI(L);  /* shrink list */
234   /* if thread is currently not handling a stack overflow and its
235      good size is smaller than current size, shrink its stack */
236   if (inuse <= (LUAI_MAXSTACK - EXTRA_STACK) &&
237       goodsize < L->stacksize)
238     luaD_reallocstack(L, goodsize);
239   else  /* don't change stack */
240     condmovestack(L,{},{});  /* (change only for debugging) */
241 }
242 
243 
244 void luaD_inctop (lua_State *L) {
245   luaD_checkstack(L, 1);
246   L->top++;
247 }
248 
249 /* }================================================================== */
250 
251 
252 /*
253 ** Call a hook for the given event. Make sure there is a hook to be
254 ** called. (Both 'L->hook' and 'L->hookmask', which triggers this
255 ** function, can be changed asynchronously by signals.)
256 */
257 void luaD_hook (lua_State *L, int event, int line) {
258   lua_Hook hook = L->hook;
259   if (hook && L->allowhook) {  /* make sure there is a hook */
260     CallInfo *ci = L->ci;
261     ptrdiff_t top = savestack(L, L->top);
262     ptrdiff_t ci_top = savestack(L, ci->top);
263     lua_Debug ar;
264     ar.event = event;
265     ar.currentline = line;
266     ar.i_ci = ci;
267     luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
268     ci->top = L->top + LUA_MINSTACK;
269     lua_assert(ci->top <= L->stack_last);
270     L->allowhook = 0;  /* cannot call hooks inside a hook */
271     ci->callstatus |= CIST_HOOKED;
272     lua_unlock(L);
273     (*hook)(L, &ar);
274     lua_lock(L);
275     lua_assert(!L->allowhook);
276     L->allowhook = 1;
277     ci->top = restorestack(L, ci_top);
278     L->top = restorestack(L, top);
279     ci->callstatus &= ~CIST_HOOKED;
280   }
281 }
282 
283 
284 static void callhook (lua_State *L, CallInfo *ci) {
285   int hook = LUA_HOOKCALL;
286   ci->u.l.savedpc++;  /* hooks assume 'pc' is already incremented */
287   if (isLua(ci->previous) &&
288       GET_OPCODE(*(ci->previous->u.l.savedpc - 1)) == OP_TAILCALL) {
289     ci->callstatus |= CIST_TAIL;
290     hook = LUA_HOOKTAILCALL;
291   }
292   luaD_hook(L, hook, -1);
293   ci->u.l.savedpc--;  /* correct 'pc' */
294 }
295 
296 
297 static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {
298   int i;
299   int nfixargs = p->numparams;
300   StkId base, fixed;
301   /* move fixed parameters to final position */
302   fixed = L->top - actual;  /* first fixed argument */
303   base = L->top;  /* final position of first argument */
304   for (i = 0; i < nfixargs && i < actual; i++) {
305     setobjs2s(L, L->top++, fixed + i);
306     setnilvalue(fixed + i);  /* erase original copy (for GC) */
307   }
308   for (; i < nfixargs; i++)
309     setnilvalue(L->top++);  /* complete missing arguments */
310   return base;
311 }
312 
313 
314 /*
315 ** Check whether __call metafield of 'func' is a function. If so, put
316 ** it in stack below original 'func' so that 'luaD_precall' can call
317 ** it. Raise an error if __call metafield is not a function.
318 */
319 static void tryfuncTM (lua_State *L, StkId func) {
320   const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
321   StkId p;
322   if (!ttisfunction(tm))
323     luaG_typeerror(L, func, "call");
324   /* Open a hole inside the stack at 'func' */
325   for (p = L->top; p > func; p--)
326     setobjs2s(L, p, p-1);
327   L->top++;  /* slot ensured by caller */
328   setobj2s(L, func, tm);  /* tag method is the new function to be called */
329 }
330 
331 
332 /*
333 ** Given 'nres' results at 'firstResult', move 'wanted' of them to 'res'.
334 ** Handle most typical cases (zero results for commands, one result for
335 ** expressions, multiple results for tail calls/single parameters)
336 ** separated.
337 */
338 static int moveresults (lua_State *L, const TValue *firstResult, StkId res,
339                                       int nres, int wanted) {
340   switch (wanted) {  /* handle typical cases separately */
341     case 0: break;  /* nothing to move */
342     case 1: {  /* one result needed */
343       if (nres == 0)   /* no results? */
344         firstResult = luaO_nilobject;  /* adjust with nil */
345       setobjs2s(L, res, firstResult);  /* move it to proper place */
346       break;
347     }
348     case LUA_MULTRET: {
349       int i;
350       for (i = 0; i < nres; i++)  /* move all results to correct place */
351         setobjs2s(L, res + i, firstResult + i);
352       L->top = res + nres;
353       return 0;  /* wanted == LUA_MULTRET */
354     }
355     default: {
356       int i;
357       if (wanted <= nres) {  /* enough results? */
358         for (i = 0; i < wanted; i++)  /* move wanted results to correct place */
359           setobjs2s(L, res + i, firstResult + i);
360       }
361       else {  /* not enough results; use all of them plus nils */
362         for (i = 0; i < nres; i++)  /* move all results to correct place */
363           setobjs2s(L, res + i, firstResult + i);
364         for (; i < wanted; i++)  /* complete wanted number of results */
365           setnilvalue(res + i);
366       }
367       break;
368     }
369   }
370   L->top = res + wanted;  /* top points after the last result */
371   return 1;
372 }
373 
374 
375 /*
376 ** Finishes a function call: calls hook if necessary, removes CallInfo,
377 ** moves current number of results to proper place; returns 0 iff call
378 ** wanted multiple (variable number of) results.
379 */
380 int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult, int nres) {
381   StkId res;
382   int wanted = ci->nresults;
383   if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) {
384     if (L->hookmask & LUA_MASKRET) {
385       ptrdiff_t fr = savestack(L, firstResult);  /* hook may change stack */
386       luaD_hook(L, LUA_HOOKRET, -1);
387       firstResult = restorestack(L, fr);
388     }
389     L->oldpc = ci->previous->u.l.savedpc;  /* 'oldpc' for caller function */
390   }
391   res = ci->func;  /* res == final position of 1st result */
392   L->ci = ci->previous;  /* back to caller */
393   /* move results to proper place */
394   return moveresults(L, firstResult, res, nres, wanted);
395 }
396 
397 
398 
399 #define next_ci(L) (L->ci = (L->ci->next ? L->ci->next : luaE_extendCI(L)))
400 
401 
402 /* macro to check stack size, preserving 'p' */
403 #define checkstackp(L,n,p)  \
404   luaD_checkstackaux(L, n, \
405     ptrdiff_t t__ = savestack(L, p);  /* save 'p' */ \
406     luaC_checkGC(L),  /* stack grow uses memory */ \
407     p = restorestack(L, t__))  /* 'pos' part: restore 'p' */
408 
409 
410 /*
411 ** Prepares a function call: checks the stack, creates a new CallInfo
412 ** entry, fills in the relevant information, calls hook if needed.
413 ** If function is a C function, does the call, too. (Otherwise, leave
414 ** the execution ('luaV_execute') to the caller, to allow stackless
415 ** calls.) Returns true iff function has been executed (C function).
416 */
417 int luaD_precall (lua_State *L, StkId func, int nresults) {
418   lua_CFunction f;
419   CallInfo *ci;
420   switch (ttype(func)) {
421     case LUA_TCCL:  /* C closure */
422       f = clCvalue(func)->f;
423       goto Cfunc;
424     case LUA_TLCF:  /* light C function */
425       f = fvalue(func);
426      Cfunc: {
427       int n;  /* number of returns */
428       checkstackp(L, LUA_MINSTACK, func);  /* ensure minimum stack size */
429       ci = next_ci(L);  /* now 'enter' new function */
430       ci->nresults = nresults;
431       ci->func = func;
432       ci->top = L->top + LUA_MINSTACK;
433       lua_assert(ci->top <= L->stack_last);
434       ci->callstatus = 0;
435       if (L->hookmask & LUA_MASKCALL)
436         luaD_hook(L, LUA_HOOKCALL, -1);
437       lua_unlock(L);
438       n = (*f)(L);  /* do the actual call */
439       lua_lock(L);
440       api_checknelems(L, n);
441       luaD_poscall(L, ci, L->top - n, n);
442       return 1;
443     }
444     case LUA_TLCL: {  /* Lua function: prepare its call */
445       StkId base;
446       Proto *p = clLvalue(func)->p;
447       int n = cast_int(L->top - func) - 1;  /* number of real arguments */
448       int fsize = p->maxstacksize;  /* frame size */
449       checkstackp(L, fsize, func);
450       if (p->is_vararg)
451         base = adjust_varargs(L, p, n);
452       else {  /* non vararg function */
453         for (; n < p->numparams; n++)
454           setnilvalue(L->top++);  /* complete missing arguments */
455         base = func + 1;
456       }
457       ci = next_ci(L);  /* now 'enter' new function */
458       ci->nresults = nresults;
459       ci->func = func;
460       ci->u.l.base = base;
461       L->top = ci->top = base + fsize;
462       lua_assert(ci->top <= L->stack_last);
463       ci->u.l.savedpc = p->code;  /* starting point */
464       ci->callstatus = CIST_LUA;
465       if (L->hookmask & LUA_MASKCALL)
466         callhook(L, ci);
467       return 0;
468     }
469     default: {  /* not a function */
470       checkstackp(L, 1, func);  /* ensure space for metamethod */
471       tryfuncTM(L, func);  /* try to get '__call' metamethod */
472       return luaD_precall(L, func, nresults);  /* now it must be a function */
473     }
474   }
475 }
476 
477 
478 /*
479 ** Check appropriate error for stack overflow ("regular" overflow or
480 ** overflow while handling stack overflow). If 'nCalls' is larger than
481 ** LUAI_MAXCCALLS (which means it is handling a "regular" overflow) but
482 ** smaller than 9/8 of LUAI_MAXCCALLS, does not report an error (to
483 ** allow overflow handling to work)
484 */
485 static void stackerror (lua_State *L) {
486   if (L->nCcalls == LUAI_MAXCCALLS)
487     luaG_runerror(L, "C stack overflow");
488   else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
489     luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
490 }
491 
492 
493 /*
494 ** Call a function (C or Lua). The function to be called is at *func.
495 ** The arguments are on the stack, right after the function.
496 ** When returns, all the results are on the stack, starting at the original
497 ** function position.
498 */
499 void luaD_call (lua_State *L, StkId func, int nResults) {
500   if (++L->nCcalls >= LUAI_MAXCCALLS)
501     stackerror(L);
502   if (!luaD_precall(L, func, nResults))  /* is a Lua function? */
503     luaV_execute(L);  /* call it */
504   L->nCcalls--;
505 }
506 
507 
508 /*
509 ** Similar to 'luaD_call', but does not allow yields during the call
510 */
511 void luaD_callnoyield (lua_State *L, StkId func, int nResults) {
512   L->nny++;
513   luaD_call(L, func, nResults);
514   L->nny--;
515 }
516 
517 
518 /*
519 ** Completes the execution of an interrupted C function, calling its
520 ** continuation function.
521 */
522 static void finishCcall (lua_State *L, int status) {
523   CallInfo *ci = L->ci;
524   int n;
525   /* must have a continuation and must be able to call it */
526   lua_assert(ci->u.c.k != NULL && L->nny == 0);
527   /* error status can only happen in a protected call */
528   lua_assert((ci->callstatus & CIST_YPCALL) || status == LUA_YIELD);
529   if (ci->callstatus & CIST_YPCALL) {  /* was inside a pcall? */
530     ci->callstatus &= ~CIST_YPCALL;  /* continuation is also inside it */
531     L->errfunc = ci->u.c.old_errfunc;  /* with the same error function */
532   }
533   /* finish 'lua_callk'/'lua_pcall'; CIST_YPCALL and 'errfunc' already
534      handled */
535   adjustresults(L, ci->nresults);
536   lua_unlock(L);
537   n = (*ci->u.c.k)(L, status, ci->u.c.ctx);  /* call continuation function */
538   lua_lock(L);
539   api_checknelems(L, n);
540   luaD_poscall(L, ci, L->top - n, n);  /* finish 'luaD_precall' */
541 }
542 
543 
544 /*
545 ** Executes "full continuation" (everything in the stack) of a
546 ** previously interrupted coroutine until the stack is empty (or another
547 ** interruption long-jumps out of the loop). If the coroutine is
548 ** recovering from an error, 'ud' points to the error status, which must
549 ** be passed to the first continuation function (otherwise the default
550 ** status is LUA_YIELD).
551 */
552 static void unroll (lua_State *L, void *ud) {
553   if (ud != NULL)  /* error status? */
554     finishCcall(L, *(int *)ud);  /* finish 'lua_pcallk' callee */
555   while (L->ci != &L->base_ci) {  /* something in the stack */
556     if (!isLua(L->ci))  /* C function? */
557       finishCcall(L, LUA_YIELD);  /* complete its execution */
558     else {  /* Lua function */
559       luaV_finishOp(L);  /* finish interrupted instruction */
560       luaV_execute(L);  /* execute down to higher C 'boundary' */
561     }
562   }
563 }
564 
565 
566 /*
567 ** Try to find a suspended protected call (a "recover point") for the
568 ** given thread.
569 */
570 static CallInfo *findpcall (lua_State *L) {
571   CallInfo *ci;
572   for (ci = L->ci; ci != NULL; ci = ci->previous) {  /* search for a pcall */
573     if (ci->callstatus & CIST_YPCALL)
574       return ci;
575   }
576   return NULL;  /* no pending pcall */
577 }
578 
579 
580 /*
581 ** Recovers from an error in a coroutine. Finds a recover point (if
582 ** there is one) and completes the execution of the interrupted
583 ** 'luaD_pcall'. If there is no recover point, returns zero.
584 */
585 static int recover (lua_State *L, int status) {
586   StkId oldtop;
587   CallInfo *ci = findpcall(L);
588   if (ci == NULL) return 0;  /* no recovery point */
589   /* "finish" luaD_pcall */
590   oldtop = restorestack(L, ci->extra);
591   luaF_close(L, oldtop);
592   seterrorobj(L, status, oldtop);
593   L->ci = ci;
594   L->allowhook = getoah(ci->callstatus);  /* restore original 'allowhook' */
595   L->nny = 0;  /* should be zero to be yieldable */
596   luaD_shrinkstack(L);
597   L->errfunc = ci->u.c.old_errfunc;
598   return 1;  /* continue running the coroutine */
599 }
600 
601 
602 /*
603 ** Signal an error in the call to 'lua_resume', not in the execution
604 ** of the coroutine itself. (Such errors should not be handled by any
605 ** coroutine error handler and should not kill the coroutine.)
606 */
607 static int resume_error (lua_State *L, const char *msg, int narg) {
608   L->top -= narg;  /* remove args from the stack */
609   setsvalue2s(L, L->top, luaS_new(L, msg));  /* push error message */
610   api_incr_top(L);
611   lua_unlock(L);
612   return LUA_ERRRUN;
613 }
614 
615 
616 /*
617 ** Do the work for 'lua_resume' in protected mode. Most of the work
618 ** depends on the status of the coroutine: initial state, suspended
619 ** inside a hook, or regularly suspended (optionally with a continuation
620 ** function), plus erroneous cases: non-suspended coroutine or dead
621 ** coroutine.
622 */
623 static void resume (lua_State *L, void *ud) {
624   int n = *(cast(int*, ud));  /* number of arguments */
625   StkId firstArg = L->top - n;  /* first argument */
626   CallInfo *ci = L->ci;
627   if (L->status == LUA_OK) {  /* starting a coroutine? */
628     if (!luaD_precall(L, firstArg - 1, LUA_MULTRET))  /* Lua function? */
629       luaV_execute(L);  /* call it */
630   }
631   else {  /* resuming from previous yield */
632     lua_assert(L->status == LUA_YIELD);
633     L->status = LUA_OK;  /* mark that it is running (again) */
634     ci->func = restorestack(L, ci->extra);
635     if (isLua(ci))  /* yielded inside a hook? */
636       luaV_execute(L);  /* just continue running Lua code */
637     else {  /* 'common' yield */
638       if (ci->u.c.k != NULL) {  /* does it have a continuation function? */
639         lua_unlock(L);
640         n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */
641         lua_lock(L);
642         api_checknelems(L, n);
643         firstArg = L->top - n;  /* yield results come from continuation */
644       }
645       luaD_poscall(L, ci, firstArg, n);  /* finish 'luaD_precall' */
646     }
647     unroll(L, NULL);  /* run continuation */
648   }
649 }
650 
651 
652 LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
653   int status;
654   unsigned short oldnny = L->nny;  /* save "number of non-yieldable" calls */
655   lua_lock(L);
656   if (L->status == LUA_OK) {  /* may be starting a coroutine */
657     if (L->ci != &L->base_ci)  /* not in base level? */
658       return resume_error(L, "cannot resume non-suspended coroutine", nargs);
659   }
660   else if (L->status != LUA_YIELD)
661     return resume_error(L, "cannot resume dead coroutine", nargs);
662   L->nCcalls = (from) ? from->nCcalls + 1 : 1;
663   if (L->nCcalls >= LUAI_MAXCCALLS)
664     return resume_error(L, "C stack overflow", nargs);
665   luai_userstateresume(L, nargs);
666   L->nny = 0;  /* allow yields */
667   api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs);
668   status = luaD_rawrunprotected(L, resume, &nargs);
669   if (status == -1)  /* error calling 'lua_resume'? */
670     status = LUA_ERRRUN;
671   else {  /* continue running after recoverable errors */
672     while (errorstatus(status) && recover(L, status)) {
673       /* unroll continuation */
674       status = luaD_rawrunprotected(L, unroll, &status);
675     }
676     if (errorstatus(status)) {  /* unrecoverable error? */
677       L->status = cast_byte(status);  /* mark thread as 'dead' */
678       seterrorobj(L, status, L->top);  /* push error message */
679       L->ci->top = L->top;
680     }
681     else lua_assert(status == L->status);  /* normal end or yield */
682   }
683   L->nny = oldnny;  /* restore 'nny' */
684   L->nCcalls--;
685   lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));
686   lua_unlock(L);
687   return status;
688 }
689 
690 
691 LUA_API int lua_isyieldable (lua_State *L) {
692   return (L->nny == 0);
693 }
694 
695 
696 LUA_API int lua_yieldk (lua_State *L, int nresults, lua_KContext ctx,
697                         lua_KFunction k) {
698   CallInfo *ci = L->ci;
699   luai_userstateyield(L, nresults);
700   lua_lock(L);
701   api_checknelems(L, nresults);
702   if (L->nny > 0) {
703     if (L != G(L)->mainthread)
704       luaG_runerror(L, "attempt to yield across a C-call boundary");
705     else
706       luaG_runerror(L, "attempt to yield from outside a coroutine");
707   }
708   L->status = LUA_YIELD;
709   ci->extra = savestack(L, ci->func);  /* save current 'func' */
710   if (isLua(ci)) {  /* inside a hook? */
711     api_check(L, k == NULL, "hooks cannot continue after yielding");
712   }
713   else {
714     if ((ci->u.c.k = k) != NULL)  /* is there a continuation? */
715       ci->u.c.ctx = ctx;  /* save context */
716     ci->func = L->top - nresults - 1;  /* protect stack below results */
717     luaD_throw(L, LUA_YIELD);
718   }
719   lua_assert(ci->callstatus & CIST_HOOKED);  /* must be inside a hook */
720   lua_unlock(L);
721   return 0;  /* return to 'luaD_hook' */
722 }
723 
724 
725 int luaD_pcall (lua_State *L, Pfunc func, void *u,
726                 ptrdiff_t old_top, ptrdiff_t ef) {
727   int status;
728   CallInfo *old_ci = L->ci;
729   lu_byte old_allowhooks = L->allowhook;
730   unsigned short old_nny = L->nny;
731   ptrdiff_t old_errfunc = L->errfunc;
732   L->errfunc = ef;
733   status = luaD_rawrunprotected(L, func, u);
734   if (status != LUA_OK) {  /* an error occurred? */
735     StkId oldtop = restorestack(L, old_top);
736     luaF_close(L, oldtop);  /* close possible pending closures */
737     seterrorobj(L, status, oldtop);
738     L->ci = old_ci;
739     L->allowhook = old_allowhooks;
740     L->nny = old_nny;
741     luaD_shrinkstack(L);
742   }
743   L->errfunc = old_errfunc;
744   return status;
745 }
746 
747 
748 
749 /*
750 ** Execute a protected parser.
751 */
752 struct SParser {  /* data to 'f_parser' */
753   ZIO *z;
754   Mbuffer buff;  /* dynamic structure used by the scanner */
755   Dyndata dyd;  /* dynamic structures used by the parser */
756   const char *mode;
757   const char *name;
758 };
759 
760 
761 static void checkmode (lua_State *L, const char *mode, const char *x) {
762   if (mode && strchr(mode, x[0]) == NULL) {
763     luaO_pushfstring(L,
764        "attempt to load a %s chunk (mode is '%s')", x, mode);
765     luaD_throw(L, LUA_ERRSYNTAX);
766   }
767 }
768 
769 
770 static void f_parser (lua_State *L, void *ud) {
771   LClosure *cl;
772   struct SParser *p = cast(struct SParser *, ud);
773   int c = zgetc(p->z);  /* read first character */
774   if (c == LUA_SIGNATURE[0]) {
775     checkmode(L, p->mode, "binary");
776     cl = luaU_undump(L, p->z, p->name);
777   }
778   else {
779     checkmode(L, p->mode, "text");
780     cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
781   }
782   lua_assert(cl->nupvalues == cl->p->sizeupvalues);
783   luaF_initupvals(L, cl);
784 }
785 
786 
787 int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
788                                         const char *mode) {
789   struct SParser p;
790   int status;
791   L->nny++;  /* cannot yield during parsing */
792   p.z = z; p.name = name; p.mode = mode;
793   p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0;
794   p.dyd.gt.arr = NULL; p.dyd.gt.size = 0;
795   p.dyd.label.arr = NULL; p.dyd.label.size = 0;
796   luaZ_initbuffer(L, &p.buff);
797   status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
798   luaZ_freebuffer(L, &p.buff);
799   luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size);
800   luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size);
801   luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size);
802   L->nny--;
803   return status;
804 }
805 
806 
807