PageRenderTime 1421ms CodeModel.GetById 266ms app.highlight 580ms RepoModel.GetById 280ms app.codeStats 0ms

/script_binding/lua/lua/lparser.c

http://ftk.googlecode.com/
C | 1339 lines | 1072 code | 182 blank | 85 comment | 183 complexity | ee183362e7aa77276b08be18083d77dc MD5 | raw file
   1/*
   2** $Id: lparser.c,v 2.42.1.3 2007/12/28 15:32:23 roberto Exp $
   3** Lua Parser
   4** See Copyright Notice in lua.h
   5*/
   6
   7
   8#include <string.h>
   9
  10#define lparser_c
  11#define LUA_CORE
  12
  13#include "lua.h"
  14
  15#include "lcode.h"
  16#include "ldebug.h"
  17#include "ldo.h"
  18#include "lfunc.h"
  19#include "llex.h"
  20#include "lmem.h"
  21#include "lobject.h"
  22#include "lopcodes.h"
  23#include "lparser.h"
  24#include "lstate.h"
  25#include "lstring.h"
  26#include "ltable.h"
  27
  28
  29
  30#define hasmultret(k)		((k) == VCALL || (k) == VVARARG)
  31
  32#define getlocvar(fs, i)	((fs)->f->locvars[(fs)->actvar[i]])
  33
  34#define luaY_checklimit(fs,v,l,m)	if ((v)>(l)) errorlimit(fs,l,m)
  35
  36
  37/*
  38** nodes for block list (list of active blocks)
  39*/
  40typedef struct BlockCnt {
  41  struct BlockCnt *previous;  /* chain */
  42  int breaklist;  /* list of jumps out of this loop */
  43  lu_byte nactvar;  /* # active locals outside the breakable structure */
  44  lu_byte upval;  /* true if some variable in the block is an upvalue */
  45  lu_byte isbreakable;  /* true if `block' is a loop */
  46} BlockCnt;
  47
  48
  49
  50/*
  51** prototypes for recursive non-terminal functions
  52*/
  53static void chunk (LexState *ls);
  54static void expr (LexState *ls, expdesc *v);
  55
  56
  57static void anchor_token (LexState *ls) {
  58  if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {
  59    TString *ts = ls->t.seminfo.ts;
  60    luaX_newstring(ls, getstr(ts), ts->tsv.len);
  61  }
  62}
  63
  64
  65static void error_expected (LexState *ls, int token) {
  66  luaX_syntaxerror(ls,
  67      luaO_pushfstring(ls->L, LUA_QS " expected", luaX_token2str(ls, token)));
  68}
  69
  70
  71static void errorlimit (FuncState *fs, int limit, const char *what) {
  72  const char *msg = (fs->f->linedefined == 0) ?
  73    luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) :
  74    luaO_pushfstring(fs->L, "function at line %d has more than %d %s",
  75                            fs->f->linedefined, limit, what);
  76  luaX_lexerror(fs->ls, msg, 0);
  77}
  78
  79
  80static int testnext (LexState *ls, int c) {
  81  if (ls->t.token == c) {
  82    luaX_next(ls);
  83    return 1;
  84  }
  85  else return 0;
  86}
  87
  88
  89static void check (LexState *ls, int c) {
  90  if (ls->t.token != c)
  91    error_expected(ls, c);
  92}
  93
  94static void checknext (LexState *ls, int c) {
  95  check(ls, c);
  96  luaX_next(ls);
  97}
  98
  99
 100#define check_condition(ls,c,msg)	{ if (!(c)) luaX_syntaxerror(ls, msg); }
 101
 102
 103
 104static void check_match (LexState *ls, int what, int who, int where) {
 105  if (!testnext(ls, what)) {
 106    if (where == ls->linenumber)
 107      error_expected(ls, what);
 108    else {
 109      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
 110             LUA_QS " expected (to close " LUA_QS " at line %d)",
 111              luaX_token2str(ls, what), luaX_token2str(ls, who), where));
 112    }
 113  }
 114}
 115
 116
 117static TString *str_checkname (LexState *ls) {
 118  TString *ts;
 119  check(ls, TK_NAME);
 120  ts = ls->t.seminfo.ts;
 121  luaX_next(ls);
 122  return ts;
 123}
 124
 125
 126static void init_exp (expdesc *e, expkind k, int i) {
 127  e->f = e->t = NO_JUMP;
 128  e->k = k;
 129  e->u.s.info = i;
 130}
 131
 132
 133static void codestring (LexState *ls, expdesc *e, TString *s) {
 134  init_exp(e, VK, luaK_stringK(ls->fs, s));
 135}
 136
 137
 138static void checkname(LexState *ls, expdesc *e) {
 139  codestring(ls, e, str_checkname(ls));
 140}
 141
 142
 143static int registerlocalvar (LexState *ls, TString *varname) {
 144  FuncState *fs = ls->fs;
 145  Proto *f = fs->f;
 146  int oldsize = f->sizelocvars;
 147  luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
 148                  LocVar, SHRT_MAX, "too many local variables");
 149  while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL;
 150  f->locvars[fs->nlocvars].varname = varname;
 151  luaC_objbarrier(ls->L, f, varname);
 152  return fs->nlocvars++;
 153}
 154
 155
 156#define new_localvarliteral(ls,v,n) \
 157  new_localvar(ls, luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char))-1), n)
 158
 159
 160static void new_localvar (LexState *ls, TString *name, int n) {
 161  FuncState *fs = ls->fs;
 162  luaY_checklimit(fs, fs->nactvar+n+1, LUAI_MAXVARS, "local variables");
 163  fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name));
 164}
 165
 166
 167static void adjustlocalvars (LexState *ls, int nvars) {
 168  FuncState *fs = ls->fs;
 169  fs->nactvar = cast_byte(fs->nactvar + nvars);
 170  for (; nvars; nvars--) {
 171    getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
 172  }
 173}
 174
 175
 176static void removevars (LexState *ls, int tolevel) {
 177  FuncState *fs = ls->fs;
 178  while (fs->nactvar > tolevel)
 179    getlocvar(fs, --fs->nactvar).endpc = fs->pc;
 180}
 181
 182
 183static int indexupvalue (FuncState *fs, TString *name, expdesc *v) {
 184  int i;
 185  Proto *f = fs->f;
 186  int oldsize = f->sizeupvalues;
 187  for (i=0; i<f->nups; i++) {
 188    if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->u.s.info) {
 189      lua_assert(f->upvalues[i] == name);
 190      return i;
 191    }
 192  }
 193  /* new one */
 194  luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, "upvalues");
 195  luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,
 196                  TString *, MAX_INT, "");
 197  while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL;
 198  f->upvalues[f->nups] = name;
 199  luaC_objbarrier(fs->L, f, name);
 200  lua_assert(v->k == VLOCAL || v->k == VUPVAL);
 201  fs->upvalues[f->nups].k = cast_byte(v->k);
 202  fs->upvalues[f->nups].info = cast_byte(v->u.s.info);
 203  return f->nups++;
 204}
 205
 206
 207static int searchvar (FuncState *fs, TString *n) {
 208  int i;
 209  for (i=fs->nactvar-1; i >= 0; i--) {
 210    if (n == getlocvar(fs, i).varname)
 211      return i;
 212  }
 213  return -1;  /* not found */
 214}
 215
 216
 217static void markupval (FuncState *fs, int level) {
 218  BlockCnt *bl = fs->bl;
 219  while (bl && bl->nactvar > level) bl = bl->previous;
 220  if (bl) bl->upval = 1;
 221}
 222
 223
 224static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
 225  if (fs == NULL) {  /* no more levels? */
 226    init_exp(var, VGLOBAL, NO_REG);  /* default is global variable */
 227    return VGLOBAL;
 228  }
 229  else {
 230    int v = searchvar(fs, n);  /* look up at current level */
 231    if (v >= 0) {
 232      init_exp(var, VLOCAL, v);
 233      if (!base)
 234        markupval(fs, v);  /* local will be used as an upval */
 235      return VLOCAL;
 236    }
 237    else {  /* not found at current level; try upper one */
 238      if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL)
 239        return VGLOBAL;
 240      var->u.s.info = indexupvalue(fs, n, var);  /* else was LOCAL or UPVAL */
 241      var->k = VUPVAL;  /* upvalue in this level */
 242      return VUPVAL;
 243    }
 244  }
 245}
 246
 247
 248static void singlevar (LexState *ls, expdesc *var) {
 249  TString *varname = str_checkname(ls);
 250  FuncState *fs = ls->fs;
 251  if (singlevaraux(fs, varname, var, 1) == VGLOBAL)
 252    var->u.s.info = luaK_stringK(fs, varname);  /* info points to global name */
 253}
 254
 255
 256static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
 257  FuncState *fs = ls->fs;
 258  int extra = nvars - nexps;
 259  if (hasmultret(e->k)) {
 260    extra++;  /* includes call itself */
 261    if (extra < 0) extra = 0;
 262    luaK_setreturns(fs, e, extra);  /* last exp. provides the difference */
 263    if (extra > 1) luaK_reserveregs(fs, extra-1);
 264  }
 265  else {
 266    if (e->k != VVOID) luaK_exp2nextreg(fs, e);  /* close last expression */
 267    if (extra > 0) {
 268      int reg = fs->freereg;
 269      luaK_reserveregs(fs, extra);
 270      luaK_nil(fs, reg, extra);
 271    }
 272  }
 273}
 274
 275
 276static void enterlevel (LexState *ls) {
 277  if (++ls->L->nCcalls > LUAI_MAXCCALLS)
 278	luaX_lexerror(ls, "chunk has too many syntax levels", 0);
 279}
 280
 281
 282#define leavelevel(ls)	((ls)->L->nCcalls--)
 283
 284
 285static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) {
 286  bl->breaklist = NO_JUMP;
 287  bl->isbreakable = isbreakable;
 288  bl->nactvar = fs->nactvar;
 289  bl->upval = 0;
 290  bl->previous = fs->bl;
 291  fs->bl = bl;
 292  lua_assert(fs->freereg == fs->nactvar);
 293}
 294
 295
 296static void leaveblock (FuncState *fs) {
 297  BlockCnt *bl = fs->bl;
 298  fs->bl = bl->previous;
 299  removevars(fs->ls, bl->nactvar);
 300  if (bl->upval)
 301    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
 302  /* a block either controls scope or breaks (never both) */
 303  lua_assert(!bl->isbreakable || !bl->upval);
 304  lua_assert(bl->nactvar == fs->nactvar);
 305  fs->freereg = fs->nactvar;  /* free registers */
 306  luaK_patchtohere(fs, bl->breaklist);
 307}
 308
 309
 310static void pushclosure (LexState *ls, FuncState *func, expdesc *v) {
 311  FuncState *fs = ls->fs;
 312  Proto *f = fs->f;
 313  int oldsize = f->sizep;
 314  int i;
 315  luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *,
 316                  MAXARG_Bx, "constant table overflow");
 317  while (oldsize < f->sizep) f->p[oldsize++] = NULL;
 318  f->p[fs->np++] = func->f;
 319  luaC_objbarrier(ls->L, f, func->f);
 320  init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));
 321  for (i=0; i<func->f->nups; i++) {
 322    OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
 323    luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0);
 324  }
 325}
 326
 327
 328static void open_func (LexState *ls, FuncState *fs) {
 329  lua_State *L = ls->L;
 330  Proto *f = luaF_newproto(L);
 331  fs->f = f;
 332  fs->prev = ls->fs;  /* linked list of funcstates */
 333  fs->ls = ls;
 334  fs->L = L;
 335  ls->fs = fs;
 336  fs->pc = 0;
 337  fs->lasttarget = -1;
 338  fs->jpc = NO_JUMP;
 339  fs->freereg = 0;
 340  fs->nk = 0;
 341  fs->np = 0;
 342  fs->nlocvars = 0;
 343  fs->nactvar = 0;
 344  fs->bl = NULL;
 345  f->source = ls->source;
 346  f->maxstacksize = 2;  /* registers 0/1 are always valid */
 347  fs->h = luaH_new(L, 0, 0);
 348  /* anchor table of constants and prototype (to avoid being collected) */
 349  sethvalue2s(L, L->top, fs->h);
 350  incr_top(L);
 351  setptvalue2s(L, L->top, f);
 352  incr_top(L);
 353}
 354
 355
 356static void close_func (LexState *ls) {
 357  lua_State *L = ls->L;
 358  FuncState *fs = ls->fs;
 359  Proto *f = fs->f;
 360  removevars(ls, 0);
 361  luaK_ret(fs, 0, 0);  /* final return */
 362  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
 363  f->sizecode = fs->pc;
 364  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
 365  f->sizelineinfo = fs->pc;
 366  luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
 367  f->sizek = fs->nk;
 368  luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
 369  f->sizep = fs->np;
 370  luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
 371  f->sizelocvars = fs->nlocvars;
 372  luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);
 373  f->sizeupvalues = f->nups;
 374  lua_assert(luaG_checkcode(f));
 375  lua_assert(fs->bl == NULL);
 376  ls->fs = fs->prev;
 377  L->top -= 2;  /* remove table and prototype from the stack */
 378  /* last token read was anchored in defunct function; must reanchor it */
 379  if (fs) anchor_token(ls);
 380}
 381
 382
 383Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
 384  struct LexState lexstate;
 385  struct FuncState funcstate;
 386  lexstate.buff = buff;
 387  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
 388  open_func(&lexstate, &funcstate);
 389  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
 390  luaX_next(&lexstate);  /* read first token */
 391  chunk(&lexstate);
 392  check(&lexstate, TK_EOS);
 393  close_func(&lexstate);
 394  lua_assert(funcstate.prev == NULL);
 395  lua_assert(funcstate.f->nups == 0);
 396  lua_assert(lexstate.fs == NULL);
 397  return funcstate.f;
 398}
 399
 400
 401
 402/*============================================================*/
 403/* GRAMMAR RULES */
 404/*============================================================*/
 405
 406
 407static void field (LexState *ls, expdesc *v) {
 408  /* field -> ['.' | ':'] NAME */
 409  FuncState *fs = ls->fs;
 410  expdesc key;
 411  luaK_exp2anyreg(fs, v);
 412  luaX_next(ls);  /* skip the dot or colon */
 413  checkname(ls, &key);
 414  luaK_indexed(fs, v, &key);
 415}
 416
 417
 418static void yindex (LexState *ls, expdesc *v) {
 419  /* index -> '[' expr ']' */
 420  luaX_next(ls);  /* skip the '[' */
 421  expr(ls, v);
 422  luaK_exp2val(ls->fs, v);
 423  checknext(ls, ']');
 424}
 425
 426
 427/*
 428** {======================================================================
 429** Rules for Constructors
 430** =======================================================================
 431*/
 432
 433
 434struct ConsControl {
 435  expdesc v;  /* last list item read */
 436  expdesc *t;  /* table descriptor */
 437  int nh;  /* total number of `record' elements */
 438  int na;  /* total number of array elements */
 439  int tostore;  /* number of array elements pending to be stored */
 440};
 441
 442
 443static void recfield (LexState *ls, struct ConsControl *cc) {
 444  /* recfield -> (NAME | `['exp1`]') = exp1 */
 445  FuncState *fs = ls->fs;
 446  int reg = ls->fs->freereg;
 447  expdesc key, val;
 448  int rkkey;
 449  if (ls->t.token == TK_NAME) {
 450    luaY_checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
 451    checkname(ls, &key);
 452  }
 453  else  /* ls->t.token == '[' */
 454    yindex(ls, &key);
 455  cc->nh++;
 456  checknext(ls, '=');
 457  rkkey = luaK_exp2RK(fs, &key);
 458  expr(ls, &val);
 459  luaK_codeABC(fs, OP_SETTABLE, cc->t->u.s.info, rkkey, luaK_exp2RK(fs, &val));
 460  fs->freereg = reg;  /* free registers */
 461}
 462
 463
 464static void closelistfield (FuncState *fs, struct ConsControl *cc) {
 465  if (cc->v.k == VVOID) return;  /* there is no list item */
 466  luaK_exp2nextreg(fs, &cc->v);
 467  cc->v.k = VVOID;
 468  if (cc->tostore == LFIELDS_PER_FLUSH) {
 469    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);  /* flush */
 470    cc->tostore = 0;  /* no more items pending */
 471  }
 472}
 473
 474
 475static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
 476  if (cc->tostore == 0) return;
 477  if (hasmultret(cc->v.k)) {
 478    luaK_setmultret(fs, &cc->v);
 479    luaK_setlist(fs, cc->t->u.s.info, cc->na, LUA_MULTRET);
 480    cc->na--;  /* do not count last expression (unknown number of elements) */
 481  }
 482  else {
 483    if (cc->v.k != VVOID)
 484      luaK_exp2nextreg(fs, &cc->v);
 485    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);
 486  }
 487}
 488
 489
 490static void listfield (LexState *ls, struct ConsControl *cc) {
 491  expr(ls, &cc->v);
 492  luaY_checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
 493  cc->na++;
 494  cc->tostore++;
 495}
 496
 497
 498static void constructor (LexState *ls, expdesc *t) {
 499  /* constructor -> ?? */
 500  FuncState *fs = ls->fs;
 501  int line = ls->linenumber;
 502  int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
 503  struct ConsControl cc;
 504  cc.na = cc.nh = cc.tostore = 0;
 505  cc.t = t;
 506  init_exp(t, VRELOCABLE, pc);
 507  init_exp(&cc.v, VVOID, 0);  /* no value (yet) */
 508  luaK_exp2nextreg(ls->fs, t);  /* fix it at stack top (for gc) */
 509  checknext(ls, '{');
 510  do {
 511    lua_assert(cc.v.k == VVOID || cc.tostore > 0);
 512    if (ls->t.token == '}') break;
 513    closelistfield(fs, &cc);
 514    switch(ls->t.token) {
 515      case TK_NAME: {  /* may be listfields or recfields */
 516        luaX_lookahead(ls);
 517        if (ls->lookahead.token != '=')  /* expression? */
 518          listfield(ls, &cc);
 519        else
 520          recfield(ls, &cc);
 521        break;
 522      }
 523      case '[': {  /* constructor_item -> recfield */
 524        recfield(ls, &cc);
 525        break;
 526      }
 527      default: {  /* constructor_part -> listfield */
 528        listfield(ls, &cc);
 529        break;
 530      }
 531    }
 532  } while (testnext(ls, ',') || testnext(ls, ';'));
 533  check_match(ls, '}', '{', line);
 534  lastlistfield(fs, &cc);
 535  SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */
 536  SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh));  /* set initial table size */
 537}
 538
 539/* }====================================================================== */
 540
 541
 542
 543static void parlist (LexState *ls) {
 544  /* parlist -> [ param { `,' param } ] */
 545  FuncState *fs = ls->fs;
 546  Proto *f = fs->f;
 547  int nparams = 0;
 548  f->is_vararg = 0;
 549  if (ls->t.token != ')') {  /* is `parlist' not empty? */
 550    do {
 551      switch (ls->t.token) {
 552        case TK_NAME: {  /* param -> NAME */
 553          new_localvar(ls, str_checkname(ls), nparams++);
 554          break;
 555        }
 556        case TK_DOTS: {  /* param -> `...' */
 557          luaX_next(ls);
 558#if defined(LUA_COMPAT_VARARG)
 559          /* use `arg' as default name */
 560          new_localvarliteral(ls, "arg", nparams++);
 561          f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;
 562#endif
 563          f->is_vararg |= VARARG_ISVARARG;
 564          break;
 565        }
 566        default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected");
 567      }
 568    } while (!f->is_vararg && testnext(ls, ','));
 569  }
 570  adjustlocalvars(ls, nparams);
 571  f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));
 572  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */
 573}
 574
 575
 576static void body (LexState *ls, expdesc *e, int needself, int line) {
 577  /* body ->  `(' parlist `)' chunk END */
 578  FuncState new_fs;
 579  open_func(ls, &new_fs);
 580  new_fs.f->linedefined = line;
 581  checknext(ls, '(');
 582  if (needself) {
 583    new_localvarliteral(ls, "self", 0);
 584    adjustlocalvars(ls, 1);
 585  }
 586  parlist(ls);
 587  checknext(ls, ')');
 588  chunk(ls);
 589  new_fs.f->lastlinedefined = ls->linenumber;
 590  check_match(ls, TK_END, TK_FUNCTION, line);
 591  close_func(ls);
 592  pushclosure(ls, &new_fs, e);
 593}
 594
 595
 596static int explist1 (LexState *ls, expdesc *v) {
 597  /* explist1 -> expr { `,' expr } */
 598  int n = 1;  /* at least one expression */
 599  expr(ls, v);
 600  while (testnext(ls, ',')) {
 601    luaK_exp2nextreg(ls->fs, v);
 602    expr(ls, v);
 603    n++;
 604  }
 605  return n;
 606}
 607
 608
 609static void funcargs (LexState *ls, expdesc *f) {
 610  FuncState *fs = ls->fs;
 611  expdesc args;
 612  int base, nparams;
 613  int line = ls->linenumber;
 614  switch (ls->t.token) {
 615    case '(': {  /* funcargs -> `(' [ explist1 ] `)' */
 616      if (line != ls->lastline)
 617        luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
 618      luaX_next(ls);
 619      if (ls->t.token == ')')  /* arg list is empty? */
 620        args.k = VVOID;
 621      else {
 622        explist1(ls, &args);
 623        luaK_setmultret(fs, &args);
 624      }
 625      check_match(ls, ')', '(', line);
 626      break;
 627    }
 628    case '{': {  /* funcargs -> constructor */
 629      constructor(ls, &args);
 630      break;
 631    }
 632    case TK_STRING: {  /* funcargs -> STRING */
 633      codestring(ls, &args, ls->t.seminfo.ts);
 634      luaX_next(ls);  /* must use `seminfo' before `next' */
 635      break;
 636    }
 637    default: {
 638      luaX_syntaxerror(ls, "function arguments expected");
 639      return;
 640    }
 641  }
 642  lua_assert(f->k == VNONRELOC);
 643  base = f->u.s.info;  /* base register for call */
 644  if (hasmultret(args.k))
 645    nparams = LUA_MULTRET;  /* open call */
 646  else {
 647    if (args.k != VVOID)
 648      luaK_exp2nextreg(fs, &args);  /* close last argument */
 649    nparams = fs->freereg - (base+1);
 650  }
 651  init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
 652  luaK_fixline(fs, line);
 653  fs->freereg = base+1;  /* call remove function and arguments and leaves
 654                            (unless changed) one result */
 655}
 656
 657
 658
 659
 660/*
 661** {======================================================================
 662** Expression parsing
 663** =======================================================================
 664*/
 665
 666
 667static void prefixexp (LexState *ls, expdesc *v) {
 668  /* prefixexp -> NAME | '(' expr ')' */
 669  switch (ls->t.token) {
 670    case '(': {
 671      int line = ls->linenumber;
 672      luaX_next(ls);
 673      expr(ls, v);
 674      check_match(ls, ')', '(', line);
 675      luaK_dischargevars(ls->fs, v);
 676      return;
 677    }
 678    case TK_NAME: {
 679      singlevar(ls, v);
 680      return;
 681    }
 682    default: {
 683      luaX_syntaxerror(ls, "unexpected symbol");
 684      return;
 685    }
 686  }
 687}
 688
 689
 690static void primaryexp (LexState *ls, expdesc *v) {
 691  /* primaryexp ->
 692        prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | funcargs } */
 693  FuncState *fs = ls->fs;
 694  prefixexp(ls, v);
 695  for (;;) {
 696    switch (ls->t.token) {
 697      case '.': {  /* field */
 698        field(ls, v);
 699        break;
 700      }
 701      case '[': {  /* `[' exp1 `]' */
 702        expdesc key;
 703        luaK_exp2anyreg(fs, v);
 704        yindex(ls, &key);
 705        luaK_indexed(fs, v, &key);
 706        break;
 707      }
 708      case ':': {  /* `:' NAME funcargs */
 709        expdesc key;
 710        luaX_next(ls);
 711        checkname(ls, &key);
 712        luaK_self(fs, v, &key);
 713        funcargs(ls, v);
 714        break;
 715      }
 716      case '(': case TK_STRING: case '{': {  /* funcargs */
 717        luaK_exp2nextreg(fs, v);
 718        funcargs(ls, v);
 719        break;
 720      }
 721      default: return;
 722    }
 723  }
 724}
 725
 726
 727static void simpleexp (LexState *ls, expdesc *v) {
 728  /* simpleexp -> NUMBER | STRING | NIL | true | false | ... |
 729                  constructor | FUNCTION body | primaryexp */
 730  switch (ls->t.token) {
 731    case TK_NUMBER: {
 732      init_exp(v, VKNUM, 0);
 733      v->u.nval = ls->t.seminfo.r;
 734      break;
 735    }
 736    case TK_STRING: {
 737      codestring(ls, v, ls->t.seminfo.ts);
 738      break;
 739    }
 740    case TK_NIL: {
 741      init_exp(v, VNIL, 0);
 742      break;
 743    }
 744    case TK_TRUE: {
 745      init_exp(v, VTRUE, 0);
 746      break;
 747    }
 748    case TK_FALSE: {
 749      init_exp(v, VFALSE, 0);
 750      break;
 751    }
 752    case TK_DOTS: {  /* vararg */
 753      FuncState *fs = ls->fs;
 754      check_condition(ls, fs->f->is_vararg,
 755                      "cannot use " LUA_QL("...") " outside a vararg function");
 756      fs->f->is_vararg &= ~VARARG_NEEDSARG;  /* don't need 'arg' */
 757      init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
 758      break;
 759    }
 760    case '{': {  /* constructor */
 761      constructor(ls, v);
 762      return;
 763    }
 764    case TK_FUNCTION: {
 765      luaX_next(ls);
 766      body(ls, v, 0, ls->linenumber);
 767      return;
 768    }
 769    default: {
 770      primaryexp(ls, v);
 771      return;
 772    }
 773  }
 774  luaX_next(ls);
 775}
 776
 777
 778static UnOpr getunopr (int op) {
 779  switch (op) {
 780    case TK_NOT: return OPR_NOT;
 781    case '-': return OPR_MINUS;
 782    case '#': return OPR_LEN;
 783    default: return OPR_NOUNOPR;
 784  }
 785}
 786
 787
 788static BinOpr getbinopr (int op) {
 789  switch (op) {
 790    case '+': return OPR_ADD;
 791    case '-': return OPR_SUB;
 792    case '*': return OPR_MUL;
 793    case '/': return OPR_DIV;
 794    case '%': return OPR_MOD;
 795    case '^': return OPR_POW;
 796    case TK_CONCAT: return OPR_CONCAT;
 797    case TK_NE: return OPR_NE;
 798    case TK_EQ: return OPR_EQ;
 799    case '<': return OPR_LT;
 800    case TK_LE: return OPR_LE;
 801    case '>': return OPR_GT;
 802    case TK_GE: return OPR_GE;
 803    case TK_AND: return OPR_AND;
 804    case TK_OR: return OPR_OR;
 805    default: return OPR_NOBINOPR;
 806  }
 807}
 808
 809
 810static const struct {
 811  lu_byte left;  /* left priority for each binary operator */
 812  lu_byte right; /* right priority */
 813} priority[] = {  /* ORDER OPR */
 814   {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7},  /* `+' `-' `/' `%' */
 815   {10, 9}, {5, 4},                 /* power and concat (right associative) */
 816   {3, 3}, {3, 3},                  /* equality and inequality */
 817   {3, 3}, {3, 3}, {3, 3}, {3, 3},  /* order */
 818   {2, 2}, {1, 1}                   /* logical (and/or) */
 819};
 820
 821#define UNARY_PRIORITY	8  /* priority for unary operators */
 822
 823
 824/*
 825** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
 826** where `binop' is any binary operator with a priority higher than `limit'
 827*/
 828static BinOpr subexpr (LexState *ls, expdesc *v, unsigned int limit) {
 829  BinOpr op;
 830  UnOpr uop;
 831  enterlevel(ls);
 832  uop = getunopr(ls->t.token);
 833  if (uop != OPR_NOUNOPR) {
 834    luaX_next(ls);
 835    subexpr(ls, v, UNARY_PRIORITY);
 836    luaK_prefix(ls->fs, uop, v);
 837  }
 838  else simpleexp(ls, v);
 839  /* expand while operators have priorities higher than `limit' */
 840  op = getbinopr(ls->t.token);
 841  while (op != OPR_NOBINOPR && priority[op].left > limit) {
 842    expdesc v2;
 843    BinOpr nextop;
 844    luaX_next(ls);
 845    luaK_infix(ls->fs, op, v);
 846    /* read sub-expression with higher priority */
 847    nextop = subexpr(ls, &v2, priority[op].right);
 848    luaK_posfix(ls->fs, op, v, &v2);
 849    op = nextop;
 850  }
 851  leavelevel(ls);
 852  return op;  /* return first untreated operator */
 853}
 854
 855
 856static void expr (LexState *ls, expdesc *v) {
 857  subexpr(ls, v, 0);
 858}
 859
 860/* }==================================================================== */
 861
 862
 863
 864/*
 865** {======================================================================
 866** Rules for Statements
 867** =======================================================================
 868*/
 869
 870
 871static int block_follow (int token) {
 872  switch (token) {
 873    case TK_ELSE: case TK_ELSEIF: case TK_END:
 874    case TK_UNTIL: case TK_EOS:
 875      return 1;
 876    default: return 0;
 877  }
 878}
 879
 880
 881static void block (LexState *ls) {
 882  /* block -> chunk */
 883  FuncState *fs = ls->fs;
 884  BlockCnt bl;
 885  enterblock(fs, &bl, 0);
 886  chunk(ls);
 887  lua_assert(bl.breaklist == NO_JUMP);
 888  leaveblock(fs);
 889}
 890
 891
 892/*
 893** structure to chain all variables in the left-hand side of an
 894** assignment
 895*/
 896struct LHS_assign {
 897  struct LHS_assign *prev;
 898  expdesc v;  /* variable (global, local, upvalue, or indexed) */
 899};
 900
 901
 902/*
 903** check whether, in an assignment to a local variable, the local variable
 904** is needed in a previous assignment (to a table). If so, save original
 905** local value in a safe place and use this safe copy in the previous
 906** assignment.
 907*/
 908static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
 909  FuncState *fs = ls->fs;
 910  int extra = fs->freereg;  /* eventual position to save local variable */
 911  int conflict = 0;
 912  for (; lh; lh = lh->prev) {
 913    if (lh->v.k == VINDEXED) {
 914      if (lh->v.u.s.info == v->u.s.info) {  /* conflict? */
 915        conflict = 1;
 916        lh->v.u.s.info = extra;  /* previous assignment will use safe copy */
 917      }
 918      if (lh->v.u.s.aux == v->u.s.info) {  /* conflict? */
 919        conflict = 1;
 920        lh->v.u.s.aux = extra;  /* previous assignment will use safe copy */
 921      }
 922    }
 923  }
 924  if (conflict) {
 925    luaK_codeABC(fs, OP_MOVE, fs->freereg, v->u.s.info, 0);  /* make copy */
 926    luaK_reserveregs(fs, 1);
 927  }
 928}
 929
 930
 931static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
 932  expdesc e;
 933  check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED,
 934                      "syntax error");
 935  if (testnext(ls, ',')) {  /* assignment -> `,' primaryexp assignment */
 936    struct LHS_assign nv;
 937    nv.prev = lh;
 938    primaryexp(ls, &nv.v);
 939    if (nv.v.k == VLOCAL)
 940      check_conflict(ls, lh, &nv.v);
 941    luaY_checklimit(ls->fs, nvars, LUAI_MAXCCALLS - ls->L->nCcalls,
 942                    "variables in assignment");
 943    assignment(ls, &nv, nvars+1);
 944  }
 945  else {  /* assignment -> `=' explist1 */
 946    int nexps;
 947    checknext(ls, '=');
 948    nexps = explist1(ls, &e);
 949    if (nexps != nvars) {
 950      adjust_assign(ls, nvars, nexps, &e);
 951      if (nexps > nvars)
 952        ls->fs->freereg -= nexps - nvars;  /* remove extra values */
 953    }
 954    else {
 955      luaK_setoneret(ls->fs, &e);  /* close last expression */
 956      luaK_storevar(ls->fs, &lh->v, &e);
 957      return;  /* avoid default */
 958    }
 959  }
 960  init_exp(&e, VNONRELOC, ls->fs->freereg-1);  /* default assignment */
 961  luaK_storevar(ls->fs, &lh->v, &e);
 962}
 963
 964
 965static int cond (LexState *ls) {
 966  /* cond -> exp */
 967  expdesc v;
 968  expr(ls, &v);  /* read condition */
 969  if (v.k == VNIL) v.k = VFALSE;  /* `falses' are all equal here */
 970  luaK_goiftrue(ls->fs, &v);
 971  return v.f;
 972}
 973
 974
 975static void breakstat (LexState *ls) {
 976  FuncState *fs = ls->fs;
 977  BlockCnt *bl = fs->bl;
 978  int upval = 0;
 979  while (bl && !bl->isbreakable) {
 980    upval |= bl->upval;
 981    bl = bl->previous;
 982  }
 983  if (!bl)
 984    luaX_syntaxerror(ls, "no loop to break");
 985  if (upval)
 986    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
 987  luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
 988}
 989
 990
 991static void whilestat (LexState *ls, int line) {
 992  /* whilestat -> WHILE cond DO block END */
 993  FuncState *fs = ls->fs;
 994  int whileinit;
 995  int condexit;
 996  BlockCnt bl;
 997  luaX_next(ls);  /* skip WHILE */
 998  whileinit = luaK_getlabel(fs);
 999  condexit = cond(ls);
1000  enterblock(fs, &bl, 1);
1001  checknext(ls, TK_DO);
1002  block(ls);
1003  luaK_patchlist(fs, luaK_jump(fs), whileinit);
1004  check_match(ls, TK_END, TK_WHILE, line);
1005  leaveblock(fs);
1006  luaK_patchtohere(fs, condexit);  /* false conditions finish the loop */
1007}
1008
1009
1010static void repeatstat (LexState *ls, int line) {
1011  /* repeatstat -> REPEAT block UNTIL cond */
1012  int condexit;
1013  FuncState *fs = ls->fs;
1014  int repeat_init = luaK_getlabel(fs);
1015  BlockCnt bl1, bl2;
1016  enterblock(fs, &bl1, 1);  /* loop block */
1017  enterblock(fs, &bl2, 0);  /* scope block */
1018  luaX_next(ls);  /* skip REPEAT */
1019  chunk(ls);
1020  check_match(ls, TK_UNTIL, TK_REPEAT, line);
1021  condexit = cond(ls);  /* read condition (inside scope block) */
1022  if (!bl2.upval) {  /* no upvalues? */
1023    leaveblock(fs);  /* finish scope */
1024    luaK_patchlist(ls->fs, condexit, repeat_init);  /* close the loop */
1025  }
1026  else {  /* complete semantics when there are upvalues */
1027    breakstat(ls);  /* if condition then break */
1028    luaK_patchtohere(ls->fs, condexit);  /* else... */
1029    leaveblock(fs);  /* finish scope... */
1030    luaK_patchlist(ls->fs, luaK_jump(fs), repeat_init);  /* and repeat */
1031  }
1032  leaveblock(fs);  /* finish loop */
1033}
1034
1035
1036static int exp1 (LexState *ls) {
1037  expdesc e;
1038  int k;
1039  expr(ls, &e);
1040  k = e.k;
1041  luaK_exp2nextreg(ls->fs, &e);
1042  return k;
1043}
1044
1045
1046static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
1047  /* forbody -> DO block */
1048  BlockCnt bl;
1049  FuncState *fs = ls->fs;
1050  int prep, endfor;
1051  adjustlocalvars(ls, 3);  /* control variables */
1052  checknext(ls, TK_DO);
1053  prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
1054  enterblock(fs, &bl, 0);  /* scope for declared variables */
1055  adjustlocalvars(ls, nvars);
1056  luaK_reserveregs(fs, nvars);
1057  block(ls);
1058  leaveblock(fs);  /* end of scope for declared variables */
1059  luaK_patchtohere(fs, prep);
1060  endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) :
1061                     luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars);
1062  luaK_fixline(fs, line);  /* pretend that `OP_FOR' starts the loop */
1063  luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1);
1064}
1065
1066
1067static void fornum (LexState *ls, TString *varname, int line) {
1068  /* fornum -> NAME = exp1,exp1[,exp1] forbody */
1069  FuncState *fs = ls->fs;
1070  int base = fs->freereg;
1071  new_localvarliteral(ls, "(for index)", 0);
1072  new_localvarliteral(ls, "(for limit)", 1);
1073  new_localvarliteral(ls, "(for step)", 2);
1074  new_localvar(ls, varname, 3);
1075  checknext(ls, '=');
1076  exp1(ls);  /* initial value */
1077  checknext(ls, ',');
1078  exp1(ls);  /* limit */
1079  if (testnext(ls, ','))
1080    exp1(ls);  /* optional step */
1081  else {  /* default step = 1 */
1082    luaK_codeABx(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1));
1083    luaK_reserveregs(fs, 1);
1084  }
1085  forbody(ls, base, line, 1, 1);
1086}
1087
1088
1089static void forlist (LexState *ls, TString *indexname) {
1090  /* forlist -> NAME {,NAME} IN explist1 forbody */
1091  FuncState *fs = ls->fs;
1092  expdesc e;
1093  int nvars = 0;
1094  int line;
1095  int base = fs->freereg;
1096  /* create control variables */
1097  new_localvarliteral(ls, "(for generator)", nvars++);
1098  new_localvarliteral(ls, "(for state)", nvars++);
1099  new_localvarliteral(ls, "(for control)", nvars++);
1100  /* create declared variables */
1101  new_localvar(ls, indexname, nvars++);
1102  while (testnext(ls, ','))
1103    new_localvar(ls, str_checkname(ls), nvars++);
1104  checknext(ls, TK_IN);
1105  line = ls->linenumber;
1106  adjust_assign(ls, 3, explist1(ls, &e), &e);
1107  luaK_checkstack(fs, 3);  /* extra space to call generator */
1108  forbody(ls, base, line, nvars - 3, 0);
1109}
1110
1111
1112static void forstat (LexState *ls, int line) {
1113  /* forstat -> FOR (fornum | forlist) END */
1114  FuncState *fs = ls->fs;
1115  TString *varname;
1116  BlockCnt bl;
1117  enterblock(fs, &bl, 1);  /* scope for loop and control variables */
1118  luaX_next(ls);  /* skip `for' */
1119  varname = str_checkname(ls);  /* first variable name */
1120  switch (ls->t.token) {
1121    case '=': fornum(ls, varname, line); break;
1122    case ',': case TK_IN: forlist(ls, varname); break;
1123    default: luaX_syntaxerror(ls, LUA_QL("=") " or " LUA_QL("in") " expected");
1124  }
1125  check_match(ls, TK_END, TK_FOR, line);
1126  leaveblock(fs);  /* loop scope (`break' jumps to this point) */
1127}
1128
1129
1130static int test_then_block (LexState *ls) {
1131  /* test_then_block -> [IF | ELSEIF] cond THEN block */
1132  int condexit;
1133  luaX_next(ls);  /* skip IF or ELSEIF */
1134  condexit = cond(ls);
1135  checknext(ls, TK_THEN);
1136  block(ls);  /* `then' part */
1137  return condexit;
1138}
1139
1140
1141static void ifstat (LexState *ls, int line) {
1142  /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
1143  FuncState *fs = ls->fs;
1144  int flist;
1145  int escapelist = NO_JUMP;
1146  flist = test_then_block(ls);  /* IF cond THEN block */
1147  while (ls->t.token == TK_ELSEIF) {
1148    luaK_concat(fs, &escapelist, luaK_jump(fs));
1149    luaK_patchtohere(fs, flist);
1150    flist = test_then_block(ls);  /* ELSEIF cond THEN block */
1151  }
1152  if (ls->t.token == TK_ELSE) {
1153    luaK_concat(fs, &escapelist, luaK_jump(fs));
1154    luaK_patchtohere(fs, flist);
1155    luaX_next(ls);  /* skip ELSE (after patch, for correct line info) */
1156    block(ls);  /* `else' part */
1157  }
1158  else
1159    luaK_concat(fs, &escapelist, flist);
1160  luaK_patchtohere(fs, escapelist);
1161  check_match(ls, TK_END, TK_IF, line);
1162}
1163
1164
1165static void localfunc (LexState *ls) {
1166  expdesc v, b;
1167  FuncState *fs = ls->fs;
1168  new_localvar(ls, str_checkname(ls), 0);
1169  init_exp(&v, VLOCAL, fs->freereg);
1170  luaK_reserveregs(fs, 1);
1171  adjustlocalvars(ls, 1);
1172  body(ls, &b, 0, ls->linenumber);
1173  luaK_storevar(fs, &v, &b);
1174  /* debug information will only see the variable after this point! */
1175  getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;
1176}
1177
1178
1179static void localstat (LexState *ls) {
1180  /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */
1181  int nvars = 0;
1182  int nexps;
1183  expdesc e;
1184  do {
1185    new_localvar(ls, str_checkname(ls), nvars++);
1186  } while (testnext(ls, ','));
1187  if (testnext(ls, '='))
1188    nexps = explist1(ls, &e);
1189  else {
1190    e.k = VVOID;
1191    nexps = 0;
1192  }
1193  adjust_assign(ls, nvars, nexps, &e);
1194  adjustlocalvars(ls, nvars);
1195}
1196
1197
1198static int funcname (LexState *ls, expdesc *v) {
1199  /* funcname -> NAME {field} [`:' NAME] */
1200  int needself = 0;
1201  singlevar(ls, v);
1202  while (ls->t.token == '.')
1203    field(ls, v);
1204  if (ls->t.token == ':') {
1205    needself = 1;
1206    field(ls, v);
1207  }
1208  return needself;
1209}
1210
1211
1212static void funcstat (LexState *ls, int line) {
1213  /* funcstat -> FUNCTION funcname body */
1214  int needself;
1215  expdesc v, b;
1216  luaX_next(ls);  /* skip FUNCTION */
1217  needself = funcname(ls, &v);
1218  body(ls, &b, needself, line);
1219  luaK_storevar(ls->fs, &v, &b);
1220  luaK_fixline(ls->fs, line);  /* definition `happens' in the first line */
1221}
1222
1223
1224static void exprstat (LexState *ls) {
1225  /* stat -> func | assignment */
1226  FuncState *fs = ls->fs;
1227  struct LHS_assign v;
1228  primaryexp(ls, &v.v);
1229  if (v.v.k == VCALL)  /* stat -> func */
1230    SETARG_C(getcode(fs, &v.v), 1);  /* call statement uses no results */
1231  else {  /* stat -> assignment */
1232    v.prev = NULL;
1233    assignment(ls, &v, 1);
1234  }
1235}
1236
1237
1238static void retstat (LexState *ls) {
1239  /* stat -> RETURN explist */
1240  FuncState *fs = ls->fs;
1241  expdesc e;
1242  int first, nret;  /* registers with returned values */
1243  luaX_next(ls);  /* skip RETURN */
1244  if (block_follow(ls->t.token) || ls->t.token == ';')
1245    first = nret = 0;  /* return no values */
1246  else {
1247    nret = explist1(ls, &e);  /* optional return values */
1248    if (hasmultret(e.k)) {
1249      luaK_setmultret(fs, &e);
1250      if (e.k == VCALL && nret == 1) {  /* tail call? */
1251        SET_OPCODE(getcode(fs,&e), OP_TAILCALL);
1252        lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar);
1253      }
1254      first = fs->nactvar;
1255      nret = LUA_MULTRET;  /* return all values */
1256    }
1257    else {
1258      if (nret == 1)  /* only one single value? */
1259        first = luaK_exp2anyreg(fs, &e);
1260      else {
1261        luaK_exp2nextreg(fs, &e);  /* values must go to the `stack' */
1262        first = fs->nactvar;  /* return all `active' values */
1263        lua_assert(nret == fs->freereg - first);
1264      }
1265    }
1266  }
1267  luaK_ret(fs, first, nret);
1268}
1269
1270
1271static int statement (LexState *ls) {
1272  int line = ls->linenumber;  /* may be needed for error messages */
1273  switch (ls->t.token) {
1274    case TK_IF: {  /* stat -> ifstat */
1275      ifstat(ls, line);
1276      return 0;
1277    }
1278    case TK_WHILE: {  /* stat -> whilestat */
1279      whilestat(ls, line);
1280      return 0;
1281    }
1282    case TK_DO: {  /* stat -> DO block END */
1283      luaX_next(ls);  /* skip DO */
1284      block(ls);
1285      check_match(ls, TK_END, TK_DO, line);
1286      return 0;
1287    }
1288    case TK_FOR: {  /* stat -> forstat */
1289      forstat(ls, line);
1290      return 0;
1291    }
1292    case TK_REPEAT: {  /* stat -> repeatstat */
1293      repeatstat(ls, line);
1294      return 0;
1295    }
1296    case TK_FUNCTION: {
1297      funcstat(ls, line);  /* stat -> funcstat */
1298      return 0;
1299    }
1300    case TK_LOCAL: {  /* stat -> localstat */
1301      luaX_next(ls);  /* skip LOCAL */
1302      if (testnext(ls, TK_FUNCTION))  /* local function? */
1303        localfunc(ls);
1304      else
1305        localstat(ls);
1306      return 0;
1307    }
1308    case TK_RETURN: {  /* stat -> retstat */
1309      retstat(ls);
1310      return 1;  /* must be last statement */
1311    }
1312    case TK_BREAK: {  /* stat -> breakstat */
1313      luaX_next(ls);  /* skip BREAK */
1314      breakstat(ls);
1315      return 1;  /* must be last statement */
1316    }
1317    default: {
1318      exprstat(ls);
1319      return 0;  /* to avoid warnings */
1320    }
1321  }
1322}
1323
1324
1325static void chunk (LexState *ls) {
1326  /* chunk -> { stat [`;'] } */
1327  int islast = 0;
1328  enterlevel(ls);
1329  while (!islast && !block_follow(ls->t.token)) {
1330    islast = statement(ls);
1331    testnext(ls, ';');
1332    lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
1333               ls->fs->freereg >= ls->fs->nactvar);
1334    ls->fs->freereg = ls->fs->nactvar;  /* free registers */
1335  }
1336  leavelevel(ls);
1337}
1338
1339/* }====================================================================== */