opening functions must be exported!

during any memory allocation +
'luaT_getvarargs' may reallocate the stack, and therefore the top must
be correct.

.gitignore

@@ -1,13 +0,0 @@
-.gitattributes
-
-*.so
-*.o
-*.a
-
-manual/manual.html
-
-testes/time.txt
-testes/time-debug.txt
-
-testes/libs/all
-

all

@@ -1,7 +0,0 @@
-cd testes
-ulimit -S -s 2000
-if { ../lua all.lua; } then 
-  echo -e "\n\n    final OK!!!!\n\n"
-else
-  echo -e "\n\n    >>>> BUG!!!!\n\n"
-fi

lapi.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.h,v 2.9.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lapi.h,v 2.10 2017/11/01 18:20:48 roberto Exp $
 ** Auxiliary functions from Lua API
 ** See Copyright Notice in lua.h
 */

lauxlib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lauxlib.c,v 1.289.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lauxlib.c,v 1.294 2018/02/27 18:47:32 roberto Exp roberto $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
@@ -76,7 +76,7 @@ static int pushglobalfuncname (lua_State *L, lua_Debug *ar) {
   lua_getfield(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE);
   if (findfield(L, top + 1, 2)) {
     const char *name = lua_tostring(L, -1);
-    if (strncmp(name, "_G.", 3) == 0) {  /* name start with '_G.'? */
+    if (strncmp(name, LUA_GNAME ".", 3) == 0) {  /* name start with '_G.'? */
       lua_pushstring(L, name + 3);  /* push name without prefix */
       lua_remove(L, -2);  /* remove original name */
     }
@@ -480,10 +480,10 @@ static int boxgc (lua_State *L) {
 
 
 static void *newbox (lua_State *L, size_t newsize) {
-  UBox *box = (UBox *)lua_newuserdata(L, sizeof(UBox));
+  UBox *box = (UBox *)lua_newuserdatauv(L, sizeof(UBox), 0);
   box->box = NULL;
   box->bsize = 0;
-  if (luaL_newmetatable(L, "LUABOX")) {  /* creating metatable? */
+  if (luaL_newmetatable(L, "_UBOX*")) {  /* creating metatable? */
     lua_pushcfunction(L, boxgc);
     lua_setfield(L, -2, "__gc");  /* metatable.__gc = boxgc */
   }
@@ -496,7 +496,7 @@ static void *newbox (lua_State *L, size_t newsize) {
 ** check whether buffer is using a userdata on the stack as a temporary
 ** buffer
 */
-#define buffonstack(B)	((B)->b != (B)->initb)
+#define buffonstack(B)	((B)->b != (B)->init.b)
 
 
 /*
@@ -568,7 +568,7 @@ LUALIB_API void luaL_addvalue (luaL_Buffer *B) {
 
 LUALIB_API void luaL_buffinit (lua_State *L, luaL_Buffer *B) {
   B->L = L;
-  B->b = B->initb;
+  B->b = B->init.b;
   B->n = 0;
   B->size = LUAL_BUFFERSIZE;
 }
@@ -845,87 +845,6 @@ LUALIB_API const char *luaL_tolstring (lua_State *L, int idx, size_t *len) {
 }
 
 
-/*
-** {======================================================
-** Compatibility with 5.1 module functions
-** =======================================================
-*/
-#if defined(LUA_COMPAT_MODULE)
-
-static const char *luaL_findtable (lua_State *L, int idx,
-                                   const char *fname, int szhint) {
-  const char *e;
-  if (idx) lua_pushvalue(L, idx);
-  do {
-    e = strchr(fname, '.');
-    if (e == NULL) e = fname + strlen(fname);
-    lua_pushlstring(L, fname, e - fname);
-    if (lua_rawget(L, -2) == LUA_TNIL) {  /* no such field? */
-      lua_pop(L, 1);  /* remove this nil */
-      lua_createtable(L, 0, (*e == '.' ? 1 : szhint)); /* new table for field */
-      lua_pushlstring(L, fname, e - fname);
-      lua_pushvalue(L, -2);
-      lua_settable(L, -4);  /* set new table into field */
-    }
-    else if (!lua_istable(L, -1)) {  /* field has a non-table value? */
-      lua_pop(L, 2);  /* remove table and value */
-      return fname;  /* return problematic part of the name */
-    }
-    lua_remove(L, -2);  /* remove previous table */
-    fname = e + 1;
-  } while (*e == '.');
-  return NULL;
-}
-
-
-/*
-** Count number of elements in a luaL_Reg list.
-*/
-static int libsize (const luaL_Reg *l) {
-  int size = 0;
-  for (; l && l->name; l++) size++;
-  return size;
-}
-
-
-/*
-** Find or create a module table with a given name. The function
-** first looks at the LOADED table and, if that fails, try a
-** global variable with that name. In any case, leaves on the stack
-** the module table.
-*/
-LUALIB_API void luaL_pushmodule (lua_State *L, const char *modname,
-                                 int sizehint) {
-  luaL_findtable(L, LUA_REGISTRYINDEX, LUA_LOADED_TABLE, 1);
-  if (lua_getfield(L, -1, modname) != LUA_TTABLE) {  /* no LOADED[modname]? */
-    lua_pop(L, 1);  /* remove previous result */
-    /* try global variable (and create one if it does not exist) */
-    lua_pushglobaltable(L);
-    if (luaL_findtable(L, 0, modname, sizehint) != NULL)
-      luaL_error(L, "name conflict for module '%s'", modname);
-    lua_pushvalue(L, -1);
-    lua_setfield(L, -3, modname);  /* LOADED[modname] = new table */
-  }
-  lua_remove(L, -2);  /* remove LOADED table */
-}
-
-
-LUALIB_API void luaL_openlib (lua_State *L, const char *libname,
-                               const luaL_Reg *l, int nup) {
-  luaL_checkversion(L);
-  if (libname) {
-    luaL_pushmodule(L, libname, libsize(l));  /* get/create library table */
-    lua_insert(L, -(nup + 1));  /* move library table to below upvalues */
-  }
-  if (l)
-    luaL_setfuncs(L, l, nup);
-  else
-    lua_pop(L, nup);  /* remove upvalues */
-}
-
-#endif
-/* }====================================================== */
-
 /*
 ** set functions from list 'l' into table at top - 'nup'; each
 ** function gets the 'nup' elements at the top as upvalues.
@@ -1011,13 +930,8 @@ static void *l_alloc (void *ud, void *ptr, size_t osize, size_t nsize) {
     free(ptr);
     return NULL;
   }
-  else {  /* cannot fail when shrinking a block */
-    void *newptr = realloc(ptr, nsize);
-    if (newptr == NULL && ptr != NULL && nsize <= osize)
-      return ptr;  /* keep the original block */
-    else  /* no fail or not shrinking */
-     return newptr;  /* use the new block */
-  }
+  else
+    return realloc(ptr, nsize);
 }
 
 
@@ -1036,13 +950,11 @@ LUALIB_API lua_State *luaL_newstate (void) {
 
 
 LUALIB_API void luaL_checkversion_ (lua_State *L, lua_Number ver, size_t sz) {
-  const lua_Number *v = lua_version(L);
+  lua_Number v = lua_version(L);
   if (sz != LUAL_NUMSIZES)  /* check numeric types */
     luaL_error(L, "core and library have incompatible numeric types");
-  if (v != lua_version(NULL))
-    luaL_error(L, "multiple Lua VMs detected");
-  else if (*v != ver)
+  else if (v != ver)
     luaL_error(L, "version mismatch: app. needs %f, Lua core provides %f",
-                  (LUAI_UACNUMBER)ver, (LUAI_UACNUMBER)*v);
+                  (LUAI_UACNUMBER)ver, (LUAI_UACNUMBER)v);
 }
 

lauxlib.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lauxlib.h,v 1.131.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lauxlib.h,v 1.133 2017/06/27 18:32:49 roberto Exp roberto $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
@@ -15,6 +15,10 @@
 #include "lua.h"
 
 
+/* global table */
+#define	LUA_GNAME	"_G"
+
+
 
 /* extra error code for 'luaL_loadfilex' */
 #define LUA_ERRFILE     (LUA_ERRERR+1)
@@ -150,7 +154,10 @@ typedef struct luaL_Buffer {
   size_t size;  /* buffer size */
   size_t n;  /* number of characters in buffer */
   lua_State *L;
-  char initb[LUAL_BUFFERSIZE];  /* initial buffer */
+  union {
+    LUAI_MAXALIGN;  /* ensure maximum alignment for buffer */
+    char b[LUAL_BUFFERSIZE];  /* initial buffer */
+  } init;
 } luaL_Buffer;
 
 
@@ -197,21 +204,6 @@ typedef struct luaL_Stream {
 
 /* }====================================================== */
 
-
-
-/* compatibility with old module system */
-#if defined(LUA_COMPAT_MODULE)
-
-LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
-                                   int sizehint);
-LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
-                                const luaL_Reg *l, int nup);
-
-#define luaL_register(L,n,l)	(luaL_openlib(L,(n),(l),0))
-
-#endif
-
-
 /*
 ** {==================================================================
 ** "Abstraction Layer" for basic report of messages and errors

lbaselib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lbaselib.c,v 1.314.1.1 2017/04/19 17:39:34 roberto Exp $
+** $Id: lbaselib.c,v 1.322 2018/02/27 18:47:32 roberto Exp roberto $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
@@ -49,7 +49,7 @@ static const char *b_str2int (const char *s, int base, lua_Integer *pn) {
   lua_Unsigned n = 0;
   int neg = 0;
   s += strspn(s, SPACECHARS);  /* skip initial spaces */
-  if (*s == '-') { s++; neg = 1; }  /* handle signal */
+  if (*s == '-') { s++; neg = 1; }  /* handle sign */
   else if (*s == '+') s++;
   if (!isalnum((unsigned char)*s))  /* no digit? */
     return NULL;
@@ -170,27 +170,58 @@ static int luaB_rawset (lua_State *L) {
 }
 
 
+static int pushmode (lua_State *L, int oldmode) {
+  lua_pushstring(L, (oldmode == LUA_GCINC) ? "incremental" : "generational");
+  return 1;
+}
+
+
 static int luaB_collectgarbage (lua_State *L) {
   static const char *const opts[] = {"stop", "restart", "collect",
     "count", "step", "setpause", "setstepmul",
-    "isrunning", NULL};
+    "isrunning", "generational", "incremental", NULL};
   static const int optsnum[] = {LUA_GCSTOP, LUA_GCRESTART, LUA_GCCOLLECT,
     LUA_GCCOUNT, LUA_GCSTEP, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL,
-    LUA_GCISRUNNING};
+    LUA_GCISRUNNING, LUA_GCGEN, LUA_GCINC};
   int o = optsnum[luaL_checkoption(L, 1, "collect", opts)];
-  int ex = (int)luaL_optinteger(L, 2, 0);
-  int res = lua_gc(L, o, ex);
   switch (o) {
     case LUA_GCCOUNT: {
-      int b = lua_gc(L, LUA_GCCOUNTB, 0);
-      lua_pushnumber(L, (lua_Number)res + ((lua_Number)b/1024));
+      int k = lua_gc(L, o);
+      int b = lua_gc(L, LUA_GCCOUNTB);
+      lua_pushnumber(L, (lua_Number)k + ((lua_Number)b/1024));
       return 1;
     }
-    case LUA_GCSTEP: case LUA_GCISRUNNING: {
+    case LUA_GCSTEP: {
+      int step = (int)luaL_optinteger(L, 2, 0);
+      int res = lua_gc(L, o, step);
       lua_pushboolean(L, res);
       return 1;
     }
+    case LUA_GCSETPAUSE:
+    case LUA_GCSETSTEPMUL: {
+      int p = (int)luaL_optinteger(L, 2, 0);
+      int previous = lua_gc(L, o, p);
+      lua_pushinteger(L, previous);
+      return 1;
+    }
+    case LUA_GCISRUNNING: {
+      int res = lua_gc(L, o);
+      lua_pushboolean(L, res);
+      return 1;
+    }
+    case LUA_GCGEN: {
+      int minormul = (int)luaL_optinteger(L, 2, 0);
+      int majormul = (int)luaL_optinteger(L, 3, 0);
+      return pushmode(L, lua_gc(L, o, minormul, majormul));
+    }
+    case LUA_GCINC: {
+      int pause = (int)luaL_optinteger(L, 2, 0);
+      int stepmul = (int)luaL_optinteger(L, 3, 0);
+      int stepsize = (int)luaL_optinteger(L, 4, 0);
+      return pushmode(L, lua_gc(L, o, pause, stepmul, stepsize));
+    }
     default: {
+      int res = lua_gc(L, o);
       lua_pushinteger(L, res);
       return 1;
     }
@@ -206,23 +237,6 @@ static int luaB_type (lua_State *L) {
 }
 
 
-static int pairsmeta (lua_State *L, const char *method, int iszero,
-                      lua_CFunction iter) {
-  luaL_checkany(L, 1);
-  if (luaL_getmetafield(L, 1, method) == LUA_TNIL) {  /* no metamethod? */
-    lua_pushcfunction(L, iter);  /* will return generator, */
-    lua_pushvalue(L, 1);  /* state, */
-    if (iszero) lua_pushinteger(L, 0);  /* and initial value */
-    else lua_pushnil(L);
-  }
-  else {
-    lua_pushvalue(L, 1);  /* argument 'self' to metamethod */
-    lua_call(L, 1, 3);  /* get 3 values from metamethod */
-  }
-  return 3;
-}
-
-
 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 */
@@ -236,7 +250,17 @@ static int luaB_next (lua_State *L) {
 
 
 static int luaB_pairs (lua_State *L) {
-  return pairsmeta(L, "__pairs", 0, luaB_next);
+  luaL_checkany(L, 1);
+  if (luaL_getmetafield(L, 1, "__pairs") == LUA_TNIL) {  /* no metamethod? */
+    lua_pushcfunction(L, luaB_next);  /* will return generator, */
+    lua_pushvalue(L, 1);  /* state, */
+    lua_pushnil(L);  /* and initial value */
+  }
+  else {
+    lua_pushvalue(L, 1);  /* argument 'self' to metamethod */
+    lua_call(L, 1, 3);  /* get 3 values from metamethod */
+  }
+  return 3;
 }
 
 
@@ -255,15 +279,11 @@ static int ipairsaux (lua_State *L) {
 ** (The given "table" may not be a table.)
 */
 static int luaB_ipairs (lua_State *L) {
-#if defined(LUA_COMPAT_IPAIRS)
-  return pairsmeta(L, "__ipairs", 1, ipairsaux);
-#else
   luaL_checkany(L, 1);
   lua_pushcfunction(L, ipairsaux);  /* iteration function */
   lua_pushvalue(L, 1);  /* state */
   lua_pushinteger(L, 0);  /* initial value */
   return 3;
-#endif
 }
 
 
@@ -459,9 +479,6 @@ static const luaL_Reg base_funcs[] = {
   {"ipairs", luaB_ipairs},
   {"loadfile", luaB_loadfile},
   {"load", luaB_load},
-#if defined(LUA_COMPAT_LOADSTRING)
-  {"loadstring", luaB_load},
-#endif
   {"next", luaB_next},
   {"pairs", luaB_pairs},
   {"pcall", luaB_pcall},
@@ -477,7 +494,7 @@ static const luaL_Reg base_funcs[] = {
   {"type", luaB_type},
   {"xpcall", luaB_xpcall},
   /* placeholders */
-  {"_G", NULL},
+  {LUA_GNAME, NULL},
   {"_VERSION", NULL},
   {NULL, NULL}
 };
@@ -489,7 +506,7 @@ LUAMOD_API int luaopen_base (lua_State *L) {
   luaL_setfuncs(L, base_funcs, 0);
   /* set global _G */
   lua_pushvalue(L, -1);
-  lua_setfield(L, -2, "_G");
+  lua_setfield(L, -2, LUA_GNAME);
   /* set global _VERSION */
   lua_pushliteral(L, LUA_VERSION);
   lua_setfield(L, -2, "_VERSION");

lbitlib.c

@@ -1,233 +1,7 @@
 /*
-** $Id: lbitlib.c,v 1.30.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lbitlib.c,v 1.31 2017/11/16 13:19:06 roberto Exp roberto $
 ** Standard library for bitwise operations
 ** See Copyright Notice in lua.h
 */
 
-#define lbitlib_c
-#define LUA_LIB
-
-#include "lprefix.h"
-
-
-#include "lua.h"
-
-#include "lauxlib.h"
-#include "lualib.h"
-
-
-#if defined(LUA_COMPAT_BITLIB)		/* { */
-
-
-#define pushunsigned(L,n)	lua_pushinteger(L, (lua_Integer)(n))
-#define checkunsigned(L,i)	((lua_Unsigned)luaL_checkinteger(L,i))
-
-
-/* number of bits to consider in a number */
-#if !defined(LUA_NBITS)
-#define LUA_NBITS	32
-#endif
-
-
-/*
-** a lua_Unsigned with its first LUA_NBITS bits equal to 1. (Shift must
-** be made in two parts to avoid problems when LUA_NBITS is equal to the
-** number of bits in a lua_Unsigned.)
-*/
-#define ALLONES		(~(((~(lua_Unsigned)0) << (LUA_NBITS - 1)) << 1))
-
-
-/* macro to trim extra bits */
-#define trim(x)		((x) & ALLONES)
-
-
-/* builds a number with 'n' ones (1 <= n <= LUA_NBITS) */
-#define mask(n)		(~((ALLONES << 1) << ((n) - 1)))
-
-
-
-static lua_Unsigned andaux (lua_State *L) {
-  int i, n = lua_gettop(L);
-  lua_Unsigned r = ~(lua_Unsigned)0;
-  for (i = 1; i <= n; i++)
-    r &= checkunsigned(L, i);
-  return trim(r);
-}
-
-
-static int b_and (lua_State *L) {
-  lua_Unsigned r = andaux(L);
-  pushunsigned(L, r);
-  return 1;
-}
-
-
-static int b_test (lua_State *L) {
-  lua_Unsigned r = andaux(L);
-  lua_pushboolean(L, r != 0);
-  return 1;
-}
-
-
-static int b_or (lua_State *L) {
-  int i, n = lua_gettop(L);
-  lua_Unsigned r = 0;
-  for (i = 1; i <= n; i++)
-    r |= checkunsigned(L, i);
-  pushunsigned(L, trim(r));
-  return 1;
-}
-
-
-static int b_xor (lua_State *L) {
-  int i, n = lua_gettop(L);
-  lua_Unsigned r = 0;
-  for (i = 1; i <= n; i++)
-    r ^= checkunsigned(L, i);
-  pushunsigned(L, trim(r));
-  return 1;
-}
-
-
-static int b_not (lua_State *L) {
-  lua_Unsigned r = ~checkunsigned(L, 1);
-  pushunsigned(L, trim(r));
-  return 1;
-}
-
-
-static int b_shift (lua_State *L, lua_Unsigned r, lua_Integer i) {
-  if (i < 0) {  /* shift right? */
-    i = -i;
-    r = trim(r);
-    if (i >= LUA_NBITS) r = 0;
-    else r >>= i;
-  }
-  else {  /* shift left */
-    if (i >= LUA_NBITS) r = 0;
-    else r <<= i;
-    r = trim(r);
-  }
-  pushunsigned(L, r);
-  return 1;
-}
-
-
-static int b_lshift (lua_State *L) {
-  return b_shift(L, checkunsigned(L, 1), luaL_checkinteger(L, 2));
-}
-
-
-static int b_rshift (lua_State *L) {
-  return b_shift(L, checkunsigned(L, 1), -luaL_checkinteger(L, 2));
-}
-
-
-static int b_arshift (lua_State *L) {
-  lua_Unsigned r = checkunsigned(L, 1);
-  lua_Integer i = luaL_checkinteger(L, 2);
-  if (i < 0 || !(r & ((lua_Unsigned)1 << (LUA_NBITS - 1))))
-    return b_shift(L, r, -i);
-  else {  /* arithmetic shift for 'negative' number */
-    if (i >= LUA_NBITS) r = ALLONES;
-    else
-      r = trim((r >> i) | ~(trim(~(lua_Unsigned)0) >> i));  /* add signal bit */
-    pushunsigned(L, r);
-    return 1;
-  }
-}
-
-
-static int b_rot (lua_State *L, lua_Integer d) {
-  lua_Unsigned r = checkunsigned(L, 1);
-  int i = d & (LUA_NBITS - 1);  /* i = d % NBITS */
-  r = trim(r);
-  if (i != 0)  /* avoid undefined shift of LUA_NBITS when i == 0 */
-    r = (r << i) | (r >> (LUA_NBITS - i));
-  pushunsigned(L, trim(r));
-  return 1;
-}
-
-
-static int b_lrot (lua_State *L) {
-  return b_rot(L, luaL_checkinteger(L, 2));
-}
-
-
-static int b_rrot (lua_State *L) {
-  return b_rot(L, -luaL_checkinteger(L, 2));
-}
-
-
-/*
-** get field and width arguments for field-manipulation functions,
-** checking whether they are valid.
-** ('luaL_error' called without 'return' to avoid later warnings about
-** 'width' being used uninitialized.)
-*/
-static int fieldargs (lua_State *L, int farg, int *width) {
-  lua_Integer f = luaL_checkinteger(L, farg);
-  lua_Integer w = luaL_optinteger(L, farg + 1, 1);
-  luaL_argcheck(L, 0 <= f, farg, "field cannot be negative");
-  luaL_argcheck(L, 0 < w, farg + 1, "width must be positive");
-  if (f + w > LUA_NBITS)
-    luaL_error(L, "trying to access non-existent bits");
-  *width = (int)w;
-  return (int)f;
-}
-
-
-static int b_extract (lua_State *L) {
-  int w;
-  lua_Unsigned r = trim(checkunsigned(L, 1));
-  int f = fieldargs(L, 2, &w);
-  r = (r >> f) & mask(w);
-  pushunsigned(L, r);
-  return 1;
-}
-
-
-static int b_replace (lua_State *L) {
-  int w;
-  lua_Unsigned r = trim(checkunsigned(L, 1));
-  lua_Unsigned v = trim(checkunsigned(L, 2));
-  int f = fieldargs(L, 3, &w);
-  lua_Unsigned m = mask(w);
-  r = (r & ~(m << f)) | ((v & m) << f);
-  pushunsigned(L, r);
-  return 1;
-}
-
-
-static const luaL_Reg bitlib[] = {
-  {"arshift", b_arshift},
-  {"band", b_and},
-  {"bnot", b_not},
-  {"bor", b_or},
-  {"bxor", b_xor},
-  {"btest", b_test},
-  {"extract", b_extract},
-  {"lrotate", b_lrot},
-  {"lshift", b_lshift},
-  {"replace", b_replace},
-  {"rrotate", b_rrot},
-  {"rshift", b_rshift},
-  {NULL, NULL}
-};
-
-
-
-LUAMOD_API int luaopen_bit32 (lua_State *L) {
-  luaL_newlib(L, bitlib);
-  return 1;
-}
-
-
-#else					/* }{ */
-
-
-LUAMOD_API int luaopen_bit32 (lua_State *L) {
-  return luaL_error(L, "library 'bit32' has been deprecated");
-}
-
-#endif					/* } */
+Deprecated module.

lcode.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.h,v 1.64.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lcode.h,v 1.72 2018/03/19 20:03:44 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -37,27 +37,31 @@ typedef enum BinOpr {
 } BinOpr;
 
 
+#define luaK_codeABC(fs,o,a,b,c)	luaK_codeABCk(fs,o,a,b,c,0)
+
+
 typedef enum UnOpr { OPR_MINUS, OPR_BNOT, OPR_NOT, OPR_LEN, OPR_NOUNOPR } UnOpr;
 
 
 /* get (pointer to) instruction of given 'expdesc' */
 #define getinstruction(fs,e)	((fs)->f->code[(e)->u.info])
 
-#define luaK_codeAsBx(fs,o,A,sBx)	luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx)
 
 #define luaK_setmultret(fs,e)	luaK_setreturns(fs, e, LUA_MULTRET)
 
 #define luaK_jumpto(fs,t)	luaK_patchlist(fs, luaK_jump(fs), t)
 
 LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx);
-LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C);
-LUAI_FUNC int luaK_codek (FuncState *fs, int reg, int k);
+LUAI_FUNC int luaK_codeAsBx (FuncState *fs, OpCode o, int A, int Bx);
+LUAI_FUNC int luaK_codeABCk (FuncState *fs, OpCode o, int A,
+                                            int B, int C, int k);
+LUAI_FUNC int luaK_isKint (expdesc *e);
 LUAI_FUNC void luaK_fixline (FuncState *fs, int line);
 LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n);
 LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n);
 LUAI_FUNC void luaK_checkstack (FuncState *fs, int n);
 LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s);
-LUAI_FUNC int luaK_intK (FuncState *fs, lua_Integer n);
+LUAI_FUNC void luaK_int (FuncState *fs, int reg, lua_Integer n);
 LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e);
 LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e);
 LUAI_FUNC void luaK_exp2anyregup (FuncState *fs, expdesc *e);
@@ -74,8 +78,10 @@ LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
 LUAI_FUNC int luaK_jump (FuncState *fs);
 LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
 LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
+LUAI_FUNC void luaK_patchgoto (FuncState *fs, int list, int target,
+                               int hasclose);
 LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
-LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level);
+LUAI_FUNC void luaK_patchclose (FuncState *fs, int list);
 LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
 LUAI_FUNC int luaK_getlabel (FuncState *fs);
 LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line);
@@ -83,6 +89,8 @@ LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v);
 LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1,
                             expdesc *v2, int line);
 LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore);
+LUAI_FUNC void luaK_finish (FuncState *fs);
+LUAI_FUNC l_noret luaK_semerror (LexState *ls, const char *msg);
 
 
 #endif

lcorolib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lcorolib.c,v 1.10.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lcorolib.c,v 1.10 2016/04/11 19:19:55 roberto Exp roberto $
 ** Coroutine Library
 ** See Copyright Notice in lua.h
 */
@@ -26,7 +26,7 @@ static lua_State *getco (lua_State *L) {
 
 
 static int auxresume (lua_State *L, lua_State *co, int narg) {
-  int status;
+  int status, nres;
   if (!lua_checkstack(co, narg)) {
     lua_pushliteral(L, "too many arguments to resume");
     return -1;  /* error flag */
@@ -36,9 +36,8 @@ static int auxresume (lua_State *L, lua_State *co, int narg) {
     return -1;  /* error flag */
   }
   lua_xmove(L, co, narg);
-  status = lua_resume(co, L, narg);
+  status = lua_resume(co, L, narg, &nres);
   if (status == LUA_OK || status == LUA_YIELD) {
-    int nres = lua_gettop(co);
     if (!lua_checkstack(L, nres + 1)) {
       lua_pop(co, nres);  /* remove results anyway */
       lua_pushliteral(L, "too many results to resume");

lctype.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lctype.c,v 1.12.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lctype.c,v 1.11 2011/10/03 16:19:23 roberto Exp roberto $
 ** 'ctype' functions for Lua
 ** See Copyright Notice in lua.h
 */

lctype.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $
+** $Id: lctype.h,v 1.12 2011/07/15 12:50:29 roberto Exp roberto $
 ** 'ctype' functions for Lua
 ** See Copyright Notice in lua.h
 */
@@ -68,7 +68,7 @@
 
 
 /* two more entries for 0 and -1 (EOZ) */
-LUAI_DDEC const lu_byte luai_ctype_[UCHAR_MAX + 2];
+LUAI_DDEC(const lu_byte luai_ctype_[UCHAR_MAX + 2];)
 
 
 #else			/* }{ */

ldblib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ldblib.c,v 1.151.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: ldblib.c,v 1.154 2018/03/05 14:15:04 roberto Exp roberto $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
@@ -64,19 +64,24 @@ static int db_setmetatable (lua_State *L) {
 
 
 static int db_getuservalue (lua_State *L) {
+  int n = (int)luaL_optinteger(L, 2, 1);
   if (lua_type(L, 1) != LUA_TUSERDATA)
     lua_pushnil(L);
-  else
-    lua_getuservalue(L, 1);
+  else if (lua_getiuservalue(L, 1, n) != LUA_TNONE) {
+    lua_pushboolean(L, 1);
+    return 2;
+  }
   return 1;
 }
 
 
 static int db_setuservalue (lua_State *L) {
+  int n = (int)luaL_optinteger(L, 3, 1);
   luaL_checktype(L, 1, LUA_TUSERDATA);
   luaL_checkany(L, 2);
   lua_settop(L, 2);
-  lua_setuservalue(L, 1);
+  if (!lua_setiuservalue(L, 1, n))
+    lua_pushnil(L);
   return 1;
 }
 
@@ -146,7 +151,7 @@ static int db_getinfo (lua_State *L) {
   lua_Debug ar;
   int arg;
   lua_State *L1 = getthread(L, &arg);
-  const char *options = luaL_optstring(L, arg+2, "flnStu");
+  const char *options = luaL_optstring(L, arg+2, "flnSrtu");
   checkstack(L, L1, 3);
   if (lua_isfunction(L, arg + 1)) {  /* info about a function? */
     options = lua_pushfstring(L, ">%s", options);  /* add '>' to 'options' */
@@ -180,6 +185,10 @@ static int db_getinfo (lua_State *L) {
     settabss(L, "name", ar.name);
     settabss(L, "namewhat", ar.namewhat);
   }
+  if (strchr(options, 'r')) {
+    settabsi(L, "ftransfer", ar.ftransfer);
+    settabsi(L, "ntransfer", ar.ntransfer);
+  }
   if (strchr(options, 't'))
     settabsb(L, "istailcall", ar.istailcall);
   if (strchr(options, 'L'))

ldebug.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.c,v 2.121.1.2 2017/07/10 17:21:50 roberto Exp $
+** $Id: ldebug.c,v 2.157 2018/05/02 18:17:59 roberto Exp roberto $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
@@ -35,7 +35,7 @@
 
 
 /* Active Lua function (given call info) */
-#define ci_func(ci)		(clLvalue((ci)->func))
+#define ci_func(ci)		(clLvalue(s2v((ci)->func)))
 
 
 static const char *funcnamefromcode (lua_State *L, CallInfo *ci,
@@ -48,29 +48,83 @@ static int currentpc (CallInfo *ci) {
 }
 
 
-static int currentline (CallInfo *ci) {
-  return getfuncline(ci_func(ci)->p, currentpc(ci));
-}
-
-
 /*
-** If function yielded, its 'func' can be in the 'extra' field. The
-** next function restores 'func' to its correct value for debugging
-** purposes. (It exchanges 'func' and 'extra'; so, when called again,
-** after debugging, it also "re-restores" ** 'func' to its altered value.
+** Get a "base line" to find the line corresponding to an instruction.
+** For that, search the array of absolute line info for the largest saved
+** instruction smaller or equal to the wanted instruction. A special
+** case is when there is no absolute info or the instruction is before
+** the first absolute one.
 */
-static void swapextra (lua_State *L) {
-  if (L->status == LUA_YIELD) {
-    CallInfo *ci = L->ci;  /* get function that yielded */
-    StkId temp = ci->func;  /* exchange its 'func' and 'extra' values */
-    ci->func = restorestack(L, ci->extra);
-    ci->extra = savestack(L, temp);
+static int getbaseline (const Proto *f, int pc, int *basepc) {
+  if (f->sizeabslineinfo == 0 || pc < f->abslineinfo[0].pc) {
+    *basepc = -1;  /* start from the beginning */
+    return f->linedefined;
+  }
+  else {
+    unsigned int i;
+    if (pc >= f->abslineinfo[f->sizeabslineinfo - 1].pc)
+      i = f->sizeabslineinfo - 1;  /* instruction is after last saved one */
+    else {  /* binary search */
+      unsigned int j = f->sizeabslineinfo - 1;  /* pc < anchorlines[j] */
+      i = 0;  /* abslineinfo[i] <= pc */
+      while (i < j - 1) {
+        unsigned int m = (j + i) / 2;
+        if (pc >= f->abslineinfo[m].pc)
+          i = m;
+        else
+          j = m;
+      }
+    }
+    *basepc = f->abslineinfo[i].pc;
+    return f->abslineinfo[i].line;
   }
 }
 
 
 /*
-** This function can be called asynchronously (e.g. during a signal).
+** Get the line corresponding to instruction 'pc' in function 'f';
+** first gets a base line and from there does the increments until
+** the desired instruction.
+*/
+int luaG_getfuncline (const Proto *f, int pc) {
+  if (f->lineinfo == NULL)  /* no debug information? */
+    return -1;
+  else {
+    int basepc;
+    int baseline = getbaseline(f, pc, &basepc);
+    while (basepc++ < pc) {  /* walk until given instruction */
+      lua_assert(f->lineinfo[basepc] != ABSLINEINFO);
+      baseline += f->lineinfo[basepc];  /* correct line */
+    }
+    return baseline;
+  }
+}
+
+
+static int currentline (CallInfo *ci) {
+  return luaG_getfuncline(ci_func(ci)->p, currentpc(ci));
+}
+
+
+/*
+** This function can be called asynchronously (e.g. during a signal),
+** under "reasonable" assumptions. A new 'ci' is completely linked
+** in the list before it becomes part of the "active" list, and
+** we assume that pointers are atomic (see comment in next function).
+** (If we traverse one more item, there is no problem. If we traverse
+** one less item, the worst that can happen is that the signal will
+** not interrupt the script.)
+*/
+static void settraps (CallInfo *ci) {
+  for (; ci != NULL; ci = ci->previous)
+    if (isLua(ci))
+      ci->u.l.trap = 1;
+}
+
+
+/*
+** This function can be called asynchronously (e.g. during a signal),
+** under "reasonable" assumptions.
 ** Fields 'oldpc', 'basehookcount', and 'hookcount' (set by
 ** 'resethookcount') are for debug only, and it is no problem if they
 ** get arbitrary values (causes at most one wrong hook call). 'hookmask'
@@ -89,6 +143,8 @@ LUA_API void lua_sethook (lua_State *L, lua_Hook func, int mask, int count) {
   L->basehookcount = count;
   resethookcount(L);
   L->hookmask = cast_byte(mask);
+  if (mask)
+    settraps(L->ci);  /* to trace inside 'luaV_execute' */
 }
 
 
@@ -124,7 +180,7 @@ LUA_API int lua_getstack (lua_State *L, int level, lua_Debug *ar) {
 }
 
 
-static const char *upvalname (Proto *p, int uv) {
+static const char *upvalname (const Proto *p, int uv) {
   TString *s = check_exp(uv < p->sizeupvalues, p->upvalues[uv].name);
   if (s == NULL) return "?";
   else return getstr(s);
@@ -132,31 +188,27 @@ static const char *upvalname (Proto *p, int uv) {
 
 
 static const char *findvararg (CallInfo *ci, int n, StkId *pos) {
-  int nparams = clLvalue(ci->func)->p->numparams;
-  int nvararg = cast_int(ci->u.l.base - ci->func) - nparams;
-  if (n <= -nvararg)
-    return NULL;  /* no such vararg */
-  else {
-    *pos = ci->func + nparams - n;
-    return "(*vararg)";  /* generic name for any vararg */
+  if (clLvalue(s2v(ci->func))->p->is_vararg) {
+    int nextra = ci->u.l.nextraargs;
+    if (n <= nextra) {
+      *pos = ci->func - nextra + (n - 1);
+      return "(*vararg)";  /* generic name for any vararg */
+    }
   }
+  return NULL;  /* no such vararg */
 }
 
 
 static const char *findlocal (lua_State *L, CallInfo *ci, int n,
                               StkId *pos) {
+  StkId base = ci->func + 1;
   const char *name = NULL;
-  StkId base;
   if (isLua(ci)) {
     if (n < 0)  /* access to vararg values? */
-      return findvararg(ci, n, pos);
-    else {
-      base = ci->u.l.base;
+      return findvararg(ci, -n, pos);
+    else
       name = luaF_getlocalname(ci_func(ci)->p, n, currentpc(ci));
-    }
   }
-  else
-    base = ci->func + 1;
   if (name == NULL) {  /* no 'standard' name? */
     StkId limit = (ci == L->ci) ? L->top : ci->next->func;
     if (limit - base >= n && n > 0)  /* is 'n' inside 'ci' stack? */
@@ -172,22 +224,20 @@ static const char *findlocal (lua_State *L, CallInfo *ci, int n,
 LUA_API const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n) {
   const char *name;
   lua_lock(L);
-  swapextra(L);
   if (ar == NULL) {  /* information about non-active function? */
-    if (!isLfunction(L->top - 1))  /* not a Lua function? */
+    if (!isLfunction(s2v(L->top - 1)))  /* not a Lua function? */
       name = NULL;
     else  /* consider live variables at function start (parameters) */
-      name = luaF_getlocalname(clLvalue(L->top - 1)->p, n, 0);
+      name = luaF_getlocalname(clLvalue(s2v(L->top - 1))->p, n, 0);
   }
   else {  /* active function; get information through 'ar' */
     StkId pos = NULL;  /* to avoid warnings */
     name = findlocal(L, ar->i_ci, n, &pos);
     if (name) {
-      setobj2s(L, L->top, pos);
+      setobjs2s(L, L->top, pos);
       api_incr_top(L);
     }
   }
-  swapextra(L);
   lua_unlock(L);
   return name;
 }
@@ -197,13 +247,11 @@ LUA_API const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n) {
   StkId pos = NULL;  /* to avoid warnings */
   const char *name;
   lua_lock(L);
-  swapextra(L);
   name = findlocal(L, ar->i_ci, n, &pos);
   if (name) {
     setobjs2s(L, pos, L->top - 1);
     L->top--;  /* pop value */
   }
-  swapextra(L);
   lua_unlock(L);
   return name;
 }
@@ -217,7 +265,7 @@ static void funcinfo (lua_Debug *ar, Closure *cl) {
     ar->what = "C";
   }
   else {
-    Proto *p = cl->l.p;
+    const Proto *p = cl->l.p;
     ar->source = p->source ? getstr(p->source) : "=?";
     ar->linedefined = p->linedefined;
     ar->lastlinedefined = p->lastlinedefined;
@@ -227,21 +275,32 @@ static void funcinfo (lua_Debug *ar, Closure *cl) {
 }
 
 
+static int nextline (const Proto *p, int currentline, int pc) {
+  if (p->lineinfo[pc] != ABSLINEINFO)
+    return currentline + p->lineinfo[pc];
+  else
+    return luaG_getfuncline(p, pc);
+}
+
+
 static void collectvalidlines (lua_State *L, Closure *f) {
   if (noLuaClosure(f)) {
-    setnilvalue(L->top);
+    setnilvalue(s2v(L->top));
     api_incr_top(L);
   }
   else {
     int i;
     TValue v;
-    int *lineinfo = f->l.p->lineinfo;
+    const Proto *p = f->l.p;
+    int currentline = p->linedefined;
     Table *t = luaH_new(L);  /* new table to store active lines */
-    sethvalue(L, L->top, t);  /* push it on stack */
+    sethvalue2s(L, L->top, t);  /* push it on stack */
     api_incr_top(L);
     setbvalue(&v, 1);  /* boolean 'true' to be the value of all indices */
-    for (i = 0; i < f->l.p->sizelineinfo; i++)  /* for all lines with code */
-      luaH_setint(L, t, lineinfo[i], &v);  /* table[line] = true */
+    for (i = 0; i < p->sizelineinfo; i++) {  /* for all lines with code */
+      currentline = nextline(p, currentline, i);
+      luaH_setint(L, t, currentline, &v);  /* table[line] = true */
+    }
   }
 }
 
@@ -297,6 +356,14 @@ static int auxgetinfo (lua_State *L, const char *what, lua_Debug *ar,
         }
         break;
       }
+      case 'r': {
+        if (ci == NULL || !(ci->callstatus & CIST_TRAN))
+          ar->ftransfer = ar->ntransfer = 0;
+        else {
+          ar->ftransfer = ci->u2.transferinfo.ftransfer;
+          ar->ntransfer = ci->u2.transferinfo.ntransfer;
+        }
+      }
       case 'L':
       case 'f':  /* handled by lua_getinfo */
         break;
@@ -311,28 +378,26 @@ LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
   int status;
   Closure *cl;
   CallInfo *ci;
-  StkId func;
+  TValue *func;
   lua_lock(L);
-  swapextra(L);
   if (*what == '>') {
     ci = NULL;
-    func = L->top - 1;
+    func = s2v(L->top - 1);
     api_check(L, ttisfunction(func), "function expected");
     what++;  /* skip the '>' */
     L->top--;  /* pop function */
   }
   else {
     ci = ar->i_ci;
-    func = ci->func;
-    lua_assert(ttisfunction(ci->func));
+    func = s2v(ci->func);
+    lua_assert(ttisfunction(func));
   }
   cl = ttisclosure(func) ? clvalue(func) : NULL;
   status = auxgetinfo(L, what, ar, cl, ci);
   if (strchr(what, 'f')) {
-    setobjs2s(L, L->top, func);
+    setobj2s(L, L->top, func);
     api_incr_top(L);
   }
-  swapextra(L);  /* correct before option 'L', which can raise a mem. error */
   if (strchr(what, 'L'))
     collectvalidlines(L, cl);
   lua_unlock(L);
@@ -346,30 +411,38 @@ LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar) {
 ** =======================================================
 */
 
-static const char *getobjname (Proto *p, int lastpc, int reg,
+static const char *getobjname (const Proto *p, int lastpc, int reg,
                                const char **name);
 
 
 /*
-** find a "name" for the RK value 'c'
+** Find a "name" for the constant 'c'.
 */
-static void kname (Proto *p, int pc, int c, const char **name) {
-  if (ISK(c)) {  /* is 'c' a constant? */
-    TValue *kvalue = &p->k[INDEXK(c)];
-    if (ttisstring(kvalue)) {  /* literal constant? */
-      *name = svalue(kvalue);  /* it is its own name */
-      return;
-    }
-    /* else no reasonable name found */
-  }
-  else {  /* 'c' is a register */
-    const char *what = getobjname(p, pc, c, name); /* search for 'c' */
-    if (what && *what == 'c') {  /* found a constant name? */
-      return;  /* 'name' already filled */
-    }
-    /* else no reasonable name found */
-  }
-  *name = "?";  /* no reasonable name found */
+static void kname (const Proto *p, int c, const char **name) {
+  TValue *kvalue = &p->k[c];
+  *name = (ttisstring(kvalue)) ? svalue(kvalue) : "?";
+}
+
+
+/*
+** Find a "name" for the register 'c'.
+*/
+static void rname (const Proto *p, int pc, int c, const char **name) {
+  const char *what = getobjname(p, pc, c, name); /* search for 'c' */
+  if (!(what && *what == 'c'))  /* did not find a constant name? */
+    *name = "?";
+}
+
+
+/*
+** Find a "name" for a 'C' value in an RK instruction.
+*/
+static void rkname (const Proto *p, int pc, Instruction i, const char **name) {
+  int c = GETARG_C(i);  /* key index */
+  if (GETARG_k(i))  /* is 'c' a constant? */
+    kname(p, c, name);
+  else  /* 'c' is a register */
+    rname(p, pc, c, name);
 }
 
 
@@ -383,7 +456,7 @@ static int filterpc (int pc, int jmptarget) {
 /*
 ** try to find last instruction before 'lastpc' that modified register 'reg'
 */
-static int findsetreg (Proto *p, int lastpc, int reg) {
+static int findsetreg (const Proto *p, int lastpc, int reg) {
   int pc;
   int setreg = -1;  /* keep last instruction that changed 'reg' */
   int jmptarget = 0;  /* any code before this address is conditional */
@@ -391,46 +464,59 @@ static int findsetreg (Proto *p, int lastpc, int reg) {
     Instruction i = p->code[pc];
     OpCode op = GET_OPCODE(i);
     int a = GETARG_A(i);
+    int change;  /* true if current instruction changed 'reg' */
     switch (op) {
-      case OP_LOADNIL: {
+      case OP_LOADNIL: {  /* set registers from 'a' to 'a+b' */
         int b = GETARG_B(i);
-        if (a <= reg && reg <= a + b)  /* set registers from 'a' to 'a+b' */
-          setreg = filterpc(pc, jmptarget);
+        change = (a <= reg && reg <= a + b);
         break;
       }
-      case OP_TFORCALL: {
-        if (reg >= a + 2)  /* affect all regs above its base */
-          setreg = filterpc(pc, jmptarget);
+      case OP_TFORCALL: {  /* affect all regs above its base */
+        change = (reg >= a + 2);
         break;
       }
       case OP_CALL:
-      case OP_TAILCALL: {
-        if (reg >= a)  /* affect all registers above base */
-          setreg = filterpc(pc, jmptarget);
+      case OP_TAILCALL: {  /* affect all registers above base */
+        change = (reg >= a);
         break;
       }
-      case OP_JMP: {
-        int b = GETARG_sBx(i);
+      case OP_JMP: {  /* doesn't change registers, but changes 'jmptarget' */
+        int b = GETARG_sJ(i);
         int dest = pc + 1 + b;
-        /* jump is forward and do not skip 'lastpc'? */
-        if (pc < dest && dest <= lastpc) {
-          if (dest > jmptarget)
-            jmptarget = dest;  /* update 'jmptarget' */
-        }
+        /* jump does not skip 'lastpc' and is larger than current one? */
+        if (dest <= lastpc && dest > jmptarget)
+          jmptarget = dest;  /* update 'jmptarget' */
+        change = 0;
         break;
       }
-      default:
-        if (testAMode(op) && reg == a)  /* any instruction that set A */
-          setreg = filterpc(pc, jmptarget);
+      default:  /* any instruction that sets A */
+        change = (testAMode(op) && reg == a);
         break;
     }
+    if (change)
+      setreg = filterpc(pc, jmptarget);
   }
   return setreg;
 }
 
 
-static const char *getobjname (Proto *p, int lastpc, int reg,
-                               const char **name) {
+/*
+** Check whether table being indexed by instruction 'i' is the
+** environment '_ENV'
+*/
+static const char *gxf (const Proto *p, int pc, Instruction i, int isup) {
+  int t = GETARG_B(i);  /* table index */
+  const char *name;  /* name of indexed variable */
+  if (isup)  /* is an upvalue? */
+    name = upvalname(p, t);
+  else
+    getobjname(p, pc, t, &name);
+  return (name && strcmp(name, LUA_ENV) == 0) ? "global" : "field";
+}
+
+
+ const char *getobjname (const Proto *p, int lastpc, int reg,
+                         const char **name) {
   int pc;
   *name = luaF_getlocalname(p, reg + 1, lastpc);
   if (*name)  /* is a local? */
@@ -447,15 +533,24 @@ static const char *getobjname (Proto *p, int lastpc, int reg,
           return getobjname(p, pc, b, name);  /* get name for 'b' */
         break;
       }
-      case OP_GETTABUP:
+      case OP_GETTABUP: {
+        int k = GETARG_C(i);  /* key index */
+        kname(p, k, name);
+        return gxf(p, pc, i, 1);
+      }
       case OP_GETTABLE: {
         int k = GETARG_C(i);  /* key index */
-        int t = GETARG_B(i);  /* table index */
-        const char *vn = (op == OP_GETTABLE)  /* name of indexed variable */
-                         ? luaF_getlocalname(p, t + 1, pc)
-                         : upvalname(p, t);
-        kname(p, pc, k, name);
-        return (vn && strcmp(vn, LUA_ENV) == 0) ? "global" : "field";
+        rname(p, pc, k, name);
+        return gxf(p, pc, i, 0);
+      }
+      case OP_GETI: {
+        *name = "integer index";
+        return "field";
+      }
+      case OP_GETFIELD: {
+        int k = GETARG_C(i);  /* key index */
+        kname(p, k, name);
+        return gxf(p, pc, i, 0);
       }
       case OP_GETUPVAL: {
         *name = upvalname(p, GETARG_B(i));
@@ -472,8 +567,7 @@ static const char *getobjname (Proto *p, int lastpc, int reg,
         break;
       }
       case OP_SELF: {
-        int k = GETARG_C(i);  /* key index */
-        kname(p, pc, k, name);
+        rkname(p, pc, i, name);
         return "method";
       }
       default: break;  /* go through to return NULL */
@@ -492,7 +586,7 @@ static const char *getobjname (Proto *p, int lastpc, int reg,
 static const char *funcnamefromcode (lua_State *L, CallInfo *ci,
                                      const char **name) {
   TMS tm = (TMS)0;  /* (initial value avoids warnings) */
-  Proto *p = ci_func(ci)->p;  /* calling function */
+  const Proto *p = ci_func(ci)->p;  /* calling function */
   int pc = currentpc(ci);  /* calling instruction index */
   Instruction i = p->code[pc];  /* calling instruction */
   if (ci->callstatus & CIST_HOOKED) {  /* was it called inside a hook? */
@@ -509,16 +603,24 @@ static const char *funcnamefromcode (lua_State *L, CallInfo *ci,
     }
     /* other instructions can do calls through metamethods */
     case OP_SELF: case OP_GETTABUP: case OP_GETTABLE:
+    case OP_GETI: case OP_GETFIELD:
       tm = TM_INDEX;
       break;
-    case OP_SETTABUP: case OP_SETTABLE:
+    case OP_SETTABUP: case OP_SETTABLE: case OP_SETI: case OP_SETFIELD:
       tm = TM_NEWINDEX;
       break;
+    case OP_ADDI: case OP_SUBI: case OP_MULI: case OP_MODI:
+    case OP_POWI: case OP_DIVI: case OP_IDIVI:
+    case OP_BANDK: case OP_BORK: case OP_BXORK: {
+      int offset = GET_OPCODE(i) - OP_ADDI;  /* ORDER OP */
+      tm = cast(TMS, offset + TM_ADD);  /* ORDER TM */
+      break;
+    }
     case OP_ADD: case OP_SUB: case OP_MUL: case OP_MOD:
     case OP_POW: case OP_DIV: case OP_IDIV: case OP_BAND:
     case OP_BOR: case OP_BXOR: case OP_SHL: case OP_SHR: {
-      int offset = cast_int(GET_OPCODE(i)) - cast_int(OP_ADD);  /* ORDER OP */
-      tm = cast(TMS, offset + cast_int(TM_ADD));  /* ORDER TM */
+      int offset = GET_OPCODE(i) - OP_ADD;  /* ORDER OP */
+      tm = cast(TMS, offset + TM_ADD);  /* ORDER TM */
       break;
     }
     case OP_UNM: tm = TM_UNM; break;
@@ -526,12 +628,16 @@ static const char *funcnamefromcode (lua_State *L, CallInfo *ci,
     case OP_LEN: tm = TM_LEN; break;
     case OP_CONCAT: tm = TM_CONCAT; break;
     case OP_EQ: tm = TM_EQ; break;
-    case OP_LT: tm = TM_LT; break;
-    case OP_LE: tm = TM_LE; break;
+    case OP_LT: case OP_LE: case OP_LTI: case OP_LEI:
+      *name = "order";  /* '<=' can call '__lt', etc. */
+      return "metamethod";
+    case OP_SHRI: case OP_SHLI:
+      *name = "shift";
+      return "metamethod";
     default:
       return NULL;  /* cannot find a reasonable name */
   }
-  *name = getstr(G(L)->tmname[tm]);
+  *name = getstr(G(L)->tmname[tm]) + 2;
   return "metamethod";
 }
 
@@ -545,8 +651,9 @@ static const char *funcnamefromcode (lua_State *L, CallInfo *ci,
 ** checks are ISO C and ensure a correct result.
 */
 static int isinstack (CallInfo *ci, const TValue *o) {
-  ptrdiff_t i = o - ci->u.l.base;
-  return (0 <= i && i < (ci->top - ci->u.l.base) && ci->u.l.base + i == o);
+  StkId base = ci->func + 1;
+  ptrdiff_t i = cast(StkId, o) - base;
+  return (0 <= i && i < (ci->top - base) && s2v(base + i) == o);
 }
 
 
@@ -577,7 +684,7 @@ static const char *varinfo (lua_State *L, const TValue *o) {
     kind = getupvalname(ci, o, &name);  /* check whether 'o' is an upvalue */
     if (!kind && isinstack(ci, o))  /* no? try a register */
       kind = getobjname(ci_func(ci)->p, currentpc(ci),
-                        cast_int(o - ci->u.l.base), &name);
+                        cast_int(cast(StkId, o) - (ci->func + 1)), &name);
   }
   return (kind) ? luaO_pushfstring(L, " (%s '%s')", kind, name) : "";
 }
@@ -597,8 +704,7 @@ l_noret luaG_concaterror (lua_State *L, const TValue *p1, const TValue *p2) {
 
 l_noret luaG_opinterror (lua_State *L, const TValue *p1,
                          const TValue *p2, const char *msg) {
-  lua_Number temp;
-  if (!tonumber(p1, &temp))  /* first operand is wrong? */
+  if (!ttisnumber(p1))  /* first operand is wrong? */
     p2 = p1;  /* now second is wrong */
   luaG_typeerror(L, p2, msg);
 }
@@ -609,7 +715,7 @@ l_noret luaG_opinterror (lua_State *L, const TValue *p1,
 */
 l_noret luaG_tointerror (lua_State *L, const TValue *p1, const TValue *p2) {
   lua_Integer temp;
-  if (!tointeger(p1, &temp))
+  if (!tointegerns(p1, &temp))
     p2 = p1;
   luaG_runerror(L, "number%s has no integer representation", varinfo(L, p2));
 }
@@ -641,6 +747,7 @@ const char *luaG_addinfo (lua_State *L, const char *msg, TString *src,
 l_noret luaG_errormsg (lua_State *L) {
   if (L->errfunc != 0) {  /* is there an error handling function? */
     StkId errfunc = restorestack(L, L->errfunc);
+    lua_assert(ttisfunction(s2v(errfunc)));
     setobjs2s(L, L->top, L->top - 1);  /* move argument */
     setobjs2s(L, L->top - 1, errfunc);  /* push function */
     L->top++;  /* assume EXTRA_STACK */
@@ -664,37 +771,60 @@ l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
 }
 
 
-void luaG_traceexec (lua_State *L) {
+/*
+** Check whether new instruction 'newpc' is in a different line from
+** previous instruction 'oldpc'.
+*/
+static int changedline (const Proto *p, int oldpc, int newpc) {
+  while (oldpc++ < newpc) {
+    if (p->lineinfo[oldpc] != 0)
+      return (luaG_getfuncline(p, oldpc - 1) != luaG_getfuncline(p, newpc));
+  }
+  return 0;  /* no line changes in the way */
+}
+
+
+int luaG_traceexec (lua_State *L, const Instruction *pc) {
   CallInfo *ci = L->ci;
   lu_byte mask = L->hookmask;
-  int counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT));
+  int counthook;
+  if (!(mask & (LUA_MASKLINE | LUA_MASKCOUNT))) {  /* no hooks? */
+    ci->u.l.trap = 0;  /* don't need to stop again */
+    return 0;  /* turn off 'trap' */
+  }
+  pc++;  /* reference is always next instruction */
+  ci->u.l.savedpc = pc;  /* save 'pc' */
+  counthook = (--L->hookcount == 0 && (mask & LUA_MASKCOUNT));
   if (counthook)
     resethookcount(L);  /* reset count */
   else if (!(mask & LUA_MASKLINE))
-    return;  /* no line hook and count != 0; nothing to be done */
+    return 1;  /* no line hook and count != 0; nothing to be done now */
   if (ci->callstatus & CIST_HOOKYIELD) {  /* called hook last time? */
     ci->callstatus &= ~CIST_HOOKYIELD;  /* erase mark */
-    return;  /* do not call hook again (VM yielded, so it did not move) */
+    return 1;  /* do not call hook again (VM yielded, so it did not move) */
   }
+  if (!isIT(*(ci->u.l.savedpc - 1)))
+    L->top = ci->top;  /* prepare top */
   if (counthook)
-    luaD_hook(L, LUA_HOOKCOUNT, -1);  /* call count hook */
+    luaD_hook(L, LUA_HOOKCOUNT, -1, 0, 0);  /* call count hook */
   if (mask & LUA_MASKLINE) {
-    Proto *p = ci_func(ci)->p;
-    int npc = pcRel(ci->u.l.savedpc, p);
-    int newline = getfuncline(p, npc);
-    if (npc == 0 ||  /* call linehook when enter a new function, */
-        ci->u.l.savedpc <= L->oldpc ||  /* when jump back (loop), or when */
-        newline != getfuncline(p, pcRel(L->oldpc, p)))  /* enter a new line */
-      luaD_hook(L, LUA_HOOKLINE, newline);  /* call line hook */
+    const Proto *p = ci_func(ci)->p;
+    int npci = pcRel(pc, p);
+    if (npci == 0 ||  /* call linehook when enter a new function, */
+        pc <= L->oldpc ||  /* when jump back (loop), or when */
+        changedline(p, pcRel(L->oldpc, p), npci)) {  /* enter new line */
+      int newline = luaG_getfuncline(p, npci);
+      luaD_hook(L, LUA_HOOKLINE, newline, 0, 0);  /* call line hook */
+    }
+    L->oldpc = pc;  /* 'pc' of last call to line hook */
   }
-  L->oldpc = ci->u.l.savedpc;
   if (L->status == LUA_YIELD) {  /* did hook yield? */
     if (counthook)
       L->hookcount = 1;  /* undo decrement to zero */
     ci->u.l.savedpc--;  /* undo increment (resume will increment it again) */
     ci->callstatus |= CIST_HOOKYIELD;  /* mark that it yielded */
-    ci->func = L->top - 1;  /* protect stack below results */
     luaD_throw(L, LUA_YIELD);
   }
+  return 1;  /* keep 'trap' on */
 }
 

ldebug.h

@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.h,v 2.14.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: ldebug.h,v 2.17 2018/05/02 18:17:59 roberto Exp roberto $
 ** Auxiliary functions from Debug Interface module
 ** See Copyright Notice in lua.h
 */
@@ -11,13 +11,17 @@
 #include "lstate.h"
 
 
-#define pcRel(pc, p)	(cast(int, (pc) - (p)->code) - 1)
-
-#define getfuncline(f,pc)	(((f)->lineinfo) ? (f)->lineinfo[pc] : -1)
+#define pcRel(pc, p)	(cast_int((pc) - (p)->code) - 1)
 
 #define resethookcount(L)	(L->hookcount = L->basehookcount)
 
+/*
+** mark for entries in 'lineinfo' array that has absolute information in
+** 'abslineinfo' array
+*/
+#define ABSLINEINFO	(-0x80)
 
+LUAI_FUNC int luaG_getfuncline (const Proto *f, int pc);
 LUAI_FUNC l_noret luaG_typeerror (lua_State *L, const TValue *o,
                                                 const char *opname);
 LUAI_FUNC l_noret luaG_concaterror (lua_State *L, const TValue *p1,
@@ -33,7 +37,7 @@ LUAI_FUNC l_noret luaG_runerror (lua_State *L, const char *fmt, ...);
 LUAI_FUNC const char *luaG_addinfo (lua_State *L, const char *msg,
                                                   TString *src, int line);
 LUAI_FUNC l_noret luaG_errormsg (lua_State *L);
-LUAI_FUNC void luaG_traceexec (lua_State *L);
+LUAI_FUNC int luaG_traceexec (lua_State *L, const Instruction *pc);
 
 
 #endif

ldo.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.c,v 2.157.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: ldo.c,v 2.201 2018/05/22 12:02:36 roberto Exp roberto $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
@@ -91,7 +91,8 @@ struct lua_longjmp {
 static void seterrorobj (lua_State *L, int errcode, StkId oldtop) {
   switch (errcode) {
     case LUA_ERRMEM: {  /* memory error? */
-      setsvalue2s(L, oldtop, G(L)->memerrmsg); /* reuse preregistered msg. */
+      TString *memerrmsg = luaS_newliteral(L, MEMERRMSG);
+      setsvalue2s(L, oldtop, memerrmsg); /* reuse preregistered msg. */
       break;
     }
     case LUA_ERRERR: {
@@ -134,7 +135,7 @@ l_noret luaD_throw (lua_State *L, int errcode) {
 
 
 int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
-  unsigned short oldnCcalls = L->nCcalls;
+  unsigned short oldnCcalls = L->nCcalls - L->nci;
   struct lua_longjmp lj;
   lj.status = LUA_OK;
   lj.previous = L->errorJmp;  /* chain new error handler */
@@ -143,7 +144,7 @@ int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
     (*f)(L, ud);
   );
   L->errorJmp = lj.previous;  /* restore old error handler */
-  L->nCcalls = oldnCcalls;
+  L->nCcalls = oldnCcalls + L->nci;
   return lj.status;
 }
 
@@ -155,17 +156,19 @@ int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
 ** Stack reallocation
 ** ===================================================================
 */
-static void correctstack (lua_State *L, TValue *oldstack) {
+static void correctstack (lua_State *L, StkId oldstack, StkId newstack) {
   CallInfo *ci;
   UpVal *up;
-  L->top = (L->top - oldstack) + L->stack;
+  if (oldstack == newstack)
+    return;  /* stack address did not change */
+  L->top = (L->top - oldstack) + newstack;
   for (up = L->openupval; up != NULL; up = up->u.open.next)
-    up->v = (up->v - oldstack) + L->stack;
+    up->v = s2v((uplevel(up) - oldstack) + newstack);
   for (ci = L->ci; ci != NULL; ci = ci->previous) {
-    ci->top = (ci->top - oldstack) + L->stack;
-    ci->func = (ci->func - oldstack) + L->stack;
+    ci->top = (ci->top - oldstack) + newstack;
+    ci->func = (ci->func - oldstack) + newstack;
     if (isLua(ci))
-      ci->u.l.base = (ci->u.l.base - oldstack) + L->stack;
+      ci->u.l.trap = 1;  /* signal to update 'trap' in 'luaV_execute' */
   }
 }
 
@@ -174,36 +177,53 @@ static void correctstack (lua_State *L, TValue *oldstack) {
 #define ERRORSTACKSIZE	(LUAI_MAXSTACK + 200)
 
 
-void luaD_reallocstack (lua_State *L, int newsize) {
-  TValue *oldstack = L->stack;
+int luaD_reallocstack (lua_State *L, int newsize, int raiseerror) {
   int lim = L->stacksize;
+  StkId newstack = luaM_reallocvector(L, L->stack, lim, newsize, StackValue);
   lua_assert(newsize <= LUAI_MAXSTACK || newsize == ERRORSTACKSIZE);
   lua_assert(L->stack_last - L->stack == L->stacksize - EXTRA_STACK);
-  luaM_reallocvector(L, L->stack, L->stacksize, newsize, TValue);
+  if (unlikely(newstack == NULL)) {  /* reallocation failed? */
+    if (raiseerror)
+      luaM_error(L);
+    else return 0;  /* do not raise an error */
+  }
   for (; lim < newsize; lim++)
-    setnilvalue(L->stack + lim); /* erase new segment */
+    setnilvalue(s2v(newstack + lim)); /* erase new segment */
+  correctstack(L, L->stack, newstack);
+  L->stack = newstack;
   L->stacksize = newsize;
   L->stack_last = L->stack + newsize - EXTRA_STACK;
-  correctstack(L, oldstack);
+  return 1;
 }
 
 
-void luaD_growstack (lua_State *L, int n) {
+/*
+** Try to grow the stack by at least 'n' elements. when 'raiseerror'
+** is true, raises any error; otherwise, return 0 in case of errors.
+*/
+int luaD_growstack (lua_State *L, int n, int raiseerror) {
   int size = L->stacksize;
-  if (size > LUAI_MAXSTACK)  /* error after extra size? */
-    luaD_throw(L, LUA_ERRERR);
+  int newsize = 2 * size;  /* tentative new size */
+  if (unlikely(size > LUAI_MAXSTACK)) {  /* need more space after extra size? */
+    if (raiseerror)
+      luaD_throw(L, LUA_ERRERR);  /* error inside message handler */
+    else return 0;
+  }
   else {
     int needed = cast_int(L->top - L->stack) + n + EXTRA_STACK;
-    int newsize = 2 * size;
-    if (newsize > LUAI_MAXSTACK) newsize = LUAI_MAXSTACK;
-    if (newsize < needed) newsize = needed;
-    if (newsize > LUAI_MAXSTACK) {  /* stack overflow? */
-      luaD_reallocstack(L, ERRORSTACKSIZE);
-      luaG_runerror(L, "stack overflow");
+    if (newsize > LUAI_MAXSTACK)  /* cannot cross the limit */
+      newsize = LUAI_MAXSTACK;
+    if (newsize < needed)  /* but must respect what was asked for */
+      newsize = needed;
+    if (unlikely(newsize > LUAI_MAXSTACK)) {  /* stack overflow? */
+      /* add extra size to be able to handle the error message */
+      luaD_reallocstack(L, ERRORSTACKSIZE, raiseerror);
+      if (raiseerror)
+        luaG_runerror(L, "stack overflow");
+      else return 0;
     }
-    else
-      luaD_reallocstack(L, newsize);
-  }
+  }  /* else no errors */
+  return luaD_reallocstack(L, newsize, raiseerror);
 }
 
 
@@ -223,17 +243,14 @@ void luaD_shrinkstack (lua_State *L) {
   int goodsize = inuse + (inuse / 8) + 2*EXTRA_STACK;
   if (goodsize > LUAI_MAXSTACK)
     goodsize = LUAI_MAXSTACK;  /* respect stack limit */
-  if (L->stacksize > LUAI_MAXSTACK)  /* had been handling stack overflow? */
-    luaE_freeCI(L);  /* free all CIs (list grew because of an error) */
-  else
-    luaE_shrinkCI(L);  /* shrink list */
   /* if thread is currently not handling a stack overflow and its
      good size is smaller than current size, shrink its stack */
   if (inuse <= (LUAI_MAXSTACK - EXTRA_STACK) &&
       goodsize < L->stacksize)
-    luaD_reallocstack(L, goodsize);
+    luaD_reallocstack(L, goodsize, 0);  /* ok if that fails */
   else  /* don't change stack */
     condmovestack(L,{},{});  /* (change only for debugging) */
+  luaE_shrinkCI(L);  /* shrink CI list */
 }
 
 
@@ -247,12 +264,14 @@ void luaD_inctop (lua_State *L) {
 
 /*
 ** Call a hook for the given event. Make sure there is a hook to be
-** called. (Both 'L->hook' and 'L->hookmask', which triggers this
+** called. (Both 'L->hook' and 'L->hookmask', which trigger this
 ** function, can be changed asynchronously by signals.)
 */
-void luaD_hook (lua_State *L, int event, int line) {
+void luaD_hook (lua_State *L, int event, int line,
+                              int ftransfer, int ntransfer) {
   lua_Hook hook = L->hook;
   if (hook && L->allowhook) {  /* make sure there is a hook */
+    int mask = CIST_HOOKED;
     CallInfo *ci = L->ci;
     ptrdiff_t top = savestack(L, L->top);
     ptrdiff_t ci_top = savestack(L, ci->top);
@@ -260,11 +279,16 @@ void luaD_hook (lua_State *L, int event, int line) {
     ar.event = event;
     ar.currentline = line;
     ar.i_ci = ci;
+    if (ntransfer != 0) {
+      mask |= CIST_TRAN;  /* 'ci' has transfer information */
+      ci->u2.transferinfo.ftransfer = ftransfer;
+      ci->u2.transferinfo.ntransfer = ntransfer;
+    }
     luaD_checkstack(L, LUA_MINSTACK);  /* ensure minimum stack size */
-    ci->top = L->top + LUA_MINSTACK;
-    lua_assert(ci->top <= L->stack_last);
+    if (L->top + LUA_MINSTACK > ci->top)
+      ci->top = L->top + LUA_MINSTACK;
     L->allowhook = 0;  /* cannot call hooks inside a hook */
-    ci->callstatus |= CIST_HOOKED;
+    ci->callstatus |= mask;
     lua_unlock(L);
     (*hook)(L, &ar);
     lua_lock(L);
@@ -272,56 +296,66 @@ void luaD_hook (lua_State *L, int event, int line) {
     L->allowhook = 1;
     ci->top = restorestack(L, ci_top);
     L->top = restorestack(L, top);
-    ci->callstatus &= ~CIST_HOOKED;
+    ci->callstatus &= ~mask;
   }
 }
 
 
-static void callhook (lua_State *L, CallInfo *ci) {
-  int hook = LUA_HOOKCALL;
+/*
+** Executes a call hook for Lua functions. This function is called
+** whenever 'hookmask' is not zero, so it checks whether call hooks are
+** active.
+*/
+void luaD_hookcall (lua_State *L, CallInfo *ci) {
+  int hook = (ci->callstatus & CIST_TAIL) ? LUA_HOOKTAILCALL : LUA_HOOKCALL;
+  Proto *p;
+  if (!(L->hookmask & LUA_MASKCALL))  /* some other hook? */
+    return;  /* don't call hook */
+  p = clLvalue(s2v(ci->func))->p;
+  L->top = ci->top;  /* prepare top */
   ci->u.l.savedpc++;  /* hooks assume 'pc' is already incremented */
-  if (isLua(ci->previous) &&
-      GET_OPCODE(*(ci->previous->u.l.savedpc - 1)) == OP_TAILCALL) {
-    ci->callstatus |= CIST_TAIL;
-    hook = LUA_HOOKTAILCALL;
-  }
-  luaD_hook(L, hook, -1);
+  luaD_hook(L, hook, -1, 1, p->numparams);
   ci->u.l.savedpc--;  /* correct 'pc' */
 }
 
 
-static StkId adjust_varargs (lua_State *L, Proto *p, int actual) {
-  int i;
-  int nfixargs = p->numparams;
-  StkId base, fixed;
-  /* move fixed parameters to final position */
-  fixed = L->top - actual;  /* first fixed argument */
-  base = L->top;  /* final position of first argument */
-  for (i = 0; i < nfixargs && i < actual; i++) {
-    setobjs2s(L, L->top++, fixed + i);
-    setnilvalue(fixed + i);  /* erase original copy (for GC) */
+static StkId rethook (lua_State *L, CallInfo *ci, StkId firstres, int nres) {
+  ptrdiff_t oldtop = savestack(L, L->top);  /* hook may change top */
+  int delta = 0;
+  if (isLuacode(ci)) {
+    Proto *p = clLvalue(s2v(ci->func))->p;
+    if (p->is_vararg)
+      delta = ci->u.l.nextraargs + p->numparams + 1;
+    if (L->top < ci->top)
+      L->top = ci->top;  /* correct top to run hook */
   }
-  for (; i < nfixargs; i++)
-    setnilvalue(L->top++);  /* complete missing arguments */
-  return base;
+  if (L->hookmask & LUA_MASKRET) {  /* is return hook on? */
+    int ftransfer;
+    ci->func += delta;  /* if vararg, back to virtual 'func' */
+    ftransfer = cast(unsigned short, firstres - ci->func);
+    luaD_hook(L, LUA_HOOKRET, -1, ftransfer, nres);  /* call it */
+    ci->func -= delta;
+  }
+  if (isLua(ci->previous))
+    L->oldpc = ci->previous->u.l.savedpc;  /* update 'oldpc' */
+  return restorestack(L, oldtop);
 }
 
 
 /*
 ** Check whether __call metafield of 'func' is a function. If so, put
-** it in stack below original 'func' so that 'luaD_precall' can call
+** it in stack below original 'func' so that 'luaD_call' can call
 ** it. Raise an error if __call metafield is not a function.
 */
-static void tryfuncTM (lua_State *L, StkId func) {
-  const TValue *tm = luaT_gettmbyobj(L, func, TM_CALL);
+void luaD_tryfuncTM (lua_State *L, StkId func) {
+  const TValue *tm = luaT_gettmbyobj(L, s2v(func), TM_CALL);
   StkId p;
-  if (!ttisfunction(tm))
-    luaG_typeerror(L, func, "call");
-  /* Open a hole inside the stack at 'func' */
+  if (unlikely(!ttisfunction(tm)))
+    luaG_typeerror(L, s2v(func), "call");
   for (p = L->top; p > func; p--)
     setobjs2s(L, p, p-1);
-  L->top++;  /* slot ensured by caller */
-  setobj2s(L, func, tm);  /* tag method is the new function to be called */
+  L->top++;  /* assume EXTRA_STACK */
+  setobj2s(L, func, tm);  /* metamethod is the new function to be called */
 }
 
 
@@ -331,158 +365,74 @@ static void tryfuncTM (lua_State *L, StkId func) {
 ** expressions, multiple results for tail calls/single parameters)
 ** separated.
 */
-static int moveresults (lua_State *L, const TValue *firstResult, StkId res,
-                                      int nres, int wanted) {
+static void moveresults (lua_State *L, StkId res, int nres, int wanted) {
   switch (wanted) {  /* handle typical cases separately */
-    case 0: break;  /* nothing to move */
-    case 1: {  /* one result needed */
-      if (nres == 0)   /* no results? */
-        firstResult = luaO_nilobject;  /* adjust with nil */
-      setobjs2s(L, res, firstResult);  /* move it to proper place */
+    case 0:  /* no values needed */
+      L->top = res;
       break;
-    }
-    case LUA_MULTRET: {
+    case 1:  /* one value needed */
+      if (nres == 0)   /* no results? */
+        setnilvalue(s2v(res));  /* adjust with nil */
+      else
+        setobjs2s(L, res, L->top - nres);  /* move it to proper place */
+      L->top = res + 1;
+      break;
+    case LUA_MULTRET:
+      wanted = nres;  /* we want all results */
+      /* FALLTHROUGH */
+    default: {  /* multiple results */
+      StkId firstresult = L->top - nres;  /* index of first result */
       int i;
-      for (i = 0; i < nres; i++)  /* move all results to correct place */
-        setobjs2s(L, res + i, firstResult + i);
-      L->top = res + nres;
-      return 0;  /* wanted == LUA_MULTRET */
-    }
-    default: {
-      int i;
-      if (wanted <= nres) {  /* enough results? */
-        for (i = 0; i < wanted; i++)  /* move wanted results to correct place */
-          setobjs2s(L, res + i, firstResult + i);
-      }
-      else {  /* not enough results; use all of them plus nils */
-        for (i = 0; i < nres; i++)  /* move all results to correct place */
-          setobjs2s(L, res + i, firstResult + i);
-        for (; i < wanted; i++)  /* complete wanted number of results */
-          setnilvalue(res + i);
-      }
+      /* move all results to correct place */
+      for (i = 0; i < nres && i < wanted; i++)
+        setobjs2s(L, res + i, firstresult + i);
+      for (; i < wanted; i++)  /* complete wanted number of results */
+        setnilvalue(s2v(res + i));
+      L->top = res + wanted;  /* top points after the last result */
       break;
     }
   }
-  L->top = res + wanted;  /* top points after the last result */
-  return 1;
 }
 
 
 /*
 ** Finishes a function call: calls hook if necessary, removes CallInfo,
-** moves current number of results to proper place; returns 0 iff call
-** wanted multiple (variable number of) results.
+** moves current number of results to proper place.
 */
-int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult, int nres) {
-  StkId res;
-  int wanted = ci->nresults;
-  if (L->hookmask & (LUA_MASKRET | LUA_MASKLINE)) {
-    if (L->hookmask & LUA_MASKRET) {
-      ptrdiff_t fr = savestack(L, firstResult);  /* hook may change stack */
-      luaD_hook(L, LUA_HOOKRET, -1);
-      firstResult = restorestack(L, fr);
-    }
-    L->oldpc = ci->previous->u.l.savedpc;  /* 'oldpc' for caller function */
-  }
-  res = ci->func;  /* res == final position of 1st result */
+void luaD_poscall (lua_State *L, CallInfo *ci, int nres) {
+  if (L->hookmask)
+    L->top = rethook(L, ci, L->top - nres, nres);
   L->ci = ci->previous;  /* back to caller */
   /* move results to proper place */
-  return moveresults(L, firstResult, res, nres, wanted);
+  moveresults(L, ci->func, nres, ci->nresults);
 }
 
 
 
-#define next_ci(L) (L->ci = (L->ci->next ? L->ci->next : luaE_extendCI(L)))
-
-
-/* macro to check stack size, preserving 'p' */
-#define checkstackp(L,n,p)  \
-  luaD_checkstackaux(L, n, \
-    ptrdiff_t t__ = savestack(L, p);  /* save 'p' */ \
-    luaC_checkGC(L),  /* stack grow uses memory */ \
-    p = restorestack(L, t__))  /* 'pos' part: restore 'p' */
+#define next_ci(L)  (L->ci = (L->ci->next ? L->ci->next : luaE_extendCI(L)))
 
 
 /*
-** Prepares a function call: checks the stack, creates a new CallInfo
-** entry, fills in the relevant information, calls hook if needed.
-** If function is a C function, does the call, too. (Otherwise, leave
-** the execution ('luaV_execute') to the caller, to allow stackless
-** calls.) Returns true iff function has been executed (C function).
+** Prepare a function for a tail call, building its call info on top
+** of the current call info. 'narg1' is the number of arguments plus 1
+** (so that it includes the function itself).
 */
-int luaD_precall (lua_State *L, StkId func, int nresults) {
-  lua_CFunction f;
-  CallInfo *ci;
-  switch (ttype(func)) {
-    case LUA_TCCL:  /* C closure */
-      f = clCvalue(func)->f;
-      goto Cfunc;
-    case LUA_TLCF:  /* light C function */
-      f = fvalue(func);
-     Cfunc: {
-      int n;  /* number of returns */
-      checkstackp(L, LUA_MINSTACK, func);  /* ensure minimum stack size */
-      ci = next_ci(L);  /* now 'enter' new function */
-      ci->nresults = nresults;
-      ci->func = func;
-      ci->top = L->top + LUA_MINSTACK;
-      lua_assert(ci->top <= L->stack_last);
-      ci->callstatus = 0;
-      if (L->hookmask & LUA_MASKCALL)
-        luaD_hook(L, LUA_HOOKCALL, -1);
-      lua_unlock(L);
-      n = (*f)(L);  /* do the actual call */
-      lua_lock(L);
-      api_checknelems(L, n);
-      luaD_poscall(L, ci, L->top - n, n);
-      return 1;
-    }
-    case LUA_TLCL: {  /* Lua function: prepare its call */
-      StkId base;
-      Proto *p = clLvalue(func)->p;
-      int n = cast_int(L->top - func) - 1;  /* number of real arguments */
-      int fsize = p->maxstacksize;  /* frame size */
-      checkstackp(L, fsize, func);
-      if (p->is_vararg)
-        base = adjust_varargs(L, p, n);
-      else {  /* non vararg function */
-        for (; n < p->numparams; n++)
-          setnilvalue(L->top++);  /* complete missing arguments */
-        base = func + 1;
-      }
-      ci = next_ci(L);  /* now 'enter' new function */
-      ci->nresults = nresults;
-      ci->func = func;
-      ci->u.l.base = base;
-      L->top = ci->top = base + fsize;
-      lua_assert(ci->top <= L->stack_last);
-      ci->u.l.savedpc = p->code;  /* starting point */
-      ci->callstatus = CIST_LUA;
-      if (L->hookmask & LUA_MASKCALL)
-        callhook(L, ci);
-      return 0;
-    }
-    default: {  /* not a function */
-      checkstackp(L, 1, func);  /* ensure space for metamethod */
-      tryfuncTM(L, func);  /* try to get '__call' metamethod */
-      return luaD_precall(L, func, nresults);  /* now it must be a function */
-    }
-  }
-}
-
-
-/*
-** Check appropriate error for stack overflow ("regular" overflow or
-** overflow while handling stack overflow). If 'nCalls' is larger than
-** LUAI_MAXCCALLS (which means it is handling a "regular" overflow) but
-** smaller than 9/8 of LUAI_MAXCCALLS, does not report an error (to
-** allow overflow handling to work)
-*/
-static void stackerror (lua_State *L) {
-  if (L->nCcalls == LUAI_MAXCCALLS)
-    luaG_runerror(L, "C stack overflow");
-  else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
-    luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
+void luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func, int narg1) {
+  Proto *p = clLvalue(s2v(func))->p;
+  int fsize = p->maxstacksize;  /* frame size */
+  int nfixparams = p->numparams;
+  int i;
+  for (i = 0; i < narg1; i++)  /* move down function and arguments */
+    setobjs2s(L, ci->func + i, func + i);
+  checkstackGC(L, fsize);
+  func = ci->func;  /* moved-down function */
+  for (; narg1 <= nfixparams; narg1++)
+    setnilvalue(s2v(func + narg1));  /* complete missing arguments */
+  ci->top = func + 1 + fsize;  /* top for new function */
+  lua_assert(ci->top <= L->stack_last);
+  ci->u.l.savedpc = p->code;  /* starting point */
+  ci->callstatus |= CIST_TAIL;
+  L->top = func + narg1;  /* set top */
 }
 
 
@@ -492,12 +442,61 @@ static void stackerror (lua_State *L) {
 ** When returns, all the results are on the stack, starting at the original
 ** function position.
 */
-void luaD_call (lua_State *L, StkId func, int nResults) {
-  if (++L->nCcalls >= LUAI_MAXCCALLS)
-    stackerror(L);
-  if (!luaD_precall(L, func, nResults))  /* is a Lua function? */
-    luaV_execute(L);  /* call it */
-  L->nCcalls--;
+void luaD_call (lua_State *L, StkId func, int nresults) {
+  lua_CFunction f;
+  TValue *funcv = s2v(func);
+  switch (ttypetag(funcv)) {
+    case LUA_TCCL:  /* C closure */
+      f = clCvalue(funcv)->f;
+      goto Cfunc;
+    case LUA_TLCF:  /* light C function */
+      f = fvalue(funcv);
+     Cfunc: {
+      int n;  /* number of returns */
+      CallInfo *ci;
+      checkstackp(L, LUA_MINSTACK, func);  /* ensure minimum stack size */
+      ci = next_ci(L);
+      ci->nresults = nresults;
+      ci->callstatus = CIST_C;
+      ci->top = L->top + LUA_MINSTACK;
+      ci->func = func;
+      lua_assert(ci->top <= L->stack_last);
+      if (L->hookmask & LUA_MASKCALL) {
+        int narg = cast_int(L->top - func) - 1;
+        luaD_hook(L, LUA_HOOKCALL, -1, 1, narg);
+      }
+      lua_unlock(L);
+      n = (*f)(L);  /* do the actual call */
+      lua_lock(L);
+      api_checknelems(L, n);
+      luaD_poscall(L, ci, n);
+      break;
+    }
+    case LUA_TLCL: {  /* Lua function */
+      CallInfo *ci;
+      Proto *p = clLvalue(funcv)->p;
+      int narg = cast_int(L->top - func) - 1;  /* number of real arguments */
+      int nfixparams = p->numparams;
+      int fsize = p->maxstacksize;  /* frame size */
+      checkstackp(L, fsize, func);
+      ci = next_ci(L);
+      ci->nresults = nresults;
+      ci->u.l.savedpc = p->code;  /* starting point */
+      ci->callstatus = 0;
+      ci->top = func + 1 + fsize;
+      ci->func = func;
+      for (; narg < nfixparams; narg++)
+        setnilvalue(s2v(L->top++));  /* complete missing arguments */
+      lua_assert(ci->top <= L->stack_last);
+      luaV_execute(L, ci);  /* run the function */
+      break;
+    }
+    default: {  /* not a function */
+      luaD_tryfuncTM(L, func);  /* try to get '__call' metamethod */
+      luaD_call(L, func, nresults);  /* now it must be a function */
+      break;
+    }
+  }
 }
 
 
@@ -533,7 +532,7 @@ static void finishCcall (lua_State *L, int status) {
   n = (*ci->u.c.k)(L, status, ci->u.c.ctx);  /* call continuation function */
   lua_lock(L);
   api_checknelems(L, n);
-  luaD_poscall(L, ci, L->top - n, n);  /* finish 'luaD_precall' */
+  luaD_poscall(L, ci, n);  /* finish 'luaD_call' */
 }
 
 
@@ -546,14 +545,15 @@ static void finishCcall (lua_State *L, int status) {
 ** status is LUA_YIELD).
 */
 static void unroll (lua_State *L, void *ud) {
+  CallInfo *ci;
   if (ud != NULL)  /* error status? */
     finishCcall(L, *(int *)ud);  /* finish 'lua_pcallk' callee */
-  while (L->ci != &L->base_ci) {  /* something in the stack */
-    if (!isLua(L->ci))  /* C function? */
+  while ((ci = L->ci) != &L->base_ci) {  /* something in the stack */
+    if (!isLua(ci))  /* C function? */
       finishCcall(L, LUA_YIELD);  /* complete its execution */
     else {  /* Lua function */
       luaV_finishOp(L);  /* finish interrupted instruction */
-      luaV_execute(L);  /* execute down to higher C 'boundary' */
+      luaV_execute(L, ci);  /* execute down to higher C 'boundary' */
     }
   }
 }
@@ -583,7 +583,7 @@ static int recover (lua_State *L, int status) {
   CallInfo *ci = findpcall(L);
   if (ci == NULL) return 0;  /* no recovery point */
   /* "finish" luaD_pcall */
-  oldtop = restorestack(L, ci->extra);
+  oldtop = restorestack(L, ci->u2.funcidx);
   luaF_close(L, oldtop);
   seterrorobj(L, status, oldtop);
   L->ci = ci;
@@ -621,31 +621,29 @@ static void resume (lua_State *L, void *ud) {
   StkId firstArg = L->top - n;  /* first argument */
   CallInfo *ci = L->ci;
   if (L->status == LUA_OK) {  /* starting a coroutine? */
-    if (!luaD_precall(L, firstArg - 1, LUA_MULTRET))  /* Lua function? */
-      luaV_execute(L);  /* call it */
+    luaD_call(L, firstArg - 1, LUA_MULTRET);
   }
   else {  /* resuming from previous yield */
     lua_assert(L->status == LUA_YIELD);
     L->status = LUA_OK;  /* mark that it is running (again) */
-    ci->func = restorestack(L, ci->extra);
     if (isLua(ci))  /* yielded inside a hook? */
-      luaV_execute(L);  /* just continue running Lua code */
+      luaV_execute(L, ci);  /* just continue running Lua code */
     else {  /* 'common' yield */
       if (ci->u.c.k != NULL) {  /* does it have a continuation function? */
         lua_unlock(L);
         n = (*ci->u.c.k)(L, LUA_YIELD, ci->u.c.ctx); /* call continuation */
         lua_lock(L);
         api_checknelems(L, n);
-        firstArg = L->top - n;  /* yield results come from continuation */
       }
-      luaD_poscall(L, ci, firstArg, n);  /* finish 'luaD_precall' */
+      luaD_poscall(L, ci, n);  /* finish 'luaD_call' */
     }
     unroll(L, NULL);  /* run continuation */
   }
 }
 
 
-LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
+LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs,
+                                      int *nresults) {
   int status;
   unsigned short oldnny = L->nny;  /* save "number of non-yieldable" calls */
   lua_lock(L);
@@ -662,23 +660,24 @@ LUA_API int lua_resume (lua_State *L, lua_State *from, int nargs) {
   L->nny = 0;  /* allow yields */
   api_checknelems(L, (L->status == LUA_OK) ? nargs + 1 : nargs);
   status = luaD_rawrunprotected(L, resume, &nargs);
-  if (status == -1)  /* error calling 'lua_resume'? */
+  if (unlikely(status == -1))  /* error calling 'lua_resume'? */
     status = LUA_ERRRUN;
   else {  /* continue running after recoverable errors */
     while (errorstatus(status) && recover(L, status)) {
       /* unroll continuation */
       status = luaD_rawrunprotected(L, unroll, &status);
     }
-    if (errorstatus(status)) {  /* unrecoverable error? */
+    if (unlikely(errorstatus(status))) {  /* unrecoverable error? */
       L->status = cast_byte(status);  /* mark thread as 'dead' */
       seterrorobj(L, status, L->top);  /* push error message */
       L->ci->top = L->top;
     }
     else lua_assert(status == L->status);  /* normal end or yield */
   }
+  *nresults = (status == LUA_YIELD) ? L->ci->u2.nyield
+                                    : cast_int(L->top - (L->ci->func + 1));
   L->nny = oldnny;  /* restore 'nny' */
   L->nCcalls--;
-  lua_assert(L->nCcalls == ((from) ? from->nCcalls : 0));
   lua_unlock(L);
   return status;
 }
@@ -695,21 +694,22 @@ LUA_API int lua_yieldk (lua_State *L, int nresults, lua_KContext ctx,
   luai_userstateyield(L, nresults);
   lua_lock(L);
   api_checknelems(L, nresults);
-  if (L->nny > 0) {
+  if (unlikely(L->nny > 0)) {
     if (L != G(L)->mainthread)
       luaG_runerror(L, "attempt to yield across a C-call boundary");
     else
       luaG_runerror(L, "attempt to yield from outside a coroutine");
   }
   L->status = LUA_YIELD;
-  ci->extra = savestack(L, ci->func);  /* save current 'func' */
   if (isLua(ci)) {  /* inside a hook? */
+    lua_assert(!isLuacode(ci));
     api_check(L, k == NULL, "hooks cannot continue after yielding");
+    ci->u2.nyield = 0;  /* no results */
   }
   else {
     if ((ci->u.c.k = k) != NULL)  /* is there a continuation? */
       ci->u.c.ctx = ctx;  /* save context */
-    ci->func = L->top - nresults - 1;  /* protect stack below results */
+    ci->u2.nyield = nresults;  /* save number of results */
     luaD_throw(L, LUA_YIELD);
   }
   lua_assert(ci->callstatus & CIST_HOOKED);  /* must be inside a hook */
@@ -727,7 +727,7 @@ int luaD_pcall (lua_State *L, Pfunc func, void *u,
   ptrdiff_t old_errfunc = L->errfunc;
   L->errfunc = ef;
   status = luaD_rawrunprotected(L, func, u);
-  if (status != LUA_OK) {  /* an error occurred? */
+  if (unlikely(status != LUA_OK)) {  /* an error occurred? */
     StkId oldtop = restorestack(L, old_top);
     luaF_close(L, oldtop);  /* close possible pending closures */
     seterrorobj(L, status, oldtop);

ldo.h

@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.h,v 2.29.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: ldo.h,v 2.43 2018/02/17 19:29:29 roberto Exp roberto $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
@@ -22,7 +22,8 @@
 */
 #define luaD_checkstackaux(L,n,pre,pos)  \
 	if (L->stack_last - L->top <= (n)) \
-	  { pre; luaD_growstack(L, n); pos; } else { condmovestack(L,pre,pos); }
+	  { pre; luaD_growstack(L, n, 1); pos; } \
+        else { condmovestack(L,pre,pos); }
 
 /* In general, 'pre'/'pos' are empty (nothing to save) */
 #define luaD_checkstack(L,n)	luaD_checkstackaux(L,n,(void)0,(void)0)
@@ -30,7 +31,20 @@
 
 
 #define savestack(L,p)		((char *)(p) - (char *)L->stack)
-#define restorestack(L,n)	((TValue *)((char *)L->stack + (n)))
+#define restorestack(L,n)	((StkId)((char *)L->stack + (n)))
+
+
+/* macro to check stack size, preserving 'p' */
+#define checkstackp(L,n,p)  \
+  luaD_checkstackaux(L, n, \
+    ptrdiff_t t__ = savestack(L, p);  /* save 'p' */ \
+    luaC_checkGC(L),  /* stack grow uses memory */ \
+    p = restorestack(L, t__))  /* 'pos' part: restore 'p' */
+
+
+/* macro to check stack size and GC */
+#define checkstackGC(L,fsize)  \
+	luaD_checkstackaux(L, (fsize), (void)0, luaC_checkGC(L))
 
 
 /* type of protected functions, to be ran by 'runprotected' */
@@ -38,16 +52,18 @@ typedef void (*Pfunc) (lua_State *L, void *ud);
 
 LUAI_FUNC int luaD_protectedparser (lua_State *L, ZIO *z, const char *name,
                                                   const char *mode);
-LUAI_FUNC void luaD_hook (lua_State *L, int event, int line);
-LUAI_FUNC int luaD_precall (lua_State *L, StkId func, int nresults);
+LUAI_FUNC void luaD_hook (lua_State *L, int event, int line,
+                                        int fTransfer, int nTransfer);
+LUAI_FUNC void luaD_hookcall (lua_State *L, CallInfo *ci);
+LUAI_FUNC void luaD_pretailcall (lua_State *L, CallInfo *ci, StkId func, int n);
 LUAI_FUNC void luaD_call (lua_State *L, StkId func, int nResults);
 LUAI_FUNC void luaD_callnoyield (lua_State *L, StkId func, int nResults);
+LUAI_FUNC void luaD_tryfuncTM (lua_State *L, StkId func);
 LUAI_FUNC int luaD_pcall (lua_State *L, Pfunc func, void *u,
                                         ptrdiff_t oldtop, ptrdiff_t ef);
-LUAI_FUNC int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult,
-                                          int nres);
-LUAI_FUNC void luaD_reallocstack (lua_State *L, int newsize);
-LUAI_FUNC void luaD_growstack (lua_State *L, int n);
+LUAI_FUNC void luaD_poscall (lua_State *L, CallInfo *ci, int nres);
+LUAI_FUNC int luaD_reallocstack (lua_State *L, int newsize, int raiseerror);
+LUAI_FUNC int luaD_growstack (lua_State *L, int n, int raiseerror);
 LUAI_FUNC void luaD_shrinkstack (lua_State *L);
 LUAI_FUNC void luaD_inctop (lua_State *L);
 

ldump.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ldump.c,v 2.37.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: ldump.c,v 2.40 2017/11/28 11:19:07 roberto Exp roberto $
 ** save precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
@@ -55,8 +55,23 @@ static void DumpByte (int y, DumpState *D) {
 }
 
 
+/* DumpInt Buff Size */
+#define DIBS    ((sizeof(size_t) * 8 / 7) + 1)
+
+static void DumpSize (size_t x, DumpState *D) {
+  lu_byte buff[DIBS];
+  int n = 0;
+  do {
+    buff[DIBS - (++n)] = x & 0x7f;  /* fill buffer in reverse order */
+    x >>= 7;
+  } while (x != 0);
+  buff[DIBS - 1] |= 0x80;  /* mark last byte */
+  DumpVector(buff + DIBS - n, n, D);
+}
+
+
 static void DumpInt (int x, DumpState *D) {
-  DumpVar(x, D);
+  DumpSize(x, D);
 }
 
 
@@ -72,17 +87,12 @@ static void DumpInteger (lua_Integer x, DumpState *D) {
 
 static void DumpString (const TString *s, DumpState *D) {
   if (s == NULL)
-    DumpByte(0, D);
+    DumpSize(0, D);
   else {
-    size_t size = tsslen(s) + 1;  /* include trailing '\0' */
+    size_t size = tsslen(s);
     const char *str = getstr(s);
-    if (size < 0xFF)
-      DumpByte(cast_int(size), D);
-    else {
-      DumpByte(0xFF, D);
-      DumpVar(size, D);
-    }
-    DumpVector(str, size - 1, D);  /* no need to save '\0' */
+    DumpSize(size + 1, D);
+    DumpVector(str, size, D);
   }
 }
 
@@ -101,25 +111,24 @@ static void DumpConstants (const Proto *f, DumpState *D) {
   DumpInt(n, D);
   for (i = 0; i < n; i++) {
     const TValue *o = &f->k[i];
-    DumpByte(ttype(o), D);
-    switch (ttype(o)) {
-    case LUA_TNIL:
-      break;
-    case LUA_TBOOLEAN:
-      DumpByte(bvalue(o), D);
-      break;
-    case LUA_TNUMFLT:
-      DumpNumber(fltvalue(o), D);
-      break;
-    case LUA_TNUMINT:
-      DumpInteger(ivalue(o), D);
-      break;
-    case LUA_TSHRSTR:
-    case LUA_TLNGSTR:
-      DumpString(tsvalue(o), D);
-      break;
-    default:
-      lua_assert(0);
+    DumpByte(ttypetag(o), D);
+    switch (ttypetag(o)) {
+      case LUA_TNIL:
+        break;
+      case LUA_TBOOLEAN:
+        DumpByte(bvalue(o), D);
+        break;
+      case LUA_TNUMFLT:
+        DumpNumber(fltvalue(o), D);
+        break;
+      case LUA_TNUMINT:
+        DumpInteger(ivalue(o), D);
+        break;
+      case LUA_TSHRSTR:
+      case LUA_TLNGSTR:
+        DumpString(tsvalue(o), D);
+        break;
+      default: lua_assert(0);
     }
   }
 }
@@ -149,6 +158,12 @@ static void DumpDebug (const Proto *f, DumpState *D) {
   n = (D->strip) ? 0 : f->sizelineinfo;
   DumpInt(n, D);
   DumpVector(f->lineinfo, n, D);
+  n = (D->strip) ? 0 : f->sizeabslineinfo;
+  DumpInt(n, D);
+  for (i = 0; i < n; i++) {
+    DumpInt(f->abslineinfo[i].pc, D);
+    DumpInt(f->abslineinfo[i].line, D);
+  }
   n = (D->strip) ? 0 : f->sizelocvars;
   DumpInt(n, D);
   for (i = 0; i < n; i++) {

lfunc.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.c,v 2.45.1.1 2017/04/19 17:39:34 roberto Exp $
+** $Id: lfunc.c,v 2.50 2017/06/27 11:35:31 roberto Exp roberto $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
@@ -45,33 +45,36 @@ LClosure *luaF_newLclosure (lua_State *L, int n) {
 void luaF_initupvals (lua_State *L, LClosure *cl) {
   int i;
   for (i = 0; i < cl->nupvalues; i++) {
-    UpVal *uv = luaM_new(L, UpVal);
-    uv->refcount = 1;
+    GCObject *o = luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal));
+    UpVal *uv = gco2upv(o);
     uv->v = &uv->u.value;  /* make it closed */
     setnilvalue(uv->v);
     cl->upvals[i] = uv;
+    luaC_objbarrier(L, cl, o);
   }
 }
 
 
 UpVal *luaF_findupval (lua_State *L, StkId level) {
   UpVal **pp = &L->openupval;
+  GCObject *o;
   UpVal *p;
   UpVal *uv;
   lua_assert(isintwups(L) || L->openupval == NULL);
-  while (*pp != NULL && (p = *pp)->v >= level) {
-    lua_assert(upisopen(p));
-    if (p->v == level)  /* found a corresponding upvalue? */
+  while ((p = *pp) != NULL && uplevel(p) >= level) {
+    if (uplevel(p) == level && !isdead(G(L), p))  /* corresponding upvalue? */
       return p;  /* return it */
     pp = &p->u.open.next;
   }
-  /* not found: create a new upvalue */
-  uv = luaM_new(L, UpVal);
-  uv->refcount = 0;
-  uv->u.open.next = *pp;  /* link it to list of open upvalues */
-  uv->u.open.touched = 1;
+  /* not found: create a new upvalue between 'pp' and 'p' */
+  o = luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal));
+  uv = gco2upv(o);
+  uv->u.open.next = p;  /* link it to list of open upvalues */
+  uv->u.open.previous = pp;
+  if (p)
+    p->u.open.previous = &uv->u.open.next;
   *pp = uv;
-  uv->v = level;  /* current value lives in the stack */
+  uv->v = s2v(level);  /* current value lives in the stack */
   if (!isintwups(L)) {  /* thread not in list of threads with upvalues? */
     L->twups = G(L)->twups;  /* link it to the list */
     G(L)->twups = L;
@@ -80,18 +83,25 @@ UpVal *luaF_findupval (lua_State *L, StkId level) {
 }
 
 
+void luaF_unlinkupval (UpVal *uv) {
+  lua_assert(upisopen(uv));
+  *uv->u.open.previous = uv->u.open.next;
+  if (uv->u.open.next)
+    uv->u.open.next->u.open.previous = uv->u.open.previous;
+}
+
+
 void luaF_close (lua_State *L, StkId level) {
   UpVal *uv;
-  while (L->openupval != NULL && (uv = L->openupval)->v >= level) {
-    lua_assert(upisopen(uv));
-    L->openupval = uv->u.open.next;  /* remove from 'open' list */
-    if (uv->refcount == 0)  /* no references? */
-      luaM_free(L, uv);  /* free upvalue */
-    else {
-      setobj(L, &uv->u.value, uv->v);  /* move value to upvalue slot */
-      uv->v = &uv->u.value;  /* now current value lives here */
-      luaC_upvalbarrier(L, uv);
-    }
+  while (L->openupval != NULL &&
+        (uv = L->openupval, uplevel(uv) >= level)) {
+    TValue *slot = &uv->u.value;  /* new position for value */
+    luaF_unlinkupval(uv);
+    setobj(L, slot, uv->v);  /* move value to upvalue slot */
+    uv->v = slot;  /* now current value lives here */
+    if (!iswhite(uv))
+      gray2black(uv);  /* closed upvalues cannot be gray */
+    luaC_barrier(L, uv, slot);
   }
 }
 
@@ -105,9 +115,12 @@ Proto *luaF_newproto (lua_State *L) {
   f->sizep = 0;
   f->code = NULL;
   f->cache = NULL;
+  f->cachemiss = 0;
   f->sizecode = 0;
   f->lineinfo = NULL;
   f->sizelineinfo = 0;
+  f->abslineinfo = NULL;
+  f->sizeabslineinfo = 0;
   f->upvalues = NULL;
   f->sizeupvalues = 0;
   f->numparams = 0;
@@ -127,6 +140,7 @@ void luaF_freeproto (lua_State *L, Proto *f) {
   luaM_freearray(L, f->p, f->sizep);
   luaM_freearray(L, f->k, f->sizek);
   luaM_freearray(L, f->lineinfo, f->sizelineinfo);
+  luaM_freearray(L, f->abslineinfo, f->sizeabslineinfo);
   luaM_freearray(L, f->locvars, f->sizelocvars);
   luaM_freearray(L, f->upvalues, f->sizeupvalues);
   luaM_free(L, f);

lfunc.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.h,v 2.15.1.1 2017/04/19 17:39:34 roberto Exp $
+** $Id: lfunc.h,v 2.19 2018/01/28 15:13:26 roberto Exp roberto $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
@@ -11,11 +11,11 @@
 #include "lobject.h"
 
 
-#define sizeCclosure(n)	(cast(int, sizeof(CClosure)) + \
-                         cast(int, sizeof(TValue)*((n)-1)))
+#define sizeCclosure(n)	(cast_int(offsetof(CClosure, upvalue)) + \
+                         cast_int(sizeof(TValue)) * (n))
 
-#define sizeLclosure(n)	(cast(int, sizeof(LClosure)) + \
-                         cast(int, sizeof(TValue *)*((n)-1)))
+#define sizeLclosure(n)	(cast_int(offsetof(LClosure, upvals)) + \
+                         cast_int(sizeof(TValue *)) * (n))
 
 
 /* test whether thread is in 'twups' list */
@@ -29,30 +29,26 @@
 #define MAXUPVAL	255
 
 
-/*
-** Upvalues for Lua closures
-*/
-struct UpVal {
-  TValue *v;  /* points to stack or to its own value */
-  lu_mem refcount;  /* reference counter */
-  union {
-    struct {  /* (when open) */
-      UpVal *next;  /* linked list */
-      int touched;  /* mark to avoid cycles with dead threads */
-    } open;
-    TValue value;  /* the value (when closed) */
-  } u;
-};
-
 #define upisopen(up)	((up)->v != &(up)->u.value)
 
 
+#define uplevel(up)	check_exp(upisopen(up), cast(StkId, (up)->v))
+
+
+/*
+** maximum number of misses before giving up the cache of closures
+** in prototypes
+*/
+#define MAXMISS		10
+
+
 LUAI_FUNC Proto *luaF_newproto (lua_State *L);
 LUAI_FUNC CClosure *luaF_newCclosure (lua_State *L, int nelems);
 LUAI_FUNC LClosure *luaF_newLclosure (lua_State *L, int nelems);
 LUAI_FUNC void luaF_initupvals (lua_State *L, LClosure *cl);
 LUAI_FUNC UpVal *luaF_findupval (lua_State *L, StkId level);
 LUAI_FUNC void luaF_close (lua_State *L, StkId level);
+LUAI_FUNC void luaF_unlinkupval (UpVal *uv);
 LUAI_FUNC void luaF_freeproto (lua_State *L, Proto *f);
 LUAI_FUNC const char *luaF_getlocalname (const Proto *func, int local_number,
                                          int pc);

lgc.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lgc.h,v 2.91.1.1 2017/04/19 17:39:34 roberto Exp $
+** $Id: lgc.h,v 2.102 2018/02/19 20:06:56 roberto Exp roberto $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
@@ -25,25 +25,18 @@
 */
 
 
-
-/* how much to allocate before next GC step */
-#if !defined(GCSTEPSIZE)
-/* ~100 small strings */
-#define GCSTEPSIZE	(cast_int(100 * sizeof(TString)))
-#endif
-
-
 /*
 ** Possible states of the Garbage Collector
 */
 #define GCSpropagate	0
-#define GCSatomic	1
-#define GCSswpallgc	2
-#define GCSswpfinobj	3
-#define GCSswptobefnz	4
-#define GCSswpend	5
-#define GCScallfin	6
-#define GCSpause	7
+#define GCSenteratomic	1
+#define GCSatomic	2
+#define GCSswpallgc	3
+#define GCSswpfinobj	4
+#define GCSswptobefnz	5
+#define GCSswpend	6
+#define GCScallfin	7
+#define GCSpause	8
 
 
 #define issweepphase(g)  \
@@ -64,7 +57,7 @@
 /*
 ** some useful bit tricks
 */
-#define resetbits(x,m)		((x) &= cast(lu_byte, ~(m)))
+#define resetbits(x,m)		((x) &= cast_byte(~(m)))
 #define setbits(x,m)		((x) |= (m))
 #define testbits(x,m)		((x) & (m))
 #define bitmask(b)		(1<<(b))
@@ -74,12 +67,17 @@
 #define testbit(x,b)		testbits(x, bitmask(b))
 
 
-/* Layout for bit use in 'marked' field: */
-#define WHITE0BIT	0  /* object is white (type 0) */
-#define WHITE1BIT	1  /* object is white (type 1) */
-#define BLACKBIT	2  /* object is black */
-#define FINALIZEDBIT	3  /* object has been marked for finalization */
-/* bit 7 is currently used by tests (luaL_checkmemory) */
+/*
+** Layout for bit use in 'marked' field. First three bits are
+** used for object "age" in generational mode. Last bit is free
+** to be used by respective objects.
+*/
+#define WHITE0BIT	3  /* object is white (type 0) */
+#define WHITE1BIT	4  /* object is white (type 1) */
+#define BLACKBIT	5  /* object is black */
+#define FINALIZEDBIT	6  /* object has been marked for finalization */
+
+
 
 #define WHITEBITS	bit2mask(WHITE0BIT, WHITE1BIT)
 
@@ -92,13 +90,52 @@
 #define tofinalize(x)	testbit((x)->marked, FINALIZEDBIT)
 
 #define otherwhite(g)	((g)->currentwhite ^ WHITEBITS)
-#define isdeadm(ow,m)	(!(((m) ^ WHITEBITS) & (ow)))
+#define isdeadm(ow,m)	((m) & (ow))
 #define isdead(g,v)	isdeadm(otherwhite(g), (v)->marked)
 
 #define changewhite(x)	((x)->marked ^= WHITEBITS)
 #define gray2black(x)	l_setbit((x)->marked, BLACKBIT)
 
-#define luaC_white(g)	cast(lu_byte, (g)->currentwhite & WHITEBITS)
+#define luaC_white(g)	cast_byte((g)->currentwhite & WHITEBITS)
+
+
+/* object age in generational mode */
+#define G_NEW		0	/* created in current cycle */
+#define G_SURVIVAL	1	/* created in previous cycle */
+#define G_OLD0		2	/* marked old by frw. barrier in this cycle */
+#define G_OLD1		3	/* first full cycle as old */
+#define G_OLD		4	/* really old object (not to be visited) */
+#define G_TOUCHED1	5	/* old object touched this cycle */
+#define G_TOUCHED2	6	/* old object touched in previous cycle */
+
+#define AGEBITS		7  /* all age bits (111) */
+
+#define getage(o)	((o)->marked & AGEBITS)
+#define setage(o,a)  ((o)->marked = cast_byte(((o)->marked & (~AGEBITS)) | a))
+#define isold(o)	(getage(o) > G_SURVIVAL)
+
+#define changeage(o,f,t)  \
+	check_exp(getage(o) == (f), (o)->marked ^= ((f)^(t)))
+
+
+/* Default Values for GC parameters */
+#define LUAI_GENMAJORMUL         100
+#define LUAI_GENMINORMUL         20
+
+/* wait memory to double before starting new cycle */
+#define LUAI_GCPAUSE    200     /* 200% */
+
+/*
+** some gc parameters are stored divided by 4 to allow a maximum value
+** larger than 1000 in a 'lu_byte'.
+*/
+#define getgcparam(p)	((p) * 4)
+#define setgcparam(p,v)	((p) = (v) / 4)
+
+#define LUAI_GCMUL      100
+
+/* how much to allocate before next GC step (log2) */
+#define LUAI_GCSTEPSIZE 13      /* 8 KB */
 
 
 /*
@@ -127,9 +164,8 @@
 	(isblack(p) && iswhite(o)) ? \
 	luaC_barrier_(L,obj2gco(p),obj2gco(o)) : cast_void(0))
 
-#define luaC_upvalbarrier(L,uv) ( \
-	(iscollectable((uv)->v) && !upisopen(uv)) ? \
-         luaC_upvalbarrier_(L,uv) : cast_void(0))
+#define luaC_protobarrier(L,p,o) \
+	(isblack(p) ? luaC_protobarrier_(L,p) : cast_void(0))
 
 LUAI_FUNC void luaC_fix (lua_State *L, GCObject *o);
 LUAI_FUNC void luaC_freeallobjects (lua_State *L);
@@ -138,10 +174,10 @@ LUAI_FUNC void luaC_runtilstate (lua_State *L, int statesmask);
 LUAI_FUNC void luaC_fullgc (lua_State *L, int isemergency);
 LUAI_FUNC GCObject *luaC_newobj (lua_State *L, int tt, size_t sz);
 LUAI_FUNC void luaC_barrier_ (lua_State *L, GCObject *o, GCObject *v);
-LUAI_FUNC void luaC_barrierback_ (lua_State *L, Table *o);
-LUAI_FUNC void luaC_upvalbarrier_ (lua_State *L, UpVal *uv);
+LUAI_FUNC void luaC_barrierback_ (lua_State *L, GCObject *o);
+LUAI_FUNC void luaC_protobarrier_ (lua_State *L, Proto *p);
 LUAI_FUNC void luaC_checkfinalizer (lua_State *L, GCObject *o, Table *mt);
-LUAI_FUNC void luaC_upvdeccount (lua_State *L, UpVal *uv);
+LUAI_FUNC void luaC_changemode (lua_State *L, int newmode);
 
 
 #endif

linit.c

@@ -1,5 +1,5 @@
 /*
-** $Id: linit.c,v 1.39.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: linit.c,v 1.40 2017/06/27 18:32:49 roberto Exp roberto $
 ** Initialization of libraries for lua.c and other clients
 ** See Copyright Notice in lua.h
 */
@@ -40,7 +40,7 @@
 ** program
 */
 static const luaL_Reg loadedlibs[] = {
-  {"_G", luaopen_base},
+  {LUA_GNAME, luaopen_base},
   {LUA_LOADLIBNAME, luaopen_package},
   {LUA_COLIBNAME, luaopen_coroutine},
   {LUA_TABLIBNAME, luaopen_table},
@@ -50,9 +50,6 @@ static const luaL_Reg loadedlibs[] = {
   {LUA_MATHLIBNAME, luaopen_math},
   {LUA_UTF8LIBNAME, luaopen_utf8},
   {LUA_DBLIBNAME, luaopen_debug},
-#if defined(LUA_COMPAT_BITLIB)
-  {LUA_BITLIBNAME, luaopen_bit32},
-#endif
   {NULL, NULL}
 };
 

liolib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: liolib.c,v 2.151.1.1 2017/04/19 17:29:57 roberto Exp $
+** $Id: liolib.c,v 2.155 2018/02/21 13:48:44 roberto Exp roberto $
 ** Standard I/O (and system) library
 ** See Copyright Notice in lua.h
 */
@@ -186,7 +186,7 @@ static FILE *tofile (lua_State *L) {
 ** handle is in a consistent state.
 */
 static LStream *newprefile (lua_State *L) {
-  LStream *p = (LStream *)lua_newuserdata(L, sizeof(LStream));
+  LStream *p = (LStream *)lua_newuserdatauv(L, sizeof(LStream), 0);
   p->closef = NULL;  /* mark file handle as 'closed' */
   luaL_setmetatable(L, LUA_FILEHANDLE);
   return p;
@@ -277,8 +277,6 @@ static int io_popen (lua_State *L) {
   const char *filename = luaL_checkstring(L, 1);
   const char *mode = luaL_optstring(L, 2, "r");
   LStream *p = newprefile(L);
-  luaL_argcheck(L, ((mode[0] == 'r' || mode[0] == 'w') && mode[1] == '\0'),
-                   2, "invalid mode");
   p->f = l_popen(L, filename, mode);
   p->closef = &io_pclose;
   return (p->f == NULL) ? luaL_fileresult(L, 0, filename) : 1;
@@ -449,7 +447,7 @@ static int read_number (lua_State *L, FILE *f) {
   decp[1] = '.';  /* always accept a dot */
   l_lockfile(rn.f);
   do { rn.c = l_getc(rn.f); } while (isspace(rn.c));  /* skip spaces */
-  test2(&rn, "-+");  /* optional signal */
+  test2(&rn, "-+");  /* optional sign */
   if (test2(&rn, "00")) {
     if (test2(&rn, "xX")) hex = 1;  /* numeral is hexadecimal */
     else count = 1;  /* count initial '0' as a valid digit */
@@ -458,7 +456,7 @@ static int read_number (lua_State *L, FILE *f) {
   if (test2(&rn, decp))  /* decimal point? */
     count += readdigits(&rn, hex);  /* fractional part */
   if (count > 0 && test2(&rn, (hex ? "pP" : "eE"))) {  /* exponent mark? */
-    test2(&rn, "-+");  /* exponent signal */
+    test2(&rn, "-+");  /* exponent sign */
     readdigits(&rn, 0);  /* exponent digits */
   }
   ungetc(rn.c, rn.f);  /* unread look-ahead char */
@@ -530,14 +528,14 @@ static int read_chars (lua_State *L, FILE *f, size_t n) {
 
 static int g_read (lua_State *L, FILE *f, int first) {
   int nargs = lua_gettop(L) - 1;
-  int success;
-  int n;
+  int n, success;
   clearerr(f);
   if (nargs == 0) {  /* no arguments? */
     success = read_line(L, f, 1);
-    n = first+1;  /* to return 1 result */
+    n = first + 1;  /* to return 1 result */
   }
-  else {  /* ensure stack space for all results and for auxlib's buffer */
+  else {
+    /* ensure stack space for all results and for auxlib's buffer */
     luaL_checkstack(L, nargs+LUA_MINSTACK, "too many arguments");
     success = 1;
     for (n = first; nargs-- && success; n++) {

ljumptab.h

@@ -0,0 +1,99 @@
+#undef vmdispatch
+#undef vmcase
+#undef vmbreak
+
+#define vmdispatch(x)     goto *disptab[x];
+
+#define vmcase(l)     L_##l:
+
+#define vmbreak		vmfetch(); vmdispatch(GET_OPCODE(i));
+
+
+static void *disptab[] = {
+
+#if 0
+** you can update the following list with this command:
+**
+**  sed -n '/^OP_/\!d; s/OP_/\&\&L_OP_/ ; s/,.*/,/ ; s/\/.*// ; p'  lopcodes.h
+**
+#endif
+
+&&L_OP_MOVE,
+&&L_OP_LOADI,
+&&L_OP_LOADF,
+&&L_OP_LOADK,
+&&L_OP_LOADKX,
+&&L_OP_LOADBOOL,
+&&L_OP_LOADNIL,
+&&L_OP_GETUPVAL,
+&&L_OP_SETUPVAL,
+&&L_OP_GETTABUP,
+&&L_OP_GETTABLE,
+&&L_OP_GETI,
+&&L_OP_GETFIELD,
+&&L_OP_SETTABUP,
+&&L_OP_SETTABLE,
+&&L_OP_SETI,
+&&L_OP_SETFIELD,
+&&L_OP_NEWTABLE,
+&&L_OP_SELF,
+&&L_OP_ADDI,
+&&L_OP_SUBI,
+&&L_OP_MULI,
+&&L_OP_MODI,
+&&L_OP_POWI,
+&&L_OP_DIVI,
+&&L_OP_IDIVI,
+&&L_OP_BANDK,
+&&L_OP_BORK,
+&&L_OP_BXORK,
+&&L_OP_SHRI,
+&&L_OP_SHLI,
+&&L_OP_ADD,
+&&L_OP_SUB,
+&&L_OP_MUL,
+&&L_OP_MOD,
+&&L_OP_POW,
+&&L_OP_DIV,
+&&L_OP_IDIV,
+&&L_OP_BAND,
+&&L_OP_BOR,
+&&L_OP_BXOR,
+&&L_OP_SHL,
+&&L_OP_SHR,
+&&L_OP_UNM,
+&&L_OP_BNOT,
+&&L_OP_NOT,
+&&L_OP_LEN,
+&&L_OP_CONCAT,
+&&L_OP_CLOSE,
+&&L_OP_JMP,
+&&L_OP_EQ,
+&&L_OP_LT,
+&&L_OP_LE,
+&&L_OP_EQK,
+&&L_OP_EQI,
+&&L_OP_LTI,
+&&L_OP_LEI,
+&&L_OP_GTI,
+&&L_OP_GEI,
+&&L_OP_TEST,
+&&L_OP_TESTSET,
+&&L_OP_CALL,
+&&L_OP_TAILCALL,
+&&L_OP_RETURN,
+&&L_OP_RETURN0,
+&&L_OP_RETURN1,
+&&L_OP_FORLOOP1,
+&&L_OP_FORPREP1,
+&&L_OP_FORLOOP,
+&&L_OP_FORPREP,
+&&L_OP_TFORCALL,
+&&L_OP_TFORLOOP,
+&&L_OP_SETLIST,
+&&L_OP_CLOSURE,
+&&L_OP_VARARG,
+&&L_OP_PREPVARARG,
+&&L_OP_EXTRAARG
+
+};

llex.c

@@ -1,5 +1,5 @@
 /*
-** $Id: llex.c,v 2.96.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: llex.c,v 2.101 2018/03/07 15:55:38 roberto Exp roberto $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
@@ -63,7 +63,7 @@ static void save (LexState *ls, int c) {
     newsize = luaZ_sizebuffer(b) * 2;
     luaZ_resizebuffer(ls->L, b, newsize);
   }
-  b->buffer[luaZ_bufflen(b)++] = cast(char, c);
+  b->buffer[luaZ_bufflen(b)++] = cast_char(c);
 }
 
 
@@ -129,15 +129,15 @@ TString *luaX_newstring (LexState *ls, const char *str, size_t l) {
   TValue *o;  /* entry for 'str' */
   TString *ts = luaS_newlstr(L, str, l);  /* create new string */
   setsvalue2s(L, L->top++, ts);  /* temporarily anchor it in stack */
-  o = luaH_set(L, ls->h, L->top - 1);
-  if (ttisnil(o)) {  /* not in use yet? */
+  o = luaH_set(L, ls->h, s2v(L->top - 1));
+  if (isempty(o)) {  /* not in use yet? */
     /* boolean value does not need GC barrier;
-       table has no metatable, so it does not need to invalidate cache */
+       table is not a metatable, so it does not need to invalidate cache */
     setbvalue(o, 1);  /* t[string] = true */
     luaC_checkGC(L);
   }
   else {  /* string already present */
-    ts = tsvalue(keyfromval(o));  /* re-use value previously stored */
+    ts = keystrval(nodefromval(o));  /* re-use value previously stored */
   }
   L->top--;  /* remove string from stack */
   return ts;
@@ -244,12 +244,12 @@ static int read_numeral (LexState *ls, SemInfo *seminfo) {
 
 
 /*
-** reads a sequence '[=*[' or ']=*]', leaving the last bracket.
-** If sequence is well formed, return its number of '='s + 2; otherwise,
-** return 1 if there is no '='s or 0 otherwise (an unfinished '[==...').
+** skip a sequence '[=*[' or ']=*]'; if sequence is well formed, return
+** its number of '='s; otherwise, return a negative number (-1 iff there
+** are no '='s after initial bracket)
 */
-static size_t skip_sep (LexState *ls) {
-  size_t count = 0;
+static int skip_sep (LexState *ls) {
+  int count = 0;
   int s = ls->current;
   lua_assert(s == '[' || s == ']');
   save_and_next(ls);
@@ -257,14 +257,11 @@ static size_t skip_sep (LexState *ls) {
     save_and_next(ls);
     count++;
   }
-  return (ls->current == s) ? count + 2
-         : (count == 0) ? 1
-         : 0;
-
+  return (ls->current == s) ? count : (-count) - 1;
 }
 
 
-static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) {
+static void read_long_string (LexState *ls, SemInfo *seminfo, int sep) {
   int line = ls->linenumber;  /* initial line (for error message) */
   save_and_next(ls);  /* skip 2nd '[' */
   if (currIsNewline(ls))  /* string starts with a newline? */
@@ -298,8 +295,8 @@ static void read_long_string (LexState *ls, SemInfo *seminfo, size_t sep) {
     }
   } endloop:
   if (seminfo)
-    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + sep,
-                                     luaZ_bufflen(ls->buff) - 2 * sep);
+    seminfo->ts = luaX_newstring(ls, luaZ_buffer(ls->buff) + (2 + sep),
+                                     luaZ_bufflen(ls->buff) - 2*(2 + sep));
 }
 
 
@@ -447,9 +444,9 @@ static int llex (LexState *ls, SemInfo *seminfo) {
         /* else is a comment */
         next(ls);
         if (ls->current == '[') {  /* long comment? */
-          size_t sep = skip_sep(ls);
+          int sep = skip_sep(ls);
           luaZ_resetbuffer(ls->buff);  /* 'skip_sep' may dirty the buffer */
-          if (sep >= 2) {
+          if (sep >= 0) {
             read_long_string(ls, NULL, sep);  /* skip long comment */
             luaZ_resetbuffer(ls->buff);  /* previous call may dirty the buff. */
             break;
@@ -461,12 +458,12 @@ static int llex (LexState *ls, SemInfo *seminfo) {
         break;
       }
       case '[': {  /* long string or simply '[' */
-        size_t sep = skip_sep(ls);
-        if (sep >= 2) {
+        int sep = skip_sep(ls);
+        if (sep >= 0) {
           read_long_string(ls, seminfo, sep);
           return TK_STRING;
         }
-        else if (sep == 0)  /* '[=...' missing second bracket */
+        else if (sep != -1)  /* '[=...' missing second bracket */
           lexerror(ls, "invalid long string delimiter", TK_STRING);
         return '[';
       }

llex.h

@@ -1,5 +1,5 @@
 /*
-** $Id: llex.h,v 1.79.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: llex.h,v 1.81 2018/03/07 15:55:38 roberto Exp roberto $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
@@ -37,7 +37,7 @@ enum RESERVED {
 };
 
 /* number of reserved words */
-#define NUM_RESERVED	(cast(int, TK_WHILE-FIRST_RESERVED+1))
+#define NUM_RESERVED	(cast_int(TK_WHILE-FIRST_RESERVED + 1))
 
 
 typedef union {

llimits.h

@@ -1,5 +1,5 @@
 /*
-** $Id: llimits.h,v 1.141.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: llimits.h,v 1.150 2018/05/30 14:25:52 roberto Exp roberto $
 ** Limits, basic types, and some other 'installation-dependent' definitions
 ** See Copyright Notice in lua.h
 */
@@ -33,6 +33,7 @@ typedef long l_mem;
 
 /* chars used as small naturals (so that 'char' is reserved for characters) */
 typedef unsigned char lu_byte;
+typedef signed char ls_byte;
 
 
 /* maximum value for size_t */
@@ -51,6 +52,19 @@ typedef unsigned char lu_byte;
 #define MAX_INT		INT_MAX  /* maximum value of an int */
 
 
+/*
+** floor of the log2 of the maximum signed value for integral type 't'.
+** (That is, maximum 'n' such that '2^n' fits in the given signed type.)
+*/
+#define log2maxs(t)	(sizeof(t) * 8 - 2)
+
+
+/*
+** test whether an unsigned value is a power of 2 (or zero)
+*/
+#define ispow2(x)	(((x) & ((x) - 1)) == 0)
+
+
 /*
 ** conversion of pointer to unsigned integer:
 ** this is for hashing only; there is no problem if the integer
@@ -60,21 +74,6 @@ typedef unsigned char lu_byte;
 
 
 
-/* type to ensure maximum alignment */
-#if defined(LUAI_USER_ALIGNMENT_T)
-typedef LUAI_USER_ALIGNMENT_T L_Umaxalign;
-#else
-typedef union {
-  lua_Number n;
-  double u;
-  void *s;
-  lua_Integer i;
-  long l;
-} L_Umaxalign;
-#endif
-
-
-
 /* types of 'usual argument conversions' for lua_Number and lua_Integer */
 typedef LUAI_UACNUMBER l_uacNumber;
 typedef LUAI_UACINT l_uacInt;
@@ -111,10 +110,15 @@ typedef LUAI_UACINT l_uacInt;
 #define cast(t, exp)	((t)(exp))
 
 #define cast_void(i)	cast(void, (i))
-#define cast_byte(i)	cast(lu_byte, (i))
+#define cast_voidp(i)	cast(void *, (i))
 #define cast_num(i)	cast(lua_Number, (i))
 #define cast_int(i)	cast(int, (i))
+#define cast_uint(i)	cast(unsigned int, (i))
+#define cast_byte(i)	cast(lu_byte, (i))
 #define cast_uchar(i)	cast(unsigned char, (i))
+#define cast_char(i)	cast(char, (i))
+#define cast_charp(i)	cast(char *, (i))
+#define cast_sizet(i)	cast(size_t, (i))
 
 
 /* cast a signed lua_Integer to lua_Unsigned */
@@ -132,9 +136,27 @@ typedef LUAI_UACINT l_uacInt;
 #endif
 
 
+/*
+** macros to improve jump prediction (used mainly for error handling)
+*/
+#if !defined(likely)
+
+#if defined(__GNUC__)
+#define likely(x)	(__builtin_expect(((x) != 0), 1))
+#define unlikely(x)	(__builtin_expect(((x) != 0), 0))
+#else
+#define likely(x)	(x)
+#define unlikely(x)	(x)
+#endif
+
+#endif
+
+
 /*
 ** non-return type
 */
+#if !defined(l_noret)
+
 #if defined(__GNUC__)
 #define l_noret		void __attribute__((noreturn))
 #elif defined(_MSC_VER) && _MSC_VER >= 1200
@@ -143,14 +165,16 @@ typedef LUAI_UACINT l_uacInt;
 #define l_noret		void
 #endif
 
+#endif
 
 
 /*
 ** maximum depth for nested C calls and syntactical nested non-terminals
-** in a program. (Value must fit in an unsigned short int.)
+** in a program. (Value must fit in an unsigned short int. It must also
+** be compatible with the size of the C stack.)
 */
 #if !defined(LUAI_MAXCCALLS)
-#define LUAI_MAXCCALLS		200
+#define LUAI_MAXCCALLS		2200
 #endif
 
 
@@ -225,8 +249,7 @@ typedef unsigned long Instruction;
 
 
 /*
-** these macros allow user-specific actions on threads when you defined
-** LUAI_EXTRASPACE and need to do something extra when a thread is
+** these macros allow user-specific actions when a thread is
 ** created/deleted/resumed/yielded.
 */
 #if !defined(luai_userstateopen)
@@ -310,7 +333,7 @@ typedef unsigned long Instruction;
 #else
 /* realloc stack keeping its size */
 #define condmovestack(L,pre,pos)  \
-	{ int sz_ = (L)->stacksize; pre; luaD_reallocstack((L), sz_); pos; }
+  { int sz_ = (L)->stacksize; pre; luaD_reallocstack((L), sz_, 0); pos; }
 #endif
 
 #if !defined(HARDMEMTESTS)

lmathlib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lmathlib.c,v 1.119.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lmathlib.c,v 1.134 2018/05/16 11:27:59 roberto Exp roberto $
 ** Standard mathematical library
 ** See Copyright Notice in lua.h
 */
@@ -10,8 +10,11 @@
 #include "lprefix.h"
 
 
-#include <stdlib.h>
+#include <float.h>
+#include <limits.h>
 #include <math.h>
+#include <stdlib.h>
+#include <time.h>
 
 #include "lua.h"
 
@@ -23,19 +26,6 @@
 #define PI	(l_mathop(3.141592653589793238462643383279502884))
 
 
-#if !defined(l_rand)		/* { */
-#if defined(LUA_USE_POSIX)
-#define l_rand()	random()
-#define l_srand(x)	srandom(x)
-#define L_RANDMAX	2147483647	/* (2^31 - 1), following POSIX */
-#else
-#define l_rand()	rand()
-#define l_srand(x)	srand(x)
-#define L_RANDMAX	RAND_MAX
-#endif
-#endif				/* } */
-
-
 static int math_abs (lua_State *L) {
   if (lua_isinteger(L, 1)) {
     lua_Integer n = lua_tointeger(L, 1);
@@ -239,22 +229,327 @@ static int math_max (lua_State *L) {
   return 1;
 }
 
+
+static int math_type (lua_State *L) {
+  if (lua_type(L, 1) == LUA_TNUMBER)
+    lua_pushstring(L, (lua_isinteger(L, 1)) ? "integer" : "float");
+  else {
+    luaL_checkany(L, 1);
+    lua_pushnil(L);
+  }
+  return 1;
+}
+
+
+
 /*
-** This function uses 'double' (instead of 'lua_Number') to ensure that
-** all bits from 'l_rand' can be represented, and that 'RANDMAX + 1.0'
-** will keep full precision (ensuring that 'r' is always less than 1.0.)
+** {==================================================================
+** Pseudo-Random Number Generator based on 'xoshiro256**'.
+** ===================================================================
 */
+
+/* number of binary digits in the mantissa of a float */
+#define FIGS	l_mathlim(MANT_DIG)
+
+#if FIGS > 64
+/* there are only 64 random bits; use them all */
+#undef FIGS
+#define FIGS	64
+#endif
+
+
+/*
+** LUA_RAND32 forces the use of 32-bit integers in the implementation
+** of the PRN generator (mainly for testing).
+*/
+#if !defined(LUA_RAND32) && !defined(Rand64)
+
+/* try to find an integer type with at least 64 bits */
+
+#if (LONG_MAX >> 31 >> 31) >= 1
+
+/* 'long' has at least 64 bits */
+#define Rand64		unsigned long
+
+#elif !defined(LUA_USE_C89) && defined(LLONG_MAX)
+
+/* there is a 'long long' type (which must have at least 64 bits) */
+#define Rand64		unsigned long long
+
+#elif (LUA_MAXINTEGER >> 31 >> 31) >= 1
+
+/* 'lua_Integer' has at least 64 bits */
+#define Rand64		lua_Unsigned
+
+#endif
+
+#endif
+
+
+#if defined(Rand64)  /* { */
+
+/*
+** Standard implementation, using 64-bit integers.
+** If 'Rand64' has more than 64 bits, the extra bits do not interfere
+** with the 64 initial bits, except in a right shift. Moreover, the
+** final result has to discard the extra bits.
+*/
+
+/* avoid using extra bits when needed */
+#define trim64(x)	((x) & 0xffffffffffffffffu)
+
+
+/* rotate left 'x' by 'n' bits */
+static Rand64 rotl (Rand64 x, int n) {
+  return (x << n) | (trim64(x) >> (64 - n)); 
+}
+
+static Rand64 nextrand (Rand64 *state) {
+  Rand64 state0 = state[0];
+  Rand64 state1 = state[1];
+  Rand64 state2 = state[2] ^ state0;
+  Rand64 state3 = state[3] ^ state1;
+  Rand64 res = rotl(state1 * 5, 7) * 9;
+  state[0] = state0 ^ state3;
+  state[1] = state1 ^ state2;
+  state[2] = state2 ^ (state1 << 17);
+  state[3] = rotl(state3, 45);
+  return res;
+}
+
+
+/* must take care to not shift stuff by more than 63 slots */
+
+
+/*
+** Convert bits from a random integer into a float in the
+** interval [0,1).
+*/
+#define maskFIG		(~(~(Rand64)1 << (FIGS - 1)))  /* use FIGS bits */
+#define shiftFIG  \
+	(l_mathop(0.5) / ((Rand64)1 << (FIGS - 1)))  /* 2^(-FIGS) */
+
+static lua_Number I2d (Rand64 x) {
+  return (lua_Number)(x & maskFIG) * shiftFIG;
+}
+
+/* convert a 'Rand64' to a 'lua_Unsigned' */
+#define I2UInt(x)	((lua_Unsigned)trim64(x))
+
+/* convert a 'lua_Unsigned' to a 'Rand64' */
+#define Int2I(x)	((Rand64)(x))
+
+
+#else	/* no 'Rand64'   }{ */
+
+/* get an integer with at least 32 bits */
+#if (INT_MAX >> 30) >= 1
+typedef unsigned int lu_int32;
+#else
+typedef unsigned long lu_int32;
+#endif
+
+
+/*
+** Use two 32-bit integers to represent a 64-bit quantity.
+*/
+typedef struct Rand64 {
+  lu_int32 h;  /* higher half */
+  lu_int32 l;  /* lower half */
+} Rand64;
+
+
+/*
+** If 'lu_int32' has more than 32 bits, the extra bits do not interfere
+** with the 32 initial bits, except in a right shift and comparisons.
+** Moreover, the final result has to discard the extra bits.
+*/
+
+/* avoid using extra bits when needed */
+#define trim32(x)	((x) & 0xffffffffu)
+
+
+/*
+** basic operations on 'Rand64' values
+*/
+
+/* build a new Rand64 value */
+static Rand64 packI (lu_int32 h, lu_int32 l) {
+  Rand64 result;
+  result.h = h;
+  result.l = l;
+  return result;
+}
+
+/* return i << n */
+static Rand64 Ishl (Rand64 i, int n) {
+  lua_assert(n > 0 && n < 32);
+  return packI((i.h << n) | (trim32(i.l) >> (32 - n)), i.l << n);
+}
+
+/* i1 ^= i2 */
+static void Ixor (Rand64 *i1, Rand64 i2) {
+  i1->h ^= i2.h;
+  i1->l ^= i2.l;
+}
+
+/* return i1 + i2 */
+static Rand64 Iadd (Rand64 i1, Rand64 i2) {
+  Rand64 result = packI(i1.h + i2.h, i1.l + i2.l);
+  if (trim32(result.l) < trim32(i1.l))  /* carry? */
+    result.h++;
+  return result;
+}
+
+/* return i * 5 */
+static Rand64 times5 (Rand64 i) {
+  return Iadd(Ishl(i, 2), i);  /* i * 5 == (i << 2) + i */
+}
+
+/* return i * 9 */
+static Rand64 times9 (Rand64 i) {
+  return Iadd(Ishl(i, 3), i);  /* i * 9 == (i << 3) + i */
+}
+
+/* return 'i' rotated left 'n' bits */
+static Rand64 rotl (Rand64 i, int n) {
+  lua_assert(n > 0 && n < 32);
+  return packI((i.h << n) | (trim32(i.l) >> (32 - n)),
+               (trim32(i.h) >> (32 - n)) | (i.l << n));
+}
+
+/* for offsets larger than 32, rotate right by 64 - offset */
+static Rand64 rotl1 (Rand64 i, int n) {
+  lua_assert(n > 32 && n < 64);
+  n = 64 - n;
+  return packI((trim32(i.h) >> n) | (i.l << (32 - n)),
+               (i.h << (32 - n)) | (trim32(i.l) >> n));
+}
+
+/*
+** implementation of 'xoshiro256**' algorithm on 'Rand64' values
+*/
+static Rand64 nextrand (Rand64 *state) {
+  Rand64 res = times9(rotl(times5(state[1]), 7));
+  Rand64 t = Ishl(state[1], 17);
+  Ixor(&state[2], state[0]);
+  Ixor(&state[3], state[1]);
+  Ixor(&state[1], state[2]);
+  Ixor(&state[0], state[3]);
+  Ixor(&state[2], t);
+  state[3] = rotl1(state[3], 45);
+  return res;
+}
+
+
+/*
+** Converts a 'Rand64' into a float.
+*/
+
+/* an unsigned 1 with proper type */
+#define UONE		((lu_int32)1)
+
+#if FIGS <= 32
+
+#define maskHI		0  /* do not need bits from higher half */
+#define maskLOW		(~(~UONE << (FIGS - 1)))  /* use FIGS bits */
+#define shiftFIG	(l_mathop(0.5) / (UONE << (FIGS - 1)))  /* 2^(-FIGS) */
+
+#else	/* 32 < FIGS <= 64 */
+
+/* must take care to not shift stuff by more than 31 slots */
+
+/* use FIGS - 32 bits from higher half */
+#define maskHI		(~(~UONE << (FIGS - 33)))
+
+/* use 32 bits from lower half */
+#define maskLOW		(~(~UONE << 31))
+
+/* 2^(-FIGS) == (1 / 2^33) / 2^(FIGS-33) */
+#define shiftFIG  ((lua_Number)(1.0 / 8589934592.0) / (UONE << (FIGS - 33)))
+
+#endif
+
+#define twoto32		l_mathop(4294967296.0)  /* 2^32 */
+
+static lua_Number I2d (Rand64 x) {
+  lua_Number h = (lua_Number)(x.h & maskHI);
+  lua_Number l = (lua_Number)(x.l & maskLOW);
+  return (h * twoto32 + l) * shiftFIG;
+}
+
+
+/* convert a 'Rand64' to a 'lua_Unsigned' */
+static lua_Unsigned I2UInt (Rand64 x) {
+  return ((lua_Unsigned)trim32(x.h) << 31 << 1) | (lua_Unsigned)trim32(x.l);
+}
+
+/* convert a 'lua_Unsigned' to a 'Rand64' */
+static Rand64 Int2I (lua_Unsigned n) {
+  return packI((lu_int32)(n >> 31 >> 1), (lu_int32)n);
+}
+
+#endif  /* } */
+
+
+/*
+** A state uses four 'Rand64' values.
+*/
+typedef struct {
+  Rand64 s[4];
+} RanState;
+
+
+/*
+** Project the random integer 'ran' into the interval [0, n].
+** Because 'ran' has 2^B possible values, the projection can only be
+** uniform when the size of the interval is a power of 2 (exact
+** division).  To get a uniform projection into [0, n], we first compute
+** 'lim', the smallest Mersenne number not smaller than 'n'. We then
+** project 'ran' into the interval [0, lim].  If the result is inside
+** [0, n], we are done. Otherwise, we try with another 'ran', until we
+** have a result inside the interval.
+*/
+static lua_Unsigned project (lua_Unsigned ran, lua_Unsigned n,
+                             RanState *state) {
+  lua_Unsigned lim = n;
+  if ((lim & (lim + 1)) > 0) {  /* 'lim + 1' is not a power of 2? */
+    /* compute the smallest (2^b - 1) not smaller than 'n' */
+    lim |= (lim >> 1);
+    lim |= (lim >> 2);
+    lim |= (lim >> 4);
+    lim |= (lim >> 8);
+    lim |= (lim >> 16);
+#if (LUA_MAXINTEGER >> 30 >> 1) > 0
+    lim |= (lim >> 32);  /* integer type has more than 32 bits */
+#endif
+  }
+  lua_assert((lim & (lim + 1)) == 0  /* 'lim + 1' is a power of 2, */
+    && lim >= n  /* not smaller than 'n', */
+    && (lim == 0 || (lim >> 1) < n));  /* and it is the smallest one */
+  while ((ran &= lim) > n)  /* project 'ran' into [0..lim] */
+    ran = I2UInt(nextrand(state->s));  /* not inside [0..n]? try again */
+  return ran;
+}
+
+
 static int math_random (lua_State *L) {
   lua_Integer low, up;
-  double r = (double)l_rand() * (1.0 / ((double)L_RANDMAX + 1.0));
+  lua_Unsigned p;
+  RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1));
+  Rand64 rv = nextrand(state->s);  /* next pseudo-random value */
   switch (lua_gettop(L)) {  /* check number of arguments */
     case 0: {  /* no arguments */
-      lua_pushnumber(L, (lua_Number)r);  /* Number between 0 and 1 */
+      lua_pushnumber(L, I2d(rv));  /* float between 0 and 1 */
       return 1;
     }
     case 1: {  /* only upper limit */
       low = 1;
       up = luaL_checkinteger(L, 1);
+      if (up == 0) {  /* single 0 as argument? */
+        lua_pushinteger(L, I2UInt(rv));  /* full random integer */
+        return 1;
+      }
       break;
     }
     case 2: {  /* lower and upper limits */
@@ -266,35 +561,56 @@ static int math_random (lua_State *L) {
   }
   /* random integer in the interval [low, up] */
   luaL_argcheck(L, low <= up, 1, "interval is empty");
-  luaL_argcheck(L, low >= 0 || up <= LUA_MAXINTEGER + low, 1,
-                   "interval too large");
-  r *= (double)(up - low) + 1.0;
-  lua_pushinteger(L, (lua_Integer)r + low);
+  /* project random integer into the interval [0, up - low] */
+  p = project(I2UInt(rv), (lua_Unsigned)up - (lua_Unsigned)low, state);
+  lua_pushinteger(L, p + (lua_Unsigned)low);
   return 1;
 }
 
 
+static void setseed (Rand64 *state, lua_Unsigned n1, lua_Unsigned n2) {
+  int i;
+  state[0] = Int2I(n1);
+  state[1] = Int2I(0xff);  /* avoid a zero state */
+  state[2] = Int2I(n2);
+  state[3] = Int2I(0);
+  for (i = 0; i < 16; i++)
+    nextrand(state);  /* discard initial values to "spread" seed */
+}
+
+
 static int math_randomseed (lua_State *L) {
-  l_srand((unsigned int)(lua_Integer)luaL_checknumber(L, 1));
-  (void)l_rand(); /* discard first value to avoid undesirable correlations */
+  RanState *state = (RanState *)lua_touserdata(L, lua_upvalueindex(1));
+  lua_Integer n1 = luaL_checkinteger(L, 1);
+  lua_Integer n2 = luaL_optinteger(L, 2, 0);
+  setseed(state->s, n1, n2);
   return 0;
 }
 
 
-static int math_type (lua_State *L) {
-  if (lua_type(L, 1) == LUA_TNUMBER) {
-      if (lua_isinteger(L, 1))
-        lua_pushliteral(L, "integer");
-      else
-        lua_pushliteral(L, "float");
-  }
-  else {
-    luaL_checkany(L, 1);
-    lua_pushnil(L);
-  }
-  return 1;
+static const luaL_Reg randfuncs[] = {
+  {"random", math_random},
+  {"randomseed", math_randomseed},
+  {NULL, NULL}
+};
+
+
+/*
+** Register the random functions and initialize their state.
+** To give some "randomness" to the initial seed, use the current time
+** and the address of 'L' (in case the machine does address space layout
+** randomization).
+*/
+static void setrandfunc (lua_State *L) {
+  RanState *state = (RanState *)lua_newuserdatauv(L, sizeof(RanState), 0);
+  lua_Unsigned seed1 = (lua_Unsigned)time(NULL); 
+  lua_Unsigned seed2 = (lua_Unsigned)(size_t)L; 
+  setseed(state->s, seed1, seed2);
+  luaL_setfuncs(L, randfuncs, 1);
 }
 
+/* }================================================================== */
+
 
 /*
 ** {==================================================================
@@ -367,8 +683,6 @@ static const luaL_Reg mathlib[] = {
   {"min",   math_min},
   {"modf",   math_modf},
   {"rad",   math_rad},
-  {"random",     math_random},
-  {"randomseed", math_randomseed},
   {"sin",   math_sin},
   {"sqrt",  math_sqrt},
   {"tan",   math_tan},
@@ -384,6 +698,8 @@ static const luaL_Reg mathlib[] = {
   {"log10", math_log10},
 #endif
   /* placeholders */
+  {"random", NULL},
+  {"randomseed", NULL},
   {"pi", NULL},
   {"huge", NULL},
   {"maxinteger", NULL},
@@ -405,6 +721,7 @@ LUAMOD_API int luaopen_math (lua_State *L) {
   lua_setfield(L, -2, "maxinteger");
   lua_pushinteger(L, LUA_MININTEGER);
   lua_setfield(L, -2, "mininteger");
+  setrandfunc(L);
   return 1;
 }
 

lmem.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lmem.c,v 1.91.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lmem.c,v 1.97 2018/05/30 14:25:52 roberto Exp roberto $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
@@ -22,6 +22,14 @@
 #include "lstate.h"
 
 
+#if defined(HARDMEMTESTS)
+#define hardtest(L,os,s)  /* force a GC whenever possible */ \
+  if ((s) > (os) && (G(L))->gcrunning) luaC_fullgc(L, 1);
+#else
+#define hardtest(L,os,s)  ((void)0)
+#endif
+
+
 
 /*
 ** About the realloc function:
@@ -45,31 +53,83 @@
 #define MINSIZEARRAY	4
 
 
-void *luaM_growaux_ (lua_State *L, void *block, int *size, size_t size_elems,
-                     int limit, const char *what) {
+void *luaM_growaux_ (lua_State *L, void *block, int nelems, int *psize,
+                     int size_elems, int limit, const char *what) {
   void *newblock;
-  int newsize;
-  if (*size >= limit/2) {  /* cannot double it? */
-    if (*size >= limit)  /* cannot grow even a little? */
+  int size = *psize;
+  if (nelems + 1 <= size)  /* does one extra element still fit? */
+    return block;  /* nothing to be done */
+  if (size >= limit / 2) {  /* cannot double it? */
+    if (unlikely(size >= limit))  /* cannot grow even a little? */
       luaG_runerror(L, "too many %s (limit is %d)", what, limit);
-    newsize = limit;  /* still have at least one free place */
+    size = limit;  /* still have at least one free place */
   }
   else {
-    newsize = (*size)*2;
-    if (newsize < MINSIZEARRAY)
-      newsize = MINSIZEARRAY;  /* minimum size */
+    size *= 2;
+    if (size < MINSIZEARRAY)
+      size = MINSIZEARRAY;  /* minimum size */
   }
-  newblock = luaM_reallocv(L, block, *size, newsize, size_elems);
-  *size = newsize;  /* update only when everything else is OK */
+  lua_assert(nelems + 1 <= size && size <= limit);
+  /* 'limit' ensures that multiplication will not overflow */
+  newblock = luaM_realloc_(L, block, cast_sizet(*psize) * size_elems,
+                                     cast_sizet(size) * size_elems);
+  if (unlikely(newblock == NULL))
+    luaM_error(L);
+  *psize = size;  /* update only when everything else is OK */
   return newblock;
 }
 
 
+void *luaM_shrinkvector_ (lua_State *L, void *block, int *size,
+                          int final_n, int size_elem) {
+  global_State *g = G(L);
+  void *newblock;
+  size_t oldsize = cast_sizet((*size) * size_elem);
+  size_t newsize = cast_sizet(final_n * size_elem);
+  lua_assert(newsize <= oldsize);
+  newblock = (*g->frealloc)(g->ud, block, oldsize, newsize);
+  if (unlikely(newblock == NULL && final_n > 0))  /* allocation failed? */
+    luaM_error(L);
+  else {
+    g->GCdebt += newsize - oldsize;
+    *size = final_n;
+    return newblock;
+  }
+}
+
+
 l_noret luaM_toobig (lua_State *L) {
   luaG_runerror(L, "memory allocation error: block too big");
 }
 
 
+/*
+** Free memory
+*/
+void luaM_free_ (lua_State *L, void *block, size_t osize) {
+  global_State *g = G(L);
+  lua_assert((block == 0) == (block == NULL));
+  (*g->frealloc)(g->ud, block, osize, 0);
+  g->GCdebt -= osize;
+}
+
+
+/*
+** In case of allocation fail, this function will call the GC to try
+** to free some memory and then try the allocation again.
+** (It should not be called when shrinking a block, because then the
+** interpreter may be in the middle of a collection step.)
+*/
+static void *tryagain (lua_State *L, void *block,
+                       size_t osize, size_t nsize) {
+  global_State *g = G(L);
+  if (ttisnil(&g->nilvalue)) {  /* is state fully build? */
+    luaC_fullgc(L, 1);  /* try to free some memory... */
+    return (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
+  }
+  else return NULL;  /* cannot free any memory without a full state */
+}
+
 
 /*
 ** generic allocation routine.
@@ -77,24 +137,43 @@ l_noret luaM_toobig (lua_State *L) {
 void *luaM_realloc_ (lua_State *L, void *block, size_t osize, size_t nsize) {
   void *newblock;
   global_State *g = G(L);
-  size_t realosize = (block) ? osize : 0;
-  lua_assert((realosize == 0) == (block == NULL));
-#if defined(HARDMEMTESTS)
-  if (nsize > realosize && g->gcrunning)
-    luaC_fullgc(L, 1);  /* force a GC whenever possible */
-#endif
+  lua_assert((osize == 0) == (block == NULL));
+  hardtest(L, osize, nsize);
   newblock = (*g->frealloc)(g->ud, block, osize, nsize);
-  if (newblock == NULL && nsize > 0) {
-    lua_assert(nsize > realosize);  /* cannot fail when shrinking a block */
-    if (g->version) {  /* is state fully built? */
-      luaC_fullgc(L, 1);  /* try to free some memory... */
-      newblock = (*g->frealloc)(g->ud, block, osize, nsize);  /* try again */
-    }
-    if (newblock == NULL)
-      luaD_throw(L, LUA_ERRMEM);
+  if (unlikely(newblock == NULL && nsize > 0)) {
+    if (nsize > osize)  /* not shrinking a block? */
+      newblock = tryagain(L, block, osize, nsize);
+    if (newblock == NULL)  /* still no memory? */
+      return NULL;
   }
   lua_assert((nsize == 0) == (newblock == NULL));
-  g->GCdebt = (g->GCdebt + nsize) - realosize;
+  g->GCdebt = (g->GCdebt + nsize) - osize;
   return newblock;
 }
 
+
+void *luaM_saferealloc_ (lua_State *L, void *block, size_t osize,
+                                                    size_t nsize) {
+  void *newblock = luaM_realloc_(L, block, osize, nsize);
+  if (unlikely(newblock == NULL && nsize > 0))  /* allocation failed? */
+    luaM_error(L);
+  return newblock;
+}
+
+
+void *luaM_malloc_ (lua_State *L, size_t size, int tag) {
+  hardtest(L, 0, size);
+  if (size == 0)
+    return NULL;  /* that's all */
+  else {
+    global_State *g = G(L);
+    void *newblock = (*g->frealloc)(g->ud, NULL, tag, size);
+    if (unlikely(newblock == NULL)) {
+      newblock = tryagain(L, NULL, tag, size);
+      if (newblock == NULL)
+        luaM_error(L);
+    }
+    g->GCdebt += size;
+    return newblock;
+  }
+}

lmem.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lmem.h,v 1.43.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lmem.h,v 1.46 2017/12/08 17:28:25 roberto Exp roberto $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
@@ -14,12 +14,13 @@
 #include "lua.h"
 
 
+#define luaM_error(L)	luaD_throw(L, LUA_ERRMEM)
+
+
 /*
-** This macro reallocs a vector 'b' from 'on' to 'n' elements, where
-** each element has size 'e'. In case of arithmetic overflow of the
-** product 'n'*'e', it raises an error (calling 'luaM_toobig'). Because
-** 'e' is always constant, it avoids the runtime division MAX_SIZET/(e).
-**
+** This macro tests whether it is safe to multiply 'n' by the size of
+** type 't' without overflows. Because 'e' is always constant, it avoids
+** the runtime division MAX_SIZET/(e).
 ** (The macro is somewhat complex to avoid warnings:  The 'sizeof'
 ** comparison avoids a runtime comparison when overflow cannot occur.
 ** The compiler should be able to optimize the real test by itself, but
@@ -27,43 +28,66 @@
 ** false due to limited range of data type"; the +1 tricks the compiler,
 ** avoiding this warning but also this optimization.)
 */
-#define luaM_reallocv(L,b,on,n,e) \
-  (((sizeof(n) >= sizeof(size_t) && cast(size_t, (n)) + 1 > MAX_SIZET/(e)) \
-      ? luaM_toobig(L) : cast_void(0)) , \
-   luaM_realloc_(L, (b), (on)*(e), (n)*(e)))
+#define luaM_testsize(n,e)  \
+	(sizeof(n) >= sizeof(size_t) && cast_sizet((n)) + 1 > MAX_SIZET/(e))
+
+#define luaM_checksize(L,n,e)  \
+	(luaM_testsize(n,e) ? luaM_toobig(L) : cast_void(0))
+
+
+/*
+** Computes the minimum between 'n' and 'MAX_SIZET/sizeof(t)', so that
+** the result is not larger than 'n' and cannot overflow a 'size_t'
+** when multiplied by the size of type 't'. (Assumes that 'n' is an
+** 'int' or 'unsigned int' and that 'int' is not larger than 'size_t'.)
+*/
+#define luaM_limitN(n,t)  \
+  ((cast_sizet(n) <= MAX_SIZET/sizeof(t)) ? (n) :  \
+     cast_uint((MAX_SIZET/sizeof(t))))
+
 
 /*
 ** Arrays of chars do not need any test
 */
 #define luaM_reallocvchar(L,b,on,n)  \
-    cast(char *, luaM_realloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char)))
+  cast_charp(luaM_saferealloc_(L, (b), (on)*sizeof(char), (n)*sizeof(char)))
 
-#define luaM_freemem(L, b, s)	luaM_realloc_(L, (b), (s), 0)
-#define luaM_free(L, b)		luaM_realloc_(L, (b), sizeof(*(b)), 0)
-#define luaM_freearray(L, b, n)   luaM_realloc_(L, (b), (n)*sizeof(*(b)), 0)
+#define luaM_freemem(L, b, s)	luaM_free_(L, (b), (s))
+#define luaM_free(L, b)		luaM_free_(L, (b), sizeof(*(b)))
+#define luaM_freearray(L, b, n)   luaM_free_(L, (b), (n)*sizeof(*(b)))
 
-#define luaM_malloc(L,s)	luaM_realloc_(L, NULL, 0, (s))
-#define luaM_new(L,t)		cast(t *, luaM_malloc(L, sizeof(t)))
-#define luaM_newvector(L,n,t) \
-		cast(t *, luaM_reallocv(L, NULL, 0, n, sizeof(t)))
+#define luaM_new(L,t)		cast(t*, luaM_malloc_(L, sizeof(t), 0))
+#define luaM_newvector(L,n,t)	cast(t*, luaM_malloc_(L, (n)*sizeof(t), 0))
+#define luaM_newvectorchecked(L,n,t) \
+  (luaM_checksize(L,n,sizeof(t)), luaM_newvector(L,n,t))
 
-#define luaM_newobject(L,tag,s)	luaM_realloc_(L, NULL, tag, (s))
+#define luaM_newobject(L,tag,s)	luaM_malloc_(L, (s), tag)
 
 #define luaM_growvector(L,v,nelems,size,t,limit,e) \
-          if ((nelems)+1 > (size)) \
-            ((v)=cast(t *, luaM_growaux_(L,v,&(size),sizeof(t),limit,e)))
+	((v)=cast(t *, luaM_growaux_(L,v,nelems,&(size),sizeof(t), \
+                         luaM_limitN(limit,t),e)))
 
 #define luaM_reallocvector(L, v,oldn,n,t) \
-   ((v)=cast(t *, luaM_reallocv(L, v, oldn, n, sizeof(t))))
+   (cast(t *, luaM_realloc_(L, v, cast_sizet(oldn) * sizeof(t), \
+                                  cast_sizet(n) * sizeof(t))))
+
+#define luaM_shrinkvector(L,v,size,fs,t) \
+   ((v)=cast(t *, luaM_shrinkvector_(L, v, &(size), fs, sizeof(t))))
 
 LUAI_FUNC l_noret luaM_toobig (lua_State *L);
 
 /* not to be called directly */
 LUAI_FUNC void *luaM_realloc_ (lua_State *L, void *block, size_t oldsize,
                                                           size_t size);
-LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int *size,
-                               size_t size_elem, int limit,
+LUAI_FUNC void *luaM_saferealloc_ (lua_State *L, void *block, size_t oldsize,
+                                                              size_t size);
+LUAI_FUNC void luaM_free_ (lua_State *L, void *block, size_t osize);
+LUAI_FUNC void *luaM_growaux_ (lua_State *L, void *block, int nelems,
+                               int *size, int size_elem, int limit,
                                const char *what);
+LUAI_FUNC void *luaM_shrinkvector_ (lua_State *L, void *block, int *nelem,
+                                    int final_n, int size_elem);
+LUAI_FUNC void *luaM_malloc_ (lua_State *L, size_t size, int tag);
 
 #endif
 

loadlib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: loadlib.c,v 1.130.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: loadlib.c,v 1.131 2017/12/13 12:51:42 roberto Exp roberto $
 ** Dynamic library loader for Lua
 ** See Copyright Notice in lua.h
 **
@@ -437,9 +437,9 @@ static const char *searchpath (lua_State *L, const char *name,
                                              const char *sep,
                                              const char *dirsep) {
   luaL_Buffer msg;  /* to build error message */
-  luaL_buffinit(L, &msg);
   if (*sep != '\0')  /* non-empty separator? */
     name = luaL_gsub(L, name, sep, dirsep);  /* replace it by 'dirsep' */
+  luaL_buffinit(L, &msg);
   while ((path = pushnexttemplate(L, path)) != NULL) {
     const char *filename = luaL_gsub(L, lua_tostring(L, -1),
                                      LUA_PATH_MARK, name);
@@ -569,10 +569,10 @@ static int searcher_preload (lua_State *L) {
 static void findloader (lua_State *L, const char *name) {
   int i;
   luaL_Buffer msg;  /* to build error message */
-  luaL_buffinit(L, &msg);
   /* push 'package.searchers' to index 3 in the stack */
   if (lua_getfield(L, lua_upvalueindex(1), "searchers") != LUA_TTABLE)
     luaL_error(L, "'package.searchers' must be a table");
+  luaL_buffinit(L, &msg);
   /*  iterate over available searchers to find a loader */
   for (i = 1; ; i++) {
     if (lua_rawgeti(L, 3, i) == LUA_TNIL) {  /* no more searchers? */
@@ -621,96 +621,10 @@ static int ll_require (lua_State *L) {
 
 
 
-/*
-** {======================================================
-** 'module' function
-** =======================================================
-*/
-#if defined(LUA_COMPAT_MODULE)
-
-/*
-** changes the environment variable of calling function
-*/
-static void set_env (lua_State *L) {
-  lua_Debug ar;
-  if (lua_getstack(L, 1, &ar) == 0 ||
-      lua_getinfo(L, "f", &ar) == 0 ||  /* get calling function */
-      lua_iscfunction(L, -1))
-    luaL_error(L, "'module' not called from a Lua function");
-  lua_pushvalue(L, -2);  /* copy new environment table to top */
-  lua_setupvalue(L, -2, 1);
-  lua_pop(L, 1);  /* remove function */
-}
-
-
-static void dooptions (lua_State *L, int n) {
-  int i;
-  for (i = 2; i <= n; i++) {
-    if (lua_isfunction(L, i)) {  /* avoid 'calling' extra info. */
-      lua_pushvalue(L, i);  /* get option (a function) */
-      lua_pushvalue(L, -2);  /* module */
-      lua_call(L, 1, 0);
-    }
-  }
-}
-
-
-static void modinit (lua_State *L, const char *modname) {
-  const char *dot;
-  lua_pushvalue(L, -1);
-  lua_setfield(L, -2, "_M");  /* module._M = module */
-  lua_pushstring(L, modname);
-  lua_setfield(L, -2, "_NAME");
-  dot = strrchr(modname, '.');  /* look for last dot in module name */
-  if (dot == NULL) dot = modname;
-  else dot++;
-  /* set _PACKAGE as package name (full module name minus last part) */
-  lua_pushlstring(L, modname, dot - modname);
-  lua_setfield(L, -2, "_PACKAGE");
-}
-
-
-static int ll_module (lua_State *L) {
-  const char *modname = luaL_checkstring(L, 1);
-  int lastarg = lua_gettop(L);  /* last parameter */
-  luaL_pushmodule(L, modname, 1);  /* get/create module table */
-  /* check whether table already has a _NAME field */
-  if (lua_getfield(L, -1, "_NAME") != LUA_TNIL)
-    lua_pop(L, 1);  /* table is an initialized module */
-  else {  /* no; initialize it */
-    lua_pop(L, 1);
-    modinit(L, modname);
-  }
-  lua_pushvalue(L, -1);
-  set_env(L);
-  dooptions(L, lastarg);
-  return 1;
-}
-
-
-static int ll_seeall (lua_State *L) {
-  luaL_checktype(L, 1, LUA_TTABLE);
-  if (!lua_getmetatable(L, 1)) {
-    lua_createtable(L, 0, 1); /* create new metatable */
-    lua_pushvalue(L, -1);
-    lua_setmetatable(L, 1);
-  }
-  lua_pushglobaltable(L);
-  lua_setfield(L, -2, "__index");  /* mt.__index = _G */
-  return 0;
-}
-
-#endif
-/* }====================================================== */
-
-
 
 static const luaL_Reg pk_funcs[] = {
   {"loadlib", ll_loadlib},
   {"searchpath", ll_searchpath},
-#if defined(LUA_COMPAT_MODULE)
-  {"seeall", ll_seeall},
-#endif
   /* placeholders */
   {"preload", NULL},
   {"cpath", NULL},
@@ -722,9 +636,6 @@ static const luaL_Reg pk_funcs[] = {
 
 
 static const luaL_Reg ll_funcs[] = {
-#if defined(LUA_COMPAT_MODULE)
-  {"module", ll_module},
-#endif
   {"require", ll_require},
   {NULL, NULL}
 };
@@ -742,10 +653,6 @@ static void createsearcherstable (lua_State *L) {
     lua_pushcclosure(L, searchers[i], 1);
     lua_rawseti(L, -2, i+1);
   }
-#if defined(LUA_COMPAT_LOADERS)
-  lua_pushvalue(L, -1);  /* make a copy of 'searchers' table */
-  lua_setfield(L, -3, "loaders");  /* put it in field 'loaders' */
-#endif
   lua_setfield(L, -2, "searchers");  /* put it in field 'searchers' */
 }
 

lobject.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.c,v 2.113.1.1 2017/04/19 17:29:57 roberto Exp $
+** $Id: lobject.c,v 2.125 2018/04/25 16:26:20 roberto Exp roberto $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -29,10 +29,6 @@
 #include "lvm.h"
 
 
-
-LUAI_DDEF const TValue luaO_nilobject_ = {NILCONSTANT};
-
-
 /*
 ** converts an integer to a "floating point byte", represented as
 ** (eeeeexxx), where the real value is (1xxx) * 2^(eeeee - 1) if
@@ -120,43 +116,49 @@ static lua_Number numarith (lua_State *L, int op, lua_Number v1,
 }
 
 
-void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2,
-                 TValue *res) {
+int luaO_rawarith (lua_State *L, int op, const TValue *p1, const TValue *p2,
+                   TValue *res) {
   switch (op) {
     case LUA_OPBAND: case LUA_OPBOR: case LUA_OPBXOR:
     case LUA_OPSHL: case LUA_OPSHR:
     case LUA_OPBNOT: {  /* operate only on integers */
       lua_Integer i1; lua_Integer i2;
-      if (tointeger(p1, &i1) && tointeger(p2, &i2)) {
+      if (tointegerns(p1, &i1) && tointegerns(p2, &i2)) {
         setivalue(res, intarith(L, op, i1, i2));
-        return;
+        return 1;
       }
-      else break;  /* go to the end */
+      else return 0;  /* fail */
     }
     case LUA_OPDIV: case LUA_OPPOW: {  /* operate only on floats */
       lua_Number n1; lua_Number n2;
-      if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
+      if (tonumberns(p1, n1) && tonumberns(p2, n2)) {
         setfltvalue(res, numarith(L, op, n1, n2));
-        return;
+        return 1;
       }
-      else break;  /* go to the end */
+      else return 0;  /* fail */
     }
     default: {  /* other operations */
       lua_Number n1; lua_Number n2;
       if (ttisinteger(p1) && ttisinteger(p2)) {
         setivalue(res, intarith(L, op, ivalue(p1), ivalue(p2)));
-        return;
+        return 1;
       }
-      else if (tonumber(p1, &n1) && tonumber(p2, &n2)) {
+      else if (tonumberns(p1, n1) && tonumberns(p2, n2)) {
         setfltvalue(res, numarith(L, op, n1, n2));
-        return;
+        return 1;
       }
-      else break;  /* go to the end */
+      else return 0;  /* fail */
     }
   }
-  /* could not perform raw operation; try metamethod */
-  lua_assert(L != NULL);  /* should not fail when folding (compile time) */
-  luaT_trybinTM(L, p1, p2, res, cast(TMS, (op - LUA_OPADD) + TM_ADD));
+}
+
+
+void luaO_arith (lua_State *L, int op, const TValue *p1, const TValue *p2,
+                 StkId res) {
+  if (!luaO_rawarith(L, op, p1, p2, s2v(res))) {
+    /* could not perform raw operation; try metamethod */
+    luaT_trybinTM(L, p1, p2, res, cast(TMS, (op - LUA_OPADD) + TM_ADD));
+  }
 }
 
 
@@ -187,7 +189,7 @@ static int isneg (const char **s) {
 #define MAXSIGDIG	30
 
 /*
-** convert an hexadecimal numeric string to a number, following
+** convert a hexadecimal numeric string to a number, following
 ** C99 specification for 'strtod'
 */
 static lua_Number lua_strx2number (const char *s, char **endptr) {
@@ -198,9 +200,9 @@ static lua_Number lua_strx2number (const char *s, char **endptr) {
   int e = 0;  /* exponent correction */
   int neg;  /* 1 if number is negative */
   int hasdot = 0;  /* true after seen a dot */
-  *endptr = cast(char *, s);  /* nothing is valid yet */
+  *endptr = cast_charp(s);  /* nothing is valid yet */
   while (lisspace(cast_uchar(*s))) s++;  /* skip initial spaces */
-  neg = isneg(&s);  /* check signal */
+  neg = isneg(&s);  /* check sign */
   if (!(*s == '0' && (*(s + 1) == 'x' || *(s + 1) == 'X')))  /* check '0x' */
     return 0.0;  /* invalid format (no '0x') */
   for (s += 2; ; s++) {  /* skip '0x' and read numeral */
@@ -220,20 +222,20 @@ static lua_Number lua_strx2number (const char *s, char **endptr) {
   }
   if (nosigdig + sigdig == 0)  /* no digits? */
     return 0.0;  /* invalid format */
-  *endptr = cast(char *, s);  /* valid up to here */
+  *endptr = cast_charp(s);  /* valid up to here */
   e *= 4;  /* each digit multiplies/divides value by 2^4 */
   if (*s == 'p' || *s == 'P') {  /* exponent part? */
     int exp1 = 0;  /* exponent value */
-    int neg1;  /* exponent signal */
+    int neg1;  /* exponent sign */
     s++;  /* skip 'p' */
-    neg1 = isneg(&s);  /* signal */
+    neg1 = isneg(&s);  /* sign */
     if (!lisdigit(cast_uchar(*s)))
       return 0.0;  /* invalid; must have at least one digit */
     while (lisdigit(cast_uchar(*s)))  /* read exponent */
       exp1 = exp1 * 10 + *(s++) - '0';
     if (neg1) exp1 = -exp1;
     e += exp1;
-    *endptr = cast(char *, s);  /* valid up to here */
+    *endptr = cast_charp(s);  /* valid up to here */
   }
   if (neg) r = -r;
   return l_mathop(ldexp)(r, e);
@@ -262,7 +264,7 @@ static const char *l_str2dloc (const char *s, lua_Number *result, int mode) {
 ** Convert string 's' to a Lua number (put in 'result'). Return NULL
 ** on fail or the address of the ending '\0' on success.
 ** 'pmode' points to (and 'mode' contains) special things in the string:
-** - 'x'/'X' means an hexadecimal numeral
+** - 'x'/'X' means a hexadecimal numeral
 ** - 'n'/'N' means 'inf' or 'nan' (which should be rejected)
 ** - '.' just optimizes the search for the common case (nothing special)
 ** This function accepts both the current locale or a dot as the radix
@@ -347,15 +349,15 @@ int luaO_utf8esc (char *buff, unsigned long x) {
   int n = 1;  /* number of bytes put in buffer (backwards) */
   lua_assert(x <= 0x10FFFF);
   if (x < 0x80)  /* ascii? */
-    buff[UTF8BUFFSZ - 1] = cast(char, x);
+    buff[UTF8BUFFSZ - 1] = cast_char(x);
   else {  /* need continuation bytes */
     unsigned int mfb = 0x3f;  /* maximum that fits in first byte */
     do {  /* add continuation bytes */
-      buff[UTF8BUFFSZ - (n++)] = cast(char, 0x80 | (x & 0x3f));
+      buff[UTF8BUFFSZ - (n++)] = cast_char(0x80 | (x & 0x3f));
       x >>= 6;  /* remove added bits */
       mfb >>= 1;  /* now there is one less bit available in first byte */
     } while (x > mfb);  /* still needs continuation byte? */
-    buff[UTF8BUFFSZ - n] = cast(char, (~mfb << 1) | x);  /* add first byte */
+    buff[UTF8BUFFSZ - n] = cast_char((~mfb << 1) | x);  /* add first byte */
   }
   return n;
 }
@@ -368,7 +370,7 @@ int luaO_utf8esc (char *buff, unsigned long x) {
 /*
 ** Convert a number object to a string
 */
-void luaO_tostring (lua_State *L, StkId obj) {
+void luaO_tostring (lua_State *L, TValue *obj) {
   char buff[MAXNUMBER2STR];
   size_t len;
   lua_assert(ttisnumber(obj));
@@ -376,20 +378,18 @@ void luaO_tostring (lua_State *L, StkId obj) {
     len = lua_integer2str(buff, sizeof(buff), ivalue(obj));
   else {
     len = lua_number2str(buff, sizeof(buff), fltvalue(obj));
-#if !defined(LUA_COMPAT_FLOATSTRING)
     if (buff[strspn(buff, "-0123456789")] == '\0') {  /* looks like an int? */
       buff[len++] = lua_getlocaledecpoint();
       buff[len++] = '0';  /* adds '.0' to result */
     }
-#endif
   }
-  setsvalue2s(L, obj, luaS_newlstr(L, buff, len));
+  setsvalue(L, obj, luaS_newlstr(L, buff, len));
 }
 
 
 static void pushstr (lua_State *L, const char *str, size_t l) {
   setsvalue2s(L, L->top, luaS_newlstr(L, str, l));
-  luaD_inctop(L);
+  L->top++;
 }
 
 
@@ -398,11 +398,10 @@ static void pushstr (lua_State *L, const char *str, size_t l) {
    conventional formats, plus Lua-specific '%I' and '%U'
 */
 const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
-  int n = 0;
-  for (;;) {
-    const char *e = strchr(fmt, '%');
-    if (e == NULL) break;
-    pushstr(L, fmt, e - fmt);
+  int n = 0;  /* number of strings in the stack to concatenate */
+  const char *e;  /* points to next conversion specifier */
+  while ((e = strchr(fmt, '%')) != NULL) {
+    pushstr(L, fmt, e - fmt);  /* string up to conversion specifier */
     switch (*(e+1)) {
       case 's': {  /* zero-terminated string */
         const char *s = va_arg(argp, char *);
@@ -411,7 +410,7 @@ const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
         break;
       }
       case 'c': {  /* an 'int' as a character */
-        char buff = cast(char, va_arg(argp, int));
+        char buff = cast_char(va_arg(argp, int));
         if (lisprint(cast_uchar(buff)))
           pushstr(L, &buff, 1);
         else  /* non-printable character; print its code */
@@ -419,18 +418,18 @@ const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
         break;
       }
       case 'd': {  /* an 'int' */
-        setivalue(L->top, va_arg(argp, int));
+        setivalue(s2v(L->top), va_arg(argp, int));
         goto top2str;
       }
       case 'I': {  /* a 'lua_Integer' */
-        setivalue(L->top, cast(lua_Integer, va_arg(argp, l_uacInt)));
+        setivalue(s2v(L->top), cast(lua_Integer, va_arg(argp, l_uacInt)));
         goto top2str;
       }
       case 'f': {  /* a 'lua_Number' */
-        setfltvalue(L->top, cast_num(va_arg(argp, l_uacNumber)));
+        setfltvalue(s2v(L->top), cast_num(va_arg(argp, l_uacNumber)));
       top2str:  /* convert the top element to a string */
-        luaD_inctop(L);
-        luaO_tostring(L, L->top - 1);
+        L->top++;
+        luaO_tostring(L, s2v(L->top - 1));
         break;
       }
       case 'p': {  /* a pointer */
@@ -456,12 +455,15 @@ const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
       }
     }
     n += 2;
-    fmt = e+2;
+    if (L->top + 2 > L->stack_last) {  /* no free stack space? */
+      luaV_concat(L, n);
+      n = 1;
+    }
+    fmt = e + 2;
   }
-  luaD_checkstack(L, 1);
   pushstr(L, fmt, strlen(fmt));
   if (n > 0) luaV_concat(L, n + 1);
-  return svalue(L->top - 1);
+  return svalue(s2v(L->top - 1));
 }
 
 

lobject.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.h,v 2.117.1.1 2017/04/19 17:39:34 roberto Exp $
+** $Id: lobject.h,v 2.145 2018/06/15 14:14:20 roberto Exp roberto $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -19,11 +19,11 @@
 /*
 ** Extra tags for non-values
 */
-#define LUA_TPROTO	LUA_NUMTAGS		/* function prototypes */
-#define LUA_TDEADKEY	(LUA_NUMTAGS+1)		/* removed keys in tables */
+#define LUA_TUPVAL	LUA_NUMTAGS  /* upvalues */
+#define LUA_TPROTO	(LUA_NUMTAGS+1)  /* function prototypes */
 
 /*
-** number of all possible tags (including LUA_TNONE but excluding DEADKEY)
+** number of all possible tags (including LUA_TNONE)
 */
 #define LUA_TOTALTAGS	(LUA_TPROTO + 2)
 
@@ -36,69 +36,12 @@
 */
 
 
-/*
-** LUA_TFUNCTION variants:
-** 0 - Lua function
-** 1 - light C function
-** 2 - regular C function (closure)
-*/
-
-/* Variant tags for functions */
-#define LUA_TLCL	(LUA_TFUNCTION | (0 << 4))  /* Lua closure */
-#define LUA_TLCF	(LUA_TFUNCTION | (1 << 4))  /* light C function */
-#define LUA_TCCL	(LUA_TFUNCTION | (2 << 4))  /* C closure */
-
-
-/* Variant tags for strings */
-#define LUA_TSHRSTR	(LUA_TSTRING | (0 << 4))  /* short strings */
-#define LUA_TLNGSTR	(LUA_TSTRING | (1 << 4))  /* long strings */
-
-
-/* Variant tags for numbers */
-#define LUA_TNUMFLT	(LUA_TNUMBER | (0 << 4))  /* float numbers */
-#define LUA_TNUMINT	(LUA_TNUMBER | (1 << 4))  /* integer numbers */
-
-
-/* Bit mark for collectable types */
-#define BIT_ISCOLLECTABLE	(1 << 6)
-
-/* mark a tag as collectable */
-#define ctb(t)			((t) | BIT_ISCOLLECTABLE)
-
-
-/*
-** Common type for all collectable objects
-*/
-typedef struct GCObject GCObject;
-
-
-/*
-** Common Header for all collectable objects (in macro form, to be
-** included in other objects)
-*/
-#define CommonHeader	GCObject *next; lu_byte tt; lu_byte marked
-
-
-/*
-** Common type has only the common header
-*/
-struct GCObject {
-  CommonHeader;
-};
-
-
-
-
-/*
-** Tagged Values. This is the basic representation of values in Lua,
-** an actual value plus a tag with its type.
-*/
 
 /*
 ** Union of all Lua values
 */
 typedef union Value {
-  GCObject *gc;    /* collectable objects */
+  struct GCObject *gc;    /* collectable objects */
   void *p;         /* light userdata */
   int b;           /* booleans */
   lua_CFunction f; /* light C functions */
@@ -107,85 +50,43 @@ typedef union Value {
 } Value;
 
 
-#define TValuefields	Value value_; int tt_
+/*
+** Tagged Values. This is the basic representation of values in Lua:
+** an actual value plus a tag with its type.
+*/
 
+#define TValuefields	Value value_; lu_byte tt_
 
-typedef struct lua_TValue {
+typedef struct TValue {
   TValuefields;
 } TValue;
 
 
-
-/* macro defining a nil value */
-#define NILCONSTANT	{NULL}, LUA_TNIL
-
-
 #define val_(o)		((o)->value_)
+#define valraw(o)	(&val_(o))
 
 
 /* raw type tag of a TValue */
-#define rttype(o)	((o)->tt_)
+#define rawtt(o)	((o)->tt_)
 
 /* tag with no variants (bits 0-3) */
-#define novariant(x)	((x) & 0x0F)
+#define novariant(t)	((t) & 0x0F)
 
 /* type tag of a TValue (bits 0-3 for tags + variant bits 4-5) */
-#define ttype(o)	(rttype(o) & 0x3F)
+#define withvariant(t)	((t) & 0x3F)
+#define ttypetag(o)	withvariant(rawtt(o))
 
-/* type tag of a TValue with no variants (bits 0-3) */
-#define ttnov(o)	(novariant(rttype(o)))
+/* type of a TValue */
+#define ttype(o)	(novariant(rawtt(o)))
 
 
 /* Macros to test type */
-#define checktag(o,t)		(rttype(o) == (t))
-#define checktype(o,t)		(ttnov(o) == (t))
-#define ttisnumber(o)		checktype((o), LUA_TNUMBER)
-#define ttisfloat(o)		checktag((o), LUA_TNUMFLT)
-#define ttisinteger(o)		checktag((o), LUA_TNUMINT)
-#define ttisnil(o)		checktag((o), LUA_TNIL)
-#define ttisboolean(o)		checktag((o), LUA_TBOOLEAN)
-#define ttislightuserdata(o)	checktag((o), LUA_TLIGHTUSERDATA)
-#define ttisstring(o)		checktype((o), LUA_TSTRING)
-#define ttisshrstring(o)	checktag((o), ctb(LUA_TSHRSTR))
-#define ttislngstring(o)	checktag((o), ctb(LUA_TLNGSTR))
-#define ttistable(o)		checktag((o), ctb(LUA_TTABLE))
-#define ttisfunction(o)		checktype(o, LUA_TFUNCTION)
-#define ttisclosure(o)		((rttype(o) & 0x1F) == LUA_TFUNCTION)
-#define ttisCclosure(o)		checktag((o), ctb(LUA_TCCL))
-#define ttisLclosure(o)		checktag((o), ctb(LUA_TLCL))
-#define ttislcf(o)		checktag((o), LUA_TLCF)
-#define ttisfulluserdata(o)	checktag((o), ctb(LUA_TUSERDATA))
-#define ttisthread(o)		checktag((o), ctb(LUA_TTHREAD))
-#define ttisdeadkey(o)		checktag((o), LUA_TDEADKEY)
-
-
-/* Macros to access values */
-#define ivalue(o)	check_exp(ttisinteger(o), val_(o).i)
-#define fltvalue(o)	check_exp(ttisfloat(o), val_(o).n)
-#define nvalue(o)	check_exp(ttisnumber(o), \
-	(ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o)))
-#define gcvalue(o)	check_exp(iscollectable(o), val_(o).gc)
-#define pvalue(o)	check_exp(ttislightuserdata(o), val_(o).p)
-#define tsvalue(o)	check_exp(ttisstring(o), gco2ts(val_(o).gc))
-#define uvalue(o)	check_exp(ttisfulluserdata(o), gco2u(val_(o).gc))
-#define clvalue(o)	check_exp(ttisclosure(o), gco2cl(val_(o).gc))
-#define clLvalue(o)	check_exp(ttisLclosure(o), gco2lcl(val_(o).gc))
-#define clCvalue(o)	check_exp(ttisCclosure(o), gco2ccl(val_(o).gc))
-#define fvalue(o)	check_exp(ttislcf(o), val_(o).f)
-#define hvalue(o)	check_exp(ttistable(o), gco2t(val_(o).gc))
-#define bvalue(o)	check_exp(ttisboolean(o), val_(o).b)
-#define thvalue(o)	check_exp(ttisthread(o), gco2th(val_(o).gc))
-/* a dead value may get the 'gc' field, but cannot access its contents */
-#define deadvalue(o)	check_exp(ttisdeadkey(o), cast(void *, val_(o).gc))
-
-#define l_isfalse(o)	(ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
-
-
-#define iscollectable(o)	(rttype(o) & BIT_ISCOLLECTABLE)
+#define checktag(o,t)		(rawtt(o) == (t))
+#define checktype(o,t)		(ttype(o) == (t))
 
 
 /* Macros for internal tests */
-#define righttt(obj)		(ttype(obj) == gcvalue(obj)->tt)
+#define righttt(obj)		(ttypetag(obj) == gcvalue(obj)->tt)
 
 #define checkliveness(L,obj) \
 	lua_longassert(!iscollectable(obj) || \
@@ -195,6 +96,199 @@ typedef struct lua_TValue {
 /* Macros to set values */
 #define settt_(o,t)	((o)->tt_=(t))
 
+
+#define setobj(L,obj1,obj2) \
+	{ TValue *io1=(obj1); const TValue *io2=(obj2); \
+          io1->value_ = io2->value_; io1->tt_ = io2->tt_; \
+	  (void)L; checkliveness(L,io1); lua_assert(!isreallyempty(io1)); }
+
+/*
+** different types of assignments, according to destination
+*/
+
+/* from stack to stack */
+#define setobjs2s(L,o1,o2)	setobj(L,s2v(o1),s2v(o2))
+/* to stack (not from same stack) */
+#define setobj2s(L,o1,o2)	setobj(L,s2v(o1),o2)
+/* from table to same table */
+#define setobjt2t	setobj
+/* to new object */
+#define setobj2n	setobj
+/* to table */
+#define setobj2t	setobj
+
+
+
+typedef union StackValue {
+  TValue val;
+} StackValue;
+
+
+typedef StackValue *StkId;  /* index to stack elements */
+
+/* convert a 'StackValue' to a 'TValue' */
+#define s2v(o)	(&(o)->val)
+
+
+
+/*
+** {==================================================================
+** Nil
+** ===================================================================
+*/
+
+/* macro to test for (any kind of) nil */
+#define ttisnil(v)		checktype((v), LUA_TNIL)
+
+/* macro to test for a "pure" nil */
+#define ttisstrictnil(o)	checktag((o), LUA_TNIL)
+
+
+#define setnilvalue(obj) settt_(obj, LUA_TNIL)
+
+
+/*
+** Variant tag, used only in tables to signal an empty slot
+** (which might be different from a slot containing nil)
+*/
+#define LUA_TEMPTY	(LUA_TNIL | (1 << 4))
+
+/*
+** Variant used only in the value returned for a key not found in a
+** table (absent key).
+*/
+#define LUA_TABSTKEY	(LUA_TNIL | (2 << 4))
+
+
+#define isabstkey(v)		checktag((v), LUA_TABSTKEY)
+
+
+/*
+** macro to detect non-standard nils (used only in assertions)
+*/
+#define isreallyempty(v)	(ttisnil(v) && !ttisstrictnil(v))
+
+
+/*
+** By default, entries with any kind of nil are considered empty.
+** (In any definition, values associated with absent keys must also
+** be accepted as empty.)
+*/
+#define isempty(v)		ttisnil(v)
+
+
+/* macro defining a value corresponding to an absent key */
+#define ABSTKEYCONSTANT		{NULL}, LUA_TABSTKEY
+
+
+/* mark an entry as empty */
+#define setempty(v)		settt_(v, LUA_TEMPTY)
+
+
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Booleans
+** ===================================================================
+*/
+
+#define ttisboolean(o)		checktag((o), LUA_TBOOLEAN)
+
+#define bvalue(o)	check_exp(ttisboolean(o), val_(o).b)
+
+#define bvalueraw(v)	((v).b)
+
+#define l_isfalse(o)	(ttisnil(o) || (ttisboolean(o) && bvalue(o) == 0))
+
+#define setbvalue(obj,x) \
+  { TValue *io=(obj); val_(io).b=(x); settt_(io, LUA_TBOOLEAN); }
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Threads
+** ===================================================================
+*/
+
+#define ttisthread(o)		checktag((o), ctb(LUA_TTHREAD))
+
+#define thvalue(o)	check_exp(ttisthread(o), gco2th(val_(o).gc))
+
+#define setthvalue(L,obj,x) \
+  { TValue *io = (obj); lua_State *x_ = (x); \
+    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTHREAD)); \
+    checkliveness(L,io); }
+
+#define setthvalue2s(L,o,t)	setthvalue(L,s2v(o),t)
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Collectable Objects
+** ===================================================================
+*/
+
+/*
+** Common Header for all collectable objects (in macro form, to be
+** included in other objects)
+*/
+#define CommonHeader	struct GCObject *next; lu_byte tt; lu_byte marked
+
+
+/* Common type for all collectable objects */
+typedef struct GCObject {
+  CommonHeader;
+} GCObject;
+
+
+/* Bit mark for collectable types */
+#define BIT_ISCOLLECTABLE	(1 << 6)
+
+#define iscollectable(o)	(rawtt(o) & BIT_ISCOLLECTABLE)
+
+/* mark a tag as collectable */
+#define ctb(t)			((t) | BIT_ISCOLLECTABLE)
+
+#define gcvalue(o)	check_exp(iscollectable(o), val_(o).gc)
+
+#define gcvalueraw(v)	((v).gc)
+
+#define setgcovalue(L,obj,x) \
+  { TValue *io = (obj); GCObject *i_g=(x); \
+    val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); }
+
+/* }================================================================== */
+
+
+/*
+** {==================================================================
+** Numbers
+** ===================================================================
+*/
+
+/* Variant tags for numbers */
+#define LUA_TNUMFLT	(LUA_TNUMBER | (1 << 4))  /* float numbers */
+#define LUA_TNUMINT	(LUA_TNUMBER | (2 << 4))  /* integer numbers */
+
+#define ttisnumber(o)		checktype((o), LUA_TNUMBER)
+#define ttisfloat(o)		checktag((o), LUA_TNUMFLT)
+#define ttisinteger(o)		checktag((o), LUA_TNUMINT)
+
+#define nvalue(o)	check_exp(ttisnumber(o), \
+	(ttisinteger(o) ? cast_num(ivalue(o)) : fltvalue(o)))
+#define fltvalue(o)	check_exp(ttisfloat(o), val_(o).n)
+#define ivalue(o)	check_exp(ttisinteger(o), val_(o).i)
+
+#define fltvalueraw(v)	((v).n)
+#define ivalueraw(v)	((v).i)
+
 #define setfltvalue(obj,x) \
   { TValue *io=(obj); val_(io).n=(x); settt_(io, LUA_TNUMFLT); }
 
@@ -207,94 +301,38 @@ typedef struct lua_TValue {
 #define chgivalue(obj,x) \
   { TValue *io=(obj); lua_assert(ttisinteger(io)); val_(io).i=(x); }
 
-#define setnilvalue(obj) settt_(obj, LUA_TNIL)
+/* }================================================================== */
 
-#define setfvalue(obj,x) \
-  { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_TLCF); }
 
-#define setpvalue(obj,x) \
-  { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_TLIGHTUSERDATA); }
+/*
+** {==================================================================
+** Strings
+** ===================================================================
+*/
 
-#define setbvalue(obj,x) \
-  { TValue *io=(obj); val_(io).b=(x); settt_(io, LUA_TBOOLEAN); }
+/* Variant tags for strings */
+#define LUA_TSHRSTR	(LUA_TSTRING | (1 << 4))  /* short strings */
+#define LUA_TLNGSTR	(LUA_TSTRING | (2 << 4))  /* long strings */
 
-#define setgcovalue(L,obj,x) \
-  { TValue *io = (obj); GCObject *i_g=(x); \
-    val_(io).gc = i_g; settt_(io, ctb(i_g->tt)); }
+#define ttisstring(o)		checktype((o), LUA_TSTRING)
+#define ttisshrstring(o)	checktag((o), ctb(LUA_TSHRSTR))
+#define ttislngstring(o)	checktag((o), ctb(LUA_TLNGSTR))
+
+#define tsvalueraw(v)	(gco2ts((v).gc))
+
+#define tsvalue(o)	check_exp(ttisstring(o), gco2ts(val_(o).gc))
 
 #define setsvalue(L,obj,x) \
   { TValue *io = (obj); TString *x_ = (x); \
     val_(io).gc = obj2gco(x_); settt_(io, ctb(x_->tt)); \
     checkliveness(L,io); }
 
-#define setuvalue(L,obj,x) \
-  { TValue *io = (obj); Udata *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TUSERDATA)); \
-    checkliveness(L,io); }
+/* set a string to the stack */
+#define setsvalue2s(L,o,s)	setsvalue(L,s2v(o),s)
 
-#define setthvalue(L,obj,x) \
-  { TValue *io = (obj); lua_State *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTHREAD)); \
-    checkliveness(L,io); }
-
-#define setclLvalue(L,obj,x) \
-  { TValue *io = (obj); LClosure *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TLCL)); \
-    checkliveness(L,io); }
-
-#define setclCvalue(L,obj,x) \
-  { TValue *io = (obj); CClosure *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TCCL)); \
-    checkliveness(L,io); }
-
-#define sethvalue(L,obj,x) \
-  { TValue *io = (obj); Table *x_ = (x); \
-    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTABLE)); \
-    checkliveness(L,io); }
-
-#define setdeadvalue(obj)	settt_(obj, LUA_TDEADKEY)
-
-
-
-#define setobj(L,obj1,obj2) \
-	{ TValue *io1=(obj1); *io1 = *(obj2); \
-	  (void)L; checkliveness(L,io1); }
-
-
-/*
-** different types of assignments, according to destination
-*/
-
-/* from stack to (same) stack */
-#define setobjs2s	setobj
-/* to stack (not from same stack) */
-#define setobj2s	setobj
-#define setsvalue2s	setsvalue
-#define sethvalue2s	sethvalue
-#define setptvalue2s	setptvalue
-/* from table to same table */
-#define setobjt2t	setobj
-/* to new object */
-#define setobj2n	setobj
+/* set a string to a new object */
 #define setsvalue2n	setsvalue
 
-/* to table (define it as an expression to be used in macros) */
-#define setobj2t(L,o1,o2)  ((void)L, *(o1)=*(o2), checkliveness(L,(o1)))
-
-
-
-
-/*
-** {======================================================
-** types and prototypes
-** =======================================================
-*/
-
-
-typedef TValue *StkId;  /* index to stack elements */
-
-
-
 
 /*
 ** Header for string value; string bytes follow the end of this structure
@@ -316,7 +354,7 @@ typedef struct TString {
 ** Ensures that address after this type is always fully aligned.
 */
 typedef union UTString {
-  L_Umaxalign dummy;  /* ensures maximum alignment for strings */
+  LUAI_MAXALIGN;  /* ensures maximum alignment for strings */
   TString tsv;
 } UTString;
 
@@ -326,7 +364,7 @@ typedef union UTString {
 ** (Access to 'extra' ensures that value is really a 'TString'.)
 */
 #define getstr(ts)  \
-  check_exp(sizeof((ts)->extra), cast(char *, (ts)) + sizeof(UTString))
+  check_exp(sizeof((ts)->extra), cast_charp((ts)) + sizeof(UTString))
 
 
 /* get the actual string (array of bytes) from a Lua value */
@@ -338,47 +376,90 @@ typedef union UTString {
 /* get string length from 'TValue *o' */
 #define vslen(o)	tsslen(tsvalue(o))
 
+/* }================================================================== */
+
 
 /*
-** Header for userdata; memory area follows the end of this structure
-** (aligned according to 'UUdata'; see next).
+** {==================================================================
+** Userdata
+** ===================================================================
+*/
+
+#define ttislightuserdata(o)	checktag((o), LUA_TLIGHTUSERDATA)
+#define ttisfulluserdata(o)	checktype((o), LUA_TUSERDATA)
+
+#define pvalue(o)	check_exp(ttislightuserdata(o), val_(o).p)
+#define uvalue(o)	check_exp(ttisfulluserdata(o), gco2u(val_(o).gc))
+
+#define pvalueraw(v)	((v).p)
+
+#define setpvalue(obj,x) \
+  { TValue *io=(obj); val_(io).p=(x); settt_(io, LUA_TLIGHTUSERDATA); }
+
+#define setuvalue(L,obj,x) \
+  { TValue *io = (obj); Udata *x_ = (x); \
+    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TUSERDATA)); \
+    checkliveness(L,io); }
+
+
+/* Ensures that addresses after this type are always fully aligned. */
+typedef union UValue {
+  TValue uv;
+  LUAI_MAXALIGN;  /* ensures maximum alignment for udata bytes */
+} UValue;
+
+
+/*
+** Header for userdata with user values;
+** memory area follows the end of this structure.
 */
 typedef struct Udata {
   CommonHeader;
-  lu_byte ttuv_;  /* user value's tag */
-  struct Table *metatable;
+  unsigned short nuvalue;  /* number of user values */
   size_t len;  /* number of bytes */
-  union Value user_;  /* user value */
+  struct Table *metatable;
+  GCObject *gclist;
+  UValue uv[1];  /* user values */
 } Udata;
 
 
 /*
-** Ensures that address after this type is always fully aligned.
+** Header for userdata with no user values. These userdata do not need
+** to be gray during GC, and therefore do not need a 'gclist' field.
+** To simplify, the code always use 'Udata' for both kinds of userdata,
+** making sure it never accesses 'gclist' on userdata with no user values.
+** This structure here is used only to compute the correct size for
+** this representation. (The 'bindata' field in its end ensures correct
+** alignment for binary data following this header.)
 */
-typedef union UUdata {
-  L_Umaxalign dummy;  /* ensures maximum alignment for 'local' udata */
-  Udata uv;
-} UUdata;
+typedef struct Udata0 {
+  CommonHeader;
+  unsigned short nuvalue;  /* number of user values */
+  size_t len;  /* number of bytes */
+  struct Table *metatable;
+  union {LUAI_MAXALIGN;} bindata;
+} Udata0;
+
+
+/* compute the offset of the memory area of a userdata */
+#define udatamemoffset(nuv) \
+	((nuv) == 0 ? offsetof(Udata0, bindata)  \
+                    : offsetof(Udata, uv) + (sizeof(UValue) * (nuv)))
+
+/* get the address of the memory block inside 'Udata' */
+#define getudatamem(u)	(cast_charp(u) + udatamemoffset((u)->nuvalue))
+
+/* compute the size of a userdata */
+#define sizeudata(nuv,nb)	(udatamemoffset(nuv) + (nb))
+
+/* }================================================================== */
 
 
 /*
-**  Get the address of memory block inside 'Udata'.
-** (Access to 'ttuv_' ensures that value is really a 'Udata'.)
+** {==================================================================
+** Prototypes
+** ===================================================================
 */
-#define getudatamem(u)  \
-  check_exp(sizeof((u)->ttuv_), (cast(char*, (u)) + sizeof(UUdata)))
-
-#define setuservalue(L,u,o) \
-	{ const TValue *io=(o); Udata *iu = (u); \
-	  iu->user_ = io->value_; iu->ttuv_ = rttype(io); \
-	  checkliveness(L,io); }
-
-
-#define getuservalue(L,u,o) \
-	{ TValue *io=(o); const Udata *iu = (u); \
-	  io->value_ = iu->user_; settt_(io, iu->ttuv_); \
-	  checkliveness(L,io); }
-
 
 /*
 ** Description of an upvalue for function prototypes
@@ -401,45 +482,112 @@ typedef struct LocVar {
 } LocVar;
 
 
+/*
+** Associates the absolute line source for a given instruction ('pc').
+** The array 'lineinfo' gives, for each instruction, the difference in
+** lines from the previous instruction. When that difference does not
+** fit into a byte, Lua saves the absolute line for that instruction.
+** (Lua also saves the absolute line periodically, to speed up the
+** computation of a line number: we can use binary search in the
+** absolute-line array, but we must traverse the 'lineinfo' array
+** linearly to compute a line.)
+*/
+typedef struct AbsLineInfo {
+  int pc;
+  int line;
+} AbsLineInfo;
+
 /*
 ** Function Prototypes
 */
 typedef struct Proto {
   CommonHeader;
-  lu_byte numparams;  /* number of fixed parameters */
+  lu_byte numparams;  /* number of fixed (named) parameters */
   lu_byte is_vararg;
   lu_byte maxstacksize;  /* number of registers needed by this function */
+  lu_byte cachemiss;  /* count for successive misses for 'cache' field */
   int sizeupvalues;  /* size of 'upvalues' */
   int sizek;  /* size of 'k' */
   int sizecode;
   int sizelineinfo;
   int sizep;  /* size of 'p' */
   int sizelocvars;
+  int sizeabslineinfo;  /* size of 'abslineinfo' */
   int linedefined;  /* debug information  */
   int lastlinedefined;  /* debug information  */
   TValue *k;  /* constants used by the function */
+  struct LClosure *cache;  /* last-created closure with this prototype */
   Instruction *code;  /* opcodes */
   struct Proto **p;  /* functions defined inside the function */
-  int *lineinfo;  /* map from opcodes to source lines (debug information) */
-  LocVar *locvars;  /* information about local variables (debug information) */
   Upvaldesc *upvalues;  /* upvalue information */
-  struct LClosure *cache;  /* last-created closure with this prototype */
+  ls_byte *lineinfo;  /* information about source lines (debug information) */
+  AbsLineInfo *abslineinfo;  /* idem */
+  LocVar *locvars;  /* information about local variables (debug information) */
   TString  *source;  /* used for debug information */
   GCObject *gclist;
 } Proto;
 
+/* }================================================================== */
 
 
 /*
-** Lua Upvalues
-*/
-typedef struct UpVal UpVal;
-
-
-/*
+** {==================================================================
 ** Closures
+** ===================================================================
 */
 
+/* Variant tags for functions */
+#define LUA_TLCL	(LUA_TFUNCTION | (1 << 4))  /* Lua closure */
+#define LUA_TLCF	(LUA_TFUNCTION | (2 << 4))  /* light C function */
+#define LUA_TCCL	(LUA_TFUNCTION | (3 << 4))  /* C closure */
+
+#define ttisfunction(o)		checktype(o, LUA_TFUNCTION)
+#define ttisclosure(o)		((rawtt(o) & 0x1F) == LUA_TLCL)
+#define ttisLclosure(o)		checktag((o), ctb(LUA_TLCL))
+#define ttislcf(o)		checktag((o), LUA_TLCF)
+#define ttisCclosure(o)		checktag((o), ctb(LUA_TCCL))
+
+#define isLfunction(o)	ttisLclosure(o)
+
+#define clvalue(o)	check_exp(ttisclosure(o), gco2cl(val_(o).gc))
+#define clLvalue(o)	check_exp(ttisLclosure(o), gco2lcl(val_(o).gc))
+#define fvalue(o)	check_exp(ttislcf(o), val_(o).f)
+#define clCvalue(o)	check_exp(ttisCclosure(o), gco2ccl(val_(o).gc))
+
+#define fvalueraw(v)	((v).f)
+
+#define setclLvalue(L,obj,x) \
+  { TValue *io = (obj); LClosure *x_ = (x); \
+    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TLCL)); \
+    checkliveness(L,io); }
+
+#define setclLvalue2s(L,o,cl)	setclLvalue(L,s2v(o),cl)
+
+#define setfvalue(obj,x) \
+  { TValue *io=(obj); val_(io).f=(x); settt_(io, LUA_TLCF); }
+
+#define setclCvalue(L,obj,x) \
+  { TValue *io = (obj); CClosure *x_ = (x); \
+    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TCCL)); \
+    checkliveness(L,io); }
+
+
+/*
+** Upvalues for Lua closures
+*/
+typedef struct UpVal {
+  CommonHeader;
+  TValue *v;  /* points to stack or to its own value */
+  union {
+    struct {  /* (when open) */
+      struct UpVal *next;  /* linked list */
+      struct UpVal **previous;
+    } open;
+    TValue value;  /* the value (when closed) */
+  } u;
+} UpVal;
+
+
 #define ClosureHeader \
 	CommonHeader; lu_byte nupvalues; GCObject *gclist
 
@@ -463,42 +611,79 @@ typedef union Closure {
 } Closure;
 
 
-#define isLfunction(o)	ttisLclosure(o)
-
 #define getproto(o)	(clLvalue(o)->p)
 
+/* }================================================================== */
+
 
 /*
+** {==================================================================
 ** Tables
+** ===================================================================
 */
 
-typedef union TKey {
-  struct {
-    TValuefields;
-    int next;  /* for chaining (offset for next node) */
-  } nk;
-  TValue tvk;
-} TKey;
+#define ttistable(o)		checktag((o), ctb(LUA_TTABLE))
+
+#define hvalue(o)	check_exp(ttistable(o), gco2t(val_(o).gc))
+
+#define sethvalue(L,obj,x) \
+  { TValue *io = (obj); Table *x_ = (x); \
+    val_(io).gc = obj2gco(x_); settt_(io, ctb(LUA_TTABLE)); \
+    checkliveness(L,io); }
+
+#define sethvalue2s(L,o,h)	sethvalue(L,s2v(o),h)
 
 
-/* copy a value into a key without messing up field 'next' */
-#define setnodekey(L,key,obj) \
-	{ TKey *k_=(key); const TValue *io_=(obj); \
-	  k_->nk.value_ = io_->value_; k_->nk.tt_ = io_->tt_; \
+/*
+** Nodes for Hash tables: A pack of two TValue's (key-value pairs)
+** plus a 'next' field to link colliding entries. The distribution
+** of the key's fields ('key_tt' and 'key_val') not forming a proper
+** 'TValue' allows for a smaller size for 'Node' both in 4-byte
+** and 8-byte alignments.
+*/
+typedef union Node {
+  struct NodeKey {
+    TValuefields;  /* fields for value */
+    lu_byte key_tt;  /* key type */
+    int next;  /* for chaining */
+    Value key_val;  /* key value */
+  } u;
+  TValue i_val;  /* direct access to node's value as a proper 'TValue' */
+} Node;
+
+
+/* copy a value into a key */
+#define setnodekey(L,node,obj) \
+	{ Node *n_=(node); const TValue *io_=(obj); \
+	  n_->u.key_val = io_->value_; n_->u.key_tt = io_->tt_; \
 	  (void)L; checkliveness(L,io_); }
 
 
-typedef struct Node {
-  TValue i_val;
-  TKey i_key;
-} Node;
+/* copy a value from a key */
+#define getnodekey(L,obj,node) \
+	{ TValue *io_=(obj); const Node *n_=(node); \
+	  io_->value_ = n_->u.key_val; io_->tt_ = n_->u.key_tt; \
+	  (void)L; checkliveness(L,io_); }
+
+
+/*
+** About 'alimit': if 'isrealasize(t)' is true, then 'alimit' is the
+** real size of 'array'. Otherwise, the real size of 'array' is the
+** smallest power of two not smaller than 'alimit' (or zero iff 'alimit'
+** is zero); 'alimit' is then used as a hint for #t.
+*/
+
+#define BITRAS		(1 << 7)
+#define isrealasize(t)		(!((t)->marked & BITRAS))
+#define setrealasize(t)		((t)->marked &= cast_byte(~BITRAS))
+#define setnorealasize(t)	((t)->marked |= BITRAS)
 
 
 typedef struct Table {
   CommonHeader;
   lu_byte flags;  /* 1<<p means tagmethod(p) is not present */
   lu_byte lsizenode;  /* log2 of size of 'node' array */
-  unsigned int sizearray;  /* size of 'array' array */
+  unsigned int alimit;  /* "limit" of 'array' array */
   TValue *array;  /* array part */
   Node *node;
   Node *lastfree;  /* any free position is before this position */
@@ -507,26 +692,50 @@ typedef struct Table {
 } Table;
 
 
+/*
+** Macros to manipulate keys inserted in nodes
+*/
+#define keytt(node)		((node)->u.key_tt)
+#define keyval(node)		((node)->u.key_val)
+
+#define keyisnil(node)		(keytt(node) == LUA_TNIL)
+#define keyisinteger(node)	(keytt(node) == LUA_TNUMINT)
+#define keyival(node)		(keyval(node).i)
+#define keyisshrstr(node)	(keytt(node) == ctb(LUA_TSHRSTR))
+#define keystrval(node)		(gco2ts(keyval(node).gc))
+
+#define setnilkey(node)		(keytt(node) = LUA_TNIL)
+
+#define keyiscollectable(n)	(keytt(n) & BIT_ISCOLLECTABLE)
+
+#define gckey(n)	(keyval(n).gc)
+#define gckeyN(n)	(keyiscollectable(n) ? gckey(n) : NULL)
+
+
+/*
+** Use a "nil table" to mark dead keys in a table. Those keys serve
+** to keep space for removed entries, which may still be part of
+** chains. Note that the 'keytt' does not have the BIT_ISCOLLECTABLE
+** set, so these values are considered not collectable and are different
+** from any valid value.
+*/
+#define setdeadkey(n)	(keytt(n) = LUA_TTABLE, gckey(n) = NULL)
+
+/* }================================================================== */
+
+
 
 /*
 ** 'module' operation for hashing (size is always a power of 2)
 */
 #define lmod(s,size) \
-	(check_exp((size&(size-1))==0, (cast(int, (s) & ((size)-1)))))
+	(check_exp((size&(size-1))==0, (cast_int((s) & ((size)-1)))))
 
 
 #define twoto(x)	(1<<(x))
 #define sizenode(t)	(twoto((t)->lsizenode))
 
 
-/*
-** (address of) a fixed nil value
-*/
-#define luaO_nilobject		(&luaO_nilobject_)
-
-
-LUAI_DDEC const TValue luaO_nilobject_;
-
 /* size of buffer for 'luaO_utf8esc' function */
 #define UTF8BUFFSZ	8
 
@@ -534,11 +743,13 @@ LUAI_FUNC int luaO_int2fb (unsigned int x);
 LUAI_FUNC int luaO_fb2int (int x);
 LUAI_FUNC int luaO_utf8esc (char *buff, unsigned long x);
 LUAI_FUNC int luaO_ceillog2 (unsigned int x);
+LUAI_FUNC int luaO_rawarith (lua_State *L, int op, const TValue *p1,
+                             const TValue *p2, TValue *res);
 LUAI_FUNC void luaO_arith (lua_State *L, int op, const TValue *p1,
-                           const TValue *p2, TValue *res);
+                           const TValue *p2, StkId res);
 LUAI_FUNC size_t luaO_str2num (const char *s, TValue *o);
 LUAI_FUNC int luaO_hexavalue (int c);
-LUAI_FUNC void luaO_tostring (lua_State *L, StkId obj);
+LUAI_FUNC void luaO_tostring (lua_State *L, TValue *obj);
 LUAI_FUNC const char *luaO_pushvfstring (lua_State *L, const char *fmt,
                                                        va_list argp);
 LUAI_FUNC const char *luaO_pushfstring (lua_State *L, const char *fmt, ...);

lopcodes.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.c,v 1.55.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lopcodes.c,v 1.81 2018/04/04 14:23:41 roberto Exp roberto $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -17,20 +17,40 @@
 
 /* ORDER OP */
 
+#if defined(LUAI_DEFOPNAMES)
+
 LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = {
   "MOVE",
+  "LOADI",
+  "LOADF",
   "LOADK",
   "LOADKX",
   "LOADBOOL",
   "LOADNIL",
   "GETUPVAL",
+  "SETUPVAL",
   "GETTABUP",
   "GETTABLE",
+  "GETI",
+  "GETFIELD",
   "SETTABUP",
-  "SETUPVAL",
   "SETTABLE",
+  "SETI",
+  "SETFIELD",
   "NEWTABLE",
   "SELF",
+  "ADDI",
+  "SUBI",
+  "MULI",
+  "MODI",
+  "POWI",
+  "DIVI",
+  "IDIVI",
+  "BANDK",
+  "BORK",
+  "BXORK",
+  "SHRI",
+  "SHLI",
   "ADD",
   "SUB",
   "MUL",
@@ -48,15 +68,26 @@ LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = {
   "NOT",
   "LEN",
   "CONCAT",
+  "CLOSE",
   "JMP",
   "EQ",
   "LT",
   "LE",
+  "EQK",
+  "EQI",
+  "LTI",
+  "LEI",
+  "GTI",
+  "GEI",
   "TEST",
   "TESTSET",
   "CALL",
   "TAILCALL",
   "RETURN",
+  "RETURN0",
+  "RETURN1",
+  "FORLOOP1",
+  "FORPREP1",
   "FORLOOP",
   "FORPREP",
   "TFORCALL",
@@ -64,61 +95,92 @@ LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = {
   "SETLIST",
   "CLOSURE",
   "VARARG",
+  "PREPVARARG",
   "EXTRAARG",
   NULL
 };
 
+#endif
 
-#define opmode(t,a,b,c,m) (((t)<<7) | ((a)<<6) | ((b)<<4) | ((c)<<2) | (m))
 
 LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = {
-/*       T  A    B       C     mode		   opcode	*/
-  opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_MOVE */
- ,opmode(0, 1, OpArgK, OpArgN, iABx)		/* OP_LOADK */
- ,opmode(0, 1, OpArgN, OpArgN, iABx)		/* OP_LOADKX */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_LOADBOOL */
- ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_LOADNIL */
- ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_GETUPVAL */
- ,opmode(0, 1, OpArgU, OpArgK, iABC)		/* OP_GETTABUP */
- ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_GETTABLE */
- ,opmode(0, 0, OpArgK, OpArgK, iABC)		/* OP_SETTABUP */
- ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_SETUPVAL */
- ,opmode(0, 0, OpArgK, OpArgK, iABC)		/* OP_SETTABLE */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_NEWTABLE */
- ,opmode(0, 1, OpArgR, OpArgK, iABC)		/* OP_SELF */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_ADD */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SUB */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MUL */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_MOD */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_POW */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_DIV */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_IDIV */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BAND */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BOR */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_BXOR */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SHL */
- ,opmode(0, 1, OpArgK, OpArgK, iABC)		/* OP_SHR */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_UNM */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_BNOT */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_NOT */
- ,opmode(0, 1, OpArgR, OpArgN, iABC)		/* OP_LEN */
- ,opmode(0, 1, OpArgR, OpArgR, iABC)		/* OP_CONCAT */
- ,opmode(0, 0, OpArgR, OpArgN, iAsBx)		/* OP_JMP */
- ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_EQ */
- ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LT */
- ,opmode(1, 0, OpArgK, OpArgK, iABC)		/* OP_LE */
- ,opmode(1, 0, OpArgN, OpArgU, iABC)		/* OP_TEST */
- ,opmode(1, 1, OpArgR, OpArgU, iABC)		/* OP_TESTSET */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_CALL */
- ,opmode(0, 1, OpArgU, OpArgU, iABC)		/* OP_TAILCALL */
- ,opmode(0, 0, OpArgU, OpArgN, iABC)		/* OP_RETURN */
- ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORLOOP */
- ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_FORPREP */
- ,opmode(0, 0, OpArgN, OpArgU, iABC)		/* OP_TFORCALL */
- ,opmode(0, 1, OpArgR, OpArgN, iAsBx)		/* OP_TFORLOOP */
- ,opmode(0, 0, OpArgU, OpArgU, iABC)		/* OP_SETLIST */
- ,opmode(0, 1, OpArgU, OpArgN, iABx)		/* OP_CLOSURE */
- ,opmode(0, 1, OpArgU, OpArgN, iABC)		/* OP_VARARG */
- ,opmode(0, 0, OpArgU, OpArgU, iAx)		/* OP_EXTRAARG */
+/*       OT IT T  A  mode		   opcode  */
+  opmode(0, 0, 0, 1, iABC)		/* OP_MOVE */
+ ,opmode(0, 0, 0, 1, iAsBx)		/* OP_LOADI */
+ ,opmode(0, 0, 0, 1, iAsBx)		/* OP_LOADF */
+ ,opmode(0, 0, 0, 1, iABx)		/* OP_LOADK */
+ ,opmode(0, 0, 0, 1, iABx)		/* OP_LOADKX */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_LOADBOOL */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_LOADNIL */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_GETUPVAL */
+ ,opmode(0, 0, 0, 0, iABC)		/* OP_SETUPVAL */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_GETTABUP */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_GETTABLE */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_GETI */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_GETFIELD */
+ ,opmode(0, 0, 0, 0, iABC)		/* OP_SETTABUP */
+ ,opmode(0, 0, 0, 0, iABC)		/* OP_SETTABLE */
+ ,opmode(0, 0, 0, 0, iABC)		/* OP_SETI */
+ ,opmode(0, 0, 0, 0, iABC)		/* OP_SETFIELD */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_NEWTABLE */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_SELF */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_ADDI */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_SUBI */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_MULI */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_MODI */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_POWI */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_DIVI */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_IDIVI */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_BANDK */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_BORK */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_BXORK */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_SHRI */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_SHLI */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_ADD */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_SUB */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_MUL */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_MOD */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_POW */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_DIV */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_IDIV */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_BAND */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_BOR */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_BXOR */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_SHL */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_SHR */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_UNM */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_BNOT */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_NOT */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_LEN */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_CONCAT */
+ ,opmode(0, 0, 0, 0, iABC)		/* OP_CLOSE */
+ ,opmode(0, 0, 0, 0, isJ)		/* OP_JMP */
+ ,opmode(0, 0, 1, 0, iABC)		/* OP_EQ */
+ ,opmode(0, 0, 1, 0, iABC)		/* OP_LT */
+ ,opmode(0, 0, 1, 0, iABC)		/* OP_LE */
+ ,opmode(0, 0, 1, 0, iABC)		/* OP_EQK */
+ ,opmode(0, 0, 1, 0, iABC)		/* OP_EQI */
+ ,opmode(0, 0, 1, 0, iABC)		/* OP_LTI */
+ ,opmode(0, 0, 1, 0, iABC)		/* OP_LEI */
+ ,opmode(0, 0, 1, 0, iABC)		/* OP_GTI */
+ ,opmode(0, 0, 1, 0, iABC)		/* OP_GEI */
+ ,opmode(0, 0, 1, 0, iABC)		/* OP_TEST */
+ ,opmode(0, 0, 1, 1, iABC)		/* OP_TESTSET */
+ ,opmode(1, 1, 0, 1, iABC)		/* OP_CALL */
+ ,opmode(1, 1, 0, 1, iABC)		/* OP_TAILCALL */
+ ,opmode(0, 1, 0, 0, iABC)		/* OP_RETURN */
+ ,opmode(0, 0, 0, 0, iABC)		/* OP_RETURN0 */
+ ,opmode(0, 0, 0, 0, iABC)		/* OP_RETURN1 */
+ ,opmode(0, 0, 0, 1, iABx)		/* OP_FORLOOP1 */
+ ,opmode(0, 0, 0, 1, iABx)		/* OP_FORPREP1 */
+ ,opmode(0, 0, 0, 1, iABx)		/* OP_FORLOOP */
+ ,opmode(0, 0, 0, 1, iABx)		/* OP_FORPREP */
+ ,opmode(0, 0, 0, 0, iABC)		/* OP_TFORCALL */
+ ,opmode(0, 0, 0, 1, iABx)		/* OP_TFORLOOP */
+ ,opmode(0, 1, 0, 0, iABC)		/* OP_SETLIST */
+ ,opmode(0, 0, 0, 1, iABx)		/* OP_CLOSURE */
+ ,opmode(1, 0, 0, 1, iABC)		/* OP_VARARG */
+ ,opmode(0, 0, 0, 1, iABC)		/* OP_PREPVARARG */
+ ,opmode(0, 0, 0, 0, iAx)		/* OP_EXTRAARG */
 };
 

lopcodes.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.h,v 1.149.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lopcodes.h,v 1.192 2018/06/08 19:07:27 roberto Exp roberto $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -11,45 +11,52 @@
 
 
 /*===========================================================================
-  We assume that instructions are unsigned numbers.
-  All instructions have an opcode in the first 6 bits.
-  Instructions can have the following fields:
-	'A' : 8 bits
-	'B' : 9 bits
-	'C' : 9 bits
-	'Ax' : 26 bits ('A', 'B', and 'C' together)
-	'Bx' : 18 bits ('B' and 'C' together)
-	'sBx' : signed Bx
+  We assume that instructions are unsigned 32-bit integers.
+  All instructions have an opcode in the first 7 bits.
+  Instructions can have the following formats:
 
-  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.
+        3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0
+        1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+iABC         C(8)     |      B(8)     |k|     A(8)      |   Op(7)     |
+iABx               Bx(17)               |     A(8)      |   Op(7)     |
+iAsB              sBx (signed)(17)      |     A(8)      |   Op(7)     |
+iAx                           Ax(25)                    |   Op(7)     |
+isJ                          sJ(24)                   |m|   Op(7)     |
+
+  A signed argument is represented in excess K: the represented value is
+  the written unsigned value minus K, where K is half the maximum for the
+  corresponding unsigned argument.
 ===========================================================================*/
 
 
-enum OpMode {iABC, iABx, iAsBx, iAx};  /* basic instruction format */
+enum OpMode {iABC, iABx, iAsBx, iAx, isJ};  /* basic instruction formats */
 
 
 /*
 ** size and position of opcode arguments.
 */
-#define SIZE_C		9
-#define SIZE_B		9
-#define SIZE_Bx		(SIZE_C + SIZE_B)
+#define SIZE_C		8
+#define SIZE_B		8
+#define SIZE_Bx		(SIZE_C + SIZE_B + 1)
 #define SIZE_A		8
-#define SIZE_Ax		(SIZE_C + SIZE_B + SIZE_A)
+#define SIZE_Ax		(SIZE_Bx + SIZE_A)
+#define SIZE_sJ		(SIZE_Bx + SIZE_A - 1)
 
-#define SIZE_OP		6
+#define SIZE_OP		7
 
 #define POS_OP		0
+
 #define POS_A		(POS_OP + SIZE_OP)
-#define POS_C		(POS_A + SIZE_A)
-#define POS_B		(POS_C + SIZE_C)
-#define POS_Bx		POS_C
+#define POS_k		(POS_A + SIZE_A)
+#define POS_B		(POS_k + 1)
+#define POS_C		(POS_B + SIZE_B)
+
+#define POS_Bx		POS_k
+
 #define POS_Ax		POS_A
 
+#define POS_m		POS_A
+#define POS_sJ		(POS_A + 1)
 
 /*
 ** limits for opcode arguments.
@@ -57,23 +64,34 @@ enum OpMode {iABC, iABx, iAsBx, iAx};  /* basic instruction format */
 ** so they must fit in LUAI_BITSINT-1 bits (-1 for sign)
 */
 #if SIZE_Bx < LUAI_BITSINT-1
-#define MAXARG_Bx        ((1<<SIZE_Bx)-1)
-#define MAXARG_sBx        (MAXARG_Bx>>1)         /* 'sBx' is signed */
+#define MAXARG_Bx	((1<<SIZE_Bx)-1)
 #else
-#define MAXARG_Bx        MAX_INT
-#define MAXARG_sBx        MAX_INT
+#define MAXARG_Bx	MAX_INT
 #endif
 
+#define OFFSET_sBx	(MAXARG_Bx>>1)         /* 'sBx' is signed */
+
+
 #if SIZE_Ax < LUAI_BITSINT-1
 #define MAXARG_Ax	((1<<SIZE_Ax)-1)
 #else
 #define MAXARG_Ax	MAX_INT
 #endif
 
+#if SIZE_sJ < LUAI_BITSINT-1
+#define MAXARG_sJ	((1 << SIZE_sJ) - 1)
+#else
+#define MAXARG_sJ	MAX_INT
+#endif
 
-#define MAXARG_A        ((1<<SIZE_A)-1)
-#define MAXARG_B        ((1<<SIZE_B)-1)
-#define MAXARG_C        ((1<<SIZE_C)-1)
+#define OFFSET_sJ	(MAXARG_sJ >> 1)
+
+
+#define MAXARG_A	((1<<SIZE_A)-1)
+#define MAXARG_B	((1<<SIZE_B)-1)
+#define MAXARG_C	((1<<SIZE_C)-1)
+#define OFFSET_sC	(MAXARG_C >> 1)
+#define MAXARG_Cx	((1<<(SIZE_C + 1))-1)
 
 
 /* creates a mask with 'n' 1 bits at position 'p' */
@@ -90,33 +108,51 @@ enum OpMode {iABC, iABx, iAsBx, iAx};  /* basic instruction format */
 #define SET_OPCODE(i,o)	((i) = (((i)&MASK0(SIZE_OP,POS_OP)) | \
 		((cast(Instruction, o)<<POS_OP)&MASK1(SIZE_OP,POS_OP))))
 
-#define getarg(i,pos,size)	(cast(int, ((i)>>pos) & MASK1(size,0)))
+#define checkopm(i,m)	(getOpMode(GET_OPCODE(i)) == m)
+
+
+#define getarg(i,pos,size)	(cast_int(((i)>>(pos)) & MASK1(size,0)))
 #define setarg(i,v,pos,size)	((i) = (((i)&MASK0(size,pos)) | \
                 ((cast(Instruction, v)<<pos)&MASK1(size,pos))))
 
 #define GETARG_A(i)	getarg(i, POS_A, SIZE_A)
 #define SETARG_A(i,v)	setarg(i, v, POS_A, SIZE_A)
 
-#define GETARG_B(i)	getarg(i, POS_B, SIZE_B)
+#define GETARG_B(i)	check_exp(checkopm(i, iABC), getarg(i, POS_B, SIZE_B))
+#define GETARG_sB(i)	(GETARG_B(i) - OFFSET_sC)
 #define SETARG_B(i,v)	setarg(i, v, POS_B, SIZE_B)
 
-#define GETARG_C(i)	getarg(i, POS_C, SIZE_C)
+#define GETARG_C(i)	check_exp(checkopm(i, iABC), getarg(i, POS_C, SIZE_C))
+#define GETARG_sC(i)	(GETARG_C(i) - OFFSET_sC)
 #define SETARG_C(i,v)	setarg(i, v, POS_C, SIZE_C)
 
-#define GETARG_Bx(i)	getarg(i, POS_Bx, SIZE_Bx)
+#define TESTARG_k(i)	(cast_int(((i) & (1u << POS_k))))
+#define GETARG_k(i)	check_exp(checkopm(i, iABC), getarg(i, POS_k, 1))
+#define SETARG_k(i,v)	setarg(i, v, POS_k, 1)
+
+#define GETARG_Bx(i)	check_exp(checkopm(i, iABx), getarg(i, POS_Bx, SIZE_Bx))
 #define SETARG_Bx(i,v)	setarg(i, v, POS_Bx, SIZE_Bx)
 
-#define GETARG_Ax(i)	getarg(i, POS_Ax, SIZE_Ax)
+#define GETARG_Ax(i)	check_exp(checkopm(i, iAx), getarg(i, POS_Ax, SIZE_Ax))
 #define SETARG_Ax(i,v)	setarg(i, v, POS_Ax, SIZE_Ax)
 
-#define GETARG_sBx(i)	(GETARG_Bx(i)-MAXARG_sBx)
-#define SETARG_sBx(i,b)	SETARG_Bx((i),cast(unsigned int, (b)+MAXARG_sBx))
+#define GETARG_sBx(i)  \
+	check_exp(checkopm(i, iAsBx), getarg(i, POS_Bx, SIZE_Bx) - OFFSET_sBx)
+#define SETARG_sBx(i,b)	SETARG_Bx((i),cast_uint((b)+OFFSET_sBx))
+
+#define GETARG_sJ(i)  \
+	check_exp(checkopm(i, isJ), getarg(i, POS_sJ, SIZE_sJ) - OFFSET_sJ)
+#define SETARG_sJ(i,j) \
+	setarg(i, cast_uint((j)+OFFSET_sJ), POS_sJ, SIZE_sJ)
+#define GETARG_m(i)	check_exp(checkopm(i, isJ), getarg(i, POS_m, 1))
+#define SETARG_m(i,m)	setarg(i, m, POS_m, 1)
 
 
-#define CREATE_ABC(o,a,b,c)	((cast(Instruction, o)<<POS_OP) \
+#define CREATE_ABCk(o,a,b,c,k)	((cast(Instruction, o)<<POS_OP) \
 			| (cast(Instruction, a)<<POS_A) \
 			| (cast(Instruction, b)<<POS_B) \
-			| (cast(Instruction, c)<<POS_C))
+			| (cast(Instruction, c)<<POS_C) \
+			| (cast(Instruction, k)<<POS_k))
 
 #define CREATE_ABx(o,a,bc)	((cast(Instruction, o)<<POS_OP) \
 			| (cast(Instruction, a)<<POS_A) \
@@ -125,27 +161,15 @@ enum OpMode {iABC, iABx, iAsBx, iAx};  /* basic instruction format */
 #define CREATE_Ax(o,a)		((cast(Instruction, o)<<POS_OP) \
 			| (cast(Instruction, a)<<POS_Ax))
 
+#define CREATE_sJ(o,j,k)	((cast(Instruction, o) << POS_OP) \
+			| (cast(Instruction, j) << POS_sJ) \
+			| (cast(Instruction, k) << POS_k))
 
-/*
-** Macros to operate RK indices
-*/
-
-/* this bit 1 means constant (0 means register) */
-#define BITRK		(1 << (SIZE_B - 1))
-
-/* test whether value is a constant */
-#define ISK(x)		((x) & BITRK)
-
-/* gets the index of the constant */
-#define INDEXK(r)	((int)(r) & ~BITRK)
 
 #if !defined(MAXINDEXRK)  /* (for debugging only) */
-#define MAXINDEXRK	(BITRK - 1)
+#define MAXINDEXRK	MAXARG_B
 #endif
 
-/* code a constant index as a RK value */
-#define RKASK(x)	((x) | BITRK)
-
 
 /*
 ** invalid register that fits in 8 bits
@@ -155,8 +179,8 @@ enum OpMode {iABC, iABx, iAsBx, iAx};  /* basic instruction format */
 
 /*
 ** R(x) - register
-** Kst(x) - constant (in constant table)
-** RK(x) == if ISK(x) then Kst(INDEXK(x)) else R(x)
+** K(x) - constant (in constant table)
+** RK(x) == if k(i) then K(x) else R(x)
 */
 
 
@@ -169,125 +193,172 @@ typedef enum {
 name		args	description
 ------------------------------------------------------------------------*/
 OP_MOVE,/*	A B	R(A) := R(B)					*/
-OP_LOADK,/*	A Bx	R(A) := Kst(Bx)					*/
-OP_LOADKX,/*	A 	R(A) := Kst(extra arg)				*/
+OP_LOADI,/*	A sBx	R(A) := sBx					*/
+OP_LOADF,/*	A sBx	R(A) := (lua_Number)sBx				*/
+OP_LOADK,/*	A Bx	R(A) := K(Bx)					*/
+OP_LOADKX,/*	A 	R(A) := K(extra arg)				*/
 OP_LOADBOOL,/*	A B C	R(A) := (Bool)B; if (C) pc++			*/
 OP_LOADNIL,/*	A B	R(A), R(A+1), ..., R(A+B) := nil		*/
 OP_GETUPVAL,/*	A B	R(A) := UpValue[B]				*/
-
-OP_GETTABUP,/*	A B C	R(A) := UpValue[B][RK(C)]			*/
-OP_GETTABLE,/*	A B C	R(A) := R(B)[RK(C)]				*/
-
-OP_SETTABUP,/*	A B C	UpValue[A][RK(B)] := RK(C)			*/
 OP_SETUPVAL,/*	A B	UpValue[B] := R(A)				*/
-OP_SETTABLE,/*	A B C	R(A)[RK(B)] := RK(C)				*/
+
+OP_GETTABUP,/*	A B C	R(A) := UpValue[B][K(C):string]			*/
+OP_GETTABLE,/*	A B C	R(A) := R(B)[R(C)]				*/
+OP_GETI,/*	A B C	R(A) := R(B)[C]					*/
+OP_GETFIELD,/*	A B C	R(A) := R(B)[K(C):string]			*/
+
+OP_SETTABUP,/*	A B C	UpValue[A][K(B):string] := RK(C)		*/
+OP_SETTABLE,/*	A B C	R(A)[R(B)] := RK(C)				*/
+OP_SETI,/*	A B C	R(A)[B] := RK(C)				*/
+OP_SETFIELD,/*	A B C	R(A)[K(B):string] := RK(C)			*/
 
 OP_NEWTABLE,/*	A B C	R(A) := {} (size = B,C)				*/
 
-OP_SELF,/*	A B C	R(A+1) := R(B); R(A) := R(B)[RK(C)]		*/
+OP_SELF,/*	A B C	R(A+1) := R(B); R(A) := R(B)[RK(C):string]	*/
 
-OP_ADD,/*	A B C	R(A) := RK(B) + RK(C)				*/
-OP_SUB,/*	A B C	R(A) := RK(B) - RK(C)				*/
-OP_MUL,/*	A B C	R(A) := RK(B) * RK(C)				*/
-OP_MOD,/*	A B C	R(A) := RK(B) % RK(C)				*/
-OP_POW,/*	A B C	R(A) := RK(B) ^ RK(C)				*/
-OP_DIV,/*	A B C	R(A) := RK(B) / RK(C)				*/
-OP_IDIV,/*	A B C	R(A) := RK(B) // RK(C)				*/
-OP_BAND,/*	A B C	R(A) := RK(B) & RK(C)				*/
-OP_BOR,/*	A B C	R(A) := RK(B) | RK(C)				*/
-OP_BXOR,/*	A B C	R(A) := RK(B) ~ RK(C)				*/
-OP_SHL,/*	A B C	R(A) := RK(B) << RK(C)				*/
-OP_SHR,/*	A B C	R(A) := RK(B) >> RK(C)				*/
+OP_ADDI,/*	A B sC	R(A) := R(B) + C				*/
+OP_SUBI,/*	A B sC	R(A) := R(B) - C				*/
+OP_MULI,/*	A B sC	R(A) := R(B) * C				*/
+OP_MODI,/*	A B sC	R(A) := R(B) % C				*/
+OP_POWI,/*	A B sC	R(A) := R(B) ^ C				*/
+OP_DIVI,/*	A B sC	R(A) := R(B) / C				*/
+OP_IDIVI,/*	A B sC	R(A) := R(B) // C				*/
+
+OP_BANDK,/*	A B C	R(A) := R(B) & K(C):integer			*/
+OP_BORK,/*	A B C	R(A) := R(B) | K(C):integer			*/
+OP_BXORK,/*	A B C	R(A) := R(B) ~ K(C):integer			*/
+
+OP_SHRI,/*	A B C	R(A) := R(B) >> C				*/
+OP_SHLI,/*	A B C	R(A) := C << R(B)				*/
+
+OP_ADD,/*	A B C	R(A) := R(B) + R(C)				*/
+OP_SUB,/*	A B C	R(A) := R(B) - R(C)				*/
+OP_MUL,/*	A B C	R(A) := R(B) * R(C)				*/
+OP_MOD,/*	A B C	R(A) := R(B) % R(C)				*/
+OP_POW,/*	A B C	R(A) := R(B) ^ R(C)				*/
+OP_DIV,/*	A B C	R(A) := R(B) / R(C)				*/
+OP_IDIV,/*	A B C	R(A) := R(B) // R(C)				*/
+OP_BAND,/*	A B C	R(A) := R(B) & R(C)				*/
+OP_BOR,/*	A B C	R(A) := R(B) | R(C)				*/
+OP_BXOR,/*	A B C	R(A) := R(B) ~ R(C)				*/
+OP_SHL,/*	A B C	R(A) := R(B) << R(C)				*/
+OP_SHR,/*	A B C	R(A) := R(B) >> R(C)				*/
 OP_UNM,/*	A B	R(A) := -R(B)					*/
 OP_BNOT,/*	A B	R(A) := ~R(B)					*/
 OP_NOT,/*	A B	R(A) := not R(B)				*/
 OP_LEN,/*	A B	R(A) := length of R(B)				*/
 
-OP_CONCAT,/*	A B C	R(A) := R(B).. ... ..R(C)			*/
+OP_CONCAT,/*	A B  	R(A) := R(A).. ... ..R(A + B - 1)		*/
 
-OP_JMP,/*	A sBx	pc+=sBx; if (A) close all upvalues >= R(A - 1)	*/
-OP_EQ,/*	A B C	if ((RK(B) == RK(C)) ~= A) then pc++		*/
-OP_LT,/*	A B C	if ((RK(B) <  RK(C)) ~= A) then pc++		*/
-OP_LE,/*	A B C	if ((RK(B) <= RK(C)) ~= A) then pc++		*/
+OP_CLOSE,/*	A	close all upvalues >= R(A)			*/
+OP_JMP,/*	k sJ	pc += sJ  (k is used in code generation)	*/
+OP_EQ,/*	A B	if ((R(A) == R(B)) ~= k) then pc++		*/
+OP_LT,/*	A B	if ((R(A) <  R(B)) ~= k) then pc++		*/
+OP_LE,/*	A B	if ((R(A) <= R(B)) ~= k) then pc++		*/
 
-OP_TEST,/*	A C	if not (R(A) <=> C) then pc++			*/
-OP_TESTSET,/*	A B C	if (R(B) <=> C) then R(A) := R(B) else pc++	*/
+OP_EQK,/*	A B	if ((R(A) == K(B)) ~= k) then pc++		*/
+OP_EQI,/*	A sB	if ((R(A) == sB) ~= k) then pc++		*/
+OP_LTI,/*	A sB	if ((R(A) < sB) ~= k) then pc++			*/
+OP_LEI,/*	A sB	if ((R(A) <= sB) ~= k) then pc++		*/
+OP_GTI,/*	A sB	if ((R(A) > sB) ~= k) then pc++			*/
+OP_GEI,/*	A sB	if ((R(A) >= sB) ~= k) then pc++		*/
+
+OP_TEST,/*	A 	if (not R(A) == k) then pc++			*/
+OP_TESTSET,/*	A B	if (not R(B) == k) then R(A) := R(B) else pc++	*/
 
 OP_CALL,/*	A B C	R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
 OP_TAILCALL,/*	A B C	return R(A)(R(A+1), ... ,R(A+B-1))		*/
-OP_RETURN,/*	A B	return R(A), ... ,R(A+B-2)	(see note)	*/
 
-OP_FORLOOP,/*	A sBx	R(A)+=R(A+2);
-			if R(A) <?= R(A+1) then { pc+=sBx; R(A+3)=R(A) }*/
-OP_FORPREP,/*	A sBx	R(A)-=R(A+2); pc+=sBx				*/
+OP_RETURN,/*	A B C	return R(A), ... ,R(A+B-2)	(see note)	*/
+OP_RETURN0,/*	  	return 						*/
+OP_RETURN1,/*	A 	return R(A)					*/
+
+OP_FORLOOP1,/*	A Bx	R(A)++;
+			if R(A) <= R(A+1) then { pc-=Bx; R(A+3)=R(A) }	*/
+OP_FORPREP1,/*	A Bx	R(A)--; pc+=Bx					*/
+
+OP_FORLOOP,/*	A Bx	R(A)+=R(A+2);
+			if R(A) <?= R(A+1) then { pc-=Bx; R(A+3)=R(A) }	*/
+OP_FORPREP,/*	A Bx	R(A)-=R(A+2); pc+=Bx				*/
 
 OP_TFORCALL,/*	A C	R(A+3), ... ,R(A+2+C) := R(A)(R(A+1), R(A+2));	*/
-OP_TFORLOOP,/*	A sBx	if R(A+1) ~= nil then { R(A)=R(A+1); pc += sBx }*/
+OP_TFORLOOP,/*	A Bx	if R(A+1) ~= nil then { R(A)=R(A+1); pc -= Bx }	*/
 
 OP_SETLIST,/*	A B C	R(A)[(C-1)*FPF+i] := R(A+i), 1 <= i <= B	*/
 
 OP_CLOSURE,/*	A Bx	R(A) := closure(KPROTO[Bx])			*/
 
-OP_VARARG,/*	A B	R(A), R(A+1), ..., R(A+B-2) = vararg		*/
+OP_VARARG,/*	A C  	R(A), R(A+1), ..., R(A+C-2) = vararg		*/
+
+OP_PREPVARARG,/*A 	(adjust vararg parameters)			*/
 
 OP_EXTRAARG/*	Ax	extra (larger) argument for previous opcode	*/
 } OpCode;
 
 
-#define NUM_OPCODES	(cast(int, OP_EXTRAARG) + 1)
+#define NUM_OPCODES	(cast_int(OP_EXTRAARG) + 1)
 
 
 
 /*===========================================================================
   Notes:
   (*) In OP_CALL, if (B == 0) then B = top. If (C == 0), then 'top' is
-  set to last_result+1, so next open instruction (OP_CALL, OP_RETURN,
+  set to last_result+1, so next open instruction (OP_CALL, OP_RETURN*,
   OP_SETLIST) may use 'top'.
 
-  (*) In OP_VARARG, if (B == 0) then use actual number of varargs and
+  (*) In OP_VARARG, if (C == 0) then use actual number of varargs and
   set top (like in OP_CALL with C == 0).
 
   (*) In OP_RETURN, if (B == 0) then return up to 'top'.
 
-  (*) In OP_SETLIST, if (B == 0) then B = 'top'; if (C == 0) then next
-  'instruction' is EXTRAARG(real C).
+  (*) In OP_SETLIST, if (B == 0) then real B = 'top'; if (C == 0) then
+  next 'instruction' is EXTRAARG(real C).
 
   (*) In OP_LOADKX, the next 'instruction' is always EXTRAARG.
 
-  (*) For comparisons, A specifies what condition the test should accept
+  (*) For comparisons, k specifies what condition the test should accept
   (true or false).
 
   (*) All 'skips' (pc++) assume that next instruction is a jump.
 
+  (*) In instructions OP_RETURN/OP_TAILCALL, 'k' specifies that the
+  function either builds upvalues, which may need to be closed, or is
+  vararg, which must be corrected before returning. When 'k' is true,
+  C > 0 means the function is vararg and (C - 1) is its number of
+  fixed parameters.
+
 ===========================================================================*/
 
 
 /*
 ** masks for instruction properties. The format is:
-** bits 0-1: op mode
-** bits 2-3: C arg mode
-** bits 4-5: B arg mode
-** bit 6: instruction set register A
-** bit 7: operator is a test (next instruction must be a jump)
+** bits 0-2: op mode
+** bit 3: instruction set register A
+** bit 4: operator is a test (next instruction must be a jump)
+** bit 5: instruction uses 'L->top' set by previous instruction (when B == 0)
+** bit 6: instruction sets 'L->top' for next instruction (when C == 0)
 */
 
-enum OpArgMask {
-  OpArgN,  /* argument is not used */
-  OpArgU,  /* argument is used */
-  OpArgR,  /* argument is a register or a jump offset */
-  OpArgK   /* argument is a constant or register/constant */
-};
+LUAI_DDEC(const lu_byte luaP_opmodes[NUM_OPCODES];)
 
-LUAI_DDEC const lu_byte luaP_opmodes[NUM_OPCODES];
+#define getOpMode(m)	(cast(enum OpMode, luaP_opmodes[m] & 7))
+#define testAMode(m)	(luaP_opmodes[m] & (1 << 3))
+#define testTMode(m)	(luaP_opmodes[m] & (1 << 4))
+#define testITMode(m)	(luaP_opmodes[m] & (1 << 5))
+#define testOTMode(m)	(luaP_opmodes[m] & (1 << 6))
 
-#define getOpMode(m)	(cast(enum OpMode, luaP_opmodes[m] & 3))
-#define getBMode(m)	(cast(enum OpArgMask, (luaP_opmodes[m] >> 4) & 3))
-#define getCMode(m)	(cast(enum OpArgMask, (luaP_opmodes[m] >> 2) & 3))
-#define testAMode(m)	(luaP_opmodes[m] & (1 << 6))
-#define testTMode(m)	(luaP_opmodes[m] & (1 << 7))
+/* "out top" (set top for next instruction) */
+#define isOT(i)  \
+	((testOTMode(GET_OPCODE(i)) && GETARG_C(i) == 0) || \
+          GET_OPCODE(i) == OP_TAILCALL)
+
+/* "in top" (uses top from previous instruction) */
+#define isIT(i)		(testITMode(GET_OPCODE(i)) && GETARG_B(i) == 0)
+
+#define opmode(ot,it,t,a,m) (((ot)<<6) | ((it)<<5) | ((t)<<4) | ((a)<<3) | (m))
 
 
-LUAI_DDEC const char *const luaP_opnames[NUM_OPCODES+1];  /* opcode names */
+LUAI_DDEC(const char *const luaP_opnames[NUM_OPCODES+1];)  /* opcode names */
 
 
 /* number of list items to accumulate before a SETLIST instruction */

loslib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: loslib.c,v 1.65.1.1 2017/04/19 17:29:57 roberto Exp $
+** $Id: loslib.c,v 1.65 2016/07/18 17:58:58 roberto Exp roberto $
 ** Standard Operating System library
 ** See Copyright Notice in lua.h
 */

lparser.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.c,v 2.155.1.2 2017/04/29 18:11:40 roberto Exp $
+** $Id: lparser.c,v 2.180 2018/04/04 14:23:41 roberto Exp roberto $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
@@ -49,6 +49,8 @@ typedef struct BlockCnt {
   struct BlockCnt *previous;  /* chain */
   int firstlabel;  /* index of first label in this block */
   int firstgoto;  /* index of first pending goto in this block */
+  int brks;  /* list of break jumps in this block */
+  lu_byte brkcls;  /* true if some 'break' needs to close upvalues */
   lu_byte nactvar;  /* # active locals outside the block */
   lu_byte upval;  /* true if some variable in the block is an upvalue */
   lu_byte isloop;  /* true if 'block' is a loop */
@@ -63,13 +65,6 @@ static void statement (LexState *ls);
 static void expr (LexState *ls, expdesc *v);
 
 
-/* semantic error */
-static l_noret semerror (LexState *ls, const char *msg) {
-  ls->t.token = 0;  /* remove "near <token>" from final message */
-  luaX_syntaxerror(ls, msg);
-}
-
-
 static l_noret error_expected (LexState *ls, int token) {
   luaX_syntaxerror(ls,
       luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token)));
@@ -328,11 +323,7 @@ static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
 }
 
 
-static void enterlevel (LexState *ls) {
-  lua_State *L = ls->L;
-  ++L->nCcalls;
-  checklimit(ls->fs, L->nCcalls, LUAI_MAXCCALLS, "C levels");
-}
+#define enterlevel(ls)	luaE_incCcalls((ls)->L)
 
 
 #define leavelevel(ls)	((ls)->L->nCcalls--)
@@ -349,9 +340,9 @@ static void closegoto (LexState *ls, int g, Labeldesc *label) {
     const char *msg = luaO_pushfstring(ls->L,
       "<goto %s> at line %d jumps into the scope of local '%s'",
       getstr(gt->name), gt->line, getstr(vname));
-    semerror(ls, msg);
+    luaK_semerror(ls, msg);
   }
-  luaK_patchlist(fs, gt->pc, label->pc);
+  luaK_patchgoto(fs, gt->pc, label->pc, 1);
   /* remove goto from pending list */
   for (i = g; i < gl->n - 1; i++)
     gl->arr[i] = gl->arr[i + 1];
@@ -362,7 +353,7 @@ static void closegoto (LexState *ls, int g, Labeldesc *label) {
 /*
 ** try to close a goto with existing labels; this solves backward jumps
 */
-static int findlabel (LexState *ls, int g) {
+static int solvelabel (LexState *ls, int g) {
   int i;
   BlockCnt *bl = ls->fs->bl;
   Dyndata *dyd = ls->dyd;
@@ -373,7 +364,7 @@ static int findlabel (LexState *ls, int g) {
     if (eqstr(lb->name, gt->name)) {  /* correct label? */
       if (gt->nactvar > lb->nactvar &&
           (bl->upval || dyd->label.n > bl->firstlabel))
-        luaK_patchclose(ls->fs, gt->pc, lb->nactvar);
+        luaK_patchclose(ls->fs, gt->pc);
       closegoto(ls, g, lb);  /* close it */
       return 1;
     }
@@ -400,12 +391,12 @@ static int newlabelentry (LexState *ls, Labellist *l, TString *name,
 ** check whether new label 'lb' matches any pending gotos in current
 ** block; solves forward jumps
 */
-static void findgotos (LexState *ls, Labeldesc *lb) {
+static void solvegotos (LexState *ls, Labeldesc *lb) {
   Labellist *gl = &ls->dyd->gt;
   int i = ls->fs->bl->firstgoto;
   while (i < gl->n) {
     if (eqstr(gl->arr[i].name, lb->name))
-      closegoto(ls, i, lb);
+      closegoto(ls, i, lb);  /* will remove 'i' from the list */
     else
       i++;
   }
@@ -416,23 +407,32 @@ static void findgotos (LexState *ls, Labeldesc *lb) {
 ** export pending gotos to outer level, to check them against
 ** outer labels; if the block being exited has upvalues, and
 ** the goto exits the scope of any variable (which can be the
-** upvalue), close those variables being exited.
+** upvalue), close those variables being exited. Also export
+** break list.
 */
 static void movegotosout (FuncState *fs, BlockCnt *bl) {
   int i = bl->firstgoto;
   Labellist *gl = &fs->ls->dyd->gt;
   /* correct pending gotos to current block and try to close it
      with visible labels */
-  while (i < gl->n) {
+  while (i < gl->n) {  /* for each pending goto */
     Labeldesc *gt = &gl->arr[i];
-    if (gt->nactvar > bl->nactvar) {
-      if (bl->upval)
-        luaK_patchclose(fs, gt->pc, bl->nactvar);
-      gt->nactvar = bl->nactvar;
+    if (gt->nactvar > bl->nactvar) {  /* leaving a variable scope? */
+      if (bl->upval)  /* variable may be an upvalue? */
+        luaK_patchclose(fs, gt->pc);  /* jump will need a close */
+      gt->nactvar = bl->nactvar;  /* update goto level */
     }
-    if (!findlabel(fs->ls, i))
+    if (!solvelabel(fs->ls, i))
       i++;  /* move to next one */
+    /* else, 'solvelabel' removed current goto from the list
+       and 'i' now points to next one */
   }
+  /* handles break list */
+  if (bl->upval)  /* exiting the scope of an upvalue? */
+    luaK_patchclose(fs, bl->brks);  /* breaks will need OP_CLOSE */
+  /* move breaks to outer block */
+  luaK_concat(fs, &bl->previous->brks, bl->brks);
+  bl->previous->brkcls |= bl->brkcls;
 }
 
 
@@ -441,6 +441,8 @@ static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) {
   bl->nactvar = fs->nactvar;
   bl->firstlabel = fs->ls->dyd->label.n;
   bl->firstgoto = fs->ls->dyd->gt.n;
+  bl->brks = NO_JUMP;
+  bl->brkcls = 0;
   bl->upval = 0;
   bl->previous = fs->bl;
   fs->bl = bl;
@@ -449,38 +451,38 @@ static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) {
 
 
 /*
-** create a label named 'break' to resolve break statements
+** Fix all breaks in block 'bl' to jump to the end of the block.
 */
-static void breaklabel (LexState *ls) {
-  TString *n = luaS_new(ls->L, "break");
-  int l = newlabelentry(ls, &ls->dyd->label, n, 0, ls->fs->pc);
-  findgotos(ls, &ls->dyd->label.arr[l]);
+static void fixbreaks (FuncState *fs, BlockCnt *bl) {
+  int target = fs->pc;
+  if (bl->brkcls)  /* does the block need to close upvalues? */
+    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
+  luaK_patchgoto(fs, bl->brks, target, bl->brkcls);
+  bl->brks = NO_JUMP;  /* no more breaks to fix */
+  bl->brkcls = 0;  /* no more need to close upvalues */
+  lua_assert(!bl->upval);  /* loop body cannot have local variables */
 }
 
+
 /*
-** generates an error for an undefined 'goto'; choose appropriate
-** message when label name is a reserved word (which can only be 'break')
+** generates an error for an undefined 'goto'.
 */
 static l_noret undefgoto (LexState *ls, Labeldesc *gt) {
-  const char *msg = isreserved(gt->name)
-                    ? "<%s> at line %d not inside a loop"
-                    : "no visible label '%s' for <goto> at line %d";
+  const char *msg = "no visible label '%s' for <goto> at line %d";
   msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line);
-  semerror(ls, msg);
+  luaK_semerror(ls, msg);
 }
 
 
 static void leaveblock (FuncState *fs) {
   BlockCnt *bl = fs->bl;
   LexState *ls = fs->ls;
-  if (bl->previous && bl->upval) {
-    /* create a 'jump to here' to close upvalues */
-    int j = luaK_jump(fs);
-    luaK_patchclose(fs, j, bl->nactvar);
-    luaK_patchtohere(fs, j);
-  }
+  if (bl->upval && bl->brks != NO_JUMP)  /* breaks in upvalue scopes? */
+    bl->brkcls = 1;  /* these breaks must close the upvalues */
   if (bl->isloop)
-    breaklabel(ls);  /* close pending breaks */
+    fixbreaks(fs, bl);  /* fix pending breaks */
+  if (bl->previous && bl->upval)
+    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
   fs->bl = bl->previous;
   removevars(fs, bl->nactvar);
   lua_assert(bl->nactvar == fs->nactvar);
@@ -488,8 +490,11 @@ static void leaveblock (FuncState *fs) {
   ls->dyd->label.n = bl->firstlabel;  /* remove local labels */
   if (bl->previous)  /* inner block? */
     movegotosout(fs, bl);  /* update pending gotos to outer block */
-  else if (bl->firstgoto < ls->dyd->gt.n)  /* pending gotos in outer block? */
-    undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]);  /* error */
+  else {
+    lua_assert(bl->brks == NO_JUMP);  /* no pending breaks */
+    if (bl->firstgoto < ls->dyd->gt.n)  /* pending gotos in outer block? */
+      undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]);  /* error */
+  }
 }
 
 
@@ -521,30 +526,30 @@ static Proto *addprototype (LexState *ls) {
 */
 static void codeclosure (LexState *ls, expdesc *v) {
   FuncState *fs = ls->fs->prev;
-  init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1));
+  init_exp(v, VRELOC, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1));
   luaK_exp2nextreg(fs, v);  /* fix it at the last register */
 }
 
 
 static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {
-  Proto *f;
+  Proto *f = fs->f;
   fs->prev = ls->fs;  /* linked list of funcstates */
   fs->ls = ls;
   ls->fs = fs;
   fs->pc = 0;
+  fs->previousline = f->linedefined;
+  fs->iwthabs = 0;
   fs->lasttarget = 0;
-  fs->jpc = NO_JUMP;
   fs->freereg = 0;
   fs->nk = 0;
+  fs->nabslineinfo = 0;
   fs->np = 0;
   fs->nups = 0;
   fs->nlocvars = 0;
   fs->nactvar = 0;
   fs->firstlocal = ls->dyd->actvar.n;
   fs->bl = NULL;
-  f = fs->f;
   f->source = ls->source;
-  luaC_objbarrier(ls->L, f, f->source);
   f->maxstacksize = 2;  /* registers 0/1 are always valid */
   enterblock(fs, bl, 0);
 }
@@ -556,19 +561,16 @@ static void close_func (LexState *ls) {
   Proto *f = fs->f;
   luaK_ret(fs, 0, 0);  /* final return */
   leaveblock(fs);
-  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
-  f->sizecode = fs->pc;
-  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
-  f->sizelineinfo = fs->pc;
-  luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
-  f->sizek = fs->nk;
-  luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
-  f->sizep = fs->np;
-  luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
-  f->sizelocvars = fs->nlocvars;
-  luaM_reallocvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc);
-  f->sizeupvalues = fs->nups;
   lua_assert(fs->bl == NULL);
+  luaK_finish(fs);
+  luaM_shrinkvector(L, f->code, f->sizecode, fs->pc, Instruction);
+  luaM_shrinkvector(L, f->lineinfo, f->sizelineinfo, fs->pc, ls_byte);
+  luaM_shrinkvector(L, f->abslineinfo, f->sizeabslineinfo,
+                       fs->nabslineinfo, AbsLineInfo);
+  luaM_shrinkvector(L, f->k, f->sizek, fs->nk, TValue);
+  luaM_shrinkvector(L, f->p, f->sizep, fs->np, Proto *);
+  luaM_shrinkvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
+  luaM_shrinkvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc);
   ls->fs = fs->prev;
   luaC_checkGC(L);
 }
@@ -645,11 +647,10 @@ struct ConsControl {
 
 
 static void recfield (LexState *ls, struct ConsControl *cc) {
-  /* recfield -> (NAME | '['exp1']') = exp1 */
+  /* recfield -> (NAME | '['exp']') = exp */
   FuncState *fs = ls->fs;
   int reg = ls->fs->freereg;
-  expdesc key, val;
-  int rkkey;
+  expdesc tab, key, val;
   if (ls->t.token == TK_NAME) {
     checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
     checkname(ls, &key);
@@ -658,9 +659,10 @@ static void recfield (LexState *ls, struct ConsControl *cc) {
     yindex(ls, &key);
   cc->nh++;
   checknext(ls, '=');
-  rkkey = luaK_exp2RK(fs, &key);
+  tab = *cc->t;
+  luaK_indexed(fs, &tab, &key);
   expr(ls, &val);
-  luaK_codeABC(fs, OP_SETTABLE, cc->t->u.info, rkkey, luaK_exp2RK(fs, &val));
+  luaK_storevar(fs, &tab, &val);
   fs->freereg = reg;  /* free registers */
 }
 
@@ -731,7 +733,7 @@ static void constructor (LexState *ls, expdesc *t) {
   struct ConsControl cc;
   cc.na = cc.nh = cc.tostore = 0;
   cc.t = t;
-  init_exp(t, VRELOCABLE, pc);
+  init_exp(t, VRELOC, pc);
   init_exp(&cc.v, VVOID, 0);  /* no value (yet) */
   luaK_exp2nextreg(ls->fs, t);  /* fix it at stack top */
   checknext(ls, '{');
@@ -750,13 +752,18 @@ static void constructor (LexState *ls, expdesc *t) {
 /* }====================================================================== */
 
 
+static void setvararg (FuncState *fs, int nparams) {
+  fs->f->is_vararg = 1;
+  luaK_codeABC(fs, OP_PREPVARARG, nparams, 0, 0);
+}
+
 
 static void parlist (LexState *ls) {
   /* parlist -> [ param { ',' param } ] */
   FuncState *fs = ls->fs;
   Proto *f = fs->f;
   int nparams = 0;
-  f->is_vararg = 0;
+  int isvararg = 0;
   if (ls->t.token != ')') {  /* is 'parlist' not empty? */
     do {
       switch (ls->t.token) {
@@ -767,16 +774,18 @@ static void parlist (LexState *ls) {
         }
         case TK_DOTS: {  /* param -> '...' */
           luaX_next(ls);
-          f->is_vararg = 1;  /* declared vararg */
+          isvararg = 1;
           break;
         }
         default: luaX_syntaxerror(ls, "<name> or '...' expected");
       }
-    } while (!f->is_vararg && testnext(ls, ','));
+    } while (!isvararg && testnext(ls, ','));
   }
   adjustlocalvars(ls, nparams);
   f->numparams = cast_byte(fs->nactvar);
-  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */
+  if (isvararg)
+    setvararg(fs, f->numparams);  /* declared vararg */
+  luaK_reserveregs(fs, fs->nactvar);  /* reserve registers for parameters */
 }
 
 
@@ -903,7 +912,7 @@ static void suffixedexp (LexState *ls, expdesc *v) {
         fieldsel(ls, v);
         break;
       }
-      case '[': {  /* '[' exp1 ']' */
+      case '[': {  /* '[' exp ']' */
         expdesc key;
         luaK_exp2anyregup(fs, v);
         yindex(ls, &key);
@@ -963,7 +972,7 @@ static void simpleexp (LexState *ls, expdesc *v) {
       FuncState *fs = ls->fs;
       check_condition(ls, fs->f->is_vararg,
                       "cannot use '...' outside a vararg function");
-      init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
+      init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 0, 1));
       break;
     }
     case '{': {  /* constructor */
@@ -1122,17 +1131,25 @@ static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
   int extra = fs->freereg;  /* eventual position to save local variable */
   int conflict = 0;
   for (; lh; lh = lh->prev) {  /* check all previous assignments */
-    if (lh->v.k == VINDEXED) {  /* assigning to a table? */
-      /* table is the upvalue/local being assigned now? */
-      if (lh->v.u.ind.vt == v->k && lh->v.u.ind.t == v->u.info) {
-        conflict = 1;
-        lh->v.u.ind.vt = VLOCAL;
-        lh->v.u.ind.t = extra;  /* previous assignment will use safe copy */
+    if (vkisindexed(lh->v.k)) {  /* assignment to table field? */
+      if (lh->v.k == VINDEXUP) {  /* is table an upvalue? */
+        if (v->k == VUPVAL && lh->v.u.ind.t == v->u.info) {
+          conflict = 1;  /* table is the upvalue being assigned now */
+          lh->v.k = VINDEXSTR;
+          lh->v.u.ind.t = extra;  /* assignment will use safe copy */
+        }
       }
-      /* index is the local being assigned? (index cannot be upvalue) */
-      if (v->k == VLOCAL && lh->v.u.ind.idx == v->u.info) {
-        conflict = 1;
-        lh->v.u.ind.idx = extra;  /* previous assignment will use safe copy */
+      else {  /* table is a register */
+        if (v->k == VLOCAL && lh->v.u.ind.t == v->u.info) {
+          conflict = 1;  /* table is the local being assigned now */
+          lh->v.u.ind.t = extra;  /* assignment will use safe copy */
+        }
+        /* is index the local being assigned? */
+        if (lh->v.k == VINDEXED && v->k == VLOCAL &&
+            lh->v.u.ind.idx == v->u.info) {
+          conflict = 1;
+          lh->v.u.ind.idx = extra;  /* previous assignment will use safe copy */
+        }
       }
     }
   }
@@ -1152,11 +1169,11 @@ static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
     struct LHS_assign nv;
     nv.prev = lh;
     suffixedexp(ls, &nv.v);
-    if (nv.v.k != VINDEXED)
+    if (!vkisindexed(nv.v.k))
       check_conflict(ls, lh, &nv.v);
-    checklimit(ls->fs, nvars + ls->L->nCcalls, LUAI_MAXCCALLS,
-                    "C levels");
+    luaE_incCcalls(ls->L);  /* control recursion depth */
     assignment(ls, &nv, nvars+1);
+    ls->L->nCcalls--;
   }
   else {  /* assignment -> '=' explist */
     int nexps;
@@ -1187,16 +1204,21 @@ static int cond (LexState *ls) {
 
 static void gotostat (LexState *ls, int pc) {
   int line = ls->linenumber;
-  TString *label;
   int g;
-  if (testnext(ls, TK_GOTO))
-    label = str_checkname(ls);
-  else {
-    luaX_next(ls);  /* skip break */
-    label = luaS_new(ls->L, "break");
-  }
-  g = newlabelentry(ls, &ls->dyd->gt, label, line, pc);
-  findlabel(ls, g);  /* close it if label already defined */
+  luaX_next(ls);  /* skip 'goto' */
+  g = newlabelentry(ls, &ls->dyd->gt, str_checkname(ls), line, pc);
+  solvelabel(ls, g);  /* close it if label already defined */
+}
+
+
+static void breakstat (LexState *ls, int pc) {
+  FuncState *fs = ls->fs;
+  BlockCnt *bl = fs->bl;
+  luaX_next(ls);  /* skip break */
+  while (bl && !bl->isloop) { bl = bl->previous; }
+  if (!bl)
+    luaX_syntaxerror(ls, "no loop to break");
+  luaK_concat(fs, &fs->bl->brks, pc);
 }
 
 
@@ -1208,7 +1230,7 @@ static void checkrepeated (FuncState *fs, Labellist *ll, TString *label) {
       const char *msg = luaO_pushfstring(fs->ls->L,
                           "label '%s' already defined on line %d",
                           getstr(label), ll->arr[i].line);
-      semerror(fs->ls, msg);
+      luaK_semerror(fs->ls, msg);
     }
   }
 }
@@ -1230,12 +1252,13 @@ static void labelstat (LexState *ls, TString *label, int line) {
   checknext(ls, TK_DBCOLON);  /* skip double colon */
   /* create new entry for this label */
   l = newlabelentry(ls, ll, label, line, luaK_getlabel(fs));
+  luaK_codeABC(fs, OP_CLOSE, fs->nactvar, 0, 0);
   skipnoopstat(ls);  /* skip other no-op statements */
   if (block_follow(ls, 0)) {  /* label is last no-op statement in the block? */
     /* assume that locals are already out of scope */
     ll->arr[l].nactvar = fs->bl->nactvar;
   }
-  findgotos(ls, &ll->arr[l]);
+  solvegotos(ls, &ll->arr[l]);
 }
 
 
@@ -1271,69 +1294,112 @@ static void repeatstat (LexState *ls, int line) {
   check_match(ls, TK_UNTIL, TK_REPEAT, line);
   condexit = cond(ls);  /* read condition (inside scope block) */
   if (bl2.upval)  /* upvalues? */
-    luaK_patchclose(fs, condexit, bl2.nactvar);
+    luaK_patchclose(fs, condexit);
   leaveblock(fs);  /* finish scope */
+  if (bl2.upval) {  /* upvalues? */
+    int exit = luaK_jump(fs);  /* normal exit must jump over fix */
+    luaK_patchtohere(fs, condexit);  /* repetition must close upvalues */
+    luaK_codeABC(fs, OP_CLOSE, bl2.nactvar, 0, 0);
+    condexit = luaK_jump(fs);  /* repeat after closing upvalues */
+    luaK_patchtohere(fs, exit);  /* normal exit comes to here */
+  }
   luaK_patchlist(fs, condexit, repeat_init);  /* close the loop */
   leaveblock(fs);  /* finish loop */
 }
 
 
-static int exp1 (LexState *ls) {
+/*
+** Read an expression and generate code to put its results in next
+** stack slot. Return true if expression is a constant integer and,
+** if 'i' is not-zero, its value is equal to 'i'.
+**
+*/
+static int exp1 (LexState *ls, int i) {
   expdesc e;
-  int reg;
+  int res;
   expr(ls, &e);
+  res = luaK_isKint(&e) && (i == 0 || i == e.u.ival);
   luaK_exp2nextreg(ls->fs, &e);
   lua_assert(e.k == VNONRELOC);
-  reg = e.u.info;
-  return reg;
+  return res;
 }
 
 
-static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
+/*
+** Fix for instruction at position 'pc' to jump to 'dest'.
+** (Jump addresses are relative in Lua). 'back' true means
+** a back jump.
+*/
+static void fixforjump (FuncState *fs, int pc, int dest, int back) {
+  Instruction *jmp = &fs->f->code[pc];
+  int offset = dest - (pc + 1);
+  if (back)
+    offset = -offset;
+  if (offset > MAXARG_Bx)
+    luaX_syntaxerror(fs->ls, "control structure too long");
+  SETARG_Bx(*jmp, offset);
+}
+
+
+/*
+** Generate code for a 'for' loop. 'kind' can be zero (a common for
+** loop), one (a basic for loop, with integer values and increment of
+** 1), or two (a generic for loop).
+*/
+static void forbody (LexState *ls, int base, int line, int nvars, int kind) {
   /* forbody -> DO block */
   BlockCnt bl;
   FuncState *fs = ls->fs;
   int prep, endfor;
   adjustlocalvars(ls, 3);  /* control variables */
   checknext(ls, TK_DO);
-  prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
+  prep = (kind == 0) ? luaK_codeABx(fs, OP_FORPREP, base, 0)
+       : (kind == 1) ? luaK_codeABx(fs, OP_FORPREP1, base, 0)
+       : luaK_jump(fs);
   enterblock(fs, &bl, 0);  /* scope for declared variables */
   adjustlocalvars(ls, nvars);
   luaK_reserveregs(fs, nvars);
   block(ls);
   leaveblock(fs);  /* end of scope for declared variables */
-  luaK_patchtohere(fs, prep);
-  if (isnum)  /* numeric for? */
-    endfor = luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP);
-  else {  /* generic for */
+  if (kind == 2) {  /* generic for? */
+    luaK_patchtohere(fs, prep);
     luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars);
     luaK_fixline(fs, line);
-    endfor = luaK_codeAsBx(fs, OP_TFORLOOP, base + 2, NO_JUMP);
+    endfor = luaK_codeABx(fs, OP_TFORLOOP, base + 2, 0);
   }
-  luaK_patchlist(fs, endfor, prep + 1);
+  else {
+    fixforjump(fs, prep, luaK_getlabel(fs), 0);
+    endfor = (kind == 0) ? luaK_codeABx(fs, OP_FORLOOP, base, 0)
+                         : luaK_codeABx(fs, OP_FORLOOP1, base, 0);
+  }
+  fixforjump(fs, endfor, prep + 1, 1);
   luaK_fixline(fs, line);
 }
 
 
 static void fornum (LexState *ls, TString *varname, int line) {
-  /* fornum -> NAME = exp1,exp1[,exp1] forbody */
+  /* fornum -> NAME = exp,exp[,exp] forbody */
   FuncState *fs = ls->fs;
   int base = fs->freereg;
+  int basicfor = 1;  /* true if it is a "basic" 'for' (integer + 1) */
   new_localvarliteral(ls, "(for index)");
   new_localvarliteral(ls, "(for limit)");
   new_localvarliteral(ls, "(for step)");
   new_localvar(ls, varname);
   checknext(ls, '=');
-  exp1(ls);  /* initial value */
+  if (!exp1(ls, 0))  /* initial value not an integer? */
+    basicfor = 0;  /* not a basic 'for' */
   checknext(ls, ',');
-  exp1(ls);  /* limit */
-  if (testnext(ls, ','))
-    exp1(ls);  /* optional step */
+  exp1(ls, 0);  /* limit */
+  if (testnext(ls, ',')) {
+    if (!exp1(ls, 1))  /* optional step not 1? */
+      basicfor = 0;  /* not a basic 'for' */
+  }
   else {  /* default step = 1 */
-    luaK_codek(fs, fs->freereg, luaK_intK(fs, 1));
+    luaK_int(fs, fs->freereg, 1);
     luaK_reserveregs(fs, 1);
   }
-  forbody(ls, base, line, 1, 1);
+  forbody(ls, base, line, 1, basicfor);
 }
 
 
@@ -1358,7 +1424,7 @@ static void forlist (LexState *ls, TString *indexname) {
   line = ls->linenumber;
   adjust_assign(ls, 3, explist(ls, &e), &e);
   luaK_checkstack(fs, 3);  /* extra space to call generator */
-  forbody(ls, base, line, nvars - 3, 0);
+  forbody(ls, base, line, nvars - 3, 2);
 }
 
 
@@ -1392,9 +1458,12 @@ static void test_then_block (LexState *ls, int *escapelist) {
   if (ls->t.token == TK_GOTO || ls->t.token == TK_BREAK) {
     luaK_goiffalse(ls->fs, &v);  /* will jump to label if condition is true */
     enterblock(fs, &bl, 0);  /* must enter block before 'goto' */
-    gotostat(ls, v.t);  /* handle goto/break */
-    while (testnext(ls, ';')) {}  /* skip colons */
-    if (block_follow(ls, 0)) {  /* 'goto' is the entire block? */
+    if (ls->t.token == TK_GOTO)
+      gotostat(ls, v.t);  /* handle goto */
+    else
+      breakstat(ls, v.t);  /* handle break */
+    while (testnext(ls, ';')) {}  /* skip semicolons */
+    if (block_follow(ls, 0)) {  /* 'goto'/'break' is the entire block? */
       leaveblock(fs);
       return;  /* and that is it */
     }
@@ -1496,8 +1565,9 @@ static void exprstat (LexState *ls) {
     assignment(ls, &v, 1);
   }
   else {  /* stat -> func */
+    Instruction *inst = &getinstruction(fs, &v.v);
     check_condition(ls, v.v.k == VCALL, "syntax error");
-    SETARG_C(getinstruction(fs, &v.v), 1);  /* call statement uses no results */
+    SETARG_C(*inst, 1);  /* call statement uses no results */
   }
 }
 
@@ -1587,7 +1657,10 @@ static void statement (LexState *ls) {
       retstat(ls);
       break;
     }
-    case TK_BREAK:   /* stat -> breakstat */
+    case TK_BREAK: {  /* stat -> breakstat */
+      breakstat(ls, luaK_jump(ls->fs));
+      break;
+    }
     case TK_GOTO: {  /* stat -> 'goto' NAME */
       gotostat(ls, luaK_jump(ls->fs));
       break;
@@ -1614,10 +1687,9 @@ static void mainfunc (LexState *ls, FuncState *fs) {
   BlockCnt bl;
   expdesc v;
   open_func(ls, fs, &bl);
-  fs->f->is_vararg = 1;  /* main function is always declared vararg */
+  setvararg(fs, 0);  /* main function is always declared vararg */
   init_exp(&v, VLOCAL, 0);  /* create and... */
   newupvalue(fs, ls->envn, &v);  /* ...set environment upvalue */
-  luaC_objbarrier(ls->L, fs->f, ls->envn);
   luaX_next(ls);  /* read first token */
   statlist(ls);  /* parse main body */
   check(ls, TK_EOS);
@@ -1630,15 +1702,14 @@ LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
   LexState lexstate;
   FuncState funcstate;
   LClosure *cl = luaF_newLclosure(L, 1);  /* create main closure */
-  setclLvalue(L, L->top, cl);  /* anchor it (to avoid being collected) */
+  setclLvalue2s(L, L->top, cl);  /* anchor it (to avoid being collected) */
   luaD_inctop(L);
   lexstate.h = luaH_new(L);  /* create table for scanner */
-  sethvalue(L, L->top, lexstate.h);  /* anchor it */
+  sethvalue2s(L, L->top, lexstate.h);  /* anchor it */
   luaD_inctop(L);
   funcstate.f = cl->p = luaF_newproto(L);
-  luaC_objbarrier(L, cl, cl->p);
   funcstate.f->source = luaS_new(L, name);  /* create and anchor TString */
-  lua_assert(iswhite(funcstate.f));  /* do not need barrier here */
+  luaC_objbarrier(L, funcstate.f, funcstate.f->source);
   lexstate.buff = buff;
   lexstate.dyd = dyd;
   dyd->actvar.n = dyd->gt.n = dyd->label.n = 0;

lparser.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.h,v 1.76.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lparser.h,v 1.81 2018/03/07 15:55:38 roberto Exp roberto $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
@@ -36,19 +36,28 @@ typedef enum {
   VLOCAL,  /* local variable; info = local register */
   VUPVAL,  /* upvalue variable; info = index of upvalue in 'upvalues' */
   VINDEXED,  /* indexed variable;
-                ind.vt = whether 't' is register or upvalue;
-                ind.t = table register or upvalue;
-                ind.idx = key's R/K index */
+                ind.t = table register;
+                ind.idx = key's R index */
+  VINDEXUP,  /* indexed upvalue;
+                ind.t = table upvalue;
+                ind.idx = key's K index */
+  VINDEXI, /* indexed variable with constant integer;
+                ind.t = table register;
+                ind.idx = key's value */
+  VINDEXSTR, /* indexed variable with literal string;
+                ind.t = table register;
+                ind.idx = key's K index */
   VJMP,  /* expression is a test/comparison;
             info = pc of corresponding jump instruction */
-  VRELOCABLE,  /* expression can put result in any register;
-                  info = instruction pc */
+  VRELOC,  /* expression can put result in any register;
+              info = instruction pc */
   VCALL,  /* expression is a function call; info = instruction pc */
   VVARARG  /* vararg expression; info = instruction pc */
 } expkind;
 
 
-#define vkisvar(k)	(VLOCAL <= (k) && (k) <= VINDEXED)
+#define vkisvar(k)	(VLOCAL <= (k) && (k) <= VINDEXSTR)
+#define vkisindexed(k)	(VINDEXED <= (k) && (k) <= VINDEXSTR)
 #define vkisinreg(k)	((k) == VNONRELOC || (k) == VLOCAL)
 
 typedef struct expdesc {
@@ -57,10 +66,9 @@ typedef struct expdesc {
     lua_Integer ival;    /* for VKINT */
     lua_Number nval;  /* for VKFLT */
     int info;  /* for generic use */
-    struct {  /* for indexed variables (VINDEXED) */
-      short idx;  /* index (R/K) */
+    struct {  /* for indexed variables */
+      short idx;  /* index (R or "long" K) */
       lu_byte t;  /* table (register or upvalue) */
-      lu_byte vt;  /* whether 't' is register (VLOCAL) or upvalue (VUPVAL) */
     } ind;
   } u;
   int t;  /* patch list of 'exit when true' */
@@ -115,14 +123,16 @@ typedef struct FuncState {
   struct BlockCnt *bl;  /* chain of current blocks */
   int pc;  /* next position to code (equivalent to 'ncode') */
   int lasttarget;   /* 'label' of last 'jump label' */
-  int jpc;  /* list of pending jumps to 'pc' */
+  int previousline;  /* last line that was saved in 'lineinfo' */
   int nk;  /* number of elements in 'k' */
   int np;  /* number of elements in 'p' */
+  int nabslineinfo;  /* number of elements in 'abslineinfo' */
   int firstlocal;  /* index of first local var (in Dyndata array) */
   short nlocvars;  /* number of elements in 'f->locvars' */
   lu_byte nactvar;  /* number of active local variables */
   lu_byte nups;  /* number of upvalues */
   lu_byte freereg;  /* first free register */
+  lu_byte iwthabs;  /* instructions issued since last absolute line info */
 } FuncState;
 
 

lprefix.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lprefix.h,v 1.2.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lprefix.h,v 1.1 2014/11/03 15:12:44 roberto Exp roberto $
 ** Definitions for Lua code that must come before any other header file
 ** See Copyright Notice in lua.h
 */

lstate.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lstate.c,v 2.133.1.1 2017/04/19 17:39:34 roberto Exp $
+** $Id: lstate.c,v 2.154 2018/06/15 19:31:22 roberto Exp roberto $
 ** Global State
 ** See Copyright Notice in lua.h
 */
@@ -28,25 +28,6 @@
 #include "ltm.h"
 
 
-#if !defined(LUAI_GCPAUSE)
-#define LUAI_GCPAUSE	200  /* 200% */
-#endif
-
-#if !defined(LUAI_GCMUL)
-#define LUAI_GCMUL	200 /* GC runs 'twice the speed' of memory allocation */
-#endif
-
-
-/*
-** a macro to help the creation of a unique random seed when a state is
-** created; the seed is used to randomize hashes.
-*/
-#if !defined(luai_makeseed)
-#include <time.h>
-#define luai_makeseed()		cast(unsigned int, time(NULL))
-#endif
-
-
 
 /*
 ** thread state + extra space
@@ -71,25 +52,35 @@ typedef struct LG {
 
 
 /*
-** Compute an initial seed as random as possible. Rely on Address Space
-** Layout Randomization (if present) to increase randomness..
+** A macro to create a "random" seed when a state is created;
+** the seed is used to randomize string hashes.
+*/
+#if !defined(luai_makeseed)
+
+#include <time.h>
+
+/*
+** Compute an initial seed with some level of randomness.
+** Rely on Address Space Layout Randomization (if present) and
+** current time.
 */
 #define addbuff(b,p,e) \
-  { size_t t = cast(size_t, e); \
+  { size_t t = cast_sizet(e); \
     memcpy(b + p, &t, sizeof(t)); p += sizeof(t); }
 
-static unsigned int makeseed (lua_State *L) {
-  char buff[4 * sizeof(size_t)];
-  unsigned int h = luai_makeseed();
+static unsigned int luai_makeseed (lua_State *L) {
+  char buff[3 * sizeof(size_t)];
+  unsigned int h = cast_uint(time(NULL));
   int p = 0;
   addbuff(buff, p, L);  /* heap variable */
   addbuff(buff, p, &h);  /* local variable */
-  addbuff(buff, p, luaO_nilobject);  /* global variable */
   addbuff(buff, p, &lua_newstate);  /* public function */
   lua_assert(p == sizeof(buff));
   return luaS_hash(buff, p, h);
 }
 
+#endif
+
 
 /*
 ** set GCdebt to a new value keeping the value (totalbytes + GCdebt)
@@ -105,12 +96,33 @@ void luaE_setdebt (global_State *g, l_mem debt) {
 }
 
 
+/*
+** Increment count of "C calls" and check for overflows. In case of
+** a stack overflow, check appropriate error ("regular" overflow or
+** overflow while handling stack overflow). If 'nCalls' is larger than
+** LUAI_MAXCCALLS (which means it is handling a "regular" overflow) but
+** smaller than 9/8 of LUAI_MAXCCALLS, does not report an error (to
+** allow overflow handling to work)
+*/
+void luaE_incCcalls (lua_State *L) {
+  if (++L->nCcalls >= LUAI_MAXCCALLS) {
+    if (L->nCcalls == LUAI_MAXCCALLS)
+      luaG_runerror(L, "C stack overflow");
+    else if (L->nCcalls >= (LUAI_MAXCCALLS + (LUAI_MAXCCALLS>>3)))
+      luaD_throw(L, LUA_ERRERR);  /* error while handing stack error */
+  }
+}
+
+
 CallInfo *luaE_extendCI (lua_State *L) {
-  CallInfo *ci = luaM_new(L, CallInfo);
+  CallInfo *ci;
+  luaE_incCcalls(L);
+  ci = luaM_new(L, CallInfo);
   lua_assert(L->ci->next == NULL);
   L->ci->next = ci;
   ci->previous = L->ci;
   ci->next = NULL;
+  ci->u.l.trap = 0;
   L->nci++;
   return ci;
 }
@@ -123,11 +135,13 @@ void luaE_freeCI (lua_State *L) {
   CallInfo *ci = L->ci;
   CallInfo *next = ci->next;
   ci->next = NULL;
+  L->nCcalls -= L->nci;  /* to subtract removed elements from 'nCcalls' */
   while ((ci = next) != NULL) {
     next = ci->next;
     luaM_free(L, ci);
     L->nci--;
   }
+  L->nCcalls += L->nci;  /* to subtract removed elements from 'nCcalls' */
 }
 
 
@@ -137,6 +151,7 @@ void luaE_freeCI (lua_State *L) {
 void luaE_shrinkCI (lua_State *L) {
   CallInfo *ci = L->ci;
   CallInfo *next2;  /* next's next */
+  L->nCcalls -= L->nci;  /* to subtract removed elements from 'nCcalls' */
   /* while there are two nexts */
   while (ci->next != NULL && (next2 = ci->next->next) != NULL) {
     luaM_free(L, ci->next);  /* free next */
@@ -145,24 +160,26 @@ void luaE_shrinkCI (lua_State *L) {
     next2->previous = ci;
     ci = next2;  /* keep next's next */
   }
+  L->nCcalls += L->nci;  /* to subtract removed elements from 'nCcalls' */
 }
 
 
 static void stack_init (lua_State *L1, lua_State *L) {
   int i; CallInfo *ci;
   /* initialize stack array */
-  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, TValue);
+  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, StackValue);
   L1->stacksize = BASIC_STACK_SIZE;
   for (i = 0; i < BASIC_STACK_SIZE; i++)
-    setnilvalue(L1->stack + i);  /* erase new stack */
+    setnilvalue(s2v(L1->stack + i));  /* erase new stack */
   L1->top = L1->stack;
   L1->stack_last = L1->stack + L1->stacksize - EXTRA_STACK;
   /* initialize first ci */
   ci = &L1->base_ci;
   ci->next = ci->previous = NULL;
-  ci->callstatus = 0;
+  ci->callstatus = CIST_C;
   ci->func = L1->top;
-  setnilvalue(L1->top++);  /* 'function' entry for this 'ci' */
+  setnilvalue(s2v(L1->top));  /* 'function' entry for this 'ci' */
+  L1->top++;
   ci->top = L1->top + LUA_MINSTACK;
   L1->ci = ci;
 }
@@ -198,7 +215,7 @@ static void init_registry (lua_State *L, global_State *g) {
 
 /*
 ** open parts of the state that may cause memory-allocation errors.
-** ('g->version' != NULL flags that the state was completely build)
+** ('ttisnil(&g->nilvalue)'' flags that the state was completely build)
 */
 static void f_luaopen (lua_State *L, void *ud) {
   global_State *g = G(L);
@@ -209,7 +226,7 @@ static void f_luaopen (lua_State *L, void *ud) {
   luaT_init(L);
   luaX_init(L);
   g->gcrunning = 1;  /* allow gc */
-  g->version = lua_version(NULL);
+  setnilvalue(&g->nilvalue);
   luai_userstateopen(L);
 }
 
@@ -243,7 +260,7 @@ static void close_state (lua_State *L) {
   global_State *g = G(L);
   luaF_close(L, L->stack);  /* close all upvalues for this thread */
   luaC_freeallobjects(L);  /* collect all objects */
-  if (g->version)  /* closing a fully built state? */
+  if (ttisnil(&g->nilvalue))  /* closing a fully built state? */
     luai_userstateclose(L);
   luaM_freearray(L, G(L)->strt.hash, G(L)->strt.size);
   freestack(L);
@@ -265,7 +282,7 @@ LUA_API lua_State *lua_newthread (lua_State *L) {
   L1->next = g->allgc;
   g->allgc = obj2gco(L1);
   /* anchor it on L stack */
-  setthvalue(L, L->top, L1);
+  setthvalue2s(L, L->top, L1);
   api_incr_top(L);
   preinit_thread(L1, g);
   L1->hookmask = L->hookmask;
@@ -300,34 +317,39 @@ LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
   if (l == NULL) return NULL;
   L = &l->l.l;
   g = &l->g;
-  L->next = NULL;
   L->tt = LUA_TTHREAD;
   g->currentwhite = bitmask(WHITE0BIT);
   L->marked = luaC_white(g);
   preinit_thread(L, g);
+  g->allgc = obj2gco(L);  /* by now, only object is the main thread */
+  L->next = NULL;
   g->frealloc = f;
   g->ud = ud;
   g->mainthread = L;
-  g->seed = makeseed(L);
+  g->seed = luai_makeseed(L);
   g->gcrunning = 0;  /* no GC while building state */
-  g->GCestimate = 0;
   g->strt.size = g->strt.nuse = 0;
   g->strt.hash = NULL;
   setnilvalue(&g->l_registry);
   g->panic = NULL;
-  g->version = NULL;
   g->gcstate = GCSpause;
-  g->gckind = KGC_NORMAL;
-  g->allgc = g->finobj = g->tobefnz = g->fixedgc = NULL;
+  g->gckind = KGC_INC;
+  g->gcemergency = 0;
+  g->finobj = g->tobefnz = g->fixedgc = NULL;
+  g->survival = g->old = g->reallyold = NULL;
+  g->finobjsur = g->finobjold = g->finobjrold = NULL;
   g->sweepgc = NULL;
   g->gray = g->grayagain = NULL;
-  g->weak = g->ephemeron = g->allweak = NULL;
+  g->weak = g->ephemeron = g->allweak = g->protogray = NULL;
   g->twups = NULL;
   g->totalbytes = sizeof(LG);
   g->GCdebt = 0;
-  g->gcfinnum = 0;
-  g->gcpause = LUAI_GCPAUSE;
-  g->gcstepmul = LUAI_GCMUL;
+  setivalue(&g->nilvalue, 0);  /* to signal that state is not yet built */
+  setgcparam(g->gcpause, LUAI_GCPAUSE);
+  setgcparam(g->gcstepmul, LUAI_GCMUL);
+  g->gcstepsize = LUAI_GCSTEPSIZE;
+  setgcparam(g->genmajormul, LUAI_GENMAJORMUL);
+  g->genminormul = LUAI_GENMINORMUL;
   for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
   if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
     /* memory allocation error: free partial state */

lstate.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lstate.h,v 2.133.1.1 2017/04/19 17:39:34 roberto Exp $
+** $Id: lstate.h,v 2.159 2018/06/15 19:31:22 roberto Exp roberto $
 ** Global State
 ** See Copyright Notice in lua.h
 */
@@ -43,7 +43,8 @@
 ** 'weak': tables with weak values to be cleared;
 ** 'ephemeron': ephemeron tables with white->white entries;
 ** 'allweak': tables with weak keys and/or weak values to be cleared.
-** The last three lists are used only during the atomic phase.
+** There is also a list 'protogray' for prototypes that need to have
+** their caches cleared.
 
 */
 
@@ -69,8 +70,8 @@ struct lua_longjmp;  /* defined in ldo.c */
 
 
 /* kinds of Garbage Collection */
-#define KGC_NORMAL	0
-#define KGC_EMERGENCY	1	/* gc was forced by an allocation failure */
+#define KGC_INC		0	/* incremental gc */
+#define KGC_GEN		1	/* generational gc */
 
 
 typedef struct stringtable {
@@ -82,12 +83,6 @@ typedef struct stringtable {
 
 /*
 ** Information about a call.
-** When a thread yields, 'func' is adjusted to pretend that the
-** top function has only the yielded values in its stack; in that
-** case, the actual 'func' value is saved in field 'extra'.
-** When a function calls another with a continuation, 'extra' keeps
-** the function index so that, in case of errors, the continuation
-** function can be called with the correct top.
 */
 typedef struct CallInfo {
   StkId func;  /* function index in the stack */
@@ -95,8 +90,9 @@ typedef struct CallInfo {
   struct CallInfo *previous, *next;  /* dynamic call link */
   union {
     struct {  /* only for Lua functions */
-      StkId base;  /* base for this function */
       const Instruction *savedpc;
+      l_signalT trap;
+      int nextraargs;  /* # of extra arguments in vararg functions */
     } l;
     struct {  /* only for C functions */
       lua_KFunction k;  /* continuation in case of yields */
@@ -104,7 +100,14 @@ typedef struct CallInfo {
       lua_KContext ctx;  /* context info. in case of yields */
     } c;
   } u;
-  ptrdiff_t extra;
+  union {
+    int funcidx;  /* called-function index */
+    int nyield;  /* number of values yielded */
+    struct {  /* info about transfered values (for call/return hooks) */
+      unsigned short ftransfer;  /* offset of first value transfered */
+      unsigned short ntransfer;  /* number of values transfered */
+    } transferinfo;
+  } u2;
   short nresults;  /* expected number of results from this function */
   unsigned short callstatus;
 } CallInfo;
@@ -114,17 +117,20 @@ typedef struct CallInfo {
 ** Bits in CallInfo status
 */
 #define CIST_OAH	(1<<0)	/* original value of 'allowhook' */
-#define CIST_LUA	(1<<1)	/* call is running a Lua function */
+#define CIST_C		(1<<1)	/* call is running a C function */
 #define CIST_HOOKED	(1<<2)	/* call is running a debug hook */
-#define CIST_FRESH	(1<<3)	/* call is running on a fresh invocation
-                                   of luaV_execute */
-#define CIST_YPCALL	(1<<4)	/* call is a yieldable protected call */
-#define CIST_TAIL	(1<<5)	/* call was tail called */
-#define CIST_HOOKYIELD	(1<<6)	/* last hook called yielded */
-#define CIST_LEQ	(1<<7)  /* using __lt for __le */
-#define CIST_FIN	(1<<8)  /* call is running a finalizer */
+#define CIST_YPCALL	(1<<3)	/* call is a yieldable protected call */
+#define CIST_TAIL	(1<<4)	/* call was tail called */
+#define CIST_HOOKYIELD	(1<<5)	/* last hook called yielded */
+#define CIST_LEQ	(1<<6)  /* using __lt for __le */
+#define CIST_FIN	(1<<7)  /* call is running a finalizer */
+#define CIST_TRAN	(1<<8)	/* 'ci' has transfer information */
 
-#define isLua(ci)	((ci)->callstatus & CIST_LUA)
+/* active function is a Lua function */
+#define isLua(ci)	(!((ci)->callstatus & CIST_C))
+
+/* call is running Lua code (not a hook) */
+#define isLuacode(ci)	(!((ci)->callstatus & (CIST_C | CIST_HOOKED)))
 
 /* assume that CIST_OAH has offset 0 and that 'v' is strictly 0/1 */
 #define setoah(st,v)	((st) = ((st) & ~CIST_OAH) | (v))
@@ -139,15 +145,21 @@ typedef struct global_State {
   void *ud;         /* auxiliary data to 'frealloc' */
   l_mem totalbytes;  /* number of bytes currently allocated - GCdebt */
   l_mem GCdebt;  /* bytes allocated not yet compensated by the collector */
-  lu_mem GCmemtrav;  /* memory traversed by the GC */
   lu_mem GCestimate;  /* an estimate of the non-garbage memory in use */
   stringtable strt;  /* hash table for strings */
   TValue l_registry;
+  TValue nilvalue;  /* a nil value */
   unsigned int seed;  /* randomized seed for hashes */
   lu_byte currentwhite;
   lu_byte gcstate;  /* state of garbage collector */
   lu_byte gckind;  /* kind of GC running */
+  lu_byte genminormul;  /* control for minor generational collections */
+  lu_byte genmajormul;  /* control for major generational collections */
   lu_byte gcrunning;  /* true if GC is running */
+  lu_byte gcemergency;  /* true if this is an emergency collection */
+  lu_byte gcpause;  /* size of pause between successive GCs */
+  lu_byte gcstepmul;  /* GC "speed" */
+  lu_byte gcstepsize;  /* (log2 of) GC granularity */
   GCObject *allgc;  /* list of all collectable objects */
   GCObject **sweepgc;  /* current position of sweep in list */
   GCObject *finobj;  /* list of collectable objects with finalizers */
@@ -156,16 +168,20 @@ typedef struct global_State {
   GCObject *weak;  /* list of tables with weak values */
   GCObject *ephemeron;  /* list of ephemeron tables (weak keys) */
   GCObject *allweak;  /* list of all-weak tables */
+  GCObject *protogray;  /* list of prototypes with "new" caches */
   GCObject *tobefnz;  /* list of userdata to be GC */
   GCObject *fixedgc;  /* list of objects not to be collected */
+  /* fields for generational collector */
+  GCObject *survival;  /* start of objects that survived one GC cycle */
+  GCObject *old;  /* start of old objects */
+  GCObject *reallyold;  /* old objects with more than one cycle */
+  GCObject *finobjsur;  /* list of survival objects with finalizers */
+  GCObject *finobjold;  /* list of old objects with finalizers */
+  GCObject *finobjrold;  /* list of really old objects with finalizers */
   struct lua_State *twups;  /* list of threads with open upvalues */
-  unsigned int gcfinnum;  /* number of finalizers to call in each GC step */
-  int gcpause;  /* size of pause between successive GCs */
-  int gcstepmul;  /* GC 'granularity' */
   lua_CFunction panic;  /* to be called in unprotected errors */
   struct lua_State *mainthread;
-  const lua_Number *version;  /* pointer to version number */
-  TString *memerrmsg;  /* memory-error message */
+  TString *memerrmsg;  /* message for memory-allocation errors */
   TString *tmname[TM_N];  /* array with tag-method names */
   struct Table *mt[LUA_NUMTAGS];  /* metatables for basic types */
   TString *strcache[STRCACHE_N][STRCACHE_M];  /* cache for strings in API */
@@ -216,6 +232,7 @@ union GCUnion {
   struct Table h;
   struct Proto p;
   struct lua_State th;  /* thread */
+  struct UpVal upv;
 };
 
 
@@ -232,11 +249,14 @@ union GCUnion {
 #define gco2t(o)  check_exp((o)->tt == LUA_TTABLE, &((cast_u(o))->h))
 #define gco2p(o)  check_exp((o)->tt == LUA_TPROTO, &((cast_u(o))->p))
 #define gco2th(o)  check_exp((o)->tt == LUA_TTHREAD, &((cast_u(o))->th))
+#define gco2upv(o)  check_exp((o)->tt == LUA_TUPVAL, &((cast_u(o))->upv))
 
 
-/* macro to convert a Lua object into a GCObject */
-#define obj2gco(v) \
-	check_exp(novariant((v)->tt) < LUA_TDEADKEY, (&(cast_u(v)->gc)))
+/*
+** macro to convert a Lua object into a GCObject
+** (The access to 'tt' tries to ensure that 'v' is actually a Lua object.)
+*/
+#define obj2gco(v)	check_exp((v)->tt >= LUA_TSTRING, &(cast_u(v)->gc))
 
 
 /* actual number of total bytes allocated */
@@ -247,6 +267,7 @@ LUAI_FUNC void luaE_freethread (lua_State *L, lua_State *L1);
 LUAI_FUNC CallInfo *luaE_extendCI (lua_State *L);
 LUAI_FUNC void luaE_freeCI (lua_State *L);
 LUAI_FUNC void luaE_shrinkCI (lua_State *L);
+LUAI_FUNC void luaE_incCcalls (lua_State *L);
 
 
 #endif

lstring.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.c,v 2.56.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lstring.c,v 2.65 2018/02/20 16:52:50 roberto Exp roberto $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
@@ -22,9 +22,6 @@
 #include "lstring.h"
 
 
-#define MEMERRMSG       "not enough memory"
-
-
 /*
 ** Lua will use at most ~(2^LUAI_HASHLIMIT) bytes from a string to
 ** compute its hash
@@ -34,6 +31,13 @@
 #endif
 
 
+
+/*
+** Maximum size for string table.
+*/
+#define MAXSTRTB	cast_int(luaM_limitN(MAX_INT, TString*))
+
+
 /*
 ** equality for long strings
 */
@@ -47,7 +51,7 @@ int luaS_eqlngstr (TString *a, TString *b) {
 
 
 unsigned int luaS_hash (const char *str, size_t l, unsigned int seed) {
-  unsigned int h = seed ^ cast(unsigned int, l);
+  unsigned int h = seed ^ cast_uint(l);
   size_t step = (l >> LUAI_HASHLIMIT) + 1;
   for (; l >= step; l -= step)
     h ^= ((h<<5) + (h>>2) + cast_byte(str[l - 1]));
@@ -65,34 +69,47 @@ unsigned int luaS_hashlongstr (TString *ts) {
 }
 
 
-/*
-** resizes the string table
-*/
-void luaS_resize (lua_State *L, int newsize) {
+static void tablerehash (TString **vect, int osize, int nsize) {
   int i;
-  stringtable *tb = &G(L)->strt;
-  if (newsize > tb->size) {  /* grow table if needed */
-    luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
-    for (i = tb->size; i < newsize; i++)
-      tb->hash[i] = NULL;
-  }
-  for (i = 0; i < tb->size; i++) {  /* rehash */
-    TString *p = tb->hash[i];
-    tb->hash[i] = NULL;
-    while (p) {  /* for each node in the list */
+  for (i = osize; i < nsize; i++)  /* clear new elements */
+    vect[i] = NULL;
+  for (i = 0; i < osize; i++) {  /* rehash old part of the array */
+    TString *p = vect[i];
+    vect[i] = NULL;
+    while (p) {  /* for each string in the list */
       TString *hnext = p->u.hnext;  /* save next */
-      unsigned int h = lmod(p->hash, newsize);  /* new position */
-      p->u.hnext = tb->hash[h];  /* chain it */
-      tb->hash[h] = p;
+      unsigned int h = lmod(p->hash, nsize);  /* new position */
+      p->u.hnext = vect[h];  /* chain it into array */
+      vect[h] = p;
       p = hnext;
     }
   }
-  if (newsize < tb->size) {  /* shrink table if needed */
-    /* vanishing slice should be empty */
-    lua_assert(tb->hash[newsize] == NULL && tb->hash[tb->size - 1] == NULL);
-    luaM_reallocvector(L, tb->hash, tb->size, newsize, TString *);
+}
+
+
+/*
+** Resize the string table. If allocation fails, keep the current size.
+** (This can degrade performance, but any non-zero size should work
+** correctly.)
+*/
+void luaS_resize (lua_State *L, int nsize) {
+  stringtable *tb = &G(L)->strt;
+  int osize = tb->size;
+  TString **newvect;
+  if (nsize < osize)  /* shrinking table? */
+    tablerehash(tb->hash, osize, nsize);  /* depopulate shrinking part */
+  newvect = luaM_reallocvector(L, tb->hash, osize, nsize, TString*);
+  if (unlikely(newvect == NULL)) {  /* reallocation failed? */
+    if (nsize < osize)  /* was it shrinking table? */
+      tablerehash(tb->hash, nsize, osize);  /* restore to original size */
+    /* leave table as it was */
+  }
+  else {  /* allocation succeeded */
+    tb->hash = newvect;
+    tb->size = nsize;
+    if (nsize > osize)
+      tablerehash(newvect, osize, nsize);  /* rehash for new size */
   }
-  tb->size = newsize;
 }
 
 
@@ -116,7 +133,10 @@ void luaS_clearcache (global_State *g) {
 void luaS_init (lua_State *L) {
   global_State *g = G(L);
   int i, j;
-  luaS_resize(L, MINSTRTABSIZE);  /* initial size of string table */
+  stringtable *tb = &G(L)->strt;
+  tb->hash = luaM_newvector(L, MINSTRTABSIZE, TString*);
+  tablerehash(tb->hash, 0, MINSTRTABSIZE);  /* clear array */
+  tb->size = MINSTRTABSIZE;
   /* pre-create memory-error message */
   g->memerrmsg = luaS_newliteral(L, MEMERRMSG);
   luaC_fix(L, obj2gco(g->memerrmsg));  /* it should never be collected */
@@ -161,34 +181,46 @@ void luaS_remove (lua_State *L, TString *ts) {
 }
 
 
+static void growstrtab (lua_State *L, stringtable *tb) {
+  if (unlikely(tb->nuse == MAX_INT)) {  /* too many strings? */
+    luaC_fullgc(L, 1);  /* try to free some... */
+    if (tb->nuse == MAX_INT)  /* still too many? */
+      luaM_error(L);  /* cannot even create a message... */
+  }
+  if (tb->size <= MAXSTRTB / 2)  /* can grow string table? */
+    luaS_resize(L, tb->size * 2);
+}
+
+
 /*
-** checks whether short string exists and reuses it or creates a new one
+** Checks whether short string exists and reuses it or creates a new one.
 */
 static TString *internshrstr (lua_State *L, const char *str, size_t l) {
   TString *ts;
   global_State *g = G(L);
+  stringtable *tb = &g->strt;
   unsigned int h = luaS_hash(str, l, g->seed);
-  TString **list = &g->strt.hash[lmod(h, g->strt.size)];
+  TString **list = &tb->hash[lmod(h, tb->size)];
   lua_assert(str != NULL);  /* otherwise 'memcmp'/'memcpy' are undefined */
   for (ts = *list; ts != NULL; ts = ts->u.hnext) {
-    if (l == ts->shrlen &&
-        (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
+    if (l == ts->shrlen && (memcmp(str, getstr(ts), l * sizeof(char)) == 0)) {
       /* found! */
       if (isdead(g, ts))  /* dead (but not collected yet)? */
         changewhite(ts);  /* resurrect it */
       return ts;
     }
   }
-  if (g->strt.nuse >= g->strt.size && g->strt.size <= MAX_INT/2) {
-    luaS_resize(L, g->strt.size * 2);
-    list = &g->strt.hash[lmod(h, g->strt.size)];  /* recompute with new size */
+  /* else must create a new string */
+  if (tb->nuse >= tb->size) {  /* need to grow string table? */
+    growstrtab(L, tb);
+    list = &tb->hash[lmod(h, tb->size)];  /* rehash with new size */
   }
   ts = createstrobj(L, l, LUA_TSHRSTR, h);
   memcpy(getstr(ts), str, l * sizeof(char));
   ts->shrlen = cast_byte(l);
   ts->u.hnext = *list;
   *list = ts;
-  g->strt.nuse++;
+  tb->nuse++;
   return ts;
 }
 
@@ -201,7 +233,7 @@ TString *luaS_newlstr (lua_State *L, const char *str, size_t l) {
     return internshrstr(L, str, l);
   else {
     TString *ts;
-    if (l >= (MAX_SIZE - sizeof(TString))/sizeof(char))
+    if (unlikely(l >= (MAX_SIZE - sizeof(TString))/sizeof(char)))
       luaM_toobig(L);
     ts = luaS_createlngstrobj(L, l);
     memcpy(getstr(ts), str, l * sizeof(char));
@@ -233,16 +265,19 @@ TString *luaS_new (lua_State *L, const char *str) {
 }
 
 
-Udata *luaS_newudata (lua_State *L, size_t s) {
+Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue) {
   Udata *u;
+  int i;
   GCObject *o;
-  if (s > MAX_SIZE - sizeof(Udata))
+  if (unlikely(s > MAX_SIZE - udatamemoffset(nuvalue)))
     luaM_toobig(L);
-  o = luaC_newobj(L, LUA_TUSERDATA, sizeludata(s));
+  o = luaC_newobj(L, LUA_TUSERDATA, sizeudata(nuvalue, s));
   u = gco2u(o);
   u->len = s;
+  u->nuvalue = nuvalue;
   u->metatable = NULL;
-  setuservalue(L, u, luaO_nilobject);
+  for (i = 0; i < nuvalue; i++)
+    setnilvalue(&u->uv[i].uv);
   return u;
 }
 

lstring.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.h,v 1.61.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lstring.h,v 1.63 2017/11/23 19:29:04 roberto Exp roberto $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
@@ -12,10 +12,14 @@
 #include "lstate.h"
 
 
-#define sizelstring(l)  (sizeof(union UTString) + ((l) + 1) * sizeof(char))
+/*
+** Memory-allocation error message must be preallocated (it cannot
+** be created after memory is exhausted)
+*/
+#define MEMERRMSG       "not enough memory"
 
-#define sizeludata(l)	(sizeof(union UUdata) + (l))
-#define sizeudata(u)	sizeludata((u)->len)
+
+#define sizelstring(l)  (sizeof(union UTString) + ((l) + 1) * sizeof(char))
 
 #define luaS_newliteral(L, s)	(luaS_newlstr(L, "" s, \
                                  (sizeof(s)/sizeof(char))-1))
@@ -40,7 +44,7 @@ LUAI_FUNC void luaS_resize (lua_State *L, int newsize);
 LUAI_FUNC void luaS_clearcache (global_State *g);
 LUAI_FUNC void luaS_init (lua_State *L);
 LUAI_FUNC void luaS_remove (lua_State *L, TString *ts);
-LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s);
+LUAI_FUNC Udata *luaS_newudata (lua_State *L, size_t s, int nuvalue);
 LUAI_FUNC TString *luaS_newlstr (lua_State *L, const char *str, size_t l);
 LUAI_FUNC TString *luaS_new (lua_State *L, const char *str);
 LUAI_FUNC TString *luaS_createlngstrobj (lua_State *L, size_t l);

lstrlib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lstrlib.c,v 1.254.1.1 2017/04/19 17:29:57 roberto Exp $
+** $Id: lstrlib.c,v 1.262 2018/02/21 17:48:31 roberto Exp roberto $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
@@ -14,6 +14,7 @@
 #include <float.h>
 #include <limits.h>
 #include <locale.h>
+#include <math.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -200,6 +201,92 @@ static int str_dump (lua_State *L) {
 
 
 
+/*
+** {======================================================
+** METAMETHODS
+** =======================================================
+*/
+
+static int tonum (lua_State *L, int arg) {
+  if (lua_type(L, arg) == LUA_TNUMBER) {  /* already a number? */
+    lua_pushvalue(L, arg);
+    return 1;
+  }
+  else {  /* check whether it is a numerical string */
+    size_t len;
+    const char *s = lua_tolstring(L, arg, &len);
+    return (s != NULL && lua_stringtonumber(L, s) == len + 1);
+  }
+}
+
+
+static void trymt (lua_State *L, const char *mtname) {
+  lua_settop(L, 2);  /* back to the original arguments */
+  if (lua_type(L, 2) == LUA_TSTRING || !luaL_getmetafield(L, 2, mtname))
+    luaL_error(L, "attempt to %s a '%s' with a '%s'", mtname + 2,
+                  luaL_typename(L, -2), luaL_typename(L, -1));
+  lua_insert(L, -3);  /* put metamethod before arguments */
+  lua_call(L, 2, 1);  /* call metamethod */
+}
+
+
+static int arith (lua_State *L, int op, const char *mtname) {
+  if (tonum(L, 1) && tonum(L, 2))
+    lua_arith(L, op);  /* result will be on the top */
+  else
+    trymt(L, mtname);
+  return 1;
+}
+
+
+static int arith_add (lua_State *L) {
+  return arith(L, LUA_OPADD, "__add");
+}
+
+static int arith_sub (lua_State *L) {
+  return arith(L, LUA_OPSUB, "__sub");
+}
+
+static int arith_mul (lua_State *L) {
+  return arith(L, LUA_OPMUL, "__mul");
+}
+
+static int arith_mod (lua_State *L) {
+  return arith(L, LUA_OPMOD, "__mod");
+}
+
+static int arith_pow (lua_State *L) {
+  return arith(L, LUA_OPPOW, "__pow");
+}
+
+static int arith_div (lua_State *L) {
+  return arith(L, LUA_OPDIV, "__div");
+}
+
+static int arith_idiv (lua_State *L) {
+  return arith(L, LUA_OPIDIV, "__idiv");
+}
+
+static int arith_unm (lua_State *L) {
+  return arith(L, LUA_OPUNM, "__unm");
+}
+
+
+static const luaL_Reg stringmetamethods[] = {
+  {"__add", arith_add},
+  {"__sub", arith_sub},
+  {"__mul", arith_mul},
+  {"__mod", arith_mod},
+  {"__pow", arith_pow},
+  {"__div", arith_div},
+  {"__idiv", arith_idiv},
+  {"__unm", arith_unm},
+  {"__index", NULL},  /* placeholder */
+  {NULL, NULL}
+};
+
+/* }====================================================== */
+
 /*
 ** {======================================================
 ** PATTERN MATCHING
@@ -692,7 +779,7 @@ static int gmatch (lua_State *L) {
   const char *p = luaL_checklstring(L, 2, &lp);
   GMatchState *gm;
   lua_settop(L, 2);  /* keep them on closure to avoid being collected */
-  gm = (GMatchState *)lua_newuserdata(L, sizeof(GMatchState));
+  gm = (GMatchState *)lua_newuserdatauv(L, sizeof(GMatchState), 0);
   prepstate(&gm->ms, L, s, ls, p, lp);
   gm->src = s; gm->p = p; gm->lastmatch = NULL;
   lua_pushcclosure(L, gmatch_aux, 3);
@@ -813,8 +900,6 @@ static int str_gsub (lua_State *L) {
 ** Hexadecimal floating-point formatter
 */
 
-#include <math.h>
-
 #define SIZELENMOD	(sizeof(LUA_NUMBER_FRMLEN)/sizeof(char))
 
 
@@ -851,7 +936,7 @@ static int num2straux (char *buff, int sz, lua_Number x) {
     lua_Number m = l_mathop(frexp)(x, &e);  /* 'x' fraction and exponent */
     int n = 0;  /* character count */
     if (m < 0) {  /* is number negative? */
-      buff[n++] = '-';  /* add signal */
+      buff[n++] = '-';  /* add sign */
       m = -m;  /* make it positive */
     }
     buff[n++] = '0'; buff[n++] = 'x';  /* add "0x" */
@@ -929,14 +1014,32 @@ static void addquoted (luaL_Buffer *b, const char *s, size_t len) {
 
 
 /*
-** Ensures the 'buff' string uses a dot as the radix character.
+** Serialize a floating-point number in such a way that it can be
+** scanned back by Lua. Use hexadecimal format for "common" numbers
+** (to preserve precision); inf, -inf, and NaN are handled separately.
+** (NaN cannot be expressed as a numeral, so we write '(0/0)' for it.)
 */
-static void checkdp (char *buff, int nb) {
-  if (memchr(buff, '.', nb) == NULL) {  /* no dot? */
-    char point = lua_getlocaledecpoint();  /* try locale point */
-    char *ppoint = (char *)memchr(buff, point, nb);
-    if (ppoint) *ppoint = '.';  /* change it to a dot */
+static int quotefloat (lua_State *L, char *buff, lua_Number n) {
+  const char *s;  /* for the fixed representations */
+  if (n == (lua_Number)HUGE_VAL)  /* inf? */
+    s = "1e9999";
+  else if (n == -(lua_Number)HUGE_VAL)  /* -inf? */
+    s = "-1e9999";
+  else if (n != n)  /* NaN? */
+    s = "(0/0)";
+  else {  /* format number as hexadecimal */
+    int  nb = lua_number2strx(L, buff, MAX_ITEM,
+                                 "%" LUA_NUMBER_FRMLEN "a", n);
+    /* ensures that 'buff' string uses a dot as the radix character */
+    if (memchr(buff, '.', nb) == NULL) {  /* no dot? */
+      char point = lua_getlocaledecpoint();  /* try locale point */
+      char *ppoint = (char *)memchr(buff, point, nb);
+      if (ppoint) *ppoint = '.';  /* change it to a dot */
+    }
+    return nb;
   }
+  /* for the fixed representations */
+  return l_sprintf(buff, MAX_ITEM, "%s", s);
 }
 
 
@@ -951,15 +1054,12 @@ static void addliteral (lua_State *L, luaL_Buffer *b, int arg) {
     case LUA_TNUMBER: {
       char *buff = luaL_prepbuffsize(b, MAX_ITEM);
       int nb;
-      if (!lua_isinteger(L, arg)) {  /* float? */
-        lua_Number n = lua_tonumber(L, arg);  /* write as hexa ('%a') */
-        nb = lua_number2strx(L, buff, MAX_ITEM, "%" LUA_NUMBER_FRMLEN "a", n);
-        checkdp(buff, nb);  /* ensure it uses a dot */
-      }
+      if (!lua_isinteger(L, arg))  /* float? */
+        nb = quotefloat(L, buff, lua_tonumber(L, arg));
       else {  /* integers */
         lua_Integer n = lua_tointeger(L, arg);
         const char *format = (n == LUA_MININTEGER)  /* corner case? */
-                           ? "0x%" LUA_INTEGER_FRMLEN "x"  /* use hexa */
+                           ? "0x%" LUA_INTEGER_FRMLEN "x"  /* use hex */
                            : LUA_INTEGER_FMT;  /* else use default format */
         nb = l_sprintf(buff, MAX_ITEM, format, (LUAI_UACINT)n);
       }
@@ -1422,17 +1522,12 @@ static int str_packsize (lua_State *L) {
   while (*fmt != '\0') {
     int size, ntoalign;
     KOption opt = getdetails(&h, totalsize, &fmt, &size, &ntoalign);
+    luaL_argcheck(L, opt != Kstring && opt != Kzstr, 1,
+                     "variable-length format");
     size += ntoalign;  /* total space used by option */
     luaL_argcheck(L, totalsize <= MAXSIZE - size, 1,
                      "format result too large");
     totalsize += size;
-    switch (opt) {
-      case Kstring:  /* strings with length count */
-      case Kzstr:    /* zero-terminated string */
-        luaL_argerror(L, 1, "variable-length format");
-        /* call never return, but to avoid warnings: *//* FALLTHROUGH */
-      default:  break;
-    }
   }
   lua_pushinteger(L, (lua_Integer)totalsize);
   return 1;
@@ -1485,8 +1580,8 @@ static int str_unpack (lua_State *L) {
   while (*fmt != '\0') {
     int size, ntoalign;
     KOption opt = getdetails(&h, pos, &fmt, &size, &ntoalign);
-    if ((size_t)ntoalign + size > ~pos || pos + ntoalign + size > ld)
-      luaL_argerror(L, 2, "data string too short");
+    luaL_argcheck(L, (size_t)ntoalign + size <= ld - pos, 2,
+                    "data string too short");
     pos += ntoalign;  /* skip alignment */
     /* stack space for item + next position */
     luaL_checkstack(L, 2, "too many results");
@@ -1515,13 +1610,15 @@ static int str_unpack (lua_State *L) {
       }
       case Kstring: {
         size_t len = (size_t)unpackint(L, data + pos, h.islittle, size, 0);
-        luaL_argcheck(L, pos + len + size <= ld, 2, "data string too short");
+        luaL_argcheck(L, len <= ld - pos - size, 2, "data string too short");
         lua_pushlstring(L, data + pos + size, len);
         pos += len;  /* skip string */
         break;
       }
       case Kzstr: {
         size_t len = (int)strlen(data + pos);
+        luaL_argcheck(L, pos + len < ld, 2,
+                         "unfinished string for format 'z'");
         lua_pushlstring(L, data + pos, len);
         pos += len + 1;  /* skip string plus final '\0' */
         break;
@@ -1562,7 +1659,9 @@ static const luaL_Reg strlib[] = {
 
 
 static void createmetatable (lua_State *L) {
-  lua_createtable(L, 0, 1);  /* table to be metatable for strings */
+  /* table to be metatable for strings */
+  luaL_newlibtable(L, stringmetamethods);
+  luaL_setfuncs(L, stringmetamethods, 0);
   lua_pushliteral(L, "");  /* dummy string */
   lua_pushvalue(L, -2);  /* copy table */
   lua_setmetatable(L, -2);  /* set table as metatable for strings */

ltable.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.c,v 2.118.1.4 2018/06/08 16:22:51 roberto Exp $
+** $Id: ltable.c,v 2.139 2018/06/15 14:14:20 roberto Exp roberto $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -40,21 +40,34 @@
 
 
 /*
-** Maximum size of array part (MAXASIZE) is 2^MAXABITS. MAXABITS is
-** the largest integer such that MAXASIZE fits in an unsigned int.
+** MAXABITS is the largest integer such that MAXASIZE fits in an
+** unsigned int.
 */
 #define MAXABITS	cast_int(sizeof(int) * CHAR_BIT - 1)
-#define MAXASIZE	(1u << MAXABITS)
+
 
 /*
-** Maximum size of hash part is 2^MAXHBITS. MAXHBITS is the largest
-** integer such that 2^MAXHBITS fits in a signed int. (Note that the
-** maximum number of elements in a table, 2^MAXABITS + 2^MAXHBITS, still
-** fits comfortably in an unsigned int.)
+** MAXASIZE is the maximum size of the array part. It is the minimum
+** between 2^MAXABITS and the maximum size such that, measured in bytes,
+** it fits in a 'size_t'.
+*/
+#define MAXASIZE	luaM_limitN(1u << MAXABITS, TValue)
+
+/*
+** MAXHBITS is the largest integer such that 2^MAXHBITS fits in a
+** signed int.
 */
 #define MAXHBITS	(MAXABITS - 1)
 
 
+/*
+** MAXHSIZE is the maximum size of the hash part. It is the minimum
+** between 2^MAXHBITS and the maximum size such that, measured in bytes,
+** it fits in a 'size_t'.
+*/
+#define MAXHSIZE	luaM_limitN(1u << MAXHBITS, Node)
+
+
 #define hashpow2(t,n)		(gnode(t, lmod((n), sizenode(t))))
 
 #define hashstr(t,str)		hashpow2(t, (str)->hash)
@@ -75,11 +88,15 @@
 #define dummynode		(&dummynode_)
 
 static const Node dummynode_ = {
-  {NILCONSTANT},  /* value */
-  {{NILCONSTANT, 0}}  /* key */
+  {{NULL}, LUA_TEMPTY,  /* value's value and type */
+   LUA_TNIL, 0, {NULL}}  /* key type, next, and key value */
 };
 
 
+static const TValue absentkey = {ABSTKEYCONSTANT};
+
+
+
 /*
 ** Hash for floating-point numbers.
 ** The main computation should be just
@@ -103,51 +120,159 @@ static int l_hashfloat (lua_Number n) {
     return 0;
   }
   else {  /* normal case */
-    unsigned int u = cast(unsigned int, i) + cast(unsigned int, ni);
-    return cast_int(u <= cast(unsigned int, INT_MAX) ? u : ~u);
+    unsigned int u = cast_uint(i) + cast_uint(ni);
+    return cast_int(u <= cast_uint(INT_MAX) ? u : ~u);
   }
 }
 #endif
 
 
 /*
-** returns the 'main' position of an element in a table (that is, the index
-** of its hash value)
+** returns the 'main' position of an element in a table (that is,
+** the index of its hash value). The key comes broken (tag in 'ktt'
+** and value in 'vkl') so that we can call it on keys inserted into
+** nodes.
 */
-static Node *mainposition (const Table *t, const TValue *key) {
-  switch (ttype(key)) {
+static Node *mainposition (const Table *t, int ktt, const Value *kvl) {
+  switch (withvariant(ktt)) {
     case LUA_TNUMINT:
-      return hashint(t, ivalue(key));
+      return hashint(t, ivalueraw(*kvl));
     case LUA_TNUMFLT:
-      return hashmod(t, l_hashfloat(fltvalue(key)));
+      return hashmod(t, l_hashfloat(fltvalueraw(*kvl)));
     case LUA_TSHRSTR:
-      return hashstr(t, tsvalue(key));
+      return hashstr(t, tsvalueraw(*kvl));
     case LUA_TLNGSTR:
-      return hashpow2(t, luaS_hashlongstr(tsvalue(key)));
+      return hashpow2(t, luaS_hashlongstr(tsvalueraw(*kvl)));
     case LUA_TBOOLEAN:
-      return hashboolean(t, bvalue(key));
+      return hashboolean(t, bvalueraw(*kvl));
     case LUA_TLIGHTUSERDATA:
-      return hashpointer(t, pvalue(key));
+      return hashpointer(t, pvalueraw(*kvl));
     case LUA_TLCF:
-      return hashpointer(t, fvalue(key));
+      return hashpointer(t, fvalueraw(*kvl));
     default:
-      lua_assert(!ttisdeadkey(key));
-      return hashpointer(t, gcvalue(key));
+      return hashpointer(t, gcvalueraw(*kvl));
+  }
+}
+
+
+static Node *mainpositionTV (const Table *t, const TValue *key) {
+  return mainposition(t, rawtt(key), valraw(key));
+}
+
+
+/*
+** Check whether key 'k1' is equal to the key in node 'n2'.
+** This equality is raw, so there are no metamethods. Floats
+** with integer values have been normalized, so integers cannot
+** be equal to floats. It is assumed that 'eqshrstr' is simply
+** pointer equality, so that short strings are handled in the
+** default case.
+*/
+static int equalkey (const TValue *k1, const Node *n2) {
+  if (rawtt(k1) != keytt(n2))  /* not the same variants? */
+   return 0;  /* cannot be same key */
+  switch (ttypetag(k1)) {
+    case LUA_TNIL:
+      return 1;
+    case LUA_TNUMINT:
+      return (ivalue(k1) == keyival(n2));
+    case LUA_TNUMFLT:
+      return luai_numeq(fltvalue(k1), fltvalueraw(keyval(n2)));
+    case LUA_TBOOLEAN:
+      return bvalue(k1) == bvalueraw(keyval(n2));
+    case LUA_TLIGHTUSERDATA:
+      return pvalue(k1) == pvalueraw(keyval(n2));
+    case LUA_TLCF:
+      return fvalue(k1) == fvalueraw(keyval(n2));
+    case LUA_TLNGSTR:
+      return luaS_eqlngstr(tsvalue(k1), keystrval(n2));
+    default:
+      return gcvalue(k1) == gcvalueraw(keyval(n2));
   }
 }
 
 
 /*
-** returns the index for 'key' if 'key' is an appropriate key to live in
-** the array part of the table, 0 otherwise.
+** True if value of 'alimit' is equal to the real size of the array
+** part of table 't'. (Otherwise, the array part must be larger than
+** 'alimit'.)
 */
-static unsigned int arrayindex (const TValue *key) {
-  if (ttisinteger(key)) {
-    lua_Integer k = ivalue(key);
-    if (0 < k && (lua_Unsigned)k <= MAXASIZE)
-      return cast(unsigned int, k);  /* 'key' is an appropriate array index */
+#define limitequalsasize(t)	(isrealasize(t) || ispow2((t)->alimit))
+
+
+/*
+** Returns the real size of the 'array' array
+*/
+LUAI_FUNC unsigned int luaH_realasize (const Table *t) {
+  if (limitequalsasize(t))
+    return t->alimit;  /* this is the size */
+  else {
+    unsigned int size = t->alimit;
+    /* compute the smallest power of 2 not smaller than 'n' */
+    size |= (size >> 1);
+    size |= (size >> 2);
+    size |= (size >> 4);
+    size |= (size >> 8);
+    size |= (size >> 16);
+#if (INT_MAX >> 30 >> 1) > 0
+    size |= (size >> 32);  /* int has more than 32 bits */
+#endif
+    size++;
+    lua_assert(ispow2(size) && size/2 < t->alimit && t->alimit < size);
+    return size;
   }
-  return 0;  /* 'key' did not match some condition */
+}
+
+
+/*
+** Check whether real size of the array is a power of 2.
+** (If it is not, 'alimit' cannot be changed to any other value
+** without changing the real size.)
+*/
+static int ispow2realasize (const Table *t) {
+  return (!isrealasize(t) || ispow2(t->alimit));
+}
+
+
+static unsigned int setlimittosize (Table *t) {
+  t->alimit = luaH_realasize(t);
+  setrealasize(t);
+  return t->alimit;
+}
+
+
+#define limitasasize(t)	check_exp(isrealasize(t), t->alimit)
+
+
+
+/*
+** "Generic" get version. (Not that generic: not valid for integers,
+** which may be in array part, nor for floats with integral values.)
+*/
+static const TValue *getgeneric (Table *t, const TValue *key) {
+  Node *n = mainpositionTV(t, key);
+  for (;;) {  /* check whether 'key' is somewhere in the chain */
+    if (equalkey(key, n))
+      return gval(n);  /* that's it */
+    else {
+      int nx = gnext(n);
+      if (nx == 0)
+        return &absentkey;  /* not found */
+      n += nx;
+    }
+  }
+}
+
+
+/*
+** returns the index for 'k' if 'k' is an appropriate key to live in
+** the array part of a table, 0 otherwise.
+*/
+static unsigned int arrayindex (lua_Integer k) {
+  if (0 < k && l_castS2U(k) <= MAXASIZE)
+    return cast_uint(k);  /* 'key' is an appropriate array index */
+  else
+    return 0;
 }
 
 
@@ -156,46 +281,39 @@ static unsigned int arrayindex (const TValue *key) {
 ** elements in the array part, then elements in the hash part. The
 ** beginning of a traversal is signaled by 0.
 */
-static unsigned int findindex (lua_State *L, Table *t, StkId key) {
+static unsigned int findindex (lua_State *L, Table *t, TValue *key,
+                               unsigned int asize) {
   unsigned int i;
   if (ttisnil(key)) return 0;  /* first iteration */
-  i = arrayindex(key);
-  if (i != 0 && i <= t->sizearray)  /* is 'key' inside array part? */
+  i = ttisinteger(key) ? arrayindex(ivalue(key)) : 0;
+  if (i != 0 && i <= asize)  /* is 'key' inside array part? */
     return i;  /* yes; that's the index */
   else {
-    int nx;
-    Node *n = mainposition(t, key);
-    for (;;) {  /* check whether 'key' is somewhere in the chain */
-      /* key may be dead already, but it is ok to use it in 'next' */
-      if (luaV_rawequalobj(gkey(n), key) ||
-            (ttisdeadkey(gkey(n)) && iscollectable(key) &&
-             deadvalue(gkey(n)) == gcvalue(key))) {
-        i = cast_int(n - gnode(t, 0));  /* key index in hash table */
-        /* hash elements are numbered after array ones */
-        return (i + 1) + t->sizearray;
-      }
-      nx = gnext(n);
-      if (nx == 0)
-        luaG_runerror(L, "invalid key to 'next'");  /* key not found */
-      else n += nx;
-    }
+    const TValue *n = getgeneric(t, key);
+    if (unlikely(isabstkey(n)))
+      luaG_runerror(L, "invalid key to 'next'");  /* key not found */
+    i = cast_int(nodefromval(n) - gnode(t, 0));  /* key index in hash table */
+    /* hash elements are numbered after array ones */
+    return (i + 1) + asize;
   }
 }
 
 
 int luaH_next (lua_State *L, Table *t, StkId key) {
-  unsigned int i = findindex(L, t, key);  /* find original element */
-  for (; i < t->sizearray; i++) {  /* try first array part */
-    if (!ttisnil(&t->array[i])) {  /* a non-nil value? */
-      setivalue(key, i + 1);
-      setobj2s(L, key+1, &t->array[i]);
+  unsigned int asize = luaH_realasize(t);
+  unsigned int i = findindex(L, t, s2v(key), asize);  /* find original key */
+  for (; i < asize; i++) {  /* try first array part */
+    if (!isempty(&t->array[i])) {  /* a non-empty entry? */
+      setivalue(s2v(key), i + 1);
+      setobj2s(L, key + 1, &t->array[i]);
       return 1;
     }
   }
-  for (i -= t->sizearray; cast_int(i) < sizenode(t); i++) {  /* hash part */
-    if (!ttisnil(gval(gnode(t, i)))) {  /* a non-nil value? */
-      setobj2s(L, key, gkey(gnode(t, i)));
-      setobj2s(L, key+1, gval(gnode(t, i)));
+  for (i -= asize; cast_int(i) < sizenode(t); i++) {  /* hash part */
+    if (!isempty(gval(gnode(t, i)))) {  /* a non-empty entry? */
+      Node *n = gnode(t, i);
+      getnodekey(L, s2v(key), n);
+      setobj2s(L, key + 1, gval(n));
       return 1;
     }
   }
@@ -203,6 +321,12 @@ int luaH_next (lua_State *L, Table *t, StkId key) {
 }
 
 
+static void freehash (lua_State *L, Table *t) {
+  if (!isdummy(t))
+    luaM_freearray(L, t->node, cast_sizet(sizenode(t)));
+}
+
+
 /*
 ** {=============================================================
 ** Rehash
@@ -214,7 +338,8 @@ int luaH_next (lua_State *L, Table *t, StkId key) {
 ** "count array" where 'nums[i]' is the number of integers in the table
 ** between 2^(i - 1) + 1 and 2^i. 'pna' enters with the total number of
 ** integer keys in the table and leaves with the number of keys that
-** will go to the array part; return the optimal size.
+** will go to the array part; return the optimal size.  (The condition
+** 'twotoi > 0' in the for loop stops the loop if 'twotoi' overflows.)
 */
 static unsigned int computesizes (unsigned int nums[], unsigned int *pna) {
   int i;
@@ -226,12 +351,10 @@ static unsigned int computesizes (unsigned int nums[], unsigned int *pna) {
   for (i = 0, twotoi = 1;
        twotoi > 0 && *pna > twotoi / 2;
        i++, twotoi *= 2) {
-    if (nums[i] > 0) {
-      a += nums[i];
-      if (a > twotoi/2) {  /* more than half elements present? */
-        optimal = twotoi;  /* optimal size (till now) */
-        na = a;  /* all elements up to 'optimal' will go to array part */
-      }
+    a += nums[i];
+    if (a > twotoi/2) {  /* more than half elements present? */
+      optimal = twotoi;  /* optimal size (till now) */
+      na = a;  /* all elements up to 'optimal' will go to array part */
     }
   }
   lua_assert((optimal == 0 || optimal / 2 < na) && na <= optimal);
@@ -240,7 +363,7 @@ static unsigned int computesizes (unsigned int nums[], unsigned int *pna) {
 }
 
 
-static int countint (const TValue *key, unsigned int *nums) {
+static int countint (lua_Integer key, unsigned int *nums) {
   unsigned int k = arrayindex(key);
   if (k != 0) {  /* is 'key' an appropriate array index? */
     nums[luaO_ceillog2(k)]++;  /* count as such */
@@ -261,18 +384,19 @@ static unsigned int numusearray (const Table *t, unsigned int *nums) {
   unsigned int ttlg;  /* 2^lg */
   unsigned int ause = 0;  /* summation of 'nums' */
   unsigned int i = 1;  /* count to traverse all array keys */
+  unsigned int asize = limitasasize(t);  /* real array size */
   /* traverse each slice */
   for (lg = 0, ttlg = 1; lg <= MAXABITS; lg++, ttlg *= 2) {
     unsigned int lc = 0;  /* counter */
     unsigned int lim = ttlg;
-    if (lim > t->sizearray) {
-      lim = t->sizearray;  /* adjust upper limit */
+    if (lim > asize) {
+      lim = asize;  /* adjust upper limit */
       if (i > lim)
         break;  /* no more elements to count */
     }
     /* count elements in range (2^(lg - 1), 2^lg] */
     for (; i <= lim; i++) {
-      if (!ttisnil(&t->array[i-1]))
+      if (!isempty(&t->array[i-1]))
         lc++;
     }
     nums[lg] += lc;
@@ -288,8 +412,9 @@ static int numusehash (const Table *t, unsigned int *nums, unsigned int *pna) {
   int i = sizenode(t);
   while (i--) {
     Node *n = &t->node[i];
-    if (!ttisnil(gval(n))) {
-      ause += countint(gkey(n), nums);
+    if (!isempty(gval(n))) {
+      if (keyisinteger(n))
+        ause += countint(keyival(n), nums);
       totaluse++;
     }
   }
@@ -298,15 +423,13 @@ static int numusehash (const Table *t, unsigned int *nums, unsigned int *pna) {
 }
 
 
-static void setarrayvector (lua_State *L, Table *t, unsigned int size) {
-  unsigned int i;
-  luaM_reallocvector(L, t->array, t->sizearray, size, TValue);
-  for (i=t->sizearray; i<size; i++)
-     setnilvalue(&t->array[i]);
-  t->sizearray = size;
-}
-
-
+/*
+** Creates an array for the hash part of a table with the given
+** size, or reuses the dummy node if size is zero.
+** The computation for size overflow is in two steps: the first
+** comparison ensures that the shift in the second one does not
+** overflow.
+*/
 static void setnodevector (lua_State *L, Table *t, unsigned int size) {
   if (size == 0) {  /* no elements to hash part? */
     t->node = cast(Node *, dummynode);  /* use common 'dummynode' */
@@ -316,15 +439,15 @@ static void setnodevector (lua_State *L, Table *t, unsigned int size) {
   else {
     int i;
     int lsize = luaO_ceillog2(size);
-    if (lsize > MAXHBITS)
+    if (lsize > MAXHBITS || (1u << lsize) > MAXHSIZE)
       luaG_runerror(L, "table overflow");
     size = twoto(lsize);
     t->node = luaM_newvector(L, size, Node);
     for (i = 0; i < (int)size; i++) {
       Node *n = gnode(t, i);
       gnext(n) = 0;
-      setnilvalue(wgkey(n));
-      setnilvalue(gval(n));
+      setnilkey(n);
+      setempty(gval(n));
     }
     t->lsizenode = cast_byte(lsize);
     t->lastfree = gnode(t, size);  /* all positions are free */
@@ -332,55 +455,88 @@ static void setnodevector (lua_State *L, Table *t, unsigned int size) {
 }
 
 
-typedef struct {
-  Table *t;
-  unsigned int nhsize;
-} AuxsetnodeT;
-
-
-static void auxsetnode (lua_State *L, void *ud) {
-  AuxsetnodeT *asn = cast(AuxsetnodeT *, ud);
-  setnodevector(L, asn->t, asn->nhsize);
+/*
+** (Re)insert all elements from the hash part of 'ot' into table 't'.
+*/
+static void reinsert (lua_State *L, Table *ot, Table *t) {
+  int j;
+  int size = sizenode(ot);
+  for (j = 0; j < size; j++) {
+    Node *old = gnode(ot, j);
+    if (!isempty(gval(old))) {
+      /* doesn't need barrier/invalidate cache, as entry was
+         already present in the table */
+      TValue k;
+      getnodekey(L, &k, old);
+      setobjt2t(L, luaH_set(L, t, &k), gval(old));
+    }
+  }
 }
 
 
-void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
+/*
+** Exchange the hash part of 't1' and 't2'.
+*/
+static void exchangehashpart (Table *t1, Table *t2) {
+  lu_byte lsizenode = t1->lsizenode;
+  Node *node = t1->node;
+  Node *lastfree = t1->lastfree;
+  t1->lsizenode = t2->lsizenode;
+  t1->node = t2->node;
+  t1->lastfree = t2->lastfree;
+  t2->lsizenode = lsizenode;
+  t2->node = node;
+  t2->lastfree = lastfree;
+}
+
+
+/*
+** Resize table 't' for the new given sizes. Both allocations (for
+** the hash part and for the array part) can fail, which creates some
+** subtleties. If the first allocation, for the hash part, fails, an
+** error is raised and that is it. Otherwise, it copies the elements from
+** the shrinking part of the array (if it is shrinking) into the new
+** hash. Then it reallocates the array part.  If that fails, the table
+** is in its original state; the function frees the new hash part and then
+** raises the allocation error. Otherwise, it sets the new hash part
+** into the table, initializes the new part of the array (if any) with
+** nils and reinserts the elements of the old hash back into the new
+** parts of the table.
+*/
+void luaH_resize (lua_State *L, Table *t, unsigned int newasize,
                                           unsigned int nhsize) {
   unsigned int i;
-  int j;
-  AuxsetnodeT asn;
-  unsigned int oldasize = t->sizearray;
-  int oldhsize = allocsizenode(t);
-  Node *nold = t->node;  /* save old hash ... */
-  if (nasize > oldasize)  /* array part must grow? */
-    setarrayvector(L, t, nasize);
-  /* create new hash part with appropriate size */
-  asn.t = t; asn.nhsize = nhsize;
-  if (luaD_rawrunprotected(L, auxsetnode, &asn) != LUA_OK) {  /* mem. error? */
-    setarrayvector(L, t, oldasize);  /* array back to its original size */
-    luaD_throw(L, LUA_ERRMEM);  /* rethrow memory error */
-  }
-  if (nasize < oldasize) {  /* array part must shrink? */
-    t->sizearray = nasize;
-    /* re-insert elements from vanishing slice */
-    for (i=nasize; i<oldasize; i++) {
-      if (!ttisnil(&t->array[i]))
+  Table newt;  /* to keep the new hash part */
+  unsigned int oldasize = setlimittosize(t);
+  TValue *newarray;
+  /* create new hash part with appropriate size into 'newt' */
+  setnodevector(L, &newt, nhsize);
+  if (newasize < oldasize) {  /* will array shrink? */
+    t->alimit = newasize;  /* pretend array has new size... */
+    exchangehashpart(t, &newt);  /* and new hash */
+    /* re-insert into the new hash the elements from vanishing slice */
+    for (i = newasize; i < oldasize; i++) {
+      if (!isempty(&t->array[i]))
         luaH_setint(L, t, i + 1, &t->array[i]);
     }
-    /* shrink array */
-    luaM_reallocvector(L, t->array, oldasize, nasize, TValue);
+    t->alimit = oldasize;  /* restore current size... */
+    exchangehashpart(t, &newt);  /* and hash (in case of errors) */
   }
-  /* re-insert elements from hash part */
-  for (j = oldhsize - 1; j >= 0; j--) {
-    Node *old = nold + j;
-    if (!ttisnil(gval(old))) {
-      /* doesn't need barrier/invalidate cache, as entry was
-         already present in the table */
-      setobjt2t(L, luaH_set(L, t, gkey(old)), gval(old));
-    }
+  /* allocate new array */
+  newarray = luaM_reallocvector(L, t->array, oldasize, newasize, TValue);
+  if (unlikely(newarray == NULL && newasize > 0)) {  /* allocation failed? */
+    freehash(L, &newt);  /* release new hash part */
+    luaM_error(L);  /* raise error (with array unchanged) */
   }
-  if (oldhsize > 0)  /* not the dummy node? */
-    luaM_freearray(L, nold, cast(size_t, oldhsize)); /* free old hash */
+  /* allocation ok; initialize new part of the array */
+  exchangehashpart(t, &newt);  /* 't' has the new hash ('newt' has the old) */
+  t->array = newarray;  /* set new array part */
+  t->alimit = newasize;
+  for (i = oldasize; i < newasize; i++)  /* clear new slice of the array */
+     setempty(&t->array[i]);
+  /* re-insert elements from old hash part into new parts */
+  reinsert(L, &newt, t);  /* 'newt' now has the old hash */
+  freehash(L, &newt);  /* free old hash part */
 }
 
 
@@ -399,11 +555,13 @@ static void rehash (lua_State *L, Table *t, const TValue *ek) {
   int i;
   int totaluse;
   for (i = 0; i <= MAXABITS; i++) nums[i] = 0;  /* reset counts */
+  setlimittosize(t);
   na = numusearray(t, nums);  /* count keys in array part */
   totaluse = na;  /* all those keys are integer keys */
   totaluse += numusehash(t, nums, &na);  /* count keys in hash part */
   /* count extra key */
-  na += countint(ek, nums);
+  if (ttisinteger(ek))
+    na += countint(ivalue(ek), nums);
   totaluse++;
   /* compute new size for array part */
   asize = computesizes(nums, &na);
@@ -424,16 +582,15 @@ Table *luaH_new (lua_State *L) {
   t->metatable = NULL;
   t->flags = cast_byte(~0);
   t->array = NULL;
-  t->sizearray = 0;
+  t->alimit = 0;
   setnodevector(L, t, 0);
   return t;
 }
 
 
 void luaH_free (lua_State *L, Table *t) {
-  if (!isdummy(t))
-    luaM_freearray(L, t->node, cast(size_t, sizenode(t)));
-  luaM_freearray(L, t->array, t->sizearray);
+  freehash(L, t);
+  luaM_freearray(L, t->array, luaH_realasize(t));
   luaM_free(L, t);
 }
 
@@ -442,7 +599,7 @@ static Node *getfreepos (Table *t) {
   if (!isdummy(t)) {
     while (t->lastfree > t->node) {
       t->lastfree--;
-      if (ttisnil(gkey(t->lastfree)))
+      if (keyisnil(t->lastfree))
         return t->lastfree;
     }
   }
@@ -461,18 +618,20 @@ static Node *getfreepos (Table *t) {
 TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) {
   Node *mp;
   TValue aux;
-  if (ttisnil(key)) luaG_runerror(L, "table index is nil");
+  if (unlikely(ttisnil(key)))
+    luaG_runerror(L, "table index is nil");
   else if (ttisfloat(key)) {
+    lua_Number f = fltvalue(key);
     lua_Integer k;
-    if (luaV_tointeger(key, &k, 0)) {  /* does index fit in an integer? */
+    if (luaV_flttointeger(f, &k, 0)) {  /* does key fit in an integer? */
       setivalue(&aux, k);
       key = &aux;  /* insert it as an integer */
     }
-    else if (luai_numisnan(fltvalue(key)))
+    else if (unlikely(luai_numisnan(f)))
       luaG_runerror(L, "table index is NaN");
   }
-  mp = mainposition(t, key);
-  if (!ttisnil(gval(mp)) || isdummy(t)) {  /* main position is taken? */
+  mp = mainpositionTV(t, key);
+  if (!isempty(gval(mp)) || isdummy(t)) {  /* main position is taken? */
     Node *othern;
     Node *f = getfreepos(t);  /* get a free place */
     if (f == NULL) {  /* cannot find a free place? */
@@ -481,7 +640,7 @@ TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) {
       return luaH_set(L, t, key);  /* insert key into grown table */
     }
     lua_assert(!isdummy(t));
-    othern = mainposition(t, gkey(mp));
+    othern = mainposition(t, keytt(mp), &keyval(mp));
     if (othern != mp) {  /* is colliding node out of its main position? */
       /* yes; move colliding node into free position */
       while (othern + gnext(othern) != mp)  /* find previous */
@@ -492,7 +651,7 @@ TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) {
         gnext(f) += cast_int(mp - f);  /* correct 'next' */
         gnext(mp) = 0;  /* now 'mp' is free */
       }
-      setnilvalue(gval(mp));
+      setempty(gval(mp));
     }
     else {  /* colliding node is in its own main position */
       /* new node will go into free position */
@@ -503,24 +662,34 @@ TValue *luaH_newkey (lua_State *L, Table *t, const TValue *key) {
       mp = f;
     }
   }
-  setnodekey(L, &mp->i_key, key);
-  luaC_barrierback(L, t, key);
-  lua_assert(ttisnil(gval(mp)));
+  setnodekey(L, mp, key);
+  luaC_barrierback(L, obj2gco(t), key);
+  lua_assert(isempty(gval(mp)));
   return gval(mp);
 }
 
 
 /*
-** search function for integers
+** Search function for integers. If integer is inside 'alimit', get it
+** directly from the array part. Otherwise, if 'alimit' is not equal to
+** the real size of the array, key still can be in the array part. In
+** this case, try to avoid a call to 'luaH_realasize' when key is just
+** one more than the limit (so that it can be incremented without
+** changing the real size of the array).
 */
 const TValue *luaH_getint (Table *t, lua_Integer key) {
-  /* (1 <= key && key <= t->sizearray) */
-  if (l_castS2U(key) - 1 < t->sizearray)
+  if (l_castS2U(key) - 1u < t->alimit)  /* (1 <= key && key <= t->alimit)? */
     return &t->array[key - 1];
+  else if (!limitequalsasize(t) &&  /* key still may be in the array part? */
+           (l_castS2U(key) == t->alimit + 1 ||
+            l_castS2U(key) - 1u < luaH_realasize(t))) {
+    t->alimit = cast_uint(key);  /* probably '#t' is here now */
+    return &t->array[key - 1];
+  }
   else {
     Node *n = hashint(t, key);
     for (;;) {  /* check whether 'key' is somewhere in the chain */
-      if (ttisinteger(gkey(n)) && ivalue(gkey(n)) == key)
+      if (keyisinteger(n) && keyival(n) == key)
         return gval(n);  /* that's it */
       else {
         int nx = gnext(n);
@@ -528,7 +697,7 @@ const TValue *luaH_getint (Table *t, lua_Integer key) {
         n += nx;
       }
     }
-    return luaO_nilobject;
+    return &absentkey;
   }
 }
 
@@ -540,32 +709,12 @@ const TValue *luaH_getshortstr (Table *t, TString *key) {
   Node *n = hashstr(t, key);
   lua_assert(key->tt == LUA_TSHRSTR);
   for (;;) {  /* check whether 'key' is somewhere in the chain */
-    const TValue *k = gkey(n);
-    if (ttisshrstring(k) && eqshrstr(tsvalue(k), key))
+    if (keyisshrstr(n) && eqshrstr(keystrval(n), key))
       return gval(n);  /* that's it */
     else {
       int nx = gnext(n);
       if (nx == 0)
-        return luaO_nilobject;  /* not found */
-      n += nx;
-    }
-  }
-}
-
-
-/*
-** "Generic" get version. (Not that generic: not valid for integers,
-** which may be in array part, nor for floats with integral values.)
-*/
-static const TValue *getgeneric (Table *t, const TValue *key) {
-  Node *n = mainposition(t, key);
-  for (;;) {  /* check whether 'key' is somewhere in the chain */
-    if (luaV_rawequalobj(gkey(n), key))
-      return gval(n);  /* that's it */
-    else {
-      int nx = gnext(n);
-      if (nx == 0)
-        return luaO_nilobject;  /* not found */
+        return &absentkey;  /* not found */
       n += nx;
     }
   }
@@ -587,13 +736,13 @@ const TValue *luaH_getstr (Table *t, TString *key) {
 ** main search function
 */
 const TValue *luaH_get (Table *t, const TValue *key) {
-  switch (ttype(key)) {
+  switch (ttypetag(key)) {
     case LUA_TSHRSTR: return luaH_getshortstr(t, tsvalue(key));
     case LUA_TNUMINT: return luaH_getint(t, ivalue(key));
-    case LUA_TNIL: return luaO_nilobject;
+    case LUA_TNIL: return &absentkey;
     case LUA_TNUMFLT: {
       lua_Integer k;
-      if (luaV_tointeger(key, &k, 0)) /* index is int? */
+      if (luaV_flttointeger(fltvalue(key), &k, 0)) /* index is an integral? */
         return luaH_getint(t, k);  /* use specialized version */
       /* else... */
     }  /* FALLTHROUGH */
@@ -609,7 +758,7 @@ const TValue *luaH_get (Table *t, const TValue *key) {
 */
 TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
   const TValue *p = luaH_get(t, key);
-  if (p != luaO_nilobject)
+  if (!isabstkey(p))
     return cast(TValue *, p);
   else return luaH_newkey(L, t, key);
 }
@@ -618,7 +767,7 @@ TValue *luaH_set (lua_State *L, Table *t, const TValue *key) {
 void luaH_setint (lua_State *L, Table *t, lua_Integer key, TValue *value) {
   const TValue *p = luaH_getint(t, key);
   TValue *cell;
-  if (p != luaO_nilobject)
+  if (!isabstkey(p))
     cell = cast(TValue *, p);
   else {
     TValue k;
@@ -629,24 +778,49 @@ void luaH_setint (lua_State *L, Table *t, lua_Integer key, TValue *value) {
 }
 
 
-static lua_Unsigned unbound_search (Table *t, lua_Unsigned j) {
-  lua_Unsigned i = j;  /* i is zero or a present index */
-  j++;
-  /* find 'i' and 'j' such that i is present and j is not */
-  while (!ttisnil(luaH_getint(t, j))) {
-    i = j;
-    if (j > l_castS2U(LUA_MAXINTEGER) / 2) {  /* overflow? */
-      /* table was built with bad purposes: resort to linear search */
-      i = 1;
-      while (!ttisnil(luaH_getint(t, i))) i++;
-      return i - 1;
+/*
+** Try to find a boundary in the hash part of table 't'. From the
+** caller, we know that 'j' is zero or present and that 'j + 1' is
+** present. We want to find a larger key that is absent from the
+** table, so that we can do a binary search between the two keys to
+** find a boundary. We keep doubling 'j' until we get an absent index.
+** If the doubling would overflow, we try LUA_MAXINTEGER. If it is
+** absent, we are ready for the binary search. ('j', being max integer,
+** is larger or equal to 'i', but it cannot be equal because it is
+** absent while 'i' is present; so 'j > i'.) Otherwise, 'j' is a
+** boundary. ('j + 1' cannot be a present integer key because it is
+** not a valid integer in Lua.)
+*/
+static lua_Unsigned hash_search (Table *t, lua_Unsigned j) {
+  lua_Unsigned i;
+  if (j == 0) j++;  /* the caller ensures 'j + 1' is present */
+  do {
+    i = j;  /* 'i' is a present index */
+    if (j <= l_castS2U(LUA_MAXINTEGER) / 2)
+      j *= 2;
+    else {
+      j = LUA_MAXINTEGER;
+      if (isempty(luaH_getint(t, j)))  /* t[j] not present? */
+        break;  /* 'j' now is an absent index */
+      else  /* weird case */
+        return j;  /* well, max integer is a boundary... */
     }
-    j *= 2;
+  } while (!isempty(luaH_getint(t, j)));  /* repeat until an absent t[j] */
+  /* i < j  &&  t[i] present  &&  t[j] absent */
+  while (j - i > 1u) {  /* do a binary search between them */
+    lua_Unsigned m = (i + j) / 2;
+    if (isempty(luaH_getint(t, m))) j = m;
+    else i = m;
   }
-  /* now do a binary search between them */
-  while (j - i > 1) {
-    lua_Unsigned m = (i+j)/2;
-    if (ttisnil(luaH_getint(t, m))) j = m;
+  return i;
+}
+
+
+static unsigned int binsearch (const TValue *array, unsigned int i,
+                                                    unsigned int j) {
+  while (j - i > 1u) {  /* binary search */
+    unsigned int m = (i + j) / 2;
+    if (isempty(&array[m - 1])) j = m;
     else i = m;
   }
   return i;
@@ -654,25 +828,80 @@ static lua_Unsigned unbound_search (Table *t, lua_Unsigned j) {
 
 
 /*
-** Try to find a boundary in table 't'. A 'boundary' is an integer index
-** such that t[i] is non-nil and t[i+1] is nil (and 0 if t[1] is nil).
+** Try to find a boundary in table 't'. (A 'boundary' is an integer index
+** such that t[i] is present and t[i+1] is absent, or 0 if t[1] is absent
+** and 'maxinteger' if t[maxinteger] is present.)
+** (In the next explanation, we use Lua indices, that is, with base 1.
+** The code itself uses base 0 when indexing the array part of the table.)
+** The code starts with 'limit', a position in the array part that may
+** be a boundary.
+** (1) If 't[limit]' is empty, there must be a boundary before it.
+** As a common case (e.g., after 't[#t]=nil'), check whether 'hint-1'
+** is present. If so, it is a boundary. Otherwise, do a binary search
+** between 0 and limit to find a boundary. In both cases, try to
+** use this boundary as the new 'limit', as a hint for the next call.
+** (2) If 't[limit]' is not empty and the array has more elements
+** after 'limit', try to find a boundary there. Again, try first
+** the special case (which should be quite frequent) where 'limit+1'
+** is empty, so that 'limit' is a boundary. Otherwise, check the
+** last element of the array part (set it as a new limit). If it is empty,
+** there must be a boundary between the old limit (present) and the new
+** limit (absent), which is found with a binary search. (This boundary
+** always can be a new limit.)
+** (3) The last case is when there are no elements in the array part
+** (limit == 0) or its last element (the new limit) is present.
+** In this case, must check the hash part. If there is no hash part,
+** the boundary is 0. Otherwise, if 'limit+1' is absent, 'limit' is
+** a boundary. Finally, if 'limit+1' is present, call 'hash_search'
+** to find a boundary in the hash part of the table. (In those
+** cases, the boundary is not inside the array part, and therefore
+** cannot be used as a new limit.)
 */
 lua_Unsigned luaH_getn (Table *t) {
-  unsigned int j = t->sizearray;
-  if (j > 0 && ttisnil(&t->array[j - 1])) {
-    /* there is a boundary in the array part: (binary) search for it */
-    unsigned int i = 0;
-    while (j - i > 1) {
-      unsigned int m = (i+j)/2;
-      if (ttisnil(&t->array[m - 1])) j = m;
-      else i = m;
+  unsigned int limit = t->alimit;
+  if (limit > 0 && isempty(&t->array[limit - 1])) {
+    /* (1) there must be a boundary before 'limit' */
+    if (limit >= 2 && !isempty(&t->array[limit - 2])) {
+      /* 'limit - 1' is a boundary; can it be a new limit? */
+      if (ispow2realasize(t) && !ispow2(limit - 1)) {
+        t->alimit = limit - 1;
+        setnorealasize(t);
+      }
+      return limit - 1;
+    }
+    else {  /* must search for a boundary in [0, limit] */
+      unsigned int boundary = binsearch(t->array, 0, limit);
+      /* can this boundary represent the real size of the array? */
+      if (ispow2realasize(t) && boundary > luaH_realasize(t) / 2) {
+        t->alimit = boundary;  /* use it as the new limit */
+        setnorealasize(t);
+      }
+      return boundary;
     }
-    return i;
   }
-  /* else must find a boundary in hash part */
-  else if (isdummy(t))  /* hash part is empty? */
-    return j;  /* that is easy... */
-  else return unbound_search(t, j);
+  /* 'limit' is zero or present in table */
+  if (!limitequalsasize(t)) {
+    /* (2) 'limit' > 0 and array has more elements after 'limit' */
+    if (isempty(&t->array[limit]))  /* 'limit + 1' is empty? */
+      return limit;  /* this is the boundary */
+    /* else, try last element in the array */
+    limit = luaH_realasize(t);
+    if (isempty(&t->array[limit - 1])) {  /* empty? */
+      /* there must be a boundary in the array after old limit,
+         and it must be a valid new limit */
+      unsigned int boundary = binsearch(t->array, t->alimit, limit);
+      t->alimit = boundary;
+      return boundary;
+    }
+    /* else, new limit is present in the table; check the hash part */
+  }
+  /* (3) 'limit' is the last element and either is zero or present in table */
+  lua_assert(limit == luaH_realasize(t) &&
+             (limit == 0 || !isempty(&t->array[limit - 1])));
+  if (isdummy(t) || isempty(luaH_getint(t, cast(lua_Integer, limit + 1))))
+    return limit;  /* 'limit + 1' is absent... */
+  else  /* 'limit + 1' is also present */
+    return hash_search(t, limit);
 }
 
 
@@ -680,7 +909,7 @@ lua_Unsigned luaH_getn (Table *t) {
 #if defined(LUA_DEBUG)
 
 Node *luaH_mainposition (const Table *t, const TValue *key) {
-  return mainposition(t, key);
+  return mainpositionTV(t, key);
 }
 
 int luaH_isdummy (const Table *t) { return isdummy(t); }

ltable.h

@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.h,v 2.23.1.2 2018/05/24 19:39:05 roberto Exp $
+** $Id: ltable.h,v 2.27 2018/06/01 16:51:34 roberto Exp roberto $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -12,18 +12,9 @@
 
 #define gnode(t,i)	(&(t)->node[i])
 #define gval(n)		(&(n)->i_val)
-#define gnext(n)	((n)->i_key.nk.next)
+#define gnext(n)	((n)->u.next)
 
 
-/* 'const' to avoid wrong writings that can mess up field 'next' */
-#define gkey(n)		cast(const TValue*, (&(n)->i_key.tvk))
-
-/*
-** writable version of 'gkey'; allows updates to individual fields,
-** but not to the whole (which has incompatible type)
-*/
-#define wgkey(n)		(&(n)->i_key.nk)
-
 #define invalidateTMcache(t)	((t)->flags = 0)
 
 
@@ -35,9 +26,8 @@
 #define allocsizenode(t)	(isdummy(t) ? 0 : sizenode(t))
 
 
-/* returns the key, given the value of a table entry */
-#define keyfromval(v) \
-  (gkey(cast(Node *, cast(char *, (v)) - offsetof(Node, i_val))))
+/* returns the Node, given the value of a table entry */
+#define nodefromval(v) 	cast(Node *, (v))
 
 
 LUAI_FUNC const TValue *luaH_getint (Table *t, lua_Integer key);
@@ -55,6 +45,7 @@ LUAI_FUNC void luaH_resizearray (lua_State *L, Table *t, unsigned int nasize);
 LUAI_FUNC void luaH_free (lua_State *L, Table *t);
 LUAI_FUNC int luaH_next (lua_State *L, Table *t, StkId key);
 LUAI_FUNC lua_Unsigned luaH_getn (Table *t);
+LUAI_FUNC unsigned int luaH_realasize (const Table *t);
 
 
 #if defined(LUA_DEBUG)

ltablib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ltablib.c,v 1.93.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: ltablib.c,v 1.96 2018/03/16 14:18:18 roberto Exp roberto $
 ** Library for Table Manipulation
 ** See Copyright Notice in lua.h
 */
@@ -58,24 +58,6 @@ static void checktab (lua_State *L, int arg, int what) {
 }
 
 
-#if defined(LUA_COMPAT_MAXN)
-static int maxn (lua_State *L) {
-  lua_Number max = 0;
-  luaL_checktype(L, 1, LUA_TTABLE);
-  lua_pushnil(L);  /* first key */
-  while (lua_next(L, 1)) {
-    lua_pop(L, 1);  /* remove value */
-    if (lua_type(L, -1) == LUA_TNUMBER) {
-      lua_Number v = lua_tonumber(L, -1);
-      if (v > max) max = v;
-    }
-  }
-  lua_pushnumber(L, max);
-  return 1;
-}
-#endif
-
-
 static int tinsert (lua_State *L) {
   lua_Integer e = aux_getn(L, 1, TAB_RW) + 1;  /* first empty element */
   lua_Integer pos;  /* where to insert new element */
@@ -114,7 +96,7 @@ static int tremove (lua_State *L) {
     lua_seti(L, 1, pos);  /* t[pos] = t[pos + 1] */
   }
   lua_pushnil(L);
-  lua_seti(L, 1, pos);  /* t[pos] = nil */
+  lua_seti(L, 1, pos);  /* remove entry t[pos] */
   return 1;
 }
 
@@ -191,7 +173,7 @@ static int tconcat (lua_State *L) {
 ** =======================================================
 */
 
-static int pack (lua_State *L) {
+static int tpack (lua_State *L) {
   int i;
   int n = lua_gettop(L);  /* number of elements to pack */
   lua_createtable(L, n, 1);  /* create result table */
@@ -204,7 +186,7 @@ static int pack (lua_State *L) {
 }
 
 
-static int unpack (lua_State *L) {
+static int tunpack (lua_State *L) {
   lua_Unsigned n;
   lua_Integer i = luaL_optinteger(L, 2, 1);
   lua_Integer e = luaL_opt(L, luaL_checkinteger, 3, luaL_len(L, 1));
@@ -425,12 +407,9 @@ static int sort (lua_State *L) {
 
 static const luaL_Reg tab_funcs[] = {
   {"concat", tconcat},
-#if defined(LUA_COMPAT_MAXN)
-  {"maxn", maxn},
-#endif
   {"insert", tinsert},
-  {"pack", pack},
-  {"unpack", unpack},
+  {"pack", tpack},
+  {"unpack", tunpack},
   {"remove", tremove},
   {"move", tmove},
   {"sort", sort},
@@ -440,11 +419,6 @@ static const luaL_Reg tab_funcs[] = {
 
 LUAMOD_API int luaopen_table (lua_State *L) {
   luaL_newlib(L, tab_funcs);
-#if defined(LUA_COMPAT_UNPACK)
-  /* _G.unpack = table.unpack */
-  lua_getfield(L, -1, "unpack");
-  lua_setglobal(L, "unpack");
-#endif
   return 1;
 }
 

ltests.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ltests.c,v 2.211.1.1 2017/04/19 17:39:34 roberto Exp $
+** $Id: ltests.c,v 2.244 2018/06/11 14:19:50 roberto Exp roberto $
 ** Internal Module for Debugging of the Lua Implementation
 ** See Copyright Notice in lua.h
 */
@@ -43,10 +43,7 @@
 void *l_Trick = 0;
 
 
-int islocked = 0;
-
-
-#define obj_at(L,k)	(L->ci->func + (k))
+#define obj_at(L,k)	s2v(L->ci->func + (k))
 
 
 static int runC (lua_State *L, lua_State *L1, const char *pc);
@@ -81,7 +78,7 @@ static int tpanic (lua_State *L) {
 #define MARK		0x55  /* 01010101 (a nice pattern) */
 
 typedef union Header {
-  L_Umaxalign a;  /* ensures maximum alignment for Header */
+  LUAI_MAXALIGN;
   struct {
     size_t size;
     int type;
@@ -105,7 +102,7 @@ typedef union Header {
 
 
 Memcontrol l_memcontrol =
-  {0L, 0L, 0L, 0L, {0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L}};
+  {0L, 0L, 0L, 0L, (~0L), {0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L}};
 
 
 static void freeblock (Memcontrol *mc, Header *block) {
@@ -113,7 +110,7 @@ static void freeblock (Memcontrol *mc, Header *block) {
     size_t size = block->d.size;
     int i;
     for (i = 0; i < MARKSIZE; i++)  /* check marks after block */
-      lua_assert(*(cast(char *, block + 1) + size + i) == MARK);
+      lua_assert(*(cast_charp(block + 1) + size + i) == MARK);
     mc->objcount[block->d.type]--;
     fillmem(block, sizeof(Header) + size + MARKSIZE);  /* erase block */
     free(block);  /* actually free block */
@@ -144,7 +141,12 @@ void *debug_realloc (void *ud, void *b, size_t oldsize, size_t size) {
     freeblock(mc, block);
     return NULL;
   }
-  else if (size > oldsize && mc->total+size-oldsize > mc->memlimit)
+  if (mc->countlimit != ~0UL && size > 0) {  /* count limit in use? */
+    if (mc->countlimit == 0)
+      return NULL;  /* fake a memory allocation error */
+    mc->countlimit--;
+  }
+  if (size > oldsize && mc->total+size-oldsize > mc->memlimit)
     return NULL;  /* fake a memory allocation error */
   else {
     Header *newblock;
@@ -159,10 +161,10 @@ void *debug_realloc (void *ud, void *b, size_t oldsize, size_t size) {
       freeblock(mc, block);  /* erase (and check) old copy */
     }
     /* initialize new part of the block with something weird */
-    fillmem(cast(char *, newblock + 1) + commonsize, size - commonsize);
+    fillmem(cast_charp(newblock + 1) + commonsize, size - commonsize);
     /* initialize marks after block */
     for (i = 0; i < MARKSIZE; i++)
-      *(cast(char *, newblock + 1) + size + i) = MARK;
+      *(cast_charp(newblock + 1) + size + i) = MARK;
     newblock->d.size = size;
     newblock->d.type = type;
     mc->total += size;
@@ -186,18 +188,39 @@ void *debug_realloc (void *ud, void *b, size_t oldsize, size_t size) {
 */
 
 
+/*
+** Check GC invariants. For incremental mode, a black object cannot
+** point to a white one. For generational mode, really old objects
+** cannot point to young objects. Both old1 and touched2 objects
+** cannot point to new objects (but can point to survivals).
+** (Threads and open upvalues, despite being marked "really old",
+** continue to be visited in all collections, and therefore can point to
+** new objects. They, and only they, are old but gray.)
+*/
 static int testobjref1 (global_State *g, GCObject *f, GCObject *t) {
   if (isdead(g,t)) return 0;
-  if (!issweepphase(g))
-    return !(isblack(f) && iswhite(t));
-  else return 1;
+  if (issweepphase(g))
+    return 1;  /* no invariants */
+  else if (g->gckind == KGC_INC)
+    return !(isblack(f) && iswhite(t));  /* basic incremental invariant */
+  else {  /* generational mode */
+    if ((getage(f) == G_OLD && isblack(f)) && !isold(t))
+      return 0;
+    if (((getage(f) == G_OLD1 || getage(f) == G_TOUCHED2) && isblack(f)) &&
+          getage(t) == G_NEW)
+      return 0;
+    return 1;
+  }
 }
 
 
 static void printobj (global_State *g, GCObject *o) {
-  printf("||%s(%p)-%c(%02X)||",
+  printf("||%s(%p)-%c%c(%02X)||",
            ttypename(novariant(o->tt)), (void *)o,
-           isdead(g,o)?'d':isblack(o)?'b':iswhite(o)?'w':'g', o->marked);
+           isdead(g,o) ? 'd' : isblack(o) ? 'b' : iswhite(o) ? 'w' : 'g',
+           "ns01oTt"[getage(o)], o->marked);
+  if (o->tt == LUA_TSHRSTR || o->tt == LUA_TLNGSTR)
+    printf(" '%s'", getstr(gco2ts(o)));
 }
 
 
@@ -225,21 +248,33 @@ static void checkvalref (global_State *g, GCObject *f, const TValue *t) {
 
 static void checktable (global_State *g, Table *h) {
   unsigned int i;
+  unsigned int asize = luaH_realasize(h);
   Node *n, *limit = gnode(h, sizenode(h));
   GCObject *hgc = obj2gco(h);
   checkobjref(g, hgc, h->metatable);
-  for (i = 0; i < h->sizearray; i++)
+  for (i = 0; i < asize; i++)
     checkvalref(g, hgc, &h->array[i]);
   for (n = gnode(h, 0); n < limit; n++) {
-    if (!ttisnil(gval(n))) {
-      lua_assert(!ttisnil(gkey(n)));
-      checkvalref(g, hgc, gkey(n));
+    if (!isempty(gval(n))) {
+      TValue k;
+      getnodekey(g->mainthread, &k, n);
+      lua_assert(!keyisnil(n));
+      checkvalref(g, hgc, &k);
       checkvalref(g, hgc, gval(n));
     }
   }
 }
 
 
+static void checkudata (global_State *g, Udata *u) {
+  int i;
+  GCObject *hgc = obj2gco(u);
+  checkobjref(g, hgc, u->metatable);
+  for (i = 0; i < u->nuvalue; i++)
+    checkvalref(g, hgc, &u->uv[i].uv);
+}
+
+
 /*
 ** All marks are conditional because a GC may happen while the
 ** prototype is still being created
@@ -262,7 +297,6 @@ static void checkproto (global_State *g, Proto *f) {
 }
 
 
-
 static void checkCclosure (global_State *g, CClosure *cl) {
   GCObject *clgc = obj2gco(cl);
   int i;
@@ -278,22 +312,19 @@ static void checkLclosure (global_State *g, LClosure *cl) {
   for (i=0; i<cl->nupvalues; i++) {
     UpVal *uv = cl->upvals[i];
     if (uv) {
-      if (!upisopen(uv))  /* only closed upvalues matter to invariant */
-        checkvalref(g, clgc, uv->v);
-      lua_assert(uv->refcount > 0);
+      checkobjref(g, clgc, uv);
+      if (!upisopen(uv))
+        checkvalref(g, obj2gco(uv), uv->v);
     }
   }
 }
 
 
-static int lua_checkpc (lua_State *L, CallInfo *ci) {
+static int lua_checkpc (CallInfo *ci) {
   if (!isLua(ci)) return 1;
   else {
-    /* if function yielded (inside a hook), real 'func' is in 'extra' field */
-    StkId f = (L->status != LUA_YIELD || ci != L->ci)
-              ? ci->func
-              : restorestack(L, ci->extra);
-    Proto *p = clLvalue(f)->p;
+    StkId f = ci->func;
+    Proto *p = clLvalue(s2v(f))->p;
     return p->code <= ci->u.l.savedpc &&
            ci->u.l.savedpc <= p->code + p->sizecode;
   }
@@ -309,102 +340,138 @@ static void checkstack (global_State *g, lua_State *L1) {
     lua_assert(upisopen(uv));  /* must be open */
   for (ci = L1->ci; ci != NULL; ci = ci->previous) {
     lua_assert(ci->top <= L1->stack_last);
-    lua_assert(lua_checkpc(L1, ci));
+    lua_assert(lua_checkpc(ci));
   }
   if (L1->stack) {  /* complete thread? */
     for (o = L1->stack; o < L1->stack_last + EXTRA_STACK; o++)
-      checkliveness(L1, o);  /* entire stack must have valid values */
+      checkliveness(L1, s2v(o));  /* entire stack must have valid values */
   }
   else lua_assert(L1->stacksize == 0);
 }
 
 
-static void checkobject (global_State *g, GCObject *o, int maybedead) {
-  if (isdead(g, o))
-    lua_assert(maybedead);
-  else {
-    lua_assert(g->gcstate != GCSpause || iswhite(o));
-    switch (o->tt) {
-      case LUA_TUSERDATA: {
-        TValue uservalue;
-        Table *mt = gco2u(o)->metatable;
-        checkobjref(g, o, mt);
-        getuservalue(g->mainthread, gco2u(o), &uservalue);
-        checkvalref(g, o, &uservalue);
-        break;
-      }
-      case LUA_TTABLE: {
-        checktable(g, gco2t(o));
-        break;
-      }
-      case LUA_TTHREAD: {
-        checkstack(g, gco2th(o));
-        break;
-      }
-      case LUA_TLCL: {
-        checkLclosure(g, gco2lcl(o));
-        break;
-      }
-      case LUA_TCCL: {
-        checkCclosure(g, gco2ccl(o));
-        break;
-      }
-      case LUA_TPROTO: {
-        checkproto(g, gco2p(o));
-        break;
-      }
-      case LUA_TSHRSTR:
-      case LUA_TLNGSTR: {
-        lua_assert(!isgray(o));  /* strings are never gray */
-        break;
-      }
-      default: lua_assert(0);
+static void checkrefs (global_State *g, GCObject *o) {
+  switch (o->tt) {
+    case LUA_TUSERDATA: {
+      checkudata(g, gco2u(o));
+      break;
     }
+    case LUA_TUPVAL: {
+      checkvalref(g, o, gco2upv(o)->v);
+      break;
+    }
+    case LUA_TTABLE: {
+      checktable(g, gco2t(o));
+      break;
+    }
+    case LUA_TTHREAD: {
+      checkstack(g, gco2th(o));
+      break;
+    }
+    case LUA_TLCL: {
+      checkLclosure(g, gco2lcl(o));
+      break;
+    }
+    case LUA_TCCL: {
+      checkCclosure(g, gco2ccl(o));
+      break;
+    }
+    case LUA_TPROTO: {
+      checkproto(g, gco2p(o));
+      break;
+    }
+    case LUA_TSHRSTR:
+    case LUA_TLNGSTR: {
+      lua_assert(!isgray(o));  /* strings are never gray */
+      break;
+    }
+    default: lua_assert(0);
   }
 }
 
 
-#define TESTGRAYBIT		7
+/*
+** Check consistency of an object:
+** - Dead objects can only happen in the 'allgc' list during a sweep
+** phase (controled by the caller through 'maybedead').
+** - During pause, all objects must be white.
+** - In generational mode:
+**   * objects must be old enough for their lists ('listage').
+**   * old objects cannot be white.
+**   * old objects must be black, except for 'touched1', 'old0',
+** threads, and open upvalues.
+*/
+static void checkobject (global_State *g, GCObject *o, int maybedead,
+                         int listage) {
+  if (isdead(g, o))
+    lua_assert(maybedead);
+  else {
+    lua_assert(g->gcstate != GCSpause || iswhite(o));
+    if (g->gckind == KGC_GEN) {  /* generational mode? */
+      lua_assert(getage(o) >= listage);
+      lua_assert(!iswhite(o) || !isold(o));
+      if (isold(o)) {
+        lua_assert(isblack(o) ||
+        getage(o) == G_TOUCHED1 ||
+        getage(o) == G_OLD0 ||
+        o->tt == LUA_TTHREAD ||
+        (o->tt == LUA_TPROTO &&
+            (gco2p(o)->cache != NULL || gco2p(o)->cachemiss >= MAXMISS)) ||
+        (o->tt == LUA_TUPVAL && upisopen(gco2upv(o))));
+      }
+    }
+    checkrefs(g, o);
+  }
+}
+
 
 static void checkgraylist (global_State *g, GCObject *o) {
   ((void)g);  /* better to keep it available if we need to print an object */
   while (o) {
-    lua_assert(isgray(o));
-    lua_assert(!testbit(o->marked, TESTGRAYBIT));
-    l_setbit(o->marked, TESTGRAYBIT);
+    lua_assert(isgray(o) || getage(o) == G_TOUCHED2);
     switch (o->tt) {
       case LUA_TTABLE: o = gco2t(o)->gclist; break;
       case LUA_TLCL: o = gco2lcl(o)->gclist; break;
       case LUA_TCCL: o = gco2ccl(o)->gclist; break;
       case LUA_TTHREAD: o = gco2th(o)->gclist; break;
       case LUA_TPROTO: o = gco2p(o)->gclist; break;
-      default: lua_assert(0);  /* other objects cannot be gray */
+      default: lua_assert(0);  /* other objects cannot be in a gray list */
     }
   }
 }
 
 
 /*
-** mark all objects in gray lists with the TESTGRAYBIT, so that
-** 'checkmemory' can check that all gray objects are in a gray list
+** Check objects in gray lists.
 */
-static void markgrays (global_State *g) {
+static void checkgrays (global_State *g) {
   if (!keepinvariant(g)) return;
   checkgraylist(g, g->gray);
   checkgraylist(g, g->grayagain);
   checkgraylist(g, g->weak);
   checkgraylist(g, g->ephemeron);
-  checkgraylist(g, g->allweak);
+  checkgraylist(g, g->protogray);
 }
 
 
-static void checkgray (global_State *g, GCObject *o) {
-  for (; o != NULL; o = o->next) {
-    if (isgray(o)) {
-      lua_assert(!keepinvariant(g) || testbit(o->marked, TESTGRAYBIT));
-      resetbit(o->marked, TESTGRAYBIT);
-    }
-    lua_assert(!testbit(o->marked, TESTGRAYBIT));
+static void checklist (global_State *g, int maybedead, int tof,
+  GCObject *newl, GCObject *survival, GCObject *old, GCObject *reallyold) {
+  GCObject *o;
+  for (o = newl; o != survival; o = o->next) {
+    checkobject(g, o, maybedead, G_NEW);
+    lua_assert(!tof == !tofinalize(o));
+  }
+  for (o = survival; o != old; o = o->next) {
+    checkobject(g, o, 0, G_SURVIVAL);
+    lua_assert(!tof == !tofinalize(o));
+  }
+  for (o = old; o != reallyold; o = o->next) {
+    checkobject(g, o, 0, G_OLD1);
+    lua_assert(!tof == !tofinalize(o));
+  }
+  for (o = reallyold; o != NULL; o = o->next) {
+    checkobject(g, o, 0, G_OLD);
+    lua_assert(!tof == !tofinalize(o));
   }
 }
 
@@ -418,32 +485,24 @@ int lua_checkmemory (lua_State *L) {
     lua_assert(!iswhite(gcvalue(&g->l_registry)));
   }
   lua_assert(!isdead(g, gcvalue(&g->l_registry)));
-  checkstack(g, g->mainthread);
-  resetbit(g->mainthread->marked, TESTGRAYBIT);
   lua_assert(g->sweepgc == NULL || issweepphase(g));
-  markgrays(g);
+  checkgrays(g);
+
   /* check 'fixedgc' list */
   for (o = g->fixedgc; o != NULL; o = o->next) {
-    lua_assert(o->tt == LUA_TSHRSTR && isgray(o));
+    lua_assert(o->tt == LUA_TSHRSTR && isgray(o) && getage(o) == G_OLD);
   }
+
   /* check 'allgc' list */
-  checkgray(g, g->allgc);
   maybedead = (GCSatomic < g->gcstate && g->gcstate <= GCSswpallgc);
-  for (o = g->allgc; o != NULL; o = o->next) {
-    checkobject(g, o, maybedead);
-    lua_assert(!tofinalize(o));
-  }
+  checklist(g, maybedead, 0, g->allgc, g->survival, g->old, g->reallyold);
+
   /* check 'finobj' list */
-  checkgray(g, g->finobj);
-  for (o = g->finobj; o != NULL; o = o->next) {
-    checkobject(g, o, 0);
-    lua_assert(tofinalize(o));
-    lua_assert(o->tt == LUA_TUSERDATA || o->tt == LUA_TTABLE);
-  }
+  checklist(g, 0, 1, g->finobj, g->finobjsur, g->finobjold, g->finobjrold);
+
   /* check 'tobefnz' list */
-  checkgray(g, g->tobefnz);
   for (o = g->tobefnz; o != NULL; o = o->next) {
-    checkobject(g, o, 0);
+    checkobject(g, o, 0, G_NEW);
     lua_assert(tofinalize(o));
     lua_assert(o->tt == LUA_TUSERDATA || o->tt == LUA_TTABLE);
   }
@@ -465,22 +524,29 @@ static char *buildop (Proto *p, int pc, char *buff) {
   Instruction i = p->code[pc];
   OpCode o = GET_OPCODE(i);
   const char *name = luaP_opnames[o];
-  int line = getfuncline(p, pc);
+  int line = luaG_getfuncline(p, pc);
   sprintf(buff, "(%4d) %4d - ", line, pc);
   switch (getOpMode(o)) {
     case iABC:
-      sprintf(buff+strlen(buff), "%-12s%4d %4d %4d", name,
-              GETARG_A(i), GETARG_B(i), GETARG_C(i));
+      sprintf(buff+strlen(buff), "%-12s%4d %4d %4d%s", name,
+              GETARG_A(i), GETARG_B(i), GETARG_C(i),
+              GETARG_k(i) ? " (k)" : "");
       break;
     case iABx:
-      sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_Bx(i));
+      sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i),
+                                                       GETARG_Bx(i));
       break;
     case iAsBx:
-      sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_sBx(i));
+      sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i),
+                                                       GETARG_sBx(i));
       break;
     case iAx:
       sprintf(buff+strlen(buff), "%-12s%4d", name, GETARG_Ax(i));
       break;
+    case isJ:
+      sprintf(buff+strlen(buff), "%-12s%4d (%1d)", name, GETARG_sJ(i),
+                                                         !!GETARG_m(i));
+      break;
   }
   return buff;
 }
@@ -523,6 +589,22 @@ static int listcode (lua_State *L) {
 }
 
 
+static int printcode (lua_State *L) {
+  int pc;
+  Proto *p;
+  luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
+                 1, "Lua function expected");
+  p = getproto(obj_at(L, 1));
+  printf("maxstack: %d\n", p->maxstacksize);
+  printf("numparams: %d\n", p->numparams);
+  for (pc=0; pc<p->sizecode; pc++) {
+    char buff[100];
+    printf("%d\t%s\n", pc + 1, buildop(p, pc, buff));
+  }
+  return 0;
+}
+
+
 static int listk (lua_State *L) {
   Proto *p;
   int i;
@@ -571,7 +653,7 @@ static int get_limits (lua_State *L) {
   setnameval(L, "BITS_INT", LUAI_BITSINT);
   setnameval(L, "MAXARG_Ax", MAXARG_Ax);
   setnameval(L, "MAXARG_Bx", MAXARG_Bx);
-  setnameval(L, "MAXARG_sBx", MAXARG_sBx);
+  setnameval(L, "OFFSET_sBx", OFFSET_sBx);
   setnameval(L, "BITS_INT", LUAI_BITSINT);
   setnameval(L, "LFPF", LFIELDS_PER_FLUSH);
   setnameval(L, "NUM_OPCODES", NUM_OPCODES);
@@ -606,6 +688,15 @@ static int mem_query (lua_State *L) {
 }
 
 
+static int alloc_count (lua_State *L) {
+  if (lua_isnone(L, 1))
+    l_memcontrol.countlimit = ~0L;
+  else
+    l_memcontrol.countlimit = luaL_checkinteger(L, 1);
+  return 0;
+}
+  
+
 static int settrick (lua_State *L) {
   if (ttisnil(obj_at(L, 1)))
     l_Trick = NULL;
@@ -625,17 +716,50 @@ static int gc_color (lua_State *L) {
     GCObject *obj = gcvalue(o);
     lua_pushstring(L, isdead(G(L), obj) ? "dead" :
                       iswhite(obj) ? "white" :
-                      isblack(obj) ? "black" : "grey");
+                      isblack(obj) ? "black" : "gray");
   }
   return 1;
 }
 
 
+static int gc_age (lua_State *L) {
+  TValue *o;
+  luaL_checkany(L, 1);
+  o = obj_at(L, 1);
+  if (!iscollectable(o))
+    lua_pushstring(L, "no collectable");
+  else {
+    static const char *gennames[] = {"new", "survival", "old0", "old1",
+                                     "old", "touched1", "touched2"};
+    GCObject *obj = gcvalue(o);
+    lua_pushstring(L, gennames[getage(obj)]);
+  }
+  return 1;
+}
+
+
+static int gc_printobj (lua_State *L) {
+  TValue *o;
+  luaL_checkany(L, 1);
+  o = obj_at(L, 1);
+  if (!iscollectable(o))
+    printf("no collectable\n");
+  else {
+    GCObject *obj = gcvalue(o);
+    printobj(G(L), obj);
+    printf("\n");
+  }
+  return 0;
+}
+
+
 static int gc_state (lua_State *L) {
-  static const char *statenames[] = {"propagate", "atomic", "sweepallgc",
-      "sweepfinobj", "sweeptobefnz", "sweepend", "pause", ""};
-  static const int states[] = {GCSpropagate, GCSatomic, GCSswpallgc,
-      GCSswpfinobj, GCSswptobefnz, GCSswpend, GCSpause, -1};
+  static const char *statenames[] = {
+    "propagate", "atomic", "enteratomic", "sweepallgc", "sweepfinobj",
+    "sweeptobefnz", "sweepend", "callfin", "pause", ""};
+  static const int states[] = {
+    GCSpropagate, GCSenteratomic, GCSatomic, GCSswpallgc, GCSswpfinobj,
+    GCSswptobefnz, GCSswpend, GCScallfin, GCSpause, -1};
   int option = states[luaL_checkoption(L, 1, "", statenames)];
   if (option == -1) {
     lua_pushstring(L, statenames[G(L)->gcstate]);
@@ -643,6 +767,8 @@ static int gc_state (lua_State *L) {
   }
   else {
     global_State *g = G(L);
+    if (G(L)->gckind == KGC_GEN)
+      luaL_error(L, "cannot change states in generational mode");
     lua_lock(L);
     if (option < g->gcstate) {  /* must cross 'pause'? */
       luaC_runtilstate(L, bitmask(GCSpause));  /* run until pause */
@@ -675,31 +801,39 @@ static int stacklevel (lua_State *L) {
   unsigned long a = 0;
   lua_pushinteger(L, (L->top - L->stack));
   lua_pushinteger(L, (L->stack_last - L->stack));
+  lua_pushinteger(L, L->nCcalls);
+  lua_pushinteger(L, L->nci);
   lua_pushinteger(L, (unsigned long)&a);
-  return 3;
+  return 5;
 }
 
 
 static int table_query (lua_State *L) {
   const Table *t;
   int i = cast_int(luaL_optinteger(L, 2, -1));
+  unsigned int asize;
   luaL_checktype(L, 1, LUA_TTABLE);
   t = hvalue(obj_at(L, 1));
+  asize = luaH_realasize(t);
   if (i == -1) {
-    lua_pushinteger(L, t->sizearray);
+    lua_pushinteger(L, asize);
     lua_pushinteger(L, allocsizenode(t));
     lua_pushinteger(L, isdummy(t) ? 0 : t->lastfree - t->node);
+    lua_pushinteger(L, t->alimit);
+    return 4;
   }
-  else if ((unsigned int)i < t->sizearray) {
+  else if ((unsigned int)i < asize) {
     lua_pushinteger(L, i);
     pushobject(L, &t->array[i]);
     lua_pushnil(L);
   }
-  else if ((i -= t->sizearray) < sizenode(t)) {
-    if (!ttisnil(gval(gnode(t, i))) ||
-        ttisnil(gkey(gnode(t, i))) ||
-        ttisnumber(gkey(gnode(t, i)))) {
-      pushobject(L, gkey(gnode(t, i)));
+  else if ((i -= asize) < sizenode(t)) {
+    TValue k;
+    getnodekey(L, &k, gnode(t, i));
+    if (!isempty(gval(gnode(t, i))) ||
+        ttisnil(&k) ||
+        ttisnumber(&k)) {
+      pushobject(L, &k);
     }
     else
       lua_pushliteral(L, "<undef>");
@@ -777,8 +911,9 @@ static int upvalue (lua_State *L) {
 
 
 static int newuserdata (lua_State *L) {
-  size_t size = cast(size_t, luaL_checkinteger(L, 1));
-  char *p = cast(char *, lua_newuserdata(L, size));
+  size_t size = cast_sizet(luaL_optinteger(L, 1, 0));
+  int nuv = luaL_optinteger(L, 2, 0);
+  char *p = cast_charp(lua_newuserdatauv(L, size, nuv));
   while (size--) *p++ = '\0';
   return 1;
 }
@@ -786,7 +921,7 @@ static int newuserdata (lua_State *L) {
 
 static int pushuserdata (lua_State *L) {
   lua_Integer u = luaL_checkinteger(L, 1);
-  lua_pushlightuserdata(L, cast(void *, cast(size_t, u)));
+  lua_pushlightuserdata(L, cast_voidp(cast_sizet(u)));
   return 1;
 }
 
@@ -810,14 +945,14 @@ static int doonnewstack (lua_State *L) {
 
 
 static int s2d (lua_State *L) {
-  lua_pushnumber(L, *cast(const double *, luaL_checkstring(L, 1)));
+  lua_pushnumber(L, cast_num(*cast(const double *, luaL_checkstring(L, 1))));
   return 1;
 }
 
 
 static int d2s (lua_State *L) {
-  double d = luaL_checknumber(L, 1);
-  lua_pushlstring(L, cast(char *, &d), sizeof(d));
+  double d = cast(double, luaL_checknumber(L, 1));
+  lua_pushlstring(L, cast_charp(&d), sizeof(d));
   return 1;
 }
 
@@ -851,7 +986,7 @@ static lua_State *getstate (lua_State *L) {
 
 static int loadlib (lua_State *L) {
   static const luaL_Reg libs[] = {
-    {"_G", luaopen_base},
+    {LUA_GNAME, luaopen_base},
     {"coroutine", luaopen_coroutine},
     {"debug", luaopen_debug},
     {"io", luaopen_io},
@@ -859,6 +994,7 @@ static int loadlib (lua_State *L) {
     {"math", luaopen_math},
     {"string", luaopen_string},
     {"table", luaopen_table},
+    {"T", luaB_opentests},
     {NULL, NULL}
   };
   lua_State *L1 = getstate(L);
@@ -1113,6 +1249,10 @@ static int runC (lua_State *L, lua_State *L1, const char *pc) {
         msg = NULL;  /* to test 'luaL_checkstack' with no message */
       luaL_checkstack(L1, sz, msg);
     }
+    else if EQ("rawcheckstack") {
+      int sz = getnum;
+      lua_pushboolean(L1, lua_checkstack(L1, sz));
+    }
     else if EQ("compare") {
       const char *opt = getstring;  /* EQ, LT, or LE */
       int op = (opt[0] == 'E') ? LUA_OPEQ
@@ -1130,7 +1270,7 @@ static int runC (lua_State *L, lua_State *L1, const char *pc) {
     }
     else if EQ("func2num") {
       lua_CFunction func = lua_tocfunction(L1, getindex);
-      lua_pushnumber(L1, cast(size_t, func));
+      lua_pushnumber(L1, cast_sizet(func));
     }
     else if EQ("getfield") {
       int t = getindex;
@@ -1230,7 +1370,7 @@ static int runC (lua_State *L, lua_State *L1, const char *pc) {
     else if EQ("pop") {
       lua_pop(L1, getnum);
     }
-    else if EQ("print") {
+    else if EQ("printstack") {
       int n = getnum;
       if (n != 0) {
         printf("%s\n", luaL_tolstring(L1, n, NULL));
@@ -1238,6 +1378,10 @@ static int runC (lua_State *L, lua_State *L1, const char *pc) {
       }
       else printstack(L1);
     }
+    else if EQ("print") {
+      const char *msg = getstring;
+      printf("%s\n", msg);
+    }
     else if EQ("pushbool") {
       lua_pushboolean(L1, getnum);
     }
@@ -1271,11 +1415,11 @@ static int runC (lua_State *L, lua_State *L1, const char *pc) {
     }
     else if EQ("rawgetp") {
       int t = getindex;
-      lua_rawgetp(L1, t, cast(void *, cast(size_t, getnum)));
+      lua_rawgetp(L1, t, cast_voidp(cast_sizet(getnum)));
     }
     else if EQ("rawsetp") {
       int t = getindex;
-      lua_rawsetp(L1, t, cast(void *, cast(size_t, getnum)));
+      lua_rawsetp(L1, t, cast_voidp(cast_sizet(getnum)));
     }
     else if EQ("remove") {
       lua_remove(L1, getnum);
@@ -1285,14 +1429,24 @@ static int runC (lua_State *L, lua_State *L1, const char *pc) {
     }
     else if EQ("resume") {
       int i = getindex;
-      status = lua_resume(lua_tothread(L1, i), L, getnum);
+      int nres;
+      status = lua_resume(lua_tothread(L1, i), L, getnum, &nres);
     }
     else if EQ("return") {
       int n = getnum;
       if (L1 != L) {
         int i;
-        for (i = 0; i < n; i++)
-          lua_pushstring(L, lua_tostring(L1, -(n - i)));
+        for (i = 0; i < n; i++) {
+          int idx = -(n - i);
+          switch (lua_type(L1, idx)) {
+            case LUA_TBOOLEAN:
+              lua_pushboolean(L, lua_toboolean(L1, idx));
+              break;
+            default:
+              lua_pushstring(L, lua_tostring(L1, idx));
+              break;
+          }
+        }
       }
       return n;
     }
@@ -1350,7 +1504,7 @@ static struct X { int x; } x;
       lua_pushnumber(L1, lua_tonumber(L1, getindex));
     }
     else if EQ("topointer") {
-      lua_pushnumber(L1, cast(size_t, lua_topointer(L1, getindex)));
+      lua_pushnumber(L1, cast_sizet(lua_topointer(L1, getindex)));
     }
     else if EQ("tostring") {
       const char *s = lua_tostring(L1, getindex);
@@ -1490,10 +1644,10 @@ static int sethook (lua_State *L) {
 
 
 static int coresume (lua_State *L) {
-  int status;
+  int status, nres;
   lua_State *co = lua_tothread(L, 1);
   luaL_argcheck(L, co, 1, "coroutine expected");
-  status = lua_resume(co, L, 0);
+  status = lua_resume(co, L, 0, &nres);
   if (status != LUA_OK && status != LUA_YIELD) {
     lua_pushboolean(L, 0);
     lua_insert(L, -2);
@@ -1516,13 +1670,16 @@ static const struct luaL_Reg tests_funcs[] = {
   {"doonnewstack", doonnewstack},
   {"doremote", doremote},
   {"gccolor", gc_color},
+  {"gcage", gc_age},
   {"gcstate", gc_state},
+  {"pobj", gc_printobj},
   {"getref", getref},
   {"hash", hash_query},
   {"int2fb", int2fb_aux},
   {"log2", log2_aux},
   {"limits", get_limits},
   {"listcode", listcode},
+  {"printcode", printcode},
   {"listk", listk},
   {"listlocals", listlocals},
   {"loadlib", loadlib},
@@ -1541,6 +1698,7 @@ static const struct luaL_Reg tests_funcs[] = {
   {"testC", testC},
   {"makeCfunc", makeCfunc},
   {"totalmem", mem_query},
+  {"alloccount", alloc_count},
   {"trick", settrick},
   {"udataval", udataval},
   {"unref", unref},
@@ -1560,7 +1718,7 @@ int luaB_opentests (lua_State *L) {
   lua_atpanic(L, &tpanic);
   atexit(checkfinalmem);
   lua_assert(lua_getallocf(L, &ud) == debug_realloc);
-  lua_assert(ud == cast(void *, &l_memcontrol));
+  lua_assert(ud == cast_voidp(&l_memcontrol));
   lua_setallocf(L, lua_getallocf(L, NULL), ud);
   luaL_newlib(L, tests_funcs);
   return 1;

ltests.h

@@ -1,5 +1,5 @@
 /*
-** $Id: ltests.h,v 2.50.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: ltests.h,v 2.58 2018/04/19 15:42:41 roberto Exp roberto $
 ** Internal Header for Debugging of the Lua Implementation
 ** See Copyright Notice in lua.h
 */
@@ -8,20 +8,11 @@
 #define ltests_h
 
 
+#include <stdio.h>
 #include <stdlib.h>
 
-/* test Lua with no compatibility code */
-#undef LUA_COMPAT_MATHLIB
-#undef LUA_COMPAT_IPAIRS
-#undef LUA_COMPAT_BITLIB
-#undef LUA_COMPAT_APIINTCASTS
-#undef LUA_COMPAT_FLOATSTRING
-#undef LUA_COMPAT_UNPACK
-#undef LUA_COMPAT_LOADERS
-#undef LUA_COMPAT_LOG10
-#undef LUA_COMPAT_LOADSTRING
-#undef LUA_COMPAT_MAXN
-#undef LUA_COMPAT_MODULE
+/* test Lua with compatibility code */
+#define LUA_COMPAT_MATHLIB
 
 
 #define LUA_DEBUG
@@ -33,6 +24,14 @@
 #define lua_assert(c)           assert(c)
 
 
+/* include opcode names */
+#define LUAI_DEFOPNAMES
+
+
+/* compiled with -O0, Lua uses a lot of C stack space... */
+#undef LUAI_MAXCCALLS
+#define LUAI_MAXCCALLS	200
+
 /* to avoid warnings, and to make sure value is really unused */
 #define UNUSED(x)       (x=0, (void)(x))
 
@@ -46,12 +45,21 @@
 #endif
 
 
+/* get a chance to test code without jump tables */
+#define LUA_USE_JUMPTABLE	0
+
+
+/* use 32-bit integers in random generator */
+#define LUA_RAND32
+
+
 /* memory-allocator control variables */
 typedef struct Memcontrol {
   unsigned long numblocks;
   unsigned long total;
   unsigned long maxmem;
   unsigned long memlimit;
+  unsigned long countlimit;
   unsigned long objcount[LUA_NUMTAGS];
 } Memcontrol;
 
@@ -111,6 +119,7 @@ LUA_API void *debug_realloc (void *ud, void *block,
 #define LUAL_BUFFERSIZE		23
 #define MINSTRTABSIZE		2
 #define MAXINDEXRK		1
+#define MAXIWTHABS		3
 
 
 /* make stack-overflow tests run faster */

ltm.c

@@ -1,5 +1,5 @@
 /*
-** $Id: ltm.c,v 2.38.1.1 2017/04/19 17:39:34 roberto Exp $
+** $Id: ltm.c,v 2.69 2018/06/08 19:06:59 roberto Exp roberto $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
@@ -16,6 +16,7 @@
 
 #include "ldebug.h"
 #include "ldo.h"
+#include "lgc.h"
 #include "lobject.h"
 #include "lstate.h"
 #include "lstring.h"
@@ -30,7 +31,7 @@ LUAI_DDEF const char *const luaT_typenames_[LUA_TOTALTAGS] = {
   "no value",
   "nil", "boolean", udatatypename, "number",
   "string", "table", "function", udatatypename, "thread",
-  "proto" /* this last case is used for tests only */
+  "upvalue", "proto" /* these last cases are used for tests only */
 };
 
 
@@ -59,7 +60,7 @@ void luaT_init (lua_State *L) {
 const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
   const TValue *tm = luaH_getshortstr(events, ename);
   lua_assert(event <= TM_EQ);
-  if (ttisnil(tm)) {  /* no tag method? */
+  if (notm(tm)) {  /* no tag method? */
     events->flags |= cast_byte(1u<<event);  /* cache this fact */
     return NULL;
   }
@@ -69,7 +70,7 @@ const TValue *luaT_gettm (Table *events, TMS event, TString *ename) {
 
 const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
   Table *mt;
-  switch (ttnov(o)) {
+  switch (ttype(o)) {
     case LUA_TTABLE:
       mt = hvalue(o)->metatable;
       break;
@@ -77,9 +78,9 @@ const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o, TMS event) {
       mt = uvalue(o)->metatable;
       break;
     default:
-      mt = G(L)->mt[ttnov(o)];
+      mt = G(L)->mt[ttype(o)];
   }
-  return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : luaO_nilobject);
+  return (mt ? luaH_getshortstr(mt, G(L)->tmname[event]) : &G(L)->nilvalue);
 }
 
 
@@ -95,54 +96,65 @@ const char *luaT_objtypename (lua_State *L, const TValue *o) {
     if (ttisstring(name))  /* is '__name' a string? */
       return getstr(tsvalue(name));  /* use it as type name */
   }
-  return ttypename(ttnov(o));  /* else use standard type name */
+  return ttypename(ttype(o));  /* else use standard type name */
 }
 
 
 void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
-                  const TValue *p2, TValue *p3, int hasres) {
-  ptrdiff_t result = savestack(L, p3);
+                  const TValue *p2, const TValue *p3) {
+  StkId func = L->top;
+  setobj2s(L, func, f);  /* push function (assume EXTRA_STACK) */
+  setobj2s(L, func + 1, p1);  /* 1st argument */
+  setobj2s(L, func + 2, p2);  /* 2nd argument */
+  setobj2s(L, func + 3, p3);  /* 3rd argument */
+  L->top = func + 4;
+  /* metamethod may yield only when called from Lua code */
+  if (isLuacode(L->ci))
+    luaD_call(L, func, 0);
+  else
+    luaD_callnoyield(L, func, 0);
+}
+
+
+void luaT_callTMres (lua_State *L, const TValue *f, const TValue *p1,
+                     const TValue *p2, StkId res) {
+  ptrdiff_t result = savestack(L, res);
   StkId func = L->top;
   setobj2s(L, func, f);  /* push function (assume EXTRA_STACK) */
   setobj2s(L, func + 1, p1);  /* 1st argument */
   setobj2s(L, func + 2, p2);  /* 2nd argument */
   L->top += 3;
-  if (!hasres)  /* no result? 'p3' is third argument */
-    setobj2s(L, L->top++, p3);  /* 3rd argument */
   /* metamethod may yield only when called from Lua code */
-  if (isLua(L->ci))
-    luaD_call(L, func, hasres);
+  if (isLuacode(L->ci))
+    luaD_call(L, func, 1);
   else
-    luaD_callnoyield(L, func, hasres);
-  if (hasres) {  /* if has result, move it to its place */
-    p3 = restorestack(L, result);
-    setobjs2s(L, p3, --L->top);
-  }
+    luaD_callnoyield(L, func, 1);
+  res = restorestack(L, result);
+  setobjs2s(L, res, --L->top);  /* move result to its place */
 }
 
 
-int luaT_callbinTM (lua_State *L, const TValue *p1, const TValue *p2,
-                    StkId res, TMS event) {
+static int callbinTM (lua_State *L, const TValue *p1, const TValue *p2,
+                      StkId res, TMS event) {
   const TValue *tm = luaT_gettmbyobj(L, p1, event);  /* try first operand */
-  if (ttisnil(tm))
+  if (notm(tm))
     tm = luaT_gettmbyobj(L, p2, event);  /* try second operand */
-  if (ttisnil(tm)) return 0;
-  luaT_callTM(L, tm, p1, p2, res, 1);
+  if (notm(tm)) return 0;
+  luaT_callTMres(L, tm, p1, p2, res);
   return 1;
 }
 
 
 void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
                     StkId res, TMS event) {
-  if (!luaT_callbinTM(L, p1, p2, res, event)) {
+  if (!callbinTM(L, p1, p2, res, event)) {
     switch (event) {
       case TM_CONCAT:
         luaG_concaterror(L, p1, p2);
       /* call never returns, but to avoid warnings: *//* FALLTHROUGH */
       case TM_BAND: case TM_BOR: case TM_BXOR:
       case TM_SHL: case TM_SHR: case TM_BNOT: {
-        lua_Number dummy;
-        if (tonumber(p1, &dummy) && tonumber(p2, &dummy))
+        if (ttisnumber(p1) && ttisnumber(p2))
           luaG_tointerror(L, p1, p2);
         else
           luaG_opinterror(L, p1, p2, "perform bitwise operation on");
@@ -155,11 +167,85 @@ void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
 }
 
 
-int luaT_callorderTM (lua_State *L, const TValue *p1, const TValue *p2,
-                      TMS event) {
-  if (!luaT_callbinTM(L, p1, p2, L->top, event))
-    return -1;  /* no metamethod */
+void luaT_trybinassocTM (lua_State *L, const TValue *p1, const TValue *p2,
+                                       StkId res, int inv, TMS event) {
+  if (inv)
+    luaT_trybinTM(L, p2, p1, res, event);
   else
-    return !l_isfalse(L->top);
+    luaT_trybinTM(L, p1, p2, res, event);
+}
+
+
+void luaT_trybiniTM (lua_State *L, const TValue *p1, int i2,
+                                   int inv, StkId res, TMS event) {
+  TValue aux;
+  setivalue(&aux, i2);
+  luaT_trybinassocTM(L, p1, &aux, res, inv, event);
+}
+
+
+int luaT_callorderTM (lua_State *L, const TValue *p1, const TValue *p2,
+                      TMS event) {
+  if (callbinTM(L, p1, p2, L->top, event))  /* try original event */
+    return !l_isfalse(s2v(L->top));
+  else if (event == TM_LE) {
+      /* try '!(p2 < p1)' for '(p1 <= p2)' */
+      L->ci->callstatus |= CIST_LEQ;  /* mark it is doing 'lt' for 'le' */
+      if (callbinTM(L, p2, p1, L->top, TM_LT)) {
+        L->ci->callstatus ^= CIST_LEQ;  /* clear mark */
+        return l_isfalse(s2v(L->top));
+      }
+      /* else error will remove this 'ci'; no need to clear mark */
+  }
+  luaG_ordererror(L, p1, p2);  /* no metamethod found */
+  return 0;  /* to avoid warnings */
+}
+
+
+int luaT_callorderiTM (lua_State *L, const TValue *p1, int v2,
+                       int inv, TMS event) {
+  TValue aux; const TValue *p2;
+  setivalue(&aux, v2);
+  if (inv) {  /* arguments were exchanged? */
+    p2 = p1; p1 = &aux;  /* correct them */
+  }
+  else
+    p2 = &aux;
+  return luaT_callorderTM(L, p1, p2, event);
+}
+
+
+void luaT_adjustvarargs (lua_State *L, int nfixparams, CallInfo *ci,
+                         const Proto *p) {
+  int i;
+  int actual = cast_int(L->top - ci->func) - 1;  /* number of arguments */
+  int nextra = actual - nfixparams;  /* number of extra arguments */
+  ci->u.l.nextraargs = nextra;
+  checkstackGC(L, p->maxstacksize + 1);
+  /* copy function to the top of the stack */
+  setobjs2s(L, L->top++, ci->func);
+  /* move fixed parameters to the top of the stack */
+  for (i = 1; i <= nfixparams; i++) {
+    setobjs2s(L, L->top++, ci->func + i);
+    setnilvalue(s2v(ci->func + i));  /* erase original parameter (for GC) */
+  }
+  ci->func += actual + 1;
+  ci->top += actual + 1;
+  lua_assert(L->top <= ci->top && ci->top <= L->stack_last);
+}
+
+
+void luaT_getvarargs (lua_State *L, CallInfo *ci, StkId where, int wanted) {
+  int i;
+  int nextra = ci->u.l.nextraargs;
+  if (wanted < 0) {
+    wanted = nextra;  /* get all extra arguments available */
+    checkstackp(L, nextra, where);  /* ensure stack space */
+    L->top = where + nextra;  /* next instruction will need top */
+  }
+  for (i = 0; i < wanted && i < nextra; i++)
+    setobjs2s(L, where + i, ci->func - nextra + i);
+  for (; i < wanted; i++)   /* complete required results with nil */
+    setnilvalue(s2v(where + i));
 }
 

ltm.h

@@ -1,5 +1,5 @@
 /*
-** $Id: ltm.h,v 2.22.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: ltm.h,v 2.38 2018/06/08 19:06:59 roberto Exp roberto $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
@@ -44,6 +44,12 @@ typedef enum {
 } TMS;
 
 
+/*
+** Test whether there is no tagmethod.
+** (Because tagmethods use raw accesses, the result may be an "empty" nil.)
+*/
+#define notm(tm)	ttisnil(tm)
+
 
 #define gfasttm(g,et,e) ((et) == NULL ? NULL : \
   ((et)->flags & (1u<<(e))) ? NULL : luaT_gettm(et, e, (g)->tmname[e]))
@@ -52,7 +58,7 @@ typedef enum {
 
 #define ttypename(x)	luaT_typenames_[(x) + 1]
 
-LUAI_DDEC const char *const luaT_typenames_[LUA_TOTALTAGS];
+LUAI_DDEC(const char *const luaT_typenames_[LUA_TOTALTAGS];)
 
 
 LUAI_FUNC const char *luaT_objtypename (lua_State *L, const TValue *o);
@@ -63,14 +69,24 @@ LUAI_FUNC const TValue *luaT_gettmbyobj (lua_State *L, const TValue *o,
 LUAI_FUNC void luaT_init (lua_State *L);
 
 LUAI_FUNC void luaT_callTM (lua_State *L, const TValue *f, const TValue *p1,
-                            const TValue *p2, TValue *p3, int hasres);
-LUAI_FUNC int luaT_callbinTM (lua_State *L, const TValue *p1, const TValue *p2,
-                              StkId res, TMS event);
+                            const TValue *p2, const TValue *p3);
+LUAI_FUNC void luaT_callTMres (lua_State *L, const TValue *f,
+                            const TValue *p1, const TValue *p2, StkId p3);
 LUAI_FUNC void luaT_trybinTM (lua_State *L, const TValue *p1, const TValue *p2,
                               StkId res, TMS event);
+LUAI_FUNC void luaT_trybinassocTM (lua_State *L, const TValue *p1,
+       const TValue *p2, StkId res, int inv, TMS event);
+LUAI_FUNC void luaT_trybiniTM (lua_State *L, const TValue *p1, int i2,
+                               int inv, StkId res, TMS event);
 LUAI_FUNC int luaT_callorderTM (lua_State *L, const TValue *p1,
                                 const TValue *p2, TMS event);
+LUAI_FUNC int luaT_callorderiTM (lua_State *L, const TValue *p1, int v2,
+                                 int inv, TMS event);
 
+LUAI_FUNC void luaT_adjustvarargs (lua_State *L, int nfixparams,
+                                   struct CallInfo *ci, const Proto *p);
+LUAI_FUNC void luaT_getvarargs (lua_State *L, struct CallInfo *ci,
+                                              StkId where, int wanted);
 
 
 #endif

lua.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lua.c,v 1.230.1.1 2017/04/19 17:29:57 roberto Exp $
+** $Id: lua.c,v 1.234 2018/03/06 20:30:17 roberto Exp roberto $
 ** Lua stand-alone interpreter
 ** See Copyright Notice in lua.h
 */
@@ -9,31 +9,22 @@
 #include "lprefix.h"
 
 
-#include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+#include <signal.h>
+
 #include "lua.h"
 
 #include "lauxlib.h"
 #include "lualib.h"
 
 
-
-#if !defined(LUA_PROMPT)
-#define LUA_PROMPT		"> "
-#define LUA_PROMPT2		">> "
-#endif
-
 #if !defined(LUA_PROGNAME)
 #define LUA_PROGNAME		"lua"
 #endif
 
-#if !defined(LUA_MAXINPUT)
-#define LUA_MAXINPUT		512
-#endif
-
 #if !defined(LUA_INIT_VAR)
 #define LUA_INIT_VAR		"LUA_INIT"
 #endif
@@ -41,65 +32,6 @@
 #define LUA_INITVARVERSION	LUA_INIT_VAR LUA_VERSUFFIX
 
 
-/*
-** lua_stdin_is_tty detects whether the standard input is a 'tty' (that
-** is, whether we're running lua interactively).
-*/
-#if !defined(lua_stdin_is_tty)	/* { */
-
-#if defined(LUA_USE_POSIX)	/* { */
-
-#include <unistd.h>
-#define lua_stdin_is_tty()	isatty(0)
-
-#elif defined(LUA_USE_WINDOWS)	/* }{ */
-
-#include <io.h>
-#include <windows.h>
-
-#define lua_stdin_is_tty()	_isatty(_fileno(stdin))
-
-#else				/* }{ */
-
-/* ISO C definition */
-#define lua_stdin_is_tty()	1  /* assume stdin is a tty */
-
-#endif				/* } */
-
-#endif				/* } */
-
-
-/*
-** lua_readline defines how to show a prompt and then read a line from
-** the standard input.
-** lua_saveline defines how to "save" a read line in a "history".
-** lua_freeline defines how to free a line read by lua_readline.
-*/
-#if !defined(lua_readline)	/* { */
-
-#if defined(LUA_USE_READLINE)	/* { */
-
-#include <readline/readline.h>
-#include <readline/history.h>
-#define lua_readline(L,b,p)	((void)L, ((b)=readline(p)) != NULL)
-#define lua_saveline(L,line)	((void)L, add_history(line))
-#define lua_freeline(L,b)	((void)L, free(b))
-
-#else				/* }{ */
-
-#define lua_readline(L,b,p) \
-        ((void)L, fputs(p, stdout), fflush(stdout),  /* show prompt */ \
-        fgets(b, LUA_MAXINPUT, stdin) != NULL)  /* get line */
-#define lua_saveline(L,line)	{ (void)L; (void)line; }
-#define lua_freeline(L,b)	{ (void)L; (void)b; }
-
-#endif				/* } */
-
-#endif				/* } */
-
-
-
-
 static lua_State *globalL = NULL;
 
 static const char *progname = LUA_PROGNAME;
@@ -267,6 +199,210 @@ static int dolibrary (lua_State *L, const char *name) {
 }
 
 
+/*
+** Push on the stack the contents of table 'arg' from 1 to #arg
+*/
+static int pushargs (lua_State *L) {
+  int i, n;
+  if (lua_getglobal(L, "arg") != LUA_TTABLE)
+    luaL_error(L, "'arg' is not a table");
+  n = (int)luaL_len(L, -1);
+  luaL_checkstack(L, n + 3, "too many arguments to script");
+  for (i = 1; i <= n; i++)
+    lua_rawgeti(L, -i, i);
+  lua_remove(L, -i);  /* remove table from the stack */
+  return n;
+}
+
+
+static int handle_script (lua_State *L, char **argv) {
+  int status;
+  const char *fname = argv[0];
+  if (strcmp(fname, "-") == 0 && strcmp(argv[-1], "--") != 0)
+    fname = NULL;  /* stdin */
+  status = luaL_loadfile(L, fname);
+  if (status == LUA_OK) {
+    int n = pushargs(L);  /* push arguments to script */
+    status = docall(L, n, LUA_MULTRET);
+  }
+  return report(L, status);
+}
+
+
+/* bits of various argument indicators in 'args' */
+#define has_error	1	/* bad option */
+#define has_i		2	/* -i */
+#define has_v		4	/* -v */
+#define has_e		8	/* -e */
+#define has_E		16	/* -E */
+
+
+/*
+** Traverses all arguments from 'argv', returning a mask with those
+** needed before running any Lua code (or an error code if it finds
+** any invalid argument). 'first' returns the first not-handled argument
+** (either the script name or a bad argument in case of error).
+*/
+static int collectargs (char **argv, int *first) {
+  int args = 0;
+  int i;
+  for (i = 1; argv[i] != NULL; i++) {
+    *first = i;
+    if (argv[i][0] != '-')  /* not an option? */
+        return args;  /* stop handling options */
+    switch (argv[i][1]) {  /* else check option */
+      case '-':  /* '--' */
+        if (argv[i][2] != '\0')  /* extra characters after '--'? */
+          return has_error;  /* invalid option */
+        *first = i + 1;
+        return args;
+      case '\0':  /* '-' */
+        return args;  /* script "name" is '-' */
+      case 'E':
+        if (argv[i][2] != '\0')  /* extra characters after 1st? */
+          return has_error;  /* invalid option */
+        args |= has_E;
+        break;
+      case 'i':
+        args |= has_i;  /* (-i implies -v) *//* FALLTHROUGH */
+      case 'v':
+        if (argv[i][2] != '\0')  /* extra characters after 1st? */
+          return has_error;  /* invalid option */
+        args |= has_v;
+        break;
+      case 'e':
+        args |= has_e;  /* FALLTHROUGH */
+      case 'l':  /* both options need an argument */
+        if (argv[i][2] == '\0') {  /* no concatenated argument? */
+          i++;  /* try next 'argv' */
+          if (argv[i] == NULL || argv[i][0] == '-')
+            return has_error;  /* no next argument or it is another option */
+        }
+        break;
+      default:  /* invalid option */
+        return has_error;
+    }
+  }
+  *first = i;  /* no script name */
+  return args;
+}
+
+
+/*
+** Processes options 'e' and 'l', which involve running Lua code.
+** Returns 0 if some code raises an error.
+*/
+static int runargs (lua_State *L, char **argv, int n) {
+  int i;
+  for (i = 1; i < n; i++) {
+    int option = argv[i][1];
+    lua_assert(argv[i][0] == '-');  /* already checked */
+    if (option == 'e' || option == 'l') {
+      int status;
+      const char *extra = argv[i] + 2;  /* both options need an argument */
+      if (*extra == '\0') extra = argv[++i];
+      lua_assert(extra != NULL);
+      status = (option == 'e')
+               ? dostring(L, extra, "=(command line)")
+               : dolibrary(L, extra);
+      if (status != LUA_OK) return 0;
+    }
+  }
+  return 1;
+}
+
+
+static int handle_luainit (lua_State *L) {
+  const char *name = "=" LUA_INITVARVERSION;
+  const char *init = getenv(name + 1);
+  if (init == NULL) {
+    name = "=" LUA_INIT_VAR;
+    init = getenv(name + 1);  /* try alternative name */
+  }
+  if (init == NULL) return LUA_OK;
+  else if (init[0] == '@')
+    return dofile(L, init+1);
+  else
+    return dostring(L, init, name);
+}
+
+
+/*
+** {==================================================================
+** Read-Eval-Print Loop (REPL)
+** ===================================================================
+*/
+
+#if !defined(LUA_PROMPT)
+#define LUA_PROMPT		"> "
+#define LUA_PROMPT2		">> "
+#endif
+
+#if !defined(LUA_MAXINPUT)
+#define LUA_MAXINPUT		512
+#endif
+
+
+/*
+** lua_stdin_is_tty detects whether the standard input is a 'tty' (that
+** is, whether we're running lua interactively).
+*/
+#if !defined(lua_stdin_is_tty)	/* { */
+
+#if defined(LUA_USE_POSIX)	/* { */
+
+#include <unistd.h>
+#define lua_stdin_is_tty()	isatty(0)
+
+#elif defined(LUA_USE_WINDOWS)	/* }{ */
+
+#include <io.h>
+#include <windows.h>
+
+#define lua_stdin_is_tty()	_isatty(_fileno(stdin))
+
+#else				/* }{ */
+
+/* ISO C definition */
+#define lua_stdin_is_tty()	1  /* assume stdin is a tty */
+
+#endif				/* } */
+
+#endif				/* } */
+
+
+/*
+** lua_readline defines how to show a prompt and then read a line from
+** the standard input.
+** lua_saveline defines how to "save" a read line in a "history".
+** lua_freeline defines how to free a line read by lua_readline.
+*/
+#if !defined(lua_readline)	/* { */
+
+#if defined(LUA_USE_READLINE)	/* { */
+
+#include <readline/readline.h>
+#include <readline/history.h>
+#define lua_initreadline(L)  \
+	((void)L, rl_readline_name="lua", rl_inhibit_completion=1)
+#define lua_readline(L,b,p)	((void)L, ((b)=readline(p)) != NULL)
+#define lua_saveline(L,line)	((void)L, add_history(line))
+#define lua_freeline(L,b)	((void)L, free(b))
+
+#else				/* }{ */
+
+#define lua_initreadline(L)  ((void)L)
+#define lua_readline(L,b,p) \
+        ((void)L, fputs(p, stdout), fflush(stdout),  /* show prompt */ \
+        fgets(b, LUA_MAXINPUT, stdin) != NULL)  /* get line */
+#define lua_saveline(L,line)	{ (void)L; (void)line; }
+#define lua_freeline(L,b)	{ (void)L; (void)b; }
+
+#endif				/* } */
+
+#endif				/* } */
+
+
 /*
 ** Returns the string to be used as a prompt by the interpreter.
 */
@@ -406,6 +542,7 @@ static void doREPL (lua_State *L) {
   int status;
   const char *oldprogname = progname;
   progname = NULL;  /* no 'progname' on errors in interactive mode */
+  lua_initreadline(L);
   while ((status = loadline(L)) != -1) {
     if (status == LUA_OK)
       status = docall(L, 0, LUA_MULTRET);
@@ -417,134 +554,7 @@ static void doREPL (lua_State *L) {
   progname = oldprogname;
 }
 
-
-/*
-** Push on the stack the contents of table 'arg' from 1 to #arg
-*/
-static int pushargs (lua_State *L) {
-  int i, n;
-  if (lua_getglobal(L, "arg") != LUA_TTABLE)
-    luaL_error(L, "'arg' is not a table");
-  n = (int)luaL_len(L, -1);
-  luaL_checkstack(L, n + 3, "too many arguments to script");
-  for (i = 1; i <= n; i++)
-    lua_rawgeti(L, -i, i);
-  lua_remove(L, -i);  /* remove table from the stack */
-  return n;
-}
-
-
-static int handle_script (lua_State *L, char **argv) {
-  int status;
-  const char *fname = argv[0];
-  if (strcmp(fname, "-") == 0 && strcmp(argv[-1], "--") != 0)
-    fname = NULL;  /* stdin */
-  status = luaL_loadfile(L, fname);
-  if (status == LUA_OK) {
-    int n = pushargs(L);  /* push arguments to script */
-    status = docall(L, n, LUA_MULTRET);
-  }
-  return report(L, status);
-}
-
-
-
-/* bits of various argument indicators in 'args' */
-#define has_error	1	/* bad option */
-#define has_i		2	/* -i */
-#define has_v		4	/* -v */
-#define has_e		8	/* -e */
-#define has_E		16	/* -E */
-
-/*
-** Traverses all arguments from 'argv', returning a mask with those
-** needed before running any Lua code (or an error code if it finds
-** any invalid argument). 'first' returns the first not-handled argument
-** (either the script name or a bad argument in case of error).
-*/
-static int collectargs (char **argv, int *first) {
-  int args = 0;
-  int i;
-  for (i = 1; argv[i] != NULL; i++) {
-    *first = i;
-    if (argv[i][0] != '-')  /* not an option? */
-        return args;  /* stop handling options */
-    switch (argv[i][1]) {  /* else check option */
-      case '-':  /* '--' */
-        if (argv[i][2] != '\0')  /* extra characters after '--'? */
-          return has_error;  /* invalid option */
-        *first = i + 1;
-        return args;
-      case '\0':  /* '-' */
-        return args;  /* script "name" is '-' */
-      case 'E':
-        if (argv[i][2] != '\0')  /* extra characters after 1st? */
-          return has_error;  /* invalid option */
-        args |= has_E;
-        break;
-      case 'i':
-        args |= has_i;  /* (-i implies -v) *//* FALLTHROUGH */
-      case 'v':
-        if (argv[i][2] != '\0')  /* extra characters after 1st? */
-          return has_error;  /* invalid option */
-        args |= has_v;
-        break;
-      case 'e':
-        args |= has_e;  /* FALLTHROUGH */
-      case 'l':  /* both options need an argument */
-        if (argv[i][2] == '\0') {  /* no concatenated argument? */
-          i++;  /* try next 'argv' */
-          if (argv[i] == NULL || argv[i][0] == '-')
-            return has_error;  /* no next argument or it is another option */
-        }
-        break;
-      default:  /* invalid option */
-        return has_error;
-    }
-  }
-  *first = i;  /* no script name */
-  return args;
-}
-
-
-/*
-** Processes options 'e' and 'l', which involve running Lua code.
-** Returns 0 if some code raises an error.
-*/
-static int runargs (lua_State *L, char **argv, int n) {
-  int i;
-  for (i = 1; i < n; i++) {
-    int option = argv[i][1];
-    lua_assert(argv[i][0] == '-');  /* already checked */
-    if (option == 'e' || option == 'l') {
-      int status;
-      const char *extra = argv[i] + 2;  /* both options need an argument */
-      if (*extra == '\0') extra = argv[++i];
-      lua_assert(extra != NULL);
-      status = (option == 'e')
-               ? dostring(L, extra, "=(command line)")
-               : dolibrary(L, extra);
-      if (status != LUA_OK) return 0;
-    }
-  }
-  return 1;
-}
-
-
-
-static int handle_luainit (lua_State *L) {
-  const char *name = "=" LUA_INITVARVERSION;
-  const char *init = getenv(name + 1);
-  if (init == NULL) {
-    name = "=" LUA_INIT_VAR;
-    init = getenv(name + 1);  /* try alternative name */
-  }
-  if (init == NULL) return LUA_OK;
-  else if (init[0] == '@')
-    return dofile(L, init+1);
-  else
-    return dostring(L, init, name);
-}
+/* }================================================================== */
 
 
 /*
@@ -570,6 +580,7 @@ static int pmain (lua_State *L) {
   }
   luaL_openlibs(L);  /* open standard libraries */
   createargtable(L, argv, argc, script);  /* create table 'arg' */
+  lua_gc(L, LUA_GCGEN, 0, 0);  /* GC in generational mode */
   if (!(args & has_E)) {  /* no option '-E'? */
     if (handle_luainit(L) != LUA_OK)  /* run LUA_INIT */
       return 0;  /* error running LUA_INIT */

lua.h

@@ -1,4 +1,5 @@
 /*
+** $Id: lua.h,v 1.346 2018/04/04 14:23:41 roberto Exp roberto $
 ** Lua - A Scripting Language
 ** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
 ** See Copyright Notice at the end of this file
@@ -16,13 +17,13 @@
 
 
 #define LUA_VERSION_MAJOR	"5"
-#define LUA_VERSION_MINOR	"3"
-#define LUA_VERSION_NUM		503
-#define LUA_VERSION_RELEASE	"6"
+#define LUA_VERSION_MINOR	"4"
+#define LUA_VERSION_NUM		504
+#define LUA_VERSION_RELEASE	"0"
 
 #define LUA_VERSION	"Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
 #define LUA_RELEASE	LUA_VERSION "." LUA_VERSION_RELEASE
-#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2020 Lua.org, PUC-Rio"
+#define LUA_COPYRIGHT	LUA_RELEASE "  Copyright (C) 1994-2018 Lua.org, PUC-Rio"
 #define LUA_AUTHORS	"R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
 
 
@@ -148,7 +149,7 @@ LUA_API lua_State *(lua_newthread) (lua_State *L);
 LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
 
 
-LUA_API const lua_Number *(lua_version) (lua_State *L);
+LUA_API lua_Number (lua_version) (lua_State *L);
 
 
 /*
@@ -181,7 +182,7 @@ LUA_API lua_Number      (lua_tonumberx) (lua_State *L, int idx, int *isnum);
 LUA_API lua_Integer     (lua_tointegerx) (lua_State *L, int idx, int *isnum);
 LUA_API int             (lua_toboolean) (lua_State *L, int idx);
 LUA_API const char     *(lua_tolstring) (lua_State *L, int idx, size_t *len);
-LUA_API size_t          (lua_rawlen) (lua_State *L, int idx);
+LUA_API lua_Unsigned    (lua_rawlen) (lua_State *L, int idx);
 LUA_API lua_CFunction   (lua_tocfunction) (lua_State *L, int idx);
 LUA_API void	       *(lua_touserdata) (lua_State *L, int idx);
 LUA_API lua_State      *(lua_tothread) (lua_State *L, int idx);
@@ -246,9 +247,9 @@ LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n);
 LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p);
 
 LUA_API void  (lua_createtable) (lua_State *L, int narr, int nrec);
-LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
+LUA_API void *(lua_newuserdatauv) (lua_State *L, size_t sz, int nuvalue);
 LUA_API int   (lua_getmetatable) (lua_State *L, int objindex);
-LUA_API int  (lua_getuservalue) (lua_State *L, int idx);
+LUA_API int  (lua_getiuservalue) (lua_State *L, int idx, int n);
 
 
 /*
@@ -262,7 +263,7 @@ LUA_API void  (lua_rawset) (lua_State *L, int idx);
 LUA_API void  (lua_rawseti) (lua_State *L, int idx, lua_Integer n);
 LUA_API void  (lua_rawsetp) (lua_State *L, int idx, const void *p);
 LUA_API int   (lua_setmetatable) (lua_State *L, int objindex);
-LUA_API void  (lua_setuservalue) (lua_State *L, int idx);
+LUA_API int   (lua_setiuservalue) (lua_State *L, int idx, int n);
 
 
 /*
@@ -287,7 +288,8 @@ LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip);
 */
 LUA_API int  (lua_yieldk)     (lua_State *L, int nresults, lua_KContext ctx,
                                lua_KFunction k);
-LUA_API int  (lua_resume)     (lua_State *L, lua_State *from, int narg);
+LUA_API int  (lua_resume)     (lua_State *L, lua_State *from, int narg,
+                               int *nres);
 LUA_API int  (lua_status)     (lua_State *L);
 LUA_API int (lua_isyieldable) (lua_State *L);
 
@@ -307,8 +309,10 @@ LUA_API int (lua_isyieldable) (lua_State *L);
 #define LUA_GCSETPAUSE		6
 #define LUA_GCSETSTEPMUL	7
 #define LUA_GCISRUNNING		9
+#define LUA_GCGEN		10
+#define LUA_GCINC		11
 
-LUA_API int (lua_gc) (lua_State *L, int what, int data);
+LUA_API int (lua_gc) (lua_State *L, int what, ...);
 
 
 /*
@@ -328,7 +332,6 @@ LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
 LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
 
 
-
 /*
 ** {==============================================================
 ** some useful macros
@@ -376,7 +379,7 @@ LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
 
 /*
 ** {==============================================================
-** compatibility macros for unsigned conversions
+** compatibility macros
 ** ===============================================================
 */
 #if defined(LUA_COMPAT_APIINTCASTS)
@@ -386,6 +389,11 @@ LUA_API void      (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
 #define lua_tounsigned(L,i)	lua_tounsignedx(L,(i),NULL)
 
 #endif
+
+#define lua_newuserdata(L,s)	lua_newuserdatauv(L,s,1)
+#define lua_getuservalue(L,idx)	lua_getiuservalue(L,idx,1)
+#define lua_setuservalue(L,idx)	lua_setiuservalue(L,idx,1)
+
 /* }============================================================== */
 
 /*
@@ -450,6 +458,8 @@ struct lua_Debug {
   unsigned char nparams;/* (u) number of parameters */
   char isvararg;        /* (u) */
   char istailcall;	/* (t) */
+  unsigned short ftransfer;   /* (r) index of first value transferred */
+  unsigned short ntransfer;   /* (r) number of transferred values */
   char short_src[LUA_IDSIZE]; /* (S) */
   /* private part */
   struct CallInfo *i_ci;  /* active function */
@@ -459,7 +469,7 @@ struct lua_Debug {
 
 
 /******************************************************************************
-* Copyright (C) 1994-2020 Lua.org, PUC-Rio.
+* Copyright (C) 1994-2018 Lua.org, PUC-Rio.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the

luaconf.h

@@ -1,5 +1,5 @@
 /*
-** $Id: luaconf.h,v 1.259.1.1 2017/04/19 17:29:57 roberto Exp $
+** $Id: luaconf.h,v 1.270 2018/06/18 12:51:05 roberto Exp roberto $
 ** Configuration file for Lua
 ** See Copyright Notice in lua.h
 */
@@ -61,14 +61,12 @@
 #if defined(LUA_USE_LINUX)
 #define LUA_USE_POSIX
 #define LUA_USE_DLOPEN		/* needs an extra library: -ldl */
-#define LUA_USE_READLINE	/* needs some extra libraries */
 #endif
 
 
 #if defined(LUA_USE_MACOSX)
 #define LUA_USE_POSIX
 #define LUA_USE_DLOPEN		/* MacOS does not need -ldl */
-#define LUA_USE_READLINE	/* needs an extra library: -lreadline */
 #endif
 
 
@@ -256,16 +254,18 @@
 #endif				/* } */
 
 
-/* more often than not the libs go together with the core */
+/*
+** More often than not the libs go together with the core.
+*/
 #define LUALIB_API	LUA_API
-#define LUAMOD_API	LUALIB_API
+#define LUAMOD_API	LUA_API
 
 
 /*
 @@ LUAI_FUNC is a mark for all extern functions that are not to be
 ** exported to outside modules.
-@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables
-** that are not to be exported to outside modules (LUAI_DDEF for
+@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables,
+** none of which to be exported to outside modules (LUAI_DDEF for
 ** definitions and LUAI_DDEC for declarations).
 ** CHANGE them if you need to mark them in some special way. Elf/gcc
 ** (versions 3.2 and later) mark them as "hidden" to optimize access
@@ -282,7 +282,7 @@
 #define LUAI_FUNC	extern
 #endif				/* } */
 
-#define LUAI_DDEC	LUAI_FUNC
+#define LUAI_DDEC(dec)	LUAI_FUNC dec
 #define LUAI_DDEF	/* empty */
 
 /* }================================================================== */
@@ -295,29 +295,20 @@
 */
 
 /*
-@@ LUA_COMPAT_5_2 controls other macros for compatibility with Lua 5.2.
-@@ LUA_COMPAT_5_1 controls other macros for compatibility with Lua 5.1.
+@@ LUA_COMPAT_5_3 controls other macros for compatibility with Lua 5.2.
 ** You can define it to get all options, or change specific options
 ** to fit your specific needs.
 */
-#if defined(LUA_COMPAT_5_2)	/* { */
+#if defined(LUA_COMPAT_5_3)	/* { */
 
 /*
 @@ LUA_COMPAT_MATHLIB controls the presence of several deprecated
 ** functions in the mathematical library.
+** (These functions were already officially removed in 5.3, but
+** nevertheless they are available by default there.)
 */
 #define LUA_COMPAT_MATHLIB
 
-/*
-@@ LUA_COMPAT_BITLIB controls the presence of library 'bit32'.
-*/
-#define LUA_COMPAT_BITLIB
-
-/*
-@@ LUA_COMPAT_IPAIRS controls the effectiveness of the __ipairs metamethod.
-*/
-#define LUA_COMPAT_IPAIRS
-
 /*
 @@ LUA_COMPAT_APIINTCASTS controls the presence of macros for
 ** manipulating other integer types (lua_pushunsigned, lua_tounsigned,
@@ -328,50 +319,6 @@
 #endif				/* } */
 
 
-#if defined(LUA_COMPAT_5_1)	/* { */
-
-/* Incompatibilities from 5.2 -> 5.3 */
-#define LUA_COMPAT_MATHLIB
-#define LUA_COMPAT_APIINTCASTS
-
-/*
-@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
-** You can replace it with 'table.unpack'.
-*/
-#define LUA_COMPAT_UNPACK
-
-/*
-@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'.
-** You can replace it with 'package.searchers'.
-*/
-#define LUA_COMPAT_LOADERS
-
-/*
-@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.
-** You can call your C function directly (with light C functions).
-*/
-#define lua_cpcall(L,f,u)  \
-	(lua_pushcfunction(L, (f)), \
-	 lua_pushlightuserdata(L,(u)), \
-	 lua_pcall(L,1,0,0))
-
-
-/*
-@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library.
-** You can rewrite 'log10(x)' as 'log(x, 10)'.
-*/
-#define LUA_COMPAT_LOG10
-
-/*
-@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base
-** library. You can rewrite 'loadstring(s)' as 'load(s)'.
-*/
-#define LUA_COMPAT_LOADSTRING
-
-/*
-@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library.
-*/
-#define LUA_COMPAT_MAXN
 
 /*
 @@ The following macros supply trivial compatibility for some
@@ -385,23 +332,6 @@
 #define lua_equal(L,idx1,idx2)		lua_compare(L,(idx1),(idx2),LUA_OPEQ)
 #define lua_lessthan(L,idx1,idx2)	lua_compare(L,(idx1),(idx2),LUA_OPLT)
 
-/*
-@@ LUA_COMPAT_MODULE controls compatibility with previous
-** module functions 'module' (Lua) and 'luaL_register' (C).
-*/
-#define LUA_COMPAT_MODULE
-
-#endif				/* } */
-
-
-/*
-@@ LUA_COMPAT_FLOATSTRING makes Lua format integral floats without a
-@@ a float mark ('.0').
-** This macro is not on by default even in compatibility mode,
-** because this is not really an incompatibility.
-*/
-/* #define LUA_COMPAT_FLOATSTRING */
-
 /* }================================================================== */
 
 
@@ -437,12 +367,13 @@
 	l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n))
 
 /*
-@@ lua_numbertointeger converts a float number to an integer, or
-** returns 0 if float is not within the range of a lua_Integer.
-** (The range comparisons are tricky because of rounding. The tests
-** here assume a two-complement representation, where MININTEGER always
-** has an exact representation as a float; MAXINTEGER may not have one,
-** and therefore its conversion to float may have an ill-defined value.)
+@@ lua_numbertointeger converts a float number with an integral value
+** to an integer, or returns 0 if float is not within the range of
+** a lua_Integer.  (The range comparisons are tricky because of
+** rounding. The tests here assume a two-complement representation,
+** where MININTEGER always has an exact representation as a float;
+** MAXINTEGER may not have one, and therefore its conversion to float
+** may have an ill-defined value.)
 */
 #define lua_numbertointeger(n,p) \
   ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \
@@ -517,6 +448,8 @@
 @@ LUA_INTEGER_FMT is the format for writing integers.
 @@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER.
 @@ LUA_MININTEGER is the minimum value for a LUA_INTEGER.
+@@ LUA_MAXUNSIGNED is the maximum value for a LUA_UNSIGNED.
+@@ LUA_UNSIGNEDBITS is the number of bits in a LUA_UNSIGNED.
 @@ lua_integer2str converts an integer to a string.
 */
 
@@ -536,6 +469,10 @@
 */
 #define LUA_UNSIGNED		unsigned LUAI_UACINT
 
+#define LUA_MAXUNSIGNED		(~(lua_Unsigned)0)
+
+#define LUA_UNSIGNEDBITS	(sizeof(LUA_UNSIGNED) * CHAR_BIT)
+
 
 /* now the variable definitions */
 
@@ -610,7 +547,7 @@
 
 
 /*
-@@ lua_strx2number converts an hexadecimal numeric string to a number.
+@@ lua_strx2number converts a hexadecimal numeric string to a number.
 ** In C99, 'strtod' does that conversion. Otherwise, you can
 ** leave 'lua_strx2number' undefined and Lua will provide its own
 ** implementation.
@@ -628,7 +565,7 @@
 
 
 /*
-@@ lua_number2strx converts a float to an hexadecimal numeric string.
+@@ lua_number2strx converts a float to a hexadecimal numeric string.
 ** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
 ** Otherwise, you can leave 'lua_number2strx' undefined and Lua will
 ** provide its own implementation.
@@ -724,6 +661,7 @@
 ** CHANGE it if you need a different limit. This limit is arbitrary;
 ** its only purpose is to stop Lua from consuming unlimited stack
 ** space (and to reserve some numbers for pseudo-indices).
+** (It must fit into max(size_t)/32.)
 */
 #if LUAI_BITSINT >= 32
 #define LUAI_MAXSTACK		1000000
@@ -761,17 +699,15 @@
 #define LUAL_BUFFERSIZE   ((int)(0x80 * sizeof(void*) * sizeof(lua_Integer)))
 #endif
 
+/*
+@@ LUAI_MAXALIGN defines fields that, when used in a union, ensure
+** maximum alignment for the other items in that union.
+*/
+#define LUAI_MAXALIGN  lua_Number n; double u; void *s; lua_Integer i; long l
+
 /* }================================================================== */
 
 
-/*
-@@ LUA_QL describes how error messages quote program elements.
-** Lua does not use these macros anymore; they are here for
-** compatibility only.
-*/
-#define LUA_QL(x)	"'" x "'"
-#define LUA_QS		LUA_QL("%s")
-
 
 
 

lualib.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lualib.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lualib.h,v 1.45 2017/01/12 17:14:26 roberto Exp roberto $
 ** Lua standard libraries
 ** See Copyright Notice in lua.h
 */
@@ -35,9 +35,6 @@ LUAMOD_API int (luaopen_string) (lua_State *L);
 #define LUA_UTF8LIBNAME	"utf8"
 LUAMOD_API int (luaopen_utf8) (lua_State *L);
 
-#define LUA_BITLIBNAME	"bit32"
-LUAMOD_API int (luaopen_bit32) (lua_State *L);
-
 #define LUA_MATHLIBNAME	"math"
 LUAMOD_API int (luaopen_math) (lua_State *L);
 

lundump.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lundump.c,v 2.44.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lundump.c,v 2.49 2017/12/07 18:59:52 roberto Exp roberto $
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
@@ -36,7 +36,7 @@ typedef struct {
 } LoadState;
 
 
-static l_noret error(LoadState *S, const char *why) {
+static l_noret error (LoadState *S, const char *why) {
   luaO_pushfstring(S->L, "%s: %s precompiled chunk", S->name, why);
   luaD_throw(S->L, LUA_ERRSYNTAX);
 }
@@ -58,16 +58,26 @@ static void LoadBlock (LoadState *S, void *b, size_t size) {
 
 
 static lu_byte LoadByte (LoadState *S) {
-  lu_byte x;
-  LoadVar(S, x);
+  int b = zgetc(S->Z);
+  if (b == EOZ)
+    error(S, "truncated");
+  return cast_byte(b);
+}
+
+
+static size_t LoadSize (LoadState *S) {
+  size_t x = 0;
+  int b;
+  do {
+    b = LoadByte(S);
+    x = (x << 7) | (b & 0x7f);
+  } while ((b & 0x80) == 0);
   return x;
 }
 
 
 static int LoadInt (LoadState *S) {
-  int x;
-  LoadVar(S, x);
-  return x;
+  return cast_int(LoadSize(S));
 }
 
 
@@ -85,34 +95,40 @@ static lua_Integer LoadInteger (LoadState *S) {
 }
 
 
-static TString *LoadString (LoadState *S, Proto *p) {
-  lua_State *L = S->L;
-  size_t size = LoadByte(S);
-  TString *ts;
-  if (size == 0xFF)
-    LoadVar(S, size);
+/*
+** Load a nullable string
+*/
+static TString *LoadStringN (LoadState *S) {
+  size_t size = LoadSize(S);
   if (size == 0)
     return NULL;
   else if (--size <= LUAI_MAXSHORTLEN) {  /* short string? */
     char buff[LUAI_MAXSHORTLEN];
     LoadVector(S, buff, size);
-    ts = luaS_newlstr(L, buff, size);
+    return luaS_newlstr(S->L, buff, size);
   }
   else {  /* long string */
-    ts = luaS_createlngstrobj(L, size);
-    setsvalue2s(L, L->top, ts);  /* anchor it ('loadVector' can GC) */
-    luaD_inctop(L);
+    TString *ts = luaS_createlngstrobj(S->L, size);
     LoadVector(S, getstr(ts), size);  /* load directly in final place */
-    L->top--;  /* pop string */
+    return ts;
   }
-  luaC_objbarrier(L, p, ts);
-  return ts;
+}
+
+
+/*
+** Load a non-nullable string.
+*/
+static TString *LoadString (LoadState *S) {
+  TString *st = LoadStringN(S);
+  if (st == NULL)
+    error(S, "bad format for constant string");
+  return st;
 }
 
 
 static void LoadCode (LoadState *S, Proto *f) {
   int n = LoadInt(S);
-  f->code = luaM_newvector(S->L, n, Instruction);
+  f->code = luaM_newvectorchecked(S->L, n, Instruction);
   f->sizecode = n;
   LoadVector(S, f->code, n);
 }
@@ -124,7 +140,7 @@ static void LoadFunction(LoadState *S, Proto *f, TString *psource);
 static void LoadConstants (LoadState *S, Proto *f) {
   int i;
   int n = LoadInt(S);
-  f->k = luaM_newvector(S->L, n, TValue);
+  f->k = luaM_newvectorchecked(S->L, n, TValue);
   f->sizek = n;
   for (i = 0; i < n; i++)
     setnilvalue(&f->k[i]);
@@ -132,24 +148,23 @@ static void LoadConstants (LoadState *S, Proto *f) {
     TValue *o = &f->k[i];
     int t = LoadByte(S);
     switch (t) {
-    case LUA_TNIL:
-      setnilvalue(o);
-      break;
-    case LUA_TBOOLEAN:
-      setbvalue(o, LoadByte(S));
-      break;
-    case LUA_TNUMFLT:
-      setfltvalue(o, LoadNumber(S));
-      break;
-    case LUA_TNUMINT:
-      setivalue(o, LoadInteger(S));
-      break;
-    case LUA_TSHRSTR:
-    case LUA_TLNGSTR:
-      setsvalue2n(S->L, o, LoadString(S, f));
-      break;
-    default:
-      lua_assert(0);
+      case LUA_TNIL:
+        setnilvalue(o);
+        break;
+      case LUA_TBOOLEAN:
+        setbvalue(o, LoadByte(S));
+        break;
+      case LUA_TNUMFLT:
+        setfltvalue(o, LoadNumber(S));
+        break;
+      case LUA_TNUMINT:
+        setivalue(o, LoadInteger(S));
+        break;
+      case LUA_TSHRSTR:
+      case LUA_TLNGSTR:
+        setsvalue2n(S->L, o, LoadString(S));
+        break;
+      default: lua_assert(0);
     }
   }
 }
@@ -158,13 +173,12 @@ static void LoadConstants (LoadState *S, Proto *f) {
 static void LoadProtos (LoadState *S, Proto *f) {
   int i;
   int n = LoadInt(S);
-  f->p = luaM_newvector(S->L, n, Proto *);
+  f->p = luaM_newvectorchecked(S->L, n, Proto *);
   f->sizep = n;
   for (i = 0; i < n; i++)
     f->p[i] = NULL;
   for (i = 0; i < n; i++) {
     f->p[i] = luaF_newproto(S->L);
-    luaC_objbarrier(S->L, f, f->p[i]);
     LoadFunction(S, f->p[i], f->source);
   }
 }
@@ -173,7 +187,7 @@ static void LoadProtos (LoadState *S, Proto *f) {
 static void LoadUpvalues (LoadState *S, Proto *f) {
   int i, n;
   n = LoadInt(S);
-  f->upvalues = luaM_newvector(S->L, n, Upvaldesc);
+  f->upvalues = luaM_newvectorchecked(S->L, n, Upvaldesc);
   f->sizeupvalues = n;
   for (i = 0; i < n; i++)
     f->upvalues[i].name = NULL;
@@ -187,27 +201,34 @@ static void LoadUpvalues (LoadState *S, Proto *f) {
 static void LoadDebug (LoadState *S, Proto *f) {
   int i, n;
   n = LoadInt(S);
-  f->lineinfo = luaM_newvector(S->L, n, int);
+  f->lineinfo = luaM_newvectorchecked(S->L, n, ls_byte);
   f->sizelineinfo = n;
   LoadVector(S, f->lineinfo, n);
   n = LoadInt(S);
-  f->locvars = luaM_newvector(S->L, n, LocVar);
+  f->abslineinfo = luaM_newvectorchecked(S->L, n, AbsLineInfo);
+  f->sizeabslineinfo = n;
+  for (i = 0; i < n; i++) {
+    f->abslineinfo[i].pc = LoadInt(S);
+    f->abslineinfo[i].line = LoadInt(S);
+  }
+  n = LoadInt(S);
+  f->locvars = luaM_newvectorchecked(S->L, n, LocVar);
   f->sizelocvars = n;
   for (i = 0; i < n; i++)
     f->locvars[i].varname = NULL;
   for (i = 0; i < n; i++) {
-    f->locvars[i].varname = LoadString(S, f);
+    f->locvars[i].varname = LoadStringN(S);
     f->locvars[i].startpc = LoadInt(S);
     f->locvars[i].endpc = LoadInt(S);
   }
   n = LoadInt(S);
   for (i = 0; i < n; i++)
-    f->upvalues[i].name = LoadString(S, f);
+    f->upvalues[i].name = LoadStringN(S);
 }
 
 
 static void LoadFunction (LoadState *S, Proto *f, TString *psource) {
-  f->source = LoadString(S, f);
+  f->source = LoadStringN(S);
   if (f->source == NULL)  /* no source in dump? */
     f->source = psource;  /* reuse parent's source */
   f->linedefined = LoadInt(S);
@@ -275,10 +296,9 @@ LClosure *luaU_undump(lua_State *L, ZIO *Z, const char *name) {
   S.Z = Z;
   checkHeader(&S);
   cl = luaF_newLclosure(L, LoadByte(&S));
-  setclLvalue(L, L->top, cl);
+  setclLvalue2s(L, L->top, cl);
   luaD_inctop(L);
   cl->p = luaF_newproto(L);
-  luaC_objbarrier(L, cl, cl->p);
   LoadFunction(&S, cl->p, NULL);
   lua_assert(cl->nupvalues == cl->p->sizeupvalues);
   luai_verifycode(L, buff, cl->p);

lundump.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lundump.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lundump.h,v 1.44 2014/06/19 18:27:20 roberto Exp roberto $
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */

lutf8lib.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lutf8lib.c,v 1.16.1.1 2017/04/19 17:29:57 roberto Exp $
+** $Id: lutf8lib.c,v 1.16 2016/12/22 13:08:50 roberto Exp roberto $
 ** Standard library for UTF-8 manipulation
 ** See Copyright Notice in lua.h
 */

lvm.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.h,v 2.41.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lvm.h,v 2.51 2018/02/23 13:13:31 roberto Exp roberto $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -37,11 +37,26 @@
 #endif
 
 
+/* convert an object to a float (including string coercion) */
 #define tonumber(o,n) \
 	(ttisfloat(o) ? (*(n) = fltvalue(o), 1) : luaV_tonumber_(o,n))
 
+
+/* convert an object to a float (without string coercion) */
+#define tonumberns(o,n) \
+	(ttisfloat(o) ? ((n) = fltvalue(o), 1) : \
+	(ttisinteger(o) ? ((n) = cast_num(ivalue(o)), 1) : 0))
+
+
+/* convert an object to an integer (including string coercion) */
 #define tointeger(o,i) \
-    (ttisinteger(o) ? (*(i) = ivalue(o), 1) : luaV_tointeger(o,i,LUA_FLOORN2I))
+  (ttisinteger(o) ? (*(i) = ivalue(o), 1) : luaV_tointeger(o,i,LUA_FLOORN2I))
+
+
+/* convert an object to an integer (without string coercion) */
+#define tointegerns(o,i) \
+  (ttisinteger(o) ? (*(i) = ivalue(o), 1) : luaV_tointegerns(o,i,LUA_FLOORN2I))
+
 
 #define intop(op,v1,v2) l_castU2S(l_castS2U(v1) op l_castS2U(v2))
 
@@ -49,47 +64,39 @@
 
 
 /*
-** fast track for 'gettable': if 't' is a table and 't[k]' is not nil,
-** return 1 with 'slot' pointing to 't[k]' (final result).  Otherwise,
-** return 0 (meaning it will have to check metamethod) with 'slot'
-** pointing to a nil 't[k]' (if 't' is a table) or NULL (otherwise).
-** 'f' is the raw get function to use.
+** fast track for 'gettable': if 't' is a table and 't[k]' is present,
+** return 1 with 'slot' pointing to 't[k]' (position of final result).
+** Otherwise, return 0 (meaning it will have to check metamethod)
+** with 'slot' pointing to an empty 't[k]' (if 't' is a table) or NULL
+** (otherwise). 'f' is the raw get function to use.
 */
 #define luaV_fastget(L,t,k,slot,f) \
   (!ttistable(t)  \
    ? (slot = NULL, 0)  /* not a table; 'slot' is NULL and result is 0 */  \
    : (slot = f(hvalue(t), k),  /* else, do raw access */  \
-      !ttisnil(slot)))  /* result not nil? */
-
-/*
-** standard implementation for 'gettable'
-*/
-#define luaV_gettable(L,t,k,v) { const TValue *slot; \
-  if (luaV_fastget(L,t,k,slot,luaH_get)) { setobj2s(L, v, slot); } \
-  else luaV_finishget(L,t,k,v,slot); }
+      !isempty(slot)))  /* result not empty? */
 
 
 /*
-** Fast track for set table. If 't' is a table and 't[k]' is not nil,
-** call GC barrier, do a raw 't[k]=v', and return true; otherwise,
-** return false with 'slot' equal to NULL (if 't' is not a table) or
-** 'nil'. (This is needed by 'luaV_finishget'.) Note that, if the macro
-** returns true, there is no need to 'invalidateTMcache', because the
-** call is not creating a new entry.
+** Special case of 'luaV_fastget' for integers, inlining the fast case
+** of 'luaH_getint'.
 */
-#define luaV_fastset(L,t,k,slot,f,v) \
-  (!ttistable(t) \
-   ? (slot = NULL, 0) \
-   : (slot = f(hvalue(t), k), \
-     ttisnil(slot) ? 0 \
-     : (luaC_barrierback(L, hvalue(t), v), \
-        setobj2t(L, cast(TValue *,slot), v), \
-        1)))
+#define luaV_fastgeti(L,t,k,slot) \
+  (!ttistable(t)  \
+   ? (slot = NULL, 0)  /* not a table; 'slot' is NULL and result is 0 */  \
+   : (slot = (l_castS2U(k) - 1u < hvalue(t)->alimit) \
+              ? &hvalue(t)->array[k - 1] : luaH_getint(hvalue(t), k), \
+      !isempty(slot)))  /* result not empty? */
 
 
-#define luaV_settable(L,t,k,v) { const TValue *slot; \
-  if (!luaV_fastset(L,t,k,slot,luaH_get,v)) \
-    luaV_finishset(L,t,k,v,slot); }
+/*
+** Finish a fast set operation (when fast get succeeds). In that case,
+** 'slot' points to the place to put the value.
+*/
+#define luaV_finishfastset(L,t,slot,v) \
+    { setobj2t(L, cast(TValue *,slot), v); \
+      luaC_barrierback(L, gcvalue(t), v); }
+
 
 
 
@@ -98,12 +105,14 @@ LUAI_FUNC int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r);
 LUAI_FUNC int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r);
 LUAI_FUNC int luaV_tonumber_ (const TValue *obj, lua_Number *n);
 LUAI_FUNC int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode);
+LUAI_FUNC int luaV_tointegerns (const TValue *obj, lua_Integer *p, int mode);
+LUAI_FUNC int luaV_flttointeger (lua_Number n, lua_Integer *p, int mode);
 LUAI_FUNC void luaV_finishget (lua_State *L, const TValue *t, TValue *key,
                                StkId val, const TValue *slot);
 LUAI_FUNC void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
-                               StkId val, const TValue *slot);
+                               TValue *val, const TValue *slot);
 LUAI_FUNC void luaV_finishOp (lua_State *L);
-LUAI_FUNC void luaV_execute (lua_State *L);
+LUAI_FUNC void luaV_execute (lua_State *L, CallInfo *ci);
 LUAI_FUNC void luaV_concat (lua_State *L, int total);
 LUAI_FUNC lua_Integer luaV_div (lua_State *L, lua_Integer x, lua_Integer y);
 LUAI_FUNC lua_Integer luaV_mod (lua_State *L, lua_Integer x, lua_Integer y);

lzio.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lzio.c,v 1.37.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lzio.c,v 1.36 2014/11/02 19:19:04 roberto Exp roberto $
 ** Buffered streams
 ** See Copyright Notice in lua.h
 */

lzio.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lzio.h,v 1.31.1.1 2017/04/19 17:20:42 roberto Exp $
+** $Id: lzio.h,v 1.30 2014/12/19 17:26:14 roberto Exp roberto $
 ** Buffered streams
 ** See Copyright Notice in lua.h
 */

makefile

@@ -6,7 +6,6 @@
 
 # Warnings valid for both C and C++
 CWARNSCPP= \
-	-pedantic \
 	-Wextra \
 	-Wshadow \
 	-Wsign-compare \
@@ -14,14 +13,15 @@ CWARNSCPP= \
 	-Wwrite-strings \
 	-Wredundant-decls \
 	-Wdisabled-optimization \
-	-Waggregate-return \
 	-Wdouble-promotion \
-	#-Wno-aggressive-loop-optimizations   # not accepted by clang \
-	#-Wlogical-op   # not accepted by clang \
+ 	-Wstrict-aliasing=3 \
+ 	-Wno-aggressive-loop-optimizations \
+ 	-Wlogical-op \
+	-Werror \
+	# -pedantic   # warns if we use jump tables \
 	# the next warnings generate too much noise, so they are disabled
 	# -Wconversion  -Wno-sign-conversion \
 	# -Wsign-conversion \
-	# -Wconversion \
 	# -Wstrict-overflow=2 \
 	# -Wformat=2 \
 	# -Wcast-qual \
@@ -35,31 +35,30 @@ CWARNSC= -Wdeclaration-after-statement \
 	-Wold-style-definition \
 
 
-CWARNS= $(CWARNSCPP)  $(CWARNSC)
+CWARNS= $(CWARNSCPP) $(CWARNSC)
 
 
 # -DEXTERNMEMCHECK -DHARDSTACKTESTS -DHARDMEMTESTS -DTRACEMEM='"tempmem"'
 # -g -DLUA_USER_H='"ltests.h"'
 # -pg -malign-double
 # -DLUA_USE_CTYPE -DLUA_USE_APICHECK
-# (in clang, '-ftrapv' for runtime checks of integer overflows)
-# -fsanitize=undefined -ftrapv
-TESTS= -DLUA_USER_H='"ltests.h"'
+# ('-ftrapv' for runtime checks of integer overflows)
+# -fsanitize=undefined -ftrapv -fno-inline
+TESTS= -DLUA_USER_H='"ltests.h"' -O0
 
-# -mtune=native -fomit-frame-pointer
-# -fno-stack-protector
-LOCAL = $(TESTS) $(CWARNS) -g
+
+# LOCAL = $(TESTS) $(CWARNS) -g
 
 
 
 # enable Linux goodies
-MYCFLAGS= $(LOCAL) -std=c99 -DLUA_USE_LINUX -DLUA_COMPAT_5_2
+MYCFLAGS= $(LOCAL) -std=c99 -DLUA_USE_LINUX -DLUA_USE_READLINE
 MYLDFLAGS= $(LOCAL) -Wl,-E
 MYLIBS= -ldl -lreadline
 
 
 CC= gcc
-CFLAGS= -Wall -O2 $(MYCFLAGS)
+CFLAGS= -Wall -O2 $(MYCFLAGS) -Wfatal-errors -fno-stack-protector -fno-common
 AR= ar rc
 RANLIB= ranlib
 RM= rm -f
@@ -77,7 +76,7 @@ CORE_O=	lapi.o lcode.o lctype.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o \
 	ltm.o lundump.o lvm.o lzio.o ltests.o
 AUX_O=	lauxlib.o
 LIB_O=	lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o lstrlib.o \
-	lutf8lib.o lbitlib.o loadlib.o lcorolib.o linit.o
+	lutf8lib.o loadlib.o lcorolib.o linit.o
 
 LUA_T=	lua
 LUA_O=	lua.o
@@ -133,7 +132,6 @@ lapi.o: lapi.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
  ltable.h lundump.h lvm.h
 lauxlib.o: lauxlib.c lprefix.h lua.h luaconf.h lauxlib.h
 lbaselib.o: lbaselib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
-lbitlib.o: lbitlib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
 lcode.o: lcode.c lprefix.h lua.h luaconf.h lcode.h llex.h lobject.h \
  llimits.h lzio.h lmem.h lopcodes.h lparser.h ldebug.h lstate.h ltm.h \
  ldo.h lgc.h lstring.h ltable.h lvm.h
@@ -183,7 +181,7 @@ ltests.o: ltests.c lprefix.h lua.h luaconf.h lapi.h llimits.h lstate.h \
  lparser.h lctype.h ldebug.h ldo.h lfunc.h lstring.h lgc.h ltable.h \
  lualib.h
 ltm.o: ltm.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
- llimits.h ltm.h lzio.h lmem.h ldo.h lstring.h lgc.h ltable.h lvm.h
+ llimits.h ltm.h lzio.h lmem.h ldo.h lgc.h lstring.h ltable.h lvm.h
 lua.o: lua.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
 lundump.o: lundump.c lprefix.h lua.h luaconf.h ldebug.h lstate.h \
  lobject.h llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lstring.h lgc.h \
@@ -191,7 +189,7 @@ lundump.o: lundump.c lprefix.h lua.h luaconf.h ldebug.h lstate.h \
 lutf8lib.o: lutf8lib.c lprefix.h lua.h luaconf.h lauxlib.h lualib.h
 lvm.o: lvm.c lprefix.h lua.h luaconf.h ldebug.h lstate.h lobject.h \
  llimits.h ltm.h lzio.h lmem.h ldo.h lfunc.h lgc.h lopcodes.h lstring.h \
- ltable.h lvm.h
+ ltable.h lvm.h ljumptab.h
 lzio.o: lzio.c lprefix.h lua.h luaconf.h llimits.h lmem.h lstate.h \
  lobject.h ltm.h lzio.h
 

manual/2html

@@ -1,518 +0,0 @@
-#!/usr/bin/env lua5.2
-
-
--- special marks:
--- \1 - paragraph (empty line)
--- \4 - remove spaces around it
--- \3 - ref (followed by label|)
-
----------------------------------------------------------------
-header = [[
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
-<html>
-
-<head>
-<title>Lua 5.3 Reference Manual</title>
-<meta http-equiv="Content-Type" content="text/html;charset=utf-8">
-<link rel="stylesheet" href="lua.css">
-<link rel="stylesheet" href="manual.css">
-</head>
-
-<body bgcolor="#FFFFFF">
-
-<hr>
-<h1>
-<a href="http://www.lua.org/home.html"><img src="logo.gif" alt="[Lua logo]" border="0"></a>
-Lua 5.3 Reference Manual
-</h1>
-
-by Roberto Ierusalimschy, Luiz Henrique de Figueiredo, Waldemar Celes
-<p>
-<small>
-<a href="http://www.lua.org/copyright.html">Copyright</a>
-&copy; 2015 Lua.org, PUC-Rio.  All rights reserved.
-</small>
-<hr>
-
-<!-- ====================================================================== -->
-<p>
-
-]]
-
-footer = "\n\n</body></html>\n\n"
-
-local seefmt = '(see %s)'
-
-if arg[1] == 'port' then
-  seefmt = '(ver %s)'
-  header = string.gsub(header, "by (.-)\n",
-  "%1\n<p>Tradu&ccedil;&atilde;o: S&eacute;rgio Queiroz de Medeiros", 1)
-  header = string.gsub(header, "Lua (%d+.%d+) Reference Manual",
-                               "Manual de Refer&ecirc;ncia de Lua %1")
-  header = string.gsub(header, "All rights reserved",
-                               "Todos os direitos reservados")
-end
-
-
----------------------------------------------------------------
-
-local function compose (f,g)
-  assert(f and g)
-  return function (s) return g(f(s)) end
-end
-
-local function concat (f, g)
-  assert(f and g)
-  return function (s) return f(s) .. g(s) end
-end
-
-
-local Tag = {}
-
-
-setmetatable(Tag, {
-  __index = function (t, tag)
-      local v = function (n, att)
-        local e = ""
-        if type(att) == "table" then
-          for k,v in pairs(att) do e = string.format('%s %s="%s"', e, k, v) end
-        end
-        if n then
-          return string.format("<%s%s>%s</%s>", tag, e, n, tag)
-        else
-          return string.format("<%s%s>", tag, e)
-        end
-      end
-      t[tag] = v
-      return v
-  end
-})
-
-
-
----------------------------------------------------------------
-local labels = {}
-
-
-local function anchor (text, label, link, textlink)
-  if labels[label] then
-    error("label " .. label .. " already defined")
-  end
-  labels[label] = {text = textlink, link = link}
-  return Tag.a(text, {name=link})
-end
-
-local function makeref (label)
-  assert(not string.find(label, "|"))
-  return string.format("\3%s\3", label)
-end
-
-local function ref (label)
-  local l = labels[label]
-  if not l then
-    io.stderr:write("label ", label, " undefined\n")
-    return "@@@@@@@"
-  else
-    return Tag.a(l.text, {href="#"..l.link})
-  end
-end
-
----------------------------------------------------------------
-local function nopara (t)
-  t = string.gsub(t, "\1", "\n\n")
-  t = string.gsub(t, "<p>%s*</p>", "")
-  return t
-end
-
-local function fixpara (t)
-  t = string.gsub(t, "\1", "\n</p>\n\n<p>\n")
-  t = string.gsub(t, "<p>%s*</p>", "")
-  return t
-end
-
-local function antipara (t)
-  return "</p>\n" .. t .. "<p>"
-end
-
-
-Tag.pre = compose(Tag.pre, antipara)
-Tag.ul = compose(Tag.ul, antipara)
-
----------------------------------------------------------------
-local Gfoots = 0
-local footnotes = {}
-
-local line = Tag.hr(nil)
-
-local function dischargefoots ()
-  if #footnotes == 0 then return "" end
-  local fn = table.concat(footnotes)
-  footnotes = {}
-  return line .. Tag.h3"footnotes:" .. fn .. line
-end
-
-
-local Glists = 0
-local listings = {}
-
-local function dischargelist ()
-  if #listings == 0 then return "" end
-  local l = listings
-  listings = {}
-  return line .. table.concat(l, line..line) .. line
-end
-
----------------------------------------------------------------
-local counters = {
-h1 = {val = 1},
-h2 = {father = "h1", val = 1},
-h3 = {father = "h2", val = 1},
-listing = {father = "h1", val = 1},
-}
-
-local function inccounter (count)
-  counters[count].val = counters[count].val + 1
-  for c, v in pairs(counters) do
-    if v.father == count then v.val = 1 end
-  end
-end
-
-local function getcounter (count)
-  local c = counters[count]
-  if c.father then
-    return getcounter(c.father) .. "." .. c.val
-  else
-    return c.val .. ""
-  end
-end
----------------------------------------------------------------
-
-
-local function fixed (x)
-  return function () return x end
-end
-
-local function id (x) return x end
-
-
-local function prepos (x, y)
-  assert(x and y)
-  return function (s) return string.format("%s%s%s", x, s, y) end
-end
-
-
-local rw = Tag.b
-
-
-
-
-local function LuaName (name)
-  return Tag.code(name)
-end
-
-
-local function getparam (s)
-  local i, e = string.find(s, "^[^%s@|]+|")
-  if not i then return nil, s
-  else return string.sub(s, i, e - 1), string.sub(s, e + 1)
-  end
-end
-
-
-local function gettitle (h)
-  local title, p = assert(string.match(h, "<title>(.-)</title>()"))
-  return title, string.sub(h, p)
-end
-
-local function getparamtitle (what, h, nonum)
-    local label, title, c, count
-    label, h = getparam(h)
-    title, h = gettitle(h)
-    if not nonum then
-      count = getcounter(what)
-      inccounter(what)
-      c = string.format("%s &ndash; ", count)
-    else
-      c = ""
-    end
-    label = label or count
-    if label then
-      title = anchor(title, label, count, "&sect;"..count)
-    end
-    title = string.format("%s%s", c, title)
-    return title, h
-end
-
-local function section (what, nonum)
-  return function (h)
-    local title
-    title, h = getparamtitle(what, h, nonum)
-    local fn = what == "h1" and dischargefoots() or ""
-    h = fixpara(Tag.p(h))
-    return "</p>\n" .. Tag[what](title) .. h .. fn ..
-           dischargelist() .. "<p>"
-  end
-end
-
-
-local function verbatim (s)
-  s = nopara(s)
-  s = string.gsub(s, "\n", "\n     ")
-  s = string.gsub(s, "\n%s*$", "\n")
-  return Tag.pre(s)
-end
-
-
-local function verb (s)
-  return Tag.code(s)
-end
-
-
-local function lua2link (e)
-  return string.find(e, "luaL?_") and e or "pdf-"..e
-end
-
-
-local verbfixed = verb
-
-
-local Tex = {
-
-ANSI = function (func)
-           return "ISO&nbsp;C function " .. Tag.code(func)
-         end,
-At = fixed"@",
-B = Tag.b,
-bigskip = fixed"",
-bignum = id,
-C = fixed"",
-Ci = prepos("<!-- ", " -->"),
-CId = function (func)
-        return "C&nbsp;function " .. Tag.code(func)
-      end,
-chapter = section"h1",
-Char = compose(verbfixed, prepos("'", "'")),
-Cdots = fixed"&middot;&middot;&middot;",
-Close = fixed"}",
-col = Tag.td,
-defid = function (name)
-          local l = lua2link(name)
-          local c = Tag.code(name)
-          return anchor(c, l, l, c)
-        end,
-def = Tag.em,
-description = compose(nopara, Tag.ul),
-Em = fixed("\4" .. "&mdash;" .. "\4"),
-emph = Tag.em,
-emphx = Tag.em,    -- emphasis plus index (if there was an index)
-En = fixed("&ndash;"),
-format = fixed"",
-["false"] = fixed(Tag.b"false"),
-id = Tag.code,
-idx = Tag.code,
-index = fixed"",
-Lidx = fixed"",  -- Tag.code,
-ldots = fixed"...",
-x = id,
-itemize = compose(nopara, Tag.ul),
-leq = fixed"&le;",
-Lid = function (s)
-        return makeref(lua2link(s))
-      end,
-M = Tag.em,
-N = function (s) return (string.gsub(s, " ", "&nbsp;")) end,
-NE = id,        -- tag"foreignphrase",
-num = id,
-["nil"] = fixed(Tag.b"nil"),
-Open = fixed"{",
-part = section("h1", true),
-Pat = compose(verbfixed, prepos("'", "'")),
-preface = section("h1", true),
-psect = section("h2", true),
-Q = prepos('"', '"'),
-refchp = makeref,
-refcode = makeref,
-refsec = makeref,
-
-pi = fixed"&pi;",
-rep = Tag.em,  -- compose(prepos("&lt;", "&gt;"), Tag.em),
-Rw = rw,
-rw = rw,
-sb = Tag.sub,
-sp = Tag.sup,
-St = compose(verbfixed, prepos('"', '"')),
-sect1 = section"h1",
-sect2 = section"h2",
-sect3 = section"h3",
-sect4 = section("h4", true),
-simplesect = id,
-Tab2 = function (s) return Tag.table(s, {border=1}) end,
-row = Tag.tr,
-title = Tag.title,
-todo = Tag.todo,
-["true"] = fixed(Tag.b"true"),
-T = verb,
-
-item = function (s)
-         local t, p = string.match(s, "^([^\n|]+)|()")
-         if t then
-           s = string.sub(s, p)
-           s = Tag.b(t..": ") .. s
-         end
-         return Tag.li(fixpara(s))
-       end,
-
-verbatim = verbatim,
-
-manual = id,
-
-
--- for the manual
-
-link =function (s)
-  local l, t = getparam(s)
-  assert(l)
-  return string.format("%s (%s)", t, makeref(l))
-end,
-
-see = function (s) return string.format(seefmt, makeref(s)) end,
-See = makeref,
-seeC = function (s)
-         return string.format(seefmt, makeref(s))
-       end,
-
-seeF = function (s)
-         return string.format(seefmt, makeref(lua2link(s)))
-       end,
-
-APIEntry = function (e)
-  local h, name
-  h, e = string.match(e, "^%s*(.-)%s*|(.*)$")
-  name = string.match(h, "(luaL?_[%w_]+)%)? +%(") or
-         string.match(h, "luaL?_[%w_]+")
-  local a = anchor(Tag.code(name), name, name, Tag.code(name))
-  local apiicmd, ne = string.match(e, "^(.-</span>)(.*)")
---io.stderr:write(e)
-  if not apiicmd then
-    return antipara(Tag.hr() .. Tag.h3(a)) .. Tag.pre(h) .. e
-  else
-    return antipara(Tag.hr() .. Tag.h3(a)) .. apiicmd .. Tag.pre(h) .. ne
-  end
-end,
-
-LibEntry = function (e)
-  local h, name
-  h, e = string.match(e, "^(.-)|(.*)$")
-  name = string.gsub(h, " (.+", "")
-  local l = lua2link(name)
-  local a = anchor(Tag.code(h), l, l, Tag.code(name))
-  return Tag.hr() .. Tag.h3(a) .. e
-end,
-
-Produc = compose(nopara, Tag.pre),
-producname = prepos("\t", " ::= "),
-Or = fixed" | ",
-VerBar = fixed"&#124;",  -- vertical bar
-OrNL = fixed" | \4",
-bnfNter = prepos("", ""),
-bnfopt = prepos("[", "]"),
-bnfrep = prepos("{", "}"),
-bnfter = compose(Tag.b, prepos("&lsquo;", "&rsquo;")),
-producbody = function (s)
-           s = string.gsub(s, "%s+", " ")
-           s = string.gsub(s, "\4", "\n\t\t")
-           return s
-         end,
-
-apii = function (s)
-        local pop,push,err = string.match(s, "^(.-),(.-),(.*)$")
-        if pop ~= "?" and string.find(pop, "%W") then
-          pop = "(" .. pop .. ")"
-        end
-        if push ~= "?" and string.find(push, "%W") then
-          push = "(" .. push .. ")"
-        end
-        err = (err == "-") and "&ndash;" or Tag.em(err)
-        return Tag.span(
-                 string.format("[-%s, +%s, %s]", pop, push, err),
-                 {class="apii"}
-               )
-      end,
-}
-
-local others = prepos("?? "," ??")
-
-local function trata (t)
-  t = string.gsub(t, "@(%w+)(%b{})", function (w, f)
-        f = trata(string.sub(f, 2, -2))
-        if type(Tex[w]) ~= "function" then
-         io.stderr:write(w .. "\n")
-         return others(f)
-        else
-         return Tex[w](f, w)
-        end
-      end)
-  return t
-end
-
-
----------------------------------------------------------------------
----------------------------------------------------------------------
-
--- read whole book
-t = io.read"*a"
-
-t = string.gsub(t, "[<>&\128-\255]",
-  {["<"] = "&lt;",
-   [">"] = "&gt;",
-   ["&"] = "&amp;",
-   ["\170"] = "&ordf;",
-   ["\186"] = "&ordm;",
-   ["\192"] = "&Agrave;",
-   ["\193"] = "&Aacute;",
-   ["\194"] = "&Acirc;",
-   ["\195"] = "&Atilde;",
-   ["\199"] = "&Ccedil;",
-   ["\201"] = "&Eacute;",
-   ["\202"] = "&Ecirc;",
-   ["\205"] = "&Iacute;",
-   ["\211"] = "&Oacute;",
-   ["\212"] = "&Ocirc;",
-   ["\218"] = "&Uacute;",
-   ["\224"] = "&agrave;",
-   ["\225"] = "&aacute;",
-   ["\226"] = "&acirc;",
-   ["\227"] = "&atilde;",
-   ["\231"] = "&ccedil;",
-   ["\233"] = "&eacute;",
-   ["\234"] = "&ecirc;",
-   ["\237"] = "&iacute;",
-   ["\243"] = "&oacute;",
-   ["\244"] = "&ocirc;",
-   ["\245"] = "&otilde;",
-   ["\250"] = "&uacute;",
-   ["\252"] = "&uuml;"
-  })
-
-t = string.gsub(t, "\n\n+", "\1")
-
-
-
--- complete macros with no arguments
-t = string.gsub(t, "(@%w+)([^{%w])", "%1{}%2")
-
-t = trata(t)
-
--- correct references
-t = string.gsub(t, "\3(.-)\3", ref)
-
--- remove extra space (??)
-t = string.gsub(t, "%s*\4%s*", "")
-
-t = nopara(t)
-
--- HTML 3.2 does not need </p> (but complains when it is in wrong places :)
-t = string.gsub(t, "</p>", "")
-
-io.write(header, t, footer)
-

testes/all.lua

@@ -1,291 +0,0 @@
-#!../lua
--- $Id: all.lua,v 1.95 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice at the end of this file
-
-
-local version = "Lua 5.3"
-if _VERSION ~= version then
-  io.stderr:write("\nThis test suite is for ", version, ", not for ", _VERSION,
-    "\nExiting tests\n")
-  return
-end
-
-
-_G._ARG = arg   -- save arg for other tests
-
-
--- next variables control the execution of some tests
--- true means no test (so an undefined variable does not skip a test)
--- defaults are for Linux; test everything.
--- Make true to avoid long or memory consuming tests
-_soft = rawget(_G, "_soft") or false
--- Make true to avoid non-portable tests
-_port = rawget(_G, "_port") or false
--- Make true to avoid messages about tests not performed
-_nomsg = rawget(_G, "_nomsg") or false
-
-
-local usertests = rawget(_G, "_U")
-
-if usertests then
-  -- tests for sissies ;)  Avoid problems
-  _soft = true
-  _port = true
-  _nomsg = true
-end
-
--- tests should require debug when needed
-debug = nil
-
-if usertests then
-  T = nil    -- no "internal" tests for user tests
-else
-  T = rawget(_G, "T")  -- avoid problems with 'strict' module
-end
-
-math.randomseed(0)
-
---[=[
-  example of a long [comment],
-  [[spanning several [lines]]]
-
-]=]
-
-print("current path:\n****" .. package.path .. "****\n")
-
-
-local initclock = os.clock()
-local lastclock = initclock
-local walltime = os.time()
-
-local collectgarbage = collectgarbage
-
-do   -- (
-
--- track messages for tests not performed
-local msgs = {}
-function Message (m)
-  if not _nomsg then
-    print(m)
-    msgs[#msgs+1] = string.sub(m, 3, -3)
-  end
-end
-
-assert(os.setlocale"C")
-
-local T,print,format,write,assert,type,unpack,floor =
-      T,print,string.format,io.write,assert,type,table.unpack,math.floor
-
--- use K for 1000 and M for 1000000 (not 2^10 -- 2^20)
-local function F (m)
-  local function round (m)
-    m = m + 0.04999
-    return format("%.1f", m)      -- keep one decimal digit
-  end
-  if m < 1000 then return m
-  else
-    m = m / 1000
-    if m < 1000 then return round(m).."K"
-    else
-      return round(m/1000).."M"
-    end
-  end
-end
-
-local showmem
-if not T then
-  local max = 0
-  showmem = function ()
-    local m = collectgarbage("count") * 1024
-    max = (m > max) and m or max
-    print(format("    ---- total memory: %s, max memory: %s ----\n",
-          F(m), F(max)))
-  end
-else
-  showmem = function ()
-    T.checkmemory()
-    local total, numblocks, maxmem = T.totalmem()
-    local count = collectgarbage("count")
-    print(format(
-      "\n    ---- total memory: %s (%.0fK), max use: %s,  blocks: %d\n",
-      F(total), count, F(maxmem), numblocks))
-    print(format("\t(strings:  %d, tables: %d, functions: %d, "..
-                 "\n\tudata: %d, threads: %d)",
-                 T.totalmem"string", T.totalmem"table", T.totalmem"function",
-                 T.totalmem"userdata", T.totalmem"thread"))
-  end
-end
-
-
---
--- redefine dofile to run files through dump/undump
---
-local function report (n) print("\n***** FILE '"..n.."'*****") end
-local olddofile = dofile
-local dofile = function (n, strip)
-  showmem()
-  local c = os.clock()
-  print(string.format("time: %g (+%g)", c - initclock, c - lastclock))
-  lastclock = c
-  report(n)
-  local f = assert(loadfile(n))
-  local b = string.dump(f, strip)
-  f = assert(load(b))
-  return f()
-end
-
-dofile('main.lua')
-
-do
-  local next, setmetatable, stderr = next, setmetatable, io.stderr
-  -- track collections
-  local mt = {}
-  -- each time a table is collected, remark it for finalization
-  -- on next cycle
-  mt.__gc = function (o)
-     stderr:write'.'    -- mark progress
-     local n = setmetatable(o, mt)   -- remark it
-   end
-   local n = setmetatable({}, mt)    -- create object
-end
-
-report"gc.lua"
-local f = assert(loadfile('gc.lua'))
-f()
-
-dofile('db.lua')
-assert(dofile('calls.lua') == deep and deep)
-olddofile('strings.lua')
-olddofile('literals.lua')
-dofile('tpack.lua')
-assert(dofile('attrib.lua') == 27)
-
-assert(dofile('locals.lua') == 5)
-dofile('constructs.lua')
-dofile('code.lua', true)
-if not _G._soft then
-  report('big.lua')
-  local f = coroutine.wrap(assert(loadfile('big.lua')))
-  assert(f() == 'b')
-  assert(f() == 'a')
-end
-dofile('nextvar.lua')
-dofile('pm.lua')
-dofile('utf8.lua')
-dofile('api.lua')
-assert(dofile('events.lua') == 12)
-dofile('vararg.lua')
-dofile('closure.lua')
-dofile('coroutine.lua')
-dofile('goto.lua', true)
-dofile('errors.lua')
-dofile('math.lua')
-dofile('sort.lua', true)
-dofile('bitwise.lua')
-assert(dofile('verybig.lua', true) == 10); collectgarbage()
-dofile('files.lua')
-
-if #msgs > 0 then
-  print("\ntests not performed:")
-  for i=1,#msgs do
-    print(msgs[i])
-  end
-  print()
-end
-
--- no test module should define 'debug'
-assert(debug == nil)
-
-local debug = require "debug"
-
-print(string.format("%d-bit integers, %d-bit floats",
-        string.packsize("j") * 8, string.packsize("n") * 8))
-
-debug.sethook(function (a) assert(type(a) == 'string') end, "cr")
-
--- to survive outside block
-_G.showmem = showmem
-
-end   --)
-
-local _G, showmem, print, format, clock, time, difftime, assert, open =
-      _G, showmem, print, string.format, os.clock, os.time, os.difftime,
-      assert, io.open
-
--- file with time of last performed test
-local fname = T and "time-debug.txt" or "time.txt"
-local lasttime
-
-if not usertests then
-  -- open file with time of last performed test
-  local f = io.open(fname)
-  if f then
-    lasttime = assert(tonumber(f:read'a'))
-    f:close();
-  else   -- no such file; assume it is recording time for first time
-    lasttime = nil
-  end
-end
-
--- erase (almost) all globals
-print('cleaning all!!!!')
-for n in pairs(_G) do
-  if not ({___Glob = 1, tostring = 1})[n] then
-    _G[n] = nil
-  end
-end
-
-
-collectgarbage()
-collectgarbage()
-collectgarbage()
-collectgarbage()
-collectgarbage()
-collectgarbage();showmem()
-
-local clocktime = clock() - initclock
-walltime = difftime(time(), walltime)
-
-print(format("\n\ntotal time: %.2fs (wall time: %gs)\n", clocktime, walltime))
-
-if not usertests then
-  lasttime = lasttime or clocktime    -- if no last time, ignore difference
-  -- check whether current test time differs more than 5% from last time
-  local diff = (clocktime - lasttime) / lasttime
-  local tolerance = 0.05    -- 5%
-  if (diff >= tolerance or diff <= -tolerance) then
-    print(format("WARNING: time difference from previous test: %+.1f%%",
-                  diff * 100))
-  end
-  assert(open(fname, "w")):write(clocktime):close()
-end
-
-print("final OK !!!")
-
-
-
---[[
-*****************************************************************************
-* Copyright (C) 1994-2016 Lua.org, PUC-Rio.
-*
-* Permission is hereby granted, free of charge, to any person obtaining
-* a copy of this software and associated documentation files (the
-* "Software"), to deal in the Software without restriction, including
-* without limitation the rights to use, copy, modify, merge, publish,
-* distribute, sublicense, and/or sell copies of the Software, and to
-* permit persons to whom the Software is furnished to do so, subject to
-* the following conditions:
-*
-* The above copyright notice and this permission notice shall be
-* included in all copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*****************************************************************************
-]]
-

testes/attrib.lua

@@ -1,470 +0,0 @@
--- $Id: attrib.lua,v 1.65 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print "testing require"
-
-assert(require"string" == string)
-assert(require"math" == math)
-assert(require"table" == table)
-assert(require"io" == io)
-assert(require"os" == os)
-assert(require"coroutine" == coroutine)
-
-assert(type(package.path) == "string")
-assert(type(package.cpath) == "string")
-assert(type(package.loaded) == "table")
-assert(type(package.preload) == "table")
-
-assert(type(package.config) == "string")
-print("package config: "..string.gsub(package.config, "\n", "|"))
-
-do
-  -- create a path with 'max' templates,
-  -- each with 1-10 repetitions of '?'
-  local max = _soft and 100 or 2000
-  local t = {}
-  for i = 1,max do t[i] = string.rep("?", i%10 + 1) end
-  t[#t + 1] = ";"    -- empty template
-  local path = table.concat(t, ";")
-  -- use that path in a search
-  local s, err = package.searchpath("xuxu", path)
-  -- search fails; check that message has an occurence of
-  -- '??????????' with ? replaced by xuxu and at least 'max' lines
-  assert(not s and
-         string.find(err, string.rep("xuxu", 10)) and
-         #string.gsub(err, "[^\n]", "") >= max)
-  -- path with one very long template
-  local path = string.rep("?", max)
-  local s, err = package.searchpath("xuxu", path)
-  assert(not s and string.find(err, string.rep('xuxu', max)))
-end
-
-do
-  local oldpath = package.path
-  package.path = {}
-  local s, err = pcall(require, "no-such-file")
-  assert(not s and string.find(err, "package.path"))
-  package.path = oldpath
-end
-
-print('+')
-
-
--- The next tests for 'require' assume some specific directories and
--- libraries.
-
-if not _port then --[
-
-local dirsep = string.match(package.config, "^([^\n]+)\n")
-
--- auxiliary directory with C modules and temporary files
-local DIR = "libs" .. dirsep
-
--- prepend DIR to a name and correct directory separators
-local function D (x)
-  x = string.gsub(x, "/", dirsep)
-  return DIR .. x
-end
-
--- prepend DIR and pospend proper C lib. extension to a name
-local function DC (x)
-  local ext = (dirsep == '\\') and ".dll" or ".so"
-  return D(x .. ext)
-end
-
-
-local function createfiles (files, preextras, posextras)
-  for n,c in pairs(files) do
-    io.output(D(n))
-    io.write(string.format(preextras, n))
-    io.write(c)
-    io.write(string.format(posextras, n))
-    io.close(io.output())
-  end
-end
-
-function removefiles (files)
-  for n in pairs(files) do
-    os.remove(D(n))
-  end
-end
-
-local files = {
-  ["names.lua"] = "do return {...} end\n",
-  ["err.lua"] = "B = 15; a = a + 1;",
-  ["synerr.lua"] = "B =",
-  ["A.lua"] = "",
-  ["B.lua"] = "assert(...=='B');require 'A'",
-  ["A.lc"] = "",
-  ["A"] = "",
-  ["L"] = "",
-  ["XXxX"] = "",
-  ["C.lua"] = "package.loaded[...] = 25; require'C'",
-}
-
-AA = nil
-local extras = [[
-NAME = '%s'
-REQUIRED = ...
-return AA]]
-
-createfiles(files, "", extras)
-
--- testing explicit "dir" separator in 'searchpath'
-assert(package.searchpath("C.lua", D"?", "", "") == D"C.lua")
-assert(package.searchpath("C.lua", D"?", ".", ".") == D"C.lua")
-assert(package.searchpath("--x-", D"?", "-", "X") == D"XXxX")
-assert(package.searchpath("---xX", D"?", "---", "XX") == D"XXxX")
-assert(package.searchpath(D"C.lua", "?", dirsep) == D"C.lua")
-assert(package.searchpath(".\\C.lua", D"?", "\\") == D"./C.lua")
-
-local oldpath = package.path
-
-package.path = string.gsub("D/?.lua;D/?.lc;D/?;D/??x?;D/L", "D/", DIR)
-
-local try = function (p, n, r)
-  NAME = nil
-  local rr = require(p)
-  assert(NAME == n)
-  assert(REQUIRED == p)
-  assert(rr == r)
-end
-
-a = require"names"
-assert(a[1] == "names" and a[2] == D"names.lua")
-
-_G.a = nil
-local st, msg = pcall(require, "err")
-assert(not st and string.find(msg, "arithmetic") and B == 15)
-st, msg = pcall(require, "synerr")
-assert(not st and string.find(msg, "error loading module"))
-
-assert(package.searchpath("C", package.path) == D"C.lua")
-assert(require"C" == 25)
-assert(require"C" == 25)
-AA = nil
-try('B', 'B.lua', true)
-assert(package.loaded.B)
-assert(require"B" == true)
-assert(package.loaded.A)
-assert(require"C" == 25)
-package.loaded.A = nil
-try('B', nil, true)   -- should not reload package
-try('A', 'A.lua', true)
-package.loaded.A = nil
-os.remove(D'A.lua')
-AA = {}
-try('A', 'A.lc', AA)  -- now must find second option
-assert(package.searchpath("A", package.path) == D"A.lc")
-assert(require("A") == AA)
-AA = false
-try('K', 'L', false)     -- default option
-try('K', 'L', false)     -- default option (should reload it)
-assert(rawget(_G, "_REQUIREDNAME") == nil)
-
-AA = "x"
-try("X", "XXxX", AA)
-
-
-removefiles(files)
-
-
--- testing require of sub-packages
-
-local _G = _G
-
-package.path = string.gsub("D/?.lua;D/?/init.lua", "D/", DIR)
-
-files = {
-  ["P1/init.lua"] = "AA = 10",
-  ["P1/xuxu.lua"] = "AA = 20",
-}
-
-createfiles(files, "_ENV = {}\n", "\nreturn _ENV\n")
-AA = 0
-
-local m = assert(require"P1")
-assert(AA == 0 and m.AA == 10)
-assert(require"P1" == m)
-assert(require"P1" == m)
-
-assert(package.searchpath("P1.xuxu", package.path) == D"P1/xuxu.lua")
-m.xuxu = assert(require"P1.xuxu")
-assert(AA == 0 and m.xuxu.AA == 20)
-assert(require"P1.xuxu" == m.xuxu)
-assert(require"P1.xuxu" == m.xuxu)
-assert(require"P1" == m and m.AA == 10)
-
-
-removefiles(files)
-
-
-package.path = ""
-assert(not pcall(require, "file_does_not_exist"))
-package.path = "??\0?"
-assert(not pcall(require, "file_does_not_exist1"))
-
-package.path = oldpath
-
--- check 'require' error message
-local fname = "file_does_not_exist2"
-local m, err = pcall(require, fname)
-for t in string.gmatch(package.path..";"..package.cpath, "[^;]+") do
-  t = string.gsub(t, "?", fname)
-  assert(string.find(err, t, 1, true))
-end
-
-do  -- testing 'package.searchers' not being a table
-  local searchers = package.searchers
-  package.searchers = 3
-  local st, msg = pcall(require, 'a')
-  assert(not st and string.find(msg, "must be a table"))
-  package.searchers = searchers
-end
-
-local function import(...)
-  local f = {...}
-  return function (m)
-    for i=1, #f do m[f[i]] = _G[f[i]] end
-  end
-end
-
--- cannot change environment of a C function
-assert(not pcall(module, 'XUXU'))
-
-
-
--- testing require of C libraries
-
-
-local p = ""   -- On Mac OS X, redefine this to "_"
-
--- check whether loadlib works in this system
-local st, err, when = package.loadlib(DC"lib1", "*")
-if not st then
-  local f, err, when = package.loadlib("donotexist", p.."xuxu")
-  assert(not f and type(err) == "string" and when == "absent")
-  ;(Message or print)('\n >>> cannot load dynamic library <<<\n')
-  print(err, when)
-else
-  -- tests for loadlib
-  local f = assert(package.loadlib(DC"lib1", p.."onefunction"))
-  local a, b = f(15, 25)
-  assert(a == 25 and b == 15)
-
-  f = assert(package.loadlib(DC"lib1", p.."anotherfunc"))
-  assert(f(10, 20) == "10%20\n")
-
-  -- check error messages
-  local f, err, when = package.loadlib(DC"lib1", p.."xuxu")
-  assert(not f and type(err) == "string" and when == "init")
-  f, err, when = package.loadlib("donotexist", p.."xuxu")
-  assert(not f and type(err) == "string" and when == "open")
-
-  -- symbols from 'lib1' must be visible to other libraries
-  f = assert(package.loadlib(DC"lib11", p.."luaopen_lib11"))
-  assert(f() == "exported")
-
-  -- test C modules with prefixes in names
-  package.cpath = DC"?"
-  local lib2 = require"lib2-v2"
-  -- check correct access to global environment and correct
-  -- parameters
-  assert(_ENV.x == "lib2-v2" and _ENV.y == DC"lib2-v2")
-  assert(lib2.id("x") == "x")
-
-  -- test C submodules
-  local fs = require"lib1.sub"
-  assert(_ENV.x == "lib1.sub" and _ENV.y == DC"lib1")
-  assert(fs.id(45) == 45)
-end
-
-_ENV = _G
-
-
--- testing preload
-
-do
-  local p = package
-  package = {}
-  p.preload.pl = function (...)
-    local _ENV = {...}
-    function xuxu (x) return x+20 end
-    return _ENV
-  end
-
-  local pl = require"pl"
-  assert(require"pl" == pl)
-  assert(pl.xuxu(10) == 30)
-  assert(pl[1] == "pl" and pl[2] == nil)
-
-  package = p
-  assert(type(package.path) == "string")
-end
-
-print('+')
-
-end  --]
-
-print("testing assignments, logical operators, and constructors")
-
-local res, res2 = 27
-
-a, b = 1, 2+3
-assert(a==1 and b==5)
-a={}
-function f() return 10, 11, 12 end
-a.x, b, a[1] = 1, 2, f()
-assert(a.x==1 and b==2 and a[1]==10)
-a[f()], b, a[f()+3] = f(), a, 'x'
-assert(a[10] == 10 and b == a and a[13] == 'x')
-
-do
-  local f = function (n) local x = {}; for i=1,n do x[i]=i end;
-                         return table.unpack(x) end;
-  local a,b,c
-  a,b = 0, f(1)
-  assert(a == 0 and b == 1)
-  A,b = 0, f(1)
-  assert(A == 0 and b == 1)
-  a,b,c = 0,5,f(4)
-  assert(a==0 and b==5 and c==1)
-  a,b,c = 0,5,f(0)
-  assert(a==0 and b==5 and c==nil)
-end
-
-a, b, c, d = 1 and nil, 1 or nil, (1 and (nil or 1)), 6
-assert(not a and b and c and d==6)
-
-d = 20
-a, b, c, d = f()
-assert(a==10 and b==11 and c==12 and d==nil)
-a,b = f(), 1, 2, 3, f()
-assert(a==10 and b==1)
-
-assert(a<b == false and a>b == true)
-assert((10 and 2) == 2)
-assert((10 or 2) == 10)
-assert((10 or assert(nil)) == 10)
-assert(not (nil and assert(nil)))
-assert((nil or "alo") == "alo")
-assert((nil and 10) == nil)
-assert((false and 10) == false)
-assert((true or 10) == true)
-assert((false or 10) == 10)
-assert(false ~= nil)
-assert(nil ~= false)
-assert(not nil == true)
-assert(not not nil == false)
-assert(not not 1 == true)
-assert(not not a == true)
-assert(not not (6 or nil) == true)
-assert(not not (nil and 56) == false)
-assert(not not (nil and true) == false)
-assert(not 10 == false)
-assert(not {} == false)
-assert(not 0.5 == false)
-assert(not "x" == false)
-
-assert({} ~= {})
-print('+')
-
-a = {}
-a[true] = 20
-a[false] = 10
-assert(a[1<2] == 20 and a[1>2] == 10)
-
-function f(a) return a end
-
-local a = {}
-for i=3000,-3000,-1 do a[i + 0.0] = i; end
-a[10e30] = "alo"; a[true] = 10; a[false] = 20
-assert(a[10e30] == 'alo' and a[not 1] == 20 and a[10<20] == 10)
-for i=3000,-3000,-1 do assert(a[i] == i); end
-a[print] = assert
-a[f] = print
-a[a] = a
-assert(a[a][a][a][a][print] == assert)
-a[print](a[a[f]] == a[print])
-assert(not pcall(function () local a = {}; a[nil] = 10 end))
-assert(not pcall(function () local a = {[nil] = 10} end))
-assert(a[nil] == nil)
-a = nil
-
-a = {10,9,8,7,6,5,4,3,2; [-3]='a', [f]=print, a='a', b='ab'}
-a, a.x, a.y = a, a[-3]
-assert(a[1]==10 and a[-3]==a.a and a[f]==print and a.x=='a' and not a.y)
-a[1], f(a)[2], b, c = {['alo']=assert}, 10, a[1], a[f], 6, 10, 23, f(a), 2
-a[1].alo(a[2]==10 and b==10 and c==print)
-
-
--- test of large float/integer indices 
-
--- compute maximum integer where all bits fit in a float
-local maxint = math.maxinteger
-
-while maxint - 1.0 == maxint - 0.0 do   -- trim (if needed) to fit in a float
-  maxint = maxint // 2
-end
-
-maxintF = maxint + 0.0   -- float version
-
-assert(math.type(maxintF) == "float" and maxintF >= 2.0^14)
-
--- floats and integers must index the same places
-a[maxintF] = 10; a[maxintF - 1.0] = 11;
-a[-maxintF] = 12; a[-maxintF + 1.0] = 13;
-
-assert(a[maxint] == 10 and a[maxint - 1] == 11 and
-       a[-maxint] == 12 and a[-maxint + 1] == 13)
-
-a[maxint] = 20
-a[-maxint] = 22
-
-assert(a[maxintF] == 20 and a[maxintF - 1.0] == 11 and
-       a[-maxintF] == 22 and a[-maxintF + 1.0] == 13)
-
-a = nil
-
-
--- test conflicts in multiple assignment
-do
-  local a,i,j,b
-  a = {'a', 'b'}; i=1; j=2; b=a
-  i, a[i], a, j, a[j], a[i+j] = j, i, i, b, j, i
-  assert(i == 2 and b[1] == 1 and a == 1 and j == b and b[2] == 2 and
-         b[3] == 1)
-end
-
--- repeat test with upvalues
-do
-  local a,i,j,b
-  a = {'a', 'b'}; i=1; j=2; b=a
-  local function foo ()
-    i, a[i], a, j, a[j], a[i+j] = j, i, i, b, j, i
-  end
-  foo()
-  assert(i == 2 and b[1] == 1 and a == 1 and j == b and b[2] == 2 and
-         b[3] == 1)
-  local t = {}
-  (function (a) t[a], a = 10, 20  end)(1);
-  assert(t[1] == 10)
-end
-
--- bug in 5.2 beta
-local function foo ()
-  local a
-  return function ()
-    local b
-    a, b = 3, 14    -- local and upvalue have same index
-    return a, b
-  end
-end
-
-local a, b = foo()()
-assert(a == 3 and b == 14)
-
-print('OK')
-
-return res
-

testes/big.lua

@@ -1,82 +0,0 @@
--- $Id: big.lua,v 1.32 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-if _soft then
-  return 'a'
-end
-
-print "testing large tables"
-
-local debug = require"debug" 
-
-local lim = 2^18 + 1000
-local prog = { "local y = {0" }
-for i = 1, lim do prog[#prog + 1] = i  end
-prog[#prog + 1] = "}\n"
-prog[#prog + 1] = "X = y\n"
-prog[#prog + 1] = ("assert(X[%d] == %d)"):format(lim - 1, lim - 2)
-prog[#prog + 1] = "return 0"
-prog = table.concat(prog, ";")
-
-local env = {string = string, assert = assert}
-local f = assert(load(prog, nil, nil, env))
-
-f()
-assert(env.X[lim] == lim - 1 and env.X[lim + 1] == lim)
-for k in pairs(env) do env[k] = nil end
-
--- yields during accesses larger than K (in RK)
-setmetatable(env, {
-  __index = function (t, n) coroutine.yield('g'); return _G[n] end,
-  __newindex = function (t, n, v) coroutine.yield('s'); _G[n] = v end,
-})
-
-X = nil
-co = coroutine.wrap(f)
-assert(co() == 's')
-assert(co() == 'g')
-assert(co() == 'g')
-assert(co() == 0)
-
-assert(X[lim] == lim - 1 and X[lim + 1] == lim)
-
--- errors in accesses larger than K (in RK)
-getmetatable(env).__index = function () end
-getmetatable(env).__newindex = function () end
-local e, m = pcall(f)
-assert(not e and m:find("global 'X'"))
-
--- errors in metamethods 
-getmetatable(env).__newindex = function () error("hi") end
-local e, m = xpcall(f, debug.traceback)
-assert(not e and m:find("'__newindex'"))
-
-f, X = nil
-
-coroutine.yield'b'
-
-if 2^32 == 0 then   -- (small integers) {   
-
-print "testing string length overflow"
-
-local repstrings = 192          -- number of strings to be concatenated
-local ssize = math.ceil(2.0^32 / repstrings) + 1   -- size of each string
-
-assert(repstrings * ssize > 2.0^32)  -- it should be larger than maximum size
-
-local longs = string.rep("\0", ssize)   -- create one long string
-
--- create function to concatentate 'repstrings' copies of its argument
-local rep = assert(load(
-  "local a = ...; return " .. string.rep("a", repstrings, "..")))
-
-local a, b = pcall(rep, longs)   -- call that function
-
--- it should fail without creating string (result would be too large)
-assert(not a and string.find(b, "overflow"))
-
-end   -- }
-
-print'OK'
-
-return 'a'

testes/bitwise.lua

@@ -1,328 +0,0 @@
--- $Id: bitwise.lua,v 1.26 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print("testing bitwise operations")
-
-local numbits = string.packsize('j') * 8
-
-assert(~0 == -1)
-
-assert((1 << (numbits - 1)) == math.mininteger)
-
--- basic tests for bitwise operators;
--- use variables to avoid constant folding
-local a, b, c, d
-a = 0xFFFFFFFFFFFFFFFF
-assert(a == -1 and a & -1 == a and a & 35 == 35)
-a = 0xF0F0F0F0F0F0F0F0
-assert(a | -1 == -1)
-assert(a ~ a == 0 and a ~ 0 == a and a ~ ~a == -1)
-assert(a >> 4 == ~a)
-a = 0xF0; b = 0xCC; c = 0xAA; d = 0xFD
-assert(a | b ~ c & d == 0xF4)
-
-a = 0xF0.0; b = 0xCC.0; c = "0xAA.0"; d = "0xFD.0"
-assert(a | b ~ c & d == 0xF4)
-
-a = 0xF0000000; b = 0xCC000000;
-c = 0xAA000000; d = 0xFD000000
-assert(a | b ~ c & d == 0xF4000000)
-assert(~~a == a and ~a == -1 ~ a and -d == ~d + 1)
-
-a = a << 32
-b = b << 32
-c = c << 32
-d = d << 32
-assert(a | b ~ c & d == 0xF4000000 << 32)
-assert(~~a == a and ~a == -1 ~ a and -d == ~d + 1)
-
-assert(-1 >> 1 == (1 << (numbits - 1)) - 1 and 1 << 31 == 0x80000000)
-assert(-1 >> (numbits - 1) == 1)
-assert(-1 >> numbits == 0 and
-       -1 >> -numbits == 0 and
-       -1 << numbits == 0 and
-       -1 << -numbits == 0)
-
-assert((2^30 - 1) << 2^30 == 0)
-assert((2^30 - 1) >> 2^30 == 0)
-
-assert(1 >> -3 == 1 << 3 and 1000 >> 5 == 1000 << -5)
-
-
--- coercion from strings to integers
-assert("0xffffffffffffffff" | 0 == -1)
-assert("0xfffffffffffffffe" & "-1" == -2)
-assert(" \t-0xfffffffffffffffe\n\t" & "-1" == 2)
-assert("   \n  -45  \t " >> "  -2  " == -45 * 4)
-
--- out of range number
-assert(not pcall(function () return "0xffffffffffffffff.0" | 0 end))
-
--- embedded zeros
-assert(not pcall(function () return "0xffffffffffffffff\0" | 0 end))
-
-print'+'
-
-
-package.preload.bit32 = function ()     --{
-
--- no built-in 'bit32' library: implement it using bitwise operators
-
-local bit = {}
-
-function bit.bnot (a)
-  return ~a & 0xFFFFFFFF
-end
-
-
---
--- in all vararg functions, avoid creating 'arg' table when there are
--- only 2 (or less) parameters, as 2 parameters is the common case
---
-
-function bit.band (x, y, z, ...)
-  if not z then
-    return ((x or -1) & (y or -1)) & 0xFFFFFFFF
-  else
-    local arg = {...}
-    local res = x & y & z
-    for i = 1, #arg do res = res & arg[i] end
-    return res & 0xFFFFFFFF
-  end
-end
-
-function bit.bor (x, y, z, ...)
-  if not z then
-    return ((x or 0) | (y or 0)) & 0xFFFFFFFF
-  else
-    local arg = {...}
-    local res = x | y | z
-    for i = 1, #arg do res = res | arg[i] end
-    return res & 0xFFFFFFFF
-  end
-end
-
-function bit.bxor (x, y, z, ...)
-  if not z then
-    return ((x or 0) ~ (y or 0)) & 0xFFFFFFFF
-  else
-    local arg = {...}
-    local res = x ~ y ~ z
-    for i = 1, #arg do res = res ~ arg[i] end
-    return res & 0xFFFFFFFF
-  end
-end
-
-function bit.btest (...)
-  return bit.band(...) ~= 0
-end
-
-function bit.lshift (a, b)
-  return ((a & 0xFFFFFFFF) << b) & 0xFFFFFFFF
-end
-
-function bit.rshift (a, b)
-  return ((a & 0xFFFFFFFF) >> b) & 0xFFFFFFFF
-end
-
-function bit.arshift (a, b)
-  a = a & 0xFFFFFFFF
-  if b <= 0 or (a & 0x80000000) == 0 then
-    return (a >> b) & 0xFFFFFFFF
-  else
-    return ((a >> b) | ~(0xFFFFFFFF >> b)) & 0xFFFFFFFF
-  end
-end
-
-function bit.lrotate (a ,b)
-  b = b & 31
-  a = a & 0xFFFFFFFF
-  a = (a << b) | (a >> (32 - b))
-  return a & 0xFFFFFFFF
-end
-
-function bit.rrotate (a, b)
-  return bit.lrotate(a, -b)
-end
-
-local function checkfield (f, w)
-  w = w or 1
-  assert(f >= 0, "field cannot be negative")
-  assert(w > 0, "width must be positive")
-  assert(f + w <= 32, "trying to access non-existent bits")
-  return f, ~(-1 << w)
-end
-
-function bit.extract (a, f, w)
-  local f, mask = checkfield(f, w)
-  return (a >> f) & mask
-end
-
-function bit.replace (a, v, f, w)
-  local f, mask = checkfield(f, w)
-  v = v & mask
-  a = (a & ~(mask << f)) | (v << f)
-  return a & 0xFFFFFFFF
-end
-
-return bit
-
-end  --}
-
-
-print("testing bitwise library")
-
-local bit32 = require'bit32'
-
-assert(bit32.band() == bit32.bnot(0))
-assert(bit32.btest() == true)
-assert(bit32.bor() == 0)
-assert(bit32.bxor() == 0)
-
-assert(bit32.band() == bit32.band(0xffffffff))
-assert(bit32.band(1,2) == 0)
-
-
--- out-of-range numbers
-assert(bit32.band(-1) == 0xffffffff)
-assert(bit32.band((1 << 33) - 1) == 0xffffffff)
-assert(bit32.band(-(1 << 33) - 1) == 0xffffffff)
-assert(bit32.band((1 << 33) + 1) == 1)
-assert(bit32.band(-(1 << 33) + 1) == 1)
-assert(bit32.band(-(1 << 40)) == 0)
-assert(bit32.band(1 << 40) == 0)
-assert(bit32.band(-(1 << 40) - 2) == 0xfffffffe)
-assert(bit32.band((1 << 40) - 4) == 0xfffffffc)
-
-assert(bit32.lrotate(0, -1) == 0)
-assert(bit32.lrotate(0, 7) == 0)
-assert(bit32.lrotate(0x12345678, 0) == 0x12345678)
-assert(bit32.lrotate(0x12345678, 32) == 0x12345678)
-assert(bit32.lrotate(0x12345678, 4) == 0x23456781)
-assert(bit32.rrotate(0x12345678, -4) == 0x23456781)
-assert(bit32.lrotate(0x12345678, -8) == 0x78123456)
-assert(bit32.rrotate(0x12345678, 8) == 0x78123456)
-assert(bit32.lrotate(0xaaaaaaaa, 2) == 0xaaaaaaaa)
-assert(bit32.lrotate(0xaaaaaaaa, -2) == 0xaaaaaaaa)
-for i = -50, 50 do
-  assert(bit32.lrotate(0x89abcdef, i) == bit32.lrotate(0x89abcdef, i%32))
-end
-
-assert(bit32.lshift(0x12345678, 4) == 0x23456780)
-assert(bit32.lshift(0x12345678, 8) == 0x34567800)
-assert(bit32.lshift(0x12345678, -4) == 0x01234567)
-assert(bit32.lshift(0x12345678, -8) == 0x00123456)
-assert(bit32.lshift(0x12345678, 32) == 0)
-assert(bit32.lshift(0x12345678, -32) == 0)
-assert(bit32.rshift(0x12345678, 4) == 0x01234567)
-assert(bit32.rshift(0x12345678, 8) == 0x00123456)
-assert(bit32.rshift(0x12345678, 32) == 0)
-assert(bit32.rshift(0x12345678, -32) == 0)
-assert(bit32.arshift(0x12345678, 0) == 0x12345678)
-assert(bit32.arshift(0x12345678, 1) == 0x12345678 // 2)
-assert(bit32.arshift(0x12345678, -1) == 0x12345678 * 2)
-assert(bit32.arshift(-1, 1) == 0xffffffff)
-assert(bit32.arshift(-1, 24) == 0xffffffff)
-assert(bit32.arshift(-1, 32) == 0xffffffff)
-assert(bit32.arshift(-1, -1) == bit32.band(-1 * 2, 0xffffffff))
-
-assert(0x12345678 << 4 == 0x123456780)
-assert(0x12345678 << 8 == 0x1234567800)
-assert(0x12345678 << -4 == 0x01234567)
-assert(0x12345678 << -8 == 0x00123456)
-assert(0x12345678 << 32 == 0x1234567800000000)
-assert(0x12345678 << -32 == 0)
-assert(0x12345678 >> 4 == 0x01234567)
-assert(0x12345678 >> 8 == 0x00123456)
-assert(0x12345678 >> 32 == 0)
-assert(0x12345678 >> -32 == 0x1234567800000000)
-
-print("+")
--- some special cases
-local c = {0, 1, 2, 3, 10, 0x80000000, 0xaaaaaaaa, 0x55555555,
-           0xffffffff, 0x7fffffff}
-
-for _, b in pairs(c) do
-  assert(bit32.band(b) == b)
-  assert(bit32.band(b, b) == b)
-  assert(bit32.band(b, b, b, b) == b)
-  assert(bit32.btest(b, b) == (b ~= 0))
-  assert(bit32.band(b, b, b) == b)
-  assert(bit32.band(b, b, b, ~b) == 0)
-  assert(bit32.btest(b, b, b) == (b ~= 0))
-  assert(bit32.band(b, bit32.bnot(b)) == 0)
-  assert(bit32.bor(b, bit32.bnot(b)) == bit32.bnot(0))
-  assert(bit32.bor(b) == b)
-  assert(bit32.bor(b, b) == b)
-  assert(bit32.bor(b, b, b) == b)
-  assert(bit32.bor(b, b, 0, ~b) == 0xffffffff)
-  assert(bit32.bxor(b) == b)
-  assert(bit32.bxor(b, b) == 0)
-  assert(bit32.bxor(b, b, b) == b)
-  assert(bit32.bxor(b, b, b, b) == 0)
-  assert(bit32.bxor(b, 0) == b)
-  assert(bit32.bnot(b) ~= b)
-  assert(bit32.bnot(bit32.bnot(b)) == b)
-  assert(bit32.bnot(b) == (1 << 32) - 1 - b)
-  assert(bit32.lrotate(b, 32) == b)
-  assert(bit32.rrotate(b, 32) == b)
-  assert(bit32.lshift(bit32.lshift(b, -4), 4) == bit32.band(b, bit32.bnot(0xf)))
-  assert(bit32.rshift(bit32.rshift(b, 4), -4) == bit32.band(b, bit32.bnot(0xf)))
-end
-
--- for this test, use at most 24 bits (mantissa of a single float)
-c = {0, 1, 2, 3, 10, 0x800000, 0xaaaaaa, 0x555555, 0xffffff, 0x7fffff}
-for _, b in pairs(c) do
-  for i = -40, 40 do
-    local x = bit32.lshift(b, i)
-    local y = math.floor(math.fmod(b * 2.0^i, 2.0^32))
-    assert(math.fmod(x - y, 2.0^32) == 0)
-  end
-end
-
-assert(not pcall(bit32.band, {}))
-assert(not pcall(bit32.bnot, "a"))
-assert(not pcall(bit32.lshift, 45))
-assert(not pcall(bit32.lshift, 45, print))
-assert(not pcall(bit32.rshift, 45, print))
-
-print("+")
-
-
--- testing extract/replace
-
-assert(bit32.extract(0x12345678, 0, 4) == 8)
-assert(bit32.extract(0x12345678, 4, 4) == 7)
-assert(bit32.extract(0xa0001111, 28, 4) == 0xa)
-assert(bit32.extract(0xa0001111, 31, 1) == 1)
-assert(bit32.extract(0x50000111, 31, 1) == 0)
-assert(bit32.extract(0xf2345679, 0, 32) == 0xf2345679)
-
-assert(not pcall(bit32.extract, 0, -1))
-assert(not pcall(bit32.extract, 0, 32))
-assert(not pcall(bit32.extract, 0, 0, 33))
-assert(not pcall(bit32.extract, 0, 31, 2))
-
-assert(bit32.replace(0x12345678, 5, 28, 4) == 0x52345678)
-assert(bit32.replace(0x12345678, 0x87654321, 0, 32) == 0x87654321)
-assert(bit32.replace(0, 1, 2) == 2^2)
-assert(bit32.replace(0, -1, 4) == 2^4)
-assert(bit32.replace(-1, 0, 31) == (1 << 31) - 1)
-assert(bit32.replace(-1, 0, 1, 2) == (1 << 32) - 7)
-
-
--- testing conversion of floats
-
-assert(bit32.bor(3.0) == 3)
-assert(bit32.bor(-4.0) == 0xfffffffc)
-
--- large floats and large-enough integers?
-if 2.0^50 < 2.0^50 + 1.0 and 2.0^50 < (-1 >> 1) then
-  assert(bit32.bor(2.0^32 - 5.0) == 0xfffffffb)
-  assert(bit32.bor(-2.0^32 - 6.0) == 0xfffffffa)
-  assert(bit32.bor(2.0^48 - 5.0) == 0xfffffffb)
-  assert(bit32.bor(-2.0^48 - 6.0) == 0xfffffffa)
-end
-
-print'OK'
-

testes/bwcoercion.lua

@@ -1,78 +0,0 @@
-local tonumber, tointeger = tonumber, math.tointeger
-local type, getmetatable, rawget, error = type, getmetatable, rawget, error
-local strsub = string.sub
-
-local print = print
-
-_ENV = nil
-
--- Try to convert a value to an integer, without assuming any coercion.
-local function toint (x)
-  x = tonumber(x)   -- handle numerical strings
-  if not x then
-    return false    -- not coercible to a number
-  end
-  return tointeger(x)
-end
-
-
--- If operation fails, maybe second operand has a metamethod that should
--- have been called if not for this string metamethod, so try to
--- call it.
-local function trymt (x, y, mtname)
-  if type(y) ~= "string" then    -- avoid recalling original metamethod
-    local mt = getmetatable(y)
-    local mm = mt and rawget(mt, mtname)
-    if mm then
-      return mm(x, y)
-    end
-  end
-  -- if any test fails, there is no other metamethod to be called
-  error("attempt to '" .. strsub(mtname, 3) ..
-        "' a " .. type(x) .. " with a " .. type(y), 4)
-end
-
-
-local function checkargs (x, y, mtname)
-  local xi = toint(x)
-  local yi = toint(y)
-  if xi and yi then
-    return xi, yi
-  else
-    return trymt(x, y, mtname), nil
-  end
-end
-
-
-local smt = getmetatable("")
-
-smt.__band = function (x, y)
-  local x, y = checkargs(x, y, "__band")
-  return y and x & y or x
-end
-
-smt.__bor = function (x, y)
-  local x, y = checkargs(x, y, "__bor")
-  return y and x | y or x
-end
-
-smt.__bxor = function (x, y)
-  local x, y = checkargs(x, y, "__bxor")
-  return y and x ~ y or x
-end
-
-smt.__shl = function (x, y)
-  local x, y = checkargs(x, y, "__shl")
-  return y and x << y or x
-end
-
-smt.__shr = function (x, y)
-  local x, y = checkargs(x, y, "__shr")
-  return y and x >> y or x
-end
-
-smt.__bnot = function (x)
-  local x, y = checkargs(x, x, "__bnot")
-  return y and ~x or x
-end
-

testes/calls.lua

@@ -1,401 +0,0 @@
--- $Id: calls.lua,v 1.60 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print("testing functions and calls")
-
-local debug = require "debug"
-
--- get the opportunity to test 'type' too ;)
-
-assert(type(1<2) == 'boolean')
-assert(type(true) == 'boolean' and type(false) == 'boolean')
-assert(type(nil) == 'nil'
-   and type(-3) == 'number'
-   and type'x' == 'string'
-   and type{} == 'table'
-   and type(type) == 'function')
-
-assert(type(assert) == type(print))
-function f (x) return a:x (x) end
-assert(type(f) == 'function')
-assert(not pcall(type))
-
-
-do    -- test error in 'print' too...
-  local tostring = _ENV.tostring
-
-  _ENV.tostring = nil
-  local st, msg = pcall(print, 1)
-  assert(st == false and string.find(msg, "attempt to call a nil value"))
-
-  _ENV.tostring = function () return {} end
-  local st, msg = pcall(print, 1)
-  assert(st == false and string.find(msg, "must return a string"))
-  
-  _ENV.tostring = tostring
-end
-
-
--- testing local-function recursion
-fact = false
-do
-  local res = 1
-  local function fact (n)
-    if n==0 then return res
-    else return n*fact(n-1)
-    end
-  end
-  assert(fact(5) == 120)
-end
-assert(fact == false)
-
--- testing declarations
-a = {i = 10}
-self = 20
-function a:x (x) return x+self.i end
-function a.y (x) return x+self end
-
-assert(a:x(1)+10 == a.y(1))
-
-a.t = {i=-100}
-a["t"].x = function (self, a,b) return self.i+a+b end
-
-assert(a.t:x(2,3) == -95)
-
-do
-  local a = {x=0}
-  function a:add (x) self.x, a.y = self.x+x, 20; return self end
-  assert(a:add(10):add(20):add(30).x == 60 and a.y == 20)
-end
-
-local a = {b={c={}}}
-
-function a.b.c.f1 (x) return x+1 end
-function a.b.c:f2 (x,y) self[x] = y end
-assert(a.b.c.f1(4) == 5)
-a.b.c:f2('k', 12); assert(a.b.c.k == 12)
-
-print('+')
-
-t = nil   -- 'declare' t
-function f(a,b,c) local d = 'a'; t={a,b,c,d} end
-
-f(      -- this line change must be valid
-  1,2)
-assert(t[1] == 1 and t[2] == 2 and t[3] == nil and t[4] == 'a')
-f(1,2,   -- this one too
-      3,4)
-assert(t[1] == 1 and t[2] == 2 and t[3] == 3 and t[4] == 'a')
-
-function fat(x)
-  if x <= 1 then return 1
-  else return x*load("return fat(" .. x-1 .. ")", "")()
-  end
-end
-
-assert(load "load 'assert(fat(6)==720)' () ")()
-a = load('return fat(5), 3')
-a,b = a()
-assert(a == 120 and b == 3)
-print('+')
-
-function err_on_n (n)
-  if n==0 then error(); exit(1);
-  else err_on_n (n-1); exit(1);
-  end
-end
-
-do
-  function dummy (n)
-    if n > 0 then
-      assert(not pcall(err_on_n, n))
-      dummy(n-1)
-    end
-  end
-end
-
-dummy(10)
-
-function deep (n)
-  if n>0 then deep(n-1) end
-end
-deep(10)
-deep(200)
-
--- testing tail call
-function deep (n) if n>0 then return deep(n-1) else return 101 end end
-assert(deep(30000) == 101)
-a = {}
-function a:deep (n) if n>0 then return self:deep(n-1) else return 101 end end
-assert(a:deep(30000) == 101)
-
-print('+')
-
-
-a = nil
-(function (x) a=x end)(23)
-assert(a == 23 and (function (x) return x*2 end)(20) == 40)
-
-
--- testing closures
-
--- fixed-point operator
-Z = function (le)
-      local function a (f)
-        return le(function (x) return f(f)(x) end)
-      end
-      return a(a)
-    end
-
-
--- non-recursive factorial
-
-F = function (f)
-      return function (n)
-               if n == 0 then return 1
-               else return n*f(n-1) end
-             end
-    end
-
-fat = Z(F)
-
-assert(fat(0) == 1 and fat(4) == 24 and Z(F)(5)==5*Z(F)(4))
-
-local function g (z)
-  local function f (a,b,c,d)
-    return function (x,y) return a+b+c+d+a+x+y+z end
-  end
-  return f(z,z+1,z+2,z+3)
-end
-
-f = g(10)
-assert(f(9, 16) == 10+11+12+13+10+9+16+10)
-
-Z, F, f = nil
-print('+')
-
--- testing multiple returns
-
-function unlpack (t, i)
-  i = i or 1
-  if (i <= #t) then
-    return t[i], unlpack(t, i+1)
-  end
-end
-
-function equaltab (t1, t2)
-  assert(#t1 == #t2)
-  for i = 1, #t1 do
-    assert(t1[i] == t2[i])
-  end
-end
-
-local pack = function (...) return (table.pack(...)) end
-
-function f() return 1,2,30,4 end
-function ret2 (a,b) return a,b end
-
-local a,b,c,d = unlpack{1,2,3}
-assert(a==1 and b==2 and c==3 and d==nil)
-a = {1,2,3,4,false,10,'alo',false,assert}
-equaltab(pack(unlpack(a)), a)
-equaltab(pack(unlpack(a), -1), {1,-1})
-a,b,c,d = ret2(f()), ret2(f())
-assert(a==1 and b==1 and c==2 and d==nil)
-a,b,c,d = unlpack(pack(ret2(f()), ret2(f())))
-assert(a==1 and b==1 and c==2 and d==nil)
-a,b,c,d = unlpack(pack(ret2(f()), (ret2(f()))))
-assert(a==1 and b==1 and c==nil and d==nil)
-
-a = ret2{ unlpack{1,2,3}, unlpack{3,2,1}, unlpack{"a", "b"}}
-assert(a[1] == 1 and a[2] == 3 and a[3] == "a" and a[4] == "b")
-
-
--- testing calls with 'incorrect' arguments
-rawget({}, "x", 1)
-rawset({}, "x", 1, 2)
-assert(math.sin(1,2) == math.sin(1))
-table.sort({10,9,8,4,19,23,0,0}, function (a,b) return a<b end, "extra arg")
-
-
--- test for generic load
-local x = "-- a comment\0\0\0\n  x = 10 + \n23; \
-     local a = function () x = 'hi' end; \
-     return '\0'"
-function read1 (x)
-  local i = 0
-  return function ()
-    collectgarbage()
-    i=i+1
-    return string.sub(x, i, i)
-  end
-end
-
-function cannotload (msg, a,b)
-  assert(not a and string.find(b, msg))
-end
-
-a = assert(load(read1(x), "modname", "t", _G))
-assert(a() == "\0" and _G.x == 33)
-assert(debug.getinfo(a).source == "modname")
--- cannot read text in binary mode
-cannotload("attempt to load a text chunk", load(read1(x), "modname", "b", {}))
-cannotload("attempt to load a text chunk", load(x, "modname", "b"))
-
-a = assert(load(function () return nil end))
-a()  -- empty chunk
-
-assert(not load(function () return true end))
-
-
--- small bug
-local t = {nil, "return ", "3"}
-f, msg = load(function () return table.remove(t, 1) end)
-assert(f() == nil)   -- should read the empty chunk
-
--- another small bug (in 5.2.1)
-f = load(string.dump(function () return 1 end), nil, "b", {})
-assert(type(f) == "function" and f() == 1)
-
-
-x = string.dump(load("x = 1; return x"))
-a = assert(load(read1(x), nil, "b"))
-assert(a() == 1 and _G.x == 1)
-cannotload("attempt to load a binary chunk", load(read1(x), nil, "t"))
-cannotload("attempt to load a binary chunk", load(x, nil, "t"))
-
-assert(not pcall(string.dump, print))  -- no dump of C functions
-
-cannotload("unexpected symbol", load(read1("*a = 123")))
-cannotload("unexpected symbol", load("*a = 123"))
-cannotload("hhi", load(function () error("hhi") end))
-
--- any value is valid for _ENV
-assert(load("return _ENV", nil, nil, 123)() == 123)
-
-
--- load when _ENV is not first upvalue
-local x; XX = 123
-local function h ()
-  local y=x   -- use 'x', so that it becomes 1st upvalue
-  return XX   -- global name
-end
-local d = string.dump(h)
-x = load(d, "", "b")
-assert(debug.getupvalue(x, 2) == '_ENV')
-debug.setupvalue(x, 2, _G)
-assert(x() == 123)
-
-assert(assert(load("return XX + ...", nil, nil, {XX = 13}))(4) == 17)
-
-
--- test generic load with nested functions
-x = [[
-  return function (x)
-    return function (y)
-     return function (z)
-       return x+y+z
-     end
-   end
-  end
-]]
-
-a = assert(load(read1(x)))
-assert(a()(2)(3)(10) == 15)
-
-
--- test for dump/undump with upvalues
-local a, b = 20, 30
-x = load(string.dump(function (x)
-  if x == "set" then a = 10+b; b = b+1 else
-  return a
-  end
-end), "", "b", nil)
-assert(x() == nil)
-assert(debug.setupvalue(x, 1, "hi") == "a")
-assert(x() == "hi")
-assert(debug.setupvalue(x, 2, 13) == "b")
-assert(not debug.setupvalue(x, 3, 10))   -- only 2 upvalues
-x("set")
-assert(x() == 23)
-x("set")
-assert(x() == 24)
-
--- test for dump/undump with many upvalues
-do
-  local nup = 200    -- maximum number of local variables
-  local prog = {"local a1"}
-  for i = 2, nup do prog[#prog + 1] = ", a" .. i end
-  prog[#prog + 1] = " = 1"
-  for i = 2, nup do prog[#prog + 1] = ", " .. i end
-  local sum = 1
-  prog[#prog + 1] = "; return function () return a1"
-  for i = 2, nup do prog[#prog + 1] = " + a" .. i; sum = sum + i end
-  prog[#prog + 1] = " end"
-  prog = table.concat(prog)
-  local f = assert(load(prog))()
-  assert(f() == sum)
-
-  f = load(string.dump(f))   -- main chunk now has many upvalues
-  local a = 10
-  local h = function () return a end
-  for i = 1, nup do
-    debug.upvaluejoin(f, i, h, 1)
-  end
-  assert(f() == 10 * nup)
-end
-
--- test for long method names
-do
-  local t = {x = 1}
-  function t:_012345678901234567890123456789012345678901234567890123456789 ()
-    return self.x
-  end
-  assert(t:_012345678901234567890123456789012345678901234567890123456789() == 1)
-end
-
-
--- test for bug in parameter adjustment
-assert((function () return nil end)(4) == nil)
-assert((function () local a; return a end)(4) == nil)
-assert((function (a) return a end)() == nil)
-
-
-print("testing binary chunks")
-do
-  local header = string.pack("c4BBc6BBBBBj",
-    "\27Lua",                -- signature
-    5*16 + 3,                -- version 5.3
-    0,                       -- format
-    "\x19\x93\r\n\x1a\n",    -- data
-    string.packsize("i"),    -- sizeof(int)
-    string.packsize("T"),    -- sizeof(size_t)
-    4,                       -- size of instruction
-    string.packsize("j"),    -- sizeof(lua integer)
-    string.packsize("n"),    -- sizeof(lua number)
-    0x5678                   -- LUAC_INT
-    -- LUAC_NUM may not have a unique binary representation (padding...)
-  )
-  local c = string.dump(function () local a = 1; local b = 3; return a+b*3 end)
-
-  assert(string.sub(c, 1, #header) == header)
-
-  -- corrupted header
-  for i = 1, #header do
-    local s = string.sub(c, 1, i - 1) ..
-              string.char(string.byte(string.sub(c, i, i)) + 1) ..
-              string.sub(c, i + 1, -1)
-    assert(#s == #c)
-    assert(not load(s))
-  end
-
-  -- loading truncated binary chunks
-  for i = 1, #c - 1 do
-    local st, msg = load(string.sub(c, 1, i))
-    assert(not st and string.find(msg, "truncated"))
-  end
-  assert(assert(load(c))() == 10)
-end
-
-print('OK')
-return deep

testes/closure.lua

@@ -1,247 +0,0 @@
--- $Id: closure.lua,v 1.59 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print "testing closures"
-
-local A,B = 0,{g=10}
-function f(x)
-  local a = {}
-  for i=1,1000 do
-    local y = 0
-    do
-      a[i] = function () B.g = B.g+1; y = y+x; return y+A end
-    end
-  end
-  local dummy = function () return a[A] end
-  collectgarbage()
-  A = 1; assert(dummy() == a[1]); A = 0;
-  assert(a[1]() == x)
-  assert(a[3]() == x)
-  collectgarbage()
-  assert(B.g == 12)
-  return a
-end
-
-local a = f(10)
--- force a GC in this level
-local x = {[1] = {}}   -- to detect a GC
-setmetatable(x, {__mode = 'kv'})
-while x[1] do   -- repeat until GC
-  local a = A..A..A..A  -- create garbage
-  A = A+1
-end
-assert(a[1]() == 20+A)
-assert(a[1]() == 30+A)
-assert(a[2]() == 10+A)
-collectgarbage()
-assert(a[2]() == 20+A)
-assert(a[2]() == 30+A)
-assert(a[3]() == 20+A)
-assert(a[8]() == 10+A)
-assert(getmetatable(x).__mode == 'kv')
-assert(B.g == 19)
-
-
--- testing equality
-a = {}
-for i = 1, 5 do  a[i] = function (x) return x + a + _ENV end  end
-assert(a[3] == a[4] and a[4] == a[5])
-
-for i = 1, 5 do  a[i] = function (x) return i + a + _ENV end  end
-assert(a[3] ~= a[4] and a[4] ~= a[5])
-
-local function f()
-  return function (x)  return math.sin(_ENV[x])  end
-end
-assert(f() == f())
-
-
--- testing closures with 'for' control variable
-a = {}
-for i=1,10 do
-  a[i] = {set = function(x) i=x end, get = function () return i end}
-  if i == 3 then break end
-end
-assert(a[4] == nil)
-a[1].set(10)
-assert(a[2].get() == 2)
-a[2].set('a')
-assert(a[3].get() == 3)
-assert(a[2].get() == 'a')
-
-a = {}
-local t = {"a", "b"}
-for i = 1, #t do
-  local k = t[i]
-  a[i] = {set = function(x, y) i=x; k=y end,
-          get = function () return i, k end}
-  if i == 2 then break end
-end
-a[1].set(10, 20)
-local r,s = a[2].get()
-assert(r == 2 and s == 'b')
-r,s = a[1].get()
-assert(r == 10 and s == 20)
-a[2].set('a', 'b')
-r,s = a[2].get()
-assert(r == "a" and s == "b")
-
-
--- testing closures with 'for' control variable x break
-for i=1,3 do
-  f = function () return i end
-  break
-end
-assert(f() == 1)
-
-for k = 1, #t do
-  local v = t[k]
-  f = function () return k, v end
-  break
-end
-assert(({f()})[1] == 1)
-assert(({f()})[2] == "a")
-
-
--- testing closure x break x return x errors
-
-local b
-function f(x)
-  local first = 1
-  while 1 do
-    if x == 3 and not first then return end
-    local a = 'xuxu'
-    b = function (op, y)
-          if op == 'set' then
-            a = x+y
-          else
-            return a
-          end
-        end
-    if x == 1 then do break end
-    elseif x == 2 then return
-    else if x ~= 3 then error() end
-    end
-    first = nil
-  end
-end
-
-for i=1,3 do
-  f(i)
-  assert(b('get') == 'xuxu')
-  b('set', 10); assert(b('get') == 10+i)
-  b = nil
-end
-
-pcall(f, 4);
-assert(b('get') == 'xuxu')
-b('set', 10); assert(b('get') == 14)
-
-
-local w
--- testing multi-level closure
-function f(x)
-  return function (y)
-    return function (z) return w+x+y+z end
-  end
-end
-
-y = f(10)
-w = 1.345
-assert(y(20)(30) == 60+w)
-
--- testing closures x repeat-until
-
-local a = {}
-local i = 1
-repeat
-  local x = i
-  a[i] = function () i = x+1; return x end
-until i > 10 or a[i]() ~= x
-assert(i == 11 and a[1]() == 1 and a[3]() == 3 and i == 4)
-
-
--- testing closures created in 'then' and 'else' parts of 'if's
-a = {}
-for i = 1, 10 do
-  if i % 3 == 0 then
-    local y = 0
-    a[i] = function (x) local t = y; y = x; return t end
-  elseif i % 3 == 1 then
-    goto L1
-    error'not here'
-  ::L1::
-    local y = 1
-    a[i] = function (x) local t = y; y = x; return t end
-  elseif i % 3 == 2 then
-    local t
-    goto l4
-    ::l4a:: a[i] = t; goto l4b
-    error("should never be here!")
-    ::l4::
-    local y = 2
-    t = function (x) local t = y; y = x; return t end
-    goto l4a
-    error("should never be here!")
-    ::l4b::
-  end
-end
-
-for i = 1, 10 do
-  assert(a[i](i * 10) == i % 3 and a[i]() == i * 10)
-end
-
-print'+'
-
-
--- test for correctly closing upvalues in tail calls of vararg functions
-local function t ()
-  local function c(a,b) assert(a=="test" and b=="OK") end
-  local function v(f, ...) c("test", f() ~= 1 and "FAILED" or "OK") end
-  local x = 1
-  return v(function() return x end)
-end
-t()
-
-
--- test for debug manipulation of upvalues
-local debug = require'debug'
-
-do
-  local a , b, c = 3, 5, 7
-  foo1 = function () return a+b end;
-  foo2 = function () return b+a end;
-  do
-    local a = 10
-    foo3 = function () return a+b end;
-  end
-end
-
-assert(debug.upvalueid(foo1, 1))
-assert(debug.upvalueid(foo1, 2))
-assert(not pcall(debug.upvalueid, foo1, 3))
-assert(debug.upvalueid(foo1, 1) == debug.upvalueid(foo2, 2))
-assert(debug.upvalueid(foo1, 2) == debug.upvalueid(foo2, 1))
-assert(debug.upvalueid(foo3, 1))
-assert(debug.upvalueid(foo1, 1) ~= debug.upvalueid(foo3, 1))
-assert(debug.upvalueid(foo1, 2) == debug.upvalueid(foo3, 2))
-
-assert(debug.upvalueid(string.gmatch("x", "x"), 1) ~= nil)
-
-assert(foo1() == 3 + 5 and foo2() == 5 + 3)
-debug.upvaluejoin(foo1, 2, foo2, 2)
-assert(foo1() == 3 + 3 and foo2() == 5 + 3)
-assert(foo3() == 10 + 5)
-debug.upvaluejoin(foo3, 2, foo2, 1)
-assert(foo3() == 10 + 5)
-debug.upvaluejoin(foo3, 2, foo2, 2)
-assert(foo3() == 10 + 3)
-
-assert(not pcall(debug.upvaluejoin, foo1, 3, foo2, 1))
-assert(not pcall(debug.upvaluejoin, foo1, 1, foo2, 3))
-assert(not pcall(debug.upvaluejoin, foo1, 0, foo2, 1))
-assert(not pcall(debug.upvaluejoin, print, 1, foo2, 1))
-assert(not pcall(debug.upvaluejoin, {}, 1, foo2, 1))
-assert(not pcall(debug.upvaluejoin, foo1, 1, print, 1))
-
-print'OK'

testes/code.lua

@@ -1,239 +0,0 @@
--- $Id: code.lua,v 1.42 2016/11/07 13:04:32 roberto Exp $
--- See Copyright Notice in file all.lua
-
-if T==nil then
-  (Message or print)('\n >>> testC not active: skipping opcode tests <<<\n')
-  return
-end
-print "testing code generation and optimizations"
-
-
--- this code gave an error for the code checker
-do
-  local function f (a)
-  for k,v,w in a do end
-  end
-end
-
-
--- testing reuse in constant table
-local function checkKlist (func, list)
-  local k = T.listk(func)
-  assert(#k == #list)
-  for i = 1, #k do
-    assert(k[i] == list[i] and math.type(k[i]) == math.type(list[i]))
-  end
-end
-
-local function foo ()
-  local a
-  a = 3;
-  a = 0; a = 0.0; a = -7 + 7
-  a = 3.78/4; a = 3.78/4
-  a = -3.78/4; a = 3.78/4; a = -3.78/4
-  a = -3.79/4; a = 0.0; a = -0;
-  a = 3; a = 3.0; a = 3; a = 3.0
-end
-
-checkKlist(foo, {3, 0, 0.0, 3.78/4, -3.78/4, -3.79/4, 3.0})
-
-
--- testing opcodes
-
-function check (f, ...)
-  local arg = {...}
-  local c = T.listcode(f)
-  for i=1, #arg do
-    -- print(arg[i], c[i])
-    assert(string.find(c[i], '- '..arg[i]..' *%d'))
-  end
-  assert(c[#arg+2] == nil)
-end
-
-
-function checkequal (a, b)
-  a = T.listcode(a)
-  b = T.listcode(b)
-  for i = 1, #a do
-    a[i] = string.gsub(a[i], '%b()', '')   -- remove line number
-    b[i] = string.gsub(b[i], '%b()', '')   -- remove line number
-    assert(a[i] == b[i])
-  end
-end
-
-
--- some basic instructions
-check(function ()
-  (function () end){f()}
-end, 'CLOSURE', 'NEWTABLE', 'GETTABUP', 'CALL', 'SETLIST', 'CALL', 'RETURN')
-
-
--- sequence of LOADNILs
-check(function ()
-  local a,b,c
-  local d; local e;
-  local f,g,h;
-  d = nil; d=nil; b=nil; a=nil; c=nil;
-end, 'LOADNIL', 'RETURN')
-
-check(function ()
-  local a,b,c,d = 1,1,1,1
-  d=nil;c=nil;b=nil;a=nil
-end, 'LOADK', 'LOADK', 'LOADK', 'LOADK', 'LOADNIL', 'RETURN')
-
-do
-  local a,b,c,d = 1,1,1,1
-  d=nil;c=nil;b=nil;a=nil
-  assert(a == nil and b == nil and c == nil and d == nil)
-end
-
-
--- single return
-check (function (a,b,c) return a end, 'RETURN')
-
-
--- infinite loops
-check(function () while true do local a = -1 end end,
-'LOADK', 'JMP', 'RETURN')
-
-check(function () while 1 do local a = -1 end end,
-'LOADK', 'JMP', 'RETURN')
-
-check(function () repeat local x = 1 until true end,
-'LOADK', 'RETURN')
-
-
--- concat optimization
-check(function (a,b,c,d) return a..b..c..d end,
-  'MOVE', 'MOVE', 'MOVE', 'MOVE', 'CONCAT', 'RETURN')
-
--- not
-check(function () return not not nil end, 'LOADBOOL', 'RETURN')
-check(function () return not not false end, 'LOADBOOL', 'RETURN')
-check(function () return not not true end, 'LOADBOOL', 'RETURN')
-check(function () return not not 1 end, 'LOADBOOL', 'RETURN')
-
--- direct access to locals
-check(function ()
-  local a,b,c,d
-  a = b*2
-  c[2], a[b] = -((a + d/2 - a[b]) ^ a.x), b
-end,
-  'LOADNIL',
-  'MUL',
-  'DIV', 'ADD', 'GETTABLE', 'SUB', 'GETTABLE', 'POW',
-    'UNM', 'SETTABLE', 'SETTABLE', 'RETURN')
-
-
--- direct access to constants
-check(function ()
-  local a,b
-  a.x = 3.2
-  a.x = b
-  a[b] = 'x'
-end,
-  'LOADNIL', 'SETTABLE', 'SETTABLE', 'SETTABLE', 'RETURN')
-
-check(function ()
-  local a,b
-  a = 1 - a
-  b = 1/a
-  b = 5-4
-end,
-  'LOADNIL', 'SUB', 'DIV', 'LOADK', 'RETURN')
-
-check(function ()
-  local a,b
-  a[true] = false
-end,
-  'LOADNIL', 'SETTABLE', 'RETURN')
-
-
--- constant folding
-local function checkK (func, val)
-  check(func, 'LOADK', 'RETURN')
-  local k = T.listk(func)
-  assert(#k == 1 and k[1] == val and math.type(k[1]) == math.type(val))
-  assert(func() == val)
-end
-checkK(function () return 0.0 end, 0.0)
-checkK(function () return 0 end, 0)
-checkK(function () return -0//1 end, 0)
-checkK(function () return 3^-1 end, 1/3)
-checkK(function () return (1 + 1)^(50 + 50) end, 2^100)
-checkK(function () return (-2)^(31 - 2) end, -0x20000000 + 0.0)
-checkK(function () return (-3^0 + 5) // 3.0 end, 1.0)
-checkK(function () return -3 % 5 end, 2)
-checkK(function () return -((2.0^8 + -(-1)) % 8)/2 * 4 - 3 end, -5.0)
-checkK(function () return -((2^8 + -(-1)) % 8)//2 * 4 - 3 end, -7.0)
-checkK(function () return 0xF0.0 | 0xCC.0 ~ 0xAA & 0xFD end, 0xF4)
-checkK(function () return ~(~0xFF0 | 0xFF0) end, 0)
-checkK(function () return ~~-100024.0 end, -100024)
-checkK(function () return ((100 << 6) << -4) >> 2 end, 100)
-
-
--- no foldings
-check(function () return -0.0 end, 'LOADK', 'UNM', 'RETURN')
-check(function () return 3/0 end, 'DIV', 'RETURN')
-check(function () return 0%0 end, 'MOD', 'RETURN')
-check(function () return -4//0 end, 'IDIV', 'RETURN')
-
--- bug in constant folding for 5.1
-check(function () return -nil end, 'LOADNIL', 'UNM', 'RETURN')
-
-
-check(function ()
-  local a,b,c
-  b[c], a = c, b
-  b[a], a = c, b
-  a, b = c, a
-  a = a
-end, 
-  'LOADNIL',
-  'MOVE', 'MOVE', 'SETTABLE',
-  'MOVE', 'MOVE', 'MOVE', 'SETTABLE',
-  'MOVE', 'MOVE', 'MOVE',
-  -- no code for a = a
-  'RETURN')
-
-
--- x == nil , x ~= nil
-checkequal(function () if (a==nil) then a=1 end; if a~=nil then a=1 end end,
-           function () if (a==9) then a=1 end; if a~=9 then a=1 end end)
-
-check(function () if a==nil then a='a' end end,
-'GETTABUP', 'EQ', 'JMP', 'SETTABUP', 'RETURN')
-
--- de morgan
-checkequal(function () local a; if not (a or b) then b=a end end,
-           function () local a; if (not a and not b) then b=a end end)
-
-checkequal(function (l) local a; return 0 <= a and a <= l end,
-           function (l) local a; return not (not(a >= 0) or not(a <= l)) end)
-
-
--- if-goto optimizations
-check(function (a, b, c, d, e)
-        if a == b then goto l1
-        elseif a == c then goto l2
-        elseif a == d then goto l2
-        else if a == e then goto l3
-             else goto l3
-             end
-        end
-        ::l1:: ::l2:: ::l3:: ::l4:: 
-end, 'EQ', 'JMP', 'EQ', 'JMP', 'EQ', 'JMP', 'EQ', 'JMP', 'JMP', 'RETURN')
-
-checkequal(
-function (a) while a < 10 do a = a + 1 end end,
-function (a) ::L2:: if not(a < 10) then goto L1 end; a = a + 1;
-                goto L2; ::L1:: end
-)
-
-checkequal(
-function (a) while a < 10 do a = a + 1 end end,
-function (a) while true do if not(a < 10) then break end; a = a + 1; end end
-)
-
-print 'OK'
-

testes/constructs.lua

@@ -1,313 +0,0 @@
--- $Id: constructs.lua,v 1.41 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-;;print "testing syntax";;
-
-local debug = require "debug"
-
-
-local function checkload (s, msg)
-  assert(string.find(select(2, load(s)), msg))
-end
-
--- testing semicollons
-do ;;; end
-; do ; a = 3; assert(a == 3) end;
-;
-
-
--- invalid operations should not raise errors when not executed
-if false then a = 3 // 0; a = 0 % 0 end
-
-
--- testing priorities
-
-assert(2^3^2 == 2^(3^2));
-assert(2^3*4 == (2^3)*4);
-assert(2.0^-2 == 1/4 and -2^- -2 == - - -4);
-assert(not nil and 2 and not(2>3 or 3<2));
-assert(-3-1-5 == 0+0-9);
-assert(-2^2 == -4 and (-2)^2 == 4 and 2*2-3-1 == 0);
-assert(-3%5 == 2 and -3+5 == 2)
-assert(2*1+3/3 == 3 and 1+2 .. 3*1 == "33");
-assert(not(2+1 > 3*1) and "a".."b" > "a");
-
-assert("7" .. 3 << 1 == 146)
-assert(10 >> 1 .. "9" == 0)
-assert(10 | 1 .. "9" == 27)
-
-assert(0xF0 | 0xCC ~ 0xAA & 0xFD == 0xF4)
-assert(0xFD & 0xAA ~ 0xCC | 0xF0 == 0xF4)
-assert(0xF0 & 0x0F + 1 == 0x10)
-
-assert(3^4//2^3//5 == 2)
-
-assert(-3+4*5//2^3^2//9+4%10/3 == (-3)+(((4*5)//(2^(3^2)))//9)+((4%10)/3))
-
-assert(not ((true or false) and nil))
-assert(      true or false  and nil)
-
--- old bug
-assert((((1 or false) and true) or false) == true)
-assert((((nil and true) or false) and true) == false)
-
-local a,b = 1,nil;
-assert(-(1 or 2) == -1 and (1 and 2)+(-1.25 or -4) == 0.75);
-x = ((b or a)+1 == 2 and (10 or a)+1 == 11); assert(x);
-x = (((2<3) or 1) == true and (2<3 and 4) == 4); assert(x);
-
-x,y=1,2;
-assert((x>y) and x or y == 2);
-x,y=2,1;
-assert((x>y) and x or y == 2);
-
-assert(1234567890 == tonumber('1234567890') and 1234567890+1 == 1234567891)
-
-
--- silly loops
-repeat until 1; repeat until true;
-while false do end; while nil do end;
-
-do  -- test old bug (first name could not be an `upvalue')
- local a; function f(x) x={a=1}; x={x=1}; x={G=1} end
-end
-
-function f (i)
-  if type(i) ~= 'number' then return i,'jojo'; end;
-  if i > 0 then return i, f(i-1); end;
-end
-
-x = {f(3), f(5), f(10);};
-assert(x[1] == 3 and x[2] == 5 and x[3] == 10 and x[4] == 9 and x[12] == 1);
-assert(x[nil] == nil)
-x = {f'alo', f'xixi', nil};
-assert(x[1] == 'alo' and x[2] == 'xixi' and x[3] == nil);
-x = {f'alo'..'xixi'};
-assert(x[1] == 'aloxixi')
-x = {f{}}
-assert(x[2] == 'jojo' and type(x[1]) == 'table')
-
-
-local f = function (i)
-  if i < 10 then return 'a';
-  elseif i < 20 then return 'b';
-  elseif i < 30 then return 'c';
-  end;
-end
-
-assert(f(3) == 'a' and f(12) == 'b' and f(26) == 'c' and f(100) == nil)
-
-for i=1,1000 do break; end;
-n=100;
-i=3;
-t = {};
-a=nil
-while not a do
-  a=0; for i=1,n do for i=i,1,-1 do a=a+1; t[i]=1; end; end;
-end
-assert(a == n*(n+1)/2 and i==3);
-assert(t[1] and t[n] and not t[0] and not t[n+1])
-
-function f(b)
-  local x = 1;
-  repeat
-    local a;
-    if b==1 then local b=1; x=10; break
-    elseif b==2 then x=20; break;
-    elseif b==3 then x=30;
-    else local a,b,c,d=math.sin(1); x=x+1;
-    end
-  until x>=12;
-  return x;
-end;
-
-assert(f(1) == 10 and f(2) == 20 and f(3) == 30 and f(4)==12)
-
-
-local f = function (i)
-  if i < 10 then return 'a'
-  elseif i < 20 then return 'b'
-  elseif i < 30 then return 'c'
-  else return 8
-  end
-end
-
-assert(f(3) == 'a' and f(12) == 'b' and f(26) == 'c' and f(100) == 8)
-
-local a, b = nil, 23
-x = {f(100)*2+3 or a, a or b+2}
-assert(x[1] == 19 and x[2] == 25)
-x = {f=2+3 or a, a = b+2}
-assert(x.f == 5 and x.a == 25)
-
-a={y=1}
-x = {a.y}
-assert(x[1] == 1)
-
-function f(i)
-  while 1 do
-    if i>0 then i=i-1;
-    else return; end;
-  end;
-end;
-
-function g(i)
-  while 1 do
-    if i>0 then i=i-1
-    else return end
-  end
-end
-
-f(10); g(10);
-
-do
-  function f () return 1,2,3; end
-  local a, b, c = f();
-  assert(a==1 and b==2 and c==3)
-  a, b, c = (f());
-  assert(a==1 and b==nil and c==nil)
-end
-
-local a,b = 3 and f();
-assert(a==1 and b==nil)
-
-function g() f(); return; end;
-assert(g() == nil)
-function g() return nil or f() end
-a,b = g()
-assert(a==1 and b==nil)
-
-print'+';
-
-
-f = [[
-return function ( a , b , c , d , e )
-  local x = a >= b or c or ( d and e ) or nil
-  return x
-end , { a = 1 , b = 2 >= 1 , } or { 1 };
-]]
-f = string.gsub(f, "%s+", "\n");   -- force a SETLINE between opcodes
-f,a = load(f)();
-assert(a.a == 1 and a.b)
-
-function g (a,b,c,d,e)
-  if not (a>=b or c or d and e or nil) then return 0; else return 1; end;
-end
-
-function h (a,b,c,d,e)
-  while (a>=b or c or (d and e) or nil) do return 1; end;
-  return 0;
-end;
-
-assert(f(2,1) == true and g(2,1) == 1 and h(2,1) == 1)
-assert(f(1,2,'a') == 'a' and g(1,2,'a') == 1 and h(1,2,'a') == 1)
-assert(f(1,2,'a')
-~=          -- force SETLINE before nil
-nil, "")
-assert(f(1,2,'a') == 'a' and g(1,2,'a') == 1 and h(1,2,'a') == 1)
-assert(f(1,2,nil,1,'x') == 'x' and g(1,2,nil,1,'x') == 1 and
-                                   h(1,2,nil,1,'x') == 1)
-assert(f(1,2,nil,nil,'x') == nil and g(1,2,nil,nil,'x') == 0 and
-                                     h(1,2,nil,nil,'x') == 0)
-assert(f(1,2,nil,1,nil) == nil and g(1,2,nil,1,nil) == 0 and
-                                   h(1,2,nil,1,nil) == 0)
-
-assert(1 and 2<3 == true and 2<3 and 'a'<'b' == true)
-x = 2<3 and not 3; assert(x==false)
-x = 2<1 or (2>1 and 'a'); assert(x=='a')
-
-
-do
-  local a; if nil then a=1; else a=2; end;    -- this nil comes as PUSHNIL 2
-  assert(a==2)
-end
-
-function F(a)
-  assert(debug.getinfo(1, "n").name == 'F')
-  return a,2,3
-end
-
-a,b = F(1)~=nil; assert(a == true and b == nil);
-a,b = F(nil)==nil; assert(a == true and b == nil)
-
-----------------------------------------------------------------
-------------------------------------------------------------------
-
--- sometimes will be 0, sometimes will not...
-_ENV.GLOB1 = math.floor(os.time()) % 2
-
--- basic expressions with their respective values
-local basiccases = {
-  {"nil", nil},
-  {"false", false},
-  {"true", true},
-  {"10", 10},
-  {"(0==_ENV.GLOB1)", 0 == _ENV.GLOB1},
-}
-
-print('testing short-circuit optimizations (' .. _ENV.GLOB1 .. ')')
-
-
--- operators with their respective values
-local binops = {
-  {" and ", function (a,b) if not a then return a else return b end end},
-  {" or ", function (a,b) if a then return a else return b end end},
-}
-
-local cases = {}
-
--- creates all combinations of '(cases[i] op cases[n-i])' plus
--- 'not(cases[i] op cases[n-i])' (syntax + value)
-local function createcases (n)
-  local res = {}
-  for i = 1, n - 1 do
-    for _, v1 in ipairs(cases[i]) do
-      for _, v2 in ipairs(cases[n - i]) do
-        for _, op in ipairs(binops) do
-            local t = {
-              "(" .. v1[1] .. op[1] .. v2[1] .. ")",
-              op[2](v1[2], v2[2])
-            }
-            res[#res + 1] = t
-            res[#res + 1] = {"not" .. t[1], not t[2]}
-        end
-      end
-    end
-  end
-  return res
-end
-
--- do not do too many combinations for soft tests
-local level = _soft and 3 or 4
-
-cases[1] = basiccases
-for i = 2, level do cases[i] = createcases(i) end
-print("+")
-
-local prog = [[if %s then IX = true end; return %s]]
-
-local i = 0
-for n = 1, level do
-  for _, v in pairs(cases[n]) do
-    local s = v[1]
-    local p = load(string.format(prog, s, s), "")
-    IX = false
-    assert(p() == v[2] and IX == not not v[2])
-    i = i + 1
-    if i % 60000 == 0 then print('+') end
-  end
-end
-------------------------------------------------------------------
-
--- testing some syntax errors (chosen through 'gcov')
-checkload("for x do", "expected")
-checkload("x:call", "expected")
-
-if not _soft then
-  -- control structure too long
-  local s = string.rep("a = a + 1\n", 2^18)
-  s = "while true do " .. s .. "end"
-  checkload(s, "too long")
-end
-
-print'OK'

testes/coroutine.lua

@@ -1,874 +0,0 @@
--- $Id: coroutine.lua,v 1.42 2016/11/07 13:03:20 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print "testing coroutines"
-
-local debug = require'debug'
-
-local f
-
-local main, ismain = coroutine.running()
-assert(type(main) == "thread" and ismain)
-assert(not coroutine.resume(main))
-assert(not coroutine.isyieldable())
-assert(not pcall(coroutine.yield))
-
-
--- trivial errors
-assert(not pcall(coroutine.resume, 0))
-assert(not pcall(coroutine.status, 0))
-
-
--- tests for multiple yield/resume arguments
-
-local function eqtab (t1, t2)
-  assert(#t1 == #t2)
-  for i = 1, #t1 do
-    local v = t1[i]
-    assert(t2[i] == v)
-  end
-end
-
-_G.x = nil   -- declare x
-function foo (a, ...)
-  local x, y = coroutine.running()
-  assert(x == f and y == false)
-  -- next call should not corrupt coroutine (but must fail,
-  -- as it attempts to resume the running coroutine)
-  assert(coroutine.resume(f) == false)
-  assert(coroutine.status(f) == "running")
-  local arg = {...}
-  assert(coroutine.isyieldable())
-  for i=1,#arg do
-    _G.x = {coroutine.yield(table.unpack(arg[i]))}
-  end
-  return table.unpack(a)
-end
-
-f = coroutine.create(foo)
-assert(type(f) == "thread" and coroutine.status(f) == "suspended")
-assert(string.find(tostring(f), "thread"))
-local s,a,b,c,d
-s,a,b,c,d = coroutine.resume(f, {1,2,3}, {}, {1}, {'a', 'b', 'c'})
-assert(s and a == nil and coroutine.status(f) == "suspended")
-s,a,b,c,d = coroutine.resume(f)
-eqtab(_G.x, {})
-assert(s and a == 1 and b == nil)
-s,a,b,c,d = coroutine.resume(f, 1, 2, 3)
-eqtab(_G.x, {1, 2, 3})
-assert(s and a == 'a' and b == 'b' and c == 'c' and d == nil)
-s,a,b,c,d = coroutine.resume(f, "xuxu")
-eqtab(_G.x, {"xuxu"})
-assert(s and a == 1 and b == 2 and c == 3 and d == nil)
-assert(coroutine.status(f) == "dead")
-s, a = coroutine.resume(f, "xuxu")
-assert(not s and string.find(a, "dead") and coroutine.status(f) == "dead")
-
-
--- yields in tail calls
-local function foo (i) return coroutine.yield(i) end
-f = coroutine.wrap(function ()
-  for i=1,10 do
-    assert(foo(i) == _G.x)
-  end
-  return 'a'
-end)
-for i=1,10 do _G.x = i; assert(f(i) == i) end
-_G.x = 'xuxu'; assert(f('xuxu') == 'a')
-
--- recursive
-function pf (n, i)
-  coroutine.yield(n)
-  pf(n*i, i+1)
-end
-
-f = coroutine.wrap(pf)
-local s=1
-for i=1,10 do
-  assert(f(1, 1) == s)
-  s = s*i
-end
-
--- sieve
-function gen (n)
-  return coroutine.wrap(function ()
-    for i=2,n do coroutine.yield(i) end
-  end)
-end
-
-
-function filter (p, g)
-  return coroutine.wrap(function ()
-    while 1 do
-      local n = g()
-      if n == nil then return end
-      if math.fmod(n, p) ~= 0 then coroutine.yield(n) end
-    end
-  end)
-end
-
-local x = gen(100)
-local a = {}
-while 1 do
-  local n = x()
-  if n == nil then break end
-  table.insert(a, n)
-  x = filter(n, x)
-end
-
-assert(#a == 25 and a[#a] == 97)
-x, a = nil
-
--- yielding across C boundaries
-
-co = coroutine.wrap(function()
-       assert(not pcall(table.sort,{1,2,3}, coroutine.yield))
-       assert(coroutine.isyieldable())
-       coroutine.yield(20)
-       return 30
-     end)
-
-assert(co() == 20)
-assert(co() == 30)
-
-
-local f = function (s, i) return coroutine.yield(i) end
-
-local f1 = coroutine.wrap(function ()
-             return xpcall(pcall, function (...) return ... end,
-               function ()
-                 local s = 0
-                 for i in f, nil, 1 do pcall(function () s = s + i end) end
-                 error({s})
-               end)
-           end)
-
-f1()
-for i = 1, 10 do assert(f1(i) == i) end
-local r1, r2, v = f1(nil)
-assert(r1 and not r2 and v[1] ==  (10 + 1)*10/2)
-
-
-function f (a, b) a = coroutine.yield(a);  error{a + b} end
-function g(x) return x[1]*2 end
-
-co = coroutine.wrap(function ()
-       coroutine.yield(xpcall(f, g, 10, 20))
-     end)
-
-assert(co() == 10)
-r, msg = co(100)
-assert(not r and msg == 240)
-
-
--- unyieldable C call
-do
-  local function f (c)
-          assert(not coroutine.isyieldable())
-          return c .. c
-        end
-
-  local co = coroutine.wrap(function (c)
-               assert(coroutine.isyieldable())
-               local s = string.gsub("a", ".", f)
-               return s
-             end)
-  assert(co() == "aa")
-end
-
-
--- errors in coroutines
-function foo ()
-  assert(debug.getinfo(1).currentline == debug.getinfo(foo).linedefined + 1)
-  assert(debug.getinfo(2).currentline == debug.getinfo(goo).linedefined)
-  coroutine.yield(3)
-  error(foo)
-end
-
-function goo() foo() end
-x = coroutine.wrap(goo)
-assert(x() == 3)
-local a,b = pcall(x)
-assert(not a and b == foo)
-
-x = coroutine.create(goo)
-a,b = coroutine.resume(x)
-assert(a and b == 3)
-a,b = coroutine.resume(x)
-assert(not a and b == foo and coroutine.status(x) == "dead")
-a,b = coroutine.resume(x)
-assert(not a and string.find(b, "dead") and coroutine.status(x) == "dead")
-
-
--- co-routines x for loop
-function all (a, n, k)
-  if k == 0 then coroutine.yield(a)
-  else
-    for i=1,n do
-      a[k] = i
-      all(a, n, k-1)
-    end
-  end
-end
-
-local a = 0
-for t in coroutine.wrap(function () all({}, 5, 4) end) do
-  a = a+1
-end
-assert(a == 5^4)
-
-
--- access to locals of collected corroutines
-local C = {}; setmetatable(C, {__mode = "kv"})
-local x = coroutine.wrap (function ()
-            local a = 10
-            local function f () a = a+10; return a end
-            while true do
-              a = a+1
-              coroutine.yield(f)
-            end
-          end)
-
-C[1] = x;
-
-local f = x()
-assert(f() == 21 and x()() == 32 and x() == f)
-x = nil
-collectgarbage()
-assert(C[1] == nil)
-assert(f() == 43 and f() == 53)
-
-
--- old bug: attempt to resume itself
-
-function co_func (current_co)
-  assert(coroutine.running() == current_co)
-  assert(coroutine.resume(current_co) == false)
-  coroutine.yield(10, 20)
-  assert(coroutine.resume(current_co) == false)
-  coroutine.yield(23)
-  return 10
-end
-
-local co = coroutine.create(co_func)
-local a,b,c = coroutine.resume(co, co)
-assert(a == true and b == 10 and c == 20)
-a,b = coroutine.resume(co, co)
-assert(a == true and b == 23)
-a,b = coroutine.resume(co, co)
-assert(a == true and b == 10)
-assert(coroutine.resume(co, co) == false)
-assert(coroutine.resume(co, co) == false)
-
-
--- other old bug when attempting to resume itself
--- (trigger C-code assertions)
-do
-  local A = coroutine.running()
-  local B = coroutine.create(function() return coroutine.resume(A) end)
-  local st, res = coroutine.resume(B)
-  assert(st == true and res == false)
-
-  A = coroutine.wrap(function() return pcall(A, 1) end)
-  st, res = A()
-  assert(not st and string.find(res, "non%-suspended"))
-end
-
-
--- attempt to resume 'normal' coroutine
-local co1, co2
-co1 = coroutine.create(function () return co2() end)
-co2 = coroutine.wrap(function ()
-        assert(coroutine.status(co1) == 'normal')
-        assert(not coroutine.resume(co1))
-        coroutine.yield(3)
-      end)
-
-a,b = coroutine.resume(co1)
-assert(a and b == 3)
-assert(coroutine.status(co1) == 'dead')
-
--- infinite recursion of coroutines
-a = function(a) coroutine.wrap(a)(a) end
-assert(not pcall(a, a))
-a = nil
-
-
--- access to locals of erroneous coroutines
-local x = coroutine.create (function ()
-            local a = 10
-            _G.f = function () a=a+1; return a end
-            error('x')
-          end)
-
-assert(not coroutine.resume(x))
--- overwrite previous position of local `a'
-assert(not coroutine.resume(x, 1, 1, 1, 1, 1, 1, 1))
-assert(_G.f() == 11)
-assert(_G.f() == 12)
-
-
-if not T then
-  (Message or print)('\n >>> testC not active: skipping yield/hook tests <<<\n')
-else
-  print "testing yields inside hooks"
-
-  local turn
-  
-  function fact (t, x)
-    assert(turn == t)
-    if x == 0 then return 1
-    else return x*fact(t, x-1)
-    end
-  end
-
-  local A, B = 0, 0
-
-  local x = coroutine.create(function ()
-    T.sethook("yield 0", "", 2)
-    A = fact("A", 6)
-  end)
-
-  local y = coroutine.create(function ()
-    T.sethook("yield 0", "", 3)
-    B = fact("B", 7)
-  end)
-
-  while A==0 or B==0 do    -- A ~= 0 when 'x' finishes (similar for 'B','y')
-    if A==0 then turn = "A"; assert(T.resume(x)) end
-    if B==0 then turn = "B"; assert(T.resume(y)) end
-  end
-
-  assert(B // A == 7)    -- fact(7) // fact(6)
-
-  local line = debug.getinfo(1, "l").currentline + 2    -- get line number
-  local function foo ()
-    local x = 10    --<< this line is 'line'
-    x = x + 10
-    _G.XX = x
-  end
-
-  -- testing yields in line hook
-  local co = coroutine.wrap(function ()
-    T.sethook("setglobal X; yield 0", "l", 0); foo(); return 10 end)
-
-  _G.XX = nil;
-  _G.X = nil; co(); assert(_G.X == line)
-  _G.X = nil; co(); assert(_G.X == line + 1)
-  _G.X = nil; co(); assert(_G.X == line + 2 and _G.XX == nil)
-  _G.X = nil; co(); assert(_G.X == line + 3 and _G.XX == 20)
-  assert(co() == 10)
-
-  -- testing yields in count hook
-  co = coroutine.wrap(function ()
-    T.sethook("yield 0", "", 1); foo(); return 10 end)
-
-  _G.XX = nil;
-  local c = 0
-  repeat c = c + 1; local a = co() until a == 10
-  assert(_G.XX == 20 and c >= 5)
-
-  co = coroutine.wrap(function ()
-    T.sethook("yield 0", "", 2); foo(); return 10 end)
-
-  _G.XX = nil;
-  local c = 0
-  repeat c = c + 1; local a = co() until a == 10
-  assert(_G.XX == 20 and c >= 5)
-  _G.X = nil; _G.XX = nil
-
-  do
-    -- testing debug library on a coroutine suspended inside a hook
-    -- (bug in 5.2/5.3)
-    c = coroutine.create(function (a, ...)
-      T.sethook("yield 0", "l")   -- will yield on next two lines
-      assert(a == 10)
-      return ...
-    end)
-
-    assert(coroutine.resume(c, 1, 2, 3))   -- start coroutine
-    local n,v = debug.getlocal(c, 0, 1)    -- check its local
-    assert(n == "a" and v == 1)
-    n,v = debug.getlocal(c, 0, -1)         -- check varargs
-    assert(v == 2)
-    n,v = debug.getlocal(c, 0, -2)
-    assert(v == 3)
-    assert(debug.setlocal(c, 0, 1, 10))     -- test 'setlocal'
-    assert(debug.setlocal(c, 0, -2, 20))
-    local t = debug.getinfo(c, 0)        -- test 'getinfo'
-    assert(t.currentline == t.linedefined + 1)
-    assert(not debug.getinfo(c, 1))      -- no other level
-    assert(coroutine.resume(c))          -- run next line
-    v = {coroutine.resume(c)}         -- finish coroutine
-    assert(v[1] == true and v[2] == 2 and v[3] == 20 and v[4] == nil)
-    assert(not coroutine.resume(c))
-  end
-
-  do
-    -- testing debug library on last function in a suspended coroutine
-    -- (bug in 5.2/5.3)
-    local c = coroutine.create(function () T.testC("yield 1", 10, 20) end)
-    local a, b = coroutine.resume(c)
-    assert(a and b == 20)
-    assert(debug.getinfo(c, 0).linedefined == -1)
-    a, b = debug.getlocal(c, 0, 2)
-    assert(b == 10)
-  end
-
-
-  print "testing coroutine API"
-  
-  -- reusing a thread
-  assert(T.testC([[
-    newthread      # create thread
-    pushvalue 2    # push body
-    pushstring 'a a a'  # push argument
-    xmove 0 3 2   # move values to new thread
-    resume -1, 1    # call it first time
-    pushstatus
-    xmove 3 0 0   # move results back to stack
-    setglobal X    # result
-    setglobal Y    # status
-    pushvalue 2     # push body (to call it again)
-    pushstring 'b b b'
-    xmove 0 3 2
-    resume -1, 1    # call it again
-    pushstatus
-    xmove 3 0 0
-    return 1        # return result
-  ]], function (...) return ... end) == 'b b b')
-
-  assert(X == 'a a a' and Y == 'OK')
-
-
-  -- resuming running coroutine
-  C = coroutine.create(function ()
-        return T.testC([[
-                 pushnum 10;
-                 pushnum 20;
-                 resume -3 2;
-                 pushstatus
-                 gettop;
-                 return 3]], C)
-      end)
-  local a, b, c, d = coroutine.resume(C)
-  assert(a == true and string.find(b, "non%-suspended") and
-         c == "ERRRUN" and d == 4)
-
-  a, b, c, d = T.testC([[
-    rawgeti R 1    # get main thread
-    pushnum 10;
-    pushnum 20;
-    resume -3 2;
-    pushstatus
-    gettop;
-    return 4]])
-  assert(a == coroutine.running() and string.find(b, "non%-suspended") and
-         c == "ERRRUN" and d == 4)
-
-
-  -- using a main thread as a coroutine
-  local state = T.newstate()
-  T.loadlib(state)
-
-  assert(T.doremote(state, [[
-    coroutine = require'coroutine';
-    X = function (x) coroutine.yield(x, 'BB'); return 'CC' end;
-    return 'ok']]))
-
-  t = table.pack(T.testC(state, [[
-    rawgeti R 1     # get main thread
-    pushstring 'XX'
-    getglobal X    # get function for body
-    pushstring AA      # arg
-    resume 1 1      # 'resume' shadows previous stack!
-    gettop
-    setglobal T    # top
-    setglobal B    # second yielded value
-    setglobal A    # fist yielded value
-    rawgeti R 1     # get main thread
-    pushnum 5       # arg (noise)
-    resume 1 1      # after coroutine ends, previous stack is back
-    pushstatus
-    return *
-  ]]))
-  assert(t.n == 4 and t[2] == 'XX' and t[3] == 'CC' and t[4] == 'OK')
-  assert(T.doremote(state, "return T") == '2')
-  assert(T.doremote(state, "return A") == 'AA')
-  assert(T.doremote(state, "return B") == 'BB')
-
-  T.closestate(state)
-
-  print'+'
-
-end
-
-
--- leaving a pending coroutine open
-_X = coroutine.wrap(function ()
-      local a = 10
-      local x = function () a = a+1 end
-      coroutine.yield()
-    end)
-
-_X()
-
-
-if not _soft then
-  -- bug (stack overflow)
-  local j = 2^9
-  local lim = 1000000    -- (C stack limit; assume 32-bit machine)
-  local t = {lim - 10, lim - 5, lim - 1, lim, lim + 1}
-  for i = 1, #t do
-    local j = t[i]
-    co = coroutine.create(function()
-           local t = {}
-           for i = 1, j do t[i] = i end
-           return table.unpack(t)
-         end)
-    local r, msg = coroutine.resume(co)
-    assert(not r)
-  end
-  co = nil
-end
-
-
-assert(coroutine.running() == main)
-
-print"+"
-
-
-print"testing yields inside metamethods"
-
-local mt = {
-  __eq = function(a,b) coroutine.yield(nil, "eq"); return a.x == b.x end,
-  __lt = function(a,b) coroutine.yield(nil, "lt"); return a.x < b.x end,
-  __le = function(a,b) coroutine.yield(nil, "le"); return a - b <= 0 end,
-  __add = function(a,b) coroutine.yield(nil, "add"); return a.x + b.x end,
-  __sub = function(a,b) coroutine.yield(nil, "sub"); return a.x - b.x end,
-  __mod = function(a,b) coroutine.yield(nil, "mod"); return a.x % b.x end,
-  __unm = function(a,b) coroutine.yield(nil, "unm"); return -a.x end,
-  __bnot = function(a,b) coroutine.yield(nil, "bnot"); return ~a.x end,
-  __shl = function(a,b) coroutine.yield(nil, "shl"); return a.x << b.x end,
-  __shr = function(a,b) coroutine.yield(nil, "shr"); return a.x >> b.x end,
-  __band = function(a,b)
-             a = type(a) == "table" and a.x or a
-             b = type(b) == "table" and b.x or b
-             coroutine.yield(nil, "band")
-             return a & b
-           end,
-  __bor = function(a,b) coroutine.yield(nil, "bor"); return a.x | b.x end,
-  __bxor = function(a,b) coroutine.yield(nil, "bxor"); return a.x ~ b.x end,
-
-  __concat = function(a,b)
-               coroutine.yield(nil, "concat");
-               a = type(a) == "table" and a.x or a
-               b = type(b) == "table" and b.x or b
-               return a .. b
-             end,
-  __index = function (t,k) coroutine.yield(nil, "idx"); return t.k[k] end,
-  __newindex = function (t,k,v) coroutine.yield(nil, "nidx"); t.k[k] = v end,
-}
-
-
-local function new (x)
-  return setmetatable({x = x, k = {}}, mt)
-end
-
-
-local a = new(10)
-local b = new(12)
-local c = new"hello"
-
-local function run (f, t)
-  local i = 1
-  local c = coroutine.wrap(f)
-  while true do
-    local res, stat = c()
-    if res then assert(t[i] == nil); return res, t end
-    assert(stat == t[i])
-    i = i + 1
-  end
-end
-
-
-assert(run(function () if (a>=b) then return '>=' else return '<' end end,
-       {"le", "sub"}) == "<")
--- '<=' using '<'
-mt.__le = nil
-assert(run(function () if (a<=b) then return '<=' else return '>' end end,
-       {"lt"}) == "<=")
-assert(run(function () if (a==b) then return '==' else return '~=' end end,
-       {"eq"}) == "~=")
-
-assert(run(function () return a & b + a end, {"add", "band"}) == 2)
-
-assert(run(function () return a % b end, {"mod"}) == 10)
-
-assert(run(function () return ~a & b end, {"bnot", "band"}) == ~10 & 12)
-assert(run(function () return a | b end, {"bor"}) == 10 | 12)
-assert(run(function () return a ~ b end, {"bxor"}) == 10 ~ 12)
-assert(run(function () return a << b end, {"shl"}) == 10 << 12)
-assert(run(function () return a >> b end, {"shr"}) == 10 >> 12)
-
-assert(run(function () return a..b end, {"concat"}) == "1012")
-
-assert(run(function() return a .. b .. c .. a end,
-       {"concat", "concat", "concat"}) == "1012hello10")
-
-assert(run(function() return "a" .. "b" .. a .. "c" .. c .. b .. "x" end,
-       {"concat", "concat", "concat"}) == "ab10chello12x")
-
-
-do   -- a few more tests for comparsion operators
-  local mt1 = {
-    __le = function (a,b)
-      coroutine.yield(10)
-      return
-        (type(a) == "table" and a.x or a) <= (type(b) == "table" and b.x or b)
-    end,
-    __lt = function (a,b)
-      coroutine.yield(10)
-      return
-        (type(a) == "table" and a.x or a) < (type(b) == "table" and b.x or b)
-    end,
-  }
-  local mt2 = { __lt = mt1.__lt }   -- no __le
-
-  local function run (f)
-    local co = coroutine.wrap(f)
-    local res
-    repeat
-      res = co()
-    until res ~= 10
-    return res
-  end
-  
-  local function test ()
-    local a1 = setmetatable({x=1}, mt1)
-    local a2 = setmetatable({x=2}, mt2)
-    assert(a1 < a2)
-    assert(a1 <= a2)
-    assert(1 < a2)
-    assert(1 <= a2)
-    assert(2 > a1)
-    assert(2 >= a2)
-    return true
-  end
-  
-  run(test)
-
-end
-
-assert(run(function ()
-             a.BB = print
-             return a.BB
-           end, {"nidx", "idx"}) == print)
-
--- getuptable & setuptable
-do local _ENV = _ENV
-  f = function () AAA = BBB + 1; return AAA end
-end
-g = new(10); g.k.BBB = 10;
-debug.setupvalue(f, 1, g)
-assert(run(f, {"idx", "nidx", "idx"}) == 11)
-assert(g.k.AAA == 11)
-
-print"+"
-
-print"testing yields inside 'for' iterators"
-
-local f = function (s, i)
-      if i%2 == 0 then coroutine.yield(nil, "for") end
-      if i < s then return i + 1 end
-    end
-
-assert(run(function ()
-             local s = 0
-             for i in f, 4, 0 do s = s + i end
-             return s
-           end, {"for", "for", "for"}) == 10)
-
-
-
--- tests for coroutine API
-if T==nil then
-  (Message or print)('\n >>> testC not active: skipping coroutine API tests <<<\n')
-  return
-end
-
-print('testing coroutine API')
-
-local function apico (...)
-  local x = {...}
-  return coroutine.wrap(function ()
-    return T.testC(table.unpack(x))
-  end)
-end
-
-local a = {apico(
-[[
-  pushstring errorcode
-  pcallk 1 0 2;
-  invalid command (should not arrive here)
-]],
-[[return *]],
-"stackmark",
-error
-)()}
-assert(#a == 4 and
-       a[3] == "stackmark" and
-       a[4] == "errorcode" and
-       _G.status == "ERRRUN" and
-       _G.ctx == 2)       -- 'ctx' to pcallk
-
-local co = apico(
-  "pushvalue 2; pushnum 10; pcallk 1 2 3; invalid command;",
-  coroutine.yield,
-  "getglobal status; getglobal ctx; pushvalue 2; pushstring a; pcallk 1 0 4; invalid command",
-  "getglobal status; getglobal ctx; return *")
-
-assert(co() == 10)
-assert(co(20, 30) == 'a')
-a = {co()}
-assert(#a == 10 and
-       a[2] == coroutine.yield and
-       a[5] == 20 and a[6] == 30 and
-       a[7] == "YIELD" and a[8] == 3 and
-       a[9] == "YIELD" and a[10] == 4)
-assert(not pcall(co))   -- coroutine is dead now
-
-
-f = T.makeCfunc("pushnum 3; pushnum 5; yield 1;")
-co = coroutine.wrap(function ()
-  assert(f() == 23); assert(f() == 23); return 10
-end)
-assert(co(23,16) == 5)
-assert(co(23,16) == 5)
-assert(co(23,16) == 10)
-
-
--- testing coroutines with C bodies
-f = T.makeCfunc([[
-        pushnum 102
-	yieldk	1 U2
-	cannot be here!
-]],
-[[      # continuation
-	pushvalue U3   # accessing upvalues inside a continuation
-        pushvalue U4
-	return *
-]], 23, "huu")
-
-x = coroutine.wrap(f)
-assert(x() == 102)
-eqtab({x()}, {23, "huu"})
-
-
-f = T.makeCfunc[[pushstring 'a'; pushnum 102; yield 2; ]]
-
-a, b, c, d = T.testC([[newthread; pushvalue 2; xmove 0 3 1; resume 3 0;
-                       pushstatus; xmove 3 0 0;  resume 3 0; pushstatus;
-                       return 4; ]], f)
-
-assert(a == 'YIELD' and b == 'a' and c == 102 and d == 'OK')
-
-
--- testing chain of suspendable C calls
-
-local count = 3   -- number of levels
-
-f = T.makeCfunc([[
-  remove 1;             # remove argument
-  pushvalue U3;         # get selection function
-  call 0 1;             # call it  (result is 'f' or 'yield')
-  pushstring hello      # single argument for selected function
-  pushupvalueindex 2;   # index of continuation program
-  callk 1 -1 .;		# call selected function
-  errorerror		# should never arrive here
-]],
-[[
-  # continuation program
-  pushnum 34	# return value
-  return *     # return all results
-]],
-function ()     -- selection function
-  count = count - 1
-  if count == 0 then return coroutine.yield
-  else return f
-  end
-end
-)
-
-co = coroutine.wrap(function () return f(nil) end)
-assert(co() == "hello")   -- argument to 'yield'
-a = {co()}
--- three '34's (one from each pending C call)
-assert(#a == 3 and a[1] == a[2] and a[2] == a[3] and a[3] == 34)
-
-
--- testing yields with continuations
-
-co = coroutine.wrap(function (...) return
-       T.testC([[ # initial function
-          yieldk 1 2
-          cannot be here!
-       ]],
-       [[  # 1st continuation
-         yieldk 0 3 
-         cannot be here!
-       ]],
-       [[  # 2nd continuation
-         yieldk 0 4 
-         cannot be here!
-       ]],
-       [[  # 3th continuation
-          pushvalue 6   # function which is last arg. to 'testC' here
-          pushnum 10; pushnum 20;
-          pcall 2 0 0   # call should throw an error and return to next line
-          pop 1		# remove error message
-          pushvalue 6
-          getglobal status; getglobal ctx
-          pcallk 2 2 5  # call should throw an error and jump to continuation
-          cannot be here!
-       ]],
-       [[  # 4th (and last) continuation
-         return *
-       ]],
-       -- function called by 3th continuation
-       function (a,b) x=a; y=b; error("errmsg") end,
-       ...
-)
-end)
-
-local a = {co(3,4,6)}
-assert(a[1] == 6 and a[2] == nil)
-a = {co()}; assert(a[1] == nil and _G.status == "YIELD" and _G.ctx == 2)
-a = {co()}; assert(a[1] == nil and _G.status == "YIELD" and _G.ctx == 3)
-a = {co(7,8)};
--- original arguments
-assert(type(a[1]) == 'string' and type(a[2]) == 'string' and
-     type(a[3]) == 'string' and type(a[4]) == 'string' and
-     type(a[5]) == 'string' and type(a[6]) == 'function')
--- arguments left from fist resume
-assert(a[7] == 3 and a[8] == 4)
--- arguments to last resume
-assert(a[9] == 7 and a[10] == 8)
--- error message and nothing more
-assert(a[11]:find("errmsg") and #a == 11)
--- check arguments to pcallk
-assert(x == "YIELD" and y == 4)
-
-assert(not pcall(co))   -- coroutine should be dead
-
-
--- bug in nCcalls
-local co = coroutine.wrap(function ()
-  local a = {pcall(pcall,pcall,pcall,pcall,pcall,pcall,pcall,error,"hi")}
-  return pcall(assert, table.unpack(a))
-end)
-
-local a = {co()}
-assert(a[10] == "hi")
-
-print'OK'

testes/db.lua

@@ -1,857 +0,0 @@
--- $Id: db.lua,v 1.79 2016/11/07 13:02:34 roberto Exp $
--- See Copyright Notice in file all.lua
-
--- testing debug library
-
-local debug = require "debug"
-
-local function dostring(s) return assert(load(s))() end
-
-print"testing debug library and debug information"
-
-do
-local a=1
-end
-
-assert(not debug.gethook())
-
-local testline = 19         -- line where 'test' is defined
-function test (s, l, p)     -- this must be line 19
-  collectgarbage()   -- avoid gc during trace
-  local function f (event, line)
-    assert(event == 'line')
-    local l = table.remove(l, 1)
-    if p then print(l, line) end
-    assert(l == line, "wrong trace!!")
-  end
-  debug.sethook(f,"l"); load(s)(); debug.sethook()
-  assert(#l == 0)
-end
-
-
-do
-  assert(not pcall(debug.getinfo, print, "X"))   -- invalid option
-  assert(not debug.getinfo(1000))   -- out of range level
-  assert(not debug.getinfo(-1))     -- out of range level
-  local a = debug.getinfo(print)
-  assert(a.what == "C" and a.short_src == "[C]")
-  a = debug.getinfo(print, "L")
-  assert(a.activelines == nil)
-  local b = debug.getinfo(test, "SfL")
-  assert(b.name == nil and b.what == "Lua" and b.linedefined == testline and
-         b.lastlinedefined == b.linedefined + 10 and
-         b.func == test and not string.find(b.short_src, "%["))
-  assert(b.activelines[b.linedefined + 1] and
-         b.activelines[b.lastlinedefined])
-  assert(not b.activelines[b.linedefined] and
-         not b.activelines[b.lastlinedefined + 1])
-end
-
-
--- test file and string names truncation
-a = "function f () end"
-local function dostring (s, x) return load(s, x)() end
-dostring(a)
-assert(debug.getinfo(f).short_src == string.format('[string "%s"]', a))
-dostring(a..string.format("; %s\n=1", string.rep('p', 400)))
-assert(string.find(debug.getinfo(f).short_src, '^%[string [^\n]*%.%.%."%]$'))
-dostring(a..string.format("; %s=1", string.rep('p', 400)))
-assert(string.find(debug.getinfo(f).short_src, '^%[string [^\n]*%.%.%."%]$'))
-dostring("\n"..a)
-assert(debug.getinfo(f).short_src == '[string "..."]')
-dostring(a, "")
-assert(debug.getinfo(f).short_src == '[string ""]')
-dostring(a, "@xuxu")
-assert(debug.getinfo(f).short_src == "xuxu")
-dostring(a, "@"..string.rep('p', 1000)..'t')
-assert(string.find(debug.getinfo(f).short_src, "^%.%.%.p*t$"))
-dostring(a, "=xuxu")
-assert(debug.getinfo(f).short_src == "xuxu")
-dostring(a, string.format("=%s", string.rep('x', 500)))
-assert(string.find(debug.getinfo(f).short_src, "^x*$"))
-dostring(a, "=")
-assert(debug.getinfo(f).short_src == "")
-a = nil; f = nil;
-
-
-repeat
-  local g = {x = function ()
-    local a = debug.getinfo(2)
-    assert(a.name == 'f' and a.namewhat == 'local')
-    a = debug.getinfo(1)
-    assert(a.name == 'x' and a.namewhat == 'field')
-    return 'xixi'
-  end}
-  local f = function () return 1+1 and (not 1 or g.x()) end
-  assert(f() == 'xixi')
-  g = debug.getinfo(f)
-  assert(g.what == "Lua" and g.func == f and g.namewhat == "" and not g.name)
-
-  function f (x, name)   -- local!
-    name = name or 'f'
-    local a = debug.getinfo(1)
-    assert(a.name == name and a.namewhat == 'local')
-    return x
-  end
-
-  -- breaks in different conditions
-  if 3>4 then break end; f()
-  if 3<4 then a=1 else break end; f()
-  while 1 do local x=10; break end; f()
-  local b = 1
-  if 3>4 then return math.sin(1) end; f()
-  a = 3<4; f()
-  a = 3<4 or 1; f()
-  repeat local x=20; if 4>3 then f() else break end; f() until 1
-  g = {}
-  f(g).x = f(2) and f(10)+f(9)
-  assert(g.x == f(19))
-  function g(x) if not x then return 3 end return (x('a', 'x')) end
-  assert(g(f) == 'a')
-until 1
-
-test([[if
-math.sin(1)
-then
-  a=1
-else
-  a=2
-end
-]], {2,3,4,7})
-
-test([[--
-if nil then
-  a=1
-else
-  a=2
-end
-]], {2,5,6})
-
-test([[a=1
-repeat
-  a=a+1
-until a==3
-]], {1,3,4,3,4})
-
-test([[ do
-  return
-end
-]], {2})
-
-test([[local a
-a=1
-while a<=3 do
-  a=a+1
-end
-]], {1,2,3,4,3,4,3,4,3,5})
-
-test([[while math.sin(1) do
-  if math.sin(1)
-  then break
-  end
-end
-a=1]], {1,2,3,6})
-
-test([[for i=1,3 do
-  a=i
-end
-]], {1,2,1,2,1,2,1,3})
-
-test([[for i,v in pairs{'a','b'} do
-  a=tostring(i) .. v
-end
-]], {1,2,1,2,1,3})
-
-test([[for i=1,4 do a=1 end]], {1,1,1,1,1})
-
-
-
-print'+'
-
--- invalid levels in [gs]etlocal
-assert(not pcall(debug.getlocal, 20, 1))
-assert(not pcall(debug.setlocal, -1, 1, 10))
-
-
--- parameter names
-local function foo (a,b,...) local d, e end
-local co = coroutine.create(foo)
-
-assert(debug.getlocal(foo, 1) == 'a')
-assert(debug.getlocal(foo, 2) == 'b')
-assert(not debug.getlocal(foo, 3))
-assert(debug.getlocal(co, foo, 1) == 'a')
-assert(debug.getlocal(co, foo, 2) == 'b')
-assert(not debug.getlocal(co, foo, 3))
-
-assert(not debug.getlocal(print, 1))
-
-
--- varargs
-local function foo (a, ...)
-  local t = table.pack(...)
-  for i = 1, t.n do
-    local n, v = debug.getlocal(1, -i)
-    assert(n == "(*vararg)" and v == t[i])
-  end
-  assert(not debug.getlocal(1, -(t.n + 1)))
-  assert(not debug.setlocal(1, -(t.n + 1), 30))
-  if t.n > 0 then
-    (function (x)
-      assert(debug.setlocal(2, -1, x) == "(*vararg)")
-      assert(debug.setlocal(2, -t.n, x) == "(*vararg)")
-     end)(430)
-     assert(... == 430)
-  end
-end
-
-foo()
-foo(print)
-foo(200, 3, 4)
-local a = {}
-for i = 1, (_soft and 100 or 1000) do a[i] = i end
-foo(table.unpack(a))
-a = nil
-
--- access to vararg in non-vararg function
-local function foo () return debug.getlocal(1, -1) end
-assert(not foo(10))
-
-
-do   -- test hook presence in debug info
-  assert(not debug.gethook())
-  local count = 0
-  local function f ()
-    assert(debug.getinfo(1).namewhat == "hook")
-    local sndline = string.match(debug.traceback(), "\n(.-)\n")
-    assert(string.find(sndline, "hook"))
-    count = count + 1
-  end
-  debug.sethook(f, "l")
-  local a = 0
-  _ENV.a = a
-  a = 1
-  debug.sethook()
-  assert(count == 4)
-end
-
-
-a = {}; L = nil
-local glob = 1
-local oldglob = glob
-debug.sethook(function (e,l)
-  collectgarbage()   -- force GC during a hook
-  local f, m, c = debug.gethook()
-  assert(m == 'crl' and c == 0)
-  if e == "line" then
-    if glob ~= oldglob then
-      L = l-1   -- get the first line where "glob" has changed
-      oldglob = glob
-    end
-  elseif e == "call" then
-      local f = debug.getinfo(2, "f").func
-      a[f] = 1
-  else assert(e == "return")
-  end
-end, "crl")
-
-
-function f(a,b)
-  collectgarbage()
-  local _, x = debug.getlocal(1, 1)
-  local _, y = debug.getlocal(1, 2)
-  assert(x == a and y == b)
-  assert(debug.setlocal(2, 3, "pera") == "AA".."AA")
-  assert(debug.setlocal(2, 4, "maçã") == "B")
-  x = debug.getinfo(2)
-  assert(x.func == g and x.what == "Lua" and x.name == 'g' and
-         x.nups == 2 and string.find(x.source, "^@.*db%.lua$"))
-  glob = glob+1
-  assert(debug.getinfo(1, "l").currentline == L+1)
-  assert(debug.getinfo(1, "l").currentline == L+2)
-end
-
-function foo()
-  glob = glob+1
-  assert(debug.getinfo(1, "l").currentline == L+1)
-end; foo()  -- set L
--- check line counting inside strings and empty lines
-
-_ = 'alo\
-alo' .. [[
-
-]]
---[[
-]]
-assert(debug.getinfo(1, "l").currentline == L+11)  -- check count of lines
-
-
-function g(...)
-  local arg = {...}
-  do local a,b,c; a=math.sin(40); end
-  local feijao
-  local AAAA,B = "xuxu", "mamão"
-  f(AAAA,B)
-  assert(AAAA == "pera" and B == "maçã")
-  do
-     local B = 13
-     local x,y = debug.getlocal(1,5)
-     assert(x == 'B' and y == 13)
-  end
-end
-
-g()
-
-
-assert(a[f] and a[g] and a[assert] and a[debug.getlocal] and not a[print])
-
-
--- tests for manipulating non-registered locals (C and Lua temporaries)
-
-local n, v = debug.getlocal(0, 1)
-assert(v == 0 and n == "(*temporary)")
-local n, v = debug.getlocal(0, 2)
-assert(v == 2 and n == "(*temporary)")
-assert(not debug.getlocal(0, 3))
-assert(not debug.getlocal(0, 0))
-
-function f()
-  assert(select(2, debug.getlocal(2,3)) == 1)
-  assert(not debug.getlocal(2,4))
-  debug.setlocal(2, 3, 10)
-  return 20
-end
-
-function g(a,b) return (a+1) + f() end
-
-assert(g(0,0) == 30)
- 
-
-debug.sethook(nil);
-assert(debug.gethook() == nil)
-
-
--- testing access to function arguments
-
-local function collectlocals (level)
-  local tab = {}
-  for i = 1, math.huge do
-    local n, v = debug.getlocal(level + 1, i)
-    if not (n and string.find(n, "^[a-zA-Z0-9_]+$")) then
-       break   -- consider only real variables
-    end
-    tab[n] = v
-  end
-  return tab
-end
-
-
-X = nil
-a = {}
-function a:f (a, b, ...) local arg = {...}; local c = 13 end
-debug.sethook(function (e)
-  assert(e == "call")
-  dostring("XX = 12")  -- test dostring inside hooks
-  -- testing errors inside hooks
-  assert(not pcall(load("a='joao'+1")))
-  debug.sethook(function (e, l) 
-    assert(debug.getinfo(2, "l").currentline == l)
-    local f,m,c = debug.gethook()
-    assert(e == "line")
-    assert(m == 'l' and c == 0)
-    debug.sethook(nil)  -- hook is called only once
-    assert(not X)       -- check that
-    X = collectlocals(2)
-  end, "l")
-end, "c")
-
-a:f(1,2,3,4,5)
-assert(X.self == a and X.a == 1   and X.b == 2 and X.c == nil)
-assert(XX == 12)
-assert(debug.gethook() == nil)
-
-
--- testing access to local variables in return hook (bug in 5.2)
-do
-  local function foo (a, b)
-    do local x,y,z end
-    local c, d = 10, 20
-    return
-  end
-
-  local function aux ()
-    if debug.getinfo(2).name == "foo" then
-      foo = nil   -- to signal that it found 'foo'
-      local tab = {a = 100, b = 200, c = 10, d = 20}
-      for n, v in pairs(collectlocals(2)) do
-        assert(tab[n] == v)
-        tab[n] = nil
-      end
-      assert(next(tab) == nil)    -- 'tab' must be empty
-    end
-  end
-
-  debug.sethook(aux, "r"); foo(100, 200); debug.sethook()
-  assert(foo == nil)
-end
-
--- testing upvalue access
-local function getupvalues (f)
-  local t = {}
-  local i = 1
-  while true do
-    local name, value = debug.getupvalue(f, i)
-    if not name then break end
-    assert(not t[name])
-    t[name] = value
-    i = i + 1
-  end
-  return t
-end
-
-local a,b,c = 1,2,3
-local function foo1 (a) b = a; return c end
-local function foo2 (x) a = x; return c+b end
-assert(not debug.getupvalue(foo1, 3))
-assert(not debug.getupvalue(foo1, 0))
-assert(not debug.setupvalue(foo1, 3, "xuxu"))
-local t = getupvalues(foo1)
-assert(t.a == nil and t.b == 2 and t.c == 3)
-t = getupvalues(foo2)
-assert(t.a == 1 and t.b == 2 and t.c == 3)
-assert(debug.setupvalue(foo1, 1, "xuxu") == "b")
-assert(({debug.getupvalue(foo2, 3)})[2] == "xuxu")
--- upvalues of C functions are allways "called" "" (the empty string)
-assert(debug.getupvalue(string.gmatch("x", "x"), 1) == "")  
-
-
--- testing count hooks
-local a=0
-debug.sethook(function (e) a=a+1 end, "", 1)
-a=0; for i=1,1000 do end; assert(1000 < a and a < 1012)
-debug.sethook(function (e) a=a+1 end, "", 4)
-a=0; for i=1,1000 do end; assert(250 < a and a < 255)
-local f,m,c = debug.gethook()
-assert(m == "" and c == 4)
-debug.sethook(function (e) a=a+1 end, "", 4000)
-a=0; for i=1,1000 do end; assert(a == 0)
-
-do
-  debug.sethook(print, "", 2^24 - 1)   -- count upperbound
-  local f,m,c = debug.gethook()
-  assert(({debug.gethook()})[3] == 2^24 - 1)
-end
-
-debug.sethook()
-
-
--- tests for tail calls
-local function f (x)
-  if x then
-    assert(debug.getinfo(1, "S").what == "Lua")
-    assert(debug.getinfo(1, "t").istailcall == true)
-    local tail = debug.getinfo(2)
-    assert(tail.func == g1 and tail.istailcall == true)
-    assert(debug.getinfo(3, "S").what == "main")
-    print"+"
-    end
-end
-
-function g(x) return f(x) end
-
-function g1(x) g(x) end
-
-local function h (x) local f=g1; return f(x) end
-
-h(true)
-
-local b = {}
-debug.sethook(function (e) table.insert(b, e) end, "cr")
-h(false)
-debug.sethook()
-local res = {"return",   -- first return (from sethook)
-  "call", "tail call", "call", "tail call",
-  "return", "return",
-  "call",    -- last call (to sethook)
-}
-for i = 1, #res do assert(res[i] == table.remove(b, 1)) end
-
-b = 0
-debug.sethook(function (e)
-                if e == "tail call" then
-                  b = b + 1
-                  assert(debug.getinfo(2, "t").istailcall == true)
-                else
-                  assert(debug.getinfo(2, "t").istailcall == false)
-                end
-              end, "c")
-h(false)
-debug.sethook()
-assert(b == 2)   -- two tail calls
-
-lim = _soft and 3000 or 30000
-local function foo (x)
-  if x==0 then
-    assert(debug.getinfo(2).what == "main")
-    local info = debug.getinfo(1)
-    assert(info.istailcall == true and info.func == foo)
-  else return foo(x-1)
-  end
-end
-
-foo(lim)
-
-
-print"+"
-
-
--- testing local function information
-co = load[[
-  local A = function ()
-    return x
-  end
-  return
-]]
-
-local a = 0
--- 'A' should be visible to debugger only after its complete definition
-debug.sethook(function (e, l)
-  if l == 3 then a = a + 1; assert(debug.getlocal(2, 1) == "(*temporary)")
-  elseif l == 4 then a = a + 1; assert(debug.getlocal(2, 1) == "A")
-  end
-end, "l")
-co()  -- run local function definition
-debug.sethook()  -- turn off hook
-assert(a == 2)   -- ensure all two lines where hooked
-
--- testing traceback
-
-assert(debug.traceback(print) == print)
-assert(debug.traceback(print, 4) == print)
-assert(string.find(debug.traceback("hi", 4), "^hi\n"))
-assert(string.find(debug.traceback("hi"), "^hi\n"))
-assert(not string.find(debug.traceback("hi"), "'debug.traceback'"))
-assert(string.find(debug.traceback("hi", 0), "'debug.traceback'"))
-assert(string.find(debug.traceback(), "^stack traceback:\n"))
-
-do  -- C-function names in traceback
-  local st, msg = (function () return pcall end)()(debug.traceback)
-  assert(st == true and string.find(msg, "pcall"))
-end
-
-
--- testing nparams, nups e isvararg
-local t = debug.getinfo(print, "u")
-assert(t.isvararg == true and t.nparams == 0 and t.nups == 0)
-
-t = debug.getinfo(function (a,b,c) end, "u")
-assert(t.isvararg == false and t.nparams == 3 and t.nups == 0)
-
-t = debug.getinfo(function (a,b,...) return t[a] end, "u")
-assert(t.isvararg == true and t.nparams == 2 and t.nups == 1)
-
-t = debug.getinfo(1)   -- main
-assert(t.isvararg == true and t.nparams == 0 and t.nups == 1 and
-       debug.getupvalue(t.func, 1) == "_ENV")
-
-
-
-
--- testing debugging of coroutines
-
-local function checktraceback (co, p, level)
-  local tb = debug.traceback(co, nil, level)
-  local i = 0
-  for l in string.gmatch(tb, "[^\n]+\n?") do
-    assert(i == 0 or string.find(l, p[i]))
-    i = i+1
-  end
-  assert(p[i] == nil)
-end
-
-
-local function f (n)
-  if n > 0 then f(n-1)
-  else coroutine.yield() end
-end
-
-local co = coroutine.create(f)
-coroutine.resume(co, 3)
-checktraceback(co, {"yield", "db.lua", "db.lua", "db.lua", "db.lua"})
-checktraceback(co, {"db.lua", "db.lua", "db.lua", "db.lua"}, 1)
-checktraceback(co, {"db.lua", "db.lua", "db.lua"}, 2)
-checktraceback(co, {"db.lua"}, 4)
-checktraceback(co, {}, 40)
-
-
-co = coroutine.create(function (x)
-       local a = 1
-       coroutine.yield(debug.getinfo(1, "l"))
-       coroutine.yield(debug.getinfo(1, "l").currentline)
-       return a
-     end)
-
-local tr = {}
-local foo = function (e, l) if l then table.insert(tr, l) end end
-debug.sethook(co, foo, "lcr")
-
-local _, l = coroutine.resume(co, 10)
-local x = debug.getinfo(co, 1, "lfLS")
-assert(x.currentline == l.currentline and x.activelines[x.currentline])
-assert(type(x.func) == "function")
-for i=x.linedefined + 1, x.lastlinedefined do
-  assert(x.activelines[i])
-  x.activelines[i] = nil
-end
-assert(next(x.activelines) == nil)   -- no 'extra' elements
-assert(not debug.getinfo(co, 2))
-local a,b = debug.getlocal(co, 1, 1)
-assert(a == "x" and b == 10)
-a,b = debug.getlocal(co, 1, 2)
-assert(a == "a" and b == 1)
-debug.setlocal(co, 1, 2, "hi")
-assert(debug.gethook(co) == foo)
-assert(#tr == 2 and
-       tr[1] == l.currentline-1 and tr[2] == l.currentline)
-
-a,b,c = pcall(coroutine.resume, co)
-assert(a and b and c == l.currentline+1)
-checktraceback(co, {"yield", "in function <"})
-
-a,b = coroutine.resume(co)
-assert(a and b == "hi")
-assert(#tr == 4 and tr[4] == l.currentline+2)
-assert(debug.gethook(co) == foo)
-assert(not debug.gethook())
-checktraceback(co, {})
-
-
--- check get/setlocal in coroutines
-co = coroutine.create(function (x)
-  local a, b = coroutine.yield(x)
-  assert(a == 100 and b == nil)
-  return x
-end)
-a, b = coroutine.resume(co, 10)
-assert(a and b == 10)
-a, b = debug.getlocal(co, 1, 1)
-assert(a == "x" and b == 10)
-assert(not debug.getlocal(co, 1, 5))
-assert(debug.setlocal(co, 1, 1, 30) == "x")
-assert(not debug.setlocal(co, 1, 5, 40))
-a, b = coroutine.resume(co, 100)
-assert(a and b == 30)
-
-
--- check traceback of suspended (or dead with error) coroutines
-
-function f(i) if i==0 then error(i) else coroutine.yield(); f(i-1) end end
-
-co = coroutine.create(function (x) f(x) end)
-a, b = coroutine.resume(co, 3)
-t = {"'coroutine.yield'", "'f'", "in function <"}
-while coroutine.status(co) == "suspended" do
-  checktraceback(co, t)
-  a, b = coroutine.resume(co)
-  table.insert(t, 2, "'f'")   -- one more recursive call to 'f'
-end
-t[1] = "'error'"
-checktraceback(co, t)
-
-
--- test acessing line numbers of a coroutine from a resume inside
--- a C function (this is a known bug in Lua 5.0)
-
-local function g(x)
-    coroutine.yield(x)
-end
-
-local function f (i)
-  debug.sethook(function () end, "l")
-  for j=1,1000 do
-    g(i+j)
-  end
-end
-
-local co = coroutine.wrap(f)
-co(10)
-pcall(co)
-pcall(co)
-
-
-assert(type(debug.getregistry()) == "table")
-
-
--- test tagmethod information
-local a = {}
-local function f (t)
-  local info = debug.getinfo(1);
-  assert(info.namewhat == "metamethod")
-  a.op = info.name
-  return info.name
-end
-setmetatable(a, {
-  __index = f; __add = f; __div = f; __mod = f; __concat = f; __pow = f;
-  __mul = f; __idiv = f; __unm = f; __len = f; __sub = f;
-  __shl = f; __shr = f; __bor = f; __bxor = f;
-  __eq = f; __le = f; __lt = f; __unm = f; __len = f; __band = f;
-  __bnot = f;
-})
-
-local b = setmetatable({}, getmetatable(a))
-
-assert(a[3] == "__index" and a^3 == "__pow" and a..a == "__concat")
-assert(a/3 == "__div" and 3%a == "__mod")
-assert(a+3 == "__add" and 3-a == "__sub" and a*3 == "__mul" and
-       -a == "__unm" and #a == "__len" and a&3 == "__band")
-assert(a|3 == "__bor" and 3~a == "__bxor" and a<<3 == "__shl" and
-       a>>1 == "__shr")
-assert (a==b and a.op == "__eq")
-assert (a>=b and a.op == "__le")
-assert (a>b and a.op == "__lt")
-assert(~a == "__bnot")
-
-do   -- testing for-iterator name
-  local function f()
-    assert(debug.getinfo(1).name == "for iterator")
-  end
-
-  for i in f do end
-end
-
-
-do   -- testing debug info for finalizers
-  local name = nil
-
-  -- create a piece of garbage with a finalizer
-  setmetatable({}, {__gc = function ()
-    local t = debug.getinfo(2)   -- get callee information
-    assert(t.namewhat == "metamethod")
-    name = t.name
-  end})
-
-  -- repeat until previous finalizer runs (setting 'name')
-  repeat local a = {} until name
-  assert(name == "__gc")
-end
-
-
-do
-  print("testing traceback sizes")
-
-  local function countlines (s)
-    return select(2, string.gsub(s, "\n", ""))
-  end
-
-  local function deep (lvl, n)
-    if lvl == 0 then
-      return (debug.traceback("message", n))
-    else
-      return (deep(lvl-1, n))
-    end
-  end
-
-  local function checkdeep (total, start)
-    local s = deep(total, start)
-    local rest = string.match(s, "^message\nstack traceback:\n(.*)$")
-    local cl = countlines(rest)
-    -- at most 10 lines in first part, 11 in second, plus '...'
-    assert(cl <= 10 + 11 + 1)
-    local brk = string.find(rest, "%.%.%.")
-    if brk then   -- does message have '...'?
-      local rest1 = string.sub(rest, 1, brk)
-      local rest2 = string.sub(rest, brk, #rest)
-      assert(countlines(rest1) == 10 and countlines(rest2) == 11)
-    else
-      assert(cl == total - start + 2)
-    end
-  end
-
-  for d = 1, 51, 10 do
-    for l = 1, d do
-      -- use coroutines to ensure complete control of the stack
-      coroutine.wrap(checkdeep)(d, l)
-    end
-  end
-
-end
-
-
-print("testing debug functions on chunk without debug info")
-prog = [[-- program to be loaded without debug information
-local debug = require'debug'
-local a = 12  -- a local variable
-
-local n, v = debug.getlocal(1, 1)
-assert(n == "(*temporary)" and v == debug)   -- unkown name but known value
-n, v = debug.getlocal(1, 2)
-assert(n == "(*temporary)" and v == 12)   -- unkown name but known value
-
--- a function with an upvalue
-local f = function () local x; return a end
-n, v = debug.getupvalue(f, 1)
-assert(n == "(*no name)" and v == 12)
-assert(debug.setupvalue(f, 1, 13) == "(*no name)")
-assert(a == 13)
-
-local t = debug.getinfo(f)
-assert(t.name == nil and t.linedefined > 0 and
-       t.lastlinedefined == t.linedefined and
-       t.short_src == "?")
-assert(debug.getinfo(1).currentline == -1)
-
-t = debug.getinfo(f, "L").activelines
-assert(next(t) == nil)    -- active lines are empty
-
--- dump/load a function without debug info
-f = load(string.dump(f))
-
-t = debug.getinfo(f)
-assert(t.name == nil and t.linedefined > 0 and
-       t.lastlinedefined == t.linedefined and
-       t.short_src == "?")
-assert(debug.getinfo(1).currentline == -1)
-
-return a
-]]
-
-
--- load 'prog' without debug info
-local f = assert(load(string.dump(load(prog), true)))
-
-assert(f() == 13)
-
-do   -- tests for 'source' in binary dumps
-  local prog = [[
-    return function (x)
-      return function (y) 
-        return x + y
-      end
-    end
-  ]]
-  local name = string.rep("x", 1000)
-  local p = assert(load(prog, name))
-  -- load 'p' as a binary chunk with debug information
-  local c = string.dump(p)
-  assert(#c > 1000 and #c < 2000)   -- no repetition of 'source' in dump
-  local f = assert(load(c))
-  local g = f()
-  local h = g(3)
-  assert(h(5) == 8)
-  assert(debug.getinfo(f).source == name and   -- all functions have 'source'
-         debug.getinfo(g).source == name and 
-         debug.getinfo(h).source == name)
-  -- again, without debug info
-  local c = string.dump(p, true)
-  assert(#c < 500)   -- no 'source' in dump
-  local f = assert(load(c))
-  local g = f()
-  local h = g(30)
-  assert(h(50) == 80)
-  assert(debug.getinfo(f).source == '=?' and   -- no function has 'source'
-         debug.getinfo(g).source == '=?' and 
-         debug.getinfo(h).source == '=?')
-end
-
-print"OK"
-

testes/errors.lua

@@ -1,537 +0,0 @@
--- $Id: errors.lua,v 1.94 2016/12/21 19:23:02 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print("testing errors")
-
-local debug = require"debug"
-
--- avoid problems with 'strict' module (which may generate other error messages)
-local mt = getmetatable(_G) or {}
-local oldmm = mt.__index
-mt.__index = nil
-
-local function checkerr (msg, f, ...)
-  local st, err = pcall(f, ...)
-  assert(not st and string.find(err, msg))
-end
-
-
-local function doit (s)
-  local f, msg = load(s)
-  if f == nil then return msg end
-  local cond, msg = pcall(f)
-  return (not cond) and msg
-end
-
-
-local function checkmessage (prog, msg)
-  local m = doit(prog)
-  assert(string.find(m, msg, 1, true))
-end
-
-local function checksyntax (prog, extra, token, line)
-  local msg = doit(prog)
-  if not string.find(token, "^<%a") and not string.find(token, "^char%(")
-    then token = "'"..token.."'" end
-  token = string.gsub(token, "(%p)", "%%%1")
-  local pt = string.format([[^%%[string ".*"%%]:%d: .- near %s$]],
-                           line, token)
-  assert(string.find(msg, pt))
-  assert(string.find(msg, msg, 1, true))
-end
-
-
--- test error message with no extra info
-assert(doit("error('hi', 0)") == 'hi')
-
--- test error message with no info
-assert(doit("error()") == nil)
-
-
--- test common errors/errors that crashed in the past
-assert(doit("table.unpack({}, 1, n=2^30)"))
-assert(doit("a=math.sin()"))
-assert(not doit("tostring(1)") and doit("tostring()"))
-assert(doit"tonumber()")
-assert(doit"repeat until 1; a")
-assert(doit"return;;")
-assert(doit"assert(false)")
-assert(doit"assert(nil)")
-assert(doit("function a (... , ...) end"))
-assert(doit("function a (, ...) end"))
-assert(doit("local t={}; t = t[#t] + 1"))
-
-checksyntax([[
-  local a = {4
-
-]], "'}' expected (to close '{' at line 1)", "<eof>", 3)
-
-
--- tests for better error messages
-
-checkmessage("a = {} + 1", "arithmetic")
-checkmessage("a = {} | 1", "bitwise operation")
-checkmessage("a = {} < 1", "attempt to compare")
-checkmessage("a = {} <= 1", "attempt to compare")
-
-checkmessage("a=1; bbbb=2; a=math.sin(3)+bbbb(3)", "global 'bbbb'")
-checkmessage("a={}; do local a=1 end a:bbbb(3)", "method 'bbbb'")
-checkmessage("local a={}; a.bbbb(3)", "field 'bbbb'")
-assert(not string.find(doit"a={13}; local bbbb=1; a[bbbb](3)", "'bbbb'"))
-checkmessage("a={13}; local bbbb=1; a[bbbb](3)", "number")
-checkmessage("a=(1)..{}", "a table value")
-
-checkmessage("a = #print", "length of a function value")
-checkmessage("a = #3", "length of a number value")
-
-aaa = nil
-checkmessage("aaa.bbb:ddd(9)", "global 'aaa'")
-checkmessage("local aaa={bbb=1}; aaa.bbb:ddd(9)", "field 'bbb'")
-checkmessage("local aaa={bbb={}}; aaa.bbb:ddd(9)", "method 'ddd'")
-checkmessage("local a,b,c; (function () a = b+1 end)()", "upvalue 'b'")
-assert(not doit"local aaa={bbb={ddd=next}}; aaa.bbb:ddd(nil)")
-
--- upvalues being indexed do not go to the stack
-checkmessage("local a,b,cc; (function () a = cc[1] end)()", "upvalue 'cc'")
-checkmessage("local a,b,cc; (function () a.x = 1 end)()", "upvalue 'a'")
-
-checkmessage("local _ENV = {x={}}; a = a + 1", "global 'a'")
-
-checkmessage("b=1; local aaa='a'; x=aaa+b", "local 'aaa'")
-checkmessage("aaa={}; x=3/aaa", "global 'aaa'")
-checkmessage("aaa='2'; b=nil;x=aaa*b", "global 'b'")
-checkmessage("aaa={}; x=-aaa", "global 'aaa'")
-
--- short circuit
-checkmessage("a=1; local a,bbbb=2,3; a = math.sin(1) and bbbb(3)",
-       "local 'bbbb'")
-checkmessage("a=1; local a,bbbb=2,3; a = bbbb(1) or a(3)", "local 'bbbb'")
-checkmessage("local a,b,c,f = 1,1,1; f((a and b) or c)", "local 'f'")
-checkmessage("local a,b,c = 1,1,1; ((a and b) or c)()", "call a number value")
-assert(not string.find(doit"aaa={}; x=(aaa or aaa)+(aaa and aaa)", "'aaa'"))
-assert(not string.find(doit"aaa={}; (aaa or aaa)()", "'aaa'"))
-
-checkmessage("print(print < 10)", "function with number")
-checkmessage("print(print < print)", "two function values")
-checkmessage("print('10' < 10)", "string with number")
-checkmessage("print(10 < '23')", "number with string")
-
--- float->integer conversions
-checkmessage("local a = 2.0^100; x = a << 2", "local a")
-checkmessage("local a = 1 >> 2.0^100", "has no integer representation")
-checkmessage("local a = '10' << 2.0^100", "has no integer representation")
-checkmessage("local a = 2.0^100 & 1", "has no integer representation")
-checkmessage("local a = 2.0^100 & '1'", "has no integer representation")
-checkmessage("local a = 2.0 | 1e40", "has no integer representation")
-checkmessage("local a = 2e100 ~ 1", "has no integer representation")
-checkmessage("string.sub('a', 2.0^100)", "has no integer representation")
-checkmessage("string.rep('a', 3.3)", "has no integer representation")
-checkmessage("return 6e40 & 7", "has no integer representation")
-checkmessage("return 34 << 7e30", "has no integer representation")
-checkmessage("return ~-3e40", "has no integer representation")
-checkmessage("return ~-3.009", "has no integer representation")
-checkmessage("return 3.009 & 1", "has no integer representation")
-checkmessage("return 34 >> {}", "table value")
-checkmessage("a = 24 // 0", "divide by zero")
-checkmessage("a = 1 % 0", "'n%0'")
-
-
--- passing light userdata instead of full userdata
-_G.D = debug
-checkmessage([[
-  -- create light udata
-  local x = D.upvalueid(function () return debug end, 1)
-  D.setuservalue(x, {})
-]], "light userdata")
-_G.D = nil
-
-do   -- named objects (field '__name')
-  checkmessage("math.sin(io.input())", "(number expected, got FILE*)")
-  _G.XX = setmetatable({}, {__name = "My Type"})
-  assert(string.find(tostring(XX), "^My Type"))
-  checkmessage("io.input(XX)", "(FILE* expected, got My Type)")
-  checkmessage("return XX + 1", "on a My Type value")
-  checkmessage("return ~io.stdin", "on a FILE* value")
-  checkmessage("return XX < XX", "two My Type values")
-  checkmessage("return {} < XX", "table with My Type")
-  checkmessage("return XX < io.stdin", "My Type with FILE*")
-  _G.XX = nil
-end
-
--- global functions
-checkmessage("(io.write or print){}", "io.write")
-checkmessage("(collectgarbage or print){}", "collectgarbage")
-
--- errors in functions without debug info
-do
-  local f = function (a) return a + 1 end
-  f = assert(load(string.dump(f, true)))
-  assert(f(3) == 4)
-  checkerr("^%?:%-1:", f, {})
-
-  -- code with a move to a local var ('OP_MOV A B' with A<B)
-  f = function () local a; a = {}; return a + 2 end
-  -- no debug info (so that 'a' is unknown)
-  f = assert(load(string.dump(f, true)))
-  -- symbolic execution should not get lost
-  checkerr("^%?:%-1:.*table value", f)
-end
-
-
--- tests for field accesses after RK limit
-local t = {}
-for i = 1, 1000 do
-  t[i] = "a = x" .. i
-end
-local s = table.concat(t, "; ")
-t = nil
-checkmessage(s.."; a = bbb + 1", "global 'bbb'")
-checkmessage("local _ENV=_ENV;"..s.."; a = bbb + 1", "global 'bbb'")
-checkmessage(s.."; local t = {}; a = t.bbb + 1", "field 'bbb'")
-checkmessage(s.."; local t = {}; t:bbb()", "method 'bbb'")
-
-checkmessage([[aaa=9
-repeat until 3==3
-local x=math.sin(math.cos(3))
-if math.sin(1) == x then return math.sin(1) end   -- tail call
-local a,b = 1, {
-  {x='a'..'b'..'c', y='b', z=x},
-  {1,2,3,4,5} or 3+3<=3+3,
-  3+1>3+1,
-  {d = x and aaa[x or y]}}
-]], "global 'aaa'")
-
-checkmessage([[
-local x,y = {},1
-if math.sin(1) == 0 then return 3 end    -- return
-x.a()]], "field 'a'")
-
-checkmessage([[
-prefix = nil
-insert = nil
-while 1 do
-  local a
-  if nil then break end
-  insert(prefix, a)
-end]], "global 'insert'")
-
-checkmessage([[  -- tail call
-  return math.sin("a")
-]], "'sin'")
-
-checkmessage([[collectgarbage("nooption")]], "invalid option")
-
-checkmessage([[x = print .. "a"]], "concatenate")
-checkmessage([[x = "a" .. false]], "concatenate")
-checkmessage([[x = {} .. 2]], "concatenate")
-
-checkmessage("getmetatable(io.stdin).__gc()", "no value")
-
-checkmessage([[
-local Var
-local function main()
-  NoSuchName (function() Var=0 end)
-end
-main()
-]], "global 'NoSuchName'")
-print'+'
-
-a = {}; setmetatable(a, {__index = string})
-checkmessage("a:sub()", "bad self")
-checkmessage("string.sub('a', {})", "#2")
-checkmessage("('a'):sub{}", "#1")
-
-checkmessage("table.sort({1,2,3}, table.sort)", "'table.sort'")
-checkmessage("string.gsub('s', 's', setmetatable)", "'setmetatable'")
-
--- tests for errors in coroutines
-
-local function f (n)
-  local c = coroutine.create(f)
-  local a,b = coroutine.resume(c)
-  return b
-end
-assert(string.find(f(), "C stack overflow"))
-
-checkmessage("coroutine.yield()", "outside a coroutine")
-
-f = coroutine.wrap(function () table.sort({1,2,3}, coroutine.yield) end)
-checkerr("yield across", f)
-
-
--- testing size of 'source' info; size of buffer for that info is
--- LUA_IDSIZE, declared as 60 in luaconf. Get one position for '\0'.
-idsize = 60 - 1
-local function checksize (source)
-  -- syntax error
-  local _, msg = load("x", source)
-  msg = string.match(msg, "^([^:]*):")   -- get source (1st part before ':')
-  assert(msg:len() <= idsize)
-end
-
-for i = 60 - 10, 60 + 10 do   -- check border cases around 60
-  checksize("@" .. string.rep("x", i))   -- file names
-  checksize(string.rep("x", i - 10))     -- string sources
-  checksize("=" .. string.rep("x", i))   -- exact sources
-end
-
-
--- testing line error
-
-local function lineerror (s, l)
-  local err,msg = pcall(load(s))
-  local line = string.match(msg, ":(%d+):")
-  assert((line and line+0) == l)
-end
-
-lineerror("local a\n for i=1,'a' do \n print(i) \n end", 2)
-lineerror("\n local a \n for k,v in 3 \n do \n print(k) \n end", 3)
-lineerror("\n\n for k,v in \n 3 \n do \n print(k) \n end", 4)
-lineerror("function a.x.y ()\na=a+1\nend", 1)
-
-lineerror("a = \na\n+\n{}", 3)
-lineerror("a = \n3\n+\n(\n4\n/\nprint)", 6)
-lineerror("a = \nprint\n+\n(\n4\n/\n7)", 3)
-
-lineerror("a\n=\n-\n\nprint\n;", 3)
-
-lineerror([[
-a
-(
-23)
-]], 1)
-
-lineerror([[
-local a = {x = 13}
-a
-.
-x
-(
-23
-)
-]], 2)
-
-lineerror([[
-local a = {x = 13}
-a
-.
-x
-(
-23 + a
-)
-]], 6)
-
-local p = [[
-  function g() f() end
-  function f(x) error('a', X) end
-g()
-]]
-X=3;lineerror((p), 3)
-X=0;lineerror((p), nil)
-X=1;lineerror((p), 2)
-X=2;lineerror((p), 1)
-
-
-if not _soft then
-  -- several tests that exaust the Lua stack
-  collectgarbage()
-  print"testing stack overflow"
-  C = 0
-  local l = debug.getinfo(1, "l").currentline; function y () C=C+1; y() end
-
-  local function checkstackmessage (m)
-    return (string.find(m, "^.-:%d+: stack overflow"))
-  end
-  -- repeated stack overflows (to check stack recovery)
-  assert(checkstackmessage(doit('y()')))
-  print('+')
-  assert(checkstackmessage(doit('y()')))
-  print('+')
-  assert(checkstackmessage(doit('y()')))
-  print('+')
-
-
-  -- error lines in stack overflow
-  C = 0
-  local l1
-  local function g(x)
-    l1 = debug.getinfo(x, "l").currentline; y()
-  end
-  local _, stackmsg = xpcall(g, debug.traceback, 1)
-  print('+')
-  local stack = {}
-  for line in string.gmatch(stackmsg, "[^\n]*") do
-    local curr = string.match(line, ":(%d+):")
-    if curr then table.insert(stack, tonumber(curr)) end
-  end
-  local i=1
-  while stack[i] ~= l1 do
-    assert(stack[i] == l)
-    i = i+1
-  end
-  assert(i > 15)
-
-
-  -- error in error handling
-  local res, msg = xpcall(error, error)
-  assert(not res and type(msg) == 'string')
-  print('+')
-
-  local function f (x)
-    if x==0 then error('a\n')
-    else
-      local aux = function () return f(x-1) end
-      local a,b = xpcall(aux, aux)
-      return a,b
-    end
-  end
-  f(3)
-
-  local function loop (x,y,z) return 1 + loop(x, y, z) end
- 
-  local res, msg = xpcall(loop, function (m)
-    assert(string.find(m, "stack overflow"))
-    checkerr("error handling", loop)
-    assert(math.sin(0) == 0)
-    return 15
-  end)
-  assert(msg == 15)
-
-  local f = function ()
-    for i = 999900, 1000000, 1 do table.unpack({}, 1, i) end
-  end
-  checkerr("too many results", f)
-
-end
-
-
-do
-  -- non string messages
-  local t = {}
-  local res, msg = pcall(function () error(t) end)
-  assert(not res and msg == t)
-
-  res, msg = pcall(function () error(nil) end)
-  assert(not res and msg == nil)
-
-  local function f() error{msg='x'} end
-  res, msg = xpcall(f, function (r) return {msg=r.msg..'y'} end)
-  assert(msg.msg == 'xy')
-
-  -- 'assert' with extra arguments
-  res, msg = pcall(assert, false, "X", t)
-  assert(not res and msg == "X")
- 
-  -- 'assert' with no message
-  res, msg = pcall(function () assert(false) end)
-  local line = string.match(msg, "%w+%.lua:(%d+): assertion failed!$")
-  assert(tonumber(line) == debug.getinfo(1, "l").currentline - 2)
-
-  -- 'assert' with non-string messages
-  res, msg = pcall(assert, false, t)
-  assert(not res and msg == t)
-
-  res, msg = pcall(assert, nil, nil)
-  assert(not res and msg == nil)
-
-  -- 'assert' without arguments
-  res, msg = pcall(assert)
-  assert(not res and string.find(msg, "value expected"))
-end
-
--- xpcall with arguments
-a, b, c = xpcall(string.find, error, "alo", "al")
-assert(a and b == 1 and c == 2)
-a, b, c = xpcall(string.find, function (x) return {} end, true, "al")
-assert(not a and type(b) == "table" and c == nil)
-
-
-print("testing tokens in error messages")
-checksyntax("syntax error", "", "error", 1)
-checksyntax("1.000", "", "1.000", 1)
-checksyntax("[[a]]", "", "[[a]]", 1)
-checksyntax("'aa'", "", "'aa'", 1)
-checksyntax("while << do end", "", "<<", 1)
-checksyntax("for >> do end", "", ">>", 1)
-
--- test invalid non-printable char in a chunk
-checksyntax("a\1a = 1", "", "<\\1>", 1)
-
--- test 255 as first char in a chunk
-checksyntax("\255a = 1", "", "<\\255>", 1)
-
-doit('I = load("a=9+"); a=3')
-assert(a==3 and I == nil)
-print('+')
-
-lim = 1000
-if _soft then lim = 100 end
-for i=1,lim do
-  doit('a = ')
-  doit('a = 4+nil')
-end
-
-
--- testing syntax limits
-
-local maxClevel = 200    -- LUAI_MAXCCALLS (in llimits.h)
-
-local function testrep (init, rep, close, repc)
-  local s = init .. string.rep(rep, maxClevel - 10) .. close ..
-               string.rep(repc, maxClevel - 10)
-  assert(load(s))   -- 190 levels is OK
-  s = init .. string.rep(rep, maxClevel + 1)
-  checkmessage(s, "too many C levels")
-end
-
-testrep("local a; a", ",a", "= 1", ",1")    -- multiple assignment
-testrep("local a; a=", "{", "0", "}")
-testrep("local a; a=", "(", "2", ")")
-testrep("local a; ", "a(", "2", ")")
-testrep("", "do ", "", " end")
-testrep("", "while a do ", "", " end")
-testrep("local a; ", "if a then else ", "", " end")
-testrep("", "function foo () ", "", " end")
-testrep("local a; a=", "a..", "a", "")
-testrep("local a; a=", "a^", "a", "")
-
-checkmessage("a = f(x" .. string.rep(",x", 260) .. ")", "too many registers")
-
-
--- testing other limits
-
--- upvalues
-local lim = 127
-local  s = "local function fooA ()\n  local "
-for j = 1,lim do
-  s = s.."a"..j..", "
-end
-s = s.."b,c\n"
-s = s.."local function fooB ()\n  local "
-for j = 1,lim do
-  s = s.."b"..j..", "
-end
-s = s.."b\n"
-s = s.."function fooC () return b+c"
-local c = 1+2
-for j = 1,lim do
-  s = s.."+a"..j.."+b"..j
-  c = c + 2
-end
-s = s.."\nend  end end"
-local a,b = load(s)
-assert(c > 255 and string.find(b, "too many upvalues") and
-       string.find(b, "line 5"))
-
--- local variables
-s = "\nfunction foo ()\n  local "
-for j = 1,300 do
-  s = s.."a"..j..", "
-end
-s = s.."b\n"
-local a,b = load(s)
-assert(string.find(b, "line 2") and string.find(b, "too many local variables"))
-
-mt.__index = oldmm
-
-print('OK')

testes/events.lua

@@ -1,456 +0,0 @@
--- $Id: events.lua,v 1.45 2016/12/21 19:23:02 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print('testing metatables')
-
-local debug = require'debug'
-
-X = 20; B = 30
-
-_ENV = setmetatable({}, {__index=_G})
-
-collectgarbage()
-
-X = X+10
-assert(X == 30 and _G.X == 20)
-B = false
-assert(B == false)
-B = nil
-assert(B == 30)
-
-assert(getmetatable{} == nil)
-assert(getmetatable(4) == nil)
-assert(getmetatable(nil) == nil)
-a={name = "NAME"}; setmetatable(a, {__metatable = "xuxu",
-                    __tostring=function(x) return x.name end})
-assert(getmetatable(a) == "xuxu")
-assert(tostring(a) == "NAME")
--- cannot change a protected metatable
-assert(pcall(setmetatable, a, {}) == false)
-a.name = "gororoba"
-assert(tostring(a) == "gororoba")
-
-local a, t = {10,20,30; x="10", y="20"}, {}
-assert(setmetatable(a,t) == a)
-assert(getmetatable(a) == t)
-assert(setmetatable(a,nil) == a)
-assert(getmetatable(a) == nil)
-assert(setmetatable(a,t) == a)
-
-
-function f (t, i, e)
-  assert(not e)
-  local p = rawget(t, "parent")
-  return (p and p[i]+3), "dummy return"
-end
-
-t.__index = f
-
-a.parent = {z=25, x=12, [4] = 24}
-assert(a[1] == 10 and a.z == 28 and a[4] == 27 and a.x == "10")
-
-collectgarbage()
-
-a = setmetatable({}, t)
-function f(t, i, v) rawset(t, i, v-3) end
-setmetatable(t, t)   -- causes a bug in 5.1 !
-t.__newindex = f
-a[1] = 30; a.x = "101"; a[5] = 200
-assert(a[1] == 27 and a.x == 98 and a[5] == 197)
-
-do    -- bug in Lua 5.3.2
-  local mt = {}
-  mt.__newindex = mt
-  local t = setmetatable({}, mt)
-  t[1] = 10     -- will segfault on some machines
-  assert(mt[1] == 10)
-end
-
-
-local c = {}
-a = setmetatable({}, t)
-t.__newindex = c
-a[1] = 10; a[2] = 20; a[3] = 90
-assert(c[1] == 10 and c[2] == 20 and c[3] == 90)
-
-
-do
-  local a;
-  a = setmetatable({}, {__index = setmetatable({},
-                     {__index = setmetatable({},
-                     {__index = function (_,n) return a[n-3]+4, "lixo" end})})})
-  a[0] = 20
-  for i=0,10 do
-    assert(a[i*3] == 20 + i*4)
-  end
-end
-
-
-do  -- newindex
-  local foi
-  local a = {}
-  for i=1,10 do a[i] = 0; a['a'..i] = 0; end
-  setmetatable(a, {__newindex = function (t,k,v) foi=true; rawset(t,k,v) end})
-  foi = false; a[1]=0; assert(not foi)
-  foi = false; a['a1']=0; assert(not foi)
-  foi = false; a['a11']=0; assert(foi)
-  foi = false; a[11]=0; assert(foi)
-  foi = false; a[1]=nil; assert(not foi)
-  foi = false; a[1]=nil; assert(foi)
-end
-
-
-setmetatable(t, nil)
-function f (t, ...) return t, {...} end
-t.__call = f
-
-do
-  local x,y = a(table.unpack{'a', 1})
-  assert(x==a and y[1]=='a' and y[2]==1 and y[3]==nil)
-  x,y = a()
-  assert(x==a and y[1]==nil)
-end
-
-
-local b = setmetatable({}, t)
-setmetatable(b,t)
-
-function f(op)
-  return function (...) cap = {[0] = op, ...} ; return (...) end
-end
-t.__add = f("add")
-t.__sub = f("sub")
-t.__mul = f("mul")
-t.__div = f("div")
-t.__idiv = f("idiv")
-t.__mod = f("mod")
-t.__unm = f("unm")
-t.__pow = f("pow")
-t.__len = f("len")
-t.__band = f("band")
-t.__bor = f("bor")
-t.__bxor = f("bxor")
-t.__shl = f("shl")
-t.__shr = f("shr")
-t.__bnot = f("bnot")
-
-assert(b+5 == b)
-assert(cap[0] == "add" and cap[1] == b and cap[2] == 5 and cap[3]==nil)
-assert(b+'5' == b)
-assert(cap[0] == "add" and cap[1] == b and cap[2] == '5' and cap[3]==nil)
-assert(5+b == 5)
-assert(cap[0] == "add" and cap[1] == 5 and cap[2] == b and cap[3]==nil)
-assert('5'+b == '5')
-assert(cap[0] == "add" and cap[1] == '5' and cap[2] == b and cap[3]==nil)
-b=b-3; assert(getmetatable(b) == t)
-assert(5-a == 5)
-assert(cap[0] == "sub" and cap[1] == 5 and cap[2] == a and cap[3]==nil)
-assert('5'-a == '5')
-assert(cap[0] == "sub" and cap[1] == '5' and cap[2] == a and cap[3]==nil)
-assert(a*a == a)
-assert(cap[0] == "mul" and cap[1] == a and cap[2] == a and cap[3]==nil)
-assert(a/0 == a)
-assert(cap[0] == "div" and cap[1] == a and cap[2] == 0 and cap[3]==nil)
-assert(a%2 == a)
-assert(cap[0] == "mod" and cap[1] == a and cap[2] == 2 and cap[3]==nil)
-assert(a // (1/0) == a)
-assert(cap[0] == "idiv" and cap[1] == a and cap[2] == 1/0 and cap[3]==nil)
-assert(a & "hi" == a)
-assert(cap[0] == "band" and cap[1] == a and cap[2] == "hi" and cap[3]==nil)
-assert(a | "hi" == a)
-assert(cap[0] == "bor" and cap[1] == a and cap[2] == "hi" and cap[3]==nil)
-assert("hi" ~ a == "hi")
-assert(cap[0] == "bxor" and cap[1] == "hi" and cap[2] == a and cap[3]==nil)
-assert(-a == a)
-assert(cap[0] == "unm" and cap[1] == a)
-assert(a^4 == a)
-assert(cap[0] == "pow" and cap[1] == a and cap[2] == 4 and cap[3]==nil)
-assert(a^'4' == a)
-assert(cap[0] == "pow" and cap[1] == a and cap[2] == '4' and cap[3]==nil)
-assert(4^a == 4)
-assert(cap[0] == "pow" and cap[1] == 4 and cap[2] == a and cap[3]==nil)
-assert('4'^a == '4')
-assert(cap[0] == "pow" and cap[1] == '4' and cap[2] == a and cap[3]==nil)
-assert(#a == a)
-assert(cap[0] == "len" and cap[1] == a)
-assert(~a == a)
-assert(cap[0] == "bnot" and cap[1] == a)
-assert(a << 3 == a)
-assert(cap[0] == "shl" and cap[1] == a and cap[2] == 3)
-assert(1.5 >> a == 1.5)
-assert(cap[0] == "shr" and cap[1] == 1.5 and cap[2] == a)
-
-
--- test for rawlen
-t = setmetatable({1,2,3}, {__len = function () return 10 end})
-assert(#t == 10 and rawlen(t) == 3)
-assert(rawlen"abc" == 3)
-assert(not pcall(rawlen, io.stdin))
-assert(not pcall(rawlen, 34))
-assert(not pcall(rawlen))
-
--- rawlen for long strings
-assert(rawlen(string.rep('a', 1000)) == 1000)
-
-
-t = {}
-t.__lt = function (a,b,c)
-  collectgarbage()
-  assert(c == nil)
-  if type(a) == 'table' then a = a.x end
-  if type(b) == 'table' then b = b.x end
- return a<b, "dummy"
-end
-
-function Op(x) return setmetatable({x=x}, t) end
-
-local function test ()
-  assert(not(Op(1)<Op(1)) and (Op(1)<Op(2)) and not(Op(2)<Op(1)))
-  assert(not(1 < Op(1)) and (Op(1) < 2) and not(2 < Op(1)))
-  assert(not(Op('a')<Op('a')) and (Op('a')<Op('b')) and not(Op('b')<Op('a')))
-  assert(not('a' < Op('a')) and (Op('a') < 'b') and not(Op('b') < Op('a')))
-  assert((Op(1)<=Op(1)) and (Op(1)<=Op(2)) and not(Op(2)<=Op(1)))
-  assert((Op('a')<=Op('a')) and (Op('a')<=Op('b')) and not(Op('b')<=Op('a')))
-  assert(not(Op(1)>Op(1)) and not(Op(1)>Op(2)) and (Op(2)>Op(1)))
-  assert(not(Op('a')>Op('a')) and not(Op('a')>Op('b')) and (Op('b')>Op('a')))
-  assert((Op(1)>=Op(1)) and not(Op(1)>=Op(2)) and (Op(2)>=Op(1)))
-  assert((1 >= Op(1)) and not(1 >= Op(2)) and (Op(2) >= 1))
-  assert((Op('a')>=Op('a')) and not(Op('a')>=Op('b')) and (Op('b')>=Op('a')))
-  assert(('a' >= Op('a')) and not(Op('a') >= 'b') and (Op('b') >= Op('a')))
-end
-
-test()
-
-t.__le = function (a,b,c)
-  assert(c == nil)
-  if type(a) == 'table' then a = a.x end
-  if type(b) == 'table' then b = b.x end
- return a<=b, "dummy"
-end
-
-test()  -- retest comparisons, now using both `lt' and `le'
-
-
--- test `partial order'
-
-local function rawSet(x)
-  local y = {}
-  for _,k in pairs(x) do y[k] = 1 end
-  return y
-end
-
-local function Set(x)
-  return setmetatable(rawSet(x), t)
-end
-
-t.__lt = function (a,b)
-  for k in pairs(a) do
-    if not b[k] then return false end
-    b[k] = nil
-  end
-  return next(b) ~= nil
-end
-
-t.__le = nil
-
-assert(Set{1,2,3} < Set{1,2,3,4})
-assert(not(Set{1,2,3,4} < Set{1,2,3,4}))
-assert((Set{1,2,3,4} <= Set{1,2,3,4}))
-assert((Set{1,2,3,4} >= Set{1,2,3,4}))
-assert((Set{1,3} <= Set{3,5}))   -- wrong!! model needs a `le' method ;-)
-
-t.__le = function (a,b)
-  for k in pairs(a) do
-    if not b[k] then return false end
-  end
-  return true
-end
-
-assert(not (Set{1,3} <= Set{3,5}))   -- now its OK!
-assert(not(Set{1,3} <= Set{3,5}))
-assert(not(Set{1,3} >= Set{3,5}))
-
-t.__eq = function (a,b)
-  for k in pairs(a) do
-    if not b[k] then return false end
-    b[k] = nil
-  end
-  return next(b) == nil
-end
-
-local s = Set{1,3,5}
-assert(s == Set{3,5,1})
-assert(not rawequal(s, Set{3,5,1}))
-assert(rawequal(s, s))
-assert(Set{1,3,5,1} == rawSet{3,5,1})
-assert(rawSet{1,3,5,1} == Set{3,5,1})
-assert(Set{1,3,5} ~= Set{3,5,1,6})
-
--- '__eq' is not used for table accesses
-t[Set{1,3,5}] = 1
-assert(t[Set{1,3,5}] == nil)
-
-
-if not T then
-  (Message or print)('\n >>> testC not active: skipping tests for \z
-userdata equality <<<\n')
-else
-  local u1 = T.newuserdata(0)
-  local u2 = T.newuserdata(0)
-  local u3 = T.newuserdata(0)
-  assert(u1 ~= u2 and u1 ~= u3)
-  debug.setuservalue(u1, 1);
-  debug.setuservalue(u2, 2);
-  debug.setuservalue(u3, 1);
-  debug.setmetatable(u1, {__eq = function (a, b)
-    return debug.getuservalue(a) == debug.getuservalue(b)
-  end})
-  debug.setmetatable(u2, {__eq = function (a, b)
-    return true
-  end})
-  assert(u1 == u3 and u3 == u1 and u1 ~= u2)
-  assert(u2 == u1 and u2 == u3 and u3 == u2)
-  assert(u2 ~= {})   -- different types cannot be equal
-end
-
-
-t.__concat = function (a,b,c)
-  assert(c == nil)
-  if type(a) == 'table' then a = a.val end
-  if type(b) == 'table' then b = b.val end
-  if A then return a..b
-  else
-    return setmetatable({val=a..b}, t)
-  end
-end
-
-c = {val="c"}; setmetatable(c, t)
-d = {val="d"}; setmetatable(d, t)
-
-A = true
-assert(c..d == 'cd')
-assert(0 .."a".."b"..c..d.."e".."f"..(5+3).."g" == "0abcdef8g")
-
-A = false
-assert((c..d..c..d).val == 'cdcd')
-x = c..d
-assert(getmetatable(x) == t and x.val == 'cd')
-x = 0 .."a".."b"..c..d.."e".."f".."g"
-assert(x.val == "0abcdefg")
-
-
--- concat metamethod x numbers (bug in 5.1.1)
-c = {}
-local x
-setmetatable(c, {__concat = function (a,b)
-  assert(type(a) == "number" and b == c or type(b) == "number" and a == c)
-  return c
-end})
-assert(c..5 == c and 5 .. c == c)
-assert(4 .. c .. 5 == c and 4 .. 5 .. 6 .. 7 .. c == c)
-
-
--- test comparison compatibilities
-local t1, t2, c, d
-t1 = {};  c = {}; setmetatable(c, t1)
-d = {}
-t1.__eq = function () return true end
-t1.__lt = function () return true end
-setmetatable(d, t1)
-assert(c == d and c < d and not(d <= c))
-t2 = {}
-t2.__eq = t1.__eq
-t2.__lt = t1.__lt
-setmetatable(d, t2)
-assert(c == d and c < d and not(d <= c))
-
-
-
--- test for several levels of calls
-local i
-local tt = {
-  __call = function (t, ...)
-    i = i+1
-    if t.f then return t.f(...)
-    else return {...}
-    end
-  end
-}
-
-local a = setmetatable({}, tt)
-local b = setmetatable({f=a}, tt)
-local c = setmetatable({f=b}, tt)
-
-i = 0
-x = c(3,4,5)
-assert(i == 3 and x[1] == 3 and x[3] == 5)
-
-
-assert(_G.X == 20)
-
-print'+'
-
-local _g = _G
-_ENV = setmetatable({}, {__index=function (_,k) return _g[k] end})
-
-
-a = {}
-rawset(a, "x", 1, 2, 3)
-assert(a.x == 1 and rawget(a, "x", 3) == 1)
-
-print '+'
-
--- testing metatables for basic types
-mt = {__index = function (a,b) return a+b end,
-      __len = function (x) return math.floor(x) end}
-debug.setmetatable(10, mt)
-assert(getmetatable(-2) == mt)
-assert((10)[3] == 13)
-assert((10)["3"] == 13)
-assert(#3.45 == 3)
-debug.setmetatable(23, nil)
-assert(getmetatable(-2) == nil)
-
-debug.setmetatable(true, mt)
-assert(getmetatable(false) == mt)
-mt.__index = function (a,b) return a or b end
-assert((true)[false] == true)
-assert((false)[false] == false)
-debug.setmetatable(false, nil)
-assert(getmetatable(true) == nil)
-
-debug.setmetatable(nil, mt)
-assert(getmetatable(nil) == mt)
-mt.__add = function (a,b) return (a or 0) + (b or 0) end
-assert(10 + nil == 10)
-assert(nil + 23 == 23)
-assert(nil + nil == 0)
-debug.setmetatable(nil, nil)
-assert(getmetatable(nil) == nil)
-
-debug.setmetatable(nil, {})
-
-
--- loops in delegation
-a = {}; setmetatable(a, a); a.__index = a; a.__newindex = a
-assert(not pcall(function (a,b) return a[b] end, a, 10))
-assert(not pcall(function (a,b,c) a[b] = c end, a, 10, true))
-
--- bug in 5.1
-T, K, V = nil
-grandparent = {}
-grandparent.__newindex = function(t,k,v) T=t; K=k; V=v end
-
-parent = {}
-parent.__newindex = parent
-setmetatable(parent, grandparent)
-
-child = setmetatable({}, parent)
-child.foo = 10      --> CRASH (on some machines)
-assert(T == parent and K == "foo" and V == 10)
-
-print 'OK'
-
-return 12
-
-

testes/files.lua

@@ -1,793 +0,0 @@
--- $Id: files.lua,v 1.95 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-local debug = require "debug"
-
-local maxint = math.maxinteger
-
-assert(type(os.getenv"PATH") == "string")
-
-assert(io.input(io.stdin) == io.stdin)
-assert(not pcall(io.input, "non-existent-file"))
-assert(io.output(io.stdout) == io.stdout)
-
-
-local function testerr (msg, f, ...)
-  local stat, err = pcall(f, ...)
-  return (not stat and string.find(err, msg, 1, true))
-end
-
-
-local function checkerr (msg, f, ...)
-  assert(testerr(msg, f, ...))
-end
-
-
--- cannot close standard files
-assert(not io.close(io.stdin) and
-       not io.stdout:close() and
-       not io.stderr:close())
-
-
-assert(type(io.input()) == "userdata" and io.type(io.output()) == "file")
-assert(type(io.stdin) == "userdata" and io.type(io.stderr) == "file")
-assert(not io.type(8))
-local a = {}; setmetatable(a, {})
-assert(not io.type(a))
-
-assert(getmetatable(io.input()).__name == "FILE*")
-
-local a,b,c = io.open('xuxu_nao_existe')
-assert(not a and type(b) == "string" and type(c) == "number")
-
-a,b,c = io.open('/a/b/c/d', 'w')
-assert(not a and type(b) == "string" and type(c) == "number")
-
-local file = os.tmpname()
-local f, msg = io.open(file, "w")
-if not f then
-  (Message or print)("'os.tmpname' file cannot be open; skipping file tests")
-
-else  --{  most tests here need tmpname
-f:close()
-
-print('testing i/o')
-
-local otherfile = os.tmpname()
-
-checkerr("invalid mode", io.open, file, "rw")
-checkerr("invalid mode", io.open, file, "rb+")
-checkerr("invalid mode", io.open, file, "r+bk")
-checkerr("invalid mode", io.open, file, "")
-checkerr("invalid mode", io.open, file, "+")
-checkerr("invalid mode", io.open, file, "b")
-assert(io.open(file, "r+b")):close()
-assert(io.open(file, "r+")):close()
-assert(io.open(file, "rb")):close()
-
-assert(os.setlocale('C', 'all'))
-
-io.input(io.stdin); io.output(io.stdout);
-
-os.remove(file)
-assert(not loadfile(file))
-checkerr("", dofile, file)
-assert(not io.open(file))
-io.output(file)
-assert(io.output() ~= io.stdout)
-
-if not _port then   -- invalid seek
-  local status, msg, code = io.stdin:seek("set", 1000)
-  assert(not status and type(msg) == "string" and type(code) == "number")
-end
-
-assert(io.output():seek() == 0)
-assert(io.write("alo alo"):seek() == string.len("alo alo"))
-assert(io.output():seek("cur", -3) == string.len("alo alo")-3)
-assert(io.write("joao"))
-assert(io.output():seek("end") == string.len("alo joao"))
-
-assert(io.output():seek("set") == 0)
-
-assert(io.write('"álo"', "{a}\n", "second line\n", "third line \n"))
-assert(io.write('çfourth_line'))
-io.output(io.stdout)
-collectgarbage()  -- file should be closed by GC
-assert(io.input() == io.stdin and rawequal(io.output(), io.stdout))
-print('+')
-
--- test GC for files
-collectgarbage()
-for i=1,120 do
-  for i=1,5 do
-    io.input(file)
-    assert(io.open(file, 'r'))
-    io.lines(file)
-  end
-  collectgarbage()
-end
-
-io.input():close()
-io.close()
-
-assert(os.rename(file, otherfile))
-assert(not os.rename(file, otherfile))
-
-io.output(io.open(otherfile, "ab"))
-assert(io.write("\n\n\t\t  ", 3450, "\n"));
-io.close()
-
--- test writing/reading numbers
-f = assert(io.open(file, "w"))
-f:write(maxint, '\n')
-f:write(string.format("0X%x\n", maxint))
-f:write("0xABCp-3", '\n')
-f:write(0, '\n')
-f:write(-maxint, '\n')
-f:write(string.format("0x%X\n", -maxint))
-f:write("-0xABCp-3", '\n')
-assert(f:close())
-f = assert(io.open(file, "r"))
-assert(f:read("n") == maxint)
-assert(f:read("n") == maxint)
-assert(f:read("n") == 0xABCp-3)
-assert(f:read("n") == 0)
-assert(f:read("*n") == -maxint)            -- test old format (with '*')
-assert(f:read("n") == -maxint)
-assert(f:read("*n") == -0xABCp-3)            -- test old format (with '*')
-assert(f:close())
-assert(os.remove(file))
-
--- test yielding during 'dofile'
-f = assert(io.open(file, "w"))
-f:write[[
-local x, z = coroutine.yield(10)
-local y = coroutine.yield(20)
-return x + y * z
-]]
-assert(f:close())
-f = coroutine.wrap(dofile)
-assert(f(file) == 10)
-print(f(100, 101) == 20)
-assert(f(200) == 100 + 200 * 101)
-assert(os.remove(file))
-
-
-f = assert(io.open(file, "w"))
--- test number termination
-f:write[[
--12.3-	-0xffff+  .3|5.E-3X  +234e+13E 0xDEADBEEFDEADBEEFx
-0x1.13Ap+3e
-]]
--- very long number
-f:write("1234"); for i = 1, 1000 do f:write("0") end;  f:write("\n")
--- invalid sequences (must read and discard valid prefixes)
-f:write[[
-.e+	0.e;	--;  0xX;
-]]
-assert(f:close())
-f = assert(io.open(file, "r"))
-assert(f:read("n") == -12.3); assert(f:read(1) == "-")
-assert(f:read("n") == -0xffff); assert(f:read(2) == "+ ")
-assert(f:read("n") == 0.3); assert(f:read(1) == "|")
-assert(f:read("n") == 5e-3); assert(f:read(1) == "X")
-assert(f:read("n") == 234e13); assert(f:read(1) == "E")
-assert(f:read("n") == 0Xdeadbeefdeadbeef); assert(f:read(2) == "x\n")
-assert(f:read("n") == 0x1.13aP3); assert(f:read(1) == "e")
-
-do   -- attempt to read too long number
-  assert(f:read("n") == nil)  -- fails
-  local s = f:read("L")   -- read rest of line
-  assert(string.find(s, "^00*\n$"))  -- lots of 0's left
-end
-
-assert(not f:read("n")); assert(f:read(2) == "e+")
-assert(not f:read("n")); assert(f:read(1) == ";")
-assert(not f:read("n")); assert(f:read(2) == "-;")
-assert(not f:read("n")); assert(f:read(1) == "X")
-assert(not f:read("n")); assert(f:read(1) == ";")
-assert(not f:read("n")); assert(not f:read(0))   -- end of file
-assert(f:close())
-assert(os.remove(file))
-
-
--- test line generators
-assert(not pcall(io.lines, "non-existent-file"))
-assert(os.rename(otherfile, file))
-io.output(otherfile)
-local n = 0
-local f = io.lines(file)
-while f() do n = n + 1 end;
-assert(n == 6)   -- number of lines in the file
-checkerr("file is already closed", f)
-checkerr("file is already closed", f)
--- copy from file to otherfile
-n = 0
-for l in io.lines(file) do io.write(l, "\n"); n = n + 1 end
-io.close()
-assert(n == 6)
--- copy from otherfile back to file
-local f = assert(io.open(otherfile))
-assert(io.type(f) == "file")
-io.output(file)
-assert(not io.output():read())
-n = 0
-for l in f:lines() do io.write(l, "\n"); n = n + 1 end
-assert(tostring(f):sub(1, 5) == "file ")
-assert(f:close()); io.close()
-assert(n == 6)
-checkerr("closed file", io.close, f)
-assert(tostring(f) == "file (closed)")
-assert(io.type(f) == "closed file")
-io.input(file)
-f = io.open(otherfile):lines()
-n = 0
-for l in io.lines() do assert(l == f()); n = n + 1 end
-f = nil; collectgarbage()
-assert(n == 6)
-assert(os.remove(otherfile))
-
-do  -- bug in 5.3.1
-  io.output(otherfile)
-  io.write(string.rep("a", 300), "\n")
-  io.close()
-  local t ={}; for i = 1, 250 do t[i] = 1 end
-  t = {io.lines(otherfile, table.unpack(t))()}
-  -- everything ok here
-  assert(#t == 250 and t[1] == 'a' and t[#t] == 'a')
-  t[#t + 1] = 1    -- one too many
-  checkerr("too many arguments", io.lines, otherfile, table.unpack(t))
-  collectgarbage()   -- ensure 'otherfile' is closed
-  assert(os.remove(otherfile))
-end
-
-io.input(file)
-do  -- test error returns
-  local a,b,c = io.input():write("xuxu")
-  assert(not a and type(b) == "string" and type(c) == "number")
-end
-checkerr("invalid format", io.read, "x")
-assert(io.read(0) == "")   -- not eof
-assert(io.read(5, 'l') == '"álo"')
-assert(io.read(0) == "")
-assert(io.read() == "second line")
-local x = io.input():seek()
-assert(io.read() == "third line ")
-assert(io.input():seek("set", x))
-assert(io.read('L') == "third line \n")
-assert(io.read(1) == "ç")
-assert(io.read(string.len"fourth_line") == "fourth_line")
-assert(io.input():seek("cur", -string.len"fourth_line"))
-assert(io.read() == "fourth_line")
-assert(io.read() == "")  -- empty line
-assert(io.read('n') == 3450)
-assert(io.read(1) == '\n')
-assert(io.read(0) == nil)  -- end of file
-assert(io.read(1) == nil)  -- end of file
-assert(io.read(30000) == nil)  -- end of file
-assert(({io.read(1)})[2] == nil)
-assert(io.read() == nil)  -- end of file
-assert(({io.read()})[2] == nil)
-assert(io.read('n') == nil)  -- end of file
-assert(({io.read('n')})[2] == nil)
-assert(io.read('a') == '')  -- end of file (OK for 'a')
-assert(io.read('a') == '')  -- end of file (OK for 'a')
-collectgarbage()
-print('+')
-io.close(io.input())
-checkerr(" input file is closed", io.read)
-
-assert(os.remove(file))
-
-local t = '0123456789'
-for i=1,10 do t = t..t; end
-assert(string.len(t) == 10*2^10)
-
-io.output(file)
-io.write("alo"):write("\n")
-io.close()
-checkerr(" output file is closed", io.write)
-local f = io.open(file, "a+b")
-io.output(f)
-collectgarbage()
-
-assert(io.write(' ' .. t .. ' '))
-assert(io.write(';', 'end of file\n'))
-f:flush(); io.flush()
-f:close()
-print('+')
-
-io.input(file)
-assert(io.read() == "alo")
-assert(io.read(1) == ' ')
-assert(io.read(string.len(t)) == t)
-assert(io.read(1) == ' ')
-assert(io.read(0))
-assert(io.read('a') == ';end of file\n')
-assert(io.read(0) == nil)
-assert(io.close(io.input()))
-
-
--- test errors in read/write
-do
-  local function ismsg (m)
-    -- error message is not a code number
-    return (type(m) == "string" and tonumber(m) == nil)
-  end
-
-  -- read
-  local f = io.open(file, "w")
-  local r, m, c = f:read()
-  assert(not r and ismsg(m) and type(c) == "number")
-  assert(f:close())
-  -- write
-  f = io.open(file, "r")
-  r, m, c = f:write("whatever")
-  assert(not r and ismsg(m) and type(c) == "number")
-  assert(f:close())
-  -- lines
-  f = io.open(file, "w")
-  r, m = pcall(f:lines())
-  assert(r == false and ismsg(m))
-  assert(f:close())
-end
-
-assert(os.remove(file))
-
--- test for L format
-io.output(file); io.write"\n\nline\nother":close()
-io.input(file)
-assert(io.read"L" == "\n")
-assert(io.read"L" == "\n")
-assert(io.read"L" == "line\n")
-assert(io.read"L" == "other")
-assert(io.read"L" == nil)
-io.input():close()
-
-local f = assert(io.open(file))
-local s = ""
-for l in f:lines("L") do s = s .. l end
-assert(s == "\n\nline\nother")
-f:close()
-
-io.input(file)
-s = ""
-for l in io.lines(nil, "L") do s = s .. l end
-assert(s == "\n\nline\nother")
-io.input():close()
-
-s = ""
-for l in io.lines(file, "L") do s = s .. l end
-assert(s == "\n\nline\nother")
-
-s = ""
-for l in io.lines(file, "l") do s = s .. l end
-assert(s == "lineother")
-
-io.output(file); io.write"a = 10 + 34\na = 2*a\na = -a\n":close()
-local t = {}
-load(io.lines(file, "L"), nil, nil, t)()
-assert(t.a == -((10 + 34) * 2))
-
-
--- test for multipe arguments in 'lines'
-io.output(file); io.write"0123456789\n":close()
-for a,b in io.lines(file, 1, 1) do
-  if a == "\n" then assert(b == nil)
-  else assert(tonumber(a) == tonumber(b) - 1)
-  end
-end
-
-for a,b,c in io.lines(file, 1, 2, "a") do
-  assert(a == "0" and b == "12" and c == "3456789\n")
-end
-
-for a,b,c in io.lines(file, "a", 0, 1) do
-  if a == "" then break end
-  assert(a == "0123456789\n" and b == nil and c == nil)
-end
-collectgarbage()   -- to close file in previous iteration
-
-io.output(file); io.write"00\n10\n20\n30\n40\n":close()
-for a, b in io.lines(file, "n", "n") do
-  if a == 40 then assert(b == nil)
-  else assert(a == b - 10)
-  end
-end
-
-
--- test load x lines
-io.output(file);
-io.write[[
-local y
-= X
-X =
-X *
-2 +
-X;
-X =
-X
--                                   y;
-]]:close()
-_G.X = 1
-assert(not load(io.lines(file)))
-collectgarbage()   -- to close file in previous iteration
-load(io.lines(file, "L"))()
-assert(_G.X == 2)
-load(io.lines(file, 1))()
-assert(_G.X == 4)
-load(io.lines(file, 3))()
-assert(_G.X == 8)
-
-print('+')
-
-local x1 = "string\n\n\\com \"\"''coisas [[estranhas]] ]]'"
-io.output(file)
-assert(io.write(string.format("x2 = %q\n-- comment without ending EOS", x1)))
-io.close()
-assert(loadfile(file))()
-assert(x1 == x2)
-print('+')
-assert(os.remove(file))
-assert(not os.remove(file))
-assert(not os.remove(otherfile))
-
--- testing loadfile
-local function testloadfile (s, expres)
-  io.output(file)
-  if s then io.write(s) end
-  io.close()
-  local res = assert(loadfile(file))()
-  assert(os.remove(file))
-  assert(res == expres)
-end
-
--- loading empty file
-testloadfile(nil, nil)
-
--- loading file with initial comment without end of line
-testloadfile("# a non-ending comment", nil)
-
-
--- checking Unicode BOM in files
-testloadfile("\xEF\xBB\xBF# some comment\nreturn 234", 234)
-testloadfile("\xEF\xBB\xBFreturn 239", 239)
-testloadfile("\xEF\xBB\xBF", nil)   -- empty file with a BOM
-
-
--- checking line numbers in files with initial comments
-testloadfile("# a comment\nreturn require'debug'.getinfo(1).currentline", 2)
-
-
--- loading binary file
-io.output(io.open(file, "wb"))
-assert(io.write(string.dump(function () return 10, '\0alo\255', 'hi' end)))
-io.close()
-a, b, c = assert(loadfile(file))()
-assert(a == 10 and b == "\0alo\255" and c == "hi")
-assert(os.remove(file))
-
--- bug in 5.2.1
-do
-  io.output(io.open(file, "wb"))
-  -- save function with no upvalues
-  assert(io.write(string.dump(function () return 1 end)))
-  io.close()
-  f = assert(loadfile(file, "b", {}))
-  assert(type(f) == "function" and f() == 1)
-  assert(os.remove(file))
-end
-
--- loading binary file with initial comment
-io.output(io.open(file, "wb"))
-assert(io.write("#this is a comment for a binary file\0\n",
-                string.dump(function () return 20, '\0\0\0' end)))
-io.close()
-a, b, c = assert(loadfile(file))()
-assert(a == 20 and b == "\0\0\0" and c == nil)
-assert(os.remove(file))
-
-
--- 'loadfile' with 'env'
-do
-  local f = io.open(file, 'w')
-  f:write[[
-    if (...) then a = 15; return b, c, d
-    else return _ENV
-    end
-  ]]
-  f:close()
-  local t = {b = 12, c = "xuxu", d = print}
-  local f = assert(loadfile(file, 't', t))
-  local b, c, d = f(1)
-  assert(t.a == 15 and b == 12 and c == t.c and d == print)
-  assert(f() == t)
-  f = assert(loadfile(file, 't', nil))
-  assert(f() == nil)
-  f = assert(loadfile(file))
-  assert(f() == _G)
-  assert(os.remove(file))
-end
-
-
--- 'loadfile' x modes
-do
-  io.open(file, 'w'):write("return 10"):close()
-  local s, m = loadfile(file, 'b')
-  assert(not s and string.find(m, "a text chunk"))
-  io.open(file, 'w'):write("\27 return 10"):close()
-  local s, m = loadfile(file, 't')
-  assert(not s and string.find(m, "a binary chunk"))
-  assert(os.remove(file))
-end
-
-
-io.output(file)
-assert(io.write("qualquer coisa\n"))
-assert(io.write("mais qualquer coisa"))
-io.close()
-assert(io.output(assert(io.open(otherfile, 'wb')))
-       :write("outra coisa\0\1\3\0\0\0\0\255\0")
-       :close())
-
-local filehandle = assert(io.open(file, 'r+'))
-local otherfilehandle = assert(io.open(otherfile, 'rb'))
-assert(filehandle ~= otherfilehandle)
-assert(type(filehandle) == "userdata")
-assert(filehandle:read('l') == "qualquer coisa")
-io.input(otherfilehandle)
-assert(io.read(string.len"outra coisa") == "outra coisa")
-assert(filehandle:read('l') == "mais qualquer coisa")
-filehandle:close();
-assert(type(filehandle) == "userdata")
-io.input(otherfilehandle)
-assert(io.read(4) == "\0\1\3\0")
-assert(io.read(3) == "\0\0\0")
-assert(io.read(0) == "")        -- 255 is not eof
-assert(io.read(1) == "\255")
-assert(io.read('a') == "\0")
-assert(not io.read(0))
-assert(otherfilehandle == io.input())
-otherfilehandle:close()
-assert(os.remove(file))
-assert(os.remove(otherfile))
-collectgarbage()
-
-io.output(file)
-  :write[[
- 123.4	-56e-2  not a number
-second line
-third line
-
-and the rest of the file
-]]
-  :close()
-io.input(file)
-local _,a,b,c,d,e,h,__ = io.read(1, 'n', 'n', 'l', 'l', 'l', 'a', 10)
-assert(io.close(io.input()))
-assert(_ == ' ' and __ == nil)
-assert(type(a) == 'number' and a==123.4 and b==-56e-2)
-assert(d=='second line' and e=='third line')
-assert(h==[[
-
-and the rest of the file
-]])
-assert(os.remove(file))
-collectgarbage()
-
--- testing buffers
-do
-  local f = assert(io.open(file, "w"))
-  local fr = assert(io.open(file, "r"))
-  assert(f:setvbuf("full", 2000))
-  f:write("x")
-  assert(fr:read("all") == "")  -- full buffer; output not written yet
-  f:close()
-  fr:seek("set")
-  assert(fr:read("all") == "x")   -- `close' flushes it
-  f = assert(io.open(file), "w")
-  assert(f:setvbuf("no"))
-  f:write("x")
-  fr:seek("set")
-  assert(fr:read("all") == "x")  -- no buffer; output is ready
-  f:close()
-  f = assert(io.open(file, "a"))
-  assert(f:setvbuf("line"))
-  f:write("x")
-  fr:seek("set", 1)
-  assert(fr:read("all") == "")   -- line buffer; no output without `\n'
-  f:write("a\n"):seek("set", 1)
-  assert(fr:read("all") == "xa\n")  -- now we have a whole line
-  f:close(); fr:close()
-  assert(os.remove(file))
-end
-
-
-if not _soft then
-  print("testing large files (> BUFSIZ)")
-  io.output(file)
-  for i=1,5001 do io.write('0123456789123') end
-  io.write('\n12346'):close()
-  io.input(file)
-  local x = io.read('a')
-  io.input():seek('set', 0)
-  local y = io.read(30001)..io.read(1005)..io.read(0)..
-            io.read(1)..io.read(100003)
-  assert(x == y and string.len(x) == 5001*13 + 6)
-  io.input():seek('set', 0)
-  y = io.read()  -- huge line
-  assert(x == y..'\n'..io.read())
-  assert(io.read() == nil)
-  io.close(io.input())
-  assert(os.remove(file))
-  x = nil; y = nil
-end
-
-if not _port then
-  local progname
-  do  -- get name of running executable
-    local arg = arg or _ARG
-    local i = 0
-    while arg[i] do i = i - 1 end
-    progname = '"' .. arg[i + 1] .. '"'
-  end
-  print("testing popen/pclose and execute")
-  local tests = {
-    -- command,   what,  code
-    {"ls > /dev/null", "ok"},
-    {"not-to-be-found-command", "exit"},
-    {"exit 3", "exit", 3},
-    {"exit 129", "exit", 129},
-    {"kill -s HUP $$", "signal", 1},
-    {"kill -s KILL $$", "signal", 9},
-    {"sh -c 'kill -s HUP $$'", "exit"},
-    {progname .. ' -e " "', "ok"},
-    {progname .. ' -e "os.exit(0, true)"', "ok"},
-    {progname .. ' -e "os.exit(20, true)"', "exit", 20},
-  }
-  print("\n(some error messages are expected now)")
-  for _, v in ipairs(tests) do
-    local x, y, z = io.popen(v[1]):close()
-    local x1, y1, z1 = os.execute(v[1])
-    assert(x == x1 and y == y1 and z == z1)
-    if v[2] == "ok" then
-      assert(x and y == 'exit' and z == 0)
-    else
-      assert(not x and y == v[2])   -- correct status and 'what'
-      -- correct code if known (but always different from 0)
-      assert((v[3] == nil and z > 0) or v[3] == z)
-    end
-  end
-end
-
-
--- testing tmpfile
-f = io.tmpfile()
-assert(io.type(f) == "file")
-f:write("alo")
-f:seek("set")
-assert(f:read"a" == "alo")
-
-end --}
-
-print'+'
-
-print("testing date/time")
-
-assert(os.date("") == "")
-assert(os.date("!") == "")
-assert(os.date("\0\0") == "\0\0")
-assert(os.date("!\0\0") == "\0\0")
-local x = string.rep("a", 10000)
-assert(os.date(x) == x)
-local t = os.time()
-D = os.date("*t", t)
-assert(os.date(string.rep("%d", 1000), t) ==
-       string.rep(os.date("%d", t), 1000))
-assert(os.date(string.rep("%", 200)) == string.rep("%", 100))
-
-local t = os.time()
-D = os.date("*t", t)
-load(os.date([[assert(D.year==%Y and D.month==%m and D.day==%d and
-  D.hour==%H and D.min==%M and D.sec==%S and
-  D.wday==%w+1 and D.yday==%j and type(D.isdst) == 'boolean')]], t))()
-
-checkerr("invalid conversion specifier", os.date, "%")
-checkerr("invalid conversion specifier", os.date, "%9")
-checkerr("invalid conversion specifier", os.date, "%")
-checkerr("invalid conversion specifier", os.date, "%O")
-checkerr("invalid conversion specifier", os.date, "%E")
-checkerr("invalid conversion specifier", os.date, "%Ea")
-
-checkerr("not an integer", os.time, {year=1000, month=1, day=1, hour='x'})
-checkerr("not an integer", os.time, {year=1000, month=1, day=1, hour=1.5})
-
-checkerr("missing", os.time, {hour = 12})   -- missing date
-
-if not _port then
-  -- test Posix-specific modifiers
-  assert(type(os.date("%Ex")) == 'string')
-  assert(type(os.date("%Oy")) == 'string')
-
-
-  -- test out-of-range dates (at least for Unix)
-  if maxint >= 2^62 then  -- cannot do these tests in Small Lua
-    -- no arith overflows
-    checkerr("out-of-bound", os.time, {year = -maxint, month = 1, day = 1})
-    if string.packsize("i") == 4 then   -- 4-byte ints
-      if testerr("out-of-bound", os.date, "%Y", 2^40) then
-        -- time_t has 4 bytes and therefore cannot represent year 4000
-        print("  4-byte time_t")
-        checkerr("cannot be represented", os.time, {year=4000, month=1, day=1})
-      else
-        -- time_t has 8 bytes; an int year cannot represent a huge time
-        print("  8-byte time_t")
-        checkerr("cannot be represented", os.date, "%Y", 2^60)
-        -- it should have no problems with year 4000
-        assert(tonumber(os.time{year=4000, month=1, day=1}))
-      end
-    else    -- 8-byte ints
-      -- assume time_t has 8 bytes too
-      print("  8-byte time_t")
-      assert(tonumber(os.date("%Y", 2^60)))
-      -- but still cannot represent a huge year
-      checkerr("cannot be represented", os.time, {year=2^60, month=1, day=1})
-    end
-  end
-end
-
-
-D = os.date("!*t", t)
-load(os.date([[!assert(D.year==%Y and D.month==%m and D.day==%d and
-  D.hour==%H and D.min==%M and D.sec==%S and
-  D.wday==%w+1 and D.yday==%j and type(D.isdst) == 'boolean')]], t))()
-
-do
-  local D = os.date("*t")
-  local t = os.time(D)
-  assert(type(D.isdst) == 'boolean')
-  D.isdst = nil
-  local t1 = os.time(D)
-  assert(t == t1)   -- if isdst is absent uses correct default
-end
-
-t = os.time(D)
-D.year = D.year-1;
-local t1 = os.time(D)
--- allow for leap years
-assert(math.abs(os.difftime(t,t1)/(24*3600) - 365) < 2)
-
--- should not take more than 1 second to execute these two lines
-t = os.time()
-t1 = os.time(os.date("*t"))
-local diff = os.difftime(t1,t)
-assert(0 <= diff and diff <= 1)
-diff = os.difftime(t,t1)
-assert(-1 <= diff and diff <= 0)
-
-local t1 = os.time{year=2000, month=10, day=1, hour=23, min=12}
-local t2 = os.time{year=2000, month=10, day=1, hour=23, min=10, sec=19}
-assert(os.difftime(t1,t2) == 60*2-19)
-
--- since 5.3.3, 'os.time' normalizes table fields
-t1 = {year = 2005, month = 1, day = 1, hour = 1, min = 0, sec = -3602}
-os.time(t1)
-assert(t1.day == 31 and t1.month == 12 and t1.year == 2004 and
-       t1.hour == 23 and t1.min == 59 and t1.sec == 58 and
-       t1.yday == 366)
-
-io.output(io.stdout)
-local t = os.date('%d %m %Y %H %M %S')
-local d, m, a, h, min, s = string.match(t,
-                             "(%d+) (%d+) (%d+) (%d+) (%d+) (%d+)")
-d = tonumber(d)
-m = tonumber(m)
-a = tonumber(a)
-h = tonumber(h)
-min = tonumber(min)
-s = tonumber(s)
-io.write(string.format('test done on %2.2d/%2.2d/%d', d, m, a))
-io.write(string.format(', at %2.2d:%2.2d:%2.2d\n', h, min, s))
-io.write(string.format('%s\n', _VERSION))
-
-

testes/gc.lua

@@ -1,624 +0,0 @@
--- $Id: gc.lua,v 1.72 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print('testing garbage collection')
-
-local debug = require"debug"
-
-collectgarbage()
-
-assert(collectgarbage("isrunning"))
-
-local function gcinfo () return collectgarbage"count" * 1024 end
-
-
--- test weird parameters
-do
-  -- save original parameters
-  local a = collectgarbage("setpause", 200)
-  local b = collectgarbage("setstepmul", 200)
-  local t = {0, 2, 10, 90, 500, 5000, 30000, 0x7ffffffe}
-  for i = 1, #t do
-    local p = t[i]
-    for j = 1, #t do
-      local m = t[j]
-      collectgarbage("setpause", p)
-      collectgarbage("setstepmul", m)
-      collectgarbage("step", 0)
-      collectgarbage("step", 10000)
-    end
-  end
-  -- restore original parameters
-  collectgarbage("setpause", a)
-  collectgarbage("setstepmul", b)
-  collectgarbage()
-end
-
-
-_G["while"] = 234
-
-limit = 5000
-
-
-local function GC1 ()
-  local u
-  local b     -- must be declared after 'u' (to be above it in the stack)
-  local finish = false
-  u = setmetatable({}, {__gc = function () finish = true end})
-  b = {34}
-  repeat u = {} until finish
-  assert(b[1] == 34)   -- 'u' was collected, but 'b' was not
-
-  finish = false; local i = 1
-  u = setmetatable({}, {__gc = function () finish = true end})
-  repeat i = i + 1; u = tostring(i) .. tostring(i) until finish
-  assert(b[1] == 34)   -- 'u' was collected, but 'b' was not
-
-  finish = false
-  u = setmetatable({}, {__gc = function () finish = true end})
-  repeat local i; u = function () return i end until finish
-  assert(b[1] == 34)   -- 'u' was collected, but 'b' was not
-end
-
-local function GC2 ()
-  local u
-  local finish = false
-  u = {setmetatable({}, {__gc = function () finish = true end})}
-  b = {34}
-  repeat u = {{}} until finish
-  assert(b[1] == 34)   -- 'u' was collected, but 'b' was not
-
-  finish = false; local i = 1
-  u = {setmetatable({}, {__gc = function () finish = true end})}
-  repeat i = i + 1; u = {tostring(i) .. tostring(i)} until finish
-  assert(b[1] == 34)   -- 'u' was collected, but 'b' was not
-
-  finish = false
-  u = {setmetatable({}, {__gc = function () finish = true end})}
-  repeat local i; u = {function () return i end} until finish
-  assert(b[1] == 34)   -- 'u' was collected, but 'b' was not
-end
-
-local function GC()  GC1(); GC2() end
-
-
-contCreate = 0
-
-print('tables')
-while contCreate <= limit do
-  local a = {}; a = nil
-  contCreate = contCreate+1
-end
-
-a = "a"
-
-contCreate = 0
-print('strings')
-while contCreate <= limit do
-  a = contCreate .. "b";
-  a = string.gsub(a, '(%d%d*)', string.upper)
-  a = "a"
-  contCreate = contCreate+1
-end
-
-
-contCreate = 0
-
-a = {}
-
-print('functions')
-function a:test ()
-  while contCreate <= limit do
-    load(string.format("function temp(a) return 'a%d' end", contCreate), "")()
-    assert(temp() == string.format('a%d', contCreate))
-    contCreate = contCreate+1
-  end
-end
-
-a:test()
-
--- collection of functions without locals, globals, etc.
-do local f = function () end end
-
-
-print("functions with errors")
-prog = [[
-do
-  a = 10;
-  function foo(x,y)
-    a = sin(a+0.456-0.23e-12);
-    return function (z) return sin(%x+z) end
-  end
-  local x = function (w) a=a+w; end
-end
-]]
-do
-  local step = 1
-  if _soft then step = 13 end
-  for i=1, string.len(prog), step do
-    for j=i, string.len(prog), step do
-      pcall(load(string.sub(prog, i, j), ""))
-    end
-  end
-end
-
-foo = nil
-print('long strings')
-x = "01234567890123456789012345678901234567890123456789012345678901234567890123456789"
-assert(string.len(x)==80)
-s = ''
-n = 0
-k = math.min(300, (math.maxinteger // 80) // 2)
-while n < k do s = s..x; n=n+1; j=tostring(n)  end
-assert(string.len(s) == k*80)
-s = string.sub(s, 1, 10000)
-s, i = string.gsub(s, '(%d%d%d%d)', '')
-assert(i==10000 // 4)
-s = nil
-x = nil
-
-assert(_G["while"] == 234)
-
-
-print("steps")
-
-print("steps (2)")
-
-local function dosteps (siz)
-  assert(not collectgarbage("isrunning"))
-  collectgarbage()
-  assert(not collectgarbage("isrunning"))
-  local a = {}
-  for i=1,100 do a[i] = {{}}; local b = {} end
-  local x = gcinfo()
-  local i = 0
-  repeat   -- do steps until it completes a collection cycle
-    i = i+1
-  until collectgarbage("step", siz)
-  assert(gcinfo() < x)
-  return i
-end
-
-collectgarbage"stop"
-
-if not _port then
-  -- test the "size" of basic GC steps (whatever they mean...)
-  assert(dosteps(0) > 10)
-  assert(dosteps(10) < dosteps(2))
-end
-
--- collector should do a full collection with so many steps
-assert(dosteps(20000) == 1)
-assert(collectgarbage("step", 20000) == true)
-assert(collectgarbage("step", 20000) == true)
-
-assert(not collectgarbage("isrunning"))
-collectgarbage"restart"
-assert(collectgarbage("isrunning"))
-
-
-if not _port then
-  -- test the pace of the collector
-  collectgarbage(); collectgarbage()
-  local x = gcinfo()
-  collectgarbage"stop"
-  assert(not collectgarbage("isrunning"))
-  repeat
-    local a = {}
-  until gcinfo() > 3 * x
-  collectgarbage"restart"
-  assert(collectgarbage("isrunning"))
-  repeat
-    local a = {}
-  until gcinfo() <= x * 2
-end
-
-
-print("clearing tables")
-lim = 15
-a = {}
--- fill a with `collectable' indices
-for i=1,lim do a[{}] = i end
-b = {}
-for k,v in pairs(a) do b[k]=v end
--- remove all indices and collect them
-for n in pairs(b) do
-  a[n] = nil
-  assert(type(n) == 'table' and next(n) == nil)
-  collectgarbage()
-end
-b = nil
-collectgarbage()
-for n in pairs(a) do error'cannot be here' end
-for i=1,lim do a[i] = i end
-for i=1,lim do assert(a[i] == i) end
-
-
-print('weak tables')
-a = {}; setmetatable(a, {__mode = 'k'});
--- fill a with some `collectable' indices
-for i=1,lim do a[{}] = i end
--- and some non-collectable ones
-for i=1,lim do a[i] = i end
-for i=1,lim do local s=string.rep('@', i); a[s] = s..'#' end
-collectgarbage()
-local i = 0
-for k,v in pairs(a) do assert(k==v or k..'#'==v); i=i+1 end
-assert(i == 2*lim)
-
-a = {}; setmetatable(a, {__mode = 'v'});
-a[1] = string.rep('b', 21)
-collectgarbage()
-assert(a[1])   -- strings are *values*
-a[1] = nil
--- fill a with some `collectable' values (in both parts of the table)
-for i=1,lim do a[i] = {} end
-for i=1,lim do a[i..'x'] = {} end
--- and some non-collectable ones
-for i=1,lim do local t={}; a[t]=t end
-for i=1,lim do a[i+lim]=i..'x' end
-collectgarbage()
-local i = 0
-for k,v in pairs(a) do assert(k==v or k-lim..'x' == v); i=i+1 end
-assert(i == 2*lim)
-
-a = {}; setmetatable(a, {__mode = 'vk'});
-local x, y, z = {}, {}, {}
--- keep only some items
-a[1], a[2], a[3] = x, y, z
-a[string.rep('$', 11)] = string.rep('$', 11)
--- fill a with some `collectable' values
-for i=4,lim do a[i] = {} end
-for i=1,lim do a[{}] = i end
-for i=1,lim do local t={}; a[t]=t end
-collectgarbage()
-assert(next(a) ~= nil)
-local i = 0
-for k,v in pairs(a) do
-  assert((k == 1 and v == x) or
-         (k == 2 and v == y) or
-         (k == 3 and v == z) or k==v);
-  i = i+1
-end
-assert(i == 4)
-x,y,z=nil
-collectgarbage()
-assert(next(a) == string.rep('$', 11))
-
-
--- 'bug' in 5.1
-a = {}
-local t = {x = 10}
-local C = setmetatable({key = t}, {__mode = 'v'})
-local C1 = setmetatable({[t] = 1}, {__mode = 'k'})
-a.x = t  -- this should not prevent 't' from being removed from
-         -- weak table 'C' by the time 'a' is finalized
-
-setmetatable(a, {__gc = function (u)
-                          assert(C.key == nil)
-                          assert(type(next(C1)) == 'table')
-                          end})
-
-a, t = nil
-collectgarbage()
-collectgarbage()
-assert(next(C) == nil and next(C1) == nil)
-C, C1 = nil
-
-
--- ephemerons
-local mt = {__mode = 'k'}
-a = {{10},{20},{30},{40}}; setmetatable(a, mt)
-x = nil
-for i = 1, 100 do local n = {}; a[n] = {k = {x}}; x = n end
-GC()
-local n = x
-local i = 0
-while n do n = a[n].k[1]; i = i + 1 end
-assert(i == 100)
-x = nil
-GC()
-for i = 1, 4 do assert(a[i][1] == i * 10); a[i] = nil end
-assert(next(a) == nil)
-
-local K = {}
-a[K] = {}
-for i=1,10 do a[K][i] = {}; a[a[K][i]] = setmetatable({}, mt) end
-x = nil
-local k = 1
-for j = 1,100 do
-  local n = {}; local nk = k%10 + 1
-  a[a[K][nk]][n] = {x, k = k}; x = n; k = nk
-end
-GC()
-local n = x
-local i = 0
-while n do local t = a[a[K][k]][n]; n = t[1]; k = t.k; i = i + 1 end
-assert(i == 100)
-K = nil
-GC()
--- assert(next(a) == nil)
-
-
--- testing errors during GC
-do
-collectgarbage("stop")   -- stop collection
-local u = {}
-local s = {}; setmetatable(s, {__mode = 'k'})
-setmetatable(u, {__gc = function (o)
-  local i = s[o]
-  s[i] = true
-  assert(not s[i - 1])   -- check proper finalization order
-  if i == 8 then error("here") end   -- error during GC
-end})
-
-for i = 6, 10 do
-  local n = setmetatable({}, getmetatable(u))
-  s[n] = i
-end
-
-assert(not pcall(collectgarbage))
-for i = 8, 10 do assert(s[i]) end
-
-for i = 1, 5 do
-  local n = setmetatable({}, getmetatable(u))
-  s[n] = i
-end
-
-collectgarbage()
-for i = 1, 10 do assert(s[i]) end
-
-getmetatable(u).__gc = false
-
-
--- __gc errors with non-string messages
-setmetatable({}, {__gc = function () error{} end})
-local a, b = pcall(collectgarbage)
-assert(not a and type(b) == "string" and string.find(b, "error in __gc"))
-
-end
-print '+'
-
-
--- testing userdata
-if T==nil then
-  (Message or print)('\n >>> testC not active: skipping userdata GC tests <<<\n')
-
-else
-
-  local function newproxy(u)
-    return debug.setmetatable(T.newuserdata(0), debug.getmetatable(u))
-  end
-
-  collectgarbage("stop")   -- stop collection
-  local u = newproxy(nil)
-  debug.setmetatable(u, {__gc = true})
-  local s = 0
-  local a = {[u] = 0}; setmetatable(a, {__mode = 'vk'})
-  for i=1,10 do a[newproxy(u)] = i end
-  for k in pairs(a) do assert(getmetatable(k) == getmetatable(u)) end
-  local a1 = {}; for k,v in pairs(a) do a1[k] = v end
-  for k,v in pairs(a1) do a[v] = k end
-  for i =1,10 do assert(a[i]) end
-  getmetatable(u).a = a1
-  getmetatable(u).u = u
-  do
-    local u = u
-    getmetatable(u).__gc = function (o)
-      assert(a[o] == 10-s)
-      assert(a[10-s] == nil) -- udata already removed from weak table
-      assert(getmetatable(o) == getmetatable(u))
-    assert(getmetatable(o).a[o] == 10-s)
-      s=s+1
-    end
-  end
-  a1, u = nil
-  assert(next(a) ~= nil)
-  collectgarbage()
-  assert(s==11)
-  collectgarbage()
-  assert(next(a) == nil)  -- finalized keys are removed in two cycles
-end
-
-
--- __gc x weak tables
-local u = setmetatable({}, {__gc = true})
--- __gc metamethod should be collected before running
-setmetatable(getmetatable(u), {__mode = "v"})
-getmetatable(u).__gc = function (o) os.exit(1) end  -- cannot happen
-u = nil
-collectgarbage()
-
-local u = setmetatable({}, {__gc = true})
-local m = getmetatable(u)
-m.x = {[{0}] = 1; [0] = {1}}; setmetatable(m.x, {__mode = "kv"});
-m.__gc = function (o)
-  assert(next(getmetatable(o).x) == nil)
-  m = 10
-end
-u, m = nil
-collectgarbage()
-assert(m==10)
-
-
--- errors during collection
-u = setmetatable({}, {__gc = function () error "!!!" end})
-u = nil
-assert(not pcall(collectgarbage))
-
-
-if not _soft then
-  print("deep structures")
-  local a = {}
-  for i = 1,200000 do
-    a = {next = a}
-  end
-  collectgarbage()
-end
-
--- create many threads with self-references and open upvalues
-print("self-referenced threads")
-local thread_id = 0
-local threads = {}
-
-local function fn (thread)
-    local x = {}
-    threads[thread_id] = function()
-                             thread = x
-                         end
-    coroutine.yield()
-end
-
-while thread_id < 1000 do
-    local thread = coroutine.create(fn)
-    coroutine.resume(thread, thread)
-    thread_id = thread_id + 1
-end
-
-
--- Create a closure (function inside 'f') with an upvalue ('param') that
--- points (through a table) to the closure itself and to the thread
--- ('co' and the initial value of 'param') where closure is running.
--- Then, assert that table (and therefore everything else) will be
--- collected.
-do
-  local collected = false   -- to detect collection
-  collectgarbage(); collectgarbage("stop")
-  do
-    local function f (param) 
-      ;(function ()
-        assert(type(f) == 'function' and type(param) == 'thread')
-        param = {param, f}
-        setmetatable(param, {__gc = function () collected = true end})
-        coroutine.yield(100)
-      end)()
-    end
-    local co = coroutine.create(f)
-    assert(coroutine.resume(co, co))
-  end
-  -- Now, thread and closure are not reacheable any more;
-  -- two collections are needed to break cycle
-  collectgarbage()
-  assert(not collected)
-  collectgarbage()
-  assert(collected)
-  collectgarbage("restart")
-end
-
-
-do
-  collectgarbage()
-  collectgarbage"stop"
-  local x = gcinfo()
-  repeat
-    for i=1,1000 do _ENV.a = {} end
-    collectgarbage("step", 0)   -- steps should not unblock the collector
-  until gcinfo() > 2 * x
-  collectgarbage"restart"
-end
-
-
-if T then   -- tests for weird cases collecting upvalues
-
-  local function foo ()
-    local a = {x = 20}
-    coroutine.yield(function () return a.x end)  -- will run collector
-    assert(a.x == 20)   -- 'a' is 'ok'
-    a = {x = 30}   -- create a new object
-    assert(T.gccolor(a) == "white")   -- of course it is new...
-    coroutine.yield(100)   -- 'a' is still local to this thread
-  end
-
-  local t = setmetatable({}, {__mode = "kv"})
-  collectgarbage(); collectgarbage('stop')
-  -- create coroutine in a weak table, so it will never be marked
-  t.co = coroutine.wrap(foo)
-  local f = t.co()   -- create function to access local 'a'
-  T.gcstate("atomic")   -- ensure all objects are traversed
-  assert(T.gcstate() == "atomic")
-  assert(t.co() == 100)   -- resume coroutine, creating new table for 'a'
-  assert(T.gccolor(t.co) == "white")  -- thread was not traversed
-  T.gcstate("pause")   -- collect thread, but should mark 'a' before that
-  assert(t.co == nil and f() == 30)   -- ensure correct access to 'a'
-
-  collectgarbage("restart")
-
-  -- test barrier in sweep phase (advance cleaning of upvalue to white)
-  local u = T.newuserdata(0)   -- create a userdata
-  collectgarbage()
-  collectgarbage"stop"
-  T.gcstate"atomic"
-  T.gcstate"sweepallgc"
-  local x = {}
-  assert(T.gccolor(u) == "black")   -- upvalue is "old" (black)
-  assert(T.gccolor(x) == "white")   -- table is "new" (white)
-  debug.setuservalue(u, x)          -- trigger barrier
-  assert(T.gccolor(u) == "white")   -- upvalue changed to white
-  collectgarbage"restart"
-
-  print"+"
-end
-
-
-if T then
-  local debug = require "debug"
-  collectgarbage("stop")
-  local x = T.newuserdata(0)
-  local y = T.newuserdata(0)
-  debug.setmetatable(y, {__gc = true})   -- bless the new udata before...
-  debug.setmetatable(x, {__gc = true})   -- ...the old one
-  assert(T.gccolor(y) == "white")
-  T.checkmemory()
-  collectgarbage("restart")
-end
-
-
-if T then
-  print("emergency collections")
-  collectgarbage()
-  collectgarbage()
-  T.totalmem(T.totalmem() + 200)
-  for i=1,200 do local a = {} end
-  T.totalmem(0)
-  collectgarbage()
-  local t = T.totalmem("table")
-  local a = {{}, {}, {}}   -- create 4 new tables
-  assert(T.totalmem("table") == t + 4)
-  t = T.totalmem("function")
-  a = function () end   -- create 1 new closure
-  assert(T.totalmem("function") == t + 1)
-  t = T.totalmem("thread")
-  a = coroutine.create(function () end)   -- create 1 new coroutine
-  assert(T.totalmem("thread") == t + 1)
-end
-
--- create an object to be collected when state is closed
-do
-  local setmetatable,assert,type,print,getmetatable =
-        setmetatable,assert,type,print,getmetatable
-  local tt = {}
-  tt.__gc = function (o)
-    assert(getmetatable(o) == tt)
-    -- create new objects during GC
-    local a = 'xuxu'..(10+3)..'joao', {}
-    ___Glob = o  -- ressurect object!
-    setmetatable({}, tt)  -- creates a new one with same metatable
-    print(">>> closing state " .. "<<<\n")
-  end
-  local u = setmetatable({}, tt)
-  ___Glob = {u}   -- avoid object being collected before program end
-end
-
--- create several objects to raise errors when collected while closing state
-do
-  local mt = {__gc = function (o) return o + 1 end}
-  for i = 1,10 do
-    -- create object and preserve it until the end
-    table.insert(___Glob, setmetatable({}, mt))
-  end
-end
-
--- just to make sure
-assert(collectgarbage'isrunning')
-
-print('OK')

testes/goto.lua

@@ -1,232 +0,0 @@
--- $Id: goto.lua,v 1.13 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-collectgarbage()
-
-local function errmsg (code, m)
-  local st, msg = load(code)
-  assert(not st and string.find(msg, m))
-end
-
--- cannot see label inside block
-errmsg([[ goto l1; do ::l1:: end ]], "label 'l1'")
-errmsg([[ do ::l1:: end goto l1; ]], "label 'l1'")
-
--- repeated label
-errmsg([[ ::l1:: ::l1:: ]], "label 'l1'")
-
-
--- undefined label
-errmsg([[ goto l1; local aa ::l1:: ::l2:: print(3) ]], "local 'aa'")
-
--- jumping over variable definition
-errmsg([[
-do local bb, cc; goto l1; end
-local aa
-::l1:: print(3)
-]], "local 'aa'")
-
--- jumping into a block
-errmsg([[ do ::l1:: end goto l1 ]], "label 'l1'")
-errmsg([[ goto l1 do ::l1:: end ]], "label 'l1'")
-
--- cannot continue a repeat-until with variables
-errmsg([[
-  repeat
-    if x then goto cont end
-    local xuxu = 10
-    ::cont::
-  until xuxu < x
-]], "local 'xuxu'")
-
--- simple gotos
-local x
-do
-  local y = 12
-  goto l1
-  ::l2:: x = x + 1; goto l3
-  ::l1:: x = y; goto l2
-end
-::l3:: ::l3_1:: assert(x == 13)
-
-
--- long labels
-do
-  local prog = [[
-  do
-    local a = 1
-    goto l%sa; a = a + 1
-   ::l%sa:: a = a + 10
-    goto l%sb; a = a + 2
-   ::l%sb:: a = a + 20
-    return a
-  end
-  ]]
-  local label = string.rep("0123456789", 40)
-  prog = string.format(prog, label, label, label, label)
-  assert(assert(load(prog))() == 31)
-end
-
--- goto to correct label when nested
-do goto l3; ::l3:: end   -- does not loop jumping to previous label 'l3'
-
--- ok to jump over local dec. to end of block
-do
-  goto l1
-  local a = 23
-  x = a
-  ::l1::;
-end
-
-while true do
-  goto l4
-  goto l1  -- ok to jump over local dec. to end of block
-  goto l1  -- multiple uses of same label
-  local x = 45
-  ::l1:: ;;;
-end
-::l4:: assert(x == 13)
-
-if print then
-  goto l1   -- ok to jump over local dec. to end of block
-  error("should not be here")
-  goto l2   -- ok to jump over local dec. to end of block
-  local x
-  ::l1:: ; ::l2:: ;;
-else end
-
--- to repeat a label in a different function is OK
-local function foo ()
-  local a = {}
-  goto l3
-  ::l1:: a[#a + 1] = 1; goto l2;
-  ::l2:: a[#a + 1] = 2; goto l5;
-  ::l3::
-  ::l3a:: a[#a + 1] = 3; goto l1;
-  ::l4:: a[#a + 1] = 4; goto l6;
-  ::l5:: a[#a + 1] = 5; goto l4;
-  ::l6:: assert(a[1] == 3 and a[2] == 1 and a[3] == 2 and
-              a[4] == 5 and a[5] == 4)
-  if not a[6] then a[6] = true; goto l3a end   -- do it twice
-end
-
-::l6:: foo()
-
-
-do   -- bug in 5.2 -> 5.3.2
-  local x
-  ::L1::
-  local y             -- cannot join this SETNIL with previous one
-  assert(y == nil)
-  y = true
-  if x == nil then
-    x = 1
-    goto L1
-  else
-    x = x + 1
-  end
-  assert(x == 2 and y == true)
-end
-
---------------------------------------------------------------------------------
--- testing closing of upvalues
-
-local debug = require 'debug'
-
-local function foo ()
-  local t = {}
-  do
-  local i = 1
-  local a, b, c, d
-  t[1] = function () return a, b, c, d end
-  ::l1::
-  local b
-  do
-    local c
-    t[#t + 1] = function () return a, b, c, d end    -- t[2], t[4], t[6]
-    if i > 2 then goto l2 end
-    do
-      local d
-      t[#t + 1] = function () return a, b, c, d end   -- t[3], t[5]
-      i = i + 1
-      local a
-      goto l1
-    end
-  end
-  end
-  ::l2:: return t
-end
-
-local a = foo()
-assert(#a == 6)
-
--- all functions share same 'a'
-for i = 2, 6 do
-  assert(debug.upvalueid(a[1], 1) == debug.upvalueid(a[i], 1))
-end
-
--- 'b' and 'c' are shared among some of them
-for i = 2, 6 do
-  -- only a[1] uses external 'b'/'b'
-  assert(debug.upvalueid(a[1], 2) ~= debug.upvalueid(a[i], 2))
-  assert(debug.upvalueid(a[1], 3) ~= debug.upvalueid(a[i], 3))
-end
-
-for i = 3, 5, 2 do
-  -- inner functions share 'b'/'c' with previous ones
-  assert(debug.upvalueid(a[i], 2) == debug.upvalueid(a[i - 1], 2))
-  assert(debug.upvalueid(a[i], 3) == debug.upvalueid(a[i - 1], 3))
-  -- but not with next ones
-  assert(debug.upvalueid(a[i], 2) ~= debug.upvalueid(a[i + 1], 2))
-  assert(debug.upvalueid(a[i], 3) ~= debug.upvalueid(a[i + 1], 3))
-end
-
--- only external 'd' is shared
-for i = 2, 6, 2 do
-  assert(debug.upvalueid(a[1], 4) == debug.upvalueid(a[i], 4))
-end
-
--- internal 'd's are all different
-for i = 3, 5, 2 do
-  for j = 1, 6 do
-    assert((debug.upvalueid(a[i], 4) == debug.upvalueid(a[j], 4))
-      == (i == j))
-  end
-end
-
---------------------------------------------------------------------------------
--- testing if x goto optimizations
-
-local function testG (a)
-  if a == 1 then
-    goto l1
-    error("should never be here!")
-  elseif a == 2 then goto l2
-  elseif a == 3 then goto l3
-  elseif a == 4 then
-    goto l1  -- go to inside the block
-    error("should never be here!")
-    ::l1:: a = a + 1   -- must go to 'if' end
-  else
-    goto l4
-    ::l4a:: a = a * 2; goto l4b
-    error("should never be here!")
-    ::l4:: goto l4a
-    error("should never be here!")
-    ::l4b::
-  end
-  do return a end
-  ::l2:: do return "2" end
-  ::l3:: do return "3" end
-  ::l1:: return "1"
-end
-
-assert(testG(1) == "1")
-assert(testG(2) == "2")
-assert(testG(3) == "3")
-assert(testG(4) == 5)
-assert(testG(5) == 10)
---------------------------------------------------------------------------------
-
-
-print'OK'

testes/heavy.lua

@@ -1,72 +0,0 @@
--- $Id: heavy.lua,v 1.4 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print("creating a string too long")
-do
-  local st, msg = pcall(function ()
-    local a = "x"
-    while true do
-      a = a .. a.. a.. a.. a.. a.. a.. a.. a.. a
-       .. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
-       .. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
-       .. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
-       .. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
-       .. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
-       .. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
-       .. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
-       .. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
-       .. a .. a.. a.. a.. a.. a.. a.. a.. a.. a
-       print(string.format("string with %d bytes", #a))
-    end
-  end)
-  assert(not st and
-    (string.find(msg, "string length overflow") or
-     string.find(msg, "not enough memory")))
-end
-print('+')
-
-
-local function loadrep (x, what)
-  local p = 1<<20
-  local s = string.rep(x, p)
-  local count = 0
-  local function f()
-    count = count + p
-    if count % (0x80*p) == 0 then
-      io.stderr:write("(", string.format("0x%x", count), ")")
-    end
-    return s
-  end
-  local st, msg = load(f, "=big")
-  print(string.format("\ntotal: 0x%x %s", count, what))
-  return st, msg
-end
-
-
-print("loading chunk with too many lines")
-do
-  local st, msg = loadrep("\n", "lines")
-  assert(not st and string.find(msg, "too many lines"))
-end
-print('+')
-
-
-print("loading chunk with huge identifier")
-do
-  local st, msg = loadrep("a", "chars")
-  assert(not st and 
-    (string.find(msg, "lexical element too long") or
-     string.find(msg, "not enough memory")))
-end
-print('+')
-
-
-print("loading chunk with too many instructions")
-do
-  local st, msg = loadrep("a = 10; ", "instructions")
-  print(st, msg)
-end
-print('+')
-
-
-print "OK"

testes/libs/P1/dummy

@@ -1,2 +0,0 @@
-# This is a dummy file just to make git keep the otherwise empty
-# directory 'P1' in the repository.

testes/libs/lib1.c

@@ -1,44 +0,0 @@
-#include "lua.h"
-#include "lauxlib.h"
-
-static int id (lua_State *L) {
-  return lua_gettop(L);
-}
-
-
-static const struct luaL_Reg funcs[] = {
-  {"id", id},
-  {NULL, NULL}
-};
-
-
-/* function used by lib11.c */
-LUAMOD_API int lib1_export (lua_State *L) {
-  lua_pushstring(L, "exported");
-  return 1;
-}
-
-
-LUAMOD_API int onefunction (lua_State *L) {
-  luaL_checkversion(L);
-  lua_settop(L, 2);
-  lua_pushvalue(L, 1);
-  return 2;
-}
-
-
-LUAMOD_API int anotherfunc (lua_State *L) {
-  luaL_checkversion(L);
-  lua_pushfstring(L, "%d%%%d\n", (int)lua_tointeger(L, 1),
-                                 (int)lua_tointeger(L, 2));
-  return 1;
-} 
-
-
-LUAMOD_API int luaopen_lib1_sub (lua_State *L) {
-  lua_setglobal(L, "y");  /* 2nd arg: extra value (file name) */
-  lua_setglobal(L, "x");  /* 1st arg: module name */
-  luaL_newlib(L, funcs);
-  return 1;
-}
-

testes/libs/lib11.c

@@ -1,10 +0,0 @@
-#include "lua.h"
-
-/* function from lib1.c */
-int lib1_export (lua_State *L);
-
-LUAMOD_API int luaopen_lib11 (lua_State *L) {
-  return lib1_export(L);
-}
-
-

testes/libs/lib2.c

@@ -1,23 +0,0 @@
-#include "lua.h"
-#include "lauxlib.h"
-
-static int id (lua_State *L) {
-  return lua_gettop(L);
-}
-
-
-static const struct luaL_Reg funcs[] = {
-  {"id", id},
-  {NULL, NULL}
-};
-
-
-LUAMOD_API int luaopen_lib2 (lua_State *L) {
-  lua_settop(L, 2);
-  lua_setglobal(L, "y");  /* y gets 2nd parameter */
-  lua_setglobal(L, "x");  /* x gets 1st parameter */
-  luaL_newlib(L, funcs);
-  return 1;
-}
-
-

testes/libs/lib21.c

@@ -1,10 +0,0 @@
-#include "lua.h"
-
-
-int luaopen_lib2 (lua_State *L);
-
-LUAMOD_API int luaopen_lib21 (lua_State *L) {
-  return luaopen_lib2(L);
-}
-
-

testes/libs/makefile

@@ -1,26 +0,0 @@
-# change this variable to point to the directory with Lua headers
-# of the version being tested
-LUA_DIR = ../../
-
-CC = gcc
-
-# compilation should generate Dynamic-Link Libraries
-CFLAGS = -Wall -std=gnu99 -O2 -I$(LUA_DIR) -fPIC -shared
-
-# libraries used by the tests
-all: lib1.so lib11.so lib2.so lib21.so lib2-v2.so
-
-lib1.so: lib1.c
-	$(CC) $(CFLAGS) -o lib1.so lib1.c
-
-lib11.so: lib11.c
-	$(CC) $(CFLAGS) -o lib11.so lib11.c
-
-lib2.so: lib2.c
-	$(CC) $(CFLAGS) -o lib2.so lib2.c
-
-lib21.so: lib21.c
-	$(CC) $(CFLAGS) -o lib21.so lib21.c
-
-lib2-v2.so: lib2.so
-	mv lib2.so ./lib2-v2.so

testes/literals.lua

@@ -1,302 +0,0 @@
--- $Id: literals.lua,v 1.36 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print('testing scanner')
-
-local debug = require "debug"
-
-
-local function dostring (x) return assert(load(x), "")() end
-
-dostring("x \v\f = \t\r 'a\0a' \v\f\f")
-assert(x == 'a\0a' and string.len(x) == 3)
-
--- escape sequences
-assert('\n\"\'\\' == [[
-
-"'\]])
-
-assert(string.find("\a\b\f\n\r\t\v", "^%c%c%c%c%c%c%c$"))
-
--- assume ASCII just for tests:
-assert("\09912" == 'c12')
-assert("\99ab" == 'cab')
-assert("\099" == '\99')
-assert("\099\n" == 'c\10')
-assert('\0\0\0alo' == '\0' .. '\0\0' .. 'alo')
-
-assert(010 .. 020 .. -030 == "1020-30")
-
--- hexadecimal escapes
-assert("\x00\x05\x10\x1f\x3C\xfF\xe8" == "\0\5\16\31\60\255\232")
-
-local function lexstring (x, y, n)
-  local f = assert(load('return ' .. x ..
-            ', require"debug".getinfo(1).currentline', ''))
-  local s, l = f()
-  assert(s == y and l == n)
-end
-
-lexstring("'abc\\z  \n   efg'", "abcefg", 2)
-lexstring("'abc\\z  \n\n\n'", "abc", 4)
-lexstring("'\\z  \n\t\f\v\n'",  "", 3)
-lexstring("[[\nalo\nalo\n\n]]", "alo\nalo\n\n", 5)
-lexstring("[[\nalo\ralo\n\n]]", "alo\nalo\n\n", 5)
-lexstring("[[\nalo\ralo\r\n]]", "alo\nalo\n", 4)
-lexstring("[[\ralo\n\ralo\r\n]]", "alo\nalo\n", 4)
-lexstring("[[alo]\n]alo]]", "alo]\n]alo", 2)
-
-assert("abc\z
-        def\z
-        ghi\z
-       " == 'abcdefghi')
-
-
--- UTF-8 sequences
-assert("\u{0}\u{00000000}\x00\0" == string.char(0, 0, 0, 0))
-
--- limits for 1-byte sequences
-assert("\u{0}\u{7F}" == "\x00\z\x7F")
-
--- limits for 2-byte sequences
-assert("\u{80}\u{7FF}" == "\xC2\x80\z\xDF\xBF")
-
--- limits for 3-byte sequences
-assert("\u{800}\u{FFFF}" ==   "\xE0\xA0\x80\z\xEF\xBF\xBF")
-
--- limits for 4-byte sequences
-assert("\u{10000}\u{10FFFF}" == "\xF0\x90\x80\x80\z\xF4\x8F\xBF\xBF")
-
-
--- Error in escape sequences
-local function lexerror (s, err)
-  local st, msg = load('return ' .. s, '')
-  if err ~= '<eof>' then err = err .. "'" end
-  assert(not st and string.find(msg, "near .-" .. err))
-end
-
-lexerror([["abc\x"]], [[\x"]])
-lexerror([["abc\x]], [[\x]])
-lexerror([["\x]], [[\x]])
-lexerror([["\x5"]], [[\x5"]])
-lexerror([["\x5]], [[\x5]])
-lexerror([["\xr"]], [[\xr]])
-lexerror([["\xr]], [[\xr]])
-lexerror([["\x.]], [[\x.]])
-lexerror([["\x8%"]], [[\x8%%]])
-lexerror([["\xAG]], [[\xAG]])
-lexerror([["\g"]], [[\g]])
-lexerror([["\g]], [[\g]])
-lexerror([["\."]], [[\%.]])
-
-lexerror([["\999"]], [[\999"]])
-lexerror([["xyz\300"]], [[\300"]])
-lexerror([["   \256"]], [[\256"]])
-
--- errors in UTF-8 sequences
-lexerror([["abc\u{110000}"]], [[abc\u{110000]])   -- too large
-lexerror([["abc\u11r"]], [[abc\u1]])    -- missing '{'
-lexerror([["abc\u"]], [[abc\u"]])    -- missing '{'
-lexerror([["abc\u{11r"]], [[abc\u{11r]])    -- missing '}'
-lexerror([["abc\u{11"]], [[abc\u{11"]])    -- missing '}'
-lexerror([["abc\u{11]], [[abc\u{11]])    -- missing '}'
-lexerror([["abc\u{r"]], [[abc\u{r]])     -- no digits
-
--- unfinished strings
-lexerror("[=[alo]]", "<eof>")
-lexerror("[=[alo]=", "<eof>")
-lexerror("[=[alo]", "<eof>")
-lexerror("'alo", "<eof>")
-lexerror("'alo \\z  \n\n", "<eof>")
-lexerror("'alo \\z", "<eof>")
-lexerror([['alo \98]], "<eof>")
-
--- valid characters in variable names
-for i = 0, 255 do
-  local s = string.char(i)
-  assert(not string.find(s, "[a-zA-Z_]") == not load(s .. "=1", ""))
-  assert(not string.find(s, "[a-zA-Z_0-9]") ==
-         not load("a" .. s .. "1 = 1", ""))
-end
-
-
--- long variable names
-
-var1 = string.rep('a', 15000) .. '1'
-var2 = string.rep('a', 15000) .. '2'
-prog = string.format([[
-  %s = 5
-  %s = %s + 1
-  return function () return %s - %s end
-]], var1, var2, var1, var1, var2)
-local f = dostring(prog)
-assert(_G[var1] == 5 and _G[var2] == 6 and f() == -1)
-var1, var2, f = nil
-print('+')
-
--- escapes --
-assert("\n\t" == [[
-
-	]])
-assert([[
-
- $debug]] == "\n $debug")
-assert([[ [ ]] ~= [[ ] ]])
--- long strings --
-b = "001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789"
-assert(string.len(b) == 960)
-prog = [=[
-print('+')
-
-a1 = [["this is a 'string' with several 'quotes'"]]
-a2 = "'quotes'"
-
-assert(string.find(a1, a2) == 34)
-print('+')
-
-a1 = [==[temp = [[an arbitrary value]]; ]==]
-assert(load(a1))()
-assert(temp == 'an arbitrary value')
--- long strings --
-b = "001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789001234567890123456789012345678901234567891234567890123456789012345678901234567890012345678901234567890123456789012345678912345678901234567890123456789012345678900123456789012345678901234567890123456789123456789012345678901234567890123456789"
-assert(string.len(b) == 960)
-print('+')
-
-a = [[00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-00123456789012345678901234567890123456789123456789012345678901234567890123456789
-]]
-assert(string.len(a) == 1863)
-assert(string.sub(a, 1, 40) == string.sub(b, 1, 40))
-x = 1
-]=]
-
-print('+')
-x = nil
-dostring(prog)
-assert(x)
-
-prog = nil
-a = nil
-b = nil
-
-
--- testing line ends
-prog = [[
-a = 1        -- a comment
-b = 2
-
-
-x = [=[
-hi
-]=]
-y = "\
-hello\r\n\
-"
-return require"debug".getinfo(1).currentline
-]]
-
-for _, n in pairs{"\n", "\r", "\n\r", "\r\n"} do
-  local prog, nn = string.gsub(prog, "\n", n)
-  assert(dostring(prog) == nn)
-  assert(_G.x == "hi\n" and _G.y == "\nhello\r\n\n")
-end
-
-
--- testing comments and strings with long brackets
-a = [==[]=]==]
-assert(a == "]=")
-
-a = [==[[===[[=[]]=][====[]]===]===]==]
-assert(a == "[===[[=[]]=][====[]]===]===")
-
-a = [====[[===[[=[]]=][====[]]===]===]====]
-assert(a == "[===[[=[]]=][====[]]===]===")
-
-a = [=[]]]]]]]]]=]
-assert(a == "]]]]]]]]")
-
-
---[===[
-x y z [==[ blu foo
-]==
-]
-]=]==]
-error error]=]===]
-
--- generate all strings of four of these chars
-local x = {"=", "[", "]", "\n"}
-local len = 4
-local function gen (c, n)
-  if n==0 then coroutine.yield(c)
-  else
-    for _, a in pairs(x) do
-      gen(c..a, n-1)
-    end
-  end
-end
-
-for s in coroutine.wrap(function () gen("", len) end) do
-  assert(s == load("return [====[\n"..s.."]====]", "")())
-end
-
-
--- testing decimal point locale
-if os.setlocale("pt_BR") or os.setlocale("ptb") then
-  assert(tonumber("3,4") == 3.4 and tonumber"3.4" == 3.4)
-  assert(tonumber("  -.4  ") == -0.4)
-  assert(tonumber("  +0x.41  ") == 0X0.41)
-  assert(not load("a = (3,4)"))
-  assert(assert(load("return 3.4"))() == 3.4)
-  assert(assert(load("return .4,3"))() == .4)
-  assert(assert(load("return 4."))() == 4.)
-  assert(assert(load("return 4.+.5"))() == 4.5)
-
-  assert(" 0x.1 " + " 0x,1" + "-0X.1\t" == 0x0.1)
-
-  assert(tonumber"inf" == nil and tonumber"NAN" == nil)
-
-  assert(assert(load(string.format("return %q", 4.51)))() == 4.51)
-
-  local a,b = load("return 4.5.")
-  assert(string.find(b, "'4%.5%.'"))
-
-  assert(os.setlocale("C"))
-else
-  (Message or print)(
-   '\n >>> pt_BR locale not available: skipping decimal point tests <<<\n')
-end
-
-
--- testing %q x line ends
-local s = "a string with \r and \n and \r\n and \n\r"
-local c = string.format("return %q", s)
-assert(assert(load(c))() == s)
-
--- testing errors
-assert(not load"a = 'non-ending string")
-assert(not load"a = 'non-ending string\n'")
-assert(not load"a = '\\345'")
-assert(not load"a = [=x]")
-
-print('OK')

testes/locals.lua

@@ -1,162 +0,0 @@
--- $Id: locals.lua,v 1.37 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print('testing local variables and environments')
-
-local debug = require"debug"
-
-
--- bug in 5.1:
-
-local function f(x) x = nil; return x end
-assert(f(10) == nil)
-
-local function f() local x; return x end
-assert(f(10) == nil)
-
-local function f(x) x = nil; local y; return x, y end
-assert(f(10) == nil and select(2, f(20)) == nil)
-
-do
-  local i = 10
-  do local i = 100; assert(i==100) end
-  do local i = 1000; assert(i==1000) end
-  assert(i == 10)
-  if i ~= 10 then
-    local i = 20
-  else
-    local i = 30
-    assert(i == 30)
-  end
-end
-
-
-
-f = nil
-
-local f
-x = 1
-
-a = nil
-load('local a = {}')()
-assert(a == nil)
-
-function f (a)
-  local _1, _2, _3, _4, _5
-  local _6, _7, _8, _9, _10
-  local x = 3
-  local b = a
-  local c,d = a,b
-  if (d == b) then
-    local x = 'q'
-    x = b
-    assert(x == 2)
-  else
-    assert(nil)
-  end
-  assert(x == 3)
-  local f = 10
-end
-
-local b=10
-local a; repeat local b; a,b=1,2; assert(a+1==b); until a+b==3
-
-
-assert(x == 1)
-
-f(2)
-assert(type(f) == 'function')
-
-
-local function getenv (f)
-  local a,b = debug.getupvalue(f, 1)
-  assert(a == '_ENV')
-  return b
-end
-
--- test for global table of loaded chunks
-assert(getenv(load"a=3") == _G)
-local c = {}; local f = load("a = 3", nil, nil, c)
-assert(getenv(f) == c)
-assert(c.a == nil)
-f()
-assert(c.a == 3)
-
--- old test for limits for special instructions (now just a generic test)
-do
-  local i = 2
-  local p = 4    -- p == 2^i
-  repeat
-    for j=-3,3 do
-      assert(load(string.format([[local a=%s;
-                                        a=a+%s;
-                                        assert(a ==2^%s)]], j, p-j, i), '')) ()
-      assert(load(string.format([[local a=%s;
-                                        a=a-%s;
-                                        assert(a==-2^%s)]], -j, p-j, i), '')) ()
-      assert(load(string.format([[local a,b=0,%s;
-                                        a=b-%s;
-                                        assert(a==-2^%s)]], -j, p-j, i), '')) ()
-    end
-    p = 2 * p;  i = i + 1
-  until p <= 0
-end
-
-print'+'
-
-
-if rawget(_G, "querytab") then
-  -- testing clearing of dead elements from tables
-  collectgarbage("stop")   -- stop GC
-  local a = {[{}] = 4, [3] = 0, alo = 1, 
-             a1234567890123456789012345678901234567890 = 10}
-
-  local t = querytab(a)
-
-  for k,_ in pairs(a) do a[k] = nil end
-  collectgarbage()   -- restore GC and collect dead fiels in `a'
-  for i=0,t-1 do
-    local k = querytab(a, i)
-    assert(k == nil or type(k) == 'number' or k == 'alo')
-  end
-end
-
-
--- testing lexical environments
-
-assert(_ENV == _G)
-
-do
-local dummy
-local _ENV = (function (...) return ... end)(_G, dummy)   -- {
-
-do local _ENV = {assert=assert}; assert(true) end
-mt = {_G = _G}
-local foo,x
-A = false    -- "declare" A
-do local _ENV = mt
-  function foo (x)
-    A = x
-    do local _ENV =  _G; A = 1000 end
-    return function (x) return A .. x end
-  end
-end
-assert(getenv(foo) == mt)
-x = foo('hi'); assert(mt.A == 'hi' and A == 1000)
-assert(x('*') == mt.A .. '*')
-
-do local _ENV = {assert=assert, A=10};
-  do local _ENV = {assert=assert, A=20};
-    assert(A==20);x=A
-  end
-  assert(A==10 and x==20)
-end
-assert(x==20)
-
-
-print('OK')
-
-return 5,f
-
-end   -- }
-

testes/main.lua

@@ -1,381 +0,0 @@
-# testing special comment on first line
--- $Id: main.lua,v 1.65 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
--- most (all?) tests here assume a reasonable "Unix-like" shell
-if _port then return end
-
--- use only "double quotes" inside shell scripts (better change to
--- run on Windows)
-
-
-print ("testing stand-alone interpreter")
-
-assert(os.execute())   -- machine has a system command
-
-local arg = arg or _ARG
-
-local prog = os.tmpname()
-local otherprog = os.tmpname()
-local out = os.tmpname()
-
-local progname
-do
-  local i = 0
-  while arg[i] do i=i-1 end
-  progname = arg[i+1]
-end
-print("progname: "..progname)
-
-local prepfile = function (s, p)
-  p = p or prog
-  io.output(p)
-  io.write(s)
-  assert(io.close())
-end
-
-local function getoutput ()
-  io.input(out)
-  local t = io.read("a")
-  io.input():close()
-  assert(os.remove(out))
-  return t
-end
-
-local function checkprogout (s)
-  local t = getoutput()
-  for line in string.gmatch(s, ".-\n") do
-    assert(string.find(t, line, 1, true))
-  end
-end
-
-local function checkout (s)
-  local t = getoutput()
-  if s ~= t then print(string.format("'%s' - '%s'\n", s, t)) end
-  assert(s == t)
-  return t
-end
-
-
-local function RUN (p, ...)
-  p = string.gsub(p, "lua", '"'..progname..'"', 1)
-  local s = string.format(p, ...)
-  assert(os.execute(s))
-end
-
-local function NoRun (msg, p, ...)
-  p = string.gsub(p, "lua", '"'..progname..'"', 1)
-  local s = string.format(p, ...)
-  s = string.format("%s 2> %s", s, out)  -- will send error to 'out'
-  assert(not os.execute(s))
-  assert(string.find(getoutput(), msg, 1, true))  -- check error message
-end
-
-RUN('lua -v')
-
-print(string.format("(temporary program file used in these tests: %s)", prog))
-
--- running stdin as a file
-prepfile""
-RUN('lua - < %s > %s', prog, out)
-checkout("")
-
-prepfile[[
-  print(
-1, a
-)
-]]
-RUN('lua - < %s > %s', prog, out)
-checkout("1\tnil\n")
-
-RUN('echo "print(10)\nprint(2)\n" | lua > %s', out)
-checkout("10\n2\n")
-
-
--- test option '-'
-RUN('echo "print(arg[1])" | lua - -h > %s', out)
-checkout("-h\n")
-
--- test environment variables used by Lua
-
-prepfile("print(package.path)")
-
--- test LUA_PATH
-RUN('env LUA_INIT= LUA_PATH=x lua %s > %s', prog, out)
-checkout("x\n")
-
--- test LUA_PATH_version
-RUN('env LUA_INIT= LUA_PATH_5_3=y LUA_PATH=x lua %s > %s', prog, out)
-checkout("y\n")
-
--- test LUA_CPATH
-prepfile("print(package.cpath)")
-RUN('env LUA_INIT= LUA_CPATH=xuxu lua %s > %s', prog, out)
-checkout("xuxu\n")
-
--- test LUA_CPATH_version
-RUN('env LUA_INIT= LUA_CPATH_5_3=yacc LUA_CPATH=x lua %s > %s', prog, out)
-checkout("yacc\n")
-
--- test LUA_INIT (and its access to 'arg' table)
-prepfile("print(X)")
-RUN('env LUA_INIT="X=tonumber(arg[1])" lua %s 3.2 > %s', prog, out)
-checkout("3.2\n")
-
--- test LUA_INIT_version
-prepfile("print(X)")
-RUN('env LUA_INIT_5_3="X=10" LUA_INIT="X=3" lua %s > %s', prog, out)
-checkout("10\n")
-
--- test LUA_INIT for files
-prepfile("x = x or 10; print(x); x = x + 1")
-RUN('env LUA_INIT="@%s" lua %s > %s', prog, prog, out)
-checkout("10\n11\n")
-
--- test errors in LUA_INIT
-NoRun('LUA_INIT:1: msg', 'env LUA_INIT="error(\'msg\')" lua')
-
--- test option '-E'
-local defaultpath, defaultCpath
-
-do
-  prepfile("print(package.path, package.cpath)")
-  RUN('env LUA_INIT="error(10)" LUA_PATH=xxx LUA_CPATH=xxx lua -E %s > %s',
-       prog, out)
-  local out = getoutput()
-  defaultpath = string.match(out, "^(.-)\t")
-  defaultCpath = string.match(out, "\t(.-)$")
-end
-
--- paths did not changed
-assert(not string.find(defaultpath, "xxx") and
-       string.find(defaultpath, "lua") and
-       not string.find(defaultCpath, "xxx") and
-       string.find(defaultCpath, "lua"))
-
-
--- test replacement of ';;' to default path
-local function convert (p)
-  prepfile("print(package.path)")
-  RUN('env LUA_PATH="%s" lua %s > %s', p, prog, out)
-  local expected = getoutput()
-  expected = string.sub(expected, 1, -2)   -- cut final end of line
-  assert(string.gsub(p, ";;", ";"..defaultpath..";") == expected)
-end
-
-convert(";")
-convert(";;")
-convert(";;;")
-convert(";;;;")
-convert(";;;;;")
-convert(";;a;;;bc")
-
-
--- test -l over multiple libraries
-prepfile("print(1); a=2; return {x=15}")
-prepfile(("print(a); print(_G['%s'].x)"):format(prog), otherprog)
-RUN('env LUA_PATH="?;;" lua -l %s -l%s -lstring -l io %s > %s', prog, otherprog, otherprog, out)
-checkout("1\n2\n15\n2\n15\n")
-
--- test 'arg' table
-local a = [[
-  assert(#arg == 3 and arg[1] == 'a' and
-         arg[2] == 'b' and arg[3] == 'c')
-  assert(arg[-1] == '--' and arg[-2] == "-e " and arg[-3] == '%s')
-  assert(arg[4] == nil and arg[-4] == nil)
-  local a, b, c = ...
-  assert(... == 'a' and a == 'a' and b == 'b' and c == 'c')
-]]
-a = string.format(a, progname)
-prepfile(a)
-RUN('lua "-e " -- %s a b c', prog)   -- "-e " runs an empty command
-
--- test 'arg' availability in libraries
-prepfile"assert(arg)"
-prepfile("assert(arg)", otherprog)
-RUN('env LUA_PATH="?;;" lua -l%s - < %s', prog, otherprog)
-
--- test messing up the 'arg' table
-RUN('echo "print(...)" | lua -e "arg[1] = 100" - > %s', out)
-checkout("100\n")
-NoRun("'arg' is not a table", 'echo "" | lua -e "arg = 1" -')
-
--- test error in 'print'
-RUN('echo 10 | lua -e "print=nil" -i > /dev/null 2> %s', out)
-assert(string.find(getoutput(), "error calling 'print'"))
-
--- test 'debug.debug'
-RUN('echo "io.stderr:write(1000)\ncont" | lua -e "require\'debug\'.debug()" 2> %s', out)
-checkout("lua_debug> 1000lua_debug> ")
-
--- test many arguments
-prepfile[[print(({...})[30])]]
-RUN('lua %s %s > %s', prog, string.rep(" a", 30), out)
-checkout("a\n")
-
-RUN([[lua "-eprint(1)" -ea=3 -e "print(a)" > %s]], out)
-checkout("1\n3\n")
-
--- test iteractive mode
-prepfile[[
-(6*2-6) -- ===
-a =
-10
-print(a)
-a]]
-RUN([[lua -e"_PROMPT='' _PROMPT2=''" -i < %s > %s]], prog, out)
-checkprogout("6\n10\n10\n\n")
-
-prepfile("a = [[b\nc\nd\ne]]\n=a")
-RUN([[lua -e"_PROMPT='' _PROMPT2=''" -i < %s > %s]], prog, out)
-checkprogout("b\nc\nd\ne\n\n")
-
-prompt = "alo"
-prepfile[[ --
-a = 2
-]]
-RUN([[lua "-e_PROMPT='%s'" -i < %s > %s]], prompt, prog, out)
-local t = getoutput()
-assert(string.find(t, prompt .. ".*" .. prompt .. ".*" .. prompt))
-
--- test for error objects
-prepfile[[
-debug = require "debug"
-m = {x=0}
-setmetatable(m, {__tostring = function(x)
-  return tostring(debug.getinfo(4).currentline + x.x)
-end})
-error(m)
-]]
-NoRun(progname .. ": 6\n", [[lua %s]], prog)
-
-prepfile("error{}")
-NoRun("error object is a table value", [[lua %s]], prog)
-
-
--- chunk broken in many lines
-s = [=[ -- 
-function f ( x ) 
-  local a = [[
-xuxu
-]]
-  local b = "\
-xuxu\n"
-  if x == 11 then return 1 + 12 , 2 + 20 end  --[[ test multiple returns ]]
-  return x + 1 
-  --\\
-end
-return( f( 100 ) )
-assert( a == b )
-do return f( 11 ) end  ]=]
-s = string.gsub(s, ' ', '\n\n')   -- change all spaces for newlines
-prepfile(s)
-RUN([[lua -e"_PROMPT='' _PROMPT2=''" -i < %s > %s]], prog, out)
-checkprogout("101\n13\t22\n\n")
-  
-prepfile[[#comment in 1st line without \n at the end]]
-RUN('lua %s', prog)
-  
-prepfile[[#test line number when file starts with comment line
-debug = require"debug"
-print(debug.getinfo(1).currentline)
-]]
-RUN('lua %s > %s', prog, out)
-checkprogout('3')
-
--- close Lua with an open file
-prepfile(string.format([[io.output(%q); io.write('alo')]], out))
-RUN('lua %s', prog)
-checkout('alo')
-
--- bug in 5.2 beta (extra \0 after version line)
-RUN([[lua -v  -e"print'hello'" > %s]], out)
-t = getoutput()
-assert(string.find(t, "PUC%-Rio\nhello"))
-
-
--- testing os.exit
-prepfile("os.exit(nil, true)")
-RUN('lua %s', prog)
-prepfile("os.exit(0, true)")
-RUN('lua %s', prog)
-prepfile("os.exit(true, true)")
-RUN('lua %s', prog)
-prepfile("os.exit(1, true)")
-NoRun("", "lua %s", prog)   -- no message
-prepfile("os.exit(false, true)")
-NoRun("", "lua %s", prog)   -- no message
-
--- remove temporary files
-assert(os.remove(prog))
-assert(os.remove(otherprog))
-assert(not os.remove(out))
-
--- invalid options
-NoRun("unrecognized option '-h'", "lua -h")
-NoRun("unrecognized option '---'", "lua ---")
-NoRun("unrecognized option '-Ex'", "lua -Ex")
-NoRun("unrecognized option '-vv'", "lua -vv")
-NoRun("unrecognized option '-iv'", "lua -iv")
-NoRun("'-e' needs argument", "lua -e")
-NoRun("syntax error", "lua -e a")
-NoRun("'-l' needs argument", "lua -l")
-
-
-if T then   -- auxiliary library?
-  print("testing 'not enough memory' to create a state")
-  NoRun("not enough memory", "env MEMLIMIT=100 lua")
-end
-print('+')
-
-print('testing Ctrl C')
-do
-  -- interrupt a script
-  local function kill (pid)
-    return os.execute(string.format('kill -INT %d 2> /dev/null', pid))
-  end
-
-  -- function to run a script in background, returning its output file
-  -- descriptor and its pid
-  local function runback (luaprg)
-    -- shell script to run 'luaprg' in background and echo its pid
-    local shellprg = string.format('%s -e "%s" & echo $!', progname, luaprg)
-    local f = io.popen(shellprg, "r")   -- run shell script
-    local pid = f:read()   -- get pid for Lua script
-    print("(if test fails now, it may leave a Lua script running in \z
-            background, pid " .. pid .. ")")
-    return f, pid
-  end
-
-  -- Lua script that runs protected infinite loop and then prints '42'
-  local f, pid = runback[[
-    pcall(function () print(12); while true do end end); print(42)]]
-  -- wait until script is inside 'pcall'
-  assert(f:read() == "12")
-  kill(pid)  -- send INT signal to Lua script
-  -- check that 'pcall' captured the exception and script continued running
-  assert(f:read() == "42")  -- expected output
-  assert(f:close())
-  print("done")
-
-  -- Lua script in a long unbreakable search
-  local f, pid = runback[[
-    print(15); string.find(string.rep('a', 100000), '.*b')]]
-  -- wait (so script can reach the loop)
-  assert(f:read() == "15")
-  assert(os.execute("sleep 1"))
-  -- must send at least two INT signals to stop this Lua script
-  local n = 100
-  for i = 0, 100 do   -- keep sending signals
-    if not kill(pid) then   -- until it fails
-      n = i   -- number of non-failed kills
-      break
-    end
-  end
-  assert(f:close())
-  assert(n >= 2)
-  print(string.format("done (with %d kills)", n))
-
-end
-
-print("OK")

testes/math.lua

@@ -1,824 +0,0 @@
--- $Id: math.lua,v 1.78 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print("testing numbers and math lib")
-
-local minint = math.mininteger
-local maxint = math.maxinteger
-
-local intbits = math.floor(math.log(maxint, 2) + 0.5) + 1
-assert((1 << intbits) == 0)
-
-assert(minint == 1 << (intbits - 1))
-assert(maxint == minint - 1)
-
--- number of bits in the mantissa of a floating-point number
-local floatbits = 24
-do
-  local p = 2.0^floatbits
-  while p < p + 1.0 do
-    p = p * 2.0
-    floatbits = floatbits + 1
-  end
-end
-
-local function isNaN (x)
-  return (x ~= x)
-end
-
-assert(isNaN(0/0))
-assert(not isNaN(1/0))
-
-
-do
-  local x = 2.0^floatbits
-  assert(x > x - 1.0 and x == x + 1.0)
-
-  print(string.format("%d-bit integers, %d-bit (mantissa) floats",
-                       intbits, floatbits))
-end
-
-assert(math.type(0) == "integer" and math.type(0.0) == "float"
-       and math.type("10") == nil)
-
-
-local function checkerror (msg, f, ...)
-  local s, err = pcall(f, ...)
-  assert(not s and string.find(err, msg))
-end
-
-local msgf2i = "number.* has no integer representation"
-
--- float equality
-function eq (a,b,limit)
-  if not limit then
-    if floatbits >= 50 then limit = 1E-11
-    else limit = 1E-5
-    end
-  end
-  -- a == b needed for +inf/-inf
-  return a == b or math.abs(a-b) <= limit
-end
-
-
--- equality with types
-function eqT (a,b)
-  return a == b and math.type(a) == math.type(b)
-end
-
-
--- basic float notation
-assert(0e12 == 0 and .0 == 0 and 0. == 0 and .2e2 == 20 and 2.E-1 == 0.2)
-
-do
-  local a,b,c = "2", " 3e0 ", " 10  "
-  assert(a+b == 5 and -b == -3 and b+"2" == 5 and "10"-c == 0)
-  assert(type(a) == 'string' and type(b) == 'string' and type(c) == 'string')
-  assert(a == "2" and b == " 3e0 " and c == " 10  " and -c == -"  10 ")
-  assert(c%a == 0 and a^b == 08)
-  a = 0
-  assert(a == -a and 0 == -0)
-end
-
-do
-  local x = -1
-  local mz = 0/x   -- minus zero
-  t = {[0] = 10, 20, 30, 40, 50}
-  assert(t[mz] == t[0] and t[-0] == t[0])
-end
-
-do   -- tests for 'modf'
-  local a,b = math.modf(3.5)
-  assert(a == 3.0 and b == 0.5)
-  a,b = math.modf(-2.5)
-  assert(a == -2.0 and b == -0.5)
-  a,b = math.modf(-3e23)
-  assert(a == -3e23 and b == 0.0)
-  a,b = math.modf(3e35)
-  assert(a == 3e35 and b == 0.0)
-  a,b = math.modf(-1/0)   -- -inf
-  assert(a == -1/0 and b == 0.0)
-  a,b = math.modf(1/0)   -- inf
-  assert(a == 1/0 and b == 0.0)
-  a,b = math.modf(0/0)   -- NaN
-  assert(isNaN(a) and isNaN(b))
-  a,b = math.modf(3)  -- integer argument
-  assert(eqT(a, 3) and eqT(b, 0.0))
-  a,b = math.modf(minint)
-  assert(eqT(a, minint) and eqT(b, 0.0))
-end
-
-assert(math.huge > 10e30)
-assert(-math.huge < -10e30)
-
-
--- integer arithmetic
-assert(minint < minint + 1)
-assert(maxint - 1 < maxint)
-assert(0 - minint == minint)
-assert(minint * minint == 0)
-assert(maxint * maxint * maxint == maxint)
-
-
--- testing floor division and conversions
-
-for _, i in pairs{-16, -15, -3, -2, -1, 0, 1, 2, 3, 15} do
-  for _, j in pairs{-16, -15, -3, -2, -1, 1, 2, 3, 15} do
-    for _, ti in pairs{0, 0.0} do     -- try 'i' as integer and as float
-      for _, tj in pairs{0, 0.0} do   -- try 'j' as integer and as float
-        local x = i + ti
-        local y = j + tj
-          assert(i//j == math.floor(i/j))
-      end
-    end
-  end
-end
-
-assert(1//0.0 == 1/0)
-assert(-1 // 0.0 == -1/0)
-assert(eqT(3.5 // 1.5, 2.0))
-assert(eqT(3.5 // -1.5, -3.0))
-
-assert(maxint // maxint == 1)
-assert(maxint // 1 == maxint)
-assert((maxint - 1) // maxint == 0)
-assert(maxint // (maxint - 1) == 1)
-assert(minint // minint == 1)
-assert(minint // minint == 1)
-assert((minint + 1) // minint == 0)
-assert(minint // (minint + 1) == 1)
-assert(minint // 1 == minint)
-
-assert(minint // -1 == -minint)
-assert(minint // -2 == 2^(intbits - 2))
-assert(maxint // -1 == -maxint)
-
-
--- negative exponents
-do
-  assert(2^-3 == 1 / 2^3)
-  assert(eq((-3)^-3, 1 / (-3)^3))
-  for i = -3, 3 do    -- variables avoid constant folding
-      for j = -3, 3 do
-        -- domain errors (0^(-n)) are not portable
-        if not _port or i ~= 0 or j > 0 then
-          assert(eq(i^j, 1 / i^(-j)))
-       end
-    end
-  end
-end
-
--- comparison between floats and integers (border cases)
-if floatbits < intbits then
-  assert(2.0^floatbits == (1 << floatbits))
-  assert(2.0^floatbits - 1.0 == (1 << floatbits) - 1.0)
-  assert(2.0^floatbits - 1.0 ~= (1 << floatbits))
-  -- float is rounded, int is not
-  assert(2.0^floatbits + 1.0 ~= (1 << floatbits) + 1)
-else   -- floats can express all integers with full accuracy
-  assert(maxint == maxint + 0.0)
-  assert(maxint - 1 == maxint - 1.0)
-  assert(minint + 1 == minint + 1.0)
-  assert(maxint ~= maxint - 1.0)
-end
-assert(maxint + 0.0 == 2.0^(intbits - 1) - 1.0)
-assert(minint + 0.0 == minint)
-assert(minint + 0.0 == -2.0^(intbits - 1))
-
-
--- order between floats and integers
-assert(1 < 1.1); assert(not (1 < 0.9))
-assert(1 <= 1.1); assert(not (1 <= 0.9))
-assert(-1 < -0.9); assert(not (-1 < -1.1))
-assert(1 <= 1.1); assert(not (-1 <= -1.1))
-assert(-1 < -0.9); assert(not (-1 < -1.1))
-assert(-1 <= -0.9); assert(not (-1 <= -1.1))
-assert(minint <= minint + 0.0)
-assert(minint + 0.0 <= minint)
-assert(not (minint < minint + 0.0))
-assert(not (minint + 0.0 < minint))
-assert(maxint < minint * -1.0)
-assert(maxint <= minint * -1.0)
-
-do
-  local fmaxi1 = 2^(intbits - 1)
-  assert(maxint < fmaxi1)
-  assert(maxint <= fmaxi1)
-  assert(not (fmaxi1 <= maxint))
-  assert(minint <= -2^(intbits - 1))
-  assert(-2^(intbits - 1) <= minint)
-end
-
-if floatbits < intbits then
-  print("testing order (floats cannot represent all integers)")
-  local fmax = 2^floatbits
-  local ifmax = fmax | 0
-  assert(fmax < ifmax + 1)
-  assert(fmax - 1 < ifmax)
-  assert(-(fmax - 1) > -ifmax)
-  assert(not (fmax <= ifmax - 1))
-  assert(-fmax > -(ifmax + 1))
-  assert(not (-fmax >= -(ifmax - 1)))
-
-  assert(fmax/2 - 0.5 < ifmax//2)
-  assert(-(fmax/2 - 0.5) > -ifmax//2)
-
-  assert(maxint < 2^intbits)
-  assert(minint > -2^intbits)
-  assert(maxint <= 2^intbits)
-  assert(minint >= -2^intbits)
-else
-  print("testing order (floats can represent all integers)")
-  assert(maxint < maxint + 1.0)
-  assert(maxint < maxint + 0.5)
-  assert(maxint - 1.0 < maxint)
-  assert(maxint - 0.5 < maxint)
-  assert(not (maxint + 0.0 < maxint))
-  assert(maxint + 0.0 <= maxint)
-  assert(not (maxint < maxint + 0.0))
-  assert(maxint + 0.0 <= maxint)
-  assert(maxint <= maxint + 0.0)
-  assert(not (maxint + 1.0 <= maxint))
-  assert(not (maxint + 0.5 <= maxint))
-  assert(not (maxint <= maxint - 1.0))
-  assert(not (maxint <= maxint - 0.5))
-
-  assert(minint < minint + 1.0)
-  assert(minint < minint + 0.5)
-  assert(minint <= minint + 0.5)
-  assert(minint - 1.0 < minint)
-  assert(minint - 1.0 <= minint)
-  assert(not (minint + 0.0 < minint))
-  assert(not (minint + 0.5 < minint))
-  assert(not (minint < minint + 0.0))
-  assert(minint + 0.0 <= minint)
-  assert(minint <= minint + 0.0)
-  assert(not (minint + 1.0 <= minint))
-  assert(not (minint + 0.5 <= minint))
-  assert(not (minint <= minint - 1.0))
-end
-
-do
-  local NaN = 0/0
-  assert(not (NaN < 0))
-  assert(not (NaN > minint))
-  assert(not (NaN <= -9))
-  assert(not (NaN <= maxint))
-  assert(not (NaN < maxint))
-  assert(not (minint <= NaN))
-  assert(not (minint < NaN))
-end
-
-
--- avoiding errors at compile time
-local function checkcompt (msg, code)
-  checkerror(msg, assert(load(code)))
-end
-checkcompt("divide by zero", "return 2 // 0")
-checkcompt(msgf2i, "return 2.3 >> 0")
-checkcompt(msgf2i, ("return 2.0^%d & 1"):format(intbits - 1))
-checkcompt("field 'huge'", "return math.huge << 1")
-checkcompt(msgf2i, ("return 1 | 2.0^%d"):format(intbits - 1))
-checkcompt(msgf2i, "return 2.3 ~ '0.0'")
-
-
--- testing overflow errors when converting from float to integer (runtime)
-local function f2i (x) return x | x end
-checkerror(msgf2i, f2i, math.huge)     -- +inf
-checkerror(msgf2i, f2i, -math.huge)    -- -inf
-checkerror(msgf2i, f2i, 0/0)           -- NaN
-
-if floatbits < intbits then
-  -- conversion tests when float cannot represent all integers
-  assert(maxint + 1.0 == maxint + 0.0)
-  assert(minint - 1.0 == minint + 0.0)
-  checkerror(msgf2i, f2i, maxint + 0.0)
-  assert(f2i(2.0^(intbits - 2)) == 1 << (intbits - 2))
-  assert(f2i(-2.0^(intbits - 2)) == -(1 << (intbits - 2)))
-  assert((2.0^(floatbits - 1) + 1.0) // 1 == (1 << (floatbits - 1)) + 1)
-  -- maximum integer representable as a float
-  local mf = maxint - (1 << (floatbits - intbits)) + 1
-  assert(f2i(mf + 0.0) == mf)  -- OK up to here
-  mf = mf + 1
-  assert(f2i(mf + 0.0) ~= mf)   -- no more representable
-else
-  -- conversion tests when float can represent all integers
-  assert(maxint + 1.0 > maxint)
-  assert(minint - 1.0 < minint)
-  assert(f2i(maxint + 0.0) == maxint)
-  checkerror("no integer rep", f2i, maxint + 1.0)
-  checkerror("no integer rep", f2i, minint - 1.0)
-end
-
--- 'minint' should be representable as a float no matter the precision
-assert(f2i(minint + 0.0) == minint)
-
-
--- testing numeric strings
-
-assert("2" + 1 == 3)
-assert("2 " + 1 == 3)
-assert(" -2 " + 1 == -1)
-assert(" -0xa " + 1 == -9)
-
-
--- Literal integer Overflows (new behavior in 5.3.3)
-do
-  -- no overflows
-  assert(eqT(tonumber(tostring(maxint)), maxint))
-  assert(eqT(tonumber(tostring(minint)), minint))
-
-  -- add 1 to last digit as a string (it cannot be 9...)
-  local function incd (n)
-    local s = string.format("%d", n)
-    s = string.gsub(s, "%d$", function (d)
-          assert(d ~= '9')
-          return string.char(string.byte(d) + 1)
-        end)
-    return s
-  end
-
-  -- 'tonumber' with overflow by 1
-  assert(eqT(tonumber(incd(maxint)), maxint + 1.0))
-  assert(eqT(tonumber(incd(minint)), minint - 1.0))
-
-  -- large numbers
-  assert(eqT(tonumber("1"..string.rep("0", 30)), 1e30))
-  assert(eqT(tonumber("-1"..string.rep("0", 30)), -1e30))
-
-  -- hexa format still wraps around
-  assert(eqT(tonumber("0x1"..string.rep("0", 30)), 0))
-
-  -- lexer in the limits
-  assert(minint == load("return " .. minint)())
-  assert(eqT(maxint, load("return " .. maxint)()))
-
-  assert(eqT(10000000000000000000000.0, 10000000000000000000000))
-  assert(eqT(-10000000000000000000000.0, -10000000000000000000000))
-end
-
-
--- testing 'tonumber'
-
--- 'tonumber' with numbers
-assert(tonumber(3.4) == 3.4)
-assert(eqT(tonumber(3), 3))
-assert(eqT(tonumber(maxint), maxint) and eqT(tonumber(minint), minint))
-assert(tonumber(1/0) == 1/0)
-
--- 'tonumber' with strings
-assert(tonumber("0") == 0)
-assert(tonumber("") == nil)
-assert(tonumber("  ") == nil)
-assert(tonumber("-") == nil)
-assert(tonumber("  -0x ") == nil)
-assert(tonumber{} == nil)
-assert(tonumber'+0.01' == 1/100 and tonumber'+.01' == 0.01 and
-       tonumber'.01' == 0.01    and tonumber'-1.' == -1 and
-       tonumber'+1.' == 1)
-assert(tonumber'+ 0.01' == nil and tonumber'+.e1' == nil and
-       tonumber'1e' == nil     and tonumber'1.0e+' == nil and
-       tonumber'.' == nil)
-assert(tonumber('-012') == -010-2)
-assert(tonumber('-1.2e2') == - - -120)
-
-assert(tonumber("0xffffffffffff") == (1 << (4*12)) - 1)
-assert(tonumber("0x"..string.rep("f", (intbits//4))) == -1)
-assert(tonumber("-0x"..string.rep("f", (intbits//4))) == 1)
-
--- testing 'tonumber' with base
-assert(tonumber('  001010  ', 2) == 10)
-assert(tonumber('  001010  ', 10) == 001010)
-assert(tonumber('  -1010  ', 2) == -10)
-assert(tonumber('10', 36) == 36)
-assert(tonumber('  -10  ', 36) == -36)
-assert(tonumber('  +1Z  ', 36) == 36 + 35)
-assert(tonumber('  -1z  ', 36) == -36 + -35)
-assert(tonumber('-fFfa', 16) == -(10+(16*(15+(16*(15+(16*15)))))))
-assert(tonumber(string.rep('1', (intbits - 2)), 2) + 1 == 2^(intbits - 2))
-assert(tonumber('ffffFFFF', 16)+1 == (1 << 32))
-assert(tonumber('0ffffFFFF', 16)+1 == (1 << 32))
-assert(tonumber('-0ffffffFFFF', 16) - 1 == -(1 << 40))
-for i = 2,36 do
-  local i2 = i * i
-  local i10 = i2 * i2 * i2 * i2 * i2      -- i^10
-  assert(tonumber('\t10000000000\t', i) == i10)
-end
-
-if not _soft then
-  -- tests with very long numerals
-  assert(tonumber("0x"..string.rep("f", 13)..".0") == 2.0^(4*13) - 1)
-  assert(tonumber("0x"..string.rep("f", 150)..".0") == 2.0^(4*150) - 1)
-  assert(tonumber("0x"..string.rep("f", 300)..".0") == 2.0^(4*300) - 1)
-  assert(tonumber("0x"..string.rep("f", 500)..".0") == 2.0^(4*500) - 1)
-  assert(tonumber('0x3.' .. string.rep('0', 1000)) == 3)
-  assert(tonumber('0x' .. string.rep('0', 1000) .. 'a') == 10)
-  assert(tonumber('0x0.' .. string.rep('0', 13).."1") == 2.0^(-4*14))
-  assert(tonumber('0x0.' .. string.rep('0', 150).."1") == 2.0^(-4*151))
-  assert(tonumber('0x0.' .. string.rep('0', 300).."1") == 2.0^(-4*301))
-  assert(tonumber('0x0.' .. string.rep('0', 500).."1") == 2.0^(-4*501))
-
-  assert(tonumber('0xe03' .. string.rep('0', 1000) .. 'p-4000') == 3587.0)
-  assert(tonumber('0x.' .. string.rep('0', 1000) .. '74p4004') == 0x7.4)
-end
-
--- testing 'tonumber' for invalid formats
-
-local function f (...)
-  if select('#', ...) == 1 then
-    return (...)
-  else
-    return "***"
-  end
-end
-
-assert(f(tonumber('fFfa', 15)) == nil)
-assert(f(tonumber('099', 8)) == nil)
-assert(f(tonumber('1\0', 2)) == nil)
-assert(f(tonumber('', 8)) == nil)
-assert(f(tonumber('  ', 9)) == nil)
-assert(f(tonumber('  ', 9)) == nil)
-assert(f(tonumber('0xf', 10)) == nil)
-
-assert(f(tonumber('inf')) == nil)
-assert(f(tonumber(' INF ')) == nil)
-assert(f(tonumber('Nan')) == nil)
-assert(f(tonumber('nan')) == nil)
-
-assert(f(tonumber('  ')) == nil)
-assert(f(tonumber('')) == nil)
-assert(f(tonumber('1  a')) == nil)
-assert(f(tonumber('1  a', 2)) == nil)
-assert(f(tonumber('1\0')) == nil)
-assert(f(tonumber('1 \0')) == nil)
-assert(f(tonumber('1\0 ')) == nil)
-assert(f(tonumber('e1')) == nil)
-assert(f(tonumber('e  1')) == nil)
-assert(f(tonumber(' 3.4.5 ')) == nil)
-
-
--- testing 'tonumber' for invalid hexadecimal formats
-
-assert(tonumber('0x') == nil)
-assert(tonumber('x') == nil)
-assert(tonumber('x3') == nil)
-assert(tonumber('0x3.3.3') == nil)   -- two decimal points
-assert(tonumber('00x2') == nil)
-assert(tonumber('0x 2') == nil)
-assert(tonumber('0 x2') == nil)
-assert(tonumber('23x') == nil)
-assert(tonumber('- 0xaa') == nil)
-assert(tonumber('-0xaaP ') == nil)   -- no exponent
-assert(tonumber('0x0.51p') == nil)
-assert(tonumber('0x5p+-2') == nil)
-
-
--- testing hexadecimal numerals
-
-assert(0x10 == 16 and 0xfff == 2^12 - 1 and 0XFB == 251)
-assert(0x0p12 == 0 and 0x.0p-3 == 0)
-assert(0xFFFFFFFF == (1 << 32) - 1)
-assert(tonumber('+0x2') == 2)
-assert(tonumber('-0xaA') == -170)
-assert(tonumber('-0xffFFFfff') == -(1 << 32) + 1)
-
--- possible confusion with decimal exponent
-assert(0E+1 == 0 and 0xE+1 == 15 and 0xe-1 == 13)
-
-
--- floating hexas
-
-assert(tonumber('  0x2.5  ') == 0x25/16)
-assert(tonumber('  -0x2.5  ') == -0x25/16)
-assert(tonumber('  +0x0.51p+8  ') == 0x51)
-assert(0x.FfffFFFF == 1 - '0x.00000001')
-assert('0xA.a' + 0 == 10 + 10/16)
-assert(0xa.aP4 == 0XAA)
-assert(0x4P-2 == 1)
-assert(0x1.1 == '0x1.' + '+0x.1')
-assert(0Xabcdef.0 == 0x.ABCDEFp+24)
-
-
-assert(1.1 == 1.+.1)
-assert(100.0 == 1E2 and .01 == 1e-2)
-assert(1111111111 - 1111111110 == 1000.00e-03)
-assert(1.1 == '1.'+'.1')
-assert(tonumber'1111111111' - tonumber'1111111110' ==
-       tonumber"  +0.001e+3 \n\t")
-
-assert(0.1e-30 > 0.9E-31 and 0.9E30 < 0.1e31)
-
-assert(0.123456 > 0.123455)
-
-assert(tonumber('+1.23E18') == 1.23*10.0^18)
-
--- testing order operators
-assert(not(1<1) and (1<2) and not(2<1))
-assert(not('a'<'a') and ('a'<'b') and not('b'<'a'))
-assert((1<=1) and (1<=2) and not(2<=1))
-assert(('a'<='a') and ('a'<='b') and not('b'<='a'))
-assert(not(1>1) and not(1>2) and (2>1))
-assert(not('a'>'a') and not('a'>'b') and ('b'>'a'))
-assert((1>=1) and not(1>=2) and (2>=1))
-assert(('a'>='a') and not('a'>='b') and ('b'>='a'))
-assert(1.3 < 1.4 and 1.3 <= 1.4 and not (1.3 < 1.3) and 1.3 <= 1.3)
-
--- testing mod operator
-assert(eqT(-4 % 3, 2))
-assert(eqT(4 % -3, -2))
-assert(eqT(-4.0 % 3, 2.0))
-assert(eqT(4 % -3.0, -2.0))
-assert(math.pi - math.pi % 1 == 3)
-assert(math.pi - math.pi % 0.001 == 3.141)
-
-assert(eqT(minint % minint, 0))
-assert(eqT(maxint % maxint, 0))
-assert((minint + 1) % minint == minint + 1)
-assert((maxint - 1) % maxint == maxint - 1)
-assert(minint % maxint == maxint - 1)
-
-assert(minint % -1 == 0)
-assert(minint % -2 == 0)
-assert(maxint % -2 == -1)
-
--- non-portable tests because Windows C library cannot compute 
--- fmod(1, huge) correctly
-if not _port then
-  local function anan (x) assert(isNaN(x)) end   -- assert Not a Number
-  anan(0.0 % 0)
-  anan(1.3 % 0)
-  anan(math.huge % 1)
-  anan(math.huge % 1e30)
-  anan(-math.huge % 1e30)
-  anan(-math.huge % -1e30)
-  assert(1 % math.huge == 1)
-  assert(1e30 % math.huge == 1e30)
-  assert(1e30 % -math.huge == -math.huge)
-  assert(-1 % math.huge == math.huge)
-  assert(-1 % -math.huge == -1)
-end
-
-
--- testing unsigned comparisons
-assert(math.ult(3, 4))
-assert(not math.ult(4, 4))
-assert(math.ult(-2, -1))
-assert(math.ult(2, -1))
-assert(not math.ult(-2, -2))
-assert(math.ult(maxint, minint))
-assert(not math.ult(minint, maxint))
-
-
-assert(eq(math.sin(-9.8)^2 + math.cos(-9.8)^2, 1))
-assert(eq(math.tan(math.pi/4), 1))
-assert(eq(math.sin(math.pi/2), 1) and eq(math.cos(math.pi/2), 0))
-assert(eq(math.atan(1), math.pi/4) and eq(math.acos(0), math.pi/2) and
-       eq(math.asin(1), math.pi/2))
-assert(eq(math.deg(math.pi/2), 90) and eq(math.rad(90), math.pi/2))
-assert(math.abs(-10.43) == 10.43)
-assert(eqT(math.abs(minint), minint))
-assert(eqT(math.abs(maxint), maxint))
-assert(eqT(math.abs(-maxint), maxint))
-assert(eq(math.atan(1,0), math.pi/2))
-assert(math.fmod(10,3) == 1)
-assert(eq(math.sqrt(10)^2, 10))
-assert(eq(math.log(2, 10), math.log(2)/math.log(10)))
-assert(eq(math.log(2, 2), 1))
-assert(eq(math.log(9, 3), 2))
-assert(eq(math.exp(0), 1))
-assert(eq(math.sin(10), math.sin(10%(2*math.pi))))
-
-
-assert(tonumber(' 1.3e-2 ') == 1.3e-2)
-assert(tonumber(' -1.00000000000001 ') == -1.00000000000001)
-
--- testing constant limits
--- 2^23 = 8388608
-assert(8388609 + -8388609 == 0)
-assert(8388608 + -8388608 == 0)
-assert(8388607 + -8388607 == 0)
-
-
-
-do   -- testing floor & ceil
-  assert(eqT(math.floor(3.4), 3))
-  assert(eqT(math.ceil(3.4), 4))
-  assert(eqT(math.floor(-3.4), -4))
-  assert(eqT(math.ceil(-3.4), -3))
-  assert(eqT(math.floor(maxint), maxint))
-  assert(eqT(math.ceil(maxint), maxint))
-  assert(eqT(math.floor(minint), minint))
-  assert(eqT(math.floor(minint + 0.0), minint))
-  assert(eqT(math.ceil(minint), minint))
-  assert(eqT(math.ceil(minint + 0.0), minint))
-  assert(math.floor(1e50) == 1e50)
-  assert(math.ceil(1e50) == 1e50)
-  assert(math.floor(-1e50) == -1e50)
-  assert(math.ceil(-1e50) == -1e50)
-  for _, p in pairs{31,32,63,64} do
-    assert(math.floor(2^p) == 2^p)
-    assert(math.floor(2^p + 0.5) == 2^p)
-    assert(math.ceil(2^p) == 2^p)
-    assert(math.ceil(2^p - 0.5) == 2^p)
-  end
-  checkerror("number expected", math.floor, {})
-  checkerror("number expected", math.ceil, print)
-  assert(eqT(math.tointeger(minint), minint))
-  assert(eqT(math.tointeger(minint .. ""), minint))
-  assert(eqT(math.tointeger(maxint), maxint))
-  assert(eqT(math.tointeger(maxint .. ""), maxint))
-  assert(eqT(math.tointeger(minint + 0.0), minint))
-  assert(math.tointeger(0.0 - minint) == nil)
-  assert(math.tointeger(math.pi) == nil)
-  assert(math.tointeger(-math.pi) == nil)
-  assert(math.floor(math.huge) == math.huge)
-  assert(math.ceil(math.huge) == math.huge)
-  assert(math.tointeger(math.huge) == nil)
-  assert(math.floor(-math.huge) == -math.huge)
-  assert(math.ceil(-math.huge) == -math.huge)
-  assert(math.tointeger(-math.huge) == nil)
-  assert(math.tointeger("34.0") == 34)
-  assert(math.tointeger("34.3") == nil)
-  assert(math.tointeger({}) == nil)
-  assert(math.tointeger(0/0) == nil)    -- NaN
-end
-
-
--- testing fmod for integers
-for i = -6, 6 do
-  for j = -6, 6 do
-    if j ~= 0 then
-      local mi = math.fmod(i, j)
-      local mf = math.fmod(i + 0.0, j)
-      assert(mi == mf)
-      assert(math.type(mi) == 'integer' and math.type(mf) == 'float')
-      if (i >= 0 and j >= 0) or (i <= 0 and j <= 0) or mi == 0 then
-        assert(eqT(mi, i % j))
-      end
-    end
-  end
-end
-assert(eqT(math.fmod(minint, minint), 0))
-assert(eqT(math.fmod(maxint, maxint), 0))
-assert(eqT(math.fmod(minint + 1, minint), minint + 1))
-assert(eqT(math.fmod(maxint - 1, maxint), maxint - 1))
-
-checkerror("zero", math.fmod, 3, 0)
-
-
-do    -- testing max/min
-  checkerror("value expected", math.max)
-  checkerror("value expected", math.min)
-  assert(eqT(math.max(3), 3))
-  assert(eqT(math.max(3, 5, 9, 1), 9))
-  assert(math.max(maxint, 10e60) == 10e60)
-  assert(eqT(math.max(minint, minint + 1), minint + 1))
-  assert(eqT(math.min(3), 3))
-  assert(eqT(math.min(3, 5, 9, 1), 1))
-  assert(math.min(3.2, 5.9, -9.2, 1.1) == -9.2)
-  assert(math.min(1.9, 1.7, 1.72) == 1.7)
-  assert(math.min(-10e60, minint) == -10e60)
-  assert(eqT(math.min(maxint, maxint - 1), maxint - 1))
-  assert(eqT(math.min(maxint - 2, maxint, maxint - 1), maxint - 2))
-end
--- testing implicit convertions
-
-local a,b = '10', '20'
-assert(a*b == 200 and a+b == 30 and a-b == -10 and a/b == 0.5 and -b == -20)
-assert(a == '10' and b == '20')
-
-
-do
-  print("testing -0 and NaN")
-  local mz, z = -0.0, 0.0
-  assert(mz == z)
-  assert(1/mz < 0 and 0 < 1/z)
-  local a = {[mz] = 1}
-  assert(a[z] == 1 and a[mz] == 1)
-  a[z] = 2
-  assert(a[z] == 2 and a[mz] == 2)
-  local inf = math.huge * 2 + 1
-  mz, z = -1/inf, 1/inf
-  assert(mz == z)
-  assert(1/mz < 0 and 0 < 1/z)
-  local NaN = inf - inf
-  assert(NaN ~= NaN)
-  assert(not (NaN < NaN))
-  assert(not (NaN <= NaN))
-  assert(not (NaN > NaN))
-  assert(not (NaN >= NaN))
-  assert(not (0 < NaN) and not (NaN < 0))
-  local NaN1 = 0/0
-  assert(NaN ~= NaN1 and not (NaN <= NaN1) and not (NaN1 <= NaN))
-  local a = {}
-  assert(not pcall(rawset, a, NaN, 1))
-  assert(a[NaN] == nil)
-  a[1] = 1
-  assert(not pcall(rawset, a, NaN, 1))
-  assert(a[NaN] == nil)
-  -- strings with same binary representation as 0.0 (might create problems
-  -- for constant manipulation in the pre-compiler)
-  local a1, a2, a3, a4, a5 = 0, 0, "\0\0\0\0\0\0\0\0", 0, "\0\0\0\0\0\0\0\0"
-  assert(a1 == a2 and a2 == a4 and a1 ~= a3)
-  assert(a3 == a5)
-end
-
-
-print("testing 'math.random'")
-math.randomseed(0)
-
-do   -- test random for floats
-  local max = -math.huge
-  local min = math.huge
-  for i = 0, 20000 do
-    local t = math.random()
-    assert(0 <= t and t < 1)
-    max = math.max(max, t)
-    min = math.min(min, t)
-    if eq(max, 1, 0.001) and eq(min, 0, 0.001) then
-      goto ok
-    end
-  end
-  -- loop ended without satisfing condition
-  assert(false)
- ::ok::
-end
-
-do
-  local function aux (p, lim)   -- test random for small intervals
-    local x1, x2
-    if #p == 1 then x1 = 1; x2 = p[1]
-    else x1 = p[1]; x2 = p[2]
-    end
-    local mark = {}; local count = 0   -- to check that all values appeared
-    for i = 0, lim or 2000 do
-      local t = math.random(table.unpack(p))
-      assert(x1 <= t and t <= x2)
-      if not mark[t] then  -- new value
-        mark[t] = true
-        count = count + 1
-      end
-      if count == x2 - x1 + 1 then   -- all values appeared; OK
-        goto ok
-      end
-    end
-    -- loop ended without satisfing condition
-    assert(false)
-   ::ok::
-  end
-
-  aux({-10,0})
-  aux({6})
-  aux({-10, 10})
-  aux({minint, minint})
-  aux({maxint, maxint})
-  aux({minint, minint + 9})
-  aux({maxint - 3, maxint})
-end
-
-do
-  local function aux(p1, p2)       -- test random for large intervals
-    local max = minint
-    local min = maxint
-    local n = 200
-    local mark = {}; local count = 0   -- to count how many different values
-    for _ = 1, n do
-      local t = math.random(p1, p2)
-      max = math.max(max, t)
-      min = math.min(min, t)
-      if not mark[t] then  -- new value
-        mark[t] = true
-        count = count + 1
-      end
-    end
-    -- at least 80% of values are different
-    assert(count >= n * 0.8)
-    -- min and max not too far from formal min and max
-    local diff = (p2 - p1) // 8
-    assert(min < p1 + diff and max > p2 - diff)
-  end
-  aux(0, maxint)
-  aux(1, maxint)
-  aux(minint, -1)
-  aux(minint // 2, maxint // 2)
-end
-
-for i=1,100 do
-  assert(math.random(maxint) > 0)
-  assert(math.random(minint, -1) < 0)
-end
-
-assert(not pcall(math.random, 1, 2, 3))    -- too many arguments
-
--- empty interval
-assert(not pcall(math.random, minint + 1, minint))
-assert(not pcall(math.random, maxint, maxint - 1))
-assert(not pcall(math.random, maxint, minint))
-
--- interval too large
-assert(not pcall(math.random, minint, 0))
-assert(not pcall(math.random, -1, maxint))
-assert(not pcall(math.random, minint // 2, maxint // 2 + 1))
-
-
-print('OK')

testes/nextvar.lua

@@ -1,631 +0,0 @@
--- $Id: nextvar.lua,v 1.79 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print('testing tables, next, and for')
-
-local function checkerror (msg, f, ...)
-  local s, err = pcall(f, ...)
-  assert(not s and string.find(err, msg))
-end
-
-
-local a = {}
-
--- make sure table has lots of space in hash part
-for i=1,100 do a[i.."+"] = true end
-for i=1,100 do a[i.."+"] = nil end
--- fill hash part with numeric indices testing size operator
-for i=1,100 do
-  a[i] = true
-  assert(#a == i)
-end
-
--- testing ipairs
-local x = 0
-for k,v in ipairs{10,20,30;x=12} do
-  x = x + 1
-  assert(k == x and v == x * 10)
-end
-
-for _ in ipairs{x=12, y=24} do assert(nil) end
-
--- test for 'false' x ipair
-x = false
-local i = 0
-for k,v in ipairs{true,false,true,false} do
-  i = i + 1
-  x = not x
-  assert(x == v)
-end
-assert(i == 4)
-
--- iterator function is always the same
-assert(type(ipairs{}) == 'function' and ipairs{} == ipairs{})
-
-
-if not T then
-  (Message or print)
-    ('\n >>> testC not active: skipping tests for table sizes <<<\n')
-else --[
--- testing table sizes
-
-local function log2 (x) return math.log(x, 2) end
-
-local function mp2 (n)   -- minimum power of 2 >= n
-  local mp = 2^math.ceil(log2(n))
-  assert(n == 0 or (mp/2 < n and n <= mp))
-  return mp
-end
-
-local function fb (n)
-  local r, nn = T.int2fb(n)
-  assert(r < 256)
-  return nn
-end
-
--- test fb function
-for a = 1, 10000 do   -- all numbers up to 10^4
-  local n = fb(a)
-  assert(a <= n and n <= a*1.125)
-end
-local a = 1024   -- plus a few up to 2 ^30
-local lim = 2^30
-while a < lim do
-  local n = fb(a)
-  assert(a <= n and n <= a*1.125)
-  a = math.ceil(a*1.3)
-end
-
- 
-local function check (t, na, nh)
-  local a, h = T.querytab(t)
-  if a ~= na or h ~= nh then
-    print(na, nh, a, h)
-    assert(nil)
-  end
-end
-
-
--- testing C library sizes
-do
-  local s = 0
-  for _ in pairs(math) do s = s + 1 end
-  check(math, 0, mp2(s))
-end
-
-
--- testing constructor sizes
-local lim = 40
-local s = 'return {'
-for i=1,lim do
-  s = s..i..','
-  local s = s
-  for k=0,lim do 
-    local t = load(s..'}', '')()
-    assert(#t == i)
-    check(t, fb(i), mp2(k))
-    s = string.format('%sa%d=%d,', s, k, k)
-  end
-end
-
-
--- tests with unknown number of elements
-local a = {}
-for i=1,lim do a[i] = i end   -- build auxiliary table
-for k=0,lim do
-  local a = {table.unpack(a,1,k)}
-  assert(#a == k)
-  check(a, k, 0)
-  a = {1,2,3,table.unpack(a,1,k)}
-  check(a, k+3, 0)
-  assert(#a == k + 3)
-end
-
-
--- testing tables dynamically built
-local lim = 130
-local a = {}; a[2] = 1; check(a, 0, 1)
-a = {}; a[0] = 1; check(a, 0, 1); a[2] = 1; check(a, 0, 2)
-a = {}; a[0] = 1; a[1] = 1; check(a, 1, 1)
-a = {}
-for i = 1,lim do
-  a[i] = 1
-  assert(#a == i)
-  check(a, mp2(i), 0)
-end
-
-a = {}
-for i = 1,lim do
-  a['a'..i] = 1
-  assert(#a == 0)
-  check(a, 0, mp2(i))
-end
-
-a = {}
-for i=1,16 do a[i] = i end
-check(a, 16, 0)
-do
-  for i=1,11 do a[i] = nil end
-  for i=30,50 do a[i] = nil end   -- force a rehash (?)
-  check(a, 0, 8)   -- only 5 elements in the table
-  a[10] = 1
-  for i=30,50 do a[i] = nil end   -- force a rehash (?)
-  check(a, 0, 8)   -- only 6 elements in the table
-  for i=1,14 do a[i] = nil end
-  for i=18,50 do a[i] = nil end   -- force a rehash (?)
-  check(a, 0, 4)   -- only 2 elements ([15] and [16])
-end
-
--- reverse filling
-for i=1,lim do
-  local a = {}
-  for i=i,1,-1 do a[i] = i end   -- fill in reverse
-  check(a, mp2(i), 0)
-end
-
--- size tests for vararg
-lim = 35
-function foo (n, ...)
-  local arg = {...}
-  check(arg, n, 0)
-  assert(select('#', ...) == n)
-  arg[n+1] = true
-  check(arg, mp2(n+1), 0)
-  arg.x = true
-  check(arg, mp2(n+1), 1)
-end
-local a = {}
-for i=1,lim do a[i] = true; foo(i, table.unpack(a)) end
-
-end  --]
-
-
--- test size operation on empty tables
-assert(#{} == 0)
-assert(#{nil} == 0)
-assert(#{nil, nil} == 0)
-assert(#{nil, nil, nil} == 0)
-assert(#{nil, nil, nil, nil} == 0)
-print'+'
-
-
-local nofind = {}
-
-a,b,c = 1,2,3
-a,b,c = nil
-
-
--- next uses always the same iteraction function
-assert(next{} == next{})
-
-local function find (name)
-  local n,v
-  while 1 do
-    n,v = next(_G, n)
-    if not n then return nofind end
-    assert(v ~= nil)
-    if n == name then return v end
-  end
-end
-
-local function find1 (name)
-  for n,v in pairs(_G) do
-    if n==name then return v end
-  end
-  return nil  -- not found
-end
-
-
-assert(print==find("print") and print == find1("print"))
-assert(_G["print"]==find("print"))
-assert(assert==find1("assert"))
-assert(nofind==find("return"))
-assert(not find1("return"))
-_G["ret" .. "urn"] = nil
-assert(nofind==find("return"))
-_G["xxx"] = 1
-assert(xxx==find("xxx"))
-
--- invalid key to 'next'
-checkerror("invalid key", next, {10,20}, 3)
-
--- both 'pairs' and 'ipairs' need an argument
-checkerror("bad argument", pairs)
-checkerror("bad argument", ipairs)
-
-print('+')
-
-a = {}
-for i=0,10000 do
-  if math.fmod(i,10) ~= 0 then
-    a['x'..i] = i
-  end
-end
-
-n = {n=0}
-for i,v in pairs(a) do
-  n.n = n.n+1
-  assert(i and v and a[i] == v)
-end
-assert(n.n == 9000)
-a = nil
-
-do   -- clear global table
-  local a = {}
-  for n,v in pairs(_G) do a[n]=v end
-  for n,v in pairs(a) do
-    if not package.loaded[n] and type(v) ~= "function" and
-       not string.find(n, "^[%u_]") then
-     _G[n] = nil
-    end
-    collectgarbage()
-  end
-end
-
-
--- 
-
-local function checknext (a)
-  local b = {}
-  do local k,v = next(a); while k do b[k] = v; k,v = next(a,k) end end
-  for k,v in pairs(b) do assert(a[k] == v) end
-  for k,v in pairs(a) do assert(b[k] == v) end
-end
-
-checknext{1,x=1,y=2,z=3}
-checknext{1,2,x=1,y=2,z=3}
-checknext{1,2,3,x=1,y=2,z=3}
-checknext{1,2,3,4,x=1,y=2,z=3}
-checknext{1,2,3,4,5,x=1,y=2,z=3}
-
-assert(#{} == 0)
-assert(#{[-1] = 2} == 0)
-assert(#{1,2,3,nil,nil} == 3)
-for i=0,40 do
-  local a = {}
-  for j=1,i do a[j]=j end
-  assert(#a == i)
-end
-
--- 'maxn' is now deprecated, but it is easily defined in Lua
-function table.maxn (t)
-  local max = 0
-  for k in pairs(t) do
-    max = (type(k) == 'number') and math.max(max, k) or max
-  end
-  return max
-end
-
-assert(table.maxn{} == 0)
-assert(table.maxn{["1000"] = true} == 0)
-assert(table.maxn{["1000"] = true, [24.5] = 3} == 24.5)
-assert(table.maxn{[1000] = true} == 1000)
-assert(table.maxn{[10] = true, [100*math.pi] = print} == 100*math.pi)
-
-table.maxn = nil
-
--- int overflow
-a = {}
-for i=0,50 do a[2^i] = true end
-assert(a[#a])
-
-print('+')
-
-
--- erasing values
-local t = {[{1}] = 1, [{2}] = 2, [string.rep("x ", 4)] = 3,
-           [100.3] = 4, [4] = 5}
-
-local n = 0
-for k, v in pairs( t ) do
-  n = n+1
-  assert(t[k] == v)
-  t[k] = nil
-  collectgarbage()
-  assert(t[k] == nil)
-end
-assert(n == 5)
-
-
-local function test (a)
-  assert(not pcall(table.insert, a, 2, 20));
-  table.insert(a, 10); table.insert(a, 2, 20);
-  table.insert(a, 1, -1); table.insert(a, 40);
-  table.insert(a, #a+1, 50)
-  table.insert(a, 2, -2)
-  assert(not pcall(table.insert, a, 0, 20));
-  assert(not pcall(table.insert, a, #a + 2, 20));
-  assert(table.remove(a,1) == -1)
-  assert(table.remove(a,1) == -2)
-  assert(table.remove(a,1) == 10)
-  assert(table.remove(a,1) == 20)
-  assert(table.remove(a,1) == 40)
-  assert(table.remove(a,1) == 50)
-  assert(table.remove(a,1) == nil)
-  assert(table.remove(a) == nil)
-  assert(table.remove(a, #a) == nil)
-end
-
-a = {n=0, [-7] = "ban"}
-test(a)
-assert(a.n == 0 and a[-7] == "ban")
-
-a = {[-7] = "ban"};
-test(a)
-assert(a.n == nil and #a == 0 and a[-7] == "ban")
-
-a = {[-1] = "ban"}
-test(a)
-assert(#a == 0 and table.remove(a) == nil and a[-1] == "ban")
-
-a = {[0] = "ban"}
-assert(#a == 0 and table.remove(a) == "ban" and a[0] == nil)
-
-table.insert(a, 1, 10); table.insert(a, 1, 20); table.insert(a, 1, -1)
-assert(table.remove(a) == 10)
-assert(table.remove(a) == 20)
-assert(table.remove(a) == -1)
-assert(table.remove(a) == nil)
-
-a = {'c', 'd'}
-table.insert(a, 3, 'a')
-table.insert(a, 'b')
-assert(table.remove(a, 1) == 'c')
-assert(table.remove(a, 1) == 'd')
-assert(table.remove(a, 1) == 'a')
-assert(table.remove(a, 1) == 'b')
-assert(table.remove(a, 1) == nil)
-assert(#a == 0 and a.n == nil)
-
-a = {10,20,30,40}
-assert(table.remove(a, #a + 1) == nil)
-assert(not pcall(table.remove, a, 0))
-assert(a[#a] == 40)
-assert(table.remove(a, #a) == 40)
-assert(a[#a] == 30)
-assert(table.remove(a, 2) == 20)
-assert(a[#a] == 30 and #a == 2)
-
-do   -- testing table library with metamethods
-  local function test (proxy, t)
-    for i = 1, 10 do
-      table.insert(proxy, 1, i)
-    end
-    assert(#proxy == 10 and #t == 10)
-    for i = 1, 10 do
-      assert(t[i] == 11 - i)
-    end
-    table.sort(proxy)
-    for i = 1, 10 do
-      assert(t[i] == i and proxy[i] == i)
-    end
-    assert(table.concat(proxy, ",") == "1,2,3,4,5,6,7,8,9,10")
-    for i = 1, 8 do
-      assert(table.remove(proxy, 1) == i)
-    end
-    assert(#proxy == 2 and #t == 2)
-    local a, b, c = table.unpack(proxy)
-    assert(a == 9 and b == 10 and c == nil)
-  end
-
-  -- all virtual
-  local t = {}
-  local proxy = setmetatable({}, {
-    __len = function () return #t end,
-    __index = t,
-    __newindex = t,
-  })
-  test(proxy, t)
-
-  -- only __newindex
-  local count = 0
-  t = setmetatable({}, {
-    __newindex = function (t,k,v) count = count + 1; rawset(t,k,v) end})
-  test(t, t)
-  assert(count == 10)   -- after first 10, all other sets are not new
-
-  -- no __newindex
-  t = setmetatable({}, {
-    __index = function (_,k) return k + 1 end,
-    __len = function (_) return 5 end})
-  assert(table.concat(t, ";") == "2;3;4;5;6")
-
-end
-
-
-if not T then
-  (Message or print)
-    ('\n >>> testC not active: skipping tests for table library on non-tables <<<\n')
-else --[
-  local debug = require'debug'
-  local tab = {10, 20, 30}
-  local mt = {}
-  local u = T.newuserdata(0)
-  checkerror("table expected", table.insert, u, 40)
-  checkerror("table expected", table.remove, u)
-  debug.setmetatable(u, mt)
-  checkerror("table expected", table.insert, u, 40)
-  checkerror("table expected", table.remove, u)
-  mt.__index = tab
-  checkerror("table expected", table.insert, u, 40)
-  checkerror("table expected", table.remove, u)
-  mt.__newindex = tab
-  checkerror("table expected", table.insert, u, 40)
-  checkerror("table expected", table.remove, u)
-  mt.__len = function () return #tab end
-  table.insert(u, 40)
-  assert(#u == 4 and #tab == 4 and u[4] == 40 and tab[4] == 40)
-  assert(table.remove(u) == 40)
-  table.insert(u, 1, 50)
-  assert(#u == 4 and #tab == 4 and u[4] == 30 and tab[1] == 50)
-
-  mt.__newindex = nil
-  mt.__len = nil
-  local tab2 = {}
-  local u2 = T.newuserdata(0) 
-  debug.setmetatable(u2, {__newindex = function (_, k, v) tab2[k] = v end})
-  table.move(u, 1, 4, 1, u2)
-  assert(#tab2 == 4 and tab2[1] == tab[1] and tab2[4] == tab[4])
-
-end -- ]
-
-print('+')
-
-a = {}
-for i=1,1000 do
-  a[i] = i; a[i-1] = nil
-end
-assert(next(a,nil) == 1000 and next(a,1000) == nil)
-
-assert(next({}) == nil)
-assert(next({}, nil) == nil)
-
-for a,b in pairs{} do error"not here" end
-for i=1,0 do error'not here' end
-for i=0,1,-1 do error'not here' end
-a = nil; for i=1,1 do assert(not a); a=1 end; assert(a)
-a = nil; for i=1,1,-1 do assert(not a); a=1 end; assert(a)
-
-do
-  print("testing floats in numeric for")
-  local a
-  -- integer count
-  a = 0; for i=1, 1, 1 do a=a+1 end; assert(a==1)
-  a = 0; for i=10000, 1e4, -1 do a=a+1 end; assert(a==1)
-  a = 0; for i=1, 0.99999, 1 do a=a+1 end; assert(a==0)
-  a = 0; for i=9999, 1e4, -1 do a=a+1 end; assert(a==0)
-  a = 0; for i=1, 0.99999, -1 do a=a+1 end; assert(a==1)
-
-  -- float count
-  a = 0; for i=0, 0.999999999, 0.1 do a=a+1 end; assert(a==10)
-  a = 0; for i=1.0, 1, 1 do a=a+1 end; assert(a==1)
-  a = 0; for i=-1.5, -1.5, 1 do a=a+1 end; assert(a==1)
-  a = 0; for i=1e6, 1e6, -1 do a=a+1 end; assert(a==1)
-  a = 0; for i=1.0, 0.99999, 1 do a=a+1 end; assert(a==0)
-  a = 0; for i=99999, 1e5, -1.0 do a=a+1 end; assert(a==0)
-  a = 0; for i=1.0, 0.99999, -1 do a=a+1 end; assert(a==1)
-end
-
--- conversion
-a = 0; for i="10","1","-2" do a=a+1 end; assert(a==5)
-
-do  -- checking types
-  local c
-  local function checkfloat (i)
-    assert(math.type(i) == "float")
-    c = c + 1
-  end
-
-  c = 0; for i = 1.0, 10 do checkfloat(i) end
-  assert(c == 10)
-
-  c = 0; for i = -1, -10, -1.0 do checkfloat(i) end
-  assert(c == 10)
-
-  local function checkint (i)
-    assert(math.type(i) == "integer")
-    c = c + 1
-  end
-
-  local m = math.maxinteger
-  c = 0; for i = m, m - 10, -1 do checkint(i) end
-  assert(c == 11)
-
-  c = 0; for i = 1, 10.9 do checkint(i) end
-  assert(c == 10)
-
-  c = 0; for i = 10, 0.001, -1 do checkint(i) end
-  assert(c == 10)
-
-  c = 0; for i = 1, "10.8" do checkint(i) end
-  assert(c == 10)
-
-  c = 0; for i = 9, "3.4", -1 do checkint(i) end
-  assert(c == 6)
-
-  c = 0; for i = 0, " -3.4  ", -1 do checkint(i) end
-  assert(c == 4)
-
-  c = 0; for i = 100, "96.3", -2 do checkint(i) end
-  assert(c == 2)
-
-  c = 0; for i = 1, math.huge do if i > 10 then break end; checkint(i) end
-  assert(c == 10)
-
-  c = 0; for i = -1, -math.huge, -1 do
-           if i < -10 then break end; checkint(i)
-          end
-  assert(c == 10)
-
-
-  for i = math.mininteger, -10e100 do assert(false) end
-  for i = math.maxinteger, 10e100, -1 do assert(false) end
-
-end
-
-collectgarbage()
-
-
--- testing generic 'for'
-
-local function f (n, p)
-  local t = {}; for i=1,p do t[i] = i*10 end
-  return function (_,n)
-           if n > 0 then
-             n = n-1
-             return n, table.unpack(t)
-           end
-         end, nil, n
-end
-
-local x = 0
-for n,a,b,c,d in f(5,3) do
-  x = x+1
-  assert(a == 10 and b == 20 and c == 30 and d == nil)
-end
-assert(x == 5)
-
-
-
--- testing __pairs and __ipairs metamethod
-a = {}
-do
-  local x,y,z = pairs(a)
-  assert(type(x) == 'function' and y == a and z == nil)
-end
-
-local function foo (e,i)
-  assert(e == a)
-  if i <= 10 then return i+1, i+2 end
-end
-
-local function foo1 (e,i)
-  i = i + 1
-  assert(e == a)
-  if i <= e.n then return i,a[i] end
-end
-
-setmetatable(a, {__pairs = function (x) return foo, x, 0 end})
-
-local i = 0
-for k,v in pairs(a) do
-  i = i + 1
-  assert(k == i and v == k+1)
-end
-
-a.n = 5
-a[3] = 30
-
--- testing ipairs with metamethods
-a = {n=10}
-setmetatable(a, { __index = function (t,k)
-                     if k <= t.n then return k * 10 end 
-                  end})
-i = 0
-for k,v in ipairs(a) do
-  i = i + 1
-  assert(k == i and v == i * 10)
-end
-assert(i == a.n)
-
-print"OK"

testes/pm.lua

@@ -1,374 +0,0 @@
--- $Id: pm.lua,v 1.48 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print('testing pattern matching')
-
-local function checkerror (msg, f, ...)
-  local s, err = pcall(f, ...)
-  assert(not s and string.find(err, msg))
-end
-
-
-function f(s, p)
-  local i,e = string.find(s, p)
-  if i then return string.sub(s, i, e) end
-end
-
-a,b = string.find('', '')    -- empty patterns are tricky
-assert(a == 1 and b == 0);
-a,b = string.find('alo', '')
-assert(a == 1 and b == 0)
-a,b = string.find('a\0o a\0o a\0o', 'a', 1)   -- first position
-assert(a == 1 and b == 1)
-a,b = string.find('a\0o a\0o a\0o', 'a\0o', 2)   -- starts in the midle
-assert(a == 5 and b == 7)
-a,b = string.find('a\0o a\0o a\0o', 'a\0o', 9)   -- starts in the midle
-assert(a == 9 and b == 11)
-a,b = string.find('a\0a\0a\0a\0\0ab', '\0ab', 2);  -- finds at the end
-assert(a == 9 and b == 11);
-a,b = string.find('a\0a\0a\0a\0\0ab', 'b')    -- last position
-assert(a == 11 and b == 11)
-assert(string.find('a\0a\0a\0a\0\0ab', 'b\0') == nil)   -- check ending
-assert(string.find('', '\0') == nil)
-assert(string.find('alo123alo', '12') == 4)
-assert(string.find('alo123alo', '^12') == nil)
-
-assert(string.match("aaab", ".*b") == "aaab")
-assert(string.match("aaa", ".*a") == "aaa")
-assert(string.match("b", ".*b") == "b")
-
-assert(string.match("aaab", ".+b") == "aaab")
-assert(string.match("aaa", ".+a") == "aaa")
-assert(not string.match("b", ".+b"))
-
-assert(string.match("aaab", ".?b") == "ab")
-assert(string.match("aaa", ".?a") == "aa")
-assert(string.match("b", ".?b") == "b")
-
-assert(f('aloALO', '%l*') == 'alo')
-assert(f('aLo_ALO', '%a*') == 'aLo')
-
-assert(f("  \n\r*&\n\r   xuxu  \n\n", "%g%g%g+") == "xuxu")
-
-assert(f('aaab', 'a*') == 'aaa');
-assert(f('aaa', '^.*$') == 'aaa');
-assert(f('aaa', 'b*') == '');
-assert(f('aaa', 'ab*a') == 'aa')
-assert(f('aba', 'ab*a') == 'aba')
-assert(f('aaab', 'a+') == 'aaa')
-assert(f('aaa', '^.+$') == 'aaa')
-assert(f('aaa', 'b+') == nil)
-assert(f('aaa', 'ab+a') == nil)
-assert(f('aba', 'ab+a') == 'aba')
-assert(f('a$a', '.$') == 'a')
-assert(f('a$a', '.%$') == 'a$')
-assert(f('a$a', '.$.') == 'a$a')
-assert(f('a$a', '$$') == nil)
-assert(f('a$b', 'a$') == nil)
-assert(f('a$a', '$') == '')
-assert(f('', 'b*') == '')
-assert(f('aaa', 'bb*') == nil)
-assert(f('aaab', 'a-') == '')
-assert(f('aaa', '^.-$') == 'aaa')
-assert(f('aabaaabaaabaaaba', 'b.*b') == 'baaabaaabaaab')
-assert(f('aabaaabaaabaaaba', 'b.-b') == 'baaab')
-assert(f('alo xo', '.o$') == 'xo')
-assert(f(' \n isto é assim', '%S%S*') == 'isto')
-assert(f(' \n isto é assim', '%S*$') == 'assim')
-assert(f(' \n isto é assim', '[a-z]*$') == 'assim')
-assert(f('um caracter ? extra', '[^%sa-z]') == '?')
-assert(f('', 'a?') == '')
-assert(f('á', 'á?') == 'á')
-assert(f('ábl', 'á?b?l?') == 'ábl')
-assert(f('  ábl', 'á?b?l?') == '')
-assert(f('aa', '^aa?a?a') == 'aa')
-assert(f(']]]áb', '[^]]') == 'á')
-assert(f("0alo alo", "%x*") == "0a")
-assert(f("alo alo", "%C+") == "alo alo")
-print('+')
-
-
-function f1(s, p)
-  p = string.gsub(p, "%%([0-9])", function (s)
-        return "%" .. (tonumber(s)+1)
-       end)
-  p = string.gsub(p, "^(^?)", "%1()", 1)
-  p = string.gsub(p, "($?)$", "()%1", 1)
-  local t = {string.match(s, p)}
-  return string.sub(s, t[1], t[#t] - 1)
-end
-
-assert(f1('alo alx 123 b\0o b\0o', '(..*) %1') == "b\0o b\0o")
-assert(f1('axz123= 4= 4 34', '(.+)=(.*)=%2 %1') == '3= 4= 4 3')
-assert(f1('=======', '^(=*)=%1$') == '=======')
-assert(string.match('==========', '^([=]*)=%1$') == nil)
-
-local function range (i, j)
-  if i <= j then
-    return i, range(i+1, j)
-  end
-end
-
-local abc = string.char(range(0, 255));
-
-assert(string.len(abc) == 256)
-
-function strset (p)
-  local res = {s=''}
-  string.gsub(abc, p, function (c) res.s = res.s .. c end)
-  return res.s
-end;
-
-assert(string.len(strset('[\200-\210]')) == 11)
-
-assert(strset('[a-z]') == "abcdefghijklmnopqrstuvwxyz")
-assert(strset('[a-z%d]') == strset('[%da-uu-z]'))
-assert(strset('[a-]') == "-a")
-assert(strset('[^%W]') == strset('[%w]'))
-assert(strset('[]%%]') == '%]')
-assert(strset('[a%-z]') == '-az')
-assert(strset('[%^%[%-a%]%-b]') == '-[]^ab')
-assert(strset('%Z') == strset('[\1-\255]'))
-assert(strset('.') == strset('[\1-\255%z]'))
-print('+');
-
-assert(string.match("alo xyzK", "(%w+)K") == "xyz")
-assert(string.match("254 K", "(%d*)K") == "")
-assert(string.match("alo ", "(%w*)$") == "")
-assert(string.match("alo ", "(%w+)$") == nil)
-assert(string.find("(álo)", "%(á") == 1)
-local a, b, c, d, e = string.match("âlo alo", "^(((.).).* (%w*))$")
-assert(a == 'âlo alo' and b == 'âl' and c == 'â' and d == 'alo' and e == nil)
-a, b, c, d  = string.match('0123456789', '(.+(.?)())')
-assert(a == '0123456789' and b == '' and c == 11 and d == nil)
-print('+')
-
-assert(string.gsub('ülo ülo', 'ü', 'x') == 'xlo xlo')
-assert(string.gsub('alo úlo  ', ' +$', '') == 'alo úlo')  -- trim
-assert(string.gsub('  alo alo  ', '^%s*(.-)%s*$', '%1') == 'alo alo')  -- double trim
-assert(string.gsub('alo  alo  \n 123\n ', '%s+', ' ') == 'alo alo 123 ')
-t = "abç d"
-a, b = string.gsub(t, '(.)', '%1@')
-assert('@'..a == string.gsub(t, '', '@') and b == 5)
-a, b = string.gsub('abçd', '(.)', '%0@', 2)
-assert(a == 'a@b@çd' and b == 2)
-assert(string.gsub('alo alo', '()[al]', '%1') == '12o 56o')
-assert(string.gsub("abc=xyz", "(%w*)(%p)(%w+)", "%3%2%1-%0") ==
-              "xyz=abc-abc=xyz")
-assert(string.gsub("abc", "%w", "%1%0") == "aabbcc")
-assert(string.gsub("abc", "%w+", "%0%1") == "abcabc")
-assert(string.gsub('áéí', '$', '\0óú') == 'áéí\0óú')
-assert(string.gsub('', '^', 'r') == 'r')
-assert(string.gsub('', '$', 'r') == 'r')
-print('+')
-
-
-do   -- new (5.3.3) semantics for empty matches
-  assert(string.gsub("a b cd", " *", "-") == "-a-b-c-d-")
-
-  local res = ""
-  local sub = "a  \nbc\t\td"
-  local i = 1
-  for p, e in string.gmatch(sub, "()%s*()") do
-    res = res .. string.sub(sub, i, p - 1) .. "-"
-    i = e
-  end
-  assert(res == "-a-b-c-d-")
-end
-
-
-assert(string.gsub("um (dois) tres (quatro)", "(%(%w+%))", string.upper) ==
-            "um (DOIS) tres (QUATRO)")
-
-do
-  local function setglobal (n,v) rawset(_G, n, v) end
-  string.gsub("a=roberto,roberto=a", "(%w+)=(%w%w*)", setglobal)
-  assert(_G.a=="roberto" and _G.roberto=="a")
-end
-
-function f(a,b) return string.gsub(a,'.',b) end
-assert(string.gsub("trocar tudo em |teste|b| é |beleza|al|", "|([^|]*)|([^|]*)|", f) ==
-            "trocar tudo em bbbbb é alalalalalal")
-
-local function dostring (s) return load(s, "")() or "" end
-assert(string.gsub("alo $a='x'$ novamente $return a$",
-                   "$([^$]*)%$",
-                   dostring) == "alo  novamente x")
-
-x = string.gsub("$x=string.gsub('alo', '.', string.upper)$ assim vai para $return x$",
-         "$([^$]*)%$", dostring)
-assert(x == ' assim vai para ALO')
-
-t = {}
-s = 'a alo jose  joao'
-r = string.gsub(s, '()(%w+)()', function (a,w,b)
-      assert(string.len(w) == b-a);
-      t[a] = b-a;
-    end)
-assert(s == r and t[1] == 1 and t[3] == 3 and t[7] == 4 and t[13] == 4)
-
-
-function isbalanced (s)
-  return string.find(string.gsub(s, "%b()", ""), "[()]") == nil
-end
-
-assert(isbalanced("(9 ((8))(\0) 7) \0\0 a b ()(c)() a"))
-assert(not isbalanced("(9 ((8) 7) a b (\0 c) a"))
-assert(string.gsub("alo 'oi' alo", "%b''", '"') == 'alo " alo')
-
-
-local t = {"apple", "orange", "lime"; n=0}
-assert(string.gsub("x and x and x", "x", function () t.n=t.n+1; return t[t.n] end)
-        == "apple and orange and lime")
-
-t = {n=0}
-string.gsub("first second word", "%w%w*", function (w) t.n=t.n+1; t[t.n] = w end)
-assert(t[1] == "first" and t[2] == "second" and t[3] == "word" and t.n == 3)
-
-t = {n=0}
-assert(string.gsub("first second word", "%w+",
-         function (w) t.n=t.n+1; t[t.n] = w end, 2) == "first second word")
-assert(t[1] == "first" and t[2] == "second" and t[3] == nil)
-
-checkerror("invalid replacement value %(a table%)",
-            string.gsub, "alo", ".", {a = {}})
-checkerror("invalid capture index %%2", string.gsub, "alo", ".", "%2")
-checkerror("invalid capture index %%0", string.gsub, "alo", "(%0)", "a")
-checkerror("invalid capture index %%1", string.gsub, "alo", "(%1)", "a")
-checkerror("invalid use of '%%'", string.gsub, "alo", ".", "%x")
-
--- bug since 2.5 (C-stack overflow)
-do
-  local function f (size)
-    local s = string.rep("a", size)
-    local p = string.rep(".?", size)
-    return pcall(string.match, s, p)
-  end
-  local r, m = f(80)
-  assert(r and #m == 80)
-  r, m = f(200000)
-  assert(not r and string.find(m, "too complex"))
-end
-
-if not _soft then
-  print("big strings")
-  local a = string.rep('a', 300000)
-  assert(string.find(a, '^a*.?$'))
-  assert(not string.find(a, '^a*.?b$'))
-  assert(string.find(a, '^a-.?$'))
-
-  -- bug in 5.1.2
-  a = string.rep('a', 10000) .. string.rep('b', 10000)
-  assert(not pcall(string.gsub, a, 'b'))
-end
-
--- recursive nest of gsubs
-function rev (s)
-  return string.gsub(s, "(.)(.+)", function (c,s1) return rev(s1)..c end)
-end
-
-local x = "abcdef"
-assert(rev(rev(x)) == x)
-
-
--- gsub with tables
-assert(string.gsub("alo alo", ".", {}) == "alo alo")
-assert(string.gsub("alo alo", "(.)", {a="AA", l=""}) == "AAo AAo")
-assert(string.gsub("alo alo", "(.).", {a="AA", l="K"}) == "AAo AAo")
-assert(string.gsub("alo alo", "((.)(.?))", {al="AA", o=false}) == "AAo AAo")
-
-assert(string.gsub("alo alo", "().", {'x','yy','zzz'}) == "xyyzzz alo")
-
-t = {}; setmetatable(t, {__index = function (t,s) return string.upper(s) end})
-assert(string.gsub("a alo b hi", "%w%w+", t) == "a ALO b HI")
-
-
--- tests for gmatch
-local a = 0
-for i in string.gmatch('abcde', '()') do assert(i == a+1); a=i end
-assert(a==6)
-
-t = {n=0}
-for w in string.gmatch("first second word", "%w+") do
-      t.n=t.n+1; t[t.n] = w
-end
-assert(t[1] == "first" and t[2] == "second" and t[3] == "word")
-
-t = {3, 6, 9}
-for i in string.gmatch ("xuxx uu ppar r", "()(.)%2") do
-  assert(i == table.remove(t, 1))
-end
-assert(#t == 0)
-
-t = {}
-for i,j in string.gmatch("13 14 10 = 11, 15= 16, 22=23", "(%d+)%s*=%s*(%d+)") do
-  t[tonumber(i)] = tonumber(j)
-end
-a = 0
-for k,v in pairs(t) do assert(k+1 == v+0); a=a+1 end
-assert(a == 3)
-
-
--- tests for `%f' (`frontiers')
-
-assert(string.gsub("aaa aa a aaa a", "%f[%w]a", "x") == "xaa xa x xaa x")
-assert(string.gsub("[[]] [][] [[[[", "%f[[].", "x") == "x[]] x]x] x[[[")
-assert(string.gsub("01abc45de3", "%f[%d]", ".") == ".01abc.45de.3")
-assert(string.gsub("01abc45 de3x", "%f[%D]%w", ".") == "01.bc45 de3.")
-assert(string.gsub("function", "%f[\1-\255]%w", ".") == ".unction")
-assert(string.gsub("function", "%f[^\1-\255]", ".") == "function.")
-
-assert(string.find("a", "%f[a]") == 1)
-assert(string.find("a", "%f[^%z]") == 1)
-assert(string.find("a", "%f[^%l]") == 2)
-assert(string.find("aba", "%f[a%z]") == 3)
-assert(string.find("aba", "%f[%z]") == 4)
-assert(not string.find("aba", "%f[%l%z]"))
-assert(not string.find("aba", "%f[^%l%z]"))
-
-local i, e = string.find(" alo aalo allo", "%f[%S].-%f[%s].-%f[%S]")
-assert(i == 2 and e == 5)
-local k = string.match(" alo aalo allo", "%f[%S](.-%f[%s].-%f[%S])")
-assert(k == 'alo ')
-
-local a = {1, 5, 9, 14, 17,}
-for k in string.gmatch("alo alo th02 is 1hat", "()%f[%w%d]") do
-  assert(table.remove(a, 1) == k)
-end
-assert(#a == 0)
-
-
--- malformed patterns
-local function malform (p, m)
-  m = m or "malformed"
-  local r, msg = pcall(string.find, "a", p)
-  assert(not r and string.find(msg, m))
-end
-
-malform("(.", "unfinished capture")
-malform(".)", "invalid pattern capture")
-malform("[a")
-malform("[]")
-malform("[^]")
-malform("[a%]")
-malform("[a%")
-malform("%b")
-malform("%ba")
-malform("%")
-malform("%f", "missing")
-
--- \0 in patterns
-assert(string.match("ab\0\1\2c", "[\0-\2]+") == "\0\1\2")
-assert(string.match("ab\0\1\2c", "[\0-\0]+") == "\0")
-assert(string.find("b$a", "$\0?") == 2)
-assert(string.find("abc\0efg", "%\0") == 4)
-assert(string.match("abc\0efg\0\1e\1g", "%b\0\1") == "\0efg\0\1e\1")
-assert(string.match("abc\0\0\0", "%\0+") == "\0\0\0")
-assert(string.match("abc\0\0\0", "%\0%\0?") == "\0\0")
-
--- magic char after \0
-assert(string.find("abc\0\0","\0.") == 4)
-assert(string.find("abcx\0\0abc\0abc","x\0\0abc\0a.") == 4)
-
-print('OK')
-

testes/sort.lua

@@ -1,310 +0,0 @@
--- $Id: sort.lua,v 1.38 2016/11/07 13:11:28 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print "testing (parts of) table library"
-
-print "testing unpack"
-
-local unpack = table.unpack
-
-local maxI = math.maxinteger
-local minI = math.mininteger
-
-
-local function checkerror (msg, f, ...)
-  local s, err = pcall(f, ...)
-  assert(not s and string.find(err, msg))
-end
-
-
-checkerror("wrong number of arguments", table.insert, {}, 2, 3, 4)
-
-local x,y,z,a,n
-a = {}; lim = _soft and 200 or 2000
-for i=1, lim do a[i]=i end
-assert(select(lim, unpack(a)) == lim and select('#', unpack(a)) == lim)
-x = unpack(a)
-assert(x == 1)
-x = {unpack(a)}
-assert(#x == lim and x[1] == 1 and x[lim] == lim)
-x = {unpack(a, lim-2)}
-assert(#x == 3 and x[1] == lim-2 and x[3] == lim)
-x = {unpack(a, 10, 6)}
-assert(next(x) == nil)   -- no elements
-x = {unpack(a, 11, 10)}
-assert(next(x) == nil)   -- no elements
-x,y = unpack(a, 10, 10)
-assert(x == 10 and y == nil)
-x,y,z = unpack(a, 10, 11)
-assert(x == 10 and y == 11 and z == nil)
-a,x = unpack{1}
-assert(a==1 and x==nil)
-a,x = unpack({1,2}, 1, 1)
-assert(a==1 and x==nil)
-
-do
-  local maxi = (1 << 31) - 1          -- maximum value for an int (usually)
-  local mini = -(1 << 31)             -- minimum value for an int (usually)
-  checkerror("too many results", unpack, {}, 0, maxi)
-  checkerror("too many results", unpack, {}, 1, maxi)
-  checkerror("too many results", unpack, {}, 0, maxI)
-  checkerror("too many results", unpack, {}, 1, maxI)
-  checkerror("too many results", unpack, {}, mini, maxi)
-  checkerror("too many results", unpack, {}, -maxi, maxi)
-  checkerror("too many results", unpack, {}, minI, maxI)
-  unpack({}, maxi, 0)
-  unpack({}, maxi, 1)
-  unpack({}, maxI, minI)
-  pcall(unpack, {}, 1, maxi + 1)
-  local a, b = unpack({[maxi] = 20}, maxi, maxi)
-  assert(a == 20 and b == nil)
-  a, b = unpack({[maxi] = 20}, maxi - 1, maxi)
-  assert(a == nil and b == 20)
-  local t = {[maxI - 1] = 12, [maxI] = 23}
-  a, b = unpack(t, maxI - 1, maxI); assert(a == 12 and b == 23)
-  a, b = unpack(t, maxI, maxI); assert(a == 23 and b == nil)
-  a, b = unpack(t, maxI, maxI - 1); assert(a == nil and b == nil)
-  t = {[minI] = 12.3, [minI + 1] = 23.5}
-  a, b = unpack(t, minI, minI + 1); assert(a == 12.3 and b == 23.5)
-  a, b = unpack(t, minI, minI); assert(a == 12.3 and b == nil)
-  a, b = unpack(t, minI + 1, minI); assert(a == nil and b == nil)
-end
-
-do   -- length is not an integer
-  local t = setmetatable({}, {__len = function () return 'abc' end})
-  assert(#t == 'abc')
-  checkerror("object length is not an integer", table.insert, t, 1)
-end
-
-print "testing pack"
-
-a = table.pack()
-assert(a[1] == nil and a.n == 0) 
-
-a = table.pack(table)
-assert(a[1] == table and a.n == 1)
-
-a = table.pack(nil, nil, nil, nil)
-assert(a[1] == nil and a.n == 4)
-
-
--- testing move
-do
-
-  checkerror("table expected", table.move, 1, 2, 3, 4)
-
-  local function eqT (a, b)
-    for k, v in pairs(a) do assert(b[k] == v) end 
-    for k, v in pairs(b) do assert(a[k] == v) end 
-  end
-
-  local a = table.move({10,20,30}, 1, 3, 2)  -- move forward
-  eqT(a, {10,10,20,30})
-
-  -- move forward with overlap of 1
-  a = table.move({10, 20, 30}, 1, 3, 3)
-  eqT(a, {10, 20, 10, 20, 30})
-
-  -- moving to the same table (not being explicit about it)
-  a = {10, 20, 30, 40}
-  table.move(a, 1, 4, 2, a)
-  eqT(a, {10, 10, 20, 30, 40})
-
-  a = table.move({10,20,30}, 2, 3, 1)   -- move backward
-  eqT(a, {20,30,30})
-
-  a = {}   -- move to new table
-  assert(table.move({10,20,30}, 1, 3, 1, a) == a)
-  eqT(a, {10,20,30})
-
-  a = {}
-  assert(table.move({10,20,30}, 1, 0, 3, a) == a)  -- empty move (no move)
-  eqT(a, {})
-
-  a = table.move({10,20,30}, 1, 10, 1)   -- move to the same place
-  eqT(a, {10,20,30})
-
-  -- moving on the fringes
-  a = table.move({[maxI - 2] = 1, [maxI - 1] = 2, [maxI] = 3},
-                 maxI - 2, maxI, -10, {})
-  eqT(a, {[-10] = 1, [-9] = 2, [-8] = 3})
-
-  a = table.move({[minI] = 1, [minI + 1] = 2, [minI + 2] = 3},
-                 minI, minI + 2, -10, {})
-  eqT(a, {[-10] = 1, [-9] = 2, [-8] = 3})
-
-  a = table.move({45}, 1, 1, maxI)
-  eqT(a, {45, [maxI] = 45})
-
-  a = table.move({[maxI] = 100}, maxI, maxI, minI)
-  eqT(a, {[minI] = 100, [maxI] = 100})
-
-  a = table.move({[minI] = 100}, minI, minI, maxI)
-  eqT(a, {[minI] = 100, [maxI] = 100})
-
-  a = setmetatable({}, {
-        __index = function (_,k) return k * 10 end,
-        __newindex = error})
-  local b = table.move(a, 1, 10, 3, {})
-  eqT(a, {})
-  eqT(b, {nil,nil,10,20,30,40,50,60,70,80,90,100})
-
-  b = setmetatable({""}, {
-        __index = error,
-        __newindex = function (t,k,v)
-          t[1] = string.format("%s(%d,%d)", t[1], k, v)
-      end})
-  table.move(a, 10, 13, 3, b)
-  assert(b[1] == "(3,100)(4,110)(5,120)(6,130)")
-  local stat, msg = pcall(table.move, b, 10, 13, 3, b)
-  assert(not stat and msg == b)
-end
-
-do
-  -- for very long moves, just check initial accesses and interrupt
-  -- move with an error
-  local function checkmove (f, e, t, x, y)
-    local pos1, pos2
-    local a = setmetatable({}, {
-                __index = function (_,k) pos1 = k end,
-                __newindex = function (_,k) pos2 = k; error() end, })
-    local st, msg = pcall(table.move, a, f, e, t)
-    assert(not st and not msg and pos1 == x and pos2 == y)
-  end
-  checkmove(1, maxI, 0, 1, 0)
-  checkmove(0, maxI - 1, 1, maxI - 1, maxI)
-  checkmove(minI, -2, -5, -2, maxI - 6)
-  checkmove(minI + 1, -1, -2, -1, maxI - 3)
-  checkmove(minI, -2, 0, minI, 0)  -- non overlapping
-  checkmove(minI + 1, -1, 1, minI + 1, 1)  -- non overlapping
-end
-
-checkerror("too many", table.move, {}, 0, maxI, 1)
-checkerror("too many", table.move, {}, -1, maxI - 1, 1)
-checkerror("too many", table.move, {}, minI, -1, 1)
-checkerror("too many", table.move, {}, minI, maxI, 1)
-checkerror("wrap around", table.move, {}, 1, maxI, 2)
-checkerror("wrap around", table.move, {}, 1, 2, maxI)
-checkerror("wrap around", table.move, {}, minI, -2, 2)
-
-
-print"testing sort"
-
-
--- strange lengths
-local a = setmetatable({}, {__len = function () return -1 end})
-assert(#a == -1)
-table.sort(a, error)    -- should not compare anything
-a = setmetatable({}, {__len = function () return maxI end})
-checkerror("too big", table.sort, a)
-
--- test checks for invalid order functions
-local function check (t)
-  local function f(a, b) assert(a and b); return true end
-  checkerror("invalid order function", table.sort, t, f)
-end
-
-check{1,2,3,4}
-check{1,2,3,4,5}
-check{1,2,3,4,5,6}
-
-
-function check (a, f)
-  f = f or function (x,y) return x<y end;
-  for n = #a, 2, -1 do
-    assert(not f(a[n], a[n-1]))
-  end
-end
-
-a = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep",
-     "Oct", "Nov", "Dec"}
-
-table.sort(a)
-check(a)
-
-function perm (s, n)
-  n = n or #s
-  if n == 1 then
-    local t = {unpack(s)}
-    table.sort(t)
-    check(t)
-  else
-    for i = 1, n do
-      s[i], s[n] = s[n], s[i]
-      perm(s, n - 1)
-      s[i], s[n] = s[n], s[i]
-    end
-  end
-end
-
-perm{}
-perm{1}
-perm{1,2}
-perm{1,2,3}
-perm{1,2,3,4}
-perm{2,2,3,4}
-perm{1,2,3,4,5}
-perm{1,2,3,3,5}
-perm{1,2,3,4,5,6}
-perm{2,2,3,3,5,6}
-
-function timesort (a, n, func, msg, pre)
-  local x = os.clock()
-  table.sort(a, func)
-  x = (os.clock() - x) * 1000
-  pre = pre or ""
-  print(string.format("%ssorting %d %s elements in %.2f msec.", pre, n, msg, x))
-  check(a, func)
-end
-
-limit = 50000
-if _soft then limit = 5000 end
-
-a = {}
-for i=1,limit do
-  a[i] = math.random()
-end
-
-timesort(a, limit, nil, "random")
-
-timesort(a, limit, nil, "sorted", "re-")
-
-a = {}
-for i=1,limit do
-  a[i] = math.random()
-end
-
-x = os.clock(); i=0
-table.sort(a, function(x,y) i=i+1; return y<x end)
-x = (os.clock() - x) * 1000
-print(string.format("Invert-sorting other %d elements in %.2f msec., with %i comparisons",
-      limit, x, i))
-check(a, function(x,y) return y<x end)
-
-
-table.sort{}  -- empty array
-
-for i=1,limit do a[i] = false end
-timesort(a, limit,  function(x,y) return nil end, "equal")
-
-for i,v in pairs(a) do assert(v == false) end
-
-A = {"álo", "\0first :-)", "alo", "then this one", "45", "and a new"}
-table.sort(A)
-check(A)
-
-table.sort(A, function (x, y)
-          load(string.format("A[%q] = ''", x), "")()
-          collectgarbage()
-          return x<y
-        end)
-
-
-tt = {__lt = function (a,b) return a.val < b.val end}
-a = {}
-for i=1,10 do  a[i] = {val=math.random(100)}; setmetatable(a[i], tt); end
-table.sort(a)
-check(a, tt.__lt)
-check(a)
-
-print"OK"

testes/strings.lua

@@ -1,379 +0,0 @@
--- $Id: strings.lua,v 1.87 2016/12/21 19:23:02 roberto Exp $
--- See Copyright Notice in file all.lua
-
-print('testing strings and string library')
-
-local maxi, mini = math.maxinteger, math.mininteger
-
-
-local function checkerror (msg, f, ...)
-  local s, err = pcall(f, ...)
-  assert(not s and string.find(err, msg))
-end
-
-
--- testing string comparisons
-assert('alo' < 'alo1')
-assert('' < 'a')
-assert('alo\0alo' < 'alo\0b')
-assert('alo\0alo\0\0' > 'alo\0alo\0')
-assert('alo' < 'alo\0')
-assert('alo\0' > 'alo')
-assert('\0' < '\1')
-assert('\0\0' < '\0\1')
-assert('\1\0a\0a' <= '\1\0a\0a')
-assert(not ('\1\0a\0b' <= '\1\0a\0a'))
-assert('\0\0\0' < '\0\0\0\0')
-assert(not('\0\0\0\0' < '\0\0\0'))
-assert('\0\0\0' <= '\0\0\0\0')
-assert(not('\0\0\0\0' <= '\0\0\0'))
-assert('\0\0\0' <= '\0\0\0')
-assert('\0\0\0' >= '\0\0\0')
-assert(not ('\0\0b' < '\0\0a\0'))
-
--- testing string.sub
-assert(string.sub("123456789",2,4) == "234")
-assert(string.sub("123456789",7) == "789")
-assert(string.sub("123456789",7,6) == "")
-assert(string.sub("123456789",7,7) == "7")
-assert(string.sub("123456789",0,0) == "")
-assert(string.sub("123456789",-10,10) == "123456789")
-assert(string.sub("123456789",1,9) == "123456789")
-assert(string.sub("123456789",-10,-20) == "")
-assert(string.sub("123456789",-1) == "9")
-assert(string.sub("123456789",-4) == "6789")
-assert(string.sub("123456789",-6, -4) == "456")
-assert(string.sub("123456789", mini, -4) == "123456")
-assert(string.sub("123456789", mini, maxi) == "123456789")
-assert(string.sub("123456789", mini, mini) == "")
-assert(string.sub("\000123456789",3,5) == "234")
-assert(("\000123456789"):sub(8) == "789")
-
--- testing string.find
-assert(string.find("123456789", "345") == 3)
-a,b = string.find("123456789", "345")
-assert(string.sub("123456789", a, b) == "345")
-assert(string.find("1234567890123456789", "345", 3) == 3)
-assert(string.find("1234567890123456789", "345", 4) == 13)
-assert(string.find("1234567890123456789", "346", 4) == nil)
-assert(string.find("1234567890123456789", ".45", -9) == 13)
-assert(string.find("abcdefg", "\0", 5, 1) == nil)
-assert(string.find("", "") == 1)
-assert(string.find("", "", 1) == 1)
-assert(not string.find("", "", 2))
-assert(string.find('', 'aaa', 1) == nil)
-assert(('alo(.)alo'):find('(.)', 1, 1) == 4)
-
-assert(string.len("") == 0)
-assert(string.len("\0\0\0") == 3)
-assert(string.len("1234567890") == 10)
-
-assert(#"" == 0)
-assert(#"\0\0\0" == 3)
-assert(#"1234567890" == 10)
-
--- testing string.byte/string.char
-assert(string.byte("a") == 97)
-assert(string.byte("\xe4") > 127)
-assert(string.byte(string.char(255)) == 255)
-assert(string.byte(string.char(0)) == 0)
-assert(string.byte("\0") == 0)
-assert(string.byte("\0\0alo\0x", -1) == string.byte('x'))
-assert(string.byte("ba", 2) == 97)
-assert(string.byte("\n\n", 2, -1) == 10)
-assert(string.byte("\n\n", 2, 2) == 10)
-assert(string.byte("") == nil)
-assert(string.byte("hi", -3) == nil)
-assert(string.byte("hi", 3) == nil)
-assert(string.byte("hi", 9, 10) == nil)
-assert(string.byte("hi", 2, 1) == nil)
-assert(string.char() == "")
-assert(string.char(0, 255, 0) == "\0\255\0")
-assert(string.char(0, string.byte("\xe4"), 0) == "\0\xe4\0")
-assert(string.char(string.byte("\xe4l\0óu", 1, -1)) == "\xe4l\0óu")
-assert(string.char(string.byte("\xe4l\0óu", 1, 0)) == "")
-assert(string.char(string.byte("\xe4l\0óu", -10, 100)) == "\xe4l\0óu")
-
-assert(string.upper("ab\0c") == "AB\0C")
-assert(string.lower("\0ABCc%$") == "\0abcc%$")
-assert(string.rep('teste', 0) == '')
-assert(string.rep('tés\00tê', 2) == 'tés\0têtés\000tê')
-assert(string.rep('', 10) == '')
-
-if string.packsize("i") == 4 then
-  -- result length would be 2^31 (int overflow)
-  checkerror("too large", string.rep, 'aa', (1 << 30))
-  checkerror("too large", string.rep, 'a', (1 << 30), ',')
-end
-
--- repetitions with separator
-assert(string.rep('teste', 0, 'xuxu') == '')
-assert(string.rep('teste', 1, 'xuxu') == 'teste')
-assert(string.rep('\1\0\1', 2, '\0\0') == '\1\0\1\0\0\1\0\1')
-assert(string.rep('', 10, '.') == string.rep('.', 9))
-assert(not pcall(string.rep, "aa", maxi // 2 + 10))
-assert(not pcall(string.rep, "", maxi // 2 + 10, "aa"))
-
-assert(string.reverse"" == "")
-assert(string.reverse"\0\1\2\3" == "\3\2\1\0")
-assert(string.reverse"\0001234" == "4321\0")
-
-for i=0,30 do assert(string.len(string.rep('a', i)) == i) end
-
-assert(type(tostring(nil)) == 'string')
-assert(type(tostring(12)) == 'string')
-assert(string.find(tostring{}, 'table:'))
-assert(string.find(tostring(print), 'function:'))
-assert(#tostring('\0') == 1)
-assert(tostring(true) == "true")
-assert(tostring(false) == "false")
-assert(tostring(-1203) == "-1203")
-assert(tostring(1203.125) == "1203.125")
-assert(tostring(-0.5) == "-0.5")
-assert(tostring(-32767) == "-32767")
-if math.tointeger(2147483647) then   -- no overflow? (32 bits)
-  assert(tostring(-2147483647) == "-2147483647")
-end
-if math.tointeger(4611686018427387904) then   -- no overflow? (64 bits)
-  assert(tostring(4611686018427387904) == "4611686018427387904")
-  assert(tostring(-4611686018427387904) == "-4611686018427387904")
-end
-
-if tostring(0.0) == "0.0" then   -- "standard" coercion float->string
-  assert('' .. 12 == '12' and 12.0 .. '' == '12.0')
-  assert(tostring(-1203 + 0.0) == "-1203.0")
-else   -- compatible coercion
-  assert(tostring(0.0) == "0")
-  assert('' .. 12 == '12' and 12.0 .. '' == '12')
-  assert(tostring(-1203 + 0.0) == "-1203")
-end
-
-
-x = '"ílo"\n\\'
-assert(string.format('%q%s', x, x) == '"\\"ílo\\"\\\n\\\\""ílo"\n\\')
-assert(string.format('%q', "\0") == [["\0"]])
-assert(load(string.format('return %q', x))() == x)
-x = "\0\1\0023\5\0009"
-assert(load(string.format('return %q', x))() == x)
-assert(string.format("\0%c\0%c%x\0", string.byte("\xe4"), string.byte("b"), 140) ==
-              "\0\xe4\0b8c\0")
-assert(string.format('') == "")
-assert(string.format("%c",34)..string.format("%c",48)..string.format("%c",90)..string.format("%c",100) ==
-       string.format("%c%c%c%c", 34, 48, 90, 100))
-assert(string.format("%s\0 is not \0%s", 'not be', 'be') == 'not be\0 is not \0be')
-assert(string.format("%%%d %010d", 10, 23) == "%10 0000000023")
-assert(tonumber(string.format("%f", 10.3)) == 10.3)
-x = string.format('"%-50s"', 'a')
-assert(#x == 52)
-assert(string.sub(x, 1, 4) == '"a  ')
-
-assert(string.format("-%.20s.20s", string.rep("%", 2000)) ==
-                     "-"..string.rep("%", 20)..".20s")
-assert(string.format('"-%20s.20s"', string.rep("%", 2000)) ==
-       string.format("%q", "-"..string.rep("%", 2000)..".20s"))
-
-do
-  local function checkQ (v)
-    local s = string.format("%q", v)
-    local nv = load("return " .. s)()
-    assert(v == nv and math.type(v) == math.type(nv))
-  end
-  checkQ("\0\0\1\255\u{234}")
-  checkQ(math.maxinteger)
-  checkQ(math.mininteger)
-  checkQ(math.pi)
-  checkQ(0.1)
-  checkQ(true)
-  checkQ(nil)
-  checkQ(false)
-  checkerror("no literal", string.format, "%q", {})
-end
-
-assert(string.format("\0%s\0", "\0\0\1") == "\0\0\0\1\0")
-checkerror("contains zeros", string.format, "%10s", "\0")
-
--- format x tostring
-assert(string.format("%s %s", nil, true) == "nil true")
-assert(string.format("%s %.4s", false, true) == "false true")
-assert(string.format("%.3s %.3s", false, true) == "fal tru")
-local m = setmetatable({}, {__tostring = function () return "hello" end,
-                            __name = "hi"})
-assert(string.format("%s %.10s", m, m) == "hello hello")
-getmetatable(m).__tostring = nil   -- will use '__name' from now on
-assert(string.format("%.4s", m) == "hi: ")
-
-getmetatable(m).__tostring = function () return {} end
-checkerror("'__tostring' must return a string", tostring, m)
-
-
-assert(string.format("%x", 0.0) == "0")
-assert(string.format("%02x", 0.0) == "00")
-assert(string.format("%08X", 0xFFFFFFFF) == "FFFFFFFF")
-assert(string.format("%+08d", 31501) == "+0031501")
-assert(string.format("%+08d", -30927) == "-0030927")
-
-
-do    -- longest number that can be formatted
-  local i = 1
-  local j = 10000
-  while i + 1 < j do   -- binary search for maximum finite float
-    local m = (i + j) // 2
-    if 10^m < math.huge then i = m else j = m end
-  end
-  assert(10^i < math.huge and 10^j == math.huge)
-  local s = string.format('%.99f', -(10^i))
-  assert(string.len(s) >= i + 101)
-  assert(tonumber(s) == -(10^i))
-end
-
-
--- testing large numbers for format
-do   -- assume at least 32 bits
-  local max, min = 0x7fffffff, -0x80000000    -- "large" for 32 bits
-  assert(string.sub(string.format("%8x", -1), -8) == "ffffffff")
-  assert(string.format("%x", max) == "7fffffff")
-  assert(string.sub(string.format("%x", min), -8) == "80000000")
-  assert(string.format("%d", max) ==  "2147483647")
-  assert(string.format("%d", min) == "-2147483648")
-  assert(string.format("%u", 0xffffffff) == "4294967295")
-  assert(string.format("%o", 0xABCD) == "125715")
-
-  max, min = 0x7fffffffffffffff, -0x8000000000000000
-  if max > 2.0^53 then  -- only for 64 bits
-    assert(string.format("%x", (2^52 | 0) - 1) == "fffffffffffff")
-    assert(string.format("0x%8X", 0x8f000003) == "0x8F000003")
-    assert(string.format("%d", 2^53) == "9007199254740992")
-    assert(string.format("%i", -2^53) == "-9007199254740992")
-    assert(string.format("%x", max) == "7fffffffffffffff")
-    assert(string.format("%x", min) == "8000000000000000")
-    assert(string.format("%d", max) ==  "9223372036854775807")
-    assert(string.format("%d", min) == "-9223372036854775808")
-    assert(string.format("%u", ~(-1 << 64)) == "18446744073709551615")
-    assert(tostring(1234567890123) == '1234567890123')
-  end
-end
-
-
-do print("testing 'format %a %A'")
-  local function matchhexa (n)
-    local s = string.format("%a", n)
-    -- result matches ISO C requirements
-    assert(string.find(s, "^%-?0x[1-9a-f]%.?[0-9a-f]*p[-+]?%d+$"))
-    assert(tonumber(s) == n)  -- and has full precision
-    s = string.format("%A", n)
-    assert(string.find(s, "^%-?0X[1-9A-F]%.?[0-9A-F]*P[-+]?%d+$"))
-    assert(tonumber(s) == n)
-  end
-  for _, n in ipairs{0.1, -0.1, 1/3, -1/3, 1e30, -1e30,
-                     -45/247, 1, -1, 2, -2, 3e-20, -3e-20} do
-    matchhexa(n)
-  end
-
-  assert(string.find(string.format("%A", 0.0), "^0X0%.?0*P%+?0$"))
-  assert(string.find(string.format("%a", -0.0), "^%-0x0%.?0*p%+?0$"))
-
-  if not _port then   -- test inf, -inf, NaN, and -0.0
-    assert(string.find(string.format("%a", 1/0), "^inf"))
-    assert(string.find(string.format("%A", -1/0), "^%-INF"))
-    assert(string.find(string.format("%a", 0/0), "^%-?nan"))
-    assert(string.find(string.format("%a", -0.0), "^%-0x0"))
-  end
-  
-  if not pcall(string.format, "%.3a", 0) then
-    (Message or print)("\n >>> modifiers for format '%a' not available <<<\n")
-  else
-    assert(string.find(string.format("%+.2A", 12), "^%+0X%x%.%x0P%+?%d$"))
-    assert(string.find(string.format("%.4A", -12), "^%-0X%x%.%x000P%+?%d$"))
-  end
-end
-
-
--- errors in format
-
-local function check (fmt, msg)
-  checkerror(msg, string.format, fmt, 10)
-end
-
-local aux = string.rep('0', 600)
-check("%100.3d", "too long")
-check("%1"..aux..".3d", "too long")
-check("%1.100d", "too long")
-check("%10.1"..aux.."004d", "too long")
-check("%t", "invalid option")
-check("%"..aux.."d", "repeated flags")
-check("%d %d", "no value")
-
-
-assert(load("return 1\n--comment without ending EOL")() == 1)
-
-
-checkerror("table expected", table.concat, 3)
-assert(table.concat{} == "")
-assert(table.concat({}, 'x') == "")
-assert(table.concat({'\0', '\0\1', '\0\1\2'}, '.\0.') == "\0.\0.\0\1.\0.\0\1\2")
-local a = {}; for i=1,300 do a[i] = "xuxu" end
-assert(table.concat(a, "123").."123" == string.rep("xuxu123", 300))
-assert(table.concat(a, "b", 20, 20) == "xuxu")
-assert(table.concat(a, "", 20, 21) == "xuxuxuxu")
-assert(table.concat(a, "x", 22, 21) == "")
-assert(table.concat(a, "3", 299) == "xuxu3xuxu")
-assert(table.concat({}, "x", maxi, maxi - 1) == "")
-assert(table.concat({}, "x", mini + 1, mini) == "")
-assert(table.concat({}, "x", maxi, mini) == "")
-assert(table.concat({[maxi] = "alo"}, "x", maxi, maxi) == "alo")
-assert(table.concat({[maxi] = "alo", [maxi - 1] = "y"}, "-", maxi - 1, maxi)
-       == "y-alo")
-
-assert(not pcall(table.concat, {"a", "b", {}}))
-
-a = {"a","b","c"}
-assert(table.concat(a, ",", 1, 0) == "")
-assert(table.concat(a, ",", 1, 1) == "a")
-assert(table.concat(a, ",", 1, 2) == "a,b")
-assert(table.concat(a, ",", 2) == "b,c")
-assert(table.concat(a, ",", 3) == "c")
-assert(table.concat(a, ",", 4) == "")
-
-if not _port then
-
-  local locales = { "ptb", "pt_BR.iso88591", "ISO-8859-1" }
-  local function trylocale (w)
-    for i = 1, #locales do
-      if os.setlocale(locales[i], w) then
-        print(string.format("'%s' locale set to '%s'", w, locales[i]))
-        return locales[i]
-      end
-    end
-    print(string.format("'%s' locale not found", w))
-    return false
-  end
-
-  if trylocale("collate")  then
-    assert("alo" < "álo" and "álo" < "amo")
-  end
-
-  if trylocale("ctype") then
-    assert(string.gsub("áéíóú", "%a", "x") == "xxxxx")
-    assert(string.gsub("áÁéÉ", "%l", "x") == "xÁxÉ")
-    assert(string.gsub("áÁéÉ", "%u", "x") == "áxéx")
-    assert(string.upper"áÁé{xuxu}ção" == "ÁÁÉ{XUXU}ÇÃO")
-  end
-
-  os.setlocale("C")
-  assert(os.setlocale() == 'C')
-  assert(os.setlocale(nil, "numeric") == 'C')
-
-end
-
-
--- bug in Lua 5.3.2
--- 'gmatch' iterator does not work across coroutines
-do
-  local f = string.gmatch("1 2 3 4 5", "%d+")
-  assert(f() == "1")
-  co = coroutine.wrap(f)
-  assert(co() == "2")
-end
-
-print('OK')
-