HPCC-14421 Use size_t for the size of a memory allocation

Signed-off-by: Gavin Halliday <gavin.halliday@lexisnexis.com>

common/deftype/defvalue.cpp

@@ -435,8 +435,10 @@ void MemoryValue::pushDecimalValue()
 
 void MemoryValue::serialize(MemoryBuffer &tgt)
 {
-    tgt.append(val.length());
-    tgt.append(val.length(), val.get());
+    size32_t serialLen = (size32_t)val.length();
+    assertex(serialLen == val.length());
+    tgt.append(serialLen);
+    tgt.append(serialLen, val.get());
 }
 
 void MemoryValue::deserialize(MemoryBuffer &src)

system/jlib/jbuff.cpp

@@ -135,13 +135,13 @@ void RaiseOutOfMemException(int errcode, size_t wanted, size_t got,bool expected
     throw createOutOfMemException(errcode, wanted, got,expected);
 }
 
-MemoryAttr::MemoryAttr(size32_t _len)
+MemoryAttr::MemoryAttr(size_t _len)
 {
     ptr = checked_malloc(_len,-1); 
     len = _len;
 }
 
-MemoryAttr::MemoryAttr(size32_t _len, const void * _ptr)
+MemoryAttr::MemoryAttr(size_t _len, const void * _ptr)
 {
     len = 0;
     ptr = NULL;
@@ -157,13 +157,13 @@ MemoryAttr::MemoryAttr(const MemoryAttr & src)
 
 
 
-void MemoryAttr::set(size32_t _len, const void * _ptr)
+void MemoryAttr::set(size_t _len, const void * _ptr)
 {
     memcpy(allocate(_len), _ptr, _len);
 }
 
 
-void MemoryAttr::setOwn(size32_t _len, void * _ptr)
+void MemoryAttr::setOwn(size_t _len, void * _ptr)
 {
     free(ptr);
     len = _len;
@@ -188,9 +188,9 @@ void * MemoryAttr::detach()
 
 int MemoryAttr::compare(const MemoryAttr & m1, const MemoryAttr & m2)
 {
-    size32_t len1 = m1.length();
-    size32_t len2 = m2.length();
-    size32_t len = len1;
+    size_t len1 = m1.length();
+    size_t len2 = m2.length();
+    size_t len = len1;
     
     if (len1 > len2)
         len = len2;
@@ -200,7 +200,7 @@ int MemoryAttr::compare(const MemoryAttr & m1, const MemoryAttr & m2)
     return compare;
 }
 
-void *  MemoryAttr::allocate(size32_t _len)
+void *  MemoryAttr::allocate(size_t _len)
 { 
     if (_len==len)
         return ptr;
@@ -210,14 +210,14 @@ void *  MemoryAttr::allocate(size32_t _len)
     return ptr; 
 }
 
-void * MemoryAttr::ensure(size32_t _len)
+void * MemoryAttr::ensure(size_t _len)
 {
     if (_len <=len)
         return ptr;
     return reallocate(_len);
 }
 
-void *  MemoryAttr::reallocate(size32_t _len)
+void *  MemoryAttr::reallocate(size_t _len)
 { 
     if (_len==len)
         return ptr;

system/jlib/jbuff.hpp

@@ -31,21 +31,21 @@ class jlib_decl MemoryAttr
 {
 public:
     inline MemoryAttr() { len = 0; ptr = NULL; }
-    MemoryAttr(size32_t _len);                      
-    MemoryAttr(size32_t _len, const void * _ptr);
+    MemoryAttr(size_t _len);
+    MemoryAttr(size_t _len, const void * _ptr);
     MemoryAttr(const MemoryAttr & src);
     inline ~MemoryAttr() { free(ptr); }
 
-    void *              allocate(size32_t _len);
+    void *              allocate(size_t _len);
     void                clear();
     void *              detach();
-    void *              ensure(size32_t _len);
-    void *              reallocate(size32_t _len);
+    void *              ensure(size_t _len);
+    void *              reallocate(size_t _len);
     inline const void * get() const         { return ptr; }
-    inline size32_t     length() const      { return len; }
+    inline size_t       length() const      { return len; }
     inline void *       mem() const         { return ptr; }
-    void                set(size32_t _len, const void * _ptr);
-    void                setOwn(size32_t _len, void * _ptr);
+    void                set(size_t _len, const void * _ptr);
+    void                setOwn(size_t _len, void * _ptr);
     
     static int          compare(const MemoryAttr & m1, const MemoryAttr & m2);
 
@@ -53,7 +53,7 @@ public:
 
 private:
     void * ptr;
-    size32_t len;
+    size_t len;
 };
 
 
@@ -302,7 +302,7 @@ public:
      IMPLEMENT_IINTERFACE;
 
      virtual const char * str() const;
-     virtual void set(const char *val) { attr.set((size32_t)strlen(val), val); }
+     virtual void set(const char *val) { attr.set(strlen(val), val); }
      virtual void clear() { attr.clear(); } // clearing when appending does nothing
      virtual void setLen(const char *val, unsigned length) { attr.set(length, val); }
      virtual unsigned length() const { return attr.length(); };

system/jlib/jptree.cpp

@@ -838,11 +838,13 @@ const void *CPTValue::queryValue() const
 
 void CPTValue::serialize(MemoryBuffer &tgt)
 {
-    tgt.append(length());
-    if (length())
+    //Retain backward compatibility for the serialization format.
+    size32_t serialLen = (size32_t)length();
+    tgt.append(serialLen);
+    if (serialLen)
     {
         tgt.append(compressed);
-        tgt.append(length(), get());
+        tgt.append(serialLen, get());
     }
 }