Use size_t for unsigned lengths to address conversion warnings

mqudsi · mqudsi · commit b5bc1e6797c1 · 2025-06-02T15:14:54.000-05:00
diff --git a/src/CppSQLite3.cpp b/src/CppSQLite3.cpp
@@ -35,8 +35,8 @@ SQLite3Memory::SQLite3Memory() :
 {
 }
 
-SQLite3Memory::SQLite3Memory(int nBufferLen) :
-    mpBuf(sqlite3_malloc(nBufferLen)),
+SQLite3Memory::SQLite3Memory(size_t nBufferLen) :
+    mpBuf(sqlite3_malloc(static_cast<int>(nBufferLen))),
     mnBufferLen(nBufferLen)
 {
     if (!mpBuf && mnBufferLen>0)
@@ -66,7 +66,7 @@ SQLite3Memory::~SQLite3Memory()
 }
 
 SQLite3Memory::SQLite3Memory(SQLite3Memory const& other) :
-    mpBuf(sqlite3_malloc(other.mnBufferLen)),
+    mpBuf(sqlite3_malloc(static_cast<int>(other.mnBufferLen))),
     mnBufferLen(other.mnBufferLen)
 {
     if (!mpBuf && mnBufferLen>0)
@@ -128,7 +128,7 @@ CppSQLite3Exception::CppSQLite3Exception(const int nErrCode,
 
     if (bDeleteMsg && szErrMess)
     {
-        sqlite3_free((void*)szErrMess);
+        sqlite3_free(static_cast<void*>(const_cast<char*>(szErrMess)));
     }
 }
 
@@ -238,7 +238,7 @@ CppSQLite3Binary::~CppSQLite3Binary()
 }
 
 
-void CppSQLite3Binary::setBinary(const unsigned char* pBuf, int nLen)
+void CppSQLite3Binary::setBinary(const unsigned char* pBuf, size_t nLen)
 {
     mpBuf = allocBuffer(nLen);
     memcpy(mpBuf, pBuf, nLen);
@@ -249,10 +249,10 @@ void CppSQLite3Binary::setEncoded(const unsigned char* pBuf)
 {
     clear();
 
-    mnEncodedLen = strlen((const char*)pBuf);
+    mnEncodedLen = strlen(reinterpret_cast<const char*>(pBuf));
     mnBufferLen = mnEncodedLen + 1; // Allow for NULL terminator
 
-    mpBuf = (unsigned char*)malloc(mnBufferLen);
+    mpBuf = reinterpret_cast<unsigned char*>(malloc(mnBufferLen));
 
     if (!mpBuf)
     {
@@ -270,9 +270,9 @@ const unsigned char* CppSQLite3Binary::getEncoded()
 {
     if (!mbEncoded)
     {
-        unsigned char* ptmp = (unsigned char*)malloc(mnBinaryLen);
+        unsigned char* ptmp = reinterpret_cast<unsigned char*>(malloc(mnBinaryLen));
         memcpy(ptmp, mpBuf, mnBinaryLen);
-        mnEncodedLen = sqlite3_encode_binary(ptmp, mnBinaryLen, mpBuf);
+        mnEncodedLen = static_cast<size_t>(sqlite3_encode_binary(ptmp, static_cast<int>(mnBinaryLen), mpBuf));
         free(ptmp);
         mbEncoded = true;
     }
@@ -286,30 +286,30 @@ const unsigned char* CppSQLite3Binary::getBinary()
     if (mbEncoded)
     {
         // in/out buffers can be the same
-        mnBinaryLen = sqlite3_decode_binary(mpBuf, mpBuf);
+        int result = sqlite3_decode_binary(mpBuf, mpBuf);
 
-        if (mnBinaryLen == -1)
+        if (result == -1)
         {
             throw CppSQLite3Exception(CPPSQLITE_ERROR,
                                     "Cannot decode binary",
                                     DONT_DELETE_MSG);
         }
-
+        mnBinaryLen = static_cast<size_t>(result);
         mbEncoded = false;
     }
 
     return mpBuf;
 }
 
 
-int CppSQLite3Binary::getBinaryLength()
+size_t CppSQLite3Binary::getBinaryLength()
 {
     getBinary();
     return mnBinaryLen;
 }
 
 
-unsigned char* CppSQLite3Binary::allocBuffer(int nLen)
+unsigned char* CppSQLite3Binary::allocBuffer(size_t nLen)
 {
     clear();
 
@@ -319,7 +319,7 @@ unsigned char* CppSQLite3Binary::allocBuffer(int nLen)
     mnBinaryLen = nLen;
     mnBufferLen = 3 + (257*nLen)/254;
 
-    mpBuf = (unsigned char*)malloc(mnBufferLen);
+    mpBuf = static_cast<unsigned char*>(malloc(mnBufferLen));
 
     if (!mpBuf)
     {
@@ -430,14 +430,14 @@ const char* CppSQLite3Query::fieldValue(int nField) const
                                 DONT_DELETE_MSG);
     }
 
-    return (const char*)sqlite3_column_text(mpVM, nField);
+    return reinterpret_cast<const char*>(sqlite3_column_text(mpVM, nField));
 }
 
 
 const char* CppSQLite3Query::fieldValue(const char* szField) const
 {
     int nField = fieldIndex(szField);
-    return (const char*)sqlite3_column_text(mpVM, nField);
+    return reinterpret_cast<const char*>(sqlite3_column_text(mpVM, nField));
 }
 
 
@@ -529,7 +529,7 @@ const char* CppSQLite3Query::getStringField(int nField, const char* szNullValue/
     }
     else
     {
-        return (const char*)sqlite3_column_text(mpVM, nField);
+        return reinterpret_cast<const char*>(sqlite3_column_text(mpVM, nField));
     }
 }
 
@@ -541,7 +541,7 @@ const char* CppSQLite3Query::getStringField(const char* szField, const char* szN
 }
 
 
-const unsigned char* CppSQLite3Query::getBlobField(int nField, int& nLen) const
+const unsigned char* CppSQLite3Query::getBlobField(int nField, size_t& nLen) const
 {
     checkVM();
 
@@ -552,12 +552,12 @@ const unsigned char* CppSQLite3Query::getBlobField(int nField, int& nLen) const
                                 DONT_DELETE_MSG);
     }
 
