Lua 5.0

Lua Team committed 23 years ago

Commit 488a64b1 parent c2bb718138 files · +16186 −12300Browse files

Showing the changes to src/lparser.c (1 of 138 files). Show all

Unified · Split

@@ -1,16 +1,18 @@
1	1	/*
2		−** $Id: lparser.c,v 1.117 2000/11/29 11:57:42 roberto Exp $
3		−** LL(1) Parser and code generator for Lua
	2	+** $Id: lparser.c,v 1.208 2003/04/03 13:35:34 roberto Exp $
	3	+** Lua Parser
4	4	** See Copyright Notice in lua.h
5	5	*/
6	6
7	7
8		−#include <stdio.h>
9	8	#include <string.h>
10	9
	10	+#define lparser_c
	11	+
11	12	#include "lua.h"
12	13
13	14	#include "lcode.h"
	15	+#include "ldebug.h"
14	16	#include "lfunc.h"
15	17	#include "llex.h"
16	18	#include "lmem.h"
@@ -21,35 +23,34 @@ · 4 unmodified lines
21	23	#include "lstring.h"
22	24
23	25
24		−/*
25		−** Constructors descriptor:
26		−** `n' indicates number of elements, and `k' signals whether
27		−** it is a list constructor (k = 0) or a record constructor (k = 1)
28		−** or empty (k = ';' or '}')
29		−*/
30		−typedef struct Constdesc {
31		− int n;
32		− int k;
33		−} Constdesc;
34	26
35	27
36		−typedef struct Breaklabel {
37		− struct Breaklabel previous; / chain */
38		− int breaklist;
39		− int stacklevel;
40		−} Breaklabel;
	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--)
