diff --git a/lapi.c b/lapi.c
index 2b37a72d..a65cc510 100644
--- a/lapi.c
+++ b/lapi.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.c,v 1.3 1997/10/24 17:17:24 roberto Exp roberto $
+** $Id: lapi.c,v 1.4 1997/11/04 15:27:53 roberto Exp roberto $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
@@ -10,13 +10,12 @@
 
 #include "lapi.h"
 #include "lauxlib.h"
-#include "lbuiltin.h"
 #include "ldo.h"
 #include "lfunc.h"
 #include "lgc.h"
-#include "llex.h"
 #include "lmem.h"
 #include "lobject.h"
+#include "lstate.h"
 #include "lstring.h"
 #include "ltable.h"
 #include "ltm.h"
@@ -38,41 +37,41 @@ TObject *luaA_Address (lua_Object o)
 
 void luaA_packresults (void)
 {
-  luaV_pack(luaD_Cstack.lua2C, luaD_Cstack.num, luaD_stack.top);
+  luaV_pack(L->Cstack.lua2C, L->Cstack.num, L->stack.top);
   incr_top;
 }
 
 
 int luaA_passresults (void)
 {
-  luaD_checkstack(luaD_Cstack.num);
-  memcpy(luaD_stack.top, luaD_Cstack.lua2C+luaD_stack.stack,
-         luaD_Cstack.num*sizeof(TObject));
-  luaD_stack.top += luaD_Cstack.num;
-  return luaD_Cstack.num;
+  luaD_checkstack(L->Cstack.num);
+  memcpy(L->stack.top, L->Cstack.lua2C+L->stack.stack,
+         L->Cstack.num*sizeof(TObject));
+  L->stack.top += L->Cstack.num;
+  return L->Cstack.num;
 }
 
 
 static void checkCparams (int nParams)
 {
-  if (luaD_stack.top-luaD_stack.stack < luaD_Cstack.base+nParams)
+  if (L->stack.top-L->stack.stack < L->Cstack.base+nParams)
     lua_error("API error - wrong number of arguments in C2lua stack");
 }
 
 
 static lua_Object put_luaObject (TObject *o)
 {
-  luaD_openstack((luaD_stack.top-luaD_stack.stack)-luaD_Cstack.base);
-  luaD_stack.stack[luaD_Cstack.base++] = *o;
-  return luaD_Cstack.base;  /* this is +1 real position (see Ref) */
+  luaD_openstack((L->stack.top-L->stack.stack)-L->Cstack.base);
+  L->stack.stack[L->Cstack.base++] = *o;
+  return L->Cstack.base;  /* this is +1 real position (see Ref) */
 }
 
 
 static lua_Object put_luaObjectonTop (void)
 {
-  luaD_openstack((luaD_stack.top-luaD_stack.stack)-luaD_Cstack.base);
-  luaD_stack.stack[luaD_Cstack.base++] = *(--luaD_stack.top);
-  return luaD_Cstack.base;  /* this is +1 real position (see Ref) */
+  luaD_openstack((L->stack.top-L->stack.stack)-L->Cstack.base);
+  L->stack.stack[L->Cstack.base++] = *(--L->stack.top);
+  return L->Cstack.base;  /* this is +1 real position (see Ref) */
 }
 
 
@@ -89,20 +88,20 @@ lua_Object lua_pop (void)
 */
 lua_Object lua_lua2C (int number)
 {
-  if (number <= 0 || number > luaD_Cstack.num) return LUA_NOOBJECT;
-  /* Ref(luaD_stack.stack+(luaD_Cstack.lua2C+number-1)) ==
-     luaD_stack.stack+(luaD_Cstack.lua2C+number-1)-luaD_stack.stack+1 == */
-  return luaD_Cstack.lua2C+number;
+  if (number <= 0 || number > L->Cstack.num) return LUA_NOOBJECT;
+  /* Ref(L->stack.stack+(L->Cstack.lua2C+number-1)) ==
+     L->stack.stack+(L->Cstack.lua2C+number-1)-L->stack.stack+1 == */
+  return L->Cstack.lua2C+number;
 }
 
 
 lua_Object lua_upvalue (int n)
 {
-  TObject *f = luaD_stack.stack+luaD_Cstack.lua2C-1;
+  TObject *f = L->stack.stack+L->Cstack.lua2C-1;
   if (ttype(f) != LUA_T_MARK || n <= 0 || n > clvalue(f)->nelems)
     return LUA_NOOBJECT;
 if (ttype(protovalue(f)) != LUA_T_CPROTO) lua_error("BAD!!");
-  *luaD_stack.top = clvalue(f)->consts[n];
+  *L->stack.top = clvalue(f)->consts[n];
   incr_top;
   return put_luaObjectonTop();
 }
@@ -113,8 +112,8 @@ int lua_callfunction (lua_Object function)
   if (function == LUA_NOOBJECT)
     return 1;
   else {
-    luaD_openstack((luaD_stack.top-luaD_stack.stack)-luaD_Cstack.base);
-    luaD_stack.stack[luaD_Cstack.base] = *Address(function);
+    luaD_openstack((L->stack.top-L->stack.stack)-L->Cstack.base);
+    L->stack.stack[L->Cstack.base] = *Address(function);
     return luaD_protectedrun(MULT_RET);
   }
 }
@@ -129,16 +128,16 @@ lua_Object lua_gettagmethod (int tag, char *event)
 lua_Object lua_settagmethod (int tag, char *event)
 {
   checkCparams(1);
-  luaT_settagmethod(tag, event, luaD_stack.top-1);
+  luaT_settagmethod(tag, event, L->stack.top-1);
   return put_luaObjectonTop();
 }
 
 
 lua_Object lua_seterrormethod (void)
 {
-  TObject temp = luaD_errorim;
+  TObject temp = L->errorim;
   checkCparams(1);
-  luaD_errorim = *(--luaD_stack.top);
+  L->errorim = *(--L->stack.top);
   return put_luaObject(&temp);
 }
 
@@ -154,15 +153,15 @@ lua_Object lua_gettable (void)
 lua_Object lua_rawgettable (void)
 {
   checkCparams(2);
-  if (ttype(luaD_stack.top-2) != LUA_T_ARRAY)
+  if (ttype(L->stack.top-2) != LUA_T_ARRAY)
     lua_error("indexed expression not a table in raw gettable");
   else {
-    TObject *h = luaH_get(avalue(luaD_stack.top-2), luaD_stack.top-1);
-    --luaD_stack.top;
+    TObject *h = luaH_get(avalue(L->stack.top-2), L->stack.top-1);
+    --L->stack.top;
     if (h != NULL)
-      *(luaD_stack.top-1) = *h;
+      *(L->stack.top-1) = *h;
     else
-      ttype(luaD_stack.top-1) = LUA_T_NIL;
+      ttype(L->stack.top-1) = LUA_T_NIL;
   }
   return put_luaObjectonTop();
 }
@@ -171,14 +170,14 @@ lua_Object lua_rawgettable (void)
 void lua_settable (void)
 {
   checkCparams(3);
-  luaV_settable(luaD_stack.top-3, 1);
+  luaV_settable(L->stack.top-3, 1);
 }
 
 
 void lua_rawsettable (void)
 {
   checkCparams(3);
-  luaV_settable(luaD_stack.top-3, 0);
+  luaV_settable(L->stack.top-3, 0);
 }
 
 
@@ -192,6 +191,12 @@ lua_Object lua_createtable (void)
 }
 
 
