`free' gets size of the block: complete control over memory use

lapi.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.c,v 1.112 2000/12/04 18:33:40 roberto Exp roberto $
+** $Id: lapi.c,v 1.113 2000/12/26 18:46:09 roberto Exp roberto $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
@@ -362,7 +362,6 @@ LUA_API int lua_ref (lua_State *L,  int lock) {
     else {  /* no more free places */
       luaM_growvector(L, L->refArray, L->nref, L->sizeref, struct Ref,
                       MAX_INT, "reference table overflow");
-      L->nblocks += sizeof(struct Ref);
       ref = L->nref++;
     }
     L->refArray[ref].o = *(L->top-1);

lcode.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.c,v 1.53 2000/12/04 18:33:40 roberto Exp roberto $
+** $Id: lcode.c,v 1.54 2000/12/26 18:46:09 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -102,14 +102,14 @@ void luaK_kstr (LexState *ls, int c) {
 static int number_constant (FuncState *fs, lua_Number r) {
   /* check whether `r' has appeared within the last LOOKBACKNUMS entries */
   Proto *f = fs->f;
-  int c = f->nknum;
+  int c = fs->nknum;
   int lim = c < LOOKBACKNUMS ? 0 : c-LOOKBACKNUMS;
   while (--c >= lim)
     if (f->knum[c] == r) return c;
   /* not found; create a new entry */
-  luaM_growvector(fs->L, f->knum, f->nknum, fs->sizeknum, lua_Number,
+  luaM_growvector(fs->L, f->knum, fs->nknum, f->sizeknum, lua_Number,
                   MAXARG_U, "constant table overflow");
-  c = f->nknum++;
+  c = fs->nknum++;
   f->knum[c] = r;
   return c;
 }
@@ -424,13 +424,13 @@ static void codelineinfo (FuncState *fs) {
   LexState *ls = fs->ls;
   if (ls->lastline > fs->lastline) {
     if (ls->lastline > fs->lastline+1) {
-      luaM_growvector(fs->L, f->lineinfo, f->nlineinfo, fs->sizelineinfo, int,
+      luaM_growvector(fs->L, f->lineinfo, fs->nlineinfo, f->sizelineinfo, int,
                       MAX_INT, "line info overflow");
-      f->lineinfo[f->nlineinfo++] = -(ls->lastline - (fs->lastline+1));
+      f->lineinfo[fs->nlineinfo++] = -(ls->lastline - (fs->lastline+1));
     }
-    luaM_growvector(fs->L, f->lineinfo, f->nlineinfo, fs->sizelineinfo, int,
+    luaM_growvector(fs->L, f->lineinfo, fs->nlineinfo, f->sizelineinfo, int,
                     MAX_INT, "line info overflow");
-    f->lineinfo[f->nlineinfo++] = fs->pc;
+    f->lineinfo[fs->nlineinfo++] = fs->pc;
     fs->lastline = ls->lastline;
   }
 }
@@ -447,6 +447,7 @@ int luaK_code1 (FuncState *fs, OpCode o, int arg1) {
 
 
 int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2) {
+  Proto *f;
   Instruction i = previous_instruction(fs);
   int delta = (int)luaK_opproperties[o].push - (int)luaK_opproperties[o].pop;
   int optm = 0;  /* 1 when there is an optimization */
@@ -629,9 +630,10 @@ int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2) {
       break;
     }
   }
+  f = fs->f;
   luaK_deltastack(fs, delta);
   if (optm) {  /* optimize: put instruction in place of last one */
-      fs->f->code[fs->pc-1] = i;  /* change previous instruction */
+      f->code[fs->pc-1] = i;  /* change previous instruction */
       return fs->pc-1;  /* do not generate new instruction */
   }
   /* else build new instruction */
@@ -643,9 +645,9 @@ int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2) {
   }
   codelineinfo(fs);
   /* put new instruction in code array */
-  luaM_growvector(fs->L, fs->f->code, fs->pc, fs->sizecode, Instruction,
+  luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction,
                   MAX_INT, "code size overflow");
-  fs->f->code[fs->pc] = i;
+  f->code[fs->pc] = i;
   return fs->pc++;
 }
 

ldo.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.c,v 1.109 2000/10/30 12:38:50 roberto Exp roberto $
+** $Id: ldo.c,v 1.110 2000/11/24 17:39:56 roberto Exp roberto $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
@@ -28,38 +28,40 @@
 
 
 /* space to handle stack overflow errors */
-#define EXTRA_STACK	(2*LUA_MINSTACK)
+#define EXTRA_STACK   (2*LUA_MINSTACK)
+
+
+static void restore_stack_limit (lua_State *L) {
+  StkId limit = L->stack+(L->stacksize-EXTRA_STACK)-1;
+  if (L->top < limit)
+    L->stack_last = limit;
+}
 
 
 void luaD_init (lua_State *L, int stacksize) {
-  L->stack = luaM_newvector(L, stacksize+EXTRA_STACK, TObject);
-  L->nblocks += stacksize*sizeof(TObject);
-  L->stack_last = L->stack+(stacksize-1);
+  stacksize += EXTRA_STACK;
+  L->stack = luaM_newvector(L, stacksize, TObject);
   L->stacksize = stacksize;
   L->Cbase = L->top = L->stack;
+  restore_stack_limit(L);
 }
 
 
 void luaD_checkstack (lua_State *L, int n) {
   if (L->stack_last - L->top <= n) {  /* stack overflow? */
-    if (L->stack_last-L->stack > (L->stacksize-1)) {
+    if (L->stack_last == L->stack+L->stacksize-1) {
       /* overflow while handling overflow */
       luaD_breakrun(L, LUA_ERRERR);  /* break run without error message */
     }
     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_error(L, "stack overflow");
     }
   }
 }
 
 
