1 files changed, 44 insertions, 33 deletions

diff --git a/lopcodes.h b/lopcodes.h
index 71a712f2..e93f8c35 100644
--- a/lopcodes.h
+++ b/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_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_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_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