better optimization options

objects while running...)

bugs

@@ -170,3 +170,103 @@ in the following platforms:
 * IRIX	  - cc, cc-purify
 * Windows - Visual C++ (.c e .cpp, warning level=4)
 
+
+** lstrlib.c
+Tue May  2 15:27:58 EST 2000
+>> `strfind' gets wrong subject length when there is an offset
+(by Jon Kleiser; since 4.0a)
+
+** lparser.c
+Fri May 12 15:11:12 EST 2000
+>> first element in a list constructor is not adjusted to one value
+>> (e.g. «a = {gsub('a','a','')}»)
+(by Tomas; since 4.0a)
+
+** lparser.c
+Wed May 24 14:50:16 EST 2000
+>> record-constructor starting with an upvalue name gets an error
+>> (e.g. «local a; function f() x = {a=1} end»)
+(by Edgar Toernig; since 3.1)
+
+** lparser.c
+Tue Aug 29 15:56:05 EST 2000
+>> error message for `for' uses `while'
+(since 4.0a; already corrected)
+
+** lgc.c
+Tue Aug 29 15:57:41 EST 2000
+>> gc tag method for nil could call line hook
+(by ry; since ?)
+
+
+
+=================================================================
+--- Version 4.0 Beta
+
+** liolib.c
+Fri Sep 22 15:12:37 EST 2000
+>> `read("*w")' should return nil at EOF
+(by roberto; since 4.0b)
+
+** lvm.c
+Mon Sep 25 11:47:48 EST 2000
+>> lua_gettable does not get key from stack top
+(by Philip Yi; since 4.0b)
+
+** lgc.c
+Mon Sep 25 11:50:48 EST 2000
+>> GC may crash when checking locked C closures
+(by Philip Yi; since 4.0b)
+
+** lapi.c
+Wed Sep 27 09:50:19 EST 2000
+>> lua_tag should return LUA_NOTAG for non-valid indices
+(by Paul Hankin; since 4.0b)
+
+** llex.h / llex.c / lparser.c
+Wed Sep 27 13:39:45 EST 2000
+>> parser overwrites semantic information when looking ahead
+>> (e.g. «a = {print'foo'}»)
+(by Edgar Toernig; since 4.0b, deriving from previous bug)
+
+** liolib.c
+Thu Oct 26 10:50:46 EDT 2000
+>> in function `read_file', realloc() doesn't free the buffer if it can't
+>> allocate new memory
+(by Mauro Vezzosi; since 4.0b)
+
+
+
+=================================================================
+--- Version 4.0
+
+** lparser.c
+Wed Nov 29 09:51:44 EDT 2000
+>> parser does not accept a `;' after a `return'
+(by lhf; since 4.0b)
+
+** liolib.c
+Fri Dec 22 15:30:42 EDT 2000
+>> when `read' fails it must return nil (and not no value)
+(by cassino; since at least 3.1)
+
+** lstring.c/lapi.c
+Thu Feb  1 11:55:45 EDT 2001
+>> lua_pushuserdata(L, NULL) is buggy
+(by Edgar Toernig; since 4.0)
+
+** ldo.c
+Fri Feb  2 14:06:40 EDT 2001
+>> «while 1 dostring[[print('hello\n')]] end» never reclaims memory
+(by Andrew Paton; since 4.0b)
+
+** lbaselib.c
+Tue Feb  6 11:57:13 EDT 2001
+>> ESC (which starts precompiled code) in C is \33, not \27
+(by Edgar Toernig and lhf; since 4.0b)
+
+** lparser.c
+Tue Jul 10 16:59:18 EST 2001
+>> error message for `%a' gave wrong line number
+(by Leonardo Constantino; since 4.0)
+

lapi.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.h,v 1.15 2000/03/10 18:37:44 roberto Exp roberto $
+** $Id: lapi.h,v 1.19 2000/08/28 17:57:04 roberto Exp roberto $
 ** Auxiliary functions from Lua API
 ** See Copyright Notice in lua.h
 */
@@ -11,11 +11,7 @@
 #include "lobject.h"
 
 
-void luaA_checkCargs (lua_State *L, int nargs);
+TObject *luaA_index (lua_State *L, int index);
 void luaA_pushobject (lua_State *L, const TObject *o);
-GlobalVar *luaA_nextvar (lua_State *L, TString *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

lauxlib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lauxlib.c,v 1.26 2000/02/08 16:34:31 roberto Exp roberto $
+** $Id: lauxlib.c,v 1.50 2001/04/23 16:35:45 roberto Exp roberto $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
@@ -14,15 +14,16 @@
 ** With care, these functions can be used by other libraries.
 */
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
 #include "lauxlib.h"
-#include "lua.h"
 #include "luadebug.h"
+#include "lualib.h"
 
 
 
-int luaL_findstring (const char *name, const char *const list[]) {
+LUALIB_API int luaL_findstring (const l_char *name, const l_char *const list[]) {
   int i;
   for (i=0; list[i]; i++)
     if (strcmp(list[i], name) == 0)
@@ -30,91 +31,96 @@ int luaL_findstring (const char *name, const char *const list[]) {
   return -1;  /* name not found */
 }
 
-void luaL_argerror (lua_State *L, int narg, const char *extramsg) {
+LUALIB_API void luaL_argerror (lua_State *L, int narg, const l_char *extramsg) {
   lua_Debug ar;
   lua_getstack(L, 0, &ar);
-  lua_getinfo(L, "nu", &ar);
-  narg -= ar.nups;
+  lua_getinfo(L, l_s("n"), &ar);
   if (ar.name == NULL)
-    ar.name = "?";
-  luaL_verror(L, "bad argument #%d to `%.50s' (%.100s)",
+    ar.name = l_s("?");
+  luaL_verror(L, l_s("bad argument #%d to `%.50s' (%.100s)"),
               narg, ar.name, extramsg);
 }
 
 
-static void type_error (lua_State *L, int narg, const char *type_name,
-                        lua_Object o) {
-  char buff[100];
-  const char *otype = (o == LUA_NOOBJECT) ? "no value" : lua_type(L, o);
-  sprintf(buff, "%.10s expected, got %.10s", type_name, otype);
+static void type_error (lua_State *L, int narg, const l_char *tname) {
+  l_char buff[80];
+  sprintf(buff, l_s("%.25s expected, got %.25s"), tname, lua_type(L,narg));
   luaL_argerror(L, narg, buff);
 }
 
 
-static const char *checkstr (lua_State *L, lua_Object o, int narg, long *len) {
-  const char *s = lua_getstring(L, o);
-  if (!s) type_error(L, narg, "string", o);
-  if (len) *len = lua_strlen(L, o);
+static void tag_error (lua_State *L, int narg, int tag) {
+  type_error(L, narg, lua_typename(L, tag)); 
+}
+
+
+LUALIB_API void luaL_checkstack (lua_State *L, int space, const l_char *mes) {
+  if (space > lua_stackspace(L))
+    luaL_verror(L, l_s("stack overflow (%.30s)"), mes);
+}
+
+
+LUALIB_API void luaL_checktype(lua_State *L, int narg, int t) {
+  if (lua_rawtag(L, narg) != t)
+    tag_error(L, narg, t);
+}
+
+
+LUALIB_API void luaL_checkany (lua_State *L, int narg) {
+  if (lua_rawtag(L, narg) == LUA_TNONE)
+    luaL_argerror(L, narg, l_s("value expected"));
+}
+
+
+LUALIB_API void *luaL_check_userdata (lua_State *L, int narg,
+                                      const l_char *name) {
+  if (strcmp(lua_type(L, narg), name) != 0)
+    type_error(L, narg, name);
+  return lua_touserdata(L, narg);
+}
+
+
+LUALIB_API const l_char *luaL_check_lstr (lua_State *L, int narg, size_t *len) {
+  const l_char *s = lua_tostring(L, narg);
+  if (!s) tag_error(L, narg, LUA_TSTRING);
+  if (len) *len = lua_strlen(L, narg);
   return s;
 }
 
-const char *luaL_check_lstr (lua_State *L, int narg, long *len) {
-  return checkstr(L, lua_getparam(L, narg), narg, len);
-}
 
-const char *luaL_opt_lstr (lua_State *L, int narg, const char *def, long *len) {
-  lua_Object o = lua_getparam(L, narg);
-  if (o == LUA_NOOBJECT) {
-    if (len) *len = def ? strlen(def) : 0;
+LUALIB_API const l_char *luaL_opt_lstr (lua_State *L, int narg, const l_char *def, size_t *len) {
+  if (lua_isnull(L, narg)) {
+    if (len)
+      *len = (def ? strlen(def) : 0);
     return def;
   }
-  else return checkstr(L, o, narg, len);
-}
-
-double luaL_check_number (lua_State *L, int narg) {
-  lua_Object o = lua_getparam(L, narg);
-  if (!lua_isnumber(L, o)) type_error(L, narg, "number", o);
-  return lua_getnumber(L, o);
+  else return luaL_check_lstr(L, narg, len);
 }
 
 
-double luaL_opt_number (lua_State *L, int narg, double def) {
-  lua_Object o = lua_getparam(L, narg);
-  if (o == LUA_NOOBJECT) return def;
-  else {
-    if (!lua_isnumber(L, o)) type_error(L, narg, "number", o);
-    return lua_getnumber(L, o);
-  }
+LUALIB_API lua_Number luaL_check_number (lua_State *L, int narg) {
+  lua_Number d = lua_tonumber(L, narg);
+  if (d == 0 && !lua_isnumber(L, narg))  /* avoid extra test when d is not 0 */
+    tag_error(L, narg, LUA_TNUMBER);
+  return d;
 }
 
 
-lua_Object luaL_tablearg (lua_State *L, int narg) {
-  lua_Object o = lua_getparam(L, narg);
-  if (!lua_istable(L, o)) type_error(L, narg, "table", o);
-  return o;
+LUALIB_API lua_Number luaL_opt_number (lua_State *L, int narg, lua_Number def) {
+  if (lua_isnull(L, narg)) return def;
+  else return luaL_check_number(L, narg);
 }
 
-lua_Object luaL_functionarg (lua_State *L, int narg) {
-  lua_Object o = lua_getparam(L, narg);
-  if (!lua_isfunction(L, o)) type_error(L, narg, "function", o);
-  return o;
-}
 
-lua_Object luaL_nonnullarg (lua_State *L, int narg) {
-  lua_Object o = lua_getparam(L, narg);
-  luaL_arg_check(L, o != LUA_NOOBJECT, narg, "value expected");
-  return o;
-}
-
-void luaL_openlib (lua_State *L, const struct luaL_reg *l, int n) {
+LUALIB_API void luaL_openlib (lua_State *L, const luaL_reg *l, int n) {
   int i;
   for (i=0; i<n; i++)
     lua_register(L, l[i].name, l[i].func);
 }
 
 
-void luaL_verror (lua_State *L, const char *fmt, ...) {
-  char buff[500];
+LUALIB_API void luaL_verror (lua_State *L, const l_char *fmt, ...) {
+  l_char buff[500];
   va_list argp;
   va_start(argp, fmt);
   vsprintf(buff, fmt, argp);
@@ -123,29 +129,97 @@ void luaL_verror (lua_State *L, const char *fmt, ...) {
 }
 
 
-#define EXTRALEN	sizeof("string \"...\"0")
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
 
-void luaL_chunkid (char *out, const char *source, int len) {
-  if (*source == '(') {
-    strncpy(out, source+1, len-1);  /* remove first char */
-    out[len-1] = '\0';  /* make sure `out' has an end */
-    out[strlen(out)-1] = '\0';  /* remove last char */
+
+#define buffempty(B)	((B)->p == (B)->buffer)
+#define bufflen(B)	((B)->p - (B)->buffer)
+#define bufffree(B)	((size_t)(LUAL_BUFFERSIZE - bufflen(B)))
+
+#define LIMIT	(LUA_MINSTACK/2)
+
+
+static int emptybuffer (luaL_Buffer *B) {
+  size_t l = bufflen(B);
+  if (l == 0) return 0;  /* put nothing on stack */
+  else {
+    lua_pushlstring(B->L, B->buffer, l);
+    B->p = B->buffer;
+    B->level++;
+    return 1;
+  }
+}
+
+
+static void adjuststack (luaL_Buffer *B) {
+  if (B->level > 1) {
+    lua_State *L = B->L;
+    int toget = 1;  /* number of levels to concat */
+    size_t toplen = lua_strlen(L, -1);
+    do {
+      size_t l = lua_strlen(L, -(toget+1));
+      if (B->level - toget + 1 >= LIMIT || toplen > l) {
+        toplen += l;
+        toget++;
+      }
+      else break;
+    } while (toget < B->level);
+    lua_concat(L, toget);
+    B->level = B->level - toget + 1;
+  }
+}
+
+
+LUALIB_API l_char *luaL_prepbuffer (luaL_Buffer *B) {
+  if (emptybuffer(B))
+    adjuststack(B);
+  return B->buffer;
+}
+
+
+LUALIB_API void luaL_addlstring (luaL_Buffer *B, const l_char *s, size_t l) {
+  while (l--)
+    luaL_putchar(B, *s++);
+}
+
+
+LUALIB_API void luaL_addstring (luaL_Buffer *B, const l_char *s) {
+  luaL_addlstring(B, s, strlen(s));
+}
+
+
+LUALIB_API void luaL_pushresult (luaL_Buffer *B) {
+  emptybuffer(B);
+  lua_concat(B->L, B->level);
+  B->level = 1;
+}
+
+
+LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
+  lua_State *L = B->L;
+  size_t vl = lua_strlen(L, -1);
+  if (vl <= bufffree(B)) {  /* fit into buffer? */
+    memcpy(B->p, lua_tostring(L, -1), vl);  /* put it there */
+    B->p += vl;
+    lua_pop(L, 1);  /* remove from stack */
   }
   else {
-    len -= EXTRALEN;
-    if (*source == '@')
-      sprintf(out, "file `%.*s'", len, source+1);
-    else {
-      const char *b = strchr(source , '\n');  /* stop at first new line */
-      int lim = (b && (b-source)<len) ? b-source : len;
-      sprintf(out, "string \"%.*s\"", lim, source);
-      strcpy(out+lim+(EXTRALEN-sizeof("...\"0")), "...\"");
-    }
+    if (emptybuffer(B))
+      lua_insert(L, -2);  /* put buffer before new value */
+    B->level++;  /* add new value into B stack */
+    adjuststack(B);
   }
 }
 
 
-void luaL_filesource (char *out, const char *filename, int len) {
-  if (filename == NULL) filename = "(stdin)";
-  sprintf(out, "@%.*s", len-2, filename);  /* -2 for '@' and '\0' */
+LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
+  B->L = L;
+  B->p = B->buffer;
+  B->level = 0;
 }
+
+/* }====================================================== */

lauxlib.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lauxlib.h,v 1.16 1999/12/03 11:26:23 roberto Exp roberto $
+** $Id: lauxlib.h,v 1.35 2001/04/06 21:17:37 roberto Exp roberto $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
@@ -9,39 +9,44 @@
 #define lauxlib_h
 
 
+#include <stddef.h>
+#include <stdio.h>
+
 #include "lua.h"
 
 
-struct luaL_reg {
-  const char *name;
+#ifndef LUALIB_API
+#define LUALIB_API	extern
+#endif
+
+
+typedef struct luaL_reg {
+  const lua_char *name;
   lua_CFunction func;
-};
+} luaL_reg;
 
 
-void luaL_openlib (lua_State *L, const struct luaL_reg *l, int n);
-void luaL_argerror (lua_State *L, int numarg, const char *extramsg);
-const char *luaL_check_lstr (lua_State *L, int numArg, long *len);
-const char *luaL_opt_lstr (lua_State *L, int numArg, const char *def, long *len);
-double luaL_check_number (lua_State *L, int numArg);
-double luaL_opt_number (lua_State *L, int numArg, double def);
-lua_Object luaL_functionarg (lua_State *L, int arg);
-lua_Object luaL_tablearg (lua_State *L, int arg);
-lua_Object luaL_nonnullarg (lua_State *L, int numArg);
-void luaL_verror (lua_State *L, const char *fmt, ...);
-char *luaL_openspace (lua_State *L, int size);
-void luaL_resetbuffer (lua_State *L);
-void luaL_addchar (lua_State *L, int c);
-int luaL_getsize (lua_State *L);
-void luaL_addsize (lua_State *L, int n);
-int luaL_newbuffer (lua_State *L, int size);
-void luaL_oldbuffer (lua_State *L, int old);
-char *luaL_buffer (lua_State *L);
-int luaL_findstring (const char *name, const char *const list[]);
-void luaL_chunkid (char *out, const char *source, int len);
-void luaL_filesource (char *out, const char *filename, int len);
+LUALIB_API void luaL_openlib (lua_State *L, const luaL_reg *l, int n);
+LUALIB_API void luaL_argerror (lua_State *L, int numarg,
+                               const lua_char *extramsg);
+LUALIB_API const lua_char *luaL_check_lstr (lua_State *L, int numArg,
+                                            size_t *len);
+LUALIB_API const lua_char *luaL_opt_lstr (lua_State *L, int numArg,
+                                          const lua_char *def, size_t *len);
+LUALIB_API lua_Number luaL_check_number (lua_State *L, int numArg);
+LUALIB_API lua_Number luaL_opt_number (lua_State *L, int nArg, lua_Number def);
+
+LUALIB_API void luaL_checkstack (lua_State *L, int space, const lua_char *msg);
+LUALIB_API void luaL_checktype (lua_State *L, int narg, int t);
+LUALIB_API void luaL_checkany (lua_State *L, int narg);
+LUALIB_API void *luaL_check_userdata (lua_State *L, int narg,
+                                      const lua_char *name);
+
+LUALIB_API void luaL_verror (lua_State *L, const lua_char *fmt, ...);
+LUALIB_API int luaL_findstring (const lua_char *name, 
+                                const lua_char *const list[]);
 
 
-#ifdef LUA_REENTRANT
 
 /*
 ** ===============================================================
@@ -59,47 +64,43 @@ void luaL_filesource (char *out, const char *filename, int len);
 #define luaL_opt_long(L,n,d)	((long)luaL_opt_number(L, n,d))
 #define luaL_openl(L,a)		luaL_openlib(L, a, (sizeof(a)/sizeof(a[0])))
 
-#else
-
 
 /*
-** ===============================================================
-** Macros for single-state use
-** ===============================================================
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
 */
 
-#define luaL_arg_check(cond,numarg,extramsg) if (!(cond)) \
-                                               luaL_argerror(numarg,extramsg)
-#define luaL_check_string(n)	(luaL_check_lstr((n), NULL))
-#define luaL_opt_string(n, d)	(luaL_opt_lstr((n), (d), NULL))
-#define luaL_check_int(n)	((int)luaL_check_number(n))
-#define luaL_check_long(n)	((long)luaL_check_number(n))
-#define luaL_opt_int(n,d)	((int)luaL_opt_number(n,d))
-#define luaL_opt_long(n,d)	((long)luaL_opt_number(n,d))
-#define luaL_openl(a)		luaL_openlib(a, (sizeof(a)/sizeof(a[0])))
+
+#ifndef LUAL_BUFFERSIZE
+#define LUAL_BUFFERSIZE	  BUFSIZ
+#endif
 
 
-#define luaL_openlib(l,n)	(luaL_openlib)(lua_state,l,n)
-#define luaL_argerror(numarg,extramsg)	\
-				(luaL_argerror)(lua_state,numarg,extramsg)
-#define luaL_check_lstr(numArg,len)	(luaL_check_lstr)(lua_state,numArg,len)
-#define luaL_opt_lstr(numArg,def,len)	\
-				(luaL_opt_lstr)(lua_state,numArg,def,len)
-#define luaL_check_number(numArg)	(luaL_check_number)(lua_state,numArg)
-#define luaL_opt_number(numArg,def)	(luaL_opt_number)(lua_state,numArg,def)
-#define luaL_functionarg(arg)	(luaL_functionarg)(lua_state,arg)
-#define luaL_tablearg(arg)	(luaL_tablearg)(lua_state,arg)
-#define luaL_nonnullarg(numArg)	(luaL_nonnullarg)(lua_state,numArg)
-#define luaL_openspace(size)	(luaL_openspace)(lua_state,size)
-#define luaL_resetbuffer()	(luaL_resetbuffer)(lua_state)
-#define luaL_addchar(c)		(luaL_addchar)(lua_state,c)
-#define luaL_getsize()		(luaL_getsize)(lua_state)
-#define luaL_addsize(n)		(luaL_addsize)(lua_state,n)
-#define luaL_newbuffer(size)	(luaL_newbuffer)(lua_state,size)
-#define luaL_oldbuffer(old)	(luaL_oldbuffer)(lua_state,old)
-#define luaL_buffer()		(luaL_buffer)(lua_state)
+typedef struct luaL_Buffer {
+  lua_char *p;			/* current position in buffer */
+  int level;
+  lua_State *L;
+  lua_char buffer[LUAL_BUFFERSIZE];
+} luaL_Buffer;
+
+#define luaL_putchar(B,c) \
+  ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \
+   (*(B)->p++ = (lua_char)(c)))
+
+#define luaL_addsize(B,n)	((B)->p += (n))
+
+LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B);
+LUALIB_API lua_char *luaL_prepbuffer (luaL_Buffer *B);
+LUALIB_API void luaL_addlstring (luaL_Buffer *B, const lua_char *s, size_t l);
+LUALIB_API void luaL_addstring (luaL_Buffer *B, const lua_char *s);
+LUALIB_API void luaL_addvalue (luaL_Buffer *B);
+LUALIB_API void luaL_pushresult (luaL_Buffer *B);
+
+
+/* }====================================================== */
+
 
 #endif
 
-#endif
 

lbaselib.c

@@ -0,0 +1,745 @@
+/*
+** $Id: lbaselib.c,v 1.38 2001/06/20 17:25:30 roberto Exp roberto $
+** Basic library
+** See Copyright Notice in lua.h
+*/
+
+
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define LUA_PRIVATE
+#include "lua.h"
+
+#include "lauxlib.h"
+#include "luadebug.h"
+#include "lualib.h"
+
+
+
+static void aux_setn (lua_State *L, int t, int n) {
+  lua_pushliteral(L, l_s("n"));
+  lua_pushnumber(L, n);
+  lua_settable(L, t);
+}
+
+
+/*
+** If your system does not support `stderr', redefine this function, or
+** redefine _ERRORMESSAGE so that it won't need _ALERT.
+*/
+static int luaB__ALERT (lua_State *L) {
+  fputs(luaL_check_string(L, 1), stderr);
+  return 0;
+}
+
+
+/*
+** Basic implementation of _ERRORMESSAGE.
+** The library `liolib' redefines _ERRORMESSAGE for better error information.
+*/
+static int luaB__ERRORMESSAGE (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TSTRING);
+  lua_getglobal(L, l_s(LUA_ALERT));
+  if (lua_isfunction(L, -1)) {  /* avoid error loop if _ALERT is not defined */
+    lua_Debug ar;
+    lua_pushliteral(L, l_s("error: "));
+    lua_pushvalue(L, 1);
+    if (lua_getstack(L, 1, &ar)) {
+      lua_getinfo(L, l_s("Sl"), &ar);
+      if (ar.source && ar.currentline > 0) {
+        l_char buff[100];
+        sprintf(buff, l_s("\n  <%.70s: line %d>"), ar.short_src, ar.currentline);
+        lua_pushstring(L, buff);
+        lua_concat(L, 2);
+      }
+    }
+    lua_pushliteral(L, l_s("\n"));
+    lua_concat(L, 3);
+    lua_rawcall(L, 1, 0);
+  }
+  return 0;
+}
+
+
+/*
+** If your system does not support `stdout', you can just remove this function.
+** If you need, you can define your own `print' function, following this
+** model but changing `fputs' to put the strings at a proper place
+** (a console window or a log file, for instance).
+*/
+static int luaB_print (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  int i;
+  lua_getglobal(L, l_s("tostring"));
+  for (i=1; i<=n; i++) {
+    const l_char *s;
+    lua_pushvalue(L, -1);  /* function to be called */
+    lua_pushvalue(L, i);   /* value to print */
+    lua_rawcall(L, 1, 1);
+    s = lua_tostring(L, -1);  /* get result */
+    if (s == NULL)
+      lua_error(L, l_s("`tostring' must return a string to `print'"));
+    if (i>1) fputs(l_s("\t"), stdout);
+    fputs(s, stdout);
+    lua_pop(L, 1);  /* pop result */
+  }
+  fputs(l_s("\n"), stdout);
+  return 0;
+}
+
+
+static int luaB_tonumber (lua_State *L) {
+  int base = luaL_opt_int(L, 2, 10);
+  if (base == 10) {  /* standard conversion */
+    luaL_checkany(L, 1);
+    if (lua_isnumber(L, 1)) {
+      lua_pushnumber(L, lua_tonumber(L, 1));
+      return 1;
+    }
+  }
+  else {
+    const l_char *s1 = luaL_check_string(L, 1);
+    l_char *s2;
+    unsigned long n;
+    luaL_arg_check(L, 2 <= base && base <= 36, 2, l_s("base out of range"));
+    n = strtoul(s1, &s2, base);
+    if (s1 != s2) {  /* at least one valid digit? */
+      while (isspace(uchar(*s2))) s2++;  /* skip trailing spaces */
+      if (*s2 == l_c('\0')) {  /* no invalid trailing characters? */
+        lua_pushnumber(L, n);
+        return 1;
+      }
+    }
+  }
+  lua_pushnil(L);  /* else not a number */
+  return 1;
+}
+
+
+static int luaB_error (lua_State *L) {
+  lua_error(L, luaL_opt_string(L, 1, NULL));
+  return 0;  /* to avoid warnings */
+}
+
+static int luaB_setglobal (lua_State *L) {
+  luaL_checkany(L, 2);
+  lua_setglobal(L, luaL_check_string(L, 1));
+  return 0;
+}
+
+static int luaB_getglobal (lua_State *L) {
+  lua_getglobal(L, luaL_check_string(L, 1));
+  return 1;
+}
+
+
+/* auxiliary function to get `tags' */
+static int gettag (lua_State *L, int narg) {
+  switch (lua_rawtag(L, narg)) {
+    case LUA_TNUMBER:
+      return (int)lua_tonumber(L, narg);
+    case LUA_TSTRING: {
+      const l_char *name = lua_tostring(L, narg);
+      int tag = lua_name2tag(L, name);
+      if (tag == LUA_TNONE)
+        luaL_verror(L, l_s("'%.30s' is not a valid type name"), name);
+      return tag;
+    }
+    default:
+      luaL_argerror(L, narg, l_s("tag or type name expected"));
+      return 0;  /* to avoid warnings */
+  }
+}
+
+
+static int luaB_tag (lua_State *L) {
+  luaL_checkany(L, 1);
+  lua_pushnumber(L, lua_tag(L, 1));
+  return 1;
+}
+
+static int luaB_settype (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  lua_pushvalue(L, 1);  /* push table */
+  lua_settag(L, gettag(L, 2));
+  return 1;  /* return table */
+}
+
+static int luaB_weakmode (lua_State *L) {
+  const l_char *mode = luaL_check_string(L, 2);
+  luaL_checktype(L, 1, LUA_TTABLE);
+  if (*mode == l_c('?')) {
+    l_char buff[3];
+    l_char *s = buff;
+    int imode = lua_getweakmode(L, 1);
+    if (imode & LUA_WEAK_KEY) *s++ = 'k';
+    if (imode & LUA_WEAK_VALUE) *s++ = 'v';
+    *s = '\0';
+    lua_pushstring(L, buff);
+    return 1;
+  }
+  else {
+    int imode = 0;
+    if (strchr(mode, l_c('k'))) imode |= LUA_WEAK_KEY;
+    if (strchr(mode, l_c('v'))) imode |= LUA_WEAK_VALUE;
+    lua_pushvalue(L, 1);  /* push table */
+    lua_setweakmode(L, imode);
+    return 1;  /* return the table */
+  }
+}
+
+static int luaB_newtype (lua_State *L) {
+  const l_char *name = luaL_opt_string(L, 1, NULL);
+  lua_pushnumber(L, lua_newtype(L, name, LUA_TTABLE));
+  return 1;
+}
+
+static int luaB_copytagmethods (lua_State *L) {
+  lua_pushnumber(L, lua_copytagmethods(L, gettag(L, 1), gettag(L, 2)));
+  return 1;
+}
+
+static int luaB_globals (lua_State *L) {
+  lua_getglobals(L);  /* value to be returned */
+  if (!lua_isnull(L, 1)) {
+    luaL_checktype(L, 1, LUA_TTABLE);
+    lua_pushvalue(L, 1);  /* new table of globals */
+    lua_setglobals(L);
+  }
+  return 1;
+}
+
+static int luaB_rawget (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  luaL_checkany(L, 2);
+  lua_rawget(L, -2);
+  return 1;
+}
+
+static int luaB_rawset (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  luaL_checkany(L, 2);
+  luaL_checkany(L, 3);
+  lua_rawset(L, -3);
+  return 1;
+}
+
+static int luaB_settagmethod (lua_State *L) {
+  int tag = gettag(L, 1);
+  const l_char *event = luaL_check_string(L, 2);
+  luaL_arg_check(L, lua_isfunction(L, 3) || lua_isnil(L, 3), 3,
+                 l_s("function or nil expected"));
+  if (strcmp(event, l_s("gc")) == 0)
+    lua_error(L, l_s("deprecated use: cannot set the `gc' tag method from Lua"));
+  lua_gettagmethod(L, tag, event);
+  lua_pushvalue(L, 3);
+  lua_settagmethod(L, tag, event);
+  return 1;
+}
+
+
+static int luaB_gettagmethod (lua_State *L) {
+  int tag = gettag(L, 1);
+  const l_char *event = luaL_check_string(L, 2);
+  if (strcmp(event, l_s("gc")) == 0)
+    lua_error(L, l_s("deprecated use: cannot get the `gc' tag method from Lua"));
+  lua_gettagmethod(L, tag, event);
+  return 1;
+}
+
+
+static int luaB_gcinfo (lua_State *L) {
+  lua_pushnumber(L, lua_getgccount(L));
+  lua_pushnumber(L, lua_getgcthreshold(L));
+  return 2;
+}
+
+
+static int luaB_collectgarbage (lua_State *L) {
+  lua_setgcthreshold(L, luaL_opt_int(L, 1, 0));
+  return 0;
+}
+
+
+static int luaB_type (lua_State *L) {
+  luaL_checkany(L, 1);
+  lua_pushstring(L, lua_type(L, 1));
+  return 1;
+}
+
+
+static int luaB_rawtype (lua_State *L) {
+  luaL_checkany(L, 1);
+  lua_pushstring(L, lua_tag2name(L, lua_rawtag(L, 1)));
+  return 1;
+}
+
+
+static int luaB_next (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  lua_settop(L, 2);  /* create a 2nd argument if there isn't one */
+  if (lua_next(L, 1))
+    return 2;
+  else {
+    lua_pushnil(L);
+    return 1;
+  }
+}
+
+
+static int passresults (lua_State *L, int status, int oldtop) {
+  static const l_char *const errornames[] =
+    {l_s("ok"), l_s("run-time error"), l_s("file error"), l_s("syntax error"),
+     l_s("memory error"), l_s("error in error handling")};
+  if (status == 0) {
+    int nresults = lua_gettop(L) - oldtop;
+    if (nresults > 0)
+      return nresults;  /* results are already on the stack */
+    else {
+      lua_newuserdatabox(L, NULL); /* at least one result to signal no errors */
+      return 1;
+    }
+  }
+  else {  /* error */
+    lua_pushnil(L);
+    lua_pushstring(L, errornames[status]);  /* error code */
+    return 2;
+  }
+}
+
+
+static int luaB_dostring (lua_State *L) {
+  int oldtop = lua_gettop(L);
+  size_t l;
+  const l_char *s = luaL_check_lstr(L, 1, &l);
+  const l_char *chunkname = luaL_opt_string(L, 2, s);
+  return passresults(L, lua_dobuffer(L, s, l, chunkname), oldtop);
+}
+
+
+static int luaB_loadstring (lua_State *L) {
+  int oldtop = lua_gettop(L);
+  size_t l;
+  const l_char *s = luaL_check_lstr(L, 1, &l);
+  const l_char *chunkname = luaL_opt_string(L, 2, s);
+  return passresults(L, lua_loadbuffer(L, s, l, chunkname), oldtop);
+}
+
+static int luaB_dofile (lua_State *L) {
+  int oldtop = lua_gettop(L);
+  const l_char *fname = luaL_opt_string(L, 1, NULL);
+  return passresults(L, lua_dofile(L, fname), oldtop);
+}
+
+
+static int luaB_loadfile (lua_State *L) {
+  int oldtop = lua_gettop(L);
+  const l_char *fname = luaL_opt_string(L, 1, NULL);
+  return passresults(L, lua_loadfile(L, fname), oldtop);
+}
+
+
+
+#define LUA_PATH	l_s("LUA_PATH")
+
+#define LUA_PATH_SEP	l_s(";")
+
+#ifndef LUA_PATH_DEFAULT
+#define LUA_PATH_DEFAULT	l_s("./")
+#endif
+
+static int luaB_require (lua_State *L) {
+  const l_char *path;
+  luaL_check_string(L, 1);
+  lua_settop(L, 1);
+  lua_getglobal(L, LUA_PATH);  /* get path */
+  if (lua_isstring(L, 2))  /* is LUA_PATH defined? */
+    path = lua_tostring(L, 2);
+  else {  /* LUA_PATH not defined */
+    lua_pop(L, 1);  /* pop old global value */
+    path = getenv(LUA_PATH);  /* try environment variable */
+    if (path == NULL) path = LUA_PATH_DEFAULT;  /* else use default */
+    lua_pushstring(L, path);
+    lua_pushvalue(L, -1);  /* duplicate to leave a copy on stack */
+    lua_setglobal(L, LUA_PATH);
+  }
+  lua_getregistry(L);
+  lua_pushliteral(L, LUA_PATH);
+  lua_gettable(L, 3);  /* get book-keeping table */
+  if (lua_isnil(L, 4)) {  /* no book-keeping table? */
+    lua_pop(L, 1);  /* pop the `nil' */
+    lua_newtable(L);  /* create book-keeping table */
+    lua_pushliteral(L, LUA_PATH);
+    lua_pushvalue(L, -2);  /* duplicate table to leave a copy on stack */
+    lua_settable(L, 3);  /* store book-keeping table in registry */
+  }
+  lua_pushvalue(L, 1);
+  lua_gettable(L, 4);  /* check package's name in book-keeping table */
+  if (!lua_isnil(L, -1))  /* is it there? */
+    return 0;  /* package is already loaded */
+  else {  /* must load it */
+    for (;;) {  /* traverse path */
+      int res;
+      int l = strcspn(path, LUA_PATH_SEP);  /* find separator */
+      lua_pushlstring(L, path, l);  /* directory name */
+      lua_pushvalue(L, 1);  /* package name */
+      lua_concat(L, 2);  /* concat directory with package name */
+      res = lua_dofile(L, lua_tostring(L, -1));  /* try to load it */
+      lua_settop(L, 4);  /* pop string and eventual results from dofile */
+      if (res == 0) break;  /* ok; file done */
+      else if (res != LUA_ERRFILE)
+        lua_error(L, NULL);  /* error running package; propagate it */
+      if (*(path+l) == l_c('\0'))  /* no more directories? */
+        luaL_verror(L, l_s("could not load package `%.20s' from path `%.200s'"),
+                    lua_tostring(L, 1), lua_tostring(L, 2));
+      path += l+1;  /* try next directory */
+    }
+  }
+  lua_pushvalue(L, 1);
+  lua_pushnumber(L, 1);
+  lua_settable(L, 4);  /* mark it as loaded */
+  return 0;
+}
+
+
+static int aux_unpack (lua_State *L, int arg) {
+  int n, i;
+  luaL_checktype(L, arg, LUA_TTABLE);
+  n = lua_getn(L, arg);
+  luaL_checkstack(L, n, l_s("table too big to unpack"));
+  for (i=1; i<=n; i++)  /* push arg[1...n] */
+    lua_rawgeti(L, arg, i);
+  return n;
+}
+
+
+static int luaB_unpack (lua_State *L) {
+  return aux_unpack(L, 1);
+}
+
+
+static int luaB_call (lua_State *L) {
+  int oldtop;
+  const l_char *options = luaL_opt_string(L, 3, l_s(""));
+  int err = 0;  /* index of old error method */
+  int status;
+  int n;
+  if (!lua_isnull(L, 4)) {  /* set new error method */
+    lua_getglobal(L, l_s(LUA_ERRORMESSAGE));
+    err = lua_gettop(L);  /* get index */
+    lua_pushvalue(L, 4);
+    lua_setglobal(L, l_s(LUA_ERRORMESSAGE));
+  }
+  oldtop = lua_gettop(L);  /* top before function-call preparation */
+  /* push function */
+  lua_pushvalue(L, 1);
+  n = aux_unpack(L, 2);  /* push arg[1...n] */
+  status = lua_call(L, n, LUA_MULTRET);
+  if (err != 0) {  /* restore old error method */
+    lua_pushvalue(L, err);
+    lua_setglobal(L, l_s(LUA_ERRORMESSAGE));
+  }
+  if (status != 0) {  /* error in call? */
+    if (strchr(options, l_c('x')))
+      lua_pushnil(L);  /* return nil to signal the error */
+    else
+      lua_error(L, NULL);  /* propagate error without additional messages */
+    return 1;
+  }
+  if (strchr(options, l_c('p')))  /* pack results? */
+    lua_error(L, l_s("deprecated option `p' in `call'"));
+  return lua_gettop(L) - oldtop;  /* results are already on the stack */
+}
+
+
+static int luaB_tostring (lua_State *L) {
+  l_char buff[64];
+  switch (lua_rawtag(L, 1)) {
+    case LUA_TNUMBER:
+      lua_pushstring(L, lua_tostring(L, 1));
+      return 1;
+    case LUA_TSTRING:
+      lua_pushvalue(L, 1);
+      return 1;
+    case LUA_TTABLE:
+      sprintf(buff, l_s("%.40s: %p"), lua_type(L, 1), lua_topointer(L, 1));
+      break;
+    case LUA_TFUNCTION:
+      sprintf(buff, l_s("function: %p"), lua_topointer(L, 1));
+      break;
+    case LUA_TUSERDATA: {
+      const l_char *t = lua_type(L, 1);
+      if (strcmp(t, l_s("userdata")) == 0)
+        sprintf(buff, l_s("userdata(%d): %p"), lua_tag(L, 1),
+                lua_touserdata(L, 1));
+      else
+        sprintf(buff, l_s("%.40s: %p"), t, lua_touserdata(L, 1));
+      break;
+    }
+    case LUA_TNIL:
+      lua_pushliteral(L, l_s("nil"));
+      return 1;
+    default:
+      luaL_argerror(L, 1, l_s("value expected"));
+  }
+  lua_pushstring(L, buff);
+  return 1;
+}
+
+
+static int luaB_foreachi (lua_State *L) {
+  int n, i;
+  luaL_checktype(L, 1, LUA_TTABLE);
+  luaL_checktype(L, 2, LUA_TFUNCTION);
+  n = lua_getn(L, 1);
+  for (i=1; i<=n; i++) {
+    lua_pushvalue(L, 2);  /* function */
+    lua_pushnumber(L, i);  /* 1st argument */
+    lua_rawgeti(L, 1, i);  /* 2nd argument */
+    lua_rawcall(L, 2, 1);
+    if (!lua_isnil(L, -1))
+      return 1;
+    lua_pop(L, 1);  /* remove nil result */
+  }
+  return 0;
+}
+
+
+static int luaB_foreach (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  luaL_checktype(L, 2, LUA_TFUNCTION);
+  lua_pushnil(L);  /* first index */
+  for (;;) {
+    if (lua_next(L, 1) == 0)
+      return 0;
+    lua_pushvalue(L, 2);  /* function */
+    lua_pushvalue(L, -3);  /* key */
+    lua_pushvalue(L, -3);  /* value */
+    lua_rawcall(L, 2, 1);
+    if (!lua_isnil(L, -1))
+      return 1;
+    lua_pop(L, 2);  /* remove value and result */
+  }
+}
+
+
+static int luaB_assert (lua_State *L) {
+  luaL_checkany(L, 1);
+  if (lua_isnil(L, 1))
+    luaL_verror(L, l_s("assertion failed!  %.90s"), luaL_opt_string(L, 2, l_s("")));
+  lua_settop(L, 1);
+  return 1;
+}
+
+
+static int luaB_getn (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TTABLE);
+  lua_pushnumber(L, lua_getn(L, 1));
+  return 1;
+}
+
+
+static int luaB_tinsert (lua_State *L) {
+  int v = lua_gettop(L);  /* last argument: to be inserted */
+  int n, pos;
+  luaL_checktype(L, 1, LUA_TTABLE);
+  n = lua_getn(L, 1);
+  if (v == 2)  /* called with only 2 arguments */
+    pos = n+1;
+  else
+    pos = luaL_check_int(L, 2);  /* 2nd argument is the position */
+  aux_setn(L, 1, n+1);  /* t.n = n+1 */
+  for (; n>=pos; n--) {
+    lua_rawgeti(L, 1, n);
+    lua_rawseti(L, 1, n+1);  /* t[n+1] = t[n] */
+  }
+  lua_pushvalue(L, v);
+  lua_rawseti(L, 1, pos);  /* t[pos] = v */
+  return 0;
+}
+
+
+static int luaB_tremove (lua_State *L) {
+  int pos, n;
+  luaL_checktype(L, 1, LUA_TTABLE);
+  n = lua_getn(L, 1);
+  pos = luaL_opt_int(L, 2, n);
+  if (n <= 0) return 0;  /* table is `empty' */
+  aux_setn(L, 1, n-1);  /* t.n = n-1 */
+  lua_rawgeti(L, 1, pos);  /* result = t[pos] */
+  for ( ;pos<n; pos++) {
+    lua_rawgeti(L, 1, pos+1);
+    lua_rawseti(L, 1, pos);  /* a[pos] = a[pos+1] */
+  }
+  lua_pushnil(L);
+  lua_rawseti(L, 1, n);  /* t[n] = nil */
+  return 1;
+}
+
+
+
+
+/*
+** {======================================================
+** Quicksort
+** (based on `Algorithms in MODULA-3', Robert Sedgewick;
+**  Addison-Wesley, 1993.)
+*/
+
+
+static void set2 (lua_State *L, int i, int j) {
+  lua_rawseti(L, 1, i);
+  lua_rawseti(L, 1, j);
+}
+
+static int sort_comp (lua_State *L, int a, int b) {
+  /* WARNING: the caller (auxsort) must ensure stack space */
+  if (!lua_isnil(L, 2)) {  /* function? */
+    int res;
+    lua_pushvalue(L, 2);
+    lua_pushvalue(L, a-1);  /* -1 to compensate function */
+    lua_pushvalue(L, b-2);  /* -2 to compensate function and `a' */
+    lua_rawcall(L, 2, 1);
+    res = !lua_isnil(L, -1);
+    lua_pop(L, 1);
+    return res;
+  }
+  else  /* a < b? */
+    return lua_lessthan(L, a, b);
+}
+
+static void auxsort (lua_State *L, int l, int u) {
+  while (l < u) {  /* for tail recursion */
+    int i, j;
+    /* sort elements a[l], a[(l+u)/2] and a[u] */
+    lua_rawgeti(L, 1, l);
+    lua_rawgeti(L, 1, u);
+    if (sort_comp(L, -1, -2))  /* a[u] < a[l]? */
+      set2(L, l, u);  /* swap a[l] - a[u] */
+    else
+      lua_pop(L, 2);
+    if (u-l == 1) break;  /* only 2 elements */
+    i = (l+u)/2;
+    lua_rawgeti(L, 1, i);
+    lua_rawgeti(L, 1, l);
+    if (sort_comp(L, -2, -1))  /* a[i]<a[l]? */
+      set2(L, i, l);
+    else {
+      lua_pop(L, 1);  /* remove a[l] */
+      lua_rawgeti(L, 1, u);
+      if (sort_comp(L, -1, -2))  /* a[u]<a[i]? */
+        set2(L, i, u);
+      else
+        lua_pop(L, 2);
+    }
+    if (u-l == 2) break;  /* only 3 elements */
+    lua_rawgeti(L, 1, i);  /* Pivot */
+    lua_pushvalue(L, -1);
+    lua_rawgeti(L, 1, u-1);
+    set2(L, i, u-1);
+    /* a[l] <= P == a[u-1] <= a[u], only need to sort from l+1 to u-2 */
+    i = l; j = u-1;
+    for (;;) {  /* invariant: a[l..i] <= P <= a[j..u] */
+      /* repeat ++i until a[i] >= P */
+      while (lua_rawgeti(L, 1, ++i), sort_comp(L, -1, -2)) {
+        if (i>u) lua_error(L, l_s("invalid order function for sorting"));
+        lua_pop(L, 1);  /* remove a[i] */
+      }
+      /* repeat --j until a[j] <= P */
+      while (lua_rawgeti(L, 1, --j), sort_comp(L, -3, -1)) {
+        if (j<l) lua_error(L, l_s("invalid order function for sorting"));
+        lua_pop(L, 1);  /* remove a[j] */
+      }
+      if (j<i) {
+        lua_pop(L, 3);  /* pop pivot, a[i], a[j] */
+        break;
+      }
+      set2(L, i, j);
+    }
+    lua_rawgeti(L, 1, u-1);
+    lua_rawgeti(L, 1, i);
+    set2(L, u-1, i);  /* swap pivot (a[u-1]) with a[i] */
+    /* a[l..i-1] <= a[i] == P <= a[i+1..u] */
+    /* adjust so that smaller half is in [j..i] and larger one in [l..u] */
+    if (i-l < u-i) {
+      j=l; i=i-1; l=i+2;
+    }
+    else {
+      j=i+1; i=u; u=j-2;
+    }
+    auxsort(L, j, i);  /* call recursively the smaller one */
+  }  /* repeat the routine for the larger one */
+}
+
+static int luaB_sort (lua_State *L) {
+  int n;
+  luaL_checktype(L, 1, LUA_TTABLE);
+  n = lua_getn(L, 1);
+  if (!lua_isnull(L, 2))  /* is there a 2nd argument? */
+    luaL_checktype(L, 2, LUA_TFUNCTION);
+  lua_settop(L, 2);  /* make sure there is two arguments */
+  auxsort(L, 1, n);
+  return 0;
+}
+
+/* }====================================================== */
+
+
+
+static const luaL_reg base_funcs[] = {
+  {l_s(LUA_ALERT), luaB__ALERT},
+  {l_s(LUA_ERRORMESSAGE), luaB__ERRORMESSAGE},
+  {l_s("call"), luaB_call},
+  {l_s("collectgarbage"), luaB_collectgarbage},
+  {l_s("copytagmethods"), luaB_copytagmethods},
+  {l_s("dofile"), luaB_dofile},
+  {l_s("dostring"), luaB_dostring},
+  {l_s("error"), luaB_error},
+  {l_s("foreach"), luaB_foreach},
+  {l_s("foreachi"), luaB_foreachi},
+  {l_s("gcinfo"), luaB_gcinfo},
+  {l_s("getglobal"), luaB_getglobal},
+  {l_s("gettagmethod"), luaB_gettagmethod},
+  {l_s("globals"), luaB_globals},
+  {l_s("loadfile"), luaB_loadfile},
+  {l_s("loadstring"), luaB_loadstring},
+  {l_s("newtype"), luaB_newtype},
+  {l_s("newtag"), luaB_newtype},  /* for compatibility 4.0 */
+  {l_s("next"), luaB_next},
+  {l_s("print"), luaB_print},
+  {l_s("rawget"), luaB_rawget},
+  {l_s("rawset"), luaB_rawset},
+  {l_s("rawgettable"), luaB_rawget},  /* for compatibility 3.2 */
+  {l_s("rawsettable"), luaB_rawset},  /* for compatibility 3.2 */
+  {l_s("rawtype"), luaB_rawtype},
+  {l_s("require"), luaB_require},
+  {l_s("setglobal"), luaB_setglobal},
+  {l_s("settag"), luaB_settype},  /* for compatibility 4.0 */
+  {l_s("settype"), luaB_settype},
+  {l_s("settagmethod"), luaB_settagmethod},
+  {l_s("tag"), luaB_tag},
+  {l_s("tonumber"), luaB_tonumber},
+  {l_s("tostring"), luaB_tostring},
+  {l_s("type"), luaB_type},
+  {l_s("assert"), luaB_assert},
+  {l_s("getn"), luaB_getn},
+  {l_s("sort"), luaB_sort},
+  {l_s("tinsert"), luaB_tinsert},
+  {l_s("tremove"), luaB_tremove},
+  {l_s("unpack"), luaB_unpack},
+  {l_s("weakmode"), luaB_weakmode}
+};
+
+
+
+LUALIB_API int lua_baselibopen (lua_State *L) {
+  luaL_openl(L, base_funcs);
+  lua_pushliteral(L, l_s(LUA_VERSION));
+  lua_setglobal(L, l_s("_VERSION"));
+  return 0;
+}
+

lbuffer.c

@@ -1,79 +0,0 @@
-/*
-** $Id: lbuffer.c,v 1.11 1999/11/22 13:12:07 roberto Exp roberto $
-** Auxiliary functions for building Lua libraries
-** See Copyright Notice in lua.h
-*/
-
-
-#include <stdio.h>
-
-#define LUA_REENTRANT
-
-#include "lauxlib.h"
-#include "lmem.h"
-#include "lstate.h"
-
-
-/*-------------------------------------------------------
-**  Auxiliary buffer
--------------------------------------------------------*/
-
-
-/*
-** amount of extra space (pre)allocated when buffer is reallocated
-*/
-#define EXTRABUFF	32
-
-
-#define openspace(L, size)  if (L->Mbuffnext+(size) > L->Mbuffsize) \
-                              Openspace(L, size)
-
-static void Openspace (lua_State *L, int size) {
-  L->Mbuffsize = (L->Mbuffnext+size+EXTRABUFF)*2;
-  luaM_reallocvector(L, L->Mbuffer, L->Mbuffsize, char);
-}
-
-
-char *luaL_openspace (lua_State *L, int size) {
-  openspace(L, size);
-  return L->Mbuffer+L->Mbuffnext;
-}
-
-
-void luaL_addchar (lua_State *L, int c) {
-  openspace(L, 1);
-  L->Mbuffer[L->Mbuffnext++] = (char)c;
-}
-
-
-void luaL_resetbuffer (lua_State *L) {
-  L->Mbuffnext = L->Mbuffbase;
-}
-
-
-void luaL_addsize (lua_State *L, int n) {
-  L->Mbuffnext += n;
-}
-
-int luaL_getsize (lua_State *L) {
-  return L->Mbuffnext-L->Mbuffbase;
-}
-
-int luaL_newbuffer (lua_State *L, int size) {
-  int old = L->Mbuffbase;
-  openspace(L, size);
-  L->Mbuffbase = L->Mbuffnext;
-  return old;
-}
-
-
-void luaL_oldbuffer (lua_State *L, int old) {
-  L->Mbuffnext = L->Mbuffbase;
-  L->Mbuffbase = old;
-}
-
-
-char *luaL_buffer (lua_State *L) {
-  return L->Mbuffer+L->Mbuffbase;
-}
-

lbuiltin.c

@@ -1,662 +0,0 @@
-/*
-** $Id: lbuiltin.c,v 1.105 2000/04/14 17:44:20 roberto Exp roberto $
-** Built-in functions
-** See Copyright Notice in lua.h
-*/
-
-
-/*
-** =========================================================================
-** All built-in functions are public (i.e. not static) and are named luaB_f,
-** where f is the function name in Lua. So, if you do not need all these
-** functions, you may register manually only the ones that you need.
-** =========================================================================
-*/
-
-
-#include <ctype.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define LUA_REENTRANT
-
-#include "lapi.h"
-#include "lauxlib.h"
-#include "lbuiltin.h"
-#include "ldo.h"
-#include "lfunc.h"
-#include "lmem.h"
-#include "lobject.h"
-#include "lstate.h"
-#include "lstring.h"
-#include "ltable.h"
-#include "ltm.h"
-#include "lua.h"
-#include "lundump.h"
-#include "lvm.h"
-
-
-
-/*
-** function defined in ltests.c, to open some internal-test functions
-*/
-void luaB_opentests (lua_State *L);
-
-
-
-/*
-** {======================================================
-** Auxiliary functions
-** =======================================================
-*/
-
-
-static void pushtagstring (lua_State *L, TString *s) {
-  ttype(L->top) = TAG_STRING;
-  tsvalue(L->top) = s;
-  incr_top;
-}
-
-
-static Number getsize (const Hash *h) {
-  Number max = 0;
-  int i = h->size;
-  Node *n = h->node;
-  while (i--) {
-    if (ttype(key(n)) == TAG_NUMBER && 
-        ttype(val(n)) != TAG_NIL &&
-        nvalue(key(n)) > max)
-      max = nvalue(key(n));
-    n++;
-  }
-  return max;
-}
-
-
-static Number getnarg (lua_State *L, const Hash *a) {
-  TObject index;
-  const TObject *value;
-  /* value = table.n */
-  ttype(&index) = TAG_STRING;
-  tsvalue(&index) = luaS_new(L, "n");
-  value = luaH_get(L, a, &index);
-  return (ttype(value) == TAG_NUMBER) ? nvalue(value) : getsize(a);
-}
-
-
-static Hash *gettable (lua_State *L, int arg) {
-  return avalue(luaL_tablearg(L, arg));
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Functions that use only the official API
-** =======================================================
-*/
-
-
-/*
-** If your system does not support `stderr', redefine this function, or
-** redefine _ERRORMESSAGE so that it won't need _ALERT.
-*/
-void luaB__ALERT (lua_State *L) {
-  fputs(luaL_check_string(L, 1), stderr);
-}
-
-
-/*
-** Standard implementation of _ERRORMESSAGE.
-** The library `liolib' redefines _ERRORMESSAGE for better error information.
-*/
-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 */
-    const char *s = luaL_check_string(L, 1);
-    char *buff = luaL_openspace(L, strlen(s)+sizeof("error: \n"));
-    strcpy(buff, "error: "); strcat(buff, s); strcat(buff, "\n");
-    lua_pushstring(L, buff);
-    lua_callfunction(L, al);
-  }
-}
-
-
-/*
-** If your system does not support `stdout', you can just remove this function.
-** If you need, you can define your own `print' function, following this
-** model but changing `fputs' to put the strings at a proper place
-** (a console window or a log file, for instance).
-*/
-void luaB_print (lua_State *L) {
-  lua_Object args[MAXPRINT];
-  lua_Object obj;
-  int n = 0;
-  int i;
-  while ((obj = lua_getparam(L, n+1)) != LUA_NOOBJECT) {
-    luaL_arg_check(L, n < MAXPRINT, n+1, "too many arguments");
-    args[n++] = obj;
-  }
-  for (i=0; i<n; i++) {
-    lua_pushobject(L, args[i]);
-    if (lua_call(L, "tostring"))
-      lua_error(L, "error in `tostring' called by `print'");
-    obj = lua_getresult(L, 1);
-    if (!lua_isstring(L, obj))
-      lua_error(L, "`tostring' must return a string to `print'");
-    if (i>0) fputs("\t", stdout);
-    fputs(lua_getstring(L, obj), stdout);
-  }
-  fputs("\n", stdout);
-}
-
-
-void luaB_tonumber (lua_State *L) {
-  int base = luaL_opt_int(L, 2, 10);
-  if (base == 10) {  /* standard conversion */
-    lua_Object o = luaL_nonnullarg(L, 1);
-    if (lua_isnumber(L, o)) {
-      lua_pushnumber(L, lua_getnumber(L, o));
-      return;
-    }
-  }
-  else {
-    const char *s1 = luaL_check_string(L, 1);
-    char *s2;
-    Number n;
-    luaL_arg_check(L, 2 <= base && base <= 36, 2, "base out of range");
-    n = strtoul(s1, &s2, base);
-    if (s1 != s2) {  /* at least one valid digit? */
-      while (isspace((unsigned char)*s2)) s2++;  /* skip trailing spaces */
-      if (*s2 == '\0') {  /* no invalid trailing characters? */
-        lua_pushnumber(L, n);
-        return;
-      }
-    }
-  }
-  lua_pushnil(L);  /* else not a number */
-}
-
-
-void luaB_error (lua_State *L) {
-  lua_error(L, luaL_opt_string(L, 1, NULL));
-}
-
-void luaB_setglobal (lua_State *L) {
-  const char *name = luaL_check_string(L, 1);
-  lua_Object value = luaL_nonnullarg(L, 2);
-  lua_pushobject(L, value);
-  lua_setglobal(L, name);
-}
-
-void luaB_rawsetglobal (lua_State *L) {
-  const char *name = luaL_check_string(L, 1);
-  lua_Object value = luaL_nonnullarg(L, 2);
-  lua_pushobject(L, value);
-  lua_rawsetglobal(L, name);
-}
-
-void luaB_getglobal (lua_State *L) {
-  lua_pushobject(L, lua_getglobal(L, luaL_check_string(L, 1)));
-}
-
-void luaB_rawgetglobal (lua_State *L) {
-  lua_pushobject(L, lua_rawgetglobal(L, luaL_check_string(L, 1)));
-}
-
-void luaB_tag (lua_State *L) {
-  lua_pushnumber(L, lua_tag(L, luaL_nonnullarg(L, 1)));
-}
-
-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 */
-}
-
-void luaB_newtag (lua_State *L) {
-  lua_pushnumber(L, lua_newtag(L));
-}
-
-void luaB_copytagmethods (lua_State *L) {
-  lua_pushnumber(L, lua_copytagmethods(L, luaL_check_int(L, 1),
-                                          luaL_check_int(L, 2)));
-}
-
-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));
-}
-
-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);
-}
-
-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);
-  luaL_arg_check(L, lua_isnil(L, nf) || lua_isfunction(L, nf), 3,
-                 "function or nil expected");
-  if (strcmp(event, "gc") == 0 && tag != TAG_NIL)
-    lua_error(L, "deprecated use: cannot set the `gc' tag method from Lua");
-  lua_pushobject(L, nf);
-  lua_pushobject(L, lua_settagmethod(L, tag, event));
-}
-
-void luaB_gettagmethod (lua_State *L) {
-  lua_pushobject(L, lua_gettagmethod(L, luaL_check_int(L, 1),
-                                        luaL_check_string(L, 2)));
-}
-
-
-void luaB_collectgarbage (lua_State *L) {
-  lua_pushnumber(L, lua_collectgarbage(L, luaL_opt_int(L, 1, 0)));
-}
-
-
-void luaB_type (lua_State *L) {
-  lua_Object o = luaL_nonnullarg(L, 1);
-  lua_pushstring(L, lua_type(L, o));
-}
-
-/* }====================================================== */
-
-
-/*
-** {======================================================
-** Functions that could use only the official API but
-** do not, for efficiency.
-** =======================================================
-*/
-
-
-static void passresults (lua_State *L) {
-  L->Cstack.base = L->Cstack.lua2C;  /* position of first result */
-  if (L->Cstack.num == 0)
-    lua_pushuserdata(L, NULL);  /* at least one result to signal no errors */
-}
-
-void luaB_dostring (lua_State *L) {
-  long l;
-  const char *s = luaL_check_lstr(L, 1, &l);
-  if (*s == ID_CHUNK)
-    lua_error(L, "`dostring' cannot run pre-compiled code");
-  if (lua_dobuffer(L, s, l, luaL_opt_string(L, 2, s)) == 0)
-    passresults(L);
-  else
-    lua_pushnil(L);
-}
-
-
-void luaB_dofile (lua_State *L) {
-  const char *fname = luaL_opt_string(L, 1, NULL);
-  if (lua_dofile(L, fname) == 0)
-    passresults(L);
-  else
-    lua_pushnil(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, "");
-  lua_Object err = lua_getparam(L, 4);
-  int narg = (int)getnarg(L, arg);
-  int i, status;
-  if (err != LUA_NOOBJECT) {  /* set new error method */
-    lua_Object oldem = lua_getglobal(L, "_ERRORMESSAGE");
-    lua_pushobject(L, err);
-    lua_setglobal(L, "_ERRORMESSAGE");
-    err = oldem;
-  }
-  /* push arg[1...n] */
-  luaD_checkstack(L, narg);
-  for (i=0; i<narg; i++)
-    *(L->top++) = *luaH_getint(L, arg, i+1);
-  status = lua_callfunction(L, f);
-  if (err != LUA_NOOBJECT) {  /* restore old error method */
-    lua_pushobject(L, err);
-    lua_setglobal(L, "_ERRORMESSAGE");
-  }
-  if (status != 0) {  /* error in call? */
-    if (strchr(options, 'x')) {
-      lua_pushnil(L);
-      return;  /* return nil to signal the error */
-    }
-    else
-      lua_error(L, NULL);  /* propagate error without additional messages */
-  }
-  else {  /* no errors */
-    if (strchr(options, 'p')) {  /* pack results? */
-      luaV_pack(L, L->Cstack.lua2C, L->Cstack.num, L->top);
-      incr_top;
-    }
-    else
-      L->Cstack.base = L->Cstack.lua2C;  /* position of first result */
-  }
-}
-
-
-void luaB_nextvar (lua_State *L) {
-  lua_Object o = lua_getparam(L, 1);
-  TString *name;
-  if (o == LUA_NOOBJECT || ttype(o) == TAG_NIL)
-    name = NULL;
-  else {
-    luaL_arg_check(L, ttype(o) == TAG_STRING, 1, "variable name expected");
-    name = tsvalue(o);
-  }
-  if (!luaA_nextvar(L, name))
-    lua_pushnil(L);
-}
-
-
-void luaB_next (lua_State *L) {
-  const Hash *a = gettable(L, 1);
-  lua_Object k = lua_getparam(L, 2);
-  int i;  /* `luaA_next' gets first element after `i' */
-  if (k == LUA_NOOBJECT || ttype(k) == TAG_NIL)
-    i = 0;  /* get first */
-  else {
-    i = luaH_pos(L, a, k)+1;
-    luaL_arg_check(L, i != 0, 2, "key not found");
-  }
-  if (luaA_next(L, a, i) == 0)
-    lua_pushnil(L);
-}
-
-
-void luaB_tostring (lua_State *L) {
-  lua_Object o = luaL_nonnullarg(L, 1);
-  char buff[64];
-  switch (ttype(o)) {
-    case TAG_NUMBER:
-      lua_pushstring(L, lua_getstring(L, o));
-      return;
-    case TAG_STRING:
-      lua_pushobject(L, o);
-      return;
-    case TAG_TABLE:
-      sprintf(buff, "table: %p", o->value.a);
-      break;
-    case TAG_LCLOSURE:  case TAG_CCLOSURE:
-      sprintf(buff, "function: %p", o->value.cl);
-      break;
-    case TAG_USERDATA:
-      sprintf(buff, "userdata: %p(%d)", o->value.ts->u.d.value,
-                                        o->value.ts->u.d.tag);
-      break;
-    case TAG_NIL:
-      lua_pushstring(L, "nil");
-      return;
-    default:
-      LUA_INTERNALERROR(L, "invalid type");
-  }
-  lua_pushstring(L, buff);
-}
-
-/* }====================================================== */
-
-
-
-/*
-** {======================================================
-** "Extra" functions
-** These functions can be written in Lua, so you can
-**  delete them if you need a tiny Lua implementation.
-** If you delete them, remove their entries in array
-** "builtin_funcs".
-** =======================================================
-*/
-
-void luaB_assert (lua_State *L) {
-  lua_Object p = luaL_nonnullarg(L, 1);
-  if (lua_isnil(L, p))
-    luaL_verror(L, "assertion failed!  %.90s", luaL_opt_string(L, 2, ""));
-}
-
-
-void luaB_foreachi (lua_State *L) {
-  const Hash *t = gettable(L, 1);
-  int n = (int)getnarg(L, t);
-  int i;
-  lua_Object f = luaL_functionarg(L, 2);
-  luaD_checkstack(L, 3);  /* for f, key, and val */
-  for (i=1; i<=n; i++) {
-    *(L->top++) = *f;
-    ttype(L->top) = TAG_NUMBER; nvalue(L->top++) = i;
-    *(L->top++) = *luaH_getint(L, t, i);
-    luaD_call(L, L->top-3, 1);
-    if (ttype(L->top-1) != TAG_NIL)
-      return;
-    L->top--;  /* remove nil result */
-  }
-}
-
-
-void luaB_foreach (lua_State *L) {
-  const Hash *a = gettable(L, 1);
-  lua_Object f = luaL_functionarg(L, 2);
-  int i;
-  luaD_checkstack(L, 3);  /* for f, key, and val */
-  for (i=0; i<a->size; i++) {
-    const Node *nd = &(a->node[i]);
-    if (ttype(val(nd)) != TAG_NIL) {
-      *(L->top++) = *f;
-      *(L->top++) = *key(nd);
-      *(L->top++) = *val(nd);
-      luaD_call(L, L->top-3, 1);
-      if (ttype(L->top-1) != TAG_NIL)
-        return;
-      L->top--;  /* remove result */
-    }
-  }
-}
-
-
-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 */
-  for (gv = L->rootglobal; gv; gv = gv->next) {
-    if (gv->value.ttype != TAG_NIL) {
-      pushtagstring(L, gv->name);  /* keep (extra) name on stack to avoid GC */
-      *(L->top++) = *f;
-      pushtagstring(L, gv->name);
-      *(L->top++) = gv->value;
-      luaD_call(L, L->top-3, 1);
-      if (ttype(L->top-1) != TAG_NIL) {
-        *(L->top-2) = *(L->top-1);  /* remove extra name */
-        L->top--;
-        return;
-      }
-      L->top-=2;  /* remove result and extra name */
-    }
-  }
-}
-
-
-void luaB_getn (lua_State *L) {
-  lua_pushnumber(L, getnarg(L, gettable(L, 1)));
-}
-
-
-void luaB_tinsert (lua_State *L) {
-  Hash *a = gettable(L, 1);
-  lua_Object v = lua_getparam(L, 3);
-  int n = (int)getnarg(L, a);
-  int pos;
-  if (v != LUA_NOOBJECT)
-    pos = luaL_check_int(L, 2);
-  else {  /* called with only 2 arguments */
-    v = luaL_nonnullarg(L, 2);
-    pos = n+1;
-  }
-  luaV_setn(L, a, n+1);  /* a.n = n+1 */
-  for (; n>=pos; n--)
-    luaH_move(L, a, n, n+1);  /* a[n+1] = a[n] */
-  luaH_setint(L, a, pos, v);  /* a[pos] = v */
-}
-
-
-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);
-  if (n <= 0) return;  /* table is "empty" */
-  luaA_pushobject(L, luaH_getint(L, a, pos));  /* result = a[pos] */
-  for ( ;pos<n; pos++)
-    luaH_move(L, a, pos+1, pos);  /* a[pos] = a[pos+1] */
-  luaV_setn(L, a, n-1);  /* a.n = n-1 */
-  luaH_setint(L, a, n, &luaO_nilobject);  /* a[n] = nil */
-}
-
-
-/*
-** {======================================================
-** Quicksort
-** (based on `Algorithms in MODULA-3', Robert Sedgewick; Addison-Wesley, 1993.)
-*/
-
-static void swap (lua_State *L, Hash *a, int i, int j) {
-  TObject temp;
-  temp = *luaH_getint(L, a, i);
-  luaH_move(L, a, j, i);
-  luaH_setint(L, a, j, &temp);
-}
-
-static int sort_comp (lua_State *L, lua_Object f, const TObject *a,
-                                                  const TObject *b) {
-  /* WARNING: the caller (auxsort) must ensure stack space */
-  if (f != LUA_NOOBJECT) {
-    *(L->top) = *f;
-    *(L->top+1) = *a;
-    *(L->top+2) = *b;
-    L->top += 3;
-    luaD_call(L, L->top-3, 1);
-    L->top--;
-    return (ttype(L->top) != TAG_NIL);
-  }
-  else  /* a < b? */
-    return luaV_lessthan(L, a, b, L->top);
-}
-
-static void auxsort (lua_State *L, Hash *a, int l, int u, lua_Object f) {
-  StkId P = L->top++;  /* temporary place for pivot */
-  ttype(P) = TAG_NIL;
-  while (l < u) {  /* for tail recursion */
-    int i, j;
-    /* sort elements a[l], a[(l+u)/2] and a[u] */
-    if (sort_comp(L, f, luaH_getint(L, a, u), luaH_getint(L, a, l)))
-      swap(L, a, l, u);  /* a[u]<a[l] */
-    if (u-l == 1) break;  /* only 2 elements */
-    i = (l+u)/2;
-    *P = *luaH_getint(L, a, i);  /* P = a[i] */
-    if (sort_comp(L, f, P, luaH_getint(L, a, l)))  /* a[i]<a[l]? */
-      swap(L, a, l, i);
-    else if (sort_comp(L, f, luaH_getint(L, a, u), P))  /* a[u]<a[i]? */
-      swap(L, a, i, u);
-    if (u-l == 2) break;  /* only 3 elements */
-    *P = *luaH_getint(L, a, i);  /* save pivot on stack (GC) */
-    swap(L, a, i, u-1);  /* put median element as pivot (a[u-1]) */
-    /* a[l] <= P == a[u-1] <= a[u], only needs to sort from l+1 to u-2 */
-    i = l; j = u-1;
-    for (;;) {  /* invariant: a[l..i] <= P <= a[j..u] */
-      /* repeat i++ until a[i] >= P */
-      while (sort_comp(L, f, luaH_getint(L, a, ++i), P))
-        if (i>u) lua_error(L, "invalid order function for sorting");
-      /* repeat j-- until a[j] <= P */
-      while (sort_comp(L, f, P, luaH_getint(L, a, --j)))
-        if (j<l) lua_error(L, "invalid order function for sorting");
-      if (j<i) break;
-      swap(L, a, i, j);
-    }
-    swap(L, a, u-1, i);  /* swap pivot (a[u-1]) with a[i] */
-    /* a[l..i-1] <= a[i] == P <= a[i+1..u] */
-    /* adjust so that smaller "half" is in [j..i] and larger one in [l..u] */
-    if (i-l < u-i) {
-      j=l; i=i-1; l=i+2;
-    }
-    else {
-      j=i+1; i=u; u=j-2;
-    }
-    auxsort(L, a, j, i, f);  /* call recursively the smaller one */
-  }  /* repeat the routine for the larger one */
-  L->top--;  /* remove pivot from stack */
-}
-
-void luaB_sort (lua_State *L) {
-  Hash *a = gettable(L, 1);
-  int n = (int)getnarg(L, a);
-  lua_Object func = lua_getparam(L, 2);
-  luaL_arg_check(L, func == LUA_NOOBJECT || lua_isfunction(L, func), 2,
-                 "function expected");
-  luaD_checkstack(L, 4);  /* for pivot, f, a, b (sort_comp) */
-  auxsort(L, a, 1, n, func);
-}
-
-/* }====================================================== */
-
-
-/* }====================================================== */
-
-
-static const struct luaL_reg builtin_funcs[] = {
-  {"_ALERT", luaB__ALERT},
-  {"_ERRORMESSAGE", luaB__ERRORMESSAGE},
-  {"call", luaB_call},
-  {"collectgarbage", luaB_collectgarbage},
-  {"copytagmethods", luaB_copytagmethods},
-  {"dofile", luaB_dofile},
-  {"dostring", luaB_dostring},
-  {"error", luaB_error},
-  {"getglobal", luaB_getglobal},
-  {"gettagmethod", luaB_gettagmethod},
-  {"newtag", luaB_newtag},
-  {"next", luaB_next},
-  {"nextvar", luaB_nextvar},
-  {"print", luaB_print},
-  {"rawgetglobal", luaB_rawgetglobal},
-  {"rawgettable", luaB_rawgettable},
-  {"rawsetglobal", luaB_rawsetglobal},
-  {"rawsettable", luaB_rawsettable},
-  {"setglobal", luaB_setglobal},
-  {"settag", luaB_settag},
-  {"settagmethod", luaB_settagmethod},
-  {"tag", luaB_tag},
-  {"tonumber", luaB_tonumber},
-  {"tostring", luaB_tostring},
-  {"type", luaB_type},
-/* "Extra" functions */
-  {"assert", luaB_assert},
-  {"foreach", luaB_foreach},
-  {"foreachi", luaB_foreachi},
-  {"foreachvar", luaB_foreachvar},
-  {"getn", luaB_getn},
-  {"sort", luaB_sort},
-  {"tinsert", luaB_tinsert},
-  {"tremove", luaB_tremove}
-};
-
-
-void luaB_predefine (lua_State *L) {
-  /* pre-register mem error messages, to avoid loop when error arises */
-  luaS_newfixed(L, tableEM);
-  luaS_newfixed(L, memEM);
-  luaL_openl(L, builtin_funcs);
-#ifdef DEBUG
-  luaB_opentests(L);  /* internal test functions */
-#endif
-  lua_pushstring(L, LUA_VERSION);
-  lua_setglobal(L, "_VERSION");
-}
-

lbuiltin.h

@@ -1,49 +0,0 @@
-/*
-** $Id: lbuiltin.h,v 1.6 2000/03/03 14:58:26 roberto Exp roberto $
-** Built-in functions
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lbuiltin_h
-#define lbuiltin_h
-
-#include "lua.h"
-
-void luaB__ALERT (lua_State *L);
-void luaB__ERRORMESSAGE (lua_State *L);
-void luaB_assert (lua_State *L);
-void luaB_call (lua_State *L);
-void luaB_collectgarbage (lua_State *L);
-void luaB_copytagmethods (lua_State *L);
-void luaB_dofile (lua_State *L);
-void luaB_dostring (lua_State *L);
-void luaB_error (lua_State *L);
-void luaB_foreach (lua_State *L);
-void luaB_foreachi (lua_State *L);
-void luaB_foreachvar (lua_State *L);
-void luaB_getglobal (lua_State *L);
-void luaB_getn (lua_State *L);
-void luaB_gettagmethod (lua_State *L);
-void luaB_newtag (lua_State *L);
-void luaB_next (lua_State *L);
-void luaB_nextvar (lua_State *L);
-void luaB_print (lua_State *L);
-void luaB_rawgetglobal (lua_State *L);
-void luaB_rawgettable (lua_State *L);
-void luaB_rawsetglobal (lua_State *L);
-void luaB_rawsettable (lua_State *L);
-void luaB_setglobal (lua_State *L);
-void luaB_settag (lua_State *L);
-void luaB_settagmethod (lua_State *L);
-void luaB_sort (lua_State *L);
-void luaB_tag (lua_State *L);
-void luaB_tinsert (lua_State *L);
-void luaB_tonumber (lua_State *L);
-void luaB_tostring (lua_State *L);
-void luaB_tremove (lua_State *L);
-void luaB_type (lua_State *L);
-
-void luaB_predefine (lua_State *L);
-
-
-#endif

lcode.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.h,v 1.11 2000/04/07 19:35:20 roberto Exp roberto $
+** $Id: lcode.h,v 1.23 2001/06/12 14:36:48 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -20,27 +20,48 @@
 #define NO_JUMP (-1)
 
 
-void luaK_error (LexState *ls, const char *msg);
-int luaK_code0 (FuncState *fs, OpCode o);
-int luaK_code1 (FuncState *fs, OpCode o, int arg1);
-int luaK_code2 (FuncState *fs, OpCode o, int arg1, int arg2);
+/*
+** grep "ORDER OPR" if you change these enums
+*/
+typedef enum BinOpr {
+  OPR_ADD, OPR_SUB, OPR_MULT, OPR_DIV, OPR_POW,
+  OPR_CONCAT,
+  OPR_NE, OPR_EQ, OPR_LT, OPR_LE, OPR_GT, OPR_GE,
+  OPR_AND, OPR_OR,
+  OPR_NOBINOPR
+} BinOpr;
+
+#define binopistest(op)	((op) >= OPR_NE)
+
+typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_NOUNOPR } UnOpr;
+
+
+#define luaK_codeAsBc(fs,o,A,sBc)	luaK_codeABc(fs,o,A,(sBc)+MAXARG_sBc)
+
+void luaK_error (LexState *ls, const l_char *msg);
+int luaK_codeABc (FuncState *fs, OpCode o, int A, unsigned int Bc);
+int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
+void luaK_nil (FuncState *fs, int from, int n);
+void luaK_reserveregs (FuncState *fs, int n);
+int luaK_stringk (FuncState *fs, TString *s);
+void luaK_dischargevars (FuncState *fs, expdesc *e);
+int luaK_exp2anyreg (FuncState *fs, expdesc *e);
+void luaK_exp2nextreg (FuncState *fs, expdesc *e);
+void luaK_exp2val (FuncState *fs, expdesc *e);
+int luaK_exp2RK (FuncState *fs, expdesc *e);
+void luaK_self (FuncState *fs, expdesc *e, expdesc *key);
+void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k);
+void luaK_goiftrue (FuncState *fs, expdesc *e);
+void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e);
+void luaK_setcallreturns (FuncState *fs, expdesc *var, int nresults);
 int luaK_jump (FuncState *fs);
 void luaK_patchlist (FuncState *fs, int list, int target);
+void luaK_fixfor (FuncState *fs, int pc, int dest);
 void luaK_concat (FuncState *fs, int *l1, int l2);
-void luaK_goiftrue (FuncState *fs, expdesc *v, int keepvalue);
-void luaK_goiffalse (FuncState *fs, expdesc *v, int keepvalue);
 int luaK_getlabel (FuncState *fs);
-void luaK_deltastack (FuncState *fs, int delta);
-void luaK_kstr (LexState *ls, int c);
-void luaK_number (FuncState *fs, Number f);
-void luaK_adjuststack (FuncState *fs, int n);
-int luaK_lastisopen (FuncState *fs);
-void luaK_setcallreturns (FuncState *fs, int nresults);
-void luaK_tostack (LexState *ls, expdesc *v, int onlyone);
-void luaK_storevar (LexState *ls, const expdesc *var);
-void luaK_prefix (LexState *ls, int op, expdesc *v);
-void luaK_infix (LexState *ls, int op, expdesc *v);
-void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2);
+void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v);
+void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
+void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2);
 
 
 #endif

ldblib.c

@@ -1,176 +1,188 @@
 /*
-** $Id: ldblib.c,v 1.12 2000/03/30 17:19:48 roberto Exp roberto $
+** $Id: ldblib.c,v 1.36 2001/03/26 14:31:49 roberto Exp roberto $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
 
 
+#include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
 #include "lauxlib.h"
-#include "lua.h"
 #include "luadebug.h"
 #include "lualib.h"
 
 
 
-static void settabss (lua_State *L, lua_Object t, const char *i, const char *v) {
-  lua_pushobject(L, t);
+static void settabss (lua_State *L, const l_char *i, const l_char *v) {
   lua_pushstring(L, i);
   lua_pushstring(L, v);
-  lua_settable(L);
+  lua_settable(L, -3);
 }
 
 
-static void settabsi (lua_State *L, lua_Object t, const char *i, int v) {
-  lua_pushobject(L, t);
+static void settabsi (lua_State *L, const l_char *i, int v) {
   lua_pushstring(L, i);
   lua_pushnumber(L, v);
-  lua_settable(L);
+  lua_settable(L, -3);
 }
 
 
-static void settabso (lua_State *L, lua_Object t, const char *i, lua_Object v) {
-  lua_pushobject(L, t);
-  lua_pushstring(L, i);
-  lua_pushobject(L, v);
-  lua_settable(L);
-}
-
-
-static void getstack (lua_State *L) {
+static int getinfo (lua_State *L) {
   lua_Debug ar;
-  if (!lua_getstack(L, luaL_check_int(L, 1), &ar))  /* level out of range? */
-    return;
-  else {
-    const char *options = luaL_check_string(L, 2);
-    lua_Object res = lua_createtable(L);
-    if (!lua_getinfo(L, options, &ar))
-      luaL_argerror(L, 2, "invalid option");
-    for (; *options; options++) {
-      switch (*options) {
-        case 'S':
-          settabss(L, res, "source", ar.source);
-          settabsi(L, res, "linedefined", ar.linedefined);
-          settabss(L, res, "what", ar.what);
-          break;
-        case 'l':
-          settabsi(L, res, "currentline", ar.currentline);
-          break;
-        case 'u':
-          settabsi(L, res, "nups", ar.nups);
-          break;
-        case 'n':
-          settabss(L, res, "name", ar.name);
-          settabss(L, res, "namewhat", ar.namewhat);
-          break;
-        case 'f':
-          settabso(L, res, "func", ar.func);
-          break;
-
-      }
+  const l_char *options = luaL_opt_string(L, 2, l_s("flnSu"));
+  l_char buff[20];
+  if (lua_isnumber(L, 1)) {
+    if (!lua_getstack(L, (int)lua_tonumber(L, 1), &ar)) {
+      lua_pushnil(L);  /* level out of range */
+      return 1;
     }
-    lua_pushobject(L, res);
   }
+  else if (lua_isfunction(L, 1)) {
+    lua_pushvalue(L, 1);
+    sprintf(buff, l_s(">%.10s"), options);
+    options = buff;
+  }
+  else
+    luaL_argerror(L, 1, l_s("function or level expected"));
+  if (!lua_getinfo(L, options, &ar))
+    luaL_argerror(L, 2, l_s("invalid option"));
+  lua_newtable(L);
+  for (; *options; options++) {
+    switch (*options) {
+      case l_c('S'):
+        settabss(L, l_s("source"), ar.source);
+        if (ar.source)
+          settabss(L, l_s("short_src"), ar.short_src);
+        settabsi(L, l_s("linedefined"), ar.linedefined);
+        settabss(L, l_s("what"), ar.what);
+        break;
+      case l_c('l'):
+        settabsi(L, l_s("currentline"), ar.currentline);
+        break;
+      case l_c('u'):
+        settabsi(L, l_s("nups"), ar.nups);
+        break;
+      case l_c('n'):
+        settabss(L, l_s("name"), ar.name);
+        settabss(L, l_s("namewhat"), ar.namewhat);
+        break;
+      case l_c('f'):
+        lua_pushliteral(L, l_s("func"));
+        lua_pushvalue(L, -3);
+        lua_settable(L, -3);
+        break;
+    }
+  }
+  return 1;  /* return table */
 }
     
 
-static void getlocal (lua_State *L) {
+static int getlocal (lua_State *L) {
   lua_Debug ar;
-  lua_Localvar lvar;
+  const l_char *name;
   if (!lua_getstack(L, luaL_check_int(L, 1), &ar))  /* level out of range? */
-    luaL_argerror(L, 1, "level out of range");
-  lvar.index = luaL_check_int(L, 2);
-  if (lua_getlocal(L, &ar, &lvar)) {
-    lua_pushstring(L, lvar.name);
-    lua_pushobject(L, lvar.value);
+    luaL_argerror(L, 1, l_s("level out of range"));
+  name = lua_getlocal(L, &ar, luaL_check_int(L, 2));
+  if (name) {
+    lua_pushstring(L, name);
+    lua_pushvalue(L, -2);
+    return 2;
+  }
+  else {
+    lua_pushnil(L);
+    return 1;
   }
-  else lua_pushnil(L);
 }
 
 
-static void setlocal (lua_State *L) {
+static int setlocal (lua_State *L) {
   lua_Debug ar;
-  lua_Localvar lvar;
   if (!lua_getstack(L, luaL_check_int(L, 1), &ar))  /* level out of range? */
-    luaL_argerror(L, 1, "level out of range");
-  lvar.index = luaL_check_int(L, 2);
-  lvar.value = luaL_nonnullarg(L, 3);
-  if (lua_setlocal(L, &ar, &lvar))
-    lua_pushstring(L, lvar.name);
-  else lua_pushnil(L);
+    luaL_argerror(L, 1, l_s("level out of range"));
+  luaL_checkany(L, 3);
+  lua_pushstring(L, lua_setlocal(L, &ar, luaL_check_int(L, 2)));
+  return 1;
 }
 
 
-/*
-** because of these variables, this module is not reentrant, and should
-** not be used in multiple states
-*/
 
-static int linehook = LUA_NOREF;  /* Lua reference to line hook function */
-static int callhook = LUA_NOREF;  /* Lua reference to call hook function */
+#define KEY_CALLHOOK	l_s("luadblibCallhook")
+#define KEY_LINEHOOK	l_s("luadblibLinehook")
 
 
-
-static void linef (lua_State *L, lua_Debug *ar) {
-  if (linehook != LUA_NOREF) {
-    lua_pushnumber(L, ar->currentline);
-    lua_callfunction(L, lua_getref(L, linehook));
+static void hookf (lua_State *L, const l_char *key) {
+  lua_getregistry(L);
+  lua_pushstring(L, key);
+  lua_gettable(L, -2);
+  if (lua_isfunction(L, -1)) {
+    lua_pushvalue(L, -3);  /* original argument (below table and function) */
+    lua_rawcall(L, 1, 0);
   }
+  else
+    lua_pop(L, 1);  /* pop result from gettable */
+  lua_pop(L, 1);  /* pop table */
 }
 
 
 static void callf (lua_State *L, lua_Debug *ar) {
-  if (callhook != LUA_NOREF) {
-    lua_pushstring(L, ar->event);
-    lua_callfunction(L, lua_getref(L, callhook));
-  }
+  lua_pushstring(L, ar->event);
+  hookf(L, KEY_CALLHOOK);
 }
 
 
-static void setcallhook (lua_State *L) {
-  lua_Object f = lua_getparam(L, 1);
-  lua_unref(L, callhook);
-  if (f == LUA_NOOBJECT) {
-    callhook = LUA_NOREF;
-    lua_setcallhook(L, NULL);
-  }
-  else {
-    lua_pushobject(L, f);
-    callhook = lua_ref(L, 1);
-    lua_setcallhook(L, callf);
-  }
+static void linef (lua_State *L, lua_Debug *ar) {
+  lua_pushnumber(L, ar->currentline);
+  hookf(L, KEY_LINEHOOK);
 }
 
 
-static void setlinehook (lua_State *L) {
-  lua_Object f = lua_getparam(L, 1);
-  lua_unref(L, linehook);
-  if (f == LUA_NOOBJECT) {
-    linehook = LUA_NOREF;
-    lua_setlinehook(L, NULL);
-  }
-  else {
-    lua_pushobject(L, f);
-    linehook = lua_ref(L, 1);
-    lua_setlinehook(L, linef);
-  }
+static void sethook (lua_State *L, const l_char *key, lua_Hook hook,
+                     lua_Hook (*sethookf)(lua_State * L, lua_Hook h)) {
+  lua_settop(L, 1);
+  if (lua_isnil(L, 1))
+    (*sethookf)(L, NULL);
+  else if (lua_isfunction(L, 1))
+    (*sethookf)(L, hook);
+  else
+    luaL_argerror(L, 1, l_s("function expected"));
+  lua_getregistry(L);
+  lua_pushstring(L, key);
+  lua_pushvalue(L, -1);  /* dup key */
+  lua_gettable(L, -3);   /* get old value */
+  lua_pushvalue(L, -2);  /* key (again) */
+  lua_pushvalue(L, 1);
+  lua_settable(L, -5);  /* set new value */
 }
 
 
-static const struct luaL_reg dblib[] = {
-  {"getlocal", getlocal},
-  {"getstack", getstack},
-  {"setcallhook", setcallhook},
-  {"setlinehook", setlinehook},
-  {"setlocal", setlocal}
+static int setcallhook (lua_State *L) {
+  sethook(L, KEY_CALLHOOK, callf, lua_setcallhook);
+  return 1;
+}
+
+
+static int setlinehook (lua_State *L) {
+  sethook(L, KEY_LINEHOOK, linef, lua_setlinehook);
+  return 1;
+}
+
+
+static const luaL_reg dblib[] = {
+  {l_s("getlocal"), getlocal},
+  {l_s("getinfo"), getinfo},
+  {l_s("setcallhook"), setcallhook},
+  {l_s("setlinehook"), setlinehook},
+  {l_s("setlocal"), setlocal}
 };
 
 
-void lua_dblibopen (lua_State *L) {
+LUALIB_API int lua_dblibopen (lua_State *L) {
   luaL_openl(L, dblib);
+  return 0;
 }
 

ldebug.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.c,v 1.15 2000/03/30 17:19:48 roberto Exp roberto $
+** $Id: ldebug.c,v 1.86 2001/06/28 19:58:57 roberto Exp roberto $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
@@ -7,215 +7,560 @@
 
 #include <stdlib.h>
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
 #include "lapi.h"
-#include "lauxlib.h"
+#include "lcode.h"
 #include "ldebug.h"
 #include "ldo.h"
 #include "lfunc.h"
 #include "lobject.h"
+#include "lopcodes.h"
 #include "lstate.h"
+#include "lstring.h"
 #include "ltable.h"
 #include "ltm.h"
-#include "lua.h"
 #include "luadebug.h"
+#include "lvm.h"
 
 
-static const lua_Type normtype[] = {  /* ORDER LUA_T */
-  TAG_USERDATA, TAG_NUMBER, TAG_STRING, TAG_TABLE,
-  TAG_LCLOSURE, TAG_CCLOSURE, TAG_NIL,
-  TAG_LCLOSURE, TAG_CCLOSURE   /* TAG_LMARK, TAG_CMARK */
-};
+
+static const l_char *getfuncname (lua_State *L, CallInfo *ci,
+                                  const l_char **name);
 
 
-static void setnormalized (TObject *d, const TObject *s) {
-  d->value = s->value;
-  d->ttype = normtype[ttype(s)];
+
+static int isLmark (CallInfo *ci) {
+  lua_assert(ci == NULL || ttype(ci->base - 1) == LUA_TFUNCTION);
+  return (ci && ci->prev && !ci_func(ci)->isC);
 }
 
 
-
-static int hasdebuginfo (lua_State *L, StkId f) {
-  return (f+1 < L->top && (f+1)->ttype == TAG_LINE);
-}
-
-
-lua_Hook lua_setcallhook (lua_State *L, lua_Hook func) {
-  lua_Hook oldhook = L->callhook;
+LUA_API lua_Hook lua_setcallhook (lua_State *L, lua_Hook func) {
+  lua_Hook oldhook;
+  lua_lock(L);
+  oldhook = L->callhook;
   L->callhook = func;
+  lua_unlock(L);
   return oldhook;
 }
 
 
-lua_Hook lua_setlinehook (lua_State *L, lua_Hook func) {
-  lua_Hook oldhook = L->linehook;
+LUA_API lua_Hook lua_setlinehook (lua_State *L, lua_Hook func) {
+  lua_Hook oldhook;
+  lua_lock(L);
+  oldhook = L->linehook;
   L->linehook = func;
+  lua_unlock(L);
   return oldhook;
 }
 
 
-int lua_setdebug (lua_State *L, int debug) {
-  int old = L->debug;
-  L->debug = debug;
-  return old;
+static CallInfo *ci_stack (lua_State *L, StkId obj) {
+  CallInfo *ci = L->ci;
+  while (ci->base > obj) ci = ci->prev;
+  return (ci != &L->basefunc) ? ci : NULL;
 }
 
 
-static StkId aux_stackedfunction (lua_State *L, int level, StkId top) {
-  int i;
-  for (i = (top-1)-L->stack; i>=0; i--) {
-    if (is_T_MARK(L->stack[i].ttype)) {
-      if (level == 0)
-        return L->stack+i;
-      level--;
+LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
+  CallInfo *ci;
+  int status;
+  lua_lock(L);
+  ci = L->ci;
+  while (level-- && ci != &L->basefunc) {
+    lua_assert(ci->base > ci->prev->base);
+    ci = ci->prev;
+  }
+  if (ci == &L->basefunc) status = 0;  /* there is no such level */
+  else {
+    ar->_ci = ci;
+    status = 1;
+  }
+  lua_unlock(L);
+  return status;
+}
+
+
+int luaG_getline (int *lineinfo, int pc, int refline, int *prefi) {
+  int refi;
+  if (lineinfo == NULL || pc == -1)
+    return -1;  /* no line info or function is not active */
+  refi = prefi ? *prefi : 0;
+  if (lineinfo[refi] < 0)
+    refline += -lineinfo[refi++];
+  lua_assert(lineinfo[refi] >= 0);
+  while (lineinfo[refi] > pc) {
+    refline--;
+    refi--;
+    if (lineinfo[refi] < 0)
+      refline -= -lineinfo[refi--];
+    lua_assert(lineinfo[refi] >= 0);
+  }
+  for (;;) {
+    int nextline = refline + 1;
+    int nextref = refi + 1;
+    if (lineinfo[nextref] < 0)
+      nextline += -lineinfo[nextref++];
+    lua_assert(lineinfo[nextref] >= 0);
+    if (lineinfo[nextref] > pc)
+      break;
+    refline = nextline;
+    refi = nextref;
+  }
+  if (prefi) *prefi = refi;
+  return refline;
+}
+
+
+static int currentpc (CallInfo *ci) {
+  lua_assert(isLmark(ci));
+  if (ci->pc)
+    return (*ci->pc - ci_func(ci)->f.l->code) - 1;
+  else
+    return -1;  /* function is not active */
+}
+
+
+static int currentline (CallInfo *ci) {
+  if (!isLmark(ci))
+    return -1;  /* only active lua functions have current-line information */
+  else {
+    int *lineinfo = ci_func(ci)->f.l->lineinfo;
+    return luaG_getline(lineinfo, currentpc(ci), 1, NULL);
+  }
+}
+
+
+
+static Proto *getluaproto (CallInfo *ci) {
+  return (isLmark(ci) ? ci_func(ci)->f.l : NULL);
+}
+
+
+LUA_API const l_char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
+  const l_char *name;
+  CallInfo *ci;
+  Proto *fp;
+  lua_lock(L);
+  name = NULL;
+  ci = ar->_ci;
+  fp = getluaproto(ci);
+  if (fp) {  /* is a Lua function? */
+    name = luaF_getlocalname(fp, n, currentpc(ci));
+    if (name)
+      luaA_pushobject(L, ci->base+(n-1));  /* push value */
+  }
+  lua_unlock(L);
+  return name;
+}
+
+
+LUA_API const l_char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
+  const l_char *name;
+  CallInfo *ci;
+  Proto *fp;
+  lua_lock(L);
+  name = NULL;
+  ci = ar->_ci;
+  fp = getluaproto(ci);
+  L->top--;  /* pop new value */
+  if (fp) {  /* is a Lua function? */
+    name = luaF_getlocalname(fp, n, currentpc(ci));
+    if (!name || name[0] == l_c('('))  /* `(' starts private locals */
+      name = NULL;
+    else
+      setobj(ci->base+(n-1), L->top);
+  }
+  lua_unlock(L);
+  return name;
+}
+
+
+static void infoLproto (lua_Debug *ar, Proto *f) {
+  ar->source = getstr(f->source);
+  ar->linedefined = f->lineDefined;
+  ar->what = l_s("Lua");
+}
+
+
+static void funcinfo (lua_State *L, lua_Debug *ar, StkId func) {
+  Closure *cl;
+  if (ttype(func) == LUA_TFUNCTION)
+    cl = clvalue(func);
+  else {
+    luaD_error(L, l_s("value for `lua_getinfo' is not a function"));
+    cl = NULL;  /* to avoid warnings */
+  }
+  if (cl->isC) {
+    ar->source = l_s("=C");
+    ar->linedefined = -1;
+    ar->what = l_s("C");
+  }
+  else
+    infoLproto(ar, cl->f.l);
+  luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
+  if (ar->linedefined == 0)
+    ar->what = l_s("main");
+}
+
+
+static const l_char *travtagmethods (global_State *G, const TObject *o) {
+  if (ttype(o) == LUA_TFUNCTION) {
+    int e;
+    for (e=0; e<TM_N; e++) {
+      int t;
+      for (t=0; t<G->ntag; t++)
+        if (clvalue(o) == luaT_gettm(G, t, e))
+          return luaT_eventname[e];
     }
   }
   return NULL;
 }
 
 
-int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
-  StkId f = aux_stackedfunction(L, level, L->top);
-  if (f == NULL) return 0;  /* there is no such level */
-  else {
-    ar->_func = f;
-    return 1;
+static const l_char *travglobals (lua_State *L, const TObject *o) {
+  Hash *g = L->gt;
+  int i;
+  for (i=0; i<g->size; i++) {
+    if (luaO_equalObj(o, val(node(g, i))) &&
+        ttype(key(node(g, i))) == LUA_TSTRING)
+      return getstr(tsvalue(key(node(g, i))));
   }
+  return NULL;
 }
 
 
-static int lua_nups (StkId f) {
-  switch (ttype(f)) {
-    case TAG_LCLOSURE:  case TAG_CCLOSURE:
-    case TAG_LMARK:   case TAG_CMARK:
-      return f->value.cl->nelems;
-    default:
-      return 0;
-  }
-}
-
-
-static int lua_currentline (lua_State *L, StkId f) {
-  return hasdebuginfo(L, f) ? (f+1)->value.i : -1;
-}
-
-
-static Proto *getluaproto (StkId f) {
-  return (ttype(f) == TAG_LMARK) ?  clvalue(f)->f.l : NULL;
-}
-
-
-int lua_getlocal (lua_State *L, const lua_Debug *ar, lua_Localvar *v) {
-  StkId f = ar->_func;
-  Proto *fp = getluaproto(f);
-  if (!fp) return 0;  /* `f' is not a Lua function? */
-  v->name = luaF_getlocalname(fp, v->index, lua_currentline(L, f));
-  if (!v->name) return 0;
-  /* if `name', there must be a TAG_LINE */
-  /* therefore, f+2 points to function base */
-  LUA_ASSERT(L, ttype(f+1) == TAG_LINE, "");
-  v->value = luaA_putluaObject(L, (f+2)+(v->index-1));
-  return 1;
-}
-
-
-int lua_setlocal (lua_State *L, const lua_Debug *ar, lua_Localvar *v) {
-  StkId f = ar->_func;
-  Proto *fp = getluaproto(f);
-  if (!fp) return 0;  /* `f' is not a Lua function? */
-  v->name = luaF_getlocalname(fp, v->index, lua_currentline(L, f));
-  if (!v->name) return 0;
-  LUA_ASSERT(L, ttype(f+1) == TAG_LINE, "");
-  *((f+2)+(v->index-1)) = *v->value;
-  return 1;
-}
-
-
-static void lua_funcinfo (lua_Debug *ar) {
-  StkId func = ar->_func;
-  switch (ttype(func)) {
-    case TAG_LCLOSURE:  case TAG_LMARK:
-      ar->source = clvalue(func)->f.l->source->str;
-      ar->linedefined = clvalue(func)->f.l->lineDefined;
-      ar->what = "Lua";
-      break;
-    case TAG_CCLOSURE:  case TAG_CMARK:
-      ar->source = "(C)";
-      ar->linedefined = -1;
-      ar->what = "C";
-      break;
-    default:
-      LUA_INTERNALERROR(L, "invalid `func' value");
-  }
-  if (ar->linedefined == 0)
-    ar->what = "main";
-}
-
-
-static int checkfunc (lua_State *L, TObject *o) {
-  return luaO_equalObj(o, L->top);
-}
-
-
-static void lua_getobjname (lua_State *L, StkId f, lua_Debug *ar) {
-  GlobalVar *g;
+static void getname (lua_State *L, const TObject *f, lua_Debug *ar) {
   /* try to find a name for given function */
-  setnormalized(L->top, f); /* to be used by `checkfunc' */
-  for (g=L->rootglobal; g; g=g->next) {
-    if (checkfunc(L, &g->value)) {
-      ar->name = g->name->str;
-      ar->namewhat = "global";
-      return;
-    }
-  }
+  if ((ar->name = travglobals(L, f)) != NULL)
+    ar->namewhat = l_s("global");
   /* not found: try tag methods */
-  if ((ar->name = luaT_travtagmethods(L, checkfunc)) != NULL)
-    ar->namewhat = "tag-method";
-  else ar->namewhat = "";  /* not found at all */
+  else if ((ar->name = travtagmethods(G(L), f)) != NULL)
+    ar->namewhat = l_s("tag-method");
+  else ar->namewhat = l_s("");  /* not found at all */
 }
 
 
-int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
-  StkId func = ar->_func;
-  LUA_ASSERT(L, is_T_MARK(ttype(func)), "invalid activation record");
+LUA_API int lua_getinfo (lua_State *L, const l_char *what, lua_Debug *ar) {
+  StkId f;
+  CallInfo *ci;
+  int status = 1;
+  lua_lock(L);
+  if (*what != l_c('>')) {  /* function is active? */
+    ci = ar->_ci;
+    f = ci->base - 1;
+  }
+  else {
+    what++;  /* skip the `>' */
+    ci = NULL;
+    f = L->top - 1;
+  }
   for (; *what; what++) {
     switch (*what) {
-      case 'S':
-        lua_funcinfo(ar);
+      case l_c('S'): {
+        funcinfo(L, ar, f);
         break;
-      case 'l':
-        ar->currentline = lua_currentline(L, func);
+      }
+      case l_c('l'): {
+        ar->currentline = currentline(ci);
         break;
-      case 'u':
-        ar->nups = lua_nups(func);
+      }
+      case l_c('u'): {
+        ar->nups = (ttype(f) == LUA_TFUNCTION) ? clvalue(f)->nupvalues : 0;
         break;
-      case 'n':
-        lua_getobjname(L, func, ar);
+      }
+      case l_c('n'): {
+        ar->namewhat = (ci) ? getfuncname(L, ci, &ar->name) : NULL;
+        if (ar->namewhat == NULL)
+          getname(L, f, ar);
         break;
-      case 'f':
-        setnormalized(L->top, func);
-        incr_top;
-        ar->func = luaA_putObjectOnTop(L);
+      }
+      case l_c('f'): {
+        setobj(L->top, f);
+        incr_top;  /* push function */
         break;
-      default: return 0;  /* invalid option */
+      }
+      default: status = 0;  /* invalid option */
     }
   }
+  if (!ci) L->top--;  /* pop function */
+  lua_unlock(L);
+  return status;
+}
+
+
+/*
+** {======================================================
+** Symbolic Execution and code checker
+** =======================================================
+*/
+
+#define check(x)		if (!(x)) return 0;
+
+#define checkjump(pt,pc)	check(0 <= pc && pc < pt->sizecode)
+
+#define checkreg(pt,reg)	check((reg) < (pt)->maxstacksize)
+
+
+static int checklineinfo (const Proto *pt) {
+  int *lineinfo = pt->lineinfo;
+  if (lineinfo == NULL) return 1;
+  check(pt->sizelineinfo >= 2 && lineinfo[pt->sizelineinfo-1] == MAX_INT);
+  if (*lineinfo < 0) lineinfo++;
+  check(*lineinfo == 0);
   return 1;
 }
 
 
-
-static void call_index_error (lua_State *L, TObject *o, const char *v) {
-  luaL_verror(L, "attempt to %.10s a %.10s value", v, lua_type(L, o));
+static int precheck (const Proto *pt) {
+  check(checklineinfo(pt));
+  check(pt->maxstacksize <= MAXSTACK);
+  check(pt->numparams+pt->is_vararg <= pt->maxstacksize);
+  check(GET_OPCODE(pt->code[pt->sizecode-1]) == OP_RETURN);
+  return 1;
 }
 
 
-void luaG_callerror (lua_State *L, TObject *func) {
-  call_index_error(L, func, "call");
+static int checkopenop (Instruction i) {
+  OpCode op = GET_OPCODE(i);
+  switch (op) {
+    case OP_CALL:
+    case OP_RETURN: {
+      check(GETARG_B(i) == NO_REG);
+      return 1;
+    }
+    case OP_SETLISTO: return 1;
+    default: return 0;  /* invalid instruction after an open call */
+  }
 }
 
 
-void luaG_indexerror (lua_State *L, TObject *t) {
-  call_index_error(L, t, "index");
+static Instruction luaG_symbexec (const Proto *pt, int lastpc, int reg) {
+  int pc;
+  int last;  /* stores position of last instruction that changed `reg' */
+  last = pt->sizecode-1;  /* points to final return (a `neutral' instruction) */
+  if (reg == NO_REG)  /* full check? */
+    check(precheck(pt));
+  for (pc = 0; pc < lastpc; pc++) {
+    const Instruction i = pt->code[pc];
+    OpCode op = GET_OPCODE(i);
+    int a = GETARG_A(i);
+    int b = 0;
+    int c = 0;
+    checkreg(pt, a);
+    switch (getOpMode(op)) {
+      case iABC: {
+        b = GETARG_B(i);
+        c = GETARG_C(i);
+        if (testOpMode(op, OpModeBreg))
+          checkreg(pt, b);
+        if (testOpMode(op, OpModeCreg))
+          check(c < pt->maxstacksize ||
+               (c >= MAXSTACK && c-MAXSTACK < pt->sizek));
+        break;
+      }
+      case iABc: {
+        b = GETARG_Bc(i);
+        if (testOpMode(op, OpModeK)) check(b < pt->sizek);
+        break;
+      }
+      case iAsBc: {
+        b = GETARG_sBc(i);
+        break;
+      }
+    }
+    if (testOpMode(op, OpModesetA)) {
+      if (a == reg) last = pc;  /* change register `a' */
+    }
+    if (testOpMode(op, OpModeT))
+      check(GET_OPCODE(pt->code[pc+1]) == OP_CJMP);
+    switch (op) {
+      case OP_LOADNIL: {
+        if (a <= reg && reg <= b)
+          last = pc;  /* set registers from `a' to `b' */
+        break;
+      }
+      case OP_LOADUPVAL: {
+        check(b < pt->nupvalues);
+        break;
+      }
+      case OP_GETGLOBAL:
+      case OP_SETGLOBAL: {
+        check(ttype(&pt->k[b]) == LUA_TSTRING);
+        break;
+      }
+      case OP_SELF: {
+        checkreg(pt, a+1);
+        if (reg == a+1) last = pc;
+        break;
+      }
+      case OP_CONCAT: {
+        /* `c' is a register, and at least two operands */
+        check(c < MAXSTACK && b < c);
+        break;
+      }
+      case OP_JMP:
+      case OP_CJMP: {
+        int dest = pc+1+b;
+	check(0 <= dest && dest < pt->sizecode);
+        /* not full check and jump is forward and do not skip `lastpc'? */
+        if (reg != NO_REG && pc < dest && dest <= lastpc)
+          pc += b;  /* do the jump */
+        break;
+      }
+      case OP_NILJMP: {
+        check(pc+2 < pt->sizecode);  /* check its jump */
+        break;
+      }
+      case OP_CALL: {
+        if (b != NO_REG) {
+          checkreg(pt, a+b);
+        }
+        if (c == NO_REG) {
+          check(checkopenop(pt->code[pc+1]));
+        }
+        else if (c != 0)
+          checkreg(pt, a+c-1);
+        if (reg >= a) last = pc;  /* affect all registers above base */
+        break;
+      }
+      case OP_RETURN: {
+        if (b != NO_REG && b != 0)
+          checkreg(pt, a+b-1);
+        break;
+      }
+      case OP_FORPREP:
+      case OP_TFORPREP: {
+        int dest = pc-b;  /* jump is negated here */
+        check(0 <= dest && dest < pt->sizecode &&
+              GET_OPCODE(pt->code[dest]) == op+1);
+        break;
+      }
+      case OP_FORLOOP:
+      case OP_TFORLOOP: {
+        int dest = pc+b;
+        check(0 <= dest && dest < pt->sizecode &&
+              pt->code[dest] == SET_OPCODE(i, op-1));
+        checkreg(pt, a + ((op == OP_FORLOOP) ? 2 : 3));
+        break;
+      }
+      case OP_SETLIST: {
+        checkreg(pt, a + (b&(LFIELDS_PER_FLUSH-1)) + 1);
+        break;
+      }
+      case OP_CLOSURE: {
+        check(b < pt->sizep);
+        checkreg(pt, a + pt->p[b]->nupvalues - 1);
+        break;
+      }
+      default: break;
+    }
+  }
+  return pt->code[last];
 }
+
+/* }====================================================== */
+
+
+int luaG_checkcode (const Proto *pt) {
+  return luaG_symbexec(pt, pt->sizecode, NO_REG);
+}
+
+
+static const l_char *getobjname (lua_State *L, StkId obj, const l_char **name) {
+  CallInfo *ci = ci_stack(L, obj);
+  if (isLmark(ci)) {  /* an active Lua function? */
+    Proto *p = ci_func(ci)->f.l;
+    int pc = currentpc(ci);
+    int stackpos = obj - ci->base;
+    Instruction i;
+    *name = luaF_getlocalname(p, stackpos+1, pc);
+    if (*name)  /* is a local? */
+      return l_s("local");
+    i = luaG_symbexec(p, pc, stackpos);  /* try symbolic execution */
+    lua_assert(pc != -1);
+    switch (GET_OPCODE(i)) {
+      case OP_GETGLOBAL: {
+        lua_assert(ttype(&p->k[GETARG_Bc(i)]) == LUA_TSTRING);
+        *name = svalue(&p->k[GETARG_Bc(i)]);
+        return l_s("global");
+      }
+      case OP_MOVE: {
+        int a = GETARG_A(i);
+        int b = GETARG_B(i);  /* move from `b' to `a' */
+        if (b < a)
+          return getobjname(L, ci->base+b, name);  /* get name for `b' */
+        break;
+      }
+      case OP_GETTABLE:
+      case OP_SELF: {
+        int c = GETARG_C(i) - MAXSTACK;
+        if (c >= 0 && ttype(&p->k[c]) == LUA_TSTRING) {
+          *name = svalue(&p->k[c]);
+          return l_s("field");
+        }
+        break;
+      }
+      default: break;
+    }
+  }
+  return NULL;  /* no useful name found */
+}
+
+
+static const l_char *getfuncname (lua_State *L, CallInfo *ci,
+                                  const l_char **name) {
+  ci = ci->prev;  /* calling function */
+  if (ci == &L->basefunc || !isLmark(ci))
+    return NULL;  /* not an active Lua function */
+  else {
+    Proto *p = ci_func(ci)->f.l;
+    int pc = currentpc(ci);
+    Instruction i;
+    if (pc == -1) return NULL;  /* function is not activated */
+    i = p->code[pc];
+    return (GET_OPCODE(i) == OP_CALL
+             ? getobjname(L, ci->base+GETARG_A(i), name)
+             : NULL);  /* no useful name found */
+  }
+}
+
+
+void luaG_typeerror (lua_State *L, StkId o, const l_char *op) {
+  const l_char *name;
+  const l_char *kind = getobjname(L, o, &name);
+  const l_char *t = luaT_typename(G(L), o);
+  if (kind)
+    luaO_verror(L, l_s("attempt to %.30s %.20s `%.40s' (a %.10s value)"),
+                op, kind, name, t);
+  else
+    luaO_verror(L, l_s("attempt to %.30s a %.10s value"), op, t);
+}
+
+
+void luaG_concaterror (lua_State *L, StkId p1, StkId p2) {
+  if (ttype(p1) == LUA_TSTRING) p1 = p2;
+  lua_assert(ttype(p1) != LUA_TSTRING);
+  luaG_typeerror(L, p1, l_s("concat"));
+}
+
+
+void luaG_aritherror (lua_State *L, StkId p1, TObject *p2) {
+  TObject temp;
+  if (luaV_tonumber(p1, &temp) != NULL)
+    p1 = p2;  /* first operand is OK; error is in the second */
+  luaG_typeerror(L, p1, l_s("perform arithmetic on"));
+}
+
+
+void luaG_ordererror (lua_State *L, const TObject *p1, const TObject *p2) {
+  const l_char *t1 = luaT_typename(G(L), p1);
+  const l_char *t2 = luaT_typename(G(L), p2);
+  if (t1[2] == t2[2])
+    luaO_verror(L, l_s("attempt to compare two %.10s values"), t1);
+  else
+    luaO_verror(L, l_s("attempt to compare %.10s with %.10s"), t1, t2);
+}
+

ldebug.h

@@ -1,5 +1,5 @@
 /*
-** $Id: $
+** $Id: ldebug.h,v 1.14 2001/06/11 14:56:42 roberto Exp roberto $
 ** Auxiliary functions from Debug Interface module
 ** See Copyright Notice in lua.h
 */
@@ -8,12 +8,16 @@
 #define ldebug_h
 
 
-#include "lobject.h"
+#include "lstate.h"
 #include "luadebug.h"
 
 
-void luaG_callerror (lua_State *L, TObject *func);
-void luaG_indexerror (lua_State *L, TObject *t);
+void luaG_typeerror (lua_State *L, StkId o, const l_char *op);
+void luaG_concaterror (lua_State *L, StkId p1, StkId p2);
+void luaG_aritherror (lua_State *L, StkId p1, TObject *p2);
+int luaG_getline (int *lineinfo, int pc, int refline, int *refi);
+void luaG_ordererror (lua_State *L, const TObject *p1, const TObject *p2);
+int luaG_checkcode (const Proto *pt);
 
 
 #endif

ldo.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.c,v 1.72 2000/03/30 20:55:50 roberto Exp roberto $
+** $Id: ldo.c,v 1.137 2001/07/12 19:34:03 roberto Exp roberto $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
@@ -10,9 +10,9 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
-#include "lauxlib.h"
 #include "ldebug.h"
 #include "ldo.h"
 #include "lgc.h"
@@ -21,346 +21,328 @@
 #include "lparser.h"
 #include "lstate.h"
 #include "lstring.h"
+#include "ltable.h"
 #include "ltm.h"
-#include "lua.h"
-#include "luadebug.h"
 #include "lundump.h"
 #include "lvm.h"
 #include "lzio.h"
 
 
-#define EXTRA_STACK	32	/* space to handle stack overflow errors */
-
-/*
-** typical numer of stack slots used by a (big) function
-** (this constant is used only for choosing error messages)
-*/
-#define SLOTS_PER_F	20
-
-
-void luaD_init (lua_State *L, int stacksize) {
-  L->stack = luaM_newvector(L, stacksize+EXTRA_STACK, TObject);
-  L->stack_last = L->stack+(stacksize-1);
-  L->stacksize = stacksize;
-  L->Cstack.base = L->Cstack.lua2C = L->top = L->stack;
-  L->Cstack.num = 0;
-}
-
-
-void luaD_checkstack (lua_State *L, int n) {
-  if (L->stack_last-L->top <= n) {  /* stack overflow? */
-    if (L->stack_last-L->stack > (L->stacksize-1)) {
-      /* overflow while handling overflow: do what?? */
-      L->top -= EXTRA_STACK;
-      lua_error(L, "BAD STACK OVERFLOW! DATA CORRUPTED!");
-    }
-    else {
-      lua_Debug dummy;
-      L->stack_last += EXTRA_STACK;  /* to be used by error message */
-      if (lua_getstack(L, L->stacksize/SLOTS_PER_F, &dummy) == 0) {
-        /* too few funcs on stack: doesn't look like a recursion loop */
-        lua_error(L, "Lua2C - C2Lua overflow");
-      }
-      else
-        lua_error(L, "stack overflow; possible recursion loop");
-    }
-  }
-}
+/* space to handle stack overflow errors */
+#define EXTRA_STACK   (2*LUA_MINSTACK)
 
 
 static void restore_stack_limit (lua_State *L) {
-  if (L->top-L->stack < L->stacksize-1)
-    L->stack_last = L->stack+(L->stacksize-1);
+  StkId limit = L->stack+(L->stacksize-EXTRA_STACK)-1;
+  if (L->top < limit)
+    L->stack_last = limit;
+}
+
+
+void luaD_init (lua_State *L, int stacksize) {
+  stacksize += EXTRA_STACK;
+  L->stack = luaM_newvector(L, stacksize, TObject);
+  L->stacksize = stacksize;
+  L->basefunc.base = L->top = L->stack;
+  restore_stack_limit(L);
+}
+
+
+void luaD_stackerror (lua_State *L) {
+  if (L->stack_last == L->stack+L->stacksize-1) {
+    /* overflow while handling overflow */
+    luaD_breakrun(L, LUA_ERRERR);  /* break run without error message */
+  }
+  else {
+    L->stack_last += EXTRA_STACK;  /* to be used by error message */
+    lua_assert(L->stack_last == L->stack+L->stacksize-1);
+    luaD_error(L, l_s("stack overflow"));
+  }
 }
 
 
 /*
-** Adjust stack. Set top to base+extra, pushing NILs if needed.
-** (we cannot add base+extra unless we are sure it fits in the stack;
-**  otherwise the result of such operation on pointers is undefined)
+** adjust top to new value; assume that new top is valid
 */
-void luaD_adjusttop (lua_State *L, StkId base, int extra) {
-  int diff = extra-(L->top-base);
-  if (diff <= 0)
-    L->top = base+extra;
-  else {
-    luaD_checkstack(L, diff);
-    while (diff--)
-      ttype(L->top++) = TAG_NIL;
-  }
+void luaD_adjusttop (lua_State *L, StkId newtop) {
+  while (L->top < newtop)
+    setnilvalue(L->top++);
+  L->top = newtop;  /* `newtop' could be lower than `top' */
 }
 
 
 /*
 ** Open a hole inside the stack at `pos'
 */
-void luaD_openstack (lua_State *L, StkId pos) {
+static void luaD_openstack (lua_State *L, StkId pos) {
   int i = L->top-pos; 
-  while (i--) pos[i+1] = pos[i];
+  while (i--) setobj(pos+i+1, pos+i);
   incr_top;
 }
 
 
-void luaD_lineHook (lua_State *L, StkId func, int line) {
+static void dohook (lua_State *L, lua_Debug *ar, lua_Hook hook) {
+  StkId old_top = L->top;
+  luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
+  L->allowhooks = 0;  /* cannot call hooks inside a hook */
+  lua_unlock(L);
+  (*hook)(L, ar);
+  lua_lock(L);
+  lua_assert(L->allowhooks == 0);
+  L->allowhooks = 1;
+  L->top = old_top;
+}
+
+
+void luaD_lineHook (lua_State *L, int line, lua_Hook linehook) {
   if (L->allowhooks) {
     lua_Debug ar;
-    struct C_Lua_Stack oldCLS = L->Cstack;
-    StkId old_top = L->Cstack.lua2C = L->Cstack.base = L->top;
-    L->Cstack.num = 0;
-    ar._func = func;
-    ar.event = "line";
+    ar.event = l_s("line");
+    ar._ci = L->ci;
     ar.currentline = line;
-    L->allowhooks = 0;  /* cannot call hooks inside a hook */
-    (*L->linehook)(L, &ar);
-    L->allowhooks = 1;
-    L->top = old_top;
-    L->Cstack = oldCLS;
+    dohook(L, &ar, linehook);
   }
 }
 
 
-static void luaD_callHook (lua_State *L, StkId func, lua_Hook callhook,
-                    const char *event) {
+static void luaD_callHook (lua_State *L, lua_Hook callhook,
+                           const l_char *event) {
   if (L->allowhooks) {
     lua_Debug ar;
-    struct C_Lua_Stack oldCLS = L->Cstack;
-    StkId old_top = L->Cstack.lua2C = L->Cstack.base = L->top;
-    L->Cstack.num = 0;
-    ar._func = func;
     ar.event = event;
-    L->allowhooks = 0;  /* cannot call hooks inside a hook */
-    callhook(L, &ar);
-    L->allowhooks = 1;
-    L->top = old_top;
-    L->Cstack = oldCLS;
+    ar._ci = L->ci;
+    L->ci->pc = NULL;  /* function is not active */
+    dohook(L, &ar, callhook);
   }
 }
 
 
-static StkId callCclosure (lua_State *L, const struct Closure *cl, StkId base) {
-  int nup = cl->nelems;  /* number of upvalues */
-  int numarg = L->top-base;
-  struct C_Lua_Stack oldCLS = L->Cstack;
-  StkId firstResult;
-  if (nup > 0) {
-    int n = numarg;
-    luaD_checkstack(L, nup);
-    /* open space for upvalues as extra arguments */
-    while (n--) *(base+nup+n) = *(base+n);
-    L->top += nup;
-    numarg += nup;
-    /* copy upvalues into stack */
-    while (nup--) *(base+nup) = cl->consts[nup];
-  }
-  L->Cstack.num = numarg;
-  L->Cstack.lua2C = base;
-  L->Cstack.base = L->top;
-  (*cl->f.c)(L);  /* do the actual call */
-  firstResult = L->Cstack.base;
-  L->Cstack = oldCLS;
-  return firstResult;
-}
-
-
-void luaD_callTM (lua_State *L, const TObject *f, int nParams, int nResults) {
-  StkId base = L->top - nParams;
-  luaD_openstack(L, base);
-  *base = *f;
-  luaD_call(L, base, nResults);
+static StkId callCclosure (lua_State *L, const struct Closure *cl) {
+  int nup = cl->nupvalues;  /* number of upvalues */
+  int n;
+  luaD_checkstack(L, nup+LUA_MINSTACK);  /* ensure minimum stack size */
+  for (n=0; n<nup; n++)  /* copy upvalues as extra arguments */
+    setobj(L->top++, &cl->upvalue[n]);
+  lua_unlock(L);
+  n = (*cl->f.c)(L);  /* do the actual call */
+  lua_lock(L);
+  return L->top - n;  /* return index of first result */
 }
 
 
 /*
 ** Call a function (C or Lua). The function to be called is at *func.
 ** The arguments are on the stack, right after the function.
-** When returns, the results are on the stack, starting at the original
+** When returns, all the results are on the stack, starting at the original
 ** function position.
-** The number of results is nResults, unless nResults=MULT_RET.
 */ 
-void luaD_call (lua_State *L, StkId func, int nResults) {
+void luaD_call (lua_State *L, StkId func) {
+  lua_Hook callhook;
   StkId firstResult;
-  lua_Hook callhook = L->callhook;
-  retry:  /* for `function' tag method */
-  switch (ttype(func)) {
-    case TAG_LCLOSURE: {
-      ttype(func) = TAG_LMARK;
-      if (callhook)
-        luaD_callHook(L, func, callhook, "call");
-      firstResult = luaV_execute(L, clvalue(func), func+1);
-      break;
-    }
-    case TAG_CCLOSURE: {
-      ttype(func) = TAG_CMARK;
-      if (callhook)
-        luaD_callHook(L, func, callhook, "call");
-      firstResult = callCclosure(L, clvalue(func), func+1);
-      break;
-    }
-    default: { /* `func' is not a function; check the `function' tag method */
-      const TObject *im = luaT_getimbyObj(L, func, IM_FUNCTION);
-      if (ttype(im) == TAG_NIL)
-        luaG_callerror(L, func);
-      luaD_openstack(L, func);
-      *func = *im;  /* tag method is the new function to be called */
-      goto retry;   /* retry the call */
-    }
+  CallInfo ci;
+  if (ttype(func) != LUA_TFUNCTION) {
+    /* `func' is not a function; check the `function' tag method */
+    Closure *tm = luaT_gettmbyObj(G(L), func, TM_FUNCTION);
+    if (tm == NULL)
+      luaG_typeerror(L, func, l_s("call"));
+    luaD_openstack(L, func);
+    setclvalue(func, tm);  /* tag method is the new function to be called */
   }
+  ci.prev = L->ci;  /* chain new callinfo */
+  L->ci = &ci;
+  ci.base = func+1;
+  callhook = L->callhook;
+  if (callhook)
+    luaD_callHook(L, callhook, l_s("call"));
+  firstResult = (clvalue(func)->isC ? callCclosure(L, clvalue(func)) :
+                                      luaV_execute(L, clvalue(func), func+1));
   if (callhook)  /* same hook that was active at entry */
-    luaD_callHook(L, func, callhook, "return");
-  /* adjust the number of results */
-  if (nResults == MULT_RET)
-    nResults = L->top - firstResult;
-  else
-    luaD_adjusttop(L, firstResult, nResults);
+    luaD_callHook(L, callhook, l_s("return"));
+  L->ci = ci.prev;  /* unchain callinfo */
   /* move results to `func' (to erase parameters and function) */
-  while (nResults) {
-    *func++ = *(L->top - nResults);
-    nResults--;
-  }
+  while (firstResult < L->top)
+    setobj(func++, firstResult++);
   L->top = func;
-}
-
-
-static void message (lua_State *L, const char *s) {
-  const TObject *em = &(luaS_assertglobalbyname(L, "_ERRORMESSAGE")->value);
-  if (*luaO_typename(em) == 'f') {
-    *L->top = *em;
-    incr_top;
-    lua_pushstring(L, s);
-    luaD_call(L, L->top-2, 0);
-  }
-}
-
-/*
-** Reports an error, and jumps up to the available recovery label
-*/
-void lua_error (lua_State *L, const char *s) {
-  if (s) message(L, s);
-  if (L->errorJmp)
-    longjmp(L->errorJmp->b, 1);
-  else {
-    message(L, "unable to recover; exiting\n");
-    exit(1);
-  }
+  luaC_checkGC(L);
 }
 
 
 /*
-** Execute a protected call. Assumes that function is at Cstack.base and
-** parameters are on top of it.
+** Execute a protected call.
 */
-int luaD_protectedrun (lua_State *L) {
-  struct lua_longjmp myErrorJmp;
-  StkId base = L->Cstack.base;
-  int numCblocks = L->numCblocks;
+struct CallS {  /* data to `f_call' */
+  StkId func;
+  int nresults;
+};
+
+static void f_call (lua_State *L, void *ud) {
+  struct CallS *c = (struct CallS *)ud;
+  luaD_call(L, c->func);
+  if (c->nresults != LUA_MULTRET)
+    luaD_adjusttop(L, c->func + c->nresults);
+}
+
+
+LUA_API int lua_call (lua_State *L, int nargs, int nresults) {
+  StkId func;
+  struct CallS c;
   int status;
-  struct lua_longjmp *volatile oldErr = L->errorJmp;
-  L->errorJmp = &myErrorJmp;
-  if (setjmp(myErrorJmp.b) == 0) {
-    luaD_call(L, base, MULT_RET);
-    L->Cstack.lua2C = base;  /* position of the new results */
-    L->Cstack.num = L->top - base;
-    L->Cstack.base = base + L->Cstack.num;  /* incorporate results on stack */
-    status = 0;
-  }
-  else {  /* an error occurred: restore the stack */
-    L->Cstack.num = 0;  /* no results */
-    L->top = L->Cstack.base = L->Cstack.lua2C = base;
-    L->numCblocks = numCblocks;
-    restore_stack_limit(L);
-    status = 1;
-  }
-  L->errorJmp = oldErr;
+  lua_lock(L);
+  func = L->top - (nargs+1);  /* function to be called */
+  c.func = func; c.nresults = nresults;
+  status = luaD_runprotected(L, f_call, &c);
+  if (status != 0)  /* an error occurred? */
+    L->top = func;  /* remove parameters from the stack */
+  lua_unlock(L);
   return status;
 }
 
 
 /*
-** returns 0 = chunk loaded; 1 = error; 2 = no more chunks to load
+** Execute a protected parser.
 */
-static int protectedparser (lua_State *L, ZIO *z, int bin) {
-  struct lua_longjmp myErrorJmp;
-  StkId base = L->Cstack.base;
-  int numCblocks = L->numCblocks;
-  int status;
-  Proto *volatile tf;
-  struct lua_longjmp *volatile oldErr = L->errorJmp;
-  L->errorJmp = &myErrorJmp;
-  L->top = base;   /* clear C2Lua */
-  if (setjmp(myErrorJmp.b) == 0) {
-    tf = bin ? luaU_undump1(L, z) : luaY_parser(L, z);
-    status = 0;
-  }
-  else {  /* an error occurred: restore Cstack and top */
-    L->Cstack.num = 0;  /* no results */
-    L->top = L->Cstack.base = L->Cstack.lua2C = base;
-    L->numCblocks = numCblocks;
-    tf = NULL;
-    status = 1;
-  }
-  L->errorJmp = oldErr;
-  if (status) return 1;  /* error code */
-  if (tf == NULL) return 2;  /* `natural' end */
+struct SParser {  /* data to `f_parser' */
+  ZIO *z;
+  int bin;
+};
+
+static void f_parser (lua_State *L, void *ud) {
+  struct SParser *p = (struct SParser *)ud;
+  Proto *tf = p->bin ? luaU_undump(L, p->z) : luaY_parser(L, p->z);
   luaV_Lclosure(L, tf, 0);
-  return 0;
 }
 
 
-static int do_main (lua_State *L, ZIO *z, int bin) {
+static int protectedparser (lua_State *L, ZIO *z, int bin) {
+  struct SParser p;
+  lu_mem old_blocks;
   int status;
-  int debug = L->debug;  /* save debug status */
-  do {
-    long old_blocks = (luaC_checkGC(L), L->nblocks);
-    status = protectedparser(L, z, bin);
-    if (status == 1) return 1;  /* error */
-    else if (status == 2) return 0;  /* `natural' end */
-    else {
-      unsigned long newelems2 = 2*(L->nblocks-old_blocks);
-      L->GCthreshold += newelems2;
-      status = luaD_protectedrun(L);
-      L->GCthreshold -= newelems2;
-    }
-  } while (bin && status == 0);
-  L->debug = debug;  /* restore debug status */
+  lua_lock(L);
+  p.z = z; p.bin = bin;
+  /* before parsing, give a (good) chance to GC */
+  if (G(L)->nblocks/8 >= G(L)->GCthreshold/10)
+    luaC_collectgarbage(L);
+  old_blocks = G(L)->nblocks;
+  status = luaD_runprotected(L, f_parser, &p);
+  if (status == 0) {
+    /* add new memory to threshold (as it probably will stay) */
+    lua_assert(G(L)->nblocks >= old_blocks);
+    G(L)->GCthreshold += (G(L)->nblocks - old_blocks);
+  }
+  else if (status == LUA_ERRRUN)  /* an error occurred: correct error code */
+    status = LUA_ERRSYNTAX;
+  lua_unlock(L);
   return status;
 }
 
 
-#define	MAXFILENAME	260	/* maximum part of a file name kept */
-
-int lua_dofile (lua_State *L, const char *filename) {
+LUA_API int lua_loadfile (lua_State *L, const l_char *filename) {
   ZIO z;
   int status;
   int bin;  /* flag for file mode */
-  int c;    /* look ahead char */
-  char source[MAXFILENAME];
-  FILE *f = (filename == NULL) ? stdin : fopen(filename, "r");
-  if (f == NULL) return 2;  /* unable to open file */
-  luaL_filesource(source, filename, sizeof(source));
-  c = fgetc(f);
-  ungetc(c, f);
-  bin = (c == ID_CHUNK);
+  int nlevel;  /* level on the stack of filename */
+  FILE *f = (filename == NULL) ? stdin : fopen(filename, l_s("r"));
+  if (f == NULL) return LUA_ERRFILE;  /* unable to open file */
+  bin = (ungetc(getc(f), f) == LUA_SIGNATURE[0]);
   if (bin && f != stdin) {
-    f = freopen(filename, "rb", f);  /* set binary mode */
-    if (f == NULL) return 2;  /* unable to reopen file */
+    fclose(f);
+    f = fopen(filename, l_s("rb"));  /* reopen in binary mode */
+    if (f == NULL) return LUA_ERRFILE;  /* unable to reopen file */
   }
-  luaZ_Fopen(&z, f, source);
-  status = do_main(L, &z, bin);
+  lua_pushliteral(L, l_s("@"));
+  lua_pushstring(L, (filename == NULL) ? l_s("(stdin)") : filename);
+  lua_concat(L, 2);
+  nlevel = lua_gettop(L);
+  filename = lua_tostring(L, -1);  /* filename = `@'..filename */
+  luaZ_Fopen(&z, f, filename);
+  status = protectedparser(L, &z, bin);
+  lua_remove(L, nlevel);  /* remove filename */
   if (f != stdin)
     fclose(f);
   return status;
 }
 
 
-int lua_dostring (lua_State *L, const char *str) {
-  return lua_dobuffer(L, str, strlen(str), str);
-}
-
-
-int lua_dobuffer (lua_State *L, const char *buff, int size, const char *name) {
+LUA_API int lua_loadbuffer (lua_State *L, const l_char *buff, size_t size,
+                          const l_char *name) {
   ZIO z;
-  if (!name) name = "?";
+  int status;
+  if (!name) name = l_s("?");
   luaZ_mopen(&z, buff, size, name);
-  return do_main(L, &z, buff[0]==ID_CHUNK);
+  status = protectedparser(L, &z, buff[0]==LUA_SIGNATURE[0]);
+  return status;
 }
 
+
+
+/*
+** {======================================================
+** Error-recover functions (based on long jumps)
+** =======================================================
+*/
+
+/* chain list of long jump buffers */
+struct lua_longjmp {
+  jmp_buf b;
+  struct lua_longjmp *previous;
+  volatile int status;  /* error code */
+};
+
+
+static void message (lua_State *L, const l_char *s) {
+  StkId top = L->top;
+  luaV_getglobal(L, luaS_newliteral(L, l_s(LUA_ERRORMESSAGE)), top);
+  if (ttype(top) == LUA_TFUNCTION) {
+    incr_top;
+    setsvalue(top+1, luaS_new(L, s));
+    incr_top;
+    luaD_call(L, top);
+    L->top = top;
+  }
+}
+
+
+/*
+** Reports an error, and jumps up to the available recovery label
+*/
+void luaD_error (lua_State *L, const l_char *s) {
+  if (s) message(L, s);
+  luaD_breakrun(L, LUA_ERRRUN);
+}
+
+
+void luaD_breakrun (lua_State *L, int errcode) {
+  if (L->errorJmp) {
+    L->errorJmp->status = errcode;
+    longjmp(L->errorJmp->b, 1);
+  }
+  else {
+    if (errcode != LUA_ERRMEM)
+      message(L, l_s("unable to recover; exiting\n"));
+    exit(EXIT_FAILURE);
+  }
+}
+
+
+int luaD_runprotected (lua_State *L, void (*f)(lua_State *, void *), void *ud) {
+  CallInfo *oldci = L->ci;
+  StkId oldtop = L->top;
+  struct lua_longjmp lj;
+  int allowhooks = L->allowhooks;
+  lj.status = 0;
+  lj.previous = L->errorJmp;  /* chain new error handler */
+  L->errorJmp = &lj;
+  if (setjmp(lj.b) == 0)
+    (*f)(L, ud);
+  else {  /* an error occurred: restore the state */
+    L->allowhooks = allowhooks;
+    L->ci = oldci;
+    L->top = oldtop;
+    restore_stack_limit(L);
+  }
+  L->errorJmp = lj.previous;  /* restore old error handler */
+  return lj.status;
+}
+
+/* }====================================================== */
+

ldo.h

@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.h,v 1.19 2000/03/29 20:19:20 roberto Exp roberto $
+** $Id: ldo.h,v 1.33 2001/06/05 19:41:24 roberto Exp roberto $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
@@ -19,14 +19,18 @@
 #define incr_top {if (L->top == L->stack_last) luaD_checkstack(L, 1); L->top++;}
 
 
+#define luaD_checkstack(L,n) if (L->stack_last-(n)<=L->top) luaD_stackerror(L)
+
+
 void luaD_init (lua_State *L, int stacksize);
-void luaD_adjusttop (lua_State *L, StkId base, int extra);
-void luaD_openstack (lua_State *L, StkId pos);
-void luaD_lineHook (lua_State *L, StkId func, int line);
-void luaD_call (lua_State *L, StkId func, int nResults);
-void luaD_callTM (lua_State *L, const TObject *f, int nParams, int nResults);
-int luaD_protectedrun (lua_State *L);
-void luaD_checkstack (lua_State *L, int n);
+void luaD_adjusttop (lua_State *L, StkId newtop);
+void luaD_lineHook (lua_State *L, int line, lua_Hook linehook);
+void luaD_call (lua_State *L, StkId func);
+void luaD_stackerror (lua_State *L);
+
+void luaD_error (lua_State *L, const l_char *s);
+void luaD_breakrun (lua_State *L, int errcode);
+int luaD_runprotected (lua_State *L, void (*f)(lua_State *, void *), void *ud);
 
 
 #endif

lfunc.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.c,v 1.20 2000/03/10 18:37:44 roberto Exp roberto $
+** $Id: lfunc.c,v 1.44 2001/06/05 18:17:01 roberto Exp roberto $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
@@ -7,63 +7,64 @@
 
 #include <stdlib.h>
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
 #include "lfunc.h"
 #include "lmem.h"
 #include "lstate.h"
 
-#define gcsizeproto(L, p)	numblocks(L, 0, sizeof(Proto))
-#define gcsizeclosure(L, c)	numblocks(L, c->nelems, sizeof(Closure))
 
+#define sizeclosure(n)	((int)sizeof(Closure) + (int)sizeof(TObject)*((n)-1))
 
 
 Closure *luaF_newclosure (lua_State *L, int nelems) {
-  Closure *c = (Closure *)luaM_malloc(L, sizeof(Closure) +
-                                         sizeof(TObject)*(nelems-1));
-  c->next = L->rootcl;
-  L->rootcl = c;
-  c->marked = 0;
-  c->nelems = nelems;
-  L->nblocks += gcsizeclosure(L, c);
+  Closure *c = (Closure *)luaM_malloc(L, sizeclosure(nelems));
+  c->next = G(L)->rootcl;
+  G(L)->rootcl = c;
+  c->mark = c;
+  c->nupvalues = nelems;
   return c;
 }
 
 
 Proto *luaF_newproto (lua_State *L) {
   Proto *f = luaM_new(L, Proto);
+  f->k = NULL;
+  f->sizek = 0;
+  f->p = NULL;
+  f->sizep = 0;
   f->code = NULL;
+  f->sizecode = 0;
+  f->nupvalues = 0;
+  f->numparams = 0;
+  f->is_vararg = 0;
+  f->maxstacksize = 0;
+  f->marked = 0;
+  f->lineinfo = NULL;
+  f->sizelocvars = 0;
+  f->sizelineinfo = 0;
+  f->locvars = NULL;
   f->lineDefined = 0;
   f->source = NULL;
-  f->kstr = NULL;
-  f->nkstr = 0;
-  f->knum = NULL;
-  f->nknum = 0;
-  f->kproto = NULL;
-  f->nkproto = 0;
-  f->locvars = NULL;
-  f->next = L->rootproto;
-  L->rootproto = f;
-  f->marked = 0;
-  L->nblocks += gcsizeproto(L, f);
+  f->next = G(L)->rootproto;  /* chain in list of protos */
+  G(L)->rootproto = f;
   return f;
 }
 
 
 void luaF_freeproto (lua_State *L, Proto *f) {
-  L->nblocks -= gcsizeproto(L, f);
-  luaM_free(L, f->code);
-  luaM_free(L, f->locvars);
-  luaM_free(L, f->kstr);
-  luaM_free(L, f->knum);
-  luaM_free(L, f->kproto);
-  luaM_free(L, f);
+  luaM_freearray(L, f->code, f->sizecode, Instruction);
+  luaM_freearray(L, f->locvars, f->sizelocvars, struct LocVar);
+  luaM_freearray(L, f->k, f->sizek, TObject);
+  luaM_freearray(L, f->p, f->sizep, Proto *);
+  luaM_freearray(L, f->lineinfo, f->sizelineinfo, int);
+  luaM_freelem(L, f, Proto);
 }
 
 
 void luaF_freeclosure (lua_State *L, Closure *c) {
-  L->nblocks -= gcsizeclosure(L, c);
-  luaM_free(L, c);
+  luaM_free(L, c, sizeclosure(c->nupvalues));
 }
 
 
@@ -71,22 +72,15 @@ void luaF_freeclosure (lua_State *L, Closure *c) {
 ** Look for n-th local variable at line `line' in function `func'.
 ** Returns NULL if not found.
 */
-const char *luaF_getlocalname (const Proto *func,
-                               int local_number, int line) {
-  int count = 0;
-  const char *varname = NULL;
-  LocVar *lv = func->locvars;
-  if (lv == NULL)
-    return NULL;
-  for (; lv->line != -1 && lv->line < line; lv++) {
-    if (lv->varname) {  /* register */
-      if (++count == local_number)
-        varname = lv->varname->str;
+const l_char *luaF_getlocalname (const Proto *f, int local_number, int pc) {
+  int i;
+  for (i = 0; i<f->sizelocvars && f->locvars[i].startpc <= pc; i++) {
+    if (pc < f->locvars[i].endpc) {  /* is variable active? */
+      local_number--;
+      if (local_number == 0)
+        return getstr(f->locvars[i].varname);
     }
-    else  /* unregister */
-      if (--count < local_number)
-        varname = NULL;
   }
-  return varname;
+  return NULL;  /* not found */
 }
 

lfunc.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.h,v 1.10 1999/12/27 17:33:22 roberto Exp roberto $
+** $Id: lfunc.h,v 1.14 2000/12/28 12:55:41 roberto Exp roberto $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
@@ -17,8 +17,7 @@ Closure *luaF_newclosure (lua_State *L, int nelems);
 void luaF_freeproto (lua_State *L, Proto *f);
 void luaF_freeclosure (lua_State *L, Closure *c);
 
-const char *luaF_getlocalname (const Proto *func,
-                               int local_number, int line);
+const l_char *luaF_getlocalname (const Proto *func, int local_number, int pc);
 
 
 #endif

lgc.c

@@ -1,269 +1,386 @@
 /*
-** $Id: lgc.c,v 1.46 2000/03/30 20:55:50 roberto Exp roberto $
+** $Id: lgc.c,v 1.108 2001/06/26 13:20:45 roberto Exp roberto $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
 #include "ldo.h"
 #include "lfunc.h"
 #include "lgc.h"
 #include "lmem.h"
 #include "lobject.h"
-#include "lref.h"
 #include "lstate.h"
 #include "lstring.h"
 #include "ltable.h"
 #include "ltm.h"
-#include "lua.h"
 
 
 
-static void luaD_gcTM (lua_State *L, const TObject *o) {
-  const TObject *im = luaT_getimbyObj(L, o, IM_GC);
-  if (ttype(im) != TAG_NIL) {
-    luaD_checkstack(L, 2);
-    *(L->top++) = *im;
-    *(L->top++) = *o;
-    luaD_call(L, L->top-2, 0);
-  }
-}
+typedef struct GCState {
+  Hash *tmark;  /* list of marked tables to be visited */
+  Closure *cmark;  /* list of marked closures to be visited */
+} GCState;
 
 
-static int markobject (lua_State *L, TObject *o);
-
 
 /* mark a string; marks larger than 1 cannot be changed */
-#define strmark(L, s)    {if ((s)->marked == 0) (s)->marked = 1;}
+#define strmark(s)    {if ((s)->tsv.marked == 0) (s)->tsv.marked = 1;}
 
 
 
-static void protomark (lua_State *L, Proto *f) {
+static void protomark (Proto *f) {
   if (!f->marked) {
     int i;
     f->marked = 1;
-    strmark(L, f->source);
-    for (i=f->nkstr-1; i>=0; i--)
-      strmark(L, f->kstr[i]);
-    for (i=f->nkproto-1; i>=0; i--)
-      protomark(L, f->kproto[i]);
-  }
-}
-
-
-static void closuremark (lua_State *L, Closure *f) {
-  if (!f->marked) {
-    int i = f->nelems;
-    f->marked = 1;
-    while (i--)
-      markobject(L, &f->consts[i]);
-  }
-}
-
-
-static void hashmark (lua_State *L, Hash *h) {
-  if (!h->marked) {
-    int i;
-    h->marked = 1;
-    for (i=h->size-1; i>=0; i--) {
-      Node *n = node(h,i);
-      if (ttype(key(n)) != TAG_NIL) {
-        markobject(L, &n->key);
-        markobject(L, &n->val);
-      }
+    strmark(f->source);
+    for (i=0; i<f->sizek; i++) {
+      if (ttype(f->k+i) == LUA_TSTRING)
+        strmark(tsvalue(f->k+i));
     }
+    for (i=0; i<f->sizep; i++)
+      protomark(f->p[i]);
+    for (i=0; i<f->sizelocvars; i++)  /* mark local-variable names */
+      strmark(f->locvars[i].varname);
   }
 }
 
 
-static void travglobal (lua_State *L) {
-  GlobalVar *gv;
-  for (gv=L->rootglobal; gv; gv=gv->next) {
-    LUA_ASSERT(L, gv->name->u.s.gv == gv, "inconsistent global name");
-    if (gv->value.ttype != TAG_NIL) {
-      strmark(L, gv->name);  /* cannot collect non nil global variables */
-      markobject(L, &gv->value);
+static void markclosure (GCState *st, Closure *cl) {
+  if (!ismarked(cl)) {
+    if (!cl->isC) {
+      lua_assert(cl->nupvalues == cl->f.l->nupvalues);
+      protomark(cl->f.l);
     }
+    cl->mark = st->cmark;  /* chain it for later traversal */
+    st->cmark = cl;
   }
 }
 
 
-static void travstack (lua_State *L) {
-  int i;
-  for (i = (L->top-1)-L->stack; i>=0; i--)
-    markobject(L, L->stack+i);
-}
-
-
-static void travlock (lua_State *L) {
-  int i;
-  for (i=0; i<L->refSize; i++) {
-    if (L->refArray[i].st == LOCK)
-      markobject(L, &L->refArray[i].o);
+static void marktable (GCState *st, Hash *h) {
+  if (!ismarked(h)) {
+    h->mark = st->tmark;  /* chain it for later traversal */
+    st->tmark = h;
   }
 }
 
 
-static int markobject (lua_State *L, TObject *o) {
+static void markobject (GCState *st, TObject *o) {
   switch (ttype(o)) {
-    case TAG_USERDATA:  case TAG_STRING:
-      strmark(L, tsvalue(o));
+    case LUA_TSTRING:
+      strmark(tsvalue(o));
       break;
-    case TAG_TABLE:
-      hashmark(L, avalue(o));
+    case LUA_TUSERDATA:
+      if (!ismarkedudata(uvalue(o)))
+        switchudatamark(uvalue(o));
       break;
-    case TAG_LCLOSURE:  case TAG_LMARK:
-      protomark(L, clvalue(o)->f.l);
-      /* go trhough */
-    case TAG_CCLOSURE:  case TAG_CMARK:
-      closuremark(L, clvalue(o));
+    case LUA_TFUNCTION:
+      markclosure(st, clvalue(o));
       break;
+    case LUA_TTABLE: {
+      marktable(st, hvalue(o));
+      break;
+    }
     default: break;  /* numbers, etc */
   }
-  return 0;
+}
+
+
+static void markstacks (lua_State *L, GCState *st) {
+  lua_State *L1 = L;
+  do {  /* for each thread */
+    StkId o, lim;
+    marktable(st, L1->gt);  /* mark table of globals */
+    for (o=L1->stack; o<L1->top; o++)
+      markobject(st, o);
+    lim = (L1->stack_last - L1->ci->base > MAXSTACK) ? L1->ci->base+MAXSTACK
+                                                     : L1->stack_last;
+    for (; o<=lim; o++) setnilvalue(o);
+    lua_assert(L1->previous->next == L1 && L1->next->previous == L1);
+    L1 = L1->next;
+  } while (L1 != L);
+}
+
+
+static void marktagmethods (global_State *G, GCState *st) {
+  int t;
+  for (t=0; t<G->ntag; t++) {
+    struct TM *tm = &G->TMtable[t];
+    int e;
+    if (tm->name) strmark(tm->name);
+    for (e=0; e<TM_N; e++) {
+      Closure *cl = tm->method[e];
+      if (cl) markclosure(st, cl);
+    }
+  }
+}
+
+
+static void traverseclosure (GCState *st, Closure *f) {
+  int i;
+  for (i=0; i<f->nupvalues; i++)  /* mark its upvalues */
+    markobject(st, &f->upvalue[i]);
+}
+
+
+static void removekey (Node *n) {
+  lua_assert(ttype(val(n)) == LUA_TNIL);
+  if (ttype(key(n)) != LUA_TNIL && ttype(key(n)) != LUA_TNUMBER)
+    setttype(key(n), LUA_TNONE);  /* dead key; remove it */
+}
+
+
+static void traversetable (GCState *st, Hash *h) {
+  int i;
+  int mode = h->weakmode;
+  if (mode == (LUA_WEAK_KEY | LUA_WEAK_VALUE))
+    return;  /* avoid traversing if both keys and values are weak */
+  for (i=0; i<h->size; i++) {
+    Node *n = node(h, i);
+    if (ttype(val(n)) == LUA_TNIL)
+      removekey(n);
+    else {
+      lua_assert(ttype(key(n)) != LUA_TNIL);
+      if (ttype(key(n)) != LUA_TNUMBER && !(mode & LUA_WEAK_KEY))
+        markobject(st, key(n));
+      if (!(mode & LUA_WEAK_VALUE))
+        markobject(st, val(n));
+    }
+  }
+}
+
+
+static void markall (lua_State *L) {
+  GCState st;
+  st.cmark = NULL;
+  st.tmark = NULL;
+  marktagmethods(G(L), &st);  /* mark tag methods */
+  markstacks(L, &st); /* mark all stacks */
+  marktable(&st, G(L)->type2tag);
+  marktable(&st, G(L)->registry);
+  marktable(&st, G(L)->weakregistry);
+  for (;;) {  /* mark tables and closures */
+    if (st.cmark) {
+      Closure *f = st.cmark;  /* get first closure from list */
+      st.cmark = f->mark;  /* remove it from list */
+      traverseclosure(&st, f);
+    }
+    else if (st.tmark) {
+      Hash *h = st.tmark;  /* get first table from list */
+      st.tmark = h->mark;  /* remove it from list */
+      traversetable(&st, h);
+    }
+    else break;  /* nothing else to mark */
+  }
+}
+
+
+static int hasmark (const TObject *o) {
+  switch (ttype(o)) {
+    case LUA_TSTRING:
+      return tsvalue(o)->tsv.marked;
+    case LUA_TUSERDATA:
+      return ismarkedudata(uvalue(o));
+    case LUA_TTABLE:
+      return ismarked(hvalue(o));
+    case LUA_TFUNCTION:
+      return ismarked(clvalue(o));
+    default:  /* number, nil */
+      return 1;
+  }
+}
+
+
+static void cleardeadnodes (Hash *h) {
+  int i;
+  for (i=0; i<h->size; i++) {
+    Node *n = node(h, i);
+    if (ttype(val(n)) == LUA_TNIL) continue;  /* empty node */
+    if (!hasmark(val(n)) || !hasmark(key(n))) {
+      setnilvalue(val(n));  /* remove value */
+      removekey(n);
+    }
+  }
+}
+
+
+static void cleartables (global_State *G) {
+  Hash *h;
+  for (h = G->roottable; h; h = h->next) {
+    if (h->weakmode && ismarked(h))
+      cleardeadnodes(h);
+  }
 }
 
 
 static void collectproto (lua_State *L) {
-  Proto **p = &L->rootproto;
-  Proto *next;
-  while ((next = *p) != NULL) {
-    if (next->marked) {
-      next->marked = 0;
-      p = &next->next;
+  Proto **p = &G(L)->rootproto;
+  Proto *curr;
+  while ((curr = *p) != NULL) {
+    if (curr->marked) {
+      curr->marked = 0;
+      p = &curr->next;
     }
     else {
-      *p = next->next;
-      luaF_freeproto(L, next);
+      *p = curr->next;
+      luaF_freeproto(L, curr);
     }
   }
 }
 
 
 static void collectclosure (lua_State *L) {
-  Closure **p = &L->rootcl;
-  Closure *next;
-  while ((next = *p) != NULL) {
-    if (next->marked) {
-      next->marked = 0;
-      p = &next->next;
+  Closure **p = &G(L)->rootcl;
+  Closure *curr;
+  while ((curr = *p) != NULL) {
+    if (ismarked(curr)) {
+      curr->mark = curr;  /* unmark */
+      p = &curr->next;
     }
     else {
-      *p = next->next;
-      luaF_freeclosure(L, next);
+      *p = curr->next;
+      luaF_freeclosure(L, curr);
     }
   }
 }
 
 
 static void collecttable (lua_State *L) {
-  Hash **p = &L->roottable;
-  Hash *next;
-  while ((next = *p) != NULL) {
-    if (next->marked) {
-      next->marked = 0;
-      p = &next->next;
+  Hash **p = &G(L)->roottable;
+  Hash *curr;
+  while ((curr = *p) != NULL) {
+    if (ismarked(curr)) {
+      curr->mark = curr;  /* unmark */
+      p = &curr->next;
     }
     else {
-      *p = next->next;
-      luaH_free(L, next);
+      *p = curr->next;
+      luaH_free(L, curr);
     }
   }
 }
 
 
-/*
-** remove from the global list globals whose names will be collected
-** (the global itself is freed when its name is freed)
-*/
-static void clear_global_list (lua_State *L, int limit) {
-  GlobalVar **p = &L->rootglobal;
-  GlobalVar *next;
-  while ((next = *p) != NULL) {
-    if (next->name->marked >= limit) p = &next->next;
-    else *p = next->next;
+static void collectudata (lua_State *L, int keep) {
+  Udata **p = &G(L)->rootudata;
+  Udata *curr;
+  while ((curr = *p) != NULL) {
+    if (ismarkedudata(curr)) {
+      switchudatamark(curr);  /* unmark */
+      p = &curr->uv.next;
+    }
+    else {  /* collect */
+      int tag = curr->uv.tag;
+      *p = curr->uv.next;
+      if (keep ||  /* must keep all of them (to close state)? */
+          luaT_gettm(G(L), tag, TM_GC)) {  /* or is there a GC tag method? */
+        curr->uv.next = G(L)->TMtable[tag].collected;  /* chain udata ... */
+        G(L)->TMtable[tag].collected = curr;  /* ... to call its TM later */
+      }
+      else  /* no tag method; delete udata */
+        luaM_free(L, curr, sizeudata(curr->uv.len));
+    }
   }
 }
 
 
-/*
-** collect all elements with `marked' < `limit'.
-** with limit=1, that means all unmarked elements;
-** with limit=MAX_INT, that means all elements.
-*/
-static void collectstring (lua_State *L, int limit) {
-  TObject o;  /* to call userdata `gc' tag method */
+static void collectstrings (lua_State *L, int all) {
   int i;
-  ttype(&o) = TAG_USERDATA;
-  clear_global_list(L, limit);
-  for (i=0; i<NUM_HASHS; i++) {  /* for each hash table */
-    stringtable *tb = &L->string_root[i];
-    int j;
-    for (j=0; j<tb->size; j++) {  /* for each list */
-      TString **p = &tb->hash[j];
-      TString *next;
-      while ((next = *p) != NULL) {
-       if (next->marked >= limit) {
-         if (next->marked < FIXMARK)  /* does not change FIXMARKs */
-           next->marked = 0;
-         p = &next->nexthash;
-       } 
-       else {  /* collect */
-          if (next->constindex == -1) {  /* is userdata? */
-            tsvalue(&o) = next;
-            luaD_gcTM(L, &o);
-          }
-          *p = next->nexthash;
-          luaS_free(L, next);
-          tb->nuse--;
-        }
+  for (i=0; i<G(L)->strt.size; i++) {  /* for each list */
+    TString **p = &G(L)->strt.hash[i];
+    TString *curr;
+    while ((curr = *p) != NULL) {
+      if (curr->tsv.marked && !all) {  /* preserve? */
+        if (curr->tsv.marked < FIXMARK)  /* does not change FIXMARKs */
+          curr->tsv.marked = 0;
+        p = &curr->tsv.nexthash;
+      } 
+      else {  /* collect */
+        *p = curr->tsv.nexthash;
+        G(L)->strt.nuse--;
+        luaM_free(L, curr, sizestring(curr->tsv.len));
       }
     }
-    if ((tb->nuse+1)*6 < tb->size)
-      luaS_resize(L, tb, tb->size/2);  /* table is too big */
+  }
+  if (G(L)->strt.nuse < (ls_nstr)(G(L)->strt.size/4) &&
+      G(L)->strt.size > MINPOWER2)
+    luaS_resize(L, G(L)->strt.size/2);  /* table is too big */
+}
+
+
+
+#define MINBUFFER	256
+static void checkMbuffer (lua_State *L) {
+  if (G(L)->Mbuffsize > MINBUFFER*2) {  /* is buffer too big? */
+    size_t newsize = G(L)->Mbuffsize/2;  /* still larger than MINBUFFER */
+    luaM_reallocvector(L, G(L)->Mbuffer, G(L)->Mbuffsize, newsize, l_char);
+    G(L)->Mbuffsize = newsize;
   }
 }
 
 
-static void markall (lua_State *L) {
-  travstack(L); /* mark stack objects */
-  travglobal(L);  /* mark global variable values and names */
-  travlock(L); /* mark locked objects */
-  luaT_travtagmethods(L, markobject);  /* mark tag methods */
+static void callgcTM (lua_State *L, const TObject *obj) {
+  Closure *tm = luaT_gettmbyObj(G(L), obj, TM_GC);
+  if (tm != NULL) {
+    int oldah = L->allowhooks;
+    StkId top = L->top;
+    L->allowhooks = 0;  /* stop debug hooks during GC tag methods */
+    setclvalue(top, tm);
+    setobj(top+1, obj);
+    L->top += 2;
+    luaD_call(L, top);
+    L->top = top;  /* restore top */
+    L->allowhooks = oldah;  /* restore hooks */
+  }
+}
+
+
+static void callgcTMudata (lua_State *L) {
+  int tag;
+  luaD_checkstack(L, 3);
+  for (tag=G(L)->ntag-1; tag>=0; tag--) {  /* for each tag (in reverse order) */
+    Udata *udata;
+    while ((udata = G(L)->TMtable[tag].collected) != NULL) {
+      G(L)->TMtable[tag].collected = udata->uv.next;  /* remove it from list */
+      udata->uv.next = G(L)->rootudata;  /* resurect it */
+      G(L)->rootudata = udata;
+      setuvalue(L->top, udata);
+      L->top++;  /* keep it in stack to avoid being (recursively) collected */
+      callgcTM(L, L->top-1);
+      uvalue(L->top-1)->uv.tag = 0;  /* default tag (udata is `finalized') */
+      L->top--;
+    }
+  }
+}
+
+
+void luaC_callallgcTM (lua_State *L) {
+  if (G(L)->rootudata) {  /* avoid problems with incomplete states */
+    collectudata(L, 1);  /* collect all udata into tag lists */
+    callgcTMudata(L);  /* call their GC tag methods */
+  }
 }
 
 
 void luaC_collect (lua_State *L, int all) {
-  int oldah = L->allowhooks;
-  L->allowhooks = 0;  /* stop debug hooks during GC */
-  L->GCthreshold *= 4;  /* to avoid GC during GC */
+  collectudata(L, 0);
+  collectstrings(L, all);
   collecttable(L);
-  collectstring(L, all?MAX_INT:1);
   collectproto(L);
   collectclosure(L);
-  L->allowhooks = oldah;  /* restore hooks */
 }
 
 
-long lua_collectgarbage (lua_State *L, long limit) {
-  unsigned long recovered = L->nblocks;  /* to subtract `nblocks' after gc */
+void luaC_collectgarbage (lua_State *L) {
   markall(L);
-  luaR_invalidaterefs(L);
+  cleartables(G(L));
   luaC_collect(L, 0);
-  recovered = recovered - L->nblocks;
-  L->GCthreshold = (limit == 0) ? 2*L->nblocks : L->nblocks+limit;
-  if (L->Mbuffsize > L->Mbuffnext*4) {  /* is buffer too big? */
-    L->Mbuffsize /= 2;  /* still larger than Mbuffnext*2 */
-    luaM_reallocvector(L, L->Mbuffer, L->Mbuffsize, char);
-  }
-  luaD_gcTM(L, &luaO_nilobject);
-  return recovered;
-}
-
-
-void luaC_checkGC (lua_State *L) {
-  if (L->nblocks >= L->GCthreshold)
-    lua_collectgarbage(L, 0);
+  checkMbuffer(L);
+  G(L)->GCthreshold = 2*G(L)->nblocks;  /* new threshold */
+  callgcTMudata(L);
+  callgcTM(L, &luaO_nilobject);
 }
 

lgc.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lgc.h,v 1.6 1999/10/04 17:51:04 roberto Exp roberto $
+** $Id: lgc.h,v 1.11 2001/06/12 18:43:13 roberto Exp roberto $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
@@ -11,8 +11,13 @@
 #include "lobject.h"
 
 
-void luaC_checkGC (lua_State *L);
+#define luaC_checkGC(L) if (G(L)->nblocks >= G(L)->GCthreshold) \
+			  luaC_collectgarbage(L)
+
+
+void luaC_callallgcTM (lua_State *L);
 void luaC_collect (lua_State *L, int all);
+void luaC_collectgarbage (lua_State *L);
 
 
 #endif

linit.c

@@ -1,21 +1,8 @@
 /*
-** $Id: linit.c,v 1.2 1999/11/22 13:12:07 roberto Exp roberto $
+** $Id: linit.c,v 1.5 2000/06/16 17:22:43 roberto Exp roberto $
 ** Initialization of libraries for lua.c
 ** See Copyright Notice in lua.h
 */
 
-#define LUA_REENTRANT
-
-#include "lua.h"
-#include "lualib.h"
-
-
-void lua_userinit (lua_State *L) {
-  lua_beginblock(L);
-  lua_iolibopen(L);
-  lua_strlibopen(L);
-  lua_mathlibopen(L);
-  lua_dblibopen(L);
-  lua_endblock(L);
-}
+>>>>>>> This module is now obsolete, and is not part of Lua. <<<<<<<<<
 

llex.c

@@ -1,5 +1,5 @@
 /*
-** $Id: llex.c,v 1.56 2000/04/07 13:11:49 roberto Exp roberto $
+** $Id: llex.c,v 1.88 2001/06/20 21:07:57 roberto Exp roberto $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
@@ -9,16 +9,14 @@
 #include <stdio.h>
 #include <string.h>
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
-#include "lauxlib.h"
 #include "llex.h"
-#include "lmem.h"
 #include "lobject.h"
 #include "lparser.h"
 #include "lstate.h"
 #include "lstring.h"
-#include "luadebug.h"
 #include "lzio.h"
 
 
@@ -26,52 +24,63 @@
 #define next(LS) (LS->current = zgetc(LS->z))
 
 
-#define save(L, c)	luaL_addchar(L, c)
-#define save_and_next(L, LS)  (save(L, LS->current), next(LS))
-
 
 /* ORDER RESERVED */
-static const char *const token2string [] = {
-    "and", "break", "do", "else", "elseif", "end", "for",
-    "function", "if", "local", "nil", "not", "or", "repeat", "return", "then",
-    "until", "while", "", "..", "...", "==", ">=", "<=", "~=", "", "", "<eof>"};
+static const l_char *const token2string [] = {
+    l_s("and"), l_s("break"), l_s("do"), l_s("else"), l_s("elseif"),
+    l_s("end"), l_s("for"), l_s("function"), l_s("global"), l_s("if"),
+    l_s("in"), l_s("local"), l_s("nil"), l_s("not"), l_s("or"), l_s("repeat"),
+    l_s("return"), l_s("then"), l_s("until"), l_s("while"), l_s(""),
+    l_s(".."), l_s("..."), l_s("=="), l_s(">="), l_s("<="), l_s("~="),
+    l_s(""), l_s(""), l_s("<eof>")
+};
 
 
 void luaX_init (lua_State *L) {
   int i;
   for (i=0; i<NUM_RESERVED; i++) {
     TString *ts = luaS_new(L, token2string[i]);
-    ts->marked = (unsigned char)(RESERVEDMARK+i);  /* reserved word */
+    lua_assert(strlen(token2string[i])+1 <= TOKEN_LEN);
+    ts->tsv.marked = (unsigned short)(RESERVEDMARK+i);  /* reserved word */
   }
 }
 
 
 #define MAXSRC          80
 
-void luaX_syntaxerror (LexState *ls, const char *s, const char *token) {
-  char buff[MAXSRC];
-  luaL_chunkid(buff, zname(ls->z), sizeof(buff));
-  luaL_verror(ls->L, "%.100s;\n  last token read: `%.50s' at line %d in %.80s",
+
+void luaX_checklimit (LexState *ls, int val, int limit, const l_char *msg) {
+  if (val > limit) {
+    l_char buff[90];
+    sprintf(buff, l_s("too many %.40s (limit=%d)"), msg, limit);
+    luaX_error(ls, buff, ls->t.token);
+  }
+}
+
+
+void luaX_syntaxerror (LexState *ls, const l_char *s, const l_char *token) {
+  l_char buff[MAXSRC];
+  luaO_chunkid(buff, getstr(ls->source), MAXSRC);
+  luaO_verror(ls->L,
+              l_s("%.99s;\n  last token read: `%.30s' at line %d in %.80s"),
               s, token, ls->linenumber, buff);
 }
 
 
-void luaX_error (LexState *ls, const char *s, int token) {
-  char buff[TOKEN_LEN];
+void luaX_error (LexState *ls, const l_char *s, int token) {
+  l_char buff[TOKEN_LEN];
   luaX_token2str(token, buff);
-  if (buff[0] == '\0') {
-    save(ls->L, '\0');
-    luaX_syntaxerror(ls, s, luaL_buffer(ls->L));
-  }
+  if (buff[0] == l_c('\0'))
+    luaX_syntaxerror(ls, s, (l_char *)G(ls->L)->Mbuffer);
   else
     luaX_syntaxerror(ls, s, buff);
 }
 
 
-void luaX_token2str (int token, char *s) {
+void luaX_token2str (int token, l_char *s) {
   if (token < 256) {
-    s[0] = (char)token;
-    s[1] = '\0';
+    s[0] = (l_char)token;
+    s[1] = l_c('\0');
   }
   else
     strcpy(s, token2string[token-FIRST_RESERVED]);
@@ -79,146 +88,32 @@ void luaX_token2str (int token, char *s) {
 
 
 static void luaX_invalidchar (LexState *ls, int c) {
-  char buff[8];
-  sprintf(buff, "0x%02X", c);
-  luaX_syntaxerror(ls, "invalid control char", buff);
+  l_char buff[8];
+  sprintf(buff, l_s("0x%02X"), uchar(c));
+  luaX_syntaxerror(ls, l_s("invalid control char"), buff);
 }
 
 
-static void firstline (LexState *LS)
-{
-  int c = zgetc(LS->z);
-  if (c == '#')
-    while ((c=zgetc(LS->z)) != '\n' && c != EOZ) /* skip first line */;
-  zungetc(LS->z);
+static void inclinenumber (LexState *LS) {
+  next(LS);  /* skip `\n' */
+  ++LS->linenumber;
+  luaX_checklimit(LS, LS->linenumber, MAX_INT, l_s("lines in a chunk"));
 }
 
 
-void luaX_setinput (lua_State *L, LexState *LS, ZIO *z) {
+void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source) {
   LS->L = L;
-  LS->current = '\n';
-  LS->linenumber = 0;
-  LS->iflevel = 0;
-  LS->ifstate[0].skip = 0;
-  LS->ifstate[0].elsepart = 1;  /* to avoid a free $else */
+  LS->lookahead.token = TK_EOS;  /* no look-ahead token */
   LS->z = z;
   LS->fs = NULL;
-  firstline(LS);
-  luaL_resetbuffer(L);
-}
-
-
-
-/*
-** =======================================================
-** PRAGMAS
-** =======================================================
-*/
-
-static void skipspace (LexState *LS) {
-  while (LS->current == ' ' || LS->current == '\t' || LS->current == '\r')
-    next(LS);
-}
-
-
-static int checkcond (lua_State *L, LexState *LS, const char *buff) {
-  static const char *const opts[] = {"nil", "1", NULL};
-  int i = luaL_findstring(buff, opts);
-  if (i >= 0) return i;
-  else if (isalpha((unsigned char)buff[0]) || buff[0] == '_')
-    return luaS_globaldefined(L, buff);
-  else {
-    luaX_syntaxerror(LS, "invalid $if condition", buff);
-    return 0;  /* to avoid warnings */
-  }
-}
-
-
-static void readname (LexState *LS, char *buff) {
-  int i = 0;
-  skipspace(LS);
-  while (isalnum(LS->current) || LS->current == '_') {
-    if (i >= PRAGMASIZE) {
-      buff[PRAGMASIZE] = 0;
-      luaX_syntaxerror(LS, "pragma too long", buff);
-    }
-    buff[i++] = (char)LS->current;
-    next(LS);
-  }
-  buff[i] = 0;
-}
-
-
-static void inclinenumber (lua_State *L, LexState *LS);
-
-
-static void ifskip (lua_State *L, LexState *LS) {
-  while (LS->ifstate[LS->iflevel].skip) {
-    if (LS->current == '\n')
-      inclinenumber(L, LS);
-    else if (LS->current == EOZ)
-      luaX_error(LS, "input ends inside a $if", TK_EOS);
-    else next(LS);
-  }
-}
-
-
-static void inclinenumber (lua_State *L, LexState *LS) {
-  static const char *const pragmas [] =
-    {"debug", "nodebug", "endinput", "end", "ifnot", "if", "else", NULL};
-  next(LS);  /* skip '\n' */
-  ++LS->linenumber;
-  if (LS->current == '$') {  /* is a pragma? */
-    char buff[PRAGMASIZE+1];
-    int ifnot = 0;
-    int skip = LS->ifstate[LS->iflevel].skip;
-    next(LS);  /* skip $ */
-    readname(LS, buff);
-    switch (luaL_findstring(buff, pragmas)) {
-      case 0:  /* debug */
-        if (!skip) L->debug = 1;
-        break;
-      case 1:  /* nodebug */
-        if (!skip) L->debug = 0;
-        break;
-      case 2:  /* endinput */
-        if (!skip) {
-          LS->current = EOZ;
-          LS->iflevel = 0;  /* to allow $endinput inside a $if */
-        }
-        break;
-      case 3:  /* end */
-        if (LS->iflevel-- == 0)
-          luaX_syntaxerror(LS, "unmatched $end", "$end");
-        break;
-      case 4:  /* ifnot */
-        ifnot = 1;
-        /* go through */
-      case 5:  /* if */
-        if (LS->iflevel == MAX_IFS-1)
-          luaX_syntaxerror(LS, "too many nested $ifs", "$if");
-        readname(LS, buff);
-        LS->iflevel++;
-        LS->ifstate[LS->iflevel].elsepart = 0;
-        LS->ifstate[LS->iflevel].condition = checkcond(L, LS, buff) ? !ifnot : ifnot;
-        LS->ifstate[LS->iflevel].skip = skip || !LS->ifstate[LS->iflevel].condition;
-        break;
-      case 6:  /* else */
-        if (LS->ifstate[LS->iflevel].elsepart)
-          luaX_syntaxerror(LS, "unmatched $else", "$else");
-        LS->ifstate[LS->iflevel].elsepart = 1;
-        LS->ifstate[LS->iflevel].skip = LS->ifstate[LS->iflevel-1].skip ||
-                                      LS->ifstate[LS->iflevel].condition;
-        break;
-      default:
-        luaX_syntaxerror(LS, "unknown pragma", buff);
-    }
-    skipspace(LS);
-    if (LS->current == '\n')  /* pragma must end with a '\n' ... */
-      inclinenumber(L, LS);
-    else if (LS->current != EOZ)  /* or eof */
-      luaX_syntaxerror(LS, "invalid pragma format", buff);
-    ifskip(L, LS);
+  LS->linenumber = 1;
+  LS->lastline = 1;
+  LS->source = source;
+  next(LS);  /* read first char */
+  if (LS->current == l_c('#')) {
+    do {  /* skip first line */
+      next(LS);
+    } while (LS->current != l_c('\n') && LS->current != EOZ);
   }
 }
 
@@ -231,215 +126,264 @@ static void inclinenumber (lua_State *L, LexState *LS) {
 */
 
 
+/* use Mbuffer to store names, literal strings and numbers */
 
-static void read_long_string (lua_State *L, LexState *LS) {
-  int cont = 0;
-  for (;;) {
-    switch (LS->current) {
-      case EOZ:
-        luaX_error(LS, "unfinished long string", TK_STRING);
-        break;  /* to avoid warnings */
-      case '[':
-        save_and_next(L, LS);
-        if (LS->current == '[') {
-          cont++;
-          save_and_next(L, LS);
-        }
-        continue;
-      case ']':
-        save_and_next(L, LS);
-        if (LS->current == ']') {
-          if (cont == 0) goto endloop;
-          cont--;
-          save_and_next(L, LS);
-        }
-        continue;
-      case '\n':
-        save(L, '\n');
-        inclinenumber(L, LS);
-        continue;
-      default:
-        save_and_next(L, LS);
-    }
-  } endloop:
-  save_and_next(L, LS);  /* skip the second ']' */
-  LS->seminfo.ts = luaS_newlstr(L, L->Mbuffer+(L->Mbuffbase+2),
-                          L->Mbuffnext-L->Mbuffbase-4);
+#define EXTRABUFF	128
+#define checkbuffer(L, n, len)	\
+    if (((len)+(n))*sizeof(l_char) > G(L)->Mbuffsize) \
+      luaO_openspace(L, (len)+(n)+EXTRABUFF, l_char)
+
+#define save(L, c, l)	(((l_char *)G(L)->Mbuffer)[l++] = (l_char)c)
+#define save_and_next(L, LS, l)  (save(L, LS->current, l), next(LS))
+
+
+static size_t readname (LexState *LS) {
+  lua_State *L = LS->L;
+  size_t l = 0;
+  checkbuffer(L, 10, l);
+  do {
+    checkbuffer(L, 10, l);
+    save_and_next(L, LS, l);
+  } while (isalnum(LS->current) || LS->current == l_c('_'));
+  save(L, l_c('\0'), l);
+  return l-1;
 }
 
 
-static void read_string (lua_State *L, LexState *LS, int del) {
-  save_and_next(L, LS);
-  while (LS->current != del) {
+/* LUA_NUMBER */
+static void read_number (LexState *LS, int comma, SemInfo *seminfo) {
+  lua_State *L = LS->L;
+  size_t l = 0;
+  checkbuffer(L, 10, l);
+  if (comma) save(L, l_c('.'), l);
+  while (isdigit(LS->current)) {
+    checkbuffer(L, 10, l);
+    save_and_next(L, LS, l);
+  }
+  if (LS->current == l_c('.')) {
+    save_and_next(L, LS, l);
+    if (LS->current == l_c('.')) {
+      save_and_next(L, LS, l);
+      save(L, l_c('\0'), l);
+      luaX_error(LS,
+                 l_s("ambiguous syntax (decimal point x string concatenation)"),
+                 TK_NUMBER);
+    }
+  }
+  while (isdigit(LS->current)) {
+    checkbuffer(L, 10, l);
+    save_and_next(L, LS, l);
+  }
+  if (LS->current == l_c('e') || LS->current == l_c('E')) {
+    save_and_next(L, LS, l);  /* read `E' */
+    if (LS->current == l_c('+') || LS->current == l_c('-'))
+      save_and_next(L, LS, l);  /* optional exponent sign */
+    while (isdigit(LS->current)) {
+      checkbuffer(L, 10, l);
+      save_and_next(L, LS, l);
+    }
+  }
+  save(L, l_c('\0'), l);
+  if (!luaO_str2d((l_char *)G(L)->Mbuffer, &seminfo->r))
+    luaX_error(LS, l_s("malformed number"), TK_NUMBER);
+}
+
+
+static void read_long_string (LexState *LS, SemInfo *seminfo) {
+  lua_State *L = LS->L;
+  int cont = 0;
+  size_t l = 0;
+  checkbuffer(L, 10, l);
+  save(L, l_c('['), l);  /* save first `[' */
+  save_and_next(L, LS, l);  /* pass the second `[' */
+  if (LS->current == l_c('\n'))  /* string starts with a newline? */
+    inclinenumber(LS);  /* skip it */
+  for (;;) {
+    checkbuffer(L, 10, l);
     switch (LS->current) {
-      case EOZ:  case '\n':
-        luaX_error(LS, "unfinished string", TK_STRING);
+      case EOZ:
+        save(L, l_c('\0'), l);
+        luaX_error(LS, l_s("unfinished long string"), TK_STRING);
         break;  /* to avoid warnings */
-      case '\\':
-        next(LS);  /* do not save the '\' */
+      case l_c('['):
+        save_and_next(L, LS, l);
+        if (LS->current == l_c('[')) {
+          cont++;
+          save_and_next(L, LS, l);
+        }
+        continue;
+      case l_c(']'):
+        save_and_next(L, LS, l);
+        if (LS->current == l_c(']')) {
+          if (cont == 0) goto endloop;
+          cont--;
+          save_and_next(L, LS, l);
+        }
+        continue;
+      case l_c('\n'):
+        save(L, l_c('\n'), l);
+        inclinenumber(LS);
+        continue;
+      default:
+        save_and_next(L, LS, l);
+    }
+  } endloop:
+  save_and_next(L, LS, l);  /* skip the second `]' */
+  save(L, l_c('\0'), l);
+  seminfo->ts = luaS_newlstr(L, (l_char *)G(L)->Mbuffer+2, l-5);
+}
+
+
+static void read_string (LexState *LS, int del, SemInfo *seminfo) {
+  lua_State *L = LS->L;
+  size_t l = 0;
+  checkbuffer(L, 10, l);
+  save_and_next(L, LS, l);
+  while (LS->current != del) {
+    checkbuffer(L, 10, l);
+    switch (LS->current) {
+      case EOZ:  case l_c('\n'):
+        save(L, l_c('\0'), l);
+        luaX_error(LS, l_s("unfinished string"), TK_STRING);
+        break;  /* to avoid warnings */
+      case l_c('\\'):
+        next(LS);  /* do not save the `\' */
         switch (LS->current) {
-          case 'a': save(L, '\a'); next(LS); break;
-          case 'b': save(L, '\b'); next(LS); break;
-          case 'f': save(L, '\f'); next(LS); break;
-          case 'n': save(L, '\n'); next(LS); break;
-          case 'r': save(L, '\r'); next(LS); break;
-          case 't': save(L, '\t'); next(LS); break;
-          case 'v': save(L, '\v'); next(LS); break;
-          case '\n': save(L, '\n'); inclinenumber(L, LS); break;
-          case '0': case '1': case '2': case '3': case '4':
-          case '5': case '6': case '7': case '8': case '9': {
-            int c = 0;
-            int i = 0;
-            do {
-              c = 10*c + (LS->current-'0');
-              next(LS);
-            } while (++i<3 && isdigit(LS->current));
-            if (c != (unsigned char)c)
-              luaX_error(LS, "escape sequence too large", TK_STRING);
-            save(L, c);
-            break;
+          case l_c('a'): save(L, l_c('\a'), l); next(LS); break;
+          case l_c('b'): save(L, l_c('\b'), l); next(LS); break;
+          case l_c('f'): save(L, l_c('\f'), l); next(LS); break;
+          case l_c('n'): save(L, l_c('\n'), l); next(LS); break;
+          case l_c('r'): save(L, l_c('\r'), l); next(LS); break;
+          case l_c('t'): save(L, l_c('\t'), l); next(LS); break;
+          case l_c('v'): save(L, l_c('\v'), l); next(LS); break;
+          case l_c('\n'): save(L, l_c('\n'), l); inclinenumber(LS); break;
+          default: {
+            if (!isdigit(LS->current))
+              save_and_next(L, LS, l);  /* handles \\, \", \', and \? */
+            else {  /* \xxx */
+              int c = 0;
+              int i = 0;
+              do {
+                c = 10*c + (LS->current-l_c('0'));
+                next(LS);
+              } while (++i<3 && isdigit(LS->current));
+              if (c > UCHAR_MAX) {
+                save(L, l_c('\0'), l);
+                luaX_error(LS, l_s("escape sequence too large"), TK_STRING);
+              }
+              save(L, c, l);
+            }
           }
-          default:  /* handles \\, \", \', and \? */
-            save(L, LS->current);
-            next(LS);
         }
         break;
       default:
-        save_and_next(L, LS);
+        save_and_next(L, LS, l);
     }
   }
-  save_and_next(L, LS);  /* skip delimiter */
-  LS->seminfo.ts = luaS_newlstr(L, L->Mbuffer+(L->Mbuffbase+1),
-                          L->Mbuffnext-L->Mbuffbase-2);
+  save_and_next(L, LS, l);  /* skip delimiter */
+  save(L, l_c('\0'), l);
+  seminfo->ts = luaS_newlstr(L, (l_char *)G(L)->Mbuffer+1, l-3);
 }
 
 
-int luaX_lex (LexState *LS) {
-  lua_State *L = LS->L;
+int luaX_lex (LexState *LS, SemInfo *seminfo) {
   for (;;) {
     switch (LS->current) {
 
-      case ' ': case '\t': case '\r':  /* `\r' to avoid problems with DOS */
+      case l_c(' '): case l_c('\t'): case l_c('\r'):  /* `\r' to avoid problems with DOS */
         next(LS);
         continue;
 
-      case '\n':
-        inclinenumber(L, LS);
+      case l_c('\n'):
+        inclinenumber(LS);
         continue;
 
-      case '-':
+      case l_c('$'):
+        luaX_error(LS,
+                   l_s("unexpected `$' (pragmas are no longer supported)"),
+                   LS->current);
+        break;
+
+      case l_c('-'):
         next(LS);
-        if (LS->current != '-') return '-';
-        do { next(LS); } while (LS->current != '\n' && LS->current != EOZ);
+        if (LS->current != l_c('-')) return l_c('-');
+        do { next(LS); } while (LS->current != l_c('\n') && LS->current != EOZ);
         continue;
 
-      case '[':
-        luaL_resetbuffer(L);
-        save_and_next(L, LS);
-        if (LS->current != '[') return '[';
+      case l_c('['):
+        next(LS);
+        if (LS->current != l_c('[')) return l_c('[');
         else {
-          save_and_next(L, LS);  /* pass the second '[' */
-          read_long_string(L, LS);
+          read_long_string(LS, seminfo);
           return TK_STRING;
         }
 
-      case '=':
+      case l_c('='):
         next(LS);
-        if (LS->current != '=') return '=';
+        if (LS->current != l_c('=')) return l_c('=');
         else { next(LS); return TK_EQ; }
 
-      case '<':
+      case l_c('<'):
         next(LS);
-        if (LS->current != '=') return '<';
+        if (LS->current != l_c('=')) return l_c('<');
         else { next(LS); return TK_LE; }
 
-      case '>':
+      case l_c('>'):
         next(LS);
-        if (LS->current != '=') return '>';
+        if (LS->current != l_c('=')) return l_c('>');
         else { next(LS); return TK_GE; }
 
-      case '~':
+      case l_c('~'):
         next(LS);
-        if (LS->current != '=') return '~';
+        if (LS->current != l_c('=')) return l_c('~');
         else { next(LS); return TK_NE; }
 
-      case '"':
-      case '\'':
-        luaL_resetbuffer(L);
-        read_string(L, LS, LS->current);
+      case l_c('"'):
+      case l_c('\''):
+        read_string(LS, LS->current, seminfo);
         return TK_STRING;
 
-      case '.':
-        luaL_resetbuffer(L);
-        save_and_next(L, LS);
-        if (LS->current == '.') {
+      case l_c('.'):
+        next(LS);
+        if (LS->current == l_c('.')) {
           next(LS);
-          if (LS->current == '.') {
+          if (LS->current == l_c('.')) {
             next(LS);
             return TK_DOTS;   /* ... */
           }
           else return TK_CONCAT;   /* .. */
         }
-        else if (!isdigit(LS->current)) return '.';
-        else goto fraction;  /* LS->current is a digit */
-
-      case '0': case '1': case '2': case '3': case '4':
-      case '5': case '6': case '7': case '8': case '9':
-        luaL_resetbuffer(L);
-        do {
-          save_and_next(L, LS);
-        } while (isdigit(LS->current));
-        if (LS->current == '.') {
-          save_and_next(L, LS);
-          if (LS->current == '.') {
-            save(L, '.');
-            luaX_error(LS, "ambiguous syntax"
-                       " (decimal point x string concatenation)", TK_NUMBER);
-          }
+        else if (!isdigit(LS->current)) return l_c('.');
+        else {
+          read_number(LS, 1, seminfo);
+          return TK_NUMBER;
         }
-      fraction:  /* LUA_NUMBER */
-        while (isdigit(LS->current))
-          save_and_next(L, LS);
-        if (LS->current == 'e' || LS->current == 'E') {
-          save_and_next(L, LS);  /* read 'E' */
-          if (LS->current == '+' || LS->current == '-')
-            save_and_next(L, LS);  /* optional exponent sign */
-          while (isdigit(LS->current))
-            save_and_next(L, LS);
-        }
-        save(L, '\0');
-        if (!luaO_str2d(L->Mbuffer+L->Mbuffbase, &LS->seminfo.r))
-          luaX_error(LS, "malformed number", TK_NUMBER);
-        return TK_NUMBER;
 
       case EOZ:
-        if (LS->iflevel > 0)
-          luaX_error(LS, "input ends inside a $if", TK_EOS);
         return TK_EOS;
 
-      case '_': goto tname;
-
-      default:
-        if (!isalpha(LS->current)) {
-          int c = LS->current;
+      default: {
+        if (isdigit(LS->current)) {
+          read_number(LS, 0, seminfo);
+          return TK_NUMBER;
+        }
+        else if (isalpha(LS->current) || LS->current == l_c('_')) {
+          /* identifier or reserved word */
+          size_t l = readname(LS);
+          TString *ts = luaS_newlstr(LS->L, (l_char *)G(LS->L)->Mbuffer, l);
+          if (ts->tsv.marked >= RESERVEDMARK)  /* reserved word? */
+            return ts->tsv.marked-RESERVEDMARK+FIRST_RESERVED;
+          seminfo->ts = ts;
+          return TK_NAME;
+        }
+        else {
+          l_charint c = LS->current;
           if (iscntrl(c))
             luaX_invalidchar(LS, c);
           next(LS);
-          return c;
-        }
-        tname: {  /* identifier or reserved word */
-          TString *ts;
-          luaL_resetbuffer(L);
-          do {
-            save_and_next(L, LS);
-          } while (isalnum(LS->current) || LS->current == '_');
-          save(L, '\0');
-          ts = luaS_new(L, L->Mbuffer+L->Mbuffbase);
-          if (ts->marked >= RESERVEDMARK)  /* reserved word? */
-            return ts->marked-RESERVEDMARK+FIRST_RESERVED;
-          LS->seminfo.ts = ts;
-          return TK_NAME;
+          return c;  /* single-char tokens (+ - / ...) */
         }
+      }
     }
   }
 }

llex.h

@@ -1,5 +1,5 @@
 /*
-** $Id: llex.h,v 1.23 2000/04/07 13:11:49 roberto Exp roberto $
+** $Id: llex.h,v 1.36 2001/06/20 21:07:57 roberto Exp roberto $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
@@ -13,8 +13,8 @@
 
 #define FIRST_RESERVED	257
 
-/* maximum length of a reserved word (+1 for final 0) */
-#define TOKEN_LEN	15
+/* maximum length of a reserved word */
+#define TOKEN_LEN	(sizeof(l_s("function"))/sizeof(l_char))
 
 
 /*
@@ -24,8 +24,9 @@
 enum RESERVED {
   /* terminal symbols denoted by reserved words */
   TK_AND = FIRST_RESERVED, TK_BREAK,
-  TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FOR, TK_FUNCTION, TK_IF, TK_LOCAL,
-  TK_NIL, TK_NOT, TK_OR, TK_REPEAT, TK_RETURN, TK_THEN, TK_UNTIL, TK_WHILE,
+  TK_DO, TK_ELSE, TK_ELSEIF, TK_END, TK_FOR, TK_FUNCTION, TK_GLOBAL, TK_IF,
+  TK_IN, TK_LOCAL, TK_NIL, TK_NOT, TK_OR, TK_REPEAT, TK_RETURN, TK_THEN,
+  TK_UNTIL, TK_WHILE,
   /* other terminal symbols */
   TK_NAME, TK_CONCAT, TK_DOTS, TK_EQ, TK_GE, TK_LE, TK_NE, TK_NUMBER,
   TK_STRING, TK_EOS
@@ -35,37 +36,38 @@ enum RESERVED {
 #define NUM_RESERVED	((int)(TK_WHILE-FIRST_RESERVED+1))
 
 
-/* `ifState' keeps the state of each nested $if the lexical is dealing with. */
+typedef union {
+  lua_Number r;
+  TString *ts;
+} SemInfo;  /* semantics information */
 
-struct ifState {
-  int elsepart;  /* true if it's in the $else part */
-  int condition;  /* true if $if condition is true */
-  int skip;  /* true if part must be skipped */
-};
+
+typedef struct Token {
+  int token;
+  SemInfo seminfo;
+} Token;
 
 
 typedef struct LexState {
-  int current;  /* look ahead character */
-  int token;  /* look ahead token */
+  l_charint current;  /* current character */
+  Token t;  /* current token */
+  Token lookahead;  /* look ahead token */
   struct FuncState *fs;  /* `FuncState' is private to the parser */
   struct lua_State *L;
-  union {
-    Number r;
-    TString *ts;
-  } seminfo;  /* semantics information */
   struct zio *z;  /* input stream */
   int linenumber;  /* input line counter */
-  int iflevel;  /* level of nested $if's (for lexical analysis) */
-  struct ifState ifstate[MAX_IFS];
+  int lastline;  /* line of last token `consumed' */
+  TString *source;  /* current source name */
 } LexState;
 
 
 void luaX_init (lua_State *L);
-void luaX_setinput (lua_State *L, LexState *LS, ZIO *z);
-int luaX_lex (LexState *LS);
-void luaX_syntaxerror (LexState *ls, const char *s, const char *token);
-void luaX_error (LexState *ls, const char *s, int token);
-void luaX_token2str (int token, char *s);
+void luaX_setinput (lua_State *L, LexState *LS, ZIO *z, TString *source);
+int luaX_lex (LexState *LS, SemInfo *seminfo);
+void luaX_checklimit (LexState *ls, int val, int limit, const l_char *msg);
+void luaX_syntaxerror (LexState *ls, const l_char *s, const l_char *token);
+void luaX_error (LexState *ls, const l_char *s, int token);
+void luaX_token2str (int token, l_char *s);
 
 
 #endif

llimits.h

@@ -1,6 +1,6 @@
 /*
-** $Id: llimits.h,v 1.4 2000/03/31 16:28:45 roberto Exp roberto $
-** Limits, basic types, and some other "instalation-dependent" definitions
+** $Id: llimits.h,v 1.29 2001/06/05 18:17:01 roberto Exp roberto $
+** Limits, basic types, and some other `installation-dependent' definitions
 ** See Copyright Notice in lua.h
 */
 
@@ -9,38 +9,69 @@
 
 
 #include <limits.h>
+#include <stddef.h>
+
+
+#include "lua.h"
 
 
 /*
-** Define the type `number' of Lua
-** GREP LUA_NUMBER to change that
+** try to find number of bits in an integer
 */
-#ifndef LUA_NUM_TYPE
-#define LUA_NUM_TYPE double
+#ifndef BITS_INT
+/* avoid overflows in comparison */
+#if INT_MAX-20 < 32760
+#define	BITS_INT	16
+#else
+#if INT_MAX > 2147483640L
+/* machine has at least 32 bits */
+#define BITS_INT	32
+#else
+#error "you must define BITS_INT with number of bits in an integer"
+#endif
+#endif
 #endif
 
-typedef LUA_NUM_TYPE Number;
 
+/*
+** the following types define integer types for values that may not
+** fit in a `small int' (16 bits), but may waste space in a
+** `large long' (64 bits). The current definitions should work in
+** any machine, but may not be optimal.
+*/
+
+/* an unsigned integer to hold hash values */
+typedef unsigned int lu_hash;
+/* its signed equivalent */
+typedef int ls_hash;
+
+/* an unsigned integer big enough to count the total memory used by Lua */
+typedef unsigned long lu_mem;
+
+/* an integer big enough to count the number of strings in use */
+typedef long ls_nstr;
+
+
+/* chars used as small naturals (so that `char' is reserved for characteres) */
+typedef unsigned char lu_byte;
+
+
+#define MAX_SIZET	((size_t)(~(size_t)0)-2)
 
 
 #define MAX_INT (INT_MAX-2)  /* maximum value of an int (-2 for safety) */
 
 /*
-** conversion of pointer to int (for hashing only)
+** conversion of pointer to integer
+** this is for hashing only; there is no problem if the integer
+** cannot hold the whole pointer value
 ** (the shift removes bits that are usually 0 because of alignment)
 */
-#define IntPoint(L, p)  (((unsigned long)(p)) >> 3)
+#define IntPoint(p)  ((((lu_hash)(p)) >> 4) ^ (lu_hash)(p))
 
 
-/*
-** number of `blocks' for garbage collection: each reference to other
-** objects count 1, and each 32 bytes of `raw' memory count 1; we add
-** 2 to the total as a minimum (and also to count the overhead of malloc)
-*/
-#define numblocks(L, o,b)       ((o)+((b)>>5)+2)
 
-
-#define MINPOWER2       4       /* minimum size for "growing" vectors */
+#define MINPOWER2       4       /* minimum size for `growing' vectors */
 
 
 
@@ -50,98 +81,34 @@ typedef LUA_NUM_TYPE Number;
 
 
 
+/* type to ensure maximum alignment */
+#ifndef LUSER_ALIGNMENT_T
+#define LUSER_ALIGNMENT_T	double
+#endif
+union L_Umaxalign { LUSER_ALIGNMENT_T u; void *s; long l; };
+
+
+
 /*
 ** type for virtual-machine instructions
-** must be an unsigned with 4 bytes (see details in lopcodes.h)
-** For a very small machine, you may change that to 2 bytes (and adjust
-** the following limits accordingly)
+** must be an unsigned with (at least) 4 bytes (see details in lopcodes.h)
 */
 typedef unsigned long Instruction;
 
 
-/*
-** limits for opcode arguments.
-** For an instruction with 2 bytes, size is 16, and size_b can be 5
-*/
-#define SIZE_INSTRUCTION        32
-#define SIZE_OP         6
-#define SIZE_B          9
-
-#define SIZE_U          (SIZE_INSTRUCTION-SIZE_OP)
-#define POS_U           SIZE_OP
-#define POS_B           SIZE_OP
-#define SIZE_A          (SIZE_INSTRUCTION-(SIZE_OP+SIZE_B))
-#define POS_A           (SIZE_OP+SIZE_B)
-
-#define MAXARG_U        ((1<<SIZE_U)-1)
-#define MAXARG_S        (MAXARG_U>>1)		/* `S' is signed */
-#define MAXARG_A        ((1<<SIZE_A)-1)
-#define MAXARG_B        ((1<<SIZE_B)-1)
-
-
-/*
-** we use int to manipulate most arguments, so they must fit
-*/
-#if MAXARG_U > MAX_INT
-#undef MAXARG_U
-#define MAXARG_U        MAX_INT
-#endif
-
-#if MAXARG_S > MAX_INT
-#undef MAXARG_S
-#define MAXARG_S        MAX_INT
-#endif
-
-#if MAXARG_A > MAX_INT
-#undef MAXARG_A
-#define MAXARG_A        MAX_INT
-#endif
-
-#if MAXARG_B > MAX_INT
-#undef MAXARG_B
-#define MAXARG_B        MAX_INT
-#endif
-
-
-/* maximum stack size in a function */
-#define MAXSTACK	MAXARG_B
+/* maximum stack for a Lua function */
+#define MAXSTACK	250
 
 
 /* maximum number of local variables */
 #ifndef MAXLOCALS
 #define MAXLOCALS 200           /* arbitrary limit (<MAXSTACK) */
 #endif
-#if MAXLOCALS>=MAXSTACK
-#undef MAXLOCALS
-#define MAXLOCALS	(MAXSTACK-1)
-#endif
 
 
 /* maximum number of upvalues */
 #ifndef MAXUPVALUES
-#define MAXUPVALUES 32          /* arbitrary limit (<=MAXARG_B) */
-#endif
-#if MAXUPVALUES>MAXARG_B
-#undef MAXUPVALUES
-#define MAXUPVALUES	MAXARG_B
-#endif
-
-
-/* special code for multiple returns */
-#define MULT_RET        255	/* (<=MAXARG_B) */
-#if MULT_RET>MAXARG_B
-#undef MULT_RET
-#define MULT_RET	MAXARG_B
-#endif
-
-
-/* maximum number of variables in the left side of an assignment */
-#ifndef MAXVARSLH
-#define MAXVARSLH 100           /* arbitrary limit (<MULT_RET) */
-#endif
-#if MAXVARSLH>=MULT_RET
-#undef MAXVARSLH
-#define MAXVARSLH	(MULT_RET-1)
+#define MAXUPVALUES 32          /* arbitrary limit (<MAXSTACK) */
 #endif
 
 
@@ -149,45 +116,17 @@ typedef unsigned long Instruction;
 #ifndef MAXPARAMS
 #define MAXPARAMS 100           /* arbitrary limit (<MAXLOCALS) */
 #endif
-#if MAXPARAMS>=MAXLOCALS
-#undef MAXPARAMS
-#define MAXPARAMS	(MAXLOCALS-1)
-#endif
 
 
 /* number of list items to accumulate before a SETLIST instruction */
+/* (must be a power of 2) */
 #define LFIELDS_PER_FLUSH	64
-#if LFIELDS_PER_FLUSH>(MAXSTACK/4)
-#undef LFIELDS_PER_FLUSH
-#define LFIELDS_PER_FLUSH	(MAXSTACK/4)
-#endif
 
-/* number of record items to accumulate before a SETMAP instruction */
-/* (each item counts 2 elements on the stack: an index and a value) */
-#define RFIELDS_PER_FLUSH	(LFIELDS_PER_FLUSH/2)
-
-
-/* maximum number of values printed in one call to `print' */
-#ifndef MAXPRINT
-#define MAXPRINT        40	/* arbitrary limit */
-#endif
-
-
-/* maximum depth of nested $ifs */
-#ifndef MAX_IFS
-#define MAX_IFS 5  /* arbitrary limit */
-#endif
-
-
-/* maximum size of a pragma line */
-#ifndef PRAGMASIZE
-#define PRAGMASIZE      80  /* arbitrary limit */
-#endif
 
 
 /* maximum lookback to find a real constant (for code generation) */
 #ifndef LOOKBACKNUMS
-#define LOOKBACKNUMS    20      /* arbitrary constant */
+#define LOOKBACKNUMS    40      /* arbitrary constant */
 #endif
 
 

lmathlib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lmathlib.c,v 1.23 1999/12/27 17:33:22 roberto Exp roberto $
+** $Id: lmathlib.c,v 1.37 2001/03/06 20:09:38 roberto Exp roberto $
 ** Standard mathematical library
 ** See Copyright Notice in lua.h
 */
@@ -8,10 +8,10 @@
 #include <stdlib.h>
 #include <math.h>
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
 #include "lauxlib.h"
-#include "lua.h"
 #include "lualib.h"
 
 
@@ -34,175 +34,207 @@
 #endif
 
 
-static void math_abs (lua_State *L) {
+static int math_abs (lua_State *L) {
   lua_pushnumber(L, fabs(luaL_check_number(L, 1)));
+  return 1;
 }
 
-static void math_sin (lua_State *L) {
+static int math_sin (lua_State *L) {
   lua_pushnumber(L, sin(TORAD(luaL_check_number(L, 1))));
+  return 1;
 }
 
-static void math_cos (lua_State *L) {
+static int math_cos (lua_State *L) {
   lua_pushnumber(L, cos(TORAD(luaL_check_number(L, 1))));
+  return 1;
 }
 
-static void math_tan (lua_State *L) {
+static int math_tan (lua_State *L) {
   lua_pushnumber(L, tan(TORAD(luaL_check_number(L, 1))));
+  return 1;
 }
 
-static void math_asin (lua_State *L) {
+static int math_asin (lua_State *L) {
   lua_pushnumber(L, FROMRAD(asin(luaL_check_number(L, 1))));
+  return 1;
 }
 
-static void math_acos (lua_State *L) {
+static int math_acos (lua_State *L) {
   lua_pushnumber(L, FROMRAD(acos(luaL_check_number(L, 1))));
+  return 1;
 }
 
-static void math_atan (lua_State *L) {
+static int math_atan (lua_State *L) {
   lua_pushnumber(L, FROMRAD(atan(luaL_check_number(L, 1))));
+  return 1;
 }
 
-static void math_atan2 (lua_State *L) {
+static int math_atan2 (lua_State *L) {
   lua_pushnumber(L, FROMRAD(atan2(luaL_check_number(L, 1), luaL_check_number(L, 2))));
+  return 1;
 }
 
-static void math_ceil (lua_State *L) {
+static int math_ceil (lua_State *L) {
   lua_pushnumber(L, ceil(luaL_check_number(L, 1)));
+  return 1;
 }
 
-static void math_floor (lua_State *L) {
+static int math_floor (lua_State *L) {
   lua_pushnumber(L, floor(luaL_check_number(L, 1)));
+  return 1;
 }
 
-static void math_mod (lua_State *L) {
+static int math_mod (lua_State *L) {
   lua_pushnumber(L, fmod(luaL_check_number(L, 1), luaL_check_number(L, 2)));
+  return 1;
 }
 
-static void math_sqrt (lua_State *L) {
+static int math_sqrt (lua_State *L) {
   lua_pushnumber(L, sqrt(luaL_check_number(L, 1)));
+  return 1;
 }
 
-static void math_pow (lua_State *L) {
+static int math_pow (lua_State *L) {
   lua_pushnumber(L, pow(luaL_check_number(L, 1), luaL_check_number(L, 2)));
+  return 1;
 }
 
-static void math_log (lua_State *L) {
+static int math_log (lua_State *L) {
   lua_pushnumber(L, log(luaL_check_number(L, 1)));
+  return 1;
 }
 
-static void math_log10 (lua_State *L) {
+static int math_log10 (lua_State *L) {
   lua_pushnumber(L, log10(luaL_check_number(L, 1)));
+  return 1;
 }
 
-static void math_exp (lua_State *L) {
+static int math_exp (lua_State *L) {
   lua_pushnumber(L, exp(luaL_check_number(L, 1)));
+  return 1;
 }
 
-static void math_deg (lua_State *L) {
+static int math_deg (lua_State *L) {
   lua_pushnumber(L, luaL_check_number(L, 1)/RADIANS_PER_DEGREE);
+  return 1;
 }
 
-static void math_rad (lua_State *L) {
+static int math_rad (lua_State *L) {
   lua_pushnumber(L, luaL_check_number(L, 1)*RADIANS_PER_DEGREE);
+  return 1;
 }
 
-static void math_frexp (lua_State *L) {
+static int math_frexp (lua_State *L) {
   int e;
   lua_pushnumber(L, frexp(luaL_check_number(L, 1), &e));
   lua_pushnumber(L, e);
+  return 2;
 }
 
-static void math_ldexp (lua_State *L) {
+static int math_ldexp (lua_State *L) {
   lua_pushnumber(L, ldexp(luaL_check_number(L, 1), luaL_check_int(L, 2)));
+  return 1;
 }
 
 
 
-static void math_min (lua_State *L) {
-  int i = 1;
-  double dmin = luaL_check_number(L, i);
-  while (lua_getparam(L, ++i) != LUA_NOOBJECT) {
-    double d = luaL_check_number(L, i);
+static int math_min (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  lua_Number dmin = luaL_check_number(L, 1);
+  int i;
+  for (i=2; i<=n; i++) {
+    lua_Number d = luaL_check_number(L, i);
     if (d < dmin)
       dmin = d;
   }
   lua_pushnumber(L, dmin);
+  return 1;
 }
 
 
-static void math_max (lua_State *L) {
-  int i = 1;
-  double dmax = luaL_check_number(L, i);
-  while (lua_getparam(L, ++i) != LUA_NOOBJECT) {
-    double d = luaL_check_number(L, i);
+static int math_max (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  lua_Number dmax = luaL_check_number(L, 1);
+  int i;
+  for (i=2; i<=n; i++) {
+    lua_Number d = luaL_check_number(L, i);
     if (d > dmax)
       dmax = d;
   }
   lua_pushnumber(L, dmax);
+  return 1;
 }
 
 
-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 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);  /* Number between 0 and 1 */
-  else {
-    int l, u;  /* lower & upper limits */
-    if (lua_getparam(L, 2) == LUA_NOOBJECT) {  /* only one argument? */
-      l = 1;
-      u = luaL_check_int(L, 1);
+static int 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 larger than RAND_MAX */
+  lua_Number r = (lua_Number)(rand()%RAND_MAX) / (lua_Number)RAND_MAX;
+  switch (lua_gettop(L)) {  /* check number of arguments */
+    case 0: {  /* no arguments */
+      lua_pushnumber(L, r);  /* Number between 0 and 1 */
+      break;
     }
-    else {  /* two arguments */
-      l = luaL_check_int(L, 1);
-      u = luaL_check_int(L, 2);
+    case 1: {  /* only upper limit */
+      int u = luaL_check_int(L, 1);
+      luaL_arg_check(L, 1<=u, 1, l_s("interval is empty"));
+      lua_pushnumber(L, (int)(r*u)+1);  /* integer between 1 and `u' */
+      break;
     }
-    luaL_arg_check(L, l<=u, 1, "interval is empty");
-    lua_pushnumber(L, (int)(r*(u-l+1))+l);  /* integer between `l' and `u' */
+    case 2: {  /* lower and upper limits */
+      int l = luaL_check_int(L, 1);
+      int u = luaL_check_int(L, 2);
+      luaL_arg_check(L, l<=u, 2, l_s("interval is empty"));
+      lua_pushnumber(L, (int)(r*(u-l+1))+l);  /* integer between `l' and `u' */
+      break;
+    }
+    default: lua_error(L, l_s("wrong number of arguments"));
   }
+  return 1;
 }
 
 
-static void math_randomseed (lua_State *L) {
+static int math_randomseed (lua_State *L) {
   srand(luaL_check_int(L, 1));
+  return 0;
 }
 
 
-static const struct luaL_reg mathlib[] = {
-{"abs",   math_abs},
-{"sin",   math_sin},
-{"cos",   math_cos},
-{"tan",   math_tan},
-{"asin",  math_asin},
-{"acos",  math_acos},
-{"atan",  math_atan},
-{"atan2", math_atan2},
-{"ceil",  math_ceil},
-{"floor", math_floor},
-{"mod",   math_mod},
-{"frexp", math_frexp},
-{"ldexp", math_ldexp},
-{"sqrt",  math_sqrt},
-{"min",   math_min},
-{"max",   math_max},
-{"log",   math_log},
-{"log10", math_log10},
-{"exp",   math_exp},
-{"deg",   math_deg},
-{"rad",   math_rad},
-{"random",     math_random},
-{"randomseed", math_randomseed}
+static const luaL_reg mathlib[] = {
+{l_s("abs"),   math_abs},
+{l_s("sin"),   math_sin},
+{l_s("cos"),   math_cos},
+{l_s("tan"),   math_tan},
+{l_s("asin"),  math_asin},
+{l_s("acos"),  math_acos},
+{l_s("atan"),  math_atan},
+{l_s("atan2"), math_atan2},
+{l_s("ceil"),  math_ceil},
+{l_s("floor"), math_floor},
+{l_s("mod"),   math_mod},
+{l_s("frexp"), math_frexp},
+{l_s("ldexp"), math_ldexp},
+{l_s("sqrt"),  math_sqrt},
+{l_s("min"),   math_min},
+{l_s("max"),   math_max},
+{l_s("log"),   math_log},
+{l_s("log10"), math_log10},
+{l_s("exp"),   math_exp},
+{l_s("deg"),   math_deg},
+{l_s("rad"),   math_rad},
+{l_s("random"),     math_random},
+{l_s("randomseed"), math_randomseed}
 };
 
 /*
 ** Open math library
 */
-void lua_mathlibopen (lua_State *L) {
+LUALIB_API int lua_mathlibopen (lua_State *L) {
   luaL_openl(L, mathlib);
   lua_pushcfunction(L, math_pow);
-  lua_pushnumber(L, 0);  /* to get its tag */
-  lua_settagmethod(L, lua_tag(L, lua_pop(L)), "pow");
-  lua_pushnumber(L, PI); lua_setglobal(L, "PI");
+  lua_settagmethod(L, LUA_TNUMBER, l_s("pow"));
+  lua_pushnumber(L, PI);
+  lua_setglobal(L, l_s("PI"));
+  return 0;
 }
 

lmem.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lmem.c,v 1.28 2000/03/10 18:37:44 roberto Exp roberto $
+** $Id: lmem.c,v 1.48 2001/02/23 17:17:25 roberto Exp roberto $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
@@ -7,136 +7,62 @@
 
 #include <stdlib.h>
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
+#include "ldo.h"
 #include "lmem.h"
 #include "lobject.h"
 #include "lstate.h"
-#include "lua.h"
 
 
-/*
-** Number ANSI systems do not need these tests;
-** but some systems (Sun OS) are not that ANSI...
-*/
-#ifdef OLD_ANSI
-#define realloc(b,s)	((b) == NULL ? malloc(s) : (realloc)(b, s))
-#define free(b)		if (b) (free)(b)
+
+#ifndef l_realloc
+#define l_realloc(b,os,s)	realloc(b,s)
+#define l_free(b,s)		free(b)
 #endif
 
 
-
-#ifdef DEBUG
-/*
-** {======================================================================
-** Controlled version for realloc.
-** =======================================================================
-*/
-
-
-#include <assert.h>
-#include <string.h>
-
-
-#define realloc(b, s)	debug_realloc(b, s)
-#define malloc(b)	debug_realloc(NULL, 0)
-#define free(b)		debug_realloc(b, 0)
-
-
-/* ensures maximum alignment for HEADER */
-#define HEADER	(sizeof(double)>sizeof(long) ? sizeof(double) : sizeof(long))
-
-#define MARKSIZE	16
-#define MARK		0x55  /* 01010101 (a nice pattern) */
-
-
-#define blocksize(b)	((unsigned long *)((char *)(b) - HEADER))
-
-unsigned long memdebug_numblocks = 0;
-unsigned long memdebug_total = 0;
-unsigned long memdebug_maxmem = 0;
-
-
-static void *checkblock (void *block) {
-  unsigned long *b = blocksize(block);
-  unsigned long size = *b;
-  int i;
-  for (i=0;i<MARKSIZE;i++)
-    assert(*(((char *)b)+HEADER+size+i) == MARK+i);  /* corrupted block? */
-  memdebug_numblocks--;
-  memdebug_total -= size;
-  return b;
-}
-
-
-static void freeblock (void *block) {
-  if (block) {
-    size_t size = *blocksize(block);
-    block = checkblock(block);
-    memset(block, -1, size+HEADER+MARKSIZE);  /* erase block */
-    (free)(block);  /* free original block */
+void *luaM_growaux (lua_State *L, void *block, int *size, int size_elems,
+                    int limit, const l_char *errormsg) {
+  void *newblock;
+  int newsize = (*size)*2;
+  if (newsize < MINPOWER2)
+    newsize = MINPOWER2;  /* minimum size */
+  else if (*size >= limit/2) {  /* cannot double it? */
+    if (*size < limit - MINPOWER2)  /* try something smaller... */
+      newsize = limit;  /* still have at least MINPOWER2 free places */
+    else luaD_error(L, errormsg);
   }
-}
-
-
-static void *debug_realloc (void *block, size_t size) {
-  if (size == 0) {
-    freeblock(block);
-    return NULL;
-  }
-  else {
-    size_t realsize = HEADER+size+MARKSIZE;
-    char *newblock = (char *)(malloc)(realsize);  /* alloc a new block */
-    int i;
-    if (newblock == NULL) return NULL;
-    if (block) {
-      size_t oldsize = *blocksize(block);
-      if (oldsize > size) oldsize = size;
-      memcpy(newblock+HEADER, block, oldsize);
-      freeblock(block);  /* erase (and check) old copy */
-    }
-    memdebug_total += size;
-    if (memdebug_total > memdebug_maxmem) memdebug_maxmem = memdebug_total;
-    memdebug_numblocks++;
-    *(unsigned long *)newblock = size;
-    for (i=0;i<MARKSIZE;i++)
-      *(newblock+HEADER+size+i) = (char)(MARK+i);
-    return newblock+HEADER;
-  }
-}
-
-
-/* }====================================================================== */
-#endif
-
-
-
-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? */
-       (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 */
-    return luaM_realloc(L, block, luaO_power2(newn)*size);
+  newblock = luaM_realloc(L, block, (lu_mem)(*size)*(lu_mem)size_elems,
+                                    (lu_mem)newsize*(lu_mem)size_elems);
+  *size = newsize;  /* update only when everything else is OK */
+  return newblock;
 }
 
 
 /*
 ** generic allocation routine.
 */
-void *luaM_realloc (lua_State *L, void *block, unsigned long size) {
+void *luaM_realloc (lua_State *L, void *block, lu_mem oldsize, lu_mem size) {
   if (size == 0) {
-    free(block);  /* block may be NULL; that is OK for free */
-    return NULL;
+    l_free(block, oldsize);  /* block may be NULL; that is OK for free */
+    block = NULL;
+  }
+  else if (size >= MAX_SIZET)
+    luaD_error(L, l_s("memory allocation error: block too big"));
+  else {
+    block = l_realloc(block, oldsize, size);
+    if (block == NULL) {
+      if (L)
+        luaD_breakrun(L, LUA_ERRMEM);  /* break run without error message */
+      else return NULL;  /* error before creating state! */
+    }
+  }
+  if (L && G(L)) {
+    G(L)->nblocks -= oldsize;
+    G(L)->nblocks += size;
   }
-  else if ((size_t)size != size)
-    lua_error(L, "memory allocation error: block too big");
-  block = realloc(block, size);
-  if (block == NULL)
-    lua_error(L, memEM);
   return block;
 }
 
-

lmem.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lmem.h,v 1.12 2000/01/13 16:30:47 roberto Exp roberto $
+** $Id: lmem.h,v 1.21 2001/02/20 18:15:33 roberto Exp roberto $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
@@ -8,36 +8,33 @@
 #define lmem_h
 
 
-#include <stdlib.h>
+#include <stddef.h>
 
+#include "llimits.h"
 #include "lua.h"
 
-/* memory error messages */
-#define codeEM   "code size overflow"
-#define constantEM   "constant table overflow"
-#define refEM   "reference table overflow"
-#define tableEM  "table overflow"
-#define memEM "not enough memory"
-#define arrEM	"internal array larger than `int' limit"
+void *luaM_realloc (lua_State *L, void *oldblock, lu_mem oldsize, lu_mem size);
 
-void *luaM_realloc (lua_State *L, void *oldblock, unsigned long size);
-void *luaM_growaux (lua_State *L, void *block, unsigned long nelems, int inc, int size,
-                       const char *errormsg, unsigned long limit);
+void *luaM_growaux (lua_State *L, void *block, int *size, int size_elem,
+                    int limit, const l_char *errormsg);
 
-#define luaM_free(L, b)	luaM_realloc(L, (b), 0)
-#define luaM_malloc(L, t)	luaM_realloc(L, NULL, (t))
+#define luaM_free(L, b, s)	luaM_realloc(L, (b), (s), 0)
+#define luaM_freelem(L, b, t)	luaM_realloc(L, (b), sizeof(t), 0)
+#define luaM_freearray(L, b, n, t)	luaM_realloc(L, (b), \
+                                          ((lu_mem)(n)*(lu_mem)sizeof(t)), 0)
+
+#define luaM_malloc(L, t)	luaM_realloc(L, NULL, 0, (t))
 #define luaM_new(L, t)          ((t *)luaM_malloc(L, sizeof(t)))
-#define luaM_newvector(L, n,t)  ((t *)luaM_malloc(L, (n)*sizeof(t)))
-#define luaM_growvector(L, v,nelems,inc,t,e,l) \
-          ((v)=(t *)luaM_growaux(L, v,nelems,inc,sizeof(t),e,l))
-#define luaM_reallocvector(L, v,n,t) ((v)=(t *)luaM_realloc(L, v,(n)*sizeof(t)))
+#define luaM_newvector(L, n,t)  ((t *)luaM_malloc(L, \
+                                         (lu_mem)(n)*(lu_mem)sizeof(t)))
 
+#define luaM_growvector(L,v,nelems,size,t,limit,e) \
+          if (((nelems)+1) > (size)) \
+            ((v)=(t *)luaM_growaux(L,v,&(size),sizeof(t),limit,e))
 
-#ifdef DEBUG
-extern unsigned long memdebug_numblocks;
-extern unsigned long memdebug_total;
-extern unsigned long memdebug_maxmem;
-#endif
+#define luaM_reallocvector(L, v,oldn,n,t) \
+	((v)=(t *)luaM_realloc(L, v,(lu_mem)(oldn)*(lu_mem)sizeof(t), \
+                                    (lu_mem)(n)*(lu_mem)sizeof(t)))
 
 
 #endif

lobject.c

@@ -1,110 +1,105 @@
 /*
-** $Id: lobject.c,v 1.35 2000/03/29 20:19:20 roberto Exp roberto $
+** $Id: lobject.c,v 1.69 2001/03/07 12:27:06 roberto Exp roberto $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
 
 #include <ctype.h>
+#include <stdarg.h>
+#include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
-#define LUA_REENTRANT
-
-#include "lobject.h"
+#define LUA_PRIVATE
 #include "lua.h"
 
-
-const char *const luaO_typenames[] = { /* ORDER LUA_T */
-    "userdata", "number", "string", "table", "function", "function", "nil",
-    "function", "function", "line"
-};
+#include "ldo.h"
+#include "lmem.h"
+#include "lobject.h"
+#include "lstate.h"
 
 
-const TObject luaO_nilobject = {TAG_NIL, {NULL}};
+
+const TObject luaO_nilobject = {LUA_TNIL, {NULL}};
 
 
-/*
-** returns smaller power of 2 larger than `n' (minimum is MINPOWER2) 
-*/
-unsigned long luaO_power2 (unsigned long n) {
-  unsigned long p = MINPOWER2;
-  while (p<=n) p<<=1;
-  return p;
-}
-
-
-int luaO_equalval (const TObject *t1, const TObject *t2) {
+int luaO_equalObj (const TObject *t1, const TObject *t2) {
+  if (ttype(t1) != ttype(t2)) return 0;
   switch (ttype(t1)) {
-    case TAG_NUMBER:
+    case LUA_TNUMBER:
       return nvalue(t1) == nvalue(t2);
-    case TAG_STRING: case TAG_USERDATA:
-      return svalue(t1) == svalue(t2);
-    case TAG_TABLE: 
-      return avalue(t1) == avalue(t2);
-    case TAG_CCLOSURE: case TAG_LCLOSURE:
-      return clvalue(t1) == clvalue(t2);
-    default:
-      LUA_ASSERT(L, ttype(t1) == TAG_NIL, "invalid type");
-      return 1; /* TAG_NIL */
+    case LUA_TNIL:
+      return 1;
+    default:  /* all other types are equal if pointers are equal */
+      return tsvalue(t1) == tsvalue(t2);
   }
 }
 
 
-static double expten (unsigned int e) {
-  double exp = 10.0;
-  double res = 1.0;
-  for (; e; e>>=1) {
-    if (e & 1) res *= exp;
-    exp *= exp;
+void *luaO_openspaceaux (lua_State *L, size_t n) {
+  if (n > G(L)->Mbuffsize) {
+    G(L)->Mbuffer = luaM_realloc(L, G(L)->Mbuffer, G(L)->Mbuffsize, n);
+    G(L)->Mbuffsize = n;
   }
-  return res;
+  return G(L)->Mbuffer;
 }
 
 
-int luaO_str2d (const char *s, Number *result) {  /* LUA_NUMBER */
-  double a = 0.0;
-  int point = 0;  /* number of decimal digits */
-  int sig;
-  while (isspace((unsigned char)*s)) s++;
-  sig = 0;
-  switch (*s) {
-    case '-': sig = 1;  /* go through */
-    case '+': s++;
-  }
-  if (! (isdigit((unsigned char)*s) ||
-          (*s == '.' && isdigit((unsigned char)*(s+1)))))
-    return 0;  /* not (at least one digit before or after the point) */
-  while (isdigit((unsigned char)*s))
-    a = 10.0*a + (*(s++)-'0');
-  if (*s == '.') {
-    s++;
-    while (isdigit((unsigned char)*s)) {
-      a = 10.0*a + (*(s++)-'0');
-      point++;
-    }
-  }
-  if (sig) a = -a;
-  if (*s == 'e' || *s == 'E') {
-    int e = 0;
-    s++;
-    sig = 0;
-    switch (*s) {
-      case '-': sig = 1;  /* go through */
-      case '+': s++;
-    }
-    if (!isdigit((unsigned char)*s)) return 0;  /* no digit in the exponent? */
-    do {
-      e = 10*e + (*(s++)-'0');
-    } while (isdigit((unsigned char)*s));
-    if (sig) e = -e;
-    point -= e;
-  }
-  while (isspace((unsigned char)*s)) s++;
-  if (*s != '\0') return 0;  /* invalid trailing characters? */
-  if (point != 0) {
-    if (point > 0) a /= expten(point);
-    else           a *= expten(-point);
-  }
-  *result = a;
+int luaO_str2d (const l_char *s, lua_Number *result) {
+  l_char *endptr;
+  lua_Number res = lua_str2number(s, &endptr);
+  if (endptr == s) return 0;  /* no conversion */
+  while (isspace(uchar(*endptr))) endptr++;
+  if (*endptr != l_c('\0')) return 0;  /* invalid trailing characters? */
+  *result = res;
   return 1;
 }
 
+
+/* maximum length of a string format for `luaO_verror' */
+#define MAX_VERROR	280
+
+/* this function needs to handle only '%d' and '%.XXs' formats */
+void luaO_verror (lua_State *L, const l_char *fmt, ...) {
+  va_list argp;
+  l_char buff[MAX_VERROR];  /* to hold formatted message */
+  va_start(argp, fmt);
+  vsprintf(buff, fmt, argp);
+  va_end(argp);
+  luaD_error(L, buff);
+}
+
+
+void luaO_chunkid (l_char *out, const l_char *source, int bufflen) {
+  if (*source == l_c('=')) {
+    strncpy(out, source+1, bufflen);  /* remove first char */
+    out[bufflen-1] = l_c('\0');  /* ensures null termination */
+  }
+  else {
+    if (*source == l_c('@')) {
+      int l;
+      source++;  /* skip the `@' */
+      bufflen -= sizeof(l_s("file `...%s'"));
+      l = strlen(source);
+      if (l>bufflen) {
+        source += (l-bufflen);  /* get last part of file name */
+        sprintf(out, l_s("file `...%.99s'"), source);
+      }
+      else
+        sprintf(out, l_s("file `%.99s'"), source);
+    }
+    else {
+      int len = strcspn(source, l_s("\n"));  /* stop at first newline */
+      bufflen -= sizeof(l_s("string \"%.*s...\""));
+      if (len > bufflen) len = bufflen;
+      if (source[len] != l_c('\0')) {  /* must truncate? */
+        strcpy(out, l_s("string \""));
+        out += strlen(out);
+        strncpy(out, source, len);
+        strcpy(out+len, l_s("...\""));
+      }
+      else
+        sprintf(out, l_s("string \"%.99s\""), source);
+    }
+  }
+}

lobject.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.h,v 1.59 2000/03/31 16:28:45 roberto Exp roberto $
+** $Id: lobject.h,v 1.108 2001/06/28 14:48:44 roberto Exp roberto $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -12,133 +12,142 @@
 #include "lua.h"
 
 
-#ifdef DEBUG
-#undef NDEBUG
-#include <assert.h>
-#define LUA_INTERNALERROR(L,s)	assert(((void)s,0))
-#define LUA_ASSERT(L,c,s)	assert(((void)s,(c)))
-#else
-#define LUA_INTERNALERROR(L,s)	/* empty */
-#define LUA_ASSERT(L,c,s)	/* empty */
+#ifndef lua_assert
+#define lua_assert(c)		/* empty */
 #endif
 
 
-#ifdef DEBUG
-/* to avoid warnings, and make sure value is really unused */
-#define UNUSED(x)	(x=0, (void)(x))
-#else
+#ifndef UNUSED
 #define UNUSED(x)	((void)(x))	/* to avoid warnings */
 #endif
 
 
-/*
-** Lua TYPES
-** WARNING: if you change the order of this enumeration,
-** grep "ORDER LUA_T"
-*/
-typedef enum {
-  TAG_USERDATA  =  0, /* default tag for userdata */
-  TAG_NUMBER,	/* fixed tag for numbers */
-  TAG_STRING,	/* fixed tag for strings */
-  TAG_TABLE,	/* default tag for tables */
-  TAG_LCLOSURE,	/* fixed tag for Lua closures */
-  TAG_CCLOSURE,	/* fixed tag for C closures */
-  TAG_NIL,	/* last "pre-defined" tag */
-
-  TAG_LMARK,	/* mark for Lua closures */
-  TAG_CMARK,	/* mark for C closures */
-
-  TAG_LINE
-} lua_Type;
 
 /* tags for values visible from Lua == first user-created tag */
-#define NUM_TAGS	7
-
-
-/*
-** check whether `t' is a mark
-*/
-#define is_T_MARK(t)	((t) == TAG_LMARK || (t) == TAG_CMARK)
+#define NUM_TAGS	6
 
 
 typedef union {
-  struct TString *ts;	/* TAG_STRING, TAG_USERDATA */
-  struct Closure *cl;	/* TAG_[CL]CLOSURE, TAG_[CL]MARK */
-  struct Hash *a;	/* TAG_TABLE */
-  Number n;		/* TAG_NUMBER */
-  int i;		/* TAG_LINE */
+  union TString *ts;
+  union Udata *u;
+  struct Closure *cl;
+  struct Hash *h;
+  lua_Number n;		/* LUA_TNUMBER */
 } Value;
 
 
-/* Macros to access values */
-#define ttype(o)        ((o)->ttype)
-#define nvalue(o)       ((o)->value.n)
-#define svalue(o)       ((o)->value.ts->str)
-#define tsvalue(o)      ((o)->value.ts)
-#define clvalue(o)      ((o)->value.cl)
-#define avalue(o)       ((o)->value.a)
-
-
-typedef struct TObject {
-  lua_Type ttype;
+typedef struct lua_TObject {
+  int tt;
   Value value;
 } TObject;
 
 
-typedef struct GlobalVar {
-  TObject value;
-  struct GlobalVar *next;
-  struct TString *name;
-} GlobalVar;
+/* Macros to access values */
+#define ttype(o)        ((o)->tt)
+#define nvalue(o)       ((o)->value.n)
+#define tsvalue(o)      ((o)->value.ts)
+#define uvalue(o)      ((o)->value.u)
+#define clvalue(o)      ((o)->value.cl)
+#define hvalue(o)       ((o)->value.h)
+
+
+/* Macros to set values */
+#define setnvalue(obj,x) \
+  { TObject *_o=(obj); _o->tt=LUA_TNUMBER; _o->value.n=(x); }
+
+#define chgnvalue(obj,x)	((obj)->value.n=(x))
+
+#define setsvalue(obj,x) \
+  { TObject *_o=(obj); _o->tt=LUA_TSTRING; _o->value.ts=(x); }
+
+#define setuvalue(obj,x) \
+  { TObject *_o=(obj); _o->tt=LUA_TUSERDATA; _o->value.u=(x); }
+
+#define setclvalue(obj,x) \
+  { TObject *_o=(obj); _o->tt=LUA_TFUNCTION; _o->value.cl=(x); }
+
+#define sethvalue(obj,x) \
+  { TObject *_o=(obj); _o->tt=LUA_TTABLE; _o->value.h=(x); }
+
+#define setnilvalue(obj) ((obj)->tt=LUA_TNIL)
+
+#define setobj(obj1,obj2) \
+  { TObject *o1=(obj1); const TObject *o2=(obj2); \
+    o1->tt=o2->tt; o1->value = o2->value; }
+
+#define setttype(obj, tt) (ttype(obj) = (tt))
+
+
+
+typedef TObject *StkId;  /* index to stack elements */
 
 
 /*
 ** String headers for string table
 */
-typedef struct TString {
-  union {
-    struct {  /* for strings */
-      GlobalVar *gv;  /* eventual global value with this name */
-      long len;
-    } s;
-    struct {  /* for userdata */
-      int tag;
-      void *value;
-    } d;
-  } u;
-  struct TString *nexthash;  /* chain for hash table */
-  unsigned long hash;
-  int constindex;  /* hint to reuse constants (= -1 if this is a userdata) */
-  unsigned char marked;
-  char str[1];   /* variable length string!! must be the last field! */
+typedef union TString {
+  union L_Umaxalign dummy;  /* ensures maximum alignment for strings */
+  struct {
+    lu_hash hash;
+    size_t len;
+    unsigned short constindex;  /* hint to reuse constants */
+    short marked;
+    union TString *nexthash;  /* chain for hash table */
+  } tsv;
 } TString;
 
 
+#define getstr(ts)	((l_char *)((ts) + 1))
+#define svalue(o)       getstr(tsvalue(o))
+
+
+
+typedef union Udata {
+  union L_Umaxalign dummy;  /* ensures maximum alignment for `local' udata */
+  struct {
+    int tag;  /* negative means `marked' (only during GC) */
+    void *value;
+    size_t len;
+    union Udata *next;  /* chain for list of all udata */
+  } uv;
+} Udata;
+
+
+#define switchudatamark(u)	((u)->uv.tag = (-((u)->uv.tag+1)))
+#define ismarkedudata(u)	((u)->uv.tag < 0)
+
+
+
 /*
 ** Function Prototypes
 */
 typedef struct Proto {
+  TObject *k;  /* constants used by the function */
+  int sizek;  /* size of `k' */
+  struct Proto **p;  /* functions defined inside the function */
+  int sizep;  /* size of `p' */
+  Instruction *code;
+  int sizecode;
+  short nupvalues;
+  short numparams;
+  short is_vararg;
+  short maxstacksize;
+  short marked;
   struct Proto *next;
-  int marked;
-  struct TString **kstr;  /* strings used by the function */
-  int nkstr;  /* size of `kstr' */
-  Number *knum;  /* Number numbers used by the function */
-  int nknum;  /* size of `knum' */
-  struct Proto **kproto;  /* functions defined inside the function */
-  int nkproto;  /* size of `kproto' */
-  Instruction *code;  /* ends with opcode ENDCODE */
+  /* debug information */
+  int *lineinfo;  /* map from opcodes to source lines */
+  int sizelineinfo;  /* size of `lineinfo' */
+  struct LocVar *locvars;  /* information about local variables */
+  int sizelocvars;
   int lineDefined;
   TString  *source;
-  int numparams;
-  int is_vararg;
-  int maxstacksize;
-  struct LocVar *locvars;  /* ends with line = -1 */
 } Proto;
 
 
 typedef struct LocVar {
-  TString *varname;           /* NULL signals end of scope */
-  int line;
+  TString *varname;
+  int startpc;  /* first point where variable is active */
+  int endpc;    /* first point where variable is dead */
 } LocVar;
 
 
@@ -146,44 +155,77 @@ typedef struct LocVar {
 ** Closures
 */
 typedef struct Closure {
-  struct Closure *next;
-  int marked;
+  int isC;  /* 0 for Lua functions, 1 for C functions */
+  int nupvalues;
   union {
     lua_CFunction c;  /* C functions */
     struct Proto *l;  /* Lua functions */
   } f;
-  int nelems;
-  TObject consts[1];
+  struct Closure *next;
+  struct Closure *mark;  /* marked closures (point to itself when not marked) */
+  TObject upvalue[1];
 } Closure;
 
 
+#define iscfunction(o)	(ttype(o) == LUA_TFUNCTION && clvalue(o)->isC)
+
+
 typedef struct Node {
+  struct Node *next;  /* for chaining */
   TObject key;
   TObject val;
-  struct Node *next;  /* for chaining */
 } Node;
 
+
 typedef struct Hash {
-  int htag;
   Node *node;
+  int htag;
   int size;
   Node *firstfree;  /* this position is free; all positions after it are full */
   struct Hash *next;
-  int marked;
+  struct Hash *mark;  /* marked tables (point to itself when not marked) */
+  int weakmode;
 } Hash;
 
 
-extern const char *const luaO_typenames[];
+/* unmarked tables and closures are represented by pointing `mark' to
+** themselves
+*/
+#define ismarked(x)	((x)->mark != (x))
+
+
+/*
+** `module' operation for hashing (size is always a power of 2)
+*/
+#define lmod(s,size)	((int)((s) & ((size)-1)))
+
+
+/*
+** informations about a call (for debugging)
+*/
+typedef struct CallInfo {
+  struct CallInfo *prev;  /* linked list */
+  StkId base;  /* base for called function */
+  const Instruction **pc;  /* current pc of called function */
+  int lastpc;  /* last pc traced */
+  int line;  /* current line */
+  int refi;  /* current index in `lineinfo' */
+} CallInfo;
+
+#define ci_func(ci)	(clvalue((ci)->base - 1))
+
+
 extern const TObject luaO_nilobject;
 
-#define luaO_typename(o)        luaO_typenames[ttype(o)]
 
-unsigned long luaO_power2 (unsigned long n);
+#define luaO_openspace(L,n,t)	((t *)luaO_openspaceaux(L,(n)*sizeof(t)))
+void *luaO_openspaceaux (lua_State *L, size_t n);
 
-#define luaO_equalObj(t1,t2)  (ttype(t1) == ttype(t2) && luaO_equalval(t1,t2))
-int luaO_equalval (const TObject *t1, const TObject *t2);
-int luaO_redimension (lua_State *L, int oldsize);
-int luaO_str2d (const char *s, Number *result);
+int luaO_equalObj (const TObject *t1, const TObject *t2);
+int luaO_str2d (const l_char *s, lua_Number *result);
+
+void luaO_verror (lua_State *L, const l_char *fmt, ...);
+void luaO_chunkid (l_char *out, const l_char *source, int len);
 
 
 #endif

lopcodes.c

@@ -0,0 +1,107 @@
+/*
+** $Id:$
+** extracted automatically from lopcodes.h by mkprint.lua
+** DO NOT EDIT
+** See Copyright Notice in lua.h
+*/
+
+
+#define LUA_PRIVATE
+#include "lua.h"
+
+#include "lopcodes.h"
+
+
+#ifdef LUA_OPNAMES
+
+const l_char *const luaP_opnames[] = {
+  l_s("MOVE"),
+  l_s("LOADK"),
+  l_s("LOADINT"),
+  l_s("LOADNIL"),
+  l_s("LOADUPVAL"),
+  l_s("GETGLOBAL"),
+  l_s("GETTABLE"),
+  l_s("SETGLOBAL"),
+  l_s("SETTABLE"),
+  l_s("NEWTABLE"),
+  l_s("SELF"),
+  l_s("ADD"),
+  l_s("SUB"),
+  l_s("MUL"),
+  l_s("DIV"),
+  l_s("POW"),
+  l_s("UNM"),
+  l_s("NOT"),
+  l_s("CONCAT"),
+  l_s("JMP"),
+  l_s("CJMP"),
+  l_s("TESTEQ"),
+  l_s("TESTNE"),
+  l_s("TESTLT"),
+  l_s("TESTLE"),
+  l_s("TESTGT"),
+  l_s("TESTGE"),
+  l_s("TESTT"),
+  l_s("TESTF"),
+  l_s("NILJMP"),
+  l_s("CALL"),
+  l_s("RETURN"),
+  l_s("FORPREP"),
+  l_s("FORLOOP"),
+  l_s("TFORPREP"),
+  l_s("TFORLOOP"),
+  l_s("SETLIST"),
+  l_s("SETLISTO"),
+  l_s("CLOSURE")
+};
+
+#endif
+
+#define opmode(t,x,b,c,sa,k,m) (((t)<<OpModeT) | \
+   ((b)<<OpModeBreg) | ((c)<<OpModeCreg) | \
+   ((sa)<<OpModesetA) | ((k)<<OpModeK) | (m))
+
+const lu_byte luaP_opmodes[] = {
+/*       T _ B C sA K mode		   opcode    */
+  opmode(0,0,1,0, 1,0,iABC)		/* OP_MOVE */
+ ,opmode(0,0,0,0, 1,1,iABc)		/* OP_LOADK */
+ ,opmode(0,0,0,0, 1,0,iAsBc)		/* OP_LOADINT */
+ ,opmode(0,0,1,0, 1,0,iABC)		/* OP_LOADNIL */
+ ,opmode(0,0,0,0, 1,0,iABc)		/* OP_LOADUPVAL */
+ ,opmode(0,0,0,0, 1,1,iABc)		/* OP_GETGLOBAL */
+ ,opmode(0,0,1,1, 1,0,iABC)		/* OP_GETTABLE */
+ ,opmode(0,0,0,0, 0,1,iABc)		/* OP_SETGLOBAL */
+ ,opmode(0,0,1,1, 0,0,iABC)		/* OP_SETTABLE */
+ ,opmode(0,0,0,0, 1,0,iABc)		/* OP_NEWTABLE */
+ ,opmode(0,0,1,1, 1,0,iABC)		/* OP_SELF */
+ ,opmode(0,0,1,1, 1,0,iABC)		/* OP_ADD */
+ ,opmode(0,0,1,1, 1,0,iABC)		/* OP_SUB */
+ ,opmode(0,0,1,1, 1,0,iABC)		/* OP_MUL */
+ ,opmode(0,0,1,1, 1,0,iABC)		/* OP_DIV */
+ ,opmode(0,0,1,1, 1,0,iABC)		/* OP_POW */
+ ,opmode(0,0,1,0, 1,0,iABC)		/* OP_UNM */
+ ,opmode(0,0,1,0, 1,0,iABC)		/* OP_NOT */
+ ,opmode(0,0,1,1, 1,0,iABC)		/* OP_CONCAT */
+ ,opmode(0,0,0,0, 0,0,iAsBc)		/* OP_JMP */
+ ,opmode(0,0,0,0, 0,0,iAsBc)		/* OP_CJMP */
+ ,opmode(1,0,0,1, 0,0,iABC)		/* OP_TESTEQ */
+ ,opmode(1,0,0,1, 0,0,iABC)		/* OP_TESTNE */
+ ,opmode(1,0,0,1, 0,0,iABC)		/* OP_TESTLT */
+ ,opmode(1,0,0,1, 0,0,iABC)		/* OP_TESTLE */
+ ,opmode(1,0,0,1, 0,0,iABC)		/* OP_TESTGT */
+ ,opmode(1,0,0,1, 0,0,iABC)		/* OP_TESTGE */
+ ,opmode(1,0,1,0, 1,0,iABC)		/* OP_TESTT */
+ ,opmode(1,0,1,0, 1,0,iABC)		/* OP_TESTF */
+ ,opmode(0,0,0,0, 1,0,iABc)		/* OP_NILJMP */
+ ,opmode(0,0,0,0, 0,0,iABC)		/* OP_CALL */
+ ,opmode(0,0,0,0, 0,0,iABC)		/* OP_RETURN */
+ ,opmode(0,0,0,0, 0,0,iAsBc)		/* OP_FORPREP */
+ ,opmode(0,0,0,0, 0,0,iAsBc)		/* OP_FORLOOP */
+ ,opmode(0,0,0,0, 0,0,iAsBc)		/* OP_TFORPREP */
+ ,opmode(0,0,0,0, 0,0,iAsBc)		/* OP_TFORLOOP */
+ ,opmode(0,0,0,0, 0,0,iABc)		/* OP_SETLIST */
+ ,opmode(0,0,0,0, 0,0,iABc)		/* OP_SETLISTO */
+ ,opmode(0,0,0,0, 1,0,iABc)		/* OP_CLOSURE */
+};
+

lopcodes.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.h,v 1.58 2000/04/13 16:51:01 roberto Exp roberto $
+** $Id: lopcodes.h,v 1.77 2001/07/03 17:01:34 roberto Exp roberto $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -12,29 +12,58 @@
 
 /*===========================================================================
   We assume that instructions are unsigned numbers.
-  All instructions have an opcode in the first 6 bits. Moreover,
-  an instruction can have 0, 1, or 2 arguments. Instructions can
-  have the following types:
-  type 0: no arguments
-  type 1: 1 unsigned argument in the higher bits (called `U')
-  type 2: 1 signed argument in the higher bits          (`S')
-  type 3: 1st unsigned argument in the higher bits      (`A')
-          2nd unsigned argument in the middle bits      (`B')
+  All instructions have an opcode in the first 6 bits.
+  Instructions can have the following fields:
+	`A' : 8 bits (25-32)
+	`B' : 8 bits (17-24)
+	`C' : 10 bits (7-16)
+	`Bc' : 18 bits (`B' and `C' together)
+	`sBc' : signed Bc
 
   A signed argument is represented in excess K; that is, the number
   value is the unsigned value minus K. K is exactly the maximum value
   for that argument (so that -max is represented by 0, and +max is
   represented by 2*max), which is half the maximum for the corresponding
   unsigned argument.
-
-  The size of each argument is defined in `llimits.h'. The usual is an
-  instruction with 32 bits, U arguments with 26 bits (32-6), B arguments
-  with 9 bits, and A arguments with 17 bits (32-6-9). For small
-  instalations, the instruction size can be 16, so U has 10 bits,
-  and A and B have 5 bits each.
 ===========================================================================*/
 
 
+enum OpMode {iABC, iABc, iAsBc};  /* basic instruction format */
+
+
+/*
+** size and position of opcode arguments.
+*/
+#define SIZE_C		10
+#define SIZE_B		8
+#define SIZE_Bc		(SIZE_C + SIZE_B)
+#define SIZE_A		8
+
+#define SIZE_OP		6
+
+#define POS_C		SIZE_OP
+#define POS_B		(POS_C + SIZE_C)
+#define POS_Bc		POS_C
+#define POS_A		(POS_B + SIZE_B)
+
+
+/*
+** limits for opcode arguments.
+** we use (signed) int to manipulate most arguments,
+** so they must fit in BITS_INT-1 bits (-1 for sign)
+*/
+#if SIZE_Bc < BITS_INT-1
+#define MAXARG_Bc        ((1<<SIZE_Bc)-1)
+#define MAXARG_sBc        (MAXARG_Bc>>1)         /* `sBc' is signed */
+#else
+#define MAXARG_Bc        MAX_INT
+#define MAXARG_sBc        MAX_INT
+#endif
+
+
+#define MAXARG_A        ((1<<SIZE_A)-1)
+#define MAXARG_B        ((1<<SIZE_B)-1)
+#define MAXARG_C        ((1<<SIZE_C)-1)
 
 
 /* creates a mask with `n' 1 bits at position `p' */
@@ -47,111 +76,153 @@
 ** the following macros help to manipulate instructions
 */
 
-#define CREATE_0(o)	 ((Instruction)(o))
 #define GET_OPCODE(i)	((OpCode)((i)&MASK1(SIZE_OP,0)))
-#define SET_OPCODE(i,o)	((i) = (((i)&MASK0(SIZE_OP,0)) | (Instruction)(o)))
+#define SET_OPCODE(i,o)	(((i)&MASK0(SIZE_OP,0)) | (Instruction)(o))
 
-#define CREATE_U(o,u)	 ((Instruction)(o) | (Instruction)(u)<<POS_U)
-#define GETARG_U(i)	((int)((i)>>POS_U))
-#define SETARG_U(i,u)	((i) = (((i)&MASK0(SIZE_U,POS_U)) | \
-                               ((Instruction)(u)<<POS_U)))
-
-#define CREATE_S(o,s)	CREATE_U((o),(s)+MAXARG_S)
-#define GETARG_S(i)	(GETARG_U(i)-MAXARG_S)
-#define SETARG_S(i,s)	SETARG_U((i),(s)+MAXARG_S)
-
-
-#define CREATE_AB(o,a,b) ((Instruction)(o) | ((Instruction)(a)<<POS_A) \
-                                           |  ((Instruction)(b)<<POS_B))
 #define GETARG_A(i)	((int)((i)>>POS_A))
-#define SETARG_A(i,a)	((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
-                               ((Instruction)(a)<<POS_A)))
+#define SETARG_A(i,u)	((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
+                               ((Instruction)(u)<<POS_A)))
+
 #define GETARG_B(i)	((int)(((i)>>POS_B) & MASK1(SIZE_B,0)))
 #define SETARG_B(i,b)	((i) = (((i)&MASK0(SIZE_B,POS_B)) | \
                                ((Instruction)(b)<<POS_B)))
 
+#define GETARG_C(i)	((int)(((i)>>POS_C) & MASK1(SIZE_C,0)))
+#define SETARG_C(i,b)	((i) = (((i)&MASK0(SIZE_C,POS_C)) | \
+                               ((Instruction)(b)<<POS_C)))
+
+#define GETARG_Bc(i)	((int)(((i)>>POS_Bc) & MASK1(SIZE_Bc,0)))
+#define SETARG_Bc(i,b)	((i) = (((i)&MASK0(SIZE_Bc,POS_Bc)) | \
+                               ((Instruction)(b)<<POS_Bc)))
+
+#define GETARG_sBc(i)	(GETARG_Bc(i)-MAXARG_sBc)
+#define SETARG_sBc(i,b)	SETARG_Bc((i),(unsigned int)((b)+MAXARG_sBc))
+
+
+#define CREATE_ABC(o,a,b,c)	((Instruction)(o) \
+			| ((Instruction)(a)<<POS_A) \
+			| ((Instruction)(b)<<POS_B) \
+			| ((Instruction)(c)<<POS_C))
+
+#define CREATE_ABc(o,a,bc)	((Instruction)(o) \
+			| ((Instruction)(a)<<POS_A) \
+			| ((Instruction)(bc)<<POS_Bc))
+
+
+
 
 /*
-** K = U argument used as index to `kstr'
-** J = S argument used as jump offset (relative to pc of next instruction)
-** L = unsigned argument used as index of local variable
-** N = U argument used as index to `knum'
+** an invalid register that fits in 8 bits
+*/
+#define NO_REG		MAXARG_A
+
+
+/*
+** R(x) - register
+** Kst(x) - constant (in constant table)
+** R/K(x) == if x < MAXSTACK then R(x) else Kst(x-MAXSTACK)
 */
 
 typedef enum {
 /*----------------------------------------------------------------------
-name		args	stack before	stack after	side effects
+name		args	description
 ------------------------------------------------------------------------*/
-OP_END,/*	-	-		(return)	no results	*/
-OP_RETURN,/*	U	v_n-v_x(at u)	(return)	returns v_x-v_n	*/
+OP_MOVE,/*	A B	R(A) := R(B)					*/
+OP_LOADK,/*	A Bc	R(A) := Kst(Bc)					*/
+OP_LOADINT,/*	A sBc	R(A) := (Number)sBc				*/
+OP_LOADNIL,/*	A B	R(A) := ... := R(B) := nil			*/
+OP_LOADUPVAL,/*	A Bc	R(A) := UpValue[Bc]				*/
 
-OP_CALL,/*	A B	v_n-v_1 f(at a)	r_b-r_1		f(v1,...,v_n)	*/
-OP_TAILCALL,/*	A B	v_n-v_1 f(at a)	(return)	f(v1,...,v_n)	*/
+OP_GETGLOBAL,/*	A Bc	R(A) := Gbl[Kst(Bc)]				*/
+OP_GETTABLE,/*	A B C	R(A) := R(B)[R/K(C)]				*/
 
-OP_PUSHNIL,/*	U	-		nil_1-nil_u			*/
-OP_POP,/*	U	a_u-a_1		-				*/
+OP_SETGLOBAL,/*	A Bc	Gbl[Kst(Bc)] := R(A)				*/
+OP_SETTABLE,/*	A B C	R(B)[R/K(C)] := R(A)				*/
 
-OP_PUSHINT,/*	S	-		(Number)s				*/
-OP_PUSHSTRING,/* K	-		KSTR[k]				*/
-OP_PUSHNUM,/*	N	-		KNUM[n]				*/
-OP_PUSHNEGNUM,/* N	-		-KNUM[n]			*/
+OP_NEWTABLE,/*	A Bc	R(A) := {} (size = Bc)				*/
 
-OP_PUSHUPVALUE,/* U	-		Closure[u]			*/
+OP_SELF,/*	A B C	R(A+1) := R(B); R(A) := R(B)[R/K(C)]		*/
 
-OP_GETLOCAL,/*	L	-		LOC[l]				*/
-OP_GETGLOBAL,/*	K	-		VAR[KSTR[k]]			*/
+OP_ADD,/*	A B C	R(A) := R(B) + R/K(C)				*/
+OP_SUB,/*	A B C	R(A) := R(B) - R/K(C)				*/
+OP_MUL,/*	A B C	R(A) := R(B) * R/K(C)				*/
+OP_DIV,/*	A B C	R(A) := R(B) / R/K(C)				*/
+OP_POW,/*	A B C	R(A) := R(B) ^ R/K(C)				*/
+OP_UNM,/*	A B	R(A) := -R(B)					*/
+OP_NOT,/*	A B	R(A) := not R(B)				*/
 
-OP_GETTABLE,/*	-	i t		t[i]				*/
-OP_GETDOTTED,/*	K	t		t[KSTR[k]]			*/
-OP_GETINDEXED,/* L	t		t[LOC[l]]			*/
-OP_PUSHSELF,/*	K	t		t t[KSTR[k]]			*/
+OP_CONCAT,/*	A B C	R(A) := R(B).. ... ..R(C)			*/
 
-OP_CREATETABLE,/* U	-		newarray(size = u)		*/
+OP_JMP,/*	sBc	PC += sBc					*/
+OP_CJMP,/*	sBc	if test then PC += sBc		(see (1))	*/
 
-OP_SETLOCAL,/*	L	x		-		LOC[l]=x	*/
-OP_SETGLOBAL,/*	K	x		-		VAR[KSTR[k]]=x	*/
-OP_SETTABLE,/*	A B	v a_a-a_1 i t	(pops b values)	t[i]=v		*/
+OP_TESTEQ,/*	A C	test := (R(A) == R/K(C))			*/
+OP_TESTNE,/*	A C	test := (R(A) ~= R/K(C))			*/
+OP_TESTLT,/*	A C	test := (R(A) < R/K(C))				*/
+OP_TESTLE,/*	A C	test := (R(A) <= R/K(C))			*/
+OP_TESTGT,/*	A C	test := (R(A) > R/K(C))				*/
+OP_TESTGE,/*	A C	test := (R(A) >= R/K(C))			*/
 
-OP_SETLIST,/*	A B	v_b-v_0 t	t		t[i+a*FPF]=v_i	*/
-OP_SETMAP,/*	U	v_u k_u - v_0 k_0 t	t	t[k_i]=v_i	*/
+OP_TESTT,/*	A B	test := R(B); if (test) R(A) := R(B)		*/
+OP_TESTF,/*	A B	test := not R(B); if (test) R(A) := nil		*/
 
-OP_ADD,/*	-	y x		x+y				*/
-OP_ADDI,/*	S	x		x+s				*/
-OP_SUB,/*	-	y x		x-y				*/
-OP_MULT,/*	-	y x		x*y				*/
-OP_DIV,/*	-	y x		x/y				*/
-OP_POW,/*	-	y x		x^y				*/
-OP_CONCAT,/*	U	v_u-v_1		v1..-..v_u			*/
-OP_MINUS,/*	-	x		-x				*/
-OP_NOT,/*	-	x		(x==nil)? 1 : nil		*/
+OP_NILJMP,/*	A Bc	R(A) := nil; PC++;				*/
 
-OP_JMPNE,/*	J	y x		-		(x~=y)? PC+=s	*/
-OP_JMPEQ,/*	J	y x		-		(x==y)? PC+=s	*/
-OP_JMPLT,/*	J	y x		-		(x<y)? PC+=s	*/
-OP_JMPLE,/*	J	y x		-		(x<y)? PC+=s	*/
-OP_JMPGT,/*	J	y x		-		(x>y)? PC+=s	*/
-OP_JMPGE,/*	J	y x		-		(x>=y)? PC+=s	*/
+OP_CALL,/*	A B C	R(A), ... ,R(A+C-1) := R(A)(R(A+1), ... ,R(A+B))*/
+OP_RETURN,/*	A B	return R(A), ... ,R(A+B-1)	(see (3))	*/
 
-OP_JMPT,/*	J	x		-		(x~=nil)? PC+=s	*/
-OP_JMPF,/*	J	x		-		(x==nil)? PC+=s	*/
-OP_JMPONT,/*	J	x		(x~=nil)? x : -	(x~=nil)? PC+=s	*/
-OP_JMPONF,/*	J	x		(x==nil)? x : -	(x==nil)? PC+=s	*/
-OP_JMP,/*	J	-		-		PC+=s		*/
+OP_FORPREP,/*	A sBc							*/
+OP_FORLOOP,/*	A sBc							*/
 
-OP_PUSHNILJMP,/* -	-		nil		PC++;		*/
+OP_TFORPREP,/*	A sBc							*/
+OP_TFORLOOP,/*	A sBc							*/
 
-OP_FORPREP,/*	J							*/
-OP_FORLOOP,/*	J							*/
-
-OP_CLOSURE,/*	A B	v_b-v_1		closure(KPROTO[a], v_1-v_b)	*/
-
-OP_SETLINE/*	U	-		-		LINE=u		*/
+OP_SETLIST,/*	A Bc	R(A)[Bc-Bc%FPF+i] := R(A+i), 1 <= i <= Bc%FPF+1	*/
+OP_SETLISTO,/*	A Bc							*/
 
+OP_CLOSURE /*	A Bc	R(A) := closure(KPROTO[Bc], R(A), ... ,R(A+n))	*/
 } OpCode;
 
 
+#define NUM_OPCODES	((int)OP_CLOSURE+1)
 
-#define ISJUMP(o)	(OP_JMPNE <= (o) && (o) <= OP_JMP)
+
+
+/*===========================================================================
+  Notes:
+  (1) In the current implementation there is no `test' variable;
+      instructions OP_TEST* and OP_CJMP must always occur together.
+
+  (2) In OP_CALL, if (B == NO_REG) then B = top. C is the number of returns,
+      and can be NO_REG. OP_CALL can set `top' to last_result+1, so
+      next open instruction (OP_CALL, OP_RETURN, OP_SETLIST) may use `top'.
+
+  (3) In OP_RETURN, if (B == NO_REG) then return up to `top'
+===========================================================================*/
+
+
+
+/*
+** masks for instruction properties
+*/  
+enum OpModeMask {
+  OpModeBreg = 2,       /* B is a register */
+  OpModeCreg,           /* C is a register/constant */
+  OpModesetA,           /* instruction set register A */
+  OpModeK,              /* Bc is a constant */
+  OpModeT               /* operator is a test */
+};
+
+extern const lu_byte luaP_opmodes[];
+
+#define getOpMode(m)            ((enum OpMode)(luaP_opmodes[m] & 3))
+#define testOpMode(m, b)        (luaP_opmodes[m] & (1 << (b)))
+
+
+/*
+** opcode names (only included when compiled with LUA_OPNAMES)
+*/
+extern const l_char *const luaP_opnames[];
 
 
 #endif

lparser.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.h,v 1.15 2000/04/05 17:51:58 roberto Exp roberto $
+** $Id: lparser.h,v 1.31 2001/06/05 18:17:01 roberto Exp roberto $
 ** LL(1) Parser and code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -16,42 +16,51 @@
 */
 
 typedef enum {
-  VGLOBAL,
-  VLOCAL,
-  VINDEXED,
-  VEXP
+  VVOID,	/* no value */
+  VNIL,
+  VNUMBER,	/* n = value */
+  VK,		/* info = index of constant in `k' */
+  VGLOBAL,	/* info = index of global name in `k' */
+  VLOCAL,	/* info = local register */
+  VINDEXED,	/* info = table register; aux = index register (or `k') */
+  VRELOCABLE,	/* info = instruction pc */
+  VNONRELOC,	/* info = result register */
+  VJMP,		/* info = result register */
+  VCALL		/* info = result register */
 } expkind;
 
 typedef struct expdesc {
   expkind k;
   union {
-    int index;  /* VGLOBAL: `kstr' index of global name; VLOCAL: stack index */
     struct {
-      int t;  /* patch list of `exit when true' */
-      int f;  /* patch list of `exit when false' */
-    } l;
+      int info, aux;
+    } i;
+    lua_Number n;
   } u;
+  int t;  /* patch list of `exit when true' */
+  int f;  /* patch list of `exit when false' */
 } expdesc;
 
 
-
 /* state needed to generate code for a given function */
 typedef struct FuncState {
   Proto *f;  /* current function header */
   struct FuncState *prev;  /* enclosing function */
   struct LexState *ls;  /* lexical state */
   struct lua_State *L;  /* copy of the Lua state */
-  int pc;  /* next position to code */
+  int pc;  /* next position to code (equivalent to `ncode') */
   int lasttarget;   /* `pc' of last `jump target' */
-  int jlt;  /* list of jumps to `lasttarged' */
-  int stacklevel;  /* number of values on activation register */
-  int nlocalvar;  /* number of active local variables */
-  int nupvalues;  /* number of upvalues */
-  int nvars;  /* number of entries in f->locvars (-1 if no debug information) */
-  int lastsetline;  /* line where last SETLINE was issued */
+  int jlt;  /* list of jumps to `lasttarget' */
+  int freereg;  /* first free register */
+  int nk;  /* number of elements in `k' */
+  int np;  /* number of elements in `p' */
+  int nlineinfo;  /* number of elements in `lineinfo' */
+  int nlocvars;  /* number of elements in `locvars' */
+  int nactloc;  /* number of active local variables */
+  int lastline;  /* line where last `lineinfo' was generated */
   struct Breaklabel *bl;  /* chain of breakable blocks */
   expdesc upvalues[MAXUPVALUES];  /* upvalues */
-  TString *localvar[MAXLOCALS];  /* store local variable names */
+  int actloc[MAXLOCALS];  /* local-variable stack (indices to locvars) */
 } FuncState;
 
 

lref.c

@@ -1,115 +0,0 @@
-/*
-** $Id: lref.c,v 1.10 2000/03/27 20:10:21 roberto Exp roberto $
-** reference mechanism
-** See Copyright Notice in lua.h
-*/
-
-
-#define LUA_REENTRANT
-
-#include "lapi.h"
-#include "lmem.h"
-#include "lref.h"
-#include "lstate.h"
-#include "lua.h"
-
-
-int lua_ref (lua_State *L,  int lock) {
-  int ref;
-  luaA_checkCargs(L, 1);
-  if (ttype(L->top-1) == TAG_NIL)
-    ref = LUA_REFNIL;
-  else {
-    if (L->refFree != NONEXT) {  /* is there a free place? */
-      ref = L->refFree;
-      L->refFree = L->refArray[ref].st;
-    }
-    else {  /* no more free places */
-      luaM_growvector(L, L->refArray, L->refSize, 1, struct Ref, refEM, MAX_INT);
-      ref = L->refSize++;
-    }
-    L->refArray[ref].o = *(L->top-1);
-    L->refArray[ref].st = lock ? LOCK : HOLD;
-  }
-  L->top--;
-  return ref;
-}
-
-
-void lua_unref (lua_State *L, int ref) {
-  if (ref >= 0) {
-    if (ref >= L->refSize || L->refArray[ref].st >= 0)
-      lua_error(L, "Lua API error - "
-                   "invalid argument for function `lua_unref'");
-    L->refArray[ref].st = L->refFree;
-    L->refFree = ref;
-  }
-}
-
-
-lua_Object lua_getref (lua_State *L, int ref) {
-  if (ref == LUA_REFNIL)
-    return luaA_putluaObject(L, &luaO_nilobject);
-  else if (0 <= ref && ref < L->refSize &&
-          (L->refArray[ref].st == LOCK || L->refArray[ref].st == HOLD))
-    return luaA_putluaObject(L, &L->refArray[ref].o);
-  else
-    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, "Lua 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) {
-    case TAG_STRING: case TAG_USERDATA:
-      return o->value.ts->marked;
-    case TAG_TABLE:
-      return o->value.a->marked;
-    case TAG_LCLOSURE:  case TAG_CCLOSURE:
-      return o->value.cl->marked;
-    default:  /* number */
-      return 1;
-  }
-}
-
-
-/* for internal debugging only; check if a link of free refs is valid */
-#define VALIDLINK(L, st,n)	(NONEXT <= (st) && (st) < (n))
-
-void luaR_invalidaterefs (lua_State *L) {
-  int n = L->refSize;
-  int i;
-  for (i=0; i<n; i++) {
-    struct Ref *r = &L->refArray[i];
-    if (r->st == HOLD && !ismarked(&r->o))
-      r->st = COLLECTED;
-    LUA_ASSERT(L, (r->st == LOCK && ismarked(&r->o)) ||
-                r->st == COLLECTED ||
-                r->st == NONEXT ||
-               (r->st < n && VALIDLINK(L, L->refArray[r->st].st, n)),
-               "inconsistent ref table");
-  }
-  LUA_ASSERT(L, VALIDLINK(L, L->refFree, n), "inconsistent ref table");
-}
-

lref.h

@@ -1,27 +0,0 @@
-/*
-** $Id: lref.h,v 1.5 1999/12/27 17:33:22 roberto Exp roberto $
-** reference mechanism
-** See Copyright Notice in lua.h
-*/
-
-#ifndef lref_h
-#define lref_h
-
-#include "lobject.h"
-
-
-#define NONEXT          -1      /* to end the free list */
-#define HOLD            -2
-#define COLLECTED       -3
-#define LOCK            -4
-
-
-struct Ref {
-  TObject o;
-  int st;  /* can be LOCK, HOLD, COLLECTED, or next (for free list) */
-};
-
-
-void luaR_invalidaterefs (lua_State *L);
-
-#endif

lstate.c

@@ -1,108 +1,142 @@
 /*
-** $Id: lstate.c,v 1.24 2000/01/13 16:30:47 roberto Exp roberto $
+** $Id: lstate.c,v 1.65 2001/06/21 16:41:34 roberto Exp roberto $
 ** Global State
 ** See Copyright Notice in lua.h
 */
 
 
-#include <stdarg.h>
+#include <stdio.h>
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
-#include "lauxlib.h"
-#include "lbuiltin.h"
 #include "ldo.h"
 #include "lgc.h"
 #include "llex.h"
 #include "lmem.h"
-#include "lref.h"
 #include "lstate.h"
 #include "lstring.h"
+#include "ltable.h"
 #include "ltm.h"
 
 
-lua_State *lua_state = NULL;
+struct Sopen {
+  int stacksize;
+  lua_State *L;
+};
 
 
-static lua_State *newstate_aux (int stacksize, int put_builtin) {
-  lua_State *L = luaM_new(NULL, lua_State);
-  L->errorJmp = NULL;
-  L->Mbuffer = NULL;
-  L->Mbuffbase = 0;
-  L->Mbuffsize = 0;
-  L->Mbuffnext = 0;
-  L->Cblocks = NULL;
-  L->numCblocks = 0;
-  L->rootproto = NULL;
-  L->rootcl = NULL;
-  L->rootglobal = NULL;
-  L->roottable = NULL;
-  L->IMtable = NULL;
-  L->refArray = NULL;
-  L->refSize = 0;
-  L->refFree = NONEXT;
-  L->nblocks = 0;
-  L->GCthreshold = MAX_INT;  /* to avoid GC during pre-definitions */
-  L->debug = 0;
-  L->callhook = NULL;
-  L->linehook = NULL;
-  L->allowhooks = 1;
-  luaD_init(L, stacksize);
-  luaS_init(L);
-  luaX_init(L);
-  luaT_init(L);
-  if (put_builtin)
-    luaB_predefine(L);
-  L->GCthreshold = L->nblocks*4;
+static void close_state (lua_State *L, lua_State *OL);
+
+
+/*
+** open parts that may cause memory-allocation errors
+*/
+static void f_luaopen (lua_State *L, void *ud) {
+  struct Sopen *so = (struct Sopen *)ud;
+  if (so->stacksize == 0)
+    so->stacksize = DEFAULT_STACK_SIZE;
+  else
+    so->stacksize += LUA_MINSTACK;
+  if (so->L != NULL) {  /* shared global state? */
+    L->G = G(so->L);
+    L->gt = so->L->gt;  /* share table of globals */
+    so->L->next->previous = L;  /* insert L into linked list */
+    L->next = so->L->next;
+    so->L->next = L;
+    L->previous = so->L;
+    luaD_init(L, so->stacksize);  /* init stack */
+  }
+  else {  /* create a new global state */
+    L->G = luaM_new(L, global_State);
+    G(L)->strt.size = 0;
+    G(L)->strt.nuse = 0;
+    G(L)->strt.hash = NULL;
+    G(L)->Mbuffer = NULL;
+    G(L)->Mbuffsize = 0;
+    G(L)->rootproto = NULL;
+    G(L)->rootcl = NULL;
+    G(L)->roottable = NULL;
+    G(L)->rootudata = NULL;
+    G(L)->TMtable = NULL;
+    G(L)->sizeTM = 0;
+    G(L)->ntag = 0;
+    G(L)->nblocks = sizeof(lua_State) + sizeof(global_State);
+    luaD_init(L, so->stacksize);  /* init stack */
+    L->gt = luaH_new(L, 10);  /* table of globals */
+    G(L)->type2tag = luaH_new(L, 10);
+    G(L)->registry = luaH_new(L, 0);
+    G(L)->weakregistry = luaH_new(L, 0);
+    /* make weakregistry weak */
+    G(L)->weakregistry->weakmode = LUA_WEAK_KEY | LUA_WEAK_VALUE;
+    luaS_resize(L, MINPOWER2);
+    luaX_init(L);
+    luaT_init(L);
+    G(L)->GCthreshold = 4*G(L)->nblocks;
+  }
+}
+
+
+LUA_API lua_State *lua_newthread (lua_State *OL, int stacksize) {
+  struct Sopen so;
+  lua_State *L;
+  if (OL) lua_lock(OL);
+  L = luaM_new(OL, lua_State);
+  if (L) {  /* allocation OK? */
+    L->G = NULL;
+    L->stack = NULL;
+    L->stacksize = 0;
+    L->ci = &L->basefunc;
+    L->basefunc.prev = NULL;
+    L->errorJmp = NULL;
+    L->callhook = NULL;
+    L->linehook = NULL;
+    L->allowhooks = 1;
+    L->next = L->previous = L;
+    so.stacksize = stacksize;
+    so.L = OL;
+    if (luaD_runprotected(L, f_luaopen, &so) != 0) {
+      /* memory allocation error: free partial state */
+      close_state(L, OL);
+      L = NULL;
+    }
+  }
+  if (OL) lua_unlock(OL);
   return L;
 }
 
 
-lua_State *lua_newstate (const char *s, ...) {
-  static const char *const ops[] = {"stack", "builtin", NULL};
-  va_list ap;
-  int stacksize = DEFAULT_STACK_SIZE;
-  int put_builtin = 1;
-  va_start(ap, s);
-  while (s) {
-    switch (luaL_findstring(s, ops)) {
-      case 0:  /* stack */
-        stacksize = va_arg(ap, int);
-        break;
-      case 1:  /* builtin */
-        put_builtin = va_arg(ap, int);
-        break;
-      default:  /* invalid argument */
-        va_end(ap);
-        return NULL;
-    }
-    s = va_arg(ap, const char *);
+static void close_state (lua_State *L, lua_State *OL) {
+  if (OL != NULL) {  /* are there other threads? */
+    lua_assert(L->previous != L);
+    L->previous->next = L->next;
+    L->next->previous = L->previous;
   }
-  va_end(ap);
-  return newstate_aux(stacksize, put_builtin);
+  else if (G(L)) {  /* last thread; close global state */
+    luaC_callallgcTM(L);  /* call GC tag methods for all udata */
+    luaC_collect(L, 1);  /* collect all elements */
+    lua_assert(G(L)->rootproto == NULL);
+    lua_assert(G(L)->rootudata == NULL);
+    lua_assert(G(L)->rootcl == NULL);
+    lua_assert(G(L)->roottable == NULL);
+    luaS_freeall(L);
+    luaM_freearray(L, G(L)->TMtable, G(L)->sizeTM, struct TM);
+    luaM_freearray(L, G(L)->Mbuffer, G(L)->Mbuffsize, l_char);
+    luaM_freelem(NULL, L->G, global_State);
+  }
+  luaM_freearray(OL, L->stack, L->stacksize, TObject);
+  luaM_freelem(OL, L, lua_State);
 }
 
-
-void lua_close (lua_State *L) {
-  luaC_collect(L, 1);  /* collect all elements */
-  LUA_ASSERT(L, L->rootproto == NULL, "list should be empty");
-  LUA_ASSERT(L, L->rootcl == NULL, "list should be empty");
-  LUA_ASSERT(L, L->rootglobal == NULL, "list should be empty");
-  LUA_ASSERT(L, L->roottable == NULL, "list should be empty");
-  luaS_freeall(L);
-  luaM_free(L, L->stack);
-  luaM_free(L, L->IMtable);
-  luaM_free(L, L->refArray);
-  luaM_free(L, L->Mbuffer);
-  luaM_free(L, L->Cblocks);
-  LUA_ASSERT(L, L->numCblocks == 0, "Cblocks still open");
-  LUA_ASSERT(L, L->nblocks == 0, "wrong count for nblocks");
-  LUA_ASSERT(L, L->Cstack.base == L->top, "C2Lua not empty");
-  luaM_free(L, L);
-  if (L == lua_state) {
-    LUA_ASSERT(L, memdebug_numblocks == 0, "memory leak!");
-    LUA_ASSERT(L, memdebug_total == 0,"memory leak!");
-    lua_state = NULL;
-  }
+LUA_API void lua_close (lua_State *L) {
+  lua_State *OL;
+  lua_assert(L != lua_state || lua_gettop(L) == 0);
+  lua_lock(L);
+  OL = L->next;  /* any surviving thread (if there is one) */
+  if (OL == L) OL = NULL;  /* no surviving threads */
+  close_state(L, OL);
+  if (OL) lua_unlock(OL);  /* cannot unlock over a freed state */
+  lua_assert(L != lua_state || memdebug_numblocks == 0);
+  lua_assert(L != lua_state || memdebug_total == 0);
 }
 

lstate.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lstate.h,v 1.30 2000/03/10 18:37:44 roberto Exp roberto $
+** $Id: lstate.h,v 1.57 2001/06/06 18:00:19 roberto Exp roberto $
 ** Global State
 ** See Copyright Notice in lua.h
 */
@@ -7,82 +7,94 @@
 #ifndef lstate_h
 #define lstate_h
 
-#include <setjmp.h>
-
 #include "lobject.h"
 #include "lua.h"
 #include "luadebug.h"
 
 
+/*
+** macros for thread syncronization inside Lua core machine:
+** all accesses to the global state and to global objects are syncronized.
+** Because threads can read the stack of other threads
+** (when running garbage collection),
+** a thread must also syncronize any write-access to its own stack.
+** Unsyncronized accesses are allowed only when reading its own stack,
+** or when reading immutable fields from global objects
+** (such as string values and udata values). 
+*/
+#ifndef lua_lock
+#define lua_lock(L)	((void) 0)
+#endif
 
-typedef TObject *StkId;  /* index to stack elements */
-
+#ifndef lua_unlock
+#define lua_unlock(L)	((void) 0)
+#endif
 
 /*
-** `jmp_buf' may be an array, so it is better to make sure it has an
-** address (and not that it *is* an address...)
+** macro to allow the inclusion of user information in Lua state
 */
-struct lua_longjmp {
-  jmp_buf b;
-};
+#ifndef LUA_USERSTATE
+#define LUA_USERSTATE
+#endif
 
 
-/*
-** stack layout for C point of view:
-** [lua2C, lua2C+num) - `array' lua2C
-** [lua2C+num, base)  - space for extra lua_Objects (limbo)
-** [base, L->top)     - `stack' C2Lua
-*/
-struct C_Lua_Stack {
-  StkId base;
-  StkId lua2C;
-  int num;
-};
+
+struct lua_longjmp;  /* defined in ldo.c */
+struct TM;  /* defined in ltm.h */
 
 
 typedef struct stringtable {
   int size;
-  int nuse;  /* number of elements (including EMPTYs) */
+  ls_nstr nuse;  /* number of elements */
   TString **hash;
 } stringtable;
 
 
-
-struct lua_State {
-  /* thread-specific state */
-  StkId top;  /* first free slot in the stack */
-  StkId stack;  /* stack base */
-  StkId stack_last;  /* last free slot in the stack */
-  int stacksize;
-  struct C_Lua_Stack Cstack;  /* C2lua struct */
-  struct lua_longjmp *errorJmp;  /* current error recover point */
-  char *Mbuffer;  /* global buffer */
-  int Mbuffbase;  /* current first position of Mbuffer */
-  int Mbuffsize;  /* size of Mbuffer */
-  int Mbuffnext;  /* next position to fill in Mbuffer */
-  struct C_Lua_Stack *Cblocks;
-  int numCblocks;  /* number of nested Cblocks */
-  /* global state */
+/*
+** `global state', shared by all threads of this state
+*/
+typedef struct global_State {
+  void *Mbuffer;  /* global buffer */
+  size_t Mbuffsize;  /* size of Mbuffer */
   Proto *rootproto;  /* list of all prototypes */
   Closure *rootcl;  /* list of all closures */
   Hash *roottable;  /* list of all tables */
-  GlobalVar *rootglobal;  /* list of global variables */
-  stringtable *string_root;  /* array of hash tables for strings and udata */
-  struct IM *IMtable;  /* table for tag methods */
-  int last_tag;  /* last used tag in IMtable */
-  struct Ref *refArray;  /* locked objects */
-  int refSize;  /* size of refArray */
-  int refFree;  /* list of free positions in refArray */
-  unsigned long GCthreshold;
-  unsigned long nblocks;  /* number of `blocks' currently allocated */
-  int debug;
+  Udata *rootudata;   /* list of all userdata */
+  stringtable strt;  /* hash table for strings */
+  Hash *type2tag;  /* hash table from type names to tags */
+  Hash *registry;  /* (strong) registry table */
+  Hash *weakregistry;  /* weakregistry table */
+  struct TM *TMtable;  /* table for tag methods */
+  int sizeTM;  /* size of TMtable */
+  int ntag;  /* number of tags in TMtable */
+  lu_mem GCthreshold;
+  lu_mem nblocks;  /* number of `bytes' currently allocated */
+} global_State;
+
+
+/*
+** `per thread' state
+*/
+struct lua_State {
+  LUA_USERSTATE
+  StkId top;  /* first free slot in the stack */
+  CallInfo *ci;  /* call info for current function */
+  StkId stack_last;  /* last free slot in the stack */
+  Hash *gt;  /* table for globals */
+  global_State *G;
+  StkId stack;  /* stack base */
+  int stacksize;
   lua_Hook callhook;
   lua_Hook linehook;
   int allowhooks;
+  struct lua_longjmp *errorJmp;  /* current error recover point */
+  lua_State *next;  /* circular double linked list of states */
+  lua_State *previous;
+  CallInfo basefunc;
 };
 
 
-
+#define G(L)	(L->G)
 
 
 #endif

lstring.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.c,v 1.33 2000/03/10 14:38:10 roberto Exp roberto $
+** $Id: lstring.c,v 1.64 2001/06/07 15:01:21 roberto Exp roberto $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
@@ -7,199 +7,92 @@
 
 #include <string.h>
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
 #include "lmem.h"
 #include "lobject.h"
 #include "lstate.h"
 #include "lstring.h"
-#include "lua.h"
 
 
 
-#define gcsizestring(L, l)	numblocks(L, 0, sizeof(TString)+l)
-#define gcsizeudata		gcsizestring(L, 0)
-
-
-
-void luaS_init (lua_State *L) {
-  int i;
-  L->string_root = luaM_newvector(L, NUM_HASHS, stringtable);
-  for (i=0; i<NUM_HASHS; i++) {
-    L->string_root[i].size = 1;
-    L->string_root[i].nuse = 0;
-    L->string_root[i].hash = luaM_newvector(L, 1, TString *);;
-    L->string_root[i].hash[0] = NULL;
-  }
-}
-
-
 void luaS_freeall (lua_State *L) {
-  int i;
-  for (i=0; i<NUM_HASHS; i++) {
-    LUA_ASSERT(L, L->string_root[i].nuse==0, "non-empty string table");
-    luaM_free(L, L->string_root[i].hash);
-  }
-  luaM_free(L, L->string_root);
+  lua_assert(G(L)->strt.nuse==0);
+  luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size, TString *);
 }
 
 
-static unsigned long hash_s (const char *s, long l) {
-  unsigned long h = l;  /* seed */
-  long step = (l>>6)+1;  /* if string is too long, don't hash all its chars */
-  for (; l>0; l-=step)
-    h = h ^ ((h<<5)+(h>>2)+(unsigned char)*(s++));
-  return h;
-}
-
-
-void luaS_resize (lua_State *L, stringtable *tb, int newsize) {
+void luaS_resize (lua_State *L, int newsize) {
   TString **newhash = luaM_newvector(L, newsize, TString *);
+  stringtable *tb = &G(L)->strt;
   int i;
   for (i=0; i<newsize; i++) newhash[i] = NULL;
   /* rehash */
   for (i=0; i<tb->size; i++) {
     TString *p = tb->hash[i];
     while (p) {  /* for each node in the list */
-      TString *next = p->nexthash;  /* save next */
-      int h = p->hash&(newsize-1);  /* new position */
-      LUA_ASSERT(L, p->hash%newsize == (p->hash&(newsize-1)),
-                    "a&(x-1) == a%x, for x power of 2");
-      p->nexthash = newhash[h];  /* chain it in new position */
-      newhash[h] = p;
+      TString *next = p->tsv.nexthash;  /* save next */
+      lu_hash h = p->tsv.hash;
+      int h1 = lmod(h, newsize);  /* new position */
+      lua_assert((int)(h%newsize) == lmod(h, newsize));
+      p->tsv.nexthash = newhash[h1];  /* chain it in new position */
+      newhash[h1] = p;
       p = next;
     }
   }
-  luaM_free(L, tb->hash);
+  luaM_freearray(L, tb->hash, tb->size, TString *);
   tb->size = newsize;
   tb->hash = newhash;
 }
 
 
-static TString *newone (lua_State *L, long l, unsigned long h) {
-  TString *ts = (TString *)luaM_malloc(L, 
-                                       sizeof(TString)+l*sizeof(char));
-  ts->marked = 0;
-  ts->nexthash = NULL;
-  ts->hash = h;
-  return ts;
-}
-
-
-static TString *newone_s (lua_State *L, const char *str,
-                               long l, unsigned long h) {
-  TString *ts = newone(L, l, h);
-  memcpy(ts->str, str, l);
-  ts->str[l] = 0;  /* ending 0 */
-  ts->u.s.gv = NULL;  /* no global value */
-  ts->u.s.len = l;
-  ts->constindex = 0;
-  L->nblocks += gcsizestring(L, l);
-  return ts;
-}
-
-
-static TString *newone_u (lua_State *L, void *buff,
-                               int tag, unsigned long h) {
-  TString *ts = newone(L, 0, h);
-  ts->u.d.value = buff;
-  ts->u.d.tag = (tag == LUA_ANYTAG) ? 0 : tag;
-  ts->constindex = -1;  /* tag -> this is a userdata */
-  L->nblocks += gcsizeudata;
-  return ts;
-}
-
-
-static void newentry (lua_State *L, stringtable *tb, TString *ts, int h) {
-  ts->nexthash = tb->hash[h];  /* chain new entry */
+static TString *newlstr (lua_State *L, const l_char *str, size_t l, lu_hash h) {
+  TString *ts = (TString *)luaM_malloc(L, sizestring(l));
+  stringtable *tb;
+  ts->tsv.nexthash = NULL;
+  ts->tsv.len = l;
+  ts->tsv.hash = h;
+  ts->tsv.marked = 0;
+  ts->tsv.constindex = 0;
+  memcpy(getstr(ts), str, l*sizeof(l_char));
+  getstr(ts)[l] = l_c('\0');  /* ending 0 */
+  tb = &G(L)->strt;
+  h = lmod(h, tb->size);
+  ts->tsv.nexthash = tb->hash[h];  /* chain new entry */
   tb->hash[h] = ts;
   tb->nuse++;
-  if (tb->nuse > tb->size)  /* too crowded? */
-    luaS_resize(L, tb, tb->size*2);
+  if (tb->nuse > (ls_nstr)tb->size && tb->size <= MAX_INT/2)
+    luaS_resize(L, tb->size*2);  /* too crowded */
+  return ts;
 }
 
 
-TString *luaS_newlstr (lua_State *L, const char *str, long l) {
-  unsigned long h = hash_s(str, l);
-  stringtable *tb = &L->string_root[(l==0) ? 0 :
-                         ((unsigned int)(str[0]+str[l-1]))&(NUM_HASHSTR-1)];
-  int h1 = h&(tb->size-1);
+TString *luaS_newlstr (lua_State *L, const l_char *str, size_t l) {
   TString *ts;
-  for (ts = tb->hash[h1]; ts; ts = ts->nexthash) {
-    if (ts->u.s.len == l && (memcmp(str, ts->str, l) == 0))
+  lu_hash h = l;  /* seed */
+  size_t step = (l>>5)+1;  /* if string is too long, don't hash all its chars */
+  size_t l1;
+  for (l1=l; l1>=step; l1-=step)  /* compute hash */
+    h = h ^ ((h<<5)+(h>>2)+uchar(str[l1-1]));
+  for (ts = G(L)->strt.hash[lmod(h, G(L)->strt.size)];
+       ts != NULL;
+       ts = ts->tsv.nexthash) {
+    if (ts->tsv.len == l && (memcmp(str, getstr(ts), l) == 0))
       return ts;
   }
-  /* not found */
-  ts = newone_s(L, str, l, h);  /* create new entry */
-  newentry(L, tb, ts, h1);  /* insert it on table */
-  return ts;
+  return newlstr(L, str, l, h);  /* not found */
 }
 
 
-/*
-** uses '%' for one hashing with userdata because addresses are too regular,
-** so two '&' operations would be highly correlated
-*/
-TString *luaS_createudata (lua_State *L, void *udata, int tag) {
-  unsigned long h = IntPoint(L, udata);
-  stringtable *tb = &L->string_root[(h%NUM_HASHUDATA)+NUM_HASHSTR];
-  int h1 = h&(tb->size-1);
-  TString *ts;
-  for (ts = tb->hash[h1]; ts; ts = ts->nexthash) {
-    if (udata == ts->u.d.value && (tag == ts->u.d.tag || tag == LUA_ANYTAG))
-      return ts;
-  }
-  /* not found */
-  ts = newone_u(L, udata, tag, h);
-  newentry(L, tb, ts, h1);
-  return ts;
+Udata *luaS_newudata (lua_State *L, size_t s) {
+  Udata *u = (Udata *)luaM_malloc(L, sizeudata(s));
+  u->uv.len = s;
+  u->uv.tag = 0;
+  u->uv.value = u + 1;
+  /* chain it on udata list */
+  u->uv.next = G(L)->rootudata;
+  G(L)->rootudata = u;
+  return u;
 }
 
-
-TString *luaS_new (lua_State *L, const char *str) {
-  return luaS_newlstr(L, str, strlen(str));
-}
-
-TString *luaS_newfixed (lua_State *L, const char *str) {
-  TString *ts = luaS_new(L, str);
-  if (ts->marked == 0) ts->marked = FIXMARK;  /* avoid GC */
-  return ts;
-}
-
-
-void luaS_free (lua_State *L, TString *t) {
-  if (t->constindex == -1)  /* is userdata? */
-    L->nblocks -= gcsizeudata;
-  else {  /* is string */
-    L->nblocks -= gcsizestring(L, t->u.s.len);
-    luaM_free(L, t->u.s.gv);
-  }
-  luaM_free(L, t);
-}
-
-
-GlobalVar *luaS_assertglobal (lua_State *L, TString *ts) {
-  GlobalVar *gv = ts->u.s.gv;
-  if (!gv) {  /* no global value yet? */
-    gv = luaM_new(L, GlobalVar);
-    gv->value.ttype = TAG_NIL;  /* initial value */
-    gv->name = ts;
-    gv->next = L->rootglobal;  /* chain in global list */
-    L->rootglobal = gv; 
-    ts->u.s.gv = gv;
-  }
-  return gv;
-}
-
-
-GlobalVar *luaS_assertglobalbyname (lua_State *L, const char *name) {
-  return luaS_assertglobal(L, luaS_new(L, name));
-}
-
-
-int luaS_globaldefined (lua_State *L, const char *name) {
-  TString *ts = luaS_new(L, name);
-  return ts->u.s.gv && ts->u.s.gv->value.ttype != TAG_NIL;
-}
-
-

lstring.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.h,v 1.17 2000/03/10 14:38:10 roberto Exp roberto $
+** $Id: lstring.h,v 1.32 2001/06/06 18:00:19 roberto Exp roberto $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
@@ -12,30 +12,28 @@
 #include "lstate.h"
 
 
-#define NUM_HASHSTR     32
-#define NUM_HASHUDATA   31
-#define NUM_HASHS (NUM_HASHSTR+NUM_HASHUDATA)
-
 
 /*
-** any taggedstring with mark>=FIXMARK is never collected.
+** any TString with mark>=FIXMARK is never collected.
 ** Marks>=RESERVEDMARK are used to identify reserved words.
 */
 #define FIXMARK		2
 #define RESERVEDMARK	3
 
 
-void luaS_init (lua_State *L);
-void luaS_resize (lua_State *L, stringtable *tb, int newsize);
-TString *luaS_createudata (lua_State *L, void *udata, int tag);
+#define sizestring(l)	((lu_mem)sizeof(union TString)+ \
+                         ((lu_mem)(l)+1)*sizeof(l_char))
+
+#define sizeudata(l)	((lu_mem)sizeof(union Udata)+(l))
+
+#define luaS_new(L, s)	(luaS_newlstr(L, s, strlen(s)))
+#define luaS_newliteral(L, s)	(luaS_newlstr(L, l_s("") s, \
+                                 (sizeof(s)/sizeof(l_char))-1))
+
+void luaS_resize (lua_State *L, int newsize);
+Udata *luaS_newudata (lua_State *L, size_t s);
 void luaS_freeall (lua_State *L);
-void luaS_free (lua_State *L, TString *ts);
-TString *luaS_newlstr (lua_State *L, const char *str, long l);
-TString *luaS_new (lua_State *L, const char *str);
-TString *luaS_newfixed (lua_State *L, const char *str);
-GlobalVar *luaS_assertglobal (lua_State *L, TString *ts);
-GlobalVar *luaS_assertglobalbyname (lua_State *L, const char *name);
-int luaS_globaldefined (lua_State *L, const char *name);
+TString *luaS_newlstr (lua_State *L, const l_char *str, size_t l);
 
 
 #endif

lstrlib.c

@@ -1,111 +1,114 @@
 /*
-** $Id: lstrlib.c,v 1.40 2000/02/08 16:34:31 roberto Exp roberto $
+** $Id: lstrlib.c,v 1.68 2001/03/26 14:31:49 roberto Exp roberto $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
 
 
 #include <ctype.h>
+#include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
 #include "lauxlib.h"
-#include "lua.h"
 #include "lualib.h"
 
 
-
-static void addnchar (lua_State *L, const char *s, int n) {
-  char *b = luaL_openspace(L, n);
-  memcpy(b, s, n);
-  luaL_addsize(L, n);
-}
+typedef long sint32;	/* a signed version for size_t */
 
 
-static void str_len (lua_State *L) {
-  long l;
+static int str_len (lua_State *L) {
+  size_t l;
   luaL_check_lstr(L, 1, &l);
   lua_pushnumber(L, l);
+  return 1;
 }
 
 
-static void closeandpush (lua_State *L) {
-  lua_pushlstring(L, luaL_buffer(L), luaL_getsize(L));
-}
-
-
-static long posrelat (long pos, long len) {
+static sint32 posrelat (sint32 pos, size_t len) {
   /* relative string position: negative means back from end */
-  return (pos>=0) ? pos : len+pos+1;
+  return (pos>=0) ? pos : (sint32)len+pos+1;
 }
 
 
-static void str_sub (lua_State *L) {
-  long l;
-  const char *s = luaL_check_lstr(L, 1, &l);
-  long start = posrelat(luaL_check_long(L, 2), l);
-  long end = posrelat(luaL_opt_long(L, 3, -1), l);
+static int str_sub (lua_State *L) {
+  size_t l;
+  const l_char *s = luaL_check_lstr(L, 1, &l);
+  sint32 start = posrelat(luaL_check_long(L, 2), l);
+  sint32 end = posrelat(luaL_opt_long(L, 3, -1), l);
   if (start < 1) start = 1;
-  if (end > l) end = l;
+  if (end > (sint32)l) end = l;
   if (start <= end)
     lua_pushlstring(L, s+start-1, end-start+1);
-  else lua_pushstring(L, "");
+  else lua_pushliteral(L, l_s(""));
+  return 1;
 }
 
 
-static void str_lower (lua_State *L) {
-  long l;
-  int i;
-  const char *s = luaL_check_lstr(L, 1, &l);
-  luaL_resetbuffer(L);
+static int str_lower (lua_State *L) {
+  size_t l;
+  size_t i;
+  luaL_Buffer b;
+  const l_char *s = luaL_check_lstr(L, 1, &l);
+  luaL_buffinit(L, &b);
   for (i=0; i<l; i++)
-    luaL_addchar(L, tolower((unsigned char)(s[i])));
-  closeandpush(L);
+    luaL_putchar(&b, tolower(uchar(s[i])));
+  luaL_pushresult(&b);
+  return 1;
 }
 
 
-static void str_upper (lua_State *L) {
-  long l;
-  int i;
-  const char *s = luaL_check_lstr(L, 1, &l);
-  luaL_resetbuffer(L);
+static int str_upper (lua_State *L) {
+  size_t l;
+  size_t i;
+  luaL_Buffer b;
+  const l_char *s = luaL_check_lstr(L, 1, &l);
+  luaL_buffinit(L, &b);
   for (i=0; i<l; i++)
-    luaL_addchar(L, toupper((unsigned char)(s[i])));
-  closeandpush(L);
+    luaL_putchar(&b, toupper(uchar(s[i])));
+  luaL_pushresult(&b);
+  return 1;
 }
 
-static void str_rep (lua_State *L) {
-  long l;
-  const char *s = luaL_check_lstr(L, 1, &l);
+static int str_rep (lua_State *L) {
+  size_t l;
+  luaL_Buffer b;
+  const l_char *s = luaL_check_lstr(L, 1, &l);
   int n = luaL_check_int(L, 2);
-  luaL_resetbuffer(L);
+  luaL_buffinit(L, &b);
   while (n-- > 0)
-    addnchar(L, s, l);
-  closeandpush(L);
+    luaL_addlstring(&b, s, l);
+  luaL_pushresult(&b);
+  return 1;
 }
 
 
-static void str_byte (lua_State *L) {
-  long l;
-  const char *s = luaL_check_lstr(L, 1, &l);
-  long pos = posrelat(luaL_opt_long(L, 2, 1), l);
-  luaL_arg_check(L, 0<pos && pos<=l, 2,  "out of range");
-  lua_pushnumber(L, (unsigned char)s[pos-1]);
+static int str_byte (lua_State *L) {
+  size_t l;
+  const l_char *s = luaL_check_lstr(L, 1, &l);
+  sint32 pos = posrelat(luaL_opt_long(L, 2, 1), l);
+  luaL_arg_check(L, 0<pos && (size_t)pos<=l, 2,  l_s("out of range"));
+  lua_pushnumber(L, uchar(s[pos-1]));
+  return 1;
 }
 
 
-static void str_char (lua_State *L) {
-  int i = 0;
-  luaL_resetbuffer(L);
-  while (lua_getparam(L, ++i) != LUA_NOOBJECT) {
+static int str_char (lua_State *L) {
+  int n = lua_gettop(L);  /* number of arguments */
+  int i;
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  for (i=1; i<=n; i++) {
     int c = luaL_check_int(L, i);
-    luaL_arg_check(L, (unsigned char)c == c, i, "invalid value");
-    luaL_addchar(L, (unsigned char)c);
+    luaL_arg_check(L, uchar(c) == c, i, l_s("invalid value"));
+    luaL_putchar(&b, uchar(c));
   }
-  closeandpush(L);
+  luaL_pushresult(&b);
+  return 1;
 }
 
 
@@ -121,58 +124,56 @@ static void str_char (lua_State *L) {
 #endif
 
 
-struct Capture {
-  const char *src_end;  /* end ('\0') of source string */
+#define CAP_UNFINISHED	(-1)
+#define CAP_POSITION	(-2)
+
+typedef struct MatchState {
+  const l_char *src_init;  /* init of source string */
+  const l_char *src_end;  /* end (`\0') of source string */
   int level;  /* total number of captures (finished or unfinished) */
   struct {
-    const char *init;
-    int len;  /* -1 signals unfinished capture */
+    const l_char *init;
+    sint32 len;
   } capture[MAX_CAPTURES];
-};
+  lua_State *L;
+} MatchState;
 
 
-#define ESC		'%'
-#define SPECIALS	"^$*+?.([%-"
+#define ESC		l_c('%')
+#define SPECIALS	l_s("^$*+?.([%-")
 
 
-static void push_captures (lua_State *L, struct Capture *cap) {
-  int i;
-  for (i=0; i<cap->level; i++) {
-    int l = cap->capture[i].len;
-    if (l == -1) lua_error(L, "unfinished capture");
-    lua_pushlstring(L, cap->capture[i].init, l);
-  }
-}
-
-
-static int check_capture (lua_State *L, int l, struct Capture *cap) {
-  l -= '1';
-  if (!(0 <= l && l < cap->level && cap->capture[l].len != -1))
-    lua_error(L, "invalid capture index");
+static int check_capture (MatchState *ms, int l) {
+  l -= l_c('1');
+  if (l < 0 || l >= ms->level || ms->capture[l].len == CAP_UNFINISHED)
+    lua_error(ms->L, l_s("invalid capture index"));
   return l;
 }
 
 
-static int capture_to_close (lua_State *L, struct Capture *cap) {
-  int level = cap->level;
+static int capture_to_close (MatchState *ms) {
+  int level = ms->level;
   for (level--; level>=0; level--)
-    if (cap->capture[level].len == -1) return level;
-  lua_error(L, "invalid pattern capture");
+    if (ms->capture[level].len == CAP_UNFINISHED) return level;
+  lua_error(ms->L, l_s("invalid pattern capture"));
   return 0;  /* to avoid warnings */
 }
 
 
-const char *luaI_classend (lua_State *L, const char *p) {
+static const l_char *luaI_classend (MatchState *ms, const l_char *p) {
   switch (*p++) {
     case ESC:
-      if (*p == '\0') lua_error(L, "malformed pattern (ends with `%')");
+      if (*p == l_c('\0'))
+        lua_error(ms->L, l_s("malformed pattern (ends with `%')"));
       return p+1;
-    case '[':
-      if (*p == '^') p++;
-      do {  /* look for a ']' */
-        if (*p == '\0') lua_error(L, "malformed pattern (missing `]')");
-        if (*(p++) == ESC && *p != '\0') p++;  /* skip escapes (e.g. '%]') */
-      } while (*p != ']');
+    case l_c('['):
+      if (*p == l_c('^')) p++;
+      do {  /* look for a `]' */
+        if (*p == l_c('\0'))
+          lua_error(ms->L, l_s("malformed pattern (missing `]')"));
+        if (*(p++) == ESC && *p != l_c('\0'))
+          p++;  /* skip escapes (e.g. `%]') */
+      } while (*p != l_c(']'));
       return p+1;
     default:
       return p;
@@ -180,77 +181,75 @@ const char *luaI_classend (lua_State *L, const char *p) {
 }
 
 
-static int match_class (int c, int cl) {
+static int match_class (l_char c, l_char cl) {
   int res;
-  switch (tolower(cl)) {
-    case 'a' : res = isalpha(c); break;
-    case 'c' : res = iscntrl(c); break;
-    case 'd' : res = isdigit(c); break;
-    case 'l' : res = islower(c); break;
-    case 'p' : res = ispunct(c); break;
-    case 's' : res = isspace(c); break;
-    case 'u' : res = isupper(c); break;
-    case 'w' : res = isalnum(c); break;
-    case 'x' : res = isxdigit(c); break;
-    case 'z' : res = (c == '\0'); break;
+  switch (tolower(uchar(cl))) {
+    case l_c('a') : res = isalpha(uchar(c)); break;
+    case l_c('c') : res = iscntrl(uchar(c)); break;
+    case l_c('d') : res = isdigit(uchar(c)); break;
+    case l_c('l') : res = islower(uchar(c)); break;
+    case l_c('p') : res = ispunct(uchar(c)); break;
+    case l_c('s') : res = isspace(uchar(c)); break;
+    case l_c('u') : res = isupper(uchar(c)); break;
+    case l_c('w') : res = isalnum(uchar(c)); break;
+    case l_c('x') : res = isxdigit(uchar(c)); break;
+    case l_c('z') : res = (c == l_c('\0')); break;
     default: return (cl == c);
   }
-  return (islower(cl) ? res : !res);
+  return (islower(uchar(cl)) ? res : !res);
 }
 
 
-
-static int matchbracketclass (int c, const char *p, const char *endclass) {
+static int matchbracketclass (l_char c, const l_char *p, const l_char *ec) {
   int sig = 1;
-  if (*(p+1) == '^') {
+  if (*(p+1) == l_c('^')) {
     sig = 0;
-    p++;  /* skip the '^' */
+    p++;  /* skip the `^' */
   }
-  while (++p < endclass) {
+  while (++p < ec) {
     if (*p == ESC) {
       p++;
-      if (match_class(c, (unsigned char)*p))
+      if (match_class(c, *p))
         return sig;
     }
-    else if ((*(p+1) == '-') && (p+2 < endclass)) {
+    else if ((*(p+1) == l_c('-')) && (p+2 < ec)) {
       p+=2;
-      if ((int)(unsigned char)*(p-2) <= c && c <= (int)(unsigned char)*p)
+      if (uchar(*(p-2)) <= uchar(c) && uchar(c) <= uchar(*p))
         return sig;
     }
-    else if ((int)(unsigned char)*p == c) return sig;
+    else if (*p == c) return sig;
   }
   return !sig;
 }
 
 
-
-int luaI_singlematch (int c, const char *p, const char *ep) {
+static int luaI_singlematch (l_char c, const l_char *p, const l_char *ep) {
   switch (*p) {
-    case '.':  /* matches any char */
+    case l_c('.'):  /* matches any char */
       return 1;
     case ESC:
-      return match_class(c, (unsigned char)*(p+1));
-    case '[':
+      return match_class(c, *(p+1));
+    case l_c('['):
       return matchbracketclass(c, p, ep-1);
     default:
-      return ((unsigned char)*p == c);
+      return (*p == c);
   }
 }
 
 
-static const char *match (lua_State *L, const char *s, const char *p, struct Capture *cap);
+static const l_char *match (MatchState *ms, const l_char *s, const l_char *p);
 
 
-static const char *matchbalance (lua_State *L, const char *s, const char *p,
-                                 struct Capture *cap) {
+static const l_char *matchbalance (MatchState *ms, const l_char *s,
+                                   const l_char *p) {
   if (*p == 0 || *(p+1) == 0)
-    lua_error(L, "unbalanced pattern");
+    lua_error(ms->L, l_s("unbalanced pattern"));
   if (*s != *p) return NULL;
   else {
     int b = *p;
     int e = *(p+1);
     int cont = 1;
-    while (++s < cap->src_end) {
+    while (++s < ms->src_end) {
       if (*s == e) {
         if (--cont == 0) return s+1;
       }
@@ -261,14 +260,14 @@ static const char *matchbalance (lua_State *L, const char *s, const char *p,
 }
 
 
-static const char *max_expand (lua_State *L, const char *s, const char *p, const char *ep,
-                         struct Capture *cap) {
-  int i = 0;  /* counts maximum expand for item */
-  while ((s+i)<cap->src_end && luaI_singlematch((unsigned char)*(s+i), p, ep))
+static const l_char *max_expand (MatchState *ms, const l_char *s,
+                                 const l_char *p, const l_char *ep) {
+  sint32 i = 0;  /* counts maximum expand for item */
+  while ((s+i)<ms->src_end && luaI_singlematch(*(s+i), p, ep))
     i++;
-  /* keeps trying to match mith the maximum repetitions */
+  /* keeps trying to match with the maximum repetitions */
   while (i>=0) {
-    const char *res = match(L, (s+i), ep+1, cap);
+    const l_char *res = match(ms, (s+i), ep+1);
     if (res) return res;
     i--;  /* else didn't match; reduce 1 repetition to try again */
   }
@@ -276,99 +275,102 @@ static const char *max_expand (lua_State *L, const char *s, const char *p, const
 }
 
 
-static const char *min_expand (lua_State *L, const char *s, const char *p, const char *ep,
-                         struct Capture *cap) {
+static const l_char *min_expand (MatchState *ms, const l_char *s,
+                                 const l_char *p, const l_char *ep) {
   for (;;) {
-    const char *res = match(L, s, ep+1, cap);
+    const l_char *res = match(ms, s, ep+1);
     if (res != NULL)
       return res;
-    else if (s<cap->src_end && luaI_singlematch((unsigned char)*s, p, ep))
+    else if (s<ms->src_end && luaI_singlematch(*s, p, ep))
       s++;  /* try with one more repetition */
     else return NULL;
   }
 }
 
 
-static const char *start_capture (lua_State *L, const char *s, const char *p,
-                                  struct Capture *cap) {
-  const char *res;
-  int level = cap->level;
-  if (level >= MAX_CAPTURES) lua_error(L, "too many captures");
-  cap->capture[level].init = s;
-  cap->capture[level].len = -1;
-  cap->level = level+1;
-  if ((res=match(L, s, p+1, cap)) == NULL)  /* match failed? */
-    cap->level--;  /* undo capture */
+static const l_char *start_capture (MatchState *ms, const l_char *s,
+                                    const l_char *p, int what) {
+  const l_char *res;
+  int level = ms->level;
+  if (level >= MAX_CAPTURES) lua_error(ms->L, l_s("too many captures"));
+  ms->capture[level].init = s;
+  ms->capture[level].len = what;
+  ms->level = level+1;
+  if ((res=match(ms, s, p)) == NULL)  /* match failed? */
+    ms->level--;  /* undo capture */
   return res;
 }
 
 
-static const char *end_capture (lua_State *L, const char *s, const char *p,
-                                struct Capture *cap) {
-  int l = capture_to_close(L, cap);
-  const char *res;
-  cap->capture[l].len = s - cap->capture[l].init;  /* close capture */
-  if ((res = match(L, s, p+1, cap)) == NULL)  /* match failed? */
-    cap->capture[l].len = -1;  /* undo capture */
+static const l_char *end_capture (MatchState *ms, const l_char *s,
+                                  const l_char *p) {
+  int l = capture_to_close(ms);
+  const l_char *res;
+  ms->capture[l].len = s - ms->capture[l].init;  /* close capture */
+  if ((res = match(ms, s, p)) == NULL)  /* match failed? */
+    ms->capture[l].len = CAP_UNFINISHED;  /* undo capture */
   return res;
 }
 
 
-static const char *match_capture (lua_State *L, const char *s, int level,
-                                  struct Capture *cap) {
-  int l = check_capture(L, level, cap);
-  int len = cap->capture[l].len;
-  if (cap->src_end-s >= len &&
-      memcmp(cap->capture[l].init, s, len) == 0)
+static const l_char *match_capture (MatchState *ms, const l_char *s, int l) {
+  size_t len;
+  l = check_capture(ms, l);
+  len = ms->capture[l].len;
+  if ((size_t)(ms->src_end-s) >= len &&
+      memcmp(ms->capture[l].init, s, len) == 0)
     return s+len;
   else return NULL;
 }
 
 
-static const char *match (lua_State *L, const char *s, const char *p, struct Capture *cap) {
+static const l_char *match (MatchState *ms, const l_char *s, const l_char *p) {
   init: /* using goto's to optimize tail recursion */
   switch (*p) {
-    case '(':  /* start capture */
-      return start_capture(L, s, p, cap);
-    case ')':  /* end capture */
-      return end_capture(L, s, p, cap);
+    case l_c('('):  /* start capture */
+      if (*(p+1) == l_c(')'))  /* position capture? */
+        return start_capture(ms, s, p+2, CAP_POSITION);
+      else
+        return start_capture(ms, s, p+1, CAP_UNFINISHED);
+    case l_c(')'):  /* end capture */
+      return end_capture(ms, s, p+1);
     case ESC:  /* may be %[0-9] or %b */
-      if (isdigit((unsigned char)(*(p+1)))) {  /* capture? */
-        s = match_capture(L, s, *(p+1), cap);
+      if (isdigit(uchar(*(p+1)))) {  /* capture? */
+        s = match_capture(ms, s, *(p+1));
         if (s == NULL) return NULL;
-        p+=2; goto init;  /* else return match(L, s, p+2, cap) */
+        p+=2; goto init;  /* else return match(ms, s, p+2) */
       }
-      else if (*(p+1) == 'b') {  /* balanced string? */
-        s = matchbalance(L, s, p+2, cap);
+      else if (*(p+1) == l_c('b')) {  /* balanced string? */
+        s = matchbalance(ms, s, p+2);
         if (s == NULL) return NULL;
-        p+=4; goto init;  /* else return match(L, s, p+4, cap); */
+        p+=4; goto init;  /* else return match(ms, s, p+4); */
       }
       else goto dflt;  /* case default */
-    case '\0':  /* end of pattern */
+    case l_c('\0'):  /* end of pattern */
       return s;  /* match succeeded */
-    case '$':
-      if (*(p+1) == '\0')  /* is the '$' the last char in pattern? */
-        return (s == cap->src_end) ? s : NULL;  /* check end of string */
+    case l_c('$'):
+      if (*(p+1) == l_c('\0'))  /* is the `$' the last char in pattern? */
+        return (s == ms->src_end) ? s : NULL;  /* check end of string */
       else goto dflt;
     default: dflt: {  /* it is a pattern item */
-      const char *ep = luaI_classend(L, p);  /* points to what is next */
-      int m = s<cap->src_end && luaI_singlematch((unsigned char)*s, p, ep);
+      const l_char *ep = luaI_classend(ms, p);  /* points to what is next */
+      int m = s<ms->src_end && luaI_singlematch(*s, p, ep);
       switch (*ep) {
-        case '?': {  /* optional */
-          const char *res;
-          if (m && ((res=match(L, s+1, ep+1, cap)) != NULL))
+        case l_c('?'): {  /* optional */
+          const l_char *res;
+          if (m && ((res=match(ms, s+1, ep+1)) != NULL))
             return res;
-          p=ep+1; goto init;  /* else return match(L, s, ep+1, cap); */
+          p=ep+1; goto init;  /* else return match(ms, s, ep+1); */
         }
-        case '*':  /* 0 or more repetitions */
-          return max_expand(L, s, p, ep, cap);
-        case '+':  /* 1 or more repetitions */
-          return (m ? max_expand(L, s+1, p, ep, cap) : NULL);
-        case '-':  /* 0 or more repetitions (minimum) */
-          return min_expand(L, s, p, ep, cap);
+        case l_c('*'):  /* 0 or more repetitions */
+          return max_expand(ms, s, p, ep);
+        case l_c('+'):  /* 1 or more repetitions */
+          return (m ? max_expand(ms, s+1, p, ep) : NULL);
+        case l_c('-'):  /* 0 or more repetitions (minimum) */
+          return min_expand(ms, s, p, ep);
         default:
           if (!m) return NULL;
-          s++; p=ep; goto init;  /* else return match(L, s+1, ep, cap); */
+          s++; p=ep; goto init;  /* else return match(ms, s+1, ep); */
       }
     }
   }
@@ -376,13 +378,15 @@ static const char *match (lua_State *L, const char *s, const char *p, struct Cap
 
 
 
-static const char *memfind (const char *s1, long l1, const char *s2, long l2) {
-  if (l2 == 0) return s1;  /* empty strings are everywhere ;-) */
+static const l_char *lmemfind (const l_char *s1, size_t l1,
+                               const l_char *s2, size_t l2) {
+  if (l2 == 0) return s1;  /* empty strings are everywhere */
+  else if (l2 > l1) return NULL;  /* avoids a negative `l1' */
   else {
-    const char *init;  /* to search for a `*s2' inside `s1' */
+    const l_char *init;  /* to search for a `*s2' inside `s1' */
     l2--;  /* 1st char will be checked by `memchr' */
     l1 = l1-l2;  /* `s2' cannot be found after that */
-    while (l1 > 0 && (init = (const char *)memchr(s1, *s2, l1)) != NULL) {
+    while (l1 > 0 && (init = (const l_char *)memchr(s1, *s2, l1)) != NULL) {
       init++;   /* 1st char is already checked */
       if (memcmp(init, s2+1, l2) == 0)
         return init-1;
@@ -396,224 +400,262 @@ static const char *memfind (const char *s1, long l1, const char *s2, long l2) {
 }
 
 
-static void str_find (lua_State *L) {
-  long l1, l2;
-  const char *s = luaL_check_lstr(L, 1, &l1);
-  const char *p = luaL_check_lstr(L, 2, &l2);
-  long init = posrelat(luaL_opt_long(L, 3, 1), l1) - 1;
-  struct Capture cap;
-  luaL_arg_check(L, 0 <= init && init <= l1, 3, "out of range");
-  if (lua_getparam(L, 4) != LUA_NOOBJECT ||
-      strpbrk(p, SPECIALS) == NULL) {  /* no special characters? */
-    const char *s2 = memfind(s+init, l1, p, l2);
-    if (s2) {
-      lua_pushnumber(L, s2-s+1);
-      lua_pushnumber(L, s2-s+l2);
-      return;
-    }
-  }
-  else {
-    int anchor = (*p == '^') ? (p++, 1) : 0;
-    const char *s1=s+init;
-    cap.src_end = s+l1;
-    do {
-      const char *res;
-      cap.level = 0;
-      if ((res=match(L, s1, p, &cap)) != NULL) {
-        lua_pushnumber(L, s1-s+1);  /* start */
-        lua_pushnumber(L, res-s);   /* end */
-        push_captures(L, &cap);
-        return;
-      }
-    } while (s1++<cap.src_end && !anchor);
-  }
-  lua_pushnil(L);  /* not found */
+static void push_onecapture (MatchState *ms, int i) {
+  int l = ms->capture[i].len;
+  if (l == CAP_UNFINISHED) lua_error(ms->L, l_s("unfinished capture"));
+  if (l == CAP_POSITION)
+    lua_pushnumber(ms->L, ms->capture[i].init - ms->src_init + 1);
+  else
+    lua_pushlstring(ms->L, ms->capture[i].init, l);
 }
 
 
-static void add_s (lua_State *L, lua_Object newp, struct Capture *cap) {
-  if (lua_isstring(L, newp)) {
-    const char *news = lua_getstring(L, newp);
-    int l = lua_strlen(L, newp);
-    int i;
+static int push_captures (MatchState *ms) {
+  int i;
+  luaL_checkstack(ms->L, ms->level, l_s("too many captures"));
+  for (i=0; i<ms->level; i++)
+    push_onecapture(ms, i);
+  return ms->level;  /* number of strings pushed */
+}
+
+
+static int str_find (lua_State *L) {
+  size_t l1, l2;
+  const l_char *s = luaL_check_lstr(L, 1, &l1);
+  const l_char *p = luaL_check_lstr(L, 2, &l2);
+  sint32 init = posrelat(luaL_opt_long(L, 3, 1), l1) - 1;
+  luaL_arg_check(L, 0 <= init && (size_t)init <= l1, 3, l_s("out of range"));
+  if (lua_gettop(L) > 3 ||  /* extra argument? */
+      strpbrk(p, SPECIALS) == NULL) {  /* or no special characters? */
+    const l_char *s2 = lmemfind(s+init, l1-init, p, l2);
+    if (s2) {
+      lua_pushnumber(L, s2-s+1);
+      lua_pushnumber(L, s2-s+l2);
+      return 2;
+    }
+  }
+  else {
+    MatchState ms;
+    int anchor = (*p == l_c('^')) ? (p++, 1) : 0;
+    const l_char *s1=s+init;
+    ms.L = L;
+    ms.src_init = s;
+    ms.src_end = s+l1;
+    do {
+      const l_char *res;
+      ms.level = 0;
+      if ((res=match(&ms, s1, p)) != NULL) {
+        lua_pushnumber(L, s1-s+1);  /* start */
+        lua_pushnumber(L, res-s);   /* end */
+        return push_captures(&ms) + 2;
+      }
+    } while (s1++<ms.src_end && !anchor);
+  }
+  lua_pushnil(L);  /* not found */
+  return 1;
+}
+
+
+static void add_s (MatchState *ms, luaL_Buffer *b) {
+  lua_State *L = ms->L;
+  if (lua_isstring(L, 3)) {
+    const l_char *news = lua_tostring(L, 3);
+    size_t l = lua_strlen(L, 3);
+    size_t i;
     for (i=0; i<l; i++) {
       if (news[i] != ESC)
-        luaL_addchar(L, news[i]);
+        luaL_putchar(b, news[i]);
       else {
         i++;  /* skip ESC */
-        if (!isdigit((unsigned char)news[i]))
-          luaL_addchar(L, news[i]);
+        if (!isdigit(uchar(news[i])))
+          luaL_putchar(b, news[i]);
         else {
-          int level = check_capture(L, news[i], cap);
-          addnchar(L, cap->capture[level].init, cap->capture[level].len);
+          int level = check_capture(ms, news[i]);
+          push_onecapture(ms, level);
+          luaL_addvalue(b);  /* add capture to accumulated result */
         }
       }
     }
   }
   else {  /* is a function */
-    lua_Object res;
-    int status;
-    int oldbuff;
-    lua_beginblock(L);
-    push_captures(L, cap);
-    /* function may use buffer, so save it and create a new one */
-    oldbuff = luaL_newbuffer(L, 0);
-    status = lua_callfunction(L, newp);
-    /* restore old buffer */
-    luaL_oldbuffer(L, oldbuff);
-    if (status != 0) {
-      lua_endblock(L);
-      lua_error(L, NULL);
-    }
-    res = lua_getresult(L, 1);
-    if (lua_isstring(L, res))
-      addnchar(L, lua_getstring(L, res), lua_strlen(L, res));
-    lua_endblock(L);
+    int n;
+    lua_pushvalue(L, 3);
+    n = push_captures(ms);
+    lua_rawcall(L, n, 1);
+    if (lua_isstring(L, -1))
+      luaL_addvalue(b);  /* add return to accumulated result */
+    else
+      lua_pop(L, 1);  /* function result is not a string: pop it */
   }
 }
 
 
-static void str_gsub (lua_State *L) {
-  long srcl;
-  const char *src = luaL_check_lstr(L, 1, &srcl);
-  const char *p = luaL_check_string(L, 2);
-  lua_Object newp = lua_getparam(L, 3);
+static int str_gsub (lua_State *L) {
+  size_t srcl;
+  const l_char *src = luaL_check_lstr(L, 1, &srcl);
+  const l_char *p = luaL_check_string(L, 2);
   int max_s = luaL_opt_int(L, 4, srcl+1);
-  int anchor = (*p == '^') ? (p++, 1) : 0;
+  int anchor = (*p == l_c('^')) ? (p++, 1) : 0;
   int n = 0;
-  struct Capture cap;
-  luaL_arg_check(L, lua_isstring(L, newp) || lua_isfunction(L, newp), 3,
-                 "string or function expected");
-  luaL_resetbuffer(L);
-  cap.src_end = src+srcl;
+  MatchState ms;
+  luaL_Buffer b;
+  luaL_arg_check(L,
+    lua_gettop(L) >= 3 && (lua_isstring(L, 3) || lua_isfunction(L, 3)),
+    3, l_s("string or function expected"));
+  luaL_buffinit(L, &b);
+  ms.L = L;
+  ms.src_init = src;
+  ms.src_end = src+srcl;
   while (n < max_s) {
-    const char *e;
-    cap.level = 0;
-    e = match(L, src, p, &cap);
+    const l_char *e;
+    ms.level = 0;
+    e = match(&ms, src, p);
     if (e) {
       n++;
-      add_s(L, newp, &cap);
+      add_s(&ms, &b);
     }
     if (e && e>src) /* non empty match? */
       src = e;  /* skip it */
-    else if (src < cap.src_end)
-      luaL_addchar(L, *src++);
+    else if (src < ms.src_end)
+      luaL_putchar(&b, *src++);
     else break;
     if (anchor) break;
   }
-  addnchar(L, src, cap.src_end-src);
-  closeandpush(L);
+  luaL_addlstring(&b, src, ms.src_end-src);
+  luaL_pushresult(&b);
   lua_pushnumber(L, n);  /* number of substitutions */
+  return 2;
 }
 
 /* }====================================================== */
 
 
-static void luaI_addquoted (lua_State *L, int arg) {
-  long l;
-  const char *s = luaL_check_lstr(L, arg, &l);
-  luaL_addchar(L, '"');
+/* maximum size of each formatted item (> len(format('%99.99f', -1e308))) */
+#define MAX_ITEM	512
+/* maximum size of each format specification (such as '%-099.99d') */
+#define MAX_FORMAT	20
+
+
+static void luaI_addquoted (lua_State *L, luaL_Buffer *b, int arg) {
+  size_t l;
+  const l_char *s = luaL_check_lstr(L, arg, &l);
+  luaL_putchar(b, l_c('"'));
   while (l--) {
     switch (*s) {
-      case '"':  case '\\':  case '\n':
-        luaL_addchar(L, '\\');
-        luaL_addchar(L, *s);
+      case l_c('"'):  case l_c('\\'):  case l_c('\n'):
+        luaL_putchar(b, l_c('\\'));
+        luaL_putchar(b, *s);
         break;
-      case '\0': addnchar(L, "\\000", 4); break;
-      default: luaL_addchar(L, *s);
+      case l_c('\0'): luaL_addlstring(b, l_s("\\000"), 4); break;
+      default: luaL_putchar(b, *s);
     }
     s++;
   }
-  luaL_addchar(L, '"');
+  luaL_putchar(b, l_c('"'));
 }
 
-/* maximum size of each format specification (such as '%-099.99d') */
-#define MAX_FORMAT 20  /* arbitrary limit */
 
-static void str_format (lua_State *L) {
+static const l_char *scanformat (lua_State *L, const l_char *strfrmt,
+                                 l_char *form, int *hasprecision) {
+  const l_char *p = strfrmt;
+  while (strchr(l_s("-+ #0"), *p)) p++;  /* skip flags */
+  if (isdigit(uchar(*p))) p++;  /* skip width */
+  if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
+  if (*p == l_c('.')) {
+    p++;
+    *hasprecision = 1;
+    if (isdigit(uchar(*p))) p++;  /* skip precision */
+    if (isdigit(uchar(*p))) p++;  /* (2 digits at most) */
+  }
+  if (isdigit(uchar(*p)))
+    lua_error(L, l_s("invalid format (width or precision too long)"));
+  if (p-strfrmt+2 > MAX_FORMAT)  /* +2 to include `%' and the specifier */
+    lua_error(L, l_s("invalid format (too long)"));
+  form[0] = l_c('%');
+  strncpy(form+1, strfrmt, p-strfrmt+1);
+  form[p-strfrmt+2] = 0;
+  return p;
+}
+
+
+static int str_format (lua_State *L) {
   int arg = 1;
-  const char *strfrmt = luaL_check_string(L, arg);
-  luaL_resetbuffer(L);
-  while (*strfrmt) {
-    if (*strfrmt != '%')
-      luaL_addchar(L, *strfrmt++);
-    else if (*++strfrmt == '%')
-      luaL_addchar(L, *strfrmt++);  /* %% */
+  size_t sfl;
+  const l_char *strfrmt = luaL_check_lstr(L, arg, &sfl);
+  const l_char *strfrmt_end = strfrmt+sfl;
+  luaL_Buffer b;
+  luaL_buffinit(L, &b);
+  while (strfrmt < strfrmt_end) {
+    if (*strfrmt != l_c('%'))
+      luaL_putchar(&b, *strfrmt++);
+    else if (*++strfrmt == l_c('%'))
+      luaL_putchar(&b, *strfrmt++);  /* %% */
     else { /* format item */
-      struct Capture cap;
-      char form[MAX_FORMAT];  /* to store the format ('%...') */
-      char *buff;  /* to store the formatted item */
-      const char *initf = strfrmt;
-      form[0] = '%';
-      if (isdigit((unsigned char)*initf) && *(initf+1) == '$') {
-        arg = *initf - '0';
-        initf += 2;  /* skip the 'n$' */
-      }
+      l_char form[MAX_FORMAT];  /* to store the format (`%...') */
+      l_char buff[MAX_ITEM];  /* to store the formatted item */
+      int hasprecision = 0;
+      if (isdigit(uchar(*strfrmt)) && *(strfrmt+1) == l_c('$'))
+        lua_error(L, l_s("obsolete `format' option (d$)"));
       arg++;
-      cap.src_end = strfrmt+strlen(strfrmt)+1;
-      cap.level = 0;
-      strfrmt = match(L, initf, "[-+ #0]*(%d*)%.?(%d*)", &cap);
-      if (cap.capture[0].len > 2 || cap.capture[1].len > 2 ||  /* < 100? */
-          strfrmt-initf > MAX_FORMAT-2)
-        lua_error(L, "invalid format (width or precision too long)");
-      strncpy(form+1, initf, strfrmt-initf+1); /* +1 to include conversion */
-      form[strfrmt-initf+2] = 0;
-      buff = luaL_openspace(L, 512);  /* 512 > len(format('%99.99f', -1e308)) */
+      strfrmt = scanformat(L, strfrmt, form, &hasprecision);
       switch (*strfrmt++) {
-        case 'c':  case 'd':  case 'i':
+        case l_c('c'):  case l_c('d'):  case l_c('i'):
           sprintf(buff, form, luaL_check_int(L, arg));
           break;
-        case 'o':  case 'u':  case 'x':  case 'X':
+        case l_c('o'):  case l_c('u'):  case l_c('x'):  case l_c('X'):
           sprintf(buff, form, (unsigned int)luaL_check_number(L, arg));
           break;
-        case 'e':  case 'E': case 'f': case 'g': case 'G':
+        case l_c('e'):  case l_c('E'): case l_c('f'):
+        case l_c('g'): case l_c('G'):
           sprintf(buff, form, luaL_check_number(L, arg));
           break;
-        case 'q':
-          luaI_addquoted(L, arg);
-          continue;  /* skip the "addsize" at the end */
-        case 's': {
-          long l;
-          const char *s = luaL_check_lstr(L, arg, &l);
-          if (cap.capture[1].len == 0 && l >= 100) {
+        case l_c('q'):
+          luaI_addquoted(L, &b, arg);
+          continue;  /* skip the `addsize' at the end */
+        case l_c('s'): {
+          size_t l;
+          const l_char *s = luaL_check_lstr(L, arg, &l);
+          if (!hasprecision && l >= 100) {
             /* no precision and string is too long to be formatted;
                keep original string */
-            addnchar(L, s, l);
-            continue;  /* skip the "addsize" at the end */
+            lua_pushvalue(L, arg);
+            luaL_addvalue(&b);
+            continue;  /* skip the `addsize' at the end */
           }
           else {
             sprintf(buff, form, s);
             break;
           }
         }
-        default:  /* also treat cases 'pnLlh' */
-          lua_error(L, "invalid option in `format'");
+        default:  /* also treat cases `pnLlh' */
+          lua_error(L, l_s("invalid option in `format'"));
       }
-      luaL_addsize(L, strlen(buff));
+      luaL_addlstring(&b, buff, strlen(buff));
     }
   }
-  closeandpush(L);  /* push the result */
+  luaL_pushresult(&b);
+  return 1;
 }
 
 
-static const struct luaL_reg strlib[] = {
-{"strlen", str_len},
-{"strsub", str_sub},
-{"strlower", str_lower},
-{"strupper", str_upper},
-{"strchar", str_char},
-{"strrep", str_rep},
-{"ascii", str_byte},  /* for compatibility with 3.0 and earlier */
-{"strbyte", str_byte},
-{"format", str_format},
-{"strfind", str_find},
-{"gsub", str_gsub}
+static const luaL_reg strlib[] = {
+{l_s("strlen"), str_len},
+{l_s("strsub"), str_sub},
+{l_s("strlower"), str_lower},
+{l_s("strupper"), str_upper},
+{l_s("strchar"), str_char},
+{l_s("strrep"), str_rep},
+{l_s("strbyte"), str_byte},
+{l_s("format"), str_format},
+{l_s("strfind"), str_find},
+{l_s("gsub"), str_gsub}
 };
 
 
 /*
 ** Open string library
 */
-void lua_strlibopen (lua_State *L) {
+LUALIB_API int lua_strlibopen (lua_State *L) {
   luaL_openl(L, strlib);
+  return 0;
 }

ltable.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.c,v 1.38 2000/03/29 20:19:20 roberto Exp roberto $
+** $Id: ltable.c,v 1.82 2001/06/26 13:20:45 roberto Exp roberto $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -18,175 +18,177 @@
 */
 
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
-#include "lauxlib.h"
+#include "ldo.h"
 #include "lmem.h"
 #include "lobject.h"
 #include "lstate.h"
 #include "ltable.h"
-#include "lua.h"
-
-
-#define gcsize(L, n)	numblocks(L, n*2, sizeof(Hash))
 
 
 
-#define TagDefault TAG_TABLE
+#define TagDefault LUA_TTABLE
 
 
+#define hashnum(t,n)		(node(t, lmod((lu_hash)(ls_hash)(n), t->size)))
+#define hashstr(t,str)		(node(t, lmod((str)->tsv.hash, t->size)))
+#define hashpointer(t,p)	(node(t, lmod(IntPoint(p), t->size)))
+
 
 /*
 ** returns the `main' position of an element in a table (that is, the index
 ** of its hash value)
 */
 Node *luaH_mainposition (const Hash *t, const TObject *key) {
-  unsigned long h;
   switch (ttype(key)) {
-    case TAG_NUMBER:
-      h = (unsigned long)(long)nvalue(key);
-      break;
-    case TAG_STRING: case TAG_USERDATA:
-      h = tsvalue(key)->hash;
-      break;
-    case TAG_TABLE:
-      h = IntPoint(L, avalue(key));
-      break;
-    case TAG_LCLOSURE:  case TAG_CCLOSURE:
-      h = IntPoint(L, clvalue(key));
-      break;
-    default:
-      return NULL;  /* invalid key */
+    case LUA_TNUMBER:
+      return hashnum(t, nvalue(key));
+    case LUA_TSTRING:
+      return hashstr(t, tsvalue(key));
+    default:  /* all other types are hashed as (void *) */
+      return hashpointer(t, tsvalue(key));
   }
-  LUA_ASSERT(L, h%(unsigned int)t->size == (h&((unsigned int)t->size-1)),
-            "a&(x-1) == a%x, for x power of 2");
-  return &t->node[h&((unsigned int)t->size-1)];
 }
 
 
-const TObject *luaH_get (lua_State *L, const Hash *t, const TObject *key) {
-  Node *n = luaH_mainposition(t, key);
-  if (!n)
-    lua_error(L, "unexpected type to index table");
-  else do {
-    if (luaO_equalObj(key, &n->key))
-      return &n->val;
-    n = n->next;
-  } while (n);
-  return &luaO_nilobject;  /* key not found */
-}
-
-
-int luaH_pos (lua_State *L, const Hash *t, const TObject *key) {
-  const TObject *v = luaH_get(L, t, key);
-  return (v == &luaO_nilobject) ?  -1 :  /* key not found */
-      (int)(((const char *)v - (const char *)(&t->node[0].val))/sizeof(Node));
-}
-
-
-
-static Node *hashnodecreate (lua_State *L, int nhash) {
-  Node *v = luaM_newvector(L, nhash, Node);
+Node *luaH_next (lua_State *L, Hash *t, const TObject *key) {
   int i;
-  for (i=0; i<nhash; i++) {
-    ttype(&v[i].key) = ttype(&v[i].val) = TAG_NIL;
-    v[i].next = NULL;
+  if (ttype(key) == LUA_TNIL)
+    i = 0;  /* first iteration */
+  else {
+    const TObject *v = luaH_get(t, key);
+    if (v == &luaO_nilobject)
+      luaD_error(L, l_s("invalid key for `next'"));
+    i = (int)(((const lu_byte *)v -
+               (const lu_byte *)(val(node(t, 0)))) / sizeof(Node)) + 1;
   }
-  return v;
+  for (; i<t->size; i++) {
+    Node *n = node(t, i);
+    if (ttype(val(n)) != LUA_TNIL)
+      return n;
+  }
+  return NULL;  /* no more elements */
+}
+
+
+int luaH_nexti (Hash *t, int i) {
+  while ((++i)<t->size) {
+    if (ttype(val(node(t, i))) != LUA_TNIL)  /* a non-nil value? */
+      return i;
+  }
+  return -1;  /* no more elements */
+}
+
+
+#define check_grow(L, p, n) \
+	if ((p) >= MAX_INT/(n)) luaD_error(L, l_s("table overflow"));
+
+/*
+** returns smaller power of 2 larger than `n' (minimum is MINPOWER2) 
+*/
+static int power2 (lua_State *L, int n) {
+  int p = MINPOWER2;
+  while (p <= n) {
+    check_grow(L, p, 2);
+    p *= 2;
+  }
+  return p;
 }
 
 
 static void setnodevector (lua_State *L, Hash *t, int size) {
-  t->node = hashnodecreate(L, size);
+  int i;
+  t->node = luaM_newvector(L, size, Node);
+  for (i=0; i<size; i++) {
+    t->node[i].next = NULL;
+    setnilvalue(key(node(t, i)));
+    setnilvalue(val(node(t, i)));
+  }
   t->size = size;
-  t->firstfree = &t->node[size-1];  /* first free position to be used */
-  L->nblocks += gcsize(L, size);
+  t->firstfree = node(t, size-1);  /* first free position to be used */
 }
 
 
 Hash *luaH_new (lua_State *L, int size) {
   Hash *t = luaM_new(L, Hash);
-  setnodevector(L, t, luaO_power2(size));
   t->htag = TagDefault;
-  t->next = L->roottable;
-  L->roottable = t;
-  t->marked = 0;
+  t->next = G(L)->roottable;
+  G(L)->roottable = t;
+  t->mark = t;
+  t->size = 0;
+  t->weakmode = 0;
+  t->node = NULL;
+  setnodevector(L, t, power2(L, size));
   return t;
 }
 
 
 void luaH_free (lua_State *L, Hash *t) {
-  L->nblocks -= gcsize(L, t->size);
-  luaM_free(L, t->node);
-  luaM_free(L, t);
+  luaM_freearray(L, t->node, t->size, Node);
+  luaM_freelem(L, t, Hash);
 }
 
 
-static int newsize (const Hash *t) {
+static int numuse (const Hash *t) {
   Node *v = t->node;
   int size = t->size;
   int realuse = 0;
   int i;
   for (i=0; i<size; i++) {
-    if (ttype(&v[i].val) != TAG_NIL)
+    if (ttype(&v[i].val) != LUA_TNIL)
       realuse++;
   }
-  return luaO_power2(realuse+realuse/4+1);
+  return realuse;
 }
 
 
 static void rehash (lua_State *L, Hash *t) {
   int oldsize = t->size;
   Node *nold = t->node;
+  int nelems = numuse(t);
   int i;
-  L->nblocks -= gcsize(L, oldsize);
-  setnodevector(L, t, newsize(t));  /* create new array of nodes */
+  lua_assert(nelems<=oldsize);
+  if (nelems >= oldsize-oldsize/4) {  /* using more than 3/4? */
+    check_grow(L, oldsize, 2);
+    setnodevector(L, t, oldsize*2);  /* grow array */
+  }
+  else if (nelems <= oldsize/4 &&  /* less than 1/4? */
+           oldsize > MINPOWER2)
+    setnodevector(L, t, oldsize/2);  /* shrink array */
+  else
+    setnodevector(L, t, oldsize);  /* just rehash; keep the same size */
   for (i=0; i<oldsize; i++) {
     Node *old = nold+i;
-    if (ttype(&old->val) != TAG_NIL)
-       luaH_set(L, t, &old->key, &old->val);
+    if (ttype(val(old)) != LUA_TNIL) {
+      TObject *v = luaH_set(L, t, key(old));
+      setobj(v, val(old));
+    }
   }
-  luaM_free(L, nold);  /* free old array */
+  luaM_freearray(L, nold, oldsize, Node);  /* free old array */
 }
 
 
 /*
-** sets a pair key-value in a hash table; first, check whether key is
-** already present; if not, check whether key's main position is free;
-** if not, check whether colliding node is in its main position or not;
-** if it is not, move colliding node to an empty place and put new pair
-** in its main position; otherwise (colliding node is in its main position),
-** new pair goes to an empty position.
-** Tricky point: the only place where an old element is moved is when
-** we move the colliding node to an empty place; nevertheless, its old
-** value is still in that position until we set the value for the new
-** pair; therefore, even when `val' points to an element of this table
-** (this happens when we use `luaH_move'), there is no problem.
+** inserts a new key into a hash table; first, check whether key's main 
+** position is free. If not, check whether colliding node is in its main 
+** position or not: if it is not, move colliding node to an empty place and 
+** put new key in its main position; otherwise (colliding node is in its main 
+** position), new key goes to an empty position. 
 */
-void luaH_set (lua_State *L, Hash *t, const TObject *key, const TObject *val) {
+static TObject *newkey (lua_State *L, Hash *t, const TObject *key) {
   Node *mp = luaH_mainposition(t, key);
-  Node *n = mp;
-  if (!mp)
-    lua_error(L, "unexpected type to index table");
-  do {  /* check whether `key' is somewhere in the chain */
-    if (luaO_equalObj(key, &n->key)) {
-      n->val = *val;  /* update value */
-      return;  /* that's all */
-    }
-    else n = n->next;
-  } while (n);
-  /* `key' not found; must insert it */
-  if (ttype(&mp->key) != TAG_NIL) {  /* main position is not free? */
-    Node *othern;  /* main position of colliding node */
-    n = t->firstfree;  /* get a free place */
-    /* is colliding node out of its main position? (can only happens if
-       its position if after "firstfree") */
-    if (mp > n && (othern=luaH_mainposition(t, &mp->key)) != mp) {
+  if (ttype(val(mp)) != LUA_TNIL) {  /* main position is not free? */
+    Node *othern = luaH_mainposition(t, key(mp));  /* `mp' of colliding node */
+    Node *n = t->firstfree;  /* get a free place */
+    if (othern != mp) {  /* is colliding node out of its main position? */
       /* yes; move colliding node into free position */
       while (othern->next != mp) othern = othern->next;  /* find previous */
       othern->next = n;  /* redo the chain with `n' in place of `mp' */
       *n = *mp;  /* copy colliding node into free pos. (mp->next also goes) */
       mp->next = NULL;  /* now `mp' is free */
+      setnilvalue(val(mp));
     }
     else {  /* colliding node is in its own main position */
       /* new node will go into free position */
@@ -195,30 +197,106 @@ void luaH_set (lua_State *L, Hash *t, const TObject *key, const TObject *val) {
       mp = n;
     }
   }
-  mp->key = *key;
-  mp->val = *val;
-  for (;;) {  /* check free places */
-    if (ttype(&t->firstfree->key) == TAG_NIL)
-      return;  /* OK; table still has a free place */
+  setobj(key(mp), key);
+  lua_assert(ttype(val(mp)) == LUA_TNIL);
+  for (;;) {  /* correct `firstfree' */
+    if (ttype(key(t->firstfree)) == LUA_TNIL)
+      return val(mp);  /* OK; table still has a free place */
     else if (t->firstfree == t->node) break;  /* cannot decrement from here */
     else (t->firstfree)--;
   }
   rehash(L, t);  /* no more free places */
+  return luaH_set(L, t, key);  /* `rehash' invalidates this insertion */
 }
 
 
-void luaH_setint (lua_State *L, Hash *t, int key, const TObject *val) {
-  TObject index;
-  ttype(&index) = TAG_NUMBER;
-  nvalue(&index) = key;
-  luaH_set(L, t, &index, val);
+/*
+** generic search function
+*/
+static const TObject *luaH_getany (Hash *t, const TObject *key) {
+  if (ttype(key) == LUA_TNIL) return &luaO_nilobject;
+  else {
+    Node *n = luaH_mainposition(t, key);
+    do {  /* check whether `key' is somewhere in the chain */
+      if (luaO_equalObj(key(n), key)) return val(n);  /* that's it */
+      else n = n->next;
+    } while (n);
+    return &luaO_nilobject;
+  }
 }
 
 
-const TObject *luaH_getint (lua_State *L, const Hash *t, int key) {
-  TObject index;
-  ttype(&index) = TAG_NUMBER;
-  nvalue(&index) = key;
-  return luaH_get(L, t, &index);
+/*
+** search function for integers
+*/
+const TObject *luaH_getnum (Hash *t, int key) {
+  Node *n = hashnum(t, key);
+  do {  /* check whether `key' is somewhere in the chain */
+    if (ttype(key(n)) == LUA_TNUMBER && nvalue(key(n)) == (lua_Number)key)
+      return val(n);  /* that's it */
+    else n = n->next;
+  } while (n);
+  return &luaO_nilobject;
+}
+
+
+/*
+** search function for strings
+*/
+const TObject *luaH_getstr (Hash *t, TString *key) {
+  Node *n = hashstr(t, key);
+  do {  /* check whether `key' is somewhere in the chain */
+    if (ttype(key(n)) == LUA_TSTRING && tsvalue(key(n)) == key)
+      return val(n);  /* that's it */
+    else n = n->next;
+  } while (n);
+  return &luaO_nilobject;
+}
+
+
+/*
+** main search function
+*/
+const TObject *luaH_get (Hash *t, const TObject *key) {
+  switch (ttype(key)) {
+    case LUA_TSTRING: return luaH_getstr(t, tsvalue(key));
+    case LUA_TNUMBER: {
+      int k = (int)nvalue(key);
+      if ((lua_Number)k == nvalue(key))  /* is an integer index? */
+        return luaH_getnum(t, k);  /* use specialized version */
+      /* else go through */
+    }
+    default: return luaH_getany(t, key);
+  }
+}
+
+
+TObject *luaH_set (lua_State *L, Hash *t, const TObject *key) {
+  const TObject *p = luaH_get(t, key);
+  if (p != &luaO_nilobject) return (TObject *)p;
+  else if (ttype(key) == LUA_TNIL) luaD_error(L, l_s("table index is nil"));
+  return newkey(L, t, key);
+}
+
+
+TObject *luaH_setstr (lua_State *L, Hash *t, TString *key) {
+  const TObject *p = luaH_getstr(t, key);
+  if (p != &luaO_nilobject) return (TObject *)p;
+  else {
+    TObject k;
+    setsvalue(&k, key);
+    return newkey(L, t, &k);
+  }
+}
+
+
+TObject *luaH_setnum (lua_State *L, Hash *t, int key) {
+  const TObject *p = luaH_getnum(t, key);
+  if (p != &luaO_nilobject) return (TObject *)p;
+  else {
+    TObject k;
+    setnvalue(&k, key);
+    return newkey(L, t, &k);
+  }
 }
 

ltable.h

@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.h,v 1.17 1999/11/23 13:58:02 roberto Exp roberto $
+** $Id: ltable.h,v 1.33 2001/06/26 13:20:45 roberto Exp roberto $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -10,20 +10,20 @@
 #include "lobject.h"
 
 
-#define node(t,i)	(&(t)->node[i])
-#define key(n)		(&(n)->key)
-#define val(n)		(&(n)->val)
-
-#define luaH_move(L, t,from,to)	(luaH_setint(L, t, to, luaH_getint(L, t, from)))
+#define node(_t,_i)	(&(_t)->node[_i])
+#define key(_n)		(&(_n)->key)
+#define val(_n)		(&(_n)->val)
 
+const TObject *luaH_getnum (Hash *t, int key);
+TObject *luaH_setnum (lua_State *L, Hash *t, int key);
+const TObject *luaH_getstr (Hash *t, TString *key);
+TObject *luaH_setstr (lua_State *L, Hash *t, TString *key);
+const TObject *luaH_get (Hash *t, const TObject *key);
+TObject *luaH_set (lua_State *L, Hash *t, const TObject *key);
 Hash *luaH_new (lua_State *L, int nhash);
 void luaH_free (lua_State *L, Hash *t);
-const TObject *luaH_get (lua_State *L, const Hash *t, const TObject *key);
-void luaH_set (lua_State *L, Hash *t, const TObject *key, const TObject *val);
-int luaH_pos (lua_State *L, const Hash *t, const TObject *r);
-void luaH_setint (lua_State *L, Hash *t, int key, const TObject *val);
-const TObject *luaH_getint (lua_State *L, const Hash *t, int key);
-unsigned long luaH_hash (lua_State *L, const TObject *key);
+Node *luaH_next (lua_State *L, Hash *t, const TObject *r);
+int luaH_nexti (Hash *t, int i);
 
 /* exported only for debugging */
 Node *luaH_mainposition (const Hash *t, const TObject *key);

ltests.c

@@ -1,46 +1,137 @@
 /*
-** $Id: ltests.c,v 1.15 2000/04/13 16:51:01 roberto Exp roberto $
+** $Id: ltests.c,v 1.87 2001/07/05 20:31:14 roberto Exp roberto $
 ** Internal Module for Debugging of the Lua Implementation
 ** See Copyright Notice in lua.h
 */
 
 
 #include <ctype.h>
+#include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#define LUA_REENTRANT
+
+#define LUA_PRIVATE
+#include "lua.h"
 
 #include "lapi.h"
 #include "lauxlib.h"
+#include "lcode.h"
+#include "ldebug.h"
+#include "ldo.h"
+#include "lfunc.h"
 #include "lmem.h"
 #include "lopcodes.h"
 #include "lstate.h"
 #include "lstring.h"
 #include "ltable.h"
-#include "lua.h"
 #include "luadebug.h"
+#include "lualib.h"
 
 
-void luaB_opentests (lua_State *L);
-
 
 /*
-** The whole module only makes sense with DEBUG on
+** The whole module only makes sense with LUA_DEBUG on
 */
-#ifdef DEBUG
+#ifdef LUA_DEBUG
+
+
+lua_State *lua_state = NULL;
+
+int islocked = 0;
 
 
 
-static void setnameval (lua_State *L, lua_Object t, const char *name, int val) {
-  lua_pushobject(L, t);
+static void setnameval (lua_State *L, const l_char *name, int val) {
   lua_pushstring(L, name);
   lua_pushnumber(L, val);
-  lua_settable(L);
+  lua_settable(L, -3);
 }
 
 
+/*
+** {======================================================================
+** Controlled version for realloc.
+** =======================================================================
+*/
+
+
+/* ensures maximum alignment for HEADER */
+#define HEADER	(sizeof(union L_Umaxalign))
+
+#define MARKSIZE	32
+#define MARK		0x55  /* 01010101 (a nice pattern) */
+
+
+#define blocksize(b)	((size_t *)((l_char *)(b) - HEADER))
+
+unsigned long memdebug_numblocks = 0;
+unsigned long memdebug_total = 0;
+unsigned long memdebug_maxmem = 0;
+unsigned long memdebug_memlimit = ULONG_MAX;
+
+
+static void *checkblock (void *block) {
+  size_t *b = blocksize(block);
+  size_t size = *b;
+  int i;
+  for (i=0;i<MARKSIZE;i++)
+    lua_assert(*(((l_char *)b)+HEADER+size+i) == MARK+i);  /* corrupted block? */
+  return b;
+}
+
+
+static void freeblock (void *block) {
+  if (block) {
+    size_t size = *blocksize(block);
+    block = checkblock(block);
+    memset(block, -1, size+HEADER+MARKSIZE);  /* erase block */
+    free(block);  /* free original block */
+    memdebug_numblocks--;
+    memdebug_total -= size;
+  }
+}
+
+
+void *debug_realloc (void *block, size_t oldsize, size_t size) {
+  lua_assert((oldsize == 0) ? block == NULL : oldsize == *blocksize(block));
+  if (size == 0) {
+    freeblock(block);
+    return NULL;
+  }
+  else if (memdebug_total+size-oldsize > memdebug_memlimit)
+    return NULL;  /* to test memory allocation errors */
+  else {
+    l_char *newblock;
+    int i;
+    size_t realsize = HEADER+size+MARKSIZE;
+    if (realsize < size) return NULL;  /* overflow! */
+    newblock = (l_char *)malloc(realsize);  /* alloc a new block */
+    if (newblock == NULL) return NULL;
+    if (oldsize > size) oldsize = size;
+    if (block) {
+      memcpy(newblock+HEADER, block, oldsize);
+      freeblock(block);  /* erase (and check) old copy */
+    }
+    /* initialize new part of the block with something `weird' */
+    memset(newblock+HEADER+oldsize, -MARK, size-oldsize);
+    memdebug_total += size;
+    if (memdebug_total > memdebug_maxmem)
+      memdebug_maxmem = memdebug_total;
+    memdebug_numblocks++;
+    *(size_t *)newblock = size;
+    for (i=0;i<MARKSIZE;i++)
+      *(newblock+HEADER+size+i) = (l_char)(MARK+i);
+    return newblock+HEADER;
+  }
+}
+
+
+/* }====================================================================== */
+
+
+
 /*
 ** {======================================================
 ** Disassembler
@@ -48,351 +139,491 @@ static void setnameval (lua_State *L, lua_Object t, const char *name, int val) {
 */
 
 
-#define O(o)	sprintf(buff, "%s", o)
-#define U(o)	sprintf(buff, "%-12s%4u", o, GETARG_U(i))
-#define S(o)	sprintf(buff, "%-12s%4d", o, GETARG_S(i))
-#define AB(o)	sprintf(buff, "%-12s%4d %4d", o, GETARG_A(i), GETARG_B(i))
-
-
-
-static int pushop (lua_State *L, Instruction i) {
-  char buff[100];
-  switch (GET_OPCODE(i)) {
-    case OP_END: O("END"); lua_pushstring(L, buff); return 0;
-    case OP_RETURN: U("RETURN"); break;
-    case OP_CALL: AB("CALL"); break;
-    case OP_TAILCALL: AB("TAILCALL"); break;
-    case OP_PUSHNIL: U("PUSHNIL"); break;
-    case OP_POP: U("POP"); break;
-    case OP_PUSHINT: S("PUSHINT"); break;
-    case OP_PUSHSTRING: U("PUSHSTRING"); break;
-    case OP_PUSHNUM: U("PUSHNUM"); break;
-    case OP_PUSHNEGNUM: U("PUSHNEGNUM"); break;
-    case OP_PUSHUPVALUE: U("PUSHUPVALUE"); break;
-    case OP_GETLOCAL: U("GETLOCAL"); break;
-    case OP_GETGLOBAL: U("GETGLOBAL"); break;
-    case OP_GETTABLE: O("GETTABLE"); break;
-    case OP_GETDOTTED: U("GETDOTTED"); break;
-    case OP_GETINDEXED: U("GETINDEXED"); break;
-    case OP_PUSHSELF: U("PUSHSELF"); break;
-    case OP_CREATETABLE: U("CREATETABLE"); break;
-    case OP_SETLOCAL: U("SETLOCAL"); break;
-    case OP_SETGLOBAL: U("SETGLOBAL"); break;
-    case OP_SETTABLE: AB("SETTABLE"); break;
-    case OP_SETLIST: AB("SETLIST"); break;
-    case OP_SETMAP: U("SETMAP"); break;
-    case OP_ADD: O("ADD"); break;
-    case OP_ADDI: S("ADDI"); break;
-    case OP_SUB: O("SUB"); break;
-    case OP_MULT: O("MULT"); break;
-    case OP_DIV: O("DIV"); break;
-    case OP_POW: O("POW"); break;
-    case OP_CONCAT: U("CONCAT"); break;
-    case OP_MINUS: O("MINUS"); break;
-    case OP_NOT: O("NOT"); break;
-    case OP_JMPNE: S("JMPNE"); break;
-    case OP_JMPEQ: S("JMPEQ"); break;
-    case OP_JMPLT: S("JMPLT"); break;
-    case OP_JMPLE: S("JMPLE"); break;
-    case OP_JMPGT: S("JMPGT"); break;
-    case OP_JMPGE: S("JMPGE"); break;
-    case OP_JMPT: S("JMPT"); break;
-    case OP_JMPF: S("JMPF"); break;
-    case OP_JMPONT: S("JMPONT"); break;
-    case OP_JMPONF: S("JMPONF"); break;
-    case OP_JMP: S("JMP"); break;
-    case OP_PUSHNILJMP: O("PUSHNILJMP"); break;
-    case OP_FORPREP: S("OP_FORPREP"); break;
-    case OP_FORLOOP: S("OP_FORLOOP"); break;
-    case OP_CLOSURE: AB("CLOSURE"); break;
-    case OP_SETLINE: U("SETLINE"); break;
+static l_char *buildop (Proto *p, int pc, l_char *buff) {
+  Instruction i = p->code[pc];
+  OpCode o = GET_OPCODE(i);
+  const l_char *name = luaP_opnames[o];
+  sprintf(buff, l_s("%4d - "), pc);
+  switch (getOpMode(o)) {  
+    case iABC:
+      sprintf(buff+strlen(buff), l_s("%-12s%4d %4d %4d"), name,
+              GETARG_A(i), GETARG_B(i), GETARG_C(i));
+      break;
+    case iABc:
+      sprintf(buff+strlen(buff), l_s("%-12s%4d %4d"), name, GETARG_A(i), GETARG_Bc(i));
+      break;
+    case iAsBc:
+      sprintf(buff+strlen(buff), l_s("%-12s%4d %4d"), name, GETARG_A(i), GETARG_sBc(i));
+      break;
+  }
+  return buff;
+}
+
+
+static int listcode (lua_State *L) {
+  int pc;
+  Proto *p;
+  luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
+                 1, l_s("Lua function expected"));
+  p = clvalue(luaA_index(L, 1))->f.l;
+  lua_newtable(L);
+  setnameval(L, l_s("maxstack"), p->maxstacksize);
+  setnameval(L, l_s("numparams"), p->numparams);
+  for (pc=0; pc<p->sizecode; pc++) {
+    l_char buff[100];
+    lua_pushnumber(L, pc+1);
+    lua_pushstring(L, buildop(p, pc, buff));
+    lua_settable(L, -3);
   }
-  lua_pushstring(L, buff);
   return 1;
 }
 
-static void listcode (lua_State *L) {
-  lua_Object o = luaL_nonnullarg(L, 1);
-  lua_Object t = lua_createtable(L);
-  Instruction *pc;
+
+static int listk (lua_State *L) {
   Proto *p;
-  int res;
-  luaL_arg_check(L, ttype(o) == TAG_LCLOSURE, 1, "Lua function expected");
-  p = clvalue(o)->f.l;
-  setnameval(L, t, "maxstack", p->maxstacksize);
-  setnameval(L, t, "numparams", p->numparams);
-  pc = p->code;
-  do {
-    lua_pushobject(L, t);
-    lua_pushnumber(L, pc - p->code + 1);
-    res = pushop(L, *pc++);
-    lua_settable(L);
-  } while (res);
-  lua_pushobject(L, t);
+  int i;
+  luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
+                 1, l_s("Lua function expected"));
+  p = clvalue(luaA_index(L, 1))->f.l;
+  lua_newtable(L);
+  for (i=0; i<p->sizek; i++) {
+    lua_pushnumber(L, i+1);
+    luaA_pushobject(L, p->k+i);
+    lua_settable(L, -3);
+  }
+  return 1;
+}
+
+
+static int listlocals (lua_State *L) {
+  Proto *p;
+  int pc = luaL_check_int(L, 2) - 1;
+  int i = 0;
+  const l_char *name;
+  luaL_arg_check(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
+                 1, l_s("Lua function expected"));
+  p = clvalue(luaA_index(L, 1))->f.l;
+  while ((name = luaF_getlocalname(p, ++i, pc)) != NULL)
+    lua_pushstring(L, name);
+  return i-1;
 }
 
 /* }====================================================== */
 
 
-
-static void get_limits (lua_State *L) {
-  lua_Object t = lua_createtable(L);
-  setnameval(L, t, "SIZE_OP", SIZE_OP);
-  setnameval(L, t, "SIZE_U", SIZE_U);
-  setnameval(L, t, "SIZE_A", SIZE_A);
-  setnameval(L, t, "SIZE_B", SIZE_B);
-  setnameval(L, t, "MAXARG_U", MAXARG_U);
-  setnameval(L, t, "MAXARG_S", MAXARG_S);
-  setnameval(L, t, "MAXARG_A", MAXARG_A);
-  setnameval(L, t, "MAXARG_B", MAXARG_B);
-  setnameval(L, t, "MAXSTACK", MAXSTACK);
-  setnameval(L, t, "MAXLOCALS", MAXLOCALS);
-  setnameval(L, t, "MAXUPVALUES", MAXUPVALUES);
-  setnameval(L, t, "MAXVARSLH", MAXVARSLH);
-  setnameval(L, t, "MAXPARAMS", MAXPARAMS);
-  setnameval(L, t, "LFPF", LFIELDS_PER_FLUSH);
-  setnameval(L, t, "RFPF", RFIELDS_PER_FLUSH);
-  lua_pushobject(L, t);
+static int pushbool (lua_State *L, int b) {
+  if (b) lua_pushnumber(L, 1);
+  else lua_pushnil(L);
+  return 1;
 }
 
 
-static void mem_query (lua_State *L) {
-  lua_pushnumber(L, memdebug_total);
-  lua_pushnumber(L, memdebug_numblocks);
-  lua_pushnumber(L, memdebug_maxmem);
+
+static int get_limits (lua_State *L) {
+  lua_newtable(L);
+  setnameval(L, l_s("BITS_INT"), BITS_INT);
+  setnameval(L, l_s("LFPF"), LFIELDS_PER_FLUSH);
+  setnameval(L, l_s("MAXLOCALS"), MAXLOCALS);
+  setnameval(L, l_s("MAXPARAMS"), MAXPARAMS);
+  setnameval(L, l_s("MAXSTACK"), MAXSTACK);
+  setnameval(L, l_s("MAXUPVALUES"), MAXUPVALUES);
+  return 1;
 }
 
 
-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) == TAG_STRING, 1, "string expected");
-    lua_pushnumber(L, tsvalue(o)->hash);
+static int mem_query (lua_State *L) {
+  if (lua_isnull(L, 1)) {
+    lua_pushnumber(L, memdebug_total);
+    lua_pushnumber(L, memdebug_numblocks);
+    lua_pushnumber(L, memdebug_maxmem);
+    return 3;
   }
   else {
-    const Hash *t = avalue(luaL_tablearg(L, 2));
-    lua_pushnumber(L, luaH_mainposition(t, o) - t->node);
+    memdebug_memlimit = luaL_check_int(L, 1);
+    return 0;
   }
 }
 
 
-static void table_query (lua_State *L) {
-  const Hash *t = avalue(luaL_tablearg(L, 1));
+static int hash_query (lua_State *L) {
+  if (lua_isnull(L, 2)) {
+    luaL_arg_check(L, lua_tag(L, 1) == LUA_TSTRING, 1, l_s("string expected"));
+    lua_pushnumber(L, tsvalue(luaA_index(L, 1))->tsv.hash);
+  }
+  else {
+    TObject *o = luaA_index(L, 1);
+    Hash *t;
+    luaL_checktype(L, 2, LUA_TTABLE);
+    t = hvalue(luaA_index(L, 2));
+    lua_pushnumber(L, luaH_mainposition(t, o) - t->node);
+  }
+  return 1;
+}
+
+
+static int table_query (lua_State *L) {
+  const Hash *t;
   int i = luaL_opt_int(L, 2, -1);
+  luaL_checktype(L, 1, LUA_TTABLE);
+  t = hvalue(luaA_index(L, 1));
   if (i == -1) {
     lua_pushnumber(L, t->size);
     lua_pushnumber(L, t->firstfree - t->node);
+    return 2;
   }
   else if (i < t->size) {
-    luaA_pushobject(L, &t->node[i].key);
+    if (ttype(val(node(t, i))) != LUA_TNIL ||
+        ttype(key(node(t, i))) == LUA_TNIL ||
+        ttype(key(node(t, i))) == LUA_TNUMBER) {
+      luaA_pushobject(L, key(node(t, i)));
+    }
+    else
+      lua_pushstring(L, "<undef>");
     luaA_pushobject(L, &t->node[i].val);
-    if (t->node[i].next)
+    if (t->node[i].next) {
       lua_pushnumber(L, t->node[i].next - t->node);
+      return 3;
+    }
+    else
+      return 2;
   }
+  return 0;
 }
 
 
-static void string_query (lua_State *L) {
-  int h = luaL_check_int(L, 1) - 1;
+static int string_query (lua_State *L) {
+  stringtable *tb = &G(L)->strt;
   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);
+    lua_pushnumber(L ,tb->nuse);
+    lua_pushnumber(L ,tb->size);
+    return 2;
+  }
+  else if (s < tb->size) {
+    TString *ts;
+    int n = 0;
+    for (ts = tb->hash[s]; ts; ts = ts->tsv.nexthash) {
+      setsvalue(L->top, ts);
+      incr_top;
+      n++;
     }
+    return n;
+  }
+  return 0;
+}
+
+
+static int tref (lua_State *L) {
+  int level = lua_gettop(L);
+  luaL_checkany(L, 1);
+  lua_pushvalue(L, 1);
+  lua_pushnumber(L, lua_ref(L, luaL_opt_int(L, 2, 1)));
+  assert(lua_gettop(L) == level+1);  /* +1 for result */
+  return 1;
+}
+
+static int getref (lua_State *L) {
+  int level = lua_gettop(L);
+  if (lua_getref(L, luaL_check_int(L, 1))) {
+    assert(lua_gettop(L) == level+1);
+    return 1;
   }
   else {
-    TString *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);
-    }
+    assert(lua_gettop(L) == level);
+    return 0;
   }
 }
 
+static int unref (lua_State *L) {
+  int level = lua_gettop(L);
+  lua_unref(L, luaL_check_int(L, 1));
+  assert(lua_gettop(L) == level);
+  return 0;
+}
+
+static int newuserdata (lua_State *L) {
+  size_t size = luaL_check_int(L, 1);
+  l_char *p = (l_char *)lua_newuserdata(L, size);
+  while (size--) *p++ = l_c('\0');
+  return 1;
+}
+
+static int newuserdatabox (lua_State *L) {
+  lua_newuserdatabox(L, (void *)luaL_check_int(L, 1));
+  return 1;
+}
+
+static int settag (lua_State *L) {
+  luaL_checkany(L, 1);
+  lua_pushvalue(L, 1);  /* push value */
+  lua_settag(L, luaL_check_int(L, 2));
+  return 1;  /* return value */
+}
+
+static int udataval (lua_State *L) {
+  luaL_checktype(L, 1, LUA_TUSERDATA);
+  lua_pushnumber(L, (int)lua_touserdata(L, 1));
+  return 1;
+}
+
+static int newtag (lua_State *L) {
+  lua_pushnumber(L, lua_newtype(L, lua_tostring(L, 1),
+                                   (int)lua_tonumber(L, 2)));
+  return 1;
+}
+
+static int doonnewstack (lua_State *L) {
+  lua_State *L1 = lua_newthread(L, luaL_check_int(L, 1));
+  if (L1 == NULL) return 0;
+  *((int **)L1) = &islocked;  /* initialize the lock */
+  lua_dostring(L1, luaL_check_string(L, 2));
+  lua_pushnumber(L, 1);
+  lua_close(L1);
+  return 1;
+}
+
+
+static int s2d (lua_State *L) {
+  lua_pushnumber(L, *(double *)luaL_check_string(L, 1));
+  return 1;
+}
+
+static int d2s (lua_State *L) {
+  double d = luaL_check_number(L, 1);
+  lua_pushlstring(L, (l_char *)&d, sizeof(d));
+  return 1;
+}
+
+
+static int newstate (lua_State *L) {
+  lua_State *L1 = lua_open(luaL_check_int(L, 1));
+  if (L1) {
+    *((int **)L1) = &islocked;  /* initialize the lock */
+    lua_pushnumber(L, (unsigned long)L1);
+  }
+  else
+    lua_pushnil(L);
+  return 1;
+}
+
+static int loadlib (lua_State *L) {
+  lua_State *L1 = (lua_State *)(unsigned long)luaL_check_number(L, 1);
+  lua_register(L1, "mathlibopen", lua_mathlibopen);
+  lua_register(L1, "strlibopen", lua_strlibopen);
+  lua_register(L1, "iolibopen", lua_iolibopen);
+  lua_register(L1, "dblibopen", lua_dblibopen);
+  lua_register(L1, "baselibopen", lua_baselibopen);
+  return 0;
+}
+
+static int closestate (lua_State *L) {
+  lua_State *L1 = (lua_State *)(unsigned long)luaL_check_number(L, 1);
+  lua_close(L1);
+  lua_unlock(L);  /* close cannot unlock that */
+  return 0;
+}
+
+static int doremote (lua_State *L) {
+  lua_State *L1;
+  const l_char *code = luaL_check_string(L, 2);
+  int status;
+  L1 = (lua_State *)(unsigned long)luaL_check_number(L, 1);
+  status = lua_dostring(L1, code);
+  if (status != 0) {
+    lua_pushnil(L);
+    lua_pushnumber(L, status);
+    return 2;
+  }
+  else {
+    int i = 0;
+    while (!lua_isnull(L1, ++i))
+      lua_pushstring(L, lua_tostring(L1, i));
+    lua_pop(L1, i-1);
+    return i-1;
+  }
+}
+
+static int settagmethod (lua_State *L) {
+  int tag = luaL_check_int(L, 1);
+  const l_char *event = luaL_check_string(L, 2);
+  luaL_checkany(L, 3);
+  lua_gettagmethod(L, tag, event);
+  lua_pushvalue(L, 3);
+  lua_settagmethod(L, tag, event);
+  return 1;
+}
+
+static int equal (lua_State *L) {
+  return pushbool(L, lua_equal(L, 1, 2));
+}
+
+  
 
 /*
 ** {======================================================
-** function to test the API with C. It interprets a kind of "assembler"
+** function to test the API with C. It interprets a kind of assembler
 ** language with calls to the API, so the test can be driven by Lua code
 ** =======================================================
 */
 
-static const char *const delimits = " \t\n,;";
+static const l_char *const delimits = l_s(" \t\n,;");
 
-static void skip (const char **pc) {
-  while (**pc != '\0' && strchr(delimits, **pc)) (*pc)++;
+static void skip (const l_char **pc) {
+  while (**pc != l_c('\0') && strchr(delimits, **pc)) (*pc)++;
 }
 
-static int getnum (const char **pc) {
+static int getnum (lua_State *L, const l_char **pc) {
   int res = 0;
+  int sig = 1;
   skip(pc);
-  while (isdigit(**pc)) res = res*10 + (*(*pc)++) - '0';
-  return res;
+  if (**pc == l_c('.')) {
+    res = (int)lua_tonumber(L, -1);
+    lua_pop(L, 1);
+    (*pc)++;
+    return res;
+  }
+  else if (**pc == l_c('-')) {
+    sig = -1;
+    (*pc)++;
+  }
+  while (isdigit(**pc)) res = res*10 + (*(*pc)++) - l_c('0');
+  return sig*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];
+static const l_char *getname (l_char *buff, const l_char **pc) {
   int i = 0;
   skip(pc);
-  while (**pc != '\0' && !strchr(delimits, **pc))
+  while (**pc != l_c('\0') && !strchr(delimits, **pc))
     buff[i++] = *(*pc)++;
-  buff[i] = '\0';
+  buff[i] = l_c('\0');
   return buff;
 }
 
 
 #define EQ(s1)	(strcmp(s1, inst) == 0)
 
+#define getnum	((getnum)(L, &pc))
+#define getname	((getname)(buff, &pc))
 
-static void testC (lua_State *L) {
-  lua_Object reg[10];
-  const char *pc = luaL_check_string(L, 1);
+
+static int testC (lua_State *L) {
+  l_char buff[30];
+  const l_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));
+    const l_char *inst = getname;
+    if EQ(l_s("")) return 0;
+    else if EQ(l_s("isnumber")) {
+      lua_pushnumber(L, lua_isnumber(L, getnum));
     }
-    else if EQ("createtable") {
-      reg[getreg(L, &pc)] = lua_createtable(L);
+    else if EQ(l_s("isstring")) {
+      lua_pushnumber(L, lua_isstring(L, getnum));
     }
-    else if EQ("closure") {
-      lua_CFunction f = lua_getcfunction(L, lua_getglobal(L, getname(&pc)));
-      lua_pushcclosure(L, f, getnum(&pc));
+    else if EQ(l_s("istable")) {
+      lua_pushnumber(L, lua_istable(L, getnum));
     }
-    else if EQ("pop") {
-      reg[getreg(L, &pc)] = lua_pop(L);
+    else if EQ(l_s("iscfunction")) {
+      lua_pushnumber(L, lua_iscfunction(L, getnum));
     }
-    else if EQ("getglobal") {
-      int n = getreg(L, &pc);
-      reg[n] = lua_getglobal(L, getname(&pc));
+    else if EQ(l_s("isfunction")) {
+      lua_pushnumber(L, lua_isfunction(L, getnum));
     }
-    else if EQ("rawgetglobal") {
-      int n = getreg(L, &pc);
-      reg[n] = lua_rawgetglobal(L, getname(&pc));
+    else if EQ(l_s("isuserdata")) {
+      lua_pushnumber(L, lua_isuserdata(L, getnum));
     }
-    else if EQ("ref") {
-      lua_pushnumber(L, lua_ref(L, 0));
-      reg[getreg(L, &pc)] = lua_pop(L);
+    else if EQ(l_s("isnil")) {
+      lua_pushnumber(L, lua_isnil(L, getnum));
     }
-    else if EQ("reflock") {
-      lua_pushnumber(L, lua_ref(L, 1));
-      reg[getreg(L, &pc)] = lua_pop(L);
+    else if EQ(l_s("isnull")) {
+      lua_pushnumber(L, lua_isnull(L, getnum));
     }
-    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(l_s("tonumber")) {
+      lua_pushnumber(L, lua_tonumber(L, getnum));
     }
-    else if EQ("unref") {
-      lua_unref(L, (int)lua_getnumber(L, reg[getreg(L, &pc)]));
+    else if EQ(l_s("tostring")) {
+      const l_char *s = lua_tostring(L, getnum);
+      lua_pushstring(L, s);
     }
-    else if EQ("getparam") {
-      int n = getreg(L, &pc);
-      reg[n] = lua_getparam(L, getnum(&pc)+1);  /* skips the command itself */
+    else if EQ(l_s("tonumber")) {
+      lua_pushnumber(L, lua_tonumber(L, getnum));
     }
-    else if EQ("getresult") {
-      int n = getreg(L, &pc);
-      reg[n] = lua_getparam(L, getnum(&pc));
+    else if EQ(l_s("strlen")) {
+      lua_pushnumber(L, lua_strlen(L, getnum));
     }
-    else if EQ("setglobal") {
-      lua_setglobal(L, getname(&pc));
+    else if EQ(l_s("tocfunction")) {
+      lua_pushcfunction(L, lua_tocfunction(L, getnum));
     }
-    else if EQ("rawsetglobal") {
-      lua_rawsetglobal(L, getname(&pc));
+    else if EQ(l_s("return")) {
+      return getnum;
     }
-    else if EQ("pushstring") {
-      lua_pushstring(L, getname(&pc));
+    else if EQ(l_s("gettop")) {
+      lua_pushnumber(L, lua_gettop(L));
     }
-    else if EQ("pushreg") {
-      lua_pushobject(L, reg[getreg(L, &pc)]);
+    else if EQ(l_s("settop")) {
+      lua_settop(L, getnum);
     }
-    else if EQ("call") {
-      if (lua_call(L, getname(&pc))) lua_error(L, NULL);
+    else if EQ(l_s("pop")) {
+      lua_pop(L, getnum);
     }
-    else if EQ("gettable") {
-      reg[getreg(L, &pc)] = lua_gettable(L);
+    else if EQ(l_s("pushnum")) {
+      lua_pushnumber(L, getnum);
     }
-    else if EQ("rawgettable") {
-      reg[getreg(L, &pc)] = lua_rawgettable(L);
+    else if EQ(l_s("pushvalue")) {
+      lua_pushvalue(L, getnum);
     }
-    else if EQ("settable") {
-      lua_settable(L);
+    else if EQ(l_s("remove")) {
+      lua_remove(L, getnum);
     }
-    else if EQ("rawsettable") {
-      lua_rawsettable(L);
+    else if EQ(l_s("insert")) {
+      lua_insert(L, getnum);
     }
-    else if EQ("tag") {
-      lua_pushnumber(L, lua_tag(L, reg[getreg(L, &pc)]));
+    else if EQ(l_s("gettable")) {
+      lua_gettable(L, getnum);
     }
-    else if EQ("type") {
-      lua_pushstring(L, lua_type(L, reg[getreg(L, &pc)]));
+    else if EQ(l_s("settable")) {
+      lua_settable(L, getnum);
     }
-    else if EQ("nextvar") {
-      lua_pushstring(L, lua_nextvar(L, lua_getstring(L, reg[getreg(L, &pc)])));
+    else if EQ(l_s("next")) {
+      lua_next(L, -2);
     }
-    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(l_s("concat")) {
+      lua_concat(L, getnum);
     }
-    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(l_s("lessthan")) {
+      int a = getnum;
+      if (lua_lessthan(L, a, getnum))
+        lua_pushnumber(L, 1);
+      else
+        lua_pushnil(L);
     }
-    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(l_s("rawcall")) {
+      int narg = getnum;
+      int nres = getnum;
+      lua_rawcall(L, narg, nres);
     }
-    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(l_s("call")) {
+      int narg = getnum;
+      int nres = getnum;
+      lua_call(L, narg, nres);
     }
-    else if EQ("settagmethod") {
-      int n = getreg(L, &pc);
-      lua_settagmethod(L, (int)lua_getnumber(L, reg[n]), getname(&pc));
+    else if EQ(l_s("dostring")) {
+      lua_dostring(L, luaL_check_string(L, getnum));
     }
-    else if EQ("beginblock") {
-      lua_beginblock(L);
+    else if EQ(l_s("settagmethod")) {
+      int tag = getnum;
+      const l_char *event = getname;
+      lua_settagmethod(L, tag, event);
     }
-    else if EQ("endblock") {
-      lua_endblock(L);
+    else if EQ(l_s("gettagmethod")) {
+      int tag = getnum;
+      const l_char *event = getname;
+      lua_gettagmethod(L, tag, event);
     }
-    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(l_s("type")) {
+      lua_pushstring(L, lua_type(L, getnum));
     }
-    else if EQ("closestate") {
-      lua_close((lua_State *)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_State *)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);
+    else luaL_verror(L, l_s("unknown instruction %.30s"), buff);
   }
+  return 0;
 }
 
 /* }====================================================== */
@@ -400,18 +631,46 @@ static void testC (lua_State *L) {
 
 
 static const struct luaL_reg tests_funcs[] = {
-  {"hash", hash_query},
-  {"limits", get_limits},
-  {"listcode", listcode},
-  {"querystr", string_query},
-  {"querytab", table_query},
-  {"testC", testC},
-  {"totalmem", mem_query}
+  {l_s("hash"), hash_query},
+  {l_s("limits"), get_limits},
+  {l_s("listcode"), listcode},
+  {l_s("listk"), listk},
+  {l_s("listlocals"), listlocals},
+  {l_s("loadlib"), loadlib},
+  {l_s("querystr"), string_query},
+  {l_s("querytab"), table_query},
+  {l_s("testC"), testC},
+  {l_s("ref"), tref},
+  {l_s("getref"), getref},
+  {l_s("unref"), unref},
+  {l_s("d2s"), d2s},
+  {l_s("s2d"), s2d},
+  {l_s("newuserdata"), newuserdata},
+  {l_s("newuserdatabox"), newuserdatabox},
+  {l_s("settag"), settag},
+  {l_s("udataval"), udataval},
+  {l_s("newtag"), newtag},
+  {l_s("doonnewstack"), doonnewstack},
+  {l_s("newstate"), newstate},
+  {l_s("closestate"), closestate},
+  {l_s("doremote"), doremote},
+  {l_s("settagmethod"), settagmethod},
+  {l_s("equal"), equal},
+  {l_s("totalmem"), mem_query}
 };
 
 
 void luaB_opentests (lua_State *L) {
-  luaL_openl(L, tests_funcs);
+  *((int **)L) = &islocked;  /* init lock */
+  lua_state = L;  /* keep first state to be opened */
+  /* open lib in a new table */
+  lua_newtable(L);
+  lua_getglobals(L);
+  lua_pushvalue(L, -2);
+  lua_setglobals(L);
+  luaL_openl(L, tests_funcs);  /* open functions inside new table */
+  lua_setglobals(L);  /* restore old table of globals */
+  lua_setglobal(L, l_s("T"));  /* set new table as global T */
 }
 
 #endif

ltests.h

@@ -0,0 +1,58 @@
+/*
+** $Id: ltests.h,v 1.6 2001/03/02 17:27:50 roberto Exp roberto $
+** Internal Header for Debugging of the Lua Implementation
+** See Copyright Notice in lua.h
+*/
+
+#ifndef ltests_h
+#define ltests_h
+
+
+#include <stdlib.h>
+
+
+#define LUA_DEBUG
+
+#define LUA_OPNAMES
+
+#undef NDEBUG
+#include <assert.h>
+#define lua_assert(c)           assert(c)
+#define api_check(L, o)		lua_assert(o)
+
+
+/* to avoid warnings, and to make sure value is really unused */
+#define UNUSED(x)       (x=0, (void)(x))
+
+
+/* memory allocator control variables */
+extern unsigned long memdebug_numblocks;
+extern unsigned long memdebug_total;
+extern unsigned long memdebug_maxmem;
+extern unsigned long memdebug_memlimit;
+
+
+#define l_malloc(s)		debug_realloc(NULL, 0, s)
+#define l_realloc(b, os, s)	debug_realloc(b, os, s)
+#define l_free(b, s)		debug_realloc(b, s, 0)
+
+void *debug_realloc (void *block, size_t oldsize, size_t size);
+
+
+
+/* test for lock/unlock */
+#define LUA_USERSTATE	int *lock;
+extern int islocked;
+#define lua_lock(L)     lua_assert((**((int **)L))++ == 0)
+#define lua_unlock(L)   lua_assert(--(**((int **)L)) == 0)
+
+
+extern lua_State *lua_state;
+
+
+void luaB_opentests (lua_State *L);
+
+#define LUA_USERINIT(L) (luaB_opentests(L), openstdlibs(L))
+
+
+#endif

ltm.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ltm.c,v 1.38 2000/03/29 20:19:20 roberto Exp roberto $
+** $Id: ltm.c,v 1.75 2001/07/23 19:56:00 roberto Exp roberto $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
@@ -8,151 +8,185 @@
 #include <stdio.h>
 #include <string.h>
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
-#include "lauxlib.h"
+#include "ldo.h"
 #include "lmem.h"
 #include "lobject.h"
 #include "lstate.h"
+#include "lstring.h"
+#include "ltable.h"
 #include "ltm.h"
 
 
-const char *const luaT_eventname[] = {  /* ORDER IM */
-  "gettable", "settable", "index", "getglobal", "setglobal", "add", "sub",
-  "mul", "div", "pow", "unm", "lt", "concat", "gc", "function",
-  "le", "gt", "ge",  /* deprecated options!! */
+const l_char *const luaT_eventname[] = {  /* ORDER TM */
+  l_s("gettable"), l_s("settable"), l_s("index"), l_s("getglobal"),
+  l_s("setglobal"), l_s("add"), l_s("sub"), l_s("mul"), l_s("div"),
+  l_s("pow"), l_s("unm"), l_s("lt"), l_s("concat"), l_s("gc"),
+  l_s("function"),
   NULL
 };
 
 
-static int luaI_checkevent (lua_State *L, const char *name, int t) {
-  int e = luaL_findstring(name, luaT_eventname);
-  if (e >= IM_N)
-    luaL_verror(L, "event `%.50s' is deprecated", name);
-  if (e == IM_GC && t == TAG_TABLE)
-    luaL_verror(L, "event `gc' for tables is deprecated");
+static int findevent (const l_char *name) {
+  int i;
+  for (i=0; luaT_eventname[i]; i++)
+    if (strcmp(luaT_eventname[i], name) == 0)
+      return i;
+  return -1;  /* name not found */
+}
+
+
+static int luaI_checkevent (lua_State *L, const l_char *name) {
+  int e = findevent(name);
   if (e < 0)
-    luaL_verror(L, "`%.50s' is not a valid event name", name);
+    luaO_verror(L, l_s("`%.50s' is not a valid event name"), name);
   return e;
 }
 
 
 
-/* events in TAG_NIL are all allowed, since this is used as a
-*  'placeholder' for "default" fallbacks
+/* events in LUA_TNIL are all allowed, since this is used as a
+*  `placeholder' for default fallbacks
 */
-/* ORDER LUA_T, ORDER IM */
-static const char luaT_validevents[NUM_TAGS][IM_N] = {
-  {1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1},  /* TAG_USERDATA */
-  {1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1},  /* TAG_NUMBER */
-  {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},  /* TAG_STRING */
-  {0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1},  /* TAG_TABLE */
-  {1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0},  /* TAG_LCLOSURE */
-  {1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0},  /* TAG_CCLOSURE */
-  {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}   /* TAG_NIL */
+/* ORDER LUA_T, ORDER TM */
+static const lu_byte luaT_validevents[NUM_TAGS][TM_N] = {
+  {1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1},  /* LUA_TUSERDATA */
+  {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},  /* LUA_TNIL */
+  {1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1},  /* LUA_TNUMBER */
+  {1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1},  /* LUA_TSTRING */
+  {0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1},  /* LUA_TTABLE */
+  {1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0}   /* LUA_TFUNCTION */
 };
 
 int luaT_validevent (int t, int e) {  /* ORDER LUA_T */
-  return (t > TAG_NIL) ?  1 : luaT_validevents[t][e];
-}
-
-
-static void init_entry (lua_State *L, int tag) {
-  int i;
-  for (i=0; i<IM_N; i++)
-    ttype(luaT_getim(L, tag, i)) = TAG_NIL;
+  return (t >= NUM_TAGS) ?  1 : (int)luaT_validevents[t][e];
 }
 
 
 void luaT_init (lua_State *L) {
-  int t;
-  L->last_tag = NUM_TAGS-1;
-  luaM_growvector(L, L->IMtable, 0, NUM_TAGS, struct IM, arrEM, MAX_INT);
-  for (t=0; t<=L->last_tag; t++)
-    init_entry(L, t);
+  static const l_char *const typenames[NUM_TAGS] = {
+    l_s("userdata"), l_s("nil"), l_s("number"), l_s("string"),
+    l_s("table"), l_s("function")
+  };
+  int i;
+  for (i=0; i<NUM_TAGS; i++)
+    luaT_newtag(L, typenames[i], i);
 }
 
 
-int lua_newtag (lua_State *L) {
-  ++L->last_tag;
-  luaM_growvector(L, L->IMtable, L->last_tag, 1, struct IM, arrEM, MAX_INT);
-  init_entry(L, L->last_tag);
-  return L->last_tag;
+int luaT_newtag (lua_State *L, const l_char *name, int basictype) {
+  int tag;
+  int i;
+  TString *ts = NULL;
+  luaM_growvector(L, G(L)->TMtable, G(L)->ntag, G(L)->sizeTM, struct TM,
+                  MAX_INT, l_s("tag table overflow"));
+  tag = G(L)->ntag;
+  if (name) {
+    TObject *v;
+    ts = luaS_new(L, name);
+    v = luaH_setstr(L, G(L)->type2tag, ts);
+    if (ttype(v) == LUA_TNUMBER) return (int)nvalue(v);
+    setnvalue(v, tag);
+  }
+  for (i=0; i<TM_N; i++)
+    luaT_gettm(G(L), tag, i) = NULL;
+  G(L)->TMtable[tag].collected = NULL;
+  G(L)->TMtable[tag].name = ts;
+  G(L)->TMtable[tag].basictype = basictype;
+  G(L)->ntag++;
+  return tag;
 }
 
 
 static void checktag (lua_State *L, int tag) {
-  if (!(0 <= tag && tag <= L->last_tag))
-    luaL_verror(L, "%d is not a valid tag", tag);
-}
-
-void luaT_realtag (lua_State *L, int tag) {
-  if (!(NUM_TAGS <= tag && tag <= L->last_tag))
-    luaL_verror(L, "tag %d was not created by `newtag'", tag);
+  if (!(0 <= tag && tag < G(L)->ntag))
+    luaO_verror(L, l_s("%d is not a valid tag"), tag);
 }
 
 
-int lua_copytagmethods (lua_State *L, int tagto, int tagfrom) {
+LUA_API int lua_copytagmethods (lua_State *L, int tagto, int tagfrom) {
   int e;
+  lua_lock(L);
   checktag(L, tagto);
   checktag(L, tagfrom);
-  for (e=0; e<IM_N; e++) {
+  for (e=0; e<TM_N; e++) {
     if (luaT_validevent(tagto, e))
-      *luaT_getim(L, tagto, e) = *luaT_getim(L, tagfrom, e);
+      luaT_gettm(G(L), tagto, e) = luaT_gettm(G(L), tagfrom, e);
   }
+  lua_unlock(L);
   return tagto;
 }
 
 
-int luaT_effectivetag (lua_State *L, const TObject *o) {
-  lua_Type t = ttype(o);
+int luaT_tag (const TObject *o) {
+  int t = ttype(o);
   switch (t) {
-    case TAG_USERDATA: {
-      int tag = o->value.ts->u.d.tag;
-      return (tag > L->last_tag) ? TAG_USERDATA : tag;  /* deprecated test */
-    }
-    case TAG_TABLE: return o->value.a->htag;
-    default: return t;
+    case LUA_TUSERDATA: return uvalue(o)->uv.tag;
+    case LUA_TTABLE:    return hvalue(o)->htag;
+    default:            return t;
   }
 }
 
 
-const TObject *luaT_gettagmethod (lua_State *L, int t, const char *event) {
-  int e;
-  e = luaI_checkevent(L, event, t);
-  checktag(L, t);
-  if (luaT_validevent(t, e))
-    return luaT_getim(L, t,e);
-  else
-    return &luaO_nilobject;
+const l_char *luaT_typename (global_State *G, const TObject *o) {
+  int t = ttype(o);
+  int tag;
+  TString *ts;
+  switch (t) {
+    case LUA_TUSERDATA:
+      tag = uvalue(o)->uv.tag;
+      break;
+    case LUA_TTABLE:
+      tag = hvalue(o)->htag;
+      break;
+    default:
+      tag = t;
+  }
+  ts = G->TMtable[tag].name;
+  if (ts == NULL)
+    ts = G->TMtable[t].name;
+  return getstr(ts);
 }
 
 
-void luaT_settagmethod (lua_State *L, int t, const char *event, TObject *func) {
-  TObject temp;
+LUA_API void lua_gettagmethod (lua_State *L, int t, const l_char *event) {
   int e;
-  e = luaI_checkevent(L, event, t);
+  lua_lock(L);
+  e = luaI_checkevent(L, event);
+  checktag(L, t);
+  if (luaT_validevent(t, e) && luaT_gettm(G(L), t, e)) {
+    setclvalue(L->top, luaT_gettm(G(L), t, e));
+  }
+  else
+    setnilvalue(L->top);
+  incr_top;
+  lua_unlock(L);
+}
+
+
+LUA_API void lua_settagmethod (lua_State *L, int t, const l_char *event) {
+  int e;
+  lua_lock(L);
+  e = luaI_checkevent(L, event);
   checktag(L, t);
   if (!luaT_validevent(t, e))
-    luaL_verror(L, "cannot change `%.20s' tag method for type `%.20s'%.20s",
-                luaT_eventname[e], luaO_typenames[t],
-                (t == TAG_TABLE || t == TAG_USERDATA) ? " with default tag"
-                                                          : "");
-  temp = *func;
-  *func = *luaT_getim(L, t,e);
-  *luaT_getim(L, t, e) = temp;
-}
-
-
-const char *luaT_travtagmethods (lua_State *L,
-                         int (*fn)(lua_State *, TObject *)) {  /* ORDER IM */
-  int e;
-  for (e=IM_GETTABLE; e<=IM_FUNCTION; e++) {
-    int t;
-    for (t=0; t<=L->last_tag; t++)
-      if (fn(L, luaT_getim(L, t,e)))
-        return luaT_eventname[e];
+    luaO_verror(L, l_s("cannot change `%.20s' tag method for type `%.20s'%.20s"),
+                luaT_eventname[e], typenamebytag(G(L), t),
+                (t == LUA_TTABLE || t == LUA_TUSERDATA) ?
+                   l_s(" with default tag") : l_s(""));
+  switch (ttype(L->top - 1)) {
+    case LUA_TNIL:
+      luaT_gettm(G(L), t, e) = NULL;
+      break;
+    case LUA_TFUNCTION:
+      luaT_gettm(G(L), t, e) = clvalue(L->top - 1);
+      break;
+    default:
+      luaD_error(L, l_s("tag method must be a function (or nil)"));
   }
-  return NULL;
+  L->top--;
+  lua_unlock(L);
 }
 

ltm.h

@@ -1,5 +1,5 @@
 /*
-** $Id: ltm.h,v 1.11 2000/03/20 19:14:54 roberto Exp roberto $
+** $Id: ltm.h,v 1.25 2001/06/06 18:00:19 roberto Exp roberto $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
@@ -13,45 +13,67 @@
 
 /*
 * WARNING: if you change the order of this enumeration,
-* grep "ORDER IM"
+* grep "ORDER TM"
 */
 typedef enum {
-  IM_GETTABLE = 0,
-  IM_SETTABLE,
-  IM_INDEX,
-  IM_GETGLOBAL,
-  IM_SETGLOBAL,
-  IM_ADD,
-  IM_SUB,
-  IM_MUL,
-  IM_DIV,
-  IM_POW,
-  IM_UNM,
-  IM_LT,
-  IM_CONCAT,
-  IM_GC,
-  IM_FUNCTION,
-  IM_N		/* number of elements in the enum */
-} IMS;
+  TM_GETTABLE = 0,
+  TM_SETTABLE,
+  TM_INDEX,
+  TM_GETGLOBAL,
+  TM_SETGLOBAL,
+  TM_ADD,
+  TM_SUB,
+  TM_MUL,
+  TM_DIV,
+  TM_POW,
+  TM_UNM,
+  TM_LT,
+  TM_CONCAT,
+  TM_GC,
+  TM_FUNCTION,
+  TM_N		/* number of elements in the enum */
+} TMS;
 
 
-struct IM {
-  TObject int_method[IM_N];
+
+/*
+** masks for allowable tag methods
+** (see `luaT_validevents')
+*/
+#define HAS_TM_GETGLOBAL(L,t)	(1<<(t) & ((1<<LUA_TUSERDATA) | \
+                                           (1<<LUA_TTABLE) | \
+                                           (1<<LUA_TNIL)))
+
+#define HAS_TM_SETGLOBAL(L,t)	(1<<(t) & ((1<<LUA_TUSERDATA) | \
+                                           (1<<LUA_TTABLE) | \
+                                           (1<<LUA_TNIL) | \
+                                           (1<<LUA_TFUNCTION)))
+
+
+
+struct TM {
+  Closure *method[TM_N];
+  Udata *collected;  /* list of garbage-collected udata with this tag */
+  TString *name;  /* type name */
+  int basictype;
 };
 
 
-#define luaT_getim(L,tag,event) (&L->IMtable[tag].int_method[event])
-#define luaT_getimbyObj(L,o,e)  (luaT_getim(L, luaT_effectivetag(L, o),(e)))
+#define luaT_gettm(G,tag,event) (G->TMtable[tag].method[event])
+#define luaT_gettmbyObj(G,o,e)  (luaT_gettm((G),luaT_tag(o),(e)))
 
-extern const char *const luaT_eventname[];
+#define typenamebytag(G, t)	getstr(G->TMtable[t].name)
+
+
+#define validtag(G,t) (NUM_TAGS <= (t) && (t) < G->ntag)
+
+extern const l_char *const luaT_eventname[];
 
 
 void luaT_init (lua_State *L);
-void luaT_realtag (lua_State *L, int tag);
-int luaT_effectivetag (lua_State *L, const TObject *o);
-void luaT_settagmethod (lua_State *L, int t, const char *event, TObject *func);
-const TObject *luaT_gettagmethod (lua_State *L, int t, const char *event);
-const char *luaT_travtagmethods (lua_State *L, int (*fn)(lua_State *, TObject *));
+int luaT_newtag (lua_State *L, const l_char *name, int basictype);
+const l_char *luaT_typename (global_State *G, const TObject *o);
+int luaT_tag (const TObject *o);
 int luaT_validevent (int t, int e);  /* used by compatibility module */
 
 

lua.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lua.c,v 1.36 2000/03/30 17:19:48 roberto Exp roberto $
+** $Id: lua.c,v 1.67 2001/06/06 18:00:19 roberto Exp roberto $
 ** Lua stand-alone interpreter
 ** See Copyright Notice in lua.h
 */
@@ -10,21 +10,44 @@
 #include <stdlib.h>
 #include <string.h>
 
+#define LUA_PRIVATE
 #include "lua.h"
+
 #include "luadebug.h"
 #include "lualib.h"
 
 
-#ifndef PROMPT
-#define PROMPT		"> "
-#endif
-
 #ifdef _POSIX_SOURCE
 #include <unistd.h>
 #else
 static int isatty (int x) { return x==0; }  /* assume stdin is a tty */
 #endif
 
+
+
+#ifndef PROMPT
+#define PROMPT		l_s("> ")
+#endif
+
+
+#ifndef LUA_USERINIT
+#define LUA_USERINIT(L)		openstdlibs(L)
+#endif
+
+
+
+/*
+** global options
+*/
+struct Options {
+  int toclose;
+  int stacksize;
+};
+
+
+static lua_State *L = NULL;
+
+
 typedef void (*handler)(int);  /* type for signal actions */
 
 static void laction (int i);
@@ -34,16 +57,17 @@ static lua_Hook old_linehook = NULL;
 static lua_Hook old_callhook = NULL;
 
 
+
 static handler lreset (void) {
   return signal(SIGINT, laction);
 }
 
 
 static void lstop (void) {
-  lua_setlinehook(lua_state, old_linehook);
-  lua_setcallhook(lua_state, old_callhook);
+  lua_setlinehook(L, old_linehook);
+  lua_setcallhook(L, old_callhook);
   lreset();
-  lua_error("interrupted!");
+  lua_error(L, l_s("interrupted!"));
 }
 
 
@@ -51,204 +75,261 @@ static void laction (int i) {
   (void)i;  /* to avoid warnings */
   signal(SIGINT, SIG_DFL); /* if another SIGINT happens before lstop,
                               terminate process (default action) */
-  old_linehook = lua_setlinehook(lua_state, (lua_Hook)lstop);
-  old_callhook = lua_setcallhook(lua_state, (lua_Hook)lstop);
+  old_linehook = lua_setlinehook(L, (lua_Hook)lstop);
+  old_callhook = lua_setcallhook(L, (lua_Hook)lstop);
 }
 
 
-static int ldo (int (*f)(lua_State *L, const char *), const char *name) {
+static int ldo (int (*f)(lua_State *l, const l_char *), const l_char *name) {
   int res;
   handler h = lreset();
-  res = f(lua_state, name);  /* dostring | dofile */
+  int top = lua_gettop(L);
+  res = f(L, name);  /* dostring | dofile */
+  lua_settop(L, top);  /* remove eventual results */
   signal(SIGINT, h);  /* restore old action */
+  /* Lua gives no message in such cases, so lua.c provides one */
+  if (res == LUA_ERRMEM) {
+    fprintf(stderr, l_s("lua: memory allocation error\n"));
+  }
+  else if (res == LUA_ERRERR)
+    fprintf(stderr, l_s("lua: error in error message\n"));
   return res;
 }
 
 
 static void print_message (void) {
   fprintf(stderr,
-  "usage: lua [options].  Available options are:\n"
-  "  -        execute stdin as a file\n"
-  "  -d       turn debug on\n"
-  "  -e stat  execute string `stat'\n"
-  "  -f name  execute file `name' with remaining arguments in table `arg'\n"
-  "  -i       enter interactive mode with prompt\n"
-  "  -q       enter interactive mode without prompt\n"
-  "  -sNUM    set stack size to NUM (must be first option)\n"
-  "  -v       print version information\n"
-  "  a=b      set global `a' to string `b'\n"
-  "  name     execute file `name'\n"
+  l_s("usage: lua [options].  Available options are:\n")
+  l_s("  -        execute stdin as a file\n")
+  l_s("  -c       close Lua when exiting\n")
+  l_s("  -e stat  execute string `stat'\n")
+  l_s("  -f name  execute file `name' with remaining arguments in table `arg'\n")
+  l_s("  -i       enter interactive mode with prompt\n")
+  l_s("  -q       enter interactive mode without prompt\n")
+  l_s("  -sNUM    set stack size to NUM (must be the first option)\n")
+  l_s("  -v       print version information\n")
+  l_s("  a=b      set global `a' to string `b'\n")
+  l_s("  name     execute file `name'\n")
 );
 }
 
 
 static void print_version (void) {
-  printf("%s  %s\n", LUA_VERSION, LUA_COPYRIGHT);
+  printf(l_s("%.80s  %.80s\n"), l_s(LUA_VERSION), l_s(LUA_COPYRIGHT));
 }
 
 
-static void assign (char *arg) {
-  char *eq = strchr(arg, '=');
-  *eq = '\0';  /* spilt `arg' in two strings (name & value) */
-  lua_pushstring(eq+1);
-  lua_setglobal(arg);
+static void assign (l_char *arg) {
+  l_char *eq = strchr(arg, l_c('='));
+  *eq = l_c('\0');  /* spilt `arg' in two strings (name & value) */
+  lua_pushstring(L, eq+1);
+  lua_setglobal(L, arg);
 }
 
 
-static lua_Object getargs (char *argv[]) {
-  lua_Object args = lua_createtable();
+static void getargs (l_char *argv[]) {
   int i;
+  lua_newtable(L);
   for (i=0; argv[i]; i++) {
     /* arg[i] = argv[i] */
-    lua_pushobject(args); lua_pushnumber(i);
-    lua_pushstring(argv[i]); lua_settable();
+    lua_pushnumber(L, i);
+    lua_pushstring(L, argv[i]);
+    lua_settable(L, -3);
   }
   /* arg.n = maximum index in table `arg' */
-  lua_pushobject(args); lua_pushstring("n");
-  lua_pushnumber(i-1); lua_settable();
-  return args;
+  lua_pushliteral(L, l_s("n"));
+  lua_pushnumber(L, i-1);
+  lua_settable(L, -3);
 }
 
 
-static void l_getargs (void) {
-  char **argv = (char **)lua_getuserdata(lua_getparam(1));
-  lua_pushobject(getargs(argv));
+static int l_getargs (lua_State *l) {
+  l_char **argv = (l_char **)lua_touserdata(l, -1);
+  getargs(argv);
+  return 1;
 }
 
 
-static void file_input (const char *argv) {
+static int file_input (const l_char *argv) {
   int result = ldo(lua_dofile, argv);
   if (result) {
-    if (result == 2) {
-      fprintf(stderr, "lua: cannot execute file ");
+    if (result == LUA_ERRFILE) {
+      fprintf(stderr, l_s("lua: cannot execute file "));
       perror(argv);
     }
-    exit(1);
+    return EXIT_FAILURE;
+  }
+  else
+    return EXIT_SUCCESS;
+}
+
+
+/* maximum length of an input line */
+#ifndef MAXINPUT
+#define MAXINPUT	512
+#endif
+
+
+static const l_char *get_prompt (int prompt) {
+  if (!prompt)
+    return l_s("");
+  else {
+    const l_char *s;
+    lua_getglobal(L, l_s("_PROMPT"));
+    s = lua_tostring(L, -1);
+    if (!s) s = PROMPT;
+    lua_pop(L, 1);  /* remove global */
+    return s;
   }
 }
 
 
 static void manual_input (int version, int prompt) {
-  int cont = 1;
   if (version) print_version();
-  while (cont) {
-    char buffer[BUFSIZ];
-    int i = 0;
-    lua_beginblock();
-    if (prompt) {
-      const char *s = lua_getstring(lua_getglobal("_PROMPT"));
-      if (!s) s = PROMPT;
-      fputs(s, stdout);
-    }
+  for (;;) {
+    fputs(get_prompt(prompt), stdout);  /* show prompt */
     for(;;) {
-      int c = getchar();
-      if (c == EOF) {
-        cont = 0;
+      l_char buffer[MAXINPUT];
+      size_t l;
+      if (fgets(buffer, sizeof(buffer), stdin) == NULL) {
+        printf(l_s("\n"));
+        return;
+      }
+      l = strlen(buffer);
+      if (buffer[l-1] == l_c('\n') && buffer[l-2] == l_c('\\')) {
+        buffer[l-2] = l_c('\n');
+        lua_pushlstring(L, buffer, l-1);
+      }
+      else {
+        lua_pushlstring(L, buffer, l);
         break;
       }
-      else if (c == '\n') {
-        if (i>0 && buffer[i-1] == '\\')
-          buffer[i-1] = '\n';
-        else break;
-      }
-      else if (i >= BUFSIZ-1) {
-        fprintf(stderr, "lua: input line too long\n");
-        break;
-      }
-      else buffer[i++] = (char)c;
     }
-    buffer[i] = '\0';
-    ldo(lua_dostring, buffer);
-    lua_endblock();
+    lua_concat(L, lua_gettop(L));
+    ldo(lua_dostring, lua_tostring(L, -1));
+    lua_settop(L, 0);  /* remove eventual results */
   }
-  printf("\n");
 }
 
 
-int main (int argc, char *argv[]) {
-  int i = 1;
-  if (i < argc && argv[1][0] == '-' && argv[1][1] == 's') {
-    int stacksize = atoi(&argv[1][2]);
-    if (stacksize == 0) {
-      fprintf(stderr, "lua: invalid stack size ('%s')\n", &argv[1][2]);
-      exit(1);
-    }
-    i++;
-    lua_state = lua_newstate("stack", stacksize, NULL);
-  }
-  else
-    lua_state = lua_newstate(NULL);
-  lua_userinit();
-  lua_pushuserdata(argv);
-  lua_pushcclosure(l_getargs, 1);
-  lua_setglobal("getargs");
-  if (i >= argc) {  /* no other arguments? */
+static int handle_argv (l_char *argv[], struct Options *opt) {
+  if (opt->stacksize > 0) argv++;  /* skip option `-s' (if present) */
+  if (*argv == NULL) {  /* no more arguments? */
     if (isatty(0)) {
       manual_input(1, 1);
     }
     else
       ldo(lua_dofile, NULL);  /* executes stdin as a file */
   }
-  else for (; i<argc; i++) {
-    if (argv[i][0] == '-') {  /* option? */
-      switch (argv[i][1]) {
-        case 0:
-          ldo(lua_dofile, NULL);  /* executes stdin as a file */
-          break;
-        case 'i':
-          manual_input(0, 1);
-          break;
-        case 'q':
-          manual_input(0, 0);
-          break;
-        case 'd':
-          lua_setdebug(lua_state, 1);
-          if (i+1 >= argc) {  /* last argument? */
-            manual_input(1, 1);
+  else {  /* other arguments; loop over them */
+    int i;
+    for (i = 0; argv[i] != NULL; i++) {
+      if (argv[i][0] != l_c('-')) {  /* not an option? */
+        if (strchr(argv[i], l_c('=')))
+          assign(argv[i]);
+        else
+          if (file_input(argv[i]) != EXIT_SUCCESS)
+            return EXIT_FAILURE;  /* stop if file fails */
+        }
+        else switch (argv[i][1]) {  /* option */
+          case 0: {
+            ldo(lua_dofile, NULL);  /* executes stdin as a file */
+            break;
           }
-          break;
-        case 'v':
-          print_version();
-          break;
-        case 'e':
-          i++;
-          if (i >= argc) {
+          case l_c('i'): {
+            manual_input(0, 1);
+            break;
+          }
+          case l_c('q'): {
+            manual_input(0, 0);
+            break;
+          }
+          case l_c('c'): {
+            opt->toclose = 1;
+            break;
+          }
+          case l_c('v'): {
+            print_version();
+            break;
+          }
+          case l_c('e'): {
+            i++;
+            if (argv[i] == NULL) {
+              print_message();
+              return EXIT_FAILURE;
+            }
+            if (ldo(lua_dostring, argv[i]) != 0) {
+              fprintf(stderr, l_s("lua: error running argument `%.99s'\n"), argv[i]);
+              return EXIT_FAILURE;
+            }
+            break;
+          }
+          case l_c('f'): {
+            i++;
+            if (argv[i] == NULL) {
+              print_message();
+              return EXIT_FAILURE;
+            }
+            getargs(argv+i);  /* collect remaining arguments */
+            lua_setglobal(L, l_s("arg"));
+            return file_input(argv[i]);  /* stop scanning arguments */
+          }
+          case l_c('s'): {
+            fprintf(stderr, l_s("lua: stack size (`-s') must be the first option\n"));
+            return EXIT_FAILURE;
+          }
+          default: {
             print_message();
-            exit(1);
+            return EXIT_FAILURE;
           }
-          if (ldo(lua_dostring, argv[i]) != 0) {
-            fprintf(stderr, "lua: error running argument `%s'\n", argv[i]);
-            exit(1);
-          }
-          break;
-        case 'f':
-          i++;
-          if (i >= argc) {
-            print_message();
-            exit(1);
-          }
-          lua_pushobject(getargs(argv+i));  /* collect remaining arguments */
-          lua_setglobal("arg");
-          file_input(argv[i]);
-          goto endloop;  /* stop scanning arguments */
-          break;
-        case 's':
-          fprintf(stderr, "lua: stack size (`-s') must be the first option\n");
-          exit(1);
-        default:
-          print_message();
-          exit(1);
-      }
+        }
     }
-    else if (strchr(argv[i], '='))
-      assign(argv[i]);
-    else
-      file_input(argv[i]);
   }
-  endloop:
-#ifdef DEBUG
-  lua_close();
-#endif
-  return 0;
+  return EXIT_SUCCESS;
+}
+
+
+static void getstacksize (int argc, l_char *argv[], struct Options *opt) {
+  if (argc >= 2 && argv[1][0] == l_c('-') && argv[1][1] == l_c('s')) {
+    int stacksize = strtol(&argv[1][2], NULL, 10);
+    if (stacksize <= 0) {
+      fprintf(stderr, l_s("lua: invalid stack size ('%.20s')\n"), &argv[1][2]);
+      exit(EXIT_FAILURE);
+    }
+    opt->stacksize = stacksize;
+  }
+  else
+    opt->stacksize = 0;  /* no stack size */
+}
+
+
+static void register_getargs (l_char *argv[]) {
+  lua_newuserdatabox(L, argv);
+  lua_pushcclosure(L, l_getargs, 1);
+  lua_setglobal(L, l_s("getargs"));
+}
+
+
+static void openstdlibs (lua_State *l) {
+  lua_baselibopen(l);
+  lua_iolibopen(l);
+  lua_strlibopen(l);
+  lua_mathlibopen(l);
+  lua_dblibopen(l);
+}
+
+
+int main (int argc, l_char *argv[]) {
+  struct Options opt;
+  int status;
+  opt.toclose = 0;
+  getstacksize(argc, argv, &opt);  /* handle option `-s' */
+  L = lua_open(opt.stacksize);  /* create state */
+  LUA_USERINIT(L);  /* open libraries */
+  register_getargs(argv);  /* create `getargs' function */
+  status = handle_argv(argv+1, &opt);
+  if (opt.toclose)
+    lua_close(L);
+  return status;
 }
 

lua.h

@@ -1,9 +1,9 @@
 /*
-** $Id: lua.h,v 1.47 2000/04/14 17:48:20 roberto Exp roberto $
+** $Id: lua.h,v 1.101 2001/07/12 18:11:58 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
-** www: http://www.tecgraf.puc-rio.br/lua/
+** e-mail: info@lua.org
+** www: http://www.lua.org
 ** See Copyright Notice at the end of this file
 */
 
@@ -11,105 +11,217 @@
 #ifndef lua_h
 #define lua_h
 
-#define LUA_VERSION	"Lua 4.0 (alpha)"
-#define LUA_COPYRIGHT	"Copyright (C) 1994-2000 TeCGraf, PUC-Rio"
+
+/* definition of `size_t' */
+#include <stddef.h>
+
+
+
+#define LUA_VERSION	"Lua 4.1 (alpha)"
+#define LUA_COPYRIGHT	"Copyright (C) 1994-2001 TeCGraf, PUC-Rio"
 #define LUA_AUTHORS 	"W. Celes, R. Ierusalimschy & L. H. de Figueiredo"
 
 
+/* name of global variable with error handler */
+#define LUA_ERRORMESSAGE	"_ERRORMESSAGE"
+
+
+/* pre-defined references */
 #define LUA_NOREF	(-2)
 #define LUA_REFNIL	(-1)
 
-#define LUA_ANYTAG	(-1)
+
+/* option for multiple returns in `lua_call' */
+#define LUA_MULTRET	(-1)
+
+
+/* error codes for `lua_do*' and the like */
+#define LUA_ERRRUN	1
+#define LUA_ERRFILE	2
+#define LUA_ERRSYNTAX	3
+#define LUA_ERRMEM	4
+#define LUA_ERRERR	5
+
+/* weak-table modes */
+#define LUA_WEAK_KEY	1
+#define LUA_WEAK_VALUE	2
+
 
 typedef struct lua_State lua_State;
 
-typedef void (*lua_CFunction) (lua_State *L);
-
-typedef struct TObject *lua_Object;
-
-#define LUA_NOOBJECT	((lua_Object)0)
+typedef int (*lua_CFunction) (lua_State *L);
 
 
-lua_State     *lua_newstate (const char *s, ...);
-void           lua_close (lua_State *L);
+/*
+** an invalid `tag'
+*/
+#define LUA_NOTAG	(-1)
 
-lua_Object     lua_settagmethod (lua_State *L, int tag, const char *event);
-                                                       /* In: new method */
-lua_Object     lua_gettagmethod (lua_State *L, int tag, const char *event);
+/*
+** tags for basic types
+*/
+#define LUA_TNONE	LUA_NOTAG
 
-int            lua_newtag (lua_State *L);
-int            lua_copytagmethods (lua_State *L, int tagto, int tagfrom);
-void           lua_settag (lua_State *L, int tag); /* In: object */
-
-void           lua_error (lua_State *L, const char *s);
-int            lua_dofile (lua_State *L, const char *filename);
-                                                        /* Out: returns */
-int            lua_dostring (lua_State *L, const char *str);
-                                                        /* Out: returns */
-int            lua_dobuffer (lua_State *L, const char *buff, int size,
-                                         const char *name); /* Out: returns */
-int            lua_callfunction (lua_State *L, lua_Object f);
-					  /* In: parameters; Out: returns */
-
-void	       lua_beginblock (lua_State *L);
-void	       lua_endblock (lua_State *L);
-
-lua_Object     lua_lua2C (lua_State *L, int number);
-#define	       lua_getparam		lua_lua2C
-#define	       lua_getresult		lua_lua2C
-
-const char    *lua_type (lua_State *L, lua_Object obj);
-
-int            lua_isnil (lua_State *L, lua_Object obj);
-int            lua_istable (lua_State *L, lua_Object obj);
-int            lua_isuserdata (lua_State *L, lua_Object obj);
-int            lua_iscfunction (lua_State *L, lua_Object obj);
-int            lua_isnumber (lua_State *L, lua_Object obj);
-int            lua_isstring (lua_State *L, lua_Object obj);
-int            lua_isfunction (lua_State *L, lua_Object obj);
-
-int            lua_equal (lua_State *L, lua_Object o1, lua_Object o2);
-
-double         lua_getnumber (lua_State *L, lua_Object obj);
-const char    *lua_getstring (lua_State *L, lua_Object obj);
-long           lua_strlen (lua_State *L, lua_Object obj);
-lua_CFunction  lua_getcfunction (lua_State *L, lua_Object obj);
-void	      *lua_getuserdata (lua_State *L, lua_Object obj);
+#define LUA_TUSERDATA	0
+#define LUA_TNIL	1
+#define LUA_TNUMBER	2
+#define LUA_TSTRING	3
+#define LUA_TTABLE	4
+#define LUA_TFUNCTION	5
 
 
-void 	       lua_pushnil (lua_State *L);
-void           lua_pushnumber (lua_State *L, double n);
-void           lua_pushlstring (lua_State *L, const char *s, long len);
-void           lua_pushstring (lua_State *L, const char *s);
-void           lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
-void           lua_pushusertag (lua_State *L, void *u, int tag);
-void           lua_pushobject (lua_State *L, lua_Object obj);
+/* minimum Lua stack available to a C function */
+#define LUA_MINSTACK	20
 
-lua_Object     lua_pop (lua_State *L);
 
-lua_Object     lua_getglobal (lua_State *L, const char *name);
-lua_Object     lua_rawgetglobal (lua_State *L, const char *name);
-void           lua_setglobal (lua_State *L, const char *name); /* In: value */
-void           lua_rawsetglobal (lua_State *L, const char *name);/* In: value */
+/*
+** generic extra include file
+*/
+#ifdef LUA_USER_H
+#include LUA_USER_H
+#endif
 
-void           lua_settable (lua_State *L); /* In: table, index, value */
-void           lua_rawsettable (lua_State *L); /* In: table, index, value */
-lua_Object     lua_gettable (lua_State *L); /* In: table, index */
-lua_Object     lua_rawgettable (lua_State *L); /* In: table, index */
 
-int            lua_tag (lua_State *L, lua_Object obj);
+/* Lua numerical type */
+#ifndef LUA_NUMBER
+#define LUA_NUMBER	double
+#endif
+typedef LUA_NUMBER lua_Number;
 
-const char    *lua_nextvar (lua_State *L, const char *varname); /* Out: value */
-int            lua_next (lua_State *L, lua_Object o, int i);
-						/* Out: ref, value */ 
+/* Lua character type */
+#ifndef L_CHAR
+#define L_CHAR	char
+#endif
+typedef L_CHAR lua_char;
 
-int            lua_ref (lua_State *L, int lock); /* In: value */
-lua_Object     lua_getref (lua_State *L, int ref);
-void	       lua_unref (lua_State *L, int ref);
 
-lua_Object     lua_createtable (lua_State *L);
+/* mark for all API functions */
+#ifndef LUA_API
+#define LUA_API		extern
+#endif
 
-long	       lua_collectgarbage (lua_State *L, long limit);
+
+/*
+** state manipulation
+*/
+LUA_API lua_State *lua_newthread (lua_State *L, int stacksize);
+LUA_API void       lua_close (lua_State *L);
+
+
+/*
+** basic stack manipulation
+*/
+LUA_API int   lua_gettop (lua_State *L);
+LUA_API void  lua_settop (lua_State *L, int index);
+LUA_API void  lua_pushvalue (lua_State *L, int index);
+LUA_API void  lua_remove (lua_State *L, int index);
+LUA_API void  lua_insert (lua_State *L, int index);
+LUA_API int   lua_stackspace (lua_State *L);
+
+
+/*
+** access functions (stack -> C)
+*/
+
+LUA_API const lua_char *lua_type (lua_State *L, int index);
+LUA_API int             lua_isnumber (lua_State *L, int index);
+LUA_API int             lua_isstring (lua_State *L, int index);
+LUA_API int             lua_iscfunction (lua_State *L, int index);
+LUA_API int             lua_tag (lua_State *L, int index);
+LUA_API int             lua_rawtag (lua_State *L, int index);
+
+LUA_API int            lua_equal (lua_State *L, int index1, int index2);
+LUA_API int            lua_lessthan (lua_State *L, int index1, int index2);
+
+LUA_API lua_Number      lua_tonumber (lua_State *L, int index);
+LUA_API const lua_char *lua_tostring (lua_State *L, int index);
+LUA_API size_t          lua_strlen (lua_State *L, int index);
+LUA_API lua_CFunction   lua_tocfunction (lua_State *L, int index);
+LUA_API void	       *lua_touserdata (lua_State *L, int index);
+LUA_API const void     *lua_topointer (lua_State *L, int index);
+
+
+/*
+** push functions (C -> stack)
+*/
+LUA_API void  lua_pushnil (lua_State *L);
+LUA_API void  lua_pushnumber (lua_State *L, lua_Number n);
+LUA_API void  lua_pushlstring (lua_State *L, const lua_char *s, size_t len);
+LUA_API void  lua_pushstring (lua_State *L, const lua_char *s);
+LUA_API void  lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);
+
+
+/*
+** get functions (Lua -> stack)
+*/
+LUA_API void  lua_getglobal (lua_State *L, const lua_char *name);
+LUA_API void  lua_gettable (lua_State *L, int index);
+LUA_API void  lua_rawget (lua_State *L, int index);
+LUA_API void  lua_rawgeti (lua_State *L, int index, int n);
+LUA_API void  lua_getglobals (lua_State *L);
+LUA_API void  lua_gettagmethod (lua_State *L, int tag, const lua_char *event);
+LUA_API int   lua_getref (lua_State *L, int ref);
+LUA_API void  lua_newtable (lua_State *L);
+LUA_API void  lua_getregistry (lua_State *L);
+LUA_API void  lua_getweakregistry (lua_State *L);
+
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void  lua_setglobal (lua_State *L, const lua_char *name);
+LUA_API void  lua_settable (lua_State *L, int index);
+LUA_API void  lua_rawset (lua_State *L, int index);
+LUA_API void  lua_rawseti (lua_State *L, int index, int n);
+LUA_API void  lua_setglobals (lua_State *L);
+LUA_API void  lua_settagmethod (lua_State *L, int tag, const lua_char *event);
+LUA_API int   lua_ref (lua_State *L, int lock);
+
+
+/*
+** `load' and `do' functions (load and run Lua code)
+*/
+LUA_API int   lua_call (lua_State *L, int nargs, int nresults);
+LUA_API void  lua_rawcall (lua_State *L, int nargs, int nresults);
+LUA_API int   lua_loadfile (lua_State *L, const lua_char *filename);
+LUA_API int   lua_dofile (lua_State *L, const lua_char *filename);
+LUA_API int   lua_dostring (lua_State *L, const lua_char *str);
+LUA_API int   lua_loadbuffer (lua_State *L, const lua_char *buff, size_t size,
+                            const lua_char *name);
+LUA_API int   lua_dobuffer (lua_State *L, const lua_char *buff, size_t size,
+                            const lua_char *name);
+
+/*
+** Garbage-collection functions
+*/
+LUA_API int   lua_getgcthreshold (lua_State *L);
+LUA_API int   lua_getgccount (lua_State *L);
+LUA_API void  lua_setgcthreshold (lua_State *L, int newthreshold);
+
+/*
+** miscellaneous functions
+*/
+LUA_API int   lua_newtype (lua_State *L, const lua_char *name, int basictype);
+LUA_API int   lua_copytagmethods (lua_State *L, int tagto, int tagfrom);
+LUA_API void  lua_settag (lua_State *L, int tag);
+
+LUA_API int             lua_name2tag (lua_State *L, const lua_char *name);
+LUA_API const lua_char *lua_tag2name (lua_State *L, int tag);
+
+LUA_API void  lua_error (lua_State *L, const lua_char *s);
+
+LUA_API void  lua_unref (lua_State *L, int ref);
+
+LUA_API int   lua_next (lua_State *L, int index);
+LUA_API int   lua_getn (lua_State *L, int index);
+
+LUA_API void  lua_concat (lua_State *L, int n);
+
+LUA_API void *lua_newuserdata (lua_State *L, size_t size);
+LUA_API void  lua_newuserdatabox (lua_State *L, void *u);
+
+LUA_API void  lua_setweakmode (lua_State *L, int mode);
+LUA_API int   lua_getweakmode (lua_State *L, int index);
 
 
 
@@ -119,109 +231,89 @@ long	       lua_collectgarbage (lua_State *L, long limit);
 ** ===============================================================
 */
 
-#ifdef LUA_REENTRANT
+#define lua_open(n)		lua_newthread(NULL, (n))
+
+#define lua_pop(L,n)		lua_settop(L, -(n)-1)
 
-#define lua_call(L,name)	lua_callfunction(L, lua_getglobal(L, name))
-#define lua_pushref(L,ref)	lua_pushobject(L, lua_getref(L, ref))
-#define lua_refobject(L,o,l)	(lua_pushobject(L, o), lua_ref(L, l))
 #define lua_register(L,n,f)	(lua_pushcfunction(L, f), lua_setglobal(L, n))
-#define lua_pushuserdata(L,u)	lua_pushusertag(L, u, 0)
 #define lua_pushcfunction(L,f)	lua_pushcclosure(L, f, 0)
 #define lua_clonetag(L,t)	lua_copytagmethods(L, lua_newtag(L), (t))
 
-#else
+#define lua_isfunction(L,n)	(lua_rawtag(L,n) == LUA_TFUNCTION)
+#define lua_istable(L,n)	(lua_rawtag(L,n) == LUA_TTABLE)
+#define lua_isuserdata(L,n)	(lua_rawtag(L,n) == LUA_TUSERDATA)
+#define lua_isnil(L,n)		(lua_rawtag(L,n) == LUA_TNIL)
+#define lua_isnull(L,n)		(lua_rawtag(L,n) == LUA_TNONE)
 
-#define lua_call(name)		lua_callfunction(lua_getglobal(name))
-#define lua_pushref(ref)	lua_pushobject(lua_getref(ref))
-#define lua_refobject(o,l)	(lua_pushobject(o), lua_ref(l))
-#define lua_register(n,f)	(lua_pushcfunction(f), lua_setglobal(n))
-#define lua_pushuserdata(u)	lua_pushusertag(u, 0)
-#define lua_pushcfunction(f)	lua_pushcclosure(f, 0)
-#define lua_clonetag(t)		lua_copytagmethods(lua_newtag(), (t))
-
-#endif
+#define lua_pushliteral(L, s)	lua_pushlstring(L, s, \
+                                                (sizeof(s)/sizeof(lua_char))-1)
 
 
 
-#ifndef LUA_REENTRANT
-/* 
-** ===============================================================
-** Macros for single-state use
-** ===============================================================
-*/
-
-extern lua_State *lua_state;
-
-#define lua_open()	((void)(lua_state?0:(lua_state=lua_newstate(0))))
-
-#define lua_close()		(lua_close)(lua_state)
-#define lua_settagmethod(tag,event)	(lua_settagmethod)(lua_state, tag,event)
-#define lua_gettagmethod(tag,event)	(lua_gettagmethod)(lua_state, tag,event)
-#define lua_newtag()		(lua_newtag)(lua_state)
-#define lua_copytagmethods(tagto,tagfrom)	\
-		(lua_copytagmethods)(lua_state, tagto,tagfrom)
-#define lua_settag(tag)		(lua_settag)(lua_state, tag)
-#define lua_error(s)		(lua_error)(lua_state, s)
-#define lua_dofile(filename)	(lua_dofile)(lua_state, filename)
-#define lua_dostring(str)	(lua_dostring)(lua_state, str)
-#define lua_callfunction(f)	(lua_callfunction)(lua_state, f)
-#define lua_beginblock()	(lua_beginblock)(lua_state)
-#define lua_endblock()		(lua_endblock)(lua_state)
-#define lua_lua2C(number)	(lua_lua2C)(lua_state, number)
-#define lua_type(obj)		(lua_type)(lua_state, obj)
-#define lua_isnil(obj)		(lua_isnil)(lua_state, obj)
-#define lua_istable(obj)	(lua_istable)(lua_state, obj)
-#define lua_isuserdata(obj)	(lua_isuserdata)(lua_state, obj)
-#define lua_iscfunction(obj)	(lua_iscfunction)(lua_state, obj)
-#define lua_isnumber(obj)	(lua_isnumber)(lua_state, obj)
-#define lua_isstring(obj)	(lua_isstring)(lua_state, obj)
-#define lua_isfunction(obj)	(lua_isfunction)(lua_state, obj)
-#define lua_equal(o1,o2)	(lua_equal)(lua_state, o1,o2)
-#define lua_getnumber(obj)	(lua_getnumber)(lua_state, obj)
-#define lua_getstring(obj)	(lua_getstring)(lua_state, obj)
-#define lua_strlen(obj)		(lua_strlen)(lua_state, obj)
-#define lua_getcfunction(obj)	(lua_getcfunction)(lua_state, obj)
-#define lua_getuserdata(obj)	(lua_getuserdata)(lua_state, obj)
-#define lua_pushnil()		(lua_pushnil)(lua_state)
-#define lua_pushnumber(n)	(lua_pushnumber)(lua_state, n)
-#define lua_pushlstring(s,len)	(lua_pushlstring)(lua_state, s,len)
-#define lua_pushstring(s)	(lua_pushstring)(lua_state, s)
-#define lua_pushusertag(u,tag)	(lua_pushusertag)(lua_state, u,tag)
-#define lua_pushobject(obj)	(lua_pushobject)(lua_state, obj)
-#define lua_pop()		(lua_pop)(lua_state)
-#define lua_getglobal(name)	(lua_getglobal)(lua_state, name)
-#define lua_rawgetglobal(name)	(lua_rawgetglobal)(lua_state, name)
-#define lua_setglobal(name)	(lua_setglobal)(lua_state, name)
-#define lua_rawsetglobal(name)	(lua_rawsetglobal)(lua_state, name)
-#define lua_settable()		(lua_settable)(lua_state)
-#define lua_rawsettable()	(lua_rawsettable)(lua_state)
-#define lua_gettable()		(lua_gettable)(lua_state)
-#define lua_rawgettable()	(lua_rawgettable)(lua_state)
-#define lua_tag(obj)		(lua_tag)(lua_state, obj)
-#define lua_nextvar(varname)	(lua_nextvar)(lua_state, varname)
-#define lua_next(o,i)		(lua_next)(lua_state, o,i)
-#define lua_ref(lock)		(lua_ref)(lua_state, lock)
-#define lua_getref(ref)		(lua_getref)(lua_state, ref)
-#define lua_unref(ref)		(lua_unref)(lua_state, ref)
-#define lua_createtable()	(lua_createtable)(lua_state)
-#define lua_collectgarbage(limit)	(lua_collectgarbage)(lua_state, limit)
 /*
-** the following typecast is a little dirty, but we know of no other
-** way to keep compatibility with old definition of `lua_CFunction'
+** compatibility macros
 */
-#define lua_pushcclosure(fn,n) \
-		(lua_pushcclosure)(lua_state, (lua_CFunction)(fn), n)
+#define lua_newtag(L)	lua_newtype(L, NULL, LUA_TNONE)
+#define lua_typename	lua_tag2name
 
 #endif
 
 
+
+/*
+** {======================================================================
+** useful definitions for Lua kernel and libraries
+*/
+#ifdef LUA_PRIVATE
+
+#define l_char	lua_char
+
+/* macro to control type of literal strings */
+#ifndef l_s
+#define l_s(x)  x
 #endif
 
+/* macro to control type of literal chars */
+#ifndef l_c
+#define l_c(x)  x
+#endif
+
+/* macro to `unsign' a character */
+#ifndef uchar
+#define uchar(c)        ((unsigned char)(c))
+#endif
+
+/* integer type to hold the result of fgetc */
+#ifndef l_charint
+#define l_charint	int
+#endif
+
+/*
+** formats for Lua numbers
+*/
+#ifndef LUA_NUMBER_SCAN
+#define LUA_NUMBER_SCAN		"%lf"
+#endif
+#ifndef LUA_NUMBER_FMT
+#define LUA_NUMBER_FMT		"%.16g"
+#endif
+/* function to convert a lua_Number to a string */
+#ifndef lua_number2str
+#define lua_number2str(s,n)     sprintf((s), l_s(LUA_NUMBER_FMT), (n))
+#endif
+
+/* function to convert a string to a lua_Number */
+#ifndef lua_str2number
+#define lua_str2number(s,p)     strtod((s), (p))
+#endif
+
+#endif
+/* }====================================================================== */
 
 
 
 /******************************************************************************
-* Copyright (C) 1994-2000 TeCGraf, PUC-Rio.  All rights reserved.
+* Copyright (C) 1994-2001 TeCGraf, PUC-Rio.  All rights reserved.
 * 
 * Permission is hereby granted, without written agreement and without license
 * or royalty fees, to use, copy, modify, and distribute this software and its
@@ -254,3 +346,4 @@ extern lua_State *lua_state;
 *
 * This implementation contains no third-party code.
 ******************************************************************************/
+

luadebug.h

@@ -1,5 +1,5 @@
 /*
-** $Id: luadebug.h,v 1.9 2000/01/19 12:00:45 roberto Exp roberto $
+** $Id: luadebug.h,v 1.19 2001/03/07 18:09:25 roberto Exp roberto $
 ** Debugging API
 ** See Copyright Notice in lua.h
 */
@@ -17,37 +17,29 @@ typedef struct lua_Localvar lua_Localvar;
 typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
 
 
-int lua_getstack (lua_State *L, int level, lua_Debug *ar);
-int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);
-int lua_getlocal (lua_State *L, const lua_Debug *ar, lua_Localvar *v);
-int lua_setlocal (lua_State *L, const lua_Debug *ar, lua_Localvar *v);
+LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar);
+LUA_API int lua_getinfo (lua_State *L, const lua_char *what, lua_Debug *ar);
+LUA_API const lua_char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const lua_char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);
 
-int lua_setdebug (lua_State *L, int debug);
-
-lua_Hook lua_setcallhook (lua_State *L, lua_Hook func);
-lua_Hook lua_setlinehook (lua_State *L, lua_Hook func);
+LUA_API lua_Hook lua_setcallhook (lua_State *L, lua_Hook func);
+LUA_API lua_Hook lua_setlinehook (lua_State *L, lua_Hook func);
 
 
+#define LUA_IDSIZE	60
 
 struct lua_Debug {
-  const char *event;     /* `call', `return' */
-  const char *source;    /* (S) */
-  int linedefined;       /* (S) */
-  const char *what;      /* (S) `Lua' function, `C' function, Lua `main' */
+  const lua_char *event;     /* `call', `return' */
   int currentline;       /* (l) */
-  const char *name;      /* (n) */
-  const char *namewhat;  /* (n) global, tag method, local, field */
+  const lua_char *name;      /* (n) */
+  const lua_char *namewhat;  /* (n) `global', `tag method', `local', `field' */
   int nups;              /* (u) number of upvalues */
-  lua_Object func;       /* (f) function being executed */
+  int linedefined;       /* (S) */
+  const lua_char *what;      /* (S) `Lua' function, `C' function, Lua `main' */
+  const lua_char *source;    /* (S) */
+  lua_char short_src[LUA_IDSIZE]; /* (S) */
   /* private part */
-  lua_Object _func;  /* active function */
-};
-
-
-struct lua_Localvar {
-  int index;
-  const char *name;
-  lua_Object value;
+  struct CallInfo *_ci;  /* active function */
 };
 
 

lualib.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lualib.h,v 1.7 1999/08/16 20:52:00 roberto Exp roberto $
+** $Id: lualib.h,v 1.20 2001/03/06 20:09:38 roberto Exp roberto $
 ** Lua standard libraries
 ** See Copyright Notice in lua.h
 */
@@ -10,36 +10,19 @@
 
 #include "lua.h"
 
-void lua_iolibopen (lua_State *L);
-void lua_strlibopen (lua_State *L);
-void lua_mathlibopen (lua_State *L);
-void lua_dblibopen (lua_State *L);
-
-
-void lua_userinit (lua_State *L);
-
-
-/* 
-** ===============================================================
-** Macros for single-state use
-** ===============================================================
-*/
-
-#ifndef LUA_REENTRANT
-
-#define lua_iolibopen()		(lua_iolibopen)(lua_state)
-#define lua_strlibopen()	(lua_strlibopen)(lua_state)
-#define lua_mathlibopen()	(lua_mathlibopen)(lua_state)
-#define lua_dblibopen()		(lua_dblibopen)(lua_state)
-#define lua_userinit()		(lua_userinit)(lua_state)
 
+#ifndef LUALIB_API
+#define LUALIB_API	extern
 #endif
 
 
+#define LUA_ALERT               "_ALERT"
 
-/* Auxiliary functions (private) */
+LUALIB_API int lua_baselibopen (lua_State *L);
+LUALIB_API int lua_iolibopen (lua_State *L);
+LUALIB_API int lua_strlibopen (lua_State *L);
+LUALIB_API int lua_mathlibopen (lua_State *L);
+LUALIB_API int lua_dblibopen (lua_State *L);
 
-const char *luaI_classend (lua_State *L, const char *p);
-int luaI_singlematch (int c, const char *p, const char *ep);
 
 #endif

lundump.c

@@ -1,33 +1,34 @@
 /*
-** $Id: lundump.c,v 1.28 2000/04/24 19:32:58 lhf Exp $
-** load bytecodes from files
+** $Id: lundump.c,v 1.36 2001/07/19 14:34:06 lhf Exp lhf $
+** load pre-compiled Lua chunks
 ** See Copyright Notice in lua.h
 */
 
 #include <stdio.h>
 #include <string.h>
 
-#define LUA_REENTRANT
+#define LUA_PRIVATE
+#include "lua.h"
 
-#include "lauxlib.h"
+#include "ldebug.h"
 #include "lfunc.h"
 #include "lmem.h"
 #include "lopcodes.h"
 #include "lstring.h"
 #include "lundump.h"
 
-#define	LoadBlock(L,b,size,Z)	ezread(L,Z,b,size)
 #define	LoadByte		ezgetc
+#define	LoadShort		(short) LoadInt
 
-static const char* ZNAME(ZIO* Z)
+static const l_char* ZNAME (ZIO* Z)
 {
- const char* s=zname(Z);
- return (*s=='@') ? s+1 : s;
+ const l_char* s=zname(Z);
+ return (*s==l_c('@')) ? s+1 : s;
 }
 
 static void unexpectedEOZ (lua_State* L, ZIO* Z)
 {
- luaL_verror(L,"unexpected end of file in `%.255s'",ZNAME(Z));
+ luaO_verror(L,l_s("unexpected end of file in `%.99s'"),ZNAME(Z));
 }
 
 static int ezgetc (lua_State* L, ZIO* Z)
@@ -43,236 +44,221 @@ static void ezread (lua_State* L, ZIO* Z, void* b, int n)
  if (r!=0) unexpectedEOZ(L,Z);
 }
 
-static unsigned int LoadWord (lua_State* L, ZIO* Z)
+static void LoadBlock (lua_State* L, void* b, size_t size, ZIO* Z, int swap)
 {
- unsigned int hi=ezgetc(L,Z);
- unsigned int lo=ezgetc(L,Z);
- return (hi<<8)|lo;
+ if (swap)
+ {
+  l_char *p=(l_char*) b+size-1;
+  int n=size;
+  while (n--) *p--=(l_char)ezgetc(L,Z);
+ }
+ else
+  ezread(L,Z,b,size);
 }
 
-static unsigned long LoadLong (lua_State* L, ZIO* Z)
+static void LoadVector (lua_State* L, void* b, int m, size_t size, ZIO* Z, int swap)
 {
- unsigned long hi=LoadWord(L,Z);
- unsigned long lo=LoadWord(L,Z);
- return (hi<<16)|lo;
+ if (swap)
+ {
+  l_char *q=(l_char*) b;
+  while (m--)
+  {
+   l_char *p=q+size-1;
+   int n=size;
+   while (n--) *p--=(l_char)ezgetc(L,Z);
+   q+=size;
+  }
+ }
+ else
+  ezread(L,Z,b,m*size);
 }
 
-static Number LoadNumber (lua_State* L, ZIO* Z)
+static int LoadInt (lua_State* L, ZIO* Z, int swap)
 {
- char b[256];
- int size=ezgetc(L,Z);
- LoadBlock(L,b,size,Z);
- b[size]=0;
- return luaU_str2d(L,b,ZNAME(Z));
+ int x;
+ LoadBlock(L,&x,sizeof(x),Z,swap);
+ return x;
 }
 
-static int LoadInt (lua_State* L, ZIO* Z, const char* message)
+static size_t LoadSize (lua_State* L, ZIO* Z, int swap)
 {
- unsigned long l=LoadLong(L,Z);
- unsigned int i=l;
- if (i!=l) luaL_verror(L,"%s in `%.255s';\n"
-		"  read %lu; expected %u",message,ZNAME(Z),l,-1);
- return i;
+ size_t x;
+ LoadBlock(L,&x,sizeof(x),Z,swap);
+ return x;
 }
 
-static TString* LoadString (lua_State* L, ZIO* Z)
+static lua_Number LoadNumber (lua_State* L, ZIO* Z, int swap)
 {
- long size=LoadLong(L,Z);
+ lua_Number x;
+ LoadBlock(L,&x,sizeof(x),Z,swap);
+ return x;
+}
+
+static TString* LoadString (lua_State* L, ZIO* Z, int swap)
+{
+ size_t size=LoadSize(L,Z,swap);
  if (size==0)
   return NULL;
  else
  {
-  char* s=luaL_openspace(L,size);
-  LoadBlock(L,s,size,Z);
+  l_char* s=luaO_openspace(L,size,l_char);
+  LoadBlock(L,s,size,Z,0);
   return luaS_newlstr(L,s,size-1);	/* remove trailing '\0' */
  }
 }
 
-static void SwapCode (lua_State* L, Instruction* code, int size, ZIO* Z)
+static void LoadCode (lua_State* L, Proto* f, ZIO* Z, int swap)
 {
- unsigned char* p;
- int c;
- if (sizeof(Instruction)==4)
-  while (size--)
-  {
-   p=(unsigned char *) code++;
-   c=p[0]; p[0]=p[3]; p[3]=c;
-   c=p[1]; p[1]=p[2]; p[2]=c;
-  }
- else if (sizeof(Instruction)==2)
-  while (size--)
-  {
-   p=(unsigned char *) code++;
-   c=p[0]; p[0]=p[1]; p[1]=c;
-  }
- else
-  luaL_verror(L,"cannot swap code with %d-byte instructions in `%.255s'",
-	(int)sizeof(Instruction),ZNAME(Z));
+ int size=LoadInt(L,Z,swap);
+ f->code=luaM_newvector(L,size,Instruction);
+ f->sizecode=size;
+ LoadVector(L,f->code,size,sizeof(*f->code),Z,swap);
 }
 
-static void LoadCode (lua_State* L, Proto* tf, ZIO* Z)
-{
- int size=LoadInt(L,Z,"code too long");
- Instruction t=0,tt=TEST_CODE;
- tf->code=luaM_newvector(L,size,Instruction);
- LoadBlock(L,tf->code,size*sizeof(*tf->code),Z);
- if (tf->code[size-1]!=OP_END) luaL_verror(L,"bad code in `%.255s'",ZNAME(Z));
- LoadBlock(L,&t,sizeof(t),Z);
- if (t!=tt)
- {
-  Instruction ot=t;
-  SwapCode(L,&t,1,Z);
-  if (t!=tt) luaL_verror(L,"cannot swap code in `%.255s';\n"
-	"  read 0x%08X; swapped to 0x%08X; expected 0x%08X",
-	ZNAME(Z),(unsigned long)ot,(unsigned long)t,(unsigned long)tt);
-  SwapCode(L,tf->code,size,Z);
- }
-}
-
-static void LoadLocals (lua_State* L, Proto* tf, ZIO* Z)
-{
- int i,n=LoadInt(L,Z,"too many locals");
- if (n==0) return;
- tf->locvars=luaM_newvector(L,n+1,LocVar);
- for (i=0; i<n; i++)
- {
-  tf->locvars[i].line=LoadInt(L,Z,"too many lines");
-  tf->locvars[i].varname=LoadString(L,Z);
- }
- tf->locvars[i].line=-1;		/* flag end of vector */
- tf->locvars[i].varname=NULL;
-}
-
-static Proto* LoadFunction (lua_State* L, ZIO* Z, int native);
-
-static void LoadConstants (lua_State* L, Proto* tf, ZIO* Z, int native)
+static void LoadLocals (lua_State* L, Proto* f, ZIO* Z, int swap)
 {
  int i,n;
- tf->nkstr=n=LoadInt(L,Z,"too many strings");
- if (n>0)
+ n=LoadInt(L,Z,swap);
+ f->locvars=luaM_newvector(L,n,LocVar);
+ f->sizelocvars=n;
+ for (i=0; i<n; i++)
  {
-  tf->kstr=luaM_newvector(L,n,TString*);
-  for (i=0; i<n; i++)
-  {
-   TString* s=LoadString(L,Z);
-   int isglobal=LoadByte(L,Z);
-   if (isglobal) luaS_assertglobal(L,s);
-   tf->kstr[i]=s;
-  }
- }
- tf->nknum=n=LoadInt(L,Z,"too many numbers");
- if (n>0)
- {
-  tf->knum=luaM_newvector(L,n,Number);
-  if (native)
-   LoadBlock(L,tf->knum,n*sizeof(*tf->knum),Z);
-  else
-   for (i=0; i<n; i++) tf->knum[i]=LoadNumber(L,Z);
- }
- tf->nkproto=n=LoadInt(L,Z,"too many functions");
- if (n>0)
- {
-  tf->kproto=luaM_newvector(L,n,Proto*);
-  for (i=0; i<n; i++) tf->kproto[i]=LoadFunction(L,Z,native);
+  f->locvars[i].varname=LoadString(L,Z,swap);
+  f->locvars[i].startpc=LoadInt(L,Z,swap);
+  f->locvars[i].endpc=LoadInt(L,Z,swap);
  }
 }
 
-static Proto* LoadFunction (lua_State* L, ZIO* Z, int native)
+static void LoadLines (lua_State* L, Proto* f, ZIO* Z, int swap)
 {
- Proto* tf=luaF_newproto(L);
- tf->source=LoadString(L,Z);
- if (tf->source==NULL) tf->source=luaS_new(L,zname(Z));
- tf->lineDefined=LoadInt(L,Z,"lineDefined too large");
- tf->numparams=LoadInt(L,Z,"too many parameters");
- tf->is_vararg=LoadByte(L,Z);
- tf->maxstacksize=LoadInt(L,Z,"too much stack needed");
- LoadCode(L,tf,Z);
- LoadLocals(L,tf,Z);
- LoadConstants(L,tf,Z,native);
- return tf;
+ int n;
+ n=LoadInt(L,Z,swap);
+ f->lineinfo=luaM_newvector(L,n,int);
+ f->sizelineinfo=n;
+ LoadVector(L,f->lineinfo,n,sizeof(*f->lineinfo),Z,swap);
+}
+
+static Proto* LoadFunction (lua_State* L, TString* p, ZIO* Z, int swap);
+
+static void LoadConstants (lua_State* L, Proto* f, ZIO* Z, int swap)
+{
+ int i,n;
+ n=LoadInt(L,Z,swap);
+ f->k=luaM_newvector(L,n,TObject);
+ f->sizek=n;
+ for (i=0; i<n; i++)
+ {
+  TObject* o=&f->k[i];
+  ttype(o)=LoadByte(L,Z);
+  switch (ttype(o))
+  {
+   case LUA_TNUMBER:
+	nvalue(o)=LoadNumber(L,Z,swap);
+	break;
+   case LUA_TSTRING:
+	tsvalue(o)=LoadString(L,Z,swap);
+	break;
+   default:
+	luaO_verror(L,l_s("bad constant type (%d) in `%.99s'"),ttype(o),ZNAME(Z));
+	break;
+  }
+ }
+ n=LoadInt(L,Z,swap);
+ f->p=luaM_newvector(L,n,Proto*);
+ f->sizep=n;
+ for (i=0; i<n; i++) f->p[i]=LoadFunction(L,f->source,Z,swap);
+}
+
+static Proto* LoadFunction (lua_State* L, TString* p, ZIO* Z, int swap)
+{
+ Proto* f=luaF_newproto(L);
+ f->source=LoadString(L,Z,swap); if (f->source==NULL) f->source=p;
+ f->lineDefined=LoadInt(L,Z,swap);
+ f->nupvalues=LoadShort(L,Z,swap);
+ f->numparams=LoadShort(L,Z,swap);
+ f->is_vararg=LoadShort(L,Z,swap);
+ f->maxstacksize=LoadShort(L,Z,swap);
+ LoadLocals(L,f,Z,swap);
+ LoadLines(L,f,Z,swap);
+ LoadConstants(L,f,Z,swap);
+ LoadCode(L,f,Z,swap);
+#ifndef TRUST_BINARIES
+ if (!luaG_checkcode(f)) luaO_verror(L,l_s("bad code in `%.99s'"),ZNAME(Z));
+#endif
+ return f;
 }
 
 static void LoadSignature (lua_State* L, ZIO* Z)
 {
- const char* s=SIGNATURE;
+ const l_char* s=l_s(LUA_SIGNATURE);
  while (*s!=0 && ezgetc(L,Z)==*s)
   ++s;
- if (*s!=0) luaL_verror(L,"bad signature in `%.255s'",ZNAME(Z));
+ if (*s!=0) luaO_verror(L,l_s("bad signature in `%.99s'"),ZNAME(Z));
 }
 
-#define V(v)	v/16,v%16
+static void TestSize (lua_State* L, int s, const l_char* what, ZIO* Z)
+{
+ int r=LoadByte(L,Z);
+ if (r!=s)
+  luaO_verror(L,l_s("virtual machine mismatch in `%.99s':\n")
+	l_s("  size of %.20s is %d but read %d"),ZNAME(Z),what,s,r);
+}
+
+#define TESTSIZE(s,w)	TestSize(L,s,w,Z)
+#define V(v)		v/16,v%16
 
 static int LoadHeader (lua_State* L, ZIO* Z)
 {
- int version,sizeofR,native;
+ int version,swap;
+ lua_Number x=0,tx=TEST_NUMBER;
  LoadSignature(L,Z);
- version=ezgetc(L,Z);
+ version=LoadByte(L,Z);
  if (version>VERSION)
-  luaL_verror(L,"`%.255s' too new:\n"
-	"  read version %d.%d; expected at most %d.%d",
+  luaO_verror(L,l_s("`%.99s' too new:\n")
+	l_s("  read version %d.%d; expected at most %d.%d"),
 	ZNAME(Z),V(version),V(VERSION));
  if (version<VERSION0)			/* check last major change */
-  luaL_verror(L,"`%.255s' too old:\n"
-	"  read version %d.%d; expected at least %d.%d",
+  luaO_verror(L,l_s("`%.99s' too old:\n")
+	l_s("  read version %d.%d; expected at least %d.%d"),
 	ZNAME(Z),V(version),V(VERSION));
- {
-  int I=ezgetc(L,Z);
-  int i=ezgetc(L,Z);
-  int op=ezgetc(L,Z);
-  int b=ezgetc(L,Z);
-  if (I!=sizeof(Instruction) || i!=SIZE_INSTRUCTION || op!=SIZE_OP || b!=SIZE_B)
-   luaL_verror(L,"virtual machine mismatch in `%.255s':\n"
-   	"  read %d-bit,%d-byte instructions, %d-bit opcodes, %d-bit b-arguments;\n"
-   	"  expected %d-bit,%d-byte instructions, %d-bit opcodes, %d-bit b-arguments",
-	ZNAME(Z),i,I,op,b,SIZE_INSTRUCTION,(int)sizeof(Instruction),SIZE_OP,SIZE_B);
- }
- sizeofR=ezgetc(L,Z);
- native=(sizeofR!=0);
- if (native)				/* test number representation */
- {
-  if (sizeofR!=sizeof(Number))
-   luaL_verror(L,"native number size mismatch in `%.255s':\n"
-	"  read %d; expected %d",
-	ZNAME(Z),sizeofR,(int)sizeof(Number));
-  else
-  {
-   Number f=0,tf=TEST_NUMBER;
-   LoadBlock(L,&f,sizeof(f),Z);
-   if ((long)f!=(long)tf)		/* disregard errors in last bit of fraction */
-    luaL_verror(L,"unknown number format in `%.255s':\n"
-	"  read " NUMBER_FMT "; expected " NUMBER_FMT,
-	ZNAME(Z),f,tf);
-  }
- }
- return native;
+ swap=(luaU_endianness()!=LoadByte(L,Z));	/* need to swap bytes? */
+ TESTSIZE(sizeof(int),l_s("int"));
+ TESTSIZE(sizeof(size_t), l_s("size_t"));
+ TESTSIZE(sizeof(Instruction), l_s("size_t"));
+ TESTSIZE(SIZE_OP, l_s("OP"));
+ TESTSIZE(SIZE_A, l_s("A"));
+ TESTSIZE(SIZE_B, l_s("B"));
+ TESTSIZE(SIZE_C, l_s("C"));
+ TESTSIZE(sizeof(lua_Number), l_s("number"));
+ x=LoadNumber(L,Z,swap);
+ if ((long)x!=(long)tx)		/* disregard errors in last bits of fraction */
+  luaO_verror(L,l_s("unknown number format in `%.99s':\n")
+      l_s("  read ") l_s(LUA_NUMBER_FMT) l_s("; expected ") l_s(LUA_NUMBER_FMT),
+      ZNAME(Z),x,tx);
+ return swap;
 }
 
 static Proto* LoadChunk (lua_State* L, ZIO* Z)
 {
- return LoadFunction(L,Z,LoadHeader(L,Z));
+ return LoadFunction(L,NULL,Z,LoadHeader(L,Z));
 }
 
 /*
 ** load one chunk from a file or buffer
-** return main if ok and NULL at EOF
 */
-Proto* luaU_undump1 (lua_State* L, ZIO* Z)
+Proto* luaU_undump (lua_State* L, ZIO* Z)
 {
- int c=zgetc(Z);
- if (c==ID_CHUNK)
-  return LoadChunk(L,Z);
- else if (c!=EOZ)
-  luaL_verror(L,"`%.255s' is not a Lua binary file",ZNAME(Z));
- return NULL;
+ Proto* f=LoadChunk(L,Z);
+ if (zgetc(Z)!=EOZ)
+  luaO_verror(L,l_s("`%.99s' apparently contains more than one chunk"),ZNAME(Z));
+ return f;
 }
 
 /*
-* convert number from text
+** find byte order
 */
-double luaU_str2d (lua_State* L, const char* b, const char* where)
+int luaU_endianness (void)
 {
- double x;
- if (!luaO_str2d(b,&x))
-  luaL_verror(L,"cannot convert number `%.255s' in `%.255s'",b,where);
- return x;
+ int x=1;
+ return *(l_char*)&x;
 }

lundump.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lundump.h,v 1.19 2000/04/24 17:32:29 lhf Exp $
+** $Id: lundump.h,v 1.23 2001/06/28 13:55:17 lhf Exp lhf $
 ** load pre-compiled Lua chunks
 ** See Copyright Notice in lua.h
 */
@@ -11,33 +11,18 @@
 #include "lzio.h"
 
 /* load one chunk */
-Proto* luaU_undump1 (lua_State* L, ZIO* Z);
+Proto* luaU_undump (lua_State* L, ZIO* Z);
 
-/* convert number from text */
-double luaU_str2d (lua_State* L, const char* b, const char* where);
+/* find byte order */
+int luaU_endianness (void);
 
 /* definitions for headers of binary files */
-#define	VERSION		0x40		/* last format change was in 4.0 */
-#define	VERSION0	0x40		/* last major  change was in 4.0 */
-#define ID_CHUNK	27		/* binary files start with ESC... */
-#define	SIGNATURE	"Lua"		/* ...followed by this signature */
-
-/* formats for error messages */
-#define xSOURCE		"<%d:%.255s>"
-#define SOURCE		"<%.255s:%d>"
-#define IN		" in %p " SOURCE
-#define INLOC		tf,tf->source->str,tf->lineDefined
-
-/* format for numbers in listings and error messages */
-#ifndef NUMBER_FMT
-#define NUMBER_FMT	"%.16g"		/* LUA_NUMBER */
-#endif
+#define	VERSION		0x41		/* last format change was in 4.1 */
+#define	VERSION0	0x41		/* last major  change was in 4.1 */
+#define	LUA_SIGNATURE	"\033Lua"	/* binary files start with <esc>Lua */
 
 /* a multiple of PI for testing native format */
 /* multiplying by 1E8 gives non-trivial integer values */
 #define	TEST_NUMBER	3.14159265358979323846E8
 
-/* something for testing byte order in instructions */
-#define	TEST_CODE	0x01020304
-
 #endif

lvm.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.h,v 1.20 2000/03/29 20:19:20 roberto Exp roberto $
+** $Id: lvm.h,v 1.29 2001/02/07 18:13:49 roberto Exp roberto $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -13,22 +13,19 @@
 #include "ltm.h"
 
 
-#define tonumber(o)   ((ttype(o) != TAG_NUMBER) && (luaV_tonumber(o) != 0))
-#define tostring(L,o) ((ttype(o) != TAG_STRING) && (luaV_tostring(L, o) != 0))
+#define tostring(L,o) ((ttype(o) != LUA_TSTRING) && (luaV_tostring(L, o) != 0))
 
 
-void luaV_pack (lua_State *L, StkId firstel, int nvararg, TObject *tab);
-int luaV_tonumber (TObject *obj);
+const TObject *luaV_tonumber (const TObject *obj, TObject *n);
 int luaV_tostring (lua_State *L, TObject *obj);
-void luaV_setn (lua_State *L, Hash *t, int val);
-void luaV_gettable (lua_State *L, StkId top);
-void luaV_settable (lua_State *L, StkId t, StkId top);
-void luaV_rawsettable (lua_State *L, StkId t);
-void luaV_getglobal (lua_State *L, GlobalVar *gv, StkId top);
-void luaV_setglobal (lua_State *L, GlobalVar *gv, StkId top);
+void luaV_gettable (lua_State *L, StkId t, TObject *key, StkId res);
+void luaV_settable (lua_State *L, StkId t, TObject *key, StkId val);
+void luaV_getglobal (lua_State *L, TString *s, StkId res);
+void luaV_setglobal (lua_State *L, TString *s, StkId val);
 StkId luaV_execute (lua_State *L, const Closure *cl, StkId base);
 void luaV_Cclosure (lua_State *L, lua_CFunction c, int nelems);
 void luaV_Lclosure (lua_State *L, Proto *l, int nelems);
-int luaV_lessthan (lua_State *L, const TObject *l, const TObject *r, StkId top);
+int luaV_lessthan (lua_State *L, const TObject *l, const TObject *r);
+void luaV_strconc (lua_State *L, int total, StkId top);
 
 #endif

lzio.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lzio.c,v 1.10 2000/02/08 16:39:42 roberto Exp roberto $
+** $Id: lzio.c,v 1.13 2000/06/12 13:52:05 roberto Exp roberto $
 ** a generic input stream interface
 ** See Copyright Notice in lua.h
 */
@@ -9,6 +9,9 @@
 #include <stdio.h>
 #include <string.h>
 
+#define LUA_PRIVATE
+#include "lua.h"
+
 #include "lzio.h"
 
 
@@ -21,7 +24,7 @@ static int zmfilbuf (ZIO* z) {
 }
 
 
-ZIO* zmopen (ZIO* z, const char* b, int size, const char *name) {
+ZIO* zmopen (ZIO* z, const char* b, size_t size, const char *name) {
   if (b==NULL) return NULL;
   z->n = size;
   z->p = (const unsigned char *)b;
@@ -41,7 +44,7 @@ ZIO* zsopen (ZIO* z, const char* s, const char *name) {
 /* -------------------------------------------------------------- FILEs --- */
 
 static int zffilbuf (ZIO* z) {
-  int n;
+  size_t n;
   if (feof((FILE *)z->u)) return EOZ;
   n = fread(z->buffer, 1, ZBSIZE, (FILE *)z->u);
   if (n==0) return EOZ;
@@ -63,13 +66,16 @@ ZIO* zFopen (ZIO* z, FILE* f, const char *name) {
 
 
 /* --------------------------------------------------------------- read --- */
-int zread (ZIO *z, void *b, int n) {
+size_t zread (ZIO *z, void *b, size_t n) {
   while (n) {
-    int m;
+    size_t m;
     if (z->n == 0) {
       if (z->filbuf(z) == EOZ)
         return n;  /* return number of missing bytes */
-      zungetc(z);  /* put result from `filbuf' in the buffer */
+      else {
+        ++z->n;  /* filbuf removed first byte; put back it */
+        --z->p;
+      }
     }
     m = (n <= z->n) ? n : z->n;  /* min. between n and z->n */
     memcpy(b, z->p, m);

lzio.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lzio.h,v 1.4 1998/01/09 14:57:43 roberto Exp roberto $
+** $Id: lzio.h,v 1.7 2000/10/20 16:36:32 roberto Exp roberto $
 ** Buffered streams
 ** See Copyright Notice in lua.h
 */
@@ -24,21 +24,23 @@ typedef struct zio ZIO;
 
 ZIO* zFopen (ZIO* z, FILE* f, const char *name);	/* open FILEs */
 ZIO* zsopen (ZIO* z, const char* s, const char *name);	/* string */
-ZIO* zmopen (ZIO* z, const char* b, int size, const char *name);  /* memory */
+ZIO* zmopen (ZIO* z, const char* b, size_t size, const char *name); /* memory */
 
-int zread (ZIO* z, void* b, int n);	/* read next n bytes */
+size_t zread (ZIO* z, void* b, size_t n);	/* read next n bytes */
 
-#define zgetc(z)	(--(z)->n>=0 ? ((int)*(z)->p++): (z)->filbuf(z))
-#define zungetc(z)	(++(z)->n,--(z)->p)
+#define zgetc(z)	(((z)->n--)>0 ? ((int)*(z)->p++): (z)->filbuf(z))
 #define zname(z)	((z)->name)
 
 
+
 /* --------- Private Part ------------------ */
 
+#ifndef ZBSIZE
 #define ZBSIZE	256			/* buffer size */
+#endif
 
 struct zio {
-  int n;				/* bytes still unread */
+  size_t n;				/* bytes still unread */
   const unsigned char* p;		/* current position in buffer */
   int (*filbuf)(ZIO* z);
   void* u;				/* additional data */

makefile

@@ -1,5 +1,5 @@
 #
-## $Id: makefile,v 1.24 2000/04/14 17:52:09 roberto Exp roberto $
+## $Id: makefile,v 1.31 2001/07/24 17:25:30 roberto Exp roberto $
 ## Makefile
 ## See Copyright Notice in lua.h
 #
@@ -17,18 +17,29 @@
 #
 # define LUA_NUM_TYPE if you need numbers to be different from double
 # (for instance, -DLUA_NUM_TYPE=float)
+# you may need to adapat the code, too.
 #
-# define LUA_COMPAT_READPATTERN if you need read patterns
-# (only for compatibility with previous versions)
 
-CONFIG = -DPOPEN -D_POSIX_SOURCE
-#CONFIG = -DOLD_ANSI -DDEBUG -DLUA_COMPAT_READPATTERN
+#EXTRA_H=-DLUA_USER_H='"ltests.h"'
+
+CONFIG = -DPOPEN -D_POSIX_SOURCE  $(EXTRA_H)
+#CONFIG = -DOLD_ANSI
 
 
 # Compilation parameters
 CC = gcc
-CWARNS = -Wall -W -Wmissing-prototypes -Wshadow -pedantic -Wpointer-arith -Wcast-align -Waggregate-return -Wcast-qual -Wnested-externs -Wwrite-strings
-CFLAGS = $(CONFIG) $(CWARNS) -ansi -O2
+CWARNS = -Wall -W -pedantic \
+	-Waggregate-return \
+	-Wcast-align \
+	-Wmissing-prototypes \
+	-Wnested-externs \
+	-Wpointer-arith \
+	-Wshadow \
+	-Wwrite-strings \
+#	-Wcast-qual
+#	-Wtraditional
+
+CFLAGS = $(CONFIG) $(CWARNS) -ansi -O3 -fomit-frame-pointer
 
 
 # To make early versions
@@ -42,10 +53,7 @@ ARFLAGS	= rvl
 # Aplication modules
 LUAOBJS = \
 	lstate.o \
-	lref.o \
 	lapi.o \
-	lauxlib.o \
-	lbuiltin.o \
 	lmem.o \
 	lstring.o \
 	ltable.o \
@@ -53,23 +61,24 @@ LUAOBJS = \
 	lvm.o \
 	ldo.o \
 	lobject.o \
-	lbuffer.o \
 	lfunc.o \
 	lgc.o \
 	lcode.o \
 	lparser.o \
 	llex.o \
+	lopcodes.o \
 	lundump.o \
 	lzio.o \
 	ldebug.o \
-	ltests.o
+	ltests.o 
 
 LIBOBJS = 	\
+	lauxlib.o \
+	lbaselib.o \
 	liolib.o \
 	lmathlib.o \
 	lstrlib.o \
-	ldblib.o \
-	linit.o
+	ldblib.o
 
 
 lua : lua.o liblua.a liblualib.a
@@ -99,56 +108,51 @@ clear	:
 	co $(CO_OPTIONS) $@
 
 
-lapi.o: lapi.c lapi.h lobject.h llimits.h lua.h lauxlib.h ldo.h \
- lstate.h luadebug.h lfunc.h lgc.h lmem.h lref.h lstring.h ltable.h \
- ltm.h lvm.h
-lauxlib.o: lauxlib.c lauxlib.h lua.h luadebug.h
-lbuffer.o: lbuffer.c lauxlib.h lua.h lmem.h lstate.h lobject.h \
- llimits.h luadebug.h
-lbuiltin.o: lbuiltin.c lapi.h lobject.h llimits.h lua.h lauxlib.h \
- lbuiltin.h ldo.h lstate.h luadebug.h lfunc.h lmem.h lstring.h \
- ltable.h ltm.h lundump.h lzio.h lvm.h
-lcode.o: lcode.c /usr/include/stdlib.h lcode.h llex.h lobject.h \
- llimits.h lua.h lzio.h lopcodes.h lparser.h ldo.h lstate.h luadebug.h \
- lmem.h lstring.h
-ldblib.o: ldblib.c lauxlib.h lua.h luadebug.h lualib.h
-ldebug.o: ldebug.c lapi.h lobject.h llimits.h lua.h lauxlib.h ldebug.h \
- luadebug.h ldo.h lstate.h lfunc.h ltable.h ltm.h
-ldo.o: ldo.c lauxlib.h lua.h ldebug.h lobject.h llimits.h luadebug.h \
- ldo.h lstate.h lgc.h lmem.h lparser.h lzio.h lstring.h ltm.h \
+lapi.o: lapi.c lua.h lapi.h lobject.h llimits.h ldo.h lstate.h \
+ luadebug.h lfunc.h lgc.h lmem.h lstring.h ltable.h ltm.h lvm.h
+lauxlib.o: lauxlib.c lua.h lauxlib.h luadebug.h lualib.h
+lbaselib.o: lbaselib.c lua.h lauxlib.h luadebug.h lualib.h
+lcode.o: lcode.c lua.h lcode.h llex.h lobject.h llimits.h lzio.h \
+ lopcodes.h lparser.h ldebug.h lstate.h luadebug.h ldo.h lmem.h
+ldblib.o: ldblib.c lua.h lauxlib.h luadebug.h lualib.h
+ldebug.o: ldebug.c lua.h lapi.h lobject.h llimits.h lcode.h llex.h \
+ lzio.h lopcodes.h lparser.h ldebug.h lstate.h luadebug.h ldo.h \
+ lfunc.h lstring.h ltable.h ltm.h lvm.h
+ldo.o: ldo.c lua.h ldebug.h lstate.h lobject.h llimits.h luadebug.h \
+ ldo.h lgc.h lmem.h lparser.h lzio.h lstring.h ltable.h ltm.h \
  lundump.h lvm.h
-lfunc.o: lfunc.c lfunc.h lobject.h llimits.h lua.h lmem.h lstate.h \
+lfunc.o: lfunc.c lua.h lfunc.h lobject.h llimits.h lmem.h lstate.h \
  luadebug.h
-lgc.o: lgc.c ldo.h lobject.h llimits.h lua.h lstate.h luadebug.h \
- lfunc.h lgc.h lmem.h lref.h lstring.h ltable.h ltm.h
-linit.o: linit.c lua.h lualib.h
-liolib.o: liolib.c lauxlib.h lua.h luadebug.h lualib.h
-llex.o: llex.c lauxlib.h lua.h llex.h lobject.h llimits.h lzio.h \
- lmem.h lparser.h lstate.h luadebug.h lstring.h
-lmathlib.o: lmathlib.c lauxlib.h lua.h lualib.h
-lmem.o: lmem.c lmem.h lua.h lobject.h llimits.h lstate.h luadebug.h
-lobject.o: lobject.c lobject.h llimits.h lua.h
-lparser.o: lparser.c lcode.h llex.h lobject.h llimits.h lua.h lzio.h \
- lopcodes.h lparser.h ldo.h lstate.h luadebug.h lfunc.h lmem.h \
+lgc.o: lgc.c lua.h ldo.h lobject.h llimits.h lstate.h luadebug.h \
+ lfunc.h lgc.h lmem.h lstring.h ltable.h ltm.h
+liolib.o: liolib.c lua.h lauxlib.h luadebug.h lualib.h
+llex.o: llex.c lua.h llex.h lobject.h llimits.h lzio.h lparser.h \
+ lstate.h luadebug.h lstring.h
+lmathlib.o: lmathlib.c lua.h lauxlib.h lualib.h
+lmem.o: lmem.c lua.h ldo.h lobject.h llimits.h lstate.h luadebug.h \
+ lmem.h
+lobject.o: lobject.c lua.h ldo.h lobject.h llimits.h lstate.h \
+ luadebug.h lmem.h
+lopcodes.o: lopcodes.c lua.h lopcodes.h llimits.h
+lparser.o: lparser.c lua.h lcode.h llex.h lobject.h llimits.h lzio.h \
+ lopcodes.h lparser.h ldebug.h lstate.h luadebug.h lfunc.h lmem.h \
  lstring.h
-lref.o: lref.c lapi.h lobject.h llimits.h lua.h lmem.h lref.h lstate.h \
- luadebug.h
-lstate.o: lstate.c lauxlib.h lua.h lbuiltin.h ldo.h lobject.h \
- llimits.h lstate.h luadebug.h lgc.h llex.h lzio.h lmem.h lref.h \
- lstring.h ltm.h
-lstring.o: lstring.c lmem.h lua.h lobject.h llimits.h lstate.h \
+lstate.o: lstate.c lua.h ldo.h lobject.h llimits.h lstate.h luadebug.h \
+ lgc.h llex.h lzio.h lmem.h lstring.h ltable.h ltm.h
+lstring.o: lstring.c lua.h lmem.h llimits.h lobject.h lstate.h \
  luadebug.h lstring.h
-lstrlib.o: lstrlib.c lauxlib.h lua.h lualib.h
-ltable.o: ltable.c lauxlib.h lua.h lmem.h lobject.h llimits.h lstate.h \
- luadebug.h ltable.h
-ltests.o: ltests.c lapi.h lobject.h llimits.h lua.h lauxlib.h lmem.h \
- lopcodes.h lstate.h luadebug.h lstring.h ltable.h
-ltm.o: ltm.c lauxlib.h lua.h lmem.h lobject.h llimits.h lstate.h \
- luadebug.h ltm.h
+lstrlib.o: lstrlib.c lua.h lauxlib.h lualib.h
+ltable.o: ltable.c lua.h ldo.h lobject.h llimits.h lstate.h luadebug.h \
+ lmem.h ltable.h
+ltests.o: ltests.c lua.h lapi.h lobject.h llimits.h lauxlib.h lcode.h \
+ llex.h lzio.h lopcodes.h lparser.h ldebug.h lstate.h luadebug.h ldo.h \
+ lfunc.h lmem.h lstring.h ltable.h lualib.h
+ltm.o: ltm.c lua.h ldo.h lobject.h llimits.h lstate.h luadebug.h \
+ lmem.h lstring.h ltable.h ltm.h
 lua.o: lua.c lua.h luadebug.h lualib.h
-lundump.o: lundump.c lauxlib.h lua.h lfunc.h lobject.h llimits.h \
- lmem.h lopcodes.h lstring.h lstate.h luadebug.h lundump.h lzio.h
-lvm.o: lvm.c lauxlib.h lua.h ldebug.h lobject.h llimits.h luadebug.h \
- ldo.h lstate.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h ltm.h \
+lundump.o: lundump.c lua.h ldebug.h lstate.h lobject.h llimits.h \
+ luadebug.h lfunc.h lmem.h lopcodes.h lstring.h lundump.h lzio.h
+lvm.o: lvm.c lua.h lapi.h lobject.h llimits.h ldebug.h lstate.h \
+ luadebug.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h ltable.h ltm.h \
  lvm.h
-lzio.o: lzio.c lzio.h
+lzio.o: lzio.c lua.h lzio.h