-static void restore_stack_limit (lua_State *L) {
-  if (L->top - L->stack < L->stacksize - 1)
-    L->stack_last = L->stack + (L->stacksize-1);
-}
-
-
 /*
 ** Adjust stack. Set top to base+extra, pushing NILs if needed.
 ** (we cannot add base+extra unless we are sure it fits in the stack;

lfunc.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.c,v 1.34 2000/10/30 12:20:29 roberto Exp roberto $
+** $Id: lfunc.c,v 1.35 2000/12/04 18:33:40 roberto Exp roberto $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
@@ -18,13 +18,11 @@
 
 
 Closure *luaF_newclosure (lua_State *L, int nelems) {
-  int size = sizeclosure(nelems);
-  Closure *c = (Closure *)luaM_malloc(L, size);
+  Closure *c = (Closure *)luaM_malloc(L, sizeclosure(nelems));
   c->next = L->rootcl;
   L->rootcl = c;
   c->mark = c;
   c->nupvalues = nelems;
-  L->nblocks += size;
   return c;
 }
 
@@ -32,20 +30,20 @@ Closure *luaF_newclosure (lua_State *L, int nelems) {
 Proto *luaF_newproto (lua_State *L) {
   Proto *f = luaM_new(L, Proto);
   f->knum = NULL;
-  f->nknum = 0;
+  f->sizeknum = 0;
   f->kstr = NULL;
-  f->nkstr = 0;
+  f->sizekstr = 0;
   f->kproto = NULL;
-  f->nkproto = 0;
+  f->sizekproto = 0;
   f->code = NULL;
-  f->ncode = 0;
+  f->sizecode = 0;
   f->numparams = 0;
   f->is_vararg = 0;
   f->maxstacksize = 0;
   f->marked = 0;
   f->lineinfo = NULL;
-  f->nlineinfo = 0;
-  f->nlocvars = 0;
+  f->sizelocvars = 0;
+  f->sizelineinfo = 0;
   f->locvars = NULL;
   f->lineDefined = 0;
   f->source = NULL;
@@ -55,39 +53,19 @@ Proto *luaF_newproto (lua_State *L) {
 }
 
 
-static size_t protosize (Proto *f) {
-  return sizeof(Proto)
-       + f->nknum*sizeof(lua_Number)
-       + f->nkstr*sizeof(TString *)
-       + f->nkproto*sizeof(Proto *)
-       + f->ncode*sizeof(Instruction)
-       + f->nlocvars*sizeof(struct LocVar)
-       + f->nlineinfo*sizeof(int);
-}
-
-
-void luaF_protook (lua_State *L, Proto *f, int pc) {
-  f->ncode = pc;  /* signal that proto was properly created */
-  L->nblocks += protosize(f);
-}
-
-
 void luaF_freeproto (lua_State *L, Proto *f) {
-  if (f->ncode > 0)  /* function was properly created? */
-    L->nblocks -= protosize(f);
-  luaM_free(L, f->code);
-  luaM_free(L, f->locvars);
-  luaM_free(L, f->kstr);
-  luaM_free(L, f->knum);
-  luaM_free(L, f->kproto);
-  luaM_free(L, f->lineinfo);
-  luaM_free(L, f);
+  luaM_freearray(L, f->code, f->sizecode, Instruction);
+  luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
+  luaM_freearray(L, f->kstr, f->sizekstr, TString *);
+  luaM_freearray(L, f->knum, f->sizeknum, lua_Number);
+  luaM_freearray(L, f->kproto, f->sizekproto, Proto *);
+  luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
+  luaM_freelem(L, f, Proto);
 }
 
 
 void luaF_freeclosure (lua_State *L, Closure *c) {
-  L->nblocks -= sizeclosure(c->nupvalues);
-  luaM_free(L, c);
+  luaM_free(L, c, sizeclosure(c->nupvalues));
 }
 
 