-    nLen = sqlite3_column_bytes(mpVM, nField);
-    return (const unsigned char*)sqlite3_column_blob(mpVM, nField);
+    nLen = static_cast<size_t>(sqlite3_column_bytes(mpVM, nField));
+    return reinterpret_cast<const unsigned char*>(sqlite3_column_blob(mpVM, nField));
 }
 
 
-const unsigned char* CppSQLite3Query::getBlobField(const char* szField, int& nLen) const
+const unsigned char* CppSQLite3Query::getBlobField(const char* szField, size_t& nLen) const
 {
     int nField = fieldIndex(szField);
     return getBlobField(nField, nLen);
@@ -1147,11 +1147,11 @@ void CppSQLite3Statement::bind(int nParam, const double dValue)
 }
 
 
-void CppSQLite3Statement::bind(int nParam, const unsigned char* blobValue, int nLen)
+void CppSQLite3Statement::bind(int nParam, const unsigned char* blobValue, size_t nLen)
 {
     checkVM();
-    int nRes = sqlite3_bind_blob(mpVM, nParam,
-                                (const void*)blobValue, nLen, SQLITE_TRANSIENT);
+    int nRes = sqlite3_bind_blob(mpVM, nParam, static_cast<const void*>(blobValue),
+            static_cast<int>(nLen), SQLITE_TRANSIENT);
 
     if (nRes != SQLITE_OK)
     {
diff --git a/src/CppSQLite3.h b/src/CppSQLite3.h
@@ -27,7 +27,7 @@ namespace detail
         // Default constructor
         SQLite3Memory();
         // Constructor that allocates memory of a given size
-        SQLite3Memory(int nBufferLen);
+        SQLite3Memory(size_t nBufferLen);
         // Constructor that formats a string with sqlite memory allocation
         SQLite3Memory(const char* szFormat, va_list list);
         // Destructor
@@ -46,7 +46,7 @@ namespace detail
         // Swap operation
         void swap(SQLite3Memory& other);
 
-        int getLength() const { return mnBufferLen; }
+        size_t getLength() const { return mnBufferLen; }
 
         void* getBuffer() const { return mpBuf; }
 
@@ -55,7 +55,7 @@ namespace detail
     private:
 
         void* mpBuf;
-        int mnBufferLen;
+        size_t mnBufferLen;
     };
 }
 
