1323530Savg/* 2323530Savg** $Id: lparser.c,v 2.130.1.1 2013/04/12 18:48:47 roberto Exp $ 3323530Savg** Lua Parser 4323530Savg** See Copyright Notice in lua.h 5323530Savg*/ 6323530Savg 7323530Savg#include <sys/zfs_context.h> 8323530Savg 9323530Savg#define lparser_c 10323530Savg#define LUA_CORE 11323530Savg 12323530Savg#include "lua.h" 13323530Savg 14323530Savg#include "lcode.h" 15323530Savg#include "ldebug.h" 16323530Savg#include "ldo.h" 17323530Savg#include "lfunc.h" 18323530Savg#include "llex.h" 19323530Savg#include "lmem.h" 20323530Savg#include "lobject.h" 21323530Savg#include "lopcodes.h" 22323530Savg#include "lparser.h" 23323530Savg#include "lstate.h" 24323530Savg#include "lstring.h" 25323530Savg#include "ltable.h" 26323530Savg 27323530Savg 28323530Savg 29323530Savg/* maximum number of local variables per function (must be smaller 30323530Savg than 250, due to the bytecode format) */ 31323530Savg#define MAXVARS 200 32323530Savg 33323530Savg 34323530Savg#define hasmultret(k) ((k) == VCALL || (k) == VVARARG) 35323530Savg 36323530Savg 37323530Savg 38323530Savg/* 39323530Savg** nodes for block list (list of active blocks) 40323530Savg*/ 41323530Savgtypedef struct BlockCnt { 42323530Savg struct BlockCnt *previous; /* chain */ 43323530Savg short firstlabel; /* index of first label in this block */ 44323530Savg short firstgoto; /* index of first pending goto in this block */ 45323530Savg lu_byte nactvar; /* # active locals outside the block */ 46323530Savg lu_byte upval; /* true if some variable in the block is an upvalue */ 47323530Savg lu_byte isloop; /* true if `block' is a loop */ 48323530Savg} BlockCnt; 49323530Savg 50323530Savg 51323530Savg 52323530Savg/* 53323530Savg** prototypes for recursive non-terminal functions 54323530Savg*/ 55323530Savgstatic void statement (LexState *ls); 56323530Savgstatic void expr (LexState *ls, expdesc *v); 57323530Savg 58323530Savg 59323530Savgstatic void anchor_token (LexState *ls) { 60323530Savg /* last token from outer function must be EOS */ 61323530Savg lua_assert(ls->fs != NULL || ls->t.token == TK_EOS); 62323530Savg if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) { 63323530Savg TString *ts = ls->t.seminfo.ts; 64323530Savg luaX_newstring(ls, getstr(ts), ts->tsv.len); 65323530Savg } 66323530Savg} 67323530Savg 68323530Savg 69323530Savg/* semantic error */ 70323530Savgstatic l_noret semerror (LexState *ls, const char *msg) { 71323530Savg ls->t.token = 0; /* remove 'near to' from final message */ 72323530Savg luaX_syntaxerror(ls, msg); 73323530Savg} 74323530Savg 75323530Savg 76323530Savgstatic l_noret error_expected (LexState *ls, int token) { 77323530Savg luaX_syntaxerror(ls, 78323530Savg luaO_pushfstring(ls->L, "%s expected", luaX_token2str(ls, token))); 79323530Savg} 80323530Savg 81323530Savg 82323530Savgstatic l_noret errorlimit (FuncState *fs, int limit, const char *what) { 83323530Savg lua_State *L = fs->ls->L; 84323530Savg const char *msg; 85323530Savg int line = fs->f->linedefined; 86323530Savg const char *where = (line == 0) 87323530Savg ? "main function" 88323530Savg : luaO_pushfstring(L, "function at line %d", line); 89323530Savg msg = luaO_pushfstring(L, "too many %s (limit is %d) in %s", 90323530Savg what, limit, where); 91323530Savg luaX_syntaxerror(fs->ls, msg); 92323530Savg} 93323530Savg 94323530Savg 95323530Savgstatic void checklimit (FuncState *fs, int v, int l, const char *what) { 96323530Savg if (v > l) errorlimit(fs, l, what); 97323530Savg} 98323530Savg 99323530Savg 100323530Savgstatic int testnext (LexState *ls, int c) { 101323530Savg if (ls->t.token == c) { 102323530Savg luaX_next(ls); 103323530Savg return 1; 104323530Savg } 105323530Savg else return 0; 106323530Savg} 107323530Savg 108323530Savg 109323530Savgstatic void check (LexState *ls, int c) { 110323530Savg if (ls->t.token != c) 111323530Savg error_expected(ls, c); 112323530Savg} 113323530Savg 114323530Savg 115323530Savgstatic void checknext (LexState *ls, int c) { 116323530Savg check(ls, c); 117323530Savg luaX_next(ls); 118323530Savg} 119323530Savg 120323530Savg 121323530Savg#define check_condition(ls,c,msg) { if (!(c)) luaX_syntaxerror(ls, msg); } 122323530Savg 123323530Savg 124323530Savg 125323530Savgstatic void check_match (LexState *ls, int what, int who, int where) { 126323530Savg if (!testnext(ls, what)) { 127323530Savg if (where == ls->linenumber) 128323530Savg error_expected(ls, what); 129323530Savg else { 130323530Savg luaX_syntaxerror(ls, luaO_pushfstring(ls->L, 131323530Savg "%s expected (to close %s at line %d)", 132323530Savg luaX_token2str(ls, what), luaX_token2str(ls, who), where)); 133323530Savg } 134323530Savg } 135323530Savg} 136323530Savg 137323530Savg 138323530Savgstatic TString *str_checkname (LexState *ls) { 139323530Savg TString *ts; 140323530Savg check(ls, TK_NAME); 141323530Savg ts = ls->t.seminfo.ts; 142323530Savg luaX_next(ls); 143323530Savg return ts; 144323530Savg} 145323530Savg 146323530Savg 147323530Savgstatic void init_exp (expdesc *e, expkind k, int i) { 148323530Savg e->f = e->t = NO_JUMP; 149323530Savg e->k = k; 150323530Savg e->u.info = i; 151323530Savg} 152323530Savg 153323530Savg 154323530Savgstatic void codestring (LexState *ls, expdesc *e, TString *s) { 155323530Savg init_exp(e, VK, luaK_stringK(ls->fs, s)); 156323530Savg} 157323530Savg 158323530Savg 159323530Savgstatic void checkname (LexState *ls, expdesc *e) { 160323530Savg codestring(ls, e, str_checkname(ls)); 161323530Savg} 162323530Savg 163323530Savg 164323530Savgstatic int registerlocalvar (LexState *ls, TString *varname) { 165323530Savg FuncState *fs = ls->fs; 166323530Savg Proto *f = fs->f; 167323530Savg int oldsize = f->sizelocvars; 168323530Savg luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars, 169323530Savg LocVar, SHRT_MAX, "local variables"); 170323530Savg while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL; 171323530Savg f->locvars[fs->nlocvars].varname = varname; 172323530Savg luaC_objbarrier(ls->L, f, varname); 173323530Savg return fs->nlocvars++; 174323530Savg} 175323530Savg 176323530Savg 177323530Savgstatic void new_localvar (LexState *ls, TString *name) { 178323530Savg FuncState *fs = ls->fs; 179323530Savg Dyndata *dyd = ls->dyd; 180323530Savg int reg = registerlocalvar(ls, name); 181323530Savg checklimit(fs, dyd->actvar.n + 1 - fs->firstlocal, 182323530Savg MAXVARS, "local variables"); 183323530Savg luaM_growvector(ls->L, dyd->actvar.arr, dyd->actvar.n + 1, 184323530Savg dyd->actvar.size, Vardesc, MAX_INT, "local variables"); 185323530Savg dyd->actvar.arr[dyd->actvar.n++].idx = cast(short, reg); 186323530Savg} 187323530Savg 188323530Savg 189323530Savgstatic void new_localvarliteral_ (LexState *ls, const char *name, size_t sz) { 190323530Savg new_localvar(ls, luaX_newstring(ls, name, sz)); 191323530Savg} 192323530Savg 193323530Savg#define new_localvarliteral(ls,v) \ 194323530Savg new_localvarliteral_(ls, "" v, (sizeof(v)/sizeof(char))-1) 195323530Savg 196323530Savg 197323530Savgstatic LocVar *getlocvar (FuncState *fs, int i) { 198323530Savg int idx = fs->ls->dyd->actvar.arr[fs->firstlocal + i].idx; 199323530Savg lua_assert(idx < fs->nlocvars); 200323530Savg return &fs->f->locvars[idx]; 201323530Savg} 202323530Savg 203323530Savg 204323530Savgstatic void adjustlocalvars (LexState *ls, int nvars) { 205323530Savg FuncState *fs = ls->fs; 206323530Savg fs->nactvar = cast_byte(fs->nactvar + nvars); 207323530Savg for (; nvars; nvars--) { 208323530Savg getlocvar(fs, fs->nactvar - nvars)->startpc = fs->pc; 209323530Savg } 210323530Savg} 211323530Savg 212323530Savg 213323530Savgstatic void removevars (FuncState *fs, int tolevel) { 214323530Savg fs->ls->dyd->actvar.n -= (fs->nactvar - tolevel); 215323530Savg while (fs->nactvar > tolevel) 216323530Savg getlocvar(fs, --fs->nactvar)->endpc = fs->pc; 217323530Savg} 218323530Savg 219323530Savg 220323530Savgstatic int searchupvalue (FuncState *fs, TString *name) { 221323530Savg int i; 222323530Savg Upvaldesc *up = fs->f->upvalues; 223323530Savg for (i = 0; i < fs->nups; i++) { 224323530Savg if (luaS_eqstr(up[i].name, name)) return i; 225323530Savg } 226323530Savg return -1; /* not found */ 227323530Savg} 228323530Savg 229323530Savg 230323530Savgstatic int newupvalue (FuncState *fs, TString *name, expdesc *v) { 231323530Savg Proto *f = fs->f; 232323530Savg int oldsize = f->sizeupvalues; 233323530Savg checklimit(fs, fs->nups + 1, MAXUPVAL, "upvalues"); 234323530Savg luaM_growvector(fs->ls->L, f->upvalues, fs->nups, f->sizeupvalues, 235323530Savg Upvaldesc, MAXUPVAL, "upvalues"); 236323530Savg while (oldsize < f->sizeupvalues) f->upvalues[oldsize++].name = NULL; 237323530Savg f->upvalues[fs->nups].instack = (v->k == VLOCAL); 238323530Savg f->upvalues[fs->nups].idx = cast_byte(v->u.info); 239323530Savg f->upvalues[fs->nups].name = name; 240323530Savg luaC_objbarrier(fs->ls->L, f, name); 241323530Savg return fs->nups++; 242323530Savg} 243323530Savg 244323530Savg 245323530Savgstatic int searchvar (FuncState *fs, TString *n) { 246323530Savg int i; 247323530Savg for (i = cast_int(fs->nactvar) - 1; i >= 0; i--) { 248323530Savg if (luaS_eqstr(n, getlocvar(fs, i)->varname)) 249323530Savg return i; 250323530Savg } 251323530Savg return -1; /* not found */ 252323530Savg} 253323530Savg 254323530Savg 255323530Savg/* 256323530Savg Mark block where variable at given level was defined 257323530Savg (to emit close instructions later). 258323530Savg*/ 259323530Savgstatic void markupval (FuncState *fs, int level) { 260323530Savg BlockCnt *bl = fs->bl; 261323530Savg while (bl->nactvar > level) bl = bl->previous; 262323530Savg bl->upval = 1; 263323530Savg} 264323530Savg 265323530Savg 266323530Savg/* 267323530Savg Find variable with given name 'n'. If it is an upvalue, add this 268323530Savg upvalue into all intermediate functions. 269323530Savg*/ 270323530Savgstatic int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { 271323530Savg if (fs == NULL) /* no more levels? */ 272323530Savg return VVOID; /* default is global */ 273323530Savg else { 274323530Savg int v = searchvar(fs, n); /* look up locals at current level */ 275323530Savg if (v >= 0) { /* found? */ 276323530Savg init_exp(var, VLOCAL, v); /* variable is local */ 277323530Savg if (!base) 278323530Savg markupval(fs, v); /* local will be used as an upval */ 279323530Savg return VLOCAL; 280323530Savg } 281323530Savg else { /* not found as local at current level; try upvalues */ 282323530Savg int idx = searchupvalue(fs, n); /* try existing upvalues */ 283323530Savg if (idx < 0) { /* not found? */ 284323530Savg if (singlevaraux(fs->prev, n, var, 0) == VVOID) /* try upper levels */ 285323530Savg return VVOID; /* not found; is a global */ 286323530Savg /* else was LOCAL or UPVAL */ 287323530Savg idx = newupvalue(fs, n, var); /* will be a new upvalue */ 288323530Savg } 289323530Savg init_exp(var, VUPVAL, idx); 290323530Savg return VUPVAL; 291323530Savg } 292323530Savg } 293323530Savg} 294323530Savg 295323530Savg 296323530Savgstatic void singlevar (LexState *ls, expdesc *var) { 297323530Savg TString *varname = str_checkname(ls); 298323530Savg FuncState *fs = ls->fs; 299323530Savg if (singlevaraux(fs, varname, var, 1) == VVOID) { /* global name? */ 300323530Savg expdesc key; 301323530Savg singlevaraux(fs, ls->envn, var, 1); /* get environment variable */ 302323530Savg lua_assert(var->k == VLOCAL || var->k == VUPVAL); 303323530Savg codestring(ls, &key, varname); /* key is variable name */ 304323530Savg luaK_indexed(fs, var, &key); /* env[varname] */ 305323530Savg } 306323530Savg} 307323530Savg 308323530Savg 309323530Savgstatic void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) { 310323530Savg FuncState *fs = ls->fs; 311323530Savg int extra = nvars - nexps; 312323530Savg if (hasmultret(e->k)) { 313323530Savg extra++; /* includes call itself */ 314323530Savg if (extra < 0) extra = 0; 315323530Savg luaK_setreturns(fs, e, extra); /* last exp. provides the difference */ 316323530Savg if (extra > 1) luaK_reserveregs(fs, extra-1); 317323530Savg } 318323530Savg else { 319323530Savg if (e->k != VVOID) luaK_exp2nextreg(fs, e); /* close last expression */ 320323530Savg if (extra > 0) { 321323530Savg int reg = fs->freereg; 322323530Savg luaK_reserveregs(fs, extra); 323323530Savg luaK_nil(fs, reg, extra); 324323530Savg } 325323530Savg } 326323530Savg} 327323530Savg 328323530Savg 329323530Savgstatic void enterlevel (LexState *ls) { 330323530Savg lua_State *L = ls->L; 331323530Savg ++L->nCcalls; 332323530Savg checklimit(ls->fs, L->nCcalls, LUAI_MAXCCALLS, "C levels"); 333323530Savg} 334323530Savg 335323530Savg 336323530Savg#define leavelevel(ls) ((ls)->L->nCcalls--) 337323530Savg 338323530Savg 339323530Savgstatic void closegoto (LexState *ls, int g, Labeldesc *label) { 340323530Savg int i; 341323530Savg FuncState *fs = ls->fs; 342323530Savg Labellist *gl = &ls->dyd->gt; 343323530Savg Labeldesc *gt = &gl->arr[g]; 344323530Savg lua_assert(luaS_eqstr(gt->name, label->name)); 345323530Savg if (gt->nactvar < label->nactvar) { 346323530Savg TString *vname = getlocvar(fs, gt->nactvar)->varname; 347323530Savg const char *msg = luaO_pushfstring(ls->L, 348323530Savg "<goto %s> at line %d jumps into the scope of local " LUA_QS, 349323530Savg getstr(gt->name), gt->line, getstr(vname)); 350323530Savg semerror(ls, msg); 351323530Savg } 352323530Savg luaK_patchlist(fs, gt->pc, label->pc); 353323530Savg /* remove goto from pending list */ 354323530Savg for (i = g; i < gl->n - 1; i++) 355323530Savg gl->arr[i] = gl->arr[i + 1]; 356323530Savg gl->n--; 357323530Savg} 358323530Savg 359323530Savg 360323530Savg/* 361323530Savg** try to close a goto with existing labels; this solves backward jumps 362323530Savg*/ 363323530Savgstatic int findlabel (LexState *ls, int g) { 364323530Savg int i; 365323530Savg BlockCnt *bl = ls->fs->bl; 366323530Savg Dyndata *dyd = ls->dyd; 367323530Savg Labeldesc *gt = &dyd->gt.arr[g]; 368323530Savg /* check labels in current block for a match */ 369323530Savg for (i = bl->firstlabel; i < dyd->label.n; i++) { 370323530Savg Labeldesc *lb = &dyd->label.arr[i]; 371323530Savg if (luaS_eqstr(lb->name, gt->name)) { /* correct label? */ 372323530Savg if (gt->nactvar > lb->nactvar && 373323530Savg (bl->upval || dyd->label.n > bl->firstlabel)) 374323530Savg luaK_patchclose(ls->fs, gt->pc, lb->nactvar); 375323530Savg closegoto(ls, g, lb); /* close it */ 376323530Savg return 1; 377323530Savg } 378323530Savg } 379323530Savg return 0; /* label not found; cannot close goto */ 380323530Savg} 381323530Savg 382323530Savg 383323530Savgstatic int newlabelentry (LexState *ls, Labellist *l, TString *name, 384323530Savg int line, int pc) { 385323530Savg int n = l->n; 386323530Savg luaM_growvector(ls->L, l->arr, n, l->size, 387323530Savg Labeldesc, SHRT_MAX, "labels/gotos"); 388323530Savg l->arr[n].name = name; 389323530Savg l->arr[n].line = line; 390323530Savg l->arr[n].nactvar = ls->fs->nactvar; 391323530Savg l->arr[n].pc = pc; 392323530Savg l->n++; 393323530Savg return n; 394323530Savg} 395323530Savg 396323530Savg 397323530Savg/* 398323530Savg** check whether new label 'lb' matches any pending gotos in current 399323530Savg** block; solves forward jumps 400323530Savg*/ 401323530Savgstatic void findgotos (LexState *ls, Labeldesc *lb) { 402323530Savg Labellist *gl = &ls->dyd->gt; 403323530Savg int i = ls->fs->bl->firstgoto; 404323530Savg while (i < gl->n) { 405323530Savg if (luaS_eqstr(gl->arr[i].name, lb->name)) 406323530Savg closegoto(ls, i, lb); 407323530Savg else 408323530Savg i++; 409323530Savg } 410323530Savg} 411323530Savg 412323530Savg 413323530Savg/* 414323530Savg** "export" pending gotos to outer level, to check them against 415323530Savg** outer labels; if the block being exited has upvalues, and 416323530Savg** the goto exits the scope of any variable (which can be the 417323530Savg** upvalue), close those variables being exited. 418323530Savg*/ 419323530Savgstatic void movegotosout (FuncState *fs, BlockCnt *bl) { 420323530Savg int i = bl->firstgoto; 421323530Savg Labellist *gl = &fs->ls->dyd->gt; 422323530Savg /* correct pending gotos to current block and try to close it 423323530Savg with visible labels */ 424323530Savg while (i < gl->n) { 425323530Savg Labeldesc *gt = &gl->arr[i]; 426323530Savg if (gt->nactvar > bl->nactvar) { 427323530Savg if (bl->upval) 428323530Savg luaK_patchclose(fs, gt->pc, bl->nactvar); 429323530Savg gt->nactvar = bl->nactvar; 430323530Savg } 431323530Savg if (!findlabel(fs->ls, i)) 432323530Savg i++; /* move to next one */ 433323530Savg } 434323530Savg} 435323530Savg 436323530Savg 437323530Savgstatic void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) { 438323530Savg bl->isloop = isloop; 439323530Savg bl->nactvar = fs->nactvar; 440323530Savg bl->firstlabel = fs->ls->dyd->label.n; 441323530Savg bl->firstgoto = fs->ls->dyd->gt.n; 442323530Savg bl->upval = 0; 443323530Savg bl->previous = fs->bl; 444323530Savg fs->bl = bl; 445323530Savg lua_assert(fs->freereg == fs->nactvar); 446323530Savg} 447323530Savg 448323530Savg 449323530Savg/* 450323530Savg** create a label named "break" to resolve break statements 451323530Savg*/ 452323530Savgstatic void breaklabel (LexState *ls) { 453323530Savg TString *n = luaS_new(ls->L, "break"); 454323530Savg int l = newlabelentry(ls, &ls->dyd->label, n, 0, ls->fs->pc); 455323530Savg findgotos(ls, &ls->dyd->label.arr[l]); 456323530Savg} 457323530Savg 458323530Savg/* 459323530Savg** generates an error for an undefined 'goto'; choose appropriate 460323530Savg** message when label name is a reserved word (which can only be 'break') 461323530Savg*/ 462323530Savgstatic l_noret undefgoto (LexState *ls, Labeldesc *gt) { 463323530Savg const char *msg = isreserved(gt->name) 464323530Savg ? "<%s> at line %d not inside a loop" 465323530Savg : "no visible label " LUA_QS " for <goto> at line %d"; 466323530Savg msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line); 467323530Savg semerror(ls, msg); 468323530Savg} 469323530Savg 470323530Savg 471323530Savgstatic void leaveblock (FuncState *fs) { 472323530Savg BlockCnt *bl = fs->bl; 473323530Savg LexState *ls = fs->ls; 474323530Savg if (bl->previous && bl->upval) { 475323530Savg /* create a 'jump to here' to close upvalues */ 476323530Savg int j = luaK_jump(fs); 477323530Savg luaK_patchclose(fs, j, bl->nactvar); 478323530Savg luaK_patchtohere(fs, j); 479323530Savg } 480323530Savg if (bl->isloop) 481323530Savg breaklabel(ls); /* close pending breaks */ 482323530Savg fs->bl = bl->previous; 483323530Savg removevars(fs, bl->nactvar); 484323530Savg lua_assert(bl->nactvar == fs->nactvar); 485323530Savg fs->freereg = fs->nactvar; /* free registers */ 486323530Savg ls->dyd->label.n = bl->firstlabel; /* remove local labels */ 487323530Savg if (bl->previous) /* inner block? */ 488323530Savg movegotosout(fs, bl); /* update pending gotos to outer block */ 489323530Savg else if (bl->firstgoto < ls->dyd->gt.n) /* pending gotos in outer block? */ 490323530Savg undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */ 491323530Savg} 492323530Savg 493323530Savg 494323530Savg/* 495323530Savg** adds a new prototype into list of prototypes 496323530Savg*/ 497323530Savgstatic Proto *addprototype (LexState *ls) { 498323530Savg Proto *clp; 499323530Savg lua_State *L = ls->L; 500323530Savg FuncState *fs = ls->fs; 501323530Savg Proto *f = fs->f; /* prototype of current function */ 502323530Savg if (fs->np >= f->sizep) { 503323530Savg int oldsize = f->sizep; 504323530Savg luaM_growvector(L, f->p, fs->np, f->sizep, Proto *, MAXARG_Bx, "functions"); 505323530Savg while (oldsize < f->sizep) f->p[oldsize++] = NULL; 506323530Savg } 507323530Savg f->p[fs->np++] = clp = luaF_newproto(L); 508323530Savg luaC_objbarrier(L, f, clp); 509323530Savg return clp; 510323530Savg} 511323530Savg 512323530Savg 513323530Savg/* 514323530Savg** codes instruction to create new closure in parent function. 515323530Savg** The OP_CLOSURE instruction must use the last available register, 516323530Savg** so that, if it invokes the GC, the GC knows which registers 517323530Savg** are in use at that time. 518323530Savg*/ 519323530Savgstatic void codeclosure (LexState *ls, expdesc *v) { 520323530Savg FuncState *fs = ls->fs->prev; 521323530Savg init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np - 1)); 522323530Savg luaK_exp2nextreg(fs, v); /* fix it at the last register */ 523323530Savg} 524323530Savg 525323530Savg 526323530Savgstatic void open_func (LexState *ls, FuncState *fs, BlockCnt *bl) { 527323530Savg lua_State *L = ls->L; 528323530Savg Proto *f; 529323530Savg fs->prev = ls->fs; /* linked list of funcstates */ 530323530Savg fs->ls = ls; 531323530Savg ls->fs = fs; 532323530Savg fs->pc = 0; 533323530Savg fs->lasttarget = 0; 534323530Savg fs->jpc = NO_JUMP; 535323530Savg fs->freereg = 0; 536323530Savg fs->nk = 0; 537323530Savg fs->np = 0; 538323530Savg fs->nups = 0; 539323530Savg fs->nlocvars = 0; 540323530Savg fs->nactvar = 0; 541323530Savg fs->firstlocal = ls->dyd->actvar.n; 542323530Savg fs->bl = NULL; 543323530Savg f = fs->f; 544323530Savg f->source = ls->source; 545323530Savg f->maxstacksize = 2; /* registers 0/1 are always valid */ 546323530Savg fs->h = luaH_new(L); 547323530Savg /* anchor table of constants (to avoid being collected) */ 548323530Savg sethvalue2s(L, L->top, fs->h); 549323530Savg incr_top(L); 550323530Savg enterblock(fs, bl, 0); 551323530Savg} 552323530Savg 553323530Savg 554323530Savgstatic void close_func (LexState *ls) { 555323530Savg lua_State *L = ls->L; 556323530Savg FuncState *fs = ls->fs; 557323530Savg Proto *f = fs->f; 558323530Savg luaK_ret(fs, 0, 0); /* final return */ 559323530Savg leaveblock(fs); 560323530Savg luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction); 561323530Savg f->sizecode = fs->pc; 562323530Savg luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int); 563323530Savg f->sizelineinfo = fs->pc; 564323530Savg luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue); 565323530Savg f->sizek = fs->nk; 566323530Savg luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *); 567323530Savg f->sizep = fs->np; 568323530Savg luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar); 569323530Savg f->sizelocvars = fs->nlocvars; 570323530Savg luaM_reallocvector(L, f->upvalues, f->sizeupvalues, fs->nups, Upvaldesc); 571323530Savg f->sizeupvalues = fs->nups; 572323530Savg lua_assert(fs->bl == NULL); 573323530Savg ls->fs = fs->prev; 574323530Savg /* last token read was anchored in defunct function; must re-anchor it */ 575323530Savg anchor_token(ls); 576323530Savg L->top--; /* pop table of constants */ 577323530Savg luaC_checkGC(L); 578323530Savg} 579323530Savg 580323530Savg 581323530Savg 582323530Savg/*============================================================*/ 583323530Savg/* GRAMMAR RULES */ 584323530Savg/*============================================================*/ 585323530Savg 586323530Savg 587323530Savg/* 588323530Savg** check whether current token is in the follow set of a block. 589323530Savg** 'until' closes syntactical blocks, but do not close scope, 590323530Savg** so it handled in separate. 591323530Savg*/ 592323530Savgstatic int block_follow (LexState *ls, int withuntil) { 593323530Savg switch (ls->t.token) { 594323530Savg case TK_ELSE: case TK_ELSEIF: 595323530Savg case TK_END: case TK_EOS: 596323530Savg return 1; 597323530Savg case TK_UNTIL: return withuntil; 598323530Savg default: return 0; 599323530Savg } 600323530Savg} 601323530Savg 602323530Savg 603323530Savgstatic void statlist (LexState *ls) { 604323530Savg /* statlist -> { stat [`;'] } */ 605323530Savg while (!block_follow(ls, 1)) { 606323530Savg if (ls->t.token == TK_RETURN) { 607323530Savg statement(ls); 608323530Savg return; /* 'return' must be last statement */ 609323530Savg } 610323530Savg statement(ls); 611323530Savg } 612323530Savg} 613323530Savg 614323530Savg 615323530Savgstatic void fieldsel (LexState *ls, expdesc *v) { 616323530Savg /* fieldsel -> ['.' | ':'] NAME */ 617323530Savg FuncState *fs = ls->fs; 618323530Savg expdesc key; 619323530Savg luaK_exp2anyregup(fs, v); 620323530Savg luaX_next(ls); /* skip the dot or colon */ 621323530Savg checkname(ls, &key); 622323530Savg luaK_indexed(fs, v, &key); 623323530Savg} 624323530Savg 625323530Savg 626323530Savgstatic void yindex (LexState *ls, expdesc *v) { 627323530Savg /* index -> '[' expr ']' */ 628323530Savg luaX_next(ls); /* skip the '[' */ 629323530Savg expr(ls, v); 630323530Savg luaK_exp2val(ls->fs, v); 631323530Savg checknext(ls, ']'); 632323530Savg} 633323530Savg 634323530Savg 635323530Savg/* 636323530Savg** {====================================================================== 637323530Savg** Rules for Constructors 638323530Savg** ======================================================================= 639323530Savg*/ 640323530Savg 641323530Savg 642323530Savgstruct ConsControl { 643323530Savg expdesc v; /* last list item read */ 644323530Savg expdesc *t; /* table descriptor */ 645323530Savg int nh; /* total number of `record' elements */ 646323530Savg int na; /* total number of array elements */ 647323530Savg int tostore; /* number of array elements pending to be stored */ 648323530Savg}; 649323530Savg 650323530Savg 651323530Savgstatic void recfield (LexState *ls, struct ConsControl *cc) { 652323530Savg /* recfield -> (NAME | `['exp1`]') = exp1 */ 653323530Savg FuncState *fs = ls->fs; 654323530Savg int reg = ls->fs->freereg; 655323530Savg expdesc key, val; 656323530Savg int rkkey; 657323530Savg if (ls->t.token == TK_NAME) { 658323530Savg checklimit(fs, cc->nh, MAX_INT, "items in a constructor"); 659323530Savg checkname(ls, &key); 660323530Savg } 661323530Savg else /* ls->t.token == '[' */ 662323530Savg yindex(ls, &key); 663323530Savg cc->nh++; 664323530Savg checknext(ls, '='); 665323530Savg rkkey = luaK_exp2RK(fs, &key); 666323530Savg expr(ls, &val); 667323530Savg luaK_codeABC(fs, OP_SETTABLE, cc->t->u.info, rkkey, luaK_exp2RK(fs, &val)); 668323530Savg fs->freereg = reg; /* free registers */ 669323530Savg} 670323530Savg 671323530Savg 672323530Savgstatic void closelistfield (FuncState *fs, struct ConsControl *cc) { 673323530Savg if (cc->v.k == VVOID) return; /* there is no list item */ 674323530Savg luaK_exp2nextreg(fs, &cc->v); 675323530Savg cc->v.k = VVOID; 676323530Savg if (cc->tostore == LFIELDS_PER_FLUSH) { 677323530Savg luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); /* flush */ 678323530Savg cc->tostore = 0; /* no more items pending */ 679323530Savg } 680323530Savg} 681323530Savg 682323530Savg 683323530Savgstatic void lastlistfield (FuncState *fs, struct ConsControl *cc) { 684323530Savg if (cc->tostore == 0) return; 685323530Savg if (hasmultret(cc->v.k)) { 686323530Savg luaK_setmultret(fs, &cc->v); 687323530Savg luaK_setlist(fs, cc->t->u.info, cc->na, LUA_MULTRET); 688323530Savg cc->na--; /* do not count last expression (unknown number of elements) */ 689323530Savg } 690323530Savg else { 691323530Savg if (cc->v.k != VVOID) 692323530Savg luaK_exp2nextreg(fs, &cc->v); 693323530Savg luaK_setlist(fs, cc->t->u.info, cc->na, cc->tostore); 694323530Savg } 695323530Savg} 696323530Savg 697323530Savg 698323530Savgstatic void listfield (LexState *ls, struct ConsControl *cc) { 699323530Savg /* listfield -> exp */ 700323530Savg expr(ls, &cc->v); 701323530Savg checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor"); 702323530Savg cc->na++; 703323530Savg cc->tostore++; 704323530Savg} 705323530Savg 706323530Savg 707323530Savgstatic void field (LexState *ls, struct ConsControl *cc) { 708323530Savg /* field -> listfield | recfield */ 709323530Savg switch(ls->t.token) { 710323530Savg case TK_NAME: { /* may be 'listfield' or 'recfield' */ 711323530Savg if (luaX_lookahead(ls) != '=') /* expression? */ 712323530Savg listfield(ls, cc); 713323530Savg else 714323530Savg recfield(ls, cc); 715323530Savg break; 716323530Savg } 717323530Savg case '[': { 718323530Savg recfield(ls, cc); 719323530Savg break; 720323530Savg } 721323530Savg default: { 722323530Savg listfield(ls, cc); 723323530Savg break; 724323530Savg } 725323530Savg } 726323530Savg} 727323530Savg 728323530Savg 729323530Savgstatic void constructor (LexState *ls, expdesc *t) { 730323530Savg /* constructor -> '{' [ field { sep field } [sep] ] '}' 731323530Savg sep -> ',' | ';' */ 732323530Savg FuncState *fs = ls->fs; 733323530Savg int line = ls->linenumber; 734323530Savg int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0); 735323530Savg struct ConsControl cc; 736323530Savg cc.na = cc.nh = cc.tostore = 0; 737323530Savg cc.t = t; 738323530Savg init_exp(t, VRELOCABLE, pc); 739323530Savg init_exp(&cc.v, VVOID, 0); /* no value (yet) */ 740323530Savg luaK_exp2nextreg(ls->fs, t); /* fix it at stack top */ 741323530Savg checknext(ls, '{'); 742323530Savg do { 743323530Savg lua_assert(cc.v.k == VVOID || cc.tostore > 0); 744323530Savg if (ls->t.token == '}') break; 745323530Savg closelistfield(fs, &cc); 746323530Savg field(ls, &cc); 747323530Savg } while (testnext(ls, ',') || testnext(ls, ';')); 748323530Savg check_match(ls, '}', '{', line); 749323530Savg lastlistfield(fs, &cc); 750323530Savg SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */ 751323530Savg SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh)); /* set initial table size */ 752323530Savg} 753323530Savg 754323530Savg/* }====================================================================== */ 755323530Savg 756323530Savg 757323530Savg 758323530Savgstatic void parlist (LexState *ls) { 759323530Savg /* parlist -> [ param { `,' param } ] */ 760323530Savg FuncState *fs = ls->fs; 761323530Savg Proto *f = fs->f; 762323530Savg int nparams = 0; 763323530Savg f->is_vararg = 0; 764323530Savg if (ls->t.token != ')') { /* is `parlist' not empty? */ 765323530Savg do { 766323530Savg switch (ls->t.token) { 767323530Savg case TK_NAME: { /* param -> NAME */ 768323530Savg new_localvar(ls, str_checkname(ls)); 769323530Savg nparams++; 770323530Savg break; 771323530Savg } 772323530Savg case TK_DOTS: { /* param -> `...' */ 773323530Savg luaX_next(ls); 774323530Savg f->is_vararg = 1; 775323530Savg break; 776323530Savg } 777323530Savg default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected"); 778323530Savg } 779323530Savg } while (!f->is_vararg && testnext(ls, ',')); 780323530Savg } 781323530Savg adjustlocalvars(ls, nparams); 782323530Savg f->numparams = cast_byte(fs->nactvar); 783323530Savg luaK_reserveregs(fs, fs->nactvar); /* reserve register for parameters */ 784323530Savg} 785323530Savg 786323530Savg 787323530Savgstatic void body (LexState *ls, expdesc *e, int ismethod, int line) { 788323530Savg /* body -> `(' parlist `)' block END */ 789323530Savg FuncState new_fs; 790323530Savg BlockCnt bl; 791323530Savg new_fs.f = addprototype(ls); 792323530Savg new_fs.f->linedefined = line; 793323530Savg open_func(ls, &new_fs, &bl); 794323530Savg checknext(ls, '('); 795323530Savg if (ismethod) { 796323530Savg new_localvarliteral(ls, "self"); /* create 'self' parameter */ 797323530Savg adjustlocalvars(ls, 1); 798323530Savg } 799323530Savg parlist(ls); 800323530Savg checknext(ls, ')'); 801323530Savg statlist(ls); 802323530Savg new_fs.f->lastlinedefined = ls->linenumber; 803323530Savg check_match(ls, TK_END, TK_FUNCTION, line); 804323530Savg codeclosure(ls, e); 805323530Savg close_func(ls); 806323530Savg} 807323530Savg 808323530Savg 809323530Savgstatic int explist (LexState *ls, expdesc *v) { 810323530Savg /* explist -> expr { `,' expr } */ 811323530Savg int n = 1; /* at least one expression */ 812323530Savg expr(ls, v); 813323530Savg while (testnext(ls, ',')) { 814323530Savg luaK_exp2nextreg(ls->fs, v); 815323530Savg expr(ls, v); 816323530Savg n++; 817323530Savg } 818323530Savg return n; 819323530Savg} 820323530Savg 821323530Savg 822323530Savgstatic void funcargs (LexState *ls, expdesc *f, int line) { 823323530Savg FuncState *fs = ls->fs; 824323530Savg expdesc args; 825323530Savg int base, nparams; 826323530Savg switch (ls->t.token) { 827323530Savg case '(': { /* funcargs -> `(' [ explist ] `)' */ 828323530Savg luaX_next(ls); 829323530Savg if (ls->t.token == ')') /* arg list is empty? */ 830323530Savg args.k = VVOID; 831323530Savg else { 832323530Savg explist(ls, &args); 833323530Savg luaK_setmultret(fs, &args); 834323530Savg } 835323530Savg check_match(ls, ')', '(', line); 836323530Savg break; 837323530Savg } 838323530Savg case '{': { /* funcargs -> constructor */ 839323530Savg constructor(ls, &args); 840323530Savg break; 841323530Savg } 842323530Savg case TK_STRING: { /* funcargs -> STRING */ 843323530Savg codestring(ls, &args, ls->t.seminfo.ts); 844323530Savg luaX_next(ls); /* must use `seminfo' before `next' */ 845323530Savg break; 846323530Savg } 847323530Savg default: { 848323530Savg luaX_syntaxerror(ls, "function arguments expected"); 849323530Savg } 850323530Savg } 851323530Savg lua_assert(f->k == VNONRELOC); 852323530Savg base = f->u.info; /* base register for call */ 853323530Savg if (hasmultret(args.k)) 854323530Savg nparams = LUA_MULTRET; /* open call */ 855323530Savg else { 856323530Savg if (args.k != VVOID) 857323530Savg luaK_exp2nextreg(fs, &args); /* close last argument */ 858323530Savg nparams = fs->freereg - (base+1); 859323530Savg } 860323530Savg init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2)); 861323530Savg luaK_fixline(fs, line); 862323530Savg fs->freereg = base+1; /* call remove function and arguments and leaves 863323530Savg (unless changed) one result */ 864323530Savg} 865323530Savg 866323530Savg 867323530Savg 868323530Savg 869323530Savg/* 870323530Savg** {====================================================================== 871323530Savg** Expression parsing 872323530Savg** ======================================================================= 873323530Savg*/ 874323530Savg 875323530Savg 876323530Savgstatic void primaryexp (LexState *ls, expdesc *v) { 877323530Savg /* primaryexp -> NAME | '(' expr ')' */ 878323530Savg switch (ls->t.token) { 879323530Savg case '(': { 880323530Savg int line = ls->linenumber; 881323530Savg luaX_next(ls); 882323530Savg expr(ls, v); 883323530Savg check_match(ls, ')', '(', line); 884323530Savg luaK_dischargevars(ls->fs, v); 885323530Savg return; 886323530Savg } 887323530Savg case TK_NAME: { 888323530Savg singlevar(ls, v); 889323530Savg return; 890323530Savg } 891323530Savg default: { 892323530Savg luaX_syntaxerror(ls, "unexpected symbol"); 893323530Savg } 894323530Savg } 895323530Savg} 896323530Savg 897323530Savg 898323530Savgstatic void suffixedexp (LexState *ls, expdesc *v) { 899323530Savg /* suffixedexp -> 900323530Savg primaryexp { '.' NAME | '[' exp ']' | ':' NAME funcargs | funcargs } */ 901323530Savg FuncState *fs = ls->fs; 902323530Savg int line = ls->linenumber; 903323530Savg primaryexp(ls, v); 904323530Savg for (;;) { 905323530Savg switch (ls->t.token) { 906323530Savg case '.': { /* fieldsel */ 907323530Savg fieldsel(ls, v); 908323530Savg break; 909323530Savg } 910323530Savg case '[': { /* `[' exp1 `]' */ 911323530Savg expdesc key; 912323530Savg luaK_exp2anyregup(fs, v); 913323530Savg yindex(ls, &key); 914323530Savg luaK_indexed(fs, v, &key); 915323530Savg break; 916323530Savg } 917323530Savg case ':': { /* `:' NAME funcargs */ 918323530Savg expdesc key; 919323530Savg luaX_next(ls); 920323530Savg checkname(ls, &key); 921323530Savg luaK_self(fs, v, &key); 922323530Savg funcargs(ls, v, line); 923323530Savg break; 924323530Savg } 925323530Savg case '(': case TK_STRING: case '{': { /* funcargs */ 926323530Savg luaK_exp2nextreg(fs, v); 927323530Savg funcargs(ls, v, line); 928323530Savg break; 929323530Savg } 930323530Savg default: return; 931323530Savg } 932323530Savg } 933323530Savg} 934323530Savg 935323530Savg 936323530Savgstatic void simpleexp (LexState *ls, expdesc *v) { 937323530Savg /* simpleexp -> NUMBER | STRING | NIL | TRUE | FALSE | ... | 938323530Savg constructor | FUNCTION body | suffixedexp */ 939323530Savg switch (ls->t.token) { 940323530Savg case TK_NUMBER: { 941323530Savg init_exp(v, VKNUM, 0); 942323530Savg v->u.nval = ls->t.seminfo.r; 943323530Savg break; 944323530Savg } 945323530Savg case TK_STRING: { 946323530Savg codestring(ls, v, ls->t.seminfo.ts); 947323530Savg break; 948323530Savg } 949323530Savg case TK_NIL: { 950323530Savg init_exp(v, VNIL, 0); 951323530Savg break; 952323530Savg } 953323530Savg case TK_TRUE: { 954323530Savg init_exp(v, VTRUE, 0); 955323530Savg break; 956323530Savg } 957323530Savg case TK_FALSE: { 958323530Savg init_exp(v, VFALSE, 0); 959323530Savg break; 960323530Savg } 961323530Savg case TK_DOTS: { /* vararg */ 962323530Savg FuncState *fs = ls->fs; 963323530Savg check_condition(ls, fs->f->is_vararg, 964323530Savg "cannot use " LUA_QL("...") " outside a vararg function"); 965323530Savg init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0)); 966323530Savg break; 967323530Savg } 968323530Savg case '{': { /* constructor */ 969323530Savg constructor(ls, v); 970323530Savg return; 971323530Savg } 972323530Savg case TK_FUNCTION: { 973323530Savg luaX_next(ls); 974323530Savg body(ls, v, 0, ls->linenumber); 975323530Savg return; 976323530Savg } 977323530Savg default: { 978323530Savg suffixedexp(ls, v); 979323530Savg return; 980323530Savg } 981323530Savg } 982323530Savg luaX_next(ls); 983323530Savg} 984323530Savg 985323530Savg 986323530Savgstatic UnOpr getunopr (int op) { 987323530Savg switch (op) { 988323530Savg case TK_NOT: return OPR_NOT; 989323530Savg case '-': return OPR_MINUS; 990323530Savg case '#': return OPR_LEN; 991323530Savg default: return OPR_NOUNOPR; 992323530Savg } 993323530Savg} 994323530Savg 995323530Savg 996323530Savgstatic BinOpr getbinopr (int op) { 997323530Savg switch (op) { 998323530Savg case '+': return OPR_ADD; 999323530Savg case '-': return OPR_SUB; 1000323530Savg case '*': return OPR_MUL; 1001323530Savg case '/': return OPR_DIV; 1002323530Savg case '%': return OPR_MOD; 1003323530Savg case '^': return OPR_POW; 1004323530Savg case TK_CONCAT: return OPR_CONCAT; 1005323530Savg case TK_NE: return OPR_NE; 1006323530Savg case TK_EQ: return OPR_EQ; 1007323530Savg case '<': return OPR_LT; 1008323530Savg case TK_LE: return OPR_LE; 1009323530Savg case '>': return OPR_GT; 1010323530Savg case TK_GE: return OPR_GE; 1011323530Savg case TK_AND: return OPR_AND; 1012323530Savg case TK_OR: return OPR_OR; 1013323530Savg default: return OPR_NOBINOPR; 1014323530Savg } 1015323530Savg} 1016323530Savg 1017323530Savg 1018323530Savgstatic const struct { 1019323530Savg lu_byte left; /* left priority for each binary operator */ 1020323530Savg lu_byte right; /* right priority */ 1021323530Savg} priority[] = { /* ORDER OPR */ 1022323530Savg {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7}, /* `+' `-' `*' `/' `%' */ 1023323530Savg {10, 9}, {5, 4}, /* ^, .. (right associative) */ 1024323530Savg {3, 3}, {3, 3}, {3, 3}, /* ==, <, <= */ 1025323530Savg {3, 3}, {3, 3}, {3, 3}, /* ~=, >, >= */ 1026323530Savg {2, 2}, {1, 1} /* and, or */ 1027323530Savg}; 1028323530Savg 1029323530Savg#define UNARY_PRIORITY 8 /* priority for unary operators */ 1030323530Savg 1031323530Savg 1032323530Savg/* 1033323530Savg** subexpr -> (simpleexp | unop subexpr) { binop subexpr } 1034323530Savg** where `binop' is any binary operator with a priority higher than `limit' 1035323530Savg*/ 1036323530Savgstatic BinOpr subexpr (LexState *ls, expdesc *v, int limit) { 1037323530Savg BinOpr op; 1038323530Savg UnOpr uop; 1039323530Savg enterlevel(ls); 1040323530Savg uop = getunopr(ls->t.token); 1041323530Savg if (uop != OPR_NOUNOPR) { 1042323530Savg int line = ls->linenumber; 1043323530Savg luaX_next(ls); 1044323530Savg subexpr(ls, v, UNARY_PRIORITY); 1045323530Savg luaK_prefix(ls->fs, uop, v, line); 1046323530Savg } 1047323530Savg else simpleexp(ls, v); 1048323530Savg /* expand while operators have priorities higher than `limit' */ 1049323530Savg op = getbinopr(ls->t.token); 1050323530Savg while (op != OPR_NOBINOPR && priority[op].left > limit) { 1051323530Savg expdesc v2; 1052323530Savg BinOpr nextop; 1053323530Savg int line = ls->linenumber; 1054323530Savg luaX_next(ls); 1055323530Savg luaK_infix(ls->fs, op, v); 1056323530Savg /* read sub-expression with higher priority */ 1057323530Savg nextop = subexpr(ls, &v2, priority[op].right); 1058323530Savg luaK_posfix(ls->fs, op, v, &v2, line); 1059323530Savg op = nextop; 1060323530Savg } 1061323530Savg leavelevel(ls); 1062323530Savg return op; /* return first untreated operator */ 1063323530Savg} 1064323530Savg 1065323530Savg 1066323530Savgstatic void expr (LexState *ls, expdesc *v) { 1067323530Savg subexpr(ls, v, 0); 1068323530Savg} 1069323530Savg 1070323530Savg/* }==================================================================== */ 1071323530Savg 1072323530Savg 1073323530Savg 1074323530Savg/* 1075323530Savg** {====================================================================== 1076323530Savg** Rules for Statements 1077323530Savg** ======================================================================= 1078323530Savg*/ 1079323530Savg 1080323530Savg 1081323530Savgstatic void block (LexState *ls) { 1082323530Savg /* block -> statlist */ 1083323530Savg FuncState *fs = ls->fs; 1084323530Savg BlockCnt bl; 1085323530Savg enterblock(fs, &bl, 0); 1086323530Savg statlist(ls); 1087323530Savg leaveblock(fs); 1088323530Savg} 1089323530Savg 1090323530Savg 1091323530Savg/* 1092323530Savg** structure to chain all variables in the left-hand side of an 1093323530Savg** assignment 1094323530Savg*/ 1095323530Savgstruct LHS_assign { 1096323530Savg struct LHS_assign *prev; 1097323530Savg expdesc v; /* variable (global, local, upvalue, or indexed) */ 1098323530Savg}; 1099323530Savg 1100323530Savg 1101323530Savg/* 1102323530Savg** check whether, in an assignment to an upvalue/local variable, the 1103323530Savg** upvalue/local variable is begin used in a previous assignment to a 1104323530Savg** table. If so, save original upvalue/local value in a safe place and 1105323530Savg** use this safe copy in the previous assignment. 1106323530Savg*/ 1107323530Savgstatic void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) { 1108323530Savg FuncState *fs = ls->fs; 1109323530Savg int extra = fs->freereg; /* eventual position to save local variable */ 1110323530Savg int conflict = 0; 1111323530Savg for (; lh; lh = lh->prev) { /* check all previous assignments */ 1112323530Savg if (lh->v.k == VINDEXED) { /* assigning to a table? */ 1113323530Savg /* table is the upvalue/local being assigned now? */ 1114323530Savg if (lh->v.u.ind.vt == v->k && lh->v.u.ind.t == v->u.info) { 1115323530Savg conflict = 1; 1116323530Savg lh->v.u.ind.vt = VLOCAL; 1117323530Savg lh->v.u.ind.t = extra; /* previous assignment will use safe copy */ 1118323530Savg } 1119323530Savg /* index is the local being assigned? (index cannot be upvalue) */ 1120323530Savg if (v->k == VLOCAL && lh->v.u.ind.idx == v->u.info) { 1121323530Savg conflict = 1; 1122323530Savg lh->v.u.ind.idx = extra; /* previous assignment will use safe copy */ 1123323530Savg } 1124323530Savg } 1125323530Savg } 1126323530Savg if (conflict) { 1127323530Savg /* copy upvalue/local value to a temporary (in position 'extra') */ 1128323530Savg OpCode op = (v->k == VLOCAL) ? OP_MOVE : OP_GETUPVAL; 1129323530Savg luaK_codeABC(fs, op, extra, v->u.info, 0); 1130323530Savg luaK_reserveregs(fs, 1); 1131323530Savg } 1132323530Savg} 1133323530Savg 1134323530Savg 1135323530Savgstatic void assignment (LexState *ls, struct LHS_assign *lh, int nvars) { 1136323530Savg expdesc e; 1137323530Savg check_condition(ls, vkisvar(lh->v.k), "syntax error"); 1138323530Savg if (testnext(ls, ',')) { /* assignment -> ',' suffixedexp assignment */ 1139323530Savg struct LHS_assign nv; 1140323530Savg nv.prev = lh; 1141323530Savg suffixedexp(ls, &nv.v); 1142323530Savg if (nv.v.k != VINDEXED) 1143323530Savg check_conflict(ls, lh, &nv.v); 1144323530Savg checklimit(ls->fs, nvars + ls->L->nCcalls, LUAI_MAXCCALLS, 1145323530Savg "C levels"); 1146323530Savg assignment(ls, &nv, nvars+1); 1147323530Savg } 1148323530Savg else { /* assignment -> `=' explist */ 1149323530Savg int nexps; 1150323530Savg checknext(ls, '='); 1151323530Savg nexps = explist(ls, &e); 1152323530Savg if (nexps != nvars) { 1153323530Savg adjust_assign(ls, nvars, nexps, &e); 1154323530Savg if (nexps > nvars) 1155323530Savg ls->fs->freereg -= nexps - nvars; /* remove extra values */ 1156323530Savg } 1157323530Savg else { 1158323530Savg luaK_setoneret(ls->fs, &e); /* close last expression */ 1159323530Savg luaK_storevar(ls->fs, &lh->v, &e); 1160323530Savg return; /* avoid default */ 1161323530Savg } 1162323530Savg } 1163323530Savg init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */ 1164323530Savg luaK_storevar(ls->fs, &lh->v, &e); 1165323530Savg} 1166323530Savg 1167323530Savg 1168323530Savgstatic int cond (LexState *ls) { 1169323530Savg /* cond -> exp */ 1170323530Savg expdesc v; 1171323530Savg expr(ls, &v); /* read condition */ 1172323530Savg if (v.k == VNIL) v.k = VFALSE; /* `falses' are all equal here */ 1173323530Savg luaK_goiftrue(ls->fs, &v); 1174323530Savg return v.f; 1175323530Savg} 1176323530Savg 1177323530Savg 1178323530Savgstatic void gotostat (LexState *ls, int pc) { 1179323530Savg int line = ls->linenumber; 1180323530Savg TString *label; 1181323530Savg int g; 1182323530Savg if (testnext(ls, TK_GOTO)) 1183323530Savg label = str_checkname(ls); 1184323530Savg else { 1185323530Savg luaX_next(ls); /* skip break */ 1186323530Savg label = luaS_new(ls->L, "break"); 1187323530Savg } 1188323530Savg g = newlabelentry(ls, &ls->dyd->gt, label, line, pc); 1189323530Savg findlabel(ls, g); /* close it if label already defined */ 1190323530Savg} 1191323530Savg 1192323530Savg 1193323530Savg/* check for repeated labels on the same block */ 1194323530Savgstatic void checkrepeated (FuncState *fs, Labellist *ll, TString *label) { 1195323530Savg int i; 1196323530Savg for (i = fs->bl->firstlabel; i < ll->n; i++) { 1197323530Savg if (luaS_eqstr(label, ll->arr[i].name)) { 1198323530Savg const char *msg = luaO_pushfstring(fs->ls->L, 1199323530Savg "label " LUA_QS " already defined on line %d", 1200323530Savg getstr(label), ll->arr[i].line); 1201323530Savg semerror(fs->ls, msg); 1202323530Savg } 1203323530Savg } 1204323530Savg} 1205323530Savg 1206323530Savg 1207323530Savg/* skip no-op statements */ 1208323530Savgstatic void skipnoopstat (LexState *ls) { 1209323530Savg while (ls->t.token == ';' || ls->t.token == TK_DBCOLON) 1210323530Savg statement(ls); 1211323530Savg} 1212323530Savg 1213323530Savg 1214323530Savgstatic void labelstat (LexState *ls, TString *label, int line) { 1215323530Savg /* label -> '::' NAME '::' */ 1216323530Savg FuncState *fs = ls->fs; 1217323530Savg Labellist *ll = &ls->dyd->label; 1218323530Savg int l; /* index of new label being created */ 1219323530Savg checkrepeated(fs, ll, label); /* check for repeated labels */ 1220323530Savg checknext(ls, TK_DBCOLON); /* skip double colon */ 1221323530Savg /* create new entry for this label */ 1222323530Savg l = newlabelentry(ls, ll, label, line, fs->pc); 1223323530Savg skipnoopstat(ls); /* skip other no-op statements */ 1224323530Savg if (block_follow(ls, 0)) { /* label is last no-op statement in the block? */ 1225323530Savg /* assume that locals are already out of scope */ 1226323530Savg ll->arr[l].nactvar = fs->bl->nactvar; 1227323530Savg } 1228323530Savg findgotos(ls, &ll->arr[l]); 1229323530Savg} 1230323530Savg 1231323530Savg 1232323530Savgstatic void whilestat (LexState *ls, int line) { 1233323530Savg /* whilestat -> WHILE cond DO block END */ 1234323530Savg FuncState *fs = ls->fs; 1235323530Savg int whileinit; 1236323530Savg int condexit; 1237323530Savg BlockCnt bl; 1238323530Savg luaX_next(ls); /* skip WHILE */ 1239323530Savg whileinit = luaK_getlabel(fs); 1240323530Savg condexit = cond(ls); 1241323530Savg enterblock(fs, &bl, 1); 1242323530Savg checknext(ls, TK_DO); 1243323530Savg block(ls); 1244323530Savg luaK_jumpto(fs, whileinit); 1245323530Savg check_match(ls, TK_END, TK_WHILE, line); 1246323530Savg leaveblock(fs); 1247323530Savg luaK_patchtohere(fs, condexit); /* false conditions finish the loop */ 1248323530Savg} 1249323530Savg 1250323530Savg 1251323530Savgstatic void repeatstat (LexState *ls, int line) { 1252323530Savg /* repeatstat -> REPEAT block UNTIL cond */ 1253323530Savg int condexit; 1254323530Savg FuncState *fs = ls->fs; 1255323530Savg int repeat_init = luaK_getlabel(fs); 1256323530Savg BlockCnt bl1, bl2; 1257323530Savg enterblock(fs, &bl1, 1); /* loop block */ 1258323530Savg enterblock(fs, &bl2, 0); /* scope block */ 1259323530Savg luaX_next(ls); /* skip REPEAT */ 1260323530Savg statlist(ls); 1261323530Savg check_match(ls, TK_UNTIL, TK_REPEAT, line); 1262323530Savg condexit = cond(ls); /* read condition (inside scope block) */ 1263323530Savg if (bl2.upval) /* upvalues? */ 1264323530Savg luaK_patchclose(fs, condexit, bl2.nactvar); 1265323530Savg leaveblock(fs); /* finish scope */ 1266323530Savg luaK_patchlist(fs, condexit, repeat_init); /* close the loop */ 1267323530Savg leaveblock(fs); /* finish loop */ 1268323530Savg} 1269323530Savg 1270323530Savg 1271323530Savgstatic int exp1 (LexState *ls) { 1272323530Savg expdesc e; 1273323530Savg int reg; 1274323530Savg expr(ls, &e); 1275323530Savg luaK_exp2nextreg(ls->fs, &e); 1276323530Savg lua_assert(e.k == VNONRELOC); 1277323530Savg reg = e.u.info; 1278323530Savg return reg; 1279323530Savg} 1280323530Savg 1281323530Savg 1282323530Savgstatic void forbody (LexState *ls, int base, int line, int nvars, int isnum) { 1283323530Savg /* forbody -> DO block */ 1284323530Savg BlockCnt bl; 1285323530Savg FuncState *fs = ls->fs; 1286323530Savg int prep, endfor; 1287323530Savg adjustlocalvars(ls, 3); /* control variables */ 1288323530Savg checknext(ls, TK_DO); 1289323530Savg prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs); 1290323530Savg enterblock(fs, &bl, 0); /* scope for declared variables */ 1291323530Savg adjustlocalvars(ls, nvars); 1292323530Savg luaK_reserveregs(fs, nvars); 1293323530Savg block(ls); 1294323530Savg leaveblock(fs); /* end of scope for declared variables */ 1295323530Savg luaK_patchtohere(fs, prep); 1296323530Savg if (isnum) /* numeric for? */ 1297323530Savg endfor = luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP); 1298323530Savg else { /* generic for */ 1299323530Savg luaK_codeABC(fs, OP_TFORCALL, base, 0, nvars); 1300323530Savg luaK_fixline(fs, line); 1301323530Savg endfor = luaK_codeAsBx(fs, OP_TFORLOOP, base + 2, NO_JUMP); 1302323530Savg } 1303323530Savg luaK_patchlist(fs, endfor, prep + 1); 1304323530Savg luaK_fixline(fs, line); 1305323530Savg} 1306323530Savg 1307323530Savg 1308323530Savgstatic void fornum (LexState *ls, TString *varname, int line) { 1309323530Savg /* fornum -> NAME = exp1,exp1[,exp1] forbody */ 1310323530Savg FuncState *fs = ls->fs; 1311323530Savg int base = fs->freereg; 1312323530Savg new_localvarliteral(ls, "(for index)"); 1313323530Savg new_localvarliteral(ls, "(for limit)"); 1314323530Savg new_localvarliteral(ls, "(for step)"); 1315323530Savg new_localvar(ls, varname); 1316323530Savg checknext(ls, '='); 1317323530Savg exp1(ls); /* initial value */ 1318323530Savg checknext(ls, ','); 1319323530Savg exp1(ls); /* limit */ 1320323530Savg if (testnext(ls, ',')) 1321323530Savg exp1(ls); /* optional step */ 1322323530Savg else { /* default step = 1 */ 1323323530Savg luaK_codek(fs, fs->freereg, luaK_numberK(fs, 1)); 1324323530Savg luaK_reserveregs(fs, 1); 1325323530Savg } 1326323530Savg forbody(ls, base, line, 1, 1); 1327323530Savg} 1328323530Savg 1329323530Savg 1330323530Savgstatic void forlist (LexState *ls, TString *indexname) { 1331323530Savg /* forlist -> NAME {,NAME} IN explist forbody */ 1332323530Savg FuncState *fs = ls->fs; 1333323530Savg expdesc e; 1334323530Savg int nvars = 4; /* gen, state, control, plus at least one declared var */ 1335323530Savg int line; 1336323530Savg int base = fs->freereg; 1337323530Savg /* create control variables */ 1338323530Savg new_localvarliteral(ls, "(for generator)"); 1339323530Savg new_localvarliteral(ls, "(for state)"); 1340323530Savg new_localvarliteral(ls, "(for control)"); 1341323530Savg /* create declared variables */ 1342323530Savg new_localvar(ls, indexname); 1343323530Savg while (testnext(ls, ',')) { 1344323530Savg new_localvar(ls, str_checkname(ls)); 1345323530Savg nvars++; 1346323530Savg } 1347323530Savg checknext(ls, TK_IN); 1348323530Savg line = ls->linenumber; 1349323530Savg adjust_assign(ls, 3, explist(ls, &e), &e); 1350323530Savg luaK_checkstack(fs, 3); /* extra space to call generator */ 1351323530Savg forbody(ls, base, line, nvars - 3, 0); 1352323530Savg} 1353323530Savg 1354323530Savg 1355323530Savgstatic void forstat (LexState *ls, int line) { 1356323530Savg /* forstat -> FOR (fornum | forlist) END */ 1357323530Savg FuncState *fs = ls->fs; 1358323530Savg TString *varname; 1359323530Savg BlockCnt bl; 1360323530Savg enterblock(fs, &bl, 1); /* scope for loop and control variables */ 1361323530Savg luaX_next(ls); /* skip `for' */ 1362323530Savg varname = str_checkname(ls); /* first variable name */ 1363323530Savg switch (ls->t.token) { 1364323530Savg case '=': fornum(ls, varname, line); break; 1365323530Savg case ',': case TK_IN: forlist(ls, varname); break; 1366323530Savg default: luaX_syntaxerror(ls, LUA_QL("=") " or " LUA_QL("in") " expected"); 1367323530Savg } 1368323530Savg check_match(ls, TK_END, TK_FOR, line); 1369323530Savg leaveblock(fs); /* loop scope (`break' jumps to this point) */ 1370323530Savg} 1371323530Savg 1372323530Savg 1373323530Savgstatic void test_then_block (LexState *ls, int *escapelist) { 1374323530Savg /* test_then_block -> [IF | ELSEIF] cond THEN block */ 1375323530Savg BlockCnt bl; 1376323530Savg FuncState *fs = ls->fs; 1377323530Savg expdesc v; 1378323530Savg int jf; /* instruction to skip 'then' code (if condition is false) */ 1379323530Savg luaX_next(ls); /* skip IF or ELSEIF */ 1380323530Savg expr(ls, &v); /* read condition */ 1381323530Savg checknext(ls, TK_THEN); 1382323530Savg if (ls->t.token == TK_GOTO || ls->t.token == TK_BREAK) { 1383323530Savg luaK_goiffalse(ls->fs, &v); /* will jump to label if condition is true */ 1384323530Savg enterblock(fs, &bl, 0); /* must enter block before 'goto' */ 1385323530Savg gotostat(ls, v.t); /* handle goto/break */ 1386323530Savg skipnoopstat(ls); /* skip other no-op statements */ 1387323530Savg if (block_follow(ls, 0)) { /* 'goto' is the entire block? */ 1388323530Savg leaveblock(fs); 1389323530Savg return; /* and that is it */ 1390323530Savg } 1391323530Savg else /* must skip over 'then' part if condition is false */ 1392323530Savg jf = luaK_jump(fs); 1393323530Savg } 1394323530Savg else { /* regular case (not goto/break) */ 1395323530Savg luaK_goiftrue(ls->fs, &v); /* skip over block if condition is false */ 1396323530Savg enterblock(fs, &bl, 0); 1397323530Savg jf = v.f; 1398323530Savg } 1399323530Savg statlist(ls); /* `then' part */ 1400323530Savg leaveblock(fs); 1401323530Savg if (ls->t.token == TK_ELSE || 1402323530Savg ls->t.token == TK_ELSEIF) /* followed by 'else'/'elseif'? */ 1403323530Savg luaK_concat(fs, escapelist, luaK_jump(fs)); /* must jump over it */ 1404323530Savg luaK_patchtohere(fs, jf); 1405323530Savg} 1406323530Savg 1407323530Savg 1408323530Savgstatic void ifstat (LexState *ls, int line) { 1409323530Savg /* ifstat -> IF cond THEN block {ELSEIF cond THEN block} [ELSE block] END */ 1410323530Savg FuncState *fs = ls->fs; 1411323530Savg int escapelist = NO_JUMP; /* exit list for finished parts */ 1412323530Savg test_then_block(ls, &escapelist); /* IF cond THEN block */ 1413323530Savg while (ls->t.token == TK_ELSEIF) 1414323530Savg test_then_block(ls, &escapelist); /* ELSEIF cond THEN block */ 1415323530Savg if (testnext(ls, TK_ELSE)) 1416323530Savg block(ls); /* `else' part */ 1417323530Savg check_match(ls, TK_END, TK_IF, line); 1418323530Savg luaK_patchtohere(fs, escapelist); /* patch escape list to 'if' end */ 1419323530Savg} 1420323530Savg 1421323530Savg 1422323530Savgstatic void localfunc (LexState *ls) { 1423323530Savg expdesc b; 1424323530Savg FuncState *fs = ls->fs; 1425323530Savg new_localvar(ls, str_checkname(ls)); /* new local variable */ 1426323530Savg adjustlocalvars(ls, 1); /* enter its scope */ 1427323530Savg body(ls, &b, 0, ls->linenumber); /* function created in next register */ 1428323530Savg /* debug information will only see the variable after this point! */ 1429323530Savg getlocvar(fs, b.u.info)->startpc = fs->pc; 1430323530Savg} 1431323530Savg 1432323530Savg 1433323530Savgstatic void localstat (LexState *ls) { 1434323530Savg /* stat -> LOCAL NAME {`,' NAME} [`=' explist] */ 1435323530Savg int nvars = 0; 1436323530Savg int nexps; 1437323530Savg expdesc e; 1438323530Savg do { 1439323530Savg new_localvar(ls, str_checkname(ls)); 1440323530Savg nvars++; 1441323530Savg } while (testnext(ls, ',')); 1442323530Savg if (testnext(ls, '=')) 1443323530Savg nexps = explist(ls, &e); 1444323530Savg else { 1445323530Savg e.k = VVOID; 1446323530Savg nexps = 0; 1447323530Savg } 1448323530Savg adjust_assign(ls, nvars, nexps, &e); 1449323530Savg adjustlocalvars(ls, nvars); 1450323530Savg} 1451323530Savg 1452323530Savg 1453323530Savgstatic int funcname (LexState *ls, expdesc *v) { 1454323530Savg /* funcname -> NAME {fieldsel} [`:' NAME] */ 1455323530Savg int ismethod = 0; 1456323530Savg singlevar(ls, v); 1457323530Savg while (ls->t.token == '.') 1458323530Savg fieldsel(ls, v); 1459323530Savg if (ls->t.token == ':') { 1460323530Savg ismethod = 1; 1461323530Savg fieldsel(ls, v); 1462323530Savg } 1463323530Savg return ismethod; 1464323530Savg} 1465323530Savg 1466323530Savg 1467323530Savgstatic void funcstat (LexState *ls, int line) { 1468323530Savg /* funcstat -> FUNCTION funcname body */ 1469323530Savg int ismethod; 1470323530Savg expdesc v, b; 1471323530Savg luaX_next(ls); /* skip FUNCTION */ 1472323530Savg ismethod = funcname(ls, &v); 1473323530Savg body(ls, &b, ismethod, line); 1474323530Savg luaK_storevar(ls->fs, &v, &b); 1475323530Savg luaK_fixline(ls->fs, line); /* definition `happens' in the first line */ 1476323530Savg} 1477323530Savg 1478323530Savg 1479323530Savgstatic void exprstat (LexState *ls) { 1480323530Savg /* stat -> func | assignment */ 1481323530Savg FuncState *fs = ls->fs; 1482323530Savg struct LHS_assign v; 1483323530Savg suffixedexp(ls, &v.v); 1484323530Savg if (ls->t.token == '=' || ls->t.token == ',') { /* stat -> assignment ? */ 1485323530Savg v.prev = NULL; 1486323530Savg assignment(ls, &v, 1); 1487323530Savg } 1488323530Savg else { /* stat -> func */ 1489323530Savg check_condition(ls, v.v.k == VCALL, "syntax error"); 1490323530Savg SETARG_C(getcode(fs, &v.v), 1); /* call statement uses no results */ 1491323530Savg } 1492323530Savg} 1493323530Savg 1494323530Savg 1495323530Savgstatic void retstat (LexState *ls) { 1496323530Savg /* stat -> RETURN [explist] [';'] */ 1497323530Savg FuncState *fs = ls->fs; 1498323530Savg expdesc e; 1499323530Savg int first, nret; /* registers with returned values */ 1500323530Savg if (block_follow(ls, 1) || ls->t.token == ';') 1501323530Savg first = nret = 0; /* return no values */ 1502323530Savg else { 1503323530Savg nret = explist(ls, &e); /* optional return values */ 1504323530Savg if (hasmultret(e.k)) { 1505323530Savg luaK_setmultret(fs, &e); 1506323530Savg if (e.k == VCALL && nret == 1) { /* tail call? */ 1507323530Savg SET_OPCODE(getcode(fs,&e), OP_TAILCALL); 1508323530Savg lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar); 1509323530Savg } 1510323530Savg first = fs->nactvar; 1511323530Savg nret = LUA_MULTRET; /* return all values */ 1512323530Savg } 1513323530Savg else { 1514323530Savg if (nret == 1) /* only one single value? */ 1515323530Savg first = luaK_exp2anyreg(fs, &e); 1516323530Savg else { 1517323530Savg luaK_exp2nextreg(fs, &e); /* values must go to the `stack' */ 1518323530Savg first = fs->nactvar; /* return all `active' values */ 1519323530Savg lua_assert(nret == fs->freereg - first); 1520323530Savg } 1521323530Savg } 1522323530Savg } 1523323530Savg luaK_ret(fs, first, nret); 1524323530Savg testnext(ls, ';'); /* skip optional semicolon */ 1525323530Savg} 1526323530Savg 1527323530Savg 1528323530Savgstatic void statement (LexState *ls) { 1529323530Savg int line = ls->linenumber; /* may be needed for error messages */ 1530323530Savg enterlevel(ls); 1531323530Savg switch (ls->t.token) { 1532323530Savg case ';': { /* stat -> ';' (empty statement) */ 1533323530Savg luaX_next(ls); /* skip ';' */ 1534323530Savg break; 1535323530Savg } 1536323530Savg case TK_IF: { /* stat -> ifstat */ 1537323530Savg ifstat(ls, line); 1538323530Savg break; 1539323530Savg } 1540323530Savg case TK_WHILE: { /* stat -> whilestat */ 1541323530Savg whilestat(ls, line); 1542323530Savg break; 1543323530Savg } 1544323530Savg case TK_DO: { /* stat -> DO block END */ 1545323530Savg luaX_next(ls); /* skip DO */ 1546323530Savg block(ls); 1547323530Savg check_match(ls, TK_END, TK_DO, line); 1548323530Savg break; 1549323530Savg } 1550323530Savg case TK_FOR: { /* stat -> forstat */ 1551323530Savg forstat(ls, line); 1552323530Savg break; 1553323530Savg } 1554323530Savg case TK_REPEAT: { /* stat -> repeatstat */ 1555323530Savg repeatstat(ls, line); 1556323530Savg break; 1557323530Savg } 1558323530Savg case TK_FUNCTION: { /* stat -> funcstat */ 1559323530Savg funcstat(ls, line); 1560323530Savg break; 1561323530Savg } 1562323530Savg case TK_LOCAL: { /* stat -> localstat */ 1563323530Savg luaX_next(ls); /* skip LOCAL */ 1564323530Savg if (testnext(ls, TK_FUNCTION)) /* local function? */ 1565323530Savg localfunc(ls); 1566323530Savg else 1567323530Savg localstat(ls); 1568323530Savg break; 1569323530Savg } 1570323530Savg case TK_DBCOLON: { /* stat -> label */ 1571323530Savg luaX_next(ls); /* skip double colon */ 1572323530Savg labelstat(ls, str_checkname(ls), line); 1573323530Savg break; 1574323530Savg } 1575323530Savg case TK_RETURN: { /* stat -> retstat */ 1576323530Savg luaX_next(ls); /* skip RETURN */ 1577323530Savg retstat(ls); 1578323530Savg break; 1579323530Savg } 1580323530Savg case TK_BREAK: /* stat -> breakstat */ 1581323530Savg case TK_GOTO: { /* stat -> 'goto' NAME */ 1582323530Savg gotostat(ls, luaK_jump(ls->fs)); 1583323530Savg break; 1584323530Savg } 1585323530Savg default: { /* stat -> func | assignment */ 1586323530Savg exprstat(ls); 1587323530Savg break; 1588323530Savg } 1589323530Savg } 1590323530Savg lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg && 1591323530Savg ls->fs->freereg >= ls->fs->nactvar); 1592323530Savg ls->fs->freereg = ls->fs->nactvar; /* free registers */ 1593323530Savg leavelevel(ls); 1594323530Savg} 1595323530Savg 1596323530Savg/* }====================================================================== */ 1597323530Savg 1598323530Savg 1599323530Savg/* 1600323530Savg** compiles the main function, which is a regular vararg function with an 1601323530Savg** upvalue named LUA_ENV 1602323530Savg*/ 1603323530Savgstatic void mainfunc (LexState *ls, FuncState *fs) { 1604323530Savg BlockCnt bl; 1605323530Savg expdesc v; 1606323530Savg open_func(ls, fs, &bl); 1607323530Savg fs->f->is_vararg = 1; /* main function is always vararg */ 1608323530Savg init_exp(&v, VLOCAL, 0); /* create and... */ 1609323530Savg newupvalue(fs, ls->envn, &v); /* ...set environment upvalue */ 1610323530Savg luaX_next(ls); /* read first token */ 1611323530Savg statlist(ls); /* parse main body */ 1612323530Savg check(ls, TK_EOS); 1613323530Savg close_func(ls); 1614323530Savg} 1615323530Savg 1616323530Savg 1617323530SavgClosure *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, 1618323530Savg Dyndata *dyd, const char *name, int firstchar) { 1619323530Savg LexState lexstate; 1620323530Savg FuncState funcstate; 1621323530Savg Closure *cl = luaF_newLclosure(L, 1); /* create main closure */ 1622323530Savg /* anchor closure (to avoid being collected) */ 1623323530Savg setclLvalue(L, L->top, cl); 1624323530Savg incr_top(L); 1625323530Savg funcstate.f = cl->l.p = luaF_newproto(L); 1626323530Savg funcstate.f->source = luaS_new(L, name); /* create and anchor TString */ 1627323530Savg lexstate.buff = buff; 1628323530Savg lexstate.dyd = dyd; 1629323530Savg dyd->actvar.n = dyd->gt.n = dyd->label.n = 0; 1630323530Savg luaX_setinput(L, &lexstate, z, funcstate.f->source, firstchar); 1631323530Savg mainfunc(&lexstate, &funcstate); 1632323530Savg lua_assert(!funcstate.prev && funcstate.nups == 1 && !lexstate.fs); 1633323530Savg /* all scopes should be correctly finished */ 1634323530Savg lua_assert(dyd->actvar.n == 0 && dyd->gt.n == 0 && dyd->label.n == 0); 1635323530Savg return cl; /* it's on the stack too */ 1636323530Savg} 1637323530Savg 1638