@@ -97,7 +75,7 @@ void luaF_freeclosure (lua_State *L, Closure *c) {
 */
 const char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
   int i;
-  for (i = 0; i<f->nlocvars && f->locvars[i].startpc <= pc; i++) {
+  for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
     if (pc < f->locvars[i].endpc) {  /* is variable active? */
       local_number--;
       if (local_number == 0)

lfunc.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.h,v 1.12 2000/06/26 19:28:31 roberto Exp roberto $
+** $Id: lfunc.h,v 1.13 2000/09/29 12:42:13 roberto Exp roberto $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
@@ -13,7 +13,6 @@
 
 
 Proto *luaF_newproto (lua_State *L);
-void luaF_protook (lua_State *L, Proto *f, int pc);
 Closure *luaF_newclosure (lua_State *L, int nelems);
 void luaF_freeproto (lua_State *L, Proto *f);
 void luaF_freeclosure (lua_State *L, Closure *c);

lgc.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lgc.c,v 1.73 2000/11/24 17:39:56 roberto Exp roberto $
+** $Id: lgc.c,v 1.74 2000/12/26 18:46:09 roberto Exp roberto $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
@@ -37,11 +37,11 @@ static void protomark (Proto *f) {
     int i;
     f->marked = 1;
     strmark(f->source);
-    for (i=0; i<f->nkstr; i++)
+    for (i=0; i<f->sizekstr; i++)
       strmark(f->kstr[i]);
-    for (i=0; i<f->nkproto; i++)
+    for (i=0; i<f->sizekproto; i++)
       protomark(f->kproto[i]);
-    for (i=0; i<f->nlocvars; i++)  /* mark local-variable names */
+    for (i=0; i<f->sizelocvars; i++)  /* mark local-variable names */
       strmark(f->locvars[i].varname);
   }
 }
@@ -248,8 +248,7 @@ static void collectstrings (lua_State *L, int all) {
       else {  /* collect */
         *p = next->nexthash;
         L->strt.nuse--;
-        L->nblocks -= sizestring(next->len);
-        luaM_free(L, next);
+        luaM_free(L, next, sizestring(next->len));
       }
     }
   }
@@ -273,7 +272,6 @@ static void collectudata (lua_State *L, int all) {
         *p = next->nexthash;
         next->nexthash = L->TMtable[tag].collected;  /* chain udata */
         L->TMtable[tag].collected = next;
-        L->nblocks -= sizestring(next->len);
         L->udt.nuse--;
       }
     }
@@ -286,9 +284,8 @@ static void collectudata (lua_State *L, int all) {
 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 */
-    L->nblocks -= (L->Mbuffsize - newsize)*sizeof(char);
+    luaM_reallocvector(L, L->Mbuffer, L->Mbuffsize, newsize, char);
     L->Mbuffsize = newsize;
-    luaM_reallocvector(L, L->Mbuffer, newsize, char);
   }
 }
 
@@ -320,7 +317,7 @@ static void callgcTMudata (lua_State *L) {
       L->TMtable[tag].collected = udata->nexthash;  /* remove it from list */
       tsvalue(&o) = udata;
       callgcTM(L, &o);
-      luaM_free(L, udata);
+      luaM_free(L, udata, sizeudata(udata->len));
     }
   }
 }

lmem.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lmem.c,v 1.40 2000/11/24 17:39:56 roberto Exp roberto $
+** $Id: lmem.c,v 1.41 2000/12/26 18:46:09 roberto Exp roberto $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
@@ -29,15 +29,14 @@
 #include <limits.h>
 #include <string.h>
 
-#define realloc(b, s)	debug_realloc(b, s)
-#define malloc(b)	debug_realloc(NULL, b)
-#define free(b)		debug_realloc(b, 0)
+#define basicrealloc(b, os, s)	debug_realloc(b, os, s)
+#define basicfree(b, s)		debug_realloc(b, s, 0)
 
 
 /* ensures maximum alignment for HEADER */
 #define HEADER	(sizeof(union L_Umaxalign))
 
-#define MARKSIZE	16
+#define MARKSIZE	32
 #define MARK		0x55  /* 01010101 (a nice pattern) */
 
 
@@ -55,8 +54,6 @@ static void *checkblock (void *block) {
   int i;
   for (i=0;i<MARKSIZE;i++)
     assert(*(((char *)b)+HEADER+size+i) == MARK+i);  /* corrupted block? */
-  memdebug_numblocks--;
-  memdebug_total -= size;
   return b;
 }
 
@@ -66,12 +63,15 @@ static void freeblock (void *block) {
     size_t size = *blocksize(block);
     block = checkblock(block);
     memset(block, -1, size+HEADER+MARKSIZE);  /* erase block */
-    (free)(block);  /* free original block */
+    free(block);  /* free original block */
+    memdebug_numblocks--;
+    memdebug_total -= size;
   }
 }
 
 
