core build system and array, it compiles!

base_data_structures.cpp

@@ -1,146 +1,8 @@
-
-//-----------------------------------------------------------------------------
-// Array
-//-----------------------------------------------------------------------------
-template <class T>
-struct Array {
-    Allocator *allocator;
-    T *data;
-    S64 cap;
-    S64 len;
-
-    T *push_empty(S64 count = 1) {
-        grow(count);
-        T *result = data + len;
-        len += count;
-        return result;
-    }
-
-    T *push_empty_zero(S64 count = 1) {
-        T *result = push_empty(count);
-        memory_zero(result, count * sizeof(T));
-        return result;
-    }
-
-    void grow(S64 required_size) {
-        if (cap == 0) {
-            S64 new_cap = max(required_size * 2, (S64)16);
-            data = allocate_array(allocator, T, new_cap);
-            cap = new_cap;
-        }
-        else if (len + required_size > cap) {
-            U64 new_cap = max(cap * 2, len + required_size + 1);
-            T *new_data = allocate_array(allocator, T, new_cap);
-            memory_copy(new_data, data, cap * sizeof(T));
-            deallocate(allocator, data);
-            data = new_data;
-            cap = new_cap;
-        }
-    }
-
-    void dealloc() {
-        if (data) deallocate(allocator, data);
-    }
-
-    S64 get_index(T *item) {
-        assert((data <= item) && ((data + len) > item));
-        size_t offset = item - data;
-        return (S64)offset;
-    }
-
-    void add(Array<T> items) {
-        For(items) {
-            add(it);
-        }
-    }
-
-#if 0
-    void insert(T item, int index) {
-        if (index == len) {
-            add(item);
-            return;
-        }
-
-        assert(index < len);
-        assert(index >= 0);
-
-        grow(1);
-        int right_len = len - index;
-        memmove(data + index + 1, data + index, sizeof(T) * right_len);
-        data[index] = item;
-        len += 1;
-    }
-#endif
-
-    void add(T item) {
-        grow(1);
-        data[len++] = item;
-    }
-
-    S64 addi(T item) {
-        S64 result = len;
-        grow(1);
-        data[len++] = item;
-        return result;
-    }
-
-    void unordered_remove(T *item) {
-        assert(len > 0);
-        assert((data <= item) && ((data + len) > item));
-        *item = data[--len];
-    }
-
-    void init(Allocator *a, S64 size = 16) {
-        allocator = a;
-        data = allocate_array(a, T, size);
-        cap = size;
-        len = 0;
-    }
-
-    Array<T> copy(Allocator *a) {
-        Array<T> result = {};
-        result.len = len;
-        result.cap = len * 2;
-        result.allocator = a;
-        result.data = allocate_array(a, T, result.cap);
-        memory_copy(result.data, data, sizeof(T) * result.len);
-        return result;
-    }
-
-    Array<T> tight_copy(Allocator *a) {
-        Array<T> result = {};
-        result.len = len;
-        result.cap = len;
-        result.allocator = 0;
-        result.data = allocate_array(a, T, len);
-        memory_copy(result.data, data, sizeof(T) * len);
-        return result;
-    }
-
-    void ordered_remove(T &item) { // Dont use in loops !!!!
-        assert(len > 0);
-        assert(&item >= begin() && &item < end());
-        int index = get_index(&item);
-        assert(index >= 0 && index < len);
-
-        int right_len = len - index - 1;
-        memmove(data + index, data + index + 1, right_len * sizeof(T));
-        len -= 1;
-    }
-
-    force_inline B32 is_last(T *item) { return item == last(); }
-    force_inline B32 is_first(T *item) { return item == begin(); }
-    force_inline void clear() { len = 0; }
-    force_inline void reset() { len = 0; }
-    force_inline T pop() { return data[--len]; }
-    force_inline T *last() { return data + len - 1; }
-    force_inline T *begin() { return data; }
-    force_inline T *end() { return data + len; }
-    force_inline T &operator[](S64 i) {
-        assert(i >= 0 && i < cap);
-        return data[i];
-    }
-};
+#define ARRAY_ALLOCATOR_TYPE Allocator
+#define ARRAY_ASSERT assert
+#define ARRAY_ALLOCATE(allocator, size) allocate_size(allocator, size)
+#define ARRAY_DEALLOCATE(allocator, p) deallocate(allocator, p)
+#include "core/array.hpp"
 
 //-----------------------------------------------------------------------------
 // Map