root/lib/lua/lparser.c

DEFINITIONS

1. anchor_token
2. error_expected
3. errorlimit
4. testnext
5. check
6. checknext
7. check_match
8. str_checkname
9. init_exp
10. codestring
11. checkname
12. registerlocalvar
13. new_localvar
14. adjustlocalvars
15. removevars
16. indexupvalue
17. searchvar
18. markupval
19. singlevaraux
20. singlevar
21. adjust_assign
22. enterlevel
23. enterblock
24. leaveblock
25. pushclosure
26. open_func
27. close_func
28. luaY_parser
29. field
30. yindex
31. recfield
32. closelistfield
33. lastlistfield
34. listfield
35. constructor
36. parlist
37. body
38. explist1
39. funcargs
40. prefixexp
41. primaryexp
42. simpleexp
43. getunopr
44. getbinopr
45. subexpr
46. expr
47. block_follow
48. block
49. check_conflict
50. assignment
51. cond
52. breakstat
53. whilestat
54. repeatstat
55. exp1
56. forbody
57. fornum
58. forlist
59. forstat
60. test_then_block
61. ifstat
62. localfunc
63. localstat
64. funcname
65. funcstat
66. exprstat
67. retstat
68. statement
69. chunk

   1 /*
   2 ** $Id: lparser.c,v 2.42.1.4 2011/10/21 19:31:42 roberto Exp $
   3 ** Lua Parser
   4 ** See Copyright Notice in lua.h
   5 */
   8 #include <string.h>
  10 #define lparser_c
  11 #define LUA_CORE
  13 #include "lua.h"
  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"
  30 #define hasmultret(k)           ((k) == VCALL || (k) == VVARARG)
  32 #define getlocvar(fs, i)        ((fs)->f->locvars[(fs)->actvar[i]])
  34 #define luaY_checklimit(fs,v,l,m)       if ((v)>(l)) errorlimit(fs,l,m)
  37 /*
  38 ** nodes for block list (list of active blocks)
  39 */
  40 typedef struct BlockCnt {
  41   struct BlockCnt *previous;  /* chain */
  42   int breaklist;  /* list of jumps out of this loop */
lu_byte nactvar;  /* # active locals outside the breakable structure */
lu_byte upval;  /* true if some variable in the block is an upvalue */
lu_byte isbreakable;  /* true if `block' is a loop */
  46 } BlockCnt;
  50 /*
  51 ** prototypes for recursive non-terminal functions
  52 */
  53 static void chunk (LexState *ls);
  54 static void expr (LexState *ls, expdesc *v);
  57 static void anchor_token (LexState *ls) {
  58   if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {
TString *ts = ls->t.seminfo.ts;
luaX_newstring(ls, getstr(ts), ts->tsv.len);
  61   }
  62 }
  65 static void error_expected (LexState *ls, int token) {
luaX_syntaxerror(ls,
luaO_pushfstring(ls->L, LUA_QS " expected", luaX_token2str(ls, token)));
  68 }
  71 static void errorlimit (FuncState *fs, int limit, const char *what) {
  72   const char *msg = (fs->f->linedefined == 0) ?
luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) :
luaO_pushfstring(fs->L, "function at line %d has more than %d %s",
fs->f->linedefined, limit, what);
luaX_lexerror(fs->ls, msg, 0);
  77 }
  80 static int testnext (LexState *ls, int c) {
  81   if (ls->t.token == c) {
luaX_next(ls);
  83     return 1;
  84   }
  85   else return 0;
  86 }
  89 static void check (LexState *ls, int c) {
  90   if (ls->t.token != c)
error_expected(ls, c);
  92 }
  94 static void checknext (LexState *ls, int c) {
check(ls, c);
luaX_next(ls);
  97 }
 100 #define check_condition(ls,c,msg)       { if (!(c)) luaX_syntaxerror(ls, msg); }
 104 static void check_match (LexState *ls, int what, int who, int where) {
 105   if (!testnext(ls, what)) {
 106     if (where == ls->linenumber)
error_expected(ls, what);
 108     else {
luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
LUA_QS " expected (to close " LUA_QS " at line %d)",
luaX_token2str(ls, what), luaX_token2str(ls, who), where));
 112     }
 113   }
 114 }
 117 static TString *str_checkname (LexState *ls) {
TString *ts;
check(ls, TK_NAME);
ts = ls->t.seminfo.ts;
luaX_next(ls);
 122   return ts;
 123 }
 126 static void init_exp (expdesc *e, expkind k, int i) {
e->f = e->t = NO_JUMP;
e->k = k;
e->u.s.info = i;
 130 }
 133 static void codestring (LexState *ls, expdesc *e, TString *s) {
init_exp(e, VK, luaK_stringK(ls->fs, s));
 135 }
 138 static void checkname(LexState *ls, expdesc *e) {
codestring(ls, e, str_checkname(ls));
 140 }
 143 static int registerlocalvar (LexState *ls, TString *varname) {
FuncState *fs = ls->fs;
Proto *f = fs->f;
 146   int oldsize = f->sizelocvars;
luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
LocVar, SHRT_MAX, "too many local variables");
 149   while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL;
