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

thead-specific state separated from "global" state

This commit is contained in:
Roberto Ierusalimschy 2001-01-19 11:20:30 -02:00
parent f2c451d745
commit 4ac58853dc
19 changed files with 268 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
lapi.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lapi.c,v 1.116 2001/01/10 18:56:11 roberto Exp roberto $
** $Id: lapi.c,v 1.117 2001/01/18 15:59:09 roberto Exp roberto $
** Lua API
** See Copyright Notice in lua.h
*/
@ -230,7 +230,7 @@ LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
LUA_API void lua_pushusertag (lua_State *L, void *u, int tag) {
/* ORDER LUA_T */
if (!(tag == LUA_ANYTAG || tag == LUA_TUSERDATA || validtag(tag)))
if (!(tag == LUA_ANYTAG || tag == LUA_TUSERDATA || validtag(G(L), tag)))
luaO_verror(L, "invalid tag for a userdata (%d)", tag);
setuvalue(L->top, luaS_createudata(L, u, tag));
api_incr_top(L);
@ -261,14 +261,14 @@ LUA_API void lua_gettable (lua_State *L, int index) {
LUA_API void lua_rawget (lua_State *L, int index) {
StkId t = Index(L, index);
LUA_ASSERT(ttype(t) == LUA_TTABLE, "table expected");
lua_assert(ttype(t) == LUA_TTABLE);
setobj(L->top - 1, luaH_get(hvalue(t), L->top - 1));
}
LUA_API void lua_rawgeti (lua_State *L, int index, int n) {
StkId o = Index(L, index);
LUA_ASSERT(ttype(o) == LUA_TTABLE, "table expected");
lua_assert(ttype(o) == LUA_TTABLE);
setobj(L->top, luaH_getnum(hvalue(o), n));
api_incr_top(L);
}
@ -284,9 +284,9 @@ LUA_API int lua_getref (lua_State *L, int ref) {
if (ref == LUA_REFNIL) {
setnilvalue(L->top);
}
else if (0 <= ref && ref < L->nref &&
(L->refArray[ref].st == LOCK || L->refArray[ref].st == HOLD)) {
setobj(L->top, &L->refArray[ref].o);
else if (0 <= ref && ref < G(L)->nref &&
(G(L)->refArray[ref].st == LOCK || G(L)->refArray[ref].st == HOLD)) {
setobj(L->top, &G(L)->refArray[ref].o);
}
else
return 0;
@ -324,7 +324,7 @@ LUA_API void lua_settable (lua_State *L, int index) {
LUA_API void lua_rawset (lua_State *L, int index) {
StkId t = Index(L, index);
LUA_ASSERT(ttype(t) == LUA_TTABLE, "table expected");
lua_assert(ttype(t) == LUA_TTABLE);
setobj(luaH_set(L, hvalue(t), L->top-2), (L->top-1));
L->top -= 2;
}
@ -332,7 +332,7 @@ LUA_API void lua_rawset (lua_State *L, int index) {
LUA_API void lua_rawseti (lua_State *L, int index, int n) {
StkId o = Index(L, index);
LUA_ASSERT(ttype(o) == LUA_TTABLE, "table expected");
lua_assert(ttype(o) == LUA_TTABLE);
setobj(luaH_setnum(L, hvalue(o), n), (L->top-1));
L->top--;
}
@ -340,7 +340,7 @@ LUA_API void lua_rawseti (lua_State *L, int index, int n) {
LUA_API void lua_setglobals (lua_State *L) {
StkId newtable = --L->top;
LUA_ASSERT(ttype(newtable) == LUA_TTABLE, "table expected");
lua_assert(ttype(newtable) == LUA_TTABLE);
L->gt = hvalue(newtable);
}
@ -350,17 +350,17 @@ LUA_API int lua_ref (lua_State *L, int lock) {
if (ttype(L->top-1) == LUA_TNIL)
ref = LUA_REFNIL;
else {
if (L->refFree != NONEXT) { /* is there a free place? */
ref = L->refFree;
L->refFree = L->refArray[ref].st;
if (G(L)->refFree != NONEXT) { /* is there a free place? */
ref = G(L)->refFree;
G(L)->refFree = G(L)->refArray[ref].st;
}
else { /* no more free places */
luaM_growvector(L, L->refArray, L->nref, L->sizeref, struct Ref,
luaM_growvector(L, G(L)->refArray, G(L)->nref, G(L)->sizeref, struct Ref,
MAX_INT, "reference table overflow");
ref = L->nref++;
ref = G(L)->nref++;
}
setobj(&L->refArray[ref].o, L->top-1);
L->refArray[ref].st = lock ? LOCK : HOLD;
setobj(&G(L)->refArray[ref].o, L->top-1);
G(L)->refArray[ref].st = lock ? LOCK : HOLD;
}
L->top--;
return ref;
@ -386,18 +386,18 @@ LUA_API void lua_rawcall (lua_State *L, int nargs, int nresults) {
#define GCunscale(x) ((mem_int)(x)<<10)
LUA_API int lua_getgcthreshold (lua_State *L) {
return GCscale(L->GCthreshold);
return GCscale(G(L)->GCthreshold);
}
LUA_API int lua_getgccount (lua_State *L) {
return GCscale(L->nblocks);
return GCscale(G(L)->nblocks);
}
LUA_API void lua_setgcthreshold (lua_State *L, int newthreshold) {
if (newthreshold > GCscale(ULONG_MAX))
L->GCthreshold = ULONG_MAX;
G(L)->GCthreshold = ULONG_MAX;
else
L->GCthreshold = GCunscale(newthreshold);
G(L)->GCthreshold = GCunscale(newthreshold);
luaC_checkGC(L);
}
@ -424,9 +424,9 @@ LUA_API void lua_settag (lua_State *L, int tag) {
LUA_API void lua_unref (lua_State *L, int ref) {
if (ref >= 0) {
LUA_ASSERT(ref < L->nref && L->refArray[ref].st < 0, "invalid ref");
L->refArray[ref].st = L->refFree;
L->refFree = ref;
lua_assert(ref < G(L)->nref && G(L)->refArray[ref].st < 0);
G(L)->refArray[ref].st = G(L)->refFree;
G(L)->refFree = ref;
}
}
@ -434,7 +434,7 @@ LUA_API void lua_unref (lua_State *L, int ref) {
LUA_API int lua_next (lua_State *L, int index) {
StkId t = luaA_index(L, index);
Node *n;
LUA_ASSERT(ttype(t) == LUA_TTABLE, "table expected");
lua_assert(ttype(t) == LUA_TTABLE);
n = luaH_next(L, hvalue(t), luaA_index(L, -1));
if (n) {
setobj(L->top-1, key(n));

16
lcode.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lcode.c,v 1.55 2000/12/28 12:55:41 roberto Exp roberto $
** $Id: lcode.c,v 1.56 2001/01/15 16:13:24 roberto Exp roberto $
** Code generator for Lua
** See Copyright Notice in lua.h
*/
@ -189,7 +189,7 @@ void luaK_storevar (LexState *ls, const expdesc *var) {
luaK_code2(fs, OP_SETTABLE, 3, 3);
break;
default:
LUA_INTERNALERROR("invalid var kind to store");
lua_assert(0); /* invalid var kind to store */
}
}
@ -205,7 +205,7 @@ static OpCode invertjump (OpCode op) {
case OP_JMPT: case OP_JMPONT: return OP_JMPF;
case OP_JMPF: case OP_JMPONF: return OP_JMPT;
default:
LUA_INTERNALERROR("invalid jump instruction");
lua_assert(0); /* invalid jump instruction */
return OP_JMP; /* to avoid warnings */
}
}
@ -280,7 +280,7 @@ static void luaK_testgo (FuncState *fs, expdesc *v, int invert, OpCode jump) {
discharge1(fs, v);
prevpos = fs->pc-1;
previous = &fs->f->code[prevpos];
LUA_ASSERT(*previous==previous_instruction(fs), "no jump allowed here");
lua_assert(*previous==previous_instruction(fs)); /* no jump allowed here */
if (!ISJUMP(GET_OPCODE(*previous)))
prevpos = luaK_code1(fs, jump, NO_JUMP);
else { /* last instruction is already a jump */
@ -398,14 +398,14 @@ void luaK_posfix (LexState *ls, BinOpr op, expdesc *v1, expdesc *v2) {
FuncState *fs = ls->fs;
switch (op) {
case OPR_AND: {
LUA_ASSERT(v1->u.l.t == NO_JUMP, "list must be closed");
lua_assert(v1->u.l.t == NO_JUMP); /* list must be closed */
discharge1(fs, v2);
v1->u.l.t = v2->u.l.t;
luaK_concat(fs, &v1->u.l.f, v2->u.l.f);
break;
}
case OPR_OR: {
LUA_ASSERT(v1->u.l.f == NO_JUMP, "list must be closed");
lua_assert(v1->u.l.f == NO_JUMP); /* list must be closed */
discharge1(fs, v2);
v1->u.l.f = v2->u.l.f;
luaK_concat(fs, &v1->u.l.t, v2->u.l.t);
@ -622,11 +622,11 @@ int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2) {
case OP_GETINDEXED:
case OP_TAILCALL:
case OP_ADDI: {
LUA_INTERNALERROR("instruction used only for optimizations");
lua_assert(0); /* instruction used only for optimizations */
break;
}
default: {
LUA_ASSERT(delta != VD, "invalid delta");
lua_assert(delta != VD);
break;
}
}

37
ldebug.c
View File

@ -1,5 +1,5 @@
/*
** $Id: ldebug.c,v 1.52 2000/12/26 18:46:09 roberto Exp roberto $
** $Id: ldebug.c,v 1.53 2001/01/18 15:59:09 roberto Exp roberto $
** Debug Interface
** See Copyright Notice in lua.h
*/
@ -96,20 +96,20 @@ int luaG_getline (int *lineinfo, int pc, int refline, int *prefi) {
refi = prefi ? *prefi : 0;
if (lineinfo[refi] < 0)
refline += -lineinfo[refi++];
LUA_ASSERT(lineinfo[refi] >= 0, "invalid line info");
lua_assert(lineinfo[refi] >= 0);
while (lineinfo[refi] > pc) {
refline--;
refi--;
if (lineinfo[refi] < 0)
refline -= -lineinfo[refi--];
LUA_ASSERT(lineinfo[refi] >= 0, "invalid line info");
lua_assert(lineinfo[refi] >= 0);
}
for (;;) {
int nextline = refline + 1;
int nextref = refi + 1;
if (lineinfo[nextref] < 0)
nextline += -lineinfo[nextref++];
LUA_ASSERT(lineinfo[nextref] >= 0, "invalid line info");
lua_assert(lineinfo[nextref] >= 0);
if (lineinfo[nextref] > pc)
break;
refline = nextline;
@ -122,7 +122,7 @@ int luaG_getline (int *lineinfo, int pc, int refline, int *prefi) {
static int currentpc (StkId f) {
CallInfo *ci = infovalue(f);
LUA_ASSERT(isLmark(f), "function has no pc");
lua_assert(isLmark(f));
if (ci->pc)
return (*ci->pc - ci->func->f.l->code) - 1;
else
@ -204,13 +204,13 @@ static void funcinfo (lua_State *L, lua_Debug *ar, StkId func) {
}
static const char *travtagmethods (lua_State *L, const TObject *o) {
static const char *travtagmethods (global_State *G, const TObject *o) {
if (ttype(o) == LUA_TFUNCTION) {
int e;
for (e=0; e<TM_N; e++) {
int t;
for (t=0; t<L->ntag; t++)
if (clvalue(o) == luaT_gettm(L, t, e))
for (t=0; t<G->ntag; t++)
if (clvalue(o) == luaT_gettm(G, t, e))
return luaT_eventname[e];
}
}
@ -237,7 +237,7 @@ static void getname (lua_State *L, StkId f, lua_Debug *ar) {
if ((ar->name = travglobals(L, &o)) != NULL)
ar->namewhat = "global";
/* not found: try tag methods */
else if ((ar->name = travtagmethods(L, &o)) != NULL)
else if ((ar->name = travtagmethods(G(L), &o)) != NULL)
ar->namewhat = "tag-method";
else ar->namewhat = ""; /* not found at all */
}
@ -308,22 +308,22 @@ static Instruction luaG_symbexec (const Proto *pt, int lastpc, int stackpos) {
top++; /* `arg' */
while (pc < lastpc) {
const Instruction i = code[pc++];
LUA_ASSERT(0 <= top && top <= pt->maxstacksize, "wrong stack");
lua_assert(0 <= top && top <= pt->maxstacksize);
switch (GET_OPCODE(i)) {
case OP_RETURN: {
LUA_ASSERT(top >= GETARG_U(i), "wrong stack");
lua_assert(top >= GETARG_U(i));
top = GETARG_U(i);
break;
}
case OP_TAILCALL: {
LUA_ASSERT(top >= GETARG_A(i), "wrong stack");
lua_assert(top >= GETARG_A(i));
top = GETARG_B(i);
break;
}
case OP_CALL: {
int nresults = GETARG_B(i);
if (nresults == MULT_RET) nresults = 1;
LUA_ASSERT(top >= GETARG_A(i), "wrong stack");
lua_assert(top >= GETARG_A(i));
top = pushpc(stack, pc, GETARG_A(i), nresults);
break;
}
@ -368,10 +368,9 @@ static Instruction luaG_symbexec (const Proto *pt, int lastpc, int stackpos) {
}
default: {
OpCode op = GET_OPCODE(i);
LUA_ASSERT(luaK_opproperties[op].push != VD,
"invalid opcode for default");
lua_assert(luaK_opproperties[op].push != VD);
top -= (int)luaK_opproperties[op].pop;
LUA_ASSERT(top >= 0, "wrong stack");
lua_assert(top >= 0);
top = pushpc(stack, pc, top, luaK_opproperties[op].push);
}
}
@ -389,7 +388,7 @@ static const char *getobjname (lua_State *L, StkId obj, const char **name) {
int pc = currentpc(func);
int stackpos = obj - (func+1); /* func+1 == function base */
Instruction i = luaG_symbexec(p, pc, stackpos);
LUA_ASSERT(pc != -1, "function must be active");
lua_assert(pc != -1);
switch (GET_OPCODE(i)) {
case OP_GETGLOBAL: {
*name = p->kstr[GETARG_U(i)]->str;
@ -397,7 +396,7 @@ static const char *getobjname (lua_State *L, StkId obj, const char **name) {
}
case OP_GETLOCAL: {
*name = luaF_getlocalname(p, GETARG_U(i)+1, pc);
LUA_ASSERT(*name, "local must exist");
lua_assert(*name);
return "local";
}
case OP_PUSHSELF:
@ -449,7 +448,7 @@ void luaG_typeerror (lua_State *L, StkId o, const char *op) {
void luaG_binerror (lua_State *L, StkId p1, int t, const char *op) {
if (ttype(p1) == t) p1++;
LUA_ASSERT(ttype(p1) != t, "must be an error");
lua_assert(ttype(p1) != t);
luaG_typeerror(L, p1, op);
}

16
ldo.c
View File

@ -1,5 +1,5 @@
/*
** $Id: ldo.c,v 1.113 2001/01/10 18:56:11 roberto Exp roberto $
** $Id: ldo.c,v 1.114 2001/01/18 15:59:09 roberto Exp roberto $
** Stack and Call structure of Lua
** See Copyright Notice in lua.h
*/
@ -55,7 +55,7 @@ void luaD_checkstack (lua_State *L, int n) {
}
else {
L->stack_last += EXTRA_STACK; /* to be used by error message */
LUA_ASSERT(L->stack_last == L->stack+L->stacksize-1, "wrong stack limit");
lua_assert(L->stack_last == L->stack+L->stacksize-1);
lua_error(L, "stack overflow");
}
}
@ -95,7 +95,7 @@ static void dohook (lua_State *L, lua_Debug *ar, lua_Hook hook) {
luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */
L->allowhooks = 0; /* cannot call hooks inside a hook */
(*hook)(L, ar);
LUA_ASSERT(L->allowhooks == 0, "invalid allow");
lua_assert(L->allowhooks == 0);
L->allowhooks = 1;
L->top = old_top;
L->Cbase = old_Cbase;
@ -161,7 +161,7 @@ void luaD_call (lua_State *L, StkId func, int nResults) {
Closure *cl;
if (ttype(func) != LUA_TFUNCTION) {
/* `func' is not a function; check the `function' tag method */
Closure *tm = luaT_gettmbyObj(L, func, TM_FUNCTION);
Closure *tm = luaT_gettmbyObj(G(L), func, TM_FUNCTION);
if (tm == NULL)
luaG_typeerror(L, func, "call");
luaD_openstack(L, func);
@ -177,7 +177,7 @@ void luaD_call (lua_State *L, StkId func, int nResults) {
luaV_execute(L, cl, func+1));
if (callhook) /* same hook that was active at entry */
luaD_callHook(L, func, callhook, "return");
LUA_ASSERT(ttype(func) == LUA_TMARK, "invalid tag");
lua_assert(ttype(func) == LUA_TMARK);
/* move results to `func' (to erase parameters and function) */
if (nResults == LUA_MULTRET) {
while (firstResult < L->top) /* copy all results */
@ -244,12 +244,12 @@ static int protectedparser (lua_State *L, ZIO *z, int bin) {
int status;
p.z = z; p.bin = bin;
luaC_checkGC(L);
old_blocks = L->nblocks;
old_blocks = G(L)->nblocks;
status = luaD_runprotected(L, f_parser, &p);
if (status == 0) {
/* add new memory to threshold (as it probably will stay) */
LUA_ASSERT(L->nblocks >= old_blocks, "cannot reduce memory usage here");
L->GCthreshold += (L->nblocks - old_blocks);
lua_assert(G(L)->nblocks >= old_blocks);
G(L)->GCthreshold += (G(L)->nblocks - old_blocks);
}
else if (status == LUA_ERRRUN) /* an error occurred: correct error code */
status = LUA_ERRSYNTAX;

10
lfunc.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lfunc.c,v 1.35 2000/12/04 18:33:40 roberto Exp roberto $
** $Id: lfunc.c,v 1.36 2000/12/28 12:55:41 roberto Exp roberto $
** Auxiliary functions to manipulate prototypes and closures
** See Copyright Notice in lua.h
*/
@ -19,8 +19,8 @@
Closure *luaF_newclosure (lua_State *L, int nelems) {
Closure *c = (Closure *)luaM_malloc(L, sizeclosure(nelems));
c->next = L->rootcl;
L->rootcl = c;
c->next = G(L)->rootcl;
G(L)->rootcl = c;
c->mark = c;
c->nupvalues = nelems;
return c;
@ -47,8 +47,8 @@ Proto *luaF_newproto (lua_State *L) {
f->locvars = NULL;
f->lineDefined = 0;
f->source = NULL;
f->next = L->rootproto; /* chain in list of protos */
L->rootproto = f;
f->next = G(L)->rootproto; /* chain in list of protos */
G(L)->rootproto = f;
return f;
}

85
lgc.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lgc.c,v 1.75 2000/12/28 12:55:41 roberto Exp roberto $
** $Id: lgc.c,v 1.76 2001/01/18 15:59:09 roberto Exp roberto $
** Garbage Collector
** See Copyright Notice in lua.h
*/
@ -54,11 +54,11 @@ static void markstack (lua_State *L, GCState *st) {
}
static void marklock (lua_State *L, GCState *st) {
static void marklock (global_State *G, GCState *st) {
int i;
for (i=0; i<L->nref; i++) {
if (L->refArray[i].st == LOCK)
markobject(st, &L->refArray[i].o);
for (i=0; i<G->nref; i++) {
if (G->refArray[i].st == LOCK)
markobject(st, &G->refArray[i].o);
}
}
@ -73,12 +73,12 @@ static void markclosure (GCState *st, Closure *cl) {
}
static void marktagmethods (lua_State *L, GCState *st) {
static void marktagmethods (global_State *G, GCState *st) {
int e;
for (e=0; e<TM_N; e++) {
int t;
for (t=0; t<L->ntag; t++) {
Closure *cl = luaT_gettm(L, t, e);
for (t=0; t<G->ntag; t++) {
Closure *cl = luaT_gettm(G, t, e);
if (cl) markclosure(st, cl);
}
}
@ -113,9 +113,9 @@ static void markall (lua_State *L) {
st.cmark = NULL;
st.tmark = L->gt; /* put table of globals in mark list */
L->gt->mark = NULL;
marktagmethods(L, &st); /* mark tag methods */
marktagmethods(G(L), &st); /* mark tag methods */
markstack(L, &st); /* mark stack objects */
marklock(L, &st); /* mark locked objects */
marklock(G(L), &st); /* mark locked objects */
for (;;) { /* mark tables and closures */
if (st.cmark) {
int i;
@ -161,27 +161,26 @@ static int hasmark (const TObject *o) {
/* macro for internal debugging; check if a link of free refs is valid */
#define VALIDLINK(L, st,n) (NONEXT <= (st) && (st) < (n))
static void invalidaterefs (lua_State *L) {
int n = L->nref;
static void invalidaterefs (global_State *G) {
int n = G->nref;
int i;
for (i=0; i<n; i++) {
struct Ref *r = &L->refArray[i];
struct Ref *r = &G->refArray[i];
if (r->st == HOLD && !hasmark(&r->o))
r->st = COLLECTED;
LUA_ASSERT((r->st == LOCK && hasmark(&r->o)) ||
lua_assert((r->st == LOCK && hasmark(&r->o)) ||
(r->st == HOLD && hasmark(&r->o)) ||
r->st == COLLECTED ||
r->st == NONEXT ||
(r->st < n && VALIDLINK(L, L->refArray[r->st].st, n)),
"inconsistent ref table");
(r->st < n && VALIDLINK(L, G->refArray[r->st].st, n)));
}
LUA_ASSERT(VALIDLINK(L, L->refFree, n), "inconsistent ref table");
lua_assert(VALIDLINK(L, G->refFree, n));
}
static void collectproto (lua_State *L) {
Proto **p = &L->rootproto;
Proto **p = &G(L)->rootproto;
Proto *next;
while ((next = *p) != NULL) {
if (next->marked) {
@ -197,7 +196,7 @@ static void collectproto (lua_State *L) {
static void collectclosure (lua_State *L) {
Closure **p = &L->rootcl;
Closure **p = &G(L)->rootcl;
Closure *next;
while ((next = *p) != NULL) {
if (ismarked(next)) {
@ -213,7 +212,7 @@ static void collectclosure (lua_State *L) {
static void collecttable (lua_State *L) {
Hash **p = &L->roottable;
Hash **p = &G(L)->roottable;
Hash *next;
while ((next = *p) != NULL) {
if (ismarked(next)) {
@ -236,8 +235,8 @@ static void checktab (lua_State *L, stringtable *tb) {
static void collectstrings (lua_State *L, int all) {
int i;
for (i=0; i<L->strt.size; i++) { /* for each list */
TString **p = &L->strt.hash[i];
for (i=0; i<G(L)->strt.size; i++) { /* for each list */
TString **p = &G(L)->strt.hash[i];
TString *next;
while ((next = *p) != NULL) {
if (next->marked && !all) { /* preserve? */
@ -247,22 +246,22 @@ static void collectstrings (lua_State *L, int all) {
}
else { /* collect */
*p = next->nexthash;
L->strt.nuse--;
G(L)->strt.nuse--;
luaM_free(L, next, sizestring(next->len));
}
}
}
checktab(L, &L->strt);
checktab(L, &G(L)->strt);
}
static void collectudata (lua_State *L, int all) {
int i;
for (i=0; i<L->udt.size; i++) { /* for each list */
TString **p = &L->udt.hash[i];
for (i=0; i<G(L)->udt.size; i++) { /* for each list */
TString **p = &G(L)->udt.hash[i];
TString *next;
while ((next = *p) != NULL) {
LUA_ASSERT(next->marked <= 1, "udata cannot be fixed");
lua_assert(next->marked <= 1);
if (next->marked && !all) { /* preserve? */
next->marked = 0;
p = &next->nexthash;
@ -270,28 +269,28 @@ static void collectudata (lua_State *L, int all) {
else { /* collect */
int tag = next->u.d.tag;
*p = next->nexthash;
next->nexthash = L->TMtable[tag].collected; /* chain udata */
L->TMtable[tag].collected = next;
L->udt.nuse--;
next->nexthash = G(L)->TMtable[tag].collected; /* chain udata */
G(L)->TMtable[tag].collected = next;
G(L)->udt.nuse--;
}
}
}
checktab(L, &L->udt);
checktab(L, &G(L)->udt);
}
#define MINBUFFER 256
static void checkMbuffer (lua_State *L) {
if (L->Mbuffsize > MINBUFFER*2) { /* is buffer too big? */
size_t newsize = L->Mbuffsize/2; /* still larger than MINBUFFER */
luaM_reallocvector(L, L->Mbuffer, L->Mbuffsize, newsize, char);
L->Mbuffsize = newsize;
if (G(L)->Mbuffsize > MINBUFFER*2) { /* is buffer too big? */
size_t newsize = G(L)->Mbuffsize/2; /* still larger than MINBUFFER */
luaM_reallocvector(L, G(L)->Mbuffer, G(L)->Mbuffsize, newsize, char);
G(L)->Mbuffsize = newsize;
}
}
static void callgcTM (lua_State *L, const TObject *obj) {
Closure *tm = luaT_gettmbyObj(L, obj, TM_GC);
Closure *tm = luaT_gettmbyObj(G(L), obj, TM_GC);
if (tm != NULL) {
int oldah = L->allowhooks;
L->allowhooks = 0; /* stop debug hooks during GC tag methods */
@ -307,12 +306,12 @@ static void callgcTM (lua_State *L, const TObject *obj) {
static void callgcTMudata (lua_State *L) {
int tag;
L->GCthreshold = 2*L->nblocks; /* avoid GC during tag methods */
for (tag=L->ntag-1; tag>=0; tag--) { /* for each tag (in reverse order) */
G(L)->GCthreshold = 2*G(L)->nblocks; /* avoid GC during tag methods */
for (tag=G(L)->ntag-1; tag>=0; tag--) { /* for each tag (in reverse order) */
TString *udata;
while ((udata = L->TMtable[tag].collected) != NULL) {
while ((udata = G(L)->TMtable[tag].collected) != NULL) {
TObject obj;
L->TMtable[tag].collected = udata->nexthash; /* remove it from list */
G(L)->TMtable[tag].collected = udata->nexthash; /* remove it from list */
setuvalue(&obj, udata);
callgcTM(L, &obj);
luaM_free(L, udata, sizeudata(udata->len));
@ -333,16 +332,16 @@ void luaC_collect (lua_State *L, int all) {
static void luaC_collectgarbage (lua_State *L) {
markall(L);
invalidaterefs(L); /* check unlocked references */
invalidaterefs(G(L)); /* check unlocked references */
luaC_collect(L, 0);
checkMbuffer(L);
L->GCthreshold = 2*L->nblocks; /* set new threshold */
G(L)->GCthreshold = 2*G(L)->nblocks; /* set new threshold */
callgcTM(L, &luaO_nilobject);
}
void luaC_checkGC (lua_State *L) {
if (L->nblocks >= L->GCthreshold)
if (G(L)->nblocks >= G(L)->GCthreshold)
luaC_collectgarbage(L);
}

18
llex.c
View File

@ -1,5 +1,5 @@
/*
** $Id: llex.c,v 1.74 2001/01/10 17:41:50 roberto Exp roberto $
** $Id: llex.c,v 1.75 2001/01/15 18:07:56 roberto Exp roberto $
** Lexical Analyzer
** See Copyright Notice in lua.h
*/
@ -35,7 +35,7 @@ void luaX_init (lua_State *L) {
int i;
for (i=0; i<NUM_RESERVED; i++) {
TString *ts = luaS_new(L, token2string[i]);
LUA_ASSERT(strlen(token2string[i])+1 <= TOKEN_LEN, "incorrect token_len");
lua_assert(strlen(token2string[i])+1 <= TOKEN_LEN);
ts->marked = (unsigned char)(RESERVEDMARK+i); /* reserved word */
}
}
@ -65,7 +65,7 @@ void luaX_error (LexState *ls, const char *s, int token) {
char buff[TOKEN_LEN];
luaX_token2str(token, buff);
if (buff[0] == '\0')
luaX_syntaxerror(ls, s, ls->L->Mbuffer);
luaX_syntaxerror(ls, s, G(ls->L)->Mbuffer);
else
luaX_syntaxerror(ls, s, buff);
}
@ -123,10 +123,10 @@ void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source) {
/* use Mbuffer to store names, literal strings and numbers */
#define EXTRABUFF 128
#define checkbuffer(L, n, len) if ((len)+(n) > L->Mbuffsize) \
#define checkbuffer(L, n, len) if ((len)+(n) > G(L)->Mbuffsize) \
luaO_openspace(L, (len)+(n)+EXTRABUFF)
#define save(L, c, l) (L->Mbuffer[l++] = (char)c)
#define save(L, c, l) (G(L)->Mbuffer[l++] = (char)c)
#define save_and_next(L, LS, l) (save(L, LS->current, l), next(LS))
@ -176,7 +176,7 @@ static void read_number (LexState *LS, int comma, SemInfo *seminfo) {
}
}
save(L, '\0', l);
if (!luaO_str2d(L->Mbuffer, &seminfo->r))
if (!luaO_str2d(G(L)->Mbuffer, &seminfo->r))
luaX_error(LS, "malformed number", TK_NUMBER);
}
@ -220,7 +220,7 @@ static void read_long_string (LexState *LS, SemInfo *seminfo) {
} endloop:
save_and_next(L, LS, l); /* skip the second ']' */
save(L, '\0', l);
seminfo->ts = luaS_newlstr(L, L->Mbuffer+2, l-5);
seminfo->ts = luaS_newlstr(L, G(L)->Mbuffer+2, l-5);
}
@ -272,7 +272,7 @@ static void read_string (LexState *LS, int del, SemInfo *seminfo) {
}
save_and_next(L, LS, l); /* skip delimiter */
save(L, '\0', l);
seminfo->ts = luaS_newlstr(L, L->Mbuffer+1, l-3);
seminfo->ts = luaS_newlstr(L, G(L)->Mbuffer+1, l-3);
}
@ -367,7 +367,7 @@ int luaX_lex (LexState *LS, SemInfo *seminfo) {
}
tname: { /* identifier or reserved word */
size_t l = readname(LS);
TString *ts = luaS_newlstr(LS->L, LS->L->Mbuffer, l);
TString *ts = luaS_newlstr(LS->L, G(LS->L)->Mbuffer, l);
if (ts->marked >= RESERVEDMARK) /* reserved word? */
return ts->marked-RESERVEDMARK+FIRST_RESERVED;
seminfo->ts = ts;

8
lmem.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lmem.c,v 1.41 2000/12/26 18:46:09 roberto Exp roberto $
** $Id: lmem.c,v 1.42 2000/12/28 12:55:41 roberto Exp roberto $
** Interface to Memory Manager
** See Copyright Notice in lua.h
*/
@ -161,9 +161,9 @@ void *luaM_realloc (lua_State *L, void *block, luint32 oldsize, luint32 size) {
else return NULL; /* error before creating state! */
}
}
if (L) {
L->nblocks -= oldsize;
L->nblocks += size;
if (L && G(L)) {
G(L)->nblocks -= oldsize;
G(L)->nblocks += size;
}
return block;
}

12
lobject.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lobject.c,v 1.57 2000/12/04 18:33:40 roberto Exp roberto $
** $Id: lobject.c,v 1.58 2000/12/28 12:55:41 roberto Exp roberto $
** Some generic functions over Lua objects
** See Copyright Notice in lua.h
*/
@ -49,18 +49,18 @@ int luaO_equalObj (const TObject *t1, const TObject *t2) {
case LUA_TFUNCTION:
return clvalue(t1) == clvalue(t2);
default:
LUA_ASSERT(ttype(t1) == LUA_TNIL, "invalid type");
lua_assert(ttype(t1) == LUA_TNIL);
return 1; /* LUA_TNIL */
}
}
char *luaO_openspace (lua_State *L, size_t n) {
if (n > L->Mbuffsize) {
luaM_reallocvector(L, L->Mbuffer, L->Mbuffsize, n, char);
L->Mbuffsize = n;
if (n > G(L)->Mbuffsize) {
luaM_reallocvector(L, G(L)->Mbuffer, G(L)->Mbuffsize, n, char);
G(L)->Mbuffsize = n;
}
return L->Mbuffer;
return G(L)->Mbuffer;
}

30
lobject.h
View File

@ -1,5 +1,5 @@
/*
** $Id: lobject.h,v 1.85 2000/12/28 12:55:41 roberto Exp roberto $
** $Id: lobject.h,v 1.86 2001/01/18 15:59:09 roberto Exp roberto $
** Type definitions for Lua objects
** See Copyright Notice in lua.h
*/
@ -15,11 +15,9 @@
#ifdef LUA_DEBUG
#undef NDEBUG
#include <assert.h>
#define LUA_INTERNALERROR(s) assert(((void)s,0))
#define LUA_ASSERT(c,s) assert(((void)s,(c)))
#define lua_assert(c) assert(c)
#else
#define LUA_INTERNALERROR(s) /* empty */
#define LUA_ASSERT(c,s) /* empty */
#define lua_assert(c) /* empty */
#endif
@ -67,27 +65,27 @@ typedef struct lua_TObject {
/* Macros to set values */
#define setnvalue(obj,x) \
{ TObject *o=(obj); o->tt=LUA_TNUMBER; o->value.n=(x); }
{ TObject *_o=(obj); _o->tt=LUA_TNUMBER; _o->value.n=(x); }
#define setsvalue(obj,x) \
{ TObject *o=(obj); struct TString *v=(x); \
o->tt=LUA_TSTRING; o->value.v=v; }
{ TObject *_o=(obj); struct TString *_v=(x); \
_o->tt=LUA_TSTRING; _o->value.v=_v; }
#define setuvalue(obj,x) \
{ TObject *o=(obj); struct TString *v=(x); \
o->tt=LUA_TUSERDATA; o->value.v=v; }
{ TObject *_o=(obj); struct TString *_v=(x); \
_o->tt=LUA_TUSERDATA; _o->value.v=_v; }
#define setclvalue(obj,x) \
{ TObject *o=(obj); struct Closure *v=(x); \
o->tt=LUA_TFUNCTION; o->value.v=v; }
{ TObject *_o=(obj); struct Closure *_v=(x); \
_o->tt=LUA_TFUNCTION; _o->value.v=_v; }
#define sethvalue(obj,x) \
{ TObject *o=(obj); struct Hash *v=(x); \
o->tt=LUA_TTABLE; o->value.v=v; }
{ TObject *_o=(obj); struct Hash *_v=(x); \
_o->tt=LUA_TTABLE; _o->value.v=_v; }
#define setivalue(obj,x) \
{ TObject *o=(obj); struct CallInfo *v=(x); \
o->tt=LUA_TMARK; o->value.v=v; }
{ TObject *_o=(obj); struct CallInfo *_v=(x); \
_o->tt=LUA_TMARK; _o->value.v=_v; }
#define setnilvalue(obj) { (obj)->tt=LUA_TNIL; }

15
lparser.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lparser.c,v 1.123 2001/01/10 17:41:50 roberto Exp roberto $
** $Id: lparser.c,v 1.124 2001/01/15 16:13:24 roberto Exp roberto $
** LL(1) Parser and code generator for Lua
** See Copyright Notice in lua.h
*/
@ -65,7 +65,7 @@ static void next (LexState *ls) {
static void lookahead (LexState *ls) {
LUA_ASSERT(ls->lookahead.token == TK_EOS, "two look-aheads");
lua_assert(ls->lookahead.token == TK_EOS);
ls->lookahead.token = luaX_lex(ls, &ls->lookahead.seminfo);
}
@ -285,7 +285,7 @@ static void enterbreak (FuncState *fs, Breaklabel *bl) {
static void leavebreak (FuncState *fs, Breaklabel *bl) {
fs->bl = bl->previous;
LUA_ASSERT(bl->stacklevel == fs->stacklevel, "wrong levels");
lua_assert(bl->stacklevel == fs->stacklevel);
luaK_patchlist(fs, bl->breaklist, luaK_getlabel(fs));
}
@ -352,7 +352,7 @@ static void close_func (LexState *ls) {
f->lineinfo[fs->nlineinfo++] = MAX_INT; /* end flag */
f->sizelineinfo = fs->nlineinfo;
ls->fs = fs->prev;
LUA_ASSERT(fs->bl == NULL, "wrong list end");
lua_assert(fs->bl == NULL);
}
@ -365,8 +365,8 @@ Proto *luaY_parser (lua_State *L, ZIO *z) {
chunk(&lexstate);
check_condition(&lexstate, (lexstate.t.token == TK_EOS), "<eof> expected");
close_func(&lexstate);
LUA_ASSERT(funcstate.prev == NULL, "wrong list end");
LUA_ASSERT(funcstate.nupvalues == 0, "no upvalues in main");
lua_assert(funcstate.prev == NULL);
lua_assert(funcstate.nupvalues == 0);
return funcstate.f;
}
@ -1130,8 +1130,7 @@ static void chunk (LexState *ls) {
while (!islast && !block_follow(ls->t.token)) {
islast = stat(ls);
optional(ls, ';');
LUA_ASSERT(ls->fs->stacklevel == ls->fs->nactloc,
"stack size != # local vars");
lua_assert(ls->fs->stacklevel == ls->fs->nactloc);
}
}

73
lstate.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lstate.c,v 1.49 2000/12/26 18:46:09 roberto Exp roberto $
** $Id: lstate.c,v 1.50 2000/12/28 12:55:41 roberto Exp roberto $
** Global State
** See Copyright Notice in lua.h
*/
@ -47,6 +47,24 @@ static void f_luaopen (lua_State *L, void *ud) {
stacksize = DEFAULT_STACK_SIZE;
else
stacksize += LUA_MINSTACK;
L->G = luaM_new(L, global_State);
G(L)->strt.size = G(L)->udt.size = 0;
G(L)->strt.nuse = G(L)->udt.nuse = 0;
G(L)->strt.hash = G(L)->udt.hash = NULL;
G(L)->Mbuffer = NULL;
G(L)->Mbuffsize = 0;
G(L)->rootproto = NULL;
G(L)->rootcl = NULL;
G(L)->roottable = NULL;
G(L)->TMtable = NULL;
G(L)->sizeTM = 0;
G(L)->ntag = 0;
G(L)->refArray = NULL;
G(L)->nref = 0;
G(L)->sizeref = 0;
G(L)->refFree = NONEXT;
G(L)->nblocks = sizeof(lua_State) + sizeof(global_State);
G(L)->GCthreshold = MAX_INT; /* to avoid GC during pre-definitions */
L->gt = luaH_new(L, 10); /* table of globals */
luaD_init(L, stacksize);
luaS_init(L);
@ -58,61 +76,48 @@ static void f_luaopen (lua_State *L, void *ud) {
#ifdef LUA_DEBUG
luaB_opentests(L);
if (lua_state == NULL) lua_state = L; /* keep first state to be opened */
LUA_ASSERT(lua_gettop(L) == 0, "wrong API stack");
lua_assert(lua_gettop(L) == 0);
#endif
}
LUA_API lua_State *lua_open (int stacksize) {
lua_State *L = luaM_new(NULL, lua_State);
lua_State *L;
L = luaM_new(NULL, lua_State);
if (L == NULL) return NULL; /* memory allocation error */
L->G = NULL;
L->stack = NULL;
L->stacksize = 0;
L->strt.size = L->udt.size = 0;
L->strt.nuse = L->udt.nuse = 0;
L->strt.hash = L->udt.hash = NULL;
L->Mbuffer = NULL;
L->Mbuffsize = 0;
L->rootproto = NULL;
L->rootcl = NULL;
L->roottable = NULL;
L->TMtable = NULL;
L->sizeTM = 0;
L->ntag = 0;
L->refArray = NULL;
L->nref = 0;
L->sizeref = 0;
L->refFree = NONEXT;
L->nblocks = sizeof(lua_State);
L->GCthreshold = MAX_INT; /* to avoid GC during pre-definitions */
L->errorJmp = NULL;
L->callhook = NULL;
L->linehook = NULL;
L->allowhooks = 1;
L->errorJmp = NULL;
if (luaD_runprotected(L, f_luaopen, &stacksize) != 0) {
/* memory allocation error: free partial state */
lua_close(L);
return NULL;
}
L->GCthreshold = 2*L->nblocks;
G(L)->GCthreshold = 2*G(L)->nblocks;
return L;
}
LUA_API void lua_close (lua_State *L) {
LUA_ASSERT(L != lua_state || lua_gettop(L) == 0, "garbage in C stack");
lua_assert(L != lua_state || lua_gettop(L) == 0);
if (G(L)) { /* close global state */
luaC_collect(L, 1); /* collect all elements */
LUA_ASSERT(L->rootproto == NULL, "list should be empty");
LUA_ASSERT(L->rootcl == NULL, "list should be empty");
LUA_ASSERT(L->roottable == NULL, "list should be empty");
lua_assert(G(L)->rootproto == NULL);
lua_assert(G(L)->rootcl == NULL);
lua_assert(G(L)->roottable == NULL);
luaS_freeall(L);
luaM_freearray(L, L->stack, L->stacksize, TObject);
luaM_freearray(L, L->TMtable, L->sizeTM, struct TM);
luaM_freearray(L, L->refArray, L->sizeref, struct Ref);
luaM_freearray(L, L->Mbuffer, L->Mbuffsize, char);
LUA_ASSERT(L->nblocks == sizeof(lua_State), "wrong count for nblocks");
luaM_freelem(L, L, lua_State);
LUA_ASSERT(L != lua_state || memdebug_numblocks == 0, "memory leak!");
LUA_ASSERT(L != lua_state || memdebug_total == 0,"memory leak!");
luaM_freearray(L, G(L)->TMtable, G(L)->sizeTM, struct TM);
luaM_freearray(L, G(L)->refArray, G(L)->sizeref, struct Ref);
luaM_freearray(L, G(L)->Mbuffer, G(L)->Mbuffsize, char);
luaM_freelem(NULL, L->G, global_State);
}
luaM_freearray(NULL, L->stack, L->stacksize, TObject);
luaM_freelem(NULL, L, lua_State);
lua_assert(L != lua_state || memdebug_numblocks == 0);
lua_assert(L != lua_state || memdebug_total == 0);
}

35
lstate.h
View File

@ -1,5 +1,5 @@
/*
** $Id: lstate.h,v 1.42 2000/11/24 17:39:56 roberto Exp roberto $
** $Id: lstate.h,v 1.43 2000/12/26 18:46:09 roberto Exp roberto $
** Global State
** See Copyright Notice in lua.h
*/
@ -42,24 +42,17 @@ typedef struct stringtable {
} stringtable;
struct lua_State {
/* thread-specific state */
StkId top; /* first free slot in the stack */
StkId stack; /* stack base */
StkId stack_last; /* last free slot in the stack */
int stacksize;
StkId Cbase; /* base for current C function */
struct lua_longjmp *errorJmp; /* current error recover point */
/*
** "global state", shared by all threads of this state
*/
typedef struct global_State {
char *Mbuffer; /* global buffer */
size_t Mbuffsize; /* size of Mbuffer */
/* global state */
Proto *rootproto; /* list of all prototypes */
Closure *rootcl; /* list of all closures */
Hash *roottable; /* list of all tables */
stringtable strt; /* hash table for strings */
stringtable udt; /* hash table for udata */
Hash *gt; /* table for globals */
struct TM *TMtable; /* table for tag methods */
int sizeTM; /* size of TMtable */
int ntag; /* number of tags in TMtable */
@ -69,11 +62,29 @@ struct lua_State {
int refFree; /* list of free positions in refArray */
mem_int GCthreshold;
mem_int nblocks; /* number of `bytes' currently allocated */
} global_State;
/*
** "per thread" state
*/
struct lua_State {
StkId top; /* first free slot in the stack */
StkId stack; /* stack base */
StkId stack_last; /* last free slot in the stack */
int stacksize;
StkId Cbase; /* base for current C function */
struct lua_longjmp *errorJmp; /* current error recover point */
Hash *gt; /* table for globals */
lua_Hook callhook;
lua_Hook linehook;
int allowhooks;
global_State *G;
};
#define G(L) (L->G)
#endif

29
lstring.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lstring.c,v 1.49 2001/01/10 17:41:50 roberto Exp roberto $
** $Id: lstring.c,v 1.50 2001/01/11 18:59:20 roberto Exp roberto $
** String table (keeps all strings handled by Lua)
** See Copyright Notice in lua.h
*/
@ -19,16 +19,16 @@
void luaS_init (lua_State *L) {
luaS_resize(L, &L->strt, MINPOWER2);
luaS_resize(L, &L->udt, MINPOWER2);
luaS_resize(L, &G(L)->strt, MINPOWER2);
luaS_resize(L, &G(L)->udt, MINPOWER2);
}
void luaS_freeall (lua_State *L) {
LUA_ASSERT(L->strt.nuse==0, "non-empty string table");
luaM_freearray(L, L->strt.hash, L->strt.size, TString *);
LUA_ASSERT(L->udt.nuse==0, "non-empty udata table");
luaM_freearray(L, L->udt.hash, L->udt.size, TString *);
lua_assert(G(L)->strt.nuse==0);
luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
lua_assert(G(L)->udt.nuse==0);
luaM_freearray(L, G(L)->udt.hash, G(L)->udt.size, TString *);
}
@ -41,10 +41,9 @@ void luaS_resize (lua_State *L, stringtable *tb, int newsize) {
TString *p = tb->hash[i];
while (p) { /* for each node in the list */
TString *next = p->nexthash; /* save next */
luint32 h = (tb == &L->strt) ? p->u.s.hash : IntPoint(p->u.d.value);
luint32 h = (tb == &G(L)->strt) ? p->u.s.hash : IntPoint(p->u.d.value);
int h1 = lmod(h, newsize); /* new position */
LUA_ASSERT((int)(h%newsize) == lmod(h, newsize),
"a&(x-1) == a%x, for x power of 2");
lua_assert((int)(h%newsize) == lmod(h, newsize));
p->nexthash = newhash[h1]; /* chain it in new position */
newhash[h1] = p;
p = next;
@ -73,7 +72,7 @@ TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
size_t l1;
for (l1=l; l1>=step; l1-=step) /* compute hash */
h = h ^ ((h<<5)+(h>>2)+(unsigned char)str[l1-1]);
for (ts = L->strt.hash[lmod(h, L->strt.size)]; ts; ts = ts->nexthash) {
for (ts = G(L)->strt.hash[lmod(h, G(L)->strt.size)]; ts; ts = ts->nexthash) {
if (ts->len == l && (memcmp(str, ts->str, l) == 0))
return ts;
}
@ -86,7 +85,7 @@ TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
ts->u.s.constindex = 0;
memcpy(ts->str, str, l);
ts->str[l] = 0; /* ending 0 */
newentry(L, &L->strt, ts, lmod(h, L->strt.size)); /* insert it on table */
newentry(L, &G(L)->strt, ts, lmod(h, G(L)->strt.size)); /* insert it */
return ts;
}
@ -100,15 +99,15 @@ TString *luaS_newudata (lua_State *L, size_t s, void *udata) {
ts->u.d.tag = 0;
ts->u.d.value = (udata == NULL) ? uts+1 : udata;
/* insert it on table */
newentry(L, &L->udt, ts, lmod(IntPoint(ts->u.d.value), L->udt.size));
newentry(L, &G(L)->udt, ts, lmod(IntPoint(ts->u.d.value), G(L)->udt.size));
return ts;
}
TString *luaS_createudata (lua_State *L, void *udata, int tag) {
int h1 = lmod(IntPoint(udata), L->udt.size);
int h1 = lmod(IntPoint(udata), G(L)->udt.size);
TString *ts;
for (ts = L->udt.hash[h1]; ts; ts = ts->nexthash) {
for (ts = G(L)->udt.hash[h1]; ts; ts = ts->nexthash) {
if (udata == ts->u.d.value && (tag == ts->u.d.tag || tag == LUA_ANYTAG))
return ts;
}

10
ltable.c
View File

@ -1,5 +1,5 @@
/*
** $Id: ltable.c,v 1.63 2001/01/10 18:56:11 roberto Exp roberto $
** $Id: ltable.c,v 1.64 2001/01/18 15:59:09 roberto Exp roberto $
** Lua tables (hash)
** See Copyright Notice in lua.h
*/
@ -144,7 +144,7 @@ void luaH_remove (Hash *t, TObject *key) {
n += t->size;
}
setnvalue(key, n);
LUA_ASSERT(luaH_mainposition(t, key) == mp, "cannot change hash");
lua_assert(luaH_mainposition(t, key) == mp);
}
}
@ -167,8 +167,8 @@ static void setnodevector (lua_State *L, Hash *t, luint32 size) {
Hash *luaH_new (lua_State *L, int size) {
Hash *t = luaM_new(L, Hash);
t->htag = TagDefault;
t->next = L->roottable;
L->roottable = t;
t->next = G(L)->roottable;
G(L)->roottable = t;
t->mark = t;
t->size = 0;
t->node = NULL;
@ -201,7 +201,7 @@ static void rehash (lua_State *L, Hash *t) {
Node *nold = t->node;
int nelems = numuse(t);
int i;
LUA_ASSERT(nelems<=oldsize, "wrong count");
lua_assert(nelems<=oldsize);
if (nelems >= oldsize-oldsize/4) /* using more than 3/4? */
setnodevector(L, t, (luint32)oldsize*2);
else if (nelems <= oldsize/4 && /* less than 1/4? */

5
ltests.c
View File

@ -1,5 +1,5 @@
/*
** $Id: ltests.c,v 1.56 2001/01/15 16:13:24 roberto Exp roberto $
** $Id: ltests.c,v 1.57 2001/01/18 15:59:09 roberto Exp roberto $
** Internal Module for Debugging of the Lua Implementation
** See Copyright Notice in lua.h
*/
@ -215,7 +215,8 @@ static int table_query (lua_State *L) {
static int string_query (lua_State *L) {
stringtable *tb = (*luaL_check_string(L, 1) == 's') ? &L->strt : &L->udt;
stringtable *tb = (*luaL_check_string(L, 1) == 's') ? &G(L)->strt :
&G(L)->udt;
int s = luaL_opt_int(L, 2, 0) - 1;
if (s==-1) {
lua_pushnumber(L ,tb->nuse);

34
ltm.c
View File

@ -1,5 +1,5 @@
/*
** $Id: ltm.c,v 1.59 2000/12/28 12:55:41 roberto Exp roberto $
** $Id: ltm.c,v 1.60 2001/01/18 15:59:09 roberto Exp roberto $
** Tag methods
** See Copyright Notice in lua.h
*/
@ -68,36 +68,36 @@ int luaT_validevent (int t, int e) { /* ORDER LUA_T */
static void init_entry (lua_State *L, int tag) {
int i;
for (i=0; i<TM_N; i++)
luaT_gettm(L, tag, i) = NULL;
L->TMtable[tag].collected = NULL;
luaT_gettm(G(L), tag, i) = NULL;
G(L)->TMtable[tag].collected = NULL;
}
void luaT_init (lua_State *L) {
int t;
L->TMtable = luaM_newvector(L, NUM_TAGS+2, struct TM);
L->sizeTM = NUM_TAGS+2;
L->ntag = NUM_TAGS;
for (t=0; t<L->ntag; t++)
G(L)->TMtable = luaM_newvector(L, NUM_TAGS+2, struct TM);
G(L)->sizeTM = NUM_TAGS+2;
G(L)->ntag = NUM_TAGS;
for (t=0; t<G(L)->ntag; t++)
init_entry(L, t);
}
LUA_API int lua_newtag (lua_State *L) {
luaM_growvector(L, L->TMtable, L->ntag, L->sizeTM, struct TM,
luaM_growvector(L, G(L)->TMtable, G(L)->ntag, G(L)->sizeTM, struct TM,
MAX_INT, "tag table overflow");
init_entry(L, L->ntag);
return L->ntag++;
init_entry(L, G(L)->ntag);
return G(L)->ntag++;
}
static void checktag (lua_State *L, int tag) {
if (!(0 <= tag && tag < L->ntag))
if (!(0 <= tag && tag < G(L)->ntag))
luaO_verror(L, "%d is not a valid tag", tag);
}
void luaT_realtag (lua_State *L, int tag) {
if (!validtag(tag))
if (!validtag(G(L), tag))
luaO_verror(L, "tag %d was not created by `newtag'", tag);
}
@ -108,7 +108,7 @@ LUA_API int lua_copytagmethods (lua_State *L, int tagto, int tagfrom) {
checktag(L, tagfrom);
for (e=0; e<TM_N; e++) {
if (luaT_validevent(tagto, e))
luaT_gettm(L, tagto, e) = luaT_gettm(L, tagfrom, e);
luaT_gettm(G(L), tagto, e) = luaT_gettm(G(L), tagfrom, e);
}
return tagto;
}
@ -128,8 +128,8 @@ LUA_API void lua_gettagmethod (lua_State *L, int t, const char *event) {
int e;
e = luaI_checkevent(L, event, t);
checktag(L, t);
if (luaT_validevent(t, e) && luaT_gettm(L, t, e)) {
setclvalue(L->top, luaT_gettm(L, t, e));
if (luaT_validevent(t, e) && luaT_gettm(G(L), t, e)) {
setclvalue(L->top, luaT_gettm(G(L), t, e));
}
else
setnilvalue(L->top);
@ -147,10 +147,10 @@ LUA_API void lua_settagmethod (lua_State *L, int t, const char *event) {
" with default tag" : "");
switch (ttype(L->top - 1)) {
case LUA_TNIL:
luaT_gettm(L, t, e) = NULL;
luaT_gettm(G(L), t, e) = NULL;
break;
case LUA_TFUNCTION:
luaT_gettm(L, t, e) = clvalue(L->top - 1);
luaT_gettm(G(L), t, e) = clvalue(L->top - 1);
break;
default:
lua_error(L, "tag method must be a function (or nil)");

8
ltm.h
View File

@ -1,5 +1,5 @@
/*
** $Id: ltm.h,v 1.18 2000/10/05 13:00:17 roberto Exp roberto $
** $Id: ltm.h,v 1.19 2000/12/26 18:46:09 roberto Exp roberto $
** Tag methods
** See Copyright Notice in lua.h
*/
@ -41,11 +41,11 @@ struct TM {
};
#define luaT_gettm(L,tag,event) (L->TMtable[tag].method[event])
#define luaT_gettmbyObj(L,o,e) (luaT_gettm((L),luaT_tag(o),(e)))
#define luaT_gettm(G,tag,event) (G->TMtable[tag].method[event])
#define luaT_gettmbyObj(G,o,e) (luaT_gettm((G),luaT_tag(o),(e)))
#define validtag(t) (NUM_TAGS <= (t) && (t) < L->ntag)
#define validtag(G,t) (NUM_TAGS <= (t) && (t) < G->ntag)
extern const char *const luaT_eventname[];

30
lvm.c
View File

@ -1,5 +1,5 @@
/*
** $Id: lvm.c,v 1.153 2001/01/15 16:13:24 roberto Exp roberto $
** $Id: lvm.c,v 1.154 2001/01/18 15:59:09 roberto Exp roberto $
** Lua virtual machine
** See Copyright Notice in lua.h
*/
@ -118,16 +118,16 @@ const TObject *luaV_gettable (lua_State *L, StkId t) {
int tg;
if (ttype(t) == LUA_TTABLE && /* `t' is a table? */
((tg = hvalue(t)->htag) == LUA_TTABLE || /* with default tag? */
luaT_gettm(L, tg, TM_GETTABLE) == NULL)) { /* or no TM? */
luaT_gettm(G(L), tg, TM_GETTABLE) == NULL)) { /* or no TM? */
/* do a primitive get */
const TObject *h = luaH_get(hvalue(t), L->top-1);
/* result is no nil or there is no `index' tag method? */
if (ttype(h) != LUA_TNIL || ((tm=luaT_gettm(L, tg, TM_INDEX)) == NULL))
if (ttype(h) != LUA_TNIL || ((tm=luaT_gettm(G(L), tg, TM_INDEX)) == NULL))
return h; /* return result */
/* else call `index' tag method */
}
else { /* try a `gettable' tag method */
tm = luaT_gettmbyObj(L, t, TM_GETTABLE);
tm = luaT_gettmbyObj(G(L), t, TM_GETTABLE);
}
if (tm != NULL) { /* is there a tag method? */
luaD_checkstack(L, 2);
@ -152,11 +152,11 @@ void luaV_settable (lua_State *L, StkId t, StkId key) {
int tg;
if (ttype(t) == LUA_TTABLE && /* `t' is a table? */
((tg = hvalue(t)->htag) == LUA_TTABLE || /* with default tag? */
luaT_gettm(L, tg, TM_SETTABLE) == NULL)) { /* or no TM? */
luaT_gettm(G(L), tg, TM_SETTABLE) == NULL)) { /* or no TM? */
setobj(luaH_set(L, hvalue(t), key), L->top-1); /* do a primitive set */
}
else { /* try a `settable' tag method */
Closure *tm = luaT_gettmbyObj(L, t, TM_SETTABLE);
Closure *tm = luaT_gettmbyObj(G(L), t, TM_SETTABLE);
if (tm != NULL) {
luaD_checkstack(L, 3);
setobj(L->top+2, L->top-1);
@ -174,7 +174,7 @@ void luaV_settable (lua_State *L, StkId t, StkId key) {
const TObject *luaV_getglobal (lua_State *L, TString *s) {
const TObject *value = luaH_getstr(L->gt, s);
Closure *tm = luaT_gettmbyObj(L, value, TM_GETGLOBAL);
Closure *tm = luaT_gettmbyObj(G(L), value, TM_GETGLOBAL);
if (tm == NULL) /* is there a tag method? */
return value; /* default behavior */
else { /* tag method */
@ -191,7 +191,7 @@ const TObject *luaV_getglobal (lua_State *L, TString *s) {
void luaV_setglobal (lua_State *L, TString *s) {
TObject *oldvalue = luaH_setstr(L, L->gt, s);
Closure *tm = luaT_gettmbyObj(L, oldvalue, TM_SETGLOBAL);
Closure *tm = luaT_gettmbyObj(G(L), oldvalue, TM_SETGLOBAL);
if (tm == NULL) { /* no tag methods? */
setobj(oldvalue, L->top - 1); /* raw set */
}
@ -209,12 +209,12 @@ void luaV_setglobal (lua_State *L, TString *s) {
static int call_binTM (lua_State *L, StkId top, TMS event) {
/* try first operand */
Closure *tm = luaT_gettmbyObj(L, top-2, event);
Closure *tm = luaT_gettmbyObj(G(L), top-2, event);
L->top = top;
if (tm == NULL) {
tm = luaT_gettmbyObj(L, top-1, event); /* try second operand */
tm = luaT_gettmbyObj(G(L), top-1, event); /* try second operand */
if (tm == NULL) {
tm = luaT_gettm(L, 0, event); /* try a `global' method */
tm = luaT_gettm(G(L), 0, event); /* try a `global' method */
if (tm == NULL)
return 0; /* error */
}
@ -369,7 +369,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
}
case OP_PUSHNIL: {
int n = GETARG_U(i);
LUA_ASSERT(n>0, "invalid argument");
lua_assert(n>0);
do {
setnilvalue(top++);
} while (--n > 0);
@ -620,8 +620,8 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
break;
}
case OP_FORLOOP: {
LUA_ASSERT(ttype(top-1) == LUA_TNUMBER, "invalid step");
LUA_ASSERT(ttype(top-2) == LUA_TNUMBER, "invalid limit");
lua_assert(ttype(top-1) == LUA_TNUMBER);
lua_assert(ttype(top-2) == LUA_TNUMBER);
if (ttype(top-3) != LUA_TNUMBER)
lua_error(L, "`for' index must be a number");
nvalue(top-3) += nvalue(top-1); /* increment index */
@ -651,7 +651,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
}
case OP_LFORLOOP: {
Node *node;
LUA_ASSERT(ttype(top-3) == LUA_TTABLE, "invalid table");
lua_assert(ttype(top-3) == LUA_TTABLE);
node = luaH_next(L, hvalue(top-3), top-2);
if (node == NULL) /* end loop? */
top -= 3; /* remove table, key, and value */