File: | deps/lua/src/lparser.c |
Warning: | line 986, column 32 Access to field 'nactvar' results in a dereference of a null pointer (loaded from variable 'bl') |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* | |||
2 | ** $Id: lparser.c,v 2.42.1.4 2011/10/21 19:31:42 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) ((k) == VCALL || (k) == VVARARG) | |||
31 | ||||
32 | #define getlocvar(fs, i)((fs)->f->locvars[(fs)->actvar[i]]) ((fs)->f->locvars[(fs)->actvar[i]]) | |||
33 | ||||
34 | #define luaY_checklimit(fs,v,l,m)if ((v)>(l)) errorlimit(fs,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)((const char *)((ts) + 1)), 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"'" "%s" "'" " 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); } { 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"'" "%s" "'" " expected (to close " LUA_QS"'" "%s" "'" " 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(-1); | |||
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,if ((fs->nlocvars)+1 > (f->sizelocvars)) ((f->locvars )=((LocVar *)(luaM_growaux_(ls->L,f->locvars,&(f-> sizelocvars),sizeof(LocVar),32767,"too many local variables") ))) | |||
148 | LocVar, SHRT_MAX, "too many local variables")if ((fs->nlocvars)+1 > (f->sizelocvars)) ((f->locvars )=((LocVar *)(luaM_growaux_(ls->L,f->locvars,&(f-> sizelocvars),sizeof(LocVar),32767,"too many local variables") ))); | |||
149 | while (oldsize < f->sizelocvars) f->locvars[oldsize++].varname = NULL((void*)0); | |||
150 | f->locvars[fs->nlocvars].varname = varname; | |||
151 | luaC_objbarrier(ls->L, f, varname){ if (((((((GCObject *)((varname)))))->gch.marked) & ( (((1<<(0)) | (1<<(1)))))) && ((((((GCObject *)((f)))))->gch.marked) & ((1<<(2))))) luaC_barrierf (ls->L,(((GCObject *)((f)))),(((GCObject *)((varname))))); }; | |||
152 | return fs->nlocvars++; | |||
153 | } | |||
154 | ||||
155 | ||||
156 | #define new_localvarliteral(ls,v,n)new_localvar(ls, luaX_newstring(ls, "" v, (sizeof(v)/sizeof(char ))-1), 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")if ((fs->nactvar+n+1)>(200)) errorlimit(fs,200,"local variables" ); | |||
163 | fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name))((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)((lu_byte)((fs->nactvar + nvars))); | |||
170 | for (; nvars; nvars--) { | |||
171 | getlocvar(fs, fs->nactvar - nvars)((fs)->f->locvars[(fs)->actvar[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)((fs)->f->locvars[(fs)->actvar[--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)((void)0); | |||
190 | return i; | |||
191 | } | |||
192 | } | |||
193 | /* new one */ | |||
194 | luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, "upvalues")if ((f->nups + 1)>(60)) errorlimit(fs,60,"upvalues"); | |||
195 | luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues,if ((f->nups)+1 > (f->sizeupvalues)) ((f->upvalues )=((TString * *)(luaM_growaux_(fs->L,f->upvalues,&( f->sizeupvalues),sizeof(TString *),(2147483647 -2),"")))) | |||
196 | TString *, MAX_INT, "")if ((f->nups)+1 > (f->sizeupvalues)) ((f->upvalues )=((TString * *)(luaM_growaux_(fs->L,f->upvalues,&( f->sizeupvalues),sizeof(TString *),(2147483647 -2),"")))); | |||
197 | while (oldsize < f->sizeupvalues) f->upvalues[oldsize++] = NULL((void*)0); | |||
198 | f->upvalues[f->nups] = name; | |||
199 | luaC_objbarrier(fs->L, f, name){ if (((((((GCObject *)((name)))))->gch.marked) & (((( 1<<(0)) | (1<<(1)))))) && ((((((GCObject * )((f)))))->gch.marked) & ((1<<(2))))) luaC_barrierf (fs->L,(((GCObject *)((f)))),(((GCObject *)((name))))); }; | |||
200 | lua_assert(v->k == VLOCAL || v->k == VUPVAL)((void)0); | |||
201 | fs->upvalues[f->nups].k = cast_byte(v->k)((lu_byte)((v->k))); | |||
202 | fs->upvalues[f->nups].info = cast_byte(v->u.s.info)((lu_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)((fs)->f->locvars[(fs)->actvar[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((void*)0)) { /* no more levels? */ | |||
226 | init_exp(var, VGLOBAL, NO_REG((1<<8)-1)); /* 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)((e->k) == VCALL || (e->k) == VVARARG)) { | |||
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_MAXCCALLS200) | |||
278 | luaX_lexerror(ls, "chunk has too many syntax levels", 0); | |||
279 | } | |||
280 | ||||
281 | ||||
282 | #define leavelevel(ls)((ls)->L->nCcalls--) ((ls)->L->nCcalls--) | |||
283 | ||||
284 | ||||
285 | static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) { | |||
286 | bl->breaklist = NO_JUMP(-1); | |||
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)((void)0); | |||
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)((void)0); | |||
304 | lua_assert(bl->nactvar == fs->nactvar)((void)0); | |||
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 *,if ((fs->np)+1 > (f->sizep)) ((f->p)=((Proto * *) (luaM_growaux_(ls->L,f->p,&(f->sizep),sizeof(Proto *),((1<<(9 + 9))-1),"constant table overflow")))) | |||
316 | MAXARG_Bx, "constant table overflow")if ((fs->np)+1 > (f->sizep)) ((f->p)=((Proto * *) (luaM_growaux_(ls->L,f->p,&(f->sizep),sizeof(Proto *),((1<<(9 + 9))-1),"constant table overflow")))); | |||
317 | while (oldsize < f->sizep) f->p[oldsize++] = NULL((void*)0); | |||
318 | f->p[fs->np++] = func->f; | |||
319 | luaC_objbarrier(ls->L, f, func->f){ if (((((((GCObject *)((func->f)))))->gch.marked) & ((((1<<(0)) | (1<<(1)))))) && ((((((GCObject *)((f)))))->gch.marked) & ((1<<(2))))) luaC_barrierf (ls->L,(((GCObject *)((f)))),(((GCObject *)((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(-1); | |||
339 | fs->freereg = 0; | |||
340 | fs->nk = 0; | |||
341 | fs->np = 0; | |||
342 | fs->nlocvars = 0; | |||
343 | fs->nactvar = 0; | |||
344 | fs->bl = NULL((void*)0); | |||
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){ TValue *i_o=(L->top); i_o->value.gc=((GCObject *)((fs ->h))); i_o->tt=5; ((void)0); }; | |||
350 | incr_top(L){if ((char *)L->stack_last - (char *)L->top <= (1)*( int)sizeof(TValue)) luaD_growstack(L, 1); else ((void)0);; L-> top++;}; | |||
351 | setptvalue2s(L, L->top, f){ TValue *i_o=(L->top); i_o->value.gc=((GCObject *)((f) )); i_o->tt=(8 +1); ((void)0); }; | |||
352 | incr_top(L){if ((char *)L->stack_last - (char *)L->top <= (1)*( int)sizeof(TValue)) luaD_growstack(L, 1); else ((void)0);; L-> top++;}; | |||
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)((f->code)=((Instruction *)(((((size_t)((fs->pc)+1)) <= ((size_t)(~(size_t)0)-2)/(sizeof(Instruction))) ? luaM_realloc_ (L, (f->code), (f->sizecode)*(sizeof(Instruction)), (fs ->pc)*(sizeof(Instruction))) : luaM_toobig(L))))); | |||
363 | f->sizecode = fs->pc; | |||
364 | luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int)((f->lineinfo)=((int *)(((((size_t)((fs->pc)+1)) <= ( (size_t)(~(size_t)0)-2)/(sizeof(int))) ? luaM_realloc_(L, (f-> lineinfo), (f->sizelineinfo)*(sizeof(int)), (fs->pc)*(sizeof (int))) : luaM_toobig(L))))); | |||
365 | f->sizelineinfo = fs->pc; | |||
366 | luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue)((f->k)=((TValue *)(((((size_t)((fs->nk)+1)) <= ((size_t )(~(size_t)0)-2)/(sizeof(TValue))) ? luaM_realloc_(L, (f-> k), (f->sizek)*(sizeof(TValue)), (fs->nk)*(sizeof(TValue ))) : luaM_toobig(L))))); | |||
367 | f->sizek = fs->nk; | |||
368 | luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *)((f->p)=((Proto * *)(((((size_t)((fs->np)+1)) <= ((size_t )(~(size_t)0)-2)/(sizeof(Proto *))) ? luaM_realloc_(L, (f-> p), (f->sizep)*(sizeof(Proto *)), (fs->np)*(sizeof(Proto *))) : luaM_toobig(L))))); | |||
369 | f->sizep = fs->np; | |||
370 | luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar)((f->locvars)=((LocVar *)(((((size_t)((fs->nlocvars)+1) ) <= ((size_t)(~(size_t)0)-2)/(sizeof(LocVar))) ? luaM_realloc_ (L, (f->locvars), (f->sizelocvars)*(sizeof(LocVar)), (fs ->nlocvars)*(sizeof(LocVar))) : luaM_toobig(L))))); | |||
371 | f->sizelocvars = fs->nlocvars; | |||
372 | luaM_reallocvector(L, f->upvalues, f->sizeupvalues, f->nups, TString *)((f->upvalues)=((TString * *)(((((size_t)((f->nups)+1)) <= ((size_t)(~(size_t)0)-2)/(sizeof(TString *))) ? luaM_realloc_ (L, (f->upvalues), (f->sizeupvalues)*(sizeof(TString *) ), (f->nups)*(sizeof(TString *))) : luaM_toobig(L))))); | |||
373 | f->sizeupvalues = f->nups; | |||
374 | lua_assert(luaG_checkcode(f))((void)0); | |||
375 | lua_assert(fs->bl == NULL)((void)0); | |||
376 | ls->fs = fs->prev; | |||
377 | /* last token read was anchored in defunct function; must reanchor it */ | |||
378 | if (fs) anchor_token(ls); | |||
379 | L->top -= 2; /* remove table and prototype from the stack */ | |||
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)(luaS_newlstr(L, name, strlen(name)))); | |||
388 | open_func(&lexstate, &funcstate); | |||
389 | funcstate.f->is_vararg = VARARG_ISVARARG2; /* 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)((void)0); | |||
395 | lua_assert(funcstate.f->nups == 0)((void)0); | |||
396 | lua_assert(lexstate.fs == NULL)((void)0); | |||
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")if ((cc->nh)>((2147483647 -2))) errorlimit(fs,(2147483647 -2),"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_FLUSH50) { | |||
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)((cc->v.k) == VCALL || (cc->v.k) == VVARARG)) { | |||
478 | luaK_setmultret(fs, &cc->v)luaK_setreturns(fs, &cc->v, (-1)); | |||
479 | luaK_setlist(fs, cc->t->u.s.info, cc->na, LUA_MULTRET(-1)); | |||
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")if ((cc->na)>((2147483647 -2))) errorlimit(ls->fs,(2147483647 -2),"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)((void)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))((fs->f->code[pc]) = (((fs->f->code[pc])&(~(( ~((~(Instruction)0)<<9))<<(((0 + 6) + 8) + 9)))) | ((((Instruction)(luaO_int2fb(cc.na)))<<(((0 + 6) + 8) + 9))&((~((~(Instruction)0)<<9))<<(((0 + 6) + 8 ) + 9))))); /* set initial array size */ | |||
536 | SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh))((fs->f->code[pc]) = (((fs->f->code[pc])&(~(( ~((~(Instruction)0)<<9))<<((0 + 6) + 8)))) | (((( Instruction)(luaO_int2fb(cc.nh)))<<((0 + 6) + 8))&( (~((~(Instruction)0)<<9))<<((0 + 6) + 8))))); /* 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++)new_localvar(ls, luaX_newstring(ls, "" "arg", (sizeof("arg")/ sizeof(char))-1), nparams++); | |||
561 | f->is_vararg = VARARG_HASARG1 | VARARG_NEEDSARG4; | |||
562 | #endif | |||
563 | f->is_vararg |= VARARG_ISVARARG2; | |||
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))((lu_byte)((fs->nactvar - (f->is_vararg & 1)))); | |||
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)new_localvar(ls, luaX_newstring(ls, "" "self", (sizeof("self" )/sizeof(char))-1), 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)luaK_setreturns(fs, &args, (-1)); | |||
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)((void)0); | |||
643 | base = f->u.s.info; /* base register for call */ | |||
644 | if (hasmultret(args.k)((args.k) == VCALL || (args.k) == VVARARG)) | |||
645 | nparams = LUA_MULTRET(-1); /* 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,{ if (!(fs->f->is_vararg)) luaX_syntaxerror(ls, "cannot use " "'" "..." "'" " outside a vararg function"); } | |||
755 | "cannot use " LUA_QL("...") " outside a vararg function"){ if (!(fs->f->is_vararg)) luaX_syntaxerror(ls, "cannot use " "'" "..." "'" " outside a vararg function"); }; | |||
756 | fs->f->is_vararg &= ~VARARG_NEEDSARG4; /* 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_PRIORITY8 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_PRIORITY8); | |||
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)((ls)->L->nCcalls--); | |||
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)((void)0); | |||
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,{ if (!(VLOCAL <= lh->v.k && lh->v.k <= VINDEXED )) luaX_syntaxerror(ls, "syntax error"); } | |||
934 | "syntax error"){ if (!(VLOCAL <= lh->v.k && lh->v.k <= VINDEXED )) luaX_syntaxerror(ls, "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,if ((nvars)>(200 - ls->L->nCcalls)) errorlimit(ls-> fs,200 - ls->L->nCcalls,"variables in assignment") | |||
942 | "variables in assignment")if ((nvars)>(200 - ls->L->nCcalls)) errorlimit(ls-> fs,200 - ls->L->nCcalls,"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_codeABx(fs,OP_FORPREP,base,((-1))+(((1<<(9 + 9))-1 )>>1)) : 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)luaK_codeABx(fs,OP_FORLOOP,base,((-1))+(((1<<(9 + 9))-1 )>>1)) : | |||
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)new_localvar(ls, luaX_newstring(ls, "" "(for index)", (sizeof ("(for index)")/sizeof(char))-1), 0); | |||
1072 | new_localvarliteral(ls, "(for limit)", 1)new_localvar(ls, luaX_newstring(ls, "" "(for limit)", (sizeof ("(for limit)")/sizeof(char))-1), 1); | |||
1073 | new_localvarliteral(ls, "(for step)", 2)new_localvar(ls, luaX_newstring(ls, "" "(for step)", (sizeof( "(for step)")/sizeof(char))-1), 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++)new_localvar(ls, luaX_newstring(ls, "" "(for generator)", (sizeof ("(for generator)")/sizeof(char))-1), nvars++); | |||
1098 | new_localvarliteral(ls, "(for state)", nvars++)new_localvar(ls, luaX_newstring(ls, "" "(for state)", (sizeof ("(for state)")/sizeof(char))-1), nvars++); | |||
1099 | new_localvarliteral(ls, "(for control)", nvars++)new_localvar(ls, luaX_newstring(ls, "" "(for control)", (sizeof ("(for control)")/sizeof(char))-1), 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")"'" "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(-1); | |||
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)((fs)->f->locvars[(fs)->actvar[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)((((fs)->f->code[(&v.v)->u.s.info])) = (((((fs)-> f->code[(&v.v)->u.s.info]))&(~((~((~(Instruction )0)<<9))<<((0 + 6) + 8)))) | ((((Instruction)(1)) <<((0 + 6) + 8))&((~((~(Instruction)0)<<9))<< ((0 + 6) + 8))))); /* call statement uses no results */ | |||
1231 | else { /* stat -> assignment */ | |||
1232 | v.prev = NULL((void*)0); | |||
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)((e.k) == VCALL || (e.k) == VVARARG)) { | |||
1249 | luaK_setmultret(fs, &e)luaK_setreturns(fs, &e, (-1)); | |||
1250 | if (e.k == VCALL && nret == 1) { /* tail call? */ | |||
1251 | SET_OPCODE(getcode(fs,&e), OP_TAILCALL)((((fs)->f->code[(&e)->u.s.info])) = (((((fs)-> f->code[(&e)->u.s.info]))&(~((~((~(Instruction) 0)<<6))<<0))) | ((((Instruction)(OP_TAILCALL))<< 0)&((~((~(Instruction)0)<<6))<<0)))); | |||
1252 | lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar)((void)0); | |||
1253 | } | |||
1254 | first = fs->nactvar; | |||
1255 | nret = LUA_MULTRET(-1); /* 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)((void)0); | |||
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
| |||
1330 | islast = statement(ls); | |||
1331 | testnext(ls, ';'); | |||
1332 | lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg &&((void)0) | |||
1333 | ls->fs->freereg >= ls->fs->nactvar)((void)0); | |||
1334 | ls->fs->freereg = ls->fs->nactvar; /* free registers */ | |||
1335 | } | |||
1336 | leavelevel(ls)((ls)->L->nCcalls--); | |||
1337 | } | |||
1338 | ||||
1339 | /* }====================================================================== */ |