nik/lush
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first version of dynamic stack

Browse Source
This commit is contained in:
Roberto Ierusalimschy
2002-01-25 20:14:54 -02:00
parent b217ae644e
commit 50e2952593
9 changed files with 251 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
ldebug.c
View File

@@ -25,8 +25,7 @@
static const char *getfuncname (lua_State *L, CallInfo *ci, static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name);
const char **name);
@@ -57,7 +56,7 @@ LUA_API lua_Hook lua_setlinehook (lua_State *L, lua_Hook func) {
static CallInfo *ci_stack (lua_State *L, StkId obj) { static CallInfo *ci_stack (lua_State *L, StkId obj) {
CallInfo *ci = L->ci; CallInfo *ci = L->ci;
while (ci->base > obj) ci--; while (ci->base > obj && ci > L->base_ci) ci--;
return ci; return ci;
} }
@@ -105,22 +104,22 @@ int luaG_getline (int *lineinfo, int pc, int refline, int *prefi) {
} }
static int currentpc (CallInfo *ci) { static int currentpc (lua_State *L, CallInfo *ci) {
lua_assert(isLmark(ci)); lua_assert(isLmark(ci));
if (ci->savedpc) if (ci->pc == NULL) return 0; /* function is not active */
return (ci->savedpc - ci_func(ci)->l.p->code) - 1; if (ci == L->ci || ci->pc != (ci+1)->pc) /* no other function using `pc'? */
else if (ci->pc)
return (*ci->pc - ci_func(ci)->l.p->code) - 1; return (*ci->pc - ci_func(ci)->l.p->code) - 1;
else return 0; else /* function's pc is saved */
return (ci->savedpc - ci_func(ci)->l.p->code) - 1;
} }
static int currentline (CallInfo *ci) { static int currentline (lua_State *L, CallInfo *ci) {
if (!isLmark(ci)) if (!isLmark(ci))
return -1; /* only active lua functions have current-line information */ return -1; /* only active lua functions have current-line information */
else { else {
int *lineinfo = ci_func(ci)->l.p->lineinfo; int *lineinfo = ci_func(ci)->l.p->lineinfo;
return luaG_getline(lineinfo, currentpc(ci), 1, NULL); return luaG_getline(lineinfo, currentpc(L, ci), 1, NULL);
} }
} }
@@ -140,7 +139,7 @@ LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
ci = L->base_ci + ar->_ci; ci = L->base_ci + ar->_ci;
fp = getluaproto(ci); fp = getluaproto(ci);
if (fp) { /* is a Lua function? */ if (fp) { /* is a Lua function? */
name = luaF_getlocalname(fp, n, currentpc(ci)); name = luaF_getlocalname(fp, n, currentpc(L, ci));
if (name) if (name)
luaA_pushobject(L, ci->base+(n-1)); /* push value */ luaA_pushobject(L, ci->base+(n-1)); /* push value */
} }
@@ -159,7 +158,7 @@ LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
fp = getluaproto(ci); fp = getluaproto(ci);
L->top--; /* pop new value */ L->top--; /* pop new value */
if (fp) { /* is a Lua function? */ if (fp) { /* is a Lua function? */
name = luaF_getlocalname(fp, n, currentpc(ci)); name = luaF_getlocalname(fp, n, currentpc(L, ci));
if (!name || name[0] == '(') /* `(' starts private locals */ if (!name || name[0] == '(') /* `(' starts private locals */
name = NULL; name = NULL;
else else
@@ -239,7 +238,7 @@ LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
break; break;
} }
case 'l': { case 'l': {
ar->currentline = (ci) ? currentline(ci) : -1; ar->currentline = (ci) ? currentline(L, ci) : -1;
break; break;
} }
case 'u': { case 'u': {
@@ -254,13 +253,14 @@ LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
} }
case 'f': { case 'f': {
setobj(L->top, f); setobj(L->top, f);
incr_top; /* push function */ status = 2;
break; break;
} }
default: status = 0; /* invalid option */ default: status = 0; /* invalid option */
} }
} }
if (!ci) L->top--; /* pop function */ if (!ci) L->top--; /* pop function */
if (status == 2) incr_top(L);
lua_unlock(L); lua_unlock(L);
return status; return status;
} }
@@ -449,7 +449,7 @@ static const char *getobjname (lua_State *L, StkId obj, const char **name) {
CallInfo *ci = ci_stack(L, obj); CallInfo *ci = ci_stack(L, obj);
if (isLmark(ci)) { /* an active Lua function? */ if (isLmark(ci)) { /* an active Lua function? */
Proto *p = ci_func(ci)->l.p; Proto *p = ci_func(ci)->l.p;
int pc = currentpc(ci); int pc = currentpc(L, ci);
int stackpos = obj - ci->base; int stackpos = obj - ci->base;
Instruction i; Instruction i;
*name = luaF_getlocalname(p, stackpos+1, pc); *name = luaF_getlocalname(p, stackpos+1, pc);
@@ -486,14 +486,13 @@ static const char *getobjname (lua_State *L, StkId obj, const char **name) {
} }
static const char *getfuncname (lua_State *L, CallInfo *ci, static const char *getfuncname (lua_State *L, CallInfo *ci, const char **name) {
const char **name) {
ci--; /* calling function */ ci--; /* calling function */
if (ci == L->base_ci || !isLmark(ci)) if (ci == L->base_ci || !isLmark(ci))
return NULL; /* not an active Lua function */ return NULL; /* not an active Lua function */
else { else {
Proto *p = ci_func(ci)->l.p; Proto *p = ci_func(ci)->l.p;
int pc = currentpc(ci); int pc = currentpc(L, ci);
Instruction i; Instruction i;
i = p->code[pc]; i = p->code[pc];
return (GET_OPCODE(i) == OP_CALL return (GET_OPCODE(i) == OP_CALL

217
ldo.c
View File

@@ -30,22 +30,72 @@
static void restore_stack_limit (lua_State *L) { /* chain list of long jump buffers */
StkId limit = L->stack+(L->stacksize-EXTRA_STACK)-1; struct lua_longjmp {
if (L->top < limit) jmp_buf b;
L->stack_last = limit; struct lua_longjmp *previous;
CallInfo *ci; /* index of call info of active function that set protection */
StkId top; /* top stack when protection was set */
TObject *stack; /* active stack for this entry */
int allowhooks; /* `allowhook' state when protection was set */
volatile int status; /* error code */
};
static void correctstack (lua_State *L, TObject *oldstack) {
struct lua_longjmp *lj;
CallInfo *ci;
UpVal *up;
L->top = (L->top - oldstack) + L->stack;
for (lj = L->errorJmp; lj && lj->stack == oldstack; lj = lj->previous) {
lj->top = (lj->top - oldstack) + L->stack;
lj->stack = L->stack;
}
for (up = L->openupval; up != NULL; up = up->next)
up->v = (up->v - oldstack) + L->stack;
for (ci = L->base_ci; ci <= L->ci; ci++) {
ci->base = (ci->base - oldstack) + L->stack;
ci->top = (ci->top - oldstack) + L->stack;
if (ci->pc) { /* entry is of an active Lua function? */
if (ci->pc != (ci-1)->pc)
*ci->pb = (*ci->pb - oldstack) + L->stack;
}
}
} }
void luaD_stackerror (lua_State *L) { void luaD_reallocstack (lua_State *L, int newsize) {
if (L->stack_last == L->stack+L->stacksize-1) { TObject *oldstack = L->stack;
/* overflow while handling overflow */ luaM_reallocvector(L, L->stack, L->stacksize, newsize, TObject);
L->stacksize = newsize;
L->stack_last = L->stack+(newsize-EXTRA_STACK)-1;
correctstack(L, oldstack);
}
static void restore_stack_limit (lua_State *L) {
if (L->stacksize > L->maxstacksize) { /* there was an overflow? */
int inuse = (L->top - L->stack);
if (inuse + MAXSTACK < L->maxstacksize) /* can `undo' overflow? */
luaD_reallocstack(L, L->maxstacksize);
}
}
void luaD_growstack (lua_State *L, int n) {
if (L->stacksize > L->maxstacksize) { /* overflow while handling overflow? */
luaD_breakrun(L, LUA_ERRERR); /* break run without error message */ luaD_breakrun(L, LUA_ERRERR); /* break run without error message */
} }
else { else {
L->stack_last += EXTRA_STACK; /* to be used by error message */ if (n <= L->stacksize && 2*L->stacksize < L->maxstacksize) /* can double? */
lua_assert(L->stack_last == L->stack+L->stacksize-1); luaD_reallocstack(L, 2*L->stacksize);
luaD_error(L, "stack overflow"); else if (L->stacksize+n <= L->maxstacksize) /* no overflow? */
luaD_reallocstack(L, L->maxstacksize);
else {
/* resize to maximum + some extra space to handle error */
luaD_reallocstack(L, L->maxstacksize+4*LUA_MINSTACK);
luaD_error(L, "stack overflow");
}
} }
} }
@@ -56,12 +106,12 @@ void luaD_stackerror (lua_State *L) {
static void luaD_openstack (lua_State *L, StkId pos) { static void luaD_openstack (lua_State *L, StkId pos) {
int i = L->top-pos; int i = L->top-pos;
while (i--) setobj(pos+i+1, pos+i); while (i--) setobj(pos+i+1, pos+i);
incr_top; incr_top(L);
} }
static void dohook (lua_State *L, lua_Debug *ar, lua_Hook hook) { static void dohook (lua_State *L, lua_Debug *ar, lua_Hook hook) {
StkId old_top = L->top; L->ci->top = L->top;
luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */ luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
L->allowhooks = 0; /* cannot call hooks inside a hook */ L->allowhooks = 0; /* cannot call hooks inside a hook */
lua_unlock(L); lua_unlock(L);
@@ -69,7 +119,7 @@ static void dohook (lua_State *L, lua_Debug *ar, lua_Hook hook) {
lua_lock(L); lua_lock(L);
lua_assert(L->allowhooks == 0); lua_assert(L->allowhooks == 0);
L->allowhooks = 1; L->allowhooks = 1;
L->top = old_top; L->top = L->ci->top;
} }
@@ -95,66 +145,82 @@ void luaD_callHook (lua_State *L, lua_Hook callhook, const char *event) {
} }
static CallInfo *growci (lua_State *L) { static void correctCI (lua_State *L, CallInfo *oldci) {
lua_assert(L->ci == L->end_ci); struct lua_longjmp *lj;
luaM_reallocvector(L, L->base_ci, L->size_ci, 2*L->size_ci, CallInfo); for (lj = L->errorJmp; lj && lj->stack == L->stack; lj = lj->previous) {
L->ci = L->base_ci + L->size_ci; lj->ci = (lj->ci - oldci) + L->base_ci;
L->size_ci *= 2; }
L->end_ci = L->base_ci + L->size_ci;
return L->ci;
} }
static void adjust_varargs (lua_State *L, StkId base, int nfixargs) { void luaD_reallocCI (lua_State *L, int newsize) {
CallInfo *oldci = L->base_ci;
luaM_reallocvector(L, L->base_ci, L->size_ci, newsize, CallInfo);
L->size_ci = newsize;
if (oldci != L->ci) {
L->ci = (L->ci - oldci) + L->base_ci;
L->end_ci = L->base_ci + L->size_ci;
correctCI(L, oldci);
}
}
static void adjust_varargs (lua_State *L, int nfixargs) {
int i; int i;
Table *htab; Table *htab;
TObject n, nname; TObject n, nname;
StkId firstvar = base + nfixargs; /* position of first vararg */ int actual = L->top - L->ci->base; /* actual number of arguments */
if (L->top < firstvar) { if (actual < nfixargs) {
luaD_checkstack(L, firstvar - L->top); luaD_checkstack(L, nfixargs - actual);
while (L->top < firstvar) for (; actual < nfixargs; ++actual)
setnilvalue(L->top++); setnilvalue(L->top++);
} }
htab = luaH_new(L, 0, 0); actual -= nfixargs; /* number of extra arguments */
for (i=0; firstvar+i<L->top; i++) htab = luaH_new(L, 0, 0); /* create `arg' table */
luaH_setnum(L, htab, i+1, firstvar+i); for (i=0; i<actual; i++) /* put extra arguments into `arg' table */
luaH_setnum(L, htab, i+1, L->top - actual + i);
/* store counter in field `n' */ /* store counter in field `n' */
setnvalue(&n, i); setnvalue(&n, actual);
setsvalue(&nname, luaS_newliteral(L, "n")); setsvalue(&nname, luaS_newliteral(L, "n"));
luaH_set(L, htab, &nname, &n); luaH_set(L, htab, &nname, &n);
L->top = firstvar; /* remove elements from the stack */ L->top -= actual; /* remove extra elements from the stack */
sethvalue(L->top, htab); sethvalue(L->top, htab);
incr_top; incr_top(L);
} }
StkId luaD_precall (lua_State *L, StkId func) { StkId luaD_precall (lua_State *L, StkId func) {
CallInfo *ci; CallInfo *ci;
LClosure *cl; LClosure *cl;
if (++L->ci == L->end_ci) luaD_reallocCI(L, 2*L->size_ci);
ci = L->ci;
ci->base = func+1;
ci->pc = NULL;
if (ttype(func) != LUA_TFUNCTION) { if (ttype(func) != LUA_TFUNCTION) {
/* `func' is not a function; check the `function' tag method */ /* `func' is not a function; check the `function' tag method */
const TObject *tm = luaT_gettmbyobj(L, func, TM_CALL); const TObject *tm = luaT_gettmbyobj(L, func, TM_CALL);
if (ttype(tm) != LUA_TFUNCTION) if (ttype(tm) != LUA_TFUNCTION) {
L->ci--; /* undo increment (no function here) */
luaG_typeerror(L, func, "call"); luaG_typeerror(L, func, "call");
}
luaD_openstack(L, func); luaD_openstack(L, func);
func = ci->base - 1; /* previous call may change stack */
setobj(func, tm); /* tag method is the new function to be called */ setobj(func, tm); /* tag method is the new function to be called */
} }
ci = ++L->ci;
if (L->ci == L->end_ci) ci = growci(L);
ci->base = func+1;
if (L->callhook)
luaD_callHook(L, L->callhook, "call");
cl = &clvalue(func)->l; cl = &clvalue(func)->l;
if (L->callhook) {
luaD_callHook(L, L->callhook, "call");
ci = L->ci; /* previous call may realocate `ci' */
}
if (!cl->isC) { /* Lua function? prepare its call */ if (!cl->isC) { /* Lua function? prepare its call */
StkId base = func+1;
Proto *p = cl->p; Proto *p = cl->p;
ci->savedpc = p->code; /* starting point */ ci->savedpc = p->code; /* starting point */
if (p->is_vararg) /* varargs? */ if (p->is_vararg) /* varargs? */
adjust_varargs(L, base, p->numparams); adjust_varargs(L, p->numparams);
if (base > L->stack_last - p->maxstacksize) if (ci->base > L->stack_last - p->maxstacksize)
luaD_stackerror(L); luaD_growstack(L, p->maxstacksize);
ci->line = 0; ci->line = 0;
ci->top = base + p->maxstacksize; ci->top = ci->base + p->maxstacksize;
while (L->top < ci->top) while (L->top < ci->top)
setnilvalue(L->top++); setnilvalue(L->top++);
L->top = ci->top; L->top = ci->top;
@@ -162,13 +228,12 @@ StkId luaD_precall (lua_State *L, StkId func) {
} }
else { /* if is a C function, call it */ else { /* if is a C function, call it */
int n; int n;
ci->savedpc = NULL;
luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */ luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
lua_unlock(L); lua_unlock(L);
#if LUA_COMPATUPVALUES #if LUA_COMPATUPVALUES
lua_pushupvalues(L); lua_pushupvalues(L);
#endif #endif
n = (*clvalue(func)->c.f)(L); /* do the actual call */ n = (*clvalue(ci->base-1)->c.f)(L); /* do the actual call */
lua_lock(L); lua_lock(L);
return L->top - n; return L->top - n;
} }
@@ -177,9 +242,12 @@ StkId luaD_precall (lua_State *L, StkId func) {
void luaD_poscall (lua_State *L, int wanted, StkId firstResult) { void luaD_poscall (lua_State *L, int wanted, StkId firstResult) {
StkId res; StkId res;
if (L->callhook) if (L->callhook) {
StkId stack = L->stack; /* next call may change stack */
luaD_callHook(L, L->callhook, "return"); luaD_callHook(L, L->callhook, "return");
res = L->ci->base - 1; /* `func' = final position of 1st result */ firstResult = (firstResult - stack) + L->stack;
}
res = L->ci->base - 1; /* func == final position of 1st result */
L->ci--; L->ci--;
/* move results to correct place */ /* move results to correct place */
while (wanted != 0 && firstResult < L->top) { while (wanted != 0 && firstResult < L->top) {
@@ -223,7 +291,7 @@ static void resume_results (lua_State *L, lua_State *from, int numresults) {
while (numresults) { while (numresults) {
setobj(L->top, from->top - numresults); setobj(L->top, from->top - numresults);
numresults--; numresults--;
incr_top; incr_top(L);
} }
} }
@@ -231,7 +299,7 @@ static void resume_results (lua_State *L, lua_State *from, int numresults) {
LUA_API void lua_resume (lua_State *L, lua_State *co) { LUA_API void lua_resume (lua_State *L, lua_State *co) {
StkId firstResult; StkId firstResult;
lua_lock(L); lua_lock(L);
if (co->ci->savedpc == NULL) /* no activation record? */ if (co->ci == co->base_ci) /* no activation record? ?? */
luaD_error(L, "thread is dead - cannot be resumed"); luaD_error(L, "thread is dead - cannot be resumed");
lua_assert(co->errorJmp == NULL); lua_assert(co->errorJmp == NULL);
co->errorJmp = L->errorJmp; co->errorJmp = L->errorJmp;
@@ -253,15 +321,13 @@ LUA_API void lua_resume (lua_State *L, lua_State *co) {
LUA_API int lua_yield (lua_State *L, int nresults) { LUA_API int lua_yield (lua_State *L, int nresults) {
CallInfo *ci; CallInfo *ci;
int ibase;
lua_lock(L); lua_lock(L);
ci = L->ci; ci = L->ci;
if (ci_func(ci-1)->c.isC) if (ci_func(ci-1)->c.isC)
luaD_error(L, "cannot `yield' a C function"); luaD_error(L, "cannot `yield' a C function");
ci->yield_results = nresults; /* very dirty trick! */ ci->yield_results = nresults;
ibase = L->top - (ci-1)->base;
lua_unlock(L); lua_unlock(L);
return ibase; return -1;
} }
@@ -280,16 +346,15 @@ static void f_call (lua_State *L, void *ud) {
LUA_API int lua_call (lua_State *L, int nargs, int nresults) { LUA_API int lua_call (lua_State *L, int nargs, int nresults) {
StkId func;
struct CallS c; struct CallS c;
int status; int status;
lua_lock(L); lua_lock(L);
func = L->top - (nargs+1); /* function to be called */ c.func = L->top - (nargs+1); /* function to be called */
c.func = func; c.nresults = nresults; c.nresults = nresults;
status = luaD_runprotected(L, f_call, &c); status = luaD_runprotected(L, f_call, &c);
if (status != 0) { /* an error occurred? */ if (status != 0) { /* an error occurred? */
luaF_close(L, func); /* close eventual pending closures */ L->top -= nargs+1; /* remove parameters and func from the stack */
L->top = func; /* remove parameters from the stack */ luaF_close(L, L->top); /* close eventual pending closures */
} }
lua_unlock(L); lua_unlock(L);
return status; return status;
@@ -310,7 +375,7 @@ static void f_parser (lua_State *L, void *ud) {
Closure *cl = luaF_newLclosure(L, 0); Closure *cl = luaF_newLclosure(L, 0);
cl->l.p = tf; cl->l.p = tf;
setclvalue(L->top, cl); setclvalue(L->top, cl);
incr_top; incr_top(L);
} }
@@ -351,7 +416,7 @@ LUA_API int lua_loadfile (lua_State *L, const char *filename) {
if (f == NULL) return LUA_ERRFILE; /* unable to reopen file */ if (f == NULL) return LUA_ERRFILE; /* unable to reopen file */
} }
lua_pushliteral(L, "@"); lua_pushliteral(L, "@");
lua_pushstring(L, (filename == NULL) ? "(stdin)" : filename); lua_pushstring(L, (filename == NULL) ? "=stdin" : filename);
lua_concat(L, 2); lua_concat(L, 2);
nlevel = lua_gettop(L); nlevel = lua_gettop(L);
filename = lua_tostring(L, -1); /* filename = `@'..filename */ filename = lua_tostring(L, -1); /* filename = `@'..filename */
@@ -380,28 +445,17 @@ LUA_API int lua_loadbuffer (lua_State *L, const char *buff, size_t size,
** ======================================================= ** =======================================================
*/ */
/* chain list of long jump buffers */
struct lua_longjmp {
jmp_buf b;
struct lua_longjmp *previous;
volatile int status; /* error code */
int ci; /* index of call info of active function that set protection */
StkId top; /* top stack when protection was set */
int allowhooks; /* `allowhook' state when protection was set */
};
static void message (lua_State *L, const char *s) { static void message (lua_State *L, const char *s) {
TObject o, m; TObject o, m;
setsvalue(&o, luaS_newliteral(L, LUA_ERRORMESSAGE)); setsvalue(&o, luaS_newliteral(L, LUA_ERRORMESSAGE));
luaV_gettable(L, gt(L), &o, &m); luaV_gettable(L, gt(L), &o, &m);
if (ttype(&m) == LUA_TFUNCTION) { if (ttype(&m) == LUA_TFUNCTION) {
StkId top = L->top; setobj(L->top, &m);
setobj(top, &m); incr_top(L);
incr_top; setsvalue(L->top, luaS_new(L, s));
setsvalue(top+1, luaS_new(L, s)); incr_top(L);
incr_top; luaD_call(L, L->top-2, 0);
luaD_call(L, top, 0);
} }
} }
@@ -410,13 +464,7 @@ static void message (lua_State *L, const char *s) {
** Reports an error, and jumps up to the available recovery label ** Reports an error, and jumps up to the available recovery label
*/ */
void luaD_error (lua_State *L, const char *s) { void luaD_error (lua_State *L, const char *s) {
if (s) { if (s) message(L, s);
if (L->ci->savedpc) { /* error in Lua function preamble? */
L->ci->savedpc = NULL; /* pretend function was already running */
L->ci->pc = NULL;
}
message(L, s);
}
luaD_breakrun(L, LUA_ERRRUN); luaD_breakrun(L, LUA_ERRRUN);
} }
@@ -436,8 +484,9 @@ void luaD_breakrun (lua_State *L, int errcode) {
int luaD_runprotected (lua_State *L, void (*f)(lua_State *, void *), void *ud) { int luaD_runprotected (lua_State *L, void (*f)(lua_State *, void *), void *ud) {
struct lua_longjmp lj; struct lua_longjmp lj;
lj.ci = L->ci - L->base_ci; lj.ci = L->ci;
lj.top = L->top; lj.top = L->top;
lj.stack = L->stack;
lj.allowhooks = L->allowhooks; lj.allowhooks = L->allowhooks;
lj.status = 0; lj.status = 0;
lj.previous = L->errorJmp; /* chain new error handler */ lj.previous = L->errorJmp; /* chain new error handler */
@@ -445,7 +494,7 @@ int luaD_runprotected (lua_State *L, void (*f)(lua_State *, void *), void *ud) {
if (setjmp(lj.b) == 0) if (setjmp(lj.b) == 0)
(*f)(L, ud); (*f)(L, ud);
else { /* an error occurred: restore the state */ else { /* an error occurred: restore the state */
L->ci = L->base_ci + lj.ci; L->ci = lj.ci;
L->top = lj.top; L->top = lj.top;
L->allowhooks = lj.allowhooks; L->allowhooks = lj.allowhooks;
restore_stack_limit(L); restore_stack_limit(L);

12
ldo.h
View File

@@ -1,5 +1,5 @@
/* /*
** $Id: ldo.h,v 1.38 2002/01/11 20:24:39 roberto Exp $ ** $Id: ldo.h,v 1.1 2001/11/29 22:14:34 rieru Exp rieru $
** Stack and Call structure of Lua ** Stack and Call structure of Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@@ -16,10 +16,10 @@
** macro to increment stack top. ** macro to increment stack top.
** There must be always an empty slot at the L->stack.top ** There must be always an empty slot at the L->stack.top
*/ */
#define incr_top {if (L->top == L->stack_last) luaD_checkstack(L, 1); L->top++;} #define incr_top(L) \
{if (L->top >= L->stack_last) luaD_growstack(L, 1); L->top++;}
#define luaD_checkstack(L,n) if (L->stack_last-(n)<=L->top) luaD_growstack(L, n)
#define luaD_checkstack(L,n) if (L->stack_last-(n)<=L->top) luaD_stackerror(L)
void luaD_lineHook (lua_State *L, int line, lua_Hook linehook); void luaD_lineHook (lua_State *L, int line, lua_Hook linehook);
@@ -27,7 +27,9 @@ void luaD_callHook (lua_State *L, lua_Hook callhook, const char *event);
StkId luaD_precall (lua_State *L, StkId func); StkId luaD_precall (lua_State *L, StkId func);
void luaD_call (lua_State *L, StkId func, int nResults); void luaD_call (lua_State *L, StkId func, int nResults);
void luaD_poscall (lua_State *L, int wanted, StkId firstResult); void luaD_poscall (lua_State *L, int wanted, StkId firstResult);
void luaD_stackerror (lua_State *L); void luaD_reallocCI (lua_State *L, int newsize);
void luaD_reallocstack (lua_State *L, int newsize);
void luaD_growstack (lua_State *L, int n);
void luaD_error (lua_State *L, const char *s); void luaD_error (lua_State *L, const char *s);
void luaD_breakrun (lua_State *L, int errcode); void luaD_breakrun (lua_State *L, int errcode);

24
lgc.c
View File

@@ -20,7 +20,6 @@
#include "ltm.h" #include "ltm.h"
typedef struct GCState { typedef struct GCState {
Table *tmark; /* list of marked tables to be visited */ Table *tmark; /* list of marked tables to be visited */
Table *toclear; /* list of visited weak tables (to be cleared after GC) */ Table *toclear; /* list of visited weak tables (to be cleared after GC) */
@@ -36,13 +35,14 @@ typedef struct GCState {
/* mark tricks for userdata */ /* mark tricks for userdata */
#define isudmarked(u) (u->uv.len & 1) #define isudmarked(u) (u->uv.len & 1)
#define markud(u) (u->uv.len |= 1) #define markud(u) (u->uv.len |= 1)
#define unmarkud(u) (u->uv.len--) #define unmarkud(u) (u->uv.len &= (~(size_t)1))
/* mark tricks for upvalues (assume that open upvalues are always marked) */ /* mark tricks for upvalues (assume that open upvalues are always marked) */
#define isupvalmarked(uv) ((uv)->v != &(uv)->value) #define isupvalmarked(uv) ((uv)->v != &(uv)->value)
static void markobject (GCState *st, TObject *o); static void markobject (GCState *st, TObject *o);
@@ -122,6 +122,17 @@ static void markobject (GCState *st, TObject *o) {
} }
static void checkstacksizes (lua_State *L, StkId lim) {
int used = L->ci - L->base_ci; /* number of `ci' in use */
if (4*used < L->size_ci && 2*BASIC_CI_SIZE < L->size_ci)
luaD_reallocCI(L, L->size_ci/2); /* still big enough... */
if (lim < L->top) lim = L->top;
used = lim - L->stack; /* part of stack in use */
if (3*used < L->stacksize && 2*BASIC_STACK_SIZE < L->stacksize)
luaD_reallocstack(L, L->stacksize/2); /* still big enough... */
}
static void markstacks (GCState *st) { static void markstacks (GCState *st) {
lua_State *L1 = st->L; lua_State *L1 = st->L;
do { /* for each thread */ do { /* for each thread */
@@ -137,6 +148,7 @@ static void markstacks (GCState *st) {
lim = (L1->stack_last - L1->ci->base > MAXSTACK) ? L1->ci->base+MAXSTACK lim = (L1->stack_last - L1->ci->base > MAXSTACK) ? L1->ci->base+MAXSTACK
: L1->stack_last; : L1->stack_last;
for (; o<=lim; o++) setnilvalue(o); for (; o<=lim; o++) setnilvalue(o);
checkstacksizes(L1, lim);
lua_assert(L1->previous->next == L1 && L1->next->previous == L1); lua_assert(L1->previous->next == L1 && L1->next->previous == L1);
L1 = L1->next; L1 = L1->next;
} while (L1 != st->L); } while (L1 != st->L);
@@ -374,11 +386,10 @@ static void checkMbuffer (lua_State *L) {
static void do1gcTM (lua_State *L, Udata *udata) { static void do1gcTM (lua_State *L, Udata *udata) {
const TObject *tm = fasttm(L, udata->uv.eventtable, TM_GC); const TObject *tm = fasttm(L, udata->uv.eventtable, TM_GC);
if (tm != NULL) { if (tm != NULL) {
StkId top = L->top; setobj(L->top, tm);
setobj(top, tm); setuvalue(L->top+1, udata);
setuvalue(top+1, udata);
L->top += 2; L->top += 2;
luaD_call(L, top, 0); luaD_call(L, L->top - 2, 0);
} }
} }
@@ -396,6 +407,7 @@ static void unprotectedcallGCTM (lua_State *L, void *pu) {
do1gcTM(L, udata); do1gcTM(L, udata);
/* mark udata as finalized (default event table) */ /* mark udata as finalized (default event table) */
uvalue(L->top-1)->uv.eventtable = hvalue(defaultet(L)); uvalue(L->top-1)->uv.eventtable = hvalue(defaultet(L));
unmarkud(uvalue(L->top-1));
} }
L->top--; L->top--;
} }

5
llimits.h
View File

@@ -72,11 +72,6 @@ typedef unsigned char lu_byte;
#ifndef DEFAULT_STACK_SIZE
#define DEFAULT_STACK_SIZE 1024
#endif
/* type to ensure maximum alignment */ /* type to ensure maximum alignment */
#ifndef LUSER_ALIGNMENT_T #ifndef LUSER_ALIGNMENT_T

24
lstate.c
View File

@@ -20,6 +20,7 @@
#include "ltm.h" #include "ltm.h"
struct Sopen { struct Sopen {
int stacksize; int stacksize;
lua_State *L; lua_State *L;
@@ -29,21 +30,21 @@ struct Sopen {
static void close_state (lua_State *L); static void close_state (lua_State *L);
static void stack_init (lua_State *L, lua_State *OL, int stacksize) { static void stack_init (lua_State *L, lua_State *OL, int maxstacksize) {
if (stacksize == 0) if (maxstacksize == 0)
stacksize = DEFAULT_STACK_SIZE; maxstacksize = DEFAULT_MAXSTACK;
else else
stacksize += LUA_MINSTACK; maxstacksize += 2*LUA_MINSTACK;
stacksize += EXTRA_STACK; L->stack = luaM_newvector(OL, BASIC_STACK_SIZE, TObject);
L->stack = luaM_newvector(OL, stacksize, TObject); L->maxstacksize = maxstacksize;
L->stacksize = stacksize; L->stacksize = BASIC_STACK_SIZE;
L->top = L->stack + RESERVED_STACK_PREFIX; L->top = L->stack + RESERVED_STACK_PREFIX;
L->stack_last = L->stack+(L->stacksize-EXTRA_STACK)-1; L->stack_last = L->stack+(BASIC_STACK_SIZE-EXTRA_STACK)-1;
L->base_ci = luaM_newvector(OL, 10, CallInfo); L->base_ci = luaM_newvector(OL, BASIC_CI_SIZE, CallInfo);
L->ci = L->base_ci; L->ci = L->base_ci;
L->ci->base = L->top; L->ci->base = L->top;
L->ci->savedpc = NULL; L->ci->pc = NULL;
L->size_ci = 10; L->size_ci = BASIC_CI_SIZE;
L->end_ci = L->base_ci + L->size_ci; L->end_ci = L->base_ci + L->size_ci;
} }
@@ -84,6 +85,7 @@ static void f_luaopen (lua_State *L, void *ud) {
static void preinit_state (lua_State *L) { static void preinit_state (lua_State *L) {
L->stack = NULL; L->stack = NULL;
L->stacksize = 0; L->stacksize = 0;
L->maxstacksize = 1;
L->errorJmp = NULL; L->errorJmp = NULL;
L->callhook = NULL; L->callhook = NULL;
L->linehook = NULL; L->linehook = NULL;

15
lstate.h
View File

@@ -64,8 +64,17 @@ struct lua_longjmp; /* defined in ldo.c */
#define RESERVED_STACK_PREFIX 3 #define RESERVED_STACK_PREFIX 3
/* space to handle stack overflow errors */
#define EXTRA_STACK (2*LUA_MINSTACK) /* space to handle TM calls */
#define EXTRA_STACK 4
#define BASIC_CI_SIZE 6
#define BASIC_STACK_SIZE (2*LUA_MINSTACK)
#define DEFAULT_MAXSTACK 12000
@@ -84,6 +93,7 @@ typedef struct CallInfo {
const Instruction *savedpc; const Instruction *savedpc;
StkId top; /* top for this function (when it's a Lua function) */ StkId top; /* top for this function (when it's a Lua function) */
const Instruction **pc; const Instruction **pc;
StkId *pb;
/* extra information for line tracing */ /* extra information for line tracing */
int lastpc; /* last pc traced */ int lastpc; /* last pc traced */
int line; /* current line */ int line; /* current line */
@@ -124,6 +134,7 @@ struct lua_State {
StkId stack_last; /* last free slot in the stack */ StkId stack_last; /* last free slot in the stack */
StkId stack; /* stack base */ StkId stack; /* stack base */
int stacksize; int stacksize;
int maxstacksize;
CallInfo *end_ci; /* points after end of ci array*/ CallInfo *end_ci; /* points after end of ci array*/
CallInfo *base_ci; /* array of CallInfo's */ CallInfo *base_ci; /* array of CallInfo's */
int size_ci; /* size of array `base_ci' */ int size_ci; /* size of array `base_ci' */

12
ltests.c
View File

@@ -254,10 +254,14 @@ static int hash_query (lua_State *L) {
} }
static int Cstacklevel (lua_State *L) { static int stacklevel (lua_State *L) {
unsigned long a = 0; unsigned long a = 0;
lua_pushnumber(L, (int)(L->top - L->stack));
lua_pushnumber(L, (int)(L->stack_last - L->stack));
lua_pushnumber(L, (int)(L->ci - L->base_ci));
lua_pushnumber(L, (int)(L->end_ci - L->base_ci));
lua_pushnumber(L, (unsigned long)&a); lua_pushnumber(L, (unsigned long)&a);
return 1; return 5;
} }
@@ -307,7 +311,7 @@ static int string_query (lua_State *L) {
int n = 0; int n = 0;
for (ts = tb->hash[s]; ts; ts = ts->tsv.nexthash) { for (ts = tb->hash[s]; ts; ts = ts->tsv.nexthash) {
setsvalue(L->top, ts); setsvalue(L->top, ts);
incr_top; incr_top(L);
n++; n++;
} }
return n; return n;
@@ -629,7 +633,7 @@ static const struct luaL_reg tests_funcs[] = {
{"listk", listk}, {"listk", listk},
{"listlocals", listlocals}, {"listlocals", listlocals},
{"loadlib", loadlib}, {"loadlib", loadlib},
{"Cstacklevel", Cstacklevel}, {"stacklevel", stacklevel},
{"querystr", string_query}, {"querystr", string_query},
{"querytab", table_query}, {"querytab", table_query},
{"testC", testC}, {"testC", testC},

83
lvm.c
View File

@@ -29,10 +29,9 @@
static void luaV_checkGC (lua_State *L, StkId top) { static void luaV_checkGC (lua_State *L, StkId top) {
if (G(L)->nblocks >= G(L)->GCthreshold) { if (G(L)->nblocks >= G(L)->GCthreshold) {
StkId temp = L->top; L->top = top; /* limit for active registers */
L->top = top;
luaC_collectgarbage(L); luaC_collectgarbage(L);
L->top = temp; /* restore old top position */ L->top = L->ci->top; /* restore old top position */
} }
} }
@@ -83,32 +82,37 @@ static void traceexec (lua_State *L, lua_Hook linehook) {
if (newline != ci->line || pc <= ci->lastpc) { if (newline != ci->line || pc <= ci->lastpc) {
ci->line = newline; ci->line = newline;
luaD_lineHook(L, newline, linehook); luaD_lineHook(L, newline, linehook);
ci = L->ci; /* previous call may realocate `ci' */
} }
ci->lastpc = pc; ci->lastpc = pc;
} }
static void callTMres (lua_State *L, const TObject *f,
const TObject *p1, const TObject *p2, TObject *result ) {
StkId stack = L->stack;
setobj(L->top, f); /* push function */
setobj(L->top+1, p1); /* 1st argument */
setobj(L->top+2, p2); /* 2nd argument */
luaD_checkstack(L, 3); /* cannot check before (could invalidate p1, p2) */
L->top += 3;
luaD_call(L, L->top - 3, 1);
if (stack != L->stack) /* stack changed? */
result = (result - stack) + L->stack; /* correct pointer */
setobj(result, --L->top); /* get result */
}
/* maximum stack used by a call to a tag method (func + args) */
#define MAXSTACK_TM 4
static void callTM (lua_State *L, const TObject *f, static void callTM (lua_State *L, const TObject *f,
const TObject *p1, const TObject *p2, const TObject *p3, TObject *result ) { const TObject *p1, const TObject *p2, const TObject *p3) {
StkId base = L->top; setobj(L->top, f); /* push function */
luaD_checkstack(L, MAXSTACK_TM); setobj(L->top+1, p1); /* 1st argument */
setobj(base, f); /* push function */ setobj(L->top+2, p2); /* 2nd argument */
setobj(base+1, p1); /* 1st argument */ setobj(L->top+3, p3); /* 3th argument */
setobj(base+2, p2); /* 2nd argument */ luaD_checkstack(L, 4); /* cannot check before (could invalidate p1...p3) */
L->top += 3; L->top += 4;
if (p3) { luaD_call(L, L->top - 4, 0);
setobj(base+3, p3); /* 3th argument */
L->top++;
}
luaD_call(L, base, 1);
if (result) { /* need a result? */
setobj(result, base); /* get it */
}
L->top = base; /* restore top */
} }
@@ -139,7 +143,7 @@ void luaV_gettable (lua_State *L, StkId t, TObject *key, StkId res) {
} }
} }
if (ttype(tm) == LUA_TFUNCTION) if (ttype(tm) == LUA_TFUNCTION)
callTM(L, tm, t, key, NULL, res); callTMres(L, tm, t, key, res);
else { else {
t = (StkId)tm; /* ?? */ t = (StkId)tm; /* ?? */
goto init; /* return luaV_gettable(L, tm, key, res); */ goto init; /* return luaV_gettable(L, tm, key, res); */
@@ -167,7 +171,7 @@ void luaV_settable (lua_State *L, StkId t, TObject *key, StkId val) {
} }
} }
if (ttype(tm) == LUA_TFUNCTION) if (ttype(tm) == LUA_TFUNCTION)
callTM(L, tm, t, key, val, NULL); callTM(L, tm, t, key, val);
else { else {
t = (StkId)tm; /* ?? */ t = (StkId)tm; /* ?? */
goto init; /* luaV_settable(L, tm, key, val); */ goto init; /* luaV_settable(L, tm, key, val); */
@@ -181,7 +185,7 @@ static int call_binTM (lua_State *L, const TObject *p1, const TObject *p2,
if (ttype(tm) == LUA_TNIL) if (ttype(tm) == LUA_TNIL)
tm = luaT_gettmbyobj(L, p2, event); /* try second operand */ tm = luaT_gettmbyobj(L, p2, event); /* try second operand */
if (ttype(tm) != LUA_TFUNCTION) return 0; if (ttype(tm) != LUA_TFUNCTION) return 0;
callTM(L, tm, p1, p2, NULL, res); callTMres(L, tm, p1, p2, res);
return 1; return 1;
} }
@@ -229,7 +233,6 @@ int luaV_lessthan (lua_State *L, const TObject *l, const TObject *r) {
void luaV_strconc (lua_State *L, int total, int last) { void luaV_strconc (lua_State *L, int total, int last) {
luaV_checkGC(L, L->ci->base + last + 1);
do { do {
StkId top = L->ci->base + last + 1; StkId top = L->ci->base + last + 1;
int n = 2; /* number of elements handled in this pass (at least 2) */ int n = 2; /* number of elements handled in this pass (at least 2) */
@@ -273,7 +276,7 @@ static void powOp (lua_State *L, StkId ra, StkId rb, StkId rc) {
luaV_gettable(L, gt(L), &o, &f); luaV_gettable(L, gt(L), &o, &f);
if (ttype(&f) != LUA_TFUNCTION) if (ttype(&f) != LUA_TFUNCTION)
luaD_error(L, "`pow' (for `^' operator) is not a function"); luaD_error(L, "`pow' (for `^' operator) is not a function");
callTM(L, &f, b, c, NULL, ra); callTMres(L, &f, b, c, ra);
} }
else else
call_arith(L, rb, rc, ra, TM_POW); call_arith(L, rb, rc, ra, TM_POW);
@@ -324,17 +327,18 @@ StkId luaV_execute (lua_State *L) {
k = cl->p->k; k = cl->p->k;
linehook = L->linehook; linehook = L->linehook;
L->ci->pc = &pc; L->ci->pc = &pc;
L->ci->pb = &base;
pc = L->ci->savedpc; pc = L->ci->savedpc;
L->ci->savedpc = NULL;
/* main loop of interpreter */ /* main loop of interpreter */
for (;;) { for (;;) {
const Instruction i = *pc++; const Instruction i = *pc++;
const StkId ra = RA(i); StkId ra;
if (linehook) if (linehook)
traceexec(L, linehook); traceexec(L, linehook);
ra = RA(i);
lua_assert(L->top <= L->stack + L->stacksize && L->top >= L->ci->base);
lua_assert(L->top == L->ci->top || GET_OPCODE(i) == OP_CALL || lua_assert(L->top == L->ci->top || GET_OPCODE(i) == OP_CALL ||
GET_OPCODE(i) == OP_RETURN || GET_OPCODE(i) == OP_SETLISTO); GET_OPCODE(i) == OP_RETURN || GET_OPCODE(i) == OP_SETLISTO);
lua_assert(L->ci->savedpc == NULL);
switch (GET_OPCODE(i)) { switch (GET_OPCODE(i)) {
case OP_MOVE: { case OP_MOVE: {
setobj(ra, RB(i)); setobj(ra, RB(i));
@@ -344,10 +348,6 @@ StkId luaV_execute (lua_State *L) {
setobj(ra, KBc(i)); setobj(ra, KBc(i));
break; break;
} }
case OP_LOADINT: {
setnvalue(ra, (lua_Number)GETARG_sBc(i));
break;
}
case OP_LOADBOOL: { case OP_LOADBOOL: {
setbvalue(ra, GETARG_B(i)); setbvalue(ra, GETARG_B(i));
if (GETARG_C(i)) pc++; /* skip next instruction (if C) */ if (GETARG_C(i)) pc++; /* skip next instruction (if C) */
@@ -441,8 +441,9 @@ StkId luaV_execute (lua_State *L) {
case OP_CONCAT: { case OP_CONCAT: {
int b = GETARG_B(i); int b = GETARG_B(i);
int c = GETARG_C(i); int c = GETARG_C(i);
luaV_strconc(L, c-b+1, c); luaV_strconc(L, c-b+1, c); /* this call may change `base' (and `ra') */
setobj(ra, base+b); setobj(base+GETARG_A(i), base+b);
luaV_checkGC(L, base+c+1);
break; break;
} }
case OP_JMP: { case OP_JMP: {
@@ -493,7 +494,7 @@ StkId luaV_execute (lua_State *L) {
nresults = GETARG_C(i) - 1; nresults = GETARG_C(i) - 1;
firstResult = luaD_precall(L, ra); firstResult = luaD_precall(L, ra);
if (firstResult) { if (firstResult) {
if (firstResult == base) { /* yield?? */ if (firstResult > L->top) { /* yield? */
(L->ci-1)->savedpc = pc; (L->ci-1)->savedpc = pc;
return NULL; return NULL;
} }
@@ -514,16 +515,16 @@ StkId luaV_execute (lua_State *L) {
b = GETARG_B(i); b = GETARG_B(i);
if (b != 0) L->top = ra+b-1; if (b != 0) L->top = ra+b-1;
ci = L->ci - 1; ci = L->ci - 1;
if (ci->savedpc == NULL) lua_assert((ci+1)->pc == &pc);
return ra; if (ci->pc != &pc) /* previous function was running `here'? */
else { /* previous function is Lua: continue its execution */ return ra; /* no: return */
else { /* yes: continue its execution */
int nresults; int nresults;
lua_assert(ttype(ci->base-1) == LUA_TFUNCTION); lua_assert(ttype(ci->base-1) == LUA_TFUNCTION);
base = ci->base; /* restore previous values */ base = ci->base; /* restore previous values */
cl = &clvalue(base - 1)->l; cl = &clvalue(base - 1)->l;
k = cl->p->k; k = cl->p->k;
pc = ci->savedpc; pc = ci->savedpc;
ci->savedpc = NULL;
lua_assert(GET_OPCODE(*(pc-1)) == OP_CALL); lua_assert(GET_OPCODE(*(pc-1)) == OP_CALL);
nresults = GETARG_C(*(pc-1)) - 1; nresults = GETARG_C(*(pc-1)) - 1;
luaD_poscall(L, nresults, ra); luaD_poscall(L, nresults, ra);
@@ -607,7 +608,6 @@ StkId luaV_execute (lua_State *L) {
Proto *p; Proto *p;
Closure *ncl; Closure *ncl;
int nup, j; int nup, j;
luaV_checkGC(L, L->top);
p = cl->p->p[GETARG_Bc(i)]; p = cl->p->p[GETARG_Bc(i)];
nup = p->nupvalues; nup = p->nupvalues;
ncl = luaF_newLclosure(L, nup); ncl = luaF_newLclosure(L, nup);
@@ -621,6 +621,7 @@ StkId luaV_execute (lua_State *L) {
} }
} }
setclvalue(ra, ncl); setclvalue(ra, ncl);
luaV_checkGC(L, L->top);
break; break;
} }
} }