new simetric format for ABC instructions, to avoid exchanging operands

for `commutative' operators

7 files changed, 131 insertions, 153 deletions

diff --git a/lcode.c b/lcode.c
index cd976cf0..61ff0701 100644
--- a/lcode.c
+++ b/lcode.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.c,v 1.108 2002/06/13 13:39:55 roberto Exp $
+** $Id: lcode.c,v 1.109 2002/08/05 14:07:34 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -100,14 +100,14 @@ static Instruction *getjumpcontrol (FuncState *fs, int pc) {
 static int need_value (FuncState *fs, int list, int cond) {
   for (; list != NO_JUMP; list = luaK_getjump(fs, list)) {
     Instruction i = *getjumpcontrol(fs, list);
-    if (GET_OPCODE(i) != OP_TEST || GETARG_B(i) != cond) return 1;
+    if (GET_OPCODE(i) != OP_TEST || GETARG_C(i) != cond) return 1;
   }
   return 0;  /* not found */
 }
 
 
 static void patchtestreg (Instruction *i, int reg) {
-  if (reg == NO_REG) reg = GETARG_C(*i);
+  if (reg == NO_REG) reg = GETARG_B(*i);
   SETARG_A(*i, reg);
 }
 
@@ -122,7 +122,7 @@ static void luaK_patchlistaux (FuncState *fs, int list,
       luaK_fixjump(fs, list, dtarget);  /* jump to default target */
     }
     else {
-      if (GETARG_B(*i)) {
+      if (GETARG_C(*i)) {
         lua_assert(ttarget != NO_JUMP);
         patchtestreg(i, treg);
         luaK_fixjump(fs, list, ttarget);
@@ -409,7 +409,7 @@ int luaK_exp2RK (FuncState *fs, expdesc *e) {
     }
     default: break;
   }
-  /* not a constant in the right range: put in a register */
+  /* not a constant in the right range: put it in a register */
   return luaK_exp2anyreg(fs, e);
 }
 
@@ -432,8 +432,8 @@ void luaK_storevar (FuncState *fs, expdesc *var, expdesc *exp) {
       break;
     }
     case VINDEXED: {
-      int e = luaK_exp2anyreg(fs, exp);
-      luaK_codeABC(fs, OP_SETTABLE, e, var->info, var->aux);
+      int e = luaK_exp2RK(fs, exp);
+      luaK_codeABC(fs, OP_SETTABLE, var->info, var->aux, e);
       break;
     }
     default: {
@@ -460,8 +460,9 @@ void luaK_self (FuncState *fs, expdesc *e, expdesc *key) {
 
 static void invertjump (FuncState *fs, expdesc *e) {
   Instruction *pc = getjumpcontrol(fs, e->info);
-  lua_assert(testOpMode(GET_OPCODE(*pc), OpModeT));
-  SETARG_B(*pc, !(GETARG_B(*pc)));
+  lua_assert(testOpMode(GET_OPCODE(*pc), OpModeT) &&
+             GET_OPCODE(*pc) != OP_TEST);
+  SETARG_A(*pc, !(GETARG_A(*pc)));
 }
 
 
@@ -470,13 +471,13 @@ static int jumponcond (FuncState *fs, expdesc *e, int cond) {
     Instruction ie = getcode(fs, e);
     if (GET_OPCODE(ie) == OP_NOT) {
       fs->pc--;  /* remove previous OP_NOT */
-      return luaK_condjump(fs, OP_TEST, NO_REG, !cond ,GETARG_B(ie));
+      return luaK_condjump(fs, OP_TEST, NO_REG, GETARG_B(ie), !cond);
     }
     /* else go through */
   }
   discharge2anyreg(fs, e);
   freeexp(fs, e);
-  return luaK_condjump(fs, OP_TEST, NO_REG, cond, e->info);
+  return luaK_condjump(fs, OP_TEST, NO_REG, e->info, cond);
 }
 
 
@@ -605,11 +606,6 @@ void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
       luaK_exp2nextreg(fs, v);  /* operand must be on the `stack' */
       break;
     }
