Branch data Line data Source code
1 : : /*
2 : : ** $Id: lparser.c $
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 <limits.h>
14 : : #include <string.h>
15 : :
16 : : #include "lua.h"
17 : :
18 : : #include "lcode.h"
19 : : #include "ldebug.h"
20 : : #include "ldo.h"
21 : : #include "lfunc.h"
22 : : #include "llex.h"
23 : : #include "lmem.h"
24 : : #include "lobject.h"
25 : : #include "lopcodes.h"
26 : : #include "lparser.h"
27 : : #include "lstate.h"
28 : : #include "lstring.h"
29 : : #include "ltable.h"
30 : :
31 : :
32 : :
33 : : /* maximum number of local variables per function (must be smaller
34 : : than 250, due to the bytecode format) */
35 : : #define MAXVARS 200
36 : :
37 : :
38 : : #define hasmultret(k) ((k) == VCALL || (k) == VVARARG)
39 : :
40 : :
41 : : /* because all strings are unified by the scanner, the parser
42 : : can use pointer equality for string equality */
43 : : #define eqstr(a,b) ((a) == (b))
44 : :
45 : :
46 : : /*
47 : : ** nodes for block list (list of active blocks)
48 : : */
49 : : typedef struct BlockCnt {
50 : : struct BlockCnt *previous; /* chain */
51 : : int firstlabel; /* index of first label in this block */
52 : : int firstgoto; /* index of first pending goto in this block */
53 : : lu_byte nactvar; /* # active locals outside the block */
54 : : lu_byte upval; /* true if some variable in the block is an upvalue */
55 : : lu_byte isloop; /* true if 'block' is a loop */
56 : : lu_byte insidetbc; /* true if inside the scope of a to-be-closed var. */
57 : : } BlockCnt;
58 : :
59 : :
60 : :
61 : : /*
62 : : ** prototypes for recursive non-terminal functions
63 : : */
64 : : static void statement (LexState *ls);
65 : : static void expr (LexState *ls, expdesc *v);
66 : :
67 : :
68 : 1 : static l_noret error_expected (LexState *ls, int token) {
69 : 2 : luaX_syntaxerror(ls,
70 : 1 : luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token)));
71 : : }
72 : :
73 : :
74 : 0 : static l_noret errorlimit (FuncState *fs, int limit, const char *what) {
75 : 0 : lua_State *L = fs->ls->L;
76 : : const char *msg;
77 : 0 : int line = fs->f->linedefined;
78 [ # # ]: 0 : const char *where = (line == 0)
79 : : ? "main function"
80 : 0 : : luaO_pushfstring(L, "function at line %d", line);
81 : 0 : msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s",
82 : 0 : what, limit, where);
83 : 0 : luaX_syntaxerror(fs->ls, msg);
84 : : }
85 : :
86 : :
87 : 688 : static void checklimit (FuncState *fs, int v, int l, const char *what) {
88 [ - + ]: 688 : if (v > l) errorlimit(fs, l, what);
89 : 688 : }
90 : :
91 : :
92 : : /*
93 : : ** Test whether next token is 'c'; if so, skip it.
94 : : */
95 : 3073 : static int testnext (LexState *ls, int c) {
96 [ + + ]: 3073 : if (ls->t.token == c) {
97 : 1431 : luaX_next(ls);
98 : 1431 : return 1;
99 : : }
100 : 1642 : else return 0;
101 : 3073 : }
102 : :
103 : :
104 : : /*
105 : : ** Check that next token is 'c'.
106 : : */
107 : 3169 : static void check (LexState *ls, int c) {
108 [ - + ]: 3169 : if (ls->t.token != c)
109 : 0 : error_expected(ls, c);
110 : 3169 : }
111 : :
112 : :
113 : : /*
114 : : ** Check that next token is 'c' and skip it.
115 : : */
116 : 403 : static void checknext (LexState *ls, int c) {
117 : 403 : check(ls, c);
118 : 403 : luaX_next(ls);
119 : 403 : }
120 : :
121 : :
122 : : #define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); }
123 : :
124 : :
125 : : /*
126 : : ** Check that next token is 'what' and skip it. In case of error,
127 : : ** raise an error that the expected 'what' should match a 'who'
128 : : ** in line 'where' (if that is not the current line).
129 : : */
130 : 1152 : static void check_match (LexState *ls, int what, int who, int where) {
131 [ + + ]: 1152 : if (unlikely(!testnext(ls, what))) {
132 [ + - ]: 1 : if (where == ls->linenumber) /* all in the same line? */
133 : 1 : error_expected(ls, what); /* do not need a complex message */
134 : : else {
135 : 0 : luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
136 : : "%s expected (to close %s at line %d)",
137 : 0 : luaX_token2str(ls, what), luaX_token2str(ls, who), where));
138 : : }
139 : : }
140 : 1151 : }
141 : :
142 : :
143 : 2114 : static TString *str_checkname (LexState *ls) {
144 : : TString *ts;
145 : 2114 : check(ls, TK_NAME);
146 : 2114 : ts = ls->t.seminfo.ts;
147 : 2114 : luaX_next(ls);
148 : 2114 : return ts;
149 : : }
150 : :
151 : :
152 : 4202 : static void init_exp (expdesc *e, expkind k, int i) {
153 : 4202 : e->f = e->t = NO_JUMP;
154 : 4202 : e->k = k;
155 : 4202 : e->u.info = i;
156 : 4202 : }
157 : :
158 : :
159 : 2801 : static void codestring (expdesc *e, TString *s) {
160 : 2801 : e->f = e->t = NO_JUMP;
161 : 2801 : e->k = VKSTR;
162 : 2801 : e->u.strval = s;
163 : 2801 : }
164 : :
165 : :
166 : 771 : static void codename (LexState *ls, expdesc *e) {
167 : 771 : codestring(e, str_checkname(ls));
168 : 771 : }
169 : :
170 : :
171 : : /*
172 : : ** Register a new local variable in the active 'Proto' (for debug
173 : : ** information).
174 : : */
175 : 32 : static int registerlocalvar (LexState *ls, FuncState *fs, TString *varname) {
176 : 32 : Proto *f = fs->f;
177 : 32 : int oldsize = f->sizelocvars;
178 : 32 : luaM_growvector(ls->L, f->locvars, fs->ndebugvars, f->sizelocvars,
179 : : LocVar, SHRT_MAX, "local variables");
180 [ + + ]: 64 : while (oldsize < f->sizelocvars)
181 : 32 : f->locvars[oldsize++].varname = NULL;
182 : 32 : f->locvars[fs->ndebugvars].varname = varname;
183 : 32 : f->locvars[fs->ndebugvars].startpc = fs->pc;
184 [ - + # # ]: 32 : luaC_objbarrier(ls->L, f, varname);
185 : 32 : return fs->ndebugvars++;
186 : : }
187 : :
188 : :
189 : : /*
190 : : ** Create a new local variable with the given 'name'. Return its index
191 : : ** in the function.
192 : : */
193 : 32 : static int new_localvar (LexState *ls, TString *name) {
194 : 32 : lua_State *L = ls->L;
195 : 32 : FuncState *fs = ls->fs;
196 : 32 : Dyndata *dyd = ls->dyd;
197 : : Vardesc *var;
198 : 32 : checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal,
199 : : MAXVARS, "local variables");
200 : 32 : luaM_growvector(L, dyd->actvar.arr, dyd->actvar.n + 1,
201 : : dyd->actvar.size, Vardesc, USHRT_MAX, "local variables");
202 : 32 : var = &dyd->actvar.arr[dyd->actvar.n++];
203 : 32 : var->vd.kind = VDKREG; /* default */
204 : 32 : var->vd.name = name;
205 : 32 : return dyd->actvar.n - 1 - fs->firstlocal;
206 : : }
207 : :
208 : : #define new_localvarliteral(ls,v) \
209 : : new_localvar(ls, \
210 : : luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char)) - 1));
211 : :
212 : :
213 : :
214 : : /*
215 : : ** Return the "variable description" (Vardesc) of a given variable.
216 : : ** (Unless noted otherwise, all variables are referred to by their
217 : : ** compiler indices.)
218 : : */
219 : 352 : static Vardesc *getlocalvardesc (FuncState *fs, int vidx) {
220 : 352 : return &fs->ls->dyd->actvar.arr[fs->firstlocal + vidx];
221 : : }
222 : :
223 : :
224 : : /*
225 : : ** Convert 'nvar', a compiler index level, to it corresponding
226 : : ** stack index level. For that, search for the highest variable
227 : : ** below that level that is in the stack and uses its stack
228 : : ** index ('sidx').
229 : : */
230 : 4349 : static int stacklevel (FuncState *fs, int nvar) {
231 [ + + ]: 4349 : while (nvar-- > 0) {
232 : 80 : Vardesc *vd = getlocalvardesc(fs, nvar); /* get variable */
233 [ + - ]: 80 : if (vd->vd.kind != RDKCTC) /* is in the stack? */
234 : 80 : return vd->vd.sidx + 1;
235 : : }
236 : 4269 : return 0; /* no variables in the stack */
237 : 4349 : }
238 : :
239 : :
240 : : /*
241 : : ** Return the number of variables in the stack for function 'fs'
242 : : */
243 : 3470 : int luaY_nvarstack (FuncState *fs) {
244 : 3470 : return stacklevel(fs, fs->nactvar);
245 : : }
246 : :
247 : :
248 : : /*
249 : : ** Get the debug-information entry for current variable 'vidx'.
250 : : */
251 : 32 : static LocVar *localdebuginfo (FuncState *fs, int vidx) {
252 : 32 : Vardesc *vd = getlocalvardesc(fs, vidx);
253 [ - + ]: 32 : if (vd->vd.kind == RDKCTC)
254 : 0 : return NULL; /* no debug info. for constants */
255 : : else {
256 : 32 : int idx = vd->vd.pidx;
257 : : lua_assert(idx < fs->ndebugvars);
258 : 32 : return &fs->f->locvars[idx];
259 : : }
260 : 32 : }
261 : :
262 : :
263 : : /*
264 : : ** Create an expression representing variable 'vidx'
265 : : */
266 : 8 : static void init_var (FuncState *fs, expdesc *e, int vidx) {
267 : 8 : e->f = e->t = NO_JUMP;
268 : 8 : e->k = VLOCAL;
269 : 8 : e->u.var.vidx = vidx;
270 : 8 : e->u.var.sidx = getlocalvardesc(fs, vidx)->vd.sidx;
271 : 8 : }
272 : :
273 : :
274 : : /*
275 : : ** Raises an error if variable described by 'e' is read only
276 : : */
277 : 110 : static void check_readonly (LexState *ls, expdesc *e) {
278 : 110 : FuncState *fs = ls->fs;
279 : 110 : TString *varname = NULL; /* to be set if variable is const */
280 [ + - - - ]: 110 : switch (e->k) {
281 : : case VCONST: {
282 : 0 : varname = ls->dyd->actvar.arr[e->u.info].vd.name;
283 : 0 : break;
284 : : }
285 : : case VLOCAL: {
286 : 0 : Vardesc *vardesc = getlocalvardesc(fs, e->u.var.vidx);
287 [ # # ]: 0 : if (vardesc->vd.kind != VDKREG) /* not a regular variable? */
288 : 0 : varname = vardesc->vd.name;
289 : 0 : break;
290 : : }
291 : : case VUPVAL: {
292 : 0 : Upvaldesc *up = &fs->f->upvalues[e->u.info];
293 [ # # ]: 0 : if (up->kind != VDKREG)
294 : 0 : varname = up->name;
295 : 0 : break;
296 : : }
297 : : default:
298 : 110 : return; /* other cases cannot be read-only */
299 : : }
300 [ # # ]: 0 : if (varname) {
301 : 0 : const char *msg = luaO_pushfstring(ls->L,
302 : 0 : "attempt to assign to const variable '%s'", getstr(varname));
303 : 0 : luaK_semerror(ls, msg); /* error */
304 : : }
305 : 110 : }
306 : :
307 : :
308 : : /*
309 : : ** Start the scope for the last 'nvars' created variables.
310 : : */
311 : 16 : static void adjustlocalvars (LexState *ls, int nvars) {
312 : 16 : FuncState *fs = ls->fs;
313 : 16 : int stklevel = luaY_nvarstack(fs);
314 : : int i;
315 [ + + ]: 48 : for (i = 0; i < nvars; i++) {
316 : 32 : int vidx = fs->nactvar++;
317 : 32 : Vardesc *var = getlocalvardesc(fs, vidx);
318 : 32 : var->vd.sidx = stklevel++;
319 : 32 : var->vd.pidx = registerlocalvar(ls, fs, var->vd.name);
320 : 32 : }
321 : 16 : }
322 : :
323 : :
324 : : /*
325 : : ** Close the scope for all variables up to level 'tolevel'.
326 : : ** (debug info.)
327 : : */
328 : 879 : static void removevars (FuncState *fs, int tolevel) {
329 : 879 : fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel);
330 [ + + ]: 911 : while (fs->nactvar > tolevel) {
331 : 32 : LocVar *var = localdebuginfo(fs, --fs->nactvar);
332 [ - + ]: 32 : if (var) /* does it have debug information? */
333 : 32 : var->endpc = fs->pc;
334 : : }
335 : 879 : }
336 : :
337 : :
338 : : /*
339 : : ** Search the upvalues of the function 'fs' for one
340 : : ** with the given 'name'.
341 : : */
342 : 2654 : static int searchupvalue (FuncState *fs, TString *name) {
343 : : int i;
344 : 2654 : Upvaldesc *up = fs->f->upvalues;
345 [ + + ]: 3981 : for (i = 0; i < fs->nups; i++) {
346 [ + + ]: 2654 : if (eqstr(up[i].name, name)) return i;
347 : 1327 : }
348 : 1327 : return -1; /* not found */
349 : 2654 : }
350 : :
351 : :
352 : 656 : static Upvaldesc *allocupvalue (FuncState *fs) {
353 : 656 : Proto *f = fs->f;
354 : 656 : int oldsize = f->sizeupvalues;
355 : 656 : checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues");
356 : 656 : luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues,
357 : : Upvaldesc, MAXUPVAL, "upvalues");
358 [ + + ]: 3280 : while (oldsize < f->sizeupvalues)
359 : 2624 : f->upvalues[oldsize++].name = NULL;
360 : 656 : return &f->upvalues[fs->nups++];
361 : : }
362 : :
363 : :
364 : 0 : static int newupvalue (FuncState *fs, TString *name, expdesc *v) {
365 : 0 : Upvaldesc *up = allocupvalue(fs);
366 : 0 : FuncState *prev = fs->prev;
367 [ # # ]: 0 : if (v->k == VLOCAL) {
368 : 0 : up->instack = 1;
369 : 0 : up->idx = v->u.var.sidx;
370 : 0 : up->kind = getlocalvardesc(prev, v->u.var.vidx)->vd.kind;
371 : : lua_assert(eqstr(name, getlocalvardesc(prev, v->u.var.vidx)->vd.name));
372 : 0 : }
373 : : else {
374 : 0 : up->instack = 0;
375 : 0 : up->idx = cast_byte(v->u.info);
376 : 0 : up->kind = prev->f->upvalues[v->u.info].kind;
377 : : lua_assert(eqstr(name, prev->f->upvalues[v->u.info].name));
378 : : }
379 : 0 : up->name = name;
380 [ # # # # ]: 0 : luaC_objbarrier(fs->ls->L, fs->f, name);
381 : 0 : return fs->nups - 1;
382 : : }
383 : :
384 : :
385 : : /*
386 : : ** Look for an active local variable with the name 'n' in the
387 : : ** function 'fs'. If found, initialize 'var' with it and return
388 : : ** its expression kind; otherwise return -1.
389 : : */
390 : 2662 : static int searchvar (FuncState *fs, TString *n, expdesc *var) {
391 : : int i;
392 [ + + ]: 2854 : for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) {
393 : 200 : Vardesc *vd = getlocalvardesc(fs, i);
394 [ + + ]: 200 : if (eqstr(n, vd->vd.name)) { /* found? */
395 [ - + ]: 8 : if (vd->vd.kind == RDKCTC) /* compile-time constant? */
396 : 0 : init_exp(var, VCONST, fs->firstlocal + i);
397 : : else /* real variable */
398 : 8 : init_var(fs, var, i);
399 : 8 : return var->k;
400 : : }
401 : 192 : }
402 : 2654 : return -1; /* not found */
403 : 2662 : }
404 : :
405 : :
406 : : /*
407 : : ** Mark block where variable at given level was defined
408 : : ** (to emit close instructions later).
409 : : */
410 : 0 : static void markupval (FuncState *fs, int level) {
411 : 0 : BlockCnt *bl = fs->bl;
412 [ # # ]: 0 : while (bl->nactvar > level)
413 : 0 : bl = bl->previous;
414 : 0 : bl->upval = 1;
415 : 0 : fs->needclose = 1;
416 : 0 : }
417 : :
418 : :
419 : : /*
420 : : ** Find a variable with the given name 'n'. If it is an upvalue, add
421 : : ** this upvalue into all intermediate functions. If it is a global, set
422 : : ** 'var' as 'void' as a flag.
423 : : */
424 : 3989 : static void singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
425 [ + + ]: 3989 : if (fs == NULL) /* no more levels? */
426 : 1327 : init_exp(var, VVOID, 0); /* default is global */
427 : : else {
428 : 2662 : int v = searchvar(fs, n, var); /* look up locals at current level */
429 [ + + ]: 2662 : if (v >= 0) { /* found? */
430 [ + - - + ]: 8 : if (v == VLOCAL && !base)
431 : 0 : markupval(fs, var->u.var.vidx); /* local will be used as an upval */
432 : 8 : }
433 : : else { /* not found as local at current level; try upvalues */
434 : 2654 : int idx = searchupvalue(fs, n); /* try existing upvalues */
435 [ + + ]: 2654 : if (idx < 0) { /* not found? */
436 : 1327 : singlevaraux(fs->prev, n, var, 0); /* try upper levels */
437 [ + - - + ]: 1327 : if (var->k == VLOCAL || var->k == VUPVAL) /* local or upvalue? */
438 : 0 : idx = newupvalue(fs, n, var); /* will be a new upvalue */
439 : : else /* it is a global or a constant */
440 : 1327 : return; /* don't need to do anything at this level */
441 : 0 : }
442 : 1327 : init_exp(var, VUPVAL, idx); /* new or old upvalue */
443 : : }
444 : : }
445 : 3989 : }
446 : :
447 : :
448 : : /*
449 : : ** Find a variable with the given name 'n', handling global variables
450 : : ** too.
451 : : */
452 : 1335 : static void singlevar (LexState *ls, expdesc *var) {
453 : 1335 : TString *varname = str_checkname(ls);
454 : 1335 : FuncState *fs = ls->fs;
455 : 1335 : singlevaraux(fs, varname, var, 1);
456 [ + + ]: 1335 : if (var->k == VVOID) { /* global name? */
457 : : expdesc key;
458 : 1327 : singlevaraux(fs, ls->envn, var, 1); /* get environment variable */
459 : : lua_assert(var->k != VVOID); /* this one must exist */
460 : 1327 : codestring(&key, varname); /* key is variable name */
461 : 1327 : luaK_indexed(fs, var, &key); /* env[varname] */
462 : 1327 : }
463 : 1335 : }
464 : :
465 : :
466 : : /*
467 : : ** Adjust the number of results from an expression list 'e' with 'nexps'
468 : : ** expressions to 'nvars' values.
469 : : */
470 : 0 : static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
471 : 0 : FuncState *fs = ls->fs;
472 : 0 : int needed = nvars - nexps; /* extra values needed */
473 [ # # # # ]: 0 : if (hasmultret(e->k)) { /* last expression has multiple returns? */
474 : 0 : int extra = needed + 1; /* discount last expression itself */
475 [ # # ]: 0 : if (extra < 0)
476 : 0 : extra = 0;
477 : 0 : luaK_setreturns(fs, e, extra); /* last exp. provides the difference */
478 : 0 : }
479 : : else {
480 [ # # ]: 0 : if (e->k != VVOID) /* at least one expression? */
481 : 0 : luaK_exp2nextreg(fs, e); /* close last expression */
482 [ # # ]: 0 : if (needed > 0) /* missing values? */
483 : 0 : luaK_nil(fs, fs->freereg, needed); /* complete with nils */
484 : : }
485 [ # # ]: 0 : if (needed > 0)
486 : 0 : luaK_reserveregs(fs, needed); /* registers for extra values */
487 : : else /* adding 'needed' is actually a subtraction */
488 : 0 : fs->freereg += needed; /* remove extra values */
489 : 0 : }
490 : :
491 : :
492 : : #define enterlevel(ls) luaE_incCstack(ls->L)
493 : :
494 : :
495 : : #define leavelevel(ls) ((ls)->L->nCcalls--)
496 : :
497 : :
498 : : /*
499 : : ** Generates an error that a goto jumps into the scope of some
500 : : ** local variable.
501 : : */
502 : 0 : static l_noret jumpscopeerror (LexState *ls, Labeldesc *gt) {
503 : 0 : const char *varname = getstr(getlocalvardesc(ls->fs, gt->nactvar)->vd.name);
504 : 0 : const char *msg = "<goto %s> at line %d jumps into the scope of local '%s'";
505 : 0 : msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line, varname);
506 : 0 : luaK_semerror(ls, msg); /* raise the error */
507 : : }
508 : :
509 : :
510 : : /*
511 : : ** Solves the goto at index 'g' to given 'label' and removes it
512 : : ** from the list of pending goto's.
513 : : ** If it jumps into the scope of some variable, raises an error.
514 : : */
515 : 0 : static void solvegoto (LexState *ls, int g, Labeldesc *label) {
516 : : int i;
517 : 0 : Labellist *gl = &ls->dyd->gt; /* list of goto's */
518 : 0 : Labeldesc *gt = &gl->arr[g]; /* goto to be resolved */
519 : : lua_assert(eqstr(gt->name, label->name));
520 [ # # ]: 0 : if (unlikely(gt->nactvar < label->nactvar)) /* enter some scope? */
521 : 0 : jumpscopeerror(ls, gt);
522 : 0 : luaK_patchlist(ls->fs, gt->pc, label->pc);
523 [ # # ]: 0 : for (i = g; i < gl->n - 1; i++) /* remove goto from pending list */
524 : 0 : gl->arr[i] = gl->arr[i + 1];
525 : 0 : gl->n--;
526 : 0 : }
527 : :
528 : :
529 : : /*
530 : : ** Search for an active label with the given name.
531 : : */
532 : 0 : static Labeldesc *findlabel (LexState *ls, TString *name) {
533 : : int i;
534 : 0 : Dyndata *dyd = ls->dyd;
535 : : /* check labels in current function for a match */
536 [ # # ]: 0 : for (i = ls->fs->firstlabel; i < dyd->label.n; i++) {
537 : 0 : Labeldesc *lb = &dyd->label.arr[i];
538 [ # # ]: 0 : if (eqstr(lb->name, name)) /* correct label? */
539 : 0 : return lb;
540 : 0 : }
541 : 0 : return NULL; /* label not found */
542 : 0 : }
543 : :
544 : :
545 : : /*
546 : : ** Adds a new label/goto in the corresponding list.
547 : : */
548 : 8 : static int newlabelentry (LexState *ls, Labellist *l, TString *name,
549 : : int line, int pc) {
550 : 8 : int n = l->n;
551 : 8 : luaM_growvector(ls->L, l->arr, n, l->size,
552 : : Labeldesc, SHRT_MAX, "labels/gotos");
553 : 8 : l->arr[n].name = name;
554 : 8 : l->arr[n].line = line;
555 : 8 : l->arr[n].nactvar = ls->fs->nactvar;
556 : 8 : l->arr[n].close = 0;
557 : 8 : l->arr[n].pc = pc;
558 : 8 : l->n = n + 1;
559 : 8 : return n;
560 : : }
561 : :
562 : :
563 : 0 : static int newgotoentry (LexState *ls, TString *name, int line, int pc) {
564 : 0 : return newlabelentry(ls, &ls->dyd->gt, name, line, pc);
565 : : }
566 : :
567 : :
568 : : /*
569 : : ** Solves forward jumps. Check whether new label 'lb' matches any
570 : : ** pending gotos in current block and solves them. Return true
571 : : ** if any of the goto's need to close upvalues.
572 : : */
573 : 8 : static int solvegotos (LexState *ls, Labeldesc *lb) {
574 : 8 : Labellist *gl = &ls->dyd->gt;
575 : 8 : int i = ls->fs->bl->firstgoto;
576 : 8 : int needsclose = 0;
577 [ - + ]: 8 : while (i < gl->n) {
578 [ # # ]: 0 : if (eqstr(gl->arr[i].name, lb->name)) {
579 : 0 : needsclose |= gl->arr[i].close;
580 : 0 : solvegoto(ls, i, lb); /* will remove 'i' from the list */
581 : 0 : }
582 : : else
583 : 0 : i++;
584 : : }
585 : 8 : return needsclose;
586 : : }
587 : :
588 : :
589 : : /*
590 : : ** Create a new label with the given 'name' at the given 'line'.
591 : : ** 'last' tells whether label is the last non-op statement in its
592 : : ** block. Solves all pending goto's to this new label and adds
593 : : ** a close instruction if necessary.
594 : : ** Returns true iff it added a close instruction.
595 : : */
596 : 8 : static int createlabel (LexState *ls, TString *name, int line,
597 : : int last) {
598 : 8 : FuncState *fs = ls->fs;
599 : 8 : Labellist *ll = &ls->dyd->label;
600 : 8 : int l = newlabelentry(ls, ll, name, line, luaK_getlabel(fs));
601 [ + - ]: 8 : if (last) { /* label is last no-op statement in the block? */
602 : : /* assume that locals are already out of scope */
603 : 0 : ll->arr[l].nactvar = fs->bl->nactvar;
604 : 0 : }
605 [ + - ]: 8 : if (solvegotos(ls, &ll->arr[l])) { /* need close? */
606 : 0 : luaK_codeABC(fs, OP_CLOSE, luaY_nvarstack(fs), 0, 0);
607 : 0 : return 1;
608 : : }
609 : 8 : return 0;
610 : 8 : }
611 : :
612 : :
613 : : /*
614 : : ** Adjust pending gotos to outer level of a block.
615 : : */
616 : 227 : static void movegotosout (FuncState *fs, BlockCnt *bl) {
617 : : int i;
618 : 227 : Labellist *gl = &fs->ls->dyd->gt;
619 : : /* correct pending gotos to current block */
620 [ - + ]: 227 : for (i = bl->firstgoto; i < gl->n; i++) { /* for each pending goto */
621 : 0 : Labeldesc *gt = &gl->arr[i];
622 : : /* leaving a variable scope? */
623 [ # # ]: 0 : if (stacklevel(fs, gt->nactvar) > stacklevel(fs, bl->nactvar))
624 : 0 : gt->close |= bl->upval; /* jump may need a close */
625 : 0 : gt->nactvar = bl->nactvar; /* update goto level */
626 : 0 : }
627 : 227 : }
628 : :
629 : :
630 : 883 : static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) {
631 : 883 : bl->isloop = isloop;
632 : 883 : bl->nactvar = fs->nactvar;
633 : 883 : bl->firstlabel = fs->ls->dyd->label.n;
634 : 883 : bl->firstgoto = fs->ls->dyd->gt.n;
635 : 883 : bl->upval = 0;
636 [ + + ]: 883 : bl->insidetbc = (fs->bl != NULL && fs->bl->insidetbc);
637 : 883 : bl->previous = fs->bl;
638 : 883 : fs->bl = bl;
639 : : lua_assert(fs->freereg == luaY_nvarstack(fs));
640 : 883 : }
641 : :
642 : :
643 : : /*
644 : : ** generates an error for an undefined 'goto'.
645 : : */
646 : 0 : static l_noret undefgoto (LexState *ls, Labeldesc *gt) {
647 : : const char *msg;
648 [ # # ]: 0 : if (eqstr(gt->name, luaS_newliteral(ls->L, "break"))) {
649 : 0 : msg = "break outside loop at line %d";
650 : 0 : msg = luaO_pushfstring(ls->L, msg, gt->line);
651 : 0 : }
652 : : else {
653 : 0 : msg = "no visible label '%s' for <goto> at line %d";
654 : 0 : msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line);
655 : : }
656 : 0 : luaK_semerror(ls, msg);
657 : : }
658 : :
659 : :
660 : 879 : static void leaveblock (FuncState *fs) {
661 : 879 : BlockCnt *bl = fs->bl;
662 : 879 : LexState *ls = fs->ls;
663 : 879 : int hasclose = 0;
664 : 879 : int stklevel = stacklevel(fs, bl->nactvar); /* level outside the block */
665 [ + + ]: 879 : if (bl->isloop) /* fix pending breaks? */
666 : 8 : hasclose = createlabel(ls, luaS_newliteral(ls->L, "break"), 0, 0);
667 [ + - + + : 879 : if (!hasclose && bl->previous && bl->upval)
+ - ]
668 : 0 : luaK_codeABC(fs, OP_CLOSE, stklevel, 0, 0);
669 : 879 : fs->bl = bl->previous;
670 : 879 : removevars(fs, bl->nactvar);
671 : : lua_assert(bl->nactvar == fs->nactvar);
672 : 879 : fs->freereg = stklevel; /* free registers */
673 : 879 : ls->dyd->label.n = bl->firstlabel; /* remove local labels */
674 [ + + ]: 879 : if (bl->previous) /* inner block? */
675 : 227 : movegotosout(fs, bl); /* update pending gotos to outer block */
676 : : else {
677 [ - + ]: 652 : if (bl->firstgoto < ls->dyd->gt.n) /* pending gotos in outer block? */
678 : 0 : undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */
679 : : }
680 : 879 : }
681 : :
682 : :
683 : : /*
684 : : ** adds a new prototype into list of prototypes
685 : : */
686 : 0 : static Proto *addprototype (LexState *ls) {
687 : : Proto *clp;
688 : 0 : lua_State *L = ls->L;
689 : 0 : FuncState *fs = ls->fs;
690 : 0 : Proto *f = fs->f; /* prototype of current function */
691 [ # # ]: 0 : if (fs->np >= f->sizep) {
692 : 0 : int oldsize = f->sizep;
693 : 0 : luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions");
694 [ # # ]: 0 : while (oldsize < f->sizep)
695 : 0 : f->p[oldsize++] = NULL;
696 : 0 : }
697 : 0 : f->p[fs->np++] = clp = luaF_newproto(L);
698 [ # # # # ]: 0 : luaC_objbarrier(L, f, clp);
699 : 0 : return clp;
700 : : }
701 : :
702 : :
703 : : /*
704 : : ** codes instruction to create new closure in parent function.
705 : : ** The OP_CLOSURE instruction uses the last available register,
706 : : ** so that, if it invokes the GC, the GC knows which registers
707 : : ** are in use at that time.
708 : :
709 : : */
710 : 0 : static void codeclosure (LexState *ls, expdesc *v) {
711 : 0 : FuncState *fs = ls->fs->prev;
712 : 0 : init_exp(v, VRELOC, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1));
713 : 0 : luaK_exp2nextreg(fs, v); /* fix it at the last register */
714 : 0 : }
715 : :
716 : :
717 : 656 : static void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) {
718 : 656 : Proto *f = fs->f;
719 : 656 : fs->prev = ls->fs; /* linked list of funcstates */
720 : 656 : fs->ls = ls;
721 : 656 : ls->fs = fs;
722 : 656 : fs->pc = 0;
723 : 656 : fs->previousline = f->linedefined;
724 : 656 : fs->iwthabs = 0;
725 : 656 : fs->lasttarget = 0;
726 : 656 : fs->freereg = 0;
727 : 656 : fs->nk = 0;
728 : 656 : fs->nabslineinfo = 0;
729 : 656 : fs->np = 0;
730 : 656 : fs->nups = 0;
731 : 656 : fs->ndebugvars = 0;
732 : 656 : fs->nactvar = 0;
733 : 656 : fs->needclose = 0;
734 : 656 : fs->firstlocal = ls->dyd->actvar.n;
735 : 656 : fs->firstlabel = ls->dyd->label.n;
736 : 656 : fs->bl = NULL;
737 : 656 : f->source = ls->source;
738 [ - + # # ]: 656 : luaC_objbarrier(ls->L, f, f->source);
739 : 656 : f->maxstacksize = 2; /* registers 0/1 are always valid */
740 : 656 : enterblock(fs, bl, 0);
741 : 656 : }
742 : :
743 : :
744 : 652 : static void close_func (LexState *ls) {
745 : 652 : lua_State *L = ls->L;
746 : 652 : FuncState *fs = ls->fs;
747 : 652 : Proto *f = fs->f;
748 : 652 : luaK_ret(fs, luaY_nvarstack(fs), 0); /* final return */
749 : 652 : leaveblock(fs);
750 : : lua_assert(fs->bl == NULL);
751 : 652 : luaK_finish(fs);
752 : 652 : luaM_shrinkvector(L, f->code, f->sizecode, fs->pc, Instruction);
753 : 652 : luaM_shrinkvector(L, f->lineinfo, f->sizelineinfo, fs->pc, ls_byte);
754 : 652 : luaM_shrinkvector(L, f->abslineinfo, f->sizeabslineinfo,
755 : : fs->nabslineinfo, AbsLineInfo);
756 : 652 : luaM_shrinkvector(L, f->k, f->sizek, fs->nk, TValue);
757 : 652 : luaM_shrinkvector(L, f->p, f->sizep, fs->np, Proto *);
758 : 652 : luaM_shrinkvector(L, f->locvars, f->sizelocvars, fs->ndebugvars, LocVar);
759 : 652 : luaM_shrinkvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc);
760 : 652 : ls->fs = fs->prev;
761 [ - + ]: 652 : luaC_checkGC(L);
762 : 652 : }
763 : :
764 : :
765 : :
766 : : /*============================================================*/
767 : : /* GRAMMAR RULES */
768 : : /*============================================================*/
769 : :
770 : :
771 : : /*
772 : : ** check whether current token is in the follow set of a block.
773 : : ** 'until' closes syntactical blocks, but do not close scope,
774 : : ** so it is handled in separate.
775 : : */
776 : 1958 : static int block_follow (LexState *ls, int withuntil) {
777 [ - + + ]: 1958 : switch (ls->t.token) {
778 : : case TK_ELSE: case TK_ELSEIF:
779 : : case TK_END: case TK_EOS:
780 : 695 : return 1;
781 : 0 : case TK_UNTIL: return withuntil;
782 : 1263 : default: return 0;
783 : : }
784 : 1958 : }
785 : :
786 : :
787 : 867 : static void statlist (LexState *ls) {
788 : : /* statlist -> { stat [';'] } */
789 [ + + ]: 1794 : while (!block_follow(ls, 1)) {
790 [ + + ]: 1095 : if (ls->t.token == TK_RETURN) {
791 : 168 : statement(ls);
792 : 168 : return; /* 'return' must be last statement */
793 : : }
794 : 927 : statement(ls);
795 : : }
796 : 867 : }
797 : :
798 : :
799 : 723 : static void fieldsel (LexState *ls, expdesc *v) {
800 : : /* fieldsel -> ['.' | ':'] NAME */
801 : 723 : FuncState *fs = ls->fs;
802 : : expdesc key;
803 : 723 : luaK_exp2anyregup(fs, v);
804 : 723 : luaX_next(ls); /* skip the dot or colon */
805 : 723 : codename(ls, &key);
806 : 723 : luaK_indexed(fs, v, &key);
807 : 723 : }
808 : :
809 : :
810 : 57 : static void yindex (LexState *ls, expdesc *v) {
811 : : /* index -> '[' expr ']' */
812 : 57 : luaX_next(ls); /* skip the '[' */
813 : 57 : expr(ls, v);
814 : 57 : luaK_exp2val(ls->fs, v);
815 : 57 : checknext(ls, ']');
816 : 57 : }
817 : :
818 : :
819 : : /*
820 : : ** {======================================================================
821 : : ** Rules for Constructors
822 : : ** =======================================================================
823 : : */
824 : :
825 : :
826 : : typedef struct ConsControl {
827 : : expdesc v; /* last list item read */
828 : : expdesc *t; /* table descriptor */
829 : : int nh; /* total number of 'record' elements */
830 : : int na; /* number of array elements already stored */
831 : : int tostore; /* number of array elements pending to be stored */
832 : : } ConsControl;
833 : :
834 : :
835 : 0 : static void recfield (LexState *ls, ConsControl *cc) {
836 : : /* recfield -> (NAME | '['exp']') = exp */
837 : 0 : FuncState *fs = ls->fs;
838 : 0 : int reg = ls->fs->freereg;
839 : : expdesc tab, key, val;
840 [ # # ]: 0 : if (ls->t.token == TK_NAME) {
841 : 0 : checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
842 : 0 : codename(ls, &key);
843 : 0 : }
844 : : else /* ls->t.token == '[' */
845 : 0 : yindex(ls, &key);
846 : 0 : cc->nh++;
847 : 0 : checknext(ls, '=');
848 : 0 : tab = *cc->t;
849 : 0 : luaK_indexed(fs, &tab, &key);
850 : 0 : expr(ls, &val);
851 : 0 : luaK_storevar(fs, &tab, &val);
852 : 0 : fs->freereg = reg; /* free registers */
853 : 0 : }
854 : :
855 : :
856 : 16 : static void closelistfield (FuncState *fs, ConsControl *cc) {
857 [ + + ]: 16 : if (cc->v.k == VVOID) return; /* there is no list item */
858 : 7 : luaK_exp2nextreg(fs, &cc->v);
859 : 7 : cc->v.k = VVOID;
860 [ + - ]: 7 : if (cc->tostore == LFIELDS_PER_FLUSH) {
861 : 0 : luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); /* flush */
862 : 0 : cc->na += cc->tostore;
863 : 0 : cc->tostore = 0; /* no more items pending */
864 : 0 : }
865 : 16 : }
866 : :
867 : :
868 : 9 : static void lastlistfield (FuncState *fs, ConsControl *cc) {
869 [ + - ]: 9 : if (cc->tostore == 0) return;
870 [ + - - + ]: 9 : if (hasmultret(cc->v.k)) {
871 : 0 : luaK_setmultret(fs, &cc->v);
872 : 0 : luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET);
873 : 0 : cc->na--; /* do not count last expression (unknown number of elements) */
874 : 0 : }
875 : : else {
876 [ + - ]: 9 : if (cc->v.k != VVOID)
877 : 9 : luaK_exp2nextreg(fs, &cc->v);
878 : 9 : luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore);
879 : : }
880 : 9 : cc->na += cc->tostore;
881 : 9 : }
882 : :
883 : :
884 : 16 : static void listfield (LexState *ls, ConsControl *cc) {
885 : : /* listfield -> exp */
886 : 16 : expr(ls, &cc->v);
887 : 16 : cc->tostore++;
888 : 16 : }
889 : :
890 : :
891 : 16 : static void field (LexState *ls, ConsControl *cc) {
892 : : /* field -> listfield | recfield */
893 [ - + - ]: 16 : switch(ls->t.token) {
894 : : case TK_NAME: { /* may be 'listfield' or 'recfield' */
895 [ # # ]: 0 : if (luaX_lookahead(ls) != '=') /* expression? */
896 : 0 : listfield(ls, cc);
897 : : else
898 : 0 : recfield(ls, cc);
899 : 0 : break;
900 : : }
901 : : case '[': {
902 : 0 : recfield(ls, cc);
903 : 0 : break;
904 : : }
905 : : default: {
906 : 16 : listfield(ls, cc);
907 : 16 : break;
908 : : }
909 : : }
910 : 16 : }
911 : :
912 : :
913 : 9 : static void constructor (LexState *ls, expdesc *t) {
914 : : /* constructor -> '{' [ field { sep field } [sep] ] '}'
915 : : sep -> ',' | ';' */
916 : 9 : FuncState *fs = ls->fs;
917 : 9 : int line = ls->linenumber;
918 : 9 : int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
919 : : ConsControl cc;
920 : 9 : luaK_code(fs, 0); /* space for extra arg. */
921 : 9 : cc.na = cc.nh = cc.tostore = 0;
922 : 9 : cc.t = t;
923 : 9 : init_exp(t, VNONRELOC, fs->freereg); /* table will be at stack top */
924 : 9 : luaK_reserveregs(fs, 1);
925 : 9 : init_exp(&cc.v, VVOID, 0); /* no value (yet) */
926 : 9 : checknext(ls, '{');
927 : 9 : do {
928 : : lua_assert(cc.v.k == VVOID || cc.tostore > 0);
929 [ + - ]: 16 : if (ls->t.token == '}') break;
930 : 16 : closelistfield(fs, &cc);
931 : 16 : field(ls, &cc);
932 [ + + + + ]: 16 : } while (testnext(ls, ',') || testnext(ls, ';'));
933 : 9 : check_match(ls, '}', '{', line);
934 : 9 : lastlistfield(fs, &cc);
935 : 9 : luaK_settablesize(fs, pc, t->u.info, cc.na, cc.nh);
936 : 9 : }
937 : :
938 : : /* }====================================================================== */
939 : :
940 : :
941 : 656 : static void setvararg (FuncState *fs, int nparams) {
942 : 656 : fs->f->is_vararg = 1;
943 : 656 : luaK_codeABC(fs, OP_VARARGPREP, nparams, 0, 0);
944 : 656 : }
945 : :
946 : :
947 : 0 : static void parlist (LexState *ls) {
948 : : /* parlist -> [ {NAME ','} (NAME | '...') ] */
949 : 0 : FuncState *fs = ls->fs;
950 : 0 : Proto *f = fs->f;
951 : 0 : int nparams = 0;
952 : 0 : int isvararg = 0;
953 [ # # ]: 0 : if (ls->t.token != ')') { /* is 'parlist' not empty? */
954 : 0 : do {
955 [ # # # ]: 0 : switch (ls->t.token) {
956 : : case TK_NAME: {
957 : 0 : new_localvar(ls, str_checkname(ls));
958 : 0 : nparams++;
959 : 0 : break;
960 : : }
961 : : case TK_DOTS: {
962 : 0 : luaX_next(ls);
963 : 0 : isvararg = 1;
964 : 0 : break;
965 : : }
966 : 0 : default: luaX_syntaxerror(ls, "<name> or '...' expected");
967 : : }
968 [ # # # # ]: 0 : } while (!isvararg && testnext(ls, ','));
969 : 0 : }
970 : 0 : adjustlocalvars(ls, nparams);
971 : 0 : f->numparams = cast_byte(fs->nactvar);
972 [ # # ]: 0 : if (isvararg)
973 : 0 : setvararg(fs, f->numparams); /* declared vararg */
974 : 0 : luaK_reserveregs(fs, fs->nactvar); /* reserve registers for parameters */
975 : 0 : }
976 : :
977 : :
978 : 0 : static void body (LexState *ls, expdesc *e, int ismethod, int line) {
979 : : /* body -> '(' parlist ')' block END */
980 : : FuncState new_fs;
981 : : BlockCnt bl;
982 : 0 : new_fs.f = addprototype(ls);
983 : 0 : new_fs.f->linedefined = line;
984 : 0 : open_func(ls, &new_fs, &bl);
985 : 0 : checknext(ls, '(');
986 [ # # ]: 0 : if (ismethod) {
987 : 0 : new_localvarliteral(ls, "self"); /* create 'self' parameter */
988 : 0 : adjustlocalvars(ls, 1);
989 : 0 : }
990 : 0 : parlist(ls);
991 : 0 : checknext(ls, ')');
992 : 0 : statlist(ls);
993 : 0 : new_fs.f->lastlinedefined = ls->linenumber;
994 : 0 : check_match(ls, TK_END, TK_FUNCTION, line);
995 : 0 : codeclosure(ls, e);
996 : 0 : close_func(ls);
997 : 0 : }
998 : :
999 : :
1000 : 1135 : static int explist (LexState *ls, expdesc *v) {
1001 : : /* explist -> expr { ',' expr } */
1002 : 1135 : int n = 1; /* at least one expression */
1003 : 1135 : expr(ls, v);
1004 [ + + ]: 1408 : while (testnext(ls, ',')) {
1005 : 273 : luaK_exp2nextreg(ls->fs, v);
1006 : 273 : expr(ls, v);
1007 : 273 : n++;
1008 : : }
1009 : 1135 : return n;
1010 : : }
1011 : :
1012 : :
1013 : 930 : static void funcargs (LexState *ls, expdesc *f, int line) {
1014 : 930 : FuncState *fs = ls->fs;
1015 : : expdesc args;
1016 : : int base, nparams;
1017 [ - + - - ]: 930 : switch (ls->t.token) {
1018 : : case '(': { /* funcargs -> '(' [ explist ] ')' */
1019 : 930 : luaX_next(ls);
1020 [ + + ]: 930 : if (ls->t.token == ')') /* arg list is empty? */
1021 : 74 : args.k = VVOID;
1022 : : else {
1023 : 856 : explist(ls, &args);
1024 [ + + - + ]: 856 : if (hasmultret(args.k))
1025 : 34 : luaK_setmultret(fs, &args);
1026 : : }
1027 : 930 : check_match(ls, ')', '(', line);
1028 : 930 : break;
1029 : : }
1030 : : case '{': { /* funcargs -> constructor */
1031 : 0 : constructor(ls, &args);
1032 : 0 : break;
1033 : : }
1034 : : case TK_STRING: { /* funcargs -> STRING */
1035 : 0 : codestring(&args, ls->t.seminfo.ts);
1036 : 0 : luaX_next(ls); /* must use 'seminfo' before 'next' */
1037 : 0 : break;
1038 : : }
1039 : : default: {
1040 : 0 : luaX_syntaxerror(ls, "function arguments expected");
1041 : : }
1042 : : }
1043 : : lua_assert(f->k == VNONRELOC);
1044 : 930 : base = f->u.info; /* base register for call */
1045 [ + + - + ]: 930 : if (hasmultret(args.k))
1046 : 35 : nparams = LUA_MULTRET; /* open call */
1047 : : else {
1048 [ + + ]: 895 : if (args.k != VVOID)
1049 : 821 : luaK_exp2nextreg(fs, &args); /* close last argument */
1050 : 895 : nparams = fs->freereg - (base+1);
1051 : : }
1052 : 930 : init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
1053 : 930 : luaK_fixline(fs, line);
1054 : 930 : fs->freereg = base+1; /* call remove function and arguments and leaves
1055 : : (unless changed) one result */
1056 : 930 : }
1057 : :
1058 : :
1059 : :
1060 : :
1061 : : /*
1062 : : ** {======================================================================
1063 : : ** Expression parsing
1064 : : ** =======================================================================
1065 : : */
1066 : :
1067 : :
1068 : 1340 : static void primaryexp (LexState *ls, expdesc *v) {
1069 : : /* primaryexp -> NAME | '(' expr ')' */
1070 [ + + + ]: 1340 : switch (ls->t.token) {
1071 : : case '(': {
1072 : 2 : int line = ls->linenumber;
1073 : 2 : luaX_next(ls);
1074 : 2 : expr(ls, v);
1075 : 2 : check_match(ls, ')', '(', line);
1076 : 2 : luaK_dischargevars(ls->fs, v);
1077 : 2 : return;
1078 : : }
1079 : : case TK_NAME: {
1080 : 1335 : singlevar(ls, v);
1081 : 1335 : return;
1082 : : }
1083 : : default: {
1084 : 3 : luaX_syntaxerror(ls, "unexpected symbol");
1085 : : }
1086 : : }
1087 : 1337 : }
1088 : :
1089 : :
1090 : 1340 : static void suffixedexp (LexState *ls, expdesc *v) {
1091 : : /* suffixedexp ->
1092 : : primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */
1093 : 1340 : FuncState *fs = ls->fs;
1094 : 1340 : int line = ls->linenumber;
1095 : 1340 : primaryexp(ls, v);
1096 : 3051 : for (;;) {
1097 [ + + + + : 3051 : switch (ls->t.token) {
+ ]
1098 : : case '.': { /* fieldsel */
1099 : 723 : fieldsel(ls, v);
1100 : 723 : break;
1101 : : }
1102 : : case '[': { /* '[' exp ']' */
1103 : : expdesc key;
1104 : 57 : luaK_exp2anyregup(fs, v);
1105 : 57 : yindex(ls, &key);
1106 : 57 : luaK_indexed(fs, v, &key);
1107 : 57 : break;
1108 : : }
1109 : : case ':': { /* ':' NAME funcargs */
1110 : : expdesc key;
1111 : 48 : luaX_next(ls);
1112 : 48 : codename(ls, &key);
1113 : 48 : luaK_self(fs, v, &key);
1114 : 48 : funcargs(ls, v, line);
1115 : 48 : break;
1116 : : }
1117 : : case '(': case TK_STRING: case '{': { /* funcargs */
1118 : 883 : luaK_exp2nextreg(fs, v);
1119 : 883 : funcargs(ls, v, line);
1120 : 883 : break;
1121 : : }
1122 : 1340 : default: return;
1123 : : }
1124 : : }
1125 : : }
1126 : :
1127 : :
1128 : 1937 : static void simpleexp (LexState *ls, expdesc *v) {
1129 : : /* simpleexp -> FLT | INT | STRING | NIL | TRUE | FALSE | ... |
1130 : : constructor | FUNCTION body | suffixedexp */
1131 [ + + + - : 1937 : switch (ls->t.token) {
+ - + + -
+ ]
1132 : : case TK_FLT: {
1133 : 0 : init_exp(v, VKFLT, 0);
1134 : 0 : v->u.nval = ls->t.seminfo.r;
1135 : 0 : break;
1136 : : }
1137 : : case TK_INT: {
1138 : 446 : init_exp(v, VKINT, 0);
1139 : 446 : v->u.ival = ls->t.seminfo.i;
1140 : 446 : break;
1141 : : }
1142 : : case TK_STRING: {
1143 : 703 : codestring(v, ls->t.seminfo.ts);
1144 : 703 : break;
1145 : : }
1146 : : case TK_NIL: {
1147 : 139 : init_exp(v, VNIL, 0);
1148 : 139 : break;
1149 : : }
1150 : : case TK_TRUE: {
1151 : 8 : init_exp(v, VTRUE, 0);
1152 : 8 : break;
1153 : : }
1154 : : case TK_FALSE: {
1155 : 8 : init_exp(v, VFALSE, 0);
1156 : 8 : break;
1157 : : }
1158 : : case TK_DOTS: { /* vararg */
1159 : 0 : FuncState *fs = ls->fs;
1160 [ # # ]: 0 : check_condition(ls, fs->f->is_vararg,
1161 : : "cannot use '...' outside a vararg function");
1162 : 0 : init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 0, 1));
1163 : 0 : break;
1164 : : }
1165 : : case '{': { /* constructor */
1166 : 9 : constructor(ls, v);
1167 : 9 : return;
1168 : : }
1169 : : case TK_FUNCTION: {
1170 : 0 : luaX_next(ls);
1171 : 0 : body(ls, v, 0, ls->linenumber);
1172 : 0 : return;
1173 : : }
1174 : : default: {
1175 : 624 : suffixedexp(ls, v);
1176 : 624 : return;
1177 : : }
1178 : : }
1179 : 1304 : luaX_next(ls);
1180 : 1937 : }
1181 : :
1182 : :
1183 : 2070 : static UnOpr getunopr (int op) {
1184 [ + + - - : 2070 : switch (op) {
+ ]
1185 : 16 : case TK_NOT: return OPR_NOT;
1186 : 0 : case '-': return OPR_MINUS;
1187 : 0 : case '~': return OPR_BNOT;
1188 : 117 : case '#': return OPR_LEN;
1189 : 1937 : default: return OPR_NOUNOPR;
1190 : : }
1191 : 2070 : }
1192 : :
1193 : :
1194 : 2069 : static BinOpr getbinopr (int op) {
1195 [ - - - - : 2069 : switch (op) {
- - - - -
- - - + +
+ - - - -
- - + ]
1196 : 0 : case '+': return OPR_ADD;
1197 : 0 : case '-': return OPR_SUB;
1198 : 0 : case '*': return OPR_MUL;
1199 : 0 : case '%': return OPR_MOD;
1200 : 0 : case '^': return OPR_POW;
1201 : 0 : case '/': return OPR_DIV;
1202 : 0 : case TK_IDIV: return OPR_IDIV;
1203 : 0 : case '&': return OPR_BAND;
1204 : 0 : case '|': return OPR_BOR;
1205 : 0 : case '~': return OPR_BXOR;
1206 : 0 : case TK_SHL: return OPR_SHL;
1207 : 0 : case TK_SHR: return OPR_SHR;
1208 : 80 : case TK_CONCAT: return OPR_CONCAT;
1209 : 129 : case TK_NE: return OPR_NE;
1210 : 90 : case TK_EQ: return OPR_EQ;
1211 : 0 : case '<': return OPR_LT;
1212 : 0 : case TK_LE: return OPR_LE;
1213 : 0 : case '>': return OPR_GT;
1214 : 0 : case TK_GE: return OPR_GE;
1215 : 0 : case TK_AND: return OPR_AND;
1216 : 0 : case TK_OR: return OPR_OR;
1217 : 1770 : default: return OPR_NOBINOPR;
1218 : : }
1219 : 2069 : }
1220 : :
1221 : :
1222 : : /*
1223 : : ** Priority table for binary operators.
1224 : : */
1225 : : static const struct {
1226 : : lu_byte left; /* left priority for each binary operator */
1227 : : lu_byte right; /* right priority */
1228 : : } priority[] = { /* ORDER OPR */
1229 : : {10, 10}, {10, 10}, /* '+' '-' */
1230 : : {11, 11}, {11, 11}, /* '*' '%' */
1231 : : {14, 13}, /* '^' (right associative) */
1232 : : {11, 11}, {11, 11}, /* '/' '//' */
1233 : : {6, 6}, {4, 4}, {5, 5}, /* '&' '|' '~' */
1234 : : {7, 7}, {7, 7}, /* '<<' '>>' */
1235 : : {9, 8}, /* '..' (right associative) */
1236 : : {3, 3}, {3, 3}, {3, 3}, /* ==, <, <= */
1237 : : {3, 3}, {3, 3}, {3, 3}, /* ~=, >, >= */
1238 : : {2, 2}, {1, 1} /* and, or */
1239 : : };
1240 : :
1241 : : #define UNARY_PRIORITY 12 /* priority for unary operators */
1242 : :
1243 : :
1244 : : /*
1245 : : ** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
1246 : : ** where 'binop' is any binary operator with a priority higher than 'limit'
1247 : : */
1248 : 2070 : static BinOpr subexpr (LexState *ls, expdesc *v, int limit) {
1249 : : BinOpr op;
1250 : : UnOpr uop;
1251 : 2070 : enterlevel(ls);
1252 : 2070 : uop = getunopr(ls->t.token);
1253 [ + + ]: 2070 : if (uop != OPR_NOUNOPR) { /* prefix (unary) operator? */
1254 : 133 : int line = ls->linenumber;
1255 : 133 : luaX_next(ls); /* skip operator */
1256 : 133 : subexpr(ls, v, UNARY_PRIORITY);
1257 : 133 : luaK_prefix(ls->fs, uop, v, line);
1258 : 133 : }
1259 : 1937 : else simpleexp(ls, v);
1260 : : /* expand while operators have priorities higher than 'limit' */
1261 : 2070 : op = getbinopr(ls->t.token);
1262 [ + + + + ]: 2305 : while (op != OPR_NOBINOPR && priority[op].left > limit) {
1263 : : expdesc v2;
1264 : : BinOpr nextop;
1265 : 235 : int line = ls->linenumber;
1266 : 235 : luaX_next(ls); /* skip operator */
1267 : 235 : luaK_infix(ls->fs, op, v);
1268 : : /* read sub-expression with higher priority */
1269 : 235 : nextop = subexpr(ls, &v2, priority[op].right);
1270 : 235 : luaK_posfix(ls->fs, op, v, &v2, line);
1271 : 235 : op = nextop;
1272 : : }
1273 : 2070 : leavelevel(ls);
1274 : 2070 : return op; /* return first untreated operator */
1275 : : }
1276 : :
1277 : :
1278 : 1702 : static void expr (LexState *ls, expdesc *v) {
1279 : 1702 : subexpr(ls, v, 0);
1280 : 1702 : }
1281 : :
1282 : : /* }==================================================================== */
1283 : :
1284 : :
1285 : :
1286 : : /*
1287 : : ** {======================================================================
1288 : : ** Rules for Statements
1289 : : ** =======================================================================
1290 : : */
1291 : :
1292 : :
1293 : 8 : static void block (LexState *ls) {
1294 : : /* block -> statlist */
1295 : 8 : FuncState *fs = ls->fs;
1296 : : BlockCnt bl;
1297 : 8 : enterblock(fs, &bl, 0);
1298 : 8 : statlist(ls);
1299 : 8 : leaveblock(fs);
1300 : 8 : }
1301 : :
1302 : :
1303 : : /*
1304 : : ** structure to chain all variables in the left-hand side of an
1305 : : ** assignment
1306 : : */
1307 : : struct LHS_assign {
1308 : : struct LHS_assign *prev;
1309 : : expdesc v; /* variable (global, local, upvalue, or indexed) */
1310 : : };
1311 : :
1312 : :
1313 : : /*
1314 : : ** check whether, in an assignment to an upvalue/local variable, the
1315 : : ** upvalue/local variable is begin used in a previous assignment to a
1316 : : ** table. If so, save original upvalue/local value in a safe place and
1317 : : ** use this safe copy in the previous assignment.
1318 : : */
1319 : 0 : static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
1320 : 0 : FuncState *fs = ls->fs;
1321 : 0 : int extra = fs->freereg; /* eventual position to save local variable */
1322 : 0 : int conflict = 0;
1323 [ # # ]: 0 : for (; lh; lh = lh->prev) { /* check all previous assignments */
1324 [ # # # # ]: 0 : if (vkisindexed(lh->v.k)) { /* assignment to table field? */
1325 [ # # ]: 0 : if (lh->v.k == VINDEXUP) { /* is table an upvalue? */
1326 [ # # # # ]: 0 : if (v->k == VUPVAL && lh->v.u.ind.t == v->u.info) {
1327 : 0 : conflict = 1; /* table is the upvalue being assigned now */
1328 : 0 : lh->v.k = VINDEXSTR;
1329 : 0 : lh->v.u.ind.t = extra; /* assignment will use safe copy */
1330 : 0 : }
1331 : 0 : }
1332 : : else { /* table is a register */
1333 [ # # # # ]: 0 : if (v->k == VLOCAL && lh->v.u.ind.t == v->u.var.sidx) {
1334 : 0 : conflict = 1; /* table is the local being assigned now */
1335 : 0 : lh->v.u.ind.t = extra; /* assignment will use safe copy */
1336 : 0 : }
1337 : : /* is index the local being assigned? */
1338 [ # # # # : 0 : if (lh->v.k == VINDEXED && v->k == VLOCAL &&
# # ]
1339 : 0 : lh->v.u.ind.idx == v->u.var.sidx) {
1340 : 0 : conflict = 1;
1341 : 0 : lh->v.u.ind.idx = extra; /* previous assignment will use safe copy */
1342 : 0 : }
1343 : : }
1344 : 0 : }
1345 : 0 : }
1346 [ # # ]: 0 : if (conflict) {
1347 : : /* copy upvalue/local value to a temporary (in position 'extra') */
1348 [ # # ]: 0 : if (v->k == VLOCAL)
1349 : 0 : luaK_codeABC(fs, OP_MOVE, extra, v->u.var.sidx, 0);
1350 : : else
1351 : 0 : luaK_codeABC(fs, OP_GETUPVAL, extra, v->u.info, 0);
1352 : 0 : luaK_reserveregs(fs, 1);
1353 : 0 : }
1354 : 0 : }
1355 : :
1356 : : /*
1357 : : ** Parse and compile a multiple assignment. The first "variable"
1358 : : ** (a 'suffixedexp') was already read by the caller.
1359 : : **
1360 : : ** assignment -> suffixedexp restassign
1361 : : ** restassign -> ',' suffixedexp restassign | '=' explist
1362 : : */
1363 : 110 : static void restassign (LexState *ls, struct LHS_assign *lh, int nvars) {
1364 : : expdesc e;
1365 [ + - ]: 110 : check_condition(ls, vkisvar(lh->v.k), "syntax error");
1366 : 110 : check_readonly(ls, &lh->v);
1367 [ - + ]: 110 : if (testnext(ls, ',')) { /* restassign -> ',' suffixedexp restassign */
1368 : : struct LHS_assign nv;
1369 : 0 : nv.prev = lh;
1370 : 0 : suffixedexp(ls, &nv.v);
1371 [ # # # # ]: 0 : if (!vkisindexed(nv.v.k))
1372 : 0 : check_conflict(ls, lh, &nv.v);
1373 : 0 : enterlevel(ls); /* control recursion depth */
1374 : 0 : restassign(ls, &nv, nvars+1);
1375 : 0 : leavelevel(ls);
1376 : 0 : }
1377 : : else { /* restassign -> '=' explist */
1378 : : int nexps;
1379 : 110 : checknext(ls, '=');
1380 : 110 : nexps = explist(ls, &e);
1381 [ - + ]: 110 : if (nexps != nvars)
1382 : 0 : adjust_assign(ls, nvars, nexps, &e);
1383 : : else {
1384 : 110 : luaK_setoneret(ls->fs, &e); /* close last expression */
1385 : 110 : luaK_storevar(ls->fs, &lh->v, &e);
1386 : 110 : return; /* avoid default */
1387 : : }
1388 : : }
1389 : 0 : init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */
1390 : 0 : luaK_storevar(ls->fs, &lh->v, &e);
1391 : 110 : }
1392 : :
1393 : :
1394 : 0 : static int cond (LexState *ls) {
1395 : : /* cond -> exp */
1396 : : expdesc v;
1397 : 0 : expr(ls, &v); /* read condition */
1398 [ # # ]: 0 : if (v.k == VNIL) v.k = VFALSE; /* 'falses' are all equal here */
1399 : 0 : luaK_goiftrue(ls->fs, &v);
1400 : 0 : return v.f;
1401 : : }
1402 : :
1403 : :
1404 : 0 : static void gotostat (LexState *ls) {
1405 : 0 : FuncState *fs = ls->fs;
1406 : 0 : int line = ls->linenumber;
1407 : 0 : TString *name = str_checkname(ls); /* label's name */
1408 : 0 : Labeldesc *lb = findlabel(ls, name);
1409 [ # # ]: 0 : if (lb == NULL) /* no label? */
1410 : : /* forward jump; will be resolved when the label is declared */
1411 : 0 : newgotoentry(ls, name, line, luaK_jump(fs));
1412 : : else { /* found a label */
1413 : : /* backward jump; will be resolved here */
1414 : 0 : int lblevel = stacklevel(fs, lb->nactvar); /* label level */
1415 [ # # ]: 0 : if (luaY_nvarstack(fs) > lblevel) /* leaving the scope of a variable? */
1416 : 0 : luaK_codeABC(fs, OP_CLOSE, lblevel, 0, 0);
1417 : : /* create jump and link it to the label */
1418 : 0 : luaK_patchlist(fs, luaK_jump(fs), lb->pc);
1419 : : }
1420 : 0 : }
1421 : :
1422 : :
1423 : : /*
1424 : : ** Break statement. Semantically equivalent to "goto break".
1425 : : */
1426 : 0 : static void breakstat (LexState *ls) {
1427 : 0 : int line = ls->linenumber;
1428 : 0 : luaX_next(ls); /* skip break */
1429 : 0 : newgotoentry(ls, luaS_newliteral(ls->L, "break"), line, luaK_jump(ls->fs));
1430 : 0 : }
1431 : :
1432 : :
1433 : : /*
1434 : : ** Check whether there is already a label with the given 'name'.
1435 : : */
1436 : 0 : static void checkrepeated (LexState *ls, TString *name) {
1437 : 0 : Labeldesc *lb = findlabel(ls, name);
1438 [ # # ]: 0 : if (unlikely(lb != NULL)) { /* already defined? */
1439 : 0 : const char *msg = "label '%s' already defined on line %d";
1440 : 0 : msg = luaO_pushfstring(ls->L, msg, getstr(name), lb->line);
1441 : 0 : luaK_semerror(ls, msg); /* error */
1442 : : }
1443 : 0 : }
1444 : :
1445 : :
1446 : 0 : static void labelstat (LexState *ls, TString *name, int line) {
1447 : : /* label -> '::' NAME '::' */
1448 : 0 : checknext(ls, TK_DBCOLON); /* skip double colon */
1449 [ # # # # ]: 0 : while (ls->t.token == ';' || ls->t.token == TK_DBCOLON)
1450 : 0 : statement(ls); /* skip other no-op statements */
1451 : 0 : checkrepeated(ls, name); /* check for repeated labels */
1452 : 0 : createlabel(ls, name, line, block_follow(ls, 0));
1453 : 0 : }
1454 : :
1455 : :
1456 : 0 : static void whilestat (LexState *ls, int line) {
1457 : : /* whilestat -> WHILE cond DO block END */
1458 : 0 : FuncState *fs = ls->fs;
1459 : : int whileinit;
1460 : : int condexit;
1461 : : BlockCnt bl;
1462 : 0 : luaX_next(ls); /* skip WHILE */
1463 : 0 : whileinit = luaK_getlabel(fs);
1464 : 0 : condexit = cond(ls);
1465 : 0 : enterblock(fs, &bl, 1);
1466 : 0 : checknext(ls, TK_DO);
1467 : 0 : block(ls);
1468 : 0 : luaK_jumpto(fs, whileinit);
1469 : 0 : check_match(ls, TK_END, TK_WHILE, line);
1470 : 0 : leaveblock(fs);
1471 : 0 : luaK_patchtohere(fs, condexit); /* false conditions finish the loop */
1472 : 0 : }
1473 : :
1474 : :
1475 : 0 : static void repeatstat (LexState *ls, int line) {
1476 : : /* repeatstat -> REPEAT block UNTIL cond */
1477 : : int condexit;
1478 : 0 : FuncState *fs = ls->fs;
1479 : 0 : int repeat_init = luaK_getlabel(fs);
1480 : : BlockCnt bl1, bl2;
1481 : 0 : enterblock(fs, &bl1, 1); /* loop block */
1482 : 0 : enterblock(fs, &bl2, 0); /* scope block */
1483 : 0 : luaX_next(ls); /* skip REPEAT */
1484 : 0 : statlist(ls);
1485 : 0 : check_match(ls, TK_UNTIL, TK_REPEAT, line);
1486 : 0 : condexit = cond(ls); /* read condition (inside scope block) */
1487 : 0 : leaveblock(fs); /* finish scope */
1488 [ # # ]: 0 : if (bl2.upval) { /* upvalues? */
1489 : 0 : int exit = luaK_jump(fs); /* normal exit must jump over fix */
1490 : 0 : luaK_patchtohere(fs, condexit); /* repetition must close upvalues */
1491 : 0 : luaK_codeABC(fs, OP_CLOSE, stacklevel(fs, bl2.nactvar), 0, 0);
1492 : 0 : condexit = luaK_jump(fs); /* repeat after closing upvalues */
1493 : 0 : luaK_patchtohere(fs, exit); /* normal exit comes to here */
1494 : 0 : }
1495 : 0 : luaK_patchlist(fs, condexit, repeat_init); /* close the loop */
1496 : 0 : leaveblock(fs); /* finish loop */
1497 : 0 : }
1498 : :
1499 : :
1500 : : /*
1501 : : ** Read an expression and generate code to put its results in next
1502 : : ** stack slot.
1503 : : **
1504 : : */
1505 : 16 : static void exp1 (LexState *ls) {
1506 : : expdesc e;
1507 : 16 : expr(ls, &e);
1508 : 16 : luaK_exp2nextreg(ls->fs, &e);
1509 : : lua_assert(e.k == VNONRELOC);
1510 : 16 : }
1511 : :
1512 : :
1513 : : /*
1514 : : ** Fix for instruction at position 'pc' to jump to 'dest'.
1515 : : ** (Jump addresses are relative in Lua). 'back' true means
1516 : : ** a back jump.
1517 : : */
1518 : 16 : static void fixforjump (FuncState *fs, int pc, int dest, int back) {
1519 : 16 : Instruction *jmp = &fs->f->code[pc];
1520 : 16 : int offset = dest - (pc + 1);
1521 [ + + ]: 16 : if (back)
1522 : 8 : offset = -offset;
1523 [ - + ]: 16 : if (unlikely(offset > MAXARG_Bx))
1524 : 0 : luaX_syntaxerror(fs->ls, "control structure too long");
1525 : 16 : SETARG_Bx(*jmp, offset);
1526 : 16 : }
1527 : :
1528 : :
1529 : : /*
1530 : : ** Generate code for a 'for' loop.
1531 : : */
1532 : 8 : static void forbody (LexState *ls, int base, int line, int nvars, int isgen) {
1533 : : /* forbody -> DO block */
1534 : : static const OpCode forprep[2] = {OP_FORPREP, OP_TFORPREP};
1535 : : static const OpCode forloop[2] = {OP_FORLOOP, OP_TFORLOOP};
1536 : : BlockCnt bl;
1537 : 8 : FuncState *fs = ls->fs;
1538 : : int prep, endfor;
1539 : 8 : checknext(ls, TK_DO);
1540 : 8 : prep = luaK_codeABx(fs, forprep[isgen], base, 0);
1541 : 8 : enterblock(fs, &bl, 0); /* scope for declared variables */
1542 : 8 : adjustlocalvars(ls, nvars);
1543 : 8 : luaK_reserveregs(fs, nvars);
1544 : 8 : block(ls);
1545 : 8 : leaveblock(fs); /* end of scope for declared variables */
1546 : 8 : fixforjump(fs, prep, luaK_getlabel(fs), 0);
1547 [ - + ]: 8 : if (isgen) { /* generic for? */
1548 : 0 : luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars);
1549 : 0 : luaK_fixline(fs, line);
1550 : 0 : }
1551 : 8 : endfor = luaK_codeABx(fs, forloop[isgen], base, 0);
1552 : 8 : fixforjump(fs, endfor, prep + 1, 1);
1553 : 8 : luaK_fixline(fs, line);
1554 : 8 : }
1555 : :
1556 : :
1557 : 8 : static void fornum (LexState *ls, TString *varname, int line) {
1558 : : /* fornum -> NAME = exp,exp[,exp] forbody */
1559 : 8 : FuncState *fs = ls->fs;
1560 : 8 : int base = fs->freereg;
1561 : 8 : new_localvarliteral(ls, "(for state)");
1562 : 8 : new_localvarliteral(ls, "(for state)");
1563 : 8 : new_localvarliteral(ls, "(for state)");
1564 : 8 : new_localvar(ls, varname);
1565 : 8 : checknext(ls, '=');
1566 : 8 : exp1(ls); /* initial value */
1567 : 8 : checknext(ls, ',');
1568 : 8 : exp1(ls); /* limit */
1569 [ - + ]: 8 : if (testnext(ls, ','))
1570 : 0 : exp1(ls); /* optional step */
1571 : : else { /* default step = 1 */
1572 : 8 : luaK_int(fs, fs->freereg, 1);
1573 : 8 : luaK_reserveregs(fs, 1);
1574 : : }
1575 : 8 : adjustlocalvars(ls, 3); /* control variables */
1576 : 8 : forbody(ls, base, line, 1, 0);
1577 : 8 : }
1578 : :
1579 : :
1580 : 0 : static void forlist (LexState *ls, TString *indexname) {
1581 : : /* forlist -> NAME {,NAME} IN explist forbody */
1582 : 0 : FuncState *fs = ls->fs;
1583 : : expdesc e;
1584 : 0 : int nvars = 5; /* gen, state, control, toclose, 'indexname' */
1585 : : int line;
1586 : 0 : int base = fs->freereg;
1587 : : /* create control variables */
1588 : 0 : new_localvarliteral(ls, "(for state)");
1589 : 0 : new_localvarliteral(ls, "(for state)");
1590 : 0 : new_localvarliteral(ls, "(for state)");
1591 : 0 : new_localvarliteral(ls, "(for state)");
1592 : : /* create declared variables */
1593 : 0 : new_localvar(ls, indexname);
1594 [ # # ]: 0 : while (testnext(ls, ',')) {
1595 : 0 : new_localvar(ls, str_checkname(ls));
1596 : 0 : nvars++;
1597 : : }
1598 : 0 : checknext(ls, TK_IN);
1599 : 0 : line = ls->linenumber;
1600 : 0 : adjust_assign(ls, 4, explist(ls, &e), &e);
1601 : 0 : adjustlocalvars(ls, 4); /* control variables */
1602 : 0 : markupval(fs, fs->nactvar); /* last control var. must be closed */
1603 : 0 : luaK_checkstack(fs, 3); /* extra space to call generator */
1604 : 0 : forbody(ls, base, line, nvars - 4, 1);
1605 : 0 : }
1606 : :
1607 : :
1608 : 8 : static void forstat (LexState *ls, int line) {
1609 : : /* forstat -> FOR (fornum | forlist) END */
1610 : 8 : FuncState *fs = ls->fs;
1611 : : TString *varname;
1612 : : BlockCnt bl;
1613 : 8 : enterblock(fs, &bl, 1); /* scope for loop and control variables */
1614 : 8 : luaX_next(ls); /* skip 'for' */
1615 : 8 : varname = str_checkname(ls); /* first variable name */
1616 [ - - + ]: 8 : switch (ls->t.token) {
1617 : 8 : case '=': fornum(ls, varname, line); break;
1618 : 0 : case ',': case TK_IN: forlist(ls, varname); break;
1619 : 0 : default: luaX_syntaxerror(ls, "'=' or 'in' expected");
1620 : : }
1621 : 8 : check_match(ls, TK_END, TK_FOR, line);
1622 : 8 : leaveblock(fs); /* loop scope ('break' jumps to this point) */
1623 : 8 : }
1624 : :
1625 : :
1626 : 203 : static void test_then_block (LexState *ls, int *escapelist) {
1627 : : /* test_then_block -> [IF | ELSEIF] cond THEN block */
1628 : : BlockCnt bl;
1629 : 203 : FuncState *fs = ls->fs;
1630 : : expdesc v;
1631 : : int jf; /* instruction to skip 'then' code (if condition is false) */
1632 : 203 : luaX_next(ls); /* skip IF or ELSEIF */
1633 : 203 : expr(ls, &v); /* read condition */
1634 : 203 : checknext(ls, TK_THEN);
1635 [ - + ]: 203 : if (ls->t.token == TK_BREAK) { /* 'if x then break' ? */
1636 : 0 : int line = ls->linenumber;
1637 : 0 : luaK_goiffalse(ls->fs, &v); /* will jump if condition is true */
1638 : 0 : luaX_next(ls); /* skip 'break' */
1639 : 0 : enterblock(fs, &bl, 0); /* must enter block before 'goto' */
1640 : 0 : newgotoentry(ls, luaS_newliteral(ls->L, "break"), line, v.t);
1641 [ # # ]: 0 : while (testnext(ls, ';')) {} /* skip semicolons */
1642 [ # # ]: 0 : if (block_follow(ls, 0)) { /* jump is the entire block? */
1643 : 0 : leaveblock(fs);
1644 : 0 : return; /* and that is it */
1645 : : }
1646 : : else /* must skip over 'then' part if condition is false */
1647 : 0 : jf = luaK_jump(fs);
1648 : 0 : }
1649 : : else { /* regular case (not a break) */
1650 : 203 : luaK_goiftrue(ls->fs, &v); /* skip over block if condition is false */
1651 : 203 : enterblock(fs, &bl, 0);
1652 : 203 : jf = v.f;
1653 : : }
1654 : 203 : statlist(ls); /* 'then' part */
1655 : 203 : leaveblock(fs);
1656 [ + - - + ]: 203 : if (ls->t.token == TK_ELSE ||
1657 : 203 : ls->t.token == TK_ELSEIF) /* followed by 'else'/'elseif'? */
1658 : 0 : luaK_concat(fs, escapelist, luaK_jump(fs)); /* must jump over it */
1659 : 203 : luaK_patchtohere(fs, jf);
1660 : 203 : }
1661 : :
1662 : :
1663 : 203 : static void ifstat (LexState *ls, int line) {
1664 : : /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
1665 : 203 : FuncState *fs = ls->fs;
1666 : 203 : int escapelist = NO_JUMP; /* exit list for finished parts */
1667 : 203 : test_then_block(ls, &escapelist); /* IF cond THEN block */
1668 [ + - ]: 203 : while (ls->t.token == TK_ELSEIF)
1669 : 0 : test_then_block(ls, &escapelist); /* ELSEIF cond THEN block */
1670 [ - + ]: 203 : if (testnext(ls, TK_ELSE))
1671 : 0 : block(ls); /* 'else' part */
1672 : 203 : check_match(ls, TK_END, TK_IF, line);
1673 : 203 : luaK_patchtohere(fs, escapelist); /* patch escape list to 'if' end */
1674 : 203 : }
1675 : :
1676 : :
1677 : 0 : static void localfunc (LexState *ls) {
1678 : : expdesc b;
1679 : 0 : FuncState *fs = ls->fs;
1680 : 0 : int fvar = fs->nactvar; /* function's variable index */
1681 : 0 : new_localvar(ls, str_checkname(ls)); /* new local variable */
1682 : 0 : adjustlocalvars(ls, 1); /* enter its scope */
1683 : 0 : body(ls, &b, 0, ls->linenumber); /* function created in next register */
1684 : : /* debug information will only see the variable after this point! */
1685 : 0 : localdebuginfo(fs, fvar)->startpc = fs->pc;
1686 : 0 : }
1687 : :
1688 : :
1689 : 0 : static int getlocalattribute (LexState *ls) {
1690 : : /* ATTRIB -> ['<' Name '>'] */
1691 [ # # ]: 0 : if (testnext(ls, '<')) {
1692 : 0 : const char *attr = getstr(str_checkname(ls));
1693 : 0 : checknext(ls, '>');
1694 [ # # ]: 0 : if (strcmp(attr, "const") == 0)
1695 : 0 : return RDKCONST; /* read-only variable */
1696 [ # # ]: 0 : else if (strcmp(attr, "close") == 0)
1697 : 0 : return RDKTOCLOSE; /* to-be-closed variable */
1698 : : else
1699 : 0 : luaK_semerror(ls,
1700 : 0 : luaO_pushfstring(ls->L, "unknown attribute '%s'", attr));
1701 : : }
1702 : 0 : return VDKREG; /* regular variable */
1703 : 0 : }
1704 : :
1705 : :
1706 : 0 : static void checktoclose (LexState *ls, int level) {
1707 [ # # ]: 0 : if (level != -1) { /* is there a to-be-closed variable? */
1708 : 0 : FuncState *fs = ls->fs;
1709 : 0 : markupval(fs, level + 1);
1710 : 0 : fs->bl->insidetbc = 1; /* in the scope of a to-be-closed variable */
1711 : 0 : luaK_codeABC(fs, OP_TBC, stacklevel(fs, level), 0, 0);
1712 : 0 : }
1713 : 0 : }
1714 : :
1715 : :
1716 : 0 : static void localstat (LexState *ls) {
1717 : : /* stat -> LOCAL NAME ATTRIB { ',' NAME ATTRIB } ['=' explist] */
1718 : 0 : FuncState *fs = ls->fs;
1719 : 0 : int toclose = -1; /* index of to-be-closed variable (if any) */
1720 : : Vardesc *var; /* last variable */
1721 : : int vidx, kind; /* index and kind of last variable */
1722 : 0 : int nvars = 0;
1723 : : int nexps;
1724 : : expdesc e;
1725 : 0 : do {
1726 : 0 : vidx = new_localvar(ls, str_checkname(ls));
1727 : 0 : kind = getlocalattribute(ls);
1728 : 0 : getlocalvardesc(fs, vidx)->vd.kind = kind;
1729 [ # # ]: 0 : if (kind == RDKTOCLOSE) { /* to-be-closed? */
1730 [ # # ]: 0 : if (toclose != -1) /* one already present? */
1731 : 0 : luaK_semerror(ls, "multiple to-be-closed variables in local list");
1732 : 0 : toclose = fs->nactvar + nvars;
1733 : 0 : }
1734 : 0 : nvars++;
1735 [ # # ]: 0 : } while (testnext(ls, ','));
1736 [ # # ]: 0 : if (testnext(ls, '='))
1737 : 0 : nexps = explist(ls, &e);
1738 : : else {
1739 : 0 : e.k = VVOID;
1740 : 0 : nexps = 0;
1741 : : }
1742 : 0 : var = getlocalvardesc(fs, vidx); /* get last variable */
1743 [ # # # # ]: 0 : if (nvars == nexps && /* no adjustments? */
1744 [ # # ]: 0 : var->vd.kind == RDKCONST && /* last variable is const? */
1745 : 0 : luaK_exp2const(fs, &e, &var->k)) { /* compile-time constant? */
1746 : 0 : var->vd.kind = RDKCTC; /* variable is a compile-time constant */
1747 : 0 : adjustlocalvars(ls, nvars - 1); /* exclude last variable */
1748 : 0 : fs->nactvar++; /* but count it */
1749 : 0 : }
1750 : : else {
1751 : 0 : adjust_assign(ls, nvars, nexps, &e);
1752 : 0 : adjustlocalvars(ls, nvars);
1753 : : }
1754 : 0 : checktoclose(ls, toclose);
1755 : 0 : }
1756 : :
1757 : :
1758 : 0 : static int funcname (LexState *ls, expdesc *v) {
1759 : : /* funcname -> NAME {fieldsel} [':' NAME] */
1760 : 0 : int ismethod = 0;
1761 : 0 : singlevar(ls, v);
1762 [ # # ]: 0 : while (ls->t.token == '.')
1763 : 0 : fieldsel(ls, v);
1764 [ # # ]: 0 : if (ls->t.token == ':') {
1765 : 0 : ismethod = 1;
1766 : 0 : fieldsel(ls, v);
1767 : 0 : }
1768 : 0 : return ismethod;
1769 : : }
1770 : :
1771 : :
1772 : 0 : static void funcstat (LexState *ls, int line) {
1773 : : /* funcstat -> FUNCTION funcname body */
1774 : : int ismethod;
1775 : : expdesc v, b;
1776 : 0 : luaX_next(ls); /* skip FUNCTION */
1777 : 0 : ismethod = funcname(ls, &v);
1778 : 0 : body(ls, &b, ismethod, line);
1779 : 0 : luaK_storevar(ls->fs, &v, &b);
1780 : 0 : luaK_fixline(ls->fs, line); /* definition "happens" in the first line */
1781 : 0 : }
1782 : :
1783 : :
1784 : 712 : static void exprstat (LexState *ls) {
1785 : : /* stat -> func | assignment */
1786 : 712 : FuncState *fs = ls->fs;
1787 : : struct LHS_assign v;
1788 : 712 : suffixedexp(ls, &v.v);
1789 [ + + - + ]: 712 : if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */
1790 : 110 : v.prev = NULL;
1791 : 110 : restassign(ls, &v, 1);
1792 : 110 : }
1793 : : else { /* stat -> func */
1794 : : Instruction *inst;
1795 [ + - ]: 602 : check_condition(ls, v.v.k == VCALL, "syntax error");
1796 : 602 : inst = &getinstruction(fs, &v.v);
1797 : 602 : SETARG_C(*inst, 1); /* call statement uses no results */
1798 : : }
1799 : 712 : }
1800 : :
1801 : :
1802 : 168 : static void retstat (LexState *ls) {
1803 : : /* stat -> RETURN [explist] [';'] */
1804 : 168 : FuncState *fs = ls->fs;
1805 : : expdesc e;
1806 : : int nret; /* number of values being returned */
1807 : 168 : int first = luaY_nvarstack(fs); /* first slot to be returned */
1808 [ + - - + ]: 168 : if (block_follow(ls, 1) || ls->t.token == ';')
1809 : 0 : nret = 0; /* return no values */
1810 : : else {
1811 : 168 : nret = explist(ls, &e); /* optional return values */
1812 [ + + - + ]: 168 : if (hasmultret(e.k)) {
1813 : 78 : luaK_setmultret(fs, &e);
1814 [ + - + - : 78 : if (e.k == VCALL && nret == 1 && !fs->bl->insidetbc) { /* tail call? */
+ - ]
1815 : 78 : SET_OPCODE(getinstruction(fs,&e), OP_TAILCALL);
1816 : : lua_assert(GETARG_A(getinstruction(fs,&e)) == luaY_nvarstack(fs));
1817 : 78 : }
1818 : 78 : nret = LUA_MULTRET; /* return all values */
1819 : 78 : }
1820 : : else {
1821 [ + - ]: 90 : if (nret == 1) /* only one single value? */
1822 : 90 : first = luaK_exp2anyreg(fs, &e); /* can use original slot */
1823 : : else { /* values must go to the top of the stack */
1824 : 0 : luaK_exp2nextreg(fs, &e);
1825 : : lua_assert(nret == fs->freereg - first);
1826 : : }
1827 : : }
1828 : : }
1829 : 168 : luaK_ret(fs, first, nret);
1830 : 168 : testnext(ls, ';'); /* skip optional semicolon */
1831 : 168 : }
1832 : :
1833 : :
1834 : 1095 : static void statement (LexState *ls) {
1835 : 1095 : int line = ls->linenumber; /* may be needed for error messages */
1836 : 1095 : enterlevel(ls);
1837 [ - + + - : 1095 : switch (ls->t.token) {
- + - - -
- + - - ]
1838 : : case ';': { /* stat -> ';' (empty statement) */
1839 : 0 : luaX_next(ls); /* skip ';' */
1840 : 0 : break;
1841 : : }
1842 : : case TK_IF: { /* stat -> ifstat */
1843 : 203 : ifstat(ls, line);
1844 : 203 : break;
1845 : : }
1846 : : case TK_WHILE: { /* stat -> whilestat */
1847 : 0 : whilestat(ls, line);
1848 : 0 : break;
1849 : : }
1850 : : case TK_DO: { /* stat -> DO block END */
1851 : 0 : luaX_next(ls); /* skip DO */
1852 : 0 : block(ls);
1853 : 0 : check_match(ls, TK_END, TK_DO, line);
1854 : 0 : break;
1855 : : }
1856 : : case TK_FOR: { /* stat -> forstat */
1857 : 8 : forstat(ls, line);
1858 : 8 : break;
1859 : : }
1860 : : case TK_REPEAT: { /* stat -> repeatstat */
1861 : 0 : repeatstat(ls, line);
1862 : 0 : break;
1863 : : }
1864 : : case TK_FUNCTION: { /* stat -> funcstat */
1865 : 0 : funcstat(ls, line);
1866 : 0 : break;
1867 : : }
1868 : : case TK_LOCAL: { /* stat -> localstat */
1869 : 0 : luaX_next(ls); /* skip LOCAL */
1870 [ # # ]: 0 : if (testnext(ls, TK_FUNCTION)) /* local function? */
1871 : 0 : localfunc(ls);
1872 : : else
1873 : 0 : localstat(ls);
1874 : 0 : break;
1875 : : }
1876 : : case TK_DBCOLON: { /* stat -> label */
1877 : 0 : luaX_next(ls); /* skip double colon */
1878 : 0 : labelstat(ls, str_checkname(ls), line);
1879 : 0 : break;
1880 : : }
1881 : : case TK_RETURN: { /* stat -> retstat */
1882 : 168 : luaX_next(ls); /* skip RETURN */
1883 : 168 : retstat(ls);
1884 : 168 : break;
1885 : : }
1886 : : case TK_BREAK: { /* stat -> breakstat */
1887 : 0 : breakstat(ls);
1888 : 0 : break;
1889 : : }
1890 : : case TK_GOTO: { /* stat -> 'goto' NAME */
1891 : 0 : luaX_next(ls); /* skip 'goto' */
1892 : 0 : gotostat(ls);
1893 : 0 : break;
1894 : : }
1895 : : default: { /* stat -> func | assignment */
1896 : 716 : exprstat(ls);
1897 : 716 : break;
1898 : : }
1899 : : }
1900 : : lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
1901 : : ls->fs->freereg >= luaY_nvarstack(ls->fs));
1902 : 1095 : ls->fs->freereg = luaY_nvarstack(ls->fs); /* free registers */
1903 : 1095 : leavelevel(ls);
1904 : 1095 : }
1905 : :
1906 : : /* }====================================================================== */
1907 : :
1908 : :
1909 : : /*
1910 : : ** compiles the main function, which is a regular vararg function with an
1911 : : ** upvalue named LUA_ENV
1912 : : */
1913 : 656 : static void mainfunc (LexState *ls, FuncState *fs) {
1914 : : BlockCnt bl;
1915 : : Upvaldesc *env;
1916 : 656 : open_func(ls, fs, &bl);
1917 : 656 : setvararg(fs, 0); /* main function is always declared vararg */
1918 : 656 : env = allocupvalue(fs); /* ...set environment upvalue */
1919 : 656 : env->instack = 1;
1920 : 656 : env->idx = 0;
1921 : 656 : env->kind = VDKREG;
1922 : 656 : env->name = ls->envn;
1923 [ - + # # ]: 656 : luaC_objbarrier(ls->L, fs->f, env->name);
1924 : 656 : luaX_next(ls); /* read first token */
1925 : 656 : statlist(ls); /* parse main body */
1926 : 656 : check(ls, TK_EOS);
1927 : 656 : close_func(ls);
1928 : 656 : }
1929 : :
1930 : :
1931 : 656 : LClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff,
1932 : : Dyndata *dyd, const char *name, int firstchar) {
1933 : : LexState lexstate;
1934 : : FuncState funcstate;
1935 : 656 : LClosure *cl = luaF_newLclosure(L, 1); /* create main closure */
1936 : 656 : setclLvalue2s(L, L->top, cl); /* anchor it (to avoid being collected) */
1937 : 656 : luaD_inctop(L);
1938 : 656 : lexstate.h = luaH_new(L); /* create table for scanner */
1939 : 656 : sethvalue2s(L, L->top, lexstate.h); /* anchor it */
1940 : 656 : luaD_inctop(L);
1941 : 656 : funcstate.f = cl->p = luaF_newproto(L);
1942 [ - + # # ]: 656 : luaC_objbarrier(L, cl, cl->p);
1943 : 656 : funcstate.f->source = luaS_new(L, name); /* create and anchor TString */
1944 [ - + # # ]: 656 : luaC_objbarrier(L, funcstate.f, funcstate.f->source);
1945 : 656 : lexstate.buff = buff;
1946 : 656 : lexstate.dyd = dyd;
1947 : 656 : dyd->actvar.n = dyd->gt.n = dyd->label.n = 0;
1948 : 656 : luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar);
1949 : 656 : mainfunc(&lexstate, &funcstate);
1950 : : lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs);
1951 : : /* all scopes should be correctly finished */
1952 : : lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0);
1953 : 656 : L->top--; /* remove scanner's table */
1954 : 656 : return cl; /* closure is on the stack, too */
1955 : : }
1956 : :
|
