mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-01-31 11:37:35 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
cosmopolitan/third_party/lua/ltests.c
Justine Tunney 957c61cbbf
Release Cosmopolitan v3.3 
This change upgrades to GCC 12.3 and GNU binutils 2.42. The GNU linker
appears to have changed things so that only a single de-duplicated str
table is present in the binary, and it gets placed wherever the linker
wants, regardless of what the linker script says. To cope with that we
need to stop using .ident to embed licenses. As such, this change does
significant work to revamp how third party licenses are defined in the
codebase, using `.section .notice,"aR",@progbits`.

This new GCC 12.3 toolchain has support for GNU indirect functions. It
lets us support __target_clones__ for the first time. This is used for
optimizing the performance of libc string functions such as strlen and
friends so far on x86, by ensuring AVX systems favor a second codepath
that uses VEX encoding. It shaves some latency off certain operations.
It's a useful feature to have for scientific computing for the reasons
explained by the test/libcxx/openmp_test.cc example which compiles for
fifteen different microarchitectures. Thanks to the upgrades, it's now
also possible to use newer instruction sets, such as AVX512FP16, VNNI.

Cosmo now uses the %gs register on x86 by default for TLS. Doing it is
helpful for any program that links `cosmo_dlopen()`. Such programs had
to recompile their binaries at startup to change the TLS instructions.
That's not great, since it means every page in the executable needs to
be faulted. The work of rewriting TLS-related x86 opcodes, is moved to
fixupobj.com instead. This is great news for MacOS x86 users, since we
previously needed to morph the binary every time for that platform but
now that's no longer necessary. The only platforms where we need fixup
of TLS x86 opcodes at runtime are now Windows, OpenBSD, and NetBSD. On
Windows we morph TLS to point deeper into the TIB, based on a TlsAlloc
assignment, and on OpenBSD/NetBSD we morph %gs back into %fs since the
kernels do not allow us to specify a value for the %gs register.

OpenBSD users are now required to use APE Loader to run Cosmo binaries
and assimilation is no longer possible. OpenBSD kernel needs to change
to allow programs to specify a value for the %gs register, or it needs
to stop marking executable pages loaded by the kernel as mimmutable().

This release fixes __constructor__, .ctor, .init_array, and lastly the
.preinit_array so they behave the exact same way as glibc.

We no longer use hex constants to define math.h symbols like M_PI.
2024-02-20 13:27:59 -08:00

1985 lines
54 KiB
C
Raw Blame History

