rusefi
/
lua
mirror of https://github.com/rusefi/lua.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

more uniform treatment to opcode variants.

This commit is contained in:
Roberto Ierusalimschy 1997-10-13 20:12:04 -02:00
parent 2bb94d9e22
commit 7c261a13b5
3 changed files with 250 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
lopcodes.h
View File

@ -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 ** Opcodes for Lua virtual machine
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -9,9 +9,9 @@
/* /*
** NOTICE: variants of the same opcode (like PUSH0, PUSHBYTE, PUSHWORD) must ** NOTICE: variants of the same opcode must be consecutive: First, those
** be consecutive: First, those with built-in parameters, then with byte ** with byte parameter, then with built-in parameters, and last with
** parameter and last with word parameter. ** word parameter.
*/ */
@ -20,15 +20,16 @@ typedef enum {
-----------------------------------------------------------------------------*/ -----------------------------------------------------------------------------*/
ENDCODE,/* - - - */ ENDCODE,/* - - - */
PUSHNIL,/* - - nil */ PUSHNIL,/* b - nil_0...nil_b */
PUSHNILS,/* b - nil_1...nil_b */ PUSHNIL0,/* - - nil */
PUSH0,/* - - 0.0 */ PUSHNUMBER,/* b - (float)b */
PUSH1,/* - - 1.0 */ PUSHNUMBER0,/* - - 0.0 */
PUSH2,/* - - 2.0 */ PUSHNUMBER1,/* - - 1.0 */
PUSHBYTE,/* b - (float)b */ PUSHNUMBER2,/* - - 2.0 */
PUSHWORD,/* w - (float)w */ PUSHNUMBERW,/* w - (float)w */
PUSHCONSTANT,/* b - CNST[b] */
PUSHCONSTANT0,/*- - CNST[0] */ PUSHCONSTANT0,/*- - CNST[0] */
PUSHCONSTANT1,/*- - CNST[1] */ PUSHCONSTANT1,/*- - CNST[1] */
PUSHCONSTANT2,/*- - CNST[2] */ PUSHCONSTANT2,/*- - CNST[2] */
@ -37,15 +38,13 @@ PUSHCONSTANT4,/*- - CNST[4] */
PUSHCONSTANT5,/*- - CNST[5] */ PUSHCONSTANT5,/*- - CNST[5] */
PUSHCONSTANT6,/*- - CNST[6] */ PUSHCONSTANT6,/*- - CNST[6] */
PUSHCONSTANT7,/*- - CNST[7] */ PUSHCONSTANT7,/*- - CNST[7] */
PUSHCONSTANT8,/*- - CNST[8] */ PUSHCONSTANTW,/*w - CNST[w] */
PUSHCONSTANT9,/*- - CNST[9] */
PUSHCONSTANTB,/*b - CNST[b] */
PUSHCONSTANT,/* w - CNST[w] */
PUSHUPVALUE,/* b - Closure[b] */
PUSHUPVALUE0,/* - - Closure[0] */ PUSHUPVALUE0,/* - - Closure[0] */
PUSHUPVALUE1,/* - - Closure[1] */ PUSHUPVALUE1,/* - - Closure[1] */
PUSHUPVALUE,/* b - Closure[b] */
PUSHLOCAL,/* b - LOC[b] */
PUSHLOCAL0,/* - - LOC[0] */ PUSHLOCAL0,/* - - LOC[0] */
PUSHLOCAL1,/* - - LOC[1] */ PUSHLOCAL1,/* - - LOC[1] */
PUSHLOCAL2,/* - - LOC[2] */ PUSHLOCAL2,/* - - LOC[2] */
@ -54,10 +53,8 @@ PUSHLOCAL4,/* - - LOC[4] */
PUSHLOCAL5,/* - - LOC[5] */ PUSHLOCAL5,/* - - LOC[5] */
PUSHLOCAL6,/* - - LOC[6] */ PUSHLOCAL6,/* - - LOC[6] */
PUSHLOCAL7,/* - - LOC[7] */ PUSHLOCAL7,/* - - LOC[7] */
PUSHLOCAL8,/* - - LOC[8] */
PUSHLOCAL9,/* - - LOC[9] */
PUSHLOCAL,/* b - LOC[b] */
GETGLOBAL,/* b - VAR[CNST[b]] */
GETGLOBAL0,/* - - VAR[CNST[0]] */ GETGLOBAL0,/* - - VAR[CNST[0]] */
GETGLOBAL1,/* - - VAR[CNST[1]] */ GETGLOBAL1,/* - - VAR[CNST[1]] */
GETGLOBAL2,/* - - VAR[CNST[2]] */ GETGLOBAL2,/* - - VAR[CNST[2]] */
@ -66,19 +63,19 @@ GETGLOBAL4,/* - - VAR[CNST[4]] */
GETGLOBAL5,/* - - VAR[CNST[5]] */ GETGLOBAL5,/* - - VAR[CNST[5]] */
GETGLOBAL6,/* - - VAR[CNST[6]] */ GETGLOBAL6,/* - - VAR[CNST[6]] */
GETGLOBAL7,/* - - VAR[CNST[7]] */ GETGLOBAL7,/* - - VAR[CNST[7]] */
GETGLOBAL8,/* - - VAR[CNST[8]] */ GETGLOBALW,/* w - VAR[CNST[w]] */
GETGLOBAL9,/* - - VAR[CNST[9]] */
GETGLOBALB,/* b - VAR[CNST[b]] */
GETGLOBAL,/* w - VAR[CNST[w]] */
GETTABLE,/* - i t t[i] */ GETTABLE,/* - i t t[i] */
PUSHSELFB,/* b t t t[CNST[b]] */ PUSHSELF,/* b t t t[CNST[b]] */
PUSHSELF,/* w t t t[CNST[w]] */ PUSHSELFW,/* w t t t[CNST[w]] */
CREATEARRAYB,/* b - newarray(size = b) */ CREATEARRAY,/* b - newarray(size = b) */
CREATEARRAY,/* w - newarray(size = w) */ CREATEARRAY0,/* - - newarray(size = 0) */
CREATEARRAY1,/* - - newarray(size = 1) */
CREATEARRAYW,/* w - newarray(size = w) */
SETLOCAL,/* b x - LOC[b]=x */
SETLOCAL0,/* - x - LOC[0]=x */ SETLOCAL0,/* - x - LOC[0]=x */
SETLOCAL1,/* - x - LOC[1]=x */ SETLOCAL1,/* - x - LOC[1]=x */
SETLOCAL2,/* - x - LOC[2]=x */ SETLOCAL2,/* - x - LOC[2]=x */
@ -87,19 +84,28 @@ SETLOCAL4,/* - x - LOC[4]=x */
SETLOCAL5,/* - x - LOC[5]=x */ SETLOCAL5,/* - x - LOC[5]=x */
SETLOCAL6,/* - x - LOC[6]=x */ SETLOCAL6,/* - x - LOC[6]=x */
SETLOCAL7,/* - x - LOC[7]=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,/* b x - VAR[CNST[b]]=x */
SETGLOBAL,/* w x - VAR[CNST[w]]=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 */ 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 */ 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 */ 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 */ EQOP,/* - y x (x==y)? 1 : nil */
NEQOP,/* - 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 */ NOTOP,/* - x (x==nil)? 1 : nil */
ONTJMP,/* b x (x!=nil)? x : - (x!=nil)? PC+=b */ 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 */ ONFJMP,/* b x (x==nil)? x : - (x==nil)? PC+=b */
JMPB,/* b - - PC+=b */ ONFJMPW,/* w x (x==nil)? x : - (x==nil)? PC+=w */
JMP,/* w - - PC+=w */ JMP,/* b - - PC+=b */
IFFJMPB,/* b x - (x==nil)? PC+=b */ JMPW,/* w - - PC+=w */
IFFJMP,/* w x - (x==nil)? PC+=w */ IFFJMP,/* b x - (x==nil)? PC+=b */
IFTUPJMPB,/* b x - (x!=nil)? PC-=b */ IFFJMPW,/* w x - (x==nil)? PC+=w */
IFTUPJMP,/* w x - (x!=nil)? PC-=w */ IFTUPJMP,/* b x - (x!=nil)? PC-=b */
IFFUPJMPB,/* b x - (x==nil)? PC-=b */ IFTUPJMPW,/* w x - (x!=nil)? PC-=w */
IFFUPJMP,/* 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,/* b v_1...v_n c(CNST[b]) */
CLOSURE,/* w v_1...v_n c(CNST[w]) */ 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 - - */ RETCODE,/* b - - */
SETLINE,/* w - - LINE=w */
POP1,/* - - - TOP-=1 */ SETLINE,/* b - - LINE=b */
POP2,/* - - - TOP-=2 */ SETLINEW,/* w - - LINE=w */
POPS,/* b - - TOP-=b */
POP,/* b - - TOP-=(b+1) */
POP0,/* - - - TOP-=1 */
POP1,/* - - - TOP-=2 */
ARGS,/* b - - TOP=BASE+b */ ARGS,/* b - - TOP=BASE+b */
VARARGS/* b v_x...v_1 {v_1...v_x;n=x} TOP=BASE+b+1 */ VARARGS/* b v_x...v_1 {v_1...v_x;n=x} TOP=BASE+b+1 */
} OpCode; } OpCode;

