opensources
/
lua
mirror of https://github.com/lua/lua.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

explicit control of size for growing vectors

v5-2
Roberto Ierusalimschy 24 years ago
parent
6af005ec20
commit
8c49e19865
12 changed files with 95 additions and 70 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 12
      lapi.c
  2. 19
      lcode.c
  3. 4
      ldebug.c
  4. 10
      lgc.c
  5. 25
      lmem.c
  6. 12
      lmem.h
  7. 31
      lparser.c
  8. 8
      lparser.h
  9. 12
      lstate.c
  10. 8
      lstate.h
  11. 20
      ltm.c
  12. 4
      ltm.h

12
lapi.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lapi.c,v 1.111 2000/11/24 17:39:56 roberto Exp roberto $ ** $Id: lapi.c,v 1.112 2000/12/04 18:33:40 roberto Exp roberto $
** Lua API ** Lua API
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -289,7 +289,7 @@ LUA_API void lua_getglobals (lua_State *L) {
LUA_API int lua_getref (lua_State *L, int ref) { LUA_API int lua_getref (lua_State *L, int ref) {
if (ref == LUA_REFNIL) if (ref == LUA_REFNIL)
ttype(L->top) = LUA_TNIL; ttype(L->top) = LUA_TNIL;
else if (0 <= ref && ref < L->refSize && else if (0 <= ref && ref < L->nref &&
(L->refArray[ref].st == LOCK || L->refArray[ref].st == HOLD)) (L->refArray[ref].st == LOCK || L->refArray[ref].st == HOLD))
*L->top = L->refArray[ref].o; *L->top = L->refArray[ref].o;
else else
@ -360,10 +360,10 @@ LUA_API int lua_ref (lua_State *L, int lock) {
L->refFree = L->refArray[ref].st; L->refFree = L->refArray[ref].st;
} }
else { /* no more free places */ else { /* no more free places */
luaM_growvector(L, L->refArray, L->refSize, 1, struct Ref, luaM_growvector(L, L->refArray, L->nref, L->sizeref, struct Ref,
"reference table overflow", MAX_INT); MAX_INT, "reference table overflow");
L->nblocks += sizeof(struct Ref); L->nblocks += sizeof(struct Ref);
ref = L->refSize++; ref = L->nref++;
} }
L->refArray[ref].o = *(L->top-1); L->refArray[ref].o = *(L->top-1);
L->refArray[ref].st = lock ? LOCK : HOLD; L->refArray[ref].st = lock ? LOCK : HOLD;
@ -430,7 +430,7 @@ LUA_API void lua_settag (lua_State *L, int tag) {
LUA_API void lua_unref (lua_State *L, int ref) { LUA_API void lua_unref (lua_State *L, int ref) {
if (ref >= 0) { if (ref >= 0) {
LUA_ASSERT(ref < L->refSize && L->refArray[ref].st < 0, "invalid ref"); LUA_ASSERT(ref < L->nref && L->refArray[ref].st < 0, "invalid ref");
L->refArray[ref].st = L->refFree; L->refArray[ref].st = L->refFree;
L->refFree = ref; L->refFree = ref;
} }

19
lcode.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lcode.c,v 1.52 2000/11/30 18:50:47 roberto Exp roberto $ ** $Id: lcode.c,v 1.53 2000/12/04 18:33:40 roberto Exp roberto $
** Code generator for Lua ** Code generator for Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -107,8 +107,8 @@ static int number_constant (FuncState *fs, lua_Number r) {
while (--c >= lim) while (--c >= lim)
if (f->knum[c] == r) return c; if (f->knum[c] == r) return c;
/* not found; create a new entry */ /* not found; create a new entry */
luaM_growvector(fs->L, f->knum, f->nknum, 1, lua_Number, luaM_growvector(fs->L, f->knum, f->nknum, fs->sizeknum, lua_Number,
"constant table overflow", MAXARG_U); MAXARG_U, "constant table overflow");
c = f->nknum++; c = f->nknum++;
f->knum[c] = r; f->knum[c] = r;
return c; return c;
@ -423,10 +423,13 @@ static void codelineinfo (FuncState *fs) {
Proto *f = fs->f; Proto *f = fs->f;
LexState *ls = fs->ls; LexState *ls = fs->ls;
if (ls->lastline > fs->lastline) { if (ls->lastline > fs->lastline) {
luaM_growvector(fs->L, f->lineinfo, f->nlineinfo, 2, int, if (ls->lastline > fs->lastline+1) {
"line info overflow", MAX_INT); luaM_growvector(fs->L, f->lineinfo, f->nlineinfo, fs->sizelineinfo, int,
if (ls->lastline > fs->lastline+1) MAX_INT, "line info overflow");
f->lineinfo[f->nlineinfo++] = -(ls->lastline - (fs->lastline+1)); f->lineinfo[f->nlineinfo++] = -(ls->lastline - (fs->lastline+1));
}
luaM_growvector(fs->L, f->lineinfo, f->nlineinfo, fs->sizelineinfo, int,
MAX_INT, "line info overflow");
f->lineinfo[f->nlineinfo++] = fs->pc; f->lineinfo[f->nlineinfo++] = fs->pc;
fs->lastline = ls->lastline; fs->lastline = ls->lastline;
} }
@ -640,8 +643,8 @@ int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2) {
} }
codelineinfo(fs); codelineinfo(fs);
/* put new instruction in code array */ /* put new instruction in code array */
luaM_growvector(fs->L, fs->f->code, fs->pc, 1, Instruction, luaM_growvector(fs->L, fs->f->code, fs->pc, fs->sizecode, Instruction,
"code size overflow", MAX_INT); MAX_INT, "code size overflow");
fs->f->code[fs->pc] = i; fs->f->code[fs->pc] = i;
return fs->pc++; return fs->pc++;
} }

4
ldebug.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: ldebug.c,v 1.50 2000/10/30 12:38:50 roberto Exp roberto $ ** $Id: ldebug.c,v 1.51 2000/11/30 18:50:47 roberto Exp roberto $
** Debug Interface ** Debug Interface
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -210,7 +210,7 @@ static const char *travtagmethods (lua_State *L, const TObject *o) {
int e; int e;
for (e=0; e<TM_N; e++) { for (e=0; e<TM_N; e++) {
int t; int t;
for (t=0; t<=L->last_tag; t++) for (t=0; t<L->ntag; t++)
if (clvalue(o) == luaT_gettm(L, t, e)) if (clvalue(o) == luaT_gettm(L, t, e))
return luaT_eventname[e]; return luaT_eventname[e];
} }

10
lgc.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lgc.c,v 1.72 2000/10/26 12:47:05 roberto Exp roberto $ ** $Id: lgc.c,v 1.73 2000/11/24 17:39:56 roberto Exp roberto $
** Garbage Collector ** Garbage Collector
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -56,7 +56,7 @@ static void markstack (lua_State *L, GCState *st) {
static void marklock (lua_State *L, GCState *st) { static void marklock (lua_State *L, GCState *st) {
int i; int i;
for (i=0; i<L->refSize; i++) { for (i=0; i<L->nref; i++) {
if (L->refArray[i].st == LOCK) if (L->refArray[i].st == LOCK)
markobject(st, &L->refArray[i].o); markobject(st, &L->refArray[i].o);
} }
@ -77,7 +77,7 @@ static void marktagmethods (lua_State *L, GCState *st) {
int e; int e;
for (e=0; e<TM_N; e++) { for (e=0; e<TM_N; e++) {
int t; int t;
for (t=0; t<=L->last_tag; t++) { for (t=0; t<L->ntag; t++) {
Closure *cl = luaT_gettm(L, t, e); Closure *cl = luaT_gettm(L, t, e);
if (cl) markclosure(st, cl); if (cl) markclosure(st, cl);
} }
@ -162,7 +162,7 @@ static int hasmark (const TObject *o) {
#define VALIDLINK(L, st,n) (NONEXT <= (st) && (st) < (n)) #define VALIDLINK(L, st,n) (NONEXT <= (st) && (st) < (n))
static void invalidaterefs (lua_State *L) { static void invalidaterefs (lua_State *L) {
int n = L->refSize; int n = L->nref;
int i; int i;
for (i=0; i<n; i++) { for (i=0; i<n; i++) {
struct Ref *r = &L->refArray[i]; struct Ref *r = &L->refArray[i];
@ -314,7 +314,7 @@ static void callgcTMudata (lua_State *L) {
TObject o; TObject o;
ttype(&o) = LUA_TUSERDATA; ttype(&o) = LUA_TUSERDATA;
L->GCthreshold = 2*L->nblocks; /* avoid GC during tag methods */ L->GCthreshold = 2*L->nblocks; /* avoid GC during tag methods */
for (tag=L->last_tag; tag>=0; tag--) { /* for each tag (in reverse order) */ for (tag=L->ntag-1; tag>=0; tag--) { /* for each tag (in reverse order) */
TString *udata; TString *udata;
while ((udata = L->TMtable[tag].collected) != NULL) { while ((udata = L->TMtable[tag].collected) != NULL) {
L->TMtable[tag].collected = udata->nexthash; /* remove it from list */ L->TMtable[tag].collected = udata->nexthash; /* remove it from list */

25
lmem.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lmem.c,v 1.39 2000/10/30 16:29:59 roberto Exp roberto $ ** $Id: lmem.c,v 1.40 2000/11/24 17:39:56 roberto Exp roberto $
** Interface to Memory Manager ** Interface to Memory Manager
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -116,15 +116,20 @@ static void *debug_realloc (void *block, size_t size) {
#endif #endif
void *luaM_growaux (lua_State *L, void *block, size_t nelems, void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems,
int inc, size_t size, const char *errormsg, size_t limit) { int limit, const char *errormsg) {
size_t newn = nelems+inc; void *newblock;
if (nelems >= limit-inc) lua_error(L, errormsg); int newsize = (*size)*2;
if ((newn ^ nelems) <= nelems || /* still the same power-of-2 limit? */ if (newsize < MINPOWER2)
(nelems > 0 && newn < MINPOWER2)) /* or block already is MINPOWER2? */ newsize = MINPOWER2; /* minimum size */
return block; /* do not need to reallocate */ else if (*size >= limit/2) { /* cannot double it? */
else /* it crossed a power-of-2 boundary; grow to next power */ if (*size < limit - MINPOWER2) /* try something smaller... */
return luaM_realloc(L, block, luaO_power2(newn)*size); newsize = limit; /* still have at least MINPOWER2 free places */
else lua_error(L, errormsg);
}
newblock = luaM_realloc(L, block, (luint32)newsize*(luint32)size_elems);
*size = newsize; /* update only when everything else is OK */
return newblock;
} }

12
lmem.h
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lmem.h,v 1.16 2000/10/30 16:29:59 roberto Exp roberto $ ** $Id: lmem.h,v 1.17 2000/11/24 17:39:56 roberto Exp roberto $
** Interface to Memory Manager ** Interface to Memory Manager
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -14,17 +14,17 @@
#include "lua.h" #include "lua.h"
void *luaM_realloc (lua_State *L, void *oldblock, luint32 size); void *luaM_realloc (lua_State *L, void *oldblock, luint32 size);
void *luaM_growaux (lua_State *L, void *block, size_t nelems, void *luaM_growaux (lua_State *L, void *block, int *size, int size_elem,
int inc, size_t size, const char *errormsg, int limit, const char *errormsg);
size_t limit);
#define luaM_free(L, b) luaM_realloc(L, (b), 0) #define luaM_free(L, b) luaM_realloc(L, (b), 0)
#define luaM_malloc(L, t) luaM_realloc(L, NULL, (t)) #define luaM_malloc(L, t) luaM_realloc(L, NULL, (t))
#define luaM_new(L, t) ((t *)luaM_malloc(L, sizeof(t))) #define luaM_new(L, t) ((t *)luaM_malloc(L, sizeof(t)))
#define luaM_newvector(L, n,t) ((t *)luaM_malloc(L, (n)*(luint32)sizeof(t))) #define luaM_newvector(L, n,t) ((t *)luaM_malloc(L, (n)*(luint32)sizeof(t)))
#define luaM_growvector(L, v,nelems,inc,t,e,l) \ #define luaM_growvector(L,v,nelems,size,t,limit,e) \
((v)=(t *)luaM_growaux(L, v,nelems,inc,sizeof(t),e,l)) if (((nelems)+1) > (size)) \
((v)=(t *)luaM_growaux(L,v,&(size),sizeof(t),limit,e))
#define luaM_reallocvector(L, v,n,t) \ #define luaM_reallocvector(L, v,n,t) \
((v)=(t *)luaM_realloc(L, v,(n)*(luint32)sizeof(t))) ((v)=(t *)luaM_realloc(L, v,(n)*(luint32)sizeof(t)))

31
lparser.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lparser.c,v 1.118 2000/11/30 18:50:47 roberto Exp roberto $ ** $Id: lparser.c,v 1.119 2000/12/04 18:33:40 roberto Exp roberto $
** LL(1) Parser and code generator for Lua ** LL(1) Parser and code generator for Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -121,8 +121,8 @@ static int string_constant (FuncState *fs, TString *s) {
Proto *f = fs->f; Proto *f = fs->f;
int c = s->u.s.constindex; int c = s->u.s.constindex;
if (c >= f->nkstr || f->kstr[c] != s) { if (c >= f->nkstr || f->kstr[c] != s) {
luaM_growvector(fs->L, f->kstr, f->nkstr, 1, TString *, luaM_growvector(fs->L, f->kstr, f->nkstr, fs->sizekstr, TString *,
"constant table overflow", MAXARG_U); MAXARG_U, "constant table overflow");
c = f->nkstr++; c = f->nkstr++;
f->kstr[c] = s; f->kstr[c] = s;
s->u.s.constindex = c; /* hint for next time */ s->u.s.constindex = c; /* hint for next time */
@ -152,7 +152,8 @@ static int checkname (LexState *ls) {
static int luaI_registerlocalvar (LexState *ls, TString *varname) { static int luaI_registerlocalvar (LexState *ls, TString *varname) {
Proto *f = ls->fs->f; Proto *f = ls->fs->f;
luaM_growvector(ls->L, f->locvars, f->nlocvars, 1, LocVar, "", MAX_INT); luaM_growvector(ls->L, f->locvars, f->nlocvars, ls->fs->sizelocvars,
LocVar, MAX_INT, "");
f->locvars[f->nlocvars].varname = varname; f->locvars[f->nlocvars].varname = varname;
return f->nlocvars++; return f->nlocvars++;
} }
@ -294,8 +295,8 @@ static void pushclosure (LexState *ls, FuncState *func) {
int i; int i;
for (i=0; i<func->nupvalues; i++) for (i=0; i<func->nupvalues; i++)
luaK_tostack(ls, &func->upvalues[i], 1); luaK_tostack(ls, &func->upvalues[i], 1);
luaM_growvector(ls->L, f->kproto, f->nkproto, 1, Proto *, luaM_growvector(ls->L, f->kproto, f->nkproto, fs->sizekproto, Proto *,
"constant table overflow", MAXARG_A); MAXARG_A, "constant table overflow");
f->kproto[f->nkproto++] = func->f; f->kproto[f->nkproto++] = func->f;
luaK_code2(fs, OP_CLOSURE, f->nkproto-1, func->nupvalues); luaK_code2(fs, OP_CLOSURE, f->nkproto-1, func->nupvalues);
} }
@ -303,21 +304,27 @@ static void pushclosure (LexState *ls, FuncState *func) {
static void open_func (LexState *ls, FuncState *fs) { static void open_func (LexState *ls, FuncState *fs) {
Proto *f = luaF_newproto(ls->L); Proto *f = luaF_newproto(ls->L);
fs->f = f;
fs->prev = ls->fs; /* linked list of funcstates */ fs->prev = ls->fs; /* linked list of funcstates */
fs->ls = ls; fs->ls = ls;
fs->L = ls->L; fs->L = ls->L;
ls->fs = fs; ls->fs = fs;
fs->pc = 0;
fs->lasttarget = 0;
fs->jlt = NO_JUMP;
fs->stacklevel = 0; fs->stacklevel = 0;
fs->sizekstr = 0;
fs->sizekproto = 0;
fs->sizeknum = 0;
fs->sizelineinfo = 0;
fs->sizecode = 0;
fs->sizelocvars = 0;
fs->nactloc = 0; fs->nactloc = 0;
fs->nupvalues = 0; fs->nupvalues = 0;
fs->bl = NULL;
fs->f = f;
f->source = ls->source;
fs->pc = 0;
fs->lasttarget = 0;
fs->lastline = 0; fs->lastline = 0;
fs->jlt = NO_JUMP; fs->bl = NULL;
f->code = NULL; f->code = NULL;
f->source = ls->source;
f->maxstacksize = 0; f->maxstacksize = 0;
f->numparams = 0; /* default for main chunk */ f->numparams = 0; /* default for main chunk */
f->is_vararg = 0; /* default for main chunk */ f->is_vararg = 0; /* default for main chunk */

8
lparser.h
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lparser.h,v 1.26 2000/10/09 13:47:46 roberto Exp roberto $ ** $Id: lparser.h,v 1.27 2000/11/30 18:50:47 roberto Exp roberto $
** LL(1) Parser and code generator for Lua ** LL(1) Parser and code generator for Lua
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -45,6 +45,12 @@ typedef struct FuncState {
int lasttarget; /* `pc' of last `jump target' */ int lasttarget; /* `pc' of last `jump target' */
int jlt; /* list of jumps to `lasttarget' */ int jlt; /* list of jumps to `lasttarget' */
int stacklevel; /* number of values on activation register */ int stacklevel; /* number of values on activation register */
int sizekstr; /* size of array `kstr' */
int sizekproto; /* size of array `kproto' */
int sizeknum; /* size of array `knum' */
int sizelineinfo; /* size of array `lineinfo' */
int sizecode; /* size of array `code' */
int sizelocvars; /* size of array `locvars' */
int nactloc; /* number of active local variables */ int nactloc; /* number of active local variables */
int nupvalues; /* number of upvalues */ int nupvalues; /* number of upvalues */
int lastline; /* line where last `lineinfo' was generated */ int lastline; /* line where last `lineinfo' was generated */

12
lstate.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lstate.c,v 1.47 2000/10/26 12:47:05 roberto Exp roberto $ ** $Id: lstate.c,v 1.48 2000/10/30 16:29:59 roberto Exp roberto $
** Global State ** Global State
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -77,9 +77,11 @@ LUA_API lua_State *lua_open (int stacksize) {
L->rootcl = NULL; L->rootcl = NULL;
L->roottable = NULL; L->roottable = NULL;
L->TMtable = NULL; L->TMtable = NULL;
L->last_tag = -1; L->sizeTM = 0;
L->ntag = 0;
L->refArray = NULL; L->refArray = NULL;
L->refSize = 0; L->nref = 0;
L->sizeref = 0;
L->refFree = NONEXT; L->refFree = NONEXT;
L->nblocks = sizeof(lua_State); L->nblocks = sizeof(lua_State);
L->GCthreshold = MAX_INT; /* to avoid GC during pre-definitions */ L->GCthreshold = MAX_INT; /* to avoid GC during pre-definitions */
@ -107,9 +109,9 @@ LUA_API void lua_close (lua_State *L) {
if (L->stack) if (L->stack)
L->nblocks -= (L->stack_last - L->stack + 1)*sizeof(TObject); L->nblocks -= (L->stack_last - L->stack + 1)*sizeof(TObject);
luaM_free(L, L->stack); luaM_free(L, L->stack);
L->nblocks -= (L->last_tag+1)*sizeof(struct TM); L->nblocks -= L->ntag*sizeof(struct TM);
luaM_free(L, L->TMtable); luaM_free(L, L->TMtable);
L->nblocks -= (L->refSize)*sizeof(struct Ref); L->nblocks -= (L->nref)*sizeof(struct Ref);
luaM_free(L, L->refArray); luaM_free(L, L->refArray);
L->nblocks -= (L->Mbuffsize)*sizeof(char); L->nblocks -= (L->Mbuffsize)*sizeof(char);
luaM_free(L, L->Mbuffer); luaM_free(L, L->Mbuffer);

8
lstate.h
View File

@ -1,5 +1,5 @@
/* /*
** $Id: lstate.h,v 1.41 2000/10/05 13:00:17 roberto Exp roberto $ ** $Id: lstate.h,v 1.42 2000/11/24 17:39:56 roberto Exp roberto $
** Global State ** Global State
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -61,9 +61,11 @@ struct lua_State {
stringtable udt; /* hash table for udata */ stringtable udt; /* hash table for udata */
Hash *gt; /* table for globals */ Hash *gt; /* table for globals */
struct TM *TMtable; /* table for tag methods */ struct TM *TMtable; /* table for tag methods */
int last_tag; /* last used tag in TMtable */ int sizeTM; /* size of TMtable */
int ntag; /* number of tags in TMtable */
struct Ref *refArray; /* locked objects */ struct Ref *refArray; /* locked objects */
int refSize; /* size of refArray */ int nref; /* first unused element in refArray */
int sizeref; /* size of refArray */
int refFree; /* list of free positions in refArray */ int refFree; /* list of free positions in refArray */
mem_int GCthreshold; mem_int GCthreshold;
mem_int nblocks; /* number of `bytes' currently allocated */ mem_int nblocks; /* number of `bytes' currently allocated */

20
ltm.c
View File

@ -1,5 +1,5 @@
/* /*
** $Id: ltm.c,v 1.56 2000/10/31 13:10:24 roberto Exp roberto $ ** $Id: ltm.c,v 1.57 2000/11/30 18:50:47 roberto Exp roberto $
** Tag methods ** Tag methods
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -75,26 +75,26 @@ static void init_entry (lua_State *L, int tag) {
void luaT_init (lua_State *L) { void luaT_init (lua_State *L) {
int t; int t;
luaM_growvector(L, L->TMtable, 0, NUM_TAGS, struct TM, "", MAX_INT); L->sizeTM = NUM_TAGS+2;
L->TMtable = luaM_newvector(L, L->sizeTM, struct TM);
L->nblocks += NUM_TAGS*sizeof(struct TM); L->nblocks += NUM_TAGS*sizeof(struct TM);
L->last_tag = NUM_TAGS-1; L->ntag = NUM_TAGS;
for (t=0; t<=L->last_tag; t++) for (t=0; t<L->ntag; t++)
init_entry(L, t); init_entry(L, t);
} }
LUA_API int lua_newtag (lua_State *L) { LUA_API int lua_newtag (lua_State *L) {
luaM_growvector(L, L->TMtable, L->last_tag, 1, struct TM, luaM_growvector(L, L->TMtable, L->ntag, L->sizeTM, struct TM,
"tag table overflow", MAX_INT); MAX_INT, "tag table overflow");
L->nblocks += sizeof(struct TM); L->nblocks += sizeof(struct TM);
L->last_tag++; init_entry(L, L->ntag);
init_entry(L, L->last_tag); return L->ntag++;
return L->last_tag;
} }
static void checktag (lua_State *L, int tag) { static void checktag (lua_State *L, int tag) {
if (!(0 <= tag && tag <= L->last_tag)) if (!(0 <= tag && tag < L->ntag))
luaO_verror(L, "%d is not a valid tag", tag); luaO_verror(L, "%d is not a valid tag", tag);
} }

4
ltm.h
View File

@ -1,5 +1,5 @@
/* /*
** $Id: ltm.h,v 1.17 2000/10/05 12:14:08 roberto Exp roberto $ ** $Id: ltm.h,v 1.18 2000/10/05 13:00:17 roberto Exp roberto $
** Tag methods ** Tag methods
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -45,7 +45,7 @@ struct TM {
#define luaT_gettmbyObj(L,o,e) (luaT_gettm((L),luaT_tag(o),(e))) #define luaT_gettmbyObj(L,o,e) (luaT_gettm((L),luaT_tag(o),(e)))
#define validtag(t) (NUM_TAGS <= (t) && (t) <= L->last_tag) #define validtag(t) (NUM_TAGS <= (t) && (t) < L->ntag)
extern const char *const luaT_eventname[]; extern const char *const luaT_eventname[];

Write Preview
Loading…
Cancel
Save