Skip to content

Commit 1ce6cfb

Browse files
marijnhmarijnh
committed
use a precedence table for operator parsing
1 parent f017a9e commit 1ce6cfb

File tree

1 file changed

+65
-131
lines changed

1 file changed

+65
-131
lines changed

‎src/comp/front/parser.rs

Lines changed: 65 additions & 131 deletions
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,7 @@ state type parser =
3535
fn get_session() -> session.session;
3636
fn get_span() -> common.span;
3737
fn next_def_id() -> ast.def_id;
38+
fn get_prec_table() -> vec[op_spec];
3839
};
3940

4041
impure fn new_parser(session.session sess,
@@ -50,7 +51,8 @@ impure fn new_parser(session.session sess,
5051
mutable ast.def_num def,
5152
mutable restriction res,
5253
ast.crate_num crate,
53-
lexer.reader rdr)
54+
lexer.reader rdr,
55+
vec[op_spec] precs)
5456
{
5557
fn peek() -> token.token {
5658
ret tok;
@@ -100,6 +102,9 @@ impure fn new_parser(session.session sess,
100102
ret env;
101103
}
102104

105+
fn get_prec_table() -> vec[op_spec] {
106+
ret precs;
107+
}
103108
}
104109
auto ftype = SOURCE_FILE;
105110
if (_str.ends_with(path, ".rc")) {
@@ -109,7 +114,8 @@ impure fn new_parser(session.session sess,
109114
auto rdr = lexer.new_reader(srdr, path);
110115
auto npos = rdr.get_curr_pos();
111116
ret stdio_parser(sess, env, ftype, lexer.next_token(rdr),
112-
npos, npos, 0, UNRESTRICTED, crate, rdr);
117+
npos, npos, 0, UNRESTRICTED, crate, rdr,
118+
prec_table());
113119
}
114120

115121
impure fn unexpected(parser p, token.token t) {
@@ -975,144 +981,72 @@ impure fn parse_prefix_expr(parser p) -> @ast.expr {
975981
ret @spanned(lo, hi, ex);
976982
}
977983

978-
impure fn parse_binops(parser p,
979-
(impure fn(parser) -> @ast.expr) sub,
980-
vec[tup(token.binop, ast.binop)] ops)
984+
type op_spec = rec(token.token tok, ast.binop op, int prec);
985+
986+
fn prec_table() -> vec[op_spec] {
987+
ret vec(rec(tok=token.BINOP(token.STAR), op=ast.mul, prec=11),
988+
rec(tok=token.BINOP(token.SLASH), op=ast.div, prec=11),
989+
rec(tok=token.BINOP(token.PERCENT), op=ast.rem, prec=11),
990+
rec(tok=token.BINOP(token.PLUS), op=ast.add, prec=10),
991+
rec(tok=token.BINOP(token.MINUS), op=ast.sub, prec=10),
992+
rec(tok=token.BINOP(token.LSL), op=ast.lsl, prec=9),
993+
rec(tok=token.BINOP(token.LSR), op=ast.lsr, prec=9),
994+
rec(tok=token.BINOP(token.ASR), op=ast.asr, prec=9),
995+
rec(tok=token.BINOP(token.AND), op=ast.bitand, prec=8),
996+
rec(tok=token.BINOP(token.CARET), op=ast.bitxor, prec=6),
997+
rec(tok=token.BINOP(token.OR), op=ast.bitor, prec=6),
998+
// ast.mul is a bogus placeholder here, AS is special
999+
// cased in parse_more_binops
1000+
rec(tok=token.AS, op=ast.mul, prec=5),
1001+
rec(tok=token.LT, op=ast.lt, prec=4),
1002+
rec(tok=token.LE, op=ast.le, prec=4),
1003+
rec(tok=token.GE, op=ast.ge, prec=4),
1004+
rec(tok=token.GT, op=ast.gt, prec=4),
1005+
rec(tok=token.EQEQ, op=ast.eq, prec=3),
1006+
rec(tok=token.NE, op=ast.ne, prec=3),
1007+
rec(tok=token.ANDAND, op=ast.and, prec=2),
1008+
rec(tok=token.OROR, op=ast.or, prec=1));
1009+
}
1010+
1011+
impure fn parse_binops(parser p) -> @ast.expr {
1012+
ret parse_more_binops(p, parse_prefix_expr(p), 0);
1013+
}
1014+
1015+
impure fn parse_more_binops(parser p, @ast.expr lhs, int min_prec)
9811016
-> @ast.expr {
982-
auto lo = p.get_span();
983-
auto hi = lo;
984-
auto e = sub(p);
985-
auto more = true;
986-
while (more) {
987-
more = false;
988-
for (tup(token.binop, ast.binop) pair in ops) {
989-
alt (p.peek()) {
990-
case (token.BINOP(?op)) {
991-
if (pair._0 == op) {
992-
p.bump();
993-
auto rhs = sub(p);
994-
hi = rhs.span;
995-
auto exp = ast.expr_binary(pair._1, e, rhs,
996-
ast.ann_none);
997-
e = @spanned(lo, hi, exp);
998-
more = true;
999-
}
1017+
// Magic nonsense to work around rustboot bug
1018+
fn op_eq(token.token a, token.token b) -> bool {
1019+
if (a == b) {ret true;}
1020+
else {ret false;}
1021+
}
1022+
auto peeked = p.peek();
1023+
for (op_spec cur in p.get_prec_table()) {
1024+
if (cur.prec > min_prec && op_eq(cur.tok, peeked)) {
1025+
p.bump();
1026+
alt (cur.tok) {
1027+
case (token.AS) {
1028+
auto rhs = parse_ty(p);
1029+
auto _as = ast.expr_cast(lhs, rhs, ast.ann_none);
1030+
auto span = @spanned(lhs.span, rhs.span, _as);
1031+
ret parse_more_binops(p, span, min_prec);
1032+
}
1033+
case (_) {
1034+
auto rhs = parse_more_binops(p, parse_prefix_expr(p),
1035+
cur.prec);
1036+
auto bin = ast.expr_binary(cur.op, lhs, rhs,
1037+
ast.ann_none);
1038+
auto span = @spanned(lhs.span, rhs.span, bin);
1039+
ret parse_more_binops(p, span, min_prec);
10001040
}
1001-
case (_) { /* fall through */ }
1002-
}
1003-
}
1004-
}
1005-
ret e;
1006-
}
1007-
1008-
impure fn parse_binary_exprs(parser p,
1009-
(impure fn(parser) -> @ast.expr) sub,
1010-
vec[tup(token.token, ast.binop)] ops)
1011-
-> @ast.expr {
1012-
auto lo = p.get_span();
1013-
auto hi = lo;
1014-
auto e = sub(p);
1015-
auto more = true;
1016-
while (more) {
1017-
more = false;
1018-
for (tup(token.token, ast.binop) pair in ops) {
1019-
if (pair._0 == p.peek()) {
1020-
p.bump();
1021-
auto rhs = sub(p);
1022-
hi = rhs.span;
1023-
auto exp = ast.expr_binary(pair._1, e, rhs, ast.ann_none);
1024-
e = @spanned(lo, hi, exp);
1025-
more = true;
1026-
}
1027-
}
1028-
}
1029-
ret e;
1030-
}
1031-
1032-
impure fn parse_factor_expr(parser p) -> @ast.expr {
1033-
auto sub = parse_prefix_expr;
1034-
ret parse_binops(p, sub, vec(tup(token.STAR, ast.mul),
1035-
tup(token.SLASH, ast.div),
1036-
tup(token.PERCENT, ast.rem)));
1037-
}
1038-
1039-
impure fn parse_term_expr(parser p) -> @ast.expr {
1040-
auto sub = parse_factor_expr;
1041-
ret parse_binops(p, sub, vec(tup(token.PLUS, ast.add),
1042-
tup(token.MINUS, ast.sub)));
1043-
}
1044-
1045-
impure fn parse_shift_expr(parser p) -> @ast.expr {
1046-
auto sub = parse_term_expr;
1047-
ret parse_binops(p, sub, vec(tup(token.LSL, ast.lsl),
1048-
tup(token.LSR, ast.lsr),
1049-
tup(token.ASR, ast.asr)));
1050-
}
1051-
1052-
impure fn parse_bitand_expr(parser p) -> @ast.expr {
1053-
auto sub = parse_shift_expr;
1054-
ret parse_binops(p, sub, vec(tup(token.AND, ast.bitand)));
1055-
}
1056-
1057-
impure fn parse_bitxor_expr(parser p) -> @ast.expr {
1058-
auto sub = parse_bitand_expr;
1059-
ret parse_binops(p, sub, vec(tup(token.CARET, ast.bitxor)));
1060-
}
1061-
1062-
impure fn parse_bitor_expr(parser p) -> @ast.expr {
1063-
auto sub = parse_bitxor_expr;
1064-
ret parse_binops(p, sub, vec(tup(token.OR, ast.bitor)));
1065-
}
1066-
1067-
impure fn parse_cast_expr(parser p) -> @ast.expr {
1068-
auto lo = p.get_span();
1069-
auto e = parse_bitor_expr(p);
1070-
auto hi = e.span;
1071-
while (true) {
1072-
alt (p.peek()) {
1073-
case (token.AS) {
1074-
p.bump();
1075-
auto t = parse_ty(p);
1076-
hi = t.span;
1077-
e = @spanned(lo, hi, ast.expr_cast(e, t, ast.ann_none));
1078-
}
1079-
1080-
case (_) {
1081-
ret e;
10821041
}
10831042
}
10841043
}
1085-
ret e;
1086-
}
1087-
1088-
impure fn parse_relational_expr(parser p) -> @ast.expr {
1089-
auto sub = parse_cast_expr;
1090-
ret parse_binary_exprs(p, sub, vec(tup(token.LT, ast.lt),
1091-
tup(token.LE, ast.le),
1092-
tup(token.GE, ast.ge),
1093-
tup(token.GT, ast.gt)));
1094-
}
1095-
1096-
1097-
impure fn parse_equality_expr(parser p) -> @ast.expr {
1098-
auto sub = parse_relational_expr;
1099-
ret parse_binary_exprs(p, sub, vec(tup(token.EQEQ, ast.eq),
1100-
tup(token.NE, ast.ne)));
1101-
}
1102-
1103-
impure fn parse_and_expr(parser p) -> @ast.expr {
1104-
auto sub = parse_equality_expr;
1105-
ret parse_binary_exprs(p, sub, vec(tup(token.ANDAND, ast.and)));
1106-
}
1107-
1108-
impure fn parse_or_expr(parser p) -> @ast.expr {
1109-
auto sub = parse_and_expr;
1110-
ret parse_binary_exprs(p, sub, vec(tup(token.OROR, ast.or)));
1044+
ret lhs;
11111045
}
11121046

11131047
impure fn parse_assign_expr(parser p) -> @ast.expr {
11141048
auto lo = p.get_span();
1115-
auto lhs = parse_or_expr(p);
1049+
auto lhs = parse_binops(p);
11161050
alt (p.peek()) {
11171051
case (token.EQ) {
11181052
p.bump();

0 commit comments

Comments
 (0)