fix warnings

Author: jlblancoc

.vscode/settings.json

@@ -17,12 +17,12 @@
         "--pretty"
     ],
     "[cpp]": {
-        "editor.defaultFormatter": "llvm-vs-code-extensions.vscode-clangd",
+        "editor.defaultFormatter": "xaver.clang-format",
         "editor.rulers": [
             100
         ]
     },
-    "[cmake]": { 
+    "[cmake]": {
         "editor.tabSize": 2,
     },
     "cSpell.allowCompoundWords": true,

modules/mrpt_serialization/include/mrpt/serialization/archiveFrom_std_streams.h

@@ -32,7 +32,7 @@ class CArchiveStreamBase<std::istream> : public CArchive
   }
   size_t read(void* d, size_t n) override
   {
-    if (m_s.read(reinterpret_cast<char*>(d), n))
+    if (m_s.read(reinterpret_cast<char*>(d), static_cast<std::streamsize>(n)))
     {
       return n;
     }
@@ -58,7 +58,7 @@ class CArchiveStreamBase<std::ostream> : public CArchive
     }
     return 0;
   }
-  size_t read(void* d, size_t n) override
+  size_t read([[maybe_unused]] void* d, [[maybe_unused]] size_t n) override
   {
     throw std::runtime_error("CArchiveStreamBase<std::ostream>: cannot read from output stream.");
   }

modules/mrpt_serialization/src/CArchive.cpp

@@ -539,7 +539,7 @@ void CArchive::sendMessage(const CMessage& msg)
   MRPT_START
 
   std::array<uint8_t, 0x10100> buf{};
-  unsigned int nBytesTx = 0;
+  std::size_t nBytesTx = 0;
 
   const bool msg_format_is_tiny = msg.content.size() < 256;
 
