Set different forkDepth based on check-level

Author: Your Name

lib/forwardanalyzer.cpp

@@ -59,6 +59,8 @@ namespace {
         Analyzer::Terminate terminate = Analyzer::Terminate::None;
         std::vector<Token*> loopEnds;
         int branchCount = 0;
+        // Nested condition-fork depth on this lineage (copied by fork()); bounds the fan-out.
+        int forkDepth = 0;
 
         Progress Break(Analyzer::Terminate t = Analyzer::Terminate::None) {
             if ((!analyzeOnly || analyzeTerminate) && t != Analyzer::Terminate::None)
@@ -796,8 +798,14 @@ namespace {
                             if (thenBranch.hasGoto() || elseBranch.hasGoto()) {
                                 return Break(Analyzer::Terminate::Bail);
                             }
-                            if (pThen != Progress::Break && !thenBranch.isEscape())
+                            // Carry the then-fork forward; past the limit only the linear main path
+                            // continues (no branch skipped). Negative == unlimited.
+                            const int forkDepthLimit = settings.vfOptions.maxForwardConditionForkDepth;
+                            if (pThen != Progress::Break && !thenBranch.isEscape() &&
+                                (forkDepthLimit < 0 || forkDepth < forkDepthLimit)) {
+                                ft.forkDepth = forkDepth + 1;
                                 ft.updateRange(thenBranch.endBlock, end, depth - 1);
+                            }
                             if (pElse == Progress::Break)
                                 return Break();
                         }

lib/settings.cpp

@@ -335,6 +335,7 @@ void Settings::setCheckLevel(CheckLevel level)
         vfOptions.maxIfCount = 100;
         vfOptions.doConditionExpressionAnalysis = false;
         vfOptions.maxForwardBranches = 4;
+        vfOptions.maxForwardConditionForkDepth = 0;
         vfOptions.maxIterations = 1;
     }
     else if (level == CheckLevel::normal) {
@@ -344,6 +345,7 @@ void Settings::setCheckLevel(CheckLevel level)
         vfOptions.maxIfCount = 100;
         vfOptions.doConditionExpressionAnalysis = false;
         vfOptions.maxForwardBranches = 4;
+        vfOptions.maxForwardConditionForkDepth = 1;
     }
     else if (level == CheckLevel::exhaustive) {
         // Checking can take a little while. ~ 10 times slower than normal analysis is OK.
@@ -352,6 +354,7 @@ void Settings::setCheckLevel(CheckLevel level)
         vfOptions.maxSubFunctionArgs = 256;
         vfOptions.doConditionExpressionAnalysis = true;
         vfOptions.maxForwardBranches = -1;
+        vfOptions.maxForwardConditionForkDepth = 4;
     }
 }
 

lib/settings.h

@@ -512,6 +512,12 @@ class CPPCHECKLIB WARN_UNUSED Settings {
         /** @brief Maximum performed forward branches */
         int maxForwardBranches = -1;
 
+        /** @brief Maximum depth of nested condition-fork continuations in the forward analyzer.
+            Bounds the exponential fan-out of carrying condition state forward at exhaustive level (where
+            maxForwardBranches is unlimited); past it the forward analysis continues on a single linear path
+            without skipping any branch. 0 disables forking (linear); a negative value means unlimited. */
+        int maxForwardConditionForkDepth = 4;
+
         /** @brief Maximum performed alignof recursion */
         int maxAlignOfRecursion = 100;