static void preinit_state (lua_State *L, global_State *g) {
G(L) = g;
L->stack = NULL;
L->stacksize = 0;
L->errorJmp = NULL;
L->hook = NULL;
L->hookmask = 0;
L->basehookcount = 0;
L->allowhook = 1;
resethookcount(L);
L->openupval = NULL;
L->size_ci = 0;
L->nCcalls = L->baseCcalls = 0;
L->status = 0;
L->base_ci = L->ci = NULL;
L->savedpc = NULL;
L->errfunc = 0;
setnilvalue(gt(L));
}
static void traversestack (GCState *st, lua_State *L1) {
StkId o, lim;
CallInfo *ci;
lua_State *L = st->L;
(void)L;
markobject(st, gt(L1));
lim = L1->top;
for (ci = L1->base_ci; ci <= L1->ci; ci++) {
lua_assert(ci->top <= L1->stack_last);
lua_assert(ci->state & (CI_C | CI_HASFRAME | CI_SAVEDPC));
if (lim < ci->top)
lim = ci->top;
}
for (o = L1->stack; o < L1->top; o++)
markobject(st, o);
for (; o <= lim; o++)
setnilvalue(o);
checkstacksizes(L1, lim);
}
static int addk (FuncState *fs, TValue *k, TValue *v) {
lua_State *L = fs->L;
TValue *idx = luaH_set(L, fs->h, k);
Proto *f = fs->f;
int oldsize = f->sizek;
if (ttisnumber(idx)) {
lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v));
return cast_int(nvalue(idx));
}
else { /* constant not found; create a new entry */
setnvalue(idx, cast_num(fs->nk));
luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
MAXARG_Bx, "constant table overflow");
while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
setobj(L, &f->k[fs->nk], v);
luaC_barrier(L, f, v);
return fs->nk++;
}
}
LUA_API void lua_pushcclosure (lua_State *L, lua_CFunction fn, int n) {
Closure *cl;
lua_lock(L);
luaC_checkGC(L);
api_checknelems(L, n);
cl = luaF_newCclosure(L, n);
cl->c.f = fn;
L->top -= n;
while (n--)
{
setobj2n(&cl->c.upvalue[n], L->top+n);
#if LUA_REFCOUNT
setnilvalue(L->top+n);
#endif LUA_REFCOUNT
}
setclvalue(L->top, cl);
api_incr_top(L);
lua_unlock(L);
}
/*
** clear collected values from weaktables
*/
static void cleartablevalues (lua_State *L, GCObject *l) {
while (l) {
Table *h = gcotoh(l);
int i = h->sizearray;
lua_assert(h->marked & VALUEWEAK);
while (i--) {
TObject *o = &h->array[i];
if (!valismarked(o)) /* value was collected? */
setnilvalue(o); /* remove value */
}
i = sizenode(h);
while (i--) {
Node *n = gnode(h, i);
if (!valismarked(gval(n))) /* value was collected? */
removekey(L, n); /* remove entry from table */
}
l = h->gclist;
}
}
static int addk (FuncState *fs, TValue *k, TValue *v) {
lua_State *L = fs->L;
TValue *idx = luaH_set(L, fs->h, k);
#ifdef LUA_TINT
/* Note: Integer-valued LUA_TNUMBER's are handled as in unpatched Lua (below)
*/
if (ttype(idx)==LUA_TINT) {
int i;
# ifdef LNUM_INT64
lua_assert( (int)ivalue(idx) == ivalue(idx) ); /* make sure no data is lost in the casting */
# endif
i= (int)ivalue(idx);
lua_assert(luaO_rawequalObj(&fs->f->k[i], v));
return i;
}
else if (ttype(idx)==LUA_TNUMBER) {
#else
if (ttisnumber(idx)) {
#endif
int i= cast_int(nvalue_fast(idx));
lua_assert(luaO_rawequalObj(&fs->f->k[i], v));
return i;
}
else { /* constant not found; create a new entry */
Proto *f = fs->f;
int oldsize = f->sizek;
setivalue(idx, fs->nk);
luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
MAXARG_Bx, "constant table overflow");
while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
setobj(L, &f->k[fs->nk], v);
luaC_barrier(L, f, v);
return fs->nk++;
}
}
int luaK_stringK (FuncState *fs, TString *s) {
TValue o;
setsvalue(fs->L, &o, s);
return addk(fs, &o, &o);
}
static int nilK (FuncState *fs) {
TValue k, v;
#if LUA_REFCOUNT
lua_State *L = fs->L;
int ret;
setnilvalue2n(L, &v);
luarc_newvalue(&k);
/* cannot use nil as key; instead use table itself to represent nil */
sethvalue(fs->L, &k, fs->h);
ret = addk(fs, &k, &v);
luarc_cleanvalue(&k);
luarc_cleanvalue(&v);
return ret;
#else
setnilvalue(&v);
/* cannot use nil as key; instead use table itself to represent nil */
sethvalue(fs->L, &k, fs->h);
return addk(fs, &k, &v);
#endif /* LUA_REFCOUNT */
}
static lu_mem traversestack (global_State *g, lua_State *th) {
int n = 0;
StkId o = th->stack;
if (o == NULL)
return 1; /* stack not completely built yet */
for (; o < th->top; o++) /* mark live elements in the stack */
markvalue(g, o);
if (g->gcstate == GCSatomic) { /* final traversal? */
StkId lim = th->stack + th->stacksize; /* real end of stack */
for (; o < lim; o++) /* clear not-marked stack slice */
setnilvalue(o);
}
else { /* count call infos to compute size */
CallInfo *ci;
for (ci = &th->base_ci; ci != th->ci; ci = ci->next)
n++;
}
return sizeof(lua_State) + sizeof(TValue) * th->stacksize +
sizeof(CallInfo) * n;
}
int php_deserialize( rabbit * r, rawbuffer * buf, TValue * tv )
{
if(!buf || !tv) {
return -1;
}
setnilvalue(tv);
int c = decode_read_byte( buf );
switch( c ) {
case PHP_NULL:
// kLOG(r, 0,"php decode nil\n");
return decode_null( r, buf, tv );
case PHP_INT:
// kLOG(r, 0,"php decode int\n");
return decode_int( r, buf, tv );
case PHP_DOUBLE:
// kLOG(r, 0,"php decode double\n");
return decode_double(r, buf, tv);
case PHP_STRING:
// kLOG(r, 0,"php decode string\n");
return decode_string(r, buf, tv);
case PHP_ARRAY:
// kLOG(r, 0,"php decode array\n");
return decode_array(r, buf, tv);
case PHP_BOOL:
return decode_bool(r, buf, tv);
default:
kLOG(r, 0, "php decode unknow:%c\n",c);
break;
}
return -1;
}
void vm_OP_VARARG(lua_State *L, LClosure *cl, int a, int b) {
TValue *base = L->base;
TValue *ra = base + a;
int j;
CallInfo *ci = L->ci;
int n = cast_int(ci->base - ci->func) - cl->p->numparams - 1;
b -= 1;
if (b == LUA_MULTRET) {
Protect(luaD_checkstack(L, n));
ra = base + a; /* previous call may change the stack */
b = n;
L->top = ra + n;
}
for (j = 0; j < b; j++) {
if (j < n) {
setobjs2s(L, ra + j, ci->base - n + j);
}
else {
setnilvalue(ra + j);
}
}
}
void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {
int loop;
TValue temp;
setnilvalue(L->top);
L->top++;
fixedstack(L);
for (loop = 0; loop < MAXTAGLOOP; loop++) {
const TValue *tm;
if (ttistable(t) || ttisrotable(t)) { /* `t' is a table? */
void *h = ttistable(t) ? hvalue(t) : rvalue(t);
TValue *oldval = ttistable(t) ? luaH_set(L, (Table*)h, key) : NULL; /* do a primitive set */
if ((oldval && !ttisnil(oldval)) || /* result is no nil? */
(tm = fasttm(L, ttistable(t) ? ((Table*)h)->metatable : (Table*)luaR_getmeta(h), TM_NEWINDEX)) == NULL) { /* or no TM? */
if(oldval) {
L->top--;
unfixedstack(L);
setobj2t(L, oldval, val);
((Table *)h)->flags = 0;
luaC_barriert(L, (Table*)h, val);
}
return;
}
/* else will try the tag method */
}
else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
luaG_typeerror(L, t, "index");
if (ttisfunction(tm) || ttislightfunction(tm)) {
L->top--;
unfixedstack(L);
callTM(L, tm, t, key, val);
return;
}
/* else repeat with `tm' */
setobj(L, &temp, tm); /* avoid pointing inside table (may rehash) */
t = &temp;
setobj2s(L, L->top-1, t); /* need to protect value from EGC. */
}
luaG_runerror(L, "loop in settable");
}
static lu_mem traversethread (global_State *g, lua_State *th) {
StkId o = th->stack;
if (o == NULL)
return 1; /* stack not completely built yet */
lua_assert(g->gcstate == GCSinsideatomic ||
th->openupval == NULL || isintwups(th));
for (; o < th->top; o++) /* mark live elements in the stack */
markvalue(g, o);
if (g->gcstate == GCSinsideatomic) { /* final traversal? */
StkId lim = th->stack + th->stacksize; /* real end of stack */
for (; o < lim; o++) /* clear not-marked stack slice */
setnilvalue(o);
/* 'remarkupvals' may have removed thread from 'twups' list */
if (!isintwups(th) && th->openupval != NULL) {
th->twups = g->twups; /* link it back to the list */
g->twups = th;
}
}
else if (g->gckind != KGC_EMERGENCY)
luaD_shrinkstack(th); /* do not change stack in emergency cycle */
return (sizeof(lua_State) + sizeof(TValue) * th->stacksize);
}
LUA_API int lua_getinfo (lua_State *L, const char *what, lua_Debug *ar)
{
int status;
Closure *f = NULL;
CallInfo *ci = NULL;
void *plight = NULL;
lua_lock(L);
if (*what == '>') {
StkId func = L->top - 1;
luai_apicheck(L, ttisfunction(func) || ttislightfunction(func));
what++; /* skip the '>' */
if (ttisfunction(func))
f = clvalue(func);
else
plight = fvalue(func);
L->top--; /* pop function */
} else if (ar->i_ci != 0) { /* no tail call? */
ci = L->base_ci + ar->i_ci;
lua_assert(ttisfunction(ci->func) || ttislightfunction(ci->func));
if (ttisfunction(ci->func))
f = clvalue(ci->func);
else
plight = fvalue(ci->func);
}
status = auxgetinfo(L, what, ar, f, plight, ci);
if (strchr(what, 'f')) {
if (f != NULL)
setclvalue(L, L->top, f)
else if (plight != NULL)
setfvalue(L->top, plight)
else
setnilvalue(L->top);
incr_top(L);
}
if (strchr(what, 'L'))
collectvalidlines(L, f);
lua_unlock(L);
return status;
}
LUA_API int lua_setmetatable (lua_State *L, int objindex) {
TObject *obj, *mt;
int res = 1;
lua_lock(L);
api_checknelems(L, 1);
obj = luaA_index(L, objindex);
mt = (!ttisnil(L->top - 1)) ? L->top - 1 : defaultmeta(L);
api_check(L, ttistable(mt));
switch (ttype(obj)) {
case LUA_TTABLE: {
#if LUA_REFCOUNT
__AddRefDirect(hvalue(mt));
__ReleaseDirect(L, hvalue(obj)->metatable);
#endif LUA_REFCOUNT
hvalue(obj)->metatable = hvalue(mt); /* write barrier */
break;
}
case LUA_TUSERDATA: {
#if LUA_REFCOUNT
__AddRefDirect(hvalue(mt));
__ReleaseDirect(L, &uvalue(obj)->uv.metatable);
#endif LUA_REFCOUNT
uvalue(obj)->uv.metatable = hvalue(mt); /* write barrier */
break;
}
default: {
res = 0; /* cannot set */
break;
}
}
#if LUA_REFCOUNT
setnilvalue(--L->top);
#else !LUA_REFCOUNT
L->top--;
#endif LUA_REFCOUNT
lua_unlock(L);
return res;
}
/*
** open parts of the state that may cause memory-allocation errors.
** ('g->version' != NULL flags that the state was completely build)
*/
static void f_luaopen (lua_State *L, void *ud) {
global_State *g = G(L);
UNUSED(ud);
stack_init(L, L); /* init stack */
init_registry(L, g);
#if LUA_FASTREF_SUPPORT
{
TValue n;
sethvalue(L, &G(L)->l_refs, luaH_new(L)); /* refs */
setivalue(&n, 0);
luaH_setint(L, hvalue(&G(L)->l_refs), LUA_RIDX_FASTREF_FREELIST, &n);
setnilvalue(&g->fastrefNilValue);
}
#endif /* LUA_FASTREF_SUPPORT */
luaS_init(L);
luaT_init(L);
luaX_init(L);
g->gcrunning = 1; /* allow gc */
g->version = lua_version(NULL);
luai_userstateopen(L);
}
static int poscall(ktap_state *ks, StkId first_result)
{
ktap_callinfo *ci;
StkId res;
int wanted, i;
ci = ks->ci;
res = ci->func;
wanted = ci->nresults;
ks->ci = ci = ci->prev;
for (i = wanted; i != 0 && first_result < ks->top; i--)
setobj(res++, first_result++);
while(i-- > 0)
setnilvalue(res++);
ks->top = res;
return (wanted - (-1));
}
static int addk (FuncState *fs, TValue *k, TValue *v) {
lua_State *L = fs->L;
TValue *idx = luaH_set(L, fs->h, k);
Proto *f = fs->f;
int oldsize = f->sizek;
if (ttype(idx)==LUA_TNUMBER) {
luai_normalize(idx);
lua_assert( ttype(idx)==LUA_TINT ); /* had no fraction */
}
if (ttisint(idx)) {
lua_assert(luaO_rawequalObj(&fs->f->k[ivalue(idx)], v));
return cast_int(ivalue(idx));
}
else { /* constant not found; create a new entry */
setivalue(idx, fs->nk);
luaM_growvector(L, f->k, fs->nk, f->sizek, TValue,
MAXARG_Bx, "constant table overflow");
while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
setobj(L, &f->k[fs->nk], v);
luaC_barrier(L, f, v);
return fs->nk++;
}
}
static void traversestack (global_State *g, lua_State *l) {
StkId o, lim;
CallInfo *ci;
markvalue(g, gt(l));
lim = l->top;
for (ci = l->base_ci; ci <= l->ci; ci++) {
lua_assert(ci->top <= l->stack_last);
if (lim < ci->top) lim = ci->top;
}
for (o = l->stack; o < l->top; o++)
markvalue(g, o);
#if LUA_REFCOUNT
for (; o <= lim; o++) {
if (iscollectable(o))
o->value.gc->gch.ref--;
setnilvalue2n(l, o);
}
#else
for (; o <= lim; o++)
setnilvalue(o);
#endif /* LUA_REFCOUNT */
checkstacksizes(l, lim);
}
static void ktap_concat(ktap_state *ks, int start, int end)
{
int i, len = 0;
StkId top = ks->ci->u.l.base;
ktap_string *ts;
char *ptr, *buffer;
for (i = start; i <= end; i++) {
if (!ttisstring(top + i)) {
kp_error(ks, "cannot concat non-string\n");
setnilvalue(top + start);
return;
}
len += rawtsvalue(top + i)->tsv.len;
}
if (len >= KTAP_PERCPU_BUFFER_SIZE) {
kp_error(ks, "Error: too long string concatenation\n");
return;
}
preempt_disable_notrace();
buffer = kp_percpu_data(KTAP_PERCPU_DATA_BUFFER);
ptr = buffer;
for (i = start; i <= end; i++) {
int len = rawtsvalue(top + i)->tsv.len;
strncpy(ptr, svalue(top + i), len);
ptr += len;
}
ts = kp_tstring_newlstr(ks, buffer, len);
setsvalue(top + start, ts);
preempt_enable_notrace();
}
static int addk (FuncState *fs, TValue *key, TValue *v) {
lua_State *L = fs->L;
TValue *idx = luaH_set(L, fs->h, key);
Proto *f = fs->f;
int k, oldsize;
if (ttisnumber(idx)) {
lua_Number n = nvalue(idx);
lua_number2int(k, n);
if (luaO_rawequalObj(&f->k[k], v))
return k;
/* else may be a collision (e.g., between 0.0 and "\0\0\0\0\0\0\0\0");
go through and create a new entry for this value */
}
/* constant not found; create a new entry */
oldsize = f->sizek;
k = fs->nk;
setnvalue(idx, cast_num(k));
luaM_growvector(L, f->k, k, f->sizek, TValue, MAXARG_Ax, "constants");
while (oldsize < f->sizek) setnilvalue(&f->k[oldsize++]);
setobj(L, &f->k[k], v);
fs->nk++;
luaC_barrier(L, f, v);
return k;
}
static void stack_init (lua_State *L1, lua_State *L) {
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.callinfo");
#endif /* LUA_MEMORY_STATS */
/* initialize CallInfo array */
L1->base_ci = luaM_newvector(L, BASIC_CI_SIZE, CallInfo);
L1->ci = L1->base_ci;
L1->size_ci = BASIC_CI_SIZE;
L1->end_ci = L1->base_ci + L1->size_ci - 1;
/* initialize stack array */
#if LUA_MEMORY_STATS
luaM_setname(L, "lua.stack");
#endif /* LUA_MEMORY_STATS */
L1->stack = luaM_newvector(L, BASIC_STACK_SIZE + EXTRA_STACK, TValue);
L1->stacksize = BASIC_STACK_SIZE + EXTRA_STACK;
L1->top = L1->stack;
L1->stack_last = L1->stack+(L1->stacksize - EXTRA_STACK)-1;
#if LUA_REFCOUNT
luarc_newarray(L1->stack, L1->stack + L1->stacksize);
#endif /* LUA_REFCOUNT */
/* initialize first ci */
L1->ci->func = L1->top;
#if LUA_REFCOUNT
setnilvalue2n(L1, L1->top++); /* `function' entry for this `ci' */
#else
setnilvalue(L1->top++); /* `function' entry for this `ci' */
#endif /* LUA_REFCOUNT */
L1->base = L1->ci->base = L1->top;
L1->ci->top = L1->top + LUA_MINSTACK;
#if LUA_EXT_RESUMABLEVM
L1->ci->errfunc = 0;
#endif /* LUA_EXT_RESUMABLEVM */
#if LUA_MEMORY_STATS
luaM_setname(L, 0);
#endif /* LUA_MEMORY_STATS */
}
LUA_API void lua_pushnil (lua_State *L) {
lua_lock(L);
setnilvalue(L->top);
api_incr_top(L);
lua_unlock(L);
}
void luaV_execute (lua_State *L, int nexeccalls) {
LClosure *cl;
StkId base;
TValue *k;
const Instruction *pc;
reentry: /* entry point */
lua_assert(isLua(L->ci));
pc = L->savedpc;
cl = &clvalue(L->ci->func)->l;
base = L->base;
k = cl->p->k;
/* main loop of interpreter */
for (;;) {
const Instruction i = *pc++;
StkId ra;
if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
(--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
traceexec(L, pc);
if (L->status == LUA_YIELD) { /* did hook yield? */
L->savedpc = pc - 1;
return;
}
base = L->base;
}
/* warning!! several calls may realloc the stack and invalidate `ra' */
ra = RA(i);
lua_assert(base == L->base && L->base == L->ci->base);
lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
switch (GET_OPCODE(i)) {
case OP_MOVE: {
setobjs2s(L, ra, RB(i));
continue;
}
case OP_LOADK: {
setobj2s(L, ra, KBx(i));
continue;
}
case OP_LOADBOOL: {
setbvalue(ra, GETARG_B(i));
if (GETARG_C(i)) pc++; /* skip next instruction (if C) */
continue;
}
case OP_LOADNIL: {
TValue *rb = RB(i);
do {
setnilvalue(rb--);
} while (rb >= ra);
continue;
}
case OP_GETUPVAL: {
int b = GETARG_B(i);
setobj2s(L, ra, cl->upvals[b]->v);
continue;
}
case OP_GETGLOBAL: {
TValue g;
TValue *rb = KBx(i);
sethvalue(L, &g, cl->env);
lua_assert(ttisstring(rb));
Protect(luaV_gettable(L, &g, rb, ra));
continue;
}
case OP_GETTABLE: {
Protect(luaV_gettable(L, RB(i), RKC(i), ra));
continue;
}
case OP_SETGLOBAL: {
TValue g;
sethvalue(L, &g, cl->env);
lua_assert(ttisstring(KBx(i)));
Protect(luaV_settable(L, &g, KBx(i), ra));
continue;
}
case OP_SETUPVAL: {
UpVal *uv = cl->upvals[GETARG_B(i)];
setobj(L, uv->v, ra);
luaC_barrier(L, uv, ra);
continue;
}
case OP_SETTABLE: {
Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
continue;
}
case OP_NEWTABLE: {
int b = GETARG_B(i);
int c = GETARG_C(i);
sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
Protect(luaC_checkGC(L));
continue;
}
case OP_SELF: {
StkId rb = RB(i);
setobjs2s(L, ra+1, rb);
Protect(luaV_gettable(L, rb, RKC(i), ra));
continue;
}
case OP_ADD: {
arith_op(luai_numadd, TM_ADD);
continue;
}
case OP_SUB: {
arith_op(luai_numsub, TM_SUB);
continue;
}
case OP_MUL: {
arith_op(luai_nummul, TM_MUL);
continue;
}
case OP_DIV: {
arith_op(luai_numdiv, TM_DIV);
continue;
}
case OP_MOD: {
arith_op(luai_nummod, TM_MOD);
continue;
}
case OP_POW: {
arith_op(luai_numpow, TM_POW);
continue;
}
case OP_UNM: {
TValue *rb = RB(i);
if (ttisnumber(rb)) {
lua_Number nb = nvalue(rb);
setnvalue(ra, luai_numunm(nb));
}
else {
Protect(luaV_arith(L, ra, rb, rb, TM_UNM));
}
continue;
}
case OP_NOT: {
int res = l_isfalse(RB(i)); /* next assignment may change this value */
setbvalue(ra, res);
continue;
}
case OP_LEN: {
const TValue *rb = RB(i);
switch (ttype(rb)) {
case LUA_TTABLE: {
setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));
break;
}
case LUA_TSTRING: {
setnvalue(ra, cast_num(tsvalue(rb)->len));
break;
}
default: { /* try metamethod */
Protect(
if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN))
luaG_typeerror(L, rb, "get length of");
)
}
}
continue;
}
case OP_CONCAT: {
int b = GETARG_B(i);
int c = GETARG_C(i);
Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L));
setobjs2s(L, RA(i), base+b);
continue;
}
case OP_JMP: {
dojump(L, pc, GETARG_sBx(i));
continue;
}
case OP_EQ: {
TValue *rb = RKB(i);
TValue *rc = RKC(i);
Protect(
if (equalobj(L, rb, rc) == GETARG_A(i))
dojump(L, pc, GETARG_sBx(*pc));
)
pc++;
continue;
}
case OP_LT: {
Protect(
if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))
dojump(L, pc, GETARG_sBx(*pc));
)
pc++;
continue;
}
case OP_LE: {
Protect(
if (luaV_lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))
dojump(L, pc, GETARG_sBx(*pc));
)
pc++;
continue;
}
UpVal *luaF_newupval (lua_State *L) {
UpVal *uv = &luaC_newobj(L, LUA_TUPVAL, sizeof(UpVal), NULL, 0)->uv;
uv->v = &uv->u.value;
setnilvalue(uv->v);
return uv;
}
// 已经准备好了lua函数的调用环境，开始逐句执行lua函数的指令
void luaV_execute (lua_State *L, int nexeccalls) {
LClosure *cl;
StkId base;
TValue *k;
const Instruction *pc;
reentry: /* entry point */
pc = L->savedpc; //这时候已经保存了lua函数的第一个指令位置
cl = &clvalue(L->ci->func)->l;
base = L->base;
k = cl->p->k;
/* main loop of interpreter */
for (;;) {
const Instruction i = *pc++;
StkId ra;
if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
(--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
traceexec(L, pc);
if (L->status == LUA_YIELD) { /* did hook yield? */
L->savedpc = pc - 1;
return;
}
base = L->base;
}
/* warning!! several calls may realloc the stack and invalidate `ra' */
ra = RA(i);
lua_assert(base == L->base && L->base == L->ci->base);
lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
// 阅读说明：
// 每lua的一个函数在编译器会生成这个函数的信息：函数引用到的upvalue，函数固定参数
// 数量，是否含有可变参数，指令序列等等，这些都记录在Proto结构体中。
// 可以通过 luac -o tmp <luafile> | luac -l tmp 来函数对应的字节码以及Proto信息
// 例如以下lua代码：
// -- t.lua
// local x, y, z
// x = x*y + y*z + x*z - (x*x + y*y + z*z)
// 得到以下输出：
// main <t.lua:0,0> (12 instructions, 48 bytes at 0074B6A0)
// 0 + params, 6 slots, 0 upvalues, 3 locals, 0 constants, 0 functions
// 1[2] MUL 3 0 1
// 2[2] MUL 4 1 2
// 3[2] ADD 3 3 4
// 4[2] MUL 4 0 2
// 5[2] ADD 3 3 4
// 6[2] MUL 4 0 0
// 7[2] MUL 5 1 1
// 8[2] ADD 4 4 5
// 9[2] MUL 5 2 2
// 10[2] ADD 4 4 5
// 11[2] SUB 0 3 4
// 12[2] RETURN 0 1
// 从输出可以得到的信息包括：
// 1 生成了多少个Proto
// 2 Proto对应的lua源代码在哪里 (<t.lua:0,0>)
// 3 Proto中的sizecode (12 instructions, 48 bytes at 0074B6A0)
// 4 Proto中的固定参数数量numparams (0 + params，这里的0)
// 5 Proto是否有可变参数is_vararg (0 + params，这里的+表示带有可变参数，没有可变参数就是 0 params)
// 6 Proto中在栈上用到的临时变量总数maxstacksize (6 slots，表示local变量+计算中辅助用的临时变量=6个)
// 7 Proto中用到的upvalue数量nups (0 upvalues，表示用到了0个upvalue)
// 8 Proto中用到的local变量数量sizelocvars (3 locals，刚好t.lua用到了x,y,z三个local变量)
// 9 Proto中用到的字面常量数量sizek (0 constants)
// 10 Proto中用到的Closure数量sizep (0 functions)
// 11 Proto中生成的字节码指令内容code，每条指令包括：
// a 指令下标
// b 指令在源代码中对应的行号
// c 指令opcode
// d 指令参数
//
// PS：第6条和第8条，由于计算一条表达式需要用到的辅助临时变量数目是不定的，但是是可以通过
// 分析一条表达式的AST来确定最少需要几个临时变量（后续遍历+逆波兰式拟真）。
// PS：lua是会对表达式进行常量计算优化的！例如 x = x + 5*60*60*1000，只有一个常量18000000
// PS：函数执行的时候需要用到“一段”参数栈上的空间，也就是第6条所谓的临时变量。这一段空间的
// 范围由L->base开始，到L->top结束。通过相对L->base的下标来标识具体的变量是哪个。一般来说，
// 固定参数的函数，L->base指向第一个固定参数，而L->base-1指向当前正在运行的函数；而可变参数
// 的函数，L->base和当前正在运行的函数中间，保存有全部的传入参数。
switch (GET_OPCODE(i)) {
// 功能：用一个已有的变量创建一个新的变量
// 将一个 lua_TValue设置成另一个lua_TValue的样子
// iABC: A待创建变量在参数栈索引，B参数栈已有lua变量的索引。
case OP_MOVE: {
// local x, y -----> 记录 index(x) = 0, index(y) = 1
// x = ...
// .....
// y = x -----> OP_MOVE: 1, 0
setobjs2s(L, ra, RB(i));
continue;
}
// 功能：用一个常量来创建一个新的变量
// 从常量池（保存在Proto类型中）中保存的常量赋值给栈上的变量
// iABx: A待创建变量在参数栈索引，Bx常量在常量池的索引
case OP_LOADK: {
// local x = 9 -----> 记录 index(x) = 0, index(constval(9)) = 1
// >----> OP_LOADK: 0, 1
setobj2s(L, ra, KBx(i));
continue;
}
// 功能：用一个布尔值来创建一个新的变量
// iABC: A待创建变量在参数栈索引，B布尔值，C通常是0
case OP_LOADBOOL: {
// 注意，local c = true这种，true就不作为一个常量放到k里面
// 而是作为字面值放到参数B里面了！所以不需要KB(i)！
// local a = false -----> 记录 index(a) = 0
// >----> OP_LOADBOOL 0 0 0
// local b = true -----> 记录 index(b) = 1
// >----> OP_LOADBOOL 1 1 0
setbvalue(ra, GETARG_B(i));
if (GETARG_C(i)) pc++; /* skip next instruction (if C) */
continue;
}
// 功能：用nil来初始化一个到多个变量
// 类似于bzero，这个指令会把一段内存中的变量置为nil
// iABC: A第一个要置nil的变量参数栈索引，B最后一个要置nil的变量参数栈索引
case OP_LOADNIL: {
// local a, b, c, d, e, f, g = 1, 2, 3, 4 -----> index(a~g) = 0~6
// >----> OP_LOADNIL 4 6
TValue *rb = RB(i);
do {
setnilvalue(rb--);
} while (rb >= ra);
continue;
}
// 功能：用upvalue来创建一个新的变量
// 所谓的“创建”操作，其实创建的不是副本而是引用
// iABC: A待创建变量在参数栈索引，B当前函数的upvalue表的索引
case OP_GETUPVAL: {
// local x = {}
// ... -- do something to x
// function f() local a = x[1] end -----> 记录index(a) = 0, index(upval(x)) = 1
// >----> OP_GETUPVAL 0 1
int b = GETARG_B(i);
setobj2s(L, ra, cl->upvals[b]->v);
continue;
}
// 功能：从全局表中取某个key的值来创建一个新的变量
// iABx：A待创建变量在参数栈索引，Bxkey对应的常量在常量池的索引
case OP_GETGLOBAL: {
// local a = dofile ------> 记录 index(a) = 0, index(constval("dofile")) = 1
// >-----> OP_GETGLOBAL 0 1
TValue g;
TValue *rb = KBx(i);
sethvalue(L, &g, cl->env);
lua_assert(ttisstring(rb));
Protect(luaV_gettable(L, &g, rb, ra));
continue;
}
// 功能：从某个table中取某个key的值来创建一个新的变量
// iABC：A待创建变量在参数栈索引，B要取出key的table变量在参数栈的索引，Ckey对应的参数栈下标或者常量池下标
case OP_GETTABLE: {
// local a = hello["world"] -----> 记录 index(a) = 0, index(hello) = 1 index(constval("world")) = 0
// >----> OP_GETTABLE 0 1 0|BITRK
Protect(luaV_gettable(L, RB(i), RKC(i), ra));
continue;
}
// 功能：将参数栈上变量设置到全局表中
// iABx：A要写入全局表的变量在栈上的索引，Bx写入到全局表的key在常量池中的下标
case OP_SETGLOBAL: {
// 假设我要替换 bit库
// local mybit = {}
// mybit.band = ...
// mybit.bor = ...
// mybit.bxor = ...
// ...
// bit = mybit -----> 记录 index(mybit) = 0, index(constval("bit")) = 1
// >----> OP_SETGLOBAL 0 1
TValue g;
sethvalue(L, &g, cl->env);
lua_assert(ttisstring(KBx(i)));
Protect(luaV_settable(L, &g, KBx(i), ra));
continue;
}
// 功能：修改upvalue的值
// iABC：A要写入upvalue的变量在参数栈上的索引，B待写入的upvalue在upvalue表的索引
case OP_SETUPVAL: {
// local a = 5
// function p()
// a = "hello" -----> 记录 index(upval(a)) = 0, index(constval("hello")) = 1
// >----> OP_SETUPVAL 0 1
// end
UpVal *uv = cl->upvals[GETARG_B(i)];
setobj(L, uv->v, ra);
luaC_barrier(L, uv, ra);
continue;
}
// 功能：修改某个table对应的key
// iABC：A要写入table变量在参数栈的索引，B要写入的key的变量的栈索引或者常量索引，C要写入的value的变量索引或者常量索引
case OP_SETTABLE: {
// local a = {}
// a[5] = 3
Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
continue;
}
// 功能：在栈上创建一个table变量
// iABC：A存放table变量的参数栈索引，B创建的table变量的数组容量，C创建的table变量的字典容量
case OP_NEWTABLE: {
// local a = {} -----> index(a) = 0
// >----> OP_NEWTABLE 0 szArray szHash
int b = GETARG_B(i);
int c = GETARG_C(i);
sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
Protect(luaC_checkGC(L)); // 注意，创建table可能会引起GC
continue;
}
// 功能：把self.method和self放到参数栈上相邻的两个位置。
// 为成员方法调用的语法糖提供支持
// iABC：A存放self.method的参数栈索引，B存放self的参数栈索引，C需要从self中调用的方法对应的变量索引或者常量索引
// 执行完成后，栈上内容为： ... -> self.method -> self -> ...
// ^
// RA
// 当然，OP_SELF之后能看到OP_CALL的身影
case OP_SELF: {
// CCNode:create() -> index(constants("CCNode")) = 1, index(constants("create")) = 2
// -> OP_GETGLOBAL 0 1
// -> OP_SELF 0 0 2
// -> OP_CALL 0 2 1
StkId rb = RB(i);
setobjs2s(L, ra+1, rb);
Protect(luaV_gettable(L, rb, RKC(i), ra));
continue;
}
//---------------------------------------------------------------------------运算符指令
// 功能：实现二元运算符：+, -, *, /, %, ^
// iABC：A存放运算结果的参数栈索引，B存放第一操作数的参数栈索引，C存放第二操作数的参数栈索引
case OP_ADD: {
// local a, b, c = ... -----> index(a) = 0, index(b) = 1, index(c) = 2
// a = b + c -----> OP_ADD 0 1|BITRK 2|BITRK
// a = 1 + b -----> index(constval(1)) = 0
// >----> OP_ADD 0 0 1|BITRK
// a = 1 + 100 -----> index(constval(1)) = 0, index(constval(100)) = 1
// >----> OP_ADD 0 0 1
arith_op(luai_numadd, TM_ADD);
continue;
}
case OP_SUB: {
// see OP_ADD
arith_op(luai_numsub, TM_SUB);
continue;
}
case OP_MUL: {
// see OP_ADD
arith_op(luai_nummul, TM_MUL);
continue;
}
case OP_DIV: {
// see OP_ADD
arith_op(luai_numdiv, TM_DIV);
continue;
}
case OP_MOD: {
// 这个很特殊！由于lua没有整数，所以mod可不是%这个运算符！
// 这里定义 mod(x, y) => (x - floor(x/y)*y)
// see OP_ADD
arith_op(luai_nummod, TM_MOD);
continue;
}
case OP_POW: {
// see OP_ADD
arith_op(luai_numpow, TM_POW);
continue;
}
// 功能：实现一元运算符 -, not, #
// iABC：A存放运算结果的参数栈索引，B存放操作数的参数栈索引
case OP_UNM: {
// local a = -b -----> index(a) = 1, index(b) = 2
// >----> OP_UNM 1 2
TValue *rb = RB(i);
if (ttisnumber(rb)) {
lua_Number nb = nvalue(rb);
setnvalue(ra, luai_numunm(nb));
}
else {
Protect(Arith(L, ra, rb, rb, TM_UNM));
}
continue;
}
case OP_NOT: {
// local a = not b -----> index(a) = 1, index(b) = 2
// >----> OP_NOT 1 2
// 那local a = not true呢？人家编译期就给你处理好了
int res = l_isfalse(RB(i)); /* next assignment may change this value */
setbvalue(ra, res);
continue;
}
case OP_LEN: {
// local a = #b -----> index(a) = 1, index(b) = 2
// >----> OP_LEN 1 2
const TValue *rb = RB(i);
switch (ttype(rb)) {
case LUA_TTABLE: {
setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));
break;
}
case LUA_TSTRING: {
setnvalue(ra, cast_num(tsvalue(rb)->len));
break;
}
default: { /* try metamethod */
Protect(
if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN))
luaG_typeerror(L, rb, "get length of");
)
}
}
continue;
}
// 功能：实现字符串拼接运算符 ..
// iABC：A拼接后存放结果的参数栈索引，B第一个要拼接的变量的参数栈索引，C最后一个要拼接的变量的参数栈索引
// 要执行这个指令，对参数栈有特殊要求：
// ... -> string1 -> string2 ... -> stringN -> ...
// ^ ^
// RB RC
case OP_CONCAT: {
// 类似OP_LOADNIL，只不过，这次范围是[rb,rc]，loadnil是[ra,rb]
// local b, c, d, a = "hello", "world", "!"
// a = b .. c .. d -----> index(a) = 4, index(b~d) = 1~3
// >----> OP_CONCAT 4 1 3
// 问题是如果b~d不能保证是连续的怎么办？答案是一个个MOVE上去在OP_CONCAT...
int b = GETARG_B(i);
int c = GETARG_C(i);
Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L));
setobjs2s(L, RA(i), base+b);
continue;
}
//---------------------------------------------------------------------------跳转指令
// 功能：无条件跳转
// iAsBx：A不使用，sBx跳转偏移
// 一般这个语句不单独出现，都是在一些条件控制中和其他的条件跳转指令配合使用的。
case OP_JMP: {
// 无条件跳转指令。由于跳转偏移总是有正向和反向之分的，所以需要用到
// 负数。那就只能用iAsBx类型的指令了。而sBx是有长度限制的！
// 所以，如果生成的指令很多，超过了sBx的长度限制，可能就会编译失败
dojump(L, pc, GETARG_sBx(i));
continue;
}
// 功能：检查两个变量是否相等，满足预期则跳转。配合OP_JMP使用。
// iABC：A纯数字，对比较结果的预期，满足预期则跳转，B参数1的索引，C参数2的索引
case OP_EQ: {
// if a == b then -----> index(a) = 1, index(b) = 2
// >----> 这里将生成两行指令：
// >----> OP_EQ 0 1 2 // 用0，因为成立的话跳过，不成立才执行
// >----> OP_JMP N // N 表示then ... end中间的指令数量
// >----> ... // Instructions between "then" and "end"
TValue *rb = RKB(i);
TValue *rc = RKC(i);
Protect(
if (equalobj(L, rb, rc) == GETARG_A(i))
dojump(L, pc, GETARG_sBx(*pc));
)
pc++;
continue;
}
// 功能：检查两个变量是否小于，满足预期则跳转。配合OP_JMP使用。
// iABC：A纯数字，对比较结果的预期，满足预期则跳转，B参数1的索引，C参数2的索引
case OP_LT: {
// if a < b then -----> index(a) = 1, index(b) = 2
// >----> 这里将生成两行指令：
// >----> OP_LT 0 1 2 // 用0，因为成立的话跳过，不成立才执行
// >----> OP_JMP N // N 表示then ... end中间的指令数量
// >----> ... // Instructions between "then" and "end"
Protect(
if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))
dojump(L, pc, GETARG_sBx(*pc));
)
pc++;
continue;
}
// 功能：检查两个变量是否小于等于，满足预期则跳转。配合OP_JMP使用。
// iABC：A纯数字，对比较结果的预期，满足预期则跳转，B参数1的索引，C参数2的索引
case OP_LE: {
// if a <= b then -----> index(a) = 1, index(b) = 2
// >----> 这里将生成两行指令：
// >----> OP_LE 0 1 2 // 用0，因为成立的话跳过，不成立才执行
// >----> OP_JMP N // N 表示then ... end中间的指令数量
// >----> ... // Instructions between "then" and "end"
Protect(
if (lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))
dojump(L, pc, GETARG_sBx(*pc));
)
pc++;
continue;
}
LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
int i;
lua_State *L;
global_State *g;
#if LUAPLUS_EXTENSIONS
void *l = (*f)(ud, NULL, 0, state_size(LG), "lua_State", 0);
#else
void *l = (*f)(ud, NULL, 0, state_size(LG));
#endif /* LUAPLUS_EXTENSIONS */
if (l == NULL) return NULL;
L = tostate(l);
g = &((LG *)L)->g;
L->next = NULL;
#if LUA_REFCOUNT
L->prev = NULL;
#endif /* LUA_REFCOUNT */
L->tt = LUA_TTHREAD;
g->currentwhite = bit2mask(WHITE0BIT, FIXEDBIT);
L->marked = luaC_white(g);
set2bits(L->marked, FIXEDBIT, SFIXEDBIT);
preinit_state(L, g);
g->frealloc = f;
g->ud = ud;
g->mainthread = L;
g->uvhead.u.l.prev = &g->uvhead;
g->uvhead.u.l.next = &g->uvhead;
g->GCthreshold = 0; /* mark it as unfinished state */
g->strt.size = 0;
g->strt.nuse = 0;
g->strt.hash = NULL;
#if LUA_REFCOUNT
setnilvalue2n(L, registry(L));
#else
setnilvalue(registry(L));
#endif /* LUA_REFCOUNT */
luaZ_initbuffer(L, &g->buff);
g->panic = NULL;
g->gcstate = GCSpause;
g->rootgc = obj2gco(L);
g->sweepstrgc = 0;
g->sweepgc = &g->rootgc;
g->gray = NULL;
g->grayagain = NULL;
g->weak = NULL;
g->tmudata = NULL;
g->totalbytes = sizeof(LG);
g->gcpause = LUAI_GCPAUSE;
g->gcstepmul = LUAI_GCMUL;
g->gcdept = 0;
#if LUAPLUS_EXTENSIONS
g->loadNotifyFunction = NULL;
g->userGCFunction = NULL;
g->gchead_next = &g->gctail_next;
g->gchead_prev = NULL;
g->gctail_next = NULL;
g->gctail_prev = &g->gchead_next;
#endif /* LUAPLUS_EXTENSIONS */
for (i=0; i<NUM_TAGS; i++) g->mt[i] = NULL;
if (luaD_rawrunprotected(L, f_luaopen, NULL) != 0) {
/* memory allocation error: free partial state */
close_state(L);
L = NULL;
}
else
luai_userstateopen(L);
return L;
}
static void cleartable (lua_State *L, GCObject *l) {
#else
static void cleartable (GCObject *l) {
#endif /* LUA_REFCOUNT */
while (l) {
Table *h = gco2h(l);
int i = h->sizearray;
lua_assert(testbit(h->marked, VALUEWEAKBIT) ||
testbit(h->marked, KEYWEAKBIT));
if (testbit(h->marked, VALUEWEAKBIT)) {
while (i--) {
TValue *o = &h->array[i];
#if LUA_REFCOUNT
if (iscleared(o, 0)) { /* value was collected? */
if (iscollectable(o))
o->value.gc->gch.ref--;
setnilvalue2n(l, o); /* remove value */
}
#else
if (iscleared(o, 0)) /* value was collected? */
setnilvalue(o); /* remove value */
#endif /* LUA_REFCOUNT */
}
}
i = sizenode(h);
while (i--) {
Node *n = gnode(h, i);
if (!ttisnil(gval(n)) && /* non-empty entry? */
(iscleared(key2tval(n), 1) || iscleared(gval(n), 0))) {
#if LUA_REFCOUNT
if (iscollectable(gval(n)))
gval(n)->value.gc->gch.ref--;
setnilvalue2n(L, gval(n)); /* remove value ... */
#else
setnilvalue(gval(n)); /* remove value ... */
#endif /* LUA_REFCOUNT */
removeentry(n); /* remove entry from table */
}
}
l = h->gclist;
}
}
static void freeobj (lua_State *L, GCObject *o) {
switch (o->gch.tt) {
case LUA_TPROTO: luaF_freeproto(L, gco2p(o)); break;
case LUA_TFUNCTION: luaF_freeclosure(L, gco2cl(o)); break;
case LUA_TUPVAL: luaF_freeupval(L, gco2uv(o)); break;
case LUA_TTABLE: luaH_free(L, gco2h(o)); break;
case LUA_TTHREAD: {
lua_assert(gco2th(o) != L && gco2th(o) != G(L)->mainthread);
luaE_freethread(L, gco2th(o));
break;
}
case LUA_TSTRING: {
G(L)->strt.nuse--;
luaM_freemem(L, o, sizestring(gco2ts(o)));
break;
}
#if LUA_WIDESTRING
case LUA_TWSTRING: {
G(L)->strt.nuse--;
luaM_freemem(L, o, sizestring(gco2ts(o)));
break;
}
#endif /* LUA_WIDESTRING */
case LUA_TUSERDATA: {
luaM_freemem(L, o, sizeudata(gco2u(o)));
break;
}
default: lua_assert(0);
}
}
#define sweepwholelist(L,p) sweeplist(L,p,MAX_LUMEM)
static GCObject **sweeplist (lua_State *L, GCObject **p, lu_mem count) {
GCObject *curr;
global_State *g = G(L);
int deadmask = otherwhite(g);
while ((curr = *p) != NULL && count-- > 0) {
if (curr->gch.tt == LUA_TTHREAD) /* sweep open upvalues of each thread */
sweepwholelist(L, &gco2th(curr)->openupval);
if ((curr->gch.marked ^ WHITEBITS) & deadmask) { /* not dead? */
lua_assert(!isdead(g, curr) || testbit(curr->gch.marked, FIXEDBIT));
makewhite(g, curr); /* make it white (for next cycle) */
p = &curr->gch.next;
}
else { /* must erase `curr' */
lua_assert(isdead(g, curr) || deadmask == bitmask(SFIXEDBIT));
#if LUA_REFCOUNT
if (curr->gch.prev)
curr->gch.prev->gch.next = curr->gch.next;
if (curr->gch.next)
curr->gch.next->gch.prev = (GCObject*)p;
#endif /* LUA_REFCOUNT */
*p = curr->gch.next;
if (curr == g->rootgc) /* is the first element of the list? */
g->rootgc = curr->gch.next; /* adjust first */
freeobj(L, curr);
}
}
return p;
}
static void marktmu (GCState *st) {
GCObject *u;
#if LUA_REFCOUNT
for (u = st->g->tmudata_head.next; u != (GCObject*)&st->g->tmudata_tail; u = u->gch.next) {
#else !LUA_REFCOUNT
for (u = st->g->tmudata; u; u = u->gch.next) {
#endif LUA_REFCOUNT
unmark(u); /* may be marked, if left from previous GC */
reallymarkobject(st, u);
}
}
/* move `dead' udata that need finalization to list `tmudata' */
size_t luaC_separateudata (lua_State *L) {
size_t deadmem = 0;
#if LUA_REFCOUNT
GCObject **p = &G(L)->rootudata_head.next;
#else !LUA_REFCOUNT
GCObject **p = &G(L)->rootudata;
#endif LUA_REFCOUNT
GCObject *curr;
GCObject *collected = NULL; /* to collect udata with gc event */
#if !LUA_REFCOUNT
GCObject **lastcollected = &collected;
while ((curr = *p) != NULL) {
lua_assert(curr->gch.tt == LUA_TUSERDATA);
#else LUA_REFCOUNT
while ((curr = *p) != (GCObject*)&G(L)->rootudata_tail) {
#endif LUA_REFCOUNT
if (ismarked(curr) || isfinalized(gcotou(curr)))
p = &curr->gch.next; /* don't bother with them */
else if (fasttm(L, gcotou(curr)->uv.metatable, TM_GC) == NULL) {
markfinalized(gcotou(curr)); /* don't need finalization */
p = &curr->gch.next;
}
else { /* must call its gc method */
deadmem += sizeudata(gcotou(curr)->uv.len);
*p = curr->gch.next;
#if LUA_REFCOUNT
Unlink(curr);
curr->gch.next = (GCObject*)&G(L)->tmudata_tail; /* link `curr' at the end of `collected' list */
curr->gch.prev = G(L)->tmudata_tail.prev;
G(L)->tmudata_tail.prev->gch.next = curr;
G(L)->tmudata_tail.prev = curr;
#else !LUA_REFCOUNT
curr->gch.next = NULL; /* link `curr' at the end of `collected' list */
*lastcollected = curr;
lastcollected = &curr->gch.next;
#endif LUA_REFCOUNT
}
}
/* insert collected udata with gc event into `tmudata' list */
#if LUA_REFCOUNT
// *lastcollected = G(L)->tmudata_head.next;
// G(L)->tmudata_head.next = collected;
#else !LUA_REFCOUNT
*lastcollected = G(L)->tmudata;
G(L)->tmudata = collected;
#endif LUA_REFCOUNT
return deadmem;
}
static void removekey (lua_State *L, Node *n) {
(void)L;
setnilvalue(gval(n)); /* remove corresponding value ... */
if (iscollectable(gkey(n)))
setttype(gkey(n), LUA_TNONE); /* dead key; remove it */
}
StkId luaV_execute (lua_State *L) {
LClosure *cl;
TObject *k;
const Instruction *pc;
callentry: /* entry point when calling new functions */
L->ci->u.l.pc = &pc;
if (L->hookmask & LUA_MASKCALL)
luaD_callhook(L, LUA_HOOKCALL, -1);
retentry: /* entry point when returning to old functions */
lua_assert(L->ci->state == CI_SAVEDPC ||
L->ci->state == (CI_SAVEDPC | CI_CALLING));
L->ci->state = CI_HASFRAME; /* activate frame */
pc = L->ci->u.l.savedpc;
cl = &clvalue(L->base - 1)->l;
k = cl->p->k;
/* main loop of interpreter */
for (;;) {
const Instruction i = *pc++;
StkId base, ra;
if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
(--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
traceexec(L);
if (L->ci->state & CI_YIELD) { /* did hook yield? */
L->ci->u.l.savedpc = pc - 1;
L->ci->state = CI_YIELD | CI_SAVEDPC;
return NULL;
}
}
/* warning!! several calls may realloc the stack and invalidate `ra' */
base = L->base;
ra = RA(i);
lua_assert(L->ci->state & CI_HASFRAME);
lua_assert(base == L->ci->base);
lua_assert(L->top <= L->stack + L->stacksize && L->top >= base);
lua_assert(L->top == L->ci->top ||
GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
GET_OPCODE(i) == OP_RETURN || GET_OPCODE(i) == OP_SETLISTO);
switch (GET_OPCODE(i)) {
case OP_MOVE: {
setobjs2s(ra, RB(i));
break;
}
case OP_LOADK: {
setobj2s(ra, KBx(i));
break;
}
case OP_LOADBOOL: {
setbvalue(ra, GETARG_B(i));
if (GETARG_C(i)) pc++; /* skip next instruction (if C) */
break;
}
case OP_LOADNIL: {
TObject *rb = RB(i);
do {
setnilvalue(rb--);
} while (rb >= ra);
break;
}
case OP_GETUPVAL: {
int b = GETARG_B(i);
setobj2s(ra, cl->upvals[b]->v);
break;
}
case OP_GETGLOBAL: {
TObject *rb = KBx(i);
const TObject *v;
lua_assert(ttisstring(rb) && ttistable(&cl->g));
v = luaH_getstr(hvalue(&cl->g), tsvalue(rb));
if (!ttisnil(v)) { setobj2s(ra, v); }
else
setobj2s(XRA(i), luaV_index(L, &cl->g, rb, 0));
break;
}
case OP_GETTABLE: {
StkId rb = RB(i);
TObject *rc = RKC(i);
if (ttistable(rb)) {
const TObject *v = luaH_get(hvalue(rb), rc);
if (!ttisnil(v)) { setobj2s(ra, v); }
else
setobj2s(XRA(i), luaV_index(L, rb, rc, 0));
}
else
setobj2s(XRA(i), luaV_getnotable(L, rb, rc, 0));
break;
}
case OP_SETGLOBAL: {
lua_assert(ttisstring(KBx(i)) && ttistable(&cl->g));
luaV_settable(L, &cl->g, KBx(i), ra);
break;
}
case OP_SETUPVAL: {
int b = GETARG_B(i);
setobj(cl->upvals[b]->v, ra); /* write barrier */
break;
}
case OP_SETTABLE: {
luaV_settable(L, ra, RKB(i), RKC(i));
break;
}
case OP_NEWTABLE: {
int b = GETARG_B(i);
b = fb2int(b);
sethvalue(ra, luaH_new(L, b, GETARG_C(i)));
luaC_checkGC(L);
break;
}
case OP_SELF: {
StkId rb = RB(i);
TObject *rc = RKC(i);
runtime_check(L, ttisstring(rc));
setobjs2s(ra+1, rb);
if (ttistable(rb)) {
const TObject *v = luaH_getstr(hvalue(rb), tsvalue(rc));
if (!ttisnil(v)) { setobj2s(ra, v); }
else
setobj2s(XRA(i), luaV_index(L, rb, rc, 0));
}
else
setobj2s(XRA(i), luaV_getnotable(L, rb, rc, 0));
break;
}
case OP_ADD: {
TObject *rb = RKB(i);
TObject *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) {
setnvalue(ra, nvalue(rb) + nvalue(rc));
}
else
Arith(L, ra, rb, rc, TM_ADD);
break;
}
case OP_SUB: {
TObject *rb = RKB(i);
TObject *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) {
setnvalue(ra, nvalue(rb) - nvalue(rc));
}
else
Arith(L, ra, rb, rc, TM_SUB);
break;
}
case OP_MUL: {
TObject *rb = RKB(i);
TObject *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) {
setnvalue(ra, nvalue(rb) * nvalue(rc));
}
else
Arith(L, ra, rb, rc, TM_MUL);
break;
}
case OP_DIV: {
TObject *rb = RKB(i);
TObject *rc = RKC(i);
if (ttisnumber(rb) && ttisnumber(rc)) {
setnvalue(ra, nvalue(rb) / nvalue(rc));
}
else
Arith(L, ra, rb, rc, TM_DIV);
break;
}
case OP_POW: {
Arith(L, ra, RKB(i), RKC(i), TM_POW);
break;
}
case OP_UNM: {
const TObject *rb = RB(i);
TObject temp;
if (tonumber(rb, &temp)) {
setnvalue(ra, -nvalue(rb));
}
else {
setnilvalue(&temp);
if (!call_binTM(L, RB(i), &temp, ra, TM_UNM))
luaG_aritherror(L, RB(i), &temp);
}
break;
}
case OP_NOT: {
int res = l_isfalse(RB(i)); /* next assignment may change this value */
setbvalue(ra, res);
break;
}
case OP_CONCAT: {
int b = GETARG_B(i);
int c = GETARG_C(i);
luaV_concat(L, c-b+1, c); /* may change `base' (and `ra') */
base = L->base;
setobjs2s(RA(i), base+b);
luaC_checkGC(L);
break;
}
case OP_JMP: {
dojump(pc, GETARG_sBx(i));
break;
}
case OP_EQ: {
if (equalobj(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;
else dojump(pc, GETARG_sBx(*pc) + 1);
break;
}
case OP_LT: {
if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;
else dojump(pc, GETARG_sBx(*pc) + 1);
break;
}
case OP_LE: {
if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;
else dojump(pc, GETARG_sBx(*pc) + 1);
break;
}
case OP_TEST: {
TObject *rb = RB(i);
if (l_isfalse(rb) == GETARG_C(i)) pc++;
else {
setobjs2s(ra, rb);
dojump(pc, GETARG_sBx(*pc) + 1);
}
break;
}
case OP_CALL:
case OP_TAILCALL: {
StkId firstResult;
int b = GETARG_B(i);
int nresults;
if (b != 0) L->top = ra+b; /* else previous instruction set top */
nresults = GETARG_C(i) - 1;
firstResult = luaD_precall(L, ra);
if (firstResult) {
if (firstResult > L->top) { /* yield? */
lua_assert(L->ci->state == (CI_C | CI_YIELD));
(L->ci - 1)->u.l.savedpc = pc;
(L->ci - 1)->state = CI_SAVEDPC;
return NULL;
}
/* it was a C function (`precall' called it); adjust results */
luaD_poscall(L, nresults, firstResult);
if (nresults >= 0) L->top = L->ci->top;
}
else { /* it is a Lua function */
if (GET_OPCODE(i) == OP_CALL) { /* regular call? */
(L->ci-1)->u.l.savedpc = pc; /* save `pc' to return later */
(L->ci-1)->state = (CI_SAVEDPC | CI_CALLING);
}
else { /* tail call: put new frame in place of previous one */
int aux;
base = (L->ci - 1)->base; /* `luaD_precall' may change the stack */
ra = RA(i);
if (L->openupval) luaF_close(L, base);
for (aux = 0; ra+aux < L->top; aux++) /* move frame down */
setobjs2s(base+aux-1, ra+aux);
(L->ci - 1)->top = L->top = base+aux; /* correct top */
lua_assert(L->ci->state & CI_SAVEDPC);
(L->ci - 1)->u.l.savedpc = L->ci->u.l.savedpc;
(L->ci - 1)->u.l.tailcalls++; /* one more call lost */
(L->ci - 1)->state = CI_SAVEDPC;
L->ci--; /* remove new frame */
L->base = L->ci->base;
}
goto callentry;
}
break;
}
case OP_RETURN: {
CallInfo *ci = L->ci - 1; /* previous function frame */
int b = GETARG_B(i);
if (b != 0) L->top = ra+b-1;
lua_assert(L->ci->state & CI_HASFRAME);
if (L->openupval) luaF_close(L, base);
L->ci->state = CI_SAVEDPC; /* deactivate current function */
L->ci->u.l.savedpc = pc;
/* previous function was running `here'? */
if (!(ci->state & CI_CALLING)) {
lua_assert((ci->state & CI_C) || ci->u.l.pc != &pc);
return ra; /* no: return */
}
else { /* yes: continue its execution */
int nresults;
lua_assert(ci->u.l.pc == &pc &&
ttisfunction(ci->base - 1) &&
(ci->state & CI_SAVEDPC));
lua_assert(GET_OPCODE(*(ci->u.l.savedpc - 1)) == OP_CALL);
nresults = GETARG_C(*(ci->u.l.savedpc - 1)) - 1;
luaD_poscall(L, nresults, ra);
if (nresults >= 0) L->top = L->ci->top;
goto retentry;
}
}
case OP_FORLOOP: {
lua_Number step, idx, limit;
const TObject *plimit = ra+1;
const TObject *pstep = ra+2;
if (!ttisnumber(ra))
luaG_runerror(L, "`for' initial value must be a number");
if (!tonumber(plimit, ra+1))
luaG_runerror(L, "`for' limit must be a number");
if (!tonumber(pstep, ra+2))
luaG_runerror(L, "`for' step must be a number");
step = nvalue(pstep);
idx = nvalue(ra) + step; /* increment index */
limit = nvalue(plimit);
if (step > 0 ? idx <= limit : idx >= limit) {
dojump(pc, GETARG_sBx(i)); /* jump back */
chgnvalue(ra, idx); /* update index */
}
break;
}
case OP_TFORLOOP: {
int nvar = GETARG_C(i) + 1;
StkId cb = ra + nvar + 2; /* call base */
setobjs2s(cb, ra);
setobjs2s(cb+1, ra+1);
setobjs2s(cb+2, ra+2);
L->top = cb+3; /* func. + 2 args (state and index) */
luaD_call(L, cb, nvar);
L->top = L->ci->top;
ra = XRA(i) + 2; /* final position of first result */
cb = ra + nvar;
do { /* move results to proper positions */
nvar--;
setobjs2s(ra+nvar, cb+nvar);
} while (nvar > 0);
if (ttisnil(ra)) /* break loop? */
pc++; /* skip jump (break loop) */
else
dojump(pc, GETARG_sBx(*pc) + 1); /* jump back */
break;
}
case OP_TFORPREP: { /* for compatibility only */
if (ttistable(ra)) {
setobjs2s(ra+1, ra);
setobj2s(ra, luaH_getstr(hvalue(gt(L)), luaS_new(L, "next")));
}
dojump(pc, GETARG_sBx(i));
break;
}
case OP_SETLIST:
case OP_SETLISTO: {
int bc;
int n;
Table *h;
runtime_check(L, ttistable(ra));
h = hvalue(ra);
bc = GETARG_Bx(i);
if (GET_OPCODE(i) == OP_SETLIST)
n = (bc&(LFIELDS_PER_FLUSH-1)) + 1;
else {
n = L->top - ra - 1;
L->top = L->ci->top;
}
bc &= ~(LFIELDS_PER_FLUSH-1); /* bc = bc - bc%FPF */
for (; n > 0; n--)
setobj2t(luaH_setnum(L, h, bc+n), ra+n); /* write barrier */
break;
}
case OP_CLOSE: {
luaF_close(L, ra);
break;
}
case OP_CLOSURE: {
Proto *p;
Closure *ncl;
int nup, j;
p = cl->p->p[GETARG_Bx(i)];
nup = p->nups;
ncl = luaF_newLclosure(L, nup, &cl->g);
ncl->l.p = p;
for (j=0; j<nup; j++, pc++) {
if (GET_OPCODE(*pc) == OP_GETUPVAL)
ncl->l.upvals[j] = cl->upvals[GETARG_B(*pc)];
else {
lua_assert(GET_OPCODE(*pc) == OP_MOVE);
ncl->l.upvals[j] = luaF_findupval(L, base + GETARG_B(*pc));
}
}
setclvalue(ra, ncl);
luaC_checkGC(L);
break;
}
}
}
}
static void Arith (lua_State *L, StkId ra, const TValue *rb,
const TValue *rc, TMS op) {
TValue tempb, tempc;
const TValue *b, *c;
#if LUA_REFCOUNT
luarc_newvalue(&tempb);
luarc_newvalue(&tempc);
if ((b = luaV_tonumber(L, rb, &tempb)) != NULL &&
(c = luaV_tonumber(L, rc, &tempc)) != NULL) {
#else
if ((b = luaV_tonumber(rb, &tempb)) != NULL &&
(c = luaV_tonumber(rc, &tempc)) != NULL) {
#endif /* LUA_REFCOUNT */
lua_Number nb = nvalue(b), nc = nvalue(c);
#if LUA_REFCOUNT
luarc_cleanvalue(&tempb);
luarc_cleanvalue(&tempc);
#endif /* LUA_REFCOUNT */
switch (op) {
case TM_ADD: setnvalue(ra, luai_numadd(nb, nc)); break;
case TM_SUB: setnvalue(ra, luai_numsub(nb, nc)); break;
case TM_MUL: setnvalue(ra, luai_nummul(nb, nc)); break;
case TM_DIV: setnvalue(ra, luai_numdiv(nb, nc)); break;
case TM_MOD: setnvalue(ra, luai_nummod(nb, nc)); break;
case TM_POW: setnvalue(ra, luai_numpow(nb, nc)); break;
case TM_UNM: setnvalue(ra, luai_numunm(nb)); break;
default: lua_assert(0); break;
}
}
#if LUA_REFCOUNT
else if (!call_binTM(L, rb, rc, ra, op)) {
luarc_cleanvalue(&tempb);
luarc_cleanvalue(&tempc);
luaG_aritherror(L, rb, rc);
}
#else
else if (!call_binTM(L, rb, rc, ra, op))
luaG_aritherror(L, rb, rc);
#endif /* LUA_REFCOUNT */
}
/*
** some macros for common tasks in `luaV_execute'
*/
#define runtime_check(L, c) { if (!(c)) break; }
#define RA(i) (base+GETARG_A(i))
/* to be used after possible stack reallocation */
#define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
#define RC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))
#define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \
ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))
#define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \
ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))
#define KBx(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, k+GETARG_Bx(i))
#define dojump(L,pc,i) {(pc) += (i); luai_threadyield(L);}
#define Protect(x) { L->savedpc = pc; {x;}; base = L->base; }
#define arith_op(op,tm) { \
TValue *rb = RKB(i); \
TValue *rc = RKC(i); \
if (ttisnumber(rb) && ttisnumber(rc)) { \
lua_Number nb = nvalue(rb), nc = nvalue(rc); \
setnvalue(ra, op(nb, nc)); \
} \
else \
Protect(Arith(L, ra, rb, rc, tm)); \
}
#if LUA_BITFIELD_OPS
#define bit_op(op) { \
TValue *rb = RKB(i); \
TValue *rc = RKC(i); \
if (ttisnumber(rb) && ttisnumber(rc)) { \
unsigned int nb = (unsigned int)nvalue(rb), nc = (unsigned int)nvalue(rc); \
setnvalue(ra, nb op nc); \
} \
else \
luaG_aritherror(L, rb, rc); \
}
#endif /* LUA_BITFIELD_OPS */
void luaV_execute (lua_State *L, int nexeccalls) {
LClosure *cl;
StkId base;
TValue *k;
const Instruction *pc;
reentry: /* entry point */
lua_assert(isLua(L->ci));
pc = L->savedpc;
cl = &clvalue(L->ci->func)->l;
base = L->base;
k = cl->p->k;
/* main loop of interpreter */
for (;;) {
const Instruction i = *pc++;
StkId ra;
if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
(--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
traceexec(L, pc);
if (L->status == LUA_YIELD) { /* did hook yield? */
L->savedpc = pc - 1;
return;
}
base = L->base;
}
/* warning!! several calls may realloc the stack and invalidate `ra' */
ra = RA(i);
lua_assert(base == L->base && L->base == L->ci->base);
lua_assert(base <= L->top && L->top <= L->stack + L->stacksize);
lua_assert(L->top == L->ci->top || luaG_checkopenop(i));
switch (GET_OPCODE(i)) {
case OP_MOVE: {
setobjs2s(L, ra, RB(i));
continue;
}
case OP_LOADK: {
setobj2s(L, ra, KBx(i));
continue;
}
case OP_LOADBOOL: {
setbvalue(ra, GETARG_B(i));
if (GETARG_C(i)) pc++; /* skip next instruction (if C) */
continue;
}
case OP_LOADNIL: {
TValue *rb = RB(i);
do {
setnilvalue(rb--);
} while (rb >= ra);
continue;
}
case OP_GETUPVAL: {
int b = GETARG_B(i);
setobj2s(L, ra, cl->upvals[b]->v);
continue;
}
case OP_GETGLOBAL: {
TValue g;
TValue *rb = KBx(i);
#if LUA_REFCOUNT
sethvalue2n(L, &g, cl->env);
#else
sethvalue(L, &g, cl->env);
#endif /* LUA_REFCOUNT */
lua_assert(ttisstring(rb));
Protect(luaV_gettable(L, &g, rb, ra));
#if LUA_REFCOUNT
setnilvalue(&g);
#endif /* LUA_REFCOUNT */
continue;
}
case OP_GETTABLE: {
Protect(luaV_gettable(L, RB(i), RKC(i), ra));
continue;
}
case OP_SETGLOBAL: {
TValue g;
#if LUA_REFCOUNT
sethvalue2n(L, &g, cl->env);
#else
sethvalue(L, &g, cl->env);
#endif /* LUA_REFCOUNT */
lua_assert(ttisstring(KBx(i)));
Protect(luaV_settable(L, &g, KBx(i), ra));
#if LUA_REFCOUNT
setnilvalue(&g);
#endif /* LUA_REFCOUNT */
continue;
}
case OP_SETUPVAL: {
UpVal *uv = cl->upvals[GETARG_B(i)];
setobj(L, uv->v, ra);
luaC_barrier(L, uv, ra);
continue;
}
case OP_SETTABLE: {
Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
continue;
}
case OP_NEWTABLE: {
int b = GETARG_B(i);
int c = GETARG_C(i);
sethvalue(L, ra, luaH_new(L, luaO_fb2int(b), luaO_fb2int(c)));
Protect(luaC_checkGC(L));
continue;
}
case OP_SELF: {
StkId rb = RB(i);
setobjs2s(L, ra+1, rb);
Protect(luaV_gettable(L, rb, RKC(i), ra));
continue;
}
case OP_ADD: {
arith_op(luai_numadd, TM_ADD);
continue;
}
case OP_SUB: {
arith_op(luai_numsub, TM_SUB);
continue;
}
case OP_MUL: {
arith_op(luai_nummul, TM_MUL);
continue;
}
case OP_DIV: {
arith_op(luai_numdiv, TM_DIV);
continue;
}
case OP_MOD: {
arith_op(luai_nummod, TM_MOD);
continue;
}
case OP_POW: {
arith_op(luai_numpow, TM_POW);
continue;
}
case OP_UNM: {
TValue *rb = RB(i);
if (ttisnumber(rb)) {
lua_Number nb = nvalue(rb);
setnvalue(ra, luai_numunm(nb));
}
else {
Protect(Arith(L, ra, rb, rb, TM_UNM));
}
continue;
}
case OP_NOT: {
int res = l_isfalse(RB(i)); /* next assignment may change this value */
setbvalue(ra, res);
continue;
}
#if LUA_BITFIELD_OPS
case OP_BAND: {
bit_op(&);
continue;
}
case OP_BOR: {
bit_op(|);
continue;
}
case OP_BXOR: {
bit_op(^);
continue;
}
case OP_BSHL: {
bit_op(<<);
continue;
}
case OP_BSHR: {
bit_op(>>);
continue;
}
#endif /* LUA_BITFIELD_OPS */
case OP_LEN: {
const TValue *rb = RB(i);
switch (ttype(rb)) {
case LUA_TTABLE: {
setnvalue(ra, cast_num(luaH_getn(hvalue(rb))));
break;
}
case LUA_TSTRING: {
setnvalue(ra, cast_num(tsvalue(rb)->len));
break;
}
#if LUA_WIDESTRING
case LUA_TWSTRING: {
setnvalue(ra, cast_num(tsvalue(rb)->len));
break;
}
#endif /* LUA_WIDESTRING */
default: { /* try metamethod */
Protect(
if (!call_binTM(L, rb, luaO_nilobject, ra, TM_LEN))
luaG_typeerror(L, rb, "get length of");
)
}
}
continue;
}
case OP_CONCAT: {
int b = GETARG_B(i);
int c = GETARG_C(i);
Protect(luaV_concat(L, c-b+1, c); luaC_checkGC(L));
setobjs2s(L, RA(i), base+b);
continue;
}
case OP_JMP: {
dojump(L, pc, GETARG_sBx(i));
continue;
}
case OP_EQ: {
TValue *rb = RKB(i);
TValue *rc = RKC(i);
Protect(
if (equalobj(L, rb, rc) == GETARG_A(i))
dojump(L, pc, GETARG_sBx(*pc));
)
pc++;
continue;
}
case OP_LT: {
Protect(
if (luaV_lessthan(L, RKB(i), RKC(i)) == GETARG_A(i))
dojump(L, pc, GETARG_sBx(*pc));
)
pc++;
continue;
}
case OP_LE: {
Protect(
if (lessequal(L, RKB(i), RKC(i)) == GETARG_A(i))
dojump(L, pc, GETARG_sBx(*pc));
)
pc++;
continue;
}