-static void *debug_realloc (void *block, size_t size) {
+static void *debug_realloc (void *block, size_t oldsize, size_t size) {
+  assert((oldsize == 0) ? block == NULL : oldsize == *blocksize(block));
   if (size == 0) {
     freeblock(block);
     return NULL;
@@ -79,19 +79,22 @@ static void *debug_realloc (void *block, size_t size) {
   else if (memdebug_total+size > memdebug_memlimit)
     return NULL;  /* to test memory allocation errors */
   else {
-    size_t realsize = HEADER+size+MARKSIZE;
-    char *newblock = (char *)(malloc)(realsize);  /* alloc a new block */
+    char *newblock;
     int i;
+    size_t realsize = HEADER+size+MARKSIZE;
     if (realsize < size) return NULL;  /* overflow! */
+    newblock = (char *)malloc(realsize);  /* alloc a new block */
     if (newblock == NULL) return NULL;
+    if (oldsize > size) oldsize = size;
     if (block) {
-      size_t oldsize = *blocksize(block);
-      if (oldsize > size) oldsize = size;
       memcpy(newblock+HEADER, block, oldsize);
       freeblock(block);  /* erase (and check) old copy */
     }
+    /* initialize new part of the block with something `weird' */
+    memset(newblock+HEADER+oldsize, -MARK, size-oldsize);
     memdebug_total += size;
-    if (memdebug_total > memdebug_maxmem) memdebug_maxmem = memdebug_total;
+    if (memdebug_total > memdebug_maxmem)
+      memdebug_maxmem = memdebug_total;
     memdebug_numblocks++;
     *(size_t *)newblock = size;
     for (i=0;i<MARKSIZE;i++)
@@ -102,20 +105,26 @@ static void *debug_realloc (void *block, size_t size) {
 
 
 /* }====================================================================== */
-#endif
-
 
+#else
+/* no debug */
 
 /*
 ** Real ISO (ANSI) systems do not need these tests;
 ** but some systems (Sun OS) are not that ISO...
 */
 #ifdef OLD_ANSI
-#define realloc(b,s)	((b) == NULL ? malloc(s) : (realloc)(b, s))
-#define free(b)		if (b) (free)(b)
+#define basicrealloc(b,os,s)	((b) == NULL ? malloc(s) : realloc(b, s))
+#define basicfree(b,s)		if (b) free(b)
+#else
+#define basicrealloc(b,os,s)	realloc(b,s)
+#define basicfree(b,s)		free(b)
+
 #endif
 
 
+#endif
+
 void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems,
                     int limit, const char *errormsg) {
   void *newblock;
@@ -127,7 +136,8 @@ void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems,
       newsize = limit;  /* still have at least MINPOWER2 free places */
     else lua_error(L, errormsg);
   }
-  newblock = luaM_realloc(L, block, (luint32)newsize*(luint32)size_elems);
+  newblock = luaM_realloc(L, block, (luint32)(*size)*(luint32)size_elems,
+                                    (luint32)newsize*(luint32)size_elems);
   *size = newsize;  /* update only when everything else is OK */
   return newblock;
 }
@@ -136,20 +146,25 @@ void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems,
 /*
 ** generic allocation routine.
 */
-void *luaM_realloc (lua_State *L, void *block, luint32 size) {
+void *luaM_realloc (lua_State *L, void *block, luint32 oldsize, luint32 size) {
   if (size == 0) {
-    free(block);  /* block may be NULL; that is OK for free */
-    return NULL;
+    basicfree(block, oldsize);  /* block may be NULL; that is OK for free */
+    block = NULL;
   }
   else if (size >= MAX_SIZET)
     lua_error(L, "memory allocation error: block too big");
-  block = realloc(block, size);
-  if (block == NULL) {
-    if (L)
-      luaD_breakrun(L, LUA_ERRMEM);  /* break run without error message */
-    else return NULL;  /* error before creating state! */
+  else {
+    block = basicrealloc(block, oldsize, size);
+    if (block == NULL) {
+      if (L)
+        luaD_breakrun(L, LUA_ERRMEM);  /* break run without error message */
+      else return NULL;  /* error before creating state! */
+    }
+  }
+  if (L) {
+    L->nblocks -= oldsize;
+    L->nblocks += size;
   }
   return block;
 }
 
-

lmem.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lmem.h,v 1.17 2000/11/24 17:39:56 roberto Exp roberto $
+** $Id: lmem.h,v 1.18 2000/12/26 18:46:09 roberto Exp roberto $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
@@ -13,21 +13,29 @@
 #include "llimits.h"
 #include "lua.h"
 
-void *luaM_realloc (lua_State *L, void *oldblock, luint32 size);
+void *luaM_realloc (lua_State *L, void *oldblock, luint32 oldsize,
+                    luint32 size);
+
 void *luaM_growaux (lua_State *L, void *block, int *size, int size_elem,
                     int limit, const char *errormsg);
 
-#define luaM_free(L, b)		luaM_realloc(L, (b), 0)
-#define luaM_malloc(L, t)	luaM_realloc(L, NULL, (t))
+#define luaM_free(L, b, s)	luaM_realloc(L, (b), (s), 0)
+#define luaM_freelem(L, b, t)	luaM_realloc(L, (b), sizeof(t), 0)
+#define luaM_freearray(L, b, n, t)	luaM_realloc(L, (b), \
+                                          ((luint32)(n)*(luint32)sizeof(t)), 0)
+
+#define luaM_malloc(L, t)	luaM_realloc(L, NULL, 0, (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, \
+                                         (luint32)(n)*(luint32)sizeof(t)))
 
 #define luaM_growvector(L,v,nelems,size,t,limit,e) \
           if (((nelems)+1) > (size)) \
             ((v)=(t *)luaM_growaux(L,v,&(size),sizeof(t),limit,e))
 
-#define luaM_reallocvector(L, v,n,t) \
-	((v)=(t *)luaM_realloc(L, v,(n)*(luint32)sizeof(t)))
+#define luaM_reallocvector(L, v,oldn,n,t) \
+	((v)=(t *)luaM_realloc(L, v,(luint32)(oldn)*(luint32)sizeof(t), \
+                                    (luint32)(n)*(luint32)sizeof(t)))
 
 
 #ifdef LUA_DEBUG

lobject.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.c,v 1.56 2000/11/24 17:39:56 roberto Exp roberto $
+** $Id: lobject.c,v 1.57 2000/12/04 18:33:40 roberto Exp roberto $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -57,8 +57,7 @@ int luaO_equalObj (const TObject *t1, const TObject *t2) {
 
 char *luaO_openspace (lua_State *L, size_t n) {
   if (n > L->Mbuffsize) {
-    luaM_reallocvector(L, L->Mbuffer, n, char);
-    L->nblocks += (n - L->Mbuffsize)*sizeof(char);
+    luaM_reallocvector(L, L->Mbuffer, L->Mbuffsize, n, char);
     L->Mbuffsize = n;
   }
   return L->Mbuffer;

lobject.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.h,v 1.83 2000/11/24 17:39:56 roberto Exp roberto $
+** $Id: lobject.h,v 1.84 2000/12/04 18:33:40 roberto Exp roberto $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -102,13 +102,13 @@ typedef struct TString {
 */
 typedef struct Proto {
   lua_Number *knum;  /* numbers used by the function */
-  int nknum;  /* size of `knum' */
+  int sizeknum;  /* size of `knum' */
   struct TString **kstr;  /* strings used by the function */
-  int nkstr;  /* size of `kstr' */
+  int sizekstr;  /* size of `kstr' */
   struct Proto **kproto;  /* functions defined inside the function */
-  int nkproto;  /* size of `kproto' */
+  int sizekproto;  /* size of `kproto' */
   Instruction *code;
-  int ncode;  /* size of `code'; when 0 means an incomplete `Proto' */
+  int sizecode;
   short numparams;
   short is_vararg;
   short maxstacksize;
@@ -116,9 +116,9 @@ typedef struct Proto {
   struct Proto *next;
   /* debug information */
   int *lineinfo;  /* map from opcodes to source lines */
-  int nlineinfo;  /* size of `lineinfo' */
-  int nlocvars;
+  int sizelineinfo;  /* size of `lineinfo' */
   struct LocVar *locvars;  /* information about local variables */
+  int sizelocvars;
   int lineDefined;
   TString  *source;
 } Proto;

lparser.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.c,v 1.119 2000/12/04 18:33:40 roberto Exp roberto $
+** $Id: lparser.c,v 1.120 2000/12/26 18:46:09 roberto Exp roberto $
 ** LL(1) Parser and code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -120,10 +120,10 @@ static void check_match (LexState *ls, int what, int who, int where) {
 static int string_constant (FuncState *fs, TString *s) {
   Proto *f = fs->f;
   int c = s->u.s.constindex;
-  if (c >= f->nkstr || f->kstr[c] != s) {
-    luaM_growvector(fs->L, f->kstr, f->nkstr, fs->sizekstr, TString *,
+  if (c >= fs->nkstr || f->kstr[c] != s) {
+    luaM_growvector(fs->L, f->kstr, fs->nkstr, f->sizekstr, TString *,
                     MAXARG_U, "constant table overflow");
-    c = f->nkstr++;
+    c = fs->nkstr++;
     f->kstr[c] = s;
     s->u.s.constindex = c;  /* hint for next time */
   }
@@ -151,11 +151,12 @@ static int checkname (LexState *ls) {
 
 
 static int luaI_registerlocalvar (LexState *ls, TString *varname) {
-  Proto *f = ls->fs->f;
-  luaM_growvector(ls->L, f->locvars, f->nlocvars, ls->fs->sizelocvars,
+  FuncState *fs = ls->fs;
+  Proto *f = fs->f;
+  luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
                   LocVar, MAX_INT, "");
-  f->locvars[f->nlocvars].varname = varname;
-  return f->nlocvars++;
+  f->locvars[fs->nlocvars].varname = varname;
+  return fs->nlocvars++;
 }
 
 
@@ -295,10 +296,10 @@ static void pushclosure (LexState *ls, FuncState *func) {
   int i;
   for (i=0; i<func->nupvalues; i++)
     luaK_tostack(ls, &func->upvalues[i], 1);
-  luaM_growvector(ls->L, f->kproto, f->nkproto, fs->sizekproto, Proto *,
+  luaM_growvector(ls->L, f->kproto, fs->nkproto, f->sizekproto, Proto *,
                   MAXARG_A, "constant table overflow");
-  f->kproto[f->nkproto++] = func->f;
-  luaK_code2(fs, OP_CLOSURE, f->nkproto-1, func->nupvalues);
+  f->kproto[fs->nkproto++] = func->f;
+  luaK_code2(fs, OP_CLOSURE, fs->nkproto-1, func->nupvalues);
 }
 
 
@@ -313,12 +314,11 @@ static void open_func (LexState *ls, FuncState *fs) {
   fs->lasttarget = 0;
   fs->jlt = NO_JUMP;
   fs->stacklevel = 0;
-  fs->sizekstr = 0;
-  fs->sizekproto = 0;
-  fs->sizeknum = 0;
-  fs->sizelineinfo = 0;
-  fs->sizecode = 0;
-  fs->sizelocvars = 0;
+  fs->nkstr = 0;
+  fs->nkproto = 0;
+  fs->nknum = 0;
+  fs->nlineinfo = 0;
+  fs->nlocvars = 0;
   fs->nactloc = 0;
   fs->nupvalues = 0;
   fs->lastline = 0;
@@ -337,15 +337,20 @@ static void close_func (LexState *ls) {
   Proto *f = fs->f;
   luaK_code0(fs, OP_END);
   luaK_getlabel(fs);  /* close eventual list of pending jumps */
-  luaM_reallocvector(L, f->code, fs->pc, Instruction);
-  luaM_reallocvector(L, f->kstr, f->nkstr, TString *);
-  luaM_reallocvector(L, f->knum, f->nknum, lua_Number);
-  luaM_reallocvector(L, f->kproto, f->nkproto, Proto *);
   removelocalvars(ls, fs->nactloc);
-  luaM_reallocvector(L, f->locvars, f->nlocvars, LocVar);
-  luaM_reallocvector(L, f->lineinfo, f->nlineinfo+1, int);
-  f->lineinfo[f->nlineinfo++] = MAX_INT;  /* end flag */
-  luaF_protook(L, f, fs->pc);  /* proto is ok now */
+  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
+  f->sizecode = fs->pc;
+  luaM_reallocvector(L, f->kstr, f->sizekstr, fs->nkstr, TString *);
+  f->sizekstr = fs->nkstr;
+  luaM_reallocvector(L, f->knum, f->sizeknum, fs->nknum, lua_Number);
+  f->sizeknum = fs->nknum;
+  luaM_reallocvector(L, f->kproto, f->sizekproto, fs->nkproto, Proto *);
+  f->sizekproto = fs->nkproto;
+  luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
+  f->sizelocvars = fs->nlocvars;
+  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->nlineinfo+1, int);
+  f->lineinfo[fs->nlineinfo++] = MAX_INT;  /* end flag */
+  f->sizelineinfo = fs->nlineinfo;
   ls->fs = fs->prev;
   LUA_ASSERT(fs->bl == NULL, "wrong list end");
 }

lparser.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.h,v 1.27 2000/11/30 18:50:47 roberto Exp roberto $
+** $Id: lparser.h,v 1.28 2000/12/26 18:46:09 roberto Exp roberto $
 ** LL(1) Parser and code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -41,16 +41,15 @@ typedef struct FuncState {
   struct FuncState *prev;  /* enclosing function */
   struct LexState *ls;  /* lexical state */
   struct lua_State *L;  /* copy of the Lua state */
-  int pc;  /* next position to code */
+  int pc;  /* next position to code (equivalent to `ncode') */
   int lasttarget;   /* `pc' of last `jump target' */
   int jlt;  /* list of jumps to `lasttarget' */
   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 nkstr;  /* number of elements in `kstr' */
+  int nkproto;  /* number of elements in `kproto' */
+  int nknum;  /* number of elements in `knum' */
+  int nlineinfo;  /* number of elements in `lineinfo' */
+  int nlocvars;  /* number of elements in `locvars' */
   int nactloc;  /* number of active local variables */
   int nupvalues;  /* number of upvalues */
   int lastline;  /* line where last `lineinfo' was generated */

lstate.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lstate.c,v 1.48 2000/10/30 16:29:59 roberto Exp roberto $
+** $Id: lstate.c,v 1.49 2000/12/26 18:46:09 roberto Exp roberto $
 ** Global State
 ** See Copyright Notice in lua.h
 */
@@ -58,8 +58,8 @@ 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 */
-#endif
   LUA_ASSERT(lua_gettop(L) == 0, "wrong API stack");
+#endif
 }
 
 
@@ -67,10 +67,10 @@ LUA_API lua_State *lua_open (int stacksize) {
   lua_State *L = luaM_new(NULL, lua_State);
   if (L == NULL) return NULL;  /* memory allocation error */
   L->stack = NULL;
+  L->stacksize = 0;
   L->strt.size = L->udt.size = 0;
   L->strt.nuse = L->udt.nuse = 0;
-  L->strt.hash = NULL;
-  L->udt.hash = NULL;
+  L->strt.hash = L->udt.hash = NULL;
   L->Mbuffer = NULL;
   L->Mbuffsize = 0;
   L->rootproto = NULL;
@@ -106,17 +106,12 @@ LUA_API void lua_close (lua_State *L) {
   LUA_ASSERT(L->rootcl == NULL, "list should be empty");
   LUA_ASSERT(L->roottable == NULL, "list should be empty");
   luaS_freeall(L);
-  if (L->stack)
-    L->nblocks -= (L->stack_last - L->stack + 1)*sizeof(TObject);
-  luaM_free(L, L->stack);
-  L->nblocks -= L->ntag*sizeof(struct TM);
-  luaM_free(L, L->TMtable);
-  L->nblocks -= (L->nref)*sizeof(struct Ref);
-  luaM_free(L, L->refArray);
-  L->nblocks -= (L->Mbuffsize)*sizeof(char);
-  luaM_free(L, L->Mbuffer);
+  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_free(L, L);
+  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!");
 }

lstring.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.c,v 1.46 2000/11/24 17:39:56 roberto Exp roberto $
+** $Id: lstring.c,v 1.47 2000/12/22 16:57:46 roberto Exp roberto $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
@@ -15,32 +15,18 @@
 #include "lstring.h"
 
 
-/*
-** type equivalent to TString, but with maximum alignment requirements
-*/
-union L_UTString {
-  TString ts;
-  union L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
-};
-
-
 
 void luaS_init (lua_State *L) {
-  L->strt.hash = luaM_newvector(L, 1, TString *);
-  L->udt.hash = luaM_newvector(L, 1, TString *);
-  L->nblocks += 2*sizeof(TString *);
-  L->strt.size = L->udt.size = 1;
-  L->strt.nuse = L->udt.nuse = 0;
-  L->strt.hash[0] = L->udt.hash[0] = NULL;
+  luaS_resize(L, &L->strt, MINPOWER2);
+  luaS_resize(L, &L->udt, MINPOWER2);
 }
 
 
 void luaS_freeall (lua_State *L) {
   LUA_ASSERT(L->strt.nuse==0, "non-empty string table");
-  L->nblocks -= (L->strt.size + L->udt.size)*sizeof(TString *);
-  luaM_free(L, L->strt.hash);
+  luaM_freearray(L, L->strt.hash, L->strt.size, TString *);
   LUA_ASSERT(L->udt.nuse==0, "non-empty udata table");
-  luaM_free(L, L->udt.hash);
+  luaM_freearray(L, L->udt.hash, L->udt.size, TString *);
 }
 
 
@@ -71,9 +57,7 @@ void luaS_resize (lua_State *L, stringtable *tb, int newsize) {
       p = next;
     }
   }
-  luaM_free(L, tb->hash);
-  L->nblocks -= tb->size*sizeof(TString *);
-  L->nblocks += newsize*sizeof(TString *);
+  luaM_freearray(L, tb->hash, tb->size, TString *);
   tb->size = newsize;
   tb->hash = newhash;
 }
@@ -106,23 +90,20 @@ 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 */
-  L->nblocks += sizestring(l);
   newentry(L, &L->strt, ts, h1);  /* insert it on table */
   return ts;
 }
 
 
 TString *luaS_newudata (lua_State *L, size_t s, void *udata) {
-  union L_UTString *uts = (union L_UTString *)luaM_malloc(L,
-                                (luint32)sizeof(union L_UTString)+s);
+  union L_UTString *uts = (union L_UTString *)luaM_malloc(L, sizeudata(s));
   TString *ts = &uts->ts;
   ts->marked = 0;
   ts->nexthash = NULL;
   ts->len = s;
   ts->u.d.tag = 0;
   ts->u.d.value = (udata == NULL) ? uts+1 : udata;
-  L->nblocks += sizestring(s);
- /* insert it on table */
+  /* insert it on table */
   newentry(L, &L->udt, ts, IntPoint(ts->u.d.value) & (L->udt.size-1));
   return ts;
 }

lstring.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.h,v 1.24 2000/10/30 17:49:19 roberto Exp roberto $
+** $Id: lstring.h,v 1.25 2000/11/24 17:39:56 roberto Exp roberto $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
@@ -12,6 +12,17 @@
 #include "lstate.h"
 
 
+
+/*
+** type equivalent to TString, but with maximum alignment requirements
+*/
+union L_UTString {
+  TString ts;
+  union L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
+};
+
+
+
 /*
 ** any TString with mark>=FIXMARK is never collected.
 ** Marks>=RESERVEDMARK are used to identify reserved words.
@@ -23,6 +34,8 @@
 #define sizestring(l)	((lint32)sizeof(TString) + \
                          ((lint32)(l+1)-TSPACK)*(lint32)sizeof(char))
 
+#define sizeudata(l)	((luint32)sizeof(union L_UTString)+(l))
+
 
 void luaS_init (lua_State *L);
 void luaS_resize (lua_State *L, stringtable *tb, int newsize);

ltable.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.c,v 1.60 2000/12/04 18:33:40 roberto Exp roberto $
+** $Id: ltable.c,v 1.61 2000/12/22 16:57:46 roberto Exp roberto $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -27,9 +27,6 @@
 #include "ltable.h"
 
 
-#define gcsize(L, n)	(sizeof(Hash)+(n)*sizeof(Node))
-
-
 
 #define TagDefault LUA_TTABLE
 
@@ -167,8 +164,6 @@ static void setnodevector (lua_State *L, Hash *t, luint32 size) {
     ttype(&t->node[i].key) = ttype(&t->node[i].val) = LUA_TNIL;
     t->node[i].next = NULL;
   }
-  L->nblocks -= gcsize(L, t->size);  /* old size */
-  L->nblocks += gcsize(L, size);  /* new size */
   t->size = size;
   t->firstfree = &t->node[size-1];  /* first free position to be used */
 }
@@ -181,7 +176,6 @@ Hash *luaH_new (lua_State *L, int size) {
   L->roottable = t;
   t->mark = t;
   t->size = 0;
-  L->nblocks += gcsize(L, 0);
   t->node = NULL;
   setnodevector(L, t, luaO_power2(size));
   return t;
@@ -189,9 +183,8 @@ Hash *luaH_new (lua_State *L, int size) {
 
 
 void luaH_free (lua_State *L, Hash *t) {
-  L->nblocks -= gcsize(L, t->size);
-  luaM_free(L, t->node);
-  luaM_free(L, t);
+  luaM_freearray(L, t->node, t->size, Node);
+  luaM_freelem(L, t, Hash);
 }
 
 
@@ -226,7 +219,7 @@ static void rehash (lua_State *L, Hash *t) {
     if (ttype(&old->val) != LUA_TNIL)
       *luaH_set(L, t, &old->key) = old->val;
   }
-  luaM_free(L, nold);  /* free old array */
+  luaM_freearray(L, nold, oldsize, Node);  /* free old array */
 }
 
 

ltests.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ltests.c,v 1.53 2000/10/30 16:29:59 roberto Exp roberto $
+** $Id: ltests.c,v 1.54 2000/10/31 13:10:24 roberto Exp roberto $
 ** Internal Module for Debugging of the Lua Implementation
 ** See Copyright Notice in lua.h
 */
@@ -116,7 +116,7 @@ static int liststrings (lua_State *L) {
                  1, "Lua function expected");
   p = clvalue(luaA_index(L, 1))->f.l;
   lua_newtable(L);
-  for (i=0; i<p->nkstr; i++) {
+  for (i=0; i<p->sizekstr; i++) {
     lua_pushnumber(L, i+1);
     lua_pushstring(L, p->kstr[i]->str);
     lua_settable(L, -3);

ltm.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ltm.c,v 1.57 2000/11/30 18:50:47 roberto Exp roberto $
+** $Id: ltm.c,v 1.58 2000/12/26 18:46:09 roberto Exp roberto $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
@@ -75,9 +75,8 @@ static void init_entry (lua_State *L, int tag) {
 
 void luaT_init (lua_State *L) {
   int t;
+  L->TMtable = luaM_newvector(L, NUM_TAGS+2, struct TM);
   L->sizeTM = NUM_TAGS+2;
-  L->TMtable = luaM_newvector(L, L->sizeTM, struct TM);
-  L->nblocks += NUM_TAGS*sizeof(struct TM);
   L->ntag = NUM_TAGS;
   for (t=0; t<L->ntag; t++)
     init_entry(L, t);
@@ -87,7 +86,6 @@ void luaT_init (lua_State *L) {
 LUA_API int lua_newtag (lua_State *L) {
   luaM_growvector(L, L->TMtable, L->ntag, L->sizeTM, struct TM,
                   MAX_INT, "tag table overflow");
-  L->nblocks += sizeof(struct TM);
   init_entry(L, L->ntag);
   return L->ntag++;
 }

lundump.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lundump.c,v 1.34 2000/11/07 12:44:44 roberto Exp roberto $
+** $Id: lundump.c,v 1.35 2000/12/04 18:33:40 roberto Exp roberto $
 ** load bytecodes from files
 ** See Copyright Notice in lua.h
 */
@@ -104,17 +104,17 @@ static TString* LoadString (lua_State* L, ZIO* Z, int swap)
 
 static void LoadCode (lua_State* L, Proto* tf, ZIO* Z, int swap)
 {
- int size=LoadInt(L,Z,swap);
+ int size;
+ tf->sizecode=size=LoadInt(L,Z,swap);
  tf->code=luaM_newvector(L,size,Instruction);
  LoadVector(L,tf->code,size,sizeof(*tf->code),Z,swap);
  if (tf->code[size-1]!=OP_END) luaO_verror(L,"bad code in `%.99s'",ZNAME(Z));
- luaF_protook(L,tf,size);
 }
 
 static void LoadLocals (lua_State* L, Proto* tf, ZIO* Z, int swap)
 {
  int i,n;
- tf->nlocvars=n=LoadInt(L,Z,swap);
+ tf->sizelocvars=n=LoadInt(L,Z,swap);
  tf->locvars=luaM_newvector(L,n,LocVar);
  for (i=0; i<n; i++)
  {
@@ -127,7 +127,7 @@ static void LoadLocals (lua_State* L, Proto* tf, ZIO* Z, int swap)
 static void LoadLines (lua_State* L, Proto* tf, ZIO* Z, int swap)
 {
  int n;
- tf->nlineinfo=n=LoadInt(L,Z,swap);
+ tf->sizelineinfo=n=LoadInt(L,Z,swap);
  tf->lineinfo=luaM_newvector(L,n,int);
  LoadVector(L,tf->lineinfo,n,sizeof(*tf->lineinfo),Z,swap);
 }
@@ -137,14 +137,14 @@ static Proto* LoadFunction (lua_State* L, ZIO* Z, int swap);
 static void LoadConstants (lua_State* L, Proto* tf, ZIO* Z, int swap)
 {
  int i,n;
- tf->nkstr=n=LoadInt(L,Z,swap);
+ tf->sizekstr=n=LoadInt(L,Z,swap);
  tf->kstr=luaM_newvector(L,n,TString*);
  for (i=0; i<n; i++)
   tf->kstr[i]=LoadString(L,Z,swap);
- tf->nknum=n=LoadInt(L,Z,swap);
+ tf->sizeknum=n=LoadInt(L,Z,swap);
  tf->knum=luaM_newvector(L,n,lua_Number);
  LoadVector(L,tf->knum,n,sizeof(*tf->knum),Z,swap);
- tf->nkproto=n=LoadInt(L,Z,swap);
+ tf->sizekproto=n=LoadInt(L,Z,swap);
  tf->kproto=luaM_newvector(L,n,Proto*);
  for (i=0; i<n; i++)
   tf->kproto[i]=LoadFunction(L,Z,swap);

lvm.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.c,v 1.147 2000/11/24 17:39:56 roberto Exp roberto $
+** $Id: lvm.c,v 1.148 2000/12/04 18:33:40 roberto Exp roberto $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -35,7 +35,7 @@
 ** Extra stack size to run a function:
 ** TAG_LINE(1), NAME(1), TM calls(3) (plus some extra...)
 */
-#define	EXTRA_STACK	8
+#define	EXTRA_FSTACK	8
 
 
 
@@ -355,7 +355,7 @@ StkId luaV_execute (lua_State *L, const Closure *cl, StkId base) {
   TString **const kstr = tf->kstr;
   const lua_Hook linehook = L->linehook;
   infovalue(base-1)->pc = &pc;
-  luaD_checkstack(L, tf->maxstacksize+EXTRA_STACK);
+  luaD_checkstack(L, tf->maxstacksize+EXTRA_FSTACK);
   if (tf->is_vararg)  /* varargs? */
     adjust_varargs(L, base, tf->numparams);
   else