string hash uses one single hash table

1 files changed, 35 insertions, 76 deletions

diff --git a/lstring.c b/lstring.c
index 3c9d0d8f..507e945a 100644
--- a/lstring.c
+++ b/lstring.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.c,v 1.34 2000/03/10 18:37:44 roberto Exp roberto $
+** $Id: lstring.c,v 1.35 2000/05/08 19:32:53 roberto Exp roberto $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
@@ -17,30 +17,20 @@
 
 
 
-#define gcsizestring(L, l)      numblocks(L, 0, sizeof(TString)+l)
-#define gcsizeudata             gcsizestring(L, 0)
-
-
-
 void luaS_init (lua_State *L) {
-  int i;
-  L->string_root = luaM_newvector(L, NUM_HASHS, stringtable);
-  for (i=0; i<NUM_HASHS; i++) {
-    L->string_root[i].size = 1;
-    L->string_root[i].nuse = 0;
-    L->string_root[i].hash = luaM_newvector(L, 1, TString *);;
-    L->string_root[i].hash[0] = NULL;
-  }
+  L->strt.size = L->udt.size = 1;
+  L->strt.nuse = L->udt.nuse = 0;
+  L->strt.hash = luaM_newvector(L, 1, TString *);
+  L->udt.hash = luaM_newvector(L, 1, TString *);
+  L->strt.hash[0] = L->udt.hash[0] = NULL;
 }
 
 
 void luaS_freeall (lua_State *L) {
-  int i;
-  for (i=0; i<NUM_HASHS; i++) {
-    LUA_ASSERT(L, L->string_root[i].nuse==0, "non-empty string table");
-    luaM_free(L, L->string_root[i].hash);
-  }
-  luaM_free(L, L->string_root);
+  LUA_ASSERT(L, L->strt.nuse==0, "non-empty string table");
+  luaM_free(L, L->strt.hash);
+  LUA_ASSERT(L, L->udt.nuse==0, "non-empty udata table");
+  luaM_free(L, L->udt.hash);
 }
 
 
@@ -62,8 +52,7 @@ 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 */
-      unsigned long h = (p->constindex == -1) ? IntPoint(p->u.d.value) :
-                                                p->u.s.hash;
+      unsigned long h = (tb == &L->strt) ? p->u.s.hash : IntPoint(p->u.d.value);
       int h1 = h&(newsize-1);  /* new position */
       LUA_ASSERT(L, h%newsize == (h&(newsize-1)),
                     "a&(x-1) == a%x, for x power of 2");
@@ -78,79 +67,55 @@ void luaS_resize (lua_State *L, stringtable *tb, int newsize) {
 }
 
 
-static TString *newone (lua_State *L, long l) {
-  TString *ts = (TString *)luaM_malloc(L, sizeof(TString)+l*sizeof(char));
-  ts->marked = 0;
-  ts->nexthash = NULL;
-  return ts;
-}
-
-
-static TString *newone_s (lua_State *L, const char *str,
-                               long l, unsigned long h) {
-  TString *ts = newone(L, l);
-  memcpy(ts->str, str, l);
-  ts->str[l] = 0;  /* ending 0 */
-  ts->u.s.len = l;
-  ts->u.s.hash = h;
-  ts->constindex = 0;
-  L->nblocks += gcsizestring(L, l);
-  return ts;
-}
-
-
-static TString *newone_u (lua_State *L, void *buff, int tag) {
-  TString *ts = newone(L, 0);
-  ts->u.d.value = buff;
-  ts->u.d.tag = (tag == LUA_ANYTAG) ? 0 : tag;
-  ts->constindex = -1;  /* tag -> this is a userdata */
-  L->nblocks += gcsizeudata;
-  return ts;
-}
-
-
 static void newentry (lua_State *L, stringtable *tb, TString *ts, int h) {
   ts->nexthash = tb->hash[h];  /* chain new entry */
   tb->hash[h] = ts;
   tb->nuse++;
-  if (tb->nuse > tb->size)  /* too crowded? */
+  if (tb->nuse > tb->size && tb->size < MAX_INT/2)  /* too crowded? */
     luaS_resize(L, tb, tb->size*2);
 }
 
 
+
 TString *luaS_newlstr (lua_State *L, const char *str, long l) {
   unsigned long h = hash_s(str, l);
-  stringtable *tb = &L->string_root[(l==0) ? 0 :
-                         ((unsigned int)(str[0]+str[l-1]))&(NUM_HASHSTR-1)];
-  int h1 = h&(tb->size-1);
+  int h1 = h&(L->strt.size-1);
   TString *ts;
-  for (ts = tb->hash[h1]; ts; ts = ts->nexthash) {
+  for (ts = L->strt.hash[h1]; ts; ts = ts->nexthash) {
     if (ts->u.s.len == l && (memcmp(str, ts->str, l) == 0))
       return ts;
   }
   /* not found */
-  ts = newone_s(L, str, l, h);  /* create new entry */
-  newentry(L, tb, ts, h1);  /* insert it on table */
+  ts = (TString *)luaM_malloc(L, sizeof(TString)+l*sizeof(char));
+  ts->marked = 0;
+  ts->nexthash = NULL;
+  ts->u.s.len = l;
+  ts->u.s.hash = h;
+  ts->u.s.constindex = 0;
+  memcpy(ts->str, str, l);
+  ts->str[l] = 0;  /* ending 0 */
+  L->nblocks += gcsizestring(L, l);
+  newentry(L, &L->strt, ts, h1);  /* insert it on table */
   return ts;
 }
 
 
-/*
-** uses '%' for one hashing with userdata because addresses are too regular,
-** so two '&' operations would be highly correlated
-*/
 TString *luaS_createudata (lua_State *L, void *udata, int tag) {
   unsigned long h = IntPoint(udata);
-  stringtable *tb = &L->string_root[(h%NUM_HASHUDATA)+NUM_HASHSTR];
-  int h1 = h&(tb->size-1);
+  int h1 = h&(L->udt.size-1);
   TString *ts;
-  for (ts = tb->hash[h1]; ts; ts = ts->nexthash) {
+  for (ts = L->udt.hash[h1]; ts; ts = ts->nexthash) {
     if (udata == ts->u.d.value && (tag == ts->u.d.tag || tag == LUA_ANYTAG))
       return ts;
   }
   /* not found */
-  ts = newone_u(L, udata, tag);
-  newentry(L, tb, ts, h1);
+  ts = luaM_new(L, TString);
+  ts->marked = 0;
+  ts->nexthash = NULL;
+  ts->u.d.value = udata;
+  ts->u.d.tag = (tag == LUA_ANYTAG) ? 0 : tag;
+  L->nblocks += gcsizeudata;
+  newentry(L, &L->udt, ts, h1);  /* insert it on table */
   return ts;
 }
 
@@ -159,16 +124,10 @@ TString *luaS_new (lua_State *L, const char *str) {
   return luaS_newlstr(L, str, strlen(str));
 }
 
+
 TString *luaS_newfixed (lua_State *L, const char *str) {
   TString *ts = luaS_new(L, str);
   if (ts->marked == 0) ts->marked = FIXMARK;  /* avoid GC */
   return ts;
 }
 
-
-void luaS_free (lua_State *L, TString *t) {
-  L->nblocks -= (t->constindex == -1) ? gcsizeudata :
-                                        gcsizestring(L, t->u.s.len);
-  luaM_free(L, t);
-}
-