luna - luajit/src/lj

   1/*
   2** Lua parser (source code -> bytecode).
   3** Copyright (C) 2005-2026 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. */
  34typedef 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. */
  56typedef 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. */
  83static 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. */
  91static 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. */
  98typedef 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. */
 114typedef 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. */
 123typedef 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 */
 149typedef 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
 158LJ_STATIC_ASSERT((int)BC_ISGE-(int)BC_ISLT == (int)OPR_GE-(int)OPR_LT);
 159LJ_STATIC_ASSERT((int)BC_ISLE-(int)BC_ISLT == (int)OPR_LE-(int)OPR_LT);
 160LJ_STATIC_ASSERT((int)BC_ISGT-(int)BC_ISLT == (int)OPR_GT-(int)OPR_LT);
 161LJ_STATIC_ASSERT((int)BC_SUBVV-(int)BC_ADDVV == (int)OPR_SUB-(int)OPR_ADD);
 162LJ_STATIC_ASSERT((int)BC_MULVV-(int)BC_ADDVV == (int)OPR_MUL-(int)OPR_ADD);
 163LJ_STATIC_ASSERT((int)BC_DIVVV-(int)BC_ADDVV == (int)OPR_DIV-(int)OPR_ADD);
 164LJ_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
 174LJ_NORET LJ_NOINLINE static void err_syntax(LexState *ls, ErrMsg em)
 175{
 176  lj_lex_error(ls, ls->tok, em);
 177}
 178
 179LJ_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
 184LJ_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. */
 205static 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. */
 218static 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. */
 232static 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. */
 239GCstr *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. */
 252void 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. */
 264static 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. */
 274static 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. */
 285static 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. */
 311static 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. */
 318static 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. */
 329static 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. */
 345static 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. */
 359static 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. */
 366static 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. */
 379static 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. */
 390static void bcreg_reserve(FuncState *fs, BCReg n)
 391{
 392  bcreg_bump(fs, n);
 393  fs->freereg += n;
 394}
 395
 396/* Free register. */
 397static 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. */
 406static 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. */
 415static 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. */
 443static 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. */
 476static 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. */
 512static 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    int64_t i64;
 526    int32_t k;
 527    if (lj_num2int_cond(expr_numberV(e), i64, k, checki16((int32_t)i64)))
 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);
 555noins:
 556  e->u.s.info = reg;
 557  e->k = VNONRELOC;
 558}
 559
 560/* Forward declaration. */
 561static BCPos bcemit_jmp(FuncState *fs);
 562
 563/* Discharge an expression to a specific register. */
 564static 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. */
 589static 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. */
 598static 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. */
 613static 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. */
 622static 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. */
 668static 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. */
 693static 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. */
 710static 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. */
 717static 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. */
 738static 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. */
 756static 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. */
 776static 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    int64_t i64;
 786    int32_t k;
 787    if (lj_num2int_check(n, i64, k)) {
 788      setintV(&e1->u.nval, k);
 789      return 1;
 790    }
 791  }
 792  setnumV(&e1->u.nval, n);
 793  return 1;
 794}
 795
 796/* Emit arithmetic operator. */
 797static void bcemit_arith(FuncState *fs, BinOpr opr, ExpDesc *e1, ExpDesc *e2)
 798{
 799  BCReg rb, rc, t;
 800  uint32_t op;
 801  if (foldarith(opr, e1, e2))
 802    return;
 803  if (opr == OPR_POW) {
 804    op = BC_POW;
 805    rc = expr_toanyreg(fs, e2);
 806    rb = expr_toanyreg(fs, e1);
 807  } else {
 808    op = opr-OPR_ADD+BC_ADDVV;
 809    /* Must discharge 2nd operand first since VINDEXED might free regs. */
 810    expr_toval(fs, e2);
 811    if (expr_isnumk(e2) && (rc = const_num(fs, e2)) <= BCMAX_C)
 812      op -= BC_ADDVV-BC_ADDVN;
 813    else
 814      rc = expr_toanyreg(fs, e2);
 815    /* 1st operand discharged by bcemit_binop_left, but need KNUM/KSHORT. */
 816    lj_assertFS(expr_isnumk(e1) || e1->k == VNONRELOC,
 817		"bad expr type %d", e1->k);
 818    expr_toval(fs, e1);
 819    /* Avoid two consts to satisfy bytecode constraints. */
 820    if (expr_isnumk(e1) && !expr_isnumk(e2) &&
 821	(t = const_num(fs, e1)) <= BCMAX_B) {
 822      rb = rc; rc = t; op -= BC_ADDVV-BC_ADDNV;
 823    } else {
 824      rb = expr_toanyreg(fs, e1);
 825    }
 826  }
 827  /* Using expr_free might cause asserts if the order is wrong. */
 828  if (e1->k == VNONRELOC && e1->u.s.info >= fs->nactvar) fs->freereg--;
 829  if (e2->k == VNONRELOC && e2->u.s.info >= fs->nactvar) fs->freereg--;
 830  e1->u.s.info = bcemit_ABC(fs, op, 0, rb, rc);
 831  e1->k = VRELOCABLE;
 832}
 833
 834/* Emit comparison operator. */
 835static void bcemit_comp(FuncState *fs, BinOpr opr, ExpDesc *e1, ExpDesc *e2)
 836{
 837  ExpDesc *eret = e1;
 838  BCIns ins;
 839  expr_toval(fs, e1);
 840  if (opr == OPR_EQ || opr == OPR_NE) {
 841    BCOp op = opr == OPR_EQ ? BC_ISEQV : BC_ISNEV;
 842    BCReg ra;
 843    if (expr_isk(e1)) { e1 = e2; e2 = eret; }  /* Need constant in 2nd arg. */
 844    ra = expr_toanyreg(fs, e1);  /* First arg must be in a reg. */
 845    expr_toval(fs, e2);
 846    switch (e2->k) {
 847    case VKNIL: case VKFALSE: case VKTRUE:
 848      ins = BCINS_AD(op+(BC_ISEQP-BC_ISEQV), ra, const_pri(e2));
 849      break;
 850    case VKSTR:
 851      ins = BCINS_AD(op+(BC_ISEQS-BC_ISEQV), ra, const_str(fs, e2));
 852      break;
 853    case VKNUM:
 854      ins = BCINS_AD(op+(BC_ISEQN-BC_ISEQV), ra, const_num(fs, e2));
 855      break;
 856    default:
 857      ins = BCINS_AD(op, ra, expr_toanyreg(fs, e2));
 858      break;
 859    }
 860  } else {
 861    uint32_t op = opr-OPR_LT+BC_ISLT;
 862    BCReg ra, rd;
 863    if ((op-BC_ISLT) & 1) {  /* GT -> LT, GE -> LE */
 864      e1 = e2; e2 = eret;  /* Swap operands. */
 865      op = ((op-BC_ISLT)^3)+BC_ISLT;
 866      expr_toval(fs, e1);
 867      ra = expr_toanyreg(fs, e1);
 868      rd = expr_toanyreg(fs, e2);
 869    } else {
 870      rd = expr_toanyreg(fs, e2);
 871      ra = expr_toanyreg(fs, e1);
 872    }
 873    ins = BCINS_AD(op, ra, rd);
 874  }
 875  /* Using expr_free might cause asserts if the order is wrong. */
 876  if (e1->k == VNONRELOC && e1->u.s.info >= fs->nactvar) fs->freereg--;
 877  if (e2->k == VNONRELOC && e2->u.s.info >= fs->nactvar) fs->freereg--;
 878  bcemit_INS(fs, ins);
 879  eret->u.s.info = bcemit_jmp(fs);
 880  eret->k = VJMP;
 881}
 882
 883/* Fixup left side of binary operator. */
 884static void bcemit_binop_left(FuncState *fs, BinOpr op, ExpDesc *e)
 885{
 886  if (op == OPR_AND) {
 887    bcemit_branch_t(fs, e);
 888  } else if (op == OPR_OR) {
 889    bcemit_branch_f(fs, e);
 890  } else if (op == OPR_CONCAT) {
 891    expr_tonextreg(fs, e);
 892  } else if (op == OPR_EQ || op == OPR_NE) {
 893    if (!expr_isk_nojump(e)) expr_toanyreg(fs, e);
 894  } else {
 895    if (!expr_isnumk_nojump(e)) expr_toanyreg(fs, e);
 896  }
 897}
 898
 899/* Emit binary operator. */
 900static void bcemit_binop(FuncState *fs, BinOpr op, ExpDesc *e1, ExpDesc *e2)
 901{
 902  if (op <= OPR_POW) {
 903    bcemit_arith(fs, op, e1, e2);
 904  } else if (op == OPR_AND) {
 905    lj_assertFS(e1->t == NO_JMP, "jump list not closed");
 906    expr_discharge(fs, e2);
 907    jmp_append(fs, &e2->f, e1->f);
 908    *e1 = *e2;
 909  } else if (op == OPR_OR) {
 910    lj_assertFS(e1->f == NO_JMP, "jump list not closed");
 911    expr_discharge(fs, e2);
 912    jmp_append(fs, &e2->t, e1->t);
 913    *e1 = *e2;
 914  } else if (op == OPR_CONCAT) {
 915    expr_toval(fs, e2);
 916    if (e2->k == VRELOCABLE && bc_op(*bcptr(fs, e2)) == BC_CAT) {
 917      lj_assertFS(e1->u.s.info == bc_b(*bcptr(fs, e2))-1,
 918		  "bad CAT stack layout");
 919      expr_free(fs, e1);
 920      setbc_b(bcptr(fs, e2), e1->u.s.info);
 921      e1->u.s.info = e2->u.s.info;
 922    } else {
 923      expr_tonextreg(fs, e2);
 924      expr_free(fs, e2);
 925      expr_free(fs, e1);
 926      e1->u.s.info = bcemit_ABC(fs, BC_CAT, 0, e1->u.s.info, e2->u.s.info);
 927    }
 928    e1->k = VRELOCABLE;
 929  } else {
 930    lj_assertFS(op == OPR_NE || op == OPR_EQ ||
 931	       op == OPR_LT || op == OPR_GE || op == OPR_LE || op == OPR_GT,
 932	       "bad binop %d", op);
 933    bcemit_comp(fs, op, e1, e2);
 934  }
 935}
 936
 937/* Emit unary operator. */
 938static void bcemit_unop(FuncState *fs, BCOp op, ExpDesc *e)
 939{
 940  if (op == BC_NOT) {
 941    /* Swap true and false lists. */
 942    { BCPos temp = e->f; e->f = e->t; e->t = temp; }
 943    jmp_dropval(fs, e->f);
 944    jmp_dropval(fs, e->t);
 945    expr_discharge(fs, e);
 946    if (e->k == VKNIL || e->k == VKFALSE) {
 947      e->k = VKTRUE;
 948      return;
 949    } else if (expr_isk(e) || (LJ_HASFFI && e->k == VKCDATA)) {
 950      e->k = VKFALSE;
 951      return;
 952    } else if (e->k == VJMP) {
 953      invertcond(fs, e);
 954      return;
 955    } else if (e->k == VRELOCABLE) {
 956      bcreg_reserve(fs, 1);
 957      setbc_a(bcptr(fs, e), fs->freereg-1);
 958      e->u.s.info = fs->freereg-1;
 959      e->k = VNONRELOC;
 960    } else {
 961      lj_assertFS(e->k == VNONRELOC, "bad expr type %d", e->k);
 962    }
 963  } else {
 964    lj_assertFS(op == BC_UNM || op == BC_LEN, "bad unop %d", op);
 965    if (op == BC_UNM && !expr_hasjump(e)) {  /* Constant-fold negations. */
 966#if LJ_HASFFI
 967      if (e->k == VKCDATA) {  /* Fold in-place since cdata is not interned. */
 968	GCcdata *cd = cdataV(&e->u.nval);
 969	uint64_t *p = (uint64_t *)cdataptr(cd);
 970	if (cd->ctypeid == CTID_COMPLEX_DOUBLE)
 971	  p[1] ^= U64x(80000000,00000000);
 972	else
 973	  *p = ~*p+1u;
 974	return;
 975      } else
 976#endif
 977      if (expr_isnumk(e) && !expr_numiszero(e)) {  /* Avoid folding to -0. */
 978	TValue *o = expr_numtv(e);
 979	if (tvisint(o)) {
 980	  int32_t k = intV(o), negk = (int32_t)(~(uint32_t)k+1u);
 981	  if (k == negk)
 982	    setnumV(o, -(lua_Number)k);
 983	  else
 984	    setintV(o, negk);
 985	  return;
 986	} else {
 987	  o->u64 ^= U64x(80000000,00000000);
 988	  return;
 989	}
 990      }
 991    }
 992    expr_toanyreg(fs, e);
 993  }
 994  expr_free(fs, e);
 995  e->u.s.info = bcemit_AD(fs, op, 0, e->u.s.info);
 996  e->k = VRELOCABLE;
 997}
 998
 999/* -- Lexer support ------------------------------------------------------- */
