lparser.c 45 KB

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