| 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 | |