Working on simplifying the allocation scheme

base.cpp

@@ -415,7 +415,7 @@ operator!=(Intern_String a, Intern_String b){
 #define allocate_array(a, T, size,...) (T *)allocate_size(a, sizeof(T)*(size),##__VA_ARGS__)
 #define allocate_struct(a, T, ...) allocate_array(a, T, 1,##__VA_ARGS__)
 CORE_Static void *allocate_size(Allocator *allocator, size_t size, bool zero_memory = true) {
-  void *result = allocator->allocate(allocator, size);
+void *result = allocator->allocate(allocator, size);
   if (zero_memory) {
     memory_zero(result, size);
   }
@@ -517,6 +517,17 @@ arena_init(Arena *a, String debug_name){
   a->deallocate   = (Allocator::Deallocate *)deallocate_stub;
 }
 
+CORE_Static Arena
+arena_sub(Arena *base, size_t size, String debug_name) {
+  Arena result = {};
+  result.memory.data = (U8 *)arena_push_size(base, size);
+  result.memory.commit = size;
+  result.memory.reserve = size;
+  result.alignment = default_alignment;
+  result.len = 0;
+  return result;
+}
+
 enum Log_Kind{Log_Kind_Normal_No_NewLine, Log_Kind_Normal, Log_Kind_Error, Log_Kind_Trace};
 typedef void Log_Proc(Log_Kind kind, String string, char *file, int line);
 //-----------------------------------------------------------------------------
@@ -652,7 +663,7 @@ struct Array{
     cap       = size;
   }
 
-  Array<T> copy(Arena *a){
+  Array<T> copy(Allocator *a){
     Array<T> result = {};
     result.len = len;
     result.cap = len*2;
@@ -662,7 +673,7 @@ struct Array{
     return result;
   }
 
-  Array<T> tight_copy(Arena *a){
+  Array<T> tight_copy(Allocator *a){
     Array<T> result = {};
     result.len = len;
     result.cap = len;
@@ -952,17 +963,6 @@ test_intern_table(){
   assert(intern3.str != intern2.str);
 }
 
-CORE_Static Arena
-arena_sub(Arena *base, size_t size, String debug_name) {
-  Arena result = {};
-  result.memory.data = (U8 *)arena_push_size(base, size);
-  result.memory.commit = size;
-  result.memory.reserve = size;
-  result.alignment = default_alignment;
-  result.len = 0;
-  return result;
-}
-
 //-----------------------------------------------------------------------------
 // Array List
 // @todo(krzosa): If even one item got removed from block
@@ -990,21 +990,23 @@ struct List{
 };
 
 template<class T>
-List_Node<T> *list_allocate_node(Arena *arena, int size){
-  auto node = (List_Node<T> *)arena_push_size(arena, sizeof(List_Node<T>) + size*sizeof(T));
+List_Node<T> *list_allocate_node(Allocator *arena, int size){
+  auto node = (List_Node<T> *)allocate_size(arena, sizeof(List_Node<T>) + size*sizeof(T), false);
   node->cap = size;
   node->len = 0;
+  node->next = 0;
+  node->prev = 0;
   return node;
 }
 
 template<class T>
-void list_allocate_free_node(Arena *arena, List<T> *list, int size){
+void list_allocate_free_node(Allocator *arena, List<T> *list, int size){
   List_Node<T> *node = list_allocate_node<T>(arena, size);
   DLL_STACK_ADD(list->first_free, node);
 }
 
 template<class T>
-void list_make_sure_there_is_room_for_item_count(Arena *arena, List<T> *list, int item_count){
+void list_make_sure_there_is_room_for_item_count(Allocator *arena, List<T> *list, int item_count){
   if(list->last == 0 || list->last->len + item_count > list->last->cap){
     // Not enough space we need to get a new block
     List_Node<T> *node = 0;
@@ -1064,13 +1066,13 @@ T get(List<T> *list, int index){
 }
 
 template<class T>
-void add(Arena *arena, List<T> *list, T item){
+void add(Allocator *arena, List<T> *list, T item){
   list_make_sure_there_is_room_for_item_count(arena, list, 1);
   list->last->data[list->last->len++] = item;
 }
 
 template<class T>
-T *add_size(Arena *arena, List<T> *list, int count = 1, int zero_memory = 0){
+T *add_size(Allocator *arena, List<T> *list, int count = 1, int zero_memory = 0){
   list_make_sure_there_is_room_for_item_count(arena, list, count);
   T *result = list->last->data + list->last->len;
   list->last->len += count;
@@ -1183,9 +1185,9 @@ T pop(List<T> *list){
 }
 
 template<class T>
-T *merge(Arena *arena, List<T> *list){
+T *merge(Allocator *arena, List<T> *list){
   int len = length(list);
-  T *result = arena_push_array(arena, T, len);
+  T *result = allocate_size(arena, T, len, false);
 
   int i = 0;
   For_Linked_List(list->first){