?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'master' into v2.1
[luajit-2.0.git] / src / lj_parse.c
blobe326432abb4490ac3c53403868caa568fcf5425b
1 /*
2 ** Lua parser (source code -> bytecode).
3 ** Copyright (C) 2005-2025 Mike Pall. See Copyright Notice in luajit.h
4 **
5 ** Major portions taken verbatim or adapted from the Lua interpreter.
6 ** Copyright (C) 1994-2008 Lua.org, PUC-Rio. See Copyright Notice in lua.h
7 */
8
9 #define lj_parse_c
10 #define LUA_CORE
11
12 #include "lj_obj.h"
13 #include "lj_gc.h"
14 #include "lj_err.h"
15 #include "lj_debug.h"
16 #include "lj_buf.h"
17 #include "lj_str.h"
18 #include "lj_tab.h"
19 #include "lj_func.h"
20 #include "lj_state.h"
21 #include "lj_bc.h"
22 #if LJ_HASFFI
23 #include "lj_ctype.h"
24 #endif
25 #include "lj_strfmt.h"
26 #include "lj_lex.h"
27 #include "lj_parse.h"
28 #include "lj_vm.h"
29 #include "lj_vmevent.h"
30
31 /* -- Parser structures and definitions ----------------------------------- */
32
33 /* Expression kinds. */
34 typedef enum {
35 /* Constant expressions must be first and in this order: */
36 VKNIL,
37 VKFALSE,
38 VKTRUE,
39 VKSTR, /* sval = string value */
40 VKNUM, /* nval = number value */
41 VKLAST = VKNUM,
42 VKCDATA, /* nval = cdata value, not treated as a constant expression */
43 /* Non-constant expressions follow: */
44 VLOCAL, /* info = local register, aux = vstack index */
45 VUPVAL, /* info = upvalue index, aux = vstack index */
46 VGLOBAL, /* sval = string value */
47 VINDEXED, /* info = table register, aux = index reg/byte/string const */
48 VJMP, /* info = instruction PC */
49 VRELOCABLE, /* info = instruction PC */
50 VNONRELOC, /* info = result register */
51 VCALL, /* info = instruction PC, aux = base */
52 VVOID
53 } ExpKind;
54
55 /* Expression descriptor. */
56 typedef struct ExpDesc {
57 union {
58 struct {
59 uint32_t info; /* Primary info. */
60 uint32_t aux; /* Secondary info. */
61 } s;
62 TValue nval; /* Number value. */
63 GCstr *sval; /* String value. */
64 } u;
65 ExpKind k;
66 BCPos t; /* True condition jump list. */
67 BCPos f; /* False condition jump list. */
68 } ExpDesc;
69
70 /* Macros for expressions. */
71 #define expr_hasjump(e) ((e)->t != (e)->f)
72
73 #define expr_isk(e) ((e)->k <= VKLAST)
74 #define expr_isk_nojump(e) (expr_isk(e) && !expr_hasjump(e))
75 #define expr_isnumk(e) ((e)->k == VKNUM)
76 #define expr_isnumk_nojump(e) (expr_isnumk(e) && !expr_hasjump(e))
77 #define expr_isstrk(e) ((e)->k == VKSTR)
78
79 #define expr_numtv(e) check_exp(expr_isnumk((e)), &(e)->u.nval)
80 #define expr_numberV(e) numberVnum(expr_numtv((e)))
81
82 /* Initialize expression. */
83 static LJ_AINLINE void expr_init(ExpDesc *e, ExpKind k, uint32_t info)
84 {
85 e->k = k;
86 e->u.s.info = info;
87 e->f = e->t = NO_JMP;
88 }
89
90 /* Check number constant for +-0. */
91 static int expr_numiszero(ExpDesc *e)
92 {
93 TValue *o = expr_numtv(e);
94 return tvisint(o) ? (intV(o) == 0) : tviszero(o);
95 }
96
97 /* Per-function linked list of scope blocks. */
98 typedef struct FuncScope {
99 struct FuncScope *prev; /* Link to outer scope. */
100 MSize vstart; /* Start of block-local variables. */
101 uint8_t nactvar; /* Number of active vars outside the scope. */
102 uint8_t flags; /* Scope flags. */
103 } FuncScope;
104
105 #define FSCOPE_LOOP 0x01 /* Scope is a (breakable) loop. */
106 #define FSCOPE_BREAK 0x02 /* Break used in scope. */
107 #define FSCOPE_GOLA 0x04 /* Goto or label used in scope. */
108 #define FSCOPE_UPVAL 0x08 /* Upvalue in scope. */
109 #define FSCOPE_NOCLOSE 0x10 /* Do not close upvalues. */
110
111 #define NAME_BREAK ((GCstr *)(uintptr_t)1)
112
113 /* Index into variable stack. */
114 typedef uint16_t VarIndex;
115 #define LJ_MAX_VSTACK (65536 - LJ_MAX_UPVAL)
116
117 /* Variable/goto/label info. */
118 #define VSTACK_VAR_RW 0x01 /* R/W variable. */
119 #define VSTACK_GOTO 0x02 /* Pending goto. */
120 #define VSTACK_LABEL 0x04 /* Label. */
121
122 /* Per-function state. */
123 typedef struct FuncState {
124 GCtab *kt; /* Hash table for constants. */
125 LexState *ls; /* Lexer state. */
126 lua_State *L; /* Lua state. */
127 FuncScope *bl; /* Current scope. */
128 struct FuncState *prev; /* Enclosing function. */
129 BCPos pc; /* Next bytecode position. */
130 BCPos lasttarget; /* Bytecode position of last jump target. */
131 BCPos jpc; /* Pending jump list to next bytecode. */
132 BCReg freereg; /* First free register. */
133 BCReg nactvar; /* Number of active local variables. */
134 BCReg nkn, nkgc; /* Number of lua_Number/GCobj constants */
135 BCLine linedefined; /* First line of the function definition. */
136 BCInsLine *bcbase; /* Base of bytecode stack. */
137 BCPos bclim; /* Limit of bytecode stack. */
138 MSize vbase; /* Base of variable stack for this function. */
139 uint8_t flags; /* Prototype flags. */
140 uint8_t numparams; /* Number of parameters. */
141 uint8_t framesize; /* Fixed frame size. */
142 uint8_t nuv; /* Number of upvalues */
143 VarIndex varmap[LJ_MAX_LOCVAR]; /* Map from register to variable idx. */
144 VarIndex uvmap[LJ_MAX_UPVAL]; /* Map from upvalue to variable idx. */
145 VarIndex uvtmp[LJ_MAX_UPVAL]; /* Temporary upvalue map. */
146 } FuncState;
147
148 /* Binary and unary operators. ORDER OPR */
149 typedef enum BinOpr {
150 OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW, /* ORDER ARITH */
151 OPR_CONCAT,
152 OPR_NE, OPR_EQ,
153 OPR_LT, OPR_GE, OPR_LE, OPR_GT,
154 OPR_AND, OPR_OR,
155 OPR_NOBINOPR
156 } BinOpr;
157
158 LJ_STATIC_ASSERT((int)BC_ISGE-(int)BC_ISLT == (int)OPR_GE-(int)OPR_LT);
159 LJ_STATIC_ASSERT((int)BC_ISLE-(int)BC_ISLT == (int)OPR_LE-(int)OPR_LT);
160 LJ_STATIC_ASSERT((int)BC_ISGT-(int)BC_ISLT == (int)OPR_GT-(int)OPR_LT);
161 LJ_STATIC_ASSERT((int)BC_SUBVV-(int)BC_ADDVV == (int)OPR_SUB-(int)OPR_ADD);
162 LJ_STATIC_ASSERT((int)BC_MULVV-(int)BC_ADDVV == (int)OPR_MUL-(int)OPR_ADD);
163 LJ_STATIC_ASSERT((int)BC_DIVVV-(int)BC_ADDVV == (int)OPR_DIV-(int)OPR_ADD);
164 LJ_STATIC_ASSERT((int)BC_MODVV-(int)BC_ADDVV == (int)OPR_MOD-(int)OPR_ADD);
165
166 #ifdef LUA_USE_ASSERT
167 #define lj_assertFS(c, ...) (lj_assertG_(G(fs->L), (c), __VA_ARGS__))
168 #else
169 #define lj_assertFS(c, ...) ((void)fs)
170 #endif
171
172 /* -- Error handling ------------------------------------------------------ */
173
174 LJ_NORET LJ_NOINLINE static void err_syntax(LexState *ls, ErrMsg em)
175 {
176 lj_lex_error(ls, ls->tok, em);
177 }
178
179 LJ_NORET LJ_NOINLINE static void err_token(LexState *ls, LexToken tok)
180 {
181 lj_lex_error(ls, ls->tok, LJ_ERR_XTOKEN, lj_lex_token2str(ls, tok));
182 }
183
184 LJ_NORET static void err_limit(FuncState *fs, uint32_t limit, const char *what)
185 {
186 if (fs->linedefined == 0)
187 lj_lex_error(fs->ls, 0, LJ_ERR_XLIMM, limit, what);
188 else
189 lj_lex_error(fs->ls, 0, LJ_ERR_XLIMF, fs->linedefined, limit, what);
190 }
191
192 #define checklimit(fs, v, l, m) if ((v) >= (l)) err_limit(fs, l, m)
193 #define checklimitgt(fs, v, l, m) if ((v) > (l)) err_limit(fs, l, m)
194 #define checkcond(ls, c, em) { if (!(c)) err_syntax(ls, em); }
195
196 /* -- Management of constants --------------------------------------------- */
197
198 /* Return bytecode encoding for primitive constant. */
199 #define const_pri(e) check_exp((e)->k <= VKTRUE, (e)->k)
200
201 #define tvhaskslot(o) ((o)->u32.hi == 0)
202 #define tvkslot(o) ((o)->u32.lo)
203
204 /* Add a number constant. */
205 static BCReg const_num(FuncState *fs, ExpDesc *e)
206 {
207 lua_State *L = fs->L;
208 TValue *o;
209 lj_assertFS(expr_isnumk(e), "bad usage");
210 o = lj_tab_set(L, fs->kt, &e->u.nval);
211 if (tvhaskslot(o))
212 return tvkslot(o);
213 o->u64 = fs->nkn;
214 return fs->nkn++;
215 }
216
217 /* Add a GC object constant. */
218 static BCReg const_gc(FuncState *fs, GCobj *gc, uint32_t itype)
219 {
220 lua_State *L = fs->L;
221 TValue key, *o;
222 setgcV(L, &key, gc, itype);
223 /* NOBARRIER: the key is new or kept alive. */
224 o = lj_tab_set(L, fs->kt, &key);
225 if (tvhaskslot(o))
226 return tvkslot(o);
227 o->u64 = fs->nkgc;
228 return fs->nkgc++;
229 }
230
231 /* Add a string constant. */
232 static BCReg const_str(FuncState *fs, ExpDesc *e)
233 {
234 lj_assertFS(expr_isstrk(e) || e->k == VGLOBAL, "bad usage");
235 return const_gc(fs, obj2gco(e->u.sval), LJ_TSTR);
236 }
237
238 /* Anchor string constant to avoid GC. */
239 GCstr *lj_parse_keepstr(LexState *ls, const char *str, size_t len)
240 {
241 /* NOBARRIER: the key is new or kept alive. */
242 lua_State *L = ls->L;
243 GCstr *s = lj_str_new(L, str, len);
244 TValue *tv = lj_tab_setstr(L, ls->fs->kt, s);
245 if (tvisnil(tv)) setboolV(tv, 1);
246 lj_gc_check(L);
247 return s;
248 }
249
250 #if LJ_HASFFI
251 /* Anchor cdata to avoid GC. */
252 void lj_parse_keepcdata(LexState *ls, TValue *tv, GCcdata *cd)
253 {
254 /* NOBARRIER: the key is new or kept alive. */
255 lua_State *L = ls->L;
256 setcdataV(L, tv, cd);
257 setboolV(lj_tab_set(L, ls->fs->kt, tv), 1);
258 }
259 #endif
260
261 /* -- Jump list handling -------------------------------------------------- */
262
263 /* Get next element in jump list. */
264 static BCPos jmp_next(FuncState *fs, BCPos pc)
265 {
266 ptrdiff_t delta = bc_j(fs->bcbase[pc].ins);
267 if ((BCPos)delta == NO_JMP)
268 return NO_JMP;
269 else
270 return (BCPos)(((ptrdiff_t)pc+1)+delta);
271 }
272
273 /* Check if any of the instructions on the jump list produce no value. */
274 static int jmp_novalue(FuncState *fs, BCPos list)
275 {
276 for (; list != NO_JMP; list = jmp_next(fs, list)) {
277 BCIns p = fs->bcbase[list >= 1 ? list-1 : list].ins;
278 if (!(bc_op(p) == BC_ISTC || bc_op(p) == BC_ISFC || bc_a(p) == NO_REG))
279 return 1;
280 }
281 return 0;
282 }
283
284 /* Patch register of test instructions. */
285 static int jmp_patchtestreg(FuncState *fs, BCPos pc, BCReg reg)
286 {
287 BCInsLine *ilp = &fs->bcbase[pc >= 1 ? pc-1 : pc];
288 BCOp op = bc_op(ilp->ins);
289 if (op == BC_ISTC || op == BC_ISFC) {
290 if (reg != NO_REG && reg != bc_d(ilp->ins)) {
291 setbc_a(&ilp->ins, reg);
292 } else { /* Nothing to store or already in the right register. */
293 setbc_op(&ilp->ins, op+(BC_IST-BC_ISTC));
294 setbc_a(&ilp->ins, 0);
295 }
296 } else if (bc_a(ilp->ins) == NO_REG) {
297 if (reg == NO_REG) {
298 ilp->ins = BCINS_AJ(BC_JMP, bc_a(fs->bcbase[pc].ins), 0);
299 } else {
300 setbc_a(&ilp->ins, reg);
301 if (reg >= bc_a(ilp[1].ins))
302 setbc_a(&ilp[1].ins, reg+1);
303 }
304 } else {
305 return 0; /* Cannot patch other instructions. */
306 }
307 return 1;
308 }
309
310 /* Drop values for all instructions on jump list. */
311 static void jmp_dropval(FuncState *fs, BCPos list)
312 {
313 for (; list != NO_JMP; list = jmp_next(fs, list))
314 jmp_patchtestreg(fs, list, NO_REG);
315 }
316
317 /* Patch jump instruction to target. */
318 static void jmp_patchins(FuncState *fs, BCPos pc, BCPos dest)
319 {
320 BCIns *jmp = &fs->bcbase[pc].ins;
321 BCPos offset = dest-(pc+1)+BCBIAS_J;
322 lj_assertFS(dest != NO_JMP, "uninitialized jump target");
323 if (offset > BCMAX_D)
324 err_syntax(fs->ls, LJ_ERR_XJUMP);
325 setbc_d(jmp, offset);
326 }
327
328 /* Append to jump list. */
329 static void jmp_append(FuncState *fs, BCPos *l1, BCPos l2)
330 {
331 if (l2 == NO_JMP) {
332 return;
333 } else if (*l1 == NO_JMP) {
334 *l1 = l2;
335 } else {
336 BCPos list = *l1;
337 BCPos next;
338 while ((next = jmp_next(fs, list)) != NO_JMP) /* Find last element. */
339 list = next;
340 jmp_patchins(fs, list, l2);
341 }
342 }
343
344 /* Patch jump list and preserve produced values. */
345 static void jmp_patchval(FuncState *fs, BCPos list, BCPos vtarget,
346 BCReg reg, BCPos dtarget)
347 {
348 while (list != NO_JMP) {
349 BCPos next = jmp_next(fs, list);
350 if (jmp_patchtestreg(fs, list, reg))
351 jmp_patchins(fs, list, vtarget); /* Jump to target with value. */
352 else
353 jmp_patchins(fs, list, dtarget); /* Jump to default target. */
354 list = next;
355 }
356 }
357
358 /* Jump to following instruction. Append to list of pending jumps. */
359 static void jmp_tohere(FuncState *fs, BCPos list)
360 {
361 fs->lasttarget = fs->pc;
362 jmp_append(fs, &fs->jpc, list);
363 }
364
365 /* Patch jump list to target. */
366 static void jmp_patch(FuncState *fs, BCPos list, BCPos target)
367 {
368 if (target == fs->pc) {
369 jmp_tohere(fs, list);
370 } else {
371 lj_assertFS(target < fs->pc, "bad jump target");
372 jmp_patchval(fs, list, target, NO_REG, target);
373 }
374 }
375
376 /* -- Bytecode register allocator ----------------------------------------- */
377
378 /* Bump frame size. */
379 static void bcreg_bump(FuncState *fs, BCReg n)
380 {
381 BCReg sz = fs->freereg + n;
382 if (sz > fs->framesize) {
383 if (sz >= LJ_MAX_SLOTS)
384 err_syntax(fs->ls, LJ_ERR_XSLOTS);
385 fs->framesize = (uint8_t)sz;
386 }
387 }
388
389 /* Reserve registers. */
390 static void bcreg_reserve(FuncState *fs, BCReg n)
391 {
392 bcreg_bump(fs, n);
393 fs->freereg += n;
394 }
395
396 /* Free register. */
397 static void bcreg_free(FuncState *fs, BCReg reg)
398 {
399 if (reg >= fs->nactvar) {
400 fs->freereg--;
401 lj_assertFS(reg == fs->freereg, "bad regfree");
402 }
403 }
404
405 /* Free register for expression. */
406 static void expr_free(FuncState *fs, ExpDesc *e)
407 {
408 if (e->k == VNONRELOC)
409 bcreg_free(fs, e->u.s.info);
410 }
411
412 /* -- Bytecode emitter ---------------------------------------------------- */
413
414 /* Emit bytecode instruction. */
415 static BCPos bcemit_INS(FuncState *fs, BCIns ins)
416 {
417 BCPos pc = fs->pc;
418 LexState *ls = fs->ls;
419 jmp_patchval(fs, fs->jpc, pc, NO_REG, pc);
420 fs->jpc = NO_JMP;
421 if (LJ_UNLIKELY(pc >= fs->bclim)) {
422 ptrdiff_t base = fs->bcbase - ls->bcstack;
423 checklimit(fs, ls->sizebcstack, LJ_MAX_BCINS, "bytecode instructions");
424 lj_mem_growvec(fs->L, ls->bcstack, ls->sizebcstack, LJ_MAX_BCINS,BCInsLine);
425 fs->bclim = (BCPos)(ls->sizebcstack - base);
426 fs->bcbase = ls->bcstack + base;
427 }
428 fs->bcbase[pc].ins = ins;
429 fs->bcbase[pc].line = ls->lastline;
430 fs->pc = pc+1;
431 return pc;
432 }
433
434 #define bcemit_ABC(fs, o, a, b, c) bcemit_INS(fs, BCINS_ABC(o, a, b, c))
435 #define bcemit_AD(fs, o, a, d) bcemit_INS(fs, BCINS_AD(o, a, d))
436 #define bcemit_AJ(fs, o, a, j) bcemit_INS(fs, BCINS_AJ(o, a, j))
437
438 #define bcptr(fs, e) (&(fs)->bcbase[(e)->u.s.info].ins)
439
440 /* -- Bytecode emitter for expressions ------------------------------------ */
441
442 /* Discharge non-constant expression to any register. */
443 static void expr_discharge(FuncState *fs, ExpDesc *e)
444 {
445 BCIns ins;
446 if (e->k == VUPVAL) {
447 ins = BCINS_AD(BC_UGET, 0, e->u.s.info);
448 } else if (e->k == VGLOBAL) {
449 ins = BCINS_AD(BC_GGET, 0, const_str(fs, e));
450 } else if (e->k == VINDEXED) {
451 BCReg rc = e->u.s.aux;
452 if ((int32_t)rc < 0) {
453 ins = BCINS_ABC(BC_TGETS, 0, e->u.s.info, ~rc);
454 } else if (rc > BCMAX_C) {
455 ins = BCINS_ABC(BC_TGETB, 0, e->u.s.info, rc-(BCMAX_C+1));
456 } else {
457 bcreg_free(fs, rc);
458 ins = BCINS_ABC(BC_TGETV, 0, e->u.s.info, rc);
459 }
460 bcreg_free(fs, e->u.s.info);
461 } else if (e->k == VCALL) {
462 e->u.s.info = e->u.s.aux;
463 e->k = VNONRELOC;
464 return;
465 } else if (e->k == VLOCAL) {
466 e->k = VNONRELOC;
467 return;
468 } else {
469 return;
470 }
471 e->u.s.info = bcemit_INS(fs, ins);
472 e->k = VRELOCABLE;
473 }
474
475 /* Emit bytecode to set a range of registers to nil. */
476 static void bcemit_nil(FuncState *fs, BCReg from, BCReg n)
477 {
478 if (fs->pc > fs->lasttarget) { /* No jumps to current position? */
479 BCIns *ip = &fs->bcbase[fs->pc-1].ins;
480 BCReg pto, pfrom = bc_a(*ip);
481 switch (bc_op(*ip)) { /* Try to merge with the previous instruction. */
482 case BC_KPRI:
483 if (bc_d(*ip) != ~LJ_TNIL) break;
484 if (from == pfrom) {
485 if (n == 1) return;
486 } else if (from == pfrom+1) {
487 from = pfrom;
488 n++;
489 } else {
490 break;
491 }
492 *ip = BCINS_AD(BC_KNIL, from, from+n-1); /* Replace KPRI. */
493 return;
494 case BC_KNIL:
495 pto = bc_d(*ip);
496 if (pfrom <= from && from <= pto+1) { /* Can we connect both ranges? */
497 if (from+n-1 > pto)
498 setbc_d(ip, from+n-1); /* Patch previous instruction range. */
499 return;
500 }
501 break;
502 default:
503 break;
504 }
505 }
506 /* Emit new instruction or replace old instruction. */
507 bcemit_INS(fs, n == 1 ? BCINS_AD(BC_KPRI, from, VKNIL) :
508 BCINS_AD(BC_KNIL, from, from+n-1));
509 }
510
511 /* Discharge an expression to a specific register. Ignore branches. */
512 static void expr_toreg_nobranch(FuncState *fs, ExpDesc *e, BCReg reg)
513 {
514 BCIns ins;
515 expr_discharge(fs, e);
516 if (e->k == VKSTR) {
517 ins = BCINS_AD(BC_KSTR, reg, const_str(fs, e));
518 } else if (e->k == VKNUM) {
519 #if LJ_DUALNUM
520 cTValue *tv = expr_numtv(e);
521 if (tvisint(tv) && checki16(intV(tv)))
522 ins = BCINS_AD(BC_KSHORT, reg, (BCReg)(uint16_t)intV(tv));
523 else
524 #else
525 lua_Number n = expr_numberV(e);
526 int32_t k = lj_num2int(n);
527 if (checki16(k) && n == (lua_Number)k)
528 ins = BCINS_AD(BC_KSHORT, reg, (BCReg)(uint16_t)k);
529 else
530 #endif
531 ins = BCINS_AD(BC_KNUM, reg, const_num(fs, e));
532 #if LJ_HASFFI
533 } else if (e->k == VKCDATA) {
534 fs->flags |= PROTO_FFI;
535 ins = BCINS_AD(BC_KCDATA, reg,
536 const_gc(fs, obj2gco(cdataV(&e->u.nval)), LJ_TCDATA));
537 #endif
538 } else if (e->k == VRELOCABLE) {
539 setbc_a(bcptr(fs, e), reg);
540 goto noins;
541 } else if (e->k == VNONRELOC) {
542 if (reg == e->u.s.info)
543 goto noins;
544 ins = BCINS_AD(BC_MOV, reg, e->u.s.info);
545 } else if (e->k == VKNIL) {
546 bcemit_nil(fs, reg, 1);
547 goto noins;
548 } else if (e->k <= VKTRUE) {
549 ins = BCINS_AD(BC_KPRI, reg, const_pri(e));
550 } else {
551 lj_assertFS(e->k == VVOID || e->k == VJMP, "bad expr type %d", e->k);
552 return;
553 }
554 bcemit_INS(fs, ins);
555 noins:
556 e->u.s.info = reg;
557 e->k = VNONRELOC;
558 }
559
560 /* Forward declaration. */
561 static BCPos bcemit_jmp(FuncState *fs);
562
563 /* Discharge an expression to a specific register. */
564 static void expr_toreg(FuncState *fs, ExpDesc *e, BCReg reg)
565 {
566 expr_toreg_nobranch(fs, e, reg);
567 if (e->k == VJMP)
568 jmp_append(fs, &e->t, e->u.s.info); /* Add it to the true jump list. */
569 if (expr_hasjump(e)) { /* Discharge expression with branches. */
570 BCPos jend, jfalse = NO_JMP, jtrue = NO_JMP;
571 if (jmp_novalue(fs, e->t) || jmp_novalue(fs, e->f)) {
572 BCPos jval = (e->k == VJMP) ? NO_JMP : bcemit_jmp(fs);
573 jfalse = bcemit_AD(fs, BC_KPRI, reg, VKFALSE);
574 bcemit_AJ(fs, BC_JMP, fs->freereg, 1);
575 jtrue = bcemit_AD(fs, BC_KPRI, reg, VKTRUE);
576 jmp_tohere(fs, jval);
577 }
578 jend = fs->pc;
579 fs->lasttarget = jend;
580 jmp_patchval(fs, e->f, jend, reg, jfalse);
581 jmp_patchval(fs, e->t, jend, reg, jtrue);
582 }
583 e->f = e->t = NO_JMP;
584 e->u.s.info = reg;
585 e->k = VNONRELOC;
586 }
587
588 /* Discharge an expression to the next free register. */
589 static void expr_tonextreg(FuncState *fs, ExpDesc *e)
590 {
591 expr_discharge(fs, e);
592 expr_free(fs, e);
593 bcreg_reserve(fs, 1);
594 expr_toreg(fs, e, fs->freereg - 1);
595 }
596
597 /* Discharge an expression to any register. */
598 static BCReg expr_toanyreg(FuncState *fs, ExpDesc *e)
599 {
600 expr_discharge(fs, e);
601 if (e->k == VNONRELOC) {
602 if (!expr_hasjump(e)) return e->u.s.info; /* Already in a register. */
603 if (e->u.s.info >= fs->nactvar) {
604 expr_toreg(fs, e, e->u.s.info); /* Discharge to temp. register. */
605 return e->u.s.info;
606 }
607 }
608 expr_tonextreg(fs, e); /* Discharge to next register. */
609 return e->u.s.info;
610 }
611
612 /* Partially discharge expression to a value. */
613 static void expr_toval(FuncState *fs, ExpDesc *e)
614 {
615 if (expr_hasjump(e))
616 expr_toanyreg(fs, e);
617 else
618 expr_discharge(fs, e);
619 }
620
621 /* Emit store for LHS expression. */
622 static void bcemit_store(FuncState *fs, ExpDesc *var, ExpDesc *e)
623 {
624 BCIns ins;
625 if (var->k == VLOCAL) {
626 fs->ls->vstack[var->u.s.aux].info |= VSTACK_VAR_RW;
627 expr_free(fs, e);
628 expr_toreg(fs, e, var->u.s.info);
629 return;
630 } else if (var->k == VUPVAL) {
631 fs->ls->vstack[var->u.s.aux].info |= VSTACK_VAR_RW;
632 expr_toval(fs, e);
633 if (e->k <= VKTRUE)
634 ins = BCINS_AD(BC_USETP, var->u.s.info, const_pri(e));
635 else if (e->k == VKSTR)
636 ins = BCINS_AD(BC_USETS, var->u.s.info, const_str(fs, e));
637 else if (e->k == VKNUM)
638 ins = BCINS_AD(BC_USETN, var->u.s.info, const_num(fs, e));
639 else
640 ins = BCINS_AD(BC_USETV, var->u.s.info, expr_toanyreg(fs, e));
641 } else if (var->k == VGLOBAL) {
642 BCReg ra = expr_toanyreg(fs, e);
643 ins = BCINS_AD(BC_GSET, ra, const_str(fs, var));
644 } else {
645 BCReg ra, rc;
646 lj_assertFS(var->k == VINDEXED, "bad expr type %d", var->k);
647 ra = expr_toanyreg(fs, e);
648 rc = var->u.s.aux;
649 if ((int32_t)rc < 0) {
650 ins = BCINS_ABC(BC_TSETS, ra, var->u.s.info, ~rc);
651 } else if (rc > BCMAX_C) {
652 ins = BCINS_ABC(BC_TSETB, ra, var->u.s.info, rc-(BCMAX_C+1));
653 } else {
654 #ifdef LUA_USE_ASSERT
655 /* Free late alloced key reg to avoid assert on free of value reg. */
656 /* This can only happen when called from expr_table(). */
657 if (e->k == VNONRELOC && ra >= fs->nactvar && rc >= ra)
658 bcreg_free(fs, rc);
659 #endif
660 ins = BCINS_ABC(BC_TSETV, ra, var->u.s.info, rc);
661 }
662 }
663 bcemit_INS(fs, ins);
664 expr_free(fs, e);
665 }
666
667 /* Emit method lookup expression. */
668 static void bcemit_method(FuncState *fs, ExpDesc *e, ExpDesc *key)
669 {
670 BCReg idx, func, fr2, obj = expr_toanyreg(fs, e);
671 expr_free(fs, e);
672 func = fs->freereg;
673 fr2 = fs->ls->fr2;
674 bcemit_AD(fs, BC_MOV, func+1+fr2, obj); /* Copy object to 1st argument. */
675 lj_assertFS(expr_isstrk(key), "bad usage");
676 idx = const_str(fs, key);
677 if (idx <= BCMAX_C) {
678 bcreg_reserve(fs, 2+fr2);
679 bcemit_ABC(fs, BC_TGETS, func, obj, idx);
680 } else {
681 bcreg_reserve(fs, 3+fr2);
682 bcemit_AD(fs, BC_KSTR, func+2+fr2, idx);
683 bcemit_ABC(fs, BC_TGETV, func, obj, func+2+fr2);
684 fs->freereg--;
685 }
686 e->u.s.info = func;
687 e->k = VNONRELOC;
688 }
689
690 /* -- Bytecode emitter for branches --------------------------------------- */
691
692 /* Emit unconditional branch. */
693 static BCPos bcemit_jmp(FuncState *fs)
694 {
695 BCPos jpc = fs->jpc;
696 BCPos j = fs->pc - 1;
697 BCIns *ip = &fs->bcbase[j].ins;
698 fs->jpc = NO_JMP;
699 if ((int32_t)j >= (int32_t)fs->lasttarget && bc_op(*ip) == BC_UCLO) {
700 setbc_j(ip, NO_JMP);
701 fs->lasttarget = j+1;
702 } else {
703 j = bcemit_AJ(fs, BC_JMP, fs->freereg, NO_JMP);
704 }
705 jmp_append(fs, &j, jpc);
706 return j;
707 }
708
709 /* Invert branch condition of bytecode instruction. */
710 static void invertcond(FuncState *fs, ExpDesc *e)
711 {
712 BCIns *ip = &fs->bcbase[e->u.s.info - 1].ins;
713 setbc_op(ip, bc_op(*ip)^1);
714 }
715
716 /* Emit conditional branch. */
717 static BCPos bcemit_branch(FuncState *fs, ExpDesc *e, int cond)
718 {
719 BCPos pc;
720 if (e->k == VRELOCABLE) {
721 BCIns *ip = bcptr(fs, e);
722 if (bc_op(*ip) == BC_NOT) {
723 *ip = BCINS_AD(cond ? BC_ISF : BC_IST, 0, bc_d(*ip));
724 return bcemit_jmp(fs);
725 }
726 }
727 if (e->k != VNONRELOC) {
728 bcreg_reserve(fs, 1);
729 expr_toreg_nobranch(fs, e, fs->freereg-1);
730 }
731 bcemit_AD(fs, cond ? BC_ISTC : BC_ISFC, NO_REG, e->u.s.info);
732 pc = bcemit_jmp(fs);
733 expr_free(fs, e);
734 return pc;
735 }
736
737 /* Emit branch on true condition. */
738 static void bcemit_branch_t(FuncState *fs, ExpDesc *e)
739 {
740 BCPos pc;
741 expr_discharge(fs, e);
742 if (e->k == VKSTR || e->k == VKNUM || e->k == VKTRUE)
743 pc = NO_JMP; /* Never jump. */
744 else if (e->k == VJMP)
745 invertcond(fs, e), pc = e->u.s.info;
746 else if (e->k == VKFALSE || e->k == VKNIL)
747 expr_toreg_nobranch(fs, e, NO_REG), pc = bcemit_jmp(fs);
748 else
749 pc = bcemit_branch(fs, e, 0);
750 jmp_append(fs, &e->f, pc);
751 jmp_tohere(fs, e->t);
752 e->t = NO_JMP;
753 }
754
755 /* Emit branch on false condition. */
756 static void bcemit_branch_f(FuncState *fs, ExpDesc *e)
757 {
758 BCPos pc;
759 expr_discharge(fs, e);
760 if (e->k == VKNIL || e->k == VKFALSE)
761 pc = NO_JMP; /* Never jump. */
762 else if (e->k == VJMP)
763 pc = e->u.s.info;
764 else if (e->k == VKSTR || e->k == VKNUM || e->k == VKTRUE)
765 expr_toreg_nobranch(fs, e, NO_REG), pc = bcemit_jmp(fs);
766 else
767 pc = bcemit_branch(fs, e, 1);
768 jmp_append(fs, &e->t, pc);
769 jmp_tohere(fs, e->f);
770 e->f = NO_JMP;
771 }
772
773 /* -- Bytecode emitter for operators -------------------------------------- */
774
775 /* Try constant-folding of arithmetic operators. */
776 static int foldarith(BinOpr opr, ExpDesc *e1, ExpDesc *e2)
777 {
778 TValue o;
779 lua_Number n;
780 if (!expr_isnumk_nojump(e1) || !expr_isnumk_nojump(e2)) return 0;
781 n = lj_vm_foldarith(expr_numberV(e1), expr_numberV(e2), (int)opr-OPR_ADD);
782 setnumV(&o, n);
783 if (tvisnan(&o) || tvismzero(&o)) return 0; /* Avoid NaN and -0 as consts. */
784 if (LJ_DUALNUM) {
785 int32_t k = lj_num2int(n);
786 if ((lua_Number)k == n) {
787 setintV(&e1->u.nval, k);
788 return 1;
789 }
790 }
791 setnumV(&e1->u.nval, n);
792 return 1;
793 }
794
795 /* Emit arithmetic operator. */
796 static void bcemit_arith(FuncState *fs, BinOpr opr, ExpDesc *e1, ExpDesc *e2)
797 {
798 BCReg rb, rc, t;
799 uint32_t op;
800 if (foldarith(opr, e1, e2))
801 return;
802 if (opr == OPR_POW) {
803 op = BC_POW;
804 rc = expr_toanyreg(fs, e2);
805 rb = expr_toanyreg(fs, e1);
806 } else {
807 op = opr-OPR_ADD+BC_ADDVV;
808 /* Must discharge 2nd operand first since VINDEXED might free regs. */
809 expr_toval(fs, e2);
810 if (expr_isnumk(e2) && (rc = const_num(fs, e2)) <= BCMAX_C)
811 op -= BC_ADDVV-BC_ADDVN;
812 else
813 rc = expr_toanyreg(fs, e2);
814 /* 1st operand discharged by bcemit_binop_left, but need KNUM/KSHORT. */
815 lj_assertFS(expr_isnumk(e1) || e1->k == VNONRELOC,
816 "bad expr type %d", e1->k);
817 expr_toval(fs, e1);
818 /* Avoid two consts to satisfy bytecode constraints. */
819 if (expr_isnumk(e1) && !expr_isnumk(e2) &&
820 (t = const_num(fs, e1)) <= BCMAX_B) {
821 rb = rc; rc = t; op -= BC_ADDVV-BC_ADDNV;
822 } else {
823 rb = expr_toanyreg(fs, e1);
824 }
825 }
826 /* Using expr_free might cause asserts if the order is wrong. */
827 if (e1->k == VNONRELOC && e1->u.s.info >= fs->nactvar) fs->freereg--;
828 if (e2->k == VNONRELOC && e2->u.s.info >= fs->nactvar) fs->freereg--;
829 e1->u.s.info = bcemit_ABC(fs, op, 0, rb, rc);
830 e1->k = VRELOCABLE;
831 }
832
833 /* Emit comparison operator. */
834 static void bcemit_comp(FuncState *fs, BinOpr opr, ExpDesc *e1, ExpDesc *e2)
835 {
836 ExpDesc *eret = e1;
837 BCIns ins;
838 expr_toval(fs, e1);
839 if (opr == OPR_EQ || opr == OPR_NE) {
840 BCOp op = opr == OPR_EQ ? BC_ISEQV : BC_ISNEV;
841 BCReg ra;
842 if (expr_isk(e1)) { e1 = e2; e2 = eret; } /* Need constant in 2nd arg. */
843 ra = expr_toanyreg(fs, e1); /* First arg must be in a reg. */
844 expr_toval(fs, e2);
845 switch (e2->k) {
846 case VKNIL: case VKFALSE: case VKTRUE:
847 ins = BCINS_AD(op+(BC_ISEQP-BC_ISEQV), ra, const_pri(e2));
848 break;
849 case VKSTR:
850 ins = BCINS_AD(op+(BC_ISEQS-BC_ISEQV), ra, const_str(fs, e2));
851 break;
852 case VKNUM:
853 ins = BCINS_AD(op+(BC_ISEQN-BC_ISEQV), ra, const_num(fs, e2));
854 break;
855 default:
856 ins = BCINS_AD(op, ra, expr_toanyreg(fs, e2));
857 break;
858 }
859 } else {
860 uint32_t op = opr-OPR_LT+BC_ISLT;
861 BCReg ra, rd;
862 if ((op-BC_ISLT) & 1) { /* GT -> LT, GE -> LE */
863 e1 = e2; e2 = eret; /* Swap operands. */
864 op = ((op-BC_ISLT)^3)+BC_ISLT;
865 expr_toval(fs, e1);
866 ra = expr_toanyreg(fs, e1);
867 rd = expr_toanyreg(fs, e2);
868 } else {
869 rd = expr_toanyreg(fs, e2);
870 ra = expr_toanyreg(fs, e1);
871 }
872 ins = BCINS_AD(op, ra, rd);
873 }
874 /* Using expr_free might cause asserts if the order is wrong. */
875 if (e1->k == VNONRELOC && e1->u.s.info >= fs->nactvar) fs->freereg--;
876 if (e2->k == VNONRELOC && e2->u.s.info >= fs->nactvar) fs->freereg--;
877 bcemit_INS(fs, ins);
878 eret->u.s.info = bcemit_jmp(fs);
879 eret->k = VJMP;
880 }
881
882 /* Fixup left side of binary operator. */
883 static void bcemit_binop_left(FuncState *fs, BinOpr op, ExpDesc *e)
884 {
885 if (op == OPR_AND) {
886 bcemit_branch_t(fs, e);
887 } else if (op == OPR_OR) {
888 bcemit_branch_f(fs, e);
889 } else if (op == OPR_CONCAT) {
890 expr_tonextreg(fs, e);
891 } else if (op == OPR_EQ || op == OPR_NE) {
892 if (!expr_isk_nojump(e)) expr_toanyreg(fs, e);
893 } else {
894 if (!expr_isnumk_nojump(e)) expr_toanyreg(fs, e);
895 }
896 }
897
898 /* Emit binary operator. */
899 static void bcemit_binop(FuncState *fs, BinOpr op, ExpDesc *e1, ExpDesc *e2)
900 {
901 if (op <= OPR_POW) {
902 bcemit_arith(fs, op, e1, e2);
903 } else if (op == OPR_AND) {
904 lj_assertFS(e1->t == NO_JMP, "jump list not closed");
905 expr_discharge(fs, e2);
906 jmp_append(fs, &e2->f, e1->f);
907 *e1 = *e2;
908 } else if (op == OPR_OR) {
909 lj_assertFS(e1->f == NO_JMP, "jump list not closed");
910 expr_discharge(fs, e2);
911 jmp_append(fs, &e2->t, e1->t);
912 *e1 = *e2;
913 } else if (op == OPR_CONCAT) {
914 expr_toval(fs, e2);
915 if (e2->k == VRELOCABLE && bc_op(*bcptr(fs, e2)) == BC_CAT) {
916 lj_assertFS(e1->u.s.info == bc_b(*bcptr(fs, e2))-1,
917 "bad CAT stack layout");
918 expr_free(fs, e1);
919 setbc_b(bcptr(fs, e2), e1->u.s.info);
920 e1->u.s.info = e2->u.s.info;
921 } else {
922 expr_tonextreg(fs, e2);
923 expr_free(fs, e2);
924 expr_free(fs, e1);
925 e1->u.s.info = bcemit_ABC(fs, BC_CAT, 0, e1->u.s.info, e2->u.s.info);
926 }
927 e1->k = VRELOCABLE;
928 } else {
929 lj_assertFS(op == OPR_NE || op == OPR_EQ ||
930 op == OPR_LT || op == OPR_GE || op == OPR_LE || op == OPR_GT,
931 "bad binop %d", op);
932 bcemit_comp(fs, op, e1, e2);
933 }
934 }
935
936 /* Emit unary operator. */
937 static void bcemit_unop(FuncState *fs, BCOp op, ExpDesc *e)
938 {
939 if (op == BC_NOT) {
940 /* Swap true and false lists. */
941 { BCPos temp = e->f; e->f = e->t; e->t = temp; }
942 jmp_dropval(fs, e->f);
943 jmp_dropval(fs, e->t);
944 expr_discharge(fs, e);
945 if (e->k == VKNIL || e->k == VKFALSE) {
946 e->k = VKTRUE;
947 return;
948 } else if (expr_isk(e) || (LJ_HASFFI && e->k == VKCDATA)) {
949 e->k = VKFALSE;
950 return;
951 } else if (e->k == VJMP) {
952 invertcond(fs, e);
953 return;
954 } else if (e->k == VRELOCABLE) {
955 bcreg_reserve(fs, 1);
956 setbc_a(bcptr(fs, e), fs->freereg-1);
957 e->u.s.info = fs->freereg-1;
958 e->k = VNONRELOC;
959 } else {
960 lj_assertFS(e->k == VNONRELOC, "bad expr type %d", e->k);
961 }
962 } else {
963 lj_assertFS(op == BC_UNM || op == BC_LEN, "bad unop %d", op);
964 if (op == BC_UNM && !expr_hasjump(e)) { /* Constant-fold negations. */
965 #if LJ_HASFFI
966 if (e->k == VKCDATA) { /* Fold in-place since cdata is not interned. */
967 GCcdata *cd = cdataV(&e->u.nval);
968 uint64_t *p = (uint64_t *)cdataptr(cd);
969 if (cd->ctypeid == CTID_COMPLEX_DOUBLE)
970 p[1] ^= U64x(80000000,00000000);
971 else
972 *p = ~*p+1u;
973 return;
974 } else
975 #endif
976 if (expr_isnumk(e) && !expr_numiszero(e)) { /* Avoid folding to -0. */
977 TValue *o = expr_numtv(e);
978 if (tvisint(o)) {
979 int32_t k = intV(o), negk = (int32_t)(~(uint32_t)k+1u);
980 if (k == negk)
981 setnumV(o, -(lua_Number)k);
982 else
983 setintV(o, negk);
984 return;
985 } else {
986 o->u64 ^= U64x(80000000,00000000);
987 return;
988 }
989 }
990 }
991 expr_toanyreg(fs, e);
992 }
993 expr_free(fs, e);
994 e->u.s.info = bcemit_AD(fs, op, 0, e->u.s.info);
995 e->k = VRELOCABLE;
996 }
997
998 /* -- Lexer support ------------------------------------------------------- */
999
1000 /* Check and consume optional token. */
1001 static int lex_opt(LexState *ls, LexToken tok)
1002 {
1003 if (ls->tok == tok) {
1004 lj_lex_next(ls);
1005 return 1;
1006 }
1007 return 0;
1008 }
1009
1010 /* Check and consume token. */
1011 static void lex_check(LexState *ls, LexToken tok)
1012 {
1013 if (ls->tok != tok)
1014 err_token(ls, tok);
1015 lj_lex_next(ls);
1016 }
1017
1018 /* Check for matching token. */
1019 static void lex_match(LexState *ls, LexToken what, LexToken who, BCLine line)
1020 {
1021 if (!lex_opt(ls, what)) {
1022 if (line == ls->linenumber) {
1023 err_token(ls, what);
1024 } else {
1025 const char *swhat = lj_lex_token2str(ls, what);
1026 const char *swho = lj_lex_token2str(ls, who);
1027 lj_lex_error(ls, ls->tok, LJ_ERR_XMATCH, swhat, swho, line);
1028 }
1029 }
1030 }
1031
1032 /* Check for string token. */
1033 static GCstr *lex_str(LexState *ls)
1034 {
1035 GCstr *s;
1036 if (ls->tok != TK_name && (LJ_52 || ls->tok != TK_goto))
1037 err_token(ls, TK_name);
1038 s = strV(&ls->tokval);
1039 lj_lex_next(ls);
1040 return s;
1041 }
1042
1043 /* -- Variable handling --------------------------------------------------- */
1044
1045 #define var_get(ls, fs, i) ((ls)->vstack[(fs)->varmap[(i)]])
1046
1047 /* Define a new local variable. */
1048 static void var_new(LexState *ls, BCReg n, GCstr *name)
1049 {
1050 FuncState *fs = ls->fs;
1051 MSize vtop = ls->vtop;
1052 checklimit(fs, fs->nactvar+n, LJ_MAX_LOCVAR, "local variables");
1053 if (LJ_UNLIKELY(vtop >= ls->sizevstack)) {
1054 if (ls->sizevstack >= LJ_MAX_VSTACK)
1055 lj_lex_error(ls, 0, LJ_ERR_XLIMC, LJ_MAX_VSTACK);
1056 lj_mem_growvec(ls->L, ls->vstack, ls->sizevstack, LJ_MAX_VSTACK, VarInfo);
1057 }
1058 lj_assertFS((uintptr_t)name < VARNAME__MAX ||
1059 lj_tab_getstr(fs->kt, name) != NULL,
1060 "unanchored variable name");
1061 /* NOBARRIER: name is anchored in fs->kt and ls->vstack is not a GCobj. */
1062 setgcref(ls->vstack[vtop].name, obj2gco(name));
1063 fs->varmap[fs->nactvar+n] = (uint16_t)vtop;
1064 ls->vtop = vtop+1;
1065 }
1066
1067 #define var_new_lit(ls, n, v) \
1068 var_new(ls, (n), lj_parse_keepstr(ls, "" v, sizeof(v)-1))
1069
1070 #define var_new_fixed(ls, n, vn) \
1071 var_new(ls, (n), (GCstr *)(uintptr_t)(vn))
1072
1073 /* Add local variables. */
1074 static void var_add(LexState *ls, BCReg nvars)
1075 {
1076 FuncState *fs = ls->fs;
1077 BCReg nactvar = fs->nactvar;
1078 while (nvars--) {
1079 VarInfo *v = &var_get(ls, fs, nactvar);
1080 v->startpc = fs->pc;
1081 v->slot = nactvar++;
1082 v->info = 0;
1083 }
1084 fs->nactvar = nactvar;
1085 }
1086
1087 /* Remove local variables. */
1088 static void var_remove(LexState *ls, BCReg tolevel)
1089 {
1090 FuncState *fs = ls->fs;
1091 while (fs->nactvar > tolevel)
1092 var_get(ls, fs, --fs->nactvar).endpc = fs->pc;
1093 }
1094
1095 /* Lookup local variable name. */
1096 static BCReg var_lookup_local(FuncState *fs, GCstr *n)
1097 {
1098 int i;
1099 for (i = fs->nactvar-1; i >= 0; i--) {
1100 if (n == strref(var_get(fs->ls, fs, i).name))
1101 return (BCReg)i;
1102 }
1103 return (BCReg)-1; /* Not found. */
1104 }
1105
1106 /* Lookup or add upvalue index. */
1107 static MSize var_lookup_uv(FuncState *fs, MSize vidx, ExpDesc *e)
1108 {
1109 MSize i, n = fs->nuv;
1110 for (i = 0; i < n; i++)
1111 if (fs->uvmap[i] == vidx)
1112 return i; /* Already exists. */
1113 /* Otherwise create a new one. */
1114 checklimit(fs, fs->nuv, LJ_MAX_UPVAL, "upvalues");
1115 lj_assertFS(e->k == VLOCAL || e->k == VUPVAL, "bad expr type %d", e->k);
1116 fs->uvmap[n] = (uint16_t)vidx;
1117 fs->uvtmp[n] = (uint16_t)(e->k == VLOCAL ? vidx : LJ_MAX_VSTACK+e->u.s.info);
1118 fs->nuv = n+1;
1119 return n;
1120 }
1121
1122 /* Forward declaration. */
1123 static void fscope_uvmark(FuncState *fs, BCReg level);
1124
1125 /* Recursively lookup variables in enclosing functions. */
1126 static MSize var_lookup_(FuncState *fs, GCstr *name, ExpDesc *e, int first)
1127 {
1128 if (fs) {
1129 BCReg reg = var_lookup_local(fs, name);
1130 if ((int32_t)reg >= 0) { /* Local in this function? */
1131 expr_init(e, VLOCAL, reg);
1132 if (!first)
1133 fscope_uvmark(fs, reg); /* Scope now has an upvalue. */
1134 return (MSize)(e->u.s.aux = (uint32_t)fs->varmap[reg]);
1135 } else {
1136 MSize vidx = var_lookup_(fs->prev, name, e, 0); /* Var in outer func? */
1137 if ((int32_t)vidx >= 0) { /* Yes, make it an upvalue here. */
1138 e->u.s.info = (uint8_t)var_lookup_uv(fs, vidx, e);
1139 e->k = VUPVAL;
1140 return vidx;
1141 }
1142 }
1143 } else { /* Not found in any function, must be a global. */
1144 expr_init(e, VGLOBAL, 0);
1145 e->u.sval = name;
1146 }
1147 return (MSize)-1; /* Global. */
1148 }
1149
1150 /* Lookup variable name. */
1151 #define var_lookup(ls, e) \
1152 var_lookup_((ls)->fs, lex_str(ls), (e), 1)
1153
1154 /* -- Goto an label handling ---------------------------------------------- */
1155
1156 /* Add a new goto or label. */
1157 static MSize gola_new(LexState *ls, GCstr *name, uint8_t info, BCPos pc)
1158 {
1159 FuncState *fs = ls->fs;
1160 MSize vtop = ls->vtop;
1161 if (LJ_UNLIKELY(vtop >= ls->sizevstack)) {
1162 if (ls->sizevstack >= LJ_MAX_VSTACK)
1163 lj_lex_error(ls, 0, LJ_ERR_XLIMC, LJ_MAX_VSTACK);
1164 lj_mem_growvec(ls->L, ls->vstack, ls->sizevstack, LJ_MAX_VSTACK, VarInfo);
1165 }
1166 lj_assertFS(name == NAME_BREAK || lj_tab_getstr(fs->kt, name) != NULL,
1167 "unanchored label name");
1168 /* NOBARRIER: name is anchored in fs->kt and ls->vstack is not a GCobj. */
1169 setgcref(ls->vstack[vtop].name, obj2gco(name));
1170 ls->vstack[vtop].startpc = pc;
1171 ls->vstack[vtop].slot = (uint8_t)fs->nactvar;
1172 ls->vstack[vtop].info = info;
1173 ls->vtop = vtop+1;
1174 return vtop;
1175 }
1176
1177 #define gola_isgoto(v) ((v)->info & VSTACK_GOTO)
1178 #define gola_islabel(v) ((v)->info & VSTACK_LABEL)
1179 #define gola_isgotolabel(v) ((v)->info & (VSTACK_GOTO|VSTACK_LABEL))
1180
1181 /* Patch goto to jump to label. */
1182 static void gola_patch(LexState *ls, VarInfo *vg, VarInfo *vl)
1183 {
1184 FuncState *fs = ls->fs;
1185 BCPos pc = vg->startpc;
1186 setgcrefnull(vg->name); /* Invalidate pending goto. */
1187 setbc_a(&fs->bcbase[pc].ins, vl->slot);
1188 jmp_patch(fs, pc, vl->startpc);
1189 }
1190
1191 /* Patch goto to close upvalues. */
1192 static void gola_close(LexState *ls, VarInfo *vg)
1193 {
1194 FuncState *fs = ls->fs;
1195 BCPos pc = vg->startpc;
1196 BCIns *ip = &fs->bcbase[pc].ins;
1197 lj_assertFS(gola_isgoto(vg), "expected goto");
1198 lj_assertFS(bc_op(*ip) == BC_JMP || bc_op(*ip) == BC_UCLO,
1199 "bad bytecode op %d", bc_op(*ip));
1200 setbc_a(ip, vg->slot);
1201 if (bc_op(*ip) == BC_JMP) {
1202 BCPos next = jmp_next(fs, pc);
1203 if (next != NO_JMP) jmp_patch(fs, next, pc); /* Jump to UCLO. */
1204 setbc_op(ip, BC_UCLO); /* Turn into UCLO. */
1205 setbc_j(ip, NO_JMP);
1206 }
1207 }
1208
1209 /* Resolve pending forward gotos for label. */
1210 static void gola_resolve(LexState *ls, FuncScope *bl, MSize idx)
1211 {
1212 VarInfo *vg = ls->vstack + bl->vstart;
1213 VarInfo *vl = ls->vstack + idx;
1214 for (; vg < vl; vg++)
1215 if (gcrefeq(vg->name, vl->name) && gola_isgoto(vg)) {
1216 if (vg->slot < vl->slot) {
1217 GCstr *name = strref(var_get(ls, ls->fs, vg->slot).name);
1218 lj_assertLS((uintptr_t)name >= VARNAME__MAX, "expected goto name");
1219 ls->linenumber = ls->fs->bcbase[vg->startpc].line;
1220 lj_assertLS(strref(vg->name) != NAME_BREAK, "unexpected break");
1221 lj_lex_error(ls, 0, LJ_ERR_XGSCOPE,
1222 strdata(strref(vg->name)), strdata(name));
1223 }
1224 gola_patch(ls, vg, vl);
1225 }
1226 }
1227
1228 /* Fixup remaining gotos and labels for scope. */
1229 static void gola_fixup(LexState *ls, FuncScope *bl)
1230 {
1231 VarInfo *v = ls->vstack + bl->vstart;
1232 VarInfo *ve = ls->vstack + ls->vtop;
1233 for (; v < ve; v++) {
1234 GCstr *name = strref(v->name);
1235 if (name != NULL) { /* Only consider remaining valid gotos/labels. */
1236 if (gola_islabel(v)) {
1237 VarInfo *vg;
1238 setgcrefnull(v->name); /* Invalidate label that goes out of scope. */
1239 for (vg = v+1; vg < ve; vg++) /* Resolve pending backward gotos. */
1240 if (strref(vg->name) == name && gola_isgoto(vg)) {
1241 if ((bl->flags&FSCOPE_UPVAL) && vg->slot > v->slot)
1242 gola_close(ls, vg);
1243 gola_patch(ls, vg, v);
1244 }
1245 } else if (gola_isgoto(v)) {
1246 if (bl->prev) { /* Propagate goto or break to outer scope. */
1247 bl->prev->flags |= name == NAME_BREAK ? FSCOPE_BREAK : FSCOPE_GOLA;
1248 v->slot = bl->nactvar;
1249 if ((bl->flags & FSCOPE_UPVAL))
1250 gola_close(ls, v);
1251 } else { /* No outer scope: undefined goto label or no loop. */
1252 ls->linenumber = ls->fs->bcbase[v->startpc].line;
1253 if (name == NAME_BREAK)
1254 lj_lex_error(ls, 0, LJ_ERR_XBREAK);
1255 else
1256 lj_lex_error(ls, 0, LJ_ERR_XLUNDEF, strdata(name));
1257 }
1258 }
1259 }
1260 }
1261 }
1262
1263 /* Find existing label. */
1264 static VarInfo *gola_findlabel(LexState *ls, GCstr *name)
1265 {
1266 VarInfo *v = ls->vstack + ls->fs->bl->vstart;
1267 VarInfo *ve = ls->vstack + ls->vtop;
1268 for (; v < ve; v++)
1269 if (strref(v->name) == name && gola_islabel(v))
1270 return v;
1271 return NULL;
1272 }
1273
1274 /* -- Scope handling ------------------------------------------------------ */
1275
1276 /* Begin a scope. */
1277 static void fscope_begin(FuncState *fs, FuncScope *bl, int flags)
1278 {
1279 bl->nactvar = (uint8_t)fs->nactvar;
1280 bl->flags = flags;
1281 bl->vstart = fs->ls->vtop;
1282 bl->prev = fs->bl;
1283 fs->bl = bl;
1284 lj_assertFS(fs->freereg == fs->nactvar, "bad regalloc");
1285 }
1286
1287 /* End a scope. */
1288 static void fscope_end(FuncState *fs)
1289 {
1290 FuncScope *bl = fs->bl;
1291 LexState *ls = fs->ls;
1292 fs->bl = bl->prev;
1293 var_remove(ls, bl->nactvar);
1294 fs->freereg = fs->nactvar;
1295 lj_assertFS(bl->nactvar == fs->nactvar, "bad regalloc");
1296 if ((bl->flags & (FSCOPE_UPVAL|FSCOPE_NOCLOSE)) == FSCOPE_UPVAL)
1297 bcemit_AJ(fs, BC_UCLO, bl->nactvar, 0);
1298 if ((bl->flags & FSCOPE_BREAK)) {
1299 if ((bl->flags & FSCOPE_LOOP)) {
1300 MSize idx = gola_new(ls, NAME_BREAK, VSTACK_LABEL, fs->pc);
1301 ls->vtop = idx; /* Drop break label immediately. */
1302 gola_resolve(ls, bl, idx);
1303 } else { /* Need the fixup step to propagate the breaks. */
1304 gola_fixup(ls, bl);
1305 return;
1306 }
1307 }
1308 if ((bl->flags & FSCOPE_GOLA)) {
1309 gola_fixup(ls, bl);
1310 }
1311 }
1312
1313 /* Mark scope as having an upvalue. */
1314 static void fscope_uvmark(FuncState *fs, BCReg level)
1315 {
1316 FuncScope *bl;
1317 for (bl = fs->bl; bl && bl->nactvar > level; bl = bl->prev)
1318 ;
1319 if (bl)
1320 bl->flags |= FSCOPE_UPVAL;
1321 }
1322
1323 /* -- Function state management ------------------------------------------- */
1324
1325 /* Fixup bytecode for prototype. */
1326 static void fs_fixup_bc(FuncState *fs, GCproto *pt, BCIns *bc, MSize n)
1327 {
1328 BCInsLine *base = fs->bcbase;
1329 MSize i;
1330 BCIns op;
1331 pt->sizebc = n;
1332 if (fs->ls->fr2 != LJ_FR2) op = BC_NOT; /* Mark non-native prototype. */
1333 else if ((fs->flags & PROTO_VARARG)) op = BC_FUNCV;
1334 else op = BC_FUNCF;
1335 bc[0] = BCINS_AD(op, fs->framesize, 0);
1336 for (i = 1; i < n; i++)
1337 bc[i] = base[i].ins;
1338 }
1339
1340 /* Fixup upvalues for child prototype, step #2. */
1341 static void fs_fixup_uv2(FuncState *fs, GCproto *pt)
1342 {
1343 VarInfo *vstack = fs->ls->vstack;
1344 uint16_t *uv = proto_uv(pt);
1345 MSize i, n = pt->sizeuv;
1346 for (i = 0; i < n; i++) {
1347 VarIndex vidx = uv[i];
1348 if (vidx >= LJ_MAX_VSTACK)
1349 uv[i] = vidx - LJ_MAX_VSTACK;
1350 else if ((vstack[vidx].info & VSTACK_VAR_RW))
1351 uv[i] = vstack[vidx].slot | PROTO_UV_LOCAL;
1352 else
1353 uv[i] = vstack[vidx].slot | PROTO_UV_LOCAL | PROTO_UV_IMMUTABLE;
1354 }
1355 }
1356
1357 /* Fixup constants for prototype. */
1358 static void fs_fixup_k(FuncState *fs, GCproto *pt, void *kptr)
1359 {
1360 GCtab *kt;
1361 TValue *array;
1362 Node *node;
1363 MSize i, hmask;
1364 checklimitgt(fs, fs->nkn, BCMAX_D+1, "constants");
1365 checklimitgt(fs, fs->nkgc, BCMAX_D+1, "constants");
1366 setmref(pt->k, kptr);
1367 pt->sizekn = fs->nkn;
1368 pt->sizekgc = fs->nkgc;
1369 kt = fs->kt;
1370 array = tvref(kt->array);
1371 for (i = 0; i < kt->asize; i++)
1372 if (tvhaskslot(&array[i])) {
1373 TValue *tv = &((TValue *)kptr)[tvkslot(&array[i])];
1374 if (LJ_DUALNUM)
1375 setintV(tv, (int32_t)i);
1376 else
1377 setnumV(tv, (lua_Number)i);
1378 }
1379 node = noderef(kt->node);
1380 hmask = kt->hmask;
1381 for (i = 0; i <= hmask; i++) {
1382 Node *n = &node[i];
1383 if (tvhaskslot(&n->val)) {
1384 ptrdiff_t kidx = (ptrdiff_t)tvkslot(&n->val);
1385 lj_assertFS(!tvisint(&n->key), "unexpected integer key");
1386 if (tvisnum(&n->key)) {
1387 TValue *tv = &((TValue *)kptr)[kidx];
1388 if (LJ_DUALNUM) {
1389 lua_Number nn = numV(&n->key);
1390 int32_t k = lj_num2int(nn);
1391 lj_assertFS(!tvismzero(&n->key), "unexpected -0 key");
1392 if ((lua_Number)k == nn)
1393 setintV(tv, k);
1394 else
1395 *tv = n->key;
1396 } else {
1397 *tv = n->key;
1398 }
1399 } else {
1400 GCobj *o = gcV(&n->key);
1401 setgcref(((GCRef *)kptr)[~kidx], o);
1402 lj_gc_objbarrier(fs->L, pt, o);
1403 if (tvisproto(&n->key))
1404 fs_fixup_uv2(fs, gco2pt(o));
1405 }
1406 }
1407 }
1408 }
1409
1410 /* Fixup upvalues for prototype, step #1. */
1411 static void fs_fixup_uv1(FuncState *fs, GCproto *pt, uint16_t *uv)
1412 {
1413 setmref(pt->uv, uv);
1414 pt->sizeuv = fs->nuv;
1415 memcpy(uv, fs->uvtmp, fs->nuv*sizeof(VarIndex));
1416 }
1417
1418 #ifndef LUAJIT_DISABLE_DEBUGINFO
1419 /* Prepare lineinfo for prototype. */
1420 static size_t fs_prep_line(FuncState *fs, BCLine numline)
1421 {
1422 return (fs->pc-1) << (numline < 256 ? 0 : numline < 65536 ? 1 : 2);
1423 }
1424
1425 /* Fixup lineinfo for prototype. */
1426 static void fs_fixup_line(FuncState *fs, GCproto *pt,
1427 void *lineinfo, BCLine numline)
1428 {
1429 BCInsLine *base = fs->bcbase + 1;
1430 BCLine first = fs->linedefined;
1431 MSize i = 0, n = fs->pc-1;
1432 pt->firstline = fs->linedefined;
1433 pt->numline = numline;
1434 setmref(pt->lineinfo, lineinfo);
1435 if (LJ_LIKELY(numline < 256)) {
1436 uint8_t *li = (uint8_t *)lineinfo;
1437 do {
1438 BCLine delta = base[i].line - first;
1439 lj_assertFS(delta >= 0 && delta < 256, "bad line delta");
1440 li[i] = (uint8_t)delta;
1441 } while (++i < n);
1442 } else if (LJ_LIKELY(numline < 65536)) {
1443 uint16_t *li = (uint16_t *)lineinfo;
1444 do {
1445 BCLine delta = base[i].line - first;
1446 lj_assertFS(delta >= 0 && delta < 65536, "bad line delta");
1447 li[i] = (uint16_t)delta;
1448 } while (++i < n);
1449 } else {
1450 uint32_t *li = (uint32_t *)lineinfo;
1451 do {
1452 BCLine delta = base[i].line - first;
1453 lj_assertFS(delta >= 0, "bad line delta");
1454 li[i] = (uint32_t)delta;
1455 } while (++i < n);
1456 }
1457 }
1458
1459 /* Prepare variable info for prototype. */
1460 static size_t fs_prep_var(LexState *ls, FuncState *fs, size_t *ofsvar)
1461 {
1462 VarInfo *vs =ls->vstack, *ve;
1463 MSize i, n;
1464 BCPos lastpc;
1465 lj_buf_reset(&ls->sb); /* Copy to temp. string buffer. */
1466 /* Store upvalue names. */
1467 for (i = 0, n = fs->nuv; i < n; i++) {
1468 GCstr *s = strref(vs[fs->uvmap[i]].name);
1469 MSize len = s->len+1;
1470 char *p = lj_buf_more(&ls->sb, len);
1471 p = lj_buf_wmem(p, strdata(s), len);
1472 ls->sb.w = p;
1473 }
1474 *ofsvar = sbuflen(&ls->sb);
1475 lastpc = 0;
1476 /* Store local variable names and compressed ranges. */
1477 for (ve = vs + ls->vtop, vs += fs->vbase; vs < ve; vs++) {
1478 if (!gola_isgotolabel(vs)) {
1479 GCstr *s = strref(vs->name);
1480 BCPos startpc;
1481 char *p;
1482 if ((uintptr_t)s < VARNAME__MAX) {
1483 p = lj_buf_more(&ls->sb, 1 + 2*5);
1484 *p++ = (char)(uintptr_t)s;
1485 } else {
1486 MSize len = s->len+1;
1487 p = lj_buf_more(&ls->sb, len + 2*5);
1488 p = lj_buf_wmem(p, strdata(s), len);
1489 }
1490 startpc = vs->startpc;
1491 p = lj_strfmt_wuleb128(p, startpc-lastpc);
1492 p = lj_strfmt_wuleb128(p, vs->endpc-startpc);
1493 ls->sb.w = p;
1494 lastpc = startpc;
1495 }
1496 }
1497 lj_buf_putb(&ls->sb, '\0'); /* Terminator for varinfo. */
1498 return sbuflen(&ls->sb);
1499 }
1500
1501 /* Fixup variable info for prototype. */
1502 static void fs_fixup_var(LexState *ls, GCproto *pt, uint8_t *p, size_t ofsvar)
1503 {
1504 setmref(pt->uvinfo, p);
1505 setmref(pt->varinfo, (char *)p + ofsvar);
1506 memcpy(p, ls->sb.b, sbuflen(&ls->sb)); /* Copy from temp. buffer. */
1507 }
1508 #else
1509
1510 /* Initialize with empty debug info, if disabled. */
1511 #define fs_prep_line(fs, numline) (UNUSED(numline), 0)
1512 #define fs_fixup_line(fs, pt, li, numline) \
1513 pt->firstline = pt->numline = 0, setmref((pt)->lineinfo, NULL)
1514 #define fs_prep_var(ls, fs, ofsvar) (UNUSED(ofsvar), 0)
1515 #define fs_fixup_var(ls, pt, p, ofsvar) \
1516 setmref((pt)->uvinfo, NULL), setmref((pt)->varinfo, NULL)
1517
1518 #endif
1519
1520 /* Fixup return instruction for prototype. */
1521 static void fs_fixup_ret(FuncState *fs)
1522 {
1523 BCPos lastpc = fs->pc;
1524 if (lastpc <= fs->lasttarget || !bc_isret_or_tail(bc_op(fs->bcbase[lastpc-1].ins))) {
1525 if ((fs->bl->flags & FSCOPE_UPVAL))
1526 bcemit_AJ(fs, BC_UCLO, 0, 0);
1527 bcemit_AD(fs, BC_RET0, 0, 1); /* Need final return. */
1528 }
1529 fs->bl->flags |= FSCOPE_NOCLOSE; /* Handled above. */
1530 fscope_end(fs);
1531 lj_assertFS(fs->bl == NULL, "bad scope nesting");
1532 /* May need to fixup returns encoded before first function was created. */
1533 if (fs->flags & PROTO_FIXUP_RETURN) {
1534 BCPos pc;
1535 for (pc = 1; pc < lastpc; pc++) {
1536 BCIns ins = fs->bcbase[pc].ins;
1537 BCPos offset;
1538 switch (bc_op(ins)) {
1539 case BC_CALLMT: case BC_CALLT:
1540 case BC_RETM: case BC_RET: case BC_RET0: case BC_RET1:
1541 offset = bcemit_INS(fs, ins); /* Copy original instruction. */
1542 fs->bcbase[offset].line = fs->bcbase[pc].line;
1543 offset = offset-(pc+1)+BCBIAS_J;
1544 if (offset > BCMAX_D)
1545 err_syntax(fs->ls, LJ_ERR_XFIXUP);
1546 /* Replace with UCLO plus branch. */
1547 fs->bcbase[pc].ins = BCINS_AD(BC_UCLO, 0, offset);
1548 break;
1549 case BC_FNEW:
1550 return; /* We're done. */
1551 default:
1552 break;
1553 }
1554 }
1555 }
1556 }
1557
1558 /* Finish a FuncState and return the new prototype. */
1559 static GCproto *fs_finish(LexState *ls, BCLine line)
1560 {
1561 lua_State *L = ls->L;
1562 FuncState *fs = ls->fs;
1563 BCLine numline = line - fs->linedefined;
1564 size_t sizept, ofsk, ofsuv, ofsli, ofsdbg, ofsvar;
1565 GCproto *pt;
1566
1567 /* Apply final fixups. */
1568 fs_fixup_ret(fs);
1569
1570 /* Calculate total size of prototype including all colocated arrays. */
1571 sizept = sizeof(GCproto) + fs->pc*sizeof(BCIns) + fs->nkgc*sizeof(GCRef);
1572 sizept = (sizept + sizeof(TValue)-1) & ~(sizeof(TValue)-1);
1573 ofsk = sizept; sizept += fs->nkn*sizeof(TValue);
1574 ofsuv = sizept; sizept += ((fs->nuv+1)&~1)*2;
1575 ofsli = sizept; sizept += fs_prep_line(fs, numline);
1576 ofsdbg = sizept; sizept += fs_prep_var(ls, fs, &ofsvar);
1577
1578 /* Allocate prototype and initialize its fields. */
1579 pt = (GCproto *)lj_mem_newgco(L, (MSize)sizept);
1580 pt->gct = ~LJ_TPROTO;
1581 pt->sizept = (MSize)sizept;
1582 pt->trace = 0;
1583 pt->flags = (uint8_t)(fs->flags & ~(PROTO_HAS_RETURN|PROTO_FIXUP_RETURN));
1584 pt->numparams = fs->numparams;
1585 pt->framesize = fs->framesize;
1586 setgcref(pt->chunkname, obj2gco(ls->chunkname));
1587
1588 /* Close potentially uninitialized gap between bc and kgc. */
1589 *(uint32_t *)((char *)pt + ofsk - sizeof(GCRef)*(fs->nkgc+1)) = 0;
1590 fs_fixup_bc(fs, pt, (BCIns *)((char *)pt + sizeof(GCproto)), fs->pc);
1591 fs_fixup_k(fs, pt, (void *)((char *)pt + ofsk));
1592 fs_fixup_uv1(fs, pt, (uint16_t *)((char *)pt + ofsuv));
1593 fs_fixup_line(fs, pt, (void *)((char *)pt + ofsli), numline);
1594 fs_fixup_var(ls, pt, (uint8_t *)((char *)pt + ofsdbg), ofsvar);
1595
1596 lj_vmevent_send(L, BC,
1597 setprotoV(L, L->top++, pt);
1598 );
1599
1600 L->top--; /* Pop table of constants. */
1601 ls->vtop = fs->vbase; /* Reset variable stack. */
1602 ls->fs = fs->prev;
1603 lj_assertL(ls->fs != NULL || ls->tok == TK_eof, "bad parser state");
1604 return pt;
1605 }
1606
1607 /* Initialize a new FuncState. */
1608 static void fs_init(LexState *ls, FuncState *fs)
1609 {
1610 lua_State *L = ls->L;
1611 fs->prev = ls->fs; ls->fs = fs; /* Append to list. */
1612 fs->ls = ls;
1613 fs->vbase = ls->vtop;
1614 fs->L = L;
1615 fs->pc = 0;
1616 fs->lasttarget = 0;
1617 fs->jpc = NO_JMP;
1618 fs->freereg = 0;
1619 fs->nkgc = 0;
1620 fs->nkn = 0;
1621 fs->nactvar = 0;
1622 fs->nuv = 0;
1623 fs->bl = NULL;
1624 fs->flags = 0;
1625 fs->framesize = 1; /* Minimum frame size. */
1626 fs->kt = lj_tab_new(L, 0, 0);
1627 /* Anchor table of constants in stack to avoid being collected. */
1628 settabV(L, L->top, fs->kt);
1629 incr_top(L);
1630 }
1631
1632 /* -- Expressions --------------------------------------------------------- */
1633
1634 /* Forward declaration. */
1635 static void expr(LexState *ls, ExpDesc *v);
1636
1637 /* Return string expression. */
1638 static void expr_str(LexState *ls, ExpDesc *e)
1639 {
1640 expr_init(e, VKSTR, 0);
1641 e->u.sval = lex_str(ls);
1642 }
1643
1644 /* Return index expression. */
1645 static void expr_index(FuncState *fs, ExpDesc *t, ExpDesc *e)
1646 {
1647 /* Already called: expr_toval(fs, e). */
1648 t->k = VINDEXED;
1649 if (expr_isnumk(e)) {
1650 #if LJ_DUALNUM
1651 if (tvisint(expr_numtv(e))) {
1652 int32_t k = intV(expr_numtv(e));
1653 if (checku8(k)) {
1654 t->u.s.aux = BCMAX_C+1+(uint32_t)k; /* 256..511: const byte key */
1655 return;
1656 }
1657 }
1658 #else
1659 lua_Number n = expr_numberV(e);
1660 int32_t k = lj_num2int(n);
1661 if (checku8(k) && n == (lua_Number)k) {
1662 t->u.s.aux = BCMAX_C+1+(uint32_t)k; /* 256..511: const byte key */
1663 return;
1664 }
1665 #endif
1666 } else if (expr_isstrk(e)) {
1667 BCReg idx = const_str(fs, e);
1668 if (idx <= BCMAX_C) {
1669 t->u.s.aux = ~idx; /* -256..-1: const string key */
1670 return;
1671 }
1672 }
1673 t->u.s.aux = expr_toanyreg(fs, e); /* 0..255: register */
1674 }
1675
1676 /* Parse index expression with named field. */
1677 static void expr_field(LexState *ls, ExpDesc *v)
1678 {
1679 FuncState *fs = ls->fs;
1680 ExpDesc key;
1681 expr_toanyreg(fs, v);
1682 lj_lex_next(ls); /* Skip dot or colon. */
1683 expr_str(ls, &key);
1684 expr_index(fs, v, &key);
1685 }
1686
1687 /* Parse index expression with brackets. */
1688 static void expr_bracket(LexState *ls, ExpDesc *v)
1689 {
1690 lj_lex_next(ls); /* Skip '['. */
1691 expr(ls, v);
1692 expr_toval(ls->fs, v);
1693 lex_check(ls, ']');
1694 }
1695
1696 /* Get value of constant expression. */
1697 static void expr_kvalue(FuncState *fs, TValue *v, ExpDesc *e)
1698 {
1699 UNUSED(fs);
1700 if (e->k <= VKTRUE) {
1701 setpriV(v, ~(uint32_t)e->k);
1702 } else if (e->k == VKSTR) {
1703 setgcVraw(v, obj2gco(e->u.sval), LJ_TSTR);
1704 } else {
1705 lj_assertFS(tvisnumber(expr_numtv(e)), "bad number constant");
1706 *v = *expr_numtv(e);
1707 }
1708 }
1709
1710 /* Parse table constructor expression. */
1711 static void expr_table(LexState *ls, ExpDesc *e)
1712 {
1713 FuncState *fs = ls->fs;
1714 BCLine line = ls->linenumber;
1715 GCtab *t = NULL;
1716 int vcall = 0, needarr = 0;
1717 uint32_t narr = 1; /* First array index. */
1718 uint32_t nhash = 0; /* Number of hash entries. */
1719 BCReg freg = fs->freereg;
1720 BCPos pc = bcemit_AD(fs, BC_TNEW, freg, 0);
1721 expr_init(e, VNONRELOC, freg);
1722 bcreg_reserve(fs, 1);
1723 freg++;
1724 lex_check(ls, '{');
1725 while (ls->tok != '}') {
1726 ExpDesc key, val;
1727 vcall = 0;
1728 if (ls->tok == '[') {
1729 expr_bracket(ls, &key); /* Already calls expr_toval. */
1730 if (!expr_isk(&key)) expr_index(fs, e, &key);
1731 if (expr_isnumk(&key) && expr_numiszero(&key)) needarr = 1; else nhash++;
1732 lex_check(ls, '=');
1733 } else if ((ls->tok == TK_name || (!LJ_52 && ls->tok == TK_goto)) &&
1734 lj_lex_lookahead(ls) == '=') {
1735 expr_str(ls, &key);
1736 lex_check(ls, '=');
1737 nhash++;
1738 } else {
1739 expr_init(&key, VKNUM, 0);
1740 setintV(&key.u.nval, (int)narr);
1741 narr++;
1742 needarr = vcall = 1;
1743 }
1744 expr(ls, &val);
1745 if (expr_isk(&key) && key.k != VKNIL &&
1746 (key.k == VKSTR || expr_isk_nojump(&val))) {
1747 TValue k, *v;
1748 if (!t) { /* Create template table on demand. */
1749 BCReg kidx;
1750 t = lj_tab_new(fs->L, needarr ? narr : 0, hsize2hbits(nhash));
1751 kidx = const_gc(fs, obj2gco(t), LJ_TTAB);
1752 fs->bcbase[pc].ins = BCINS_AD(BC_TDUP, freg-1, kidx);
1753 }
1754 vcall = 0;
1755 expr_kvalue(fs, &k, &key);
1756 v = lj_tab_set(fs->L, t, &k);
1757 lj_gc_anybarriert(fs->L, t);
1758 if (expr_isk_nojump(&val)) { /* Add const key/value to template table. */
1759 expr_kvalue(fs, v, &val);
1760 /* Mark nil value with table value itself to preserve the key. */
1761 if (key.k == VKSTR && tvisnil(v)) settabV(fs->L, v, t);
1762 } else { /* Preserve the key for the following non-const store. */
1763 settabV(fs->L, v, t);
1764 goto nonconst;
1765 }
1766 } else {
1767 nonconst:
1768 if (val.k != VCALL) { expr_toanyreg(fs, &val); vcall = 0; }
1769 if (expr_isk(&key)) expr_index(fs, e, &key);
1770 bcemit_store(fs, e, &val);
1771 }
1772 fs->freereg = freg;
1773 if (!lex_opt(ls, ',') && !lex_opt(ls, ';')) break;
1774 }
1775 lex_match(ls, '}', '{', line);
1776 if (vcall) {
1777 BCInsLine *ilp = &fs->bcbase[fs->pc-1];
1778 ExpDesc en;
1779 lj_assertFS(bc_a(ilp->ins) == freg &&
1780 bc_op(ilp->ins) == (narr > 256 ? BC_TSETV : BC_TSETB),
1781 "bad CALL code generation");
1782 expr_init(&en, VKNUM, 0);
1783 en.u.nval.u32.lo = narr-1;
1784 en.u.nval.u32.hi = 0x43300000; /* Biased integer to avoid denormals. */
1785 if (narr > 256) { fs->pc--; ilp--; }
1786 ilp->ins = BCINS_AD(BC_TSETM, freg, const_num(fs, &en));
1787 setbc_b(&ilp[-1].ins, 0);
1788 }
1789 if (pc == fs->pc-1) { /* Make expr relocable if possible. */
1790 e->u.s.info = pc;
1791 fs->freereg--;
1792 e->k = VRELOCABLE;
1793 } else {
1794 e->k = VNONRELOC; /* May have been changed by expr_index. */
1795 }
1796 if (!t) { /* Construct TNEW RD: hhhhhaaaaaaaaaaa. */
1797 BCIns *ip = &fs->bcbase[pc].ins;
1798 if (!needarr) narr = 0;
1799 else if (narr < 3) narr = 3;
1800 else if (narr > 0x7ff) narr = 0x7ff;
1801 setbc_d(ip, narr|(hsize2hbits(nhash)<<11));
1802 } else {
1803 if (needarr && t->asize < narr)
1804 lj_tab_reasize(fs->L, t, narr-1);
1805 lj_gc_check(fs->L);
1806 }
1807 }
1808
1809 /* Parse function parameters. */
1810 static BCReg parse_params(LexState *ls, int needself)
1811 {
1812 FuncState *fs = ls->fs;
1813 BCReg nparams = 0;
1814 lex_check(ls, '(');
1815 if (needself)
1816 var_new_lit(ls, nparams++, "self");
1817 if (ls->tok != ')') {
1818 do {
1819 if (ls->tok == TK_name || (!LJ_52 && ls->tok == TK_goto)) {
1820 var_new(ls, nparams++, lex_str(ls));
1821 } else if (ls->tok == TK_dots) {
1822 lj_lex_next(ls);
1823 fs->flags |= PROTO_VARARG;
1824 break;
1825 } else {
1826 err_syntax(ls, LJ_ERR_XPARAM);
1827 }
1828 } while (lex_opt(ls, ','));
1829 }
1830 var_add(ls, nparams);
1831 lj_assertFS(fs->nactvar == nparams, "bad regalloc");
1832 bcreg_reserve(fs, nparams);
1833 lex_check(ls, ')');
1834 return nparams;
1835 }
1836
1837 /* Forward declaration. */
1838 static void parse_chunk(LexState *ls);
1839
1840 /* Parse body of a function. */
1841 static void parse_body(LexState *ls, ExpDesc *e, int needself, BCLine line)
1842 {
1843 FuncState fs, *pfs = ls->fs;
1844 FuncScope bl;
1845 GCproto *pt;
1846 ptrdiff_t oldbase = pfs->bcbase - ls->bcstack;
1847 fs_init(ls, &fs);
1848 fscope_begin(&fs, &bl, 0);
1849 fs.linedefined = line;
1850 fs.numparams = (uint8_t)parse_params(ls, needself);
1851 fs.bcbase = pfs->bcbase + pfs->pc;
1852 fs.bclim = pfs->bclim - pfs->pc;
1853 bcemit_AD(&fs, BC_FUNCF, 0, 0); /* Placeholder. */
1854 parse_chunk(ls);
1855 if (ls->tok != TK_end) lex_match(ls, TK_end, TK_function, line);
1856 pt = fs_finish(ls, (ls->lastline = ls->linenumber));
1857 pfs->bcbase = ls->bcstack + oldbase; /* May have been reallocated. */
1858 pfs->bclim = (BCPos)(ls->sizebcstack - oldbase);
1859 /* Store new prototype in the constant array of the parent. */
1860 expr_init(e, VRELOCABLE,
1861 bcemit_AD(pfs, BC_FNEW, 0, const_gc(pfs, obj2gco(pt), LJ_TPROTO)));
1862 #if LJ_HASFFI
1863 pfs->flags |= (fs.flags & PROTO_FFI);
1864 #endif
1865 if (!(pfs->flags & PROTO_CHILD)) {
1866 if (pfs->flags & PROTO_HAS_RETURN)
1867 pfs->flags |= PROTO_FIXUP_RETURN;
1868 pfs->flags |= PROTO_CHILD;
1869 }
1870 lj_lex_next(ls);
1871 }
1872
1873 /* Parse expression list. Last expression is left open. */
1874 static BCReg expr_list(LexState *ls, ExpDesc *v)
1875 {
1876 BCReg n = 1;
1877 expr(ls, v);
1878 while (lex_opt(ls, ',')) {
1879 expr_tonextreg(ls->fs, v);
1880 expr(ls, v);
1881 n++;
1882 }
1883 return n;
1884 }
1885
1886 /* Parse function argument list. */
1887 static void parse_args(LexState *ls, ExpDesc *e)
1888 {
1889 FuncState *fs = ls->fs;
1890 ExpDesc args;
1891 BCIns ins;
1892 BCReg base;
1893 BCLine line = ls->linenumber;
1894 if (ls->tok == '(') {
1895 #if !LJ_52
1896 if (line != ls->lastline)
1897 err_syntax(ls, LJ_ERR_XAMBIG);
1898 #endif
1899 lj_lex_next(ls);
1900 if (ls->tok == ')') { /* f(). */
1901 args.k = VVOID;
1902 } else {
1903 expr_list(ls, &args);
1904 if (args.k == VCALL) /* f(a, b, g()) or f(a, b, ...). */
1905 setbc_b(bcptr(fs, &args), 0); /* Pass on multiple results. */
1906 }
1907 lex_match(ls, ')', '(', line);
1908 } else if (ls->tok == '{') {
1909 expr_table(ls, &args);
1910 } else if (ls->tok == TK_string) {
1911 expr_init(&args, VKSTR, 0);
1912 args.u.sval = strV(&ls->tokval);
1913 lj_lex_next(ls);
1914 } else {
1915 err_syntax(ls, LJ_ERR_XFUNARG);
1916 return; /* Silence compiler. */
1917 }
1918 lj_assertFS(e->k == VNONRELOC, "bad expr type %d", e->k);
1919 base = e->u.s.info; /* Base register for call. */
1920 if (args.k == VCALL) {
1921 ins = BCINS_ABC(BC_CALLM, base, 2, args.u.s.aux - base - 1 - ls->fr2);
1922 } else {
1923 if (args.k != VVOID)
1924 expr_tonextreg(fs, &args);
1925 ins = BCINS_ABC(BC_CALL, base, 2, fs->freereg - base - ls->fr2);
1926 }
1927 expr_init(e, VCALL, bcemit_INS(fs, ins));
1928 e->u.s.aux = base;
1929 fs->bcbase[fs->pc - 1].line = line;
1930 fs->freereg = base+1; /* Leave one result by default. */
1931 }
1932
1933 /* Parse primary expression. */
1934 static void expr_primary(LexState *ls, ExpDesc *v)
1935 {
1936 FuncState *fs = ls->fs;
1937 /* Parse prefix expression. */
1938 if (ls->tok == '(') {
1939 BCLine line = ls->linenumber;
1940 lj_lex_next(ls);
1941 expr(ls, v);
1942 lex_match(ls, ')', '(', line);
1943 expr_discharge(ls->fs, v);
1944 } else if (ls->tok == TK_name || (!LJ_52 && ls->tok == TK_goto)) {
1945 var_lookup(ls, v);
1946 } else {
1947 err_syntax(ls, LJ_ERR_XSYMBOL);
1948 }
1949 for (;;) { /* Parse multiple expression suffixes. */
1950 if (ls->tok == '.') {
1951 expr_field(ls, v);
1952 } else if (ls->tok == '[') {
1953 ExpDesc key;
1954 expr_toanyreg(fs, v);
1955 expr_bracket(ls, &key);
1956 expr_index(fs, v, &key);
1957 } else if (ls->tok == ':') {
1958 ExpDesc key;
1959 lj_lex_next(ls);
1960 expr_str(ls, &key);
1961 bcemit_method(fs, v, &key);
1962 parse_args(ls, v);
1963 } else if (ls->tok == '(' || ls->tok == TK_string || ls->tok == '{') {
1964 expr_tonextreg(fs, v);
1965 if (ls->fr2) bcreg_reserve(fs, 1);
1966 parse_args(ls, v);
1967 } else {
1968 break;
1969 }
1970 }
1971 }
1972
1973 /* Parse simple expression. */
1974 static void expr_simple(LexState *ls, ExpDesc *v)
1975 {
1976 switch (ls->tok) {
1977 case TK_number:
1978 expr_init(v, (LJ_HASFFI && tviscdata(&ls->tokval)) ? VKCDATA : VKNUM, 0);
1979 copyTV(ls->L, &v->u.nval, &ls->tokval);
1980 break;
1981 case TK_string:
1982 expr_init(v, VKSTR, 0);
1983 v->u.sval = strV(&ls->tokval);
1984 break;
1985 case TK_nil:
1986 expr_init(v, VKNIL, 0);
1987 break;
1988 case TK_true:
1989 expr_init(v, VKTRUE, 0);
1990 break;
1991 case TK_false:
1992 expr_init(v, VKFALSE, 0);
1993 break;
1994 case TK_dots: { /* Vararg. */
1995 FuncState *fs = ls->fs;
1996 BCReg base;
1997 checkcond(ls, fs->flags & PROTO_VARARG, LJ_ERR_XDOTS);
1998 bcreg_reserve(fs, 1);
1999 base = fs->freereg-1;
2000 expr_init(v, VCALL, bcemit_ABC(fs, BC_VARG, base, 2, fs->numparams));
2001 v->u.s.aux = base;
2002 break;
2003 }
2004 case '{': /* Table constructor. */
2005 expr_table(ls, v);
2006 return;
2007 case TK_function:
2008 lj_lex_next(ls);
2009 parse_body(ls, v, 0, ls->linenumber);
2010 return;
2011 default:
2012 expr_primary(ls, v);
2013 return;
2014 }
2015 lj_lex_next(ls);
2016 }
2017
2018 /* Manage syntactic levels to avoid blowing up the stack. */
2019 static void synlevel_begin(LexState *ls)
2020 {
2021 if (++ls->level >= LJ_MAX_XLEVEL)
2022 lj_lex_error(ls, 0, LJ_ERR_XLEVELS);
2023 }
2024
2025 #define synlevel_end(ls) ((ls)->level--)
2026
2027 /* Convert token to binary operator. */
2028 static BinOpr token2binop(LexToken tok)
2029 {
2030 switch (tok) {
2031 case '+': return OPR_ADD;
2032 case '-': return OPR_SUB;
2033 case '*': return OPR_MUL;
2034 case '/': return OPR_DIV;
2035 case '%': return OPR_MOD;
2036 case '^': return OPR_POW;
2037 case TK_concat: return OPR_CONCAT;
2038 case TK_ne: return OPR_NE;
2039 case TK_eq: return OPR_EQ;
2040 case '<': return OPR_LT;
2041 case TK_le: return OPR_LE;
2042 case '>': return OPR_GT;
2043 case TK_ge: return OPR_GE;
2044 case TK_and: return OPR_AND;
2045 case TK_or: return OPR_OR;
2046 default: return OPR_NOBINOPR;
2047 }
2048 }
2049
2050 /* Priorities for each binary operator. ORDER OPR. */
2051 static const struct {
2052 uint8_t left; /* Left priority. */
2053 uint8_t right; /* Right priority. */
2054 } priority[] = {
2055 {6,6}, {6,6}, {7,7}, {7,7}, {7,7}, /* ADD SUB MUL DIV MOD */
2056 {10,9}, {5,4}, /* POW CONCAT (right associative) */
2057 {3,3}, {3,3}, /* EQ NE */
2058 {3,3}, {3,3}, {3,3}, {3,3}, /* LT GE GT LE */
2059 {2,2}, {1,1} /* AND OR */
2060 };
2061
2062 #define UNARY_PRIORITY 8 /* Priority for unary operators. */
2063
2064 /* Forward declaration. */
2065 static BinOpr expr_binop(LexState *ls, ExpDesc *v, uint32_t limit);
2066
2067 /* Parse unary expression. */
2068 static void expr_unop(LexState *ls, ExpDesc *v)
2069 {
2070 BCOp op;
2071 if (ls->tok == TK_not) {
2072 op = BC_NOT;
2073 } else if (ls->tok == '-') {
2074 op = BC_UNM;
2075 } else if (ls->tok == '#') {
2076 op = BC_LEN;
2077 } else {
2078 expr_simple(ls, v);
2079 return;
2080 }
2081 lj_lex_next(ls);
2082 expr_binop(ls, v, UNARY_PRIORITY);
2083 bcemit_unop(ls->fs, op, v);
2084 }
2085
2086 /* Parse binary expressions with priority higher than the limit. */
2087 static BinOpr expr_binop(LexState *ls, ExpDesc *v, uint32_t limit)
2088 {
2089 BinOpr op;
2090 synlevel_begin(ls);
2091 expr_unop(ls, v);
2092 op = token2binop(ls->tok);
2093 while (op != OPR_NOBINOPR && priority[op].left > limit) {
2094 ExpDesc v2;
2095 BinOpr nextop;
2096 lj_lex_next(ls);
2097 bcemit_binop_left(ls->fs, op, v);
2098 /* Parse binary expression with higher priority. */
2099 nextop = expr_binop(ls, &v2, priority[op].right);
2100 bcemit_binop(ls->fs, op, v, &v2);
2101 op = nextop;
2102 }
2103 synlevel_end(ls);
2104 return op; /* Return unconsumed binary operator (if any). */
2105 }
2106
2107 /* Parse expression. */
2108 static void expr(LexState *ls, ExpDesc *v)
2109 {
2110 expr_binop(ls, v, 0); /* Priority 0: parse whole expression. */
2111 }
2112
2113 /* Assign expression to the next register. */
2114 static void expr_next(LexState *ls)
2115 {
2116 ExpDesc e;
2117 expr(ls, &e);
2118 expr_tonextreg(ls->fs, &e);
2119 }
2120
2121 /* Parse conditional expression. */
2122 static BCPos expr_cond(LexState *ls)
2123 {
2124 ExpDesc v;
2125 expr(ls, &v);
2126 if (v.k == VKNIL) v.k = VKFALSE;
2127 bcemit_branch_t(ls->fs, &v);
2128 return v.f;
2129 }
2130
2131 /* -- Assignments --------------------------------------------------------- */
2132
2133 /* List of LHS variables. */
2134 typedef struct LHSVarList {
2135 ExpDesc v; /* LHS variable. */
2136 struct LHSVarList *prev; /* Link to previous LHS variable. */
2137 } LHSVarList;
2138
2139 /* Eliminate write-after-read hazards for local variable assignment. */
2140 static void assign_hazard(LexState *ls, LHSVarList *lh, const ExpDesc *v)
2141 {
2142 FuncState *fs = ls->fs;
2143 BCReg reg = v->u.s.info; /* Check against this variable. */
2144 BCReg tmp = fs->freereg; /* Rename to this temp. register (if needed). */
2145 int hazard = 0;
2146 for (; lh; lh = lh->prev) {
2147 if (lh->v.k == VINDEXED) {
2148 if (lh->v.u.s.info == reg) { /* t[i], t = 1, 2 */
2149 hazard = 1;
2150 lh->v.u.s.info = tmp;
2151 }
2152 if (lh->v.u.s.aux == reg) { /* t[i], i = 1, 2 */
2153 hazard = 1;
2154 lh->v.u.s.aux = tmp;
2155 }
2156 }
2157 }
2158 if (hazard) {
2159 bcemit_AD(fs, BC_MOV, tmp, reg); /* Rename conflicting variable. */
2160 bcreg_reserve(fs, 1);
2161 }
2162 }
2163
2164 /* Adjust LHS/RHS of an assignment. */
2165 static void assign_adjust(LexState *ls, BCReg nvars, BCReg nexps, ExpDesc *e)
2166 {
2167 FuncState *fs = ls->fs;
2168 int32_t extra = (int32_t)nvars - (int32_t)nexps;
2169 if (e->k == VCALL) {
2170 extra++; /* Compensate for the VCALL itself. */
2171 if (extra < 0) extra = 0;
2172 setbc_b(bcptr(fs, e), extra+1); /* Fixup call results. */
2173 if (extra > 1) bcreg_reserve(fs, (BCReg)extra-1);
2174 } else {
2175 if (e->k != VVOID)
2176 expr_tonextreg(fs, e); /* Close last expression. */
2177 if (extra > 0) { /* Leftover LHS are set to nil. */
2178 BCReg reg = fs->freereg;
2179 bcreg_reserve(fs, (BCReg)extra);
2180 bcemit_nil(fs, reg, (BCReg)extra);
2181 }
2182 }
2183 if (nexps > nvars)
2184 ls->fs->freereg -= nexps - nvars; /* Drop leftover regs. */
2185 }
2186
2187 /* Recursively parse assignment statement. */
2188 static void parse_assignment(LexState *ls, LHSVarList *lh, BCReg nvars)
2189 {
2190 ExpDesc e;
2191 checkcond(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED, LJ_ERR_XSYNTAX);
2192 if (lex_opt(ls, ',')) { /* Collect LHS list and recurse upwards. */
2193 LHSVarList vl;
2194 vl.prev = lh;
2195 expr_primary(ls, &vl.v);
2196 if (vl.v.k == VLOCAL)
2197 assign_hazard(ls, lh, &vl.v);
2198 checklimit(ls->fs, ls->level + nvars, LJ_MAX_XLEVEL, "variable names");
2199 parse_assignment(ls, &vl, nvars+1);
2200 } else { /* Parse RHS. */
2201 BCReg nexps;
2202 lex_check(ls, '=');
2203 nexps = expr_list(ls, &e);
2204 if (nexps == nvars) {
2205 if (e.k == VCALL) {
2206 if (bc_op(*bcptr(ls->fs, &e)) == BC_VARG) { /* Vararg assignment. */
2207 ls->fs->freereg--;
2208 e.k = VRELOCABLE;
2209 } else { /* Multiple call results. */
2210 e.u.s.info = e.u.s.aux; /* Base of call is not relocatable. */
2211 e.k = VNONRELOC;
2212 }
2213 }
2214 bcemit_store(ls->fs, &lh->v, &e);
2215 return;
2216 }
2217 assign_adjust(ls, nvars, nexps, &e);
2218 }
2219 /* Assign RHS to LHS and recurse downwards. */
2220 expr_init(&e, VNONRELOC, ls->fs->freereg-1);
2221 bcemit_store(ls->fs, &lh->v, &e);
2222 }
2223
2224 /* Parse call statement or assignment. */
2225 static void parse_call_assign(LexState *ls)
2226 {
2227 FuncState *fs = ls->fs;
2228 LHSVarList vl;
2229 expr_primary(ls, &vl.v);
2230 if (vl.v.k == VCALL) { /* Function call statement. */
2231 setbc_b(bcptr(fs, &vl.v), 1); /* No results. */
2232 } else { /* Start of an assignment. */
2233 vl.prev = NULL;
2234 parse_assignment(ls, &vl, 1);
2235 }
2236 }
2237
2238 /* Parse 'local' statement. */
2239 static void parse_local(LexState *ls)
2240 {
2241 if (lex_opt(ls, TK_function)) { /* Local function declaration. */
2242 ExpDesc v, b;
2243 FuncState *fs = ls->fs;
2244 var_new(ls, 0, lex_str(ls));
2245 expr_init(&v, VLOCAL, fs->freereg);
2246 v.u.s.aux = fs->varmap[fs->freereg];
2247 bcreg_reserve(fs, 1);
2248 var_add(ls, 1);
2249 parse_body(ls, &b, 0, ls->linenumber);
2250 /* bcemit_store(fs, &v, &b) without setting VSTACK_VAR_RW. */
2251 expr_free(fs, &b);
2252 expr_toreg(fs, &b, v.u.s.info);
2253 /* The upvalue is in scope, but the local is only valid after the store. */
2254 var_get(ls, fs, fs->nactvar - 1).startpc = fs->pc;
2255 } else { /* Local variable declaration. */
2256 ExpDesc e;
2257 BCReg nexps, nvars = 0;
2258 do { /* Collect LHS. */
2259 var_new(ls, nvars++, lex_str(ls));
2260 } while (lex_opt(ls, ','));
2261 if (lex_opt(ls, '=')) { /* Optional RHS. */
2262 nexps = expr_list(ls, &e);
2263 } else { /* Or implicitly set to nil. */
2264 e.k = VVOID;
2265 nexps = 0;
2266 }
2267 assign_adjust(ls, nvars, nexps, &e);
2268 var_add(ls, nvars);
2269 }
2270 }
2271
2272 /* Parse 'function' statement. */
2273 static void parse_func(LexState *ls, BCLine line)
2274 {
2275 FuncState *fs;
2276 ExpDesc v, b;
2277 int needself = 0;
2278 lj_lex_next(ls); /* Skip 'function'. */
2279 /* Parse function name. */
2280 var_lookup(ls, &v);
2281 while (ls->tok == '.') /* Multiple dot-separated fields. */
2282 expr_field(ls, &v);
2283 if (ls->tok == ':') { /* Optional colon to signify method call. */
2284 needself = 1;
2285 expr_field(ls, &v);
2286 }
2287 parse_body(ls, &b, needself, line);
2288 fs = ls->fs;
2289 bcemit_store(fs, &v, &b);
2290 fs->bcbase[fs->pc - 1].line = line; /* Set line for the store. */
2291 }
2292
2293 /* -- Control transfer statements ----------------------------------------- */
2294
2295 /* Check for end of block. */
2296 static int parse_isend(LexToken tok)
2297 {
2298 switch (tok) {
2299 case TK_else: case TK_elseif: case TK_end: case TK_until: case TK_eof:
2300 return 1;
2301 default:
2302 return 0;
2303 }
2304 }
2305
2306 /* Parse 'return' statement. */
2307 static void parse_return(LexState *ls)
2308 {
2309 BCIns ins;
2310 FuncState *fs = ls->fs;
2311 lj_lex_next(ls); /* Skip 'return'. */
2312 fs->flags |= PROTO_HAS_RETURN;
2313 if (parse_isend(ls->tok) || ls->tok == ';') { /* Bare return. */
2314 ins = BCINS_AD(BC_RET0, 0, 1);
2315 } else { /* Return with one or more values. */
2316 ExpDesc e; /* Receives the _last_ expression in the list. */
2317 BCReg nret = expr_list(ls, &e);
2318 if (nret == 1) { /* Return one result. */
2319 if (e.k == VCALL) { /* Check for tail call. */
2320 #ifdef LUAJIT_DISABLE_TAILCALL
2321 goto notailcall;
2322 #else
2323 BCIns *ip = bcptr(fs, &e);
2324 /* It doesn't pay off to add BC_VARGT just for 'return ...'. */
2325 if (bc_op(*ip) == BC_VARG) goto notailcall;
2326 fs->pc--;
2327 ins = BCINS_AD(bc_op(*ip)-BC_CALL+BC_CALLT, bc_a(*ip), bc_c(*ip));
2328 #endif
2329 } else { /* Can return the result from any register. */
2330 ins = BCINS_AD(BC_RET1, expr_toanyreg(fs, &e), 2);
2331 }
2332 } else {
2333 if (e.k == VCALL) { /* Append all results from a call. */
2334 notailcall:
2335 setbc_b(bcptr(fs, &e), 0);
2336 ins = BCINS_AD(BC_RETM, fs->nactvar, e.u.s.aux - fs->nactvar);
2337 } else {
2338 expr_tonextreg(fs, &e); /* Force contiguous registers. */
2339 ins = BCINS_AD(BC_RET, fs->nactvar, nret+1);
2340 }
2341 }
2342 }
2343 if (fs->flags & PROTO_CHILD)
2344 bcemit_AJ(fs, BC_UCLO, 0, 0); /* May need to close upvalues first. */
2345 bcemit_INS(fs, ins);
2346 }
2347
2348 /* Parse 'break' statement. */
2349 static void parse_break(LexState *ls)
2350 {
2351 ls->fs->bl->flags |= FSCOPE_BREAK;
2352 gola_new(ls, NAME_BREAK, VSTACK_GOTO, bcemit_jmp(ls->fs));
2353 }
2354
2355 /* Parse 'goto' statement. */
2356 static void parse_goto(LexState *ls)
2357 {
2358 FuncState *fs = ls->fs;
2359 GCstr *name = lex_str(ls);
2360 VarInfo *vl = gola_findlabel(ls, name);
2361 if (vl) /* Treat backwards goto within same scope like a loop. */
2362 bcemit_AJ(fs, BC_LOOP, vl->slot, -1); /* No BC range check. */
2363 fs->bl->flags |= FSCOPE_GOLA;
2364 gola_new(ls, name, VSTACK_GOTO, bcemit_jmp(fs));
2365 }
2366
2367 /* Parse label. */
2368 static void parse_label(LexState *ls)
2369 {
2370 FuncState *fs = ls->fs;
2371 GCstr *name;
2372 MSize idx;
2373 fs->lasttarget = fs->pc;
2374 fs->bl->flags |= FSCOPE_GOLA;
2375 lj_lex_next(ls); /* Skip '::'. */
2376 name = lex_str(ls);
2377 if (gola_findlabel(ls, name))
2378 lj_lex_error(ls, 0, LJ_ERR_XLDUP, strdata(name));
2379 idx = gola_new(ls, name, VSTACK_LABEL, fs->pc);
2380 lex_check(ls, TK_label);
2381 /* Recursively parse trailing statements: labels and ';' (Lua 5.2 only). */
2382 for (;;) {
2383 if (ls->tok == TK_label) {
2384 synlevel_begin(ls);
2385 parse_label(ls);
2386 synlevel_end(ls);
2387 } else if (LJ_52 && ls->tok == ';') {
2388 lj_lex_next(ls);
2389 } else {
2390 break;
2391 }
2392 }
2393 /* Trailing label is considered to be outside of scope. */
2394 if (parse_isend(ls->tok) && ls->tok != TK_until)
2395 ls->vstack[idx].slot = fs->bl->nactvar;
2396 gola_resolve(ls, fs->bl, idx);
2397 }
2398
2399 /* -- Blocks, loops and conditional statements ---------------------------- */
2400
2401 /* Parse a block. */
2402 static void parse_block(LexState *ls)
2403 {
2404 FuncState *fs = ls->fs;
2405 FuncScope bl;
2406 fscope_begin(fs, &bl, 0);
2407 parse_chunk(ls);
2408 fscope_end(fs);
2409 }
2410
2411 /* Parse 'while' statement. */
2412 static void parse_while(LexState *ls, BCLine line)
2413 {
2414 FuncState *fs = ls->fs;
2415 BCPos start, loop, condexit;
2416 FuncScope bl;
2417 lj_lex_next(ls); /* Skip 'while'. */
2418 start = fs->lasttarget = fs->pc;
2419 condexit = expr_cond(ls);
2420 fscope_begin(fs, &bl, FSCOPE_LOOP);
2421 lex_check(ls, TK_do);
2422 loop = bcemit_AD(fs, BC_LOOP, fs->nactvar, 0);
2423 parse_block(ls);
2424 jmp_patch(fs, bcemit_jmp(fs), start);
2425 lex_match(ls, TK_end, TK_while, line);
2426 fscope_end(fs);
2427 jmp_tohere(fs, condexit);
2428 jmp_patchins(fs, loop, fs->pc);
2429 }
2430
2431 /* Parse 'repeat' statement. */
2432 static void parse_repeat(LexState *ls, BCLine line)
2433 {
2434 FuncState *fs = ls->fs;
2435 BCPos loop = fs->lasttarget = fs->pc;
2436 BCPos condexit;
2437 FuncScope bl1, bl2;
2438 fscope_begin(fs, &bl1, FSCOPE_LOOP); /* Breakable loop scope. */
2439 fscope_begin(fs, &bl2, 0); /* Inner scope. */
2440 lj_lex_next(ls); /* Skip 'repeat'. */
2441 bcemit_AD(fs, BC_LOOP, fs->nactvar, 0);
2442 parse_chunk(ls);
2443 lex_match(ls, TK_until, TK_repeat, line);
2444 condexit = expr_cond(ls); /* Parse condition (still inside inner scope). */
2445 if (!(bl2.flags & FSCOPE_UPVAL)) { /* No upvalues? Just end inner scope. */
2446 fscope_end(fs);
2447 } else { /* Otherwise generate: cond: UCLO+JMP out, !cond: UCLO+JMP loop. */
2448 parse_break(ls); /* Break from loop and close upvalues. */
2449 jmp_tohere(fs, condexit);
2450 fscope_end(fs); /* End inner scope and close upvalues. */
2451 condexit = bcemit_jmp(fs);
2452 }
2453 jmp_patch(fs, condexit, loop); /* Jump backwards if !cond. */
2454 jmp_patchins(fs, loop, fs->pc);
2455 fscope_end(fs); /* End loop scope. */
2456 }
2457
2458 /* Parse numeric 'for'. */
2459 static void parse_for_num(LexState *ls, GCstr *varname, BCLine line)
2460 {
2461 FuncState *fs = ls->fs;
2462 BCReg base = fs->freereg;
2463 FuncScope bl;
2464 BCPos loop, loopend;
2465 /* Hidden control variables. */
2466 var_new_fixed(ls, FORL_IDX, VARNAME_FOR_IDX);
2467 var_new_fixed(ls, FORL_STOP, VARNAME_FOR_STOP);
2468 var_new_fixed(ls, FORL_STEP, VARNAME_FOR_STEP);
2469 /* Visible copy of index variable. */
2470 var_new(ls, FORL_EXT, varname);
2471 lex_check(ls, '=');
2472 expr_next(ls);
2473 lex_check(ls, ',');
2474 expr_next(ls);
2475 if (lex_opt(ls, ',')) {
2476 expr_next(ls);
2477 } else {
2478 bcemit_AD(fs, BC_KSHORT, fs->freereg, 1); /* Default step is 1. */
2479 bcreg_reserve(fs, 1);
2480 }
2481 var_add(ls, 3); /* Hidden control variables. */
2482 lex_check(ls, TK_do);
2483 loop = bcemit_AJ(fs, BC_FORI, base, NO_JMP);
2484 fscope_begin(fs, &bl, 0); /* Scope for visible variables. */
2485 var_add(ls, 1);
2486 bcreg_reserve(fs, 1);
2487 parse_block(ls);
2488 fscope_end(fs);
2489 /* Perform loop inversion. Loop control instructions are at the end. */
2490 loopend = bcemit_AJ(fs, BC_FORL, base, NO_JMP);
2491 fs->bcbase[loopend].line = line; /* Fix line for control ins. */
2492 jmp_patchins(fs, loopend, loop+1);
2493 jmp_patchins(fs, loop, fs->pc);
2494 }
2495
2496 /* Try to predict whether the iterator is next() and specialize the bytecode.
2497 ** Detecting next() and pairs() by name is simplistic, but quite effective.
2498 ** The interpreter backs off if the check for the closure fails at runtime.
2499 */
2500 static int predict_next(LexState *ls, FuncState *fs, BCPos pc)
2501 {
2502 BCIns ins = fs->bcbase[pc].ins;
2503 GCstr *name;
2504 cTValue *o;
2505 switch (bc_op(ins)) {
2506 case BC_MOV:
2507 if (bc_d(ins) >= fs->nactvar) return 0;
2508 name = gco2str(gcref(var_get(ls, fs, bc_d(ins)).name));
2509 break;
2510 case BC_UGET:
2511 name = gco2str(gcref(ls->vstack[fs->uvmap[bc_d(ins)]].name));
2512 break;
2513 case BC_GGET:
2514 /* There's no inverse index (yet), so lookup the strings. */
2515 o = lj_tab_getstr(fs->kt, lj_str_newlit(ls->L, "pairs"));
2516 if (o && tvhaskslot(o) && tvkslot(o) == bc_d(ins))
2517 return 1;
2518 o = lj_tab_getstr(fs->kt, lj_str_newlit(ls->L, "next"));
2519 if (o && tvhaskslot(o) && tvkslot(o) == bc_d(ins))
2520 return 1;
2521 return 0;
2522 default:
2523 return 0;
2524 }
2525 return (name->len == 5 && !strcmp(strdata(name), "pairs")) ||
2526 (name->len == 4 && !strcmp(strdata(name), "next"));
2527 }
2528
2529 /* Parse 'for' iterator. */
2530 static void parse_for_iter(LexState *ls, GCstr *indexname)
2531 {
2532 FuncState *fs = ls->fs;
2533 ExpDesc e;
2534 BCReg nvars = 0;
2535 BCLine line;
2536 BCReg base = fs->freereg + 3;
2537 BCPos loop, loopend, exprpc = fs->pc;
2538 FuncScope bl;
2539 int isnext;
2540 /* Hidden control variables. */
2541 var_new_fixed(ls, nvars++, VARNAME_FOR_GEN);
2542 var_new_fixed(ls, nvars++, VARNAME_FOR_STATE);
2543 var_new_fixed(ls, nvars++, VARNAME_FOR_CTL);
2544 /* Visible variables returned from iterator. */
2545 var_new(ls, nvars++, indexname);
2546 while (lex_opt(ls, ','))
2547 var_new(ls, nvars++, lex_str(ls));
2548 lex_check(ls, TK_in);
2549 line = ls->linenumber;
2550 assign_adjust(ls, 3, expr_list(ls, &e), &e);
2551 /* The iterator needs another 3 [4] slots (func [pc] | state ctl). */
2552 bcreg_bump(fs, 3+ls->fr2);
2553 isnext = (nvars <= 5 && fs->pc > exprpc && predict_next(ls, fs, exprpc));
2554 var_add(ls, 3); /* Hidden control variables. */
2555 lex_check(ls, TK_do);
2556 loop = bcemit_AJ(fs, isnext ? BC_ISNEXT : BC_JMP, base, NO_JMP);
2557 fscope_begin(fs, &bl, 0); /* Scope for visible variables. */
2558 var_add(ls, nvars-3);
2559 bcreg_reserve(fs, nvars-3);
2560 parse_block(ls);
2561 fscope_end(fs);
2562 /* Perform loop inversion. Loop control instructions are at the end. */
2563 jmp_patchins(fs, loop, fs->pc);
2564 bcemit_ABC(fs, isnext ? BC_ITERN : BC_ITERC, base, nvars-3+1, 2+1);
2565 loopend = bcemit_AJ(fs, BC_ITERL, base, NO_JMP);
2566 fs->bcbase[loopend-1].line = line; /* Fix line for control ins. */
2567 fs->bcbase[loopend].line = line;
2568 jmp_patchins(fs, loopend, loop+1);
2569 }
2570
2571 /* Parse 'for' statement. */
2572 static void parse_for(LexState *ls, BCLine line)
2573 {
2574 FuncState *fs = ls->fs;
2575 GCstr *varname;
2576 FuncScope bl;
2577 fscope_begin(fs, &bl, FSCOPE_LOOP);
2578 lj_lex_next(ls); /* Skip 'for'. */
2579 varname = lex_str(ls); /* Get first variable name. */
2580 if (ls->tok == '=')
2581 parse_for_num(ls, varname, line);
2582 else if (ls->tok == ',' || ls->tok == TK_in)
2583 parse_for_iter(ls, varname);
2584 else
2585 err_syntax(ls, LJ_ERR_XFOR);
2586 lex_match(ls, TK_end, TK_for, line);
2587 fscope_end(fs); /* Resolve break list. */
2588 }
2589
2590 /* Parse condition and 'then' block. */
2591 static BCPos parse_then(LexState *ls)
2592 {
2593 BCPos condexit;
2594 lj_lex_next(ls); /* Skip 'if' or 'elseif'. */
2595 condexit = expr_cond(ls);
2596 lex_check(ls, TK_then);
2597 parse_block(ls);
2598 return condexit;
2599 }
2600
2601 /* Parse 'if' statement. */
2602 static void parse_if(LexState *ls, BCLine line)
2603 {
2604 FuncState *fs = ls->fs;
2605 BCPos flist;
2606 BCPos escapelist = NO_JMP;
2607 flist = parse_then(ls);
2608 while (ls->tok == TK_elseif) { /* Parse multiple 'elseif' blocks. */
2609 jmp_append(fs, &escapelist, bcemit_jmp(fs));
2610 jmp_tohere(fs, flist);
2611 flist = parse_then(ls);
2612 }
2613 if (ls->tok == TK_else) { /* Parse optional 'else' block. */
2614 jmp_append(fs, &escapelist, bcemit_jmp(fs));
2615 jmp_tohere(fs, flist);
2616 lj_lex_next(ls); /* Skip 'else'. */
2617 parse_block(ls);
2618 } else {
2619 jmp_append(fs, &escapelist, flist);
2620 }
2621 jmp_tohere(fs, escapelist);
2622 lex_match(ls, TK_end, TK_if, line);
2623 }
2624
2625 /* -- Parse statements ---------------------------------------------------- */
2626
2627 /* Parse a statement. Returns 1 if it must be the last one in a chunk. */
2628 static int parse_stmt(LexState *ls)
2629 {
2630 BCLine line = ls->linenumber;
2631 switch (ls->tok) {
2632 case TK_if:
2633 parse_if(ls, line);
2634 break;
2635 case TK_while:
2636 parse_while(ls, line);
2637 break;
2638 case TK_do:
2639 lj_lex_next(ls);
2640 parse_block(ls);
2641 lex_match(ls, TK_end, TK_do, line);
2642 break;
2643 case TK_for:
2644 parse_for(ls, line);
2645 break;
2646 case TK_repeat:
2647 parse_repeat(ls, line);
2648 break;
2649 case TK_function:
2650 parse_func(ls, line);
2651 break;
2652 case TK_local:
2653 lj_lex_next(ls);
2654 parse_local(ls);
2655 break;
2656 case TK_return:
2657 parse_return(ls);
2658 return 1; /* Must be last. */
2659 case TK_break:
2660 lj_lex_next(ls);
2661 parse_break(ls);
2662 return !LJ_52; /* Must be last in Lua 5.1. */
2663 #if LJ_52
2664 case ';':
2665 lj_lex_next(ls);
2666 break;
2667 #endif
2668 case TK_label:
2669 parse_label(ls);
2670 break;
2671 case TK_goto:
2672 if (LJ_52 || lj_lex_lookahead(ls) == TK_name) {
2673 lj_lex_next(ls);
2674 parse_goto(ls);
2675 break;
2676 }
2677 /* fallthrough */
2678 default:
2679 parse_call_assign(ls);
2680 break;
2681 }
2682 return 0;
2683 }
2684
2685 /* A chunk is a list of statements optionally separated by semicolons. */
2686 static void parse_chunk(LexState *ls)
2687 {
2688 int islast = 0;
2689 synlevel_begin(ls);
2690 while (!islast && !parse_isend(ls->tok)) {
2691 islast = parse_stmt(ls);
2692 lex_opt(ls, ';');
2693 lj_assertLS(ls->fs->framesize >= ls->fs->freereg &&
2694 ls->fs->freereg >= ls->fs->nactvar,
2695 "bad regalloc");
2696 ls->fs->freereg = ls->fs->nactvar; /* Free registers after each stmt. */
2697 }
2698 synlevel_end(ls);
2699 }
2700
2701 /* Entry point of bytecode parser. */
2702 GCproto *lj_parse(LexState *ls)
2703 {
2704 FuncState fs;
2705 FuncScope bl;
2706 GCproto *pt;
2707 lua_State *L = ls->L;
2708 #ifdef LUAJIT_DISABLE_DEBUGINFO
2709 ls->chunkname = lj_str_newlit(L, "=");
2710 #else
2711 ls->chunkname = lj_str_newz(L, ls->chunkarg);
2712 #endif
2713 setstrV(L, L->top, ls->chunkname); /* Anchor chunkname string. */
2714 incr_top(L);
2715 ls->level = 0;
2716 fs_init(ls, &fs);
2717 fs.linedefined = 0;
2718 fs.numparams = 0;
2719 fs.bcbase = NULL;
2720 fs.bclim = 0;
2721 fs.flags |= PROTO_VARARG; /* Main chunk is always a vararg func. */
2722 fscope_begin(&fs, &bl, 0);
2723 bcemit_AD(&fs, BC_FUNCV, 0, 0); /* Placeholder. */
2724 lj_lex_next(ls); /* Read-ahead first token. */
2725 parse_chunk(ls);
2726 if (ls->tok != TK_eof)
2727 err_token(ls, TK_eof);
2728 pt = fs_finish(ls, ls->linenumber);
2729 L->top--; /* Drop chunkname. */
2730 lj_assertL(fs.prev == NULL && ls->fs == NULL, "mismatched frame nesting");
2731 lj_assertL(pt->sizeuv == 0, "toplevel proto has upvalues");
2732 return pt;
2733 }
2734
LuaJIT is a Just-In-Time Compiler for the Lua programming language.