Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/weapon2/src/lua/lparser.c @ 2705

Last change on this file since 2705 was 1810, checked in by rgrieder, 16 years ago

merged ceguilua branch back to trunk

  • Property svn:eol-style set to native
File size: 35.8 KB
Line 
1/*
2** $Id: lparser.c,v 2.42.1.3 2007/12/28 15:32:23 roberto Exp $
3** Lua Parser
4** See Copyright Notice in lua.h
5*/
6
7
8#include <string.h>
9
10#define lparser_c
11#define LUA_CORE
12
13#include "lua.h"
14
15#include "lcode.h"
16#include "ldebug.h"
17#include "ldo.h"
18#include "lfunc.h"
19#include "llex.h"
20#include "lmem.h"
21#include "lobject.h"
22#include "lopcodes.h"
23#include "lparser.h"
24#include "lstate.h"
25#include "lstring.h"
26#include "ltable.h"
27
28
29
30#define hasmultret(k)           ((k) == VCALL || (k) == VVARARG)
31
32#define getlocvar(fs, i)        ((fs)->f->locvars[(fs)->actvar[i]])
33
34#define luaY_checklimit(fs,v,l,m)       if ((v)>(l)) errorlimit(fs,l,m)
35
36
37/*
38** nodes for block list (list of active blocks)
39*/
40typedef struct BlockCnt {
41  struct BlockCnt *previous;  /* chain */
42  int breaklist;  /* list of jumps out of this loop */
43  lu_byte nactvar;  /* # active locals outside the breakable structure */
44  lu_byte upval;  /* true if some variable in the block is an upvalue */
45  lu_byte isbreakable;  /* true if `block' is a loop */
46} BlockCnt;
47
48
49
50/*
51** prototypes for recursive non-terminal functions
52*/
53static void chunk (LexState *ls);
54static void expr (LexState *ls, expdesc *v);
55
56
57static void anchor_token (LexState *ls) {
58  if (ls->t.token == TK_NAME || ls->t.token == TK_STRING) {
59    TString *ts = ls->t.seminfo.ts;
60    luaX_newstring(ls, getstr(ts), ts->tsv.len);
61  }
62}
63
64
65static void error_expected (LexState *ls, int token) {
66  luaX_syntaxerror(ls,
67      luaO_pushfstring(ls->L, LUA_QS " expected", luaX_token2str(ls, token)));
68}
69
70
71static void errorlimit (FuncState *fs, int limit, const char *what) {
72  const char *msg = (fs->f->linedefined == 0) ?
73    luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) :
74    luaO_pushfstring(fs->L, "function at line %d has more than %d %s",
75                            fs->f->linedefined, limit, what);
76  luaX_lexerror(fs->ls, msg, 0);
77}
78
79
80static int testnext (LexState *ls, int c) {
81  if (ls->t.token == c) {
82    luaX_next(ls);
83    return 1;
84  }
85  else return 0;
86}
87
88
89static void check (LexState *ls, int c) {
90  if (ls->t.token != c)
91    error_expected(ls, c);
92}
93
94static void checknext (LexState *ls, int c) {
95  check(ls, c);
96  luaX_next(ls);
97}
98
99
100#define check_condition(ls,c,msg)       { if (!(c)) luaX_syntaxerror(ls, msg); }
101
102
103
104static void check_match (LexState *ls, int what, int who, int where) {
105  if (!testnext(ls, what)) {
106    if (where == ls->linenumber)
107      error_expected(ls, what);
108    else {
109      luaX_syntaxerror(ls, luaO_pushfstring(ls->L,
110             LUA_QS " expected (to close " LUA_QS " at line %d)",
111              luaX_token2str(ls, what), luaX_token2str(ls, who), where));
112    }
113  }
114}
115
116
117static TString *str_checkname (LexState *ls) {
118  TString *ts;
119  check(ls, TK_NAME);
120  ts = ls->t.seminfo.ts;
121  luaX_next(ls);
122  return ts;
123}
124
125
126static void init_exp (expdesc *e, expkind k, int i) {
127  e->f = e->t = NO_JUMP;
128  e->k = k;
129  e->u.s.info = i;
130}
131
132
133static void codestring (LexState *ls, expdesc *e, TString *s) {
134  init_exp(e, VK, luaK_stringK(ls->fs, s));
135}
136
137
138static void checkname(LexState *ls, expdesc *e) {
139  codestring(ls, e, str_checkname(ls));
140}
141
142
143static int registerlocalvar (LexState *ls, TString *varname) {
144  FuncState *fs = ls->fs;
145  Proto *f = fs->f;
146  int oldsize = f->sizelocvars;
147  luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars,
148                  LocVar, SHRT_MAX, "too many local variables");
149  while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL;
150  f->locvars[fs->nlocvars].varname = varname;
151  luaC_objbarrier(ls->L, f, varname);
152  return fs->nlocvars++;
153}
154
155
156#define new_localvarliteral(ls,v,n) \
157  new_localvar(ls, luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char))-1), n)
158
159
160static void new_localvar (LexState *ls, TString *name, int n) {
161  FuncState *fs = ls->fs;
162  luaY_checklimit(fs, fs->nactvar+n+1, LUAI_MAXVARS, "local variables");
163  fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name));
164}
165
166
167static void adjustlocalvars (LexState *ls, int nvars) {
168  FuncState *fs = ls->fs;
169  fs->nactvar = cast_byte(fs->nactvar + nvars);
170  for (; nvars; nvars--) {
171    getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
172  }
173}
174
175
176static void removevars (LexState *ls, int tolevel) {
177  FuncState *fs = ls->fs;
178  while (fs->nactvar > tolevel)
179    getlocvar(fs, --fs->nactvar).endpc = fs->pc;
180}
181
182
183static int indexupvalue (FuncState *fs, TString *name, expdesc *v) {
184  int i;
185  Proto *f = fs->f;
186  int oldsize = f->sizeupvalues;
187  for (i=0; i<f->nups; i++) {
188    if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->u.s.info) {
189      lua_assert(f->upvalues[i] == name);
190      return i;
191    }
192  }
193  /* new one */
194  luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, "upvalues");
195  luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,
196                  TString *, MAX_INT, "");
197  while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL;
198  f->upvalues[f->nups] = name;
199  luaC_objbarrier(fs->L, f, name);
200  lua_assert(v->k == VLOCAL || v->k == VUPVAL);
201  fs->upvalues[f->nups].k = cast_byte(v->k);
202  fs->upvalues[f->nups].info = cast_byte(v->u.s.info);
203  return f->nups++;
204}
205
206
207static int searchvar (FuncState *fs, TString *n) {
208  int i;
209  for (i=fs->nactvar-1; i >= 0; i--) {
210    if (n == getlocvar(fs, i).varname)
211      return i;
212  }
213  return -1;  /* not found */
214}
215
216
217static void markupval (FuncState *fs, int level) {
218  BlockCnt *bl = fs->bl;
219  while (bl && bl->nactvar > level) bl = bl->previous;
220  if (bl) bl->upval = 1;
221}
222
223
224static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) {
225  if (fs == NULL) {  /* no more levels? */
226    init_exp(var, VGLOBAL, NO_REG);  /* default is global variable */
227    return VGLOBAL;
228  }
229  else {
230    int v = searchvar(fs, n);  /* look up at current level */
231    if (v >= 0) {
232      init_exp(var, VLOCAL, v);
233      if (!base)
234        markupval(fs, v);  /* local will be used as an upval */
235      return VLOCAL;
236    }
237    else {  /* not found at current level; try upper one */
238      if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL)
239        return VGLOBAL;
240      var->u.s.info = indexupvalue(fs, n, var);  /* else was LOCAL or UPVAL */
241      var->k = VUPVAL;  /* upvalue in this level */
242      return VUPVAL;
243    }
244  }
245}
246
247
248static void singlevar (LexState *ls, expdesc *var) {
249  TString *varname = str_checkname(ls);
250  FuncState *fs = ls->fs;
251  if (singlevaraux(fs, varname, var, 1) == VGLOBAL)
252    var->u.s.info = luaK_stringK(fs, varname);  /* info points to global name */
253}
254
255
256static void adjust_assign (LexState *ls, int nvars, int nexps, expdesc *e) {
257  FuncState *fs = ls->fs;
258  int extra = nvars - nexps;
259  if (hasmultret(e->k)) {
260    extra++;  /* includes call itself */
261    if (extra < 0) extra = 0;
262    luaK_setreturns(fs, e, extra);  /* last exp. provides the difference */
263    if (extra > 1) luaK_reserveregs(fs, extra-1);
264  }
265  else {
266    if (e->k != VVOID) luaK_exp2nextreg(fs, e);  /* close last expression */
267    if (extra > 0) {
268      int reg = fs->freereg;
269      luaK_reserveregs(fs, extra);
270      luaK_nil(fs, reg, extra);
271    }
272  }
273}
274
275
276static void enterlevel (LexState *ls) {
277  if (++ls->L->nCcalls > LUAI_MAXCCALLS)
278        luaX_lexerror(ls, "chunk has too many syntax levels", 0);
279}
280
281
282#define leavelevel(ls)  ((ls)->L->nCcalls--)
283
284
285static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) {
286  bl->breaklist = NO_JUMP;
287  bl->isbreakable = isbreakable;
288  bl->nactvar = fs->nactvar;
289  bl->upval = 0;
290  bl->previous = fs->bl;
291  fs->bl = bl;
292  lua_assert(fs->freereg == fs->nactvar);
293}
294
295
296static void leaveblock (FuncState *fs) {
297  BlockCnt *bl = fs->bl;
298  fs->bl = bl->previous;
299  removevars(fs->ls, bl->nactvar);
300  if (bl->upval)
301    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
302  /* a block either controls scope or breaks (never both) */
303  lua_assert(!bl->isbreakable || !bl->upval);
304  lua_assert(bl->nactvar == fs->nactvar);
305  fs->freereg = fs->nactvar;  /* free registers */
306  luaK_patchtohere(fs, bl->breaklist);
307}
308
309
310static void pushclosure (LexState *ls, FuncState *func, expdesc *v) {
311  FuncState *fs = ls->fs;
312  Proto *f = fs->f;
313  int oldsize = f->sizep;
314  int i;
315  luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *,
316                  MAXARG_Bx, "constant table overflow");
317  while (oldsize < f->sizep) f->p[oldsize++] = NULL;
318  f->p[fs->np++] = func->f;
319  luaC_objbarrier(ls->L, f, func->f);
320  init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1));
321  for (i=0; i<func->f->nups; i++) {
322    OpCode o = (func->upvalues[i].k == VLOCAL) ? OP_MOVE : OP_GETUPVAL;
323    luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0);
324  }
325}
326
327
328static void open_func (LexState *ls, FuncState *fs) {
329  lua_State *L = ls->L;
330  Proto *f = luaF_newproto(L);
331  fs->f = f;
332  fs->prev = ls->fs;  /* linked list of funcstates */
333  fs->ls = ls;
334  fs->L = L;
335  ls->fs = fs;
336  fs->pc = 0;
337  fs->lasttarget = -1;
338  fs->jpc = NO_JUMP;
339  fs->freereg = 0;
340  fs->nk = 0;
341  fs->np = 0;
342  fs->nlocvars = 0;
343  fs->nactvar = 0;
344  fs->bl = NULL;
345  f->source = ls->source;
346  f->maxstacksize = 2;  /* registers 0/1 are always valid */
347  fs->h = luaH_new(L, 0, 0);
348  /* anchor table of constants and prototype (to avoid being collected) */
349  sethvalue2s(L, L->top, fs->h);
350  incr_top(L);
351  setptvalue2s(L, L->top, f);
352  incr_top(L);
353}
354
355
356static void close_func (LexState *ls) {
357  lua_State *L = ls->L;
358  FuncState *fs = ls->fs;
359  Proto *f = fs->f;
360  removevars(ls, 0);
361  luaK_ret(fs, 0, 0);  /* final return */
362  luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction);
363  f->sizecode = fs->pc;
364  luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int);
365  f->sizelineinfo = fs->pc;
366  luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue);
367  f->sizek = fs->nk;
368  luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *);
369  f->sizep = fs->np;
370  luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar);
371  f->sizelocvars = fs->nlocvars;
372  luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *);
373  f->sizeupvalues = f->nups;
374  lua_assert(luaG_checkcode(f));
375  lua_assert(fs->bl == NULL);
376  ls->fs = fs->prev;
377  L->top -= 2;  /* remove table and prototype from the stack */
378  /* last token read was anchored in defunct function; must reanchor it */
379  if (fs) anchor_token(ls);
380}
381
382
383Proto *luaY_parser (lua_State *L, ZIO *z, Mbuffer *buff, const char *name) {
384  struct LexState lexstate;
385  struct FuncState funcstate;
386  lexstate.buff = buff;
387  luaX_setinput(L, &lexstate, z, luaS_new(L, name));
388  open_func(&lexstate, &funcstate);
389  funcstate.f->is_vararg = VARARG_ISVARARG;  /* main func. is always vararg */
390  luaX_next(&lexstate);  /* read first token */
391  chunk(&lexstate);
392  check(&lexstate, TK_EOS);
393  close_func(&lexstate);
394  lua_assert(funcstate.prev == NULL);
395  lua_assert(funcstate.f->nups == 0);
396  lua_assert(lexstate.fs == NULL);
397  return funcstate.f;
398}
399
400
401
402/*============================================================*/
403/* GRAMMAR RULES */
404/*============================================================*/
405
406
407static void field (LexState *ls, expdesc *v) {
408  /* field -> ['.' | ':'] NAME */
409  FuncState *fs = ls->fs;
410  expdesc key;
411  luaK_exp2anyreg(fs, v);
412  luaX_next(ls);  /* skip the dot or colon */
413  checkname(ls, &key);
414  luaK_indexed(fs, v, &key);
415}
416
417
418static void yindex (LexState *ls, expdesc *v) {
419  /* index -> '[' expr ']' */
420  luaX_next(ls);  /* skip the '[' */
421  expr(ls, v);
422  luaK_exp2val(ls->fs, v);
423  checknext(ls, ']');
424}
425
426
427/*
428** {======================================================================
429** Rules for Constructors
430** =======================================================================
431*/
432
433
434struct ConsControl {
435  expdesc v;  /* last list item read */
436  expdesc *t;  /* table descriptor */
437  int nh;  /* total number of `record' elements */
438  int na;  /* total number of array elements */
439  int tostore;  /* number of array elements pending to be stored */
440};
441
442
443static void recfield (LexState *ls, struct ConsControl *cc) {
444  /* recfield -> (NAME | `['exp1`]') = exp1 */
445  FuncState *fs = ls->fs;
446  int reg = ls->fs->freereg;
447  expdesc key, val;
448  int rkkey;
449  if (ls->t.token == TK_NAME) {
450    luaY_checklimit(fs, cc->nh, MAX_INT, "items in a constructor");
451    checkname(ls, &key);
452  }
453  else  /* ls->t.token == '[' */
454    yindex(ls, &key);
455  cc->nh++;
456  checknext(ls, '=');
457  rkkey = luaK_exp2RK(fs, &key);
458  expr(ls, &val);
459  luaK_codeABC(fs, OP_SETTABLE, cc->t->u.s.info, rkkey, luaK_exp2RK(fs, &val));
460  fs->freereg = reg;  /* free registers */
461}
462
463
464static void closelistfield (FuncState *fs, struct ConsControl *cc) {
465  if (cc->v.k == VVOID) return;  /* there is no list item */
466  luaK_exp2nextreg(fs, &cc->v);
467  cc->v.k = VVOID;
468  if (cc->tostore == LFIELDS_PER_FLUSH) {
469    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);  /* flush */
470    cc->tostore = 0;  /* no more items pending */
471  }
472}
473
474
475static void lastlistfield (FuncState *fs, struct ConsControl *cc) {
476  if (cc->tostore == 0) return;
477  if (hasmultret(cc->v.k)) {
478    luaK_setmultret(fs, &cc->v);
479    luaK_setlist(fs, cc->t->u.s.info, cc->na, LUA_MULTRET);
480    cc->na--;  /* do not count last expression (unknown number of elements) */
481  }
482  else {
483    if (cc->v.k != VVOID)
484      luaK_exp2nextreg(fs, &cc->v);
485    luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore);
486  }
487}
488
489
490static void listfield (LexState *ls, struct ConsControl *cc) {
491  expr(ls, &cc->v);
492  luaY_checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor");
493  cc->na++;
494  cc->tostore++;
495}
496
497
498static void constructor (LexState *ls, expdesc *t) {
499  /* constructor -> ?? */
500  FuncState *fs = ls->fs;
501  int line = ls->linenumber;
502  int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0);
503  struct ConsControl cc;
504  cc.na = cc.nh = cc.tostore = 0;
505  cc.t = t;
506  init_exp(t, VRELOCABLE, pc);
507  init_exp(&cc.v, VVOID, 0);  /* no value (yet) */
508  luaK_exp2nextreg(ls->fs, t);  /* fix it at stack top (for gc) */
509  checknext(ls, '{');
510  do {
511    lua_assert(cc.v.k == VVOID || cc.tostore > 0);
512    if (ls->t.token == '}') break;
513    closelistfield(fs, &cc);
514    switch(ls->t.token) {
515      case TK_NAME: {  /* may be listfields or recfields */
516        luaX_lookahead(ls);
517        if (ls->lookahead.token != '=')  /* expression? */
518          listfield(ls, &cc);
519        else
520          recfield(ls, &cc);
521        break;
522      }
523      case '[': {  /* constructor_item -> recfield */
524        recfield(ls, &cc);
525        break;
526      }
527      default: {  /* constructor_part -> listfield */
528        listfield(ls, &cc);
529        break;
530      }
531    }
532  } while (testnext(ls, ',') || testnext(ls, ';'));
533  check_match(ls, '}', '{', line);
534  lastlistfield(fs, &cc);
535  SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */
536  SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh));  /* set initial table size */
537}
538
539/* }====================================================================== */
540
541
542
543static void parlist (LexState *ls) {
544  /* parlist -> [ param { `,' param } ] */
545  FuncState *fs = ls->fs;
546  Proto *f = fs->f;
547  int nparams = 0;
548  f->is_vararg = 0;
549  if (ls->t.token != ')') {  /* is `parlist' not empty? */
550    do {
551      switch (ls->t.token) {
552        case TK_NAME: {  /* param -> NAME */
553          new_localvar(ls, str_checkname(ls), nparams++);
554          break;
555        }
556        case TK_DOTS: {  /* param -> `...' */
557          luaX_next(ls);
558#if defined(LUA_COMPAT_VARARG)
559          /* use `arg' as default name */
560          new_localvarliteral(ls, "arg", nparams++);
561          f->is_vararg = VARARG_HASARG | VARARG_NEEDSARG;
562#endif
563          f->is_vararg |= VARARG_ISVARARG;
564          break;
565        }
566        default: luaX_syntaxerror(ls, "<name> or " LUA_QL("...") " expected");
567      }
568    } while (!f->is_vararg && testnext(ls, ','));
569  }
570  adjustlocalvars(ls, nparams);
571  f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG));
572  luaK_reserveregs(fs, fs->nactvar);  /* reserve register for parameters */
573}
574
575
576static void body (LexState *ls, expdesc *e, int needself, int line) {
577  /* body ->  `(' parlist `)' chunk END */
578  FuncState new_fs;
579  open_func(ls, &new_fs);
580  new_fs.f->linedefined = line;
581  checknext(ls, '(');
582  if (needself) {
583    new_localvarliteral(ls, "self", 0);
584    adjustlocalvars(ls, 1);
585  }
586  parlist(ls);
587  checknext(ls, ')');
588  chunk(ls);
589  new_fs.f->lastlinedefined = ls->linenumber;
590  check_match(ls, TK_END, TK_FUNCTION, line);
591  close_func(ls);
592  pushclosure(ls, &new_fs, e);
593}
594
595
596static int explist1 (LexState *ls, expdesc *v) {
597  /* explist1 -> expr { `,' expr } */
598  int n = 1;  /* at least one expression */
599  expr(ls, v);
600  while (testnext(ls, ',')) {
601    luaK_exp2nextreg(ls->fs, v);
602    expr(ls, v);
603    n++;
604  }
605  return n;
606}
607
608
609static void funcargs (LexState *ls, expdesc *f) {
610  FuncState *fs = ls->fs;
611  expdesc args;
612  int base, nparams;
613  int line = ls->linenumber;
614  switch (ls->t.token) {
615    case '(': {  /* funcargs -> `(' [ explist1 ] `)' */
616      if (line != ls->lastline)
617        luaX_syntaxerror(ls,"ambiguous syntax (function call x new statement)");
618      luaX_next(ls);
619      if (ls->t.token == ')')  /* arg list is empty? */
620        args.k = VVOID;
621      else {
622        explist1(ls, &args);
623        luaK_setmultret(fs, &args);
624      }
625      check_match(ls, ')', '(', line);
626      break;
627    }
628    case '{': {  /* funcargs -> constructor */
629      constructor(ls, &args);
630      break;
631    }
632    case TK_STRING: {  /* funcargs -> STRING */
633      codestring(ls, &args, ls->t.seminfo.ts);
634      luaX_next(ls);  /* must use `seminfo' before `next' */
635      break;
636    }
637    default: {
638      luaX_syntaxerror(ls, "function arguments expected");
639      return;
640    }
641  }
642  lua_assert(f->k == VNONRELOC);
643  base = f->u.s.info;  /* base register for call */
644  if (hasmultret(args.k))
645    nparams = LUA_MULTRET;  /* open call */
646  else {
647    if (args.k != VVOID)
648      luaK_exp2nextreg(fs, &args);  /* close last argument */
649    nparams = fs->freereg - (base+1);
650  }
651  init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2));
652  luaK_fixline(fs, line);
653  fs->freereg = base+1;  /* call remove function and arguments and leaves
654                            (unless changed) one result */
655}
656
657
658
659
660/*
661** {======================================================================
662** Expression parsing
663** =======================================================================
664*/
665
666
667static void prefixexp (LexState *ls, expdesc *v) {
668  /* prefixexp -> NAME | '(' expr ')' */
669  switch (ls->t.token) {
670    case '(': {
671      int line = ls->linenumber;
672      luaX_next(ls);
673      expr(ls, v);
674      check_match(ls, ')', '(', line);
675      luaK_dischargevars(ls->fs, v);
676      return;
677    }
678    case TK_NAME: {
679      singlevar(ls, v);
680      return;
681    }
682    default: {
683      luaX_syntaxerror(ls, "unexpected symbol");
684      return;
685    }
686  }
687}
688
689
690static void primaryexp (LexState *ls, expdesc *v) {
691  /* primaryexp ->
692        prefixexp { `.' NAME | `[' exp `]' | `:' NAME funcargs | funcargs } */
693  FuncState *fs = ls->fs;
694  prefixexp(ls, v);
695  for (;;) {
696    switch (ls->t.token) {
697      case '.': {  /* field */
698        field(ls, v);
699        break;
700      }
701      case '[': {  /* `[' exp1 `]' */
702        expdesc key;
703        luaK_exp2anyreg(fs, v);
704        yindex(ls, &key);
705        luaK_indexed(fs, v, &key);
706        break;
707      }
708      case ':': {  /* `:' NAME funcargs */
709        expdesc key;
710        luaX_next(ls);
711        checkname(ls, &key);
712        luaK_self(fs, v, &key);
713        funcargs(ls, v);
714        break;
715      }
716      case '(': case TK_STRING: case '{': {  /* funcargs */
717        luaK_exp2nextreg(fs, v);
718        funcargs(ls, v);
719        break;
720      }
721      default: return;
722    }
723  }
724}
725
726
727static void simpleexp (LexState *ls, expdesc *v) {
728  /* simpleexp -> NUMBER | STRING | NIL | true | false | ... |
729                  constructor | FUNCTION body | primaryexp */
730  switch (ls->t.token) {
731    case TK_NUMBER: {
732      init_exp(v, VKNUM, 0);
733      v->u.nval = ls->t.seminfo.r;
734      break;
735    }
736    case TK_STRING: {
737      codestring(ls, v, ls->t.seminfo.ts);
738      break;
739    }
740    case TK_NIL: {
741      init_exp(v, VNIL, 0);
742      break;
743    }
744    case TK_TRUE: {
745      init_exp(v, VTRUE, 0);
746      break;
747    }
748    case TK_FALSE: {
749      init_exp(v, VFALSE, 0);
750      break;
751    }
752    case TK_DOTS: {  /* vararg */
753      FuncState *fs = ls->fs;
754      check_condition(ls, fs->f->is_vararg,
755                      "cannot use " LUA_QL("...") " outside a vararg function");
756      fs->f->is_vararg &= ~VARARG_NEEDSARG;  /* don't need 'arg' */
757      init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0));
758      break;
759    }
760    case '{': {  /* constructor */
761      constructor(ls, v);
762      return;
763    }
764    case TK_FUNCTION: {
765      luaX_next(ls);
766      body(ls, v, 0, ls->linenumber);
767      return;
768    }
769    default: {
770      primaryexp(ls, v);
771      return;
772    }
773  }
774  luaX_next(ls);
775}
776
777
778static UnOpr getunopr (int op) {
779  switch (op) {
780    case TK_NOT: return OPR_NOT;
781    case '-': return OPR_MINUS;
782    case '#': return OPR_LEN;
783    default: return OPR_NOUNOPR;
784  }
785}
786
787
788static BinOpr getbinopr (int op) {
789  switch (op) {
790    case '+': return OPR_ADD;
791    case '-': return OPR_SUB;
792    case '*': return OPR_MUL;
793    case '/': return OPR_DIV;
794    case '%': return OPR_MOD;
795    case '^': return OPR_POW;
796    case TK_CONCAT: return OPR_CONCAT;
797    case TK_NE: return OPR_NE;
798    case TK_EQ: return OPR_EQ;
799    case '<': return OPR_LT;
800    case TK_LE: return OPR_LE;
801    case '>': return OPR_GT;
802    case TK_GE: return OPR_GE;
803    case TK_AND: return OPR_AND;
804    case TK_OR: return OPR_OR;
805    default: return OPR_NOBINOPR;
806  }
807}
808
809
810static const struct {
811  lu_byte left;  /* left priority for each binary operator */
812  lu_byte right; /* right priority */
813} priority[] = {  /* ORDER OPR */
814   {6, 6}, {6, 6}, {7, 7}, {7, 7}, {7, 7},  /* `+' `-' `/' `%' */
815   {10, 9}, {5, 4},                 /* power and concat (right associative) */
816   {3, 3}, {3, 3},                  /* equality and inequality */
817   {3, 3}, {3, 3}, {3, 3}, {3, 3},  /* order */
818   {2, 2}, {1, 1}                   /* logical (and/or) */
819};
820
821#define UNARY_PRIORITY  8  /* priority for unary operators */
822
823
824/*
825** subexpr -> (simpleexp | unop subexpr) { binop subexpr }
826** where `binop' is any binary operator with a priority higher than `limit'
827*/
828static BinOpr subexpr (LexState *ls, expdesc *v, unsigned int limit) {
829  BinOpr op;
830  UnOpr uop;
831  enterlevel(ls);
832  uop = getunopr(ls->t.token);
833  if (uop != OPR_NOUNOPR) {
834    luaX_next(ls);
835    subexpr(ls, v, UNARY_PRIORITY);
836    luaK_prefix(ls->fs, uop, v);
837  }
838  else simpleexp(ls, v);
839  /* expand while operators have priorities higher than `limit' */
840  op = getbinopr(ls->t.token);
841  while (op != OPR_NOBINOPR && priority[op].left > limit) {
842    expdesc v2;
843    BinOpr nextop;
844    luaX_next(ls);
845    luaK_infix(ls->fs, op, v);
846    /* read sub-expression with higher priority */
847    nextop = subexpr(ls, &v2, priority[op].right);
848    luaK_posfix(ls->fs, op, v, &v2);
849    op = nextop;
850  }
851  leavelevel(ls);
852  return op;  /* return first untreated operator */
853}
854
855
856static void expr (LexState *ls, expdesc *v) {
857  subexpr(ls, v, 0);
858}
859
860/* }==================================================================== */
861
862
863
864/*
865** {======================================================================
866** Rules for Statements
867** =======================================================================
868*/
869
870
871static int block_follow (int token) {
872  switch (token) {
873    case TK_ELSE: case TK_ELSEIF: case TK_END:
874    case TK_UNTIL: case TK_EOS:
875      return 1;
876    default: return 0;
877  }
878}
879
880
881static void block (LexState *ls) {
882  /* block -> chunk */
883  FuncState *fs = ls->fs;
884  BlockCnt bl;
885  enterblock(fs, &bl, 0);
886  chunk(ls);
887  lua_assert(bl.breaklist == NO_JUMP);
888  leaveblock(fs);
889}
890
891
892/*
893** structure to chain all variables in the left-hand side of an
894** assignment
895*/
896struct LHS_assign {
897  struct LHS_assign *prev;
898  expdesc v;  /* variable (global, local, upvalue, or indexed) */
899};
900
901
902/*
903** check whether, in an assignment to a local variable, the local variable
904** is needed in a previous assignment (to a table). If so, save original
905** local value in a safe place and use this safe copy in the previous
906** assignment.
907*/
908static void check_conflict (LexState *ls, struct LHS_assign *lh, expdesc *v) {
909  FuncState *fs = ls->fs;
910  int extra = fs->freereg;  /* eventual position to save local variable */
911  int conflict = 0;
912  for (; lh; lh = lh->prev) {
913    if (lh->v.k == VINDEXED) {
914      if (lh->v.u.s.info == v->u.s.info) {  /* conflict? */
915        conflict = 1;
916        lh->v.u.s.info = extra;  /* previous assignment will use safe copy */
917      }
918      if (lh->v.u.s.aux == v->u.s.info) {  /* conflict? */
919        conflict = 1;
920        lh->v.u.s.aux = extra;  /* previous assignment will use safe copy */
921      }
922    }
923  }
924  if (conflict) {
925    luaK_codeABC(fs, OP_MOVE, fs->freereg, v->u.s.info, 0);  /* make copy */
926    luaK_reserveregs(fs, 1);
927  }
928}
929
930
931static void assignment (LexState *ls, struct LHS_assign *lh, int nvars) {
932  expdesc e;
933  check_condition(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED,
934                      "syntax error");
935  if (testnext(ls, ',')) {  /* assignment -> `,' primaryexp assignment */
936    struct LHS_assign nv;
937    nv.prev = lh;
938    primaryexp(ls, &nv.v);
939    if (nv.v.k == VLOCAL)
940      check_conflict(ls, lh, &nv.v);
941    luaY_checklimit(ls->fs, nvars, LUAI_MAXCCALLS - ls->L->nCcalls,
942                    "variables in assignment");
943    assignment(ls, &nv, nvars+1);
944  }
945  else {  /* assignment -> `=' explist1 */
946    int nexps;
947    checknext(ls, '=');
948    nexps = explist1(ls, &e);
949    if (nexps != nvars) {
950      adjust_assign(ls, nvars, nexps, &e);
951      if (nexps > nvars)
952        ls->fs->freereg -= nexps - nvars;  /* remove extra values */
953    }
954    else {
955      luaK_setoneret(ls->fs, &e);  /* close last expression */
956      luaK_storevar(ls->fs, &lh->v, &e);
957      return;  /* avoid default */
958    }
959  }
960  init_exp(&e, VNONRELOC, ls->fs->freereg-1);  /* default assignment */
961  luaK_storevar(ls->fs, &lh->v, &e);
962}
963
964
965static int cond (LexState *ls) {
966  /* cond -> exp */
967  expdesc v;
968  expr(ls, &v);  /* read condition */
969  if (v.k == VNIL) v.k = VFALSE;  /* `falses' are all equal here */
970  luaK_goiftrue(ls->fs, &v);
971  return v.f;
972}
973
974
975static void breakstat (LexState *ls) {
976  FuncState *fs = ls->fs;
977  BlockCnt *bl = fs->bl;
978  int upval = 0;
979  while (bl && !bl->isbreakable) {
980    upval |= bl->upval;
981    bl = bl->previous;
982  }
983  if (!bl)
984    luaX_syntaxerror(ls, "no loop to break");
985  if (upval)
986    luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
987  luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
988}
989
990
991static void whilestat (LexState *ls, int line) {
992  /* whilestat -> WHILE cond DO block END */
993  FuncState *fs = ls->fs;
994  int whileinit;
995  int condexit;
996  BlockCnt bl;
997  luaX_next(ls);  /* skip WHILE */
998  whileinit = luaK_getlabel(fs);
999  condexit = cond(ls);
1000  enterblock(fs, &bl, 1);
1001  checknext(ls, TK_DO);
1002  block(ls);
1003  luaK_patchlist(fs, luaK_jump(fs), whileinit);
1004  check_match(ls, TK_END, TK_WHILE, line);
1005  leaveblock(fs);
1006  luaK_patchtohere(fs, condexit);  /* false conditions finish the loop */
1007}
1008
1009
1010static void repeatstat (LexState *ls, int line) {
1011  /* repeatstat -> REPEAT block UNTIL cond */
1012  int condexit;
1013  FuncState *fs = ls->fs;
1014  int repeat_init = luaK_getlabel(fs);
1015  BlockCnt bl1, bl2;
1016  enterblock(fs, &bl1, 1);  /* loop block */
1017  enterblock(fs, &bl2, 0);  /* scope block */
1018  luaX_next(ls);  /* skip REPEAT */
1019  chunk(ls);
1020  check_match(ls, TK_UNTIL, TK_REPEAT, line);
1021  condexit = cond(ls);  /* read condition (inside scope block) */
1022  if (!bl2.upval) {  /* no upvalues? */
1023    leaveblock(fs);  /* finish scope */
1024    luaK_patchlist(ls->fs, condexit, repeat_init);  /* close the loop */
1025  }
1026  else {  /* complete semantics when there are upvalues */
1027    breakstat(ls);  /* if condition then break */
1028    luaK_patchtohere(ls->fs, condexit);  /* else... */
1029    leaveblock(fs);  /* finish scope... */
1030    luaK_patchlist(ls->fs, luaK_jump(fs), repeat_init);  /* and repeat */
1031  }
1032  leaveblock(fs);  /* finish loop */
1033}
1034
1035
1036static int exp1 (LexState *ls) {
1037  expdesc e;
1038  int k;
1039  expr(ls, &e);
1040  k = e.k;
1041  luaK_exp2nextreg(ls->fs, &e);
1042  return k;
1043}
1044
1045
1046static void forbody (LexState *ls, int base, int line, int nvars, int isnum) {
1047  /* forbody -> DO block */
1048  BlockCnt bl;
1049  FuncState *fs = ls->fs;
1050  int prep, endfor;
1051  adjustlocalvars(ls, 3);  /* control variables */
1052  checknext(ls, TK_DO);
1053  prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs);
1054  enterblock(fs, &bl, 0);  /* scope for declared variables */
1055  adjustlocalvars(ls, nvars);
1056  luaK_reserveregs(fs, nvars);
1057  block(ls);
1058  leaveblock(fs);  /* end of scope for declared variables */
1059  luaK_patchtohere(fs, prep);
1060  endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) :
1061                     luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars);
1062  luaK_fixline(fs, line);  /* pretend that `OP_FOR' starts the loop */
1063  luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1);
1064}
1065
1066
1067static void fornum (LexState *ls, TString *varname, int line) {
1068  /* fornum -> NAME = exp1,exp1[,exp1] forbody */
1069  FuncState *fs = ls->fs;
1070  int base = fs->freereg;
1071  new_localvarliteral(ls, "(for index)", 0);
1072  new_localvarliteral(ls, "(for limit)", 1);
1073  new_localvarliteral(ls, "(for step)", 2);
1074  new_localvar(ls, varname, 3);
1075  checknext(ls, '=');
1076  exp1(ls);  /* initial value */
1077  checknext(ls, ',');
1078  exp1(ls);  /* limit */
1079  if (testnext(ls, ','))
1080    exp1(ls);  /* optional step */
1081  else {  /* default step = 1 */
1082    luaK_codeABx(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1));
1083    luaK_reserveregs(fs, 1);
1084  }
1085  forbody(ls, base, line, 1, 1);
1086}
1087
1088
1089static void forlist (LexState *ls, TString *indexname) {
1090  /* forlist -> NAME {,NAME} IN explist1 forbody */
1091  FuncState *fs = ls->fs;
1092  expdesc e;
1093  int nvars = 0;
1094  int line;
1095  int base = fs->freereg;
1096  /* create control variables */
1097  new_localvarliteral(ls, "(for generator)", nvars++);
1098  new_localvarliteral(ls, "(for state)", nvars++);
1099  new_localvarliteral(ls, "(for control)", nvars++);
1100  /* create declared variables */
1101  new_localvar(ls, indexname, nvars++);
1102  while (testnext(ls, ','))
1103    new_localvar(ls, str_checkname(ls), nvars++);
1104  checknext(ls, TK_IN);
1105  line = ls->linenumber;
1106  adjust_assign(ls, 3, explist1(ls, &e), &e);
1107  luaK_checkstack(fs, 3);  /* extra space to call generator */
1108  forbody(ls, base, line, nvars - 3, 0);
1109}
1110
1111
1112static void forstat (LexState *ls, int line) {
1113  /* forstat -> FOR (fornum | forlist) END */
1114  FuncState *fs = ls->fs;
1115  TString *varname;
1116  BlockCnt bl;
1117  enterblock(fs, &bl, 1);  /* scope for loop and control variables */
1118  luaX_next(ls);  /* skip `for' */
1119  varname = str_checkname(ls);  /* first variable name */
1120  switch (ls->t.token) {
1121    case '=': fornum(ls, varname, line); break;
1122    case ',': case TK_IN: forlist(ls, varname); break;
1123    default: luaX_syntaxerror(ls, LUA_QL("=") " or " LUA_QL("in") " expected");
1124  }
1125  check_match(ls, TK_END, TK_FOR, line);
1126  leaveblock(fs);  /* loop scope (`break' jumps to this point) */
1127}
1128
1129
1130static 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}
1139
1140
1141static 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  else
1159    luaK_concat(fs, &escapelist, flist);
1160  luaK_patchtohere(fs, escapelist);
1161  check_match(ls, TK_END, TK_IF, line);
1162}
1163
1164
1165static 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}
1177
1178
1179static 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}
1196
1197
1198static 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}
1210
1211
1212static 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}
1222
1223
1224static 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}
1236
1237
1238static 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}
1269
1270
1271static 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      else
1305        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}
1323
1324
1325static 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}
1338
1339/* }====================================================================== */
Note: See TracBrowser for help on using the repository browser.