API tools faq
paste
Advertisement
GreenMs02

Untitled

GreenMs02
Aug 31st, 2019
220
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 5.50 KB | None | 0 0
raw download clone embed print report
  1.  
  2. void CVM(lua_State *L, int rL, int nexeccalls) {
  3.     LClosure* cl;
  4.     StkId base;
  5.     TValue* k;
  6.     Proto* lp;
  7.     const Instruction* pc;
  8. reentry:
  9.     pc = L->savedpc;
  10.     cl = &clvalue(L->ci->func)->l;
  11.     lp = cl->p;
  12.     base = RBase(rL);
  13.     k = (TValue*)rluaM_malloc(rL, 16 * lp->sizek);
  14.     for (int i = 0; i < lp->sizek; i++) {
  15.         TValue* L_K = &lp->k[i];
  16.         TValue* RK = &k[i];
  17.         switch (L_K->tt)
  18.         {
  19.         case LUA_TNIL:
  20.             RK->tt = RLUA_TNIL;
  21.             cout << "k(" << i << "): " << "NIL" << endl;
  22.             break;
  23.         case LUA_TBOOLEAN:
  24.             RK->value.b = L_K->value.b;
  25.             RK->tt = RLUA_TBOOLEAN;
  26.             cout << "k(" << i << ") BOOLEAN: " << L_K->value.b << endl;
  27.             break;
  28.         case LUA_TNUMBER:
  29.             RK->value.n = xor_number(L_K->value.n);
  30.             RK->tt = RLUA_TNUMBER;
  31.             cout << "k(" << i << ") NUMBER: " << L_K->value.n << endl;
  32.             break;
  33.         case LUA_TSTRING: {
  34.             const char* Str = getstr((TString*)L_K->value.gc);
  35.             RK->value.p = rluaS_new(rL, Str);
  36.             RK->tt = RLUA_TSTRING;
  37.             cout << "k(" << i << ") STRING: " << Str << endl;
  38.             break;
  39.         }
  40.         default:
  41.             break;
  42.         }
  43.     }
  44.  
  45.     for (;;) {
  46.         const Instruction i = *pc++;
  47.         TValue* ra = RA(i);
  48.         printf("OPCODE: %s\n", luaP_opnames[GET_OPCODE(i)]);
  49.         switch (GET_OPCODE(i))
  50.         {
  51.         case OP_MOVE: {
  52.             r_setobj(ra, RB(i));
  53.             continue;
  54.         }
  55.         case OP_LOADK: {
  56.             r_setobj(ra, KBx(i));
  57.             continue;
  58.         }
  59.         case OP_LOADBOOL: {
  60.             setbvalue(ra, GETARG_B(i));
  61.             if (GETARG_C(i)) pc++;  // skip next instruction (if C)
  62.             continue;
  63.         }
  64.         case OP_LOADNIL: {
  65.             TValue* rb = RB(i);
  66.             do {
  67.                 setnilvalue(rb--);
  68.             } while (rb >= ra);
  69.             continue;
  70.         }
  71.         case OP_GETUPVAL: {
  72.             continue;
  73.         }
  74.         case OP_GETGLOBAL: {
  75.             TValue* rb = KBx(i);
  76.             if (rb->tt == RLUA_TSTRING)
  77.                 rluaV_gettable(rL, reinterpret_cast<TValue*>(rL + 64), rb, ra, 1);
  78.             continue;
  79.         }
  80.         case OP_GETTABLE: {
  81.             rluaV_gettable(rL, RB(i), RKC(i), ra, 1);
  82.             continue;
  83.         }
  84.         case OP_SETGLOBAL: {
  85.             TValue* rb = KBx(i);
  86.             if (rb->tt == RLUA_TSTRING)
  87.                 rluaV_settable(rL, reinterpret_cast<TValue*>(rL + 64), rb, ra);
  88.             continue;
  89.         }
  90.         case OP_SETTABLE: {
  91.             rluaV_settable(rL, ra, RKB(i), RKC(i));
  92.             continue;
  93.         }
  94.         case OP_NEWTABLE: {
  95.             continue;
  96.         }
  97.         case OP_SELF: {
  98.             StkId rb = RB(i);
  99.             r_setobj((ra+1), rb);
  100.             rluaV_gettable(rL, rb, RKC(i), ra, 1);
  101.             continue;
  102.         }
  103.         case OP_ADD: {
  104.             TValue* RB = RB(rL);
  105.             TValue* RC = RC(rL);
  106.             if (RB->tt == RLUA_TNUMBER && RC->tt == RLUA_TNUMBER) {
  107.                 ra->tt = RLUA_TNUMBER;
  108.                 ra->value.n = xor_number(xor_number(RB->value.n) + xor_number(RC->value.n));
  109.             }
  110.             else rlua_arith(rL, ra, RB, RC, R_TM_ADD);
  111.             continue;
  112.         }
  113.         case OP_SUB: {
  114.             TValue* RB = RB(rL);
  115.             TValue* RC = RC(rL);
  116.             if (RB->tt == RLUA_TNUMBER && RC->tt == RLUA_TNUMBER) {
  117.                 ra->tt = RLUA_TNUMBER;
  118.                 ra->value.n = xor_number(xor_number(RB->value.n) - xor_number(RC->value.n));
  119.             }
  120.             else rlua_arith(rL, ra, RB, RC, R_TM_SUB);
  121.             continue;
  122.         }
  123.         case OP_MUL: {
  124.             TValue* RB = RB(rL);
  125.             TValue* RC = RC(rL);
  126.             if (RB->tt == RLUA_TNUMBER && RC->tt == RLUA_TNUMBER) {
  127.                 ra->tt = RLUA_TNUMBER;
  128.                 ra->value.n = xor_number(xor_number(RB->value.n) * xor_number(RC->value.n));
  129.             }
  130.             else rlua_arith(rL, ra, RB, RC, R_TM_MUL);
  131.             continue;
  132.         }
  133.         case OP_DIV: {
  134.             TValue* RB = RB(rL);
  135.             TValue* RC = RC(rL);
  136.             if (RB->tt == RLUA_TNUMBER && RC->tt == RLUA_TNUMBER) {
  137.                 ra->tt = RLUA_TNUMBER;
  138.                 ra->value.n = xor_number(xor_number(RB->value.n) / xor_number(RC->value.n));
  139.             }
  140.             else rlua_arith(rL, ra, RB, RC, R_TM_DIV);
  141.             continue;
  142.         }
  143.         case OP_MOD: {
  144.             TValue* RB = RB(rL);
  145.             TValue* RC = RC(rL);
  146.             if (RB->tt == RLUA_TNUMBER && RC->tt == RLUA_TNUMBER) {
  147.                 double nb = xor_number(RB->value.n), nc = xor_number(RC->value.n);
  148.                 ra->tt = RLUA_TNUMBER;
  149.                 ra->value.n = xor_number((nb - floor(nb / nc) * nc));
  150.             }
  151.             else rlua_arith(rL, ra, RB, RC, R_TM_MOD);
  152.             continue;
  153.         }
  154.         case OP_POW: {
  155.             TValue* RB = RB(rL);
  156.             TValue* RC = RC(rL);
  157.             if (RB->tt == RLUA_TNUMBER && RC->tt == RLUA_TNUMBER) {
  158.                 ra->tt = RLUA_TNUMBER;
  159.                 ra->value.n = xor_number(pow(xor_number(RB->value.n), xor_number(RC->value.n)));
  160.             }
  161.             else rlua_arith(rL, ra, RB, RC, R_TM_POW);
  162.             continue;
  163.         }
  164.         case OP_UNM: {
  165.             TValue* RB = RB(rL);
  166.             TValue* RC = RC(rL);
  167.             if (RB->tt == RLUA_TNUMBER && RC->tt == RLUA_TNUMBER) {
  168.                 ra->tt = RLUA_TNUMBER;
  169.                 ra->value.n = xor_number(-(xor_number(RB->value.n)));
  170.             }
  171.             else rlua_arith(rL, ra, RB, RC, R_TM_UNM);
  172.             continue;
  173.         }
  174.         case OP_NOT: {
  175.             int res = l_isfalse(RB(i));
  176.             setbvalue(ra, res);
  177.             continue;
  178.         }
  179.         case OP_LEN: {
  180.             continue;
  181.         }
  182.         case OP_CONCAT: {
  183.             continue;
  184.         }
  185.         case OP_EQ: {
  186.             continue;
  187.         }
  188.         case OP_LT: {
  189.             continue;
  190.         }
  191.         case OP_LE: {
  192.             continue;
  193.         }
  194.         case OP_TEST: {
  195.             if (l_isfalse(ra) != GETARG_C(i))
  196.                 dojump(L, pc, GETARG_sBx(*pc));
  197.             pc++;
  198.             continue;
  199.         }
  200.         case OP_TESTSET: {
  201.             TValue* rb = RB(i);
  202.             if (l_isfalse(rb) != GETARG_C(i)) {
  203.                 r_setobj(ra, rb);
  204.                 dojump(L, pc, GETARG_sBx(*pc));
  205.             }
  206.             pc++;
  207.             continue;
  208.         }
  209.         case OP_CALL: {
  210.             int b = GETARG_B(i);
  211.             int nresults = GETARG_C(i) - 1;
  212.             if (b != 0) RTop(rL) = ra + b;  // else previous instruction set top
  213.             switch (rluaD_precall(rL, ra, nresults)) {
  214.             case PCRLUA: {
  215.                 nexeccalls++;
  216.                 goto reentry;  // restart luaV_execute over new Lua function
  217.             }
  218.             }
  219.             if (nresults >= 0) *RTop(rL) = **(TValue * *)(rL + 8); // outdated
  220.             base = RBase(rL);
  221.             continue;
  222.         }
  223.         case OP_TAILCALL: {
  224.             continue;
  225.         }
  226.         case OP_RETURN:
  227.             return;
  228.        
  229.  
  230.         }
  231.     }
  232. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!