1000
1001/* Check and consume optional token. */
1002static int lex_opt(LexState *ls, LexToken tok)
1003{
1004  if (ls->tok == tok) {
1005    lj_lex_next(ls);
1006    return 1;
1007  }
1008  return 0;
1009}
1010
1011/* Check and consume token. */
1012static void lex_check(LexState *ls, LexToken tok)
1013{
1014  if (ls->tok != tok)
1015    err_token(ls, tok);
1016  lj_lex_next(ls);
1017}
1018
1019/* Check for matching token. */
1020static void lex_match(LexState *ls, LexToken what, LexToken who, BCLine line)
1021{
1022  if (!lex_opt(ls, what)) {
1023    if (line == ls->linenumber) {
1024      err_token(ls, what);
1025    } else {
1026      const char *swhat = lj_lex_token2str(ls, what);
1027      const char *swho = lj_lex_token2str(ls, who);
1028      lj_lex_error(ls, ls->tok, LJ_ERR_XMATCH, swhat, swho, line);
1029    }
1030  }
1031}
1032
1033/* Check for string token. */
1034static GCstr *lex_str(LexState *ls)
1035{
1036  GCstr *s;
1037  if (ls->tok != TK_name && (LJ_52 || ls->tok != TK_goto))
1038    err_token(ls, TK_name);
1039  s = strV(&ls->tokval);
1040  lj_lex_next(ls);
1041  return s;
1042}
1043
1044/* -- Variable handling --------------------------------------------------- */
1045
1046#define var_get(ls, fs, i)	((ls)->vstack[(fs)->varmap[(i)]])
1047
1048/* Define a new local variable. */
1049static void var_new(LexState *ls, BCReg n, GCstr *name)
1050{
1051  FuncState *fs = ls->fs;
1052  MSize vtop = ls->vtop;
1053  checklimit(fs, fs->nactvar+n, LJ_MAX_LOCVAR, "local variables");
1054  if (LJ_UNLIKELY(vtop >= ls->sizevstack)) {
1055    if (ls->sizevstack >= LJ_MAX_VSTACK)
1056      lj_lex_error(ls, 0, LJ_ERR_XLIMC, LJ_MAX_VSTACK);
1057    lj_mem_growvec(ls->L, ls->vstack, ls->sizevstack, LJ_MAX_VSTACK, VarInfo);
1058  }
1059  lj_assertFS((uintptr_t)name < VARNAME__MAX ||
1060	      lj_tab_getstr(fs->kt, name) != NULL,
1061	      "unanchored variable name");
1062  /* NOBARRIER: name is anchored in fs->kt and ls->vstack is not a GCobj. */
1063  setgcref(ls->vstack[vtop].name, obj2gco(name));
1064  fs->varmap[fs->nactvar+n] = (uint16_t)vtop;
1065  ls->vtop = vtop+1;
1066}
1067
1068#define var_new_lit(ls, n, v) \
1069  var_new(ls, (n), lj_parse_keepstr(ls, "" v, sizeof(v)-1))
1070
1071#define var_new_fixed(ls, n, vn) \
1072  var_new(ls, (n), (GCstr *)(uintptr_t)(vn))
1073
1074/* Add local variables. */
1075static void var_add(LexState *ls, BCReg nvars)
1076{
1077  FuncState *fs = ls->fs;
1078  BCReg nactvar = fs->nactvar;
1079  while (nvars--) {
1080    VarInfo *v = &var_get(ls, fs, nactvar);
1081    v->startpc = fs->pc;
1082    v->slot = nactvar++;
1083    v->info = 0;
1084  }
1085  fs->nactvar = nactvar;
1086}
1087
1088/* Remove local variables. */
1089static void var_remove(LexState *ls, BCReg tolevel)
1090{
1091  FuncState *fs = ls->fs;
1092  while (fs->nactvar > tolevel)
1093    var_get(ls, fs, --fs->nactvar).endpc = fs->pc;
1094}
1095
1096/* Lookup local variable name. */
1097static BCReg var_lookup_local(FuncState *fs, GCstr *n)
1098{
1099  int i;
1100  for (i = fs->nactvar-1; i >= 0; i--) {
1101    if (n == strref(var_get(fs->ls, fs, i).name))
1102      return (BCReg)i;
1103  }
1104  return (BCReg)-1;  /* Not found. */
1105}
1106
1107/* Lookup or add upvalue index. */
1108static MSize var_lookup_uv(FuncState *fs, MSize vidx, ExpDesc *e)
1109{
1110  MSize i, n = fs->nuv;
1111  for (i = 0; i < n; i++)
1112    if (fs->uvmap[i] == vidx)
1113      return i;  /* Already exists. */
1114  /* Otherwise create a new one. */
1115  checklimit(fs, fs->nuv, LJ_MAX_UPVAL, "upvalues");
1116  lj_assertFS(e->k == VLOCAL || e->k == VUPVAL, "bad expr type %d", e->k);
1117  fs->uvmap[n] = (uint16_t)vidx;
1118  fs->uvtmp[n] = (uint16_t)(e->k == VLOCAL ? vidx : LJ_MAX_VSTACK+e->u.s.info);
1119  fs->nuv = n+1;
1120  return n;
1121}
1122
1123/* Forward declaration. */
1124static void fscope_uvmark(FuncState *fs, BCReg level);
1125
1126/* Recursively lookup variables in enclosing functions. */
1127static MSize var_lookup_(FuncState *fs, GCstr *name, ExpDesc *e, int first)
1128{
1129  if (fs) {
1130    BCReg reg = var_lookup_local(fs, name);
1131    if ((int32_t)reg >= 0) {  /* Local in this function? */
1132      expr_init(e, VLOCAL, reg);
1133      if (!first)
1134	fscope_uvmark(fs, reg);  /* Scope now has an upvalue. */
1135      return (MSize)(e->u.s.aux = (uint32_t)fs->varmap[reg]);
1136    } else {
1137      MSize vidx = var_lookup_(fs->prev, name, e, 0);  /* Var in outer func? */
1138      if ((int32_t)vidx >= 0) {  /* Yes, make it an upvalue here. */
1139	e->u.s.info = (uint8_t)var_lookup_uv(fs, vidx, e);
1140	e->k = VUPVAL;
1141	return vidx;
1142      }
1143    }
1144  } else {  /* Not found in any function, must be a global. */
1145    expr_init(e, VGLOBAL, 0);
1146    e->u.sval = name;
1147  }
1148  return (MSize)-1;  /* Global. */
1149}
1150
1151/* Lookup variable name. */
1152#define var_lookup(ls, e) \
1153  var_lookup_((ls)->fs, lex_str(ls), (e), 1)
1154
1155/* -- Goto an label handling ---------------------------------------------- */
1156
1157/* Add a new goto or label. */
1158static MSize gola_new(LexState *ls, GCstr *name, uint8_t info, BCPos pc)
1159{
1160  FuncState *fs = ls->fs;
1161  MSize vtop = ls->vtop;
1162  if (LJ_UNLIKELY(vtop >= ls->sizevstack)) {
1163    if (ls->sizevstack >= LJ_MAX_VSTACK)
1164      lj_lex_error(ls, 0, LJ_ERR_XLIMC, LJ_MAX_VSTACK);
1165    lj_mem_growvec(ls->L, ls->vstack, ls->sizevstack, LJ_MAX_VSTACK, VarInfo);
1166  }
1167  lj_assertFS(name == NAME_BREAK || lj_tab_getstr(fs->kt, name) != NULL,
1168	      "unanchored label name");
1169  /* NOBARRIER: name is anchored in fs->kt and ls->vstack is not a GCobj. */
1170  setgcref(ls->vstack[vtop].name, obj2gco(name));
1171  ls->vstack[vtop].startpc = pc;
1172  ls->vstack[vtop].slot = (uint8_t)fs->nactvar;
1173  ls->vstack[vtop].info = info;
1174  ls->vtop = vtop+1;
1175  return vtop;
1176}
1177
1178#define gola_isgoto(v)		((v)->info & VSTACK_GOTO)
1179#define gola_islabel(v)		((v)->info & VSTACK_LABEL)
1180#define gola_isgotolabel(v)	((v)->info & (VSTACK_GOTO|VSTACK_LABEL))
1181
1182/* Patch goto to jump to label. */
1183static void gola_patch(LexState *ls, VarInfo *vg, VarInfo *vl)
1184{
1185  FuncState *fs = ls->fs;
1186  BCPos pc = vg->startpc;
1187  setgcrefnull(vg->name);  /* Invalidate pending goto. */
1188  setbc_a(&fs->bcbase[pc].ins, vl->slot);
1189  jmp_patch(fs, pc, vl->startpc);
1190}
1191
1192/* Patch goto to close upvalues. */
1193static void gola_close(LexState *ls, VarInfo *vg)
1194{
1195  FuncState *fs = ls->fs;
1196  BCPos pc = vg->startpc;
1197  BCIns *ip = &fs->bcbase[pc].ins;
1198  lj_assertFS(gola_isgoto(vg), "expected goto");
1199  lj_assertFS(bc_op(*ip) == BC_JMP || bc_op(*ip) == BC_UCLO,
1200	      "bad bytecode op %d", bc_op(*ip));
1201  setbc_a(ip, vg->slot);
1202  if (bc_op(*ip) == BC_JMP) {
1203    BCPos next = jmp_next(fs, pc);
1204    if (next != NO_JMP) jmp_patch(fs, next, pc);  /* Jump to UCLO. */
1205    setbc_op(ip, BC_UCLO);  /* Turn into UCLO. */
1206    setbc_j(ip, NO_JMP);
1207  }
1208}
1209
1210/* Resolve pending forward gotos for label. */
1211static void gola_resolve(LexState *ls, FuncScope *bl, MSize idx)
1212{
1213  VarInfo *vg = ls->vstack + bl->vstart;
1214  VarInfo *vl = ls->vstack + idx;
1215  for (; vg < vl; vg++)
1216    if (gcrefeq(vg->name, vl->name) && gola_isgoto(vg)) {
1217      if (vg->slot < vl->slot) {
1218	GCstr *name = strref(var_get(ls, ls->fs, vg->slot).name);
1219	lj_assertLS((uintptr_t)name >= VARNAME__MAX, "expected goto name");
1220	ls->linenumber = ls->fs->bcbase[vg->startpc].line;
1221	lj_assertLS(strref(vg->name) != NAME_BREAK, "unexpected break");
1222	lj_lex_error(ls, 0, LJ_ERR_XGSCOPE,
1223		     strdata(strref(vg->name)), strdata(name));
1224      }
1225      gola_patch(ls, vg, vl);
1226    }
1227}
1228
1229/* Fixup remaining gotos and labels for scope. */
1230static void gola_fixup(LexState *ls, FuncScope *bl)
1231{
1232  VarInfo *v = ls->vstack + bl->vstart;
1233  VarInfo *ve = ls->vstack + ls->vtop;
1234  for (; v < ve; v++) {
1235    GCstr *name = strref(v->name);
1236    if (name != NULL) {  /* Only consider remaining valid gotos/labels. */
1237      if (gola_islabel(v)) {
1238	VarInfo *vg;
1239	setgcrefnull(v->name);  /* Invalidate label that goes out of scope. */
1240	for (vg = v+1; vg < ve; vg++)  /* Resolve pending backward gotos. */
1241	  if (strref(vg->name) == name && gola_isgoto(vg)) {
1242	    if ((bl->flags&FSCOPE_UPVAL) && vg->slot > v->slot)
1243	      gola_close(ls, vg);
1244	    gola_patch(ls, vg, v);
1245	  }
1246      } else if (gola_isgoto(v)) {
1247	if (bl->prev) {  /* Propagate goto or break to outer scope. */
1248	  bl->prev->flags |= name == NAME_BREAK ? FSCOPE_BREAK : FSCOPE_GOLA;
1249	  v->slot = bl->nactvar;
1250	  if ((bl->flags & FSCOPE_UPVAL))
1251	    gola_close(ls, v);
1252	} else {  /* No outer scope: undefined goto label or no loop. */
1253	  ls->linenumber = ls->fs->bcbase[v->startpc].line;
1254	  if (name == NAME_BREAK)
1255	    lj_lex_error(ls, 0, LJ_ERR_XBREAK);
1256	  else
1257	    lj_lex_error(ls, 0, LJ_ERR_XLUNDEF, strdata(name));
1258	}
1259      }
1260    }
1261  }
1262}
1263
1264/* Find existing label. */
1265static VarInfo *gola_findlabel(LexState *ls, GCstr *name)
1266{
1267  VarInfo *v = ls->vstack + ls->fs->bl->vstart;
1268  VarInfo *ve = ls->vstack + ls->vtop;
1269  for (; v < ve; v++)
1270    if (strref(v->name) == name && gola_islabel(v))
1271      return v;
1272  return NULL;
1273}
1274
1275/* -- Scope handling ------------------------------------------------------ */
1276
1277/* Begin a scope. */
1278static void fscope_begin(FuncState *fs, FuncScope *bl, int flags)
1279{
1280  bl->nactvar = (uint8_t)fs->nactvar;
1281  bl->flags = flags;
1282  bl->vstart = fs->ls->vtop;
1283  bl->prev = fs->bl;
1284  fs->bl = bl;
1285  lj_assertFS(fs->freereg == fs->nactvar, "bad regalloc");
1286}
1287
1288/* End a scope. */
1289static void fscope_end(FuncState *fs)
1290{
1291  FuncScope *bl = fs->bl;
1292  LexState *ls = fs->ls;
1293  fs->bl = bl->prev;
1294  var_remove(ls, bl->nactvar);
1295  fs->freereg = fs->nactvar;
1296  lj_assertFS(bl->nactvar == fs->nactvar, "bad regalloc");
1297  if ((bl->flags & (FSCOPE_UPVAL|FSCOPE_NOCLOSE)) == FSCOPE_UPVAL)
1298    bcemit_AJ(fs, BC_UCLO, bl->nactvar, 0);
1299  if ((bl->flags & FSCOPE_BREAK)) {
1300    if ((bl->flags & FSCOPE_LOOP)) {
1301      MSize idx = gola_new(ls, NAME_BREAK, VSTACK_LABEL, fs->pc);
1302      ls->vtop = idx;  /* Drop break label immediately. */
1303      gola_resolve(ls, bl, idx);
1304    } else {  /* Need the fixup step to propagate the breaks. */
1305      gola_fixup(ls, bl);
1306      return;
1307    }
1308  }
1309  if ((bl->flags & FSCOPE_GOLA)) {
1310    gola_fixup(ls, bl);
1311  }
1312}
1313
1314/* Mark scope as having an upvalue. */
1315static void fscope_uvmark(FuncState *fs, BCReg level)
1316{
1317  FuncScope *bl;
1318  for (bl = fs->bl; bl && bl->nactvar > level; bl = bl->prev)
1319    ;
1320  if (bl)
1321    bl->flags |= FSCOPE_UPVAL;
1322}
1323
1324/* -- Function state management ------------------------------------------- */
1325
1326/* Fixup bytecode for prototype. */
1327static void fs_fixup_bc(FuncState *fs, GCproto *pt, BCIns *bc, MSize n)
1328{
1329  BCInsLine *base = fs->bcbase;
1330  MSize i;
1331  BCIns op;
1332  pt->sizebc = n;
1333  if (fs->ls->fr2 != LJ_FR2) op = BC_NOT;  /* Mark non-native prototype. */
1334  else if ((fs->flags & PROTO_VARARG)) op = BC_FUNCV;
1335  else op = BC_FUNCF;
1336  bc[0] = BCINS_AD(op, fs->framesize, 0);
1337  for (i = 1; i < n; i++)
1338    bc[i] = base[i].ins;
1339}
1340
1341/* Fixup upvalues for child prototype, step #2. */
1342static void fs_fixup_uv2(FuncState *fs, GCproto *pt)
1343{
1344  VarInfo *vstack = fs->ls->vstack;
1345  uint16_t *uv = proto_uv(pt);
1346  MSize i, n = pt->sizeuv;
1347  for (i = 0; i < n; i++) {
1348    VarIndex vidx = uv[i];
1349    if (vidx >= LJ_MAX_VSTACK)
1350      uv[i] = vidx - LJ_MAX_VSTACK;
1351    else if ((vstack[vidx].info & VSTACK_VAR_RW))
1352      uv[i] = vstack[vidx].slot | PROTO_UV_LOCAL;
1353    else
1354      uv[i] = vstack[vidx].slot | PROTO_UV_LOCAL | PROTO_UV_IMMUTABLE;
1355  }
1356}
1357
1358/* Fixup constants for prototype. */
1359static void fs_fixup_k(FuncState *fs, GCproto *pt, void *kptr)
1360{
1361  GCtab *kt;
1362  TValue *array;
1363  Node *node;
1364  MSize i, hmask;
1365  checklimitgt(fs, fs->nkn, BCMAX_D+1, "constants");
1366  checklimitgt(fs, fs->nkgc, BCMAX_D+1, "constants");
1367  setmref(pt->k, kptr);
1368  pt->sizekn = fs->nkn;
1369  pt->sizekgc = fs->nkgc;
1370  kt = fs->kt;
1371  array = tvref(kt->array);
1372  for (i = 0; i < kt->asize; i++)
1373    if (tvhaskslot(&array[i])) {
1374      TValue *tv = &((TValue *)kptr)[tvkslot(&array[i])];
1375      if (LJ_DUALNUM)
1376	setintV(tv, (int32_t)i);
1377      else
1378	setnumV(tv, (lua_Number)i);
1379    }
1380  node = noderef(kt->node);
1381  hmask = kt->hmask;
1382  for (i = 0; i <= hmask; i++) {
1383    Node *n = &node[i];
1384    if (tvhaskslot(&n->val)) {
1385      ptrdiff_t kidx = (ptrdiff_t)tvkslot(&n->val);
1386      lj_assertFS(!tvisint(&n->key), "unexpected integer key");
1387      if (tvisnum(&n->key)) {
1388	TValue *tv = &((TValue *)kptr)[kidx];
1389	if (LJ_DUALNUM) {
1390	  int64_t i64;
1391	  int32_t k;
1392	  lj_assertFS(!tvismzero(&n->key), "unexpected -0 key");
1393	  if (lj_num2int_check(numV(&n->key), i64, k))
1394	    setintV(tv, k);
1395	  else
1396	    *tv = n->key;
1397	} else {
1398	  *tv = n->key;
1399	}
1400      } else {
1401	GCobj *o = gcV(&n->key);
1402	setgcref(((GCRef *)kptr)[~kidx], o);
1403	lj_gc_objbarrier(fs->L, pt, o);
1404	if (tvisproto(&n->key))
1405	  fs_fixup_uv2(fs, gco2pt(o));
1406      }
1407    }
1408  }
1409}
1410
1411/* Fixup upvalues for prototype, step #1. */
1412static void fs_fixup_uv1(FuncState *fs, GCproto *pt, uint16_t *uv)
1413{
1414  setmref(pt->uv, uv);
1415  pt->sizeuv = fs->nuv;
1416  memcpy(uv, fs->uvtmp, fs->nuv*sizeof(VarIndex));
1417}
1418
1419#ifndef LUAJIT_DISABLE_DEBUGINFO
1420/* Prepare lineinfo for prototype. */
1421static size_t fs_prep_line(FuncState *fs, BCLine numline)
1422{
1423  return (fs->pc-1) << (numline < 256 ? 0 : numline < 65536 ? 1 : 2);
1424}
1425
1426/* Fixup lineinfo for prototype. */
1427static void fs_fixup_line(FuncState *fs, GCproto *pt,
1428			  void *lineinfo, BCLine numline)
1429{
1430  BCInsLine *base = fs->bcbase + 1;
1431  BCLine first = fs->linedefined;
1432  MSize i = 0, n = fs->pc-1;
1433  pt->firstline = fs->linedefined;
1434  pt->numline = numline;
1435  setmref(pt->lineinfo, lineinfo);
1436  if (LJ_LIKELY(numline < 256)) {
1437    uint8_t *li = (uint8_t *)lineinfo;
1438    do {
1439      BCLine delta = base[i].line - first;
1440      lj_assertFS(delta >= 0 && delta < 256, "bad line delta");
1441      li[i] = (uint8_t)delta;
1442    } while (++i < n);
1443  } else if (LJ_LIKELY(numline < 65536)) {
1444    uint16_t *li = (uint16_t *)lineinfo;
1445    do {
1446      BCLine delta = base[i].line - first;
1447      lj_assertFS(delta >= 0 && delta < 65536, "bad line delta");
1448      li[i] = (uint16_t)delta;
1449    } while (++i < n);
1450  } else {
1451    uint32_t *li = (uint32_t *)lineinfo;
1452    do {
1453      BCLine delta = base[i].line - first;
1454      lj_assertFS(delta >= 0, "bad line delta");
1455      li[i] = (uint32_t)delta;
1456    } while (++i < n);
1457  }
1458}
1459
1460/* Prepare variable info for prototype. */
1461static size_t fs_prep_var(LexState *ls, FuncState *fs, size_t *ofsvar)
1462{
1463  VarInfo *vs =ls->vstack, *ve;
1464  MSize i, n;
1465  BCPos lastpc;
1466  lj_buf_reset(&ls->sb);  /* Copy to temp. string buffer. */
1467  /* Store upvalue names. */
1468  for (i = 0, n = fs->nuv; i < n; i++) {
1469    GCstr *s = strref(vs[fs->uvmap[i]].name);
1470    MSize len = s->len+1;
1471    char *p = lj_buf_more(&ls->sb, len);
1472    p = lj_buf_wmem(p, strdata(s), len);
1473    ls->sb.w = p;
1474  }
1475  *ofsvar = sbuflen(&ls->sb);
1476  lastpc = 0;
1477  /* Store local variable names and compressed ranges. */
1478  for (ve = vs + ls->vtop, vs += fs->vbase; vs < ve; vs++) {
1479    if (!gola_isgotolabel(vs)) {
1480      GCstr *s = strref(vs->name);
1481      BCPos startpc;
1482      char *p;
1483      if ((uintptr_t)s < VARNAME__MAX) {
1484	p = lj_buf_more(&ls->sb, 1 + 2*5);
1485	*p++ = (char)(uintptr_t)s;
1486      } else {
1487	MSize len = s->len+1;
1488	p = lj_buf_more(&ls->sb, len + 2*5);
1489	p = lj_buf_wmem(p, strdata(s), len);
1490      }
1491      startpc = vs->startpc;
1492      p = lj_strfmt_wuleb128(p, startpc-lastpc);
1493      p = lj_strfmt_wuleb128(p, vs->endpc-startpc);
1494      ls->sb.w = p;
1495      lastpc = startpc;
1496    }
1497  }
1498  lj_buf_putb(&ls->sb, '\0');  /* Terminator for varinfo. */
1499  return sbuflen(&ls->sb);
1500}
1501
1502/* Fixup variable info for prototype. */
1503static void fs_fixup_var(LexState *ls, GCproto *pt, uint8_t *p, size_t ofsvar)
1504{
1505  setmref(pt->uvinfo, p);
1506  setmref(pt->varinfo, (char *)p + ofsvar);
1507  memcpy(p, ls->sb.b, sbuflen(&ls->sb));  /* Copy from temp. buffer. */
1508}
1509#else
1510
1511/* Initialize with empty debug info, if disabled. */
1512#define fs_prep_line(fs, numline)		(UNUSED(numline), 0)
1513#define fs_fixup_line(fs, pt, li, numline) \
1514  pt->firstline = pt->numline = 0, setmref((pt)->lineinfo, NULL)
1515#define fs_prep_var(ls, fs, ofsvar)		(UNUSED(ofsvar), 0)
1516#define fs_fixup_var(ls, pt, p, ofsvar) \
1517  setmref((pt)->uvinfo, NULL), setmref((pt)->varinfo, NULL)
1518
1519#endif
1520
1521/* Fixup return instruction for prototype. */
1522static void fs_fixup_ret(FuncState *fs)
1523{
1524  BCPos lastpc = fs->pc;
1525  if (lastpc <= fs->lasttarget || !bc_isret_or_tail(bc_op(fs->bcbase[lastpc-1].ins))) {
1526    if ((fs->bl->flags & FSCOPE_UPVAL))
1527      bcemit_AJ(fs, BC_UCLO, 0, 0);
1528    bcemit_AD(fs, BC_RET0, 0, 1);  /* Need final return. */
1529  }
1530  fs->bl->flags |= FSCOPE_NOCLOSE;  /* Handled above. */
1531  fscope_end(fs);
1532  lj_assertFS(fs->bl == NULL, "bad scope nesting");
1533  /* May need to fixup returns encoded before first function was created. */
1534  if (fs->flags & PROTO_FIXUP_RETURN) {
1535    BCPos pc;
1536    for (pc = 1; pc < lastpc; pc++) {
1537      BCIns ins = fs->bcbase[pc].ins;
1538      BCPos offset;
1539      switch (bc_op(ins)) {
1540      case BC_CALLMT: case BC_CALLT:
1541      case BC_RETM: case BC_RET: case BC_RET0: case BC_RET1:
1542	offset = bcemit_INS(fs, ins);  /* Copy original instruction. */
1543	fs->bcbase[offset].line = fs->bcbase[pc].line;
1544	offset = offset-(pc+1)+BCBIAS_J;
1545	if (offset > BCMAX_D)
1546	  err_syntax(fs->ls, LJ_ERR_XFIXUP);
1547	/* Replace with UCLO plus branch. */
1548	fs->bcbase[pc].ins = BCINS_AD(BC_UCLO, 0, offset);
1549	break;
1550      case BC_FNEW:
1551	return;  /* We're done. */
1552      default:
1553	break;
1554      }
1555    }
1556  }
1557}
1558
1559/* Finish a FuncState and return the new prototype. */
1560static GCproto *fs_finish(LexState *ls, BCLine line)
1561{
1562  lua_State *L = ls->L;
1563  FuncState *fs = ls->fs;
1564  BCLine numline = line - fs->linedefined;
1565  size_t sizept, ofsk, ofsuv, ofsli, ofsdbg, ofsvar;
1566  GCproto *pt;
1567
1568  /* Apply final fixups. */
1569  fs_fixup_ret(fs);
1570
1571  /* Calculate total size of prototype including all colocated arrays. */
1572  sizept = sizeof(GCproto) + fs->pc*sizeof(BCIns) + fs->nkgc*sizeof(GCRef);
1573  sizept = (sizept + sizeof(TValue)-1) & ~(sizeof(TValue)-1);
1574  ofsk = sizept; sizept += fs->nkn*sizeof(TValue);
1575  ofsuv = sizept; sizept += ((fs->nuv+1)&~1)*2;
1576  ofsli = sizept; sizept += fs_prep_line(fs, numline);
1577  ofsdbg = sizept; sizept += fs_prep_var(ls, fs, &ofsvar);
1578
1579  /* Allocate prototype and initialize its fields. */
1580  pt = (GCproto *)lj_mem_newgco(L, (MSize)sizept);
1581  pt->gct = ~LJ_TPROTO;
1582  pt->sizept = (MSize)sizept;
1583  pt->trace = 0;
1584  pt->flags = (uint8_t)(fs->flags & ~(PROTO_HAS_RETURN|PROTO_FIXUP_RETURN));
1585  pt->numparams = fs->numparams;
1586  pt->framesize = fs->framesize;
1587  setgcref(pt->chunkname, obj2gco(ls->chunkname));
1588
1589  /* Close potentially uninitialized gap between bc and kgc. */
1590  *(uint32_t *)((char *)pt + ofsk - sizeof(GCRef)*(fs->nkgc+1)) = 0;
1591  fs_fixup_bc(fs, pt, (BCIns *)((char *)pt + sizeof(GCproto)), fs->pc);
1592  fs_fixup_k(fs, pt, (void *)((char *)pt + ofsk));
1593  fs_fixup_uv1(fs, pt, (uint16_t *)((char *)pt + ofsuv));
1594  fs_fixup_line(fs, pt, (void *)((char *)pt + ofsli), numline);
1595  fs_fixup_var(ls, pt, (uint8_t *)((char *)pt + ofsdbg), ofsvar);
1596
1597  lj_vmevent_send(G(L), BC,
1598    setprotoV(V, V->top++, pt);
1599  );
1600
1601  L->top--;  /* Pop table of constants. */
1602  ls->vtop = fs->vbase;  /* Reset variable stack. */
1603  ls->fs = fs->prev;
1604  lj_assertL(ls->fs != NULL || ls->tok == TK_eof, "bad parser state");
1605  return pt;
1606}
1607
1608/* Initialize a new FuncState. */
1609static void fs_init(LexState *ls, FuncState *fs)
1610{
1611  lua_State *L = ls->L;
1612  fs->prev = ls->fs; ls->fs = fs;  /* Append to list. */
1613  fs->ls = ls;
1614  fs->vbase = ls->vtop;
1615  fs->L = L;
1616  fs->pc = 0;
1617  fs->lasttarget = 0;
1618  fs->jpc = NO_JMP;
1619  fs->freereg = 0;
1620  fs->nkgc = 0;
1621  fs->nkn = 0;
1622  fs->nactvar = 0;
1623  fs->nuv = 0;
1624  fs->bl = NULL;
1625  fs->flags = 0;
1626  fs->framesize = 1;  /* Minimum frame size. */
1627  fs->kt = lj_tab_new(L, 0, 0);
1628  /* Anchor table of constants in stack to avoid being collected. */
1629  settabV(L, L->top, fs->kt);
1630  incr_top(L);
1631}
1632
1633/* -- Expressions --------------------------------------------------------- */
1634
1635/* Forward declaration. */
1636static void expr(LexState *ls, ExpDesc *v);
1637
1638/* Return string expression. */
1639static void expr_str(LexState *ls, ExpDesc *e)
1640{
1641  expr_init(e, VKSTR, 0);
1642  e->u.sval = lex_str(ls);
1643}
1644
1645/* Return index expression. */
1646static void expr_index(FuncState *fs, ExpDesc *t, ExpDesc *e)
1647{
1648  /* Already called: expr_toval(fs, e). */
1649  t->k = VINDEXED;
1650  if (expr_isnumk(e)) {
1651#if LJ_DUALNUM
1652    if (tvisint(expr_numtv(e))) {
1653      int32_t k = intV(expr_numtv(e));
1654      if (checku8(k)) {
1655	t->u.s.aux = BCMAX_C+1+(uint32_t)k;  /* 256..511: const byte key */
1656	return;
1657      }
1658    }
1659#else
1660    int64_t i64;
1661    int32_t k;
1662    if (lj_num2int_cond(expr_numberV(e), i64, k, checku8((int32_t)i64))) {
1663      t->u.s.aux = BCMAX_C+1+(uint32_t)k;  /* 256..511: const byte key */
1664      return;
1665    }
1666#endif
1667  } else if (expr_isstrk(e)) {
1668    BCReg idx = const_str(fs, e);
1669    if (idx <= BCMAX_C) {
1670      t->u.s.aux = ~idx;  /* -256..-1: const string key */
1671      return;
1672    }
1673  }
1674  t->u.s.aux = expr_toanyreg(fs, e);  /* 0..255: register */
1675}
1676
1677/* Parse index expression with named field. */
1678static void expr_field(LexState *ls, ExpDesc *v)
1679{
1680  FuncState *fs = ls->fs;
1681  ExpDesc key;
1682  expr_toanyreg(fs, v);
1683  lj_lex_next(ls);  /* Skip dot or colon. */
1684  expr_str(ls, &key);
1685  expr_index(fs, v, &key);
1686}
1687
1688/* Parse index expression with brackets. */
1689static void expr_bracket(LexState *ls, ExpDesc *v)
1690{
1691  lj_lex_next(ls);  /* Skip '['. */
1692  expr(ls, v);
1693  expr_toval(ls->fs, v);
1694  lex_check(ls, ']');
1695}
1696
1697/* Get value of constant expression. */
1698static void expr_kvalue(FuncState *fs, TValue *v, ExpDesc *e)
1699{
1700  UNUSED(fs);
1701  if (e->k <= VKTRUE) {
1702    setpriV(v, ~(uint32_t)e->k);
1703  } else if (e->k == VKSTR) {
1704    setgcVraw(v, obj2gco(e->u.sval), LJ_TSTR);
1705  } else {
1706    lj_assertFS(tvisnumber(expr_numtv(e)), "bad number constant");
1707    *v = *expr_numtv(e);
1708  }
1709}
1710
1711/* Parse table constructor expression. */
1712static void expr_table(LexState *ls, ExpDesc *e)
1713{
1714  FuncState *fs = ls->fs;
1715  BCLine line = ls->linenumber;
1716  GCtab *t = NULL;
1717  int vcall = 0, needarr = 0;
1718  uint32_t narr = 1;  /* First array index. */
1719  uint32_t nhash = 0;  /* Number of hash entries. */
1720  BCReg freg = fs->freereg;
1721  BCPos pc = bcemit_AD(fs, BC_TNEW, freg, 0);
1722  expr_init(e, VNONRELOC, freg);
1723  bcreg_reserve(fs, 1);
1724  freg++;
1725  lex_check(ls, '{');
1726  while (ls->tok != '}') {
1727    ExpDesc key, val;
1728    vcall = 0;
1729    if (ls->tok == '[') {
1730      expr_bracket(ls, &key);  /* Already calls expr_toval. */
1731      if (!expr_isk(&key)) expr_index(fs, e, &key);
1732      if (expr_isnumk(&key) && expr_numiszero(&key)) needarr = 1; else nhash++;
1733      lex_check(ls, '=');
1734    } else if ((ls->tok == TK_name || (!LJ_52 && ls->tok == TK_goto)) &&
1735	       lj_lex_lookahead(ls) == '=') {
1736      expr_str(ls, &key);
1737      lex_check(ls, '=');
1738      nhash++;
1739    } else {
1740      expr_init(&key, VKNUM, 0);
1741      setintV(&key.u.nval, (int)narr);
1742      narr++;
1743      needarr = vcall = 1;
1744    }
1745    expr(ls, &val);
1746    if (expr_isk(&key) && key.k != VKNIL &&
1747	(key.k == VKSTR || expr_isk_nojump(&val))) {
1748      TValue k, *v;
1749      if (!t) {  /* Create template table on demand. */
1750	BCReg kidx;
1751	t = lj_tab_new(fs->L, needarr ? narr : 0, hsize2hbits(nhash));
1752	kidx = const_gc(fs, obj2gco(t), LJ_TTAB);
1753	fs->bcbase[pc].ins = BCINS_AD(BC_TDUP, freg-1, kidx);
1754      }
1755      vcall = 0;
1756      expr_kvalue(fs, &k, &key);
1757      v = lj_tab_set(fs->L, t, &k);
1758      lj_gc_anybarriert(fs->L, t);
1759      if (expr_isk_nojump(&val)) {  /* Add const key/value to template table. */
1760	expr_kvalue(fs, v, &val);
1761	/* Mark nil value with table value itself to preserve the key. */
1762	if (key.k == VKSTR && tvisnil(v)) settabV(fs->L, v, t);
1763      } else {  /* Preserve the key for the following non-const store.  */
1764	settabV(fs->L, v, t);
1765	goto nonconst;
1766      }
1767    } else {
1768    nonconst:
1769      if (val.k != VCALL) { expr_toanyreg(fs, &val); vcall = 0; }
1770      if (expr_isk(&key)) expr_index(fs, e, &key);
1771      bcemit_store(fs, e, &val);
1772    }
1773    fs->freereg = freg;
1774    if (!lex_opt(ls, ',') && !lex_opt(ls, ';')) break;
1775  }
1776  lex_match(ls, '}', '{', line);
1777  if (vcall) {
1778    BCInsLine *ilp = &fs->bcbase[fs->pc-1];
1779    ExpDesc en;
1780    lj_assertFS(bc_a(ilp->ins) == freg &&
1781		bc_op(ilp->ins) == (narr > 256 ? BC_TSETV : BC_TSETB),
1782		"bad CALL code generation");
1783    expr_init(&en, VKNUM, 0);
1784    en.u.nval.u32.lo = narr-1;
1785    en.u.nval.u32.hi = 0x43300000;  /* Biased integer to avoid denormals. */
1786    if (narr > 256) { fs->pc--; ilp--; }
1787    ilp->ins = BCINS_AD(BC_TSETM, freg, const_num(fs, &en));
1788    setbc_b(&ilp[-1].ins, 0);
1789  }
1790  if (pc == fs->pc-1) {  /* Make expr relocable if possible. */
1791    e->u.s.info = pc;
1792    fs->freereg--;
1793    e->k = VRELOCABLE;
1794  } else {
1795    e->k = VNONRELOC;  /* May have been changed by expr_index. */
1796  }
1797  if (!t) {  /* Construct TNEW RD: hhhhhaaaaaaaaaaa. */
1798    BCIns *ip = &fs->bcbase[pc].ins;
1799    if (!needarr) narr = 0;
1800    else if (narr < 3) narr = 3;
1801    else if (narr > 0x7ff) narr = 0x7ff;
1802    setbc_d(ip, narr|(hsize2hbits(nhash)<<11));
1803  } else {
1804    if (needarr && t->asize < narr)
1805      lj_tab_reasize(fs->L, t, narr-1);
1806    lj_gc_check(fs->L);
1807  }
1808}
1809
1810/* Parse function parameters. */
1811static BCReg parse_params(LexState *ls, int needself)
1812{
1813  FuncState *fs = ls->fs;
1814  BCReg nparams = 0;
1815  lex_check(ls, '(');
1816  if (needself)
1817    var_new_lit(ls, nparams++, "self");
1818  if (ls->tok != ')') {
1819    do {
1820      if (ls->tok == TK_name || (!LJ_52 && ls->tok == TK_goto)) {
1821	var_new(ls, nparams++, lex_str(ls));
1822      } else if (ls->tok == TK_dots) {
1823	lj_lex_next(ls);
1824	fs->flags |= PROTO_VARARG;
1825	break;
1826      } else {
1827	err_syntax(ls, LJ_ERR_XPARAM);
1828      }
1829    } while (lex_opt(ls, ','));
1830  }
1831  var_add(ls, nparams);
1832  lj_assertFS(fs->nactvar == nparams, "bad regalloc");
1833  bcreg_reserve(fs, nparams);
1834  lex_check(ls, ')');
1835  return nparams;
1836}
1837
1838/* Forward declaration. */
1839static void parse_chunk(LexState *ls);
1840
1841/* Parse body of a function. */
1842static void parse_body(LexState *ls, ExpDesc *e, int needself, BCLine line)
1843{
1844  FuncState fs, *pfs = ls->fs;
1845  FuncScope bl;
1846  GCproto *pt;
1847  ptrdiff_t oldbase = pfs->bcbase - ls->bcstack;
1848  fs_init(ls, &fs);
1849  fscope_begin(&fs, &bl, 0);
1850  fs.linedefined = line;
1851  fs.numparams = (uint8_t)parse_params(ls, needself);
1852  fs.bcbase = pfs->bcbase + pfs->pc;
1853  fs.bclim = pfs->bclim - pfs->pc;
1854  bcemit_AD(&fs, BC_FUNCF, 0, 0);  /* Placeholder. */
1855  parse_chunk(ls);
1856  if (ls->tok != TK_end) lex_match(ls, TK_end, TK_function, line);
1857  pt = fs_finish(ls, (ls->lastline = ls->linenumber));
1858  pfs->bcbase = ls->bcstack + oldbase;  /* May have been reallocated. */
1859  pfs->bclim = (BCPos)(ls->sizebcstack - oldbase);
1860  /* Store new prototype in the constant array of the parent. */
1861  expr_init(e, VRELOCABLE,
1862	    bcemit_AD(pfs, BC_FNEW, 0, const_gc(pfs, obj2gco(pt), LJ_TPROTO)));
1863#if LJ_HASFFI
1864  pfs->flags |= (fs.flags & PROTO_FFI);
1865#endif
1866  if (!(pfs->flags & PROTO_CHILD)) {
1867    if (pfs->flags & PROTO_HAS_RETURN)
1868      pfs->flags |= PROTO_FIXUP_RETURN;
1869    pfs->flags |= PROTO_CHILD;
1870  }
1871  lj_lex_next(ls);
1872}
1873
1874/* Parse expression list. Last expression is left open. */
1875static BCReg expr_list(LexState *ls, ExpDesc *v)
1876{
1877  BCReg n = 1;
1878  expr(ls, v);
1879  while (lex_opt(ls, ',')) {
1880    expr_tonextreg(ls->fs, v);
1881    expr(ls, v);
1882    n++;
1883  }
1884  return n;
1885}
1886
1887/* Parse function argument list. */
1888static void parse_args(LexState *ls, ExpDesc *e)
1889{
1890  FuncState *fs = ls->fs;
1891  ExpDesc args;
1892  BCIns ins;
1893  BCReg base;
1894  BCLine line = ls->linenumber;
1895  if (ls->tok == '(') {
1896#if !LJ_52
1897    if (line != ls->lastline)
1898      err_syntax(ls, LJ_ERR_XAMBIG);
1899#endif
1900    lj_lex_next(ls);
1901    if (ls->tok == ')') {  /* f(). */
1902      args.k = VVOID;
1903    } else {
1904      expr_list(ls, &args);
1905      if (args.k == VCALL)  /* f(a, b, g()) or f(a, b, ...). */
1906	setbc_b(bcptr(fs, &args), 0);  /* Pass on multiple results. */
1907    }
1908    lex_match(ls, ')', '(', line);
1909  } else if (ls->tok == '{') {
1910    expr_table(ls, &args);
1911  } else if (ls->tok == TK_string) {
1912    expr_init(&args, VKSTR, 0);
1913    args.u.sval = strV(&ls->tokval);
1914    lj_lex_next(ls);
1915  } else {
1916    err_syntax(ls, LJ_ERR_XFUNARG);
1917    return;  /* Silence compiler. */
1918  }
1919  lj_assertFS(e->k == VNONRELOC, "bad expr type %d", e->k);
1920  base = e->u.s.info;  /* Base register for call. */
1921  if (args.k == VCALL) {
1922    ins = BCINS_ABC(BC_CALLM, base, 2, args.u.s.aux - base - 1 - ls->fr2);
1923  } else {
1924    if (args.k != VVOID)
1925      expr_tonextreg(fs, &args);
1926    ins = BCINS_ABC(BC_CALL, base, 2, fs->freereg - base - ls->fr2);
1927  }
1928  expr_init(e, VCALL, bcemit_INS(fs, ins));
1929  e->u.s.aux = base;
1930  fs->bcbase[fs->pc - 1].line = line;
1931  fs->freereg = base+1;  /* Leave one result by default. */
1932}
1933
1934/* Parse primary expression. */
1935static void expr_primary(LexState *ls, ExpDesc *v)
1936{
1937  FuncState *fs = ls->fs;
1938  /* Parse prefix expression. */
1939  if (ls->tok == '(') {
1940    BCLine line = ls->linenumber;
1941    lj_lex_next(ls);
1942    expr(ls, v);
1943    lex_match(ls, ')', '(', line);
1944    expr_discharge(ls->fs, v);
1945  } else if (ls->tok == TK_name || (!LJ_52 && ls->tok == TK_goto)) {
1946    var_lookup(ls, v);
1947  } else {
1948    err_syntax(ls, LJ_ERR_XSYMBOL);
1949  }
1950  for (;;) {  /* Parse multiple expression suffixes. */
1951    if (ls->tok == '.') {
1952      expr_field(ls, v);
1953    } else if (ls->tok == '[') {
1954      ExpDesc key;
1955      expr_toanyreg(fs, v);
1956      expr_bracket(ls, &key);
1957      expr_index(fs, v, &key);
1958    } else if (ls->tok == ':') {
1959      ExpDesc key;
1960      lj_lex_next(ls);
1961      expr_str(ls, &key);
1962      bcemit_method(fs, v, &key);
1963      parse_args(ls, v);
1964    } else if (ls->tok == '(' || ls->tok == TK_string || ls->tok == '{') {
1965      expr_tonextreg(fs, v);
1966      if (ls->fr2) bcreg_reserve(fs, 1);
1967      parse_args(ls, v);
1968    } else {
1969      break;
1970    }
1971  }
1972}
1973
1974/* Parse simple expression. */
1975static void expr_simple(LexState *ls, ExpDesc *v)
1976{
1977  switch (ls->tok) {
1978  case TK_number:
1979    expr_init(v, (LJ_HASFFI && tviscdata(&ls->tokval)) ? VKCDATA : VKNUM, 0);
1980    copyTV(ls->L, &v->u.nval, &ls->tokval);
1981    break;
1982  case TK_string:
1983    expr_init(v, VKSTR, 0);
1984    v->u.sval = strV(&ls->tokval);
1985    break;
1986  case TK_nil:
1987    expr_init(v, VKNIL, 0);
1988    break;
1989  case TK_true:
1990    expr_init(v, VKTRUE, 0);
1991    break;
1992  case TK_false:
1993    expr_init(v, VKFALSE, 0);
1994    break;
1995  case TK_dots: {  /* Vararg. */
1996    FuncState *fs = ls->fs;
1997    BCReg base;
1998    checkcond(ls, fs->flags & PROTO_VARARG, LJ_ERR_XDOTS);
1999    bcreg_reserve(fs, 1);
2000    base = fs->freereg-1;
2001    expr_init(v, VCALL, bcemit_ABC(fs, BC_VARG, base, 2, fs->numparams));
2002    v->u.s.aux = base;
2003    break;
2004  }
2005  case '{':  /* Table constructor. */
2006    expr_table(ls, v);
2007    return;
2008  case TK_function:
2009    lj_lex_next(ls);
2010    parse_body(ls, v, 0, ls->linenumber);
2011    return;
2012  default:
2013    expr_primary(ls, v);
2014    return;
2015  }
2016  lj_lex_next(ls);
2017}
2018
2019/* Manage syntactic levels to avoid blowing up the stack. */
2020static void synlevel_begin(LexState *ls)
2021{
2022  if (++ls->level >= LJ_MAX_XLEVEL)
2023    lj_lex_error(ls, 0, LJ_ERR_XLEVELS);
2024}
2025
2026#define synlevel_end(ls)	((ls)->level--)
2027
2028/* Convert token to binary operator. */
2029static BinOpr token2binop(LexToken tok)
2030{
2031  switch (tok) {
2032  case '+':	return OPR_ADD;
2033  case '-':	return OPR_SUB;
2034  case '*':	return OPR_MUL;
2035  case '/':	return OPR_DIV;
2036  case '%':	return OPR_MOD;
2037  case '^':	return OPR_POW;
2038  case TK_concat: return OPR_CONCAT;
2039  case TK_ne:	return OPR_NE;
2040  case TK_eq:	return OPR_EQ;
2041  case '<':	return OPR_LT;
2042  case TK_le:	return OPR_LE;
2043  case '>':	return OPR_GT;
2044  case TK_ge:	return OPR_GE;
2045  case TK_and:	return OPR_AND;
2046  case TK_or:	return OPR_OR;
2047  default:	return OPR_NOBINOPR;
2048  }
2049}
2050
2051/* Priorities for each binary operator. ORDER OPR. */
2052static const struct {
2053  uint8_t left;		/* Left priority. */
2054  uint8_t right;	/* Right priority. */
2055} priority[] = {
2056  {6,6}, {6,6}, {7,7}, {7,7}, {7,7},	/* ADD SUB MUL DIV MOD */
2057  {10,9}, {5,4},			/* POW CONCAT (right associative) */
2058  {3,3}, {3,3},				/* EQ NE */
2059  {3,3}, {3,3}, {3,3}, {3,3},		/* LT GE GT LE */
2060  {2,2}, {1,1}				/* AND OR */
2061};
2062
2063#define UNARY_PRIORITY		8  /* Priority for unary operators. */
2064
2065/* Forward declaration. */
2066static BinOpr expr_binop(LexState *ls, ExpDesc *v, uint32_t limit);
2067
2068/* Parse unary expression. */
2069static void expr_unop(LexState *ls, ExpDesc *v)
2070{
2071  BCOp op;
2072  if (ls->tok == TK_not) {
2073    op = BC_NOT;
2074  } else if (ls->tok == '-') {
2075    op = BC_UNM;
2076  } else if (ls->tok == '#') {
2077    op = BC_LEN;
2078  } else {
2079    expr_simple(ls, v);
2080    return;
2081  }
2082  lj_lex_next(ls);
2083  expr_binop(ls, v, UNARY_PRIORITY);
2084  bcemit_unop(ls->fs, op, v);
2085}
2086
2087/* Parse binary expressions with priority higher than the limit. */
2088static BinOpr expr_binop(LexState *ls, ExpDesc *v, uint32_t limit)
2089{
2090  BinOpr op;
2091  synlevel_begin(ls);
2092  expr_unop(ls, v);
2093  op = token2binop(ls->tok);
2094  while (op != OPR_NOBINOPR && priority[op].left > limit) {
2095    ExpDesc v2;
2096    BinOpr nextop;
2097    lj_lex_next(ls);
2098    bcemit_binop_left(ls->fs, op, v);
2099    /* Parse binary expression with higher priority. */
2100    nextop = expr_binop(ls, &v2, priority[op].right);
2101    bcemit_binop(ls->fs, op, v, &v2);
2102    op = nextop;
2103  }
2104  synlevel_end(ls);
2105  return op;  /* Return unconsumed binary operator (if any). */
2106}
2107
2108/* Parse expression. */
2109static void expr(LexState *ls, ExpDesc *v)
2110{
2111  expr_binop(ls, v, 0);  /* Priority 0: parse whole expression. */
2112}
2113
2114/* Assign expression to the next register. */
2115static void expr_next(LexState *ls)
2116{
2117  ExpDesc e;
2118  expr(ls, &e);
2119  expr_tonextreg(ls->fs, &e);
2120}
2121
2122/* Parse conditional expression. */
2123static BCPos expr_cond(LexState *ls)
2124{
2125  ExpDesc v;
2126  expr(ls, &v);
2127  if (v.k == VKNIL) v.k = VKFALSE;
2128  bcemit_branch_t(ls->fs, &v);
2129  return v.f;
2130}
2131
2132/* -- Assignments --------------------------------------------------------- */
2133
2134/* List of LHS variables. */
2135typedef struct LHSVarList {
2136  ExpDesc v;			/* LHS variable. */
2137  struct LHSVarList *prev;	/* Link to previous LHS variable. */
2138} LHSVarList;
2139
2140/* Eliminate write-after-read hazards for local variable assignment. */
2141static void assign_hazard(LexState *ls, LHSVarList *lh, const ExpDesc *v)
2142{
2143  FuncState *fs = ls->fs;
2144  BCReg reg = v->u.s.info;  /* Check against this variable. */
2145  BCReg tmp = fs->freereg;  /* Rename to this temp. register (if needed). */
2146  int hazard = 0;
2147  for (; lh; lh = lh->prev) {
2148    if (lh->v.k == VINDEXED) {
2149      if (lh->v.u.s.info == reg) {  /* t[i], t = 1, 2 */
2150	hazard = 1;
2151	lh->v.u.s.info = tmp;
2152      }
2153      if (lh->v.u.s.aux == reg) {  /* t[i], i = 1, 2 */
2154	hazard = 1;
2155	lh->v.u.s.aux = tmp;
2156      }
2157    }
2158  }
2159  if (hazard) {
2160    bcemit_AD(fs, BC_MOV, tmp, reg);  /* Rename conflicting variable. */
2161    bcreg_reserve(fs, 1);
2162  }
2163}
2164
2165/* Adjust LHS/RHS of an assignment. */
2166static void assign_adjust(LexState *ls, BCReg nvars, BCReg nexps, ExpDesc *e)
2167{
2168  FuncState *fs = ls->fs;
2169  int32_t extra = (int32_t)nvars - (int32_t)nexps;
2170  if (e->k == VCALL) {
2171    extra++;  /* Compensate for the VCALL itself. */
2172    if (extra < 0) extra = 0;
2173    setbc_b(bcptr(fs, e), extra+1);  /* Fixup call results. */
2174    if (extra > 1) bcreg_reserve(fs, (BCReg)extra-1);
2175  } else {
2176    if (e->k != VVOID)
2177      expr_tonextreg(fs, e);  /* Close last expression. */
2178    if (extra > 0) {  /* Leftover LHS are set to nil. */
2179      BCReg reg = fs->freereg;
2180      bcreg_reserve(fs, (BCReg)extra);
2181      bcemit_nil(fs, reg, (BCReg)extra);
2182    }
2183  }
2184  if (nexps > nvars)
2185    ls->fs->freereg -= nexps - nvars;  /* Drop leftover regs. */
2186}
2187
2188/* Recursively parse assignment statement. */
2189static void parse_assignment(LexState *ls, LHSVarList *lh, BCReg nvars)
2190{
2191  ExpDesc e;
2192  checkcond(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED, LJ_ERR_XSYNTAX);
2193  if (lex_opt(ls, ',')) {  /* Collect LHS list and recurse upwards. */
2194    LHSVarList vl;
2195    vl.prev = lh;
2196    expr_primary(ls, &vl.v);
2197    if (vl.v.k == VLOCAL)
2198      assign_hazard(ls, lh, &vl.v);
2199    checklimit(ls->fs, ls->level + nvars, LJ_MAX_XLEVEL, "variable names");
2200    parse_assignment(ls, &vl, nvars+1);
2201  } else {  /* Parse RHS. */
2202    BCReg nexps;
2203    lex_check(ls, '=');
2204    nexps = expr_list(ls, &e);
2205    if (nexps == nvars) {
2206      if (e.k == VCALL) {
2207	if (bc_op(*bcptr(ls->fs, &e)) == BC_VARG) {  /* Vararg assignment. */
2208	  ls->fs->freereg--;
2209	  e.k = VRELOCABLE;
2210	} else {  /* Multiple call results. */
2211	  e.u.s.info = e.u.s.aux;  /* Base of call is not relocatable. */
2212	  e.k = VNONRELOC;
2213	}
2214      }
2215      bcemit_store(ls->fs, &lh->v, &e);
2216      return;
2217    }
2218    assign_adjust(ls, nvars, nexps, &e);
2219  }
2220  /* Assign RHS to LHS and recurse downwards. */
2221  expr_init(&e, VNONRELOC, ls->fs->freereg-1);
2222  bcemit_store(ls->fs, &lh->v, &e);
2223}
2224
2225/* Parse call statement or assignment. */
2226static void parse_call_assign(LexState *ls)
2227{
2228  FuncState *fs = ls->fs;
2229  LHSVarList vl;
2230  expr_primary(ls, &vl.v);
2231  if (vl.v.k == VCALL) {  /* Function call statement. */
2232    setbc_b(bcptr(fs, &vl.v), 1);  /* No results. */
2233  } else {  /* Start of an assignment. */
2234    vl.prev = NULL;
2235    parse_assignment(ls, &vl, 1);
2236  }
2237}
2238
2239/* Parse 'local' statement. */
2240static void parse_local(LexState *ls)
2241{
2242  if (lex_opt(ls, TK_function)) {  /* Local function declaration. */
2243    ExpDesc v, b;
2244    FuncState *fs = ls->fs;
2245    var_new(ls, 0, lex_str(ls));
2246    expr_init(&v, VLOCAL, fs->freereg);
2247    v.u.s.aux = fs->varmap[fs->freereg];
2248    bcreg_reserve(fs, 1);
2249    var_add(ls, 1);
2250    parse_body(ls, &b, 0, ls->linenumber);
2251    /* bcemit_store(fs, &v, &b) without setting VSTACK_VAR_RW. */
2252    expr_free(fs, &b);
2253    expr_toreg(fs, &b, v.u.s.info);
2254    /* The upvalue is in scope, but the local is only valid after the store. */
2255    var_get(ls, fs, fs->nactvar - 1).startpc = fs->pc;
2256  } else {  /* Local variable declaration. */
2257    ExpDesc e;
2258    BCReg nexps, nvars = 0;
2259    do {  /* Collect LHS. */
2260      var_new(ls, nvars++, lex_str(ls));
2261    } while (lex_opt(ls, ','));
2262    if (lex_opt(ls, '=')) {  /* Optional RHS. */
2263      nexps = expr_list(ls, &e);
2264    } else {  /* Or implicitly set to nil. */
2265      e.k = VVOID;
2266      nexps = 0;
2267    }
2268    assign_adjust(ls, nvars, nexps, &e);
2269    var_add(ls, nvars);
2270  }
2271}
2272
2273/* Parse 'function' statement. */
2274static void parse_func(LexState *ls, BCLine line)
2275{
2276  FuncState *fs;
2277  ExpDesc v, b;
2278  int needself = 0;
2279  lj_lex_next(ls);  /* Skip 'function'. */
2280  /* Parse function name. */
2281  var_lookup(ls, &v);
2282  while (ls->tok == '.')  /* Multiple dot-separated fields. */
2283    expr_field(ls, &v);
2284  if (ls->tok == ':') {  /* Optional colon to signify method call. */
2285    needself = 1;
2286    expr_field(ls, &v);
2287  }
2288  parse_body(ls, &b, needself, line);
2289  fs = ls->fs;
2290  bcemit_store(fs, &v, &b);
2291  fs->bcbase[fs->pc - 1].line = line;  /* Set line for the store. */
2292}
2293
2294/* -- Control transfer statements ----------------------------------------- */
2295
2296/* Check for end of block. */
2297static int parse_isend(LexToken tok)
2298{
2299  switch (tok) {
2300  case TK_else: case TK_elseif: case TK_end: case TK_until: case TK_eof:
2301    return 1;
2302  default:
2303    return 0;
2304  }
2305}
2306
2307/* Parse 'return' statement. */
2308static void parse_return(LexState *ls)
2309{
2310  BCIns ins;
2311  FuncState *fs = ls->fs;
2312  lj_lex_next(ls);  /* Skip 'return'. */
2313  fs->flags |= PROTO_HAS_RETURN;
2314  if (parse_isend(ls->tok) || ls->tok == ';') {  /* Bare return. */
2315    ins = BCINS_AD(BC_RET0, 0, 1);
2316  } else {  /* Return with one or more values. */
2317    ExpDesc e;  /* Receives the _last_ expression in the list. */
2318    BCReg nret = expr_list(ls, &e);
2319    if (nret == 1) {  /* Return one result. */
2320      if (e.k == VCALL) {  /* Check for tail call. */
2321#ifdef LUAJIT_DISABLE_TAILCALL
2322	goto notailcall;
2323#else
2324	BCIns *ip = bcptr(fs, &e);
2325	/* It doesn't pay off to add BC_VARGT just for 'return ...'. */
2326	if (bc_op(*ip) == BC_VARG) goto notailcall;
2327	fs->pc--;
2328	ins = BCINS_AD(bc_op(*ip)-BC_CALL+BC_CALLT, bc_a(*ip), bc_c(*ip));
2329#endif
2330      } else {  /* Can return the result from any register. */
2331	ins = BCINS_AD(BC_RET1, expr_toanyreg(fs, &e), 2);
2332      }
2333    } else {
2334      if (e.k == VCALL) {  /* Append all results from a call. */
2335      notailcall:
2336	setbc_b(bcptr(fs, &e), 0);
2337	ins = BCINS_AD(BC_RETM, fs->nactvar, e.u.s.aux - fs->nactvar);
2338      } else {
2339	expr_tonextreg(fs, &e);  /* Force contiguous registers. */
2340	ins = BCINS_AD(BC_RET, fs->nactvar, nret+1);
2341      }
2342    }
2343  }
2344  if (fs->flags & PROTO_CHILD)
2345    bcemit_AJ(fs, BC_UCLO, 0, 0);  /* May need to close upvalues first. */
2346  bcemit_INS(fs, ins);
2347}
2348
2349/* Parse 'break' statement. */
2350static void parse_break(LexState *ls)
2351{
2352  ls->fs->bl->flags |= FSCOPE_BREAK;
2353  gola_new(ls, NAME_BREAK, VSTACK_GOTO, bcemit_jmp(ls->fs));
2354}
2355
2356/* Parse 'goto' statement. */
2357static void parse_goto(LexState *ls)
2358{
2359  FuncState *fs = ls->fs;
2360  GCstr *name = lex_str(ls);
2361  VarInfo *vl = gola_findlabel(ls, name);
2362  if (vl)  /* Treat backwards goto within same scope like a loop. */
2363    bcemit_AJ(fs, BC_LOOP, vl->slot, -1);  /* No BC range check. */
2364  fs->bl->flags |= FSCOPE_GOLA;
2365  gola_new(ls, name, VSTACK_GOTO, bcemit_jmp(fs));
2366}
2367
2368/* Parse label. */
2369static void parse_label(LexState *ls)
2370{
2371  FuncState *fs = ls->fs;
2372  GCstr *name;
2373  MSize idx;
2374  fs->lasttarget = fs->pc;
2375  fs->bl->flags |= FSCOPE_GOLA;
2376  lj_lex_next(ls);  /* Skip '::'. */
2377  name = lex_str(ls);
2378  if (gola_findlabel(ls, name))
2379    lj_lex_error(ls, 0, LJ_ERR_XLDUP, strdata(name));
2380  idx = gola_new(ls, name, VSTACK_LABEL, fs->pc);
2381  lex_check(ls, TK_label);
2382  /* Recursively parse trailing statements: labels and ';' (Lua 5.2 only). */
2383  for (;;) {
2384    if (ls->tok == TK_label) {
2385      synlevel_begin(ls);
2386      parse_label(ls);
2387      synlevel_end(ls);
2388    } else if (LJ_52 && ls->tok == ';') {
2389      lj_lex_next(ls);
2390    } else {
2391      break;
2392    }
2393  }
2394  /* Trailing label is considered to be outside of scope. */
2395  if (parse_isend(ls->tok) && ls->tok != TK_until)
2396    ls->vstack[idx].slot = fs->bl->nactvar;
2397  gola_resolve(ls, fs->bl, idx);
2398}
2399
2400/* -- Blocks, loops and conditional statements ---------------------------- */
2401
2402/* Parse a block. */
2403static void parse_block(LexState *ls)
2404{
2405  FuncState *fs = ls->fs;
2406  FuncScope bl;
2407  fscope_begin(fs, &bl, 0);
2408  parse_chunk(ls);
2409  fscope_end(fs);
2410}
2411
2412/* Parse 'while' statement. */
2413static void parse_while(LexState *ls, BCLine line)
2414{
2415  FuncState *fs = ls->fs;
2416  BCPos start, loop, condexit;
2417  FuncScope bl;
2418  lj_lex_next(ls);  /* Skip 'while'. */
2419  start = fs->lasttarget = fs->pc;
2420  condexit = expr_cond(ls);
2421  fscope_begin(fs, &bl, FSCOPE_LOOP);
2422  lex_check(ls, TK_do);
2423  loop = bcemit_AD(fs, BC_LOOP, fs->nactvar, 0);
2424  parse_block(ls);
2425  jmp_patch(fs, bcemit_jmp(fs), start);
2426  lex_match(ls, TK_end, TK_while, line);
2427  fscope_end(fs);
2428  jmp_tohere(fs, condexit);
2429  jmp_patchins(fs, loop, fs->pc);
2430}
2431
2432/* Parse 'repeat' statement. */
2433static void parse_repeat(LexState *ls, BCLine line)
2434{
2435  FuncState *fs = ls->fs;
2436  BCPos loop = fs->lasttarget = fs->pc;
2437  BCPos condexit;
2438  FuncScope bl1, bl2;
2439  fscope_begin(fs, &bl1, FSCOPE_LOOP);  /* Breakable loop scope. */
2440  fscope_begin(fs, &bl2, 0);  /* Inner scope. */
2441  lj_lex_next(ls);  /* Skip 'repeat'. */
2442  bcemit_AD(fs, BC_LOOP, fs->nactvar, 0);
2443  parse_chunk(ls);
2444  lex_match(ls, TK_until, TK_repeat, line);
2445  condexit = expr_cond(ls);  /* Parse condition (still inside inner scope). */
2446  if (!(bl2.flags & FSCOPE_UPVAL)) {  /* No upvalues? Just end inner scope. */
2447    fscope_end(fs);
2448  } else {  /* Otherwise generate: cond: UCLO+JMP out, !cond: UCLO+JMP loop. */
2449    parse_break(ls);  /* Break from loop and close upvalues. */
2450    jmp_tohere(fs, condexit);
2451    fscope_end(fs);  /* End inner scope and close upvalues. */
2452    condexit = bcemit_jmp(fs);
2453  }
2454  jmp_patch(fs, condexit, loop);  /* Jump backwards if !cond. */
2455  jmp_patchins(fs, loop, fs->pc);
2456  fscope_end(fs);  /* End loop scope. */
2457}
2458
2459/* Parse numeric 'for'. */
2460static void parse_for_num(LexState *ls, GCstr *varname, BCLine line)
2461{
2462  FuncState *fs = ls->fs;
2463  BCReg base = fs->freereg;
2464  FuncScope bl;
2465  BCPos loop, loopend;
2466  /* Hidden control variables. */
2467  var_new_fixed(ls, FORL_IDX, VARNAME_FOR_IDX);
2468  var_new_fixed(ls, FORL_STOP, VARNAME_FOR_STOP);
2469  var_new_fixed(ls, FORL_STEP, VARNAME_FOR_STEP);
2470  /* Visible copy of index variable. */
2471  var_new(ls, FORL_EXT, varname);
2472  lex_check(ls, '=');
2473  expr_next(ls);
2474  lex_check(ls, ',');
2475  expr_next(ls);
2476  if (lex_opt(ls, ',')) {
2477    expr_next(ls);
2478  } else {
2479    bcemit_AD(fs, BC_KSHORT, fs->freereg, 1);  /* Default step is 1. */
2480    bcreg_reserve(fs, 1);
2481  }
2482  var_add(ls, 3);  /* Hidden control variables. */
2483  lex_check(ls, TK_do);
2484  loop = bcemit_AJ(fs, BC_FORI, base, NO_JMP);
2485  fscope_begin(fs, &bl, 0);  /* Scope for visible variables. */
2486  var_add(ls, 1);
2487  bcreg_reserve(fs, 1);
2488  parse_block(ls);
2489  fscope_end(fs);
2490  /* Perform loop inversion. Loop control instructions are at the end. */
2491  loopend = bcemit_AJ(fs, BC_FORL, base, NO_JMP);
2492  fs->bcbase[loopend].line = line;  /* Fix line for control ins. */
2493  jmp_patchins(fs, loopend, loop+1);
2494  jmp_patchins(fs, loop, fs->pc);
2495}
2496
2497/* Try to predict whether the iterator is next() and specialize the bytecode.
2498** Detecting next() and pairs() by name is simplistic, but quite effective.
2499** The interpreter backs off if the check for the closure fails at runtime.
2500*/
2501static int predict_next(LexState *ls, FuncState *fs, BCPos pc)
2502{
2503  BCIns ins = fs->bcbase[pc].ins;
2504  GCstr *name;
2505  cTValue *o;
2506  switch (bc_op(ins)) {
2507  case BC_MOV:
2508    if (bc_d(ins) >= fs->nactvar) return 0;
2509    name = gco2str(gcref(var_get(ls, fs, bc_d(ins)).name));
2510    break;
2511  case BC_UGET:
2512    name = gco2str(gcref(ls->vstack[fs->uvmap[bc_d(ins)]].name));
2513    break;
2514  case BC_GGET:
2515    /* There's no inverse index (yet), so lookup the strings. */
2516    o = lj_tab_getstr(fs->kt, lj_str_newlit(ls->L, "pairs"));
2517    if (o && tvhaskslot(o) && tvkslot(o) == bc_d(ins))
2518      return 1;
2519    o = lj_tab_getstr(fs->kt, lj_str_newlit(ls->L, "next"));
2520    if (o && tvhaskslot(o) && tvkslot(o) == bc_d(ins))
2521      return 1;
2522    return 0;
2523  default:
2524    return 0;
2525  }
2526  return (name->len == 5 && !strcmp(strdata(name), "pairs")) ||
2527	 (name->len == 4 && !strcmp(strdata(name), "next"));
2528}
2529
2530/* Parse 'for' iterator. */
2531static void parse_for_iter(LexState *ls, GCstr *indexname)
2532{
2533  FuncState *fs = ls->fs;
2534  ExpDesc e;
2535  BCReg nvars = 0;
2536  BCLine line;
2537  BCReg base = fs->freereg + 3;
2538  BCPos loop, loopend, exprpc = fs->pc;
2539  FuncScope bl;
2540  int isnext;
2541  /* Hidden control variables. */
2542  var_new_fixed(ls, nvars++, VARNAME_FOR_GEN);
2543  var_new_fixed(ls, nvars++, VARNAME_FOR_STATE);
2544  var_new_fixed(ls, nvars++, VARNAME_FOR_CTL);
2545  /* Visible variables returned from iterator. */
2546  var_new(ls, nvars++, indexname);
2547  while (lex_opt(ls, ','))
2548    var_new(ls, nvars++, lex_str(ls));
2549  lex_check(ls, TK_in);
2550  line = ls->linenumber;
2551  assign_adjust(ls, 3, expr_list(ls, &e), &e);
2552  /* The iterator needs another 3 [4] slots (func [pc] | state ctl). */
2553  bcreg_bump(fs, 3+ls->fr2);
2554  isnext = (nvars <= 5 && fs->pc > exprpc && predict_next(ls, fs, exprpc));
2555  var_add(ls, 3);  /* Hidden control variables. */
2556  lex_check(ls, TK_do);
2557  loop = bcemit_AJ(fs, isnext ? BC_ISNEXT : BC_JMP, base, NO_JMP);
2558  fscope_begin(fs, &bl, 0);  /* Scope for visible variables. */
2559  var_add(ls, nvars-3);
2560  bcreg_reserve(fs, nvars-3);
2561  parse_block(ls);
2562  fscope_end(fs);
2563  /* Perform loop inversion. Loop control instructions are at the end. */
2564  jmp_patchins(fs, loop, fs->pc);
2565  bcemit_ABC(fs, isnext ? BC_ITERN : BC_ITERC, base, nvars-3+1, 2+1);
2566  loopend = bcemit_AJ(fs, BC_ITERL, base, NO_JMP);
2567  fs->bcbase[loopend-1].line = line;  /* Fix line for control ins. */
2568  fs->bcbase[loopend].line = line;
2569  jmp_patchins(fs, loopend, loop+1);
2570}
2571
2572/* Parse 'for' statement. */
2573static void parse_for(LexState *ls, BCLine line)
2574{
2575  FuncState *fs = ls->fs;
2576  GCstr *varname;
2577  FuncScope bl;
2578  fscope_begin(fs, &bl, FSCOPE_LOOP);
2579  lj_lex_next(ls);  /* Skip 'for'. */
2580  varname = lex_str(ls);  /* Get first variable name. */
2581  if (ls->tok == '=')
2582    parse_for_num(ls, varname, line);
2583  else if (ls->tok == ',' || ls->tok == TK_in)
2584    parse_for_iter(ls, varname);
2585  else
2586    err_syntax(ls, LJ_ERR_XFOR);
2587  lex_match(ls, TK_end, TK_for, line);
2588  fscope_end(fs);  /* Resolve break list. */
2589}
2590
2591/* Parse condition and 'then' block. */
2592static BCPos parse_then(LexState *ls)
2593{
2594  BCPos condexit;
2595  lj_lex_next(ls);  /* Skip 'if' or 'elseif'. */
2596  condexit = expr_cond(ls);
2597  lex_check(ls, TK_then);
2598  parse_block(ls);
2599  return condexit;
2600}
2601
2602/* Parse 'if' statement. */
2603static void parse_if(LexState *ls, BCLine line)
2604{
2605  FuncState *fs = ls->fs;
2606  BCPos flist;
2607  BCPos escapelist = NO_JMP;
2608  flist = parse_then(ls);
2609  while (ls->tok == TK_elseif) {  /* Parse multiple 'elseif' blocks. */
2610    jmp_append(fs, &escapelist, bcemit_jmp(fs));
2611    jmp_tohere(fs, flist);
2612    flist = parse_then(ls);
2613  }
2614  if (ls->tok == TK_else) {  /* Parse optional 'else' block. */
2615    jmp_append(fs, &escapelist, bcemit_jmp(fs));
2616    jmp_tohere(fs, flist);
2617    lj_lex_next(ls);  /* Skip 'else'. */
2618    parse_block(ls);
2619  } else {
2620    jmp_append(fs, &escapelist, flist);
2621  }
2622  jmp_tohere(fs, escapelist);
2623  lex_match(ls, TK_end, TK_if, line);
2624}
2625
2626/* -- Parse statements ---------------------------------------------------- */
2627
2628/* Parse a statement. Returns 1 if it must be the last one in a chunk. */
2629static int parse_stmt(LexState *ls)
2630{
2631  BCLine line = ls->linenumber;
2632  switch (ls->tok) {
2633  case TK_if:
2634    parse_if(ls, line);
2635    break;
2636  case TK_while:
2637    parse_while(ls, line);
2638    break;
2639  case TK_do:
2640    lj_lex_next(ls);
2641    parse_block(ls);
2642    lex_match(ls, TK_end, TK_do, line);
2643    break;
2644  case TK_for:
2645    parse_for(ls, line);
2646    break;
2647  case TK_repeat:
2648    parse_repeat(ls, line);
2649    break;
2650  case TK_function:
2651    parse_func(ls, line);
2652    break;
2653  case TK_local:
2654    lj_lex_next(ls);
2655    parse_local(ls);
2656    break;
2657  case TK_return:
2658    parse_return(ls);
2659    return 1;  /* Must be last. */
2660  case TK_break:
2661    lj_lex_next(ls);
2662    parse_break(ls);
2663    return !LJ_52;  /* Must be last in Lua 5.1. */
2664#if LJ_52
2665  case ';':
2666    lj_lex_next(ls);
2667    break;
2668#endif
2669  case TK_label:
2670    parse_label(ls);
2671    break;
2672  case TK_goto:
2673    if (LJ_52 || lj_lex_lookahead(ls) == TK_name) {
2674      lj_lex_next(ls);
2675      parse_goto(ls);
2676      break;
2677    }
2678    /* fallthrough */
2679  default:
2680    parse_call_assign(ls);
2681    break;
2682  }
2683  return 0;
2684}
2685
2686/* A chunk is a list of statements optionally separated by semicolons. */
2687static void parse_chunk(LexState *ls)
2688{
2689  int islast = 0;
2690  synlevel_begin(ls);
2691  while (!islast && !parse_isend(ls->tok)) {
2692    islast = parse_stmt(ls);
2693    lex_opt(ls, ';');
2694    lj_assertLS(ls->fs->framesize >= ls->fs->freereg &&
2695		ls->fs->freereg >= ls->fs->nactvar,
2696		"bad regalloc");
2697    ls->fs->freereg = ls->fs->nactvar;  /* Free registers after each stmt. */
2698  }
2699  synlevel_end(ls);
2700}
2701
2702/* Entry point of bytecode parser. */
2703GCproto *lj_parse(LexState *ls)
2704{
2705  FuncState fs;
2706  FuncScope bl;
2707  GCproto *pt;
2708  lua_State *L = ls->L;
2709#ifdef LUAJIT_DISABLE_DEBUGINFO
2710  ls->chunkname = lj_str_newlit(L, "=");
2711#else
2712  ls->chunkname = lj_str_newz(L, ls->chunkarg);
2713#endif
2714  setstrV(L, L->top, ls->chunkname);  /* Anchor chunkname string. */
2715  incr_top(L);
2716  ls->level = 0;
2717  fs_init(ls, &fs);
2718  fs.linedefined = 0;
2719  fs.numparams = 0;
2720  fs.bcbase = NULL;
2721  fs.bclim = 0;
2722  fs.flags |= PROTO_VARARG;  /* Main chunk is always a vararg func. */
2723  fscope_begin(&fs, &bl, 0);
2724  bcemit_AD(&fs, BC_FUNCV, 0, 0);  /* Placeholder. */
2725  lj_lex_next(ls);  /* Read-ahead first token. */
2726  parse_chunk(ls);
2727  if (ls->tok != TK_eof)
2728    err_token(ls, TK_eof);
2729  pt = fs_finish(ls, ls->linenumber);
2730  L->top--;  /* Drop chunkname. */
2731  lj_assertL(fs.prev == NULL && ls->fs == NULL, "mismatched frame nesting");
2732  lj_assertL(pt->sizeuv == 0, "toplevel proto has upvalues");
2733  return pt;
2734}
2735