mirror of
https://github.com/lua/lua
synced 2024-11-22 21:01:26 +03:00
opcodes with builtin parameters are too complicated for very little extra
performance.
This commit is contained in:
Roberto Ierusalimschy
parent
50248e440a
commit
1a17da2ff9
84
lopcodes.h
84
lopcodes.h
@ -1,5 +1,5 @@
|
||||
/*
|
||||
** $Id: lopcodes.h,v 1.17 1998/03/25 18:52:29 roberto Exp roberto $
|
||||
** $Id: lopcodes.h,v 1.18 1998/06/25 14:37:00 roberto Exp roberto $
|
||||
** Opcodes for Lua virtual machine
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
@ -8,10 +8,11 @@
|
||||
#define lopcodes_h
|
||||
|
||||
|
||||
#define NUMOFFSET 100
|
||||
|
||||
/*
|
||||
** NOTICE: variants of the same opcode must be consecutive: First, those
|
||||
** with byte parameter, then with built-in parameters, and last with
|
||||
** word parameter.
|
||||
** with byte parameter, then with word parameter.
|
||||
*/
|
||||
|
||||
|
||||
@ -21,98 +22,34 @@ typedef enum {
|
||||
ENDCODE,/* - - - */
|
||||
|
||||
PUSHNIL,/* b - nil_0...nil_b */
|
||||
PUSHNIL0,/* - - nil */
|
||||
|
||||
PUSHNUMBER,/* b - (float)b */
|
||||
PUSHNUMBER0,/* - - 0.0 */
|
||||
PUSHNUMBER1,/* - - 1.0 */
|
||||
PUSHNUMBER2,/* - - 2.0 */
|
||||
PUSHNUMBERW,/* w - (float)w */
|
||||
PUSHNUMBER,/* b - (float)(b-NUMOFFSET) */
|
||||
PUSHNUMBERW,/* w - (float)(w-NUMOFFSET) */
|
||||
|
||||
PUSHCONSTANT,/* b - CNST[b] */
|
||||
PUSHCONSTANT0,/*- - CNST[0] */
|
||||
PUSHCONSTANT1,/*- - CNST[1] */
|
||||
PUSHCONSTANT2,/*- - CNST[2] */
|
||||
PUSHCONSTANT3,/*- - CNST[3] */
|
||||
PUSHCONSTANT4,/*- - CNST[4] */
|
||||
PUSHCONSTANT5,/*- - CNST[5] */
|
||||
PUSHCONSTANT6,/*- - CNST[6] */
|
||||
PUSHCONSTANT7,/*- - CNST[7] */
|
||||
PUSHCONSTANTW,/*w - CNST[w] */
|
||||
|
||||
PUSHUPVALUE,/* b - Closure[b] */
|
||||
PUSHUPVALUE0,/* - - Closure[0] */
|
||||
PUSHUPVALUE1,/* - - Closure[1] */
|
||||
|
||||
PUSHLOCAL,/* b - LOC[b] */
|
||||
PUSHLOCAL0,/* - - LOC[0] */
|
||||
PUSHLOCAL1,/* - - LOC[1] */
|
||||
PUSHLOCAL2,/* - - LOC[2] */
|
||||
PUSHLOCAL3,/* - - LOC[3] */
|
||||
PUSHLOCAL4,/* - - LOC[4] */
|
||||
PUSHLOCAL5,/* - - LOC[5] */
|
||||
PUSHLOCAL6,/* - - LOC[6] */
|
||||
PUSHLOCAL7,/* - - LOC[7] */
|
||||
|
||||
GETGLOBAL,/* b - VAR[CNST[b]] */
|
||||
GETGLOBAL0,/* - - VAR[CNST[0]] */
|
||||
GETGLOBAL1,/* - - VAR[CNST[1]] */
|
||||
GETGLOBAL2,/* - - VAR[CNST[2]] */
|
||||
GETGLOBAL3,/* - - VAR[CNST[3]] */
|
||||
GETGLOBAL4,/* - - VAR[CNST[4]] */
|
||||
GETGLOBAL5,/* - - VAR[CNST[5]] */
|
||||
GETGLOBAL6,/* - - VAR[CNST[6]] */
|
||||
GETGLOBAL7,/* - - VAR[CNST[7]] */
|
||||
GETGLOBALW,/* w - VAR[CNST[w]] */
|
||||
|
||||
GETTABLE,/* - i t t[i] */
|
||||
|
||||
GETDOTTED,/* b t t[CNST[b]] */
|
||||
GETDOTTED0,/* - t t[CNST[0]] */
|
||||
GETDOTTED1,/* - t t[CNST[1]] */
|
||||
GETDOTTED2,/* - t t[CNST[2]] */
|
||||
GETDOTTED3,/* - t t[CNST[3]] */
|
||||
GETDOTTED4,/* - t t[CNST[4]] */
|
||||
GETDOTTED5,/* - t t[CNST[5]] */
|
||||
GETDOTTED6,/* - t t[CNST[6]] */
|
||||
GETDOTTED7,/* - t t[CNST[7]] */
|
||||
GETDOTTEDW,/* w t t[CNST[w]] */
|
||||
|
||||
PUSHSELF,/* b t t t[CNST[b]] */
|
||||
PUSHSELF0,/* - t t t[CNST[0]] */
|
||||
PUSHSELF1,/* - t t t[CNST[1]] */
|
||||
PUSHSELF2,/* - t t t[CNST[2]] */
|
||||
PUSHSELF3,/* - t t t[CNST[3]] */
|
||||
PUSHSELF4,/* - t t t[CNST[4]] */
|
||||
PUSHSELF5,/* - t t t[CNST[5]] */
|
||||
PUSHSELF6,/* - t t t[CNST[6]] */
|
||||
PUSHSELF7,/* - t t t[CNST[7]] */
|
||||
PUSHSELFW,/* w t t t[CNST[w]] */
|
||||
|
||||
CREATEARRAY,/* b - newarray(size = b) */
|
||||
CREATEARRAY0,/* - - newarray(size = 0) */
|
||||
CREATEARRAY1,/* - - newarray(size = 1) */
|
||||
CREATEARRAYW,/* w - newarray(size = w) */
|
||||
|
||||
SETLOCAL,/* b x - LOC[b]=x */
|
||||
SETLOCAL0,/* - x - LOC[0]=x */
|
||||
SETLOCAL1,/* - x - LOC[1]=x */
|
||||
SETLOCAL2,/* - x - LOC[2]=x */
|
||||
SETLOCAL3,/* - x - LOC[3]=x */
|
||||
SETLOCAL4,/* - x - LOC[4]=x */
|
||||
SETLOCAL5,/* - x - LOC[5]=x */
|
||||
SETLOCAL6,/* - x - LOC[6]=x */
|
||||
SETLOCAL7,/* - x - LOC[7]=x */
|
||||
|
||||
SETGLOBAL,/* b x - VAR[CNST[b]]=x */
|
||||
SETGLOBAL0,/* - x - VAR[CNST[0]]=x */
|
||||
SETGLOBAL1,/* - x - VAR[CNST[1]]=x */
|
||||
SETGLOBAL2,/* - x - VAR[CNST[2]]=x */
|
||||
SETGLOBAL3,/* - x - VAR[CNST[3]]=x */
|
||||
SETGLOBAL4,/* - x - VAR[CNST[4]]=x */
|
||||
SETGLOBAL5,/* - x - VAR[CNST[5]]=x */
|
||||
SETGLOBAL6,/* - x - VAR[CNST[6]]=x */
|
||||
SETGLOBAL7,/* - x - VAR[CNST[7]]=x */
|
||||
SETGLOBALW,/* w x - VAR[CNST[w]]=x */
|
||||
|
||||
SETTABLE0,/* - v i t - t[i]=v */
|
||||
@ -120,11 +57,9 @@ SETTABLE0,/* - v i t - t[i]=v */
|
||||
SETTABLE,/* b v a_b...a_1 i t a_b...a_1 i t t[i]=v */
|
||||
|
||||
SETLIST,/* b c v_c...v_1 t - t[i+b*FPF]=v_i */
|
||||
SETLIST0,/* b v_b...v_1 t - t[i]=v_i */
|
||||
SETLISTW,/* w c v_c...v_1 t - t[i+w*FPF]=v_i */
|
||||
|
||||
SETMAP,/* b v_b k_b ...v_0 k_0 t t t[k_i]=v_i */
|
||||
SETMAP0,/* - v_0 k_0 t t t[k_0]=v_0 */
|
||||
|
||||
EQOP,/* - y x (x==y)? 1 : nil */
|
||||
NEQOP,/* - y x (x~=y)? 1 : nil */
|
||||
@ -155,20 +90,15 @@ IFFUPJMP,/* b x - (x==nil)? PC-=b */
|
||||
IFFUPJMPW,/* w x - (x==nil)? PC-=w */
|
||||
|
||||
CLOSURE,/* b c v_c...v_1 closure(CNST[b], v_c...v_1) */
|
||||
CLOSUREW,/* w c v_b...v_1 closure(CNST[w], v_c...v_1) */
|
||||
|
||||
CALLFUNC,/* b c v_c...v_1 f r_b...r_1 f(v1,...,v_c) */
|
||||
CALLFUNC0,/* b v_b...v_1 f - f(v1,...,v_b) */
|
||||
CALLFUNC1,/* b v_b...v_1 f r_1 f(v1,...,v_b) */
|
||||
|
||||
RETCODE,/* b - - */
|
||||
|
||||
SETLINE,/* b - - LINE=b */
|
||||
SETLINEW,/* w - - LINE=w */
|
||||
|
||||
POP,/* b - - TOP-=(b+1) */
|
||||
POP0,/* - - - TOP-=1 */
|
||||
POP1/* - - - TOP-=2 */
|
||||
POP /* b - - TOP-=(b+1) */
|
||||
|
||||
} OpCode;
|
||||
|
||||
|
||||
86
lparser.c
86
lparser.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
** $Id: lparser.c,v 1.11 1999/02/01 18:52:05 roberto Exp roberto $
|
||||
** $Id: lparser.c,v 1.12 1999/02/02 13:47:31 roberto Exp roberto $
|
||||
** LL(1) Parser and code generator for Lua
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
@ -153,24 +153,19 @@ static void deltastack (LexState *ls, int delta) {
|
||||
}
|
||||
|
||||
|
||||
static int code_oparg_at (LexState *ls, int pc, OpCode op, int builtin,
|
||||
int arg, int delta) {
|
||||
static int code_oparg_at (LexState *ls, int pc, OpCode op, int arg, int delta) {
|
||||
Byte *code = ls->fs->f->code;
|
||||
deltastack(ls, delta);
|
||||
if (arg < builtin) {
|
||||
code[pc] = (Byte)(op+1+arg);
|
||||
return 1;
|
||||
}
|
||||
else if (arg <= 255) {
|
||||
if (arg <= 255) {
|
||||
code[pc] = (Byte)op;
|
||||
code[pc+1] = (Byte)arg;
|
||||
return 2;
|
||||
return 2; /* code size (opcode + 1 byte) */
|
||||
}
|
||||
else if (arg <= MAX_WORD) {
|
||||
code[pc] = (Byte)(op+1+builtin);
|
||||
code[pc] = (Byte)(op+1);
|
||||
code[pc+1] = (Byte)(arg>>8);
|
||||
code[pc+2] = (Byte)(arg&0xFF);
|
||||
return 3;
|
||||
return 3; /* code size (opcode + 1 word) */
|
||||
}
|
||||
else luaX_error(ls, "code too long " MES_LIM("64K")
|
||||
" (try turning off debug mode)");
|
||||
@ -178,25 +173,21 @@ static int code_oparg_at (LexState *ls, int pc, OpCode op, int builtin,
|
||||
}
|
||||
|
||||
|
||||
static int fix_opcode (LexState *ls, int pc, OpCode op, int builtin, int arg) {
|
||||
static int fix_opcode (LexState *ls, int pc, OpCode op, int arg) {
|
||||
FuncState *fs = ls->fs;
|
||||
TProtoFunc *f = fs->f;
|
||||
if (arg < builtin) { /* close space */
|
||||
luaO_memdown(f->code+pc+1, f->code+pc+2, fs->pc-(pc+2));
|
||||
fs->pc--;
|
||||
}
|
||||
else if (arg > 255) { /* open space */
|
||||
if (arg > 255) { /* open space */
|
||||
check_pc(fs, 1);
|
||||
luaO_memup(f->code+pc+1, f->code+pc, fs->pc-pc);
|
||||
fs->pc++;
|
||||
}
|
||||
return code_oparg_at(ls, pc, op, builtin, arg, 0) - 2;
|
||||
return code_oparg_at(ls, pc, op, arg, 0) - 2;
|
||||
}
|
||||
|
||||
static void code_oparg (LexState *ls, OpCode op, int builtin, int arg,
|
||||
int delta) {
|
||||
|
||||
static void code_oparg (LexState *ls, OpCode op, int arg, int delta) {
|
||||
check_pc(ls->fs, 3); /* maximum code size */
|
||||
ls->fs->pc += code_oparg_at(ls, ls->fs->pc, op, builtin, arg, delta);
|
||||
ls->fs->pc += code_oparg_at(ls, ls->fs->pc, op, arg, delta);
|
||||
}
|
||||
|
||||
|
||||
@ -207,7 +198,7 @@ static void code_opcode (LexState *ls, OpCode op, int delta) {
|
||||
|
||||
|
||||
static void code_constant (LexState *ls, int c) {
|
||||
code_oparg(ls, PUSHCONSTANT, 8, c, 1);
|
||||
code_oparg(ls, PUSHCONSTANT, c, 1);
|
||||
}
|
||||
|
||||
|
||||
@ -261,8 +252,9 @@ static int real_constant (FuncState *fs, real r) {
|
||||
|
||||
static void code_number (LexState *ls, real f) {
|
||||
int i;
|
||||
if (0 <= f && f <= (real)MAX_WORD && (real)(i=(int)f) == f)
|
||||
code_oparg(ls, PUSHNUMBER, 3, i, 1); /* f has a short integer value */
|
||||
if (0 <= f+NUMOFFSET && f+NUMOFFSET <= (real)MAX_WORD &&
|
||||
(real)(i=(int)f) == f) /* f+NUMOFFSET has a short integer value? */
|
||||
code_oparg(ls, PUSHNUMBER, i+NUMOFFSET, 1);
|
||||
else
|
||||
code_constant(ls, real_constant(ls->fs, f));
|
||||
}
|
||||
@ -270,13 +262,13 @@ static void code_number (LexState *ls, real f) {
|
||||
|
||||
static void flush_record (LexState *ls, int n) {
|
||||
if (n > 0)
|
||||
code_oparg(ls, SETMAP, 1, n-1, -2*n);
|
||||
code_oparg(ls, SETMAP, n-1, -2*n);
|
||||
}
|
||||
|
||||
|
||||
static void flush_list (LexState *ls, int m, int n) {
|
||||
if (n == 0) return;
|
||||
code_oparg(ls, SETLIST, 1, m, -n);
|
||||
code_oparg(ls, SETLIST, m, -n);
|
||||
code_byte(ls->fs, (Byte)n);
|
||||
}
|
||||
|
||||
@ -285,14 +277,12 @@ static void luaI_registerlocalvar (FuncState *fs, TaggedString *varname,
|
||||
int line) {
|
||||
if (fs->maxvars != -1) { /* debug information? */
|
||||
TProtoFunc *f = fs->f;
|
||||
if (fs->nvars+2 > fs->maxvars)
|
||||
fs->maxvars = luaM_growvector(&f->locvars, fs->maxvars+2,
|
||||
if (fs->nvars+1 > fs->maxvars)
|
||||
fs->maxvars = luaM_growvector(&f->locvars, fs->maxvars+1,
|
||||
LocVar, "", MAX_WORD);
|
||||
f->locvars[fs->nvars].varname = varname;
|
||||
f->locvars[fs->nvars].line = line;
|
||||
fs->nvars++;
|
||||
f->locvars[fs->nvars].line = -1; /* flag end of vector */
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -369,14 +359,14 @@ static void pushupvalue (LexState *ls, TaggedString *n) {
|
||||
if (aux_localname(ls->fs, n) >= 0)
|
||||
luaX_syntaxerror(ls, "cannot access an upvalue in current scope", n->str);
|
||||
i = indexupvalue(ls, n);
|
||||
code_oparg(ls, PUSHUPVALUE, 2, i, 1);
|
||||
code_oparg(ls, PUSHUPVALUE, i, 1);
|
||||
}
|
||||
|
||||
|
||||
|
||||
static void check_debugline (LexState *ls) {
|
||||
if (lua_debug && ls->linenumber != ls->fs->lastsetline) {
|
||||
code_oparg(ls, SETLINE, 0, ls->linenumber, 0);
|
||||
code_oparg(ls, SETLINE, ls->linenumber, 0);
|
||||
ls->fs->lastsetline = ls->linenumber;
|
||||
}
|
||||
}
|
||||
@ -384,9 +374,9 @@ static void check_debugline (LexState *ls) {
|
||||
|
||||
static void adjuststack (LexState *ls, int n) {
|
||||
if (n > 0)
|
||||
code_oparg(ls, POP, 2, n-1, -n);
|
||||
code_oparg(ls, POP, n-1, -n);
|
||||
else if (n < 0)
|
||||
code_oparg(ls, PUSHNIL, 1, (-n)-1, -n);
|
||||
code_oparg(ls, PUSHNIL, (-n)-1, -n);
|
||||
}
|
||||
|
||||
|
||||
@ -394,7 +384,7 @@ static void close_exp (LexState *ls, int pc, int nresults) {
|
||||
if (pc > 0) { /* expression is an open function call */
|
||||
Byte *code = ls->fs->f->code;
|
||||
Byte nparams = code[pc]; /* save nparams */
|
||||
pc += fix_opcode(ls, pc-2, CALLFUNC, 2, nresults);
|
||||
pc += fix_opcode(ls, pc-2, CALLFUNC, nresults);
|
||||
code[pc] = nparams; /* restore nparams */
|
||||
if (nresults != MULT_RET)
|
||||
deltastack(ls, nresults); /* "push" results */
|
||||
@ -442,13 +432,13 @@ static void code_args (LexState *ls, int nparams, int dots) {
|
||||
static void lua_pushvar (LexState *ls, vardesc *var) {
|
||||
switch (var->k) {
|
||||
case VLOCAL:
|
||||
code_oparg(ls, PUSHLOCAL, 8, var->info, 1);
|
||||
code_oparg(ls, PUSHLOCAL, var->info, 1);
|
||||
break;
|
||||
case VGLOBAL:
|
||||
code_oparg(ls, GETGLOBAL, 8, var->info, 1);
|
||||
code_oparg(ls, GETGLOBAL, var->info, 1);
|
||||
break;
|
||||
case VDOT:
|
||||
code_oparg(ls, GETDOTTED, 8, var->info, 0);
|
||||
code_oparg(ls, GETDOTTED, var->info, 0);
|
||||
break;
|
||||
case VINDEXED:
|
||||
code_opcode(ls, GETTABLE, -1);
|
||||
@ -465,10 +455,10 @@ static void lua_pushvar (LexState *ls, vardesc *var) {
|
||||
static void storevar (LexState *ls, vardesc *var) {
|
||||
switch (var->k) {
|
||||
case VLOCAL:
|
||||
code_oparg(ls, SETLOCAL, 8, var->info, -1);
|
||||
code_oparg(ls, SETLOCAL, var->info, -1);
|
||||
break;
|
||||
case VGLOBAL:
|
||||
code_oparg(ls, SETGLOBAL, 8, var->info, -1);
|
||||
code_oparg(ls, SETGLOBAL, var->info, -1);
|
||||
break;
|
||||
case VINDEXED:
|
||||
code_opcode(ls, SETTABLE0, -3);
|
||||
@ -481,14 +471,14 @@ static void storevar (LexState *ls, vardesc *var) {
|
||||
|
||||
static int fix_jump (LexState *ls, int pc, OpCode op, int n) {
|
||||
/* jump is relative to position following jump instruction */
|
||||
return fix_opcode(ls, pc, op, 0, n-(pc+JMPSIZE));
|
||||
return fix_opcode(ls, pc, op, n-(pc+JMPSIZE));
|
||||
}
|
||||
|
||||
|
||||
static void fix_upjmp (LexState *ls, OpCode op, int pos) {
|
||||
int delta = ls->fs->pc+JMPSIZE - pos; /* jump is relative */
|
||||
if (delta > 255) delta++;
|
||||
code_oparg(ls, op, 0, delta, 0);
|
||||
code_oparg(ls, op, delta, 0);
|
||||
}
|
||||
|
||||
|
||||
@ -516,7 +506,7 @@ static void func_onstack (LexState *ls, FuncState *func) {
|
||||
else {
|
||||
for (i=0; i<func->nupvalues; i++)
|
||||
lua_pushvar(ls, &func->upvalues[i]);
|
||||
code_oparg(ls, CLOSURE, 0, c, -func->nupvalues+1);
|
||||
code_oparg(ls, CLOSURE, c, -func->nupvalues+1);
|
||||
code_byte(fs, (Byte)func->nupvalues);
|
||||
}
|
||||
}
|
||||
@ -862,7 +852,7 @@ static void ifpart (LexState *ls, int isexp, int line) {
|
||||
}
|
||||
else { /* is exp */
|
||||
if (elsepart) exp1(ls);
|
||||
else code_oparg(ls, PUSHNIL, 1, 0, 1); /* empty else exp */
|
||||
else adjuststack(ls, -1); /* empty else exp -> push nil */
|
||||
}
|
||||
check_match(ls, END, IF, line);
|
||||
}
|
||||
@ -878,7 +868,7 @@ static void ret (LexState *ls) {
|
||||
next(ls);
|
||||
explist(ls, &e);
|
||||
close_exp(ls, e.pc, MULT_RET);
|
||||
code_oparg(ls, RETCODE, 0, ls->fs->nlocalvar, 0);
|
||||
code_oparg(ls, RETCODE, ls->fs->nlocalvar, 0);
|
||||
ls->fs->stacksize = ls->fs->nlocalvar; /* removes all temp values */
|
||||
optional(ls, ';');
|
||||
}
|
||||
@ -1078,7 +1068,7 @@ static void var_or_func_tail (LexState *ls, vardesc *v) {
|
||||
case ':': /* var_or_func_tail -> ':' NAME funcparams */
|
||||
next(ls);
|
||||
lua_pushvar(ls, v); /* 'v' must be on stack */
|
||||
code_oparg(ls, PUSHSELF, 8, checkname(ls), 1);
|
||||
code_oparg(ls, PUSHSELF, checkname(ls), 1);
|
||||
v->k = VEXP;
|
||||
v->info = funcparams(ls, 1);
|
||||
break;
|
||||
@ -1242,7 +1232,7 @@ static int assignment (LexState *ls, vardesc *v, int nvars) {
|
||||
storevar(ls, v);
|
||||
}
|
||||
else { /* indexed var with values in between*/
|
||||
code_oparg(ls, SETTABLE, 0, left+(nvars-1), -1);
|
||||
code_oparg(ls, SETTABLE, left+(nvars-1), -1);
|
||||
left += 2; /* table/index are not popped, because they aren't on top */
|
||||
}
|
||||
return left;
|
||||
@ -1267,7 +1257,7 @@ static void constructor (LexState *ls) {
|
||||
nelems += other_cd.n;
|
||||
}
|
||||
check_match(ls, '}', '{', line);
|
||||
fix_opcode(ls, pc, CREATEARRAY, 2, nelems);
|
||||
fix_opcode(ls, pc, CREATEARRAY, nelems);
|
||||
}
|
||||
|
||||
static void part (LexState *ls, constdesc *cd) {
|
||||
|
||||
235
lvm.c
235
lvm.c
@ -1,5 +1,5 @@
|
||||
/*
|
||||
** $Id: lvm.c,v 1.40 1999/01/20 20:22:06 roberto Exp roberto $
|
||||
** $Id: lvm.c,v 1.41 1999/01/25 17:39:28 roberto Exp roberto $
|
||||
** Lua virtual machine
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
@ -31,9 +31,7 @@
|
||||
#endif
|
||||
|
||||
|
||||
#define skip_word(pc) (pc+=2)
|
||||
#define get_word(pc) ((*(pc)<<8)+(*((pc)+1)))
|
||||
#define next_word(pc) (pc+=2, get_word(pc-2))
|
||||
#define highbyte(x) ((x)<<8)
|
||||
|
||||
|
||||
/* Extra stack size to run a function: LUA_T_LINE(1), TM calls(2), ... */
|
||||
@ -315,10 +313,9 @@ static void adjust_varargs (StkId first_extra_arg)
|
||||
** [stack+base,top). Returns n such that the the results are between
|
||||
** [stack+n,top).
|
||||
*/
|
||||
StkId luaV_execute (Closure *cl, TProtoFunc *tf, StkId base)
|
||||
{
|
||||
StkId luaV_execute (Closure *cl, TProtoFunc *tf, StkId base) {
|
||||
struct Stack *S = &L->stack; /* to optimize */
|
||||
Byte *pc = tf->code;
|
||||
register Byte *pc = tf->code;
|
||||
TObject *consts = tf->consts;
|
||||
if (lua_callhook)
|
||||
luaD_callHook(base, tf, 0);
|
||||
@ -330,54 +327,28 @@ StkId luaV_execute (Closure *cl, TProtoFunc *tf, StkId base)
|
||||
adjust_varargs(base+(*pc++)-ZEROVARARG);
|
||||
}
|
||||
for (;;) {
|
||||
int aux;
|
||||
switch ((OpCode)(aux = *pc++)) {
|
||||
register int aux = 0;
|
||||
switch ((OpCode)*pc++) {
|
||||
|
||||
case PUSHNIL0:
|
||||
ttype(S->top++) = LUA_T_NIL;
|
||||
break;
|
||||
|
||||
case PUSHNIL:
|
||||
aux = *pc++;
|
||||
case PUSHNIL: aux = *pc++;
|
||||
do {
|
||||
ttype(S->top++) = LUA_T_NIL;
|
||||
} while (aux--);
|
||||
break;
|
||||
|
||||
case PUSHNUMBER:
|
||||
aux = *pc++; goto pushnumber;
|
||||
|
||||
case PUSHNUMBERW:
|
||||
aux = next_word(pc); goto pushnumber;
|
||||
|
||||
case PUSHNUMBER0: case PUSHNUMBER1: case PUSHNUMBER2:
|
||||
aux -= PUSHNUMBER0;
|
||||
pushnumber:
|
||||
case PUSHNUMBERW: aux = highbyte(*pc++);
|
||||
case PUSHNUMBER: aux += *pc++;
|
||||
ttype(S->top) = LUA_T_NUMBER;
|
||||
nvalue(S->top) = aux;
|
||||
nvalue(S->top) = aux-NUMOFFSET;
|
||||
S->top++;
|
||||
break;
|
||||
|
||||
case PUSHLOCAL:
|
||||
aux = *pc++; goto pushlocal;
|
||||
|
||||
case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2: case PUSHLOCAL3:
|
||||
case PUSHLOCAL4: case PUSHLOCAL5: case PUSHLOCAL6: case PUSHLOCAL7:
|
||||
aux -= PUSHLOCAL0;
|
||||
pushlocal:
|
||||
case PUSHLOCAL: aux = *pc++;
|
||||
*S->top++ = *((S->stack+base) + aux);
|
||||
break;
|
||||
|
||||
case GETGLOBALW:
|
||||
aux = next_word(pc); goto getglobal;
|
||||
|
||||
case GETGLOBAL:
|
||||
aux = *pc++; goto getglobal;
|
||||
|
||||
case GETGLOBAL0: case GETGLOBAL1: case GETGLOBAL2: case GETGLOBAL3:
|
||||
case GETGLOBAL4: case GETGLOBAL5: case GETGLOBAL6: case GETGLOBAL7:
|
||||
aux -= GETGLOBAL0;
|
||||
getglobal:
|
||||
case GETGLOBALW: aux = highbyte(*pc++);
|
||||
case GETGLOBAL: aux += *pc++;
|
||||
luaV_getglobal(tsvalue(&consts[aux]));
|
||||
break;
|
||||
|
||||
@ -385,30 +356,14 @@ StkId luaV_execute (Closure *cl, TProtoFunc *tf, StkId base)
|
||||
luaV_gettable();
|
||||
break;
|
||||
|
||||
case GETDOTTEDW:
|
||||
aux = next_word(pc); goto getdotted;
|
||||
|
||||
case GETDOTTED:
|
||||
aux = *pc++; goto getdotted;
|
||||
|
||||
case GETDOTTED0: case GETDOTTED1: case GETDOTTED2: case GETDOTTED3:
|
||||
case GETDOTTED4: case GETDOTTED5: case GETDOTTED6: case GETDOTTED7:
|
||||
aux -= GETDOTTED0;
|
||||
getdotted:
|
||||
case GETDOTTEDW: aux = highbyte(*pc++);
|
||||
case GETDOTTED: aux += *pc++;
|
||||
*S->top++ = consts[aux];
|
||||
luaV_gettable();
|
||||
break;
|
||||
|
||||
case PUSHSELFW:
|
||||
aux = next_word(pc); goto pushself;
|
||||
|
||||
case PUSHSELF:
|
||||
aux = *pc++; goto pushself;
|
||||
|
||||
case PUSHSELF0: case PUSHSELF1: case PUSHSELF2: case PUSHSELF3:
|
||||
case PUSHSELF4: case PUSHSELF5: case PUSHSELF6: case PUSHSELF7:
|
||||
aux -= PUSHSELF0;
|
||||
pushself: {
|
||||
case PUSHSELFW: aux = highbyte(*pc++);
|
||||
case PUSHSELF: aux += *pc++; {
|
||||
TObject receiver = *(S->top-1);
|
||||
*S->top++ = consts[aux];
|
||||
luaV_gettable();
|
||||
@ -416,49 +371,21 @@ StkId luaV_execute (Closure *cl, TProtoFunc *tf, StkId base)
|
||||
break;
|
||||
}
|
||||
|
||||
case PUSHCONSTANTW:
|
||||
aux = next_word(pc); goto pushconstant;
|
||||
|
||||
case PUSHCONSTANT:
|
||||
aux = *pc++; goto pushconstant;
|
||||
|
||||
case PUSHCONSTANT0: case PUSHCONSTANT1: case PUSHCONSTANT2:
|
||||
case PUSHCONSTANT3: case PUSHCONSTANT4: case PUSHCONSTANT5:
|
||||
case PUSHCONSTANT6: case PUSHCONSTANT7:
|
||||
aux -= PUSHCONSTANT0;
|
||||
pushconstant:
|
||||
case PUSHCONSTANTW: aux = highbyte(*pc++);
|
||||
case PUSHCONSTANT: aux += *pc++;
|
||||
*S->top++ = consts[aux];
|
||||
break;
|
||||
|
||||
case PUSHUPVALUE:
|
||||
aux = *pc++; goto pushupvalue;
|
||||
|
||||
case PUSHUPVALUE0: case PUSHUPVALUE1:
|
||||
aux -= PUSHUPVALUE0;
|
||||
pushupvalue:
|
||||
case PUSHUPVALUE: aux = *pc++;
|
||||
*S->top++ = cl->consts[aux+1];
|
||||
break;
|
||||
|
||||
case SETLOCAL:
|
||||
aux = *pc++; goto setlocal;
|
||||
|
||||
case SETLOCAL0: case SETLOCAL1: case SETLOCAL2: case SETLOCAL3:
|
||||
case SETLOCAL4: case SETLOCAL5: case SETLOCAL6: case SETLOCAL7:
|
||||
aux -= SETLOCAL0;
|
||||
setlocal:
|
||||
case SETLOCAL: aux = *pc++;
|
||||
*((S->stack+base) + aux) = *(--S->top);
|
||||
break;
|
||||
|
||||
case SETGLOBALW:
|
||||
aux = next_word(pc); goto setglobal;
|
||||
|
||||
case SETGLOBAL:
|
||||
aux = *pc++; goto setglobal;
|
||||
|
||||
case SETGLOBAL0: case SETGLOBAL1: case SETGLOBAL2: case SETGLOBAL3:
|
||||
case SETGLOBAL4: case SETGLOBAL5: case SETGLOBAL6: case SETGLOBAL7:
|
||||
aux -= SETGLOBAL0;
|
||||
setglobal:
|
||||
case SETGLOBALW: aux = highbyte(*pc++);
|
||||
case SETGLOBAL: aux += *pc++;
|
||||
luaV_setglobal(tsvalue(&consts[aux]));
|
||||
break;
|
||||
|
||||
@ -470,28 +397,17 @@ StkId luaV_execute (Closure *cl, TProtoFunc *tf, StkId base)
|
||||
luaV_settable(S->top-3-(*pc++), 1);
|
||||
break;
|
||||
|
||||
case SETLISTW:
|
||||
aux = next_word(pc); aux *= LFIELDS_PER_FLUSH; goto setlist;
|
||||
|
||||
case SETLIST:
|
||||
aux = *(pc++) * LFIELDS_PER_FLUSH; goto setlist;
|
||||
|
||||
case SETLIST0:
|
||||
aux = 0;
|
||||
setlist: {
|
||||
case SETLISTW: aux = highbyte(*pc++);
|
||||
case SETLIST: aux += *pc++; {
|
||||
int n = *(pc++);
|
||||
TObject *arr = S->top-n-1;
|
||||
aux *= LFIELDS_PER_FLUSH;
|
||||
for (; n; n--)
|
||||
luaH_setint(avalue(arr), n+aux, --S->top);
|
||||
break;
|
||||
}
|
||||
|
||||
case SETMAP0:
|
||||
aux = 0; goto setmap;
|
||||
|
||||
case SETMAP:
|
||||
aux = *pc++;
|
||||
setmap: {
|
||||
case SETMAP: aux = *pc++; {
|
||||
TObject *arr = S->top-(2*aux)-3;
|
||||
do {
|
||||
luaH_set(avalue(arr), S->top-2, S->top-1);
|
||||
@ -500,34 +416,23 @@ StkId luaV_execute (Closure *cl, TProtoFunc *tf, StkId base)
|
||||
break;
|
||||
}
|
||||
|
||||
case POP:
|
||||
aux = *pc++; goto pop;
|
||||
|
||||
case POP0: case POP1:
|
||||
aux -= POP0;
|
||||
pop:
|
||||
case POP: aux = *pc++;
|
||||
S->top -= (aux+1);
|
||||
break;
|
||||
|
||||
case CREATEARRAYW:
|
||||
aux = next_word(pc); goto createarray;
|
||||
|
||||
case CREATEARRAY0: case CREATEARRAY1:
|
||||
aux -= CREATEARRAY0; goto createarray;
|
||||
|
||||
case CREATEARRAY:
|
||||
aux = *pc++;
|
||||
createarray:
|
||||
case CREATEARRAYW: aux = highbyte(*pc++);
|
||||
case CREATEARRAY: aux += *pc++;
|
||||
luaC_checkGC();
|
||||
avalue(S->top) = luaH_new(aux);
|
||||
ttype(S->top) = LUA_T_ARRAY;
|
||||
S->top++;
|
||||
break;
|
||||
|
||||
case EQOP: case NEQOP: {
|
||||
case NEQOP: aux = 1;
|
||||
case EQOP: {
|
||||
int res = luaO_equalObj(S->top-2, S->top-1);
|
||||
if (aux) res = !res;
|
||||
S->top--;
|
||||
if (aux == NEQOP) res = !res;
|
||||
ttype(S->top-1) = res ? LUA_T_NUMBER : LUA_T_NIL;
|
||||
nvalue(S->top-1) = 1;
|
||||
break;
|
||||
@ -630,98 +535,60 @@ StkId luaV_execute (Closure *cl, TProtoFunc *tf, StkId base)
|
||||
nvalue(S->top-1) = 1;
|
||||
break;
|
||||
|
||||
case ONTJMPW:
|
||||
aux = next_word(pc); goto ontjmp;
|
||||
|
||||
case ONTJMP:
|
||||
aux = *pc++;
|
||||
ontjmp:
|
||||
case ONTJMPW: aux = highbyte(*pc++);
|
||||
case ONTJMP: aux += *pc++;
|
||||
if (ttype(S->top-1) != LUA_T_NIL) pc += aux;
|
||||
else S->top--;
|
||||
break;
|
||||
|
||||
case ONFJMPW:
|
||||
aux = next_word(pc); goto onfjmp;
|
||||
|
||||
case ONFJMP:
|
||||
aux = *pc++;
|
||||
onfjmp:
|
||||
case ONFJMPW: aux = highbyte(*pc++);
|
||||
case ONFJMP: aux += *pc++;
|
||||
if (ttype(S->top-1) == LUA_T_NIL) pc += aux;
|
||||
else S->top--;
|
||||
break;
|
||||
|
||||
case JMPW:
|
||||
aux = next_word(pc); goto jmp;
|
||||
|
||||
case JMP:
|
||||
aux = *pc++;
|
||||
jmp:
|
||||
case JMPW: aux = highbyte(*pc++);
|
||||
case JMP: aux += *pc++;
|
||||
pc += aux;
|
||||
break;
|
||||
|
||||
case IFFJMPW:
|
||||
aux = next_word(pc); goto iffjmp;
|
||||
|
||||
case IFFJMP:
|
||||
aux = *pc++;
|
||||
iffjmp:
|
||||
case IFFJMPW: aux = highbyte(*pc++);
|
||||
case IFFJMP: aux += *pc++;
|
||||
if (ttype(--S->top) == LUA_T_NIL) pc += aux;
|
||||
break;
|
||||
|
||||
case IFTUPJMPW:
|
||||
aux = next_word(pc); goto iftupjmp;
|
||||
|
||||
case IFTUPJMP:
|
||||
aux = *pc++;
|
||||
iftupjmp:
|
||||
case IFTUPJMPW: aux = highbyte(*pc++);
|
||||
case IFTUPJMP: aux += *pc++;
|
||||
if (ttype(--S->top) != LUA_T_NIL) pc -= aux;
|
||||
break;
|
||||
|
||||
case IFFUPJMPW:
|
||||
aux = next_word(pc); goto iffupjmp;
|
||||
|
||||
case IFFUPJMP:
|
||||
aux = *pc++;
|
||||
iffupjmp:
|
||||
case IFFUPJMPW: aux = highbyte(*pc++);
|
||||
case IFFUPJMP: aux += *pc++;
|
||||
if (ttype(--S->top) == LUA_T_NIL) pc -= aux;
|
||||
break;
|
||||
|
||||
case CLOSUREW:
|
||||
aux = next_word(pc); goto closure;
|
||||
|
||||
case CLOSURE:
|
||||
aux = *pc++;
|
||||
closure:
|
||||
case CLOSURE: aux = *pc++;
|
||||
*S->top++ = consts[aux];
|
||||
luaV_closure(*pc++);
|
||||
luaC_checkGC();
|
||||
break;
|
||||
|
||||
case CALLFUNC:
|
||||
aux = *pc++; goto callfunc;
|
||||
|
||||
case CALLFUNC0: case CALLFUNC1:
|
||||
aux -= CALLFUNC0;
|
||||
callfunc: {
|
||||
case CALLFUNC: aux = *pc++; {
|
||||
StkId newBase = (S->top-S->stack)-(*pc++);
|
||||
luaD_call(newBase, aux);
|
||||
break;
|
||||
}
|
||||
|
||||
case ENDCODE:
|
||||
case ENDCODE: aux = 1;
|
||||
S->top = S->stack + base;
|
||||
/* goes through */
|
||||
case RETCODE:
|
||||
if (lua_callhook)
|
||||
luaD_callHook(base, NULL, 1);
|
||||
return (base + ((aux==RETCODE) ? *pc : 0));
|
||||
return base + (aux ? 0 : *pc);
|
||||
|
||||
case SETLINEW:
|
||||
aux = next_word(pc); goto setline;
|
||||
|
||||
case SETLINE:
|
||||
aux = *pc++;
|
||||
setline:
|
||||
case SETLINEW: aux = highbyte(*pc++);
|
||||
case SETLINE: aux += *pc++;
|
||||
if ((S->stack+base-1)->ttype != LUA_T_LINE) {
|
||||
/* open space for LINE value */
|
||||
luaD_openstack((S->top-S->stack)-base);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user