w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

lparser.c
Go to the documentation of this file.
1 /*
2 ** $Id: lparser.c,v 2.155.1.2 2017/04/29 18:11:40 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 */
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 
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 
439 static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) {
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 */
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  luaC_objbarrier(ls->L, f, f->source);
548  f->maxstacksize = 2; /* registers 0/1 are always valid */
549  enterblock(fs, bl, 0);
550 }
551 
552 
553 static void close_func (LexState *ls) {
554  lua_State *L = ls->L;
555  FuncState *fs = ls->fs;
556  Proto *f = fs->f;
557  luaK_ret(fs, 0, 0); /* final return */
558  leaveblock(fs);
559  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
560  f->sizecode = fs->pc;
561  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
562  f->sizelineinfo = fs->pc;
563  luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
564  f->sizek = fs->nk;
565  luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
566  f->sizep = fs->np;
567  luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
568  f->sizelocvars = fs->nlocvars;
569  luaM_reallocvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc);
570  f->sizeupvalues = fs->nups;
571  lua_assert(fs->bl == NULL);
572  ls->fs = fs->prev;
573  luaC_checkGC(L);
574 }
575 
576 
577 
578 /*============================================================*/
579 /* GRAMMAR RULES */
580 /*============================================================*/
581 
582 
583 /*
584 ** check whether current token is in the follow set of a block.
585 ** 'until' closes syntactical blocks, but do not close scope,
586 ** so it is handled in separate.
587 */
588 static int block_follow (LexState *ls, int withuntil) {
589  switch (ls->t.token) {
590  case TK_ELSE: case TK_ELSEIF:
591  case TK_END: case TK_EOS:
592  return 1;
593  case TK_UNTIL: return withuntil;
594  default: return 0;
595  }
596 }
597 
598 
599 static void statlist (LexState *ls) {
600  /* statlist -> { stat [';'] } */
601  while (!block_follow(ls, 1)) {
602  if (ls->t.token == TK_RETURN) {
603  statement(ls);
604  return; /* 'return' must be last statement */
605  }
606  statement(ls);
607  }
608 }
609 
610 
611 static void fieldsel (LexState *ls, expdesc *v) {
612  /* fieldsel -> ['.' | ':'] NAME */
613  FuncState *fs = ls->fs;
614  expdesc key;
615  luaK_exp2anyregup(fs, v);
616  luaX_next(ls); /* skip the dot or colon */
617  checkname(ls, &key);
618  luaK_indexed(fs, v, &key);
619 }
620 
621 
622 static void yindex (LexState *ls, expdesc *v) {
623  /* index -> '[' expr ']' */
624  luaX_next(ls); /* skip the '[' */
625  expr(ls, v);
626  luaK_exp2val(ls->fs, v);
627  checknext(ls, ']');
628 }
629 
630 
631 /*
632 ** {======================================================================
633 ** Rules for Constructors
634 ** =======================================================================
635 */
636 
637 
638 struct ConsControl {
639  expdesc v; /* last list item read */
640  expdesc *t; /* table descriptor */
641  int nh; /* total number of 'record' elements */
642  int na; /* total number of array elements */
643  int tostore; /* number of array elements pending to be stored */
644 };
645 
646 
647 static void recfield (LexState *ls, struct ConsControl *cc) {
648  /* recfield -> (NAME | '['exp1']') = exp1 */
649  FuncState *fs = ls->fs;
650  int reg = ls->fs->freereg;
651  expdesc key, val;
652  int rkkey;
653  if (ls->t.token == TK_NAME) {
654  checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
655  checkname(ls, &key);
656  }
657  else /* ls->t.token == '[' */
658  yindex(ls, &key);
659  cc->nh++;
660  checknext(ls, '=');
661  rkkey = luaK_exp2RK(fs, &key);
662  expr(ls, &val);
663  luaK_codeABC(fs, OP_SETTABLE, cc->t->u.info, rkkey, luaK_exp2RK(fs, &val));
664  fs->freereg = reg; /* free registers */
665 }
666 
667 
668 static void closelistfield (FuncState *fs, struct ConsControl *cc) {
669  if (cc->v.k == VVOID) return; /* there is no list item */
670  luaK_exp2nextreg(fs, &cc->v);
671  cc->v.k = VVOID;
672  if (cc->tostore == LFIELDS_PER_FLUSH) {
673  luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); /* flush */
674  cc->tostore = 0; /* no more items pending */
675  }
676 }
677 
678 
679 static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
680  if (cc->tostore == 0) return;
681  if (hasmultret(cc->v.k)) {
682  luaK_setmultret(fs, &cc->v);
683  luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET);
684  cc->na--; /* do not count last expression (unknown number of elements) */
685  }
686  else {
687  if (cc->v.k != VVOID)
688  luaK_exp2nextreg(fs, &cc->v);
689  luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore);
690  }
691 }
692 
693 
694 static void listfield (LexState *ls, struct ConsControl *cc) {
695  /* listfield -> exp */
696  expr(ls, &cc->v);
697  checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
698  cc->na++;
699  cc->tostore++;
700 }
701 
702 
703 static void field (LexState *ls, struct ConsControl *cc) {
704  /* field -> listfield | recfield */
705  switch(ls->t.token) {
706  case TK_NAME: { /* may be 'listfield' or 'recfield' */
707  if (luaX_lookahead(ls) != '=') /* expression? */
708  listfield(ls, cc);
709  else
710  recfield(ls, cc);
711  break;
712  }
713  case '[': {
714  recfield(ls, cc);
715  break;
716  }
717  default: {
718  listfield(ls, cc);
719  break;
720  }
721  }
722 }
723 
724 
725 static void constructor (LexState *ls, expdesc *t) {
726  /* constructor -> '{' [ field { sep field } [sep] ] '}'
727  sep -> ',' | ';' */
728  FuncState *fs = ls->fs;
729  int line = ls->linenumber;
730  int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
731  struct ConsControl cc;
732  cc.na = cc.nh = cc.tostore = 0;
733  cc.t = t;
734  init_exp(t, VRELOCABLE, pc);
735  init_exp(&cc.v, VVOID, 0); /* no value (yet) */
736  luaK_exp2nextreg(ls->fs, t); /* fix it at stack top */
737  checknext(ls, '{');
738  do {
739  lua_assert(cc.v.k == VVOID || cc.tostore > 0);
740  if (ls->t.token == '}') break;
741  closelistfield(fs, &cc);
742  field(ls, &cc);
743  } while (testnext(ls, ',') || testnext(ls, ';'));
744  check_match(ls, '}', '{', line);
745  lastlistfield(fs, &cc);
746  SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */
747  SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh)); /* set initial table size */
748 }
749 
750 /* }====================================================================== */
751 
752 
753 
754 static void parlist (LexState *ls) {
755  /* parlist -> [ param { ',' param } ] */
756  FuncState *fs = ls->fs;
757  Proto *f = fs->f;
758  int nparams = 0;
759  f->is_vararg = 0;
760  if (ls->t.token != ')') { /* is 'parlist' not empty? */
761  do {
762  switch (ls->t.token) {
763  case TK_NAME: { /* param -> NAME */
764  new_localvar(ls, str_checkname(ls));
765  nparams++;
766  break;
767  }
768  case TK_DOTS: { /* param -> '...' */
769  luaX_next(ls);
770  f->is_vararg = 1; /* declared vararg */
771  break;
772  }
773  default: luaX_syntaxerror(ls, "<name> or '...' expected");
774  }
775  } while (!f->is_vararg && testnext(ls, ','));
776  }
777  adjustlocalvars(ls, nparams);
778  f->numparams = cast_byte(fs->nactvar);
779  luaK_reserveregs(fs, fs->nactvar); /* reserve register for parameters */
780 }
781 
782 
783 static void body (LexState *ls, expdesc *e, int ismethod, int line) {
784  /* body -> '(' parlist ')' block END */
785  FuncState new_fs;
786  BlockCnt bl;
787  new_fs.f = addprototype(ls);
788  new_fs.f->linedefined = line;
789  open_func(ls, &new_fs, &bl);
790  checknext(ls, '(');
791  if (ismethod) {
792  new_localvarliteral(ls, "self"); /* create 'self' parameter */
793  adjustlocalvars(ls, 1);
794  }
795  parlist(ls);
796  checknext(ls, ')');
797  statlist(ls);
798  new_fs.f->lastlinedefined = ls->linenumber;
800  codeclosure(ls, e);
801  close_func(ls);
802 }
803 
804 
805 static int explist (LexState *ls, expdesc *v) {
806  /* explist -> expr { ',' expr } */
807  int n = 1; /* at least one expression */
808  expr(ls, v);
809  while (testnext(ls, ',')) {
810  luaK_exp2nextreg(ls->fs, v);
811  expr(ls, v);
812  n++;
813  }
814  return n;
815 }
816 
817 
818 static void funcargs (LexState *ls, expdesc *f, int line) {
819  FuncState *fs = ls->fs;
820  expdesc args;
821  int base, nparams;
822  switch (ls->t.token) {
823  case '(': { /* funcargs -> '(' [ explist ] ')' */
824  luaX_next(ls);
825  if (ls->t.token == ')') /* arg list is empty? */
826  args.k = VVOID;
827  else {
828  explist(ls, &args);
829  luaK_setmultret(fs, &args);
830  }
831  check_match(ls, ')', '(', line);
832  break;
833  }
834  case '{': { /* funcargs -> constructor */
835  constructor(ls, &args);
836  break;
837  }
838  case TK_STRING: { /* funcargs -> STRING */
839  codestring(ls, &args, ls->t.seminfo.ts);
840  luaX_next(ls); /* must use 'seminfo' before 'next' */
841  break;
842  }
843  default: {
844  luaX_syntaxerror(ls, "function arguments expected");
845  }
846  }
847  lua_assert(f->k == VNONRELOC);
848  base = f->u.info; /* base register for call */
849  if (hasmultret(args.k))
850  nparams = LUA_MULTRET; /* open call */
851  else {
852  if (args.k != VVOID)
853  luaK_exp2nextreg(fs, &args); /* close last argument */
854  nparams = fs->freereg - (base+1);
855  }
856  init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
857  luaK_fixline(fs, line);
858  fs->freereg = base+1; /* call remove function and arguments and leaves
859  (unless changed) one result */
860 }
861 
862 
863 
864 
865 /*
866 ** {======================================================================
867 ** Expression parsing
868 ** =======================================================================
869 */
870 
871 
872 static void primaryexp (LexState *ls, expdesc *v) {
873  /* primaryexp -> NAME | '(' expr ')' */
874  switch (ls->t.token) {
875  case '(': {
876  int line = ls->linenumber;
877  luaX_next(ls);
878  expr(ls, v);
879  check_match(ls, ')', '(', line);
880  luaK_dischargevars(ls->fs, v);
881  return;
882  }
883  case TK_NAME: {
884  singlevar(ls, v);
885  return;
886  }
887  default: {
888  luaX_syntaxerror(ls, "unexpected symbol");
889  }
890  }
891 }
892 
893 
894 static void suffixedexp (LexState *ls, expdesc *v) {
895  /* suffixedexp ->
896  primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */
897  FuncState *fs = ls->fs;
898  int line = ls->linenumber;
899  primaryexp(ls, v);
900  for (;;) {
901  switch (ls->t.token) {
902  case '.': { /* fieldsel */
903  fieldsel(ls, v);
904  break;
905  }
906  case '[': { /* '[' exp1 ']' */
907  expdesc key;
908  luaK_exp2anyregup(fs, v);
909  yindex(ls, &key);
910  luaK_indexed(fs, v, &key);
911  break;
912  }
913  case ':': { /* ':' NAME funcargs */
914  expdesc key;
915  luaX_next(ls);
916  checkname(ls, &key);
917  luaK_self(fs, v, &key);
918  funcargs(ls, v, line);
919  break;
920  }
921  case '(': case TK_STRING: case '{': { /* funcargs */
922  luaK_exp2nextreg(fs, v);
923  funcargs(ls, v, line);
924  break;
925  }
926  default: return;
927  }
928  }
929 }
930 
931 
932 static void simpleexp (LexState *ls, expdesc *v) {
933  /* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... |
934  constructor | FUNCTION body | suffixedexp */
935  switch (ls->t.token) {
936  case TK_FLT: {
937  init_exp(v, VKFLT, 0);
938  v->u.nval = ls->t.seminfo.r;
939  break;
940  }
941  case TK_INT: {
942  init_exp(v, VKINT, 0);
943  v->u.ival = ls->t.seminfo.i;
944  break;
945  }
946  case TK_STRING: {
947  codestring(ls, v, ls->t.seminfo.ts);
948  break;
949  }
950  case TK_NIL: {
951  init_exp(v, VNIL, 0);
952  break;
953  }
954  case TK_TRUE: {
955  init_exp(v, VTRUE, 0);
956  break;
957  }
958  case TK_FALSE: {
959  init_exp(v, VFALSE, 0);
960  break;
961  }
962  case TK_DOTS: { /* vararg */
963  FuncState *fs = ls->fs;
964  check_condition(ls, fs->f->is_vararg,
965  "cannot use '...' outside a vararg function");
966  init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
967  break;
968  }
969  case '{': { /* constructor */
970  constructor(ls, v);
971  return;
972  }
973  case TK_FUNCTION: {
974  luaX_next(ls);
975  body(ls, v, 0, ls->linenumber);
976  return;
977  }
978  default: {
979  suffixedexp(ls, v);
980  return;
981  }
982  }
983  luaX_next(ls);
984 }
985 
986 
987 static UnOpr getunopr (int op) {
988  switch (op) {
989  case TK_NOT: return OPR_NOT;
990  case '-': return OPR_MINUS;
991  case '~': return OPR_BNOT;
992  case '#': return OPR_LEN;
993  default: return OPR_NOUNOPR;
994  }
995 }
996 
997 
998 static BinOpr getbinopr (int op) {
999  switch (op) {
1000  case '+': return OPR_ADD;
1001  case '-': return OPR_SUB;
1002  case '*': return OPR_MUL;
1003  case '%': return OPR_MOD;
1004  case '^': return OPR_POW;
1005  case '/': return OPR_DIV;
1006  case TK_IDIV: return OPR_IDIV;
1007  case '&': return OPR_BAND;
1008  case '|': return OPR_BOR;
1009  case '~': return OPR_BXOR;
1010  case TK_SHL: return OPR_SHL;
1011  case TK_SHR: return OPR_SHR;
1012  case TK_CONCAT: return OPR_CONCAT;
1013  case TK_NE: return OPR_NE;
1014  case TK_EQ: return OPR_EQ;
1015  case '<': return OPR_LT;
1016  case TK_LE: return OPR_LE;
1017  case '>': return OPR_GT;
1018  case TK_GE: return OPR_GE;
1019  case TK_AND: return OPR_AND;
1020  case TK_OR: return OPR_OR;
1021  default: return OPR_NOBINOPR;
1022  }
1023 }
1024 
1025 
1026 static const struct {
1027  lu_byte left; /* left priority for each binary operator */
1028  lu_byte right; /* right priority */
1029 } priority[] = { /* ORDER OPR */
1030  {10, 10}, {10, 10}, /* '+' '-' */
1031  {11, 11}, {11, 11}, /* '*' '%' */
1032  {14, 13}, /* '^' (right associative) */
1033  {11, 11}, {11, 11}, /* '/' '//' */
1034  {6, 6}, {4, 4}, {5, 5}, /* '&' '|' '~' */
1035  {7, 7}, {7, 7}, /* '<<' '>>' */
1036  {9, 8}, /* '..' (right associative) */
1037  {3, 3}, {3, 3}, {3, 3}, /* ==, <, <= */
1038  {3, 3}, {3, 3}, {3, 3}, /* ~=, >, >= */
1039  {2, 2}, {1, 1} /* and, or */
1040 };
1041 
1042 #define UNARY_PRIORITY 12 /* priority for unary operators */
1043 
1044 
1045 /*
1046 ** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
1047 ** where 'binop' is any binary operator with a priority higher than 'limit'
1048 */
1049 static BinOpr subexpr (LexState *ls, expdesc *v, int limit) {
1050  BinOpr op;
1051  UnOpr uop;
1052  enterlevel(ls);
1053  uop = getunopr(ls->t.token);
1054  if (uop != OPR_NOUNOPR) {
1055  int line = ls->linenumber;
1056  luaX_next(ls);
1057  subexpr(ls, v, UNARY_PRIORITY);
1058  luaK_prefix(ls->fs, uop, v, line);
1059  }
1060  else simpleexp(ls, v);
1061  /* expand while operators have priorities higher than 'limit' */
1062  op = getbinopr(ls->t.token);
1063  while (op != OPR_NOBINOPR && priority[op].left > limit) {
1064  expdesc v2;
1065  BinOpr nextop;
1066  int line = ls->linenumber;
1067  luaX_next(ls);
1068  luaK_infix(ls->fs, op, v);
1069  /* read sub-expression with higher priority */
1070  nextop = subexpr(ls, &v2, priority[op].right);
1071  luaK_posfix(ls->fs, op, v, &v2, line);
1072  op = nextop;
1073  }
1074  leavelevel(ls);
1075  return op; /* return first untreated operator */
1076 }
1077 
1078 
1079 static void expr (LexState *ls, expdesc *v) {
1080  subexpr(ls, v, 0);
1081 }
1082 
1083 /* }==================================================================== */
1084 
1085 
1086 
1087 /*
1088 ** {======================================================================
1089 ** Rules for Statements
1090 ** =======================================================================
1091 */
1092 
1093 
1094 static void block (LexState *ls) {
1095  /* block -> statlist */
1096  FuncState *fs = ls->fs;
1097  BlockCnt bl;
1098  enterblock(fs, &bl, 0);
1099  statlist(ls);
1100  leaveblock(fs);
1101 }
1102 
1103 
1104 /*
1105 ** structure to chain all variables in the left-hand side of an
1106 ** assignment
1107 */
1108 struct LHS_assign {
1109  struct LHS_assign *prev;
1110  expdesc v; /* variable (global, local, upvalue, or indexed) */
1111 };
1112 
1113 
1114 /*
1115 ** check whether, in an assignment to an upvalue/local variable, the
1116 ** upvalue/local variable is begin used in a previous assignment to a
1117 ** table. If so, save original upvalue/local value in a safe place and
1118 ** use this safe copy in the previous assignment.
1119 */
1120 static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
1121  FuncState *fs = ls->fs;
1122  int extra = fs->freereg; /* eventual position to save local variable */
1123  int conflict = 0;
1124  for (; lh; lh = lh->prev) { /* check all previous assignments */
1125  if (lh->v.k == VINDEXED) { /* assigning to a table? */
1126  /* table is the upvalue/local being assigned now? */
1127  if (lh->v.u.ind.vt == v->k && lh->v.u.ind.t == v->u.info) {
1128  conflict = 1;
1129  lh->v.u.ind.vt = VLOCAL;
1130  lh->v.u.ind.t = extra; /* previous assignment will use safe copy */
1131  }
1132  /* index is the local being assigned? (index cannot be upvalue) */
1133  if (v->k == VLOCAL && lh->v.u.ind.idx == v->u.info) {
1134  conflict = 1;
1135  lh->v.u.ind.idx = extra; /* previous assignment will use safe copy */
1136  }
1137  }
1138  }
1139  if (conflict) {
1140  /* copy upvalue/local value to a temporary (in position 'extra') */
1141  OpCode op = (v->k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
1142  luaK_codeABC(fs, op, extra, v->u.info, 0);
1143  luaK_reserveregs(fs, 1);
1144  }
1145 }
1146 
1147 
1148 static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
1149  expdesc e;
1150  check_condition(ls, vkisvar(lh->v.k), "syntax error");
1151  if (testnext(ls, ',')) { /* assignment -> ',' suffixedexp assignment */
1152  struct LHS_assign nv;
1153  nv.prev = lh;
1154  suffixedexp(ls, &nv.v);
1155  if (nv.v.k != VINDEXED)
1156  check_conflict(ls, lh, &nv.v);
1157  checklimit(ls->fs, nvars + ls->L->nCcalls, LUAI_MAXCCALLS,
1158  "C levels");
1159  assignment(ls, &nv, nvars+1);
1160  }
1161  else { /* assignment -> '=' explist */
1162  int nexps;
1163  checknext(ls, '=');
1164  nexps = explist(ls, &e);
1165  if (nexps != nvars)
1166  adjust_assign(ls, nvars, nexps, &e);
1167  else {
1168  luaK_setoneret(ls->fs, &e); /* close last expression */
1169  luaK_storevar(ls->fs, &lh->v, &e);
1170  return; /* avoid default */
1171  }
1172  }
1173  init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */
1174  luaK_storevar(ls->fs, &lh->v, &e);
1175 }
1176 
1177 
1178 static int cond (LexState *ls) {
1179  /* cond -> exp */
1180  expdesc v;
1181  expr(ls, &v); /* read condition */
1182  if (v.k == VNIL) v.k = VFALSE; /* 'falses' are all equal here */
1183  luaK_goiftrue(ls->fs, &v);
1184  return v.f;
1185 }
1186 
1187 
1188 static void gotostat (LexState *ls, int pc) {
1189  int line = ls->linenumber;
1190  TString *label;
1191  int g;
1192  if (testnext(ls, TK_GOTO))
1193  label = str_checkname(ls);
1194  else {
1195  luaX_next(ls); /* skip break */
1196  label = luaS_new(ls->L, "break");
1197  }
1198  g = newlabelentry(ls, &ls->dyd->gt, label, line, pc);
1199  findlabel(ls, g); /* close it if label already defined */
1200 }
1201 
1202 
1203 /* check for repeated labels on the same block */
1204 static void checkrepeated (FuncState *fs, Labellist *ll, TString *label) {
1205  int i;
1206  for (i = fs->bl->firstlabel; i < ll->n; i++) {
1207  if (eqstr(label, ll->arr[i].name)) {
1208  const char *msg = luaO_pushfstring(fs->ls->L,
1209  "label '%s' already defined on line %d",
1210  getstr(label), ll->arr[i].line);
1211  semerror(fs->ls, msg);
1212  }
1213  }
1214 }
1215 
1216 
1217 /* skip no-op statements */
1218 static void skipnoopstat (LexState *ls) {
1219  while (ls->t.token == ';' || ls->t.token == TK_DBCOLON)
1220  statement(ls);
1221 }
1222 
1223 
1224 static void labelstat (LexState *ls, TString *label, int line) {
1225  /* label -> '::' NAME '::' */
1226  FuncState *fs = ls->fs;
1227  Labellist *ll = &ls->dyd->label;
1228  int l; /* index of new label being created */
1229  checkrepeated(fs, ll, label); /* check for repeated labels */
1230  checknext(ls, TK_DBCOLON); /* skip double colon */
1231  /* create new entry for this label */
1232  l = newlabelentry(ls, ll, label, line, luaK_getlabel(fs));
1233  skipnoopstat(ls); /* skip other no-op statements */
1234  if (block_follow(ls, 0)) { /* label is last no-op statement in the block? */
1235  /* assume that locals are already out of scope */
1236  ll->arr[l].nactvar = fs->bl->nactvar;
1237  }
1238  findgotos(ls, &ll->arr[l]);
1239 }
1240 
1241 
1242 static void whilestat (LexState *ls, int line) {
1243  /* whilestat -> WHILE cond DO block END */
1244  FuncState *fs = ls->fs;
1245  int whileinit;
1246  int condexit;
1247  BlockCnt bl;
1248  luaX_next(ls); /* skip WHILE */
1249  whileinit = luaK_getlabel(fs);
1250  condexit = cond(ls);
1251  enterblock(fs, &bl, 1);
1252  checknext(ls, TK_DO);
1253  block(ls);
1254  luaK_jumpto(fs, whileinit);
1256  leaveblock(fs);
1257  luaK_patchtohere(fs, condexit); /* false conditions finish the loop */
1258 }
1259 
1260 
1261 static void repeatstat (LexState *ls, int line) {
1262  /* repeatstat -> REPEAT block UNTIL cond */
1263  int condexit;
1264  FuncState *fs = ls->fs;
1265  int repeat_init = luaK_getlabel(fs);
1266  BlockCnt bl1, bl2;
1267  enterblock(fs, &bl1, 1); /* loop block */
1268  enterblock(fs, &bl2, 0); /* scope block */
1269  luaX_next(ls); /* skip REPEAT */
1270  statlist(ls);
1272  condexit = cond(ls); /* read condition (inside scope block) */
1273  if (bl2.upval) /* upvalues? */
1274  luaK_patchclose(fs, condexit, bl2.nactvar);
1275  leaveblock(fs); /* finish scope */
1276  luaK_patchlist(fs, condexit, repeat_init); /* close the loop */
1277  leaveblock(fs); /* finish loop */
1278 }
1279 
1280 
1281 static int exp1 (LexState *ls) {
1282  expdesc e;
1283  int reg;
1284  expr(ls, &e);
1285  luaK_exp2nextreg(ls->fs, &e);
1286  lua_assert(e.k == VNONRELOC);
1287  reg = e.u.info;
1288  return reg;
1289 }
1290 
1291 
1292 static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
1293  /* forbody -> DO block */
1294  BlockCnt bl;
1295  FuncState *fs = ls->fs;
1296  int prep, endfor;
1297  adjustlocalvars(ls, 3); /* control variables */
1298  checknext(ls, TK_DO);
1299  prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
1300  enterblock(fs, &bl, 0); /* scope for declared variables */
1301  adjustlocalvars(ls, nvars);
1302  luaK_reserveregs(fs, nvars);
1303  block(ls);
1304  leaveblock(fs); /* end of scope for declared variables */
1305  luaK_patchtohere(fs, prep);
1306  if (isnum) /* numeric for? */
1307  endfor = luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP);
1308  else { /* generic for */
1309  luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars);
1310  luaK_fixline(fs, line);
1311  endfor = luaK_codeAsBx(fs, OP_TFORLOOP, base + 2, NO_JUMP);
1312  }
1313  luaK_patchlist(fs, endfor, prep + 1);
1314  luaK_fixline(fs, line);
1315 }
1316 
1317 
1318 static void fornum (LexState *ls, TString *varname, int line) {
1319  /* fornum -> NAME = exp1,exp1[,exp1] forbody */
1320  FuncState *fs = ls->fs;
1321  int base = fs->freereg;
1322  new_localvarliteral(ls, "(for index)");
1323  new_localvarliteral(ls, "(for limit)");
1324  new_localvarliteral(ls, "(for step)");
1325  new_localvar(ls, varname);
1326  checknext(ls, '=');
1327  exp1(ls); /* initial value */
1328  checknext(ls, ',');
1329  exp1(ls); /* limit */
1330  if (testnext(ls, ','))
1331  exp1(ls); /* optional step */
1332  else { /* default step = 1 */
1333  luaK_codek(fs, fs->freereg, luaK_intK(fs, 1));
1334  luaK_reserveregs(fs, 1);
1335  }
1336  forbody(ls, base, line, 1, 1);
1337 }
1338 
1339 
1340 static void forlist (LexState *ls, TString *indexname) {
1341  /* forlist -> NAME {,NAME} IN explist forbody */
1342  FuncState *fs = ls->fs;
1343  expdesc e;
1344  int nvars = 4; /* gen, state, control, plus at least one declared var */
1345  int line;
1346  int base = fs->freereg;
1347  /* create control variables */
1348  new_localvarliteral(ls, "(for generator)");
1349  new_localvarliteral(ls, "(for state)");
1350  new_localvarliteral(ls, "(for control)");
1351  /* create declared variables */
1352  new_localvar(ls, indexname);
1353  while (testnext(ls, ',')) {
1354  new_localvar(ls, str_checkname(ls));
1355  nvars++;
1356  }
1357  checknext(ls, TK_IN);
1358  line = ls->linenumber;
1359  adjust_assign(ls, 3, explist(ls, &e), &e);
1360  luaK_checkstack(fs, 3); /* extra space to call generator */
1361  forbody(ls, base, line, nvars - 3, 0);
1362 }
1363 
1364 
1365 static void forstat (LexState *ls, int line) {
1366  /* forstat -> FOR (fornum | forlist) END */
1367  FuncState *fs = ls->fs;
1368  TString *varname;
1369  BlockCnt bl;
1370  enterblock(fs, &bl, 1); /* scope for loop and control variables */
1371  luaX_next(ls); /* skip 'for' */
1372  varname = str_checkname(ls); /* first variable name */
1373  switch (ls->t.token) {
1374  case '=': fornum(ls, varname, line); break;
1375  case ',': case TK_IN: forlist(ls, varname); break;
1376  default: luaX_syntaxerror(ls, "'=' or 'in' expected");
1377  }
1378  check_match(ls, TK_END, TK_FOR, line);
1379  leaveblock(fs); /* loop scope ('break' jumps to this point) */
1380 }
1381 
1382 
1383 static void test_then_block (LexState *ls, int *escapelist) {
1384  /* test_then_block -> [IF | ELSEIF] cond THEN block */
1385  BlockCnt bl;
1386  FuncState *fs = ls->fs;
1387  expdesc v;
1388  int jf; /* instruction to skip 'then' code (if condition is false) */
1389  luaX_next(ls); /* skip IF or ELSEIF */
1390  expr(ls, &v); /* read condition */
1391  checknext(ls, TK_THEN);
1392  if (ls->t.token == TK_GOTO || ls->t.token == TK_BREAK) {
1393  luaK_goiffalse(ls->fs, &v); /* will jump to label if condition is true */
1394  enterblock(fs, &bl, 0); /* must enter block before 'goto' */
1395  gotostat(ls, v.t); /* handle goto/break */
1396  while (testnext(ls, ';')) {} /* skip colons */
1397  if (block_follow(ls, 0)) { /* 'goto' is the entire block? */
1398  leaveblock(fs);
1399  return; /* and that is it */
1400  }
1401  else /* must skip over 'then' part if condition is false */
1402  jf = luaK_jump(fs);
1403  }
1404  else { /* regular case (not goto/break) */
1405  luaK_goiftrue(ls->fs, &v); /* skip over block if condition is false */
1406  enterblock(fs, &bl, 0);
1407  jf = v.f;
1408  }
1409  statlist(ls); /* 'then' part */
1410  leaveblock(fs);
1411  if (ls->t.token == TK_ELSE ||
1412  ls->t.token == TK_ELSEIF) /* followed by 'else'/'elseif'? */
1413  luaK_concat(fs, escapelist, luaK_jump(fs)); /* must jump over it */
1414  luaK_patchtohere(fs, jf);
1415 }
1416 
1417 
1418 static void ifstat (LexState *ls, int line) {
1419  /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
1420  FuncState *fs = ls->fs;
1421  int escapelist = NO_JUMP; /* exit list for finished parts */
1422  test_then_block(ls, &escapelist); /* IF cond THEN block */
1423  while (ls->t.token == TK_ELSEIF)
1424  test_then_block(ls, &escapelist); /* ELSEIF cond THEN block */
1425  if (testnext(ls, TK_ELSE))
1426  block(ls); /* 'else' part */
1427  check_match(ls, TK_END, TK_IF, line);
1428  luaK_patchtohere(fs, escapelist); /* patch escape list to 'if' end */
1429 }
1430 
1431 
1432 static void localfunc (LexState *ls) {
1433  expdesc b;
1434  FuncState *fs = ls->fs;
1435  new_localvar(ls, str_checkname(ls)); /* new local variable */
1436  adjustlocalvars(ls, 1); /* enter its scope */
1437  body(ls, &b, 0, ls->linenumber); /* function created in next register */
1438  /* debug information will only see the variable after this point! */
1439  getlocvar(fs, b.u.info)->startpc = fs->pc;
1440 }
1441 
1442 
1443 static void localstat (LexState *ls) {
1444  /* stat -> LOCAL NAME {',' NAME} ['=' explist] */
1445  int nvars = 0;
1446  int nexps;
1447  expdesc e;
1448  do {
1449  new_localvar(ls, str_checkname(ls));
1450  nvars++;
1451  } while (testnext(ls, ','));
1452  if (testnext(ls, '='))
1453  nexps = explist(ls, &e);
1454  else {
1455  e.k = VVOID;
1456  nexps = 0;
1457  }
1458  adjust_assign(ls, nvars, nexps, &e);
1459  adjustlocalvars(ls, nvars);
1460 }
1461 
1462 
1463 static int funcname (LexState *ls, expdesc *v) {
1464  /* funcname -> NAME {fieldsel} [':' NAME] */
1465  int ismethod = 0;
1466  singlevar(ls, v);
1467  while (ls->t.token == '.')
1468  fieldsel(ls, v);
1469  if (ls->t.token == ':') {
1470  ismethod = 1;
1471  fieldsel(ls, v);
1472  }
1473  return ismethod;
1474 }
1475 
1476 
1477 static void funcstat (LexState *ls, int line) {
1478  /* funcstat -> FUNCTION funcname body */
1479  int ismethod;
1480  expdesc v, b;
1481  luaX_next(ls); /* skip FUNCTION */
1482  ismethod = funcname(ls, &v);
1483  body(ls, &b, ismethod, line);
1484  luaK_storevar(ls->fs, &v, &b);
1485  luaK_fixline(ls->fs, line); /* definition "happens" in the first line */
1486 }
1487 
1488 
1489 static void exprstat (LexState *ls) {
1490  /* stat -> func | assignment */
1491  FuncState *fs = ls->fs;
1492  struct LHS_assign v;
1493  suffixedexp(ls, &v.v);
1494  if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */
1495  v.prev = NULL;
1496  assignment(ls, &v, 1);
1497  }
1498  else { /* stat -> func */
1499  check_condition(ls, v.v.k == VCALL, "syntax error");
1500  SETARG_C(getinstruction(fs, &v.v), 1); /* call statement uses no results */
1501  }
1502 }
1503 
1504 
1505 static void retstat (LexState *ls) {
1506  /* stat -> RETURN [explist] [';'] */
1507  FuncState *fs = ls->fs;
1508  expdesc e;
1509  int first, nret; /* registers with returned values */
1510  if (block_follow(ls, 1) || ls->t.token == ';')
1511  first = nret = 0; /* return no values */
1512  else {
1513  nret = explist(ls, &e); /* optional return values */
1514  if (hasmultret(e.k)) {
1515  luaK_setmultret(fs, &e);
1516  if (e.k == VCALL && nret == 1) { /* tail call? */
1518  lua_assert(GETARG_A(getinstruction(fs,&e)) == fs->nactvar);
1519  }
1520  first = fs->nactvar;
1521  nret = LUA_MULTRET; /* return all values */
1522  }
1523  else {
1524  if (nret == 1) /* only one single value? */
1525  first = luaK_exp2anyreg(fs, &e);
1526  else {
1527  luaK_exp2nextreg(fs, &e); /* values must go to the stack */
1528  first = fs->nactvar; /* return all active values */
1529  lua_assert(nret == fs->freereg - first);
1530  }
1531  }
1532  }
1533  luaK_ret(fs, first, nret);
1534  testnext(ls, ';'); /* skip optional semicolon */
1535 }
1536 
1537 
1538 static void statement (LexState *ls) {
1539  int line = ls->linenumber; /* may be needed for error messages */
1540  enterlevel(ls);
1541  switch (ls->t.token) {
1542  case ';': { /* stat -> ';' (empty statement) */
1543  luaX_next(ls); /* skip ';' */
1544  break;
1545  }
1546  case TK_IF: { /* stat -> ifstat */
1547  ifstat(ls, line);
1548  break;
1549  }
1550  case TK_WHILE: { /* stat -> whilestat */
1551  whilestat(ls, line);
1552  break;
1553  }
1554  case TK_DO: { /* stat -> DO block END */
1555  luaX_next(ls); /* skip DO */
1556  block(ls);
1557  check_match(ls, TK_END, TK_DO, line);
1558  break;
1559  }
1560  case TK_FOR: { /* stat -> forstat */
1561  forstat(ls, line);
1562  break;
1563  }
1564  case TK_REPEAT: { /* stat -> repeatstat */
1565  repeatstat(ls, line);
1566  break;
1567  }
1568  case TK_FUNCTION: { /* stat -> funcstat */
1569  funcstat(ls, line);
1570  break;
1571  }
1572  case TK_LOCAL: { /* stat -> localstat */
1573  luaX_next(ls); /* skip LOCAL */
1574  if (testnext(ls, TK_FUNCTION)) /* local function? */
1575  localfunc(ls);
1576  else
1577  localstat(ls);
1578  break;
1579  }
1580  case TK_DBCOLON: { /* stat -> label */
1581  luaX_next(ls); /* skip double colon */
1582  labelstat(ls, str_checkname(ls), line);
1583  break;
1584  }
1585  case TK_RETURN: { /* stat -> retstat */
1586  luaX_next(ls); /* skip RETURN */
1587  retstat(ls);
1588  break;
1589  }
1590  case TK_BREAK: /* stat -> breakstat */
1591  case TK_GOTO: { /* stat -> 'goto' NAME */
1592  gotostat(ls, luaK_jump(ls->fs));
1593  break;
1594  }
1595  default: { /* stat -> func | assignment */
1596  exprstat(ls);
1597  break;
1598  }
1599  }
1600  lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
1601  ls->fs->freereg >= ls->fs->nactvar);
1602  ls->fs->freereg = ls->fs->nactvar; /* free registers */
1603  leavelevel(ls);
1604 }
1605 
1606 /* }====================================================================== */
1607 
1608 
1609 /*
1610 ** compiles the main function, which is a regular vararg function with an
1611 ** upvalue named LUA_ENV
1612 */
1613 static void mainfunc (LexState *ls, FuncState *fs) {
1614  BlockCnt bl;
1615  expdesc v;
1616  open_func(ls, fs, &bl);
1617  fs->f->is_vararg = 1; /* main function is always declared vararg */
1618  init_exp(&v, VLOCAL, 0); /* create and... */
1619  newupvalue(fs, ls->envn, &v); /* ...set environment upvalue */
1620  luaC_objbarrier(ls->L, fs->f, ls->envn);
1621  luaX_next(ls); /* read first token */
1622  statlist(ls); /* parse main body */
1623  check(ls, TK_EOS);
1624  close_func(ls);
1625 }
1626 
1627 
1629  Dyndata *dyd, const char *name, int firstchar) {
1630  LexState lexstate;
1631  FuncState funcstate;
1632  LClosure *cl = luaF_newLclosure(L, 1); /* create main closure */
1633  setclLvalue(L, L->top, cl); /* anchor it (to avoid being collected) */
1634  luaD_inctop(L);
1635  lexstate.h = luaH_new(L); /* create table for scanner */
1636  sethvalue(L, L->top, lexstate.h); /* anchor it */
1637  luaD_inctop(L);
1638  funcstate.f = cl->p = luaF_newproto(L);
1639  luaC_objbarrier(L, cl, cl->p);
1640  funcstate.f->source = luaS_new(L, name); /* create and anchor TString */
1641  lua_assert(iswhite(funcstate.f)); /* do not need barrier here */
1642  lexstate.buff = buff;
1643  lexstate.dyd = dyd;
1644  dyd->actvar.n = dyd->gt.n = dyd->label.n = 0;
1645  luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar);
1646  mainfunc(&lexstate, &funcstate);
1647  lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
1648  /* all scopes should be correctly finished */
1649  lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0);
1650  L->top--; /* remove scanner's table */
1651  return cl; /* closure is on the stack, too */
1652 }
1653 
int level
Definition: afm2pl.c:1694
static char * vname(int c)
Definition: afm2tfm.c:1328
#define name
#define n
Definition: t4ht.c:1290
#define b
Definition: jpegint.h:372
long pc
Definition: disdvi.c:114
int z
Definition: dviconv.c:26
int v
Definition: dviconv.c:10
mpz_t * f
Definition: gen-fib.c:34
#define v2
#define s
Definition: afcover.h:80
#define t
Definition: afcover.h:96
static char buff[2 *10240]
Definition: genind.c:46
#define c(n)
Definition: gpos-common.c:150
#define lh
Definition: gsftopk.c:500
int base
Definition: gsftopk.c:1502
#define reg
Definition: hbf.c:83
#define NULL
Definition: ftobjs.h:61
small capitals from c petite p scientific i
Definition: afcover.h:80
FT_UInt idx
Definition: cffcmap.c:135
#define SHRT_MAX
Definition: c-minmax.h:43
char args[100]
Definition: fixwrites.c:7
char msg[512]
Definition: nsfix.c:80
int k
Definition: otp-parser.c:70
static int sz
Definition: pdftocairo.cc:114
integer nv
Definition: pmxab.c:88
static int32_t first
Definition: ppagelist.c:29
int g
Definition: ppmqvga.c:68
char line[1024]
Definition: process_score.c:29
#define gt(L)
Definition: minilua.c:415
#define luaS_new(L, s)
Definition: minilua.c:592
int luaK_jump(FuncState *fs)
Definition: lcode.c:136
void luaK_infix(FuncState *fs, BinOpr op, expdesc *v)
Definition: lcode.c:1086
int luaK_codek(FuncState *fs, int reg, int k)
Definition: lcode.c:346
void luaK_exp2val(FuncState *fs, expdesc *e)
Definition: lcode.c:744
int luaK_codeABC(FuncState *fs, OpCode o, int a, int b, int c)
Definition: lcode.c:312
void luaK_exp2nextreg(FuncState *fs, expdesc *e)
Definition: lcode.c:703
void luaK_storevar(FuncState *fs, expdesc *var, expdesc *ex)
Definition: lcode.c:782
void luaK_concat(FuncState *fs, int *l1, int l2)
Definition: lcode.c:116
void luaK_self(FuncState *fs, expdesc *e, expdesc *key)
Definition: lcode.c:809
void luaK_prefix(FuncState *fs, UnOpr op, expdesc *e, int line)
Definition: lcode.c:1066
void luaK_posfix(FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2, int line)
Definition: lcode.c:1124
void luaK_patchlist(FuncState *fs, int list, int target)
Definition: lcode.c:263
int luaK_intK(FuncState *fs, lua_Integer n)
Definition: lcode.c:471
void luaK_goiffalse(FuncState *fs, expdesc *e)
Definition: lcode.c:884
void luaK_nil(FuncState *fs, int from, int n)
Definition: lcode.c:64
void luaK_goiftrue(FuncState *fs, expdesc *e)
Definition: lcode.c:857
void luaK_setoneret(FuncState *fs, expdesc *e)
Definition: lcode.c:539
int luaK_exp2RK(FuncState *fs, expdesc *e)
Definition: lcode.c:758
void luaK_dischargevars(FuncState *fs, expdesc *e)
Definition: lcode.c:556
int luaK_codeABx(FuncState *fs, OpCode o, int a, unsigned int bc)
Definition: lcode.c:324
void luaK_fixline(FuncState *fs, int line)
Definition: lcode.c:1177
int luaK_stringK(FuncState *fs, TString *s)
Definition: lcode.c:458
void luaK_patchtohere(FuncState *fs, int list)
Definition: lcode.c:252
int luaK_exp2anyreg(FuncState *fs, expdesc *e)
Definition: lcode.c:715
void luaK_exp2anyregup(FuncState *fs, expdesc *e)
Definition: lcode.c:734
void luaK_setlist(FuncState *fs, int base, int nelems, int tostore)
Definition: lcode.c:1189
void luaK_setreturns(FuncState *fs, expdesc *e, int nresults)
Definition: lcode.c:515
void luaK_patchclose(FuncState *fs, int list, int level)
Definition: lcode.c:278
void luaK_ret(FuncState *fs, int first, int nret)
Definition: lcode.c:149
void luaK_reserveregs(FuncState *fs, int n)
Definition: lcode.c:375
void luaK_indexed(FuncState *fs, expdesc *t, expdesc *k)
Definition: lcode.c:946
int luaK_getlabel(FuncState *fs)
Definition: lcode.c:168
void luaK_checkstack(FuncState *fs, int n)
Definition: lcode.c:361
#define luaK_jumpto(fs, t)
Definition: lcode.h:50
UnOpr
Definition: lcode.h:40
@ OPR_LEN
Definition: lcode.h:40
@ OPR_NOT
Definition: lcode.h:40
@ OPR_BNOT
Definition: lcode.h:40
@ OPR_MINUS
Definition: lcode.h:40
@ OPR_NOUNOPR
Definition: lcode.h:40
#define luaK_setmultret(fs, e)
Definition: lcode.h:48
#define luaK_codeAsBx(fs, o, A, sBx)
Definition: lcode.h:46
#define NO_JUMP
Definition: lcode.h:20
#define getinstruction(fs, e)
Definition: lcode.h:44
BinOpr
Definition: lcode.h:26
@ OPR_LT
Definition: lcode.h:33
@ OPR_NOBINOPR
Definition: lcode.h:36
@ OPR_EQ
Definition: lcode.h:33
@ OPR_NE
Definition: lcode.h:34
@ OPR_MUL
Definition: lcode.h:27
@ OPR_GT
Definition: lcode.h:34
@ OPR_AND
Definition: lcode.h:35
@ OPR_SHR
Definition: lcode.h:31
@ OPR_GE
Definition: lcode.h:34
@ OPR_CONCAT
Definition: lcode.h:32
@ OPR_ADD
Definition: lcode.h:27
@ OPR_BAND
Definition: lcode.h:30
@ OPR_LE
Definition: lcode.h:33
@ OPR_SUB
Definition: lcode.h:27
@ OPR_DIV
Definition: lcode.h:28
@ OPR_BXOR
Definition: lcode.h:30
@ OPR_MOD
Definition: lcode.h:27
@ OPR_IDIV
Definition: lcode.h:29
@ OPR_OR
Definition: lcode.h:35
@ OPR_SHL
Definition: lcode.h:31
@ OPR_BOR
Definition: lcode.h:30
@ OPR_POW
Definition: lcode.h:27
void luaD_inctop(lua_State *L)
Definition: ldo.c:240
LClosure * luaF_newLclosure(lua_State *L, int n)
Definition: lfunc.c:33
Proto * luaF_newproto(lua_State *L)
Definition: lfunc.c:99
#define MAXUPVAL
Definition: lfunc.h:29
#define iswhite(x)
Definition: lgc.h:87
#define luaC_objbarrier(L, p, o)
Definition: lgc.h:126
#define luaC_checkGC(L)
Definition: lgc.h:115
void luaX_syntaxerror(LexState *ls, const char *msg)
Definition: llex.c:117
void luaX_setinput(lua_State *L, LexState *ls, ZIO *z, TString *source, int firstchar)
Definition: llex.c:162
TString * luaX_newstring(LexState *ls, const char *str, size_t l)
Definition: llex.c:127
void luaX_next(LexState *ls)
Definition: llex.c:552
int luaX_lookahead(LexState *ls)
Definition: llex.c:563
const char * luaX_token2str(LexState *ls, int token)
Definition: llex.c:82
@ TK_FALSE
Definition: llex.h:29
@ TK_STRING
Definition: llex.h:36
@ TK_DO
Definition: llex.h:29
@ TK_BREAK
Definition: llex.h:28
@ TK_GE
Definition: llex.h:33
@ TK_DBCOLON
Definition: llex.h:35
@ TK_ELSE
Definition: llex.h:29
@ TK_DOTS
Definition: llex.h:33
@ TK_END
Definition: llex.h:29
@ TK_WHILE
Definition: llex.h:31
@ TK_LOCAL
Definition: llex.h:30
@ TK_IF
Definition: llex.h:30
@ TK_TRUE
Definition: llex.h:31
@ TK_NE
Definition: llex.h:33
@ TK_THEN
Definition: llex.h:31
@ TK_FOR
Definition: llex.h:29
@ TK_IDIV
Definition: llex.h:33
@ TK_FLT
Definition: llex.h:36
@ TK_CONCAT
Definition: llex.h:33
@ TK_NAME
Definition: llex.h:36
@ TK_IN
Definition: llex.h:30
@ TK_NIL
Definition: llex.h:30
@ TK_NOT
Definition: llex.h:30
@ TK_INT
Definition: llex.h:36
@ TK_REPEAT
Definition: llex.h:30
@ TK_EOS
Definition: llex.h:35
@ TK_FUNCTION
Definition: llex.h:29
@ TK_OR
Definition: llex.h:30
@ TK_UNTIL
Definition: llex.h:31
@ TK_RETURN
Definition: llex.h:31
@ TK_LE
Definition: llex.h:33
@ TK_SHR
Definition: llex.h:34
@ TK_AND
Definition: llex.h:28
@ TK_EQ
Definition: llex.h:33
@ TK_GOTO
Definition: llex.h:30
@ TK_ELSEIF
Definition: llex.h:29
@ TK_SHL
Definition: llex.h:34
#define LUAI_MAXCCALLS
Definition: llimits.h:153
#define cast_int(i)
Definition: llimits.h:116
#define cast_byte(i)
Definition: llimits.h:114
#define lua_assert(c)
Definition: llimits.h:89
#define l_noret
Definition: llimits.h:143
#define MAX_INT
Definition: llimits.h:51
unsigned char lu_byte
Definition: llimits.h:35
#define cast(t, exp)
Definition: llimits.h:111
#define luaM_growvector(L, v, nelems, size, t, limit, e)
Definition: lmem.h:52
#define luaM_reallocvector(L, v, oldn, n, t)
Definition: lmem.h:56
const char * luaO_pushfstring(lua_State *L, const char *fmt,...)
Definition: lobject.c:468
int luaO_int2fb(unsigned int x)
Definition: lobject.c:41
#define sethvalue(L, obj, x)
Definition: lobject.h:250
#define setclLvalue(L, obj, x)
Definition: lobject.h:240
#define getstr(ts)
Definition: lobject.h:328
#define SETARG_C(i, v)
Definition: lopcodes.h:104
#define LFIELDS_PER_FLUSH
Definition: lopcodes.h:294
#define GETARG_A(i)
Definition: lopcodes.h:97
#define SETARG_B(i, v)
Definition: lopcodes.h:101
#define SET_OPCODE(i, o)
Definition: lopcodes.h:90
OpCode
Definition: lopcodes.h:167
@ OP_CALL
Definition: lopcodes.h:216
@ OP_VARARG
Definition: lopcodes.h:231
@ OP_SETTABLE
Definition: lopcodes.h:183
@ OP_CLOSURE
Definition: lopcodes.h:229
@ OP_FORPREP
Definition: lopcodes.h:222
@ OP_TFORLOOP
Definition: lopcodes.h:225
@ OP_TFORCALL
Definition: lopcodes.h:224
@ OP_FORLOOP
Definition: lopcodes.h:220
@ OP_GETUPVAL
Definition: lopcodes.h:176
@ OP_MOVE
Definition: lopcodes.h:171
@ OP_NEWTABLE
Definition: lopcodes.h:185
@ OP_TAILCALL
Definition: lopcodes.h:217
#define MAXARG_Bx
Definition: lopcodes.h:60
static void checknext(LexState *ls, int c)
Definition: lparser.c:112
static void mainfunc(LexState *ls, FuncState *fs)
Definition: lparser.c:1613
#define new_localvarliteral(ls, v)
Definition: lparser.c:191
#define MAXVARS
Definition: lparser.c:34
static void removevars(FuncState *fs, int tolevel)
Definition: lparser.c:211
#define leavelevel(ls)
Definition: lparser.c:338
static void fornum(LexState *ls, TString *varname, int line)
Definition: lparser.c:1318
static const struct @1685 priority[]
static void gotostat(LexState *ls, int pc)
Definition: lparser.c:1188
static void block(LexState *ls)
Definition: lparser.c:1094
static int exp1(LexState *ls)
Definition: lparser.c:1281
static int cond(LexState *ls)
Definition: lparser.c:1178
static int explist(LexState *ls, expdesc *v)
Definition: lparser.c:805
static void assignment(LexState *ls, struct LHS_assign *lh, int nvars)
Definition: lparser.c:1148
static void exprstat(LexState *ls)
Definition: lparser.c:1489
static void check(LexState *ls, int c)
Definition: lparser.c:106
static void checkrepeated(FuncState *fs, Labellist *ll, TString *label)
Definition: lparser.c:1204
lu_byte right
Definition: lparser.c:1028
lu_byte left
Definition: lparser.c:1027
static void findgotos(LexState *ls, Labeldesc *lb)
Definition: lparser.c:403
#define hasmultret(k)
Definition: lparser.c:37
static void singlevar(LexState *ls, expdesc *var)
Definition: lparser.c:295
static void simpleexp(LexState *ls, expdesc *v)
Definition: lparser.c:932
static void codeclosure(LexState *ls, expdesc *v)
Definition: lparser.c:522
static void labelstat(LexState *ls, TString *label, int line)
Definition: lparser.c:1224
static void close_func(LexState *ls)
Definition: lparser.c:553
static BinOpr subexpr(LexState *ls, expdesc *v, int limit)
Definition: lparser.c:1049
static void skipnoopstat(LexState *ls)
Definition: lparser.c:1218
static void closegoto(LexState *ls, int g, Labeldesc *label)
Definition: lparser.c:341
static void singlevaraux(FuncState *fs, TString *n, expdesc *var, int base)
Definition: lparser.c:270
static void adjustlocalvars(LexState *ls, int nvars)
Definition: lparser.c:202
static int searchupvalue(FuncState *fs, TString *name)
Definition: lparser.c:218
static void funcargs(LexState *ls, expdesc *f, int line)
Definition: lparser.c:818
static void test_then_block(LexState *ls, int *escapelist)
Definition: lparser.c:1383
#define UNARY_PRIORITY
Definition: lparser.c:1042
static void checkname(LexState *ls, expdesc *e)
Definition: lparser.c:156
static void new_localvar(LexState *ls, TString *name)
Definition: lparser.c:175
static Proto * addprototype(LexState *ls)
Definition: lparser.c:499
static void movegotosout(FuncState *fs, BlockCnt *bl)
Definition: lparser.c:421
static int block_follow(LexState *ls, int withuntil)
Definition: lparser.c:588
#define eqstr(a, b)
Definition: lparser.c:42
static void forlist(LexState *ls, TString *indexname)
Definition: lparser.c:1340
struct BlockCnt BlockCnt
static void new_localvarliteral_(LexState *ls, const char *name, size_t sz)
Definition: lparser.c:187
static void error_expected(LexState *ls, int token)
Definition: lparser.c:73
static int testnext(LexState *ls, int c)
Definition: lparser.c:97
static void fieldsel(LexState *ls, expdesc *v)
Definition: lparser.c:611
static BinOpr getbinopr(int op)
Definition: lparser.c:998
static void enterlevel(LexState *ls)
Definition: lparser.c:331
static void retstat(LexState *ls)
Definition: lparser.c:1505
static void funcstat(LexState *ls, int line)
Definition: lparser.c:1477
static int findlabel(LexState *ls, int g)
Definition: lparser.c:365
static void check_conflict(LexState *ls, struct LHS_assign *lh, expdesc *v)
Definition: lparser.c:1120
static void adjust_assign(LexState *ls, int nvars, int nexps, expdesc *e)
Definition: lparser.c:309
static int registerlocalvar(LexState *ls, TString *varname)
Definition: lparser.c:161
static void field(LexState *ls, struct ConsControl *cc)
Definition: lparser.c:703
static int newupvalue(FuncState *fs, TString *name, expdesc *v)
Definition: lparser.c:228
static void repeatstat(LexState *ls, int line)
Definition: lparser.c:1261
static void localfunc(LexState *ls)
Definition: lparser.c:1432
static int funcname(LexState *ls, expdesc *v)
Definition: lparser.c:1463
static void lastlistfield(FuncState *fs, struct ConsControl *cc)
Definition: lparser.c:679
static void errorlimit(FuncState *fs, int limit, const char *what)
Definition: lparser.c:79
static void leaveblock(FuncState *fs)
Definition: lparser.c:473
static LocVar * getlocvar(FuncState *fs, int i)
Definition: lparser.c:195
static void semerror(LexState *ls, const char *msg)
Definition: lparser.c:67
static void body(LexState *ls, expdesc *e, int ismethod, int line)
Definition: lparser.c:783
static void init_exp(expdesc *e, expkind k, int i)
Definition: lparser.c:144
static void closelistfield(FuncState *fs, struct ConsControl *cc)
Definition: lparser.c:668
LClosure * luaY_parser(lua_State *L, ZIO *z, Mbuffer *buff, Dyndata *dyd, const char *name, int firstchar)
Definition: lparser.c:1628
static void codestring(LexState *ls, expdesc *e, TString *s)
Definition: lparser.c:151
static void markupval(FuncState *fs, int level)
Definition: lparser.c:258
static void primaryexp(LexState *ls, expdesc *v)
Definition: lparser.c:872
static void check_match(LexState *ls, int what, int who, int where)
Definition: lparser.c:122
static int searchvar(FuncState *fs, TString *n)
Definition: lparser.c:244
static void statement(LexState *ls)
Definition: lparser.c:1538
static void yindex(LexState *ls, expdesc *v)
Definition: lparser.c:622
static void listfield(LexState *ls, struct ConsControl *cc)
Definition: lparser.c:694
static TString * str_checkname(LexState *ls)
Definition: lparser.c:135
static int newlabelentry(LexState *ls, Labellist *l, TString *name, int line, int pc)
Definition: lparser.c:385
static void open_func(LexState *ls, FuncState *fs, BlockCnt *bl)
Definition: lparser.c:529
static void forbody(LexState *ls, int base, int line, int nvars, int isnum)
Definition: lparser.c:1292
static void recfield(LexState *ls, struct ConsControl *cc)
Definition: lparser.c:647
static void parlist(LexState *ls)
Definition: lparser.c:754
static void checklimit(FuncState *fs, int v, int l, const char *what)
Definition: lparser.c:92
static void suffixedexp(LexState *ls, expdesc *v)
Definition: lparser.c:894
static void ifstat(LexState *ls, int line)
Definition: lparser.c:1418
static void breaklabel(LexState *ls)
Definition: lparser.c:454
#define check_condition(ls, c, msg)
Definition: lparser.c:118
static void localstat(LexState *ls)
Definition: lparser.c:1443
static void undefgoto(LexState *ls, Labeldesc *gt)
Definition: lparser.c:464
static void enterblock(FuncState *fs, BlockCnt *bl, lu_byte isloop)
Definition: lparser.c:439
static void whilestat(LexState *ls, int line)
Definition: lparser.c:1242
static void expr(LexState *ls, expdesc *v)
Definition: lparser.c:1079
static void forstat(LexState *ls, int line)
Definition: lparser.c:1365
static UnOpr getunopr(int op)
Definition: lparser.c:987
static void constructor(LexState *ls, expdesc *t)
Definition: lparser.c:725
static void statlist(LexState *ls)
Definition: lparser.c:599
#define vkisvar(k)
Definition: lparser.h:51
expkind
Definition: lparser.h:25
@ VTRUE
Definition: lparser.h:29
@ VFALSE
Definition: lparser.h:30
@ VVARARG
Definition: lparser.h:47
@ VKFLT
Definition: lparser.h:32
@ VNIL
Definition: lparser.h:28
@ VKINT
Definition: lparser.h:33
@ VUPVAL
Definition: lparser.h:37
@ VNONRELOC
Definition: lparser.h:34
@ VINDEXED
Definition: lparser.h:38
@ VRELOCABLE
Definition: lparser.h:44
@ VLOCAL
Definition: lparser.h:36
@ VVOID
Definition: lparser.h:26
@ VCALL
Definition: lparser.h:46
@ VK
Definition: lparser.h:31
#define isreserved(s)
Definition: lstring.h:27
Table * luaH_new(lua_State *L)
Definition: ltable.c:421
#define LUA_MULTRET
Definition: lua.h:33
ShellFileEnvironment e
Definition: sh6.c:388
lu_byte nactvar
Definition: lparser.c:52
struct BlockCnt * previous
Definition: lparser.c:49
lu_byte upval
Definition: lparser.c:53
lu_byte isloop
Definition: lparser.c:54
int firstlabel
Definition: lparser.c:50
int firstgoto
Definition: lparser.c:51
int tostore
Definition: lparser.c:643
expdesc * t
Definition: lparser.c:640
expdesc v
Definition: lparser.c:639
Labellist gt
Definition: lparser.h:101
int size
Definition: lparser.h:99
Labellist label
Definition: lparser.h:102
Vardesc * arr
Definition: lparser.h:97
int n
Definition: lparser.h:98
struct Dyndata::@1688 actvar
struct LexState * ls
Definition: lparser.h:114
struct FuncState * prev
Definition: lparser.h:113
int nk
Definition: lparser.h:119
Proto * f
Definition: lparser.h:112
short nlocvars
Definition: lparser.h:122
int jpc
Definition: lparser.h:118
int firstlocal
Definition: lparser.h:121
int lasttarget
Definition: lparser.h:117
lu_byte nups
Definition: lparser.h:124
int np
Definition: lparser.h:120
int pc
Definition: lparser.h:116
lu_byte nactvar
Definition: lparser.h:123
struct BlockCnt * bl
Definition: lparser.h:115
lu_byte freereg
Definition: lparser.h:125
struct Proto * p
Definition: lobject.h:455
expdesc v
Definition: lparser.c:1110
struct LHS_assign * prev
Definition: lparser.c:1109
lu_byte nactvar
Definition: lparser.h:82
TString * name
Definition: lparser.h:79
int line
Definition: lparser.h:81
int n
Definition: lparser.h:89
Labeldesc * arr
Definition: lparser.h:88
Definition: llex.h:58
struct lua_State * L
Definition: llex.h:65
TString * source
Definition: llex.h:70
Token t
Definition: llex.h:62
Table * h
Definition: llex.h:68
struct FuncState * fs
Definition: llex.h:64
struct Dyndata * dyd
Definition: llex.h:69
int linenumber
Definition: llex.h:60
Mbuffer * buff
Definition: llex.h:67
TString * envn
Definition: llex.h:71
TString * varname
Definition: lobject.h:398
int startpc
Definition: lobject.h:399
int endpc
Definition: lobject.h:400
Definition: lzio.h:23
Definition: lobject.h:407
Instruction * code
Definition: lobject.h:421
LocVar * locvars
Definition: lobject.h:424
int linedefined
Definition: lobject.h:418
lu_byte is_vararg
Definition: lobject.h:410
lu_byte maxstacksize
Definition: lobject.h:411
int lastlinedefined
Definition: lobject.h:419
TString * source
Definition: lobject.h:427
Upvaldesc * upvalues
Definition: lobject.h:425
SemInfo seminfo
Definition: llex.h:52
int token
Definition: llex.h:51
Definition: f2c.h:150
short idx
Definition: lparser.h:73
Definition: lzio.h:55
Definition: usprintf.c:39
int info
Definition: lparser.h:59
union expdesc::@1686 u
expkind k
Definition: lparser.h:55
Definition: bdf.c:133
unsigned short nCcalls
Definition: lstate.h:199
Definition: texview.c:48
Definition: sh.h:1226
Definition: dvips.h:235
Definition: parser.c:43
Definition: strexpr.c:21
Definition: sh.h:1782
struct def_label label[1024]
Definition: t1part.c:286
int j
Definition: t4ht.c:1589
#define key
Definition: tex2xindy.c:753
up
Definition: tex4ht.c:2558
val
Definition: tex4ht.c:3227
op
Definition: tex4ht.c:3129
@ L
Definition: ubidiimp.h:45
lua_Number r
Definition: llex.h:44
lua_Integer i
Definition: llex.h:45
TString * ts
Definition: llex.h:46
#define limit(x)
Definition: yuvsplittoppm.c:26