LCOV - code coverage report
Current view: directory - src - lparser.c Found Hit Coverage
Test: Lua 5.1.4 Lines: 755 723 95.8 %
Date: 2009-09-13
Colors: not hit hit

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

Generated by: LCOV version 1.7