1 /* 2 ** $Id: lvm.c,v 2.155 2013/03/16 21:10:18 roberto Exp $ 3 ** Lua virtual machine 4 ** See Copyright Notice in lua.h 5 */ 6 7 8 #include <stdio.h> 9 #include <stdlib.h> 10 #include <string.h> 11 12 #define lvm_c 13 #define LUA_CORE 14 15 #include "lua.h" 16 17 #include "ldebug.h" 18 #include "ldo.h" 19 #include "lfunc.h" 20 #include "lgc.h" 21 #include "lobject.h" 22 #include "lopcodes.h" 23 #include "lstate.h" 24 #include "lstring.h" 25 #include "ltable.h" 26 #include "ltm.h" 27 #include "lvm.h" 28 29 30 31 /* limit for table tag-method chains (to avoid loops) */ 32 #define MAXTAGLOOP 100 33 34 35 const TValue *luaV_tonumber (const TValue *obj, TValue *n) { 36 lua_Number num; 37 if (ttisnumber(obj)) return obj; 38 if (ttisstring(obj) && luaO_str2d(svalue(obj), tsvalue(obj)->len, &num)) { 39 setnvalue(n, num); 40 return n; 41 } 42 else 43 return NULL; 44 } 45 46 47 int luaV_tostring (lua_State *L, StkId obj) { 48 if (!ttisnumber(obj)) 49 return 0; 50 else { 51 char s[LUAI_MAXNUMBER2STR]; 52 lua_Number n = nvalue(obj); 53 int l = lua_number2str(s, n); 54 setsvalue2s(L, obj, luaS_newlstr(L, s, l)); 55 return 1; 56 } 57 } 58 59 60 static void traceexec (lua_State *L) { 61 CallInfo *ci = L->ci; 62 lu_byte mask = L->hookmask; 63 int counthook = ((mask & LUA_MASKCOUNT) && L->hookcount == 0); 64 if (counthook) 65 resethookcount(L); /* reset count */ 66 if (ci->callstatus & CIST_HOOKYIELD) { /* called hook last time? */ 67 ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */ 68 return; /* do not call hook again (VM yielded, so it did not move) */ 69 } 70 if (counthook) 71 luaD_hook(L, LUA_HOOKCOUNT, -1); /* call count hook */ 72 if (mask & LUA_MASKLINE) { 73 Proto *p = ci_func(ci)->p; 74 int npc = pcRel(ci->u.l.savedpc, p); 75 int newline = getfuncline(p, npc); 76 if (npc == 0 || /* call linehook when enter a new function, */ 77 ci->u.l.savedpc <= L->oldpc || /* when jump back (loop), or when */ 78 newline != getfuncline(p, pcRel(L->oldpc, p))) /* enter a new line */ 79 luaD_hook(L, LUA_HOOKLINE, newline); /* call line hook */ 80 } 81 L->oldpc = ci->u.l.savedpc; 82 if (L->status == LUA_YIELD) { /* did hook yield? */ 83 if (counthook) 84 L->hookcount = 1; /* undo decrement to zero */ 85 ci->u.l.savedpc--; /* undo increment (resume will increment it again) */ 86 ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */ 87 ci->func = L->top - 1; /* protect stack below results */ 88 luaD_throw(L, LUA_YIELD); 89 } 90 } 91 92 93 static void callTM (lua_State *L, const TValue *f, const TValue *p1, 94 const TValue *p2, TValue *p3, int hasres) { 95 ptrdiff_t result = savestack(L, p3); 96 setobj2s(L, L->top++, f); /* push function */ 97 setobj2s(L, L->top++, p1); /* 1st argument */ 98 setobj2s(L, L->top++, p2); /* 2nd argument */ 99 if (!hasres) /* no result? 'p3' is third argument */ 100 setobj2s(L, L->top++, p3); /* 3rd argument */ 101 /* metamethod may yield only when called from Lua code */ 102 luaD_call(L, L->top - (4 - hasres), hasres, isLua(L->ci)); 103 if (hasres) { /* if has result, move it to its place */ 104 p3 = restorestack(L, result); 105 setobjs2s(L, p3, --L->top); 106 } 107 } 108 109 110 void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) { 111 int loop; 112 for (loop = 0; loop < MAXTAGLOOP; loop++) { 113 const TValue *tm; 114 if (ttistable(t)) { /* `t' is a table? */ 115 Table *h = hvalue(t); 116 const TValue *res = luaH_get(h, key); /* do a primitive get */ 117 if (!ttisnil(res) || /* result is not nil? */ 118 (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */ 119 setobj2s(L, val, res); 120 return; 121 } 122 /* else will try the tag method */ 123 } 124 else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))) 125 luaG_typeerror(L, t, "index"); 126 if (ttisfunction(tm)) { 127 callTM(L, tm, t, key, val, 1); 128 return; 129 } 130 t = tm; /* else repeat with 'tm' */ 131 } 132 luaG_runerror(L, "loop in gettable"); 133 } 134 135 136 void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) { 137 int loop; 138 for (loop = 0; loop < MAXTAGLOOP; loop++) { 139 const TValue *tm; 140 if (ttistable(t)) { /* `t' is a table? */ 141 Table *h = hvalue(t); 142 TValue *oldval = cast(TValue *, luaH_get(h, key)); 143 /* if previous value is not nil, there must be a previous entry 144 in the table; moreover, a metamethod has no relevance */ 145 if (!ttisnil(oldval) || 146 /* previous value is nil; must check the metamethod */ 147 ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL && 148 /* no metamethod; is there a previous entry in the table? */ 149 (oldval != luaO_nilobject || 150 /* no previous entry; must create one. (The next test is 151 always true; we only need the assignment.) */ 152 (oldval = luaH_newkey(L, h, key), 1)))) { 153 /* no metamethod and (now) there is an entry with given key */ 154 setobj2t(L, oldval, val); /* assign new value to that entry */ 155 invalidateTMcache(h); 156 luaC_barrierback(L, obj2gco(h), val); 157 return; 158 } 159 /* else will try the metamethod */ 160 } 161 else /* not a table; check metamethod */ 162 if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))) 163 luaG_typeerror(L, t, "index"); 164 /* there is a metamethod */ 165 if (ttisfunction(tm)) { 166 callTM(L, tm, t, key, val, 0); 167 return; 168 } 169 t = tm; /* else repeat with 'tm' */ 170 } 171 luaG_runerror(L, "loop in settable"); 172 } 173 174 175 static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2, 176 StkId res, TMS event) { 177 const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */ 178 if (ttisnil(tm)) 179 tm = luaT_gettmbyobj(L, p2, event); /* try second operand */ 180 if (ttisnil(tm)) return 0; 181 callTM(L, tm, p1, p2, res, 1); 182 return 1; 183 } 184 185 186 static const TValue *get_equalTM (lua_State *L, Table *mt1, Table *mt2, 187 TMS event) { 188 const TValue *tm1 = fasttm(L, mt1, event); 189 const TValue *tm2; 190 if (tm1 == NULL) return NULL; /* no metamethod */ 191 if (mt1 == mt2) return tm1; /* same metatables => same metamethods */ 192 tm2 = fasttm(L, mt2, event); 193 if (tm2 == NULL) return NULL; /* no metamethod */ 194 if (luaV_rawequalobj(tm1, tm2)) /* same metamethods? */ 195 return tm1; 196 return NULL; 197 } 198 199 200 static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2, 201 TMS event) { 202 if (!call_binTM(L, p1, p2, L->top, event)) 203 return -1; /* no metamethod */ 204 else 205 return !l_isfalse(L->top); 206 } 207 208 209 static int l_strcmp (const TString *ls, const TString *rs) { 210 const char *l = getstr(ls); 211 size_t ll = ls->tsv.len; 212 const char *r = getstr(rs); 213 size_t lr = rs->tsv.len; 214 for (;;) { 215 int temp = strcoll(l, r); 216 if (temp != 0) return temp; 217 else { /* strings are equal up to a `\0' */ 218 size_t len = strlen(l); /* index of first `\0' in both strings */ 219 if (len == lr) /* r is finished? */ 220 return (len == ll) ? 0 : 1; 221 else if (len == ll) /* l is finished? */ 222 return -1; /* l is smaller than r (because r is not finished) */ 223 /* both strings longer than `len'; go on comparing (after the `\0') */ 224 len++; 225 l += len; ll -= len; r += len; lr -= len; 226 } 227 } 228 } 229 230 231 int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) { 232 int res; 233 if (ttisnumber(l) && ttisnumber(r)) 234 return luai_numlt(L, nvalue(l), nvalue(r)); 235 else if (ttisstring(l) && ttisstring(r)) 236 return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0; 237 else if ((res = call_orderTM(L, l, r, TM_LT)) < 0) 238 luaG_ordererror(L, l, r); 239 return res; 240 } 241 242 243 int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) { 244 int res; 245 if (ttisnumber(l) && ttisnumber(r)) 246 return luai_numle(L, nvalue(l), nvalue(r)); 247 else if (ttisstring(l) && ttisstring(r)) 248 return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0; 249 else if ((res = call_orderTM(L, l, r, TM_LE)) >= 0) /* first try `le' */ 250 return res; 251 else if ((res = call_orderTM(L, r, l, TM_LT)) < 0) /* else try `lt' */ 252 luaG_ordererror(L, l, r); 253 return !res; 254 } 255 256 257 /* 258 ** equality of Lua values. L == NULL means raw equality (no metamethods) 259 */ 260 int luaV_equalobj_ (lua_State *L, const TValue *t1, const TValue *t2) { 261 const TValue *tm; 262 lua_assert(ttisequal(t1, t2)); 263 switch (ttype(t1)) { 264 case LUA_TNIL: return 1; 265 case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2)); 266 case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */ 267 case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); 268 case LUA_TLCF: return fvalue(t1) == fvalue(t2); 269 case LUA_TSHRSTR: return eqshrstr(rawtsvalue(t1), rawtsvalue(t2)); 270 case LUA_TLNGSTR: return luaS_eqlngstr(rawtsvalue(t1), rawtsvalue(t2)); 271 case LUA_TUSERDATA: { 272 if (uvalue(t1) == uvalue(t2)) return 1; 273 else if (L == NULL) return 0; 274 tm = get_equalTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable, TM_EQ); 275 break; /* will try TM */ 276 } 277 case LUA_TTABLE: { 278 if (hvalue(t1) == hvalue(t2)) return 1; 279 else if (L == NULL) return 0; 280 tm = get_equalTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ); 281 break; /* will try TM */ 282 } 283 default: 284 lua_assert(iscollectable(t1)); 285 return gcvalue(t1) == gcvalue(t2); 286 } 287 if (tm == NULL) return 0; /* no TM? */ 288 callTM(L, tm, t1, t2, L->top, 1); /* call TM */ 289 return !l_isfalse(L->top); 290 } 291 292 293 void luaV_concat (lua_State *L, int total) { 294 lua_assert(total >= 2); 295 do { 296 StkId top = L->top; 297 int n = 2; /* number of elements handled in this pass (at least 2) */ 298 if (!(ttisstring(top-2) || ttisnumber(top-2)) || !tostring(L, top-1)) { 299 if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT)) 300 luaG_concaterror(L, top-2, top-1); 301 } 302 else if (tsvalue(top-1)->len == 0) /* second operand is empty? */ 303 (void)tostring(L, top - 2); /* result is first operand */ 304 else if (ttisstring(top-2) && tsvalue(top-2)->len == 0) { 305 setobjs2s(L, top - 2, top - 1); /* result is second op. */ 306 } 307 else { 308 /* at least two non-empty string values; get as many as possible */ 309 size_t tl = tsvalue(top-1)->len; 310 char *buffer; 311 int i; 312 /* collect total length */ 313 for (i = 1; i < total && tostring(L, top-i-1); i++) { 314 size_t l = tsvalue(top-i-1)->len; 315 if (l >= (MAX_SIZET/sizeof(char)) - tl) 316 luaG_runerror(L, "string length overflow"); 317 tl += l; 318 } 319 buffer = luaZ_openspace(L, &G(L)->buff, tl); 320 tl = 0; 321 n = i; 322 do { /* concat all strings */ 323 size_t l = tsvalue(top-i)->len; 324 memcpy(buffer+tl, svalue(top-i), l * sizeof(char)); 325 tl += l; 326 } while (--i > 0); 327 setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl)); 328 } 329 total -= n-1; /* got 'n' strings to create 1 new */ 330 L->top -= n-1; /* popped 'n' strings and pushed one */ 331 } while (total > 1); /* repeat until only 1 result left */ 332 } 333 334 335 void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) { 336 const TValue *tm; 337 switch (ttypenv(rb)) { 338 case LUA_TTABLE: { 339 Table *h = hvalue(rb); 340 tm = fasttm(L, h->metatable, TM_LEN); 341 if (tm) break; /* metamethod? break switch to call it */ 342 setnvalue(ra, cast_num(luaH_getn(h))); /* else primitive len */ 343 return; 344 } 345 case LUA_TSTRING: { 346 setnvalue(ra, cast_num(tsvalue(rb)->len)); 347 return; 348 } 349 default: { /* try metamethod */ 350 tm = luaT_gettmbyobj(L, rb, TM_LEN); 351 if (ttisnil(tm)) /* no metamethod? */ 352 luaG_typeerror(L, rb, "get length of"); 353 break; 354 } 355 } 356 callTM(L, tm, rb, rb, ra, 1); 357 } 358 359 360 void luaV_arith (lua_State *L, StkId ra, const TValue *rb, 361 const TValue *rc, TMS op) { 362 TValue tempb, tempc; 363 const TValue *b, *c; 364 if ((b = luaV_tonumber(rb, &tempb)) != NULL && 365 (c = luaV_tonumber(rc, &tempc)) != NULL) { 366 lua_Number res = luaO_arith(op - TM_ADD + LUA_OPADD, nvalue(b), nvalue(c)); 367 setnvalue(ra, res); 368 } 369 else if (!call_binTM(L, rb, rc, ra, op)) 370 luaG_aritherror(L, rb, rc); 371 } 372 373 374 /* 375 ** check whether cached closure in prototype 'p' may be reused, that is, 376 ** whether there is a cached closure with the same upvalues needed by 377 ** new closure to be created. 378 */ 379 static Closure *getcached (Proto *p, UpVal **encup, StkId base) { 380 Closure *c = p->cache; 381 if (c != NULL) { /* is there a cached closure? */ 382 int nup = p->sizeupvalues; 383 Upvaldesc *uv = p->upvalues; 384 int i; 385 for (i = 0; i < nup; i++) { /* check whether it has right upvalues */ 386 TValue *v = uv[i].instack ? base + uv[i].idx : encup[uv[i].idx]->v; 387 if (c->l.upvals[i]->v != v) 388 return NULL; /* wrong upvalue; cannot reuse closure */ 389 } 390 } 391 return c; /* return cached closure (or NULL if no cached closure) */ 392 } 393 394 395 /* 396 ** create a new Lua closure, push it in the stack, and initialize 397 ** its upvalues. Note that the call to 'luaC_barrierproto' must come 398 ** before the assignment to 'p->cache', as the function needs the 399 ** original value of that field. 400 */ 401 static void pushclosure (lua_State *L, Proto *p, UpVal **encup, StkId base, 402 StkId ra) { 403 int nup = p->sizeupvalues; 404 Upvaldesc *uv = p->upvalues; 405 int i; 406 Closure *ncl = luaF_newLclosure(L, nup); 407 ncl->l.p = p; 408 setclLvalue(L, ra, ncl); /* anchor new closure in stack */ 409 for (i = 0; i < nup; i++) { /* fill in its upvalues */ 410 if (uv[i].instack) /* upvalue refers to local variable? */ 411 ncl->l.upvals[i] = luaF_findupval(L, base + uv[i].idx); 412 else /* get upvalue from enclosing function */ 413 ncl->l.upvals[i] = encup[uv[i].idx]; 414 } 415 luaC_barrierproto(L, p, ncl); 416 p->cache = ncl; /* save it on cache for reuse */ 417 } 418 419 420 /* 421 ** finish execution of an opcode interrupted by an yield 422 */ 423 void luaV_finishOp (lua_State *L) { 424 CallInfo *ci = L->ci; 425 StkId base = ci->u.l.base; 426 Instruction inst = *(ci->u.l.savedpc - 1); /* interrupted instruction */ 427 OpCode op = GET_OPCODE(inst); 428 switch (op) { /* finish its execution */ 429 case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: 430 case OP_MOD: case OP_POW: case OP_UNM: case OP_LEN: 431 case OP_GETTABUP: case OP_GETTABLE: case OP_SELF: { 432 setobjs2s(L, base + GETARG_A(inst), --L->top); 433 break; 434 } 435 case OP_LE: case OP_LT: case OP_EQ: { 436 int res = !l_isfalse(L->top - 1); 437 L->top--; 438 /* metamethod should not be called when operand is K */ 439 lua_assert(!ISK(GETARG_B(inst))); 440 if (op == OP_LE && /* "<=" using "<" instead? */ 441 ttisnil(luaT_gettmbyobj(L, base + GETARG_B(inst), TM_LE))) 442 res = !res; /* invert result */ 443 lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_JMP); 444 if (res != GETARG_A(inst)) /* condition failed? */ 445 ci->u.l.savedpc++; /* skip jump instruction */ 446 break; 447 } 448 case OP_CONCAT: { 449 StkId top = L->top - 1; /* top when 'call_binTM' was called */ 450 int b = GETARG_B(inst); /* first element to concatenate */ 451 int total = cast_int(top - 1 - (base + b)); /* yet to concatenate */ 452 setobj2s(L, top - 2, top); /* put TM result in proper position */ 453 if (total > 1) { /* are there elements to concat? */ 454 L->top = top - 1; /* top is one after last element (at top-2) */ 455 luaV_concat(L, total); /* concat them (may yield again) */ 456 } 457 /* move final result to final position */ 458 setobj2s(L, ci->u.l.base + GETARG_A(inst), L->top - 1); 459 L->top = ci->top; /* restore top */ 460 break; 461 } 462 case OP_TFORCALL: { 463 lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_TFORLOOP); 464 L->top = ci->top; /* correct top */ 465 break; 466 } 467 case OP_CALL: { 468 if (GETARG_C(inst) - 1 >= 0) /* nresults >= 0? */ 469 L->top = ci->top; /* adjust results */ 470 break; 471 } 472 case OP_TAILCALL: case OP_SETTABUP: case OP_SETTABLE: 473 break; 474 default: lua_assert(0); 475 } 476 } 477 478 479 480 /* 481 ** some macros for common tasks in `luaV_execute' 482 */ 483 484 #if !defined luai_runtimecheck 485 #define luai_runtimecheck(L, c) /* void */ 486 #endif 487 488 489 #define RA(i) (base+GETARG_A(i)) 490 /* to be used after possible stack reallocation */ 491 #define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i)) 492 #define RC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i)) 493 #define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \ 494 ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i)) 495 #define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \ 496 ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i)) 497 #define KBx(i) \ 498 (k + (GETARG_Bx(i) != 0 ? GETARG_Bx(i) - 1 : GETARG_Ax(*ci->u.l.savedpc++))) 499 500 501 /* execute a jump instruction */ 502 #define dojump(ci,i,e) \ 503 { int a = GETARG_A(i); \ 504 if (a > 0) luaF_close(L, ci->u.l.base + a - 1); \ 505 ci->u.l.savedpc += GETARG_sBx(i) + e; } 506 507 /* for test instructions, execute the jump instruction that follows it */ 508 #define donextjump(ci) { i = *ci->u.l.savedpc; dojump(ci, i, 1); } 509 510 511 #define Protect(x) { {x;}; base = ci->u.l.base; } 512 513 #define checkGC(L,c) \ 514 Protect( luaC_condGC(L,{L->top = (c); /* limit of live values */ \ 515 luaC_step(L); \ 516 L->top = ci->top;}) /* restore top */ \ 517 luai_threadyield(L); ) 518 519 520 #define arith_op(op,tm) { \ 521 TValue *rb = RKB(i); \ 522 TValue *rc = RKC(i); \ 523 if (ttisnumber(rb) && ttisnumber(rc)) { \ 524 lua_Number nb = nvalue(rb), nc = nvalue(rc); \ 525 setnvalue(ra, op(L, nb, nc)); \ 526 } \ 527 else { Protect(luaV_arith(L, ra, rb, rc, tm)); } } 528 529 530 #define vmdispatch(o) switch(o) 531 #define vmcase(l,b) case l: {b} break; 532 #define vmcasenb(l,b) case l: {b} /* nb = no break */ 533 534 void luaV_execute (lua_State *L) { 535 CallInfo *ci = L->ci; 536 LClosure *cl; 537 TValue *k; 538 StkId base; 539 newframe: /* reentry point when frame changes (call/return) */ 540 lua_assert(ci == L->ci); 541 cl = clLvalue(ci->func); 542 k = cl->p->k; 543 base = ci->u.l.base; 544 /* main loop of interpreter */ 545 for (;;) { 546 Instruction i = *(ci->u.l.savedpc++); 547 StkId ra; 548 if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) && 549 (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) { 550 Protect(traceexec(L)); 551 } 552 /* WARNING: several calls may realloc the stack and invalidate `ra' */ 553 ra = RA(i); 554 lua_assert(base == ci->u.l.base); 555 lua_assert(base <= L->top && L->top < L->stack + L->stacksize); 556 vmdispatch (GET_OPCODE(i)) { 557 vmcase(OP_MOVE, 558 setobjs2s(L, ra, RB(i)); 559 ) 560 vmcase(OP_LOADK, 561 TValue *rb = k + GETARG_Bx(i); 562 setobj2s(L, ra, rb); 563 ) 564 vmcase(OP_LOADKX, 565 TValue *rb; 566 lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG); 567 rb = k + GETARG_Ax(*ci->u.l.savedpc++); 568 setobj2s(L, ra, rb); 569 ) 570 vmcase(OP_LOADBOOL, 571 setbvalue(ra, GETARG_B(i)); 572 if (GETARG_C(i)) ci->u.l.savedpc++; /* skip next instruction (if C) */ 573 ) 574 vmcase(OP_LOADNIL, 575 int b = GETARG_B(i); 576 do { 577 setnilvalue(ra++); 578 } while (b--); 579 ) 580 vmcase(OP_GETUPVAL, 581 int b = GETARG_B(i); 582 setobj2s(L, ra, cl->upvals[b]->v); 583 ) 584 vmcase(OP_GETTABUP, 585 int b = GETARG_B(i); 586 Protect(luaV_gettable(L, cl->upvals[b]->v, RKC(i), ra)); 587 ) 588 vmcase(OP_GETTABLE, 589 Protect(luaV_gettable(L, RB(i), RKC(i), ra)); 590 ) 591 vmcase(OP_SETTABUP, 592 int a = GETARG_A(i); 593 Protect(luaV_settable(L, cl->upvals[a]->v, RKB(i), RKC(i))); 594 ) 595 vmcase(OP_SETUPVAL, 596 UpVal *uv = cl->upvals[GETARG_B(i)]; 597 setobj(L, uv->v, ra); 598 luaC_barrier(L, uv, ra); 599 ) 600 vmcase(OP_SETTABLE, 601 Protect(luaV_settable(L, ra, RKB(i), RKC(i))); 602 ) 603 vmcase(OP_NEWTABLE, 604 int b = GETARG_B(i); 605 int c = GETARG_C(i); 606 Table *t = luaH_new(L); 607 sethvalue(L, ra, t); 608 if (b != 0 || c != 0) 609 luaH_resize(L, t, luaO_fb2int(b), luaO_fb2int(c)); 610 checkGC(L, ra + 1); 611 ) 612 vmcase(OP_SELF, 613 StkId rb = RB(i); 614 setobjs2s(L, ra+1, rb); 615 Protect(luaV_gettable(L, rb, RKC(i), ra)); 616 ) 617 vmcase(OP_ADD, 618 arith_op(luai_numadd, TM_ADD); 619 ) 620 vmcase(OP_SUB, 621 arith_op(luai_numsub, TM_SUB); 622 ) 623 vmcase(OP_MUL, 624 arith_op(luai_nummul, TM_MUL); 625 ) 626 vmcase(OP_DIV, 627 arith_op(luai_numdiv, TM_DIV); 628 ) 629 vmcase(OP_MOD, 630 arith_op(luai_nummod, TM_MOD); 631 ) 632 vmcase(OP_POW, 633 arith_op(luai_numpow, TM_POW); 634 ) 635 vmcase(OP_UNM, 636 TValue *rb = RB(i); 637 if (ttisnumber(rb)) { 638 lua_Number nb = nvalue(rb); 639 setnvalue(ra, luai_numunm(L, nb)); 640 } 641 else { 642 Protect(luaV_arith(L, ra, rb, rb, TM_UNM)); 643 } 644 ) 645 vmcase(OP_NOT, 646 TValue *rb = RB(i); 647 int res = l_isfalse(rb); /* next assignment may change this value */ 648 setbvalue(ra, res); 649 ) 650 vmcase(OP_LEN, 651 Protect(luaV_objlen(L, ra, RB(i))); 652 ) 653 vmcase(OP_CONCAT, 654 int b = GETARG_B(i); 655 int c = GETARG_C(i); 656 StkId rb; 657 L->top = base + c + 1; /* mark the end of concat operands */ 658 Protect(luaV_concat(L, c - b + 1)); 659 ra = RA(i); /* 'luav_concat' may invoke TMs and move the stack */ 660 rb = b + base; 661 setobjs2s(L, ra, rb); 662 checkGC(L, (ra >= rb ? ra + 1 : rb)); 663 L->top = ci->top; /* restore top */ 664 ) 665 vmcase(OP_JMP, 666 dojump(ci, i, 0); 667 ) 668 vmcase(OP_EQ, 669 TValue *rb = RKB(i); 670 TValue *rc = RKC(i); 671 Protect( 672 if (cast_int(equalobj(L, rb, rc)) != GETARG_A(i)) 673 ci->u.l.savedpc++; 674 else 675 donextjump(ci); 676 ) 677 ) 678 vmcase(OP_LT, 679 Protect( 680 if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i)) 681 ci->u.l.savedpc++; 682 else 683 donextjump(ci); 684 ) 685 ) 686 vmcase(OP_LE, 687 Protect( 688 if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) 689 ci->u.l.savedpc++; 690 else 691 donextjump(ci); 692 ) 693 ) 694 vmcase(OP_TEST, 695 if (GETARG_C(i) ? l_isfalse(ra) : !l_isfalse(ra)) 696 ci->u.l.savedpc++; 697 else 698 donextjump(ci); 699 ) 700 vmcase(OP_TESTSET, 701 TValue *rb = RB(i); 702 if (GETARG_C(i) ? l_isfalse(rb) : !l_isfalse(rb)) 703 ci->u.l.savedpc++; 704 else { 705 setobjs2s(L, ra, rb); 706 donextjump(ci); 707 } 708 ) 709 vmcase(OP_CALL, 710 int b = GETARG_B(i); 711 int nresults = GETARG_C(i) - 1; 712 if (b != 0) L->top = ra+b; /* else previous instruction set top */ 713 if (luaD_precall(L, ra, nresults)) { /* C function? */ 714 if (nresults >= 0) L->top = ci->top; /* adjust results */ 715 base = ci->u.l.base; 716 } 717 else { /* Lua function */ 718 ci = L->ci; 719 ci->callstatus |= CIST_REENTRY; 720 goto newframe; /* restart luaV_execute over new Lua function */ 721 } 722 ) 723 vmcase(OP_TAILCALL, 724 int b = GETARG_B(i); 725 if (b != 0) L->top = ra+b; /* else previous instruction set top */ 726 lua_assert(GETARG_C(i) - 1 == LUA_MULTRET); 727 if (luaD_precall(L, ra, LUA_MULTRET)) /* C function? */ 728 base = ci->u.l.base; 729 else { 730 /* tail call: put called frame (n) in place of caller one (o) */ 731 CallInfo *nci = L->ci; /* called frame */ 732 CallInfo *oci = nci->previous; /* caller frame */ 733 StkId nfunc = nci->func; /* called function */ 734 StkId ofunc = oci->func; /* caller function */ 735 /* last stack slot filled by 'precall' */ 736 StkId lim = nci->u.l.base + getproto(nfunc)->numparams; 737 int aux; 738 /* close all upvalues from previous call */ 739 if (cl->p->sizep > 0) luaF_close(L, oci->u.l.base); 740 /* move new frame into old one */ 741 for (aux = 0; nfunc + aux < lim; aux++) 742 setobjs2s(L, ofunc + aux, nfunc + aux); 743 oci->u.l.base = ofunc + (nci->u.l.base - nfunc); /* correct base */ 744 oci->top = L->top = ofunc + (L->top - nfunc); /* correct top */ 745 oci->u.l.savedpc = nci->u.l.savedpc; 746 oci->callstatus |= CIST_TAIL; /* function was tail called */ 747 ci = L->ci = oci; /* remove new frame */ 748 lua_assert(L->top == oci->u.l.base + getproto(ofunc)->maxstacksize); 749 goto newframe; /* restart luaV_execute over new Lua function */ 750 } 751 ) 752 vmcasenb(OP_RETURN, 753 int b = GETARG_B(i); 754 if (b != 0) L->top = ra+b-1; 755 if (cl->p->sizep > 0) luaF_close(L, base); 756 b = luaD_poscall(L, ra); 757 if (!(ci->callstatus & CIST_REENTRY)) /* 'ci' still the called one */ 758 return; /* external invocation: return */ 759 else { /* invocation via reentry: continue execution */ 760 ci = L->ci; 761 if (b) L->top = ci->top; 762 lua_assert(isLua(ci)); 763 lua_assert(GET_OPCODE(*((ci)->u.l.savedpc - 1)) == OP_CALL); 764 goto newframe; /* restart luaV_execute over new Lua function */ 765 } 766 ) 767 vmcase(OP_FORLOOP, 768 lua_Number step = nvalue(ra+2); 769 lua_Number idx = luai_numadd(L, nvalue(ra), step); /* increment index */ 770 lua_Number limit = nvalue(ra+1); 771 if (luai_numlt(L, 0, step) ? luai_numle(L, idx, limit) 772 : luai_numle(L, limit, idx)) { 773 ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ 774 setnvalue(ra, idx); /* update internal index... */ 775 setnvalue(ra+3, idx); /* ...and external index */ 776 } 777 ) 778 vmcase(OP_FORPREP, 779 const TValue *init = ra; 780 const TValue *plimit = ra+1; 781 const TValue *pstep = ra+2; 782 if (!tonumber(init, ra)) 783 luaG_runerror(L, LUA_QL("for") " initial value must be a number"); 784 else if (!tonumber(plimit, ra+1)) 785 luaG_runerror(L, LUA_QL("for") " limit must be a number"); 786 else if (!tonumber(pstep, ra+2)) 787 luaG_runerror(L, LUA_QL("for") " step must be a number"); 788 setnvalue(ra, luai_numsub(L, nvalue(ra), nvalue(pstep))); 789 ci->u.l.savedpc += GETARG_sBx(i); 790 ) 791 vmcasenb(OP_TFORCALL, 792 StkId cb = ra + 3; /* call base */ 793 setobjs2s(L, cb+2, ra+2); 794 setobjs2s(L, cb+1, ra+1); 795 setobjs2s(L, cb, ra); 796 L->top = cb + 3; /* func. + 2 args (state and index) */ 797 Protect(luaD_call(L, cb, GETARG_C(i), 1)); 798 L->top = ci->top; 799 i = *(ci->u.l.savedpc++); /* go to next instruction */ 800 ra = RA(i); 801 lua_assert(GET_OPCODE(i) == OP_TFORLOOP); 802 goto l_tforloop; 803 ) 804 vmcase(OP_TFORLOOP, 805 l_tforloop: 806 if (!ttisnil(ra + 1)) { /* continue loop? */ 807 setobjs2s(L, ra, ra + 1); /* save control variable */ 808 ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ 809 } 810 ) 811 vmcase(OP_SETLIST, 812 int n = GETARG_B(i); 813 int c = GETARG_C(i); 814 int last; 815 Table *h; 816 if (n == 0) n = cast_int(L->top - ra) - 1; 817 if (c == 0) { 818 lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG); 819 c = GETARG_Ax(*ci->u.l.savedpc++); 820 } 821 luai_runtimecheck(L, ttistable(ra)); 822 h = hvalue(ra); 823 last = ((c-1)*LFIELDS_PER_FLUSH) + n; 824 if (last > h->sizearray) /* needs more space? */ 825 luaH_resizearray(L, h, last); /* pre-allocate it at once */ 826 for (; n > 0; n--) { 827 TValue *val = ra+n; 828 luaH_setint(L, h, last--, val); 829 luaC_barrierback(L, obj2gco(h), val); 830 } 831 L->top = ci->top; /* correct top (in case of previous open call) */ 832 ) 833 vmcase(OP_CLOSURE, 834 Proto *p = cl->p->p[GETARG_Bx(i)]; 835 Closure *ncl = getcached(p, cl->upvals, base); /* cached closure */ 836 if (ncl == NULL) /* no match? */ 837 pushclosure(L, p, cl->upvals, base, ra); /* create a new one */ 838 else 839 setclLvalue(L, ra, ncl); /* push cashed closure */ 840 checkGC(L, ra + 1); 841 ) 842 vmcase(OP_VARARG, 843 int b = GETARG_B(i) - 1; 844 int j; 845 int n = cast_int(base - ci->func) - cl->p->numparams - 1; 846 if (b < 0) { /* B == 0? */ 847 b = n; /* get all var. arguments */ 848 Protect(luaD_checkstack(L, n)); 849 ra = RA(i); /* previous call may change the stack */ 850 L->top = ra + n; 851 } 852 for (j = 0; j < b; j++) { 853 if (j < n) { 854 setobjs2s(L, ra + j, base - n + j); 855 } 856 else { 857 setnilvalue(ra + j); 858 } 859 } 860 ) 861 vmcase(OP_EXTRAARG, 862 lua_assert(0); 863 ) 864 } 865 } 866 } 867 868
