Mercurial > mm7

comparison lib/lua/lua-5.2.2/lvm.c @ 1866:41cc4dd3c122

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Lua 5.2.2 added.
author Nomad
date Wed, 16 Oct 2013 13:34:26 +0200
parents
children
comparison
equal deleted inserted replaced
1848:3b39b70e8e93 1866:41cc4dd3c122
1 /*
2 ** $Id: lvm.c,v 2.155 2013/03/16 21:10:18 roberto Exp $
3 ** Lua virtual machine
4 ** See Copyright Notice in lua.h
5 */
6
7
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11
12 #define lvm_c
13 #define LUA_CORE
14
15 #include "lua.h"
16
17 #include "ldebug.h"
18 #include "ldo.h"
19 #include "lfunc.h"
20 #include "lgc.h"
21 #include "lobject.h"
22 #include "lopcodes.h"
23 #include "lstate.h"
24 #include "lstring.h"
25 #include "ltable.h"
26 #include "ltm.h"
27 #include "lvm.h"
28
29
30
31 /* limit for table tag-method chains (to avoid loops) */
32 #define MAXTAGLOOP 100
33
34
35 const TValue *luaV_tonumber (const TValue *obj, TValue *n) {
36 lua_Number num;
37 if (ttisnumber(obj)) return obj;
38 if (ttisstring(obj) && luaO_str2d(svalue(obj), tsvalue(obj)->len, &num)) {
39 setnvalue(n, num);
40 return n;
41 }
42 else
43 return NULL;
44 }
45
46
47 int luaV_tostring (lua_State *L, StkId obj) {
48 if (!ttisnumber(obj))
49 return 0;
50 else {
51 char s[LUAI_MAXNUMBER2STR];
52 lua_Number n = nvalue(obj);
53 int l = lua_number2str(s, n);
54 setsvalue2s(L, obj, luaS_newlstr(L, s, l));
55 return 1;
56 }
57 }
58
59
60 static void traceexec (lua_State *L) {
61 CallInfo *ci = L->ci;
62 lu_byte mask = L->hookmask;
63 int counthook = ((mask & LUA_MASKCOUNT) && L->hookcount == 0);
64 if (counthook)
65 resethookcount(L); /* reset count */
66 if (ci->callstatus & CIST_HOOKYIELD) { /* called hook last time? */
67 ci->callstatus &= ~CIST_HOOKYIELD; /* erase mark */
68 return; /* do not call hook again (VM yielded, so it did not move) */
69 }
70 if (counthook)
71 luaD_hook(L, LUA_HOOKCOUNT, -1); /* call count hook */
72 if (mask & LUA_MASKLINE) {
73 Proto *p = ci_func(ci)->p;
74 int npc = pcRel(ci->u.l.savedpc, p);
75 int newline = getfuncline(p, npc);
76 if (npc == 0 || /* call linehook when enter a new function, */
77 ci->u.l.savedpc <= L->oldpc || /* when jump back (loop), or when */
78 newline != getfuncline(p, pcRel(L->oldpc, p))) /* enter a new line */
79 luaD_hook(L, LUA_HOOKLINE, newline); /* call line hook */
80 }
81 L->oldpc = ci->u.l.savedpc;
82 if (L->status == LUA_YIELD) { /* did hook yield? */
83 if (counthook)
84 L->hookcount = 1; /* undo decrement to zero */
85 ci->u.l.savedpc--; /* undo increment (resume will increment it again) */
86 ci->callstatus |= CIST_HOOKYIELD; /* mark that it yielded */
87 ci->func = L->top - 1; /* protect stack below results */
88 luaD_throw(L, LUA_YIELD);
89 }
90 }
91
92
93 static void callTM (lua_State *L, const TValue *f, const TValue *p1,
94 const TValue *p2, TValue *p3, int hasres) {
95 ptrdiff_t result = savestack(L, p3);
96 setobj2s(L, L->top++, f); /* push function */
97 setobj2s(L, L->top++, p1); /* 1st argument */
98 setobj2s(L, L->top++, p2); /* 2nd argument */
99 if (!hasres) /* no result? 'p3' is third argument */
100 setobj2s(L, L->top++, p3); /* 3rd argument */
101 /* metamethod may yield only when called from Lua code */
102 luaD_call(L, L->top - (4 - hasres), hasres, isLua(L->ci));
103 if (hasres) { /* if has result, move it to its place */
104 p3 = restorestack(L, result);
105 setobjs2s(L, p3, --L->top);
106 }
107 }
108
109
110 void luaV_gettable (lua_State *L, const TValue *t, TValue *key, StkId val) {
111 int loop;
112 for (loop = 0; loop < MAXTAGLOOP; loop++) {
113 const TValue *tm;
114 if (ttistable(t)) { /* `t' is a table? */
115 Table *h = hvalue(t);
116 const TValue *res = luaH_get(h, key); /* do a primitive get */
117 if (!ttisnil(res) || /* result is not nil? */
118 (tm = fasttm(L, h->metatable, TM_INDEX)) == NULL) { /* or no TM? */
119 setobj2s(L, val, res);
120 return;
121 }
122 /* else will try the tag method */
123 }
124 else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_INDEX)))
125 luaG_typeerror(L, t, "index");
126 if (ttisfunction(tm)) {
127 callTM(L, tm, t, key, val, 1);
128 return;
129 }
130 t = tm; /* else repeat with 'tm' */
131 }
132 luaG_runerror(L, "loop in gettable");
133 }
134
135
136 void luaV_settable (lua_State *L, const TValue *t, TValue *key, StkId val) {
137 int loop;
138 for (loop = 0; loop < MAXTAGLOOP; loop++) {
139 const TValue *tm;
140 if (ttistable(t)) { /* `t' is a table? */
141 Table *h = hvalue(t);
142 TValue *oldval = cast(TValue *, luaH_get(h, key));
143 /* if previous value is not nil, there must be a previous entry
144 in the table; moreover, a metamethod has no relevance */
145 if (!ttisnil(oldval) ||
146 /* previous value is nil; must check the metamethod */
147 ((tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL &&
148 /* no metamethod; is there a previous entry in the table? */
149 (oldval != luaO_nilobject ||
150 /* no previous entry; must create one. (The next test is
151 always true; we only need the assignment.) */
152 (oldval = luaH_newkey(L, h, key), 1)))) {
153 /* no metamethod and (now) there is an entry with given key */
154 setobj2t(L, oldval, val); /* assign new value to that entry */
155 invalidateTMcache(h);
156 luaC_barrierback(L, obj2gco(h), val);
157 return;
158 }
159 /* else will try the metamethod */
160 }
161 else /* not a table; check metamethod */
162 if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
163 luaG_typeerror(L, t, "index");
164 /* there is a metamethod */
165 if (ttisfunction(tm)) {
166 callTM(L, tm, t, key, val, 0);
167 return;
168 }
169 t = tm; /* else repeat with 'tm' */
170 }
171 luaG_runerror(L, "loop in settable");
172 }
173
174
175 static int call_binTM (lua_State *L, const TValue *p1, const TValue *p2,
176 StkId res, TMS event) {
177 const TValue *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */
178 if (ttisnil(tm))
179 tm = luaT_gettmbyobj(L, p2, event); /* try second operand */
180 if (ttisnil(tm)) return 0;
181 callTM(L, tm, p1, p2, res, 1);
182 return 1;
183 }
184
185
186 static const TValue *get_equalTM (lua_State *L, Table *mt1, Table *mt2,
187 TMS event) {
188 const TValue *tm1 = fasttm(L, mt1, event);
189 const TValue *tm2;
190 if (tm1 == NULL) return NULL; /* no metamethod */
191 if (mt1 == mt2) return tm1; /* same metatables => same metamethods */
192 tm2 = fasttm(L, mt2, event);
193 if (tm2 == NULL) return NULL; /* no metamethod */
194 if (luaV_rawequalobj(tm1, tm2)) /* same metamethods? */
195 return tm1;
196 return NULL;
197 }
198
199
200 static int call_orderTM (lua_State *L, const TValue *p1, const TValue *p2,
201 TMS event) {
202 if (!call_binTM(L, p1, p2, L->top, event))
203 return -1; /* no metamethod */
204 else
205 return !l_isfalse(L->top);
206 }
207
208
209 static int l_strcmp (const TString *ls, const TString *rs) {
210 const char *l = getstr(ls);
211 size_t ll = ls->tsv.len;
212 const char *r = getstr(rs);
213 size_t lr = rs->tsv.len;
214 for (;;) {
215 int temp = strcoll(l, r);
216 if (temp != 0) return temp;
217 else { /* strings are equal up to a `\0' */
218 size_t len = strlen(l); /* index of first `\0' in both strings */
219 if (len == lr) /* r is finished? */
220 return (len == ll) ? 0 : 1;
221 else if (len == ll) /* l is finished? */
222 return -1; /* l is smaller than r (because r is not finished) */
223 /* both strings longer than `len'; go on comparing (after the `\0') */
224 len++;
225 l += len; ll -= len; r += len; lr -= len;
226 }
227 }
228 }
229
230
231 int luaV_lessthan (lua_State *L, const TValue *l, const TValue *r) {
232 int res;
233 if (ttisnumber(l) && ttisnumber(r))
234 return luai_numlt(L, nvalue(l), nvalue(r));
235 else if (ttisstring(l) && ttisstring(r))
236 return l_strcmp(rawtsvalue(l), rawtsvalue(r)) < 0;
237 else if ((res = call_orderTM(L, l, r, TM_LT)) < 0)
238 luaG_ordererror(L, l, r);
239 return res;
240 }
241
242
243 int luaV_lessequal (lua_State *L, const TValue *l, const TValue *r) {
244 int res;
245 if (ttisnumber(l) && ttisnumber(r))
246 return luai_numle(L, nvalue(l), nvalue(r));
247 else if (ttisstring(l) && ttisstring(r))
248 return l_strcmp(rawtsvalue(l), rawtsvalue(r)) <= 0;
249 else if ((res = call_orderTM(L, l, r, TM_LE)) >= 0) /* first try `le' */
250 return res;
251 else if ((res = call_orderTM(L, r, l, TM_LT)) < 0) /* else try `lt' */
252 luaG_ordererror(L, l, r);
253 return !res;
254 }
255
256
257 /*
258 ** equality of Lua values. L == NULL means raw equality (no metamethods)
259 */
260 int luaV_equalobj_ (lua_State *L, const TValue *t1, const TValue *t2) {
261 const TValue *tm;
262 lua_assert(ttisequal(t1, t2));
263 switch (ttype(t1)) {
264 case LUA_TNIL: return 1;
265 case LUA_TNUMBER: return luai_numeq(nvalue(t1), nvalue(t2));
266 case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */
267 case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
268 case LUA_TLCF: return fvalue(t1) == fvalue(t2);
269 case LUA_TSHRSTR: return eqshrstr(rawtsvalue(t1), rawtsvalue(t2));
270 case LUA_TLNGSTR: return luaS_eqlngstr(rawtsvalue(t1), rawtsvalue(t2));
271 case LUA_TUSERDATA: {
272 if (uvalue(t1) == uvalue(t2)) return 1;
273 else if (L == NULL) return 0;
274 tm = get_equalTM(L, uvalue(t1)->metatable, uvalue(t2)->metatable, TM_EQ);
275 break; /* will try TM */
276 }
277 case LUA_TTABLE: {
278 if (hvalue(t1) == hvalue(t2)) return 1;
279 else if (L == NULL) return 0;
280 tm = get_equalTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);
281 break; /* will try TM */
282 }
283 default:
284 lua_assert(iscollectable(t1));
285 return gcvalue(t1) == gcvalue(t2);
286 }
287 if (tm == NULL) return 0; /* no TM? */
288 callTM(L, tm, t1, t2, L->top, 1); /* call TM */
289 return !l_isfalse(L->top);
290 }
291
292
293 void luaV_concat (lua_State *L, int total) {
294 lua_assert(total >= 2);
295 do {
296 StkId top = L->top;
297 int n = 2; /* number of elements handled in this pass (at least 2) */
298 if (!(ttisstring(top-2) || ttisnumber(top-2)) || !tostring(L, top-1)) {
299 if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT))
300 luaG_concaterror(L, top-2, top-1);
301 }
302 else if (tsvalue(top-1)->len == 0) /* second operand is empty? */
303 (void)tostring(L, top - 2); /* result is first operand */
304 else if (ttisstring(top-2) && tsvalue(top-2)->len == 0) {
305 setobjs2s(L, top - 2, top - 1); /* result is second op. */
306 }
307 else {
308 /* at least two non-empty string values; get as many as possible */
309 size_t tl = tsvalue(top-1)->len;
310 char *buffer;
311 int i;
312 /* collect total length */
313 for (i = 1; i < total && tostring(L, top-i-1); i++) {
314 size_t l = tsvalue(top-i-1)->len;
315 if (l >= (MAX_SIZET/sizeof(char)) - tl)
316 luaG_runerror(L, "string length overflow");
317 tl += l;
318 }
319 buffer = luaZ_openspace(L, &G(L)->buff, tl);
320 tl = 0;
321 n = i;
322 do { /* concat all strings */
323 size_t l = tsvalue(top-i)->len;
324 memcpy(buffer+tl, svalue(top-i), l * sizeof(char));
325 tl += l;
326 } while (--i > 0);
327 setsvalue2s(L, top-n, luaS_newlstr(L, buffer, tl));
328 }
329 total -= n-1; /* got 'n' strings to create 1 new */
330 L->top -= n-1; /* popped 'n' strings and pushed one */
331 } while (total > 1); /* repeat until only 1 result left */
332 }
333
334
335 void luaV_objlen (lua_State *L, StkId ra, const TValue *rb) {
336 const TValue *tm;
337 switch (ttypenv(rb)) {
338 case LUA_TTABLE: {
339 Table *h = hvalue(rb);
340 tm = fasttm(L, h->metatable, TM_LEN);
341 if (tm) break; /* metamethod? break switch to call it */
342 setnvalue(ra, cast_num(luaH_getn(h))); /* else primitive len */
343 return;
344 }
345 case LUA_TSTRING: {
346 setnvalue(ra, cast_num(tsvalue(rb)->len));
347 return;
348 }
349 default: { /* try metamethod */
350 tm = luaT_gettmbyobj(L, rb, TM_LEN);
351 if (ttisnil(tm)) /* no metamethod? */
352 luaG_typeerror(L, rb, "get length of");
353 break;
354 }
355 }
356 callTM(L, tm, rb, rb, ra, 1);
357 }
358
359
360 void luaV_arith (lua_State *L, StkId ra, const TValue *rb,
361 const TValue *rc, TMS op) {
362 TValue tempb, tempc;
363 const TValue *b, *c;
364 if ((b = luaV_tonumber(rb, &tempb)) != NULL &&
365 (c = luaV_tonumber(rc, &tempc)) != NULL) {
366 lua_Number res = luaO_arith(op - TM_ADD + LUA_OPADD, nvalue(b), nvalue(c));
367 setnvalue(ra, res);
368 }
369 else if (!call_binTM(L, rb, rc, ra, op))
370 luaG_aritherror(L, rb, rc);
371 }
372
373
374 /*
375 ** check whether cached closure in prototype 'p' may be reused, that is,
376 ** whether there is a cached closure with the same upvalues needed by
377 ** new closure to be created.
378 */
379 static Closure *getcached (Proto *p, UpVal **encup, StkId base) {
380 Closure *c = p->cache;
381 if (c != NULL) { /* is there a cached closure? */
382 int nup = p->sizeupvalues;
383 Upvaldesc *uv = p->upvalues;
384 int i;
385 for (i = 0; i < nup; i++) { /* check whether it has right upvalues */
386 TValue *v = uv[i].instack ? base + uv[i].idx : encup[uv[i].idx]->v;
387 if (c->l.upvals[i]->v != v)
388 return NULL; /* wrong upvalue; cannot reuse closure */
389 }
390 }
391 return c; /* return cached closure (or NULL if no cached closure) */
392 }
393
394
395 /*
396 ** create a new Lua closure, push it in the stack, and initialize
397 ** its upvalues. Note that the call to 'luaC_barrierproto' must come
398 ** before the assignment to 'p->cache', as the function needs the
399 ** original value of that field.
400 */
401 static void pushclosure (lua_State *L, Proto *p, UpVal **encup, StkId base,
402 StkId ra) {
403 int nup = p->sizeupvalues;
404 Upvaldesc *uv = p->upvalues;
405 int i;
406 Closure *ncl = luaF_newLclosure(L, nup);
407 ncl->l.p = p;
408 setclLvalue(L, ra, ncl); /* anchor new closure in stack */
409 for (i = 0; i < nup; i++) { /* fill in its upvalues */
410 if (uv[i].instack) /* upvalue refers to local variable? */
411 ncl->l.upvals[i] = luaF_findupval(L, base + uv[i].idx);
412 else /* get upvalue from enclosing function */
413 ncl->l.upvals[i] = encup[uv[i].idx];
414 }
415 luaC_barrierproto(L, p, ncl);
416 p->cache = ncl; /* save it on cache for reuse */
417 }
418
419
420 /*
421 ** finish execution of an opcode interrupted by an yield
422 */
423 void luaV_finishOp (lua_State *L) {
424 CallInfo *ci = L->ci;
425 StkId base = ci->u.l.base;
426 Instruction inst = *(ci->u.l.savedpc - 1); /* interrupted instruction */
427 OpCode op = GET_OPCODE(inst);
428 switch (op) { /* finish its execution */
429 case OP_ADD: case OP_SUB: case OP_MUL: case OP_DIV:
430 case OP_MOD: case OP_POW: case OP_UNM: case OP_LEN:
431 case OP_GETTABUP: case OP_GETTABLE: case OP_SELF: {
432 setobjs2s(L, base + GETARG_A(inst), --L->top);
433 break;
434 }
435 case OP_LE: case OP_LT: case OP_EQ: {
436 int res = !l_isfalse(L->top - 1);
437 L->top--;
438 /* metamethod should not be called when operand is K */
439 lua_assert(!ISK(GETARG_B(inst)));
440 if (op == OP_LE && /* "<=" using "<" instead? */
441 ttisnil(luaT_gettmbyobj(L, base + GETARG_B(inst), TM_LE)))
442 res = !res; /* invert result */
443 lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_JMP);
444 if (res != GETARG_A(inst)) /* condition failed? */
445 ci->u.l.savedpc++; /* skip jump instruction */
446 break;
447 }
448 case OP_CONCAT: {
449 StkId top = L->top - 1; /* top when 'call_binTM' was called */
450 int b = GETARG_B(inst); /* first element to concatenate */
451 int total = cast_int(top - 1 - (base + b)); /* yet to concatenate */
452 setobj2s(L, top - 2, top); /* put TM result in proper position */
453 if (total > 1) { /* are there elements to concat? */
454 L->top = top - 1; /* top is one after last element (at top-2) */
455 luaV_concat(L, total); /* concat them (may yield again) */
456 }
457 /* move final result to final position */
458 setobj2s(L, ci->u.l.base + GETARG_A(inst), L->top - 1);
459 L->top = ci->top; /* restore top */
460 break;
461 }
462 case OP_TFORCALL: {
463 lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_TFORLOOP);
464 L->top = ci->top; /* correct top */
465 break;
466 }
467 case OP_CALL: {
468 if (GETARG_C(inst) - 1 >= 0) /* nresults >= 0? */
469 L->top = ci->top; /* adjust results */
470 break;
471 }
472 case OP_TAILCALL: case OP_SETTABUP: case OP_SETTABLE:
473 break;
474 default: lua_assert(0);
475 }
476 }
477
478
479
480 /*
481 ** some macros for common tasks in `luaV_execute'
482 */
483
484 #if !defined luai_runtimecheck
485 #define luai_runtimecheck(L, c) /* void */
486 #endif
487
488
489 #define RA(i) (base+GETARG_A(i))
490 /* to be used after possible stack reallocation */
491 #define RB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgR, base+GETARG_B(i))
492 #define RC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgR, base+GETARG_C(i))
493 #define RKB(i) check_exp(getBMode(GET_OPCODE(i)) == OpArgK, \
494 ISK(GETARG_B(i)) ? k+INDEXK(GETARG_B(i)) : base+GETARG_B(i))
495 #define RKC(i) check_exp(getCMode(GET_OPCODE(i)) == OpArgK, \
496 ISK(GETARG_C(i)) ? k+INDEXK(GETARG_C(i)) : base+GETARG_C(i))
497 #define KBx(i) \
498 (k + (GETARG_Bx(i) != 0 ? GETARG_Bx(i) - 1 : GETARG_Ax(*ci->u.l.savedpc++)))
499
500
501 /* execute a jump instruction */
502 #define dojump(ci,i,e) \
503 { int a = GETARG_A(i); \
504 if (a > 0) luaF_close(L, ci->u.l.base + a - 1); \
505 ci->u.l.savedpc += GETARG_sBx(i) + e; }
506
507 /* for test instructions, execute the jump instruction that follows it */
508 #define donextjump(ci) { i = *ci->u.l.savedpc; dojump(ci, i, 1); }
509
510
511 #define Protect(x) { {x;}; base = ci->u.l.base; }
512
513 #define checkGC(L,c) \
514 Protect( luaC_condGC(L,{L->top = (c); /* limit of live values */ \
515 luaC_step(L); \
516 L->top = ci->top;}) /* restore top */ \
517 luai_threadyield(L); )
518
519
520 #define arith_op(op,tm) { \
521 TValue *rb = RKB(i); \
522 TValue *rc = RKC(i); \
523 if (ttisnumber(rb) && ttisnumber(rc)) { \
524 lua_Number nb = nvalue(rb), nc = nvalue(rc); \
525 setnvalue(ra, op(L, nb, nc)); \
526 } \
527 else { Protect(luaV_arith(L, ra, rb, rc, tm)); } }
528
529
530 #define vmdispatch(o) switch(o)
531 #define vmcase(l,b) case l: {b} break;
532 #define vmcasenb(l,b) case l: {b} /* nb = no break */
533
534 void luaV_execute (lua_State *L) {
535 CallInfo *ci = L->ci;
536 LClosure *cl;
537 TValue *k;
538 StkId base;
539 newframe: /* reentry point when frame changes (call/return) */
540 lua_assert(ci == L->ci);
541 cl = clLvalue(ci->func);
542 k = cl->p->k;
543 base = ci->u.l.base;
544 /* main loop of interpreter */
545 for (;;) {
546 Instruction i = *(ci->u.l.savedpc++);
547 StkId ra;
548 if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
549 (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
550 Protect(traceexec(L));
551 }
552 /* WARNING: several calls may realloc the stack and invalidate `ra' */
553 ra = RA(i);
554 lua_assert(base == ci->u.l.base);
555 lua_assert(base <= L->top && L->top < L->stack + L->stacksize);
556 vmdispatch (GET_OPCODE(i)) {
557 vmcase(OP_MOVE,
558 setobjs2s(L, ra, RB(i));
559 )
560 vmcase(OP_LOADK,
561 TValue *rb = k + GETARG_Bx(i);
562 setobj2s(L, ra, rb);
563 )
564 vmcase(OP_LOADKX,
565 TValue *rb;
566 lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG);
567 rb = k + GETARG_Ax(*ci->u.l.savedpc++);
568 setobj2s(L, ra, rb);
569 )
570 vmcase(OP_LOADBOOL,
571 setbvalue(ra, GETARG_B(i));
572 if (GETARG_C(i)) ci->u.l.savedpc++; /* skip next instruction (if C) */
573 )
574 vmcase(OP_LOADNIL,
575 int b = GETARG_B(i);
576 do {
577 setnilvalue(ra++);
578 } while (b--);
579 )
580 vmcase(OP_GETUPVAL,
581 int b = GETARG_B(i);
582 setobj2s(L, ra, cl->upvals[b]->v);
583 )
584 vmcase(OP_GETTABUP,
585 int b = GETARG_B(i);
586 Protect(luaV_gettable(L, cl->upvals[b]->v, RKC(i), ra));
587 )
588 vmcase(OP_GETTABLE,
589 Protect(luaV_gettable(L, RB(i), RKC(i), ra));
590 )
591 vmcase(OP_SETTABUP,
592 int a = GETARG_A(i);
593 Protect(luaV_settable(L, cl->upvals[a]->v, RKB(i), RKC(i)));
594 )
595 vmcase(OP_SETUPVAL,
596 UpVal *uv = cl->upvals[GETARG_B(i)];
597 setobj(L, uv->v, ra);
598 luaC_barrier(L, uv, ra);
599 )
600 vmcase(OP_SETTABLE,
601 Protect(luaV_settable(L, ra, RKB(i), RKC(i)));
602 )
603 vmcase(OP_NEWTABLE,
604 int b = GETARG_B(i);
605 int c = GETARG_C(i);
606 Table *t = luaH_new(L);
607 sethvalue(L, ra, t);
608 if (b != 0 || c != 0)
609 luaH_resize(L, t, luaO_fb2int(b), luaO_fb2int(c));
610 checkGC(L, ra + 1);
611 )
612 vmcase(OP_SELF,
613 StkId rb = RB(i);
614 setobjs2s(L, ra+1, rb);
615 Protect(luaV_gettable(L, rb, RKC(i), ra));
616 )
617 vmcase(OP_ADD,
618 arith_op(luai_numadd, TM_ADD);
619 )
620 vmcase(OP_SUB,
621 arith_op(luai_numsub, TM_SUB);
622 )
623 vmcase(OP_MUL,
624 arith_op(luai_nummul, TM_MUL);
625 )
626 vmcase(OP_DIV,
627 arith_op(luai_numdiv, TM_DIV);
628 )
629 vmcase(OP_MOD,
630 arith_op(luai_nummod, TM_MOD);
631 )
632 vmcase(OP_POW,
633 arith_op(luai_numpow, TM_POW);
634 )
635 vmcase(OP_UNM,
636 TValue *rb = RB(i);
637 if (ttisnumber(rb)) {
638 lua_Number nb = nvalue(rb);
639 setnvalue(ra, luai_numunm(L, nb));
640 }
641 else {
642 Protect(luaV_arith(L, ra, rb, rb, TM_UNM));
643 }
644 )
645 vmcase(OP_NOT,
646 TValue *rb = RB(i);
647 int res = l_isfalse(rb); /* next assignment may change this value */
648 setbvalue(ra, res);
649 )
650 vmcase(OP_LEN,
651 Protect(luaV_objlen(L, ra, RB(i)));
652 )
653 vmcase(OP_CONCAT,
654 int b = GETARG_B(i);
655 int c = GETARG_C(i);
656 StkId rb;
657 L->top = base + c + 1; /* mark the end of concat operands */
658 Protect(luaV_concat(L, c - b + 1));
659 ra = RA(i); /* 'luav_concat' may invoke TMs and move the stack */
660 rb = b + base;
661 setobjs2s(L, ra, rb);
662 checkGC(L, (ra >= rb ? ra + 1 : rb));
663 L->top = ci->top; /* restore top */
664 )
665 vmcase(OP_JMP,
666 dojump(ci, i, 0);
667 )
668 vmcase(OP_EQ,
669 TValue *rb = RKB(i);
670 TValue *rc = RKC(i);
671 Protect(
672 if (cast_int(equalobj(L, rb, rc)) != GETARG_A(i))
673 ci->u.l.savedpc++;
674 else
675 donextjump(ci);
676 )
677 )
678 vmcase(OP_LT,
679 Protect(
680 if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i))
681 ci->u.l.savedpc++;
682 else
683 donextjump(ci);
684 )
685 )
686 vmcase(OP_LE,
687 Protect(
688 if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i))
689 ci->u.l.savedpc++;
690 else
691 donextjump(ci);
692 )
693 )
694 vmcase(OP_TEST,
695 if (GETARG_C(i) ? l_isfalse(ra) : !l_isfalse(ra))
696 ci->u.l.savedpc++;
697 else
698 donextjump(ci);
699 )
700 vmcase(OP_TESTSET,
701 TValue *rb = RB(i);
702 if (GETARG_C(i) ? l_isfalse(rb) : !l_isfalse(rb))
703 ci->u.l.savedpc++;
704 else {
705 setobjs2s(L, ra, rb);
706 donextjump(ci);
707 }
708 )
709 vmcase(OP_CALL,
710 int b = GETARG_B(i);
711 int nresults = GETARG_C(i) - 1;
712 if (b != 0) L->top = ra+b; /* else previous instruction set top */
713 if (luaD_precall(L, ra, nresults)) { /* C function? */
714 if (nresults >= 0) L->top = ci->top; /* adjust results */
715 base = ci->u.l.base;
716 }
717 else { /* Lua function */
718 ci = L->ci;
719 ci->callstatus |= CIST_REENTRY;
720 goto newframe; /* restart luaV_execute over new Lua function */
721 }
722 )
723 vmcase(OP_TAILCALL,
724 int b = GETARG_B(i);
725 if (b != 0) L->top = ra+b; /* else previous instruction set top */
726 lua_assert(GETARG_C(i) - 1 == LUA_MULTRET);
727 if (luaD_precall(L, ra, LUA_MULTRET)) /* C function? */
728 base = ci->u.l.base;
729 else {
730 /* tail call: put called frame (n) in place of caller one (o) */
731 CallInfo *nci = L->ci; /* called frame */
732 CallInfo *oci = nci->previous; /* caller frame */
733 StkId nfunc = nci->func; /* called function */
734 StkId ofunc = oci->func; /* caller function */
735 /* last stack slot filled by 'precall' */
736 StkId lim = nci->u.l.base + getproto(nfunc)->numparams;
737 int aux;
738 /* close all upvalues from previous call */
739 if (cl->p->sizep > 0) luaF_close(L, oci->u.l.base);
740 /* move new frame into old one */
741 for (aux = 0; nfunc + aux < lim; aux++)
742 setobjs2s(L, ofunc + aux, nfunc + aux);
743 oci->u.l.base = ofunc + (nci->u.l.base - nfunc); /* correct base */
744 oci->top = L->top = ofunc + (L->top - nfunc); /* correct top */
745 oci->u.l.savedpc = nci->u.l.savedpc;
746 oci->callstatus |= CIST_TAIL; /* function was tail called */
747 ci = L->ci = oci; /* remove new frame */
748 lua_assert(L->top == oci->u.l.base + getproto(ofunc)->maxstacksize);
749 goto newframe; /* restart luaV_execute over new Lua function */
750 }
751 )
752 vmcasenb(OP_RETURN,
753 int b = GETARG_B(i);
754 if (b != 0) L->top = ra+b-1;
755 if (cl->p->sizep > 0) luaF_close(L, base);
756 b = luaD_poscall(L, ra);
757 if (!(ci->callstatus & CIST_REENTRY)) /* 'ci' still the called one */
758 return; /* external invocation: return */
759 else { /* invocation via reentry: continue execution */
760 ci = L->ci;
761 if (b) L->top = ci->top;
762 lua_assert(isLua(ci));
763 lua_assert(GET_OPCODE(*((ci)->u.l.savedpc - 1)) == OP_CALL);
764 goto newframe; /* restart luaV_execute over new Lua function */
765 }
766 )
767 vmcase(OP_FORLOOP,
768 lua_Number step = nvalue(ra+2);
769 lua_Number idx = luai_numadd(L, nvalue(ra), step); /* increment index */
770 lua_Number limit = nvalue(ra+1);
771 if (luai_numlt(L, 0, step) ? luai_numle(L, idx, limit)
772 : luai_numle(L, limit, idx)) {
773 ci->u.l.savedpc += GETARG_sBx(i); /* jump back */
774 setnvalue(ra, idx); /* update internal index... */
775 setnvalue(ra+3, idx); /* ...and external index */
776 }
777 )
778 vmcase(OP_FORPREP,
779 const TValue *init = ra;
780 const TValue *plimit = ra+1;
781 const TValue *pstep = ra+2;
782 if (!tonumber(init, ra))
783 luaG_runerror(L, LUA_QL("for") " initial value must be a number");
784 else if (!tonumber(plimit, ra+1))
785 luaG_runerror(L, LUA_QL("for") " limit must be a number");
786 else if (!tonumber(pstep, ra+2))
787 luaG_runerror(L, LUA_QL("for") " step must be a number");
788 setnvalue(ra, luai_numsub(L, nvalue(ra), nvalue(pstep)));
789 ci->u.l.savedpc += GETARG_sBx(i);
790 )
791 vmcasenb(OP_TFORCALL,
792 StkId cb = ra + 3; /* call base */
793 setobjs2s(L, cb+2, ra+2);
794 setobjs2s(L, cb+1, ra+1);
795 setobjs2s(L, cb, ra);
796 L->top = cb + 3; /* func. + 2 args (state and index) */
797 Protect(luaD_call(L, cb, GETARG_C(i), 1));
798 L->top = ci->top;
799 i = *(ci->u.l.savedpc++); /* go to next instruction */
800 ra = RA(i);
801 lua_assert(GET_OPCODE(i) == OP_TFORLOOP);
802 goto l_tforloop;
803 )
804 vmcase(OP_TFORLOOP,
805 l_tforloop:
806 if (!ttisnil(ra + 1)) { /* continue loop? */
807 setobjs2s(L, ra, ra + 1); /* save control variable */
808 ci->u.l.savedpc += GETARG_sBx(i); /* jump back */
809 }
810 )
811 vmcase(OP_SETLIST,
812 int n = GETARG_B(i);
813 int c = GETARG_C(i);
814 int last;
815 Table *h;
816 if (n == 0) n = cast_int(L->top - ra) - 1;
817 if (c == 0) {
818 lua_assert(GET_OPCODE(*ci->u.l.savedpc) == OP_EXTRAARG);
819 c = GETARG_Ax(*ci->u.l.savedpc++);
820 }
821 luai_runtimecheck(L, ttistable(ra));
822 h = hvalue(ra);
823 last = ((c-1)*LFIELDS_PER_FLUSH) + n;
824 if (last > h->sizearray) /* needs more space? */
825 luaH_resizearray(L, h, last); /* pre-allocate it at once */
826 for (; n > 0; n--) {
827 TValue *val = ra+n;
828 luaH_setint(L, h, last--, val);
829 luaC_barrierback(L, obj2gco(h), val);
830 }
831 L->top = ci->top; /* correct top (in case of previous open call) */
832 )
833 vmcase(OP_CLOSURE,
834 Proto *p = cl->p->p[GETARG_Bx(i)];
835 Closure *ncl = getcached(p, cl->upvals, base); /* cached closure */
836 if (ncl == NULL) /* no match? */
837 pushclosure(L, p, cl->upvals, base, ra); /* create a new one */
838 else
839 setclLvalue(L, ra, ncl); /* push cashed closure */
840 checkGC(L, ra + 1);
841 )
842 vmcase(OP_VARARG,
843 int b = GETARG_B(i) - 1;
844 int j;
845 int n = cast_int(base - ci->func) - cl->p->numparams - 1;
846 if (b < 0) { /* B == 0? */
847 b = n; /* get all var. arguments */
848 Protect(luaD_checkstack(L, n));
849 ra = RA(i); /* previous call may change the stack */
850 L->top = ra + n;
851 }
852 for (j = 0; j < b; j++) {
853 if (j < n) {
854 setobjs2s(L, ra + j, base - n + j);
855 }
856 else {
857 setnilvalue(ra + j);
858 }
859 }
860 )
861 vmcase(OP_EXTRAARG,
862 lua_assert(0);
863 )
864 }
865 }
866 }
867