Remove switch on phase from Stepwise left/right step

ConflictSet.cpp

@@ -2001,37 +2001,63 @@ struct CheckRangeLeftSide {
   int searchPathLen = 0;
   bool ok;
 
-  enum Phase { Search, DownLeftSpine } phase = Search;
-
   bool step() {
-    switch (phase) {
+    if (maxVersion(n, impl) <= readVersion) {
-    case Search: {
+      ok = true;
-      if (maxVersion(n, impl) <= readVersion) {
+      return true;
-        ok = true;
+    }
+    if (remaining.size() == 0) {
+      assert(searchPathLen >= prefixLen);
+      ok = maxVersion(n, impl) <= readVersion;
+      return true;
+    }
+
+    if (searchPathLen >= prefixLen) {
+      if (!checkMaxBetweenExclusive(n, remaining[0], 256, readVersion)) {
+        ok = false;
         return true;
       }
-      if (remaining.size() == 0) {
+    }
-        assert(searchPathLen >= prefixLen);
+
+    auto *child = getChild(n, remaining[0]);
+    if (child == nullptr) {
+      int c = getChildGeq(n, remaining[0]);
+      if (c >= 0) {
+        if (searchPathLen < prefixLen) {
+          n = getChildExists(n, c);
+          return downLeftSpine();
+        }
+        n = getChildExists(n, c);
         ok = maxVersion(n, impl) <= readVersion;
         return true;
-      }
+      } else {
-
+        n = nextSibling(n);
-      if (searchPathLen >= prefixLen) {
+        if (n == nullptr) {
-        if (!checkMaxBetweenExclusive(n, remaining[0], 256, readVersion)) {
+          ok = true;
-          ok = false;
           return true;
         }
+        return downLeftSpine();
       }
+    }
 
-      auto *child = getChild(n, remaining[0]);
+    n = child;
-      if (child == nullptr) {
+    remaining = remaining.subspan(1, remaining.size() - 1);
-        int c = getChildGeq(n, remaining[0]);
+    ++searchPathLen;
-        if (c >= 0) {
+
+    if (n->partialKeyLen > 0) {
+      int commonLen = std::min<int>(n->partialKeyLen, remaining.size());
+      int i = longestCommonPrefix(n->partialKey(), remaining.data(), commonLen);
+      searchPathLen += i;
+      if (i < commonLen) {
+        auto c = n->partialKey()[i] <=> remaining[i];
+        if (c > 0) {
           if (searchPathLen < prefixLen) {
-            n = getChildExists(n, c);
             return downLeftSpine();
           }
-          n = getChildExists(n, c);
+          if (n->entryPresent && n->entry.rangeVersion > readVersion) {
+            ok = false;
+            return true;
+          }
           ok = maxVersion(n, impl) <= readVersion;
           return true;
         } else {
@@ -2043,54 +2069,24 @@ struct CheckRangeLeftSide {
           return downLeftSpine();
         }
       }
-
+      if (commonLen == n->partialKeyLen) {
-      n = child;
+        // partial key matches
-      remaining = remaining.subspan(1, remaining.size() - 1);
+        remaining = remaining.subspan(commonLen, remaining.size() - commonLen);
-      ++searchPathLen;
+      } else if (n->partialKeyLen > int(remaining.size())) {
-
+        assert(searchPathLen >= prefixLen);
-      if (n->partialKeyLen > 0) {
+        if (n->entryPresent && n->entry.rangeVersion > readVersion) {
-        int commonLen = std::min<int>(n->partialKeyLen, remaining.size());
+          ok = false;
-        int i =
-            longestCommonPrefix(n->partialKey(), remaining.data(), commonLen);
-        searchPathLen += i;
-        if (i < commonLen) {
-          auto c = n->partialKey()[i] <=> remaining[i];
-          if (c > 0) {
-            if (searchPathLen < prefixLen) {
-              return downLeftSpine();
-            }
-            if (n->entryPresent && n->entry.rangeVersion > readVersion) {
-              ok = false;
-              return true;
-            }
-            ok = maxVersion(n, impl) <= readVersion;
-            return true;
-          } else {
-            n = nextSibling(n);
-            if (n == nullptr) {
-              ok = true;
-              return true;
-            }
-            return downLeftSpine();
-          }
-        }
-        if (commonLen == n->partialKeyLen) {
-          // partial key matches
-          remaining =
-              remaining.subspan(commonLen, remaining.size() - commonLen);
-        } else if (n->partialKeyLen > int(remaining.size())) {
-          assert(searchPathLen >= prefixLen);
-          if (n->entryPresent && n->entry.rangeVersion > readVersion) {
-            ok = false;
-            return true;
-          }
-          ok = maxVersion(n, impl) <= readVersion;
           return true;
         }
+        ok = maxVersion(n, impl) <= readVersion;
+        return true;
       }
-      break;
     }
-    case DownLeftSpine: {
+    return false;
+  }
+
+  bool downLeftSpine() {
+    for (;;) {
       if (n->entryPresent) {
         ok = n->entry.rangeVersion <= readVersion;
         return true;
@@ -2098,16 +2094,7 @@ struct CheckRangeLeftSide {
       int c = getChildGeq(n, 0);
       assert(c >= 0);
       n = getChildExists(n, c);
-    } break;
-    default:                   // GCOVR_EXCL_LINE
-      __builtin_unreachable(); // GCOVR_EXCL_LINE
     }
-    return false;
-  }
-
-  bool downLeftSpine() {
-    phase = DownLeftSpine;
-    return false;
   }
 };
 
@@ -2134,97 +2121,78 @@ struct CheckRangeRightSide {
   int searchPathLen = 0;
   bool ok;
 
-  enum Phase { Search, DownLeftSpine } phase = Search;
-
   bool step() {
-    switch (phase) {
-    case Search: {
 #if DEBUG_VERBOSE && !defined(NDEBUG)
-      fprintf(
+    fprintf(stderr,
-          stderr,
+            "Search path: %s, searchPathLen: %d, prefixLen: %d, remaining: "
-          "Search path: %s, searchPathLen: %d, prefixLen: %d, remaining: %s\n",
+            "%s\n",
-          getSearchPathPrintable(n).c_str(), searchPathLen, prefixLen,
+            getSearchPathPrintable(n).c_str(), searchPathLen, prefixLen,
-          printable(remaining).c_str());
+            printable(remaining).c_str());
 #endif
 
-      assert(searchPathLen <= int(key.size()));
+    assert(searchPathLen <= int(key.size()));
 
-      if (remaining.size() == 0) {
+    if (remaining.size() == 0) {
-        return downLeftSpine();
+      return downLeftSpine();
-      }
+    }
 
-      if (searchPathLen >= prefixLen) {
+    if (searchPathLen >= prefixLen) {
-        if (n->entryPresent && n->entry.pointVersion > readVersion) {
+      if (n->entryPresent && n->entry.pointVersion > readVersion) {
-          ok = false;
-          return true;
-        }
-
-        if (!checkMaxBetweenExclusive(n, -1, remaining[0], readVersion)) {
-          ok = false;
-          return true;
-        }
-      }
-
-      if (searchPathLen > prefixLen && n->entryPresent &&
-          n->entry.rangeVersion > readVersion) {
         ok = false;
         return true;
       }
 
-      auto *child = getChild(n, remaining[0]);
+      if (!checkMaxBetweenExclusive(n, -1, remaining[0], readVersion)) {
-      if (child == nullptr) {
+        ok = false;
-        int c = getChildGeq(n, remaining[0]);
+        return true;
-        if (c >= 0) {
+      }
-          n = getChildExists(n, c);
+    }
+
+    if (searchPathLen > prefixLen && n->entryPresent &&
+        n->entry.rangeVersion > readVersion) {
+      ok = false;
+      return true;
+    }
+
+    auto *child = getChild(n, remaining[0]);
+    if (child == nullptr) {
+      int c = getChildGeq(n, remaining[0]);
+      if (c >= 0) {
+        n = getChildExists(n, c);
+        return downLeftSpine();
+      } else {
+        return backtrack();
+      }
+    }
+
+    n = child;
+    remaining = remaining.subspan(1, remaining.size() - 1);
+    ++searchPathLen;
+
+    if (n->partialKeyLen > 0) {
+      int commonLen = std::min<int>(n->partialKeyLen, remaining.size());
+      int i = longestCommonPrefix(n->partialKey(), remaining.data(), commonLen);
+      searchPathLen += i;
+      if (i < commonLen) {
+        ++searchPathLen;
+        auto c = n->partialKey()[i] <=> remaining[i];
+        if (c > 0) {
           return downLeftSpine();
         } else {
+          if (searchPathLen > prefixLen && n->entryPresent &&
+              n->entry.rangeVersion > readVersion) {
+            ok = false;
+            return true;
+          }
           return backtrack();
         }
       }
-
+      if (commonLen == n->partialKeyLen) {
-      n = child;
+        // partial key matches
-      remaining = remaining.subspan(1, remaining.size() - 1);
+        remaining = remaining.subspan(commonLen, remaining.size() - commonLen);
-      ++searchPathLen;
+      } else if (n->partialKeyLen > int(remaining.size())) {
-
+        return downLeftSpine();
-      if (n->partialKeyLen > 0) {
-        int commonLen = std::min<int>(n->partialKeyLen, remaining.size());
-        int i =
-            longestCommonPrefix(n->partialKey(), remaining.data(), commonLen);
-        searchPathLen += i;
-        if (i < commonLen) {
-          ++searchPathLen;
-          auto c = n->partialKey()[i] <=> remaining[i];
-          if (c > 0) {
-            return downLeftSpine();
-          } else {
-            if (searchPathLen > prefixLen && n->entryPresent &&
-                n->entry.rangeVersion > readVersion) {
-              ok = false;
-              return true;
-            }
-            return backtrack();
-          }
-        }
-        if (commonLen == n->partialKeyLen) {
-          // partial key matches
-          remaining =
-              remaining.subspan(commonLen, remaining.size() - commonLen);
-        } else if (n->partialKeyLen > int(remaining.size())) {
-          return downLeftSpine();
-        }
       }
-    } break;
-    case DownLeftSpine: {
-      if (n->entryPresent) {
-        ok = n->entry.rangeVersion <= readVersion;
-        return true;
-      }
-      int c = getChildGeq(n, 0);
-      assert(c >= 0);
-      n = getChildExists(n, c);
-    } break;
-    default:                   // GCOVR_EXCL_LINE
-      __builtin_unreachable(); // GCOVR_EXCL_LINE
     }
     return false;
   }
@@ -2253,9 +2221,15 @@ struct CheckRangeRightSide {
   }
 
   bool downLeftSpine() {
-    phase = DownLeftSpine;
+    for (;;) {
-    assert(n != nullptr);
+      if (n->entryPresent) {
-    return false;
+        ok = n->entry.rangeVersion <= readVersion;
+        return true;
+      }
+      int c = getChildGeq(n, 0);
+      assert(c >= 0);
+      n = getChildExists(n, c);
+    }
   }
 };