230
lua.stx
View File

@ -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 ** Syntax analizer and code generator
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -23,9 +23,6 @@
/* to avoid warnings generated by yacc */ /* to avoid warnings generated by yacc */
int luaY_parse (void); 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 */ /* 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) static void deltastack (int delta)
{ {
currState->stacksize += 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) static void code_opcode (OpCode op, int delta)
{ {
code_byte(op);
deltastack(delta); deltastack(delta);
} code_byte(op);
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);
} }
@ -193,7 +187,10 @@ static void code_pop (OpCode op)
#define code_binop(op) code_pop(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 */ /* unary operations get 1 argument and leave one, so they are neutral */
#define code_unop(op) code_neutralop(op) #define code_unop(op) code_neutralop(op)
@ -201,7 +198,7 @@ static void code_pop (OpCode op)
static void code_constant (int c) 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) static int real_constant (real r)
{ {
/* check whether 'r' has appeared within the last LIM entries */ /* check whether 'r' has appeared within the last LIM entries */
@ -261,7 +258,7 @@ static void code_number (real f)
{ {
Word i; Word i;
if (f >= 0 && f <= (real)MAX_WORD && (real)(i=(Word)f) == f) 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 else
code_constant(real_constant(f)); code_constant(real_constant(f));
} }
@ -270,18 +267,13 @@ static void code_number (real f)
static void flush_record (int n) static void flush_record (int n)
{ {
if (n > 0) 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) static void flush_list (int m, int n)
{ {
if (n == 0) return; if (n == 0) return;
if (m == 0) code_oparg(SETLIST, 1, m, -n);
code_opcode(SETLIST0, -n);
else if (m < 255)
code_opb(SETLIST, m, -n);
else
luaY_error("list constructor too long");
code_byte(n); code_byte(n);
} }
@ -375,7 +367,7 @@ static void pushupvalue (TaggedString *n)
if (aux_localname(n, currState) >= 0) if (aux_localname(n, currState) >= 0)
luaY_syntaxerror("cannot access an upvalue in current scope", n->str); luaY_syntaxerror("cannot access an upvalue in current scope", n->str);
i = indexupvalue(n); 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; static int lastline = 0;
if (lua_debug && line != lastline) { if (lua_debug && line != lastline) {
code_opw(SETLINE, line, 0); code_oparg(SETLINE, 0, line, 0);
lastline = line; lastline = line;
} }
} }
@ -392,22 +384,25 @@ void luaY_codedebugline (int line)
static void adjuststack (int n) static void adjuststack (int n)
{ {
if (n > 0) if (n > 0)
code_oparg(POP1-1, POPS, n, -n); /* POP1-1 = POP0 */ code_oparg(POP, 2, n-1, -n);
else if (n < 0) 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) if (exp <= 0)
return -exp; /* exp is -list length */ return -exp; /* exp is -list length */
else { else {
int temp = currState->f->code[exp]; int temp = currState->f->code[exp];
currState->f->code[exp] = i; int nparams = currState->f->code[exp-1];
if (i != MULT_RET) exp += fix_opcode(exp-2, CALLFUNC, 2, nresults);
deltastack(i); currState->f->code[exp] = nparams;
return temp+i; 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) static void code_args (int dots)
{ {
if (!dots) if (!dots)
code_opb(ARGS, currState->nlocalvar, currState->nlocalvar); code_oparg(ARGS, 0, currState->nlocalvar, currState->nlocalvar);
else { else {
code_opb(VARARGS, currState->nlocalvar, currState->nlocalvar+1); code_oparg(VARARGS, 0, currState->nlocalvar, currState->nlocalvar+1);
add_localvar(luaS_new("arg")); add_localvar(luaS_new("arg"));
} }
} }
@ -441,9 +436,9 @@ static void code_args (int dots)
static void lua_pushvar (vardesc number) static void lua_pushvar (vardesc number)
{ {
if (number > 0) /* global var */ 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 */ else if (number < 0) /* local var */
code_oparg(PUSHLOCAL0, PUSHLOCAL, (-number)-1, 1); code_oparg(PUSHLOCAL, 8, (-number)-1, 1);
else else
code_pop(GETTABLE); code_pop(GETTABLE);
} }
@ -454,9 +449,9 @@ static void storevar (vardesc number)
if (number == 0) /* indexed var */ if (number == 0) /* indexed var */
code_opcode(SETTABLE0, -3); code_opcode(SETTABLE0, -3);
else if (number > 0) /* global var */ else if (number > 0) /* global var */
code_opborw(SETGLOBALB, number-1, -1); code_oparg(SETGLOBAL, 8, number-1, -1);
else /* number < 0 - local var */ 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; return left;
} }
else { /* indexed var with values in between*/ else { /* indexed var with values in between*/
code_pop(SETTABLE); code_oparg(SETTABLE, 0, left+i, -1);
code_byte(left+i); /* number of elements between table/index and value */
return left+2; /* table/index are not poped, since they are not on top */ 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) static int fix_jump (int pc, OpCode op, int n)
{ {
/* jump is relative to position following jump instruction */ /* 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 */ int delta = currState->pc+JMPSIZE - pos; /* jump is relative */
if (delta > 255) delta++; 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; elseinit = currState->pc;
} }
else else
elseinit += fix_jump(elseAdd, JMPB, currState->pc); elseinit += fix_jump(elseAdd, JMP, currState->pc);
fix_jump(thenAdd, IFFJMPB, elseinit); 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); fix_jump(pc, op, currState->pc);
if (dist > 255)
luaY_error("and/or expression too long");
currState->f->code[pos] = op;
currState->f->code[pos+1] = dist;
} }
static void codereturn (void) static void codereturn (void)
{ {
code_neutralop(RETCODE); code_oparg(RETCODE, 0, currState->nlocalvar, 0);
code_byte(currState->nlocalvar);
currState->stacksize = currState->nlocalvar; currState->stacksize = currState->nlocalvar;
} }
@ -549,7 +520,7 @@ static void func_onstack (TProtoFunc *f)
currState->f->consts[c].value.tf = (currState+1)->f; currState->f->consts[c].value.tf = (currState+1)->f;
for (i=0; i<nupvalues; i++) for (i=0; i<nupvalues; i++)
lua_pushvar((currState+1)->upvalues[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; currState->f->lineDefined = luaX_linenumber;
} }
static TProtoFunc *close_func (void) static TProtoFunc *close_func (void)
{ {
TProtoFunc *f = currState->f; TProtoFunc *f = currState->f;
@ -687,13 +657,13 @@ stat : IF cond THEN block SaveWord elsepart END
memcpy(&currState->f->code[currState->pc], memcpy(&currState->f->code[currState->pc],
&currState->f->code[$2], expsize); &currState->f->code[$2], expsize);
movecode_down($2, $3, currState->pc-$2); movecode_down($2, $3, currState->pc-$2);
newpos += fix_jump($2, JMPB, currState->pc-expsize); newpos += fix_jump($2, JMP, currState->pc-expsize);
fix_upjmp(IFTUPJMPB, newpos); fix_upjmp(IFTUPJMP, newpos);
}} }}
| REPEAT GetPC block UNTIL expr1 | REPEAT GetPC block UNTIL expr1
{ {
fix_upjmp(IFFUPJMPB, $2); fix_upjmp(IFFUPJMP, $2);
deltastack(-1); /* pops condition */ deltastack(-1); /* pops condition */
} }
@ -706,7 +676,7 @@ stat : IF cond THEN block SaveWord elsepart END
left = lua_codestore(i, left); left = lua_codestore(i, left);
adjuststack(left); /* remove eventual 'garbage' left on stack */ adjuststack(left); /* remove eventual 'garbage' left on stack */
}} }}
| functioncall | functioncall { adjust_functioncall($1, 0); }
| LOCAL localdeclist decinit | LOCAL localdeclist decinit
{ {
currState->nlocalvar += $2; currState->nlocalvar += $2;
@ -757,7 +727,11 @@ ret : /* empty */
GetPC : /* empty */ { $$ = currState->pc; } 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 */ } SaveWordPop : SaveWord { $$ = $1; deltastack(-1); /* pop condition */ }
@ -787,33 +761,33 @@ expr : '(' expr ')' { $$ = $2; }
| expr1 CONC expr1 { code_binop(CONCOP); $$ = 0; } | expr1 CONC expr1 { code_binop(CONCOP); $$ = 0; }
| '-' expr1 %prec UNARY { code_unop(MINUSOP); $$ = 0;} | '-' expr1 %prec UNARY { code_unop(MINUSOP); $$ = 0;}
| NOT expr1 { code_unop(NOTOP); $$ = 0;} | NOT expr1 { code_unop(NOTOP); $$ = 0;}
| table { $$ = 0; } | table { $$ = 0; }
| varexp { $$ = 0;} | varexp { $$ = 0;}
| NUMBER { code_number($1); $$ = 0; } | NUMBER { code_number($1); $$ = 0; }
| STRING { code_string($1); $$ = 0; } | STRING { code_string($1); $$ = 0; }
| NIL {code_opcode(PUSHNIL, 1); $$ = 0; } | NIL { adjuststack(-1); $$ = 0; }
| functioncall { $$ = $1; } | functioncall { $$ = $1; }
| FUNCTION { init_func(); } body { func_onstack($3); $$ = 0; } | FUNCTION { init_func(); } body { func_onstack($3); $$ = 0; }
| expr1 AND SaveWordPop expr1 { code_shortcircuit(ONFJMP, $3); $$ = 0; } | expr1 AND SaveWordPop expr1 { code_shortcircuit($3, ONFJMP); $$ = 0; }
| expr1 OR SaveWordPop expr1 { code_shortcircuit(ONTJMP, $3); $$ = 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 functioncall : funcvalue funcParams
{ {
code_opcode(CALLFUNC, -($1+$2+1)); /* ajdust counts results */ code_byte(0); /* save space for opcode */
code_byte($1+$2); code_byte($1+$2); /* number of parameters */
$$ = currState->pc; $$ = currState->pc;
code_byte(0); /* may be adjusted by other rules */ code_byte(0); /* must be adjusted by other rules */
} }
; ;
funcvalue : varexp { $$ = 0; } funcvalue : varexp { $$ = 0; }
| varexp ':' NAME | varexp ':' NAME
{ {
code_opborw(PUSHSELFB, string_constant($3, currState), 1); code_oparg(PUSHSELF, 0, string_constant($3, currState), 1);
$$ = 1; $$ = 1;
} }
; ;

145
lvm.c
View File

@ -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 ** Lua virtual machine
** See Copyright Notice in lua.h ** See Copyright Notice in lua.h
*/ */
@ -284,25 +284,25 @@ StkId luaV_execute (Closure *cl, StkId base)
int aux; int aux;
switch ((OpCode)(aux = *pc++)) { switch ((OpCode)(aux = *pc++)) {
case PUSHNIL: case PUSHNIL0:
ttype(luaD_stack.top++) = LUA_T_NIL; ttype(luaD_stack.top++) = LUA_T_NIL;
break; break;
case PUSHNILS: { case PUSHNIL:
int n = *pc++; aux = *pc++;
while (n--) do {
ttype(luaD_stack.top++) = LUA_T_NIL; ttype(luaD_stack.top++) = LUA_T_NIL;
} while (aux--);
break; break;
}
case PUSHBYTE: case PUSHNUMBER:
aux = *pc++; goto pushnumber; aux = *pc++; goto pushnumber;
case PUSHWORD: case PUSHNUMBERW:
aux = next_word(pc); goto pushnumber; aux = next_word(pc); goto pushnumber;
case PUSH0: case PUSH1: case PUSH2: case PUSHNUMBER0: case PUSHNUMBER1: case PUSHNUMBER2:
aux -= PUSH0; aux -= PUSHNUMBER0;
pushnumber: pushnumber:
ttype(luaD_stack.top) = LUA_T_NUMBER; ttype(luaD_stack.top) = LUA_T_NUMBER;
nvalue(luaD_stack.top) = aux; nvalue(luaD_stack.top) = aux;
@ -312,25 +312,21 @@ StkId luaV_execute (Closure *cl, StkId base)
case PUSHLOCAL: case PUSHLOCAL:
aux = *pc++; goto pushlocal; aux = *pc++; goto pushlocal;
case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2: case PUSHLOCAL0: case PUSHLOCAL1: case PUSHLOCAL2: case PUSHLOCAL3:
case PUSHLOCAL3: case PUSHLOCAL4: case PUSHLOCAL5: case PUSHLOCAL4: case PUSHLOCAL5: case PUSHLOCAL6: case PUSHLOCAL7:
case PUSHLOCAL6: case PUSHLOCAL7: case PUSHLOCAL8:
case PUSHLOCAL9:
aux -= PUSHLOCAL0; aux -= PUSHLOCAL0;
pushlocal: pushlocal:
*luaD_stack.top++ = *((luaD_stack.stack+base) + aux); *luaD_stack.top++ = *((luaD_stack.stack+base) + aux);
break; break;
case GETGLOBAL: case GETGLOBALW:
aux = next_word(pc); goto getglobal; aux = next_word(pc); goto getglobal;
case GETGLOBALB: case GETGLOBAL:
aux = *pc++; goto getglobal; aux = *pc++; goto getglobal;
case GETGLOBAL0: case GETGLOBAL1: case GETGLOBAL2: case GETGLOBAL0: case GETGLOBAL1: case GETGLOBAL2: case GETGLOBAL3:
case GETGLOBAL3: case GETGLOBAL4: case GETGLOBAL5: case GETGLOBAL4: case GETGLOBAL5: case GETGLOBAL6: case GETGLOBAL7:
case GETGLOBAL6: case GETGLOBAL7: case GETGLOBAL8:
case GETGLOBAL9:
aux -= GETGLOBAL0; aux -= GETGLOBAL0;
getglobal: getglobal:
luaV_getglobal(tsvalue(&consts[aux])); luaV_getglobal(tsvalue(&consts[aux]));
@ -340,10 +336,10 @@ StkId luaV_execute (Closure *cl, StkId base)
luaV_gettable(); luaV_gettable();
break; break;
case PUSHSELF: case PUSHSELFW:
aux = next_word(pc); goto pushself; aux = next_word(pc); goto pushself;
case PUSHSELFB: case PUSHSELF:
aux = *pc++; aux = *pc++;
pushself: { pushself: {
TObject receiver = *(luaD_stack.top-1); TObject receiver = *(luaD_stack.top-1);
@ -353,16 +349,15 @@ StkId luaV_execute (Closure *cl, StkId base)
break; break;
} }
case PUSHCONSTANT: case PUSHCONSTANTW:
aux = next_word(pc); goto pushconstant; aux = next_word(pc); goto pushconstant;
case PUSHCONSTANTB: case PUSHCONSTANT:
aux = *pc++; goto pushconstant; aux = *pc++; goto pushconstant;
case PUSHCONSTANT0: case PUSHCONSTANT1: case PUSHCONSTANT2: case PUSHCONSTANT0: case PUSHCONSTANT1: case PUSHCONSTANT2:
case PUSHCONSTANT3: case PUSHCONSTANT4: case PUSHCONSTANT5: case PUSHCONSTANT3: case PUSHCONSTANT4: case PUSHCONSTANT5:
case PUSHCONSTANT6: case PUSHCONSTANT7: case PUSHCONSTANT8: case PUSHCONSTANT6: case PUSHCONSTANT7:
case PUSHCONSTANT9:
aux -= PUSHCONSTANT0; aux -= PUSHCONSTANT0;
pushconstant: pushconstant:
*luaD_stack.top++ = consts[aux]; *luaD_stack.top++ = consts[aux];
@ -380,20 +375,22 @@ StkId luaV_execute (Closure *cl, StkId base)
case SETLOCAL: case SETLOCAL:
aux = *pc++; goto setlocal; aux = *pc++; goto setlocal;
case SETLOCAL0: case SETLOCAL1: case SETLOCAL2: case SETLOCAL0: case SETLOCAL1: case SETLOCAL2: case SETLOCAL3:
case SETLOCAL3: case SETLOCAL4: case SETLOCAL5: case SETLOCAL4: case SETLOCAL5: case SETLOCAL6: case SETLOCAL7:
case SETLOCAL6: case SETLOCAL7: case SETLOCAL8:
case SETLOCAL9:
aux -= SETLOCAL0; aux -= SETLOCAL0;
setlocal: setlocal:
*((luaD_stack.stack+base) + aux) = *(--luaD_stack.top); *((luaD_stack.stack+base) + aux) = *(--luaD_stack.top);
break; break;
case SETGLOBAL: case SETGLOBALW:
aux = next_word(pc); goto setglobal; aux = next_word(pc); goto setglobal;
case SETGLOBALB: case SETGLOBAL:
aux = *pc++; aux = *pc++; goto setglobal;
case SETGLOBAL0: case SETGLOBAL1: case SETGLOBAL2: case SETGLOBAL3:
case SETGLOBAL4: case SETGLOBAL5: case SETGLOBAL6: case SETGLOBAL7:
aux -= SETGLOBAL0;
setglobal: setglobal:
luaV_setglobal(tsvalue(&consts[aux])); luaV_setglobal(tsvalue(&consts[aux]));
break; break;
@ -406,6 +403,9 @@ StkId luaV_execute (Closure *cl, StkId base)
luaV_settable(luaD_stack.top-3-(*pc++), 2); luaV_settable(luaD_stack.top-3-(*pc++), 2);
break; break;
case SETLISTW:
aux = next_word(pc); aux *= LFIELDS_PER_FLUSH; goto setlist;
case SETLIST: case SETLIST:
aux = *(pc++) * LFIELDS_PER_FLUSH; goto setlist; aux = *(pc++) * LFIELDS_PER_FLUSH; goto setlist;
@ -423,23 +423,27 @@ StkId luaV_execute (Closure *cl, StkId base)
break; break;
} }
case SETMAP: { case SETMAP0:
int n = *(pc++); aux = 0; goto setmap;
TObject *arr = luaD_stack.top-(2*n)-1;
while (n--) { 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); *(luaH_set (avalue(arr), luaD_stack.top-2)) = *(luaD_stack.top-1);
luaD_stack.top-=2; luaD_stack.top-=2;
} } while (aux--);
break; break;
} }
case POPS: case POP:
aux = *pc++; goto pop; aux = *pc++; goto pop;
case POP1: case POP2: case POP0: case POP1:
aux -= (POP1-1); aux -= POP0;
pop: pop:
luaD_stack.top -= aux; luaD_stack.top -= (aux+1);
break; break;
case ARGS: case ARGS:
@ -451,10 +455,13 @@ StkId luaV_execute (Closure *cl, StkId base)
adjust_varargs(base + *(pc++)); adjust_varargs(base + *(pc++));
break; break;
case CREATEARRAY: case CREATEARRAYW:
aux = next_word(pc); goto createarray; aux = next_word(pc); goto createarray;
case CREATEARRAYB: case CREATEARRAY0: case CREATEARRAY1:
aux -= CREATEARRAY0; goto createarray;
case CREATEARRAY:
aux = *pc++; aux = *pc++;
createarray: createarray:
luaC_checkGC(); luaC_checkGC();
@ -569,58 +576,66 @@ StkId luaV_execute (Closure *cl, StkId base)
nvalue(luaD_stack.top-1) = 1; nvalue(luaD_stack.top-1) = 1;
break; break;
case ONTJMPW:
aux = next_word(pc); goto ontjmp;
case ONTJMP: case ONTJMP:
aux = *pc++; aux = *pc++;
ontjmp:
if (ttype(luaD_stack.top-1) != LUA_T_NIL) pc += aux; if (ttype(luaD_stack.top-1) != LUA_T_NIL) pc += aux;
else luaD_stack.top--; else luaD_stack.top--;
break; break;
case ONFJMPW:
aux = next_word(pc); goto onfjmp;
case ONFJMP: case ONFJMP:
aux = *pc++; aux = *pc++;
onfjmp:
if (ttype(luaD_stack.top-1) == LUA_T_NIL) pc += aux; if (ttype(luaD_stack.top-1) == LUA_T_NIL) pc += aux;
else luaD_stack.top--; else luaD_stack.top--;
break; break;
case JMP: case JMPW:
aux = next_word(pc); goto jmp; aux = next_word(pc); goto jmp;
case JMPB: case JMP:
aux = *pc++; aux = *pc++;
jmp: jmp:
pc += aux; pc += aux;
break; break;
case IFFJMP: case IFFJMPW:
aux = next_word(pc); goto iffjmp; aux = next_word(pc); goto iffjmp;
case IFFJMPB: case IFFJMP:
aux = *pc++; aux = *pc++;
iffjmp: iffjmp:
if (ttype(--luaD_stack.top) == LUA_T_NIL) pc += aux; if (ttype(--luaD_stack.top) == LUA_T_NIL) pc += aux;
break; break;
case IFTUPJMP: case IFTUPJMPW:
aux = next_word(pc); goto iftupjmp; aux = next_word(pc); goto iftupjmp;
case IFTUPJMPB: case IFTUPJMP:
aux = *pc++; aux = *pc++;
iftupjmp: iftupjmp:
if (ttype(--luaD_stack.top) != LUA_T_NIL) pc -= aux; if (ttype(--luaD_stack.top) != LUA_T_NIL) pc -= aux;
break; break;
case IFFUPJMP: case IFFUPJMPW:
aux = next_word(pc); goto iffupjmp; aux = next_word(pc); goto iffupjmp;
case IFFUPJMPB: case IFFUPJMP:
aux = *pc++; aux = *pc++;
iffupjmp: iffupjmp:
if (ttype(--luaD_stack.top) == LUA_T_NIL) pc -= aux; if (ttype(--luaD_stack.top) == LUA_T_NIL) pc -= aux;
break; break;
case CLOSURE: case CLOSUREW:
aux = next_word(pc); goto closure; aux = next_word(pc); goto closure;
case CLOSUREB: case CLOSURE:
aux = *pc++; aux = *pc++;
closure: closure:
*luaD_stack.top++ = consts[aux]; *luaD_stack.top++ = consts[aux];
@ -628,9 +643,14 @@ StkId luaV_execute (Closure *cl, StkId base)
luaC_checkGC(); luaC_checkGC();
break; 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++); StkId newBase = (luaD_stack.top-luaD_stack.stack)-(*pc++);
luaD_call(newBase, *pc++); luaD_call(newBase, aux);
break; break;
} }
@ -642,19 +662,22 @@ StkId luaV_execute (Closure *cl, StkId base)
luaD_callHook(base, LUA_T_MARK, 1); luaD_callHook(base, LUA_T_MARK, 1);
return (base + ((aux==RETCODE) ? *pc : 0)); return (base + ((aux==RETCODE) ? *pc : 0));
case SETLINE: { case SETLINEW:
int line = next_word(pc); aux = next_word(pc); goto setline;
case SETLINE:
aux = *pc++;
setline:
if ((luaD_stack.stack+base-1)->ttype != LUA_T_LINE) { if ((luaD_stack.stack+base-1)->ttype != LUA_T_LINE) {
/* open space for LINE value */ /* open space for LINE value */
luaD_openstack((luaD_stack.top-luaD_stack.stack)-base); luaD_openstack((luaD_stack.top-luaD_stack.stack)-base);
base++; base++;
(luaD_stack.stack+base-1)->ttype = LUA_T_LINE; (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) if (lua_linehook)
luaD_lineHook(line); luaD_lineHook(aux);
break; break;
}
#ifdef DEBUG #ifdef DEBUG
default: default: