fixing mimalloc build

5 files changed, 71 insertions, 25 deletions

diff --git a/makefile b/makefile
index b07343a..9fada52 100644
--- a/makefile
+++ b/makefile
@@ -16,7 +16,11 @@ SRC_DIR := $(TOP_DIR)/src
 MI_DIR := $(TOP_DIR)/mimalloc
 MI_INCLUDE_DIR := $(MI_DIR)/include
 
+ifeq ($(RELEASE),1)
 MI_O := $(MI_DIR)/mimalloc.o
+else
+MI_O := $(MI_DIR)/mimalloc-debug.o
+endif
 
 VOIDC_CXX := $(SRC_DIR)/voidc.cc
 VOIDC_O := $(VOIDC_CXX:.cc=.o)
@@ -37,10 +41,11 @@ MI_FLAGS := -G"Unix Makefiles" -DCMAKE_C_COMPILER=$(CC) \
 
 ifeq ($(RELEASE),1)
 	CXX_FLAGS += -flto=auto -O2
-	MI_FLAGS += -DMI_DEBUG=0
+	MI_FLAGS += -DCMAKE_BUILD_TYPE=Release -DMI_DEBUG=OFF
+	LD_FLAGS += -flto=auto -O2
 else
-	CCXX_FLAGS += -g3
-	MI_FLAGS += -DMI_DEBUG=2
+	CXX_FLAGS += -g3
+	MI_FLAGS += -DCMAKE_BUILD_TYPE=Debug -DMI_DEBUG_INTERNAL=ON
 endif
 
 # ====== Rules ====== #
diff --git a/src/array.cc b/src/array.cc
index fa2cb61..f522bfc 100644
--- a/src/array.cc
+++ b/src/array.cc
@@ -9,7 +9,7 @@
 template <typename T>
 struct Array {
   usize capacity, size;
-  u8* data;
+  T* data;
   const Allocator* allocator;
 };
 
