The Battle for Wesnoth  1.15.0-dev
lparser.cpp
Go to the documentation of this file.
1 /*
2 ** $Id: lparser.c,v 2.155 2016/08/01 19:51:24 roberto Exp $
3 ** Lua Parser
4 ** See Copyright Notice in lua.h
5 */
6 
7 #define lparser_c
8 #define LUA_CORE
9 
10 #include "lprefix.h"
11 
12 
13 #include <string.h>
14 
15 #include "lua.h"
16 
17 #include "lcode.h"
18 #include "ldebug.h"
19 #include "ldo.h"
20 #include "lfunc.h"
21 #include "llex.h"
22 #include "lmem.h"
23 #include "lobject.h"
24 #include "lopcodes.h"
25 #include "lparser.h"
26 #include "lstate.h"
27 #include "lstring.h"
28 #include "ltable.h"
29 
30 
31 
32 /* maximum number of local variables per function (must be smaller
33  than 250, due to the bytecode format) */
34 #define MAXVARS 200
35 
36 
37 #define hasmultret(k) ((k) == VCALL || (k) == VVARARG)
38 
39 
40 /* because all strings are unified by the scanner, the parser
41  can use pointer equality for string equality */
42 #define eqstr(a,b) ((a) == (b))
43 
44 
45 /*
46 ** nodes for block list (list of active blocks)
47 */
48 typedef struct BlockCnt {
49  struct BlockCnt *previous; /* chain */
50  int firstlabel; /* index of first label in this block */
51  int firstgoto; /* index of first pending goto in this block */
52  lu_byte nactvar; /* # active locals outside the block */
53  lu_byte upval; /* true if some variable in the block is an upvalue */
54  lu_byte isloop; /* true if 'block' is a loop */
55 } BlockCnt;
56 
57 
58 
59 /*
60 ** prototypes for recursive non-terminal functions
61 */
62 static void statement (LexState *ls);
63 static void expr (LexState *ls, expdesc *v);
64 
65 
66 /* semantic error */
67 static l_noret semerror (LexState *ls, const char *msg) {
68  ls->t.token = 0; /* remove "near <token>" from final message */
69  luaX_syntaxerror(ls, msg);
70 }
71 
72 
73 static l_noret error_expected (LexState *ls, int token) {
75  luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token)));
76 }
77 
78 
79 static l_noret errorlimit (FuncState *fs, int limit, const char *what) {
80  lua_State *L = fs->ls->L;
81  const char *msg;
82  int line = fs->f->linedefined;
83  const char *where = (line == 0)
84  ? "main function"
85  : luaO_pushfstring(L, "function at line %d", line);
86  msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s",
87  what, limit, where);
88  luaX_syntaxerror(fs->ls, msg);
89 }
90 
91 
92 static void checklimit (FuncState *fs, int v, int l, const char *what) {
93  if (v > l) errorlimit(fs, l, what);
94 }
95 
96 
97 static int testnext (LexState *ls, int c) {
98  if (ls->t.token == c) {
99  luaX_next(ls);
100  return 1;
101  }
102  else return 0;
103 }
104 
105 
106 static void check (LexState *ls, int c) {
107  if (ls->t.token != c)
108  error_expected(ls, c);
109 }
110 
111 
112 static void checknext (LexState *ls, int c) {
113  check(ls, c);
114  luaX_next(ls);
115 }
116 
117 
118 #define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); }
119 
120 
121 
122 static void check_match (LexState *ls, int what, int who, int where) {
123  if (!testnext(ls, what)) {
124  if (where == ls->linenumber)
125  error_expected(ls, what);
126  else {
128  "%s expected (to close %s at line %d)",
129  luaX_token2str(ls, what), luaX_token2str(ls, who), where));
130  }
131  }
132 }
133 
134 
136  TString *ts;
137  check(ls, TK_NAME);
138  ts = ls->t.seminfo.ts;
139  luaX_next(ls);
140  return ts;
141 }
142 
143 
144 static void init_exp (expdesc *e, expkind k, int i) {
145  e->f = e->t = NO_JUMP;
146  e->k = k;
147  e->u.info = i;
148 }
149 
150 
151 static void codestring (LexState *ls, expdesc *e, TString *s) {
152  init_exp(e, VK, luaK_stringK(ls->fs, s));
153 }
154 
155 
156 static void checkname (LexState *ls, expdesc *e) {
157  codestring(ls, e, str_checkname(ls));
158 }
159 
160 
161 static int registerlocalvar (LexState *ls, TString *varname) {
162  FuncState *fs = ls->fs;
163  Proto *f = fs->f;
164  int oldsize = f->sizelocvars;
165  luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
166  LocVar, SHRT_MAX, "local variables");
167  while (oldsize < f->sizelocvars)
168  f->locvars[oldsize++].varname = NULL;
169  f->locvars[fs->nlocvars].varname = varname;
170  luaC_objbarrier(ls->L, f, varname);
171  return fs->nlocvars++;
172 }
173 
174 
175 static void new_localvar (LexState *ls, TString *name) {
176  FuncState *fs = ls->fs;
177  Dyndata *dyd = ls->dyd;
178  int reg = registerlocalvar(ls, name);
179  checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal,
180  MAXVARS, "local variables");
181  luaM_growvector(ls->L, dyd->actvar.arr, dyd->actvar.n + 1,
182  dyd->actvar.size, Vardesc, MAX_INT, "local variables");
183  dyd->actvar.arr[dyd->actvar.n++].idx = cast(short, reg);
184 }
185 
186 
187 static void new_localvarliteral_ (LexState *ls, const char *name, size_t sz) {
188  new_localvar(ls, luaX_newstring(ls, name, sz));
189 }
190 
191 #define new_localvarliteral(ls,v) \
192  new_localvarliteral_(ls, "" v, (sizeof(v)/sizeof(char))-1)
193 
194 
195 static LocVar *getlocvar (FuncState *fs, int i) {
196  int idx = fs->ls->dyd->actvar.arr[fs->firstlocal + i].idx;
197  lua_assert(idx < fs->nlocvars);
198  return &fs->f->locvars[idx];
199 }
200 
201 
202 static void adjustlocalvars (LexState *ls, int nvars) {
203  FuncState *fs = ls->fs;
204  fs->nactvar = cast_byte(fs->nactvar + nvars);
205  for (; nvars; nvars--) {
206  getlocvar(fs, fs->nactvar - nvars)->startpc = fs->pc;
207  }
208 }
209 
210 
211 static void removevars (FuncState *fs, int tolevel) {
212  fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel);
213  while (fs->nactvar > tolevel)
214  getlocvar(fs, --fs->nactvar)->endpc = fs->pc;
215 }
216 
217 
218 static int searchupvalue (FuncState *fs, TString *name) {
219  int i;
220  Upvaldesc *up = fs->f->upvalues;
221  for (i = 0; i < fs->nups; i++) {
222  if (eqstr(up[i].name, name)) return i;
223  }
224  return -1; /* not found */
225 }
226 
227 
228 static int newupvalue (FuncState *fs, TString *name, expdesc *v) {
229  Proto *f = fs->f;
230  int oldsize = f->sizeupvalues;
231  checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues");
232  luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues,
233  Upvaldesc, MAXUPVAL, "upvalues");
234  while (oldsize < f->sizeupvalues)
235  f->upvalues[oldsize++].name = NULL;
236  f->upvalues[fs->nups].instack = (v->k == VLOCAL);
237  f->upvalues[fs->nups].idx = cast_byte(v->u.info);
238  f->upvalues[fs->nups].name = name;
239  luaC_objbarrier(fs->ls->L, f, name);
240  return fs->nups++;
241 }
242 
243 
244 static int searchvar (FuncState *fs, TString *n) {
245  int i;
246  for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) {
247  if (eqstr(n, getlocvar(fs, i)->varname))
248  return i;
249  }
250  return -1; /* not found */
251 }
252 
253 
254 /*
255  Mark block where variable at given level was defined
256  (to emit close instructions later).
257 */
258 static void markupval (FuncState *fs, int level) {
259  BlockCnt *bl = fs->bl;
260  while (bl->nactvar > level)
261  bl = bl->previous;
262  bl->upval = 1;
263 }
264 
265 
266 /*
267  Find variable with given name 'n'. If it is an upvalue, add this
268  upvalue into all intermediate functions.
269 */
270 static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
271  if (fs == NULL) /* no more levels? */
272  init_exp(var, VVOID, 0); /* default is global */
273  else {
274  int v = searchvar(fs, n); /* look up locals at current level */
275  if (v >= 0) { /* found? */
276  init_exp(var, VLOCAL, v); /* variable is local */
277  if (!base)
278  markupval(fs, v); /* local will be used as an upval */
279  }
280  else { /* not found as local at current level; try upvalues */
281  int idx = searchupvalue(fs, n); /* try existing upvalues */
282  if (idx < 0) { /* not found? */
283  singlevaraux(fs->prev, n, var, 0); /* try upper levels */
284  if (var->k == VVOID) /* not found? */
285  return; /* it is a global */
286  /* else was LOCAL or UPVAL */
287  idx = newupvalue(fs, n, var); /* will be a new upvalue */
288  }
289  init_exp(var, VUPVAL, idx); /* new or old upvalue */
290  }
291  }
292 }
293 
294 
295 static void singlevar (LexState *ls, expdesc *var) {
296  TString *varname = str_checkname(ls);
297  FuncState *fs = ls->fs;
298  singlevaraux(fs, varname, var, 1);
299  if (var->k == VVOID) { /* global name? */
300  expdesc key;
301  singlevaraux(fs, ls->envn, var, 1); /* get environment variable */
302  lua_assert(var->k != VVOID); /* this one must exist */
303  codestring(ls, &key, varname); /* key is variable name */
304  luaK_indexed(fs, var, &key); /* env[varname] */
305  }
306 }
307 
308 
309 static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
310  FuncState *fs = ls->fs;
311  int extra = nvars - nexps;
312  if (hasmultret(e->k)) {
313  extra++; /* includes call itself */
314  if (extra < 0) extra = 0;
315  luaK_setreturns(fs, e, extra); /* last exp. provides the difference */
316  if (extra > 1) luaK_reserveregs(fs, extra-1);
317  }
318  else {
319  if (e->k != VVOID) luaK_exp2nextreg(fs, e); /* close last expression */
320  if (extra > 0) {
321  int reg = fs->freereg;
322  luaK_reserveregs(fs, extra);
323  luaK_nil(fs, reg, extra);
324  }
325  }
326  if (nexps > nvars)
327  ls->fs->freereg -= nexps - nvars; /* remove extra values */
328 }
329 
330 
331 static void enterlevel (LexState *ls) {
332  lua_State *L = ls->L;
333  ++L->nCcalls;
334  checklimit(ls->fs, L->nCcalls, LUAI_MAXCCALLS, "C levels");
335 }
336 
337 
338 #define leavelevel(ls) ((ls)->L->nCcalls--)
339 
340 
341 static void closegoto (LexState *ls, int g, Labeldesc *label) {
342  int i;
343  FuncState *fs = ls->fs;
344  Labellist *gl = &ls->dyd->gt;
345  Labeldesc *gt = &gl->arr[g];
346  lua_assert(eqstr(gt->name, label->name));
347  if (gt->nactvar < label->nactvar) {
348  TString *vname = getlocvar(fs, gt->nactvar)->varname;
349  const char *msg = luaO_pushfstring(ls->L,
350  "<goto %s> at line %d jumps into the scope of local '%s'",
351  getstr(gt->name), gt->line, getstr(vname));
352  semerror(ls, msg);
353  }
354  luaK_patchlist(fs, gt->pc, label->pc);
355  /* remove goto from pending list */
356  for (i = g; i < gl->n - 1; i++)
357  gl->arr[i] = gl->arr[i + 1];
358  gl->n--;
359 }
360 
361 
362 /*
363 ** try to close a goto with existing labels; this solves backward jumps
364 */
365 static int findlabel (LexState *ls, int g) {
366  int i;
367  BlockCnt *bl = ls->fs->bl;
368  Dyndata *dyd = ls->dyd;
369  Labeldesc *gt = &dyd->gt.arr[g];
370  /* check labels in current block for a match */
371  for (i = bl->firstlabel; i < dyd->label.n; i++) {
372  Labeldesc *lb = &dyd->label.arr[i];
373  if (eqstr(lb->name, gt->name)) { /* correct label? */
374  if (gt->nactvar > lb->nactvar &&
375  (bl->upval || dyd->label.n > bl->firstlabel))
376  luaK_patchclose(ls->fs, gt->pc, lb->nactvar);
377  closegoto(ls, g, lb); /* close it */
378  return 1;
379  }
380  }
381  return 0; /* label not found; cannot close goto */
382 }
383 
384 
385 static int newlabelentry (LexState *ls, Labellist *l, TString *name,
386  int line, int pc) {
387  int n = l->n;
388  luaM_growvector(ls->L, l->arr, n, l->size,
389  Labeldesc, SHRT_MAX, "labels/gotos");
390  l->arr[n].name = name;
391  l->arr[n].line = line;
392  l->arr[n].nactvar = ls->fs->nactvar;
393  l->arr[n].pc = pc;
394  l->n = n + 1;
395  return n;
396 }
397 
398 
399 /*
400 ** check whether new label 'lb' matches any pending gotos in current
401 ** block; solves forward jumps
402 */
403 static void findgotos (LexState *ls, Labeldesc *lb) {
404  Labellist *gl = &ls->dyd->gt;
405  int i = ls->fs->bl->firstgoto;
406  while (i < gl->n) {
407  if (eqstr(gl->arr[i].name, lb->name))
408  closegoto(ls, i, lb);
409  else
410  i++;
411  }
412 }
413 
414 
415 /*
416 ** export pending gotos to outer level, to check them against
417 ** outer labels; if the block being exited has upvalues, and
418 ** the goto exits the scope of any variable (which can be the
419 ** upvalue), close those variables being exited.
420 */
421 static void movegotosout (FuncState *fs, BlockCnt *bl) {
422  int i = bl->firstgoto;
423  Labellist *gl = &fs->ls->dyd->gt;
424  /* correct pending gotos to current block and try to close it
425  with visible labels */
426  while (i < gl->n) {
427  Labeldesc *gt = &gl->arr[i];
428  if (gt->nactvar > bl->nactvar) {
429  if (bl->upval)
430  luaK_patchclose(fs, gt->pc, bl->nactvar);
431  gt->nactvar = bl->nactvar;
432  }
433  if (!findlabel(fs->ls, i))
434  i++; /* move to next one */
435  }
436 }
437 
438 
440  bl->isloop = isloop;
441  bl->nactvar = fs->nactvar;
442  bl->firstlabel = fs->ls->dyd->label.n;
443  bl->firstgoto = fs->ls->dyd->gt.n;
444  bl->upval = 0;
445  bl->previous = fs->bl;
446  fs->bl = bl;
447  lua_assert(fs->freereg == fs->nactvar);
448 }
449 
450 
451 /*
452 ** create a label named 'break' to resolve break statements
453 */
454 static void breaklabel (LexState *ls) {
455  TString *n = luaS_new(ls->L, "break");
456  int l = newlabelentry(ls, &ls->dyd->label, n, 0, ls->fs->pc);
457  findgotos(ls, &ls->dyd->label.arr[l]);
458 }
459 
460 /*
461 ** generates an error for an undefined 'goto'; choose appropriate
462 ** message when label name is a reserved word (which can only be 'break')
463 */
464 static l_noret undefgoto (LexState *ls, Labeldesc *gt) {
465  const char *msg = isreserved(gt->name)
466  ? "<%s> at line %d not inside a loop"
467  : "no visible label '%s' for <goto> at line %d";
468  msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line);
469  semerror(ls, msg);
470 }
471 
472 
473 static void leaveblock (FuncState *fs) {
474  BlockCnt *bl = fs->bl;
475  LexState *ls = fs->ls;
476  if (bl->previous && bl->upval) {
477  /* create a 'jump to here' to close upvalues */
478  int j = luaK_jump(fs);
479  luaK_patchclose(fs, j, bl->nactvar);
480  luaK_patchtohere(fs, j);
481  }
482  if (bl->isloop)
483  breaklabel(ls); /* close pending breaks */
484  fs->bl = bl->previous;
485  removevars(fs, bl->nactvar);
486  lua_assert(bl->nactvar == fs->nactvar);
487  fs->freereg = fs->nactvar; /* free registers */
488  ls->dyd->label.n = bl->firstlabel; /* remove local labels */
489  if (bl->previous) /* inner block? */
490  movegotosout(fs, bl); /* update pending gotos to outer block */
491  else if (bl->firstgoto < ls->dyd->gt.n) /* pending gotos in outer block? */
492  undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */
493 }
494 
495 
496 /*
497 ** adds a new prototype into list of prototypes
498 */
499 static Proto *addprototype (LexState *ls) {
500  Proto *clp;
501  lua_State *L = ls->L;
502  FuncState *fs = ls->fs;
503  Proto *f = fs->f; /* prototype of current function */
504  if (fs->np >= f->sizep) {
505  int oldsize = f->sizep;
506  luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions");
507  while (oldsize < f->sizep)
508  f->p[oldsize++] = NULL;
509  }
510  f->p[fs->np++] = clp = luaF_newproto(L);
511  luaC_objbarrier(L, f, clp);
512  return clp;
513 }
514 
515 
516 /*
517 ** codes instruction to create new closure in parent function.
518 ** The OP_CLOSURE instruction must use the last available register,
519 ** so that, if it invokes the GC, the GC knows which registers
520 ** are in use at that time.
521 */
522 static void codeclosure (LexState *ls, expdesc *v) {
523  FuncState *fs = ls->fs->prev;
524  init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1));
525  luaK_exp2nextreg(fs, v); /* fix it at the last register */
526 }
527 
528 
529 static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {
530  Proto *f;
531  fs->prev = ls->fs; /* linked list of funcstates */
532  fs->ls = ls;
533  ls->fs = fs;
534  fs->pc = 0;
535  fs->lasttarget = 0;
536  fs->jpc = NO_JUMP;
537  fs->freereg = 0;
538  fs->nk = 0;
539  fs->np = 0;
540  fs->nups = 0;
541  fs->nlocvars = 0;
542  fs->nactvar = 0;
543  fs->firstlocal = ls->dyd->actvar.n;
544  fs->bl = NULL;
545  f = fs->f;
546  f->source = ls->source;
547  f->maxstacksize = 2; /* registers 0/1 are always valid */
548  enterblock(fs, bl, 0);
549 }
550 
551 
552 static void close_func (LexState *ls) {
553  lua_State *L = ls->L;
554  FuncState *fs = ls->fs;
555  Proto *f = fs->f;
556  luaK_ret(fs, 0, 0); /* final return */
557  leaveblock(fs);
558  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
559  f->sizecode = fs->pc;
560  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
561  f->sizelineinfo = fs->pc;
562  luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
563  f->sizek = fs->nk;
564  luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
565  f->sizep = fs->np;
567  f->sizelocvars = fs->nlocvars;
569  f->sizeupvalues = fs->nups;
570  lua_assert(fs->bl == NULL);
571  ls->fs = fs->prev;
572  luaC_checkGC(L);
573 }
574 
575 
576 
577 /*============================================================*/
578 /* GRAMMAR RULES */
579 /*============================================================*/
580 
581 
582 /*
583 ** check whether current token is in the follow set of a block.
584 ** 'until' closes syntactical blocks, but do not close scope,
585 ** so it is handled in separate.
586 */
587 static int block_follow (LexState *ls, int withuntil) {
588  switch (ls->t.token) {
589  case TK_ELSE: case TK_ELSEIF:
590  case TK_END: case TK_EOS:
591  return 1;
592  case TK_UNTIL: return withuntil;
593  default: return 0;
594  }
595 }
596 
597 
598 static void statlist (LexState *ls) {
599  /* statlist -> { stat [';'] } */
600  while (!block_follow(ls, 1)) {
601  if (ls->t.token == TK_RETURN) {
602  statement(ls);
603  return; /* 'return' must be last statement */
604  }
605  statement(ls);
606  }
607 }
608 
609 
610 static void fieldsel (LexState *ls, expdesc *v) {
611  /* fieldsel -> ['.' | ':'] NAME */
612  FuncState *fs = ls->fs;
613  expdesc key;
614  luaK_exp2anyregup(fs, v);
615  luaX_next(ls); /* skip the dot or colon */
616  checkname(ls, &key);
617  luaK_indexed(fs, v, &key);
618 }
619 
620 
621 static void yindex (LexState *ls, expdesc *v) {
622  /* index -> '[' expr ']' */
623  luaX_next(ls); /* skip the '[' */
624  expr(ls, v);
625  luaK_exp2val(ls->fs, v);
626  checknext(ls, ']');
627 }
628 
629 
630 /*
631 ** {======================================================================
632 ** Rules for Constructors
633 ** =======================================================================
634 */
635 
636 
637 struct ConsControl {
638  expdesc v; /* last list item read */
639  expdesc *t; /* table descriptor */
640  int nh; /* total number of 'record' elements */
641  int na; /* total number of array elements */
642  int tostore; /* number of array elements pending to be stored */
643 };
644 
645 
646 static void recfield (LexState *ls, struct ConsControl *cc) {
647  /* recfield -> (NAME | '['exp1']') = exp1 */
648  FuncState *fs = ls->fs;
649  int reg = ls->fs->freereg;
650  expdesc key, val;
651  int rkkey;
652  if (ls->t.token == TK_NAME) {
653  checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
654  checkname(ls, &key);
655  }
656  else /* ls->t.token == '[' */
657  yindex(ls, &key);
658  cc->nh++;
659  checknext(ls, '=');
660  rkkey = luaK_exp2RK(fs, &key);
661  expr(ls, &val);
662  luaK_codeABC(fs, OP_SETTABLE, cc->t->u.info, rkkey, luaK_exp2RK(fs, &val));
663  fs->freereg = reg; /* free registers */
664 }
665 
666 
667 static void closelistfield (FuncState *fs, struct ConsControl *cc) {
668  if (cc->v.k == VVOID) return; /* there is no list item */
669  luaK_exp2nextreg(fs, &cc->v);
670  cc->v.k = VVOID;
671  if (cc->tostore == LFIELDS_PER_FLUSH) {
672  luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); /* flush */
673  cc->tostore = 0; /* no more items pending */
674  }
675 }
676 
677 
678 static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
679  if (cc->tostore == 0) return;
680  if (hasmultret(cc->v.k)) {
681  luaK_setmultret(fs, &cc->v);
682  luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET);
683  cc->na--; /* do not count last expression (unknown number of elements) */
684  }
685  else {
686  if (cc->v.k != VVOID)
687  luaK_exp2nextreg(fs, &cc->v);
688  luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore);
689  }
690 }
691 
692 
693 static void listfield (LexState *ls, struct ConsControl *cc) {
694  /* listfield -> exp */
695  expr(ls, &cc->v);
696  checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
697  cc->na++;
698  cc->tostore++;
699 }
700 
701 
702 static void field (LexState *ls, struct ConsControl *cc) {
703  /* field -> listfield | recfield */
704  switch(ls->t.token) {
705  case TK_NAME: { /* may be 'listfield' or 'recfield' */
706  if (luaX_lookahead(ls) != '=') /* expression? */
707  listfield(ls, cc);
708  else
709  recfield(ls, cc);
710  break;
711  }
712  case '[': {
713  recfield(ls, cc);
714  break;
715  }
716  default: {
717  listfield(ls, cc);
718  break;
719  }
720  }
721 }
722 
723 
724 static void constructor (LexState *ls, expdesc *t) {
725  /* constructor -> '{' [ field { sep field } [sep] ] '}'
726  sep -> ',' | ';' */
727  FuncState *fs = ls->fs;
728  int line = ls->linenumber;
729  int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
730  struct ConsControl cc;
731  cc.na = cc.nh = cc.tostore = 0;
732  cc.t = t;
733  init_exp(t, VRELOCABLE, pc);
734  init_exp(&cc.v, VVOID, 0); /* no value (yet) */
735  luaK_exp2nextreg(ls->fs, t); /* fix it at stack top */
736  checknext(ls, '{');
737  do {
738  lua_assert(cc.v.k == VVOID || cc.tostore > 0);
739  if (ls->t.token == '}') break;
740  closelistfield(fs, &cc);
741  field(ls, &cc);
742  } while (testnext(ls, ',') || testnext(ls, ';'));
743  check_match(ls, '}', '{', line);
744  lastlistfield(fs, &cc);
745  SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */
746  SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh)); /* set initial table size */
747 }
748 
749 /* }====================================================================== */
750 
751 
752 
753 static void parlist (LexState *ls) {
754  /* parlist -> [ param { ',' param } ] */
755  FuncState *fs = ls->fs;
756  Proto *f = fs->f;
757  int nparams = 0;
758  f->is_vararg = 0;
759  if (ls->t.token != ')') { /* is 'parlist' not empty? */
760  do {
761  switch (ls->t.token) {
762  case TK_NAME: { /* param -> NAME */
763  new_localvar(ls, str_checkname(ls));
764  nparams++;
765  break;
766  }
767  case TK_DOTS: { /* param -> '...' */
768  luaX_next(ls);
769  f->is_vararg = 1; /* declared vararg */
770  break;
771  }
772  default: luaX_syntaxerror(ls, "<name> or '...' expected");
773  }
774  } while (!f->is_vararg && testnext(ls, ','));
775  }
776  adjustlocalvars(ls, nparams);
777  f->numparams = cast_byte(fs->nactvar);
778  luaK_reserveregs(fs, fs->nactvar); /* reserve register for parameters */
779 }
780 
781 
782 static void body (LexState *ls, expdesc *e, int ismethod, int line) {
783  /* body -> '(' parlist ')' block END */
784  FuncState new_fs;
785  BlockCnt bl;
786  new_fs.f = addprototype(ls);
787  new_fs.f->linedefined = line;
788  open_func(ls, &new_fs, &bl);
789  checknext(ls, '(');
790  if (ismethod) {
791  new_localvarliteral(ls, "self"); /* create 'self' parameter */
792  adjustlocalvars(ls, 1);
793  }
794  parlist(ls);
795  checknext(ls, ')');
796  statlist(ls);
797  new_fs.f->lastlinedefined = ls->linenumber;
798  check_match(ls, TK_END, TK_FUNCTION, line);
799  codeclosure(ls, e);
800  close_func(ls);
801 }
802 
803 
804 static int explist (LexState *ls, expdesc *v) {
805  /* explist -> expr { ',' expr } */
806  int n = 1; /* at least one expression */
807  expr(ls, v);
808  while (testnext(ls, ',')) {
809  luaK_exp2nextreg(ls->fs, v);
810  expr(ls, v);
811  n++;
812  }
813  return n;
814 }
815 
816 
817 static void funcargs (LexState *ls, expdesc *f, int line) {
818  FuncState *fs = ls->fs;
819  expdesc args;
820  int base, nparams;
821  switch (ls->t.token) {
822  case '(': { /* funcargs -> '(' [ explist ] ')' */
823  luaX_next(ls);
824  if (ls->t.token == ')') /* arg list is empty? */
825  args.k = VVOID;
826  else {
827  explist(ls, &args);
828  luaK_setmultret(fs, &args);
829  }
830  check_match(ls, ')', '(', line);
831  break;
832  }
833  case '{': { /* funcargs -> constructor */
834  constructor(ls, &args);
835  break;
836  }
837  case TK_STRING: { /* funcargs -> STRING */
838  codestring(ls, &args, ls->t.seminfo.ts);
839  luaX_next(ls); /* must use 'seminfo' before 'next' */
840  break;
841  }
842  default: {
843  luaX_syntaxerror(ls, "function arguments expected");
844  }
845  }
846  lua_assert(f->k == VNONRELOC);
847  base = f->u.info; /* base register for call */
848  if (hasmultret(args.k))
849  nparams = LUA_MULTRET; /* open call */
850  else {
851  if (args.k != VVOID)
852  luaK_exp2nextreg(fs, &args); /* close last argument */
853  nparams = fs->freereg - (base+1);
854  }
855  init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
856  luaK_fixline(fs, line);
857  fs->freereg = base+1; /* call remove function and arguments and leaves
858  (unless changed) one result */
859 }
860 
861 
862 
863 
864 /*
865 ** {======================================================================
866 ** Expression parsing
867 ** =======================================================================
868 */
869 
870 
871 static void primaryexp (LexState *ls, expdesc *v) {
872  /* primaryexp -> NAME | '(' expr ')' */
873  switch (ls->t.token) {
874  case '(': {
875  int line = ls->linenumber;
876  luaX_next(ls);
877  expr(ls, v);
878  check_match(ls, ')', '(', line);
879  luaK_dischargevars(ls->fs, v);
880  return;
881  }
882  case TK_NAME: {
883  singlevar(ls, v);
884  return;
885  }
886  default: {
887  luaX_syntaxerror(ls, "unexpected symbol");
888  }
889  }
890 }
891 
892 
893 static void suffixedexp (LexState *ls, expdesc *v) {
894  /* suffixedexp ->
895  primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */
896  FuncState *fs = ls->fs;
897  int line = ls->linenumber;
898  primaryexp(ls, v);
899  for (;;) {
900  switch (ls->t.token) {
901  case '.': { /* fieldsel */
902  fieldsel(ls, v);
903  break;
904  }
905  case '[': { /* '[' exp1 ']' */
906  expdesc key;
907  luaK_exp2anyregup(fs, v);
908  yindex(ls, &key);
909  luaK_indexed(fs, v, &key);
910  break;
911  }
912  case ':': { /* ':' NAME funcargs */
913  expdesc key;
914  luaX_next(ls);
915  checkname(ls, &key);
916  luaK_self(fs, v, &key);
917  funcargs(ls, v, line);
918  break;
919  }
920  case '(': case TK_STRING: case '{': { /* funcargs */
921  luaK_exp2nextreg(fs, v);
922  funcargs(ls, v, line);
923  break;
924  }
925  default: return;
926  }
927  }
928 }
929 
930 
931 static void simpleexp (LexState *ls, expdesc *v) {
932  /* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... |
933  constructor | FUNCTION body | suffixedexp */
934  switch (ls->t.token) {
935  case TK_FLT: {
936  init_exp(v, VKFLT, 0);
937  v->u.nval = ls->t.seminfo.r;
938  break;
939  }
940  case TK_INT: {
941  init_exp(v, VKINT, 0);
942  v->u.ival = ls->t.seminfo.i;
943  break;
944  }
945  case TK_STRING: {
946  codestring(ls, v, ls->t.seminfo.ts);
947  break;
948  }
949  case TK_NIL: {
950  init_exp(v, VNIL, 0);
951  break;
952  }
953  case TK_TRUE: {
954  init_exp(v, VTRUE, 0);
955  break;
956  }
957  case TK_FALSE: {
958  init_exp(v, VFALSE, 0);
959  break;
960  }
961  case TK_DOTS: { /* vararg */
962  FuncState *fs = ls->fs;
963  check_condition(ls, fs->f->is_vararg,
964  "cannot use '...' outside a vararg function");
965  init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
966  break;
967  }
968  case '{': { /* constructor */
969  constructor(ls, v);
970  return;
971  }
972  case TK_FUNCTION: {
973  luaX_next(ls);
974  body(ls, v, 0, ls->linenumber);
975  return;
976  }
977  default: {
978  suffixedexp(ls, v);
979  return;
980  }
981  }
982  luaX_next(ls);
983 }
984 
985 
986 static UnOpr getunopr (int op) {
987  switch (op) {
988  case TK_NOT: return OPR_NOT;
989  case '-': return OPR_MINUS;
990  case '~': return OPR_BNOT;
991  case '#': return OPR_LEN;
992  default: return OPR_NOUNOPR;
993  }
994 }
995 
996 
997 static BinOpr getbinopr (int op) {
998  switch (op) {
999  case '+': return OPR_ADD;
1000  case '-': return OPR_SUB;
1001  case '*': return OPR_MUL;
1002  case '%': return OPR_MOD;
1003  case '^': return OPR_POW;
1004  case '/': return OPR_DIV;
1005  case TK_IDIV: return OPR_IDIV;
1006  case '&': return OPR_BAND;
1007  case '|': return OPR_BOR;
1008  case '~': return OPR_BXOR;
1009  case TK_SHL: return OPR_SHL;
1010  case TK_SHR: return OPR_SHR;
1011  case TK_CONCAT: return OPR_CONCAT;
1012  case TK_NE: return OPR_NE;
1013  case TK_EQ: return OPR_EQ;
1014  case '<': return OPR_LT;
1015  case TK_LE: return OPR_LE;
1016  case '>': return OPR_GT;
1017  case TK_GE: return OPR_GE;
1018  case TK_AND: return OPR_AND;
1019  case TK_OR: return OPR_OR;
1020  default: return OPR_NOBINOPR;
1021  }
1022 }
1023 
1024 
1025 static const struct {
1026  lu_byte left; /* left priority for each binary operator */
1027  lu_byte right; /* right priority */
1028 } priority[] = { /* ORDER OPR */
1029  {10, 10}, {10, 10}, /* '+' '-' */
1030  {11, 11}, {11, 11}, /* '*' '%' */
1031  {14, 13}, /* '^' (right associative) */
1032  {11, 11}, {11, 11}, /* '/' '//' */
1033  {6, 6}, {4, 4}, {5, 5}, /* '&' '|' '~' */
1034  {7, 7}, {7, 7}, /* '<<' '>>' */
1035  {9, 8}, /* '..' (right associative) */
1036  {3, 3}, {3, 3}, {3, 3}, /* ==, <, <= */
1037  {3, 3}, {3, 3}, {3, 3}, /* ~=, >, >= */
1038  {2, 2}, {1, 1} /* and, or */
1039 };
1040 
1041 #define UNARY_PRIORITY 12 /* priority for unary operators */
1042 
1043 
1044 /*
1045 ** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
1046 ** where 'binop' is any binary operator with a priority higher than 'limit'
1047 */
1048 static BinOpr subexpr (LexState *ls, expdesc *v, int limit) {
1049  BinOpr op;
1050  UnOpr uop;
1051  enterlevel(ls);
1052  uop = getunopr(ls->t.token);
1053  if (uop != OPR_NOUNOPR) {
1054  int line = ls->linenumber;
1055  luaX_next(ls);
1056  subexpr(ls, v, UNARY_PRIORITY);
1057  luaK_prefix(ls->fs, uop, v, line);
1058  }
1059  else simpleexp(ls, v);
1060  /* expand while operators have priorities higher than 'limit' */
1061  op = getbinopr(ls->t.token);
1062  while (op != OPR_NOBINOPR && priority[op].left > limit) {
1063  expdesc v2;
1064  BinOpr nextop;
1065  int line = ls->linenumber;
1066  luaX_next(ls);
1067  luaK_infix(ls->fs, op, v);
1068  /* read sub-expression with higher priority */
1069  nextop = subexpr(ls, &v2, priority[op].right);
1070  luaK_posfix(ls->fs, op, v, &v2, line);
1071  op = nextop;
1072  }
1073  leavelevel(ls);
1074  return op; /* return first untreated operator */
1075 }
1076 
1077 
1078 static void expr (LexState *ls, expdesc *v) {
1079  subexpr(ls, v, 0);
1080 }
1081 
1082 /* }==================================================================== */
1083 
1084 
1085 
1086 /*
1087 ** {======================================================================
1088 ** Rules for Statements
1089 ** =======================================================================
1090 */
1091 
1092 
1093 static void block (LexState *ls) {
1094  /* block -> statlist */
1095  FuncState *fs = ls->fs;
1096  BlockCnt bl;
1097  enterblock(fs, &bl, 0);
1098  statlist(ls);
1099  leaveblock(fs);
1100 }
1101 
1102 
1103 /*
1104 ** structure to chain all variables in the left-hand side of an
1105 ** assignment
1106 */
1107 struct LHS_assign {
1108  struct LHS_assign *prev;
1109  expdesc v; /* variable (global, local, upvalue, or indexed) */
1110 };
1111 
1112 
1113 /*
1114 ** check whether, in an assignment to an upvalue/local variable, the
1115 ** upvalue/local variable is begin used in a previous assignment to a
1116 ** table. If so, save original upvalue/local value in a safe place and
1117 ** use this safe copy in the previous assignment.
1118 */
1119 static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
1120  FuncState *fs = ls->fs;
1121  int extra = fs->freereg; /* eventual position to save local variable */
1122  int conflict = 0;
1123  for (; lh; lh = lh->prev) { /* check all previous assignments */
1124  if (lh->v.k == VINDEXED) { /* assigning to a table? */
1125  /* table is the upvalue/local being assigned now? */
1126  if (lh->v.u.ind.vt == v->k && lh->v.u.ind.t == v->u.info) {
1127  conflict = 1;
1128  lh->v.u.ind.vt = VLOCAL;
1129  lh->v.u.ind.t = extra; /* previous assignment will use safe copy */
1130  }
1131  /* index is the local being assigned? (index cannot be upvalue) */
1132  if (v->k == VLOCAL && lh->v.u.ind.idx == v->u.info) {
1133  conflict = 1;
1134  lh->v.u.ind.idx = extra; /* previous assignment will use safe copy */
1135  }
1136  }
1137  }
1138  if (conflict) {
1139  /* copy upvalue/local value to a temporary (in position 'extra') */
1140  OpCode op = (v->k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
1141  luaK_codeABC(fs, op, extra, v->u.info, 0);
1142  luaK_reserveregs(fs, 1);
1143  }
1144 }
1145 
1146 
1147 static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
1148  expdesc e;
1149  check_condition(ls, vkisvar(lh->v.k), "syntax error");
1150  if (testnext(ls, ',')) { /* assignment -> ',' suffixedexp assignment */
1151  struct LHS_assign nv;
1152  nv.prev = lh;
1153  suffixedexp(ls, &nv.v);
1154  if (nv.v.k != VINDEXED)
1155  check_conflict(ls, lh, &nv.v);
1156  checklimit(ls->fs, nvars + ls->L->nCcalls, LUAI_MAXCCALLS,
1157  "C levels");
1158  assignment(ls, &nv, nvars+1);
1159  }
1160  else { /* assignment -> '=' explist */
1161  int nexps;
1162  checknext(ls, '=');
1163  nexps = explist(ls, &e);
1164  if (nexps != nvars)
1165  adjust_assign(ls, nvars, nexps, &e);
1166  else {
1167  luaK_setoneret(ls->fs, &e); /* close last expression */
1168  luaK_storevar(ls->fs, &lh->v, &e);
1169  return; /* avoid default */
1170  }
1171  }
1172  init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */
1173  luaK_storevar(ls->fs, &lh->v, &e);
1174 }
1175 
1176 
1177 static int cond (LexState *ls) {
1178  /* cond -> exp */
1179  expdesc v;
1180  expr(ls, &v); /* read condition */
1181  if (v.k == VNIL) v.k = VFALSE; /* 'falses' are all equal here */
1182  luaK_goiftrue(ls->fs, &v);
1183  return v.f;
1184 }
1185 
1186 
1187 static void gotostat (LexState *ls, int pc) {
1188  int line = ls->linenumber;
1189  TString *label;
1190  int g;
1191  if (testnext(ls, TK_GOTO))
1192  label = str_checkname(ls);
1193  else {
1194  luaX_next(ls); /* skip break */
1195  label = luaS_new(ls->L, "break");
1196  }
1197  g = newlabelentry(ls, &ls->dyd->gt, label, line, pc);
1198  findlabel(ls, g); /* close it if label already defined */
1199 }
1200 
1201 
1202 /* check for repeated labels on the same block */
1203 static void checkrepeated (FuncState *fs, Labellist *ll, TString *label) {
1204  int i;
1205  for (i = fs->bl->firstlabel; i < ll->n; i++) {
1206  if (eqstr(label, ll->arr[i].name)) {
1207  const char *msg = luaO_pushfstring(fs->ls->L,
1208  "label '%s' already defined on line %d",
1209  getstr(label), ll->arr[i].line);
1210  semerror(fs->ls, msg);
1211  }
1212  }
1213 }
1214 
1215 
1216 /* skip no-op statements */
1217 static void skipnoopstat (LexState *ls) {
1218  while (ls->t.token == ';' || ls->t.token == TK_DBCOLON)
1219  statement(ls);
1220 }
1221 
1222 
1223 static void labelstat (LexState *ls, TString *label, int line) {
1224  /* label -> '::' NAME '::' */
1225  FuncState *fs = ls->fs;
1226  Labellist *ll = &ls->dyd->label;
1227  int l; /* index of new label being created */
1228  checkrepeated(fs, ll, label); /* check for repeated labels */
1229  checknext(ls, TK_DBCOLON); /* skip double colon */
1230  /* create new entry for this label */
1231  l = newlabelentry(ls, ll, label, line, luaK_getlabel(fs));
1232  skipnoopstat(ls); /* skip other no-op statements */
1233  if (block_follow(ls, 0)) { /* label is last no-op statement in the block? */
1234  /* assume that locals are already out of scope */
1235  ll->arr[l].nactvar = fs->bl->nactvar;
1236  }
1237  findgotos(ls, &ll->arr[l]);
1238 }
1239 
1240 
1241 static void whilestat (LexState *ls, int line) {
1242  /* whilestat -> WHILE cond DO block END */
1243  FuncState *fs = ls->fs;
1244  int whileinit;
1245  int condexit;
1246  BlockCnt bl;
1247  luaX_next(ls); /* skip WHILE */
1248  whileinit = luaK_getlabel(fs);
1249  condexit = cond(ls);
1250  enterblock(fs, &bl, 1);
1251  checknext(ls, TK_DO);
1252  block(ls);
1253  luaK_jumpto(fs, whileinit);
1254  check_match(ls, TK_END, TK_WHILE, line);
1255  leaveblock(fs);
1256  luaK_patchtohere(fs, condexit); /* false conditions finish the loop */
1257 }
1258 
1259 
1260 static void repeatstat (LexState *ls, int line) {
1261  /* repeatstat -> REPEAT block UNTIL cond */
1262  int condexit;
1263  FuncState *fs = ls->fs;
1264  int repeat_init = luaK_getlabel(fs);
1265  BlockCnt bl1, bl2;
1266  enterblock(fs, &bl1, 1); /* loop block */
1267  enterblock(fs, &bl2, 0); /* scope block */
1268  luaX_next(ls); /* skip REPEAT */
1269  statlist(ls);
1270  check_match(ls, TK_UNTIL, TK_REPEAT, line);
1271  condexit = cond(ls); /* read condition (inside scope block) */
1272  if (bl2.upval) /* upvalues? */
1273  luaK_patchclose(fs, condexit, bl2.nactvar);
1274  leaveblock(fs); /* finish scope */
1275  luaK_patchlist(fs, condexit, repeat_init); /* close the loop */
1276  leaveblock(fs); /* finish loop */
1277 }
1278 
1279 
1280 static int exp1 (LexState *ls) {
1281  expdesc e;
1282  int reg;
1283  expr(ls, &e);
1284  luaK_exp2nextreg(ls->fs, &e);
1285  lua_assert(e.k == VNONRELOC);
1286  reg = e.u.info;
1287  return reg;
1288 }
1289 
1290 
1291 static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
1292  /* forbody -> DO block */
1293  BlockCnt bl;
1294  FuncState *fs = ls->fs;
1295  int prep, endfor;
1296  adjustlocalvars(ls, 3); /* control variables */
1297  checknext(ls, TK_DO);
1298  prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
1299  enterblock(fs, &bl, 0); /* scope for declared variables */
1300  adjustlocalvars(ls, nvars);
1301  luaK_reserveregs(fs, nvars);
1302  block(ls);
1303  leaveblock(fs); /* end of scope for declared variables */
1304  luaK_patchtohere(fs, prep);
1305  if (isnum) /* numeric for? */
1306  endfor = luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP);
1307  else { /* generic for */
1308  luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars);
1309  luaK_fixline(fs, line);
1310  endfor = luaK_codeAsBx(fs, OP_TFORLOOP, base + 2, NO_JUMP);
1311  }
1312  luaK_patchlist(fs, endfor, prep + 1);
1313  luaK_fixline(fs, line);
1314 }
1315 
1316 
1317 static void fornum (LexState *ls, TString *varname, int line) {
1318  /* fornum -> NAME = exp1,exp1[,exp1] forbody */
1319  FuncState *fs = ls->fs;
1320  int base = fs->freereg;
1321  new_localvarliteral(ls, "(for index)");
1322  new_localvarliteral(ls, "(for limit)");
1323  new_localvarliteral(ls, "(for step)");
1324  new_localvar(ls, varname);
1325  checknext(ls, '=');
1326  exp1(ls); /* initial value */
1327  checknext(ls, ',');
1328  exp1(ls); /* limit */
1329  if (testnext(ls, ','))
1330  exp1(ls); /* optional step */
1331  else { /* default step = 1 */
1332  luaK_codek(fs, fs->freereg, luaK_intK(fs, 1));
1333  luaK_reserveregs(fs, 1);
1334  }
1335  forbody(ls, base, line, 1, 1);
1336 }
1337 
1338 
1339 static void forlist (LexState *ls, TString *indexname) {
1340  /* forlist -> NAME {,NAME} IN explist forbody */
1341  FuncState *fs = ls->fs;
1342  expdesc e;
1343  int nvars = 4; /* gen, state, control, plus at least one declared var */
1344  int line;
1345  int base = fs->freereg;
1346  /* create control variables */
1347  new_localvarliteral(ls, "(for generator)");
1348  new_localvarliteral(ls, "(for state)");
1349  new_localvarliteral(ls, "(for control)");
1350  /* create declared variables */
1351  new_localvar(ls, indexname);
1352  while (testnext(ls, ',')) {
1353  new_localvar(ls, str_checkname(ls));
1354  nvars++;
1355  }
1356  checknext(ls, TK_IN);
1357  line = ls->linenumber;
1358  adjust_assign(ls, 3, explist(ls, &e), &e);
1359  luaK_checkstack(fs, 3); /* extra space to call generator */
1360  forbody(ls, base, line, nvars - 3, 0);
1361 }
1362 
1363 
1364 static void forstat (LexState *ls, int line) {
1365  /* forstat -> FOR (fornum | forlist) END */
1366  FuncState *fs = ls->fs;
1367  TString *varname;
1368  BlockCnt bl;
1369  enterblock(fs, &bl, 1); /* scope for loop and control variables */
1370  luaX_next(ls); /* skip 'for' */
1371  varname = str_checkname(ls); /* first variable name */
1372  switch (ls->t.token) {
1373  case '=': fornum(ls, varname, line); break;
1374  case ',': case TK_IN: forlist(ls, varname); break;
1375  default: luaX_syntaxerror(ls, "'=' or 'in' expected");
1376  }
1377  check_match(ls, TK_END, TK_FOR, line);
1378  leaveblock(fs); /* loop scope ('break' jumps to this point) */
1379 }
1380 
1381 
1382 static void test_then_block (LexState *ls, int *escapelist) {
1383  /* test_then_block -> [IF | ELSEIF] cond THEN block */
1384  BlockCnt bl;
1385  FuncState *fs = ls->fs;
1386  expdesc v;
1387  int jf; /* instruction to skip 'then' code (if condition is false) */
1388  luaX_next(ls); /* skip IF or ELSEIF */
1389  expr(ls, &v); /* read condition */
1390  checknext(ls, TK_THEN);
1391  if (ls->t.token == TK_GOTO || ls->t.token == TK_BREAK) {
1392  luaK_goiffalse(ls->fs, &v); /* will jump to label if condition is true */
1393  enterblock(fs, &bl, 0); /* must enter block before 'goto' */
1394  gotostat(ls, v.t); /* handle goto/break */
1395  while (testnext(ls, ';')) {} /* skip semicolons */
1396  if (block_follow(ls, 0)) { /* 'goto' is the entire block? */
1397  leaveblock(fs);
1398  return; /* and that is it */
1399  }
1400  else /* must skip over 'then' part if condition is false */
1401  jf = luaK_jump(fs);
1402  }
1403  else { /* regular case (not goto/break) */
1404  luaK_goiftrue(ls->fs, &v); /* skip over block if condition is false */
1405  enterblock(fs, &bl, 0);
1406  jf = v.f;
1407  }
1408  statlist(ls); /* 'then' part */
1409  leaveblock(fs);
1410  if (ls->t.token == TK_ELSE ||
1411  ls->t.token == TK_ELSEIF) /* followed by 'else'/'elseif'? */
1412  luaK_concat(fs, escapelist, luaK_jump(fs)); /* must jump over it */
1413  luaK_patchtohere(fs, jf);
1414 }
1415 
1416 
1417 static void ifstat (LexState *ls, int line) {
1418  /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
1419  FuncState *fs = ls->fs;
1420  int escapelist = NO_JUMP; /* exit list for finished parts */
1421  test_then_block(ls, &escapelist); /* IF cond THEN block */
1422  while (ls->t.token == TK_ELSEIF)
1423  test_then_block(ls, &escapelist); /* ELSEIF cond THEN block */
1424  if (testnext(ls, TK_ELSE))
1425  block(ls); /* 'else' part */
1426  check_match(ls, TK_END, TK_IF, line);
1427  luaK_patchtohere(fs, escapelist); /* patch escape list to 'if' end */
1428 }
1429 
1430 
1431 static void localfunc (LexState *ls) {
1432  expdesc b;
1433  FuncState *fs = ls->fs;
1434  new_localvar(ls, str_checkname(ls)); /* new local variable */
1435  adjustlocalvars(ls, 1); /* enter its scope */
1436  body(ls, &b, 0, ls->linenumber); /* function created in next register */
1437  /* debug information will only see the variable after this point! */
1438  getlocvar(fs, b.u.info)->startpc = fs->pc;
1439 }
1440 
1441 
1442 static void localstat (LexState *ls) {
1443  /* stat -> LOCAL NAME {',' NAME} ['=' explist] */
1444  int nvars = 0;
1445  int nexps;
1446  expdesc e;
1447  do {
1448  new_localvar(ls, str_checkname(ls));
1449  nvars++;
1450  } while (testnext(ls, ','));
1451  if (testnext(ls, '='))
1452  nexps = explist(ls, &e);
1453  else {
1454  e.k = VVOID;
1455  nexps = 0;
1456  }
1457  adjust_assign(ls, nvars, nexps, &e);
1458  adjustlocalvars(ls, nvars);
1459 }
1460 
1461 
1462 static int funcname (LexState *ls, expdesc *v) {
1463  /* funcname -> NAME {fieldsel} [':' NAME] */
1464  int ismethod = 0;
1465  singlevar(ls, v);
1466  while (ls->t.token == '.')
1467  fieldsel(ls, v);
1468  if (ls->t.token == ':') {
1469  ismethod = 1;
1470  fieldsel(ls, v);
1471  }
1472  return ismethod;
1473 }
1474 
1475 
1476 static void funcstat (LexState *ls, int line) {
1477  /* funcstat -> FUNCTION funcname body */
1478  int ismethod;
1479  expdesc v, b;
1480  luaX_next(ls); /* skip FUNCTION */
1481  ismethod = funcname(ls, &v);
1482  body(ls, &b, ismethod, line);
1483  luaK_storevar(ls->fs, &v, &b);
1484  luaK_fixline(ls->fs, line); /* definition "happens" in the first line */
1485 }
1486 
1487 
1488 static void exprstat (LexState *ls) {
1489  /* stat -> func | assignment */
1490  FuncState *fs = ls->fs;
1491  struct LHS_assign v;
1492  suffixedexp(ls, &v.v);
1493  if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */
1494  v.prev = NULL;
1495  assignment(ls, &v, 1);
1496  }
1497  else { /* stat -> func */
1498  check_condition(ls, v.v.k == VCALL, "syntax error");
1499  SETARG_C(getinstruction(fs, &v.v), 1); /* call statement uses no results */
1500  }
1501 }
1502 
1503 
1504 static void retstat (LexState *ls) {
1505  /* stat -> RETURN [explist] [';'] */
1506  FuncState *fs = ls->fs;
1507  expdesc e;
1508  int first, nret; /* registers with returned values */
1509  if (block_follow(ls, 1) || ls->t.token == ';')
1510  first = nret = 0; /* return no values */
1511  else {
1512  nret = explist(ls, &e); /* optional return values */
1513  if (hasmultret(e.k)) {
1514  luaK_setmultret(fs, &e);
1515  if (e.k == VCALL && nret == 1) { /* tail call? */
1517  lua_assert(GETARG_A(getinstruction(fs,&e)) == fs->nactvar);
1518  }
1519  first = fs->nactvar;
1520  nret = LUA_MULTRET; /* return all values */
1521  }
1522  else {
1523  if (nret == 1) /* only one single value? */
1524  first = luaK_exp2anyreg(fs, &e);
1525  else {
1526  luaK_exp2nextreg(fs, &e); /* values must go to the stack */
1527  first = fs->nactvar; /* return all active values */
1528  lua_assert(nret == fs->freereg - first);
1529  }
1530  }
1531  }
1532  luaK_ret(fs, first, nret);
1533  testnext(ls, ';'); /* skip optional semicolon */
1534 }
1535 
1536 
1537 static void statement (LexState *ls) {
1538  int line = ls->linenumber; /* may be needed for error messages */
1539  enterlevel(ls);
1540  switch (ls->t.token) {
1541  case ';': { /* stat -> ';' (empty statement) */
1542  luaX_next(ls); /* skip ';' */
1543  break;
1544  }
1545  case TK_IF: { /* stat -> ifstat */
1546  ifstat(ls, line);
1547  break;
1548  }
1549  case TK_WHILE: { /* stat -> whilestat */
1550  whilestat(ls, line);
1551  break;
1552  }
1553  case TK_DO: { /* stat -> DO block END */
1554  luaX_next(ls); /* skip DO */
1555  block(ls);
1556  check_match(ls, TK_END, TK_DO, line);
1557  break;
1558  }
1559  case TK_FOR: { /* stat -> forstat */
1560  forstat(ls, line);
1561  break;
1562  }
1563  case TK_REPEAT: { /* stat -> repeatstat */
1564  repeatstat(ls, line);
1565  break;
1566  }
1567  case TK_FUNCTION: { /* stat -> funcstat */
1568  funcstat(ls, line);
1569  break;
1570  }
1571  case TK_LOCAL: { /* stat -> localstat */
1572  luaX_next(ls); /* skip LOCAL */
1573  if (testnext(ls, TK_FUNCTION)) /* local function? */
1574  localfunc(ls);
1575  else
1576  localstat(ls);
1577  break;
1578  }
1579  case TK_DBCOLON: { /* stat -> label */
1580  luaX_next(ls); /* skip double colon */
1581  labelstat(ls, str_checkname(ls), line);
1582  break;
1583  }
1584  case TK_RETURN: { /* stat -> retstat */
1585  luaX_next(ls); /* skip RETURN */
1586  retstat(ls);
1587  break;
1588  }
1589  case TK_BREAK: /* stat -> breakstat */
1590  case TK_GOTO: { /* stat -> 'goto' NAME */
1591  gotostat(ls, luaK_jump(ls->fs));
1592  break;
1593  }
1594  default: { /* stat -> func | assignment */
1595  exprstat(ls);
1596  break;
1597  }
1598  }
1599  lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
1600  ls->fs->freereg >= ls->fs->nactvar);
1601  ls->fs->freereg = ls->fs->nactvar; /* free registers */
1602  leavelevel(ls);
1603 }
1604 
1605 /* }====================================================================== */
1606 
1607 
1608 /*
1609 ** compiles the main function, which is a regular vararg function with an
1610 ** upvalue named LUA_ENV
1611 */
1612 static void mainfunc (LexState *ls, FuncState *fs) {
1613  BlockCnt bl;
1614  expdesc v;
1615  open_func(ls, fs, &bl);
1616  fs->f->is_vararg = 1; /* main function is always declared vararg */
1617  init_exp(&v, VLOCAL, 0); /* create and... */
1618  newupvalue(fs, ls->envn, &v); /* ...set environment upvalue */
1619  luaX_next(ls); /* read first token */
1620  statlist(ls); /* parse main body */
1621  check(ls, TK_EOS);
1622  close_func(ls);
1623 }
1624 
1625 
1627  Dyndata *dyd, const char *name, int firstchar) {
1628  LexState lexstate;
1629  FuncState funcstate;
1630  LClosure *cl = luaF_newLclosure(L, 1); /* create main closure */
1631  setclLvalue(L, L->top, cl); /* anchor it (to avoid being collected) */
1632  luaD_inctop(L);
1633  lexstate.h = luaH_new(L); /* create table for scanner */
1634  sethvalue(L, L->top, lexstate.h); /* anchor it */
1635  luaD_inctop(L);
1636  funcstate.f = cl->p = luaF_newproto(L);
1637  funcstate.f->source = luaS_new(L, name); /* create and anchor TString */
1638  lua_assert(iswhite(funcstate.f)); /* do not need barrier here */
1639  lexstate.buff = buff;
1640  lexstate.dyd = dyd;
1641  dyd->actvar.n = dyd->gt.n = dyd->label.n = 0;
1642  luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar);
1643  mainfunc(&lexstate, &funcstate);
1644  lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
1645  /* all scopes should be correctly finished */
1646  lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0);
1647  L->top--; /* remove scanner's table */
1648  return cl; /* closure is on the stack, too */
1649 }
1650 
Definition: lcode.h:34
struct Dyndata * dyd
Definition: llex.h:69
static void close_func(LexState *ls)
Definition: lparser.cpp:552
struct LexState * ls
Definition: lparser.h:114
TString * source
Definition: lobject.h:427
Definition: llex.h:31
Definition: llex.h:29
void luaK_prefix(FuncState *fs, UnOpr op, expdesc *e, int line)
Definition: lcode.cpp:1066
static Proto * addprototype(LexState *ls)
Definition: lparser.cpp:499
Definition: llex.h:30
#define isreserved(s)
Definition: lstring.h:27
int n
Definition: lparser.h:89
lu_byte isloop
Definition: lparser.cpp:54
TString * envn
Definition: llex.h:71
void luaX_next(LexState *ls)
Definition: llex.cpp:549
#define luaK_setmultret(fs, e)
Definition: lcode.h:48
static void constructor(LexState *ls, expdesc *t)
Definition: lparser.cpp:724
static void check(LexState *ls, int c)
Definition: lparser.cpp:106
Definition: llex.h:28
Definition: lcode.h:27
static void localfunc(LexState *ls)
Definition: lparser.cpp:1431
int luaK_codek(FuncState *fs, int reg, int k)
Definition: lcode.cpp:346
lu_byte t
Definition: lparser.h:62
Definition: lcode.h:33
Definition: llex.h:36
static void exprstat(LexState *ls)
Definition: lparser.cpp:1488
static int exp1(LexState *ls)
Definition: lparser.cpp:1280
Definition: lcode.h:31
static void whilestat(LexState *ls, int line)
Definition: lparser.cpp:1241
int pc
Definition: lparser.h:80
Definition: llex.h:34
Definition: llex.h:29
Definition: lobject.h:407
lu_byte upval
Definition: lparser.cpp:53
int luaK_intK(FuncState *fs, lua_Integer n)
Definition: lcode.cpp:471
int luaK_jump(FuncState *fs)
Definition: lcode.cpp:136
static void forstat(LexState *ls, int line)
Definition: lparser.cpp:1364
#define LUA_MULTRET
Definition: lua.h:34
Proto * luaF_newproto(lua_State *L)
Definition: lfunc.cpp:99
Definition: lparser.h:32
Definition: lparser.h:26
static void checkrepeated(FuncState *fs, Labellist *ll, TString *label)
Definition: lparser.cpp:1203
lua_Number nval
Definition: lparser.h:58
int pc
Definition: lparser.h:116
#define iswhite(x)
Definition: lgc.h:87
static void mainfunc(LexState *ls, FuncState *fs)
Definition: lparser.cpp:1612
Definition: llex.h:30
int nk
Definition: lparser.h:119
static void skipnoopstat(LexState *ls)
Definition: lparser.cpp:1217
Labellist gt
Definition: lparser.h:101
int n
Definition: lparser.h:98
TString * ts
Definition: llex.h:46
int sizep
Definition: lobject.h:416
struct Dyndata::@8 actvar
#define luaK_codeAsBx(fs, o, A, sBx)
Definition: lcode.h:46
int linenumber
Definition: llex.h:60
int lasttarget
Definition: lparser.h:117
static void primaryexp(LexState *ls, expdesc *v)
Definition: lparser.cpp:871
int line
Definition: lparser.h:81
static void body(LexState *ls, expdesc *e, int ismethod, int line)
Definition: lparser.cpp:782
static void singlevar(LexState *ls, expdesc *var)
Definition: lparser.cpp:295
static void singlevaraux(FuncState *fs, TString *n, expdesc *var, int base)
Definition: lparser.cpp:270
struct LHS_assign * prev
Definition: lparser.cpp:1108
static int searchupvalue(FuncState *fs, TString *name)
Definition: lparser.cpp:218
static void localstat(LexState *ls)
Definition: lparser.cpp:1442
#define new_localvarliteral(ls, v)
Definition: lparser.cpp:191
int token
Definition: llex.h:51
#define cast(t, exp)
Definition: llimits.h:111
static l_noret semerror(LexState *ls, const char *msg)
Definition: lparser.cpp:67
#define cast_byte(i)
Definition: llimits.h:114
Definition: llex.h:31
static void codestring(LexState *ls, expdesc *e, TString *s)
Definition: lparser.cpp:151
#define l_noret
Definition: llimits.h:143
int luaK_codeABx(FuncState *fs, OpCode o, int a, unsigned int bc)
Definition: lcode.cpp:324
static int registerlocalvar(LexState *ls, TString *varname)
Definition: lparser.cpp:161
void luaK_setoneret(FuncState *fs, expdesc *e)
Definition: lcode.cpp:539
Definition: llex.h:33
static void retstat(LexState *ls)
Definition: lparser.cpp:1504
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
Definition: debugger.cpp:109
lu_byte nups
Definition: lparser.h:124
Definition: llex.h:33
int firstlocal
Definition: lparser.h:121
l_noret luaX_syntaxerror(LexState *ls, const char *msg)
Definition: llex.cpp:117
static void listfield(LexState *ls, struct ConsControl *cc)
Definition: lparser.cpp:693
Definition: lcode.h:29
LocVar * locvars
Definition: lobject.h:424
#define check_condition(ls, c, msg)
Definition: lparser.cpp:118
Definition: lcode.h:35
Definition: lparser.h:33
#define SET_OPCODE(i, o)
Definition: lopcodes.h:90
void luaK_self(FuncState *fs, expdesc *e, expdesc *key)
Definition: lcode.cpp:809
expkind
Definition: lparser.h:25
union expdesc::@6 u
static void statlist(LexState *ls)
Definition: lparser.cpp:598
Definition: llex.h:29
expdesc * t
Definition: lparser.cpp:639
expdesc v
Definition: lparser.cpp:638
struct expdesc::@6::@7 ind
static void labelstat(LexState *ls, TString *label, int line)
Definition: lparser.cpp:1223
int sizelocvars
Definition: lobject.h:417
Token t
Definition: llex.h:62
Definition: llex.h:35
TString * luaS_new(lua_State *L, const char *str)
Definition: lstring.cpp:219
Definition: lcode.h:31
OpCode
Definition: lopcodes.h:167
Upvaldesc * upvalues
Definition: lobject.h:425
int info
Definition: lparser.h:59
Definition: lcode.h:33
TString * name
Definition: lparser.h:79
void luaK_goiftrue(FuncState *fs, expdesc *e)
Definition: lcode.cpp:857
int firstlabel
Definition: lparser.cpp:50
#define b
Definition: llex.h:31
Definition: llex.h:30
StkId top
Definition: lstate.h:164
void luaK_nil(FuncState *fs, int from, int n)
Definition: lcode.cpp:64
#define luaM_reallocvector(L, v, oldn, n, t)
Definition: lmem.h:56
Definition: llex.h:33
#define sethvalue(L, obj, x)
Definition: lobject.h:250
void luaK_ret(FuncState *fs, int first, int nret)
Definition: lcode.cpp:149
Definition: lparser.h:36
unsigned char lu_byte
Definition: llimits.h:35
SemInfo seminfo
Definition: llex.h:52
Definition: lparser.h:31
#define getstr(ts)
Definition: lobject.h:328
static void suffixedexp(LexState *ls, expdesc *v)
Definition: lparser.cpp:893
Definition: lparser.h:46
static void adjust_assign(LexState *ls, int nvars, int nexps, expdesc *e)
Definition: lparser.cpp:309
static BinOpr getbinopr(int op)
Definition: lparser.cpp:997
TString * luaX_newstring(LexState *ls, const char *str, size_t l)
Definition: llex.cpp:127
static LocVar * getlocvar(FuncState *fs, int i)
Definition: lparser.cpp:195
void luaK_exp2nextreg(FuncState *fs, expdesc *e)
Definition: lcode.cpp:703
#define MAXUPVAL
Definition: lfunc.h:29
Definition: llex.h:33
static int findlabel(LexState *ls, int g)
Definition: lparser.cpp:365
UnOpr
Definition: lcode.h:40
Definition: llex.h:36
Labeldesc * arr
Definition: lparser.h:88
static void init_exp(expdesc *e, expkind k, int i)
Definition: lparser.cpp:144
int jpc
Definition: lparser.h:118
#define GETARG_A(i)
Definition: lopcodes.h:97
static void movegotosout(FuncState *fs, BlockCnt *bl)
Definition: lparser.cpp:421
void luaX_setinput(lua_State *L, LexState *ls, ZIO *z, TString *source, int firstchar)
Definition: llex.cpp:162
short idx
Definition: lparser.h:73
Definition: lcode.h:30
static void findgotos(LexState *ls, Labeldesc *lb)
Definition: lparser.cpp:403
unsigned short nCcalls
Definition: lstate.h:181
#define MAXVARS
Definition: lparser.cpp:34
Definition: llex.h:29
static void forlist(LexState *ls, TString *indexname)
Definition: lparser.cpp:1339
#define SETARG_C(i, v)
Definition: lopcodes.h:104
int size
Definition: lparser.h:90
Definition: lcode.h:33
static TString * str_checkname(LexState *ls)
Definition: lparser.cpp:135
void luaK_indexed(FuncState *fs, expdesc *t, expdesc *k)
Definition: lcode.cpp:946
#define hasmultret(k)
Definition: lparser.cpp:37
expdesc v
Definition: lparser.cpp:1109
static void field(LexState *ls, struct ConsControl *cc)
Definition: lparser.cpp:702
#define LFIELDS_PER_FLUSH
Definition: lopcodes.h:294
Definition: llex.h:31
static void test_then_block(LexState *ls, int *escapelist)
Definition: lparser.cpp:1382
Definition: llex.h:30
struct FuncState * fs
Definition: llex.h:64
static void closelistfield(FuncState *fs, struct ConsControl *cc)
Definition: lparser.cpp:667
static void enterblock(FuncState *fs, BlockCnt *bl, lu_byte isloop)
Definition: lparser.cpp:439
static void adjustlocalvars(LexState *ls, int nvars)
Definition: lparser.cpp:202
int * lineinfo
Definition: lobject.h:423
int lastlinedefined
Definition: lobject.h:419
Vardesc * arr
Definition: lparser.h:97
TString * varname
Definition: lobject.h:398
Definition: llex.h:33
BinOpr
Definition: lcode.h:26
#define UNARY_PRIORITY
Definition: lparser.cpp:1041
static void check_match(LexState *ls, int what, int who, int where)
Definition: lparser.cpp:122
static void checklimit(FuncState *fs, int v, int l, const char *what)
Definition: lparser.cpp:92
static void parlist(LexState *ls)
Definition: lparser.cpp:753
static void leaveblock(FuncState *fs)
Definition: lparser.cpp:473
void luaK_patchtohere(FuncState *fs, int list)
Definition: lcode.cpp:252
static void new_localvar(LexState *ls, TString *name)
Definition: lparser.cpp:175
Instruction * code
Definition: lobject.h:421
void luaK_reserveregs(FuncState *fs, int n)
Definition: lcode.cpp:375
const char * luaX_token2str(LexState *ls, int token)
Definition: llex.cpp:82
lu_byte right
Definition: lparser.cpp:1027
static l_noret errorlimit(FuncState *fs, int limit, const char *what)
Definition: lparser.cpp:79
void luaK_checkstack(FuncState *fs, int n)
Definition: lcode.cpp:361
struct Proto ** p
Definition: lobject.h:422
static int newupvalue(FuncState *fs, TString *name, expdesc *v)
Definition: lparser.cpp:228
Definition: lcode.h:27
void luaK_exp2anyregup(FuncState *fs, expdesc *e)
Definition: lcode.cpp:734
Labellist label
Definition: lparser.h:102
void luaK_setreturns(FuncState *fs, expdesc *e, int nresults)
Definition: lcode.cpp:515
static void fieldsel(LexState *ls, expdesc *v)
Definition: lparser.cpp:610
Table * luaH_new(lua_State *L)
Definition: ltable.cpp:402
lu_byte nactvar
Definition: lparser.cpp:52
Definition: llex.h:28
lu_byte maxstacksize
Definition: lobject.h:411
void luaK_posfix(FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2, int line)
Definition: lcode.cpp:1124
int luaO_int2fb(unsigned int x)
Definition: lobject.cpp:41
static void closegoto(LexState *ls, int g, Labeldesc *label)
Definition: lparser.cpp:341
Definition: lcode.h:40
int sizelineinfo
Definition: lobject.h:415
#define SETARG_B(i, v)
Definition: lopcodes.h:101
Definition: lcode.h:27
Definition: lcode.h:30
Definition: lcode.h:27
Definition: lparser.h:29
static void funcstat(LexState *ls, int line)
Definition: lparser.cpp:1476
static void block(LexState *ls)
Definition: lparser.cpp:1093
Definition: lzio.h:55
static void removevars(FuncState *fs, int tolevel)
Definition: lparser.cpp:211
static void checknext(LexState *ls, int c)
Definition: lparser.cpp:112
static void open_func(LexState *ls, FuncState *fs, BlockCnt *bl)
Definition: lparser.cpp:529
#define lua_assert(c)
Definition: llimits.h:89
static void simpleexp(LexState *ls, expdesc *v)
Definition: lparser.cpp:931
std::size_t i
Definition: function.cpp:933
Definition: lcode.h:35
static void new_localvarliteral_(LexState *ls, const char *name, size_t sz)
Definition: lparser.cpp:187
Definition: llex.h:31
static void checkname(LexState *ls, expdesc *e)
Definition: lparser.cpp:156
short nlocvars
Definition: lparser.h:122
Definition: llex.h:29
TString * source
Definition: llex.h:70
static void funcargs(LexState *ls, expdesc *f, int line)
Definition: lparser.cpp:817
lu_byte nactvar
Definition: lparser.h:123
lu_byte freereg
Definition: lparser.h:125
Definition: llex.h:29
Definition: lparser.h:28
int luaK_exp2RK(FuncState *fs, expdesc *e)
Definition: lcode.cpp:758
Definition: lcode.h:28
static void expr(LexState *ls, expdesc *v)
Definition: lparser.cpp:1078
static map_location::DIRECTION s
static void gotostat(LexState *ls, int pc)
Definition: lparser.cpp:1187
static void enterlevel(LexState *ls)
Definition: lparser.cpp:331
double g
Definition: astarsearch.cpp:63
lu_byte idx
Definition: lobject.h:389
Definition: llex.h:58
lu_byte instack
Definition: lobject.h:388
lu_byte nactvar
Definition: lparser.h:82
int luaK_getlabel(FuncState *fs)
Definition: lcode.cpp:168
#define setclLvalue(L, obj, x)
Definition: lobject.h:240
int sizek
Definition: lobject.h:413
#define NO_JUMP
Definition: lcode.h:20
static void statement(LexState *ls)
Definition: lparser.cpp:1537
static UnOpr getunopr(int op)
Definition: lparser.cpp:986
#define leavelevel(ls)
Definition: lparser.cpp:338
Definition: lcode.h:27
static void forbody(LexState *ls, int base, int line, int nvars, int isnum)
Definition: lparser.cpp:1291
lu_byte is_vararg
Definition: lobject.h:410
void luaK_goiffalse(FuncState *fs, expdesc *e)
Definition: lcode.cpp:884
static int testnext(LexState *ls, int c)
Definition: lparser.cpp:97
static int funcname(LexState *ls, expdesc *v)
Definition: lparser.cpp:1462
static void markupval(FuncState *fs, int level)
Definition: lparser.cpp:258
int linedefined
Definition: lobject.h:418
#define eqstr(a, b)
Definition: lparser.cpp:42
#define LUAI_MAXCCALLS
Definition: llimits.h:153
#define MAX_INT
Definition: llimits.h:51
const char * luaO_pushfstring(lua_State *L, const char *fmt,...)
Definition: lobject.cpp:467
Definition: lcode.h:40
static void repeatstat(LexState *ls, int line)
Definition: lparser.cpp:1260
#define getinstruction(fs, e)
Definition: lcode.h:44
lua_Number r
Definition: llex.h:44
int sizecode
Definition: lobject.h:414
Definition: llex.h:30
#define luaK_jumpto(fs, t)
Definition: lcode.h:50
Definition: lcode.h:34
int luaX_lookahead(LexState *ls)
Definition: llex.cpp:560
int luaK_exp2anyreg(FuncState *fs, expdesc *e)
Definition: lcode.cpp:715
static void codeclosure(LexState *ls, expdesc *v)
Definition: lparser.cpp:522
Definition: llex.h:30
static l_noret undefgoto(LexState *ls, Labeldesc *gt)
Definition: lparser.cpp:464
The paths manager is responsible for recording the various paths that binary files may be located at...
Definition: fs_commit.cpp:37
void luaK_storevar(FuncState *fs, expdesc *var, expdesc *ex)
Definition: lcode.cpp:782
unsigned long Instruction
Definition: llimits.h:165
LClosure * luaF_newLclosure(lua_State *L, int n)
Definition: lfunc.cpp:33
Definition: lcode.h:34
Definition: llex.h:33
int np
Definition: lparser.h:120
static void breaklabel(LexState *ls)
Definition: lparser.cpp:454
#define f
Definition: lcode.h:30
double t
Definition: astarsearch.cpp:63
Proto * f
Definition: lparser.h:112
int firstgoto
Definition: lparser.cpp:51
lu_byte left
Definition: lparser.cpp:1026
static void assignment(LexState *ls, struct LHS_assign *lh, int nvars)
Definition: lparser.cpp:1147
struct BlockCnt BlockCnt
struct lua_State * L
Definition: llex.h:65
static int cond(LexState *ls)
Definition: lparser.cpp:1177
struct BlockCnt * previous
Definition: lparser.cpp:49
#define cast_int(i)
Definition: llimits.h:116
#define luaC_checkGC(L)
Definition: lgc.h:115
TString * name
Definition: lobject.h:387
Table * h
Definition: llex.h:68
Definition: llex.h:30
void luaK_infix(FuncState *fs, BinOpr op, expdesc *v)
Definition: lcode.cpp:1086
struct Proto * p
Definition: lobject.h:455
Definition: lcode.h:40
static int block_follow(LexState *ls, int withuntil)
Definition: lparser.cpp:587
void luaK_patchlist(FuncState *fs, int list, int target)
Definition: lcode.cpp:263
int startpc
Definition: lobject.h:399
Definition: llex.h:30
int endpc
Definition: lobject.h:400
static l_noret error_expected(LexState *ls, int token)
Definition: lparser.cpp:73
static int newlabelentry(LexState *ls, Labellist *l, TString *name, int line, int pc)
Definition: lparser.cpp:385
Definition: lzio.h:23
int f
Definition: lparser.h:67
void luaK_patchclose(FuncState *fs, int list, int level)
Definition: lcode.cpp:278
#define e
int sizeupvalues
Definition: lobject.h:412
Definition: llex.h:36
#define MAXARG_Bx
Definition: lopcodes.h:63
void luaK_dischargevars(FuncState *fs, expdesc *e)
Definition: lcode.cpp:556
Definition: llex.h:34
static const struct @5 priority[]
int luaK_codeABC(FuncState *fs, OpCode o, int a, int b, int c)
Definition: lcode.cpp:312
lua_Integer ival
Definition: lparser.h:57
lua_Integer i
Definition: llex.h:45
static void recfield(LexState *ls, struct ConsControl *cc)
Definition: lparser.cpp:646
static BinOpr subexpr(LexState *ls, expdesc *v, int limit)
Definition: lparser.cpp:1048
TValue * k
Definition: lobject.h:420
#define luaC_objbarrier(L, p, o)
Definition: lgc.h:126
void luaD_inctop(lua_State *L)
Definition: ldo.cpp:240
Definition: llex.h:33
void luaK_fixline(FuncState *fs, int line)
Definition: lcode.cpp:1177
mock_char c
#define luaM_growvector(L, v, nelems, size, t, limit, e)
Definition: lmem.h:52
static void check_conflict(LexState *ls, struct LHS_assign *lh, expdesc *v)
Definition: lparser.cpp:1119
static map_location::DIRECTION n
int size
Definition: lparser.h:99
void luaK_concat(FuncState *fs, int *l1, int l2)
Definition: lcode.cpp:116
LClosure * luaY_parser(lua_State *L, ZIO *z, Mbuffer *buff, Dyndata *dyd, const char *name, int firstchar)
Definition: lparser.cpp:1626
static void yindex(LexState *ls, expdesc *v)
Definition: lparser.cpp:621
Mbuffer * buff
Definition: llex.h:67
void luaK_exp2val(FuncState *fs, expdesc *e)
Definition: lcode.cpp:744
static int searchvar(FuncState *fs, TString *n)
Definition: lparser.cpp:244
static void ifstat(LexState *ls, int line)
Definition: lparser.cpp:1417
struct BlockCnt * bl
Definition: lparser.h:115
Definition: lparser.h:37
static int explist(LexState *ls, expdesc *v)
Definition: lparser.cpp:804
#define vkisvar(k)
Definition: lparser.h:51
Definition: lparser.h:30
struct FuncState * prev
Definition: lparser.h:113
lu_byte numparams
Definition: lobject.h:409
int luaK_stringK(FuncState *fs, TString *s)
Definition: lcode.cpp:458
static void lastlistfield(FuncState *fs, struct ConsControl *cc)
Definition: lparser.cpp:678
Definition: llex.h:36
void luaK_setlist(FuncState *fs, int base, int nelems, int tostore)
Definition: lcode.cpp:1189
expkind k
Definition: lparser.h:55
static void fornum(LexState *ls, TString *varname, int line)
Definition: lparser.cpp:1317