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