]>
Commit | Line | Data |
---|---|---|
ba8b5c17 | 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 |