/* Lookup metamethod for object. */
cTValue *lj_meta_lookup(lua_State *L, cTValue *o, MMS mm)
{
GCtab *mt;
if (tvistab(o))
mt = tabref(tabV(o)->metatable);
else if (tvisudata(o))
mt = tabref(udataV(o)->metatable);
else
mt = tabref(basemt_obj(G(L), o));
if (mt) {
cTValue *mo = lj_tab_getstr(mt, mmname_str(G(L), mm));
if (mo)
return mo;
}
return niltv(L);
}
int lj_lib_postreg(lua_State *L, lua_CFunction cf, int id, const char *name)
{
GCfunc *fn = lj_lib_pushcf(L, cf, id);
GCtab *t = tabref(curr_func(L)->c.env); /* Reference to parent table. */
setfuncV(L, lj_tab_setstr(L, t, lj_str_newz(L, name)), fn);
lj_gc_anybarriert(L, t);
setfuncV(L, L->top++, fn);
return 1;
}
/* Helper for LEN. __len metamethod. */
TValue * LJ_FASTCALL lj_meta_len(lua_State *L, cTValue *o)
{
cTValue *mo = lj_meta_lookup(L, o, MM_len);
if (tvisnil(mo)) {
if (LJ_52 && tvistab(o))
tabref(tabV(o)->metatable)->nomm |= (uint8_t)(1u<<MM_len);
else
lj_err_optype(L, o, LJ_ERR_OPLEN);
return NULL;
}
return mmcall(L, lj_cont_ra, mo, o, LJ_52 ? o : niltv(L));
}
/* Helper for equality comparisons. __eq metamethod. */
TValue *lj_meta_equal(lua_State *L, GCobj *o1, GCobj *o2, int ne)
{
/* Field metatable must be at same offset for GCtab and GCudata! */
cTValue *mo = lj_meta_fast(L, tabref(o1->gch.metatable), MM_eq);
if (mo) {
TValue *top;
uint32_t it;
if (tabref(o1->gch.metatable) != tabref(o2->gch.metatable)) {
cTValue *mo2 = lj_meta_fast(L, tabref(o2->gch.metatable), MM_eq);
if (mo2 == NULL || !lj_obj_equal(mo, mo2))
return (TValue *)(intptr_t)ne;
}
top = curr_top(L);
setcont(top, ne ? lj_cont_condf : lj_cont_condt);
copyTV(L, top+1, mo);
it = ~(uint32_t)o1->gch.gct;
setgcV(L, top+2, o1, it);
setgcV(L, top+3, o2, it);
return top+2; /* Trigger metamethod call. */
}
return (TValue *)(intptr_t)ne;
}
/* Helper for LEN. __len metamethod. */
TValue * LJ_FASTCALL lj_meta_len(lua_State *L, cTValue *o)
{
cTValue *mo = lj_meta_lookup(L, o, MM_len);
if (tvisnil(mo)) {
#ifdef LUAJIT_ENABLE_LUA52COMPAT
if (tvistab(o))
tabref(tabV(o)->metatable)->nomm |= (uint8_t)(1u<<MM_len);
else
#endif
lj_err_optype(L, o, LJ_ERR_OPLEN);
return NULL;
}
#ifdef LUAJIT_ENABLE_LUA52COMPAT
return mmcall(L, lj_cont_ra, mo, o, o);
#else
return mmcall(L, lj_cont_ra, mo, o, niltv(L));
#endif
}
static TValue *cpparser(lua_State *L, lua_CFunction dummy, void *ud)
{
LexState *ls = (LexState *)ud;
GCproto *pt;
GCfunc *fn;
int bc;
UNUSED(dummy);
cframe_errfunc(L->cframe) = -1; /* Inherit error function. */
bc = lj_lex_setup(L, ls);
if (ls->mode && !strchr(ls->mode, bc ? 'b' : 't')) {
setstrV(L, L->top++, lj_err_str(L, LJ_ERR_XMODE));
lj_err_throw(L, LUA_ERRSYNTAX);
}
pt = bc ? lj_bcread(ls) : lj_parse(ls);
fn = lj_func_newL_empty(L, pt, tabref(L->env));
/* Don't combine above/below into one statement. */
setfuncV(L, L->top++, fn);
return NULL;
}
/* Do a GC check and create a new Lua function with inherited upvalues. */
GCfunc *lj_func_newL_gc(lua_State *L, GCproto *pt, GCfuncL *parent)
{
GCfunc *fn;
GCRef *puv;
MSize i, nuv;
TValue *base;
lj_gc_check_fixtop(L);
fn = func_newL(L, pt, tabref(parent->env));
/* NOBARRIER: The GCfunc is new (marked white). */
puv = parent->uvptr;
nuv = pt->sizeuv;
base = L->base;
for (i = 0; i < nuv; i++) {
uint32_t v = proto_uv(pt)[i];
GCupval *uv;
if ((v & 0x8000)) {
uv = func_finduv(L, base + (v & 0xff));
uv->dhash = (uint32_t)(uintptr_t)mref(parent->pc, char) ^ (v << 24);
} else {
static const uint8_t *lib_read_lfunc(lua_State *L, const uint8_t *p, GCtab *tab)
{
int len = *p++;
GCstr *name = lj_str_new(L, (const char *)p, len);
LexState ls;
GCproto *pt;
GCfunc *fn;
memset(&ls, 0, sizeof(ls));
ls.L = L;
ls.p = (const char *)(p+len);
ls.pe = (const char *)~(uintptr_t)0;
ls.c = -1;
ls.level = (BCDUMP_F_STRIP|(LJ_BE*BCDUMP_F_BE));
ls.chunkname = name;
pt = lj_bcread_proto(&ls);
pt->firstline = ~(BCLine)0;
fn = lj_func_newL_empty(L, pt, tabref(L->env));
/* NOBARRIER: See below for common barrier. */
setfuncV(L, lj_tab_setstr(L, tab, name), fn);
return (const uint8_t *)ls.p;
}
/* Helper for TSET*. __newindex chain and metamethod. */
TValue *lj_meta_tset(lua_State *L, cTValue *o, cTValue *k)
{
TValue tmp;
int loop;
for (loop = 0; loop < LJ_MAX_IDXCHAIN; loop++) {
cTValue *mo;
if (LJ_LIKELY(tvistab(o))) {
GCtab *t = tabV(o);
cTValue *tv = lj_tab_get(L, t, k);
if (LJ_LIKELY(!tvisnil(tv))) {
t->nomm = 0; /* Invalidate negative metamethod cache. */
lj_gc_anybarriert(L, t);
return (TValue *)tv;
} else if (!(mo = lj_meta_fast(L, tabref(t->metatable), MM_newindex))) {
t->nomm = 0; /* Invalidate negative metamethod cache. */
lj_gc_anybarriert(L, t);
if (tv != niltv(L))
return (TValue *)tv;
if (tvisnil(k)) lj_err_msg(L, LJ_ERR_NILIDX);
else if (tvisint(k)) { setnumV(&tmp, (lua_Number)intV(k)); k = &tmp; }
else if (tvisnum(k) && tvisnan(k)) lj_err_msg(L, LJ_ERR_NANIDX);
return lj_tab_newkey(L, t, k);
}
} else if (tvisnil(mo = lj_meta_lookup(L, o, MM_newindex))) {
lj_err_optype(L, o, LJ_ERR_OPINDEX);
return NULL; /* unreachable */
}
if (tvisfunc(mo)) {
L->top = mmcall(L, lj_cont_nop, mo, o, k);
/* L->top+2 = v filled in by caller. */
return NULL; /* Trigger metamethod call. */
}
copyTV(L, &tmp, mo);
o = &tmp;
}
lj_err_msg(L, LJ_ERR_SETLOOP);
return NULL; /* unreachable */
}
/* Helper for TGET*. __index chain and metamethod. */
cTValue *lj_meta_tget(lua_State *L, cTValue *o, cTValue *k)
{
int loop;
for (loop = 0; loop < LJ_MAX_IDXCHAIN; loop++) {
cTValue *mo;
if (LJ_LIKELY(tvistab(o))) {
GCtab *t = tabV(o);
cTValue *tv = lj_tab_get(L, t, k);
if (!tvisnil(tv) ||
!(mo = lj_meta_fast(L, tabref(t->metatable), MM_index)))
return tv;
} else if (tvisnil(mo = lj_meta_lookup(L, o, MM_index))) {
lj_err_optype(L, o, LJ_ERR_OPINDEX);
return NULL; /* unreachable */
}
if (tvisfunc(mo)) {
L->top = mmcall(L, lj_cont_ra, mo, o, k);
return NULL; /* Trigger metamethod call. */
}
o = mo;
}
lj_err_msg(L, LJ_ERR_GETLOOP);
return NULL; /* unreachable */
}
void lj_lib_register(lua_State *L, const char *libname,
const uint8_t *p, const lua_CFunction *cf)
{
GCtab *env = tabref(L->env);
GCfunc *ofn = NULL;
int ffid = *p++;
BCIns *bcff = &L2GG(L)->bcff[*p++];
GCtab *tab = lib_create_table(L, libname, *p++);
ptrdiff_t tpos = L->top - L->base;
/* Avoid barriers further down. */
lj_gc_anybarriert(L, tab);
tab->nomm = 0;
for (;;) {
uint32_t tag = *p++;
MSize len = tag & LIBINIT_LENMASK;
tag &= LIBINIT_TAGMASK;
if (tag != LIBINIT_STRING) {
const char *name;
MSize nuv = (MSize)(L->top - L->base - tpos);
GCfunc *fn = lj_func_newC(L, nuv, env);
if (nuv) {
L->top = L->base + tpos;
memcpy(fn->c.upvalue, L->top, sizeof(TValue)*nuv);
}
fn->c.ffid = (uint8_t)(ffid++);
name = (const char *)p;
p += len;
if (tag == LIBINIT_CF)
setmref(fn->c.pc, &G(L)->bc_cfunc_int);
else
setmref(fn->c.pc, bcff++);
if (tag == LIBINIT_ASM_)
fn->c.f = ofn->c.f; /* Copy handler from previous function. */
else
fn->c.f = *cf++; /* Get cf or handler from C function table. */
if (len) {
/* NOBARRIER: See above for common barrier. */
setfuncV(L, lj_tab_setstr(L, tab, lj_str_new(L, name, len)), fn);
}
ofn = fn;
} else {
switch (tag | len) {
case LIBINIT_SET:
L->top -= 2;
if (tvisstr(L->top+1) && strV(L->top+1)->len == 0)
env = tabV(L->top);
else /* NOBARRIER: See above for common barrier. */
copyTV(L, lj_tab_set(L, tab, L->top+1), L->top);
break;
case LIBINIT_NUMBER:
memcpy(&L->top->n, p, sizeof(double));
L->top++;
p += sizeof(double);
break;
case LIBINIT_COPY:
copyTV(L, L->top, L->top - *p++);
L->top++;
break;
case LIBINIT_LASTCL:
setfuncV(L, L->top++, ofn);
break;
case LIBINIT_FFID:
ffid++;
break;
case LIBINIT_END:
return;
default:
setstrV(L, L->top++, lj_str_new(L, (const char *)p, len));
p += len;
break;
}
}
}
}