rpm  4.5
lvm.c
Go to the documentation of this file.
1 /*
2 ** $Id: lvm.c,v 1.2 2004/03/19 21:14:32 niemeyer Exp $
3 ** Lua virtual machine
4 ** See Copyright Notice in lua.h
5 */
6 
7 
8 #include <stdarg.h>
9 #include <stdlib.h>
10 #include <string.h>
11 
12 /* needed only when `lua_number2str' uses `sprintf' */
13 #include <stdio.h>
14 
15 #define lvm_c
16 
17 #include "lua.h"
18 
19 #include "ldebug.h"
20 #include "ldo.h"
21 #include "lfunc.h"
22 #include "lgc.h"
23 #include "lobject.h"
24 #include "lopcodes.h"
25 #include "lstate.h"
26 #include "lstring.h"
27 #include "ltable.h"
28 #include "ltm.h"
29 #include "lvm.h"
30 
31 
32 
33 /* function to convert a lua_Number to a string */
34 #ifndef lua_number2str
35 #define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n))
36 #endif
37 
38 
39 /* limit for table tag-method chains (to avoid loops) */
40 #define MAXTAGLOOP 100
41 
42 
43 const TObject *luaV_tonumber (const TObject *obj, TObject *n) {
44  lua_Number num;
45  if (ttisnumber(obj)) return obj;
46  if (ttisstring(obj) && luaO_str2d(svalue(obj), &num)) {
47  setnvalue(n, num);
48  return n;
49  }
50  else
51  return NULL;
52 }
53 
54 
55 int luaV_tostring (lua_State *L, StkId obj) {
56  if (!ttisnumber(obj))
57  return 0;
58  else {
59  char s[32]; /* 16 digits, sign, point and \0 (+ some extra...) */
60  lua_number2str(s, nvalue(obj));
61  setsvalue2s(obj, luaS_new(L, s));
62  return 1;
63  }
64 }
65 
66 
67 static void traceexec (lua_State *L)
68  /*@modifies L @*/
69 {
70  lu_byte mask = L->hookmask;
71  if (mask & LUA_MASKCOUNT) { /* instruction-hook set? */
72  if (L->hookcount == 0) {
73  resethookcount(L);
74  luaD_callhook(L, LUA_HOOKCOUNT, -1);
75  return;
76  }
77  }
78  if (mask & LUA_MASKLINE) {
79  CallInfo *ci = L->ci;
80  Proto *p = ci_func(ci)->l.p;
81  int newline = getline(p, pcRel(*ci->u.l.pc, p));
82  if (!L->hookinit) {
83  luaG_inithooks(L);
84  return;
85  }
87  if (pcRel(*ci->u.l.pc, p) == 0) /* tracing may be starting now? */
88  ci->u.l.savedpc = *ci->u.l.pc; /* initialize `savedpc' */
89  /* calls linehook when enters a new line or jumps back (loop) */
90  if (*ci->u.l.pc <= ci->u.l.savedpc ||
91  newline != getline(p, pcRel(ci->u.l.savedpc, p))) {
92  luaD_callhook(L, LUA_HOOKLINE, newline);
93  ci = L->ci; /* previous call may reallocate `ci' */
94  }
95  ci->u.l.savedpc = *ci->u.l.pc;
96  }
97 }
98 
99 
100 static void callTMres (lua_State *L, const TObject *f,
101  const TObject *p1, const TObject *p2)
102  /*@modifies L @*/
103 {
104  setobj2s(L->top, f); /* push function */
105  setobj2s(L->top+1, p1); /* 1st argument */
106  setobj2s(L->top+2, p2); /* 2nd argument */
107  luaD_checkstack(L, 3); /* cannot check before (could invalidate p1, p2) */
108  L->top += 3;
109  luaD_call(L, L->top - 3, 1);
110  L->top--; /* result will be in L->top */
111 }
112 
113 
114 
115 static void callTM (lua_State *L, const TObject *f,
116  const TObject *p1, const TObject *p2, const TObject *p3)
117  /*@modifies L @*/
118 {
119  setobj2s(L->top, f); /* push function */
120  setobj2s(L->top+1, p1); /* 1st argument */
121  setobj2s(L->top+2, p2); /* 2nd argument */
122  setobj2s(L->top+3, p3); /* 3th argument */
123  luaD_checkstack(L, 4); /* cannot check before (could invalidate p1...p3) */
124  L->top += 4;
125  luaD_call(L, L->top - 4, 0);
126 }
127 
128 
129 /*@observer@*/
130 static const TObject *luaV_index (lua_State *L, const TObject *t,
131  TObject *key, int loop)
132  /*@modifies L, t @*/
133 {
134  const TObject *tm = fasttm(L, hvalue(t)->metatable, TM_INDEX);
135  if (tm == NULL) return &luaO_nilobject; /* no TM */
136  if (ttisfunction(tm)) {
137  callTMres(L, tm, t, key);
138  return L->top;
139  }
140  else return luaV_gettable(L, tm, key, loop);
141 }
142 
143 /*@observer@*/
144 static const TObject *luaV_getnotable (lua_State *L, const TObject *t,
145  TObject *key, int loop)
146  /*@modifies L @*/
147 {
148  const TObject *tm = luaT_gettmbyobj(L, t, TM_INDEX);
149  if (ttisnil(tm))
150  luaG_typeerror(L, t, "index");
151  if (ttisfunction(tm)) {
152  callTMres(L, tm, t, key);
153  return L->top;
154  }
155 /*@-modobserver@*/
156  else return luaV_gettable(L, tm, key, loop);
157 /*@=modobserver@*/
158 }
159 
160 
161 /*
162 ** Function to index a table.
163 ** Receives the table at `t' and the key at `key'.
164 ** leaves the result at `res'.
165 */
166 const TObject *luaV_gettable (lua_State *L, const TObject *t, TObject *key,
167  int loop) {
168  if (loop > MAXTAGLOOP)
169  luaG_runerror(L, "loop in gettable");
170  if (ttistable(t)) { /* `t' is a table? */
171  Table *h = hvalue(t);
172  const TObject *v = luaH_get(h, key); /* do a primitive get */
173  if (!ttisnil(v)) return v;
174  else return luaV_index(L, t, key, loop+1);
175  }
176  else return luaV_getnotable(L, t, key, loop+1);
177 }
178 
179 
180 /*
181 ** Receives table at `t', key at `key' and value at `val'.
182 */
183 void luaV_settable (lua_State *L, const TObject *t, TObject *key, StkId val) {
184  const TObject *tm;
185  int loop = 0;
186  do {
187  if (ttistable(t)) { /* `t' is a table? */
188  Table *h = hvalue(t);
189  TObject *oldval = luaH_set(L, h, key); /* do a primitive set */
190  if (!ttisnil(oldval) || /* result is no nil? */
191  (tm = fasttm(L, h->metatable, TM_NEWINDEX)) == NULL) { /* or no TM? */
192  setobj2t(oldval, val); /* write barrier */
193  return;
194  }
195  /* else will try the tag method */
196  }
197  else if (ttisnil(tm = luaT_gettmbyobj(L, t, TM_NEWINDEX)))
198  luaG_typeerror(L, t, "index");
199  if (ttisfunction(tm)) {
200  callTM(L, tm, t, key, val);
201  return;
202  }
203  t = tm; /* else repeat with `tm' */
204  } while (++loop <= MAXTAGLOOP);
205  luaG_runerror(L, "loop in settable");
206 }
207 
208 
209 static int call_binTM (lua_State *L, const TObject *p1, const TObject *p2,
210  StkId res, TMS event)
211  /*@modifies L @*/
212 {
213  ptrdiff_t result = savestack(L, res);
214  const TObject *tm = luaT_gettmbyobj(L, p1, event); /* try first operand */
215  if (ttisnil(tm))
216  tm = luaT_gettmbyobj(L, p2, event); /* try second operand */
217  if (!ttisfunction(tm)) return 0;
218  callTMres(L, tm, p1, p2);
219  res = restorestack(L, result); /* previous call may change stack */
220  setobjs2s(res, L->top);
221  return 1;
222 }
223 
224 
225 /*@null@*/
226 static const TObject *get_compTM (lua_State *L, Table *mt1, Table *mt2,
227  TMS event)
228  /*@modifies mt1, mt2 @*/
229 {
230  const TObject *tm1 = fasttm(L, mt1, event);
231  const TObject *tm2;
232  if (tm1 == NULL) return NULL; /* no metamethod */
233  if (mt1 == mt2) return tm1; /* same metatables => same metamethods */
234  tm2 = fasttm(L, mt2, event);
235  if (tm2 == NULL) return NULL; /* no metamethod */
236  if (luaO_rawequalObj(tm1, tm2)) /* same metamethods? */
237  return tm1;
238  return NULL;
239 }
240 
241 
242 static int call_orderTM (lua_State *L, const TObject *p1, const TObject *p2,
243  TMS event)
244  /*@modifies L @*/
245 {
246  const TObject *tm1 = luaT_gettmbyobj(L, p1, event);
247  const TObject *tm2;
248  if (ttisnil(tm1)) return -1; /* no metamethod? */
249  tm2 = luaT_gettmbyobj(L, p2, event);
250  if (!luaO_rawequalObj(tm1, tm2)) /* different metamethods? */
251  return -1;
252  callTMres(L, tm1, p1, p2);
253  return !l_isfalse(L->top);
254 }
255 
256 
257 static int luaV_strcmp (const TString *ls, const TString *rs)
258  /*@*/
259 {
260  const char *l = getstr(ls);
261  size_t ll = ls->tsv.len;
262  const char *r = getstr(rs);
263  size_t lr = rs->tsv.len;
264  for (;;) {
265  int temp = strcoll(l, r);
266  if (temp != 0) return temp;
267  else { /* strings are equal up to a `\0' */
268  size_t len = strlen(l); /* index of first `\0' in both strings */
269  if (len == lr) /* r is finished? */
270  return (len == ll) ? 0 : 1;
271  else if (len == ll) /* l is finished? */
272  return -1; /* l is smaller than r (because r is not finished) */
273  /* both strings longer than `len'; go on comparing (after the `\0') */
274  len++;
275  l += len; ll -= len; r += len; lr -= len;
276  }
277  }
278 }
279 
280 
281 int luaV_lessthan (lua_State *L, const TObject *l, const TObject *r) {
282  int res;
283  if (ttype(l) != ttype(r))
284  return luaG_ordererror(L, l, r);
285  else if (ttisnumber(l))
286  return nvalue(l) < nvalue(r);
287  else if (ttisstring(l))
288  return luaV_strcmp(tsvalue(l), tsvalue(r)) < 0;
289  else if ((res = call_orderTM(L, l, r, TM_LT)) != -1)
290  return res;
291  return luaG_ordererror(L, l, r);
292 }
293 
294 
295 static int luaV_lessequal (lua_State *L, const TObject *l, const TObject *r)
296  /*@modifies L @*/
297 {
298  int res;
299  if (ttype(l) != ttype(r))
300  return luaG_ordererror(L, l, r);
301  else if (ttisnumber(l))
302  return nvalue(l) <= nvalue(r);
303  else if (ttisstring(l))
304  return luaV_strcmp(tsvalue(l), tsvalue(r)) <= 0;
305  else if ((res = call_orderTM(L, l, r, TM_LE)) != -1) /* first try `le' */
306  return res;
307  else if ((res = call_orderTM(L, r, l, TM_LT)) != -1) /* else try `lt' */
308  return !res;
309  return luaG_ordererror(L, l, r);
310 }
311 
312 
313 int luaV_equalval (lua_State *L, const TObject *t1, const TObject *t2) {
314  const TObject *tm;
315  lua_assert(ttype(t1) == ttype(t2));
316  switch (ttype(t1)) {
317  case LUA_TNIL: return 1;
318  case LUA_TNUMBER: return nvalue(t1) == nvalue(t2);
319  case LUA_TBOOLEAN: return bvalue(t1) == bvalue(t2); /* true must be 1 !! */
320  case LUA_TLIGHTUSERDATA: return pvalue(t1) == pvalue(t2);
321  case LUA_TUSERDATA: {
322  if (uvalue(t1) == uvalue(t2)) return 1;
323  tm = get_compTM(L, uvalue(t1)->uv.metatable, uvalue(t2)->uv.metatable,
324  TM_EQ);
325  break; /* will try TM */
326  }
327  case LUA_TTABLE: {
328  if (hvalue(t1) == hvalue(t2)) return 1;
329  tm = get_compTM(L, hvalue(t1)->metatable, hvalue(t2)->metatable, TM_EQ);
330  break; /* will try TM */
331  }
332  default: return gcvalue(t1) == gcvalue(t2);
333  }
334  if (tm == NULL) return 0; /* no TM? */
335  callTMres(L, tm, t1, t2); /* call TM */
336  return !l_isfalse(L->top);
337 }
338 
339 
340 void luaV_concat (lua_State *L, int total, int last) {
341  do {
342  StkId top = L->base + last + 1;
343  int n = 2; /* number of elements handled in this pass (at least 2) */
344  if (!tostring(L, top-2) || !tostring(L, top-1)) {
345  if (!call_binTM(L, top-2, top-1, top-2, TM_CONCAT))
346  luaG_concaterror(L, top-2, top-1);
347  } else if (tsvalue(top-1)->tsv.len > 0) { /* if len=0, do nothing */
348  /* at least two string values; get as many as possible */
349  lu_mem tl = cast(lu_mem, tsvalue(top-1)->tsv.len) +
350  cast(lu_mem, tsvalue(top-2)->tsv.len);
351  char *buffer;
352  int i;
353  while (n < total && tostring(L, top-n-1)) { /* collect total length */
354  tl += tsvalue(top-n-1)->tsv.len;
355  n++;
356  }
357  if (tl > MAX_SIZET) luaG_runerror(L, "string size overflow");
358  buffer = luaZ_openspace(L, &G(L)->buff, tl);
359  tl = 0;
360  for (i=n; i>0; i--) { /* concat all strings */
361  size_t l = tsvalue(top-i)->tsv.len;
362  memcpy(buffer+tl, svalue(top-i), l);
363  tl += l;
364  }
365  setsvalue2s(top-n, luaS_newlstr(L, buffer, tl));
366  }
367  total -= n-1; /* got `n' strings to create 1 new */
368  last -= n-1;
369  } while (total > 1); /* repeat until only 1 result left */
370 }
371 
372 
373 static void Arith (lua_State *L, StkId ra,
374  const TObject *rb, const TObject *rc, TMS op)
375  /*@modifies L, ra @*/
376 {
377  TObject tempb, tempc;
378  const TObject *b, *c;
379  if ((b = luaV_tonumber(rb, &tempb)) != NULL &&
380  (c = luaV_tonumber(rc, &tempc)) != NULL) {
381  switch (op) {
382  case TM_ADD: setnvalue(ra, nvalue(b) + nvalue(c)); break;
383  case TM_SUB: setnvalue(ra, nvalue(b) - nvalue(c)); break;
384  case TM_MUL: setnvalue(ra, nvalue(b) * nvalue(c)); break;
385  case TM_DIV: setnvalue(ra, nvalue(b) / nvalue(c)); break;
386  case TM_POW: {
387  const TObject *f = luaH_getstr(hvalue(gt(L)), G(L)->tmname[TM_POW]);
388  ptrdiff_t res = savestack(L, ra);
389  if (!ttisfunction(f))
390  luaG_runerror(L, "`__pow' (`^' operator) is not a function");
391  callTMres(L, f, b, c);
392  ra = restorestack(L, res); /* previous call may change stack */
393  setobjs2s(ra, L->top);
394  break;
395  }
396  default: lua_assert(0); break;
397  }
398  }
399  else if (!call_binTM(L, rb, rc, ra, op))
400  luaG_aritherror(L, rb, rc);
401 }
402 
403 
404 
405 /*
406 ** some macros for common tasks in `luaV_execute'
407 */
408 
409 #define runtime_check(L, c) { if (!(c)) return 0; }
410 
411 #define RA(i) (base+GETARG_A(i))
412 /* to be used after possible stack reallocation */
413 #define XRA(i) (L->base+GETARG_A(i))
414 #define RB(i) (base+GETARG_B(i))
415 #define RKB(i) ((GETARG_B(i) < MAXSTACK) ? RB(i) : k+GETARG_B(i)-MAXSTACK)
416 #define RC(i) (base+GETARG_C(i))
417 #define RKC(i) ((GETARG_C(i) < MAXSTACK) ? RC(i) : k+GETARG_C(i)-MAXSTACK)
418 #define KBx(i) (k+GETARG_Bx(i))
419 
420 
421 #define dojump(pc, i) ((pc) += (i))
422 
423 
425  LClosure *cl;
426  TObject *k;
427  const Instruction *pc;
428  callentry: /* entry point when calling new functions */
429  if (L->hookmask & LUA_MASKCALL) {
430  L->ci->u.l.pc = &pc;
431  luaD_callhook(L, LUA_HOOKCALL, -1);
432  }
433  retentry: /* entry point when returning to old functions */
434  L->ci->u.l.pc = &pc;
435  lua_assert(L->ci->state == CI_SAVEDPC ||
436  L->ci->state == (CI_SAVEDPC | CI_CALLING));
437  L->ci->state = CI_HASFRAME; /* activate frame */
438  pc = L->ci->u.l.savedpc;
439  cl = &clvalue(L->base - 1)->l;
440  k = cl->p->k;
441  /* main loop of interpreter */
442  for (;;) {
443  const Instruction i = *pc++;
444  StkId base, ra;
445  if ((L->hookmask & (LUA_MASKLINE | LUA_MASKCOUNT)) &&
446  (--L->hookcount == 0 || L->hookmask & LUA_MASKLINE)) {
447  traceexec(L);
448  if (L->ci->state & CI_YIELD) { /* did hook yield? */
449  L->ci->u.l.savedpc = pc - 1;
450  L->ci->state = CI_YIELD | CI_SAVEDPC;
451  return NULL;
452  }
453  }
454  /* warning!! several calls may realloc the stack and invalidate `ra' */
455  base = L->base;
456  ra = RA(i);
458  lua_assert(base == L->ci->base);
459  lua_assert(L->top <= L->stack + L->stacksize && L->top >= base);
460  lua_assert(L->top == L->ci->top ||
461  GET_OPCODE(i) == OP_CALL || GET_OPCODE(i) == OP_TAILCALL ||
462  GET_OPCODE(i) == OP_RETURN || GET_OPCODE(i) == OP_SETLISTO);
463  switch (GET_OPCODE(i)) {
464  case OP_MOVE: {
465  setobjs2s(ra, RB(i));
466  break;
467  }
468  case OP_LOADK: {
469  setobj2s(ra, KBx(i));
470  break;
471  }
472  case OP_LOADBOOL: {
473  setbvalue(ra, GETARG_B(i));
474  if (GETARG_C(i)) pc++; /* skip next instruction (if C) */
475  break;
476  }
477  case OP_LOADNIL: {
478  TObject *rb = RB(i);
479  do {
480  setnilvalue(rb--);
481  } while (rb >= ra);
482  break;
483  }
484  case OP_GETUPVAL: {
485  int b = GETARG_B(i);
486  setobj2s(ra, cl->upvals[b]->v);
487  break;
488  }
489  case OP_GETGLOBAL: {
490  TObject *rb = KBx(i);
491  const TObject *v;
492  lua_assert(ttisstring(rb) && ttistable(&cl->g));
493  v = luaH_getstr(hvalue(&cl->g), tsvalue(rb));
494  if (!ttisnil(v)) { setobj2s(ra, v); }
495  else
496  setobj2s(XRA(i), luaV_index(L, &cl->g, rb, 0));
497  break;
498  }
499  case OP_GETTABLE: {
500  StkId rb = RB(i);
501  TObject *rc = RKC(i);
502  if (ttistable(rb)) {
503  const TObject *v = luaH_get(hvalue(rb), rc);
504  if (!ttisnil(v)) { setobj2s(ra, v); }
505  else
506  setobj2s(XRA(i), luaV_index(L, rb, rc, 0));
507  }
508  else
509  setobj2s(XRA(i), luaV_getnotable(L, rb, rc, 0));
510  break;
511  }
512  case OP_SETGLOBAL: {
513  lua_assert(ttisstring(KBx(i)) && ttistable(&cl->g));
514  luaV_settable(L, &cl->g, KBx(i), ra);
515  break;
516  }
517  case OP_SETUPVAL: {
518  int b = GETARG_B(i);
519  setobj(cl->upvals[b]->v, ra); /* write barrier */
520  break;
521  }
522  case OP_SETTABLE: {
523  luaV_settable(L, ra, RKB(i), RKC(i));
524  break;
525  }
526  case OP_NEWTABLE: {
527  int b = GETARG_B(i);
528  b = fb2int(b);
529  sethvalue(ra, luaH_new(L, b, GETARG_C(i)));
530  luaC_checkGC(L);
531  break;
532  }
533  case OP_SELF: {
534  StkId rb = RB(i);
535  TObject *rc = RKC(i);
536  runtime_check(L, ttisstring(rc));
537  setobjs2s(ra+1, rb);
538  if (ttistable(rb)) {
539  const TObject *v = luaH_getstr(hvalue(rb), tsvalue(rc));
540  if (!ttisnil(v)) { setobj2s(ra, v); }
541  else
542  setobj2s(XRA(i), luaV_index(L, rb, rc, 0));
543  }
544  else
545  setobj2s(XRA(i), luaV_getnotable(L, rb, rc, 0));
546  break;
547  }
548  case OP_ADD: {
549  TObject *rb = RKB(i);
550  TObject *rc = RKC(i);
551  if (ttisnumber(rb) && ttisnumber(rc)) {
552  setnvalue(ra, nvalue(rb) + nvalue(rc));
553  }
554  else
555  Arith(L, ra, rb, rc, TM_ADD);
556  break;
557  }
558  case OP_SUB: {
559  TObject *rb = RKB(i);
560  TObject *rc = RKC(i);
561  if (ttisnumber(rb) && ttisnumber(rc)) {
562  setnvalue(ra, nvalue(rb) - nvalue(rc));
563  }
564  else
565  Arith(L, ra, rb, rc, TM_SUB);
566  break;
567  }
568  case OP_MUL: {
569  TObject *rb = RKB(i);
570  TObject *rc = RKC(i);
571  if (ttisnumber(rb) && ttisnumber(rc)) {
572  setnvalue(ra, nvalue(rb) * nvalue(rc));
573  }
574  else
575  Arith(L, ra, rb, rc, TM_MUL);
576  break;
577  }
578  case OP_DIV: {
579  TObject *rb = RKB(i);
580  TObject *rc = RKC(i);
581  if (ttisnumber(rb) && ttisnumber(rc)) {
582  setnvalue(ra, nvalue(rb) / nvalue(rc));
583  }
584  else
585  Arith(L, ra, rb, rc, TM_DIV);
586  break;
587  }
588  case OP_POW: {
589  Arith(L, ra, RKB(i), RKC(i), TM_POW);
590  break;
591  }
592  case OP_UNM: {
593  const TObject *rb = RB(i);
594  TObject temp;
595  if (tonumber(rb, &temp)) {
596  setnvalue(ra, -nvalue(rb));
597  }
598  else {
599  setnilvalue(&temp);
600  if (!call_binTM(L, RB(i), &temp, ra, TM_UNM))
601  luaG_aritherror(L, RB(i), &temp);
602  }
603  break;
604  }
605  case OP_NOT: {
606  int res = l_isfalse(RB(i)); /* next assignment may change this value */
607  setbvalue(ra, res);
608  break;
609  }
610  case OP_CONCAT: {
611  int b = GETARG_B(i);
612  int c = GETARG_C(i);
613  luaV_concat(L, c-b+1, c); /* may change `base' (and `ra') */
614  base = L->base;
615  setobjs2s(RA(i), base+b);
616  luaC_checkGC(L);
617  break;
618  }
619  case OP_JMP: {
620  dojump(pc, GETARG_sBx(i));
621  break;
622  }
623  case OP_EQ: {
624  if (equalobj(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;
625  else dojump(pc, GETARG_sBx(*pc) + 1);
626  break;
627  }
628  case OP_LT: {
629  if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;
630  else dojump(pc, GETARG_sBx(*pc) + 1);
631  break;
632  }
633  case OP_LE: {
634  if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;
635  else dojump(pc, GETARG_sBx(*pc) + 1);
636  break;
637  }
638  case OP_TEST: {
639  TObject *rb = RB(i);
640  if (l_isfalse(rb) == GETARG_C(i)) pc++;
641  else {
642  setobjs2s(ra, rb);
643  dojump(pc, GETARG_sBx(*pc) + 1);
644  }
645  break;
646  }
647  case OP_CALL:
648  case OP_TAILCALL: {
649  StkId firstResult;
650  int b = GETARG_B(i);
651  int nresults;
652  if (b != 0) L->top = ra+b; /* else previous instruction set top */
653  nresults = GETARG_C(i) - 1;
654  firstResult = luaD_precall(L, ra);
655  if (firstResult) {
656  if (firstResult > L->top) { /* yield? */
657  lua_assert(L->ci->state == (CI_C | CI_YIELD));
658  (L->ci - 1)->u.l.savedpc = pc;
659  (L->ci - 1)->state = CI_SAVEDPC;
660  return NULL;
661  }
662  /* it was a C function (`precall' called it); adjust results */
663  luaD_poscall(L, nresults, firstResult);
664  if (nresults >= 0) L->top = L->ci->top;
665  }
666  else { /* it is a Lua function */
667  if (GET_OPCODE(i) == OP_CALL) { /* regular call? */
668  (L->ci-1)->u.l.savedpc = pc; /* save `pc' to return later */
669  (L->ci-1)->state = (CI_SAVEDPC | CI_CALLING);
670  }
671  else { /* tail call: put new frame in place of previous one */
672  int aux;
673  base = (L->ci - 1)->base; /* `luaD_precall' may change the stack */
674  ra = RA(i);
675  if (L->openupval) luaF_close(L, base);
676  for (aux = 0; ra+aux < L->top; aux++) /* move frame down */
677  setobjs2s(base+aux-1, ra+aux);
678  (L->ci - 1)->top = L->top = base+aux; /* correct top */
679  lua_assert(L->ci->state & CI_SAVEDPC);
680  (L->ci - 1)->u.l.savedpc = L->ci->u.l.savedpc;
681  (L->ci - 1)->u.l.tailcalls++; /* one more call lost */
682  (L->ci - 1)->state = CI_SAVEDPC;
683  L->ci--; /* remove new frame */
684  L->base = L->ci->base;
685  }
686  goto callentry;
687  }
688  break;
689  }
690  case OP_RETURN: {
691  CallInfo *ci = L->ci - 1; /* previous function frame */
692  int b = GETARG_B(i);
693  if (b != 0) L->top = ra+b-1;
695  if (L->openupval) luaF_close(L, base);
696  L->ci->state = CI_SAVEDPC; /* deactivate current function */
697  L->ci->u.l.savedpc = pc;
698  /* previous function was running `here'? */
699  if (!(ci->state & CI_CALLING)) {
700  lua_assert((ci->state & CI_C) || ci->u.l.pc != &pc);
701  return ra; /* no: return */
702  }
703  else { /* yes: continue its execution */
704  int nresults;
705  lua_assert(ttisfunction(ci->base - 1) && (ci->state & CI_SAVEDPC));
706  lua_assert(GET_OPCODE(*(ci->u.l.savedpc - 1)) == OP_CALL);
707  nresults = GETARG_C(*(ci->u.l.savedpc - 1)) - 1;
708  luaD_poscall(L, nresults, ra);
709  if (nresults >= 0) L->top = L->ci->top;
710  goto retentry;
711  }
712  }
713  case OP_FORLOOP: {
714  lua_Number step, idx, limit;
715  const TObject *plimit = ra+1;
716  const TObject *pstep = ra+2;
717  if (!ttisnumber(ra))
718  luaG_runerror(L, "`for' initial value must be a number");
719  if (!tonumber(plimit, ra+1))
720  luaG_runerror(L, "`for' limit must be a number");
721 /*@-modobserver@*/
722  if (!tonumber(pstep, ra+2))
723  luaG_runerror(L, "`for' step must be a number");
724 /*@=modobserver@*/
725  step = nvalue(pstep);
726  idx = nvalue(ra) + step; /* increment index */
727  limit = nvalue(plimit);
728  if (step > 0 ? idx <= limit : idx >= limit) {
729  dojump(pc, GETARG_sBx(i)); /* jump back */
730  chgnvalue(ra, idx); /* update index */
731  }
732  break;
733  }
734  case OP_TFORLOOP: {
735  int nvar = GETARG_C(i) + 1;
736  StkId cb = ra + nvar + 2; /* call base */
737  setobjs2s(cb, ra);
738  setobjs2s(cb+1, ra+1);
739  setobjs2s(cb+2, ra+2);
740  L->top = cb+3; /* func. + 2 args (state and index) */
741  luaD_call(L, cb, nvar);
742  L->top = L->ci->top;
743  ra = XRA(i) + 2; /* final position of first result */
744  cb = ra + nvar;
745  do { /* move results to proper positions */
746  nvar--;
747  setobjs2s(ra+nvar, cb+nvar);
748  } while (nvar > 0);
749  if (ttisnil(ra)) /* break loop? */
750  pc++; /* skip jump (break loop) */
751  else
752  dojump(pc, GETARG_sBx(*pc) + 1); /* jump back */
753  break;
754  }
755  case OP_TFORPREP: { /* for compatibility only */
756  if (ttistable(ra)) {
757  setobjs2s(ra+1, ra);
758  setobj2s(ra, luaH_getstr(hvalue(gt(L)), luaS_new(L, "next")));
759  }
760  dojump(pc, GETARG_sBx(i));
761  break;
762  }
763  case OP_SETLIST:
764  case OP_SETLISTO: {
765  int bc;
766  int n;
767  Table *h;
768  runtime_check(L, ttistable(ra));
769  h = hvalue(ra);
770  bc = GETARG_Bx(i);
771  if (GET_OPCODE(i) == OP_SETLIST)
772  n = (bc&(LFIELDS_PER_FLUSH-1)) + 1;
773  else {
774  n = L->top - ra - 1;
775  L->top = L->ci->top;
776  }
777  bc &= ~(LFIELDS_PER_FLUSH-1); /* bc = bc - bc%FPF */
778  for (; n > 0; n--)
779  setobj2t(luaH_setnum(L, h, bc+n), ra+n); /* write barrier */
780  break;
781  }
782  case OP_CLOSE: {
783  luaF_close(L, ra);
784  break;
785  }
786  case OP_CLOSURE: {
787  Proto *p;
788  Closure *ncl;
789  int nup, j;
790  p = cl->p->p[GETARG_Bx(i)];
791  nup = p->nups;
792  ncl = luaF_newLclosure(L, nup, &cl->g);
793  ncl->l.p = p;
794  for (j=0; j<nup; j++, pc++) {
795  if (GET_OPCODE(*pc) == OP_GETUPVAL)
796  ncl->l.upvals[j] = cl->upvals[GETARG_B(*pc)];
797  else {
798  lua_assert(GET_OPCODE(*pc) == OP_MOVE);
799  ncl->l.upvals[j] = luaF_findupval(L, base + GETARG_B(*pc));
800  }
801  }
802  setclvalue(ra, ncl);
803  luaC_checkGC(L);
804  break;
805  }
806  }
807  }
808 }
809 
810