First pass memory tool

src/dawn/dawnlibs.hpp

@@ -7,6 +7,7 @@
 
 #pragma once
 #include "dawnsharedlibs.hpp"
+#include "util/memory.hpp"
 
 #include <stb_truetype.h>
 

src/dawn/display/font/truetype/TrueTypeFaceTexture.cpp

@@ -47,7 +47,7 @@ TrueTypeFaceTexture::TrueTypeFaceTexture(
 
   // I'd love to just buffer straight to the GPU, but it seems that is a bit 
   // unstable right now.
-  uint8_t *buffer = (uint8_t *)memoryFillWithZero(w * h * sizeof(uint8_t));
+  uint8_t *buffer = (uint8_t *)memoryAllocateEmpty(w * h, sizeof(uint8_t));
 
   size_t offset = 0;
   struct TrueTypeCharacter info;

src/dawnglfw/host/DawnGLFWHost.cpp

@@ -155,12 +155,22 @@ int32_t DawnHost::update(DawnGame *game, float_t delta) {
 }
 
 void DawnHost::unload(DawnGame *game) {
-  glfwDestroyWindow(this->data->window);
-  this->data->window = nullptr;
-  glfwTerminate();
+  assertNotNull(game, "DawnHost::unload: game must not be null");
+  assertNotNull(this->data, "DawnHost::unload: data must not be null");
+  if(this->data->window != nullptr) {
+    glfwDestroyWindow(this->data->window);
+    this->data->window = nullptr;
+    glfwTerminate();
+  }
 }
 
 DawnHost::~DawnHost() {
+  assertNotNull(this->data, "DawnHost::~DawnHost: data must not be null");
+  if(this->data->window != nullptr) {
+    glfwDestroyWindow(this->data->window);
+    this->data->window = nullptr;
+    glfwTerminate();
+  }
   delete this->data;
   DAWN_HOST = nullptr;
 }

src/dawnlinux64/host/DawnHostTux32.cpp

@@ -5,18 +5,13 @@
 
 #include "DawnHostTux32.hpp"
 
-#if DAWN_DEBUG_BUILD
-  uint64_t dawnAllocatedItemCount;
-#endif
-
 using namespace Dawn;
 
 int32_t main(int32_t argc, char **args) {
   int32_t result;
 
-  #if DAWN_DEBUG_BUILD
-    dawnAllocatedItemCount = 0;
-  #endif
+  // Init the memory system.
+  memoryInit();
 
   // Create the host
   auto host = new DawnHost();
@@ -47,10 +42,8 @@ int32_t main(int32_t argc, char **args) {
 
   delete game;
   delete host;
-
-  #if DAWN_DEBUG_BUILD
-    assertTrue(dawnAllocatedItemCount == 0, "DawnHostTux32: Failed to free all allocated items.");
-  #endif
+  
+  memoryDispose();
 
   // Success
   return 0;

src/dawnosx/host/DawnHostOSX.cpp

@@ -5,19 +5,11 @@
 
 #include "DawnHostOSX.hpp"
 
-#if DAWN_DEBUG_BUILD
-  uint64_t dawnAllocatedItemCount;
-#endif
-
 using namespace Dawn;
 
 int32_t main(int32_t argc, char **args) {
   int32_t result;
 
-  #if DAWN_DEBUG_BUILD
-    dawnAllocatedItemCount = 0;
-  #endif
-
   // Create the host
   auto host = new DawnHost();
   auto game = new DawnGame(host);

src/dawnshared/CMakeLists.txt

@@ -16,6 +16,7 @@ set(
 set(D ${CMAKE_CURRENT_LIST_DIR})
 set(
   DAWN_SHARED_SOURCES
+    ${D}/util/memory.cpp
     ${D}/display/Color.cpp
     ${D}/assert/assert.cpp
     ${D}/util/Xml.cpp

src/dawnshared/assert/assert.cpp

@@ -11,7 +11,7 @@ void assertTrue(bool_t x, const char message[]) {
   if(x != true) {
     std::cout << message << std::endl;
     throw message;
-    free(0);
+    abort();
   }
   assert(x == true);
 }

src/dawnshared/util/memory.cpp

@@ -0,0 +1,99 @@
+// Copyright (c) 2022 Dominic Masters
+// 
+// This software is released under the MIT License.
+// https://opensource.org/licenses/MIT
+
+#include "memory.hpp"
+#include "assert/assert.hpp"
+
+uint64_t dawnAllocatedItemCount = -1;
+
+void memoryInit() {
+  dawnAllocatedItemCount = 0;
+}
+
+void memoryDispose() {
+  assertTrue(dawnAllocatedItemCount <= 0, "memoryDispose: !!!Leaked memory detected (not enough free)!!!");
+  assertTrue(dawnAllocatedItemCount >= 0, "memoryDispose: !!!Leaked memory detected (too much free)!!!");
+  dawnAllocatedItemCount = -1;
+}
+
+void * memoryAllocate(const size_t size) {
+  assertTrue(dawnAllocatedItemCount >= 0, "memoryAllocate: Either a memory leak or memoryInit was not called.");
+  assertTrue(size >= 0, "memoryAllocate: size must be greater than 0 or equal to.");
+  if(size == 0) {
+    // Technically this is an implementation specific case, I think it should
+    // basically be undefined behaviour tbh.
+    return memoryCallMalloc(size);
+  }
+  dawnAllocatedItemCount++;
+  auto x = (void *)memoryCallMalloc(size);
+  assertNotNull(x, "memoryAllocate: Failed to allocate memory");
+  return x;
+}
+
+void * memoryAllocateEmpty(const size_t count, const size_t size) {
+  assertTrue(dawnAllocatedItemCount >= 0, "memoryAllocateEmpty: Either a memory leak or memoryInit was not called.");
+  assertTrue(count >= 0, "memoryAllocateEmpty: count must be greater than or equal to 0");
+  assertTrue(size >= 0, "memoryAllocateEmpty: size must be greater than or equal to 0");
+  if(count == 0 || size == 0) {
+    // Technically this is an implementation specific case, I think it should
+    // basically be undefined behaviour tbh.
+    return memoryCallCalloc(count, size);
+  }
+  dawnAllocatedItemCount++;
+  auto x = (void*)memoryCallCalloc(count, size);
+  assertNotNull(x, "memoryAllocateEmpty: Failed to allocate memory");
+  return x;
+}
+
+void memoryFree(void *pointer) {
+  assertTrue(dawnAllocatedItemCount > 0, "memoryFree: Either a memory leak or memoryInit was not called.");
+  if(pointer == nullptr || pointer == NULL) {
+    // Technically this is an implementation specific case, I think it should
+    // basically be undefined behaviour tbh.
+    return memoryCallFree(pointer);
+  }
+  dawnAllocatedItemCount--;
+  memoryCallFree(pointer);
+}
+
+void memoryCopy(void *source, void *destination, size_t size) {
+  assertTrue(dawnAllocatedItemCount >= 0, "memoryAllocate: Either a memory leak or memoryInit was not called.");
+  assertNotNull(source, "memoryCopy: source must not be null");
+  assertNotNull(destination, "memoryCopy: destination must not be null");
+  assertTrue(destination != source, "memoryCopy: destination must not be source");
+  assertTrue(size > 0, "memoryCopy: size must be greater than 0");
+  memcpy(destination, source, size);
+}
+
+int32_t memoryCompare(const void *left, const void *right, const size_t size) {
+  assertTrue(dawnAllocatedItemCount >= 0, "memoryAllocate: Either a memory leak or memoryInit was not called.");
+  assertTrue(left != right, "memoryCompare: left must not be right");
+  assertTrue(size > 0, "memoryCompare: size must be greater than 0");
+  return memcmp(left, right, size);
+}
+
+void memorySet(void *dest, uint8_t data, size_t length) {
+  assertTrue(dawnAllocatedItemCount >= 0, "memoryAllocate: Either a memory leak or memoryInit was not called.");
+  assertNotNull(dest, "memorySet: dest must not be null");
+  assertTrue(length > 0, "memorySet: length must be greater than 0");
+  memset(dest, data, length);
+}
+
+size_t memoryReallocate(void **pointer, size_t currentSize, size_t newSize) {
+  // Create the new buffer
+  void *newBuffer = memoryAllocate(newSize);
+  memoryCopy(*pointer, newBuffer, currentSize);
+  memoryFree(*pointer);
+  *pointer = newBuffer;
+  return newSize;
+}
+
+void * operator new(size_t size) {
+  return memoryAllocate(size);
+}
+
+void operator delete(void *pointer) {
+  memoryFree(pointer);
+}

src/dawnshared/util/memory.hpp

@@ -6,11 +6,31 @@
  */
 
 #pragma once
-#include "assert/assert.hpp"
+#include "dawnsharedlibs.hpp"
 
-#if DAWN_DEBUG_BUILD
-  extern uint64_t dawnAllocatedItemCount;
-#endif
+extern uint64_t dawnAllocatedItemCount;
+
+static void * memoryCallMalloc(const size_t size) {
+  return malloc(size);
+}
+
+static void * memoryCallCalloc(const size_t num, const size_t size) {
+  return calloc(num, size);
+}
+
+static void memoryCallFree(void *p) {
+  free(p);
+}
+
+/**
+ * Initializes the memory management system.
+ */
+void memoryInit();
+
+/**
+ * Disposes of the memory management system.
+ */
+void memoryDispose();
 
 /**
  * Allocate some space in memory to use for your needs. Memory allocation may
@@ -20,44 +40,22 @@
  * @param size Size of the array you wish to buffer.
  * @return Pointer to the space in memory to use.
  */
-static inline void * memoryAllocate(const size_t size) {
-  assertTrue(size > 0, "memoryAllocate: size must be greater than 0");
-  #if DAWN_DEBUG_BUILD
-    dawnAllocatedItemCount++;
-  #endif
-  auto x = (void *)malloc(size);
-  assertNotNull(x, "memoryAllocate: Failed to allocate memory");
-  return x;
-}
+void * memoryAllocate(const size_t size);
 
 /**
  * Allocate space in memory, where all values are set to 0 (in binary space).
  * 
- * @param size Size of the array.
+ * @param count Count of elements to allocate.
+ * @param size Size of each element to allocate.
  * @return Pointer to the space in memory to use.
  */
-static inline void * memoryFillWithZero(const size_t size) {
-  assertTrue(size > 0, "memoryFillWithZero: size must be greater than 0");
-  #if DAWN_DEBUG_BUILD
-    dawnAllocatedItemCount++;
-  #endif
-  auto x = (void*)calloc(1, size);
-  assertNotNull(x, "memoryFillWithZero: Failed to allocate memory");
-  return x;
-}
-
+void * memoryAllocateEmpty(const size_t count, const size_t size);
 
 /**
  * Free some previously allocated memory space.
  * @param pointer Pointer in memory to free.
  */
-static inline void memoryFree(void *pointer) {
-  assertNotNull(pointer, "memoryFree: pointer must not be null");
-  #if DAWN_DEBUG_BUILD
-    dawnAllocatedItemCount--;
-  #endif
-  free(pointer);
-}
+void memoryFree(void *pointer);
 
 /**
  * Copies data from one buffer to another. Typically used for array operations.
@@ -66,17 +64,7 @@ static inline void memoryFree(void *pointer) {
  * @param destination Destination buffer.
  * @param size Size in bytes of data to copy.
  */
-static inline void memoryCopy(
-  void *source,
-  void *destination,
-  size_t size
-) {
-  assertNotNull(source, "memoryCopy: source must not be null");
-  assertNotNull(destination, "memoryCopy: destination must not be null");
-  assertTrue(destination != source, "memoryCopy: destination must not be source");
-  assertTrue(size > 0, "memoryCopy: size must be greater than 0");
-  memcpy(destination, source, size);
-}
+void memoryCopy(void *source, void *destination, size_t size);
 
 /**
  * Compares the data within two memory banks. Shorthand for memcpy.
@@ -86,15 +74,7 @@ static inline void memoryCopy(
  * @param size Count of bytes to compare.
  * @return 0 for equal, <0 for left being greater, >0 for right being greater.
  */
-static inline int32_t memoryCompare(
-  const void *left,
-  const void *right,
-  const size_t size
-) {
-  assertTrue(left != right, "memoryCompare: left must not be right");
-  assertTrue(size > 0, "memoryCompare: size must be greater than 0");
-  return memcmp(left, right, size);
-}
+int32_t memoryCompare(const void *left, const void *right, const size_t size);
 
 /**
  * Fill destination with a repeating set of bytes.
@@ -103,15 +83,7 @@ static inline int32_t memoryCompare(
  * @param data Data byte to write.
  * @param length How many times to write that byte.
  */
-static inline void memorySet(
-  void *dest,
-  uint8_t data,
-  size_t length
-) {
-  assertNotNull(dest, "memorySet: dest must not be null");
-  assertTrue(length > 0, "memorySet: length must be greater than 0");
-  memset(dest, data, length);
-}
+void memorySet(void *dest, uint8_t data, size_t length);
 
 /**
  * Reallocate a part of memory. Reallocation simply creates a new buffer that
@@ -122,15 +94,24 @@ static inline void memorySet(
  * @param newSize The new size of the buffer.
  * @return The new size param you provided.
  */
-static inline size_t memoryReallocate(
-  void **pointer,
-  size_t currentSize,
-  size_t newSize
-) {
-  // Create the new buffer
-  void *newBuffer = memoryAllocate(newSize);
-  memoryCopy(*pointer, newBuffer, currentSize);
-  memoryFree(*pointer);
-  *pointer = newBuffer;
-  return newSize;
-}
+size_t memoryReallocate(void **pointer, size_t currentSize, size_t newSize);
+
+/**
+ * Overloads the new operator to use our memory allocation.
+ * 
+ * @param size Size of the memory to allocate.
+ * @return Pointer to the memory.
+ */
+void * operator new(size_t size);
+
+/**
+ * Overloads the delete operator to use our memory allocation.
+ * 
+ * @param p Pointer to the memory to free.
+ */
+void operator delete(void * p);
+
+// Override default memory functions
+#define malloc(n) memoryAllocate(n)
+#define free(n) memoryFree(n)
+#define calloc(n, s) memoryAllocateEmpty(n, s)

src/dawntools/util/DawnTool.cpp

@@ -4,6 +4,7 @@
 // https://opensource.org/licenses/MIT
 
 #include "DawnTool.hpp"
+#include "util/memory.hpp"
 
 #if !defined(DAWN_TOOL_INSTANCE)
   #error Dawn Tool Instance, e.g. LanguageTool has not been defined
@@ -25,7 +26,7 @@ std::map<std::string, std::string> DawnTool::getOptionalFlags() {
   return std::map<std::string, std::string>();
 }
 
-int32_t DawnTool::exec(const int32_t argc, const char *argv[]) {
+int32_t DawnTool::exec(const int32_t argc, const char *argv[]) {  
   // Set up flags
   flags = this->getOptionalFlags();
 
@@ -71,6 +72,10 @@ int32_t DawnTool::exec(const int32_t argc, const char *argv[]) {
 }
 
 int main(const int32_t argc, const char *argv[]) {
-  DAWN_TOOL_INSTANCE self;
-  return self.exec(argc, argv);
+  memoryInit();
+  DAWN_TOOL_INSTANCE *self = new DAWN_TOOL_INSTANCE();
+  int32_t ret = self->exec(argc, argv);
+  delete self;
+  if(ret == 0) memoryDispose();
+  return ret;
 }

src/dawntools/util/DawnTool.hpp

@@ -34,6 +34,8 @@ namespace Dawn {
       virtual std::map<std::string, std::string> getOptionalFlags();
 
     public:
+      int32_t *test;
+
       /**
        * Execute the Dawn Tool from the CLI, functionally identically to main()
        *