mirror of https://github.com/lua/lua
jumps do not close upvalues (to be faster and simpler);
explicit instruction to close upvalues; command 'break' not handled like a 'goto' (to optimize removal of uneeded 'close' instructions)
This commit is contained in:
Roberto Ierusalimschy
parent
029d269f4d
commit
80d9b09f35
51
lcode.c
51
lcode.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lcode.c,v 2.120 2017/06/27 11:35:31 roberto Exp roberto $
|
||||
** $Id: lcode.c,v 2.121 2017/06/29 15:06:44 roberto Exp roberto $
|
||||
** Code generator for Lua
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -272,20 +272,51 @@ void luaK_patchlist (FuncState *fs, int list, int target) {
|
|||
|
||||
|
||||
/*
|
||||
** Path all jumps in 'list' to close upvalues up to given 'level'
|
||||
** (The assertion checks that jumps either were closing nothing
|
||||
** or were closing higher levels, from inner blocks.)
|
||||
** Check whether some jump in given list needs a close instruction.
|
||||
*/
|
||||
void luaK_patchclose (FuncState *fs, int list, int level) {
|
||||
level++; /* argument is +1 to reserve 0 as non-op */
|
||||
int luaK_needclose (FuncState *fs, int list) {
|
||||
for (; list != NO_JUMP; list = getjump(fs, list)) {
|
||||
lua_assert(GET_OPCODE(fs->f->code[list]) == OP_JMP &&
|
||||
(GETARG_A(fs->f->code[list]) == 0 ||
|
||||
GETARG_A(fs->f->code[list]) >= level));
|
||||
SETARG_A(fs->f->code[list], level);
|
||||
if (GETARG_A(fs->f->code[list])) /* needs close? */
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Correct a jump list to jump to 'target'. If 'hasclose' is true,
|
||||
** 'target' contains an OP_CLOSE instruction (see first assert).
|
||||
** Only jumps with the A arg true need that close; other jumps
|
||||
** avoid it jumping to the next instruction.
|
||||
*/
|
||||
void luaK_patchgoto (FuncState *fs, int list, int target, int hasclose) {
|
||||
lua_assert(!hasclose || GET_OPCODE(fs->f->code[target]) == OP_CLOSE);
|
||||
while (list != NO_JUMP) {
|
||||
int next = getjump(fs, list);
|
||||
lua_assert(!GETARG_A(fs->f->code[list]) || hasclose);
|
||||
patchtestreg(fs, list, NO_REG); /* do not generate values */
|
||||
if (!hasclose || GETARG_A(fs->f->code[list]))
|
||||
fixjump(fs, list, target);
|
||||
else /* there is a CLOSE instruction but jump does not need it */
|
||||
fixjump(fs, list, target + 1); /* avoid CLOSE instruction */
|
||||
list = next;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** Mark (using the A arg) all jumps in 'list' to close upvalues. Mark
|
||||
** will instruct 'luaK_patchgoto' to make these jumps go to OP_CLOSE
|
||||
** instructions.
|
||||
*/
|
||||
void luaK_patchclose (FuncState *fs, int list) {
|
||||
for (; list != NO_JUMP; list = getjump(fs, list)) {
|
||||
lua_assert(GET_OPCODE(fs->f->code[list]) == OP_JMP);
|
||||
SETARG_A(fs->f->code[list], 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#if !defined(MAXIWTHABS)
|
||||
#define MAXIWTHABS 120
|
||||
#endif
|
||||
|
|
|
|||
6
lcode.h
6
lcode.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lcode.h,v 1.64 2016/01/05 16:22:37 roberto Exp roberto $
|
||||
** $Id: lcode.h,v 1.65 2017/04/20 19:53:55 roberto Exp roberto $
|
||||
** Code generator for Lua
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -73,8 +73,10 @@ LUAI_FUNC void luaK_setoneret (FuncState *fs, expdesc *e);
|
|||
LUAI_FUNC int luaK_jump (FuncState *fs);
|
||||
LUAI_FUNC void luaK_ret (FuncState *fs, int first, int nret);
|
||||
LUAI_FUNC void luaK_patchlist (FuncState *fs, int list, int target);
|
||||
void luaK_patchgoto (FuncState *fs, int list, int target, int hasclose);
|
||||
LUAI_FUNC void luaK_patchtohere (FuncState *fs, int list);
|
||||
LUAI_FUNC void luaK_patchclose (FuncState *fs, int list, int level);
|
||||
LUAI_FUNC void luaK_patchclose (FuncState *fs, int list);
|
||||
LUAI_FUNC int luaK_needclose (FuncState *fs, int list);
|
||||
LUAI_FUNC void luaK_concat (FuncState *fs, int *l1, int l2);
|
||||
LUAI_FUNC int luaK_getlabel (FuncState *fs);
|
||||
LUAI_FUNC void luaK_prefix (FuncState *fs, UnOpr op, expdesc *v, int line);
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lopcodes.c,v 1.59 2017/06/29 15:38:41 roberto Exp roberto $
|
||||
** $Id: lopcodes.c,v 1.60 2017/08/14 18:33:14 roberto Exp roberto $
|
||||
** Opcodes for Lua virtual machine
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -54,6 +54,7 @@ LUAI_DDEF const char *const luaP_opnames[NUM_OPCODES+1] = {
|
|||
"NOT",
|
||||
"LEN",
|
||||
"CONCAT",
|
||||
"CLOSE",
|
||||
"JMP",
|
||||
"EQ",
|
||||
"LT",
|
||||
|
|
@ -115,7 +116,8 @@ LUAI_DDEF const lu_byte luaP_opmodes[NUM_OPCODES] = {
|
|||
,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_NOT */
|
||||
,opmode(0, 1, OpArgR, OpArgN, iABC) /* OP_LEN */
|
||||
,opmode(0, 1, OpArgR, OpArgR, iABC) /* OP_CONCAT */
|
||||
,opmode(0, 0, OpArgR, OpArgN, iAsBx) /* OP_JMP */
|
||||
,opmode(0, 0, OpArgN, OpArgN, iABC) /* OP_CLOSE */
|
||||
,opmode(0, 0, OpArgU, OpArgN, iAsBx) /* OP_JMP */
|
||||
,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_EQ */
|
||||
,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LT */
|
||||
,opmode(1, 0, OpArgK, OpArgK, iABC) /* OP_LE */
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lopcodes.h,v 1.155 2017/06/29 15:38:41 roberto Exp roberto $
|
||||
** $Id: lopcodes.h,v 1.156 2017/08/14 18:33:14 roberto Exp roberto $
|
||||
** Opcodes for Lua virtual machine
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -217,7 +217,8 @@ OP_LEN,/* A B R(A) := length of R(B) */
|
|||
|
||||
OP_CONCAT,/* A B C R(A) := R(B).. ... ..R(C) */
|
||||
|
||||
OP_JMP,/* A sBx pc+=sBx; if (A) close all upvalues >= R(A - 1) */
|
||||
OP_CLOSE,/* A close all upvalues >= R(A) */
|
||||
OP_JMP,/* sBx pc+=sBx */
|
||||
OP_EQ,/* A B C if ((RK(B) == RK(C)) ~= A) then pc++ */
|
||||
OP_LT,/* A B C if ((RK(B) < RK(C)) ~= A) then pc++ */
|
||||
OP_LE,/* A B C if ((RK(B) <= RK(C)) ~= A) then pc++ */
|
||||
|
|
|
|||
127
lparser.c
127
lparser.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lparser.c,v 2.163 2017/08/12 13:12:21 roberto Exp roberto $
|
||||
** $Id: lparser.c,v 2.164 2017/08/14 18:33:14 roberto Exp roberto $
|
||||
** Lua Parser
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -49,6 +49,8 @@ typedef struct BlockCnt {
|
|||
struct BlockCnt *previous; /* chain */
|
||||
int firstlabel; /* index of first label in this block */
|
||||
int firstgoto; /* index of first pending goto in this block */
|
||||
int brks; /* list of break jumps in this block */
|
||||
lu_byte brkcls; /* true if some 'break' needs to close upvalues */
|
||||
lu_byte nactvar; /* # active locals outside the block */
|
||||
lu_byte upval; /* true if some variable in the block is an upvalue */
|
||||
lu_byte isloop; /* true if 'block' is a loop */
|
||||
|
|
@ -351,7 +353,7 @@ static void closegoto (LexState *ls, int g, Labeldesc *label) {
|
|||
getstr(gt->name), gt->line, getstr(vname));
|
||||
semerror(ls, msg);
|
||||
}
|
||||
luaK_patchlist(fs, gt->pc, label->pc);
|
||||
luaK_patchgoto(fs, gt->pc, label->pc, 1);
|
||||
/* remove goto from pending list */
|
||||
for (i = g; i < gl->n - 1; i++)
|
||||
gl->arr[i] = gl->arr[i + 1];
|
||||
|
|
@ -362,7 +364,7 @@ static void closegoto (LexState *ls, int g, Labeldesc *label) {
|
|||
/*
|
||||
** try to close a goto with existing labels; this solves backward jumps
|
||||
*/
|
||||
static int findlabel (LexState *ls, int g) {
|
||||
static int solvelabel (LexState *ls, int g) {
|
||||
int i;
|
||||
BlockCnt *bl = ls->fs->bl;
|
||||
Dyndata *dyd = ls->dyd;
|
||||
|
|
@ -373,7 +375,7 @@ static int findlabel (LexState *ls, int g) {
|
|||
if (eqstr(lb->name, gt->name)) { /* correct label? */
|
||||
if (gt->nactvar > lb->nactvar &&
|
||||
(bl->upval || dyd->label.n > bl->firstlabel))
|
||||
luaK_patchclose(ls->fs, gt->pc, lb->nactvar);
|
||||
luaK_patchclose(ls->fs, gt->pc);
|
||||
closegoto(ls, g, lb); /* close it */
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -400,12 +402,12 @@ static int newlabelentry (LexState *ls, Labellist *l, TString *name,
|
|||
** check whether new label 'lb' matches any pending gotos in current
|
||||
** block; solves forward jumps
|
||||
*/
|
||||
static void findgotos (LexState *ls, Labeldesc *lb) {
|
||||
static void solvegotos (LexState *ls, Labeldesc *lb) {
|
||||
Labellist *gl = &ls->dyd->gt;
|
||||
int i = ls->fs->bl->firstgoto;
|
||||
while (i < gl->n) {
|
||||
if (eqstr(gl->arr[i].name, lb->name))
|
||||
closegoto(ls, i, lb);
|
||||
closegoto(ls, i, lb); /* will remove 'i' from the list */
|
||||
else
|
||||
i++;
|
||||
}
|
||||
|
|
@ -416,23 +418,32 @@ static void findgotos (LexState *ls, Labeldesc *lb) {
|
|||
** export pending gotos to outer level, to check them against
|
||||
** outer labels; if the block being exited has upvalues, and
|
||||
** the goto exits the scope of any variable (which can be the
|
||||
** upvalue), close those variables being exited.
|
||||
** upvalue), close those variables being exited. Also export
|
||||
** break list.
|
||||
*/
|
||||
static void movegotosout (FuncState *fs, BlockCnt *bl) {
|
||||
int i = bl->firstgoto;
|
||||
Labellist *gl = &fs->ls->dyd->gt;
|
||||
/* correct pending gotos to current block and try to close it
|
||||
with visible labels */
|
||||
while (i < gl->n) {
|
||||
while (i < gl->n) { /* for each pending goto */
|
||||
Labeldesc *gt = &gl->arr[i];
|
||||
if (gt->nactvar > bl->nactvar) {
|
||||
if (bl->upval)
|
||||
luaK_patchclose(fs, gt->pc, bl->nactvar);
|
||||
gt->nactvar = bl->nactvar;
|
||||
if (gt->nactvar > bl->nactvar) { /* leaving a variable scope? */
|
||||
if (bl->upval) /* variable may be an upvalue? */
|
||||
luaK_patchclose(fs, gt->pc); /* jump will need a close */
|
||||
gt->nactvar = bl->nactvar; /* update goto level */
|
||||
}
|
||||
if (!findlabel(fs->ls, i))
|
||||
if (!solvelabel(fs->ls, i))
|
||||
i++; /* move to next one */
|
||||
/* else, 'solvelabel' removed current goto from the list
|
||||
and 'i' now points to next one */
|
||||
}
|
||||
/* handles break list */
|
||||
if (bl->upval) /* exiting the scope of an upvalue? */
|
||||
luaK_patchclose(fs, bl->brks); /* breaks will need OP_CLOSE */
|
||||
/* move breaks to outer block */
|
||||
luaK_concat(fs, &bl->previous->brks, bl->brks);
|
||||
bl->previous->brkcls |= bl->brkcls;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -441,6 +452,8 @@ static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) {
|
|||
bl->nactvar = fs->nactvar;
|
||||
bl->firstlabel = fs->ls->dyd->label.n;
|
||||
bl->firstgoto = fs->ls->dyd->gt.n;
|
||||
bl->brks = NO_JUMP;
|
||||
bl->brkcls = 0;
|
||||
bl->upval = 0;
|
||||
bl->previous = fs->bl;
|
||||
fs->bl = bl;
|
||||
|
|
@ -449,22 +462,24 @@ static void enterblock (FuncState *fs, BlockCnt *bl, lu_byte isloop) {
|
|||
|
||||
|
||||
/*
|
||||
** create a label named 'break' to resolve break statements
|
||||
** Fix all breaks in block 'bl' to jump to the end of the block.
|
||||
*/
|
||||
static void breaklabel (LexState *ls) {
|
||||
TString *n = luaS_new(ls->L, "break");
|
||||
int l = newlabelentry(ls, &ls->dyd->label, n, 0, ls->fs->pc);
|
||||
findgotos(ls, &ls->dyd->label.arr[l]);
|
||||
static void fixbreaks (FuncState *fs, BlockCnt *bl) {
|
||||
int target = fs->pc;
|
||||
if (bl->brkcls) /* does the block need to close upvalues? */
|
||||
luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
|
||||
luaK_patchgoto(fs, bl->brks, target, bl->brkcls);
|
||||
bl->brks = NO_JUMP; /* no more breaks to fix */
|
||||
bl->brkcls = 0; /* no more need to close upvalues */
|
||||
lua_assert(!bl->upval); /* loop body cannot have local variables */
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
** generates an error for an undefined 'goto'; choose appropriate
|
||||
** message when label name is a reserved word (which can only be 'break')
|
||||
** generates an error for an undefined 'goto'.
|
||||
*/
|
||||
static l_noret undefgoto (LexState *ls, Labeldesc *gt) {
|
||||
const char *msg = isreserved(gt->name)
|
||||
? "<%s> at line %d not inside a loop"
|
||||
: "no visible label '%s' for <goto> at line %d";
|
||||
const char *msg = "no visible label '%s' for <goto> at line %d";
|
||||
msg = luaO_pushfstring(ls->L, msg, getstr(gt->name), gt->line);
|
||||
semerror(ls, msg);
|
||||
}
|
||||
|
|
@ -473,14 +488,12 @@ static l_noret undefgoto (LexState *ls, Labeldesc *gt) {
|
|||
static void leaveblock (FuncState *fs) {
|
||||
BlockCnt *bl = fs->bl;
|
||||
LexState *ls = fs->ls;
|
||||
if (bl->previous && bl->upval) {
|
||||
/* create a 'jump to here' to close upvalues */
|
||||
int j = luaK_jump(fs);
|
||||
luaK_patchclose(fs, j, bl->nactvar);
|
||||
luaK_patchtohere(fs, j);
|
||||
}
|
||||
if (bl->upval && bl->brks != NO_JUMP) /* breaks in upvalue scopes? */
|
||||
bl->brkcls = 1; /* these breaks must close the upvalues */
|
||||
if (bl->isloop)
|
||||
breaklabel(ls); /* close pending breaks */
|
||||
fixbreaks(fs, bl); /* fix pending breaks */
|
||||
if (bl->previous && bl->upval)
|
||||
luaK_codeABC(fs, OP_CLOSE, bl->nactvar, 0, 0);
|
||||
fs->bl = bl->previous;
|
||||
removevars(fs, bl->nactvar);
|
||||
lua_assert(bl->nactvar == fs->nactvar);
|
||||
|
|
@ -488,8 +501,11 @@ static void leaveblock (FuncState *fs) {
|
|||
ls->dyd->label.n = bl->firstlabel; /* remove local labels */
|
||||
if (bl->previous) /* inner block? */
|
||||
movegotosout(fs, bl); /* update pending gotos to outer block */
|
||||
else if (bl->firstgoto < ls->dyd->gt.n) /* pending gotos in outer block? */
|
||||
undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */
|
||||
else {
|
||||
lua_assert(bl->brks == NO_JUMP); /* no pending breaks */
|
||||
if (bl->firstgoto < ls->dyd->gt.n) /* pending gotos in outer block? */
|
||||
undefgoto(ls, &ls->dyd->gt.arr[bl->firstgoto]); /* error */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1205,16 +1221,21 @@ static int cond (LexState *ls) {
|
|||
|
||||
static void gotostat (LexState *ls, int pc) {
|
||||
int line = ls->linenumber;
|
||||
TString *label;
|
||||
int g;
|
||||
if (testnext(ls, TK_GOTO))
|
||||
label = str_checkname(ls);
|
||||
else {
|
||||
luaX_next(ls); /* skip break */
|
||||
label = luaS_new(ls->L, "break");
|
||||
}
|
||||
g = newlabelentry(ls, &ls->dyd->gt, label, line, pc);
|
||||
findlabel(ls, g); /* close it if label already defined */
|
||||
luaX_next(ls); /* skip 'goto' */
|
||||
g = newlabelentry(ls, &ls->dyd->gt, str_checkname(ls), line, pc);
|
||||
solvelabel(ls, g); /* close it if label already defined */
|
||||
}
|
||||
|
||||
|
||||
static void breakstat (LexState *ls, int pc) {
|
||||
FuncState *fs = ls->fs;
|
||||
BlockCnt *bl = fs->bl;
|
||||
luaX_next(ls); /* skip break */
|
||||
while (bl && !bl->isloop) { bl = bl->previous; }
|
||||
if (!bl)
|
||||
luaX_syntaxerror(ls, "no loop to break");
|
||||
luaK_concat(fs, &fs->bl->brks, pc);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1248,12 +1269,13 @@ static void labelstat (LexState *ls, TString *label, int line) {
|
|||
checknext(ls, TK_DBCOLON); /* skip double colon */
|
||||
/* create new entry for this label */
|
||||
l = newlabelentry(ls, ll, label, line, luaK_getlabel(fs));
|
||||
luaK_codeABC(fs, OP_CLOSE, fs->nactvar, 0, 0);
|
||||
skipnoopstat(ls); /* skip other no-op statements */
|
||||
if (block_follow(ls, 0)) { /* label is last no-op statement in the block? */
|
||||
/* assume that locals are already out of scope */
|
||||
ll->arr[l].nactvar = fs->bl->nactvar;
|
||||
}
|
||||
findgotos(ls, &ll->arr[l]);
|
||||
solvegotos(ls, &ll->arr[l]);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1289,8 +1311,15 @@ static void repeatstat (LexState *ls, int line) {
|
|||
check_match(ls, TK_UNTIL, TK_REPEAT, line);
|
||||
condexit = cond(ls); /* read condition (inside scope block) */
|
||||
if (bl2.upval) /* upvalues? */
|
||||
luaK_patchclose(fs, condexit, bl2.nactvar);
|
||||
luaK_patchclose(fs, condexit);
|
||||
leaveblock(fs); /* finish scope */
|
||||
if (bl2.upval) { /* upvalues? */
|
||||
int exit = luaK_jump(fs); /* normal exit must jump over fix */
|
||||
luaK_patchtohere(fs, condexit); /* repetition must close upvalues */
|
||||
luaK_codeABC(fs, OP_CLOSE, bl2.nactvar, 0, 0);
|
||||
condexit = luaK_jump(fs); /* repeat after closing upvalues */
|
||||
luaK_patchtohere(fs, exit); /* normal exit comes to here */
|
||||
}
|
||||
luaK_patchlist(fs, condexit, repeat_init); /* close the loop */
|
||||
leaveblock(fs); /* finish loop */
|
||||
}
|
||||
|
|
@ -1428,9 +1457,12 @@ static void test_then_block (LexState *ls, int *escapelist) {
|
|||
if (ls->t.token == TK_GOTO || ls->t.token == TK_BREAK) {
|
||||
luaK_goiffalse(ls->fs, &v); /* will jump to label if condition is true */
|
||||
enterblock(fs, &bl, 0); /* must enter block before 'goto' */
|
||||
gotostat(ls, v.t); /* handle goto/break */
|
||||
if (ls->t.token == TK_GOTO)
|
||||
gotostat(ls, v.t); /* handle goto */
|
||||
else
|
||||
breakstat(ls, v.t); /* handle break */
|
||||
while (testnext(ls, ';')) {} /* skip semicolons */
|
||||
if (block_follow(ls, 0)) { /* 'goto' is the entire block? */
|
||||
if (block_follow(ls, 0)) { /* 'goto'/'break' is the entire block? */
|
||||
leaveblock(fs);
|
||||
return; /* and that is it */
|
||||
}
|
||||
|
|
@ -1623,7 +1655,10 @@ static void statement (LexState *ls) {
|
|||
retstat(ls);
|
||||
break;
|
||||
}
|
||||
case TK_BREAK: /* stat -> breakstat */
|
||||
case TK_BREAK: { /* stat -> breakstat */
|
||||
breakstat(ls, luaK_jump(ls->fs));
|
||||
break;
|
||||
}
|
||||
case TK_GOTO: { /* stat -> 'goto' NAME */
|
||||
gotostat(ls, luaK_jump(ls->fs));
|
||||
break;
|
||||
|
|
|
|||
11
lvm.c
11
lvm.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lvm.c,v 2.290 2017/07/07 16:34:32 roberto Exp roberto $
|
||||
** $Id: lvm.c,v 2.291 2017/08/14 18:33:14 roberto Exp roberto $
|
||||
** Lua virtual machine
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -753,10 +753,7 @@ void luaV_finishOp (lua_State *L) {
|
|||
** Execute a jump instruction. The 'updatemask' allows signals to stop
|
||||
** tight loops. (Without it, the local copy of 'mask' could never change.)
|
||||
*/
|
||||
#define dojump(ci,i,e) \
|
||||
{ int a = GETARG_A(i); \
|
||||
if (a != 0) luaF_close(L, ci->func + a); \
|
||||
pc += GETARG_sBx(i) + e; updatemask(L); }
|
||||
#define dojump(ci,i,e) { pc += GETARG_sBx(i) + e; updatemask(L); }
|
||||
|
||||
|
||||
/* for test instructions, execute the jump instruction that follows it */
|
||||
|
|
@ -1201,6 +1198,10 @@ void luaV_execute (lua_State *L) {
|
|||
L->top = ci->top; /* restore top */
|
||||
vmbreak;
|
||||
}
|
||||
vmcase(OP_CLOSE) {
|
||||
luaF_close(L, ra);
|
||||
vmbreak;
|
||||
}
|
||||
vmcase(OP_JMP) {
|
||||
dojump(ci, i, 0);
|
||||
vmbreak;
|
||||
|
|
|
|||
Loading…
Reference in New Issue