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