private static int patchtestreg(FuncState fs, int node, int reg) { InstructionPtr i = getjumpcontrol(fs, node); if (GET_OPCODE(i[0]) != OpCode.OP_TESTSET) { return(0); /* cannot patch other instructions */ } if (reg != NO_REG && reg != GETARG_B(i[0])) { SETARG_A(i, reg); } else /* no register to put value or register already has the value */ { i[0] = (uint)CREATE_ABC(OpCode.OP_TEST, GETARG_B(i[0]), 0, GETARG_C(i[0])); } return(1); }
//#define Protect(x) { L.savedpc = pc; {x;}; base = L.base_; } public static void arith_op(LuaState L, op_delegate op, TMS tm, StkId base_, Instruction i, TValue[] k, StkId ra, InstructionPtr pc) { TValue rb = RKB(L, base_, i, k); TValue rc = RKC(L, base_, i, k); if (ttisnumber(rb) && ttisnumber(rc)) { lua_Number nb = nvalue(rb), nc = nvalue(rc); setnvalue(ra, op(nb, nc)); } else { //Protect( L.savedpc = InstructionPtr.Assign(pc); Arith(L, ra, rb, rc, tm); base_ = L.base_; //); } }
private static void traceexec(LuaState L, InstructionPtr pc) { lu_byte mask = L.hookmask; InstructionPtr oldpc = InstructionPtr.Assign(L.savedpc); L.savedpc = InstructionPtr.Assign(pc); if (((mask & LUA_MASKCOUNT) != 0) && (L.hookcount == 0)) { resethookcount(L); luaD_callhook(L, LUA_HOOKCOUNT, -1); } if ((mask & LUA_MASKLINE) != 0) { Proto p = ci_func(L.ci).l.p; int npc = pcRel(pc, p); int newline = getline(p, npc); /* call linehook when enter a new function, when jump back (loop), or when enter a new line */ if (npc == 0 || pc <= oldpc || newline != getline(p, pcRel(oldpc, p))) luaD_callhook(L, LUA_HOOKLINE, newline); } }
public static int luaD_precall(LuaState L, StkId func, int nresults) { LClosure cl; ptrdiff_t funcr; if (!ttisfunction(func)) /* `func' is not a function? */ { func = tryfuncTM(L, func); /* check the `function' tag method */ } funcr = savestack(L, func); cl = clvalue(func).l; L.ci.savedpc = InstructionPtr.Assign(L.savedpc); if (cl.isC == 0) { /* Lua function? prepare its call */ CallInfo ci; StkId st, base_; Proto p = cl.p; luaD_checkstack(L, p.maxstacksize); func = restorestack(L, funcr); if (p.is_vararg == 0) { /* no varargs? */ base_ = L.stack[func + 1]; if (L.top > base_ + p.numparams) { L.top = base_ + p.numparams; } } else { /* vararg function */ int nargs = L.top - func - 1; base_ = adjust_varargs(L, p, nargs); func = restorestack(L, funcr); /* previous call may change the stack */ } ci = inc_ci(L); /* now `enter' new function */ ci.func = func; L.base_ = ci.base_ = base_; ci.top = L.base_ + p.maxstacksize; lua_assert(ci.top <= L.stack_last); L.savedpc = new InstructionPtr(p.code, 0); /* starting point */ ci.tailcalls = 0; ci.nresults = nresults; for (st = L.top; st < ci.top; StkId.inc(ref st)) { setnilvalue(st); } L.top = ci.top; if ((L.hookmask & LUA_MASKCALL) != 0) { InstructionPtr.inc(ref L._savedpc); /* hooks assume 'pc' is already incremented */ luaD_callhook(L, LUA_HOOKCALL, -1); InstructionPtr.dec(ref L._savedpc); /* correct 'pc' */ } return(PCRLUA); } else { /* if is a C function, call it */ CallInfo ci; int n; luaD_checkstack(L, LUA_MINSTACK); /* ensure minimum stack size */ ci = inc_ci(L); /* now `enter' new function */ ci.func = restorestack(L, funcr); L.base_ = ci.base_ = ci.func + 1; ci.top = L.top + LUA_MINSTACK; lua_assert(ci.top <= L.stack_last); ci.nresults = nresults; if ((L.hookmask & LUA_MASKCALL) != 0) { luaD_callhook(L, LUA_HOOKCALL, -1); } lua_unlock(L); n = curr_func(L).c.f(L); /* do the actual call */ lua_lock(L); if (n < 0) /* yielding? */ { return(PCRYIELD); } else { luaD_poscall(L, L.top - n); return(PCRC); } } }
public static void dojump(LuaState L, InstructionPtr pc, int i) { pc.pc += i; luai_threadyield(L); }
public static InstructionPtr Assign(InstructionPtr ptr) { if (ptr == null) return null; return new InstructionPtr(ptr.codes, ptr.pc); }
private static void fixjump(FuncState fs, int pc, int dest) { InstructionPtr jmp = new InstructionPtr(fs.f.code, pc); int offset = dest - (pc + 1); lua_assert(dest != NO_JUMP); if (Math.Abs(offset) > MAXARG_sBx) luaX_syntaxerror(fs.ls, "control structure too long"); SETARG_sBx(jmp, offset); }
public static OpCode GET_OPCODE(InstructionPtr i) { return GET_OPCODE(i[0]); }
public static int GETARG_sBx(InstructionPtr i) { return GETARG_sBx(i[0]); }
public static void SET_OPCODE(InstructionPtr i, OpCode opcode) { SET_OPCODE(ref i.codes[i.pc], opcode); }
public static int pcRel(InstructionPtr pc, Proto p) { Debug.Assert(pc.codes == p.code); return(pc.pc - 1); }
public static void luaV_execute(LuaState L, int nexeccalls) { LClosure cl; StkId base_; TValue[] k; /*const*/ InstructionPtr pc; reentry: /* entry point */ lua_assert(isLua(L.ci)); pc = InstructionPtr.Assign(L.savedpc); cl = clvalue(L.ci.func).l; base_ = L.base_; k = cl.p.k; /* main loop of interpreter */ for (; ;) { /*const*/ Instruction i = InstructionPtr.inc(ref pc)[0]; StkId ra; if (((L.hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) != 0) && (((--L.hookcount) == 0) || ((L.hookmask & LUA_MASKLINE) != 0))) { traceexec(L, pc); if (L.status == LUA_YIELD) { /* did hook yield? */ L.savedpc = new InstructionPtr(pc.codes, pc.pc - 1); return; } base_ = L.base_; } /* warning!! several calls may realloc the stack and invalidate `ra' */ ra = RA(L, base_, 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) != 0)); //Dump(pc.pc, i); switch (GET_OPCODE(i)) { case OpCode.OP_MOVE: { setobjs2s(L, ra, RB(L, base_, i)); continue; } case OpCode.OP_LOADK: { setobj2s(L, ra, KBx(L, i, k)); continue; } case OpCode.OP_LOADBOOL: { setbvalue(ra, GETARG_B(i)); if (GETARG_C(i) != 0) { InstructionPtr.inc(ref pc); /* skip next instruction (if C) */ } continue; } case OpCode.OP_LOADNIL: { TValue rb = RB(L, base_, i); do { setnilvalue(StkId.dec(ref rb)); } while (rb >= ra); continue; } case OpCode.OP_GETUPVAL: { int b = GETARG_B(i); setobj2s(L, ra, cl.upvals[b].v); continue; } case OpCode.OP_GETGLOBAL: { TValue g = new TValue(); TValue rb = KBx(L, i, k); sethvalue(L, g, cl.env); lua_assert(ttisstring(rb)); //Protect( L.savedpc = InstructionPtr.Assign(pc); luaV_gettable(L, g, rb, ra); base_ = L.base_; //); L.savedpc = InstructionPtr.Assign(pc); continue; } case OpCode.OP_GETTABLE: { //Protect( L.savedpc = InstructionPtr.Assign(pc); luaV_gettable(L, RB(L, base_, i), RKC(L, base_, i, k), ra); base_ = L.base_; //); L.savedpc = InstructionPtr.Assign(pc); continue; } case OpCode.OP_SETGLOBAL: { TValue g = new TValue(); sethvalue(L, g, cl.env); lua_assert(ttisstring(KBx(L, i, k))); //Protect( L.savedpc = InstructionPtr.Assign(pc); luaV_settable(L, g, KBx(L, i, k), ra); base_ = L.base_; //); L.savedpc = InstructionPtr.Assign(pc); continue; } case OpCode.OP_SETUPVAL: { UpVal uv = cl.upvals[GETARG_B(i)]; setobj(L, uv.v, ra); luaC_barrier(L, uv, ra); continue; } case OpCode.OP_SETTABLE: { //Protect( L.savedpc = InstructionPtr.Assign(pc); luaV_settable(L, ra, RKB(L, base_, i, k), RKC(L, base_, i, k)); base_ = L.base_; //); L.savedpc = InstructionPtr.Assign(pc); continue; } case OpCode.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( L.savedpc = InstructionPtr.Assign(pc); luaC_checkGC(L); base_ = L.base_; //); L.savedpc = InstructionPtr.Assign(pc); continue; } case OpCode.OP_SELF: { StkId rb = RB(L, base_, i); setobjs2s(L, ra + 1, rb); //Protect( L.savedpc = InstructionPtr.Assign(pc); luaV_gettable(L, rb, RKC(L, base_, i, k), ra); base_ = L.base_; //); L.savedpc = InstructionPtr.Assign(pc); continue; } case OpCode.OP_ADD: { arith_op(L, luai_numadd, TMS.TM_ADD, base_, i, k, ra, pc); continue; } case OpCode.OP_SUB: { arith_op(L, luai_numsub, TMS.TM_SUB, base_, i, k, ra, pc); continue; } case OpCode.OP_MUL: { arith_op(L, luai_nummul, TMS.TM_MUL, base_, i, k, ra, pc); continue; } case OpCode.OP_DIV: { arith_op(L, luai_numdiv, TMS.TM_DIV, base_, i, k, ra, pc); continue; } case OpCode.OP_MOD: { arith_op(L, luai_nummod, TMS.TM_MOD, base_, i, k, ra, pc); continue; } case OpCode.OP_POW: { arith_op(L, luai_numpow, TMS.TM_POW, base_, i, k, ra, pc); continue; } case OpCode.OP_UNM: { TValue rb = RB(L, base_, i); if (ttisnumber(rb)) { lua_Number nb = nvalue(rb); setnvalue(ra, luai_numunm(nb)); } else { //Protect( L.savedpc = InstructionPtr.Assign(pc); Arith(L, ra, rb, rb, TMS.TM_UNM); base_ = L.base_; //); L.savedpc = InstructionPtr.Assign(pc); } continue; } case OpCode.OP_NOT: { int res = l_isfalse(RB(L, base_, i)) == 0 ? 0 : 1; /* next assignment may change this value */ setbvalue(ra, res); continue; } case OpCode.OP_LEN: { TValue rb = RB(L, base_, i); switch (ttype(rb)) { case LUA_TTABLE: { setnvalue(ra, (lua_Number)luaH_getn(hvalue(rb))); break; } case LUA_TSTRING: { setnvalue(ra, (lua_Number)tsvalue(rb).len); break; } default: { /* try metamethod */ //Protect( L.savedpc = InstructionPtr.Assign(pc); if (call_binTM(L, rb, luaO_nilobject, ra, TMS.TM_LEN) == 0) { luaG_typeerror(L, rb, "get length of"); } base_ = L.base_; //) break; } } continue; } case OpCode.OP_CONCAT: { int b = GETARG_B(i); int c = GETARG_C(i); //Protect( L.savedpc = InstructionPtr.Assign(pc); luaV_concat(L, c - b + 1, c); luaC_checkGC(L); base_ = L.base_; //); setobjs2s(L, RA(L, base_, i), base_ + b); continue; } case OpCode.OP_JMP: { dojump(L, pc, GETARG_sBx(i)); continue; } case OpCode.OP_EQ: { TValue rb = RKB(L, base_, i, k); TValue rc = RKC(L, base_, i, k); //Protect( L.savedpc = InstructionPtr.Assign(pc); if (equalobj(L, rb, rc) == GETARG_A(i)) { dojump(L, pc, GETARG_sBx(pc[0])); } base_ = L.base_; //); InstructionPtr.inc(ref pc); continue; } case OpCode.OP_LT: { //Protect( L.savedpc = InstructionPtr.Assign(pc); if (luaV_lessthan(L, RKB(L, base_, i, k), RKC(L, base_, i, k)) == GETARG_A(i)) { dojump(L, pc, GETARG_sBx(pc[0])); } base_ = L.base_; //); InstructionPtr.inc(ref pc); continue; } case OpCode.OP_LE: { //Protect( L.savedpc = InstructionPtr.Assign(pc); if (lessequal(L, RKB(L, base_, i, k), RKC(L, base_, i, k)) == GETARG_A(i)) { dojump(L, pc, GETARG_sBx(pc[0])); } base_ = L.base_; //); InstructionPtr.inc(ref pc); continue; } case OpCode.OP_TEST: { if (l_isfalse(ra) != GETARG_C(i)) { dojump(L, pc, GETARG_sBx(pc[0])); } InstructionPtr.inc(ref pc); continue; } case OpCode.OP_TESTSET: { TValue rb = RB(L, base_, i); if (l_isfalse(rb) != GETARG_C(i)) { setobjs2s(L, ra, rb); dojump(L, pc, GETARG_sBx(pc[0])); } InstructionPtr.inc(ref pc); continue; } case OpCode.OP_CALL: { int b = GETARG_B(i); int nresults = GETARG_C(i) - 1; if (b != 0) { L.top = ra + b; /* else previous instruction set top */ } L.savedpc = InstructionPtr.Assign(pc); switch (luaD_precall(L, ra, nresults)) { case PCRLUA: { nexeccalls++; goto reentry; /* restart luaV_execute over new Lua function */ } case PCRC: { /* it was a C function (`precall' called it); adjust results */ if (nresults >= 0) { L.top = L.ci.top; } base_ = L.base_; continue; } default: { return; /* yield */ } } } case OpCode.OP_TAILCALL: { int b = GETARG_B(i); if (b != 0) { L.top = ra + b; /* else previous instruction set top */ } L.savedpc = InstructionPtr.Assign(pc); lua_assert(GETARG_C(i) - 1 == LUA_MULTRET); switch (luaD_precall(L, ra, LUA_MULTRET)) { case PCRLUA: { /* tail call: put new frame in place of previous one */ CallInfo ci = L.ci - 1; /* previous frame */ int aux; StkId func = ci.func; StkId pfunc = (ci + 1).func; /* previous function index */ if (L.openupval != null) { luaF_close(L, ci.base_); } L.base_ = ci.base_ = ci.func + (ci[1].base_ - pfunc); for (aux = 0; pfunc + aux < L.top; aux++) /* move frame down */ { setobjs2s(L, func + aux, pfunc + aux); } ci.top = L.top = func + aux; /* correct top */ lua_assert(L.top == L.base_ + clvalue(func).l.p.maxstacksize); ci.savedpc = InstructionPtr.Assign(L.savedpc); ci.tailcalls++; /* one more call lost */ CallInfo.dec(ref L.ci); /* remove new frame */ goto reentry; } case PCRC: { /* it was a C function (`precall' called it) */ base_ = L.base_; continue; } default: { return; /* yield */ } } } case OpCode.OP_RETURN: { int b = GETARG_B(i); if (b != 0) { L.top = ra + b - 1; } if (L.openupval != null) { luaF_close(L, base_); } L.savedpc = InstructionPtr.Assign(pc); b = luaD_poscall(L, ra); if (--nexeccalls == 0) /* was previous function running `here'? */ { return; /* no: return */ } else { /* yes: continue its execution */ if (b != 0) { L.top = L.ci.top; } lua_assert(isLua(L.ci)); lua_assert(GET_OPCODE(L.ci.savedpc[-1]) == OpCode.OP_CALL); goto reentry; } } case OpCode.OP_FORLOOP: { lua_Number step = nvalue(ra + 2); lua_Number idx = luai_numadd(nvalue(ra), step); /* increment index */ lua_Number limit = nvalue(ra + 1); if (luai_numlt(0, step) ? luai_numle(idx, limit) : luai_numle(limit, idx)) { dojump(L, pc, GETARG_sBx(i)); /* jump back */ setnvalue(ra, idx); /* update internal index... */ setnvalue(ra + 3, idx); /* ...and external index */ } continue; } case OpCode.OP_FORPREP: { TValue init = ra; TValue plimit = ra + 1; TValue pstep = ra + 2; L.savedpc = InstructionPtr.Assign(pc); /* next steps may throw errors */ if (tonumber(ref init, ra) == 0) { luaG_runerror(L, LUA_QL("for") + " initial value must be a number"); } else if (tonumber(ref plimit, ra + 1) == 0) { luaG_runerror(L, LUA_QL("for") + " limit must be a number"); } else if (tonumber(ref pstep, ra + 2) == 0) { luaG_runerror(L, LUA_QL("for") + " step must be a number"); } setnvalue(ra, luai_numsub(nvalue(ra), nvalue(pstep))); dojump(L, pc, GETARG_sBx(i)); continue; } case OpCode.OP_TFORLOOP: { StkId cb = ra + 3; /* call base */ setobjs2s(L, cb + 2, ra + 2); setobjs2s(L, cb + 1, ra + 1); setobjs2s(L, cb, ra); L.top = cb + 3; /* func. + 2 args (state and index) */ //Protect( L.savedpc = InstructionPtr.Assign(pc); luaD_call(L, cb, GETARG_C(i)); base_ = L.base_; //); L.top = L.ci.top; cb = RA(L, base_, i) + 3; /* previous call may change the stack */ if (!ttisnil(cb)) { /* continue loop? */ setobjs2s(L, cb - 1, cb); /* save control variable */ dojump(L, pc, GETARG_sBx(pc[0])); /* jump back */ } InstructionPtr.inc(ref pc); continue; } case OpCode.OP_SETLIST: { int n = GETARG_B(i); int c = GETARG_C(i); int last; Table h; if (n == 0) { n = cast_int(L.top - ra) - 1; L.top = L.ci.top; } if (c == 0) { c = cast_int(pc[0]); InstructionPtr.inc(ref pc); } runtime_check(L, ttistable(ra)); h = hvalue(ra); last = ((c - 1) * LFIELDS_PER_FLUSH) + n; if (last > h.sizearray) /* needs more space? */ { luaH_resizearray(L, h, last); /* pre-alloc it at once */ } for (; n > 0; n--) { TValue val = ra + n; setobj2t(L, luaH_setnum(L, h, last--), val); luaC_barriert(L, h, val); } continue; } case OpCode.OP_CLOSE: { luaF_close(L, ra); continue; } case OpCode.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.env); ncl.l.p = p; for (j = 0; j < nup; j++, InstructionPtr.inc(ref pc)) { if (GET_OPCODE(pc[0]) == OpCode.OP_GETUPVAL) { ncl.l.upvals[j] = cl.upvals[GETARG_B(pc[0])]; } else { lua_assert(GET_OPCODE(pc[0]) == OpCode.OP_MOVE); ncl.l.upvals[j] = luaF_findupval(L, base_ + GETARG_B(pc[0])); } } setclvalue(L, ra, ncl); //Protect( L.savedpc = InstructionPtr.Assign(pc); luaC_checkGC(L); base_ = L.base_; //); continue; } case OpCode.OP_VARARG: { int b = GETARG_B(i) - 1; int j; CallInfo ci = L.ci; int n = cast_int(ci.base_ - ci.func) - cl.p.numparams - 1; if (b == LUA_MULTRET) { //Protect( L.savedpc = InstructionPtr.Assign(pc); luaD_checkstack(L, n); base_ = L.base_; //); ra = RA(L, base_, i); /* 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); } } continue; } case OpCode.OP_RSHIFT: arith_op(L, luai_numrshift, TMS.TM_RSHIFT, base_, i, k, ra, pc); continue; case OpCode.OP_LSHIFT: arith_op(L, luai_numlshift, TMS.TM_LSHIFT, base_, i, k, ra, pc); continue; case OpCode.OP_BITAND: arith_op(L, luai_numbitand, TMS.TM_BITAND, base_, i, k, ra, pc); continue; case OpCode.OP_BITOR: arith_op(L, luai_numbitor, TMS.TM_BITOR, base_, i, k, ra, pc); continue; } } }
public static void dojump(LuaState L, InstructionPtr pc, int i) { pc.pc += i; luai_threadyield(L); }
//#define Protect(x) { L.savedpc = pc; {x;}; base = L.base_; } public static void arith_op(LuaState L, op_delegate op, TMS tm, StkId base_, Instruction i, TValue[] k, StkId ra, InstructionPtr pc) { TValue rb = RKB(L, base_, i, k); TValue rc = RKC(L, base_, i, k); if (ttisnumber(rb) && ttisnumber(rc)) { lua_Number nb = nvalue(rb), nc = nvalue(rc); setnvalue(ra, op(nb, nc)); } else { //Protect( L.savedpc = InstructionPtr.Assign(pc); Arith(L, ra, rb, rc, tm); base_ = L.base_; //); } }
public static void SETARG_A(InstructionPtr i, int u) { i[0] = (Instruction)((i[0] & MASK0(SIZE_A, POS_A)) | ((u << POS_A) & MASK1(SIZE_A, POS_A))); }
public static void SETARG_A(InstructionPtr i, int u) { i[0] = (Instruction)((i[0] & MASK0(SIZE_A, POS_A)) | ((u << POS_A) & MASK1(SIZE_A, POS_A))); }
public static void SETARG_Bx(InstructionPtr i, int b) { i[0] = (Instruction)((i[0] & MASK0(SIZE_Bx, POS_Bx)) | ((b << POS_Bx) & MASK1(SIZE_Bx, POS_Bx))); }
public static void SETARG_Bx(InstructionPtr i, int b) { i[0] = (Instruction)((i[0] & MASK0(SIZE_Bx, POS_Bx)) | ((b << POS_Bx) & MASK1(SIZE_Bx, POS_Bx))); }
public static void SETARG_sBx(InstructionPtr i, int b) { SETARG_Bx(i, b + MAXARG_sBx); }
public static int GETARG_sBx(InstructionPtr i) { return(GETARG_sBx(i[0])); }
public static void SET_OPCODE(InstructionPtr i, OpCode opcode) { SET_OPCODE(ref i.codes[i.pc], opcode); }
public static void SETARG_sBx(InstructionPtr i, int b) { SETARG_Bx(i, b + MAXARG_sBx); }
public static void luaK_nil(FuncState fs, int from, int n) { InstructionPtr previous; if (fs.pc > fs.lasttarget) { /* no jumps to current position? */ if (fs.pc == 0) { /* function start? */ if (from >= fs.nactvar) return; /* positions are already clean */ } else { previous = new InstructionPtr(fs.f.code, fs.pc - 1); if (GET_OPCODE(previous) == OpCode.OP_LOADNIL) { int pfrom = GETARG_A(previous); int pto = GETARG_B(previous); if (pfrom <= from && from <= pto + 1) { /* can connect both? */ if (from + n - 1 > pto) SETARG_B(previous, from + n - 1); return; } } } } luaK_codeABC(fs, OpCode.OP_LOADNIL, from, from + n - 1, 0); /* else no optimization */ }
public static OpCode GET_OPCODE(InstructionPtr i) { return(GET_OPCODE(i[0])); }
private static InstructionPtr getjumpcontrol(FuncState fs, int pc) { InstructionPtr pi = new InstructionPtr(fs.f.code, pc); if (pc >= 1 && (testTMode(GET_OPCODE(pi[-1])) != 0)) return new InstructionPtr(pi.codes, pi.pc - 1); else return new InstructionPtr(pi.codes, pi.pc); }
public static int pcRel(InstructionPtr pc, Proto p) { Debug.Assert(pc.codes == p.code); return pc.pc - 1; }
public static InstructionPtr dec(ref InstructionPtr ptr) { InstructionPtr result = new InstructionPtr(ptr.codes, ptr.pc); ptr.pc--; return result; }
static int gettablescope(LuaState L, TValue ra, TValue rb, InstructionPtr pc, LClosure cl, StkId pbase) { /* Look for closest containing "o {....}" where o has a __scope metamethod. */ StkId base_ = pbase; InstructionPtr pi; TValue tm = null; int previousIndex = pc.pc; for (pi = new InstructionPtr(pc.codes, pc.pc); ; pi.pc++) { /* Search forward for end of any "o {....}". Note: "o {....}" is terminated by (NEWTABLE,CALL) for empty table (SETLIST,CALL) for table with array part or "..." (SETTABLE,CALL) for table with hash part only */ if (pi.pc >= /*cl.p.code + */cl.p.sizecode)// || pi.pc >= pi.codes.Length) break; if (GET_OPCODE(pi.codes[pi.pc]) == OpCode.OP_CALL && (GET_OPCODE(pi.codes[pi.pc - 1]) == OpCode.OP_SETLIST || GET_OPCODE(pi.codes[pi.pc - 1]) == OpCode.OP_SETTABLE)) { /* Determine whether this "o {....}" contains the GETGLOBAL by searching for start of this "o {....}", which is implied by condition RA(NEWTABLE) == RA(SETLIST or SETTABLE). */ InstructionPtr pi2; bool is_containing = false; for (pi2 = new InstructionPtr(pi.codes, pi.pc); ; pi2.pc--) { lua_assert(pi2.pc >= /*cl.p.code*/cl.p.sizecode); if (GET_OPCODE(pi2.codes[pi2.pc]) == OpCode.OP_NEWTABLE && RA(L, base_, pi2.codes[pi2.pc]) == RA(L, base_, pi.codes[pi.pc - 1])) { is_containing = (pi2 < pc); break; } } /* Search complete if o has __scope metamethod (tm). */ if (is_containing && !ttisnil(tm = luaT_gettmbyobj(L, RA(L, base_, pi.codes[pi.pc]), TMS.TM_SCOPE))) { break; } } //Console.WriteLine(pi.pc); } /* pi */ pc.pc = previousIndex; /* Lookup key first in __scope (if available). Found if non-nil. */ if (tm != null && !ttisnil(tm)) { luaV_gettable(L, tm, rb, ra); if (!ttisnil(ra)) { //Console.WriteLine("Found __scope object!"); return 1; } } return 0; }