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