+lua_Object lua_globalbag (void)
+{
+  return put_luaObject(&L->globalbag);
+}
+
+
 lua_Object lua_getglobal (char *name)
 {
   luaD_checkstack(2);  /* may need that to call T.M. */
@@ -219,7 +224,7 @@ void lua_rawsetglobal (char *name)
 {
   TaggedString *ts = luaS_new(name);
   checkCparams(1);
-  luaS_rawsetglobal(ts, --luaD_stack.top);
+  luaS_rawsetglobal(ts, --L->stack.top);
 }
 
 
@@ -293,24 +298,24 @@ lua_CFunction lua_getcfunction (lua_Object object)
 
 void lua_pushnil (void)
 {
-  ttype(luaD_stack.top) = LUA_T_NIL;
+  ttype(L->stack.top) = LUA_T_NIL;
   incr_top;
 }
 
 void lua_pushnumber (real n)
 {
-  ttype(luaD_stack.top) = LUA_T_NUMBER;
-  nvalue(luaD_stack.top) = n;
+  ttype(L->stack.top) = LUA_T_NUMBER;
+  nvalue(L->stack.top) = n;
   incr_top;
 }
 
 void lua_pushstring (char *s)
 {
   if (s == NULL)
-    ttype(luaD_stack.top) = LUA_T_NIL;
+    ttype(L->stack.top) = LUA_T_NIL;
   else {
-    tsvalue(luaD_stack.top) = luaS_new(s);
-    ttype(luaD_stack.top) = LUA_T_STRING;
+    tsvalue(L->stack.top) = luaS_new(s);
+    ttype(L->stack.top) = LUA_T_STRING;
   }
   incr_top;
   luaC_checkGC();
@@ -319,13 +324,13 @@ void lua_pushstring (char *s)
 void lua_pushCclosure (lua_CFunction fn, int n)
 {
   if (fn == NULL) {
-    ttype(luaD_stack.top) = LUA_T_NIL;
+    ttype(L->stack.top) = LUA_T_NIL;
     incr_top;
   }
   else {
     checkCparams(n);
-    ttype(luaD_stack.top) = LUA_T_CPROTO;
-    fvalue(luaD_stack.top) = fn;
+    ttype(L->stack.top) = LUA_T_CPROTO;
+    fvalue(L->stack.top) = fn;
     incr_top;
     luaV_closure(n);
   }
@@ -335,15 +340,15 @@ void lua_pushusertag (void *u, int tag)
 {
   if (tag < 0 && tag != LUA_ANYTAG)
     luaT_realtag(tag);  /* error if tag is not valid */
-  tsvalue(luaD_stack.top) = luaS_createudata(u, tag);
-  ttype(luaD_stack.top) = LUA_T_USERDATA;
+  tsvalue(L->stack.top) = luaS_createudata(u, tag);
+  ttype(L->stack.top) = LUA_T_USERDATA;
   incr_top;
   luaC_checkGC();
 }
 
 void luaA_pushobject (TObject *o)
 {
-  *luaD_stack.top = *o;
+  *L->stack.top = *o;
   incr_top;
 }
 
@@ -351,9 +356,9 @@ void lua_pushobject (lua_Object o)
 {
   if (o == LUA_NOOBJECT)
     lua_error("API error - attempt to push a NOOBJECT");
-  *luaD_stack.top = *Address(o);
-  if (ttype(luaD_stack.top) == LUA_T_MARK)
-    ttype(luaD_stack.top) = LUA_T_FUNCTION;
+  *L->stack.top = *Address(o);
+  if (ttype(L->stack.top) == LUA_T_MARK)
+    ttype(L->stack.top) = LUA_T_FUNCTION;
   incr_top;
 }
 
@@ -376,18 +381,18 @@ void lua_settag (int tag)
 {
   checkCparams(1);
   luaT_realtag(tag);
-  switch (ttype(luaD_stack.top-1)) {
+  switch (ttype(L->stack.top-1)) {
     case LUA_T_ARRAY:
-      (luaD_stack.top-1)->value.a->htag = tag;
+      (L->stack.top-1)->value.a->htag = tag;
       break;
     case LUA_T_USERDATA:
-      (luaD_stack.top-1)->value.ts->u.d.tag = tag;
+      (L->stack.top-1)->value.ts->u.d.tag = tag;
       break;
     default:
       luaL_verror("cannot change the tag of a %s",
-                  luaO_typenames[-ttype((luaD_stack.top-1))]);
+                  luaO_typenames[-ttype((L->stack.top-1))]);
   }
-  luaD_stack.top--;
+  L->stack.top--;
 }
 
 
@@ -406,10 +411,10 @@ lua_LHFunction lua_linehook = NULL;
 lua_Function lua_stackedfunction (int level)
 {
   StkId i;
-  for (i = (luaD_stack.top-1)-luaD_stack.stack; i>=0; i--)
-    if (luaD_stack.stack[i].ttype == LUA_T_MARK)
+  for (i = (L->stack.top-1)-L->stack.stack; i>=0; i--)
+    if (L->stack.stack[i].ttype == LUA_T_MARK)
       if (level-- == 0)
-        return Ref(luaD_stack.stack+i);
+        return Ref(L->stack.stack+i);
   return LUA_NOOBJECT;
 }
 
@@ -417,7 +422,7 @@ lua_Function lua_stackedfunction (int level)
 int lua_currentline (lua_Function func)
 {
   TObject *f = Address(func);
-  return (f+1 < luaD_stack.top && (f+1)->ttype == LUA_T_LINE) ? (f+1)->value.i : -1;
+  return (f+1 < L->stack.top && (f+1)->ttype == LUA_T_LINE) ? (f+1)->value.i : -1;
 }
 
 
@@ -447,11 +452,11 @@ int lua_setlocal (lua_Function func, int local_number)
   TProtoFunc *fp = protovalue(f)->value.tf;
   char *name = luaF_getlocalname(fp, local_number, lua_currentline(func));
   checkCparams(1);
-  --luaD_stack.top;
+  --L->stack.top;
   if (name) {
     /* if "name", there must be a LUA_T_LINE */
     /* therefore, f+2 points to function base */
-    *((f+2)+(local_number-1)) = *luaD_stack.top;
+    *((f+2)+(local_number-1)) = *L->stack.top;
     return 1;
   }
   else
@@ -478,19 +483,18 @@ void lua_funcinfo (lua_Object func, char **filename, int *linedefined)
 }
 
 
-static TObject *functofind;
 static int checkfunc (TObject *o)
 {
     return (o->ttype == LUA_T_FUNCTION) &&
-           ((functofind->ttype == LUA_T_FUNCTION) ||
-            (functofind->ttype == LUA_T_MARK)) &&
-           (functofind->value.cl == o->value.cl);
+           ((L->functofind->ttype == LUA_T_FUNCTION) ||
+            (L->functofind->ttype == LUA_T_MARK)) &&
+           (L->functofind->value.cl == o->value.cl);
 }
 
 
 char *lua_getobjname (lua_Object o, char **name)
 { /* try to find a name for given function */
-  functofind = Address(o);
+  L->functofind = Address(o);
   if ((*name = luaT_travtagmethods(checkfunc)) != NULL)
     return "tag-method";
   else if ((*name = luaS_travsymbol(checkfunc)) != NULL)
@@ -504,36 +508,30 @@ char *lua_getobjname (lua_Object o, char **name)
 ** =======================================================
 */
 
-#define MAX_C_BLOCKS 10
-
-static int numCblocks = 0;
-static struct C_Lua_Stack Cblocks[MAX_C_BLOCKS];
 
 void lua_beginblock (void)
 {
-  if (numCblocks >= MAX_C_BLOCKS)
+  if (L->numCblocks >= MAX_C_BLOCKS)
     lua_error("`lua_beginblock': too many nested blocks");
-  Cblocks[numCblocks] = luaD_Cstack;
-  numCblocks++;
+  L->Cblocks[L->numCblocks] = L->Cstack;
+  L->numCblocks++;
 }
 
 void lua_endblock (void)
 {
-  --numCblocks;
-  luaD_Cstack = Cblocks[numCblocks];
-  luaD_adjusttop(luaD_Cstack.base);
+  --L->numCblocks;
+  L->Cstack = L->Cblocks[L->numCblocks];
+  luaD_adjusttop(L->Cstack.base);
 }
 
 
 
-
-
 int lua_ref (int lock)
 {
   int ref;
   checkCparams(1);
-  ref = luaC_ref(luaD_stack.top-1, lock);
-  luaD_stack.top--;
+  ref = luaC_ref(L->stack.top-1, lock);
+  L->stack.top--;
   return ref;
 }
 
@@ -546,19 +544,6 @@ lua_Object lua_getref (int ref)
 }
 
 
-void lua_open (void)
-{
-  static int firsttime = 1;
-  if (!firsttime) return;
-  firsttime = 0;
-  luaS_init();
-  luaX_init();
-  luaT_init();
-  luaD_init();
-  luaB_predefine();
-}
-
-
 
 #if LUA_COMPAT2_5
 /*
@@ -567,11 +552,11 @@ void lua_open (void)
 
 static void do_unprotectedrun (lua_CFunction f, int nParams, int nResults)
 {
-  StkId base = (luaD_stack.top-luaD_stack.stack)-nParams;
+  StkId base = (L->stack.top-L->stack.stack)-nParams;
   luaD_openstack(nParams);
-  luaD_stack.stack[base].ttype = LUA_T_CPROTO;
-  luaD_stack.stack[base].value.f = f;
-  luaF_simpleclosure(luaD_stack.stack+base);
+  L->stack.stack[base].ttype = LUA_T_CPROTO;
+  L->stack.stack[base].value.f = f;
+  luaF_simpleclosure(L->stack.stack+base);
   luaD_call(base+1, nResults);
 }
 
diff --git a/lbuiltin.c b/lbuiltin.c
index b9d81621..36432add 100644
--- a/lbuiltin.c
+++ b/lbuiltin.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lbuiltin.c,v 1.6 1997/11/04 15:27:53 roberto Exp roberto $
+** $Id: lbuiltin.c,v 1.7 1997/11/07 18:19:13 roberto Exp roberto $
 ** Built-in functions
 ** See Copyright Notice in lua.h
 */
@@ -15,6 +15,7 @@
 #include "lfunc.h"
 #include "lmem.h"
 #include "lobject.h"
+#include "lstate.h"
 #include "lstring.h"
 #include "ltable.h"
 #include "ltm.h"
@@ -51,7 +52,7 @@ static void nextvar (void)
   TObject *o = luaA_Address(luaL_nonnullarg(1));
   TaggedString *g;
   if (ttype(o) == LUA_T_NIL)
-    g = (TaggedString *)luaS_root.next;
+    g = (TaggedString *)L->rootglobal.next;
   else {
     luaL_arg_check(ttype(o) == LUA_T_STRING, 1, "variable name expected");
     g = tsvalue(o);
@@ -72,21 +73,21 @@ static void foreachvar (void)
 {
   TObject f = *luaA_Address(functionarg(1));
   GCnode *g;
-  StkId name = luaD_Cstack.base++;  /* place to keep var name (to avoid GC) */
-  ttype(luaD_stack.stack+name) = LUA_T_NIL;
-  luaD_stack.top++;
-  for (g = luaS_root.next; g; g = g->next) {
+  StkId name = L->Cstack.base++;  /* place to keep var name (to avoid GC) */
+  ttype(L->stack.stack+name) = LUA_T_NIL;
+  L->stack.top++;
+  for (g = L->rootglobal.next; g; g = g->next) {
     TaggedString *s = (TaggedString *)g;
     if (s->u.globalval.ttype != LUA_T_NIL) {
-      ttype(luaD_stack.stack+name) = LUA_T_STRING;
-      tsvalue(luaD_stack.stack+name) = s;  /* keep s on stack to avoid GC */
+      ttype(L->stack.stack+name) = LUA_T_STRING;
+      tsvalue(L->stack.stack+name) = s;  /* keep s on stack to avoid GC */
       luaA_pushobject(&f);
       pushstring(s);
       luaA_pushobject(&s->u.globalval);
-      luaD_call((luaD_stack.top-luaD_stack.stack)-2, 1);
-      if (ttype(luaD_stack.top-1) != LUA_T_NIL)
+      luaD_call((L->stack.top-L->stack.stack)-2, 1);
+      if (ttype(L->stack.top-1) != LUA_T_NIL)
         return;
-      luaD_stack.top--;
+      L->stack.top--;
     }
   }
 }
@@ -115,10 +116,10 @@ static void foreach (void)
       luaA_pushobject(&f);
       luaA_pushobject(ref(nd));
       luaA_pushobject(val(nd));
-      luaD_call((luaD_stack.top-luaD_stack.stack)-2, 1);
-      if (ttype(luaD_stack.top-1) != LUA_T_NIL)
+      luaD_call((L->stack.top-L->stack.stack)-2, 1);
+      if (ttype(L->stack.top-1) != LUA_T_NIL)
         return;
-      luaD_stack.top--;
+      L->stack.top--;
     }
   }
 }
diff --git a/ldo.c b/ldo.c
index f869f82a..94c2bf3a 100644
--- a/ldo.c
+++ b/ldo.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.c,v 1.7 1997/11/04 15:27:53 roberto Exp roberto $
+** $Id: ldo.c,v 1.8 1997/11/07 15:09:49 roberto Exp roberto $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
@@ -16,6 +16,7 @@
 #include "lmem.h"
 #include "lobject.h"
 #include "lparser.h"
+#include "lstate.h"
 #include "ltm.h"
 #include "lua.h"
 #include "luadebug.h"
@@ -30,14 +31,6 @@
 #endif
 
 
-struct Stack luaD_stack;
-
-
-struct C_Lua_Stack luaD_Cstack = {0, 0, 0};
-
-static  jmp_buf *errorJmp = NULL; /* current error recover point */
-
-
 
 /*
 ** Error messages
@@ -50,8 +43,6 @@ static void stderrorim (void)
     fprintf(stderr, "lua error: %s\n", lua_getstring(s));
 }
 
-TObject luaD_errorim;
-
 
 static void initCfunc (TObject *o, lua_CFunction f)
 {
@@ -67,24 +58,25 @@ static void initCfunc (TObject *o, lua_CFunction f)
 
 void luaD_init (void)
 {
-  luaD_stack.stack = luaM_newvector(INIT_STACK_SIZE, TObject);
-  luaD_stack.top = luaD_stack.stack;
-  luaD_stack.last = luaD_stack.stack+(INIT_STACK_SIZE-1);
-  initCfunc(&luaD_errorim, stderrorim);
+  L->stacklimit = STACK_LIMIT;
+  L->stack.stack = luaM_newvector(INIT_STACK_SIZE, TObject);
+  L->stack.top = L->stack.stack;
+  L->stack.last = L->stack.stack+(INIT_STACK_SIZE-1);
+  initCfunc(&L->errorim, stderrorim);
 }
 
 
 void luaD_checkstack (int n)
 {
-  if (luaD_stack.last-luaD_stack.top <= n) {
-    static int limit = STACK_LIMIT;
-    StkId top = luaD_stack.top-luaD_stack.stack;
-    int stacksize = (luaD_stack.last-luaD_stack.stack)+1+STACK_EXTRA+n;
-    luaD_stack.stack = luaM_reallocvector(luaD_stack.stack, stacksize,TObject);
-    luaD_stack.last = luaD_stack.stack+(stacksize-1);
-    luaD_stack.top = luaD_stack.stack + top;
-    if (stacksize >= limit) {
-      limit = stacksize+STACK_EXTRA;  /* extra space to run error handler */
+  if (L->stack.last-L->stack.top <= n) {
+    StkId top = L->stack.top-L->stack.stack;
+    int stacksize = (L->stack.last-L->stack.stack)+1+STACK_EXTRA+n;
+    L->stack.stack = luaM_reallocvector(L->stack.stack, stacksize,TObject);
+    L->stack.last = L->stack.stack+(stacksize-1);
+    L->stack.top = L->stack.stack + top;
+    if (stacksize >= L->stacklimit) {
+      /* extra space to run error handler */
+      L->stacklimit = stacksize+STACK_EXTRA;
       if (lua_stackedfunction(100) == LUA_NOOBJECT) {
         /* less than 100 functions on the stack: cannot be recursive loop */
         lua_error("Lua2C - C2Lua overflow");
@@ -101,80 +93,80 @@ void luaD_checkstack (int n)
 */
 void luaD_adjusttop (StkId newtop)
 {
-  int diff = newtop-(luaD_stack.top-luaD_stack.stack);
+  int diff = newtop-(L->stack.top-L->stack.stack);
   if (diff <= 0)
-    luaD_stack.top += diff;
+    L->stack.top += diff;
   else {
     luaD_checkstack(diff);
     while (diff--)
-      ttype(luaD_stack.top++) = LUA_T_NIL;
+      ttype(L->stack.top++) = LUA_T_NIL;
   }
 }
 
 
 /*
-** Open a hole below "nelems" from the luaD_stack.top.
+** Open a hole below "nelems" from the L->stack.top.
 */
 void luaD_openstack (int nelems)
 {
   int i;
   for (i=0; i<nelems; i++)
-    *(luaD_stack.top-i) = *(luaD_stack.top-i-1);
+    *(L->stack.top-i) = *(L->stack.top-i-1);
   incr_top;
 }
 
 
 void luaD_lineHook (int line)
 {
-  struct C_Lua_Stack oldCLS = luaD_Cstack;
-  StkId old_top = luaD_Cstack.lua2C = luaD_Cstack.base = luaD_stack.top-luaD_stack.stack;
-  luaD_Cstack.num = 0;
+  struct C_Lua_Stack oldCLS = L->Cstack;
+  StkId old_top = L->Cstack.lua2C = L->Cstack.base = L->stack.top-L->stack.stack;
+  L->Cstack.num = 0;
   (*lua_linehook)(line);
-  luaD_stack.top = luaD_stack.stack+old_top;
-  luaD_Cstack = oldCLS;
+  L->stack.top = L->stack.stack+old_top;
+  L->Cstack = oldCLS;
 }
 
 
 void luaD_callHook (StkId base, lua_Type type, int isreturn)
 {
-  struct C_Lua_Stack oldCLS = luaD_Cstack;
-  StkId old_top = luaD_Cstack.lua2C = luaD_Cstack.base = luaD_stack.top-luaD_stack.stack;
-  luaD_Cstack.num = 0;
+  struct C_Lua_Stack oldCLS = L->Cstack;
+  StkId old_top = L->Cstack.lua2C = L->Cstack.base = L->stack.top-L->stack.stack;
+  L->Cstack.num = 0;
   if (isreturn)
     (*lua_callhook)(LUA_NOOBJECT, "(return)", 0);
   else {
-    TObject *f = luaD_stack.stack+base-1;
+    TObject *f = L->stack.stack+base-1;
     if (type == LUA_T_PROTO)
       (*lua_callhook)(Ref(f), tfvalue(protovalue(f))->fileName->str,
                               tfvalue(protovalue(f))->lineDefined);
     else
       (*lua_callhook)(Ref(f), "(C)", -1);
   }
-  luaD_stack.top = luaD_stack.stack+old_top;
-  luaD_Cstack = oldCLS;
+  L->stack.top = L->stack.stack+old_top;
+  L->Cstack = oldCLS;
 }
 
 
 /*
-** Call a C function. luaD_Cstack.base will point to the top of the stack,
-** and luaD_Cstack.num is the number of parameters. Returns an index
+** Call a C function. L->Cstack.base will point to the top of the stack,
+** and L->Cstack.num is the number of parameters. Returns an index
 ** to the first result from C.
 */
 static StkId callC (lua_CFunction func, StkId base)
 {
-  struct C_Lua_Stack oldCLS = luaD_Cstack;
+  struct C_Lua_Stack oldCLS = L->Cstack;
   StkId firstResult;
-  luaD_Cstack.num = (luaD_stack.top-luaD_stack.stack) - base;
-  /* incorporate parameters on the luaD_stack.stack */
-  luaD_Cstack.lua2C = base;
-  luaD_Cstack.base = base+luaD_Cstack.num;  /* == top-stack */
+  L->Cstack.num = (L->stack.top-L->stack.stack) - base;
+  /* incorporate parameters on the L->stack.stack */
+  L->Cstack.lua2C = base;
+  L->Cstack.base = base+L->Cstack.num;  /* == top-stack */
   if (lua_callhook)
     luaD_callHook(base, LUA_T_CPROTO, 0);
   (*func)();
   if (lua_callhook)  /* func may have changed lua_callhook */
     luaD_callHook(base, LUA_T_CPROTO, 1);
-  firstResult = luaD_Cstack.base;
-  luaD_Cstack = oldCLS;
+  firstResult = L->Cstack.base;
+  L->Cstack = oldCLS;
   return firstResult;
 }
 
@@ -182,21 +174,21 @@ static StkId callC (lua_CFunction func, StkId base)
 void luaD_callTM (TObject *f, int nParams, int nResults)
 {
   luaD_openstack(nParams);
-  *(luaD_stack.top-nParams-1) = *f;
-  luaD_call((luaD_stack.top-luaD_stack.stack)-nParams, nResults);
+  *(L->stack.top-nParams-1) = *f;
+  luaD_call((L->stack.top-L->stack.stack)-nParams, nResults);
 }
 
 
 /*
-** Call a function (C or Lua). The parameters must be on the luaD_stack.stack,
-** between [luaD_stack.stack+base,luaD_stack.top). The function to be called is at luaD_stack.stack+base-1.
-** When returns, the results are on the luaD_stack.stack, between [luaD_stack.stack+base-1,luaD_stack.top).
+** Call a function (C or Lua). The parameters must be on the L->stack.stack,
+** between [L->stack.stack+base,L->stack.top). The function to be called is at L->stack.stack+base-1.
+** When returns, the results are on the L->stack.stack, between [L->stack.stack+base-1,L->stack.top).
 ** The number of results is nResults, unless nResults=MULT_RET.
 */
 void luaD_call (StkId base, int nResults)
 {
   StkId firstResult;
-  TObject *func = luaD_stack.stack+base-1;
+  TObject *func = L->stack.stack+base-1;
   int i;
   if (ttype(func) == LUA_T_FUNCTION) {
     TObject *proto = protovalue(func);
@@ -209,7 +201,7 @@ void luaD_call (StkId base, int nResults)
     TObject *im = luaT_getimbyObj(func, IM_FUNCTION);
     if (ttype(im) == LUA_T_NIL)
       lua_error("call expression not a function");
-    luaD_callTM(im, (luaD_stack.top-luaD_stack.stack)-(base-1), nResults);
+    luaD_callTM(im, (L->stack.top-L->stack.stack)-(base-1), nResults);
     return;
   }
   /* adjust the number of results */
@@ -217,29 +209,29 @@ void luaD_call (StkId base, int nResults)
     luaD_adjusttop(firstResult+nResults);
   /* move results to base-1 (to erase parameters and function) */
   base--;
-  nResults = luaD_stack.top - (luaD_stack.stack+firstResult);  /* actual number of results */
+  nResults = L->stack.top - (L->stack.stack+firstResult);  /* actual number of results */
   for (i=0; i<nResults; i++)
-    *(luaD_stack.stack+base+i) = *(luaD_stack.stack+firstResult+i);
-  luaD_stack.top -= firstResult-base;
+    *(L->stack.stack+base+i) = *(L->stack.stack+firstResult+i);
+  L->stack.top -= firstResult-base;
 }
 
 
 
 /*
-** Traverse all objects on luaD_stack.stack
+** Traverse all objects on L->stack.stack
 */
 void luaD_travstack (int (*fn)(TObject *))
 {
   StkId i;
-  for (i = (luaD_stack.top-1)-luaD_stack.stack; i>=0; i--)
-    fn (luaD_stack.stack+i);
+  for (i = (L->stack.top-1)-L->stack.stack; i>=0; i--)
+    fn (L->stack.stack+i);
 }
 
 
 
 static void message (char *s)
 {
-  TObject im = luaD_errorim;
+  TObject im = L->errorim;
   if (ttype(&im) != LUA_T_NIL) {
     lua_pushstring(s);
     luaD_callTM(&im, 1, 0);
@@ -252,8 +244,8 @@ static void message (char *s)
 void lua_error (char *s)
 {
   if (s) message(s);
-  if (errorJmp)
-    longjmp(*errorJmp, 1);
+  if (L->errorJmp)
+    longjmp(*((jmp_buf *)L->errorJmp), 1);
   else {
     fprintf (stderr, "lua: exit(1). Unable to recover\n");
     exit(1);
@@ -261,40 +253,40 @@ void lua_error (char *s)
 }
 
 /*
-** Call the function at luaD_Cstack.base, and incorporate results on
+** Call the function at L->Cstack.base, and incorporate results on
 ** the Lua2C structure.
 */
 static void do_callinc (int nResults)
 {
-  StkId base = luaD_Cstack.base;
+  StkId base = L->Cstack.base;
   luaD_call(base+1, nResults);
-  luaD_Cstack.lua2C = base;  /* position of the luaM_new results */
-  luaD_Cstack.num = (luaD_stack.top-luaD_stack.stack) - base;  /* number of results */
-  luaD_Cstack.base = base + luaD_Cstack.num;  /* incorporate results on luaD_stack.stack */
+  L->Cstack.lua2C = base;  /* position of the luaM_new results */
+  L->Cstack.num = (L->stack.top-L->stack.stack) - base;  /* number of results */
+  L->Cstack.base = base + L->Cstack.num;  /* incorporate results on L->stack.stack */
 }
 
 
 /*
-** Execute a protected call. Assumes that function is at luaD_Cstack.base and
+** Execute a protected call. Assumes that function is at L->Cstack.base and
 ** parameters are on top of it. Leave nResults on the stack.
 */
 int luaD_protectedrun (int nResults)
 {
   jmp_buf myErrorJmp;
   int status;
-  struct C_Lua_Stack oldCLS = luaD_Cstack;
-  jmp_buf *oldErr = errorJmp;
-  errorJmp = &myErrorJmp;
+  struct C_Lua_Stack oldCLS = L->Cstack;
+  jmp_buf *oldErr = L->errorJmp;
+  L->errorJmp = &myErrorJmp;
   if (setjmp(myErrorJmp) == 0) {
     do_callinc(nResults);
     status = 0;
   }
-  else { /* an error occurred: restore luaD_Cstack and luaD_stack.top */
-    luaD_Cstack = oldCLS;
-    luaD_stack.top = luaD_stack.stack+luaD_Cstack.base;
+  else { /* an error occurred: restore L->Cstack and L->stack.top */
+    L->Cstack = oldCLS;
+    L->stack.top = L->stack.stack+L->Cstack.base;
     status = 1;
   }
-  errorJmp = oldErr;
+  L->errorJmp = oldErr;
   return status;
 }
 
@@ -307,8 +299,8 @@ static int protectedparser (ZIO *z, char *chunkname, int bin)
   int status;
   TProtoFunc *tf;
   jmp_buf myErrorJmp;
-  jmp_buf *oldErr = errorJmp;
-  errorJmp = &myErrorJmp;
+  jmp_buf *oldErr = L->errorJmp;
+  L->errorJmp = &myErrorJmp;
   if (setjmp(myErrorJmp) == 0) {
     tf = bin ? luaU_undump1(z, chunkname) : luaY_parser(z, chunkname);
     status = 0;
@@ -317,12 +309,12 @@ static int protectedparser (ZIO *z, char *chunkname, int bin)
     tf = NULL;
     status = 1;
   }
-  errorJmp = oldErr;
+  L->errorJmp = oldErr;
   if (status) return 1;  /* error code */
   if (tf == NULL) return 2;  /* 'natural' end */
-  luaD_adjusttop(luaD_Cstack.base+1);  /* one slot for the pseudo-function */
-  luaD_stack.stack[luaD_Cstack.base].ttype = LUA_T_PROTO;
-  luaD_stack.stack[luaD_Cstack.base].value.tf = tf;
+  luaD_adjusttop(L->Cstack.base+1);  /* one slot for the pseudo-function */
+  L->stack.stack[L->Cstack.base].ttype = LUA_T_PROTO;
+  L->stack.stack[L->Cstack.base].value.tf = tf;
   luaV_closure(0);
   return 0;
 }
@@ -332,15 +324,15 @@ static int do_main (ZIO *z, char *chunkname, int bin)
 {
   int status;
   do {
-    long old_blocks = (luaC_checkGC(), luaO_nblocks);
+    long old_blocks = (luaC_checkGC(), L->nblocks);
     status = protectedparser(z, chunkname, bin);
     if (status == 1) return 1;  /* error */
     else if (status == 2) return 0;  /* 'natural' end */
     else {
-      unsigned long newelems2 = 2*(luaO_nblocks-old_blocks);
-      luaC_threshold += newelems2;
+      unsigned long newelems2 = 2*(L->nblocks-old_blocks);
+      L->GCthreshold += newelems2;
       status = luaD_protectedrun(MULT_RET);
-      luaC_threshold -= newelems2;
+      L->GCthreshold -= newelems2;
     }
   } while (bin && status == 0);
   return status;
@@ -351,7 +343,7 @@ void luaD_gcIM (TObject *o)
 {
   TObject *im = luaT_getimbyObj(o, IM_GC);
   if (ttype(im) != LUA_T_NIL) {
-    *luaD_stack.top = *o;
+    *L->stack.top = *o;
     incr_top;
     luaD_callTM(im, 1, 0);
   }
diff --git a/ldo.h b/ldo.h
index baa268eb..3b381c01 100644
--- a/ldo.h
+++ b/ldo.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.h,v 1.1 1997/09/16 19:25:59 roberto Exp roberto $
+** $Id: ldo.h,v 1.2 1997/11/04 15:27:53 roberto Exp roberto $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
@@ -9,43 +9,25 @@
 
 
 #include "lobject.h"
+#include "lstate.h"
 
 
-typedef int StkId;  /* index to luaD_stack.stack elements */
-
 #define MULT_RET        255
 
 
-extern struct Stack {
-  TObject *last;
-  TObject *stack;
-  TObject *top;
-} luaD_stack;
-
-
-extern struct C_Lua_Stack {
-  StkId base;  /* when Lua calls C or C calls Lua, points to */
-               /* the first slot after the last parameter. */
-  StkId lua2C; /* points to first element of "array" lua2C */
-  int num;     /* size of "array" lua2C */
-} luaD_Cstack;
-
-
-extern TObject luaD_errorim;
-
 
 /*
 ** macro to increment stack top.
-** There must be always an empty slot at the luaD_stack.top
+** There must be always an empty slot at the L->stack.top
 */
-#define incr_top { if (luaD_stack.top >= luaD_stack.last) luaD_checkstack(1); \
-                   luaD_stack.top++; }
+#define incr_top { if (L->stack.top >= L->stack.last) luaD_checkstack(1); \
+                   L->stack.top++; }
 
 
 /* macros to convert from lua_Object to (TObject *) and back */
 
-#define Address(lo)     ((lo)+luaD_stack.stack-1)
-#define Ref(st)         ((st)-luaD_stack.stack+1)
+#define Address(lo)     ((lo)+L->stack.stack-1)
+#define Ref(st)         ((st)-L->stack.stack+1)
 
 
 void luaD_init (void);
diff --git a/lfunc.c b/lfunc.c
index 7270e980..2ab76335 100644
--- a/lfunc.c
+++ b/lfunc.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.c,v 1.4 1997/10/23 16:26:37 roberto Exp roberto $
+** $Id: lfunc.c,v 1.5 1997/10/24 17:17:24 roberto Exp roberto $
 ** Lua Funcion auxiliar
 ** See Copyright Notice in lua.h
 */
@@ -9,20 +9,18 @@
 
 #include "lfunc.h"
 #include "lmem.h"
+#include "lstate.h"
 
 #define gcsizeproto(p)	5
 #define gcsizeclosure(c) 1
 
-GCnode luaF_root = {NULL, 0};
-GCnode luaF_rootcl = {NULL, 0};
-
 
 
 Closure *luaF_newclosure (int nelems)
 {
   Closure *c = (Closure *)luaM_malloc(sizeof(Closure)+nelems*sizeof(TObject));
-  luaO_insertlist(&luaF_rootcl, (GCnode *)c);
-  luaO_nblocks += gcsizeclosure(c);
+  luaO_insertlist(&(L->rootcl), (GCnode *)c);
+  L->nblocks += gcsizeclosure(c);
   c->nelems = nelems;
   return c;
 }
@@ -46,8 +44,8 @@ TProtoFunc *luaF_newproto (void)
   f->consts = NULL;
   f->nconsts = 0;
   f->locvars = NULL;
-  luaO_insertlist(&luaF_root, (GCnode *)f);
-  luaO_nblocks += gcsizeproto(f);
+  luaO_insertlist(&(L->rootproto), (GCnode *)f);
+  L->nblocks += gcsizeproto(f);
   return f;
 }
 
@@ -66,7 +64,7 @@ void luaF_freeproto (TProtoFunc *l)
 {
   while (l) {
     TProtoFunc *next = (TProtoFunc *)l->head.next;
-    luaO_nblocks -= gcsizeproto(l);
+    L->nblocks -= gcsizeproto(l);
     freefunc(l);
     l = next;
   }
@@ -77,7 +75,7 @@ void luaF_freeclosure (Closure *l)
 {
   while (l) {
     Closure *next = (Closure *)l->head.next;
-    luaO_nblocks -= gcsizeclosure(l);
+    L->nblocks -= gcsizeclosure(l);
     luaM_free(l);
     l = next;
   }
diff --git a/lfunc.h b/lfunc.h
index b6e14e26..72fcafad 100644
--- a/lfunc.h
+++ b/lfunc.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.h,v 1.2 1997/09/26 16:46:20 roberto Exp roberto $
+** $Id: lfunc.h,v 1.3 1997/10/24 17:17:24 roberto Exp roberto $
 ** Lua Function structures
 ** See Copyright Notice in lua.h
 */
@@ -11,9 +11,6 @@
 #include "lobject.h"
 
 
-extern GCnode luaF_root;
-extern GCnode luaF_rootcl;
-
 
 TProtoFunc *luaF_newproto (void);
 Closure *luaF_newclosure (int nelems);
diff --git a/lgc.c b/lgc.c
index 6fdbacaa..c3225deb 100644
--- a/lgc.c
+++ b/lgc.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lgc.c,v 1.6 1997/10/24 17:17:24 roberto Exp roberto $
+** $Id: lgc.c,v 1.7 1997/11/03 20:45:23 roberto Exp roberto $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
@@ -10,6 +10,7 @@
 #include "lgc.h"
 #include "lmem.h"
 #include "lobject.h"
+#include "lstate.h"
 #include "lstring.h"
 #include "ltable.h"
 #include "ltm.h"
@@ -27,12 +28,6 @@ static int markobject (TObject *o);
 ** =======================================================
 */
 
-static struct ref {
-  TObject o;
-  enum {LOCK, HOLD, FREE, COLLECTED} status;
-} *refArray = NULL;
-static int refSize = 0;
-
 
 int luaC_ref (TObject *o, int lock)
 {
@@ -40,18 +35,19 @@ int luaC_ref (TObject *o, int lock)
   if (ttype(o) == LUA_T_NIL)
     ref = -1;   /* special ref for nil */
   else {
-    for (ref=0; ref<refSize; ref++)
-      if (refArray[ref].status == FREE)
+    for (ref=0; ref<L->refSize; ref++)
+      if (L->refArray[ref].status == FREE)
         goto found;
     /* no more empty spaces */ {
-      int oldSize = refSize;
-      refSize = luaM_growvector(&refArray, refSize, struct ref, refEM, MAX_WORD);
-      for (ref=oldSize; ref<refSize; ref++)
-        refArray[ref].status = FREE;
+      int oldSize = L->refSize;
+      L->refSize = luaM_growvector(&L->refArray, L->refSize, struct ref,
+                                   refEM, MAX_WORD);
+      for (ref=oldSize; ref<L->refSize; ref++)
+        L->refArray[ref].status = FREE;
       ref = oldSize;
     } found:
-    refArray[ref].o = *o;
-    refArray[ref].status = lock ? LOCK : HOLD;
+    L->refArray[ref].o = *o;
+    L->refArray[ref].status = lock ? LOCK : HOLD;
   }
   return ref;
 }
@@ -59,8 +55,8 @@ int luaC_ref (TObject *o, int lock)
 
 void lua_unref (int ref)
 {
-  if (ref >= 0 && ref < refSize)
-    refArray[ref].status = FREE;
+  if (ref >= 0 && ref < L->refSize)
+    L->refArray[ref].status = FREE;
 }
 
 
@@ -68,9 +64,9 @@ TObject* luaC_getref (int ref)
 {
   if (ref == -1)
     return &luaO_nilobject;
-  if (ref >= 0 && ref < refSize &&
-      (refArray[ref].status == LOCK || refArray[ref].status == HOLD))
-    return &refArray[ref].o;
+  if (ref >= 0 && ref < L->refSize &&
+      (L->refArray[ref].status == LOCK || L->refArray[ref].status == HOLD))
+    return &L->refArray[ref].o;
   else
     return NULL;
 }
@@ -79,9 +75,9 @@ TObject* luaC_getref (int ref)
 static void travlock (void)
 {
   int i;
-  for (i=0; i<refSize; i++)
-    if (refArray[i].status == LOCK)
-      markobject(&refArray[i].o);
+  for (i=0; i<L->refSize; i++)
+    if (L->refArray[i].status == LOCK)
+      markobject(&L->refArray[i].o);
 }
 
 
@@ -105,9 +101,9 @@ static int ismarked (TObject *o)
 static void invalidaterefs (void)
 {
   int i;
-  for (i=0; i<refSize; i++)
-    if (refArray[i].status == HOLD && !ismarked(&refArray[i].o))
-      refArray[i].status = COLLECTED;
+  for (i=0; i<L->refSize; i++)
+    if (L->refArray[i].status == HOLD && !ismarked(&L->refArray[i].o))
+      L->refArray[i].status = COLLECTED;
 }
 
 
@@ -210,7 +206,7 @@ static void hashmark (Hash *h)
 static void globalmark (void)
 {
   TaggedString *g;
-  for (g=(TaggedString *)luaS_root.next; g; g=(TaggedString *)g->head.next)
+  for (g=(TaggedString *)L->rootglobal.next; g; g=(TaggedString *)g->head.next)
     if (g->u.globalval.ttype != LUA_T_NIL) {
       markobject(&g->u.globalval);
       strmark(g);  /* cannot collect non nil global variables */
@@ -240,23 +236,19 @@ static int markobject (TObject *o)
 
 
 
-#define GARBAGE_BLOCK 150
-
-unsigned long luaC_threshold = GARBAGE_BLOCK;
-
-
 static void markall (void)
 {
   luaD_travstack(markobject); /* mark stack objects */
   globalmark();  /* mark global variable values and names */
   travlock(); /* mark locked objects */
+  markobject(&L->globalbag);  /* mark elements in global bag */
   luaT_travtagmethods(markobject);  /* mark fallbacks */
 }
 
 
 long lua_collectgarbage (long limit)
 {
-  unsigned long recovered = luaO_nblocks;  /* to subtract nblocks after gc */
+  unsigned long recovered = L->nblocks;  /* to subtract nblocks after gc */
   Hash *freetable;
   TaggedString *freestr;
   TProtoFunc *freefunc;
@@ -264,10 +256,10 @@ long lua_collectgarbage (long limit)
   markall();
   invalidaterefs();
   freestr = luaS_collector();
-  freetable = (Hash *)listcollect(&luaH_root);
-  freefunc = (TProtoFunc *)listcollect(&luaF_root);
-  freeclos = (Closure *)listcollect(&luaF_rootcl);
-  luaC_threshold *= 4;  /* to avoid GC during GC */
+  freetable = (Hash *)listcollect(&(L->roottable));
+  freefunc = (TProtoFunc *)listcollect(&(L->rootproto));
+  freeclos = (Closure *)listcollect(&(L->rootcl));
+  L->GCthreshold *= 4;  /* to avoid GC during GC */
   hashcallIM(freetable);  /* GC tag methods for tables */
   strcallIM(freestr);  /* GC tag methods for userdata */
   luaD_gcIM(&luaO_nilobject);  /* GC tag method for nil (signal end of GC) */
@@ -276,16 +268,16 @@ long lua_collectgarbage (long limit)
   luaF_freeproto(freefunc);
   luaF_freeclosure(freeclos);
   luaM_clearbuffer();
-  recovered = recovered-luaO_nblocks;
-/*printf("==total %ld  coletados %ld\n", luaO_nblocks+recovered, recovered);*/
-  luaC_threshold = (limit == 0) ? 2*luaO_nblocks : luaO_nblocks+limit;
+  recovered = recovered-L->nblocks;
+/*printf("==total %ld  coletados %ld\n", L->nblocks+recovered, recovered);*/
+  L->GCthreshold = (limit == 0) ? 2*L->nblocks : L->nblocks+limit;
   return recovered;
 }
 
 
 void luaC_checkGC (void)
 {
-  if (luaO_nblocks >= luaC_threshold)
+  if (L->nblocks >= L->GCthreshold)
     lua_collectgarbage(0);
 }
 
diff --git a/lgc.h b/lgc.h
index ea669aa2..a7a9a77a 100644
--- a/lgc.h
+++ b/lgc.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lgc.h,v 1.1 1997/09/16 19:25:59 roberto Exp roberto $
+** $Id: lgc.h,v 1.2 1997/10/23 16:26:37 roberto Exp roberto $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
@@ -11,8 +11,6 @@
 #include "lobject.h"
 
 
-extern unsigned long luaC_threshold;
-
 void luaC_checkGC (void);
 TObject* luaC_getref (int ref);
 int luaC_ref (TObject *o, int lock);
diff --git a/liolib.c b/liolib.c
index a0464671..ffa5b16c 100644
--- a/liolib.c
+++ b/liolib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: liolib.c,v 1.3 1997/10/30 20:29:09 roberto Exp roberto $
+** $Id: liolib.c,v 1.4 1997/11/04 15:27:53 roberto Exp roberto $
 ** Standard I/O (and system) library
 ** See Copyright Notice in lua.h
 */
@@ -41,8 +41,21 @@ int pclose();
 #endif
 
 
-int lua_tagio;
-static int closedtag;
+static void createtag (char *t)
+{
+  lua_pushobject(lua_globalbag());
+  lua_pushstring(t);
+  lua_pushnumber(lua_newtag());
+  lua_settable();
+}
+
+
+static int gettag (char *t)
+{
+  lua_pushobject(lua_globalbag());
+  lua_pushstring(t);
+  return lua_getnumber(lua_gettable());
+}
 
 
 static void pushresult (int i)
@@ -59,9 +72,9 @@ static void pushresult (int i)
 static int ishandler (lua_Object f)
 {
   if (lua_isuserdata(f)) {
-    if (lua_tag(f) == closedtag)
+    if (lua_tag(f) == gettag("closedtag"))
       lua_error("trying to access a closed file");
-    return lua_tag(f) == lua_tagio;
+    return lua_tag(f) == gettag("tagio");
   }
   else return 0;
 }
@@ -94,13 +107,13 @@ static void closefile (char *name)
   if (pclose(f) == -1)
     fclose(f);
   lua_pushobject(lua_getglobal(name));
-  lua_settag(closedtag);
+  lua_settag(gettag("closedtag"));
 }
 
 
 static void setfile (FILE *f, char *name)
 {
-  lua_pushusertag(f, lua_tagio);
+  lua_pushusertag(f, gettag("tagio"));
   lua_setglobal(name);
 }
 
@@ -108,7 +121,7 @@ static void setfile (FILE *f, char *name)
 static void setreturn (FILE *f, char *name)
 {
   setfile(f, name);
-  lua_pushusertag(f, lua_tagio);
+  lua_pushusertag(f, gettag("tagio"));
 }
 
 
@@ -120,7 +133,7 @@ static void io_readfrom (void)
     closefile("_INPUT");
     current = stdin;
   }
-  else if (lua_tag(f) == lua_tagio)
+  else if (lua_tag(f) == gettag("tagio"))
     current = lua_getuserdata(f);
   else {
     char *s = luaL_check_string(1);
@@ -142,7 +155,7 @@ static void io_writeto (void)
     closefile("_OUTPUT");
     current = stdout;
   }
-  else if (lua_tag(f) == lua_tagio)
+  else if (lua_tag(f) == gettag("tagio"))
     current = lua_getuserdata(f);
   else {
     char *s = luaL_check_string(1);
@@ -373,8 +386,8 @@ static struct luaL_reg iolib[] = {
 void lua_iolibopen (void)
 {
   luaL_openlib(iolib, (sizeof(iolib)/sizeof(iolib[0])));
-  lua_tagio = lua_newtag();
-  closedtag = lua_newtag();
+  createtag("iotag");
+  createtag("closedtag");
   setfile(stdin, "_INPUT");
   setfile(stdout, "_OUTPUT");
   setfile(stdin, "_STDIN");
diff --git a/llex.c b/llex.c
index 5b800011..38e72c5d 100644
--- a/llex.c
+++ b/llex.c
@@ -1,5 +1,5 @@
 /*
-** $Id: llex.c,v 1.4 1997/11/04 15:27:53 roberto Exp roberto $
+** $Id: llex.c,v 1.5 1997/11/07 15:09:49 roberto Exp roberto $
 ** Lexical Analizer
 ** See Copyright Notice in lua.h
 */
@@ -12,35 +12,32 @@
 #include "lmem.h"
 #include "lobject.h"
 #include "lparser.h"
+#include "lstate.h"
 #include "lstring.h"
 #include "lstx.h"
 #include "luadebug.h"
 #include "lzio.h"
 
 
-static int current;  /* look ahead character */
-static ZIO *lex_z;
 
-
-int luaX_linenumber;
 int lua_debug=0;
 
 
-#define next() (current = zgetc(lex_z))
+#define next(LL) (LL->current = zgetc(LL->lex_z))
 
 
+static struct {
+  char *name;
+  int token;
+} reserved [] = {
+    {"and", AND}, {"do", DO}, {"else", ELSE}, {"elseif", ELSEIF},
+    {"end", END}, {"function", FUNCTION}, {"if", IF}, {"local", LOCAL},
+    {"nil", NIL}, {"not", NOT}, {"or", OR}, {"repeat", REPEAT},
+    {"return", RETURN}, {"then", THEN}, {"until", UNTIL}, {"while", WHILE}
+};
 
 void luaX_init (void)
 {
-  static struct {
-    char *name;
-    int token;
-  } reserved [] = {
-      {"and", AND}, {"do", DO}, {"else", ELSE}, {"elseif", ELSEIF},
-      {"end", END}, {"function", FUNCTION}, {"if", IF}, {"local", LOCAL},
-      {"nil", NIL}, {"not", NOT}, {"or", OR}, {"repeat", REPEAT},
-      {"return", RETURN}, {"then", THEN}, {"until", UNTIL}, {"while", WHILE}
-    };
   int i;
   for (i=0; i<(sizeof(reserved)/sizeof(reserved[0])); i++) {
     TaggedString *ts = luaS_new(reserved[i].name);
@@ -49,47 +46,29 @@ void luaX_init (void)
 }
 
 
-
-#define MAX_IFS	5
-
-/* "ifstate" keeps the state of each nested $if the lexical is dealing with. */
-
-static struct {
-  int elsepart;  /* true if its in the $else part */
-  int condition;  /* true if $if condition is true */
-  int skip;  /* true if part must be skiped */
-} ifstate[MAX_IFS];
-
-static int iflevel;  /* level of nested $if's */
-
-
-static struct textbuff {
-  char *text;
-  int tokensize;
-  int buffsize;
-} textbuff;
-
-
-static void firstline (void)
+static void firstline (LexState *LL)
 {
-  int c = zgetc(lex_z);
+  int c = zgetc(LL->lex_z);
   if (c == '#')
-    while((c=zgetc(lex_z)) != '\n' && c != EOZ) /* skip first line */;
-  zungetc(lex_z);
+    while((c=zgetc(LL->lex_z)) != '\n' && c != EOZ) /* skip first line */;
+  zungetc(LL->lex_z);
 }
 
 
 void luaX_setinput (ZIO *z)
 {
-  current = '\n';
-  luaX_linenumber = 0;
-  iflevel = 0;
-  ifstate[0].skip = 0;
-  ifstate[0].elsepart = 1;  /* to avoid a free $else */
-  lex_z = z;
-  firstline();
-  textbuff.buffsize = 20;
-  textbuff.text = luaM_buffer(textbuff.buffsize);
+  LexState *LL = L->lexstate;
+  LL->current = '\n';
+  LL->linelasttoken = 0;
+  LL->lastline = 0;
+  LL->linenumber = 0;
+  LL->iflevel = 0;
+  LL->ifstate[0].skip = 0;
+  LL->ifstate[0].elsepart = 1;  /* to avoid a free $else */
+  LL->lex_z = z;
+  firstline(LL);
+  LL->textbuff.buffsize = 20;
+  LL->textbuff.text = luaM_buffer(LL->textbuff.buffsize);
 }
 
 
@@ -102,9 +81,9 @@ void luaX_setinput (ZIO *z)
 
 #define PRAGMASIZE	20
 
-static void skipspace (void)
+static void skipspace (LexState *LL)
 {
-  while (current == ' ' || current == '\t') next();
+  while (LL->current == ' ' || LL->current == '\t') next(LL);
 }
 
 
@@ -122,49 +101,49 @@ static int checkcond (char *buff)
 }
 
 
-static void readname (char *buff)
+static void readname (LexState *LL, char *buff)
 {
   int i = 0;
-  skipspace();
-  while (isalnum(current) || current == '_') {
+  skipspace(LL);
+  while (isalnum(LL->current) || LL->current == '_') {
     if (i >= PRAGMASIZE) {
       buff[PRAGMASIZE] = 0;
       luaY_syntaxerror("pragma too long", buff);
     }
-    buff[i++] = current;
-    next();
+    buff[i++] = LL->current;
+    next(LL);
   }
   buff[i] = 0;
 }
 
 
-static void inclinenumber (void);
+static void inclinenumber (LexState *LL);
 
 
-static void ifskip (void)
+static void ifskip (LexState *LL)
 {
-  while (ifstate[iflevel].skip) {
-    if (current == '\n')
-      inclinenumber();
-    else if (current == EOZ)
+  while (LL->ifstate[LL->iflevel].skip) {
+    if (LL->current == '\n')
+      inclinenumber(LL);
+    else if (LL->current == EOZ)
       luaY_syntaxerror("input ends inside a $if", "");
-    else next();
+    else next(LL);
   }
 }
 
 
-static void inclinenumber (void)
+static void inclinenumber (LexState *LL)
 {
   static char *pragmas [] =
     {"debug", "nodebug", "endinput", "end", "ifnot", "if", "else", NULL};
-  next();  /* skip '\n' */
-  ++luaX_linenumber;
-  if (current == '$') {  /* is a pragma? */
+  next(LL);  /* skip '\n' */
+  ++LL->linenumber;
+  if (LL->current == '$') {  /* is a pragma? */
     char buff[PRAGMASIZE+1];
     int ifnot = 0;
-    int skip = ifstate[iflevel].skip;
-    next();  /* skip $ */
-    readname(buff);
+    int skip = LL->ifstate[LL->iflevel].skip;
+    next(LL);  /* skip $ */
+    readname(LL, buff);
     switch (luaO_findstring(buff, pragmas)) {
       case 0:  /* debug */
         if (!skip) lua_debug = 1;
@@ -174,42 +153,42 @@ static void inclinenumber (void)
         break;
       case 2:  /* endinput */
         if (!skip) {
-          current = EOZ;
-          iflevel = 0;  /* to allow $endinput inside a $if */
+          LL->current = EOZ;
+          LL->iflevel = 0;  /* to allow $endinput inside a $if */
         }
         break;
       case 3:  /* end */
-        if (iflevel-- == 0)
+        if (LL->iflevel-- == 0)
           luaY_syntaxerror("unmatched $end", "$end");
         break;
       case 4:  /* ifnot */
         ifnot = 1;
         /* go through */
       case 5:  /* if */
-        if (iflevel == MAX_IFS-1)
+        if (LL->iflevel == MAX_IFS-1)
           luaY_syntaxerror("too many nested `$ifs'", "$if");
-        readname(buff);
-        iflevel++;
-        ifstate[iflevel].elsepart = 0;
-        ifstate[iflevel].condition = checkcond(buff) ? !ifnot : ifnot;
-        ifstate[iflevel].skip = skip || !ifstate[iflevel].condition;
+        readname(LL, buff);
+        LL->iflevel++;
+        LL->ifstate[LL->iflevel].elsepart = 0;
+        LL->ifstate[LL->iflevel].condition = checkcond(buff) ? !ifnot : ifnot;
+        LL->ifstate[LL->iflevel].skip = skip || !LL->ifstate[LL->iflevel].condition;
         break;
       case 6:  /* else */
-        if (ifstate[iflevel].elsepart)
+        if (LL->ifstate[LL->iflevel].elsepart)
           luaY_syntaxerror("unmatched $else", "$else");
-        ifstate[iflevel].elsepart = 1;
-        ifstate[iflevel].skip =
-                    ifstate[iflevel-1].skip || ifstate[iflevel].condition;
+        LL->ifstate[LL->iflevel].elsepart = 1;
+        LL->ifstate[LL->iflevel].skip = LL->ifstate[LL->iflevel-1].skip ||
+                                      LL->ifstate[LL->iflevel].condition;
         break;
       default:
         luaY_syntaxerror("invalid pragma", buff);
     }
-    skipspace();
-    if (current == '\n')  /* pragma must end with a '\n' ... */
-      inclinenumber();
-    else if (current != EOZ)  /* or eof */
+    skipspace(LL);
+    if (LL->current == '\n')  /* pragma must end with a '\n' ... */
+      inclinenumber(LL);
+    else if (LL->current != EOZ)  /* or eof */
       luaY_syntaxerror("invalid pragma format", buff);
-    ifskip();
+    ifskip(LL);
   }
 }
 
@@ -222,162 +201,167 @@ static void inclinenumber (void)
 
 
 
-static void save (int c)
+static void save (LexState *LL, int c)
 {
-  if (textbuff.tokensize >= textbuff.buffsize)
-    textbuff.text = luaM_buffer(textbuff.buffsize *= 2);
-  textbuff.text[textbuff.tokensize++] = c;
+  if (LL->textbuff.tokensize >= LL->textbuff.buffsize)
+    LL->textbuff.text = luaM_buffer(LL->textbuff.buffsize *= 2);
+  LL->textbuff.text[LL->textbuff.tokensize++] = c;
 }
 
 
 char *luaX_lasttoken (void)
 {
-  save(0);
-  return textbuff.text;
+  save(L->lexstate, 0);
+  return L->lexstate->textbuff.text;
 }
 
 
-#define save_and_next()  (save(current), next())
+#define save_and_next(LL)  (save(LL, LL->current), next(LL))
 
 
-static int read_long_string (void)
+static int read_long_string (LexState *LL, YYSTYPE *l)
 {
   int cont = 0;
   while (1) {
-    switch (current) {
+    switch (LL->current) {
       case EOZ:
-        save(0);
+        save(LL, 0);
         return WRONGTOKEN;
       case '[':
-        save_and_next();
-        if (current == '[') {
+        save_and_next(LL);
+        if (LL->current == '[') {
           cont++;
-          save_and_next();
+          save_and_next(LL);
         }
         continue;
       case ']':
-        save_and_next();
-        if (current == ']') {
+        save_and_next(LL);
+        if (LL->current == ']') {
           if (cont == 0) goto endloop;
           cont--;
-          save_and_next();
+          save_and_next(LL);
         }
         continue;
       case '\n':
-        save('\n');
-        inclinenumber();
+        save(LL, '\n');
+        inclinenumber(LL);
         continue;
       default:
-        save_and_next();
+        save_and_next(LL);
     }
   } endloop:
-  save_and_next();  /* pass the second ']' */
-  textbuff.text[textbuff.tokensize-2] = 0;  /* erases ']]' */
-  luaY_lval.pTStr = luaS_new(textbuff.text+2);
-  textbuff.text[textbuff.tokensize-2] = ']';  /* restores ']]' */
+  save_and_next(LL);  /* pass the second ']' */
+  LL->textbuff.text[LL->textbuff.tokensize-2] = 0;  /* erases ']]' */
+  l->pTStr = luaS_new(LL->textbuff.text+2);
+  LL->textbuff.text[LL->textbuff.tokensize-2] = ']';  /* restores ']]' */
   return STRING;
 }
 
 
-int luaY_lex (void)
+/* to avoid warnings; this declaration cannot be public since YYSTYPE
+** cannot be visible in llex.h (otherwise there is an error, since
+** the parser body redefines it!)
+*/
+int luaY_lex (YYSTYPE *l);
+int luaY_lex (YYSTYPE *l)
 {
-  static int linelasttoken = 0;
+  LexState *LL = L->lexstate;
   double a;
-  textbuff.tokensize = 0;
+  LL->textbuff.tokensize = 0;
   if (lua_debug)
-    luaY_codedebugline(linelasttoken);
-  linelasttoken = luaX_linenumber;
+    luaY_codedebugline(LL->linelasttoken);
+  LL->linelasttoken = LL->linenumber;
   while (1) {
-    switch (current) {
+    switch (LL->current) {
       case '\n':
-        inclinenumber();
-        linelasttoken = luaX_linenumber;
+        inclinenumber(LL);
+        LL->linelasttoken = LL->linenumber;
         continue;
 
       case ' ': case '\t': case '\r':  /* CR: to avoid problems with DOS */
-        next();
+        next(LL);
         continue;
 
       case '-':
-        save_and_next();
-        if (current != '-') return '-';
-        do { next(); } while (current != '\n' && current != EOZ);
-        textbuff.tokensize = 0;
+        save_and_next(LL);
+        if (LL->current != '-') return '-';
+        do { next(LL); } while (LL->current != '\n' && LL->current != EOZ);
+        LL->textbuff.tokensize = 0;
         continue;
 
       case '[':
-        save_and_next();
-        if (current != '[') return '[';
+        save_and_next(LL);
+        if (LL->current != '[') return '[';
         else {
-          save_and_next();  /* pass the second '[' */
-          return read_long_string();
+          save_and_next(LL);  /* pass the second '[' */
+          return read_long_string(LL, l);
         }
 
       case '=':
-        save_and_next();
-        if (current != '=') return '=';
-        else { save_and_next(); return EQ; }
+        save_and_next(LL);
+        if (LL->current != '=') return '=';
+        else { save_and_next(LL); return EQ; }
 
       case '<':
-        save_and_next();
-        if (current != '=') return '<';
-        else { save_and_next(); return LE; }
+        save_and_next(LL);
+        if (LL->current != '=') return '<';
+        else { save_and_next(LL); return LE; }
 
       case '>':
-        save_and_next();
-        if (current != '=') return '>';
-        else { save_and_next(); return GE; }
+        save_and_next(LL);
+        if (LL->current != '=') return '>';
+        else { save_and_next(LL); return GE; }
 
       case '~':
-        save_and_next();
-        if (current != '=') return '~';
-        else { save_and_next(); return NE; }
+        save_and_next(LL);
+        if (LL->current != '=') return '~';
+        else { save_and_next(LL); return NE; }
 
       case '"':
       case '\'': {
-        int del = current;
-        save_and_next();
-        while (current != del) {
-          switch (current) {
+        int del = LL->current;
+        save_and_next(LL);
+        while (LL->current != del) {
+          switch (LL->current) {
             case EOZ:
             case '\n':
-              save(0);
+              save(LL, 0);
               return WRONGTOKEN;
             case '\\':
-              next();  /* do not save the '\' */
-              switch (current) {
-                case 'n': save('\n'); next(); break;
-                case 't': save('\t'); next(); break;
-                case 'r': save('\r'); next(); break;
-                case '\n': save('\n'); inclinenumber(); break;
-                default : save_and_next(); break;
+              next(LL);  /* do not save the '\' */
+              switch (LL->current) {
+                case 'n': save(LL, '\n'); next(LL); break;
+                case 't': save(LL, '\t'); next(LL); break;
+                case 'r': save(LL, '\r'); next(LL); break;
+                case '\n': save(LL, '\n'); inclinenumber(LL); break;
+                default : save_and_next(LL); break;
               }
               break;
             default:
-              save_and_next();
+              save_and_next(LL);
           }
         }
-        next();  /* skip delimiter */
-        save(0);
-        luaY_lval.pTStr = luaS_new(textbuff.text+1);
-        textbuff.text[textbuff.tokensize-1] = del;  /* restore delimiter */
+        next(LL);  /* skip delimiter */
+        save(LL, 0);
+        l->pTStr = luaS_new(LL->textbuff.text+1);
+        LL->textbuff.text[LL->textbuff.tokensize-1] = del;  /* restore delimiter */
         return STRING;
       }
 
       case '.':
-        save_and_next();
-        if (current == '.')
+        save_and_next(LL);
+        if (LL->current == '.')
         {
-          save_and_next();
-          if (current == '.')
+          save_and_next(LL);
+          if (LL->current == '.')
           {
-            save_and_next();
+            save_and_next(LL);
             return DOTS;   /* ... */
           }
           else return CONC;   /* .. */
         }
-        else if (!isdigit(current)) return '.';
-        /* current is a digit: goes through to number */
+        else if (!isdigit(LL->current)) return '.';
+        /* LL->current is a digit: goes through to number */
 	a=0.0;
         goto fraction;
 
@@ -385,69 +369,69 @@ int luaY_lex (void)
       case '5': case '6': case '7': case '8': case '9':
 	a=0.0;
         do {
-          a=10.0*a+(current-'0');
-          save_and_next();
-        } while (isdigit(current));
-        if (current == '.') {
-          save_and_next();
-          if (current == '.') {
-            save(0);
+          a=10.0*a+(LL->current-'0');
+          save_and_next(LL);
+        } while (isdigit(LL->current));
+        if (LL->current == '.') {
+          save_and_next(LL);
+          if (LL->current == '.') {
+            save(LL, 0);
             luaY_error(
               "ambiguous syntax (decimal point x string concatenation)");
           }
         }
       fraction:
 	{ double da=0.1;
-	  while (isdigit(current))
+	  while (isdigit(LL->current))
 	  {
-            a+=(current-'0')*da;
+            a+=(LL->current-'0')*da;
             da/=10.0;
-            save_and_next();
+            save_and_next(LL);
           }
-          if (toupper(current) == 'E') {
+          if (toupper(LL->current) == 'E') {
 	    int e=0;
 	    int neg;
 	    double ea;
-            save_and_next();
-	    neg=(current=='-');
-            if (current == '+' || current == '-') save_and_next();
-            if (!isdigit(current)) {
-              save(0); return WRONGTOKEN; }
+            save_and_next(LL);
+	    neg=(LL->current=='-');
+            if (LL->current == '+' || LL->current == '-') save_and_next(LL);
+            if (!isdigit(LL->current)) {
+              save(LL, 0); return WRONGTOKEN; }
             do {
-              e=10.0*e+(current-'0');
-              save_and_next();
-            } while (isdigit(current));
+              e=10.0*e+(LL->current-'0');
+              save_and_next(LL);
+            } while (isdigit(LL->current));
 	    for (ea=neg?0.1:10.0; e>0; e>>=1)
 	    {
 	      if (e & 1) a*=ea;
 	      ea*=ea;
 	    }
           }
-          luaY_lval.vReal = a;
+          l->vReal = a;
           return NUMBER;
         }
 
       case EOZ:
-        save(0);
-        if (iflevel > 0)
+        save(LL, 0);
+        if (LL->iflevel > 0)
           luaY_error("missing $endif");
         return 0;
 
       default:
-        if (current != '_' && !isalpha(current)) {
-          save_and_next();
-          return textbuff.text[0];
+        if (LL->current != '_' && !isalpha(LL->current)) {
+          save_and_next(LL);
+          return LL->textbuff.text[0];
         }
         else {  /* identifier or reserved word */
           TaggedString *ts;
           do {
-            save_and_next();
-          } while (isalnum(current) || current == '_');
-          save(0);
-          ts = luaS_new(textbuff.text);
+            save_and_next(LL);
+          } while (isalnum(LL->current) || LL->current == '_');
+          save(LL, 0);
+          ts = luaS_new(LL->textbuff.text);
           if (ts->head.marked > 255)
             return ts->head.marked;  /* reserved word */
-          luaY_lval.pTStr = ts;
+          l->pTStr = ts;
           return NAME;
         }
     }
diff --git a/llex.h b/llex.h
index f6f7c18e..4f28cc24 100644
--- a/llex.h
+++ b/llex.h
@@ -1,5 +1,5 @@
 /*
-** $Id: llex.h,v 1.1 1997/09/16 19:25:59 roberto Exp roberto $
+** $Id: llex.h,v 1.2 1997/11/04 15:27:53 roberto Exp roberto $
 ** Lexical Analizer
 ** See Copyright Notice in lua.h
 */
@@ -11,11 +11,39 @@
 #include "lzio.h"
 
 
+#define MAX_IFS 5
+
+/* "ifstate" keeps the state of each nested $if the lexical is dealing with. */
+
+struct ifState {
+  int elsepart;  /* true if its in the $else part */
+  int condition;  /* true if $if condition is true */
+  int skip;  /* true if part must be skiped */
+};
+
+struct textBuff {
+  char *text;
+  int tokensize;
+  int buffsize;
+};
+
+
+typedef struct LexState {
+  int current;  /* look ahead character */
+  struct zio *lex_z;
+  int linenumber;
+  struct ifState ifstate[MAX_IFS];
+  int iflevel;  /* level of nested $if's (for lexical analysis) */
+  struct textBuff textbuff;
+  int linelasttoken;
+  int lastline;
+} LexState;
+
+
 extern int luaX_linenumber;
 
 
 void luaX_init (void);
-int  luaY_lex (void);
 void luaX_setinput (ZIO *z);
 char *luaX_lasttoken (void);
 
diff --git a/lmem.c b/lmem.c
index 8aeb9974..749fca5b 100644
--- a/lmem.c
+++ b/lmem.c
@@ -1,5 +1,5 @@
 /*
-** $Id: $
+** $Id: lmem.c,v 1.1 1997/09/16 19:25:59 roberto Exp roberto $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
@@ -8,6 +8,7 @@
 #include <stdlib.h>
 
 #include "lmem.h"
+#include "lstate.h"
 #include "lua.h"
 
 
@@ -25,24 +26,21 @@ int luaM_growaux (void **block, unsigned long nelems, int size,
 }
 
 
-static unsigned long Mbuffsize = 0;
-static char *Mbuffer = NULL;
-
 
 void *luaM_buffer (unsigned long size)
 {
-  if (size > Mbuffsize) {
-    Mbuffsize = size;
-    Mbuffer = luaM_realloc(Mbuffer, Mbuffsize);
+  if (size > L->Mbuffsize) {
+    L->Mbuffsize = size;
+    L->Mbuffer = luaM_realloc(L->Mbuffer, L->Mbuffsize);
   }
-  return Mbuffer;
+  return L->Mbuffer;
 }
 
 
 void luaM_clearbuffer (void)
 {
-  Mbuffsize /= 2;
-  Mbuffer = luaM_realloc(Mbuffer, Mbuffsize);
+  L->Mbuffsize /= 2;
+  L->Mbuffer = luaM_realloc(L->Mbuffer, L->Mbuffsize);
 }
 
 
diff --git a/lobject.c b/lobject.c
index b38d3425..c575030d 100644
--- a/lobject.c
+++ b/lobject.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.c,v 1.5 1997/10/24 17:17:24 roberto Exp roberto $
+** $Id: lobject.c,v 1.6 1997/11/03 20:45:23 roberto Exp roberto $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -21,9 +21,6 @@ TObject luaO_nilobject = {LUA_T_NIL, {NULL}};
 
 
 
-unsigned long luaO_nblocks = 0;
-
-
 /* hash dimensions values */
 static long dimensions[] =
  {5L, 11L, 23L, 47L, 97L, 197L, 397L, 797L, 1597L, 3203L, 6421L,
diff --git a/lobject.h b/lobject.h
index 6cf77303..45e27995 100644
--- a/lobject.h
+++ b/lobject.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.h,v 1.7 1997/10/24 17:17:24 roberto Exp roberto $
+** $Id: lobject.h,v 1.8 1997/11/03 20:45:23 roberto Exp roberto $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -162,7 +162,6 @@ typedef struct Hash {
 ** a gross estimation of number of memory "blocks" allocated
 ** (a block is *roughly* 32 bytes)
 */
-extern unsigned long luaO_nblocks;
 
 extern char *luaO_typenames[];
 
diff --git a/lstring.c b/lstring.c
index d29aa8f0..57a579f2 100644
--- a/lstring.c
+++ b/lstring.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.c,v 1.3 1997/10/23 16:26:37 roberto Exp roberto $
+** $Id: lstring.c,v 1.4 1997/11/04 15:27:53 roberto Exp roberto $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
@@ -9,6 +9,7 @@
 
 #include "lmem.h"
 #include "lobject.h"
+#include "lstate.h"
 #include "lstring.h"
 #include "lua.h"
 
@@ -19,18 +20,6 @@
 #define gcsizestring(l)	(1+(l/64))
 
 
-GCnode luaS_root = {NULL, 0};  /* list of global variables */
-
-
-typedef struct {
-  int size;
-  int nuse;  /* number of elements (including EMPTYs) */
-  TaggedString **hash;
-} stringtable;
-
-
-static stringtable string_root[NUM_HASHS];
-
 
 static TaggedString EMPTY = {{NULL, 2}, 0, 0L, {{LUA_T_NIL, {NULL}}}, {0}};
 
@@ -38,10 +27,11 @@ static TaggedString EMPTY = {{NULL, 2}, 0, 0L, {{LUA_T_NIL, {NULL}}}, {0}};
 void luaS_init (void)
 {
   int i;
+  L->string_root = luaM_newvector(NUM_HASHS, stringtable);
   for (i=0; i<NUM_HASHS; i++) {
-    string_root[i].size = 0;
-    string_root[i].nuse = 0;
-    string_root[i].hash = NULL;
+    L->string_root[i].size = 0;
+    L->string_root[i].nuse = 0;
+    L->string_root[i].hash = NULL;
   }
 }
 
@@ -93,14 +83,14 @@ static TaggedString *newone(char *buff, int tag, unsigned long h)
     strcpy(ts->str, buff);
     ts->u.globalval.ttype = LUA_T_NIL;  /* initialize global value */
     ts->constindex = 0;
-    luaO_nblocks += gcsizestring(l);
+    L->nblocks += gcsizestring(l);
   }
   else {
     ts = (TaggedString *)luaM_malloc(sizeof(TaggedString));
     ts->u.d.v = buff;
     ts->u.d.tag = tag == LUA_ANYTAG ? 0 : tag;
     ts->constindex = -1;  /* tag -> this is a userdata */
-    luaO_nblocks++;
+    L->nblocks++;
   }
   ts->head.marked = 0;
   ts->head.next = (GCnode *)ts;  /* signal it is in no list */
@@ -138,12 +128,12 @@ static TaggedString *insert (char *buff, int tag, stringtable *tb)
 
 TaggedString *luaS_createudata (void *udata, int tag)
 {
-  return insert(udata, tag, &string_root[(unsigned)udata%NUM_HASHS]);
+  return insert(udata, tag, &L->string_root[(unsigned)udata%NUM_HASHS]);
 }
 
 TaggedString *luaS_new (char *str)
 {
-  return insert(str, LUA_T_STRING, &string_root[(unsigned)str[0]%NUM_HASHS]);
+  return insert(str, LUA_T_STRING, &L->string_root[(unsigned)str[0]%NUM_HASHS]);
 }
 
 TaggedString *luaS_newfixedstring (char *str)
@@ -159,7 +149,7 @@ void luaS_free (TaggedString *l)
 {
   while (l) {
     TaggedString *next = (TaggedString *)l->head.next;
-    luaO_nblocks -= (l->constindex == -1) ? 1 : gcsizestring(strlen(l->str));
+    L->nblocks -= (l->constindex == -1) ? 1 : gcsizestring(strlen(l->str));
     luaM_free(l);
     l = next;
   }
@@ -185,9 +175,9 @@ TaggedString *luaS_collector (void)
 {
   TaggedString *frees = NULL;
   int i;
-  remove_from_list(&luaS_root);
+  remove_from_list(&(L->rootglobal));
   for (i=0; i<NUM_HASHS; i++) {
-    stringtable *tb = &string_root[i];
+    stringtable *tb = &L->string_root[i];
     int j;
     for (j=0; j<tb->size; j++) {
       TaggedString *t = tb->hash[j];
@@ -209,8 +199,8 @@ void luaS_rawsetglobal (TaggedString *ts, TObject *newval)
 {
   ts->u.globalval = *newval;
   if (ts->head.next == (GCnode *)ts) {  /* is not in list? */
-    ts->head.next = luaS_root.next;
-    luaS_root.next = (GCnode *)ts;
+    ts->head.next = L->rootglobal.next;
+    L->rootglobal.next = (GCnode *)ts;
   }
 }
 
@@ -218,7 +208,7 @@ void luaS_rawsetglobal (TaggedString *ts, TObject *newval)
 char *luaS_travsymbol (int (*fn)(TObject *))
 {
   TaggedString *g;
-  for (g=(TaggedString *)luaS_root.next; g; g=(TaggedString *)g->head.next)
+  for (g=(TaggedString *)L->rootglobal.next; g; g=(TaggedString *)g->head.next)
     if (fn(&g->u.globalval))
       return g->str;
   return NULL;
diff --git a/lstring.h b/lstring.h
index fa606cf5..c842afe8 100644
--- a/lstring.h
+++ b/lstring.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.h,v 1.2 1997/09/26 15:02:26 roberto Exp roberto $
+** $Id: lstring.h,v 1.3 1997/11/04 15:27:53 roberto Exp roberto $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
@@ -10,8 +10,6 @@
 
 #include "lobject.h"
 
-extern GCnode luaS_root;
-
 
 void luaS_init (void);
 TaggedString *luaS_createudata (void *udata, int tag);
diff --git a/ltable.c b/ltable.c
index 4ac0caab..f0adc627 100644
--- a/ltable.c
+++ b/ltable.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.c,v 1.4 1997/10/23 16:26:37 roberto Exp roberto $
+** $Id: ltable.c,v 1.5 1997/10/24 17:17:24 roberto Exp roberto $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -9,6 +9,7 @@
 #include "lauxlib.h"
 #include "lmem.h"
 #include "lobject.h"
+#include "lstate.h"
 #include "ltable.h"
 #include "lua.h"
 
@@ -24,9 +25,6 @@
 #define TagDefault LUA_T_ARRAY;
 
 
-GCnode luaH_root = {NULL, 0};
-
-
 
 static long int hashindex (TObject *ref)
 {
@@ -95,7 +93,7 @@ void luaH_free (Hash *frees)
 {
   while (frees) {
     Hash *next = (Hash *)frees->head.next;
-    luaO_nblocks -= gcsize(frees->nhash);
+    L->nblocks -= gcsize(frees->nhash);
     hashdelete(frees);
     frees = next;
   }
@@ -110,8 +108,8 @@ Hash *luaH_new (int nhash)
   nhash(t) = nhash;
   nuse(t) = 0;
   t->htag = TagDefault;
-  luaO_insertlist(&luaH_root, (GCnode *)t);
-  luaO_nblocks += gcsize(nhash);
+  luaO_insertlist(&(L->roottable), (GCnode *)t);
+  L->nblocks += gcsize(nhash);
   return t;
 }
 
@@ -145,7 +143,7 @@ static void rehash (Hash *t)
     if (ttype(ref(n)) != LUA_T_NIL && ttype(val(n)) != LUA_T_NIL)
       *node(t, present(t, ref(n))) = *n;  /* copy old node to luaM_new hash */
   }
-  luaO_nblocks += gcsize(t->nhash)-gcsize(nold);
+  L->nblocks += gcsize(t->nhash)-gcsize(nold);
   luaM_free(vold);
 }
 
diff --git a/ltable.h b/ltable.h
index 58d09720..4fb66a91 100644
--- a/ltable.h
+++ b/ltable.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.h,v 1.2 1997/09/26 16:46:20 roberto Exp roberto $
+** $Id: ltable.h,v 1.3 1997/10/18 16:29:15 roberto Exp roberto $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -10,9 +10,6 @@
 #include "lobject.h"
 
 
-extern GCnode luaH_root;
-
-
 #define node(t,i)       (&(t)->node[i])
 #define ref(n)		(&(n)->ref)
 #define val(n)		(&(n)->val)
diff --git a/ltm.c b/ltm.c
index 1006aaeb..e19aab54 100644
--- a/ltm.c
+++ b/ltm.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltm.c,v 1.6 1997/11/04 15:27:53 roberto Exp roberto $
+** $Id: ltm.c,v 1.7 1997/11/10 17:47:01 roberto Exp roberto $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
@@ -9,9 +9,9 @@
 #include <string.h>
 
 #include "lauxlib.h"
-#include "ldo.h"
 #include "lmem.h"
 #include "lobject.h"
+#include "lstate.h"
 #include "ltm.h"
 
 
@@ -31,10 +31,6 @@ static int luaI_checkevent (char *name, char *list[])
 }
 
 
-struct IM *luaT_IMtable;
-static int IMtable_size;
-static int last_tag;
-
 
 /* events in LUA_T_NIL are all allowed, since this is used as a
 *  'placeholder' for "default" fallbacks
@@ -67,34 +63,34 @@ static void init_entry (int tag)
 void luaT_init (void)
 {
   int t;
-  IMtable_size = NUM_TAGS*2;
-  last_tag = -(NUM_TAGS-1);
-  luaT_IMtable = luaM_newvector(IMtable_size, struct IM);
-  for (t=last_tag; t<=0; t++)
+  L->IMtable_size = NUM_TAGS*2;
+  L->last_tag = -(NUM_TAGS-1);
+  L->IMtable = luaM_newvector(L->IMtable_size, struct IM);
+  for (t=L->last_tag; t<=0; t++)
     init_entry(t);
 }
 
 
 int lua_newtag (void)
 {
-  --last_tag;
-  if ((-last_tag) >= IMtable_size)
-    IMtable_size = luaM_growvector(&luaT_IMtable, IMtable_size,
+  --L->last_tag;
+  if ((-L->last_tag) >= L->IMtable_size)
+    L->IMtable_size = luaM_growvector(&L->IMtable, L->IMtable_size,
                                    struct IM, memEM, MAX_INT);
-  init_entry(last_tag);
-  return last_tag;
+  init_entry(L->last_tag);
+  return L->last_tag;
 }
 
 
 static void checktag (int tag)
 {
-  if (!(last_tag <= tag && tag <= 0))
+  if (!(L->last_tag <= tag && tag <= 0))
     luaL_verror("%d is not a valid tag", tag);
 }
 
 void luaT_realtag (int tag)
 {
-  if (!(last_tag <= tag && tag < LUA_T_NIL))
+  if (!(L->last_tag <= tag && tag < LUA_T_NIL))
     luaL_verror("tag %d is not result of `newtag'", tag);
 }
 
@@ -145,11 +141,11 @@ void luaT_settagmethod (int t, char *event, TObject *func)
 char *luaT_travtagmethods (int (*fn)(TObject *))
 {
   int e;
-  if (fn(&luaD_errorim))
+  if (fn(&L->errorim))
     return "error";
   for (e=IM_GETTABLE; e<=IM_FUNCTION; e++) {  /* ORDER IM */
     int t;
-    for (t=0; t>=last_tag; t--)
+    for (t=0; t>=L->last_tag; t--)
       if (fn(luaT_getim(t,e)))
         return luaT_eventname[e];
   }
@@ -203,8 +199,8 @@ void luaT_setfallback (void)
   luaL_arg_check(lua_isfunction(func), 2, "function expected");
   switch (luaO_findstring(name, oldnames)) {
     case 0:  /* old error fallback */
-      oldfunc = luaD_errorim;
-      luaD_errorim = *luaA_Address(func);
+      oldfunc = L->errorim;
+      L->errorim = *luaA_Address(func);
       replace = errorFB;
       break;
     case 1:  /* old getglobal fallback */
diff --git a/ltm.h b/ltm.h
index bad12fa9..4b52fe94 100644
--- a/ltm.h
+++ b/ltm.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ltm.h,v 1.1 1997/09/16 19:25:59 roberto Exp roberto $
+** $Id: ltm.h,v 1.2 1997/11/04 15:27:53 roberto Exp roberto $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
@@ -9,6 +9,7 @@
 
 
 #include "lobject.h"
+#include "lstate.h"
 
 /*
 * WARNING: if you change the order of this enumeration,
@@ -38,12 +39,12 @@ typedef enum {
 #define IM_N 18
 
 
-extern struct IM {
+struct IM {
   TObject int_method[IM_N];
-} *luaT_IMtable;
+};
 
 
-#define luaT_getim(tag,event) (&luaT_IMtable[-(tag)].int_method[event])
+#define luaT_getim(tag,event) (&L->IMtable[-(tag)].int_method[event])
 #define luaT_getimbyObj(o,e)  (luaT_getim(luaT_efectivetag(o),(e)))
 
 extern char *luaT_eventname[];
diff --git a/lua.c b/lua.c
index ce3b4ec7..0eb21982 100644
--- a/lua.c
+++ b/lua.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lua.c,v 1.2 1997/10/06 14:51:32 roberto Exp roberto $
+** $Id: lua.c,v 1.3 1997/10/16 18:35:59 roberto Exp roberto $
 ** Lua stand-alone interpreter
 ** See Copyright Notice in lua.h
 */
@@ -82,6 +82,7 @@ int main (int argc, char *argv[])
       }
     }
   }
+/*  lua_close(); */
   return 0;
 }
 
diff --git a/lua.h b/lua.h
index 4fa70b57..48fd80cf 100644
--- a/lua.h
+++ b/lua.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lua.h,v 1.2 1997/10/24 17:17:24 roberto Exp roberto $
+** $Id: lua.h,v 1.3 1997/11/04 15:27:53 roberto Exp roberto $
 ** LUA - An Extensible Extension Language
 ** TeCGraf: Grupo de Tecnologia em Computacao Grafica, PUC-Rio, Brazil
 ** e-mail: lua@tecgraf.puc-rio.br
@@ -117,6 +117,8 @@ int            lua_ref			(int lock); /* In: value */
 lua_Object     lua_getref		(int ref);
 void	       lua_unref		(int ref);
 
+lua_Object     lua_globalbag		(void);
+
 lua_Object     lua_createtable		(void);
 
 long	       lua_collectgarbage	(long limit);
diff --git a/lua.stx b/lua.stx
index 65d1337f..3d6dbaa7 100644
--- a/lua.stx
+++ b/lua.stx
@@ -1,6 +1,6 @@
 %{
 /*
-** $Id: lua.stx,v 1.16 1997/10/30 18:47:19 roberto Exp roberto $
+** $Id: lua.stx,v 1.17 1997/11/07 15:09:49 roberto Exp roberto $
 ** Syntax analizer and code generator
 ** See Copyright Notice in lua.h
 */
@@ -16,13 +16,13 @@
 #include "lmem.h"
 #include "lopcodes.h"
 #include "lparser.h"
+#include "lstate.h"
 #include "lstring.h"
 #include "lua.h"
 #include "luadebug.h"
 #include "lzio.h"
 
 
-/* to avoid warnings generated by yacc */
 int luaY_parse (void);
 
 
@@ -61,7 +61,7 @@ typedef long vardesc;
 #define dotindex(v)	((-(v))-1)
 
 /* state needed to generate code for a given function */
-typedef struct State {
+typedef struct FuncState {
   TProtoFunc *f;  /* current function header */
   int pc;  /* next position to code */
   TaggedString *localvar[MAXLOCALS];  /* store local variable names */
@@ -75,19 +75,19 @@ typedef struct State {
   int maxconsts;  /* size of f->consts */
   vardesc varbuffer[MAXVAR];  /* variables in an assignment list */
   vardesc upvalues[MAXUPVALUES];  /* upvalues */
-} State;
-
-static State *mainState, *currState;
+} FuncState;
 
 
 
+#define YYPURE	1
+
 
 void luaY_syntaxerror (char *s, char *token)
 {
   if (token[0] == 0)
     token = "<eof>";
   luaL_verror("%.100s;\n> last token read: \"%.50s\" at line %d in file %.50s",
-           s, token, luaX_linenumber, mainState->f->fileName->str);
+           s, token, L->lexstate->linenumber, L->mainState->f->fileName->str);
 }
 
 
@@ -99,16 +99,16 @@ void luaY_error (char *s)
 
 static void check_pc (int n)
 {
-  if (currState->pc+n > currState->maxcode)
-    currState->maxcode = luaM_growvector(&currState->f->code,
-                                currState->maxcode, Byte, codeEM, MAX_INT);
+  if (L->currState->pc+n > L->currState->maxcode)
+    L->currState->maxcode = luaM_growvector(&L->currState->f->code,
+                                L->currState->maxcode, Byte, codeEM, MAX_INT);
 }
 
 
 static void movecode_up (int d, int s, int n)
 {
   while (n--)
-    currState->f->code[d+n] = currState->f->code[s+n];
+    L->currState->f->code[d+n] = L->currState->f->code[s+n];
 }
 
 
@@ -116,24 +116,24 @@ static void movecode_down (int d, int s, int n)
 {
   int i;
   for (i=0; i<n; i++)
-    currState->f->code[d+i] = currState->f->code[s+i];
+    L->currState->f->code[d+i] = L->currState->f->code[s+i];
 }
 
 
 static void code_byte (Byte c)
 {
   check_pc(1);
-  currState->f->code[currState->pc++] = c;
+  L->currState->f->code[L->currState->pc++] = c;
 }
 
 
 static void deltastack (int delta)
 {
-  currState->stacksize += delta;
-  if (currState->stacksize > currState->maxstacksize) {
-    if (currState->stacksize > 255)
+  L->currState->stacksize += delta;
+  if (L->currState->stacksize > L->currState->maxstacksize) {
+    if (L->currState->stacksize > 255)
       luaY_error("function/expression too complex (limit 256)");
-    currState->maxstacksize = currState->stacksize;
+    L->currState->maxstacksize = L->currState->stacksize;
   }
 }
 
@@ -142,18 +142,18 @@ static int code_oparg_at (int pc, OpCode op, int builtin, int arg, int delta)
 {
   deltastack(delta);
   if (arg < builtin) {
-    currState->f->code[pc] = op+1+arg;
+    L->currState->f->code[pc] = op+1+arg;
     return 1;
   }
   else if (arg <= 255) {
-    currState->f->code[pc] = op;
-    currState->f->code[pc+1] = arg;
+    L->currState->f->code[pc] = op;
+    L->currState->f->code[pc+1] = arg;
     return 2;
   }
   else if (arg <= MAX_WORD) {
-    currState->f->code[pc] = op+1+builtin;
-    currState->f->code[pc+1] = arg&0xFF;
-    currState->f->code[pc+2] = arg>>8;
+    L->currState->f->code[pc] = op+1+builtin;
+    L->currState->f->code[pc+1] = arg&0xFF;
+    L->currState->f->code[pc+2] = arg>>8;
     return 3;
   }
   else luaY_error("code too long (limit 64K)");
@@ -164,13 +164,13 @@ static int code_oparg_at (int pc, OpCode op, int builtin, int arg, int delta)
 static int fix_opcode (int pc, OpCode op, int builtin, int arg)
 {
   if (arg < builtin) {  /* close space */
-    movecode_down(pc+1, pc+2, currState->pc-(pc+2));
-    currState->pc--;
+    movecode_down(pc+1, pc+2, L->currState->pc-(pc+2));
+    L->currState->pc--;
   }
   else if (arg > 255) {  /* open space */
     check_pc(1);
-    movecode_up(pc+1, pc, currState->pc-pc);
-    currState->pc++;
+    movecode_up(pc+1, pc, L->currState->pc-pc);
+    L->currState->pc++;
   }
   return code_oparg_at(pc, op, builtin, arg, 0) - 2;
 }
@@ -179,7 +179,7 @@ static int fix_opcode (int pc, OpCode op, int builtin, int arg)
 static void code_oparg (OpCode op, int builtin, int arg, int delta)
 {
   check_pc(3);  /* maximum code size */
-  currState->pc += code_oparg_at(currState->pc, op, builtin, arg, delta);
+  L->currState->pc += code_oparg_at(L->currState->pc, op, builtin, arg, delta);
 }
 
 
@@ -214,7 +214,7 @@ static void code_constant (int c)
 }
 
 
-static int next_constant (State *cs)
+static int next_constant (FuncState *cs)
 {
   TProtoFunc *f = cs->f;
   if (f->nconsts >= cs->maxconsts) {
@@ -225,7 +225,7 @@ static int next_constant (State *cs)
 }
 
 
-static int string_constant (TaggedString *s, State *cs)
+static int string_constant (TaggedString *s, FuncState *cs)
 {
   TProtoFunc *f = cs->f;
   int c = s->constindex;
@@ -242,7 +242,7 @@ static int string_constant (TaggedString *s, State *cs)
 
 static void code_string (TaggedString *s)
 {
-  code_constant(string_constant(s, currState));
+  code_constant(string_constant(s, L->currState));
 }
 
 
@@ -250,16 +250,16 @@ static void code_string (TaggedString *s)
 static int real_constant (real r)
 {
   /* check whether 'r' has appeared within the last LIM entries */
-  TObject *cnt = currState->f->consts;
-  int c = currState->f->nconsts;
+  TObject *cnt = L->currState->f->consts;
+  int c = L->currState->f->nconsts;
   int lim = c < LIM ? 0 : c-LIM;
   while (--c >= lim) {
     if (ttype(&cnt[c]) == LUA_T_NUMBER && nvalue(&cnt[c]) == r)
       return c;
   }
   /* not found; create a luaM_new entry */
-  c = next_constant(currState);
-  cnt = currState->f->consts;  /* 'next_constant' may reallocate this vector */
+  c = next_constant(L->currState);
+  cnt = L->currState->f->consts;  /* 'next_constant' may reallocate this vector */
   ttype(&cnt[c]) = LUA_T_NUMBER;
   nvalue(&cnt[c]) = r;
   return c;
@@ -292,13 +292,13 @@ static void flush_list (int m, int n)
 
 static void luaI_registerlocalvar (TaggedString *varname, int line)
 {
-  if (currState->maxvars != -1) {  /* debug information? */
-    if (currState->nvars >= currState->maxvars)
-      currState->maxvars = luaM_growvector(&currState->f->locvars,
-                                      currState->maxvars, LocVar, "", MAX_WORD);
-    currState->f->locvars[currState->nvars].varname = varname;
-    currState->f->locvars[currState->nvars].line = line;
-    currState->nvars++;
+  if (L->currState->maxvars != -1) {  /* debug information? */
+    if (L->currState->nvars >= L->currState->maxvars)
+      L->currState->maxvars = luaM_growvector(&L->currState->f->locvars,
+                                      L->currState->maxvars, LocVar, "", MAX_WORD);
+    L->currState->f->locvars[L->currState->nvars].varname = varname;
+    L->currState->f->locvars[L->currState->nvars].line = line;
+    L->currState->nvars++;
   }
 }
 
@@ -311,17 +311,17 @@ static void luaI_unregisterlocalvar (int line)
 
 static void store_localvar (TaggedString *name, int n)
 {
-  if (currState->nlocalvar+n < MAXLOCALS)
-    currState->localvar[currState->nlocalvar+n] = name;
+  if (L->currState->nlocalvar+n < MAXLOCALS)
+    L->currState->localvar[L->currState->nlocalvar+n] = name;
   else
     luaY_error("too many local variables (limit 32)");
-  luaI_registerlocalvar(name, luaX_linenumber);
+  luaI_registerlocalvar(name, L->lexstate->linenumber);
 }
 
 static void add_localvar (TaggedString *name)
 {
   store_localvar(name, 0);
-  currState->nlocalvar++;
+  L->currState->nlocalvar++;
 }
 
 
@@ -342,11 +342,11 @@ static void add_varbuffer (vardesc var, int n)
 {
   if (n >= MAXVAR)
     luaY_error("variable buffer overflow (limit 32)");
-  currState->varbuffer[n] = var2store(var);
+  L->currState->varbuffer[n] = var2store(var);
 }
 
 
-static int aux_localname (TaggedString *n, State *st)
+static int aux_localname (TaggedString *n, FuncState *st)
 {
   int i;
   for (i=st->nlocalvar-1; i >= 0; i--)
@@ -355,12 +355,12 @@ static int aux_localname (TaggedString *n, State *st)
 }
 
 
-static vardesc singlevar (TaggedString *n, State *st)
+static vardesc singlevar (TaggedString *n, FuncState *st)
 {
   int i = aux_localname(n, st);
   if (i == -1) {  /* check shadowing */
     int l;
-    for (l=1; l<=(st-mainState); l++)
+    for (l=1; l<=(st-L->mainState); l++)
       if (aux_localname(n, st-l) >= 0)
         luaY_syntaxerror("cannot access a variable in outer scope", n->str);
     return string_constant(n, st)+MINGLOBAL;  /* global value */
@@ -371,16 +371,16 @@ static vardesc singlevar (TaggedString *n, State *st)
 
 static int indexupvalue (TaggedString *n)
 {
-  vardesc v = singlevar(n, currState-1);
+  vardesc v = singlevar(n, L->currState-1);
   int i;
-  for (i=0; i<currState->nupvalues; i++) {
-    if (currState->upvalues[i] == v)
+  for (i=0; i<L->currState->nupvalues; i++) {
+    if (L->currState->upvalues[i] == v)
       return i;
   }
   /* new one */
-  if (++(currState->nupvalues) > MAXUPVALUES)
+  if (++(L->currState->nupvalues) > MAXUPVALUES)
     luaY_error("too many upvalues in a single function (limit 16)");
-  currState->upvalues[i] = v;  /* i = currState->nupvalues - 1 */
+  L->currState->upvalues[i] = v;  /* i = L->currState->nupvalues - 1 */
   return i;
 }
 
@@ -388,9 +388,9 @@ static int indexupvalue (TaggedString *n)
 static void pushupvalue (TaggedString *n)
 {
   int i;
-  if (currState == mainState)
+  if (L->currState == L->mainState)
     luaY_error("cannot access upvalue in main");
-  if (aux_localname(n, currState) >= 0)
+  if (aux_localname(n, L->currState) >= 0)
     luaY_syntaxerror("cannot access an upvalue in current scope", n->str);
   i = indexupvalue(n);
   code_oparg(PUSHUPVALUE, 2, i, 1);
@@ -399,10 +399,9 @@ static void pushupvalue (TaggedString *n)
 
 void luaY_codedebugline (int line)
 {
-  static int lastline = 0;
-  if (lua_debug && line != lastline) {
+  if (lua_debug && line != L->lexstate->lastline) {
     code_oparg(SETLINE, 0, line, 0);
-    lastline = line;
+    L->lexstate->lastline = line;
   }
 }
 
@@ -421,10 +420,10 @@ static long adjust_functioncall (long exp, int nresults)
   if (exp <= 0)
     return -exp; /* exp is -list length */
   else {
-    int temp = currState->f->code[exp];
-    int nparams = currState->f->code[exp-1];
+    int temp = L->currState->f->code[exp];
+    int nparams = L->currState->f->code[exp-1];
     exp += fix_opcode(exp-2, CALLFUNC, 2, nresults);
-    currState->f->code[exp] = nparams;
+    L->currState->f->code[exp] = nparams;
     if (nresults != MULT_RET)
       deltastack(nresults);
     deltastack(-(nparams+1));
@@ -436,7 +435,7 @@ static long adjust_functioncall (long exp, int nresults)
 static void adjust_mult_assign (int vars, long exps)
 {
   if (exps > 0) { /* must correct function call */
-    int diff = currState->f->code[exps] - vars;
+    int diff = L->currState->f->code[exps] - vars;
     if (diff < 0)
       adjust_functioncall(exps, -diff);
     else {
@@ -450,11 +449,11 @@ static void adjust_mult_assign (int vars, long exps)
 
 static void code_args (int nparams, int dots)
 {
-  currState->nlocalvar += nparams;
+  L->currState->nlocalvar += nparams;
   if (!dots)
-    code_oparg(ARGS, 0, currState->nlocalvar, currState->nlocalvar);
+    code_oparg(ARGS, 0, L->currState->nlocalvar, L->currState->nlocalvar);
   else {
-    code_oparg(VARARGS, 0, currState->nlocalvar, currState->nlocalvar+1);
+    code_oparg(VARARGS, 0, L->currState->nlocalvar, L->currState->nlocalvar+1);
     add_localvar(luaS_new("arg"));
   }
 }
@@ -487,9 +486,9 @@ static void storevar (vardesc var)
 /* returns how many elements are left as 'garbage' on the stack */
 static int lua_codestore (int i, int left)
 {
-  if (currState->varbuffer[i] != 0 ||  /* global or local var or */
+  if (L->currState->varbuffer[i] != 0 ||  /* global or local var or */
       left+i == 0) {  /* indexed var without values in between */
-    storevar(currState->varbuffer[i]);
+    storevar(L->currState->varbuffer[i]);
     return left;
   }
   else {  /* indexed var with values in between*/
@@ -508,7 +507,7 @@ static int fix_jump (int pc, OpCode op, int n)
 
 static void fix_upjmp (OpCode op, int pos)
 {
-  int delta = currState->pc+JMPSIZE - pos;  /* jump is relative */
+  int delta = L->currState->pc+JMPSIZE - pos;  /* jump is relative */
   if (delta > 255) delta++;
   code_oparg(op, 0, delta, 0);
 }
@@ -517,38 +516,38 @@ static void fix_upjmp (OpCode op, int pos)
 static void codeIf (int thenAdd, int elseAdd)
 {
   int elseinit = elseAdd+JMPSIZE;
-  if (currState->pc == elseinit) {  /* no else part */
-    currState->pc -= JMPSIZE;
-    elseinit = currState->pc;
+  if (L->currState->pc == elseinit) {  /* no else part */
+    L->currState->pc -= JMPSIZE;
+    elseinit = L->currState->pc;
   }
   else
-    elseinit += fix_jump(elseAdd, JMP, currState->pc);
+    elseinit += fix_jump(elseAdd, JMP, L->currState->pc);
   fix_jump(thenAdd, IFFJMP, elseinit);
 }
 
 
 static void code_shortcircuit (int pc, OpCode op)
 {
-  fix_jump(pc, op, currState->pc);
+  fix_jump(pc, op, L->currState->pc);
 }
 
 
 static void codereturn (void)
 {
-  code_oparg(RETCODE, 0, currState->nlocalvar, 0);
-  currState->stacksize = currState->nlocalvar;
+  code_oparg(RETCODE, 0, L->currState->nlocalvar, 0);
+  L->currState->stacksize = L->currState->nlocalvar;
 }
 
 
 static void func_onstack (TProtoFunc *f)
 {
   int i;
-  int nupvalues = (currState+1)->nupvalues;
-  int c = next_constant(currState);
-  ttype(&currState->f->consts[c]) = LUA_T_PROTO;
-  currState->f->consts[c].value.tf = (currState+1)->f;
+  int nupvalues = (L->currState+1)->nupvalues;
+  int c = next_constant(L->currState);
+  ttype(&L->currState->f->consts[c]) = LUA_T_PROTO;
+  L->currState->f->consts[c].value.tf = (L->currState+1)->f;
   for (i=0; i<nupvalues; i++)
-    lua_pushvar((currState+1)->upvalues[i]);
+    lua_pushvar((L->currState+1)->upvalues[i]);
   code_constant(c);
   code_oparg(CLOSURE, 2, nupvalues, -nupvalues);
 }
@@ -557,48 +556,48 @@ static void func_onstack (TProtoFunc *f)
 static void init_state (TaggedString *filename)
 {
   TProtoFunc *f = luaF_newproto();
-  currState->stacksize = 0;
-  currState->maxstacksize = 0;
-  currState->nlocalvar = 0;
-  currState->nupvalues = 0;
-  currState->f = f;
+  L->currState->stacksize = 0;
+  L->currState->maxstacksize = 0;
+  L->currState->nlocalvar = 0;
+  L->currState->nupvalues = 0;
+  L->currState->f = f;
   f->fileName = filename;
-  currState->pc = 0;
-  currState->maxcode = 0;
+  L->currState->pc = 0;
+  L->currState->maxcode = 0;
   f->code = NULL;
-  currState->maxconsts = 0;
+  L->currState->maxconsts = 0;
   if (lua_debug) {
-    currState->nvars = 0;
-    currState->maxvars = 0;
+    L->currState->nvars = 0;
+    L->currState->maxvars = 0;
   }
   else
-    currState->maxvars = -1;  /* flag no debug information */
+    L->currState->maxvars = -1;  /* flag no debug information */
   code_byte(0);  /* to be filled with stacksize */
 }
 
 
 static void init_func (void)
 {
-  if (currState-mainState >= MAXSTATES-1)
+  if (L->currState-L->mainState >= MAXSTATES-1)
     luaY_error("too many nested functions (limit 6)");
-  currState++;
-  init_state(mainState->f->fileName);
-  luaY_codedebugline(luaX_linenumber);
-  currState->f->lineDefined = luaX_linenumber;
+  L->currState++;
+  init_state(L->mainState->f->fileName);
+  luaY_codedebugline(L->lexstate->linenumber);
+  L->currState->f->lineDefined = L->lexstate->linenumber;
 }
 
 static TProtoFunc *close_func (void)
 {
-  TProtoFunc *f = currState->f;
+  TProtoFunc *f = L->currState->f;
   code_neutralop(ENDCODE);
-  f->code[0] = currState->maxstacksize;
-  f->code = luaM_reallocvector(f->code, currState->pc, Byte);
+  f->code[0] = L->currState->maxstacksize;
+  f->code = luaM_reallocvector(f->code, L->currState->pc, Byte);
   f->consts = luaM_reallocvector(f->consts, f->nconsts, TObject);
-  if (currState->maxvars != -1) {  /* debug information? */
+  if (L->currState->maxvars != -1) {  /* debug information? */
     luaI_registerlocalvar(NULL, -1);  /* flag end of vector */
-    f->locvars = luaM_reallocvector(f->locvars, currState->nvars, LocVar);
+    f->locvars = luaM_reallocvector(f->locvars, L->currState->nvars, LocVar);
   }
-  currState--;
+  L->currState--;
   return f;
 }
 
@@ -608,8 +607,10 @@ static TProtoFunc *close_func (void)
 */
 TProtoFunc *luaY_parser (ZIO *z, char *chunkname)
 {
-  State state[MAXSTATES];
-  currState = mainState = &state[0];
+  struct LexState lexstate;
+  FuncState state[MAXSTATES];
+  L->currState = L->mainState = &state[0];
+  L->lexstate = &lexstate;
   luaX_setinput(z);
   init_state(luaS_new(chunkname));
   if (luaY_parse ()) lua_error("parse error");
@@ -685,10 +686,10 @@ stat   : IF cond THEN block SaveWord elsepart END { codeIf($2, $5); }
          int expsize = $3-$2;
 	 int newpos = $2+JMPSIZE;
 	 check_pc(expsize);
-	 memcpy(&currState->f->code[currState->pc],
-                &currState->f->code[$2], expsize);
-	 movecode_down($2, $3, currState->pc-$2);
-	 newpos += fix_jump($2, JMP, currState->pc-expsize);
+	 memcpy(&L->currState->f->code[L->currState->pc],
+                &L->currState->f->code[$2], expsize);
+	 movecode_down($2, $3, L->currState->pc-$2);
+	 newpos += fix_jump($2, JMP, L->currState->pc-expsize);
 	 fix_upjmp(IFTUPJMP, newpos);
        }}
 
@@ -712,18 +713,18 @@ stat   : IF cond THEN block SaveWord elsepart END { codeIf($2, $5); }
 
        | LOCAL localnamelist decinit
        {
-         currState->nlocalvar += $2;
+         L->currState->nlocalvar += $2;
          adjust_mult_assign($2, $3);
        }
 
        | FUNCTION funcname body { func_onstack($3); storevar($2); }
        ;
 
-block    : {$<vInt>$ = currState->nlocalvar;} chunk
+block    : {$<vInt>$ = L->currState->nlocalvar;} chunk
          {
-           adjuststack(currState->nlocalvar - $<vInt>1);
-	   for (; currState->nlocalvar > $<vInt>1; currState->nlocalvar--)
-	     luaI_unregisterlocalvar(luaX_linenumber);
+           adjuststack(L->currState->nlocalvar - $<vInt>1);
+	   for (; L->currState->nlocalvar > $<vInt>1; L->currState->nlocalvar--)
+	     luaI_unregisterlocalvar(L->lexstate->linenumber);
          }
          ;
 
@@ -753,13 +754,13 @@ ret	: /* empty */
           }
 	;
 
-GetPC	: /* empty */ { $$ = currState->pc; }
+GetPC	: /* empty */ { $$ = L->currState->pc; }
 	;
 
 SaveWord : /* empty */
-	{ $$ = currState->pc;
+	{ $$ = L->currState->pc;
 	  check_pc(JMPSIZE);
-	  currState->pc += JMPSIZE;  /* open space */
+	  L->currState->pc += JMPSIZE;  /* open space */
 	}
 	 ;
 
@@ -808,7 +809,7 @@ functioncall : funcvalue funcParams
 	{
 	  code_byte(0);  /* save space for opcode */
 	  code_byte($1+$2);  /* number of parameters */
-	  $$ = currState->pc;
+	  $$ = L->currState->pc;
 	  code_byte(0);  /* must be adjusted by other rules */
 	}
 	     ;
@@ -816,7 +817,7 @@ functioncall : funcvalue funcParams
 funcvalue    : varexp { $$ = 0; }
 	     | varexp ':' NAME
 	     {
-               code_oparg(PUSHSELF, 0, string_constant($3, currState), 1);
+               code_oparg(PUSHSELF, 0, string_constant($3, L->currState), 1);
                $$ = 1;
 	     }
 	     ;
@@ -834,7 +835,7 @@ exprlist1 :  expr	{ if ($1 != 0) $$ = $1; else $$ = -1; }
 	{
 	  if ($4 == 0) $$ = -($<vLong>3 + 1);  /* -length */
 	  else {
-            currState->f->code[$4] = $<vLong>3;  /* store list length */
+            L->currState->f->code[$4] = $<vLong>3;  /* store list length */
 	    $$ = $4;
 	  }
 	}
@@ -899,9 +900,9 @@ varlist1  : var { $$ = 1; add_varbuffer($1, 0); }
 	  | varlist1 ',' var { add_varbuffer($3, $1); $$ = $1+1; }
 	  ;
 		
-var	  :	NAME { $$ = singlevar($1, currState); }
+var	  :	NAME { $$ = singlevar($1, L->currState); }
 	  |	varexp '[' expr1 ']' { $$ = 0; }  /* indexed variable */
-	  |	varexp '.' NAME { $$ = (-string_constant($3, currState))-1; }
+	  |	varexp '.' NAME { $$ = (-string_constant($3, L->currState))-1; }
 	  ;
 		
 varexp	: var { lua_pushvar($1); }
diff --git a/lvm.c b/lvm.c
index 1ba3e310..9e4aa8e0 100644
--- a/lvm.c
+++ b/lvm.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.c,v 1.12 1997/10/24 18:40:29 roberto Exp roberto $
+** $Id: lvm.c,v 1.13 1997/10/27 16:14:37 roberto Exp roberto $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -14,6 +14,7 @@
 #include "lgc.h"
 #include "lmem.h"
 #include "lopcodes.h"
+#include "lstate.h"
 #include "lstring.h"
 #include "ltable.h"
 #include "ltm.h"
@@ -79,11 +80,11 @@ int luaV_tostring (TObject *obj)
 void luaV_closure (int nelems)
 {
   Closure *c = luaF_newclosure(nelems);
-  c->consts[0] = *(luaD_stack.top-1);
-  memcpy(&c->consts[1], luaD_stack.top-(nelems+1), nelems*sizeof(TObject));
-  luaD_stack.top -= nelems;
-  ttype(luaD_stack.top-1) = LUA_T_FUNCTION;
-  (luaD_stack.top-1)->value.cl = c;
+  c->consts[0] = *(L->stack.top-1);
+  memcpy(&c->consts[1], L->stack.top-(nelems+1), nelems*sizeof(TObject));
+  L->stack.top -= nelems;
+  ttype(L->stack.top-1) = LUA_T_FUNCTION;
+  (L->stack.top-1)->value.cl = c;
 }
 
 
@@ -94,22 +95,22 @@ void luaV_closure (int nelems)
 void luaV_gettable (void)
 {
   TObject *im;
-  if (ttype(luaD_stack.top-2) != LUA_T_ARRAY)  /* not a table, get "gettable" method */
-    im = luaT_getimbyObj(luaD_stack.top-2, IM_GETTABLE);
+  if (ttype(L->stack.top-2) != LUA_T_ARRAY)  /* not a table, get "gettable" method */
+    im = luaT_getimbyObj(L->stack.top-2, IM_GETTABLE);
   else {  /* object is a table... */
-    int tg = (luaD_stack.top-2)->value.a->htag;
+    int tg = (L->stack.top-2)->value.a->htag;
     im = luaT_getim(tg, IM_GETTABLE);
     if (ttype(im) == LUA_T_NIL) {  /* and does not have a "gettable" method */
-      TObject *h = luaH_get(avalue(luaD_stack.top-2), luaD_stack.top-1);
+      TObject *h = luaH_get(avalue(L->stack.top-2), L->stack.top-1);
       if (h != NULL && ttype(h) != LUA_T_NIL) {
-        --luaD_stack.top;
-        *(luaD_stack.top-1) = *h;
+        --L->stack.top;
+        *(L->stack.top-1) = *h;
       }
       else if (ttype(im=luaT_getim(tg, IM_INDEX)) != LUA_T_NIL)
         luaD_callTM(im, 2, 1);
       else {
-        --luaD_stack.top;
-        ttype(luaD_stack.top-1) = LUA_T_NIL;
+        --L->stack.top;
+        ttype(L->stack.top-1) = LUA_T_NIL;
       }
       return;
     }
@@ -124,26 +125,26 @@ void luaV_gettable (void)
 
 
 /*
-** Function to store indexed based on values at the luaD_stack.top
+** Function to store indexed based on values at the L->stack.top
 ** mode = 0: raw store (without internal methods)
 ** mode = 1: normal store (with internal methods)
-** mode = 2: "deep luaD_stack.stack" store (with internal methods)
+** mode = 2: "deep L->stack.stack" store (with internal methods)
 */
 void luaV_settable (TObject *t, int mode)
 {
   TObject *im = (mode == 0) ? NULL : luaT_getimbyObj(t, IM_SETTABLE);
   if (ttype(t) == LUA_T_ARRAY && (im == NULL || ttype(im) == LUA_T_NIL)) {
     TObject *h = luaH_set(avalue(t), t+1);
-    *h = *(luaD_stack.top-1);
-    luaD_stack.top -= (mode == 2) ? 1 : 3;
+    *h = *(L->stack.top-1);
+    L->stack.top -= (mode == 2) ? 1 : 3;
   }
   else {  /* object is not a table, and/or has a specific "settable" method */
     if (im && ttype(im) != LUA_T_NIL) {
       if (mode == 2) {
-        *(luaD_stack.top+1) = *(luaD_stack.top-1);
-        *(luaD_stack.top) = *(t+1);
-        *(luaD_stack.top-1) = *t;
-        luaD_stack.top += 2;  /* WARNING: caller must assure stack space */
+        *(L->stack.top+1) = *(L->stack.top-1);
+        *(L->stack.top) = *(t+1);
+        *(L->stack.top-1) = *t;
+        L->stack.top += 2;  /* WARNING: caller must assure stack space */
       }
       luaD_callTM(im, 3, 0);
     }
@@ -159,13 +160,13 @@ void luaV_getglobal (TaggedString *ts)
   TObject *value = &ts->u.globalval;
   TObject *im = luaT_getimbyObj(value, IM_GETGLOBAL);
   if (ttype(im) == LUA_T_NIL) {  /* default behavior */
-    *luaD_stack.top++ = *value;
+    *L->stack.top++ = *value;
   }
   else {
-    ttype(luaD_stack.top) = LUA_T_STRING;
-    tsvalue(luaD_stack.top) = ts;
-    luaD_stack.top++;
-    *luaD_stack.top++ = *value;
+    ttype(L->stack.top) = LUA_T_STRING;
+    tsvalue(L->stack.top) = ts;
+    L->stack.top++;
+    *L->stack.top++ = *value;
     luaD_callTM(im, 2, 1);
   }
 }
@@ -176,14 +177,14 @@ void luaV_setglobal (TaggedString *ts)
   TObject *oldvalue = &ts->u.globalval;
   TObject *im = luaT_getimbyObj(oldvalue, IM_SETGLOBAL);
   if (ttype(im) == LUA_T_NIL)  /* default behavior */
-    luaS_rawsetglobal(ts, --luaD_stack.top);
+    luaS_rawsetglobal(ts, --L->stack.top);
   else {
     /* WARNING: caller must assure stack space */
-    TObject newvalue = *(luaD_stack.top-1);
-    ttype(luaD_stack.top-1) = LUA_T_STRING;
-    tsvalue(luaD_stack.top-1) = ts;
-    *luaD_stack.top++ = *oldvalue;
-    *luaD_stack.top++ = newvalue;
+    TObject newvalue = *(L->stack.top-1);
+    ttype(L->stack.top-1) = LUA_T_STRING;
+    tsvalue(L->stack.top-1) = ts;
+    *L->stack.top++ = *oldvalue;
+    *L->stack.top++ = newvalue;
     luaD_callTM(im, 3, 0);
   }
 }
@@ -191,9 +192,9 @@ void luaV_setglobal (TaggedString *ts)
 
 static void call_binTM (IMS event, char *msg)
 {
-  TObject *im = luaT_getimbyObj(luaD_stack.top-2, event);/* try first operand */
+  TObject *im = luaT_getimbyObj(L->stack.top-2, event);/* try first operand */
   if (ttype(im) == LUA_T_NIL) {
-    im = luaT_getimbyObj(luaD_stack.top-1, event);  /* try second operand */
+    im = luaT_getimbyObj(L->stack.top-1, event);  /* try second operand */
     if (ttype(im) == LUA_T_NIL) {
       im = luaT_getim(0, event);  /* try a 'global' i.m. */
       if (ttype(im) == LUA_T_NIL)
@@ -214,8 +215,8 @@ static void call_arith (IMS event)
 static void comparison (lua_Type ttype_less, lua_Type ttype_equal,
                         lua_Type ttype_great, IMS op)
 {
-  TObject *l = luaD_stack.top-2;
-  TObject *r = luaD_stack.top-1;
+  TObject *l = L->stack.top-2;
+  TObject *r = L->stack.top-1;
   int result;
   if (ttype(l) == LUA_T_NUMBER && ttype(r) == LUA_T_NUMBER)
     result = (nvalue(l) < nvalue(r)) ? -1 : (nvalue(l) == nvalue(r)) ? 0 : 1;
@@ -225,16 +226,16 @@ static void comparison (lua_Type ttype_less, lua_Type ttype_equal,
     call_binTM(op, "unexpected type at comparison");
     return;
   }
-  luaD_stack.top--;
-  nvalue(luaD_stack.top-1) = 1;
-  ttype(luaD_stack.top-1) = (result < 0) ? ttype_less :
+  L->stack.top--;
+  nvalue(L->stack.top-1) = 1;
+  ttype(L->stack.top-1) = (result < 0) ? ttype_less :
                                 (result == 0) ? ttype_equal : ttype_great;
 }
 
 
 void luaV_pack (StkId firstel, int nvararg, TObject *tab)
 {
-  TObject *firstelem = luaD_stack.stack+firstel;
+  TObject *firstelem = L->stack.stack+firstel;
   int i;
   if (nvararg < 0) nvararg = 0;
   avalue(tab)  = luaH_new(nvararg+1);  /* +1 for field 'n' */
@@ -260,20 +261,21 @@ static void adjust_varargs (StkId first_extra_arg)
 {
   TObject arg;
   luaV_pack(first_extra_arg,
-       (luaD_stack.top-luaD_stack.stack)-first_extra_arg, &arg);
+       (L->stack.top-L->stack.stack)-first_extra_arg, &arg);
   luaD_adjusttop(first_extra_arg);
-  *luaD_stack.top++ = arg;
+  *L->stack.top++ = arg;
 }
 
 
 
 /*
 ** Execute the given opcode, until a RET. Parameters are between
-** [luaD_stack.stack+base,luaD_stack.top). Returns n such that the the results are between
-** [luaD_stack.stack+n,luaD_stack.top).
+** [stack+base,top). Returns n such that the the results are between
+** [stack+n,top).
 */
 StkId luaV_execute (Closure *cl, StkId base)
 {
+  LState *LL = L;  /* to optimize */
   Byte *pc = cl->consts[0].value.tf->code;
   TObject *consts = cl->consts[0].value.tf->consts;
   if (lua_callhook)
@@ -284,13 +286,13 @@ StkId luaV_execute (Closure *cl, StkId base)
     switch ((OpCode)(aux = *pc++)) {
 
       case PUSHNIL0:
-        ttype(luaD_stack.top++) = LUA_T_NIL;
+        ttype(LL->stack.top++) = LUA_T_NIL;
         break;
 
       case PUSHNIL:
         aux = *pc++;
         do {
-          ttype(luaD_stack.top++) = LUA_T_NIL;
+          ttype(LL->stack.top++) = LUA_T_NIL;
         } while (aux--);
         break;
 
@@ -303,9 +305,9 @@ StkId luaV_execute (Closure *cl, StkId base)
       case PUSHNUMBER0: case PUSHNUMBER1: case PUSHNUMBER2:
         aux -= PUSHNUMBER0;
       pushnumber:
-        ttype(luaD_stack.top) = LUA_T_NUMBER;
-        nvalue(luaD_stack.top) = aux;
-        luaD_stack.top++;
+        ttype(LL->stack.top) = LUA_T_NUMBER;
+        nvalue(LL->stack.top) = aux;
+        LL->stack.top++;
         break;
 
       case PUSHLOCAL:
@@ -315,7 +317,7 @@ StkId luaV_execute (Closure *cl, StkId base)
       case PUSHLOCAL4: case PUSHLOCAL5: case PUSHLOCAL6: case PUSHLOCAL7:
         aux -= PUSHLOCAL0;
       pushlocal:
-        *luaD_stack.top++ = *((luaD_stack.stack+base) + aux);
+        *LL->stack.top++ = *((LL->stack.stack+base) + aux);
         break;
 
       case GETGLOBALW:
@@ -345,7 +347,7 @@ StkId luaV_execute (Closure *cl, StkId base)
       case GETDOTTED4: case GETDOTTED5: case GETDOTTED6: case GETDOTTED7:
         aux -= GETDOTTED0;
       getdotted:
-        *luaD_stack.top++ = consts[aux];
+        *LL->stack.top++ = consts[aux];
         luaV_gettable();
         break;
 
@@ -355,10 +357,10 @@ StkId luaV_execute (Closure *cl, StkId base)
       case PUSHSELF:
         aux = *pc++;
       pushself: {
-        TObject receiver = *(luaD_stack.top-1);
-        *luaD_stack.top++ = consts[aux];
+        TObject receiver = *(LL->stack.top-1);
+        *LL->stack.top++ = consts[aux];
         luaV_gettable();
-        *luaD_stack.top++ = receiver;
+        *LL->stack.top++ = receiver;
         break;
       }
 
@@ -373,7 +375,7 @@ StkId luaV_execute (Closure *cl, StkId base)
       case PUSHCONSTANT6: case PUSHCONSTANT7:
         aux -= PUSHCONSTANT0;
       pushconstant:
-        *luaD_stack.top++ = consts[aux];
+        *LL->stack.top++ = consts[aux];
         break;
 
       case PUSHUPVALUE:
@@ -382,7 +384,7 @@ StkId luaV_execute (Closure *cl, StkId base)
       case PUSHUPVALUE0: case PUSHUPVALUE1:
         aux -= PUSHUPVALUE0;
       pushupvalue:
-        *luaD_stack.top++ = cl->consts[aux+1];
+        *LL->stack.top++ = cl->consts[aux+1];
         break;
 
       case SETLOCAL:
@@ -392,7 +394,7 @@ StkId luaV_execute (Closure *cl, StkId base)
       case SETLOCAL4: case SETLOCAL5: case SETLOCAL6: case SETLOCAL7:
         aux -= SETLOCAL0;
       setlocal:
-        *((luaD_stack.stack+base) + aux) = *(--luaD_stack.top);
+        *((LL->stack.stack+base) + aux) = *(--LL->stack.top);
         break;
 
       case SETGLOBALW:
@@ -409,11 +411,11 @@ StkId luaV_execute (Closure *cl, StkId base)
         break;
 
       case SETTABLE0:
-       luaV_settable(luaD_stack.top-3, 1);
+       luaV_settable(LL->stack.top-3, 1);
        break;
 
       case SETTABLE:
-        luaV_settable(luaD_stack.top-3-(*pc++), 2);
+        luaV_settable(LL->stack.top-3-(*pc++), 2);
         break;
 
       case SETLISTW:
@@ -426,12 +428,12 @@ StkId luaV_execute (Closure *cl, StkId base)
         aux = 0;
       setlist: {
         int n = *(pc++);
-        TObject *arr = luaD_stack.top-n-1;
+        TObject *arr = LL->stack.top-n-1;
         for (; n; n--) {
-          ttype(luaD_stack.top) = LUA_T_NUMBER;
-          nvalue(luaD_stack.top) = n+aux;
-          *(luaH_set (avalue(arr), luaD_stack.top)) = *(luaD_stack.top-1);
-          luaD_stack.top--;
+          ttype(LL->stack.top) = LUA_T_NUMBER;
+          nvalue(LL->stack.top) = n+aux;
+          *(luaH_set (avalue(arr), LL->stack.top)) = *(LL->stack.top-1);
+          LL->stack.top--;
         }
         break;
       }
@@ -442,10 +444,10 @@ StkId luaV_execute (Closure *cl, StkId base)
       case SETMAP:
         aux = *pc++;
       setmap: {
-        TObject *arr = luaD_stack.top-(2*aux)-3;
+        TObject *arr = LL->stack.top-(2*aux)-3;
         do {
-          *(luaH_set (avalue(arr), luaD_stack.top-2)) = *(luaD_stack.top-1);
-          luaD_stack.top-=2;
+          *(luaH_set (avalue(arr), LL->stack.top-2)) = *(LL->stack.top-1);
+          LL->stack.top-=2;
         } while (aux--);
         break;
       }
@@ -456,7 +458,7 @@ StkId luaV_execute (Closure *cl, StkId base)
       case POP0: case POP1:
         aux -= POP0;
       pop:
-        luaD_stack.top -= (aux+1);
+        LL->stack.top -= (aux+1);
         break;
 
       case ARGS:
@@ -478,17 +480,17 @@ StkId luaV_execute (Closure *cl, StkId base)
         aux = *pc++;
       createarray:
         luaC_checkGC();
-        avalue(luaD_stack.top) = luaH_new(aux);
-        ttype(luaD_stack.top) = LUA_T_ARRAY;
-        luaD_stack.top++;
+        avalue(LL->stack.top) = luaH_new(aux);
+        ttype(LL->stack.top) = LUA_T_ARRAY;
+        LL->stack.top++;
         break;
 
       case EQOP: case NEQOP: {
-        int res = luaO_equalObj(luaD_stack.top-2, luaD_stack.top-1);
-        luaD_stack.top--;
+        int res = luaO_equalObj(LL->stack.top-2, LL->stack.top-1);
+        LL->stack.top--;
         if (aux == NEQOP) res = !res;
-        ttype(luaD_stack.top-1) = res ? LUA_T_NUMBER : LUA_T_NIL;
-        nvalue(luaD_stack.top-1) = 1;
+        ttype(LL->stack.top-1) = res ? LUA_T_NUMBER : LUA_T_NIL;
+        nvalue(LL->stack.top-1) = 1;
         break;
       }
 
@@ -509,49 +511,49 @@ StkId luaV_execute (Closure *cl, StkId base)
         break;
 
       case ADDOP: {
-        TObject *l = luaD_stack.top-2;
-        TObject *r = luaD_stack.top-1;
+        TObject *l = LL->stack.top-2;
+        TObject *r = LL->stack.top-1;
         if (tonumber(r) || tonumber(l))
           call_arith(IM_ADD);
         else {
           nvalue(l) += nvalue(r);
-          --luaD_stack.top;
+          --LL->stack.top;
         }
         break;
       }
 
       case SUBOP: {
-        TObject *l = luaD_stack.top-2;
-        TObject *r = luaD_stack.top-1;
+        TObject *l = LL->stack.top-2;
+        TObject *r = LL->stack.top-1;
         if (tonumber(r) || tonumber(l))
           call_arith(IM_SUB);
         else {
           nvalue(l) -= nvalue(r);
-          --luaD_stack.top;
+          --LL->stack.top;
         }
         break;
       }
 
       case MULTOP: {
-        TObject *l = luaD_stack.top-2;
-        TObject *r = luaD_stack.top-1;
+        TObject *l = LL->stack.top-2;
+        TObject *r = LL->stack.top-1;
         if (tonumber(r) || tonumber(l))
           call_arith(IM_MUL);
         else {
           nvalue(l) *= nvalue(r);
-          --luaD_stack.top;
+          --LL->stack.top;
         }
         break;
       }
 
       case DIVOP: {
-        TObject *l = luaD_stack.top-2;
-        TObject *r = luaD_stack.top-1;
+        TObject *l = LL->stack.top-2;
+        TObject *r = LL->stack.top-1;
         if (tonumber(r) || tonumber(l))
           call_arith(IM_DIV);
         else {
           nvalue(l) /= nvalue(r);
-          --luaD_stack.top;
+          --LL->stack.top;
         }
         break;
       }
@@ -561,32 +563,32 @@ StkId luaV_execute (Closure *cl, StkId base)
         break;
 
       case CONCOP: {
-        TObject *l = luaD_stack.top-2;
-        TObject *r = luaD_stack.top-1;
+        TObject *l = LL->stack.top-2;
+        TObject *r = LL->stack.top-1;
         if (tostring(l) || tostring(r))
           call_binTM(IM_CONCAT, "unexpected type for concatenation");
         else {
           tsvalue(l) = strconc(svalue(l), svalue(r));
-          --luaD_stack.top;
+          --LL->stack.top;
         }
         luaC_checkGC();
         break;
       }
 
       case MINUSOP:
-        if (tonumber(luaD_stack.top-1)) {
-          ttype(luaD_stack.top) = LUA_T_NIL;
-          luaD_stack.top++;
+        if (tonumber(LL->stack.top-1)) {
+          ttype(LL->stack.top) = LUA_T_NIL;
+          LL->stack.top++;
           call_arith(IM_UNM);
         }
         else
-          nvalue(luaD_stack.top-1) = - nvalue(luaD_stack.top-1);
+          nvalue(LL->stack.top-1) = - nvalue(LL->stack.top-1);
         break;
 
       case NOTOP:
-        ttype(luaD_stack.top-1) =
-           (ttype(luaD_stack.top-1) == LUA_T_NIL) ? LUA_T_NUMBER : LUA_T_NIL;
-        nvalue(luaD_stack.top-1) = 1;
+        ttype(LL->stack.top-1) =
+           (ttype(LL->stack.top-1) == LUA_T_NIL) ? LUA_T_NUMBER : LUA_T_NIL;
+        nvalue(LL->stack.top-1) = 1;
         break;
 
       case ONTJMPW:
@@ -595,8 +597,8 @@ StkId luaV_execute (Closure *cl, StkId base)
       case ONTJMP:
         aux = *pc++;
       ontjmp:
-        if (ttype(luaD_stack.top-1) != LUA_T_NIL) pc += aux;
-        else luaD_stack.top--;
+        if (ttype(LL->stack.top-1) != LUA_T_NIL) pc += aux;
+        else LL->stack.top--;
         break;
 
       case ONFJMPW:
@@ -605,8 +607,8 @@ StkId luaV_execute (Closure *cl, StkId base)
       case ONFJMP:
         aux = *pc++;
       onfjmp:
-        if (ttype(luaD_stack.top-1) == LUA_T_NIL) pc += aux;
-        else luaD_stack.top--;
+        if (ttype(LL->stack.top-1) == LUA_T_NIL) pc += aux;
+        else LL->stack.top--;
         break;
 
       case JMPW:
@@ -624,7 +626,7 @@ StkId luaV_execute (Closure *cl, StkId base)
       case IFFJMP:
         aux = *pc++;
       iffjmp:
-        if (ttype(--luaD_stack.top) == LUA_T_NIL) pc += aux;
+        if (ttype(--LL->stack.top) == LUA_T_NIL) pc += aux;
         break;
 
       case IFTUPJMPW:
@@ -633,7 +635,7 @@ StkId luaV_execute (Closure *cl, StkId base)
       case IFTUPJMP:
         aux = *pc++;
       iftupjmp:
-        if (ttype(--luaD_stack.top) != LUA_T_NIL) pc -= aux;
+        if (ttype(--LL->stack.top) != LUA_T_NIL) pc -= aux;
         break;
 
       case IFFUPJMPW:
@@ -642,7 +644,7 @@ StkId luaV_execute (Closure *cl, StkId base)
       case IFFUPJMP:
         aux = *pc++;
       iffupjmp:
-        if (ttype(--luaD_stack.top) == LUA_T_NIL) pc -= aux;
+        if (ttype(--LL->stack.top) == LUA_T_NIL) pc -= aux;
         break;
 
       case CLOSURE:
@@ -661,13 +663,13 @@ StkId luaV_execute (Closure *cl, StkId base)
       case CALLFUNC0: case CALLFUNC1:
         aux -= CALLFUNC0;
       callfunc: {
-        StkId newBase = (luaD_stack.top-luaD_stack.stack)-(*pc++);
+        StkId newBase = (LL->stack.top-LL->stack.stack)-(*pc++);
         luaD_call(newBase, aux);
         break;
       }
 
       case ENDCODE:
-        luaD_stack.top = luaD_stack.stack + base;
+        LL->stack.top = LL->stack.stack + base;
         /* goes through */
       case RETCODE:
         if (lua_callhook)
@@ -680,13 +682,13 @@ StkId luaV_execute (Closure *cl, StkId base)
       case SETLINE:
         aux = *pc++;
       setline:
-        if ((luaD_stack.stack+base-1)->ttype != LUA_T_LINE) {
+        if ((LL->stack.stack+base-1)->ttype != LUA_T_LINE) {
           /* open space for LINE value */
-          luaD_openstack((luaD_stack.top-luaD_stack.stack)-base);
+          luaD_openstack((LL->stack.top-LL->stack.stack)-base);
           base++;
-          (luaD_stack.stack+base-1)->ttype = LUA_T_LINE;
+          (LL->stack.stack+base-1)->ttype = LUA_T_LINE;
         }
-        (luaD_stack.stack+base-1)->value.i = aux;
+        (LL->stack.stack+base-1)->value.i = aux;
         if (lua_linehook)
           luaD_lineHook(aux);
         break;
diff --git a/makefile b/makefile
index 6858543e..234cf701 100644
--- a/makefile
+++ b/makefile
@@ -1,5 +1,5 @@
 #
-## $Id: makefile,v 1.4 1997/10/24 17:17:24 roberto Exp roberto $
+## $Id: makefile,v 1.5 1997/11/07 15:09:49 roberto Exp roberto $
 ## Makefile
 ## See Copyright Notice in lua.h
 #
@@ -18,7 +18,7 @@
 # define LUA_COMPAT2_5=0 if yous system does not need to be compatible with
 # version 2.5 (or older)
 
-CONFIG = -DPOPEN -D_POSIX_SOURCE
+CONFIG = -DPOPEN -D_POSIX_SOURCE -DLUA_COMPAT2_5=0
 #CONFIG = -DLUA_COMPAT2_5=0 -DOLD_ANSI -DDEBUG
 
 
@@ -43,6 +43,7 @@ LUAOBJS = \
 	llex.o \
 	lmem.o \
 	lobject.o \
+	lstate.o \
 	lstx.o \
 	lstring.o \
 	ltable.o \
@@ -90,32 +91,34 @@ clear	:
 %.c : RCS/%.c,v
 	co $@
 
-lapi.o: lapi.c lapi.h lua.h lobject.h lauxlib.h lbuiltin.h ldo.h \
- lfunc.h lgc.h llex.h lzio.h lmem.h lstring.h ltable.h ltm.h \
- luadebug.h lvm.h
+
+lapi.o: lapi.c lapi.h lua.h lobject.h lauxlib.h ldo.h lstate.h lfunc.h \
+ lgc.h lmem.h lstring.h ltable.h ltm.h luadebug.h lvm.h
 lauxlib.o: lauxlib.c lauxlib.h lua.h luadebug.h
 lbuiltin.o: lbuiltin.c lapi.h lua.h lobject.h lauxlib.h lbuiltin.h \
- ldo.h lfunc.h lmem.h lstring.h ltable.h ltm.h
-ldo.o: ldo.c ldo.h lobject.h lua.h lfunc.h lgc.h lmem.h lparser.h \
- lzio.h ltm.h luadebug.h lundump.h lvm.h
-lfunc.o: lfunc.c lfunc.h lobject.h lua.h lmem.h
-lgc.o: lgc.c ldo.h lobject.h lua.h lfunc.h lgc.h lmem.h lstring.h \
- ltable.h ltm.h
+ ldo.h lstate.h lfunc.h lmem.h lstring.h ltable.h ltm.h
+ldo.o: ldo.c ldo.h lobject.h lua.h lstate.h lfunc.h lgc.h lmem.h \
+ lparser.h lzio.h ltm.h luadebug.h lundump.h lvm.h
+lfunc.o: lfunc.c lfunc.h lobject.h lua.h lmem.h lstate.h
+lgc.o: lgc.c ldo.h lobject.h lua.h lstate.h lfunc.h lgc.h lmem.h \
+ lstring.h ltable.h ltm.h
 liolib.o: liolib.c lauxlib.h lua.h luadebug.h lualib.h
-llex.o: llex.c llex.h lobject.h lua.h lzio.h lmem.h lparser.h \
+llex.o: llex.c llex.h lobject.h lua.h lzio.h lmem.h lparser.h lstate.h \
  lstring.h lstx.h luadebug.h
 lmathlib.o: lmathlib.c lauxlib.h lua.h lualib.h
-lmem.o: lmem.c lmem.h lua.h
+lmem.o: lmem.c lmem.h lstate.h lobject.h lua.h
 lobject.o: lobject.c lobject.h lua.h
-lstring.o: lstring.c lmem.h lobject.h lua.h lstring.h
+lstate.o: lstate.c lbuiltin.h ldo.h lobject.h lua.h lstate.h llex.h \
+ lzio.h lmem.h lstring.h ltable.h ltm.h
+lstring.o: lstring.c lmem.h lobject.h lua.h lstate.h lstring.h
 lstrlib.o: lstrlib.c lauxlib.h lua.h lualib.h
-lstx.o: lstx.c lauxlib.h lua.h ldo.h lobject.h lfunc.h llex.h lzio.h \
- lmem.h lopcodes.h lparser.h lstring.h luadebug.h
-ltable.o: ltable.c lauxlib.h lua.h lmem.h lobject.h ltable.h
-ltm.o: ltm.c lauxlib.h lua.h ldo.h lobject.h lmem.h ltm.h lapi.h
+lstx.o: lstx.c lauxlib.h lua.h ldo.h lobject.h lstate.h lfunc.h llex.h \
+ lzio.h lmem.h lopcodes.h lparser.h lstring.h luadebug.h
+ltable.o: ltable.c lauxlib.h lua.h lmem.h lobject.h lstate.h ltable.h
+ltm.o: ltm.c lauxlib.h lua.h lmem.h lobject.h lstate.h ltm.h lapi.h
 lua.o: lua.c lua.h luadebug.h lualib.h
 lundump.o: lundump.c lauxlib.h lua.h lfunc.h lobject.h lmem.h \
  lstring.h lundump.h lzio.h
-lvm.o: lvm.c lauxlib.h lua.h ldo.h lobject.h lfunc.h lgc.h lmem.h \
- lopcodes.h lstring.h ltable.h ltm.h luadebug.h lvm.h
+lvm.o: lvm.c lauxlib.h lua.h ldo.h lobject.h lstate.h lfunc.h lgc.h \
+ lmem.h lopcodes.h lstring.h ltable.h ltm.h luadebug.h lvm.h
 lzio.o: lzio.c lzio.h