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