f->locvars[fs->nlocvars].varname = varname;
luaC_objbarrier(ls->L, f, varname);
 152   return fs->nlocvars++;
 153 }
 156 #define new_localvarliteral(ls,v,n) \
new_localvar(ls, luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char))-1), n)
 160 static void new_localvar (LexState *ls, TString *name, int n) {
FuncState *fs = ls->fs;
luaY_checklimit(fs, fs->nactvar+n+1, LUAI_MAXVARS, "local variables");
fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name));
 164 }
 167 static void adjustlocalvars (LexState *ls, int nvars) {
FuncState *fs = ls->fs;
fs->nactvar = cast_byte(fs->nactvar + nvars);
 170   for (; nvars; nvars--) {
getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
 172   }
 173 }
 176 static void removevars (LexState *ls, int tolevel) {
FuncState *fs = ls->fs;
 178   while (fs->nactvar > tolevel)
getlocvar(fs, --fs->nactvar).endpc = fs->pc;
 180 }
 183 static int indexupvalue (FuncState *fs, TString *name, expdesc *v) {
 184   int i;
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) {
lua_assert(f->upvalues[i] == name);
 190       return i;
 191     }
 192   }
 193   /* new one */
luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, "upvalues");
luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,
TString *, MAX_INT, "");
 197   while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL;
f->upvalues[f->nups] = name;
luaC_objbarrier(fs->L, f, name);
lua_assert(v->k == VLOCAL || v->k == VUPVAL);
fs->upvalues[f->nups].k = cast_byte(v->k);
fs->upvalues[f->nups].info = cast_byte(v->u.s.info);
 203   return f->nups++;
 204 }
 207 static 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 }
 217 static void markupval (FuncState *fs, int level) {
BlockCnt *bl = fs->bl;
 219   while (bl && bl->nactvar > level) bl = bl->previous;
 220   if (bl) bl->upval = 1;
 221 }
 224 static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
 225   if (fs == NULL) {  /* no more levels? */
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) {
init_exp(var, VLOCAL, v);
 233       if (!base)
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;
var->u.s.info = indexupvalue(fs, n, var);  /* else was LOCAL or UPVAL */
var->k = VUPVAL;  /* upvalue in this level */
 242       return VUPVAL;
 243     }
 244   }
 245 }
 248 static void singlevar (LexState *ls, expdesc *var) {
TString *varname = str_checkname(ls);
FuncState *fs = ls->fs;
 251   if (singlevaraux(fs, varname, var, 1) == VGLOBAL)
var->u.s.info = luaK_stringK(fs, varname);  /* info points to global name */
 253 }
 256 static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
FuncState *fs = ls->fs;
 258   int extra = nvars - nexps;
 259   if (hasmultret(e->k)) {
extra++;  /* includes call itself */
 261     if (extra < 0) extra = 0;
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;
luaK_reserveregs(fs, extra);
luaK_nil(fs, reg, extra);
 271     }
 272   }
 273 }
 276 static void enterlevel (LexState *ls) {
 277   if (++ls->L->nCcalls > LUAI_MAXCCALLS)
luaX_lexerror(ls, "chunk has too many syntax levels", 0);
 279 }
 282 #define leavelevel(ls)  ((ls)->L->nCcalls--)
 285 static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) {
bl->breaklist = NO_JUMP;
bl->isbreakable = isbreakable;
bl->nactvar = fs->nactvar;
bl->upval = 0;
bl->previous = fs->bl;
fs->bl = bl;
lua_assert(fs->freereg == fs->nactvar);
 293 }
 296 static void leaveblock (FuncState *fs) {
BlockCnt *bl = fs->bl;
fs->bl = bl->previous;
removevars(fs->ls, bl->nactvar);
 300   if (bl->upval)
luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
 302   /* a block either controls scope or breaks (never both) */
lua_assert(!bl->isbreakable || !bl->upval);
lua_assert(bl->nactvar == fs->nactvar);
fs->freereg = fs->nactvar;  /* free registers */
luaK_patchtohere(fs, bl->breaklist);
 307 }
 310 static void pushclosure (LexState *ls, FuncState *func, expdesc *v) {
FuncState *fs = ls->fs;
Proto *f = fs->f;
 313   int oldsize = f->sizep;
 314   int i;
luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *,
MAXARG_Bx, "constant table overflow");
 317   while (oldsize < f->sizep) f->p[oldsize++] = NULL;
