rusefi
/
lua
mirror of https://github.com/rusefi/lua.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

several small improvements based on 'ci' being fixed now (including 

erasing savedpc from lua_State)
This commit is contained in:
Roberto Ierusalimschy 2009-04-17 19:00:01 -03:00
parent c6b442bd36
commit d3037d97ec
8 changed files with 133 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
lapi.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lapi.c,v 2.74 2009/04/08 18:04:33 roberto Exp roberto $
** $Id: lapi.c,v 2.75 2009/04/17 14:28:06 roberto Exp roberto $
** Lua API
** See Copyright Notice in lua.h
*/
@ -829,18 +829,19 @@ LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,
status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
}
else { /* prepare continuation (call is already protected by 'resume') */
L->ci->u.c.k = k; /* save continuation */
L->ci->u.c.ctx = ctx; /* save context */
CallInfo *ci = L->ci;
ci->u.c.k = k; /* save continuation */
ci->u.c.ctx = ctx; /* save context */
/* save information for error recovery */
L->ci->u.c.oldtop = savestack(L, c.func);
L->ci->u.c.old_allowhook = L->allowhook;
L->ci->u.c.old_errfunc = L->errfunc;
ci->u.c.oldtop = savestack(L, c.func);
ci->u.c.old_allowhook = L->allowhook;
ci->u.c.old_errfunc = L->errfunc;
L->errfunc = func;
/* mark that function may do error recovery */
L->ci->callstatus |= CIST_YPCALL;
ci->callstatus |= CIST_YPCALL;
luaD_call(L, c.func, nresults, 1); /* do the call */
L->ci->callstatus &= ~CIST_YPCALL;
L->errfunc = L->ci->u.c.old_errfunc;
ci->callstatus &= ~CIST_YPCALL;
L->errfunc = ci->u.c.old_errfunc;
status = LUA_OK; /* if it is here, there were no errors */
}
adjustresults(L, nresults);

8
ldebug.c
View File

@ -1,5 +1,5 @@
/*
** $Id: ldebug.c,v 2.45 2009/03/26 12:56:38 roberto Exp roberto $
** $Id: ldebug.c,v 2.46 2009/04/17 14:28:06 roberto Exp roberto $
** Debug Interface
** See Copyright Notice in lua.h
*/
@ -35,9 +35,7 @@ static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name);
static int currentpc (lua_State *L, CallInfo *ci) {
if (!isLua(ci)) return -1; /* function is not a Lua function? */
if (ci == L->ci)
ci->savedpc = L->savedpc;
return pcRel(ci->savedpc, ci_func(ci)->l.p);
return pcRel(ci->u.l.savedpc, ci_func(ci)->l.p);
}
@ -58,7 +56,7 @@ LUA_API int lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
mask = 0;
func = NULL;
}
L->oldpc = L->savedpc;
L->oldpc = NULL;
L->hook = func;
L->basehookcount = count;
resethookcount(L);

52
ldo.c
View File