@@ -18,25 +18,26 @@ struct Array {
 
 template<typename T>
 static inline usize array_nbytes(usize size) {
+  assert_neq(size, 0);
   return size * sizeof(T);
 }
 
 template<typename T>
 static inline usize array_next_capacity(const Array<T>* array) {
-  assert(array != nullptr);
+  assert_neq(array, nullptr);
   return array->capacity == 0 ? ARRAY_INIT : array->capacity * ARRAY_GROWTH;
 }
 
 template<typename T>
 bool array_resize(Array<T>* array, usize new_capacity) {
-  assert(array != nullptr);
-  assert(array->size < new_capacity);
+  assert_neq(array, nullptr);
+  assert_st(array->size, new_capacity);
 
-  u8* new_data = allocate(array->allocator, array_nbytes<T>(new_capacity), alignof(T));
+  T* new_data = (T*)allocate(array->allocator, array_nbytes<T>(new_capacity), alignof(T));
   if(new_data == nullptr) return false;
 
   memcpy(new_data, array->data, array_nbytes<T>(new_capacity));
-  deallocate(array->allocator, array->data);
+  deallocate(array->allocator, (u8*)array->data);
 
   array->data = new_data;
   array->capacity = new_capacity;
@@ -45,8 +46,8 @@ bool array_resize(Array<T>* array, usize new_capacity) {
 
 template<typename T>
 static inline bool array_grow_if_needed(Array<T>* array) {
-  assert(array != nullptr);
-  assert(array->size <= array->capacity);
+  assert_neq(array, nullptr);
+  assert_ste(array->size, array->capacity);
   
   if(array->size < array->capacity) return true;
 
@@ -56,16 +57,24 @@ static inline bool array_grow_if_needed(Array<T>* array) {
 
 template<typename T>
 static inline T* array_at(const Array<T>* array, usize index) {
-  assert(array != NULL);
-  assert(index < array->capacity);
+  assert_neq(array, nullptr);
+  assert_st(index, array->capacity);
 
   return array->data + index;
 }
 
 template<typename T>
+inline T* array_last(const Array<T>* array) {
+  assert_neq(array, nullptr);
+
+  if(array->size == 0) return nullptr;
+  return array_at(array, array->size - 1);
+}
+
+template<typename T>
 bool array_push(Array<T>* array, T* item) {
-  assert(array != nullptr);
-  assert(item != nullptr);
+  assert_neq(array, nullptr);
+  assert_neq(item, nullptr);
 
   bool ret = array_grow_if_needed(array);
   if(!ret) return false;
@@ -79,11 +88,11 @@ bool array_push(Array<T>* array, T* item) {
 
 template <typename T>
 void array_deinit(Array<T>* array) {
-  assert(array != nullptr);
-
+  assert_neq(array, nullptr);
+  
   if (unlikely(array->data == nullptr)) return;
 
-  deallocate(array->allocator, array->data);
+  deallocate(array->allocator, (u8*)array->data);
   memset(array, 0, sizeof(*array));  
 }
 
diff --git a/src/common.cc b/src/common.cc
index 36ddbeb..fd2a843 100644
--- a/src/common.cc
+++ b/src/common.cc
@@ -49,6 +49,10 @@ typedef intptr_t isize;
     if (unlikely(!(cond))) panic("assertion failed: %s", #cond); \
   } while (0)
 
+#define assert_neq(x, y) assert(x != y)
+#define assert_st(x, y) assert(x < y)
+#define assert_ste(x, y) assert(x <= y)
+
 /* slice and string handling */
 
 template <typename T>
@@ -75,6 +79,9 @@ struct Slice {
 
 template <typename T>
 bool slice_write(const Slice<T>* slice, FILE* stream) {
+  assert_neq(slice, nullptr);
+  assert_neq(stream, nullptr);
+  
   usize rc = fwrite(slice->ptr, sizeof(T), slice->length, stream);
   if (rc == 0 || slice->size() > rc) return false;
   return true;
@@ -93,8 +100,8 @@ struct Link {
 };
 
 static inline void link_after(Link* prev, Link* nlink) {
-  assert(prev != nullptr);
-  assert(nlink != nullptr);
+  assert_neq(prev, nullptr);
+  assert_neq(nlink, nullptr);
 
   Link* next = prev->next;
 
@@ -107,7 +114,7 @@ static inline void link_after(Link* prev, Link* nlink) {
 }
 
 static inline void link_remove(Link* item) {
-  assert(item != nullptr);
+  assert_neq(item, nullptr);
 
   Link* prev = item->prev;
   Link* next = item->next;
diff --git a/src/source.cc b/src/source.cc
index c13fefc..69f1941 100644
--- a/src/source.cc
+++ b/src/source.cc
@@ -23,6 +23,11 @@ struct Buffer {
 
 bool buffer_init(Buffer* buffer, const Allocator* allocator,
                  const String* content_in, const String* file_in) {
+  assert_neq(buffer, nullptr);
+  assert_neq(allocator, nullptr);
+  assert_neq(content_in, nullptr);
+  assert_neq(file_in, nullptr);
+
   String content, file;
   bool ret = slice_copy(allocator, content_in, &content);
   if (unlikely(!ret)) return false;
@@ -41,6 +46,8 @@ bool buffer_init(Buffer* buffer, const Allocator* allocator,
 }
 
 void buffer_deinit(Buffer* buffer) {
+  assert_neq(buffer, nullptr);
+
   slice_deallocate(buffer->allocator, &buffer->file);
   slice_deallocate(buffer->allocator, &buffer->content);
 
@@ -55,9 +62,26 @@ struct Buffer_Manager {
 #define buffer_manager_init(allocator) \
   Buffer_Manager { nullptr, array_init(Buffer, allocator) }
 
-void buffer_manager_deinit(Buffer_Manager* stack) {
-  assert(stack != nullptr);
-  array_deinit(&stack->buffers);
+bool buffer_manager_push(Buffer_Manager* manager, Buffer* b) {
+  assert_neq(manager, nullptr);
+  assert_neq(b, nullptr);
+
+  bool ret = array_push(&manager->buffers, b);
+  if(!ret) return false;
+
+  b = array_last(&manager->buffers);
+  if(manager->stack == nullptr) {
+    manager->stack = &b->link;
+    return true;
+  }
+
+  link_after(manager->stack, &b->link);
+  return true;
+}
+
+void buffer_manager_deinit(Buffer_Manager* manager) {
+  assert_neq(manager, nullptr);
+  array_deinit(&manager->buffers);
 }
 
 #endif
diff --git a/src/voidc.cc b/src/voidc.cc
index d536acb..be97c41 100644
--- a/src/voidc.cc
+++ b/src/voidc.cc
@@ -26,7 +26,8 @@ int main() {
   bool ret = buffer_init(&buffer, heap_allocator(), &source, &file);
   if (!ret) return EXIT_FAILURE;
 
-  buffer_deinit(&buffer);
+  buffer_manager_push(&manager, &buffer);
 
+  
   buffer_manager_deinit(&manager);
 }