fs 35 lib/lua/lcode.c LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n) { fs 37 lib/lua/lcode.c if (fs->pc > fs->lasttarget) { /* no jumps to current position? */ fs 38 lib/lua/lcode.c if (fs->pc == 0) { /* function start? */ fs 39 lib/lua/lcode.c if (from >= fs->nactvar) fs 43 lib/lua/lcode.c previous = &fs->f->code[fs->pc-1]; fs 55 lib/lua/lcode.c luaK_codeABC(fs, OP_LOADNIL, from, from+n-1, 0); /* else no optimization */ fs 59 lib/lua/lcode.c LUAI_FUNC int luaK_jump (FuncState *fs) { fs 60 lib/lua/lcode.c int jpc = fs->jpc; /* save list of jumps to here */ fs 62 lib/lua/lcode.c fs->jpc = NO_JUMP; fs 63 lib/lua/lcode.c j = luaK_codeAsBx(fs, OP_JMP, 0, NO_JUMP); fs 64 lib/lua/lcode.c luaK_concat(fs, &j, jpc); /* keep them on hold */ fs 69 lib/lua/lcode.c LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret) { fs 70 lib/lua/lcode.c luaK_codeABC(fs, OP_RETURN, first, nret+1, 0); fs 74 lib/lua/lcode.c static int condjump (FuncState *fs, OpCode op, int A, int B, int C) { fs 75 lib/lua/lcode.c luaK_codeABC(fs, op, A, B, C); fs 76 lib/lua/lcode.c return luaK_jump(fs); fs 80 lib/lua/lcode.c static void fixjump (FuncState *fs, int pc, int dest) { fs 81 lib/lua/lcode.c Instruction *jmp = &fs->f->code[pc]; fs 85 lib/lua/lcode.c luaX_syntaxerror(fs->ls, "control structure too long"); fs 94 lib/lua/lcode.c LUAI_FUNC int luaK_getlabel (FuncState *fs) { fs 95 lib/lua/lcode.c fs->lasttarget = fs->pc; fs 96 lib/lua/lcode.c return fs->pc; fs 100 lib/lua/lcode.c static int getjump (FuncState *fs, int pc) { fs 101 lib/lua/lcode.c int offset = GETARG_sBx(fs->f->code[pc]); fs 109 lib/lua/lcode.c static Instruction *getjumpcontrol (FuncState *fs, int pc) { fs 110 lib/lua/lcode.c Instruction *pi = &fs->f->code[pc]; fs 122 lib/lua/lcode.c static int need_value (FuncState *fs, int list) { fs 123 lib/lua/lcode.c for (; list != NO_JUMP; list = getjump(fs, list)) { fs 124 lib/lua/lcode.c Instruction i = *getjumpcontrol(fs, list); fs 131 lib/lua/lcode.c static int patchtestreg (FuncState *fs, int node, int reg) { fs 132 lib/lua/lcode.c Instruction *i = getjumpcontrol(fs, node); fs 144 lib/lua/lcode.c static void removevalues (FuncState *fs, int list) { fs 145 lib/lua/lcode.c for (; list != NO_JUMP; list = getjump(fs, list)) fs 146 lib/lua/lcode.c patchtestreg(fs, list, NO_REG); fs 150 lib/lua/lcode.c static void patchlistaux (FuncState *fs, int list, int vtarget, int reg, fs 153 lib/lua/lcode.c int next = getjump(fs, list); fs 154 lib/lua/lcode.c if (patchtestreg(fs, list, reg)) fs 155 lib/lua/lcode.c fixjump(fs, list, vtarget); fs 157 lib/lua/lcode.c fixjump(fs, list, dtarget); /* jump to default target */ fs 163 lib/lua/lcode.c static void dischargejpc (FuncState *fs) { fs 164 lib/lua/lcode.c patchlistaux(fs, fs->jpc, fs->pc, NO_REG, fs->pc); fs 165 lib/lua/lcode.c fs->jpc = NO_JUMP; fs 169 lib/lua/lcode.c LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target) { fs 170 lib/lua/lcode.c if (target == fs->pc) fs 171 lib/lua/lcode.c luaK_patchtohere(fs, list); fs 173 lib/lua/lcode.c lua_assert(target < fs->pc); fs 174 lib/lua/lcode.c patchlistaux(fs, list, target, NO_REG, target); fs 179 lib/lua/lcode.c LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list) { fs 180 lib/lua/lcode.c luaK_getlabel(fs); fs 181 lib/lua/lcode.c luaK_concat(fs, &fs->jpc, list); fs 185 lib/lua/lcode.c LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2) { fs 192 lib/lua/lcode.c while ((next = getjump(fs, list)) != NO_JUMP) /* find last element */ fs 194 lib/lua/lcode.c fixjump(fs, list, l2); fs 199 lib/lua/lcode.c LUAI_FUNC void luaK_checkstack (FuncState *fs, int n) { fs 200 lib/lua/lcode.c int newstack = fs->freereg + n; fs 201 lib/lua/lcode.c if (newstack > fs->f->maxstacksize) { fs 203 lib/lua/lcode.c luaX_syntaxerror(fs->ls, "function or expression too complex"); fs 204 lib/lua/lcode.c fs->f->maxstacksize = cast_byte(newstack); fs 209 lib/lua/lcode.c LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n) { fs 210 lib/lua/lcode.c luaK_checkstack(fs, n); fs 211 lib/lua/lcode.c fs->freereg += n; fs 215 lib/lua/lcode.c static void freereg (FuncState *fs, int reg) { fs 216 lib/lua/lcode.c if (!ISK(reg) && reg >= fs->nactvar) { fs 217 lib/lua/lcode.c fs->freereg--; fs 218 lib/lua/lcode.c lua_assert(reg == fs->freereg); fs 223 lib/lua/lcode.c static void freeexp (FuncState *fs, expdesc *e) { fs 225 lib/lua/lcode.c freereg(fs, e->u.s.info); fs 229 lib/lua/lcode.c static int addk (FuncState *fs, TValue *k, TValue *v) { fs 230 lib/lua/lcode.c lua_State *L = fs->L; fs 231 lib/lua/lcode.c TValue *idx = luaH_set(L, fs->h, k); fs 232 lib/lua/lcode.c Proto *f = fs->f; fs 235 lib/lua/lcode.c lua_assert(luaO_rawequalObj(&fs->f->k[cast_int(nvalue(idx))], v)); fs 239 lib/lua/lcode.c setnvalue(idx, cast_num(fs->nk)); fs 240 lib/lua/lcode.c luaM_growvector(L, f->k, fs->nk, f->sizek, TValue, fs 243 lib/lua/lcode.c setobj(L, &f->k[fs->nk], v); fs 245 lib/lua/lcode.c return fs->nk++; fs 250 lib/lua/lcode.c LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s) { fs 252 lib/lua/lcode.c setsvalue(fs->L, &o, s); fs 253 lib/lua/lcode.c return addk(fs, &o, &o); fs 257 lib/lua/lcode.c LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r) { fs 260 lib/lua/lcode.c return addk(fs, &o, &o); fs 264 lib/lua/lcode.c static int boolK (FuncState *fs, int b) { fs 267 lib/lua/lcode.c return addk(fs, &o, &o); fs 271 lib/lua/lcode.c static int nilK (FuncState *fs) { fs 275 lib/lua/lcode.c sethvalue(fs->L, &k, fs->h); fs 276 lib/lua/lcode.c return addk(fs, &k, &v); fs 280 lib/lua/lcode.c LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults) { fs 282 lib/lua/lcode.c SETARG_C(getcode(fs, e), nresults+1); fs 285 lib/lua/lcode.c SETARG_B(getcode(fs, e), nresults+1); fs 286 lib/lua/lcode.c SETARG_A(getcode(fs, e), fs->freereg); fs 287 lib/lua/lcode.c luaK_reserveregs(fs, 1); fs 292 lib/lua/lcode.c LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e) { fs 295 lib/lua/lcode.c e->u.s.info = GETARG_A(getcode(fs, e)); fs 298 lib/lua/lcode.c SETARG_B(getcode(fs, e), 2); fs 304 lib/lua/lcode.c LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e) { fs 311 lib/lua/lcode.c e->u.s.info = luaK_codeABC(fs, OP_GETUPVAL, 0, e->u.s.info, 0); fs 316 lib/lua/lcode.c e->u.s.info = luaK_codeABx(fs, OP_GETGLOBAL, 0, e->u.s.info); fs 321 lib/lua/lcode.c freereg(fs, e->u.s.aux); fs 322 lib/lua/lcode.c freereg(fs, e->u.s.info); fs 323 lib/lua/lcode.c e->u.s.info = luaK_codeABC(fs, OP_GETTABLE, 0, e->u.s.info, e->u.s.aux); fs 329 lib/lua/lcode.c luaK_setoneret(fs, e); fs 337 lib/lua/lcode.c static int code_label (FuncState *fs, int A, int b, int jump) { fs 338 lib/lua/lcode.c luaK_getlabel(fs); /* those instructions may be jump targets */ fs 339 lib/lua/lcode.c return luaK_codeABC(fs, OP_LOADBOOL, A, b, jump); fs 343 lib/lua/lcode.c static void discharge2reg (FuncState *fs, expdesc *e, int reg) { fs 344 lib/lua/lcode.c luaK_dischargevars(fs, e); fs 347 lib/lua/lcode.c luaK_nil(fs, reg, 1); fs 351 lib/lua/lcode.c luaK_codeABC(fs, OP_LOADBOOL, reg, e->k == VTRUE, 0); fs 355 lib/lua/lcode.c luaK_codeABx(fs, OP_LOADK, reg, e->u.s.info); fs 359 lib/lua/lcode.c luaK_codeABx(fs, OP_LOADK, reg, luaK_numberK(fs, e->u.nval)); fs 363 lib/lua/lcode.c Instruction *pc = &getcode(fs, e); fs 369 lib/lua/lcode.c luaK_codeABC(fs, OP_MOVE, reg, e->u.s.info, 0); fs 382 lib/lua/lcode.c static void discharge2anyreg (FuncState *fs, expdesc *e) { fs 384 lib/lua/lcode.c luaK_reserveregs(fs, 1); fs 385 lib/lua/lcode.c discharge2reg(fs, e, fs->freereg-1); fs 390 lib/lua/lcode.c static void exp2reg (FuncState *fs, expdesc *e, int reg) { fs 391 lib/lua/lcode.c discharge2reg(fs, e, reg); fs 393 lib/lua/lcode.c luaK_concat(fs, &e->t, e->u.s.info); /* put this jump in `t' list */ fs 398 lib/lua/lcode.c if (need_value(fs, e->t) || need_value(fs, e->f)) { fs 399 lib/lua/lcode.c int fj = (e->k == VJMP) ? NO_JUMP : luaK_jump(fs); fs 400 lib/lua/lcode.c p_f = code_label(fs, reg, 0, 1); fs 401 lib/lua/lcode.c p_t = code_label(fs, reg, 1, 0); fs 402 lib/lua/lcode.c luaK_patchtohere(fs, fj); fs 404 lib/lua/lcode.c final = luaK_getlabel(fs); fs 405 lib/lua/lcode.c patchlistaux(fs, e->f, final, reg, p_f); fs 406 lib/lua/lcode.c patchlistaux(fs, e->t, final, reg, p_t); fs 414 lib/lua/lcode.c LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e) { fs 415 lib/lua/lcode.c luaK_dischargevars(fs, e); fs 416 lib/lua/lcode.c freeexp(fs, e); fs 417 lib/lua/lcode.c luaK_reserveregs(fs, 1); fs 418 lib/lua/lcode.c exp2reg(fs, e, fs->freereg - 1); fs 422 lib/lua/lcode.c LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e) { fs 423 lib/lua/lcode.c luaK_dischargevars(fs, e); fs 426 lib/lua/lcode.c if (e->u.s.info >= fs->nactvar) { /* reg. is not a local? */ fs 427 lib/lua/lcode.c exp2reg(fs, e, e->u.s.info); /* put value on it */ fs 431 lib/lua/lcode.c luaK_exp2nextreg(fs, e); /* default */ fs 436 lib/lua/lcode.c LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e) { fs 438 lib/lua/lcode.c luaK_exp2anyreg(fs, e); fs 440 lib/lua/lcode.c luaK_dischargevars(fs, e); fs 444 lib/lua/lcode.c LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e) { fs 445 lib/lua/lcode.c luaK_exp2val(fs, e); fs 451 lib/lua/lcode.c if (fs->nk <= MAXINDEXRK) { /* constant fit in RK operand? */ fs 452 lib/lua/lcode.c e->u.s.info = (e->k == VNIL) ? nilK(fs) : fs 453 lib/lua/lcode.c (e->k == VKNUM) ? luaK_numberK(fs, e->u.nval) : fs 454 lib/lua/lcode.c boolK(fs, (e->k == VTRUE)); fs 468 lib/lua/lcode.c return luaK_exp2anyreg(fs, e); fs 472 lib/lua/lcode.c LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *ex) { fs 475 lib/lua/lcode.c freeexp(fs, ex); fs 476 lib/lua/lcode.c exp2reg(fs, ex, var->u.s.info); fs 480 lib/lua/lcode.c int e = luaK_exp2anyreg(fs, ex); fs 481 lib/lua/lcode.c luaK_codeABC(fs, OP_SETUPVAL, e, var->u.s.info, 0); fs 485 lib/lua/lcode.c int e = luaK_exp2anyreg(fs, ex); fs 486 lib/lua/lcode.c luaK_codeABx(fs, OP_SETGLOBAL, e, var->u.s.info); fs 490 lib/lua/lcode.c int e = luaK_exp2RK(fs, ex); fs 491 lib/lua/lcode.c luaK_codeABC(fs, OP_SETTABLE, var->u.s.info, var->u.s.aux, e); fs 499 lib/lua/lcode.c freeexp(fs, ex); fs 503 lib/lua/lcode.c LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key) { fs 505 lib/lua/lcode.c luaK_exp2anyreg(fs, e); fs 506 lib/lua/lcode.c freeexp(fs, e); fs 507 lib/lua/lcode.c func = fs->freereg; fs 508 lib/lua/lcode.c luaK_reserveregs(fs, 2); fs 509 lib/lua/lcode.c luaK_codeABC(fs, OP_SELF, func, e->u.s.info, luaK_exp2RK(fs, key)); fs 510 lib/lua/lcode.c freeexp(fs, key); fs 516 lib/lua/lcode.c static void invertjump (FuncState *fs, expdesc *e) { fs 517 lib/lua/lcode.c Instruction *pc = getjumpcontrol(fs, e->u.s.info); fs 524 lib/lua/lcode.c static int jumponcond (FuncState *fs, expdesc *e, int cond) { fs 526 lib/lua/lcode.c Instruction ie = getcode(fs, e); fs 528 lib/lua/lcode.c fs->pc--; /* remove previous OP_NOT */ fs 529 lib/lua/lcode.c return condjump(fs, OP_TEST, GETARG_B(ie), 0, !cond); fs 533 lib/lua/lcode.c discharge2anyreg(fs, e); fs 534 lib/lua/lcode.c freeexp(fs, e); fs 535 lib/lua/lcode.c return condjump(fs, OP_TESTSET, NO_REG, e->u.s.info, cond); fs 539 lib/lua/lcode.c LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e) { fs 541 lib/lua/lcode.c luaK_dischargevars(fs, e); fs 548 lib/lua/lcode.c invertjump(fs, e); fs 553 lib/lua/lcode.c pc = jumponcond(fs, e, 0); fs 557 lib/lua/lcode.c luaK_concat(fs, &e->f, pc); /* insert last jump in `f' list */ fs 558 lib/lua/lcode.c luaK_patchtohere(fs, e->t); fs 563 lib/lua/lcode.c static void luaK_goiffalse (FuncState *fs, expdesc *e) { fs 565 lib/lua/lcode.c luaK_dischargevars(fs, e); fs 576 lib/lua/lcode.c pc = jumponcond(fs, e, 1); fs 580 lib/lua/lcode.c luaK_concat(fs, &e->t, pc); /* insert last jump in `t' list */ fs 581 lib/lua/lcode.c luaK_patchtohere(fs, e->f); fs 586 lib/lua/lcode.c static void codenot (FuncState *fs, expdesc *e) { fs 587 lib/lua/lcode.c luaK_dischargevars(fs, e); fs 598 lib/lua/lcode.c invertjump(fs, e); fs 603 lib/lua/lcode.c discharge2anyreg(fs, e); fs 604 lib/lua/lcode.c freeexp(fs, e); fs 605 lib/lua/lcode.c e->u.s.info = luaK_codeABC(fs, OP_NOT, 0, e->u.s.info, 0); fs 616 lib/lua/lcode.c removevalues(fs, e->f); fs 617 lib/lua/lcode.c removevalues(fs, e->t); fs 621 lib/lua/lcode.c LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k) { fs 622 lib/lua/lcode.c t->u.s.aux = luaK_exp2RK(fs, k); fs 653 lib/lua/lcode.c static void codearith (FuncState *fs, OpCode op, expdesc *e1, expdesc *e2) { fs 657 lib/lua/lcode.c int o2 = (op != OP_UNM && op != OP_LEN) ? luaK_exp2RK(fs, e2) : 0; fs 658 lib/lua/lcode.c int o1 = luaK_exp2RK(fs, e1); fs 660 lib/lua/lcode.c freeexp(fs, e1); fs 661 lib/lua/lcode.c freeexp(fs, e2); fs 664 lib/lua/lcode.c freeexp(fs, e2); fs 665 lib/lua/lcode.c freeexp(fs, e1); fs 667 lib/lua/lcode.c e1->u.s.info = luaK_codeABC(fs, op, 0, o1, o2); fs 673 lib/lua/lcode.c static void codecomp (FuncState *fs, OpCode op, int cond, expdesc *e1, fs 675 lib/lua/lcode.c int o1 = luaK_exp2RK(fs, e1); fs 676 lib/lua/lcode.c int o2 = luaK_exp2RK(fs, e2); fs 677 lib/lua/lcode.c freeexp(fs, e2); fs 678 lib/lua/lcode.c freeexp(fs, e1); fs 684 lib/lua/lcode.c e1->u.s.info = condjump(fs, op, cond, o1, o2); fs 689 lib/lua/lcode.c LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *e) { fs 695 lib/lua/lcode.c luaK_exp2anyreg(fs, e); /* cannot operate on non-numeric constants */ fs 696 lib/lua/lcode.c codearith(fs, OP_UNM, e, &e2); fs 699 lib/lua/lcode.c case OPR_NOT: codenot(fs, e); break; fs 701 lib/lua/lcode.c luaK_exp2anyreg(fs, e); /* cannot operate on constants */ fs 702 lib/lua/lcode.c codearith(fs, OP_LEN, e, &e2); fs 710 lib/lua/lcode.c LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) { fs 713 lib/lua/lcode.c luaK_goiftrue(fs, v); fs 717 lib/lua/lcode.c luaK_goiffalse(fs, v); fs 721 lib/lua/lcode.c luaK_exp2nextreg(fs, v); /* operand must be on the `stack' */ fs 726 lib/lua/lcode.c if (!isnumeral(v)) luaK_exp2RK(fs, v); fs 730 lib/lua/lcode.c luaK_exp2RK(fs, v); fs 737 lib/lua/lcode.c LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) { fs 741 lib/lua/lcode.c luaK_dischargevars(fs, e2); fs 742 lib/lua/lcode.c luaK_concat(fs, &e2->f, e1->f); fs 748 lib/lua/lcode.c luaK_dischargevars(fs, e2); fs 749 lib/lua/lcode.c luaK_concat(fs, &e2->t, e1->t); fs 754 lib/lua/lcode.c luaK_exp2val(fs, e2); fs 755 lib/lua/lcode.c if (e2->k == VRELOCABLE && GET_OPCODE(getcode(fs, e2)) == OP_CONCAT) { fs 756 lib/lua/lcode.c lua_assert(e1->u.s.info == GETARG_B(getcode(fs, e2))-1); fs 757 lib/lua/lcode.c freeexp(fs, e1); fs 758 lib/lua/lcode.c SETARG_B(getcode(fs, e2), e1->u.s.info); fs 762 lib/lua/lcode.c luaK_exp2nextreg(fs, e2); /* operand must be on the 'stack' */ fs 763 lib/lua/lcode.c codearith(fs, OP_CONCAT, e1, e2); fs 767 lib/lua/lcode.c case OPR_ADD: codearith(fs, OP_ADD, e1, e2); break; fs 768 lib/lua/lcode.c case OPR_SUB: codearith(fs, OP_SUB, e1, e2); break; fs 769 lib/lua/lcode.c case OPR_MUL: codearith(fs, OP_MUL, e1, e2); break; fs 770 lib/lua/lcode.c case OPR_DIV: codearith(fs, OP_DIV, e1, e2); break; fs 771 lib/lua/lcode.c case OPR_MOD: codearith(fs, OP_MOD, e1, e2); break; fs 772 lib/lua/lcode.c case OPR_POW: codearith(fs, OP_POW, e1, e2); break; fs 773 lib/lua/lcode.c case OPR_EQ: codecomp(fs, OP_EQ, 1, e1, e2); break; fs 774 lib/lua/lcode.c case OPR_NE: codecomp(fs, OP_EQ, 0, e1, e2); break; fs 775 lib/lua/lcode.c case OPR_LT: codecomp(fs, OP_LT, 1, e1, e2); break; fs 776 lib/lua/lcode.c case OPR_LE: codecomp(fs, OP_LE, 1, e1, e2); break; fs 777 lib/lua/lcode.c case OPR_GT: codecomp(fs, OP_LT, 0, e1, e2); break; fs 778 lib/lua/lcode.c case OPR_GE: codecomp(fs, OP_LE, 0, e1, e2); break; fs 784 lib/lua/lcode.c LUAI_FUNC void luaK_fixline (FuncState *fs, int line) { fs 785 lib/lua/lcode.c fs->f->lineinfo[fs->pc - 1] = line; fs 789 lib/lua/lcode.c static int luaK_code (FuncState *fs, Instruction i, int line) { fs 790 lib/lua/lcode.c Proto *f = fs->f; fs 791 lib/lua/lcode.c dischargejpc(fs); /* `pc' will change */ fs 793 lib/lua/lcode.c luaM_growvector(fs->L, f->code, fs->pc, f->sizecode, Instruction, fs 795 lib/lua/lcode.c f->code[fs->pc] = i; fs 797 lib/lua/lcode.c luaM_growvector(fs->L, f->lineinfo, fs->pc, f->sizelineinfo, int, fs 799 lib/lua/lcode.c f->lineinfo[fs->pc] = line; fs 800 lib/lua/lcode.c return fs->pc++; fs 804 lib/lua/lcode.c LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int a, int b, int c) { fs 808 lib/lua/lcode.c return luaK_code(fs, CREATE_ABC(o, a, b, c), fs->ls->lastline); fs 812 lib/lua/lcode.c LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int a, unsigned int bc) { fs 815 lib/lua/lcode.c return luaK_code(fs, CREATE_ABx(o, a, bc), fs->ls->lastline); fs 819 lib/lua/lcode.c LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore) { fs 824 lib/lua/lcode.c luaK_codeABC(fs, OP_SETLIST, base, b, c); fs 826 lib/lua/lcode.c luaK_codeABC(fs, OP_SETLIST, base, b, 0); fs 827 lib/lua/lcode.c luaK_code(fs, cast(Instruction, c), fs->ls->lastline); fs 829 lib/lua/lcode.c fs->freereg = base + 1; /* free registers with list values */ fs 39 lib/lua/lcode.h #define getcode(fs,e) ((fs)->f->code[(e)->u.s.info]) fs 41 lib/lua/lcode.h #define luaK_codeAsBx(fs,o,A,sBx) luaK_codeABx(fs,o,A,(sBx)+MAXARG_sBx) fs 43 lib/lua/lcode.h #define luaK_setmultret(fs,e) luaK_setreturns(fs, e, LUA_MULTRET) fs 45 lib/lua/lcode.h LUAI_FUNC int luaK_codeABx (FuncState *fs, OpCode o, int A, unsigned int Bx); fs 46 lib/lua/lcode.h LUAI_FUNC int luaK_codeABC (FuncState *fs, OpCode o, int A, int B, int C); fs 47 lib/lua/lcode.h LUAI_FUNC void luaK_fixline (FuncState *fs, int line); fs 48 lib/lua/lcode.h LUAI_FUNC void luaK_nil (FuncState *fs, int from, int n); fs 49 lib/lua/lcode.h LUAI_FUNC void luaK_reserveregs (FuncState *fs, int n); fs 50 lib/lua/lcode.h LUAI_FUNC void luaK_checkstack (FuncState *fs, int n); fs 51 lib/lua/lcode.h LUAI_FUNC int luaK_stringK (FuncState *fs, TString *s); fs 52 lib/lua/lcode.h LUAI_FUNC int luaK_numberK (FuncState *fs, lua_Number r); fs 53 lib/lua/lcode.h LUAI_FUNC void luaK_dischargevars (FuncState *fs, expdesc *e); fs 54 lib/lua/lcode.h LUAI_FUNC int luaK_exp2anyreg (FuncState *fs, expdesc *e); fs 55 lib/lua/lcode.h LUAI_FUNC void luaK_exp2nextreg (FuncState *fs, expdesc *e); fs 56 lib/lua/lcode.h LUAI_FUNC void luaK_exp2val (FuncState *fs, expdesc *e); fs 57 lib/lua/lcode.h LUAI_FUNC int luaK_exp2RK (FuncState *fs, expdesc *e); fs 58 lib/lua/lcode.h LUAI_FUNC void luaK_self (FuncState *fs, expdesc *e, expdesc *key); fs 59 lib/lua/lcode.h LUAI_FUNC void luaK_indexed (FuncState *fs, expdesc *t, expdesc *k); fs 60 lib/lua/lcode.h LUAI_FUNC void luaK_goiftrue (FuncState *fs, expdesc *e); fs 61 lib/lua/lcode.h LUAI_FUNC void luaK_storevar (FuncState *fs, expdesc *var, expdesc *e); fs 62 lib/lua/lcode.h LUAI_FUNC void luaK_setreturns (FuncState *fs, expdesc *e, int nresults); fs 63 lib/lua/lcode.h LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e); fs 64 lib/lua/lcode.h LUAI_FUNC int luaK_jump (FuncState *fs); fs 65 lib/lua/lcode.h LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret); fs 66 lib/lua/lcode.h LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target); fs 67 lib/lua/lcode.h LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list); fs 68 lib/lua/lcode.h LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2); fs 69 lib/lua/lcode.h LUAI_FUNC int luaK_getlabel (FuncState *fs); fs 70 lib/lua/lcode.h LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v); fs 71 lib/lua/lcode.h LUAI_FUNC void luaK_infix (FuncState *fs, BinOpr op, expdesc *v); fs 72 lib/lua/lcode.h LUAI_FUNC void luaK_posfix (FuncState *fs, BinOpr op, expdesc *v1, expdesc *v2); fs 73 lib/lua/lcode.h LUAI_FUNC void luaK_setlist (FuncState *fs, int base, int nelems, int tostore); fs 120 lib/lua/llex.c TValue *o = luaH_setstr(L, ls->fs->h, ts); /* entry for `str' */ fs 145 lib/lua/llex.c ls->fs = NULL; fs 61 lib/lua/llex.h struct FuncState *fs; /* `FuncState' is private to the parser */ fs 32 lib/lua/lparser.c #define getlocvar(fs, i) ((fs)->f->locvars[(fs)->actvar[i]]) fs 34 lib/lua/lparser.c #define luaY_checklimit(fs,v,l,m) if ((v)>(l)) errorlimit(fs,l,m) fs 71 lib/lua/lparser.c static void errorlimit (FuncState *fs, int limit, const char *what) { fs 72 lib/lua/lparser.c const char *msg = (fs->f->linedefined == 0) ? fs 73 lib/lua/lparser.c luaO_pushfstring(fs->L, "main function has more than %d %s", limit, what) : fs 74 lib/lua/lparser.c luaO_pushfstring(fs->L, "function at line %d has more than %d %s", fs 75 lib/lua/lparser.c fs->f->linedefined, limit, what); fs 76 lib/lua/lparser.c luaX_lexerror(fs->ls, msg, 0); fs 134 lib/lua/lparser.c init_exp(e, VK, luaK_stringK(ls->fs, s)); fs 144 lib/lua/lparser.c FuncState *fs = ls->fs; fs 145 lib/lua/lparser.c Proto *f = fs->f; fs 147 lib/lua/lparser.c luaM_growvector(ls->L, f->locvars, fs->nlocvars, f->sizelocvars, fs 150 lib/lua/lparser.c f->locvars[fs->nlocvars].varname = varname; fs 152 lib/lua/lparser.c return fs->nlocvars++; fs 161 lib/lua/lparser.c FuncState *fs = ls->fs; fs 162 lib/lua/lparser.c luaY_checklimit(fs, fs->nactvar+n+1, LUAI_MAXVARS, "local variables"); fs 163 lib/lua/lparser.c fs->actvar[fs->nactvar+n] = cast(unsigned short, registerlocalvar(ls, name)); fs 168 lib/lua/lparser.c FuncState *fs = ls->fs; fs 169 lib/lua/lparser.c fs->nactvar = cast_byte(fs->nactvar + nvars); fs 171 lib/lua/lparser.c getlocvar(fs, fs->nactvar - nvars).startpc = fs->pc; fs 177 lib/lua/lparser.c FuncState *fs = ls->fs; fs 178 lib/lua/lparser.c while (fs->nactvar > tolevel) fs 179 lib/lua/lparser.c getlocvar(fs, --fs->nactvar).endpc = fs->pc; fs 183 lib/lua/lparser.c static int indexupvalue (FuncState *fs, TString *name, expdesc *v) { fs 185 lib/lua/lparser.c Proto *f = fs->f; fs 188 lib/lua/lparser.c if (fs->upvalues[i].k == v->k && fs->upvalues[i].info == v->u.s.info) { fs 194 lib/lua/lparser.c luaY_checklimit(fs, f->nups + 1, LUAI_MAXUPVALUES, "upvalues"); fs 195 lib/lua/lparser.c luaM_growvector(fs->L, f->upvalues, f->nups, f->sizeupvalues, fs 199 lib/lua/lparser.c luaC_objbarrier(fs->L, f, name); fs 201 lib/lua/lparser.c fs->upvalues[f->nups].k = cast_byte(v->k); fs 202 lib/lua/lparser.c fs->upvalues[f->nups].info = cast_byte(v->u.s.info); fs 207 lib/lua/lparser.c static int searchvar (FuncState *fs, TString *n) { fs 209 lib/lua/lparser.c for (i=fs->nactvar-1; i >= 0; i--) { fs 210 lib/lua/lparser.c if (n == getlocvar(fs, i).varname) fs 217 lib/lua/lparser.c static void markupval (FuncState *fs, int level) { fs 218 lib/lua/lparser.c BlockCnt *bl = fs->bl; fs 224 lib/lua/lparser.c static int singlevaraux (FuncState *fs, TString *n, expdesc *var, int base) { fs 225 lib/lua/lparser.c if (fs == NULL) { /* no more levels? */ fs 230 lib/lua/lparser.c int v = searchvar(fs, n); /* look up at current level */ fs 234 lib/lua/lparser.c markupval(fs, v); /* local will be used as an upval */ fs 238 lib/lua/lparser.c if (singlevaraux(fs->prev, n, var, 0) == VGLOBAL) fs 240 lib/lua/lparser.c var->u.s.info = indexupvalue(fs, n, var); /* else was LOCAL or UPVAL */ fs 250 lib/lua/lparser.c FuncState *fs = ls->fs; fs 251 lib/lua/lparser.c if (singlevaraux(fs, varname, var, 1) == VGLOBAL) fs 252 lib/lua/lparser.c var->u.s.info = luaK_stringK(fs, varname); /* info points to global name */ fs 257 lib/lua/lparser.c FuncState *fs = ls->fs; fs 262 lib/lua/lparser.c luaK_setreturns(fs, e, extra); /* last exp. provides the difference */ fs 263 lib/lua/lparser.c if (extra > 1) luaK_reserveregs(fs, extra-1); fs 266 lib/lua/lparser.c if (e->k != VVOID) luaK_exp2nextreg(fs, e); /* close last expression */ fs 268 lib/lua/lparser.c int reg = fs->freereg; fs 269 lib/lua/lparser.c luaK_reserveregs(fs, extra); fs 270 lib/lua/lparser.c luaK_nil(fs, reg, extra); fs 285 lib/lua/lparser.c static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isbreakable) { fs 288 lib/lua/lparser.c bl->nactvar = fs->nactvar; fs 290 lib/lua/lparser.c bl->previous = fs->bl; fs 291 lib/lua/lparser.c fs->bl = bl; fs 292 lib/lua/lparser.c lua_assert(fs->freereg == fs->nactvar); fs 296 lib/lua/lparser.c static void leaveblock (FuncState *fs) { fs 297 lib/lua/lparser.c BlockCnt *bl = fs->bl; fs 298 lib/lua/lparser.c fs->bl = bl->previous; fs 299 lib/lua/lparser.c removevars(fs->ls, bl->nactvar); fs 301 lib/lua/lparser.c luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0); fs 304 lib/lua/lparser.c lua_assert(bl->nactvar == fs->nactvar); fs 305 lib/lua/lparser.c fs->freereg = fs->nactvar; /* free registers */ fs 306 lib/lua/lparser.c luaK_patchtohere(fs, bl->breaklist); fs 311 lib/lua/lparser.c FuncState *fs = ls->fs; fs 312 lib/lua/lparser.c Proto *f = fs->f; fs 315 lib/lua/lparser.c luaM_growvector(ls->L, f->p, fs->np, f->sizep, Proto *, fs 318 lib/lua/lparser.c f->p[fs->np++] = func->f; fs 320 lib/lua/lparser.c init_exp(v, VRELOCABLE, luaK_codeABx(fs, OP_CLOSURE, 0, fs->np-1)); fs 323 lib/lua/lparser.c luaK_codeABC(fs, o, 0, func->upvalues[i].info, 0); fs 328 lib/lua/lparser.c static void open_func (LexState *ls, FuncState *fs) { fs 331 lib/lua/lparser.c fs->f = f; fs 332 lib/lua/lparser.c fs->prev = ls->fs; /* linked list of funcstates */ fs 333 lib/lua/lparser.c fs->ls = ls; fs 334 lib/lua/lparser.c fs->L = L; fs 335 lib/lua/lparser.c ls->fs = fs; fs 336 lib/lua/lparser.c fs->pc = 0; fs 337 lib/lua/lparser.c fs->lasttarget = -1; fs 338 lib/lua/lparser.c fs->jpc = NO_JUMP; fs 339 lib/lua/lparser.c fs->freereg = 0; fs 340 lib/lua/lparser.c fs->nk = 0; fs 341 lib/lua/lparser.c fs->np = 0; fs 342 lib/lua/lparser.c fs->nlocvars = 0; fs 343 lib/lua/lparser.c fs->nactvar = 0; fs 344 lib/lua/lparser.c fs->bl = NULL; fs 347 lib/lua/lparser.c fs->h = luaH_new(L, 0, 0); fs 349 lib/lua/lparser.c sethvalue2s(L, L->top, fs->h); fs 358 lib/lua/lparser.c FuncState *fs = ls->fs; fs 359 lib/lua/lparser.c Proto *f = fs->f; fs 361 lib/lua/lparser.c luaK_ret(fs, 0, 0); /* final return */ fs 362 lib/lua/lparser.c luaM_reallocvector(L, f->code, f->sizecode, fs->pc, Instruction); fs 363 lib/lua/lparser.c f->sizecode = fs->pc; fs 364 lib/lua/lparser.c luaM_reallocvector(L, f->lineinfo, f->sizelineinfo, fs->pc, int); fs 365 lib/lua/lparser.c f->sizelineinfo = fs->pc; fs 366 lib/lua/lparser.c luaM_reallocvector(L, f->k, f->sizek, fs->nk, TValue); fs 367 lib/lua/lparser.c f->sizek = fs->nk; fs 368 lib/lua/lparser.c luaM_reallocvector(L, f->p, f->sizep, fs->np, Proto *); fs 369 lib/lua/lparser.c f->sizep = fs->np; fs 370 lib/lua/lparser.c luaM_reallocvector(L, f->locvars, f->sizelocvars, fs->nlocvars, LocVar); fs 371 lib/lua/lparser.c f->sizelocvars = fs->nlocvars; fs 375 lib/lua/lparser.c lua_assert(fs->bl == NULL); fs 376 lib/lua/lparser.c ls->fs = fs->prev; fs 378 lib/lua/lparser.c if (fs) anchor_token(ls); fs 396 lib/lua/lparser.c lua_assert(lexstate.fs == NULL); fs 409 lib/lua/lparser.c FuncState *fs = ls->fs; fs 411 lib/lua/lparser.c luaK_exp2anyreg(fs, v); fs 414 lib/lua/lparser.c luaK_indexed(fs, v, &key); fs 422 lib/lua/lparser.c luaK_exp2val(ls->fs, v); fs 445 lib/lua/lparser.c FuncState *fs = ls->fs; fs 446 lib/lua/lparser.c int reg = ls->fs->freereg; fs 450 lib/lua/lparser.c luaY_checklimit(fs, cc->nh, MAX_INT, "items in a constructor"); fs 457 lib/lua/lparser.c rkkey = luaK_exp2RK(fs, &key); fs 459 lib/lua/lparser.c luaK_codeABC(fs, OP_SETTABLE, cc->t->u.s.info, rkkey, luaK_exp2RK(fs, &val)); fs 460 lib/lua/lparser.c fs->freereg = reg; /* free registers */ fs 464 lib/lua/lparser.c static void closelistfield (FuncState *fs, struct ConsControl *cc) { fs 466 lib/lua/lparser.c luaK_exp2nextreg(fs, &cc->v); fs 469 lib/lua/lparser.c luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore); /* flush */ fs 475 lib/lua/lparser.c static void lastlistfield (FuncState *fs, struct ConsControl *cc) { fs 478 lib/lua/lparser.c luaK_setmultret(fs, &cc->v); fs 479 lib/lua/lparser.c luaK_setlist(fs, cc->t->u.s.info, cc->na, LUA_MULTRET); fs 484 lib/lua/lparser.c luaK_exp2nextreg(fs, &cc->v); fs 485 lib/lua/lparser.c luaK_setlist(fs, cc->t->u.s.info, cc->na, cc->tostore); fs 492 lib/lua/lparser.c luaY_checklimit(ls->fs, cc->na, MAX_INT, "items in a constructor"); fs 500 lib/lua/lparser.c FuncState *fs = ls->fs; fs 502 lib/lua/lparser.c int pc = luaK_codeABC(fs, OP_NEWTABLE, 0, 0, 0); fs 508 lib/lua/lparser.c luaK_exp2nextreg(ls->fs, t); /* fix it at stack top (for gc) */ fs 513 lib/lua/lparser.c closelistfield(fs, &cc); fs 534 lib/lua/lparser.c lastlistfield(fs, &cc); fs 535 lib/lua/lparser.c SETARG_B(fs->f->code[pc], luaO_int2fb(cc.na)); /* set initial array size */ fs 536 lib/lua/lparser.c SETARG_C(fs->f->code[pc], luaO_int2fb(cc.nh)); /* set initial table size */ fs 545 lib/lua/lparser.c FuncState *fs = ls->fs; fs 546 lib/lua/lparser.c Proto *f = fs->f; fs 571 lib/lua/lparser.c f->numparams = cast_byte(fs->nactvar - (f->is_vararg & VARARG_HASARG)); fs 572 lib/lua/lparser.c luaK_reserveregs(fs, fs->nactvar); /* reserve register for parameters */ fs 601 lib/lua/lparser.c luaK_exp2nextreg(ls->fs, v); fs 610 lib/lua/lparser.c FuncState *fs = ls->fs; fs 623 lib/lua/lparser.c luaK_setmultret(fs, &args); fs 648 lib/lua/lparser.c luaK_exp2nextreg(fs, &args); /* close last argument */ fs 649 lib/lua/lparser.c nparams = fs->freereg - (base+1); fs 651 lib/lua/lparser.c init_exp(f, VCALL, luaK_codeABC(fs, OP_CALL, base, nparams+1, 2)); fs 652 lib/lua/lparser.c luaK_fixline(fs, line); fs 653 lib/lua/lparser.c fs->freereg = base+1; /* call remove function and arguments and leaves fs 675 lib/lua/lparser.c luaK_dischargevars(ls->fs, v); fs 693 lib/lua/lparser.c FuncState *fs = ls->fs; fs 703 lib/lua/lparser.c luaK_exp2anyreg(fs, v); fs 705 lib/lua/lparser.c luaK_indexed(fs, v, &key); fs 712 lib/lua/lparser.c luaK_self(fs, v, &key); fs 717 lib/lua/lparser.c luaK_exp2nextreg(fs, v); fs 753 lib/lua/lparser.c FuncState *fs = ls->fs; fs 754 lib/lua/lparser.c check_condition(ls, fs->f->is_vararg, fs 756 lib/lua/lparser.c fs->f->is_vararg &= ~VARARG_NEEDSARG; /* don't need 'arg' */ fs 757 lib/lua/lparser.c init_exp(v, VVARARG, luaK_codeABC(fs, OP_VARARG, 0, 1, 0)); fs 836 lib/lua/lparser.c luaK_prefix(ls->fs, uop, v); fs 845 lib/lua/lparser.c luaK_infix(ls->fs, op, v); fs 848 lib/lua/lparser.c luaK_posfix(ls->fs, op, v, &v2); fs 883 lib/lua/lparser.c FuncState *fs = ls->fs; fs 885 lib/lua/lparser.c enterblock(fs, &bl, 0); fs 888 lib/lua/lparser.c leaveblock(fs); fs 909 lib/lua/lparser.c FuncState *fs = ls->fs; fs 910 lib/lua/lparser.c int extra = fs->freereg; /* eventual position to save local variable */ fs 925 lib/lua/lparser.c luaK_codeABC(fs, OP_MOVE, fs->freereg, v->u.s.info, 0); /* make copy */ fs 926 lib/lua/lparser.c luaK_reserveregs(fs, 1); fs 941 lib/lua/lparser.c luaY_checklimit(ls->fs, nvars, LUAI_MAXCCALLS - ls->L->nCcalls, fs 952 lib/lua/lparser.c ls->fs->freereg -= nexps - nvars; /* remove extra values */ fs 955 lib/lua/lparser.c luaK_setoneret(ls->fs, &e); /* close last expression */ fs 956 lib/lua/lparser.c luaK_storevar(ls->fs, &lh->v, &e); fs 960 lib/lua/lparser.c init_exp(&e, VNONRELOC, ls->fs->freereg-1); /* default assignment */ fs 961 lib/lua/lparser.c luaK_storevar(ls->fs, &lh->v, &e); fs 970 lib/lua/lparser.c luaK_goiftrue(ls->fs, &v); fs 976 lib/lua/lparser.c FuncState *fs = ls->fs; fs 977 lib/lua/lparser.c BlockCnt *bl = fs->bl; fs 986 lib/lua/lparser.c luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0); fs 987 lib/lua/lparser.c luaK_concat(fs, &bl->breaklist, luaK_jump(fs)); fs 993 lib/lua/lparser.c FuncState *fs = ls->fs; fs 998 lib/lua/lparser.c whileinit = luaK_getlabel(fs); fs 1000 lib/lua/lparser.c enterblock(fs, &bl, 1); fs 1003 lib/lua/lparser.c luaK_patchlist(fs, luaK_jump(fs), whileinit); fs 1005 lib/lua/lparser.c leaveblock(fs); fs 1006 lib/lua/lparser.c luaK_patchtohere(fs, condexit); /* false conditions finish the loop */ fs 1013 lib/lua/lparser.c FuncState *fs = ls->fs; fs 1014 lib/lua/lparser.c int repeat_init = luaK_getlabel(fs); fs 1016 lib/lua/lparser.c enterblock(fs, &bl1, 1); /* loop block */ fs 1017 lib/lua/lparser.c enterblock(fs, &bl2, 0); /* scope block */ fs 1023 lib/lua/lparser.c leaveblock(fs); /* finish scope */ fs 1024 lib/lua/lparser.c luaK_patchlist(ls->fs, condexit, repeat_init); /* close the loop */ fs 1028 lib/lua/lparser.c luaK_patchtohere(ls->fs, condexit); /* else... */ fs 1029 lib/lua/lparser.c leaveblock(fs); /* finish scope... */ fs 1030 lib/lua/lparser.c luaK_patchlist(ls->fs, luaK_jump(fs), repeat_init); /* and repeat */ fs 1032 lib/lua/lparser.c leaveblock(fs); /* finish loop */ fs 1041 lib/lua/lparser.c luaK_exp2nextreg(ls->fs, &e); fs 1049 lib/lua/lparser.c FuncState *fs = ls->fs; fs 1053 lib/lua/lparser.c prep = isnum ? luaK_codeAsBx(fs, OP_FORPREP, base, NO_JUMP) : luaK_jump(fs); fs 1054 lib/lua/lparser.c enterblock(fs, &bl, 0); /* scope for declared variables */ fs 1056 lib/lua/lparser.c luaK_reserveregs(fs, nvars); fs 1058 lib/lua/lparser.c leaveblock(fs); /* end of scope for declared variables */ fs 1059 lib/lua/lparser.c luaK_patchtohere(fs, prep); fs 1060 lib/lua/lparser.c endfor = (isnum) ? luaK_codeAsBx(fs, OP_FORLOOP, base, NO_JUMP) : fs 1061 lib/lua/lparser.c luaK_codeABC(fs, OP_TFORLOOP, base, 0, nvars); fs 1062 lib/lua/lparser.c luaK_fixline(fs, line); /* pretend that `OP_FOR' starts the loop */ fs 1063 lib/lua/lparser.c luaK_patchlist(fs, (isnum ? endfor : luaK_jump(fs)), prep + 1); fs 1069 lib/lua/lparser.c FuncState *fs = ls->fs; fs 1070 lib/lua/lparser.c int base = fs->freereg; fs 1082 lib/lua/lparser.c luaK_codeABx(fs, OP_LOADK, fs->freereg, luaK_numberK(fs, 1)); fs 1083 lib/lua/lparser.c luaK_reserveregs(fs, 1); fs 1091 lib/lua/lparser.c FuncState *fs = ls->fs; fs 1095 lib/lua/lparser.c int base = fs->freereg; fs 1107 lib/lua/lparser.c luaK_checkstack(fs, 3); /* extra space to call generator */ fs 1114 lib/lua/lparser.c FuncState *fs = ls->fs; fs 1117 lib/lua/lparser.c enterblock(fs, &bl, 1); /* scope for loop and control variables */ fs 1126 lib/lua/lparser.c leaveblock(fs); /* loop scope (`break' jumps to this point) */ fs 1143 lib/lua/lparser.c FuncState *fs = ls->fs; fs 1148 lib/lua/lparser.c luaK_concat(fs, &escapelist, luaK_jump(fs)); fs 1149 lib/lua/lparser.c luaK_patchtohere(fs, flist); fs 1153 lib/lua/lparser.c luaK_concat(fs, &escapelist, luaK_jump(fs)); fs 1154 lib/lua/lparser.c luaK_patchtohere(fs, flist); fs 1159 lib/lua/lparser.c luaK_concat(fs, &escapelist, flist); fs 1160 lib/lua/lparser.c luaK_patchtohere(fs, escapelist); fs 1167 lib/lua/lparser.c FuncState *fs = ls->fs; fs 1169 lib/lua/lparser.c init_exp(&v, VLOCAL, fs->freereg); fs 1170 lib/lua/lparser.c luaK_reserveregs(fs, 1); fs 1173 lib/lua/lparser.c luaK_storevar(fs, &v, &b); fs 1175 lib/lua/lparser.c getlocvar(fs, fs->nactvar - 1).startpc = fs->pc; fs 1219 lib/lua/lparser.c luaK_storevar(ls->fs, &v, &b); fs 1220 lib/lua/lparser.c luaK_fixline(ls->fs, line); /* definition `happens' in the first line */ fs 1226 lib/lua/lparser.c FuncState *fs = ls->fs; fs 1230 lib/lua/lparser.c SETARG_C(getcode(fs, &v.v), 1); /* call statement uses no results */ fs 1240 lib/lua/lparser.c FuncState *fs = ls->fs; fs 1249 lib/lua/lparser.c luaK_setmultret(fs, &e); fs 1251 lib/lua/lparser.c SET_OPCODE(getcode(fs,&e), OP_TAILCALL); fs 1252 lib/lua/lparser.c lua_assert(GETARG_A(getcode(fs,&e)) == fs->nactvar); fs 1254 lib/lua/lparser.c first = fs->nactvar; fs 1259 lib/lua/lparser.c first = luaK_exp2anyreg(fs, &e); fs 1261 lib/lua/lparser.c luaK_exp2nextreg(fs, &e); /* values must go to the `stack' */ fs 1262 lib/lua/lparser.c first = fs->nactvar; /* return all `active' values */ fs 1263 lib/lua/lparser.c lua_assert(nret == fs->freereg - first); fs 1267 lib/lua/lparser.c luaK_ret(fs, first, nret); fs 1332 lib/lua/lparser.c lua_assert(ls->fs->f->maxstacksize >= ls->fs->freereg && fs 1333 lib/lua/lparser.c ls->fs->freereg >= ls->fs->nactvar); fs 1334 lib/lua/lparser.c ls->fs->freereg = ls->fs->nactvar; /* free registers */