mirror of https://github.com/rusefi/lua.git
more uniform treatment to opcode variants.
This commit is contained in:
Roberto Ierusalimschy
parent
2bb94d9e22
commit
7c261a13b5
113
lopcodes.h
113
lopcodes.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lopcodes.h,v 1.6 1997/10/01 20:05:34 roberto Exp roberto $
|
||||
** $Id: lopcodes.h,v 1.7 1997/10/06 14:51:11 roberto Exp roberto $
|
||||
** Opcodes for Lua virtual machine
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -9,9 +9,9 @@
|
|||
|
||||
|
||||
/*
|
||||
** NOTICE: variants of the same opcode (like PUSH0, PUSHBYTE, PUSHWORD) must
|
||||
** be consecutive: First, those with built-in parameters, then with byte
|
||||
** parameter and last with word parameter.
|
||||
** NOTICE: variants of the same opcode must be consecutive: First, those
|
||||
** with byte parameter, then with built-in parameters, and last with
|
||||
** word parameter.
|
||||
*/
|
||||
|
||||
|
||||
|
|
@ -20,15 +20,16 @@ typedef enum {
|
|||
-----------------------------------------------------------------------------*/
|
||||
ENDCODE,/* - - - */
|
||||
|
||||
PUSHNIL,/* - - nil */
|
||||
PUSHNILS,/* b - nil_1...nil_b */
|
||||
PUSHNIL,/* b - nil_0...nil_b */
|
||||
PUSHNIL0,/* - - nil */
|
||||
|
||||
PUSH0,/* - - 0.0 */
|
||||
PUSH1,/* - - 1.0 */
|
||||
PUSH2,/* - - 2.0 */
|
||||
PUSHBYTE,/* b - (float)b */
|
||||
PUSHWORD,/* w - (float)w */
|
||||
PUSHNUMBER,/* b - (float)b */
|
||||
PUSHNUMBER0,/* - - 0.0 */
|
||||
PUSHNUMBER1,/* - - 1.0 */
|
||||
PUSHNUMBER2,/* - - 2.0 */
|
||||
PUSHNUMBERW,/* w - (float)w */
|
||||
|
||||
PUSHCONSTANT,/* b - CNST[b] */
|
||||
PUSHCONSTANT0,/*- - CNST[0] */
|
||||
PUSHCONSTANT1,/*- - CNST[1] */
|
||||
PUSHCONSTANT2,/*- - CNST[2] */
|
||||
|
|
@ -37,15 +38,13 @@ PUSHCONSTANT4,/*- - CNST[4] */
|
|||
PUSHCONSTANT5,/*- - CNST[5] */
|
||||
PUSHCONSTANT6,/*- - CNST[6] */
|
||||
PUSHCONSTANT7,/*- - CNST[7] */
|
||||
PUSHCONSTANT8,/*- - CNST[8] */
|
||||
PUSHCONSTANT9,/*- - CNST[9] */
|
||||
PUSHCONSTANTB,/*b - CNST[b] */
|
||||
PUSHCONSTANT,/* w - CNST[w] */
|
||||
PUSHCONSTANTW,/*w - CNST[w] */
|
||||
|
||||
PUSHUPVALUE,/* b - Closure[b] */
|
||||
PUSHUPVALUE0,/* - - Closure[0] */
|
||||
PUSHUPVALUE1,/* - - Closure[1] */
|
||||
PUSHUPVALUE,/* b - Closure[b] */
|
||||
|
||||
PUSHLOCAL,/* b - LOC[b] */
|
||||
PUSHLOCAL0,/* - - LOC[0] */
|
||||
PUSHLOCAL1,/* - - LOC[1] */
|
||||
PUSHLOCAL2,/* - - LOC[2] */
|
||||
|
|
@ -54,10 +53,8 @@ PUSHLOCAL4,/* - - LOC[4] */
|
|||
PUSHLOCAL5,/* - - LOC[5] */
|
||||
PUSHLOCAL6,/* - - LOC[6] */
|
||||
PUSHLOCAL7,/* - - LOC[7] */
|
||||
PUSHLOCAL8,/* - - LOC[8] */
|
||||
PUSHLOCAL9,/* - - LOC[9] */
|
||||
PUSHLOCAL,/* b - LOC[b] */
|
||||
|
||||
GETGLOBAL,/* b - VAR[CNST[b]] */
|
||||
GETGLOBAL0,/* - - VAR[CNST[0]] */
|
||||
GETGLOBAL1,/* - - VAR[CNST[1]] */
|
||||
GETGLOBAL2,/* - - VAR[CNST[2]] */
|
||||
|
|
@ -66,19 +63,19 @@ GETGLOBAL4,/* - - VAR[CNST[4]] */
|
|||
GETGLOBAL5,/* - - VAR[CNST[5]] */
|
||||
GETGLOBAL6,/* - - VAR[CNST[6]] */
|
||||
GETGLOBAL7,/* - - VAR[CNST[7]] */
|
||||
GETGLOBAL8,/* - - VAR[CNST[8]] */
|
||||
GETGLOBAL9,/* - - VAR[CNST[9]] */
|
||||
GETGLOBALB,/* b - VAR[CNST[b]] */
|
||||
GETGLOBAL,/* w - VAR[CNST[w]] */
|
||||
GETGLOBALW,/* w - VAR[CNST[w]] */
|
||||
|
||||
GETTABLE,/* - i t t[i] */
|
||||
|
||||
PUSHSELFB,/* b t t t[CNST[b]] */
|
||||
PUSHSELF,/* w t t t[CNST[w]] */
|
||||
PUSHSELF,/* b t t t[CNST[b]] */
|
||||
PUSHSELFW,/* w t t t[CNST[w]] */
|
||||
|
||||
CREATEARRAYB,/* b - newarray(size = b) */
|
||||
CREATEARRAY,/* w - newarray(size = 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 */
|
||||
|
|
@ -87,19 +84,28 @@ SETLOCAL4,/* - x - LOC[4]=x */
|
|||
SETLOCAL5,/* - x - LOC[5]=x */
|
||||
SETLOCAL6,/* - x - LOC[6]=x */
|
||||
SETLOCAL7,/* - x - LOC[7]=x */
|
||||
SETLOCAL8,/* - x - LOC[8]=x */
|
||||
SETLOCAL9,/* - x - LOC[9]=x */
|
||||
SETLOCAL,/* b x - LOC[b]=x */
|
||||
|
||||
SETGLOBALB,/* b x - VAR[CNST[b]]=x */
|
||||
SETGLOBAL,/* w x - VAR[CNST[w]]=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 */
|
||||
|
||||
SETTABLE,/* b v a_b...a_1 i t a_b...a_1 i t t[i]=v */
|
||||
|
||||
SETLIST0,/* b v_b...v_1 t - t[i]=v_i */
|
||||
SETLIST,/* b c v_b...v_1 t - t[i+c*FPF]=v_i */
|
||||
SETMAP,/* b v_b k_b ...v_1 k_1 t t t[k_i]=v_i */
|
||||
SETLIST0,/* b v_b...v_1 t - t[i]=v_i */
|
||||
SETLISTW,/* w c v_b...v_1 t - t[i+c*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 */
|
||||
|
|
@ -117,25 +123,34 @@ MINUSOP,/* - x -x */
|
|||
NOTOP,/* - x (x==nil)? 1 : nil */
|
||||
|
||||
ONTJMP,/* b x (x!=nil)? x : - (x!=nil)? PC+=b */
|
||||
ONTJMPW,/* w x (x!=nil)? x : - (x!=nil)? PC+=w */
|
||||
ONFJMP,/* b x (x==nil)? x : - (x==nil)? PC+=b */
|
||||
JMPB,/* b - - PC+=b */
|
||||
JMP,/* w - - PC+=w */
|
||||
IFFJMPB,/* b x - (x==nil)? PC+=b */
|
||||
IFFJMP,/* w x - (x==nil)? PC+=w */
|
||||
IFTUPJMPB,/* b x - (x!=nil)? PC-=b */
|
||||
IFTUPJMP,/* w x - (x!=nil)? PC-=w */
|
||||
IFFUPJMPB,/* b x - (x==nil)? PC-=b */
|
||||
IFFUPJMP,/* w x - (x==nil)? PC-=w */
|
||||
ONFJMPW,/* w x (x==nil)? x : - (x==nil)? PC+=w */
|
||||
JMP,/* b - - PC+=b */
|
||||
JMPW,/* w - - PC+=w */
|
||||
IFFJMP,/* b x - (x==nil)? PC+=b */
|
||||
IFFJMPW,/* w x - (x==nil)? PC+=w */
|
||||
IFTUPJMP,/* b x - (x!=nil)? PC-=b */
|
||||
IFTUPJMPW,/* w x - (x!=nil)? PC-=w */
|
||||
IFFUPJMP,/* b x - (x==nil)? PC-=b */
|
||||
IFFUPJMPW,/* w x - (x==nil)? PC-=w */
|
||||
|
||||
CLOSUREB,/* b v_1...v_n c(CNST[b]) */
|
||||
CLOSURE,/* w v_1...v_n c(CNST[w]) */
|
||||
CLOSURE,/* b v_1...v_n c(CNST[b]) */
|
||||
CLOSUREW,/* w v_1...v_n c(CNST[w]) */
|
||||
|
||||
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) */
|
||||
|
||||
CALLFUNC,/* b c v_b...v_1 f r_c...r_1 f(v1,...,v_b) */
|
||||
RETCODE,/* b - - */
|
||||
SETLINE,/* w - - LINE=w */
|
||||
POP1,/* - - - TOP-=1 */
|
||||
POP2,/* - - - TOP-=2 */
|
||||
POPS,/* b - - TOP-=b */
|
||||
|
||||
SETLINE,/* b - - LINE=b */
|
||||
SETLINEW,/* w - - LINE=w */
|
||||
|
||||
POP,/* b - - TOP-=(b+1) */
|
||||
POP0,/* - - - TOP-=1 */
|
||||
POP1,/* - - - TOP-=2 */
|
||||
|
||||
ARGS,/* b - - TOP=BASE+b */
|
||||
VARARGS/* b v_x...v_1 {v_1...v_x;n=x} TOP=BASE+b+1 */
|
||||
} OpCode;
|
||||
|
|
|
|||
226
lua.stx
226
lua.stx
|
|
@ -1,6 +1,6 @@
|
|||
%{
|
||||
/*
|
||||
** $Id: lua.stx,v 1.7 1997/10/01 20:05:34 roberto Exp roberto $
|
||||
** $Id: lua.stx,v 1.8 1997/10/06 14:51:11 roberto Exp roberto $
|
||||
** Syntax analizer and code generator
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -23,9 +23,6 @@
|
|||
|
||||
/* to avoid warnings generated by yacc */
|
||||
int luaY_parse (void);
|
||||
#define malloc luaM_malloc
|
||||
#define realloc luaM_realloc
|
||||
#define free luaM_free
|
||||
|
||||
|
||||
/* size of a "normal" jump instruction: OpCode + 1 byte */
|
||||
|
|
@ -118,23 +115,6 @@ static void code_byte (Byte c)
|
|||
}
|
||||
|
||||
|
||||
static void code_word_at (int pc, int n)
|
||||
{
|
||||
if (n > MAX_WORD)
|
||||
luaY_error("construction too big; unable to compile");
|
||||
currState->f->code[pc] = n&0xFF;
|
||||
currState->f->code[pc+1] = n>>8;
|
||||
}
|
||||
|
||||
|
||||
static void code_word (int n)
|
||||
{
|
||||
check_pc(2);
|
||||
currState->pc += 2;
|
||||
code_word_at(currState->pc-2, n);
|
||||
}
|
||||
|
||||
|
||||
static void deltastack (int delta)
|
||||
{
|
||||
currState->stacksize += delta;
|
||||
|
|
@ -146,41 +126,55 @@ static void deltastack (int delta)
|
|||
}
|
||||
|
||||
|
||||
static int code_oparg_at (int pc, OpCode op, int builtin, int arg, int delta)
|
||||
{
|
||||
deltastack(delta);
|
||||
if (arg < builtin) {
|
||||
currState->f->code[pc] = op+1+arg;
|
||||
return 1;
|
||||
}
|
||||
else if (arg <= 255) {
|
||||
currState->f->code[pc] = op;
|
||||
currState->f->code[pc+1] = arg;
|
||||
return 2;
|
||||
}
|
||||
else if (arg <= MAX_WORD) {
|
||||
currState->f->code[pc] = op+1+builtin;
|
||||
currState->f->code[pc+1] = arg&0xFF;
|
||||
currState->f->code[pc+2] = arg>>8;
|
||||
return 3;
|
||||
}
|
||||
else luaY_error("construction too big - unable to compile");
|
||||
return 0; /* to avoid warnings */
|
||||
}
|
||||
|
||||
|
||||
static int fix_opcode (int pc, OpCode op, int builtin, int arg)
|
||||
{
|
||||
if (arg < builtin) { /* close space */
|
||||
movecode_down(pc+1, pc+2, currState->pc-(pc+2));
|
||||
currState->pc--;
|
||||
}
|
||||
else if (arg > 255) { /* open space */
|
||||
check_pc(1);
|
||||
movecode_up(pc+1, pc, currState->pc-pc);
|
||||
currState->pc++;
|
||||
}
|
||||
return code_oparg_at(pc, op, builtin, arg, 0) - 2;
|
||||
}
|
||||
|
||||
|
||||
static void code_oparg (OpCode op, int builtin, int arg, int delta)
|
||||
{
|
||||
check_pc(3); /* maximum code size */
|
||||
currState->pc += code_oparg_at(currState->pc, op, builtin, arg, delta);
|
||||
}
|
||||
|
||||
|
||||
static void code_opcode (OpCode op, int delta)
|
||||
{
|
||||
code_byte(op);
|
||||
deltastack(delta);
|
||||
}
|
||||
|
||||
|
||||
static void code_opb (OpCode opbyte, int arg, int delta)
|
||||
{
|
||||
code_opcode(opbyte, delta);
|
||||
code_byte(arg);
|
||||
}
|
||||
|
||||
static void code_opw (OpCode opbyte, int arg, int delta)
|
||||
{
|
||||
code_opcode(opbyte, delta);
|
||||
code_word(arg);
|
||||
}
|
||||
|
||||
|
||||
static void code_opborw (OpCode opbyte, int arg, int delta)
|
||||
{
|
||||
if (arg <= 255)
|
||||
code_opb(opbyte, arg, delta);
|
||||
else
|
||||
code_opw(opbyte+1, arg, delta);
|
||||
}
|
||||
|
||||
|
||||
static void code_oparg (OpCode firstop, OpCode opbyte, int arg, int delta)
|
||||
{
|
||||
if (firstop+arg < opbyte)
|
||||
code_opcode(firstop+arg, delta);
|
||||
else
|
||||
code_opborw(opbyte, arg, delta);
|
||||
code_byte(op);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -193,7 +187,10 @@ static void code_pop (OpCode op)
|
|||
#define code_binop(op) code_pop(op)
|
||||
|
||||
|
||||
#define code_neutralop(op) code_byte(op)
|
||||
static void code_neutralop (OpCode op)
|
||||
{
|
||||
code_opcode(op, 0);
|
||||
}
|
||||
|
||||
/* unary operations get 1 argument and leave one, so they are neutral */
|
||||
#define code_unop(op) code_neutralop(op)
|
||||
|
|
@ -201,7 +198,7 @@ static void code_pop (OpCode op)
|
|||
|
||||
static void code_constant (int c)
|
||||
{
|
||||
code_oparg(PUSHCONSTANT0, PUSHCONSTANTB, c, 1);
|
||||
code_oparg(PUSHCONSTANT, 8, c, 1);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -237,7 +234,7 @@ static void code_string (TaggedString *s)
|
|||
}
|
||||
|
||||
|
||||
#define LIM 13
|
||||
#define LIM 20
|
||||
static int real_constant (real r)
|
||||
{
|
||||
/* check whether 'r' has appeared within the last LIM entries */
|
||||
|
|
@ -261,7 +258,7 @@ static void code_number (real f)
|
|||
{
|
||||
Word i;
|
||||
if (f >= 0 && f <= (real)MAX_WORD && (real)(i=(Word)f) == f)
|
||||
code_oparg(PUSH0, PUSHBYTE, i, 1); /* f has an (short) integer value */
|
||||
code_oparg(PUSHNUMBER, 3, i, 1); /* f has an (short) integer value */
|
||||
else
|
||||
code_constant(real_constant(f));
|
||||
}
|
||||
|
|
@ -270,18 +267,13 @@ static void code_number (real f)
|
|||
static void flush_record (int n)
|
||||
{
|
||||
if (n > 0)
|
||||
code_opb(SETMAP, n, -2*n);
|
||||
code_oparg(SETMAP, 1, n-1, -2*n);
|
||||
}
|
||||
|
||||
static void flush_list (int m, int n)
|
||||
{
|
||||
if (n == 0) return;
|
||||
if (m == 0)
|
||||
code_opcode(SETLIST0, -n);
|
||||
else if (m < 255)
|
||||
code_opb(SETLIST, m, -n);
|
||||
else
|
||||
luaY_error("list constructor too long");
|
||||
code_oparg(SETLIST, 1, m, -n);
|
||||
code_byte(n);
|
||||
}
|
||||
|
||||
|
|
@ -375,7 +367,7 @@ static void pushupvalue (TaggedString *n)
|
|||
if (aux_localname(n, currState) >= 0)
|
||||
luaY_syntaxerror("cannot access an upvalue in current scope", n->str);
|
||||
i = indexupvalue(n);
|
||||
code_oparg(PUSHUPVALUE0, PUSHUPVALUE, i, 1);
|
||||
code_oparg(PUSHUPVALUE, 2, i, 1);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -383,7 +375,7 @@ void luaY_codedebugline (int line)
|
|||
{
|
||||
static int lastline = 0;
|
||||
if (lua_debug && line != lastline) {
|
||||
code_opw(SETLINE, line, 0);
|
||||
code_oparg(SETLINE, 0, line, 0);
|
||||
lastline = line;
|
||||
}
|
||||
}
|
||||
|
|
@ -392,22 +384,25 @@ void luaY_codedebugline (int line)
|
|||
static void adjuststack (int n)
|
||||
{
|
||||
if (n > 0)
|
||||
code_oparg(POP1-1, POPS, n, -n); /* POP1-1 = POP0 */
|
||||
code_oparg(POP, 2, n-1, -n);
|
||||
else if (n < 0)
|
||||
code_oparg(PUSHNIL-1, PUSHNILS, -n, -n); /* PUSHNIL1-1 = PUSHNIL0 */
|
||||
code_oparg(PUSHNIL, 1, (-n)-1, -n);
|
||||
}
|
||||
|
||||
|
||||
static long adjust_functioncall (long exp, int i)
|
||||
static long adjust_functioncall (long exp, int nresults)
|
||||
{
|
||||
if (exp <= 0)
|
||||
return -exp; /* exp is -list length */
|
||||
else {
|
||||
int temp = currState->f->code[exp];
|
||||
currState->f->code[exp] = i;
|
||||
if (i != MULT_RET)
|
||||
deltastack(i);
|
||||
return temp+i;
|
||||
int nparams = currState->f->code[exp-1];
|
||||
exp += fix_opcode(exp-2, CALLFUNC, 2, nresults);
|
||||
currState->f->code[exp] = nparams;
|
||||
if (nresults != MULT_RET)
|
||||
deltastack(nresults);
|
||||
deltastack(-(nparams+1));
|
||||
return temp+nresults;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -430,9 +425,9 @@ static void adjust_mult_assign (int vars, long exps)
|
|||
static void code_args (int dots)
|
||||
{
|
||||
if (!dots)
|
||||
code_opb(ARGS, currState->nlocalvar, currState->nlocalvar);
|
||||
code_oparg(ARGS, 0, currState->nlocalvar, currState->nlocalvar);
|
||||
else {
|
||||
code_opb(VARARGS, currState->nlocalvar, currState->nlocalvar+1);
|
||||
code_oparg(VARARGS, 0, currState->nlocalvar, currState->nlocalvar+1);
|
||||
add_localvar(luaS_new("arg"));
|
||||
}
|
||||
}
|
||||
|
|
@ -441,9 +436,9 @@ static void code_args (int dots)
|
|||
static void lua_pushvar (vardesc number)
|
||||
{
|
||||
if (number > 0) /* global var */
|
||||
code_oparg(GETGLOBAL0, GETGLOBALB, number-1, 1);
|
||||
code_oparg(GETGLOBAL, 8, number-1, 1);
|
||||
else if (number < 0) /* local var */
|
||||
code_oparg(PUSHLOCAL0, PUSHLOCAL, (-number)-1, 1);
|
||||
code_oparg(PUSHLOCAL, 8, (-number)-1, 1);
|
||||
else
|
||||
code_pop(GETTABLE);
|
||||
}
|
||||
|
|
@ -454,9 +449,9 @@ static void storevar (vardesc number)
|
|||
if (number == 0) /* indexed var */
|
||||
code_opcode(SETTABLE0, -3);
|
||||
else if (number > 0) /* global var */
|
||||
code_opborw(SETGLOBALB, number-1, -1);
|
||||
code_oparg(SETGLOBAL, 8, number-1, -1);
|
||||
else /* number < 0 - local var */
|
||||
code_oparg(SETLOCAL0, SETLOCAL, (-number)-1, -1);
|
||||
code_oparg(SETLOCAL, 8, (-number)-1, -1);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -469,35 +464,16 @@ static int lua_codestore (int i, int left)
|
|||
return left;
|
||||
}
|
||||
else { /* indexed var with values in between*/
|
||||
code_pop(SETTABLE);
|
||||
code_byte(left+i); /* number of elements between table/index and value */
|
||||
code_oparg(SETTABLE, 0, left+i, -1);
|
||||
return left+2; /* table/index are not poped, since they are not on top */
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int fix_opcode (int pc, OpCode op, int n)
|
||||
{
|
||||
if (n <= 255) {
|
||||
currState->f->code[pc] = op;
|
||||
currState->f->code[pc+1] = n;
|
||||
return 0;
|
||||
}
|
||||
else {
|
||||
check_pc(1); /* open space */
|
||||
movecode_up(pc+1, pc, currState->pc-pc);
|
||||
currState->pc++;
|
||||
currState->f->code[pc] = op+1; /* opcode must be word variant */
|
||||
code_word_at(pc+1, n);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static int fix_jump (int pc, OpCode op, int n)
|
||||
{
|
||||
/* jump is relative to position following jump instruction */
|
||||
return fix_opcode(pc, op, n-(pc+JMPSIZE));
|
||||
return fix_opcode(pc, op, 0, n-(pc+JMPSIZE));
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -505,7 +481,7 @@ static void fix_upjmp (OpCode op, int pos)
|
|||
{
|
||||
int delta = currState->pc+JMPSIZE - pos; /* jump is relative */
|
||||
if (delta > 255) delta++;
|
||||
code_opborw(op, delta, 0);
|
||||
code_oparg(op, 0, delta, 0);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -517,25 +493,20 @@ static void codeIf (int thenAdd, int elseAdd)
|
|||
elseinit = currState->pc;
|
||||
}
|
||||
else
|
||||
elseinit += fix_jump(elseAdd, JMPB, currState->pc);
|
||||
fix_jump(thenAdd, IFFJMPB, elseinit);
|
||||
elseinit += fix_jump(elseAdd, JMP, currState->pc);
|
||||
fix_jump(thenAdd, IFFJMP, elseinit);
|
||||
}
|
||||
|
||||
|
||||
static void code_shortcircuit (OpCode op, int pos)
|
||||
static void code_shortcircuit (int pc, OpCode op)
|
||||
{
|
||||
int dist = currState->pc - (pos+JMPSIZE);
|
||||
if (dist > 255)
|
||||
luaY_error("and/or expression too long");
|
||||
currState->f->code[pos] = op;
|
||||
currState->f->code[pos+1] = dist;
|
||||
fix_jump(pc, op, currState->pc);
|
||||
}
|
||||
|
||||
|
||||
static void codereturn (void)
|
||||
{
|
||||
code_neutralop(RETCODE);
|
||||
code_byte(currState->nlocalvar);
|
||||
code_oparg(RETCODE, 0, currState->nlocalvar, 0);
|
||||
currState->stacksize = currState->nlocalvar;
|
||||
}
|
||||
|
||||
|
|
@ -549,7 +520,7 @@ static void func_onstack (TProtoFunc *f)
|
|||
currState->f->consts[c].value.tf = (currState+1)->f;
|
||||
for (i=0; i<nupvalues; i++)
|
||||
lua_pushvar((currState+1)->upvalues[i]);
|
||||
code_opborw(CLOSUREB, c, 1-nupvalues);
|
||||
code_oparg(CLOSURE, 0, c, 1-nupvalues);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -585,7 +556,6 @@ static void init_func (void)
|
|||
currState->f->lineDefined = luaX_linenumber;
|
||||
}
|
||||
|
||||
|
||||
static TProtoFunc *close_func (void)
|
||||
{
|
||||
TProtoFunc *f = currState->f;
|
||||
|
|
@ -687,13 +657,13 @@ stat : IF cond THEN block SaveWord elsepart END
|
|||
memcpy(&currState->f->code[currState->pc],
|
||||
&currState->f->code[$2], expsize);
|
||||
movecode_down($2, $3, currState->pc-$2);
|
||||
newpos += fix_jump($2, JMPB, currState->pc-expsize);
|
||||
fix_upjmp(IFTUPJMPB, newpos);
|
||||
newpos += fix_jump($2, JMP, currState->pc-expsize);
|
||||
fix_upjmp(IFTUPJMP, newpos);
|
||||
}}
|
||||
|
||||
| REPEAT GetPC block UNTIL expr1
|
||||
{
|
||||
fix_upjmp(IFFUPJMPB, $2);
|
||||
fix_upjmp(IFFUPJMP, $2);
|
||||
deltastack(-1); /* pops condition */
|
||||
}
|
||||
|
||||
|
|
@ -706,7 +676,7 @@ stat : IF cond THEN block SaveWord elsepart END
|
|||
left = lua_codestore(i, left);
|
||||
adjuststack(left); /* remove eventual 'garbage' left on stack */
|
||||
}}
|
||||
| functioncall
|
||||
| functioncall { adjust_functioncall($1, 0); }
|
||||
| LOCAL localdeclist decinit
|
||||
{
|
||||
currState->nlocalvar += $2;
|
||||
|
|
@ -757,7 +727,11 @@ ret : /* empty */
|
|||
GetPC : /* empty */ { $$ = currState->pc; }
|
||||
;
|
||||
|
||||
SaveWord : GetPC { $$ = $1; code_word(0); /* open space */ }
|
||||
SaveWord : /* empty */
|
||||
{ $$ = currState->pc;
|
||||
check_pc(JMPSIZE);
|
||||
currState->pc += JMPSIZE; /* open space */
|
||||
}
|
||||
;
|
||||
|
||||
SaveWordPop : SaveWord { $$ = $1; deltastack(-1); /* pop condition */ }
|
||||
|
|
@ -791,29 +765,29 @@ expr : '(' expr ')' { $$ = $2; }
|
|||
| varexp { $$ = 0;}
|
||||
| NUMBER { code_number($1); $$ = 0; }
|
||||
| STRING { code_string($1); $$ = 0; }
|
||||
| NIL {code_opcode(PUSHNIL, 1); $$ = 0; }
|
||||
| NIL { adjuststack(-1); $$ = 0; }
|
||||
| functioncall { $$ = $1; }
|
||||
| FUNCTION { init_func(); } body { func_onstack($3); $$ = 0; }
|
||||
| expr1 AND SaveWordPop expr1 { code_shortcircuit(ONFJMP, $3); $$ = 0; }
|
||||
| expr1 OR SaveWordPop expr1 { code_shortcircuit(ONTJMP, $3); $$ = 0; }
|
||||
| expr1 AND SaveWordPop expr1 { code_shortcircuit($3, ONFJMP); $$ = 0; }
|
||||
| expr1 OR SaveWordPop expr1 { code_shortcircuit($3, ONTJMP); $$ = 0; }
|
||||
;
|
||||
|
||||
table : '{' SaveWordPush fieldlist '}' { fix_opcode($2, CREATEARRAYB, $3); }
|
||||
table : '{' SaveWordPush fieldlist '}' { fix_opcode($2, CREATEARRAY, 2, $3); }
|
||||
;
|
||||
|
||||
functioncall : funcvalue funcParams
|
||||
{
|
||||
code_opcode(CALLFUNC, -($1+$2+1)); /* ajdust counts results */
|
||||
code_byte($1+$2);
|
||||
code_byte(0); /* save space for opcode */
|
||||
code_byte($1+$2); /* number of parameters */
|
||||
$$ = currState->pc;
|
||||
code_byte(0); /* may be adjusted by other rules */
|
||||
code_byte(0); /* must be adjusted by other rules */
|
||||
}
|
||||
;
|
||||
|
||||
funcvalue : varexp { $$ = 0; }
|
||||
| varexp ':' NAME
|
||||
{
|
||||
code_opborw(PUSHSELFB, string_constant($3, currState), 1);
|
||||
code_oparg(PUSHSELF, 0, string_constant($3, currState), 1);
|
||||
$$ = 1;
|
||||
}
|
||||
;
|
||||
|
|
|
|||
149
lvm.c
149
lvm.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lvm.c,v 1.7 1997/10/01 20:05:34 roberto Exp roberto $
|
||||
** $Id: lvm.c,v 1.8 1997/10/06 14:51:11 roberto Exp roberto $
|
||||
** Lua virtual machine
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -284,25 +284,25 @@ StkId luaV_execute (Closure *cl, StkId base)
|
|||
int aux;
|
||||
switch ((OpCode)(aux = *pc++)) {
|
||||
|
||||
case PUSHNIL0:
|
||||
ttype(luaD_stack.top++) = LUA_T_NIL;
|
||||
break;
|
||||
|
||||
case PUSHNIL:
|
||||
aux = *pc++;
|
||||
do {
|
||||
ttype(luaD_stack.top++) = LUA_T_NIL;
|
||||
} while (aux--);
|
||||
break;
|
||||
|
||||
case PUSHNILS: {
|
||||
int n = *pc++;
|
||||
while (n--)
|
||||
ttype(luaD_stack.top++) = LUA_T_NIL;
|
||||
break;
|
||||
}
|
||||
|
||||
case PUSHBYTE:
|
||||
case PUSHNUMBER:
|
||||
aux = *pc++; goto pushnumber;
|
||||
|
||||
case PUSHWORD:
|
||||
case PUSHNUMBERW:
|
||||
aux = next_word(pc); goto pushnumber;
|
||||
|
||||
case PUSH0: case PUSH1: case PUSH2:
|
||||
aux -= PUSH0;
|
||||
case PUSHNUMBER0: case PUSHNUMBER1: case PUSHNUMBER2:
|
||||
aux -= PUSHNUMBER0;
|
||||
pushnumber:
|
||||
ttype(luaD_stack.top) = LUA_T_NUMBER;
|
||||
nvalue(luaD_stack.top) = aux;
|
||||
|
|
@ -312,25 +312,21 @@ StkId luaV_execute (Closure *cl, StkId base)
|
|||
case PUSHLOCAL:
|
||||
aux = *pc++; goto pushlocal;
|
||||
|
||||
case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2:
|
||||
case PUSHLOCAL3: case PUSHLOCAL4: case PUSHLOCAL5:
|
||||
case PUSHLOCAL6: case PUSHLOCAL7: case PUSHLOCAL8:
|
||||
case PUSHLOCAL9:
|
||||
case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2: case PUSHLOCAL3:
|
||||
case PUSHLOCAL4: case PUSHLOCAL5: case PUSHLOCAL6: case PUSHLOCAL7:
|
||||
aux -= PUSHLOCAL0;
|
||||
pushlocal:
|
||||
*luaD_stack.top++ = *((luaD_stack.stack+base) + aux);
|
||||
break;
|
||||
|
||||
case GETGLOBAL:
|
||||
case GETGLOBALW:
|
||||
aux = next_word(pc); goto getglobal;
|
||||
|
||||
case GETGLOBALB:
|
||||
case GETGLOBAL:
|
||||
aux = *pc++; goto getglobal;
|
||||
|
||||
case GETGLOBAL0: case GETGLOBAL1: case GETGLOBAL2:
|
||||
case GETGLOBAL3: case GETGLOBAL4: case GETGLOBAL5:
|
||||
case GETGLOBAL6: case GETGLOBAL7: case GETGLOBAL8:
|
||||
case GETGLOBAL9:
|
||||
case GETGLOBAL0: case GETGLOBAL1: case GETGLOBAL2: case GETGLOBAL3:
|
||||
case GETGLOBAL4: case GETGLOBAL5: case GETGLOBAL6: case GETGLOBAL7:
|
||||
aux -= GETGLOBAL0;
|
||||
getglobal:
|
||||
luaV_getglobal(tsvalue(&consts[aux]));
|
||||
|
|
@ -340,10 +336,10 @@ StkId luaV_execute (Closure *cl, StkId base)
|
|||
luaV_gettable();
|
||||
break;
|
||||
|
||||
case PUSHSELF:
|
||||
case PUSHSELFW:
|
||||
aux = next_word(pc); goto pushself;
|
||||
|
||||
case PUSHSELFB:
|
||||
case PUSHSELF:
|
||||
aux = *pc++;
|
||||
pushself: {
|
||||
TObject receiver = *(luaD_stack.top-1);
|
||||
|
|
@ -353,16 +349,15 @@ StkId luaV_execute (Closure *cl, StkId base)
|
|||
break;
|
||||
}
|
||||
|
||||
case PUSHCONSTANT:
|
||||
case PUSHCONSTANTW:
|
||||
aux = next_word(pc); goto pushconstant;
|
||||
|
||||
case PUSHCONSTANTB:
|
||||
case PUSHCONSTANT:
|
||||
aux = *pc++; goto pushconstant;
|
||||
|
||||
case PUSHCONSTANT0: case PUSHCONSTANT1: case PUSHCONSTANT2:
|
||||
case PUSHCONSTANT3: case PUSHCONSTANT4: case PUSHCONSTANT5:
|
||||
case PUSHCONSTANT6: case PUSHCONSTANT7: case PUSHCONSTANT8:
|
||||
case PUSHCONSTANT9:
|
||||
case PUSHCONSTANT6: case PUSHCONSTANT7:
|
||||
aux -= PUSHCONSTANT0;
|
||||
pushconstant:
|
||||
*luaD_stack.top++ = consts[aux];
|
||||
|
|
@ -380,20 +375,22 @@ StkId luaV_execute (Closure *cl, StkId base)
|
|||
case SETLOCAL:
|
||||
aux = *pc++; goto setlocal;
|
||||
|
||||
case SETLOCAL0: case SETLOCAL1: case SETLOCAL2:
|
||||
case SETLOCAL3: case SETLOCAL4: case SETLOCAL5:
|
||||
case SETLOCAL6: case SETLOCAL7: case SETLOCAL8:
|
||||
case SETLOCAL9:
|
||||
case SETLOCAL0: case SETLOCAL1: case SETLOCAL2: case SETLOCAL3:
|
||||
case SETLOCAL4: case SETLOCAL5: case SETLOCAL6: case SETLOCAL7:
|
||||
aux -= SETLOCAL0;
|
||||
setlocal:
|
||||
*((luaD_stack.stack+base) + aux) = *(--luaD_stack.top);
|
||||
break;
|
||||
|
||||
case SETGLOBAL:
|
||||
case SETGLOBALW:
|
||||
aux = next_word(pc); goto setglobal;
|
||||
|
||||
case SETGLOBALB:
|
||||
aux = *pc++;
|
||||
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:
|
||||
luaV_setglobal(tsvalue(&consts[aux]));
|
||||
break;
|
||||
|
|
@ -406,6 +403,9 @@ StkId luaV_execute (Closure *cl, StkId base)
|
|||
luaV_settable(luaD_stack.top-3-(*pc++), 2);
|
||||
break;
|
||||
|
||||
case SETLISTW:
|
||||
aux = next_word(pc); aux *= LFIELDS_PER_FLUSH; goto setlist;
|
||||
|
||||
case SETLIST:
|
||||
aux = *(pc++) * LFIELDS_PER_FLUSH; goto setlist;
|
||||
|
||||
|
|
@ -423,23 +423,27 @@ StkId luaV_execute (Closure *cl, StkId base)
|
|||
break;
|
||||
}
|
||||
|
||||
case SETMAP: {
|
||||
int n = *(pc++);
|
||||
TObject *arr = luaD_stack.top-(2*n)-1;
|
||||
while (n--) {
|
||||
case SETMAP0:
|
||||
aux = 0; goto setmap;
|
||||
|
||||
case SETMAP:
|
||||
aux = *(pc++);
|
||||
setmap: {
|
||||
TObject *arr = luaD_stack.top-(2*aux)-3;
|
||||
do {
|
||||
*(luaH_set (avalue(arr), luaD_stack.top-2)) = *(luaD_stack.top-1);
|
||||
luaD_stack.top-=2;
|
||||
}
|
||||
} while (aux--);
|
||||
break;
|
||||
}
|
||||
|
||||
case POPS:
|
||||
case POP:
|
||||
aux = *pc++; goto pop;
|
||||
|
||||
case POP1: case POP2:
|
||||
aux -= (POP1-1);
|
||||
case POP0: case POP1:
|
||||
aux -= POP0;
|
||||
pop:
|
||||
luaD_stack.top -= aux;
|
||||
luaD_stack.top -= (aux+1);
|
||||
break;
|
||||
|
||||
case ARGS:
|
||||
|
|
@ -451,10 +455,13 @@ StkId luaV_execute (Closure *cl, StkId base)
|
|||
adjust_varargs(base + *(pc++));
|
||||
break;
|
||||
|
||||
case CREATEARRAY:
|
||||
case CREATEARRAYW:
|
||||
aux = next_word(pc); goto createarray;
|
||||
|
||||
case CREATEARRAYB:
|
||||
case CREATEARRAY0: case CREATEARRAY1:
|
||||
aux -= CREATEARRAY0; goto createarray;
|
||||
|
||||
case CREATEARRAY:
|
||||
aux = *pc++;
|
||||
createarray:
|
||||
luaC_checkGC();
|
||||
|
|
@ -569,58 +576,66 @@ StkId luaV_execute (Closure *cl, StkId base)
|
|||
nvalue(luaD_stack.top-1) = 1;
|
||||
break;
|
||||
|
||||
case ONTJMPW:
|
||||
aux = next_word(pc); goto ontjmp;
|
||||
|
||||
case ONTJMP:
|
||||
aux = *pc++;
|
||||
ontjmp:
|
||||
if (ttype(luaD_stack.top-1) != LUA_T_NIL) pc += aux;
|
||||
else luaD_stack.top--;
|
||||
break;
|
||||
|
||||
case ONFJMPW:
|
||||
aux = next_word(pc); goto onfjmp;
|
||||
|
||||
case ONFJMP:
|
||||
aux = *pc++;
|
||||
onfjmp:
|
||||
if (ttype(luaD_stack.top-1) == LUA_T_NIL) pc += aux;
|
||||
else luaD_stack.top--;
|
||||
break;
|
||||
|
||||
case JMP:
|
||||
case JMPW:
|
||||
aux = next_word(pc); goto jmp;
|
||||
|
||||
case JMPB:
|
||||
case JMP:
|
||||
aux = *pc++;
|
||||
jmp:
|
||||
pc += aux;
|
||||
break;
|
||||
|
||||
case IFFJMP:
|
||||
case IFFJMPW:
|
||||
aux = next_word(pc); goto iffjmp;
|
||||
|
||||
case IFFJMPB:
|
||||
case IFFJMP:
|
||||
aux = *pc++;
|
||||
iffjmp:
|
||||
if (ttype(--luaD_stack.top) == LUA_T_NIL) pc += aux;
|
||||
break;
|
||||
|
||||
case IFTUPJMP:
|
||||
case IFTUPJMPW:
|
||||
aux = next_word(pc); goto iftupjmp;
|
||||
|
||||
case IFTUPJMPB:
|
||||
case IFTUPJMP:
|
||||
aux = *pc++;
|
||||
iftupjmp:
|
||||
if (ttype(--luaD_stack.top) != LUA_T_NIL) pc -= aux;
|
||||
break;
|
||||
|
||||
case IFFUPJMP:
|
||||
case IFFUPJMPW:
|
||||
aux = next_word(pc); goto iffupjmp;
|
||||
|
||||
case IFFUPJMPB:
|
||||
case IFFUPJMP:
|
||||
aux = *pc++;
|
||||
iffupjmp:
|
||||
if (ttype(--luaD_stack.top) == LUA_T_NIL) pc -= aux;
|
||||
break;
|
||||
|
||||
case CLOSURE:
|
||||
case CLOSUREW:
|
||||
aux = next_word(pc); goto closure;
|
||||
|
||||
case CLOSUREB:
|
||||
case CLOSURE:
|
||||
aux = *pc++;
|
||||
closure:
|
||||
*luaD_stack.top++ = consts[aux];
|
||||
|
|
@ -628,9 +643,14 @@ StkId luaV_execute (Closure *cl, StkId base)
|
|||
luaC_checkGC();
|
||||
break;
|
||||
|
||||
case CALLFUNC: {
|
||||
case CALLFUNC:
|
||||
aux = *pc++; goto callfunc;
|
||||
|
||||
case CALLFUNC0: case CALLFUNC1:
|
||||
aux -= CALLFUNC0;
|
||||
callfunc: {
|
||||
StkId newBase = (luaD_stack.top-luaD_stack.stack)-(*pc++);
|
||||
luaD_call(newBase, *pc++);
|
||||
luaD_call(newBase, aux);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -642,19 +662,22 @@ StkId luaV_execute (Closure *cl, StkId base)
|
|||
luaD_callHook(base, LUA_T_MARK, 1);
|
||||
return (base + ((aux==RETCODE) ? *pc : 0));
|
||||
|
||||
case SETLINE: {
|
||||
int line = next_word(pc);
|
||||
case SETLINEW:
|
||||
aux = next_word(pc); goto setline;
|
||||
|
||||
case SETLINE:
|
||||
aux = *pc++;
|
||||
setline:
|
||||
if ((luaD_stack.stack+base-1)->ttype != LUA_T_LINE) {
|
||||
/* open space for LINE value */
|
||||
luaD_openstack((luaD_stack.top-luaD_stack.stack)-base);
|
||||
base++;
|
||||
(luaD_stack.stack+base-1)->ttype = LUA_T_LINE;
|
||||
}
|
||||
(luaD_stack.stack+base-1)->value.i = line;
|
||||
(luaD_stack.stack+base-1)->value.i = aux;
|
||||
if (lua_linehook)
|
||||
luaD_lineHook(line);
|
||||
luaD_lineHook(aux);
|
||||
break;
|
||||
}
|
||||
|
||||
#ifdef DEBUG
|
||||
default:
|
||||
|
|
|
|||
Loading…
Reference in New Issue