ltests.c - external/github.com/lua/lua - Git at Google

 /*
 ** $Id: ltests.c,v 1.157 2003/04/03 13:35:34 roberto Exp roberto $
 ** Internal Module for Debugging of the Lua Implementation
 ** See Copyright Notice in lua.h
 */


 #include <ctype.h>
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #define ltests_c

 #include "lua.h"

 #include "lapi.h"
 #include "lauxlib.h"
 #include "lcode.h"
 #include "ldebug.h"
 #include "ldo.h"
 #include "lfunc.h"
 #include "lmem.h"
 #include "lopcodes.h"
 #include "lstate.h"
 #include "lstring.h"
 #include "ltable.h"
 #include "lualib.h"


 /*
 ** The whole module only makes sense with LUA_DEBUG on
 */
 #ifdef LUA_DEBUG


 #define lua_pushintegral(L,i)	lua_pushnumber(L, cast(lua_Number, (i)))


 static lua_State *lua_state = NULL;

 int islocked = 0;


 #define func_at(L,k)	(L->ci->base+(k) - 1)


 static void setnameval (lua_State *L, const char *name, int val) {
   lua_pushstring(L, name);
   lua_pushintegral(L, val);
   lua_settable(L, -3);
 }


 /*
 ** {======================================================================
 ** Controlled version for realloc.
 ** =======================================================================
 */

 #define MARK		0x55  /* 01010101 (a nice pattern) */

 #ifndef EXTERNMEMCHECK
 /* full memory check */
 #define HEADER	(sizeof(L_Umaxalign)) /* ensures maximum alignment for HEADER */
 #define MARKSIZE	16  /* size of marks after each block */
 #define blockhead(b)	(cast(char *, b) - HEADER)
 #define setsize(newblock, size)	(*cast(size_t *, newblock) = size)
 #define checkblocksize(b, size) (size == (*cast(size_t *, blockhead(b))))
 #define fillmem(mem,size)	memset(mem, -MARK, size)
 #else
 /* external memory check: don't do it twice */
 #define HEADER		0
 #define MARKSIZE	0
 #define blockhead(b)	(b)
 #define setsize(newblock, size)	/* empty */
 #define checkblocksize(b,size)	(1)
 #define fillmem(mem,size)	/* empty */
 #endif

 unsigned long memdebug_numblocks = 0;
 unsigned long memdebug_total = 0;
 unsigned long memdebug_maxmem = 0;
 unsigned long memdebug_memlimit = ULONG_MAX;


 static void *checkblock (void *block, size_t size) {
   void *b = blockhead(block);
   int i;
   for (i=0;i<MARKSIZE;i++)
     lua_assert(*(cast(char *, b)+HEADER+size+i) == MARK+i); /* corrupted block? */
   return b;
 }


 static void freeblock (void *block, size_t size) {
   if (block) {
     lua_assert(checkblocksize(block, size));
     block = checkblock(block, size);
     fillmem(block, size+HEADER+MARKSIZE);  /* erase block */
     free(block);  /* free original block */
     memdebug_numblocks--;
     memdebug_total -= size;
   }
 }


 void *debug_realloc (void *block, size_t oldsize, size_t size) {
   lua_assert(oldsize == 0 || checkblocksize(block, oldsize));
   /* ISO does not specify what realloc(NULL, 0) does */
   lua_assert(block != NULL || size > 0);
   if (size == 0) {
     freeblock(block, oldsize);
     return NULL;
   }
   else if (size > oldsize && memdebug_total+size-oldsize > memdebug_memlimit)
     return NULL;  /* to test memory allocation errors */
   else {
     void *newblock;
     int i;
     size_t realsize = HEADER+size+MARKSIZE;
     size_t commonsize = (oldsize < size) ? oldsize : size;
     if (realsize < size) return NULL;  /* overflow! */
     newblock = malloc(realsize);  /* alloc a new block */
     if (newblock == NULL) return NULL;
     if (block) {
       memcpy(cast(char *, newblock)+HEADER, block, commonsize);
       freeblock(block, oldsize);  /* erase (and check) old copy */
     }
     /* initialize new part of the block with something `weird' */
     fillmem(cast(char *, newblock)+HEADER+commonsize, size-commonsize);
     memdebug_total += size;
     if (memdebug_total > memdebug_maxmem)
       memdebug_maxmem = memdebug_total;
     memdebug_numblocks++;
     setsize(newblock, size);
     for (i=0;i<MARKSIZE;i++)
       *(cast(char *, newblock)+HEADER+size+i) = cast(char, MARK+i);
     return cast(char *, newblock)+HEADER;
   }
 }


 /* }====================================================================== */


 /*
 ** {======================================================
 ** Disassembler
 ** =======================================================
 */


 static char *buildop (Proto *p, int pc, char *buff) {
   Instruction i = p->code[pc];
   OpCode o = GET_OPCODE(i);
   const char *name = luaP_opnames[o];
   int line = getline(p, pc);
   sprintf(buff, "(%4d) %4d - ", line, pc);
   switch (getOpMode(o)) {
     case iABC:
       sprintf(buff+strlen(buff), "%-12s%4d %4d %4d", name,
               GETARG_A(i), GETARG_B(i), GETARG_C(i));
       break;
     case iABx:
       sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_Bx(i));
       break;
     case iAsBx:
       sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_sBx(i));
       break;
   }
   return buff;
 }


 #if 0
 void luaI_printcode (Proto *pt, int size) {
   int pc;
   for (pc=0; pc<size; pc++) {
     char buff[100];
     printf("%s\n", buildop(pt, pc, buff));
   }
   printf("-------\n");
 }
 #endif


 static int listcode (lua_State *L) {
   int pc;
   Proto *p;
   luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
                  1, "Lua function expected");
   p = clvalue(func_at(L, 1))->l.p;
   lua_newtable(L);
   setnameval(L, "maxstack", p->maxstacksize);
   setnameval(L, "numparams", p->numparams);
   for (pc=0; pc<p->sizecode; pc++) {
     char buff[100];
     lua_pushintegral(L, pc+1);
     lua_pushstring(L, buildop(p, pc, buff));
     lua_settable(L, -3);
   }
   return 1;
 }


 static int listk (lua_State *L) {
   Proto *p;
   int i;
   luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
                  1, "Lua function expected");
   p = clvalue(func_at(L, 1))->l.p;
   lua_newtable(L);
   for (i=0; i<p->sizek; i++) {
     lua_pushintegral(L, i+1);
     luaA_pushobject(L, p->k+i);
     lua_settable(L, -3);
   }
   return 1;
 }


 static int listlocals (lua_State *L) {
   Proto *p;
   int pc = luaL_checkint(L, 2) - 1;
   int i = 0;
   const char *name;
   luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
                  1, "Lua function expected");
   p = clvalue(func_at(L, 1))->l.p;
   while ((name = luaF_getlocalname(p, ++i, pc)) != NULL)
     lua_pushstring(L, name);
   return i-1;
 }

 /* }====================================================== */


 static int get_limits (lua_State *L) {
   lua_newtable(L);
   setnameval(L, "BITS_INT", BITS_INT);
   setnameval(L, "LFPF", LFIELDS_PER_FLUSH);
   setnameval(L, "MAXVARS", MAXVARS);
   setnameval(L, "MAXPARAMS", MAXPARAMS);
   setnameval(L, "MAXSTACK", MAXSTACK);
   setnameval(L, "MAXUPVALUES", MAXUPVALUES);
   return 1;
 }


 static int mem_query (lua_State *L) {
   if (lua_isnone(L, 1)) {
     lua_pushintegral(L, memdebug_total);
     lua_pushintegral(L, memdebug_numblocks);
     lua_pushintegral(L, memdebug_maxmem);
     return 3;
   }
   else {
     memdebug_memlimit = luaL_checkint(L, 1);
     return 0;
   }
 }


 static int hash_query (lua_State *L) {
   if (lua_isnone(L, 2)) {
     luaL_argcheck(L, lua_type(L, 1) == LUA_TSTRING, 1, "string expected");
     lua_pushintegral(L, tsvalue(func_at(L, 1))->tsv.hash);
   }
   else {
     TObject *o = func_at(L, 1);
     Table *t;
     luaL_checktype(L, 2, LUA_TTABLE);
     t = hvalue(func_at(L, 2));
     lua_pushintegral(L, luaH_mainposition(t, o) - t->node);
   }
   return 1;
 }


 static int stacklevel (lua_State *L) {
   unsigned long a = 0;
   lua_pushintegral(L, (int)(L->top - L->stack));
   lua_pushintegral(L, (int)(L->stack_last - L->stack));
   lua_pushintegral(L, (int)(L->ci - L->base_ci));
   lua_pushintegral(L, (int)(L->end_ci - L->base_ci));
   lua_pushintegral(L, (unsigned long)&a);
   return 5;
 }


 static int table_query (lua_State *L) {
   const Table *t;
   int i = luaL_optint(L, 2, -1);
   luaL_checktype(L, 1, LUA_TTABLE);
   t = hvalue(func_at(L, 1));
   if (i == -1) {
     lua_pushintegral(L, t->sizearray);
     lua_pushintegral(L, sizenode(t));
     lua_pushintegral(L, t->firstfree - t->node);
   }
   else if (i < t->sizearray) {
     lua_pushintegral(L, i);
     luaA_pushobject(L, &t->array[i]);
     lua_pushnil(L);
   }
   else if ((i -= t->sizearray) < sizenode(t)) {
     if (!ttisnil(gval(gnode(t, i))) ||
         ttisnil(gkey(gnode(t, i))) ||
         ttisnumber(gkey(gnode(t, i)))) {
       luaA_pushobject(L, gkey(gnode(t, i)));
     }
     else
       lua_pushstring(L, "<undef>");
     luaA_pushobject(L, gval(gnode(t, i)));
     if (t->node[i].next)
       lua_pushintegral(L, t->node[i].next - t->node);
     else
       lua_pushnil(L);
   }
   return 3;
 }


 static int string_query (lua_State *L) {
   stringtable *tb = &G(L)->strt;
   int s = luaL_optint(L, 2, 0) - 1;
   if (s==-1) {
     lua_pushintegral(L ,tb->nuse);
     lua_pushintegral(L ,tb->size);
     return 2;
   }
   else if (s < tb->size) {
     GCObject *ts;
     int n = 0;
     for (ts = tb->hash[s]; ts; ts = ts->gch.next) {
       setsvalue2s(L->top, gcotots(ts));
       incr_top(L);
       n++;
     }
     return n;
   }
   return 0;
 }


 static int tref (lua_State *L) {
   int level = lua_gettop(L);
   int lock = luaL_optint(L, 2, 1);
   luaL_checkany(L, 1);
   lua_pushvalue(L, 1);
   lua_pushintegral(L, lua_ref(L, lock));
   assert(lua_gettop(L) == level+1);  /* +1 for result */
   return 1;
 }

 static int getref (lua_State *L) {
   int level = lua_gettop(L);
   lua_getref(L, luaL_checkint(L, 1));
   assert(lua_gettop(L) == level+1);
   return 1;
 }

 static int unref (lua_State *L) {
   int level = lua_gettop(L);
   lua_unref(L, luaL_checkint(L, 1));
   assert(lua_gettop(L) == level);
   return 0;
 }

 static int metatable (lua_State *L) {
   luaL_checkany(L, 1);
   if (lua_isnone(L, 2)) {
     if (lua_getmetatable(L, 1) == 0)
       lua_pushnil(L);
   }
   else {
     lua_settop(L, 2);
     luaL_checktype(L, 2, LUA_TTABLE);
     lua_setmetatable(L, 1);
   }
   return 1;
 }


 static int upvalue (lua_State *L) {
   int n = luaL_checkint(L, 2);
   luaL_checktype(L, 1, LUA_TFUNCTION);
   if (lua_isnone(L, 3)) {
     const char *name = lua_getupvalue(L, 1, n);
     if (name == NULL) return 0;
     lua_pushstring(L, name);
     return 2;
   }
   else {
     const char *name = lua_setupvalue(L, 1, n);
     lua_pushstring(L, name);
     return 1;
   }
 }


 static int newuserdata (lua_State *L) {
   size_t size = luaL_checkint(L, 1);
   char *p = cast(char *, lua_newuserdata(L, size));
   while (size--) *p++ = '\0';
   return 1;
 }


 static int pushuserdata (lua_State *L) {
   lua_pushlightuserdata(L, cast(void *, luaL_checkint(L, 1)));
   return 1;
 }


 static int udataval (lua_State *L) {
   lua_pushintegral(L, cast(int, lua_touserdata(L, 1)));
   return 1;
 }


 static int doonnewstack (lua_State *L) {
   lua_State *L1 = lua_newthread(L);
   size_t l;
   const char *s = luaL_checklstring(L, 1, &l);
   int status = luaL_loadbuffer(L1, s, l, s);
   if (status == 0)
     status = lua_pcall(L1, 0, 0, 0);
   lua_pushintegral(L, status);
   return 1;
 }


 static int s2d (lua_State *L) {
   lua_pushnumber(L, *cast(const double *, luaL_checkstring(L, 1)));
   return 1;
 }

 static int d2s (lua_State *L) {
   double d = luaL_checknumber(L, 1);
   lua_pushlstring(L, cast(char *, &d), sizeof(d));
   return 1;
 }


 static int newstate (lua_State *L) {
   lua_State *L1 = lua_open();
   if (L1) {
     lua_userstateopen(L1);  /* init lock */
     lua_pushintegral(L, (unsigned long)L1);
   }
   else
     lua_pushnil(L);
   return 1;
 }


 static int loadlib (lua_State *L) {
   static const luaL_reg libs[] = {
     {"mathlibopen", luaopen_math},
     {"strlibopen", luaopen_string},
     {"iolibopen", luaopen_io},
     {"tablibopen", luaopen_table},
     {"dblibopen", luaopen_debug},
     {"baselibopen", luaopen_base},
     {NULL, NULL}
   };
   lua_State *L1 = cast(lua_State *,
                        cast(unsigned long, luaL_checknumber(L, 1)));
   lua_pushvalue(L1, LUA_GLOBALSINDEX);
   luaL_openlib(L1, NULL, libs, 0);
   return 0;
 }

 static int closestate (lua_State *L) {
   lua_State *L1 = cast(lua_State *, cast(unsigned long, luaL_checknumber(L, 1)));
   lua_close(L1);
   lua_unlock(L);  /* close cannot unlock that */
   return 0;
 }

 static int doremote (lua_State *L) {
   lua_State *L1 = cast(lua_State *,cast(unsigned long,luaL_checknumber(L, 1)));
   size_t lcode;
   const char *code = luaL_checklstring(L, 2, &lcode);
   int status;
   lua_settop(L1, 0);
   status = luaL_loadbuffer(L1, code, lcode, code);
   if (status == 0)
     status = lua_pcall(L1, 0, LUA_MULTRET, 0);
   if (status != 0) {
     lua_pushnil(L);
     lua_pushintegral(L, status);
     lua_pushstring(L, lua_tostring(L1, -1));
     return 3;
   }
   else {
     int i = 0;
     while (!lua_isnone(L1, ++i))
       lua_pushstring(L, lua_tostring(L1, i));
     lua_pop(L1, i-1);
     return i-1;
   }
 }


 static int log2_aux (lua_State *L) {
   lua_pushintegral(L, luaO_log2(luaL_checkint(L, 1)));
   return 1;
 }

 static int int2fb_aux (lua_State *L) {
   int b = luaO_int2fb(luaL_checkint(L, 1));
   lua_pushintegral(L, b);
   lua_pushintegral(L, fb2int(b));
   return 2;
 }


 static int test_do (lua_State *L) {
   const char *p = luaL_checkstring(L, 1);
   if (*p == '@')
     lua_dofile(L, p+1);
   else
     lua_dostring(L, p);
   return lua_gettop(L);
 }


 /*
 ** {======================================================
 ** function to test the API with C. It interprets a kind of assembler
 ** language with calls to the API, so the test can be driven by Lua code
 ** =======================================================
 */

 static const char *const delimits = " \t\n,;";

 static void skip (const char **pc) {
   while (**pc != '\0' && strchr(delimits, **pc)) (*pc)++;
 }

 static int getnum_aux (lua_State *L, const char **pc) {
   int res = 0;
   int sig = 1;
   skip(pc);
   if (**pc == '.') {
     res = cast(int, lua_tonumber(L, -1));
     lua_pop(L, 1);
     (*pc)++;
     return res;
   }
   else if (**pc == '-') {
     sig = -1;
     (*pc)++;
   }
   while (isdigit(cast(int, **pc))) res = res*10 + (*(*pc)++) - '0';
   return sig*res;
 }

 static const char *getname_aux (char *buff, const char **pc) {
   int i = 0;
   skip(pc);
   while (**pc != '\0' && !strchr(delimits, **pc))
     buff[i++] = *(*pc)++;
   buff[i] = '\0';
   return buff;
 }


 #define EQ(s1)	(strcmp(s1, inst) == 0)

 #define getnum	(getnum_aux(L, &pc))
 #define getname	(getname_aux(buff, &pc))


 static int testC (lua_State *L) {
   char buff[30];
   const char *pc = luaL_checkstring(L, 1);
   for (;;) {
     const char *inst = getname;
     if EQ("") return 0;
     else if EQ("isnumber") {
       lua_pushintegral(L, lua_isnumber(L, getnum));
     }
     else if EQ("isstring") {
       lua_pushintegral(L, lua_isstring(L, getnum));
     }
     else if EQ("istable") {
       lua_pushintegral(L, lua_istable(L, getnum));
     }
     else if EQ("iscfunction") {
       lua_pushintegral(L, lua_iscfunction(L, getnum));
     }
     else if EQ("isfunction") {
       lua_pushintegral(L, lua_isfunction(L, getnum));
     }
     else if EQ("isuserdata") {
       lua_pushintegral(L, lua_isuserdata(L, getnum));
     }
     else if EQ("isudataval") {
       lua_pushintegral(L, lua_islightuserdata(L, getnum));
     }
     else if EQ("isnil") {
       lua_pushintegral(L, lua_isnil(L, getnum));
     }
     else if EQ("isnull") {
       lua_pushintegral(L, lua_isnone(L, getnum));
     }
     else if EQ("tonumber") {
       lua_pushnumber(L, lua_tonumber(L, getnum));
     }
     else if EQ("tostring") {
       const char *s = lua_tostring(L, getnum);
       lua_pushstring(L, s);
     }
     else if EQ("strlen") {
       lua_pushintegral(L, lua_strlen(L, getnum));
     }
     else if EQ("tocfunction") {
       lua_pushcfunction(L, lua_tocfunction(L, getnum));
     }
     else if EQ("return") {
       return getnum;
     }
     else if EQ("gettop") {
       lua_pushintegral(L, lua_gettop(L));
     }
     else if EQ("settop") {
       lua_settop(L, getnum);
     }
     else if EQ("pop") {
       lua_pop(L, getnum);
     }
     else if EQ("pushnum") {
       lua_pushintegral(L, getnum);
     }
     else if EQ("pushnil") {
       lua_pushnil(L);
     }
     else if EQ("pushbool") {
       lua_pushboolean(L, getnum);
     }
     else if EQ("tobool") {
       lua_pushintegral(L, lua_toboolean(L, getnum));
     }
     else if EQ("pushvalue") {
       lua_pushvalue(L, getnum);
     }
     else if EQ("pushcclosure") {
       lua_pushcclosure(L, testC, getnum);
     }
     else if EQ("pushupvalues") {
       lua_pushupvalues(L);
     }
     else if EQ("remove") {
       lua_remove(L, getnum);
     }
     else if EQ("insert") {
       lua_insert(L, getnum);
     }
     else if EQ("replace") {
       lua_replace(L, getnum);
     }
     else if EQ("gettable") {
       lua_gettable(L, getnum);
     }
     else if EQ("settable") {
       lua_settable(L, getnum);
     }
     else if EQ("next") {
       lua_next(L, -2);
     }
     else if EQ("concat") {
       lua_concat(L, getnum);
     }
     else if EQ("lessthan") {
       int a = getnum;
       lua_pushboolean(L, lua_lessthan(L, a, getnum));
     }
     else if EQ("equal") {
       int a = getnum;
       lua_pushboolean(L, lua_equal(L, a, getnum));
     }
     else if EQ("rawcall") {
       int narg = getnum;
       int nres = getnum;
       lua_call(L, narg, nres);
     }
     else if EQ("call") {
       int narg = getnum;
       int nres = getnum;
       lua_pcall(L, narg, nres, 0);
     }
     else if EQ("loadstring") {
       size_t sl;
       const char *s = luaL_checklstring(L, getnum, &sl);
       luaL_loadbuffer(L, s, sl, s);
     }
     else if EQ("loadfile") {
       luaL_loadfile(L, luaL_checkstring(L, getnum));
     }
     else if EQ("setmetatable") {
       lua_setmetatable(L, getnum);
     }
     else if EQ("getmetatable") {
       if (lua_getmetatable(L, getnum) == 0)
         lua_pushnil(L);
     }
     else if EQ("type") {
       lua_pushstring(L, lua_typename(L, lua_type(L, getnum)));
     }
     else if EQ("getn") {
       int i = getnum;
       lua_pushintegral(L, luaL_getn(L, i));
     }
     else if EQ("setn") {
       int i = getnum;
       int n = cast(int, lua_tonumber(L, -1));
       luaL_setn(L, i, n);
       lua_pop(L, 1);
     }
     else luaL_error(L, "unknown instruction %s", buff);
   }
   return 0;
 }

 /* }====================================================== */


 /*
 ** {======================================================
 ** tests for yield inside hooks
 ** =======================================================
 */

 static void yieldf (lua_State *L, lua_Debug *ar) {
   lua_yield(L, 0);
 }

 static int setyhook (lua_State *L) {
   if (lua_isnoneornil(L, 1))
     lua_sethook(L, NULL, 0, 0);  /* turn off hooks */
   else {
     const char *smask = luaL_checkstring(L, 1);
     int count = luaL_optint(L, 2, 0);
     int mask = 0;
     if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
     if (count > 0) mask |= LUA_MASKCOUNT;
     lua_sethook(L, yieldf, mask, count);
   }
   return 0;
 }


 static int coresume (lua_State *L) {
   int status;
   lua_State *co = lua_tothread(L, 1);
   luaL_argcheck(L, co, 1, "coroutine expected");
   status = lua_resume(co, 0);
   if (status != 0) {
     lua_pushboolean(L, 0);
     lua_insert(L, -2);
     return 2;  /* return false + error message */
   }
   else {
     lua_pushboolean(L, 1);
     return 1;
   }
 }

 /* }====================================================== */


 static const struct luaL_reg tests_funcs[] = {
   {"hash", hash_query},
   {"limits", get_limits},
   {"listcode", listcode},
   {"listk", listk},
   {"listlocals", listlocals},
   {"loadlib", loadlib},
   {"stacklevel", stacklevel},
   {"querystr", string_query},
   {"querytab", table_query},
   {"doit", test_do},
   {"testC", testC},
   {"ref", tref},
   {"getref", getref},
   {"unref", unref},
   {"d2s", d2s},
   {"s2d", s2d},
   {"metatable", metatable},
   {"upvalue", upvalue},
   {"newuserdata", newuserdata},
   {"pushuserdata", pushuserdata},
   {"udataval", udataval},
   {"doonnewstack", doonnewstack},
   {"newstate", newstate},
   {"closestate", closestate},
   {"doremote", doremote},
   {"log2", log2_aux},
   {"int2fb", int2fb_aux},
   {"totalmem", mem_query},
   {"resume", coresume},
   {"setyhook", setyhook},
   {NULL, NULL}
 };


 static void fim (void) {
   if (!islocked)
     lua_close(lua_state);
   lua_assert(memdebug_numblocks == 0);
   lua_assert(memdebug_total == 0);
 }


 static int l_panic (lua_State *L) {
   UNUSED(L);
   fprintf(stderr, "unable to recover; exiting\n");
   return 0;
 }


 int luaB_opentests (lua_State *L) {
   lua_atpanic(L, l_panic);
   lua_userstateopen(L);  /* init lock */
   lua_state = L;  /* keep first state to be opened */
   luaL_openlib(L, "T", tests_funcs, 0);
   atexit(fim);
   return 0;
 }


 #undef main
 int main (int argc, char *argv[]) {
   char *limit = getenv("MEMLIMIT");
   if (limit)
     memdebug_memlimit = strtoul(limit, NULL, 10);
   l_main(argc, argv);
   return 0;
 }

 #endif
	/*
	** $Id: ltests.c,v 1.157 2003/04/03 13:35:34 roberto Exp roberto $
	** Internal Module for Debugging of the Lua Implementation
	** See Copyright Notice in lua.h
	*/


	#include <ctype.h>
	#include <limits.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#define ltests_c

	#include "lua.h"

	#include "lapi.h"
	#include "lauxlib.h"
	#include "lcode.h"
	#include "ldebug.h"
	#include "ldo.h"
	#include "lfunc.h"
	#include "lmem.h"
	#include "lopcodes.h"
	#include "lstate.h"
	#include "lstring.h"
	#include "ltable.h"
	#include "lualib.h"



	/*
	** The whole module only makes sense with LUA_DEBUG on
	*/
	#ifdef LUA_DEBUG


	#define lua_pushintegral(L,i) lua_pushnumber(L, cast(lua_Number, (i)))


	static lua_State *lua_state = NULL;

	int islocked = 0;


	#define func_at(L,k) (L->ci->base+(k) - 1)


	static void setnameval (lua_State L, const char name, int val) {
	lua_pushstring(L, name);
	lua_pushintegral(L, val);
	lua_settable(L, -3);
	}


	/*
	** {======================================================================
	** Controlled version for realloc.
	** =======================================================================
	*/

	#define MARK 0x55 /* 01010101 (a nice pattern) */

	#ifndef EXTERNMEMCHECK
	/* full memory check */
	#define HEADER (sizeof(L_Umaxalign)) /* ensures maximum alignment for HEADER */
	#define MARKSIZE 16 /* size of marks after each block */
	#define blockhead(b) (cast(char *, b) - HEADER)
	#define setsize(newblock, size) (cast(size_t , newblock) = size)
	#define checkblocksize(b, size) (size == (cast(size_t , blockhead(b))))
	#define fillmem(mem,size) memset(mem, -MARK, size)
	#else
	/* external memory check: don't do it twice */
	#define HEADER 0
	#define MARKSIZE 0
	#define blockhead(b) (b)
	#define setsize(newblock, size) /* empty */
	#define checkblocksize(b,size) (1)
	#define fillmem(mem,size) /* empty */
	#endif

	unsigned long memdebug_numblocks = 0;
	unsigned long memdebug_total = 0;
	unsigned long memdebug_maxmem = 0;
	unsigned long memdebug_memlimit = ULONG_MAX;


	static void checkblock (void block, size_t size) {
	void *b = blockhead(block);
	int i;
	for (i=0;i<MARKSIZE;i++)
	lua_assert((cast(char , b)+HEADER+size+i) == MARK+i); /* corrupted block? */
	return b;
	}


	static void freeblock (void *block, size_t size) {
	if (block) {
	lua_assert(checkblocksize(block, size));
	block = checkblock(block, size);
	fillmem(block, size+HEADER+MARKSIZE); /* erase block */
	free(block); /* free original block */
	memdebug_numblocks--;
	memdebug_total -= size;
	}
	}


	void debug_realloc (void block, size_t oldsize, size_t size) {
	lua_assert(oldsize == 0 \|\| checkblocksize(block, oldsize));
	/* ISO does not specify what realloc(NULL, 0) does */
	lua_assert(block != NULL \|\| size > 0);
	if (size == 0) {
	freeblock(block, oldsize);
	return NULL;
	}
	else if (size > oldsize && memdebug_total+size-oldsize > memdebug_memlimit)
	return NULL; /* to test memory allocation errors */
	else {
	void *newblock;
	int i;
	size_t realsize = HEADER+size+MARKSIZE;
	size_t commonsize = (oldsize < size) ? oldsize : size;
	if (realsize < size) return NULL; /* overflow! */
	newblock = malloc(realsize); /* alloc a new block */
	if (newblock == NULL) return NULL;
	if (block) {
	memcpy(cast(char *, newblock)+HEADER, block, commonsize);
	freeblock(block, oldsize); /* erase (and check) old copy */
	}
	/* initialize new part of the block with something `weird' */
	fillmem(cast(char *, newblock)+HEADER+commonsize, size-commonsize);
	memdebug_total += size;
	if (memdebug_total > memdebug_maxmem)
	memdebug_maxmem = memdebug_total;
	memdebug_numblocks++;
	setsize(newblock, size);
	for (i=0;i<MARKSIZE;i++)
	(cast(char , newblock)+HEADER+size+i) = cast(char, MARK+i);
	return cast(char *, newblock)+HEADER;
	}
	}


	/* }====================================================================== */



	/*
	** {======================================================
	** Disassembler
	** =======================================================
	*/


	static char buildop (Proto p, int pc, char *buff) {
	Instruction i = p->code[pc];
	OpCode o = GET_OPCODE(i);
	const char *name = luaP_opnames[o];
	int line = getline(p, pc);
	sprintf(buff, "(%4d) %4d - ", line, pc);
	switch (getOpMode(o)) {
	case iABC:
	sprintf(buff+strlen(buff), "%-12s%4d %4d %4d", name,
	GETARG_A(i), GETARG_B(i), GETARG_C(i));
	break;
	case iABx:
	sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_Bx(i));
	break;
	case iAsBx:
	sprintf(buff+strlen(buff), "%-12s%4d %4d", name, GETARG_A(i), GETARG_sBx(i));
	break;
	}
	return buff;
	}


	#if 0
	void luaI_printcode (Proto *pt, int size) {
	int pc;
	for (pc=0; pc<size; pc++) {
	char buff[100];
	printf("%s\n", buildop(pt, pc, buff));
	}
	printf("-------\n");
	}
	#endif


	static int listcode (lua_State *L) {
	int pc;
	Proto *p;
	luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
	1, "Lua function expected");
	p = clvalue(func_at(L, 1))->l.p;
	lua_newtable(L);
	setnameval(L, "maxstack", p->maxstacksize);
	setnameval(L, "numparams", p->numparams);
	for (pc=0; pc<p->sizecode; pc++) {
	char buff[100];
	lua_pushintegral(L, pc+1);
	lua_pushstring(L, buildop(p, pc, buff));
	lua_settable(L, -3);
	}
	return 1;
	}


	static int listk (lua_State *L) {
	Proto *p;
	int i;
	luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
	1, "Lua function expected");
	p = clvalue(func_at(L, 1))->l.p;
	lua_newtable(L);
	for (i=0; i<p->sizek; i++) {
	lua_pushintegral(L, i+1);
	luaA_pushobject(L, p->k+i);
	lua_settable(L, -3);
	}
	return 1;
	}


	static int listlocals (lua_State *L) {
	Proto *p;
	int pc = luaL_checkint(L, 2) - 1;
	int i = 0;
	const char *name;
	luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
	1, "Lua function expected");
	p = clvalue(func_at(L, 1))->l.p;
	while ((name = luaF_getlocalname(p, ++i, pc)) != NULL)
	lua_pushstring(L, name);
	return i-1;
	}

	/* }====================================================== */




	static int get_limits (lua_State *L) {
	lua_newtable(L);
	setnameval(L, "BITS_INT", BITS_INT);
	setnameval(L, "LFPF", LFIELDS_PER_FLUSH);
	setnameval(L, "MAXVARS", MAXVARS);
	setnameval(L, "MAXPARAMS", MAXPARAMS);
	setnameval(L, "MAXSTACK", MAXSTACK);
	setnameval(L, "MAXUPVALUES", MAXUPVALUES);
	return 1;
	}


	static int mem_query (lua_State *L) {
	if (lua_isnone(L, 1)) {
	lua_pushintegral(L, memdebug_total);
	lua_pushintegral(L, memdebug_numblocks);
	lua_pushintegral(L, memdebug_maxmem);
	return 3;
	}
	else {
	memdebug_memlimit = luaL_checkint(L, 1);
	return 0;
	}
	}


	static int hash_query (lua_State *L) {
	if (lua_isnone(L, 2)) {
	luaL_argcheck(L, lua_type(L, 1) == LUA_TSTRING, 1, "string expected");
	lua_pushintegral(L, tsvalue(func_at(L, 1))->tsv.hash);
	}
	else {
	TObject *o = func_at(L, 1);
	Table *t;
	luaL_checktype(L, 2, LUA_TTABLE);
	t = hvalue(func_at(L, 2));
	lua_pushintegral(L, luaH_mainposition(t, o) - t->node);
	}
	return 1;
	}


	static int stacklevel (lua_State *L) {
	unsigned long a = 0;
	lua_pushintegral(L, (int)(L->top - L->stack));
	lua_pushintegral(L, (int)(L->stack_last - L->stack));
	lua_pushintegral(L, (int)(L->ci - L->base_ci));
	lua_pushintegral(L, (int)(L->end_ci - L->base_ci));
	lua_pushintegral(L, (unsigned long)&a);
	return 5;
	}


	static int table_query (lua_State *L) {
	const Table *t;
	int i = luaL_optint(L, 2, -1);
	luaL_checktype(L, 1, LUA_TTABLE);
	t = hvalue(func_at(L, 1));
	if (i == -1) {
	lua_pushintegral(L, t->sizearray);
	lua_pushintegral(L, sizenode(t));
	lua_pushintegral(L, t->firstfree - t->node);
	}
	else if (i < t->sizearray) {
	lua_pushintegral(L, i);
	luaA_pushobject(L, &t->array[i]);
	lua_pushnil(L);
	}
	else if ((i -= t->sizearray) < sizenode(t)) {
	if (!ttisnil(gval(gnode(t, i))) \|\|
	ttisnil(gkey(gnode(t, i))) \|\|
	ttisnumber(gkey(gnode(t, i)))) {
	luaA_pushobject(L, gkey(gnode(t, i)));
	}
	else
	lua_pushstring(L, "<undef>");
	luaA_pushobject(L, gval(gnode(t, i)));
	if (t->node[i].next)
	lua_pushintegral(L, t->node[i].next - t->node);
	else
	lua_pushnil(L);
	}
	return 3;
	}


	static int string_query (lua_State *L) {
	stringtable *tb = &G(L)->strt;
	int s = luaL_optint(L, 2, 0) - 1;
	if (s==-1) {
	lua_pushintegral(L ,tb->nuse);
	lua_pushintegral(L ,tb->size);
	return 2;
	}
	else if (s < tb->size) {
	GCObject *ts;
	int n = 0;
	for (ts = tb->hash[s]; ts; ts = ts->gch.next) {
	setsvalue2s(L->top, gcotots(ts));
	incr_top(L);
	n++;
	}
	return n;
	}
	return 0;
	}


	static int tref (lua_State *L) {
	int level = lua_gettop(L);
	int lock = luaL_optint(L, 2, 1);
	luaL_checkany(L, 1);
	lua_pushvalue(L, 1);
	lua_pushintegral(L, lua_ref(L, lock));
	assert(lua_gettop(L) == level+1); /* +1 for result */
	return 1;
	}

	static int getref (lua_State *L) {
	int level = lua_gettop(L);
	lua_getref(L, luaL_checkint(L, 1));
	assert(lua_gettop(L) == level+1);
	return 1;
	}

	static int unref (lua_State *L) {
	int level = lua_gettop(L);
	lua_unref(L, luaL_checkint(L, 1));
	assert(lua_gettop(L) == level);
	return 0;
	}

	static int metatable (lua_State *L) {
	luaL_checkany(L, 1);
	if (lua_isnone(L, 2)) {
	if (lua_getmetatable(L, 1) == 0)
	lua_pushnil(L);
	}
	else {
	lua_settop(L, 2);
	luaL_checktype(L, 2, LUA_TTABLE);
	lua_setmetatable(L, 1);
	}
	return 1;
	}


	static int upvalue (lua_State *L) {
	int n = luaL_checkint(L, 2);
	luaL_checktype(L, 1, LUA_TFUNCTION);
	if (lua_isnone(L, 3)) {
	const char *name = lua_getupvalue(L, 1, n);
	if (name == NULL) return 0;
	lua_pushstring(L, name);
	return 2;
	}
	else {
	const char *name = lua_setupvalue(L, 1, n);
	lua_pushstring(L, name);
	return 1;
	}
	}


	static int newuserdata (lua_State *L) {
	size_t size = luaL_checkint(L, 1);
	char p = cast(char , lua_newuserdata(L, size));
	while (size--) *p++ = '\0';
	return 1;
	}


	static int pushuserdata (lua_State *L) {
	lua_pushlightuserdata(L, cast(void *, luaL_checkint(L, 1)));
	return 1;
	}


	static int udataval (lua_State *L) {
	lua_pushintegral(L, cast(int, lua_touserdata(L, 1)));
	return 1;
	}


	static int doonnewstack (lua_State *L) {
	lua_State *L1 = lua_newthread(L);
	size_t l;
	const char *s = luaL_checklstring(L, 1, &l);
	int status = luaL_loadbuffer(L1, s, l, s);
	if (status == 0)
	status = lua_pcall(L1, 0, 0, 0);
	lua_pushintegral(L, status);
	return 1;
	}


	static int s2d (lua_State *L) {
	lua_pushnumber(L, cast(const double , luaL_checkstring(L, 1)));
	return 1;
	}

	static int d2s (lua_State *L) {
	double d = luaL_checknumber(L, 1);
	lua_pushlstring(L, cast(char *, &d), sizeof(d));
	return 1;
	}


	static int newstate (lua_State *L) {
	lua_State *L1 = lua_open();
	if (L1) {
	lua_userstateopen(L1); /* init lock */
	lua_pushintegral(L, (unsigned long)L1);
	}
	else
	lua_pushnil(L);
	return 1;
	}


	static int loadlib (lua_State *L) {
	static const luaL_reg libs[] = {
	{"mathlibopen", luaopen_math},
	{"strlibopen", luaopen_string},
	{"iolibopen", luaopen_io},
	{"tablibopen", luaopen_table},
	{"dblibopen", luaopen_debug},
	{"baselibopen", luaopen_base},
	{NULL, NULL}
	};
	lua_State L1 = cast(lua_State ,
	cast(unsigned long, luaL_checknumber(L, 1)));
	lua_pushvalue(L1, LUA_GLOBALSINDEX);
	luaL_openlib(L1, NULL, libs, 0);
	return 0;
	}

	static int closestate (lua_State *L) {
	lua_State L1 = cast(lua_State , cast(unsigned long, luaL_checknumber(L, 1)));
	lua_close(L1);
	lua_unlock(L); /* close cannot unlock that */
	return 0;
	}

	static int doremote (lua_State *L) {
	lua_State L1 = cast(lua_State ,cast(unsigned long,luaL_checknumber(L, 1)));
	size_t lcode;
	const char *code = luaL_checklstring(L, 2, &lcode);
	int status;
	lua_settop(L1, 0);
	status = luaL_loadbuffer(L1, code, lcode, code);
	if (status == 0)
	status = lua_pcall(L1, 0, LUA_MULTRET, 0);
	if (status != 0) {
	lua_pushnil(L);
	lua_pushintegral(L, status);
	lua_pushstring(L, lua_tostring(L1, -1));
	return 3;
	}
	else {
	int i = 0;
	while (!lua_isnone(L1, ++i))
	lua_pushstring(L, lua_tostring(L1, i));
	lua_pop(L1, i-1);
	return i-1;
	}
	}


	static int log2_aux (lua_State *L) {
	lua_pushintegral(L, luaO_log2(luaL_checkint(L, 1)));
	return 1;
	}

	static int int2fb_aux (lua_State *L) {
	int b = luaO_int2fb(luaL_checkint(L, 1));
	lua_pushintegral(L, b);
	lua_pushintegral(L, fb2int(b));
	return 2;
	}


	static int test_do (lua_State *L) {
	const char *p = luaL_checkstring(L, 1);
	if (*p == '@')
	lua_dofile(L, p+1);
	else
	lua_dostring(L, p);
	return lua_gettop(L);
	}



	/*
	** {======================================================
	** function to test the API with C. It interprets a kind of assembler
	** language with calls to the API, so the test can be driven by Lua code
	** =======================================================
	*/

	static const char *const delimits = " \t\n,;";

	static void skip (const char **pc) {
	while (pc != '\0' && strchr(delimits, pc)) (*pc)++;
	}

	static int getnum_aux (lua_State L, const char *pc) {
	int res = 0;
	int sig = 1;
	skip(pc);
	if (**pc == '.') {
	res = cast(int, lua_tonumber(L, -1));
	lua_pop(L, 1);
	(*pc)++;
	return res;
	}
	else if (**pc == '-') {
	sig = -1;
	(*pc)++;
	}
	while (isdigit(cast(int, *pc))) res = res10 + ((pc)++) - '0';
	return sig*res;
	}

	static const char getname_aux (char buff, const char **pc) {
	int i = 0;
	skip(pc);
	while (pc != '\0' && !strchr(delimits, pc))
	buff[i++] = (pc)++;
	buff[i] = '\0';
	return buff;
	}


	#define EQ(s1) (strcmp(s1, inst) == 0)

	#define getnum (getnum_aux(L, &pc))
	#define getname (getname_aux(buff, &pc))


	static int testC (lua_State *L) {
	char buff[30];
	const char *pc = luaL_checkstring(L, 1);
	for (;;) {
	const char *inst = getname;
	if EQ("") return 0;
	else if EQ("isnumber") {
	lua_pushintegral(L, lua_isnumber(L, getnum));
	}
	else if EQ("isstring") {
	lua_pushintegral(L, lua_isstring(L, getnum));
	}
	else if EQ("istable") {
	lua_pushintegral(L, lua_istable(L, getnum));
	}
	else if EQ("iscfunction") {
	lua_pushintegral(L, lua_iscfunction(L, getnum));
	}
	else if EQ("isfunction") {
	lua_pushintegral(L, lua_isfunction(L, getnum));
	}
	else if EQ("isuserdata") {
	lua_pushintegral(L, lua_isuserdata(L, getnum));
	}
	else if EQ("isudataval") {
	lua_pushintegral(L, lua_islightuserdata(L, getnum));
	}
	else if EQ("isnil") {
	lua_pushintegral(L, lua_isnil(L, getnum));
	}
	else if EQ("isnull") {
	lua_pushintegral(L, lua_isnone(L, getnum));
	}
	else if EQ("tonumber") {
	lua_pushnumber(L, lua_tonumber(L, getnum));
	}
	else if EQ("tostring") {
	const char *s = lua_tostring(L, getnum);
	lua_pushstring(L, s);
	}
	else if EQ("strlen") {
	lua_pushintegral(L, lua_strlen(L, getnum));
	}
	else if EQ("tocfunction") {
	lua_pushcfunction(L, lua_tocfunction(L, getnum));
	}
	else if EQ("return") {
	return getnum;
	}
	else if EQ("gettop") {
	lua_pushintegral(L, lua_gettop(L));
	}
	else if EQ("settop") {
	lua_settop(L, getnum);
	}
	else if EQ("pop") {
	lua_pop(L, getnum);
	}
	else if EQ("pushnum") {
	lua_pushintegral(L, getnum);
	}
	else if EQ("pushnil") {
	lua_pushnil(L);
	}
	else if EQ("pushbool") {
	lua_pushboolean(L, getnum);
	}
	else if EQ("tobool") {
	lua_pushintegral(L, lua_toboolean(L, getnum));
	}
	else if EQ("pushvalue") {
	lua_pushvalue(L, getnum);
	}
	else if EQ("pushcclosure") {
	lua_pushcclosure(L, testC, getnum);
	}
	else if EQ("pushupvalues") {
	lua_pushupvalues(L);
	}
	else if EQ("remove") {
	lua_remove(L, getnum);
	}
	else if EQ("insert") {
	lua_insert(L, getnum);
	}
	else if EQ("replace") {
	lua_replace(L, getnum);
	}
	else if EQ("gettable") {
	lua_gettable(L, getnum);
	}
	else if EQ("settable") {
	lua_settable(L, getnum);
	}
	else if EQ("next") {
	lua_next(L, -2);
	}
	else if EQ("concat") {
	lua_concat(L, getnum);
	}
	else if EQ("lessthan") {
	int a = getnum;
	lua_pushboolean(L, lua_lessthan(L, a, getnum));
	}
	else if EQ("equal") {
	int a = getnum;
	lua_pushboolean(L, lua_equal(L, a, getnum));
	}
	else if EQ("rawcall") {
	int narg = getnum;
	int nres = getnum;
	lua_call(L, narg, nres);
	}
	else if EQ("call") {
	int narg = getnum;
	int nres = getnum;
	lua_pcall(L, narg, nres, 0);
	}
	else if EQ("loadstring") {
	size_t sl;
	const char *s = luaL_checklstring(L, getnum, &sl);
	luaL_loadbuffer(L, s, sl, s);
	}
	else if EQ("loadfile") {
	luaL_loadfile(L, luaL_checkstring(L, getnum));
	}
	else if EQ("setmetatable") {
	lua_setmetatable(L, getnum);
	}
	else if EQ("getmetatable") {
	if (lua_getmetatable(L, getnum) == 0)
	lua_pushnil(L);
	}
	else if EQ("type") {
	lua_pushstring(L, lua_typename(L, lua_type(L, getnum)));
	}
	else if EQ("getn") {
	int i = getnum;
	lua_pushintegral(L, luaL_getn(L, i));
	}
	else if EQ("setn") {
	int i = getnum;
	int n = cast(int, lua_tonumber(L, -1));
	luaL_setn(L, i, n);
	lua_pop(L, 1);
	}
	else luaL_error(L, "unknown instruction %s", buff);
	}
	return 0;
	}

	/* }====================================================== */


	/*
	** {======================================================
	** tests for yield inside hooks
	** =======================================================
	*/

	static void yieldf (lua_State L, lua_Debug ar) {
	lua_yield(L, 0);
	}

	static int setyhook (lua_State *L) {
	if (lua_isnoneornil(L, 1))
	lua_sethook(L, NULL, 0, 0); /* turn off hooks */
	else {
	const char *smask = luaL_checkstring(L, 1);
	int count = luaL_optint(L, 2, 0);
	int mask = 0;
	if (strchr(smask, 'l')) mask \|= LUA_MASKLINE;
	if (count > 0) mask \|= LUA_MASKCOUNT;
	lua_sethook(L, yieldf, mask, count);
	}
	return 0;
	}


	static int coresume (lua_State *L) {
	int status;
	lua_State *co = lua_tothread(L, 1);
	luaL_argcheck(L, co, 1, "coroutine expected");
	status = lua_resume(co, 0);
	if (status != 0) {
	lua_pushboolean(L, 0);
	lua_insert(L, -2);
	return 2; /* return false + error message */
	}
	else {
	lua_pushboolean(L, 1);
	return 1;
	}
	}

	/* }====================================================== */



	static const struct luaL_reg tests_funcs[] = {
	{"hash", hash_query},
	{"limits", get_limits},
	{"listcode", listcode},
	{"listk", listk},
	{"listlocals", listlocals},
	{"loadlib", loadlib},
	{"stacklevel", stacklevel},
	{"querystr", string_query},
	{"querytab", table_query},
	{"doit", test_do},
	{"testC", testC},
	{"ref", tref},
	{"getref", getref},
	{"unref", unref},
	{"d2s", d2s},
	{"s2d", s2d},
	{"metatable", metatable},
	{"upvalue", upvalue},
	{"newuserdata", newuserdata},
	{"pushuserdata", pushuserdata},
	{"udataval", udataval},
	{"doonnewstack", doonnewstack},
	{"newstate", newstate},
	{"closestate", closestate},
	{"doremote", doremote},
	{"log2", log2_aux},
	{"int2fb", int2fb_aux},
	{"totalmem", mem_query},
	{"resume", coresume},
	{"setyhook", setyhook},
	{NULL, NULL}
	};


	static void fim (void) {
	if (!islocked)
	lua_close(lua_state);
	lua_assert(memdebug_numblocks == 0);
	lua_assert(memdebug_total == 0);
	}


	static int l_panic (lua_State *L) {
	UNUSED(L);
	fprintf(stderr, "unable to recover; exiting\n");
	return 0;
	}


	int luaB_opentests (lua_State *L) {
	lua_atpanic(L, l_panic);
	lua_userstateopen(L); /* init lock */
	lua_state = L; /* keep first state to be opened */
	luaL_openlib(L, "T", tests_funcs, 0);
	atexit(fim);
	return 0;
	}


	#undef main
	int main (int argc, char *argv[]) {
	char *limit = getenv("MEMLIMIT");
	if (limit)
	memdebug_memlimit = strtoul(limit, NULL, 10);
	l_main(argc, argv);
	return 0;
	}

	#endif