-    case OPR_SUB: case OPR_DIV: case OPR_POW: {
-      /* non-comutative operators */
-      luaK_exp2anyreg(fs, v);  /* first operand must be a register */
-      break;
-    }
     default: {
       luaK_exp2RK(fs, v);
       break;
@@ -619,13 +615,11 @@ void luaK_infix (FuncState *fs, BinOpr op, expdesc *v) {
 
 
 static void codebinop (FuncState *fs, expdesc *res, BinOpr op,
-                       int o1, int o2, int ic) {
+                       int o1, int o2) {
   switch (op) {
     case OPR_SUB:
     case OPR_DIV:
     case OPR_POW:
-      lua_assert(!ic);
-      /* go through */
     case OPR_ADD:
     case OPR_MULT: {  /* ORDER OPR */
       OpCode opc = cast(OpCode, (op - OPR_ADD) + OP_ADD);
@@ -635,20 +629,21 @@ static void codebinop (FuncState *fs, expdesc *res, BinOpr op,
     }
     case OPR_NE:
     case OPR_EQ: {
-      res->info = luaK_condjump(fs, OP_EQ, o1, (op == OPR_EQ), o2);
+      res->info = luaK_condjump(fs, OP_EQ, (op == OPR_EQ), o1, o2);
       res->k = VJMP;
       break;
     }
-    case OPR_LT:
-    case OPR_LE:
     case OPR_GT:
     case OPR_GE: {  /* ORDER OPR */
-      OpCode opc;
-      int i = op - OPR_LT;
-      if (ic)  /* operands were interchanged? */
-        i = (i+2)&3;  /* correct operator */
-      opc = cast(OpCode, i + OP_LT);
-      res->info = luaK_condjump(fs, opc, o1, 1, o2);
+      int temp;
+      temp = o1; o1 = o2; o2 = temp;  /* o1 <==> o2 */
+      op -= 2;  /* GT -> LT, GE -> LE */
+      /* go through */
+    }
+    case OPR_LT:
+    case OPR_LE: {
+      OpCode opc = cast(OpCode, (op - OPR_LT) + OP_LT);
+      res->info = luaK_condjump(fs, opc, 1, o1, o2);
       res->k = VJMP;
       break;
     }
@@ -691,21 +686,11 @@ void luaK_posfix (FuncState *fs, BinOpr op, expdesc *e1, expdesc *e2) {
       break;
     }
     default: {
-      int o1, o2;
-      int ic;  /* interchange flag */
-      if (e1->k != VK) {  /* not a constant operator? */
-        o1 = e1->info;
-        o2 = luaK_exp2RK(fs, e2);  /* maybe other operator is constant... */
-        ic = 0;
-      }
-      else {  /* interchange operands */
-        o2 = luaK_exp2RK(fs, e1);  /* constant must be 2nd operand */
-        o1 = luaK_exp2anyreg(fs, e2);  /* other operator must be in register */
-        ic = 1;
-      }
+      int o1 = luaK_exp2RK(fs, e1);
+      int o2 = luaK_exp2RK(fs, e2);
       freeexp(fs, e2);
       freeexp(fs, e1);
-      codebinop(fs, e1, op, o1, o2, ic);
+      codebinop(fs, e1, op, o1, o2);
     }
   }
 }
diff --git a/ldebug.c b/ldebug.c
index d4d0eb00..55c53f9d 100644
--- a/ldebug.c
+++ b/ldebug.c
@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.c,v 1.131 2002/08/08 20:08:41 roberto Exp roberto $
+** $Id: ldebug.c,v 1.132 2002/08/12 17:23:12 roberto Exp roberto $
 ** Debug Interface
 ** See Copyright Notice in lua.h
 */
@@ -269,6 +269,11 @@ static int checkopenop (const Proto *pt, int pc) {
 }
 
 
+static int checkRK (const Proto *pt, int r) {
+  return (r < pt->maxstacksize || (r >= MAXSTACK && r-MAXSTACK < pt->sizek));
+}
+
+
 static Instruction luaG_symbexec (const Proto *pt, int lastpc, int reg) {
   int pc;
   int last;  /* stores position of last instruction that changed `reg' */
@@ -285,11 +290,13 @@ static Instruction luaG_symbexec (const Proto *pt, int lastpc, int reg) {
       case iABC: {
         b = GETARG_B(i);
         c = GETARG_C(i);
-        if (testOpMode(op, OpModeBreg))
+        if (testOpMode(op, OpModeBreg)) {
           checkreg(pt, b);
-        if (testOpMode(op, OpModeCreg))
-          check(c < pt->maxstacksize ||
-               (c >= MAXSTACK && c-MAXSTACK < pt->sizek));
+        }
+        else if (testOpMode(op, OpModeBrk))
+          check(checkRK(pt, b));
+        if (testOpMode(op, OpModeCrk))
+          check(checkRK(pt, c));
         break;
       }
       case iABx: {
@@ -496,7 +503,7 @@ void luaG_concaterror (lua_State *L, StkId p1, StkId p2) {
 }
 
 
-void luaG_aritherror (lua_State *L, StkId p1, const TObject *p2) {
+void luaG_aritherror (lua_State *L, const TObject *p1, const TObject *p2) {
   TObject temp;
   if (luaV_tonumber(p1, &temp) == NULL)
     p2 = p1;  /* first operand is wrong */
diff --git a/ldebug.h b/ldebug.h
index 19be8fee..e0d0a097 100644
--- a/ldebug.h
+++ b/ldebug.h
@@ -1,5 +1,5 @@
 /*
-** $Id: ldebug.h,v 1.29 2002/08/08 20:08:41 roberto Exp roberto $
+** $Id: ldebug.h,v 1.30 2002/08/12 17:23:12 roberto Exp roberto $
 ** Auxiliary functions from Debug Interface module
 ** See Copyright Notice in lua.h
 */
@@ -23,7 +23,7 @@
 
 void luaG_typeerror (lua_State *L, const TObject *o, const char *opname);
 void luaG_concaterror (lua_State *L, StkId p1, StkId p2);
-void luaG_aritherror (lua_State *L, StkId p1, const TObject *p2);
+void luaG_aritherror (lua_State *L, const TObject *p1, const TObject *p2);
 int luaG_ordererror (lua_State *L, const TObject *p1, const TObject *p2);
 void luaG_runerror (lua_State *L, const char *fmt, ...);
 void luaG_errormsg (lua_State *L);
diff --git a/lopcodes.c b/lopcodes.c
index 767c6bd5..8dd3bee3 100644
--- a/lopcodes.c
+++ b/lopcodes.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.c,v 1.19 2002/05/13 13:09:00 roberto Exp roberto $
+** $Id: lopcodes.c,v 1.20 2002/06/12 14:51:31 roberto Exp roberto $
 ** extracted automatically from lopcodes.h by mkprint.lua
 ** DO NOT EDIT
 ** See Copyright Notice in lua.h
@@ -39,8 +39,6 @@ const char *const luaP_opnames[] = {
   "EQ",
   "LT",
   "LE",
-  "GT",
-  "GE",
   "TEST",
   "CALL",
   "TAILCALL",
@@ -56,49 +54,47 @@ const char *const luaP_opnames[] = {
 
 #endif
 
-#define opmode(t,x,b,c,sa,k,m) (((t)<<OpModeT) | \
-   ((b)<<OpModeBreg) | ((c)<<OpModeCreg) | \
+#define opmode(t,b,bk,ck,sa,k,m) (((t)<<OpModeT) | \
+   ((b)<<OpModeBreg) | ((bk)<<OpModeBrk) | ((ck)<<OpModeCrk) | \
    ((sa)<<OpModesetA) | ((k)<<OpModeK) | (m))
 
 
 const lu_byte luaP_opmodes[NUM_OPCODES] = {
-/*       T _ B C sA K mode                 opcode    */
-  opmode(0,0,1,0, 1,0,iABC)             /* OP_MOVE */
- ,opmode(0,0,0,0, 1,1,iABx)             /* OP_LOADK */
- ,opmode(0,0,0,0, 1,0,iABC)             /* OP_LOADBOOL */
- ,opmode(0,0,1,0, 1,0,iABC)             /* OP_LOADNIL */
- ,opmode(0,0,0,0, 1,0,iABC)             /* OP_GETUPVAL */
- ,opmode(0,0,0,0, 1,1,iABx)             /* OP_GETGLOBAL */
- ,opmode(0,0,1,1, 1,0,iABC)             /* OP_GETTABLE */
- ,opmode(0,0,0,0, 0,1,iABx)             /* OP_SETGLOBAL */
- ,opmode(0,0,0,0, 0,0,iABC)             /* OP_SETUPVAL */
- ,opmode(0,0,1,1, 0,0,iABC)             /* OP_SETTABLE */
- ,opmode(0,0,0,0, 1,0,iABC)             /* OP_NEWTABLE */
- ,opmode(0,0,1,1, 1,0,iABC)             /* OP_SELF */
- ,opmode(0,0,1,1, 1,0,iABC)             /* OP_ADD */
- ,opmode(0,0,1,1, 1,0,iABC)             /* OP_SUB */
- ,opmode(0,0,1,1, 1,0,iABC)             /* OP_MUL */
- ,opmode(0,0,1,1, 1,0,iABC)             /* OP_DIV */
- ,opmode(0,0,1,1, 1,0,iABC)             /* OP_POW */
- ,opmode(0,0,1,0, 1,0,iABC)             /* OP_UNM */
- ,opmode(0,0,1,0, 1,0,iABC)             /* OP_NOT */
- ,opmode(0,0,1,1, 1,0,iABC)             /* OP_CONCAT */
- ,opmode(0,0,0,0, 0,0,iAsBx)            /* OP_JMP */
- ,opmode(1,0,0,1, 0,0,iABC)             /* OP_EQ */
- ,opmode(1,0,0,1, 0,0,iABC)             /* OP_LT */
- ,opmode(1,0,0,1, 0,0,iABC)             /* OP_LE */
- ,opmode(1,0,0,1, 0,0,iABC)             /* OP_GT */
- ,opmode(1,0,0,1, 0,0,iABC)             /* OP_GE */
- ,opmode(1,0,0,1, 1,0,iABC)             /* OP_TEST */
- ,opmode(0,0,0,0, 0,0,iABC)             /* OP_CALL */
- ,opmode(0,0,0,0, 0,0,iABC)             /* OP_TAILCALL */
- ,opmode(0,0,0,0, 0,0,iABC)             /* OP_RETURN */
- ,opmode(0,0,0,0, 0,0,iAsBx)            /* OP_FORLOOP */
- ,opmode(1,0,0,0, 0,0,iABC)             /* OP_TFORLOOP */
- ,opmode(0,0,0,0, 0,0,iAsBx)            /* OP_TFORPREP */
- ,opmode(0,0,0,0, 0,0,iABx)             /* OP_SETLIST */
- ,opmode(0,0,0,0, 0,0,iABx)             /* OP_SETLISTO */
- ,opmode(0,0,0,0, 0,0,iABC)             /* OP_CLOSE */
- ,opmode(0,0,0,0, 1,0,iABx)             /* OP_CLOSURE */
+/*       T  B Bk Ck sA  K  mode                    opcode    */
+  opmode(0, 1, 0, 0, 1, 0, iABC)                /* OP_MOVE */
+ ,opmode(0, 0, 0, 0, 1, 1, iABx)                /* OP_LOADK */
+ ,opmode(0, 0, 0, 0, 1, 0, iABC)                /* OP_LOADBOOL */
+ ,opmode(0, 1, 0, 0, 1, 0, iABC)                /* OP_LOADNIL */
+ ,opmode(0, 0, 0, 0, 1, 0, iABC)                /* OP_GETUPVAL */
+ ,opmode(0, 0, 0, 0, 1, 1, iABx)                /* OP_GETGLOBAL */
+ ,opmode(0, 1, 0, 1, 1, 0, iABC)                /* OP_GETTABLE */
+ ,opmode(0, 0, 0, 0, 0, 1, iABx)                /* OP_SETGLOBAL */
+ ,opmode(0, 0, 0, 0, 0, 0, iABC)                /* OP_SETUPVAL */
+ ,opmode(0, 0, 1, 1, 0, 0, iABC)                /* OP_SETTABLE */
+ ,opmode(0, 0, 0, 0, 1, 0, iABC)                /* OP_NEWTABLE */
+ ,opmode(0, 1, 0, 1, 1, 0, iABC)                /* OP_SELF */
+ ,opmode(0, 0, 1, 1, 1, 0, iABC)                /* OP_ADD */
+ ,opmode(0, 0, 1, 1, 1, 0, iABC)                /* OP_SUB */
+ ,opmode(0, 0, 1, 1, 1, 0, iABC)                /* OP_MUL */
+ ,opmode(0, 0, 1, 1, 1, 0, iABC)                /* OP_DIV */
+ ,opmode(0, 0, 1, 1, 1, 0, iABC)                /* OP_POW */
+ ,opmode(0, 1, 0, 0, 1, 0, iABC)                /* OP_UNM */
+ ,opmode(0, 1, 0, 0, 1, 0, iABC)                /* OP_NOT */
+ ,opmode(0, 1, 0, 1, 1, 0, iABC)                /* OP_CONCAT */
+ ,opmode(0, 0, 0, 0, 0, 0, iAsBx)               /* OP_JMP */
+ ,opmode(1, 0, 1, 1, 0, 0, iABC)                /* OP_EQ */
+ ,opmode(1, 0, 1, 1, 0, 0, iABC)                /* OP_LT */
+ ,opmode(1, 0, 1, 1, 0, 0, iABC)                /* OP_LE */
+ ,opmode(1, 1, 0, 0, 1, 0, iABC)                /* OP_TEST */
+ ,opmode(0, 0, 0, 0, 0, 0, iABC)                /* OP_CALL */
+ ,opmode(0, 0, 0, 0, 0, 0, iABC)                /* OP_TAILCALL */
+ ,opmode(0, 0, 0, 0, 0, 0, iABC)                /* OP_RETURN */
+ ,opmode(0, 0, 0, 0, 0, 0, iAsBx)               /* OP_FORLOOP */
+ ,opmode(1, 0, 0, 0, 0, 0, iABC)                /* OP_TFORLOOP */
+ ,opmode(0, 0, 0, 0, 0, 0, iAsBx)               /* OP_TFORPREP */
+ ,opmode(0, 0, 0, 0, 0, 0, iABx)                /* OP_SETLIST */
+ ,opmode(0, 0, 0, 0, 0, 0, iABx)                /* OP_SETLISTO */
+ ,opmode(0, 0, 0, 0, 0, 0, iABC)                /* OP_CLOSE */
+ ,opmode(0, 0, 0, 0, 1, 0, iABx)                /* OP_CLOSURE */
 };
 
diff --git a/lopcodes.h b/lopcodes.h
index f2d5b10b..7c695324 100644
--- a/lopcodes.h
+++ b/lopcodes.h
@@ -1,5 +1,5 @@
 /*
-** $Id: lopcodes.h,v 1.99 2002/06/12 14:51:31 roberto Exp $
+** $Id: lopcodes.h,v 1.100 2002/08/05 14:46:43 roberto Exp roberto $
 ** Opcodes for Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -14,9 +14,9 @@
   We assume that instructions are unsigned numbers.
   All instructions have an opcode in the first 6 bits.
   Instructions can have the following fields:
-        `A' : 8 bits (25-32)
-        `B' : 8 bits (17-24)
-        `C' : 10 bits (7-16)
+        `A' : 8 bits
+        `B' : 9 bits
+        `C' : 9 bits
         `Bx' : 18 bits (`B' and `C' together)
         `sBx' : signed Bx
 
@@ -34,8 +34,8 @@ enum OpMode {iABC, iABx, iAsBx};  /* basic instruction format */
 /*
 ** size and position of opcode arguments.
 */
-#define SIZE_C          10
-#define SIZE_B          8
+#define SIZE_C          9
+#define SIZE_B          9
 #define SIZE_Bx         (SIZE_C + SIZE_B)
 #define SIZE_A          8
 
@@ -112,16 +112,15 @@ enum OpMode {iABC, iABx, iAsBx};  /* basic instruction format */
 
 
 /*
-** invalid registers that fits in 8 bits
+** invalid register that fits in 8 bits
 */
 #define NO_REG          MAXARG_A
-#define NO_REG1         (NO_REG+1)
 
 
 /*
 ** R(x) - register
 ** Kst(x) - constant (in constant table)
-** R/K(x) == if x < MAXSTACK then R(x) else Kst(x-MAXSTACK)
+** RK(x) == if x < MAXSTACK then R(x) else Kst(x-MAXSTACK)
 */
 
 typedef enum {
@@ -135,21 +134,21 @@ OP_LOADNIL,/*	A B	R(A) := ... := R(B) := nil			*/
 OP_GETUPVAL,/*  A B     R(A) := UpValue[B]                              */
 
 OP_GETGLOBAL,/* A Bx    R(A) := Gbl[Kst(Bx)]                            */
-OP_GETTABLE,/*  A B C   R(A) := R(B)[R/K(C)]                            */
+OP_GETTABLE,/*  A B C   R(A) := R(B)[RK(C)]                             */
 
 OP_SETGLOBAL,/* A Bx    Gbl[Kst(Bx)] := R(A)                            */
 OP_SETUPVAL,/*  A B     UpValue[B] := R(A)                              */
-OP_SETTABLE,/*  A B C   R(B)[R/K(C)] := R(A)                            */
+OP_SETTABLE,/*  A B C   R(A)[RK(B)] := RK(C)                            */
 
 OP_NEWTABLE,/*  A B C   R(A) := {} (size = B,C)                         */
 
-OP_SELF,/*      A B C   R(A+1) := R(B); R(A) := R(B)[R/K(C)]            */
+OP_SELF,/*      A B C   R(A+1) := R(B); R(A) := R(B)[RK(C)]             */
 
-OP_ADD,/*       A B C   R(A) := R(B) + R/K(C)                           */
-OP_SUB,/*       A B C   R(A) := R(B) - R/K(C)                           */
-OP_MUL,/*       A B C   R(A) := R(B) * R/K(C)                           */
-OP_DIV,/*       A B C   R(A) := R(B) / R/K(C)                           */
-OP_POW,/*       A B C   R(A) := R(B) ^ R/K(C)                           */
+OP_ADD,/*       A B C   R(A) := RK(B) + RK(C)                           */
+OP_SUB,/*       A B C   R(A) := RK(B) - RK(C)                           */
+OP_MUL,/*       A B C   R(A) := RK(B) * RK(C)                           */
+OP_DIV,/*       A B C   R(A) := RK(B) / RK(C)                           */
+OP_POW,/*       A B C   R(A) := RK(B) ^ RK(C)                           */
 OP_UNM,/*       A B     R(A) := -R(B)                                   */
 OP_NOT,/*       A B     R(A) := not R(B)                                */
 
@@ -157,13 +156,11 @@ OP_CONCAT,/*	A B C	R(A) := R(B).. ... ..R(C)			*/
 
 OP_JMP,/*       sBx     PC += sBx                                       */
 
-OP_EQ,/*        A B C   if ((R(A) == R/K(C)) ~= B) then pc++            */
-OP_LT,/*        A B C   if ((R(A) <  R/K(C)) ~= B) then pc++            */
-OP_LE,/*        A B C   if ((R(A) <= R/K(C)) ~= B) then pc++            */
-OP_GT,/*        A B C   if ((R(A) >  R/K(C)) ~= B) then pc++            */
-OP_GE,/*        A B C   if ((R(A) >= R/K(C)) ~= B) then pc++            */
+OP_EQ,/*        A B C   if ((RK(B) == RK(C)) ~= A) then pc++            */
+OP_LT,/*        A B C   if ((RK(B) <  RK(C)) ~= A) then pc++            */
+OP_LE,/*        A B C   if ((RK(B) <= RK(C)) ~= A) then pc++            */
 
-OP_TEST,/*      A B C   if (R(C) <=> B) then R(A) := R(C) else pc++     */ 
+OP_TEST,/*      A B C   if (R(B) <=> C) then R(A) := R(B) else pc++     */ 
 
 OP_CALL,/*      A B C   R(A), ... ,R(A+C-2) := R(A)(R(A+1), ... ,R(A+B-1)) */
 OP_TAILCALL,/*  A B C   return R(A)(R(A+1), ... ,R(A+B-1))              */
@@ -207,12 +204,15 @@ OP_CLOSURE/*	A Bx	R(A) := closure(KPROTO[Bx], R(A), ... ,R(A+n))	*/
 */  
 enum OpModeMask {
   OpModeBreg = 2,       /* B is a register */
-  OpModeCreg,           /* C is a register/constant */
+  OpModeBrk,            /* B is a register/constant */
+  OpModeCrk,           /* C is a register/constant */
   OpModesetA,           /* instruction set register A */
   OpModeK,              /* Bx is a constant */
   OpModeT               /* operator is a test */
+  
 };
 
+
 extern const lu_byte luaP_opmodes[NUM_OPCODES];
 
 #define getOpMode(m)            (cast(enum OpMode, luaP_opmodes[m] & 3))
diff --git a/lparser.c b/lparser.c
index bca90809..8a82db68 100644
--- a/lparser.c
+++ b/lparser.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.c,v 1.190 2002/07/04 18:23:42 roberto Exp $
+** $Id: lparser.c,v 1.191 2002/08/05 17:35:45 roberto Exp roberto $
 ** Lua Parser
 ** See Copyright Notice in lua.h
 */
@@ -324,7 +324,7 @@ static void open_func (LexState *ls, FuncState *fs) {
   fs->bl = NULL;
   f->code = NULL;
   f->source = ls->source;
-  f->maxstacksize = 1;  /* register 0 is always valid */
+  f->maxstacksize = 2;  /* registers 0/1 are always valid */
   f->numparams = 0;  /* default for main chunk */
   f->is_vararg = 0;  /* default for main chunk */
 }
@@ -489,8 +489,8 @@ static void recfield (LexState *ls, struct ConsControl *cc) {
   check(ls, '=');
   luaK_exp2RK(fs, &key);
   expr(ls, &val);
-  luaK_exp2anyreg(fs, &val);
-  luaK_codeABC(fs, OP_SETTABLE, val.info, cc->t->info, luaK_exp2RK(fs, &key));
+  luaK_codeABC(fs, OP_SETTABLE, cc->t->info, luaK_exp2RK(fs, &key),
+                                             luaK_exp2RK(fs, &val));
   fs->freereg = reg;  /* free registers */
 }
 
@@ -735,7 +735,7 @@ static const struct {
   lu_byte right; /* right priority */
 } priority[] = {  /* ORDER OPR */
    {6, 6}, {6, 6}, {7, 7}, {7, 7},  /* arithmetic */
-   {10, 9}, {5, 4},                  /* power and concat (right associative) */
+   {10, 9}, {5, 4},                 /* power and concat (right associative) */
    {3, 3}, {3, 3},                  /* equality */
    {3, 3}, {3, 3}, {3, 3}, {3, 3},  /* order */
    {2, 2}, {1, 1}                   /* logical (and/or) */
diff --git a/lvm.c b/lvm.c
index fe30a27f..b0184b46 100644
--- a/lvm.c
+++ b/lvm.c
@@ -1,5 +1,5 @@
 /*
-** $Id: lvm.c,v 1.251 2002/08/07 19:22:39 roberto Exp roberto $
+** $Id: lvm.c,v 1.252 2002/08/12 17:23:12 roberto Exp roberto $
 ** Lua virtual machine
 ** See Copyright Notice in lua.h
 */
@@ -318,7 +318,8 @@ void luaV_concat (lua_State *L, int total, int last) {
 }
 
 
-static void Arith (lua_State *L, StkId ra, StkId rb, StkId rc, TMS op) {
+static void Arith (lua_State *L, StkId ra,
+                   const TObject *rb, const TObject *rc, TMS op) {
   TObject tempb, tempc;
   const TObject *b, *c;
   if ((b = luaV_tonumber(rb, &tempb)) != NULL &&
@@ -356,10 +357,9 @@ static void Arith (lua_State *L, StkId ra, StkId rb, StkId rc, TMS op) {
 
 #define RA(i)   (base+GETARG_A(i))
 #define RB(i)   (base+GETARG_B(i))
+#define RKB(i)  ((GETARG_B(i) < MAXSTACK) ? RB(i) : k+GETARG_B(i)-MAXSTACK)
 #define RC(i)   (base+GETARG_C(i))
-#define RKC(i)  ((GETARG_C(i) < MAXSTACK) ? \
-                        base+GETARG_C(i) : \
-                        k+GETARG_C(i)-MAXSTACK)
+#define RKC(i)  ((GETARG_C(i) < MAXSTACK) ? RC(i) : k+GETARG_C(i)-MAXSTACK)
 #define KBx(i)  (k+GETARG_Bx(i))
 
 
@@ -423,7 +423,7 @@ StkId luaV_execute (lua_State *L) {
         break;
       }
       case OP_GETGLOBAL: {
-        StkId rb = KBx(i);
+        TObject *rb = KBx(i);
         const TObject *v;
         lua_assert(ttisstring(rb) && ttistable(&cl->g));
         v = luaH_getstr(hvalue(&cl->g), tsvalue(rb));
@@ -456,7 +456,7 @@ StkId luaV_execute (lua_State *L) {
         break;
       }
       case OP_SETTABLE: {
-        luaV_settable(L, RB(i), RKC(i), ra);
+        luaV_settable(L, ra, RKB(i), RKC(i));
         break;
       }
       case OP_NEWTABLE: {
@@ -482,8 +482,8 @@ StkId luaV_execute (lua_State *L) {
         break;
       }
       case OP_ADD: {
-        StkId rb = RB(i);
-        StkId rc = RKC(i);
+        TObject *rb = RKB(i);
+        TObject *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
           setnvalue(ra, nvalue(rb) + nvalue(rc));
         }
@@ -492,8 +492,8 @@ StkId luaV_execute (lua_State *L) {
         break;
       }
       case OP_SUB: {
-        StkId rb = RB(i);
-        StkId rc = RKC(i);
+        TObject *rb = RKB(i);
+        TObject *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
           setnvalue(ra, nvalue(rb) - nvalue(rc));
         }
@@ -502,8 +502,8 @@ StkId luaV_execute (lua_State *L) {
         break;
       }
       case OP_MUL: {
-        StkId rb = RB(i);
-        StkId rc = RKC(i);
+        TObject *rb = RKB(i);
+        TObject *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
           setnvalue(ra, nvalue(rb) * nvalue(rc));
         }
@@ -512,8 +512,8 @@ StkId luaV_execute (lua_State *L) {
         break;
       }
       case OP_DIV: {
-        StkId rb = RB(i);
-        StkId rc = RKC(i);
+        TObject *rb = RKB(i);
+        TObject *rc = RKC(i);
         if (ttisnumber(rb) && ttisnumber(rc)) {
           setnvalue(ra, nvalue(rb) / nvalue(rc));
         }
@@ -522,7 +522,7 @@ StkId luaV_execute (lua_State *L) {
         break;
       }
       case OP_POW: {
-        Arith(L, ra, RB(i), RKC(i), TM_POW);
+        Arith(L, ra, RKB(i), RKC(i), TM_POW);
         break;
       }
       case OP_UNM: {
@@ -556,35 +556,25 @@ StkId luaV_execute (lua_State *L) {
         break;
       }
       case OP_EQ: {  /* skip next instruction if test fails */
-        if (equalobj(L, ra, RKC(i)) != GETARG_B(i)) pc++;
+        if (equalobj(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;
         else dojump(pc, GETARG_sBx(*pc) + 1);
         break;
       }
       case OP_LT: {
-        if (luaV_lessthan(L, ra, RKC(i)) != GETARG_B(i)) pc++;
+        if (luaV_lessthan(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;
         else dojump(pc, GETARG_sBx(*pc) + 1);
         break;
       }
       case OP_LE: {
-        if (luaV_lessequal(L, ra, RKC(i)) != GETARG_B(i)) pc++;
-        else dojump(pc, GETARG_sBx(*pc) + 1);
-        break;
-      }
-      case OP_GT: {
-        if (luaV_lessthan(L, RKC(i), ra) != GETARG_B(i)) pc++;
-        else dojump(pc, GETARG_sBx(*pc) + 1);
-        break;
-      }
-      case OP_GE: {
-        if (luaV_lessequal(L, RKC(i), ra) != GETARG_B(i)) pc++;
+        if (luaV_lessequal(L, RKB(i), RKC(i)) != GETARG_A(i)) pc++;
         else dojump(pc, GETARG_sBx(*pc) + 1);
         break;
       }
       case OP_TEST: {
-        StkId rc = RKC(i);
-        if (l_isfalse(rc) == GETARG_B(i)) pc++;
+        TObject *rb = RB(i);
+        if (l_isfalse(rb) == GETARG_C(i)) pc++;
         else {
-          setobj(ra, rc);
+          setobj(ra, rb);
           dojump(pc, GETARG_sBx(*pc) + 1);
         }
         break;