f->p[fs->np++] = func->f;
luaC_objbarrier(ls->L, f, func->f);
init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));
 321   for (i=0; i<func->f->nups; i++) {
OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0);
 324   }
 325 }
 328 static void open_func (LexState *ls, FuncState *fs) {
lua_State *L = ls->L;
Proto *f = luaF_newproto(L);
fs->f = f;
fs->prev = ls->fs;  /* linked list of funcstates */
fs->ls = ls;
fs->L = L;
ls->fs = fs;
fs->pc = 0;
fs->lasttarget = -1;
fs->jpc = NO_JUMP;
fs->freereg = 0;
fs->nk = 0;
fs->np = 0;
fs->nlocvars = 0;
fs->nactvar = 0;
fs->bl = NULL;
f->source = ls->source;
f->maxstacksize = 2;  /* registers 0/1 are always valid */
fs->h = luaH_new(L, 0, 0);
 348   /* anchor table of constants and prototype (to avoid being collected) */
sethvalue2s(L, L->top, fs->h);
incr_top(L);
setptvalue2s(L, L->top, f);
incr_top(L);
 353 }
 356 static void close_func (LexState *ls) {
lua_State *L = ls->L;
FuncState *fs = ls->fs;
Proto *f = fs->f;
removevars(ls, 0);
luaK_ret(fs, 0, 0);  /* final return */
luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
f->sizecode = fs->pc;
luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
f->sizelineinfo = fs->pc;
luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
f->sizek = fs->nk;
luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
f->sizep = fs->np;
luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
f->sizelocvars = fs->nlocvars;
luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);
f->sizeupvalues = f->nups;
lua_assert(luaG_checkcode(f));
lua_assert(fs->bl == NULL);
ls->fs = fs->prev;
 377   /* last token read was anchored in defunct function; must reanchor it */
 378   if (fs) anchor_token(ls);
L->top -= 2;  /* remove table and prototype from the stack */
 380 }
LUAI_FUNC Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
 384   struct LexState lexstate;
 385   struct FuncState funcstate;
