One Level Up Top Level

userspace/kp_parse.c - ktap

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /*
  2. * ktap parser (source code -> bytecode).
  3. *
  4. * This file is part of ktap by Jovi Zhangwei.
  5. *
  6. * Copyright (C) 2012-2014 Jovi Zhangwei <jovi.zhangwei@gmail.com>.
  7. *
  8. * Adapted from luajit and lua interpreter.
  9. * Copyright (C) 2005-2014 Mike Pall.
  10. * Copyright (C) 1994-2008 Lua.org, PUC-Rio.
  11. *
  12. * ktap is free software; you can redistribute it and/or modify it
  13. * under the terms and conditions of the GNU General Public License,
  14. * version 2, as published by the Free Software Foundation.
  15. *
  16. * ktap is distributed in the hope it will be useful, but WITHOUT
  17. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18. * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  19. * more details.
  20. *
  21. * You should have received a copy of the GNU General Public License along with
  22. * this program; if not, write to the Free Software Foundation, Inc.,
  23. * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  24. */

  26. #include "../include/ktap_types.h"
  27. #include "../include/ktap_err.h"
  28. #include "kp_util.h"
  29. #include "kp_lex.h"

  31. /* Fixed internal variable names. */
  32. ‌#define VARNAMEDEF(_) \
  33.     _(FOR_IDX, "(for index)") \
  34.     _(FOR_STOP, "(for limit)") \
  35.     _(FOR_STEP, "(for step)") \
  36.     _(FOR_GEN, "(for generator)") \
  37.     _(FOR_STATE, "(for state)") \
  38.     _(FOR_CTL, "(for control)")

  40. enum {
  41.     VARNAME_END,
  42. ‌#define VARNAMEENUM(name, str)  VARNAME_##name,
  43.     VARNAMEDEF(VARNAMEENUM)
  44. ‌#undef VARNAMEENUM
  45.     VARNAME__MAX
  46. };

  48. /* -- Parser structures and definitions ----------------------------------- */

  50. /* Expression kinds. */
  51. typedef enum {
  52.     /* Constant expressions must be first and in this order: */
  53.     VKNIL,
  54.     VKFALSE,
  55.     VKTRUE,
  56.     VKSTR,    /* sval = string value */
  57.     VKNUM,    /* nval = number value */
  58.     VKLAST = VKNUM,
  59.     VKCDATA, /* nval = cdata value, not treated as a constant expression */
  60.     /* Non-constant expressions follow: */
  61.     VLOCAL,    /* info = local register, aux = vstack index */
  62.     VUPVAL,    /* info = upvalue index, aux = vstack index */
  63.     VGLOBAL,/* sval = string value */
  64.     VINDEXED,/* info = table register, aux = index reg/byte/string const */
  65.     VJMP,    /* info = instruction PC */
  66.     VRELOCABLE, /* info = instruction PC */
  67.     VNONRELOC, /* info = result register */
  68.     VCALL,    /* info = instruction PC, aux = base */
  69.     VVOID,

  71.     VARGN,
  72.     VARGSTR,
  73.     VARGNAME,
  74.     VPID,
  75.     VTID,
  76.     VUID,
  77.     VCPU,
  78.     VEXECNAME,
  79.     VMAX
  80. ‌} ExpKind;

  82. /* Expression descriptor. */
  83. ‌typedef struct ExpDesc {
  84.     union {
  85.         struct {
  86.             uint32_t info;    /* Primary info. */
  87.             uint32_t aux;    /* Secondary info. */
  88.         } s;
  89.         ktap_val_t nval;    /* Number value. */
  90.         ktap_str_t *sval;    /* String value. */
  91.     } u;
  92.     ExpKind k;
  93.     BCPos t;    /* True condition jump list. */
  94.     BCPos f;    /* False condition jump list. */
  95. ‌} ExpDesc;

  97. /* Macros for expressions. */
  98. ‌#define expr_hasjump(e)        ((e)->t != (e)->f)

  100. ‌#define expr_isk(e)        ((e)->k <= VKLAST)
  101. ‌#define expr_isk_nojump(e)    (expr_isk(e) && !expr_hasjump(e))
  102. ‌#define expr_isnumk(e)        ((e)->k == VKNUM)
  103. ‌#define expr_isnumk_nojump(e)    (expr_isnumk(e) && !expr_hasjump(e))
  104. ‌#define expr_isstrk(e)        ((e)->k == VKSTR)

  106. ‌#define expr_numtv(e)        (&(e)->u.nval)
  107. ‌#define expr_numberV(e)        nvalue(expr_numtv((e)))

  109. /* Initialize expression. */
  110. ‌static inline void expr_init(ExpDesc *e, ExpKind k, uint32_t info)
  111. {
  112.     e->k = k;
  113.     e->u.s.info = info;
  114.     e->f = e->t = NO_JMP;
  115. }

  117. /* Check number constant for +-0. */
  118. ‌static int expr_numiszero(ExpDesc *e)
  119. {
  120.     ktap_val_t *o = expr_numtv(e);
  121.     return (nvalue(o) == 0);
  122. }

  124. /* Per-function linked list of scope blocks. */
  125. ‌typedef struct FuncScope {
  126.     struct FuncScope *prev;    /* Link to outer scope. */
  127.     int vstart;        /* Start of block-local variables. */
  128.     uint8_t nactvar;    /* Number of active vars outside the scope. */
  129.     uint8_t flags;        /* Scope flags. */
  130. ‌} FuncScope;

  132. ‌#define FSCOPE_LOOP        0x01    /* Scope is a (breakable) loop. */
  133. ‌#define FSCOPE_BREAK        0x02    /* Break used in scope. */
  134. ‌#define FSCOPE_GOLA        0x04    /* Goto or label used in scope. */
  135. ‌#define FSCOPE_UPVAL        0x08    /* Upvalue in scope. */
  136. ‌#define FSCOPE_NOCLOSE        0x10    /* Do not close upvalues. */

  138. ‌#define NAME_BREAK        ((ktap_str_t *)(uintptr_t)1)

  140. /* Index into variable stack. */
  141. ‌typedef uint16_t VarIndex;
  142. ‌#define KP_MAX_VSTACK        (65536 - KP_MAX_UPVAL)

  144. /* Variable/goto/label info. */
  145. ‌#define VSTACK_VAR_RW        0x01    /* R/W variable. */
  146. ‌#define VSTACK_GOTO        0x02    /* Pending goto. */
  147. ‌#define VSTACK_LABEL        0x04    /* Label. */

  149. /* Per-function state. */
  150. ‌typedef struct FuncState {
  151.     ktap_tab_t *kt;        /* Hash table for constants. */
  152.     LexState *ls;        /* Lexer state. */
  153.     FuncScope *bl;        /* Current scope. */
  154.     struct FuncState *prev;    /* Enclosing function. */
  155.     BCPos pc;        /* Next bytecode position. */
  156.     BCPos lasttarget;    /* Bytecode position of last jump target. */
  157.     BCPos jpc;        /* Pending jump list to next bytecode. */
  158.     BCReg freereg;        /* First free register. */
  159.     BCReg nactvar;        /* Number of active local variables. */
  160.     BCReg nkn, nkgc;        /* Number of ktap_number/ktap_obj_t constants*/
  161.     BCLine linedefined;    /* First line of the function definition. */
  162.     BCInsLine *bcbase;    /* Base of bytecode stack. */
  163.     BCPos bclim;        /* Limit of bytecode stack. */
  164.     int vbase;        /* Base of variable stack for this function. */
  165.     uint8_t flags;        /* Prototype flags. */
  166.     uint8_t numparams;    /* Number of parameters. */
  167.     uint8_t framesize;    /* Fixed frame size. */
  168.     uint8_t nuv;        /* Number of upvalues */
  169.     VarIndex varmap[KP_MAX_LOCVAR];/* Map from register to variable idx. */
  170.     VarIndex uvmap[KP_MAX_UPVAL];    /* Map from upvalue to variable idx. */
  171.     VarIndex uvtmp[KP_MAX_UPVAL];    /* Temporary upvalue map. */
  172. ‌} FuncState;

  174. /* Binary and unary operators. ORDER OPR */
  175. ‌typedef enum BinOpr {
  176.     OPR_ADD, OPR_SUB, OPR_MUL, OPR_DIV, OPR_MOD, OPR_POW, /* ORDER ARITH */
  177.     OPR_CONCAT,
  178.     OPR_NE, OPR_EQ,
  179.     OPR_LT, OPR_GE, OPR_LE, OPR_GT,
  180.     OPR_AND, OPR_OR,
  181.     OPR_NOBINOPR
  182. ‌} BinOpr;

  184. KP_STATIC_ASSERT((int)BC_ISGE-(int)BC_ISLT == (int)OPR_GE-(int)OPR_LT);
  185. KP_STATIC_ASSERT((int)BC_ISLE-(int)BC_ISLT == (int)OPR_LE-(int)OPR_LT);
  186. KP_STATIC_ASSERT((int)BC_ISGT-(int)BC_ISLT == (int)OPR_GT-(int)OPR_LT);
  187. KP_STATIC_ASSERT((int)BC_SUBVV-(int)BC_ADDVV == (int)OPR_SUB-(int)OPR_ADD);
  188. KP_STATIC_ASSERT((int)BC_MULVV-(int)BC_ADDVV == (int)OPR_MUL-(int)OPR_ADD);
  189. KP_STATIC_ASSERT((int)BC_DIVVV-(int)BC_ADDVV == (int)OPR_DIV-(int)OPR_ADD);
  190. KP_STATIC_ASSERT((int)BC_MODVV-(int)BC_ADDVV == (int)OPR_MOD-(int)OPR_ADD);

  192. /* -- Error handling ------------------------------------------------------ */

  194. ‌static void err_syntax(LexState *ls, ErrMsg em)
  195. {
  196.     kp_lex_error(ls, ls->tok, em);
  197. }

  199. ‌static void err_token(LexState *ls, LexToken tok)
  200. {
  201.     kp_lex_error(ls, ls->tok, KP_ERR_XTOKEN, kp_lex_token2str(ls, tok));
  202. }

  204. ‌static void err_limit(FuncState *fs, uint32_t limit, const char *what)
  205. {
  206.     if (fs->linedefined == 0)
  207.         kp_lex_error(fs->ls, 0, KP_ERR_XLIMM, limit, what);
  208.     else
  209.         kp_lex_error(fs->ls, 0, KP_ERR_XLIMF, fs->linedefined,
  210.                 limit, what);
  211. }

  213. ‌#define checklimit(fs, v, l, m)        if ((v) >= (l)) err_limit(fs, l, m)
  214. ‌#define checklimitgt(fs, v, l, m)    if ((v) > (l)) err_limit(fs, l, m)
  215. ‌#define checkcond(ls, c, em)        { if (!(c)) err_syntax(ls, em); }

  217. /* -- Management of constants --------------------------------------------- */

  219. /* Return bytecode encoding for primitive constant. */
  220. ‌#define const_pri(e)    ((e)->k)

  222. ‌#define tvhaskslot(o)    (is_number(o))
  223. ‌#define tvkslot(o)    (nvalue(o))

  225. /* Add a number constant. */
  226. ‌static BCReg const_num(FuncState *fs, ExpDesc *e)
  227. {
  228.     ktap_val_t *o;

  230.     kp_assert(expr_isnumk(e));
  231.     o = kp_tab_set(fs->kt, &e->u.nval);
  232.     if (tvhaskslot(o))
  233.         return tvkslot(o);
  234.     set_number(o, fs->nkn);
  235.     return fs->nkn++;
  236. }

  238. /* Add a GC object constant. */
  239. ‌static BCReg const_gc(FuncState *fs, ktap_obj_t *gc, uint32_t itype)
  240. {
  241.     ktap_val_t key, *o;

  243.     setitype(&key, itype);
  244.     key.val.gc = gc;
  245.     o = kp_tab_set(fs->kt, &key);
  246.     if (tvhaskslot(o))
  247.         return tvkslot(o);
  248.     set_number(o, fs->nkgc);
  249.     return fs->nkgc++;
  250. }

  252. /* Add a string constant. */
  253. ‌static BCReg const_str(FuncState *fs, ExpDesc *e)
  254. {
  255.     kp_assert(expr_isstrk(e) || e->k == VGLOBAL);
  256.     return const_gc(fs, obj2gco(e->u.sval), KTAP_TSTR);
  257. }

  259. /* Anchor string constant. */
  260. ‌ktap_str_t *kp_parse_keepstr(LexState *ls, const char *str, size_t len)
  261. {
  262.     ktap_val_t v;
  263.     ktap_str_t *s = kp_str_new(str, len);

  265.     set_string(&v, s);
  266.     ktap_val_t *tv = kp_tab_set(ls->fs->kt, &v);
  267.     if (is_nil(tv))
  268.         set_bool(tv, 1);
  269.     return s;
  270. }

  272. /* -- Jump list handling -------------------------------------------------- */

  274. /* Get next element in jump list. */
  275. ‌static BCPos jmp_next(FuncState *fs, BCPos pc)
  276. {
  277.     ptrdiff_t delta = bc_j(fs->bcbase[pc].ins);
  278.     if ((BCPos)delta == NO_JMP)
  279.         return NO_JMP;
  280.     else
  281.         return (BCPos)(((ptrdiff_t)pc+1)+delta);
  282. }

  284. /* Check if any of the instructions on the jump list produce no value. */
  285. ‌static int jmp_novalue(FuncState *fs, BCPos list)
  286. {
  287.     for (; list != NO_JMP; list = jmp_next(fs, list)) {
  288.         BCIns p = fs->bcbase[list >= 1 ? list-1 : list].ins;
  289.         if (!(bc_op(p) == BC_ISTC || bc_op(p) == BC_ISFC ||
  290.             bc_a(p) == NO_REG))
  291.         return 1;
  292.     }
  293.     return 0;
  294. }

  296. /* Patch register of test instructions. */
  297. ‌static int jmp_patchtestreg(FuncState *fs, BCPos pc, BCReg reg)
  298. {
  299.     BCInsLine *ilp = &fs->bcbase[pc >= 1 ? pc-1 : pc];
  300.     BCOp op = bc_op(ilp->ins);

  302.     if (op == BC_ISTC || op == BC_ISFC) {
  303.         if (reg != NO_REG && reg != bc_d(ilp->ins)) {
  304.             setbc_a(&ilp->ins, reg);
  305.         } else {/* Nothing to store or already in the right register */
  306.             setbc_op(&ilp->ins, op+(BC_IST-BC_ISTC));
  307.             setbc_a(&ilp->ins, 0);
  308.         }
  309.     } else if (bc_a(ilp->ins) == NO_REG) {
  310.         if (reg == NO_REG) {
  311.             ilp->ins =
  312.                 BCINS_AJ(BC_JMP, bc_a(fs->bcbase[pc].ins), 0);
  313.         } else {
  314.             setbc_a(&ilp->ins, reg);
  315.             if (reg >= bc_a(ilp[1].ins))
  316.                 setbc_a(&ilp[1].ins, reg+1);
  317.         }
  318.     } else {
  319.         return 0;  /* Cannot patch other instructions. */
  320.     }
  321.     return 1;
  322. }

  324. /* Drop values for all instructions on jump list. */
  325. ‌static void jmp_dropval(FuncState *fs, BCPos list)
  326. {
  327.     for (; list != NO_JMP; list = jmp_next(fs, list))
  328.         jmp_patchtestreg(fs, list, NO_REG);
  329. }

  331. /* Patch jump instruction to target. */
  332. ‌static void jmp_patchins(FuncState *fs, BCPos pc, BCPos dest)
  333. {
  334.     BCIns *jmp = &fs->bcbase[pc].ins;
  335.     BCPos offset = dest-(pc+1)+BCBIAS_J;

  337.     kp_assert(dest != NO_JMP);
  338.     if (offset > BCMAX_D)
  339.         err_syntax(fs->ls, KP_ERR_XJUMP);
  340.     setbc_d(jmp, offset);
  341. }

  343. /* Append to jump list. */
  344. ‌static void jmp_append(FuncState *fs, BCPos *l1, BCPos l2)
  345. {
  346.     if (l2 == NO_JMP) {
  347.         return;
  348.     } else if (*l1 == NO_JMP) {
  349.         *l1 = l2;
  350.     } else {
  351.         BCPos list = *l1;
  352.         BCPos next;
  353.         /* Find last element. */
  354.         while ((next = jmp_next(fs, list)) != NO_JMP)
  355.             list = next;
  356.         jmp_patchins(fs, list, l2);
  357.     }
  358. }

  360. /* Patch jump list and preserve produced values. */
  361. ‌static void jmp_patchval(FuncState *fs, BCPos list, BCPos vtarget,
  362.              BCReg reg, BCPos dtarget)
  363. {
  364.     while (list != NO_JMP) {
  365.         BCPos next = jmp_next(fs, list);
  366.         if (jmp_patchtestreg(fs, list, reg)) {
  367.             /* Jump to target with value. */
  368.             jmp_patchins(fs, list, vtarget);
  369.         } else {
  370.             /* Jump to default target. */
  371.             jmp_patchins(fs, list, dtarget);
  372.         }
  373.         list = next;
  374.     }
  375. }

  377. /* Jump to following instruction. Append to list of pending jumps. */
  378. ‌static void jmp_tohere(FuncState *fs, BCPos list)
  379. {
  380.     fs->lasttarget = fs->pc;
  381.     jmp_append(fs, &fs->jpc, list);
  382. }

  384. /* Patch jump list to target. */
  385. ‌static void jmp_patch(FuncState *fs, BCPos list, BCPos target)
  386. {
  387.     if (target == fs->pc) {
  388.         jmp_tohere(fs, list);
  389.     } else {
  390.         kp_assert(target < fs->pc);
  391.         jmp_patchval(fs, list, target, NO_REG, target);
  392.     }
  393. }

  395. /* -- Bytecode register allocator ----------------------------------------- */

  397. /* Bump frame size. */
  398. ‌static void bcreg_bump(FuncState *fs, BCReg n)
  399. {
  400.     BCReg sz = fs->freereg + n;

  402.     if (sz > fs->framesize) {
  403.         if (sz >= KP_MAX_SLOTS)
  404.             err_syntax(fs->ls, KP_ERR_XSLOTS);
  405.         fs->framesize = (uint8_t)sz;
  406.     }
  407. }

  409. /* Reserve registers. */
  410. ‌static void bcreg_reserve(FuncState *fs, BCReg n)
  411. {
  412.     bcreg_bump(fs, n);
  413.     fs->freereg += n;
  414. }

  416. /* Free register. */
  417. ‌static void bcreg_free(FuncState *fs, BCReg reg)
  418. {
  419.     if (reg >= fs->nactvar) {
  420.         fs->freereg--;
  421.         kp_assert(reg == fs->freereg);
  422.     }
  423. }

  425. /* Free register for expression. */
  426. ‌static void expr_free(FuncState *fs, ExpDesc *e)
  427. {
  428.     if (e->k == VNONRELOC)
  429.         bcreg_free(fs, e->u.s.info);
  430. }

  432. /* -- Bytecode emitter ---------------------------------------------------- */

  434. /* Emit bytecode instruction. */
  435. ‌static BCPos bcemit_INS(FuncState *fs, BCIns ins)
  436. {
  437.     BCPos pc = fs->pc;
  438.     LexState *ls = fs->ls;

  440.     jmp_patchval(fs, fs->jpc, pc, NO_REG, pc);
  441.     fs->jpc = NO_JMP;
  442.     if (pc >= fs->bclim) {
  443.         ptrdiff_t base = fs->bcbase - ls->bcstack;
  444.         checklimit(fs, ls->sizebcstack, KP_MAX_BCINS,
  445.                 "bytecode instructions");
  446.         if (!ls->bcstack) {
  447.             ls->bcstack = malloc(sizeof(BCInsLine) * 20);
  448.             ls->sizebcstack = 20;
  449.         } else {
  450.             ls->bcstack = realloc(ls->bcstack,
  451.                 ls->sizebcstack * sizeof(BCInsLine) * 2);
  452.             ls->sizebcstack = ls->sizebcstack * 2;
  453.         }
  454.         fs->bclim = (BCPos)(ls->sizebcstack - base);
  455.         fs->bcbase = ls->bcstack + base;
  456.     }
  457.     fs->bcbase[pc].ins = ins;
  458.     fs->bcbase[pc].line = ls->lastline;
  459.     fs->pc = pc+1;
  460.     return pc;
  461. }

  463. ‌#define bcemit_ABC(fs, o, a, b, c)    bcemit_INS(fs, BCINS_ABC(o, a, b, c))
  464. ‌#define bcemit_AD(fs, o, a, d)        bcemit_INS(fs, BCINS_AD(o, a, d))
  465. ‌#define bcemit_AJ(fs, o, a, j)        bcemit_INS(fs, BCINS_AJ(o, a, j))

  467. ‌#define bcptr(fs, e)            (&(fs)->bcbase[(e)->u.s.info].ins)

  469. /* -- Bytecode emitter for expressions ------------------------------------ */

  471. /* Discharge non-constant expression to any register. */
  472. ‌static void expr_discharge(FuncState *fs, ExpDesc *e)
  473. {
  474.     BCIns ins;

  476.     if (e->k == VUPVAL) {
  477.         ins = BCINS_AD(BC_UGET, 0, e->u.s.info);
  478.     } else if (e->k == VGLOBAL) {
  479.         ins = BCINS_AD(BC_GGET, 0, const_str(fs, e));
  480.     } else if (e->k == VINDEXED) {
  481.         BCReg rc = e->u.s.aux;
  482.         if ((int32_t)rc < 0) {
  483.             ins = BCINS_ABC(BC_TGETS, 0, e->u.s.info, ~rc);
  484.         } else if (rc > BCMAX_C) {
  485.             ins = BCINS_ABC(BC_TGETB, 0, e->u.s.info,
  486.                     rc-(BCMAX_C+1));
  487.         } else {
  488.             bcreg_free(fs, rc);
  489.             ins = BCINS_ABC(BC_TGETV, 0, e->u.s.info, rc);
  490.         }
  491.         bcreg_free(fs, e->u.s.info);
  492.     } else if (e->k == VCALL) {
  493.         e->u.s.info = e->u.s.aux;
  494.         e->k = VNONRELOC;
  495.         return;
  496.     } else if (e->k == VLOCAL) {
  497.         e->k = VNONRELOC;
  498.         return;
  499.     } else {
  500.         return;
  501.     }

  503.     e->u.s.info = bcemit_INS(fs, ins);
  504.     e->k = VRELOCABLE;
  505. }

  507. /* Emit bytecode to set a range of registers to nil. */
  508. ‌static void bcemit_nil(FuncState *fs, BCReg from, BCReg n)
  509. {
  510.     if (fs->pc > fs->lasttarget) {  /* No jumps to current position? */
  511.         BCIns *ip = &fs->bcbase[fs->pc-1].ins;
  512.         BCReg pto, pfrom = bc_a(*ip);
  513.         /* Try to merge with the previous instruction. */
  514.         switch (bc_op(*ip)) {
  515.         case BC_KPRI:
  516.             if (bc_d(*ip) != ~KTAP_TNIL) break;
  517.             if (from == pfrom) {
  518.                 if (n == 1)
  519.                     return;
  520.             } else if (from == pfrom+1) {
  521.                 from = pfrom;
  522.                 n++;
  523.             } else {
  524.                 break;
  525.             }
  526.             /* Replace KPRI. */
  527.             *ip = BCINS_AD(BC_KNIL, from, from+n-1);
  528.             return;
  529.         case BC_KNIL:
  530.             pto = bc_d(*ip);
  531.             /* Can we connect both ranges? */
  532.             if (pfrom <= from && from <= pto+1) {
  533.                 if (from+n-1 > pto) {
  534.                     /* Patch previous instruction range. */
  535.                     setbc_d(ip, from+n-1);
  536.                 }
  537.                 return;
  538.             }
  539.             break;
  540.         default:
  541.             break;
  542.         }
  543.     }

  545.     /* Emit new instruction or replace old instruction. */
  546.     bcemit_INS(fs, n == 1 ? BCINS_AD(BC_KPRI, from, VKNIL) :
  547.                 BCINS_AD(BC_KNIL, from, from+n-1));
  548. }

  550. /* Discharge an expression to a specific register. Ignore branches. */
  551. ‌static void expr_toreg_nobranch(FuncState *fs, ExpDesc *e, BCReg reg)
  552. {
  553.     BCIns ins;

  555.     expr_discharge(fs, e);
  556.     if (e->k == VKSTR) {
  557.         ins = BCINS_AD(BC_KSTR, reg, const_str(fs, e));
  558.     } else if (e->k == VKNUM) {
  559.         ktap_number n = expr_numberV(e);
  560.         if (n >= 0 && n <= 0xffff) {
  561.             ins = BCINS_AD(BC_KSHORT, reg, (BCReg)(uint16_t)n);
  562.         } else
  563.             ins = BCINS_AD(BC_KNUM, reg, const_num(fs, e));
  564.     } else if (e->k == VRELOCABLE) {
  565.         setbc_a(bcptr(fs, e), reg);
  566.         goto noins;
  567.     } else if (e->k == VNONRELOC) {
  568.         if (reg == e->u.s.info)
  569.             goto noins;
  570.         ins = BCINS_AD(BC_MOV, reg, e->u.s.info);
  571.     } else if (e->k == VKNIL) {
  572.         bcemit_nil(fs, reg, 1);
  573.         goto noins;
  574.     } else if (e->k <= VKTRUE) {
  575.         ins = BCINS_AD(BC_KPRI, reg, const_pri(e));
  576.     } else if (e->k == VARGN) {
  577.         ins = BCINS_AD(BC_VARGN, reg, e->u.s.info);
  578.     } else if (e->k > VARGN && e->k < VMAX) {
  579.         ins = BCINS_AD(e->k - VARGN + BC_VARGN, reg, 0);
  580.     } else {
  581.         kp_assert(e->k == VVOID || e->k == VJMP);
  582.         return;
  583.     }
  584.     bcemit_INS(fs, ins);
  585. noins:
  586.     e->u.s.info = reg;
  587.     e->k = VNONRELOC;
  588. }

  590. /* Forward declaration. */
  591. static BCPos bcemit_jmp(FuncState *fs);

  593. /* Discharge an expression to a specific register. */
  594. ‌static void expr_toreg(FuncState *fs, ExpDesc *e, BCReg reg)
  595. {
  596.     expr_toreg_nobranch(fs, e, reg);
  597.     if (e->k == VJMP) {
  598.         /* Add it to the true jump list. */
  599.         jmp_append(fs, &e->t, e->u.s.info);
  600.     }
  601.     if (expr_hasjump(e)) {  /* Discharge expression with branches. */
  602.         BCPos jend, jfalse = NO_JMP, jtrue = NO_JMP;
  603.         if (jmp_novalue(fs, e->t) || jmp_novalue(fs, e->f)) {
  604.             BCPos jval = (e->k == VJMP) ? NO_JMP : bcemit_jmp(fs);
  605.             jfalse = bcemit_AD(fs, BC_KPRI, reg, VKFALSE);
  606.             bcemit_AJ(fs, BC_JMP, fs->freereg, 1);
  607.             jtrue = bcemit_AD(fs, BC_KPRI, reg, VKTRUE);
  608.             jmp_tohere(fs, jval);
  609.         }
  610.         jend = fs->pc;
  611.         fs->lasttarget = jend;
  612.         jmp_patchval(fs, e->f, jend, reg, jfalse);
  613.         jmp_patchval(fs, e->t, jend, reg, jtrue);
  614.     }
  615.     e->f = e->t = NO_JMP;
  616.     e->u.s.info = reg;
  617.     e->k = VNONRELOC;
  618. }

  620. /* Discharge an expression to the next free register. */
  621. ‌static void expr_tonextreg(FuncState *fs, ExpDesc *e)
  622. {
  623.     expr_discharge(fs, e);
  624.     expr_free(fs, e);
  625.     bcreg_reserve(fs, 1);
  626.     expr_toreg(fs, e, fs->freereg - 1);
  627. }

  629. /* Discharge an expression to any register. */
  630. ‌static BCReg expr_toanyreg(FuncState *fs, ExpDesc *e)
  631. {
  632.     expr_discharge(fs, e);
  633.     if (e->k == VNONRELOC) {
  634.         if (!expr_hasjump(e))
  635.             return e->u.s.info;  /* Already in a register. */
  636.         if (e->u.s.info >= fs->nactvar) {
  637.             /* Discharge to temp. register. */
  638.             expr_toreg(fs, e, e->u.s.info);
  639.             return e->u.s.info;
  640.         }
  641.     }
  642.     expr_tonextreg(fs, e);  /* Discharge to next register. */
  643.     return e->u.s.info;
  644. }

  646. /* Partially discharge expression to a value. */
  647. ‌static void expr_toval(FuncState *fs, ExpDesc *e)
  648. {
  649.     if (expr_hasjump(e))
  650.         expr_toanyreg(fs, e);
  651.     else
  652.         expr_discharge(fs, e);
  653. }

  655. /* Emit store for LHS expression. */
  656. ‌static void bcemit_store(FuncState *fs, ExpDesc *var, ExpDesc *e)
  657. {
  658.     BCIns ins;

  660.     if (var->k == VLOCAL) {
  661.         fs->ls->vstack[var->u.s.aux].info |= VSTACK_VAR_RW;
  662.         expr_free(fs, e);
  663.         expr_toreg(fs, e, var->u.s.info);
  664.         return;
  665.     } else if (var->k == VUPVAL) {
  666.         fs->ls->vstack[var->u.s.aux].info |= VSTACK_VAR_RW;
  667.         expr_toval(fs, e);
  668.         if (e->k <= VKTRUE)
  669.             ins = BCINS_AD(BC_USETP, var->u.s.info, const_pri(e));
  670.         else if (e->k == VKSTR)
  671.             ins = BCINS_AD(BC_USETS, var->u.s.info,
  672.                     const_str(fs, e));
  673.         else if (e->k == VKNUM)
  674.             ins = BCINS_AD(BC_USETN, var->u.s.info,
  675.                     const_num(fs, e));
  676.         else
  677.             ins = BCINS_AD(BC_USETV, var->u.s.info,
  678.                     expr_toanyreg(fs, e));
  679.     } else if (var->k == VGLOBAL) {
  680.         BCReg ra = expr_toanyreg(fs, e);
  681.         ins = BCINS_AD(BC_GSET, ra, const_str(fs, var));
  682.     } else {
  683.         BCReg ra, rc;
  684.         kp_assert(var->k == VINDEXED);
  685.         ra = expr_toanyreg(fs, e);
  686.         rc = var->u.s.aux;
  687.         if ((int32_t)rc < 0) {
  688.             ins = BCINS_ABC(BC_TSETS, ra, var->u.s.info, ~rc);
  689.         } else if (rc > BCMAX_C) {
  690.             ins = BCINS_ABC(BC_TSETB, ra, var->u.s.info,
  691.                 rc-(BCMAX_C+1));
  692.         } else {
  693.             /*
  694.              * Free late alloced key reg to avoid assert on
  695.              * free of value reg. This can only happen when
  696.              * called from expr_table().
  697.              */
  698.             kp_assert(e->k != VNONRELOC || ra < fs->nactvar ||
  699.                     rc < ra || (bcreg_free(fs, rc),1));
  700.             ins = BCINS_ABC(BC_TSETV, ra, var->u.s.info, rc);
  701.         }
  702.     }
  703.     bcemit_INS(fs, ins);
  704.     expr_free(fs, e);
  705. }

  707. /* Emit store for '+=' expression. */
  708. ‌static void bcemit_store_incr(FuncState *fs, ExpDesc *var, ExpDesc *e)
  709. {
  710.     BCIns ins;

  712.     if (var->k == VLOCAL) {
  713.         /* don't need to do like "var a=0; a+=1", just use 'a=a+1' */
  714.         err_syntax(fs->ls, KP_ERR_XSYMBOL);
  715.         return;
  716.     } else if (var->k == VUPVAL) {
  717.         fs->ls->vstack[var->u.s.aux].info |= VSTACK_VAR_RW;
  718.         expr_toval(fs, e);
  719.         if (e->k == VKNUM) {
  720.             ins = BCINS_AD(BC_UINCN, var->u.s.info,
  721.                     const_num(fs, e));
  722.         } else if (e->k <= VKTRUE || e->k == VKSTR) {
  723.             err_syntax(fs->ls, KP_ERR_XSYMBOL);
  724.             return;
  725.         } else
  726.             ins = BCINS_AD(BC_UINCV, var->u.s.info,
  727.                     expr_toanyreg(fs, e));
  728.     } else if (var->k == VGLOBAL) {
  729.         BCReg ra = expr_toanyreg(fs, e);
  730.         ins = BCINS_AD(BC_GINC, ra, const_str(fs, var));
  731.     } else {
  732.         BCReg ra, rc;
  733.         kp_assert(var->k == VINDEXED);
  734.         ra = expr_toanyreg(fs, e);
  735.         rc = var->u.s.aux;
  736.         if ((int32_t)rc < 0) {
  737.             ins = BCINS_ABC(BC_TINCS, ra, var->u.s.info, ~rc);
  738.         } else if (rc > BCMAX_C) {
  739.             ins = BCINS_ABC(BC_TINCB, ra, var->u.s.info,
  740.                 rc-(BCMAX_C+1));
  741.         } else {
  742.             /*
  743.              * Free late alloced key reg to avoid assert on
  744.              * free of value reg. This can only happen when
  745.              * called from expr_table().
  746.              */
  747.             kp_assert(e->k != VNONRELOC || ra < fs->nactvar ||
  748.                     rc < ra || (bcreg_free(fs, rc),1));
  749.             ins = BCINS_ABC(BC_TINCV, ra, var->u.s.info, rc);
  750.         }
  751.     }
  752.     bcemit_INS(fs, ins);
  753.     expr_free(fs, e);
  754. }


  757. /* Emit method lookup expression. */
  758. ‌static void bcemit_method(FuncState *fs, ExpDesc *e, ExpDesc *key)
  759. {
  760.     BCReg idx, func, obj = expr_toanyreg(fs, e);

  762.     expr_free(fs, e);
  763.     func = fs->freereg;
  764.     bcemit_AD(fs, BC_MOV, func+1, obj);/* Copy object to first argument. */
  765.     kp_assert(expr_isstrk(key));
  766.     idx = const_str(fs, key);
  767.     if (idx <= BCMAX_C) {
  768.         bcreg_reserve(fs, 2);
  769.         bcemit_ABC(fs, BC_TGETS, func, obj, idx);
  770.     } else {
  771.         bcreg_reserve(fs, 3);
  772.         bcemit_AD(fs, BC_KSTR, func+2, idx);
  773.         bcemit_ABC(fs, BC_TGETV, func, obj, func+2);
  774.         fs->freereg--;
  775.     }
  776.     e->u.s.info = func;
  777.     e->k = VNONRELOC;
  778. }

  780. /* -- Bytecode emitter for branches --------------------------------------- */

  782. /* Emit unconditional branch. */
  783. ‌static BCPos bcemit_jmp(FuncState *fs)
  784. {
  785.     BCPos jpc = fs->jpc;
  786.     BCPos j = fs->pc - 1;
  787.     BCIns *ip = &fs->bcbase[j].ins;

  789.     fs->jpc = NO_JMP;
  790.     if ((int32_t)j >= (int32_t)fs->lasttarget && bc_op(*ip) == BC_UCLO)
  791.         setbc_j(ip, NO_JMP);
  792.     else
  793.         j = bcemit_AJ(fs, BC_JMP, fs->freereg, NO_JMP);
  794.     jmp_append(fs, &j, jpc);
  795.     return j;
  796. }

  798. /* Invert branch condition of bytecode instruction. */
  799. ‌static void invertcond(FuncState *fs, ExpDesc *e)
  800. {
  801.     BCIns *ip = &fs->bcbase[e->u.s.info - 1].ins;
  802.     setbc_op(ip, bc_op(*ip)^1);
  803. }

  805. /* Emit conditional branch. */
  806. ‌static BCPos bcemit_branch(FuncState *fs, ExpDesc *e, int cond)
  807. {
  808.     BCPos pc;

  810.     if (e->k == VRELOCABLE) {
  811.         BCIns *ip = bcptr(fs, e);
  812.         if (bc_op(*ip) == BC_NOT) {
  813.             *ip = BCINS_AD(cond ? BC_ISF : BC_IST, 0, bc_d(*ip));
  814.             return bcemit_jmp(fs);
  815.         }
  816.     }
  817.     if (e->k != VNONRELOC) {
  818.         bcreg_reserve(fs, 1);
  819.         expr_toreg_nobranch(fs, e, fs->freereg-1);
  820.     }
  821.     bcemit_AD(fs, cond ? BC_ISTC : BC_ISFC, NO_REG, e->u.s.info);
  822.     pc = bcemit_jmp(fs);
  823.     expr_free(fs, e);
  824.     return pc;
  825. }

  827. /* Emit branch on true condition. */
  828. ‌static void bcemit_branch_t(FuncState *fs, ExpDesc *e)
  829. {
  830.     BCPos pc;

  832.     expr_discharge(fs, e);
  833.     if (e->k == VKSTR || e->k == VKNUM || e->k == VKTRUE)
  834.         pc = NO_JMP;  /* Never jump. */
  835.     else if (e->k == VJMP)
  836.         invertcond(fs, e), pc = e->u.s.info;
  837.     else if (e->k == VKFALSE || e->k == VKNIL)
  838.         expr_toreg_nobranch(fs, e, NO_REG), pc = bcemit_jmp(fs);
  839.     else
  840.         pc = bcemit_branch(fs, e, 0);
  841.     jmp_append(fs, &e->f, pc);
  842.     jmp_tohere(fs, e->t);
  843.     e->t = NO_JMP;
  844. }

  846. /* Emit branch on false condition. */
  847. ‌static void bcemit_branch_f(FuncState *fs, ExpDesc *e)
  848. {
  849.     BCPos pc;

  851.     expr_discharge(fs, e);
  852.     if (e->k == VKNIL || e->k == VKFALSE)
  853.         pc = NO_JMP;  /* Never jump. */
  854.     else if (e->k == VJMP)
  855.         pc = e->u.s.info;
  856.     else if (e->k == VKSTR || e->k == VKNUM || e->k == VKTRUE)
  857.         expr_toreg_nobranch(fs, e, NO_REG), pc = bcemit_jmp(fs);
  858.     else
  859.         pc = bcemit_branch(fs, e, 1);
  860.     jmp_append(fs, &e->t, pc);
  861.     jmp_tohere(fs, e->f);
  862.     e->f = NO_JMP;
  863. }

  865. /* -- Bytecode emitter for operators -------------------------------------- */

  867. ‌static ktap_number number_foldarith(ktap_number x, ktap_number y, int op)
  868. {
  869.     switch (op) {
  870.     case OPR_ADD - OPR_ADD: return x + y;
  871.     case OPR_SUB - OPR_ADD: return x - y;
  872.     case OPR_MUL - OPR_ADD: return x * y;
  873.     case OPR_DIV - OPR_ADD: return x / y;
  874.     default: return x;
  875.     }
  876. }

  878. /* Try constant-folding of arithmetic operators. */
  879. ‌static int foldarith(BinOpr opr, ExpDesc *e1, ExpDesc *e2)
  880. {
  881.     ktap_val_t o;
  882.     ktap_number n;

  884.     if (!expr_isnumk_nojump(e1) || !expr_isnumk_nojump(e2))
  885.         return 0;

  887.     if (opr == OPR_DIV && expr_numberV(e2) == 0)
  888.         return 0; /* do not attempt to divide by 0 */

  890.     if (opr == OPR_MOD)
  891.         return 0; /* ktap current do not suppor pow arith */

  893.     n = number_foldarith(expr_numberV(e1), expr_numberV(e2),
  894.                 (int)opr-OPR_ADD);
  895.     set_number(&o, n);
  896.     set_number(&e1->u.nval, n);
  897.     return 1;
  898. }

  900. /* Emit arithmetic operator. */
  901. ‌static void bcemit_arith(FuncState *fs, BinOpr opr, ExpDesc *e1, ExpDesc *e2)
  902. {
  903.     BCReg rb, rc, t;
  904.     uint32_t op;

  906.     if (foldarith(opr, e1, e2))
  907.         return;
  908.     if (opr == OPR_POW) {
  909.         op = BC_POW;
  910.         rc = expr_toanyreg(fs, e2);
  911.         rb = expr_toanyreg(fs, e1);
  912.     } else {
  913.         op = opr-OPR_ADD+BC_ADDVV;
  914.         /*
  915.          * Must discharge 2nd operand first since VINDEXED
  916.          * might free regs.
  917.          */
  918.         expr_toval(fs, e2);
  919.         if (expr_isnumk(e2) && (rc = const_num(fs, e2)) <= BCMAX_C)
  920.             op -= BC_ADDVV-BC_ADDVN;
  921.         else
  922.             rc = expr_toanyreg(fs, e2);
  923.         /* 1st operand discharged by bcemit_binop_left,
  924.          * but need KNUM/KSHORT. */
  925.         kp_assert(expr_isnumk(e1) || e1->k == VNONRELOC);
  926.         expr_toval(fs, e1);
  927.         /* Avoid two consts to satisfy bytecode constraints. */
  928.         if (expr_isnumk(e1) && !expr_isnumk(e2) &&
  929.             (t = const_num(fs, e1)) <= BCMAX_B) {
  930.             rb = rc; rc = t; op -= BC_ADDVV-BC_ADDNV;
  931.         } else {
  932.             rb = expr_toanyreg(fs, e1);
  933.         }
  934.     }
  935.     /* Using expr_free might cause asserts if the order is wrong. */
  936.     if (e1->k == VNONRELOC && e1->u.s.info >= fs->nactvar)
  937.         fs->freereg--;
  938.     if (e2->k == VNONRELOC && e2->u.s.info >= fs->nactvar)
  939.         fs->freereg--;
  940.     e1->u.s.info = bcemit_ABC(fs, op, 0, rb, rc);
  941.     e1->k = VRELOCABLE;
  942. }

  944. /* Emit comparison operator. */
  945. ‌static void bcemit_comp(FuncState *fs, BinOpr opr, ExpDesc *e1, ExpDesc *e2)
  946. {
  947.     ExpDesc *eret = e1;
  948.     BCIns ins;

  950.     expr_toval(fs, e1);
  951.     if (opr == OPR_EQ || opr == OPR_NE) {
  952.         BCOp op = opr == OPR_EQ ? BC_ISEQV : BC_ISNEV;
  953.         BCReg ra;

  955.         if (expr_isk(e1)) { /* Need constant in 2nd arg. */
  956.             e1 = e2;
  957.             e2 = eret;
  958.         }
  959.         ra = expr_toanyreg(fs, e1);  /* First arg must be in a reg. */
  960.         expr_toval(fs, e2);
  961.         switch (e2->k) {
  962.         case VKNIL: case VKFALSE: case VKTRUE:
  963.             ins = BCINS_AD(op+(BC_ISEQP-BC_ISEQV), ra,
  964.                     const_pri(e2));
  965.             break;
  966.         case VKSTR:
  967.             ins = BCINS_AD(op+(BC_ISEQS-BC_ISEQV), ra,
  968.                     const_str(fs, e2));
  969.             break;
  970.         case VKNUM:
  971.             ins = BCINS_AD(op+(BC_ISEQN-BC_ISEQV), ra,
  972.                     const_num(fs, e2));
  973.             break;
  974.         default:
  975.             ins = BCINS_AD(op, ra, expr_toanyreg(fs, e2));
  976.             break;
  977.         }
  978.     } else {
  979.         uint32_t op = opr-OPR_LT+BC_ISLT;
  980.         BCReg ra, rd;
  981.         if ((op-BC_ISLT) & 1) {  /* GT -> LT, GE -> LE */
  982.             e1 = e2; e2 = eret;  /* Swap operands. */
  983.             op = ((op-BC_ISLT)^3)+BC_ISLT;
  984.             expr_toval(fs, e1);
  985.         }
  986.         rd = expr_toanyreg(fs, e2);
  987.         ra = expr_toanyreg(fs, e1);
  988.         ins = BCINS_AD(op, ra, rd);
  989.     }
  990.     /* Using expr_free might cause asserts if the order is wrong. */
  991.     if (e1->k == VNONRELOC && e1->u.s.info >= fs->nactvar)
  992.         fs->freereg--;
  993.     if (e2->k == VNONRELOC && e2->u.s.info >= fs->nactvar)
  994.         fs->freereg--;
  995.     bcemit_INS(fs, ins);
  996.     eret->u.s.info = bcemit_jmp(fs);
  997.     eret->k = VJMP;
  998. }

  1000. /* Fixup left side of binary operator. */
  1001. ‌static void bcemit_binop_left(FuncState *fs, BinOpr op, ExpDesc *e)
  1002. {
  1003.     if (op == OPR_AND) {
  1004.         bcemit_branch_t(fs, e);
  1005.     } else if (op == OPR_OR) {
  1006.         bcemit_branch_f(fs, e);
  1007.     } else if (op == OPR_CONCAT) {
  1008.         expr_tonextreg(fs, e);
  1009.     } else if (op == OPR_EQ || op == OPR_NE) {
  1010.         if (!expr_isk_nojump(e))
  1011.             expr_toanyreg(fs, e);
  1012.     } else {
  1013.         if (!expr_isnumk_nojump(e))
  1014.             expr_toanyreg(fs, e);
  1015.     }
  1016. }

  1018. /* Emit binary operator. */
  1019. ‌static void bcemit_binop(FuncState *fs, BinOpr op, ExpDesc *e1, ExpDesc *e2)
  1020. {
  1021.     if (op <= OPR_POW) {
  1022.         bcemit_arith(fs, op, e1, e2);
  1023.     } else if (op == OPR_AND) {
  1024.         kp_assert(e1->t == NO_JMP);  /* List must be closed. */
  1025.         expr_discharge(fs, e2);
  1026.         jmp_append(fs, &e2->f, e1->f);
  1027.         *e1 = *e2;
  1028.     } else if (op == OPR_OR) {
  1029.         kp_assert(e1->f == NO_JMP);  /* List must be closed. */
  1030.         expr_discharge(fs, e2);
  1031.         jmp_append(fs, &e2->t, e1->t);
  1032.         *e1 = *e2;
  1033.     } else if (op == OPR_CONCAT) {
  1034.         expr_toval(fs, e2);
  1035.         if (e2->k == VRELOCABLE && bc_op(*bcptr(fs, e2)) == BC_CAT) {
  1036.             kp_assert(e1->u.s.info == bc_b(*bcptr(fs, e2))-1);
  1037.             expr_free(fs, e1);
  1038.             setbc_b(bcptr(fs, e2), e1->u.s.info);
  1039.             e1->u.s.info = e2->u.s.info;
  1040.         } else {
  1041.             expr_tonextreg(fs, e2);
  1042.             expr_free(fs, e2);
  1043.             expr_free(fs, e1);
  1044.             e1->u.s.info = bcemit_ABC(fs, BC_CAT, 0, e1->u.s.info,
  1045.                                  e2->u.s.info);
  1046.         }
  1047.         e1->k = VRELOCABLE;
  1048.     } else {
  1049.         kp_assert(op == OPR_NE || op == OPR_EQ || op == OPR_LT ||
  1050.               op == OPR_GE || op == OPR_LE || op == OPR_GT);
  1051.         bcemit_comp(fs, op, e1, e2);
  1052.     }
  1053. }

  1055. /* Emit unary operator. */
  1056. ‌static void bcemit_unop(FuncState *fs, BCOp op, ExpDesc *e)
  1057. {
  1058.     if (op == BC_NOT) {
  1059.         /* Swap true and false lists. */
  1060.         { BCPos temp = e->f; e->f = e->t; e->t = temp; }
  1061.         jmp_dropval(fs, e->f);
  1062.         jmp_dropval(fs, e->t);
  1063.         expr_discharge(fs, e);
  1064.         if (e->k == VKNIL || e->k == VKFALSE) {
  1065.             e->k = VKTRUE;
  1066.             return;
  1067.         } else if (expr_isk(e)) {
  1068.             e->k = VKFALSE;
  1069.             return;
  1070.         } else if (e->k == VJMP) {
  1071.             invertcond(fs, e);
  1072.             return;
  1073.         } else if (e->k == VRELOCABLE) {
  1074.             bcreg_reserve(fs, 1);
  1075.             setbc_a(bcptr(fs, e), fs->freereg-1);
  1076.             e->u.s.info = fs->freereg-1;
  1077.             e->k = VNONRELOC;
  1078.         } else {
  1079.             kp_assert(e->k == VNONRELOC);
  1080.         }
  1081.     } else {
  1082.         kp_assert(op == BC_UNM || op == BC_LEN);
  1083.         /* Constant-fold negations. */
  1084.         if (op == BC_UNM && !expr_hasjump(e)) {
  1085.             /* Avoid folding to -0. */
  1086.             if (expr_isnumk(e) && !expr_numiszero(e)) {
  1087.                 ktap_val_t *o = expr_numtv(e);
  1088.                 if (is_number(o))
  1089.                     set_number(o, -nvalue(o));
  1090.                 return;
  1091.             }
  1092.         }
  1093.         expr_toanyreg(fs, e);
  1094.     }
  1095.     expr_free(fs, e);
  1096.     e->u.s.info = bcemit_AD(fs, op, 0, e->u.s.info);
  1097.     e->k = VRELOCABLE;
  1098. }

  1100. /* -- Lexer support ------------------------------------------------------- */

  1102. /* Check and consume optional token. */
  1103. ‌static int lex_opt(LexState *ls, LexToken tok)
  1104. {
  1105.     if (ls->tok == tok) {
  1106.         kp_lex_next(ls);
  1107.         return 1;
  1108.     }
  1109.     return 0;
  1110. }

  1112. /* Check and consume token. */
  1113. ‌static void lex_check(LexState *ls, LexToken tok)
  1114. {
  1115.     if (ls->tok != tok)
  1116.         err_token(ls, tok);
  1117.     kp_lex_next(ls);
  1118. }

  1120. /* Check for matching token. */
  1121. ‌static void lex_match(LexState *ls, LexToken what, LexToken who, BCLine line)
  1122. {
  1123.     if (!lex_opt(ls, what)) {
  1124.         if (line == ls->linenumber) {
  1125.             err_token(ls, what);
  1126.         } else {
  1127.             const char *swhat = kp_lex_token2str(ls, what);
  1128.             const char *swho = kp_lex_token2str(ls, who);
  1129.             kp_lex_error(ls, ls->tok, KP_ERR_XMATCH, swhat, swho,
  1130.                                 line);
  1131.         }
  1132.     }
  1133. }

  1135. /* Check for string token. */
  1136. ‌static ktap_str_t *lex_str(LexState *ls)
  1137. {
  1138.     ktap_str_t *s;

  1140.     if (ls->tok != TK_name)
  1141.         err_token(ls, TK_name);
  1142.     s = rawtsvalue(&ls->tokval);
  1143.     kp_lex_next(ls);
  1144.     return s;
  1145. }

  1147. /* -- Variable handling --------------------------------------------------- */

  1149. ‌#define var_get(ls, fs, i)    ((ls)->vstack[(fs)->varmap[(i)]])

  1151. /* Define a new local variable. */
  1152. ‌static void var_new(LexState *ls, BCReg n, ktap_str_t *name)
  1153. {
  1154.     FuncState *fs = ls->fs;
  1155.     int vtop = ls->vtop;

  1157.     checklimit(fs, fs->nactvar+n, KP_MAX_LOCVAR, "local variables");
  1158.     if (vtop >= ls->sizevstack) {
  1159.         if (ls->sizevstack >= KP_MAX_VSTACK)
  1160.             kp_lex_error(ls, 0, KP_ERR_XLIMC, KP_MAX_VSTACK);
  1161.         if (!ls->vstack) {
  1162.             ls->vstack = malloc(sizeof(VarInfo) * 20);
  1163.             ls->sizevstack = 20;
  1164.         } else {
  1165.             ls->vstack = realloc(ls->vstack,
  1166.                 ls->sizevstack * sizeof(VarInfo) * 2);
  1167.             ls->sizevstack = ls->sizevstack * 2;
  1168.         }
  1169.     }
  1170.     kp_assert((uintptr_t)name < VARNAME__MAX ||
  1171.             kp_tab_getstr(fs->kt, name) != NULL);
  1172.     ls->vstack[vtop].name = name;
  1173.     fs->varmap[fs->nactvar+n] = (uint16_t)vtop;
  1174.     ls->vtop = vtop+1;
  1175. }

  1177. ‌#define var_new_lit(ls, n, v) \
  1178.     var_new(ls, (n), kp_parse_keepstr(ls, "" v, sizeof(v)-1))

  1180. ‌#define var_new_fixed(ls, n, vn) \
  1181.     var_new(ls, (n), (ktap_str_t *)(uintptr_t)(vn))

  1183. /* Add local variables. */
  1184. ‌static void var_add(LexState *ls, BCReg nvars)
  1185. {
  1186.     FuncState *fs = ls->fs;
  1187.     BCReg nactvar = fs->nactvar;

  1189.     while (nvars--) {
  1190.         VarInfo *v = &var_get(ls, fs, nactvar);
  1191.         v->startpc = fs->pc;
  1192.         v->slot = nactvar++;
  1193.         v->info = 0;
  1194.     }
  1195.     fs->nactvar = nactvar;
  1196. }

  1198. /* Remove local variables. */
  1199. ‌static void var_remove(LexState *ls, BCReg tolevel)
  1200. {
  1201.     FuncState *fs = ls->fs;
  1202.     while (fs->nactvar > tolevel)
  1203.         var_get(ls, fs, --fs->nactvar).endpc = fs->pc;
  1204. }

  1206. /* Lookup local variable name. */
  1207. ‌static BCReg var_lookup_local(FuncState *fs, ktap_str_t *n)
  1208. {
  1209.     int i;

  1211.     for (i = fs->nactvar-1; i >= 0; i--) {
  1212.         if (n == var_get(fs->ls, fs, i).name)
  1213.             return (BCReg)i;
  1214.     }
  1215.     return (BCReg)-1;  /* Not found. */
  1216. }

  1218. /* Lookup or add upvalue index. */
  1219. ‌static int var_lookup_uv(FuncState *fs, int vidx, ExpDesc *e)
  1220. {
  1221.     int i, n = fs->nuv;

  1223.     for (i = 0; i < n; i++)
  1224.         if (fs->uvmap[i] == vidx)
  1225.             return i;  /* Already exists. */

  1227.     /* Otherwise create a new one. */
  1228.     checklimit(fs, fs->nuv, KP_MAX_UPVAL, "upvalues");
  1229.     kp_assert(e->k == VLOCAL || e->k == VUPVAL);
  1230.     fs->uvmap[n] = (uint16_t)vidx;
  1231.     fs->uvtmp[n] = (uint16_t)(e->k == VLOCAL ? vidx :
  1232.             KP_MAX_VSTACK+e->u.s.info);
  1233.     fs->nuv = n+1;
  1234.     return n;
  1235. }

  1237. /* Forward declaration. */
  1238. static void fscope_uvmark(FuncState *fs, BCReg level);

  1240. /* Recursively lookup variables in enclosing functions. */
  1241. ‌static int var_lookup_(FuncState *fs, ktap_str_t *name, ExpDesc *e,
  1242.              int first)
  1243. {
  1244.     if (fs) {
  1245.         BCReg reg = var_lookup_local(fs, name);
  1246.         if ((int32_t)reg >= 0) {  /* Local in this function? */
  1247.             expr_init(e, VLOCAL, reg);
  1248.             if (!first) {
  1249.                 /* Scope now has an upvalue. */
  1250.                 fscope_uvmark(fs, reg);
  1251.             }
  1252.             return (int)(e->u.s.aux = (uint32_t)fs->varmap[reg]);
  1253.         } else {
  1254.             /* Var in outer func? */
  1255.             int vidx = var_lookup_(fs->prev, name, e, 0);
  1256.             if ((int32_t)vidx >= 0) {
  1257.                 /* Yes, make it an upvalue here. */
  1258.                 e->u.s.info =
  1259.                     (uint8_t)var_lookup_uv(fs, vidx, e);
  1260.                 e->k = VUPVAL;
  1261.                 return vidx;
  1262.             }
  1263.         }
  1264.     } else {  /* Not found in any function, must be a global. */
  1265.         expr_init(e, VGLOBAL, 0);
  1266.         e->u.sval = name;
  1267.     }
  1268.     return (int)-1;  /* Global. */
  1269. }

  1271. /* Lookup variable name. */
  1272. ‌#define var_lookup(ls, e) \
  1273.     var_lookup_((ls)->fs, lex_str(ls), (e), 1)

  1275. /* -- Goto an label handling ---------------------------------------------- */

  1277. /* Add a new goto or label. */
  1278. ‌static int gola_new(LexState *ls, ktap_str_t *name, uint8_t info, BCPos pc)
  1279. {
  1280.     FuncState *fs = ls->fs;
  1281.     int vtop = ls->vtop;

  1283.     if (vtop >= ls->sizevstack) {
  1284.         if (ls->sizevstack >= KP_MAX_VSTACK)
  1285.             kp_lex_error(ls, 0, KP_ERR_XLIMC, KP_MAX_VSTACK);
  1286.         if (!ls->vstack) {
  1287.             ls->vstack = malloc(sizeof(VarInfo) * 20);
  1288.             ls->sizevstack = 20;
  1289.         } else {
  1290.             ls->vstack = realloc(ls->vstack,
  1291.                     ls->sizevstack * sizeof(VarInfo) * 2);
  1292.             ls->sizevstack = ls->sizevstack * 2;
  1293.         }
  1294.     }
  1295.     kp_assert(name == NAME_BREAK ||
  1296.           kp_tab_getstr(fs->kt, name) != NULL);
  1297.     ls->vstack[vtop].name = name;
  1298.     ls->vstack[vtop].startpc = pc;
  1299.     ls->vstack[vtop].slot = (uint8_t)fs->nactvar;
  1300.     ls->vstack[vtop].info = info;
  1301.     ls->vtop = vtop+1;
  1302.     return vtop;
  1303. }

  1305. ‌#define gola_isgoto(v)        ((v)->info & VSTACK_GOTO)
  1306. ‌#define gola_islabel(v)        ((v)->info & VSTACK_LABEL)
  1307. ‌#define gola_isgotolabel(v)    ((v)->info & (VSTACK_GOTO|VSTACK_LABEL))

  1309. /* Patch goto to jump to label. */
  1310. ‌static void gola_patch(LexState *ls, VarInfo *vg, VarInfo *vl)
  1311. {
  1312.     FuncState *fs = ls->fs;
  1313.     BCPos pc = vg->startpc;

  1315.     vg->name = NULL; /* Invalidate pending goto. */
  1316.     setbc_a(&fs->bcbase[pc].ins, vl->slot);
  1317.     jmp_patch(fs, pc, vl->startpc);
  1318. }

  1320. /* Patch goto to close upvalues. */
  1321. ‌static void gola_close(LexState *ls, VarInfo *vg)
  1322. {
  1323.     FuncState *fs = ls->fs;
  1324.     BCPos pc = vg->startpc;
  1325.     BCIns *ip = &fs->bcbase[pc].ins;
  1326.     kp_assert(gola_isgoto(vg));
  1327.     kp_assert(bc_op(*ip) == BC_JMP || bc_op(*ip) == BC_UCLO);
  1328.     setbc_a(ip, vg->slot);
  1329.     if (bc_op(*ip) == BC_JMP) {
  1330.         BCPos next = jmp_next(fs, pc);
  1331.         if (next != NO_JMP)
  1332.             jmp_patch(fs, next, pc);  /* Jump to UCLO. */
  1333.         setbc_op(ip, BC_UCLO);  /* Turn into UCLO. */
  1334.         setbc_j(ip, NO_JMP);
  1335.     }
  1336. }

  1338. /* Resolve pending forward gotos for label. */
  1339. ‌static void gola_resolve(LexState *ls, FuncScope *bl, int idx)
  1340. {
  1341.     VarInfo *vg = ls->vstack + bl->vstart;
  1342.     VarInfo *vl = ls->vstack + idx;
  1343.     for (; vg < vl; vg++)
  1344.         if (vg->name == vl->name && gola_isgoto(vg)) {
  1345.             if (vg->slot < vl->slot) {
  1346.                 ktap_str_t *name =
  1347.                     var_get(ls, ls->fs, vg->slot).name;
  1348.                 kp_assert((uintptr_t)name >= VARNAME__MAX);
  1349.                 ls->linenumber =
  1350.                     ls->fs->bcbase[vg->startpc].line;
  1351.                 kp_assert(vg->name != NAME_BREAK);
  1352.                 kp_lex_error(ls, 0, KP_ERR_XGSCOPE,
  1353.                 getstr(vg->name), getstr(name));
  1354.             }
  1355.             gola_patch(ls, vg, vl);
  1356.         }
  1357. }

  1359. /* Fixup remaining gotos and labels for scope. */
  1360. ‌static void gola_fixup(LexState *ls, FuncScope *bl)
  1361. {
  1362.     VarInfo *v = ls->vstack + bl->vstart;
  1363.     VarInfo *ve = ls->vstack + ls->vtop;

  1365.     for (; v < ve; v++) {
  1366.         ktap_str_t *name = v->name;
  1367.         /* Only consider remaining valid gotos/labels. */
  1368.         if (name != NULL) {
  1369.             if (gola_islabel(v)) {
  1370.                 VarInfo *vg;
  1371.                 /* Invalidate label that goes out of scope. */
  1372.                 v->name = NULL;
  1373.                 /* Resolve pending backward gotos. */
  1374.                 for (vg = v+1; vg < ve; vg++)
  1375.                     if (vg->name == name &&
  1376.                         gola_isgoto(vg)) {
  1377.                         if ((bl->flags&FSCOPE_UPVAL) &&
  1378.                              vg->slot > v->slot)
  1379.                             gola_close(ls, vg);
  1380.                         gola_patch(ls, vg, v);
  1381.                     }
  1382.             } else if (gola_isgoto(v)) {
  1383.                 /* Propagate goto or break to outer scope. */
  1384.                 if (bl->prev) {
  1385.                     bl->prev->flags |= name == NAME_BREAK ?                         FSCOPE_BREAK : FSCOPE_GOLA;
  1386.                     v->slot = bl->nactvar;
  1387.                     if ((bl->flags & FSCOPE_UPVAL))
  1388.                         gola_close(ls, v);
  1389.                 } else {
  1390.                     ls->linenumber =
  1391.                     ls->fs->bcbase[v->startpc].line;
  1392.                     if (name == NAME_BREAK)
  1393.                         kp_lex_error(ls, 0, KP_ERR_XBREAK);
  1394.                     else
  1395.                         kp_lex_error(ls, 0, KP_ERR_XLUNDEF, getstr(name));
  1396.                 }
  1397.             }
  1398.         }
  1399.     }
  1400. }

  1402. /* Find existing label. */
  1403. ‌static VarInfo *gola_findlabel(LexState *ls, ktap_str_t *name)
  1404. {
  1405.     VarInfo *v = ls->vstack + ls->fs->bl->vstart;
  1406.     VarInfo *ve = ls->vstack + ls->vtop;

  1408.     for (; v < ve; v++)
  1409.         if (v->name == name && gola_islabel(v))
  1410.             return v;
  1411.     return NULL;
  1412. }

  1414. /* -- Scope handling ------------------------------------------------------ */

  1416. /* Begin a scope. */
  1417. ‌static void fscope_begin(FuncState *fs, FuncScope *bl, int flags)
  1418. {
  1419.     bl->nactvar = (uint8_t)fs->nactvar;
  1420.     bl->flags = flags;
  1421.     bl->vstart = fs->ls->vtop;
  1422.     bl->prev = fs->bl;
  1423.     fs->bl = bl;
  1424.     kp_assert(fs->freereg == fs->nactvar);
  1425. }

  1427. /* End a scope. */
  1428. ‌static void fscope_end(FuncState *fs)
  1429. {
  1430.     FuncScope *bl = fs->bl;
  1431.     LexState *ls = fs->ls;

  1433.     fs->bl = bl->prev;
  1434.     var_remove(ls, bl->nactvar);
  1435.     fs->freereg = fs->nactvar;
  1436.     kp_assert(bl->nactvar == fs->nactvar);
  1437.     if ((bl->flags & (FSCOPE_UPVAL|FSCOPE_NOCLOSE)) == FSCOPE_UPVAL)
  1438.         bcemit_AJ(fs, BC_UCLO, bl->nactvar, 0);
  1439.     if ((bl->flags & FSCOPE_BREAK)) {
  1440.         if ((bl->flags & FSCOPE_LOOP)) {
  1441.             int idx = gola_new(ls, NAME_BREAK, VSTACK_LABEL,
  1442.                         fs->pc);
  1443.             ls->vtop = idx;  /* Drop break label immediately. */
  1444.             gola_resolve(ls, bl, idx);
  1445.             return;
  1446.         }  /* else: need the fixup step to propagate the breaks. */
  1447.     } else if (!(bl->flags & FSCOPE_GOLA)) {
  1448.         return;
  1449.     }
  1450.     gola_fixup(ls, bl);
  1451. }

  1453. /* Mark scope as having an upvalue. */
  1454. ‌static void fscope_uvmark(FuncState *fs, BCReg level)
  1455. {
  1456.     FuncScope *bl;

  1458.     for (bl = fs->bl; bl && bl->nactvar > level; bl = bl->prev);
  1459.     if (bl)
  1460.         bl->flags |= FSCOPE_UPVAL;
  1461. }

  1463. /* -- Function state management ------------------------------------------- */

  1465. /* Fixup bytecode for prototype. */
  1466. ‌static void fs_fixup_bc(FuncState *fs, ktap_proto_t *pt, BCIns *bc, int n)
  1467. {
  1468.     BCInsLine *base = fs->bcbase;
  1469.     int i;

  1471.     pt->sizebc = n;
  1472.     bc[0] = BCINS_AD((fs->flags & PROTO_VARARG) ? BC_FUNCV : BC_FUNCF,
  1473.              fs->framesize, 0);
  1474.     for (i = 1; i < n; i++)
  1475.         bc[i] = base[i].ins;
  1476. }

  1478. /* Fixup upvalues for child prototype, step #2. */
  1479. ‌static void fs_fixup_uv2(FuncState *fs, ktap_proto_t *pt)
  1480. {
  1481.     VarInfo *vstack = fs->ls->vstack;
  1482.     uint16_t *uv = pt->uv;
  1483.     int i, n = pt->sizeuv;

  1485.     for (i = 0; i < n; i++) {
  1486.         VarIndex vidx = uv[i];
  1487.         if (vidx >= KP_MAX_VSTACK)
  1488.             uv[i] = vidx - KP_MAX_VSTACK;
  1489.         else if ((vstack[vidx].info & VSTACK_VAR_RW))
  1490.             uv[i] = vstack[vidx].slot | PROTO_UV_LOCAL;
  1491.         else
  1492.             uv[i] = vstack[vidx].slot | PROTO_UV_LOCAL |
  1493.                     PROTO_UV_IMMUTABLE;
  1494.     }
  1495. }

  1497. /* Fixup constants for prototype. */
  1498. ‌static void fs_fixup_k(FuncState *fs, ktap_proto_t *pt, void *kptr)
  1499. {
  1500.     ktap_tab_t *kt;
  1501.     ktap_node_t *node;
  1502.     int i, hmask;

  1504.     checklimitgt(fs, fs->nkn, BCMAX_D+1, "constants");
  1505.     checklimitgt(fs, fs->nkgc, BCMAX_D+1, "constants");

  1507.     pt->k = kptr;
  1508.     pt->sizekn = fs->nkn;
  1509.     pt->sizekgc = fs->nkgc;
  1510.     kt = fs->kt;
  1511.     node = kt->node;
  1512.     hmask = kt->hmask;
  1513.     for (i = 0; i <= hmask; i++) {
  1514.         ktap_node_t *n = &node[i];

  1516.         if (tvhaskslot(&n->val)) {
  1517.             ptrdiff_t kidx = (ptrdiff_t)tvkslot(&n->val);
  1518.             kp_assert(!is_number(&n->key));
  1519.             if (is_number(&n->key)) {
  1520.                 ktap_val_t *tv = &((ktap_val_t *)kptr)[kidx];
  1521.                 *tv = n->key;
  1522.             } else {
  1523.                 ktap_obj_t *o = n->key.val.gc;
  1524.                 ktap_obj_t **v = (ktap_obj_t **)kptr;
  1525.                 v[~kidx] = o;
  1526.                 if (is_proto(&n->key))
  1527.                     fs_fixup_uv2(fs, (ktap_proto_t *)o);
  1528.             }
  1529.         }
  1530.     }
  1531. }

  1533. /* Fixup upvalues for prototype, step #1. */
  1534. ‌static void fs_fixup_uv1(FuncState *fs, ktap_proto_t *pt, uint16_t *uv)
  1535. {
  1536.     pt->uv = uv;
  1537.     pt->sizeuv = fs->nuv;
  1538.     memcpy(uv, fs->uvtmp, fs->nuv*sizeof(VarIndex));
  1539. }

  1541. #ifndef KTAP_DISABLE_LINEINFO
  1542. /* Prepare lineinfo for prototype. */
  1543. ‌static size_t fs_prep_line(FuncState *fs, BCLine numline)
  1544. {
  1545.     return (fs->pc-1) << (numline < 256 ? 0 : numline < 65536 ? 1 : 2);
  1546. }

  1548. /* Fixup lineinfo for prototype. */
  1549. ‌static void fs_fixup_line(FuncState *fs, ktap_proto_t *pt,
  1550.               void *lineinfo, BCLine numline)
  1551. {
  1552.     BCInsLine *base = fs->bcbase + 1;
  1553.     BCLine first = fs->linedefined;
  1554.     int i = 0, n = fs->pc-1;

  1556.     pt->firstline = fs->linedefined;
  1557.     pt->numline = numline;
  1558.     pt->lineinfo = lineinfo;
  1559.     if (numline < 256) {
  1560.         uint8_t *li = (uint8_t *)lineinfo;
  1561.         do {
  1562.             BCLine delta = base[i].line - first;
  1563.             kp_assert(delta >= 0 && delta < 256);
  1564.             li[i] = (uint8_t)delta;
  1565.         } while (++i < n);
  1566.     } else if (numline < 65536) {
  1567.         uint16_t *li = (uint16_t *)lineinfo;
  1568.         do {
  1569.             BCLine delta = base[i].line - first;
  1570.             kp_assert(delta >= 0 && delta < 65536);
  1571.             li[i] = (uint16_t)delta;
  1572.         } while (++i < n);
  1573.     } else {
  1574.         uint32_t *li = (uint32_t *)lineinfo;
  1575.         do {
  1576.             BCLine delta = base[i].line - first;
  1577.             kp_assert(delta >= 0);
  1578.             li[i] = (uint32_t)delta;
  1579.         } while (++i < n);
  1580.     }
  1581. }

  1583. /* Prepare variable info for prototype. */
  1584. ‌static size_t fs_prep_var(LexState *ls, FuncState *fs, size_t *ofsvar)
  1585. {
  1586.     VarInfo *vs =ls->vstack, *ve;
  1587.     int i, n;
  1588.     BCPos lastpc;

  1590.     kp_buf_reset(&ls->sb);  /* Copy to temp. string buffer. */
  1591.     /* Store upvalue names. */
  1592.     for (i = 0, n = fs->nuv; i < n; i++) {
  1593.         ktap_str_t *s = vs[fs->uvmap[i]].name;
  1594.         int len = s->len+1;
  1595.         char *p = kp_buf_more(&ls->sb, len);
  1596.         p = kp_buf_wmem(p, getstr(s), len);
  1597.         setsbufP(&ls->sb, p);
  1598.     }

  1600.     *ofsvar = sbuflen(&ls->sb);
  1601.     lastpc = 0;
  1602.     /* Store local variable names and compressed ranges. */
  1603.     for (ve = vs + ls->vtop, vs += fs->vbase; vs < ve; vs++) {
  1604.         if (!gola_isgotolabel(vs)) {
  1605.             ktap_str_t *s = vs->name;
  1606.             BCPos startpc;
  1607.             char *p;
  1608.             if ((uintptr_t)s < VARNAME__MAX) {
  1609.                 p = kp_buf_more(&ls->sb, 1 + 2*5);
  1610.                 *p++ = (char)(uintptr_t)s;
  1611.             } else {
  1612.                 int len = s->len+1;
  1613.                 p = kp_buf_more(&ls->sb, len + 2*5);
  1614.                 p = kp_buf_wmem(p, getstr(s), len);
  1615.             }
  1616.             startpc = vs->startpc;
  1617.             p = strfmt_wuleb128(p, startpc-lastpc);
  1618.             p = strfmt_wuleb128(p, vs->endpc-startpc);
  1619.             setsbufP(&ls->sb, p);
  1620.             lastpc = startpc;
  1621.         }
  1622.     }

  1624.     kp_buf_putb(&ls->sb, '\0');  /* Terminator for varinfo. */
  1625.     return sbuflen(&ls->sb);
  1626. }

  1628. /* Fixup variable info for prototype. */
  1629. ‌static void fs_fixup_var(LexState *ls, ktap_proto_t *pt, uint8_t *p,
  1630.              size_t ofsvar)
  1631. {
  1632.     pt->uvinfo = p;
  1633.     pt->varinfo = (char *)p + ofsvar;
  1634.     /* Copy from temp. buffer. */
  1635.     memcpy(p, sbufB(&ls->sb), sbuflen(&ls->sb));
  1636. }
  1637. #else

  1639. /* Initialize with empty debug info, if disabled. */
  1640. ‌#define fs_prep_line(fs, numline)        (UNUSED(numline), 0)
  1641. ‌#define fs_fixup_line(fs, pt, li, numline) \
  1642.   pt->firstline = pt->numline = 0, (pt)->lineinfo = NULL
  1643. ‌#define fs_prep_var(ls, fs, ofsvar)        (UNUSED(ofsvar), 0)
  1644. ‌#define fs_fixup_var(ls, pt, p, ofsvar) \
  1645.   (pt)->uvinfo = NULL, (pt)->varinfo = NULL

  1647. #endif

  1649. /* Check if bytecode op returns. */
  1650. ‌static int bcopisret(BCOp op)
  1651. {
  1652.     switch (op) {
  1653.     case BC_CALLMT: case BC_CALLT:
  1654.     case BC_RETM: case BC_RET: case BC_RET0: case BC_RET1:
  1655.         return 1;
  1656.     default:
  1657.         return 0;
  1658.     }
  1659. }

  1661. /* Fixup return instruction for prototype. */
  1662. ‌static void fs_fixup_ret(FuncState *fs)
  1663. {
  1664.     BCPos lastpc = fs->pc;

  1666.     if (lastpc <= fs->lasttarget ||
  1667.         !bcopisret(bc_op(fs->bcbase[lastpc-1].ins))) {
  1668.         if ((fs->bl->flags & FSCOPE_UPVAL))
  1669.             bcemit_AJ(fs, BC_UCLO, 0, 0);
  1670.         bcemit_AD(fs, BC_RET0, 0, 1);  /* Need final return. */
  1671.     }
  1672.     fs->bl->flags |= FSCOPE_NOCLOSE;  /* Handled above. */
  1673.     fscope_end(fs);
  1674.     kp_assert(fs->bl == NULL);
  1675.     /* May need to fixup returns encoded before first function
  1676.      * was created. */
  1677.     if (fs->flags & PROTO_FIXUP_RETURN) {
  1678.         BCPos pc;
  1679.         for (pc = 1; pc < lastpc; pc++) {
  1680.             BCIns ins = fs->bcbase[pc].ins;
  1681.             BCPos offset;
  1682.             switch (bc_op(ins)) {
  1683.             case BC_CALLMT: case BC_CALLT:
  1684.             case BC_RETM: case BC_RET: case BC_RET0: case BC_RET1:
  1685.                 /* Copy original instruction. */
  1686.                 offset = bcemit_INS(fs, ins);
  1687.                 fs->bcbase[offset].line = fs->bcbase[pc].line;
  1688.                 offset = offset-(pc+1)+BCBIAS_J;
  1689.                 if (offset > BCMAX_D)
  1690.                     err_syntax(fs->ls, KP_ERR_XFIXUP);
  1691.                 /* Replace with UCLO plus branch. */
  1692.                 fs->bcbase[pc].ins = BCINS_AD(BC_UCLO, 0,
  1693.                                 offset);
  1694.                 break;
  1695.             case BC_UCLO:
  1696.                 return;  /* We're done. */
  1697.             default:
  1698.                 break;
  1699.             }
  1700.         }
  1701.     }
  1702. }

  1704. /* Finish a FuncState and return the new prototype. */
  1705. ‌static ktap_proto_t *fs_finish(LexState *ls, BCLine line)
  1706. {
  1707.     FuncState *fs = ls->fs;
  1708.     BCLine numline = line - fs->linedefined;
  1709.     size_t sizept, ofsk, ofsuv, ofsli, ofsdbg, ofsvar;
  1710.     ktap_proto_t *pt;

  1712.     /* Apply final fixups. */
  1713.     fs_fixup_ret(fs);

  1715.     /* Calculate total size of prototype including all colocated arrays. */
  1716.     sizept = sizeof(ktap_proto_t) + fs->pc*sizeof(BCIns) +
  1717.             fs->nkgc*sizeof(ktap_obj_t *);
  1718.     sizept = (sizept + sizeof(ktap_val_t)-1) & ~(sizeof(ktap_val_t)-1);
  1719.     ofsk = sizept; sizept += fs->nkn*sizeof(ktap_val_t);
  1720.     ofsuv = sizept; sizept += ((fs->nuv+1)&~1)*2;
  1721.     ofsli = sizept; sizept += fs_prep_line(fs, numline);
  1722.     ofsdbg = sizept; sizept += fs_prep_var(ls, fs, &ofsvar);

  1724.     /* Allocate prototype and initialize its fields. */
  1725.     pt = (ktap_proto_t *)malloc((int)sizept);
  1726.     pt->gct = ~KTAP_TPROTO;
  1727.     pt->sizept = (int)sizept;
  1728.     pt->flags =
  1729.         (uint8_t)(fs->flags & ~(PROTO_HAS_RETURN|PROTO_FIXUP_RETURN));
  1730.     pt->numparams = fs->numparams;
  1731.     pt->framesize = fs->framesize;
  1732.     pt->chunkname = ls->chunkname;

  1734.     /* Close potentially uninitialized gap between bc and kgc. */
  1735.     *(uint32_t *)((char *)pt + ofsk - sizeof(ktap_obj_t *)*(fs->nkgc+1)) = 0;
  1736.     fs_fixup_bc(fs, pt, (BCIns *)((char *)pt + sizeof(ktap_proto_t)), fs->pc);
  1737.     fs_fixup_k(fs, pt, (void *)((char *)pt + ofsk));
  1738.     fs_fixup_uv1(fs, pt, (uint16_t *)((char *)pt + ofsuv));
  1739.     fs_fixup_line(fs, pt, (void *)((char *)pt + ofsli), numline);
  1740.     fs_fixup_var(ls, pt, (uint8_t *)((char *)pt + ofsdbg), ofsvar);

  1742.     ls->vtop = fs->vbase;  /* Reset variable stack. */
  1743.     ls->fs = fs->prev;
  1744.     kp_assert(ls->fs != NULL || ls->tok == TK_eof);
  1745.     return pt;
  1746. }

  1748. /* Initialize a new FuncState. */
  1749. ‌static void fs_init(LexState *ls, FuncState *fs)
  1750. {
  1751.     fs->prev = ls->fs; ls->fs = fs;  /* Append to list. */
  1752.     fs->ls = ls;
  1753.     fs->vbase = ls->vtop;
  1754.     fs->pc = 0;
  1755.     fs->lasttarget = 0;
  1756.     fs->jpc = NO_JMP;
  1757.     fs->freereg = 0;
  1758.     fs->nkgc = 0;
  1759.     fs->nkn = 0;
  1760.     fs->nactvar = 0;
  1761.     fs->nuv = 0;
  1762.     fs->bl = NULL;
  1763.     fs->flags = 0;
  1764.     fs->framesize = 1;  /* Minimum frame size. */
  1765.     fs->kt = kp_tab_new();
  1766. }

  1768. /* -- Expressions --------------------------------------------------------- */

  1770. /* Forward declaration. */
  1771. static void expr(LexState *ls, ExpDesc *v);

  1773. /* Return string expression. */
  1774. ‌static void expr_str(LexState *ls, ExpDesc *e)
  1775. {
  1776.     expr_init(e, VKSTR, 0);
  1777.     e->u.sval = lex_str(ls);
  1778. }

  1780. ‌#define checku8(x)     ((x) == (int32_t)(uint8_t)(x))

  1782. /* Return index expression. */
  1783. ‌static void expr_index(FuncState *fs, ExpDesc *t, ExpDesc *e)
  1784. {
  1785.     /* Already called: expr_toval(fs, e). */
  1786.     t->k = VINDEXED;
  1787.     if (expr_isnumk(e)) {
  1788.         ktap_number n = expr_numberV(e);
  1789.         int32_t k = (int)n;
  1790.         if (checku8(k) && n == (ktap_number)k) {
  1791.             /* 256..511: const byte key */
  1792.             t->u.s.aux = BCMAX_C+1+(uint32_t)k;
  1793.             return;
  1794.         }
  1795.     } else if (expr_isstrk(e)) {
  1796.         BCReg idx = const_str(fs, e);
  1797.         if (idx <= BCMAX_C) {
  1798.             /* -256..-1: const string key */
  1799.             t->u.s.aux = ~idx;
  1800.             return;
  1801.         }
  1802.     }
  1803.     t->u.s.aux = expr_toanyreg(fs, e);  /* 0..255: register */
  1804. }

  1806. /* Parse index expression with named field. */
  1807. ‌static void expr_field(LexState *ls, ExpDesc *v)
  1808. {
  1809.     FuncState *fs = ls->fs;
  1810.     ExpDesc key;

  1812.     expr_toanyreg(fs, v);
  1813.     kp_lex_next(ls);  /* Skip dot or colon. */
  1814.     expr_str(ls, &key);
  1815.     expr_index(fs, v, &key);
  1816. }

  1818. /* Parse index expression with brackets. */
  1819. ‌static void expr_bracket(LexState *ls, ExpDesc *v)
  1820. {
  1821.     kp_lex_next(ls);  /* Skip '['. */
  1822.     expr(ls, v);
  1823.     expr_toval(ls->fs, v);
  1824.     lex_check(ls, ']');
  1825. }

  1827. /* Get value of constant expression. */
  1828. ‌static void expr_kvalue(ktap_val_t *v, ExpDesc *e)
  1829. {
  1830.     if (e->k <= VKTRUE) {
  1831.         setitype(v, ~(uint32_t)e->k);
  1832.     } else if (e->k == VKSTR) {
  1833.         set_string(v, e->u.sval);
  1834.     } else {
  1835.         kp_assert(tvisnumber(expr_numtv(e)));
  1836.         *v = *expr_numtv(e);
  1837.     }
  1838. }

  1840. ‌#define FLS(x)       ((uint32_t)(__builtin_clz(x)^31))
  1841. ‌#define hsize2hbits(s) ((s) ? ((s)==1 ? 1 : 1+FLS((uint32_t)((s)-1))) : 0)


  1844. /* Parse table constructor expression. */
  1845. ‌static void expr_table(LexState *ls, ExpDesc *e)
  1846. {
  1847.     FuncState *fs = ls->fs;
  1848.     BCLine line = ls->linenumber;
  1849.     ktap_tab_t *t = NULL;
  1850.     int vcall = 0, needarr = 0, fixt = 0;
  1851.     uint32_t narr = 1;  /* First array index. */
  1852.     uint32_t nhash = 0;  /* Number of hash entries. */
  1853.     BCReg freg = fs->freereg;
  1854.     BCPos pc = bcemit_AD(fs, BC_TNEW, freg, 0);

  1856.     expr_init(e, VNONRELOC, freg);
  1857.     bcreg_reserve(fs, 1);
  1858.     freg++;
  1859.     lex_check(ls, '{');
  1860.     while (ls->tok != '}') {
  1861.         ExpDesc key, val;
  1862.         vcall = 0;
  1863.         if (ls->tok == '[') {
  1864.             expr_bracket(ls, &key);/* Already calls expr_toval. */
  1865.             if (!expr_isk(&key))
  1866.                 expr_index(fs, e, &key);
  1867.             if (expr_isnumk(&key) && expr_numiszero(&key))
  1868.                 needarr = 1;
  1869.             else
  1870.                 nhash++;
  1871.             lex_check(ls, '=');
  1872.         } else if ((ls->tok == TK_name) &&
  1873.                 kp_lex_lookahead(ls) == '=') {
  1874.             expr_str(ls, &key);
  1875.             lex_check(ls, '=');
  1876.             nhash++;
  1877.         } else {
  1878.             expr_init(&key, VKNUM, 0);
  1879.             set_number(&key.u.nval, (int)narr);
  1880.             narr++;
  1881.             needarr = vcall = 1;
  1882.         }
  1883.         expr(ls, &val);
  1884.         if (expr_isk(&key) && key.k != VKNIL &&
  1885.             (key.k == VKSTR || expr_isk_nojump(&val))) {
  1886.             ktap_val_t k, *v;
  1887.             if (!t) {  /* Create template table on demand. */
  1888.                 BCReg kidx;
  1889.                 t = kp_tab_new();
  1890.                 kidx = const_gc(fs, obj2gco(t), KTAP_TTAB);
  1891.                 fs->bcbase[pc].ins = BCINS_AD(BC_TDUP, freg-1,
  1892.                                  kidx);
  1893.             }
  1894.             vcall = 0;
  1895.             expr_kvalue(&k, &key);
  1896.             v = kp_tab_set(t, &k);
  1897.             /* Add const key/value to template table. */
  1898.             if (expr_isk_nojump(&val)) {
  1899.                 expr_kvalue(v, &val);
  1900.             } else {
  1901.                 /* Otherwise create dummy string key (avoids kp_tab_newkey). */
  1902.                 set_table(v, t);  /* Preserve key with table itself as value. */
  1903.                 fixt = 1;/* Fix this later, after all resizes. */
  1904.                 goto nonconst;
  1905.             }
  1906.         } else {
  1907. nonconst:
  1908.             if (val.k != VCALL) {
  1909.                 expr_toanyreg(fs, &val);
  1910.                 vcall = 0;
  1911.             }
  1912.             if (expr_isk(&key))
  1913.                 expr_index(fs, e, &key);
  1914.             bcemit_store(fs, e, &val);
  1915.         }
  1916.         fs->freereg = freg;
  1917.         if (!lex_opt(ls, ',') && !lex_opt(ls, ';'))
  1918.             break;
  1919.     }
  1920.     lex_match(ls, '}', '{', line);
  1921.     if (vcall) {
  1922.         BCInsLine *ilp = &fs->bcbase[fs->pc-1];
  1923.         ExpDesc en;
  1924.         kp_assert(bc_a(ilp->ins) == freg &&
  1925.             bc_op(ilp->ins) == (narr > 256 ? BC_TSETV : BC_TSETB));
  1926.         expr_init(&en, VKNUM, 0);
  1927.         set_number(&en.u.nval, narr - 1);
  1928.         if (narr > 256) { fs->pc--; ilp--; }
  1929.         ilp->ins = BCINS_AD(BC_TSETM, freg, const_num(fs, &en));
  1930.         setbc_b(&ilp[-1].ins, 0);
  1931.     }
  1932.     if (pc == fs->pc-1) {  /* Make expr relocable if possible. */
  1933.         e->u.s.info = pc;
  1934.         fs->freereg--;
  1935.         e->k = VRELOCABLE;
  1936.     } else {
  1937.         e->k = VNONRELOC;  /* May have been changed by expr_index. */
  1938.     }
  1939.     if (!t) {  /* Construct TNEW RD: hhhhhaaaaaaaaaaa. */
  1940.         BCIns *ip = &fs->bcbase[pc].ins;
  1941.         if (!needarr) narr = 0;
  1942.         else if (narr < 3) narr = 3;
  1943.         else if (narr > 0x7ff) narr = 0x7ff;
  1944.         setbc_d(ip, narr|(hsize2hbits(nhash)<<11));
  1945.     } else {
  1946.         if (fixt) {  /* Fix value for dummy keys in template table. */
  1947.             ktap_node_t *node = t->node;
  1948.             uint32_t i, hmask = t->hmask;
  1949.             for (i = 0; i <= hmask; i++) {
  1950.                 ktap_node_t *n = &node[i];
  1951.                 if (is_table(&n->val)) {
  1952.                     kp_assert(tabV(&n->val) == t);
  1953.                     /* Turn value into nil. */
  1954.                     set_nil(&n->val);
  1955.                 }
  1956.             }
  1957.         }
  1958.     }
  1959. }

  1961. /* Parse function parameters. */
  1962. ‌static BCReg parse_params(LexState *ls, int needself)
  1963. {
  1964.     FuncState *fs = ls->fs;
  1965.     BCReg nparams = 0;
  1966.     lex_check(ls, '(');
  1967.     if (needself)
  1968.         var_new_lit(ls, nparams++, "self");
  1969.     if (ls->tok != ')') {
  1970.         do {
  1971.             if (ls->tok == TK_name) {
  1972.                 var_new(ls, nparams++, lex_str(ls));
  1973.             } else if (ls->tok == TK_dots) {
  1974.                 kp_lex_next(ls);
  1975.                 fs->flags |= PROTO_VARARG;
  1976.                 break;
  1977.             } else {
  1978.                 err_syntax(ls, KP_ERR_XPARAM);
  1979.             }
  1980.         } while (lex_opt(ls, ','));
  1981.     }
  1982.     var_add(ls, nparams);
  1983.     kp_assert(fs->nactvar == nparams);
  1984.     bcreg_reserve(fs, nparams);
  1985.     lex_check(ls, ')');
  1986.     return nparams;
  1987. }

  1989. /* Forward declaration. */
  1990. static void parse_chunk(LexState *ls);

  1992. /* Parse body of a function. */
  1993. ‌static void parse_body(LexState *ls, ExpDesc *e, int needself, BCLine line)
  1994. {
  1995.     FuncState fs, *pfs = ls->fs;
  1996.     FuncScope bl;
  1997.     ktap_proto_t *pt;
  1998.     ptrdiff_t oldbase = pfs->bcbase - ls->bcstack;

  2000.     fs_init(ls, &fs);
  2001.     fscope_begin(&fs, &bl, 0);
  2002.     fs.linedefined = line;
  2003.     fs.numparams = (uint8_t)parse_params(ls, needself);
  2004.     fs.bcbase = pfs->bcbase + pfs->pc;
  2005.     fs.bclim = pfs->bclim - pfs->pc;
  2006.     bcemit_AD(&fs, BC_FUNCF, 0, 0);  /* Placeholder. */
  2007.     lex_check(ls, '{');
  2008.     parse_chunk(ls);
  2009.     lex_check(ls, '}');
  2010.     pt = fs_finish(ls, (ls->lastline = ls->linenumber));
  2011.     pfs->bcbase = ls->bcstack + oldbase;  /* May have been reallocated. */
  2012.     pfs->bclim = (BCPos)(ls->sizebcstack - oldbase);
  2013.     /* Store new prototype in the constant array of the parent. */
  2014.     expr_init(e, VRELOCABLE,
  2015.         bcemit_AD(pfs, BC_FNEW, 0,
  2016.               const_gc(pfs, (ktap_obj_t *)pt, KTAP_TPROTO)));
  2017.     if (!(pfs->flags & PROTO_CHILD)) {
  2018.         if (pfs->flags & PROTO_HAS_RETURN)
  2019.             pfs->flags |= PROTO_FIXUP_RETURN;
  2020.         pfs->flags |= PROTO_CHILD;
  2021.     }
  2022.     //kp_lex_next(ls);
  2023. }

  2025. /* Parse body of a function, for 'trace/trace_end/profile/tick' closure */
  2026. ‌static void parse_body_no_args(LexState *ls, ExpDesc *e, int needself,
  2027.                 BCLine line)
  2028. {
  2029.     FuncState fs, *pfs = ls->fs;
  2030.     FuncScope bl;
  2031.     ktap_proto_t *pt;
  2032.     ptrdiff_t oldbase = pfs->bcbase - ls->bcstack;

  2034.     fs_init(ls, &fs);
  2035.     fscope_begin(&fs, &bl, 0);
  2036.     fs.linedefined = line;
  2037.     fs.numparams = 0;
  2038.     fs.bcbase = pfs->bcbase + pfs->pc;
  2039.     fs.bclim = pfs->bclim - pfs->pc;
  2040.     bcemit_AD(&fs, BC_FUNCF, 0, 0);  /* Placeholder. */
  2041.     lex_check(ls, '{');
  2042.     parse_chunk(ls);
  2043.     lex_check(ls, '}');
  2044.     pt = fs_finish(ls, (ls->lastline = ls->linenumber));
  2045.     pfs->bcbase = ls->bcstack + oldbase;  /* May have been reallocated. */
  2046.     pfs->bclim = (BCPos)(ls->sizebcstack - oldbase);
  2047.     /* Store new prototype in the constant array of the parent. */
  2048.     expr_init(e, VRELOCABLE,
  2049.         bcemit_AD(pfs, BC_FNEW, 0,
  2050.               const_gc(pfs, (ktap_obj_t *)pt, KTAP_TPROTO)));
  2051.     if (!(pfs->flags & PROTO_CHILD)) {
  2052.         if (pfs->flags & PROTO_HAS_RETURN)
  2053.             pfs->flags |= PROTO_FIXUP_RETURN;
  2054.         pfs->flags |= PROTO_CHILD;
  2055.     }
  2056.     //kp_lex_next(ls);
  2057. }


  2060. /* Parse expression list. Last expression is left open. */
  2061. ‌static BCReg expr_list(LexState *ls, ExpDesc *v)
  2062. {
  2063.     BCReg n = 1;

  2065.     expr(ls, v);
  2066.     while (lex_opt(ls, ',')) {
  2067.         expr_tonextreg(ls->fs, v);
  2068.         expr(ls, v);
  2069.         n++;
  2070.     }
  2071.     return n;
  2072. }

  2074. /* Parse function argument list. */
  2075. ‌static void parse_args(LexState *ls, ExpDesc *e)
  2076. {
  2077.     FuncState *fs = ls->fs;
  2078.     ExpDesc args;
  2079.     BCIns ins;
  2080.     BCReg base;
  2081.     BCLine line = ls->linenumber;

  2083.     if (ls->tok == '(') {
  2084.         if (line != ls->lastline)
  2085.             err_syntax(ls, KP_ERR_XAMBIG);
  2086.         kp_lex_next(ls);
  2087.         if (ls->tok == ')') {  /* f(). */
  2088.             args.k = VVOID;
  2089.         } else {
  2090.             expr_list(ls, &args);
  2091.             /* f(a, b, g()) or f(a, b, ...). */
  2092.             if (args.k == VCALL) {
  2093.                 /* Pass on multiple results. */
  2094.                 setbc_b(bcptr(fs, &args), 0);
  2095.             }
  2096.         }
  2097.         lex_match(ls, ')', '(', line);
  2098.     } else if (ls->tok == '{') {
  2099.         expr_table(ls, &args);
  2100.     } else if (ls->tok == TK_string) {
  2101.         expr_init(&args, VKSTR, 0);
  2102.         args.u.sval = rawtsvalue(&ls->tokval);
  2103.         kp_lex_next(ls);
  2104.     } else {
  2105.         err_syntax(ls, KP_ERR_XFUNARG);
  2106.         return;  /* Silence compiler. */
  2107.     }

  2109.     kp_assert(e->k == VNONRELOC);
  2110.     base = e->u.s.info;  /* Base register for call. */
  2111.     if (args.k == VCALL) {
  2112.         ins = BCINS_ABC(BC_CALLM, base, 2, args.u.s.aux - base - 1);
  2113.     } else {
  2114.         if (args.k != VVOID)
  2115.             expr_tonextreg(fs, &args);
  2116.         ins = BCINS_ABC(BC_CALL, base, 2, fs->freereg - base);
  2117.     }
  2118.     expr_init(e, VCALL, bcemit_INS(fs, ins));
  2119.     e->u.s.aux = base;
  2120.     fs->bcbase[fs->pc - 1].line = line;
  2121.     fs->freereg = base+1;  /* Leave one result by default. */
  2122. }

  2124. /* Parse primary expression. */
  2125. ‌static void expr_primary(LexState *ls, ExpDesc *v)
  2126. {
  2127.     FuncState *fs = ls->fs;

  2129.     /* Parse prefix expression. */
  2130.     if (ls->tok == '(') {
  2131.         BCLine line = ls->linenumber;
  2132.         kp_lex_next(ls);
  2133.         expr(ls, v);
  2134.         lex_match(ls, ')', '(', line);
  2135.         expr_discharge(ls->fs, v);
  2136.     } else if (ls->tok == TK_name) {
  2137.         var_lookup(ls, v);
  2138.     } else {
  2139.         err_syntax(ls, KP_ERR_XSYMBOL);
  2140.     }

  2142.     for (;;) {  /* Parse multiple expression suffixes. */
  2143.         if (ls->tok == '.') {
  2144.             expr_field(ls, v);
  2145.         } else if (ls->tok == '[') {
  2146.             ExpDesc key;
  2147.             expr_toanyreg(fs, v);
  2148.             expr_bracket(ls, &key);
  2149.             expr_index(fs, v, &key);
  2150.         } else if (ls->tok == ':') {
  2151.             ExpDesc key;
  2152.             kp_lex_next(ls);
  2153.             expr_str(ls, &key);
  2154.             bcemit_method(fs, v, &key);
  2155.             parse_args(ls, v);
  2156.         } else if (ls->tok == '(' || ls->tok == TK_string ||
  2157.                 ls->tok == '{') {
  2158.             expr_tonextreg(fs, v);
  2159.             parse_args(ls, v);
  2160.         } else {
  2161.             break;
  2162.         }
  2163.     }
  2164. }

  2166. /* Parse simple expression. */
  2167. ‌static void expr_simple(LexState *ls, ExpDesc *v)
  2168. {
  2169.     switch (ls->tok) {
  2170.     case TK_number:
  2171.         expr_init(v, VKNUM, 0);
  2172.         set_obj(&v->u.nval, &ls->tokval);
  2173.         break;
  2174.     case TK_string:
  2175.         expr_init(v, VKSTR, 0);
  2176.         v->u.sval = rawtsvalue(&ls->tokval);
  2177.         break;
  2178.     case TK_nil:
  2179.         expr_init(v, VKNIL, 0);
  2180.         break;
  2181.     case TK_true:
  2182.         expr_init(v, VKTRUE, 0);
  2183.         break;
  2184.     case TK_false:
  2185.         expr_init(v, VKFALSE, 0);
  2186.         break;
  2187.     case TK_dots: {  /* Vararg. */
  2188.         FuncState *fs = ls->fs;
  2189.         BCReg base;
  2190.         checkcond(ls, fs->flags & PROTO_VARARG, KP_ERR_XDOTS);
  2191.         bcreg_reserve(fs, 1);
  2192.         base = fs->freereg-1;
  2193.         expr_init(v, VCALL, bcemit_ABC(fs, BC_VARG, base, 2,
  2194.         fs->numparams));
  2195.         v->u.s.aux = base;
  2196.         break;
  2197.     }
  2198.     case '{':  /* Table constructor. */
  2199.         expr_table(ls, v);
  2200.         return;
  2201.     case TK_function:
  2202.         kp_lex_next(ls);
  2203.         parse_body(ls, v, 0, ls->linenumber);
  2204.         return;
  2205.     case TK_argstr:
  2206.         expr_init(v, VARGSTR, 0);
  2207.         break;
  2208.     case TK_probename:
  2209.         expr_init(v, VARGNAME, 0);
  2210.         break;
  2211.     case TK_arg0: case TK_arg1: case TK_arg2: case TK_arg3: case TK_arg4:
  2212.     case TK_arg5: case TK_arg6: case TK_arg7: case TK_arg8: case TK_arg9:
  2213.         expr_init(v, VARGN, ls->tok - TK_arg0);
  2214.         break;
  2215.     case TK_pid:
  2216.         expr_init(v, VPID, 0);
  2217.         break;
  2218.     case TK_tid:
  2219.         expr_init(v, VTID, 0);
  2220.         break;
  2221.     case TK_uid:
  2222.         expr_init(v, VUID, 0);
  2223.         break;
  2224.     case TK_cpu:
  2225.         expr_init(v, VCPU, 0);
  2226.         break;
  2227.     case TK_execname:
  2228.         expr_init(v, VEXECNAME, 0);
  2229.         break;
  2230.     default:
  2231.         expr_primary(ls, v);
  2232.         return;
  2233.     }
  2234.     kp_lex_next(ls);
  2235. }

  2237. /* Manage syntactic levels to avoid blowing up the stack. */
  2238. ‌static void synlevel_begin(LexState *ls)
  2239. {
  2240.     if (++ls->level >= KP_MAX_XLEVEL)
  2241.         kp_lex_error(ls, 0, KP_ERR_XLEVELS);
  2242. }

  2244. ‌#define synlevel_end(ls)    ((ls)->level--)

  2246. /* Convert token to binary operator. */
  2247. ‌static BinOpr token2binop(LexToken tok)
  2248. {
  2249.     switch (tok) {
  2250.     case '+':    return OPR_ADD;
  2251.     case '-':    return OPR_SUB;
  2252.     case '*':    return OPR_MUL;
  2253.     case '/':    return OPR_DIV;
  2254.     case '%':    return OPR_MOD;
  2255.     case '^':    return OPR_POW;
  2256.     case TK_concat: return OPR_CONCAT;
  2257.     case TK_ne:    return OPR_NE;
  2258.     case TK_eq:    return OPR_EQ;
  2259.     case '<':    return OPR_LT;
  2260.     case TK_le:    return OPR_LE;
  2261.     case '>':    return OPR_GT;
  2262.     case TK_ge:    return OPR_GE;
  2263.     case TK_and:    return OPR_AND;
  2264.     case TK_or:    return OPR_OR;
  2265.     default:    return OPR_NOBINOPR;
  2266.     }
  2267. }

  2269. /* Priorities for each binary operator. ORDER OPR. */
  2270. static const struct {
  2271.     uint8_t left;    /* Left priority. */
  2272.     uint8_t right;    /* Right priority. */
  2273. ‌} priority[] = {
  2274.     {6,6}, {6,6}, {7,7}, {7,7}, {7,7},    /* ADD SUB MUL DIV MOD */
  2275.     {10,9}, {5,4},            /* POW CONCAT (right associative) */
  2276.     {3,3}, {3,3},                /* EQ NE */
  2277.     {3,3}, {3,3}, {3,3}, {3,3},        /* LT GE GT LE */
  2278.     {2,2}, {1,1}                /* AND OR */
  2279. };

  2281. ‌#define UNARY_PRIORITY        8  /* Priority for unary operators. */

  2283. /* Forward declaration. */
  2284. static BinOpr expr_binop(LexState *ls, ExpDesc *v, uint32_t limit);

  2286. /* Parse unary expression. */
  2287. ‌static void expr_unop(LexState *ls, ExpDesc *v)
  2288. {
  2289.     BCOp op;
  2290.     if (ls->tok == TK_not) {
  2291.         op = BC_NOT;
  2292.     } else if (ls->tok == '-') {
  2293.         op = BC_UNM;
  2294. #if 0 /* ktap don't support lua length operator '#' */
  2295.     } else if (ls->tok == '#') {
  2296.         op = BC_LEN;
  2297. #endif
  2298.     } else {
  2299.         expr_simple(ls, v);
  2300.         return;
  2301.     }
  2302.     kp_lex_next(ls);
  2303.     expr_binop(ls, v, UNARY_PRIORITY);
  2304.     bcemit_unop(ls->fs, op, v);
  2305. }

  2307. /* Parse binary expressions with priority higher than the limit. */
  2308. ‌static BinOpr expr_binop(LexState *ls, ExpDesc *v, uint32_t limit)
  2309. {
  2310.     BinOpr op;

  2312.     synlevel_begin(ls);
  2313.     expr_unop(ls, v);
  2314.     op = token2binop(ls->tok);
  2315.     while (op != OPR_NOBINOPR && priority[op].left > limit) {
  2316.         ExpDesc v2;
  2317.         BinOpr nextop;
  2318.         kp_lex_next(ls);
  2319.         bcemit_binop_left(ls->fs, op, v);
  2320.         /* Parse binary expression with higher priority. */
  2321.         nextop = expr_binop(ls, &v2, priority[op].right);
  2322.         bcemit_binop(ls->fs, op, v, &v2);
  2323.         op = nextop;
  2324.     }
  2325.     synlevel_end(ls);
  2326.     return op;  /* Return unconsumed binary operator (if any). */
  2327. }

  2329. /* Parse expression. */
  2330. ‌static void expr(LexState *ls, ExpDesc *v)
  2331. {
  2332.     expr_binop(ls, v, 0);  /* Priority 0: parse whole expression. */
  2333. }

  2335. /* Assign expression to the next register. */
  2336. ‌static void expr_next(LexState *ls)
  2337. {
  2338.     ExpDesc e;
  2339.     expr(ls, &e);
  2340.     expr_tonextreg(ls->fs, &e);
  2341. }

  2343. /* Parse conditional expression. */
  2344. ‌static BCPos expr_cond(LexState *ls)
  2345. {
  2346.     ExpDesc v;

  2348.     lex_check(ls, '(');
  2349.     expr(ls, &v);
  2350.     if (v.k == VKNIL)
  2351.         v.k = VKFALSE;
  2352.     bcemit_branch_t(ls->fs, &v);
  2353.     lex_check(ls, ')');
  2354.     return v.f;
  2355. }

  2357. /* -- Assignments --------------------------------------------------------- */

  2359. /* List of LHS variables. */
  2360. ‌typedef struct LHSVarList {
  2361.     ExpDesc v;            /* LHS variable. */
  2362.     struct LHSVarList *prev;    /* Link to previous LHS variable. */
  2363. ‌} LHSVarList;

  2365. /* Eliminate write-after-read hazards for local variable assignment. */
  2366. ‌static void assign_hazard(LexState *ls, LHSVarList *lh, const ExpDesc *v)
  2367. {
  2368.     FuncState *fs = ls->fs;
  2369.     BCReg reg = v->u.s.info; /* Check against this variable. */
  2370.     BCReg tmp = fs->freereg; /* Rename to this temp. register(if needed) */
  2371.     int hazard = 0;

  2373.     for (; lh; lh = lh->prev) {
  2374.         if (lh->v.k == VINDEXED) {
  2375.             if (lh->v.u.s.info == reg) {  /* t[i], t = 1, 2 */
  2376.                 hazard = 1;
  2377.                 lh->v.u.s.info = tmp;
  2378.             }
  2379.             if (lh->v.u.s.aux == reg) {  /* t[i], i = 1, 2 */
  2380.                 hazard = 1;
  2381.                 lh->v.u.s.aux = tmp;
  2382.             }
  2383.         }
  2384.     }
  2385.     if (hazard) {
  2386.         /* Rename conflicting variable. */
  2387.         bcemit_AD(fs, BC_MOV, tmp, reg);
  2388.         bcreg_reserve(fs, 1);
  2389.     }
  2390. }

  2392. /* Adjust LHS/RHS of an assignment. */
  2393. ‌static void assign_adjust(LexState *ls, BCReg nvars, BCReg nexps, ExpDesc *e)
  2394. {
  2395.     FuncState *fs = ls->fs;
  2396.     int32_t extra = (int32_t)nvars - (int32_t)nexps;

  2398.     if (e->k == VCALL) {
  2399.         extra++;  /* Compensate for the VCALL itself. */
  2400.         if (extra < 0)
  2401.             extra = 0;
  2402.         setbc_b(bcptr(fs, e), extra+1);  /* Fixup call results. */
  2403.         if (extra > 1)
  2404.             bcreg_reserve(fs, (BCReg)extra-1);
  2405.     } else {
  2406.         if (e->k != VVOID)
  2407.             expr_tonextreg(fs, e);  /* Close last expression. */
  2408.         if (extra > 0) {  /* Leftover LHS are set to nil. */
  2409.             BCReg reg = fs->freereg;
  2410.             bcreg_reserve(fs, (BCReg)extra);
  2411.             bcemit_nil(fs, reg, (BCReg)extra);
  2412.         }
  2413.     }
  2414. }

  2416. /* Recursively parse assignment statement. */
  2417. ‌static void parse_assignment(LexState *ls, LHSVarList *lh, BCReg nvars)
  2418. {
  2419.     ExpDesc e;

  2421.     checkcond(ls, VLOCAL <= lh->v.k && lh->v.k <= VINDEXED,
  2422.             KP_ERR_XSYNTAX);
  2423.     if (lex_opt(ls, ',')) {  /* Collect LHS list and recurse upwards. */
  2424.         LHSVarList vl;
  2425.         vl.prev = lh;
  2426.         expr_primary(ls, &vl.v);
  2427.         if (vl.v.k == VLOCAL)
  2428.             assign_hazard(ls, lh, &vl.v);
  2429.         checklimit(ls->fs, ls->level + nvars, KP_MAX_XLEVEL,
  2430.                 "variable names");
  2431.         parse_assignment(ls, &vl, nvars+1);
  2432.     } else {  /* Parse RHS. */
  2433.         BCReg nexps;
  2434.         int assign_incr = 1;

  2436.         if (lex_opt(ls, '='))
  2437.             assign_incr = 0;
  2438.         else if (lex_opt(ls, TK_incr))
  2439.             assign_incr = 1;
  2440.         else
  2441.             err_syntax(ls, KP_ERR_XSYMBOL);

  2443.         nexps = expr_list(ls, &e);
  2444.         if (nexps == nvars) {
  2445.             if (e.k == VCALL) {
  2446.                 /* Vararg assignment. */
  2447.                 if (bc_op(*bcptr(ls->fs, &e)) == BC_VARG) {
  2448.                     ls->fs->freereg--;
  2449.                     e.k = VRELOCABLE;
  2450.                 } else {  /* Multiple call results. */
  2451.                     /* Base of call is not relocatable. */
  2452.                     e.u.s.info = e.u.s.aux;
  2453.                     e.k = VNONRELOC;
  2454.                 }
  2455.             }
  2456.             if (assign_incr == 0)
  2457.                 bcemit_store(ls->fs, &lh->v, &e);
  2458.             else
  2459.                 bcemit_store_incr(ls->fs, &lh->v, &e);
  2460.             return;
  2461.         }
  2462.         assign_adjust(ls, nvars, nexps, &e);
  2463.         if (nexps > nvars) {
  2464.             /* Drop leftover regs. */
  2465.             ls->fs->freereg -= nexps - nvars;
  2466.         }
  2467.     }
  2468.     /* Assign RHS to LHS and recurse downwards. */
  2469.     expr_init(&e, VNONRELOC, ls->fs->freereg-1);
  2470.     bcemit_store(ls->fs, &lh->v, &e);
  2471. }

  2473. /* Parse call statement or assignment. */
  2474. ‌static void parse_call_assign(LexState *ls)
  2475. {
  2476.     FuncState *fs = ls->fs;
  2477.     LHSVarList vl;

  2479.     expr_primary(ls, &vl.v);
  2480.     if (vl.v.k == VCALL) {  /* Function call statement. */
  2481.         setbc_b(bcptr(fs, &vl.v), 1);  /* No results. */
  2482.     } else {  /* Start of an assignment. */
  2483.         vl.prev = NULL;
  2484.         parse_assignment(ls, &vl, 1);
  2485.     }
  2486. }

  2488. /* Parse 'var'(local in lua) statement. */
  2489. ‌static void parse_local(LexState *ls)
  2490. {
  2491.     if (lex_opt(ls, TK_function)) {  /* Local function declaration. */
  2492.         ExpDesc v, b;
  2493.         FuncState *fs = ls->fs;
  2494.         var_new(ls, 0, lex_str(ls));
  2495.         expr_init(&v, VLOCAL, fs->freereg);
  2496.         v.u.s.aux = fs->varmap[fs->freereg];
  2497.         bcreg_reserve(fs, 1);
  2498.         var_add(ls, 1);
  2499.         parse_body(ls, &b, 0, ls->linenumber);
  2500.         /* bcemit_store(fs, &v, &b) without setting VSTACK_VAR_RW. */
  2501.         expr_free(fs, &b);
  2502.         expr_toreg(fs, &b, v.u.s.info);
  2503.         /* The upvalue is in scope, but the local is only valid
  2504.          * after the store. */
  2505.         var_get(ls, fs, fs->nactvar - 1).startpc = fs->pc;
  2506.     } else {  /* Local variable declaration. */
  2507.         ExpDesc e;
  2508.         BCReg nexps, nvars = 0;
  2509.         do {  /* Collect LHS. */
  2510.             var_new(ls, nvars++, lex_str(ls));
  2511.         } while (lex_opt(ls, ','));
  2512.         if (lex_opt(ls, '=')) {  /* Optional RHS. */
  2513.             nexps = expr_list(ls, &e);
  2514.         } else {  /* Or implicitly set to nil. */
  2515.             e.k = VVOID;
  2516.             nexps = 0;
  2517.         }
  2518.         assign_adjust(ls, nvars, nexps, &e);
  2519.         var_add(ls, nvars);
  2520.     }
  2521. }

  2523. /* Parse 'function' statement. */
  2524. ‌static void parse_func(LexState *ls, BCLine line)
  2525. {
  2526.     FuncState *fs = ls->fs;
  2527.     ExpDesc v, b;

  2529.     kp_lex_next(ls);  /* Skip 'function'. */

  2531.     /* function is declared as local */
  2532. #if 1
  2533.     var_new(ls, 0, lex_str(ls));
  2534.     expr_init(&v, VLOCAL, fs->freereg);
  2535.     v.u.s.aux = fs->varmap[fs->freereg];
  2536.     bcreg_reserve(fs, 1);
  2537.     var_add(ls, 1);
  2538.     parse_body(ls, &b, 0, ls->linenumber);
  2539.     /* bcemit_store(fs, &v, &b) without setting VSTACK_VAR_RW. */
  2540.     expr_free(fs, &b);
  2541.     expr_toreg(fs, &b, v.u.s.info);
  2542.     /* The upvalue is in scope, but the local is only valid
  2543.      * after the store. */
  2544.     var_get(ls, fs, fs->nactvar - 1).startpc = fs->pc;

  2546. #else
  2547.     int needself = 0;

  2549.     /* Parse function name. */
  2550.     var_lookup(ls, &v);
  2551.     while (ls->tok == '.')  /* Multiple dot-separated fields. */
  2552.         expr_field(ls, &v);
  2553.     if (ls->tok == ':') {  /* Optional colon to signify method call. */
  2554.         needself = 1;
  2555.         expr_field(ls, &v);
  2556.     }
  2557.     parse_body(ls, &b, needself, line);
  2558.     fs = ls->fs;
  2559.     bcemit_store(fs, &v, &b);
  2560.     fs->bcbase[fs->pc - 1].line = line;  /* Set line for the store. */
  2561. #endif
  2562. }

  2564. /* -- Control transfer statements ----------------------------------------- */

  2566. /* Check for end of block. */
  2567. ‌static int parse_isend(LexToken tok)
  2568. {
  2569.     switch (tok) {
  2570.     case TK_else: case TK_elseif: case TK_end: case TK_until: case TK_eof:
  2571.     case '}':
  2572.         return 1;
  2573.     default:
  2574.         return 0;
  2575.     }
  2576. }

  2578. /* Parse 'return' statement. */
  2579. ‌static void parse_return(LexState *ls)
  2580. {
  2581.     BCIns ins;
  2582.     FuncState *fs = ls->fs;

  2584.     kp_lex_next(ls);  /* Skip 'return'. */
  2585.     fs->flags |= PROTO_HAS_RETURN;
  2586.     if (parse_isend(ls->tok) || ls->tok == ';') {  /* Bare return. */
  2587.         ins = BCINS_AD(BC_RET0, 0, 1);
  2588.     } else {  /* Return with one or more values. */
  2589.         ExpDesc e;  /* Receives the _last_ expression in the list. */
  2590.         BCReg nret = expr_list(ls, &e);
  2591.         if (nret == 1) {  /* Return one result. */
  2592.             if (e.k == VCALL) {  /* Check for tail call. */
  2593.                 BCIns *ip = bcptr(fs, &e);
  2594.                 /* It doesn't pay off to add BC_VARGT just
  2595.                  * for 'return ...'. */
  2596.                 if (bc_op(*ip) == BC_VARG)
  2597.                     goto notailcall;
  2598.                 fs->pc--;
  2599.                 ins = BCINS_AD(bc_op(*ip)-BC_CALL+BC_CALLT,
  2600.                         bc_a(*ip), bc_c(*ip));
  2601.             } else { /* Can return the result from any register. */
  2602.                 ins = BCINS_AD(BC_RET1,
  2603.                     expr_toanyreg(fs, &e), 2);
  2604.             }
  2605.         } else {
  2606.             if (e.k == VCALL) {/* Append all results from a call */
  2607. notailcall:
  2608.                 setbc_b(bcptr(fs, &e), 0);
  2609.                 ins = BCINS_AD(BC_RETM, fs->nactvar,
  2610.                         e.u.s.aux - fs->nactvar);
  2611.             } else {
  2612.                 /* Force contiguous registers. */
  2613.                 expr_tonextreg(fs, &e);
  2614.                 ins = BCINS_AD(BC_RET, fs->nactvar, nret+1);
  2615.             }
  2616.         }
  2617.     }
  2618.     if (fs->flags & PROTO_CHILD) {
  2619.         /* May need to close upvalues first. */
  2620.         bcemit_AJ(fs, BC_UCLO, 0, 0);
  2621.     }
  2622.     bcemit_INS(fs, ins);
  2623. }

  2625. /* Parse 'break' statement. */
  2626. ‌static void parse_break(LexState *ls)
  2627. {
  2628.     ls->fs->bl->flags |= FSCOPE_BREAK;
  2629.     gola_new(ls, NAME_BREAK, VSTACK_GOTO, bcemit_jmp(ls->fs));
  2630. }

  2632. /* Parse label. */
  2633. ‌static void parse_label(LexState *ls)
  2634. {
  2635.     FuncState *fs = ls->fs;
  2636.     ktap_str_t *name;
  2637.     int idx;

  2639.     fs->lasttarget = fs->pc;
  2640.     fs->bl->flags |= FSCOPE_GOLA;
  2641.     kp_lex_next(ls);  /* Skip '::'. */
  2642.     name = lex_str(ls);
  2643.     if (gola_findlabel(ls, name))
  2644.         kp_lex_error(ls, 0, KP_ERR_XLDUP, getstr(name));
  2645.     idx = gola_new(ls, name, VSTACK_LABEL, fs->pc);
  2646.     lex_check(ls, TK_label);
  2647.     /* Recursively parse trailing statements: labels and ';'. */
  2648.     for (;;) {
  2649.         if (ls->tok == TK_label) {
  2650.             synlevel_begin(ls);
  2651.             parse_label(ls);
  2652.             synlevel_end(ls);
  2653.         } else if (ls->tok == ';') {
  2654.             kp_lex_next(ls);
  2655.         } else {
  2656.             break;
  2657.         }
  2658.     }
  2659.     /* Trailing label is considered to be outside of scope. */
  2660.     if (parse_isend(ls->tok) && ls->tok != TK_until)
  2661.         ls->vstack[idx].slot = fs->bl->nactvar;
  2662.     gola_resolve(ls, fs->bl, idx);
  2663. }

  2665. /* -- Blocks, loops and conditional statements ---------------------------- */

  2667. /* Parse a block. */
  2668. ‌static void parse_block(LexState *ls)
  2669. {
  2670.     FuncState *fs = ls->fs;
  2671.     FuncScope bl;

  2673.     fscope_begin(fs, &bl, 0);
  2674.     parse_chunk(ls);
  2675.     fscope_end(fs);
  2676. }

  2678. /* Parse 'while' statement. */
  2679. ‌static void parse_while(LexState *ls, BCLine line)
  2680. {
  2681.     FuncState *fs = ls->fs;
  2682.     BCPos start, loop, condexit;
  2683.     FuncScope bl;

  2685.     kp_lex_next(ls);  /* Skip 'while'. */
  2686.     start = fs->lasttarget = fs->pc;
  2687.     condexit = expr_cond(ls);
  2688.     fscope_begin(fs, &bl, FSCOPE_LOOP);
  2689.     //lex_check(ls, TK_do);
  2690.     lex_check(ls, '{');
  2691.     loop = bcemit_AD(fs, BC_LOOP, fs->nactvar, 0);
  2692.     parse_block(ls);
  2693.     jmp_patch(fs, bcemit_jmp(fs), start);
  2694.     //lex_match(ls, TK_end, TK_while, line);
  2695.     lex_check(ls, '}');
  2696.     fscope_end(fs);
  2697.     jmp_tohere(fs, condexit);
  2698.     jmp_patchins(fs, loop, fs->pc);
  2699. }

  2701. /* Parse 'repeat' statement. */
  2702. ‌static void parse_repeat(LexState *ls, BCLine line)
  2703. {
  2704.     FuncState *fs = ls->fs;
  2705.     BCPos loop = fs->lasttarget = fs->pc;
  2706.     BCPos condexit;
  2707.     FuncScope bl1, bl2;

  2709.     fscope_begin(fs, &bl1, FSCOPE_LOOP);  /* Breakable loop scope. */
  2710.     fscope_begin(fs, &bl2, 0);  /* Inner scope. */
  2711.     kp_lex_next(ls);  /* Skip 'repeat'. */
  2712.     bcemit_AD(fs, BC_LOOP, fs->nactvar, 0);
  2713.     parse_chunk(ls);
  2714.     lex_match(ls, TK_until, TK_repeat, line);
  2715.     /* Parse condition (still inside inner scope). */
  2716.     condexit = expr_cond(ls);
  2717.     /* No upvalues? Just end inner scope. */
  2718.     if (!(bl2.flags & FSCOPE_UPVAL)) {
  2719.         fscope_end(fs);
  2720.     } else {
  2721.         /* Otherwise generate: cond: UCLO+JMP out,
  2722.          * !cond: UCLO+JMP loop. */
  2723.         parse_break(ls);  /* Break from loop and close upvalues. */
  2724.         jmp_tohere(fs, condexit);
  2725.         fscope_end(fs);  /* End inner scope and close upvalues. */
  2726.         condexit = bcemit_jmp(fs);
  2727.     }
  2728.     jmp_patch(fs, condexit, loop);  /* Jump backwards if !cond. */
  2729.     jmp_patchins(fs, loop, fs->pc);
  2730.     fscope_end(fs);  /* End loop scope. */
  2731. }

  2733. /* Parse numeric 'for'. */
  2734. ‌static void parse_for_num(LexState *ls, ktap_str_t *varname, BCLine line)
  2735. {
  2736.     FuncState *fs = ls->fs;
  2737.     BCReg base = fs->freereg;
  2738.     FuncScope bl;
  2739.     BCPos loop, loopend;

  2741.     /* Hidden control variables. */
  2742.     var_new_fixed(ls, FORL_IDX, VARNAME_FOR_IDX);
  2743.     var_new_fixed(ls, FORL_STOP, VARNAME_FOR_STOP);
  2744.     var_new_fixed(ls, FORL_STEP, VARNAME_FOR_STEP);
  2745.     /* Visible copy of index variable. */
  2746.     var_new(ls, FORL_EXT, varname);
  2747.     lex_check(ls, '=');
  2748.     expr_next(ls);
  2749.     lex_check(ls, ',');
  2750.     expr_next(ls);
  2751.     if (lex_opt(ls, ',')) {
  2752.         expr_next(ls);
  2753.     } else {
  2754.         /* Default step is 1. */
  2755.         bcemit_AD(fs, BC_KSHORT, fs->freereg, 1);
  2756.         bcreg_reserve(fs, 1);
  2757.     }
  2758.     var_add(ls, 3);  /* Hidden control variables. */
  2759.     //lex_check(ls, TK_do);
  2760.     lex_check(ls, ')');
  2761.     lex_check(ls, '{');
  2762.     loop = bcemit_AJ(fs, BC_FORI, base, NO_JMP);
  2763.     fscope_begin(fs, &bl, 0);  /* Scope for visible variables. */
  2764.     var_add(ls, 1);
  2765.     bcreg_reserve(fs, 1);
  2766.     parse_block(ls);
  2767.     fscope_end(fs);
  2768.     /* Perform loop inversion. Loop control instructions are at the end. */
  2769.     loopend = bcemit_AJ(fs, BC_FORL, base, NO_JMP);
  2770.     fs->bcbase[loopend].line = line;  /* Fix line for control ins. */
  2771.     jmp_patchins(fs, loopend, loop+1);
  2772.     jmp_patchins(fs, loop, fs->pc);
  2773. }

  2775. /*
  2776. * Try to predict whether the iterator is next() and specialize the bytecode.
  2777. * Detecting next() and pairs() by name is simplistic, but quite effective.
  2778. * The interpreter backs off if the check for the closure fails at runtime.
  2779. */
  2780. ‌static int predict_next(LexState *ls, FuncState *fs, BCPos pc)
  2781. {
  2782.     BCIns ins = fs->bcbase[pc].ins;
  2783.     ktap_str_t *name;
  2784.     const ktap_val_t *o;

  2786.     switch (bc_op(ins)) {
  2787.     case BC_MOV:
  2788.         name = var_get(ls, fs, bc_d(ins)).name;
  2789.         break;
  2790.     case BC_UGET:
  2791.         name = ls->vstack[fs->uvmap[bc_d(ins)]].name;
  2792.         break;
  2793.     case BC_GGET:
  2794.         /* There's no inverse index (yet), so lookup the strings. */
  2795.         o = kp_tab_getstr(fs->kt, kp_str_newz("pairs"));
  2796.         if (o && tvhaskslot(o) && tvkslot(o) == bc_d(ins))
  2797.             return 1;
  2798.         o = kp_tab_getstr(fs->kt, kp_str_newz("next"));
  2799.         if (o && tvhaskslot(o) && tvkslot(o) == bc_d(ins))
  2800.             return 1;
  2801.         return 0;
  2802.     default:
  2803.         return 0;
  2804.     }

  2806.     return (name->len == 5 && !strcmp(getstr(name), "pairs")) ||
  2807.         (name->len == 4 && !strcmp(getstr(name), "next"));
  2808. }

  2810. /* Parse 'for' iterator. */
  2811. ‌static void parse_for_iter(LexState *ls, ktap_str_t *indexname)
  2812. {
  2813.     FuncState *fs = ls->fs;
  2814.     ExpDesc e;
  2815.     BCReg nvars = 0;
  2816.     BCLine line;
  2817.     BCReg base = fs->freereg + 3;
  2818.     BCPos loop, loopend, exprpc = fs->pc;
  2819.     FuncScope bl;
  2820.     int isnext;

  2822.     /* Hidden control variables. */
  2823.     var_new_fixed(ls, nvars++, VARNAME_FOR_GEN);
  2824.     var_new_fixed(ls, nvars++, VARNAME_FOR_STATE);
  2825.     var_new_fixed(ls, nvars++, VARNAME_FOR_CTL);

  2827.     /* Visible variables returned from iterator. */
  2828.     var_new(ls, nvars++, indexname);
  2829.     while (lex_opt(ls, ','))
  2830.         var_new(ls, nvars++, lex_str(ls));
  2831.     lex_check(ls, TK_in);
  2832.     line = ls->linenumber;
  2833.     assign_adjust(ls, 3, expr_list(ls, &e), &e);
  2834.     /* The iterator needs another 3 slots (func + 2 args). */
  2835.     bcreg_bump(fs, 3);
  2836.     isnext = (nvars <= 5 && predict_next(ls, fs, exprpc));
  2837.     var_add(ls, 3);  /* Hidden control variables. */
  2838.     //lex_check(ls, TK_do);
  2839.     lex_check(ls, ')');
  2840.     lex_check(ls, '{');
  2841.     loop = bcemit_AJ(fs, isnext ? BC_ISNEXT : BC_JMP, base, NO_JMP);
  2842.     fscope_begin(fs, &bl, 0);  /* Scope for visible variables. */
  2843.     var_add(ls, nvars-3);
  2844.     bcreg_reserve(fs, nvars-3);
  2845.     parse_block(ls);
  2846.     fscope_end(fs);
  2847.     /* Perform loop inversion. Loop control instructions are at the end. */
  2848.     jmp_patchins(fs, loop, fs->pc);
  2849.     bcemit_ABC(fs, isnext ? BC_ITERN : BC_ITERC, base, nvars-3+1, 2+1);
  2850.     loopend = bcemit_AJ(fs, BC_ITERL, base, NO_JMP);
  2851.     fs->bcbase[loopend-1].line = line;  /* Fix line for control ins. */
  2852.     fs->bcbase[loopend].line = line;
  2853.     jmp_patchins(fs, loopend, loop+1);
  2854. }

  2856. /* Parse 'for' statement. */
  2857. ‌static void parse_for(LexState *ls, BCLine line)
  2858. {
  2859.     FuncState *fs = ls->fs;
  2860.     ktap_str_t *varname;
  2861.     FuncScope bl;

  2863.     fscope_begin(fs, &bl, FSCOPE_LOOP);
  2864.     kp_lex_next(ls);  /* Skip 'for'. */
  2865.     lex_check(ls, '(');
  2866.     varname = lex_str(ls);  /* Get first variable name. */
  2867.     if (ls->tok == '=')
  2868.         parse_for_num(ls, varname, line);
  2869.     else if (ls->tok == ',' || ls->tok == TK_in)
  2870.         parse_for_iter(ls, varname);
  2871.     else
  2872.         err_syntax(ls, KP_ERR_XFOR);
  2873.     //lex_check(ls, '}');
  2874.     //lex_match(ls, TK_end, TK_for, line);
  2875.     lex_match(ls, '}', TK_for, line);
  2876.     fscope_end(fs);  /* Resolve break list. */
  2877. }

  2879. /* Parse condition and 'then' block. */
  2880. ‌static BCPos parse_then(LexState *ls)
  2881. {
  2882.     BCPos condexit;
  2883.     kp_lex_next(ls);  /* Skip 'if' or 'elseif'. */
  2884.     condexit = expr_cond(ls);
  2885.     lex_check(ls, '{');
  2886.     parse_block(ls);
  2887.     lex_check(ls, '}');
  2888.     return condexit;
  2889. }

  2891. /* Parse 'if' statement. */
  2892. ‌static void parse_if(LexState *ls, BCLine line)
  2893. {
  2894.     FuncState *fs = ls->fs;
  2895.     BCPos flist;
  2896.     BCPos escapelist = NO_JMP;
  2897.     flist = parse_then(ls);
  2898.     while (ls->tok == TK_elseif) {  /* Parse multiple 'elseif' blocks. */
  2899.         jmp_append(fs, &escapelist, bcemit_jmp(fs));
  2900.         jmp_tohere(fs, flist);
  2901.         flist = parse_then(ls);
  2902.     }
  2903.     if (ls->tok == TK_else) {  /* Parse optional 'else' block. */
  2904.         jmp_append(fs, &escapelist, bcemit_jmp(fs));
  2905.         jmp_tohere(fs, flist);
  2906.         kp_lex_next(ls);  /* Skip 'else'. */
  2907.         lex_check(ls, '{');
  2908.         parse_block(ls);
  2909.         lex_check(ls, '}');
  2910.     } else {
  2911.         jmp_append(fs, &escapelist, flist);
  2912.     }
  2913.     jmp_tohere(fs, escapelist);
  2914.     //lex_match(ls, TK_end, TK_if, line);
  2915. }

  2917. /* Parse 'trace' and 'trace_end' statement. */
  2918. ‌static void parse_trace(LexState *ls)
  2919. {
  2920.     ExpDesc v, key, args;
  2921.     ktap_str_t *kdebug_str = kp_str_newz("kdebug");
  2922.     ktap_str_t *probe_str = kp_str_newz("trace_by_id");
  2923.     ktap_str_t *probe_end_str = kp_str_newz("trace_end");
  2924.     FuncState *fs = ls->fs;
  2925.     int token = ls->tok;
  2926.     BCIns ins;
  2927.     BCReg base;
  2928.     BCLine line = ls->linenumber;

  2930.     if (token == TK_trace)
  2931.         kp_lex_read_string_until(ls, '{');
  2932.     else
  2933.         kp_lex_next(ls);  /* skip "trace_end" keyword */

  2935.     /* kdebug */
  2936.     expr_init(&v, VGLOBAL, 0);
  2937.     v.u.sval = kdebug_str;
  2938.     expr_toanyreg(fs, &v);

  2940.     /* fieldsel: kdebug.probe */
  2941.     expr_init(&key, VKSTR, 0);
  2942.     key.u.sval = token == TK_trace ? probe_str : probe_end_str;
  2943.     expr_index(fs, &v, &key);

  2945.     /* funcargs*/
  2946.     expr_tonextreg(fs, &v);

  2948.     if (token == TK_trace) {
  2949.         ktap_eventdesc_t *evdef_info;
  2950.         const char *str;

  2952.         /* argument: EVENTDEF string */
  2953.         lex_check(ls, TK_string);
  2954.         str = svalue(&ls->tokval);
  2955.         evdef_info = kp_parse_events(str);
  2956.         if (!evdef_info)
  2957.             kp_lex_error(ls, 0, KP_ERR_XEVENTDEF, str);


  2960.         /* pass a userspace pointer to kernel */
  2961.         expr_init(&args, VKNUM, 0);
  2962.         set_number(&args.u.nval, (ktap_number)evdef_info);

  2964.         expr_tonextreg(fs, &args);
  2965.     }

  2967.     /* argument: callback function */
  2968.     parse_body_no_args(ls, &args, 0, ls->linenumber);

  2970.     expr_tonextreg(fs, &args);

  2972.     base = v.u.s.info;  /* base register for call */
  2973.     ins = BCINS_ABC(BC_CALL, base, 2, fs->freereg - base);

  2975.     expr_init(&v, VCALL, bcemit_INS(fs, ins));
  2976.     v.u.s.aux = base;
  2977.     fs->bcbase[fs->pc - 1].line = line;
  2978.     fs->freereg = base+1;  /* Leave one result by default. */

  2980.     setbc_b(bcptr(fs, &v), 1);  /* No results. */
  2981. }


  2984. /* Parse 'profile' and 'tick' statement. */
  2985. ‌static void parse_timer(LexState *ls)
  2986. {
  2987.     FuncState *fs = ls->fs;
  2988.     ExpDesc v, key, args;
  2989.     ktap_str_t *token_str = rawtsvalue(&ls->tokval);
  2990.     ktap_str_t *interval_str;
  2991.     BCLine line = ls->linenumber;
  2992.     BCIns ins;
  2993.     BCReg base;

  2995.     kp_lex_next(ls);  /* skip '-' */

  2997.     kp_lex_read_string_until(ls, '{');
  2998.     interval_str = rawtsvalue(&ls->tokval);
  2999.     lex_check(ls, TK_string);

  3001.     /* timer */
  3002.     expr_init(&v, VGLOBAL, 0);
  3003.     v.u.sval = kp_str_newz("timer");
  3004.     expr_toanyreg(fs, &v);

  3006.     /* fieldsel: timer.profile, timer.tick */
  3007.     expr_init(&key, VKSTR, 0);
  3008.     key.u.sval = token_str;
  3009.     expr_index(fs, &v, &key);

  3011.     /* funcargs*/
  3012.     expr_tonextreg(fs, &v);

  3014.     /* argument: interval string */
  3015.     expr_init(&args, VKSTR, 0);
  3016.     args.u.sval = interval_str;

  3018.     expr_tonextreg(fs, &args);

  3020.     /* argument: callback function */
  3021.     parse_body_no_args(ls, &args, 0, ls->linenumber);

  3023.     expr_tonextreg(fs, &args);

  3025.     base = v.u.s.info;  /* base register for call */
  3026.     ins = BCINS_ABC(BC_CALL, base, 2, fs->freereg - base);

  3028.     expr_init(&v, VCALL, bcemit_INS(fs, ins));
  3029.     v.u.s.aux = base;
  3030.     fs->bcbase[fs->pc - 1].line = line;
  3031.     fs->freereg = base+1;  /* Leave one result by default. */

  3033.     setbc_b(bcptr(fs, &v), 1);  /* No results. */
  3034. }

  3036. /* -- Parse statements ---------------------------------------------------- */

  3038. /* Parse a statement. Returns 1 if it must be the last one in a chunk. */
  3039. ‌static int parse_stmt(LexState *ls)
  3040. {
  3041.     BCLine line = ls->linenumber;
  3042.     switch (ls->tok) {
  3043.     case TK_if:
  3044.         parse_if(ls, line);
  3045.         break;
  3046.     case TK_while:
  3047.         parse_while(ls, line);
  3048.         break;
  3049.     case TK_do:
  3050.         kp_lex_next(ls);
  3051.         parse_block(ls);
  3052.         lex_match(ls, TK_end, TK_do, line);
  3053.         break;
  3054.     case TK_for:
  3055.         parse_for(ls, line);
  3056.         break;
  3057.     case TK_repeat:
  3058.         parse_repeat(ls, line);
  3059.         break;
  3060.     case TK_function:
  3061.         parse_func(ls, line);
  3062.         break;
  3063.     case TK_local:
  3064.         kp_lex_next(ls);
  3065.         parse_local(ls);
  3066.         break;
  3067.     case TK_return:
  3068.         parse_return(ls);
  3069.         return 1;  /* Must be last. */
  3070.     case TK_break:
  3071.         kp_lex_next(ls);
  3072.         parse_break(ls);
  3073.         return 0;  /* Must be last. */
  3074.     case ';':
  3075.         kp_lex_next(ls);
  3076.         break;
  3077.     case TK_label:
  3078.         parse_label(ls);
  3079.         break;
  3080.     case TK_trace:
  3081.     case TK_trace_end:
  3082.         parse_trace(ls);
  3083.         break;
  3084.     case TK_profile:
  3085.     case TK_tick:
  3086.         parse_timer(ls);
  3087.         break;
  3088.     default:
  3089.         parse_call_assign(ls);
  3090.         break;
  3091.     }
  3092.     return 0;
  3093. }

  3095. /* A chunk is a list of statements optionally separated by semicolons. */
  3096. ‌static void parse_chunk(LexState *ls)
  3097. {
  3098.     int islast = 0;

  3100.     synlevel_begin(ls);
  3101.     while (!islast && !parse_isend(ls->tok)) {
  3102.         islast = parse_stmt(ls);
  3103.         lex_opt(ls, ';');
  3104.         kp_assert(ls->fs->framesize >= ls->fs->freereg &&
  3105.             ls->fs->freereg >= ls->fs->nactvar);
  3106.         /* Free registers after each stmt. */
  3107.         ls->fs->freereg = ls->fs->nactvar;
  3108.     }
  3109.     synlevel_end(ls);
  3110. }

  3112. /* Entry point of bytecode parser. */
  3113. ‌ktap_proto_t *kp_parse(LexState *ls)
  3114. {
  3115.     FuncState fs;
  3116.     FuncScope bl;
  3117.     ktap_proto_t *pt;

  3119.     ls->chunkname = kp_str_newz(ls->chunkarg);
  3120.     ls->level = 0;
  3121.     fs_init(ls, &fs);
  3122.     fs.linedefined = 0;
  3123.     fs.numparams = 0;
  3124.     fs.bcbase = NULL;
  3125.     fs.bclim = 0;
  3126.     fs.flags |= PROTO_VARARG;  /* Main chunk is always a vararg func. */
  3127.     fscope_begin(&fs, &bl, 0);
  3128.     bcemit_AD(&fs, BC_FUNCV, 0, 0);  /* Placeholder. */
  3129.     kp_lex_next(ls);  /* Read-ahead first token. */
  3130.     parse_chunk(ls);
  3131.     if (ls->tok != TK_eof)
  3132.         err_token(ls, TK_eof);
  3133.     pt = fs_finish(ls, ls->linenumber);
  3134.     kp_assert(fs.prev == NULL);
  3135.     kp_assert(ls->fs == NULL);
  3136.     kp_assert(pt->sizeuv == 0);
  3137.     return pt;
  3138. }

One Level Up Top Level