@@ -110,24 +110,24 @@ class CppSQLite3Binary
 
     ~CppSQLite3Binary();
 
-    void setBinary(const unsigned char* pBuf, int nLen);
+    void setBinary(const unsigned char* pBuf, size_t nLen);
     void setEncoded(const unsigned char* pBuf);
 
     const unsigned char* getEncoded();
     const unsigned char* getBinary();
 
-    int getBinaryLength();
+    size_t getBinaryLength();
 
-    unsigned char* allocBuffer(int nLen);
+    unsigned char* allocBuffer(size_t nLen);
 
     void clear();
 
 private:
 
     unsigned char* mpBuf;
-    int mnBinaryLen;
-    int mnBufferLen;
-    int mnEncodedLen;
+    size_t mnBinaryLen;
+    size_t mnBufferLen;
+    size_t mnEncodedLen;
     bool mbEncoded;
 };
 
@@ -175,8 +175,8 @@ class CppSQLite3Query
     const char* getStringField(int nField, const char* szNullValue="") const;
     const char* getStringField(const char* szField, const char* szNullValue="") const;
 
-    const unsigned char* getBlobField(int nField, int& nLen) const;
-    const unsigned char* getBlobField(const char* szField, int& nLen) const;
+    const unsigned char* getBlobField(int nField, size_t& nLen) const;
+    const unsigned char* getBlobField(const char* szField, size_t& nLen) const;
 
     bool fieldIsNull(int nField) const;
     bool fieldIsNull(const char* szField) const;
@@ -274,7 +274,7 @@ class CppSQLite3Statement
     void bind(int nParam, const int nValue);
     void bind(int nParam, const long long nValue);
     void bind(int nParam, const double dwValue);
-    void bind(int nParam, const unsigned char* blobValue, int nLen);
+    void bind(int nParam, const unsigned char* blobValue, size_t nLen);
     void bindNull(int nParam);
 
     void reset();

Original file line number	Diff line number	Diff line change
`@@ -35,8 +35,8 @@ SQLite3Memory::SQLite3Memory() :`
`35`	`35`	`{`
`36`	`36`	`}`
`37`	`37`
`38`		`-SQLite3Memory::SQLite3Memory(int nBufferLen) :`
`39`		`- mpBuf(sqlite3_malloc(nBufferLen)),`
	`38`	`+SQLite3Memory::SQLite3Memory(size_t nBufferLen) :`
	`39`	`+ mpBuf(sqlite3_malloc(static_cast<int>(nBufferLen))),`
`40`	`40`	`mnBufferLen(nBufferLen)`
`41`	`41`	`{`
`42`	`42`	`if (!mpBuf && mnBufferLen>0)`
`@@ -66,7 +66,7 @@ SQLite3Memory::~SQLite3Memory()`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`SQLite3Memory::SQLite3Memory(SQLite3Memory const& other) :`
`69`		`- mpBuf(sqlite3_malloc(other.mnBufferLen)),`
	`69`	`+ mpBuf(sqlite3_malloc(static_cast<int>(other.mnBufferLen))),`
`70`	`70`	`mnBufferLen(other.mnBufferLen)`
`71`	`71`	`{`
`72`	`72`	`if (!mpBuf && mnBufferLen>0)`
`@@ -128,7 +128,7 @@ CppSQLite3Exception::CppSQLite3Exception(const int nErrCode,`
`128`	`128`
`129`	`129`	`if (bDeleteMsg && szErrMess)`
`130`	`130`	`{`
`131`		`- sqlite3_free((void*)szErrMess);`
	`131`	`+ sqlite3_free(static_cast<void>(const_cast<char>(szErrMess)));`
`132`	`132`	`}`
`133`	`133`	`}`
`134`	`134`
`@@ -238,7 +238,7 @@ CppSQLite3Binary::~CppSQLite3Binary()`
`238`	`238`	`}`
`239`	`239`
`240`	`240`
`241`		`-void CppSQLite3Binary::setBinary(const unsigned char* pBuf, int nLen)`
	`241`	`+void CppSQLite3Binary::setBinary(const unsigned char* pBuf, size_t nLen)`