/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│ vi: set et ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi │
╚──────────────────────────────────────────────────────────────────────────────╝
│ │
│ Lua │
│ Copyright © 2004-2021 Lua.org, PUC-Rio. │
│ │
│ Permission is hereby granted, free of charge, to any person obtaining │
│ a copy of this software and associated documentation files (the │
│ "Software"), to deal in the Software without restriction, including │
│ without limitation the rights to use, copy, modify, merge, publish, │
│ distribute, sublicense, and/or sell copies of the Software, and to │
│ permit persons to whom the Software is furnished to do so, subject to │
│ the following conditions: │
│ │
│ The above copyright notice and this permission notice shall be │
│ included in all copies or substantial portions of the Software. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, │
│ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF │
│ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. │
│ IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY │
│ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, │
│ TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE │
│ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. │
│ │
╚─────────────────────────────────────────────────────────────────────────────*/
#define ltests_c
#define LUA_CORE
#include "third_party/lua/lapi.h"
#include "third_party/lua/lauxlib.h"
#include "third_party/lua/lcode.h"
#include "third_party/lua/lctype.h"
#include "third_party/lua/ldebug.h"
#include "third_party/lua/ldo.h"
#include "third_party/lua/lfunc.h"
#include "third_party/lua/lmem.h"
#include "third_party/lua/lopcodes.h"
#include "third_party/lua/lopnames.inc"
#include "third_party/lua/lprefix.h"
#include "third_party/lua/lstate.h"
#include "third_party/lua/lstring.h"
#include "third_party/lua/ltable.h"
#include "third_party/lua/lua.h"
#include "third_party/lua/lualib.h"
__static_yoink("lua_notice");
/*
** The whole module only makes sense with LUA_DEBUG on
*/
#if defined(LUA_DEBUG)
void *l_Trick = 0;
#define obj_at(L,k) s2v(L->ci->func + (k))
static int runC (lua_State *L, lua_State *L1, const char *pc);
static void setnameval (lua_State *L, const char *name, int val) {
lua_pushinteger(L, val);
lua_setfield(L, -2, name);
}
static void pushobject (lua_State *L, const TValue *o) {
setobj2s(L, L->top, o);
api_incr_top(L);
}
static void badexit (const char *fmt, const char *s1, const char *s2) {
fprintf(stderr, fmt, s1);
if (s2)
fprintf(stderr, "extra info: %s\n", s2);
/* avoid assertion failures when exiting */
l_memcontrol.numblocks = l_memcontrol.total = 0;
exit(EXIT_FAILURE);
}
static int tpanic (lua_State *L) {
const char *msg = lua_tostring(L, -1);
if (msg == NULL) msg = "error object is not a string";
return (badexit("PANIC: unprotected error in call to Lua API (%s)\n",
msg, NULL),
0); /* do not return to Lua */
}
/*
** Warning function for tests. First, it concatenates all parts of
** a warning in buffer 'buff'. Then, it has three modes:
** - 0.normal: messages starting with '#' are shown on standard output;
** - other messages abort the tests (they represent real warning
** conditions; the standard tests should not generate these conditions
** unexpectedly);
** - 1.allow: all messages are shown;
** - 2.store: all warnings go to the global '_WARN';
*/
static void warnf (void *ud, const char *msg, int tocont) {
lua_State *L = cast(lua_State *, ud);
static char buff[200] = ""; /* should be enough for tests... */
static int onoff = 0;
static int mode = 0; /* start in normal mode */
static int lasttocont = 0;
if (!lasttocont && !tocont && *msg == '@') { /* control message? */
if (buff[0] != '\0')
badexit("Control warning during warning: %s\naborting...\n", msg, buff);
if (strcmp(msg, "@off") == 0)
onoff = 0;
else if (strcmp(msg, "@on") == 0)
onoff = 1;
else if (strcmp(msg, "@normal") == 0)
mode = 0;
else if (strcmp(msg, "@allow") == 0)
mode = 1;
else if (strcmp(msg, "@store") == 0)
mode = 2;
else
badexit("Invalid control warning in test mode: %s\naborting...\n",
msg, NULL);
return;
}
lasttocont = tocont;
if (strlen(msg) >= sizeof(buff) - strlen(buff))
badexit("warnf-buffer overflow (%s)\n", msg, buff);
strcat(buff, msg); /* add new message to current warning */
if (!tocont) { /* message finished? */
lua_unlock(L);
luaL_checkstack(L, 1, "warn stack space");
lua_getglobal(L, "_WARN");
if (!lua_toboolean(L, -1))
lua_pop(L, 1); /* ok, no previous unexpected warning */
else {
badexit("Unhandled warning in store mode: %s\naborting...\n",
lua_tostring(L, -1), buff);
}
lua_lock(L);
switch (mode) {
case 0: { /* normal */
if (buff[0] != '#' && onoff) /* unexpected warning? */
badexit("Unexpected warning in test mode: %s\naborting...\n",
buff, NULL);
} /* FALLTHROUGH */
case 1: { /* allow */
if (onoff)
fprintf(stderr, "Lua warning: %s\n", buff); /* print warning */
break;
}
case 2: { /* store */
lua_unlock(L);
luaL_checkstack(L, 1, "warn stack space");
lua_pushstring(L, buff);
lua_setglobal(L, "_WARN"); /* assign message to global '_WARN' */
lua_lock(L);
break;
}
}
buff[0] = '\0'; /* prepare buffer for next warning */
}
}
/*
** {======================================================================
** Controlled version for realloc.
** =======================================================================
*/
#define MARK 0x55 /* 01010101 (a nice pattern) */
typedef union Header {
LUAI_MAXALIGN;
struct {
size_t size;
int type;
} d;
} Header;
#if !defined(EXTERNMEMCHECK)
/* full memory check */
#define MARKSIZE 16 /* size of marks after each block */
#define fillmem(mem,size) memset(mem, -MARK, size)
#else
/* external memory check: don't do it twice */
#define MARKSIZE 0
#define fillmem(mem,size) /* empty */
#endif
Memcontrol l_memcontrol =
{0, 0UL, 0UL, 0UL, 0UL, (~0UL),
{0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL, 0UL}};
static void freeblock (Memcontrol *mc, Header *block) {
if (block) {
size_t size = block->d.size;
int i;
for (i = 0; i < MARKSIZE; i++) /* check marks after block */
lua_assert(*(cast_charp(block + 1) + size + i) == MARK);
mc->objcount[block->d.type]--;
fillmem(block, sizeof(Header) + size + MARKSIZE); /* erase block */
free(block); /* actually free block */
mc->numblocks--; /* update counts */
mc->total -= size;
}
}
void *debug_realloc (void *ud, void *b, size_t oldsize, size_t size) {
Memcontrol *mc = cast(Memcontrol *, ud);
Header *block = cast(Header *, b);
int type;
if (mc->memlimit == 0) { /* first time? */
char *limit = getenv("MEMLIMIT"); /* initialize memory limit */
mc->memlimit = limit ? strtoul(limit, NULL, 10) : ULONG_MAX;
}
if (block == NULL) {
type = (oldsize < LUA_NUMTAGS) ? oldsize : 0;
oldsize = 0;
}
else {
block--; /* go to real header */
type = block->d.type;
lua_assert(oldsize == block->d.size);
}
if (size == 0) {
freeblock(mc, block);
return NULL;
}
if (mc->failnext) {
mc->failnext = 0;
return NULL; /* fake a single memory allocation error */
}
if (mc->countlimit != ~0UL && size != oldsize) { /* count limit in use? */
if (mc->countlimit == 0)
return NULL; /* fake a memory allocation error */
mc->countlimit--;
}
if (size > oldsize && mc->total+size-oldsize > mc->memlimit)
return NULL; /* fake a memory allocation error */
else {
Header *newblock;
int i;
size_t commonsize = (oldsize < size) ? oldsize : size;
size_t realsize = sizeof(Header) + size + MARKSIZE;
if (realsize < size) return NULL; /* arithmetic overflow! */
newblock = cast(Header *, malloc(realsize)); /* alloc a new block */
if (newblock == NULL)
return NULL; /* really out of memory? */
if (block) {
memcpy(newblock + 1, block + 1, commonsize); /* copy old contents */
freeblock(mc, block); /* erase (and check) old copy */
}
/* initialize new part of the block with something weird */
fillmem(cast_charp(newblock + 1) + commonsize, size - commonsize);
/* initialize marks after block */
for (i = 0; i < MARKSIZE; i++)
*(cast_charp(newblock + 1) + size + i) = MARK;
newblock->d.size = size;
newblock->d.type = type;
mc->total += size;
if (mc->total > mc->maxmem)
mc->maxmem = mc->total;
mc->numblocks++;
mc->objcount[type]++;
return newblock + 1;
}
}
/* }====================================================================== */
/*
** {=====================================================================
** Functions to check memory consistency.
** Most of these checks are done through asserts, so this code does
** not make sense with asserts off. For this reason, it uses 'assert'
** directly, instead of 'lua_assert'.
** ======================================================================
*/
#include <assert.h>
/*
** Check GC invariants. For incremental mode, a black object cannot
** point to a white one. For generational mode, really old objects
** cannot point to young objects. Both old1 and touched2 objects
** cannot point to new objects (but can point to survivals).
** (Threads and open upvalues, despite being marked "really old",
** continue to be visited in all collections, and therefore can point to
** new objects. They, and only they, are old but gray.)
*/
static int testobjref1 (global_State *g, GCObject *f, GCObject *t) {
if (isdead(g,t)) return 0;
if (issweepphase(g))
return 1; /* no invariants */
else if (g->gckind == KGC_INC)
return !(isblack(f) && iswhite(t)); /* basic incremental invariant */
else { /* generational mode */
if ((getage(f) == G_OLD && isblack(f)) && !isold(t))
return 0;
if (((getage(f) == G_OLD1 || getage(f) == G_TOUCHED2) && isblack(f)) &&
getage(t) == G_NEW)
return 0;
return 1;
}
}
static void printobj (global_State *g, GCObject *o) {
printf("||%s(%p)-%c%c(%02X)||",
ttypename(novariant(o->tt)), (void *)o,
isdead(g,o) ? 'd' : isblack(o) ? 'b' : iswhite(o) ? 'w' : 'g',
"ns01oTt"[getage(o)], o->marked);
if (o->tt == LUA_VSHRSTR || o->tt == LUA_VLNGSTR)
printf(" '%s'", getstr(gco2ts(o)));
}
void lua_printobj (lua_State *L, struct GCObject *o) {
printobj(G(L), o);
}
static int testobjref (global_State *g, GCObject *f, GCObject *t) {
int r1 = testobjref1(g, f, t);
if (!r1) {
printf("%d(%02X) - ", g->gcstate, g->currentwhite);
printobj(g, f);
printf(" -> ");
printobj(g, t);
printf("\n");
}
return r1;
}
static void checkobjref (global_State *g, GCObject *f, GCObject *t) {
assert(testobjref(g, f, t));
}
/*
** Version where 't' can be NULL. In that case, it should not apply the
** macro 'obj2gco' over the object. ('t' may have several types, so this
** definition must be a macro.) Most checks need this version, because
** the check may run while an object is still being created.
*/
#define checkobjrefN(g,f,t) { if (t) checkobjref(g,f,obj2gco(t)); }
static void checkvalref (global_State *g, GCObject *f, const TValue *t) {
assert(!iscollectable(t) || (righttt(t) && testobjref(g, f, gcvalue(t))));
}
static void checktable (global_State *g, Table *h) {
unsigned int i;
unsigned int asize = luaH_realasize(h);
Node *n, *limit = gnode(h, sizenode(h));
GCObject *hgc = obj2gco(h);
checkobjrefN(g, hgc, h->metatable);
for (i = 0; i < asize; i++)
checkvalref(g, hgc, &h->array[i]);
for (n = gnode(h, 0); n < limit; n++) {
if (!isempty(gval(n))) {
TValue k;
getnodekey(g->mainthread, &k, n);
assert(!keyisnil(n));
checkvalref(g, hgc, &k);
checkvalref(g, hgc, gval(n));
}
}
}
static void checkudata (global_State *g, Udata *u) {
int i;
GCObject *hgc = obj2gco(u);
checkobjrefN(g, hgc, u->metatable);
for (i = 0; i < u->nuvalue; i++)
checkvalref(g, hgc, &u->uv[i].uv);
}
static void checkproto (global_State *g, Proto *f) {
int i;
GCObject *fgc = obj2gco(f);
checkobjrefN(g, fgc, f->source);
for (i=0; i<f->sizek; i++) {
if (iscollectable(f->k + i))
checkobjref(g, fgc, gcvalue(f->k + i));
}
for (i=0; i<f->sizeupvalues; i++)
checkobjrefN(g, fgc, f->upvalues[i].name);
for (i=0; i<f->sizep; i++)
checkobjrefN(g, fgc, f->p[i]);
for (i=0; i<f->sizelocvars; i++)
checkobjrefN(g, fgc, f->locvars[i].varname);
}
static void checkCclosure (global_State *g, CClosure *cl) {
GCObject *clgc = obj2gco(cl);
int i;
for (i = 0; i < cl->nupvalues; i++)
checkvalref(g, clgc, &cl->upvalue[i]);
}
static void checkLclosure (global_State *g, LClosure *cl) {
GCObject *clgc = obj2gco(cl);
int i;
checkobjrefN(g, clgc, cl->p);
for (i=0; i<cl->nupvalues; i++) {
UpVal *uv = cl->upvals[i];
if (uv) {
checkobjrefN(g, clgc, uv);
if (!upisopen(uv))
checkvalref(g, obj2gco(uv), uv->v);
}
}
}
static int lua_checkpc (CallInfo *ci) {
if (!isLua(ci)) return 1;
else {
StkId f = ci->func;
Proto *p = clLvalue(s2v(f))->p;
return p->code <= ci->u.l.savedpc &&
ci->u.l.savedpc <= p->code + p->sizecode;
}
}
static void checkstack (global_State *g, lua_State *L1) {
StkId o;
CallInfo *ci;
UpVal *uv;
assert(!isdead(g, L1));
if (L1->stack == NULL) { /* incomplete thread? */
assert(L1->openupval == NULL && L1->ci == NULL);
return;
}
for (uv = L1->openupval; uv != NULL; uv = uv->u.open.next)
assert(upisopen(uv)); /* must be open */
assert(L1->top <= L1->stack_last);
assert(L1->tbclist <= L1->top);
for (ci = L1->ci; ci != NULL; ci = ci->previous) {
assert(ci->top <= L1->stack_last);
assert(lua_checkpc(ci));
}
for (o = L1->stack; o < L1->stack_last; o++)
checkliveness(L1, s2v(o)); /* entire stack must have valid values */
}
static void checkrefs (global_State *g, GCObject *o) {
switch (o->tt) {
case LUA_VUSERDATA: {
checkudata(g, gco2u(o));
break;
}
case LUA_VUPVAL: {
checkvalref(g, o, gco2upv(o)->v);
break;
}
case LUA_VTABLE: {
checktable(g, gco2t(o));
break;
}
case LUA_VTHREAD: {
checkstack(g, gco2th(o));
break;
}
case LUA_VLCL: {
checkLclosure(g, gco2lcl(o));
break;
}
case LUA_VCCL: {
checkCclosure(g, gco2ccl(o));
break;
}
case LUA_VPROTO: {
checkproto(g, gco2p(o));
break;
}
case LUA_VSHRSTR:
case LUA_VLNGSTR: {
assert(!isgray(o)); /* strings are never gray */
break;
}
default: assert(0);
}
}
/*
** Check consistency of an object:
** - Dead objects can only happen in the 'allgc' list during a sweep
** phase (controlled by the caller through 'maybedead').
** - During pause, all objects must be white.
** - In generational mode:
** * objects must be old enough for their lists ('listage').
** * old objects cannot be white.
** * old objects must be black, except for 'touched1', 'old0',
** threads, and open upvalues.
*/
static void checkobject (global_State *g, GCObject *o, int maybedead,
int listage) {
if (isdead(g, o))
assert(maybedead);
else {
assert(g->gcstate != GCSpause || iswhite(o));
if (g->gckind == KGC_GEN) { /* generational mode? */
assert(getage(o) >= listage);
assert(!iswhite(o) || !isold(o));
if (isold(o)) {
assert(isblack(o) ||
getage(o) == G_TOUCHED1 ||
getage(o) == G_OLD0 ||
o->tt == LUA_VTHREAD ||
(o->tt == LUA_VUPVAL && upisopen(gco2upv(o))));
}
}
checkrefs(g, o);
}
}
static lu_mem checkgraylist (global_State *g, GCObject *o) {
int total = 0; /* count number of elements in the list */
((void)g); /* better to keep it available if we need to print an object */
while (o) {
assert(!!isgray(o) ^ (getage(o) == G_TOUCHED2));
assert(!testbit(o->marked, TESTBIT));
if (keepinvariant(g))
l_setbit(o->marked, TESTBIT); /* mark that object is in a gray list */
total++;
switch (o->tt) {
case LUA_VTABLE: o = gco2t(o)->gclist; break;
case LUA_VLCL: o = gco2lcl(o)->gclist; break;
case LUA_VCCL: o = gco2ccl(o)->gclist; break;
case LUA_VTHREAD: o = gco2th(o)->gclist; break;
case LUA_VPROTO: o = gco2p(o)->gclist; break;
case LUA_VUSERDATA:
assert(gco2u(o)->nuvalue > 0);
o = gco2u(o)->gclist;
break;
default: assert(0); /* other objects cannot be in a gray list */
}
}
return total;
}
/*
** Check objects in gray lists.
*/
static lu_mem checkgrays (global_State *g) {
int total = 0; /* count number of elements in all lists */
if (!keepinvariant(g)) return total;
total += checkgraylist(g, g->gray);
total += checkgraylist(g, g->grayagain);
total += checkgraylist(g, g->weak);
total += checkgraylist(g, g->allweak);
total += checkgraylist(g, g->ephemeron);
return total;
}
/*
** Check whether 'o' should be in a gray list. If so, increment
** 'count' and check its TESTBIT. (It must have been previously set by
** 'checkgraylist'.)
*/
static void incifingray (global_State *g, GCObject *o, lu_mem *count) {
if (!keepinvariant(g))
return; /* gray lists not being kept in these phases */
if (o->tt == LUA_VUPVAL) {
/* only open upvalues can be gray */
assert(!isgray(o) || upisopen(gco2upv(o)));
return; /* upvalues are never in gray lists */
}
/* these are the ones that must be in gray lists */
if (isgray(o) || getage(o) == G_TOUCHED2) {
(*count)++;
assert(testbit(o->marked, TESTBIT));
resetbit(o->marked, TESTBIT); /* prepare for next cycle */
}
}
static lu_mem checklist (global_State *g, int maybedead, int tof,
GCObject *newl, GCObject *survival, GCObject *old, GCObject *reallyold) {
GCObject *o;
lu_mem total = 0; /* number of object that should be in gray lists */
for (o = newl; o != survival; o = o->next) {
checkobject(g, o, maybedead, G_NEW);
incifingray(g, o, &total);
assert(!tof == !tofinalize(o));
}
for (o = survival; o != old; o = o->next) {
checkobject(g, o, 0, G_SURVIVAL);
incifingray(g, o, &total);
assert(!tof == !tofinalize(o));
}
for (o = old; o != reallyold; o = o->next) {
checkobject(g, o, 0, G_OLD1);
incifingray(g, o, &total);
assert(!tof == !tofinalize(o));
}
for (o = reallyold; o != NULL; o = o->next) {
checkobject(g, o, 0, G_OLD);
incifingray(g, o, &total);
assert(!tof == !tofinalize(o));
}
return total;
}
int lua_checkmemory (lua_State *L) {
global_State *g = G(L);
GCObject *o;
int maybedead;
lu_mem totalin; /* total of objects that are in gray lists */
lu_mem totalshould; /* total of objects that should be in gray lists */
if (keepinvariant(g)) {
assert(!iswhite(g->mainthread));
assert(!iswhite(gcvalue(&g->l_registry)));
}
assert(!isdead(g, gcvalue(&g->l_registry)));
assert(g->sweepgc == NULL || issweepphase(g));
totalin = checkgrays(g);
/* check 'fixedgc' list */
for (o = g->fixedgc; o != NULL; o = o->next) {
assert(o->tt == LUA_VSHRSTR && isgray(o) && getage(o) == G_OLD);
}
/* check 'allgc' list */
maybedead = (GCSatomic < g->gcstate && g->gcstate <= GCSswpallgc);
totalshould = checklist(g, maybedead, 0, g->allgc,
g->survival, g->old1, g->reallyold);
/* check 'finobj' list */
totalshould += checklist(g, 0, 1, g->finobj,
g->finobjsur, g->finobjold1, g->finobjrold);
/* check 'tobefnz' list */
for (o = g->tobefnz; o != NULL; o = o->next) {
checkobject(g, o, 0, G_NEW);
incifingray(g, o, &totalshould);
assert(tofinalize(o));
assert(o->tt == LUA_VUSERDATA || o->tt == LUA_VTABLE);
}
if (keepinvariant(g))
assert(totalin == totalshould);
return 0;
}
/* }====================================================== */
/*
** {======================================================
** Disassembler
** =======================================================
*/
static char *buildop (Proto *p, int pc, char *buff) {
char *obuff = buff;
Instruction i = p->code[pc];
OpCode o = GET_OPCODE(i);
const char *name = opnames[o];
int line = luaG_getfuncline(p, pc);
int lineinfo = (p->lineinfo != NULL) ? p->lineinfo[pc] : 0;
if (lineinfo == ABSLINEINFO)
buff += sprintf(buff, "(__");
else
buff += sprintf(buff, "(%2d", lineinfo);
buff += sprintf(buff, " - %4d) %4d - ", line, pc);
switch (getOpMode(o)) {
case iABC:
sprintf(buff, "%-12s%4d %4d %4d%s", name,
GETARG_A(i), GETARG_B(i), GETARG_C(i),
GETARG_k(i) ? " (k)" : "");
break;
case iABx:
sprintf(buff, "%-12s%4d %4d", name, GETARG_A(i), GETARG_Bx(i));
break;
case iAsBx:
sprintf(buff, "%-12s%4d %4d", name, GETARG_A(i), GETARG_sBx(i));
break;
case iAx:
sprintf(buff, "%-12s%4d", name, GETARG_Ax(i));
break;
case isJ:
sprintf(buff, "%-12s%4d", name, GETARG_sJ(i));
break;
}
return obuff;
}
#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");
}
void luaI_printinst (Proto *pt, int pc) {
char buff[100];
printf("%s\n", buildop(pt, pc, buff));
}
#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 = getproto(obj_at(L, 1));
lua_newtable(L);
setnameval(L, "maxstack", p->maxstacksize);
setnameval(L, "numparams", p->numparams);
for (pc=0; pc<p->sizecode; pc++) {
char buff[100];
lua_pushinteger(L, pc+1);
lua_pushstring(L, buildop(p, pc, buff));
lua_settable(L, -3);
}
return 1;
}
static int printcode (lua_State *L) {
int pc;
Proto *p;
luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
1, "Lua function expected");
p = getproto(obj_at(L, 1));
printf("maxstack: %d\n", p->maxstacksize);
printf("numparams: %d\n", p->numparams);
for (pc=0; pc<p->sizecode; pc++) {
char buff[100];
printf("%s\n", buildop(p, pc, buff));
}
return 0;
}
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 = getproto(obj_at(L, 1));
lua_createtable(L, p->sizek, 0);
for (i=0; i<p->sizek; i++) {
pushobject(L, p->k+i);
lua_rawseti(L, -2, i+1);
}
return 1;
}
static int listabslineinfo (lua_State *L) {
Proto *p;
int i;
luaL_argcheck(L, lua_isfunction(L, 1) && !lua_iscfunction(L, 1),
1, "Lua function expected");
p = getproto(obj_at(L, 1));
luaL_argcheck(L, p->abslineinfo != NULL, 1, "function has no debug info");
lua_createtable(L, 2 * p->sizeabslineinfo, 0);
for (i=0; i < p->sizeabslineinfo; i++) {
lua_pushinteger(L, p->abslineinfo[i].pc);
lua_rawseti(L, -2, 2 * i + 1);
lua_pushinteger(L, p->abslineinfo[i].line);
lua_rawseti(L, -2, 2 * i + 2);
}
return 1;
}
static int listlocals (lua_State *L) {
Proto *p;
int pc = cast_int(luaL_checkinteger(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 = getproto(obj_at(L, 1));
while ((name = luaF_getlocalname(p, ++i, pc)) != NULL)
lua_pushstring(L, name);
return i-1;
}
/* }====================================================== */
static void printstack (lua_State *L) {
int i;
int n = lua_gettop(L);
printf("stack: >>\n");
for (i = 1; i <= n; i++) {
printf("%3d: %s\n", i, luaL_tolstring(L, i, NULL));
lua_pop(L, 1);
}
printf("<<\n");
}
static int get_limits (lua_State *L) {
lua_createtable(L, 0, 6);
setnameval(L, "IS32INT", LUAI_IS32INT);
setnameval(L, "MAXARG_Ax", MAXARG_Ax);
setnameval(L, "MAXARG_Bx", MAXARG_Bx);
setnameval(L, "OFFSET_sBx", OFFSET_sBx);
setnameval(L, "LFPF", LFIELDS_PER_FLUSH);
setnameval(L, "NUM_OPCODES", NUM_OPCODES);
return 1;
}
static int mem_query (lua_State *L) {
if (lua_isnone(L, 1)) {
lua_pushinteger(L, l_memcontrol.total);
lua_pushinteger(L, l_memcontrol.numblocks);
lua_pushinteger(L, l_memcontrol.maxmem);
return 3;
}
else if (lua_isnumber(L, 1)) {
unsigned long limit = cast(unsigned long, luaL_checkinteger(L, 1));
if (limit == 0) limit = ULONG_MAX;
l_memcontrol.memlimit = limit;
return 0;
}
else {
const char *t = luaL_checkstring(L, 1);
int i;
for (i = LUA_NUMTAGS - 1; i >= 0; i--) {
if (strcmp(t, ttypename(i)) == 0) {
lua_pushinteger(L, l_memcontrol.objcount[i]);
return 1;
}
}
return luaL_error(L, "unknown type '%s'", t);
}
}
static int alloc_count (lua_State *L) {
if (lua_isnone(L, 1))
l_memcontrol.countlimit = ~0L;
else
l_memcontrol.countlimit = luaL_checkinteger(L, 1);
return 0;
}
static int alloc_failnext (lua_State *L) {
UNUSED(L);
l_memcontrol.failnext = 1;
return 0;
}
static int settrick (lua_State *L) {
if (ttisnil(obj_at(L, 1)))
l_Trick = NULL;
else
l_Trick = gcvalue(obj_at(L, 1));
return 0;
}
static int gc_color (lua_State *L) {
TValue *o;
luaL_checkany(L, 1);
o = obj_at(L, 1);
if (!iscollectable(o))
lua_pushstring(L, "no collectable");
else {
GCObject *obj = gcvalue(o);
lua_pushstring(L, isdead(G(L), obj) ? "dead" :
iswhite(obj) ? "white" :
isblack(obj) ? "black" : "gray");
}
return 1;
}
static int gc_age (lua_State *L) {
TValue *o;
luaL_checkany(L, 1);
o = obj_at(L, 1);
if (!iscollectable(o))
lua_pushstring(L, "no collectable");
else {
static const char *gennames[] = {"new", "survival", "old0", "old1",
"old", "touched1", "touched2"};
GCObject *obj = gcvalue(o);
lua_pushstring(L, gennames[getage(obj)]);
}
return 1;
}
static int gc_printobj (lua_State *L) {
TValue *o;
luaL_checkany(L, 1);
o = obj_at(L, 1);
if (!iscollectable(o))
printf("no collectable\n");
else {
GCObject *obj = gcvalue(o);
printobj(G(L), obj);
printf("\n");
}
return 0;
}
static int gc_state (lua_State *L) {
static const char *statenames[] = {
"propagate", "atomic", "enteratomic", "sweepallgc", "sweepfinobj",
"sweeptobefnz", "sweepend", "callfin", "pause", ""};
static const int states[] = {
GCSpropagate, GCSenteratomic, GCSatomic, GCSswpallgc, GCSswpfinobj,
GCSswptobefnz, GCSswpend, GCScallfin, GCSpause, -1};
int option = states[luaL_checkoption(L, 1, "", statenames)];
if (option == -1) {
lua_pushstring(L, statenames[G(L)->gcstate]);
return 1;
}
else {
global_State *g = G(L);
if (G(L)->gckind == KGC_GEN)
luaL_error(L, "cannot change states in generational mode");
lua_lock(L);
if (option < g->gcstate) { /* must cross 'pause'? */
luaC_runtilstate(L, bitmask(GCSpause)); /* run until pause */
}
luaC_runtilstate(L, bitmask(option));
lua_assert(G(L)->gcstate == option);
lua_unlock(L);
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_pushinteger(L, tsvalue(obj_at(L, 1))->hash);
}
else {
TValue *o = obj_at(L, 1);
Table *t;
luaL_checktype(L, 2, LUA_TTABLE);
t = hvalue(obj_at(L, 2));
lua_pushinteger(L, luaH_mainposition(t, o) - t->node);
}
return 1;
}
static int stacklevel (lua_State *L) {
unsigned long a = 0;
lua_pushinteger(L, (L->top - L->stack));
lua_pushinteger(L, stacksize(L));
lua_pushinteger(L, L->nCcalls);
lua_pushinteger(L, L->nci);
lua_pushinteger(L, (unsigned long)&a);
return 5;
}
static int table_query (lua_State *L) {
const Table *t;
int i = cast_int(luaL_optinteger(L, 2, -1));
unsigned int asize;
luaL_checktype(L, 1, LUA_TTABLE);
t = hvalue(obj_at(L, 1));
asize = luaH_realasize(t);
if (i == -1) {
lua_pushinteger(L, asize);
lua_pushinteger(L, allocsizenode(t));
lua_pushinteger(L, isdummy(t) ? 0 : t->lastfree - t->node);
lua_pushinteger(L, t->alimit);
return 4;
}
else if ((unsigned int)i < asize) {
lua_pushinteger(L, i);
pushobject(L, &t->array[i]);
lua_pushnil(L);
}
else if ((i -= asize) < sizenode(t)) {
TValue k;
getnodekey(L, &k, gnode(t, i));
if (!isempty(gval(gnode(t, i))) ||
ttisnil(&k) ||
ttisnumber(&k)) {
pushobject(L, &k);
}
else
lua_pushliteral(L, "<undef>");
pushobject(L, gval(gnode(t, i)));
if (gnext(&t->node[i]) != 0)
lua_pushinteger(L, gnext(&t->node[i]));
else
lua_pushnil(L);
}
return 3;
}
static int string_query (lua_State *L) {
stringtable *tb = &G(L)->strt;
int s = cast_int(luaL_optinteger(L, 1, 0)) - 1;
if (s == -1) {
lua_pushinteger(L ,tb->size);
lua_pushinteger(L ,tb->nuse);
return 2;
}
else if (s < tb->size) {
TString *ts;
int n = 0;
for (ts = tb->hash[s]; ts != NULL; ts = ts->u.hnext) {
setsvalue2s(L, L->top, ts);
api_incr_top(L);
n++;
}
return n;
}
else return 0;
}
static int tref (lua_State *L) {
int level = lua_gettop(L);
luaL_checkany(L, 1);
lua_pushvalue(L, 1);
lua_pushinteger(L, luaL_ref(L, LUA_REGISTRYINDEX));
(void)level; /* to avoid warnings */
lua_assert(lua_gettop(L) == level+1); /* +1 for result */
return 1;
}
static int getref (lua_State *L) {
int level = lua_gettop(L);
lua_rawgeti(L, LUA_REGISTRYINDEX, luaL_checkinteger(L, 1));
(void)level; /* to avoid warnings */
lua_assert(lua_gettop(L) == level+1);
return 1;
}
static int unref (lua_State *L) {
int level = lua_gettop(L);
luaL_unref(L, LUA_REGISTRYINDEX, cast_int(luaL_checkinteger(L, 1)));
(void)level; /* to avoid warnings */
lua_assert(lua_gettop(L) == level);
return 0;
}
static int upvalue (lua_State *L) {
int n = cast_int(luaL_checkinteger(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 = cast_sizet(luaL_optinteger(L, 1, 0));
int nuv = luaL_optinteger(L, 2, 0);
char *p = cast_charp(lua_newuserdatauv(L, size, nuv));
while (size--) *p++ = '\0';
return 1;
}
static int pushuserdata (lua_State *L) {
lua_Integer u = luaL_checkinteger(L, 1);
lua_pushlightuserdata(L, cast_voidp(cast_sizet(u)));
return 1;
}
static int udataval (lua_State *L) {
lua_pushinteger(L, cast(long, 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 == LUA_OK)
status = lua_pcall(L1, 0, 0, 0);
lua_pushinteger(L, status);
return 1;
}
static int s2d (lua_State *L) {
lua_pushnumber(L, cast_num(*cast(const double *, luaL_checkstring(L, 1))));
return 1;
}
static int d2s (lua_State *L) {
double d = cast(double, luaL_checknumber(L, 1));
lua_pushlstring(L, cast_charp(&d), sizeof(d));
return 1;
}
static int num2int (lua_State *L) {
lua_pushinteger(L, lua_tointeger(L, 1));
return 1;
}
static int newstate (lua_State *L) {
void *ud;
lua_Alloc f = lua_getallocf(L, &ud);
lua_State *L1 = lua_newstate(f, ud);
if (L1) {
lua_atpanic(L1, tpanic);
lua_pushlightuserdata(L, L1);
}
else
lua_pushnil(L);
return 1;
}
static lua_State *getstate (lua_State *L) {
lua_State *L1 = cast(lua_State *, lua_touserdata(L, 1));
luaL_argcheck(L, L1 != NULL, 1, "state expected");
return L1;
}
static int loadlib (lua_State *L) {
static const luaL_Reg libs[] = {
{LUA_GNAME, luaopen_base},
{"coroutine", luaopen_coroutine},
{"debug", luaopen_debug},
{"io", luaopen_io},
{"os", luaopen_os},
{"math", luaopen_math},
{"string", luaopen_string},
{"table", luaopen_table},
{"T", luaB_opentests},
{NULL, NULL}
};
lua_State *L1 = getstate(L);
int i;
luaL_requiref(L1, "package", luaopen_package, 0);
lua_assert(lua_type(L1, -1) == LUA_TTABLE);
/* 'requiref' should not reload module already loaded... */
luaL_requiref(L1, "package", NULL, 1); /* seg. fault if it reloads */
/* ...but should return the same module */
lua_assert(lua_compare(L1, -1, -2, LUA_OPEQ));
luaL_getsubtable(L1, LUA_REGISTRYINDEX, LUA_PRELOAD_TABLE);
for (i = 0; libs[i].name; i++) {
lua_pushcfunction(L1, libs[i].func);
lua_setfield(L1, -2, libs[i].name);
}
return 0;
}
static int closestate (lua_State *L) {
lua_State *L1 = getstate(L);
lua_close(L1);
return 0;
}
static int doremote (lua_State *L) {
lua_State *L1 = getstate(L);
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 == LUA_OK)
status = lua_pcall(L1, 0, LUA_MULTRET, 0);
if (status != LUA_OK) {
lua_pushnil(L);
lua_pushstring(L, lua_tostring(L1, -1));
lua_pushinteger(L, status);
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) {
unsigned int x = (unsigned int)luaL_checkinteger(L, 1);
lua_pushinteger(L, luaO_ceillog2(x));
return 1;
}
struct Aux { jmp_buf jb; const char *paniccode; lua_State *L; };
/*
** does a long-jump back to "main program".
*/
static int panicback (lua_State *L) {
struct Aux *b;
lua_checkstack(L, 1); /* open space for 'Aux' struct */
lua_getfield(L, LUA_REGISTRYINDEX, "_jmpbuf"); /* get 'Aux' struct */
b = (struct Aux *)lua_touserdata(L, -1);
lua_pop(L, 1); /* remove 'Aux' struct */
runC(b->L, L, b->paniccode); /* run optional panic code */
gclongjmp(b->jb, 1);
return 1; /* to avoid warnings */
}
static int checkpanic (lua_State *L) {
struct Aux b;
void *ud;
lua_State *L1;
const char *code = luaL_checkstring(L, 1);
lua_Alloc f = lua_getallocf(L, &ud);
b.paniccode = luaL_optstring(L, 2, "");
b.L = L;
L1 = lua_newstate(f, ud); /* create new state */
if (L1 == NULL) { /* error? */
lua_pushnil(L);
return 1;
}
lua_atpanic(L1, panicback); /* set its panic function */
lua_pushlightuserdata(L1, &b);
lua_setfield(L1, LUA_REGISTRYINDEX, "_jmpbuf"); /* store 'Aux' struct */
if (setjmp(b.jb) == 0) { /* set jump buffer */
runC(L, L1, code); /* run code unprotected */
lua_pushliteral(L, "no errors");
}
else { /* error handling */
/* move error message to original state */
lua_pushstring(L, lua_tostring(L1, -1));
}
lua_close(L1);
return 1;
}
/*
** {====================================================================
** 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 void sethookaux (lua_State *L, int mask, int count, const char *code);
static const char *const delimits = " \t\n,;";
static void skip (const char **pc) {
for (;;) {
if (**pc != '\0' && strchr(delimits, **pc)) (*pc)++;
else if (**pc == '#') { /* comment? */
while (**pc != '\n' && **pc != '\0') (*pc)++; /* until end-of-line */
}
else break;
}
}
static int getnum_aux (lua_State *L, lua_State *L1, const char **pc) {
int res = 0;
int sig = 1;
skip(pc);
if (**pc == '.') {
res = cast_int(lua_tointeger(L1, -1));
lua_pop(L1, 1);
(*pc)++;
return res;
}
else if (**pc == '*') {
res = lua_gettop(L1);
(*pc)++;
return res;
}
else if (**pc == '-') {
sig = -1;
(*pc)++;
}
if (!lisdigit(cast_uchar(**pc)))
luaL_error(L, "number expected (%s)", *pc);
while (lisdigit(cast_uchar(**pc))) res = res*10 + (*(*pc)++) - '0';
return sig*res;
}
static const char *getstring_aux (lua_State *L, char *buff, const char **pc) {
int i = 0;
skip(pc);
if (**pc == '"' || **pc == '\'') { /* quoted string? */
int quote = *(*pc)++;
while (**pc != quote) {
if (**pc == '\0') luaL_error(L, "unfinished string in C script");
buff[i++] = *(*pc)++;
}
(*pc)++;
}
else {
while (**pc != '\0' && !strchr(delimits, **pc))
buff[i++] = *(*pc)++;
}
buff[i] = '\0';
return buff;
}
static int getindex_aux (lua_State *L, lua_State *L1, const char **pc) {
skip(pc);
switch (*(*pc)++) {
case 'R': return LUA_REGISTRYINDEX;
case 'G': return luaL_error(L, "deprecated index 'G'");
case 'U': return lua_upvalueindex(getnum_aux(L, L1, pc));
default: (*pc)--; return getnum_aux(L, L1, pc);
}
}
static const char *const statcodes[] = {"OK", "YIELD", "ERRRUN",
"ERRSYNTAX", MEMERRMSG, "ERRGCMM", "ERRERR"};
/*
** Avoid these stat codes from being collected, to avoid possible
** memory error when pushing them.
*/
static void regcodes (lua_State *L) {
unsigned int i;
for (i = 0; i < sizeof(statcodes) / sizeof(statcodes[0]); i++) {
lua_pushboolean(L, 1);
lua_setfield(L, LUA_REGISTRYINDEX, statcodes[i]);
}
}
#define EQ(s1) (strcmp(s1, inst) == 0)
#define getnum (getnum_aux(L, L1, &pc))
#define getstring (getstring_aux(L, buff, &pc))
#define getindex (getindex_aux(L, L1, &pc))
static int testC (lua_State *L);
static int Cfunck (lua_State *L, int status, lua_KContext ctx);
/*
** arithmetic operation encoding for 'arith' instruction
** LUA_OPIDIV -> \
** LUA_OPSHL -> <
** LUA_OPSHR -> >
** LUA_OPUNM -> _
** LUA_OPBNOT -> !
*/
static const char ops[] = "+-*%^/\\&|~<>_!";
static int runC (lua_State *L, lua_State *L1, const char *pc) {
char buff[300];
int status = 0;
if (pc == NULL) return luaL_error(L, "attempt to runC null script");
for (;;) {
const char *inst = getstring;
if EQ("") return 0;
else if EQ("absindex") {
lua_pushnumber(L1, lua_absindex(L1, getindex));
}
else if EQ("append") {
int t = getindex;
int i = lua_rawlen(L1, t);
lua_rawseti(L1, t, i + 1);
}
else if EQ("arith") {
int op;
skip(&pc);
op = strchr(ops, *pc++) - ops;
lua_arith(L1, op);
}
else if EQ("call") {
int narg = getnum;
int nres = getnum;
lua_call(L1, narg, nres);
}
else if EQ("callk") {
int narg = getnum;
int nres = getnum;
int i = getindex;
lua_callk(L1, narg, nres, i, Cfunck);
}
else if EQ("checkstack") {
int sz = getnum;
const char *msg = getstring;
if (*msg == '\0')
msg = NULL; /* to test 'luaL_checkstack' with no message */
luaL_checkstack(L1, sz, msg);
}
else if EQ("rawcheckstack") {
int sz = getnum;
lua_pushboolean(L1, lua_checkstack(L1, sz));
}
else if EQ("compare") {
const char *opt = getstring; /* EQ, LT, or LE */
int op = (opt[0] == 'E') ? LUA_OPEQ
: (opt[1] == 'T') ? LUA_OPLT : LUA_OPLE;
int a = getindex;
int b = getindex;
lua_pushboolean(L1, lua_compare(L1, a, b, op));
}
else if EQ("concat") {
lua_concat(L1, getnum);
}
else if EQ("copy") {
int f = getindex;
lua_copy(L1, f, getindex);
}
else if EQ("func2num") {
lua_CFunction func = lua_tocfunction(L1, getindex);
lua_pushnumber(L1, cast_sizet(func));
}
else if EQ("getfield") {
int t = getindex;
lua_getfield(L1, t, getstring);
}
else if EQ("getglobal") {
lua_getglobal(L1, getstring);
}
else if EQ("getmetatable") {
if (lua_getmetatable(L1, getindex) == 0)
lua_pushnil(L1);
}
else if EQ("gettable") {
lua_gettable(L1, getindex);
}
else if EQ("gettop") {
lua_pushinteger(L1, lua_gettop(L1));
}
else if EQ("gsub") {
int a = getnum; int b = getnum; int c = getnum;
luaL_gsub(L1, lua_tostring(L1, a),
lua_tostring(L1, b),
lua_tostring(L1, c));
}
else if EQ("insert") {
lua_insert(L1, getnum);
}
else if EQ("iscfunction") {
lua_pushboolean(L1, lua_iscfunction(L1, getindex));
}
else if EQ("isfunction") {
lua_pushboolean(L1, lua_isfunction(L1, getindex));
}
else if EQ("isnil") {
lua_pushboolean(L1, lua_isnil(L1, getindex));
}
else if EQ("isnull") {
lua_pushboolean(L1, lua_isnone(L1, getindex));
}
else if EQ("isnumber") {
lua_pushboolean(L1, lua_isnumber(L1, getindex));
}
else if EQ("isstring") {
lua_pushboolean(L1, lua_isstring(L1, getindex));
}
else if EQ("istable") {
lua_pushboolean(L1, lua_istable(L1, getindex));
}
else if EQ("isudataval") {
lua_pushboolean(L1, lua_islightuserdata(L1, getindex));
}
else if EQ("isuserdata") {
lua_pushboolean(L1, lua_isuserdata(L1, getindex));
}
else if EQ("len") {
lua_len(L1, getindex);
}
else if EQ("Llen") {
lua_pushinteger(L1, luaL_len(L1, getindex));
}
else if EQ("loadfile") {
luaL_loadfile(L1, luaL_checkstring(L1, getnum));
}
else if EQ("loadstring") {
const char *s = luaL_checkstring(L1, getnum);
luaL_loadstring(L1, s);
}
else if EQ("newmetatable") {
lua_pushboolean(L1, luaL_newmetatable(L1, getstring));
}
else if EQ("newtable") {
lua_newtable(L1);
}
else if EQ("newthread") {
lua_newthread(L1);
}
else if EQ("resetthread") {
lua_pushinteger(L1, lua_resetthread(L1));
}
else if EQ("newuserdata") {
lua_newuserdata(L1, getnum);
}
else if EQ("next") {
lua_next(L1, -2);
}
else if EQ("objsize") {
lua_pushinteger(L1, lua_rawlen(L1, getindex));
}
else if EQ("pcall") {
int narg = getnum;
int nres = getnum;
status = lua_pcall(L1, narg, nres, getnum);
}
else if EQ("pcallk") {
int narg = getnum;
int nres = getnum;
int i = getindex;
status = lua_pcallk(L1, narg, nres, 0, i, Cfunck);
}
else if EQ("pop") {
lua_pop(L1, getnum);
}
else if EQ("printstack") {
int n = getnum;
if (n != 0) {
printf("%s\n", luaL_tolstring(L1, n, NULL));
lua_pop(L1, 1);
}
else printstack(L1);
}
else if EQ("print") {
const char *msg = getstring;
printf("%s\n", msg);
}
else if EQ("warningC") {
const char *msg = getstring;
lua_warning(L1, msg, 1);
}
else if EQ("warning") {
const char *msg = getstring;
lua_warning(L1, msg, 0);
}
else if EQ("pushbool") {
lua_pushboolean(L1, getnum);
}
else if EQ("pushcclosure") {
lua_pushcclosure(L1, testC, getnum);
}
else if EQ("pushint") {
lua_pushinteger(L1, getnum);
}
else if EQ("pushnil") {
lua_pushnil(L1);
}
else if EQ("pushnum") {
lua_pushnumber(L1, (lua_Number)getnum);
}
else if EQ("pushstatus") {
lua_pushstring(L1, statcodes[status]);
}
else if EQ("pushstring") {
lua_pushstring(L1, getstring);
}
else if EQ("pushupvalueindex") {
lua_pushinteger(L1, lua_upvalueindex(getnum));
}
else if EQ("pushvalue") {
lua_pushvalue(L1, getindex);
}
else if EQ("pushfstringI") {
lua_pushfstring(L1, lua_tostring(L, -2), (int)lua_tointeger(L, -1));
}
else if EQ("pushfstringS") {
lua_pushfstring(L1, lua_tostring(L, -2), lua_tostring(L, -1));
}
else if EQ("pushfstringP") {
lua_pushfstring(L1, lua_tostring(L, -2), lua_topointer(L, -1));
}
else if EQ("rawget") {
int t = getindex;
lua_rawget(L1, t);
}
else if EQ("rawgeti") {
int t = getindex;
lua_rawgeti(L1, t, getnum);
}
else if EQ("rawgetp") {
int t = getindex;
lua_rawgetp(L1, t, cast_voidp(cast_sizet(getnum)));
}
else if EQ("rawset") {
int t = getindex;
lua_rawset(L1, t);
}
else if EQ("rawseti") {
int t = getindex;
lua_rawseti(L1, t, getnum);
}
else if EQ("rawsetp") {
int t = getindex;
lua_rawsetp(L1, t, cast_voidp(cast_sizet(getnum)));
}
else if EQ("remove") {
lua_remove(L1, getnum);
}
else if EQ("replace") {
lua_replace(L1, getindex);
}
else if EQ("resume") {
int i = getindex;
int nres;
status = lua_resume(lua_tothread(L1, i), L, getnum, &nres);
}
else if EQ("return") {
int n = getnum;
if (L1 != L) {
int i;
for (i = 0; i < n; i++) {
int idx = -(n - i);
switch (lua_type(L1, idx)) {
case LUA_TBOOLEAN:
lua_pushboolean(L, lua_toboolean(L1, idx));
break;
default:
lua_pushstring(L, lua_tostring(L1, idx));
break;
}
}
}
return n;
}
else if EQ("rotate") {
int i = getindex;
lua_rotate(L1, i, getnum);
}
else if EQ("setfield") {
int t = getindex;
const char *s = getstring;
lua_setfield(L1, t, s);
}
else if EQ("seti") {
int t = getindex;
lua_seti(L1, t, getnum);
}
else if EQ("setglobal") {
const char *s = getstring;
lua_setglobal(L1, s);
}
else if EQ("sethook") {
int mask = getnum;
int count = getnum;
const char *s = getstring;
sethookaux(L1, mask, count, s);
}
else if EQ("setmetatable") {
int idx = getindex;
lua_setmetatable(L1, idx);
}
else if EQ("settable") {
lua_settable(L1, getindex);
}
else if EQ("settop") {
lua_settop(L1, getnum);
}
else if EQ("testudata") {
int i = getindex;
lua_pushboolean(L1, luaL_testudata(L1, i, getstring) != NULL);
}
else if EQ("error") {
lua_error(L1);
}
else if EQ("abort") {
__die();
}
else if EQ("throw") {
#if defined(__cplusplus)
static struct X { int x; } x;
throw x;
#else
luaL_error(L1, "C++");
#endif
break;
}
else if EQ("tobool") {
lua_pushboolean(L1, lua_toboolean(L1, getindex));
}
else if EQ("tocfunction") {
lua_pushcfunction(L1, lua_tocfunction(L1, getindex));
}
else if EQ("tointeger") {
lua_pushinteger(L1, lua_tointeger(L1, getindex));
}
else if EQ("tonumber") {
lua_pushnumber(L1, lua_tonumber(L1, getindex));
}
else if EQ("topointer") {
lua_pushlightuserdata(L1, cast_voidp(lua_topointer(L1, getindex)));
}
else if EQ("touserdata") {
lua_pushlightuserdata(L1, lua_touserdata(L1, getindex));
}
else if EQ("tostring") {
const char *s = lua_tostring(L1, getindex);
const char *s1 = lua_pushstring(L1, s);
(void)s1; /* to avoid warnings */
lua_longassert((s == NULL && s1 == NULL) || strcmp(s, s1) == 0);
}
else if EQ("type") {
lua_pushstring(L1, luaL_typename(L1, getnum));
}
else if EQ("xmove") {
int f = getindex;
int t = getindex;
lua_State *fs = (f == 0) ? L1 : lua_tothread(L1, f);
lua_State *ts = (t == 0) ? L1 : lua_tothread(L1, t);
int n = getnum;
if (n == 0) n = lua_gettop(fs);
lua_xmove(fs, ts, n);
}
else if EQ("isyieldable") {
lua_pushboolean(L1, lua_isyieldable(lua_tothread(L1, getindex)));
}
else if EQ("yield") {
return lua_yield(L1, getnum);
}
else if EQ("yieldk") {
int nres = getnum;
int i = getindex;
return lua_yieldk(L1, nres, i, Cfunck);
}
else if EQ("toclose") {
lua_toclose(L1, getnum);
}
else if EQ("closeslot") {
lua_closeslot(L1, getnum);
}
else luaL_error(L, "unknown instruction %s", buff);
}
return 0;
}
static int testC (lua_State *L) {
lua_State *L1;
const char *pc;
if (lua_isuserdata(L, 1)) {
L1 = getstate(L);
pc = luaL_checkstring(L, 2);
}
else if (lua_isthread(L, 1)) {
L1 = lua_tothread(L, 1);
pc = luaL_checkstring(L, 2);
}
else {
L1 = L;
pc = luaL_checkstring(L, 1);
}
return runC(L, L1, pc);
}
static int Cfunc (lua_State *L) {
return runC(L, L, lua_tostring(L, lua_upvalueindex(1)));
}
static int Cfunck (lua_State *L, int status, lua_KContext ctx) {
lua_pushstring(L, statcodes[status]);
lua_setglobal(L, "status");
lua_pushinteger(L, ctx);
lua_setglobal(L, "ctx");
return runC(L, L, lua_tostring(L, ctx));
}
static int makeCfunc (lua_State *L) {
luaL_checkstring(L, 1);
lua_pushcclosure(L, Cfunc, lua_gettop(L));
return 1;
}
/* }====================================================== */
/*
** {======================================================
** tests for C hooks
** =======================================================
*/
/*
** C hook that runs the C script stored in registry.C_HOOK[L]
*/
static void Chook (lua_State *L, lua_Debug *ar) {
const char *scpt;
const char *const events [] = {"call", "ret", "line", "count", "tailcall"};
lua_getfield(L, LUA_REGISTRYINDEX, "C_HOOK");
lua_pushlightuserdata(L, L);
lua_gettable(L, -2); /* get C_HOOK[L] (script saved by sethookaux) */
scpt = lua_tostring(L, -1); /* not very religious (string will be popped) */
lua_pop(L, 2); /* remove C_HOOK and script */
lua_pushstring(L, events[ar->event]); /* may be used by script */
lua_pushinteger(L, ar->currentline); /* may be used by script */
runC(L, L, scpt); /* run script from C_HOOK[L] */
}
/*
** sets 'registry.C_HOOK[L] = scpt' and sets 'Chook' as a hook
*/
static void sethookaux (lua_State *L, int mask, int count, const char *scpt) {
if (*scpt == '\0') { /* no script? */
lua_sethook(L, NULL, 0, 0); /* turn off hooks */
return;
}
lua_getfield(L, LUA_REGISTRYINDEX, "C_HOOK"); /* get C_HOOK table */
if (!lua_istable(L, -1)) { /* no hook table? */
lua_pop(L, 1); /* remove previous value */
lua_newtable(L); /* create new C_HOOK table */
lua_pushvalue(L, -1);
lua_setfield(L, LUA_REGISTRYINDEX, "C_HOOK"); /* register it */
}
lua_pushlightuserdata(L, L);
lua_pushstring(L, scpt);
lua_settable(L, -3); /* C_HOOK[L] = script */
lua_sethook(L, Chook, mask, count);
}
static int sethook (lua_State *L) {
if (lua_isnoneornil(L, 1))
lua_sethook(L, NULL, 0, 0); /* turn off hooks */
else {
const char *scpt = luaL_checkstring(L, 1);
const char *smask = luaL_checkstring(L, 2);
int count = cast_int(luaL_optinteger(L, 3, 0));
int mask = 0;
if (strchr(smask, 'c')) mask |= LUA_MASKCALL;
if (strchr(smask, 'r')) mask |= LUA_MASKRET;
if (strchr(smask, 'l')) mask |= LUA_MASKLINE;
if (count > 0) mask |= LUA_MASKCOUNT;
sethookaux(L, mask, count, scpt);
}
return 0;
}
static int coresume (lua_State *L) {
int status, nres;
lua_State *co = lua_tothread(L, 1);
luaL_argcheck(L, co, 1, "coroutine expected");
status = lua_resume(co, L, 0, &nres);
if (status != LUA_OK && status != LUA_YIELD) {
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[] = {
{"checkmemory", lua_checkmemory},
{"closestate", closestate},
{"d2s", d2s},
{"doonnewstack", doonnewstack},
{"doremote", doremote},
{"gccolor", gc_color},
{"gcage", gc_age},
{"gcstate", gc_state},
{"pobj", gc_printobj},
{"getref", getref},
{"hash", hash_query},
{"log2", log2_aux},
{"limits", get_limits},
{"listcode", listcode},
{"printcode", printcode},
{"listk", listk},
{"listabslineinfo", listabslineinfo},
{"listlocals", listlocals},
{"loadlib", loadlib},
{"checkpanic", checkpanic},
{"newstate", newstate},
{"newuserdata", newuserdata},
{"num2int", num2int},
{"pushuserdata", pushuserdata},
{"querystr", string_query},
{"querytab", table_query},
{"ref", tref},
{"resume", coresume},
{"s2d", s2d},
{"sethook", sethook},
{"stacklevel", stacklevel},
{"testC", testC},
{"makeCfunc", makeCfunc},
{"totalmem", mem_query},
{"alloccount", alloc_count},
{"allocfailnext", alloc_failnext},
{"trick", settrick},
{"udataval", udataval},
{"unref", unref},
{"upvalue", upvalue},
{NULL, NULL}
};
static void checkfinalmem (void) {
lua_assert(l_memcontrol.numblocks == 0);
lua_assert(l_memcontrol.total == 0);
}
int luaB_opentests (lua_State *L) {
void *ud;
lua_Alloc f = lua_getallocf(L, &ud);
lua_atpanic(L, &tpanic);
lua_setwarnf(L, &warnf, L);
lua_pushboolean(L, 0);
lua_setglobal(L, "_WARN"); /* _WARN = false */
regcodes(L);
atexit(checkfinalmem);
lua_assert(f == debug_realloc && ud == cast_voidp(&l_memcontrol));
lua_setallocf(L, f, ud); /* exercise this function */
luaL_newlib(L, tests_funcs);
return 1;
}
#endif
Reference in a new issue View git blame Copy permalink