commit 5f22f8961c80ce36297f086ae31d87bbb6897c97
parent a7c1390ffaf0edfe839d075df484f2b81b3151bf
Author: Roberto Ierusalimschy <roberto@inf.puc-rio.br>
Date: Wed, 9 Aug 2000 11:48:51 -0300
better code for unary/binary operators
Diffstat:
| M | lcode.c | | | 84 | +++++++++++++++++++++++++++++++++++++++++++------------------------------------ |
| M | lcode.h | | | 22 | ++++++++++++++++++---- |
| M | lparser.c | | | 79 | ++++++++++++++++++++++++++++++++++++++++++++++++++----------------------------- |
3 files changed, 114 insertions(+), 71 deletions(-)
diff --git a/lcode.c b/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)
- luaK_goiftrue(fs, v, 1);
- else if (op == TK_OR)
- luaK_goiffalse(fs, v, 1);
- else
- luaK_tostack(ls, v, 1); /* all other binary operators need a value */
+ switch (op) {
+ case OPR_AND:
+ luaK_goiftrue(fs, v, 1);
+ break;
+ case OPR_OR:
+ luaK_goiffalse(fs, v, 1);
+ 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) {
- 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);
- }
- else if (op == TK_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);
- }
- else {
- luaK_tostack(ls, v2, 1); /* `v2' must be a value */
- switch (op) {
- 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;
+ 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;
+ }
+ 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;
+ }
+ default: {
+ luaK_tostack(ls, v2, 1); /* `v2' must be a value */
+ luaK_code1(fs, codes[op].opcode, codes[op].arg);
}
}
}
diff --git a/lcode.h b/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_infix (LexState *ls, int op, expdesc *v);
-void luaK_posfix (LexState *ls, int op, expdesc *v1, expdesc *v2);
+void luaK_prefix (LexState *ls, UnOpr op, expdesc *v);
+void luaK_infix (LexState *ls, BinOpr op, expdesc *v);
+void luaK_posfix (LexState *ls, BinOpr op, expdesc *v1, expdesc *v2);
#endif
diff --git a/lparser.c b/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) {
}
-/*
-** 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) {
+static UnOpr getunopr (int op) {
switch (op) {
+ case TK_NOT: return OPR_NOT;
+ case '-': return OPR_MINUS;
+ default: return OPR_NOUNOPR;
+ }
+}
- case '^': *rp = 8; return 9; /* right associative */
-
-#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 (?) */
+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;
+ }
+}
- 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;
+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 */
+};
- default: *rp = -1; return -1;
- }
-}
+#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) {
- int rp;
- if (ls->t.token == '-' || ls->t.token == TK_NOT) {
- int op = ls->t.token; /* operator */
+static BinOpr subexpr (LexState *ls, expdesc *v, int limit) {
+ BinOpr op;
+ UnOpr uop = getunopr(ls->t.token);
+ 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 */
}
