4 ** See Copyright Notice in lua.h
35 ** By default, use jump tables in the main interpreter loop on gcc
36 ** and compatible compilers.
38 #if !defined(LUA_USE_JUMPTABLE)
40 #define LUA_USE_JUMPTABLE 1
42 #define LUA_USE_JUMPTABLE 0
48 /* limit for table tag-method chains (to avoid infinite loops) */
49 #define MAXTAGLOOP 2000
53 ** 'l_intfitsf' checks whether a given integer is in the range that
54 ** can be converted to a float without rounding. Used in comparisons.
57 /* number of bits in the mantissa of a float */
58 #define NBM (l_floatatt(MANT_DIG))
61 ** Check whether some integers may not fit in a float, testing whether
62 ** (maxinteger >> NBM) > 0. (That implies (1 << NBM) <= maxinteger.)
63 ** (The shifts are done in parts, to avoid shifting by more than the size
64 ** of an integer. In a worst case, NBM == 113 for long double and
65 ** sizeof(long) == 32.)
67 #if ((((LUA_MAXINTEGER >> (NBM / 4)) >> (NBM / 4)) >> (NBM / 4)) \
68 >> (NBM - (3 * (NBM / 4)))) > 0
70 /* limit for integers that fit in a float */
71 #define MAXINTFITSF ((lua_Unsigned)1 << NBM)
73 /* check whether 'i' is in the interval [-MAXINTFITSF, MAXINTFITSF] */
74 #define l_intfitsf(i) ((MAXINTFITSF + l_castS2U(i)) <= (2 * MAXINTFITSF))
76 #else /* all integers fit in a float precisely */
78 #define l_intfitsf(i) 1
84 ** Try to convert a value from string to a number value.
85 ** If the value is not a string or is a string not representing
86 ** a valid numeral (or if coercions from strings to numbers
87 ** are disabled via macro 'cvt2num'), do not modify 'result'
90 static int l_strton (const TValue
*obj
, TValue
*result
) {
91 lua_assert(obj
!= result
);
92 if (!cvt2num(obj
)) /* is object not a string? */
95 return (luaO_str2num(svalue(obj
), result
) == vslen(obj
) + 1);
100 ** Try to convert a value to a float. The float case is already handled
101 ** by the macro 'tonumber'.
103 int luaV_tonumber_ (const TValue
*obj
, lua_Number
*n
) {
105 if (ttisinteger(obj
)) {
106 *n
= cast_num(ivalue(obj
));
109 else if (l_strton(obj
, &v
)) { /* string coercible to number? */
110 *n
= nvalue(&v
); /* convert result of 'luaO_str2num' to a float */
114 return 0; /* conversion failed */
119 ** try to convert a float to an integer, rounding according to 'mode'.
121 int luaV_flttointeger (lua_Number n
, lua_Integer
*p
, F2Imod mode
) {
122 lua_Number f
= l_floor(n
);
123 if (n
!= f
) { /* not an integral value? */
124 if (mode
== F2Ieq
) return 0; /* fails if mode demands integral value */
125 else if (mode
== F2Iceil
) /* needs ceil? */
126 f
+= 1; /* convert floor to ceil (remember: n != f) */
128 return lua_numbertointeger(f
, p
);
133 ** try to convert a value to an integer, rounding according to 'mode',
134 ** without string coercion.
135 ** ("Fast track" handled by macro 'tointegerns'.)
137 int luaV_tointegerns (const TValue
*obj
, lua_Integer
*p
, F2Imod mode
) {
139 return luaV_flttointeger(fltvalue(obj
), p
, mode
);
140 else if (ttisinteger(obj
)) {
150 ** try to convert a value to an integer.
152 int luaV_tointeger (const TValue
*obj
, lua_Integer
*p
, F2Imod mode
) {
154 if (l_strton(obj
, &v
)) /* does 'obj' point to a numerical string? */
155 obj
= &v
; /* change it to point to its corresponding number */
156 return luaV_tointegerns(obj
, p
, mode
);
161 ** Try to convert a 'for' limit to an integer, preserving the semantics
162 ** of the loop. Return true if the loop must not run; otherwise, '*p'
163 ** gets the integer limit.
164 ** (The following explanation assumes a positive step; it is valid for
165 ** negative steps mutatis mutandis.)
166 ** If the limit is an integer or can be converted to an integer,
167 ** rounding down, that is the limit.
168 ** Otherwise, check whether the limit can be converted to a float. If
169 ** the float is too large, clip it to LUA_MAXINTEGER. If the float
170 ** is too negative, the loop should not run, because any initial
171 ** integer value is greater than such limit; so, the function returns
172 ** true to signal that. (For this latter case, no integer limit would be
173 ** correct; even a limit of LUA_MININTEGER would run the loop once for
174 ** an initial value equal to LUA_MININTEGER.)
176 static int forlimit (lua_State
*L
, lua_Integer init
, const TValue
*lim
,
177 lua_Integer
*p
, lua_Integer step
) {
178 if (!luaV_tointeger(lim
, p
, (step
< 0 ? F2Iceil
: F2Ifloor
))) {
179 /* not coercible to in integer */
180 lua_Number flim
; /* try to convert to float */
181 if (!tonumber(lim
, &flim
)) /* cannot convert to float? */
182 luaG_forerror(L
, lim
, "limit");
183 /* else 'flim' is a float out of integer bounds */
184 if (luai_numlt(0, flim
)) { /* if it is positive, it is too large */
185 if (step
< 0) return 1; /* initial value must be less than it */
186 *p
= LUA_MAXINTEGER
; /* truncate */
188 else { /* it is less than min integer */
189 if (step
> 0) return 1; /* initial value must be greater than it */
190 *p
= LUA_MININTEGER
; /* truncate */
193 return (step
> 0 ? init
> *p
: init
< *p
); /* not to run? */
198 ** Prepare a numerical for loop (opcode OP_FORPREP).
199 ** Return true to skip the loop. Otherwise,
200 ** after preparation, stack will be as follows:
201 ** ra : internal index (safe copy of the control variable)
202 ** ra + 1 : loop counter (integer loops) or limit (float loops)
204 ** ra + 3 : control variable
206 static int forprep (lua_State
*L
, StkId ra
) {
207 TValue
*pinit
= s2v(ra
);
208 TValue
*plimit
= s2v(ra
+ 1);
209 TValue
*pstep
= s2v(ra
+ 2);
210 if (ttisinteger(pinit
) && ttisinteger(pstep
)) { /* integer loop? */
211 lua_Integer init
= ivalue(pinit
);
212 lua_Integer step
= ivalue(pstep
);
215 luaG_runerror(L
, "'for' step is zero");
216 setivalue(s2v(ra
+ 3), init
); /* control variable */
217 if (forlimit(L
, init
, plimit
, &limit
, step
))
218 return 1; /* skip the loop */
219 else { /* prepare loop counter */
221 if (step
> 0) { /* ascending loop? */
222 count
= l_castS2U(limit
) - l_castS2U(init
);
223 if (step
!= 1) /* avoid division in the too common case */
224 count
/= l_castS2U(step
);
226 else { /* step < 0; descending loop */
227 count
= l_castS2U(init
) - l_castS2U(limit
);
228 /* 'step+1' avoids negating 'mininteger' */
229 count
/= l_castS2U(-(step
+ 1)) + 1u;
231 /* store the counter in place of the limit (which won't be
233 setivalue(plimit
, l_castU2S(count
));
236 else { /* try making all values floats */
237 lua_Number init
; lua_Number limit
; lua_Number step
;
238 if (l_unlikely(!tonumber(plimit
, &limit
)))
239 luaG_forerror(L
, plimit
, "limit");
240 if (l_unlikely(!tonumber(pstep
, &step
)))
241 luaG_forerror(L
, pstep
, "step");
242 if (l_unlikely(!tonumber(pinit
, &init
)))
243 luaG_forerror(L
, pinit
, "initial value");
245 luaG_runerror(L
, "'for' step is zero");
246 if (luai_numlt(0, step
) ? luai_numlt(limit
, init
)
247 : luai_numlt(init
, limit
))
248 return 1; /* skip the loop */
250 /* make sure internal values are all floats */
251 setfltvalue(plimit
, limit
);
252 setfltvalue(pstep
, step
);
253 setfltvalue(s2v(ra
), init
); /* internal index */
254 setfltvalue(s2v(ra
+ 3), init
); /* control variable */
262 ** Execute a step of a float numerical for loop, returning
263 ** true iff the loop must continue. (The integer case is
264 ** written online with opcode OP_FORLOOP, for performance.)
266 static int floatforloop (StkId ra
) {
267 lua_Number step
= fltvalue(s2v(ra
+ 2));
268 lua_Number limit
= fltvalue(s2v(ra
+ 1));
269 lua_Number idx
= fltvalue(s2v(ra
)); /* internal index */
270 idx
= luai_numadd(L
, idx
, step
); /* increment index */
271 if (luai_numlt(0, step
) ? luai_numle(idx
, limit
)
272 : luai_numle(limit
, idx
)) {
273 chgfltvalue(s2v(ra
), idx
); /* update internal index */
274 setfltvalue(s2v(ra
+ 3), idx
); /* and control variable */
275 return 1; /* jump back */
278 return 0; /* finish the loop */
283 ** Finish the table access 'val = t[key]'.
284 ** if 'slot' is NULL, 't' is not a table; otherwise, 'slot' points to
285 ** t[k] entry (which must be empty).
287 void luaV_finishget (lua_State
*L
, const TValue
*t
, TValue
*key
, StkId val
,
288 const TValue
*slot
) {
289 int loop
; /* counter to avoid infinite loops */
290 const TValue
*tm
; /* metamethod */
291 for (loop
= 0; loop
< MAXTAGLOOP
; loop
++) {
292 if (slot
== NULL
) { /* 't' is not a table? */
293 lua_assert(!ttistable(t
));
294 tm
= luaT_gettmbyobj(L
, t
, TM_INDEX
);
295 if (l_unlikely(notm(tm
)))
296 luaG_typeerror(L
, t
, "index"); /* no metamethod */
297 /* else will try the metamethod */
299 else { /* 't' is a table */
300 lua_assert(isempty(slot
));
301 tm
= fasttm(L
, hvalue(t
)->metatable
, TM_INDEX
); /* table's metamethod */
302 if (tm
== NULL
) { /* no metamethod? */
303 setnilvalue(s2v(val
)); /* result is nil */
306 /* else will try the metamethod */
308 if (ttisfunction(tm
)) { /* is metamethod a function? */
309 luaT_callTMres(L
, tm
, t
, key
, val
); /* call it */
312 t
= tm
; /* else try to access 'tm[key]' */
313 if (luaV_fastget(L
, t
, key
, slot
, luaH_get
)) { /* fast track? */
314 setobj2s(L
, val
, slot
); /* done */
317 /* else repeat (tail call 'luaV_finishget') */
319 luaG_runerror(L
, "'__index' chain too long; possible loop");
324 ** Finish a table assignment 't[key] = val'.
325 ** If 'slot' is NULL, 't' is not a table. Otherwise, 'slot' points
326 ** to the entry 't[key]', or to a value with an absent key if there
327 ** is no such entry. (The value at 'slot' must be empty, otherwise
328 ** 'luaV_fastget' would have done the job.)
330 void luaV_finishset (lua_State
*L
, const TValue
*t
, TValue
*key
,
331 TValue
*val
, const TValue
*slot
) {
332 int loop
; /* counter to avoid infinite loops */
333 for (loop
= 0; loop
< MAXTAGLOOP
; loop
++) {
334 const TValue
*tm
; /* '__newindex' metamethod */
335 if (slot
!= NULL
) { /* is 't' a table? */
336 Table
*h
= hvalue(t
); /* save 't' table */
337 lua_assert(isempty(slot
)); /* slot must be empty */
338 tm
= fasttm(L
, h
->metatable
, TM_NEWINDEX
); /* get metamethod */
339 if (tm
== NULL
) { /* no metamethod? */
340 luaH_finishset(L
, h
, key
, slot
, val
); /* set new value */
341 invalidateTMcache(h
);
342 luaC_barrierback(L
, obj2gco(h
), val
);
345 /* else will try the metamethod */
347 else { /* not a table; check metamethod */
348 tm
= luaT_gettmbyobj(L
, t
, TM_NEWINDEX
);
349 if (l_unlikely(notm(tm
)))
350 luaG_typeerror(L
, t
, "index");
352 /* try the metamethod */
353 if (ttisfunction(tm
)) {
354 luaT_callTM(L
, tm
, t
, key
, val
);
357 t
= tm
; /* else repeat assignment over 'tm' */
358 if (luaV_fastget(L
, t
, key
, slot
, luaH_get
)) {
359 luaV_finishfastset(L
, t
, slot
, val
);
362 /* else 'return luaV_finishset(L, t, key, val, slot)' (loop) */
364 luaG_runerror(L
, "'__newindex' chain too long; possible loop");
369 ** Compare two strings 'ls' x 'rs', returning an integer less-equal-
370 ** -greater than zero if 'ls' is less-equal-greater than 'rs'.
371 ** The code is a little tricky because it allows '\0' in the strings
372 ** and it uses 'strcoll' (to respect locales) for each segments
375 static int l_strcmp (const TString
*ls
, const TString
*rs
) {
376 const char *l
= getstr(ls
);
377 size_t ll
= tsslen(ls
);
378 const char *r
= getstr(rs
);
379 size_t lr
= tsslen(rs
);
380 for (;;) { /* for each segment */
381 int temp
= strcoll(l
, r
);
382 if (temp
!= 0) /* not equal? */
383 return temp
; /* done */
384 else { /* strings are equal up to a '\0' */
385 size_t len
= strlen(l
); /* index of first '\0' in both strings */
386 if (len
== lr
) /* 'rs' is finished? */
387 return (len
== ll
) ? 0 : 1; /* check 'ls' */
388 else if (len
== ll
) /* 'ls' is finished? */
389 return -1; /* 'ls' is less than 'rs' ('rs' is not finished) */
390 /* both strings longer than 'len'; go on comparing after the '\0' */
392 l
+= len
; ll
-= len
; r
+= len
; lr
-= len
;
399 ** Check whether integer 'i' is less than float 'f'. If 'i' has an
400 ** exact representation as a float ('l_intfitsf'), compare numbers as
401 ** floats. Otherwise, use the equivalence 'i < f <=> i < ceil(f)'.
402 ** If 'ceil(f)' is out of integer range, either 'f' is greater than
403 ** all integers or less than all integers.
404 ** (The test with 'l_intfitsf' is only for performance; the else
405 ** case is correct for all values, but it is slow due to the conversion
406 ** from float to int.)
407 ** When 'f' is NaN, comparisons must result in false.
409 l_sinline
int LTintfloat (lua_Integer i
, lua_Number f
) {
411 return luai_numlt(cast_num(i
), f
); /* compare them as floats */
412 else { /* i < f <=> i < ceil(f) */
414 if (luaV_flttointeger(f
, &fi
, F2Iceil
)) /* fi = ceil(f) */
415 return i
< fi
; /* compare them as integers */
416 else /* 'f' is either greater or less than all integers */
417 return f
> 0; /* greater? */
423 ** Check whether integer 'i' is less than or equal to float 'f'.
424 ** See comments on previous function.
426 l_sinline
int LEintfloat (lua_Integer i
, lua_Number f
) {
428 return luai_numle(cast_num(i
), f
); /* compare them as floats */
429 else { /* i <= f <=> i <= floor(f) */
431 if (luaV_flttointeger(f
, &fi
, F2Ifloor
)) /* fi = floor(f) */
432 return i
<= fi
; /* compare them as integers */
433 else /* 'f' is either greater or less than all integers */
434 return f
> 0; /* greater? */
440 ** Check whether float 'f' is less than integer 'i'.
441 ** See comments on previous function.
443 l_sinline
int LTfloatint (lua_Number f
, lua_Integer i
) {
445 return luai_numlt(f
, cast_num(i
)); /* compare them as floats */
446 else { /* f < i <=> floor(f) < i */
448 if (luaV_flttointeger(f
, &fi
, F2Ifloor
)) /* fi = floor(f) */
449 return fi
< i
; /* compare them as integers */
450 else /* 'f' is either greater or less than all integers */
451 return f
< 0; /* less? */
457 ** Check whether float 'f' is less than or equal to integer 'i'.
458 ** See comments on previous function.
460 l_sinline
int LEfloatint (lua_Number f
, lua_Integer i
) {
462 return luai_numle(f
, cast_num(i
)); /* compare them as floats */
463 else { /* f <= i <=> ceil(f) <= i */
465 if (luaV_flttointeger(f
, &fi
, F2Iceil
)) /* fi = ceil(f) */
466 return fi
<= i
; /* compare them as integers */
467 else /* 'f' is either greater or less than all integers */
468 return f
< 0; /* less? */
474 ** Return 'l < r', for numbers.
476 l_sinline
int LTnum (const TValue
*l
, const TValue
*r
) {
477 lua_assert(ttisnumber(l
) && ttisnumber(r
));
478 if (ttisinteger(l
)) {
479 lua_Integer li
= ivalue(l
);
481 return li
< ivalue(r
); /* both are integers */
482 else /* 'l' is int and 'r' is float */
483 return LTintfloat(li
, fltvalue(r
)); /* l < r ? */
486 lua_Number lf
= fltvalue(l
); /* 'l' must be float */
488 return luai_numlt(lf
, fltvalue(r
)); /* both are float */
489 else /* 'l' is float and 'r' is int */
490 return LTfloatint(lf
, ivalue(r
));
496 ** Return 'l <= r', for numbers.
498 l_sinline
int LEnum (const TValue
*l
, const TValue
*r
) {
499 lua_assert(ttisnumber(l
) && ttisnumber(r
));
500 if (ttisinteger(l
)) {
501 lua_Integer li
= ivalue(l
);
503 return li
<= ivalue(r
); /* both are integers */
504 else /* 'l' is int and 'r' is float */
505 return LEintfloat(li
, fltvalue(r
)); /* l <= r ? */
508 lua_Number lf
= fltvalue(l
); /* 'l' must be float */
510 return luai_numle(lf
, fltvalue(r
)); /* both are float */
511 else /* 'l' is float and 'r' is int */
512 return LEfloatint(lf
, ivalue(r
));
518 ** return 'l < r' for non-numbers.
520 static int lessthanothers (lua_State
*L
, const TValue
*l
, const TValue
*r
) {
521 lua_assert(!ttisnumber(l
) || !ttisnumber(r
));
522 if (ttisstring(l
) && ttisstring(r
)) /* both are strings? */
523 return l_strcmp(tsvalue(l
), tsvalue(r
)) < 0;
525 return luaT_callorderTM(L
, l
, r
, TM_LT
);
530 ** Main operation less than; return 'l < r'.
532 int luaV_lessthan (lua_State
*L
, const TValue
*l
, const TValue
*r
) {
533 if (ttisnumber(l
) && ttisnumber(r
)) /* both operands are numbers? */
535 else return lessthanothers(L
, l
, r
);
540 ** return 'l <= r' for non-numbers.
542 static int lessequalothers (lua_State
*L
, const TValue
*l
, const TValue
*r
) {
543 lua_assert(!ttisnumber(l
) || !ttisnumber(r
));
544 if (ttisstring(l
) && ttisstring(r
)) /* both are strings? */
545 return l_strcmp(tsvalue(l
), tsvalue(r
)) <= 0;
547 return luaT_callorderTM(L
, l
, r
, TM_LE
);
552 ** Main operation less than or equal to; return 'l <= r'.
554 int luaV_lessequal (lua_State
*L
, const TValue
*l
, const TValue
*r
) {
555 if (ttisnumber(l
) && ttisnumber(r
)) /* both operands are numbers? */
557 else return lessequalothers(L
, l
, r
);
562 ** Main operation for equality of Lua values; return 't1 == t2'.
563 ** L == NULL means raw equality (no metamethods)
565 int luaV_equalobj (lua_State
*L
, const TValue
*t1
, const TValue
*t2
) {
567 if (ttypetag(t1
) != ttypetag(t2
)) { /* not the same variant? */
568 if (ttype(t1
) != ttype(t2
) || ttype(t1
) != LUA_TNUMBER
)
569 return 0; /* only numbers can be equal with different variants */
570 else { /* two numbers with different variants */
571 /* One of them is an integer. If the other does not have an
572 integer value, they cannot be equal; otherwise, compare their
575 return (luaV_tointegerns(t1
, &i1
, F2Ieq
) &&
576 luaV_tointegerns(t2
, &i2
, F2Ieq
) &&
580 /* values have same type and same variant */
581 switch (ttypetag(t1
)) {
582 case LUA_VNIL
: case LUA_VFALSE
: case LUA_VTRUE
: return 1;
583 case LUA_VNUMINT
: return (ivalue(t1
) == ivalue(t2
));
584 case LUA_VNUMFLT
: return luai_numeq(fltvalue(t1
), fltvalue(t2
));
585 case LUA_VLIGHTUSERDATA
: return pvalue(t1
) == pvalue(t2
);
586 case LUA_VLCF
: return fvalue(t1
) == fvalue(t2
);
587 case LUA_VSHRSTR
: return eqshrstr(tsvalue(t1
), tsvalue(t2
));
588 case LUA_VLNGSTR
: return luaS_eqlngstr(tsvalue(t1
), tsvalue(t2
));
589 case LUA_VUSERDATA
: {
590 if (uvalue(t1
) == uvalue(t2
)) return 1;
591 else if (L
== NULL
) return 0;
592 tm
= fasttm(L
, uvalue(t1
)->metatable
, TM_EQ
);
594 tm
= fasttm(L
, uvalue(t2
)->metatable
, TM_EQ
);
595 break; /* will try TM */
598 if (hvalue(t1
) == hvalue(t2
)) return 1;
599 else if (L
== NULL
) return 0;
600 tm
= fasttm(L
, hvalue(t1
)->metatable
, TM_EQ
);
602 tm
= fasttm(L
, hvalue(t2
)->metatable
, TM_EQ
);
603 break; /* will try TM */
606 return gcvalue(t1
) == gcvalue(t2
);
608 if (tm
== NULL
) /* no TM? */
609 return 0; /* objects are different */
611 luaT_callTMres(L
, tm
, t1
, t2
, L
->top
.p
); /* call TM */
612 return !l_isfalse(s2v(L
->top
.p
));
617 /* macro used by 'luaV_concat' to ensure that element at 'o' is a string */
618 #define tostring(L,o) \
619 (ttisstring(o) || (cvt2str(o) && (luaO_tostring(L, o), 1)))
621 #define isemptystr(o) (ttisshrstring(o) && tsvalue(o)->shrlen == 0)
623 /* copy strings in stack from top - n up to top - 1 to buffer */
624 static void copy2buff (StkId top
, int n
, char *buff
) {
625 size_t tl
= 0; /* size already copied */
627 size_t l
= vslen(s2v(top
- n
)); /* length of string being copied */
628 memcpy(buff
+ tl
, svalue(s2v(top
- n
)), l
* sizeof(char));
635 ** Main operation for concatenation: concat 'total' values in the stack,
636 ** from 'L->top.p - total' up to 'L->top.p - 1'.
638 void luaV_concat (lua_State
*L
, int total
) {
640 return; /* "all" values already concatenated */
642 StkId top
= L
->top
.p
;
643 int n
= 2; /* number of elements handled in this pass (at least 2) */
644 if (!(ttisstring(s2v(top
- 2)) || cvt2str(s2v(top
- 2))) ||
645 !tostring(L
, s2v(top
- 1)))
646 luaT_tryconcatTM(L
); /* may invalidate 'top' */
647 else if (isemptystr(s2v(top
- 1))) /* second operand is empty? */
648 cast_void(tostring(L
, s2v(top
- 2))); /* result is first operand */
649 else if (isemptystr(s2v(top
- 2))) { /* first operand is empty string? */
650 setobjs2s(L
, top
- 2, top
- 1); /* result is second op. */
653 /* at least two non-empty string values; get as many as possible */
654 size_t tl
= vslen(s2v(top
- 1));
656 /* collect total length and number of strings */
657 for (n
= 1; n
< total
&& tostring(L
, s2v(top
- n
- 1)); n
++) {
658 size_t l
= vslen(s2v(top
- n
- 1));
659 if (l_unlikely(l
>= (MAX_SIZE
/sizeof(char)) - tl
)) {
660 L
->top
.p
= top
- total
; /* pop strings to avoid wasting stack */
661 luaG_runerror(L
, "string length overflow");
665 if (tl
<= LUAI_MAXSHORTLEN
) { /* is result a short string? */
666 char buff
[LUAI_MAXSHORTLEN
];
667 copy2buff(top
, n
, buff
); /* copy strings to buffer */
668 ts
= luaS_newlstr(L
, buff
, tl
);
670 else { /* long string; copy strings directly to final result */
671 ts
= luaS_createlngstrobj(L
, tl
);
672 copy2buff(top
, n
, getstr(ts
));
674 setsvalue2s(L
, top
- n
, ts
); /* create result */
676 total
-= n
- 1; /* got 'n' strings to create one new */
677 L
->top
.p
-= n
- 1; /* popped 'n' strings and pushed one */
678 } while (total
> 1); /* repeat until only 1 result left */
683 ** Main operation 'ra = #rb'.
685 void luaV_objlen (lua_State
*L
, StkId ra
, const TValue
*rb
) {
687 switch (ttypetag(rb
)) {
689 Table
*h
= hvalue(rb
);
690 tm
= fasttm(L
, h
->metatable
, TM_LEN
);
691 if (tm
) break; /* metamethod? break switch to call it */
692 setivalue(s2v(ra
), luaH_getn(h
)); /* else primitive len */
696 setivalue(s2v(ra
), tsvalue(rb
)->shrlen
);
700 setivalue(s2v(ra
), tsvalue(rb
)->u
.lnglen
);
703 default: { /* try metamethod */
704 tm
= luaT_gettmbyobj(L
, rb
, TM_LEN
);
705 if (l_unlikely(notm(tm
))) /* no metamethod? */
706 luaG_typeerror(L
, rb
, "get length of");
710 luaT_callTMres(L
, tm
, rb
, rb
, ra
);
715 ** Integer division; return 'm // n', that is, floor(m/n).
716 ** C division truncates its result (rounds towards zero).
717 ** 'floor(q) == trunc(q)' when 'q >= 0' or when 'q' is integer,
718 ** otherwise 'floor(q) == trunc(q) - 1'.
720 lua_Integer
luaV_idiv (lua_State
*L
, lua_Integer m
, lua_Integer n
) {
721 if (l_unlikely(l_castS2U(n
) + 1u <= 1u)) { /* special cases: -1 or 0 */
723 luaG_runerror(L
, "attempt to divide by zero");
724 return intop(-, 0, m
); /* n==-1; avoid overflow with 0x80000...//-1 */
727 lua_Integer q
= m
/ n
; /* perform C division */
728 if ((m
^ n
) < 0 && m
% n
!= 0) /* 'm/n' would be negative non-integer? */
729 q
-= 1; /* correct result for different rounding */
736 ** Integer modulus; return 'm % n'. (Assume that C '%' with
737 ** negative operands follows C99 behavior. See previous comment
740 lua_Integer
luaV_mod (lua_State
*L
, lua_Integer m
, lua_Integer n
) {
741 if (l_unlikely(l_castS2U(n
) + 1u <= 1u)) { /* special cases: -1 or 0 */
743 luaG_runerror(L
, "attempt to perform 'n%%0'");
744 return 0; /* m % -1 == 0; avoid overflow with 0x80000...%-1 */
747 lua_Integer r
= m
% n
;
748 if (r
!= 0 && (r
^ n
) < 0) /* 'm/n' would be non-integer negative? */
749 r
+= n
; /* correct result for different rounding */
758 lua_Number
luaV_modf (lua_State
*L
, lua_Number m
, lua_Number n
) {
760 luai_nummod(L
, m
, n
, r
);
765 /* number of bits in an integer */
766 #define NBITS cast_int(sizeof(lua_Integer) * CHAR_BIT)
770 ** Shift left operation. (Shift right just negates 'y'.)
772 lua_Integer
luaV_shiftl (lua_Integer x
, lua_Integer y
) {
773 if (y
< 0) { /* shift right? */
774 if (y
<= -NBITS
) return 0;
775 else return intop(>>, x
, -y
);
777 else { /* shift left */
778 if (y
>= NBITS
) return 0;
779 else return intop(<<, x
, y
);
785 ** create a new Lua closure, push it in the stack, and initialize
788 static void pushclosure (lua_State
*L
, Proto
*p
, UpVal
**encup
, StkId base
,
790 int nup
= p
->sizeupvalues
;
791 Upvaldesc
*uv
= p
->upvalues
;
793 LClosure
*ncl
= luaF_newLclosure(L
, nup
);
795 setclLvalue2s(L
, ra
, ncl
); /* anchor new closure in stack */
796 for (i
= 0; i
< nup
; i
++) { /* fill in its upvalues */
797 if (uv
[i
].instack
) /* upvalue refers to local variable? */
798 ncl
->upvals
[i
] = luaF_findupval(L
, base
+ uv
[i
].idx
);
799 else /* get upvalue from enclosing function */
800 ncl
->upvals
[i
] = encup
[uv
[i
].idx
];
801 luaC_objbarrier(L
, ncl
, ncl
->upvals
[i
]);
807 ** finish execution of an opcode interrupted by a yield
809 void luaV_finishOp (lua_State
*L
) {
810 CallInfo
*ci
= L
->ci
;
811 StkId base
= ci
->func
.p
+ 1;
812 Instruction inst
= *(ci
->u
.l
.savedpc
- 1); /* interrupted instruction */
813 OpCode op
= GET_OPCODE(inst
);
814 switch (op
) { /* finish its execution */
815 case OP_MMBIN
: case OP_MMBINI
: case OP_MMBINK
: {
816 setobjs2s(L
, base
+ GETARG_A(*(ci
->u
.l
.savedpc
- 2)), --L
->top
.p
);
819 case OP_UNM
: case OP_BNOT
: case OP_LEN
:
820 case OP_GETTABUP
: case OP_GETTABLE
: case OP_GETI
:
821 case OP_GETFIELD
: case OP_SELF
: {
822 setobjs2s(L
, base
+ GETARG_A(inst
), --L
->top
.p
);
825 case OP_LT
: case OP_LE
:
826 case OP_LTI
: case OP_LEI
:
827 case OP_GTI
: case OP_GEI
:
828 case OP_EQ
: { /* note that 'OP_EQI'/'OP_EQK' cannot yield */
829 int res
= !l_isfalse(s2v(L
->top
.p
- 1));
831 #if defined(LUA_COMPAT_LT_LE)
832 if (ci
->callstatus
& CIST_LEQ
) { /* "<=" using "<" instead? */
833 ci
->callstatus
^= CIST_LEQ
; /* clear mark */
834 res
= !res
; /* negate result */
837 lua_assert(GET_OPCODE(*ci
->u
.l
.savedpc
) == OP_JMP
);
838 if (res
!= GETARG_k(inst
)) /* condition failed? */
839 ci
->u
.l
.savedpc
++; /* skip jump instruction */
843 StkId top
= L
->top
.p
- 1; /* top when 'luaT_tryconcatTM' was called */
844 int a
= GETARG_A(inst
); /* first element to concatenate */
845 int total
= cast_int(top
- 1 - (base
+ a
)); /* yet to concatenate */
846 setobjs2s(L
, top
- 2, top
); /* put TM result in proper position */
847 L
->top
.p
= top
- 1; /* top is one after last element (at top-2) */
848 luaV_concat(L
, total
); /* concat them (may yield again) */
851 case OP_CLOSE
: { /* yielded closing variables */
852 ci
->u
.l
.savedpc
--; /* repeat instruction to close other vars. */
855 case OP_RETURN
: { /* yielded closing variables */
856 StkId ra
= base
+ GETARG_A(inst
);
857 /* adjust top to signal correct number of returns, in case the
858 return is "up to top" ('isIT') */
859 L
->top
.p
= ra
+ ci
->u2
.nres
;
860 /* repeat instruction to close other vars. and complete the return */
865 /* only these other opcodes can yield */
866 lua_assert(op
== OP_TFORCALL
|| op
== OP_CALL
||
867 op
== OP_TAILCALL
|| op
== OP_SETTABUP
|| op
== OP_SETTABLE
||
868 op
== OP_SETI
|| op
== OP_SETFIELD
);
878 ** {==================================================================
879 ** Macros for arithmetic/bitwise/comparison opcodes in 'luaV_execute'
880 ** ===================================================================
883 #define l_addi(L,a,b) intop(+, a, b)
884 #define l_subi(L,a,b) intop(-, a, b)
885 #define l_muli(L,a,b) intop(*, a, b)
886 #define l_band(a,b) intop(&, a, b)
887 #define l_bor(a,b) intop(|, a, b)
888 #define l_bxor(a,b) intop(^, a, b)
890 #define l_lti(a,b) (a < b)
891 #define l_lei(a,b) (a <= b)
892 #define l_gti(a,b) (a > b)
893 #define l_gei(a,b) (a >= b)
897 ** Arithmetic operations with immediate operands. 'iop' is the integer
898 ** operation, 'fop' is the float operation.
900 #define op_arithI(L,iop,fop) { \
902 TValue *v1 = vRB(i); \
903 int imm = GETARG_sC(i); \
904 if (ttisinteger(v1)) { \
905 lua_Integer iv1 = ivalue(v1); \
906 pc++; setivalue(s2v(ra), iop(L, iv1, imm)); \
908 else if (ttisfloat(v1)) { \
909 lua_Number nb = fltvalue(v1); \
910 lua_Number fimm = cast_num(imm); \
911 pc++; setfltvalue(s2v(ra), fop(L, nb, fimm)); \
916 ** Auxiliary function for arithmetic operations over floats and others
917 ** with two register operands.
919 #define op_arithf_aux(L,v1,v2,fop) { \
920 lua_Number n1; lua_Number n2; \
921 if (tonumberns(v1, n1) && tonumberns(v2, n2)) { \
922 pc++; setfltvalue(s2v(ra), fop(L, n1, n2)); \
927 ** Arithmetic operations over floats and others with register operands.
929 #define op_arithf(L,fop) { \
931 TValue *v1 = vRB(i); \
932 TValue *v2 = vRC(i); \
933 op_arithf_aux(L, v1, v2, fop); }
937 ** Arithmetic operations with K operands for floats.
939 #define op_arithfK(L,fop) { \
941 TValue *v1 = vRB(i); \
942 TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \
943 op_arithf_aux(L, v1, v2, fop); }
947 ** Arithmetic operations over integers and floats.
949 #define op_arith_aux(L,v1,v2,iop,fop) { \
951 if (ttisinteger(v1) && ttisinteger(v2)) { \
952 lua_Integer i1 = ivalue(v1); lua_Integer i2 = ivalue(v2); \
953 pc++; setivalue(s2v(ra), iop(L, i1, i2)); \
955 else op_arithf_aux(L, v1, v2, fop); }
959 ** Arithmetic operations with register operands.
961 #define op_arith(L,iop,fop) { \
962 TValue *v1 = vRB(i); \
963 TValue *v2 = vRC(i); \
964 op_arith_aux(L, v1, v2, iop, fop); }
968 ** Arithmetic operations with K operands.
970 #define op_arithK(L,iop,fop) { \
971 TValue *v1 = vRB(i); \
972 TValue *v2 = KC(i); lua_assert(ttisnumber(v2)); \
973 op_arith_aux(L, v1, v2, iop, fop); }
977 ** Bitwise operations with constant operand.
979 #define op_bitwiseK(L,op) { \
981 TValue *v1 = vRB(i); \
982 TValue *v2 = KC(i); \
984 lua_Integer i2 = ivalue(v2); \
985 if (tointegerns(v1, &i1)) { \
986 pc++; setivalue(s2v(ra), op(i1, i2)); \
991 ** Bitwise operations with register operands.
993 #define op_bitwise(L,op) { \
995 TValue *v1 = vRB(i); \
996 TValue *v2 = vRC(i); \
997 lua_Integer i1; lua_Integer i2; \
998 if (tointegerns(v1, &i1) && tointegerns(v2, &i2)) { \
999 pc++; setivalue(s2v(ra), op(i1, i2)); \
1004 ** Order operations with register operands. 'opn' actually works
1005 ** for all numbers, but the fast track improves performance for
1008 #define op_order(L,opi,opn,other) { \
1011 TValue *rb = vRB(i); \
1012 if (ttisinteger(s2v(ra)) && ttisinteger(rb)) { \
1013 lua_Integer ia = ivalue(s2v(ra)); \
1014 lua_Integer ib = ivalue(rb); \
1015 cond = opi(ia, ib); \
1017 else if (ttisnumber(s2v(ra)) && ttisnumber(rb)) \
1018 cond = opn(s2v(ra), rb); \
1020 Protect(cond = other(L, s2v(ra), rb)); \
1025 ** Order operations with immediate operand. (Immediate operand is
1026 ** always small enough to have an exact representation as a float.)
1028 #define op_orderI(L,opi,opf,inv,tm) { \
1031 int im = GETARG_sB(i); \
1032 if (ttisinteger(s2v(ra))) \
1033 cond = opi(ivalue(s2v(ra)), im); \
1034 else if (ttisfloat(s2v(ra))) { \
1035 lua_Number fa = fltvalue(s2v(ra)); \
1036 lua_Number fim = cast_num(im); \
1037 cond = opf(fa, fim); \
1040 int isf = GETARG_C(i); \
1041 Protect(cond = luaT_callorderiTM(L, s2v(ra), im, inv, isf, tm)); \
1045 /* }================================================================== */
1049 ** {==================================================================
1050 ** Function 'luaV_execute': main interpreter loop
1051 ** ===================================================================
1055 ** some macros for common tasks in 'luaV_execute'
1059 #define RA(i) (base+GETARG_A(i))
1060 #define RB(i) (base+GETARG_B(i))
1061 #define vRB(i) s2v(RB(i))
1062 #define KB(i) (k+GETARG_B(i))
1063 #define RC(i) (base+GETARG_C(i))
1064 #define vRC(i) s2v(RC(i))
1065 #define KC(i) (k+GETARG_C(i))
1066 #define RKC(i) ((TESTARG_k(i)) ? k + GETARG_C(i) : s2v(base + GETARG_C(i)))
1070 #define updatetrap(ci) (trap = ci->u.l.trap)
1072 #define updatebase(ci) (base = ci->func.p + 1)
1075 #define updatestack(ci) \
1076 { if (l_unlikely(trap)) { updatebase(ci); ra = RA(i); } }
1080 ** Execute a jump instruction. The 'updatetrap' allows signals to stop
1081 ** tight loops. (Without it, the local copy of 'trap' could never change.)
1083 #define dojump(ci,i,e) { pc += GETARG_sJ(i) + e; updatetrap(ci); }
1086 /* for test instructions, execute the jump instruction that follows it */
1087 #define donextjump(ci) { Instruction ni = *pc; dojump(ci, ni, 1); }
1090 ** do a conditional jump: skip next instruction if 'cond' is not what
1091 ** was expected (parameter 'k'), else do next instruction, which must
1094 #define docondjump() if (cond != GETARG_k(i)) pc++; else donextjump(ci);
1098 ** Correct global 'pc'.
1100 #define savepc(L) (ci->u.l.savedpc = pc)
1104 ** Whenever code can raise errors, the global 'pc' and the global
1105 ** 'top' must be correct to report occasional errors.
1107 #define savestate(L,ci) (savepc(L), L->top.p = ci->top.p)
1111 ** Protect code that, in general, can raise errors, reallocate the
1112 ** stack, and change the hooks.
1114 #define Protect(exp) (savestate(L,ci), (exp), updatetrap(ci))
1116 /* special version that does not change the top */
1117 #define ProtectNT(exp) (savepc(L), (exp), updatetrap(ci))
1120 ** Protect code that can only raise errors. (That is, it cannot change
1121 ** the stack or hooks.)
1123 #define halfProtect(exp) (savestate(L,ci), (exp))
1125 /* 'c' is the limit of live values in the stack */
1126 #define checkGC(L,c) \
1127 { luaC_condGC(L, (savepc(L), L->top.p = (c)), \
1129 luai_threadyield(L); }
1132 /* fetch an instruction and prepare its execution */
1133 #define vmfetch() { \
1134 if (l_unlikely(trap)) { /* stack reallocation or hooks? */ \
1135 trap = luaG_traceexec(L, pc); /* handle hooks */ \
1136 updatebase(ci); /* correct stack */ \
1141 #define vmdispatch(o) switch(o)
1142 #define vmcase(l) case l:
1143 #define vmbreak break
1146 void luaV_execute (lua_State
*L
, CallInfo
*ci
) {
1150 const Instruction
*pc
;
1152 #if LUA_USE_JUMPTABLE
1153 #include "ljumptab.h"
1157 returning
: /* trap already set */
1158 cl
= clLvalue(s2v(ci
->func
.p
));
1160 pc
= ci
->u
.l
.savedpc
;
1161 if (l_unlikely(trap
)) {
1162 if (pc
== cl
->p
->code
) { /* first instruction (not resuming)? */
1163 if (cl
->p
->is_vararg
)
1164 trap
= 0; /* hooks will start after VARARGPREP instruction */
1165 else /* check 'call' hook */
1166 luaD_hookcall(L
, ci
);
1168 ci
->u
.l
.trap
= 1; /* assume trap is on, for now */
1170 base
= ci
->func
.p
+ 1;
1171 /* main loop of interpreter */
1173 Instruction i
; /* instruction being executed */
1176 /* low-level line tracing for debugging Lua */
1177 printf("line: %d\n", luaG_getfuncline(cl
->p
, pcRel(pc
, cl
->p
)));
1179 lua_assert(base
== ci
->func
.p
+ 1);
1180 lua_assert(base
<= L
->top
.p
&& L
->top
.p
<= L
->stack_last
.p
);
1181 /* invalidate top for instructions not expecting it */
1182 lua_assert(isIT(i
) || (cast_void(L
->top
.p
= base
), 1));
1183 vmdispatch (GET_OPCODE(i
)) {
1186 setobjs2s(L
, ra
, RB(i
));
1191 lua_Integer b
= GETARG_sBx(i
);
1192 setivalue(s2v(ra
), b
);
1197 int b
= GETARG_sBx(i
);
1198 setfltvalue(s2v(ra
), cast_num(b
));
1203 TValue
*rb
= k
+ GETARG_Bx(i
);
1204 setobj2s(L
, ra
, rb
);
1210 rb
= k
+ GETARG_Ax(*pc
); pc
++;
1211 setobj2s(L
, ra
, rb
);
1214 vmcase(OP_LOADFALSE
) {
1216 setbfvalue(s2v(ra
));
1219 vmcase(OP_LFALSESKIP
) {
1221 setbfvalue(s2v(ra
));
1222 pc
++; /* skip next instruction */
1225 vmcase(OP_LOADTRUE
) {
1227 setbtvalue(s2v(ra
));
1230 vmcase(OP_LOADNIL
) {
1232 int b
= GETARG_B(i
);
1234 setnilvalue(s2v(ra
++));
1238 vmcase(OP_GETUPVAL
) {
1240 int b
= GETARG_B(i
);
1241 setobj2s(L
, ra
, cl
->upvals
[b
]->v
.p
);
1244 vmcase(OP_SETUPVAL
) {
1246 UpVal
*uv
= cl
->upvals
[GETARG_B(i
)];
1247 setobj(L
, uv
->v
.p
, s2v(ra
));
1248 luaC_barrier(L
, uv
, s2v(ra
));
1251 vmcase(OP_GETTABUP
) {
1254 TValue
*upval
= cl
->upvals
[GETARG_B(i
)]->v
.p
;
1256 TString
*key
= tsvalue(rc
); /* key must be a string */
1257 if (luaV_fastget(L
, upval
, key
, slot
, luaH_getshortstr
)) {
1258 setobj2s(L
, ra
, slot
);
1261 Protect(luaV_finishget(L
, upval
, rc
, ra
, slot
));
1264 vmcase(OP_GETTABLE
) {
1267 TValue
*rb
= vRB(i
);
1268 TValue
*rc
= vRC(i
);
1270 if (ttisinteger(rc
) /* fast track for integers? */
1271 ? (cast_void(n
= ivalue(rc
)), luaV_fastgeti(L
, rb
, n
, slot
))
1272 : luaV_fastget(L
, rb
, rc
, slot
, luaH_get
)) {
1273 setobj2s(L
, ra
, slot
);
1276 Protect(luaV_finishget(L
, rb
, rc
, ra
, slot
));
1282 TValue
*rb
= vRB(i
);
1283 int c
= GETARG_C(i
);
1284 if (luaV_fastgeti(L
, rb
, c
, slot
)) {
1285 setobj2s(L
, ra
, slot
);
1290 Protect(luaV_finishget(L
, rb
, &key
, ra
, slot
));
1294 vmcase(OP_GETFIELD
) {
1297 TValue
*rb
= vRB(i
);
1299 TString
*key
= tsvalue(rc
); /* key must be a string */
1300 if (luaV_fastget(L
, rb
, key
, slot
, luaH_getshortstr
)) {
1301 setobj2s(L
, ra
, slot
);
1304 Protect(luaV_finishget(L
, rb
, rc
, ra
, slot
));
1307 vmcase(OP_SETTABUP
) {
1309 TValue
*upval
= cl
->upvals
[GETARG_A(i
)]->v
.p
;
1311 TValue
*rc
= RKC(i
);
1312 TString
*key
= tsvalue(rb
); /* key must be a string */
1313 if (luaV_fastget(L
, upval
, key
, slot
, luaH_getshortstr
)) {
1314 luaV_finishfastset(L
, upval
, slot
, rc
);
1317 Protect(luaV_finishset(L
, upval
, rb
, rc
, slot
));
1320 vmcase(OP_SETTABLE
) {
1323 TValue
*rb
= vRB(i
); /* key (table is in 'ra') */
1324 TValue
*rc
= RKC(i
); /* value */
1326 if (ttisinteger(rb
) /* fast track for integers? */
1327 ? (cast_void(n
= ivalue(rb
)), luaV_fastgeti(L
, s2v(ra
), n
, slot
))
1328 : luaV_fastget(L
, s2v(ra
), rb
, slot
, luaH_get
)) {
1329 luaV_finishfastset(L
, s2v(ra
), slot
, rc
);
1332 Protect(luaV_finishset(L
, s2v(ra
), rb
, rc
, slot
));
1338 int c
= GETARG_B(i
);
1339 TValue
*rc
= RKC(i
);
1340 if (luaV_fastgeti(L
, s2v(ra
), c
, slot
)) {
1341 luaV_finishfastset(L
, s2v(ra
), slot
, rc
);
1346 Protect(luaV_finishset(L
, s2v(ra
), &key
, rc
, slot
));
1350 vmcase(OP_SETFIELD
) {
1354 TValue
*rc
= RKC(i
);
1355 TString
*key
= tsvalue(rb
); /* key must be a string */
1356 if (luaV_fastget(L
, s2v(ra
), key
, slot
, luaH_getshortstr
)) {
1357 luaV_finishfastset(L
, s2v(ra
), slot
, rc
);
1360 Protect(luaV_finishset(L
, s2v(ra
), rb
, rc
, slot
));
1363 vmcase(OP_NEWTABLE
) {
1365 int b
= GETARG_B(i
); /* log2(hash size) + 1 */
1366 int c
= GETARG_C(i
); /* array size */
1369 b
= 1 << (b
- 1); /* size is 2^(b - 1) */
1370 lua_assert((!TESTARG_k(i
)) == (GETARG_Ax(*pc
) == 0));
1371 if (TESTARG_k(i
)) /* non-zero extra argument? */
1372 c
+= GETARG_Ax(*pc
) * (MAXARG_C
+ 1); /* add it to size */
1373 pc
++; /* skip extra argument */
1374 L
->top
.p
= ra
+ 1; /* correct top in case of emergency GC */
1375 t
= luaH_new(L
); /* memory allocation */
1376 sethvalue2s(L
, ra
, t
);
1377 if (b
!= 0 || c
!= 0)
1378 luaH_resize(L
, t
, c
, b
); /* idem */
1385 TValue
*rb
= vRB(i
);
1386 TValue
*rc
= RKC(i
);
1387 TString
*key
= tsvalue(rc
); /* key must be a string */
1388 setobj2s(L
, ra
+ 1, rb
);
1389 if (luaV_fastget(L
, rb
, key
, slot
, luaH_getstr
)) {
1390 setobj2s(L
, ra
, slot
);
1393 Protect(luaV_finishget(L
, rb
, rc
, ra
, slot
));
1397 op_arithI(L
, l_addi
, luai_numadd
);
1401 op_arithK(L
, l_addi
, luai_numadd
);
1405 op_arithK(L
, l_subi
, luai_numsub
);
1409 op_arithK(L
, l_muli
, luai_nummul
);
1413 savestate(L
, ci
); /* in case of division by 0 */
1414 op_arithK(L
, luaV_mod
, luaV_modf
);
1418 op_arithfK(L
, luai_numpow
);
1422 op_arithfK(L
, luai_numdiv
);
1426 savestate(L
, ci
); /* in case of division by 0 */
1427 op_arithK(L
, luaV_idiv
, luai_numidiv
);
1431 op_bitwiseK(L
, l_band
);
1435 op_bitwiseK(L
, l_bor
);
1439 op_bitwiseK(L
, l_bxor
);
1444 TValue
*rb
= vRB(i
);
1445 int ic
= GETARG_sC(i
);
1447 if (tointegerns(rb
, &ib
)) {
1448 pc
++; setivalue(s2v(ra
), luaV_shiftl(ib
, -ic
));
1454 TValue
*rb
= vRB(i
);
1455 int ic
= GETARG_sC(i
);
1457 if (tointegerns(rb
, &ib
)) {
1458 pc
++; setivalue(s2v(ra
), luaV_shiftl(ic
, ib
));
1463 op_arith(L
, l_addi
, luai_numadd
);
1467 op_arith(L
, l_subi
, luai_numsub
);
1471 op_arith(L
, l_muli
, luai_nummul
);
1475 savestate(L
, ci
); /* in case of division by 0 */
1476 op_arith(L
, luaV_mod
, luaV_modf
);
1480 op_arithf(L
, luai_numpow
);
1483 vmcase(OP_DIV
) { /* float division (always with floats) */
1484 op_arithf(L
, luai_numdiv
);
1487 vmcase(OP_IDIV
) { /* floor division */
1488 savestate(L
, ci
); /* in case of division by 0 */
1489 op_arith(L
, luaV_idiv
, luai_numidiv
);
1493 op_bitwise(L
, l_band
);
1497 op_bitwise(L
, l_bor
);
1501 op_bitwise(L
, l_bxor
);
1505 op_bitwise(L
, luaV_shiftr
);
1509 op_bitwise(L
, luaV_shiftl
);
1514 Instruction pi
= *(pc
- 2); /* original arith. expression */
1515 TValue
*rb
= vRB(i
);
1516 TMS tm
= (TMS
)GETARG_C(i
);
1517 StkId result
= RA(pi
);
1518 lua_assert(OP_ADD
<= GET_OPCODE(pi
) && GET_OPCODE(pi
) <= OP_SHR
);
1519 Protect(luaT_trybinTM(L
, s2v(ra
), rb
, result
, tm
));
1524 Instruction pi
= *(pc
- 2); /* original arith. expression */
1525 int imm
= GETARG_sB(i
);
1526 TMS tm
= (TMS
)GETARG_C(i
);
1527 int flip
= GETARG_k(i
);
1528 StkId result
= RA(pi
);
1529 Protect(luaT_trybiniTM(L
, s2v(ra
), imm
, flip
, result
, tm
));
1534 Instruction pi
= *(pc
- 2); /* original arith. expression */
1535 TValue
*imm
= KB(i
);
1536 TMS tm
= (TMS
)GETARG_C(i
);
1537 int flip
= GETARG_k(i
);
1538 StkId result
= RA(pi
);
1539 Protect(luaT_trybinassocTM(L
, s2v(ra
), imm
, flip
, result
, tm
));
1544 TValue
*rb
= vRB(i
);
1546 if (ttisinteger(rb
)) {
1547 lua_Integer ib
= ivalue(rb
);
1548 setivalue(s2v(ra
), intop(-, 0, ib
));
1550 else if (tonumberns(rb
, nb
)) {
1551 setfltvalue(s2v(ra
), luai_numunm(L
, nb
));
1554 Protect(luaT_trybinTM(L
, rb
, rb
, ra
, TM_UNM
));
1559 TValue
*rb
= vRB(i
);
1561 if (tointegerns(rb
, &ib
)) {
1562 setivalue(s2v(ra
), intop(^, ~l_castS2U(0), ib
));
1565 Protect(luaT_trybinTM(L
, rb
, rb
, ra
, TM_BNOT
));
1570 TValue
*rb
= vRB(i
);
1572 setbtvalue(s2v(ra
));
1574 setbfvalue(s2v(ra
));
1579 Protect(luaV_objlen(L
, ra
, vRB(i
)));
1584 int n
= GETARG_B(i
); /* number of elements to concatenate */
1585 L
->top
.p
= ra
+ n
; /* mark the end of concat operands */
1586 ProtectNT(luaV_concat(L
, n
));
1587 checkGC(L
, L
->top
.p
); /* 'luaV_concat' ensures correct top */
1592 Protect(luaF_close(L
, ra
, LUA_OK
, 1));
1597 /* create new to-be-closed upvalue */
1598 halfProtect(luaF_newtbcupval(L
, ra
));
1608 TValue
*rb
= vRB(i
);
1609 Protect(cond
= luaV_equalobj(L
, s2v(ra
), rb
));
1614 op_order(L
, l_lti
, LTnum
, lessthanothers
);
1618 op_order(L
, l_lei
, LEnum
, lessequalothers
);
1624 /* basic types do not use '__eq'; we can use raw equality */
1625 int cond
= luaV_rawequalobj(s2v(ra
), rb
);
1632 int im
= GETARG_sB(i
);
1633 if (ttisinteger(s2v(ra
)))
1634 cond
= (ivalue(s2v(ra
)) == im
);
1635 else if (ttisfloat(s2v(ra
)))
1636 cond
= luai_numeq(fltvalue(s2v(ra
)), cast_num(im
));
1638 cond
= 0; /* other types cannot be equal to a number */
1643 op_orderI(L
, l_lti
, luai_numlt
, 0, TM_LT
);
1647 op_orderI(L
, l_lei
, luai_numle
, 0, TM_LE
);
1651 op_orderI(L
, l_gti
, luai_numgt
, 1, TM_LT
);
1655 op_orderI(L
, l_gei
, luai_numge
, 1, TM_LE
);
1660 int cond
= !l_isfalse(s2v(ra
));
1664 vmcase(OP_TESTSET
) {
1666 TValue
*rb
= vRB(i
);
1667 if (l_isfalse(rb
) == GETARG_k(i
))
1670 setobj2s(L
, ra
, rb
);
1678 int b
= GETARG_B(i
);
1679 int nresults
= GETARG_C(i
) - 1;
1680 if (b
!= 0) /* fixed number of arguments? */
1681 L
->top
.p
= ra
+ b
; /* top signals number of arguments */
1682 /* else previous instruction set top */
1683 savepc(L
); /* in case of errors */
1684 if ((newci
= luaD_precall(L
, ra
, nresults
)) == NULL
)
1685 updatetrap(ci
); /* C call; nothing else to be done */
1686 else { /* Lua call: run function in this same C frame */
1692 vmcase(OP_TAILCALL
) {
1694 int b
= GETARG_B(i
); /* number of arguments + 1 (function) */
1695 int n
; /* number of results when calling a C function */
1696 int nparams1
= GETARG_C(i
);
1697 /* delta is virtual 'func' - real 'func' (vararg functions) */
1698 int delta
= (nparams1
) ? ci
->u
.l
.nextraargs
+ nparams1
: 0;
1701 else /* previous instruction set top */
1702 b
= cast_int(L
->top
.p
- ra
);
1703 savepc(ci
); /* several calls here can raise errors */
1705 luaF_closeupval(L
, base
); /* close upvalues from current call */
1706 lua_assert(L
->tbclist
.p
< base
); /* no pending tbc variables */
1707 lua_assert(base
== ci
->func
.p
+ 1);
1709 if ((n
= luaD_pretailcall(L
, ci
, ra
, b
, delta
)) < 0) /* Lua function? */
1710 goto startfunc
; /* execute the callee */
1711 else { /* C function? */
1712 ci
->func
.p
-= delta
; /* restore 'func' (if vararg) */
1713 luaD_poscall(L
, ci
, n
); /* finish caller */
1714 updatetrap(ci
); /* 'luaD_poscall' can change hooks */
1715 goto ret
; /* caller returns after the tail call */
1720 int n
= GETARG_B(i
) - 1; /* number of results */
1721 int nparams1
= GETARG_C(i
);
1722 if (n
< 0) /* not fixed? */
1723 n
= cast_int(L
->top
.p
- ra
); /* get what is available */
1725 if (TESTARG_k(i
)) { /* may there be open upvalues? */
1726 ci
->u2
.nres
= n
; /* save number of returns */
1727 if (L
->top
.p
< ci
->top
.p
)
1728 L
->top
.p
= ci
->top
.p
;
1729 luaF_close(L
, base
, CLOSEKTOP
, 1);
1733 if (nparams1
) /* vararg function? */
1734 ci
->func
.p
-= ci
->u
.l
.nextraargs
+ nparams1
;
1735 L
->top
.p
= ra
+ n
; /* set call for 'luaD_poscall' */
1736 luaD_poscall(L
, ci
, n
);
1737 updatetrap(ci
); /* 'luaD_poscall' can change hooks */
1740 vmcase(OP_RETURN0
) {
1741 if (l_unlikely(L
->hookmask
)) {
1745 luaD_poscall(L
, ci
, 0); /* no hurry... */
1748 else { /* do the 'poscall' here */
1750 L
->ci
= ci
->previous
; /* back to caller */
1751 L
->top
.p
= base
- 1;
1752 for (nres
= ci
->nresults
; l_unlikely(nres
> 0); nres
--)
1753 setnilvalue(s2v(L
->top
.p
++)); /* all results are nil */
1757 vmcase(OP_RETURN1
) {
1758 if (l_unlikely(L
->hookmask
)) {
1762 luaD_poscall(L
, ci
, 1); /* no hurry... */
1765 else { /* do the 'poscall' here */
1766 int nres
= ci
->nresults
;
1767 L
->ci
= ci
->previous
; /* back to caller */
1769 L
->top
.p
= base
- 1; /* asked for no results */
1772 setobjs2s(L
, base
- 1, ra
); /* at least this result */
1774 for (; l_unlikely(nres
> 1); nres
--)
1775 setnilvalue(s2v(L
->top
.p
++)); /* complete missing results */
1778 ret
: /* return from a Lua function */
1779 if (ci
->callstatus
& CIST_FRESH
)
1780 return; /* end this frame */
1783 goto returning
; /* continue running caller in this frame */
1786 vmcase(OP_FORLOOP
) {
1788 if (ttisinteger(s2v(ra
+ 2))) { /* integer loop? */
1789 lua_Unsigned count
= l_castS2U(ivalue(s2v(ra
+ 1)));
1790 if (count
> 0) { /* still more iterations? */
1791 lua_Integer step
= ivalue(s2v(ra
+ 2));
1792 lua_Integer idx
= ivalue(s2v(ra
)); /* internal index */
1793 chgivalue(s2v(ra
+ 1), count
- 1); /* update counter */
1794 idx
= intop(+, idx
, step
); /* add step to index */
1795 chgivalue(s2v(ra
), idx
); /* update internal index */
1796 setivalue(s2v(ra
+ 3), idx
); /* and control variable */
1797 pc
-= GETARG_Bx(i
); /* jump back */
1800 else if (floatforloop(ra
)) /* float loop */
1801 pc
-= GETARG_Bx(i
); /* jump back */
1802 updatetrap(ci
); /* allows a signal to break the loop */
1805 vmcase(OP_FORPREP
) {
1807 savestate(L
, ci
); /* in case of errors */
1809 pc
+= GETARG_Bx(i
) + 1; /* skip the loop */
1812 vmcase(OP_TFORPREP
) {
1814 /* create to-be-closed upvalue (if needed) */
1815 halfProtect(luaF_newtbcupval(L
, ra
+ 3));
1817 i
= *(pc
++); /* go to next instruction */
1818 lua_assert(GET_OPCODE(i
) == OP_TFORCALL
&& ra
== RA(i
));
1821 vmcase(OP_TFORCALL
) {
1824 /* 'ra' has the iterator function, 'ra + 1' has the state,
1825 'ra + 2' has the control variable, and 'ra + 3' has the
1826 to-be-closed variable. The call will use the stack after
1827 these values (starting at 'ra + 4')
1829 /* push function, state, and control variable */
1830 memcpy(ra
+ 4, ra
, 3 * sizeof(*ra
));
1831 L
->top
.p
= ra
+ 4 + 3;
1832 ProtectNT(luaD_call(L
, ra
+ 4, GETARG_C(i
))); /* do the call */
1833 updatestack(ci
); /* stack may have changed */
1834 i
= *(pc
++); /* go to next instruction */
1835 lua_assert(GET_OPCODE(i
) == OP_TFORLOOP
&& ra
== RA(i
));
1838 vmcase(OP_TFORLOOP
) {
1841 if (!ttisnil(s2v(ra
+ 4))) { /* continue loop? */
1842 setobjs2s(L
, ra
+ 2, ra
+ 4); /* save control variable */
1843 pc
-= GETARG_Bx(i
); /* jump back */
1847 vmcase(OP_SETLIST
) {
1849 int n
= GETARG_B(i
);
1850 unsigned int last
= GETARG_C(i
);
1851 Table
*h
= hvalue(s2v(ra
));
1853 n
= cast_int(L
->top
.p
- ra
) - 1; /* get up to the top */
1855 L
->top
.p
= ci
->top
.p
; /* correct top in case of emergency GC */
1858 last
+= GETARG_Ax(*pc
) * (MAXARG_C
+ 1);
1861 if (last
> luaH_realasize(h
)) /* needs more space? */
1862 luaH_resizearray(L
, h
, last
); /* preallocate it at once */
1863 for (; n
> 0; n
--) {
1864 TValue
*val
= s2v(ra
+ n
);
1865 setobj2t(L
, &h
->array
[last
- 1], val
);
1867 luaC_barrierback(L
, obj2gco(h
), val
);
1871 vmcase(OP_CLOSURE
) {
1873 Proto
*p
= cl
->p
->p
[GETARG_Bx(i
)];
1874 halfProtect(pushclosure(L
, p
, cl
->upvals
, base
, ra
));
1880 int n
= GETARG_C(i
) - 1; /* required results */
1881 Protect(luaT_getvarargs(L
, ci
, ra
, n
));
1884 vmcase(OP_VARARGPREP
) {
1885 ProtectNT(luaT_adjustvarargs(L
, GETARG_A(i
), ci
, cl
->p
));
1886 if (l_unlikely(trap
)) { /* previous "Protect" updated trap */
1887 luaD_hookcall(L
, ci
);
1888 L
->oldpc
= 1; /* next opcode will be seen as a "new" line */
1890 updatebase(ci
); /* function has new base after adjustment */
1893 vmcase(OP_EXTRAARG
) {
1901 /* }================================================================== */