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