From 989ad7232af7d3c12848129e1f1ff01943535d0e Mon Sep 17 00:00:00 2001 From: Roberto Ierusalimschy Date: Fri, 2 Jun 2000 14:06:42 -0300 Subject: changed to test macros for single-state use --- ltests.c | 270 ++++++++++++++++++++++++++++++++------------------------------- 1 file changed, 136 insertions(+), 134 deletions(-) (limited to 'ltests.c') diff --git a/ltests.c b/ltests.c index eab1214c..f8464261 100644 --- a/ltests.c +++ b/ltests.c @@ -1,5 +1,5 @@ /* -** $Id: ltests.c,v 1.20 2000/05/22 18:44:46 roberto Exp roberto $ +** $Id: ltests.c,v 1.21 2000/05/26 19:17:57 roberto Exp roberto $ ** Internal Module for Debugging of the Lua Implementation ** See Copyright Notice in lua.h */ @@ -10,7 +10,6 @@ #include #include -#define LUA_REENTRANT #include "lapi.h" #include "lauxlib.h" @@ -35,11 +34,11 @@ void luaB_opentests (lua_State *L); -static void setnameval (lua_State *L, lua_Object t, const char *name, int val) { - lua_pushobject(L, t); - lua_pushstring(L, name); - lua_pushnumber(L, val); - lua_settable(L); +static void setnameval (lua_Object t, const char *name, int val) { + lua_pushobject(t); + lua_pushstring(name); + lua_pushnumber(val); + lua_settable(); } @@ -62,7 +61,7 @@ static const char *const instrname[OP_SETLINE+1] = { }; -static int pushop (lua_State *L, Instruction i) { +static int pushop (Instruction i) { char buff[100]; OpCode o = GET_OPCODE(i); const char *name = instrname[o]; @@ -80,98 +79,99 @@ static int pushop (lua_State *L, Instruction i) { sprintf(buff, "%-12s%4d %4d", name, GETARG_A(i), GETARG_B(i)); break; } - lua_pushstring(L, buff); + lua_pushstring(buff); return (o != OP_END); } -static void listcode (lua_State *L) { - lua_Object o = luaL_nonnullarg(L, 1); - lua_Object t = lua_createtable(L); +static void listcode (void) { + lua_Object o = luaL_nonnullarg(1); + lua_Object t = lua_createtable(); Instruction *pc; Proto *p; int res; - luaL_arg_check(L, ttype(o) == TAG_LCLOSURE, 1, "Lua function expected"); + luaL_arg_check(ttype(o) == TAG_LCLOSURE, 1, "Lua function expected"); p = clvalue(o)->f.l; - setnameval(L, t, "maxstack", p->maxstacksize); - setnameval(L, t, "numparams", p->numparams); + setnameval(t, "maxstack", p->maxstacksize); + setnameval(t, "numparams", p->numparams); pc = p->code; do { - lua_pushobject(L, t); - lua_pushnumber(L, pc - p->code + 1); - res = pushop(L, *pc++); - lua_settable(L); + lua_pushobject(t); + lua_pushnumber(pc - p->code + 1); + res = pushop(*pc++); + lua_settable(); } while (res); - lua_pushobject(L, t); + lua_pushobject(t); } /* }====================================================== */ -static void get_limits (lua_State *L) { - lua_Object t = lua_createtable(L); - setnameval(L, t, "SIZE_OP", SIZE_OP); - setnameval(L, t, "SIZE_U", SIZE_U); - setnameval(L, t, "SIZE_A", SIZE_A); - setnameval(L, t, "SIZE_B", SIZE_B); - setnameval(L, t, "MAXARG_U", MAXARG_U); - setnameval(L, t, "MAXARG_S", MAXARG_S); - setnameval(L, t, "MAXARG_A", MAXARG_A); - setnameval(L, t, "MAXARG_B", MAXARG_B); - setnameval(L, t, "MAXSTACK", MAXSTACK); - setnameval(L, t, "MAXLOCALS", MAXLOCALS); - setnameval(L, t, "MAXUPVALUES", MAXUPVALUES); - setnameval(L, t, "MAXVARSLH", MAXVARSLH); - setnameval(L, t, "MAXPARAMS", MAXPARAMS); - setnameval(L, t, "LFPF", LFIELDS_PER_FLUSH); - setnameval(L, t, "RFPF", RFIELDS_PER_FLUSH); - lua_pushobject(L, t); +static void get_limits (void) { + lua_Object t = lua_createtable(); + setnameval(t, "SIZE_OP", SIZE_OP); + setnameval(t, "SIZE_U", SIZE_U); + setnameval(t, "SIZE_A", SIZE_A); + setnameval(t, "SIZE_B", SIZE_B); + setnameval(t, "MAXARG_U", MAXARG_U); + setnameval(t, "MAXARG_S", MAXARG_S); + setnameval(t, "MAXARG_A", MAXARG_A); + setnameval(t, "MAXARG_B", MAXARG_B); + setnameval(t, "MAXSTACK", MAXSTACK); + setnameval(t, "MAXLOCALS", MAXLOCALS); + setnameval(t, "MAXUPVALUES", MAXUPVALUES); + setnameval(t, "MAXVARSLH", MAXVARSLH); + setnameval(t, "MAXPARAMS", MAXPARAMS); + setnameval(t, "LFPF", LFIELDS_PER_FLUSH); + setnameval(t, "RFPF", RFIELDS_PER_FLUSH); + lua_pushobject(t); } -static void mem_query (lua_State *L) { - lua_pushnumber(L, memdebug_total); - lua_pushnumber(L, memdebug_numblocks); - lua_pushnumber(L, memdebug_maxmem); +static void mem_query (void) { + lua_pushnumber(memdebug_total); + lua_pushnumber(memdebug_numblocks); + lua_pushnumber(memdebug_maxmem); } -static void hash_query (lua_State *L) { - lua_Object o = luaL_nonnullarg(L, 1); - if (lua_getparam(L, 2) == LUA_NOOBJECT) { - luaL_arg_check(L, ttype(o) == TAG_STRING, 1, "string expected"); - lua_pushnumber(L, tsvalue(o)->u.s.hash); +static void hash_query (void) { + lua_Object o = luaL_nonnullarg(1); + if (lua_getparam(2) == LUA_NOOBJECT) { + luaL_arg_check(ttype(o) == TAG_STRING, 1, "string expected"); + lua_pushnumber(tsvalue(o)->u.s.hash); } else { - const Hash *t = avalue(luaL_tablearg(L, 2)); - lua_pushnumber(L, luaH_mainposition(t, o) - t->node); + const Hash *t = avalue(luaL_tablearg(2)); + lua_pushnumber(luaH_mainposition(t, o) - t->node); } } -static void table_query (lua_State *L) { - const Hash *t = avalue(luaL_tablearg(L, 1)); - int i = luaL_opt_int(L, 2, -1); +static void table_query (void) { + const Hash *t = avalue(luaL_tablearg(1)); + int i = luaL_opt_int(2, -1); if (i == -1) { - lua_pushnumber(L, t->size); - lua_pushnumber(L, t->firstfree - t->node); + lua_pushnumber(t->size); + lua_pushnumber(t->firstfree - t->node); } else if (i < t->size) { - luaA_pushobject(L, &t->node[i].key); - luaA_pushobject(L, &t->node[i].val); + luaA_pushobject(lua_state, &t->node[i].key); + luaA_pushobject(lua_state, &t->node[i].val); if (t->node[i].next) - lua_pushnumber(L, t->node[i].next - t->node); + lua_pushnumber(t->node[i].next - t->node); } } -static void string_query (lua_State *L) { - stringtable *tb = (*luaL_check_string(L, 1) == 's') ? &L->strt : &L->udt; - int s = luaL_opt_int(L, 2, 0) - 1; +static void string_query (void) { + lua_State *L = lua_state; + stringtable *tb = (*luaL_check_string(1) == 's') ? &L->strt : &L->udt; + int s = luaL_opt_int(2, 0) - 1; if (s==-1) { - lua_pushnumber(L, tb->nuse); - lua_pushnumber(L, tb->size); + lua_pushnumber(tb->nuse); + lua_pushnumber(tb->size); } else if (s < tb->size) { TString *ts; @@ -203,9 +203,9 @@ static int getnum (const char **pc) { return res; } -static int getreg (lua_State *L, const char **pc) { +static int getreg (const char **pc) { skip(pc); - if (*(*pc)++ != 'r') lua_error(L, "`testC' expecting a register"); + if (*(*pc)++ != 'r') lua_error("`testC' expecting a register"); return getnum(pc); } @@ -223,149 +223,149 @@ static const char *getname (const char **pc) { #define EQ(s1) (strcmp(s1, inst) == 0) -static void testC (lua_State *L) { +static void testC (void) { lua_Object reg[10]; - const char *pc = luaL_check_string(L, 1); + const char *pc = luaL_check_string(1); for (;;) { const char *inst = getname(&pc); if EQ("") return; else if EQ("pushnum") { - lua_pushnumber(L, getnum(&pc)); + lua_pushnumber(getnum(&pc)); } else if EQ("createtable") { - reg[getreg(L, &pc)] = lua_createtable(L); + reg[getreg(&pc)] = lua_createtable(); } else if EQ("closure") { - lua_CFunction f = lua_getcfunction(L, lua_getglobal(L, getname(&pc))); - lua_pushcclosure(L, f, getnum(&pc)); + lua_CFunction f = lua_getcfunction(lua_getglobal(getname(&pc))); + lua_pushcclosure(f, getnum(&pc)); } else if EQ("pop") { - reg[getreg(L, &pc)] = lua_pop(L); + reg[getreg(&pc)] = lua_pop(); } else if EQ("getglobal") { - int n = getreg(L, &pc); - reg[n] = lua_getglobal(L, getname(&pc)); + int n = getreg(&pc); + reg[n] = lua_getglobal(getname(&pc)); } else if EQ("ref") { - lua_pushnumber(L, lua_ref(L, 0)); - reg[getreg(L, &pc)] = lua_pop(L); + lua_pushnumber(lua_ref(0)); + reg[getreg(&pc)] = lua_pop(); } else if EQ("reflock") { - lua_pushnumber(L, lua_ref(L, 1)); - reg[getreg(L, &pc)] = lua_pop(L); + lua_pushnumber(lua_ref(1)); + reg[getreg(&pc)] = lua_pop(); } else if EQ("getref") { - int n = getreg(L, &pc); - reg[n] = lua_getref(L, (int)lua_getnumber(L, reg[getreg(L, &pc)])); + int n = getreg(&pc); + reg[n] = lua_getref((int)lua_getnumber(reg[getreg(&pc)])); } else if EQ("unref") { - lua_unref(L, (int)lua_getnumber(L, reg[getreg(L, &pc)])); + lua_unref((int)lua_getnumber(reg[getreg(&pc)])); } else if EQ("getparam") { - int n = getreg(L, &pc); - reg[n] = lua_getparam(L, getnum(&pc)+1); /* skips the command itself */ + int n = getreg(&pc); + reg[n] = lua_getparam(getnum(&pc)+1); /* skips the command itself */ } else if EQ("getresult") { - int n = getreg(L, &pc); - reg[n] = lua_getparam(L, getnum(&pc)); + int n = getreg(&pc); + reg[n] = lua_getparam(getnum(&pc)); } else if EQ("setglobal") { - lua_setglobal(L, getname(&pc)); + lua_setglobal(getname(&pc)); } else if EQ("pushglobals") { - lua_pushglobaltable(L); + lua_pushglobaltable(); } else if EQ("pushstring") { - lua_pushstring(L, getname(&pc)); + lua_pushstring(getname(&pc)); } else if EQ("pushreg") { - lua_pushobject(L, reg[getreg(L, &pc)]); + lua_pushobject(reg[getreg(&pc)]); } else if EQ("call") { - if (lua_call(L, getname(&pc))) lua_error(L, NULL); + if (lua_call(getname(&pc))) lua_error(NULL); } else if EQ("gettable") { - reg[getreg(L, &pc)] = lua_gettable(L); + reg[getreg(&pc)] = lua_gettable(); } else if EQ("rawget") { - reg[getreg(L, &pc)] = lua_rawget(L); + reg[getreg(&pc)] = lua_rawget(); } else if EQ("settable") { - lua_settable(L); + lua_settable(); } else if EQ("rawset") { - lua_rawset(L); + lua_rawset(); } else if EQ("tag") { - lua_pushnumber(L, lua_tag(L, reg[getreg(L, &pc)])); + lua_pushnumber(lua_tag(reg[getreg(&pc)])); } else if EQ("type") { - lua_pushstring(L, lua_type(L, reg[getreg(L, &pc)])); + lua_pushstring(lua_type(reg[getreg(&pc)])); } else if EQ("next") { - int n = getreg(L, &pc); - n = lua_next(L, reg[n], (int)lua_getnumber(L, reg[getreg(L, &pc)])); - lua_pushnumber(L, n); + int n = getreg(&pc); + n = lua_next(reg[n], (int)lua_getnumber(reg[getreg(&pc)])); + lua_pushnumber(n); } else if EQ("equal") { - int n1 = getreg(L, &pc); - int n2 = getreg(L, &pc); - lua_pushnumber(L, lua_equal(L, reg[n1], reg[n2])); + int n1 = getreg(&pc); + int n2 = getreg(&pc); + lua_pushnumber(lua_equal(reg[n1], reg[n2])); } else if EQ("pushusertag") { - int val = getreg(L, &pc); - int tag = getreg(L, &pc); - lua_pushusertag(L, (void *)(int)lua_getnumber(L, reg[val]), - (int)lua_getnumber(L, reg[tag])); + int val = getreg(&pc); + int tag = getreg(&pc); + lua_pushusertag((void *)(int)lua_getnumber(reg[val]), + (int)lua_getnumber(reg[tag])); } else if EQ("udataval") { - int n = getreg(L, &pc); - lua_pushnumber(L, (int)lua_getuserdata(L, reg[getreg(L, &pc)])); - reg[n] = lua_pop(L); + int n = getreg(&pc); + lua_pushnumber((int)lua_getuserdata(reg[getreg(&pc)])); + reg[n] = lua_pop(); } else if EQ("settagmethod") { - int n = getreg(L, &pc); - lua_settagmethod(L, (int)lua_getnumber(L, reg[n]), getname(&pc)); + int n = getreg(&pc); + lua_settagmethod((int)lua_getnumber(reg[n]), getname(&pc)); } else if EQ("beginblock") { - lua_beginblock(L); + lua_beginblock(); } else if EQ("endblock") { - lua_endblock(L); + lua_endblock(); } else if EQ("newstate") { int stacksize = getnum(&pc); lua_State *L1 = lua_newstate("stack", stacksize, "builtin", getnum(&pc), NULL); - lua_pushuserdata(L, L1); + lua_pushuserdata(L1); } else if EQ("closestate") { - lua_close((lua_State *)lua_getuserdata(L, reg[getreg(L, &pc)])); + (lua_close)((lua_State *)lua_getuserdata(reg[getreg(&pc)])); } else if EQ("doremote") { - lua_Object ol1 = reg[getreg(L, &pc)]; - lua_Object str = reg[getreg(L, &pc)]; + lua_Object ol1 = reg[getreg(&pc)]; + lua_Object str = reg[getreg(&pc)]; lua_State *L1; lua_Object temp; int i; - if (!lua_isuserdata(L, ol1) || !lua_isstring(L, str)) - lua_error(L, "bad arguments for `doremote'"); - L1 = (lua_State *)lua_getuserdata(L, ol1); - lua_dostring(L1, lua_getstring(L, str)); + if (!lua_isuserdata(ol1) || !lua_isstring(str)) + lua_error("bad arguments for `doremote'"); + L1 = (lua_State *)lua_getuserdata(ol1); + (lua_dostring)(L1, lua_getstring(str)); i = 1; - while ((temp = lua_getresult(L1, i++)) != LUA_NOOBJECT) - lua_pushstring(L, lua_getstring(L1, temp)); + while ((temp = (lua_getresult)(L1, i++)) != LUA_NOOBJECT) + lua_pushstring((lua_getstring)(L1, temp)); } #if LUA_DEPRECATETFUNCS else if EQ("rawsetglobal") { - lua_rawsetglobal(L, getname(&pc)); + lua_rawsetglobal(getname(&pc)); } else if EQ("rawgetglobal") { - int n = getreg(L, &pc); - reg[n] = lua_rawgetglobal(L, getname(&pc)); + int n = getreg(&pc); + reg[n] = lua_rawgetglobal(getname(&pc)); } #endif - else luaL_verror(L, "unknown command in `testC': %.20s", inst); + else luaL_verror(lua_state, "unknown command in `testC': %.20s", inst); } } @@ -374,18 +374,20 @@ static void testC (lua_State *L) { static const struct luaL_reg tests_funcs[] = { - {"hash", hash_query}, - {"limits", get_limits}, - {"listcode", listcode}, - {"querystr", string_query}, - {"querytab", table_query}, - {"testC", testC}, - {"totalmem", mem_query} + {"hash", (lua_CFunction)hash_query}, + {"limits", (lua_CFunction)get_limits}, + {"listcode", (lua_CFunction)listcode}, + {"querystr", (lua_CFunction)string_query}, + {"querytab", (lua_CFunction)table_query}, + {"testC", (lua_CFunction)testC}, + {"totalmem", (lua_CFunction)mem_query} }; void luaB_opentests (lua_State *L) { - luaL_openl(L, tests_funcs); + if (lua_state != NULL) return; /* do not open tests for auxiliar states */ + lua_state = L; + luaL_openl(tests_funcs); } #endif -- cgit v1.2.3-55-g6feb