99 files changed, 21665 insertions, 87 deletions

diff --git a/all b/all
new file mode 100755
index 00000000..12acaf36
--- /dev/null
+++ b/all
@@ -0,0 +1,7 @@
+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
diff --git a/lapi.c b/lapi.c
index 1c4d07dd..02b7fab7 100644
--- a/lapi.c
+++ b/lapi.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.c,v 2.258 2016/01/05 16:07:21 roberto Exp roberto $
+** $Id: lapi.c,v 2.259.1.2 2017/12/06 18:35:12 roberto Exp $
 ** Lua API
 ** See Copyright Notice in lua.h
 */
@@ -533,6 +533,7 @@ LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
   lua_lock(L);
   if (n == 0) {
     setfvalue(L->top, fn);
+    api_incr_top(L);
   }
   else {
     CClosure *cl;
@@ -546,9 +547,9 @@ LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
       /* does not need barrier because closure is white */
     }
     setclCvalue(L, L->top, cl);
+    api_incr_top(L);
+    luaC_checkGC(L);
   }
-  api_incr_top(L);
-  luaC_checkGC(L);
   lua_unlock(L);
 }
 
diff --git a/lapi.h b/lapi.h
index b39898eb..8e16ad53 100644
--- a/lapi.h
+++ b/lapi.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lapi.h,v 2.8 2014/07/15 21:26:50 roberto Exp roberto $
+** $Id: lapi.h,v 2.9.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Auxiliary functions from Lua API
 ** See Copyright Notice in lua.h
 */
diff --git a/lauxlib.c b/lauxlib.c
index 7b14ca4d..8bdada50 100644
--- a/lauxlib.c
+++ b/lauxlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lauxlib.c,v 1.288 2016/12/04 20:17:24 roberto Exp roberto $
+** $Id: lauxlib.c,v 1.289.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
diff --git a/lauxlib.h b/lauxlib.h
index 1d65c975..9857d3a8 100644
--- a/lauxlib.h
+++ b/lauxlib.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lauxlib.h,v 1.130 2016/12/04 20:17:24 roberto Exp roberto $
+** $Id: lauxlib.h,v 1.131.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Auxiliary functions for building Lua libraries
 ** See Copyright Notice in lua.h
 */
diff --git a/lbaselib.c b/lbaselib.c
index 98602952..6460e4f8 100644
--- a/lbaselib.c
+++ b/lbaselib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lbaselib.c,v 1.313 2016/04/11 19:18:40 roberto Exp roberto $
+** $Id: lbaselib.c,v 1.314.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Basic library
 ** See Copyright Notice in lua.h
 */
diff --git a/lbitlib.c b/lbitlib.c
index 02483d69..4786c0d4 100644
--- a/lbitlib.c
+++ b/lbitlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lbitlib.c,v 1.29 2015/10/08 15:55:35 roberto Exp roberto $
+** $Id: lbitlib.c,v 1.30.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Standard library for bitwise operations
 ** See Copyright Notice in lua.h
 */
diff --git a/lcode.c b/lcode.c
index aca0256d..12619f54 100644
--- a/lcode.c
+++ b/lcode.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.c,v 2.111 2016/07/19 17:12:07 roberto Exp roberto $
+** $Id: lcode.c,v 2.112.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
diff --git a/lcode.h b/lcode.h
index d2b5100e..882dc9c1 100644
--- a/lcode.h
+++ b/lcode.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.h,v 1.63 2013/12/30 20:47:58 roberto Exp roberto $
+** $Id: lcode.h,v 1.64.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
diff --git a/lcorolib.c b/lcorolib.c
index 95467264..0b17af9e 100644
--- a/lcorolib.c
+++ b/lcorolib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lcorolib.c,v 1.9 2014/11/02 19:19:04 roberto Exp roberto $
+** $Id: lcorolib.c,v 1.10.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Coroutine Library
 ** See Copyright Notice in lua.h
 */
diff --git a/lctype.c b/lctype.c
index 367640c6..f8ad7a2e 100644
--- a/lctype.c
+++ b/lctype.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lctype.c,v 1.11 2011/10/03 16:19:23 roberto Exp roberto $
+** $Id: lctype.c,v 1.12.1.1 2017/04/19 17:20:42 roberto Exp $
 ** 'ctype' functions for Lua
 ** See Copyright Notice in lua.h
 */
diff --git a/lctype.h b/lctype.h
index 5dc17013..b09b21a3 100644
--- a/lctype.h
+++ b/lctype.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lctype.h,v 1.11 2011/06/27 18:22:46 roberto Exp roberto $
+** $Id: lctype.h,v 1.12.1.1 2013/04/12 18:48:47 roberto Exp $
 ** 'ctype' functions for Lua
 ** See Copyright Notice in lua.h
 */
diff --git a/ldblib.c b/ldblib.c
index 0bcd2e9e..9d29afb0 100644
--- a/ldblib.c
+++ b/ldblib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldblib.c,v 1.150 2015/11/19 19:16:22 roberto Exp roberto $
+** $Id: ldblib.c,v 1.151.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Interface from Lua to its debug API
 ** See Copyright Notice in lua.h
 */
diff --git a/ldebug.c b/ldebug.c
index f1835890..e1389296 100644
--- a/ldebug.c
+++ b/ldebug.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.c,v 2.120 2016/03/31 19:01:21 roberto Exp roberto $
+** $Id: ldebug.c,v 2.121.1.2 2017/07/10 17:21:50 roberto Exp $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
@@ -653,6 +653,7 @@ l_noret luaG_runerror (lua_State *L, const char *fmt, ...) {
   CallInfo *ci = L->ci;
   const char *msg;
   va_list argp;
+  luaC_checkGC(L);  /* error message uses memory */
   va_start(argp, fmt);
   msg = luaO_pushvfstring(L, fmt, argp);  /* format message */
   va_end(argp);
diff --git a/ldebug.h b/ldebug.h
index 9c0a03a6..8cea0ee0 100644
--- a/ldebug.h
+++ b/ldebug.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.h,v 2.13 2015/03/11 16:10:41 roberto Exp roberto $
+** $Id: ldebug.h,v 2.14.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Auxiliary functions from Debug Interface module
 ** See Copyright Notice in lua.h
 */
diff --git a/ldo.c b/ldo.c
index 13387516..316e45c8 100644
--- a/ldo.c
+++ b/ldo.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.c,v 2.156 2016/09/20 16:37:45 roberto Exp roberto $
+** $Id: ldo.c,v 2.157.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
diff --git a/ldo.h b/ldo.h
index b2065cfa..3b2983a3 100644
--- a/ldo.h
+++ b/ldo.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ldo.h,v 2.28 2015/11/23 11:29:43 roberto Exp roberto $
+** $Id: ldo.h,v 2.29.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Stack and Call structure of Lua
 ** See Copyright Notice in lua.h
 */
diff --git a/ldump.c b/ldump.c
index 19030edc..f025acac 100644
--- a/ldump.c
+++ b/ldump.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldump.c,v 2.36 2015/03/30 15:43:51 roberto Exp roberto $
+** $Id: ldump.c,v 2.37.1.1 2017/04/19 17:20:42 roberto Exp $
 ** save precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
diff --git a/lfunc.c b/lfunc.c
index 4c10230e..ccafbb8a 100644
--- a/lfunc.c
+++ b/lfunc.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.c,v 2.44 2014/10/25 11:50:46 roberto Exp roberto $
+** $Id: lfunc.c,v 2.45.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
diff --git a/lfunc.h b/lfunc.h
index 6fd3fbac..c916e987 100644
--- a/lfunc.h
+++ b/lfunc.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lfunc.h,v 2.14 2014/06/19 18:27:20 roberto Exp roberto $
+** $Id: lfunc.h,v 2.15.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Auxiliary functions to manipulate prototypes and closures
 ** See Copyright Notice in lua.h
 */
diff --git a/lgc.c b/lgc.c
index de3f2a21..db4df829 100644
--- a/lgc.c
+++ b/lgc.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lgc.c,v 2.214 2016/11/07 12:38:35 roberto Exp roberto $
+** $Id: lgc.c,v 2.215.1.2 2017/08/31 16:15:27 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
@@ -643,8 +643,9 @@ static void clearkeys (global_State *g, GCObject *l, GCObject *f) {
     for (n = gnode(h, 0); n < limit; n++) {
       if (!ttisnil(gval(n)) && (iscleared(g, gkey(n)))) {
         setnilvalue(gval(n));  /* remove value ... */
-        removeentry(n);  /* and remove entry from table */
       }
+      if (ttisnil(gval(n)))  /* is entry empty? */
+        removeentry(n);  /* remove entry from table */
     }
   }
 }
diff --git a/lgc.h b/lgc.h
index 75f24bc0..425cd7ce 100644
--- a/lgc.h
+++ b/lgc.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lgc.h,v 2.90 2015/10/21 18:15:15 roberto Exp roberto $
+** $Id: lgc.h,v 2.91.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Garbage Collector
 ** See Copyright Notice in lua.h
 */
diff --git a/linit.c b/linit.c
index 897ae352..480da52c 100644
--- a/linit.c
+++ b/linit.c
@@ -1,5 +1,5 @@
 /*
-** $Id: linit.c,v 1.38 2015/01/05 13:48:33 roberto Exp roberto $
+** $Id: linit.c,v 1.39.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Initialization of libraries for lua.c and other clients
 ** See Copyright Notice in lua.h
 */
diff --git a/liolib.c b/liolib.c
index 8491edca..8a9e75cd 100644
--- a/liolib.c
+++ b/liolib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: liolib.c,v 2.150 2016/09/01 16:14:56 roberto Exp roberto $
+** $Id: liolib.c,v 2.151.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Standard I/O (and system) library
 ** See Copyright Notice in lua.h
 */
@@ -206,11 +206,16 @@ static int aux_close (lua_State *L) {
 }
 
 
+static int f_close (lua_State *L) {
+  tofile(L);  /* make sure argument is an open stream */
+  return aux_close(L);
+}
+
+
 static int io_close (lua_State *L) {
   if (lua_isnone(L, 1))  /* no argument? */
     lua_getfield(L, LUA_REGISTRYINDEX, IO_OUTPUT);  /* use standard output */
-  tofile(L);  /* make sure argument is an open stream */
-  return aux_close(L);
+  return f_close(L);
 }
 
 
@@ -712,7 +717,7 @@ static const luaL_Reg iolib[] = {
 ** methods for file handles
 */
 static const luaL_Reg flib[] = {
-  {"close", io_close},
+  {"close", f_close},
   {"flush", f_flush},
   {"lines", f_lines},
   {"read", f_read},
diff --git a/llex.c b/llex.c
index 8f44cbef..66fd411b 100644
--- a/llex.c
+++ b/llex.c
@@ -1,5 +1,5 @@
 /*
-** $Id: llex.c,v 2.95 2015/11/19 19:16:22 roberto Exp roberto $
+** $Id: llex.c,v 2.96.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
diff --git a/llex.h b/llex.h
index a50b6873..2ed0af66 100644
--- a/llex.h
+++ b/llex.h
@@ -1,5 +1,5 @@
 /*
-** $Id: llex.h,v 1.78 2014/10/29 15:38:24 roberto Exp roberto $
+** $Id: llex.h,v 1.79.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Lexical Analyzer
 ** See Copyright Notice in lua.h
 */
diff --git a/llimits.h b/llimits.h
index fa14dfc7..d1036f6b 100644
--- a/llimits.h
+++ b/llimits.h
@@ -1,5 +1,5 @@
 /*
-** $Id: llimits.h,v 1.140 2015/10/21 18:40:47 roberto Exp roberto $
+** $Id: llimits.h,v 1.141.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Limits, basic types, and some other 'installation-dependent' definitions
 ** See Copyright Notice in lua.h
 */
diff --git a/lmathlib.c b/lmathlib.c
index e0240c9b..7ef7e593 100644
--- a/lmathlib.c
+++ b/lmathlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lmathlib.c,v 1.118 2016/12/20 18:37:00 roberto Exp roberto $
+** $Id: lmathlib.c,v 1.119.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Standard mathematical library
 ** See Copyright Notice in lua.h
 */
diff --git a/lmem.c b/lmem.c
index 83a9082c..0241cc3b 100644
--- a/lmem.c
+++ b/lmem.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lmem.c,v 1.90 2015/03/03 18:18:29 roberto Exp roberto $
+** $Id: lmem.c,v 1.91.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
diff --git a/lmem.h b/lmem.h
index 7af316f0..357b1e43 100644
--- a/lmem.h
+++ b/lmem.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lmem.h,v 1.42 2014/12/19 13:45:40 roberto Exp roberto $
+** $Id: lmem.h,v 1.43.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Interface to Memory Manager
 ** See Copyright Notice in lua.h
 */
diff --git a/loadlib.c b/loadlib.c
index d1941a99..45f44d32 100644
--- a/loadlib.c
+++ b/loadlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: loadlib.c,v 1.129 2016/12/04 20:17:24 roberto Exp roberto $
+** $Id: loadlib.c,v 1.130.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Dynamic library loader for Lua
 ** See Copyright Notice in lua.h
 **
diff --git a/lobject.c b/lobject.c
index e234df3d..2218c8cd 100644
--- a/lobject.c
+++ b/lobject.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.c,v 2.112 2016/06/27 13:15:08 roberto Exp roberto $
+** $Id: lobject.c,v 2.113.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Some generic functions over Lua objects
 ** See Copyright Notice in lua.h
 */
@@ -435,7 +435,8 @@ const char *luaO_pushvfstring (lua_State *L, const char *fmt, va_list argp) {
       }
       case 'p': {  /* a pointer */
         char buff[4*sizeof(void *) + 8]; /* should be enough space for a '%p' */
-        int l = l_sprintf(buff, sizeof(buff), "%p", va_arg(argp, void *));
+        void *p = va_arg(argp, void *);
+        int l = lua_pointer2str(buff, sizeof(buff), p);
         pushstr(L, buff, l);
         break;
       }
diff --git a/lobject.h b/lobject.h
index eeddfdef..24088614 100644
--- a/lobject.h
+++ b/lobject.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lobject.h,v 2.116 2015/11/03 18:33:10 roberto Exp roberto $
+** $Id: lobject.h,v 2.117.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Type definitions for Lua objects
 ** See Copyright Notice in lua.h
 */
diff --git a/lopcodes.c b/lopcodes.c
index 10d4bbce..5ca3eb26 100644
--- a/lopcodes.c
+++ b/lopcodes.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.c,v 1.54 2014/11/02 19:19:04 roberto Exp roberto $
+** $Id: lopcodes.c,v 1.55.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
diff --git a/lopcodes.h b/lopcodes.h
index dd2a7571..6feaa1cd 100644
--- a/lopcodes.h
+++ b/lopcodes.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.h,v 1.148 2014/10/25 11:50:46 roberto Exp roberto $
+** $Id: lopcodes.h,v 1.149.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
diff --git a/loslib.c b/loslib.c
index dd2bb378..de590c6b 100644
--- a/loslib.c
+++ b/loslib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: loslib.c,v 1.64 2016/04/18 13:06:55 roberto Exp $
+** $Id: loslib.c,v 1.65.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Standard Operating System library
 ** See Copyright Notice in lua.h
 */
@@ -293,7 +293,8 @@ static int os_date (lua_State *L) {
   else
     stm = l_localtime(&t, &tmr);
   if (stm == NULL)  /* invalid date? */
-    luaL_error(L, "time result cannot be represented in this installation");
+    return luaL_error(L,
+                 "time result cannot be represented in this installation");
   if (strcmp(s, "*t") == 0) {
     lua_createtable(L, 0, 9);  /* 9 = number of fields */
     setallfields(L, stm);
@@ -340,7 +341,8 @@ static int os_time (lua_State *L) {
     setallfields(L, &ts);  /* update fields with normalized values */
   }
   if (t != (time_t)(l_timet)t || t == (time_t)(-1))
-    luaL_error(L, "time result cannot be represented in this installation");
+    return luaL_error(L,
+                  "time result cannot be represented in this installation");
   l_pushtime(L, t);
   return 1;
 }
diff --git a/lparser.c b/lparser.c
index 5894d8ff..cc54de43 100644
--- a/lparser.c
+++ b/lparser.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.c,v 2.154 2016/06/22 15:48:25 roberto Exp roberto $
+** $Id: lparser.c,v 2.155.1.2 2017/04/29 18:11:40 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
@@ -1392,7 +1392,7 @@ static void test_then_block (LexState *ls, int *escapelist) {
     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 */
-    skipnoopstat(ls);  /* skip other no-op statements */
+    while (testnext(ls, ';')) {}  /* skip colons */
     if (block_follow(ls, 0)) {  /* 'goto' is the entire block? */
       leaveblock(fs);
       return;  /* and that is it */
diff --git a/lparser.h b/lparser.h
index 13e613ac..f45b23cb 100644
--- a/lparser.h
+++ b/lparser.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.h,v 1.75 2015/12/17 15:44:50 roberto Exp roberto $
+** $Id: lparser.h,v 1.76.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
diff --git a/lprefix.h b/lprefix.h
index 6b72f0eb..9a749a3f 100644
--- a/lprefix.h
+++ b/lprefix.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lprefix.h,v 1.1 2014/11/03 15:12:44 roberto Exp roberto $
+** $Id: lprefix.h,v 1.2.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Definitions for Lua code that must come before any other header file
 ** See Copyright Notice in lua.h
 */
diff --git a/lstate.c b/lstate.c
index 11299d37..c1a76643 100644
--- a/lstate.c
+++ b/lstate.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstate.c,v 2.132 2015/11/02 16:01:41 roberto Exp roberto $
+** $Id: lstate.c,v 2.133.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
diff --git a/lstate.h b/lstate.h
index 9985545e..56b37410 100644
--- a/lstate.h
+++ b/lstate.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lstate.h,v 2.132 2016/10/19 12:31:42 roberto Exp roberto $
+** $Id: lstate.h,v 2.133.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Global State
 ** See Copyright Notice in lua.h
 */
@@ -26,6 +26,24 @@
 ** 'tobefnz': all objects ready to be finalized;
 ** 'fixedgc': all objects that are not to be collected (currently
 ** only small strings, such as reserved words).
+**
+** Moreover, there is another set of lists that control gray objects.
+** These lists are linked by fields 'gclist'. (All objects that
+** can become gray have such a field. The field is not the same
+** in all objects, but it always has this name.)  Any gray object
+** must belong to one of these lists, and all objects in these lists
+** must be gray:
+**
+** 'gray': regular gray objects, still waiting to be visited.
+** 'grayagain': objects that must be revisited at the atomic phase.
+**   That includes
+**   - black objects got in a write barrier;
+**   - all kinds of weak tables during propagation phase;
+**   - all threads.
+** '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.
 
 */
 
diff --git a/lstring.c b/lstring.c
index fc9eb220..6257f211 100644
--- a/lstring.c
+++ b/lstring.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.c,v 2.55 2015/11/03 15:36:01 roberto Exp roberto $
+** $Id: lstring.c,v 2.56.1.1 2017/04/19 17:20:42 roberto Exp $
 ** String table (keeps all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
diff --git a/lstring.h b/lstring.h
index 6351003a..d612abd3 100644
--- a/lstring.h
+++ b/lstring.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lstring.h,v 1.60 2015/09/08 15:41:05 roberto Exp roberto $
+** $Id: lstring.h,v 1.61.1.1 2017/04/19 17:20:42 roberto Exp $
 ** String table (keep all strings handled by Lua)
 ** See Copyright Notice in lua.h
 */
diff --git a/lstrlib.c b/lstrlib.c
index 934b7db8..b4bed7e9 100644
--- a/lstrlib.c
+++ b/lstrlib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lstrlib.c,v 1.253 2016/12/20 18:37:00 roberto Exp roberto $
+** $Id: lstrlib.c,v 1.254.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Standard library for string operations and pattern-matching
 ** See Copyright Notice in lua.h
 */
@@ -879,7 +879,7 @@ static int lua_number2strx (lua_State *L, char *buff, int sz,
       buff[i] = toupper(uchar(buff[i]));
   }
   else if (fmt[SIZELENMOD] != 'a')
-    luaL_error(L, "modifiers for format '%%a'/'%%A' not implemented");
+    return luaL_error(L, "modifiers for format '%%a'/'%%A' not implemented");
   return n;
 }
 
@@ -1199,8 +1199,8 @@ static int getnum (const char **fmt, int df) {
 static int getnumlimit (Header *h, const char **fmt, int df) {
   int sz = getnum(fmt, df);
   if (sz > MAXINTSIZE || sz <= 0)
-    luaL_error(h->L, "integral size (%d) out of limits [1,%d]",
-                     sz, MAXINTSIZE);
+    return luaL_error(h->L, "integral size (%d) out of limits [1,%d]",
+                            sz, MAXINTSIZE);
   return sz;
 }
 
diff --git a/ltable.c b/ltable.c
index 92c165ad..ea4fe7fc 100644
--- a/ltable.c
+++ b/ltable.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.c,v 2.117 2015/11/19 19:16:22 roberto Exp roberto $
+** $Id: ltable.c,v 2.118.1.4 2018/06/08 16:22:51 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -223,7 +223,9 @@ static unsigned int computesizes (unsigned int nums[], unsigned int *pna) {
   unsigned int na = 0;  /* number of elements to go to array part */
   unsigned int optimal = 0;  /* optimal size for array part */
   /* loop while keys can fill more than half of total size */
-  for (i = 0, twotoi = 1; *pna > twotoi / 2; i++, twotoi *= 2) {
+  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? */
@@ -330,17 +332,34 @@ 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);
+}
+
+
 void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
                                           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 */
-  setnodevector(L, t, nhsize);
+  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 */
@@ -610,13 +629,13 @@ void luaH_setint (lua_State *L, Table *t, lua_Integer key, TValue *value) {
 }
 
 
-static int unbound_search (Table *t, unsigned int j) {
-  unsigned int i = j;  /* i is zero or a present index */
+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 > cast(unsigned int, MAX_INT)/2) {  /* overflow? */
+    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++;
@@ -626,7 +645,7 @@ static int unbound_search (Table *t, unsigned int j) {
   }
   /* now do a binary search between them */
   while (j - i > 1) {
-    unsigned int m = (i+j)/2;
+    lua_Unsigned m = (i+j)/2;
     if (ttisnil(luaH_getint(t, m))) j = m;
     else i = m;
   }
@@ -638,7 +657,7 @@ static int unbound_search (Table *t, unsigned int 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).
 */
-int luaH_getn (Table *t) {
+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 */
diff --git a/ltable.h b/ltable.h
index bd3543b5..92db0ac7 100644
--- a/ltable.h
+++ b/ltable.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ltable.h,v 2.22 2016/11/07 12:38:35 roberto Exp roberto $
+** $Id: ltable.h,v 2.23.1.2 2018/05/24 19:39:05 roberto Exp $
 ** Lua tables (hash)
 ** See Copyright Notice in lua.h
 */
@@ -54,7 +54,7 @@ LUAI_FUNC void luaH_resize (lua_State *L, Table *t, unsigned int nasize,
 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 int luaH_getn (Table *t);
+LUAI_FUNC lua_Unsigned luaH_getn (Table *t);
 
 
 #if defined(LUA_DEBUG)
diff --git a/ltablib.c b/ltablib.c
index 588bf40d..c5349578 100644
--- a/ltablib.c
+++ b/ltablib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltablib.c,v 1.92 2016/02/08 12:55:19 roberto Exp roberto $
+** $Id: ltablib.c,v 1.93.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Library for Table Manipulation
 ** See Copyright Notice in lua.h
 */
diff --git a/ltests.c b/ltests.c
index 6dba514a..bfc102ea 100644
--- a/ltests.c
+++ b/ltests.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltests.c,v 2.210 2016/11/07 12:38:35 roberto Exp roberto $
+** $Id: ltests.c,v 2.211.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Internal Module for Debugging of the Lua Implementation
 ** See Copyright Notice in lua.h
 */
diff --git a/ltests.h b/ltests.h
index 9d26fcb0..820bc82f 100644
--- a/ltests.h
+++ b/ltests.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ltests.h,v 2.49 2015/09/22 14:18:24 roberto Exp roberto $
+** $Id: ltests.h,v 2.50.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Internal Header for Debugging of the Lua Implementation
 ** See Copyright Notice in lua.h
 */
diff --git a/ltm.c b/ltm.c
index b664dbed..0e7c7132 100644
--- a/ltm.c
+++ b/ltm.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ltm.c,v 2.37 2016/02/26 19:20:15 roberto Exp roberto $
+** $Id: ltm.c,v 2.38.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
diff --git a/ltm.h b/ltm.h
index 70569f82..8170688d 100644
--- a/ltm.h
+++ b/ltm.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ltm.h,v 2.21 2014/10/25 11:50:46 roberto Exp roberto $
+** $Id: ltm.h,v 2.22.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Tag methods
 ** See Copyright Notice in lua.h
 */
diff --git a/lua.c b/lua.c
index 62de0f58..ca5b2985 100644
--- a/lua.c
+++ b/lua.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lua.c,v 1.229 2016/12/22 13:08:50 roberto Exp roberto $
+** $Id: lua.c,v 1.230.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Lua stand-alone interpreter
 ** See Copyright Notice in lua.h
 */
@@ -138,7 +138,7 @@ static void print_usage (const char *badoption) {
   "Available options are:\n"
   "  -e stat  execute string 'stat'\n"
   "  -i       enter interactive mode after executing 'script'\n"
-  "  -l name  require library 'name'\n"
+  "  -l name  require library 'name' into global 'name'\n"
   "  -v       show version information\n"
   "  -E       ignore environment variables\n"
   "  --       stop handling options\n"
diff --git a/lua.h b/lua.h
index fc4e2388..c236e360 100644
--- a/lua.h
+++ b/lua.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lua.h,v 1.331 2016/05/30 15:53:28 roberto Exp roberto $
+** $Id: lua.h,v 1.332.1.2 2018/06/13 16:58:17 roberto Exp $
 ** Lua - A Scripting Language
 ** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
 ** See Copyright Notice at the end of this file
@@ -19,11 +19,11 @@
 #define LUA_VERSION_MAJOR       "5"
 #define LUA_VERSION_MINOR       "3"
 #define LUA_VERSION_NUM         503
-#define LUA_VERSION_RELEASE     "4"
+#define LUA_VERSION_RELEASE     "5"
 
 #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-2017 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"
 
 
@@ -460,7 +460,7 @@ struct lua_Debug {
 
 
 /******************************************************************************
-* Copyright (C) 1994-2017 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
diff --git a/luaconf.h b/luaconf.h
index 118f997a..9eeeea69 100644
--- a/luaconf.h
+++ b/luaconf.h
@@ -1,5 +1,5 @@
 /*
-** $Id: luaconf.h,v 1.258 2016/12/20 18:37:00 roberto Exp roberto $
+** $Id: luaconf.h,v 1.259.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Configuration file for Lua
 ** See Copyright Notice in lua.h
 */
@@ -621,6 +621,13 @@
 
 
 /*
+@@ lua_pointer2str converts a pointer to a readable string in a
+** non-specified way.
+*/
+#define lua_pointer2str(buff,sz,p)      l_sprintf(buff,sz,"%p",p)
+
+
+/*
 @@ lua_number2strx converts a float to an hexadecimal numeric string.
 ** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that.
 ** Otherwise, you can leave 'lua_number2strx' undefined and Lua will
diff --git a/lualib.h b/lualib.h
index c01eb9c8..f5304aa0 100644
--- a/lualib.h
+++ b/lualib.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lualib.h,v 1.44 2014/02/06 17:32:33 roberto Exp roberto $
+** $Id: lualib.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Lua standard libraries
 ** See Copyright Notice in lua.h
 */
diff --git a/lundump.c b/lundump.c
index 13916bc1..7a67d75a 100644
--- a/lundump.c
+++ b/lundump.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lundump.c,v 2.43 2015/09/17 15:51:05 roberto Exp roberto $
+** $Id: lundump.c,v 2.44.1.1 2017/04/19 17:20:42 roberto Exp $
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
diff --git a/lundump.h b/lundump.h
index bc9f99a2..ce492d68 100644
--- a/lundump.h
+++ b/lundump.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lundump.h,v 1.44 2014/06/19 18:27:20 roberto Exp roberto $
+** $Id: lundump.h,v 1.45.1.1 2017/04/19 17:20:42 roberto Exp $
 ** load precompiled Lua chunks
 ** See Copyright Notice in lua.h
 */
diff --git a/lutf8lib.c b/lutf8lib.c
index 6db6fd37..10bd238a 100644
--- a/lutf8lib.c
+++ b/lutf8lib.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lutf8lib.c,v 1.15 2015/03/28 19:16:55 roberto Exp roberto $
+** $Id: lutf8lib.c,v 1.16.1.1 2017/04/19 17:29:57 roberto Exp $
 ** Standard library for UTF-8 manipulation
 ** See Copyright Notice in lua.h
 */
@@ -171,7 +171,7 @@ static int byteoffset (lua_State *L) {
   }
   else {
     if (iscont(s + posi))
-      luaL_error(L, "initial position is a continuation byte");
+      return luaL_error(L, "initial position is a continuation byte");
     if (n < 0) {
        while (n < 0 && posi > 0) {  /* move back */
          do {  /* find beginning of previous character */
diff --git a/lvm.c b/lvm.c
index 3709d77a..cc43d871 100644
--- a/lvm.c
+++ b/lvm.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.c,v 2.267 2016/01/05 16:07:21 roberto Exp roberto $
+** $Id: lvm.c,v 2.268.1.1 2017/04/19 17:39:34 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
diff --git a/lvm.h b/lvm.h
index ca75a338..a8f954f0 100644
--- a/lvm.h
+++ b/lvm.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.h,v 2.40 2016/01/05 16:07:21 roberto Exp roberto $
+** $Id: lvm.h,v 2.41.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
diff --git a/lzio.c b/lzio.c
index eb6151a0..6f790944 100644
--- a/lzio.c
+++ b/lzio.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lzio.c,v 1.36 2014/11/02 19:19:04 roberto Exp roberto $
+** $Id: lzio.c,v 1.37.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Buffered streams
 ** See Copyright Notice in lua.h
 */
diff --git a/lzio.h b/lzio.h
index fb310b99..d8978708 100644
--- a/lzio.h
+++ b/lzio.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lzio.h,v 1.30 2014/12/19 17:26:14 roberto Exp roberto $
+** $Id: lzio.h,v 1.31.1.1 2017/04/19 17:20:42 roberto Exp $
 ** Buffered streams
 ** See Copyright Notice in lua.h
 */
diff --git a/manual/2html b/manual/2html
new file mode 100755
index 00000000..6a6740fb
--- /dev/null
+++ b/manual/2html
@@ -0,0 +1,518 @@
+#!/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)
+
diff --git a/manual/manual.of b/manual/manual.of
new file mode 100644
index 00000000..5b2abbe7
--- /dev/null
+++ b/manual/manual.of
@@ -0,0 +1,8630 @@
+@Ci{$Id: manual.of,v 1.167.1.2 2018/06/26 15:49:07 roberto Exp $}
+@C{[(-------------------------------------------------------------------------}
+@manual{
+
+@sect1{@title{Introduction}
+
+Lua is a powerful, efficient, lightweight, embeddable scripting language.
+It supports procedural programming,
+object-oriented programming, functional programming,
+data-driven programming, and data description.
+
+Lua combines simple procedural syntax with powerful data description
+constructs based on associative arrays and extensible semantics.
+Lua is dynamically typed,
+runs by interpreting bytecode with a register-based
+virtual machine,
+and has automatic memory management with
+incremental garbage collection,
+making it ideal for configuration, scripting,
+and rapid prototyping.
+
+Lua is implemented as a library, written in @emphx{clean C},
+the common subset of @N{Standard C} and C++.
+The Lua distribution includes a host program called @id{lua},
+which uses the Lua library to offer a complete,
+standalone Lua interpreter,
+for interactive or batch use.
+Lua is intended to be used both as a powerful, lightweight,
+embeddable scripting language for any program that needs one,
+and as a powerful but lightweight and efficient stand-alone language.
+
+As an extension language, Lua has no notion of a @Q{main} program:
+it works @emph{embedded} in a host client,
+called the @emph{embedding program} or simply the @emphx{host}.
+(Frequently, this host is the stand-alone @id{lua} program.)
+The host program can invoke functions to execute a piece of Lua code,
+can write and read Lua variables,
+and can register @N{C functions} to be called by Lua code.
+Through the use of @N{C functions}, Lua can be augmented to cope with
+a wide range of different domains,
+thus creating customized programming languages sharing a syntactical framework.
+
+Lua is free software,
+and is provided as usual with no guarantees,
+as stated in its license.
+The implementation described in this manual is available
+at Lua's official web site, @id{www.lua.org}.
+
+Like any other reference manual,
+this document is dry in places.
+For a discussion of the decisions behind the design of Lua,
+see the technical papers available at Lua's web site.
+For a detailed introduction to programming in Lua,
+see Roberto's book, @emphx{Programming in Lua}.
+
+}
+
+
+@C{-------------------------------------------------------------------------}
+@sect1{basic| @title{Basic Concepts}
+
+This section describes the basic concepts of the language.
+
+@sect2{TypesSec| @title{Values and Types}
+
+Lua is a @emph{dynamically typed language}.
+This means that
+variables do not have types; only values do.
+There are no type definitions in the language.
+All values carry their own type.
+
+All values in Lua are @emph{first-class values}.
+This means that all values can be stored in variables,
+passed as arguments to other functions, and returned as results.
+
+There are eight @x{basic types} in Lua:
+@def{nil}, @def{boolean}, @def{number},
+@def{string}, @def{function}, @def{userdata},
+@def{thread}, and @def{table}.
+The type @emph{nil} has one single value, @nil,
+whose main property is to be different from any other value;
+it usually represents the absence of a useful value.
+The type @emph{boolean} has two values, @false and @true.
+Both @nil and @false make a condition false;
+any other value makes it true.
+The type @emph{number} represents both
+integer numbers and real (floating-point) numbers.
+The type @emph{string} represents immutable sequences of bytes.
+@index{eight-bit clean}
+Lua is 8-bit clean:
+strings can contain any 8-bit value,
+including @x{embedded zeros} (@Char{\0}).
+Lua is also encoding-agnostic;
+it makes no assumptions about the contents of a string.
+
+The type @emph{number} uses two internal representations,
+or two @x{subtypes},
+one called @def{integer} and the other called @def{float}.
+Lua has explicit rules about when each representation is used,
+but it also converts between them automatically as needed @see{coercion}.
+Therefore,
+the programmer may choose to mostly ignore the difference
+between integers and floats
+or to assume complete control over the representation of each number.
+Standard Lua uses 64-bit integers and double-precision (64-bit) floats,
+but you can also compile Lua so that it
+uses 32-bit integers and/or single-precision (32-bit) floats.
+The option with 32 bits for both integers and floats
+is particularly attractive
+for small machines and embedded systems.
+(See macro @id{LUA_32BITS} in file @id{luaconf.h}.)
+
+Lua can call (and manipulate) functions written in Lua and
+functions written in C @see{functioncall}.
+Both are represented by the type @emph{function}.
+
+The type @emph{userdata} is provided to allow arbitrary @N{C data} to
+be stored in Lua variables.
+A userdata value represents a block of raw memory.
+There are two kinds of userdata:
+@emphx{full userdata},
+which is an object with a block of memory managed by Lua,
+and @emphx{light userdata},
+which is simply a @N{C pointer} value.
+Userdata has no predefined operations in Lua,
+except assignment and identity test.
+By using @emph{metatables},
+the programmer can define operations for full userdata values
+@see{metatable}.
+Userdata values cannot be created or modified in Lua,
+only through the @N{C API}.
+This guarantees the integrity of data owned by the host program.
+
+The type @def{thread} represents independent threads of execution
+and it is used to implement coroutines @see{coroutine}.
+Lua threads are not related to operating-system threads.
+Lua supports coroutines on all systems,
+even those that do not support threads natively.
+
+The type @emph{table} implements @x{associative arrays},
+that is, @x{arrays} that can have as indices not only numbers,
+but any Lua value except @nil and @x{NaN}.
+(@emphx{Not a Number} is a special value used to represent
+undefined or unrepresentable numerical results, such as @T{0/0}.)
+Tables can be @emph{heterogeneous};
+that is, they can contain values of all types (except @nil).
+Any key with value @nil is not considered part of the table.
+Conversely, any key that is not part of a table has
+an associated value @nil.
+
+Tables are the sole data-structuring mechanism in Lua;
+they can be used to represent ordinary arrays, lists,
+symbol tables, sets, records, graphs, trees, etc.
+To represent @x{records}, Lua uses the field name as an index.
+The language supports this representation by
+providing @id{a.name} as syntactic sugar for @T{a["name"]}.
+There are several convenient ways to create tables in Lua
+@see{tableconstructor}.
+
+Like indices,
+the values of table fields can be of any type.
+In particular,
+because functions are first-class values,
+table fields can contain functions.
+Thus tables can also carry @emph{methods} @see{func-def}.
+
+The indexing of tables follows
+the definition of raw equality in the language.
+The expressions @T{a[i]} and @T{a[j]}
+denote the same table element
+if and only if @id{i} and @id{j} are raw equal
+(that is, equal without metamethods).
+In particular, floats with integral values
+are equal to their respective integers
+(e.g., @T{1.0 == 1}).
+To avoid ambiguities,
+any float with integral value used as a key
+is converted to its respective integer.
+For instance, if you write @T{a[2.0] = true},
+the actual key inserted into the table will be the
+integer @T{2}.
+(On the other hand,
+2 and @St{2} are different Lua values and therefore
+denote different table entries.)
+
+
+Tables, functions, threads, and (full) userdata values are @emph{objects}:
+variables do not actually @emph{contain} these values,
+only @emph{references} to them.
+Assignment, parameter passing, and function returns
+always manipulate references to such values;
+these operations do not imply any kind of copy.
+
+The library function @Lid{type} returns a string describing the type
+of a given value @see{predefined}.
+
+}
+
+@sect2{globalenv| @title{Environments and the Global Environment}
+
+As will be discussed in @refsec{variables} and @refsec{assignment},
+any reference to a free name
+(that is, a name not bound to any declaration) @id{var}
+is syntactically translated to @T{_ENV.var}.
+Moreover, every chunk is compiled in the scope of
+an external local variable named @id{_ENV} @see{chunks},
+so @id{_ENV} itself is never a free name in a chunk.
+
+Despite the existence of this external @id{_ENV} variable and
+the translation of free names,
+@id{_ENV} is a completely regular name.
+In particular,
+you can define new variables and parameters with that name.
+Each reference to a free name uses the @id{_ENV} that is
+visible at that point in the program,
+following the usual visibility rules of Lua @see{visibility}.
+
+Any table used as the value of @id{_ENV} is called an @def{environment}.
+
+Lua keeps a distinguished environment called the @def{global environment}.
+This value is kept at a special index in the C registry @see{registry}.
+In Lua, the global variable @Lid{_G} is initialized with this same value.
+(@Lid{_G} is never used internally.)
+
+When Lua loads a chunk,
+the default value for its @id{_ENV} upvalue
+is the global environment @seeF{load}.
+Therefore, by default,
+free names in Lua code refer to entries in the global environment
+(and, therefore, they are also called @def{global variables}).
+Moreover, all standard libraries are loaded in the global environment
+and some functions there operate on that environment.
+You can use @Lid{load} (or @Lid{loadfile})
+to load a chunk with a different environment.
+(In C, you have to load the chunk and then change the value
+of its first upvalue.)
+
+}
+
+@sect2{error| @title{Error Handling}
+
+Because Lua is an embedded extension language,
+all Lua actions start from @N{C code} in the host program
+calling a function from the Lua library.
+(When you use Lua standalone,
+the @id{lua} application is the host program.)
+Whenever an error occurs during
+the compilation or execution of a Lua chunk,
+control returns to the host,
+which can take appropriate measures
+(such as printing an error message).
+
+Lua code can explicitly generate an error by calling the
+@Lid{error} function.
+If you need to catch errors in Lua,
+you can use @Lid{pcall} or @Lid{xpcall}
+to call a given function in @emphx{protected mode}.
+
+Whenever there is an error,
+an @def{error object} (also called an @def{error message})
+is propagated with information about the error.
+Lua itself only generates errors whose error object is a string,
+but programs may generate errors with
+any value as the error object.
+It is up to the Lua program or its host to handle such error objects.
+
+
+When you use @Lid{xpcall} or @Lid{lua_pcall},
+you may give a @def{message handler}
+to be called in case of errors.
+This function is called with the original error object
+and returns a new error object.
+It is called before the error unwinds the stack,
+so that it can gather more information about the error,
+for instance by inspecting the stack and creating a stack traceback.
+This message handler is still protected by the protected call;
+so, an error inside the message handler
+will call the message handler again.
+If this loop goes on for too long,
+Lua breaks it and returns an appropriate message.
+(The message handler is called only for regular runtime errors.
+It is not called for memory-allocation errors
+nor for errors while running finalizers.)
+
+}
+
+@sect2{metatable| @title{Metatables and Metamethods}
+
+Every value in Lua can have a @emph{metatable}.
+This @def{metatable} is an ordinary Lua table
+that defines the behavior of the original value
+under certain special operations.
+You can change several aspects of the behavior
+of operations over a value by setting specific fields in its metatable.
+For instance, when a non-numeric value is the operand of an addition,
+Lua checks for a function in the field @St{__add} of the value's metatable.
+If it finds one,
+Lua calls this function to perform the addition.
+
+The key for each event in a metatable is a string
+with the event name prefixed by two underscores;
+the corresponding values are called @def{metamethods}.
+In the previous example, the key is @St{__add}
+and the metamethod is the function that performs the addition.
+Unless stated otherwise,
+metamethods should be function values.
+
+You can query the metatable of any value
+using the @Lid{getmetatable} function.
+Lua queries metamethods in metatables using a raw access @seeF{rawget}.
+So, to retrieve the metamethod for event @id{ev} in object @id{o},
+Lua does the equivalent to the following code:
+@verbatim{
+rawget(getmetatable(@rep{o}) or {}, "__@rep{ev}")
+}
+
+You can replace the metatable of tables
+using the @Lid{setmetatable} function.
+You cannot change the metatable of other types from Lua code
+(except by using the @link{debuglib|debug library});
+you should use the @N{C API} for that.
+
+Tables and full userdata have individual metatables
+(although multiple tables and userdata can share their metatables).
+Values of all other types share one single metatable per type;
+that is, there is one single metatable for all numbers,
+one for all strings, etc.
+By default, a value has no metatable,
+but the string library sets a metatable for the string type @see{strlib}.
+
+A metatable controls how an object behaves in
+arithmetic operations, bitwise operations,
+order comparisons, concatenation, length operation, calls, and indexing.
+A metatable also can define a function to be called
+when a userdata or a table is @link{GC|garbage collected}.
+
+For the unary operators (negation, length, and bitwise NOT),
+the metamethod is computed and called with a dummy second operand,
+equal to the first one.
+This extra operand is only to simplify Lua's internals
+(by making these operators behave like a binary operation)
+and may be removed in future versions.
+(For most uses this extra operand is irrelevant.)
+
+A detailed list of events controlled by metatables is given next.
+Each operation is identified by its corresponding key.
+
+@description{
+
+@item{@idx{__add}|
+the addition (@T{+}) operation.
+If any operand for an addition is not a number
+(nor a string coercible to a number),
+Lua will try to call a metamethod.
+First, Lua will check the first operand (even if it is valid).
+If that operand does not define a metamethod for @idx{__add},
+then Lua will check the second operand.
+If Lua can find a metamethod,
+it calls the metamethod with the two operands as arguments,
+and the result of the call
+(adjusted to one value)
+is the result of the operation.
+Otherwise,
+it raises an error.
+}
+
+@item{@idx{__sub}|
+the subtraction (@T{-}) operation.
+Behavior similar to the addition operation.
+}
+
+@item{@idx{__mul}|
+the multiplication (@T{*}) operation.
+Behavior similar to the addition operation.
+}
+
+@item{@idx{__div}|
+the division (@T{/}) operation.
+Behavior similar to the addition operation.
+}
+
+@item{@idx{__mod}|
+the modulo (@T{%}) operation.
+Behavior similar to the addition operation.
+}
+
+@item{@idx{__pow}|
+the exponentiation (@T{^}) operation.
+Behavior similar to the addition operation.
+}
+
+@item{@idx{__unm}|
+the negation (unary @T{-}) operation.
+Behavior similar to the addition operation.
+}
+
+@item{@idx{__idiv}|
+the floor division (@T{//}) operation.
+Behavior similar to the addition operation.
+}
+
+@item{@idx{__band}|
+the bitwise AND (@T{&}) operation.
+Behavior similar to the addition operation,
+except that Lua will try a metamethod
+if any operand is neither an integer
+nor a value coercible to an integer @see{coercion}.
+}
+
+@item{@idx{__bor}|
+the bitwise OR (@T{|}) operation.
+Behavior similar to the bitwise AND operation.
+}
+
+@item{@idx{__bxor}|
+the bitwise exclusive OR (binary @T{~}) operation.
+Behavior similar to the bitwise AND operation.
+}
+
+@item{@idx{__bnot}|
+the bitwise NOT (unary @T{~}) operation.
+Behavior similar to the bitwise AND operation.
+}
+
+@item{@idx{__shl}|
+the bitwise left shift (@T{<<}) operation.
+Behavior similar to the bitwise AND operation.
+}
+
+@item{@idx{__shr}|
+the bitwise right shift (@T{>>}) operation.
+Behavior similar to the bitwise AND operation.
+}
+
+@item{@idx{__concat}|
+the concatenation (@T{..}) operation.
+Behavior similar to the addition operation,
+except that Lua will try a metamethod
+if any operand is neither a string nor a number
+(which is always coercible to a string).
+}
+
+@item{@idx{__len}|
+the length (@T{#}) operation.
+If the object is not a string,
+Lua will try its metamethod.
+If there is a metamethod,
+Lua calls it with the object as argument,
+and the result of the call
+(always adjusted to one value)
+is the result of the operation.
+If there is no metamethod but the object is a table,
+then Lua uses the table length operation @see{len-op}.
+Otherwise, Lua raises an error.
+}
+
+@item{@idx{__eq}|
+the equal (@T{==}) operation.
+Behavior similar to the addition operation,
+except that Lua will try a metamethod only when the values
+being compared are either both tables or both full userdata
+and they are not primitively equal.
+The result of the call is always converted to a boolean.
+}
+
+@item{@idx{__lt}|
+the less than (@T{<}) operation.
+Behavior similar to the addition operation,
+except that Lua will try a metamethod only when the values
+being compared are neither both numbers nor both strings.
+The result of the call is always converted to a boolean.
+}
+
+@item{@idx{__le}|
+the less equal (@T{<=}) operation.
+Unlike other operations,
+the less-equal operation can use two different events.
+First, Lua looks for the @idx{__le} metamethod in both operands,
+like in the less than operation.
+If it cannot find such a metamethod,
+then it will try the @idx{__lt} metamethod,
+assuming that @T{a <= b} is equivalent to @T{not (b < a)}.
+As with the other comparison operators,
+the result is always a boolean.
+(This use of the @idx{__lt} event can be removed in future versions;
+it is also slower than a real @idx{__le} metamethod.)
+}
+
+@item{@idx{__index}|
+The indexing access operation @T{table[key]}.
+This event happens when @id{table} is not a table or
+when @id{key} is not present in @id{table}.
+The metamethod is looked up in @id{table}.
+
+Despite the name,
+the metamethod for this event can be either a function or a table.
+If it is a function,
+it is called with @id{table} and @id{key} as arguments,
+and the result of the call
+(adjusted to one value)
+is the result of the operation.
+If it is a table,
+the final result is the result of indexing this table with @id{key}.
+(This indexing is regular, not raw,
+and therefore can trigger another metamethod.)
+}
+
+@item{@idx{__newindex}|
+The indexing assignment @T{table[key] = value}.
+Like the index event,
+this event happens when @id{table} is not a table or
+when @id{key} is not present in @id{table}.
+The metamethod is looked up in @id{table}.
+
+Like with indexing,
+the metamethod for this event can be either a function or a table.
+If it is a function,
+it is called with @id{table}, @id{key}, and @id{value} as arguments.
+If it is a table,
+Lua does an indexing assignment to this table with the same key and value.
+(This assignment is regular, not raw,
+and therefore can trigger another metamethod.)
+
+Whenever there is a @idx{__newindex} metamethod,
+Lua does not perform the primitive assignment.
+(If necessary,
+the metamethod itself can call @Lid{rawset}
+to do the assignment.)
+}
+
+@item{@idx{__call}|
+The call operation @T{func(args)}.
+This event happens when Lua tries to call a non-function value
+(that is, @id{func} is not a function).
+The metamethod is looked up in @id{func}.
+If present,
+the metamethod is called with @id{func} as its first argument,
+followed by the arguments of the original call (@id{args}).
+All results of the call
+are the result of the operation.
+(This is the only metamethod that allows multiple results.)
+}
+
+}
+
+It is a good practice to add all needed metamethods to a table
+before setting it as a metatable of some object.
+In particular, the @idx{__gc} metamethod works only when this order
+is followed @see{finalizers}.
+
+Because metatables are regular tables,
+they can contain arbitrary fields,
+not only the event names defined above.
+Some functions in the standard library
+(e.g., @Lid{tostring})
+use other fields in metatables for their own purposes.
+
+}
+
+@sect2{GC| @title{Garbage Collection}
+
+Lua performs automatic memory management.
+This means that
+you do not have to worry about allocating memory for new objects
+or freeing it when the objects are no longer needed.
+Lua manages memory automatically by running
+a @def{garbage collector} to collect all @emph{dead objects}
+(that is, objects that are no longer accessible from Lua).
+All memory used by Lua is subject to automatic management:
+strings, tables, userdata, functions, threads, internal structures, etc.
+
+Lua implements an incremental mark-and-sweep collector.
+It uses two numbers to control its garbage-collection cycles:
+the @def{garbage-collector pause} and
+the @def{garbage-collector step multiplier}.
+Both use percentage points as units
+(e.g., a value of 100 means an internal value of 1).
+
+The garbage-collector pause
+controls how long the collector waits before starting a new cycle.
+Larger values make the collector less aggressive.
+Values smaller than 100 mean the collector will not wait to
+start a new cycle.
+A value of 200 means that the collector waits for the total memory in use
+to double before starting a new cycle.
+
+The garbage-collector step multiplier
+controls the relative speed of the collector relative to
+memory allocation.
+Larger values make the collector more aggressive but also increase
+the size of each incremental step.
+You should not use values smaller than 100,
+because they make the collector too slow and
+can result in the collector never finishing a cycle.
+The default is 200,
+which means that the collector runs at @Q{twice}
+the speed of memory allocation.
+
+If you set the step multiplier to a very large number
+(larger than 10% of the maximum number of
+bytes that the program may use),
+the collector behaves like a stop-the-world collector.
+If you then set the pause to 200,
+the collector behaves as in old Lua versions,
+doing a complete collection every time Lua doubles its
+memory usage.
+
+You can change these numbers by calling @Lid{lua_gc} in C
+or @Lid{collectgarbage} in Lua.
+You can also use these functions to control
+the collector directly (e.g., stop and restart it).
+
+
+@sect3{finalizers| @title{Garbage-Collection Metamethods}
+
+You can set garbage-collector metamethods for tables
+and, using the @N{C API},
+for full userdata @see{metatable}.
+These metamethods are also called @def{finalizers}.
+Finalizers allow you to coordinate Lua's garbage collection
+with external resource management
+(such as closing files, network or database connections,
+or freeing your own memory).
+
+For an object (table or userdata) to be finalized when collected,
+you must @emph{mark} it for finalization.
+@index{mark (for finalization)}
+You mark an object for finalization when you set its metatable
+and the metatable has a field indexed by the string @St{__gc}.
+Note that if you set a metatable without a @idx{__gc} field
+and later create that field in the metatable,
+the object will not be marked for finalization.
+
+When a marked object becomes garbage,
+it is not collected immediately by the garbage collector.
+Instead, Lua puts it in a list.
+After the collection,
+Lua goes through that list.
+For each object in the list,
+it checks the object's @idx{__gc} metamethod:
+If it is a function,
+Lua calls it with the object as its single argument;
+if the metamethod is not a function,
+Lua simply ignores it.
+
+At the end of each garbage-collection cycle,
+the finalizers for objects are called in
+the reverse order that the objects were marked for finalization,
+among those collected in that cycle;
+that is, the first finalizer to be called is the one associated
+with the object marked last in the program.
+The execution of each finalizer may occur at any point during
+the execution of the regular code.
+
+Because the object being collected must still be used by the finalizer,
+that object (and other objects accessible only through it)
+must be @emph{resurrected} by Lua.@index{resurrection}
+Usually, this resurrection is transient,
+and the object memory is freed in the next garbage-collection cycle.
+However, if the finalizer stores the object in some global place
+(e.g., a global variable),
+then the resurrection is permanent.
+Moreover, if the finalizer marks a finalizing object for finalization again,
+its finalizer will be called again in the next cycle where the
+object is unreachable.
+In any case,
+the object memory is freed only in a GC cycle where
+the object is unreachable and not marked for finalization.
+
+When you close a state @seeF{lua_close},
+Lua calls the finalizers of all objects marked for finalization,
+following the reverse order that they were marked.
+If any finalizer marks objects for collection during that phase,
+these marks have no effect.
+
+}
+
+@sect3{weak-table| @title{Weak Tables}
+
+A @def{weak table} is a table whose elements are
+@def{weak references}.
+A weak reference is ignored by the garbage collector.
+In other words,
+if the only references to an object are weak references,
+then the garbage collector will collect that object.
+
+A weak table can have weak keys, weak values, or both.
+A table with weak values allows the collection of its values,
+but prevents the collection of its keys.
+A table with both weak keys and weak values allows the collection of
+both keys and values.
+In any case, if either the key or the value is collected,
+the whole pair is removed from the table.
+The weakness of a table is controlled by the
+@idx{__mode} field of its metatable.
+If the @idx{__mode} field is a string containing the @N{character @Char{k}},
+the keys in the table are weak.
+If @idx{__mode} contains @Char{v},
+the values in the table are weak.
+
+A table with weak keys and strong values
+is also called an @def{ephemeron table}.
+In an ephemeron table,
+a value is considered reachable only if its key is reachable.
+In particular,
+if the only reference to a key comes through its value,
+the pair is removed.
+
+Any change in the weakness of a table may take effect only
+at the next collect cycle.
+In particular, if you change the weakness to a stronger mode,
+Lua may still collect some items from that table
+before the change takes effect.
+
+Only objects that have an explicit construction
+are removed from weak tables.
+Values, such as numbers and @x{light @N{C functions}},
+are not subject to garbage collection,
+and therefore are not removed from weak tables
+(unless their associated values are collected).
+Although strings are subject to garbage collection,
+they do not have an explicit construction,
+and therefore are not removed from weak tables.
+
+Resurrected objects
+(that is, objects being finalized
+and objects accessible only through objects being finalized)
+have a special behavior in weak tables.
+They are removed from weak values before running their finalizers,
+but are removed from weak keys only in the next collection
+after running their finalizers, when such objects are actually freed.
+This behavior allows the finalizer to access properties
+associated with the object through weak tables.
+
+If a weak table is among the resurrected objects in a collection cycle,
+it may not be properly cleared until the next cycle.
+
+}
+
+}
+
+@sect2{coroutine| @title{Coroutines}
+
+Lua supports coroutines,
+also called @emphx{collaborative multithreading}.
+A coroutine in Lua represents an independent thread of execution.
+Unlike threads in multithread systems, however,
+a coroutine only suspends its execution by explicitly calling
+a yield function.
+
+You create a coroutine by calling @Lid{coroutine.create}.
+Its sole argument is a function
+that is the main function of the coroutine.
+The @id{create} function only creates a new coroutine and
+returns a handle to it (an object of type @emph{thread});
+it does not start the coroutine.
+
+You execute a coroutine by calling @Lid{coroutine.resume}.
+When you first call @Lid{coroutine.resume},
+passing as its first argument
+a thread returned by @Lid{coroutine.create},
+the coroutine starts its execution by
+calling its main function.
+Extra arguments passed to @Lid{coroutine.resume} are passed
+as arguments to that function.
+After the coroutine starts running,
+it runs until it terminates or @emph{yields}.
+
+A coroutine can terminate its execution in two ways:
+normally, when its main function returns
+(explicitly or implicitly, after the last instruction);
+and abnormally, if there is an unprotected error.
+In case of normal termination,
+@Lid{coroutine.resume} returns @true,
+plus any values returned by the coroutine main function.
+In case of errors, @Lid{coroutine.resume} returns @false
+plus an error object.
+
+A coroutine yields by calling @Lid{coroutine.yield}.
+When a coroutine yields,
+the corresponding @Lid{coroutine.resume} returns immediately,
+even if the yield happens inside nested function calls
+(that is, not in the main function,
+but in a function directly or indirectly called by the main function).
+In the case of a yield, @Lid{coroutine.resume} also returns @true,
+plus any values passed to @Lid{coroutine.yield}.
+The next time you resume the same coroutine,
+it continues its execution from the point where it yielded,
+with the call to @Lid{coroutine.yield} returning any extra
+arguments passed to @Lid{coroutine.resume}.
+
+Like @Lid{coroutine.create},
+the @Lid{coroutine.wrap} function also creates a coroutine,
+but instead of returning the coroutine itself,
+it returns a function that, when called, resumes the coroutine.
+Any arguments passed to this function
+go as extra arguments to @Lid{coroutine.resume}.
+@Lid{coroutine.wrap} returns all the values returned by @Lid{coroutine.resume},
+except the first one (the boolean error code).
+Unlike @Lid{coroutine.resume},
+@Lid{coroutine.wrap} does not catch errors;
+any error is propagated to the caller.
+
+As an example of how coroutines work,
+consider the following code:
+@verbatim{
+function foo (a)
+  print("foo", a)
+  return coroutine.yield(2*a)
+end
+
+co = coroutine.create(function (a,b)
+      print("co-body", a, b)
+      local r = foo(a+1)
+      print("co-body", r)
+      local r, s = coroutine.yield(a+b, a-b)
+      print("co-body", r, s)
+      return b, "end"
+end)
+
+print("main", coroutine.resume(co, 1, 10))
+print("main", coroutine.resume(co, "r"))
+print("main", coroutine.resume(co, "x", "y"))
+print("main", coroutine.resume(co, "x", "y"))
+}
+When you run it, it produces the following output:
+@verbatim{
+co-body 1       10
+foo     2
+main    true    4
+co-body r
+main    true    11      -9
+co-body x       y
+main    true    10      end
+main    false   cannot resume dead coroutine
+}
+
+You can also create and manipulate coroutines through the C API:
+see functions @Lid{lua_newthread}, @Lid{lua_resume},
+and @Lid{lua_yield}.
+
+}
+
+}
+
+
+@C{-------------------------------------------------------------------------}
+@sect1{language| @title{The Language}
+
+This section describes the lexis, the syntax, and the semantics of Lua.
+In other words,
+this section describes
+which tokens are valid,
+how they can be combined,
+and what their combinations mean.
+
+Language constructs will be explained using the usual extended BNF notation,
+in which
+@N{@bnfrep{@rep{a}} means 0} or more @rep{a}'s, and
+@N{@bnfopt{@rep{a}} means} an optional @rep{a}.
+Non-terminals are shown like @bnfNter{non-terminal},
+keywords are shown like @rw{kword},
+and other terminal symbols are shown like @bnfter{=}.
+The complete syntax of Lua can be found in @refsec{BNF}
+at the end of this manual.
+
+@sect2{lexical| @title{Lexical Conventions}
+
+Lua is a @x{free-form} language.
+It ignores spaces (including new lines) and comments
+between lexical elements (@x{tokens}),
+except as delimiters between @x{names} and @x{keywords}.
+
+@def{Names}
+(also called @def{identifiers})
+in Lua can be any string of letters,
+digits, and underscores,
+not beginning with a digit and
+not being a reserved word.
+Identifiers are used to name variables, table fields, and labels.
+
+The following @def{keywords} are reserved
+and cannot be used as names:
+@index{reserved words}
+@verbatim{
+and       break     do        else      elseif    end
+false     for       function  goto      if        in
+local     nil       not       or        repeat    return
+then      true      until     while
+}
+
+Lua is a case-sensitive language:
+@id{and} is a reserved word, but @id{And} and @id{AND}
+are two different, valid names.
+As a convention,
+programs should avoid creating
+names that start with an underscore followed by
+one or more uppercase letters (such as @Lid{_VERSION}).
+
+The following strings denote other @x{tokens}:
+@verbatim{
++     -     *     /     %     ^     #
+&     ~     |     <<    >>    //
+==    ~=    <=    >=    <     >     =
+(     )     {     }     [     ]     ::
+;     :     ,     .     ..    ...
+}
+
+A @def{short literal string}
+can be delimited by matching single or double quotes,
+and can contain the following C-like escape sequences:
+@Char{\a} (bell),
+@Char{\b} (backspace),
+@Char{\f} (form feed),
+@Char{\n} (newline),
+@Char{\r} (carriage return),
+@Char{\t} (horizontal tab),
+@Char{\v} (vertical tab),
+@Char{\\} (backslash),
+@Char{\"} (quotation mark [double quote]),
+and @Char{\'} (apostrophe [single quote]).
+A backslash followed by a line break
+results in a newline in the string.
+The escape sequence @Char{\z} skips the following span
+of white-space characters,
+including line breaks;
+it is particularly useful to break and indent a long literal string
+into multiple lines without adding the newlines and spaces
+into the string contents.
+A short literal string cannot contain unescaped line breaks
+nor escapes not forming a valid escape sequence.
+
+We can specify any byte in a short literal string by its numeric value
+(including @x{embedded zeros}).
+This can be done
+with the escape sequence @T{\x@rep{XX}},
+where @rep{XX} is a sequence of exactly two hexadecimal digits,
+or with the escape sequence @T{\@rep{ddd}},
+where @rep{ddd} is a sequence of up to three decimal digits.
+(Note that if a decimal escape sequence is to be followed by a digit,
+it must be expressed using exactly three digits.)
+
+The @x{UTF-8} encoding of a @x{Unicode} character
+can be inserted in a literal string with
+the escape sequence @T{\u{@rep{XXX}}}
+(note the mandatory enclosing brackets),
+where @rep{XXX} is a sequence of one or more hexadecimal digits
+representing the character code point.
+
+Literal strings can also be defined using a long format
+enclosed by @def{long brackets}.
+We define an @def{opening long bracket of level @rep{n}} as an opening
+square bracket followed by @rep{n} equal signs followed by another
+opening square bracket.
+So, an opening long bracket of @N{level 0} is written as @T{[[}, @C{]]}
+an opening long bracket of @N{level 1} is written as @T{[=[}, @C{]]}
+and so on.
+A @emph{closing long bracket} is defined similarly;
+for instance,
+a closing long bracket of @N{level 4} is written as @C{[[} @T{]====]}.
+A @def{long literal} starts with an opening long bracket of any level and
+ends at the first closing long bracket of the same level.
+It can contain any text except a closing bracket of the same level.
+Literals in this bracketed form can run for several lines,
+do not interpret any escape sequences,
+and ignore long brackets of any other level.
+Any kind of end-of-line sequence
+(carriage return, newline, carriage return followed by newline,
+or newline followed by carriage return)
+is converted to a simple newline.
+
+For convenience,
+when the opening long bracket is immediately followed by a newline,
+the newline is not included in the string.
+As an example, in a system using ASCII
+(in which @Char{a} is coded @N{as 97},
+newline is coded @N{as 10}, and @Char{1} is coded @N{as 49}),
+the five literal strings below denote the same string:
+@verbatim{
+a = 'alo\n123"'
+a = "alo\n123\""
+a = '\97lo\10\04923"'
+a = [[alo
+123"]]
+a = [==[
+alo
+123"]==]
+}
+
+Any byte in a literal string not
+explicitly affected by the previous rules represents itself.
+However, Lua opens files for parsing in text mode,
+and the system file functions may have problems with
+some control characters.
+So, it is safer to represent
+non-text data as a quoted literal with
+explicit escape sequences for the non-text characters.
+
+A @def{numeric constant} (or @def{numeral})
+can be written with an optional fractional part
+and an optional decimal exponent,
+marked by a letter @Char{e} or @Char{E}.
+Lua also accepts @x{hexadecimal constants},
+which start with @T{0x} or @T{0X}.
+Hexadecimal constants also accept an optional fractional part
+plus an optional binary exponent,
+marked by a letter @Char{p} or @Char{P}.
+A numeric constant with a radix point or an exponent
+denotes a float;
+otherwise,
+if its value fits in an integer,
+it denotes an integer.
+Examples of valid integer constants are
+@verbatim{
+3   345   0xff   0xBEBADA
+}
+Examples of valid float constants are
+@verbatim{
+3.0     3.1416     314.16e-2     0.31416E1     34e1
+0x0.1E  0xA23p-4   0X1.921FB54442D18P+1
+}
+
+A @def{comment} starts with a double hyphen (@T{--})
+anywhere outside a string.
+If the text immediately after @T{--} is not an opening long bracket,
+the comment is a @def{short comment},
+which runs until the end of the line.
+Otherwise, it is a @def{long comment},
+which runs until the corresponding closing long bracket.
+Long comments are frequently used to disable code temporarily.
+
+}
+
+@sect2{variables| @title{Variables}
+
+Variables are places that store values.
+There are three kinds of variables in Lua:
+global variables, local variables, and table fields.
+
+A single name can denote a global variable or a local variable
+(or a function's formal parameter,
+which is a particular kind of local variable):
+@Produc{
+@producname{var}@producbody{@bnfNter{Name}}
+}
+@bnfNter{Name} denotes identifiers, as defined in @See{lexical}.
+
+Any variable name is assumed to be global unless explicitly declared
+as a local @see{localvar}.
+@x{Local variables} are @emph{lexically scoped}:
+local variables can be freely accessed by functions
+defined inside their scope @see{visibility}.
+
+Before the first assignment to a variable, its value is @nil.
+
+Square brackets are used to index a table:
+@Produc{
+@producname{var}@producbody{prefixexp @bnfter{[} exp @bnfter{]}}
+}
+The meaning of accesses to table fields can be changed via metatables
+@see{metatable}.
+
+The syntax @id{var.Name} is just syntactic sugar for
+@T{var["Name"]}:
+@Produc{
+@producname{var}@producbody{prefixexp @bnfter{.} @bnfNter{Name}}
+}
+
+An access to a global variable @id{x}
+is equivalent to @id{_ENV.x}.
+Due to the way that chunks are compiled,
+@id{_ENV} is never a global name @see{globalenv}.
+
+}
+
+@sect2{stats| @title{Statements}
+
+Lua supports an almost conventional set of @x{statements},
+similar to those in Pascal or C.
+This set includes
+assignments, control structures, function calls,
+and variable declarations.
+
+@sect3{@title{Blocks}
+
+A @x{block} is a list of statements,
+which are executed sequentially:
+@Produc{
+@producname{block}@producbody{@bnfrep{stat}}
+}
+Lua has @def{empty statements}
+that allow you to separate statements with semicolons,
+start a block with a semicolon
+or write two semicolons in sequence:
+@Produc{
+@producname{stat}@producbody{@bnfter{;}}
+}
+
+Function calls and assignments
+can start with an open parenthesis.
+This possibility leads to an ambiguity in Lua's grammar.
+Consider the following fragment:
+@verbatim{
+a = b + c
+(print or io.write)('done')
+}
+The grammar could see it in two ways:
+@verbatim{
+a = b + c(print or io.write)('done')
+
+a = b + c; (print or io.write)('done')
+}
+The current parser always sees such constructions
+in the first way,
+interpreting the open parenthesis
+as the start of the arguments to a call.
+To avoid this ambiguity,
+it is a good practice to always precede with a semicolon
+statements that start with a parenthesis:
+@verbatim{
+;(print or io.write)('done')
+}
+
+A block can be explicitly delimited to produce a single statement:
+@Produc{
+@producname{stat}@producbody{@Rw{do} block @Rw{end}}
+}
+Explicit blocks are useful
+to control the scope of variable declarations.
+Explicit blocks are also sometimes used to
+add a @Rw{return} statement in the middle
+of another block @see{control}.
+
+}
+
+@sect3{chunks| @title{Chunks}
+
+The unit of compilation of Lua is called a @def{chunk}.
+Syntactically,
+a chunk is simply a block:
+@Produc{
+@producname{chunk}@producbody{block}
+}
+
+Lua handles a chunk as the body of an anonymous function
+with a variable number of arguments
+@see{func-def}.
+As such, chunks can define local variables,
+receive arguments, and return values.
+Moreover, such anonymous function is compiled as in the
+scope of an external local variable called @id{_ENV} @see{globalenv}.
+The resulting function always has @id{_ENV} as its only upvalue,
+even if it does not use that variable.
+
+A chunk can be stored in a file or in a string inside the host program.
+To execute a chunk,
+Lua first @emph{loads} it,
+precompiling the chunk's code into instructions for a virtual machine,
+and then Lua executes the compiled code
+with an interpreter for the virtual machine.
+
+Chunks can also be precompiled into binary form;
+see program @idx{luac} and function @Lid{string.dump} for details.
+Programs in source and compiled forms are interchangeable;
+Lua automatically detects the file type and acts accordingly @seeF{load}.
+
+}
+
+@sect3{assignment| @title{Assignment}
+
+Lua allows @x{multiple assignments}.
+Therefore, the syntax for assignment
+defines a list of variables on the left side
+and a list of expressions on the right side.
+The elements in both lists are separated by commas:
+@Produc{
+@producname{stat}@producbody{varlist @bnfter{=} explist}
+@producname{varlist}@producbody{var @bnfrep{@bnfter{,} var}}
+@producname{explist}@producbody{exp @bnfrep{@bnfter{,} exp}}
+}
+Expressions are discussed in @See{expressions}.
+
+Before the assignment,
+the list of values is @emph{adjusted} to the length of
+the list of variables.@index{adjustment}
+If there are more values than needed,
+the excess values are thrown away.
+If there are fewer values than needed,
+the list is extended with as many  @nil's as needed.
+If the list of expressions ends with a function call,
+then all values returned by that call enter the list of values,
+before the adjustment
+(except when the call is enclosed in parentheses; see @See{expressions}).
+
+The assignment statement first evaluates all its expressions
+and only then the assignments are performed.
+Thus the code
+@verbatim{
+i = 3
+i, a[i] = i+1, 20
+}
+sets @T{a[3]} to 20, without affecting @T{a[4]}
+because the @id{i} in @T{a[i]} is evaluated (to 3)
+before it is @N{assigned 4}.
+Similarly, the line
+@verbatim{
+x, y = y, x
+}
+exchanges the values of @id{x} and @id{y},
+and
+@verbatim{
+x, y, z = y, z, x
+}
+cyclically permutes the values of @id{x}, @id{y}, and @id{z}.
+
+An assignment to a global name @T{x = val}
+is equivalent to the assignment
+@T{_ENV.x = val} @see{globalenv}.
+
+The meaning of assignments to table fields and
+global variables (which are actually table fields, too)
+can be changed via metatables @see{metatable}.
+
+}
+
+@sect3{control| @title{Control Structures}
+The control structures
+@Rw{if}, @Rw{while}, and @Rw{repeat} have the usual meaning and
+familiar syntax:
+@index{while-do statement}
+@index{repeat-until statement}
+@index{if-then-else statement}
+@Produc{
+@producname{stat}@producbody{@Rw{while} exp @Rw{do} block @Rw{end}}
+@producname{stat}@producbody{@Rw{repeat} block @Rw{until} exp}
+@producname{stat}@producbody{@Rw{if} exp @Rw{then} block
+  @bnfrep{@Rw{elseif} exp @Rw{then} block}
+   @bnfopt{@Rw{else} block} @Rw{end}}
+}
+Lua also has a @Rw{for} statement, in two flavors @see{for}.
+
+The @x{condition expression} of a
+control structure can return any value.
+Both @false and @nil are considered false.
+All values different from @nil and @false are considered true
+(in particular, the number 0 and the empty string are also true).
+
+In the @Rw{repeat}@En@Rw{until} loop,
+the inner block does not end at the @Rw{until} keyword,
+but only after the condition.
+So, the condition can refer to local variables
+declared inside the loop block.
+
+The @Rw{goto} statement transfers the program control to a label.
+For syntactical reasons,
+labels in Lua are considered statements too:
+@index{goto statement}
+@index{label}
+@Produc{
+@producname{stat}@producbody{@Rw{goto} Name}
+@producname{stat}@producbody{label}
+@producname{label}@producbody{@bnfter{::} Name @bnfter{::}}
+}
+
+A label is visible in the entire block where it is defined,
+except
+inside nested blocks where a label with the same name is defined and
+inside nested functions.
+A goto may jump to any visible label as long as it does not
+enter into the scope of a local variable.
+
+Labels and empty statements are called @def{void statements},
+as they perform no actions.
+
+The @Rw{break} statement terminates the execution of a
+@Rw{while}, @Rw{repeat}, or @Rw{for} loop,
+skipping to the next statement after the loop:
+@index{break statement}
+@Produc{
+@producname{stat}@producbody{@Rw{break}}
+}
+A @Rw{break} ends the innermost enclosing loop.
+
+The @Rw{return} statement is used to return values
+from a function or a chunk
+(which is an anonymous function).
+@index{return statement}
+Functions can return more than one value,
+so the syntax for the @Rw{return} statement is
+@Produc{
+@producname{stat}@producbody{@Rw{return} @bnfopt{explist} @bnfopt{@bnfter{;}}}
+}
+
+The @Rw{return} statement can only be written
+as the last statement of a block.
+If it is really necessary to @Rw{return} in the middle of a block,
+then an explicit inner block can be used,
+as in the idiom @T{do return end},
+because now @Rw{return} is the last statement in its (inner) block.
+
+}
+
+@sect3{for| @title{For Statement}
+
+@index{for statement}
+The @Rw{for} statement has two forms:
+one numerical and one generic.
+
+The numerical @Rw{for} loop repeats a block of code while a
+control variable runs through an arithmetic progression.
+It has the following syntax:
+@Produc{
+@producname{stat}@producbody{@Rw{for} @bnfNter{Name} @bnfter{=}
+  exp @bnfter{,} exp @bnfopt{@bnfter{,} exp} @Rw{do} block @Rw{end}}
+}
+The @emph{block} is repeated for @emph{name} starting at the value of
+the first @emph{exp}, until it passes the second @emph{exp} by steps of the
+third @emph{exp}.
+More precisely, a @Rw{for} statement like
+@verbatim{
+for v = @rep{e1}, @rep{e2}, @rep{e3} do @rep{block} end
+}
+is equivalent to the code:
+@verbatim{
+do
+  local @rep{var}, @rep{limit}, @rep{step} = tonumber(@rep{e1}), tonumber(@rep{e2}), tonumber(@rep{e3})
+  if not (@rep{var} and @rep{limit} and @rep{step}) then error() end
+  @rep{var} = @rep{var} - @rep{step}
+  while true do
+    @rep{var} = @rep{var} + @rep{step}
+    if (@rep{step} >= 0 and @rep{var} > @rep{limit}) or (@rep{step} < 0 and @rep{var} < @rep{limit}) then
+      break
+    end
+    local v = @rep{var}
+    @rep{block}
+  end
+end
+}
+
+Note the following:
+@itemize{
+
+@item{
+All three control expressions are evaluated only once,
+before the loop starts.
+They must all result in numbers.
+}
+
+@item{
+@T{@rep{var}}, @T{@rep{limit}}, and @T{@rep{step}} are invisible variables.
+The names shown here are for explanatory purposes only.
+}
+
+@item{
+If the third expression (the step) is absent,
+then a step @N{of 1} is used.
+}
+
+@item{
+You can use @Rw{break} and @Rw{goto} to exit a @Rw{for} loop.
+}
+
+@item{
+The loop variable @T{v} is local to the loop body.
+If you need its value after the loop,
+assign it to another variable before exiting the loop.
+}
+
+}
+
+The generic @Rw{for} statement works over functions,
+called @def{iterators}.
+On each iteration, the iterator function is called to produce a new value,
+stopping when this new value is @nil.
+The generic @Rw{for} loop has the following syntax:
+@Produc{
+@producname{stat}@producbody{@Rw{for} namelist @Rw{in} explist
+                    @Rw{do} block @Rw{end}}
+@producname{namelist}@producbody{@bnfNter{Name} @bnfrep{@bnfter{,} @bnfNter{Name}}}
+}
+A @Rw{for} statement like
+@verbatim{
+for @rep{var_1}, @Cdots, @rep{var_n} in @rep{explist} do @rep{block} end
+}
+is equivalent to the code:
+@verbatim{
+do
+  local @rep{f}, @rep{s}, @rep{var} = @rep{explist}
+  while true do
+    local @rep{var_1}, @Cdots, @rep{var_n} = @rep{f}(@rep{s}, @rep{var})
+    if @rep{var_1} == nil then break end
+    @rep{var} = @rep{var_1}
+    @rep{block}
+  end
+end
+}
+Note the following:
+@itemize{
+
+@item{
+@T{@rep{explist}} is evaluated only once.
+Its results are an @emph{iterator} function,
+a @emph{state},
+and an initial value for the first @emph{iterator variable}.
+}
+
+@item{
+@T{@rep{f}}, @T{@rep{s}}, and @T{@rep{var}} are invisible variables.
+The names are here for explanatory purposes only.
+}
+
+@item{
+You can use @Rw{break} to exit a @Rw{for} loop.
+}
+
+@item{
+The loop variables @T{@rep{var_i}} are local to the loop;
+you cannot use their values after the @Rw{for} ends.
+If you need these values,
+then assign them to other variables before breaking or exiting the loop.
+}
+
+}
+
+}
+
+@sect3{funcstat| @title{Function Calls as Statements}
+To allow possible side-effects,
+function calls can be executed as statements:
+@Produc{
+@producname{stat}@producbody{functioncall}
+}
+In this case, all returned values are thrown away.
+Function calls are explained in @See{functioncall}.
+
+}
+
+@sect3{localvar| @title{Local Declarations}
+@x{Local variables} can be declared anywhere inside a block.
+The declaration can include an initial assignment:
+@Produc{
+@producname{stat}@producbody{@Rw{local} namelist @bnfopt{@bnfter{=} explist}}
+}
+If present, an initial assignment has the same semantics
+of a multiple assignment @see{assignment}.
+Otherwise, all variables are initialized with @nil.
+
+A chunk is also a block @see{chunks},
+and so local variables can be declared in a chunk outside any explicit block.
+
+The visibility rules for local variables are explained in @See{visibility}.
+
+}
+
+}
+
+@sect2{expressions| @title{Expressions}
+
+The basic expressions in Lua are the following:
+@Produc{
+@producname{exp}@producbody{prefixexp}
+@producname{exp}@producbody{@Rw{nil} @Or @Rw{false} @Or @Rw{true}}
+@producname{exp}@producbody{@bnfNter{Numeral}}
+@producname{exp}@producbody{@bnfNter{LiteralString}}
+@producname{exp}@producbody{functiondef}
+@producname{exp}@producbody{tableconstructor}
+@producname{exp}@producbody{@bnfter{...}}
+@producname{exp}@producbody{exp binop exp}
+@producname{exp}@producbody{unop exp}
+@producname{prefixexp}@producbody{var @Or functioncall @Or
+                                  @bnfter{(} exp @bnfter{)}}
+}
+
+Numerals and literal strings are explained in @See{lexical};
+variables are explained in @See{variables};
+function definitions are explained in @See{func-def};
+function calls are explained in @See{functioncall};
+table constructors are explained in @See{tableconstructor}.
+Vararg expressions,
+denoted by three dots (@Char{...}), can only be used when
+directly inside a vararg function;
+they are explained in @See{func-def}.
+
+Binary operators comprise arithmetic operators @see{arith},
+bitwise operators @see{bitwise},
+relational operators @see{rel-ops}, logical operators @see{logic},
+and the concatenation operator @see{concat}.
+Unary operators comprise the unary minus @see{arith},
+the unary bitwise NOT @see{bitwise},
+the unary logical @Rw{not} @see{logic},
+and the unary @def{length operator} @see{len-op}.
+
+Both function calls and vararg expressions can result in multiple values.
+If a function call is used as a statement @see{funcstat},
+then its return list is adjusted to zero elements,
+thus discarding all returned values.
+If an expression is used as the last (or the only) element
+of a list of expressions,
+then no adjustment is made
+(unless the expression is enclosed in parentheses).
+In all other contexts,
+Lua adjusts the result list to one element,
+either discarding all values except the first one
+or adding a single @nil if there are no values.
+
+Here are some examples:
+@verbatim{
+f()                -- adjusted to 0 results
+g(f(), x)          -- f() is adjusted to 1 result
+g(x, f())          -- g gets x plus all results from f()
+a,b,c = f(), x     -- f() is adjusted to 1 result (c gets nil)
+a,b = ...          -- a gets the first vararg argument, b gets
+                   -- the second (both a and b can get nil if there
+                   -- is no corresponding vararg argument)
+
+a,b,c = x, f()     -- f() is adjusted to 2 results
+a,b,c = f()        -- f() is adjusted to 3 results
+return f()         -- returns all results from f()
+return ...         -- returns all received vararg arguments
+return x,y,f()     -- returns x, y, and all results from f()
+{f()}              -- creates a list with all results from f()
+{...}              -- creates a list with all vararg arguments
+{f(), nil}         -- f() is adjusted to 1 result
+}
+
+Any expression enclosed in parentheses always results in only one value.
+Thus,
+@T{(f(x,y,z))} is always a single value,
+even if @id{f} returns several values.
+(The value of @T{(f(x,y,z))} is the first value returned by @id{f}
+or @nil if @id{f} does not return any values.)
+
+
+
+@sect3{arith| @title{Arithmetic Operators}
+Lua supports the following @x{arithmetic operators}:
+@description{
+@item{@T{+}|addition}
+@item{@T{-}|subtraction}
+@item{@T{*}|multiplication}
+@item{@T{/}|float division}
+@item{@T{//}|floor division}
+@item{@T{%}|modulo}
+@item{@T{^}|exponentiation}
+@item{@T{-}|unary minus}
+}
+
+With the exception of exponentiation and float division,
+the arithmetic operators work as follows:
+If both operands are integers,
+the operation is performed over integers and the result is an integer.
+Otherwise, if both operands are numbers
+or strings that can be converted to
+numbers @see{coercion},
+then they are converted to floats,
+the operation is performed following the usual rules
+for floating-point arithmetic
+(usually the @x{IEEE 754} standard),
+and the result is a float.
+
+Exponentiation and float division (@T{/})
+always convert their operands to floats
+and the result is always a float.
+Exponentiation uses the @ANSI{pow},
+so that it works for non-integer exponents too.
+
+Floor division (@T{//}) is a division
+that rounds the quotient towards minus infinity,
+that is, the floor of the division of its operands.
+
+Modulo is defined as the remainder of a division
+that rounds the quotient towards minus infinity (floor division).
+
+In case of overflows in integer arithmetic,
+all operations @emphx{wrap around},
+according to the usual rules of two-complement arithmetic.
+(In other words,
+they return the unique representable integer
+that is equal modulo @M{2@sp{64}} to the mathematical result.)
+}
+
+@sect3{bitwise| @title{Bitwise Operators}
+Lua supports the following @x{bitwise operators}:
+@description{
+@item{@T{&}|bitwise AND}
+@item{@T{@VerBar}|bitwise OR}
+@item{@T{~}|bitwise exclusive OR}
+@item{@T{>>}|right shift}
+@item{@T{<<}|left shift}
+@item{@T{~}|unary bitwise NOT}
+}
+
+All bitwise operations convert its operands to integers
+@see{coercion},
+operate on all bits of those integers,
+and result in an integer.
+
+Both right and left shifts fill the vacant bits with zeros.
+Negative displacements shift to the other direction;
+displacements with absolute values equal to or higher than
+the number of bits in an integer
+result in zero (as all bits are shifted out).
+
+}
+
+@sect3{coercion| @title{Coercions and Conversions}
+Lua provides some automatic conversions between some
+types and representations at run time.
+Bitwise operators always convert float operands to integers.
+Exponentiation and float division
+always convert integer operands to floats.
+All other arithmetic operations applied to mixed numbers
+(integers and floats) convert the integer operand to a float;
+this is called the @def{usual rule}.
+The C API also converts both integers to floats and
+floats to integers, as needed.
+Moreover, string concatenation accepts numbers as arguments,
+besides strings.
+
+Lua also converts strings to numbers,
+whenever a number is expected.
+
+In a conversion from integer to float,
+if the integer value has an exact representation as a float,
+that is the result.
+Otherwise,
+the conversion gets the nearest higher or
+the nearest lower representable value.
+This kind of conversion never fails.
+
+The conversion from float to integer
+checks whether the float has an exact representation as an integer
+(that is, the float has an integral value and
+it is in the range of integer representation).
+If it does, that representation is the result.
+Otherwise, the conversion fails.
+
+The conversion from strings to numbers goes as follows:
+First, the string is converted to an integer or a float,
+following its syntax and the rules of the Lua lexer.
+(The string may have also leading and trailing spaces and a sign.)
+Then, the resulting number (float or integer)
+is converted to the type (float or integer) required by the context
+(e.g., the operation that forced the conversion).
+
+All conversions from strings to numbers
+accept both a dot and the current locale mark
+as the radix character.
+(The Lua lexer, however, accepts only a dot.)
+
+The conversion from numbers to strings uses a
+non-specified human-readable format.
+For complete control over how numbers are converted to strings,
+use the @id{format} function from the string library
+@seeF{string.format}.
+
+}
+
+@sect3{rel-ops| @title{Relational Operators}
+Lua supports the following @x{relational operators}:
+@description{
+@item{@T{==}|equality}
+@item{@T{~=}|inequality}
+@item{@T{<}|less than}
+@item{@T{>}|greater than}
+@item{@T{<=}|less or equal}
+@item{@T{>=}|greater or equal}
+}
+These operators always result in @false or @true.
+
+Equality (@T{==}) first compares the type of its operands.
+If the types are different, then the result is @false.
+Otherwise, the values of the operands are compared.
+Strings are compared in the obvious way.
+Numbers are equal if they denote the same mathematical value.
+
+Tables, userdata, and threads
+are compared by reference:
+two objects are considered equal only if they are the same object.
+Every time you create a new object
+(a table, userdata, or thread),
+this new object is different from any previously existing object.
+A closure is always equal to itself.
+Closures with any detectable difference
+(different behavior, different definition) are always different.
+Closures created at different times but with no detectable differences
+may be classified as equal or not
+(depending on internal caching details).
+
+You can change the way that Lua compares tables and userdata
+by using the @Q{eq} metamethod @see{metatable}.
+
+Equality comparisons do not convert strings to numbers
+or vice versa.
+Thus, @T{"0"==0} evaluates to @false,
+and @T{t[0]} and @T{t["0"]} denote different
+entries in a table.
+
+The operator @T{~=} is exactly the negation of equality (@T{==}).
+
+The order operators work as follows.
+If both arguments are numbers,
+then they are compared according to their mathematical values
+(regardless of their subtypes).
+Otherwise, if both arguments are strings,
+then their values are compared according to the current locale.
+Otherwise, Lua tries to call the @Q{lt} or the @Q{le}
+metamethod @see{metatable}.
+A comparison @T{a > b} is translated to @T{b < a}
+and @T{a >= b} is translated to @T{b <= a}.
+
+Following the @x{IEEE 754} standard,
+@x{NaN} is considered neither smaller than,
+nor equal to, nor greater than any value (including itself).
+
+}
+
+@sect3{logic| @title{Logical Operators}
+The @x{logical operators} in Lua are
+@Rw{and}, @Rw{or}, and @Rw{not}.
+Like the control structures @see{control},
+all logical operators consider both @false and @nil as false
+and anything else as true.
+
+The negation operator @Rw{not} always returns @false or @true.
+The conjunction operator @Rw{and} returns its first argument
+if this value is @false or @nil;
+otherwise, @Rw{and} returns its second argument.
+The disjunction operator @Rw{or} returns its first argument
+if this value is different from @nil and @false;
+otherwise, @Rw{or} returns its second argument.
+Both @Rw{and} and @Rw{or} use @x{short-circuit evaluation};
+that is,
+the second operand is evaluated only if necessary.
+Here are some examples:
+@verbatim{
+10 or 20            --> 10
+10 or error()       --> 10
+nil or "a"          --> "a"
+nil and 10          --> nil
+false and error()   --> false
+false and nil       --> false
+false or nil        --> nil
+10 and 20           --> 20
+}
+(In this manual,
+@T{-->} indicates the result of the preceding expression.)
+
+}
+
+@sect3{concat| @title{Concatenation}
+The string @x{concatenation} operator in Lua is
+denoted by two dots (@Char{..}).
+If both operands are strings or numbers, then they are converted to
+strings according to the rules described in @See{coercion}.
+Otherwise, the @idx{__concat} metamethod is called @see{metatable}.
+
+}
+
+@sect3{len-op| @title{The Length Operator}
+
+The length operator is denoted by the unary prefix operator @T{#}.
+
+The length of a string is its number of bytes
+(that is, the usual meaning of string length when each
+character is one byte).
+
+The length operator applied on a table
+returns a @x{border} in that table.
+A @def{border} in a table @id{t} is any natural number
+that satisfies the following condition:
+@verbatim{
+(border == 0 or t[border] ~= nil) and t[border + 1] == nil
+}
+In words,
+a border is any (natural) index in a table
+where a non-nil value is followed by a nil value
+(or zero, when index 1 is nil).
+
+A table with exactly one border is called a @def{sequence}.
+For instance, the table @T{{10, 20, 30, 40, 50}} is a sequence,
+as it has only one border (5).
+The table @T{{10, 20, 30, nil, 50}} has two borders (3 and 5),
+and therefore it is not a sequence.
+The table @T{{nil, 20, 30, nil, nil, 60, nil}}
+has three borders (0, 3, and 6),
+so it is not a sequence, too.
+The table @T{{}} is a sequence with border 0.
+Note that non-natural keys do not interfere
+with whether a table is a sequence.
+
+When @id{t} is a sequence,
+@T{#t} returns its only border,
+which corresponds to the intuitive notion of the length of the sequence.
+When @id{t} is not a sequence,
+@T{#t} can return any of its borders.
+(The exact one depends on details of
+the internal representation of the table,
+which in turn can depend on how the table was populated and
+the memory addresses of its non-numeric keys.)
+
+The computation of the length of a table
+has a guaranteed worst time of @M{O(log n)},
+where @M{n} is the largest natural key in the table.
+
+A program can modify the behavior of the length operator for
+any value but strings through the @idx{__len} metamethod @see{metatable}.
+
+}
+
+@sect3{prec| @title{Precedence}
+@x{Operator precedence} in Lua follows the table below,
+from lower to higher priority:
+@verbatim{
+or
+and
+<     >     <=    >=    ~=    ==
+|
+~
+&
+<<    >>
+..
++     -
+*     /     //    %
+unary operators (not   #     -     ~)
+^
+}
+As usual,
+you can use parentheses to change the precedences of an expression.
+The concatenation (@Char{..}) and exponentiation (@Char{^})
+operators are right associative.
+All other binary operators are left associative.
+
+}
+
+@sect3{tableconstructor| @title{Table Constructors}
+Table @x{constructors} are expressions that create tables.
+Every time a constructor is evaluated, a new table is created.
+A constructor can be used to create an empty table
+or to create a table and initialize some of its fields.
+The general syntax for constructors is
+@Produc{
+@producname{tableconstructor}@producbody{@bnfter{@Open} @bnfopt{fieldlist} @bnfter{@Close}}
+@producname{fieldlist}@producbody{field @bnfrep{fieldsep field} @bnfopt{fieldsep}}
+@producname{field}@producbody{@bnfter{[} exp @bnfter{]} @bnfter{=} exp @Or
+               @bnfNter{Name} @bnfter{=} exp @Or exp}
+@producname{fieldsep}@producbody{@bnfter{,} @Or @bnfter{;}}
+}
+
+Each field of the form @T{[exp1] = exp2} adds to the new table an entry
+with key @id{exp1} and value @id{exp2}.
+A field of the form @T{name = exp} is equivalent to
+@T{["name"] = exp}.
+Finally, fields of the form @id{exp} are equivalent to
+@T{[i] = exp}, where @id{i} are consecutive integers
+starting with 1.
+Fields in the other formats do not affect this counting.
+For example,
+@verbatim{
+a = { [f(1)] = g; "x", "y"; x = 1, f(x), [30] = 23; 45 }
+}
+is equivalent to
+@verbatim{
+do
+  local t = {}
+  t[f(1)] = g
+  t[1] = "x"         -- 1st exp
+  t[2] = "y"         -- 2nd exp
+  t.x = 1            -- t["x"] = 1
+  t[3] = f(x)        -- 3rd exp
+  t[30] = 23
+  t[4] = 45          -- 4th exp
+  a = t
+end
+}
+
+The order of the assignments in a constructor is undefined.
+(This order would be relevant only when there are repeated keys.)
+
+If the last field in the list has the form @id{exp}
+and the expression is a function call or a vararg expression,
+then all values returned by this expression enter the list consecutively
+@see{functioncall}.
+
+The field list can have an optional trailing separator,
+as a convenience for machine-generated code.
+
+}
+
+@sect3{functioncall| @title{Function Calls}
+A @x{function call} in Lua has the following syntax:
+@Produc{
+@producname{functioncall}@producbody{prefixexp args}
+}
+In a function call,
+first @bnfNter{prefixexp} and @bnfNter{args} are evaluated.
+If the value of @bnfNter{prefixexp} has type @emph{function},
+then this function is called
+with the given arguments.
+Otherwise, the @bnfNter{prefixexp} @Q{call} metamethod is called,
+having as first argument the value of @bnfNter{prefixexp},
+followed by the original call arguments
+@see{metatable}.
+
+The form
+@Produc{
+@producname{functioncall}@producbody{prefixexp @bnfter{:} @bnfNter{Name} args}
+}
+can be used to call @Q{methods}.
+A call @T{v:name(@rep{args})}
+is syntactic sugar for @T{v.name(v,@rep{args})},
+except that @id{v} is evaluated only once.
+
+Arguments have the following syntax:
+@Produc{
+@producname{args}@producbody{@bnfter{(} @bnfopt{explist} @bnfter{)}}
+@producname{args}@producbody{tableconstructor}
+@producname{args}@producbody{@bnfNter{LiteralString}}
+}
+All argument expressions are evaluated before the call.
+A call of the form @T{f{@rep{fields}}} is
+syntactic sugar for @T{f({@rep{fields}})};
+that is, the argument list is a single new table.
+A call of the form @T{f'@rep{string}'}
+(or @T{f"@rep{string}"} or @T{f[[@rep{string}]]})
+is syntactic sugar for @T{f('@rep{string}')};
+that is, the argument list is a single literal string.
+
+A call of the form @T{return @rep{functioncall}} is called
+a @def{tail call}.
+Lua implements @def{proper tail calls}
+(or @emph{proper tail recursion}):
+in a tail call,
+the called function reuses the stack entry of the calling function.
+Therefore, there is no limit on the number of nested tail calls that
+a program can execute.
+However, a tail call erases any debug information about the
+calling function.
+Note that a tail call only happens with a particular syntax,
+where the @Rw{return} has one single function call as argument;
+this syntax makes the calling function return exactly
+the returns of the called function.
+So, none of the following examples are tail calls:
+@verbatim{
+return (f(x))        -- results adjusted to 1
+return 2 * f(x)
+return x, f(x)       -- additional results
+f(x); return         -- results discarded
+return x or f(x)     -- results adjusted to 1
+}
+
+}
+
+@sect3{func-def| @title{Function Definitions}
+
+The syntax for function definition is
+@Produc{
+@producname{functiondef}@producbody{@Rw{function} funcbody}
+@producname{funcbody}@producbody{@bnfter{(} @bnfopt{parlist} @bnfter{)} block @Rw{end}}
+}
+
+The following syntactic sugar simplifies function definitions:
+@Produc{
+@producname{stat}@producbody{@Rw{function} funcname funcbody}
+@producname{stat}@producbody{@Rw{local} @Rw{function} @bnfNter{Name} funcbody}
+@producname{funcname}@producbody{@bnfNter{Name} @bnfrep{@bnfter{.} @bnfNter{Name}} @bnfopt{@bnfter{:} @bnfNter{Name}}}
+}
+The statement
+@verbatim{
+function f () @rep{body} end
+}
+translates to
+@verbatim{
+f = function () @rep{body} end
+}
+The statement
+@verbatim{
+function t.a.b.c.f () @rep{body} end
+}
+translates to
+@verbatim{
+t.a.b.c.f = function () @rep{body} end
+}
+The statement
+@verbatim{
+local function f () @rep{body} end
+}
+translates to
+@verbatim{
+local f; f = function () @rep{body} end
+}
+not to
+@verbatim{
+local f = function () @rep{body} end
+}
+(This only makes a difference when the body of the function
+contains references to @id{f}.)
+
+A function definition is an executable expression,
+whose value has type @emph{function}.
+When Lua precompiles a chunk,
+all its function bodies are precompiled too.
+Then, whenever Lua executes the function definition,
+the function is @emph{instantiated} (or @emph{closed}).
+This function instance (or @emphx{closure})
+is the final value of the expression.
+
+Parameters act as local variables that are
+initialized with the argument values:
+@Produc{
+@producname{parlist}@producbody{namelist @bnfopt{@bnfter{,} @bnfter{...}} @Or
+  @bnfter{...}}
+}
+When a function is called,
+the list of @x{arguments} is adjusted to
+the length of the list of parameters,
+unless the function is a @def{vararg function},
+which is indicated by three dots (@Char{...})
+at the end of its parameter list.
+A vararg function does not adjust its argument list;
+instead, it collects all extra arguments and supplies them
+to the function through a @def{vararg expression},
+which is also written as three dots.
+The value of this expression is a list of all actual extra arguments,
+similar to a function with multiple results.
+If a vararg expression is used inside another expression
+or in the middle of a list of expressions,
+then its return list is adjusted to one element.
+If the expression is used as the last element of a list of expressions,
+then no adjustment is made
+(unless that last expression is enclosed in parentheses).
+
+
+As an example, consider the following definitions:
+@verbatim{
+function f(a, b) end
+function g(a, b, ...) end
+function r() return 1,2,3 end
+}
+Then, we have the following mapping from arguments to parameters and
+to the vararg expression:
+@verbatim{
+CALL            PARAMETERS
+
+f(3)             a=3, b=nil
+f(3, 4)          a=3, b=4
+f(3, 4, 5)       a=3, b=4
+f(r(), 10)       a=1, b=10
+f(r())           a=1, b=2
+
+g(3)             a=3, b=nil, ... -->  (nothing)
+g(3, 4)          a=3, b=4,   ... -->  (nothing)
+g(3, 4, 5, 8)    a=3, b=4,   ... -->  5  8
+g(5, r())        a=5, b=1,   ... -->  2  3
+}
+
+Results are returned using the @Rw{return} statement @see{control}.
+If control reaches the end of a function
+without encountering a @Rw{return} statement,
+then the function returns with no results.
+
+@index{multiple return}
+There is a system-dependent limit on the number of values
+that a function may return.
+This limit is guaranteed to be larger than 1000.
+
+The @emphx{colon} syntax
+is used for defining @def{methods},
+that is, functions that have an implicit extra parameter @idx{self}.
+Thus, the statement
+@verbatim{
+function t.a.b.c:f (@rep{params}) @rep{body} end
+}
+is syntactic sugar for
+@verbatim{
+t.a.b.c.f = function (self, @rep{params}) @rep{body} end
+}
+
+}
+
+}
+
+@sect2{visibility| @title{Visibility Rules}
+
+@index{visibility}
+Lua is a lexically scoped language.
+The scope of a local variable begins at the first statement after
+its declaration and lasts until the last non-void statement
+of the innermost block that includes the declaration.
+Consider the following example:
+@verbatim{
+x = 10                -- global variable
+do                    -- new block
+  local x = x         -- new 'x', with value 10
+  print(x)            --> 10
+  x = x+1
+  do                  -- another block
+    local x = x+1     -- another 'x'
+    print(x)          --> 12
+  end
+  print(x)            --> 11
+end
+print(x)              --> 10  (the global one)
+}
+
+Notice that, in a declaration like @T{local x = x},
+the new @id{x} being declared is not in scope yet,
+and so the second @id{x} refers to the outside variable.
+
+Because of the @x{lexical scoping} rules,
+local variables can be freely accessed by functions
+defined inside their scope.
+A local variable used by an inner function is called
+an @def{upvalue}, or @emphx{external local variable},
+inside the inner function.
+
+Notice that each execution of a @Rw{local} statement
+defines new local variables.
+Consider the following example:
+@verbatim{
+a = {}
+local x = 20
+for i=1,10 do
+  local y = 0
+  a[i] = function () y=y+1; return x+y end
+end
+}
+The loop creates ten closures
+(that is, ten instances of the anonymous function).
+Each of these closures uses a different @id{y} variable,
+while all of them share the same @id{x}.
+
+}
+
+}
+
+
+@C{-------------------------------------------------------------------------}
+@sect1{API| @title{The Application Program Interface}
+
+@index{C API}
+This section describes the @N{C API} for Lua, that is,
+the set of @N{C functions} available to the host program to communicate
+with Lua.
+All API functions and related types and constants
+are declared in the header file @defid{lua.h}.
+
+Even when we use the term @Q{function},
+any facility in the API may be provided as a macro instead.
+Except where stated otherwise,
+all such macros use each of their arguments exactly once
+(except for the first argument, which is always a Lua state),
+and so do not generate any hidden side-effects.
+
+As in most @N{C libraries},
+the Lua API functions do not check their arguments for validity or consistency.
+However, you can change this behavior by compiling Lua
+with the macro @defid{LUA_USE_APICHECK} defined.
+
+The Lua library is fully reentrant:
+it has no global variables.
+It keeps all information it needs in a dynamic structure,
+called the @def{Lua state}.
+
+Each Lua state has one or more threads,
+which correspond to independent, cooperative lines of execution.
+The type @Lid{lua_State} (despite its name) refers to a thread.
+(Indirectly, through the thread, it also refers to the
+Lua state associated to the thread.)
+
+A pointer to a thread must be passed as the first argument to
+every function in the library, except to @Lid{lua_newstate},
+which creates a Lua state from scratch and returns a pointer
+to the @emph{main thread} in the new state.
+
+
+@sect2{@title{The Stack}
+
+Lua uses a @emph{virtual stack} to pass values to and from C.
+Each element in this stack represents a Lua value
+(@nil, number, string, etc.).
+Functions in the API can access this stack through the
+Lua state parameter that they receive.
+
+Whenever Lua calls C, the called function gets a new stack,
+which is independent of previous stacks and of stacks of
+@N{C functions} that are still active.
+This stack initially contains any arguments to the @N{C function}
+and it is where the @N{C function} can store temporary
+Lua values and must push its results
+to be returned to the caller @seeC{lua_CFunction}.
+
+For convenience,
+most query operations in the API do not follow a strict stack discipline.
+Instead, they can refer to any element in the stack
+by using an @emph{index}:@index{index (API stack)}
+A positive index represents an absolute stack position
+(starting @N{at 1});
+a negative index represents an offset relative to the top of the stack.
+More specifically, if the stack has @rep{n} elements,
+then @N{index 1} represents the first element
+(that is, the element that was pushed onto the stack first)
+and
+@N{index @rep{n}} represents the last element;
+@N{index @num{-1}} also represents the last element
+(that is, the element at @N{the top})
+and index @M{-n} represents the first element.
+
+}
+
+@sect2{stacksize| @title{Stack Size}
+
+When you interact with the Lua API,
+you are responsible for ensuring consistency.
+In particular,
+@emph{you are responsible for controlling stack overflow}.
+You can use the function @Lid{lua_checkstack}
+to ensure that the stack has enough space for pushing new elements.
+
+Whenever Lua calls C,
+it ensures that the stack has space for
+at least @defid{LUA_MINSTACK} extra slots.
+@id{LUA_MINSTACK} is defined as 20,
+so that usually you do not have to worry about stack space
+unless your code has loops pushing elements onto the stack.
+
+When you call a Lua function
+without a fixed number of results @seeF{lua_call},
+Lua ensures that the stack has enough space for all results,
+but it does not ensure any extra space.
+So, before pushing anything in the stack after such a call
+you should use @Lid{lua_checkstack}.
+
+}
+
+@sect2{@title{Valid and Acceptable Indices}
+
+Any function in the API that receives stack indices
+works only with @emphx{valid indices} or @emphx{acceptable indices}.
+
+A @def{valid index} is an index that refers to a
+position that stores a modifiable Lua value.
+It comprises stack indices @N{between 1} and the stack top
+(@T{1 @leq abs(index) @leq top})
+@index{stack index}
+plus @def{pseudo-indices},
+which represent some positions that are accessible to @N{C code}
+but that are not in the stack.
+Pseudo-indices are used to access the registry @see{registry}
+and the upvalues of a @N{C function} @see{c-closure}.
+
+Functions that do not need a specific mutable position,
+but only a value (e.g., query functions),
+can be called with acceptable indices.
+An @def{acceptable index} can be any valid index,
+but it also can be any positive index after the stack top
+within the space allocated for the stack,
+that is, indices up to the stack size.
+(Note that 0 is never an acceptable index.)
+Except when noted otherwise,
+functions in the API work with acceptable indices.
+
+Acceptable indices serve to avoid extra tests
+against the stack top when querying the stack.
+For instance, a @N{C function} can query its third argument
+without the need to first check whether there is a third argument,
+that is, without the need to check whether 3 is a valid index.
+
+For functions that can be called with acceptable indices,
+any non-valid index is treated as if it
+contains a value of a virtual type @defid{LUA_TNONE},
+which behaves like a nil value.
+
+}
+
+@sect2{c-closure| @title{C Closures}
+
+When a @N{C function} is created,
+it is possible to associate some values with it,
+thus creating a @def{@N{C closure}}
+@seeC{lua_pushcclosure};
+these values are called @def{upvalues} and are
+accessible to the function whenever it is called.
+
+Whenever a @N{C function} is called,
+its upvalues are located at specific pseudo-indices.
+These pseudo-indices are produced by the macro
+@Lid{lua_upvalueindex}.
+The first upvalue associated with a function is at index
+@T{lua_upvalueindex(1)}, and so on.
+Any access to @T{lua_upvalueindex(@rep{n})},
+where @rep{n} is greater than the number of upvalues of the
+current function
+(but not greater than 256,
+which is one plus the maximum number of upvalues in a closure),
+produces an acceptable but invalid index.
+
+}
+
+@sect2{registry| @title{Registry}
+
+Lua provides a @def{registry},
+a predefined table that can be used by any @N{C code} to
+store whatever Lua values it needs to store.
+The registry table is always located at pseudo-index
+@defid{LUA_REGISTRYINDEX}.
+Any @N{C library} can store data into this table,
+but it must take care to choose keys
+that are different from those used
+by other libraries, to avoid collisions.
+Typically, you should use as key a string containing your library name,
+or a light userdata with the address of a @N{C object} in your code,
+or any Lua object created by your code.
+As with variable names,
+string keys starting with an underscore followed by
+uppercase letters are reserved for Lua.
+
+The integer keys in the registry are used
+by the reference mechanism @seeC{luaL_ref}
+and by some predefined values.
+Therefore, integer keys must not be used for other purposes.
+
+When you create a new Lua state,
+its registry comes with some predefined values.
+These predefined values are indexed with integer keys
+defined as constants in @id{lua.h}.
+The following constants are defined:
+@description{
+@item{@defid{LUA_RIDX_MAINTHREAD}| At this index the registry has
+the main thread of the state.
+(The main thread is the one created together with the state.)
+}
+
+@item{@defid{LUA_RIDX_GLOBALS}| At this index the registry has
+the @x{global environment}.
+}
+}
+
+}
+
+@sect2{C-error|@title{Error Handling in C}
+
+Internally, Lua uses the C @id{longjmp} facility to handle errors.
+(Lua will use exceptions if you compile it as C++;
+search for @id{LUAI_THROW} in the source code for details.)
+When Lua faces any error
+(such as a @x{memory allocation error} or a type error)
+it @emph{raises} an error;
+that is, it does a long jump.
+A @emphx{protected environment} uses @id{setjmp}
+to set a recovery point;
+any error jumps to the most recent active recovery point.
+
+Inside a @N{C function} you can raise an error by calling @Lid{lua_error}.
+
+Most functions in the API can raise an error,
+for instance due to a @x{memory allocation error}.
+The documentation for each function indicates whether
+it can raise errors.
+
+If an error happens outside any protected environment,
+Lua calls a @def{panic function} (see @Lid{lua_atpanic})
+and then calls @T{abort},
+thus exiting the host application.
+Your panic function can avoid this exit by
+never returning
+(e.g., doing a long jump to your own recovery point outside Lua).
+
+The panic function,
+as its name implies,
+is a mechanism of last resort.
+Programs should avoid it.
+As a general rule,
+when a @N{C function} is called by Lua with a Lua state,
+it can do whatever it wants on that Lua state,
+as it should be already protected.
+However,
+when C code operates on other Lua states
+(e.g., a Lua argument to the function,
+a Lua state stored in the registry, or
+the result of @Lid{lua_newthread}),
+it should use them only in API calls that cannot raise errors.
+
+The panic function runs as if it were a @x{message handler} @see{error};
+in particular, the error object is at the top of the stack.
+However, there is no guarantee about stack space.
+To push anything on the stack,
+the panic function must first check the available space @see{stacksize}.
+
+}
+
+@sect2{continuations|@title{Handling Yields in C}
+
+Internally, Lua uses the C @id{longjmp} facility to yield a coroutine.
+Therefore, if a @N{C function} @id{foo} calls an API function
+and this API function yields
+(directly or indirectly by calling another function that yields),
+Lua cannot return to @id{foo} any more,
+because the @id{longjmp} removes its frame from the C stack.
+
+To avoid this kind of problem,
+Lua raises an error whenever it tries to yield across an API call,
+except for three functions:
+@Lid{lua_yieldk}, @Lid{lua_callk}, and @Lid{lua_pcallk}.
+All those functions receive a @def{continuation function}
+(as a parameter named @id{k}) to continue execution after a yield.
+
+We need to set some terminology to explain continuations.
+We have a @N{C function} called from Lua which we will call
+the @emph{original function}.
+This original function then calls one of those three functions in the C API,
+which we will call the @emph{callee function},
+that then yields the current thread.
+(This can happen when the callee function is @Lid{lua_yieldk},
+or when the callee function is either @Lid{lua_callk} or @Lid{lua_pcallk}
+and the function called by them yields.)
+
+Suppose the running thread yields while executing the callee function.
+After the thread resumes,
+it eventually will finish running the callee function.
+However,
+the callee function cannot return to the original function,
+because its frame in the C stack was destroyed by the yield.
+Instead, Lua calls a @def{continuation function},
+which was given as an argument to the callee function.
+As the name implies,
+the continuation function should continue the task
+of the original function.
+
+As an illustration, consider the following function:
+@verbatim{
+int original_function (lua_State *L) {
+  ...     /* code 1 */
+  status = lua_pcall(L, n, m, h);  /* calls Lua */
+  ...     /* code 2 */
+}
+}
+Now we want to allow
+the Lua code being run by @Lid{lua_pcall} to yield.
+First, we can rewrite our function like here:
+@verbatim{
+int k (lua_State *L, int status, lua_KContext ctx) {
+  ...  /* code 2 */
+}
+
+int original_function (lua_State *L) {
+  ...     /* code 1 */
+  return k(L, lua_pcall(L, n, m, h), ctx);
+}
+}
+In the above code,
+the new function @id{k} is a
+@emph{continuation function} (with type @Lid{lua_KFunction}),
+which should do all the work that the original function
+was doing after calling @Lid{lua_pcall}.
+Now, we must inform Lua that it must call @id{k} if the Lua code
+being executed by @Lid{lua_pcall} gets interrupted in some way
+(errors or yielding),
+so we rewrite the code as here,
+replacing @Lid{lua_pcall} by @Lid{lua_pcallk}:
+@verbatim{
+int original_function (lua_State *L) {
+  ...     /* code 1 */
+  return k(L, lua_pcallk(L, n, m, h, ctx2, k), ctx1);
+}
+}
+Note the external, explicit call to the continuation:
+Lua will call the continuation only if needed, that is,
+in case of errors or resuming after a yield.
+If the called function returns normally without ever yielding,
+@Lid{lua_pcallk} (and @Lid{lua_callk}) will also return normally.
+(Of course, instead of calling the continuation in that case,
+you can do the equivalent work directly inside the original function.)
+
+Besides the Lua state,
+the continuation function has two other parameters:
+the final status of the call plus the context value (@id{ctx}) that
+was passed originally to @Lid{lua_pcallk}.
+(Lua does not use this context value;
+it only passes this value from the original function to the
+continuation function.)
+For @Lid{lua_pcallk},
+the status is the same value that would be returned by @Lid{lua_pcallk},
+except that it is @Lid{LUA_YIELD} when being executed after a yield
+(instead of @Lid{LUA_OK}).
+For @Lid{lua_yieldk} and @Lid{lua_callk},
+the status is always @Lid{LUA_YIELD} when Lua calls the continuation.
+(For these two functions,
+Lua will not call the continuation in case of errors,
+because they do not handle errors.)
+Similarly, when using @Lid{lua_callk},
+you should call the continuation function
+with @Lid{LUA_OK} as the status.
+(For @Lid{lua_yieldk}, there is not much point in calling
+directly the continuation function,
+because @Lid{lua_yieldk} usually does not return.)
+
+Lua treats the continuation function as if it were the original function.
+The continuation function receives the same Lua stack
+from the original function,
+in the same state it would be if the callee function had returned.
+(For instance,
+after a @Lid{lua_callk} the function and its arguments are
+removed from the stack and replaced by the results from the call.)
+It also has the same upvalues.
+Whatever it returns is handled by Lua as if it were the return
+of the original function.
+
+}
+
+@sect2{@title{Functions and Types}
+
+Here we list all functions and types from the @N{C API} in
+alphabetical order.
+Each function has an indicator like this:
+@apii{o,p,x}
+
+The first field, @T{o},
+is how many elements the function pops from the stack.
+The second field, @T{p},
+is how many elements the function pushes onto the stack.
+(Any function always pushes its results after popping its arguments.)
+A field in the form @T{x|y} means the function can push (or pop)
+@T{x} or @T{y} elements,
+depending on the situation;
+an interrogation mark @Char{?} means that
+we cannot know how many elements the function pops/pushes
+by looking only at its arguments
+(e.g., they may depend on what is on the stack).
+The third field, @T{x},
+tells whether the function may raise errors:
+@Char{-} means the function never raises any error;
+@Char{m} means the function may raise out-of-memory errors
+and errors running a @idx{__gc} metamethod;
+@Char{e} means the function may raise any errors
+(it can run arbitrary Lua code,
+either directly or through metamethods);
+@Char{v} means the function may raise an error on purpose.
+
+
+@APIEntry{int lua_absindex (lua_State *L, int idx);|
+@apii{0,0,-}
+
+Converts the @x{acceptable index} @id{idx}
+into an equivalent @x{absolute index}
+(that is, one that does not depend on the stack top).
+
+}
+
+
+@APIEntry{
+typedef void * (*lua_Alloc) (void *ud,
+                             void *ptr,
+                             size_t osize,
+                             size_t nsize);|
+
+The type of the @x{memory-allocation function} used by Lua states.
+The allocator function must provide a
+functionality similar to @id{realloc},
+but not exactly the same.
+Its arguments are
+@id{ud}, an opaque pointer passed to @Lid{lua_newstate};
+@id{ptr}, a pointer to the block being allocated/reallocated/freed;
+@id{osize}, the original size of the block or some code about what
+is being allocated;
+and @id{nsize}, the new size of the block.
+
+When @id{ptr} is not @id{NULL},
+@id{osize} is the size of the block pointed by @id{ptr},
+that is, the size given when it was allocated or reallocated.
+
+When @id{ptr} is @id{NULL},
+@id{osize} encodes the kind of object that Lua is allocating.
+@id{osize} is any of
+@Lid{LUA_TSTRING}, @Lid{LUA_TTABLE}, @Lid{LUA_TFUNCTION},
+@Lid{LUA_TUSERDATA}, or @Lid{LUA_TTHREAD} when (and only when)
+Lua is creating a new object of that type.
+When @id{osize} is some other value,
+Lua is allocating memory for something else.
+
+Lua assumes the following behavior from the allocator function:
+
+When @id{nsize} is zero,
+the allocator must behave like @id{free}
+and return @id{NULL}.
+
+When @id{nsize} is not zero,
+the allocator must behave like @id{realloc}.
+The allocator returns @id{NULL}
+if and only if it cannot fulfill the request.
+Lua assumes that the allocator never fails when
+@T{osize >= nsize}.
+
+Here is a simple implementation for the @x{allocator function}.
+It is used in the auxiliary library by @Lid{luaL_newstate}.
+@verbatim{
+static void *l_alloc (void *ud, void *ptr, size_t osize,
+                                           size_t nsize) {
+  (void)ud;  (void)osize;  /* not used */
+  if (nsize == 0) {
+    free(ptr);
+    return NULL;
+  }
+  else
+    return realloc(ptr, nsize);
+}
+}
+Note that @N{Standard C} ensures
+that @T{free(NULL)} has no effect and that
+@T{realloc(NULL,size)} is equivalent to @T{malloc(size)}.
+This code assumes that @id{realloc} does not fail when shrinking a block.
+(Although @N{Standard C} does not ensure this behavior,
+it seems to be a safe assumption.)
+
+}
+
+@APIEntry{void lua_arith (lua_State *L, int op);|
+@apii{2|1,1,e}
+
+Performs an arithmetic or bitwise operation over the two values
+(or one, in the case of negations)
+at the top of the stack,
+with the value at the top being the second operand,
+pops these values, and pushes the result of the operation.
+The function follows the semantics of the corresponding Lua operator
+(that is, it may call metamethods).
+
+The value of @id{op} must be one of the following constants:
+@description{
+
+@item{@defid{LUA_OPADD}| performs addition (@T{+})}
+@item{@defid{LUA_OPSUB}| performs subtraction (@T{-})}
+@item{@defid{LUA_OPMUL}| performs multiplication (@T{*})}
+@item{@defid{LUA_OPDIV}| performs float division (@T{/})}
+@item{@defid{LUA_OPIDIV}| performs floor division (@T{//})}
+@item{@defid{LUA_OPMOD}| performs modulo (@T{%})}
+@item{@defid{LUA_OPPOW}| performs exponentiation (@T{^})}
+@item{@defid{LUA_OPUNM}| performs mathematical negation (unary @T{-})}
+@item{@defid{LUA_OPBNOT}| performs bitwise NOT (@T{~})}
+@item{@defid{LUA_OPBAND}| performs bitwise AND (@T{&})}
+@item{@defid{LUA_OPBOR}| performs bitwise OR (@T{|})}
+@item{@defid{LUA_OPBXOR}| performs bitwise exclusive OR (@T{~})}
+@item{@defid{LUA_OPSHL}| performs left shift (@T{<<})}
+@item{@defid{LUA_OPSHR}| performs right shift (@T{>>})}
+
+}
+
+}
+
+@APIEntry{lua_CFunction lua_atpanic (lua_State *L, lua_CFunction panicf);|
+@apii{0,0,-}
+
+Sets a new panic function and returns the old one @see{C-error}.
+
+}
+
+@APIEntry{void lua_call (lua_State *L, int nargs, int nresults);|
+@apii{nargs+1,nresults,e}
+
+
+Calls a function.
+
+To call a function you must use the following protocol:
+first, the function to be called is pushed onto the stack;
+then, the arguments to the function are pushed
+in direct order;
+that is, the first argument is pushed first.
+Finally you call @Lid{lua_call};
+@id{nargs} is the number of arguments that you pushed onto the stack.
+All arguments and the function value are popped from the stack
+when the function is called.
+The function results are pushed onto the stack when the function returns.
+The number of results is adjusted to @id{nresults},
+unless @id{nresults} is @defid{LUA_MULTRET}.
+In this case, all results from the function are pushed;
+Lua takes care that the returned values fit into the stack space,
+but it does not ensure any extra space in the stack.
+The function results are pushed onto the stack in direct order
+(the first result is pushed first),
+so that after the call the last result is on the top of the stack.
+
+Any error inside the called function is propagated upwards
+(with a @id{longjmp}).
+
+The following example shows how the host program can do the
+equivalent to this Lua code:
+@verbatim{
+a = f("how", t.x, 14)
+}
+Here it is @N{in C}:
+@verbatim{
+lua_getglobal(L, "f");                  /* function to be called */
+lua_pushliteral(L, "how");                       /* 1st argument */
+lua_getglobal(L, "t");                    /* table to be indexed */
+lua_getfield(L, -1, "x");        /* push result of t.x (2nd arg) */
+lua_remove(L, -2);                  /* remove 't' from the stack */
+lua_pushinteger(L, 14);                          /* 3rd argument */
+lua_call(L, 3, 1);     /* call 'f' with 3 arguments and 1 result */
+lua_setglobal(L, "a");                         /* set global 'a' */
+}
+Note that the code above is @emph{balanced}:
+at its end, the stack is back to its original configuration.
+This is considered good programming practice.
+
+}
+
+@APIEntry{
+void lua_callk (lua_State *L,
+                int nargs,
+                int nresults,
+                lua_KContext ctx,
+                lua_KFunction k);|
+@apii{nargs + 1,nresults,e}
+
+This function behaves exactly like @Lid{lua_call},
+but allows the called function to yield @see{continuations}.
+
+}
+
+@APIEntry{typedef int (*lua_CFunction) (lua_State *L);|
+
+Type for @N{C functions}.
+
+In order to communicate properly with Lua,
+a @N{C function} must use the following protocol,
+which defines the way parameters and results are passed:
+a @N{C function} receives its arguments from Lua in its stack
+in direct order (the first argument is pushed first).
+So, when the function starts,
+@T{lua_gettop(L)} returns the number of arguments received by the function.
+The first argument (if any) is at index 1
+and its last argument is at index @T{lua_gettop(L)}.
+To return values to Lua, a @N{C function} just pushes them onto the stack,
+in direct order (the first result is pushed first),
+and returns the number of results.
+Any other value in the stack below the results will be properly
+discarded by Lua.
+Like a Lua function, a @N{C function} called by Lua can also return
+many results.
+
+As an example, the following function receives a variable number
+of numeric arguments and returns their average and their sum:
+@verbatim{
+static int foo (lua_State *L) {
+  int n = lua_gettop(L);    /* number of arguments */
+  lua_Number sum = 0.0;
+  int i;
+  for (i = 1; i <= n; i++) {
+    if (!lua_isnumber(L, i)) {
+      lua_pushliteral(L, "incorrect argument");
+      lua_error(L);
+    }
+    sum += lua_tonumber(L, i);
+  }
+  lua_pushnumber(L, sum/n);        /* first result */
+  lua_pushnumber(L, sum);         /* second result */
+  return 2;                   /* number of results */
+}
+}
+
+
+
+}
+
+
+@APIEntry{int lua_checkstack (lua_State *L, int n);|
+@apii{0,0,-}
+
+Ensures that the stack has space for at least @id{n} extra slots
+(that is, that you can safely push up to @id{n} values into it).
+It returns false if it cannot fulfill the request,
+either because it would cause the stack
+to be larger than a fixed maximum size
+(typically at least several thousand elements) or
+because it cannot allocate memory for the extra space.
+This function never shrinks the stack;
+if the stack already has space for the extra slots,
+it is left unchanged.
+
+}
+
+@APIEntry{void lua_close (lua_State *L);|
+@apii{0,0,-}
+
+Destroys all objects in the given Lua state
+(calling the corresponding garbage-collection metamethods, if any)
+and frees all dynamic memory used by this state.
+In several platforms, you may not need to call this function,
+because all resources are naturally released when the host program ends.
+On the other hand, long-running programs that create multiple states,
+such as daemons or web servers,
+will probably need to close states as soon as they are not needed.
+
+}
+
+@APIEntry{int lua_compare (lua_State *L, int index1, int index2, int op);|
+@apii{0,0,e}
+
+Compares two Lua values.
+Returns 1 if the value at index @id{index1} satisfies @id{op}
+when compared with the value at index @id{index2},
+following the semantics of the corresponding Lua operator
+(that is, it may call metamethods).
+Otherwise @N{returns 0}.
+Also @N{returns 0} if any of the indices is not valid.
+
+The value of @id{op} must be one of the following constants:
+@description{
+
+@item{@defid{LUA_OPEQ}| compares for equality (@T{==})}
+@item{@defid{LUA_OPLT}| compares for less than (@T{<})}
+@item{@defid{LUA_OPLE}| compares for less or equal (@T{<=})}
+
+}
+
+}
+
+@APIEntry{void lua_concat (lua_State *L, int n);|
+@apii{n,1,e}
+
+Concatenates the @id{n} values at the top of the stack,
+pops them, and leaves the result at the top.
+If @N{@T{n} is 1}, the result is the single value on the stack
+(that is, the function does nothing);
+if @id{n} is 0, the result is the empty string.
+Concatenation is performed following the usual semantics of Lua
+@see{concat}.
+
+}
+
+@APIEntry{void lua_copy (lua_State *L, int fromidx, int toidx);|
+@apii{0,0,-}
+
+Copies the element at index @id{fromidx}
+into the valid index @id{toidx},
+replacing the value at that position.
+Values at other positions are not affected.
+
+}
+
+@APIEntry{void lua_createtable (lua_State *L, int narr, int nrec);|
+@apii{0,1,m}
+
+Creates a new empty table and pushes it onto the stack.
+Parameter @id{narr} is a hint for how many elements the table
+will have as a sequence;
+parameter @id{nrec} is a hint for how many other elements
+the table will have.
+Lua may use these hints to preallocate memory for the new table.
+This preallocation is useful for performance when you know in advance
+how many elements the table will have.
+Otherwise you can use the function @Lid{lua_newtable}.
+
+}
+
+@APIEntry{int lua_dump (lua_State *L,
+                        lua_Writer writer,
+                        void *data,
+                        int strip);|
+@apii{0,0,-}
+
+Dumps a function as a binary chunk.
+Receives a Lua function on the top of the stack
+and produces a binary chunk that,
+if loaded again,
+results in a function equivalent to the one dumped.
+As it produces parts of the chunk,
+@Lid{lua_dump} calls function @id{writer} @seeC{lua_Writer}
+with the given @id{data}
+to write them.
+
+If @id{strip} is true,
+the binary representation may not include all debug information
+about the function,
+to save space.
+
+The value returned is the error code returned by the last
+call to the writer;
+@N{0 means} no errors.
+
+This function does not pop the Lua function from the stack.
+
+}
+
+@APIEntry{int lua_error (lua_State *L);|
+@apii{1,0,v}
+
+Generates a Lua error,
+using the value at the top of the stack as the error object.
+This function does a long jump,
+and therefore never returns
+@seeC{luaL_error}.
+
+}
+
+@APIEntry{int lua_gc (lua_State *L, int what, int data);|
+@apii{0,0,m}
+
+Controls the garbage collector.
+
+This function performs several tasks,
+according to the value of the parameter @id{what}:
+@description{
+
+@item{@id{LUA_GCSTOP}|
+stops the garbage collector.
+}
+
+@item{@id{LUA_GCRESTART}|
+restarts the garbage collector.
+}
+
+@item{@id{LUA_GCCOLLECT}|
+performs a full garbage-collection cycle.
+}
+
+@item{@id{LUA_GCCOUNT}|
+returns the current amount of memory (in Kbytes) in use by Lua.
+}
+
+@item{@id{LUA_GCCOUNTB}|
+returns the remainder of dividing the current amount of bytes of
+memory in use by Lua by 1024.
+}
+
+@item{@id{LUA_GCSTEP}|
+performs an incremental step of garbage collection.
+}
+
+@item{@id{LUA_GCSETPAUSE}|
+sets @id{data} as the new value
+for the @emph{pause} of the collector @see{GC}
+and returns the previous value of the pause.
+}
+
+@item{@id{LUA_GCSETSTEPMUL}|
+sets @id{data} as the new value for the @emph{step multiplier} of
+the collector @see{GC}
+and returns the previous value of the step multiplier.
+}
+
+@item{@id{LUA_GCISRUNNING}|
+returns a boolean that tells whether the collector is running
+(i.e., not stopped).
+}
+
+}
+
+For more details about these options,
+see @Lid{collectgarbage}.
+
+}
+
+@APIEntry{lua_Alloc lua_getallocf (lua_State *L, void **ud);|
+@apii{0,0,-}
+
+Returns the @x{memory-allocation function} of a given state.
+If @id{ud} is not @id{NULL}, Lua stores in @T{*ud} the
+opaque pointer given when the memory-allocator function was set.
+
+}
+
+@APIEntry{int lua_getfield (lua_State *L, int index, const char *k);|
+@apii{0,1,e}
+
+Pushes onto the stack the value @T{t[k]},
+where @id{t} is the value at the given index.
+As in Lua, this function may trigger a metamethod
+for the @Q{index} event @see{metatable}.
+
+Returns the type of the pushed value.
+
+}
+
+@APIEntry{void *lua_getextraspace (lua_State *L);|
+@apii{0,0,-}
+
+Returns a pointer to a raw memory area associated with the
+given Lua state.
+The application can use this area for any purpose;
+Lua does not use it for anything.
+
+Each new thread has this area initialized with a copy
+of the area of the @x{main thread}.
+
+By default, this area has the size of a pointer to void,
+but you can recompile Lua with a different size for this area.
+(See @id{LUA_EXTRASPACE} in @id{luaconf.h}.)
+
+}
+
+@APIEntry{int lua_getglobal (lua_State *L, const char *name);|
+@apii{0,1,e}
+
+Pushes onto the stack the value of the global @id{name}.
+Returns the type of that value.
+
+}
+
+@APIEntry{int lua_geti (lua_State *L, int index, lua_Integer i);|
+@apii{0,1,e}
+
+Pushes onto the stack the value @T{t[i]},
+where @id{t} is the value at the given index.
+As in Lua, this function may trigger a metamethod
+for the @Q{index} event @see{metatable}.
+
+Returns the type of the pushed value.
+
+}
+
+@APIEntry{int lua_getmetatable (lua_State *L, int index);|
+@apii{0,0|1,-}
+
+If the value at the given index has a metatable,
+the function pushes that metatable onto the stack and @N{returns 1}.
+Otherwise,
+the function @N{returns 0} and pushes nothing on the stack.
+
+}
+
+@APIEntry{int lua_gettable (lua_State *L, int index);|
+@apii{1,1,e}
+
+Pushes onto the stack the value @T{t[k]},
+where @id{t} is the value at the given index
+and @id{k} is the value at the top of the stack.
+
+This function pops the key from the stack,
+pushing the resulting value in its place.
+As in Lua, this function may trigger a metamethod
+for the @Q{index} event @see{metatable}.
+
+Returns the type of the pushed value.
+
+}
+
+@APIEntry{int lua_gettop (lua_State *L);|
+@apii{0,0,-}
+
+Returns the index of the top element in the stack.
+Because indices start @N{at 1},
+this result is equal to the number of elements in the stack;
+in particular, @N{0 means} an empty stack.
+
+}
+
+@APIEntry{int lua_getuservalue (lua_State *L, int index);|
+@apii{0,1,-}
+
+Pushes onto the stack the Lua value associated with the full userdata
+at the given index.
+
+Returns the type of the pushed value.
+
+}
+
+@APIEntry{void lua_insert (lua_State *L, int index);|
+@apii{1,1,-}
+
+Moves the top element into the given valid index,
+shifting up the elements above this index to open space.
+This function cannot be called with a pseudo-index,
+because a pseudo-index is not an actual stack position.
+
+}
+
+@APIEntry{typedef @ldots lua_Integer;|
+
+The type of integers in Lua.
+
+By default this type is @id{long long},
+(usually a 64-bit two-complement integer),
+but that can be changed to @id{long} or @id{int}
+(usually a 32-bit two-complement integer).
+(See @id{LUA_INT_TYPE} in @id{luaconf.h}.)
+
+Lua also defines the constants
+@defid{LUA_MININTEGER} and @defid{LUA_MAXINTEGER},
+with the minimum and the maximum values that fit in this type.
+
+}
+
+@APIEntry{int lua_isboolean (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the value at the given index is a boolean,
+and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_iscfunction (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the value at the given index is a @N{C function},
+and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_isfunction (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the value at the given index is a function
+(either C or Lua), and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_isinteger (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the value at the given index is an integer
+(that is, the value is a number and is represented as an integer),
+and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_islightuserdata (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the value at the given index is a light userdata,
+and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_isnil (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the value at the given index is @nil,
+and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_isnone (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the given index is not valid,
+and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_isnoneornil (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the given index is not valid
+or if the value at this index is @nil,
+and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_isnumber (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the value at the given index is a number
+or a string convertible to a number,
+and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_isstring (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the value at the given index is a string
+or a number (which is always convertible to a string),
+and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_istable (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the value at the given index is a table,
+and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_isthread (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the value at the given index is a thread,
+and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_isuserdata (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns 1 if the value at the given index is a userdata
+(either full or light), and @N{0 otherwise}.
+
+}
+
+@APIEntry{int lua_isyieldable (lua_State *L);|
+@apii{0,0,-}
+
+Returns 1 if the given coroutine can yield,
+and @N{0 otherwise}.
+
+}
+
+@APIEntry{typedef @ldots lua_KContext;|
+
+The type for continuation-function contexts.
+It must be a numeric type.
+This type is defined as @id{intptr_t}
+when @id{intptr_t} is available,
+so that it can store pointers too.
+Otherwise, it is defined as @id{ptrdiff_t}.
+
+}
+
+@APIEntry{
+typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx);|
+
+Type for continuation functions @see{continuations}.
+
+}
+
+@APIEntry{void lua_len (lua_State *L, int index);|
+@apii{0,1,e}
+
+Returns the length of the value at the given index.
+It is equivalent to the @Char{#} operator in Lua @see{len-op} and
+may trigger a metamethod for the @Q{length} event @see{metatable}.
+The result is pushed on the stack.
+
+}
+
+@APIEntry{
+int lua_load (lua_State *L,
+              lua_Reader reader,
+              void *data,
+              const char *chunkname,
+              const char *mode);|
+@apii{0,1,-}
+
+Loads a Lua chunk without running it.
+If there are no errors,
+@id{lua_load} pushes the compiled chunk as a Lua
+function on top of the stack.
+Otherwise, it pushes an error message.
+
+The return values of @id{lua_load} are:
+@description{
+
+@item{@Lid{LUA_OK}| no errors;}
+
+@item{@defid{LUA_ERRSYNTAX}|
+syntax error during precompilation;}
+
+@item{@Lid{LUA_ERRMEM}|
+@x{memory allocation (out-of-memory) error};}
+
+@item{@Lid{LUA_ERRGCMM}|
+error while running a @idx{__gc} metamethod.
+(This error has no relation with the chunk being loaded.
+It is generated by the garbage collector.)
+}
+
+}
+
+The @id{lua_load} function uses a user-supplied @id{reader} function
+to read the chunk @seeC{lua_Reader}.
+The @id{data} argument is an opaque value passed to the reader function.
+
+The @id{chunkname} argument gives a name to the chunk,
+which is used for error messages and in debug information @see{debugI}.
+
+@id{lua_load} automatically detects whether the chunk is text or binary
+and loads it accordingly (see program @idx{luac}).
+The string @id{mode} works as in function @Lid{load},
+with the addition that
+a @id{NULL} value is equivalent to the string @St{bt}.
+
+@id{lua_load} uses the stack internally,
+so the reader function must always leave the stack
+unmodified when returning.
+
+If the resulting function has upvalues,
+its first upvalue is set to the value of the @x{global environment}
+stored at index @id{LUA_RIDX_GLOBALS} in the registry @see{registry}.
+When loading main chunks,
+this upvalue will be the @id{_ENV} variable @see{globalenv}.
+Other upvalues are initialized with @nil.
+
+}
+
+@APIEntry{lua_State *lua_newstate (lua_Alloc f, void *ud);|
+@apii{0,0,-}
+
+Creates a new thread running in a new, independent state.
+Returns @id{NULL} if it cannot create the thread or the state
+(due to lack of memory).
+The argument @id{f} is the @x{allocator function};
+Lua does all memory allocation for this state
+through this function @seeF{lua_Alloc}.
+The second argument, @id{ud}, is an opaque pointer that Lua
+passes to the allocator in every call.
+
+}
+
+@APIEntry{void lua_newtable (lua_State *L);|
+@apii{0,1,m}
+
+Creates a new empty table and pushes it onto the stack.
+It is equivalent to @T{lua_createtable(L, 0, 0)}.
+
+}
+
+@APIEntry{lua_State *lua_newthread (lua_State *L);|
+@apii{0,1,m}
+
+Creates a new thread, pushes it on the stack,
+and returns a pointer to a @Lid{lua_State} that represents this new thread.
+The new thread returned by this function shares with the original thread
+its global environment,
+but has an independent execution stack.
+
+There is no explicit function to close or to destroy a thread.
+Threads are subject to garbage collection,
+like any Lua object.
+
+}
+
+@APIEntry{void *lua_newuserdata (lua_State *L, size_t size);|
+@apii{0,1,m}
+
+This function allocates a new block of memory with the given size,
+pushes onto the stack a new full userdata with the block address,
+and returns this address.
+The host program can freely use this memory.
+
+}
+
+@APIEntry{int lua_next (lua_State *L, int index);|
+@apii{1,2|0,e}
+
+Pops a key from the stack,
+and pushes a key@En{}value pair from the table at the given index
+(the @Q{next} pair after the given key).
+If there are no more elements in the table,
+then @Lid{lua_next} returns 0 (and pushes nothing).
+
+A typical traversal looks like this:
+@verbatim{
+/* table is in the stack at index 't' */
+lua_pushnil(L);  /* first key */
+while (lua_next(L, t) != 0) {
+  /* uses 'key' (at index -2) and 'value' (at index -1) */
+  printf("%s - %s\n",
+         lua_typename(L, lua_type(L, -2)),
+         lua_typename(L, lua_type(L, -1)));
+  /* removes 'value'; keeps 'key' for next iteration */
+  lua_pop(L, 1);
+}
+}
+
+While traversing a table,
+do not call @Lid{lua_tolstring} directly on a key,
+unless you know that the key is actually a string.
+Recall that @Lid{lua_tolstring} may change
+the value at the given index;
+this confuses the next call to @Lid{lua_next}.
+
+See function @Lid{next} for the caveats of modifying
+the table during its traversal.
+
+}
+
+@APIEntry{typedef @ldots lua_Number;|
+
+The type of floats in Lua.
+
+By default this type is double,
+but that can be changed to a single float or a long double.
+(See @id{LUA_FLOAT_TYPE} in @id{luaconf.h}.)
+
+}
+
+@APIEntry{int lua_numbertointeger (lua_Number n, lua_Integer *p);|
+
+Converts a Lua float to a Lua integer.
+This macro assumes that @id{n} has an integral value.
+If that value is within the range of Lua integers,
+it is converted to an integer and assigned to @T{*p}.
+The macro results in a boolean indicating whether the
+conversion was successful.
+(Note that this range test can be tricky to do
+correctly without this macro,
+due to roundings.)
+
+This macro may evaluate its arguments more than once.
+
+}
+
+@APIEntry{int lua_pcall (lua_State *L, int nargs, int nresults, int msgh);|
+@apii{nargs + 1,nresults|1,-}
+
+Calls a function in protected mode.
+
+Both @id{nargs} and @id{nresults} have the same meaning as
+in @Lid{lua_call}.
+If there are no errors during the call,
+@Lid{lua_pcall} behaves exactly like @Lid{lua_call}.
+However, if there is any error,
+@Lid{lua_pcall} catches it,
+pushes a single value on the stack (the error object),
+and returns an error code.
+Like @Lid{lua_call},
+@Lid{lua_pcall} always removes the function
+and its arguments from the stack.
+
+If @id{msgh} is 0,
+then the error object returned on the stack
+is exactly the original error object.
+Otherwise, @id{msgh} is the stack index of a
+@emph{message handler}.
+(This index cannot be a pseudo-index.)
+In case of runtime errors,
+this function will be called with the error object
+and its return value will be the object
+returned on the stack by @Lid{lua_pcall}.
+
+Typically, the message handler is used to add more debug
+information to the error object, such as a stack traceback.
+Such information cannot be gathered after the return of @Lid{lua_pcall},
+since by then the stack has unwound.
+
+The @Lid{lua_pcall} function returns one of the following constants
+(defined in @id{lua.h}):
+@description{
+
+@item{@defid{LUA_OK} (0)|
+success.}
+
+@item{@defid{LUA_ERRRUN}|
+a runtime error.
+}
+
+@item{@defid{LUA_ERRMEM}|
+@x{memory allocation error}.
+For such errors, Lua does not call the @x{message handler}.
+}
+
+@item{@defid{LUA_ERRERR}|
+error while running the @x{message handler}.
+}
+
+@item{@defid{LUA_ERRGCMM}|
+error while running a @idx{__gc} metamethod.
+For such errors, Lua does not call the @x{message handler}
+(as this kind of error typically has no relation
+with the function being called).
+}
+
+}
+
+}
+
+@APIEntry{
+int lua_pcallk (lua_State *L,
+                int nargs,
+                int nresults,
+                int msgh,
+                lua_KContext ctx,
+                lua_KFunction k);|
+@apii{nargs + 1,nresults|1,-}
+
+This function behaves exactly like @Lid{lua_pcall},
+but allows the called function to yield @see{continuations}.
+
+}
+
+@APIEntry{void lua_pop (lua_State *L, int n);|
+@apii{n,0,-}
+
+Pops @id{n} elements from the stack.
+
+}
+
+@APIEntry{void lua_pushboolean (lua_State *L, int b);|
+@apii{0,1,-}
+
+Pushes a boolean value with value @id{b} onto the stack.
+
+}
+
+@APIEntry{void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n);|
+@apii{n,1,m}
+
+Pushes a new @N{C closure} onto the stack.
+
+When a @N{C function} is created,
+it is possible to associate some values with it,
+thus creating a @x{@N{C closure}} @see{c-closure};
+these values are then accessible to the function whenever it is called.
+To associate values with a @N{C function},
+first these values must be pushed onto the stack
+(when there are multiple values, the first value is pushed first).
+Then @Lid{lua_pushcclosure}
+is called to create and push the @N{C function} onto the stack,
+with the argument @id{n} telling how many values will be
+associated with the function.
+@Lid{lua_pushcclosure} also pops these values from the stack.
+
+The maximum value for @id{n} is 255.
+
+When @id{n} is zero,
+this function creates a @def{light @N{C function}},
+which is just a pointer to the @N{C function}.
+In that case, it never raises a memory error.
+
+}
+
+@APIEntry{void lua_pushcfunction (lua_State *L, lua_CFunction f);|
+@apii{0,1,-}
+
+Pushes a @N{C function} onto the stack.
+This function receives a pointer to a @N{C function}
+and pushes onto the stack a Lua value of type @id{function} that,
+when called, invokes the corresponding @N{C function}.
+
+Any function to be callable by Lua must
+follow the correct protocol to receive its parameters
+and return its results @seeC{lua_CFunction}.
+
+}
+
+@APIEntry{const char *lua_pushfstring (lua_State *L, const char *fmt, ...);|
+@apii{0,1,e}
+
+Pushes onto the stack a formatted string
+and returns a pointer to this string.
+It is similar to the @ANSI{sprintf},
+but has some important differences:
+@itemize{
+
+@item{
+You do not have to allocate space for the result:
+the result is a Lua string and Lua takes care of memory allocation
+(and deallocation, through garbage collection).
+}
+
+@item{
+The conversion specifiers are quite restricted.
+There are no flags, widths, or precisions.
+The conversion specifiers can only be
+@Char{%%} (inserts the character @Char{%}),
+@Char{%s} (inserts a zero-terminated string, with no size restrictions),
+@Char{%f} (inserts a @Lid{lua_Number}),
+@Char{%I} (inserts a @Lid{lua_Integer}),
+@Char{%p} (inserts a pointer as a hexadecimal numeral),
+@Char{%d} (inserts an @T{int}),
+@Char{%c} (inserts an @T{int} as a one-byte character), and
+@Char{%U} (inserts a @T{long int} as a @x{UTF-8} byte sequence).
+}
+
+}
+
+Unlike other push functions,
+this function checks for the stack space it needs,
+including the slot for its result.
+
+}
+
+@APIEntry{void lua_pushglobaltable (lua_State *L);|
+@apii{0,1,-}
+
+Pushes the @x{global environment} onto the stack.
+
+}
+
+@APIEntry{void lua_pushinteger (lua_State *L, lua_Integer n);|
+@apii{0,1,-}
+
+Pushes an integer with value @id{n} onto the stack.
+
+}
+
+@APIEntry{void lua_pushlightuserdata (lua_State *L, void *p);|
+@apii{0,1,-}
+
+Pushes a light userdata onto the stack.
+
+Userdata represent @N{C values} in Lua.
+A @def{light userdata} represents a pointer, a @T{void*}.
+It is a value (like a number):
+you do not create it, it has no individual metatable,
+and it is not collected (as it was never created).
+A light userdata is equal to @Q{any}
+light userdata with the same @N{C address}.
+
+}
+
+@APIEntry{const char *lua_pushliteral (lua_State *L, const char *s);|
+@apii{0,1,m}
+
+This macro is equivalent to @Lid{lua_pushstring},
+but should be used only when @id{s} is a literal string.
+
+}
+
+@APIEntry{const char *lua_pushlstring (lua_State *L, const char *s, size_t len);|
+@apii{0,1,m}
+
+Pushes the string pointed to by @id{s} with size @id{len}
+onto the stack.
+Lua makes (or reuses) an internal copy of the given string,
+so the memory at @id{s} can be freed or reused immediately after
+the function returns.
+The string can contain any binary data,
+including @x{embedded zeros}.
+
+Returns a pointer to the internal copy of the string.
+
+}
+
+@APIEntry{void lua_pushnil (lua_State *L);|
+@apii{0,1,-}
+
+Pushes a nil value onto the stack.
+
+}
+
+@APIEntry{void lua_pushnumber (lua_State *L, lua_Number n);|
+@apii{0,1,-}
+
+Pushes a float with value @id{n} onto the stack.
+
+}
+
+@APIEntry{const char *lua_pushstring (lua_State *L, const char *s);|
+@apii{0,1,m}
+
+Pushes the zero-terminated string pointed to by @id{s}
+onto the stack.
+Lua makes (or reuses) an internal copy of the given string,
+so the memory at @id{s} can be freed or reused immediately after
+the function returns.
+
+Returns a pointer to the internal copy of the string.
+
+If @id{s} is @id{NULL}, pushes @nil and returns @id{NULL}.
+
+}
+
+@APIEntry{int lua_pushthread (lua_State *L);|
+@apii{0,1,-}
+
+Pushes the thread represented by @id{L} onto the stack.
+Returns 1 if this thread is the @x{main thread} of its state.
+
+}
+
+@APIEntry{void lua_pushvalue (lua_State *L, int index);|
+@apii{0,1,-}
+
+Pushes a copy of the element at the given index
+onto the stack.
+
+}
+
+@APIEntry{
+const char *lua_pushvfstring (lua_State *L,
+                              const char *fmt,
+                              va_list argp);|
+@apii{0,1,m}
+
+Equivalent to @Lid{lua_pushfstring}, except that it receives a @id{va_list}
+instead of a variable number of arguments.
+
+}
+
+@APIEntry{int lua_rawequal (lua_State *L, int index1, int index2);|
+@apii{0,0,-}
+
+Returns 1 if the two values in indices @id{index1} and
+@id{index2} are primitively equal
+(that is, without calling the @idx{__eq} metamethod).
+Otherwise @N{returns 0}.
+Also @N{returns 0} if any of the indices are not valid.
+
+}
+
+@APIEntry{int lua_rawget (lua_State *L, int index);|
+@apii{1,1,-}
+
+Similar to @Lid{lua_gettable}, but does a raw access
+(i.e., without metamethods).
+
+}
+
+@APIEntry{int lua_rawgeti (lua_State *L, int index, lua_Integer n);|
+@apii{0,1,-}
+
+Pushes onto the stack the value @T{t[n]},
+where @id{t} is the table at the given index.
+The access is raw,
+that is, it does not invoke the @idx{__index} metamethod.
+
+Returns the type of the pushed value.
+
+}
+
+@APIEntry{int lua_rawgetp (lua_State *L, int index, const void *p);|
+@apii{0,1,-}
+
+Pushes onto the stack the value @T{t[k]},
+where @id{t} is the table at the given index and
+@id{k} is the pointer @id{p} represented as a light userdata.
+The access is raw;
+that is, it does not invoke the @idx{__index} metamethod.
+
+Returns the type of the pushed value.
+
+}
+
+@APIEntry{size_t lua_rawlen (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns the raw @Q{length} of the value at the given index:
+for strings, this is the string length;
+for tables, this is the result of the length operator (@Char{#})
+with no metamethods;
+for userdata, this is the size of the block of memory allocated
+for the userdata;
+for other values, it @N{is 0}.
+
+}
+
+@APIEntry{void lua_rawset (lua_State *L, int index);|
+@apii{2,0,m}
+
+Similar to @Lid{lua_settable}, but does a raw assignment
+(i.e., without metamethods).
+
+}
+
+@APIEntry{void lua_rawseti (lua_State *L, int index, lua_Integer i);|
+@apii{1,0,m}
+
+Does the equivalent of @T{t[i] = v},
+where @id{t} is the table at the given index
+and @id{v} is the value at the top of the stack.
+
+This function pops the value from the stack.
+The assignment is raw,
+that is, it does not invoke the @idx{__newindex} metamethod.
+
+}
+
+@APIEntry{void lua_rawsetp (lua_State *L, int index, const void *p);|
+@apii{1,0,m}
+
+Does the equivalent of @T{t[p] = v},
+where @id{t} is the table at the given index,
+@id{p} is encoded as a light userdata,
+and @id{v} is the value at the top of the stack.
+
+This function pops the value from the stack.
+The assignment is raw,
+that is, it does not invoke @idx{__newindex} metamethod.
+
+}
+
+@APIEntry{
+typedef const char * (*lua_Reader) (lua_State *L,
+                                    void *data,
+                                    size_t *size);|
+
+The reader function used by @Lid{lua_load}.
+Every time it needs another piece of the chunk,
+@Lid{lua_load} calls the reader,
+passing along its @id{data} parameter.
+The reader must return a pointer to a block of memory
+with a new piece of the chunk
+and set @id{size} to the block size.
+The block must exist until the reader function is called again.
+To signal the end of the chunk,
+the reader must return @id{NULL} or set @id{size} to zero.
+The reader function may return pieces of any size greater than zero.
+
+}
+
+@APIEntry{void lua_register (lua_State *L, const char *name, lua_CFunction f);|
+@apii{0,0,e}
+
+Sets the @N{C function} @id{f} as the new value of global @id{name}.
+It is defined as a macro:
+@verbatim{
+#define lua_register(L,n,f) \
+       (lua_pushcfunction(L, f), lua_setglobal(L, n))
+}
+
+}
+
+@APIEntry{void lua_remove (lua_State *L, int index);|
+@apii{1,0,-}
+
+Removes the element at the given valid index,
+shifting down the elements above this index to fill the gap.
+This function cannot be called with a pseudo-index,
+because a pseudo-index is not an actual stack position.
+
+}
+
+@APIEntry{void lua_replace (lua_State *L, int index);|
+@apii{1,0,-}
+
+Moves the top element into the given valid index
+without shifting any element
+(therefore replacing the value at that given index),
+and then pops the top element.
+
+}
+
+@APIEntry{int lua_resume (lua_State *L, lua_State *from, int nargs);|
+@apii{?,?,-}
+
+Starts and resumes a coroutine in the given thread @id{L}.
+
+To start a coroutine,
+you push onto the thread stack the main function plus any arguments;
+then you call @Lid{lua_resume},
+with @id{nargs} being the number of arguments.
+This call returns when the coroutine suspends or finishes its execution.
+When it returns, the stack contains all values passed to @Lid{lua_yield},
+or all values returned by the body function.
+@Lid{lua_resume} returns
+@Lid{LUA_YIELD} if the coroutine yields,
+@Lid{LUA_OK} if the coroutine finishes its execution
+without errors,
+or an error code in case of errors @seeC{lua_pcall}.
+
+In case of errors,
+the stack is not unwound,
+so you can use the debug API over it.
+The error object is on the top of the stack.
+
+To resume a coroutine,
+you remove any results from the last @Lid{lua_yield},
+put on its stack only the values to
+be passed as results from @id{yield},
+and then call @Lid{lua_resume}.
+
+The parameter @id{from} represents the coroutine that is resuming @id{L}.
+If there is no such coroutine,
+this parameter can be @id{NULL}.
+
+}
+
+@APIEntry{void lua_rotate (lua_State *L, int idx, int n);|
+@apii{0,0,-}
+
+Rotates the stack elements between the valid index @id{idx}
+and the top of the stack.
+The elements are rotated @id{n} positions in the direction of the top,
+for a positive @id{n},
+or @T{-n} positions in the direction of the bottom,
+for a negative @id{n}.
+The absolute value of @id{n} must not be greater than the size
+of the slice being rotated.
+This function cannot be called with a pseudo-index,
+because a pseudo-index is not an actual stack position.
+
+}
+
+@APIEntry{void lua_setallocf (lua_State *L, lua_Alloc f, void *ud);|
+@apii{0,0,-}
+
+Changes the @x{allocator function} of a given state to @id{f}
+with user data @id{ud}.
+
+}
+
+@APIEntry{void lua_setfield (lua_State *L, int index, const char *k);|
+@apii{1,0,e}
+
+Does the equivalent to @T{t[k] = v},
+where @id{t} is the value at the given index
+and @id{v} is the value at the top of the stack.
+
+This function pops the value from the stack.
+As in Lua, this function may trigger a metamethod
+for the @Q{newindex} event @see{metatable}.
+
+}
+
+@APIEntry{void lua_setglobal (lua_State *L, const char *name);|
+@apii{1,0,e}
+
+Pops a value from the stack and
+sets it as the new value of global @id{name}.
+
+}
+
+@APIEntry{void lua_seti (lua_State *L, int index, lua_Integer n);|
+@apii{1,0,e}
+
+Does the equivalent to @T{t[n] = v},
+where @id{t} is the value at the given index
+and @id{v} is the value at the top of the stack.
+
+This function pops the value from the stack.
+As in Lua, this function may trigger a metamethod
+for the @Q{newindex} event @see{metatable}.
+
+}
+
+@APIEntry{void lua_setmetatable (lua_State *L, int index);|
+@apii{1,0,-}
+
+Pops a table from the stack and
+sets it as the new metatable for the value at the given index.
+
+}
+
+@APIEntry{void lua_settable (lua_State *L, int index);|
+@apii{2,0,e}
+
+Does the equivalent to @T{t[k] = v},
+where @id{t} is the value at the given index,
+@id{v} is the value at the top of the stack,
+and @id{k} is the value just below the top.
+
+This function pops both the key and the value from the stack.
+As in Lua, this function may trigger a metamethod
+for the @Q{newindex} event @see{metatable}.
+
+}
+
+@APIEntry{void lua_settop (lua_State *L, int index);|
+@apii{?,?,-}
+
+Accepts any index, @N{or 0},
+and sets the stack top to this index.
+If the new top is larger than the old one,
+then the new elements are filled with @nil.
+If @id{index} @N{is 0}, then all stack elements are removed.
+
+}
+
+@APIEntry{void lua_setuservalue (lua_State *L, int index);|
+@apii{1,0,-}
+
+Pops a value from the stack and sets it as
+the new value associated to the full userdata at the given index.
+
+}
+
+@APIEntry{typedef struct lua_State lua_State;|
+
+An opaque structure that points to a thread and indirectly
+(through the thread) to the whole state of a Lua interpreter.
+The Lua library is fully reentrant:
+it has no global variables.
+All information about a state is accessible through this structure.
+
+A pointer to this structure must be passed as the first argument to
+every function in the library, except to @Lid{lua_newstate},
+which creates a Lua state from scratch.
+
+}
+
+@APIEntry{int lua_status (lua_State *L);|
+@apii{0,0,-}
+
+Returns the status of the thread @id{L}.
+
+The status can be 0 (@Lid{LUA_OK}) for a normal thread,
+an error code if the thread finished the execution
+of a @Lid{lua_resume} with an error,
+or @defid{LUA_YIELD} if the thread is suspended.
+
+You can only call functions in threads with status @Lid{LUA_OK}.
+You can resume threads with status @Lid{LUA_OK}
+(to start a new coroutine) or @Lid{LUA_YIELD}
+(to resume a coroutine).
+
+}
+
+@APIEntry{size_t lua_stringtonumber (lua_State *L, const char *s);|
+@apii{0,1,-}
+
+Converts the zero-terminated string @id{s} to a number,
+pushes that number into the stack,
+and returns the total size of the string,
+that is, its length plus one.
+The conversion can result in an integer or a float,
+according to the lexical conventions of Lua @see{lexical}.
+The string may have leading and trailing spaces and a sign.
+If the string is not a valid numeral,
+returns 0 and pushes nothing.
+(Note that the result can be used as a boolean,
+true if the conversion succeeds.)
+
+}
+
+@APIEntry{int lua_toboolean (lua_State *L, int index);|
+@apii{0,0,-}
+
+Converts the Lua value at the given index to a @N{C boolean}
+value (@N{0 or 1}).
+Like all tests in Lua,
+@Lid{lua_toboolean} returns true for any Lua value
+different from @false and @nil;
+otherwise it returns false.
+(If you want to accept only actual boolean values,
+use @Lid{lua_isboolean} to test the value's type.)
+
+}
+
+@APIEntry{lua_CFunction lua_tocfunction (lua_State *L, int index);|
+@apii{0,0,-}
+
+Converts a value at the given index to a @N{C function}.
+That value must be a @N{C function};
+otherwise, returns @id{NULL}.
+
+}
+
+@APIEntry{lua_Integer lua_tointeger (lua_State *L, int index);|
+@apii{0,0,-}
+
+Equivalent to @Lid{lua_tointegerx} with @id{isnum} equal to @id{NULL}.
+
+}
+
+@APIEntry{lua_Integer lua_tointegerx (lua_State *L, int index, int *isnum);|
+@apii{0,0,-}
+
+Converts the Lua value at the given index
+to the signed integral type @Lid{lua_Integer}.
+The Lua value must be an integer,
+or a number or string convertible to an integer @see{coercion};
+otherwise, @id{lua_tointegerx} @N{returns 0}.
+
+If @id{isnum} is not @id{NULL},
+its referent is assigned a boolean value that
+indicates whether the operation succeeded.
+
+}
+
+@APIEntry{const char *lua_tolstring (lua_State *L, int index, size_t *len);|
+@apii{0,0,m}
+
+Converts the Lua value at the given index to a @N{C string}.
+If @id{len} is not @id{NULL},
+it sets @T{*len} with the string length.
+The Lua value must be a string or a number;
+otherwise, the function returns @id{NULL}.
+If the value is a number,
+then @id{lua_tolstring} also
+@emph{changes the actual value in the stack to a string}.
+(This change confuses @Lid{lua_next}
+when @id{lua_tolstring} is applied to keys during a table traversal.)
+
+@id{lua_tolstring} returns a pointer
+to a string inside the Lua state.
+This string always has a zero (@Char{\0})
+after its last character (as @N{in C}),
+but can contain other zeros in its body.
+
+Because Lua has garbage collection,
+there is no guarantee that the pointer returned by @id{lua_tolstring}
+will be valid after the corresponding Lua value is removed from the stack.
+
+}
+
+@APIEntry{lua_Number lua_tonumber (lua_State *L, int index);|
+@apii{0,0,-}
+
+Equivalent to @Lid{lua_tonumberx} with @id{isnum} equal to @id{NULL}.
+
+}
+
+@APIEntry{lua_Number lua_tonumberx (lua_State *L, int index, int *isnum);|
+@apii{0,0,-}
+
+Converts the Lua value at the given index
+to the @N{C type} @Lid{lua_Number} @seeC{lua_Number}.
+The Lua value must be a number or a string convertible to a number
+@see{coercion};
+otherwise, @Lid{lua_tonumberx} @N{returns 0}.
+
+If @id{isnum} is not @id{NULL},
+its referent is assigned a boolean value that
+indicates whether the operation succeeded.
+
+}
+
+@APIEntry{const void *lua_topointer (lua_State *L, int index);|
+@apii{0,0,-}
+
+Converts the value at the given index to a generic
+@N{C pointer} (@T{void*}).
+The value can be a userdata, a table, a thread, or a function;
+otherwise, @id{lua_topointer} returns @id{NULL}.
+Different objects will give different pointers.
+There is no way to convert the pointer back to its original value.
+
+Typically this function is used only for hashing and debug information.
+
+}
+
+@APIEntry{const char *lua_tostring (lua_State *L, int index);|
+@apii{0,0,m}
+
+Equivalent to @Lid{lua_tolstring} with @id{len} equal to @id{NULL}.
+
+}
+
+@APIEntry{lua_State *lua_tothread (lua_State *L, int index);|
+@apii{0,0,-}
+
+Converts the value at the given index to a Lua thread
+(represented as @T{lua_State*}).
+This value must be a thread;
+otherwise, the function returns @id{NULL}.
+
+}
+
+@APIEntry{void *lua_touserdata (lua_State *L, int index);|
+@apii{0,0,-}
+
+If the value at the given index is a full userdata,
+returns its block address.
+If the value is a light userdata,
+returns its pointer.
+Otherwise, returns @id{NULL}.
+
+}
+
+@APIEntry{int lua_type (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns the type of the value in the given valid index,
+or @id{LUA_TNONE} for a non-valid (but acceptable) index.
+The types returned by @Lid{lua_type} are coded by the following constants
+defined in @id{lua.h}:
+@defid{LUA_TNIL} (0),
+@defid{LUA_TNUMBER},
+@defid{LUA_TBOOLEAN},
+@defid{LUA_TSTRING},
+@defid{LUA_TTABLE},
+@defid{LUA_TFUNCTION},
+@defid{LUA_TUSERDATA},
+@defid{LUA_TTHREAD},
+and
+@defid{LUA_TLIGHTUSERDATA}.
+
+}
+
+@APIEntry{const char *lua_typename (lua_State *L, int tp);|
+@apii{0,0,-}
+
+Returns the name of the type encoded by the value @id{tp},
+which must be one the values returned by @Lid{lua_type}.
+
+}
+
+@APIEntry{typedef @ldots lua_Unsigned;|
+
+The unsigned version of @Lid{lua_Integer}.
+
+}
+
+@APIEntry{int lua_upvalueindex (int i);|
+@apii{0,0,-}
+
+Returns the pseudo-index that represents the @id{i}-th upvalue of
+the running function @see{c-closure}.
+
+}
+
+@APIEntry{const lua_Number *lua_version (lua_State *L);|
+@apii{0,0,-}
+
+Returns the address of the version number
+(a C static variable)
+stored in the Lua core.
+When called with a valid @Lid{lua_State},
+returns the address of the version used to create that state.
+When called with @id{NULL},
+returns the address of the version running the call.
+
+}
+
+@APIEntry{
+typedef int (*lua_Writer) (lua_State *L,
+                           const void* p,
+                           size_t sz,
+                           void* ud);|
+
+The type of the writer function used by @Lid{lua_dump}.
+Every time it produces another piece of chunk,
+@Lid{lua_dump} calls the writer,
+passing along the buffer to be written (@id{p}),
+its size (@id{sz}),
+and the @id{data} parameter supplied to @Lid{lua_dump}.
+
+The writer returns an error code:
+@N{0 means} no errors;
+any other value means an error and stops @Lid{lua_dump} from
+calling the writer again.
+
+}
+
+@APIEntry{void lua_xmove (lua_State *from, lua_State *to, int n);|
+@apii{?,?,-}
+
+Exchange values between different threads of the same state.
+
+This function pops @id{n} values from the stack @id{from},
+and pushes them onto the stack @id{to}.
+
+}
+
+@APIEntry{int lua_yield (lua_State *L, int nresults);|
+@apii{?,?,e}
+
+This function is equivalent to @Lid{lua_yieldk},
+but it has no continuation @see{continuations}.
+Therefore, when the thread resumes,
+it continues the function that called
+the function calling @id{lua_yield}.
+
+}
+
+
+@APIEntry{
+int lua_yieldk (lua_State *L,
+                int nresults,
+                lua_KContext ctx,
+                lua_KFunction k);|
+@apii{?,?,e}
+
+Yields a coroutine (thread).
+
+When a @N{C function} calls @Lid{lua_yieldk},
+the running coroutine suspends its execution,
+and the call to @Lid{lua_resume} that started this coroutine returns.
+The parameter @id{nresults} is the number of values from the stack
+that will be passed as results to @Lid{lua_resume}.
+
+When the coroutine is resumed again,
+Lua calls the given @x{continuation function} @id{k} to continue
+the execution of the @N{C function} that yielded @see{continuations}.
+This continuation function receives the same stack
+from the previous function,
+with the @id{n} results removed and
+replaced by the arguments passed to @Lid{lua_resume}.
+Moreover,
+the continuation function receives the value @id{ctx}
+that was passed to @Lid{lua_yieldk}.
+
+Usually, this function does not return;
+when the coroutine eventually resumes,
+it continues executing the continuation function.
+However, there is one special case,
+which is when this function is called
+from inside a line or a count hook @see{debugI}.
+In that case, @id{lua_yieldk} should be called with no continuation
+(probably in the form of @Lid{lua_yield}) and no results,
+and the hook should return immediately after the call.
+Lua will yield and,
+when the coroutine resumes again,
+it will continue the normal execution
+of the (Lua) function that triggered the hook.
+
+This function can raise an error if it is called from a thread
+with a pending C call with no continuation function,
+or it is called from a thread that is not running inside a resume
+(e.g., the main thread).
+
+}
+
+}
+
+@sect2{debugI| @title{The Debug Interface}
+
+Lua has no built-in debugging facilities.
+Instead, it offers a special interface
+by means of functions and @emph{hooks}.
+This interface allows the construction of different
+kinds of debuggers, profilers, and other tools
+that need @Q{inside information} from the interpreter.
+
+
+@APIEntry{
+typedef struct lua_Debug {
+  int event;
+  const char *name;           /* (n) */
+  const char *namewhat;       /* (n) */
+  const char *what;           /* (S) */
+  const char *source;         /* (S) */
+  int currentline;            /* (l) */
+  int linedefined;            /* (S) */
+  int lastlinedefined;        /* (S) */
+  unsigned char nups;         /* (u) number of upvalues */
+  unsigned char nparams;      /* (u) number of parameters */
+  char isvararg;              /* (u) */
+  char istailcall;            /* (t) */
+  char short_src[LUA_IDSIZE]; /* (S) */
+  /* private part */
+  @rep{other fields}
+} lua_Debug;
+|
+
+A structure used to carry different pieces of
+information about a function or an activation record.
+@Lid{lua_getstack} fills only the private part
+of this structure, for later use.
+To fill the other fields of @Lid{lua_Debug} with useful information,
+call @Lid{lua_getinfo}.
+
+The fields of @Lid{lua_Debug} have the following meaning:
+@description{
+
+@item{@id{source}|
+the name of the chunk that created the function.
+If @T{source} starts with a @Char{@At},
+it means that the function was defined in a file where
+the file name follows the @Char{@At}.
+If @T{source} starts with a @Char{=},
+the remainder of its contents describe the source in a user-dependent manner.
+Otherwise,
+the function was defined in a string where
+@T{source} is that string.
+}
+
+@item{@id{short_src}|
+a @Q{printable} version of @T{source}, to be used in error messages.
+}
+
+@item{@id{linedefined}|
+the line number where the definition of the function starts.
+}
+
+@item{@id{lastlinedefined}|
+the line number where the definition of the function ends.
+}
+
+@item{@id{what}|
+the string @T{"Lua"} if the function is a Lua function,
+@T{"C"} if it is a @N{C function},
+@T{"main"} if it is the main part of a chunk.
+}
+
+@item{@id{currentline}|
+the current line where the given function is executing.
+When no line information is available,
+@T{currentline} is set to @num{-1}.
+}
+
+@item{@id{name}|
+a reasonable name for the given function.
+Because functions in Lua are first-class values,
+they do not have a fixed name:
+some functions can be the value of multiple global variables,
+while others can be stored only in a table field.
+The @T{lua_getinfo} function checks how the function was
+called to find a suitable name.
+If it cannot find a name,
+then @id{name} is set to @id{NULL}.
+}
+
+@item{@id{namewhat}|
+explains the @T{name} field.
+The value of @T{namewhat} can be
+@T{"global"}, @T{"local"}, @T{"method"},
+@T{"field"}, @T{"upvalue"}, or @T{""} (the empty string),
+according to how the function was called.
+(Lua uses the empty string when no other option seems to apply.)
+}
+
+@item{@id{istailcall}|
+true if this function invocation was called by a tail call.
+In this case, the caller of this level is not in the stack.
+}
+
+@item{@id{nups}|
+the number of upvalues of the function.
+}
+
+@item{@id{nparams}|
+the number of fixed parameters of the function
+(always @N{0 for} @N{C functions}).
+}
+
+@item{@id{isvararg}|
+true if the function is a vararg function
+(always true for @N{C functions}).
+}
+
+}
+
+}
+
+@APIEntry{lua_Hook lua_gethook (lua_State *L);|
+@apii{0,0,-}
+
+Returns the current hook function.
+
+}
+
+@APIEntry{int lua_gethookcount (lua_State *L);|
+@apii{0,0,-}
+
+Returns the current hook count.
+
+}
+
+@APIEntry{int lua_gethookmask (lua_State *L);|
+@apii{0,0,-}
+
+Returns the current hook mask.
+
+}
+
+@APIEntry{int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar);|
+@apii{0|1,0|1|2,e}
+
+Gets information about a specific function or function invocation.
+
+To get information about a function invocation,
+the parameter @id{ar} must be a valid activation record that was
+filled by a previous call to @Lid{lua_getstack} or
+given as argument to a hook @seeC{lua_Hook}.
+
+To get information about a function, you push it onto the stack
+and start the @id{what} string with the character @Char{>}.
+(In that case,
+@id{lua_getinfo} pops the function from the top of the stack.)
+For instance, to know in which line a function @id{f} was defined,
+you can write the following code:
+@verbatim{
+lua_Debug ar;
+lua_getglobal(L, "f");  /* get global 'f' */
+lua_getinfo(L, ">S", &ar);
+printf("%d\n", ar.linedefined);
+}
+
+Each character in the string @id{what}
+selects some fields of the structure @id{ar} to be filled or
+a value to be pushed on the stack:
+@description{
+
+@item{@Char{n}| fills in the field @id{name} and @id{namewhat};
+}
+
+@item{@Char{S}|
+fills in the fields @id{source}, @id{short_src},
+@id{linedefined}, @id{lastlinedefined}, and @id{what};
+}
+
+@item{@Char{l}| fills in the field @id{currentline};
+}
+
+@item{@Char{t}| fills in the field @id{istailcall};
+}
+
+@item{@Char{u}| fills in the fields
+@id{nups}, @id{nparams}, and @id{isvararg};
+}
+
+@item{@Char{f}|
+pushes onto the stack the function that is
+running at the given level;
+}
+
+@item{@Char{L}|
+pushes onto the stack a table whose indices are the
+numbers of the lines that are valid on the function.
+(A @emph{valid line} is a line with some associated code,
+that is, a line where you can put a break point.
+Non-valid lines include empty lines and comments.)
+
+If this option is given together with option @Char{f},
+its table is pushed after the function.
+}
+
+}
+
+This function returns 0 on error
+(for instance, an invalid option in @id{what}).
+
+}
+
+@APIEntry{const char *lua_getlocal (lua_State *L, const lua_Debug *ar, int n);|
+@apii{0,0|1,-}
+
+Gets information about a local variable of
+a given activation record or a given function.
+
+In the first case,
+the parameter @id{ar} must be a valid activation record that was
+filled by a previous call to @Lid{lua_getstack} or
+given as argument to a hook @seeC{lua_Hook}.
+The index @id{n} selects which local variable to inspect;
+see @Lid{debug.getlocal} for details about variable indices
+and names.
+
+@Lid{lua_getlocal} pushes the variable's value onto the stack
+and returns its name.
+
+In the second case, @id{ar} must be @id{NULL} and the function
+to be inspected must be at the top of the stack.
+In this case, only parameters of Lua functions are visible
+(as there is no information about what variables are active)
+and no values are pushed onto the stack.
+
+Returns @id{NULL} (and pushes nothing)
+when the index is greater than
+the number of active local variables.
+
+}
+
+@APIEntry{int lua_getstack (lua_State *L, int level, lua_Debug *ar);|
+@apii{0,0,-}
+
+Gets information about the interpreter runtime stack.
+
+This function fills parts of a @Lid{lua_Debug} structure with
+an identification of the @emph{activation record}
+of the function executing at a given level.
+@N{Level 0} is the current running function,
+whereas level @M{n+1} is the function that has called level @M{n}
+(except for tail calls, which do not count on the stack).
+When there are no errors, @Lid{lua_getstack} returns 1;
+when called with a level greater than the stack depth,
+it returns 0.
+
+}
+
+@APIEntry{const char *lua_getupvalue (lua_State *L, int funcindex, int n);|
+@apii{0,0|1,-}
+
+Gets information about the @id{n}-th upvalue
+of the closure at index @id{funcindex}.
+It pushes the upvalue's value onto the stack
+and returns its name.
+Returns @id{NULL} (and pushes nothing)
+when the index @id{n} is greater than the number of upvalues.
+
+For @N{C functions}, this function uses the empty string @T{""}
+as a name for all upvalues.
+(For Lua functions,
+upvalues are the external local variables that the function uses,
+and that are consequently included in its closure.)
+
+Upvalues have no particular order,
+as they are active through the whole function.
+They are numbered in an arbitrary order.
+
+}
+
+@APIEntry{typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);|
+
+Type for debugging hook functions.
+
+Whenever a hook is called, its @id{ar} argument has its field
+@id{event} set to the specific event that triggered the hook.
+Lua identifies these events with the following constants:
+@defid{LUA_HOOKCALL}, @defid{LUA_HOOKRET},
+@defid{LUA_HOOKTAILCALL}, @defid{LUA_HOOKLINE},
+and @defid{LUA_HOOKCOUNT}.
+Moreover, for line events, the field @id{currentline} is also set.
+To get the value of any other field in @id{ar},
+the hook must call @Lid{lua_getinfo}.
+
+For call events, @id{event} can be @id{LUA_HOOKCALL},
+the normal value, or @id{LUA_HOOKTAILCALL}, for a tail call;
+in this case, there will be no corresponding return event.
+
+While Lua is running a hook, it disables other calls to hooks.
+Therefore, if a hook calls back Lua to execute a function or a chunk,
+this execution occurs without any calls to hooks.
+
+Hook functions cannot have continuations,
+that is, they cannot call @Lid{lua_yieldk},
+@Lid{lua_pcallk}, or @Lid{lua_callk} with a non-null @id{k}.
+
+Hook functions can yield under the following conditions:
+Only count and line events can yield;
+to yield, a hook function must finish its execution
+calling @Lid{lua_yield} with @id{nresults} equal to zero
+(that is, with no values).
+
+}
+
+@APIEntry{void lua_sethook (lua_State *L, lua_Hook f, int mask, int count);|
+@apii{0,0,-}
+
+Sets the debugging hook function.
+
+Argument @id{f} is the hook function.
+@id{mask} specifies on which events the hook will be called:
+it is formed by a bitwise OR of the constants
+@defid{LUA_MASKCALL},
+@defid{LUA_MASKRET},
+@defid{LUA_MASKLINE},
+and @defid{LUA_MASKCOUNT}.
+The @id{count} argument is only meaningful when the mask
+includes @id{LUA_MASKCOUNT}.
+For each event, the hook is called as explained below:
+@description{
+
+@item{The call hook| is called when the interpreter calls a function.
+The hook is called just after Lua enters the new function,
+before the function gets its arguments.
+}
+
+@item{The return hook| is called when the interpreter returns from a function.
+The hook is called just before Lua leaves the function.
+There is no standard way to access the values
+to be returned by the function.
+}
+
+@item{The line hook| is called when the interpreter is about to
+start the execution of a new line of code,
+or when it jumps back in the code (even to the same line).
+(This event only happens while Lua is executing a Lua function.)
+}
+
+@item{The count hook| is called after the interpreter executes every
+@T{count} instructions.
+(This event only happens while Lua is executing a Lua function.)
+}
+
+}
+
+A hook is disabled by setting @id{mask} to zero.
+
+}
+
+@APIEntry{const char *lua_setlocal (lua_State *L, const lua_Debug *ar, int n);|
+@apii{0|1,0,-}
+
+Sets the value of a local variable of a given activation record.
+It assigns the value at the top of the stack
+to the variable and returns its name.
+It also pops the value from the stack.
+
+Returns @id{NULL} (and pops nothing)
+when the index is greater than
+the number of active local variables.
+
+Parameters @id{ar} and @id{n} are as in function @Lid{lua_getlocal}.
+
+}
+
+@APIEntry{const char *lua_setupvalue (lua_State *L, int funcindex, int n);|
+@apii{0|1,0,-}
+
+Sets the value of a closure's upvalue.
+It assigns the value at the top of the stack
+to the upvalue and returns its name.
+It also pops the value from the stack.
+
+Returns @id{NULL} (and pops nothing)
+when the index @id{n} is greater than the number of upvalues.
+
+Parameters @id{funcindex} and @id{n} are as in function @Lid{lua_getupvalue}.
+
+}
+
+@APIEntry{void *lua_upvalueid (lua_State *L, int funcindex, int n);|
+@apii{0,0,-}
+
+Returns a unique identifier for the upvalue numbered @id{n}
+from the closure at index @id{funcindex}.
+
+These unique identifiers allow a program to check whether different
+closures share upvalues.
+Lua closures that share an upvalue
+(that is, that access a same external local variable)
+will return identical ids for those upvalue indices.
+
+Parameters @id{funcindex} and @id{n} are as in function @Lid{lua_getupvalue},
+but @id{n} cannot be greater than the number of upvalues.
+
+}
+
+@APIEntry{
+void lua_upvaluejoin (lua_State *L, int funcindex1, int n1,
+                                    int funcindex2, int n2);|
+@apii{0,0,-}
+
+Make the @id{n1}-th upvalue of the Lua closure at index @id{funcindex1}
+refer to the @id{n2}-th upvalue of the Lua closure at index @id{funcindex2}.
+
+}
+
+}
+
+}
+
+
+@C{-------------------------------------------------------------------------}
+@sect1{@title{The Auxiliary Library}
+
+@index{lauxlib.h}
+The @def{auxiliary library} provides several convenient functions
+to interface C with Lua.
+While the basic API provides the primitive functions for all
+interactions between C and Lua,
+the auxiliary library provides higher-level functions for some
+common tasks.
+
+All functions and types from the auxiliary library
+are defined in header file @id{lauxlib.h} and
+have a prefix @id{luaL_}.
+
+All functions in the auxiliary library are built on
+top of the basic API,
+and so they provide nothing that cannot be done with that API.
+Nevertheless, the use of the auxiliary library ensures
+more consistency to your code.
+
+
+Several functions in the auxiliary library use internally some
+extra stack slots.
+When a function in the auxiliary library uses less than five slots,
+it does not check the stack size;
+it simply assumes that there are enough slots.
+
+Several functions in the auxiliary library are used to
+check @N{C function} arguments.
+Because the error message is formatted for arguments
+(e.g., @St{bad argument #1}),
+you should not use these functions for other stack values.
+
+Functions called @id{luaL_check*}
+always raise an error if the check is not satisfied.
+
+@sect2{@title{Functions and Types}
+
+Here we list all functions and types from the auxiliary library
+in alphabetical order.
+
+
+@APIEntry{void luaL_addchar (luaL_Buffer *B, char c);|
+@apii{?,?,m}
+
+Adds the byte @id{c} to the buffer @id{B}
+@seeC{luaL_Buffer}.
+
+}
+
+@APIEntry{void luaL_addlstring (luaL_Buffer *B, const char *s, size_t l);|
+@apii{?,?,m}
+
+Adds the string pointed to by @id{s} with length @id{l} to
+the buffer @id{B}
+@seeC{luaL_Buffer}.
+The string can contain @x{embedded zeros}.
+
+}
+
+@APIEntry{void luaL_addsize (luaL_Buffer *B, size_t n);|
+@apii{?,?,-}
+
+Adds to the buffer @id{B} @seeC{luaL_Buffer}
+a string of length @id{n} previously copied to the
+buffer area @seeC{luaL_prepbuffer}.
+
+}
+
+@APIEntry{void luaL_addstring (luaL_Buffer *B, const char *s);|
+@apii{?,?,m}
+
+Adds the zero-terminated string pointed to by @id{s}
+to the buffer @id{B}
+@seeC{luaL_Buffer}.
+
+}
+
+@APIEntry{void luaL_addvalue (luaL_Buffer *B);|
+@apii{1,?,m}
+
+Adds the value at the top of the stack
+to the buffer @id{B}
+@seeC{luaL_Buffer}.
+Pops the value.
+
+This is the only function on string buffers that can (and must)
+be called with an extra element on the stack,
+which is the value to be added to the buffer.
+
+}
+
+@APIEntry{
+void luaL_argcheck (lua_State *L,
+                    int cond,
+                    int arg,
+                    const char *extramsg);|
+@apii{0,0,v}
+
+Checks whether @id{cond} is true.
+If it is not, raises an error with a standard message @seeF{luaL_argerror}.
+
+}
+
+@APIEntry{int luaL_argerror (lua_State *L, int arg, const char *extramsg);|
+@apii{0,0,v}
+
+Raises an error reporting a problem with argument @id{arg}
+of the @N{C function} that called it,
+using a standard message
+that includes @id{extramsg} as a comment:
+@verbatim{
+bad argument #@rep{arg} to '@rep{funcname}' (@rep{extramsg})
+}
+This function never returns.
+
+}
+
+@APIEntry{typedef struct luaL_Buffer luaL_Buffer;|
+
+Type for a @def{string buffer}.
+
+A string buffer allows @N{C code} to build Lua strings piecemeal.
+Its pattern of use is as follows:
+@itemize{
+
+@item{First declare a variable @id{b} of type @Lid{luaL_Buffer}.}
+
+@item{Then initialize it with a call @T{luaL_buffinit(L, &b)}.}
+
+@item{
+Then add string pieces to the buffer calling any of
+the @id{luaL_add*} functions.
+}
+
+@item{
+Finish by calling @T{luaL_pushresult(&b)}.
+This call leaves the final string on the top of the stack.
+}
+
+}
+
+If you know beforehand the total size of the resulting string,
+you can use the buffer like this:
+@itemize{
+
+@item{First declare a variable @id{b} of type @Lid{luaL_Buffer}.}
+
+@item{Then initialize it and preallocate a space of
+size @id{sz} with a call @T{luaL_buffinitsize(L, &b, sz)}.}
+
+@item{Then copy the string into that space.}
+
+@item{
+Finish by calling @T{luaL_pushresultsize(&b, sz)},
+where @id{sz} is the total size of the resulting string
+copied into that space.
+}
+
+}
+
+During its normal operation,
+a string buffer uses a variable number of stack slots.
+So, while using a buffer, you cannot assume that you know where
+the top of the stack is.
+You can use the stack between successive calls to buffer operations
+as long as that use is balanced;
+that is,
+when you call a buffer operation,
+the stack is at the same level
+it was immediately after the previous buffer operation.
+(The only exception to this rule is @Lid{luaL_addvalue}.)
+After calling @Lid{luaL_pushresult} the stack is back to its
+level when the buffer was initialized,
+plus the final string on its top.
+
+}
+
+@APIEntry{void luaL_buffinit (lua_State *L, luaL_Buffer *B);|
+@apii{0,0,-}
+
+Initializes a buffer @id{B}.
+This function does not allocate any space;
+the buffer must be declared as a variable
+@seeC{luaL_Buffer}.
+
+}
+
+@APIEntry{char *luaL_buffinitsize (lua_State *L, luaL_Buffer *B, size_t sz);|
+@apii{?,?,m}
+
+Equivalent to the sequence
+@Lid{luaL_buffinit}, @Lid{luaL_prepbuffsize}.
+
+}
+
+@APIEntry{int luaL_callmeta (lua_State *L, int obj, const char *e);|
+@apii{0,0|1,e}
+
+Calls a metamethod.
+
+If the object at index @id{obj} has a metatable and this
+metatable has a field @id{e},
+this function calls this field passing the object as its only argument.
+In this case this function returns true and pushes onto the
+stack the value returned by the call.
+If there is no metatable or no metamethod,
+this function returns false (without pushing any value on the stack).
+
+}
+
+@APIEntry{void luaL_checkany (lua_State *L, int arg);|
+@apii{0,0,v}
+
+Checks whether the function has an argument
+of any type (including @nil) at position @id{arg}.
+
+}
+
+@APIEntry{lua_Integer luaL_checkinteger (lua_State *L, int arg);|
+@apii{0,0,v}
+
+Checks whether the function argument @id{arg} is an integer
+(or can be converted to an integer)
+and returns this integer cast to a @Lid{lua_Integer}.
+
+}
+
+@APIEntry{const char *luaL_checklstring (lua_State *L, int arg, size_t *l);|
+@apii{0,0,v}
+
+Checks whether the function argument @id{arg} is a string
+and returns this string;
+if @id{l} is not @id{NULL} fills @T{*l}
+with the string's length.
+
+This function uses @Lid{lua_tolstring} to get its result,
+so all conversions and caveats of that function apply here.
+
+}
+
+@APIEntry{lua_Number luaL_checknumber (lua_State *L, int arg);|
+@apii{0,0,v}
+
+Checks whether the function argument @id{arg} is a number
+and returns this number.
+
+}
+
+@APIEntry{
+int luaL_checkoption (lua_State *L,
+                      int arg,
+                      const char *def,
+                      const char *const lst[]);|
+@apii{0,0,v}
+
+Checks whether the function argument @id{arg} is a string and
+searches for this string in the array @id{lst}
+(which must be NULL-terminated).
+Returns the index in the array where the string was found.
+Raises an error if the argument is not a string or
+if the string cannot be found.
+
+If @id{def} is not @id{NULL},
+the function uses @id{def} as a default value when
+there is no argument @id{arg} or when this argument is @nil.
+
+This is a useful function for mapping strings to @N{C enums}.
+(The usual convention in Lua libraries is
+to use strings instead of numbers to select options.)
+
+}
+
+@APIEntry{void luaL_checkstack (lua_State *L, int sz, const char *msg);|
+@apii{0,0,v}
+
+Grows the stack size to @T{top + sz} elements,
+raising an error if the stack cannot grow to that size.
+@id{msg} is an additional text to go into the error message
+(or @id{NULL} for no additional text).
+
+}
+
+@APIEntry{const char *luaL_checkstring (lua_State *L, int arg);|
+@apii{0,0,v}
+
+Checks whether the function argument @id{arg} is a string
+and returns this string.
+
+This function uses @Lid{lua_tolstring} to get its result,
+so all conversions and caveats of that function apply here.
+
+}
+
+@APIEntry{void luaL_checktype (lua_State *L, int arg, int t);|
+@apii{0,0,v}
+
+Checks whether the function argument @id{arg} has type @id{t}.
+See @Lid{lua_type} for the encoding of types for @id{t}.
+
+}
+
+@APIEntry{void *luaL_checkudata (lua_State *L, int arg, const char *tname);|
+@apii{0,0,v}
+
+Checks whether the function argument @id{arg} is a userdata
+of the type @id{tname} @seeC{luaL_newmetatable} and
+returns the userdata address @seeC{lua_touserdata}.
+
+}
+
+@APIEntry{void luaL_checkversion (lua_State *L);|
+@apii{0,0,v}
+
+Checks whether the core running the call,
+the core that created the Lua state,
+and the code making the call are all using the same version of Lua.
+Also checks whether the core running the call
+and the core that created the Lua state
+are using the same address space.
+
+}
+
+@APIEntry{int luaL_dofile (lua_State *L, const char *filename);|
+@apii{0,?,e}
+
+Loads and runs the given file.
+It is defined as the following macro:
+@verbatim{
+(luaL_loadfile(L, filename) || lua_pcall(L, 0, LUA_MULTRET, 0))
+}
+It returns false if there are no errors
+or true in case of errors.
+
+}
+
+@APIEntry{int luaL_dostring (lua_State *L, const char *str);|
+@apii{0,?,-}
+
+Loads and runs the given string.
+It is defined as the following macro:
+@verbatim{
+(luaL_loadstring(L, str) || lua_pcall(L, 0, LUA_MULTRET, 0))
+}
+It returns false if there are no errors
+or true in case of errors.
+
+}
+
+@APIEntry{int luaL_error (lua_State *L, const char *fmt, ...);|
+@apii{0,0,v}
+
+Raises an error.
+The error message format is given by @id{fmt}
+plus any extra arguments,
+following the same rules of @Lid{lua_pushfstring}.
+It also adds at the beginning of the message the file name and
+the line number where the error occurred,
+if this information is available.
+
+This function never returns,
+but it is an idiom to use it in @N{C functions}
+as @T{return luaL_error(@rep{args})}.
+
+}
+
+@APIEntry{int luaL_execresult (lua_State *L, int stat);|
+@apii{0,3,m}
+
+This function produces the return values for
+process-related functions in the standard library
+(@Lid{os.execute} and @Lid{io.close}).
+
+}
+
+@APIEntry{
+int luaL_fileresult (lua_State *L, int stat, const char *fname);|
+@apii{0,1|3,m}
+
+This function produces the return values for
+file-related functions in the standard library
+(@Lid{io.open}, @Lid{os.rename}, @Lid{file:seek}, etc.).
+
+}
+
+@APIEntry{int luaL_getmetafield (lua_State *L, int obj, const char *e);|
+@apii{0,0|1,m}
+
+Pushes onto the stack the field @id{e} from the metatable
+of the object at index @id{obj} and returns the type of the pushed value.
+If the object does not have a metatable,
+or if the metatable does not have this field,
+pushes nothing and returns @id{LUA_TNIL}.
+
+}
+
+@APIEntry{int luaL_getmetatable (lua_State *L, const char *tname);|
+@apii{0,1,m}
+
+Pushes onto the stack the metatable associated with name @id{tname}
+in the registry @seeC{luaL_newmetatable}
+(@nil if there is no metatable associated with that name).
+Returns the type of the pushed value.
+
+}
+
+@APIEntry{int luaL_getsubtable (lua_State *L, int idx, const char *fname);|
+@apii{0,1,e}
+
+Ensures that the value @T{t[fname]},
+where @id{t} is the value at index @id{idx},
+is a table,
+and pushes that table onto the stack.
+Returns true if it finds a previous table there
+and false if it creates a new table.
+
+}
+
+@APIEntry{
+const char *luaL_gsub (lua_State *L,
+                       const char *s,
+                       const char *p,
+                       const char *r);|
+@apii{0,1,m}
+
+Creates a copy of string @id{s} by replacing
+any occurrence of the string @id{p}
+with the string @id{r}.
+Pushes the resulting string on the stack and returns it.
+
+}
+
+@APIEntry{lua_Integer luaL_len (lua_State *L, int index);|
+@apii{0,0,e}
+
+Returns the @Q{length} of the value at the given index
+as a number;
+it is equivalent to the @Char{#} operator in Lua @see{len-op}.
+Raises an error if the result of the operation is not an integer.
+(This case only can happen through metamethods.)
+
+}
+
+@APIEntry{
+int luaL_loadbuffer (lua_State *L,
+                     const char *buff,
+                     size_t sz,
+                     const char *name);|
+@apii{0,1,-}
+
+Equivalent to @Lid{luaL_loadbufferx} with @id{mode} equal to @id{NULL}.
+
+}
+
+
+@APIEntry{
+int luaL_loadbufferx (lua_State *L,
+                      const char *buff,
+                      size_t sz,
+                      const char *name,
+                      const char *mode);|
+@apii{0,1,-}
+
+Loads a buffer as a Lua chunk.
+This function uses @Lid{lua_load} to load the chunk in the
+buffer pointed to by @id{buff} with size @id{sz}.
+
+This function returns the same results as @Lid{lua_load}.
+@id{name} is the chunk name,
+used for debug information and error messages.
+The string @id{mode} works as in function @Lid{lua_load}.
+
+}
+
+
+@APIEntry{int luaL_loadfile (lua_State *L, const char *filename);|
+@apii{0,1,m}
+
+Equivalent to @Lid{luaL_loadfilex} with @id{mode} equal to @id{NULL}.
+
+}
+
+@APIEntry{int luaL_loadfilex (lua_State *L, const char *filename,
+                                            const char *mode);|
+@apii{0,1,m}
+
+Loads a file as a Lua chunk.
+This function uses @Lid{lua_load} to load the chunk in the file
+named @id{filename}.
+If @id{filename} is @id{NULL},
+then it loads from the standard input.
+The first line in the file is ignored if it starts with a @T{#}.
+
+The string @id{mode} works as in function @Lid{lua_load}.
+
+This function returns the same results as @Lid{lua_load},
+but it has an extra error code @defid{LUA_ERRFILE}
+for file-related errors
+(e.g., it cannot open or read the file).
+
+As @Lid{lua_load}, this function only loads the chunk;
+it does not run it.
+
+}
+
+@APIEntry{int luaL_loadstring (lua_State *L, const char *s);|
+@apii{0,1,-}
+
+Loads a string as a Lua chunk.
+This function uses @Lid{lua_load} to load the chunk in
+the zero-terminated string @id{s}.
+
+This function returns the same results as @Lid{lua_load}.
+
+Also as @Lid{lua_load}, this function only loads the chunk;
+it does not run it.
+
+}
+
+
+@APIEntry{void luaL_newlib (lua_State *L, const luaL_Reg l[]);|
+@apii{0,1,m}
+
+Creates a new table and registers there
+the functions in list @id{l}.
+
+It is implemented as the following macro:
+@verbatim{
+(luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+}
+The array @id{l} must be the actual array,
+not a pointer to it.
+
+}
+
+@APIEntry{void luaL_newlibtable (lua_State *L, const luaL_Reg l[]);|
+@apii{0,1,m}
+
+Creates a new table with a size optimized
+to store all entries in the array @id{l}
+(but does not actually store them).
+It is intended to be used in conjunction with @Lid{luaL_setfuncs}
+@seeF{luaL_newlib}.
+
+It is implemented as a macro.
+The array @id{l} must be the actual array,
+not a pointer to it.
+
+}
+
+@APIEntry{int luaL_newmetatable (lua_State *L, const char *tname);|
+@apii{0,1,m}
+
+If the registry already has the key @id{tname},
+returns 0.
+Otherwise,
+creates a new table to be used as a metatable for userdata,
+adds to this new table the pair @T{__name = tname},
+adds to the registry the pair @T{[tname] = new table},
+and returns 1.
+(The entry @idx{__name} is used by some error-reporting functions.)
+
+In both cases pushes onto the stack the final value associated
+with @id{tname} in the registry.
+
+}
+
+@APIEntry{lua_State *luaL_newstate (void);|
+@apii{0,0,-}
+
+Creates a new Lua state.
+It calls @Lid{lua_newstate} with an
+allocator based on the @N{standard C} @id{realloc} function
+and then sets a panic function @see{C-error} that prints
+an error message to the standard error output in case of fatal
+errors.
+
+Returns the new state,
+or @id{NULL} if there is a @x{memory allocation error}.
+
+}
+
+@APIEntry{void luaL_openlibs (lua_State *L);|
+@apii{0,0,e}
+
+Opens all standard Lua libraries into the given state.
+
+}
+
+@APIEntry{
+T luaL_opt (L, func, arg, dflt);|
+@apii{0,0,e}
+
+This macro is defined as follows:
+@verbatim{
+(lua_isnoneornil(L,(arg)) ? (dflt) : func(L,(arg)))
+}
+In words, if the argument @id{arg} is nil or absent,
+the macro results in the default @id{dflt}.
+Otherwise, it results in the result of calling @id{func}
+with the state @id{L} and the argument index @id{arg} as
+arguments.
+Note that it evaluates the expression @id{dflt} only if needed.
+
+}
+
+@APIEntry{
+lua_Integer luaL_optinteger (lua_State *L,
+                             int arg,
+                             lua_Integer d);|
+@apii{0,0,v}
+
+If the function argument @id{arg} is an integer
+(or convertible to an integer),
+returns this integer.
+If this argument is absent or is @nil,
+returns @id{d}.
+Otherwise, raises an error.
+
+}
+
+@APIEntry{
+const char *luaL_optlstring (lua_State *L,
+                             int arg,
+                             const char *d,
+                             size_t *l);|
+@apii{0,0,v}
+
+If the function argument @id{arg} is a string,
+returns this string.
+If this argument is absent or is @nil,
+returns @id{d}.
+Otherwise, raises an error.
+
+If @id{l} is not @id{NULL},
+fills the position @T{*l} with the result's length.
+If the result is @id{NULL}
+(only possible when returning @id{d} and @T{d == NULL}),
+its length is considered zero.
+
+This function uses @Lid{lua_tolstring} to get its result,
+so all conversions and caveats of that function apply here.
+
+}
+
+@APIEntry{lua_Number luaL_optnumber (lua_State *L, int arg, lua_Number d);|
+@apii{0,0,v}
+
+If the function argument @id{arg} is a number,
+returns this number.
+If this argument is absent or is @nil,
+returns @id{d}.
+Otherwise, raises an error.
+
+}
+
+@APIEntry{
+const char *luaL_optstring (lua_State *L,
+                            int arg,
+                            const char *d);|
+@apii{0,0,v}
+
+If the function argument @id{arg} is a string,
+returns this string.
+If this argument is absent or is @nil,
+returns @id{d}.
+Otherwise, raises an error.
+
+}
+
+@APIEntry{char *luaL_prepbuffer (luaL_Buffer *B);|
+@apii{?,?,m}
+
+Equivalent to @Lid{luaL_prepbuffsize}
+with the predefined size @defid{LUAL_BUFFERSIZE}.
+
+}
+
+@APIEntry{char *luaL_prepbuffsize (luaL_Buffer *B, size_t sz);|
+@apii{?,?,m}
+
+Returns an address to a space of size @id{sz}
+where you can copy a string to be added to buffer @id{B}
+@seeC{luaL_Buffer}.
+After copying the string into this space you must call
+@Lid{luaL_addsize} with the size of the string to actually add
+it to the buffer.
+
+}
+
+@APIEntry{void luaL_pushresult (luaL_Buffer *B);|
+@apii{?,1,m}
+
+Finishes the use of buffer @id{B} leaving the final string on
+the top of the stack.
+
+}
+
+@APIEntry{void luaL_pushresultsize (luaL_Buffer *B, size_t sz);|
+@apii{?,1,m}
+
+Equivalent to the sequence @Lid{luaL_addsize}, @Lid{luaL_pushresult}.
+
+}
+
+@APIEntry{int luaL_ref (lua_State *L, int t);|
+@apii{1,0,m}
+
+Creates and returns a @def{reference},
+in the table at index @id{t},
+for the object at the top of the stack (and pops the object).
+
+A reference is a unique integer key.
+As long as you do not manually add integer keys into table @id{t},
+@Lid{luaL_ref} ensures the uniqueness of the key it returns.
+You can retrieve an object referred by reference @id{r}
+by calling @T{lua_rawgeti(L, t, r)}.
+Function @Lid{luaL_unref} frees a reference and its associated object.
+
+If the object at the top of the stack is @nil,
+@Lid{luaL_ref} returns the constant @defid{LUA_REFNIL}.
+The constant @defid{LUA_NOREF} is guaranteed to be different
+from any reference returned by @Lid{luaL_ref}.
+
+}
+
+@APIEntry{
+typedef struct luaL_Reg {
+  const char *name;
+  lua_CFunction func;
+} luaL_Reg;
+|
+
+Type for arrays of functions to be registered by
+@Lid{luaL_setfuncs}.
+@id{name} is the function name and @id{func} is a pointer to
+the function.
+Any array of @Lid{luaL_Reg} must end with a sentinel entry
+in which both @id{name} and @id{func} are @id{NULL}.
+
+}
+
+@APIEntry{
+void luaL_requiref (lua_State *L, const char *modname,
+                    lua_CFunction openf, int glb);|
+@apii{0,1,e}
+
+If @id{modname} is not already present in @Lid{package.loaded},
+calls function @id{openf} with string @id{modname} as an argument
+and sets the call result in @T{package.loaded[modname]},
+as if that function has been called through @Lid{require}.
+
+If @id{glb} is true,
+also stores the module into global @id{modname}.
+
+Leaves a copy of the module on the stack.
+
+}
+
+@APIEntry{void luaL_setfuncs (lua_State *L, const luaL_Reg *l, int nup);|
+@apii{nup,0,m}
+
+Registers all functions in the array @id{l}
+@seeC{luaL_Reg} into the table on the top of the stack
+(below optional upvalues, see next).
+
+When @id{nup} is not zero,
+all functions are created sharing @id{nup} upvalues,
+which must be previously pushed on the stack
+on top of the library table.
+These values are popped from the stack after the registration.
+
+}
+
+@APIEntry{void luaL_setmetatable (lua_State *L, const char *tname);|
+@apii{0,0,-}
+
+Sets the metatable of the object at the top of the stack
+as the metatable associated with name @id{tname}
+in the registry @seeC{luaL_newmetatable}.
+
+}
+
+@APIEntry{
+typedef struct luaL_Stream {
+  FILE *f;
+  lua_CFunction closef;
+} luaL_Stream;
+|
+
+The standard representation for @x{file handles},
+which is used by the standard I/O library.
+
+A file handle is implemented as a full userdata,
+with a metatable called @id{LUA_FILEHANDLE}
+(where @id{LUA_FILEHANDLE} is a macro with the actual metatable's name).
+The metatable is created by the I/O library
+@seeF{luaL_newmetatable}.
+
+This userdata must start with the structure @id{luaL_Stream};
+it can contain other data after this initial structure.
+Field @id{f} points to the corresponding C stream
+(or it can be @id{NULL} to indicate an incompletely created handle).
+Field @id{closef} points to a Lua function
+that will be called to close the stream
+when the handle is closed or collected;
+this function receives the file handle as its sole argument and
+must return either @Rw{true} (in case of success)
+or @nil plus an error message (in case of error).
+Once Lua calls this field,
+it changes the field value to @id{NULL}
+to signal that the handle is closed.
+
+}
+
+@APIEntry{void *luaL_testudata (lua_State *L, int arg, const char *tname);|
+@apii{0,0,m}
+
+This function works like @Lid{luaL_checkudata},
+except that, when the test fails,
+it returns @id{NULL} instead of raising an error.
+
+}
+
+@APIEntry{const char *luaL_tolstring (lua_State *L, int idx, size_t *len);|
+@apii{0,1,e}
+
+Converts any Lua value at the given index to a @N{C string}
+in a reasonable format.
+The resulting string is pushed onto the stack and also
+returned by the function.
+If @id{len} is not @id{NULL},
+the function also sets @T{*len} with the string length.
+
+If the value has a metatable with a @idx{__tostring} field,
+then @id{luaL_tolstring} calls the corresponding metamethod
+with the value as argument,
+and uses the result of the call as its result.
+
+}
+
+@APIEntry{
+void luaL_traceback (lua_State *L, lua_State *L1, const char *msg,
+                     int level);|
+@apii{0,1,m}
+
+Creates and pushes a traceback of the stack @id{L1}.
+If @id{msg} is not @id{NULL} it is appended
+at the beginning of the traceback.
+The @id{level} parameter tells at which level
+to start the traceback.
+
+}
+
+@APIEntry{const char *luaL_typename (lua_State *L, int index);|
+@apii{0,0,-}
+
+Returns the name of the type of the value at the given index.
+
+}
+
+@APIEntry{void luaL_unref (lua_State *L, int t, int ref);|
+@apii{0,0,-}
+
+Releases reference @id{ref} from the table at index @id{t}
+@seeC{luaL_ref}.
+The entry is removed from the table,
+so that the referred object can be collected.
+The reference @id{ref} is also freed to be used again.
+
+If @id{ref} is @Lid{LUA_NOREF} or @Lid{LUA_REFNIL},
+@Lid{luaL_unref} does nothing.
+
+}
+
+@APIEntry{void luaL_where (lua_State *L, int lvl);|
+@apii{0,1,m}
+
+Pushes onto the stack a string identifying the current position
+of the control at level @id{lvl} in the call stack.
+Typically this string has the following format:
+@verbatim{
+@rep{chunkname}:@rep{currentline}:
+}
+@N{Level 0} is the running function,
+@N{level 1} is the function that called the running function,
+etc.
+
+This function is used to build a prefix for error messages.
+
+}
+
+}
+
+}
+
+
+@C{-------------------------------------------------------------------------}
+@sect1{libraries| @title{Standard Libraries}
+
+The standard Lua libraries provide useful functions
+that are implemented directly through the @N{C API}.
+Some of these functions provide essential services to the language
+(e.g., @Lid{type} and @Lid{getmetatable});
+others provide access to @Q{outside} services (e.g., I/O);
+and others could be implemented in Lua itself,
+but are quite useful or have critical performance requirements that
+deserve an implementation in C (e.g., @Lid{table.sort}).
+
+All libraries are implemented through the official @N{C API}
+and are provided as separate @N{C modules}.
+Currently, Lua has the following standard libraries:
+@itemize{
+
+@item{@link{predefined|basic library};}
+
+@item{@link{corolib|coroutine library};}
+
+@item{@link{packlib|package library};}
+
+@item{@link{strlib|string manipulation};}
+
+@item{@link{utf8|basic UTF-8 support};}
+
+@item{@link{tablib|table manipulation};}
+
+@item{@link{mathlib|mathematical functions} (sin, log, etc.);}
+
+@item{@link{iolib|input and output};}
+
+@item{@link{oslib|operating system facilities};}
+
+@item{@link{debuglib|debug facilities}.}
+
+}
+Except for the basic and the package libraries,
+each library provides all its functions as fields of a global table
+or as methods of its objects.
+
+To have access to these libraries,
+the @N{C host} program should call the @Lid{luaL_openlibs} function,
+which opens all standard libraries.
+Alternatively,
+the host program can open them individually by using
+@Lid{luaL_requiref} to call
+@defid{luaopen_base} (for the basic library),
+@defid{luaopen_package} (for the package library),
+@defid{luaopen_coroutine} (for the coroutine library),
+@defid{luaopen_string} (for the string library),
+@defid{luaopen_utf8} (for the UTF8 library),
+@defid{luaopen_table} (for the table library),
+@defid{luaopen_math} (for the mathematical library),
+@defid{luaopen_io} (for the I/O library),
+@defid{luaopen_os} (for the operating system library),
+and @defid{luaopen_debug} (for the debug library).
+These functions are declared in @defid{lualib.h}.
+
+@sect2{predefined| @title{Basic Functions}
+
+The basic library provides core functions to Lua.
+If you do not include this library in your application,
+you should check carefully whether you need to provide
+implementations for some of its facilities.
+
+
+@LibEntry{assert (v [, message])|
+
+Calls @Lid{error} if
+the value of its argument @id{v} is false (i.e., @nil or @false);
+otherwise, returns all its arguments.
+In case of error,
+@id{message} is the error object;
+when absent, it defaults to @St{assertion failed!}
+
+}
+
+@LibEntry{collectgarbage ([opt [, arg]])|
+
+This function is a generic interface to the garbage collector.
+It performs different functions according to its first argument, @id{opt}:
+@description{
+
+@item{@St{collect}|
+performs a full garbage-collection cycle.
+This is the default option.
+}
+
+@item{@St{stop}|
+stops automatic execution of the garbage collector.
+The collector will run only when explicitly invoked,
+until a call to restart it.
+}
+
+@item{@St{restart}|
+restarts automatic execution of the garbage collector.
+}
+
+@item{@St{count}|
+returns the total memory in use by Lua in Kbytes.
+The value has a fractional part,
+so that it multiplied by 1024
+gives the exact number of bytes in use by Lua
+(except for overflows).
+}
+
+@item{@St{step}|
+performs a garbage-collection step.
+The step @Q{size} is controlled by @id{arg}.
+With a zero value,
+the collector will perform one basic (indivisible) step.
+For non-zero values,
+the collector will perform as if that amount of memory
+(in KBytes) had been allocated by Lua.
+Returns @Rw{true} if the step finished a collection cycle.
+}
+
+@item{@St{setpause}|
+sets @id{arg} as the new value for the @emph{pause} of
+the collector @see{GC}.
+Returns the previous value for @emph{pause}.
+}
+
+@item{@St{setstepmul}|
+sets @id{arg} as the new value for the @emph{step multiplier} of
+the collector @see{GC}.
+Returns the previous value for @emph{step}.
+}
+
+@item{@St{isrunning}|
+returns a boolean that tells whether the collector is running
+(i.e., not stopped).
+}
+
+}
+
+}
+
+@LibEntry{dofile ([filename])|
+Opens the named file and executes its contents as a Lua chunk.
+When called without arguments,
+@id{dofile} executes the contents of the standard input (@id{stdin}).
+Returns all values returned by the chunk.
+In case of errors, @id{dofile} propagates the error
+to its caller (that is, @id{dofile} does not run in protected mode).
+
+}
+
+@LibEntry{error (message [, level])|
+Terminates the last protected function called
+and returns @id{message} as the error object.
+Function @id{error} never returns.
+
+Usually, @id{error} adds some information about the error position
+at the beginning of the message, if the message is a string.
+The @id{level} argument specifies how to get the error position.
+With @N{level 1} (the default), the error position is where the
+@id{error} function was called.
+@N{Level 2} points the error to where the function
+that called @id{error} was called; and so on.
+Passing a @N{level 0} avoids the addition of error position information
+to the message.
+
+}
+
+@LibEntry{_G|
+A global variable (not a function) that
+holds the @x{global environment} @see{globalenv}.
+Lua itself does not use this variable;
+changing its value does not affect any environment,
+nor vice versa.
+
+}
+
+@LibEntry{getmetatable (object)|
+
+If @id{object} does not have a metatable, returns @nil.
+Otherwise,
+if the object's metatable has a @idx{__metatable} field,
+returns the associated value.
+Otherwise, returns the metatable of the given object.
+
+}
+
+@LibEntry{ipairs (t)|
+
+Returns three values (an iterator function, the table @id{t}, and 0)
+so that the construction
+@verbatim{
+for i,v in ipairs(t) do @rep{body} end
+}
+will iterate over the key@En{}value pairs
+(@T{1,t[1]}), (@T{2,t[2]}), @ldots,
+up to the first nil value.
+
+}
+
+@LibEntry{load (chunk [, chunkname [, mode [, env]]])|
+
+Loads a chunk.
+
+If @id{chunk} is a string, the chunk is this string.
+If @id{chunk} is a function,
+@id{load} calls it repeatedly to get the chunk pieces.
+Each call to @id{chunk} must return a string that concatenates
+with previous results.
+A return of an empty string, @nil, or no value signals the end of the chunk.
+
+If there are no syntactic errors,
+returns the compiled chunk as a function;
+otherwise, returns @nil plus the error message.
+
+If the resulting function has upvalues,
+the first upvalue is set to the value of @id{env},
+if that parameter is given,
+or to the value of the @x{global environment}.
+Other upvalues are initialized with @nil.
+(When you load a main chunk,
+the resulting function will always have exactly one upvalue,
+the @id{_ENV} variable @see{globalenv}.
+However,
+when you load a binary chunk created from a function @seeF{string.dump},
+the resulting function can have an arbitrary number of upvalues.)
+All upvalues are fresh, that is,
+they are not shared with any other function.
+
+@id{chunkname} is used as the name of the chunk for error messages
+and debug information @see{debugI}.
+When absent,
+it defaults to @id{chunk}, if @id{chunk} is a string,
+or to @St{=(load)} otherwise.
+
+The string @id{mode} controls whether the chunk can be text or binary
+(that is, a precompiled chunk).
+It may be the string @St{b} (only @x{binary chunk}s),
+@St{t} (only text chunks),
+or @St{bt} (both binary and text).
+The default is @St{bt}.
+
+Lua does not check the consistency of binary chunks.
+Maliciously crafted binary chunks can crash
+the interpreter.
+
+}
+
+@LibEntry{loadfile ([filename [, mode [, env]]])|
+
+Similar to @Lid{load},
+but gets the chunk from file @id{filename}
+or from the standard input,
+if no file name is given.
+
+}
+
+@LibEntry{next (table [, index])|
+
+Allows a program to traverse all fields of a table.
+Its first argument is a table and its second argument
+is an index in this table.
+@id{next} returns the next index of the table
+and its associated value.
+When called with @nil as its second argument,
+@id{next} returns an initial index
+and its associated value.
+When called with the last index,
+or with @nil in an empty table,
+@id{next} returns @nil.
+If the second argument is absent, then it is interpreted as @nil.
+In particular,
+you can use @T{next(t)} to check whether a table is empty.
+
+The order in which the indices are enumerated is not specified,
+@emph{even for numeric indices}.
+(To traverse a table in numerical order,
+use a numerical @Rw{for}.)
+
+The behavior of @id{next} is undefined if,
+during the traversal,
+you assign any value to a non-existent field in the table.
+You may however modify existing fields.
+In particular, you may clear existing fields.
+
+}
+
+@LibEntry{pairs (t)|
+
+If @id{t} has a metamethod @idx{__pairs},
+calls it with @id{t} as argument and returns the first three
+results from the call.
+
+Otherwise,
+returns three values: the @Lid{next} function, the table @id{t}, and @nil,
+so that the construction
+@verbatim{
+for k,v in pairs(t) do @rep{body} end
+}
+will iterate over all key@En{}value pairs of table @id{t}.
+
+See function @Lid{next} for the caveats of modifying
+the table during its traversal.
+
+}
+
+@LibEntry{pcall (f [, arg1, @Cdots])|
+
+Calls function @id{f} with
+the given arguments in @def{protected mode}.
+This means that any error @N{inside @T{f}} is not propagated;
+instead, @id{pcall} catches the error
+and returns a status code.
+Its first result is the status code (a boolean),
+which is true if the call succeeds without errors.
+In such case, @id{pcall} also returns all results from the call,
+after this first result.
+In case of any error, @id{pcall} returns @false plus the error message.
+
+}
+
+@LibEntry{print (@Cdots)|
+Receives any number of arguments
+and prints their values to @id{stdout},
+using the @Lid{tostring} function to convert each argument to a string.
+@id{print} is not intended for formatted output,
+but only as a quick way to show a value,
+for instance for debugging.
+For complete control over the output,
+use @Lid{string.format} and @Lid{io.write}.
+
+}
+
+@LibEntry{rawequal (v1, v2)|
+Checks whether @id{v1} is equal to @id{v2},
+without invoking the @idx{__eq} metamethod.
+Returns a boolean.
+
+}
+
+@LibEntry{rawget (table, index)|
+Gets the real value of @T{table[index]},
+without invoking the @idx{__index} metamethod.
+@id{table} must be a table;
+@id{index} may be any value.
+
+}
+
+@LibEntry{rawlen (v)|
+Returns the length of the object @id{v},
+which must be a table or a string,
+without invoking the @idx{__len} metamethod.
+Returns an integer.
+
+}
+
+@LibEntry{rawset (table, index, value)|
+Sets the real value of @T{table[index]} to @id{value},
+without invoking the @idx{__newindex} metamethod.
+@id{table} must be a table,
+@id{index} any value different from @nil and @x{NaN},
+and @id{value} any Lua value.
+
+This function returns @id{table}.
+
+}
+
+@LibEntry{select (index, @Cdots)|
+
+If @id{index} is a number,
+returns all arguments after argument number @id{index};
+a negative number indexes from the end (@num{-1} is the last argument).
+Otherwise, @id{index} must be the string @T{"#"},
+and @id{select} returns the total number of extra arguments it received.
+
+}
+
+@LibEntry{setmetatable (table, metatable)|
+
+Sets the metatable for the given table.
+(To change the metatable of other types from Lua code,
+you must use the @link{debuglib|debug library}.)
+If @id{metatable} is @nil,
+removes the metatable of the given table.
+If the original metatable has a @idx{__metatable} field,
+raises an error.
+
+This function returns @id{table}.
+
+}
+
+@LibEntry{tonumber (e [, base])|
+
+When called with no @id{base},
+@id{tonumber} tries to convert its argument to a number.
+If the argument is already a number or
+a string convertible to a number,
+then @id{tonumber} returns this number;
+otherwise, it returns @nil.
+
+The conversion of strings can result in integers or floats,
+according to the lexical conventions of Lua @see{lexical}.
+(The string may have leading and trailing spaces and a sign.)
+
+When called with @id{base},
+then @id{e} must be a string to be interpreted as
+an integer numeral in that base.
+The base may be any integer between 2 and 36, inclusive.
+In bases @N{above 10}, the letter @Char{A} (in either upper or lower case)
+@N{represents 10}, @Char{B} @N{represents 11}, and so forth,
+with @Char{Z} representing 35.
+If the string @id{e} is not a valid numeral in the given base,
+the function returns @nil.
+
+}
+
+@LibEntry{tostring (v)|
+Receives a value of any type and
+converts it to a string in a human-readable format.
+(For complete control of how numbers are converted,
+use @Lid{string.format}.)
+
+If the metatable of @id{v} has a @idx{__tostring} field,
+then @id{tostring} calls the corresponding value
+with @id{v} as argument,
+and uses the result of the call as its result.
+
+}
+
+@LibEntry{type (v)|
+Returns the type of its only argument, coded as a string.
+The possible results of this function are
+@St{nil} (a string, not the value @nil),
+@St{number},
+@St{string},
+@St{boolean},
+@St{table},
+@St{function},
+@St{thread},
+and @St{userdata}.
+
+}
+
+@LibEntry{_VERSION|
+
+A global variable (not a function) that
+holds a string containing the running Lua version.
+The current value of this variable is @St{Lua 5.3}.
+
+}
+
+@LibEntry{xpcall (f, msgh [, arg1, @Cdots])|
+
+This function is similar to @Lid{pcall},
+except that it sets a new @x{message handler} @id{msgh}.
+
+}
+
+}
+
+@sect2{corolib| @title{Coroutine Manipulation}
+
+This library comprises the operations to manipulate coroutines,
+which come inside the table @defid{coroutine}.
+See @See{coroutine} for a general description of coroutines.
+
+
+@LibEntry{coroutine.create (f)|
+
+Creates a new coroutine, with body @id{f}.
+@id{f} must be a function.
+Returns this new coroutine,
+an object with type @T{"thread"}.
+
+}
+
+@LibEntry{coroutine.isyieldable ()|
+
+Returns true when the running coroutine can yield.
+
+A running coroutine is yieldable if it is not the main thread and
+it is not inside a non-yieldable @N{C function}.
+
+}
+
+@LibEntry{coroutine.resume (co [, val1, @Cdots])|
+
+Starts or continues the execution of coroutine @id{co}.
+The first time you resume a coroutine,
+it starts running its body.
+The values @id{val1}, @ldots are passed
+as the arguments to the body function.
+If the coroutine has yielded,
+@id{resume} restarts it;
+the values @id{val1}, @ldots are passed
+as the results from the yield.
+
+If the coroutine runs without any errors,
+@id{resume} returns @true plus any values passed to @id{yield}
+(when the coroutine yields) or any values returned by the body function
+(when the coroutine terminates).
+If there is any error,
+@id{resume} returns @false plus the error message.
+
+}
+
+@LibEntry{coroutine.running ()|
+
+Returns the running coroutine plus a boolean,
+true when the running coroutine is the main one.
+
+}
+
+@LibEntry{coroutine.status (co)|
+
+Returns the status of coroutine @id{co}, as a string:
+@T{"running"},
+if the coroutine is running (that is, it called @id{status});
+@T{"suspended"}, if the coroutine is suspended in a call to @id{yield},
+or if it has not started running yet;
+@T{"normal"} if the coroutine is active but not running
+(that is, it has resumed another coroutine);
+and @T{"dead"} if the coroutine has finished its body function,
+or if it has stopped with an error.
+
+}
+
+@LibEntry{coroutine.wrap (f)|
+
+Creates a new coroutine, with body @id{f}.
+@id{f} must be a function.
+Returns a function that resumes the coroutine each time it is called.
+Any arguments passed to the function behave as the
+extra arguments to @id{resume}.
+Returns the same values returned by @id{resume},
+except the first boolean.
+In case of error, propagates the error.
+
+}
+
+@LibEntry{coroutine.yield (@Cdots)|
+
+Suspends the execution of the calling coroutine.
+Any arguments to @id{yield} are passed as extra results to @id{resume}.
+
+}
+
+}
+
+@sect2{packlib| @title{Modules}
+
+The package library provides basic
+facilities for loading modules in Lua.
+It exports one function directly in the global environment:
+@Lid{require}.
+Everything else is exported in a table @defid{package}.
+
+
+@LibEntry{require (modname)|
+
+Loads the given module.
+The function starts by looking into the @Lid{package.loaded} table
+to determine whether @id{modname} is already loaded.
+If it is, then @id{require} returns the value stored
+at @T{package.loaded[modname]}.
+Otherwise, it tries to find a @emph{loader} for the module.
+
+To find a loader,
+@id{require} is guided by the @Lid{package.searchers} sequence.
+By changing this sequence,
+we can change how @id{require} looks for a module.
+The following explanation is based on the default configuration
+for @Lid{package.searchers}.
+
+First @id{require} queries @T{package.preload[modname]}.
+If it has a value,
+this value (which must be a function) is the loader.
+Otherwise @id{require} searches for a Lua loader using the
+path stored in @Lid{package.path}.
+If that also fails, it searches for a @N{C loader} using the
+path stored in @Lid{package.cpath}.
+If that also fails,
+it tries an @emph{all-in-one} loader @seeF{package.searchers}.
+
+Once a loader is found,
+@id{require} calls the loader with two arguments:
+@id{modname} and an extra value dependent on how it got the loader.
+(If the loader came from a file,
+this extra value is the file name.)
+If the loader returns any non-nil value,
+@id{require} assigns the returned value to @T{package.loaded[modname]}.
+If the loader does not return a non-nil value and
+has not assigned any value to @T{package.loaded[modname]},
+then @id{require} assigns @Rw{true} to this entry.
+In any case, @id{require} returns the
+final value of @T{package.loaded[modname]}.
+
+If there is any error loading or running the module,
+or if it cannot find any loader for the module,
+then @id{require} raises an error.
+
+}
+
+@LibEntry{package.config|
+
+A string describing some compile-time configurations for packages.
+This string is a sequence of lines:
+@itemize{
+
+@item{The first line is the @x{directory separator} string.
+Default is @Char{\} for @x{Windows} and @Char{/} for all other systems.}
+
+@item{The second line is the character that separates templates in a path.
+Default is @Char{;}.}
+
+@item{The third line is the string that marks the
+substitution points in a template.
+Default is @Char{?}.}
+
+@item{The fourth line is a string that, in a path in @x{Windows},
+is replaced by the executable's directory.
+Default is @Char{!}.}
+
+@item{The fifth line is a mark to ignore all text after it
+when building the @id{luaopen_} function name.
+Default is @Char{-}.}
+
+}
+
+}
+
+@LibEntry{package.cpath|
+
+The path used by @Lid{require} to search for a @N{C loader}.
+
+Lua initializes the @N{C path} @Lid{package.cpath} in the same way
+it initializes the Lua path @Lid{package.path},
+using the environment variable @defid{LUA_CPATH_5_3},
+or the environment variable @defid{LUA_CPATH},
+or a default path defined in @id{luaconf.h}.
+
+}
+
+@LibEntry{package.loaded|
+
+A table used by @Lid{require} to control which
+modules are already loaded.
+When you require a module @id{modname} and
+@T{package.loaded[modname]} is not false,
+@Lid{require} simply returns the value stored there.
+
+This variable is only a reference to the real table;
+assignments to this variable do not change the
+table used by @Lid{require}.
+
+}
+
+@LibEntry{package.loadlib (libname, funcname)|
+
+Dynamically links the host program with the @N{C library} @id{libname}.
+
+If @id{funcname} is @St{*},
+then it only links with the library,
+making the symbols exported by the library
+available to other dynamically linked libraries.
+Otherwise,
+it looks for a function @id{funcname} inside the library
+and returns this function as a @N{C function}.
+So, @id{funcname} must follow the @Lid{lua_CFunction} prototype
+@seeC{lua_CFunction}.
+
+This is a low-level function.
+It completely bypasses the package and module system.
+Unlike @Lid{require},
+it does not perform any path searching and
+does not automatically adds extensions.
+@id{libname} must be the complete file name of the @N{C library},
+including if necessary a path and an extension.
+@id{funcname} must be the exact name exported by the @N{C library}
+(which may depend on the @N{C compiler} and linker used).
+
+This function is not supported by @N{Standard C}.
+As such, it is only available on some platforms
+(Windows, Linux, Mac OS X, Solaris, BSD,
+plus other Unix systems that support the @id{dlfcn} standard).
+
+}
+
+@LibEntry{package.path|
+
+The path used by @Lid{require} to search for a Lua loader.
+
+At start-up, Lua initializes this variable with
+the value of the environment variable @defid{LUA_PATH_5_3} or
+the environment variable @defid{LUA_PATH} or
+with a default path defined in @id{luaconf.h},
+if those environment variables are not defined.
+Any @St{;;} in the value of the environment variable
+is replaced by the default path.
+
+}
+
+@LibEntry{package.preload|
+
+A table to store loaders for specific modules
+@seeF{require}.
+
+This variable is only a reference to the real table;
+assignments to this variable do not change the
+table used by @Lid{require}.
+
+}
+
+@LibEntry{package.searchers|
+
+A table used by @Lid{require} to control how to load modules.
+
+Each entry in this table is a @def{searcher function}.
+When looking for a module,
+@Lid{require} calls each of these searchers in ascending order,
+with the module name (the argument given to @Lid{require}) as its
+sole parameter.
+The function can return another function (the module @def{loader})
+plus an extra value that will be passed to that loader,
+or a string explaining why it did not find that module
+(or @nil if it has nothing to say).
+
+Lua initializes this table with four searcher functions.
+
+The first searcher simply looks for a loader in the
+@Lid{package.preload} table.
+
+The second searcher looks for a loader as a Lua library,
+using the path stored at @Lid{package.path}.
+The search is done as described in function @Lid{package.searchpath}.
+
+The third searcher looks for a loader as a @N{C library},
+using the path given by the variable @Lid{package.cpath}.
+Again,
+the search is done as described in function @Lid{package.searchpath}.
+For instance,
+if the @N{C path} is the string
+@verbatim{
+"./?.so;./?.dll;/usr/local/?/init.so"
+}
+the searcher for module @id{foo}
+will try to open the files @T{./foo.so}, @T{./foo.dll},
+and @T{/usr/local/foo/init.so}, in that order.
+Once it finds a @N{C library},
+this searcher first uses a dynamic link facility to link the
+application with the library.
+Then it tries to find a @N{C function} inside the library to
+be used as the loader.
+The name of this @N{C function} is the string @St{luaopen_}
+concatenated with a copy of the module name where each dot
+is replaced by an underscore.
+Moreover, if the module name has a hyphen,
+its suffix after (and including) the first hyphen is removed.
+For instance, if the module name is @id{a.b.c-v2.1},
+the function name will be @id{luaopen_a_b_c}.
+
+The fourth searcher tries an @def{all-in-one loader}.
+It searches the @N{C path} for a library for
+the root name of the given module.
+For instance, when requiring @id{a.b.c},
+it will search for a @N{C library} for @id{a}.
+If found, it looks into it for an open function for
+the submodule;
+in our example, that would be @id{luaopen_a_b_c}.
+With this facility, a package can pack several @N{C submodules}
+into one single library,
+with each submodule keeping its original open function.
+
+All searchers except the first one (preload) return as the extra value
+the file name where the module was found,
+as returned by @Lid{package.searchpath}.
+The first searcher returns no extra value.
+
+}
+
+@LibEntry{package.searchpath (name, path [, sep [, rep]])|
+
+Searches for the given @id{name} in the given @id{path}.
+
+A path is a string containing a sequence of
+@emph{templates} separated by semicolons.
+For each template,
+the function replaces each interrogation mark (if any)
+in the template with a copy of @id{name}
+wherein all occurrences of @id{sep}
+(a dot, by default)
+were replaced by @id{rep}
+(the system's directory separator, by default),
+and then tries to open the resulting file name.
+
+For instance, if the path is the string
+@verbatim{
+"./?.lua;./?.lc;/usr/local/?/init.lua"
+}
+the search for the name @id{foo.a}
+will try to open the files
+@T{./foo/a.lua}, @T{./foo/a.lc}, and
+@T{/usr/local/foo/a/init.lua}, in that order.
+
+Returns the resulting name of the first file that it can
+open in read mode (after closing the file),
+or @nil plus an error message if none succeeds.
+(This error message lists all file names it tried to open.)
+
+}
+
+}
+
+@sect2{strlib| @title{String Manipulation}
+
+This library provides generic functions for string manipulation,
+such as finding and extracting substrings, and pattern matching.
+When indexing a string in Lua, the first character is at @N{position 1}
+(not @N{at 0}, as in C).
+Indices are allowed to be negative and are interpreted as indexing backwards,
+from the end of the string.
+Thus, the last character is at position @num{-1}, and so on.
+
+The string library provides all its functions inside the table
+@defid{string}.
+It also sets a @x{metatable for strings}
+where the @idx{__index} field points to the @id{string} table.
+Therefore, you can use the string functions in object-oriented style.
+For instance, @T{string.byte(s,i)}
+can be written as @T{s:byte(i)}.
+
+The string library assumes one-byte character encodings.
+
+
+@LibEntry{string.byte (s [, i [, j]])|
+Returns the internal numeric codes of the characters @T{s[i]},
+@T{s[i+1]}, @ldots, @T{s[j]}.
+The default value for @id{i} @N{is 1};
+the default value for @id{j} @N{is @id{i}}.
+These indices are corrected
+following the same rules of function @Lid{string.sub}.
+
+Numeric codes are not necessarily portable across platforms.
+
+}
+
+@LibEntry{string.char (@Cdots)|
+Receives zero or more integers.
+Returns a string with length equal to the number of arguments,
+in which each character has the internal numeric code equal
+to its corresponding argument.
+
+Numeric codes are not necessarily portable across platforms.
+
+}
+
+@LibEntry{string.dump (function [, strip])|
+
+Returns a string containing a binary representation
+(a @emph{binary chunk})
+of the given function,
+so that a later @Lid{load} on this string returns
+a copy of the function (but with new upvalues).
+If @id{strip} is a true value,
+the binary representation may not include all debug information
+about the function,
+to save space.
+
+Functions with upvalues have only their number of upvalues saved.
+When (re)loaded,
+those upvalues receive fresh instances containing @nil.
+(You can use the debug library to serialize
+and reload the upvalues of a function
+in a way adequate to your needs.)
+
+}
+
+@LibEntry{string.find (s, pattern [, init [, plain]])|
+
+Looks for the first match of
+@id{pattern} @see{pm} in the string @id{s}.
+If it finds a match, then @id{find} returns the indices @N{of @T{s}}
+where this occurrence starts and ends;
+otherwise, it returns @nil.
+A third, optional numeric argument @id{init} specifies
+where to start the search;
+its default value @N{is 1} and can be negative.
+A value of @true as a fourth, optional argument @id{plain}
+turns off the pattern matching facilities,
+so the function does a plain @Q{find substring} operation,
+with no characters in @id{pattern} being considered magic.
+Note that if @id{plain} is given, then @id{init} must be given as well.
+
+If the pattern has captures,
+then in a successful match
+the captured values are also returned,
+after the two indices.
+
+}
+
+@LibEntry{string.format (formatstring, @Cdots)|
+
+Returns a formatted version of its variable number of arguments
+following the description given in its first argument (which must be a string).
+The format string follows the same rules as the @ANSI{sprintf}.
+The only differences are that the options/modifiers
+@T{*}, @id{h}, @id{L}, @id{l}, @id{n},
+and @id{p} are not supported
+and that there is an extra option, @id{q}.
+
+The @id{q} option formats a string between double quotes,
+using escape sequences when necessary to ensure that
+it can safely be read back by the Lua interpreter.
+For instance, the call
+@verbatim{
+string.format('%q', 'a string with "quotes" and \n new line')
+}
+may produce the string:
+@verbatim{
+"a string with \"quotes\" and \
+ new line"
+}
+
+Options
+@id{A}, @id{a}, @id{E}, @id{e}, @id{f},
+@id{G}, and @id{g} all expect a number as argument.
+Options @id{c}, @id{d},
+@id{i}, @id{o}, @id{u}, @id{X}, and @id{x}
+expect an integer.
+When Lua is compiled with a C89 compiler,
+options @id{A} and @id{a} (hexadecimal floats)
+do not support any modifier (flags, width, length).
+
+Option @id{s} expects a string;
+if its argument is not a string,
+it is converted to one following the same rules of @Lid{tostring}.
+If the option has any modifier (flags, width, length),
+the string argument should not contain @x{embedded zeros}.
+
+}
+
+@LibEntry{string.gmatch (s, pattern)|
+Returns an iterator function that,
+each time it is called,
+returns the next captures from @id{pattern} @see{pm}
+over the string @id{s}.
+If @id{pattern} specifies no captures,
+then the whole match is produced in each call.
+
+As an example, the following loop
+will iterate over all the words from string @id{s},
+printing one per line:
+@verbatim{
+s = "hello world from Lua"
+for w in string.gmatch(s, "%a+") do
+  print(w)
+end
+}
+The next example collects all pairs @T{key=value} from the
+given string into a table:
+@verbatim{
+t = {}
+s = "from=world, to=Lua"
+for k, v in string.gmatch(s, "(%w+)=(%w+)") do
+  t[k] = v
+end
+}
+
+For this function, a caret @Char{^} at the start of a pattern does not
+work as an anchor, as this would prevent the iteration.
+
+}
+
+@LibEntry{string.gsub (s, pattern, repl [, n])|
+Returns a copy of @id{s}
+in which all (or the first @id{n}, if given)
+occurrences of the @id{pattern} @see{pm} have been
+replaced by a replacement string specified by @id{repl},
+which can be a string, a table, or a function.
+@id{gsub} also returns, as its second value,
+the total number of matches that occurred.
+The name @id{gsub} comes from @emph{Global SUBstitution}.
+
+If @id{repl} is a string, then its value is used for replacement.
+The @N{character @T{%}} works as an escape character:
+any sequence in @id{repl} of the form @T{%@rep{d}},
+with @rep{d} between 1 and 9,
+stands for the value of the @rep{d}-th captured substring.
+The sequence @T{%0} stands for the whole match.
+The sequence @T{%%} stands for a @N{single @T{%}}.
+
+If @id{repl} is a table, then the table is queried for every match,
+using the first capture as the key.
+
+If @id{repl} is a function, then this function is called every time a
+match occurs, with all captured substrings passed as arguments,
+in order.
+
+In any case,
+if the pattern specifies no captures,
+then it behaves as if the whole pattern was inside a capture.
+
+If the value returned by the table query or by the function call
+is a string or a number,
+then it is used as the replacement string;
+otherwise, if it is @Rw{false} or @nil,
+then there is no replacement
+(that is, the original match is kept in the string).
+
+Here are some examples:
+@verbatim{
+x = string.gsub("hello world", "(%w+)", "%1 %1")
+--> x="hello hello world world"
+
+x = string.gsub("hello world", "%w+", "%0 %0", 1)
+--> x="hello hello world"
+
+x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1")
+--> x="world hello Lua from"
+
+x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv)
+--> x="home = /home/roberto, user = roberto"
+
+x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s)
+      return load(s)()
+    end)
+--> x="4+5 = 9"
+
+local t = {name="lua", version="5.3"}
+x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t)
+--> x="lua-5.3.tar.gz"
+}
+
+}
+
+@LibEntry{string.len (s)|
+Receives a string and returns its length.
+The empty string @T{""} has length 0.
+Embedded zeros are counted,
+so @T{"a\000bc\000"} has length 5.
+
+}
+
+@LibEntry{string.lower (s)|
+Receives a string and returns a copy of this string with all
+uppercase letters changed to lowercase.
+All other characters are left unchanged.
+The definition of what an uppercase letter is depends on the current locale.
+
+}
+
+@LibEntry{string.match (s, pattern [, init])|
+Looks for the first @emph{match} of
+@id{pattern} @see{pm} in the string @id{s}.
+If it finds one, then @id{match} returns
+the captures from the pattern;
+otherwise it returns @nil.
+If @id{pattern} specifies no captures,
+then the whole match is returned.
+A third, optional numeric argument @id{init} specifies
+where to start the search;
+its default value @N{is 1} and can be negative.
+
+}
+
+@LibEntry{string.pack (fmt, v1, v2, @Cdots)|
+
+Returns a binary string containing the values @id{v1}, @id{v2}, etc.
+packed (that is, serialized in binary form)
+according to the format string @id{fmt} @see{pack}.
+
+}
+
+@LibEntry{string.packsize (fmt)|
+
+Returns the size of a string resulting from @Lid{string.pack}
+with the given format.
+The format string cannot have the variable-length options
+@Char{s} or @Char{z} @see{pack}.
+
+}
+
+@LibEntry{string.rep (s, n [, sep])|
+Returns a string that is the concatenation of @id{n} copies of
+the string @id{s} separated by the string @id{sep}.
+The default value for @id{sep} is the empty string
+(that is, no separator).
+Returns the empty string if @id{n} is not positive.
+
+(Note that it is very easy to exhaust the memory of your machine
+with a single call to this function.)
+
+}
+
+@LibEntry{string.reverse (s)|
+Returns a string that is the string @id{s} reversed.
+
+}
+
+@LibEntry{string.sub (s, i [, j])|
+Returns the substring of @id{s} that
+starts at @id{i}  and continues until @id{j};
+@id{i} and @id{j} can be negative.
+If @id{j} is absent, then it is assumed to be equal to @num{-1}
+(which is the same as the string length).
+In particular,
+the call @T{string.sub(s,1,j)} returns a prefix of @id{s}
+with length @id{j},
+and @T{string.sub(s, -i)} (for a positive @id{i})
+returns a suffix of @id{s}
+with length @id{i}.
+
+If, after the translation of negative indices,
+@id{i} is less than 1,
+it is corrected to 1.
+If @id{j} is greater than the string length,
+it is corrected to that length.
+If, after these corrections,
+@id{i} is greater than @id{j},
+the function returns the empty string.
+
+}
+
+@LibEntry{string.unpack (fmt, s [, pos])|
+
+Returns the values packed in string @id{s} @seeF{string.pack}
+according to the format string @id{fmt} @see{pack}.
+An optional @id{pos} marks where
+to start reading in @id{s} (default is 1).
+After the read values,
+this function also returns the index of the first unread byte in @id{s}.
+
+}
+
+@LibEntry{string.upper (s)|
+Receives a string and returns a copy of this string with all
+lowercase letters changed to uppercase.
+All other characters are left unchanged.
+The definition of what a lowercase letter is depends on the current locale.
+
+}
+
+
+@sect3{pm| @title{Patterns}
+
+Patterns in Lua are described by regular strings,
+which are interpreted as patterns by the pattern-matching functions
+@Lid{string.find},
+@Lid{string.gmatch},
+@Lid{string.gsub},
+and @Lid{string.match}.
+This section describes the syntax and the meaning
+(that is, what they match) of these strings.
+
+@sect4{@title{Character Class:}
+A @def{character class} is used to represent a set of characters.
+The following combinations are allowed in describing a character class:
+@description{
+
+@item{@rep{x}|
+(where @rep{x} is not one of the @emphx{magic characters}
+@T{^$()%.[]*+-?})
+represents the character @emph{x} itself.
+}
+
+@item{@T{.}| (a dot) represents all characters.}
+
+@item{@T{%a}| represents all letters.}
+
+@item{@T{%c}| represents all control characters.}
+
+@item{@T{%d}| represents all digits.}
+
+@item{@T{%g}| represents all printable characters except space.}
+
+@item{@T{%l}| represents all lowercase letters.}
+
+@item{@T{%p}| represents all punctuation characters.}
+
+@item{@T{%s}| represents all space characters.}
+
+@item{@T{%u}| represents all uppercase letters.}
+
+@item{@T{%w}| represents all alphanumeric characters.}
+
+@item{@T{%x}| represents all hexadecimal digits.}
+
+@item{@T{%@rep{x}}| (where @rep{x} is any non-alphanumeric character)
+represents the character @rep{x}.
+This is the standard way to escape the magic characters.
+Any non-alphanumeric character
+(including all punctuation characters, even the non-magical)
+can be preceded by a @Char{%}
+when used to represent itself in a pattern.
+}
+
+@item{@T{[@rep{set}]}|
+represents the class which is the union of all
+characters in @rep{set}.
+A range of characters can be specified by
+separating the end characters of the range,
+in ascending order, with a @Char{-}.
+All classes @T{%}@emph{x} described above can also be used as
+components in @rep{set}.
+All other characters in @rep{set} represent themselves.
+For example, @T{[%w_]} (or @T{[_%w]})
+represents all alphanumeric characters plus the underscore,
+@T{[0-7]} represents the octal digits,
+and @T{[0-7%l%-]} represents the octal digits plus
+the lowercase letters plus the @Char{-} character.
+
+You can put a closing square bracket in a set
+by positioning it as the first character in the set.
+You can put a hyphen in a set
+by positioning it as the first or the last character in the set.
+(You can also use an escape for both cases.)
+
+The interaction between ranges and classes is not defined.
+Therefore, patterns like @T{[%a-z]} or @T{[a-%%]}
+have no meaning.
+}
+
+@item{@T{[^@rep{set}]}|
+represents the complement of @rep{set},
+where @rep{set} is interpreted as above.
+}
+
+}
+For all classes represented by single letters (@T{%a}, @T{%c}, etc.),
+the corresponding uppercase letter represents the complement of the class.
+For instance, @T{%S} represents all non-space characters.
+
+The definitions of letter, space, and other character groups
+depend on the current locale.
+In particular, the class @T{[a-z]} may not be equivalent to @T{%l}.
+
+}
+
+@sect4{@title{Pattern Item:}
+A @def{pattern item} can be
+@itemize{
+
+@item{
+a single character class,
+which matches any single character in the class;
+}
+
+@item{
+a single character class followed by @Char{*},
+which matches zero or more repetitions of characters in the class.
+These repetition items will always match the longest possible sequence;
+}
+
+@item{
+a single character class followed by @Char{+},
+which matches one or more repetitions of characters in the class.
+These repetition items will always match the longest possible sequence;
+}
+
+@item{
+a single character class followed by @Char{-},
+which also matches zero or more repetitions of characters in the class.
+Unlike @Char{*},
+these repetition items will always match the shortest possible sequence;
+}
+
+@item{
+a single character class followed by @Char{?},
+which matches zero or one occurrence of a character in the class.
+It always matches one occurrence if possible;
+}
+
+@item{
+@T{%@rep{n}}, for @rep{n} between 1 and 9;
+such item matches a substring equal to the @rep{n}-th captured string
+(see below);
+}
+
+@item{
+@T{%b@rep{xy}}, where @rep{x} and @rep{y} are two distinct characters;
+such item matches strings that start @N{with @rep{x}}, end @N{with @rep{y}},
+and where the @rep{x} and @rep{y} are @emph{balanced}.
+This means that, if one reads the string from left to right,
+counting @M{+1} for an @rep{x} and @M{-1} for a @rep{y},
+the ending @rep{y} is the first @rep{y} where the count reaches 0.
+For instance, the item @T{%b()} matches expressions with
+balanced parentheses.
+}
+
+@item{
+@T{%f[@rep{set}]}, a @def{frontier pattern};
+such item matches an empty string at any position such that
+the next character belongs to @rep{set}
+and the previous character does not belong to @rep{set}.
+The set @rep{set} is interpreted as previously described.
+The beginning and the end of the subject are handled as if
+they were the character @Char{\0}.
+}
+
+}
+
+}
+
+@sect4{@title{Pattern:}
+A @def{pattern} is a sequence of pattern items.
+A caret @Char{^} at the beginning of a pattern anchors the match at the
+beginning of the subject string.
+A @Char{$} at the end of a pattern anchors the match at the
+end of the subject string.
+At other positions,
+@Char{^} and @Char{$} have no special meaning and represent themselves.
+
+}
+
+@sect4{@title{Captures:}
+A pattern can contain sub-patterns enclosed in parentheses;
+they describe @def{captures}.
+When a match succeeds, the substrings of the subject string
+that match captures are stored (@emph{captured}) for future use.
+Captures are numbered according to their left parentheses.
+For instance, in the pattern @T{"(a*(.)%w(%s*))"},
+the part of the string matching @T{"a*(.)%w(%s*)"} is
+stored as the first capture (and therefore has @N{number 1});
+the character matching @St{.} is captured with @N{number 2},
+and the part matching @St{%s*} has @N{number 3}.
+
+As a special case, the empty capture @T{()} captures
+the current string position (a number).
+For instance, if we apply the pattern @T{"()aa()"} on the
+string @T{"flaaap"}, there will be two captures: @N{3 and 5}.
+
+}
+
+}
+
+
+@sect3{pack| @title{Format Strings for Pack and Unpack}
+
+The first argument to @Lid{string.pack},
+@Lid{string.packsize}, and @Lid{string.unpack}
+is a format string,
+which describes the layout of the structure being created or read.
+
+A format string is a sequence of conversion options.
+The conversion options are as follows:
+@description{
+@item{@T{<}|sets little endian}
+@item{@T{>}|sets big endian}
+@item{@T{=}|sets native endian}
+@item{@T{![@rep{n}]}|sets maximum alignment to @id{n}
+(default is native alignment)}
+@item{@T{b}|a signed byte (@id{char})}
+@item{@T{B}|an unsigned byte (@id{char})}
+@item{@T{h}|a signed @id{short} (native size)}
+@item{@T{H}|an unsigned @id{short} (native size)}
+@item{@T{l}|a signed @id{long} (native size)}
+@item{@T{L}|an unsigned @id{long} (native size)}
+@item{@T{j}|a @id{lua_Integer}}
+@item{@T{J}|a @id{lua_Unsigned}}
+@item{@T{T}|a @id{size_t} (native size)}
+@item{@T{i[@rep{n}]}|a signed @id{int} with @id{n} bytes
+(default is native size)}
+@item{@T{I[@rep{n}]}|an unsigned @id{int} with @id{n} bytes
+(default is native size)}
+@item{@T{f}|a @id{float} (native size)}
+@item{@T{d}|a @id{double} (native size)}
+@item{@T{n}|a @id{lua_Number}}
+@item{@T{c@rep{n}}|a fixed-sized string with @id{n} bytes}
+@item{@T{z}|a zero-terminated string}
+@item{@T{s[@emph{n}]}|a string preceded by its length
+coded as an unsigned integer with @id{n} bytes
+(default is a @id{size_t})}
+@item{@T{x}|one byte of padding}
+@item{@T{X@rep{op}}|an empty item that aligns
+according to option @id{op}
+(which is otherwise ignored)}
+@item{@Char{ }|(empty space) ignored}
+}
+(A @St{[@rep{n}]} means an optional integral numeral.)
+Except for padding, spaces, and configurations
+(options @St{xX <=>!}),
+each option corresponds to an argument (in @Lid{string.pack})
+or a result (in @Lid{string.unpack}).
+
+For options @St{!@rep{n}}, @St{s@rep{n}}, @St{i@rep{n}}, and @St{I@rep{n}},
+@id{n} can be any integer between 1 and 16.
+All integral options check overflows;
+@Lid{string.pack} checks whether the given value fits in the given size;
+@Lid{string.unpack} checks whether the read value fits in a Lua integer.
+
+Any format string starts as if prefixed by @St{!1=},
+that is,
+with maximum alignment of 1 (no alignment)
+and native endianness.
+
+Alignment works as follows:
+For each option,
+the format gets extra padding until the data starts
+at an offset that is a multiple of the minimum between the
+option size and the maximum alignment;
+this minimum must be a power of 2.
+Options @St{c} and @St{z} are not aligned;
+option @St{s} follows the alignment of its starting integer.
+
+All padding is filled with zeros by @Lid{string.pack}
+(and ignored by @Lid{string.unpack}).
+
+}
+
+}
+
+@sect2{utf8| @title{UTF-8 Support}
+
+This library provides basic support for @x{UTF-8} encoding.
+It provides all its functions inside the table @defid{utf8}.
+This library does not provide any support for @x{Unicode} other
+than the handling of the encoding.
+Any operation that needs the meaning of a character,
+such as character classification, is outside its scope.
+
+Unless stated otherwise,
+all functions that expect a byte position as a parameter
+assume that the given position is either the start of a byte sequence
+or one plus the length of the subject string.
+As in the string library,
+negative indices count from the end of the string.
+
+
+@LibEntry{utf8.char (@Cdots)|
+Receives zero or more integers,
+converts each one to its corresponding UTF-8 byte sequence
+and returns a string with the concatenation of all these sequences.
+
+}
+
+@LibEntry{utf8.charpattern|
+The pattern (a string, not a function) @St{[\0-\x7F\xC2-\xF4][\x80-\xBF]*}
+@see{pm},
+which matches exactly one UTF-8 byte sequence,
+assuming that the subject is a valid UTF-8 string.
+
+}
+
+@LibEntry{utf8.codes (s)|
+
+Returns values so that the construction
+@verbatim{
+for p, c in utf8.codes(s) do @rep{body} end
+}
+will iterate over all characters in string @id{s},
+with @id{p} being the position (in bytes) and @id{c} the code point
+of each character.
+It raises an error if it meets any invalid byte sequence.
+
+}
+
+@LibEntry{utf8.codepoint (s [, i [, j]])|
+Returns the codepoints (as integers) from all characters in @id{s}
+that start between byte position @id{i} and @id{j} (both included).
+The default for @id{i} is 1 and for @id{j} is @id{i}.
+It raises an error if it meets any invalid byte sequence.
+
+}
+
+@LibEntry{utf8.len (s [, i [, j]])|
+Returns the number of UTF-8 characters in string @id{s}
+that start between positions @id{i} and @id{j} (both inclusive).
+The default for @id{i} is @num{1} and for @id{j} is @num{-1}.
+If it finds any invalid byte sequence,
+returns a false value plus the position of the first invalid byte.
+
+}
+
+@LibEntry{utf8.offset (s, n [, i])|
+Returns the position (in bytes) where the encoding of the
+@id{n}-th character of @id{s}
+(counting from position @id{i}) starts.
+A negative @id{n} gets characters before position @id{i}.
+The default for @id{i} is 1 when @id{n} is non-negative
+and @T{#s + 1} otherwise,
+so that @T{utf8.offset(s, -n)} gets the offset of the
+@id{n}-th character from the end of the string.
+If the specified character is neither in the subject
+nor right after its end,
+the function returns @nil.
+
+As a special case,
+when @id{n} is 0 the function returns the start of the encoding
+of the character that contains the @id{i}-th byte of @id{s}.
+
+This function assumes that @id{s} is a valid UTF-8 string.
+
+}
+
+}
+
+@sect2{tablib| @title{Table Manipulation}
+
+This library provides generic functions for table manipulation.
+It provides all its functions inside the table @defid{table}.
+
+Remember that, whenever an operation needs the length of a table,
+all caveats about the length operator apply @see{len-op}.
+All functions ignore non-numeric keys
+in the tables given as arguments.
+
+
+@LibEntry{table.concat (list [, sep [, i [, j]]])|
+
+Given a list where all elements are strings or numbers,
+returns the string @T{list[i]..sep..list[i+1] @Cdots sep..list[j]}.
+The default value for @id{sep} is the empty string,
+the default for @id{i} is 1,
+and the default for @id{j} is @T{#list}.
+If @id{i} is greater than @id{j}, returns the empty string.
+
+}
+
+@LibEntry{table.insert (list, [pos,] value)|
+
+Inserts element @id{value} at position @id{pos} in @id{list},
+shifting up the elements
+@T{list[pos], list[pos+1], @Cdots, list[#list]}.
+The default value for @id{pos} is @T{#list+1},
+so that a call @T{table.insert(t,x)} inserts @id{x} at the end
+of list @id{t}.
+
+}
+
+@LibEntry{table.move (a1, f, e, t [,a2])|
+
+Moves elements from table @id{a1} to table @id{a2},
+performing the equivalent to the following
+multiple assignment:
+@T{a2[t],@Cdots = a1[f],@Cdots,a1[e]}.
+The default for @id{a2} is @id{a1}.
+The destination range can overlap with the source range.
+The number of elements to be moved must fit in a Lua integer.
+
+Returns the destination table @id{a2}.
+
+}
+
+@LibEntry{table.pack (@Cdots)|
+
+Returns a new table with all arguments stored into keys 1, 2, etc.
+and with a field @St{n} with the total number of arguments.
+Note that the resulting table may not be a sequence.
+
+}
+
+@LibEntry{table.remove (list [, pos])|
+
+Removes from @id{list} the element at position @id{pos},
+returning the value of the removed element.
+When @id{pos} is an integer between 1 and @T{#list},
+it shifts down the elements
+@T{list[pos+1], list[pos+2], @Cdots, list[#list]}
+and erases element @T{list[#list]};
+The index @id{pos} can also be 0 when @T{#list} is 0,
+or @T{#list + 1};
+in those cases, the function erases the element @T{list[pos]}.
+
+The default value for @id{pos} is @T{#list},
+so that a call @T{table.remove(l)} removes the last element
+of list @id{l}.
+
+}
+
+@LibEntry{table.sort (list [, comp])|
+
+Sorts list elements in a given order, @emph{in-place},
+from @T{list[1]} to @T{list[#list]}.
+If @id{comp} is given,
+then it must be a function that receives two list elements
+and returns true when the first element must come
+before the second in the final order
+(so that, after the sort,
+@T{i < j} implies @T{not comp(list[j],list[i])}).
+If @id{comp} is not given,
+then the standard Lua operator @T{<} is used instead.
+
+Note that the @id{comp} function must define
+a strict partial order over the elements in the list;
+that is, it must be asymmetric and transitive.
+Otherwise, no valid sort may be possible.
+
+The sort algorithm is not stable:
+elements considered equal by the given order
+may have their relative positions changed by the sort.
+
+}
+
+@LibEntry{table.unpack (list [, i [, j]])|
+
+Returns the elements from the given list.
+This function is equivalent to
+@verbatim{
+return list[i], list[i+1], @Cdots, list[j]
+}
+By default, @id{i} @N{is 1} and @id{j} is @T{#list}.
+
+}
+
+}
+
+@sect2{mathlib| @title{Mathematical Functions}
+
+This library provides basic mathematical functions.
+It provides all its functions and constants inside the table @defid{math}.
+Functions with the annotation @St{integer/float} give
+integer results for integer arguments
+and float results for float (or mixed) arguments.
+Rounding functions
+(@Lid{math.ceil}, @Lid{math.floor}, and @Lid{math.modf})
+return an integer when the result fits in the range of an integer,
+or a float otherwise.
+
+@LibEntry{math.abs (x)|
+
+Returns the absolute value of @id{x}. (integer/float)
+
+}
+
+@LibEntry{math.acos (x)|
+
+Returns the arc cosine of @id{x} (in radians).
+
+}
+
+@LibEntry{math.asin (x)|
+
+Returns the arc sine of @id{x} (in radians).
+
+}
+
+@LibEntry{math.atan (y [, x])|
+
+@index{atan2}
+Returns the arc tangent of @T{y/x} (in radians),
+but uses the signs of both arguments to find the
+quadrant of the result.
+(It also handles correctly the case of @id{x} being zero.)
+
+The default value for @id{x} is 1,
+so that the call @T{math.atan(y)}
+returns the arc tangent of @id{y}.
+
+}
+
+@LibEntry{math.ceil (x)|
+
+Returns the smallest integral value larger than or equal to @id{x}.
+
+}
+
+@LibEntry{math.cos (x)|
+
+Returns the cosine of @id{x} (assumed to be in radians).
+
+}
+
+@LibEntry{math.deg (x)|
+
+Converts the angle @id{x} from radians to degrees.
+
+}
+
+@LibEntry{math.exp (x)|
+
+Returns the value @M{e@sp{x}}
+(where @id{e} is the base of natural logarithms).
+
+}
+
+@LibEntry{math.floor (x)|
+
+Returns the largest integral value smaller than or equal to @id{x}.
+
+}
+
+@LibEntry{math.fmod (x, y)|
+
+Returns the remainder of the division of @id{x} by @id{y}
+that rounds the quotient towards zero. (integer/float)
+
+}
+
+@LibEntry{math.huge|
+
+The float value @idx{HUGE_VAL},
+a value larger than any other numeric value.
+
+}
+
+@LibEntry{math.log (x [, base])|
+
+Returns the logarithm of @id{x} in the given base.
+The default for @id{base} is @M{e}
+(so that the function returns the natural logarithm of @id{x}).
+
+}
+
+@LibEntry{math.max (x, @Cdots)|
+
+Returns the argument with the maximum value,
+according to the Lua operator @T{<}. (integer/float)
+
+}
+
+@LibEntry{math.maxinteger|
+An integer with the maximum value for an integer.
+
+}
+
+@LibEntry{math.min (x, @Cdots)|
+
+Returns the argument with the minimum value,
+according to the Lua operator @T{<}. (integer/float)
+
+}
+
+@LibEntry{math.mininteger|
+An integer with the minimum value for an integer.
+
+}
+
+@LibEntry{math.modf (x)|
+
+Returns the integral part of @id{x} and the fractional part of @id{x}.
+Its second result is always a float.
+
+}
+
+@LibEntry{math.pi|
+
+The value of @M{@pi}.
+
+}
+
+@LibEntry{math.rad (x)|
+
+Converts the angle @id{x} from degrees to radians.
+
+}
+
+@LibEntry{math.random ([m [, n]])|
+
+When called without arguments,
+returns a pseudo-random float with uniform distribution
+in the range @C{(} @M{[0,1)}.  @C{]}
+When called with two integers @id{m} and @id{n},
+@id{math.random} returns a pseudo-random integer
+with uniform distribution in the range @M{[m, n]}.
+(The value @M{n-m} cannot be negative and must fit in a Lua integer.)
+The call @T{math.random(n)} is equivalent to @T{math.random(1,n)}.
+
+This function is an interface to the underling
+pseudo-random generator function provided by C.
+
+}
+
+@LibEntry{math.randomseed (x)|
+
+Sets @id{x} as the @Q{seed}
+for the pseudo-random generator:
+equal seeds produce equal sequences of numbers.
+
+}
+
+@LibEntry{math.sin (x)|
+
+Returns the sine of @id{x} (assumed to be in radians).
+
+}
+
+@LibEntry{math.sqrt (x)|
+
+Returns the square root of @id{x}.
+(You can also use the expression @T{x^0.5} to compute this value.)
+
+}
+
+@LibEntry{math.tan (x)|
+
+Returns the tangent of @id{x} (assumed to be in radians).
+
+}
+
+@LibEntry{math.tointeger (x)|
+
+If the value @id{x} is convertible to an integer,
+returns that integer.
+Otherwise, returns @nil.
+
+}
+
+@LibEntry{math.type (x)|
+
+Returns @St{integer} if @id{x} is an integer,
+@St{float} if it is a float,
+or @nil if @id{x} is not a number.
+
+}
+
+@LibEntry{math.ult (m, n)|
+
+Returns a boolean,
+true if and only if integer @id{m} is below integer @id{n} when
+they are compared as @x{unsigned integers}.
+
+}
+
+}
+
+
+@sect2{iolib| @title{Input and Output Facilities}
+
+The I/O library provides two different styles for file manipulation.
+The first one uses implicit file handles;
+that is, there are operations to set a default input file and a
+default output file,
+and all input/output operations are over these default files.
+The second style uses explicit file handles.
+
+When using implicit file handles,
+all operations are supplied by table @defid{io}.
+When using explicit file handles,
+the operation @Lid{io.open} returns a file handle
+and then all operations are supplied as methods of the file handle.
+
+The table @id{io} also provides
+three predefined file handles with their usual meanings from C:
+@defid{io.stdin}, @defid{io.stdout}, and @defid{io.stderr}.
+The I/O library never closes these files.
+
+Unless otherwise stated,
+all I/O functions return @nil on failure
+(plus an error message as a second result and
+a system-dependent error code as a third result)
+and some value different from @nil on success.
+In non-POSIX systems,
+the computation of the error message and error code
+in case of errors
+may be not @x{thread safe},
+because they rely on the global C variable @id{errno}.
+
+@LibEntry{io.close ([file])|
+
+Equivalent to @T{file:close()}.
+Without a @id{file}, closes the default output file.
+
+}
+
+@LibEntry{io.flush ()|
+
+Equivalent to @T{io.output():flush()}.
+
+}
+
+@LibEntry{io.input ([file])|
+
+When called with a file name, it opens the named file (in text mode),
+and sets its handle as the default input file.
+When called with a file handle,
+it simply sets this file handle as the default input file.
+When called without arguments,
+it returns the current default input file.
+
+In case of errors this function raises the error,
+instead of returning an error code.
+
+}
+
+@LibEntry{io.lines ([filename, @Cdots])|
+
+Opens the given file name in read mode
+and returns an iterator function that
+works like @T{file:lines(@Cdots)} over the opened file.
+When the iterator function detects the end of file,
+it returns no values (to finish the loop) and automatically closes the file.
+
+The call @T{io.lines()} (with no file name) is equivalent
+to @T{io.input():lines("*l")};
+that is, it iterates over the lines of the default input file.
+In this case, the iterator does not close the file when the loop ends.
+
+In case of errors this function raises the error,
+instead of returning an error code.
+
+}
+
+@LibEntry{io.open (filename [, mode])|
+
+This function opens a file,
+in the mode specified in the string @id{mode}.
+In case of success,
+it returns a new file handle.
+
+The @id{mode} string can be any of the following:
+@description{
+@item{@St{r}| read mode (the default);}
+@item{@St{w}| write mode;}
+@item{@St{a}| append mode;}
+@item{@St{r+}| update mode, all previous data is preserved;}
+@item{@St{w+}| update mode, all previous data is erased;}
+@item{@St{a+}| append update mode, previous data is preserved,
+  writing is only allowed at the end of file.}
+}
+The @id{mode} string can also have a @Char{b} at the end,
+which is needed in some systems to open the file in binary mode.
+
+}
+
+@LibEntry{io.output ([file])|
+
+Similar to @Lid{io.input}, but operates over the default output file.
+
+}
+
+@LibEntry{io.popen (prog [, mode])|
+
+This function is system dependent and is not available
+on all platforms.
+
+Starts program @id{prog} in a separated process and returns
+a file handle that you can use to read data from this program
+(if @id{mode} is @T{"r"}, the default)
+or to write data to this program
+(if @id{mode} is @T{"w"}).
+
+}
+
+@LibEntry{io.read (@Cdots)|
+
+Equivalent to @T{io.input():read(@Cdots)}.
+
+}
+
+@LibEntry{io.tmpfile ()|
+
+In case of success,
+returns a handle for a temporary file.
+This file is opened in update mode
+and it is automatically removed when the program ends.
+
+}
+
+@LibEntry{io.type (obj)|
+
+Checks whether @id{obj} is a valid file handle.
+Returns the string @T{"file"} if @id{obj} is an open file handle,
+@T{"closed file"} if @id{obj} is a closed file handle,
+or @nil if @id{obj} is not a file handle.
+
+}
+
+@LibEntry{io.write (@Cdots)|
+
+Equivalent to @T{io.output():write(@Cdots)}.
+
+
+}
+
+@LibEntry{file:close ()|
+
+Closes @id{file}.
+Note that files are automatically closed when
+their handles are garbage collected,
+but that takes an unpredictable amount of time to happen.
+
+When closing a file handle created with @Lid{io.popen},
+@Lid{file:close} returns the same values
+returned by @Lid{os.execute}.
+
+}
+
+@LibEntry{file:flush ()|
+
+Saves any written data to @id{file}.
+
+}
+
+@LibEntry{file:lines (@Cdots)|
+
+Returns an iterator function that,
+each time it is called,
+reads the file according to the given formats.
+When no format is given,
+uses @St{l} as a default.
+As an example, the construction
+@verbatim{
+for c in file:lines(1) do @rep{body} end
+}
+will iterate over all characters of the file,
+starting at the current position.
+Unlike @Lid{io.lines}, this function does not close the file
+when the loop ends.
+
+In case of errors this function raises the error,
+instead of returning an error code.
+
+}
+
+@LibEntry{file:read (@Cdots)|
+
+Reads the file @id{file},
+according to the given formats, which specify what to read.
+For each format,
+the function returns a string or a number with the characters read,
+or @nil if it cannot read data with the specified format.
+(In this latter case,
+the function does not read subsequent formats.)
+When called without formats,
+it uses a default format that reads the next line
+(see below).
+
+The available formats are
+@description{
+
+@item{@St{n}|
+reads a numeral and returns it as a float or an integer,
+following the lexical conventions of Lua.
+(The numeral may have leading spaces and a sign.)
+This format always reads the longest input sequence that
+is a valid prefix for a numeral;
+if that prefix does not form a valid numeral
+(e.g., an empty string, @St{0x}, or @St{3.4e-}),
+it is discarded and the function returns @nil.
+}
+
+@item{@St{a}|
+reads the whole file, starting at the current position.
+On end of file, it returns the empty string.
+}
+
+@item{@St{l}|
+reads the next line skipping the end of line,
+returning @nil on end of file.
+This is the default format.
+}
+
+@item{@St{L}|
+reads the next line keeping the end-of-line character (if present),
+returning @nil on end of file.
+}
+
+@item{@emph{number}|
+reads a string with up to this number of bytes,
+returning @nil on end of file.
+If @id{number} is zero,
+it reads nothing and returns an empty string,
+or @nil on end of file.
+}
+
+}
+The formats @St{l} and @St{L} should be used only for text files.
+
+}
+
+@LibEntry{file:seek ([whence [, offset]])|
+
+Sets and gets the file position,
+measured from the beginning of the file,
+to the position given by @id{offset} plus a base
+specified by the string @id{whence}, as follows:
+@description{
+@item{@St{set}| base is position 0 (beginning of the file);}
+@item{@St{cur}| base is current position;}
+@item{@St{end}| base is end of file;}
+}
+In case of success, @id{seek} returns the final file position,
+measured in bytes from the beginning of the file.
+If @id{seek} fails, it returns @nil,
+plus a string describing the error.
+
+The default value for @id{whence} is @T{"cur"},
+and for @id{offset} is 0.
+Therefore, the call @T{file:seek()} returns the current
+file position, without changing it;
+the call @T{file:seek("set")} sets the position to the
+beginning of the file (and returns 0);
+and the call @T{file:seek("end")} sets the position to the
+end of the file, and returns its size.
+
+}
+
+@LibEntry{file:setvbuf (mode [, size])|
+
+Sets the buffering mode for an output file.
+There are three available modes:
+@description{
+
+@item{@St{no}|
+no buffering; the result of any output operation appears immediately.
+}
+
+@item{@St{full}|
+full buffering; output operation is performed only
+when the buffer is full or when
+you explicitly @T{flush} the file @seeF{io.flush}.
+}
+
+@item{@St{line}|
+line buffering; output is buffered until a newline is output
+or there is any input from some special files
+(such as a terminal device).
+}
+
+}
+For the last two cases, @id{size}
+specifies the size of the buffer, in bytes.
+The default is an appropriate size.
+
+}
+
+@LibEntry{file:write (@Cdots)|
+
+Writes the value of each of its arguments to @id{file}.
+The arguments must be strings or numbers.
+
+In case of success, this function returns @id{file}.
+Otherwise it returns @nil plus a string describing the error.
+
+}
+
+}
+
+@sect2{oslib| @title{Operating System Facilities}
+
+This library is implemented through table @defid{os}.
+
+
+@LibEntry{os.clock ()|
+
+Returns an approximation of the amount in seconds of CPU time
+used by the program.
+
+}
+
+@LibEntry{os.date ([format [, time]])|
+
+Returns a string or a table containing date and time,
+formatted according to the given string @id{format}.
+
+If the @id{time} argument is present,
+this is the time to be formatted
+(see the @Lid{os.time} function for a description of this value).
+Otherwise, @id{date} formats the current time.
+
+If @id{format} starts with @Char{!},
+then the date is formatted in Coordinated Universal Time.
+After this optional character,
+if @id{format} is the string @St{*t},
+then @id{date} returns a table with the following fields:
+@id{year}, @id{month} (1@En{}12), @id{day} (1@En{}31),
+@id{hour} (0@En{}23), @id{min} (0@En{}59), @id{sec} (0@En{}61),
+@id{wday} (weekday, 1@En{}7, Sunday @N{is 1}),
+@id{yday} (day of the year, 1@En{}366),
+and @id{isdst} (daylight saving flag, a boolean).
+This last field may be absent
+if the information is not available.
+
+If @id{format} is not @St{*t},
+then @id{date} returns the date as a string,
+formatted according to the same rules as the @ANSI{strftime}.
+
+When called without arguments,
+@id{date} returns a reasonable date and time representation that depends on
+the host system and on the current locale.
+(More specifically, @T{os.date()} is equivalent to @T{os.date("%c")}.)
+
+In non-POSIX systems,
+this function may be not @x{thread safe}
+because of its reliance on @CId{gmtime} and @CId{localtime}.
+
+}
+
+@LibEntry{os.difftime (t2, t1)|
+
+Returns the difference, in seconds,
+from time @id{t1} to time @id{t2}
+(where the times are values returned by @Lid{os.time}).
+In @x{POSIX}, @x{Windows}, and some other systems,
+this value is exactly @id{t2}@M{-}@id{t1}.
+
+}
+
+@LibEntry{os.execute ([command])|
+
+This function is equivalent to the @ANSI{system}.
+It passes @id{command} to be executed by an operating system shell.
+Its first result is @true
+if the command terminated successfully,
+or @nil otherwise.
+After this first result
+the function returns a string plus a number,
+as follows:
+@description{
+
+@item{@St{exit}|
+the command terminated normally;
+the following number is the exit status of the command.
+}
+
+@item{@St{signal}|
+the command was terminated by a signal;
+the following number is the signal that terminated the command.
+}
+
+}
+
+When called without a @id{command},
+@id{os.execute} returns a boolean that is true if a shell is available.
+
+}
+
+@LibEntry{os.exit ([code [, close]])|
+
+Calls the @ANSI{exit} to terminate the host program.
+If @id{code} is @Rw{true},
+the returned status is @idx{EXIT_SUCCESS};
+if @id{code} is @Rw{false},
+the returned status is @idx{EXIT_FAILURE};
+if @id{code} is a number,
+the returned status is this number.
+The default value for @id{code} is @Rw{true}.
+
+If the optional second argument @id{close} is true,
+closes the Lua state before exiting.
+
+}
+
+@LibEntry{os.getenv (varname)|
+
+Returns the value of the process environment variable @id{varname},
+or @nil if the variable is not defined.
+
+}
+
+@LibEntry{os.remove (filename)|
+
+Deletes the file (or empty directory, on @x{POSIX} systems)
+with the given name.
+If this function fails, it returns @nil,
+plus a string describing the error and the error code.
+Otherwise, it returns true.
+
+}
+
+@LibEntry{os.rename (oldname, newname)|
+
+Renames the file or directory named @id{oldname} to @id{newname}.
+If this function fails, it returns @nil,
+plus a string describing the error and the error code.
+Otherwise, it returns true.
+
+}
+
+@LibEntry{os.setlocale (locale [, category])|
+
+Sets the current locale of the program.
+@id{locale} is a system-dependent string specifying a locale;
+@id{category} is an optional string describing which category to change:
+@T{"all"}, @T{"collate"}, @T{"ctype"},
+@T{"monetary"}, @T{"numeric"}, or @T{"time"};
+the default category is @T{"all"}.
+The function returns the name of the new locale,
+or @nil if the request cannot be honored.
+
+If @id{locale} is the empty string,
+the current locale is set to an implementation-defined native locale.
+If @id{locale} is the string @St{C},
+the current locale is set to the standard C locale.
+
+When called with @nil as the first argument,
+this function only returns the name of the current locale
+for the given category.
+
+This function may be not @x{thread safe}
+because of its reliance on @CId{setlocale}.
+
+}
+
+@LibEntry{os.time ([table])|
+
+Returns the current time when called without arguments,
+or a time representing the local date and time specified by the given table.
+This table must have fields @id{year}, @id{month}, and @id{day},
+and may have fields
+@id{hour} (default is 12),
+@id{min} (default is 0),
+@id{sec} (default is 0),
+and @id{isdst} (default is @nil).
+Other fields are ignored.
+For a description of these fields, see the @Lid{os.date} function.
+
+The values in these fields do not need to be inside their valid ranges.
+For instance, if @id{sec} is -10,
+it means -10 seconds from the time specified by the other fields;
+if @id{hour} is 1000,
+it means +1000 hours from the time specified by the other fields.
+
+The returned value is a number, whose meaning depends on your system.
+In @x{POSIX}, @x{Windows}, and some other systems,
+this number counts the number
+of seconds since some given start time (the @Q{epoch}).
+In other systems, the meaning is not specified,
+and the number returned by @id{time} can be used only as an argument to
+@Lid{os.date} and @Lid{os.difftime}.
+
+}
+
+@LibEntry{os.tmpname ()|
+
+Returns a string with a file name that can
+be used for a temporary file.
+The file must be explicitly opened before its use
+and explicitly removed when no longer needed.
+
+In @x{POSIX} systems,
+this function also creates a file with that name,
+to avoid security risks.
+(Someone else might create the file with wrong permissions
+in the time between getting the name and creating the file.)
+You still have to open the file to use it
+and to remove it (even if you do not use it).
+
+When possible,
+you may prefer to use @Lid{io.tmpfile},
+which automatically removes the file when the program ends.
+
+}
+
+}
+
+@sect2{debuglib| @title{The Debug Library}
+
+This library provides
+the functionality of the @link{debugI|debug interface} to Lua programs.
+You should exert care when using this library.
+Several of its functions
+violate basic assumptions about Lua code
+(e.g., that variables local to a function
+cannot be accessed from outside;
+that userdata metatables cannot be changed by Lua code;
+that Lua programs do not crash)
+and therefore can compromise otherwise secure code.
+Moreover, some functions in this library may be slow.
+
+All functions in this library are provided
+inside the @defid{debug} table.
+All functions that operate over a thread
+have an optional first argument which is the
+thread to operate over.
+The default is always the current thread.
+
+
+@LibEntry{debug.debug ()|
+
+Enters an interactive mode with the user,
+running each string that the user enters.
+Using simple commands and other debug facilities,
+the user can inspect global and local variables,
+change their values, evaluate expressions, and so on.
+A line containing only the word @id{cont} finishes this function,
+so that the caller continues its execution.
+
+Note that commands for @id{debug.debug} are not lexically nested
+within any function and so have no direct access to local variables.
+
+}
+
+@LibEntry{debug.gethook ([thread])|
+
+Returns the current hook settings of the thread, as three values:
+the current hook function, the current hook mask,
+and the current hook count
+(as set by the @Lid{debug.sethook} function).
+
+}
+
+@LibEntry{debug.getinfo ([thread,] f [, what])|
+
+Returns a table with information about a function.
+You can give the function directly
+or you can give a number as the value of @id{f},
+which means the function running at level @id{f} of the call stack
+of the given thread:
+@N{level 0} is the current function (@id{getinfo} itself);
+@N{level 1} is the function that called @id{getinfo}
+(except for tail calls, which do not count on the stack);
+and so on.
+If @id{f} is a number larger than the number of active functions,
+then @id{getinfo} returns @nil.
+
+The returned table can contain all the fields returned by @Lid{lua_getinfo},
+with the string @id{what} describing which fields to fill in.
+The default for @id{what} is to get all information available,
+except the table of valid lines.
+If present,
+the option @Char{f}
+adds a field named @id{func} with the function itself.
+If present,
+the option @Char{L}
+adds a field named @id{activelines} with the table of
+valid lines.
+
+For instance, the expression @T{debug.getinfo(1,"n").name} returns
+a name for the current function,
+if a reasonable name can be found,
+and the expression @T{debug.getinfo(print)}
+returns a table with all available information
+about the @Lid{print} function.
+
+}
+
+@LibEntry{debug.getlocal ([thread,] f, local)|
+
+This function returns the name and the value of the local variable
+with index @id{local} of the function at level @id{f} of the stack.
+This function accesses not only explicit local variables,
+but also parameters, temporaries, etc.
+
+The first parameter or local variable has @N{index 1}, and so on,
+following the order that they are declared in the code,
+counting only the variables that are active
+in the current scope of the function.
+Negative indices refer to vararg arguments;
+@num{-1} is the first vararg argument.
+The function returns @nil if there is no variable with the given index,
+and raises an error when called with a level out of range.
+(You can call @Lid{debug.getinfo} to check whether the level is valid.)
+
+Variable names starting with @Char{(} (open parenthesis) @C{)}
+represent variables with no known names
+(internal variables such as loop control variables,
+and variables from chunks saved without debug information).
+
+The parameter @id{f} may also be a function.
+In that case, @id{getlocal} returns only the name of function parameters.
+
+}
+
+@LibEntry{debug.getmetatable (value)|
+
+Returns the metatable of the given @id{value}
+or @nil if it does not have a metatable.
+
+}
+
+@LibEntry{debug.getregistry ()|
+
+Returns the registry table @see{registry}.
+
+}
+
+@LibEntry{debug.getupvalue (f, up)|
+
+This function returns the name and the value of the upvalue
+with index @id{up} of the function @id{f}.
+The function returns @nil if there is no upvalue with the given index.
+
+Variable names starting with @Char{(} (open parenthesis) @C{)}
+represent variables with no known names
+(variables from chunks saved without debug information).
+
+}
+
+@LibEntry{debug.getuservalue (u)|
+
+Returns the Lua value associated to @id{u}.
+If @id{u} is not a full userdata,
+returns @nil.
+
+}
+
+@LibEntry{debug.sethook ([thread,] hook, mask [, count])|
+
+Sets the given function as a hook.
+The string @id{mask} and the number @id{count} describe
+when the hook will be called.
+The string mask may have any combination of the following characters,
+with the given meaning:
+@description{
+@item{@Char{c}| the hook is called every time Lua calls a function;}
+@item{@Char{r}| the hook is called every time Lua returns from a function;}
+@item{@Char{l}| the hook is called every time Lua enters a new line of code.}
+}
+Moreover,
+with a @id{count} different from zero,
+the hook is called also after every @id{count} instructions.
+
+When called without arguments,
+@Lid{debug.sethook} turns off the hook.
+
+When the hook is called, its first argument is a string
+describing the event that has triggered its call:
+@T{"call"} (or @T{"tail call"}),
+@T{"return"},
+@T{"line"}, and @T{"count"}.
+For line events,
+the hook also gets the new line number as its second parameter.
+Inside a hook,
+you can call @id{getinfo} with @N{level 2} to get more information about
+the running function
+(@N{level 0} is the @id{getinfo} function,
+and @N{level 1} is the hook function).
+
+}
+
+@LibEntry{debug.setlocal ([thread,] level, local, value)|
+
+This function assigns the value @id{value} to the local variable
+with index @id{local} of the function at level @id{level} of the stack.
+The function returns @nil if there is no local
+variable with the given index,
+and raises an error when called with a @id{level} out of range.
+(You can call @id{getinfo} to check whether the level is valid.)
+Otherwise, it returns the name of the local variable.
+
+See @Lid{debug.getlocal} for more information about
+variable indices and names.
+
+}
+
+@LibEntry{debug.setmetatable (value, table)|
+
+Sets the metatable for the given @id{value} to the given @id{table}
+(which can be @nil).
+Returns @id{value}.
+
+}
+
+@LibEntry{debug.setupvalue (f, up, value)|
+
+This function assigns the value @id{value} to the upvalue
+with index @id{up} of the function @id{f}.
+The function returns @nil if there is no upvalue
+with the given index.
+Otherwise, it returns the name of the upvalue.
+
+}
+
+@LibEntry{debug.setuservalue (udata, value)|
+
+Sets the given @id{value} as
+the Lua value associated to the given @id{udata}.
+@id{udata} must be a full userdata.
+
+Returns @id{udata}.
+
+}
+
+@LibEntry{debug.traceback ([thread,] [message [, level]])|
+
+If @id{message} is present but is neither a string nor @nil,
+this function returns @id{message} without further processing.
+Otherwise,
+it returns a string with a traceback of the call stack.
+The optional @id{message} string is appended
+at the beginning of the traceback.
+An optional @id{level} number tells at which level
+to start the traceback
+(default is 1, the function calling @id{traceback}).
+
+}
+
+@LibEntry{debug.upvalueid (f, n)|
+
+Returns a unique identifier (as a light userdata)
+for the upvalue numbered @id{n}
+from the given function.
+
+These unique identifiers allow a program to check whether different
+closures share upvalues.
+Lua closures that share an upvalue
+(that is, that access a same external local variable)
+will return identical ids for those upvalue indices.
+
+}
+
+@LibEntry{debug.upvaluejoin (f1, n1, f2, n2)|
+
+Make the @id{n1}-th upvalue of the Lua closure @id{f1}
+refer to the @id{n2}-th upvalue of the Lua closure @id{f2}.
+
+}
+
+}
+
+}
+
+
+@C{-------------------------------------------------------------------------}
+@sect1{lua-sa| @title{Lua Standalone}
+
+Although Lua has been designed as an extension language,
+to be embedded in a host @N{C program},
+it is also frequently used as a standalone language.
+An interpreter for Lua as a standalone language,
+called simply @id{lua},
+is provided with the standard distribution.
+The @x{standalone interpreter} includes
+all standard libraries, including the debug library.
+Its usage is:
+@verbatim{
+lua [options] [script [args]]
+}
+The options are:
+@description{
+@item{@T{-e @rep{stat}}| executes string @rep{stat};}
+@item{@T{-l @rep{mod}}| @Q{requires} @rep{mod} and assigns the
+  result to global @@rep{mod};}
+@item{@T{-i}| enters interactive mode after running @rep{script};}
+@item{@T{-v}| prints version information;}
+@item{@T{-E}| ignores environment variables;}
+@item{@T{--}| stops handling options;}
+@item{@T{-}| executes @id{stdin} as a file and stops handling options.}
+}
+After handling its options, @id{lua} runs the given @emph{script}.
+When called without arguments,
+@id{lua} behaves as @T{lua -v -i}
+when the standard input (@id{stdin}) is a terminal,
+and as @T{lua -} otherwise.
+
+When called without option @T{-E},
+the interpreter checks for an environment variable @defid{LUA_INIT_5_3}
+(or @defid{LUA_INIT} if the versioned name is not defined)
+before running any argument.
+If the variable content has the format @T{@At@rep{filename}},
+then @id{lua} executes the file.
+Otherwise, @id{lua} executes the string itself.
+
+When called with option @T{-E},
+besides ignoring @id{LUA_INIT},
+Lua also ignores
+the values of @id{LUA_PATH} and @id{LUA_CPATH},
+setting the values of
+@Lid{package.path} and @Lid{package.cpath}
+with the default paths defined in @id{luaconf.h}.
+
+All options are handled in order, except @T{-i} and @T{-E}.
+For instance, an invocation like
+@verbatim{
+$ lua -e'a=1' -e 'print(a)' script.lua
+}
+will first set @id{a} to 1, then print the value of @id{a},
+and finally run the file @id{script.lua} with no arguments.
+(Here @T{$} is the shell prompt. Your prompt may be different.)
+
+Before running any code,
+@id{lua} collects all command-line arguments
+in a global table called @id{arg}.
+The script name goes to index 0,
+the first argument after the script name goes to index 1,
+and so on.
+Any arguments before the script name
+(that is, the interpreter name plus its options)
+go to negative indices.
+For instance, in the call
+@verbatim{
+$ lua -la b.lua t1 t2
+}
+the table is like this:
+@verbatim{
+arg = { [-2] = "lua", [-1] = "-la",
+        [0] = "b.lua",
+        [1] = "t1", [2] = "t2" }
+}
+If there is no script in the call,
+the interpreter name goes to index 0,
+followed by the other arguments.
+For instance, the call
+@verbatim{
+$ lua -e "print(arg[1])"
+}
+will print @St{-e}.
+If there is a script,
+the script is called with arguments
+@T{arg[1]}, @Cdots, @T{arg[#arg]}.
+(Like all chunks in Lua,
+the script is compiled as a vararg function.)
+
+In interactive mode,
+Lua repeatedly prompts and waits for a line.
+After reading a line,
+Lua first try to interpret the line as an expression.
+If it succeeds, it prints its value.
+Otherwise, it interprets the line as a statement.
+If you write an incomplete statement,
+the interpreter waits for its completion
+by issuing a different prompt.
+
+If the global variable @defid{_PROMPT} contains a string,
+then its value is used as the prompt.
+Similarly, if the global variable @defid{_PROMPT2} contains a string,
+its value is used as the secondary prompt
+(issued during incomplete statements).
+
+In case of unprotected errors in the script,
+the interpreter reports the error to the standard error stream.
+If the error object is not a string but
+has a metamethod @idx{__tostring},
+the interpreter calls this metamethod to produce the final message.
+Otherwise, the interpreter converts the error object to a string
+and adds a stack traceback to it.
+
+When finishing normally,
+the interpreter closes its main Lua state
+@seeF{lua_close}.
+The script can avoid this step by
+calling @Lid{os.exit} to terminate.
+
+To allow the use of Lua as a
+script interpreter in Unix systems,
+the standalone interpreter skips
+the first line of a chunk if it starts with @T{#}.
+Therefore, Lua scripts can be made into executable programs
+by using @T{chmod +x} and @N{the @T{#!}} form,
+as in
+@verbatim{
+#!/usr/local/bin/lua
+}
+(Of course,
+the location of the Lua interpreter may be different in your machine.
+If @id{lua} is in your @id{PATH},
+then
+@verbatim{
+#!/usr/bin/env lua
+}
+is a more portable solution.)
+
+}
+
+
+@sect1{incompat| @title{Incompatibilities with the Previous Version}
+
+Here we list the incompatibilities that you may find when moving a program
+from @N{Lua 5.2} to @N{Lua 5.3}.
+You can avoid some incompatibilities by compiling Lua with
+appropriate options (see file @id{luaconf.h}).
+However,
+all these compatibility options will be removed in the future.
+
+Lua versions can always change the C API in ways that
+do not imply source-code changes in a program,
+such as the numeric values for constants
+or the implementation of functions as macros.
+Therefore,
+you should not assume that binaries are compatible between
+different Lua versions.
+Always recompile clients of the Lua API when
+using a new version.
+
+Similarly, Lua versions can always change the internal representation
+of precompiled chunks;
+precompiled chunks are not compatible between different Lua versions.
+
+The standard paths in the official distribution may
+change between versions.
+
+@sect2{@title{Changes in the Language}
+@itemize{
+
+@item{
+The main difference between @N{Lua 5.2} and @N{Lua 5.3} is the
+introduction of an integer subtype for numbers.
+Although this change should not affect @Q{normal} computations,
+some computations
+(mainly those that involve some kind of overflow)
+can give different results.
+
+You can fix these differences by forcing a number to be a float
+(in @N{Lua 5.2} all numbers were float),
+in particular writing constants with an ending @T{.0}
+or using @T{x = x + 0.0} to convert a variable.
+(This recommendation is only for a quick fix
+for an occasional incompatibility;
+it is not a general guideline for good programming.
+For good programming,
+use floats where you need floats
+and integers where you need integers.)
+}
+
+@item{
+The conversion of a float to a string now adds a @T{.0} suffix
+to the result if it looks like an integer.
+(For instance, the float 2.0 will be printed as @T{2.0},
+not as @T{2}.)
+You should always use an explicit format
+when you need a specific format for numbers.
+
+(Formally this is not an incompatibility,
+because Lua does not specify how numbers are formatted as strings,
+but some programs assumed a specific format.)
+}
+
+@item{
+The generational mode for the garbage collector was removed.
+(It was an experimental feature in @N{Lua 5.2}.)
+}
+
+}
+
+}
+
+@sect2{@title{Changes in the Libraries}
+@itemize{
+
+@item{
+The @id{bit32} library has been deprecated.
+It is easy to require a compatible external library or,
+better yet, to replace its functions with appropriate bitwise operations.
+(Keep in mind that @id{bit32} operates on 32-bit integers,
+while the bitwise operators in @N{Lua 5.3} operate on Lua integers,
+which by default have @N{64 bits}.)
+}
+
+@item{
+The Table library now respects metamethods
+for setting and getting elements.
+}
+
+@item{
+The @Lid{ipairs} iterator now respects metamethods and
+its @idx{__ipairs} metamethod has been deprecated.
+}
+
+
+@item{
+Option names in @Lid{io.read} do not have a starting @Char{*} anymore.
+For compatibility, Lua will continue to accept (and ignore) this character.
+}
+
+@item{
+The following functions were deprecated in the mathematical library:
+@id{atan2}, @id{cosh}, @id{sinh}, @id{tanh}, @id{pow},
+@id{frexp}, and @id{ldexp}.
+You can replace @T{math.pow(x,y)} with @T{x^y};
+you can replace @id{math.atan2} with @id{math.atan},
+which now accepts one or two arguments;
+you can replace @T{math.ldexp(x,exp)} with @T{x * 2.0^exp}.
+For the other operations,
+you can either use an external library or
+implement them in Lua.
+}
+
+@item{
+The searcher for C loaders used by @Lid{require}
+changed the way it handles versioned names.
+Now, the version should come after the module name
+(as is usual in most other tools).
+For compatibility, that searcher still tries the old format
+if it cannot find an open function according to the new style.
+(@N{Lua 5.2} already worked that way,
+but it did not document the change.)
+}
+
+@item{
+The call @T{collectgarbage("count")} now returns only one result.
+(You can compute that second result from the fractional part
+of the first result.)
+}
+
+}
+
+}
+
+@sect2{@title{Changes in the API}
+
+@itemize{
+
+@item{
+Continuation functions now receive as arguments what they needed
+to get through @id{lua_getctx},
+so @id{lua_getctx} has been removed.
+Adapt your code accordingly.
+}
+
+@item{
+Function @Lid{lua_dump} has an extra parameter, @id{strip}.
+Use 0 as the value of this parameter to get the old behavior.
+}
+
+@item{
+Functions to inject/project unsigned integers
+(@id{lua_pushunsigned}, @id{lua_tounsigned}, @id{lua_tounsignedx},
+@id{luaL_checkunsigned}, @id{luaL_optunsigned})
+were deprecated.
+Use their signed equivalents with a type cast.
+}
+
+@item{
+Macros to project non-default integer types
+(@id{luaL_checkint}, @id{luaL_optint}, @id{luaL_checklong}, @id{luaL_optlong})
+were deprecated.
+Use their equivalent over @Lid{lua_Integer} with a type cast
+(or, when possible, use @Lid{lua_Integer} in your code).
+}
+
+}
+
+}
+
+}
+
+
+@C{[===============================================================}
+
+@sect1{BNF| @title{The Complete Syntax of Lua}
+
+Here is the complete syntax of Lua in extended BNF.
+As usual in extended BNF,
+@bnfNter{{A}} means 0 or more @bnfNter{A}s,
+and @bnfNter{[A]} means an optional @bnfNter{A}.
+(For operator precedences, see @See{prec};
+for a description of the terminals
+@bnfNter{Name}, @bnfNter{Numeral},
+and @bnfNter{LiteralString}, see @See{lexical}.)
+@index{grammar}
+
+@Produc{
+
+@producname{chunk}@producbody{block}
+
+@producname{block}@producbody{@bnfrep{stat} @bnfopt{retstat}}
+
+@producname{stat}@producbody{
+        @bnfter{;}
+@OrNL   varlist @bnfter{=} explist
+@OrNL   functioncall
+@OrNL   label
+@OrNL   @Rw{break}
+@OrNL   @Rw{goto} Name
+@OrNL   @Rw{do} block @Rw{end}
+@OrNL   @Rw{while} exp @Rw{do} block @Rw{end}
+@OrNL   @Rw{repeat} block @Rw{until} exp
+@OrNL   @Rw{if} exp @Rw{then} block
+        @bnfrep{@Rw{elseif} exp @Rw{then} block}
+        @bnfopt{@Rw{else} block} @Rw{end}
+@OrNL   @Rw{for} @bnfNter{Name} @bnfter{=} exp @bnfter{,} exp @bnfopt{@bnfter{,} exp}
+        @Rw{do} block @Rw{end}
+@OrNL   @Rw{for} namelist @Rw{in} explist @Rw{do} block @Rw{end}
+@OrNL   @Rw{function} funcname funcbody
+@OrNL   @Rw{local} @Rw{function} @bnfNter{Name} funcbody
+@OrNL   @Rw{local} namelist @bnfopt{@bnfter{=} explist}
+}
+
+@producname{retstat}@producbody{@Rw{return}
+                                   @bnfopt{explist} @bnfopt{@bnfter{;}}}
+
+@producname{label}@producbody{@bnfter{::} Name @bnfter{::}}
+
+@producname{funcname}@producbody{@bnfNter{Name} @bnfrep{@bnfter{.} @bnfNter{Name}}
+                              @bnfopt{@bnfter{:} @bnfNter{Name}}}
+
+@producname{varlist}@producbody{var @bnfrep{@bnfter{,} var}}
+
+@producname{var}@producbody{
+        @bnfNter{Name}
+@Or     prefixexp @bnfter{[} exp @bnfter{]}
+@Or     prefixexp @bnfter{.} @bnfNter{Name}
+}
+
+@producname{namelist}@producbody{@bnfNter{Name} @bnfrep{@bnfter{,} @bnfNter{Name}}}
+
+
+@producname{explist}@producbody{exp @bnfrep{@bnfter{,} exp}}
+
+@producname{exp}@producbody{
+        @Rw{nil}
+@Or     @Rw{false}
+@Or     @Rw{true}
+@Or     @bnfNter{Numeral}
+@Or     @bnfNter{LiteralString}
+@Or     @bnfter{...}
+@Or     functiondef
+@OrNL   prefixexp
+@Or     tableconstructor
+@Or     exp binop exp
+@Or     unop exp
+}
+
+@producname{prefixexp}@producbody{var @Or functioncall @Or @bnfter{(} exp @bnfter{)}}
+
+@producname{functioncall}@producbody{
+        prefixexp args
+@Or     prefixexp @bnfter{:} @bnfNter{Name} args
+}
+
+@producname{args}@producbody{
+        @bnfter{(} @bnfopt{explist} @bnfter{)}
+@Or     tableconstructor
+@Or     @bnfNter{LiteralString}
+}
+
+@producname{functiondef}@producbody{@Rw{function} funcbody}
+
+@producname{funcbody}@producbody{@bnfter{(} @bnfopt{parlist} @bnfter{)} block @Rw{end}}
+
+@producname{parlist}@producbody{namelist @bnfopt{@bnfter{,} @bnfter{...}}
+  @Or @bnfter{...}}
+
+@producname{tableconstructor}@producbody{@bnfter{@Open} @bnfopt{fieldlist} @bnfter{@Close}}
+
+@producname{fieldlist}@producbody{field @bnfrep{fieldsep field} @bnfopt{fieldsep}}
+
+@producname{field}@producbody{@bnfter{[} exp @bnfter{]} @bnfter{=} exp @Or @bnfNter{Name} @bnfter{=} exp @Or exp}
+
+@producname{fieldsep}@producbody{@bnfter{,} @Or @bnfter{;}}
+
+@producname{binop}@producbody{
+  @bnfter{+} @Or @bnfter{-} @Or @bnfter{*} @Or @bnfter{/} @Or @bnfter{//}
+    @Or @bnfter{^} @Or @bnfter{%}
+        @OrNL
+  @bnfter{&} @Or @bnfter{~} @Or @bnfter{|} @Or @bnfter{>>} @Or @bnfter{<<}
+    @Or @bnfter{..}
+        @OrNL
+  @bnfter{<} @Or @bnfter{<=} @Or @bnfter{>} @Or @bnfter{>=}
+    @Or @bnfter{==} @Or @bnfter{~=}
+        @OrNL
+  @Rw{and} @Or @Rw{or}}
+
+@producname{unop}@producbody{@bnfter{-} @Or @Rw{not} @Or @bnfter{#} @Or
+  @bnfter{~}}
+
+}
+
+}
+
+@C{]===============================================================}
+
+}
+@C{)]-------------------------------------------------------------------------}
diff --git a/testes/all.lua b/testes/all.lua
new file mode 100755
index 00000000..017533ca
--- /dev/null
+++ b/testes/all.lua
@@ -0,0 +1,291 @@
+#!../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.
+*****************************************************************************
+]]
+
diff --git a/testes/api.lua b/testes/api.lua
new file mode 100644
index 00000000..c27ee97f
--- /dev/null
+++ b/testes/api.lua
@@ -0,0 +1,1172 @@
+-- $Id: api.lua,v 1.147 2016/11/07 13:06:25 roberto Exp $
+-- See Copyright Notice in file all.lua
+
+if T==nil then
+  (Message or print)('\n >>> testC not active: skipping API tests <<<\n')
+  return
+end
+
+local debug = require "debug"
+
+local pack = table.pack
+
+
+function tcheck (t1, t2)
+  assert(t1.n == (t2.n or #t2) + 1)
+  for i = 2, t1.n do assert(t1[i] == t2[i - 1]) end
+end
+
+
+local function checkerr (msg, f, ...)
+  local stat, err = pcall(f, ...)
+  assert(not stat and string.find(err, msg))
+end
+
+
+print('testing C API')
+
+a = T.testC("pushvalue R; return 1")
+assert(a == debug.getregistry())
+
+
+-- absindex
+assert(T.testC("settop 10; absindex -1; return 1") == 10)
+assert(T.testC("settop 5; absindex -5; return 1") == 1)
+assert(T.testC("settop 10; absindex 1; return 1") == 1)
+assert(T.testC("settop 10; absindex R; return 1") < -10)
+
+-- testing alignment
+a = T.d2s(12458954321123.0)
+assert(a == string.pack("d", 12458954321123.0))
+assert(T.s2d(a) == 12458954321123.0)
+
+a,b,c = T.testC("pushnum 1; pushnum 2; pushnum 3; return 2")
+assert(a == 2 and b == 3 and not c)
+
+f = T.makeCfunc("pushnum 1; pushnum 2; pushnum 3; return 2")
+a,b,c = f()
+assert(a == 2 and b == 3 and not c)
+
+-- test that all trues are equal
+a,b,c = T.testC("pushbool 1; pushbool 2; pushbool 0; return 3")
+assert(a == b and a == true and c == false)
+a,b,c = T.testC"pushbool 0; pushbool 10; pushnil;\
+                      tobool -3; tobool -3; tobool -3; return 3"
+assert(a==false and b==true and c==false)
+
+
+a,b,c = T.testC("gettop; return 2", 10, 20, 30, 40)
+assert(a == 40 and b == 5 and not c)
+
+t = pack(T.testC("settop 5; return *", 2, 3))
+tcheck(t, {n=4,2,3})
+
+t = pack(T.testC("settop 0; settop 15; return 10", 3, 1, 23))
+assert(t.n == 10 and t[1] == nil and t[10] == nil)
+
+t = pack(T.testC("remove -2; return *", 2, 3, 4))
+tcheck(t, {n=2,2,4})
+
+t = pack(T.testC("insert -1; return *", 2, 3))
+tcheck(t, {n=2,2,3})
+
+t = pack(T.testC("insert 3; return *", 2, 3, 4, 5))
+tcheck(t, {n=4,2,5,3,4})
+
+t = pack(T.testC("replace 2; return *", 2, 3, 4, 5))
+tcheck(t, {n=3,5,3,4})
+
+t = pack(T.testC("replace -2; return *", 2, 3, 4, 5))
+tcheck(t, {n=3,2,3,5})
+
+t = pack(T.testC("remove 3; return *", 2, 3, 4, 5))
+tcheck(t, {n=3,2,4,5})
+
+t = pack(T.testC("copy 3 4; return *", 2, 3, 4, 5))
+tcheck(t, {n=4,2,3,3,5})
+
+t = pack(T.testC("copy -3 -1; return *", 2, 3, 4, 5))
+tcheck(t, {n=4,2,3,4,3})
+
+do   -- testing 'rotate'
+  local t = {10, 20, 30, 40, 50, 60}
+  for i = -6, 6 do
+    local s = string.format("rotate 2 %d; return 7", i)
+    local t1 = pack(T.testC(s, 10, 20, 30, 40, 50, 60))
+    tcheck(t1, t)
+    table.insert(t, 1, table.remove(t))
+  end
+
+  t = pack(T.testC("rotate -2 1; return *", 10, 20, 30, 40))
+  tcheck(t, {10, 20, 40, 30})
+  t = pack(T.testC("rotate -2 -1; return *", 10, 20, 30, 40))
+  tcheck(t, {10, 20, 40, 30})
+
+  -- some corner cases
+  t = pack(T.testC("rotate -1 0; return *", 10, 20, 30, 40))
+  tcheck(t, {10, 20, 30, 40})
+  t = pack(T.testC("rotate -1 1; return *", 10, 20, 30, 40))
+  tcheck(t, {10, 20, 30, 40})
+  t = pack(T.testC("rotate 5 -1; return *", 10, 20, 30, 40))
+  tcheck(t, {10, 20, 30, 40})
+end
+
+-- testing non-function message handlers
+do
+  local f = T.makeCfunc[[
+    getglobal error
+    pushstring bola
+    pcall 1 1 1   # call 'error' with given handler
+    pushstatus
+    return 2     # return error message and status
+  ]]
+
+  local msg, st = f({})     -- invalid handler
+  assert(st == "ERRERR" and string.find(msg, "error handling"))
+  local msg, st = f(nil)     -- invalid handler
+  assert(st == "ERRERR" and string.find(msg, "error handling"))
+
+  local a = setmetatable({}, {__call = function (_, x) return x:upper() end})
+  local msg, st = f(a)   -- callable handler
+  assert(st == "ERRRUN" and msg == "BOLA")
+end
+
+t = pack(T.testC("insert 3; pushvalue 3; remove 3; pushvalue 2; remove 2; \
+                  insert 2; pushvalue 1; remove 1; insert 1; \
+      insert -2; pushvalue -2; remove -3; return *",
+      2, 3, 4, 5, 10, 40, 90))
+tcheck(t, {n=7,2,3,4,5,10,40,90})
+
+t = pack(T.testC("concat 5; return *", "alo", 2, 3, "joao", 12))
+tcheck(t, {n=1,"alo23joao12"})
+
+-- testing MULTRET
+t = pack(T.testC("call 2,-1; return *",
+     function (a,b) return 1,2,3,4,a,b end, "alo", "joao"))
+tcheck(t, {n=6,1,2,3,4,"alo", "joao"})
+
+do  -- test returning more results than fit in the caller stack
+  local a = {}
+  for i=1,1000 do a[i] = true end; a[999] = 10
+  local b = T.testC([[pcall 1 -1 0; pop 1; tostring -1; return 1]],
+                    table.unpack, a)
+  assert(b == "10")
+end
+
+
+-- testing globals
+_G.a = 14; _G.b = "a31"
+local a = {T.testC[[
+  getglobal a;
+  getglobal b;
+  getglobal b;
+  setglobal a;
+  return *
+]]}
+assert(a[2] == 14 and a[3] == "a31" and a[4] == nil and _G.a == "a31")
+
+
+-- testing arith
+assert(T.testC("pushnum 10; pushnum 20; arith /; return 1") == 0.5)
+assert(T.testC("pushnum 10; pushnum 20; arith -; return 1") == -10)
+assert(T.testC("pushnum 10; pushnum -20; arith *; return 1") == -200)
+assert(T.testC("pushnum 10; pushnum 3; arith ^; return 1") == 1000)
+assert(T.testC("pushnum 10; pushstring 20; arith /; return 1") == 0.5)
+assert(T.testC("pushstring 10; pushnum 20; arith -; return 1") == -10)
+assert(T.testC("pushstring 10; pushstring -20; arith *; return 1") == -200)
+assert(T.testC("pushstring 10; pushstring 3; arith ^; return 1") == 1000)
+assert(T.testC("arith /; return 1", 2, 0) == 10.0/0)
+a = T.testC("pushnum 10; pushint 3; arith \\; return 1")
+assert(a == 3.0 and math.type(a) == "float")
+a = T.testC("pushint 10; pushint 3; arith \\; return 1")
+assert(a == 3 and math.type(a) == "integer")
+a = assert(T.testC("pushint 10; pushint 3; arith +; return 1"))
+assert(a == 13 and math.type(a) == "integer")
+a = assert(T.testC("pushnum 10; pushint 3; arith +; return 1"))
+assert(a == 13 and math.type(a) == "float")
+a,b,c = T.testC([[pushnum 1;
+                  pushstring 10; arith _;
+                  pushstring 5; return 3]])
+assert(a == 1 and b == -10 and c == "5")
+mt = {__add = function (a,b) return setmetatable({a[1] + b[1]}, mt) end,
+      __mod = function (a,b) return setmetatable({a[1] % b[1]}, mt) end,
+      __unm = function (a) return setmetatable({a[1]* 2}, mt) end}
+a,b,c = setmetatable({4}, mt),
+        setmetatable({8}, mt),
+        setmetatable({-3}, mt)
+x,y,z = T.testC("arith +; return 2", 10, a, b)
+assert(x == 10 and y[1] == 12 and z == nil)
+assert(T.testC("arith %; return 1", a, c)[1] == 4%-3)
+assert(T.testC("arith _; arith +; arith %; return 1", b, a, c)[1] ==
+               8 % (4 + (-3)*2))
+
+-- errors in arithmetic
+checkerr("divide by zero", T.testC, "arith \\", 10, 0)
+checkerr("%%0", T.testC, "arith %", 10, 0)
+
+
+-- testing lessthan and lessequal
+assert(T.testC("compare LT 2 5, return 1", 3, 2, 2, 4, 2, 2))
+assert(T.testC("compare LE 2 5, return 1", 3, 2, 2, 4, 2, 2))
+assert(not T.testC("compare LT 3 4, return 1", 3, 2, 2, 4, 2, 2))
+assert(T.testC("compare LE 3 4, return 1", 3, 2, 2, 4, 2, 2))
+assert(T.testC("compare LT 5 2, return 1", 4, 2, 2, 3, 2, 2))
+assert(not T.testC("compare LT 2 -3, return 1", "4", "2", "2", "3", "2", "2"))
+assert(not T.testC("compare LT -3 2, return 1", "3", "2", "2", "4", "2", "2"))
+
+-- non-valid indices produce false
+assert(not T.testC("compare LT 1 4, return 1"))
+assert(not T.testC("compare LE 9 1, return 1"))
+assert(not T.testC("compare EQ 9 9, return 1"))
+
+local b = {__lt = function (a,b) return a[1] < b[1] end}
+local a1,a3,a4 = setmetatable({1}, b),
+                 setmetatable({3}, b),
+                 setmetatable({4}, b)
+assert(T.testC("compare LT 2 5, return 1", a3, 2, 2, a4, 2, 2))
+assert(T.testC("compare LE 2 5, return 1", a3, 2, 2, a4, 2, 2))
+assert(T.testC("compare LT 5 -6, return 1", a4, 2, 2, a3, 2, 2))
+a,b = T.testC("compare LT 5 -6, return 2", a1, 2, 2, a3, 2, 20)
+assert(a == 20 and b == false)
+a,b = T.testC("compare LE 5 -6, return 2", a1, 2, 2, a3, 2, 20)
+assert(a == 20 and b == false)
+a,b = T.testC("compare LE 5 -6, return 2", a1, 2, 2, a1, 2, 20)
+assert(a == 20 and b == true)
+
+-- testing length
+local t = setmetatable({x = 20}, {__len = function (t) return t.x end})
+a,b,c = T.testC([[
+   len 2;
+   Llen 2;
+   objsize 2;
+   return 3
+]], t)
+assert(a == 20 and b == 20 and c == 0)
+
+t.x = "234"; t[1] = 20
+a,b,c = T.testC([[
+   len 2;
+   Llen 2;
+   objsize 2;
+   return 3
+]], t)
+assert(a == "234" and b == 234 and c == 1)
+
+t.x = print; t[1] = 20
+a,c = T.testC([[
+   len 2;
+   objsize 2;
+   return 2
+]], t)
+assert(a == print and c == 1)
+
+
+-- testing __concat
+
+a = setmetatable({x="u"}, {__concat = function (a,b) return a.x..'.'..b.x end})
+x,y = T.testC([[
+  pushnum 5
+  pushvalue 2;
+  pushvalue 2;
+  concat 2;
+  pushvalue -2;
+  return 2;
+]], a, a)
+assert(x == a..a and y == 5)
+
+-- concat with 0 elements
+assert(T.testC("concat 0; return 1") == "")
+
+-- concat with 1 element
+assert(T.testC("concat 1; return 1", "xuxu") == "xuxu")
+
+
+
+-- testing lua_is
+
+function B(x) return x and 1 or 0 end
+
+function count (x, n)
+  n = n or 2
+  local prog = [[
+    isnumber %d;
+    isstring %d;
+    isfunction %d;
+    iscfunction %d;
+    istable %d;
+    isuserdata %d;
+    isnil %d;
+    isnull %d;
+    return 8
+  ]]
+  prog = string.format(prog, n, n, n, n, n, n, n, n)
+  local a,b,c,d,e,f,g,h = T.testC(prog, x)
+  return B(a)+B(b)+B(c)+B(d)+B(e)+B(f)+B(g)+(100*B(h))
+end
+
+assert(count(3) == 2)
+assert(count('alo') == 1)
+assert(count('32') == 2)
+assert(count({}) == 1)
+assert(count(print) == 2)
+assert(count(function () end) == 1)
+assert(count(nil) == 1)
+assert(count(io.stdin) == 1)
+assert(count(nil, 15) == 100)
+
+
+-- testing lua_to...
+
+function to (s, x, n)
+  n = n or 2
+  return T.testC(string.format("%s %d; return 1", s, n), x)
+end
+
+local hfunc = string.gmatch("", "")    -- a "heavy C function" (with upvalues)
+assert(debug.getupvalue(hfunc, 1))
+assert(to("tostring", {}) == nil)
+assert(to("tostring", "alo") == "alo")
+assert(to("tostring", 12) == "12")
+assert(to("tostring", 12, 3) == nil)
+assert(to("objsize", {}) == 0)
+assert(to("objsize", {1,2,3}) == 3)
+assert(to("objsize", "alo\0\0a") == 6)
+assert(to("objsize", T.newuserdata(0)) == 0)
+assert(to("objsize", T.newuserdata(101)) == 101)
+assert(to("objsize", 124) == 0)
+assert(to("objsize", true) == 0)
+assert(to("tonumber", {}) == 0)
+assert(to("tonumber", "12") == 12)
+assert(to("tonumber", "s2") == 0)
+assert(to("tonumber", 1, 20) == 0)
+assert(to("topointer", 10) == 0)
+assert(to("topointer", true) == 0)
+assert(to("topointer", T.pushuserdata(20)) == 20)
+assert(to("topointer", io.read) ~= 0)           -- light C function
+assert(to("topointer", hfunc) ~= 0)        -- "heavy" C function
+assert(to("topointer", function () end) ~= 0)   -- Lua function
+assert(to("topointer", io.stdin) ~= 0)   -- full userdata
+assert(to("func2num", 20) == 0)
+assert(to("func2num", T.pushuserdata(10)) == 0)
+assert(to("func2num", io.read) ~= 0)     -- light C function
+assert(to("func2num", hfunc) ~= 0)  -- "heavy" C function (with upvalue)
+a = to("tocfunction", math.deg)
+assert(a(3) == math.deg(3) and a == math.deg)
+
+
+print("testing panic function")
+do
+  -- trivial error
+  assert(T.checkpanic("pushstring hi; error") == "hi")
+
+  -- using the stack inside panic
+  assert(T.checkpanic("pushstring hi; error;",
+    [[checkstack 5 XX
+      pushstring ' alo'
+      pushstring ' mundo'
+      concat 3]]) == "hi alo mundo")
+
+  -- "argerror" without frames
+  assert(T.checkpanic("loadstring 4") ==
+      "bad argument #4 (string expected, got no value)")
+  
+
+  -- memory error
+  T.totalmem(T.totalmem()+10000)   -- set low memory limit (+10k)
+  assert(T.checkpanic("newuserdata 20000") == "not enough memory")
+  T.totalmem(0)          -- restore high limit
+
+  -- stack error
+  if not _soft then
+    local msg = T.checkpanic[[
+      pushstring "function f() f() end"
+      loadstring -1; call 0 0
+      getglobal f; call 0 0
+    ]]
+    assert(string.find(msg, "stack overflow"))
+  end
+
+end
+
+-- testing deep C stack
+if not _soft then
+  print("testing stack overflow")
+  collectgarbage("stop")
+  checkerr("XXXX", T.testC, "checkstack 1000023 XXXX")   -- too deep
+  -- too deep (with no message)
+  checkerr("^stack overflow$", T.testC, "checkstack 1000023 ''")
+  local s = string.rep("pushnil;checkstack 1 XX;", 1000000)
+  checkerr("overflow", T.testC, s)
+  collectgarbage("restart")
+  print'+'
+end
+
+local lim = _soft and 500 or 12000
+local prog = {"checkstack " .. (lim * 2 + 100) .. "msg", "newtable"}
+for i = 1,lim do
+  prog[#prog + 1] = "pushnum " .. i
+  prog[#prog + 1] = "pushnum " .. i * 10
+end
+
+prog[#prog + 1] = "rawgeti R 2"   -- get global table in registry
+prog[#prog + 1] = "insert " .. -(2*lim + 2)
+
+for i = 1,lim do
+  prog[#prog + 1] = "settable " .. -(2*(lim - i + 1) + 1)
+end
+
+prog[#prog + 1] = "return 2"
+
+prog = table.concat(prog, ";")
+local g, t = T.testC(prog)
+assert(g == _G)
+for i = 1,lim do assert(t[i] == i*10); t[i] = nil end
+assert(next(t) == nil)
+prog, g, t = nil
+
+-- testing errors
+
+a = T.testC([[
+  loadstring 2; pcall 0 1 0;
+  pushvalue 3; insert -2; pcall 1 1 0;
+  pcall 0 0 0;
+  return 1
+]], "x=150", function (a) assert(a==nil); return 3 end)
+
+assert(type(a) == 'string' and x == 150)
+
+function check3(p, ...)
+  local arg = {...}
+  assert(#arg == 3)
+  assert(string.find(arg[3], p))
+end
+check3(":1:", T.testC("loadstring 2; return *", "x="))
+check3("%.", T.testC("loadfile 2; return *", "."))
+check3("xxxx", T.testC("loadfile 2; return *", "xxxx"))
+
+-- test errors in non protected threads
+function checkerrnopro (code, msg)
+  local th = coroutine.create(function () end)  -- create new thread
+  local stt, err = pcall(T.testC, th, code)   -- run code there
+  assert(not stt and string.find(err, msg))
+end
+
+if not _soft then
+  checkerrnopro("pushnum 3; call 0 0", "attempt to call")
+  print"testing stack overflow in unprotected thread"
+  function f () f() end
+  checkerrnopro("getglobal 'f'; call 0 0;", "stack overflow")
+end
+print"+"
+
+
+-- testing table access
+
+do   -- getp/setp
+  local a = {}
+  T.testC("rawsetp 2 1", a, 20)
+  assert(a[T.pushuserdata(1)] == 20)
+  assert(T.testC("rawgetp 2 1; return 1", a) == 20)
+end
+
+a = {x=0, y=12}
+x, y = T.testC("gettable 2; pushvalue 4; gettable 2; return 2",
+                a, 3, "y", 4, "x")
+assert(x == 0 and y == 12)
+T.testC("settable -5", a, 3, 4, "x", 15)
+assert(a.x == 15)
+a[a] = print
+x = T.testC("gettable 2; return 1", a)  -- table and key are the same object!
+assert(x == print)
+T.testC("settable 2", a, "x")    -- table and key are the same object!
+assert(a[a] == "x")
+
+b = setmetatable({p = a}, {})
+getmetatable(b).__index = function (t, i) return t.p[i] end
+k, x = T.testC("gettable 3, return 2", 4, b, 20, 35, "x")
+assert(x == 15 and k == 35)
+k = T.testC("getfield 2 y, return 1", b)
+assert(k == 12)
+getmetatable(b).__index = function (t, i) return a[i] end
+getmetatable(b).__newindex = function (t, i,v ) a[i] = v end
+y = T.testC("insert 2; gettable -5; return 1", 2, 3, 4, "y", b)
+assert(y == 12)
+k = T.testC("settable -5, return 1", b, 3, 4, "x", 16)
+assert(a.x == 16 and k == 4)
+a[b] = 'xuxu'
+y = T.testC("gettable 2, return 1", b)
+assert(y == 'xuxu')
+T.testC("settable 2", b, 19)
+assert(a[b] == 19)
+
+--
+do   -- testing getfield/setfield with long keys
+  local t = {_012345678901234567890123456789012345678901234567890123456789 = 32}
+  local a = T.testC([[
+    getfield 2 _012345678901234567890123456789012345678901234567890123456789
+    return 1
+  ]], t)
+  assert(a == 32)
+  local a = T.testC([[
+    pushnum 33
+    setglobal _012345678901234567890123456789012345678901234567890123456789
+  ]])
+  assert(_012345678901234567890123456789012345678901234567890123456789 == 33)
+  _012345678901234567890123456789012345678901234567890123456789 = nil
+end
+
+-- testing next
+a = {}
+t = pack(T.testC("next; return *", a, nil))
+tcheck(t, {n=1,a})
+a = {a=3}
+t = pack(T.testC("next; return *", a, nil))
+tcheck(t, {n=3,a,'a',3})
+t = pack(T.testC("next; pop 1; next; return *", a, nil))
+tcheck(t, {n=1,a})
+
+
+
+-- testing upvalues
+
+do
+  local A = T.testC[[ pushnum 10; pushnum 20; pushcclosure 2; return 1]]
+  t, b, c = A([[pushvalue U0; pushvalue U1; pushvalue U2; return 3]])
+  assert(b == 10 and c == 20 and type(t) == 'table')
+  a, b = A([[tostring U3; tonumber U4; return 2]])
+  assert(a == nil and b == 0)
+  A([[pushnum 100; pushnum 200; replace U2; replace U1]])
+  b, c = A([[pushvalue U1; pushvalue U2; return 2]])
+  assert(b == 100 and c == 200)
+  A([[replace U2; replace U1]], {x=1}, {x=2})
+  b, c = A([[pushvalue U1; pushvalue U2; return 2]])
+  assert(b.x == 1 and c.x == 2)
+  T.checkmemory()
+end
+
+
+-- testing absent upvalues from C-function pointers
+assert(T.testC[[isnull U1; return 1]] == true)
+assert(T.testC[[isnull U100; return 1]] == true)
+assert(T.testC[[pushvalue U1; return 1]] == nil)
+
+local f = T.testC[[ pushnum 10; pushnum 20; pushcclosure 2; return 1]]
+assert(T.upvalue(f, 1) == 10 and
+       T.upvalue(f, 2) == 20 and
+       T.upvalue(f, 3) == nil)
+T.upvalue(f, 2, "xuxu")
+assert(T.upvalue(f, 2) == "xuxu")
+
+
+-- large closures
+do
+  local A = "checkstack 300 msg;" ..
+            string.rep("pushnum 10;", 255) ..
+            "pushcclosure 255; return 1"
+  A = T.testC(A)
+  for i=1,255 do
+    assert(A(("pushvalue U%d; return 1"):format(i)) == 10)
+  end
+  assert(A("isnull U256; return 1"))
+  assert(not A("isnil U256; return 1"))
+end
+
+
+
+-- testing get/setuservalue
+-- bug in 5.1.2
+checkerr("got number", debug.setuservalue, 3, {})
+checkerr("got nil", debug.setuservalue, nil, {})
+checkerr("got light userdata", debug.setuservalue, T.pushuserdata(1), {})
+
+local b = T.newuserdata(0)
+assert(debug.getuservalue(b) == nil)
+for _, v in pairs{true, false, 4.56, print, {}, b, "XYZ"} do
+  assert(debug.setuservalue(b, v) == b)
+  assert(debug.getuservalue(b) == v)
+end
+
+assert(debug.getuservalue(4) == nil)
+
+debug.setuservalue(b, function () return 10 end)
+collectgarbage()   -- function should not be collected
+assert(debug.getuservalue(b)() == 10)
+
+debug.setuservalue(b, 134)
+collectgarbage()   -- number should not be a problem for collector
+assert(debug.getuservalue(b) == 134)
+
+-- test barrier for uservalues
+T.gcstate("atomic")
+assert(T.gccolor(b) == "black")
+debug.setuservalue(b, {x = 100})
+T.gcstate("pause")  -- complete collection
+assert(debug.getuservalue(b).x == 100)  -- uvalue should be there
+
+-- long chain of userdata
+for i = 1, 1000 do
+  local bb = T.newuserdata(0)
+  debug.setuservalue(bb, b)
+  b = bb
+end
+collectgarbage()     -- nothing should not be collected
+for i = 1, 1000 do
+  b = debug.getuservalue(b)
+end
+assert(debug.getuservalue(b).x == 100)
+b = nil
+
+
+-- testing locks (refs)
+
+-- reuse of references
+local i = T.ref{}
+T.unref(i)
+assert(T.ref{} == i)
+
+Arr = {}
+Lim = 100
+for i=1,Lim do   -- lock many objects
+  Arr[i] = T.ref({})
+end
+
+assert(T.ref(nil) == -1 and T.getref(-1) == nil)
+T.unref(-1); T.unref(-1)
+
+for i=1,Lim do   -- unlock all them
+  T.unref(Arr[i])
+end
+
+function printlocks ()
+  local f = T.makeCfunc("gettable R; return 1")
+  local n = f("n")
+  print("n", n)
+  for i=0,n do
+    print(i, f(i))
+  end
+end
+
+
+for i=1,Lim do   -- lock many objects
+  Arr[i] = T.ref({})
+end
+
+for i=1,Lim,2 do   -- unlock half of them
+  T.unref(Arr[i])
+end
+
+assert(type(T.getref(Arr[2])) == 'table')
+
+
+assert(T.getref(-1) == nil)
+
+
+a = T.ref({})
+
+collectgarbage()
+
+assert(type(T.getref(a)) == 'table')
+
+
+-- colect in cl the `val' of all collected userdata
+tt = {}
+cl = {n=0}
+A = nil; B = nil
+local F
+F = function (x)
+  local udval = T.udataval(x)
+  table.insert(cl, udval)
+  local d = T.newuserdata(100)   -- cria lixo
+  d = nil
+  assert(debug.getmetatable(x).__gc == F)
+  assert(load("table.insert({}, {})"))()   -- cria mais lixo
+  collectgarbage()   -- forca coleta de lixo durante coleta!
+  assert(debug.getmetatable(x).__gc == F)   -- coleta anterior nao melou isso?
+  local dummy = {}    -- cria lixo durante coleta
+  if A ~= nil then
+    assert(type(A) == "userdata")
+    assert(T.udataval(A) == B)
+    debug.getmetatable(A)    -- just acess it
+  end
+  A = x   -- ressucita userdata
+  B = udval
+  return 1,2,3
+end
+tt.__gc = F
+
+-- test whether udate collection frees memory in the right time
+do
+  collectgarbage();
+  collectgarbage();
+  local x = collectgarbage("count");
+  local a = T.newuserdata(5001)
+  assert(T.testC("objsize 2; return 1", a) == 5001)
+  assert(collectgarbage("count") >= x+4)
+  a = nil
+  collectgarbage();
+  assert(collectgarbage("count") <= x+1)
+  -- udata without finalizer
+  x = collectgarbage("count")
+  collectgarbage("stop")
+  for i=1,1000 do T.newuserdata(0) end
+  assert(collectgarbage("count") > x+10)
+  collectgarbage()
+  assert(collectgarbage("count") <= x+1)
+  -- udata with finalizer
+  collectgarbage()
+  x = collectgarbage("count")
+  collectgarbage("stop")
+  a = {__gc = function () end}
+  for i=1,1000 do debug.setmetatable(T.newuserdata(0), a) end
+  assert(collectgarbage("count") >= x+10)
+  collectgarbage()  -- this collection only calls TM, without freeing memory
+  assert(collectgarbage("count") >= x+10)
+  collectgarbage()  -- now frees memory
+  assert(collectgarbage("count") <= x+1)
+  collectgarbage("restart")
+end
+
+
+collectgarbage("stop")
+
+-- create 3 userdatas with tag `tt'
+a = T.newuserdata(0); debug.setmetatable(a, tt); na = T.udataval(a)
+b = T.newuserdata(0); debug.setmetatable(b, tt); nb = T.udataval(b)
+c = T.newuserdata(0); debug.setmetatable(c, tt); nc = T.udataval(c)
+
+-- create userdata without meta table
+x = T.newuserdata(4)
+y = T.newuserdata(0)
+
+checkerr("FILE%* expected, got userdata", io.input, a)
+checkerr("FILE%* expected, got userdata", io.input, x)
+
+assert(debug.getmetatable(x) == nil and debug.getmetatable(y) == nil)
+
+d=T.ref(a);
+e=T.ref(b);
+f=T.ref(c);
+t = {T.getref(d), T.getref(e), T.getref(f)}
+assert(t[1] == a and t[2] == b and t[3] == c)
+
+t=nil; a=nil; c=nil;
+T.unref(e); T.unref(f)
+
+collectgarbage()
+
+-- check that unref objects have been collected
+assert(#cl == 1 and cl[1] == nc)
+
+x = T.getref(d)
+assert(type(x) == 'userdata' and debug.getmetatable(x) == tt)
+x =nil
+tt.b = b  -- create cycle
+tt=nil    -- frees tt for GC
+A = nil
+b = nil
+T.unref(d);
+n5 = T.newuserdata(0)
+debug.setmetatable(n5, {__gc=F})
+n5 = T.udataval(n5)
+collectgarbage()
+assert(#cl == 4)
+-- check order of collection
+assert(cl[2] == n5 and cl[3] == nb and cl[4] == na)
+
+collectgarbage"restart"
+
+
+a, na = {}, {}
+for i=30,1,-1 do
+  a[i] = T.newuserdata(0)
+  debug.setmetatable(a[i], {__gc=F})
+  na[i] = T.udataval(a[i])
+end
+cl = {}
+a = nil; collectgarbage()
+assert(#cl == 30)
+for i=1,30 do assert(cl[i] == na[i]) end
+na = nil
+
+
+for i=2,Lim,2 do   -- unlock the other half
+  T.unref(Arr[i])
+end
+
+x = T.newuserdata(41); debug.setmetatable(x, {__gc=F})
+assert(T.testC("objsize 2; return 1", x) == 41)
+cl = {}
+a = {[x] = 1}
+x = T.udataval(x)
+collectgarbage()
+-- old `x' cannot be collected (`a' still uses it)
+assert(#cl == 0)
+for n in pairs(a) do a[n] = nil end
+collectgarbage()
+assert(#cl == 1 and cl[1] == x)   -- old `x' must be collected
+
+-- testing lua_equal
+assert(T.testC("compare EQ 2 4; return 1", print, 1, print, 20))
+assert(T.testC("compare EQ 3 2; return 1", 'alo', "alo"))
+assert(T.testC("compare EQ 2 3; return 1", nil, nil))
+assert(not T.testC("compare EQ 2 3; return 1", {}, {}))
+assert(not T.testC("compare EQ 2 3; return 1"))
+assert(not T.testC("compare EQ 2 3; return 1", 3))
+
+-- testing lua_equal with fallbacks
+do
+  local map = {}
+  local t = {__eq = function (a,b) return map[a] == map[b] end}
+  local function f(x)
+    local u = T.newuserdata(0)
+    debug.setmetatable(u, t)
+    map[u] = x
+    return u
+  end
+  assert(f(10) == f(10))
+  assert(f(10) ~= f(11))
+  assert(T.testC("compare EQ 2 3; return 1", f(10), f(10)))
+  assert(not T.testC("compare EQ 2 3; return 1", f(10), f(20)))
+  t.__eq = nil
+  assert(f(10) ~= f(10))
+end
+
+print'+'
+
+
+
+-- testing changing hooks during hooks
+_G.t = {}
+T.sethook([[
+  # set a line hook after 3 count hooks
+  sethook 4 0 '
+    getglobal t;
+    pushvalue -3; append -2
+    pushvalue -2; append -2
+  ']], "c", 3)
+local a = 1   -- counting
+a = 1   -- counting
+a = 1   -- count hook (set line hook)
+a = 1   -- line hook
+a = 1   -- line hook
+debug.sethook()
+t = _G.t
+assert(t[1] == "line")
+line = t[2]
+assert(t[3] == "line" and t[4] == line + 1)
+assert(t[5] == "line" and t[6] == line + 2)
+assert(t[7] == nil)
+
+
+-------------------------------------------------------------------------
+do   -- testing errors during GC
+  local a = {}
+  for i=1,20 do
+    a[i] = T.newuserdata(i)   -- creates several udata
+  end
+  for i=1,20,2 do   -- mark half of them to raise errors during GC
+    debug.setmetatable(a[i], {__gc = function (x) error("error inside gc") end})
+  end
+  for i=2,20,2 do   -- mark the other half to count and to create more garbage
+    debug.setmetatable(a[i], {__gc = function (x) load("A=A+1")() end})
+  end
+  _G.A = 0
+  a = 0
+  while 1 do
+    local stat, msg = pcall(collectgarbage)
+    if stat then
+      break   -- stop when no more errors
+    else
+      a = a + 1
+      assert(string.find(msg, "__gc"))
+    end
+  end
+  assert(a == 10)  -- number of errors
+
+  assert(A == 10)  -- number of normal collections
+end
+-------------------------------------------------------------------------
+-- test for userdata vals
+do
+  local a = {}; local lim = 30
+  for i=0,lim do a[i] = T.pushuserdata(i) end
+  for i=0,lim do assert(T.udataval(a[i]) == i) end
+  for i=0,lim do assert(T.pushuserdata(i) == a[i]) end
+  for i=0,lim do a[a[i]] = i end
+  for i=0,lim do a[T.pushuserdata(i)] = i end
+  assert(type(tostring(a[1])) == "string")
+end
+
+
+-------------------------------------------------------------------------
+-- testing multiple states
+T.closestate(T.newstate());
+L1 = T.newstate()
+assert(L1)
+
+assert(T.doremote(L1, "X='a'; return 'a'") == 'a')
+
+
+assert(#pack(T.doremote(L1, "function f () return 'alo', 3 end; f()")) == 0)
+
+a, b = T.doremote(L1, "return f()")
+assert(a == 'alo' and b == '3')
+
+T.doremote(L1, "_ERRORMESSAGE = nil")
+-- error: `sin' is not defined
+a, _, b = T.doremote(L1, "return sin(1)")
+assert(a == nil and b == 2)   -- 2 == run-time error
+
+-- error: syntax error
+a, b, c = T.doremote(L1, "return a+")
+assert(a == nil and c == 3 and type(b) == "string")   -- 3 == syntax error
+
+T.loadlib(L1)
+a, b, c = T.doremote(L1, [[
+  string = require'string'
+  a = require'_G'; assert(a == _G and require("_G") == a)
+  io = require'io'; assert(type(io.read) == "function")
+  assert(require("io") == io)
+  a = require'table'; assert(type(a.insert) == "function")
+  a = require'debug'; assert(type(a.getlocal) == "function")
+  a = require'math'; assert(type(a.sin) == "function")
+  return string.sub('okinama', 1, 2)
+]])
+assert(a == "ok")
+
+T.closestate(L1);
+
+
+L1 = T.newstate()
+T.loadlib(L1)
+T.doremote(L1, "a = {}")
+T.testC(L1, [[getglobal "a"; pushstring "x"; pushint 1;
+             settable -3]])
+assert(T.doremote(L1, "return a.x") == "1")
+
+T.closestate(L1)
+
+L1 = nil
+
+print('+')
+
+-------------------------------------------------------------------------
+-- testing memory limits
+-------------------------------------------------------------------------
+checkerr("block too big", T.newuserdata, math.maxinteger)
+collectgarbage()
+T.totalmem(T.totalmem()+5000)   -- set low memory limit (+5k)
+checkerr("not enough memory", load"local a={}; for i=1,100000 do a[i]=i end")
+T.totalmem(0)          -- restore high limit
+
+-- test memory errors; increase memory limit in small steps, so that
+-- we get memory errors in different parts of a given task, up to there
+-- is enough memory to complete the task without errors
+function testamem (s, f)
+  collectgarbage(); collectgarbage()
+  local M = T.totalmem()
+  local oldM = M
+  local a,b = nil
+  while 1 do
+    M = M+7   -- increase memory limit in small steps
+    T.totalmem(M)
+    a, b = pcall(f)
+    T.totalmem(0)  -- restore high limit
+    if a and b then break end       -- stop when no more errors
+    collectgarbage()
+    if not a and not    -- `real' error?
+      (string.find(b, "memory") or string.find(b, "overflow")) then
+      error(b, 0)   -- propagate it
+    end
+  end
+  print("\nlimit for " .. s .. ": " .. M-oldM)
+  return b
+end
+
+
+-- testing memory errors when creating a new state
+
+b = testamem("state creation", T.newstate)
+T.closestate(b);  -- close new state
+
+
+-- testing threads
+
+-- get main thread from registry (at index LUA_RIDX_MAINTHREAD == 1)
+mt = T.testC("rawgeti R 1; return 1")
+assert(type(mt) == "thread" and coroutine.running() == mt)
+
+
+
+function expand (n,s)
+  if n==0 then return "" end
+  local e = string.rep("=", n)
+  return string.format("T.doonnewstack([%s[ %s;\n collectgarbage(); %s]%s])\n",
+                              e, s, expand(n-1,s), e)
+end
+
+G=0; collectgarbage(); a =collectgarbage("count")
+load(expand(20,"G=G+1"))()
+assert(G==20); collectgarbage();  -- assert(gcinfo() <= a+1)
+
+testamem("thread creation", function ()
+  return T.doonnewstack("x=1") == 0  -- try to create thread
+end)
+
+
+-- testing memory x compiler
+
+testamem("loadstring", function ()
+  return load("x=1")  -- try to do load a string
+end)
+
+
+local testprog = [[
+local function foo () return end
+local t = {"x"}
+a = "aaa"
+for i = 1, #t do a=a..t[i] end
+return true
+]]
+
+-- testing memory x dofile
+_G.a = nil
+local t =os.tmpname()
+local f = assert(io.open(t, "w"))
+f:write(testprog)
+f:close()
+testamem("dofile", function ()
+  local a = loadfile(t)
+  return a and a()
+end)
+assert(os.remove(t))
+assert(_G.a == "aaax")
+
+
+-- other generic tests
+
+testamem("string creation", function ()
+  local a, b = string.gsub("alo alo", "(a)", function (x) return x..'b' end)
+  return (a == 'ablo ablo')
+end)
+
+testamem("dump/undump", function ()
+  local a = load(testprog)
+  local b = a and string.dump(a)
+  a = b and load(b)
+  return a and a()
+end)
+
+local t = os.tmpname()
+testamem("file creation", function ()
+  local f = assert(io.open(t, 'w'))
+  assert (not io.open"nomenaoexistente")
+  io.close(f);
+  return not loadfile'nomenaoexistente'
+end)
+assert(os.remove(t))
+
+testamem("table creation", function ()
+  local a, lim = {}, 10
+  for i=1,lim do a[i] = i; a[i..'a'] = {} end
+  return (type(a[lim..'a']) == 'table' and a[lim] == lim)
+end)
+
+testamem("constructors", function ()
+  local a = {10, 20, 30, 40, 50; a=1, b=2, c=3, d=4, e=5}
+  return (type(a) == 'table' and a.e == 5)
+end)
+
+local a = 1
+close = nil
+testamem("closure creation", function ()
+  function close (b,c)
+   return function (x) return a+b+c+x end
+  end
+  return (close(2,3)(4) == 10)
+end)
+
+testamem("coroutines", function ()
+  local a = coroutine.wrap(function ()
+              coroutine.yield(string.rep("a", 10))
+              return {}
+            end)
+  assert(string.len(a()) == 10)
+  return a()
+end)
+
+do   -- auxiliary buffer
+  local lim = 100
+  local a = {}; for i = 1, lim do a[i] = "01234567890123456789" end
+  testamem("auxiliary buffer", function ()
+    return (#table.concat(a, ",") == 20*lim + lim - 1)
+  end)
+end
+
+print'+'
+
+-- testing some auxlib functions
+local function gsub (a, b, c)
+  a, b = T.testC("gsub 2 3 4; gettop; return 2", a, b, c)
+  assert(b == 5)
+  return a
+end
+
+assert(gsub("alo.alo.uhuh.", ".", "//") == "alo//alo//uhuh//")
+assert(gsub("alo.alo.uhuh.", "alo", "//") == "//.//.uhuh.")
+assert(gsub("", "alo", "//") == "")
+assert(gsub("...", ".", "/.") == "/././.")
+assert(gsub("...", "...", "") == "")
+
+
+-- testing luaL_newmetatable
+local mt_xuxu, res, top = T.testC("newmetatable xuxu; gettop; return 3")
+assert(type(mt_xuxu) == "table" and res and top == 3)
+local d, res, top = T.testC("newmetatable xuxu; gettop; return 3")
+assert(mt_xuxu == d and not res and top == 3)
+d, res, top = T.testC("newmetatable xuxu1; gettop; return 3")
+assert(mt_xuxu ~= d and res and top == 3)
+
+x = T.newuserdata(0);
+y = T.newuserdata(0);
+T.testC("pushstring xuxu; gettable R; setmetatable 2", x)
+assert(getmetatable(x) == mt_xuxu)
+
+-- testing luaL_testudata
+-- correct metatable
+local res1, res2, top = T.testC([[testudata -1 xuxu
+                                  testudata 2 xuxu
+                                  gettop
+                                  return 3]], x)
+assert(res1 and res2 and top == 4)
+
+-- wrong metatable
+res1, res2, top = T.testC([[testudata -1 xuxu1
+                            testudata 2 xuxu1
+                            gettop
+                            return 3]], x)
+assert(not res1 and not res2 and top == 4)
+
+-- non-existent type
+res1, res2, top = T.testC([[testudata -1 xuxu2
+                            testudata 2 xuxu2
+                            gettop
+                            return 3]], x)
+assert(not res1 and not res2 and top == 4)
+
+-- userdata has no metatable
+res1, res2, top = T.testC([[testudata -1 xuxu
+                            testudata 2 xuxu
+                            gettop
+                            return 3]], y)
+assert(not res1 and not res2 and top == 4)
+
+-- erase metatables
+do
+  local r = debug.getregistry()
+  assert(r.xuxu == mt_xuxu and r.xuxu1 == d)
+  r.xuxu = nil; r.xuxu1 = nil
+end
+
+print'OK'
+
diff --git a/testes/attrib.lua b/testes/attrib.lua
new file mode 100644
index 00000000..993a96cc
--- /dev/null
+++ b/testes/attrib.lua
@@ -0,0 +1,470 @@
+-- $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
+
diff --git a/testes/big.lua b/testes/big.lua
new file mode 100644
index 00000000..1a1fa788
--- /dev/null
+++ b/testes/big.lua
@@ -0,0 +1,82 @@
+-- $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'
diff --git a/testes/bitwise.lua b/testes/bitwise.lua
new file mode 100755
index 00000000..786679f4
--- /dev/null
+++ b/testes/bitwise.lua
@@ -0,0 +1,328 @@
+-- $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'
+
diff --git a/testes/bwcoercion.lua b/testes/bwcoercion.lua
new file mode 100644
index 00000000..cd735ab0
--- /dev/null
+++ b/testes/bwcoercion.lua
@@ -0,0 +1,78 @@
+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
+
diff --git a/testes/calls.lua b/testes/calls.lua
new file mode 100644
index 00000000..6d6fb7b2
--- /dev/null
+++ b/testes/calls.lua
@@ -0,0 +1,401 @@
+-- $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
diff --git a/testes/closure.lua b/testes/closure.lua
new file mode 100644
index 00000000..15897ae6
--- /dev/null
+++ b/testes/closure.lua
@@ -0,0 +1,247 @@
+-- $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'
diff --git a/testes/code.lua b/testes/code.lua
new file mode 100644
index 00000000..0b9d142d
--- /dev/null
+++ b/testes/code.lua
@@ -0,0 +1,239 @@
+-- $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'
+
diff --git a/testes/constructs.lua b/testes/constructs.lua
new file mode 100644
index 00000000..cebd2572
--- /dev/null
+++ b/testes/constructs.lua
@@ -0,0 +1,313 @@
+-- $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'
diff --git a/testes/coroutine.lua b/testes/coroutine.lua
new file mode 100644
index 00000000..c8fc8572
--- /dev/null
+++ b/testes/coroutine.lua
@@ -0,0 +1,874 @@
+-- $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'
diff --git a/testes/db.lua b/testes/db.lua
new file mode 100644
index 00000000..004f57a7
--- /dev/null
+++ b/testes/db.lua
@@ -0,0 +1,857 @@
+-- $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"
+
diff --git a/testes/errors.lua b/testes/errors.lua
new file mode 100644
index 00000000..79d746c7
--- /dev/null
+++ b/testes/errors.lua
@@ -0,0 +1,537 @@
+-- $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')
diff --git a/testes/events.lua b/testes/events.lua
new file mode 100644
index 00000000..9136f99c
--- /dev/null
+++ b/testes/events.lua
@@ -0,0 +1,456 @@
+-- $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
+
+
diff --git a/testes/files.lua b/testes/files.lua
new file mode 100644
index 00000000..3cfe12d2
--- /dev/null
+++ b/testes/files.lua
@@ -0,0 +1,793 @@
+-- $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))
+
+
diff --git a/testes/gc.lua b/testes/gc.lua
new file mode 100644
index 00000000..93fd6d69
--- /dev/null
+++ b/testes/gc.lua
@@ -0,0 +1,624 @@
+-- $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')
diff --git a/testes/goto.lua b/testes/goto.lua
new file mode 100644
index 00000000..0372aa9d
--- /dev/null
+++ b/testes/goto.lua
@@ -0,0 +1,232 @@
+-- $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'
diff --git a/testes/heavy.lua b/testes/heavy.lua
new file mode 100644
index 00000000..889d9f49
--- /dev/null
+++ b/testes/heavy.lua
@@ -0,0 +1,72 @@
+-- $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"
diff --git a/testes/libs/lib1.c b/testes/libs/lib1.c
new file mode 100644
index 00000000..56b6ef41
--- /dev/null
+++ b/testes/libs/lib1.c
@@ -0,0 +1,44 @@
+#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;
+}
+
diff --git a/testes/libs/lib11.c b/testes/libs/lib11.c
new file mode 100644
index 00000000..377d0c48
--- /dev/null
+++ b/testes/libs/lib11.c
@@ -0,0 +1,10 @@
+#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);
+}
+
+
diff --git a/testes/libs/lib2.c b/testes/libs/lib2.c
new file mode 100644
index 00000000..bc9651ee
--- /dev/null
+++ b/testes/libs/lib2.c
@@ -0,0 +1,23 @@
+#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;
+}
+
+
diff --git a/testes/libs/lib21.c b/testes/libs/lib21.c
new file mode 100644
index 00000000..a39b683d
--- /dev/null
+++ b/testes/libs/lib21.c
@@ -0,0 +1,10 @@
+#include "lua.h"
+
+
+int luaopen_lib2 (lua_State *L);
+
+LUAMOD_API int luaopen_lib21 (lua_State *L) {
+  return luaopen_lib2(L);
+}
+
+
diff --git a/testes/libs/makefile b/testes/libs/makefile
new file mode 100644
index 00000000..9925fb00
--- /dev/null
+++ b/testes/libs/makefile
@@ -0,0 +1,26 @@
+# 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
diff --git a/testes/literals.lua b/testes/literals.lua
new file mode 100644
index 00000000..3922b3f5
--- /dev/null
+++ b/testes/literals.lua
@@ -0,0 +1,302 @@
+-- $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')
diff --git a/testes/locals.lua b/testes/locals.lua
new file mode 100644
index 00000000..f66f6f7a
--- /dev/null
+++ b/testes/locals.lua
@@ -0,0 +1,162 @@
+-- $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   -- }
+
diff --git a/testes/main.lua b/testes/main.lua
new file mode 100644
index 00000000..9fc20c1d
--- /dev/null
+++ b/testes/main.lua
@@ -0,0 +1,381 @@
+# 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")
diff --git a/testes/math.lua b/testes/math.lua
new file mode 100644
index 00000000..53ce9b5a
--- /dev/null
+++ b/testes/math.lua
@@ -0,0 +1,824 @@
+-- $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')
diff --git a/testes/nextvar.lua b/testes/nextvar.lua
new file mode 100644
index 00000000..ce7312e3
--- /dev/null
+++ b/testes/nextvar.lua
@@ -0,0 +1,631 @@
+-- $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"
diff --git a/testes/pm.lua b/testes/pm.lua
new file mode 100644
index 00000000..fde39ff0
--- /dev/null
+++ b/testes/pm.lua
@@ -0,0 +1,374 @@
+-- $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')
+
diff --git a/testes/sort.lua b/testes/sort.lua
new file mode 100644
index 00000000..d52feee8
--- /dev/null
+++ b/testes/sort.lua
@@ -0,0 +1,310 @@
+-- $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"
diff --git a/testes/strings.lua b/testes/strings.lua
new file mode 100644
index 00000000..c37a8e75
--- /dev/null
+++ b/testes/strings.lua
@@ -0,0 +1,379 @@
+-- $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')
+
diff --git a/testes/tpack.lua b/testes/tpack.lua
new file mode 100644
index 00000000..96bb4da4
--- /dev/null
+++ b/testes/tpack.lua
@@ -0,0 +1,322 @@
+-- $Id: tpack.lua,v 1.13 2016/11/07 13:11:28 roberto Exp $
+-- See Copyright Notice in file all.lua
+
+local pack = string.pack
+local packsize = string.packsize
+local unpack = string.unpack
+
+print "testing pack/unpack"
+
+-- maximum size for integers
+local NB = 16
+
+local sizeshort = packsize("h")
+local sizeint = packsize("i")
+local sizelong = packsize("l")
+local sizesize_t = packsize("T")
+local sizeLI = packsize("j")
+local sizefloat = packsize("f")
+local sizedouble = packsize("d")
+local sizenumber = packsize("n")
+local little = (pack("i2", 1) == "\1\0")
+local align = packsize("!xXi16")
+
+assert(1 <= sizeshort and sizeshort <= sizeint and sizeint <= sizelong and
+       sizefloat <= sizedouble)
+
+print("platform:")
+print(string.format(
+  "\tshort %d, int %d, long %d, size_t %d, float %d, double %d,\n\z
+   \tlua Integer %d, lua Number %d",
+   sizeshort, sizeint, sizelong, sizesize_t, sizefloat, sizedouble,
+   sizeLI, sizenumber))
+print("\t" .. (little and "little" or "big") .. " endian")
+print("\talignment: " .. align)
+
+
+-- check errors in arguments
+function checkerror (msg, f, ...)
+  local status, err = pcall(f, ...)
+  -- print(status, err, msg)
+  assert(not status and string.find(err, msg))
+end
+
+-- minimum behavior for integer formats
+assert(unpack("B", pack("B", 0xff)) == 0xff)
+assert(unpack("b", pack("b", 0x7f)) == 0x7f)
+assert(unpack("b", pack("b", -0x80)) == -0x80)
+
+assert(unpack("H", pack("H", 0xffff)) == 0xffff)
+assert(unpack("h", pack("h", 0x7fff)) == 0x7fff)
+assert(unpack("h", pack("h", -0x8000)) == -0x8000)
+
+assert(unpack("L", pack("L", 0xffffffff)) == 0xffffffff)
+assert(unpack("l", pack("l", 0x7fffffff)) == 0x7fffffff)
+assert(unpack("l", pack("l", -0x80000000)) == -0x80000000)
+
+
+for i = 1, NB do
+  -- small numbers with signal extension ("\xFF...")
+  local s = string.rep("\xff", i)
+  assert(pack("i" .. i, -1) == s)
+  assert(packsize("i" .. i) == #s)
+  assert(unpack("i" .. i, s) == -1)
+
+  -- small unsigned number ("\0...\xAA")
+  s = "\xAA" .. string.rep("\0", i - 1)
+  assert(pack("<I" .. i, 0xAA) == s)
+  assert(unpack("<I" .. i, s) == 0xAA)
+  assert(pack(">I" .. i, 0xAA) == s:reverse())
+  assert(unpack(">I" .. i, s:reverse()) == 0xAA)
+end
+
+do
+  local lnum = 0x13121110090807060504030201
+  local s = pack("<j", lnum)
+  assert(unpack("<j", s) == lnum)
+  assert(unpack("<i" .. sizeLI + 1, s .. "\0") == lnum)
+  assert(unpack("<i" .. sizeLI + 1, s .. "\0") == lnum)
+
+  for i = sizeLI + 1, NB do
+    local s = pack("<j", -lnum)
+    assert(unpack("<j", s) == -lnum)
+    -- strings with (correct) extra bytes
+    assert(unpack("<i" .. i, s .. ("\xFF"):rep(i - sizeLI)) == -lnum)
+    assert(unpack(">i" .. i, ("\xFF"):rep(i - sizeLI) .. s:reverse()) == -lnum)
+    assert(unpack("<I" .. i, s .. ("\0"):rep(i - sizeLI)) == -lnum)
+
+    -- overflows
+    checkerror("does not fit", unpack, "<I" .. i, ("\x00"):rep(i - 1) .. "\1")
+    checkerror("does not fit", unpack, ">i" .. i, "\1" .. ("\x00"):rep(i - 1))
+  end
+end
+
+for i = 1, sizeLI do
+  local lstr = "\1\2\3\4\5\6\7\8\9\10\11\12\13"
+  local lnum = 0x13121110090807060504030201
+  local n = lnum & (~(-1 << (i * 8)))
+  local s = string.sub(lstr, 1, i)
+  assert(pack("<i" .. i, n) == s)
+  assert(pack(">i" .. i, n) == s:reverse())
+  assert(unpack(">i" .. i, s:reverse()) == n)
+end
+
+-- sign extension
+do
+  local u = 0xf0
+  for i = 1, sizeLI - 1 do
+    assert(unpack("<i"..i, "\xf0"..("\xff"):rep(i - 1)) == -16)
+    assert(unpack(">I"..i, "\xf0"..("\xff"):rep(i - 1)) == u)
+    u = u * 256 + 0xff
+  end
+end
+
+-- mixed endianness
+do
+  assert(pack(">i2 <i2", 10, 20) == "\0\10\20\0")
+  local a, b = unpack("<i2 >i2", "\10\0\0\20")
+  assert(a == 10 and b == 20)
+  assert(pack("=i4", 2001) == pack("i4", 2001))
+end
+
+print("testing invalid formats")
+
+checkerror("out of limits", pack, "i0", 0)
+checkerror("out of limits", pack, "i" .. NB + 1, 0)
+checkerror("out of limits", pack, "!" .. NB + 1, 0)
+checkerror("%(17%) out of limits %[1,16%]", pack, "Xi" .. NB + 1)
+checkerror("invalid format option 'r'", pack, "i3r", 0)
+checkerror("16%-byte integer", unpack, "i16", string.rep('\3', 16))
+checkerror("not power of 2", pack, "!4i3", 0);
+checkerror("missing size", pack, "c", "")
+checkerror("variable%-length format", packsize, "s")
+checkerror("variable%-length format", packsize, "z")
+
+-- overflow in option size  (error will be in digit after limit)
+checkerror("invalid format", packsize, "c1" .. string.rep("0", 40))
+
+if packsize("i") == 4 then
+  -- result would be 2^31  (2^3 repetitions of 2^28 strings)
+  local s = string.rep("c268435456", 2^3)
+  checkerror("too large", packsize, s)
+  -- one less is OK
+  s = string.rep("c268435456", 2^3 - 1) .. "c268435455"
+  assert(packsize(s) == 0x7fffffff)
+end
+
+-- overflow in packing
+for i = 1, sizeLI - 1 do
+  local umax = (1 << (i * 8)) - 1
+  local max = umax >> 1
+  local min = ~max
+  checkerror("overflow", pack, "<I" .. i, -1)
+  checkerror("overflow", pack, "<I" .. i, min)
+  checkerror("overflow", pack, ">I" .. i, umax + 1)
+
+  checkerror("overflow", pack, ">i" .. i, umax)
+  checkerror("overflow", pack, ">i" .. i, max + 1)
+  checkerror("overflow", pack, "<i" .. i, min - 1)
+
+  assert(unpack(">i" .. i, pack(">i" .. i, max)) == max)
+  assert(unpack("<i" .. i, pack("<i" .. i, min)) == min)
+  assert(unpack(">I" .. i, pack(">I" .. i, umax)) == umax)
+end
+
+-- Lua integer size
+assert(unpack(">j", pack(">j", math.maxinteger)) == math.maxinteger)
+assert(unpack("<j", pack("<j", math.mininteger)) == math.mininteger)
+assert(unpack("<J", pack("<j", -1)) == -1)   -- maximum unsigned integer
+
+if little then
+  assert(pack("f", 24) == pack("<f", 24))
+else
+  assert(pack("f", 24) == pack(">f", 24))
+end
+
+print "testing pack/unpack of floating-point numbers" 
+
+for _, n in ipairs{0, -1.1, 1.9, 1/0, -1/0, 1e20, -1e20, 0.1, 2000.7} do
+    assert(unpack("n", pack("n", n)) == n)
+    assert(unpack("<n", pack("<n", n)) == n)
+    assert(unpack(">n", pack(">n", n)) == n)
+    assert(pack("<f", n) == pack(">f", n):reverse())
+    assert(pack(">d", n) == pack("<d", n):reverse())
+end
+
+-- for non-native precisions, test only with "round" numbers
+for _, n in ipairs{0, -1.5, 1/0, -1/0, 1e10, -1e9, 0.5, 2000.25} do
+  assert(unpack("<f", pack("<f", n)) == n)
+  assert(unpack(">f", pack(">f", n)) == n)
+  assert(unpack("<d", pack("<d", n)) == n)
+  assert(unpack(">d", pack(">d", n)) == n)
+end
+
+print "testing pack/unpack of strings"
+do
+  local s = string.rep("abc", 1000)
+  assert(pack("zB", s, 247) == s .. "\0\xF7")
+  local s1, b = unpack("zB", s .. "\0\xF9")
+  assert(b == 249 and s1 == s)
+  s1 = pack("s", s)
+  assert(unpack("s", s1) == s)
+
+  checkerror("does not fit", pack, "s1", s)
+
+  checkerror("contains zeros", pack, "z", "alo\0");
+
+  for i = 2, NB do
+    local s1 = pack("s" .. i, s)
+    assert(unpack("s" .. i, s1) == s and #s1 == #s + i)
+  end
+end
+
+do
+  local x = pack("s", "alo")
+  checkerror("too short", unpack, "s", x:sub(1, -2))
+  checkerror("too short", unpack, "c5", "abcd")
+  checkerror("out of limits", pack, "s100", "alo")
+end
+
+do
+  assert(pack("c0", "") == "")
+  assert(packsize("c0") == 0)
+  assert(unpack("c0", "") == "")
+  assert(pack("<! c3", "abc") == "abc")
+  assert(packsize("<! c3") == 3)
+  assert(pack(">!4 c6", "abcdef") == "abcdef")
+  assert(pack("c3", "123") == "123")
+  assert(pack("c0", "") == "")
+  assert(pack("c8", "123456") == "123456\0\0")
+  assert(pack("c88", "") == string.rep("\0", 88))
+  assert(pack("c188", "ab") == "ab" .. string.rep("\0", 188 - 2))
+  local a, b, c = unpack("!4 z c3", "abcdefghi\0xyz")
+  assert(a == "abcdefghi" and b == "xyz" and c == 14)
+  checkerror("longer than", pack, "c3", "1234")
+end
+
+
+-- testing multiple types and sequence
+do
+  local x = pack("<b h b f d f n i", 1, 2, 3, 4, 5, 6, 7, 8)
+  assert(#x == packsize("<b h b f d f n i"))
+  local a, b, c, d, e, f, g, h = unpack("<b h b f d f n i", x)
+  assert(a == 1 and b == 2 and c == 3 and d == 4 and e == 5 and f == 6 and
+         g == 7 and h == 8) 
+end
+
+print "testing alignment"
+do
+  assert(pack(" < i1 i2 ", 2, 3) == "\2\3\0")   -- no alignment by default
+  local x = pack(">!8 b Xh i4 i8 c1 Xi8", -12, 100, 200, "\xEC")
+  assert(#x == packsize(">!8 b Xh i4 i8 c1 Xi8"))
+  assert(x == "\xf4" .. "\0\0\0" ..
+              "\0\0\0\100" ..
+              "\0\0\0\0\0\0\0\xC8" .. 
+              "\xEC" .. "\0\0\0\0\0\0\0")
+  local a, b, c, d, pos = unpack(">!8 c1 Xh i4 i8 b Xi8 XI XH", x)
+  assert(a == "\xF4" and b == 100 and c == 200 and d == -20 and (pos - 1) == #x)
+
+  x = pack(">!4 c3 c4 c2 z i4 c5 c2 Xi4",
+                  "abc", "abcd", "xz", "hello", 5, "world", "xy")
+  assert(x == "abcabcdxzhello\0\0\0\0\0\5worldxy\0")
+  local a, b, c, d, e, f, g, pos = unpack(">!4 c3 c4 c2 z i4 c5 c2 Xh Xi4", x)
+  assert(a == "abc" and b == "abcd" and c == "xz" and d == "hello" and
+         e == 5 and f == "world" and g == "xy" and (pos - 1) % 4 == 0)
+
+  x = pack(" b b Xd b Xb x", 1, 2, 3)
+  assert(packsize(" b b Xd b Xb x") == 4)
+  assert(x == "\1\2\3\0")
+  a, b, c, pos = unpack("bbXdb", x)
+  assert(a == 1 and b == 2 and c == 3 and pos == #x)
+
+  -- only alignment
+  assert(packsize("!8 xXi8") == 8)
+  local pos = unpack("!8 xXi8", "0123456701234567"); assert(pos == 9)
+  assert(packsize("!8 xXi2") == 2)
+  local pos = unpack("!8 xXi2", "0123456701234567"); assert(pos == 3)
+  assert(packsize("!2 xXi2") == 2)
+  local pos = unpack("!2 xXi2", "0123456701234567"); assert(pos == 3)
+  assert(packsize("!2 xXi8") == 2)
+  local pos = unpack("!2 xXi8", "0123456701234567"); assert(pos == 3)
+  assert(packsize("!16 xXi16") == 16)
+  local pos = unpack("!16 xXi16", "0123456701234567"); assert(pos == 17)
+
+  checkerror("invalid next option", pack, "X")
+  checkerror("invalid next option", unpack, "XXi", "")
+  checkerror("invalid next option", unpack, "X i", "")
+  checkerror("invalid next option", pack, "Xc1")
+end
+
+do    -- testing initial position
+  local x = pack("i4i4i4i4", 1, 2, 3, 4)
+  for pos = 1, 16, 4 do
+    local i, p = unpack("i4", x, pos)
+    assert(i == pos//4 + 1 and p == pos + 4)
+  end
+
+  -- with alignment
+  for pos = 0, 12 do    -- will always round position to power of 2
+    local i, p = unpack("!4 i4", x, pos + 1)
+    assert(i == (pos + 3)//4 + 1 and p == i*4 + 1)
+  end
+
+  -- negative indices
+  local i, p = unpack("!4 i4", x, -4)
+  assert(i == 4 and p == 17)
+  local i, p = unpack("!4 i4", x, -7)
+  assert(i == 4 and p == 17)
+  local i, p = unpack("!4 i4", x, -#x)
+  assert(i == 1 and p == 5)
+
+  -- limits
+  for i = 1, #x + 1 do
+    assert(unpack("c0", x, i) == "")
+  end
+  checkerror("out of string", unpack, "c0", x, 0)
+  checkerror("out of string", unpack, "c0", x, #x + 2)
+  checkerror("out of string", unpack, "c0", x, -(#x + 1))
+ 
+end
+
+print "OK"
+
diff --git a/testes/utf8.lua b/testes/utf8.lua
new file mode 100644
index 00000000..ebc190b7
--- /dev/null
+++ b/testes/utf8.lua
@@ -0,0 +1,210 @@
+-- $Id: utf8.lua,v 1.12 2016/11/07 13:11:28 roberto Exp $
+-- See Copyright Notice in file all.lua
+
+print "testing UTF-8 library"
+
+local utf8 = require'utf8'
+
+
+local function checkerror (msg, f, ...)
+  local s, err = pcall(f, ...)
+  assert(not s and string.find(err, msg))
+end
+
+
+local function len (s)
+  return #string.gsub(s, "[\x80-\xBF]", "")
+end
+
+
+local justone = "^" .. utf8.charpattern .. "$"
+
+-- 't' is the list of codepoints of 's'
+local function checksyntax (s, t)
+  local ts = {"return '"}
+  for i = 1, #t do ts[i + 1] = string.format("\\u{%x}", t[i]) end
+  ts[#t + 2] = "'"
+  ts = table.concat(ts)
+  assert(assert(load(ts))() == s)
+end
+
+assert(utf8.offset("alo", 5) == nil)
+assert(utf8.offset("alo", -4) == nil)
+
+-- 't' is the list of codepoints of 's'
+local function check (s, t)
+  local l = utf8.len(s) 
+  assert(#t == l and len(s) == l)
+  assert(utf8.char(table.unpack(t)) == s)
+
+  assert(utf8.offset(s, 0) == 1)
+
+  checksyntax(s, t)
+
+  local t1 = {utf8.codepoint(s, 1, -1)}
+  assert(#t == #t1)
+  for i = 1, #t do assert(t[i] == t1[i]) end
+
+  for i = 1, l do
+    local pi = utf8.offset(s, i)        -- position of i-th char
+    local pi1 = utf8.offset(s, 2, pi)   -- position of next char
+    assert(string.find(string.sub(s, pi, pi1 - 1), justone))
+    assert(utf8.offset(s, -1, pi1) == pi)
+    assert(utf8.offset(s, i - l - 1) == pi)
+    assert(pi1 - pi == #utf8.char(utf8.codepoint(s, pi)))
+    for j = pi, pi1 - 1 do 
+      assert(utf8.offset(s, 0, j) == pi)
+    end
+    for j = pi + 1, pi1 - 1 do
+      assert(not utf8.len(s, j))
+    end
+   assert(utf8.len(s, pi, pi) == 1)
+   assert(utf8.len(s, pi, pi1 - 1) == 1)
+   assert(utf8.len(s, pi) == l - i + 1)
+   assert(utf8.len(s, pi1) == l - i)
+   assert(utf8.len(s, 1, pi) == i)
+  end
+
+  local i = 0
+  for p, c in utf8.codes(s) do
+    i = i + 1
+    assert(c == t[i] and p == utf8.offset(s, i))
+    assert(utf8.codepoint(s, p) == c)
+  end
+  assert(i == #t)
+
+  i = 0
+  for p, c in utf8.codes(s) do
+    i = i + 1
+    assert(c == t[i] and p == utf8.offset(s, i)) 
+  end
+  assert(i == #t)
+
+  i = 0
+  for c in string.gmatch(s, utf8.charpattern) do
+    i = i + 1
+    assert(c == utf8.char(t[i]))
+  end
+  assert(i == #t)
+
+  for i = 1, l do
+    assert(utf8.offset(s, i) == utf8.offset(s, i - l - 1, #s + 1))
+  end
+
+end
+
+
+do    -- error indication in utf8.len
+  local function check (s, p)
+    local a, b = utf8.len(s)
+    assert(not a and b == p)
+  end
+  check("abc\xE3def", 4)
+  check("汉字\x80", #("汉字") + 1)
+  check("\xF4\x9F\xBF", 1)
+  check("\xF4\x9F\xBF\xBF", 1)
+end
+
+-- error in utf8.codes
+checkerror("invalid UTF%-8 code",
+  function ()
+    local s = "ab\xff"
+    for c in utf8.codes(s) do assert(c) end
+  end)
+
+
+-- error in initial position for offset
+checkerror("position out of range", utf8.offset, "abc", 1, 5)
+checkerror("position out of range", utf8.offset, "abc", 1, -4)
+checkerror("position out of range", utf8.offset, "", 1, 2)
+checkerror("position out of range", utf8.offset, "", 1, -1)
+checkerror("continuation byte", utf8.offset, "𦧺", 1, 2)
+checkerror("continuation byte", utf8.offset, "𦧺", 1, 2)
+checkerror("continuation byte", utf8.offset, "\x80", 1)
+
+
+
+local s = "hello World"
+local t = {string.byte(s, 1, -1)}
+for i = 1, utf8.len(s) do assert(t[i] == string.byte(s, i)) end
+check(s, t)
+
+check("汉字/漢字", {27721, 23383, 47, 28450, 23383,})
+
+do
+  local s = "áéí\128"
+  local t = {utf8.codepoint(s,1,#s - 1)}
+  assert(#t == 3 and t[1] == 225 and t[2] == 233 and t[3] == 237)
+  checkerror("invalid UTF%-8 code", utf8.codepoint, s, 1, #s)
+  checkerror("out of range", utf8.codepoint, s, #s + 1)
+  t = {utf8.codepoint(s, 4, 3)}
+  assert(#t == 0)
+  checkerror("out of range", utf8.codepoint, s, -(#s + 1), 1)
+  checkerror("out of range", utf8.codepoint, s, 1, #s + 1)
+end
+
+assert(utf8.char() == "")
+assert(utf8.char(97, 98, 99) == "abc")
+
+assert(utf8.codepoint(utf8.char(0x10FFFF)) == 0x10FFFF)
+
+checkerror("value out of range", utf8.char, 0x10FFFF + 1)
+
+local function invalid (s)
+  checkerror("invalid UTF%-8 code", utf8.codepoint, s)
+  assert(not utf8.len(s))
+end
+
+-- UTF-8 representation for 0x11ffff (value out of valid range)
+invalid("\xF4\x9F\xBF\xBF")
+
+-- overlong sequences
+invalid("\xC0\x80")          -- zero
+invalid("\xC1\xBF")          -- 0x7F (should be coded in 1 byte)
+invalid("\xE0\x9F\xBF")      -- 0x7FF (should be coded in 2 bytes)
+invalid("\xF0\x8F\xBF\xBF")  -- 0xFFFF (should be coded in 3 bytes)
+
+
+-- invalid bytes
+invalid("\x80")  -- continuation byte
+invalid("\xBF")  -- continuation byte
+invalid("\xFE")  -- invalid byte
+invalid("\xFF")  -- invalid byte
+
+
+-- empty string
+check("", {})
+
+-- minimum and maximum values for each sequence size
+s = "\0 \x7F\z
+     \xC2\x80 \xDF\xBF\z
+     \xE0\xA0\x80 \xEF\xBF\xBF\z
+     \xF0\x90\x80\x80  \xF4\x8F\xBF\xBF"
+s = string.gsub(s, " ", "")
+check(s, {0,0x7F, 0x80,0x7FF, 0x800,0xFFFF, 0x10000,0x10FFFF})
+
+x = "日本語a-4\0éó"
+check(x, {26085, 26412, 35486, 97, 45, 52, 0, 233, 243})
+
+
+-- Supplementary Characters
+check("𣲷𠜎𠱓�𠵼ab𠺢",
+      {0x23CB7, 0x2070E, 0x20C53, 0x2107B, 0x20D7C, 0x61, 0x62, 0x20EA2,})
+
+check("𨳊𩶘𦧺𨳒𥄫𤓓\xF4\x8F\xBF\xBF",
+      {0x28CCA, 0x29D98, 0x269FA, 0x28CD2, 0x2512B, 0x244D3, 0x10ffff})
+
+
+local i = 0
+for p, c in string.gmatch(x, "()(" .. utf8.charpattern .. ")") do
+  i = i + 1
+  assert(utf8.offset(x, i) == p)
+  assert(utf8.len(x, p) == utf8.len(x) - i + 1)
+  assert(utf8.len(c) == 1)
+  for j = 1, #c - 1 do
+    assert(utf8.offset(x, 0, p + j - 1) == p)
+  end
+end
+
+print'ok'
+
diff --git a/testes/vararg.lua b/testes/vararg.lua
new file mode 100644
index 00000000..d617a98b
--- /dev/null
+++ b/testes/vararg.lua
@@ -0,0 +1,142 @@
+-- $Id: vararg.lua,v 1.25 2016/11/07 13:11:28 roberto Exp $
+-- See Copyright Notice in file all.lua
+
+print('testing vararg')
+
+function f(a, ...)
+  local arg = {n = select('#', ...), ...}
+  for i=1,arg.n do assert(a[i]==arg[i]) end
+  return arg.n
+end
+
+function c12 (...)
+  assert(arg == _G.arg)    -- no local 'arg'
+  local x = {...}; x.n = #x
+  local res = (x.n==2 and x[1] == 1 and x[2] == 2)
+  if res then res = 55 end
+  return res, 2
+end
+
+function vararg (...) return {n = select('#', ...), ...} end
+
+local call = function (f, args) return f(table.unpack(args, 1, args.n)) end
+
+assert(f() == 0)
+assert(f({1,2,3}, 1, 2, 3) == 3)
+assert(f({"alo", nil, 45, f, nil}, "alo", nil, 45, f, nil) == 5)
+
+assert(c12(1,2)==55)
+a,b = assert(call(c12, {1,2}))
+assert(a == 55 and b == 2)
+a = call(c12, {1,2;n=2})
+assert(a == 55 and b == 2)
+a = call(c12, {1,2;n=1})
+assert(not a)
+assert(c12(1,2,3) == false)
+local a = vararg(call(next, {_G,nil;n=2}))
+local b,c = next(_G)
+assert(a[1] == b and a[2] == c and a.n == 2)
+a = vararg(call(call, {c12, {1,2}}))
+assert(a.n == 2 and a[1] == 55 and a[2] == 2)
+a = call(print, {'+'})
+assert(a == nil)
+
+local t = {1, 10}
+function t:f (...) local arg = {...}; return self[...]+#arg end
+assert(t:f(1,4) == 3 and t:f(2) == 11)
+print('+')
+
+lim = 20
+local i, a = 1, {}
+while i <= lim do a[i] = i+0.3; i=i+1 end
+
+function f(a, b, c, d, ...)
+  local more = {...}
+  assert(a == 1.3 and more[1] == 5.3 and
+         more[lim-4] == lim+0.3 and not more[lim-3])
+end
+
+function g(a,b,c)
+  assert(a == 1.3 and b == 2.3 and c == 3.3)
+end
+
+call(f, a)
+call(g, a)
+
+a = {}
+i = 1
+while i <= lim do a[i] = i; i=i+1 end
+assert(call(math.max, a) == lim)
+
+print("+")
+
+
+-- new-style varargs
+
+function oneless (a, ...) return ... end
+
+function f (n, a, ...)
+  local b
+  assert(arg == _G.arg)   -- no local 'arg'
+  if n == 0 then
+    local b, c, d = ...
+    return a, b, c, d, oneless(oneless(oneless(...)))
+  else
+    n, b, a = n-1, ..., a
+    assert(b == ...)
+    return f(n, a, ...)
+  end
+end
+
+a,b,c,d,e = assert(f(10,5,4,3,2,1))
+assert(a==5 and b==4 and c==3 and d==2 and e==1)
+
+a,b,c,d,e = f(4)
+assert(a==nil and b==nil and c==nil and d==nil and e==nil)
+
+
+-- varargs for main chunks
+f = load[[ return {...} ]]
+x = f(2,3)
+assert(x[1] == 2 and x[2] == 3 and x[3] == nil)
+
+
+f = load[[
+  local x = {...}
+  for i=1,select('#', ...) do assert(x[i] == select(i, ...)) end
+  assert(x[select('#', ...)+1] == nil)
+  return true
+]]
+
+assert(f("a", "b", nil, {}, assert))
+assert(f())
+
+a = {select(3, table.unpack{10,20,30,40})}
+assert(#a == 2 and a[1] == 30 and a[2] == 40)
+a = {select(1)}
+assert(next(a) == nil)
+a = {select(-1, 3, 5, 7)}
+assert(a[1] == 7 and a[2] == nil)
+a = {select(-2, 3, 5, 7)}
+assert(a[1] == 5 and a[2] == 7 and a[3] == nil)
+pcall(select, 10000)
+pcall(select, -10000)
+
+
+-- bug in 5.2.2
+
+function f(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
+p11, p12, p13, p14, p15, p16, p17, p18, p19, p20,
+p21, p22, p23, p24, p25, p26, p27, p28, p29, p30,
+p31, p32, p33, p34, p35, p36, p37, p38, p39, p40,
+p41, p42, p43, p44, p45, p46, p48, p49, p50, ...)
+  local a1,a2,a3,a4,a5,a6,a7
+  local a8,a9,a10,a11,a12,a13,a14
+end
+
+-- assertion fail here
+f()
+
+
+print('OK')
+
diff --git a/testes/verybig.lua b/testes/verybig.lua
new file mode 100644
index 00000000..1cfd10be
--- /dev/null
+++ b/testes/verybig.lua
@@ -0,0 +1,152 @@
+-- $Id: verybig.lua,v 1.25 2016/11/07 13:11:28 roberto Exp $
+-- See Copyright Notice in file all.lua
+
+print "testing RK"
+
+-- testing opcodes with RK arguments larger than K limit
+local function foo ()
+  local dummy = {
+     -- fill first 256 entries in table of constants
+     1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+     17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
+     33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+     49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
+     65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
+     81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
+     97, 98, 99, 100, 101, 102, 103, 104,
+     105, 106, 107, 108, 109, 110, 111, 112,
+     113, 114, 115, 116, 117, 118, 119, 120,
+     121, 122, 123, 124, 125, 126, 127, 128,
+     129, 130, 131, 132, 133, 134, 135, 136,
+     137, 138, 139, 140, 141, 142, 143, 144,
+     145, 146, 147, 148, 149, 150, 151, 152,
+     153, 154, 155, 156, 157, 158, 159, 160,
+     161, 162, 163, 164, 165, 166, 167, 168,
+     169, 170, 171, 172, 173, 174, 175, 176,
+     177, 178, 179, 180, 181, 182, 183, 184,
+     185, 186, 187, 188, 189, 190, 191, 192,
+     193, 194, 195, 196, 197, 198, 199, 200,
+     201, 202, 203, 204, 205, 206, 207, 208,
+     209, 210, 211, 212, 213, 214, 215, 216,
+     217, 218, 219, 220, 221, 222, 223, 224,
+     225, 226, 227, 228, 229, 230, 231, 232,
+     233, 234, 235, 236, 237, 238, 239, 240,
+     241, 242, 243, 244, 245, 246, 247, 248,
+     249, 250, 251, 252, 253, 254, 255, 256,
+  }
+  assert(24.5 + 0.6 == 25.1)
+  local t = {foo = function (self, x) return x + self.x end, x = 10}
+  t.t = t
+  assert(t:foo(1.5) == 11.5)
+  assert(t.t:foo(0.5) == 10.5)   -- bug in 5.2 alpha
+  assert(24.3 == 24.3)
+  assert((function () return t.x end)() == 10)
+end
+
+
+foo()
+foo = nil
+
+if _soft then return 10 end
+
+print "testing large programs (>64k)"
+
+-- template to create a very big test file
+prog = [[$
+
+local a,b
+
+b = {$1$
+  b30009 = 65534,
+  b30010 = 65535,
+  b30011 = 65536,
+  b30012 = 65537,
+  b30013 = 16777214,
+  b30014 = 16777215,
+  b30015 = 16777216,
+  b30016 = 16777217,
+  b30017 = 0x7fffff,
+  b30018 = -0x7fffff,
+  b30019 = 0x1ffffff,
+  b30020 = -0x1ffffd,
+  b30021 = -65534,
+  b30022 = -65535,
+  b30023 = -65536,
+  b30024 = -0xffffff,
+  b30025 = 15012.5,
+  $2$
+};
+
+assert(b.a50008 == 25004 and b["a11"] == -5.5)
+assert(b.a33007 == -16503.5 and b.a50009 == -25004.5)
+assert(b["b"..30024] == -0xffffff)
+
+function b:xxx (a,b) return a+b end
+assert(b:xxx(10, 12) == 22)   -- pushself with non-constant index
+b.xxx = nil
+
+s = 0; n=0
+for a,b in pairs(b) do s=s+b; n=n+1 end
+-- with 32-bit floats, exact value of 's' depends on summation order
+assert(81800000.0 < s and s < 81860000 and n == 70001)
+
+a = nil; b = nil
+print'+'
+
+function f(x) b=x end
+
+a = f{$3$} or 10
+
+assert(a==10)
+assert(b[1] == "a10" and b[2] == 5 and b[#b-1] == "a50009")
+
+
+function xxxx (x) return b[x] end
+
+assert(xxxx(3) == "a11")
+
+a = nil; b=nil
+xxxx = nil
+
+return 10
+
+]]
+
+-- functions to fill in the $n$
+
+local function sig (x)
+  return (x % 2 == 0) and '' or '-'
+end
+
+F = {
+function ()   -- $1$
+  for i=10,50009 do
+    io.write('a', i, ' = ', sig(i), 5+((i-10)/2), ',\n')
+  end
+end,
+
+function ()   -- $2$
+  for i=30026,50009 do
+    io.write('b', i, ' = ', sig(i), 15013+((i-30026)/2), ',\n')
+  end
+end,
+
+function ()   -- $3$
+  for i=10,50009 do
+    io.write('"a', i, '", ', sig(i), 5+((i-10)/2), ',\n')
+  end
+end,
+}
+
+file = os.tmpname()
+io.output(file)
+for s in string.gmatch(prog, "$([^$]+)") do
+  local n = tonumber(s)
+  if not n then io.write(s) else F[n]() end
+end
+io.close()
+result = dofile(file)
+assert(os.remove(file))
+print'OK'
+return result
+