Format

Author: Your Name

lib/forwardanalyzer.cpp

@@ -777,8 +777,8 @@ namespace {
                         if (thenBranch.check) {
                             // The condition is only "known" because of an earlier assumption, so the
                             // skipped else block could still modify the value -> lower to possible
-                            if (!condTok->hasKnownIntValue() && hasElse && analyzeScope(elseBranch.endBlock).isModified() &&
-                                !analyzer->lowerToPossible())
+                            if (!condTok->hasKnownIntValue() && hasElse &&
+                                analyzeScope(elseBranch.endBlock).isModified() && !analyzer->lowerToPossible())
                                 return Break(Analyzer::Terminate::Bail);
                             if (updateScope(thenBranch.endBlock, depth - 1) == Progress::Break)
                                 return Break();
@@ -808,7 +808,9 @@ namespace {
                             // no else the false path continues past the closing brace, so record the
                             // assumed state there (None).
                             if (thenBranch.isDead())
-                                analyzer->assume(condTok, false, hasElse ? Analyzer::Assume::Pending : Analyzer::Assume::None);
+                                analyzer->assume(condTok,
+                                                 false,
+                                                 hasElse ? Analyzer::Assume::Pending : Analyzer::Assume::None);
                             // The else block is traversed on the main path. If it kills the value
                             // (modified) the main path stops, but the then-fork may still carry the
                             // value forward, so defer the break until after the fork continues.

lib/programmemory.cpp

@@ -262,9 +262,16 @@ ProgramMemory::Map::iterator ProgramMemory::find(nonneg int exprid)
     return mValues->find(ExprIdToken::create(exprid));
 }
 
-static ValueFlow::Value execute(const Token* expr, ProgramMemory& pm, const Settings& settings, const ProgramMemory::Map& vars = {});
-
-static bool evaluateCondition(MathLib::bigint r, const Token* condition, ProgramMemory& pm, const Settings& settings, const ProgramMemory::Map& vars = {})
+static ValueFlow::Value execute(const Token* expr,
+                                ProgramMemory& pm,
+                                const Settings& settings,
+                                const ProgramMemory::Map& vars = {});
+
+static bool evaluateCondition(MathLib::bigint r,
+                              const Token* condition,
+                              ProgramMemory& pm,
+                              const Settings& settings,
+                              const ProgramMemory::Map& vars = {})
 {
     if (!condition)
         return false;
@@ -1320,7 +1327,8 @@ namespace {
         }
 
         // Is the tracked value for this expression available?
-        const ValueFlow::Value* getTrackedValue(const Token* expr) const {
+        const ValueFlow::Value* getTrackedValue(const Token* expr) const
+        {
             if (!vars || expr->exprId() == 0)
                 return nullptr;
             const auto it = vars->find(ExprIdToken::create(expr->exprId()));
@@ -1329,7 +1337,8 @@ namespace {
 
         // Does the expression read a tracked value? If so, any value cached for it may be stale
         // (the tracked value may have changed since), so it must be re-evaluated, not served cached.
-        bool dependsOnTrackedValue(const Token* expr) const {
+        bool dependsOnTrackedValue(const Token* expr) const
+        {
             if (!vars || vars->empty())
                 return false;
             return findAstNode(expr, [&](const Token* tok) {
@@ -1836,7 +1845,10 @@ namespace {
     };
 }     // namespace
 
-static ValueFlow::Value execute(const Token* expr, ProgramMemory& pm, const Settings& settings, const ProgramMemory::Map& vars)
+static ValueFlow::Value execute(const Token* expr,
+                                ProgramMemory& pm,
+                                const Settings& settings,
+                                const ProgramMemory::Map& vars)
 {
     Executor ex{&pm, settings};
     ex.vars = &vars;

lib/programmemory.h

@@ -193,15 +193,21 @@ void execute(const Token* expr,
  * \param pm   program memory
  * \param vars  optional tracked values that take precedence over the program memory
  */
-bool conditionIsFalse(const Token* condition, ProgramMemory pm, const Settings& settings, const ProgramMemory::Map& vars = {});
+bool conditionIsFalse(const Token* condition,
+                      ProgramMemory pm,
+                      const Settings& settings,
+                      const ProgramMemory::Map& vars = {});
 
 /**
  * Is condition always true when variable has given value?
  * \param condition   top ast token in condition
  * \param pm   program memory
  * \param vars  optional tracked values that take precedence over the program memory
  */
-bool conditionIsTrue(const Token* condition, ProgramMemory pm, const Settings& settings, const ProgramMemory::Map& vars = {});
+bool conditionIsTrue(const Token* condition,
+                     ProgramMemory pm,
+                     const Settings& settings,
+                     const ProgramMemory::Map& vars = {});
 
 /**
  * Get program memory by looking backwards from given token.

lib/vf_analyzers.cpp

@@ -727,7 +727,8 @@ struct ValueFlowAnalyzer : Analyzer {
         return {};
     }
 
-    void assume(const Token* tok, bool state, unsigned int flags) override {
+    void assume(const Token* tok, bool state, unsigned int flags) override
+    {
         bool isCondBlock = false;
         const Token* parent = tok->astParent();
         if (parent) {

test/testautovariables.cpp

@@ -4848,7 +4848,9 @@ class TestAutoVariables : public TestFixture {
               "        return *iPtr;\n"
               "    return 0;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:5:16] -> [test.cpp:7:10] -> [test.cpp:4:13] -> [test.cpp:8:17]: (error) Using pointer to local variable 'x' that is out of scope. [invalidLifetime]\n", errout_str());
+        ASSERT_EQUALS(
+            "[test.cpp:5:16] -> [test.cpp:7:10] -> [test.cpp:4:13] -> [test.cpp:8:17]: (error) Using pointer to local variable 'x' that is out of scope. [invalidLifetime]\n",
+            errout_str());
 
         // #11753
         check("int main(int argc, const char *argv[]) {\n"

test/testother.cpp

@@ -11491,8 +11491,9 @@ class TestOther : public TestFixture {
               "        x = a + b;\n"
               "    return x;\n"
               "}\n");
-        ASSERT_EQUALS("[test.cpp:2:11] -> [test.cpp:3:9] -> [test.cpp:4:9]: (style) Variable 'x' is assigned an expression that holds the same value. [redundantAssignment]\n",
-                      errout_str());
+        ASSERT_EQUALS(
+            "[test.cpp:2:11] -> [test.cpp:3:9] -> [test.cpp:4:9]: (style) Variable 'x' is assigned an expression that holds the same value. [redundantAssignment]\n",
+            errout_str());
     }
 
     void varFuncNullUB() { // #4482

test/teststl.cpp

@@ -368,7 +368,9 @@ class TestStl : public TestFixture {
                     "    if(b) ++x;\n"
                     "    return s[x];\n"
                     "}");
-        ASSERT_EQUALS("[test.cpp:5:13]: error: Out of bounds access in 's[x]', if 's' size is 6 and 'x' is 7 [containerOutOfBounds]\n", errout_str());
+        ASSERT_EQUALS(
+            "[test.cpp:5:13]: error: Out of bounds access in 's[x]', if 's' size is 6 and 'x' is 7 [containerOutOfBounds]\n",
+            errout_str());
 
         checkNormal("void f() {\n"
                     "    static const int N = 4;\n"

test/testuninitvar.cpp

@@ -4284,7 +4284,8 @@ class TestUninitVar : public TestFixture {
                         "    else y = 123;\n" // <- y is always initialized
                         "    return y;\n"
                         "}");
-        ASSERT_EQUALS("", errout_str()); // #4560: fork-based condition analysis tracks x==0 -> else branch -> y initialized
+        ASSERT_EQUALS("",
+                      errout_str()); // #4560: fork-based condition analysis tracks x==0 -> else branch -> y initialized
 
         valueFlowUninit("void f(int x) {\n" // #3948
                         "  int value;\n"
@@ -5632,7 +5633,9 @@ class TestUninitVar : public TestFixture {
                         "        return;\n"
                         "    if (!mightBeLarger) {}\n"
                         "}");
-        ASSERT_EQUALS("[test.cpp:5:9] -> [test.cpp:7:24] -> [test.cpp:14:10]: (warning) Uninitialized variable: mightBeLarger [uninitvar]\n", errout_str());
+        ASSERT_EQUALS(
+            "[test.cpp:5:9] -> [test.cpp:7:24] -> [test.cpp:14:10]: (warning) Uninitialized variable: mightBeLarger [uninitvar]\n",
+            errout_str());
 
         // Same shape, but the later condition (dimensions == 0) is implied by the narrowing, so the
         // early return fires on the uninitialized path and there must be no warning.