explicitly convert MathLib::big{u}int to/from other types / small cleanup (danmar#7129)

firewave · web-flow · commit 047b7259733b · 2025-01-01T23:11:51.000+01:00
fixes some compiler warnings with `USE_BOOST_INT128` as those implicit
conversions are not allowed
diff --git a/lib/checkother.cpp b/lib/checkother.cpp
@@ -4056,7 +4056,7 @@ void CheckOther::knownPointerToBoolError(const Token* tok, const ValueFlow::Valu
         reportError(tok, Severity::style, "knownPointerToBool", "Pointer expression 'p' converted to bool is always true.");
         return;
     }
-    std::string cond = bool_to_string(value->intvalue);
+    std::string cond = bool_to_string(!!value->intvalue);
     const std::string& expr = tok->expressionString();
     std::string errmsg = "Pointer expression '" + expr + "' converted to bool is always " + cond + ".";
     const ErrorPath errorPath = getErrorPath(tok, value, errmsg);
diff --git a/lib/fwdanalysis.cpp b/lib/fwdanalysis.cpp
@@ -224,7 +224,7 @@ FwdAnalysis::Result FwdAnalysis::checkRecursive(const Token *expr, const Token *
             const Token *conditionStart = tok->next();
             const Token *condTok = conditionStart->astOperand2();
             if (condTok->hasKnownIntValue()) {
-                const bool cond = condTok->values().front().intvalue;
+                const bool cond = !!condTok->values().front().intvalue;
                 if (cond) {
                     FwdAnalysis::Result result = checkRecursive(expr, bodyStart, bodyStart->link(), exprVarIds, local, true, depth);
                     if (result.type != Result::Type::NONE)
diff --git a/lib/infer.cpp b/lib/infer.cpp
@@ -349,7 +349,7 @@ std::vector<ValueFlow::Value> infer(const ValuePtr<InferModel>& model,
         std::vector<const ValueFlow::Value*> refs;
         std::vector<bool> r = Interval::compare(op, lhs, rhs, &refs);
         if (!r.empty()) {
-            ValueFlow::Value value(r.front());
+            ValueFlow::Value value(static_cast<int>(r.front()));
             addToErrorPath(value, refs);
             setValueKind(value, refs);
             result.push_back(std::move(value));
diff --git a/lib/library.cpp b/lib/library.cpp
@@ -1055,7 +1055,7 @@ bool Library::isIntArgValid(const Token *ftok, int argnr, const MathLib::bigint
     if (!ac || ac->valid.empty())
         return true;
     if (ac->valid.find('.') != std::string::npos)
-        return isFloatArgValid(ftok, argnr, argvalue);
+        return isFloatArgValid(ftok, argnr, static_cast<double>(argvalue));
     TokenList tokenList(nullptr);
     gettokenlistfromvalid(ac->valid, ftok->isCpp(), tokenList);
     for (const Token *tok = tokenList.front(); tok; tok = tok->next()) {
diff --git a/lib/mathlib.cpp b/lib/mathlib.cpp
@@ -116,7 +116,7 @@ void MathLib::value::promote(const MathLib::value &v)
         }
     } else if (!isFloat()) {
         mIsUnsigned = false;
-        mDoubleValue = mIntValue;
+        mDoubleValue = static_cast<double>(mIntValue);
         mType = MathLib::value::Type::FLOAT;
     }
 }
diff --git a/lib/pathanalysis.cpp b/lib/pathanalysis.cpp
@@ -50,7 +50,7 @@ std::pair<bool, bool> PathAnalysis::checkCond(const Token * tok, bool& known)
 {
     if (tok->hasKnownIntValue()) {
         known = true;
-        return std::make_pair(tok->values().front().intvalue, !tok->values().front().intvalue);
+        return std::make_pair(!!tok->values().front().intvalue, !tok->values().front().intvalue);
     }
     auto it = std::find_if(tok->values().cbegin(), tok->values().cend(), [](const ValueFlow::Value& v) {
         return v.isIntValue();
@@ -62,7 +62,7 @@ std::pair<bool, bool> PathAnalysis::checkCond(const Token * tok, bool& known)
         return true;
     })) {
         known = false;
-        return std::make_pair(it->intvalue, !it->intvalue);
+        return std::make_pair(!!it->intvalue, !it->intvalue);
     }
     return std::make_pair(true, true);
 }
diff --git a/lib/programmemory.cpp b/lib/programmemory.cpp
diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
@@ -9894,7 +9894,7 @@ void Tokenizer::simplifyBitfields()
             !Token::simpleMatch(tok->tokAt(2), "default :")) {
             Token *tok1 = (tok->strAt(1) == "const") ? tok->tokAt(3) : tok->tokAt(2);
             if (Token::Match(tok1, "%name% : %num% [;=]"))
-                tok1->setBits(MathLib::toBigNumber(tok1->strAt(2)));
+                tok1->setBits(static_cast<unsigned char>(MathLib::toBigNumber(tok1->strAt(2))));
             if (tok1 && tok1->tokAt(2) &&
                 (Token::Match(tok1->tokAt(2), "%bool%|%num%") ||
                  !Token::Match(tok1->tokAt(2), "public|protected|private| %type% ::|<|,|{|;"))) {
diff --git a/lib/valueflow.cpp b/lib/valueflow.cpp
@@ -759,14 +759,14 @@ static void valueFlowArrayElement(TokenList& tokenlist, const Settings& settings
                         result.intvalue = 0;
                         setTokenValue(tok, std::move(result), settings);
                     } else if (index >= 0 && index < s.size()) {
-                        result.intvalue = s[index];
+                        result.intvalue = s[static_cast<std::size_t>(index)];
                         setTokenValue(tok, std::move(result), settings);
                     }
                 } else if (Token::simpleMatch(arrayValue.tokvalue, "{")) {
                     std::vector<const Token*> args = getArguments(arrayValue.tokvalue);
                     if (index < 0 || index >= args.size())
                         continue;
-                    const Token* arg = args[index];
+                    const Token* arg = args[static_cast<std::size_t>(index)];
                     if (!arg->hasKnownIntValue())
                         continue;
                     const ValueFlow::Value& v = arg->values().front();
@@ -3982,7 +3982,7 @@ static std::list<ValueFlow::Value> truncateValues(std::list<ValueFlow::Value> va
         if (value.isImpossible())
             continue;
         if (value.isFloatValue()) {
-            value.intvalue = value.floatValue;
+            value.intvalue = static_cast<MathLib::bigint>(value.floatValue);
             value.valueType = ValueFlow::Value::ValueType::INT;
         }
 
@@ -4505,7 +4505,7 @@ struct ConditionHandler {
             if (Token::Match(tok->astParent(), "==|!=")) {
                 const Token* sibling = tok->astSibling();
                 if (sibling->hasKnownIntValue() && (astIsBool(tok) || astIsBool(sibling))) {
-                    const bool value = sibling->values().front().intvalue;
+                    const bool value = !!sibling->values().front().intvalue;
                     if (inverted)
                         *inverted ^= value == Token::simpleMatch(tok->astParent(), "!=");
                     continue;
@@ -6916,12 +6916,12 @@ static void valueFlowSafeFunctions(const TokenList& tokenlist, const SymbolDatab
                     std::list<ValueFlow::Value> argValues;
                     argValues.emplace_back(0);
                     argValues.back().valueType = ValueFlow::Value::ValueType::FLOAT;
-                    argValues.back().floatValue = isLow ? low : -1E25;
+                    argValues.back().floatValue = isLow ? static_cast<double>(low) : -1E25;
                     argValues.back().errorPath.emplace_back(arg.nameToken(), "Safe checks: Assuming argument has value " + MathLib::toString(argValues.back().floatValue));
                     argValues.back().safe = true;
                     argValues.emplace_back(0);
                     argValues.back().valueType = ValueFlow::Value::ValueType::FLOAT;
-                    argValues.back().floatValue = isHigh ? high : 1E25;
+                    argValues.back().floatValue = isHigh ? static_cast<double>(high) : 1E25;
                     argValues.back().errorPath.emplace_back(arg.nameToken(), "Safe checks: Assuming argument has value " + MathLib::toString(argValues.back().floatValue));
                     argValues.back().safe = true;
                     valueFlowForward(const_cast<Token*>(functionScope->bodyStart->next()),
diff --git a/lib/vf_analyzers.cpp b/lib/vf_analyzers.cpp
@@ -470,7 +470,7 @@ struct ValueFlowAnalyzer : Analyzer {
             return T{};
         }
         if (assign == "=")
-            return y;
+            return static_cast<T>(y);
         return calculate<T, T>(removeAssign(assign), x, y, error);
     }
 
diff --git a/lib/vf_common.cpp b/lib/vf_common.cpp
@@ -335,7 +335,7 @@ namespace ValueFlow
         if (value.isFloatValue()) {
             value.valueType = Value::ValueType::INT;
             if (value.floatValue >= std::numeric_limits<int>::min() && value.floatValue <= std::numeric_limits<int>::max()) {
-                value.intvalue = value.floatValue;
+                value.intvalue = static_cast<MathLib::bigint>(value.floatValue);
             } else { // don't perform UB
                 value.intvalue = 0;
             }
diff --git a/lib/vf_settokenvalue.cpp b/lib/vf_settokenvalue.cpp
@@ -143,7 +143,7 @@ namespace ValueFlow
             Value floatValue = value;
             floatValue.valueType = Value::ValueType::FLOAT;
             if (value.isIntValue())
-                floatValue.floatValue = value.intvalue;
+                floatValue.floatValue = static_cast<double>(value.intvalue);
             setTokenValue(parent, std::move(floatValue), settings);
         } else if (value.isIntValue()) {
             const long long charMax = settings.platform.signedCharMax();
@@ -494,8 +494,8 @@ namespace ValueFlow
                             continue;
                         result.valueType = Value::ValueType::FLOAT;
                     }
-                    const double floatValue1 = value1.isFloatValue() ? value1.floatValue : value1.intvalue;
-                    const double floatValue2 = value2.isFloatValue() ? value2.floatValue : value2.intvalue;
+                    const double floatValue1 = value1.isFloatValue() ? value1.floatValue : static_cast<double>(value1.intvalue);
+                    const double floatValue2 = value2.isFloatValue() ? value2.floatValue : static_cast<double>(value2.intvalue);
                     const auto intValue1 = [&]() -> MathLib::bigint {
                         return value1.isFloatValue() ? static_cast<MathLib::bigint>(value1.floatValue) : value1.intvalue;
                     };

Original file line number	Diff line number	Diff line change
`@@ -4056,7 +4056,7 @@ void CheckOther::knownPointerToBoolError(const Token* tok, const ValueFlow::Valu`
`4056`	`4056`	`reportError(tok, Severity::style, "knownPointerToBool", "Pointer expression 'p' converted to bool is always true.");`
`4057`	`4057`	`return;`
`4058`	`4058`	`}`
`4059`		`- std::string cond = bool_to_string(value->intvalue);`
	`4059`	`+ std::string cond = bool_to_string(!!value->intvalue);`
`4060`	`4060`	`const std::string& expr = tok->expressionString();`
`4061`	`4061`	`std::string errmsg = "Pointer expression '" + expr + "' converted to bool is always " + cond + ".";`
`4062`	`4062`	`const ErrorPath errorPath = getErrorPath(tok, value, errmsg);`
Original file line number	Diff line number	Diff line change
`@@ -116,7 +116,7 @@ void MathLib::value::promote(const MathLib::value &v)`
`116`	`116`	`}`
`117`	`117`	`} else if (!isFloat()) {`
`118`	`118`	`mIsUnsigned = false;`
`119`		`- mDoubleValue = mIntValue;`
	`119`	`+ mDoubleValue = static_cast<double>(mIntValue);`
`120`	`120`	`mType = MathLib::value::Type::FLOAT;`
`121`	`121`	`}`
`122`	`122`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ std::pair<bool, bool> PathAnalysis::checkCond(const Token * tok, bool& known)`
`50`	`50`	`{`
`51`	`51`	`if (tok->hasKnownIntValue()) {`
`52`	`52`	`known = true;`
`53`		`- return std::make_pair(tok->values().front().intvalue, !tok->values().front().intvalue);`
	`53`	`+ return std::make_pair(!!tok->values().front().intvalue, !tok->values().front().intvalue);`
`54`	`54`	`}`
`55`	`55`	`auto it = std::find_if(tok->values().cbegin(), tok->values().cend(), [](const ValueFlow::Value& v) {`
`56`	`56`	`return v.isIntValue();`
`@@ -62,7 +62,7 @@ std::pair<bool, bool> PathAnalysis::checkCond(const Token * tok, bool& known)`
`62`	`62`	`return true;`
`63`	`63`	`})) {`
`64`	`64`	`known = false;`
`65`		`- return std::make_pair(it->intvalue, !it->intvalue);`
	`65`	`+ return std::make_pair(!!it->intvalue, !it->intvalue);`
`66`	`66`	`}`
`67`	`67`	`return std::make_pair(true, true);`
`68`	`68`	`}`
Original file line number	Diff line number	Diff line change
`@@ -470,7 +470,7 @@ struct ValueFlowAnalyzer : Analyzer {`
`470`	`470`	`return T{};`
`471`	`471`	`}`
`472`	`472`	`if (assign == "=")`
`473`		`- return y;`
	`473`	`+ return static_cast<T>(y);`
`474`	`474`	`return calculate<T, T>(removeAssign(assign), x, y, error);`
`475`	`475`	`}`
`476`	`476`