41	34
42	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	+
43	47
44	48
45	49	/*
46	50	** prototypes for recursive non-terminal functions
47	51	*/
48		−static void body (LexState *ls, int needself, int line);
49	52	static void chunk (LexState *ls);
50		−static void constructor (LexState *ls);
51	53	static void expr (LexState ls, expdesc v);
52		−static void exp1 (LexState *ls);
53	54
54	55
55	56
@@ -65,32 +66,18 @@ static void next (LexState *ls) { · 9 unmodified lines
65	66
66	67
67	68	static void lookahead (LexState *ls) {
68		− LUA_ASSERT(ls->lookahead.token == TK_EOS, "two look-aheads");
	69	+ lua_assert(ls->lookahead.token == TK_EOS);
69	70	ls->lookahead.token = luaX_lex(ls, &ls->lookahead.seminfo);
70	71	}
71	72
72	73
73	74	static void error_expected (LexState *ls, int token) {
74		− char buff[100], t[TOKEN_LEN];
75		− luaX_token2str(token, t);
76		− sprintf(buff, "`%.20s' expected", t);
77		− luaK_error(ls, buff);
	75	+ luaX_syntaxerror(ls,
	76	+ luaO_pushfstring(ls->L, "`%s' expected", luaX_token2str(ls, token)));
78	77	}
79	78
80	79
81		−static void check (LexState *ls, int c) {
82		− if (ls->t.token != c)
83		− error_expected(ls, c);
84		− next(ls);
85		−}
86		−
87		−
88		−static void check_condition (LexState ls, int c, const char msg) {
89		− if (!c) luaK_error(ls, msg);
90		−}
91		−
92		−
93		−static int optional (LexState *ls, int c) {
	80	+static int testnext (LexState *ls, int c) {
94	81	if (ls->t.token == c) {
95	82	next(ls);
96	83	return 1;
@@ -99,40 +86,26 @@ static int optional (LexState *ls, int c) { · 2 unmodified lines
99	86	}
100	87
101	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	+
102	99	static void check_match (LexState *ls, int what, int who, int where) {
103		− if (ls->t.token != what) {
	100	+ if (!testnext(ls, what)) {
104	101	if (where == ls->linenumber)
105	102	error_expected(ls, what);
106	103	else {
107		− char buff[100];
108		− char t_what[TOKEN_LEN], t_who[TOKEN_LEN];
109		− luaX_token2str(what, t_what);
110		− luaX_token2str(who, t_who);
111		− sprintf(buff, "`%.20s' expected (to close `%.20s' at line %d)",
112		− t_what, t_who, where);
113		− luaK_error(ls, buff);
	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));
114	107	}
115	108	}
116		− next(ls);
117		−}
118		−
119		−
120		−static int string_constant (FuncState fs, TString s) {
121		− Proto *f = fs->f;
122		− int c = s->u.s.constindex;
123		− if (c >= f->nkstr \|\| f->kstr[c] != s) {
124		− luaM_growvector(fs->L, f->kstr, f->nkstr, 1, TString *,
125		− "constant table overflow", MAXARG_U);
126		− c = f->nkstr++;
127		− f->kstr[c] = s;
128		− s->u.s.constindex = c; /* hint for next time */
129		− }
130		− return c;
131		−}
132		−
133		−
134		−static void code_string (LexState ls, TString s) {
135		− luaK_kstr(ls, string_constant(ls->fs, s));
136	109	}
137	110
138	111
@@ -145,182 +118,224 @@ static TString str_checkname (LexState ls) { · 6 unmodified lines
145	118	}
146	119
147	120
148		−static int checkname (LexState *ls) {
149		− return string_constant(ls->fs, str_checkname(ls));
	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));
150	135	}
151	136
152	137
153	138	static int luaI_registerlocalvar (LexState ls, TString varname) {
154		− Proto *f = ls->fs->f;
155		− luaM_growvector(ls->L, f->locvars, f->nlocvars, 1, LocVar, "", MAX_INT);
156		− f->locvars[f->nlocvars].varname = varname;
157		− return f->nlocvars++;
	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++;
158	145	}
159	146
160	147
161	148	static void new_localvar (LexState ls, TString name, int n) {
162	149	FuncState *fs = ls->fs;
163		− luaX_checklimit(ls, fs->nactloc+n+1, MAXLOCALS, "local variables");
164		− fs->actloc[fs->nactloc+n] = luaI_registerlocalvar(ls, name);
	150	+ luaX_checklimit(ls, fs->nactvar+n+1, MAXVARS, "local variables");
	151	+ fs->actvar[fs->nactvar+n] = luaI_registerlocalvar(ls, name);
165	152	}
166	153
167	154
168	155	static void adjustlocalvars (LexState *ls, int nvars) {
169	156	FuncState *fs = ls->fs;
170		− while (nvars--)
171		− fs->f->locvars[fs->actloc[fs->nactloc++]].startpc = fs->pc;
	157	+ fs->nactvar += nvars;
	158	+ for (; nvars; nvars--) {
	159	+ getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc;
	160	+ }
172	161	}
173	162
174	163
175		−static void removelocalvars (LexState *ls, int nvars) {
	164	+static void removevars (LexState *ls, int tolevel) {
176	165	FuncState *fs = ls->fs;
177		− while (nvars--)
178		− fs->f->locvars[fs->actloc[--fs->nactloc]].endpc = fs->pc;
	166	+ while (fs->nactvar > tolevel)
	167	+ getlocvar(fs, --fs->nactvar).endpc = fs->pc;
179	168	}
180	169
181	170
182	171	static void new_localvarstr (LexState ls, const char name, int n) {
183		− new_localvar(ls, luaS_newfixed(ls->L, name), n);
	172	+ new_localvar(ls, luaS_new(ls->L, name), n);
184	173	}
185	174
186	175
187		−static int search_local (LexState ls, TString n, expdesc *var) {
188		− FuncState *fs;
189		− int level = 0;
190		− for (fs=ls->fs; fs; fs=fs->prev) {
191		− int i;
192		− for (i=fs->nactloc-1; i >= 0; i--) {
193		− if (n == fs->f->locvars[fs->actloc[i]].varname) {
194		− var->k = VLOCAL;
195		− var->u.index = i;
196		− return level;
197		− }
198		− }
199		− level++; /* `var' not found; check outer level */
200		− }
201		− var->k = VGLOBAL; /* not found in any level; must be global */
202		− return -1;
	176	+static void create_local (LexState ls, const char name) {
	177	+ new_localvarstr(ls, name, 0);
	178	+ adjustlocalvars(ls, 1);
203	179	}
204	180
205	181
206		−static void singlevar (LexState ls, TString n, expdesc *var) {
207		− int level = search_local(ls, n, var);
208		− if (level >= 1) /* neither local (0) nor global (-1)? */
209		− luaX_syntaxerror(ls, "cannot access a variable in outer scope", n->str);
210		− else if (level == -1) /* global? */
211		− var->u.index = string_constant(ls->fs, n);
	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++;
212	198	}
213	199
214	200
215		−static int indexupvalue (LexState ls, expdesc v) {
216		− FuncState *fs = ls->fs;
	201	+static int searchvar (FuncState fs, TString n) {
217	202	int i;
218		− for (i=0; i<fs->nupvalues; i++) {
219		− if (fs->upvalues[i].k == v->k && fs->upvalues[i].u.index == v->u.index)
	203	+ for (i=fs->nactvar-1; i >= 0; i--) {
	204	+ if (n == getlocvar(fs, i).varname)
220	205	return i;
221	206	}
222		− /* new one */
223		− luaX_checklimit(ls, fs->nupvalues+1, MAXUPVALUES, "upvalues");
224		− fs->upvalues[fs->nupvalues] = *v;
225		− return fs->nupvalues++;
	207	+ return -1; /* not found */
226	208	}
227	209
228	210
229		−static void pushupvalue (LexState ls, TString n) {
230		− FuncState *fs = ls->fs;
231		− expdesc v;
232		− int level = search_local(ls, n, &v);
233		− if (level == -1) { /* global? */
234		− if (fs->prev == NULL)
235		− luaX_syntaxerror(ls, "cannot access upvalue in main", n->str);
236		− v.u.index = string_constant(fs->prev, n);
	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	+ }
237	239	}
238		− else if (level != 1)
239		− luaX_syntaxerror(ls,
240		− "upvalue must be global or local to immediately outer scope", n->str);
241		− luaK_code1(fs, OP_PUSHUPVALUE, indexupvalue(ls, &v));
242	240	}
243	241
244	242
245		−static void adjust_mult_assign (LexState *ls, int nvars, int nexps) {
	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) {
246	251	FuncState *fs = ls->fs;
247		− int diff = nexps - nvars;
248		− if (nexps > 0 && luaK_lastisopen(fs)) { /* list ends in a function call */
249		− diff--; /* do not count function call itself */
250		− if (diff <= 0) { /* more variables than values? */
251		− luaK_setcallreturns(fs, -diff); /* function call provide extra values */
252		− diff = 0; /* no more difference */
	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);
253	265	}
254		− else /* more values than variables */
255		− luaK_setcallreturns(fs, 0); /* call should provide no value */
256	266	}
257		− /* push or pop eventual difference between list lengths */
258		− luaK_adjuststack(fs, diff);
259	267	}
260	268
261	269
262	270	static void code_params (LexState *ls, int nparams, int dots) {
263	271	FuncState *fs = ls->fs;
264	272	adjustlocalvars(ls, nparams);
265		− luaX_checklimit(ls, fs->nactloc, MAXPARAMS, "parameters");
266		− fs->f->numparams = fs->nactloc; /* `self' could be there already */
267		− fs->f->is_vararg = dots;
268		− if (dots) {
269		− new_localvarstr(ls, "arg", 0);
270		− adjustlocalvars(ls, 1);
271		− }
272		− luaK_deltastack(fs, fs->nactloc); /* count parameters in the stack */
	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 */
273	279	}
274	280
275	281
276		−static void enterbreak (FuncState fs, Breaklabel bl) {
277		− bl->stacklevel = fs->stacklevel;
	282	+static void enterblock (FuncState fs, BlockCnt bl, int isbreakable) {
278	283	bl->breaklist = NO_JUMP;
	284	+ bl->isbreakable = isbreakable;
	285	+ bl->nactvar = fs->nactvar;
	286	+ bl->upval = 0;
279	287	bl->previous = fs->bl;
280	288	fs->bl = bl;
	289	+ lua_assert(fs->freereg == fs->nactvar);
281	290	}
282	291
283	292
284		−static void leavebreak (FuncState fs, Breaklabel bl) {
	293	+static void leaveblock (FuncState *fs) {
	294	+ BlockCnt *bl = fs->bl;
285	295	fs->bl = bl->previous;
286		− LUA_ASSERT(bl->stacklevel == fs->stacklevel, "wrong levels");
287		− luaK_patchlist(fs, bl->breaklist, luaK_getlabel(fs));
	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);
288	302	}
289	303
290	304
291		−static void pushclosure (LexState ls, FuncState func) {
	305	+static void pushclosure (LexState ls, FuncState func, expdesc *v) {
292	306	FuncState *fs = ls->fs;
293	307	Proto *f = fs->f;
294	308	int i;
295		− for (i=0; i<func->nupvalues; i++)
296		− luaK_tostack(ls, &func->upvalues[i], 1);
297		− luaM_growvector(ls->L, f->kproto, f->nkproto, 1, Proto *,
298		− "constant table overflow", MAXARG_A);
299		− f->kproto[f->nkproto++] = func->f;
300		− luaK_code2(fs, OP_CLOSURE, f->nkproto-1, func->nupvalues);
	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	+ }
301	317	}
302	318
303	319
304	320	static void open_func (LexState ls, FuncState fs) {
305	321	Proto *f = luaF_newproto(ls->L);
	322	+ fs->f = f;
306	323	fs->prev = ls->fs; /* linked list of funcstates */
307	324	fs->ls = ls;
308	325	fs->L = ls->L;
309	326	ls->fs = fs;
310		− fs->stacklevel = 0;
311		− fs->nactloc = 0;
312		− fs->nupvalues = 0;
313		− fs->bl = NULL;
314		− fs->f = f;
315		− f->source = ls->source;
316	327	fs->pc = 0;
317	328	fs->lasttarget = 0;
318		− fs->lastline = 0;
319		− fs->jlt = NO_JUMP;
320		− f->code = NULL;
321		− f->maxstacksize = 0;
322		− f->numparams = 0; /* default for main chunk */
323		− f->is_vararg = 0; /* default for main chunk */
	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 */
324	339	}
325	340
326	341
@@ -328,33 +343,40 @@ static void close_func (LexState *ls) { · 1 unmodified line
328	343	lua_State *L = ls->L;
329	344	FuncState *fs = ls->fs;
330	345	Proto *f = fs->f;
331		− luaK_code0(fs, OP_END);
332		− luaK_getlabel(fs); /* close eventual list of pending jumps */
333		− luaM_reallocvector(L, f->code, fs->pc, Instruction);
334		− luaM_reallocvector(L, f->kstr, f->nkstr, TString *);
335		− luaM_reallocvector(L, f->knum, f->nknum, Number);
336		− luaM_reallocvector(L, f->kproto, f->nkproto, Proto *);
337		− removelocalvars(ls, fs->nactloc);
338		− luaM_reallocvector(L, f->locvars, f->nlocvars, LocVar);
339		− luaM_reallocvector(L, f->lineinfo, f->nlineinfo+1, int);
340		− f->lineinfo[f->nlineinfo++] = MAX_INT; /* end flag */
341		− luaF_protook(L, f, fs->pc); /* proto is ok now */
	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);
342	362	ls->fs = fs->prev;
343		− LUA_ASSERT(fs->bl == NULL, "wrong list end");
344	363	}
345	364
346	365
347		−Proto luaY_parser (lua_State L, ZIO *z) {
	366	+Proto luaY_parser (lua_State L, ZIO z, Mbuffer buff) {
348	367	struct LexState lexstate;
349	368	struct FuncState funcstate;
	369	+ lexstate.buff = buff;
	370	+ lexstate.nestlevel = 0;
350	371	luaX_setinput(L, &lexstate, z, luaS_new(L, zname(z)));
351	372	open_func(&lexstate, &funcstate);
352	373	next(&lexstate); /* read first token */
353	374	chunk(&lexstate);
354	375	check_condition(&lexstate, (lexstate.t.token == TK_EOS), "<eof> expected");
355	376	close_func(&lexstate);
356		− LUA_ASSERT(funcstate.prev == NULL, "wrong list end");
357		− LUA_ASSERT(funcstate.nupvalues == 0, "no upvalues in main");
	377	+ lua_assert(funcstate.prev == NULL);
	378	+ lua_assert(funcstate.f->nups == 0);
	379	+ lua_assert(lexstate.nestlevel == 0);
358	380	return funcstate.f;
359	381	}
360	382
@@ -365,235 +387,239 @@ Proto luaY_parser (lua_State L, ZIO *z) { · 4 unmodified lines
365	387	/============================================================/
366	388
367	389
368		−static int explist1 (LexState *ls) {
369		− /* explist1 -> expr { ',' expr } */
370		− int n = 1; /* at least one expression */
371		− expdesc v;
372		− expr(ls, &v);
373		− while (ls->t.token == ',') {
374		− luaK_tostack(ls, &v, 1); /* gets only 1 value from previous expression */
375		− next(ls); /* skip comma */
376		− expr(ls, &v);
377		− n++;
378		− }
379		− luaK_tostack(ls, &v, 0); /* keep open number of values of last expression */
380		− return n;
	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);
381	398	}
382	399
383	400
384		−static void funcargs (LexState *ls, int slf) {
	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 */
385	428	FuncState *fs = ls->fs;
386		− int slevel = fs->stacklevel - slf - 1; /* where is func in the stack */
387		− switch (ls->t.token) {
388		− case '(': { /* funcargs -> '(' [ explist1 ] ')' */
389		− int line = ls->linenumber;
390		− int nargs = 0;
391		− next(ls);
392		− if (ls->t.token != ')') /* arg list not empty? */
393		− nargs = explist1(ls);
394		− check_match(ls, ')', '(', line);
395		−#ifdef LUA_COMPAT_ARGRET
396		− if (nargs > 0) /* arg list is not empty? */
397		− luaK_setcallreturns(fs, 1); /* last call returns only 1 value */
398		−#else
399		− UNUSED(nargs); /* to avoid warnings */
400		−#endif
401		− break;
402		− }
403		− case '{': { /* funcargs -> constructor */
404		− constructor(ls);
405		− break;
406		− }
407		− case TK_STRING: { /* funcargs -> STRING */
408		− code_string(ls, ls->t.seminfo.ts); /* must use `seminfo' before `next' */
409		− next(ls);
410		− break;
411		− }
412		− default: {
413		− luaK_error(ls, "function arguments expected");
414		− break;
415		− }
	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 */
416	455	}
417		− fs->stacklevel = slevel; /* call will remove function and arguments */
418		− luaK_code2(fs, OP_CALL, slevel, MULT_RET);
419	456	}
420	457
421	458
422		−static void var_or_func_tail (LexState ls, expdesc v) {
423		− for (;;) {
424		− switch (ls->t.token) {
425		− case '.': { /* var_or_func_tail -> '.' NAME */
426		− next(ls);
427		− luaK_tostack(ls, v, 1); /* `v' must be on stack */
428		− luaK_kstr(ls, checkname(ls));
429		− v->k = VINDEXED;
430		− break;
431		− }
432		− case '[': { /* var_or_func_tail -> '[' exp1 ']' */
433		− next(ls);
434		− luaK_tostack(ls, v, 1); /* `v' must be on stack */
435		− v->k = VINDEXED;
436		− exp1(ls);
437		− check(ls, ']');
	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);
438	506	break;
439	507	}
440		− case ':': { /* var_or_func_tail -> ':' NAME funcargs */
441		− int name;
442		− next(ls);
443		− name = checkname(ls);
444		− luaK_tostack(ls, v, 1); /* `v' must be on stack */
445		− luaK_code1(ls->fs, OP_PUSHSELF, name);
446		− funcargs(ls, 1);
447		− v->k = VEXP;
448		− v->u.l.t = v->u.l.f = NO_JUMP;
	508	+ case '[': { /* constructor_item -> recfield */
	509	+ recfield(ls, &cc);
449	510	break;
450	511	}
451		− case '(': case TK_STRING: case '{': { /* var_or_func_tail -> funcargs */
452		− luaK_tostack(ls, v, 1); /* `v' must be on stack */
453		− funcargs(ls, 0);
454		− v->k = VEXP;
455		− v->u.l.t = v->u.l.f = NO_JUMP;
	512	+ default: { /* constructor_part -> listfield */
	513	+ listfield(ls, &cc);
456	514	break;
457	515	}
458		− default: return; /* should be follow... */
459	516	}
460		− }
461		−}
462		−
463		−
464		−static void var_or_func (LexState ls, expdesc v) {
465		− /* var_or_func -> ['%'] NAME var_or_func_tail */
466		− if (optional(ls, '%')) { /* upvalue? */
467		− pushupvalue(ls, str_checkname(ls));
468		− v->k = VEXP;
469		− v->u.l.t = v->u.l.f = NO_JUMP;
470		− }
471		− else /* variable name */
472		− singlevar(ls, str_checkname(ls), v);
473		− var_or_func_tail(ls, v);
	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 */
474	522	}
475	523
	524	+/* }====================================================================== */
476	525
477	526
478		−/*
479		−** {======================================================================
480		−** Rules for Constructors
481		−** =======================================================================
482		−*/
483		−
484	527
485		−static void recfield (LexState *ls) {
486		− /* recfield -> (NAME \| '['exp1']') = exp1 */
487		− switch (ls->t.token) {
488		− case TK_NAME: {
489		− luaK_kstr(ls, checkname(ls));
490		− break;
491		− }
492		− case '[': {
493		− next(ls);
494		− exp1(ls);
495		− check(ls, ']');
496		− break;
497		− }
498		− default: luaK_error(ls, "<name> or `[' expected");
	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, ','));
499	540	}
500		− check(ls, '=');
501		− exp1(ls);
	541	+ code_params(ls, nparams, dots);
502	542	}
503	543
504	544
505		−static int recfields (LexState *ls) {
506		− /* recfields -> recfield { ',' recfield } [','] */
507		− FuncState *fs = ls->fs;
508		− int n = 1; /* at least one element */
509		− recfield(ls);
510		− while (ls->t.token == ',') {
511		− next(ls);
512		− if (ls->t.token == ';' \|\| ls->t.token == '}')
513		− break;
514		− recfield(ls);
515		− n++;
516		− if (n%RFIELDS_PER_FLUSH == 0)
517		− luaK_code1(fs, OP_SETMAP, RFIELDS_PER_FLUSH);
518		− }
519		− luaK_code1(fs, OP_SETMAP, n%RFIELDS_PER_FLUSH);
520		− return n;
	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);
521	559	}
522	560
523	561
524		−static int listfields (LexState *ls) {
525		− /* listfields -> exp1 { ',' exp1 } [','] */
526		− FuncState *fs = ls->fs;
527		− int n = 1; /* at least one element */
528		− exp1(ls);
529		− while (ls->t.token == ',') {
530		− next(ls);
531		− if (ls->t.token == ';' \|\| ls->t.token == '}')
532		− break;
533		− exp1(ls);
	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);
534	569	n++;
535		− luaX_checklimit(ls, n/LFIELDS_PER_FLUSH, MAXARG_A,
536		− "`item groups' in a list initializer");
537		− if (n%LFIELDS_PER_FLUSH == 0)
538		− luaK_code2(fs, OP_SETLIST, n/LFIELDS_PER_FLUSH - 1, LFIELDS_PER_FLUSH);
539	570	}
540		− luaK_code2(fs, OP_SETLIST, n/LFIELDS_PER_FLUSH, n%LFIELDS_PER_FLUSH);
541	571	return n;
542	572	}
543	573
544	574
545		−
546		−static void constructor_part (LexState ls, Constdesc cd) {
	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;
547	580	switch (ls->t.token) {
548		− case ';': case '}': { /* constructor_part -> empty */
549		− cd->n = 0;
550		− cd->k = 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);
551	592	break;
552	593	}
553		− case TK_NAME: { /* may be listfields or recfields */
554		− lookahead(ls);
555		− if (ls->lookahead.token != '=') /* expression? */
556		− goto case_default;
557		− /* else go through to recfields */
558		− }
559		− case '[': { /* constructor_part -> recfields */
560		− cd->n = recfields(ls);
561		− cd->k = 1; /* record */
	594	+ case '{': { /* funcargs -> constructor */
	595	+ constructor(ls, &args);
562	596	break;
563	597	}
564		− default: { /* constructor_part -> listfields */
565		− case_default:
566		− cd->n = listfields(ls);
567		− cd->k = 0; /* list */
	598	+ case TK_STRING: { /* funcargs -> STRING */
	599	+ codestring(ls, &args, ls->t.seminfo.ts);
	600	+ next(ls); /* must use `seminfo' before `next' */
568	601	break;
569	602	}
	603	+ default: {
	604	+ luaX_syntaxerror(ls, "function arguments expected");
	605	+ return;
	606	+ }
570	607	}
571		−}
572		−
573		−
574		−static void constructor (LexState *ls) {
575		− /* constructor -> '{' constructor_part [';' constructor_part] '}' */
576		− FuncState *fs = ls->fs;
577		− int line = ls->linenumber;
578		− int pc = luaK_code1(fs, OP_CREATETABLE, 0);
579		− int nelems;
580		− Constdesc cd;
581		− check(ls, '{');
582		− constructor_part(ls, &cd);
583		− nelems = cd.n;
584		− if (optional(ls, ';')) {
585		− Constdesc other_cd;
586		− constructor_part(ls, &other_cd);
587		− check_condition(ls, (cd.k != other_cd.k), "invalid constructor syntax");
588		− nelems += other_cd.n;
	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);
589	616	}
590		− check_match(ls, '}', '{', line);
591		− luaX_checklimit(ls, nelems, MAXARG_U, "elements in a table constructor");
592		− SETARG_U(fs->f->code[pc], nelems); /* set initial table size */
	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 */
593	621	}
594	622
595		−/* }====================================================================== */
596		−
597	623
598	624
599	625
@@ -604,58 +630,121 @@ static void constructor (LexState *ls) { · 4 unmodified lines
604	630	*/
605	631
606	632
607		−static void simpleexp (LexState ls, expdesc v) {
608		− FuncState *fs = ls->fs;
	633	+static void prefixexp (LexState ls, expdesc v) {
	634	+ /* prefixexp -> NAME \| '(' expr ')' */
609	635	switch (ls->t.token) {
610		− case TK_NUMBER: { /* simpleexp -> NUMBER */
611		− Number r = ls->t.seminfo.r;
	636	+ case '(': {
	637	+ int line = ls->linenumber;
612	638	next(ls);
613		− luaK_number(fs, r);
	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' */
614	712	break;
615	713	}
616		− case TK_STRING: { /* simpleexp -> STRING */
617		− code_string(ls, ls->t.seminfo.ts); /* must use `seminfo' before `next' */
618		− next(ls);
	714	+ case TK_STRING: {
	715	+ codestring(ls, v, ls->t.seminfo.ts);
	716	+ next(ls); /* must use `seminfo' before `next' */
619	717	break;
620	718	}
621		− case TK_NIL: { /* simpleexp -> NIL */
622		− luaK_adjuststack(fs, -1);
	719	+ case TK_NIL: {
	720	+ init_exp(v, VNIL, 0);
623	721	next(ls);
624	722	break;
625	723	}
626		− case '{': { /* simpleexp -> constructor */
627		− constructor(ls);
	724	+ case TK_TRUE: {
	725	+ init_exp(v, VTRUE, 0);
	726	+ next(ls);
628	727	break;
629	728	}
630		− case TK_FUNCTION: { /* simpleexp -> FUNCTION body */
	729	+ case TK_FALSE: {
	730	+ init_exp(v, VFALSE, 0);
631	731	next(ls);
632		− body(ls, 0, ls->linenumber);
633	732	break;
634	733	}
635		− case '(': { /* simpleexp -> '(' expr ')' */
636		− next(ls);
637		− expr(ls, v);
638		− check(ls, ')');
639		− return;
	734	+ case '{': { /* constructor */
	735	+ constructor(ls, v);
	736	+ break;
640	737	}
641		− case TK_NAME: case '%': {
642		− var_or_func(ls, v);
643		− return;
	738	+ case TK_FUNCTION: {
	739	+ next(ls);
	740	+ body(ls, v, 0, ls->linenumber);
	741	+ break;
644	742	}
645	743	default: {
646		− luaK_error(ls, "<expression> expected");
647		− return;
	744	+ primaryexp(ls, v);
	745	+ break;
648	746	}
649	747	}
650		− v->k = VEXP;
651		− v->u.l.t = v->u.l.f = NO_JUMP;
652		−}
653		−
654		−
655		−static void exp1 (LexState *ls) {
656		− expdesc v;
657		− expr(ls, &v);
658		− luaK_tostack(ls, &v, 1);
659	748	}
660	749
661	750
@@ -690,17 +779,17 @@ static BinOpr getbinopr (int op) { · 28 unmodified lines
690	779
691	780
692	781	static const struct {
693		− char left; /* left priority for each binary operator */
694		− char right; /* right priority */
	782	+ lu_byte left; /* left priority for each binary operator */
	783	+ lu_byte right; /* right priority */
695	784	} priority[] = { /* ORDER OPR */
696		− {5, 5}, {5, 5}, {6, 6}, {6, 6}, /* arithmetic */
697		− {9, 8}, {4, 3}, /* power and concat (right associative) */
698		− {2, 2}, {2, 2}, /* equality */
699		− {2, 2}, {2, 2}, {2, 2}, {2, 2}, /* order */
700		− {1, 1}, {1, 1} /* logical */
	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) */
701	790	};
702	791
703		−#define UNARY_PRIORITY 7 /* priority for unary operators */
	792	+#define UNARY_PRIORITY 8 /* priority for unary operators */
704	793
705	794
706	795	/*
@@ -709,25 +798,28 @@ static const struct { · 2 unmodified lines
709	798	*/
710	799	static BinOpr subexpr (LexState ls, expdesc v, int limit) {
711	800	BinOpr op;
712		− UnOpr uop = getunopr(ls->t.token);
	801	+ UnOpr uop;
	802	+ enterlevel(ls);
	803	+ uop = getunopr(ls->t.token);
713	804	if (uop != OPR_NOUNOPR) {
714	805	next(ls);
715	806	subexpr(ls, v, UNARY_PRIORITY);
716		− luaK_prefix(ls, uop, v);
	807	+ luaK_prefix(ls->fs, uop, v);
717	808	}
718	809	else simpleexp(ls, v);
719	810	/* expand while operators have priorities higher than `limit' */
720	811	op = getbinopr(ls->t.token);
721		− while (op != OPR_NOBINOPR && priority[op].left > limit) {
	812	+ while (op != OPR_NOBINOPR && cast(int, priority[op].left) > limit) {
722	813	expdesc v2;
723	814	BinOpr nextop;
724	815	next(ls);
725		− luaK_infix(ls, op, v);
	816	+ luaK_infix(ls->fs, op, v);
726	817	/* read sub-expression with higher priority */
727		− nextop = subexpr(ls, &v2, priority[op].right);
728		− luaK_posfix(ls, op, v, &v2);
	818	+ nextop = subexpr(ls, &v2, cast(int, priority[op].right));
	819	+ luaK_posfix(ls->fs, op, v, &v2);
729	820	op = nextop;
730	821	}
	822	+ leavelevel(ls);
731	823	return op; /* return first untreated operator */
732	824	}
733	825
@@ -739,6 +831,7 @@ static void expr (LexState ls, expdesc v) { · 5 unmodified lines
739	831	/* }==================================================================== */
740	832
741	833
	834	+
742	835	/*
743	836	** {======================================================================
744	837	** Rules for Statements
@@ -759,61 +852,151 @@ static int block_follow (int token) { · 14 unmodified lines
759	852	static void block (LexState *ls) {
760	853	/* block -> chunk */
761	854	FuncState *fs = ls->fs;
762		− int nactloc = fs->nactloc;
	855	+ BlockCnt bl;
	856	+ enterblock(fs, &bl, 0);
763	857	chunk(ls);
764		− luaK_adjuststack(fs, fs->nactloc - nactloc); /* remove local variables */
765		− removelocalvars(ls, fs->nactloc - nactloc);
	858	+ lua_assert(bl.breaklist == NO_JUMP);
	859	+ leaveblock(fs);
766	860	}
767	861
768	862
769		−static int assignment (LexState ls, expdesc v, int nvars) {
770		− int left = 0; /* number of values left in the stack after assignment */
771		− luaX_checklimit(ls, nvars, MAXVARSLH, "variables in a multiple assignment");
772		− if (ls->t.token == ',') { /* assignment -> ',' NAME assignment */
773		− expdesc nv;
774		− next(ls);
775		− var_or_func(ls, &nv);
776		− check_condition(ls, (nv.k != VEXP), "syntax error");
777		− left = assignment(ls, &nv, nvars+1);
	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);
778	898	}
779		− else { /* assignment -> '=' explist1 */
	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 */
780	915	int nexps;
781	916	check(ls, '=');
782		− nexps = explist1(ls);
783		− adjust_mult_assign(ls, nvars, nexps);
784		− }
785		− if (v->k != VINDEXED)
786		− luaK_storevar(ls, v);
787		− else { /* there may be garbage between table-index and value */
788		− luaK_code2(ls->fs, OP_SETTABLE, left+nvars+2, 1);
789		− left += 2;
	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	+ }
790	928	}
791		− return left;
	929	+ init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */
	930	+ luaK_storevar(ls->fs, &lh->v, &e);
792	931	}
793	932
794	933
795	934	static void cond (LexState ls, expdesc v) {
796	935	/* cond -> exp */
797	936	expr(ls, v); /* read condition */
798		− luaK_goiftrue(ls->fs, v, 0);
	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);
799	940	}
800	941
801	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	+
802	961	static void whilestat (LexState *ls, int line) {
803	962	/* whilestat -> WHILE cond DO block END */
	963	+ Instruction codeexp[MAXEXPWHILE + EXTRAEXP];
	964	+ int lineexp;
	965	+ int i;
	966	+ int sizeexp;
804	967	FuncState *fs = ls->fs;
805		− int while_init = luaK_getlabel(fs);
	968	+ int whileinit, blockinit, expinit;
806	969	expdesc v;
807		− Breaklabel bl;
808		− enterbreak(fs, &bl);
809		− next(ls);
810		− cond(ls, &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);
811	987	check(ls, TK_DO);
	988	+ blockinit = luaK_getlabel(fs);
812	989	block(ls);
813		− luaK_patchlist(fs, luaK_jump(fs), while_init);
814		− luaK_patchlist(fs, v.u.l.f, luaK_getlabel(fs));
	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);
815	996	check_match(ls, TK_END, TK_WHILE, line);
816		− leavebreak(fs, &bl);
	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 */
817	1000	}
818	1001
819	1002
@@ -822,64 +1005,86 @@ static void repeatstat (LexState *ls, int line) { · 2 unmodified lines
822	1005	FuncState *fs = ls->fs;
823	1006	int repeat_init = luaK_getlabel(fs);
824	1007	expdesc v;
825		− Breaklabel bl;
826		− enterbreak(fs, &bl);
	1008	+ BlockCnt bl;
	1009	+ enterblock(fs, &bl, 1);
827	1010	next(ls);
828	1011	block(ls);
829	1012	check_match(ls, TK_UNTIL, TK_REPEAT, line);
830	1013	cond(ls, &v);
831		− luaK_patchlist(fs, v.u.l.f, repeat_init);
832		− leavebreak(fs, &bl);
	1014	+ luaK_patchlist(fs, v.f, repeat_init);
	1015	+ leaveblock(fs);
833	1016	}
834	1017
835	1018
836		−static void forbody (LexState *ls, int nvar, OpCode prepfor, OpCode loopfor) {
837		− /* forbody -> DO block END */
	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;
838	1031	FuncState *fs = ls->fs;
839		− int prep = luaK_code1(fs, prepfor, NO_JUMP);
840		− int blockinit = luaK_getlabel(fs);
	1032	+ int prep, endfor;
	1033	+ adjustlocalvars(ls, nvars); /* scope for all variables */
841	1034	check(ls, TK_DO);
842		− adjustlocalvars(ls, nvar); /* scope for control variables */
	1035	+ enterblock(fs, &bl, 1); /* loop block */
	1036	+ prep = luaK_getlabel(fs);
843	1037	block(ls);
844		− luaK_patchlist(fs, luaK_code1(fs, loopfor, NO_JUMP), blockinit);
845		− luaK_patchlist(fs, prep, luaK_getlabel(fs));
846		− removelocalvars(ls, nvar);
	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);
847	1044	}
848	1045
849	1046
850		−static void fornum (LexState ls, TString varname) {
851		− /* fornum -> NAME = exp1,exp1[,exp1] forbody */
	1047	+static void fornum (LexState ls, TString varname, int line) {
	1048	+ /* fornum -> NAME = exp1,exp1[,exp1] DO body */
852	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);
853	1054	check(ls, '=');
854	1055	exp1(ls); /* initial value */
855	1056	check(ls, ',');
856	1057	exp1(ls); /* limit */
857		− if (optional(ls, ','))
	1058	+ if (testnext(ls, ','))
858	1059	exp1(ls); /* optional step */
859		− else
860		− luaK_code1(fs, OP_PUSHINT, 1); /* default step */
861		− new_localvar(ls, varname, 0);
862		− new_localvarstr(ls, "(limit)", 1);
863		− new_localvarstr(ls, "(step)", 2);
864		− forbody(ls, 3, OP_FORPREP, OP_FORLOOP);
	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);
865	1067	}
866	1068
867	1069
868	1070	static void forlist (LexState ls, TString indexname) {
869		− /* forlist -> NAME,NAME IN exp1 forbody */
870		− TString *valname;
871		− check(ls, ',');
872		− valname = str_checkname(ls);
873		− /* next test is dirty, but avoids `in' being a reserved word */
874		− check_condition(ls,
875		− (ls->t.token == TK_NAME && ls->t.seminfo.ts == luaS_new(ls->L, "in")),
876		− "`in' expected");
877		− next(ls); /* skip `in' */
878		− exp1(ls); /* table */
879		− new_localvarstr(ls, "(table)", 0);
880		− new_localvar(ls, indexname, 1);
881		− new_localvar(ls, valname, 2);
882		− forbody(ls, 3, OP_LFORPREP, OP_LFORLOOP);
	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);
883	1088	}
884	1089
885	1090
@@ -887,17 +1092,17 @@ static void forstat (LexState *ls, int line) { · 1 unmodified line
887	1092	/* forstat -> fornum \| forlist */
888	1093	FuncState *fs = ls->fs;
889	1094	TString *varname;
890		− Breaklabel bl;
891		− enterbreak(fs, &bl);
	1095	+ BlockCnt bl;
	1096	+ enterblock(fs, &bl, 0); /* block to control variable scope */
892	1097	next(ls); /* skip `for' */
893	1098	varname = str_checkname(ls); /* first variable name */
894	1099	switch (ls->t.token) {
895		− case '=': fornum(ls, varname); break;
896		− case ',': forlist(ls, varname); break;
897		− default: luaK_error(ls, "`=' or `,' expected");
	1100	+ case '=': fornum(ls, varname, line); break;
	1101	+ case ',': case TK_IN: forlist(ls, varname); break;
	1102	+ default: luaX_syntaxerror(ls, "`=' or `in' expected");
898	1103	}
899	1104	check_match(ls, TK_END, TK_FOR, line);
900		− leavebreak(fs, &bl);
	1105	+ leaveblock(fs);
901	1106	}
902	1107
903	1108
@@ -918,49 +1123,60 @@ static void ifstat (LexState *ls, int line) { · 14 unmodified lines
918	1123	test_then_block(ls, &v); /* IF cond THEN block */
919	1124	while (ls->t.token == TK_ELSEIF) {
920	1125	luaK_concat(fs, &escapelist, luaK_jump(fs));
921		− luaK_patchlist(fs, v.u.l.f, luaK_getlabel(fs));
	1126	+ luaK_patchtohere(fs, v.f);
922	1127	test_then_block(ls, &v); /* ELSEIF cond THEN block */
923	1128	}
924	1129	if (ls->t.token == TK_ELSE) {
925	1130	luaK_concat(fs, &escapelist, luaK_jump(fs));
926		− luaK_patchlist(fs, v.u.l.f, luaK_getlabel(fs));
927		− next(ls); /* skip ELSE */
	1131	+ luaK_patchtohere(fs, v.f);
	1132	+ next(ls); /* skip ELSE (after patch, for correct line info) */
928	1133	block(ls); /* `else' part */
929	1134	}
930	1135	else
931		− luaK_concat(fs, &escapelist, v.u.l.f);
932		− luaK_patchlist(fs, escapelist, luaK_getlabel(fs));
	1136	+ luaK_concat(fs, &escapelist, v.f);
	1137	+ luaK_patchtohere(fs, escapelist);
933	1138	check_match(ls, TK_END, TK_IF, line);
934	1139	}
935	1140
936	1141
	1142	+static void localfunc (LexState *ls) {
	1143	+ expdesc v, b;
	1144	+ new_localvar(ls, str_checkname(ls), 0);
	1145	+ init_exp(&v, VLOCAL, ls->fs->freereg++);
	1146	+ adjustlocalvars(ls, 1);
	1147	+ body(ls, &b, 0, ls->linenumber);
	1148	+ luaK_storevar(ls->fs, &v, &b);
	1149	+}
	1150	+
	1151	+
937	1152	static void localstat (LexState *ls) {
938		− /* stat -> LOCAL NAME {',' NAME} ['=' explist1] */
	1153	+ /* stat -> LOCAL NAME {`,' NAME} [`=' explist1] */
939	1154	int nvars = 0;
940	1155	int nexps;
	1156	+ expdesc e;
941	1157	do {
942		− next(ls); /* skip LOCAL or ',' */
943	1158	new_localvar(ls, str_checkname(ls), nvars++);
944		− } while (ls->t.token == ',');
945		− if (optional(ls, '='))
946		− nexps = explist1(ls);
947		− else
	1159	+ } while (testnext(ls, ','));
	1160	+ if (testnext(ls, '='))
	1161	+ nexps = explist1(ls, &e);
	1162	+ else {
	1163	+ e.k = VVOID;
948	1164	nexps = 0;
949		− adjust_mult_assign(ls, nvars, nexps);
	1165	+ }
	1166	+ adjust_assign(ls, nvars, nexps, &e);
950	1167	adjustlocalvars(ls, nvars);
951	1168	}
952	1169
953	1170
954	1171	static int funcname (LexState ls, expdesc v) {
955		− /* funcname -> NAME [':' NAME \| '.' NAME] */
	1172	+ /* funcname -> NAME {field} [`:' NAME] */
956	1173	int needself = 0;
957		− singlevar(ls, str_checkname(ls), v);
958		− if (ls->t.token == ':' \|\| ls->t.token == '.') {
959		− needself = (ls->t.token == ':');
960		− next(ls);
961		− luaK_tostack(ls, v, 1);
962		− luaK_kstr(ls, checkname(ls));
963		− v->k = VINDEXED;
	1174	+ singlevar(ls, v, 1);
	1175	+ while (ls->t.token == '.')
	1176	+ luaY_field(ls, v);
	1177	+ if (ls->t.token == ':') {
	1178	+ needself = 1;
	1179	+ luaY_field(ls, v);
964	1180	}
965	1181	return needself;
966	1182	}
@@ -969,26 +1185,26 @@ static int funcname (LexState ls, expdesc v) { · 2 unmodified lines
969	1185	static void funcstat (LexState *ls, int line) {
970	1186	/* funcstat -> FUNCTION funcname body */
971	1187	int needself;
972		− expdesc v;
	1188	+ expdesc v, b;
973	1189	next(ls); /* skip FUNCTION */
974	1190	needself = funcname(ls, &v);
975		− body(ls, needself, line);
976		− luaK_storevar(ls, &v);
	1191	+ body(ls, &b, needself, line);
	1192	+ luaK_storevar(ls->fs, &v, &b);
	1193	+ luaK_fixline(ls->fs, line); /* definition `happens' in the first line */
977	1194	}
978	1195
979	1196
980		−static void namestat (LexState *ls) {
981		− /* stat -> func \| ['%'] NAME assignment */
	1197	+static void exprstat (LexState *ls) {
	1198	+ /* stat -> func \| assignment */
982	1199	FuncState *fs = ls->fs;
983		− expdesc v;
984		− var_or_func(ls, &v);
985		− if (v.k == VEXP) { /* stat -> func */
986		− check_condition(ls, luaK_lastisopen(fs), "syntax error"); /* an upvalue? */
987		− luaK_setcallreturns(fs, 0); /* call statement uses no results */
	1200	+ struct LHS_assign v;
	1201	+ primaryexp(ls, &v.v);
	1202	+ if (v.v.k == VCALL) { /* stat -> func */
	1203	+ luaK_setcallreturns(fs, &v.v, 0); /* call statement uses no results */
988	1204	}
989		− else { /* stat -> ['%'] NAME assignment */
990		− int left = assignment(ls, &v, 1);
991		− luaK_adjuststack(fs, left); /* remove eventual garbage left on stack */
	1205	+ else { /* stat -> assignment */
	1206	+ v.prev = NULL;
	1207	+ assignment(ls, &v, 1);
992	1208	}
993	1209	}
994	1210
@@ -996,30 +1212,55 @@ static void namestat (LexState *ls) { · 1 unmodified line
996	1212	static void retstat (LexState *ls) {
997	1213	/* stat -> RETURN explist */
998	1214	FuncState *fs = ls->fs;
	1215	+ expdesc e;
	1216	+ int first, nret; /* registers with returned values */
999	1217	next(ls); /* skip RETURN */
1000		− if (!block_follow(ls->t.token) && ls->t.token != ';')
1001		− explist1(ls); /* optional return values */
1002		− luaK_code1(fs, OP_RETURN, ls->fs->nactloc);
1003		− fs->stacklevel = fs->nactloc; /* removes all temp values */
	1218	+ if (block_follow(ls->t.token) \|\| ls->t.token == ';')
	1219	+ first = nret = 0; /* return no values */
	1220	+ else {
	1221	+ nret = explist1(ls, &e); /* optional return values */
	1222	+ if (e.k == VCALL) {
	1223	+ luaK_setcallreturns(fs, &e, LUA_MULTRET);
	1224	+ if (nret == 1) { /* tail call? */
	1225	+ SET_OPCODE(getcode(fs,&e), OP_TAILCALL);
	1226	+ lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar);
	1227	+ }
	1228	+ first = fs->nactvar;
	1229	+ nret = LUA_MULTRET; /* return all values */
	1230	+ }
	1231	+ else {
	1232	+ if (nret == 1) /* only one single value? */
	1233	+ first = luaK_exp2anyreg(fs, &e);
	1234	+ else {
	1235	+ luaK_exp2nextreg(fs, &e); /* values must go to the `stack' */
	1236	+ first = fs->nactvar; /* return all `active' values */
	1237	+ lua_assert(nret == fs->freereg - first);
	1238	+ }
	1239	+ }
	1240	+ }
	1241	+ luaK_codeABC(fs, OP_RETURN, first, nret+1, 0);
1004	1242	}
1005	1243
1006	1244
1007	1245	static void breakstat (LexState *ls) {
1008	1246	/* stat -> BREAK [NAME] */
1009	1247	FuncState *fs = ls->fs;
1010		− int currentlevel = fs->stacklevel;
1011		− Breaklabel *bl = fs->bl;
1012		− if (!bl)
1013		− luaK_error(ls, "no loop to break");
	1248	+ BlockCnt *bl = fs->bl;
	1249	+ int upval = 0;
1014	1250	next(ls); /* skip BREAK */
1015		− luaK_adjuststack(fs, currentlevel - bl->stacklevel);
	1251	+ while (bl && !bl->isbreakable) {
	1252	+ upval \|= bl->upval;
	1253	+ bl = bl->previous;
	1254	+ }
	1255	+ if (!bl)
	1256	+ luaX_syntaxerror(ls, "no loop to break");
	1257	+ if (upval)
	1258	+ luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
1016	1259	luaK_concat(fs, &bl->breaklist, luaK_jump(fs));
1017		− /* correct stack for compiler and symbolic execution */
1018		− luaK_adjuststack(fs, bl->stacklevel - currentlevel);
1019	1260	}
1020	1261
1021	1262
1022		−static int stat (LexState *ls) {
	1263	+static int statement (LexState *ls) {
1023	1264	int line = ls->linenumber; /* may be needed for error messages */
1024	1265	switch (ls->t.token) {
1025	1266	case TK_IF: { /* stat -> ifstat */
@@ -1044,16 +1285,16 @@ static int stat (LexState *ls) { · 18 unmodified lines
1044	1285	repeatstat(ls, line);
1045	1286	return 0;
1046	1287	}
1047		− case TK_FUNCTION: { /* stat -> funcstat */
1048		− funcstat(ls, line);
	1288	+ case TK_FUNCTION: {
	1289	+ funcstat(ls, line); /* stat -> funcstat */
1049	1290	return 0;
1050	1291	}
1051	1292	case TK_LOCAL: { /* stat -> localstat */
1052		− localstat(ls);
1053		− return 0;
1054		− }
1055		− case TK_NAME: case '%': { /* stat -> namestat */
1056		− namestat(ls);
	1293	+ next(ls); /* skip LOCAL */
	1294	+ if (testnext(ls, TK_FUNCTION)) /* local function? */
	1295	+ localfunc(ls);
	1296	+ else
	1297	+ localstat(ls);
1057	1298	return 0;
1058	1299	}
1059	1300	case TK_RETURN: { /* stat -> retstat */
@@ -1065,60 +1306,24 @@ static int stat (LexState *ls) { · 5 unmodified lines
1065	1306	return 1; /* must be last statement */
1066	1307	}
1067	1308	default: {
1068		− luaK_error(ls, "<statement> expected");
	1309	+ exprstat(ls);
1069	1310	return 0; /* to avoid warnings */
1070	1311	}
1071	1312	}
1072	1313	}
1073	1314
1074	1315
1075		−static void parlist (LexState *ls) {
1076		− /* parlist -> [ param { ',' param } ] */
1077		− int nparams = 0;
1078		− int dots = 0;
1079		− if (ls->t.token != ')') { /* is `parlist' not empty? */
1080		− do {
1081		− switch (ls->t.token) {
1082		− case TK_DOTS: next(ls); dots = 1; break;
1083		− case TK_NAME: new_localvar(ls, str_checkname(ls), nparams++); break;
1084		− default: luaK_error(ls, "<name> or `...' expected");
1085		− }
1086		− } while (!dots && optional(ls, ','));
1087		− }
1088		− code_params(ls, nparams, dots);
1089		−}
1090		−
1091		−
1092		−static void body (LexState *ls, int needself, int line) {
1093		− /* body -> '(' parlist ')' chunk END */
1094		− FuncState new_fs;
1095		− open_func(ls, &new_fs);
1096		− new_fs.f->lineDefined = line;
1097		− check(ls, '(');
1098		− if (needself) {
1099		− new_localvarstr(ls, "self", 0);
1100		− adjustlocalvars(ls, 1);
1101		− }
1102		− parlist(ls);
1103		− check(ls, ')');
1104		− chunk(ls);
1105		− check_match(ls, TK_END, TK_FUNCTION, line);
1106		− close_func(ls);
1107		− pushclosure(ls, &new_fs);
1108		−}
1109		−
1110		−
1111		−/* }====================================================================== */
1112		−
1113		−
1114	1316	static void chunk (LexState *ls) {
1115		− /* chunk -> { stat [';'] } */
	1317	+ /* chunk -> { stat [`;'] } */
1116	1318	int islast = 0;
	1319	+ enterlevel(ls);
1117	1320	while (!islast && !block_follow(ls->t.token)) {
1118		− islast = stat(ls);
1119		− optional(ls, ';');
1120		− LUA_ASSERT(ls->fs->stacklevel == ls->fs->nactloc,
1121		− "stack size != # local vars");
	1321	+ islast = statement(ls);
	1322	+ testnext(ls, ';');
	1323	+ lua_assert(ls->fs->freereg >= ls->fs->nactvar);
	1324	+ ls->fs->freereg = ls->fs->nactvar; /* free registers */
1122	1325	}
	1326	+ leavelevel(ls);
1123	1327	}
1124	1328
	1329	+/* }====================================================================== */

Lua 5.0

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code