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