Format

danmar · danmar · Mar 30, 2021 · Feb 18, 2021 · Feb 18, 2021 · Feb 18, 2021
commit 31b70677018854e4275657b0589e31b762f989c7
diff --git a/lib/astutils.cpp b/lib/astutils.cpp
@@ -167,7 +167,7 @@ bool astIsIntegral(const Token *tok, bool unknown)
     return vt->isIntegral() && vt->pointer == 0U;
 }
 
-bool astIsUnsigned(const Token *tok)
+bool astIsUnsigned(const Token* tok)
 {
     return tok && tok->valueType() && tok->valueType()->sign == ValueType::UNSIGNED;
 }

diff --git a/lib/astutils.h b/lib/astutils.h
@@ -70,7 +70,7 @@ bool astIsSignedChar(const Token *tok);
 bool astIsUnknownSignChar(const Token *tok);
 /** Is expression of integral type? */
 bool astIsIntegral(const Token *tok, bool unknown);
-bool astIsUnsigned(const Token *tok);
+bool astIsUnsigned(const Token* tok);
 /** Is expression of floating point type? */
 bool astIsFloat(const Token *tok, bool unknown);
 /** Is expression of boolean type? */

diff --git a/lib/token.cpp b/lib/token.cpp
@@ -2024,23 +2024,18 @@ static bool removeContradiction(std::list<ValueFlow::Value>& values)
     return result;
 }
 
-
 using ValueIterator = std::list<ValueFlow::Value>::iterator;
 
-template<class Iterator>
+template <class Iterator>
 static ValueIterator removeAdjacentValues(std::list<ValueFlow::Value>& values, ValueIterator x, Iterator start, Iterator last)
 {
     if (!isAdjacent(*x, **start))
         return std::next(x);
-    auto it = std::adjacent_find(start, last, [](ValueIterator x, ValueIterator y) {
-        return !isAdjacent(*x, *y);
-    });
+    auto it = std::adjacent_find(start, last, [](ValueIterator x, ValueIterator y) { return !isAdjacent(*x, *y); });
     if (it == last)
         it--;
     (*it)->bound = x->bound;
-    std::for_each(start, it, [&](ValueIterator y) {
-        values.erase(y);
-    });
+    std::for_each(start, it, [&](ValueIterator y) { values.erase(y); });
     return values.erase(x);
 }
 
@@ -2056,7 +2051,7 @@ static void mergeAdjacent(std::list<ValueFlow::Value>& values)
             continue;
         }
         std::vector<ValueIterator> adjValues;
-        for (auto y = values.begin(); y != values.end();y++) {
+        for (auto y = values.begin(); y != values.end(); y++) {
             if (x == y)
                 continue;
             if (y->isNonValue())
@@ -2090,7 +2085,6 @@ static void mergeAdjacent(std::list<ValueFlow::Value>& values)
             x = removeAdjacentValues(values, x, adjValues.rbegin(), adjValues.rend());
         else if (x->bound == ValueFlow::Value::Bound::Upper)
             x = removeAdjacentValues(values, x, adjValues.begin(), adjValues.end());
-
     }
 }
 
@@ -2132,7 +2126,6 @@ static void removeContradictions(std::list<ValueFlow::Value>& values)
     }
 }
 