lexstate.buff = buff;
luaX_setinput(L, &lexstate, z, luaS_new(L, name));
open_func(&lexstate, &funcstate);
funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
luaX_next(&lexstate);  /* read first token */
chunk(&lexstate);
check(&lexstate, TK_EOS);
close_func(&lexstate);
lua_assert(funcstate.prev == NULL);
lua_assert(funcstate.f->nups == 0);
lua_assert(lexstate.fs == NULL);
 397   return funcstate.f;
 398 }
 402 /*============================================================*/
 403 /* GRAMMAR RULES */
 404 /*============================================================*/
 407 static void field (LexState *ls, expdesc *v) {
 408   /* field -> ['.' | ':'] NAME */
FuncState *fs = ls->fs;
expdesc key;
luaK_exp2anyreg(fs, v);
luaX_next(ls);  /* skip the dot or colon */
checkname(ls, &key);
luaK_indexed(fs, v, &key);
 415 }
 418 static void yindex (LexState *ls, expdesc *v) {
 419   /* index -> '[' expr ']' */
luaX_next(ls);  /* skip the '[' */
expr(ls, v);
luaK_exp2val(ls->fs, v);
checknext(ls, ']');
 424 }
 427 /*
 428 ** {======================================================================
 429 ** Rules for Constructors
 430 ** =======================================================================
 431 */
 434 struct ConsControl {
expdesc v;  /* last list item read */
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 };
 443 static void recfield (LexState *ls, struct ConsControl *cc) {
 444   /* recfield -> (NAME | `['exp1`]') = exp1 */
FuncState *fs = ls->fs;
 446   int reg = ls->fs->freereg;
expdesc key, val;
 448   int rkkey;
 449   if (ls->t.token == TK_NAME) {
luaY_checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
checkname(ls, &key);
 452   }
 453   else  /* ls->t.token == '[' */
yindex(ls, &key);
cc->nh++;
checknext(ls, '=');
rkkey = luaK_exp2RK(fs, &key);
expr(ls, &val);
luaK_codeABC(fs, OP_SETTABLE, cc->t->u.s.info, rkkey, luaK_exp2RK(fs, &val));
fs->freereg = reg;  /* free registers */
 461 }
 464 static void closelistfield (FuncState *fs, struct ConsControl *cc) {
 465   if (cc->v.k == VVOID) return;  /* there is no list item */
luaK_exp2nextreg(fs, &cc->v);
cc->v.k = VVOID;
 468   if (cc->tostore == LFIELDS_PER_FLUSH) {
luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);  /* flush */
cc->tostore = 0;  /* no more items pending */
 471   }
 472 }
 475 static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
 476   if (cc->tostore == 0) return;
 477   if (hasmultret(cc->v.k)) {
luaK_setmultret(fs, &cc->v);
luaK_setlist(fs, cc->t->u.s.info, cc->na, LUA_MULTRET);
cc->na--;  /* do not count last expression (unknown number of elements) */
 481   }
 482   else {
 483     if (cc->v.k != VVOID)
luaK_exp2nextreg(fs, &cc->v);
luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);
 486   }
 487 }
 490 static void listfield (LexState *ls, struct ConsControl *cc) {
expr(ls, &cc->v);
luaY_checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
cc->na++;
cc->tostore++;
 495 }
 498 static void constructor (LexState *ls, expdesc *t) {
 499   /* constructor -> ?? */
FuncState *fs = ls->fs;
 501   int line = ls->linenumber;
 502   int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
 503   struct ConsControl cc;
cc.na = cc.nh = cc.tostore = 0;
cc.t = t;
init_exp(t, VRELOCABLE, pc);
init_exp(&cc.v, VVOID, 0);  /* no value (yet) */
luaK_exp2nextreg(ls->fs, t);  /* fix it at stack top (for gc) */
checknext(ls, '{');
 510   do {
lua_assert(cc.v.k == VVOID || cc.tostore > 0);
 512     if (ls->t.token == '}') break;
closelistfield(fs, &cc);
 514     switch(ls->t.token) {
 515       case TK_NAME: {  /* may be listfields or recfields */
luaX_lookahead(ls);
 517         if (ls->lookahead.token != '=')  /* expression? */
listfield(ls, &cc);
 519         else
recfield(ls, &cc);
 521         break;
 522       }
 523       case '[': {  /* constructor_item -> recfield */
recfield(ls, &cc);
 525         break;
 526       }
 527       default: {  /* constructor_part -> listfield */
listfield(ls, &cc);
 529         break;
 530       }
 531     }
 532   } while (testnext(ls, ',') || testnext(ls, ';'));
check_match(ls, '}', '{', line);
lastlistfield(fs, &cc);
SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */
SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh));  /* set initial table size */
 537 }
 539 /* }====================================================================== */
 543 static void parlist (LexState *ls) {
 544   /* parlist -> [ param { `,' param } ] */
FuncState *fs = ls->fs;
Proto *f = fs->f;
 547   int nparams = 0;
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 */
new_localvar(ls, str_checkname(ls), nparams++);
 554           break;
 555         }
 556         case TK_DOTS: {  /* param -> `...' */
luaX_next(ls);
 558 #if defined(LUA_COMPAT_VARARG)
 559           /* use `arg' as default name */
new_localvarliteral(ls, "arg", nparams++);
f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;
 562 #endif
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   }
adjustlocalvars(ls, nparams);
f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));
luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */
 573 }
 576 static void body (LexState *ls, expdesc *e, int needself, int line) {
 577   /* body ->  `(' parlist `)' chunk END */
FuncState new_fs;
open_func(ls, &new_fs);
new_fs.f->linedefined = line;
checknext(ls, '(');
 582   if (needself) {
new_localvarliteral(ls, "self", 0);
adjustlocalvars(ls, 1);
 585   }
parlist(ls);
checknext(ls, ')');
chunk(ls);
new_fs.f->lastlinedefined = ls->linenumber;
check_match(ls, TK_END, TK_FUNCTION, line);
close_func(ls);
pushclosure(ls, &new_fs, e);
 593 }
 596 static int explist1 (LexState *ls, expdesc *v) {
 597   /* explist1 -> expr { `,' expr } */
 598   int n = 1;  /* at least one expression */
expr(ls, v);
 600   while (testnext(ls, ',')) {
luaK_exp2nextreg(ls->fs, v);
expr(ls, v);
n++;
 604   }
 605   return n;
 606 }
 609 static void funcargs (LexState *ls, expdesc *f) {
FuncState *fs = ls->fs;
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)
luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
luaX_next(ls);
 619       if (ls->t.token == ')')  /* arg list is empty? */
args.k = VVOID;
 621       else {
explist1(ls, &args);
luaK_setmultret(fs, &args);
 624       }
check_match(ls, ')', '(', line);
 626       break;
 627     }
 628     case '{': {  /* funcargs -> constructor */
constructor(ls, &args);
 630       break;
 631     }
 632     case TK_STRING: {  /* funcargs -> STRING */
codestring(ls, &args, ls->t.seminfo.ts);
luaX_next(ls);  /* must use `seminfo' before `next' */
 635       break;
 636     }
 637     default: {
luaX_syntaxerror(ls, "function arguments expected");
 639       return;
 640     }
 641   }
lua_assert(f->k == VNONRELOC);
base = f->u.s.info;  /* base register for call */
 644   if (hasmultret(args.k))
nparams = LUA_MULTRET;  /* open call */
 646   else {
 647     if (args.k != VVOID)
luaK_exp2nextreg(fs, &args);  /* close last argument */
nparams = fs->freereg - (base+1);
 650   }
