Line data Source code
1 : /*
2 : ** $Id: ldo.c,v 2.38.1.4 2012/01/18 02:27:10 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 "ldebug.h"
18 : #include "ldo.h"
19 : #include "lfunc.h"
20 : #include "lgc.h"
21 : #include "lmem.h"
22 : #include "lobject.h"
23 : #include "lopcodes.h"
24 : #include "lparser.h"
25 : #include "lstate.h"
26 : #include "lstring.h"
27 : #include "ltable.h"
28 : #include "ltm.h"
29 : #include "lundump.h"
30 : #include "lvm.h"
31 : #include "lzio.h"
32 :
33 :
34 :
35 :
36 : /*
37 : ** {======================================================
38 : ** Error-recovery functions
39 : ** =======================================================
40 : */
41 :
42 :
43 : /* chain list of long jump buffers */
44 : struct lua_longjmp {
45 : struct lua_longjmp *previous;
46 : luai_jmpbuf b;
47 : volatile int status; /* error code */
48 : };
49 :
50 :
51 373 : void luaD_seterrorobj (lua_State *L, int errcode, StkId oldtop) {
52 373 : switch (errcode) {
53 0 : case LUA_ERRMEM: {
54 0 : setsvalue2s(L, oldtop, luaS_newliteral(L, MEMERRMSG));
55 0 : break;
56 : }
57 1 : case LUA_ERRERR: {
58 1 : setsvalue2s(L, oldtop, luaS_newliteral(L, "error in error handling"));
59 1 : break;
60 : }
61 372 : case LUA_ERRSYNTAX:
62 : case LUA_ERRRUN: {
63 372 : setobjs2s(L, oldtop, L->top - 1); /* error message on current top */
64 372 : break;
65 : }
66 : }
67 373 : L->top = oldtop + 1;
68 373 : }
69 :
70 :
71 372 : static void restore_stack_limit (lua_State *L) {
72 : lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
73 372 : if (L->size_ci > LUAI_MAXCALLS) { /* there was an overflow? */
74 0 : int inuse = cast_int(L->ci - L->base_ci);
75 0 : if (inuse + 1 < LUAI_MAXCALLS) /* can `undo' overflow? */
76 0 : luaD_reallocCI(L, LUAI_MAXCALLS);
77 : }
78 372 : }
79 :
80 :
81 0 : static void resetstack (lua_State *L, int status) {
82 0 : L->ci = L->base_ci;
83 0 : L->base = L->ci->base;
84 0 : luaF_close(L, L->base); /* close eventual pending closures */
85 0 : luaD_seterrorobj(L, status, L->base);
86 0 : L->nCcalls = L->baseCcalls;
87 0 : L->allowhook = 1;
88 0 : restore_stack_limit(L);
89 0 : L->errfunc = 0;
90 0 : L->errorJmp = NULL;
91 0 : }
92 :
93 :
94 373 : void luaD_throw (lua_State *L, int errcode) {
95 373 : if (L->errorJmp) {
96 373 : L->errorJmp->status = errcode;
97 373 : LUAI_THROW(L, L->errorJmp);
98 : }
99 : else {
100 0 : L->status = cast_byte(errcode);
101 0 : if (G(L)->panic) {
102 0 : resetstack(L, errcode);
103 : lua_unlock(L);
104 0 : G(L)->panic(L);
105 : }
106 0 : exit(EXIT_FAILURE);
107 : }
108 : }
109 :
110 :
111 7450 : int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
112 : struct lua_longjmp lj;
113 7450 : lj.status = 0;
114 7450 : lj.previous = L->errorJmp; /* chain new error handler */
115 7450 : L->errorJmp = &lj;
116 7450 : LUAI_TRY(L, &lj,
117 : (*f)(L, ud);
118 : );
119 7431 : L->errorJmp = lj.previous; /* restore old error handler */
120 7431 : return lj.status;
121 : }
122 :
123 : /* }====================================================== */
124 :
125 :
126 54 : static void correctstack (lua_State *L, TValue *oldstack) {
127 : CallInfo *ci;
128 : GCObject *up;
129 54 : L->top = (L->top - oldstack) + L->stack;
130 1106 : for (up = L->openupval; up != NULL; up = up->gch.next)
131 1052 : gco2uv(up)->v = (gco2uv(up)->v - oldstack) + L->stack;
132 574 : for (ci = L->base_ci; ci <= L->ci; ci++) {
133 520 : ci->top = (ci->top - oldstack) + L->stack;
134 520 : ci->base = (ci->base - oldstack) + L->stack;
135 520 : ci->func = (ci->func - oldstack) + L->stack;
136 : }
137 54 : L->base = (L->base - oldstack) + L->stack;
138 54 : }
139 :
140 :
141 54 : void luaD_reallocstack (lua_State *L, int newsize) {
142 54 : TValue *oldstack = L->stack;
143 54 : int realsize = newsize + 1 + EXTRA_STACK;
144 : lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK - 1);
145 54 : luaM_reallocvector(L, L->stack, L->stacksize, realsize, TValue);
146 54 : L->stacksize = realsize;
147 54 : L->stack_last = L->stack+newsize;
148 54 : correctstack(L, oldstack);
149 54 : }
150 :
151 :
152 9 : void luaD_reallocCI (lua_State *L, int newsize) {
153 9 : CallInfo *oldci = L->base_ci;
154 9 : luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);
155 9 : L->size_ci = newsize;
156 9 : L->ci = (L->ci - oldci) + L->base_ci;
157 9 : L->end_ci = L->base_ci + L->size_ci - 1;
158 9 : }
159 :
160 :
161 54 : void luaD_growstack (lua_State *L, int n) {
162 54 : if (n <= L->stacksize) /* double size is enough? */
163 53 : luaD_reallocstack(L, 2*L->stacksize);
164 : else
165 1 : luaD_reallocstack(L, L->stacksize + n);
166 54 : }
167 :
168 :
169 9 : static CallInfo *growCI (lua_State *L) {
170 9 : if (L->size_ci > LUAI_MAXCALLS) /* overflow while handling overflow? */
171 0 : luaD_throw(L, LUA_ERRERR);
172 : else {
173 9 : luaD_reallocCI(L, 2*L->size_ci);
174 9 : if (L->size_ci > LUAI_MAXCALLS)
175 0 : luaG_runerror(L, "stack overflow");
176 : }
177 9 : return ++L->ci;
178 : }
179 :
180 :
181 491 : void luaD_callhook (lua_State *L, int event, int line) {
182 491 : lua_Hook hook = L->hook;
183 491 : if (hook && L->allowhook) {
184 243 : ptrdiff_t top = savestack(L, L->top);
185 243 : ptrdiff_t ci_top = savestack(L, L->ci->top);
186 : lua_Debug ar;
187 243 : ar.event = event;
188 243 : ar.currentline = line;
189 243 : if (event == LUA_HOOKTAILRET)
190 0 : ar.i_ci = 0; /* tail call; no debug information about it */
191 : else
192 243 : ar.i_ci = cast_int(L->ci - L->base_ci);
193 243 : luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
194 243 : L->ci->top = L->top + LUA_MINSTACK;
195 : lua_assert(L->ci->top <= L->stack_last);
196 243 : L->allowhook = 0; /* cannot call hooks inside a hook */
197 : lua_unlock(L);
198 243 : (*hook)(L, &ar);
199 : lua_lock(L);
200 : lua_assert(!L->allowhook);
201 243 : L->allowhook = 1;
202 243 : L->ci->top = restorestack(L, ci_top);
203 243 : L->top = restorestack(L, top);
204 : }
205 491 : }
206 :
207 :
208 452 : static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {
209 : int i;
210 452 : int nfixargs = p->numparams;
211 452 : Table *htab = NULL;
212 : StkId base, fixed;
213 455 : for (; actual < nfixargs; ++actual)
214 3 : setnilvalue(L->top++);
215 : #if defined(LUA_COMPAT_VARARG)
216 452 : if (p->is_vararg & VARARG_NEEDSARG) { /* compat. with old-style vararg? */
217 0 : int nvar = actual - nfixargs; /* number of extra arguments */
218 : lua_assert(p->is_vararg & VARARG_HASARG);
219 0 : luaC_checkGC(L);
220 0 : luaD_checkstack(L, p->maxstacksize);
221 0 : htab = luaH_new(L, nvar, 1); /* create `arg' table */
222 0 : for (i=0; i<nvar; i++) /* put extra arguments into `arg' table */
223 0 : setobj2n(L, luaH_setnum(L, htab, i+1), L->top - nvar + i);
224 : /* store counter in field `n' */
225 0 : setnvalue(luaH_setstr(L, htab, luaS_newliteral(L, "n")), cast_num(nvar));
226 : }
227 : #endif
228 : /* move fixed parameters to final position */
229 452 : fixed = L->top - actual; /* first fixed argument */
230 452 : base = L->top; /* final position of first argument */
231 473 : for (i=0; i<nfixargs; i++) {
232 21 : setobjs2s(L, L->top++, fixed+i);
233 21 : setnilvalue(fixed+i);
234 : }
235 : /* add `arg' parameter */
236 452 : if (htab) {
237 0 : sethvalue(L, L->top++, htab);
238 : lua_assert(iswhite(obj2gco(htab)));
239 : }
240 452 : return base;
241 : }
242 :
243 :
244 6 : static StkId tryfuncTM (lua_State *L, StkId func) {
245 6 : const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
246 : StkId p;
247 6 : ptrdiff_t funcr = savestack(L, func);
248 6 : if (!ttisfunction(tm))
249 2 : luaG_typeerror(L, func, "call");
250 : /* Open a hole inside the stack at `func' */
251 12 : for (p = L->top; p > func; p--) setobjs2s(L, p, p-1);
252 4 : incr_top(L);
253 4 : func = restorestack(L, funcr); /* previous call may change stack */
254 4 : setobj2s(L, func, tm); /* tag method is the new function to be called */
255 4 : return func;
256 : }
257 :
258 :
259 :
260 : #define inc_ci(L) \
261 : ((L->ci == L->end_ci) ? growCI(L) : \
262 : (condhardstacktests(luaD_reallocCI(L, L->size_ci)), ++L->ci))
263 :
264 :
265 128729 : int luaD_precall (lua_State *L, StkId func, int nresults) {
266 : LClosure *cl;
267 : ptrdiff_t funcr;
268 128729 : if (!ttisfunction(func)) /* `func' is not a function? */
269 6 : func = tryfuncTM(L, func); /* check the `function' tag method */
270 128727 : funcr = savestack(L, func);
271 128727 : cl = &clvalue(func)->l;
272 128727 : L->ci->savedpc = L->savedpc;
273 128727 : if (!cl->isC) { /* Lua function? prepare its call */
274 : CallInfo *ci;
275 : StkId st, base;
276 23720 : Proto *p = cl->p;
277 23720 : luaD_checkstack(L, p->maxstacksize);
278 23720 : func = restorestack(L, funcr);
279 23720 : if (!p->is_vararg) { /* no varargs? */
280 23268 : base = func + 1;
281 23268 : if (L->top > base + p->numparams)
282 6203 : L->top = base + p->numparams;
283 : }
284 : else { /* vararg function */
285 452 : int nargs = cast_int(L->top - func) - 1;
286 452 : base = adjust_varargs(L, p, nargs);
287 452 : func = restorestack(L, funcr); /* previous call may change the stack */
288 : }
289 23720 : ci = inc_ci(L); /* now `enter' new function */
290 23720 : ci->func = func;
291 23720 : L->base = ci->base = base;
292 23720 : ci->top = L->base + p->maxstacksize;
293 : lua_assert(ci->top <= L->stack_last);
294 23720 : L->savedpc = p->code; /* starting point */
295 23720 : ci->tailcalls = 0;
296 23720 : ci->nresults = nresults;
297 142135 : for (st = L->top; st < ci->top; st++)
298 118415 : setnilvalue(st);
299 23720 : L->top = ci->top;
300 23720 : if (L->hookmask & LUA_MASKCALL) {
301 310 : L->savedpc++; /* hooks assume 'pc' is already incremented */
302 310 : luaD_callhook(L, LUA_HOOKCALL, -1);
303 310 : L->savedpc--; /* correct 'pc' */
304 : }
305 23720 : return PCRLUA;
306 : }
307 : else { /* if is a C function, call it */
308 : CallInfo *ci;
309 : int n;
310 105007 : luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
311 105007 : ci = inc_ci(L); /* now `enter' new function */
312 105007 : ci->func = restorestack(L, funcr);
313 105007 : L->base = ci->base = ci->func + 1;
314 105007 : ci->top = L->top + LUA_MINSTACK;
315 : lua_assert(ci->top <= L->stack_last);
316 105007 : ci->nresults = nresults;
317 105007 : if (L->hookmask & LUA_MASKCALL)
318 147 : luaD_callhook(L, LUA_HOOKCALL, -1);
319 : lua_unlock(L);
320 105007 : n = (*curr_func(L)->c.f)(L); /* do the actual call */
321 : lua_lock(L);
322 104838 : if (n < 0) /* yielding? */
323 5948 : return PCRYIELD;
324 : else {
325 98890 : luaD_poscall(L, L->top - n);
326 98890 : return PCRC;
327 : }
328 : }
329 : }
330 :
331 :
332 0 : static StkId callrethooks (lua_State *L, StkId firstResult) {
333 0 : ptrdiff_t fr = savestack(L, firstResult); /* next call may change stack */
334 0 : luaD_callhook(L, LUA_HOOKRET, -1);
335 0 : if (f_isLua(L->ci)) { /* Lua function? */
336 0 : while ((L->hookmask & LUA_MASKRET) && L->ci->tailcalls--) /* tail calls */
337 0 : luaD_callhook(L, LUA_HOOKTAILRET, -1);
338 : }
339 0 : return restorestack(L, fr);
340 : }
341 :
342 :
343 127093 : int luaD_poscall (lua_State *L, StkId firstResult) {
344 : StkId res;
345 : int wanted, i;
346 : CallInfo *ci;
347 127093 : if (L->hookmask & LUA_MASKRET)
348 0 : firstResult = callrethooks(L, firstResult);
349 127093 : ci = L->ci--;
350 127093 : res = ci->func; /* res == final position of 1st result */
351 127093 : wanted = ci->nresults;
352 127093 : L->base = (ci - 1)->base; /* restore base */
353 127093 : L->savedpc = (ci - 1)->savedpc; /* restore savedpc */
354 : /* move results to correct place */
355 271626 : for (i = wanted; i != 0 && firstResult < L->top; i--)
356 144533 : setobjs2s(L, res++, firstResult++);
357 139419 : while (i-- > 0)
358 12326 : setnilvalue(res++);
359 127093 : L->top = res;
360 127093 : return (wanted - LUA_MULTRET); /* 0 iff wanted == LUA_MULTRET */
361 : }
362 :
363 :
364 : /*
365 : ** Call a function (C or Lua). The function to be called is at *func.
366 : ** The arguments are on the stack, right after the function.
367 : ** When returns, all the results are on the stack, starting at the original
368 : ** function position.
369 : */
370 57001 : void luaD_call (lua_State *L, StkId func, int nResults) {
371 57001 : if (++L->nCcalls >= LUAI_MAXCCALLS) {
372 0 : if (L->nCcalls == LUAI_MAXCCALLS)
373 0 : luaG_runerror(L, "C stack overflow");
374 0 : else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
375 0 : luaD_throw(L, LUA_ERRERR); /* error while handing stack error */
376 : }
377 57001 : if (luaD_precall(L, func, nResults) == PCRLUA) /* is a Lua function? */
378 7019 : luaV_execute(L, 1); /* call it */
379 56642 : L->nCcalls--;
380 56642 : luaC_checkGC(L);
381 56642 : }
382 :
383 :
384 5962 : static void resume (lua_State *L, void *ud) {
385 5962 : StkId firstArg = cast(StkId, ud);
386 5962 : CallInfo *ci = L->ci;
387 5962 : if (L->status == 0) { /* start coroutine? */
388 : lua_assert(ci == L->base_ci && firstArg > L->base);
389 16 : if (luaD_precall(L, firstArg - 1, LUA_MULTRET) != PCRLUA)
390 0 : return;
391 : }
392 : else { /* resuming from previous yield */
393 : lua_assert(L->status == LUA_YIELD);
394 5946 : L->status = 0;
395 5946 : if (!f_isLua(ci)) { /* `common' yield? */
396 : /* finish interrupted execution of `OP_CALL' */
397 : lua_assert(GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_CALL ||
398 : GET_OPCODE(*((ci-1)->savedpc - 1)) == OP_TAILCALL);
399 5946 : if (luaD_poscall(L, firstArg)) /* complete it... */
400 5945 : L->top = L->ci->top; /* and correct top if not multiple results */
401 : }
402 : else /* yielded inside a hook: just continue its execution */
403 0 : L->base = L->ci->base;
404 : }
405 5962 : luaV_execute(L, cast_int(L->ci - L->base_ci));
406 : }
407 :
408 :
409 0 : static int resume_error (lua_State *L, const char *msg) {
410 0 : L->top = L->ci->base;
411 0 : setsvalue2s(L, L->top, luaS_new(L, msg));
412 0 : incr_top(L);
413 : lua_unlock(L);
414 0 : return LUA_ERRRUN;
415 : }
416 :
417 :
418 5962 : LUA_API int lua_resume (lua_State *L, int nargs) {
419 : int status;
420 : lua_lock(L);
421 5962 : if (L->status != LUA_YIELD && (L->status != 0 || L->ci != L->base_ci))
422 0 : return resume_error(L, "cannot resume non-suspended coroutine");
423 5962 : if (L->nCcalls >= LUAI_MAXCCALLS)
424 0 : return resume_error(L, "C stack overflow");
425 : luai_userstateresume(L, nargs);
426 : lua_assert(L->errfunc == 0);
427 5962 : L->baseCcalls = ++L->nCcalls;
428 5962 : status = luaD_rawrunprotected(L, resume, L->top - nargs);
429 5962 : if (status != 0) { /* error? */
430 1 : L->status = cast_byte(status); /* mark thread as `dead' */
431 1 : luaD_seterrorobj(L, status, L->top);
432 1 : L->ci->top = L->top;
433 : }
434 : else {
435 : lua_assert(L->nCcalls == L->baseCcalls);
436 5961 : status = L->status;
437 : }
438 5962 : --L->nCcalls;
439 : lua_unlock(L);
440 5962 : return status;
441 : }
442 :
443 :
444 5949 : LUA_API int lua_yield (lua_State *L, int nresults) {
445 : luai_userstateyield(L, nresults);
446 : lua_lock(L);
447 5949 : if (L->nCcalls > L->baseCcalls)
448 1 : luaG_runerror(L, "attempt to yield across metamethod/C-call boundary");
449 5948 : L->base = L->top - nresults; /* protect stack slots below */
450 5948 : L->status = LUA_YIELD;
451 : lua_unlock(L);
452 5948 : return -1;
453 : }
454 :
455 :
456 1308 : int luaD_pcall (lua_State *L, Pfunc func, void *u,
457 : ptrdiff_t old_top, ptrdiff_t ef) {
458 : int status;
459 1308 : unsigned short oldnCcalls = L->nCcalls;
460 1308 : ptrdiff_t old_ci = saveci(L, L->ci);
461 1308 : lu_byte old_allowhooks = L->allowhook;
462 1308 : ptrdiff_t old_errfunc = L->errfunc;
463 1308 : L->errfunc = ef;
464 1308 : status = luaD_rawrunprotected(L, func, u);
465 1289 : if (status != 0) { /* an error occurred? */
466 372 : StkId oldtop = restorestack(L, old_top);
467 372 : luaF_close(L, oldtop); /* close eventual pending closures */
468 372 : luaD_seterrorobj(L, status, oldtop);
469 372 : L->nCcalls = oldnCcalls;
470 372 : L->ci = restoreci(L, old_ci);
471 372 : L->base = L->ci->base;
472 372 : L->savedpc = L->ci->savedpc;
473 372 : L->allowhook = old_allowhooks;
474 372 : restore_stack_limit(L);
475 : }
476 1289 : L->errfunc = old_errfunc;
477 1289 : return status;
478 : }
479 :
480 :
481 :
482 : /*
483 : ** Execute a protected parser.
484 : */
485 : struct SParser { /* data to `f_parser' */
486 : ZIO *z;
487 : Mbuffer buff; /* buffer to be used by the scanner */
488 : const char *name;
489 : };
490 :
491 488 : static void f_parser (lua_State *L, void *ud) {
492 : int i;
493 : Proto *tf;
494 : Closure *cl;
495 488 : struct SParser *p = cast(struct SParser *, ud);
496 488 : int c = luaZ_lookahead(p->z);
497 487 : luaC_checkGC(L);
498 487 : tf = ((c == LUA_SIGNATURE[0]) ? luaU_undump : luaY_parser)(L, p->z,
499 : &p->buff, p->name);
500 451 : cl = luaF_newLclosure(L, tf->nups, hvalue(gt(L)));
501 451 : cl->l.p = tf;
502 451 : for (i = 0; i < tf->nups; i++) /* initialize eventual upvalues */
503 0 : cl->l.upvals[i] = luaF_newupval(L);
504 451 : setclvalue(L, L->top, cl);
505 451 : incr_top(L);
506 451 : }
507 :
508 :
509 488 : int luaD_protectedparser (lua_State *L, ZIO *z, const char *name) {
510 : struct SParser p;
511 : int status;
512 488 : p.z = z; p.name = name;
513 488 : luaZ_initbuffer(L, &p.buff);
514 488 : status = luaD_pcall(L, f_parser, &p, savestack(L, L->top), L->errfunc);
515 488 : luaZ_freebuffer(L, &p.buff);
516 488 : return status;
517 : }
518 :
519 :
|