@@ -574,11 +574,11 @@ bool CArchive::receiveMessage(CMessage& msg)
 {
   MRPT_START
   std::vector<unsigned char> buf(66000);
-  unsigned int nBytesInFrame = 0;
-  unsigned long nBytesToRx = 0;
-  unsigned char tries = 2;
-  unsigned int payload_len = 0;
-  unsigned int expectedLen = 0;
+  std::size_t nBytesInFrame = 0;
+  std::size_t nBytesToRx = 0;
+  uint8_t tries = 2;
+  std::size_t payload_len = 0;
+  std::size_t expectedLen = 0;
 
   for (;;)
   {

modules/mrpt_system/src/md5.cpp

@@ -78,35 +78,37 @@ class MD5
 
  private:
   void init();
-  using uint1 = unsigned char;  //  8bit
-  using uint4 = unsigned int;   // 32bit
   enum
   {
     blocksize = 64
   };  // VC6 won't eat a const static int here
 
-  void transform(const uint1 block[blocksize]);
-  static void decode(uint4 output[], const uint1 input[], size_type len);
-  static void encode(uint1 output[], const uint4 input[], size_type len);
+  void transform(const uint8_t block[blocksize]);
+  static void decode(uint32_t output[], const uint8_t input[], size_type len);
+  static void encode(uint8_t output[], const uint32_t input[], size_type len);
 
   bool finalized{false};
   // bytes that didn't fit in last 64 byte chunk
-  uint1 buffer[blocksize]{};
-  uint4 count[2] = {0, 0};  // 64bit counter for number of bits (lo, hi)
+  uint8_t buffer[blocksize]{};
+  uint32_t count[2] = {0, 0};  // 64bit counter for number of bits (lo, hi)
   // load magic initialization constants:
-  uint4 state[4] = {0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476};
-  uint1 digest[16]{};  // the result
+  uint32_t state[4] = {0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476};
+  uint8_t digest[16]{};  // the result
 
   // low level logic operations
-  static inline uint4 F(uint4 x, uint4 y, uint4 z);
-  static inline uint4 G(uint4 x, uint4 y, uint4 z);
-  static inline uint4 H(uint4 x, uint4 y, uint4 z);
-  static inline uint4 I(uint4 x, uint4 y, uint4 z);
-  static inline uint4 rotate_left(uint4 x, int n);
-  static inline void FF(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
-  static inline void GG(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
-  static inline void HH(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
-  static inline void II(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+  static inline uint32_t F(uint32_t x, uint32_t y, uint32_t z);
+  static inline uint32_t G(uint32_t x, uint32_t y, uint32_t z);
+  static inline uint32_t H(uint32_t x, uint32_t y, uint32_t z);
+  static inline uint32_t I(uint32_t x, uint32_t y, uint32_t z);
+  static inline uint32_t rotate_left(uint32_t x, uint32_t n);
+  static inline void FF(
+      uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac);
+  static inline void GG(
+      uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac);
+  static inline void HH(
+      uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac);
+  static inline void II(
+      uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac);
 };
 
 // Constants for MD5Transform routine.
@@ -130,33 +132,37 @@ class MD5
 ///////////////////////////////////////////////
 
 // F, G, H and I are basic MD5 functions.
-inline MD5::uint4 MD5::F(uint4 x, uint4 y, uint4 z) { return (x & y) | (~x & z); }
+inline uint32_t MD5::F(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (~x & z); }
 
-inline MD5::uint4 MD5::G(uint4 x, uint4 y, uint4 z) { return (x & z) | (y & ~z); }
+inline uint32_t MD5::G(uint32_t x, uint32_t y, uint32_t z) { return (x & z) | (y & ~z); }
 
-inline MD5::uint4 MD5::H(uint4 x, uint4 y, uint4 z) { return x ^ y ^ z; }
-inline MD5::uint4 MD5::I(uint4 x, uint4 y, uint4 z) { return y ^ (x | ~z); }
+inline uint32_t MD5::H(uint32_t x, uint32_t y, uint32_t z) { return x ^ y ^ z; }
+inline uint32_t MD5::I(uint32_t x, uint32_t y, uint32_t z) { return y ^ (x | ~z); }
 // rotate_left rotates x left n bits.
-inline MD5::uint4 MD5::rotate_left(uint4 x, int n) { return (x << n) | (x >> (32 - n)); }
+inline uint32_t MD5::rotate_left(uint32_t x, uint32_t n) { return (x << n) | (x >> (32 - n)); }
 
 // FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
 // Rotation is separate from addition to prevent recomputation.
-inline void MD5::FF(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac)
+inline void MD5::FF(
+    uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac)
 {
   a = rotate_left(a + F(b, c, d) + x + ac, s) + b;
 }
 
-inline void MD5::GG(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac)
+inline void MD5::GG(
+    uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac)
 {
   a = rotate_left(a + G(b, c, d) + x + ac, s) + b;
 }
 
-inline void MD5::HH(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac)
+inline void MD5::HH(
+    uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac)
 {
   a = rotate_left(a + H(b, c, d) + x + ac, s) + b;
 }
 
-inline void MD5::II(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac)
+inline void MD5::II(
+    uint32_t& a, uint32_t b, uint32_t c, uint32_t d, uint32_t x, uint32_t s, uint32_t ac)
 {
   a = rotate_left(a + I(b, c, d) + x + ac, s) + b;
 }
@@ -167,7 +173,7 @@ inline void MD5::II(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4
 MD5::MD5(const std::string& text)
 {
   init();
-  update(text.c_str(), text.length());
+  update(text.c_str(), static_cast<size_type>(text.length()));
   finalize();
 }
 
@@ -177,38 +183,40 @@ void MD5::init() { *this = MD5(); }
 
 //////////////////////////////
 
-// decodes input (unsigned char) into output (uint4). Assumes len is a multiple
+// decodes input (unsigned char) into output (uint32_t). Assumes len is a multiple
 // of 4.
-void MD5::decode(uint4 output[], const uint1 input[], size_type len)
+void MD5::decode(uint32_t output[], const uint8_t input[], size_type len)
 {
   for (unsigned int i = 0, j = 0; j < len; i++, j += 4)
   {
-    output[i] = ((uint4)input[j]) | (((uint4)input[j + 1]) << 8) | (((uint4)input[j + 2]) << 16) |
-                (((uint4)input[j + 3]) << 24);
+    output[i] = (static_cast<uint32_t>(input[j])) |  //
+                ((static_cast<uint32_t>(input[j + 1])) << 8) |
+                ((static_cast<uint32_t>(input[j + 2])) << 16) |
+                ((static_cast<uint32_t>(input[j + 3])) << 24);
   }
 }
 
 //////////////////////////////
 
-// encodes input (uint4) into output (unsigned char). Assumes len is
+// encodes input (uint32_t) into output (unsigned char). Assumes len is
 // a multiple of 4.
-void MD5::encode(uint1 output[], const uint4 input[], size_type len)
+void MD5::encode(uint8_t output[], const uint32_t input[], size_type len)
 {
   for (size_type i = 0, j = 0; j < len; i++, j += 4)
   {
-    output[j] = input[i] & 0xff;
-    output[j + 1] = (input[i] >> 8) & 0xff;
-    output[j + 2] = (input[i] >> 16) & 0xff;
-    output[j + 3] = (input[i] >> 24) & 0xff;
+    output[j] = static_cast<uint8_t>(input[i] & 0xff);
+    output[j + 1] = static_cast<uint8_t>((input[i] >> 8) & 0xff);
+    output[j + 2] = static_cast<uint8_t>((input[i] >> 16) & 0xff);
+    output[j + 3] = static_cast<uint8_t>((input[i] >> 24) & 0xff);
   }
 }
 
 //////////////////////////////
 
 // apply MD5 algo on a block
-void MD5::transform(const uint1 block[blocksize])
+void MD5::transform(const uint8_t block[blocksize])
 {
-  uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+  uint32_t a = state[0], b = state[1], c = state[2], d = state[3], x[16];
   decode(x, block, blocksize);
 
   /* Round 1 */
@@ -419,7 +427,7 @@ std::string mrpt::system::md5(const unsigned char* data, size_t len)
 {
   ASSERT_(data);
   MD5 md5;
-  md5.update(data, len);
+  md5.update(data, static_cast<uint32_t>(len));
   md5.finalize();
 
   return md5.hexdigest();