mirror of
https://github.com/lua/lua
synced 2024-11-22 21:01:26 +03:00
1830 lines
56 KiB
C
1830 lines
56 KiB
C
/*
|
|
** $Id: lvm.c $
|
|
** Lua virtual machine
|
|
** See Copyright Notice in lua.h
|
|
*/
|
|
|
|
#define lvm_c
|
|
#define LUA_CORE
|
|
|
|
#include "lprefix.h"
|
|
|
|
#include <float.h>
|
|
#include <limits.h>
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#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"
|
|
|
|
|
|
/*
|
|
** By default, use jump tables in the main interpreter loop on gcc
|
|
** and compatible compilers.
|
|
*/
|
|
#if !defined(LUA_USE_JUMPTABLE)
|
|
#if defined(__GNUC__)
|
|
#define LUA_USE_JUMPTABLE 1
|
|
#else
|
|
#define LUA_USE_JUMPTABLE 0
|
|
#endif
|
|
#endif
|
|
|
|
|
|
|
|
/* limit for table tag-method chains (to avoid infinite loops) */
|
|
#define MAXTAGLOOP 2000
|
|
|
|
|
|
/*
|
|
** 'l_intfitsf' checks whether a given integer is in the range that
|
|
** can be converted to a float without rounding. Used in comparisons.
|
|
*/
|
|
|
|
/* number of bits in the mantissa of a float */
|
|
#define NBM (l_mathlim(MANT_DIG))
|
|
|
|
/*
|
|
** Check whether some integers may not fit in a float, testing whether
|
|
** (maxinteger >> NBM) > 0. (That implies (1 << NBM) <= maxinteger.)
|
|
** (The shifts are done in parts, to avoid shifting by more than the size
|
|
** of an integer. In a worst case, NBM == 113 for long double and
|
|
** sizeof(long) == 32.)
|
|
*/
|
|
#if ((((LUA_MAXINTEGER >> (NBM / 4)) >> (NBM / 4)) >> (NBM / 4)) \
|
|
>> (NBM - (3 * (NBM / 4)))) > 0
|
|
|
|
/* limit for integers that fit in a float */
|
|
#define MAXINTFITSF ((lua_Unsigned)1 << NBM)
|
|
|
|
/* check whether 'i' is in the interval [-MAXINTFITSF, MAXINTFITSF] */
|
|
#define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF))
|
|
|
|
#else /* all integers fit in a float precisely */
|
|
|
|
#define l_intfitsf(i) 1
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
** Try to convert a value to a float. The float case is already handled
|
|
** by the macro 'tonumber'.
|
|
*/
|
|
int luaV_tonumber_ (const TValue *obj, lua_Number *n) {
|
|
TValue v;
|
|
if (ttisinteger(obj)) {
|
|
*n = cast_num(ivalue(obj));
|
|
return 1;
|
|
}
|
|
else if (cvt2num(obj) && /* string coercible to number? */
|
|
luaO_str2num(svalue(obj), &v) == vslen(obj) + 1) {
|
|
*n = nvalue(&v); /* convert result of 'luaO_str2num' to a float */
|
|
return 1;
|
|
}
|
|
else
|
|
return 0; /* conversion failed */
|
|
}
|
|
|
|
|
|
/*
|
|
** try to convert a float to an integer, rounding according to 'mode':
|
|
** mode == 0: accepts only integral values
|
|
** mode == 1: takes the floor of the number
|
|
** mode == 2: takes the ceil of the number
|
|
*/
|
|
int luaV_flttointeger (lua_Number n, lua_Integer *p, int mode) {
|
|
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 > 1) /* needs ceil? */
|
|
f += 1; /* convert floor to ceil (remember: n != f) */
|
|
}
|
|
return lua_numbertointeger(f, p);
|
|
}
|
|
|
|
|
|
/*
|
|
** try to convert a value to an integer, rounding according to 'mode',
|
|
** without string coercion.
|
|
** ("Fast track" handled by macro 'tointegerns'.)
|
|
*/
|
|
int luaV_tointegerns (const TValue *obj, lua_Integer *p, int mode) {
|
|
if (ttisfloat(obj))
|
|
return luaV_flttointeger(fltvalue(obj), p, mode);
|
|
else if (ttisinteger(obj)) {
|
|
*p = ivalue(obj);
|
|
return 1;
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
** try to convert a value to an integer.
|
|
*/
|
|
int luaV_tointeger (const TValue *obj, lua_Integer *p, int mode) {
|
|
TValue v;
|
|
if (cvt2num(obj) && luaO_str2num(svalue(obj), &v) == vslen(obj) + 1)
|
|
obj = &v; /* change string to its corresponding number */
|
|
return luaV_tointegerns(obj, p, mode);
|
|
}
|
|
|
|
|
|
/*
|
|
** Try to convert a 'for' limit to an integer, preserving the semantics
|
|
** of the loop. (The following explanation assumes a positive step;
|
|
** it is valid for negative steps mutatis mutandis.)
|
|
** Return true if the loop must not run.
|
|
** If the limit is an integer or can be converted to an integer,
|
|
** rounding down, that is the limit.
|
|
** Otherwise, check whether the limit can be converted to a float. If
|
|
** the float is too large, clip it to LUA_MAXINTEGER. If the float
|
|
** is too negative, the loop should not run, because any initial
|
|
** integer value is greater than such limit; so, it returns true to
|
|
** signal that.
|
|
** (For this latter case, no integer limit would be correct; even a
|
|
** limit of LUA_MININTEGER would run the loop once for an initial
|
|
** value equal to LUA_MININTEGER.)
|
|
*/
|
|
static int forlimit (lua_State *L, lua_Integer init, const TValue *lim,
|
|
lua_Integer *p, lua_Integer step) {
|
|
if (!luaV_tointeger(lim, p, (step < 0 ? 2 : 1))) {
|
|
/* not coercible to in integer */
|
|
lua_Number flim; /* try to convert to float */
|
|
if (!tonumber(lim, &flim)) /* cannot convert to float? */
|
|
luaG_forerror(L, lim, "limit");
|
|
/* else 'flim' is a float out of integer bounds */
|
|
if (luai_numlt(0, flim)) { /* if it is positive, it is too large */
|
|
if (step < 0) return 1; /* initial value must be less than it */
|
|
*p = LUA_MAXINTEGER; /* truncate */
|
|
}
|
|
else { /* it is less than min integer */
|
|
if (step > 0) return 1; /* initial value must be greater than it */
|
|
*p = LUA_MININTEGER; /* truncate */
|
|
}
|
|
}
|
|
return (step > 0 ? init > *p : init < *p); /* not to run? */
|
|
}
|
|
|
|
|
|
/*
|
|
** Finish the table access 'val = t[key]'.
|
|
** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to
|
|
** t[k] entry (which must be empty).
|
|
*/
|
|
void luaV_finishget (lua_State *L, const TValue *t, TValue *key, StkId val,
|
|
const TValue *slot) {
|
|
int loop; /* counter to avoid infinite loops */
|
|
const TValue *tm; /* metamethod */
|
|
for (loop = 0; loop < MAXTAGLOOP; loop++) {
|
|
if (slot == NULL) { /* 't' is not a table? */
|
|
lua_assert(!ttistable(t));
|
|
tm = luaT_gettmbyobj(L, t, TM_INDEX);
|
|
if (unlikely(notm(tm)))
|
|
luaG_typeerror(L, t, "index"); /* no metamethod */
|
|
/* else will try the metamethod */
|
|
}
|
|
else { /* 't' is a table */
|
|
lua_assert(isempty(slot));
|
|
tm = fasttm(L, hvalue(t)->metatable, TM_INDEX); /* table's metamethod */
|
|
if (tm == NULL) { /* no metamethod? */
|
|
setnilvalue(s2v(val)); /* result is nil */
|
|
return;
|
|
}
|
|
/* else will try the metamethod */
|
|
}
|
|
if (ttisfunction(tm)) { /* is metamethod a function? */
|
|
luaT_callTMres(L, tm, t, key, val); /* call it */
|
|
return;
|
|
}
|
|
t = tm; /* else try to access 'tm[key]' */
|
|
if (luaV_fastget(L, t, key, slot, luaH_get)) { /* fast track? */
|
|
setobj2s(L, val, slot); /* done */
|
|
return;
|
|
}
|
|
/* else repeat (tail call 'luaV_finishget') */
|
|
}
|
|
luaG_runerror(L, "'__index' chain too long; possible loop");
|
|
}
|
|
|
|
|
|
/*
|
|
** Finish a table assignment 't[key] = val'.
|
|
** If 'slot' is NULL, 't' is not a table. Otherwise, 'slot' points
|
|
** to the entry 't[key]', or to a value with an absent key if there
|
|
** is no such entry. (The value at 'slot' must be empty, otherwise
|
|
** 'luaV_fastget' would have done the job.)
|
|
*/
|
|
void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
|
|
TValue *val, const TValue *slot) {
|
|
int loop; /* counter to avoid infinite loops */
|
|
for (loop = 0; loop < MAXTAGLOOP; loop++) {
|
|
const TValue *tm; /* '__newindex' metamethod */
|
|
if (slot != NULL) { /* is 't' a table? */
|
|
Table *h = hvalue(t); /* save 't' table */
|
|
lua_assert(isempty(slot)); /* slot must be empty */
|
|
tm = fasttm(L, h->metatable, TM_NEWINDEX); /* get metamethod */
|
|
if (tm == NULL) { /* no metamethod? */
|
|
if (isabstkey(slot)) /* no previous entry? */
|
|
slot = luaH_newkey(L, h, key); /* create one */
|
|
/* no metamethod and (now) there is an entry with given key */
|
|
setobj2t(L, cast(TValue *, slot), val); /* set its new value */
|
|
invalidateTMcache(h);
|
|
luaC_barrierback(L, obj2gco(h), val);
|
|
return;
|
|
}
|
|
/* else will try the metamethod */
|
|
}
|
|
else { /* not a table; check metamethod */
|
|
tm = luaT_gettmbyobj(L, t, TM_NEWINDEX);
|
|
if (unlikely(notm(tm)))
|
|
luaG_typeerror(L, t, "index");
|
|
}
|
|
/* try the metamethod */
|
|
if (ttisfunction(tm)) {
|
|
luaT_callTM(L, tm, t, key, val);
|
|
return;
|
|
}
|
|
t = tm; /* else repeat assignment over 'tm' */
|
|
if (luaV_fastget(L, t, key, slot, luaH_get)) {
|
|
luaV_finishfastset(L, t, slot, val);
|
|
return; /* done */
|
|
}
|
|
/* else 'return luaV_finishset(L, t, key, val, slot)' (loop) */
|
|
}
|
|
luaG_runerror(L, "'__newindex' chain too long; possible loop");
|
|
}
|
|
|
|
|
|
/*
|
|
** Compare two strings 'ls' x 'rs', returning an integer less-equal-
|
|
** -greater than zero if 'ls' is less-equal-greater 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 = tsslen(ls);
|
|
const char *r = getstr(rs);
|
|
size_t lr = tsslen(rs);
|
|
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 less 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;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Check whether integer 'i' is less than float 'f'. If 'i' has an
|
|
** exact representation as a float ('l_intfitsf'), compare numbers as
|
|
** floats. Otherwise, use the equivalence 'i < f <=> i < ceil(f)'.
|
|
** If 'ceil(f)' is out of integer range, either 'f' is greater than
|
|
** all integers or less than all integers.
|
|
** (The test with 'l_intfitsf' is only for performance; the else
|
|
** case is correct for all values, but it is slow due to the conversion
|
|
** from float to int.)
|
|
** When 'f' is NaN, comparisons must result in false.
|
|
*/
|
|
static int LTintfloat (lua_Integer i, lua_Number f) {
|
|
if (l_intfitsf(i))
|
|
return luai_numlt(cast_num(i), f); /* compare them as floats */
|
|
else { /* i < f <=> i < ceil(f) */
|
|
lua_Integer fi;
|
|
if (luaV_flttointeger(f, &fi, 2)) /* fi = ceil(f) */
|
|
return i < fi; /* compare them as integers */
|
|
else /* 'f' is either greater or less than all integers */
|
|
return f > 0; /* greater? */
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Check whether integer 'i' is less than or equal to float 'f'.
|
|
** See comments on previous function.
|
|
*/
|
|
static int LEintfloat (lua_Integer i, lua_Number f) {
|
|
if (l_intfitsf(i))
|
|
return luai_numle(cast_num(i), f); /* compare them as floats */
|
|
else { /* i <= f <=> i <= floor(f) */
|
|
lua_Integer fi;
|
|
if (luaV_flttointeger(f, &fi, 1)) /* fi = floor(f) */
|
|
return i <= fi; /* compare them as integers */
|
|
else /* 'f' is either greater or less than all integers */
|
|
return f > 0; /* greater? */
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Check whether float 'f' is less than integer 'i'.
|
|
** See comments on previous function.
|
|
*/
|
|
static int LTfloatint (lua_Number f, lua_Integer i) {
|
|
if (l_intfitsf(i))
|
|
return luai_numlt(f, cast_num(i)); /* compare them as floats */
|
|
else { /* f < i <=> floor(f) < i */
|
|
lua_Integer fi;
|
|
if (luaV_flttointeger(f, &fi, 1)) /* fi = floor(f) */
|
|
return fi < i; /* compare them as integers */
|
|
else /* 'f' is either greater or less than all integers */
|
|
return f < 0; /* less? */
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Check whether float 'f' is less than or equal to integer 'i'.
|
|
** See comments on previous function.
|
|
*/
|
|
static int LEfloatint (lua_Number f, lua_Integer i) {
|
|
if (l_intfitsf(i))
|
|
return luai_numle(f, cast_num(i)); /* compare them as floats */
|
|
else { /* f <= i <=> ceil(f) <= i */
|
|
lua_Integer fi;
|
|
if (luaV_flttointeger(f, &fi, 2)) /* fi = ceil(f) */
|
|
return fi <= i; /* compare them as integers */
|
|
else /* 'f' is either greater or less than all integers */
|
|
return f < 0; /* less? */
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Return 'l < r', for numbers.
|
|
*/
|
|
static int LTnum (const TValue *l, const TValue *r) {
|
|
lua_assert(ttisnumber(l) && ttisnumber(r));
|
|
if (ttisinteger(l)) {
|
|
lua_Integer li = ivalue(l);
|
|
if (ttisinteger(r))
|
|
return li < ivalue(r); /* both are integers */
|
|
else /* 'l' is int and 'r' is float */
|
|
return LTintfloat(li, fltvalue(r)); /* l < r ? */
|
|
}
|
|
else {
|
|
lua_Number lf = fltvalue(l); /* 'l' must be float */
|
|
if (ttisfloat(r))
|
|
return luai_numlt(lf, fltvalue(r)); /* both are float */
|
|
else /* 'l' is float and 'r' is int */
|
|
return LTfloatint(lf, ivalue(r));
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Return 'l <= r', for numbers.
|
|
*/
|
|
static int LEnum (const TValue *l, const TValue *r) {
|
|
lua_assert(ttisnumber(l) && ttisnumber(r));
|
|
if (ttisinteger(l)) {
|
|
lua_Integer li = ivalue(l);
|
|
if (ttisinteger(r))
|
|
return li <= ivalue(r); /* both are integers */
|
|
else /* 'l' is int and 'r' is float */
|
|
return LEintfloat(li, fltvalue(r)); /* l <= r ? */
|
|
}
|
|
else {
|
|
lua_Number lf = fltvalue(l); /* 'l' must be float */
|
|
if (ttisfloat(r))
|
|
return luai_numle(lf, fltvalue(r)); /* both are float */
|
|
else /* 'l' is float and 'r' is int */
|
|
return LEfloatint(lf, ivalue(r));
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** return 'l < r' for non-numbers.
|
|
*/
|
|
static int lessthanothers (lua_State *L, const TValue *l, const TValue *r) {
|
|
lua_assert(!ttisnumber(l) || !ttisnumber(r));
|
|
if (ttisstring(l) && ttisstring(r)) /* both are strings? */
|
|
return l_strcmp(tsvalue(l), tsvalue(r)) < 0;
|
|
else
|
|
return luaT_callorderTM(L, l, r, TM_LT);
|
|
}
|
|
|
|
|
|
/*
|
|
** Main operation less than; return 'l < r'.
|
|
*/
|
|
int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
|
|
if (ttisnumber(l) && ttisnumber(r)) /* both operands are numbers? */
|
|
return LTnum(l, r);
|
|
else return lessthanothers(L, l, r);
|
|
}
|
|
|
|
|
|
/*
|
|
** return 'l <= r' for non-numbers.
|
|
** If it needs a metamethod and there is no '__le', try '__lt', based
|
|
** on l <= r iff !(r < l) (assuming a total order). If the metamethod
|
|
** yields during this substitution, the continuation has to know about
|
|
** it (to negate the result of r<l); bit CIST_LEQ in the call status
|
|
** keeps that information.
|
|
*/
|
|
static int lessequalothers (lua_State *L, const TValue *l, const TValue *r) {
|
|
lua_assert(!ttisnumber(l) || !ttisnumber(r));
|
|
if (ttisstring(l) && ttisstring(r)) /* both are strings? */
|
|
return l_strcmp(tsvalue(l), tsvalue(r)) <= 0;
|
|
else
|
|
return luaT_callorderTM(L, l, r, TM_LE);
|
|
}
|
|
|
|
|
|
/*
|
|
** Main operation less than or equal to; return 'l <= r'.
|
|
*/
|
|
int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) {
|
|
if (ttisnumber(l) && ttisnumber(r)) /* both operands are numbers? */
|
|
return LEnum(l, r);
|
|
else return lessequalothers(L, l, r);
|
|
}
|
|
|
|
|
|
/*
|
|
** 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 (ttypetag(t1) != ttypetag(t2)) { /* not the same variant? */
|
|
if (ttype(t1) != ttype(t2) || ttype(t1) != LUA_TNUMBER)
|
|
return 0; /* only numbers can be equal with different variants */
|
|
else { /* two numbers with different variants */
|
|
lua_Integer i1, i2; /* compare them as integers */
|
|
return (tointegerns(t1, &i1) && tointegerns(t2, &i2) && i1 == i2);
|
|
}
|
|
}
|
|
/* values have same type and same variant */
|
|
switch (ttypetag(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 */
|
|
else {
|
|
L->top = L->ci->top;
|
|
luaT_callTMres(L, tm, t1, t2, L->top); /* call TM */
|
|
return !l_isfalse(s2v(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)))
|
|
|
|
#define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0)
|
|
|
|
/* copy strings in stack from top - n up to top - 1 to buffer */
|
|
static void copy2buff (StkId top, int n, char *buff) {
|
|
size_t tl = 0; /* size already copied */
|
|
do {
|
|
size_t l = vslen(s2v(top - n)); /* length of string being copied */
|
|
memcpy(buff + tl, svalue(s2v(top - n)), l * sizeof(char));
|
|
tl += l;
|
|
} while (--n > 0);
|
|
}
|
|
|
|
|
|
/*
|
|
** 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(s2v(top - 2)) || cvt2str(s2v(top - 2))) ||
|
|
!tostring(L, s2v(top - 1)))
|
|
luaT_tryconcatTM(L);
|
|
else if (isemptystr(s2v(top - 1))) /* second operand is empty? */
|
|
cast_void(tostring(L, s2v(top - 2))); /* result is first operand */
|
|
else if (isemptystr(s2v(top - 2))) { /* first operand is empty string? */
|
|
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 = vslen(s2v(top - 1));
|
|
TString *ts;
|
|
/* collect total length and number of strings */
|
|
for (n = 1; n < total && tostring(L, s2v(top - n - 1)); n++) {
|
|
size_t l = vslen(s2v(top - n - 1));
|
|
if (unlikely(l >= (MAX_SIZE/sizeof(char)) - tl))
|
|
luaG_runerror(L, "string length overflow");
|
|
tl += l;
|
|
}
|
|
if (tl <= LUAI_MAXSHORTLEN) { /* is result a short string? */
|
|
char buff[LUAI_MAXSHORTLEN];
|
|
copy2buff(top, n, buff); /* copy strings to buffer */
|
|
ts = luaS_newlstr(L, buff, tl);
|
|
}
|
|
else { /* long string; copy strings directly to final result */
|
|
ts = luaS_createlngstrobj(L, tl);
|
|
copy2buff(top, n, getstr(ts));
|
|
}
|
|
setsvalue2s(L, top - n, ts); /* 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 (ttypetag(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(s2v(ra), luaH_getn(h)); /* else primitive len */
|
|
return;
|
|
}
|
|
case LUA_TSHRSTR: {
|
|
setivalue(s2v(ra), tsvalue(rb)->shrlen);
|
|
return;
|
|
}
|
|
case LUA_TLNGSTR: {
|
|
setivalue(s2v(ra), tsvalue(rb)->u.lnglen);
|
|
return;
|
|
}
|
|
default: { /* try metamethod */
|
|
tm = luaT_gettmbyobj(L, rb, TM_LEN);
|
|
if (unlikely(notm(tm))) /* no metamethod? */
|
|
luaG_typeerror(L, rb, "get length of");
|
|
break;
|
|
}
|
|
}
|
|
luaT_callTMres(L, tm, rb, rb, ra);
|
|
}
|
|
|
|
|
|
/*
|
|
** Integer division; return 'm // n', that is, floor(m/n).
|
|
** C division truncates its result (rounds towards zero).
|
|
** 'floor(q) == trunc(q)' when 'q >= 0' or when 'q' is integer,
|
|
** otherwise 'floor(q) == trunc(q) - 1'.
|
|
*/
|
|
lua_Integer luaV_idiv (lua_State *L, lua_Integer m, lua_Integer n) {
|
|
if (unlikely(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 q = m / n; /* perform C division */
|
|
if ((m ^ n) < 0 && m % n != 0) /* 'm/n' would be negative non-integer? */
|
|
q -= 1; /* correct result for different rounding */
|
|
return q;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Integer modulus; return 'm % n'. (Assume that C '%' with
|
|
** negative operands follows C99 behavior. See previous comment
|
|
** about luaV_idiv.)
|
|
*/
|
|
lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) {
|
|
if (unlikely(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 && (r ^ n) < 0) /* 'm/n' would be non-integer negative? */
|
|
r += n; /* correct result for different rounding */
|
|
return r;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** Float modulus
|
|
*/
|
|
lua_Number luaV_modf (lua_State *L, lua_Number m, lua_Number n) {
|
|
lua_Number r;
|
|
luai_nummod(L, m, n, r);
|
|
return r;
|
|
}
|
|
|
|
|
|
/* 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);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** create a new Lua closure, push it in the stack, and initialize
|
|
** its upvalues.
|
|
*/
|
|
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;
|
|
setclLvalue2s(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];
|
|
luaC_objbarrier(L, ncl, ncl->upvals[i]);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** finish execution of an opcode interrupted by a yield
|
|
*/
|
|
void luaV_finishOp (lua_State *L) {
|
|
CallInfo *ci = L->ci;
|
|
StkId base = ci->func + 1;
|
|
Instruction inst = *(ci->u.l.savedpc - 1); /* interrupted instruction */
|
|
OpCode op = GET_OPCODE(inst);
|
|
switch (op) { /* finish its execution */
|
|
case OP_ADDI: case OP_SUBI:
|
|
case OP_MULI: case OP_DIVI: case OP_IDIVI:
|
|
case OP_MODI: case OP_POWI:
|
|
case OP_ADDK: case OP_SUBK:
|
|
case OP_MULK: case OP_DIVK: case OP_IDIVK:
|
|
case OP_MODK: case OP_POWK:
|
|
case OP_ADD: case OP_SUB:
|
|
case OP_MUL: case OP_DIV: case OP_IDIV:
|
|
case OP_BANDK: case OP_BORK: case OP_BXORK:
|
|
case OP_BAND: case OP_BOR: case OP_BXOR:
|
|
case OP_SHLI: case OP_SHRI: 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_GETI:
|
|
case OP_GETFIELD: case OP_SELF: {
|
|
setobjs2s(L, base + GETARG_A(inst), --L->top);
|
|
break;
|
|
}
|
|
case OP_LT: case OP_LE:
|
|
case OP_LTI: case OP_LEI:
|
|
case OP_GTI: case OP_GEI:
|
|
case OP_EQ: { /* note that 'OP_EQI'/'OP_EQK' cannot yield */
|
|
int res = !l_isfalse(s2v(L->top - 1));
|
|
L->top--;
|
|
#if defined(LUA_COMPAT_LT_LE)
|
|
if (ci->callstatus & CIST_LEQ) { /* "<=" using "<" instead? */
|
|
ci->callstatus ^= CIST_LEQ; /* clear mark */
|
|
res = !res; /* negate result */
|
|
}
|
|
#endif
|
|
lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_JMP);
|
|
if (res != GETARG_k(inst)) /* condition failed? */
|
|
ci->u.l.savedpc++; /* skip jump instruction */
|
|
break;
|
|
}
|
|
case OP_CONCAT: {
|
|
StkId top = L->top - 1; /* top when 'luaT_tryconcatTM' was called */
|
|
int a = GETARG_A(inst); /* first element to concatenate */
|
|
int total = cast_int(top - 1 - (base + a)); /* yet to concatenate */
|
|
setobjs2s(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) */
|
|
}
|
|
break;
|
|
}
|
|
default: {
|
|
/* only these other opcodes can yield */
|
|
lua_assert(op == OP_TFORCALL || op == OP_CALL ||
|
|
op == OP_TAILCALL || op == OP_SETTABUP || op == OP_SETTABLE ||
|
|
op == OP_SETI || op == OP_SETFIELD);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
** {==================================================================
|
|
** Macros for arithmetic/bitwise/comparison opcodes in 'luaV_execute'
|
|
** ===================================================================
|
|
*/
|
|
|
|
#define l_addi(L,a,b) intop(+, a, b)
|
|
#define l_subi(L,a,b) intop(-, a, b)
|
|
#define l_muli(L,a,b) intop(*, a, b)
|
|
#define l_band(L,a,b) intop(&, a, b)
|
|
#define l_bor(L,a,b) intop(|, a, b)
|
|
#define l_bxor(L,a,b) intop(^, a, b)
|
|
|
|
#define l_lti(a,b) (a < b)
|
|
#define l_lei(a,b) (a <= b)
|
|
#define l_gti(a,b) (a > b)
|
|
#define l_gei(a,b) (a >= b)
|
|
|
|
|
|
/*
|
|
** Auxiliary macro for arithmetic operations over floats and others
|
|
** with immediate operand. 'fop' is the float operation; 'tm' is the
|
|
** corresponding metamethod; 'flip' is true if operands were flipped.
|
|
*/
|
|
#define op_arithfI_aux(L,v1,imm,fop,tm,flip) { \
|
|
lua_Number nb; \
|
|
if (tonumberns(v1, nb)) { \
|
|
lua_Number fimm = cast_num(imm); \
|
|
setfltvalue(s2v(ra), fop(L, nb, fimm)); \
|
|
} \
|
|
else \
|
|
ProtectNT(luaT_trybiniTM(L, v1, imm, flip, ra, tm)); }
|
|
|
|
|
|
/*
|
|
** Arithmetic operations over floats and others with immediate operand.
|
|
*/
|
|
#define op_arithfI(L,fop,tm) { \
|
|
TValue *v1 = vRB(i); \
|
|
int imm = GETARG_sC(i); \
|
|
op_arithfI_aux(L, v1, imm, fop, tm, 0); }
|
|
|
|
/*
|
|
** Arithmetic operations with immediate operands. 'iop' is the integer
|
|
** operation.
|
|
*/
|
|
#define op_arithI(L,iop,fop,tm,flip) { \
|
|
TValue *v1 = vRB(i); \
|
|
int imm = GETARG_sC(i); \
|
|
if (ttisinteger(v1)) { \
|
|
lua_Integer iv1 = ivalue(v1); \
|
|
setivalue(s2v(ra), iop(L, iv1, imm)); \
|
|
} \
|
|
else op_arithfI_aux(L, v1, imm, fop, tm, flip); }
|
|
|
|
|
|
/*
|
|
** Auxiliary function for arithmetic operations over floats and others
|
|
** with two register operands.
|
|
*/
|
|
#define op_arithf_aux(L,v1,v2,fop,tm) { \
|
|
lua_Number n1; lua_Number n2; \
|
|
if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \
|
|
setfltvalue(s2v(ra), fop(L, n1, n2)); \
|
|
} \
|
|
else \
|
|
ProtectNT(luaT_trybinTM(L, v1, v2, ra, tm)); }
|
|
|
|
|
|
/*
|
|
** Arithmetic operations over floats and others with register operands.
|
|
*/
|
|
#define op_arithf(L,fop,tm) { \
|
|
TValue *v1 = vRB(i); \
|
|
TValue *v2 = vRC(i); \
|
|
op_arithf_aux(L, v1, v2, fop, tm); }
|
|
|
|
|
|
/*
|
|
** Arithmetic operations with register operands.
|
|
*/
|
|
#define op_arith(L,iop,fop,tm) { \
|
|
TValue *v1 = vRB(i); \
|
|
TValue *v2 = vRC(i); \
|
|
if (ttisinteger(v1) && ttisinteger(v2)) { \
|
|
lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \
|
|
setivalue(s2v(ra), iop(L, i1, i2)); \
|
|
} \
|
|
else op_arithf_aux(L, v1, v2, fop, tm); }
|
|
|
|
|
|
/*
|
|
** Arithmetic operations with K operands.
|
|
*/
|
|
#define op_arithK(L,iop,fop,tm,flip) { \
|
|
TValue *v1 = vRB(i); \
|
|
TValue *v2 = KC(i); \
|
|
if (ttisinteger(v1) && ttisinteger(v2)) { \
|
|
lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \
|
|
setivalue(s2v(ra), iop(L, i1, i2)); \
|
|
} \
|
|
else { \
|
|
lua_Number n1; lua_Number n2; \
|
|
if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \
|
|
setfltvalue(s2v(ra), fop(L, n1, n2)); \
|
|
} \
|
|
else \
|
|
ProtectNT(luaT_trybinassocTM(L, v1, v2, ra, flip, tm)); } }
|
|
|
|
|
|
/*
|
|
** Arithmetic operations with K operands for floats.
|
|
*/
|
|
#define op_arithfK(L,fop,tm) { \
|
|
TValue *v1 = vRB(i); \
|
|
TValue *v2 = KC(i); \
|
|
lua_Number n1; lua_Number n2; \
|
|
if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \
|
|
setfltvalue(s2v(ra), fop(L, n1, n2)); \
|
|
} \
|
|
else \
|
|
ProtectNT(luaT_trybinTM(L, v1, v2, ra, tm)); }
|
|
|
|
|
|
/*
|
|
** Bitwise operations with constant operand.
|
|
*/
|
|
#define op_bitwiseK(L,op,tm) { \
|
|
TValue *v1 = vRB(i); \
|
|
TValue *v2 = KC(i); \
|
|
lua_Integer i1; \
|
|
lua_Integer i2 = ivalue(v2); \
|
|
if (tointegerns(v1, &i1)) { \
|
|
setivalue(s2v(ra), op(L, i1, i2)); \
|
|
} \
|
|
else \
|
|
ProtectNT(luaT_trybiniTM(L, v1, i2, TESTARG_k(i), ra, tm)); }
|
|
|
|
|
|
/*
|
|
** Bitwise operations with register operands.
|
|
*/
|
|
#define op_bitwise(L,op,tm) { \
|
|
TValue *v1 = vRB(i); \
|
|
TValue *v2 = vRC(i); \
|
|
lua_Integer i1; lua_Integer i2; \
|
|
if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \
|
|
setivalue(s2v(ra), op(L, i1, i2)); \
|
|
} \
|
|
else \
|
|
ProtectNT(luaT_trybinTM(L, v1, v2, ra, tm)); }
|
|
|
|
|
|
/*
|
|
** Order operations with register operands.
|
|
*/
|
|
#define op_order(L,opi,opf,other) { \
|
|
int cond; \
|
|
TValue *rb = vRB(i); \
|
|
if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \
|
|
lua_Integer ia = ivalue(s2v(ra)); \
|
|
lua_Integer ib = ivalue(rb); \
|
|
cond = opi(ia, ib); \
|
|
} \
|
|
else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \
|
|
cond = opf(s2v(ra), rb); \
|
|
else \
|
|
ProtectNT(cond = other(L, s2v(ra), rb)); \
|
|
docondjump(); }
|
|
|
|
|
|
/*
|
|
** Order operations with immediate operand.
|
|
*/
|
|
#define op_orderI(L,opi,opf,inv,tm) { \
|
|
int cond; \
|
|
int im = GETARG_sB(i); \
|
|
if (ttisinteger(s2v(ra))) \
|
|
cond = opi(ivalue(s2v(ra)), im); \
|
|
else if (ttisfloat(s2v(ra))) { \
|
|
lua_Number fa = fltvalue(s2v(ra)); \
|
|
lua_Number fim = cast_num(im); \
|
|
cond = opf(fa, fim); \
|
|
} \
|
|
else { \
|
|
int isf = GETARG_C(i); \
|
|
ProtectNT(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \
|
|
} \
|
|
docondjump(); }
|
|
|
|
/* }================================================================== */
|
|
|
|
|
|
/*
|
|
** {==================================================================
|
|
** Function 'luaV_execute': main interpreter loop
|
|
** ===================================================================
|
|
*/
|
|
|
|
/*
|
|
** some macros for common tasks in 'luaV_execute'
|
|
*/
|
|
|
|
|
|
#define RA(i) (base+GETARG_A(i))
|
|
#define RB(i) (base+GETARG_B(i))
|
|
#define vRB(i) s2v(RB(i))
|
|
#define KB(i) (k+GETARG_B(i))
|
|
#define RC(i) (base+GETARG_C(i))
|
|
#define vRC(i) s2v(RC(i))
|
|
#define KC(i) (k+GETARG_C(i))
|
|
#define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i)))
|
|
|
|
|
|
|
|
#define updatetrap(ci) (trap = ci->u.l.trap)
|
|
|
|
#define updatebase(ci) (base = ci->func + 1)
|
|
|
|
|
|
#define updatestack(ci) { if (trap) { updatebase(ci); ra = RA(i); } }
|
|
|
|
|
|
/*
|
|
** Execute a jump instruction. The 'updatetrap' allows signals to stop
|
|
** tight loops. (Without it, the local copy of 'trap' could never change.)
|
|
*/
|
|
#define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); }
|
|
|
|
|
|
/* for test instructions, execute the jump instruction that follows it */
|
|
#define donextjump(ci) { i = *pc; dojump(ci, i, 1); }
|
|
|
|
/*
|
|
** do a conditional jump: skip next instruction if 'cond' is not what
|
|
** was expected (parameter 'k'), else do next instruction, which must
|
|
** be a jump.
|
|
*/
|
|
#define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci);
|
|
|
|
|
|
/*
|
|
** Correct global 'pc'.
|
|
*/
|
|
#define savepc(L) (ci->u.l.savedpc = pc)
|
|
|
|
|
|
/*
|
|
** Whenever code can raise errors, the global 'pc' and the global
|
|
** 'top' must be correct to report occasional errors.
|
|
*/
|
|
#define savestate(L,ci) (savepc(L), L->top = ci->top)
|
|
|
|
|
|
/*
|
|
** Protect code that, in general, can raise errors, reallocate the
|
|
** stack, and change the hooks.
|
|
*/
|
|
#define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci))
|
|
|
|
/* special version that does not change the top */
|
|
#define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci))
|
|
|
|
/*
|
|
** Protect code that will finish the loop (returns) or can only raise
|
|
** errors. (That is, it will not return to the interpreter main loop
|
|
** after changing the stack or hooks.)
|
|
*/
|
|
#define halfProtect(exp) (savestate(L,ci), (exp))
|
|
|
|
/* idem, but without changing the stack */
|
|
#define halfProtectNT(exp) (savepc(L), (exp))
|
|
|
|
|
|
#define checkGC(L,c) \
|
|
{ luaC_condGC(L, L->top = (c), /* limit of live values */ \
|
|
updatetrap(ci)); \
|
|
luai_threadyield(L); }
|
|
|
|
|
|
/* fetch an instruction and prepare its execution */
|
|
#define vmfetch() { \
|
|
if (trap) { /* stack reallocation or hooks? */ \
|
|
trap = luaG_traceexec(L, pc); /* handle hooks */ \
|
|
updatebase(ci); /* correct stack */ \
|
|
} \
|
|
i = *(pc++); \
|
|
ra = RA(i); /* WARNING: any stack reallocation invalidates 'ra' */ \
|
|
}
|
|
|
|
#define vmdispatch(o) switch(o)
|
|
#define vmcase(l) case l:
|
|
#define vmbreak break
|
|
|
|
|
|
void luaV_execute (lua_State *L, CallInfo *ci) {
|
|
LClosure *cl;
|
|
TValue *k;
|
|
StkId base;
|
|
const Instruction *pc;
|
|
int trap;
|
|
#if LUA_USE_JUMPTABLE
|
|
#include "ljumptab.h"
|
|
#endif
|
|
tailcall:
|
|
trap = L->hookmask;
|
|
cl = clLvalue(s2v(ci->func));
|
|
k = cl->p->k;
|
|
pc = ci->u.l.savedpc;
|
|
if (trap) {
|
|
if (cl->p->is_vararg)
|
|
trap = 0; /* hooks will start after VARARGPREP instruction */
|
|
else if (pc == cl->p->code) /* first instruction (not resuming)? */
|
|
luaD_hookcall(L, ci);
|
|
ci->u.l.trap = 1; /* there may be other hooks */
|
|
}
|
|
base = ci->func + 1;
|
|
/* main loop of interpreter */
|
|
for (;;) {
|
|
Instruction i; /* instruction being executed */
|
|
StkId ra; /* instruction's A register */
|
|
vmfetch();
|
|
lua_assert(base == ci->func + 1);
|
|
lua_assert(base <= L->top && L->top < L->stack + L->stacksize);
|
|
/* invalidate top for instructions not expecting it */
|
|
lua_assert(isIT(i) || (L->top = base));
|
|
vmdispatch (GET_OPCODE(i)) {
|
|
vmcase(OP_MOVE) {
|
|
setobjs2s(L, ra, RB(i));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_LOADI) {
|
|
lua_Integer b = GETARG_sBx(i);
|
|
setivalue(s2v(ra), b);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_LOADF) {
|
|
int b = GETARG_sBx(i);
|
|
setfltvalue(s2v(ra), cast_num(b));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_LOADK) {
|
|
TValue *rb = k + GETARG_Bx(i);
|
|
setobj2s(L, ra, rb);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_LOADKX) {
|
|
TValue *rb;
|
|
rb = k + GETARG_Ax(*pc); pc++;
|
|
setobj2s(L, ra, rb);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_LOADBOOL) {
|
|
setbvalue(s2v(ra), GETARG_B(i));
|
|
if (GETARG_C(i)) pc++; /* skip next instruction (if C) */
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_LOADNIL) {
|
|
int b = GETARG_B(i);
|
|
do {
|
|
setnilvalue(s2v(ra++));
|
|
} while (b--);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_GETUPVAL) {
|
|
int b = GETARG_B(i);
|
|
setobj2s(L, ra, cl->upvals[b]->v);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SETUPVAL) {
|
|
UpVal *uv = cl->upvals[GETARG_B(i)];
|
|
setobj(L, uv->v, s2v(ra));
|
|
luaC_barrier(L, uv, s2v(ra));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_GETTABUP) {
|
|
const TValue *slot;
|
|
TValue *upval = cl->upvals[GETARG_B(i)]->v;
|
|
TValue *rc = KC(i);
|
|
TString *key = tsvalue(rc); /* key must be a string */
|
|
if (luaV_fastget(L, upval, key, slot, luaH_getshortstr)) {
|
|
setobj2s(L, ra, slot);
|
|
}
|
|
else
|
|
Protect(luaV_finishget(L, upval, rc, ra, slot));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_GETTABLE) {
|
|
const TValue *slot;
|
|
TValue *rb = vRB(i);
|
|
TValue *rc = vRC(i);
|
|
lua_Unsigned n;
|
|
if (ttisinteger(rc) /* fast track for integers? */
|
|
? (cast_void(n = ivalue(rc)), luaV_fastgeti(L, rb, n, slot))
|
|
: luaV_fastget(L, rb, rc, slot, luaH_get)) {
|
|
setobj2s(L, ra, slot);
|
|
}
|
|
else
|
|
Protect(luaV_finishget(L, rb, rc, ra, slot));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_GETI) {
|
|
const TValue *slot;
|
|
TValue *rb = vRB(i);
|
|
int c = GETARG_C(i);
|
|
if (luaV_fastgeti(L, rb, c, slot)) {
|
|
setobj2s(L, ra, slot);
|
|
}
|
|
else {
|
|
TValue key;
|
|
setivalue(&key, c);
|
|
Protect(luaV_finishget(L, rb, &key, ra, slot));
|
|
}
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_GETFIELD) {
|
|
const TValue *slot;
|
|
TValue *rb = vRB(i);
|
|
TValue *rc = KC(i);
|
|
TString *key = tsvalue(rc); /* key must be a string */
|
|
if (luaV_fastget(L, rb, key, slot, luaH_getshortstr)) {
|
|
setobj2s(L, ra, slot);
|
|
}
|
|
else
|
|
Protect(luaV_finishget(L, rb, rc, ra, slot));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SETTABUP) {
|
|
const TValue *slot;
|
|
TValue *upval = cl->upvals[GETARG_A(i)]->v;
|
|
TValue *rb = KB(i);
|
|
TValue *rc = RKC(i);
|
|
TString *key = tsvalue(rb); /* key must be a string */
|
|
if (luaV_fastget(L, upval, key, slot, luaH_getshortstr)) {
|
|
luaV_finishfastset(L, upval, slot, rc);
|
|
}
|
|
else
|
|
Protect(luaV_finishset(L, upval, rb, rc, slot));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SETTABLE) {
|
|
const TValue *slot;
|
|
TValue *rb = vRB(i); /* key (table is in 'ra') */
|
|
TValue *rc = RKC(i); /* value */
|
|
lua_Unsigned n;
|
|
if (ttisinteger(rb) /* fast track for integers? */
|
|
? (cast_void(n = ivalue(rb)), luaV_fastgeti(L, s2v(ra), n, slot))
|
|
: luaV_fastget(L, s2v(ra), rb, slot, luaH_get)) {
|
|
luaV_finishfastset(L, s2v(ra), slot, rc);
|
|
}
|
|
else
|
|
Protect(luaV_finishset(L, s2v(ra), rb, rc, slot));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SETI) {
|
|
const TValue *slot;
|
|
int c = GETARG_B(i);
|
|
TValue *rc = RKC(i);
|
|
if (luaV_fastgeti(L, s2v(ra), c, slot)) {
|
|
luaV_finishfastset(L, s2v(ra), slot, rc);
|
|
}
|
|
else {
|
|
TValue key;
|
|
setivalue(&key, c);
|
|
Protect(luaV_finishset(L, s2v(ra), &key, rc, slot));
|
|
}
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SETFIELD) {
|
|
const TValue *slot;
|
|
TValue *rb = KB(i);
|
|
TValue *rc = RKC(i);
|
|
TString *key = tsvalue(rb); /* key must be a string */
|
|
if (luaV_fastget(L, s2v(ra), key, slot, luaH_getshortstr)) {
|
|
luaV_finishfastset(L, s2v(ra), slot, rc);
|
|
}
|
|
else
|
|
Protect(luaV_finishset(L, s2v(ra), rb, rc, slot));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_NEWTABLE) {
|
|
int b = GETARG_B(i); /* log2(hash size) + 1 */
|
|
int c = GETARG_C(i); /* array size */
|
|
Table *t;
|
|
if (b > 0)
|
|
b = 1 << (b - 1); /* size is 2^(b - 1) */
|
|
if (TESTARG_k(i))
|
|
c += GETARG_Ax(*pc) * (MAXARG_C + 1);
|
|
pc++; /* skip extra argument */
|
|
L->top = ra + 1; /* correct top in case of emergency GC */
|
|
t = luaH_new(L); /* memory allocation */
|
|
sethvalue2s(L, ra, t);
|
|
if (b != 0 || c != 0)
|
|
luaH_resize(L, t, c, b); /* idem */
|
|
checkGC(L, ra + 1);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SELF) {
|
|
const TValue *slot;
|
|
TValue *rb = vRB(i);
|
|
TValue *rc = RKC(i);
|
|
TString *key = tsvalue(rc); /* key must be a string */
|
|
setobj2s(L, ra + 1, rb);
|
|
if (luaV_fastget(L, rb, key, slot, luaH_getstr)) {
|
|
setobj2s(L, ra, slot);
|
|
}
|
|
else
|
|
Protect(luaV_finishget(L, rb, rc, ra, slot));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_ADDI) {
|
|
op_arithI(L, l_addi, luai_numadd, TM_ADD, GETARG_k(i));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SUBI) {
|
|
op_arithI(L, l_subi, luai_numsub, TM_SUB, 0);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_MULI) {
|
|
op_arithI(L, l_muli, luai_nummul, TM_MUL, GETARG_k(i));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_MODI) {
|
|
op_arithI(L, luaV_mod, luaV_modf, TM_MOD, 0);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_POWI) {
|
|
op_arithfI(L, luai_numpow, TM_POW);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_DIVI) {
|
|
op_arithfI(L, luai_numdiv, TM_DIV);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_IDIVI) {
|
|
op_arithI(L, luaV_idiv, luai_numidiv, TM_IDIV, 0);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_ADDK) {
|
|
op_arithK(L, l_addi, luai_numadd, TM_ADD, GETARG_k(i));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SUBK) {
|
|
op_arithK(L, l_subi, luai_numsub, TM_SUB, 0);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_MULK) {
|
|
op_arithK(L, l_muli, luai_nummul, TM_MUL, GETARG_k(i));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_MODK) {
|
|
op_arithK(L, luaV_mod, luaV_modf, TM_MOD, 0);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_POWK) {
|
|
op_arithfK(L, luai_numpow, TM_POW);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_DIVK) {
|
|
op_arithfK(L, luai_numdiv, TM_DIV);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_IDIVK) {
|
|
op_arithK(L, luaV_idiv, luai_numidiv, TM_IDIV, 0);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_BANDK) {
|
|
op_bitwiseK(L, l_band, TM_BAND);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_BORK) {
|
|
op_bitwiseK(L, l_bor, TM_BOR);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_BXORK) {
|
|
op_bitwiseK(L, l_bxor, TM_BXOR);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SHRI) {
|
|
TValue *rb = vRB(i);
|
|
int ic = GETARG_sC(i);
|
|
lua_Integer ib;
|
|
if (tointegerns(rb, &ib)) {
|
|
setivalue(s2v(ra), luaV_shiftl(ib, -ic));
|
|
}
|
|
else {
|
|
TMS ev = TM_SHR;
|
|
if (TESTARG_k(i)) {
|
|
ic = -ic; ev = TM_SHL;
|
|
}
|
|
ProtectNT(luaT_trybiniTM(L, rb, ic, 0, ra, ev));
|
|
}
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SHLI) {
|
|
TValue *rb = vRB(i);
|
|
int ic = GETARG_sC(i);
|
|
lua_Integer ib;
|
|
if (tointegerns(rb, &ib)) {
|
|
setivalue(s2v(ra), luaV_shiftl(ic, ib));
|
|
}
|
|
else
|
|
ProtectNT(luaT_trybiniTM(L, rb, ic, 1, ra, TM_SHL));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_ADD) {
|
|
op_arith(L, l_addi, luai_numadd, TM_ADD);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SUB) {
|
|
op_arith(L, l_subi, luai_numsub, TM_SUB);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_MUL) {
|
|
op_arith(L, l_muli, luai_nummul, TM_MUL);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_MOD) {
|
|
op_arith(L, luaV_mod, luaV_modf, TM_MOD);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_POW) {
|
|
op_arithf(L, luai_numpow, TM_POW);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_DIV) { /* float division (always with floats) */
|
|
op_arithf(L, luai_numdiv, TM_DIV);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_IDIV) { /* floor division */
|
|
op_arith(L, luaV_idiv, luai_numidiv, TM_IDIV);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_BAND) {
|
|
op_bitwise(L, l_band, TM_BAND);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_BOR) {
|
|
op_bitwise(L, l_bor, TM_BOR);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_BXOR) {
|
|
op_bitwise(L, l_bxor, TM_BXOR);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SHR) {
|
|
TValue *rb = vRB(i);
|
|
TValue *rc = vRC(i);
|
|
lua_Integer ib; lua_Integer ic;
|
|
if (tointegerns(rb, &ib) && tointegerns(rc, &ic)) {
|
|
setivalue(s2v(ra), luaV_shiftl(ib, -ic));
|
|
}
|
|
else
|
|
ProtectNT(luaT_trybinTM(L, rb, rc, ra, TM_SHR));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SHL) {
|
|
TValue *rb = vRB(i);
|
|
TValue *rc = vRC(i);
|
|
lua_Integer ib; lua_Integer ic;
|
|
if (tointegerns(rb, &ib) && tointegerns(rc, &ic)) {
|
|
setivalue(s2v(ra), luaV_shiftl(ib, ic));
|
|
}
|
|
else
|
|
ProtectNT(luaT_trybinTM(L, rb, rc, ra, TM_SHL));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_UNM) {
|
|
TValue *rb = vRB(i);
|
|
lua_Number nb;
|
|
if (ttisinteger(rb)) {
|
|
lua_Integer ib = ivalue(rb);
|
|
setivalue(s2v(ra), intop(-, 0, ib));
|
|
}
|
|
else if (tonumberns(rb, nb)) {
|
|
setfltvalue(s2v(ra), luai_numunm(L, nb));
|
|
}
|
|
else
|
|
ProtectNT(luaT_trybinTM(L, rb, rb, ra, TM_UNM));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_BNOT) {
|
|
TValue *rb = vRB(i);
|
|
lua_Integer ib;
|
|
if (tointegerns(rb, &ib)) {
|
|
setivalue(s2v(ra), intop(^, ~l_castS2U(0), ib));
|
|
}
|
|
else
|
|
ProtectNT(luaT_trybinTM(L, rb, rb, ra, TM_BNOT));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_NOT) {
|
|
TValue *rb = vRB(i);
|
|
int nrb = l_isfalse(rb); /* next assignment may change this value */
|
|
setbvalue(s2v(ra), nrb);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_LEN) {
|
|
Protect(luaV_objlen(L, ra, vRB(i)));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_CONCAT) {
|
|
int n = GETARG_B(i); /* number of elements to concatenate */
|
|
L->top = ra + n; /* mark the end of concat operands */
|
|
ProtectNT(luaV_concat(L, n));
|
|
checkGC(L, L->top); /* 'luaV_concat' ensures correct top */
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_CLOSE) {
|
|
Protect(luaF_close(L, ra, LUA_OK));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_TBC) {
|
|
/* create new to-be-closed upvalue */
|
|
halfProtect(luaF_newtbcupval(L, ra));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_JMP) {
|
|
dojump(ci, i, 0);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_EQ) {
|
|
int cond;
|
|
TValue *rb = vRB(i);
|
|
ProtectNT(cond = luaV_equalobj(L, s2v(ra), rb));
|
|
docondjump();
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_LT) {
|
|
op_order(L, l_lti, LTnum, lessthanothers);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_LE) {
|
|
op_order(L, l_lei, LEnum, lessequalothers);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_EQK) {
|
|
TValue *rb = KB(i);
|
|
/* basic types do not use '__eq'; we can use raw equality */
|
|
int cond = luaV_equalobj(NULL, s2v(ra), rb);
|
|
docondjump();
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_EQI) {
|
|
int cond;
|
|
int im = GETARG_sB(i);
|
|
if (ttisinteger(s2v(ra)))
|
|
cond = (ivalue(s2v(ra)) == im);
|
|
else if (ttisfloat(s2v(ra)))
|
|
cond = luai_numeq(fltvalue(s2v(ra)), cast_num(im));
|
|
else
|
|
cond = 0; /* other types cannot be equal to a number */
|
|
docondjump();
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_LTI) {
|
|
op_orderI(L, l_lti, luai_numlt, 0, TM_LT);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_LEI) {
|
|
op_orderI(L, l_lei, luai_numle, 0, TM_LE);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_GTI) {
|
|
op_orderI(L, l_gti, luai_numgt, 1, TM_LT);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_GEI) {
|
|
op_orderI(L, l_gei, luai_numge, 1, TM_LE);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_TEST) {
|
|
int cond = !l_isfalse(s2v(ra));
|
|
docondjump();
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_TESTSET) {
|
|
TValue *rb = vRB(i);
|
|
if (l_isfalse(rb) == GETARG_k(i))
|
|
pc++;
|
|
else {
|
|
setobj2s(L, ra, rb);
|
|
donextjump(ci);
|
|
}
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_CALL) {
|
|
int b = GETARG_B(i);
|
|
int nresults = GETARG_C(i) - 1;
|
|
if (b != 0) /* fixed number of arguments? */
|
|
L->top = ra + b; /* top signals number of arguments */
|
|
/* else previous instruction set top */
|
|
ProtectNT(luaD_call(L, ra, nresults));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_TAILCALL) {
|
|
int b = GETARG_B(i); /* number of arguments + 1 (function) */
|
|
int nparams1 = GETARG_C(i);
|
|
/* delat is virtual 'func' - real 'func' (vararg functions) */
|
|
int delta = (nparams1) ? ci->u.l.nextraargs + nparams1 : 0;
|
|
if (b != 0)
|
|
L->top = ra + b;
|
|
else /* previous instruction set top */
|
|
b = cast_int(L->top - ra);
|
|
savepc(ci); /* some calls here can raise errors */
|
|
if (TESTARG_k(i)) {
|
|
/* close upvalues from current call; the compiler ensures
|
|
that there are no to-be-closed variables here, so this
|
|
call cannot change the stack */
|
|
luaF_close(L, base, NOCLOSINGMETH);
|
|
lua_assert(base == ci->func + 1);
|
|
}
|
|
if (!ttisfunction(s2v(ra))) { /* not a function? */
|
|
luaD_tryfuncTM(L, ra); /* try '__call' metamethod */
|
|
b++; /* there is now one extra argument */
|
|
}
|
|
if (!ttisLclosure(s2v(ra))) { /* C function? */
|
|
luaD_call(L, ra, LUA_MULTRET); /* call it */
|
|
updatetrap(ci);
|
|
updatestack(ci); /* stack may have been relocated */
|
|
ci->func -= delta;
|
|
luaD_poscall(L, ci, cast_int(L->top - ra));
|
|
return;
|
|
}
|
|
else { /* Lua tail call */
|
|
ci->func -= delta;
|
|
luaD_pretailcall(L, ci, ra, b); /* prepare call frame */
|
|
goto tailcall;
|
|
}
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_RETURN) {
|
|
int n = GETARG_B(i) - 1; /* number of results */
|
|
int nparams1 = GETARG_C(i);
|
|
if (n < 0) /* not fixed? */
|
|
n = cast_int(L->top - ra); /* get what is available */
|
|
savepc(ci);
|
|
if (TESTARG_k(i)) { /* may there be open upvalues? */
|
|
if (L->top < ci->top)
|
|
L->top = ci->top;
|
|
luaF_close(L, base, LUA_OK);
|
|
updatetrap(ci);
|
|
updatestack(ci);
|
|
}
|
|
if (nparams1) /* vararg function? */
|
|
ci->func -= ci->u.l.nextraargs + nparams1;
|
|
L->top = ra + n; /* set call for 'luaD_poscall' */
|
|
luaD_poscall(L, ci, n);
|
|
return;
|
|
}
|
|
vmcase(OP_RETURN0) {
|
|
if (L->hookmask) {
|
|
L->top = ra;
|
|
halfProtectNT(luaD_poscall(L, ci, 0)); /* no hurry... */
|
|
}
|
|
else { /* do the 'poscall' here */
|
|
int nres = ci->nresults;
|
|
L->ci = ci->previous; /* back to caller */
|
|
L->top = base - 1;
|
|
while (nres-- > 0)
|
|
setnilvalue(s2v(L->top++)); /* all results are nil */
|
|
}
|
|
return;
|
|
}
|
|
vmcase(OP_RETURN1) {
|
|
if (L->hookmask) {
|
|
L->top = ra + 1;
|
|
halfProtectNT(luaD_poscall(L, ci, 1)); /* no hurry... */
|
|
}
|
|
else { /* do the 'poscall' here */
|
|
int nres = ci->nresults;
|
|
L->ci = ci->previous; /* back to caller */
|
|
if (nres == 0)
|
|
L->top = base - 1; /* asked for no results */
|
|
else {
|
|
setobjs2s(L, base - 1, ra); /* at least this result */
|
|
L->top = base;
|
|
while (--nres > 0) /* complete missing results */
|
|
setnilvalue(s2v(L->top++));
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
vmcase(OP_FORLOOP) {
|
|
if (ttisinteger(s2v(ra + 2))) { /* integer loop? */
|
|
lua_Unsigned count = l_castS2U(ivalue(s2v(ra + 1)));
|
|
if (count > 0) { /* still more iterations? */
|
|
lua_Integer step = ivalue(s2v(ra + 2));
|
|
lua_Integer idx = ivalue(s2v(ra)); /* internal index */
|
|
chgivalue(s2v(ra + 1), count - 1); /* update counter */
|
|
idx = intop(+, idx, step); /* add step to index */
|
|
chgivalue(s2v(ra), idx); /* update internal index */
|
|
setivalue(s2v(ra + 3), idx); /* and control variable */
|
|
pc -= GETARG_Bx(i); /* jump back */
|
|
}
|
|
}
|
|
else { /* floating loop */
|
|
lua_Number step = fltvalue(s2v(ra + 2));
|
|
lua_Number limit = fltvalue(s2v(ra + 1));
|
|
lua_Number idx = fltvalue(s2v(ra));
|
|
idx = luai_numadd(L, idx, step); /* increment index */
|
|
if (luai_numlt(0, step) ? luai_numle(idx, limit)
|
|
: luai_numle(limit, idx)) {
|
|
chgfltvalue(s2v(ra), idx); /* update internal index */
|
|
setfltvalue(s2v(ra + 3), idx); /* and control variable */
|
|
pc -= GETARG_Bx(i); /* jump back */
|
|
}
|
|
}
|
|
updatetrap(ci); /* allows a signal to break the loop */
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_FORPREP) {
|
|
TValue *pinit = s2v(ra);
|
|
TValue *plimit = s2v(ra + 1);
|
|
TValue *pstep = s2v(ra + 2);
|
|
savestate(L, ci); /* in case of errors */
|
|
if (ttisinteger(pinit) && ttisinteger(pstep)) { /* integer loop? */
|
|
lua_Integer init = ivalue(pinit);
|
|
lua_Integer step = ivalue(pstep);
|
|
lua_Integer limit;
|
|
if (step == 0)
|
|
luaG_runerror(L, "'for' step is zero");
|
|
setivalue(s2v(ra + 3), init); /* control variable */
|
|
if (forlimit(L, init, plimit, &limit, step))
|
|
pc += GETARG_Bx(i) + 1; /* skip the loop */
|
|
else { /* prepare loop counter */
|
|
lua_Unsigned count;
|
|
if (step > 0) { /* ascending loop? */
|
|
count = l_castS2U(limit) - l_castS2U(init);
|
|
if (step != 1) /* avoid division in the too common case */
|
|
count /= l_castS2U(step);
|
|
}
|
|
else { /* step < 0; descending loop */
|
|
count = l_castS2U(init) - l_castS2U(limit);
|
|
/* 'step+1' avoids negating 'mininteger' */
|
|
count /= l_castS2U(-(step + 1)) + 1u;
|
|
}
|
|
/* store the counter in place of the limit (which won't be
|
|
needed anymore */
|
|
setivalue(plimit, l_castU2S(count));
|
|
}
|
|
}
|
|
else { /* try making all values floats */
|
|
lua_Number init; lua_Number limit; lua_Number step;
|
|
if (unlikely(!tonumber(plimit, &limit)))
|
|
luaG_forerror(L, plimit, "limit");
|
|
if (unlikely(!tonumber(pstep, &step)))
|
|
luaG_forerror(L, pstep, "step");
|
|
if (unlikely(!tonumber(pinit, &init)))
|
|
luaG_forerror(L, pinit, "initial value");
|
|
if (step == 0)
|
|
luaG_runerror(L, "'for' step is zero");
|
|
if (luai_numlt(0, step) ? luai_numlt(limit, init)
|
|
: luai_numlt(init, limit))
|
|
pc += GETARG_Bx(i) + 1; /* skip the loop */
|
|
else {
|
|
/* make sure internal values are all float */
|
|
setfltvalue(plimit, limit);
|
|
setfltvalue(pstep, step);
|
|
setfltvalue(s2v(ra), init); /* internal index */
|
|
setfltvalue(s2v(ra + 3), init); /* control variable */
|
|
}
|
|
}
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_TFORPREP) {
|
|
/* create to-be-closed upvalue (if needed) */
|
|
halfProtect(luaF_newtbcupval(L, ra + 3));
|
|
pc += GETARG_Bx(i);
|
|
i = *(pc++); /* go to next instruction */
|
|
lua_assert(GET_OPCODE(i) == OP_TFORCALL && ra == RA(i));
|
|
goto l_tforcall;
|
|
}
|
|
vmcase(OP_TFORCALL) {
|
|
l_tforcall:
|
|
/* 'ra' has the iterator function, 'ra + 1' has the state,
|
|
'ra + 2' has the control variable, and 'ra + 3' has the
|
|
to-be-closed variable. The call will use the stack after
|
|
these values (starting at 'ra + 4')
|
|
*/
|
|
/* push function, state, and control variable */
|
|
memcpy(ra + 4, ra, 3 * sizeof(*ra));
|
|
L->top = ra + 4 + 3;
|
|
ProtectNT(luaD_call(L, ra + 4, GETARG_C(i))); /* do the call */
|
|
updatestack(ci); /* stack may have changed */
|
|
i = *(pc++); /* go to next instruction */
|
|
lua_assert(GET_OPCODE(i) == OP_TFORLOOP && ra == RA(i));
|
|
goto l_tforloop;
|
|
}
|
|
vmcase(OP_TFORLOOP) {
|
|
l_tforloop:
|
|
if (!ttisnil(s2v(ra + 4))) { /* continue loop? */
|
|
setobjs2s(L, ra + 2, ra + 4); /* save control variable */
|
|
pc -= GETARG_Bx(i); /* jump back */
|
|
}
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_SETLIST) {
|
|
int n = GETARG_B(i);
|
|
unsigned int last = GETARG_C(i);
|
|
Table *h = hvalue(s2v(ra));
|
|
if (n == 0)
|
|
n = cast_int(L->top - ra) - 1; /* get up to the top */
|
|
else
|
|
L->top = ci->top; /* correct top in case of emergency GC */
|
|
last += n;
|
|
if (TESTARG_k(i)) {
|
|
last += GETARG_Ax(*pc) * (MAXARG_C + 1);
|
|
pc++;
|
|
}
|
|
if (last > luaH_realasize(h)) /* needs more space? */
|
|
luaH_resizearray(L, h, last); /* preallocate it at once */
|
|
for (; n > 0; n--) {
|
|
TValue *val = s2v(ra + n);
|
|
setobj2t(L, &h->array[last - 1], val);
|
|
last--;
|
|
luaC_barrierback(L, obj2gco(h), val);
|
|
}
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_CLOSURE) {
|
|
Proto *p = cl->p->p[GETARG_Bx(i)];
|
|
halfProtect(pushclosure(L, p, cl->upvals, base, ra));
|
|
checkGC(L, ra + 1);
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_VARARG) {
|
|
int n = GETARG_C(i) - 1; /* required results */
|
|
Protect(luaT_getvarargs(L, ci, ra, n));
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_VARARGPREP) {
|
|
luaT_adjustvarargs(L, GETARG_A(i), ci, cl->p);
|
|
updatetrap(ci);
|
|
if (trap) {
|
|
luaD_hookcall(L, ci);
|
|
L->oldpc = pc + 1; /* next opcode will be seen as a "new" line */
|
|
}
|
|
updatebase(ci); /* function has new base after adjustment */
|
|
vmbreak;
|
|
}
|
|
vmcase(OP_EXTRAARG) {
|
|
lua_assert(0);
|
|
vmbreak;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* }================================================================== */
|
|
|