Memory functions

src/dawn/CMakeLists.txt

@@ -23,6 +23,7 @@ add_subdirectory(game)
 add_subdirectory(rpg)
 add_subdirectory(ui)
 add_subdirectory(locale)
+add_subdirectory(util)
 
 # Sources
 target_sources(${DAWN_TARGET_NAME}

src/dawn/asset/assetjson.c

@@ -7,6 +7,7 @@
 
 #include "assetjson.h"
 #include "assert/assert.h"
+#include "util/memory.h"
 
 size_t assetJsonParse(const char_t *json, assetjson_t **out) {
   size_t offset = assetJsonParseSub(json, out);
@@ -84,7 +85,7 @@ size_t assetJsonParseAsNull(
   const char_t *json,
   assetjson_t **out
 ) {
-  assetjson_t *obj = malloc(sizeof(assetjson_t));
+  assetjson_t *obj = (assetjson_t*)memoryAllocate(sizeof(assetjson_t));
   // Read "null"
   assertTrue(json[0] == 'n', "Expected NULL data type. (n0)");
   assertTrue(json[1] == 'u', "Expected NULL data type. (u0)");
@@ -102,7 +103,7 @@ size_t assetJsonParseAsBoolean(
   const char_t *json,
   assetjson_t **out
 ) {
-  assetjson_t *obj = malloc(sizeof(assetjson_t));
+  assetjson_t *obj = (assetjson_t*)memoryAllocate(sizeof(assetjson_t));
 
   obj->type = ASSET_JSON_DATA_TYPE_BOOLEAN;
   *out = obj;
@@ -131,7 +132,7 @@ size_t assetJsonParseAsString(
   const char_t *json,
   assetjson_t **out
 ) {
-  assetjson_t *obj = malloc(sizeof(assetjson_t));
+  assetjson_t *obj = memoryAllocate(sizeof(assetjson_t));
 
   obj->type = ASSET_JSON_DATA_TYPE_STRING;
 
@@ -141,7 +142,7 @@ size_t assetJsonParseAsString(
   char c;
   bool_t inEscape = false;
   size_t bufferSize = 2;
-  char_t *string = (char_t*)malloc(bufferSize * sizeof(char_t));
+  char_t *string = (char_t*)memoryAllocate(bufferSize * sizeof(char_t));
   while(true) {
     c = json[offset];
     if(c == '\0') assertUnreachable("Unexpected end of string.");
@@ -178,7 +179,7 @@ size_t assetJsonParseAsString(
 
       if(outOffset >= bufferSize) {
         bufferSize *= 2;
-        string = realloc(string, bufferSize * sizeof(char_t));
+        string = memoryReallocate(string, bufferSize * sizeof(char_t));
       }
       string[outOffset] = c;
       offset++;
@@ -193,7 +194,7 @@ size_t assetJsonParseAsString(
     if(c == '"') break;
     if(outOffset >= bufferSize) {
       bufferSize *= 2;
-      string = realloc(string, bufferSize * sizeof(char_t));
+      string = memoryReallocate(string, bufferSize * sizeof(char_t));
     }
     string[outOffset] = c;
     offset++;
@@ -212,13 +213,13 @@ size_t assetJsonParseAsObject(
   const char_t *json,
   assetjson_t **out
 ) {
-  assetjson_t *obj = malloc(sizeof(assetjson_t));
+  assetjson_t *obj = memoryAllocate(sizeof(assetjson_t));
 
   obj->type = ASSET_JSON_DATA_TYPE_OBJECT;
   
   size_t bufferSize = 2;
-  char_t **keys = malloc(bufferSize * sizeof(char_t*));
-  assetjson_t **values = malloc(bufferSize * sizeof(assetjson_t*));
+  char_t **keys = memoryAllocate(bufferSize * sizeof(char_t*));
+  assetjson_t **values = memoryAllocate(bufferSize * sizeof(assetjson_t*));
   size_t length = 0;
 
   // Skip whitespace
@@ -264,8 +265,8 @@ size_t assetJsonParseAsObject(
     // Need to resize?
     if(length >= bufferSize) {
       bufferSize *= 2;
-      keys = realloc(keys, bufferSize * sizeof(char_t*));
-      values = realloc(values, bufferSize * sizeof(assetjson_t*));
+      keys = memoryReallocate(keys, bufferSize * sizeof(char_t*));
+      values = memoryReallocate(values, bufferSize * sizeof(assetjson_t*));
     }
 
     keys[length] = bufferKey;
@@ -279,7 +280,10 @@ size_t assetJsonParseAsObject(
     }
 
     // Expect either comma or closing bracket
-    assertTrue(c == ',' || c == '}', "Expected comma or closing bracket after JSON object value.");
+    assertTrue(
+      c == ',' || c == '}',
+      "Expected comma or closing bracket after JSON object value."
+    );
     if(c == '}') break;
 
     offset++;
@@ -297,7 +301,7 @@ size_t assetJsonParseAsArray(
   const char_t *json,
   assetjson_t **out
 ) {
-  assetjson_t *obj = malloc(sizeof(assetjson_t));
+  assetjson_t *obj = (assetjson_t*)memoryAllocate(sizeof(assetjson_t));
 
   obj->type = ASSET_JSON_DATA_TYPE_ARRAY;
 
@@ -306,7 +310,9 @@ size_t assetJsonParseAsArray(
 
   // Create array
   size_t arraySize = 2;
-  obj->array.value = malloc(arraySize * sizeof(assetjson_t*));
+  obj->array.value = (assetjson_t**)memoryAllocate(
+    arraySize * sizeof(assetjson_t*)
+  );
   obj->array.length = 0;
   
   // Until closing bracket
@@ -326,7 +332,7 @@ size_t assetJsonParseAsArray(
     // Need to expand?
     if(obj->array.length >= arraySize) {
       arraySize *= 2;
-      obj->array.value = realloc(
+      obj->array.value = memoryReallocate(
         obj->array.value, arraySize * sizeof(assetjson_t*)
       );
     }
@@ -365,7 +371,7 @@ size_t assetJsonParseAsNumber(
   const char_t *json,
   assetjson_t **out
 ) {
-  assetjson_t *obj = malloc(sizeof(assetjson_t));
+  assetjson_t *obj = (assetjson_t*)memoryAllocate(sizeof(assetjson_t));
 
   obj->type = ASSET_JSON_DATA_TYPE_NUMBER;
 
@@ -374,7 +380,7 @@ size_t assetJsonParseAsNumber(
   size_t outOffset = 0;
   char_t c;
   size_t bufferSize = 2;
-  char_t *buffer = (char_t*)malloc(bufferSize * sizeof(char_t));
+  char_t *buffer = (char_t*)memoryAllocate(bufferSize * sizeof(char_t));
   bool_t hasDecimal = false;
   bool_t hasNumber = false;
 
@@ -395,7 +401,7 @@ size_t assetJsonParseAsNumber(
         // If no number before decimal, add a 0
         if(outOffset >= bufferSize) {
           bufferSize *= 2;
-          buffer = realloc(buffer, bufferSize * sizeof(char_t));
+          buffer = memoryReallocate(buffer, bufferSize * sizeof(char_t));
         }
         buffer[outOffset] = '0';
         outOffset++;
@@ -409,7 +415,7 @@ size_t assetJsonParseAsNumber(
     // Need to expand?
     if(outOffset >= bufferSize) {
       bufferSize *= 2;
-      buffer = realloc(buffer, bufferSize * sizeof(char_t));
+      buffer = memoryReallocate(buffer, bufferSize * sizeof(char_t));
     }
 
     buffer[outOffset] = c;
@@ -420,7 +426,7 @@ size_t assetJsonParseAsNumber(
   // Seal the buffer, parse and cleanup
   buffer[outOffset] = '\0';
   obj->number = strtod(buffer, NULL);
-  free(buffer);
+  memoryFree(buffer);
 
   *out = obj;
   return offset;
@@ -434,7 +440,7 @@ size_t assetJsonReadString(
   size_t outOffset = 0;
   char_t c;
   size_t bufferSize = 32;
-  char_t *string = (char_t*)malloc(sizeof(char_t) * bufferSize);
+  char_t *string = (char_t*)memoryAllocate(sizeof(char_t) * bufferSize);
   bool_t inEscape = false;
 
   // For each char
@@ -475,7 +481,7 @@ size_t assetJsonReadString(
 
       if(outOffset >= bufferSize) {
         bufferSize *= 2;
-        string = realloc(string, bufferSize);
+        string = memoryReallocate(string, bufferSize);
       }
       string[outOffset] = c;
       offset++;
@@ -493,7 +499,7 @@ size_t assetJsonReadString(
 
     if(outOffset >= bufferSize) {
       bufferSize *= 2;
-      string = realloc(string, bufferSize);
+      string = memoryReallocate(string, bufferSize);
     }
     string[outOffset] = c;
     offset++;
@@ -522,22 +528,22 @@ void assetJsonDispose(assetjson_t *json) {
   switch(json->type) {
     case ASSET_JSON_DATA_TYPE_OBJECT:
       for(size_t i = 0; i < json->object.length; i++) {
-        free(json->object.keys[i]);
+        memoryFree(json->object.keys[i]);
         assetJsonDispose(json->object.values[i]);
       }
-      free(json->object.keys);
-      free(json->object.values);
+      memoryFree(json->object.keys);
+      memoryFree(json->object.values);
       break;
     
     case ASSET_JSON_DATA_TYPE_ARRAY:
       for(size_t i = 0; i < json->array.length; i++) {
         assetJsonDispose(json->array.value[i]);
       }
-      free(json->array.value);
+      memoryFree(json->array.value);
       break;
     
     case ASSET_JSON_DATA_TYPE_STRING:
-      free(json->string);
+      memoryFree(json->string);
       break;
     
     case ASSET_JSON_DATA_TYPE_NUMBER:
@@ -550,5 +556,5 @@ void assetJsonDispose(assetjson_t *json) {
       break;
   }
 
-  free(json);
+  memoryFree(json);
 }

src/dawn/asset/assetlanguage.c

@@ -9,6 +9,7 @@
 #include "asset/asset.h"
 #include "assert/assert.h"
 #include "locale/language.h"
+#include "util/memory.h"
 
 void assetLanguageObjectLoad(
   const char_t *key,
@@ -48,7 +49,7 @@ void assetLanguageLoad(const char_t *path) {
 
   assetOpen(path);
   size_t length = assetGetSize();
-  char_t *buffer = malloc(sizeof(char_t) * (length + 1));
+  char_t *buffer = memoryAllocate(sizeof(char_t) * (length + 1));
   buffer[length] = '\0';
   size_t read = assetRead((uint8_t*)buffer, length);
   assertTrue(read == length, "Failed to read language file!");
@@ -56,7 +57,7 @@ void assetLanguageLoad(const char_t *path) {
 
   assetjson_t *json;
   read = assetJsonParse(buffer, &json);
-  free(buffer);
+  memoryFree(buffer);
 
   assertTrue(
     json->type == ASSET_JSON_DATA_TYPE_OBJECT,
@@ -65,4 +66,5 @@ void assetLanguageLoad(const char_t *path) {
 
   languageInit();
   assetLanguageObjectLoad("", json);
+  assetJsonDispose(json);
 }

src/dawn/asset/assetmap.c

@@ -8,6 +8,7 @@
 #include "assetmap.h"
 #include "asset/asset.h"
 #include "assert/assert.h"
+#include "util/memory.h"
 
 void assetMapLoadEntity(
   assetjson_t *jEnt,
@@ -104,7 +105,7 @@ void assetMapLoad(
   // Read in the string data.
   assetOpen(path);
   size_t length = assetGetSize();
-  char_t *buffer = malloc(sizeof(char_t) * (length + 1));
+  char_t *buffer = memoryAllocate(sizeof(char_t) * (length + 1));
   size_t read = assetRead((uint8_t*)buffer, length);
   buffer[length] = '\0';
   assertTrue(read == length, "assetMapLoad: Failed to read map data!");
@@ -113,7 +114,7 @@ void assetMapLoad(
   // Begin parsing JSON data.
   assetjson_t *json;
   read = assetJsonParse(buffer, &json);
-  free(buffer);
+  memoryFree(buffer);
   
   assertTrue(
     json->type == ASSET_JSON_DATA_TYPE_OBJECT,

src/dawn/display/draw/drawshape.c

@@ -7,13 +7,14 @@
 
 #include "drawshape.h"
 #include "assert/assert.h"
+#include "util/memory.h"
 
 void drawClear(
   const char_t c,
   const uint8_t color
 ) {
-  memset(FRAME_BUFFER, c, FRAME_HEIGHT * FRAME_WIDTH);
-  memset(FRAME_COLOR, color, FRAME_HEIGHT * FRAME_WIDTH);
+  memorySet(FRAME_BUFFER, c, FRAME_HEIGHT * FRAME_WIDTH);
+  memorySet(FRAME_COLOR, color, FRAME_HEIGHT * FRAME_WIDTH);
 }
 
 void drawBox(
@@ -31,13 +32,13 @@ void drawBox(
   assertTrue(y + height <= FRAME_HEIGHT, "Box is too tall.");
 
   if(width == FRAME_WIDTH) {
-    memset(&FRAME_BUFFER[y * FRAME_WIDTH + x], c, height * width);
-    memset(&FRAME_COLOR[y * FRAME_WIDTH + x], color, height * width);
+    memorySet(&FRAME_BUFFER[y * FRAME_WIDTH + x], c, height * width);
+    memorySet(&FRAME_COLOR[y * FRAME_WIDTH + x], color, height * width);
     return;
   }
 
   for(uint16_t iy = 0; iy < height; iy++) {
-    memset(&FRAME_BUFFER[(y + iy) * FRAME_WIDTH + x], c, width);
-    memset(&FRAME_COLOR[(y + iy) * FRAME_WIDTH + x], color, width);
+    memorySet(&FRAME_BUFFER[(y + iy) * FRAME_WIDTH + x], c, width);
+    memorySet(&FRAME_COLOR[(y + iy) * FRAME_WIDTH + x], color, width);
   }
 }

src/dawn/display/draw/drawui.c

@@ -13,6 +13,7 @@
 #include "ui/textbox.h"
 #include "ui/testmenu.h"
 #include "util/math.h"
+#include "util/memory.h"
 
 void drawUIBox(
   const uint16_t x,
@@ -218,8 +219,8 @@ void drawUITextbox() {
   );
 
   // Blinking cursor
-  memset(&FRAME_BUFFER[DRAW_UI_TEXTBOX_CURSOR_POS], ' ', 3);
-  memset(&FRAME_COLOR[DRAW_UI_TEXTBOX_CURSOR_POS], COLOR_WHITE, 3);
+  memorySet(&FRAME_BUFFER[DRAW_UI_TEXTBOX_CURSOR_POS], ' ', 3);
+  memorySet(&FRAME_COLOR[DRAW_UI_TEXTBOX_CURSOR_POS], COLOR_WHITE, 3);
   if(TEXTBOX.textIndex < TEXTBOX.textLength) return;
   
   int32_t blink = (int32_t)(TIME.time * DRAW_UI_TEXTBOX_BLINKS_PER_SECOND) % 2;

src/dawn/game/game.c

@@ -21,11 +21,13 @@
 
 #include "rpg/conversation/conversation.h"
 #include "asset/assetlanguage.h"
+#include "util/memory.h"
 
 game_t GAME;
 
 void gameInit() {
-  memset(&GAME, 0, sizeof(game_t));
+  memoryInit();
+  memorySet(&GAME, 0, sizeof(game_t));
 
   timeInit();
   inputInit();
@@ -81,4 +83,6 @@ gameupdateresult_t gameUpdate(const float_t delta) {
 void gameDispose() {
   assetDispose();
   displayDispose();
+
+  memoryTestZero();
 }

src/dawn/input.c

@@ -6,16 +6,17 @@
  */
 
 #include "input.h"
+#include "util/memory.h"
 
 input_t INPUT;
 
 void inputInit() {
-  memset(&INPUT, 0, sizeof(input_t));
+  memorySet(&INPUT, 0, sizeof(input_t));
 }
 
 void inputUpdate() {
   // Update the previous state
-  memcpy(
+  memoryCopy(
     INPUT.previousState,
     INPUT.currentState,
     sizeof(INPUT.previousState)

src/dawn/locale/language.c

@@ -7,11 +7,12 @@
 
 #include "language.h"
 #include "assert/assert.h"
+#include "util/memory.h"
 
 language_t LANGUAGE;
 
 void languageInit() {
-  memset(&LANGUAGE, 0, sizeof(language_t));
+  memorySet(&LANGUAGE, 0, sizeof(language_t));
 }
 
 const char_t * languageGetPointer(const char_t *key) {

src/dawn/rpg/conversation/conversation.c

@@ -7,11 +7,12 @@
 
 #include "conversation.h"
 #include "assert/assert.h"
+#include "util/memory.h"
 
 conversation_t CONVERSATION;
 
 void conversationInit() {
-  memset(&CONVERSATION, 0, sizeof(conversation_t));
+  memorySet(&CONVERSATION, 0, sizeof(conversation_t));
 }
 
 void conversationSet(

src/dawn/rpg/conversation/conversationinteracttile.c

@@ -19,10 +19,7 @@ uint16_t conversationInteractTileInit(
   
   switch(convo->data.tileInteract.tile) {
     case TILE_WATER:
-      textboxSetText(
-        NULL,
-        "tiles.water.interact"
-      );
+      textboxSetText(NULL, "tiles.water.interact");
       break;
 
     default:

src/dawn/rpg/entity/entity.c

@@ -11,6 +11,7 @@
 #include "assert/assert.h"
 #include "game/time.h"
 #include "ui/textbox.h"
+#include "util/memory.h"
 
 void entityInit(
   entity_t *entity,
@@ -20,7 +21,7 @@ void entityInit(
   assertNotNull(entity, "Entity cannot be NULL.");
   assertNotNull(map, "Map cannot be NULL.");
 
-  memset(entity, 0, sizeof(entity_t));
+  memorySet(entity, 0, sizeof(entity_t));
   entity->type = type;
   entity->map = map;
 

src/dawn/rpg/world/map.c

@@ -7,6 +7,7 @@
 
 #include "map.h"
 #include "assert/assert.h"
+#include "util/memory.h"
 
 map_t MAP_MAIN;
 
@@ -43,7 +44,7 @@ void mapInit(
     "Map layers must be less than or equal to MAP_LAYERS_MAX."
   );
 
-  memset(map, 0, sizeof(map_t));
+  memorySet(map, 0, sizeof(map_t));
 
   map->list = list;
   map->width = width;

src/dawn/rpg/world/trigger.c

@@ -7,6 +7,7 @@
 
 #include "trigger.h"
 #include "assert/assert.h"
+#include "util/memory.h"
 
 void triggerInit(
   trigger_t *trigger,
@@ -26,7 +27,7 @@ void triggerInit(
     "Trigger height must be greater than 0."
   );
 
-  memset(trigger, 0, sizeof(trigger_t));
+  memorySet(trigger, 0, sizeof(trigger_t));
   trigger->type = type;
   trigger->x = x;
   trigger->y = y;
@@ -37,6 +38,5 @@ void triggerInit(
 void triggerOnStep(trigger_t *trigger, entity_t *entity) {
   assertNotNull(trigger, "Trigger cannot be NULL.");
   assertNotNull(entity, "Entity cannot be NULL."); 
-  
   printf("Trigger\n");
 }

src/dawn/ui/menu.c

@@ -9,6 +9,7 @@
 #include "assert/assert.h"
 #include "input.h"
 #include "game/time.h"
+#include "util/memory.h"
 
 void menuInit(
   menu_t *menu,
@@ -18,7 +19,7 @@ void menuInit(
   assertNotNull(menu, "Menu cannot be NULL.");
   assertTrue(rows > 0, "Rows must be greater than 0.");
   assertTrue(columns > 0, "Columns must be greater than 0.");
-  memset(menu, 0, sizeof(menu_t));
+  memorySet(menu, 0, sizeof(menu_t));
   menu->rows = rows;
   menu->columns = columns;
 }

src/dawn/ui/textbox.c

@@ -10,11 +10,12 @@
 #include "input.h"
 #include "game/time.h"
 #include "locale/language.h"
+#include "util/memory.h"
 
 textbox_t TEXTBOX;
 
 void textboxInit() {
-  memset(&TEXTBOX, 0, sizeof(textbox_t));
+  memorySet(&TEXTBOX, 0, sizeof(textbox_t));
 }
 
 void textboxSetText(

src/dawn/util/CMakeLists.txt

@@ -0,0 +1,12 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Subdirs
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    memory.c
+)

src/dawn/util/memory.c

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "memory.h"
+#include "assert/assert.h"
+
+uint64_t MEMORY_ALLOCATED;
+
+void * memoryAllocate(const size_t size) {
+  assertTrue(size > 0, "Memory size must be greater than 0.");
+  assertTrue(size != ((size_t)-1), "Memory size is probably too large.");
+
+  void *ptr = malloc(size);
+  if(ptr == NULL) {
+    fprintf(stderr, "Failed to allocate memory.\n");
+    exit(EXIT_FAILURE);
+  }
+  MEMORY_ALLOCATED++;
+  return ptr;
+}
+
+void memoryFree(void *ptr) {
+  MEMORY_ALLOCATED--;
+  free(ptr);
+}
+
+void * memoryReallocate(void *ptr, const size_t size) {
+  assertTrue(size > 0, "Memory size must be greater than 0.");
+  assertNotNull(ptr, "Memory pointer cannot be NULL.");
+
+  ptr = realloc(ptr, size);
+  if(ptr == NULL) {
+    fprintf(stderr, "Failed to reallocate memory.\n");
+    exit(EXIT_FAILURE);
+  }
+  return ptr;
+}
+
+void memorySet(void *ptr, const uint8_t value, const size_t size) {
+  assertNotNull(ptr, "Memory pointer cannot be NULL.");
+  assertTrue(size > 0, "Memory size must be greater than 0.");
+  memset(ptr, value, size);
+}
+
+void memoryCopy(void *dest, const void *src, const size_t size) {
+  assertNotNull(dest, "Memory destination cannot be NULL.");
+  assertNotNull(src, "Memory source cannot be NULL.");
+  assertTrue(size > 0, "Memory size must be greater than 0.");
+  memcpy(dest, src, size);
+}
+
+void memoryInit() {
+  MEMORY_ALLOCATED = 0;
+  memoryTestZero();
+}
+
+void memoryTestZero() {
+  assertTrue(MEMORY_ALLOCATED == 0, "Memory leak detected.");
+}

src/dawn/util/memory.h

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dawn.h"
+
+extern uint64_t MEMORY_ALLOCATED;
+
+/**
+ * Allocates memory. Will assert fail if no memory is available.
+ * 
+ * @param size The size of the memory to allocate.
+ * @return The allocated memory.
+ */
+void * memoryAllocate(const size_t size);
+
+/**
+ * Frees memory.
+ * 
+ * @param ptr The memory to free.
+ */
+void memoryFree(void *ptr);
+
+/**
+ * Reallocates memory. Will assert fail if no memory is available.
+ * 
+ * @param ptr The memory to reallocate.
+ * @param size The new size of the memory.
+ * @return The reallocated memory.
+ */
+void * memoryReallocate(void *ptr, const size_t size);
+
+/**
+ * Sets memory to a specific value.
+ * 
+ * @param ptr The memory to set.
+ * @param value The value to set.
+ * @param size The size of the memory to set.
+ */
+void memorySet(void *ptr, const uint8_t value, const size_t size);
+
+/**
+ * Copies memory from one location to another.
+ * 
+ * @param dest The destination memory.
+ * @param src The source memory.
+ * @param size The size of the memory to copy.
+ */
+void memoryCopy(void *dest, const void *src, const size_t size);
+
+/**
+ * Initializes the memory system.
+ */
+void memoryInit();
+
+/**
+ * Tests if there is any memory allocated.
+ */
+void memoryTestZero();

src/dawnglfw/dawnglfw.c

@@ -116,6 +116,8 @@ int32_t dawnGlfwStart() {
     if(updateResult != GAME_UPDATE_RESULT_CONTINUE) break;
   }
   
+  gameDispose();
+
   // Terminate GLFW
   glfwDestroyWindow(DAWN_GLFW.window);
   glfwTerminate();

src/dawnopengl/assert/assertgl.c

@@ -8,6 +8,7 @@
 #include "dawnopengl.h"
 #include "assert/assert.h"
 #include "assertgl.h"
+#include "util/memory.h"
 
 void assertNotGLErrorCheck(const char_t *file, const int32_t line) {
   assertNotNull(file, "assertNotGLErrorCheck: File is an invlaid string");
@@ -19,7 +20,7 @@ void assertNotGLErrorCheck(const char_t *file, const int32_t line) {
 
   while((errorCode = glGetError()) != GL_NO_ERROR) {
     if(errorCount == 0) {
-      buffer = malloc(sizeof(char_t) * 4096);
+      buffer = memoryAllocate(sizeof(char_t) * 4096);
       sprintf(buffer, "assertNotGLErrorCheck: %s:%d\n", file, line);
     }
 
@@ -64,6 +65,6 @@ void assertNotGLErrorCheck(const char_t *file, const int32_t line) {
 
   if(errorCount > 0) {
     assertUnreachable(buffer);
-    free(buffer);
+    memoryFree(buffer);
   }
 }

src/dawnopengl/display/font.c

@@ -6,6 +6,7 @@
  */
 
 #include "font.h"
+#include "util/memory.h"
 
 #ifndef FONT8X8_BASIC_H
   #include <font8x8_basic.h>
@@ -15,7 +16,7 @@
 font_t FONT;
 
 void fontInit() {
-  memset(&FONT, 0, sizeof(FONT));
+  memorySet(&FONT, 0, sizeof(FONT));
 
   // font is uint8_t[8] * count of chars
   size_t charCount = sizeof(font8x8_basic) / 8;
@@ -33,7 +34,7 @@ void fontInit() {
   FONT.texture.filterModeMag = TEXTURE_FILTER_MODE_NEAREST;
   FONT.texture.filterModeMin = TEXTURE_FILTER_MODE_NEAREST;
 
-  uint8_t *pixels = (uint8_t*)malloc(totalPixels);
+  uint8_t *pixels = (uint8_t*)memoryAllocate(totalPixels);
 
   for(size_t i = 0; i < charCount; i++) {
     for(size_t y = 0; y < 8; y++) {
@@ -45,7 +46,7 @@ void fontInit() {
   }
 
   textureBuffer(&FONT.texture, pixels);
-  free(pixels);
+  memoryFree(pixels);
 }
 
 void fontCharGetUV(const char_t c, vec4_t out) {