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 */

    40 typedef 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 */

    53 static void chunk (LexState *ls);

    54 static void expr (LexState *ls, expdesc *v);

    55 

    56 

    57 static 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 

    65 static 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 

    71 static 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 

    80 static 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 

    89 static void check (LexState *ls, int c) {

    90   if (ls->t.token != c)

    91     error_expected(ls, c);

    92 }

    93 

    94 static 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 

   104 static 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 

   117 static 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 

   126 static 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 

   133 static void codestring (LexState *ls, expdesc *e, TString *s) {

   134   init_exp(e, VK, luaK_stringK(ls->fs, s));

   135 }

   136 

   137 

   138 static void checkname(LexState *ls, expdesc *e) {

   139   codestring(ls, e, str_checkname(ls));

   140 }

   141 

   142 

   143 static 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 

   160 static 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 

   167 static 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 

   176 static 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 

   183 static 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 

   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 }

   215 

   216 

   217 static 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 

   224 static 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 

   248 static 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 

   256 static 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 

   276 static 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 

   285 static 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 

   296 static 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 

   310 static 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 

   328 static 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 

   356 static 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 

   383 Proto *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 

   407 static 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 

   418 static 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 

   434 struct 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 

   443 static 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 

   464 static 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 

   475 static 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 

   490 static 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 

   498 static 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 

   543 static 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 

   576 static 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 

   596 static 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 

   609 static 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 

   667 static 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 

   690 static 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 

   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: {

   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 

   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 }

   786 

   787 

   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 }

   808 

   809 

   810 static 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 */

   828 static 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 

   856 static 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 

   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 }

   879 

   880 

   881 static 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 */

   896 struct 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 */

   908 static 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 

   931 static 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 

   965 static 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 

   975 static 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 

   991 static 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 

  1010 static 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 

  1036 static 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 

  1046 static 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 

  1067 static 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 

  1089 static 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 

  1112 static 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 

  1130 static 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);