Add stack allocator

engine/breeze/memory/memory.c

@@ -0,0 +1,36 @@
+#include "memory.h"
+
+#include "../core/logger.h"
+
+#include <malloc.h>
+#include <memory.h>
+
+void *bzAlloc(size_t numBytes) {
+    void *ptr = malloc(numBytes);
+    bzLoggerOnlyLog(BZ_LOG_TRACE, "Allocating address: %p (num bytes: %llu)", ptr, numBytes);
+    return ptr;
+}
+void bzFree(void *ptr) {
+    bzLoggerOnlyLog(BZ_LOG_TRACE, "Freeing address: %p", ptr);
+    free(ptr);
+}
+void *bzCalloc(size_t numBytes, size_t count) {
+    void *ptr = calloc(numBytes, count);
+    bzLoggerOnlyLog(BZ_LOG_TRACE, "Allocating address: %p (num bytes: %llu)", ptr, numBytes * count);
+    return ptr;
+}
+void *bzResize(void *ptr, size_t newSize) {
+    void *outPtr = realloc(ptr, newSize);
+    bzLoggerOnlyLog(BZ_LOG_TRACE, "Resizing address: %p (%p) to %llu bytes.", outPtr, ptr, newSize);
+    return outPtr;
+}
+
+void *bzMemSet(void *ptr, int value, size_t numBytes) {
+    return memset(ptr, value, numBytes);
+}
+void *bzMemMove(void *dst, void *src, size_t numBytes) {
+    return memmove(dst, src, numBytes);
+}
+void *bzMemCpy(void *dst, void *src, size_t numBytes) {
+    return memcpy(dst, src, numBytes);
+}

engine/breeze/memory/memory.h

@@ -0,0 +1,16 @@
+#ifndef BREEZE_MEMORY_H
+#define BREEZE_MEMORY_H
+
+#include "../defines.h"
+
+void *bzAlloc(size_t numBytes);
+void bzFree(void *ptr);
+void *bzCalloc(size_t numBytes, size_t count);
+void *bzResize(void *ptr, size_t newSize);
+
+void *bzMemSet(void *ptr, int value, size_t numBytes);
+void *bzMemMove(void *dst, void *src, size_t numBytes);
+void *bzMemCpy(void *dst, void *src, size_t numBytes);
+
+
+#endif //BREEZE_MEMORY_H

engine/breeze/memory/stack_alloc.c

@@ -0,0 +1,34 @@
+#include "stack_alloc.h"
+
+#include "memory.h"
+
+BzStackAlloc bzStackAllocCreate(size_t size) {
+    BzStackAlloc alloc = {
+            .memory=bzAlloc(size),
+            .size=size,
+            .allocated=0
+    };
+    BZ_ASSERT(alloc.memory);
+
+    return alloc;
+}
+
+void bzStackAllocDestroy(BzStackAlloc *alloc) {
+    bzFree(alloc->memory);
+    alloc->memory    = NULL;
+    alloc->size      = 0;
+    alloc->allocated = 0;
+}
+
+void *bzStackAlloc(BzStackAlloc *alloc, size_t numBytes) {
+    BZ_ASSERT(alloc->size + numBytes < alloc->size);
+    void *allocated = (u8 *) alloc->memory + alloc->allocated;
+    alloc->allocated += numBytes;
+    return allocated;
+}
+
+void bzStackAllocFree(BzStackAlloc *alloc, void *ptr) {
+    size_t byteOffset = (u8 *) ptr - (u8 *) alloc->memory;
+    BZ_ASSERT(byteOffset >= 0 && byteOffset < alloc->size);
+    alloc->allocated = byteOffset;
+}

engine/breeze/memory/stack_alloc.h

@@ -0,0 +1,18 @@
+#ifndef BREEZE_STACK_ALLOC_H
+#define BREEZE_STACK_ALLOC_H
+
+#include "../defines.h"
+
+typedef struct BzStackAlloc {
+    void *memory;
+    size_t size;
+    size_t allocated;
+} BzStackAlloc;
+
+BzStackAlloc bzStackAllocCreate(size_t size);
+void         bzStackAllocDestroy(BzStackAlloc *alloc);
+
+void *bzStackAlloc(BzStackAlloc *alloc, size_t numBytes);
+void  bzStackAllocFree(BzStackAlloc *alloc, void *ptr);
+
+#endif //BREEZE_STACK_ALLOC_H