cmd/compile, go/parser: simpler binary expression parsing

The existing nested loops are too tricky for me to grok and don't seem
necessary.

Change-Id: I75c65c8470b799d6f4cfb05bb1b4796c5d7d32e7
Reviewed-on: https://go-review.googlesource.com/19927
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>

diff --git a/src/cmd/compile/internal/gc/parser.go b/src/cmd/compile/internal/gc/parser.go
index 25754e5663a1755a29d3ea3a73e913268aced08e..ffa20711b774e6085d3ed0b7650a8050c7934187 100644 (file)
--- a/src/cmd/compile/internal/gc/parser.go
+++ b/src/cmd/compile/internal/gc/parser.go
@@ -1142,17 +1142,14 @@ func (p *parser) bexpr(prec int) *Node {
        // don't trace bexpr - only leads to overly nested trace output
 
        x := p.uexpr()
-       t := prectab[p.tok]
-       for tprec := t.prec; tprec >= prec; tprec-- {
-               for tprec == prec {
-                       p.next()
-                       y := p.bexpr(t.prec + 1)
-                       x = Nod(t.op, x, y)
-                       t = prectab[p.tok]
-                       tprec = t.prec
+       for {
+               t := prectab[p.tok]
+               if t.prec < prec {
+                       return x
                }
+               p.next()
+               x = Nod(t.op, x, p.bexpr(t.prec+1))
        }
-       return x
 }
 
 func (p *parser) expr() *Node {

diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go
index f3a26032eec448100159fd0255201158019d2aff..d3ef7db31eafbfe3c0f35007ce92e536bfebc8be 100644 (file)
--- a/src/go/parser/parser.go
+++ b/src/go/parser/parser.go
@@ -1597,23 +1597,19 @@ func (p *parser) parseBinaryExpr(lhs bool, prec1 int) ast.Expr {
        }
 
        x := p.parseUnaryExpr(lhs)
-       for _, prec := p.tokPrec(); prec >= prec1; prec-- {
-               for {
-                       op, oprec := p.tokPrec()
-                       if oprec != prec {
-                               break
-                       }
-                       pos := p.expect(op)
-                       if lhs {
-                               p.resolve(x)
-                               lhs = false
-                       }
-                       y := p.parseBinaryExpr(false, prec+1)
-                       x = &ast.BinaryExpr{X: p.checkExpr(x), OpPos: pos, Op: op, Y: p.checkExpr(y)}
+       for {
+               op, oprec := p.tokPrec()
+               if oprec < prec1 {
+                       return x
+               }
+               pos := p.expect(op)
+               if lhs {
+                       p.resolve(x)
+                       lhs = false
                }
+               y := p.parseBinaryExpr(false, oprec+1)
+               x = &ast.BinaryExpr{X: p.checkExpr(x), OpPos: pos, Op: op, Y: p.checkExpr(y)}
        }
-
-       return x
 }
 
 // If lhs is set and the result is an identifier, it is not resolved.