Lua 4.04.0

1 files changed, 66 insertions, 55 deletions

diff --git a/src/lfunc.c b/src/lfunc.c
index 7494e2cd..6841ef71 100644
--- a/src/lfunc.c
+++ b/src/lfunc.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.c,v 1.10 1999/03/04 21:17:26 roberto Exp $
+** $Id: lfunc.c,v 1.34 2000/10/30 12:20:29 roberto Exp $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
@@ -7,92 +7,103 @@
 
 #include <stdlib.h>
 
+#include "lua.h"
+
 #include "lfunc.h"
 #include "lmem.h"
 #include "lstate.h"
 
-#define gcsizeproto(p)	5  /* approximate "weight" for a prototype */
-#define gcsizeclosure(c) 1  /* approximate "weight" for a closure */
 
+#define sizeclosure(n)	((int)sizeof(Closure) + (int)sizeof(TObject)*((n)-1))
 
 
-Closure *luaF_newclosure (int nelems)
-{
-  Closure *c = (Closure *)luaM_malloc(sizeof(Closure)+nelems*sizeof(TObject));
-  luaO_insertlist(&(L->rootcl), (GCnode *)c);
-  L->nblocks += gcsizeclosure(c);
-  c->nelems = nelems;
+Closure *luaF_newclosure (lua_State *L, int nelems) {
+  int size = sizeclosure(nelems);
+  Closure *c = (Closure *)luaM_malloc(L, size);
+  c->next = L->rootcl;
+  L->rootcl = c;
+  c->mark = c;
+  c->nupvalues = nelems;
+  L->nblocks += size;
   return c;
 }
 
 
-TProtoFunc *luaF_newproto (void)
-{
-  TProtoFunc *f = luaM_new(TProtoFunc);
+Proto *luaF_newproto (lua_State *L) {
+  Proto *f = luaM_new(L, Proto);
+  f->knum = NULL;
+  f->nknum = 0;
+  f->kstr = NULL;
+  f->nkstr = 0;
+  f->kproto = NULL;
+  f->nkproto = 0;
   f->code = NULL;
+  f->ncode = 0;
+  f->numparams = 0;
+  f->is_vararg = 0;
+  f->maxstacksize = 0;
+  f->marked = 0;
+  f->lineinfo = NULL;
+  f->nlineinfo = 0;
+  f->nlocvars = 0;
+  f->locvars = NULL;
   f->lineDefined = 0;
   f->source = NULL;
-  f->consts = NULL;
-  f->nconsts = 0;
-  f->locvars = NULL;
-  luaO_insertlist(&(L->rootproto), (GCnode *)f);
-  L->nblocks += gcsizeproto(f);
+  f->next = L->rootproto;  /* chain in list of protos */
+  L->rootproto = f;
   return f;
 }
 
 
+static size_t protosize (Proto *f) {
+  return sizeof(Proto)
+       + f->nknum*sizeof(Number)
+       + f->nkstr*sizeof(TString *)
+       + f->nkproto*sizeof(Proto *)
+       + f->ncode*sizeof(Instruction)
+       + f->nlocvars*sizeof(struct LocVar)
+       + f->nlineinfo*sizeof(int);
+}
 
-static void freefunc (TProtoFunc *f)
-{
-  luaM_free(f->code);
-  luaM_free(f->locvars);
-  luaM_free(f->consts);
-  luaM_free(f);
+
+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 (TProtoFunc *l)
-{
-  while (l) {
-    TProtoFunc *next = (TProtoFunc *)l->head.next;
-    L->nblocks -= gcsizeproto(l);
-    freefunc(l);
-    l = next;
-  }
+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);
 }
 
 
-void luaF_freeclosure (Closure *l)
-{
-  while (l) {
-    Closure *next = (Closure *)l->head.next;
-    L->nblocks -= gcsizeclosure(l);
-    luaM_free(l);
-    l = next;
-  }
+void luaF_freeclosure (lua_State *L, Closure *c) {
+  L->nblocks -= sizeclosure(c->nupvalues);
+  luaM_free(L, c);
 }
 
 
 /*
-** Look for n-th local variable at line "line" in function "func".
+** Look for n-th local variable at line `line' in function `func'.
 ** Returns NULL if not found.
 */
-char *luaF_getlocalname (TProtoFunc *func, int local_number, int line)
-{
-  int count = 0;
-  char *varname = NULL;
-  LocVar *lv = func->locvars;
-  if (lv == NULL)
-    return NULL;
-  for (; lv->line != -1 && lv->line < line; lv++) {
-    if (lv->varname) {  /* register */
-      if (++count == local_number)
-        varname = lv->varname->str;
+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++) {
+    if (pc < f->locvars[i].endpc) {  /* is variable active? */
+      local_number--;
+      if (local_number == 0)
+        return f->locvars[i].varname->str;
     }
-    else  /* unregister */
-      if (--count < local_number)
-        varname = NULL;
   }
-  return varname;
+  return NULL;  /* not found */
 }