Using more intptr_t in SafePointer to handle larger allocations.

Source/DFPSR/base/SafePointer.cpp

@@ -1,6 +1,6 @@
 // zlib open source license
 //
-// Copyright (c) 2017 to 2019 David Forsgren Piuva
+// Copyright (c) 2017 to 2023 David Forsgren Piuva
 // 
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -26,13 +26,13 @@
 
 using namespace dsr;
 
-void dsr::assertNonNegativeSize(int size) {
+void dsr::assertNonNegativeSize(intptr_t size) {
 	if (size < 0) {
 		throwError(U"Negative size of SafePointer!\n");
 	}
 }
 
-void dsr::assertInsideSafePointer(const char* method, const char* name, const uint8_t* pointer, const uint8_t* data, const uint8_t* regionStart, const uint8_t* regionEnd, int claimedSize, int elementSize) {
+void dsr::assertInsideSafePointer(const char* method, const char* name, const uint8_t* pointer, const uint8_t* data, const uint8_t* regionStart, const uint8_t* regionEnd, intptr_t claimedSize, intptr_t elementSize) {
 	if (pointer < regionStart || pointer + claimedSize > regionEnd) {
 		String message;
 		if (data == nullptr) {
@@ -49,16 +49,16 @@ void dsr::assertInsideSafePointer(const char* method, const char* name, const ui
 		string_append(message, U"|  Requested pointer: ", (uintptr_t)pointer, U"\n");
 		string_append(message, U"|  Requested size: ", claimedSize, U" bytes\n");
 
-		int startOffset = (int)((intptr_t)pointer - (intptr_t)regionStart);
-		int baseOffset = (int)((intptr_t)pointer - (intptr_t)data);
+		intptr_t startOffset = (intptr_t)pointer - (intptr_t)regionStart;
+		intptr_t baseOffset = (intptr_t)pointer - (intptr_t)data;
 
 		// Index relative to allocation start
 		//   regionStart is the start of the accessible memory region
 		if (startOffset != baseOffset) {
 			string_append(message, U"|  Start offset: ", startOffset, U" bytes\n");
 			if (startOffset % elementSize == 0) {
-				int index = startOffset / elementSize;
-				int elementCount = ((int)((intptr_t)regionEnd - (intptr_t)regionStart)) / elementSize;
+				intptr_t index = startOffset / elementSize;
+				intptr_t elementCount = ((intptr_t)regionEnd - (intptr_t)regionStart) / elementSize;
 				string_append(message, U"|    Start index: ", index, U" [0..", (elementCount - 1), U"]\n");
 			}
 		}
@@ -67,8 +67,8 @@ void dsr::assertInsideSafePointer(const char* method, const char* name, const ui
 		//   data is the base of the allocation at index zero
 		string_append(message, U"|  Base offset: ", baseOffset, U" bytes\n");
 		if (baseOffset % elementSize == 0) {
-			int index = baseOffset / elementSize;
-			int elementCount = ((int)((intptr_t)regionEnd - (intptr_t)data)) / elementSize;
+			intptr_t index = baseOffset / elementSize;
+			intptr_t elementCount = ((intptr_t)regionEnd - (intptr_t)data) / elementSize;
 			string_append(message, U"|    Base index: ", index, U" [0..", (elementCount - 1), U"]\n");
 		}
 		string_append(message, U"\\_______________________________________________________________________\n\n");

Source/DFPSR/base/SafePointer.h

@@ -1,6 +1,6 @@
 // zlib open source license
 //
-// Copyright (c) 2017 to 2019 David Forsgren Piuva
+// Copyright (c) 2017 to 2023 David Forsgren Piuva
 // 
 // This software is provided 'as-is', without any express or implied
 // warranty. In no event will the authors be held liable for any damages
@@ -36,8 +36,8 @@
 namespace dsr {
 
 // Generic implementaions
-void assertInsideSafePointer(const char* method, const char* name, const uint8_t* pointer, const uint8_t* data, const uint8_t* regionStart, const uint8_t* regionEnd, int claimedSize, int elementSize);
-void assertNonNegativeSize(int size);
+void assertInsideSafePointer(const char* method, const char* name, const uint8_t* pointer, const uint8_t* data, const uint8_t* regionStart, const uint8_t* regionEnd, intptr_t claimedSize, intptr_t elementSize);
+void assertNonNegativeSize(intptr_t size);
 
 template<typename T>
 class SafePointer {
@@ -54,21 +54,21 @@ public:
 	#ifdef SAFE_POINTER_CHECKS
 	SafePointer() : data(nullptr), regionStart(nullptr), regionEnd(nullptr), name("Unnamed null pointer") {}
 	explicit SafePointer(const char* name) : data(nullptr), regionStart(nullptr), regionEnd(nullptr), name(name) {}
-	SafePointer(const char* name, T* regionStart, int regionByteSize = sizeof(T)) : data(regionStart), regionStart(regionStart), regionEnd((T*)(((uint8_t*)regionStart) + (intptr_t)regionByteSize)), name(name) {
+	SafePointer(const char* name, T* regionStart, intptr_t regionByteSize = sizeof(T)) : data(regionStart), regionStart(regionStart), regionEnd((T*)(((uint8_t*)regionStart) + (intptr_t)regionByteSize)), name(name) {
 		assertNonNegativeSize(regionByteSize);
 	}
-	SafePointer(const char* name, T* regionStart, int regionByteSize, T* data) : data(data), regionStart(regionStart), regionEnd((T*)(((uint8_t*)regionStart) + (intptr_t)regionByteSize)), name(name) {
+	SafePointer(const char* name, T* regionStart, intptr_t regionByteSize, T* data) : data(data), regionStart(regionStart), regionEnd((T*)(((uint8_t*)regionStart) + (intptr_t)regionByteSize)), name(name) {
 		assertNonNegativeSize(regionByteSize);
 	}
 	#else
 	SafePointer() : data(nullptr) {}
 	explicit SafePointer(const char* name) : data(nullptr) {}
-	SafePointer(const char* name, T* regionStart, int regionByteSize = sizeof(T)) : data(regionStart) {}
-	SafePointer(const char* name, T* regionStart, int regionByteSize, T* data) : data(data) {}
+	SafePointer(const char* name, T* regionStart, intptr_t regionByteSize = sizeof(T)) : data(regionStart) {}
+	SafePointer(const char* name, T* regionStart, intptr_t regionByteSize, T* data) : data(data) {}
 	#endif
 public:
 	#ifdef SAFE_POINTER_CHECKS
-	inline void assertInside(const char* method, const T* pointer, int size = (int)sizeof(T)) const {
+	inline void assertInside(const char* method, const T* pointer, intptr_t size = (intptr_t)sizeof(T)) const {
 		assertInsideSafePointer(method, this->name, (const uint8_t*)pointer, (const uint8_t*)this->data, (const uint8_t*)this->regionStart, (const uint8_t*)this->regionEnd, size, sizeof(T));
 	}
 	inline void assertInside(const char* method) const {
@@ -100,7 +100,7 @@ public:
 	}
 	// Returns the pointer in modulo byteAlignment
 	// Returns 0 if the pointer is aligned with byteAlignment
-	inline int getAlignmentOffset(int byteAlignment) const {
+	inline int32_t getAlignmentOffset(int32_t byteAlignment) const {
 		return ((uintptr_t)this->data) % byteAlignment;
 	}
 	inline bool isNull() const {
@@ -112,8 +112,8 @@ public:
 	// Get a new safe pointer from a sub-set of data
 	//  byteOffset is which byte in the source will be index zero in the new pointer
 	//  size is the new pointer's size, which may not exceed the remaining available space
-	inline SafePointer<T> slice(const char* name, int byteOffset, int size) {
-		T *newStart = (T*)(((uint8_t*)(this->data)) + (intptr_t)byteOffset);
+	inline SafePointer<T> slice(const char* name, intptr_t byteOffset, intptr_t size) {
+		T *newStart = (T*)(((uint8_t*)(this->data)) + byteOffset);
 		#ifdef SAFE_POINTER_CHECKS
 		assertInside("getSlice", newStart, size);
 		return SafePointer<T>(name, newStart, size);
@@ -121,8 +121,8 @@ public:
 		return SafePointer<T>(name, newStart);
 		#endif
 	}
-	inline const SafePointer<T> slice(const char* name, int byteOffset, int size) const {
-		T *newStart = (T*)(((uint8_t*)(this->data)) + (intptr_t)byteOffset);
+	inline const SafePointer<T> slice(const char* name, intptr_t byteOffset, intptr_t size) const {
+		T *newStart = (T*)(((uint8_t*)(this->data)) + byteOffset);
 		#ifdef SAFE_POINTER_CHECKS
 		assertInside("getSlice", newStart, size);
 		return SafePointer<T>(name, newStart, size);
@@ -157,14 +157,14 @@ public:
 		#endif
 		return *(this->data);
 	}
-	inline T& operator[] (int index) {
+	inline T& operator[] (intptr_t index) {
 		T* address = this->data + index;
 		#ifdef SAFE_POINTER_CHECKS
 		assertInside("operator[]", address);
 		#endif
 		return *address;
 	}
-	inline const T& operator[] (int index) const {
+	inline const T& operator[] (intptr_t index) const {
 		T* address = this->data + index;
 		#ifdef SAFE_POINTER_CHECKS
 		assertInside("operator[]", address);
@@ -225,7 +225,7 @@ public:
 };
 
 template <typename T, typename S>
-inline void safeMemoryCopy(SafePointer<T> target, const SafePointer<S>& source, int64_t byteSize) {
+inline void safeMemoryCopy(SafePointer<T> target, const SafePointer<S>& source, intptr_t byteSize) {
 	#ifdef SAFE_POINTER_CHECKS
 		// Both target and source must be in valid memory
 		target.assertInside("memoryCopy (target)", target.getUnchecked(), (size_t)byteSize);
@@ -238,7 +238,7 @@ inline void safeMemoryCopy(SafePointer<T> target, const SafePointer<S>& source,
 }
 
 template <typename T>
-inline void safeMemorySet(SafePointer<T>& target, uint8_t value, int64_t byteSize) {
+inline void safeMemorySet(SafePointer<T>& target, uint8_t value, intptr_t byteSize) {
 	#ifdef SAFE_POINTER_CHECKS
 		// Target must be in valid memory
 		target.assertInside("memoryCopy (target)", target.getUnchecked(), byteSize);