The Battle for Wesnoth  1.15.0-dev
ldo.cpp
Go to the documentation of this file.
1 /*
2 ** $Id: ldo.c,v 2.157 2016/12/13 15:52:21 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 {
87  volatile int status; /* error code */
88 };
89 
90 
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 
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 
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 */
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 
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);
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 
191 void luaD_growstack (lua_State *L, int n) {
192  int size = L->stacksize;
193  if (size > LUAI_MAXSTACK) /* error after extra size? */
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? */
202  luaG_runerror(L, "stack overflow");
203  }
204  else
205  luaD_reallocstack(L, newsize);
206  }
207 }
208 
209 
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 
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 
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 */
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 
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 
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 */
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 */
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 */
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 */
413 int luaD_precall (lua_State *L, StkId func, int nresults) {
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 */
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 
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 
688  return (L->nny == 0);
689 }
690 
691 
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 
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 
757 static void checkmode (lua_State *L, const char *mode, const char *x) {
758  if (mode && strchr(mode, x[0]) == NULL) {
760  "attempt to load a %s chunk (mode is '%s')", x, mode);
762  }
763 }
764 
765 
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 
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);
796  luaM_freearray(L, p.dyd.gt.arr, p.dyd.gt.size);
798  L->nny--;
799  return status;
800 }
801 
802 
#define LUA_HOOKCALL
Definition: lua.h:402
unsigned short callstatus
Definition: lstate.h:91
lu_byte allowhook
Definition: lstate.h:183
#define luaZ_freebuffer(L, buff)
Definition: lzio.h:44
const char * name
Definition: ldo.cpp:753
Definition: lua.h:441
#define LUA_TCCL
Definition: lobject.h:49
#define luaZ_initbuffer(L, buff)
Definition: lzio.h:29
ptrdiff_t errfunc
Definition: lstate.h:176
l_noret luaG_runerror(lua_State *L, const char *fmt,...)
Definition: ldebug.cpp:652
void luaF_close(lua_State *L, StkId level)
Definition: lfunc.cpp:83
void luaE_shrinkCI(lua_State *L)
Definition: lstate.cpp:137
LUA_KCONTEXT lua_KContext
Definition: lua.h:99
#define luaM_freearray(L, b, n)
Definition: lmem.h:43
void luaD_shrinkstack(lua_State *L)
Definition: ldo.cpp:221
#define LUA_TLCF
Definition: lobject.h:48
#define LUAI_TRY(L, c, a)
Definition: ldo.cpp:74
StkId stack
Definition: lstate.h:169
Definition: lobject.h:407
#define LUA_MULTRET
Definition: lua.h:34
#define setobjs2s
Definition: lobject.h:269
#define CIST_YPCALL
Definition: lstate.h:103
struct lua_longjmp * previous
Definition: ldo.cpp:85
static int resume_error(lua_State *L, const char *msg, int narg)
Definition: ldo.cpp:603
#define LUA_MASKRET
Definition: lua.h:413
#define LUA_HOOKTAILCALL
Definition: lua.h:406
#define fvalue(o)
Definition: lobject.h:174
Definition: ldo.cpp:748
static void resume(lua_State *L, void *ud)
Definition: ldo.cpp:619
#define LUA_MASKCALL
Definition: lua.h:412
Labellist gt
Definition: lparser.h:101
struct Dyndata::@8 actvar
#define CIST_TAIL
Definition: lstate.h:104
static void tryfuncTM(lua_State *L, StkId func)
Definition: ldo.cpp:315
#define ERRORSTACKSIZE
Definition: ldo.cpp:174
static CallInfo * findpcall(lua_State *L)
Definition: ldo.cpp:566
#define LUA_TLCL
Definition: lobject.h:47
StkId top
Definition: lstate.h:76
#define luai_userstateresume(L, n)
Definition: llimits.h:249
#define cast(t, exp)
Definition: llimits.h:111
#define ttisfunction(o)
Definition: lobject.h:152
int event
Definition: lua.h:442
#define cast_byte(i)
Definition: llimits.h:114
#define l_noret
Definition: llimits.h:143
#define setnilvalue(obj)
Definition: lobject.h:210
static StkId adjust_varargs(lua_State *L, Proto *p, int actual)
Definition: ldo.cpp:293
#define G(L)
Definition: lstate.h:187
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
Definition: debugger.cpp:109
#define lua_unlock(L)
Definition: llimits.h:215
struct CallInfo::@9::@10 l
Definition: ltm.h:42
#define luai_userstateyield(L, n)
Definition: llimits.h:253
#define clCvalue(o)
Definition: lobject.h:173
#define setobj2s
Definition: lobject.h:271
#define GET_OPCODE(i)
Definition: lopcodes.h:89
void luaE_freeCI(lua_State *L)
Definition: lstate.cpp:122
#define LUA_SIGNATURE
Definition: lua.h:31
#define LUAI_MAXSTACK
Definition: luaconf.h:724
static void callhook(lua_State *L, CallInfo *ci)
Definition: ldo.cpp:280
TString * luaS_new(lua_State *L, const char *str)
Definition: lstring.cpp:219
struct CallInfo * i_ci
Definition: lua.h:456
#define luaO_nilobject
Definition: lobject.h:525
StkId top
Definition: lstate.h:164
l_noret luaG_typeerror(lua_State *L, const TValue *o, const char *op)
Definition: ldebug.cpp:585
#define luaM_reallocvector(L, v, oldn, n, t)
Definition: lmem.h:56
#define luaS_newliteral(L, s)
Definition: lstring.h:20
const char * mode
Definition: ldo.cpp:752
StkId stack_last
Definition: lstate.h:168
#define restorestack(L, n)
Definition: ldo.h:33
#define lua_lock(L)
Definition: llimits.h:214
unsigned char lu_byte
Definition: llimits.h:35
ZIO * z
Definition: ldo.cpp:749
std::size_t size(const std::string &str)
Length in characters of a UTF-8 string.
Definition: unicode.cpp:86
Definition: lfunc.h:35
int luaD_precall(lua_State *L, StkId func, int nresults)
Definition: ldo.cpp:413
int(* lua_CFunction)(lua_State *L)
Definition: lua.h:105
struct lua_State * mainthread
Definition: lstate.h:148
#define LUA_HOOKRET
Definition: lua.h:403
TValue * v
Definition: lfunc.h:36
struct UpVal::@1::@2 open
unsigned short nny
Definition: lstate.h:180
Labeldesc * arr
Definition: lparser.h:88
int luaD_pcall(lua_State *L, Pfunc func, void *u, ptrdiff_t old_top, ptrdiff_t ef)
Definition: ldo.cpp:721
#define LUA_YIELD
Definition: lua.h:48
#define CIST_HOOKED
Definition: lstate.h:100
LClosure * luaU_undump(lua_State *L, ZIO *Z, const char *name)
Definition: lundump.cpp:258
unsigned short nCcalls
Definition: lstate.h:181
CallInfo * ci
Definition: lstate.h:166
lua_CFunction panic
Definition: lstate.h:147
int size
Definition: lparser.h:90
#define luai_jmpbuf
Definition: ldo.cpp:75
#define api_incr_top(L)
Definition: lapi.h:14
#define clLvalue(o)
Definition: lobject.h:172
#define luaD_checkstack(L, n)
Definition: ldo.h:28
int(* lua_KFunction)(lua_State *L, int status, lua_KContext ctx)
Definition: lua.h:110
void luaD_growstack(lua_State *L, int n)
Definition: ldo.cpp:191
int luaD_protectedparser(lua_State *L, ZIO *z, const char *name, const char *mode)
Definition: ldo.cpp:783
#define LUA_API
Definition: luaconf.h:254
StkId func
Definition: lstate.h:75
void(* Pfunc)(lua_State *L, void *ud)
Definition: ldo.h:37
if(win_locale=="af") win_locale
union CallInfo::@9 u
Vardesc * arr
Definition: lparser.h:97
l_signalT hookmask
Definition: lstate.h:182
static int moveresults(lua_State *L, const TValue *firstResult, StkId res, int nres, int wanted)
Definition: ldo.cpp:334
static int stackinuse(lua_State *L)
Definition: ldo.cpp:210
Instruction * code
Definition: lobject.h:421
CallInfo base_ci
Definition: lstate.h:174
void luaD_hook(lua_State *L, int event, int line)
Definition: ldo.cpp:253
static void correctstack(lua_State *L, TValue *oldstack)
Definition: ldo.cpp:158
Dyndata dyd
Definition: ldo.cpp:751
Labellist label
Definition: lparser.h:102
static void seterrorobj(lua_State *L, int errcode, StkId oldtop)
Definition: ldo.cpp:91
lu_byte maxstacksize
Definition: lobject.h:411
#define api_checknelems(L, n)
Definition: lapi.h:20
l_noret luaD_throw(lua_State *L, int errcode)
Definition: ldo.cpp:110
const TValue * luaT_gettmbyobj(lua_State *L, const TValue *o, TMS event)
Definition: ltm.cpp:70
#define LUA_ERRERR
Definition: lua.h:53
#define zgetc(z)
Definition: lzio.h:20
Definition: lzio.h:55
#define lua_assert(c)
Definition: llimits.h:89
std::size_t i
Definition: function.cpp:933
mock_party p
double g
Definition: astarsearch.cpp:63
short nresults
Definition: lstate.h:90
#define errorstatus(s)
Definition: ldo.cpp:38
#define LUA_ERRSYNTAX
Definition: lua.h:50
UpVal * openupval
Definition: lstate.h:170
static void checkmode(lua_State *L, const char *mode, const char *x)
Definition: ldo.cpp:757
lu_byte is_vararg
Definition: lobject.h:410
#define CIST_LUA
Definition: lstate.h:99
#define checkstackp(L, n, p)
Definition: ldo.cpp:399
#define LUA_MINSTACK
Definition: lua.h:79
void luaD_call(lua_State *L, StkId func, int nResults)
Definition: ldo.cpp:495
#define LUA_ERRMEM
Definition: lua.h:51
#define LUAI_MAXCCALLS
Definition: llimits.h:153
#define LUAI_THROW(L, c)
Definition: ldo.cpp:73
LUA_API int lua_resume(lua_State *L, lua_State *from, int nargs)
Definition: ldo.cpp:648
const char * luaO_pushfstring(lua_State *L, const char *fmt,...)
Definition: lobject.cpp:467
int luaD_rawrunprotected(lua_State *L, Pfunc f, void *ud)
Definition: ldo.cpp:136
#define next_ci(L)
Definition: ldo.cpp:395
LUA_API int lua_isyieldable(lua_State *L)
Definition: ldo.cpp:687
void luaD_callnoyield(lua_State *L, StkId func, int nResults)
Definition: ldo.cpp:507
#define savestack(L, p)
Definition: ldo.h:32
void luaV_execute(lua_State *L)
Definition: lvm.cpp:786
void luaF_initupvals(lua_State *L, LClosure *cl)
Definition: lfunc.cpp:45
#define ttype(o)
Definition: lobject.h:133
Mbuffer buff
Definition: ldo.cpp:750
union UpVal::@1 u
LUA_API int lua_yieldk(lua_State *L, int nresults, lua_KContext ctx, lua_KFunction k)
Definition: ldo.cpp:692
int luaD_poscall(lua_State *L, CallInfo *ci, StkId firstResult, int nres)
Definition: ldo.cpp:376
#define api_check(l, e, msg)
Definition: llimits.h:101
#define f
struct CallInfo * previous
Definition: lstate.h:77
#define LUA_OK
Definition: lua.h:47
static int recover(lua_State *L, int status)
Definition: ldo.cpp:581
void(* lua_Hook)(lua_State *L, lua_Debug *ar)
Definition: lua.h:421
#define getoah(st)
Definition: lstate.h:113
#define condmovestack(L, pre, pos)
Definition: llimits.h:309
#define cast_int(i)
Definition: llimits.h:116
int stacksize
Definition: lstate.h:177
static void finishCcall(lua_State *L, int status)
Definition: ldo.cpp:518
struct Proto * p
Definition: lobject.h:455
static void unroll(lua_State *L, void *ud)
Definition: ldo.cpp:548
static void stackerror(lua_State *L)
Definition: ldo.cpp:481
ptrdiff_t extra
Definition: lstate.h:89
Definition: lzio.h:23
int currentline
Definition: lua.h:447
int sizeupvalues
Definition: lobject.h:412
volatile lua_Hook hook
Definition: lstate.h:175
void luaD_reallocstack(lua_State *L, int newsize)
Definition: ldo.cpp:177
void luaD_inctop(lua_State *L)
Definition: ldo.cpp:240
mock_char c
const Instruction * oldpc
Definition: lstate.h:167
luai_jmpbuf b
Definition: ldo.cpp:86
#define setsvalue2s
Definition: lobject.h:272
void luaV_finishOp(lua_State *L)
Definition: lvm.cpp:656
static map_location::DIRECTION n
int size
Definition: lparser.h:99
LClosure * luaY_parser(lua_State *L, ZIO *z, Mbuffer *buff, Dyndata *dyd, const char *name, int firstchar)
Definition: lparser.cpp:1626
#define isLua(ci)
Definition: lstate.h:109
volatile int status
Definition: ldo.cpp:87
#define LUA_ERRRUN
Definition: lua.h:49
#define LUA_MASKLINE
Definition: lua.h:414
lu_byte numparams
Definition: lobject.h:409
static void f_parser(lua_State *L, void *ud)
Definition: ldo.cpp:766
struct lua_longjmp * errorJmp
Definition: lstate.h:173
lu_byte status
Definition: lstate.h:163
#define EXTRA_STACK
Definition: lstate.h:47
struct CallInfo::@9::@11 c
#define adjustresults(L, nres)
Definition: lapi.h:17