better code for unary/binary operators

lcode.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.c,v 1.43 2000/08/08 18:26:05 roberto Exp roberto $
+** $Id: lcode.c,v 1.44 2000/08/08 20:42:07 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -348,9 +348,9 @@ void luaK_tostack (LexState *ls, expdesc *v, int onlyone) {
 }
 
 
-void luaK_prefix (LexState *ls, int op, expdesc *v) {
+void luaK_prefix (LexState *ls, UnOpr op, expdesc *v) {
   FuncState *fs = ls->fs;
-  if (op == '-') {
+  if (op == OPR_MINUS) {
     luaK_tostack(ls, v, 1);
     luaK_code0(fs, OP_MINUS);
   }
@@ -368,46 +368,54 @@ void luaK_prefix (LexState *ls, int op, expdesc *v) {
 }
 
 
-void luaK_infix (LexState *ls, int op, expdesc *v) {
+void luaK_infix (LexState *ls, BinOpr op, expdesc *v) {
   FuncState *fs = ls->fs;
-  if (op == TK_AND)
+  switch (op) {
+    case OPR_AND:
       luaK_goiftrue(fs, v, 1);
-  else if (op == TK_OR)
+      break;
+    case OPR_OR:
       luaK_goiffalse(fs, v, 1);
-  else
+      break;
+    default:
       luaK_tostack(ls, v, 1);  /* all other binary operators need a value */
+  }
 }
 
 
-void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2) {
+
+static const struct {
+  OpCode opcode;  /* opcode for each binary operator */
+  int arg;        /* default argument for the opcode */
+} codes[] = {  /* ORDER OPR */
+      {OP_ADD, 0}, {OP_SUB, 0}, {OP_MULT, 0}, {OP_DIV, 0},
+      {OP_POW, 0}, {OP_CONCAT, 2},
+      {OP_JMPNE, NO_JUMP}, {OP_JMPEQ, NO_JUMP},
+      {OP_JMPLT, NO_JUMP}, {OP_JMPLE, NO_JUMP},
+      {OP_JMPGT, NO_JUMP}, {OP_JMPGE, NO_JUMP}
+};
+
+
+void luaK_posfix (LexState *ls, BinOpr op, expdesc *v1, expdesc *v2) {
   FuncState *fs = ls->fs;
-  if (op == TK_AND) {
+  switch (op) {
+    case OPR_AND: {
       LUA_ASSERT(v1->u.l.t == NO_JUMP, "list must be closed");
       discharge1(fs, v2);
       v1->u.l.t = v2->u.l.t;
       luaK_concat(fs, &v1->u.l.f, v2->u.l.f);
+      break;
     }
-  else if (op == TK_OR) {
+    case OPR_OR: {
       LUA_ASSERT(v1->u.l.f == NO_JUMP, "list must be closed");
       discharge1(fs, v2);
       v1->u.l.f = v2->u.l.f;
       luaK_concat(fs, &v1->u.l.t, v2->u.l.t);
+      break;
     }
-  else {
+    default: {
       luaK_tostack(ls, v2, 1);  /* `v2' must be a value */
-    switch (op) {
+      luaK_code1(fs, codes[op].opcode, codes[op].arg);
-      case '+': luaK_code0(fs, OP_ADD); break;
-      case '-': luaK_code0(fs, OP_SUB); break;
-      case '*': luaK_code0(fs, OP_MULT); break;
-      case '/': luaK_code0(fs, OP_DIV); break;
-      case '^': luaK_code0(fs, OP_POW); break;
-      case TK_CONCAT: luaK_code1(fs, OP_CONCAT, 2); break;
-      case TK_EQ: luaK_code1(fs, OP_JMPEQ, NO_JUMP); break;
-      case TK_NE: luaK_code1(fs, OP_JMPNE, NO_JUMP); break;
-      case '>': luaK_code1(fs, OP_JMPGT, NO_JUMP); break;
-      case '<': luaK_code1(fs, OP_JMPLT, NO_JUMP); break;
-      case TK_GE: luaK_code1(fs, OP_JMPGE, NO_JUMP); break;
-      case TK_LE: luaK_code1(fs, OP_JMPLE, NO_JUMP); break;
     }
   }
 }

lcode.h

@@ -1,5 +1,5 @@
 /*
-** $Id: lcode.h,v 1.14 2000/06/16 17:51:40 roberto Exp roberto $
+** $Id: lcode.h,v 1.15 2000/06/28 20:20:36 roberto Exp roberto $
 ** Code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -20,6 +20,20 @@
 #define NO_JUMP (-1)
 
 
+/*
+** grep "ORDER OPR" if you change these enums
+*/
+typedef enum BinOpr {
+  OPR_ADD, OPR_SUB, OPR_MULT, OPR_DIV, OPR_POW,
+  OPR_CONCAT,
+  OPR_NE, OPR_EQ, OPR_LT, OPR_LE, OPR_GT, OPR_GE,
+  OPR_AND, OPR_OR,
+  OPR_NOBINOPR
+} BinOpr;
+
+typedef enum UnOpr { OPR_MINUS, OPR_NOT, OPR_NOUNOPR } UnOpr;
+
+
 enum Mode {iO, iU, iS, iAB};  /* instruction format */
 
 #define VD	100	/* flag for variable delta */
@@ -48,9 +62,9 @@ int luaK_lastisopen (FuncState *fs);
 void luaK_setcallreturns (FuncState *fs, int nresults);
 void luaK_tostack (LexState *ls, expdesc *v, int onlyone);
 void luaK_storevar (LexState *ls, const expdesc *var);
-void luaK_prefix (LexState *ls, int op, expdesc *v);
+void luaK_prefix (LexState *ls, UnOpr op, expdesc *v);
-void luaK_infix (LexState *ls, int op, expdesc *v);
+void luaK_infix (LexState *ls, BinOpr op, expdesc *v);
-void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2);
+void luaK_posfix (LexState *ls, BinOpr op, expdesc *v1, expdesc *v2);
 
 
 #endif

lparser.c

@@ -1,5 +1,5 @@
 /*
-** $Id: lparser.c,v 1.104 2000/08/08 20:42:07 roberto Exp roberto $
+** $Id: lparser.c,v 1.105 2000/08/08 20:48:55 roberto Exp roberto $
 ** LL(1) Parser and code generator for Lua
 ** See Copyright Notice in lua.h
 */
@@ -670,55 +670,76 @@ static void exp1 (LexState *ls) {
 }
 
 
-/*
+static UnOpr getunopr (int op) {
-** gets priorities of an operator. Returns the priority to the left, and
-** sets `rp' to the priority to the right.
-*/
-static int get_priority (int op, int *rp) {
   switch (op) {
-
+    case TK_NOT: return OPR_NOT;
-    case  '^': *rp = 8; return 9;  /* right associative */
+    case '-': return OPR_MINUS;
-
+    default: return OPR_NOUNOPR;
-#define UNARY_PRIORITY	7
-
-    case  '*': case  '/': *rp = 6; return 6;
-
-    case  '+': case  '-': *rp = 5; return 5;
-
-    case  TK_CONCAT: *rp = 3; return 4;  /* right associative (?) */
-
-    case TK_EQ: case  TK_NE: case  '>': case  '<': case  TK_LE: case  TK_GE:
-      *rp = 2; return 2;
-
-    case TK_AND: case TK_OR: *rp = 1; return 1;
-
-    default: *rp = -1; return -1;
   }
 }
 
 
+static BinOpr getbinopr (int op) {
+  switch (op) {
+    case '+': return OPR_ADD;
+    case '-': return OPR_SUB;
+    case '*': return OPR_MULT;
+    case '/': return OPR_DIV;
+    case '^': return OPR_POW;
+    case TK_CONCAT: return OPR_CONCAT;
+    case TK_NE: return OPR_NE;
+    case TK_EQ: return OPR_EQ;
+    case '<': return OPR_LT;
+    case TK_LE: return OPR_LE;
+    case '>': return OPR_GT;
+    case TK_GE: return OPR_GE;
+    case TK_AND: return OPR_AND;
+    case TK_OR: return OPR_OR;
+    default: return OPR_NOBINOPR;
+  }
+}
+
+
+static const struct {
+  char left;  /* left priority for each binary operator */
+  char right; /* right priority */
+} priority[] = {  /* ORDER OPR */
+   {5, 5}, {5, 5}, {6, 6}, {6, 6},  /* arithmetic */
+   {9, 8}, {4, 3},                  /* power and concat (right associative) */
+   {2, 2}, {2, 2},                  /* equality */
+   {2, 2}, {2, 2}, {2, 2}, {2, 2},  /* order */
+   {1, 1}, {1, 1}                   /* logical */
+};
+
+#define UNARY_PRIORITY	7  /* priority for unary operators */
+
+
 /*
-** subexpr -> (simplexep | (NOT | '-') subexpr) { binop subexpr }
+** subexpr -> (simplexep | unop subexpr) { binop subexpr }
 ** where `binop' is any binary operator with a priority higher than `limit'
 */
-static void subexpr (LexState *ls, expdesc *v, int limit) {
+static BinOpr subexpr (LexState *ls, expdesc *v, int limit) {
-  int rp;
+  BinOpr op;
-  if (ls->t.token == '-' || ls->t.token == TK_NOT) {
+  UnOpr uop = getunopr(ls->t.token);
-    int op = ls->t.token;  /* operator */
+  if (uop != OPR_NOUNOPR) {
     next(ls);
     subexpr(ls, v, UNARY_PRIORITY);
-    luaK_prefix(ls, op, v);
+    luaK_prefix(ls, uop, v);
   }
   else simpleexp(ls, v);
   /* expand while operators have priorities higher than `limit' */
-  while (get_priority(ls->t.token, &rp) > limit) {
+  op = getbinopr(ls->t.token);
+  while (op != OPR_NOBINOPR && priority[op].left > limit) {
     expdesc v2;
-    int op = ls->t.token;  /* current operator (with priority == `rp') */
+    BinOpr nextop;
     next(ls);
     luaK_infix(ls, op, v);
-    subexpr(ls, &v2, rp);  /* read sub-expression with priority > `rp' */
+    /* read sub-expression with higher priority */
+    nextop = subexpr(ls, &v2, priority[op].right);
     luaK_posfix(ls, op, v, &v2);
+    op = nextop;
   }
+  return op;  /* return first untreated operator */
 }