1 /*
2 ** $Id: ldo.c,v 2.108 2012/10/01 14:05:04 roberto Exp $
3 ** Stack and Call structure of Lua
4 ** See Copyright Notice in lua.h
5 */
6 
7 
8 #include <setjmp.h>
9 #include <stdlib.h>
10 #include <string.h>
11 
12 #define ldo_c
13 #define LUA_CORE
14 
15 #include "lua.h"
16 
17 #include "lapi.h"
18 #include "ldebug.h"
19 #include "ldo.h"
20 #include "lfunc.h"
21 #include "lgc.h"
22 #include "lmem.h"
23 #include "lobject.h"
24 #include "lopcodes.h"
25 #include "lparser.h"
26 #include "lstate.h"
27 #include "lstring.h"
28 #include "ltable.h"
29 #include "ltm.h"
30 #include "lundump.h"
31 #include "lvm.h"
32 #include "lzio.h"
33 
34 
35 
36 
37 /*
38 ** {======================================================
39 ** Error-recovery functions
40 ** =======================================================
41 */
42 
43 /*
44 ** LUAI_THROW/LUAI_TRY define how Lua does exception handling. By
45 ** default, Lua handles errors with exceptions when compiling as
46 ** C++ code, with _longjmp/_setjmp when asked to use them, and with
47 ** longjmp/setjmp otherwise.
48 */
49 #if !defined(LUAI_THROW)
50 
51 #if defined(__cplusplus) && !defined(LUA_USE_LONGJMP)
52 /* C++ exceptions */
53 #define LUAI_THROW(L,c)		throw(c)
54 #define LUAI_TRY(L,c,a) \
55 	try { a } catch(...) { if ((c)->status == 0) (c)->status = -1; }
56 #define luai_jmpbuf		int  /* dummy variable */
57 
58 #elif defined(LUA_USE_ULONGJMP)
59 /* in Unix, try _longjmp/_setjmp (more efficient) */
60 #define LUAI_THROW(L,c)		_longjmp((c)->b, 1)
61 #define LUAI_TRY(L,c,a)		if (_setjmp((c)->b) == 0) { a }
62 #define luai_jmpbuf		jmp_buf
63 
64 #else
65 /* default handling with long jumps */
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 #endif
71 
72 #endif
73 
74 
75 
76 /* chain list of long jump buffers */
77 struct lua_longjmp {
78   struct lua_longjmp *previous;
79   luai_jmpbuf b;
80   volatile int status;  /* error code */
81 };
82 
83 
seterrorobj(lua_State * L,int errcode,StkId oldtop)84 static void seterrorobj (lua_State *L, int errcode, StkId oldtop) {
85   switch (errcode) {
86     case LUA_ERRMEM: {  /* memory error? */
87       setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */
88       break;
89     }
90     case LUA_ERRERR: {
91       setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
92       break;
93     }
94     default: {
95       setobjs2s(L, oldtop, L->top - 1);  /* error message on current top */
96       break;
97     }
98   }
99   L->top = oldtop + 1;
100 }
101 
102 
luaD_throw(lua_State * L,int errcode)103 l_noret luaD_throw (lua_State *L, int errcode) {
104   if (L->errorJmp) {  /* thread has an error handler? */
105     L->errorJmp->status = errcode;  /* set status */
106     LUAI_THROW(L, L->errorJmp);  /* jump to it */
107   }
108   else {  /* thread has no error handler */
109     L->status = cast_byte(errcode);  /* mark it as dead */
110     if (G(L)->mainthread->errorJmp) {  /* main thread has a handler? */
111       setobjs2s(L, G(L)->mainthread->top++, L->top - 1);  /* copy error obj. */
112       luaD_throw(G(L)->mainthread, errcode);  /* re-throw in main thread */
113     }
114     else {  /* no handler at all; abort */
115       if (G(L)->panic) {  /* panic function? */
116         lua_unlock(L);
117         G(L)->panic(L);  /* call it (last chance to jump out) */
118       }
119       abort();
120     }
121   }
122 }
123 
124 
luaD_rawrunprotected(lua_State * L,Pfunc f,void * ud)125 int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
126   unsigned short oldnCcalls = L->nCcalls;
127   struct lua_longjmp lj;
128   lj.status = LUA_OK;
129   lj.previous = L->errorJmp;  /* chain new error handler */
130   L->errorJmp = &lj;
131   LUAI_TRY(L, &lj,
132     (*f)(L, ud);
133   );
134   L->errorJmp = lj.previous;  /* restore old error handler */
135   L->nCcalls = oldnCcalls;
136   return lj.status;
137 }
138 
139 /* }====================================================== */
140 
141 
correctstack(lua_State * L,TValue * oldstack)142 static void correctstack (lua_State *L, TValue *oldstack) {
143   CallInfo *ci;
144   GCObject *up;
145   L->top = (L->top - oldstack) + L->stack;
146   for (up = L->openupval; up != NULL; up = up->gch.next)
147     gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;
148   for (ci = L->ci; ci != NULL; ci = ci->previous) {
149     ci->top = (ci->top - oldstack) + L->stack;
150     ci->func = (ci->func - oldstack) + L->stack;
151     if (isLua(ci))
152       ci->u.l.base = (ci->u.l.base - oldstack) + L->stack;
153   }
154 }
155 
156 
157 /* some space for error handling */
158 #define ERRORSTACKSIZE	(LUAI_MAXSTACK + 200)
159 
160 
luaD_reallocstack(lua_State * L,int newsize)161 void luaD_reallocstack (lua_State *L, int newsize) {
162   TValue *oldstack = L->stack;
163   int lim = L->stacksize;
164   lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE);
165   lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK);
166   luaM_reallocvector(L, L->stack, L->stacksize, newsize, TValue);
167   for (; lim < newsize; lim++)
168     setnilvalue(L->stack + lim); /* erase new segment */
169   L->stacksize = newsize;
170   L->stack_last = L->stack + newsize - EXTRA_STACK;
171   correctstack(L, oldstack);
172 }
173 
174 
luaD_growstack(lua_State * L,int n)175 void luaD_growstack (lua_State *L, int n) {
176   int size = L->stacksize;
177   if (size > LUAI_MAXSTACK)  /* error after extra size? */
178     luaD_throw(L, LUA_ERRERR);
179   else {
180     int needed = cast_int(L->top - L->stack) + n + EXTRA_STACK;
181     int newsize = 2 * size;
182     if (newsize > LUAI_MAXSTACK) newsize = LUAI_MAXSTACK;
183     if (newsize < needed) newsize = needed;
184     if (newsize > LUAI_MAXSTACK) {  /* stack overflow? */
185       luaD_reallocstack(L, ERRORSTACKSIZE);
186       luaG_runerror(L, "stack overflow");
187     }
188     else
189       luaD_reallocstack(L, newsize);
190   }
191 }
192 
193 
stackinuse(lua_State * L)194 static int stackinuse (lua_State *L) {
195   CallInfo *ci;
196   StkId lim = L->top;
197   for (ci = L->ci; ci != NULL; ci = ci->previous) {
198     lua_assert(ci->top <= L->stack_last);
199     if (lim < ci->top) lim = ci->top;
200   }
201   return cast_int(lim - L->stack) + 1;  /* part of stack in use */
202 }
203 
204 
luaD_shrinkstack(lua_State * L)205 void luaD_shrinkstack (lua_State *L) {
206   int inuse = stackinuse(L);
207   int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;
208   if (goodsize > LUAI_MAXSTACK) goodsize = LUAI_MAXSTACK;
209   if (inuse > LUAI_MAXSTACK ||  /* handling stack overflow? */
210       goodsize >= L->stacksize)  /* would grow instead of shrink? */
211     condmovestack(L);  /* don't change stack (change only for debugging) */
212   else
213     luaD_reallocstack(L, goodsize);  /* shrink it */
214 }
215 
216 
luaD_hook(lua_State * L,int event,int line)217 void luaD_hook (lua_State *L, int event, int line) {
218   lua_Hook hook = L->hook;
219   if (hook && L->allowhook) {
220     CallInfo *ci = L->ci;
221     ptrdiff_t top = savestack(L, L->top);
222     ptrdiff_t ci_top = savestack(L, ci->top);
223     lua_Debug ar;
224     ar.event = event;
225     ar.currentline = line;
226     ar.i_ci = ci;
227     luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
228     ci->top = L->top + LUA_MINSTACK;
229     lua_assert(ci->top <= L->stack_last);
230     L->allowhook = 0;  /* cannot call hooks inside a hook */
231     ci->callstatus |= CIST_HOOKED;
232     lua_unlock(L);
233     (*hook)(L, &ar);
234     lua_lock(L);
235     lua_assert(!L->allowhook);
236     L->allowhook = 1;
237     ci->top = restorestack(L, ci_top);
238     L->top = restorestack(L, top);
239     ci->callstatus &= ~CIST_HOOKED;
240   }
241 }
242 
243 
callhook(lua_State * L,CallInfo * ci)244 static void callhook (lua_State *L, CallInfo *ci) {
245   int hook = LUA_HOOKCALL;
246   ci->u.l.savedpc++;  /* hooks assume 'pc' is already incremented */
247   if (isLua(ci->previous) &&
248       GET_OPCODE(*(ci->previous->u.l.savedpc - 1)) == OP_TAILCALL) {
249     ci->callstatus |= CIST_TAIL;
250     hook = LUA_HOOKTAILCALL;
251   }
252   luaD_hook(L, hook, -1);
253   ci->u.l.savedpc--;  /* correct 'pc' */
254 }
255 
256 
adjust_varargs(lua_State * L,Proto * p,int actual)257 static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {
258   int i;
259   int nfixargs = p->numparams;
260   StkId base, fixed;
261   lua_assert(actual >= nfixargs);
262   /* move fixed parameters to final position */
263   fixed = L->top - actual;  /* first fixed argument */
264   base = L->top;  /* final position of first argument */
265   for (i=0; i<nfixargs; i++) {
266     setobjs2s(L, L->top++, fixed + i);
267     setnilvalue(fixed + i);
268   }
269   return base;
270 }
271 
272 
tryfuncTM(lua_State * L,StkId func)273 static StkId tryfuncTM (lua_State *L, StkId func) {
274   const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
275   StkId p;
276   ptrdiff_t funcr = savestack(L, func);
277   if (!ttisfunction(tm))
278     luaG_typeerror(L, func, "call");
279   /* Open a hole inside the stack at `func' */
280   for (p = L->top; p > func; p--) setobjs2s(L, p, p-1);
281   incr_top(L);
282   func = restorestack(L, funcr);  /* previous call may change stack */
283   setobj2s(L, func, tm);  /* tag method is the new function to be called */
284   return func;
285 }
286 
287 
288 
289 #define next_ci(L) (L->ci = (L->ci->next ? L->ci->next : luaE_extendCI(L)))
290 
291 
292 /*
293 ** returns true if function has been executed (C function)
294 */
luaD_precall(lua_State * L,StkId func,int nresults)295 int luaD_precall (lua_State *L, StkId func, int nresults) {
296   lua_CFunction f;
297   CallInfo *ci;
298   int n;  /* number of arguments (Lua) or returns (C) */
299   ptrdiff_t funcr = savestack(L, func);
300   switch (ttype(func)) {
301     case LUA_TLCF:  /* light C function */
302       f = fvalue(func);
303       goto Cfunc;
304     case LUA_TCCL: {  /* C closure */
305       f = clCvalue(func)->f;
306      Cfunc:
307       luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
308       ci = next_ci(L);  /* now 'enter' new function */
309       ci->nresults = nresults;
310       ci->func = restorestack(L, funcr);
311       ci->top = L->top + LUA_MINSTACK;
312       lua_assert(ci->top <= L->stack_last);
313       ci->callstatus = 0;
314       luaC_checkGC(L);  /* stack grow uses memory */
315       if (L->hookmask & LUA_MASKCALL)
316         luaD_hook(L, LUA_HOOKCALL, -1);
317       lua_unlock(L);
318       n = (*f)(L);  /* do the actual call */
319       lua_lock(L);
320       api_checknelems(L, n);
321       luaD_poscall(L, L->top - n);
322       return 1;
323     }
324     case LUA_TLCL: {  /* Lua function: prepare its call */
325       StkId base;
326       Proto *p = clLvalue(func)->p;
327       luaD_checkstack(L, p->maxstacksize);
328       func = restorestack(L, funcr);
329       n = cast_int(L->top - func) - 1;  /* number of real arguments */
330       for (; n < p->numparams; n++)
331         setnilvalue(L->top++);  /* complete missing arguments */
332       base = (!p->is_vararg) ? func + 1 : adjust_varargs(L, p, n);
333       ci = next_ci(L);  /* now 'enter' new function */
334       ci->nresults = nresults;
335       ci->func = func;
336       ci->u.l.base = base;
337       ci->top = base + p->maxstacksize;
338       lua_assert(ci->top <= L->stack_last);
339       ci->u.l.savedpc = p->code;  /* starting point */
340       ci->callstatus = CIST_LUA;
341       L->top = ci->top;
342       luaC_checkGC(L);  /* stack grow uses memory */
343       if (L->hookmask & LUA_MASKCALL)
344         callhook(L, ci);
345       return 0;
346     }
347     default: {  /* not a function */
348       func = tryfuncTM(L, func);  /* retry with 'function' tag method */
349       return luaD_precall(L, func, nresults);  /* now it must be a function */
350     }
351   }
352 }
353 
354 
luaD_poscall(lua_State * L,StkId firstResult)355 int luaD_poscall (lua_State *L, StkId firstResult) {
356   StkId res;
357   int wanted, i;
358   CallInfo *ci = L->ci;
359   if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) {
360     if (L->hookmask & LUA_MASKRET) {
361       ptrdiff_t fr = savestack(L, firstResult);  /* hook may change stack */
362       luaD_hook(L, LUA_HOOKRET, -1);
363       firstResult = restorestack(L, fr);
364     }
365     L->oldpc = ci->previous->u.l.savedpc;  /* 'oldpc' for caller function */
366   }
367   res = ci->func;  /* res == final position of 1st result */
368   wanted = ci->nresults;
369   L->ci = ci = ci->previous;  /* back to caller */
370   /* move results to correct place */
371   for (i = wanted; i != 0 && firstResult < L->top; i--)
372     setobjs2s(L, res++, firstResult++);
373   while (i-- > 0)
374     setnilvalue(res++);
375   L->top = res;
376   return (wanted - LUA_MULTRET);  /* 0 iff wanted == LUA_MULTRET */
377 }
378 
379 
380 /*
381 ** Call a function (C or Lua). The function to be called is at *func.
382 ** The arguments are on the stack, right after the function.
383 ** When returns, all the results are on the stack, starting at the original
384 ** function position.
385 */
luaD_call(lua_State * L,StkId func,int nResults,int allowyield)386 void luaD_call (lua_State *L, StkId func, int nResults, int allowyield) {
387   if (++L->nCcalls >= LUAI_MAXCCALLS) {
388     if (L->nCcalls == LUAI_MAXCCALLS)
389       luaG_runerror(L, "C stack overflow");
390     else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
391       luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
392   }
393   if (!allowyield) L->nny++;
394   if (!luaD_precall(L, func, nResults))  /* is a Lua function? */
395     luaV_execute(L);  /* call it */
396   if (!allowyield) L->nny--;
397   L->nCcalls--;
398 }
399 
400 
finishCcall(lua_State * L)401 static void finishCcall (lua_State *L) {
402   CallInfo *ci = L->ci;
403   int n;
404   lua_assert(ci->u.c.k != NULL);  /* must have a continuation */
405   lua_assert(L->nny == 0);
406   if (ci->callstatus & CIST_YPCALL) {  /* was inside a pcall? */
407     ci->callstatus &= ~CIST_YPCALL;  /* finish 'lua_pcall' */
408     L->errfunc = ci->u.c.old_errfunc;
409   }
410   /* finish 'lua_callk'/'lua_pcall' */
411   adjustresults(L, ci->nresults);
412   /* call continuation function */
413   if (!(ci->callstatus & CIST_STAT))  /* no call status? */
414     ci->u.c.status = LUA_YIELD;  /* 'default' status */
415   lua_assert(ci->u.c.status != LUA_OK);
416   ci->callstatus = (ci->callstatus & ~(CIST_YPCALL | CIST_STAT)) | CIST_YIELDED;
417   lua_unlock(L);
418   n = (*ci->u.c.k)(L);
419   lua_lock(L);
420   api_checknelems(L, n);
421   /* finish 'luaD_precall' */
422   luaD_poscall(L, L->top - n);
423 }
424 
425 
unroll(lua_State * L,void * ud)426 static void unroll (lua_State *L, void *ud) {
427   UNUSED(ud);
428   for (;;) {
429     if (L->ci == &L->base_ci)  /* stack is empty? */
430       return;  /* coroutine finished normally */
431     if (!isLua(L->ci))  /* C function? */
432       finishCcall(L);
433     else {  /* Lua function */
434       luaV_finishOp(L);  /* finish interrupted instruction */
435       luaV_execute(L);  /* execute down to higher C 'boundary' */
436     }
437   }
438 }
439 
440 
441 /*
442 ** check whether thread has a suspended protected call
443 */
findpcall(lua_State * L)444 static CallInfo *findpcall (lua_State *L) {
445   CallInfo *ci;
446   for (ci = L->ci; ci != NULL; ci = ci->previous) {  /* search for a pcall */
447     if (ci->callstatus & CIST_YPCALL)
448       return ci;
449   }
450   return NULL;  /* no pending pcall */
451 }
452 
453 
recover(lua_State * L,int status)454 static int recover (lua_State *L, int status) {
455   StkId oldtop;
456   CallInfo *ci = findpcall(L);
457   if (ci == NULL) return 0;  /* no recovery point */
458   /* "finish" luaD_pcall */
459   oldtop = restorestack(L, ci->extra);
460   luaF_close(L, oldtop);
461   seterrorobj(L, status, oldtop);
462   L->ci = ci;
463   L->allowhook = ci->u.c.old_allowhook;
464   L->nny = 0;  /* should be zero to be yieldable */
465   luaD_shrinkstack(L);
466   L->errfunc = ci->u.c.old_errfunc;
467   ci->callstatus |= CIST_STAT;  /* call has error status */
468   ci->u.c.status = status;  /* (here it is) */
469   return 1;  /* continue running the coroutine */
470 }
471 
472 
473 /*
474 ** signal an error in the call to 'resume', not in the execution of the
475 ** coroutine itself. (Such errors should not be handled by any coroutine
476 ** error handler and should not kill the coroutine.)
477 */
resume_error(lua_State * L,const char * msg,StkId firstArg)478 static l_noret resume_error (lua_State *L, const char *msg, StkId firstArg) {
479   L->top = firstArg;  /* remove args from the stack */
480   setsvalue2s(L, L->top, luaS_new(L, msg));  /* push error message */
481   api_incr_top(L);
482   luaD_throw(L, -1);  /* jump back to 'lua_resume' */
483 }
484 
485 
486 /*
487 ** do the work for 'lua_resume' in protected mode
488 */
resume(lua_State * L,void * ud)489 static void resume (lua_State *L, void *ud) {
490   int nCcalls = L->nCcalls;
491   StkId firstArg = cast(StkId, ud);
492   CallInfo *ci = L->ci;
493   if (nCcalls >= LUAI_MAXCCALLS)
494     resume_error(L, "C stack overflow", firstArg);
495   if (L->status == LUA_OK) {  /* may be starting a coroutine */
496     if (ci != &L->base_ci)  /* not in base level? */
497       resume_error(L, "cannot resume non-suspended coroutine", firstArg);
498     /* coroutine is in base level; start running it */
499     if (!luaD_precall(L, firstArg - 1, LUA_MULTRET))  /* Lua function? */
500       luaV_execute(L);  /* call it */
501   }
502   else if (L->status != LUA_YIELD)
503     resume_error(L, "cannot resume dead coroutine", firstArg);
504   else {  /* resuming from previous yield */
505     L->status = LUA_OK;
506     ci->func = restorestack(L, ci->extra);
507     if (isLua(ci))  /* yielded inside a hook? */
508       luaV_execute(L);  /* just continue running Lua code */
509     else {  /* 'common' yield */
510       if (ci->u.c.k != NULL) {  /* does it have a continuation? */
511         int n;
512         ci->u.c.status = LUA_YIELD;  /* 'default' status */
513         ci->callstatus |= CIST_YIELDED;
514         lua_unlock(L);
515         n = (*ci->u.c.k)(L);  /* call continuation */
516         lua_lock(L);
517         api_checknelems(L, n);
518         firstArg = L->top - n;  /* yield results come from continuation */
519       }
520       luaD_poscall(L, firstArg);  /* finish 'luaD_precall' */
521     }
522     unroll(L, NULL);
523   }
524   lua_assert(nCcalls == L->nCcalls);
525 }
526 
527 
lua_resume(lua_State * L,lua_State * from,int nargs)528 LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
529   int status;
530   lua_lock(L);
531   luai_userstateresume(L, nargs);
532   L->nCcalls = (from) ? from->nCcalls + 1 : 1;
533   L->nny = 0;  /* allow yields */
534   api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs);
535   status = luaD_rawrunprotected(L, resume, L->top - nargs);
536   if (status == -1)  /* error calling 'lua_resume'? */
537     status = LUA_ERRRUN;
538   else {  /* yield or regular error */
539     while (status != LUA_OK && status != LUA_YIELD) {  /* error? */
540       if (recover(L, status))  /* recover point? */
541         status = luaD_rawrunprotected(L, unroll, NULL);  /* run continuation */
542       else {  /* unrecoverable error */
543         L->status = cast_byte(status);  /* mark thread as `dead' */
544         seterrorobj(L, status, L->top);
545         L->ci->top = L->top;
546         break;
547       }
548     }
549     lua_assert(status == L->status);
550   }
551   L->nny = 1;  /* do not allow yields */
552   L->nCcalls--;
553   lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));
554   lua_unlock(L);
555   return status;
556 }
557 
558 
lua_yieldk(lua_State * L,int nresults,int ctx,lua_CFunction k)559 LUA_API int lua_yieldk (lua_State *L, int nresults, int ctx, lua_CFunction k) {
560   CallInfo *ci = L->ci;
561   luai_userstateyield(L, nresults);
562   lua_lock(L);
563   api_checknelems(L, nresults);
564   if (L->nny > 0) {
565     if (L != G(L)->mainthread)
566       luaG_runerror(L, "attempt to yield across a C-call boundary");
567     else
568       luaG_runerror(L, "attempt to yield from outside a coroutine");
569   }
570   L->status = LUA_YIELD;
571   ci->extra = savestack(L, ci->func);  /* save current 'func' */
572   if (isLua(ci)) {  /* inside a hook? */
573     api_check(L, k == NULL, "hooks cannot continue after yielding");
574   }
575   else {
576     if ((ci->u.c.k = k) != NULL)  /* is there a continuation? */
577       ci->u.c.ctx = ctx;  /* save context */
578     ci->func = L->top - nresults - 1;  /* protect stack below results */
579     luaD_throw(L, LUA_YIELD);
580   }
581   lua_assert(ci->callstatus & CIST_HOOKED);  /* must be inside a hook */
582   lua_unlock(L);
583   return 0;  /* return to 'luaD_hook' */
584 }
585 
586 
luaD_pcall(lua_State * L,Pfunc func,void * u,ptrdiff_t old_top,ptrdiff_t ef)587 int luaD_pcall (lua_State *L, Pfunc func, void *u,
588                 ptrdiff_t old_top, ptrdiff_t ef) {
589   int status;
590   CallInfo *old_ci = L->ci;
591   lu_byte old_allowhooks = L->allowhook;
592   unsigned short old_nny = L->nny;
593   ptrdiff_t old_errfunc = L->errfunc;
594   L->errfunc = ef;
595   status = luaD_rawrunprotected(L, func, u);
596   if (status != LUA_OK) {  /* an error occurred? */
597     StkId oldtop = restorestack(L, old_top);
598     luaF_close(L, oldtop);  /* close possible pending closures */
599     seterrorobj(L, status, oldtop);
600     L->ci = old_ci;
601     L->allowhook = old_allowhooks;
602     L->nny = old_nny;
603     luaD_shrinkstack(L);
604   }
605   L->errfunc = old_errfunc;
606   return status;
607 }
608 
609 
610 
611 /*
612 ** Execute a protected parser.
613 */
614 struct SParser {  /* data to `f_parser' */
615   ZIO *z;
616   Mbuffer buff;  /* dynamic structure used by the scanner */
617   Dyndata dyd;  /* dynamic structures used by the parser */
618   const char *mode;
619   const char *name;
620 };
621 
622 
checkmode(lua_State * L,const char * mode,const char * x)623 static void checkmode (lua_State *L, const char *mode, const char *x) {
624   if (mode && strchr(mode, x[0]) == NULL) {
625     luaO_pushfstring(L,
626        "attempt to load a %s chunk (mode is " LUA_QS ")", x, mode);
627     luaD_throw(L, LUA_ERRSYNTAX);
628   }
629 }
630 
631 
f_parser(lua_State * L,void * ud)632 static void f_parser (lua_State *L, void *ud) {
633   int i;
634   Closure *cl;
635   struct SParser *p = cast(struct SParser *, ud);
636   int c = zgetc(p->z);  /* read first character */
637   if (c == LUA_SIGNATURE[0]) {
638     checkmode(L, p->mode, "binary");
639     cl = luaU_undump(L, p->z, &p->buff, p->name);
640   }
641   else {
642     checkmode(L, p->mode, "text");
643     cl = luaY_parser(L, p->z, &p->buff, &p->dyd, p->name, c);
644   }
645   lua_assert(cl->l.nupvalues == cl->l.p->sizeupvalues);
646   for (i = 0; i < cl->l.nupvalues; i++) {  /* initialize upvalues */
647     UpVal *up = luaF_newupval(L);
648     cl->l.upvals[i] = up;
649     luaC_objbarrier(L, cl, up);
650   }
651 }
652 
653 
luaD_protectedparser(lua_State * L,ZIO * z,const char * name,const char * mode)654 int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
655                                         const char *mode) {
656   struct SParser p;
657   int status;
658   L->nny++;  /* cannot yield during parsing */
659   p.z = z; p.name = name; p.mode = mode;
660   p.dyd.actvar.arr = NULL; p.dyd.actvar.size = 0;
661   p.dyd.gt.arr = NULL; p.dyd.gt.size = 0;
662   p.dyd.label.arr = NULL; p.dyd.label.size = 0;
663   luaZ_initbuffer(L, &p.buff);
664   status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
665   luaZ_freebuffer(L, &p.buff);
666   luaM_freearray(L, p.dyd.actvar.arr, p.dyd.actvar.size);
667   luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size);
668   luaM_freearray(L, p.dyd.label.arr, p.dyd.label.size);
669   L->nny--;
670   return status;
671 }
672