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