← Back to branch summary

~ubuntu-branches/ubuntu/quantal/genometools/quantal-backports

« back to all changes in this revision

Viewing changes to src/external/lua-5.1.4/src/lparser.c

  • Committer: Package Import Robot
  • Author(s): Sascha Steinbiss
  • Date: 2012-07-09 14:10:23 UTC
  • Revision ID: package-import@ubuntu.com-20120709141023-juuu4spm6chqsf9o
Tags: upstream-1.4.1
Import upstream version 1.4.1

Show diffs side-by-side

added added

removed removed

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