-
 bool Token::addValue(const ValueFlow::Value &value)
 {
     if (value.isKnown() && mImpl->mValues) {

diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
@@ -1455,9 +1455,9 @@ static std::vector<MathLib::bigint> minUnsignedValue(const Token* tok, int depth
     return result;
 }
 
-static void valueFlowImpossibleValues(TokenList *tokenList, const Settings* settings)
+static void valueFlowImpossibleValues(TokenList* tokenList, const Settings* settings)
 {
-    for (Token *tok = tokenList->front(); tok; tok = tok->next()) {
+    for (Token* tok = tokenList->front(); tok; tok = tok->next()) {
         if (tok->hasKnownIntValue())
             continue;
         if (astIsUnsigned(tok)) {
@@ -4749,8 +4749,8 @@ ValueFlow::Value inferCondition(const std::string& op, const Token* varTok, Math
     if (varTok->hasKnownIntValue())
         return ValueFlow::Value{};
     if (std::none_of(varTok->values().begin(), varTok->values().end(), [](const ValueFlow::Value& v) {
-        return v.isImpossible() && v.valueType == ValueFlow::Value::ValueType::INT;
-    })) {
+            return v.isImpossible() && v.valueType == ValueFlow::Value::ValueType::INT;
+        })) {
         return ValueFlow::Value{};
     }
     const ValueFlow::Value* result = nullptr;
@@ -4818,11 +4818,11 @@ static void valueFlowInferCondition(TokenList* tokenlist,
             ValueFlow::Value value{};
             std::string op = tok->str();
             if (tok->astOperand1()->hasKnownIntValue()) {
-                MathLib::bigint val =  tok->astOperand1()->values().front().intvalue;
+                MathLib::bigint val = tok->astOperand1()->values().front().intvalue;
                 const Token* varTok = tok->astOperand2();
                 value = inferCondition(tok->str(), val, varTok);
             } else if (tok->astOperand2()->hasKnownIntValue()) {
-                MathLib::bigint val =  tok->astOperand2()->values().front().intvalue;
+                MathLib::bigint val = tok->astOperand2()->values().front().intvalue;
                 const Token* varTok = tok->astOperand1();
                 value = inferCondition(tok->str(), varTok, val);
             }

diff --git a/lib/valueflow.h b/lib/valueflow.h
@@ -56,15 +56,17 @@ namespace ValueFlow {
     };
 
     struct less {
-        template<class T, class U>
-        bool operator()(const T& x, const U& y) const {
+        template <class T, class U>
+        bool operator()(const T& x, const U& y) const
+        {
             return x < y;
         }
     };
 
     struct adjacent {
-        template<class T, class U>
-        bool operator()(const T& x, const U& y) const {
+        template <class T, class U>
+        bool operator()(const T& x, const U& y) const
+        {
             return std::abs(x - y) == 1;
         }
     };
@@ -160,23 +162,27 @@ namespace ValueFlow {
 
         struct compareVisitor {
             struct innerVisitor {
-                template<class Compare, class T, class U>
-                void operator()(bool& result, Compare compare, T x, U y) const {
+                template <class Compare, class T, class U>
+                void operator()(bool& result, Compare compare, T x, U y) const
+                {
                     result = compare(x, y);
                 }
             };
-            template<class Compare, class T>
-            void operator()(bool& result, const Value& rhs, Compare compare, T x) const {
-                visitValue(rhs, std::bind(innerVisitor{}, std::ref(result), std::move(compare), x, std::placeholders::_1));
+            template <class Compare, class T>
+            void operator()(bool& result, const Value& rhs, Compare compare, T x) const
+            {
+                visitValue(rhs,
+                           std::bind(innerVisitor{}, std::ref(result), std::move(compare), x, std::placeholders::_1));
             }
-
         };
 
-        template<class Compare>
+        template <class Compare>
         bool compareValue(const Value& rhs, Compare compare) const
         {
             bool result = false;
-            visitValue(*this, std::bind(compareVisitor{}, std::ref(result), std::ref(rhs), std::move(compare), std::placeholders::_1));
+            visitValue(
+                *this,
+                std::bind(compareVisitor{}, std::ref(result), std::ref(rhs), std::move(compare), std::placeholders::_1));
             return result;
         }
 

diff --git a/test/testcondition.cpp b/test/testcondition.cpp
@@ -1718,23 +1718,27 @@ class TestCondition : public TestFixture {
               "    b5 = a % 5 >= 5;\n"
               "    return a % 5 > 5;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:7]: (style) Condition 'a%5>5' is always false\n"
-                      "[test.cpp:2]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:3]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:4]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:5]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:6]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:7]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:7]: (style) Condition 'a%5>5' is always false\n"
+            "[test.cpp:2]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
+            "[test.cpp:3]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
+            "[test.cpp:4]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
+            "[test.cpp:5]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
+            "[test.cpp:6]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
+            "[test.cpp:7]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n",
+            errout.str());
 
         check("void f(bool& b1, bool& b2) {\n"
               "    b1 = bar() % 5 < 889;\n"
               "    if(x[593] % 5 <= 5)\n"
               "        b2 = x.a % 5 == 5;\n"
               "}");
-        ASSERT_EQUALS("[test.cpp:3]: (style) Condition 'x[593]%5<=5' is always true\n"
-                      "[test.cpp:2]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:3]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
-                      "[test.cpp:4]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n", errout.str());
+        ASSERT_EQUALS(
+            "[test.cpp:3]: (style) Condition 'x[593]%5<=5' is always true\n"
+            "[test.cpp:2]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
+            "[test.cpp:3]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n"
+            "[test.cpp:4]: (warning) Comparison of modulo result is predetermined, because it is always less than 5.\n",
+            errout.str());
 
         check("void f() {\n"
               "    if (a % 2 + b % 2 == 2)\n"

diff --git a/test/testvalueflow.cpp b/test/testvalueflow.cpp
@@ -409,7 +409,8 @@ class TestValueFlow : public TestFixture {
         ASSERT_EQUALS(0, valueOfTok("x(NULL);", "NULL").intvalue);
         ASSERT_EQUALS((int)('a'), valueOfTok("x='a';", "'a'").intvalue);
         ASSERT_EQUALS((int)('\n'), valueOfTok("x='\\n';", "'\\n'").intvalue);
-        TODO_ASSERT_EQUALS(0xFFFFFFFF00000000, -1, valueOfTok("x=0xFFFFFFFF00000000;","0xFFFFFFFF00000000").intvalue); // #7701
+        TODO_ASSERT_EQUALS(
+            0xFFFFFFFF00000000, -1, valueOfTok("x=0xFFFFFFFF00000000;", "0xFFFFFFFF00000000").intvalue); // #7701
 
         // scope
         {