@ -1,5 +1,5 @@
/*
** $Id: ldo.c,v 2.59 2009/04/15 16:53:39 roberto Exp roberto $
** $Id: ldo.c,v 2.60 2009/04/17 14:28:06 roberto Exp roberto $
** Stack and Call structure of Lua
** See Copyright Notice in lua.h
*/
@ -151,28 +151,29 @@ void luaD_growstack (lua_State *L, int n) {
void luaD_callhook (lua_State *L, int event, int line) {
lua_Hook hook = L->hook;
if (hook && L->allowhook) {
CallInfo *ci = L->ci;
ptrdiff_t top = savestack(L, L->top);
ptrdiff_t ci_top = savestack(L, L->ci->top);
ptrdiff_t ci_top = savestack(L, ci->top);
lua_Debug ar;
ar.event = event;
ar.currentline = line;
if (event == LUA_HOOKTAILRET)
ar.i_ci = NULL; /* tail call; no debug information about it */
else
ar.i_ci = L->ci;
ar.i_ci = ci;
luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
L->ci->top = L->top + LUA_MINSTACK;
lua_assert(L->ci->top <= L->stack_last);
ci->top = L->top + LUA_MINSTACK;
lua_assert(ci->top <= L->stack_last);
L->allowhook = 0; /* cannot call hooks inside a hook */
L->ci->callstatus |= CIST_HOOKED;
ci->callstatus |= CIST_HOOKED;
lua_unlock(L);
(*hook)(L, &ar);
lua_lock(L);
lua_assert(!L->allowhook);
L->allowhook = 1;
L->ci->top = restorestack(L, ci_top);
ci->top = restorestack(L, ci_top);
L->top = restorestack(L, top);
L->ci->callstatus &= ~CIST_HOOKED;
ci->callstatus &= ~CIST_HOOKED;
}
}
@ -223,7 +224,6 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
func = tryfuncTM(L, func); /* check the `function' tag method */
funcr = savestack(L, func);
cl = &clvalue(func)->l;
L->ci->savedpc = L->savedpc;
L->ci->nresults = nresults;
if (!cl->isC) { /* Lua function? prepare its call */
CallInfo *ci;
@ -243,16 +243,16 @@ int luaD_precall (lua_State *L, StkId func, int nresults) {
L->base = ci->base = base;
ci->top = L->base + p->maxstacksize;
lua_assert(ci->top <= L->stack_last);
L->savedpc = p->code; /* starting point */
ci->u.l.savedpc = p->code; /* starting point */
ci->u.l.tailcalls = 0;
ci->callstatus = CIST_LUA;
for (st = L->top; st < ci->top; st++)
setnilvalue(st);
L->top = ci->top;
if (L->hookmask & LUA_MASKCALL) {
L->savedpc++; /* hooks assume 'pc' is already incremented */
ci->u.l.savedpc++; /* hooks assume 'pc' is already incremented */
luaD_callhook(L, LUA_HOOKCALL, -1);
L->savedpc--; /* correct 'pc' */
ci->u.l.savedpc--; /* correct 'pc' */
}
return 0;
}
@ -295,13 +295,12 @@ int luaD_poscall (lua_State *L, StkId firstResult) {
if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) {
if (L->hookmask & LUA_MASKRET)
firstResult = callrethooks(L, firstResult);
L->oldpc = L->ci->previous->savedpc; /* 'oldpc' for returning function */
L->oldpc = ci->previous->u.l.savedpc; /* 'oldpc' for returning function */
}
res = ci->func; /* res == final position of 1st result */
L->ci = ci = L->ci->previous; /* back to caller */
L->ci = ci = ci->previous; /* back to caller */
wanted = ci->nresults;
L->base = ci->base; /* restore base */
L->savedpc = ci->savedpc; /* restore savedpc */
/* move results to correct place */
for (i = wanted; i != 0 && firstResult < L->top; i--)
setobjs2s(L, res++, firstResult++);
@ -336,21 +335,21 @@ void luaD_call (lua_State *L, StkId func, int nResults, int allowyield) {
static void finishCcall (lua_State *L) {
CallInfo *ci = L->ci;
int n;
lua_assert(L->ci->u.c.k != NULL); /* must have a continuation */
lua_assert(ci->u.c.k != NULL); /* must have a continuation */
lua_assert(L->nny == 0);
/* finish 'luaD_call' */
G(L)->nCcalls--;
/* finish 'lua_callk' */
adjustresults(L, L->ci->nresults);
adjustresults(L, ci->nresults);
/* call continuation function */
if (!(L->ci->callstatus & CIST_STAT)) /* no call status? */
L->ci->u.c.status = LUA_YIELD; /* 'default' status */
lua_assert(L->ci->u.c.status != LUA_OK);
L->ci->callstatus = (L->ci->callstatus & ~(CIST_YPCALL | CIST_STAT))
| CIST_YIELDED;
if (!(ci->callstatus & CIST_STAT)) /* no call status? */
ci->u.c.status = LUA_YIELD; /* 'default' status */
lua_assert(ci->u.c.status != LUA_OK);
ci->callstatus = (ci->callstatus & ~(CIST_YPCALL | CIST_STAT)) | CIST_YIELDED;
lua_unlock(L);
n = (*L->ci->u.c.k)(L);
n = (*ci->u.c.k)(L);
lua_lock(L);
/* finish 'luaD_precall' */
luaD_poscall(L, L->top - n);
@ -384,7 +383,7 @@ static void resume (lua_State *L, void *ud) {
lua_assert(L->status == LUA_YIELD);
L->status = LUA_OK;
if (isLua(ci)) { /* yielded inside a hook? */
L->base = L->ci->base; /* just continue its execution */
L->base = ci->base; /* just continue its execution */
luaV_execute(L);
}
else { /* 'common' yield */
@ -427,7 +426,7 @@ static int recover (lua_State *L, int status) {
luaF_close(L, oldtop);
luaD_seterrorobj(L, status, oldtop);
L->ci = ci;
L->base = L->ci->base;
L->base = ci->base;
L->allowhook = ci->u.c.old_allowhook;
L->nny = 0; /* should be zero to be yieldable */
restore_stack_limit(L);
@ -499,8 +498,7 @@ int luaD_pcall (lua_State *L, Pfunc func, void *u,
luaF_close(L, oldtop); /* close possible pending closures */
luaD_seterrorobj(L, status, oldtop);
L->ci = old_ci;
L->base = L->ci->base;
L->savedpc = L->ci->savedpc;
L->base = old_ci->base;
L->allowhook = old_allowhooks;
L->nny = old_nny;
restore_stack_limit(L);

3
lstate.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lstate.c,v 2.51 2009/04/17 14:28:06 roberto Exp roberto $
** $Id: lstate.c,v 2.52 2009/04/17 14:40:13 roberto Exp roberto $
** Global State
** See Copyright Notice in lua.h
*/
@ -130,7 +130,6 @@ static void preinit_state (lua_State *L, global_State *g) {
L->base_ci.next = L->base_ci.previous = NULL;
L->ci = &L->base_ci;
L->nci = 0;
L->savedpc = NULL;
L->errfunc = 0;
setnilvalue(gt(L));
}

5
lstate.h
View File

@ -1,5 +1,5 @@
/*
** $Id: lstate.h,v 2.41 2009/04/08 18:04:33 roberto Exp roberto $
** $Id: lstate.h,v 2.42 2009/04/17 14:28:06 roberto Exp roberto $
** Global State
** See Copyright Notice in lua.h
*/
@ -81,11 +81,11 @@ typedef struct CallInfo {
StkId func; /* function index in the stack */
StkId top; /* top for this function */
struct CallInfo *previous, *next; /* dynamic call link */
const Instruction *savedpc;
short nresults; /* expected number of results from a call */
lu_byte callstatus;
union {
struct { /* only for Lua functions */
const Instruction *savedpc;
int tailcalls; /* number of tail calls lost under this entry */
} l;
struct { /* only for C functions */
@ -165,7 +165,6 @@ struct lua_State {
global_State *l_G;
CallInfo *ci; /* call info for current function */
int nci; /* number of total CallInfo structures linked */
const Instruction *savedpc; /* `savedpc' of current function */
const Instruction *oldpc; /* last pc traced */
StkId stack_last; /* last free slot in the stack */
StkId stack; /* stack base */

26
ltests.c
View File

@ -1,5 +1,5 @@
/*
** $Id: ltests.c,v 2.60 2009/04/14 19:10:17 roberto Exp roberto $
** $Id: ltests.c,v 2.61 2009/04/17 14:28:06 roberto Exp roberto $
** Internal Module for Debugging of the Lua Implementation
** See Copyright Notice in lua.h
*/
@ -285,6 +285,16 @@ static void checkclosure (global_State *g, Closure *cl) {
}
static int lua_checkpc (pCallInfo ci) {
if (!isLua(ci)) return 1;
else {
Proto *p = ci_func(ci)->l.p;
return p->code <= ci->u.l.savedpc &&
ci->u.l.savedpc <= p->code + p->sizecode;
}
}
static void checkstack (global_State *g, lua_State *L1) {
StkId o;
CallInfo *ci;
@ -298,7 +308,7 @@ static void checkstack (global_State *g, lua_State *L1) {
checkliveness(g, gt(L1));
for (ci = L1->ci; ci != NULL; ci = ci->previous) {
lua_assert(ci->top <= L1->stack_last);
lua_assert(lua_checkpc(L1, ci));
lua_assert(lua_checkpc(ci));
}
if (L1->stack) {
for (o = L1->stack; o < L1->top; o++)
@ -352,18 +362,6 @@ printf(">>> %d %s %02x\n", g->gcstate, luaT_typenames[gch(o)->tt], gch(o)->mar
}
int lua_checkpc (lua_State *L, pCallInfo ci) {
if (!isLua(ci)) return 1;
else {
Proto *p = ci_func(ci)->l.p;
if (ci != L->ci)
return p->code <= ci->savedpc && ci->savedpc <= p->code + p->sizecode;
else
return p->code <= L->savedpc && L->savedpc <= p->code + p->sizecode;
}
}
int lua_checkmemory (lua_State *L) {
global_State *g = G(L);
GCObject *o;

3
ltests.h
View File

@ -1,5 +1,5 @@
/*
** $Id: ltests.h,v 2.23 2008/07/18 19:58:10 roberto Exp roberto $
** $Id: ltests.h,v 2.24 2008/08/05 19:24:46 roberto Exp roberto $
** Internal Header for Debugging of the Lua Implementation
** See Copyright Notice in lua.h
*/
@ -51,7 +51,6 @@ void *debug_realloc (void *ud, void *block, size_t osize, size_t nsize);
typedef struct CallInfo *pCallInfo;
int lua_checkmemory (lua_State *L);
int lua_checkpc (lua_State *L, pCallInfo ci);
/* test for lock/unlock */

155
lvm.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lvm.c,v 2.84 2009/03/10 17:14:37 roberto Exp roberto $
** $Id: lvm.c,v 2.85 2009/04/17 14:28:06 roberto Exp roberto $
** Lua virtual machine
** See Copyright Notice in lua.h
*/
@ -58,21 +58,22 @@ int luaV_tostring (lua_State *L, StkId obj) {
static void traceexec (lua_State *L) {
CallInfo *ci = L->ci;
lu_byte mask = L->hookmask;
if ((mask & LUA_MASKCOUNT) && L->hookcount == 0) {
resethookcount(L);
luaD_callhook(L, LUA_HOOKCOUNT, -1);
}
if (mask & LUA_MASKLINE) {
Proto *p = ci_func(L->ci)->l.p;
int npc = pcRel(L->savedpc, p);
Proto *p = ci_func(ci)->l.p;
int npc = pcRel(ci->u.l.savedpc, p);
int newline = getline(p, npc);
if (npc == 0 || /* call linehook when enter a new function, */
L->savedpc <= L->oldpc || /* when jump back (loop), or when */
ci->u.l.savedpc <= L->oldpc || /* when jump back (loop), or when */
newline != getline(p, pcRel(L->oldpc, p))) /* enter a new line */
luaD_callhook(L, LUA_HOOKLINE, newline);
}
L->oldpc = L->savedpc;
L->oldpc = ci->u.l.savedpc;
}
@ -357,7 +358,8 @@ static void Arith (lua_State *L, StkId ra, const TValue *rb,
** finish execution of an opcode interrupted by an yield
*/
void luaV_finishOp (lua_State *L) {
Instruction inst = *(L->savedpc - 1); /* interrupted instruction */
CallInfo *ci = L->ci;
Instruction inst = *(ci->u.l.savedpc - 1); /* interrupted instruction */
switch (GET_OPCODE(inst)) { /* finish its execution */
case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV:
case OP_MOD: case OP_POW: case OP_UNM: case OP_LEN:
@ -373,9 +375,9 @@ void luaV_finishOp (lua_State *L) {
if (GET_OPCODE(inst) == OP_LE && /* "<=" using "<" instead? */
ttisnil(luaT_gettmbyobj(L, L->base + GETARG_B(inst), TM_LE)))
res = !res; /* invert result */
lua_assert(GET_OPCODE(*L->savedpc) == OP_JMP);
lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_JMP);
if (res != GETARG_A(inst)) /* condition failed? */
L->savedpc++; /* skip jump instruction */
ci->u.l.savedpc++; /* skip jump instruction */
break;
}
case OP_CONCAT: {
@ -384,7 +386,7 @@ void luaV_finishOp (lua_State *L) {
int b = GETARG_B(inst); /* ... first element to concatenate */
int total = last - b + 1; /* number of elements to concatenate */
setobj2s(L, top - 2, top); /* put TM result in proper position */
L->top = L->ci->top; /* correct top */
L->top = ci->top; /* correct top */
if (total > 1) /* are there elements to concat? */
luaV_concat(L, total, last); /* concat them (may yield again) */
/* move final result to final position */
@ -392,13 +394,13 @@ void luaV_finishOp (lua_State *L) {
break;
}
case OP_TFORCALL: {
lua_assert(GET_OPCODE(*L->savedpc) == OP_TFORLOOP);
L->top = L->ci->top; /* correct top */
lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_TFORLOOP);
L->top = ci->top; /* correct top */
break;
}
case OP_CALL: {
if (GETARG_C(inst) - 1 >= 0) /* nresults >= 0? */
L->top = L->ci->top; /* adjust results */
L->top = ci->top; /* adjust results */
break;
}
case OP_TAILCALL: case OP_SETGLOBAL: case OP_SETTABLE:
@ -413,8 +415,6 @@ void luaV_finishOp (lua_State *L) {
** some macros for common tasks in `luaV_execute'
*/
#define runtime_check(L, c) { if (!(c)) break; }
#define RA(i) (base+GETARG_A(i))
/* to be used after possible stack reallocation */
#define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
@ -426,10 +426,10 @@ void luaV_finishOp (lua_State *L) {
#define KBx(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, k+GETARG_Bx(i))
#define dojump(L,i) { L->savedpc += (i); luai_threadyield(L);}
#define dojump(i) { ci->u.l.savedpc += (i); luai_threadyield(L);}
#define Protect(x) { {x;}; base = L->base; }
#define Protect(x) { {x;}; base = ci->base; }
#define arith_op(op,tm) { \
@ -446,32 +446,29 @@ void luaV_finishOp (lua_State *L) {
void luaV_execute (lua_State *L) {
LClosure *cl;
StkId base;
TValue *k;
reentry: /* entry point */
lua_assert(isLua(L->ci));
cl = &curr_func(L)->l;
base = L->base;
k = cl->p->k;
CallInfo *ci = L->ci;
LClosure *cl = &clvalue(ci->func)->l;
TValue *k = cl->p->k;
StkId base = ci->base;
lua_assert(isLua(ci));
/* main loop of interpreter */
for (;;) {
Instruction i = *(L->savedpc++);
Instruction i = *(ci->u.l.savedpc++);
StkId ra;
if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
(--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
traceexec(L);
if (L->status == LUA_YIELD) { /* did hook yield? */
L->savedpc--; /* undo increment */
ci->u.l.savedpc--; /* undo increment */
luaD_throw(L, LUA_YIELD);
}
base = L->base;
base = ci->base;
}
/* warning!! several calls may realloc the stack and invalidate `ra' */
ra = RA(i);
lua_assert(base == L->base && L->base == L->ci->base);
lua_assert(base == ci->base && base == L->base);
lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
lua_assert(L->top == ci->top || luaG_checkopenop(i));
switch (GET_OPCODE(i)) {
case OP_MOVE: {
setobjs2s(L, ra, RB(i));
@ -483,7 +480,7 @@ void luaV_execute (lua_State *L) {
}
case OP_LOADBOOL: {
setbvalue(ra, GETARG_B(i));
if (GETARG_C(i)) L->savedpc++; /* skip next instruction (if C) */
if (GETARG_C(i)) ci->u.l.savedpc++; /* skip next instruction (if C) */
continue;
}
case OP_LOADNIL: {
@ -595,7 +592,7 @@ void luaV_execute (lua_State *L) {
continue;
}
case OP_JMP: {
dojump(L, GETARG_sBx(i));
dojump(GETARG_sBx(i));
continue;
}
case OP_EQ: {
@ -603,40 +600,40 @@ void luaV_execute (lua_State *L) {
TValue *rc = RKC(i);
Protect(
if (equalobj(L, rb, rc) == GETARG_A(i))
dojump(L, GETARG_sBx(*L->savedpc));
dojump(GETARG_sBx(*ci->u.l.savedpc));
)
L->savedpc++;
ci->u.l.savedpc++;
continue;
}
case OP_LT: {
Protect(
if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))
dojump(L, GETARG_sBx(*L->savedpc));
dojump(GETARG_sBx(*ci->u.l.savedpc));
)
L->savedpc++;
ci->u.l.savedpc++;
continue;
}
case OP_LE: {
Protect(
if (lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))
dojump(L, GETARG_sBx(*L->savedpc));
dojump(GETARG_sBx(*ci->u.l.savedpc));
)
L->savedpc++;
ci->u.l.savedpc++;
continue;
}
case OP_TEST: {
if (GETARG_C(i) ? !l_isfalse(ra) : l_isfalse(ra))
dojump(L, GETARG_sBx(*L->savedpc));
L->savedpc++;
dojump(GETARG_sBx(*ci->u.l.savedpc));
ci->u.l.savedpc++;
continue;
}
case OP_TESTSET: {
TValue *rb = RB(i);
if (GETARG_C(i) ? !l_isfalse(rb) : l_isfalse(rb)) {
setobjs2s(L, ra, rb);
dojump(L, GETARG_sBx(*L->savedpc));
dojump(GETARG_sBx(*ci->u.l.savedpc));
}
L->savedpc++;
ci->u.l.savedpc++;
continue;
}
case OP_CALL: {
@ -644,13 +641,14 @@ void luaV_execute (lua_State *L) {
int nresults = GETARG_C(i) - 1;
if (b != 0) L->top = ra+b; /* else previous instruction set top */
if (luaD_precall(L, ra, nresults)) { /* C function? */
if (nresults >= 0) L->top = L->ci->top; /* adjust results */
base = L->base;
if (nresults >= 0) L->top = ci->top; /* adjust results */
base = ci->base;
continue;
}
else { /* Lua function */
L->ci->callstatus |= CIST_REENTRY;
goto reentry; /* restart luaV_execute over new Lua function */
ci = L->ci;
ci->callstatus |= CIST_REENTRY;
break; /* restart luaV_execute over new Lua function */
}
}
case OP_TAILCALL: {
@ -658,25 +656,26 @@ void luaV_execute (lua_State *L) {
if (b != 0) L->top = ra+b; /* else previous instruction set top */
lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
if (luaD_precall(L, ra, LUA_MULTRET)) { /* C function? */
base = L->base;
base = ci->base;
continue;
}
else {
/* tail call: put new frame in place of previous one */
StkId pfunc = L->ci->func; /* called function index */
CallInfo *ci = L->ci->previous; /* caller frame */
StkId func = ci->func;
/* tail call: put called frame (n) in place of caller one (o) */
CallInfo *nci = L->ci; /* called frame */
CallInfo *oci = nci->previous; /* caller frame */
StkId nfunc = nci->func; /* called function index */
StkId ofunc = oci->func;
int aux;
if (cl->p->sizep > 0) luaF_close(L, ci->base);
L->base = ci->base = ci->func + (L->ci->base - pfunc);
for (aux = 0; pfunc+aux < L->top; aux++) /* move frame down */
setobjs2s(L, func+aux, pfunc+aux);
ci->top = L->top = func+aux; /* correct top */
lua_assert(L->top == L->base + clvalue(func)->l.p->maxstacksize);
ci->savedpc = L->savedpc;
ci->u.l.tailcalls++; /* one more call lost */
L->ci = ci; /* remove new frame */
goto reentry;
if (cl->p->sizep > 0) luaF_close(L, oci->base);
L->base = oci->base = ofunc + (nci->base - nfunc);
for (aux = 0; nfunc+aux < L->top; aux++) /* move frame down */
setobjs2s(L, ofunc + aux, nfunc + aux);
oci->top = L->top = ofunc + aux; /* correct top */
lua_assert(L->top == L->base + clvalue(ofunc)->l.p->maxstacksize);
oci->u.l.savedpc = nci->u.l.savedpc;
oci->u.l.tailcalls++; /* one more call lost */
ci = L->ci = oci; /* remove new frame */
break; /* restart luaV_execute over new Lua function */
}
}
case OP_RETURN: {
@ -684,13 +683,14 @@ void luaV_execute (lua_State *L) {
if (b != 0) L->top = ra+b-1;
if (cl->p->sizep > 0) luaF_close(L, base);
b = luaD_poscall(L, ra);
if (!(L->ci->next->callstatus & CIST_REENTRY))
if (!(ci->callstatus & CIST_REENTRY)) /* 'ci' still the called one */
return; /* external invocation: return */
else { /* invocation via reentry: continue execution */
if (b) L->top = L->ci->top;
lua_assert(isLua(L->ci));
lua_assert(GET_OPCODE(*((L->ci)->savedpc - 1)) == OP_CALL);
goto reentry;
ci = L->ci;
if (b) L->top = ci->top;
lua_assert(isLua(ci));
lua_assert(GET_OPCODE(*((ci)->u.l.savedpc - 1)) == OP_CALL);
break; /* restart luaV_execute over new Lua function */
}
}
case OP_FORLOOP: {
@ -699,7 +699,7 @@ void luaV_execute (lua_State *L) {
lua_Number limit = nvalue(ra+1);
if (luai_numlt(L, 0, step) ? luai_numle(L, idx, limit)
: luai_numle(L, limit, idx)) {
dojump(L, GETARG_sBx(i)); /* jump back */
dojump(GETARG_sBx(i)); /* jump back */
setnvalue(ra, idx); /* update internal index... */
setnvalue(ra+3, idx); /* ...and external index */
}
@ -716,7 +716,7 @@ void luaV_execute (lua_State *L) {
else if (!tonumber(pstep, ra+2))
luaG_runerror(L, LUA_QL("for") " step must be a number");
setnvalue(ra, luai_numsub(L, nvalue(ra), nvalue(pstep)));
dojump(L, GETARG_sBx(i));
dojump(GETARG_sBx(i));
continue;
}
case OP_TFORCALL: {
@ -726,8 +726,8 @@ void luaV_execute (lua_State *L) {
setobjs2s(L, cb, ra);
L->top = cb + 3; /* func. + 2 args (state and index) */
Protect(luaD_call(L, cb, GETARG_C(i), 1));
L->top = L->ci->top;
i = *(L->savedpc++); /* go to next instruction */
L->top = ci->top;
i = *(ci->u.l.savedpc++); /* go to next instruction */
ra = RA(i);
lua_assert(GET_OPCODE(i) == OP_TFORLOOP);
/* go through */
@ -735,7 +735,7 @@ void luaV_execute (lua_State *L) {
case OP_TFORLOOP: {
if (!ttisnil(ra + 1)) { /* continue loop? */
setobjs2s(L, ra, ra + 1); /* save control variable */
dojump(L, GETARG_sBx(i)); /* jump back */
dojump(GETARG_sBx(i)); /* jump back */
}
continue;
}
@ -746,10 +746,9 @@ void luaV_execute (lua_State *L) {
Table *h;
if (n == 0) n = cast_int(L->top - ra) - 1;
if (c == 0) {
lua_assert(GET_OPCODE(*L->savedpc) == OP_EXTRAARG);
c = GETARG_Ax(*L->savedpc++);
lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG);
c = GETARG_Ax(*ci->u.l.savedpc++);
}
runtime_check(L, ttistable(ra));
h = hvalue(ra);
last = ((c-1)*LFIELDS_PER_FLUSH) + n;
if (last > h->sizearray) /* needs more space? */
@ -759,7 +758,7 @@ void luaV_execute (lua_State *L) {
setobj2t(L, luaH_setnum(L, h, last--), val);
luaC_barriert(L, h, val);
}
L->top = L->ci->top; /* correct top (in case of previous open call) */
L->top = ci->top; /* correct top (in case of previous open call) */
continue;
}
case OP_CLOSE: {
@ -776,7 +775,7 @@ void luaV_execute (lua_State *L) {
ncl->l.p = p;
setclvalue(L, ra, ncl);
for (j=0; j<nup; j++) {
Instruction u = *L->savedpc++;
Instruction u = *ci->u.l.savedpc++;
if (GET_OPCODE(u) == OP_GETUPVAL)
ncl->l.upvals[j] = cl->upvals[GETARG_B(u)];
else {
@ -790,7 +789,6 @@ void luaV_execute (lua_State *L) {
case OP_VARARG: {
int b = GETARG_B(i) - 1;
int j;
CallInfo *ci = L->ci;
int n = cast_int(ci->base - ci->func) - cl->p->numparams - 1;
if (b == LUA_MULTRET) {
Protect(luaD_checkstack(L, n));
@ -813,6 +811,11 @@ void luaV_execute (lua_State *L) {
return;
}
}
/* function changed (call/return): update pointers */
lua_assert(ci == L->ci);
cl = &clvalue(ci->func)->l;
k = cl->p->k;
base = ci->base;
}
}