]>
git.zerfleddert.de Git - proxmark3-svn/blob - liblua/lvm.c
2 ** $Id: lvm.c,v 2.155 2013/03/16 21:10:18 roberto Exp $
4 ** See Copyright Notice in lua.h
31 /* limit for table tag-method chains (to avoid loops) */
32 #define MAXTAGLOOP 100
35 const TValue
*luaV_tonumber (const TValue
*obj
, TValue
*n
) {
37 if (ttisnumber(obj
)) return obj
;
38 if (ttisstring(obj
) && luaO_str2d(svalue(obj
), tsvalue(obj
)->len
, &num
)) {
47 int luaV_tostring (lua_State
*L
, StkId obj
) {
51 char s
[LUAI_MAXNUMBER2STR
];
52 lua_Number n
= nvalue(obj
);
53 int l
= lua_number2str(s
, n
);
54 setsvalue2s(L
, obj
, luaS_newlstr(L
, s
, l
));
60 static void traceexec (lua_State
*L
) {
62 lu_byte mask
= L
->hookmask
;
63 int counthook
= ((mask
& LUA_MASKCOUNT
) && L
->hookcount
== 0);
65 resethookcount(L
); /* reset count */
66 if (ci
->callstatus
& CIST_HOOKYIELD
) { /* called hook last time? */
67 ci
->callstatus
&= ~CIST_HOOKYIELD
; /* erase mark */
68 return; /* do not call hook again (VM yielded, so it did not move) */
71 luaD_hook(L
, LUA_HOOKCOUNT
, -1); /* call count hook */
72 if (mask
& LUA_MASKLINE
) {
73 Proto
*p
= ci_func(ci
)->p
;
74 int npc
= pcRel(ci
->u
.l
.savedpc
, p
);
75 int newline
= getfuncline(p
, npc
);
76 if (npc
== 0 || /* call linehook when enter a new function, */
77 ci
->u
.l
.savedpc
<= L
->oldpc
|| /* when jump back (loop), or when */
78 newline
!= getfuncline(p
, pcRel(L
->oldpc
, p
))) /* enter a new line */
79 luaD_hook(L
, LUA_HOOKLINE
, newline
); /* call line hook */
81 L
->oldpc
= ci
->u
.l
.savedpc
;
82 if (L
->status
== LUA_YIELD
) { /* did hook yield? */
84 L
->hookcount
= 1; /* undo decrement to zero */
85 ci
->u
.l
.savedpc
--; /* undo increment (resume will increment it again) */
86 ci
->callstatus
|= CIST_HOOKYIELD
; /* mark that it yielded */
87 ci
->func
= L
->top
- 1; /* protect stack below results */
88 luaD_throw(L
, LUA_YIELD
);
93 static void callTM (lua_State
*L
, const TValue
*f
, const TValue
*p1
,
94 const TValue
*p2
, TValue
*p3
, int hasres
) {
95 ptrdiff_t result
= savestack(L
, p3
);
96 setobj2s(L
, L
->top
++, f
); /* push function */
97 setobj2s(L
, L
->top
++, p1
); /* 1st argument */
98 setobj2s(L
, L
->top
++, p2
); /* 2nd argument */
99 if (!hasres
) /* no result? 'p3' is third argument */
100 setobj2s(L
, L
->top
++, p3
); /* 3rd argument */
101 /* metamethod may yield only when called from Lua code */
102 luaD_call(L
, L
->top
- (4 - hasres
), hasres
, isLua(L
->ci
));
103 if (hasres
) { /* if has result, move it to its place */
104 p3
= restorestack(L
, result
);
105 setobjs2s(L
, p3
, --L
->top
);
110 void luaV_gettable (lua_State
*L
, const TValue
*t
, TValue
*key
, StkId val
) {
112 for (loop
= 0; loop
< MAXTAGLOOP
; loop
++) {
114 if (ttistable(t
)) { /* `t' is a table? */
115 Table
*h
= hvalue(t
);
116 const TValue
*res
= luaH_get(h
, key
); /* do a primitive get */
117 if (!ttisnil(res
) || /* result is not nil? */
118 (tm
= fasttm(L
, h
->metatable
, TM_INDEX
)) == NULL
) { /* or no TM? */
119 setobj2s(L
, val
, res
);
122 /* else will try the tag method */
124 else if (ttisnil(tm
= luaT_gettmbyobj(L
, t
, TM_INDEX
)))
125 luaG_typeerror(L
, t
, "index");
126 if (ttisfunction(tm
)) {
127 callTM(L
, tm
, t
, key
, val
, 1);
130 t
= tm
; /* else repeat with 'tm' */
132 luaG_runerror(L
, "loop in gettable");
136 void luaV_settable (lua_State
*L
, const TValue
*t
, TValue
*key
, StkId val
) {
138 for (loop
= 0; loop
< MAXTAGLOOP
; loop
++) {
140 if (ttistable(t
)) { /* `t' is a table? */
141 Table
*h
= hvalue(t
);
142 TValue
*oldval
= cast(TValue
*, luaH_get(h
, key
));
143 /* if previous value is not nil, there must be a previous entry
144 in the table; moreover, a metamethod has no relevance */
145 if (!ttisnil(oldval
) ||
146 /* previous value is nil; must check the metamethod */
147 ((tm
= fasttm(L
, h
->metatable
, TM_NEWINDEX
)) == NULL
&&
148 /* no metamethod; is there a previous entry in the table? */
149 (oldval
!= luaO_nilobject
||
150 /* no previous entry; must create one. (The next test is
151 always true; we only need the assignment.) */
152 (oldval
= luaH_newkey(L
, h
, key
), 1)))) {
153 /* no metamethod and (now) there is an entry with given key */
154 setobj2t(L
, oldval
, val
); /* assign new value to that entry */
155 invalidateTMcache(h
);
156 luaC_barrierback(L
, obj2gco(h
), val
);
159 /* else will try the metamethod */
161 else /* not a table; check metamethod */
162 if (ttisnil(tm
= luaT_gettmbyobj(L
, t
, TM_NEWINDEX
)))
163 luaG_typeerror(L
, t
, "index");
164 /* there is a metamethod */
165 if (ttisfunction(tm
)) {
166 callTM(L
, tm
, t
, key
, val
, 0);
169 t
= tm
; /* else repeat with 'tm' */
171 luaG_runerror(L
, "loop in settable");
175 static int call_binTM (lua_State
*L
, const TValue
*p1
, const TValue
*p2
,
176 StkId res
, TMS event
) {
177 const TValue
*tm
= luaT_gettmbyobj(L
, p1
, event
); /* try first operand */
179 tm
= luaT_gettmbyobj(L
, p2
, event
); /* try second operand */
180 if (ttisnil(tm
)) return 0;
181 callTM(L
, tm
, p1
, p2
, res
, 1);
186 static const TValue
*get_equalTM (lua_State
*L
, Table
*mt1
, Table
*mt2
,
188 const TValue
*tm1
= fasttm(L
, mt1
, event
);
190 if (tm1
== NULL
) return NULL
; /* no metamethod */
191 if (mt1
== mt2
) return tm1
; /* same metatables => same metamethods */
192 tm2
= fasttm(L
, mt2
, event
);
193 if (tm2
== NULL
) return NULL
; /* no metamethod */
194 if (luaV_rawequalobj(tm1
, tm2
)) /* same metamethods? */
200 static int call_orderTM (lua_State
*L
, const TValue
*p1
, const TValue
*p2
,
202 if (!call_binTM(L
, p1
, p2
, L
->top
, event
))
203 return -1; /* no metamethod */
205 return !l_isfalse(L
->top
);
209 static int l_strcmp (const TString
*ls
, const TString
*rs
) {
210 const char *l
= getstr(ls
);
211 size_t ll
= ls
->tsv
.len
;
212 const char *r
= getstr(rs
);
213 size_t lr
= rs
->tsv
.len
;
215 int temp
= strcoll(l
, r
);
216 if (temp
!= 0) return temp
;
217 else { /* strings are equal up to a `\0' */
218 size_t len
= strlen(l
); /* index of first `\0' in both strings */
219 if (len
== lr
) /* r is finished? */
220 return (len
== ll
) ? 0 : 1;
221 else if (len
== ll
) /* l is finished? */
222 return -1; /* l is smaller than r (because r is not finished) */
223 /* both strings longer than `len'; go on comparing (after the `\0') */
225 l
+= len
; ll
-= len
; r
+= len
; lr
-= len
;
231 int luaV_lessthan (lua_State
*L
, const TValue
*l
, const TValue
*r
) {
233 if (ttisnumber(l
) && ttisnumber(r
))
234 return luai_numlt(L
, nvalue(l
), nvalue(r
));
235 else if (ttisstring(l
) && ttisstring(r
))
236 return l_strcmp(rawtsvalue(l
), rawtsvalue(r
)) < 0;
237 else if ((res
= call_orderTM(L
, l
, r
, TM_LT
)) < 0)
238 luaG_ordererror(L
, l
, r
);
243 int luaV_lessequal (lua_State
*L
, const TValue
*l
, const TValue
*r
) {
245 if (ttisnumber(l
) && ttisnumber(r
))
246 return luai_numle(L
, nvalue(l
), nvalue(r
));
247 else if (ttisstring(l
) && ttisstring(r
))
248 return l_strcmp(rawtsvalue(l
), rawtsvalue(r
)) <= 0;
249 else if ((res
= call_orderTM(L
, l
, r
, TM_LE
)) >= 0) /* first try `le' */
251 else if ((res
= call_orderTM(L
, r
, l
, TM_LT
)) < 0) /* else try `lt' */
252 luaG_ordererror(L
, l
, r
);
258 ** equality of Lua values. L == NULL means raw equality (no metamethods)
260 int luaV_equalobj_ (lua_State
*L
, const TValue
*t1
, const TValue
*t2
) {
262 lua_assert(ttisequal(t1
, t2
));
264 case LUA_TNIL
: return 1;
265 case LUA_TNUMBER
: return luai_numeq(nvalue(t1
), nvalue(t2
));
266 case LUA_TBOOLEAN
: return bvalue(t1
) == bvalue(t2
); /* true must be 1 !! */
267 case LUA_TLIGHTUSERDATA
: return pvalue(t1
) == pvalue(t2
);
268 case LUA_TLCF
: return fvalue(t1
) == fvalue(t2
);
269 case LUA_TSHRSTR
: return eqshrstr(rawtsvalue(t1
), rawtsvalue(t2
));
270 case LUA_TLNGSTR
: return luaS_eqlngstr(rawtsvalue(t1
), rawtsvalue(t2
));
271 case LUA_TUSERDATA
: {
272 if (uvalue(t1
) == uvalue(t2
)) return 1;
273 else if (L
== NULL
) return 0;
274 tm
= get_equalTM(L
, uvalue(t1
)->metatable
, uvalue(t2
)->metatable
, TM_EQ
);
275 break; /* will try TM */
278 if (hvalue(t1
) == hvalue(t2
)) return 1;
279 else if (L
== NULL
) return 0;
280 tm
= get_equalTM(L
, hvalue(t1
)->metatable
, hvalue(t2
)->metatable
, TM_EQ
);
281 break; /* will try TM */
284 lua_assert(iscollectable(t1
));
285 return gcvalue(t1
) == gcvalue(t2
);
287 if (tm
== NULL
) return 0; /* no TM? */
288 callTM(L
, tm
, t1
, t2
, L
->top
, 1); /* call TM */
289 return !l_isfalse(L
->top
);
293 void luaV_concat (lua_State
*L
, int total
) {
294 lua_assert(total
>= 2);
297 int n
= 2; /* number of elements handled in this pass (at least 2) */
298 if (!(ttisstring(top
-2) || ttisnumber(top
-2)) || !tostring(L
, top
-1)) {
299 if (!call_binTM(L
, top
-2, top
-1, top
-2, TM_CONCAT
))
300 luaG_concaterror(L
, top
-2, top
-1);
302 else if (tsvalue(top
-1)->len
== 0) /* second operand is empty? */
303 (void)tostring(L
, top
- 2); /* result is first operand */
304 else if (ttisstring(top
-2) && tsvalue(top
-2)->len
== 0) {
305 setobjs2s(L
, top
- 2, top
- 1); /* result is second op. */
308 /* at least two non-empty string values; get as many as possible */
309 size_t tl
= tsvalue(top
-1)->len
;
312 /* collect total length */
313 for (i
= 1; i
< total
&& tostring(L
, top
-i
-1); i
++) {
314 size_t l
= tsvalue(top
-i
-1)->len
;
315 if (l
>= (MAX_SIZET
/sizeof(char)) - tl
)
316 luaG_runerror(L
, "string length overflow");
319 buffer
= luaZ_openspace(L
, &G(L
)->buff
, tl
);
322 do { /* concat all strings */
323 size_t l
= tsvalue(top
-i
)->len
;
324 memcpy(buffer
+tl
, svalue(top
-i
), l
* sizeof(char));
327 setsvalue2s(L
, top
-n
, luaS_newlstr(L
, buffer
, tl
));
329 total
-= n
-1; /* got 'n' strings to create 1 new */
330 L
->top
-= n
-1; /* popped 'n' strings and pushed one */
331 } while (total
> 1); /* repeat until only 1 result left */
335 void luaV_objlen (lua_State
*L
, StkId ra
, const TValue
*rb
) {
337 switch (ttypenv(rb
)) {
339 Table
*h
= hvalue(rb
);
340 tm
= fasttm(L
, h
->metatable
, TM_LEN
);
341 if (tm
) break; /* metamethod? break switch to call it */
342 setnvalue(ra
, cast_num(luaH_getn(h
))); /* else primitive len */
346 setnvalue(ra
, cast_num(tsvalue(rb
)->len
));
349 default: { /* try metamethod */
350 tm
= luaT_gettmbyobj(L
, rb
, TM_LEN
);
351 if (ttisnil(tm
)) /* no metamethod? */
352 luaG_typeerror(L
, rb
, "get length of");
356 callTM(L
, tm
, rb
, rb
, ra
, 1);
360 void luaV_arith (lua_State
*L
, StkId ra
, const TValue
*rb
,
361 const TValue
*rc
, TMS op
) {
364 if ((b
= luaV_tonumber(rb
, &tempb
)) != NULL
&&
365 (c
= luaV_tonumber(rc
, &tempc
)) != NULL
) {
366 lua_Number res
= luaO_arith(op
- TM_ADD
+ LUA_OPADD
, nvalue(b
), nvalue(c
));
369 else if (!call_binTM(L
, rb
, rc
, ra
, op
))
370 luaG_aritherror(L
, rb
, rc
);
375 ** check whether cached closure in prototype 'p' may be reused, that is,
376 ** whether there is a cached closure with the same upvalues needed by
377 ** new closure to be created.
379 static Closure
*getcached (Proto
*p
, UpVal
**encup
, StkId base
) {
380 Closure
*c
= p
->cache
;
381 if (c
!= NULL
) { /* is there a cached closure? */
382 int nup
= p
->sizeupvalues
;
383 Upvaldesc
*uv
= p
->upvalues
;
385 for (i
= 0; i
< nup
; i
++) { /* check whether it has right upvalues */
386 TValue
*v
= uv
[i
].instack
? base
+ uv
[i
].idx
: encup
[uv
[i
].idx
]->v
;
387 if (c
->l
.upvals
[i
]->v
!= v
)
388 return NULL
; /* wrong upvalue; cannot reuse closure */
391 return c
; /* return cached closure (or NULL if no cached closure) */
396 ** create a new Lua closure, push it in the stack, and initialize
397 ** its upvalues. Note that the call to 'luaC_barrierproto' must come
398 ** before the assignment to 'p->cache', as the function needs the
399 ** original value of that field.
401 static void pushclosure (lua_State
*L
, Proto
*p
, UpVal
**encup
, StkId base
,
403 int nup
= p
->sizeupvalues
;
404 Upvaldesc
*uv
= p
->upvalues
;
406 Closure
*ncl
= luaF_newLclosure(L
, nup
);
408 setclLvalue(L
, ra
, ncl
); /* anchor new closure in stack */
409 for (i
= 0; i
< nup
; i
++) { /* fill in its upvalues */
410 if (uv
[i
].instack
) /* upvalue refers to local variable? */
411 ncl
->l
.upvals
[i
] = luaF_findupval(L
, base
+ uv
[i
].idx
);
412 else /* get upvalue from enclosing function */
413 ncl
->l
.upvals
[i
] = encup
[uv
[i
].idx
];
415 luaC_barrierproto(L
, p
, ncl
);
416 p
->cache
= ncl
; /* save it on cache for reuse */
421 ** finish execution of an opcode interrupted by an yield
423 void luaV_finishOp (lua_State
*L
) {
424 CallInfo
*ci
= L
->ci
;
425 StkId base
= ci
->u
.l
.base
;
426 Instruction inst
= *(ci
->u
.l
.savedpc
- 1); /* interrupted instruction */
427 OpCode op
= GET_OPCODE(inst
);
428 switch (op
) { /* finish its execution */
429 case OP_ADD
: case OP_SUB
: case OP_MUL
: case OP_DIV
:
430 case OP_MOD
: case OP_POW
: case OP_UNM
: case OP_LEN
:
431 case OP_GETTABUP
: case OP_GETTABLE
: case OP_SELF
: {
432 setobjs2s(L
, base
+ GETARG_A(inst
), --L
->top
);
435 case OP_LE
: case OP_LT
: case OP_EQ
: {
436 int res
= !l_isfalse(L
->top
- 1);
438 /* metamethod should not be called when operand is K */
439 lua_assert(!ISK(GETARG_B(inst
)));
440 if (op
== OP_LE
&& /* "<=" using "<" instead? */
441 ttisnil(luaT_gettmbyobj(L
, base
+ GETARG_B(inst
), TM_LE
)))
442 res
= !res
; /* invert result */
443 lua_assert(GET_OPCODE(*ci
->u
.l
.savedpc
) == OP_JMP
);
444 if (res
!= GETARG_A(inst
)) /* condition failed? */
445 ci
->u
.l
.savedpc
++; /* skip jump instruction */
449 StkId top
= L
->top
- 1; /* top when 'call_binTM' was called */
450 int b
= GETARG_B(inst
); /* first element to concatenate */
451 int total
= cast_int(top
- 1 - (base
+ b
)); /* yet to concatenate */
452 setobj2s(L
, top
- 2, top
); /* put TM result in proper position */
453 if (total
> 1) { /* are there elements to concat? */
454 L
->top
= top
- 1; /* top is one after last element (at top-2) */
455 luaV_concat(L
, total
); /* concat them (may yield again) */
457 /* move final result to final position */
458 setobj2s(L
, ci
->u
.l
.base
+ GETARG_A(inst
), L
->top
- 1);
459 L
->top
= ci
->top
; /* restore top */
463 lua_assert(GET_OPCODE(*ci
->u
.l
.savedpc
) == OP_TFORLOOP
);
464 L
->top
= ci
->top
; /* correct top */
468 if (GETARG_C(inst
) - 1 >= 0) /* nresults >= 0? */
469 L
->top
= ci
->top
; /* adjust results */
472 case OP_TAILCALL
: case OP_SETTABUP
: case OP_SETTABLE
:
474 default: lua_assert(0);
481 ** some macros for common tasks in `luaV_execute'
484 #if !defined luai_runtimecheck
485 #define luai_runtimecheck(L, c) /* void */
489 #define RA(i) (base+GETARG_A(i))
490 /* to be used after possible stack reallocation */
491 #define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
492 #define RC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))
493 #define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \
494 ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))
495 #define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \
496 ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))
498 (k + (GETARG_Bx(i) != 0 ? GETARG_Bx(i) - 1 : GETARG_Ax(*ci->u.l.savedpc++)))
501 /* execute a jump instruction */
502 #define dojump(ci,i,e) \
503 { int a = GETARG_A(i); \
504 if (a > 0) luaF_close(L, ci->u.l.base + a - 1); \
505 ci->u.l.savedpc += GETARG_sBx(i) + e; }
507 /* for test instructions, execute the jump instruction that follows it */
508 #define donextjump(ci) { i = *ci->u.l.savedpc; dojump(ci, i, 1); }
511 #define Protect(x) { {x;}; base = ci->u.l.base; }
513 #define checkGC(L,c) \
514 Protect( luaC_condGC(L,{L->top = (c); /* limit of live values */ \
516 L->top = ci->top;}) /* restore top */ \
517 luai_threadyield(L); )
520 #define arith_op(op,tm) { \
521 TValue *rb = RKB(i); \
522 TValue *rc = RKC(i); \
523 if (ttisnumber(rb) && ttisnumber(rc)) { \
524 lua_Number nb = nvalue(rb), nc = nvalue(rc); \
525 setnvalue(ra, op(L, nb, nc)); \
527 else { Protect(luaV_arith(L, ra, rb, rc, tm)); } }
530 #define vmdispatch(o) switch(o)
531 #define vmcase(l,b) case l: {b} break;
532 #define vmcasenb(l,b) case l: {b} /* nb = no break */
534 void luaV_execute (lua_State
*L
) {
535 CallInfo
*ci
= L
->ci
;
539 newframe
: /* reentry point when frame changes (call/return) */
540 lua_assert(ci
== L
->ci
);
541 cl
= clLvalue(ci
->func
);
544 /* main loop of interpreter */
546 Instruction i
= *(ci
->u
.l
.savedpc
++);
548 if ((L
->hookmask
& (LUA_MASKLINE
| LUA_MASKCOUNT
)) &&
549 (--L
->hookcount
== 0 || L
->hookmask
& LUA_MASKLINE
)) {
550 Protect(traceexec(L
));
552 /* WARNING: several calls may realloc the stack and invalidate `ra' */
554 lua_assert(base
== ci
->u
.l
.base
);
555 lua_assert(base
<= L
->top
&& L
->top
< L
->stack
+ L
->stacksize
);
556 vmdispatch (GET_OPCODE(i
)) {
558 setobjs2s(L
, ra
, RB(i
));
561 TValue
*rb
= k
+ GETARG_Bx(i
);
566 lua_assert(GET_OPCODE(*ci
->u
.l
.savedpc
) == OP_EXTRAARG
);
567 rb
= k
+ GETARG_Ax(*ci
->u
.l
.savedpc
++);
571 setbvalue(ra
, GETARG_B(i
));
572 if (GETARG_C(i
)) ci
->u
.l
.savedpc
++; /* skip next instruction (if C) */
582 setobj2s(L
, ra
, cl
->upvals
[b
]->v
);
586 Protect(luaV_gettable(L
, cl
->upvals
[b
]->v
, RKC(i
), ra
));
589 Protect(luaV_gettable(L
, RB(i
), RKC(i
), ra
));
593 Protect(luaV_settable(L
, cl
->upvals
[a
]->v
, RKB(i
), RKC(i
)));
596 UpVal
*uv
= cl
->upvals
[GETARG_B(i
)];
597 setobj(L
, uv
->v
, ra
);
598 luaC_barrier(L
, uv
, ra
);
601 Protect(luaV_settable(L
, ra
, RKB(i
), RKC(i
)));
606 Table
*t
= luaH_new(L
);
608 if (b
!= 0 || c
!= 0)
609 luaH_resize(L
, t
, luaO_fb2int(b
), luaO_fb2int(c
));
614 setobjs2s(L
, ra
+1, rb
);
615 Protect(luaV_gettable(L
, rb
, RKC(i
), ra
));
618 arith_op(luai_numadd
, TM_ADD
);
621 arith_op(luai_numsub
, TM_SUB
);
624 arith_op(luai_nummul
, TM_MUL
);
627 arith_op(luai_numdiv
, TM_DIV
);
630 arith_op(luai_nummod
, TM_MOD
);
633 arith_op(luai_numpow
, TM_POW
);
637 if (ttisnumber(rb
)) {
638 lua_Number nb
= nvalue(rb
);
639 setnvalue(ra
, luai_numunm(L
, nb
));
642 Protect(luaV_arith(L
, ra
, rb
, rb
, TM_UNM
));
647 int res
= l_isfalse(rb
); /* next assignment may change this value */
651 Protect(luaV_objlen(L
, ra
, RB(i
)));
657 L
->top
= base
+ c
+ 1; /* mark the end of concat operands */
658 Protect(luaV_concat(L
, c
- b
+ 1));
659 ra
= RA(i
); /* 'luav_concat' may invoke TMs and move the stack */
661 setobjs2s(L
, ra
, rb
);
662 checkGC(L
, (ra
>= rb
? ra
+ 1 : rb
));
663 L
->top
= ci
->top
; /* restore top */
672 if (cast_int(equalobj(L
, rb
, rc
)) != GETARG_A(i
))
680 if (luaV_lessthan(L
, RKB(i
), RKC(i
)) != GETARG_A(i
))
688 if (luaV_lessequal(L
, RKB(i
), RKC(i
)) != GETARG_A(i
))
695 if (GETARG_C(i
) ? l_isfalse(ra
) : !l_isfalse(ra
))
702 if (GETARG_C(i
) ? l_isfalse(rb
) : !l_isfalse(rb
))
705 setobjs2s(L
, ra
, rb
);
711 int nresults
= GETARG_C(i
) - 1;
712 if (b
!= 0) L
->top
= ra
+b
; /* else previous instruction set top */
713 if (luaD_precall(L
, ra
, nresults
)) { /* C function? */
714 if (nresults
>= 0) L
->top
= ci
->top
; /* adjust results */
717 else { /* Lua function */
719 ci
->callstatus
|= CIST_REENTRY
;
720 goto newframe
; /* restart luaV_execute over new Lua function */
725 if (b
!= 0) L
->top
= ra
+b
; /* else previous instruction set top */
726 lua_assert(GETARG_C(i
) - 1 == LUA_MULTRET
);
727 if (luaD_precall(L
, ra
, LUA_MULTRET
)) /* C function? */
730 /* tail call: put called frame (n) in place of caller one (o) */
731 CallInfo
*nci
= L
->ci
; /* called frame */
732 CallInfo
*oci
= nci
->previous
; /* caller frame */
733 StkId nfunc
= nci
->func
; /* called function */
734 StkId ofunc
= oci
->func
; /* caller function */
735 /* last stack slot filled by 'precall' */
736 StkId lim
= nci
->u
.l
.base
+ getproto(nfunc
)->numparams
;
738 /* close all upvalues from previous call */
739 if (cl
->p
->sizep
> 0) luaF_close(L
, oci
->u
.l
.base
);
740 /* move new frame into old one */
741 for (aux
= 0; nfunc
+ aux
< lim
; aux
++)
742 setobjs2s(L
, ofunc
+ aux
, nfunc
+ aux
);
743 oci
->u
.l
.base
= ofunc
+ (nci
->u
.l
.base
- nfunc
); /* correct base */
744 oci
->top
= L
->top
= ofunc
+ (L
->top
- nfunc
); /* correct top */
745 oci
->u
.l
.savedpc
= nci
->u
.l
.savedpc
;
746 oci
->callstatus
|= CIST_TAIL
; /* function was tail called */
747 ci
= L
->ci
= oci
; /* remove new frame */
748 lua_assert(L
->top
== oci
->u
.l
.base
+ getproto(ofunc
)->maxstacksize
);
749 goto newframe
; /* restart luaV_execute over new Lua function */
754 if (b
!= 0) L
->top
= ra
+b
-1;
755 if (cl
->p
->sizep
> 0) luaF_close(L
, base
);
756 b
= luaD_poscall(L
, ra
);
757 if (!(ci
->callstatus
& CIST_REENTRY
)) /* 'ci' still the called one */
758 return; /* external invocation: return */
759 else { /* invocation via reentry: continue execution */
761 if (b
) L
->top
= ci
->top
;
762 lua_assert(isLua(ci
));
763 lua_assert(GET_OPCODE(*((ci
)->u
.l
.savedpc
- 1)) == OP_CALL
);
764 goto newframe
; /* restart luaV_execute over new Lua function */
768 lua_Number step
= nvalue(ra
+2);
769 lua_Number idx
= luai_numadd(L
, nvalue(ra
), step
); /* increment index */
770 lua_Number limit
= nvalue(ra
+1);
771 if (luai_numlt(L
, 0, step
) ? luai_numle(L
, idx
, limit
)
772 : luai_numle(L
, limit
, idx
)) {
773 ci
->u
.l
.savedpc
+= GETARG_sBx(i
); /* jump back */
774 setnvalue(ra
, idx
); /* update internal index... */
775 setnvalue(ra
+3, idx
); /* ...and external index */
779 const TValue
*init
= ra
;
780 const TValue
*plimit
= ra
+1;
781 const TValue
*pstep
= ra
+2;
782 if (!tonumber(init
, ra
))
783 luaG_runerror(L
, LUA_QL("for") " initial value must be a number");
784 else if (!tonumber(plimit
, ra
+1))
785 luaG_runerror(L
, LUA_QL("for") " limit must be a number");
786 else if (!tonumber(pstep
, ra
+2))
787 luaG_runerror(L
, LUA_QL("for") " step must be a number");
788 setnvalue(ra
, luai_numsub(L
, nvalue(ra
), nvalue(pstep
)));
789 ci
->u
.l
.savedpc
+= GETARG_sBx(i
);
791 vmcasenb(OP_TFORCALL
,
792 StkId cb
= ra
+ 3; /* call base */
793 setobjs2s(L
, cb
+2, ra
+2);
794 setobjs2s(L
, cb
+1, ra
+1);
795 setobjs2s(L
, cb
, ra
);
796 L
->top
= cb
+ 3; /* func. + 2 args (state and index) */
797 Protect(luaD_call(L
, cb
, GETARG_C(i
), 1));
799 i
= *(ci
->u
.l
.savedpc
++); /* go to next instruction */
801 lua_assert(GET_OPCODE(i
) == OP_TFORLOOP
);
806 if (!ttisnil(ra
+ 1)) { /* continue loop? */
807 setobjs2s(L
, ra
, ra
+ 1); /* save control variable */
808 ci
->u
.l
.savedpc
+= GETARG_sBx(i
); /* jump back */
816 if (n
== 0) n
= cast_int(L
->top
- ra
) - 1;
818 lua_assert(GET_OPCODE(*ci
->u
.l
.savedpc
) == OP_EXTRAARG
);
819 c
= GETARG_Ax(*ci
->u
.l
.savedpc
++);
821 luai_runtimecheck(L
, ttistable(ra
));
823 last
= ((c
-1)*LFIELDS_PER_FLUSH
) + n
;
824 if (last
> h
->sizearray
) /* needs more space? */
825 luaH_resizearray(L
, h
, last
); /* pre-allocate it at once */
828 luaH_setint(L
, h
, last
--, val
);
829 luaC_barrierback(L
, obj2gco(h
), val
);
831 L
->top
= ci
->top
; /* correct top (in case of previous open call) */
834 Proto
*p
= cl
->p
->p
[GETARG_Bx(i
)];
835 Closure
*ncl
= getcached(p
, cl
->upvals
, base
); /* cached closure */
836 if (ncl
== NULL
) /* no match? */
837 pushclosure(L
, p
, cl
->upvals
, base
, ra
); /* create a new one */
839 setclLvalue(L
, ra
, ncl
); /* push cashed closure */
843 int b
= GETARG_B(i
) - 1;
845 int n
= cast_int(base
- ci
->func
) - cl
->p
->numparams
- 1;
846 if (b
< 0) { /* B == 0? */
847 b
= n
; /* get all var. arguments */
848 Protect(luaD_checkstack(L
, n
));
849 ra
= RA(i
); /* previous call may change the stack */
852 for (j
= 0; j
< b
; j
++) {
854 setobjs2s(L
, ra
+ j
, base
- n
+ j
);