init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
luaK_fixline(fs, line);
fs->freereg = base+1;  /* call remove function and arguments and leaves
 654                             (unless changed) one result */
 655 }
 660 /*
 661 ** {======================================================================
 662 ** Expression parsing
 663 ** =======================================================================
 664 */
 667 static void prefixexp (LexState *ls, expdesc *v) {
 668   /* prefixexp -> NAME | '(' expr ')' */
 669   switch (ls->t.token) {
 670     case '(': {
 671       int line = ls->linenumber;
luaX_next(ls);
expr(ls, v);
check_match(ls, ')', '(', line);
luaK_dischargevars(ls->fs, v);
 676       return;
 677     }
 678     case TK_NAME: {
singlevar(ls, v);
 680       return;
 681     }
 682     default: {
luaX_syntaxerror(ls, "unexpected symbol");
 684       return;
 685     }
 686   }
 687 }
 690 static void primaryexp (LexState *ls, expdesc *v) {
 691   /* primaryexp ->
 692         prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | funcargs } */
FuncState *fs = ls->fs;
prefixexp(ls, v);
 695   for (;;) {
 696     switch (ls->t.token) {
 697       case '.': {  /* field */
field(ls, v);
 699         break;
 700       }
 701       case '[': {  /* `[' exp1 `]' */
expdesc key;
luaK_exp2anyreg(fs, v);
yindex(ls, &key);
luaK_indexed(fs, v, &key);
 706         break;
 707       }
 708       case ':': {  /* `:' NAME funcargs */
expdesc key;
luaX_next(ls);
checkname(ls, &key);
luaK_self(fs, v, &key);
funcargs(ls, v);
 714         break;
 715       }
 716       case '(': case TK_STRING: case '{': {  /* funcargs */
luaK_exp2nextreg(fs, v);
funcargs(ls, v);
 719         break;
 720       }
 721       default: return;
 722     }
 723   }
 724 }
 727 static 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: {
init_exp(v, VKNUM, 0);
v->u.nval = ls->t.seminfo.r;
 734       break;
 735     }
 736     case TK_STRING: {
codestring(ls, v, ls->t.seminfo.ts);
 738       break;
 739     }
 740     case TK_NIL: {
init_exp(v, VNIL, 0);
 742       break;
 743     }
 744     case TK_TRUE: {
init_exp(v, VTRUE, 0);
 746       break;
 747     }
 748     case TK_FALSE: {
init_exp(v, VFALSE, 0);
 750       break;
 751     }
 752     case TK_DOTS: {  /* vararg */
FuncState *fs = ls->fs;
check_condition(ls, fs->f->is_vararg,
 755                       "cannot use " LUA_QL("...") " outside a vararg function");
fs->f->is_vararg &= ~VARARG_NEEDSARG;  /* don't need 'arg' */
init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
 758       break;
 759     }
 760     case '{': {  /* constructor */
constructor(ls, v);
 762       return;
 763     }
 764     case TK_FUNCTION: {
luaX_next(ls);
body(ls, v, 0, ls->linenumber);
 767       return;
 768     }
 769     default: {
primaryexp(ls, v);
 771       return;
 772     }
 773   }
luaX_next(ls);
 775 }
 778 static 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 }
 788 static 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 }
 810 static const struct {
lu_byte left;  /* left priority for each binary operator */
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 };
 821 #define UNARY_PRIORITY  8  /* priority for unary operators */
 824 /*
 825 ** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
 826 ** where `binop' is any binary operator with a priority higher than `limit'
 827 */
 828 static BinOpr subexpr (LexState *ls, expdesc *v, unsigned int limit) {
BinOpr op;
UnOpr uop;
enterlevel(ls);
uop = getunopr(ls->t.token);
 833   if (uop != OPR_NOUNOPR) {
luaX_next(ls);
subexpr(ls, v, UNARY_PRIORITY);
luaK_prefix(ls->fs, uop, v);
 837   }
 838   else simpleexp(ls, v);
 839   /* expand while operators have priorities higher than `limit' */
op = getbinopr(ls->t.token);
 841   while (op != OPR_NOBINOPR && priority[op].left > limit) {
expdesc v2;
BinOpr nextop;
luaX_next(ls);
luaK_infix(ls->fs, op, v);
 846     /* read sub-expression with higher priority */
nextop = subexpr(ls, &v2, priority[op].right);
luaK_posfix(ls->fs, op, v, &v2);
op = nextop;
 850   }
leavelevel(ls);
 852   return op;  /* return first untreated operator */
 853 }
 856 static void expr (LexState *ls, expdesc *v) {
subexpr(ls, v, 0);
 858 }
 860 /* }==================================================================== */
 864 /*
 865 ** {======================================================================
 866 ** Rules for Statements
 867 ** =======================================================================
 868 */
 871 static 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 }
 881 static void block (LexState *ls) {
 882   /* block -> chunk */
FuncState *fs = ls->fs;
BlockCnt bl;
enterblock(fs, &bl, 0);
chunk(ls);
lua_assert(bl.breaklist == NO_JUMP);
leaveblock(fs);
 889 }
 892 /*
 893 ** structure to chain all variables in the left-hand side of an
 894 ** assignment
 895 */
 896 struct LHS_assign {
 897   struct LHS_assign *prev;
expdesc v;  /* variable (global, local, upvalue, or indexed) */
 899 };
 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 */
 908 static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
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? */
conflict = 1;
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? */
conflict = 1;
lh->v.u.s.aux = extra;  /* previous assignment will use safe copy */
 921       }
 922     }
 923   }
 924   if (conflict) {
luaK_codeABC(fs, OP_MOVE, fs->freereg, v->u.s.info, 0);  /* make copy */
luaK_reserveregs(fs, 1);
 927   }
 928 }
 931 static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
