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