Fixing conversion warnings caught by MSVC and adding flags if available on gcc

Author: LinuxDevon

CMakeLists.txt

@@ -63,10 +63,19 @@ if(DBC_GENERATE_DOCS)
     add_subdirectory(doc)
 endif()
 
+list(APPEND GCC_CLANG_COMPILE_FLAGS
+    -Wall -Wextra -Wpedantic
+    -Warith-conversion -Wconversion
+    -Wint-in-bool-context
+    -Wmissing-declarations
+    -Werror
+)
+
+
 if (MSVC)
     add_compile_options(/W4 /WX)
 else()
-    add_compile_options(-Wall -Wextra -Wpedantic -Werror)
+    add_compile_options(${GCC_CLANG_COMPILE_FLAGS})
 endif()
 
 add_library(${PROJECT_NAME} STATIC ${SOURCE_FILES})

src/dbc.cpp

@@ -1,3 +1,4 @@
+#include <cstdint>
 #include <libdbc/dbc.hpp>
 #include <libdbc/exceptions/error.hpp>
 #include <libdbc/utils/utils.hpp>
@@ -32,6 +33,7 @@ struct VALObject {
 	std::vector<libdbc::Signal::SignalValueDescriptions> vd;
 };
 
+static bool parseVal(const std::string& str, VALObject& obj);
 bool parseVal(const std::string& str, VALObject& obj) {
 	obj.signal_name = "";
 	obj.vd.clear();
@@ -67,7 +69,7 @@ bool parseVal(const std::string& str, VALObject& obj) {
 			}
 			if (can_id_str.empty())
 				return false;
-			obj.can_id = std::stoul(can_id_str);
+			obj.can_id = static_cast<uint32_t>(std::stoul(can_id_str));
 			if (*a != ' ')
 				return false;
 			a++; // skip whitespace
@@ -237,9 +239,9 @@ void DbcParser::parse_dbc_messages(const std::vector<std::string>& lines) {
 	VALObject obj;
 	for (const auto& line : lines) {
 		if (std::regex_search(line, match, message_re)) {
-			uint32_t id = std::stoul(match.str(2));
+			uint32_t id = static_cast<uint32_t>(std::stoul(match.str(2)));
 			std::string name = match.str(3);
-			uint8_t size = std::stoul(match.str(4));
+			uint8_t size = static_cast<uint8_t>(std::stoul(match.str(4)));
 			std::string node = match.str(5);
 
 			Message msg(id, name, size, node);
@@ -251,8 +253,8 @@ void DbcParser::parse_dbc_messages(const std::vector<std::string>& lines) {
 		if (std::regex_search(line, match, signal_re)) {
 			std::string name = match.str(2);
 			bool is_multiplexed = false; // No support yet
-			uint32_t start_bit = std::stoul(match.str(3));
-			uint32_t size = std::stoul(match.str(4));
+			uint32_t start_bit = static_cast<uint32_t>(std::stoul(match.str(3)));
+			uint32_t size = static_cast<uint32_t>(std::stoul(match.str(4)));
 			bool is_bigendian = (std::stoul(match.str(5)) == 0);
 			bool is_signed = (match.str(6) == "-");
 

src/message.cpp

@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <cstdint>
 #include <libdbc/message.hpp>
 
 namespace libdbc {
@@ -14,20 +15,20 @@ bool Message::operator==(const Message& rhs) const {
 }
 
 Message::ParseSignalsStatus Message::parseSignals(const std::vector<uint8_t>& data, std::vector<double>& values) const {
-	int size = data.size();
+	auto size = data.size();
 	if (size > 8)
 		return ParseSignalsStatus::ErrorMessageToLong; // not supported yet
 
 	uint64_t data_little_endian = 0;
 	uint64_t data_big_endian = 0;
-	for (int i = 0; i < size; i++) {
+	for (size_t i = 0; i < size; i++) {
 		data_little_endian |= ((uint64_t)data[i]) << i * 8;
 		data_big_endian = (data_big_endian << 8) | (uint64_t)data[i];
 	}
 
 	// TODO: does this also work on a big endian machine?
 
-	const uint32_t len = size * 8;
+	const auto len = size * 8;
 	uint64_t v = 0;
 	for (const auto& signal : m_signals) {
 		if (signal.is_bigendian) {
@@ -40,33 +41,33 @@ Message::ParseSignalsStatus Message::parseSignals(const std::vector<uint8_t>& da
 		if (signal.is_signed && signal.size > 1) {
 			switch (signal.size) {
 			case 8:
-				values.push_back((int8_t)v * signal.factor + signal.offset);
+				values.push_back(static_cast<int8_t>(v) * signal.factor + signal.offset);
 				break;
 			case 16:
-				values.push_back((int16_t)v * signal.factor + signal.offset);
+				values.push_back(static_cast<int16_t>(v) * signal.factor + signal.offset);
 				break;
 			case 32:
-				values.push_back((int32_t)v * signal.factor + signal.offset);
+				values.push_back(static_cast<int32_t>(v) * signal.factor + signal.offset);
 				break;
 			case 64:
-				values.push_back((int64_t)v * signal.factor + signal.offset);
+				values.push_back(static_cast<double>(v) * signal.factor + signal.offset);
 				break;
 			default: {
 				// 2 complement -> decimal
-				const int negative = (v & (1 << (signal.size - 1))) != 0;
+				const int negative = (v & (1ull << (signal.size - 1))) != 0;
 				int64_t nativeInt;
 				if (negative)
-					nativeInt = v | ~((1 << signal.size) - 1); // invert all bits above signal.size
+					nativeInt = v | ~((1ull << signal.size) - 1); // invert all bits above signal.size
 				else
-					nativeInt = v & ((1 << signal.size) - 1); // masking
-				values.push_back(nativeInt * signal.factor + signal.offset);
+					nativeInt = v & ((1ull << signal.size) - 1); // masking
+				values.push_back(static_cast<double>(nativeInt) * signal.factor + signal.offset);
 				break;
 			}
 			}
 		} else {
 			// use only the relevant bits
 			v = v & ((1 << signal.size) - 1); // masking
-			values.push_back(v * signal.factor + signal.offset);
+			values.push_back(static_cast<double>(v) * signal.factor + signal.offset);
 		}
 	}
 	return ParseSignalsStatus::Success;