`242`	`242`	`{`
`243`	`243`	`mpBuf = allocBuffer(nLen);`
`244`	`244`	`memcpy(mpBuf, pBuf, nLen);`
`@@ -249,10 +249,10 @@ void CppSQLite3Binary::setEncoded(const unsigned char* pBuf)`
`249`	`249`	`{`
`250`	`250`	`clear();`
`251`	`251`
`252`		`- mnEncodedLen = strlen((const char*)pBuf);`
	`252`	`+ mnEncodedLen = strlen(reinterpret_cast<const char*>(pBuf));`
`253`	`253`	`mnBufferLen = mnEncodedLen + 1; // Allow for NULL terminator`
`254`	`254`
`255`		`- mpBuf = (unsigned char*)malloc(mnBufferLen);`
	`255`	`+ mpBuf = reinterpret_cast<unsigned char*>(malloc(mnBufferLen));`
`256`	`256`
`257`	`257`	`if (!mpBuf)`
`258`	`258`	`{`
`@@ -270,9 +270,9 @@ const unsigned char* CppSQLite3Binary::getEncoded()`
`270`	`270`	`{`
`271`	`271`	`if (!mbEncoded)`
`272`	`272`	`{`
`273`		`- unsigned char* ptmp = (unsigned char*)malloc(mnBinaryLen);`
	`273`	`+ unsigned char* ptmp = reinterpret_cast<unsigned char*>(malloc(mnBinaryLen));`
`274`	`274`	`memcpy(ptmp, mpBuf, mnBinaryLen);`
`275`		`- mnEncodedLen = sqlite3_encode_binary(ptmp, mnBinaryLen, mpBuf);`
	`275`	`+ mnEncodedLen = static_cast<size_t>(sqlite3_encode_binary(ptmp, static_cast<int>(mnBinaryLen), mpBuf));`
`276`	`276`	`free(ptmp);`
`277`	`277`	`mbEncoded = true;`
`278`	`278`	`}`
`@@ -286,30 +286,30 @@ const unsigned char* CppSQLite3Binary::getBinary()`
`286`	`286`	`if (mbEncoded)`
`287`	`287`	`{`
`288`	`288`	`// in/out buffers can be the same`
`289`		`- mnBinaryLen = sqlite3_decode_binary(mpBuf, mpBuf);`
	`289`	`+ int result = sqlite3_decode_binary(mpBuf, mpBuf);`
`290`	`290`
`291`		`- if (mnBinaryLen == -1)`
	`291`	`+ if (result == -1)`
`292`	`292`	`{`
`293`	`293`	`throw CppSQLite3Exception(CPPSQLITE_ERROR,`
`294`	`294`	`"Cannot decode binary",`
`295`	`295`	`DONT_DELETE_MSG);`
`296`	`296`	`}`
`297`		`-`
	`297`	`+ mnBinaryLen = static_cast<size_t>(result);`
`298`	`298`	`mbEncoded = false;`
`299`	`299`	`}`
`300`	`300`
`301`	`301`	`return mpBuf;`
`302`	`302`	`}`
`303`	`303`
`304`	`304`
`305`		`-int CppSQLite3Binary::getBinaryLength()`
	`305`	`+size_t CppSQLite3Binary::getBinaryLength()`
`306`	`306`	`{`
`307`	`307`	`getBinary();`
`308`	`308`	`return mnBinaryLen;`
`309`	`309`	`}`
`310`	`310`
`311`	`311`
`312`		`-unsigned char* CppSQLite3Binary::allocBuffer(int nLen)`
	`312`	`+unsigned char* CppSQLite3Binary::allocBuffer(size_t nLen)`
`313`	`313`	`{`
`314`	`314`	`clear();`
`315`	`315`
`@@ -319,7 +319,7 @@ unsigned char* CppSQLite3Binary::allocBuffer(int nLen)`
`319`	`319`	`mnBinaryLen = nLen;`
`320`	`320`	`mnBufferLen = 3 + (257*nLen)/254;`
`321`	`321`
`322`		`- mpBuf = (unsigned char*)malloc(mnBufferLen);`
	`322`	`+ mpBuf = static_cast<unsigned char*>(malloc(mnBufferLen));`
