From e2b042bd9721995486f4f0cf96847c02d27908e3 Mon Sep 17 00:00:00 2001
From: Cliff Click <cliffc@acm.org>
Date: Sat, 24 Oct 2026 15:26:23 -0700
Subject: Fix chained comparisons and restore recursion coverage

---
 .../main/java/com/seaofnodes/simple/Parser.java    | 108 ++++++++++++---------
 1 file changed, 62 insertions(+), 46 deletions(-)

(limited to 'chapter24b/src/main')

diff --git a/chapter24b/src/main/java/com/seaofnodes/simple/Parser.java b/chapter24b/src/main/java/com/seaofnodes/simple/Parser.java
index 9cf565ac..81c7be32 100644
--- a/chapter24b/src/main/java/com/seaofnodes/simple/Parser.java
+++ b/chapter24b/src/main/java/com/seaofnodes/simple/Parser.java
@@ -1100,57 +1100,73 @@ public class Parser {
      */
     private Node parseComparison() {
         Node lhs = parseShift();
-        int dir = 0;
+        int dir = parseCompDir();
+        // No compare
+        if( dir==0 ) return lhs;
+        lhs.keep();
 
-        while( true ) {
-            int dir0;
-            if( false ) ;
-            else if( match("<=" ) ) dir0 = -1;
-            else if( match(">=" ) ) dir0 = -2;
-            else if( match("<"  ) ) dir0 =  1;
-            else if( match(">"  ) ) dir0 =  2;
-            else break;
-            lhs.keep();
-            // Check and record direction
-            if( dir==0 ) {
-                dir = Math.abs(dir0);
-                Node rhs = parseShift();
-                lhs = makeCompBool(dir0,lhs.unkeep(),rhs); // Convert to a bool
-            } else if( dir == Math.abs(dir0) ) {
-                // e0 < lhs < ???
-                Node ifNode = new IfNode(ctrl(), lhs).peephole();
-                Node ifT = new CProjNode(ifNode.  keep(), 0, "True" ).peephole();
-                Node ifF = new CProjNode(ifNode.unkeep(), 1, "False").peephole();
-                // False side does nothing
-                ScopeNode fScope = _scope.dup();
-                fScope.ctrl(ifF);
-                // True side executes next part of range
-                ctrl(ifT);
-                _scope.addGuards(ifT,lhs,false);
-                Node rhs = parseShift();
-                _scope.removeGuards(ifT); // TODO: I think should remain true as long as possible
-                Node next = makeCompBool(dir0, lhs, rhs).keep();
-                // Merge result
-                RegionNode r = ctrl(_scope.mergeScopes(fScope, loc()));
-                assert next._type.meet(lhs._type).isa( TypeInteger.BOOL );
-                lhs = peep(new PhiNode("",TypeInteger.BOOL,r,next.unkeep(),lhs.unkeep()));
-                r.peephole();
-            } else {
-                throw error("Mixing relational directions in a chained relational test");
-            }
+        // Compare
+        Node rhs = parseShift().keep();
+        Node cmp = makeCompBool(dir,lhs.unkeep(),rhs).keep(); // Convert to a bool
+
+        // Stacked compares?
+        int dir0 = parseCompDir();
+        if( dir0 == 0 ) {
+            rhs.unkill();
+            return cmp.unkeep();
         }
-        return lhs;
-    }
 
-    private Node makeCompBool( int dir0, Node lhs, Node rhs ) {
-        // Convert to a bool
-        if( Math.abs(dir0)==2 ) // Swap direction
-            { Node tmp = lhs; lhs = rhs; rhs = tmp; }
-        lhs = peep(dir0 < 0 ? new BoolNode.LE(lhs,rhs) : new BoolNode.LT(lhs,rhs));
-        return peep(lhs.widen());
+        // Keep the middle operand separately from the boolean result.
+        // The next test compares adjacent operands, not that boolean.
+        Node ifNode = new IfNode(ctrl(), cmp.unkeep()).peephole();
+        Node ifT = new CProjNode(ifNode.  keep(), 0, "True" ).peephole().keep();
+        Node ifF = new CProjNode(ifNode.unkeep(), 1, "False").peephole();
+        // False side does nothing but capture memory & side-effects
+        ScopeNode fail = _scope.dup();
+        fail.ctrl(ifF);
+
+        // Loop over stacked compares.  Each loop moves the old RHS to become
+        // the new LHS, so e.g. (a < b < c < d) compares (LHS:a < RHS:b) then
+        // compares (LHS:b < RHS:c) then (LHS:c < RHS:d), etc.
+        while( dir0 != 0 ) {
+            if( Math.abs(dir) != Math.abs(dir0) )
+                throw error("Mixing relational directions in a chained relational test");
+            // True side parses next arm of test
+            ctrl(ifT.unkeep());
+            lhs = rhs;          // Reuse the previous RHS exactly once
+            rhs = parseShift().keep();
+            cmp = makeCompBool(dir0,lhs.unkeep(),rhs); // Convert to a bool
+            ifNode = new IfNode(ctrl(), cmp).peephole();
+            ifT = new CProjNode(ifNode.  keep(), 0, "True" ).peephole().keep();
+            ifF = new CProjNode(ifNode.unkeep(), 1, "False").peephole();
+            // Merge result into the fail case
+            ctrl(ifF);
+            fail.mergeScopes(_scope.dup(), loc()).peephole();
+            // Check next stacked compare
+            dir0 = parseCompDir();
+        }
+        rhs.unkill();
+        ctrl(ifT.unkeep());
+        RegionNode r = fail.mergeScopes(_scope, loc()).init();
+        _scope = fail;
+        return new PhiNode("",TypeInteger.BOOL,r,con(0),con(1)).peephole();
+    }
+
+    private int parseCompDir() {
+        if( match("<=") ) return -1; // Negative for "equals-or-less"
+        if( match(">=") ) return -2; // 1 for <, 2 for >
+        if( match("<" ) ) return  1; // Positive for just "less"
+        if( match(">" ) ) return  2;
+        return 0;
+    }
+
+    private Node makeCompBool( int dir, Node lhs, Node rhs ) {
+        if( Math.abs(dir)==2 )
+            { Node tmp=lhs; lhs=rhs; rhs=tmp; }
+        Node cmp = dir < 0 ? new BoolNode.LE(lhs,rhs) : new BoolNode.LT(lhs,rhs);
+        return peep(cmp.widen());
     }
 
-
     /**
      * Parse an additive expression
      *
-- 
cgit v1.2.3