mirror of https://github.com/lua/lua
new opcode INCLOCAL.
This commit is contained in:
Roberto Ierusalimschy
parent
3e45496295
commit
4e7e9e8de5
89
lcode.c
89
lcode.c
|
|
@ -1,10 +1,12 @@
|
|||
/*
|
||||
** $Id: lcode.c,v 1.17 2000/03/24 12:18:30 roberto Exp roberto $
|
||||
** $Id: lcode.c,v 1.18 2000/03/24 17:26:08 roberto Exp roberto $
|
||||
** Code generator for Lua
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
||||
|
||||
#include "stdlib.h"
|
||||
|
||||
#define LUA_REENTRANT
|
||||
|
||||
#include "lcode.h"
|
||||
|
|
@ -73,11 +75,12 @@ static void setprevious (FuncState *fs, Instruction i) {
|
|||
|
||||
|
||||
static void luaK_minus (FuncState *fs) {
|
||||
/* PUSHINT s; MINUS -> PUSHINT -s (-k) */
|
||||
/* PUSHNUM u; MINUS -> PUSHNEGNUM u (-k) */
|
||||
Instruction previous = prepare(fs, CREATE_0(OP_MINUS), 0);
|
||||
switch(GET_OPCODE(previous)) {
|
||||
case OP_PUSHINT: SETARG_S(previous, -GETARG_S(previous)); break;
|
||||
case OP_PUSHNUM: SET_OPCODE(previous, OP_PUSHNEGNUM); break;
|
||||
case OP_PUSHNEGNUM: SET_OPCODE(previous, OP_PUSHNUM); break;
|
||||
default: return;
|
||||
}
|
||||
setprevious(fs, previous);
|
||||
|
|
@ -85,6 +88,7 @@ static void luaK_minus (FuncState *fs) {
|
|||
|
||||
|
||||
static void luaK_gettable (FuncState *fs) {
|
||||
/* PUSHSTRING u; GETTABLE -> GETDOTTED u (t.x) */
|
||||
Instruction previous = prepare(fs, CREATE_0(OP_GETTABLE), -1);
|
||||
switch(GET_OPCODE(previous)) {
|
||||
case OP_PUSHSTRING: SET_OPCODE(previous, OP_GETDOTTED); break;
|
||||
|
|
@ -95,6 +99,7 @@ static void luaK_gettable (FuncState *fs) {
|
|||
|
||||
|
||||
static void luaK_add (FuncState *fs) {
|
||||
/* PUSHINT s; ADD -> ADDI s (a+k) */
|
||||
Instruction previous = prepare(fs, CREATE_0(OP_ADD), -1);
|
||||
switch(GET_OPCODE(previous)) {
|
||||
case OP_PUSHINT: SET_OPCODE(previous, OP_ADDI); break;
|
||||
|
|
@ -105,6 +110,7 @@ static void luaK_add (FuncState *fs) {
|
|||
|
||||
|
||||
static void luaK_sub (FuncState *fs) {
|
||||
/* PUSHINT s; SUB -> ADDI -s (a-k) */
|
||||
Instruction previous = prepare(fs, CREATE_0(OP_SUB), -1);
|
||||
switch(GET_OPCODE(previous)) {
|
||||
case OP_PUSHINT:
|
||||
|
|
@ -118,6 +124,7 @@ static void luaK_sub (FuncState *fs) {
|
|||
|
||||
|
||||
static void luaK_conc (FuncState *fs) {
|
||||
/* CONC u; CONC 2 -> CONC u+1 (a..b..c) */
|
||||
Instruction previous = prepare(fs, CREATE_U(OP_CONC, 2), -1);
|
||||
switch(GET_OPCODE(previous)) {
|
||||
case OP_CONC: SETARG_U(previous, GETARG_U(previous)+1); break;
|
||||
|
|
@ -127,8 +134,27 @@ static void luaK_conc (FuncState *fs) {
|
|||
}
|
||||
|
||||
|
||||
static void luaK_setlocal (FuncState *fs, int l) {
|
||||
/* PUSHLOCAL l; ADDI k, SETLOCAL l -> INCLOCAL k, l ((local)a=a+k) */
|
||||
Instruction *code = fs->f->code;
|
||||
int pc = fs->pc;
|
||||
if (pc-1 > fs->lasttarget && /* no jumps in-between instructions? */
|
||||
code[pc-2] == CREATE_U(OP_PUSHLOCAL, l) &&
|
||||
GET_OPCODE(code[pc-1]) == OP_ADDI &&
|
||||
abs(GETARG_S(code[pc-1])) <= MAXARG_sA) {
|
||||
int inc = GETARG_S(code[pc-1]);
|
||||
fs->pc = pc-1;
|
||||
code[pc-2] = CREATE_sAB(OP_INCLOCAL, inc, l);
|
||||
luaK_deltastack(fs, -1);
|
||||
}
|
||||
else
|
||||
luaK_U(fs, OP_SETLOCAL, l, -1);
|
||||
}
|
||||
|
||||
|
||||
static void luaK_eq (FuncState *fs) {
|
||||
Instruction previous = prepare(fs, CREATE_S(OP_IFEQJMP, 0), -2);
|
||||
/* PUSHNIL 1; JMPEQ -> NOT (a==nil) */
|
||||
Instruction previous = prepare(fs, CREATE_S(OP_JMPEQ, 0), -2);
|
||||
if (previous == CREATE_U(OP_PUSHNIL, 1)) {
|
||||
setprevious(fs, CREATE_0(OP_NOT));
|
||||
luaK_deltastack(fs, 1); /* undo delta from `prepare' */
|
||||
|
|
@ -137,9 +163,10 @@ static void luaK_eq (FuncState *fs) {
|
|||
|
||||
|
||||
static void luaK_neq (FuncState *fs) {
|
||||
Instruction previous = prepare(fs, CREATE_S(OP_IFNEQJMP, 0), -2);
|
||||
/* PUSHNIL 1; JMPNEQ -> JMPT (a~=nil) */
|
||||
Instruction previous = prepare(fs, CREATE_S(OP_JMPNEQ, 0), -2);
|
||||
if (previous == CREATE_U(OP_PUSHNIL, 1)) {
|
||||
setprevious(fs, CREATE_S(OP_IFTJMP, 0));
|
||||
setprevious(fs, CREATE_S(OP_JMPT, 0));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -171,7 +198,7 @@ void luaK_fixjump (FuncState *fs, int pc, int dest) {
|
|||
SETARG_S(*jmp, 0); /* absolute value to represent end of list */
|
||||
else { /* jump is relative to position following jump instruction */
|
||||
int offset = dest-(pc+1);
|
||||
if (offset < -MAXARG_S || offset > MAXARG_S)
|
||||
if (abs(offset) > MAXARG_S)
|
||||
luaK_error(fs->ls, "control structure too long");
|
||||
SETARG_S(*jmp, offset);
|
||||
}
|
||||
|
|
@ -298,7 +325,7 @@ void luaK_storevar (LexState *ls, const expdesc *var) {
|
|||
FuncState *fs = ls->fs;
|
||||
switch (var->k) {
|
||||
case VLOCAL:
|
||||
luaK_U(fs, OP_SETLOCAL, var->u.index, -1);
|
||||
luaK_setlocal(fs, var->u.index);
|
||||
break;
|
||||
case VGLOBAL:
|
||||
luaK_U(fs, OP_SETGLOBAL, var->u.index, -1);
|
||||
|
|
@ -315,14 +342,14 @@ void luaK_storevar (LexState *ls, const expdesc *var) {
|
|||
|
||||
static OpCode invertjump (OpCode op) {
|
||||
switch (op) {
|
||||
case OP_IFNEQJMP: return OP_IFEQJMP;
|
||||
case OP_IFEQJMP: return OP_IFNEQJMP;
|
||||
case OP_IFLTJMP: return OP_IFGEJMP;
|
||||
case OP_IFLEJMP: return OP_IFGTJMP;
|
||||
case OP_IFGTJMP: return OP_IFLEJMP;
|
||||
case OP_IFGEJMP: return OP_IFLTJMP;
|
||||
case OP_IFTJMP: case OP_ONTJMP: return OP_IFFJMP;
|
||||
case OP_IFFJMP: case OP_ONFJMP: return OP_IFTJMP;
|
||||
case OP_JMPNEQ: return OP_JMPEQ;
|
||||
case OP_JMPEQ: return OP_JMPNEQ;
|
||||
case OP_JMPLT: return OP_JMPGE;
|
||||
case OP_JMPLE: return OP_JMPGT;
|
||||
case OP_JMPGT: return OP_JMPLE;
|
||||
case OP_JMPGE: return OP_JMPLT;
|
||||
case OP_JMPT: case OP_JMPONT: return OP_JMPF;
|
||||
case OP_JMPF: case OP_JMPONF: return OP_JMPT;
|
||||
default:
|
||||
LUA_INTERNALERROR(NULL, "invalid jump instruction");
|
||||
return OP_END; /* to avoid warnings */
|
||||
|
|
@ -334,8 +361,8 @@ static void luaK_jump (FuncState *fs, OpCode jump) {
|
|||
Instruction previous = prepare(fs, CREATE_S(jump, 0), -1);
|
||||
switch (GET_OPCODE(previous)) {
|
||||
case OP_NOT: previous = CREATE_S(invertjump(jump), 0); break;
|
||||
case OP_PUSHINT:
|
||||
if (jump == OP_IFTJMP) {
|
||||
case OP_PUSHNIL: /* optimize `repeat until nil' */
|
||||
if (GETARG_U(previous) == 1 && jump == OP_JMPF) {
|
||||
previous = CREATE_S(OP_JMP, 0);
|
||||
break;
|
||||
}
|
||||
|
|
@ -364,10 +391,10 @@ static void luaK_patchlistaux (FuncState *fs, int list, int target,
|
|||
luaK_fixjump(fs, list, special_target);
|
||||
else {
|
||||
luaK_fixjump(fs, list, target); /* do the patch */
|
||||
if (op == OP_ONTJMP) /* remove eventual values */
|
||||
SET_OPCODE(*i, OP_IFTJMP);
|
||||
else if (op == OP_ONFJMP)
|
||||
SET_OPCODE(*i, OP_IFFJMP);
|
||||
if (op == OP_JMPONT) /* remove eventual values */
|
||||
SET_OPCODE(*i, OP_JMPT);
|
||||
else if (op == OP_JMPONF)
|
||||
SET_OPCODE(*i, OP_JMPF);
|
||||
}
|
||||
list = next;
|
||||
}
|
||||
|
|
@ -427,12 +454,12 @@ static void luaK_testgo (FuncState *fs, expdesc *v, int invert, OpCode jump) {
|
|||
|
||||
|
||||
void luaK_goiftrue (FuncState *fs, expdesc *v, int keepvalue) {
|
||||
luaK_testgo(fs, v, 1, keepvalue ? OP_ONFJMP : OP_IFFJMP);
|
||||
luaK_testgo(fs, v, 1, keepvalue ? OP_JMPONF : OP_JMPF);
|
||||
}
|
||||
|
||||
|
||||
void luaK_goiffalse (FuncState *fs, expdesc *v, int keepvalue) {
|
||||
luaK_testgo(fs, v, 0, keepvalue ? OP_ONTJMP : OP_IFTJMP);
|
||||
luaK_testgo(fs, v, 0, keepvalue ? OP_JMPONT : OP_JMPT);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -456,8 +483,8 @@ void luaK_tostack (LexState *ls, expdesc *v, int onlyone) {
|
|||
p_1 = luaK_S(fs, OP_PUSHINT, 1, 1);
|
||||
}
|
||||
else { /* still may need a PUSHNIL or a PUSHINT */
|
||||
int need_nil = need_value(fs, v->u.l.f, OP_ONFJMP);
|
||||
int need_1 = need_value(fs, v->u.l.t, OP_ONTJMP);
|
||||
int need_nil = need_value(fs, v->u.l.f, OP_JMPONF);
|
||||
int need_1 = need_value(fs, v->u.l.t, OP_JMPONT);
|
||||
if (need_nil && need_1) {
|
||||
luaK_S(fs, OP_JMP, 2, 0); /* skip both pushes */
|
||||
p_nil = luaK_0(fs, OP_PUSHNILJMP, 0);
|
||||
|
|
@ -472,8 +499,8 @@ void luaK_tostack (LexState *ls, expdesc *v, int onlyone) {
|
|||
}
|
||||
}
|
||||
final = luaK_getlabel(fs);
|
||||
luaK_patchlistaux(fs, v->u.l.f, p_nil, OP_ONFJMP, final);
|
||||
luaK_patchlistaux(fs, v->u.l.t, p_1, OP_ONTJMP, final);
|
||||
luaK_patchlistaux(fs, v->u.l.f, p_nil, OP_JMPONF, final);
|
||||
luaK_patchlistaux(fs, v->u.l.t, p_1, OP_JMPONT, final);
|
||||
v->u.l.f = v->u.l.t = NO_JUMP;
|
||||
}
|
||||
}
|
||||
|
|
@ -536,10 +563,10 @@ void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2) {
|
|||
case TK_CONC: luaK_conc(fs); break;
|
||||
case TK_EQ: luaK_eq(fs); break;
|
||||
case TK_NE: luaK_neq(fs); break;
|
||||
case '>': luaK_S(fs, OP_IFGTJMP, 0, -2); break;
|
||||
case '<': luaK_S(fs, OP_IFLTJMP, 0, -2); break;
|
||||
case TK_GE: luaK_S(fs, OP_IFGEJMP, 0, -2); break;
|
||||
case TK_LE: luaK_S(fs, OP_IFLEJMP, 0, -2); break;
|
||||
case '>': luaK_S(fs, OP_JMPGT, 0, -2); break;
|
||||
case '<': luaK_S(fs, OP_JMPLT, 0, -2); break;
|
||||
case TK_GE: luaK_S(fs, OP_JMPGE, 0, -2); break;
|
||||
case TK_LE: luaK_S(fs, OP_JMPLE, 0, -2); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: llimits.h,v 1.3 2000/03/27 20:08:33 roberto Exp roberto $
|
||||
** $Id: llimits.h,v 1.4 2000/03/31 16:28:45 roberto Exp roberto $
|
||||
** Limits, basic types, and some other "instalation-dependent" definitions
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -69,14 +69,12 @@ typedef unsigned long Instruction;
|
|||
|
||||
#define SIZE_U (SIZE_INSTRUCTION-SIZE_OP)
|
||||
#define POS_U SIZE_OP
|
||||
#define SIZE_S (SIZE_INSTRUCTION-SIZE_OP)
|
||||
#define POS_S SIZE_OP
|
||||
#define POS_B SIZE_OP
|
||||
#define SIZE_A (SIZE_INSTRUCTION-(SIZE_OP+SIZE_B))
|
||||
#define POS_A (SIZE_OP+SIZE_B)
|
||||
|
||||
#define MAXARG_U ((1<<SIZE_U)-1)
|
||||
#define MAXARG_S ((1<<(SIZE_S-1))-1) /* `S' is signed */
|
||||
#define MAXARG_S (MAXARG_U>>1) /* `S' is signed */
|
||||
#define MAXARG_A ((1<<SIZE_A)-1)
|
||||
#define MAXARG_B ((1<<SIZE_B)-1)
|
||||
|
||||
|
|
|
|||
75
lopcodes.h
75
lopcodes.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lopcodes.h,v 1.52 2000/03/24 19:49:23 roberto Exp roberto $
|
||||
** $Id: lopcodes.h,v 1.53 2000/03/27 14:31:12 roberto Exp roberto $
|
||||
** Opcodes for Lua virtual machine
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -13,26 +13,30 @@
|
|||
/*===========================================================================
|
||||
We assume that instructions are unsigned numbers.
|
||||
All instructions have an opcode in the first 6 bits. Moreover,
|
||||
an instruction can have 0, 1, or 2 arguments. There are 4 types of
|
||||
Instructions:
|
||||
an instruction can have 0, 1, or 2 arguments. Instructions can
|
||||
have the following types:
|
||||
type 0: no arguments
|
||||
type 1: 1 unsigned argument in the higher bits (called `U')
|
||||
type 2: 1 signed argument in the higher bits (`S')
|
||||
type 3: 1st unsigned argument in the higher bits (`A')
|
||||
2nd unsigned argument in the middle bits (`B')
|
||||
|
||||
The signed argument is represented in excess 2^K; that is, the number
|
||||
value is the usigned value minus 2^K.
|
||||
A signed argument is represented in excess K; that is, the number
|
||||
value is the unsigned value minus K. K is exactly the maximum value
|
||||
for that argument (so that -max is represented by 0, and +max is
|
||||
represented by 2*max), which is half the maximum for the corresponding
|
||||
unsigned argument.
|
||||
|
||||
The size of each argument is defined in `llimits.h'. The usual is an
|
||||
instruction with 32 bits, U and S arguments with 26 bits (32-6), B
|
||||
argument with 9 bits, and A argument with 17 bits (32-6-9). For small
|
||||
instalations, the instruction size can be 16, so U and S have 10 bits,
|
||||
instruction with 32 bits, U arguments with 26 bits (32-6), B arguments
|
||||
with 9 bits, and A arguments with 17 bits (32-6-9). For small
|
||||
instalations, the instruction size can be 16, so U has 10 bits,
|
||||
and A and B have 5 bits each.
|
||||
===========================================================================*/
|
||||
|
||||
|
||||
#define EXCESS_S (1<<(SIZE_S-1)) /* == 2^K */
|
||||
|
||||
#define MAXARG_sA (MAXARG_A>>1) /* max value for a signed A */
|
||||
|
||||
|
||||
/* creates a mask with `n' 1 bits at position `p' */
|
||||
|
|
@ -45,27 +49,33 @@
|
|||
** the following macros help to manipulate instructions
|
||||
*/
|
||||
|
||||
#define CREATE_0(o) ((Instruction)(o))
|
||||
#define GET_OPCODE(i) ((OpCode)((i)&MASK1(SIZE_OP,0)))
|
||||
#define GETARG_U(i) ((int)((i)>>POS_U))
|
||||
#define GETARG_S(i) ((int)((i)>>POS_S)-EXCESS_S)
|
||||
#define GETARG_A(i) ((int)((i)>>POS_A))
|
||||
#define GETARG_B(i) ((int)(((i)>>POS_B) & MASK1(SIZE_B,0)))
|
||||
|
||||
#define SET_OPCODE(i,o) ((i) = (((i)&MASK0(SIZE_OP,0)) | (Instruction)(o)))
|
||||
|
||||
#define CREATE_U(o,u) ((Instruction)(o) | (Instruction)(u)<<POS_U)
|
||||
#define GETARG_U(i) ((int)((i)>>POS_U))
|
||||
#define SETARG_U(i,u) ((i) = (((i)&MASK0(SIZE_U,POS_U)) | \
|
||||
((Instruction)(u)<<POS_U)))
|
||||
#define SETARG_S(i,s) ((i) = (((i)&MASK0(SIZE_S,POS_S)) | \
|
||||
((Instruction)((s)+EXCESS_S)<<POS_S)))
|
||||
|
||||
#define CREATE_S(o,s) CREATE_U((o),(s)+MAXARG_S)
|
||||
#define GETARG_S(i) (GETARG_U(i)-MAXARG_S)
|
||||
#define SETARG_S(i,s) SETARG_U((i),(s)+MAXARG_S)
|
||||
|
||||
|
||||
#define CREATE_AB(o,a,b) ((Instruction)(o) | ((Instruction)(a)<<POS_A) \
|
||||
| ((Instruction)(b)<<POS_B))
|
||||
#define GETARG_A(i) ((int)((i)>>POS_A))
|
||||
#define SETARG_A(i,a) ((i) = (((i)&MASK0(SIZE_A,POS_A)) | \
|
||||
((Instruction)(a)<<POS_A)))
|
||||
#define GETARG_B(i) ((int)(((i)>>POS_B) & MASK1(SIZE_B,0)))
|
||||
#define SETARG_B(i,b) ((i) = (((i)&MASK0(SIZE_B,POS_B)) | \
|
||||
((Instruction)(b)<<POS_B)))
|
||||
|
||||
#define CREATE_0(o) ((Instruction)(o))
|
||||
#define CREATE_U(o,u) ((Instruction)(o) | (Instruction)(u)<<POS_U)
|
||||
#define CREATE_S(o,s) ((Instruction)(o) | ((Instruction)(s)+EXCESS_S)<<POS_S)
|
||||
#define CREATE_AB(o,a,b) ((Instruction)(o) | ((Instruction)(a)<<POS_A) \
|
||||
| ((Instruction)(b)<<POS_B))
|
||||
|
||||
#define CREATE_sAB(o,a,b) (CREATE_AB((o),(a)+MAXARG_sA,(b)))
|
||||
#define GETARG_sA(i) (GETARG_A(i)-MAXARG_sA)
|
||||
|
||||
|
||||
|
||||
/*
|
||||
|
|
@ -112,6 +122,7 @@ OP_SETTABLE,/* U v a_u-a_1 i t a_u-a_1 i t t[i]=v */
|
|||
OP_SETLIST,/* A B v_b-v_0 t t t[i+a*FPF]=v_i */
|
||||
OP_SETMAP,/* U v_u k_u - v_0 k_0 t t t[k_i]=v_i */
|
||||
|
||||
OP_INCLOCAL,/* sA B - - LOC[B]+=sA */
|
||||
OP_ADD,/* - y x x+y */
|
||||
OP_ADDI,/* S x x+s */
|
||||
OP_SUB,/* - y x x-y */
|
||||
|
|
@ -122,17 +133,17 @@ OP_CONC,/* U v_u-v_1 v1..-..v_u */
|
|||
OP_MINUS,/* - x -x */
|
||||
OP_NOT,/* - x (x==nil)? 1 : nil */
|
||||
|
||||
OP_IFNEQJMP,/* J y x - (x~=y)? PC+=s */
|
||||
OP_IFEQJMP,/* J y x - (x==y)? PC+=s */
|
||||
OP_IFLTJMP,/* J y x - (x<y)? PC+=s */
|
||||
OP_IFLEJMP,/* J y x - (x<y)? PC+=s */
|
||||
OP_IFGTJMP,/* J y x - (x>y)? PC+=s */
|
||||
OP_IFGEJMP,/* J y x - (x>=y)? PC+=s */
|
||||
OP_JMPNEQ,/* J y x - (x~=y)? PC+=s */
|
||||
OP_JMPEQ,/* J y x - (x==y)? PC+=s */
|
||||
OP_JMPLT,/* J y x - (x<y)? PC+=s */
|
||||
OP_JMPLE,/* J y x - (x<y)? PC+=s */
|
||||
OP_JMPGT,/* J y x - (x>y)? PC+=s */
|
||||
OP_JMPGE,/* J y x - (x>=y)? PC+=s */
|
||||
|
||||
OP_IFTJMP,/* J x - (x!=nil)? PC+=s */
|
||||
OP_IFFJMP,/* J x - (x==nil)? PC+=s */
|
||||
OP_ONTJMP,/* J x (x!=nil)? x : - (x!=nil)? PC+=s */
|
||||
OP_ONFJMP,/* J x (x==nil)? x : - (x==nil)? PC+=s */
|
||||
OP_JMPT,/* J x - (x!=nil)? PC+=s */
|
||||
OP_JMPF,/* J x - (x==nil)? PC+=s */
|
||||
OP_JMPONT,/* J x (x!=nil)? x : - (x!=nil)? PC+=s */
|
||||
OP_JMPONF,/* J x (x==nil)? x : - (x==nil)? PC+=s */
|
||||
OP_JMP,/* J - - PC+=s */
|
||||
|
||||
OP_PUSHNILJMP,/* - - nil PC++; */
|
||||
|
|
@ -145,7 +156,7 @@ OP_SETLINE/* U - - LINE=u */
|
|||
|
||||
|
||||
|
||||
#define ISJUMP(o) (OP_IFNEQJMP <= (o) && (o) <= OP_JMP)
|
||||
#define ISJUMP(o) (OP_JMPNEQ <= (o) && (o) <= OP_JMP)
|
||||
|
||||
|
||||
#endif
|
||||
|
|
|
|||
41
lvm.c
41
lvm.c
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
** $Id: lvm.c,v 1.97 2000/03/27 20:10:21 roberto Exp roberto $
|
||||
** $Id: lvm.c,v 1.98 2000/03/29 20:19:20 roberto Exp roberto $
|
||||
** Lua virtual machine
|
||||
** See Copyright Notice in lua.h
|
||||
*/
|
||||
|
|
@ -365,9 +365,9 @@ StkId luaV_execute (lua_State *L, const Closure *cl, register StkId base) {
|
|||
case OP_PUSHNIL: {
|
||||
int n = GETARG_U(i);
|
||||
LUA_ASSERT(L, n>0, "invalid argument");
|
||||
do {
|
||||
do {
|
||||
ttype(top++) = TAG_NIL;
|
||||
} while (--n > 0);
|
||||
} while (--n > 0);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -491,6 +491,21 @@ StkId luaV_execute (lua_State *L, const Closure *cl, register StkId base) {
|
|||
top--;
|
||||
break;
|
||||
|
||||
case OP_INCLOCAL: {
|
||||
TObject *var = base+GETARG_B(i);
|
||||
int n = GETARG_sA(i);
|
||||
if (tonumber(var)) {
|
||||
*top = *var; /* PUSHLOCAL */
|
||||
ttype(top+1) = TAG_NUMBER;
|
||||
nvalue(top+1) = (Number)n; /* PUSHINT */
|
||||
call_arith(L, top+2, IM_ADD);
|
||||
*var = *top; /* SETLOCAL */
|
||||
}
|
||||
else
|
||||
nvalue(var) += (Number)n;
|
||||
break;
|
||||
}
|
||||
|
||||
case OP_ADDI:
|
||||
if (tonumber(top-1)) {
|
||||
ttype(top) = TAG_NUMBER;
|
||||
|
|
@ -554,50 +569,50 @@ StkId luaV_execute (lua_State *L, const Closure *cl, register StkId base) {
|
|||
nvalue(top-1) = 1;
|
||||
break;
|
||||
|
||||
case OP_IFNEQJMP:
|
||||
case OP_JMPNEQ:
|
||||
top -= 2;
|
||||
if (!luaO_equalObj(top, top+1)) pc += GETARG_S(i);
|
||||
break;
|
||||
|
||||
case OP_IFEQJMP:
|
||||
case OP_JMPEQ:
|
||||
top -= 2;
|
||||
if (luaO_equalObj(top, top+1)) pc += GETARG_S(i);
|
||||
break;
|
||||
|
||||
case OP_IFLTJMP:
|
||||
case OP_JMPLT:
|
||||
top -= 2;
|
||||
if (luaV_lessthan(L, top, top+1, top+2)) pc += GETARG_S(i);
|
||||
break;
|
||||
|
||||
case OP_IFLEJMP: /* a <= b === !(b<a) */
|
||||
case OP_JMPLE: /* a <= b === !(b<a) */
|
||||
top -= 2;
|
||||
if (!luaV_lessthan(L, top+1, top, top+2)) pc += GETARG_S(i);
|
||||
break;
|
||||
|
||||
case OP_IFGTJMP: /* a > b === (b<a) */
|
||||
case OP_JMPGT: /* a > b === (b<a) */
|
||||
top -= 2;
|
||||
if (luaV_lessthan(L, top+1, top, top+2)) pc += GETARG_S(i);
|
||||
break;
|
||||
|
||||
case OP_IFGEJMP: /* a >= b === !(a<b) */
|
||||
case OP_JMPGE: /* a >= b === !(a<b) */
|
||||
top -= 2;
|
||||
if (!luaV_lessthan(L, top, top+1, top+2)) pc += GETARG_S(i);
|
||||
break;
|
||||
|
||||
case OP_IFTJMP:
|
||||
case OP_JMPT:
|
||||
if (ttype(--top) != TAG_NIL) pc += GETARG_S(i);
|
||||
break;
|
||||
|
||||
case OP_IFFJMP:
|
||||
case OP_JMPF:
|
||||
if (ttype(--top) == TAG_NIL) pc += GETARG_S(i);
|
||||
break;
|
||||
|
||||
case OP_ONTJMP:
|
||||
case OP_JMPONT:
|
||||
if (ttype(top-1) != TAG_NIL) pc += GETARG_S(i);
|
||||
else top--;
|
||||
break;
|
||||
|
||||
case OP_ONFJMP:
|
||||
case OP_JMPONF:
|
||||
if (ttype(top-1) == TAG_NIL) pc += GETARG_S(i);
|
||||
else top--;
|
||||
break;
|
||||
|
|
|
|||
Loading…
Reference in New Issue