| /* |
| ** $Id: lvm.c,v 2.223 2014/09/04 18:15:29 roberto Exp roberto $ |
| ** Lua virtual machine |
| ** See Copyright Notice in lua.h |
| */ |
| |
| |
| #include <limits.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #define lvm_c |
| #define LUA_CORE |
| |
| #include "lua.h" |
| |
| #include "ldebug.h" |
| #include "ldo.h" |
| #include "lfunc.h" |
| #include "lgc.h" |
| #include "lobject.h" |
| #include "lopcodes.h" |
| #include "lstate.h" |
| #include "lstring.h" |
| #include "ltable.h" |
| #include "ltm.h" |
| #include "lvm.h" |
| |
| |
| |
| /* limit for table tag-method chains (to avoid loops) */ |
| #define MAXTAGLOOP 2000 |
| |
| |
| /* |
| ** Similar to 'tonumber', but does not attempt to convert strings and |
| ** ensure correct precision (no extra bits). Used in comparisons. |
| */ |
| static int tofloat (const TValue *obj, lua_Number *n) { |
| if (ttisfloat(obj)) *n = fltvalue(obj); |
| else if (ttisinteger(obj)) { |
| volatile lua_Number x = cast_num(ivalue(obj)); /* avoid extra precision */ |
| *n = x; |
| } |
| else { |
| *n = 0; /* to avoid warnings */ |
| return 0; |
| } |
| return 1; |
| } |
| |
| |
| /* |
| ** Try to convert a value to a float. Check 'isinteger' first, because |
| ** in general the float case is already handled by the macro 'tonumber'. |
| */ |
| int luaV_tonumber_ (const TValue *obj, lua_Number *n) { |
| TValue v; |
| again: |
| if (ttisinteger(obj)) { |
| *n = cast_num(ivalue(obj)); |
| return 1; |
| } |
| else if (ttisfloat(obj)) { |
| *n = fltvalue(obj); |
| return 1; |
| } |
| else if (cvt2num(obj) && /* string convertible to number? */ |
| luaO_str2num(svalue(obj), &v) == tsvalue(obj)->len + 1) { |
| obj = &v; |
| goto again; /* convert result from 'luaO_str2num' to a float */ |
| } |
| return 0; /* conversion failed */ |
| } |
| |
| |
| /* |
| ** try to convert a value to an integer, rounding according to 'mode': |
| ** mode == 0: accepts only integral values |
| ** mode < 0: takes the floor of the number |
| ** mode > 0: takes the ceil of the number |
| */ |
| static int tointeger_aux (const TValue *obj, lua_Integer *p, int mode) { |
| TValue v; |
| again: |
| if (ttisfloat(obj)) { |
| lua_Number n = fltvalue(obj); |
| lua_Number f = l_floor(n); |
| if (n != f) { /* not an integral value? */ |
| if (mode == 0) return 0; /* fails if mode demands integral value */ |
| else if (mode > 0) /* needs ceil? */ |
| f += 1; /* convert floor to ceil (remember: n != f) */ |
| } |
| return lua_numtointeger(f, p); |
| } |
| else if (ttisinteger(obj)) { |
| *p = ivalue(obj); |
| return 1; |
| } |
| else if (cvt2num(obj) && |
| luaO_str2num(svalue(obj), &v) == tsvalue(obj)->len + 1) { |
| obj = &v; |
| goto again; /* convert result from 'luaO_str2num' to an integer */ |
| } |
| return 0; /* conversion failed */ |
| } |
| |
| |
| /* |
| ** try to convert a value to an integer |
| */ |
| int luaV_tointeger_ (const TValue *obj, lua_Integer *p) { |
| return tointeger_aux(obj, p, 0); |
| } |
| |
| |
| /* |
| ** Try to convert a 'for' limit to an integer, preserving the |
| ** semantics of the loop. |
| ** (The following explanation assumes a non-negative step; it is valid |
| ** for negative steps mutatis mutandis.) |
| ** If the limit can be converted to an integer, rounding down, that is |
| ** it. |
| ** Otherwise, check whether the limit can be converted to a number. If |
| ** the number is too large, it is OK to set the limit as LUA_MAXINTEGER, |
| ** which means no limit. If the number is too negative, the loop |
| ** should not run, because any initial integer value is larger than the |
| ** limit. So, it sets the limit to LUA_MININTEGER. 'stopnow' corrects |
| ** the extreme case when the initial value is LUA_MININTEGER, in which |
| ** case the LUA_MININTEGER limit would still run the loop once. |
| */ |
| static int forlimit (const TValue *obj, lua_Integer *p, lua_Integer step, |
| int *stopnow) { |
| *stopnow = 0; /* usually, let loops run */ |
| if (!tointeger_aux(obj, p, (step < 0 ? 1 : -1))) { /* not fit in integer? */ |
| lua_Number n; /* try to convert to float */ |
| if (!tonumber(obj, &n)) /* cannot convert to float? */ |
| return 0; /* not a number */ |
| if (n > 0) { /* if true, float is larger than max integer */ |
| *p = LUA_MAXINTEGER; |
| if (step < 0) *stopnow = 1; |
| } |
| else { /* float is smaller than min integer */ |
| *p = LUA_MININTEGER; |
| if (step >= 0) *stopnow = 1; |
| } |
| } |
| return 1; |
| } |
| |
| |
| /* |
| ** Main function for table access (invoking metamethods if needed). |
| ** Compute 'val = t[key]' |
| */ |
| void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) { |
| int loop; /* counter to avoid infinite loops */ |
| for (loop = 0; loop < MAXTAGLOOP; loop++) { |
| const TValue *tm; |
| if (ttistable(t)) { /* `t' is a table? */ |
| Table *h = hvalue(t); |
| const TValue *res = luaH_get(h, key); /* do a primitive get */ |
| if (!ttisnil(res) || /* result is not nil? */ |
| (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */ |
| setobj2s(L, val, res); /* result is the raw get */ |
| return; |
| } |
| /* else will try metamethod */ |
| } |
| else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX))) |
| luaG_typeerror(L, t, "index"); /* no metamethod */ |
| if (ttisfunction(tm)) { /* metamethod is a function */ |
| luaT_callTM(L, tm, t, key, val, 1); |
| return; |
| } |
| t = tm; /* else repeat access over 'tm' */ |
| } |
| luaG_runerror(L, "gettable chain too long; possible loop"); |
| } |
| |
| |
| /* |
| ** Main function for table assignment (invoking metamethods if needed). |
| ** Compute 't[key] = val' |
| */ |
| void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) { |
| int loop; /* counter to avoid infinite loops */ |
| for (loop = 0; loop < MAXTAGLOOP; loop++) { |
| const TValue *tm; |
| if (ttistable(t)) { /* `t' is a table? */ |
| Table *h = hvalue(t); |
| TValue *oldval = cast(TValue *, luaH_get(h, key)); |
| /* if previous value is not nil, there must be a previous entry |
| in the table; a metamethod has no relevance */ |
| if (!ttisnil(oldval) || |
| /* previous value is nil; must check the metamethod */ |
| ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL && |
| /* no metamethod; is there a previous entry in the table? */ |
| (oldval != luaO_nilobject || |
| /* no previous entry; must create one. (The next test is |
| always true; we only need the assignment.) */ |
| (oldval = luaH_newkey(L, h, key), 1)))) { |
| /* no metamethod and (now) there is an entry with given key */ |
| setobj2t(L, oldval, val); /* assign new value to that entry */ |
| invalidateTMcache(h); |
| luaC_barrierback(L, h, val); |
| return; |
| } |
| /* else will try the metamethod */ |
| } |
| else /* not a table; check metamethod */ |
| if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX))) |
| luaG_typeerror(L, t, "index"); |
| /* try the metamethod */ |
| if (ttisfunction(tm)) { |
| luaT_callTM(L, tm, t, key, val, 0); |
| return; |
| } |
| t = tm; /* else repeat assignment over 'tm' */ |
| } |
| luaG_runerror(L, "settable chain too long; possible loop"); |
| } |
| |
| |
| /* |
| ** Compare two strings 'ls' x 'rs', returning an integer smaller-equal- |
| ** -larger than zero if 'ls' is smaller-equal-larger than 'rs'. |
| ** The code is a little tricky because it allows '\0' in the strings |
| ** and it uses 'strcoll' (to respect locales) for each segments |
| ** of the strings. |
| */ |
| static int l_strcmp (const TString *ls, const TString *rs) { |
| const char *l = getstr(ls); |
| size_t ll = ls->len; |
| const char *r = getstr(rs); |
| size_t lr = rs->len; |
| for (;;) { /* for each segment */ |
| int temp = strcoll(l, r); |
| if (temp != 0) /* not equal? */ |
| return temp; /* done */ |
| else { /* strings are equal up to a '\0' */ |
| size_t len = strlen(l); /* index of first `\0' in both strings */ |
| if (len == lr) /* 'rs' is finished? */ |
| return (len == ll) ? 0 : 1; /* check 'ls' */ |
| else if (len == ll) /* 'ls' is finished? */ |
| return -1; /* 'ls' is smaller than 'rs' ('rs' is not finished) */ |
| /* both strings longer than `len'; go on comparing after the '\0' */ |
| len++; |
| l += len; ll -= len; r += len; lr -= len; |
| } |
| } |
| } |
| |
| |
| /* |
| ** Main operation less than; return 'l < r'. |
| */ |
| int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) { |
| int res; |
| lua_Number nl, nr; |
| if (ttisinteger(l) && ttisinteger(r)) /* both operands are integers? */ |
| return (ivalue(l) < ivalue(r)); |
| else if (tofloat(l, &nl) && tofloat(r, &nr)) /* both are numbers? */ |
| return luai_numlt(nl, nr); |
| else if (ttisstring(l) && ttisstring(r)) /* both are strings? */ |
| return l_strcmp(tsvalue(l), tsvalue(r)) < 0; |
| else if ((res = luaT_callorderTM(L, l, r, TM_LT)) < 0) /* no metamethod? */ |
| luaG_ordererror(L, l, r); /* error */ |
| return res; |
| } |
| |
| |
| /* |
| ** Main operation less than or equal to; return 'l <= r'. |
| */ |
| int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) { |
| int res; |
| lua_Number nl, nr; |
| if (ttisinteger(l) && ttisinteger(r)) /* both operands are integers? */ |
| return (ivalue(l) <= ivalue(r)); |
| else if (tofloat(l, &nl) && tofloat(r, &nr)) /* both are numbers? */ |
| return luai_numle(nl, nr); |
| else if (ttisstring(l) && ttisstring(r)) /* both are strings? */ |
| return l_strcmp(tsvalue(l), tsvalue(r)) <= 0; |
| else if ((res = luaT_callorderTM(L, l, r, TM_LE)) >= 0) /* first try `le' */ |
| return res; |
| else if ((res = luaT_callorderTM(L, r, l, TM_LT)) < 0) /* else try `lt' */ |
| luaG_ordererror(L, l, r); |
| return !res; |
| } |
| |
| |
| /* |
| ** Main operation for equality of Lua values; return 't1 == t2'. |
| ** L == NULL means raw equality (no metamethods) |
| */ |
| int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) { |
| const TValue *tm; |
| if (ttype(t1) != ttype(t2)) { /* not the same variant? */ |
| if (ttnov(t1) != ttnov(t2) || ttnov(t1) != LUA_TNUMBER) |
| return 0; /* only numbers can be equal with different variants */ |
| else { /* two numbers with different variants */ |
| lua_Number n1, n2; /* compare them as floats */ |
| lua_assert(ttisnumber(t1) && ttisnumber(t2)); |
| cast_void(tofloat(t1, &n1)); cast_void(tofloat(t2, &n2)); |
| return luai_numeq(n1, n2); |
| } |
| } |
| /* values have same type and same variant */ |
| switch (ttype(t1)) { |
| case LUA_TNIL: return 1; |
| case LUA_TNUMINT: return (ivalue(t1) == ivalue(t2)); |
| case LUA_TNUMFLT: return luai_numeq(fltvalue(t1), fltvalue(t2)); |
| case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */ |
| case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2); |
| case LUA_TLCF: return fvalue(t1) == fvalue(t2); |
| case LUA_TSHRSTR: return eqshrstr(tsvalue(t1), tsvalue(t2)); |
| case LUA_TLNGSTR: return luaS_eqlngstr(tsvalue(t1), tsvalue(t2)); |
| case LUA_TUSERDATA: { |
| if (uvalue(t1) == uvalue(t2)) return 1; |
| else if (L == NULL) return 0; |
| tm = fasttm(L, uvalue(t1)->metatable, TM_EQ); |
| if (tm == NULL) |
| tm = fasttm(L, uvalue(t2)->metatable, TM_EQ); |
| break; /* will try TM */ |
| } |
| case LUA_TTABLE: { |
| if (hvalue(t1) == hvalue(t2)) return 1; |
| else if (L == NULL) return 0; |
| tm = fasttm(L, hvalue(t1)->metatable, TM_EQ); |
| if (tm == NULL) |
| tm = fasttm(L, hvalue(t2)->metatable, TM_EQ); |
| break; /* will try TM */ |
| } |
| default: |
| return gcvalue(t1) == gcvalue(t2); |
| } |
| if (tm == NULL) /* no TM? */ |
| return 0; /* objects are different */ |
| luaT_callTM(L, tm, t1, t2, L->top, 1); /* call TM */ |
| return !l_isfalse(L->top); |
| } |
| |
| |
| /* macro used by 'luaV_concat' to ensure that element at 'o' is a string */ |
| #define tostring(L,o) \ |
| (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1))) |
| |
| /* |
| ** Main operation for concatenation: concat 'total' values in the stack, |
| ** from 'L->top - total' up to 'L->top - 1'. |
| */ |
| void luaV_concat (lua_State *L, int total) { |
| lua_assert(total >= 2); |
| do { |
| StkId top = L->top; |
| int n = 2; /* number of elements handled in this pass (at least 2) */ |
| if (!(ttisstring(top-2) || cvt2str(top-2)) || !tostring(L, top-1)) |
| luaT_trybinTM(L, top-2, top-1, top-2, TM_CONCAT); |
| else if (tsvalue(top-1)->len == 0) /* second operand is empty? */ |
| cast_void(tostring(L, top - 2)); /* result is first operand */ |
| else if (ttisstring(top-2) && tsvalue(top-2)->len == 0) { |
| setobjs2s(L, top - 2, top - 1); /* result is second op. */ |
| } |
| else { |
| /* at least two non-empty string values; get as many as possible */ |
| size_t tl = tsvalue(top-1)->len; |
| char *buffer; |
| int i; |
| /* collect total length */ |
| for (i = 1; i < total && tostring(L, top-i-1); i++) { |
| size_t l = tsvalue(top-i-1)->len; |
| if (l >= (MAX_SIZE/sizeof(char)) - tl) |
| luaG_runerror(L, "string length overflow"); |
| tl += l; |
| } |
| buffer = luaZ_openspace(L, &G(L)->buff, tl); |
| tl = 0; |
| n = i; |
| do { /* copy all strings to buffer */ |
| size_t l = tsvalue(top-i)->len; |
| memcpy(buffer+tl, svalue(top-i), l * sizeof(char)); |
| tl += l; |
| } while (--i > 0); |
| setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl)); /* create result */ |
| } |
| total -= n-1; /* got 'n' strings to create 1 new */ |
| L->top -= n-1; /* popped 'n' strings and pushed one */ |
| } while (total > 1); /* repeat until only 1 result left */ |
| } |
| |
| |
| /* |
| ** Main operation 'ra' = #rb'. |
| */ |
| void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) { |
| const TValue *tm; |
| switch (ttnov(rb)) { |
| case LUA_TTABLE: { |
| Table *h = hvalue(rb); |
| tm = fasttm(L, h->metatable, TM_LEN); |
| if (tm) break; /* metamethod? break switch to call it */ |
| setivalue(ra, luaH_getn(h)); /* else primitive len */ |
| return; |
| } |
| case LUA_TSTRING: { |
| setivalue(ra, tsvalue(rb)->len); |
| return; |
| } |
| default: { /* try metamethod */ |
| tm = luaT_gettmbyobj(L, rb, TM_LEN); |
| if (ttisnil(tm)) /* no metamethod? */ |
| luaG_typeerror(L, rb, "get length of"); |
| break; |
| } |
| } |
| luaT_callTM(L, tm, rb, rb, ra, 1); |
| } |
| |
| |
| /* |
| ** Integer division; return 'm // n'. (Assume that C division with |
| ** negative operands follows C99 behavior.) |
| */ |
| lua_Integer luaV_div (lua_State *L, lua_Integer m, lua_Integer n) { |
| if (l_castS2U(n) + 1u <= 1u) { /* special cases: -1 or 0 */ |
| if (n == 0) |
| luaG_runerror(L, "attempt to divide by zero"); |
| return intop(-, 0, m); /* n==-1; avoid overflow with 0x80000...//-1 */ |
| } |
| else { |
| lua_Integer d = m / n; /* perform division */ |
| if ((m ^ n) >= 0 || m % n == 0) /* same signal or no rest? */ |
| return d; |
| else |
| return d - 1; /* correct 'div' for negative case */ |
| } |
| } |
| |
| |
| /* |
| ** Integer modulus; return 'm % n'. (Assume that C '%' with |
| ** negative operands follows C99 behavior.) |
| */ |
| lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) { |
| if (l_castS2U(n) + 1u <= 1u) { /* special cases: -1 or 0 */ |
| if (n == 0) |
| luaG_runerror(L, "attempt to perform 'n%%0'"); |
| return 0; /* m % -1 == 0; avoid overflow with 0x80000...%-1 */ |
| } |
| else { |
| lua_Integer r = m % n; |
| if (r == 0 || (m ^ n) >= 0) /* no rest or same signal? */ |
| return r; |
| else |
| return r + n; /* correct 'mod' for negative case */ |
| } |
| } |
| |
| |
| /* number of bits in an integer */ |
| #define NBITS cast_int(sizeof(lua_Integer) * CHAR_BIT) |
| |
| /* |
| ** Shift left operation. (Shift right just negates 'y'.) |
| */ |
| lua_Integer luaV_shiftl (lua_Integer x, lua_Integer y) { |
| if (y < 0) { /* shift right? */ |
| if (y <= -NBITS) return 0; |
| else return intop(>>, x, -y); |
| } |
| else { /* shift left */ |
| if (y >= NBITS) return 0; |
| else return intop(<<, x, y); |
| } |
| } |
| |
| |
| /* |
| ** check whether cached closure in prototype 'p' may be reused, that is, |
| ** whether there is a cached closure with the same upvalues needed by |
| ** new closure to be created. |
| */ |
| static LClosure *getcached (Proto *p, UpVal **encup, StkId base) { |
| LClosure *c = p->cache; |
| if (c != NULL) { /* is there a cached closure? */ |
| int nup = p->sizeupvalues; |
| Upvaldesc *uv = p->upvalues; |
| int i; |
| for (i = 0; i < nup; i++) { /* check whether it has right upvalues */ |
| TValue *v = uv[i].instack ? base + uv[i].idx : encup[uv[i].idx]->v; |
| if (c->upvals[i]->v != v) |
| return NULL; /* wrong upvalue; cannot reuse closure */ |
| } |
| } |
| return c; /* return cached closure (or NULL if no cached closure) */ |
| } |
| |
| |
| /* |
| ** create a new Lua closure, push it in the stack, and initialize |
| ** its upvalues. Note that the closure is not cached if prototype is |
| ** already black (which means that 'cache' was already cleared by the |
| ** GC). |
| */ |
| static void pushclosure (lua_State *L, Proto *p, UpVal **encup, StkId base, |
| StkId ra) { |
| int nup = p->sizeupvalues; |
| Upvaldesc *uv = p->upvalues; |
| int i; |
| LClosure *ncl = luaF_newLclosure(L, nup); |
| ncl->p = p; |
| setclLvalue(L, ra, ncl); /* anchor new closure in stack */ |
| for (i = 0; i < nup; i++) { /* fill in its upvalues */ |
| if (uv[i].instack) /* upvalue refers to local variable? */ |
| ncl->upvals[i] = luaF_findupval(L, base + uv[i].idx); |
| else /* get upvalue from enclosing function */ |
| ncl->upvals[i] = encup[uv[i].idx]; |
| ncl->upvals[i]->refcount++; |
| /* new closure is white, so we do not need a barrier here */ |
| } |
| if (!isblack(p)) /* cache will not break GC invariant? */ |
| p->cache = ncl; /* save it on cache for reuse */ |
| } |
| |
| |
| /* |
| ** finish execution of an opcode interrupted by an yield |
| */ |
| void luaV_finishOp (lua_State *L) { |
| CallInfo *ci = L->ci; |
| StkId base = ci->u.l.base; |
| Instruction inst = *(ci->u.l.savedpc - 1); /* interrupted instruction */ |
| OpCode op = GET_OPCODE(inst); |
| switch (op) { /* finish its execution */ |
| case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV: case OP_IDIV: |
| case OP_BAND: case OP_BOR: case OP_BXOR: case OP_SHL: case OP_SHR: |
| case OP_MOD: case OP_POW: |
| case OP_UNM: case OP_BNOT: case OP_LEN: |
| case OP_GETTABUP: case OP_GETTABLE: case OP_SELF: { |
| setobjs2s(L, base + GETARG_A(inst), --L->top); |
| break; |
| } |
| case OP_LE: case OP_LT: case OP_EQ: { |
| int res = !l_isfalse(L->top - 1); |
| L->top--; |
| /* metamethod should not be called when operand is K */ |
| lua_assert(!ISK(GETARG_B(inst))); |
| if (op == OP_LE && /* "<=" using "<" instead? */ |
| ttisnil(luaT_gettmbyobj(L, base + GETARG_B(inst), TM_LE))) |
| res = !res; /* invert result */ |
| lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_JMP); |
| if (res != GETARG_A(inst)) /* condition failed? */ |
| ci->u.l.savedpc++; /* skip jump instruction */ |
| break; |
| } |
| case OP_CONCAT: { |
| StkId top = L->top - 1; /* top when 'luaT_trybinTM' was called */ |
| int b = GETARG_B(inst); /* first element to concatenate */ |
| int total = cast_int(top - 1 - (base + b)); /* yet to concatenate */ |
| setobj2s(L, top - 2, top); /* put TM result in proper position */ |
| if (total > 1) { /* are there elements to concat? */ |
| L->top = top - 1; /* top is one after last element (at top-2) */ |
| luaV_concat(L, total); /* concat them (may yield again) */ |
| } |
| /* move final result to final position */ |
| setobj2s(L, ci->u.l.base + GETARG_A(inst), L->top - 1); |
| L->top = ci->top; /* restore top */ |
| break; |
| } |
| case OP_TFORCALL: { |
| lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_TFORLOOP); |
| L->top = ci->top; /* correct top */ |
| break; |
| } |
| case OP_CALL: { |
| if (GETARG_C(inst) - 1 >= 0) /* nresults >= 0? */ |
| L->top = ci->top; /* adjust results */ |
| break; |
| } |
| case OP_TAILCALL: case OP_SETTABUP: case OP_SETTABLE: |
| break; |
| default: lua_assert(0); |
| } |
| } |
| |
| |
| |
| |
| /* |
| ** {================================================================== |
| ** Function 'luaV_execute': main interpreter loop |
| ** =================================================================== |
| */ |
| |
| |
| /* |
| ** some macros for common tasks in `luaV_execute' |
| */ |
| |
| #if !defined luai_runtimecheck |
| #define luai_runtimecheck(L, c) /* void */ |
| #endif |
| |
| |
| #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) \ |
| (k + (GETARG_Bx(i) != 0 ? GETARG_Bx(i) - 1 : GETARG_Ax(*ci->u.l.savedpc++))) |
| |
| |
| /* execute a jump instruction */ |
| #define dojump(ci,i,e) \ |
| { int a = GETARG_A(i); \ |
| if (a > 0) luaF_close(L, ci->u.l.base + a - 1); \ |
| ci->u.l.savedpc += GETARG_sBx(i) + e; } |
| |
| /* for test instructions, execute the jump instruction that follows it */ |
| #define donextjump(ci) { i = *ci->u.l.savedpc; dojump(ci, i, 1); } |
| |
| |
| #define Protect(x) { {x;}; base = ci->u.l.base; } |
| |
| #define checkGC(L,c) \ |
| Protect( luaC_condGC(L,{L->top = (c); /* limit of live values */ \ |
| luaC_step(L); \ |
| L->top = ci->top;}) /* restore top */ \ |
| luai_threadyield(L); ) |
| |
| |
| #define vmdispatch(o) switch(o) |
| #define vmcase(l,b) case l: {b} break; |
| #define vmcasenb(l,b) case l: {b} /* nb = no break */ |
| |
| void luaV_execute (lua_State *L) { |
| CallInfo *ci = L->ci; |
| LClosure *cl; |
| TValue *k; |
| StkId base; |
| newframe: /* reentry point when frame changes (call/return) */ |
| lua_assert(ci == L->ci); |
| cl = clLvalue(ci->func); |
| k = cl->p->k; |
| base = ci->u.l.base; |
| /* main loop of interpreter */ |
| for (;;) { |
| Instruction i = *(ci->u.l.savedpc++); |
| StkId ra; |
| if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) && |
| (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) { |
| Protect(luaG_traceexec(L)); |
| } |
| /* WARNING: several calls may realloc the stack and invalidate `ra' */ |
| ra = RA(i); |
| lua_assert(base == ci->u.l.base); |
| lua_assert(base <= L->top && L->top < L->stack + L->stacksize); |
| vmdispatch (GET_OPCODE(i)) { |
| vmcase(OP_MOVE, |
| setobjs2s(L, ra, RB(i)); |
| ) |
| vmcase(OP_LOADK, |
| TValue *rb = k + GETARG_Bx(i); |
| setobj2s(L, ra, rb); |
| ) |
| vmcase(OP_LOADKX, |
| TValue *rb; |
| lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG); |
| rb = k + GETARG_Ax(*ci->u.l.savedpc++); |
| setobj2s(L, ra, rb); |
| ) |
| vmcase(OP_LOADBOOL, |
| setbvalue(ra, GETARG_B(i)); |
| if (GETARG_C(i)) ci->u.l.savedpc++; /* skip next instruction (if C) */ |
| ) |
| vmcase(OP_LOADNIL, |
| int b = GETARG_B(i); |
| do { |
| setnilvalue(ra++); |
| } while (b--); |
| ) |
| vmcase(OP_GETUPVAL, |
| int b = GETARG_B(i); |
| setobj2s(L, ra, cl->upvals[b]->v); |
| ) |
| vmcase(OP_GETTABUP, |
| int b = GETARG_B(i); |
| Protect(luaV_gettable(L, cl->upvals[b]->v, RKC(i), ra)); |
| ) |
| vmcase(OP_GETTABLE, |
| Protect(luaV_gettable(L, RB(i), RKC(i), ra)); |
| ) |
| vmcase(OP_SETTABUP, |
| int a = GETARG_A(i); |
| Protect(luaV_settable(L, cl->upvals[a]->v, RKB(i), RKC(i))); |
| ) |
| vmcase(OP_SETUPVAL, |
| UpVal *uv = cl->upvals[GETARG_B(i)]; |
| setobj(L, uv->v, ra); |
| luaC_upvalbarrier(L, uv); |
| ) |
| vmcase(OP_SETTABLE, |
| Protect(luaV_settable(L, ra, RKB(i), RKC(i))); |
| ) |
| vmcase(OP_NEWTABLE, |
| int b = GETARG_B(i); |
| int c = GETARG_C(i); |
| Table *t = luaH_new(L); |
| sethvalue(L, ra, t); |
| if (b != 0 || c != 0) |
| luaH_resize(L, t, luaO_fb2int(b), luaO_fb2int(c)); |
| checkGC(L, ra + 1); |
| ) |
| vmcase(OP_SELF, |
| StkId rb = RB(i); |
| setobjs2s(L, ra+1, rb); |
| Protect(luaV_gettable(L, rb, RKC(i), ra)); |
| ) |
| vmcase(OP_ADD, |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| lua_Number nb; lua_Number nc; |
| if (ttisinteger(rb) && ttisinteger(rc)) { |
| lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc); |
| setivalue(ra, intop(+, ib, ic)); |
| } |
| else if (tonumber(rb, &nb) && tonumber(rc, &nc)) { |
| setfltvalue(ra, luai_numadd(L, nb, nc)); |
| } |
| else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_ADD)); } |
| ) |
| vmcase(OP_SUB, |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| lua_Number nb; lua_Number nc; |
| if (ttisinteger(rb) && ttisinteger(rc)) { |
| lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc); |
| setivalue(ra, intop(-, ib, ic)); |
| } |
| else if (tonumber(rb, &nb) && tonumber(rc, &nc)) { |
| setfltvalue(ra, luai_numsub(L, nb, nc)); |
| } |
| else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SUB)); } |
| ) |
| vmcase(OP_MUL, |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| lua_Number nb; lua_Number nc; |
| if (ttisinteger(rb) && ttisinteger(rc)) { |
| lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc); |
| setivalue(ra, intop(*, ib, ic)); |
| } |
| else if (tonumber(rb, &nb) && tonumber(rc, &nc)) { |
| setfltvalue(ra, luai_nummul(L, nb, nc)); |
| } |
| else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_MUL)); } |
| ) |
| vmcase(OP_DIV, /* float division (always with floats) */ |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| lua_Number nb; lua_Number nc; |
| if (tonumber(rb, &nb) && tonumber(rc, &nc)) { |
| setfltvalue(ra, luai_numdiv(L, nb, nc)); |
| } |
| else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_DIV)); } |
| ) |
| vmcase(OP_IDIV, /* integer division */ |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| lua_Integer ib; lua_Integer ic; |
| if (tointeger(rb, &ib) && tointeger(rc, &ic)) { |
| setivalue(ra, luaV_div(L, ib, ic)); |
| } |
| else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_IDIV)); } |
| ) |
| vmcase(OP_BAND, |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| lua_Integer ib; lua_Integer ic; |
| if (tointeger(rb, &ib) && tointeger(rc, &ic)) { |
| setivalue(ra, intop(&, ib, ic)); |
| } |
| else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BAND)); } |
| ) |
| vmcase(OP_BOR, |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| lua_Integer ib; lua_Integer ic; |
| if (tointeger(rb, &ib) && tointeger(rc, &ic)) { |
| setivalue(ra, intop(|, ib, ic)); |
| } |
| else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BOR)); } |
| ) |
| vmcase(OP_BXOR, |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| lua_Integer ib; lua_Integer ic; |
| if (tointeger(rb, &ib) && tointeger(rc, &ic)) { |
| setivalue(ra, intop(^, ib, ic)); |
| } |
| else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_BXOR)); } |
| ) |
| vmcase(OP_SHL, |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| lua_Integer ib; lua_Integer ic; |
| if (tointeger(rb, &ib) && tointeger(rc, &ic)) { |
| setivalue(ra, luaV_shiftl(ib, ic)); |
| } |
| else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SHL)); } |
| ) |
| vmcase(OP_SHR, |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| lua_Integer ib; lua_Integer ic; |
| if (tointeger(rb, &ib) && tointeger(rc, &ic)) { |
| setivalue(ra, luaV_shiftl(ib, -ic)); |
| } |
| else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_SHR)); } |
| ) |
| vmcase(OP_MOD, |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| lua_Number nb; lua_Number nc; |
| if (ttisinteger(rb) && ttisinteger(rc)) { |
| lua_Integer ib = ivalue(rb); lua_Integer ic = ivalue(rc); |
| setivalue(ra, luaV_mod(L, ib, ic)); |
| } |
| else if (tonumber(rb, &nb) && tonumber(rc, &nc)) { |
| lua_Number m; |
| luai_nummod(L, nb, nc, m); |
| setfltvalue(ra, m); |
| } |
| else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_MOD)); } |
| ) |
| vmcase(OP_POW, |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| lua_Number nb; lua_Number nc; |
| if (tonumber(rb, &nb) && tonumber(rc, &nc)) { |
| setfltvalue(ra, luai_numpow(L, nb, nc)); |
| } |
| else { Protect(luaT_trybinTM(L, rb, rc, ra, TM_POW)); } |
| ) |
| vmcase(OP_UNM, |
| TValue *rb = RB(i); |
| lua_Number nb; |
| if (ttisinteger(rb)) { |
| lua_Integer ib = ivalue(rb); |
| setivalue(ra, intop(-, 0, ib)); |
| } |
| else if (tonumber(rb, &nb)) { |
| setfltvalue(ra, luai_numunm(L, nb)); |
| } |
| else { |
| Protect(luaT_trybinTM(L, rb, rb, ra, TM_UNM)); |
| } |
| ) |
| vmcase(OP_BNOT, |
| TValue *rb = RB(i); |
| lua_Integer ib; |
| if (tointeger(rb, &ib)) { |
| setivalue(ra, intop(^, ~l_castS2U(0), ib)); |
| } |
| else { |
| Protect(luaT_trybinTM(L, rb, rb, ra, TM_BNOT)); |
| } |
| ) |
| vmcase(OP_NOT, |
| TValue *rb = RB(i); |
| int res = l_isfalse(rb); /* next assignment may change this value */ |
| setbvalue(ra, res); |
| ) |
| vmcase(OP_LEN, |
| Protect(luaV_objlen(L, ra, RB(i))); |
| ) |
| vmcase(OP_CONCAT, |
| int b = GETARG_B(i); |
| int c = GETARG_C(i); |
| StkId rb; |
| L->top = base + c + 1; /* mark the end of concat operands */ |
| Protect(luaV_concat(L, c - b + 1)); |
| ra = RA(i); /* 'luav_concat' may invoke TMs and move the stack */ |
| rb = b + base; |
| setobjs2s(L, ra, rb); |
| checkGC(L, (ra >= rb ? ra + 1 : rb)); |
| L->top = ci->top; /* restore top */ |
| ) |
| vmcase(OP_JMP, |
| dojump(ci, i, 0); |
| ) |
| vmcase(OP_EQ, |
| TValue *rb = RKB(i); |
| TValue *rc = RKC(i); |
| Protect( |
| if (cast_int(luaV_equalobj(L, rb, rc)) != GETARG_A(i)) |
| ci->u.l.savedpc++; |
| else |
| donextjump(ci); |
| ) |
| ) |
| vmcase(OP_LT, |
| Protect( |
| if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i)) |
| ci->u.l.savedpc++; |
| else |
| donextjump(ci); |
| ) |
| ) |
| vmcase(OP_LE, |
| Protect( |
| if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) |
| ci->u.l.savedpc++; |
| else |
| donextjump(ci); |
| ) |
| ) |
| vmcase(OP_TEST, |
| if (GETARG_C(i) ? l_isfalse(ra) : !l_isfalse(ra)) |
| ci->u.l.savedpc++; |
| else |
| donextjump(ci); |
| ) |
| vmcase(OP_TESTSET, |
| TValue *rb = RB(i); |
| if (GETARG_C(i) ? l_isfalse(rb) : !l_isfalse(rb)) |
| ci->u.l.savedpc++; |
| else { |
| setobjs2s(L, ra, rb); |
| donextjump(ci); |
| } |
| ) |
| vmcase(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 */ |
| if (luaD_precall(L, ra, nresults)) { /* C function? */ |
| if (nresults >= 0) L->top = ci->top; /* adjust results */ |
| base = ci->u.l.base; |
| } |
| else { /* Lua function */ |
| ci = L->ci; |
| ci->callstatus |= CIST_REENTRY; |
| goto newframe; /* restart luaV_execute over new Lua function */ |
| } |
| ) |
| vmcase(OP_TAILCALL, |
| int b = GETARG_B(i); |
| if (b != 0) L->top = ra+b; /* else previous instruction set top */ |
| lua_assert(GETARG_C(i) - 1 == LUA_MULTRET); |
| if (luaD_precall(L, ra, LUA_MULTRET)) /* C function? */ |
| base = ci->u.l.base; |
| else { |
| /* tail call: put called frame (n) in place of caller one (o) */ |
| CallInfo *nci = L->ci; /* called frame */ |
| CallInfo *oci = nci->previous; /* caller frame */ |
| StkId nfunc = nci->func; /* called function */ |
| StkId ofunc = oci->func; /* caller function */ |
| /* last stack slot filled by 'precall' */ |
| StkId lim = nci->u.l.base + getproto(nfunc)->numparams; |
| int aux; |
| /* close all upvalues from previous call */ |
| if (cl->p->sizep > 0) luaF_close(L, oci->u.l.base); |
| /* move new frame into old one */ |
| for (aux = 0; nfunc + aux < lim; aux++) |
| setobjs2s(L, ofunc + aux, nfunc + aux); |
| oci->u.l.base = ofunc + (nci->u.l.base - nfunc); /* correct base */ |
| oci->top = L->top = ofunc + (L->top - nfunc); /* correct top */ |
| oci->u.l.savedpc = nci->u.l.savedpc; |
| oci->callstatus |= CIST_TAIL; /* function was tail called */ |
| ci = L->ci = oci; /* remove new frame */ |
| lua_assert(L->top == oci->u.l.base + getproto(ofunc)->maxstacksize); |
| goto newframe; /* restart luaV_execute over new Lua function */ |
| } |
| ) |
| vmcasenb(OP_RETURN, |
| int b = GETARG_B(i); |
| if (b != 0) L->top = ra+b-1; |
| if (cl->p->sizep > 0) luaF_close(L, base); |
| b = luaD_poscall(L, ra); |
| if (!(ci->callstatus & CIST_REENTRY)) /* 'ci' still the called one */ |
| return; /* external invocation: return */ |
| else { /* invocation via reentry: continue execution */ |
| ci = L->ci; |
| if (b) L->top = ci->top; |
| lua_assert(isLua(ci)); |
| lua_assert(GET_OPCODE(*((ci)->u.l.savedpc - 1)) == OP_CALL); |
| goto newframe; /* restart luaV_execute over new Lua function */ |
| } |
| ) |
| vmcase(OP_FORLOOP, |
| if (ttisinteger(ra)) { /* integer loop? */ |
| lua_Integer step = ivalue(ra + 2); |
| lua_Integer idx = ivalue(ra) + step; /* increment index */ |
| lua_Integer limit = ivalue(ra + 1); |
| if ((0 < step) ? (idx <= limit) : (limit <= idx)) { |
| ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ |
| setivalue(ra, idx); /* update internal index... */ |
| setivalue(ra + 3, idx); /* ...and external index */ |
| } |
| } |
| else { /* floating loop */ |
| lua_Number step = fltvalue(ra + 2); |
| lua_Number idx = luai_numadd(L, fltvalue(ra), step); /* inc. index */ |
| lua_Number limit = fltvalue(ra + 1); |
| if (luai_numlt(0, step) ? luai_numle(idx, limit) |
| : luai_numle(limit, idx)) { |
| ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ |
| setfltvalue(ra, idx); /* update internal index... */ |
| setfltvalue(ra + 3, idx); /* ...and external index */ |
| } |
| } |
| ) |
| vmcase(OP_FORPREP, |
| TValue *init = ra; |
| TValue *plimit = ra + 1; |
| TValue *pstep = ra + 2; |
| lua_Integer ilimit; |
| int stopnow; |
| if (ttisinteger(init) && ttisinteger(pstep) && |
| forlimit(plimit, &ilimit, ivalue(pstep), &stopnow)) { |
| /* all values are integer */ |
| lua_Integer initv = (stopnow ? 0 : ivalue(init)); |
| setivalue(plimit, ilimit); |
| setivalue(init, initv - ivalue(pstep)); |
| } |
| else { /* try making all values floats */ |
| lua_Number ninit; lua_Number nlimit; lua_Number nstep; |
| if (!tonumber(plimit, &nlimit)) |
| luaG_runerror(L, "'for' limit must be a number"); |
| setfltvalue(plimit, nlimit); |
| if (!tonumber(pstep, &nstep)) |
| luaG_runerror(L, "'for' step must be a number"); |
| setfltvalue(pstep, nstep); |
| if (!tonumber(init, &ninit)) |
| luaG_runerror(L, "'for' initial value must be a number"); |
| setfltvalue(init, luai_numsub(L, ninit, nstep)); |
| } |
| ci->u.l.savedpc += GETARG_sBx(i); |
| ) |
| vmcasenb(OP_TFORCALL, |
| 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(luaD_call(L, cb, GETARG_C(i), 1)); |
| L->top = ci->top; |
| i = *(ci->u.l.savedpc++); /* go to next instruction */ |
| ra = RA(i); |
| lua_assert(GET_OPCODE(i) == OP_TFORLOOP); |
| goto l_tforloop; |
| ) |
| vmcase(OP_TFORLOOP, |
| l_tforloop: |
| if (!ttisnil(ra + 1)) { /* continue loop? */ |
| setobjs2s(L, ra, ra + 1); /* save control variable */ |
| ci->u.l.savedpc += GETARG_sBx(i); /* jump back */ |
| } |
| ) |
| vmcase(OP_SETLIST, |
| int n = GETARG_B(i); |
| int c = GETARG_C(i); |
| unsigned int last; |
| Table *h; |
| if (n == 0) n = cast_int(L->top - ra) - 1; |
| if (c == 0) { |
| lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG); |
| c = GETARG_Ax(*ci->u.l.savedpc++); |
| } |
| luai_runtimecheck(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-allocate it at once */ |
| for (; n > 0; n--) { |
| TValue *val = ra+n; |
| luaH_setint(L, h, last--, val); |
| luaC_barrierback(L, h, val); |
| } |
| L->top = ci->top; /* correct top (in case of previous open call) */ |
| ) |
| vmcase(OP_CLOSURE, |
| Proto *p = cl->p->p[GETARG_Bx(i)]; |
| LClosure *ncl = getcached(p, cl->upvals, base); /* cached closure */ |
| if (ncl == NULL) /* no match? */ |
| pushclosure(L, p, cl->upvals, base, ra); /* create a new one */ |
| else |
| setclLvalue(L, ra, ncl); /* push cashed closure */ |
| checkGC(L, ra + 1); |
| ) |
| vmcase(OP_VARARG, |
| int b = GETARG_B(i) - 1; |
| int j; |
| int n = cast_int(base - ci->func) - cl->p->numparams - 1; |
| if (b < 0) { /* B == 0? */ |
| b = n; /* get all var. arguments */ |
| Protect(luaD_checkstack(L, n)); |
| ra = RA(i); /* previous call may change the stack */ |
| L->top = ra + n; |
| } |
| for (j = 0; j < b; j++) { |
| if (j < n) { |
| setobjs2s(L, ra + j, base - n + j); |
| } |
| else { |
| setnilvalue(ra + j); |
| } |
| } |
| ) |
| vmcase(OP_EXTRAARG, |
| lua_assert(0); |
| ) |
| } |
| } |
| } |
| |
| /* }================================================================== */ |
| |