`323`	`323`
`324`	`324`	`if (!mpBuf)`
`325`	`325`	`{`
`@@ -430,14 +430,14 @@ const char* CppSQLite3Query::fieldValue(int nField) const`
`430`	`430`	`DONT_DELETE_MSG);`
`431`	`431`	`}`
`432`	`432`
`433`		`- return (const char*)sqlite3_column_text(mpVM, nField);`
	`433`	`+ return reinterpret_cast<const char*>(sqlite3_column_text(mpVM, nField));`
`434`	`434`	`}`
`435`	`435`
`436`	`436`
`437`	`437`	`const char* CppSQLite3Query::fieldValue(const char* szField) const`
`438`	`438`	`{`
`439`	`439`	`int nField = fieldIndex(szField);`
`440`		`- return (const char*)sqlite3_column_text(mpVM, nField);`
	`440`	`+ return reinterpret_cast<const char*>(sqlite3_column_text(mpVM, nField));`
`441`	`441`	`}`
`442`	`442`
`443`	`443`
`@@ -529,7 +529,7 @@ const char* CppSQLite3Query::getStringField(int nField, const char* szNullValue/`
`529`	`529`	`}`
`530`	`530`	`else`
`531`	`531`	`{`
`532`		`- return (const char*)sqlite3_column_text(mpVM, nField);`
	`532`	`+ return reinterpret_cast<const char*>(sqlite3_column_text(mpVM, nField));`
`533`	`533`	`}`
`534`	`534`	`}`
`535`	`535`
`@@ -541,7 +541,7 @@ const char* CppSQLite3Query::getStringField(const char* szField, const char* szN`
`541`	`541`	`}`
`542`	`542`
`543`	`543`
`544`		`-const unsigned char* CppSQLite3Query::getBlobField(int nField, int& nLen) const`
	`544`	`+const unsigned char* CppSQLite3Query::getBlobField(int nField, size_t& nLen) const`
`545`	`545`	`{`
`546`	`546`	`checkVM();`
`547`	`547`
`@@ -552,12 +552,12 @@ const unsigned char* CppSQLite3Query::getBlobField(int nField, int& nLen) const`
`552`	`552`	`DONT_DELETE_MSG);`
`553`	`553`	`}`
`554`	`554`
`555`		`- nLen = sqlite3_column_bytes(mpVM, nField);`
`556`		`- return (const unsigned char*)sqlite3_column_blob(mpVM, nField);`
	`555`	`+ nLen = static_cast<size_t>(sqlite3_column_bytes(mpVM, nField));`
	`556`	`+ return reinterpret_cast<const unsigned char*>(sqlite3_column_blob(mpVM, nField));`
`557`	`557`	`}`
`558`	`558`
`559`	`559`
`560`		`-const unsigned char* CppSQLite3Query::getBlobField(const char* szField, int& nLen) const`
	`560`	`+const unsigned char* CppSQLite3Query::getBlobField(const char* szField, size_t& nLen) const`
`561`	`561`	`{`
`562`	`562`	`int nField = fieldIndex(szField);`
`563`	`563`	`return getBlobField(nField, nLen);`
`@@ -1147,11 +1147,11 @@ void CppSQLite3Statement::bind(int nParam, const double dValue)`
`1147`	`1147`	`}`
`1148`	`1148`
`1149`	`1149`
`1150`		`-void CppSQLite3Statement::bind(int nParam, const unsigned char* blobValue, int nLen)`
	`1150`	`+void CppSQLite3Statement::bind(int nParam, const unsigned char* blobValue, size_t nLen)`
`1151`	`1151`	`{`
`1152`	`1152`	`checkVM();`
`1153`		`- int nRes = sqlite3_bind_blob(mpVM, nParam,`
`1154`		`- (const void*)blobValue, nLen, SQLITE_TRANSIENT);`
	`1153`	`+ int nRes = sqlite3_bind_blob(mpVM, nParam, static_cast<const void*>(blobValue),`
	`1154`	`+ static_cast<int>(nLen), SQLITE_TRANSIENT);`
`1155`	`1155`
`1156`	`1156`	`if (nRes != SQLITE_OK)`
`1157`	`1157`	`{`