many details + code redistribution

13 files changed, 170 insertions, 529 deletions

diff --git a/lapi.c b/lapi.c
index 953c066e..caeb6318 100644
--- a/lapi.c
+++ b/lapi.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.c,v 1.62 1999/12/02 16:24:45 roberto Exp roberto $
+** $Id: lapi.c,v 1.63 1999/12/06 12:03:45 roberto Exp roberto $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
@@ -22,16 +22,15 @@
 #include "ltable.h"
 #include "ltm.h"
 #include "lua.h"
-#include "luadebug.h"
 #include "lvm.h"
 
 
 const char lua_ident[] = "$Lua: " LUA_VERSION " " LUA_COPYRIGHT " $\n"
-                               "$Authors:  " LUA_AUTHORS " $";
+                               "$Authors: " LUA_AUTHORS " $";
 
 
 
-static lua_Type normalized_type (const TObject *o) {
+lua_Type luaA_normalizedtype (const TObject *o) {
   int t = ttype(o);
   switch (t) {
     case LUA_T_PMARK:
@@ -46,24 +45,24 @@ static lua_Type normalized_type (const TObject *o) {
 }
 
 
-static void set_normalized (TObject *d, const TObject *s) {
+void luaA_setnormalized (TObject *d, const TObject *s) {
   d->value = s->value;
-  d->ttype = normalized_type(s);
+  d->ttype = luaA_normalizedtype(s);
 }
 
 
-static const TObject *luaA_protovalue (const TObject *o) {
-  return (normalized_type(o) == LUA_T_CLOSURE) ?  protovalue(o) : o;
+const TObject *luaA_protovalue (const TObject *o) {
+  return (luaA_normalizedtype(o) == LUA_T_CLOSURE) ?  protovalue(o) : o;
 }
 
 
-static void checkCparams (lua_State *L, int nParams) {
+void luaA_checkCparams (lua_State *L, int nParams) {
   if (nParams > L->top-L->Cstack.base)
     lua_error(L, "API error - wrong number of arguments in C2lua stack");
 }
 
 
-static lua_Object put_luaObject (lua_State *L, const TObject *o) {
+lua_Object luaA_putluaObject (lua_State *L, const TObject *o) {
   luaD_openstack(L, L->Cstack.base);
   *L->Cstack.base++ = *o;
   return L->Cstack.base-1;
@@ -86,7 +85,7 @@ static void top2LC (lua_State *L, int n) {
 
 
 lua_Object lua_pop (lua_State *L) {
-  checkCparams(L, 1);
+  luaA_checkCparams(L, 1);
   return luaA_putObjectOnTop(L);
 }
 
@@ -106,19 +105,19 @@ int lua_callfunction (lua_State *L, lua_Object function) {
     return 1;
   else {
     luaD_openstack(L, L->Cstack.base);
-    set_normalized(L->Cstack.base, function);
+    luaA_setnormalized(L->Cstack.base, function);
     return luaD_protectedrun(L);
   }
 }
 
 
 lua_Object lua_gettagmethod (lua_State *L, int tag, const char *event) {
-  return put_luaObject(L, luaT_gettagmethod(L, tag, event));
+  return luaA_putluaObject(L, luaT_gettagmethod(L, tag, event));
 }
 
 
 lua_Object lua_settagmethod (lua_State *L, int tag, const char *event) {
-  checkCparams(L, 1);
+  luaA_checkCparams(L, 1);
   luaT_settagmethod(L, tag, event, L->top-1);
   return luaA_putObjectOnTop(L);
 }
@@ -126,7 +125,7 @@ lua_Object lua_settagmethod (lua_State *L, int tag, const char *event) {
 
 lua_Object lua_seterrormethod (lua_State *L) {
   lua_Object temp;
-  checkCparams(L, 1);
+  luaA_checkCparams(L, 1);
   temp = lua_getglobal(L, "_ERRORMESSAGE");
   lua_setglobal(L, "_ERRORMESSAGE");
   return temp;
@@ -134,14 +133,14 @@ lua_Object lua_seterrormethod (lua_State *L) {
 
 
 lua_Object lua_gettable (lua_State *L) {
-  checkCparams(L, 2);
+  luaA_checkCparams(L, 2);
   luaV_gettable(L);
   return luaA_putObjectOnTop(L);
 }
 
 
 lua_Object lua_rawgettable (lua_State *L) {
-  checkCparams(L, 2);
+  luaA_checkCparams(L, 2);
   if (ttype(L->top-2) != LUA_T_ARRAY)
     lua_error(L, "indexed expression not a table in rawgettable");
   *(L->top-2) = *luaH_get(L, avalue(L->top-2), L->top-1);
@@ -151,14 +150,14 @@ lua_Object lua_rawgettable (lua_State *L) {
 
 
 void lua_settable (lua_State *L) {
-  checkCparams(L, 3);
+  luaA_checkCparams(L, 3);
   luaV_settable(L, L->top-3);
   L->top -= 2;  /* pop table and index */
 }
 
 
 void lua_rawsettable (lua_State *L) {
-  checkCparams(L, 3);
+  luaA_checkCparams(L, 3);
   luaV_rawsettable(L, L->top-3);
 }
 
@@ -168,12 +167,12 @@ lua_Object lua_createtable (lua_State *L) {
   luaC_checkGC(L);
   avalue(&o) = luaH_new(L, 0);
   ttype(&o) = LUA_T_ARRAY;
-  return put_luaObject(L, &o);
+  return luaA_putluaObject(L, &o);
 }
 
 
 lua_Object lua_getglobal (lua_State *L, const char *name) {
-  luaD_checkstack(L, 2);  /* may need that to call T.M. */
+  luaD_checkstack(L, 2);  /* may need that to call a tag method */
   luaV_getglobal(L, luaS_assertglobalbyname(L, name));
   return luaA_putObjectOnTop(L);
 }
@@ -181,27 +180,27 @@ lua_Object lua_getglobal (lua_State *L, const char *name) {
 
 lua_Object lua_rawgetglobal (lua_State *L, const char *name) {
   GlobalVar *gv = luaS_assertglobalbyname(L, name);
-  return put_luaObject(L, &gv->value);
+  return luaA_putluaObject(L, &gv->value);
 }
 
 
 void lua_setglobal (lua_State *L, const char *name) {
-  checkCparams(L, 1);
-  luaD_checkstack(L, 2);  /* may need that to call T.M. */
+  luaA_checkCparams(L, 1);
+  luaD_checkstack(L, 2);  /* may need that to call a tag method */
   luaV_setglobal(L, luaS_assertglobalbyname(L, name));
 }
 
 
 void lua_rawsetglobal (lua_State *L, const char *name) {
   GlobalVar *gv = luaS_assertglobalbyname(L, name);
-  checkCparams(L, 1);
+  luaA_checkCparams(L, 1);
   gv->value = *(--L->top);
 }
 
 
 const char *lua_type (lua_State *L, lua_Object o) {
   UNUSED(L);
-  return (o == LUA_NOOBJECT) ? "NOOBJECT" : luaO_typename(L, o);
+  return (o == LUA_NOOBJECT) ? "NOOBJECT" : luaO_typename(o);
 }
 
 int lua_isnil (lua_State *L, lua_Object o) {
@@ -220,7 +219,6 @@ int lua_isuserdata (lua_State *L, lua_Object o) {
 }
 
 int lua_iscfunction (lua_State *L, lua_Object o) {
-  UNUSED(L);
   return (lua_tag(L, o) == LUA_T_CPROTO);
 }
 
@@ -261,7 +259,6 @@ const char *lua_getstring (lua_State *L, lua_Object obj) {
 }
 
 long lua_strlen (lua_State *L, lua_Object obj) {
-  UNUSED(L);
   if (obj == LUA_NOOBJECT || tostring(L, obj))
     return 0L;
   else return (tsvalue(obj)->u.s.len);
@@ -309,7 +306,7 @@ void lua_pushstring (lua_State *L, const char *s) {
 void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
   if (fn == NULL)
     lua_error(L, "API error - attempt to push a NULL Cfunction");
-  checkCparams(L, n);
+  luaA_checkCparams(L, n);
   ttype(L->top) = LUA_T_CPROTO;
   fvalue(L->top) = fn;
   incr_top;
@@ -334,7 +331,7 @@ void luaA_pushobject (lua_State *L, const TObject *o) {
 void lua_pushobject (lua_State *L, lua_Object o) {
   if (o == LUA_NOOBJECT)
     lua_error(L, "API error - attempt to push a NOOBJECT");
-  set_normalized(L->top, o);
+  luaA_setnormalized(L->top, o);
   incr_top;
 }
 
@@ -368,7 +365,7 @@ int lua_tag (lua_State *L, lua_Object o) {
 
 
 void lua_settag (lua_State *L, int tag) {
-  checkCparams(L, 1);
+  luaA_checkCparams(L, 1);
   luaT_realtag(L, tag);
   switch (ttype(L->top-1)) {
     case LUA_T_ARRAY:
@@ -379,7 +376,7 @@ void lua_settag (lua_State *L, int tag) {
       break;
     default:
       luaL_verror(L, "cannot change the tag of a %.20s",
-                  luaO_typename(L, L->top-1));
+                  luaO_typename(L->top-1));
   }
   L->top--;
 }
@@ -442,187 +439,3 @@ int lua_next (lua_State *L, lua_Object t, int i) {
 }
 
 
-
-/*
-** {======================================================
-** To manipulate some state information
-** =======================================================
-*/
-
-
-
-lua_LHFunction lua_setlinehook (lua_State *L, lua_LHFunction func) {
-  lua_LHFunction old = L->linehook;
-  L->linehook = func;
-  return old;
-}
-
-lua_CHFunction lua_setcallhook (lua_State *L, lua_CHFunction func) {
-  lua_CHFunction old = L->callhook;
-  L->callhook = func;
-  return old;
-}
-
-int lua_setdebug (lua_State *L, int debug) {
-  int old = L->debug;
-  L->debug = debug;
-  return old;
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Debug interface
-** =======================================================
-*/
-
-
-lua_Function lua_stackedfunction (lua_State *L, int level) {
-  int i;
-  for (i = (L->top-1)-L->stack; i>=0; i--) {
-    int t = L->stack[i].ttype;
-    if (t == LUA_T_CLMARK || t == LUA_T_PMARK || t == LUA_T_CMARK)
-      if (level-- == 0)
-        return L->stack+i;
-  }
-  return LUA_NOOBJECT;
-}
-
-
-int lua_nups (lua_State *L, lua_Function f) {
-  UNUSED(L);
-  return (!f || normalized_type(f) != LUA_T_CLOSURE) ? 0 : f->value.cl->nelems;
-}
-
-
-int lua_currentline (lua_State *L, lua_Function f) {
-  return (f+1 < L->top && (f+1)->ttype == LUA_T_LINE) ? (f+1)->value.i : -1;
-}
-
-
-lua_Object lua_getlocal (lua_State *L, lua_Function f, int local_number,
-                         const char **name) {
-  /* check whether `f' is a Lua function */
-  if (lua_tag(L, f) != LUA_T_PROTO)
-    return LUA_NOOBJECT;
-  else {
-    TProtoFunc *fp = luaA_protovalue(f)->value.tf;
-    *name = luaF_getlocalname(fp, local_number, lua_currentline(L, f));
-    if (*name) {
-      /* if "*name", there must be a LUA_T_LINE */
-      /* therefore, f+2 points to function base */
-      return put_luaObject(L, (f+2)+(local_number-1));
-    }
-    else
-      return LUA_NOOBJECT;
-  }
-}
-
-
-int lua_setlocal (lua_State *L, lua_Function f, int local_number) {
-  /* check whether `f' is a Lua function */
-  if (lua_tag(L, f) != LUA_T_PROTO)
-    return 0;
-  else {
-    TProtoFunc *fp = luaA_protovalue(f)->value.tf;
-    const char *name = luaF_getlocalname(fp, local_number,
-                                         lua_currentline(L, f));
-    checkCparams(L, 1);
-    --L->top;
-    if (name) {
-      /* if "name", there must be a LUA_T_LINE */
-      /* therefore, f+2 points to function base */
-      *((f+2)+(local_number-1)) = *L->top;
-      return 1;
-    }
-    else
-      return 0;
-  }
-}
-
-
-void lua_funcinfo (lua_State *L, lua_Object func,
-                   const char **source, int *linedefined) {
-  if (!lua_isfunction(L, func))
-    lua_error(L, "API error - `funcinfo' called with a non-function value");
-  else {
-    const TObject *f = luaA_protovalue(func);
-    if (normalized_type(f) == LUA_T_PROTO) {
-      *source = tfvalue(f)->source->str;
-      *linedefined = tfvalue(f)->lineDefined;
-    }
-    else {
-      *source = "(C)";
-      *linedefined = -1;
-    }
-  }
-}
-
-
-static int checkfunc (lua_State *L, TObject *o) {
-  return luaO_equalObj(o, L->top);
-}
-
-
-const char *lua_getobjname (lua_State *L, lua_Object o, const char **name) {
-  /* try to find a name for given function */
-  GlobalVar *g;
-  set_normalized(L->top, o); /* to be used by `checkfunc' */
-  for (g=L->rootglobal; g; g=g->next) {
-    if (checkfunc(L, &g->value)) {
-      *name = g->name->str;
-      return "global";
-    }
-  }
-  /* not found: try tag methods */
-  if ((*name = luaT_travtagmethods(L, checkfunc)) != NULL)
-    return "tag-method";
-  else return "";  /* not found at all */
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** BLOCK mechanism
-** =======================================================
-*/
-
-
-void lua_beginblock (lua_State *L) {
-  luaM_growvector(L, L->Cblocks, L->numCblocks, 1, struct C_Lua_Stack,
-                  "too many nested blocks", L->stacksize);
-  L->Cblocks[L->numCblocks] = L->Cstack;
-  L->numCblocks++;
-}
-
-void lua_endblock (lua_State *L) {
-  if (L->numCblocks <= 0)
-    lua_error(L, "API error - no block to end");
-  --L->numCblocks;
-  L->Cstack = L->Cblocks[L->numCblocks];
-  L->top = L->Cstack.base;
-}
-
-
-
-int lua_ref (lua_State *L, int lock) {
-  int ref;
-  checkCparams(L, 1);
-  ref = luaR_ref(L, L->top-1, lock);
-  L->top--;
-  return ref;
-}
-
-
-
-lua_Object lua_getref (lua_State *L, int ref) {
-  const TObject *o = luaR_getref(L, ref);
-  return (o ? put_luaObject(L, o) : LUA_NOOBJECT);
-}
-
-/* }====================================================== */
-
diff --git a/lapi.h b/lapi.h
index 96969134..6a69dd15 100644
--- a/lapi.h
+++ b/lapi.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.h,v 1.9 1999/11/22 13:12:07 roberto Exp roberto $
+** $Id: lapi.h,v 1.10 1999/12/02 16:24:45 roberto Exp roberto $
 ** Auxiliary functions from Lua API
 ** See Copyright Notice in lua.h
 */
@@ -11,9 +11,14 @@
 #include "lobject.h"
 
 
+lua_Type luaA_normalizedtype (const TObject *o);
+void luaA_setnormalized (TObject *d, const TObject *s);
+void luaA_checkCparams (lua_State *L, int nParams);
+const TObject *luaA_protovalue (const TObject *o);
 void luaA_pushobject (lua_State *L, const TObject *o);
 GlobalVar *luaA_nextvar (lua_State *L, TaggedString *g);
 int luaA_next (lua_State *L, const Hash *t, int i);
+lua_Object luaA_putluaObject (lua_State *L, const TObject *o);
 lua_Object luaA_putObjectOnTop (lua_State *L);
 
 #endif
diff --git a/lbuiltin.c b/lbuiltin.c
index 77e1bc56..a28db531 100644
--- a/lbuiltin.c
+++ b/lbuiltin.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lbuiltin.c,v 1.82 1999/12/06 11:42:18 roberto Exp roberto $
+** $Id: lbuiltin.c,v 1.83 1999/12/07 12:05:34 roberto Exp roberto $
 ** Built-in functions
 ** See Copyright Notice in lua.h
 */
@@ -29,6 +29,17 @@
 
 
 
+#ifdef DEBUG
+/*
+** function defined in ltests.c, to open some internal-test functions
+*/
+void luaB_opentests (lua_State *L);
+#else
+#define luaB_opentests(L)       /* do nothing */
+#endif
+
+
+
 /*
 ** {======================================================
 ** Auxiliary functions
@@ -87,7 +98,7 @@ static Hash *gettable (lua_State *L, int arg) {
 ** If your system does not support "stderr", redefine this function, or
 ** redefine _ERRORMESSAGE so that it won't need _ALERT.
 */
-static void luaB_alert (lua_State *L) {
+void luaB_alert (lua_State *L) {
   fputs(luaL_check_string(L, 1), stderr);
 }
 
@@ -96,7 +107,7 @@ static void luaB_alert (lua_State *L) {
 ** Standard implementation of _ERRORMESSAGE.
 ** The library "iolib" redefines _ERRORMESSAGE for better error information.
 */
-static void error_message (lua_State *L) {
+void luaB_ERRORMESSAGE (lua_State *L) {
   lua_Object al = lua_rawgetglobal(L, "_ALERT");
   if (lua_isfunction(L, al)) {  /* avoid error loop if _ALERT is not defined */
     char buff[600];
@@ -117,7 +128,7 @@ static void error_message (lua_State *L) {
 #define MAXPRINT        40  /* arbitrary limit */
 #endif
 
-static void luaB_print (lua_State *L) {
+void luaB_print (lua_State *L) {
   lua_Object args[MAXPRINT];
   lua_Object obj;
   int n = 0;
@@ -140,7 +151,7 @@ static void luaB_print (lua_State *L) {
 }
 
 
-static void luaB_tonumber (lua_State *L) {
+void luaB_tonumber (lua_State *L) {
   int base = luaL_opt_int(L, 2, 10);
   if (base == 10) {  /* standard conversion */
     lua_Object o = lua_getparam(L, 1);
@@ -161,66 +172,66 @@ static void luaB_tonumber (lua_State *L) {
 }
 
 
-static void luaB_error (lua_State *L) {
+void luaB_error (lua_State *L) {
   lua_error(L, lua_getstring(L, lua_getparam(L, 1)));
 }
 
-static void luaB_setglobal (lua_State *L) {
+void luaB_setglobal (lua_State *L) {
   const char *n = luaL_check_string(L, 1);
   lua_Object value = luaL_nonnullarg(L, 2);
   lua_pushobject(L, value);
   lua_setglobal(L, n);
 }
 
-static void luaB_rawsetglobal (lua_State *L) {
+void luaB_rawsetglobal (lua_State *L) {
   const char *n = luaL_check_string(L, 1);
   lua_Object value = luaL_nonnullarg(L, 2);
   lua_pushobject(L, value);
   lua_rawsetglobal(L, n);
 }
 
-static void luaB_getglobal (lua_State *L) {
+void luaB_getglobal (lua_State *L) {
   lua_pushobject(L, lua_getglobal(L, luaL_check_string(L, 1)));
 }
 
-static void luaB_rawgetglobal (lua_State *L) {
+void luaB_rawgetglobal (lua_State *L) {
   lua_pushobject(L, lua_rawgetglobal(L, luaL_check_string(L, 1)));
 }
 
-static void luaB_tag (lua_State *L) {
+void luaB_tag (lua_State *L) {
   lua_pushnumber(L, lua_tag(L, lua_getparam(L, 1)));
 }
 
-static void luaB_settag (lua_State *L) {
+void luaB_settag (lua_State *L) {
   lua_Object o = luaL_tablearg(L, 1);
   lua_pushobject(L, o);
   lua_settag(L, luaL_check_int(L, 2));
   lua_pushobject(L, o);  /* return first argument */
 }
 
-static void luaB_newtag (lua_State *L) {
+void luaB_newtag (lua_State *L) {
   lua_pushnumber(L, lua_newtag(L));
 }
 
-static void luaB_copytagmethods (lua_State *L) {
+void luaB_copytagmethods (lua_State *L) {
   lua_pushnumber(L, lua_copytagmethods(L, luaL_check_int(L, 1),
                                     luaL_check_int(L, 2)));
 }
 
-static void luaB_rawgettable (lua_State *L) {
+void luaB_rawgettable (lua_State *L) {
   lua_pushobject(L, luaL_nonnullarg(L, 1));
   lua_pushobject(L, luaL_nonnullarg(L, 2));
   lua_pushobject(L, lua_rawgettable(L));
 }
 
-static void luaB_rawsettable (lua_State *L) {
+void luaB_rawsettable (lua_State *L) {
   lua_pushobject(L, luaL_nonnullarg(L, 1));
   lua_pushobject(L, luaL_nonnullarg(L, 2));
   lua_pushobject(L, luaL_nonnullarg(L, 3));
   lua_rawsettable(L);
 }
 
-static void luaB_settagmethod (lua_State *L) {
+void luaB_settagmethod (lua_State *L) {
   int tag = luaL_check_int(L, 1);
   const char *event = luaL_check_string(L, 2);
   lua_Object nf = luaL_nonnullarg(L, 3);
@@ -232,23 +243,23 @@ static void luaB_settagmethod (lua_State *L) {
   lua_pushobject(L, lua_settagmethod(L, tag, event));
 }
 
-static void luaB_gettagmethod (lua_State *L) {
+void luaB_gettagmethod (lua_State *L) {
   lua_pushobject(L, lua_gettagmethod(L, luaL_check_int(L, 1),
                                         luaL_check_string(L, 2)));
 }
 
-static void luaB_seterrormethod (lua_State *L) {
+void luaB_seterrormethod (lua_State *L) {
   lua_Object nf = luaL_functionarg(L, 1);
   lua_pushobject(L, nf);
   lua_pushobject(L, lua_seterrormethod(L));
 }
 
-static void luaB_collectgarbage (lua_State *L) {
+void luaB_collectgarbage (lua_State *L) {
   lua_pushnumber(L, lua_collectgarbage(L, luaL_opt_int(L, 1, 0)));
 }
 
 
-static void luaB_type (lua_State *L) {
+void luaB_type (lua_State *L) {
   lua_Object o = luaL_nonnullarg(L, 1);
   lua_pushstring(L, lua_type(L, o));
 }
@@ -270,7 +281,7 @@ static void passresults (lua_State *L) {
     lua_pushuserdata(L, NULL);  /* at least one result to signal no errors */
 }
 
-static void luaB_dostring (lua_State *L) {
+void luaB_dostring (lua_State *L) {
   long l;
   const char *s = luaL_check_lstr(L, 1, &l);
   if (*s == ID_CHUNK)
@@ -281,7 +292,7 @@ static void luaB_dostring (lua_State *L) {
 }
 
 
-static void luaB_dofile (lua_State *L) {
+void luaB_dofile (lua_State *L) {
   const char *fname = luaL_opt_string(L, 1, NULL);
   if (lua_dofile(L, fname) == 0)
     passresults(L);
@@ -289,7 +300,7 @@ static void luaB_dofile (lua_State *L) {
 }
 
 
-static void luaB_call (lua_State *L) {
+void luaB_call (lua_State *L) {
   lua_Object f = luaL_nonnullarg(L, 1);
   const Hash *arg = gettable(L, 2);
   const char *options = luaL_opt_string(L, 3, "");
@@ -328,7 +339,7 @@ static void luaB_call (lua_State *L) {
 }
 
 
-static void luaB_nextvar (lua_State *L) {
+void luaB_nextvar (lua_State *L) {
   lua_Object o = luaL_nonnullarg(L, 1);
   TaggedString *g;
   if (ttype(o) == LUA_T_NIL)
@@ -342,7 +353,7 @@ static void luaB_nextvar (lua_State *L) {
 }
 
 
-static void luaB_next (lua_State *L) {
+void luaB_next (lua_State *L) {
   const Hash *a = gettable(L, 1);
   lua_Object k = luaL_nonnullarg(L, 2);
   int i;  /* will get first element after `i' */
@@ -357,7 +368,7 @@ static void luaB_next (lua_State *L) {
 }
 
 
-static void luaB_tostring (lua_State *L) {
+void luaB_tostring (lua_State *L) {
   lua_Object o = lua_getparam(L, 1);
   char buff[64];
   switch (ttype(o)) {
@@ -405,14 +416,14 @@ static void luaB_tostring (lua_State *L) {
 ** =======================================================
 */
 
-static void luaB_assert (lua_State *L) {
+void luaB_assert (lua_State *L) {
   lua_Object p = lua_getparam(L, 1);
   if (p == LUA_NOOBJECT || lua_isnil(L, p))
     luaL_verror(L, "assertion failed!  %.90s", luaL_opt_string(L, 2, ""));
 }
 
 
-static void luaB_foreachi (lua_State *L) {
+void luaB_foreachi (lua_State *L) {
   const Hash *t = gettable(L, 1);
   int n = (int)getnarg(L, t);
   int i;
@@ -430,7 +441,7 @@ static void luaB_foreachi (lua_State *L) {
 }
 
 
-static void luaB_foreach (lua_State *L) {
+void luaB_foreach (lua_State *L) {
   const Hash *a = gettable(L, 1);
   lua_Object f = luaL_functionarg(L, 2);
   int i;
@@ -450,7 +461,7 @@ static void luaB_foreach (lua_State *L) {
 }
 
 
-static void luaB_foreachvar (lua_State *L) {
+void luaB_foreachvar (lua_State *L) {
   lua_Object f = luaL_functionarg(L, 1);
   GlobalVar *gv;
   luaD_checkstack(L, 4);  /* for extra var name, f, var name, and globalval */
@@ -472,12 +483,12 @@ static void luaB_foreachvar (lua_State *L) {
 }
 
 
-static void luaB_getn (lua_State *L) {
+void luaB_getn (lua_State *L) {
   lua_pushnumber(L, getnarg(L, gettable(L, 1)));
 }
 
 
-static void luaB_tinsert (lua_State *L) {
+void luaB_tinsert (lua_State *L) {
   Hash *a = gettable(L, 1);
   lua_Object v = lua_getparam(L, 3);
   int n = (int)getnarg(L, a);
@@ -495,7 +506,7 @@ static void luaB_tinsert (lua_State *L) {
 }
 
 
-static void luaB_tremove (lua_State *L) {
+void luaB_tremove (lua_State *L) {
   Hash *a = gettable(L, 1);
   int n = (int)getnarg(L, a);
   int pos = luaL_opt_int(L, 2, n);
@@ -583,7 +594,7 @@ static void auxsort (lua_State *L, Hash *a, int l, int u, lua_Object f) {
   L->top--;  /* remove pivot from stack */
 }
 
-static void luaB_sort (lua_State *L) {
+void luaB_sort (lua_State *L) {
   lua_Object t = lua_getparam(L, 1);
   Hash *a = gettable(L, 1);
   int n = (int)getnarg(L, a);
@@ -601,255 +612,9 @@ static void luaB_sort (lua_State *L) {
 /* }====================================================== */
 
 
-
-#ifdef DEBUG
-/*
-** {======================================================
-** some DEBUG functions
-** (for internal debugging of the Lua implementation)
-** =======================================================
-*/
-
-static void mem_query (lua_State *L) {
-  lua_pushnumber(L, totalmem);
-  lua_pushnumber(L, numblocks);
-}
-
-
-static void hash_query (lua_State *L) {
-  lua_Object o = luaL_nonnullarg(L, 1);
-  if (lua_getparam(L, 2) == LUA_NOOBJECT) {
-    luaL_arg_check(L, ttype(o) == LUA_T_STRING, 1, "string expected");
-    lua_pushnumber(L, tsvalue(o)->hash);
-  }
-  else {
-    const Hash *t = avalue(luaL_tablearg(L, 2));
-    lua_pushnumber(L, luaH_mainposition(t, o) - t->node);
-  }
-}
-
-
-static void table_query (lua_State *L) {
-  const Hash *t = avalue(luaL_tablearg(L, 1));
-  int i = luaL_opt_int(L, 2, -1);
-  if (i == -1) {
-    lua_pushnumber(L, t->size);
-    lua_pushnumber(L, t->firstfree - t->node);
-  }
-  else if (i < t->size) {
-    luaA_pushobject(L, &t->node[i].key);
-    luaA_pushobject(L, &t->node[i].val);
-    if (t->node[i].next)
-      lua_pushnumber(L, t->node[i].next - t->node);
-  }
-}
-
-
-static void query_strings (lua_State *L) {
-  int h = luaL_check_int(L, 1) - 1;
-  int s = luaL_opt_int(L, 2, 0) - 1;
-  if (s==-1) {
-    if (h < NUM_HASHS) {
-      lua_pushnumber(L, L->string_root[h].nuse);
-      lua_pushnumber(L, L->string_root[h].size);
-    }
-  }
-  else {
-    TaggedString *ts = L->string_root[h].hash[s];
-    for (ts = L->string_root[h].hash[s]; ts; ts = ts->nexthash) {
-      if (ts->constindex == -1) lua_pushstring(L, "<USERDATA>");
-      else lua_pushstring(L, ts->str);
-    }
-  }
-}
-
-
-static const char *delimits = " \t\n,;";
-
-static void skip (const char **pc) {
-  while (**pc != '\0' && strchr(delimits, **pc)) (*pc)++;
-}
-
-static int getnum (const char **pc) {
-  int res = 0;
-  skip(pc);
-  while (isdigit(**pc)) res = res*10 + (*(*pc)++) - '0';
-  return res;
-}
-  
-static int getreg (lua_State *L, const char **pc) {
-  skip(pc);
-  if (*(*pc)++ != 'r') lua_error(L, "`testC' expecting a register");
-  return getnum(pc);
-}
-
-static const char *getname (const char **pc) {
-  static char buff[30];
-  int i = 0;
-  skip(pc);
-  while (**pc != '\0' && !strchr(delimits, **pc))
-    buff[i++] = *(*pc)++;
-  buff[i] = '\0';
-  return buff;
-}
-
-
-#define EQ(s1)  (strcmp(s1, inst) == 0)
-
-static void testC (lua_State *L) {
-  lua_Object reg[10];
-  const char *pc = luaL_check_string(L, 1);
-  for (;;) {
-    const char *inst = getname(&pc);
-    if EQ("") return;
-    else if EQ("pushnum") {
-      lua_pushnumber(L, getnum(&pc));
-    }
-    else if EQ("createtable") {
-      reg[getreg(L, &pc)] = lua_createtable(L);
-    }
-    else if EQ("closure") {
-      lua_CFunction f = lua_getcfunction(L, lua_getglobal(L, getname(&pc)));
-      lua_pushcclosure(L, f, getnum(&pc));
-    }
-    else if EQ("pop") {
-      reg[getreg(L, &pc)] = lua_pop(L);
-    }
-    else if EQ("getglobal") {
-      int n = getreg(L, &pc);
-      reg[n] = lua_getglobal(L, getname(&pc));
-    }
-    else if EQ("rawgetglobal") {
-      int n = getreg(L, &pc);
-      reg[n] = lua_rawgetglobal(L, getname(&pc));
-    }
-    else if EQ("ref") {
-      lua_pushnumber(L, lua_ref(L, 0));
-      reg[getreg(L, &pc)] = lua_pop(L);
-    }
-    else if EQ("reflock") {
-      lua_pushnumber(L, lua_ref(L, 1));
-      reg[getreg(L, &pc)] = lua_pop(L);
-    }
-    else if EQ("getref") {
-      int n = getreg(L, &pc);
-      reg[n] = lua_getref(L, (int)lua_getnumber(L, reg[getreg(L, &pc)]));
-    }
-    else if EQ("unref") {
-      lua_unref(L, (int)lua_getnumber(L, reg[getreg(L, &pc)]));
-    }
-    else if EQ("getparam") {
-      int n = getreg(L, &pc);
-      reg[n] = lua_getparam(L, getnum(&pc)+1);  /* skips the commmand itself */
-    }
-    else if EQ("getresult") {
-      int n = getreg(L, &pc);
-      reg[n] = lua_getparam(L, getnum(&pc));
-    }
-    else if EQ("setglobal") {
-      lua_setglobal(L, getname(&pc));
-    }
-    else if EQ("rawsetglobal") {
-      lua_rawsetglobal(L, getname(&pc));
-    }
-    else if EQ("pushstring") {
-      lua_pushstring(L, getname(&pc));
-    }
-    else if EQ("pushreg") {
-      lua_pushobject(L, reg[getreg(L, &pc)]);
-    }
-    else if EQ("call") {
-      lua_call(L, getname(&pc));
-    }
-    else if EQ("gettable") {
-      reg[getreg(L, &pc)] = lua_gettable(L);
-    }
-    else if EQ("rawgettable") {
-      reg[getreg(L, &pc)] = lua_rawgettable(L);
-    }
-    else if EQ("settable") {
-      lua_settable(L);
-    }
-    else if EQ("rawsettable") {
-      lua_rawsettable(L);
-    }
-    else if EQ("nextvar") {
-      lua_pushstring(L, lua_nextvar(L, lua_getstring(L, reg[getreg(L, &pc)])));
-    }
-    else if EQ("next") {
-      int n = getreg(L, &pc);
-      n = lua_next(L, reg[n], (int)lua_getnumber(L, reg[getreg(L, &pc)]));
-      lua_pushnumber(L, n);
-    }
-    else if EQ("equal") {
-      int n1 = getreg(L, &pc);
-      int n2 = getreg(L, &pc);
-      lua_pushnumber(L, lua_equal(L, reg[n1], reg[n2]));
-    }
-    else if EQ("pushusertag") {
-      int val = getreg(L, &pc);
-      int tag = getreg(L, &pc);
-      lua_pushusertag(L, (void *)(int)lua_getnumber(L, reg[val]),
-                         (int)lua_getnumber(L, reg[tag]));
-    }
-    else if EQ("udataval") {
-      int n = getreg(L, &pc);
-      lua_pushnumber(L, (int)lua_getuserdata(L, reg[getreg(L, &pc)]));
-      reg[n] = lua_pop(L);
-    }
-    else if EQ("settagmethod") {
-      int n = getreg(L, &pc);
-      lua_settagmethod(L, (int)lua_getnumber(L, reg[n]), getname(&pc));
-    }
-    else if EQ("beginblock") {
-      lua_beginblock(L);
-    }
-    else if EQ("endblock") {
-      lua_endblock(L);
-    }
-    else if EQ("newstate") {
-      int stacksize = getnum(&pc);
-      lua_State *L1 = lua_newstate("stack", stacksize,
-                                   "builtin", getnum(&pc), NULL);
-      lua_pushuserdata(L, L1);
-    }
-    else if EQ("closestate") {
-      lua_close(lua_getuserdata(L, reg[getreg(L, &pc)]));
-    }
-    else if EQ("doremote") {
-      lua_Object ol1 = reg[getreg(L, &pc)];
-      lua_Object str = reg[getreg(L, &pc)];
-      lua_State *L1;
-      lua_Object temp;
-      int i;
-      if (!lua_isuserdata(L, ol1) || !lua_isstring(L, str))
-        lua_error(L, "bad arguments for `doremote'");
-      L1 = lua_getuserdata(L, ol1);
-      lua_dostring(L1, lua_getstring(L, str));
-      i = 1;
-      while ((temp = lua_getresult(L1, i++)) != LUA_NOOBJECT)
-        lua_pushstring(L, lua_getstring(L1, temp));
-    }
-    else luaL_verror(L, "unknown command in `testC': %.20s", inst);
-  }
-}
-                
-
-/* }====================================================== */
-#endif
-
-
-
 static const struct luaL_reg builtin_funcs[] = {
-#ifdef DEBUG
-  {"hash", hash_query},
-  {"querystr", query_strings},
-  {"querytab", table_query},
-  {"testC", testC},
-  {"totalmem", mem_query},
-#endif
   {"_ALERT", luaB_alert},
-  {"_ERRORMESSAGE", error_message},
+  {"_ERRORMESSAGE", luaB_ERRORMESSAGE},
   {"call", luaB_call},
   {"collectgarbage", luaB_collectgarbage},
   {"copytagmethods", luaB_copytagmethods},
@@ -891,6 +656,7 @@ void luaB_predefine (lua_State *L) {
   luaS_newfixedstring(L, tableEM);
   luaS_newfixedstring(L, memEM);
   luaL_openl(L, builtin_funcs);
+  luaB_opentests(L);  /* internal test functions (when DEBUG is on) */
   lua_pushstring(L, LUA_VERSION);
   lua_setglobal(L, "_VERSION");
 }
diff --git a/lbuiltin.h b/lbuiltin.h
index 6a4915d0..0e42c138 100644
--- a/lbuiltin.h
+++ b/lbuiltin.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lbuiltin.h,v 1.1 1997/09/16 19:25:59 roberto Exp roberto $
+** $Id: lbuiltin.h,v 1.2 1999/11/22 13:12:07 roberto Exp roberto $
 ** Built-in functions
 ** See Copyright Notice in lua.h
 */
@@ -9,6 +9,42 @@
 
 #include "lua.h"
 
+void luaB_alert (lua_State *L);
+void luaB_ERRORMESSAGE (lua_State *L);
+void luaB_print (lua_State *L);
+void luaB_tonumber (lua_State *L);
+void luaB_error (lua_State *L);
+void luaB_setglobal (lua_State *L);
+void luaB_rawsetglobal (lua_State *L);
+void luaB_getglobal (lua_State *L);
+void luaB_rawgetglobal (lua_State *L);
+void luaB_tag (lua_State *L);
+void luaB_settag (lua_State *L);
+void luaB_newtag (lua_State *L);
+void luaB_copytagmethods (lua_State *L);
+void luaB_rawgettable (lua_State *L);
+void luaB_rawsettable (lua_State *L);
+void luaB_settagmethod (lua_State *L);
+void luaB_gettagmethod (lua_State *L);
+void luaB_seterrormethod (lua_State *L);
+void luaB_collectgarbage (lua_State *L);
+void luaB_type (lua_State *L);
+void luaB_dostring (lua_State *L);
+void luaB_dofile (lua_State *L);
+void luaB_call (lua_State *L);
+void luaB_nextvar (lua_State *L);
+void luaB_next (lua_State *L);
+void luaB_tostring (lua_State *L);
+void luaB_assert (lua_State *L);
+void luaB_foreachi (lua_State *L);
+void luaB_foreach (lua_State *L);
+void luaB_foreachvar (lua_State *L);
+void luaB_getn (lua_State *L);
+void luaB_tinsert (lua_State *L);
+void luaB_tremove (lua_State *L);
+void luaB_sort (lua_State *L);
+
+
 void luaB_predefine (lua_State *L);
 
 
diff --git a/lgc.c b/lgc.c
index 14ef9539..ceade0a4 100644
--- a/lgc.c
+++ b/lgc.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lgc.c,v 1.34 1999/11/26 18:59:20 roberto Exp roberto $
+** $Id: lgc.c,v 1.35 1999/12/01 19:50:08 roberto Exp roberto $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
@@ -23,7 +23,7 @@
 static int markobject (lua_State *L, TObject *o);
 
 
-/* mark a string; marks bigger than 1 cannot be changed */
+/* mark a string; marks larger than 1 cannot be changed */
 #define strmark(L, s)    {if ((s)->marked == 0) (s)->marked = 1;}
 
 
diff --git a/llex.c b/llex.c
index c9250706..13fe627f 100644
--- a/llex.c
+++ b/llex.c
@@ -1,5 +1,5 @@
 /*
-** $Id: llex.c,v 1.44 1999/11/22 13:12:07 roberto Exp roberto $
+** $Id: llex.c,v 1.45 1999/12/02 16:41:29 roberto Exp roberto $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
@@ -64,7 +64,7 @@ void luaX_error (LexState *ls, const char *s) {
 
 
 void luaX_token2str (int token, char *s) {
-  if (token < 255) {
+  if (token < 256) {
     s[0] = (char)token;
     s[1] = '\0';
   }
@@ -225,7 +225,7 @@ static void inclinenumber (lua_State *L, LexState *LS) {
 
 /*
 ** =======================================================
-** LEXICAL ANALIZER
+** LEXICAL ANALYZER
 ** =======================================================
 */
 
@@ -407,7 +407,7 @@ int luaX_lex (LexState *LS) {
         }
         save(L, '\0');
         if (!luaO_str2d(L->Mbuffer+L->Mbuffbase, &LS->seminfo.r))
-          luaX_error(LS, "invalid numeric format");
+          luaX_error(LS, "malformed number");
         return NUMBER;
 
       case EOZ:
diff --git a/lmathlib.c b/lmathlib.c
index 83c8e0bc..6fc9f78f 100644
--- a/lmathlib.c
+++ b/lmathlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lmathlib.c,v 1.20 1999/11/22 13:12:07 roberto Exp roberto $
+** $Id: lmathlib.c,v 1.21 1999/11/22 17:39:51 roberto Exp roberto $
 ** Lua standard mathematical library
 ** See Copyright Notice in lua.h
 */
@@ -144,7 +144,7 @@ static void math_max (lua_State *L) {
 
 static void math_random (lua_State *L) {
   /* the '%' avoids the (rare) case of r==1, and is needed also because on
-     some systems (SunOS!) "rand()" may return a value bigger than RAND_MAX */
+     some systems (SunOS!) "rand()" may return a value larger than RAND_MAX */
   double r = (double)(rand()%RAND_MAX) / (double)RAND_MAX;
   if (lua_getparam(L, 1) == LUA_NOOBJECT)  /* no arguments? */
     lua_pushnumber(L, r);  /* real between 0 & 1 */
diff --git a/lmem.c b/lmem.c
index 7caa0f3e..47c45156 100644
--- a/lmem.c
+++ b/lmem.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lmem.c,v 1.20 1999/11/22 13:12:07 roberto Exp roberto $
+** $Id: lmem.c,v 1.21 1999/11/29 16:38:48 roberto Exp roberto $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
@@ -31,10 +31,10 @@ void *luaM_growaux (lua_State *L, void *block, unsigned long nelems,
                int inc, int size, const char *errormsg, unsigned long limit) {
   unsigned long newn = nelems+inc;
   if (newn >= limit) lua_error(L, errormsg);
-  if ((newn ^ nelems) <= nelems ||  /* still the same power of 2 limit? */
+  if ((newn ^ nelems) <= nelems ||  /* still the same power-of-2 limit? */
        (nelems > 0 && newn < MINPOWER2))  /* or block already is MINPOWER2? */
       return block;  /* do not need to reallocate */
-  else  /* it crossed a power of 2 boundary; grow to next power */
+  else  /* it crossed a power-of-2 boundary; grow to next power */
     return luaM_realloc(L, block, luaO_power2(newn)*size);
 }
 
diff --git a/lobject.c b/lobject.c
index e2845127..b8b9247e 100644
--- a/lobject.c
+++ b/lobject.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.c,v 1.25 1999/11/22 13:12:07 roberto Exp roberto $
+** $Id: lobject.c,v 1.26 1999/11/26 18:59:20 roberto Exp roberto $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -23,7 +23,7 @@ const TObject luaO_nilobject = {LUA_T_NIL, {NULL}};
 
 
 /*
-** returns smaller power of 2 bigger than `n' (minimum is MINPOWER2) 
+** returns smaller power of 2 larger than `n' (minimum is MINPOWER2) 
 */
 unsigned long luaO_power2 (unsigned long n) {
   unsigned long p = MINPOWER2;
diff --git a/lobject.h b/lobject.h
index d644d2ea..8c6b63f1 100644
--- a/lobject.h
+++ b/lobject.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.h,v 1.38 1999/11/26 18:59:20 roberto Exp roberto $
+** $Id: lobject.h,v 1.39 1999/12/02 16:24:45 roberto Exp roberto $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -197,7 +197,7 @@ typedef struct Hash {
 
 extern const char *const luaO_typenames[];
 
-#define luaO_typename(L, o)        luaO_typenames[-ttype(o)]
+#define luaO_typename(o)        luaO_typenames[-ttype(o)]
 
 #define MINPOWER2       4       /* minimum size for "growing" vectors */
 
diff --git a/lref.c b/lref.c
index caaae400..c2e90d38 100644
--- a/lref.c
+++ b/lref.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lref.c,v 1.2 1999/11/10 15:37:50 roberto Exp roberto $
+** $Id: lref.c,v 1.3 1999/11/22 13:12:07 roberto Exp roberto $
 ** REF mechanism
 ** See Copyright Notice in lua.h
 */
@@ -7,15 +7,17 @@
 
 #define LUA_REENTRANT
 
+#include "lapi.h"
 #include "lmem.h"
 #include "lref.h"
 #include "lstate.h"
 #include "lua.h"
 
 
-int luaR_ref (lua_State *L, const TObject *o, int lock) {
+int lua_ref (lua_State *L,  int lock) {
   int ref;
-  if (ttype(o) == LUA_T_NIL)
+  luaA_checkCparams(L, 1);
+  if (ttype(L->top-1) == LUA_T_NIL)
     ref = LUA_REFNIL;
   else {
     if (L->refFree != NONEXT) {  /* is there a free place? */
@@ -26,9 +28,10 @@ int luaR_ref (lua_State *L, const TObject *o, int lock) {
       luaM_growvector(L, L->refArray, L->refSize, 1, struct ref, refEM, MAX_INT);
       ref = L->refSize++;
     }
-    L->refArray[ref].o = *o;
+    L->refArray[ref].o = *(L->top-1);
     L->refArray[ref].st = lock ? LOCK : HOLD;
   }
+  L->top--;
   return ref;
 }
 
@@ -43,17 +46,38 @@ void lua_unref (lua_State *L, int ref) {
 }
 
 
-const TObject *luaR_getref (lua_State *L, int ref) {
+lua_Object lua_getref (lua_State *L, int ref) {
   if (ref == LUA_REFNIL)
-    return &luaO_nilobject;
+    return luaA_putluaObject(L, &luaO_nilobject);
   else if (0 <= ref && ref < L->refSize &&
           (L->refArray[ref].st == LOCK || L->refArray[ref].st == HOLD))
-    return &L->refArray[ref].o;
+    return luaA_putluaObject(L, &L->refArray[ref].o);
   else
-    return NULL;
+    return LUA_NOOBJECT;
 }
 
 
+void lua_beginblock (lua_State *L) {
+  luaM_growvector(L, L->Cblocks, L->numCblocks, 1, struct C_Lua_Stack,
+                  "too many nested blocks", L->stacksize);
+  L->Cblocks[L->numCblocks] = L->Cstack;
+  L->numCblocks++;
+}
+
+
+void lua_endblock (lua_State *L) {
+  if (L->numCblocks <= 0)
+    lua_error(L, "API error - no block to end");
+  --L->numCblocks;
+  L->Cstack = L->Cblocks[L->numCblocks];
+  L->top = L->Cstack.base;
+}
+
+
+
+
+
+
 static int ismarked (const TObject *o) {
   /* valid only for locked objects */
   switch (o->ttype) {
diff --git a/lref.h b/lref.h
index aff9e185..af4a1431 100644
--- a/lref.h
+++ b/lref.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lref.h,v 1.2 1999/11/10 15:37:50 roberto Exp roberto $
+** $Id: lref.h,v 1.3 1999/11/22 13:12:07 roberto Exp roberto $
 ** REF mechanism
 ** See Copyright Notice in lua.h
 */
@@ -22,9 +22,6 @@ struct ref {
 };
 
 
-int luaR_ref (lua_State *L, const TObject *o, int lock);
-const TObject *luaR_getref (lua_State *L, int ref);
 void luaR_invalidaterefs (lua_State *L);
 
-
 #endif
diff --git a/lvm.c b/lvm.c
index 4b05c894..026b089a 100644
--- a/lvm.c
+++ b/lvm.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.c,v 1.71 1999/12/06 19:30:53 roberto Exp roberto $
+** $Id: lvm.c,v 1.72 1999/12/09 20:01:48 roberto Exp roberto $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -64,7 +64,7 @@ int luaV_tostring (lua_State *L, TObject *obj) {  /* LUA_NUMBER */
   if (ttype(obj) != LUA_T_NUMBER)
     return 1;
   else {
-    char s[32];  /* 16 digits, signal, point and \0  (+ some extra...) */
+    char s[32];  /* 16 digits, sign, point and \0  (+ some extra...) */
     sprintf(s, "%.16g", (double)nvalue(obj));
     tsvalue(obj) = luaS_new(L, s);
     ttype(obj) = LUA_T_STRING;