expdesc e;
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;
nv.prev = lh;
primaryexp(ls, &nv.v);
 939     if (nv.v.k == VLOCAL)
check_conflict(ls, lh, &nv.v);
luaY_checklimit(ls->fs, nvars, LUAI_MAXCCALLS - ls->L->nCcalls,
 942                     "variables in assignment");
assignment(ls, &nv, nvars+1);
 944   }
 945   else {  /* assignment -> `=' explist1 */
 946     int nexps;
checknext(ls, '=');
nexps = explist1(ls, &e);
 949     if (nexps != nvars) {
adjust_assign(ls, nvars, nexps, &e);
 951       if (nexps > nvars)
ls->fs->freereg -= nexps - nvars;  /* remove extra values */
 953     }
 954     else {
luaK_setoneret(ls->fs, &e);  /* close last expression */
luaK_storevar(ls->fs, &lh->v, &e);
 957       return;  /* avoid default */
 958     }
 959   }
init_exp(&e, VNONRELOC, ls->fs->freereg-1);  /* default assignment */
luaK_storevar(ls->fs, &lh->v, &e);
 962 }
 965 static int cond (LexState *ls) {
 966   /* cond -> exp */
expdesc v;
expr(ls, &v);  /* read condition */
 969   if (v.k == VNIL) v.k = VFALSE;  /* `falses' are all equal here */
luaK_goiftrue(ls->fs, &v);
 971   return v.f;
 972 }
 975 static void breakstat (LexState *ls) {
FuncState *fs = ls->fs;
BlockCnt *bl = fs->bl;
 978   int upval = 0;
 979   while (bl && !bl->isbreakable) {
upval |= bl->upval;
bl = bl->previous;
 982   }
 983   if (!bl)
luaX_syntaxerror(ls, "no loop to break");
 985   if (upval)
luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
 988 }
 991 static void whilestat (LexState *ls, int line) {
 992   /* whilestat -> WHILE cond DO block END */
FuncState *fs = ls->fs;
 994   int whileinit;
 995   int condexit;
BlockCnt bl;
luaX_next(ls);  /* skip WHILE */
whileinit = luaK_getlabel(fs);
condexit = cond(ls);
enterblock(fs, &bl, 1);
checknext(ls, TK_DO);
block(ls);
luaK_patchlist(fs, luaK_jump(fs), whileinit);
check_match(ls, TK_END, TK_WHILE, line);
leaveblock(fs);
luaK_patchtohere(fs, condexit);  /* false conditions finish the loop */
1007 }
1010 static void repeatstat (LexState *ls, int line) {
1011   /* repeatstat -> REPEAT block UNTIL cond */
1012   int condexit;
FuncState *fs = ls->fs;
1014   int repeat_init = luaK_getlabel(fs);
BlockCnt bl1, bl2;
enterblock(fs, &bl1, 1);  /* loop block */
enterblock(fs, &bl2, 0);  /* scope block */
luaX_next(ls);  /* skip REPEAT */
chunk(ls);
check_match(ls, TK_UNTIL, TK_REPEAT, line);
condexit = cond(ls);  /* read condition (inside scope block) */
1022   if (!bl2.upval) {  /* no upvalues? */
leaveblock(fs);  /* finish scope */
luaK_patchlist(ls->fs, condexit, repeat_init);  /* close the loop */
1025   }
1026   else {  /* complete semantics when there are upvalues */
breakstat(ls);  /* if condition then break */
luaK_patchtohere(ls->fs, condexit);  /* else... */
leaveblock(fs);  /* finish scope... */
luaK_patchlist(ls->fs, luaK_jump(fs), repeat_init);  /* and repeat */
1031   }
leaveblock(fs);  /* finish loop */
1033 }
1036 static int exp1 (LexState *ls) {
expdesc e;
1038   int k;
expr(ls, &e);
k = e.k;
luaK_exp2nextreg(ls->fs, &e);
1042   return k;
1043 }
1046 static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
1047   /* forbody -> DO block */
BlockCnt bl;
FuncState *fs = ls->fs;
1050   int prep, endfor;
adjustlocalvars(ls, 3);  /* control variables */
checknext(ls, TK_DO);
prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
enterblock(fs, &bl, 0);  /* scope for declared variables */
adjustlocalvars(ls, nvars);
luaK_reserveregs(fs, nvars);
block(ls);
leaveblock(fs);  /* end of scope for declared variables */
luaK_patchtohere(fs, prep);
endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) :
luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars);
luaK_fixline(fs, line);  /* pretend that `OP_FOR' starts the loop */
luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1);
1064 }
1067 static void fornum (LexState *ls, TString *varname, int line) {
1068   /* fornum -> NAME = exp1,exp1[,exp1] forbody */
FuncState *fs = ls->fs;
1070   int base = fs->freereg;
new_localvarliteral(ls, "(for index)", 0);
new_localvarliteral(ls, "(for limit)", 1);
new_localvarliteral(ls, "(for step)", 2);
new_localvar(ls, varname, 3);
checknext(ls, '=');
exp1(ls);  /* initial value */
checknext(ls, ',');
exp1(ls);  /* limit */
1079   if (testnext(ls, ','))
exp1(ls);  /* optional step */
1081   else {  /* default step = 1 */
luaK_codeABx(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1));
luaK_reserveregs(fs, 1);
1084   }
forbody(ls, base, line, 1, 1);
1086 }
1089 static void forlist (LexState *ls, TString *indexname) {
1090   /* forlist -> NAME {,NAME} IN explist1 forbody */
FuncState *fs = ls->fs;
expdesc e;
1093   int nvars = 0;
1094   int line;
1095   int base = fs->freereg;
1096   /* create control variables */
new_localvarliteral(ls, "(for generator)", nvars++);
new_localvarliteral(ls, "(for state)", nvars++);
new_localvarliteral(ls, "(for control)", nvars++);
1100   /* create declared variables */
new_localvar(ls, indexname, nvars++);
1102   while (testnext(ls, ','))
new_localvar(ls, str_checkname(ls), nvars++);
checknext(ls, TK_IN);
line = ls->linenumber;
adjust_assign(ls, 3, explist1(ls, &e), &e);
luaK_checkstack(fs, 3);  /* extra space to call generator */
forbody(ls, base, line, nvars - 3, 0);
1109 }
1112 static void forstat (LexState *ls, int line) {
1113   /* forstat -> FOR (fornum | forlist) END */
FuncState *fs = ls->fs;
TString *varname;
BlockCnt bl;
enterblock(fs, &bl, 1);  /* scope for loop and control variables */
luaX_next(ls);  /* skip `for' */
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   }
check_match(ls, TK_END, TK_FOR, line);
leaveblock(fs);  /* loop scope (`break' jumps to this point) */
1127 }
1130 static int test_then_block (LexState *ls) {
1131   /* test_then_block -> [IF | ELSEIF] cond THEN block */
1132   int condexit;
luaX_next(ls);  /* skip IF or ELSEIF */
condexit = cond(ls);
checknext(ls, TK_THEN);
block(ls);  /* `then' part */
1137   return condexit;
1138 }
1141 static void ifstat (LexState *ls, int line) {
1142   /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */
FuncState *fs = ls->fs;
1144   int flist;
1145   int escapelist = NO_JUMP;
flist = test_then_block(ls);  /* IF cond THEN block */
1147   while (ls->t.token == TK_ELSEIF) {
luaK_concat(fs, &escapelist, luaK_jump(fs));
luaK_patchtohere(fs, flist);
flist = test_then_block(ls);  /* ELSEIF cond THEN block */
1151   }
1152   if (ls->t.token == TK_ELSE) {
luaK_concat(fs, &escapelist, luaK_jump(fs));
luaK_patchtohere(fs, flist);
luaX_next(ls);  /* skip ELSE (after patch, for correct line info) */
block(ls);  /* `else' part */
1157   }
1158   else
luaK_concat(fs, &escapelist, flist);
luaK_patchtohere(fs, escapelist);
check_match(ls, TK_END, TK_IF, line);
1162 }
1165 static void localfunc (LexState *ls) {
expdesc v, b;
FuncState *fs = ls->fs;
new_localvar(ls, str_checkname(ls), 0);
init_exp(&v, VLOCAL, fs->freereg);
luaK_reserveregs(fs, 1);
adjustlocalvars(ls, 1);
body(ls, &b, 0, ls->linenumber);
luaK_storevar(fs, &v, &b);
1174   /* debug information will only see the variable after this point! */
getlocvar(fs, fs->nactvar - 1).startpc = fs->pc;
1176 }
1179 static void localstat (LexState *ls) {
1180   /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */
1181   int nvars = 0;
1182   int nexps;
expdesc e;
1184   do {
new_localvar(ls, str_checkname(ls), nvars++);
1186   } while (testnext(ls, ','));
1187   if (testnext(ls, '='))
nexps = explist1(ls, &e);
1189   else {
e.k = VVOID;
nexps = 0;
1192   }
adjust_assign(ls, nvars, nexps, &e);
adjustlocalvars(ls, nvars);
1195 }
1198 static int funcname (LexState *ls, expdesc *v) {
1199   /* funcname -> NAME {field} [`:' NAME] */
1200   int needself = 0;
singlevar(ls, v);
1202   while (ls->t.token == '.')
field(ls, v);
1204   if (ls->t.token == ':') {
needself = 1;
field(ls, v);
1207   }
1208   return needself;
1209 }
1212 static void funcstat (LexState *ls, int line) {
1213   /* funcstat -> FUNCTION funcname body */
1214   int needself;
expdesc v, b;
luaX_next(ls);  /* skip FUNCTION */
needself = funcname(ls, &v);
body(ls, &b, needself, line);
luaK_storevar(ls->fs, &v, &b);
luaK_fixline(ls->fs, line);  /* definition `happens' in the first line */
1221 }
1224 static void exprstat (LexState *ls) {
1225   /* stat -> func | assignment */
FuncState *fs = ls->fs;
1227   struct LHS_assign v;
primaryexp(ls, &v.v);
1229   if (v.v.k == VCALL)  /* stat -> func */
SETARG_C(getcode(fs, &v.v), 1);  /* call statement uses no results */
1231   else {  /* stat -> assignment */
v.prev = NULL;
assignment(ls, &v, 1);
1234   }
1235 }
1238 static void retstat (LexState *ls) {
1239   /* stat -> RETURN explist */
FuncState *fs = ls->fs;
expdesc e;
1242   int first, nret;  /* registers with returned values */
luaX_next(ls);  /* skip RETURN */
1244   if (block_follow(ls->t.token) || ls->t.token == ';')
first = nret = 0;  /* return no values */
1246   else {
nret = explist1(ls, &e);  /* optional return values */
1248     if (hasmultret(e.k)) {
luaK_setmultret(fs, &e);
1250       if (e.k == VCALL && nret == 1) {  /* tail call? */
SET_OPCODE(getcode(fs,&e), OP_TAILCALL);
lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar);
1253       }
first = fs->nactvar;
nret = LUA_MULTRET;  /* return all values */
1256     }
1257     else {
1258       if (nret == 1)  /* only one single value? */
first = luaK_exp2anyreg(fs, &e);
1260       else {
luaK_exp2nextreg(fs, &e);  /* values must go to the `stack' */
first = fs->nactvar;  /* return all `active' values */
lua_assert(nret == fs->freereg - first);
1264       }
1265     }
1266   }
luaK_ret(fs, first, nret);
1268 }
1271 static 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 */
ifstat(ls, line);
1276       return 0;
1277     }
1278     case TK_WHILE: {  /* stat -> whilestat */
whilestat(ls, line);
1280       return 0;
1281     }
1282     case TK_DO: {  /* stat -> DO block END */
luaX_next(ls);  /* skip DO */
block(ls);
check_match(ls, TK_END, TK_DO, line);
1286       return 0;
1287     }
1288     case TK_FOR: {  /* stat -> forstat */
forstat(ls, line);
1290       return 0;
1291     }
1292     case TK_REPEAT: {  /* stat -> repeatstat */
repeatstat(ls, line);
1294       return 0;
1295     }
1296     case TK_FUNCTION: {
funcstat(ls, line);  /* stat -> funcstat */
1298       return 0;
1299     }
1300     case TK_LOCAL: {  /* stat -> localstat */
luaX_next(ls);  /* skip LOCAL */
1302       if (testnext(ls, TK_FUNCTION))  /* local function? */
localfunc(ls);
1304       else
localstat(ls);
1306       return 0;
1307     }
1308     case TK_RETURN: {  /* stat -> retstat */
retstat(ls);
1310       return 1;  /* must be last statement */
1311     }
1312     case TK_BREAK: {  /* stat -> breakstat */
luaX_next(ls);  /* skip BREAK */
breakstat(ls);
1315       return 1;  /* must be last statement */
1316     }
1317     default: {
exprstat(ls);
1319       return 0;  /* to avoid warnings */
1320     }
1321   }
1322 }
1325 static void chunk (LexState *ls) {
1326   /* chunk -> { stat [`;'] } */
1327   int islast = 0;
enterlevel(ls);
1329   while (!islast && !block_follow(ls->t.token)) {
islast = statement(ls);
testnext(ls, ';');
lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&
ls->fs->freereg >= ls->fs->nactvar);
ls->fs->freereg = ls->fs->nactvar;  /* free registers */
1335   }
leavelevel(ls);
1337 }
1339 /* }====================================================================== */