summaryrefslogtreecommitdiff
path: root/lib/lua/src/ltests.c
diff options
context:
space:
mode:
Diffstat (limited to 'lib/lua/src/ltests.c')
-rw-r--r--lib/lua/src/ltests.c1704
1 files changed, 852 insertions, 852 deletions
diff --git a/lib/lua/src/ltests.c b/lib/lua/src/ltests.c
index 79ae526..8e53314 100644
--- a/lib/lua/src/ltests.c
+++ b/lib/lua/src/ltests.c
@@ -1,852 +1,852 @@
-/*
-** $Id: ltests.c,v 1.2 2003-12-11 16:53:30 pixel Exp $
-** 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.3 2004-11-27 21:35:20 pixel Exp $
+** 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
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-24 17:38:45 +0000