`gb_internal` a lot

1 files changed, 75 insertions, 75 deletions

diff --git a/src/array.cpp b/src/array.cpp
index d08bd647f..c633078f6 100644
--- a/src/array.cpp
+++ b/src/array.cpp
@@ -23,32 +23,32 @@ struct Array {
 	}
 };
 
-template <typename T> void     array_init          (Array<T> *array, gbAllocator const &a);
-template <typename T> void     array_init          (Array<T> *array, gbAllocator const &a, isize count);
-template <typename T> void     array_init          (Array<T> *array, gbAllocator const &a, isize count, isize capacity);
-template <typename T> Array<T> array_make          (gbAllocator const &a);
-template <typename T> Array<T> array_make          (gbAllocator const &a, isize count);
-template <typename T> Array<T> array_make          (gbAllocator const &a, isize count, isize capacity);
-template <typename T> Array<T> array_make_from_ptr (T *data, isize count, isize capacity);
-template <typename T> void     array_free          (Array<T> *array);
-template <typename T> void     array_add           (Array<T> *array, T const &t);
-template <typename T> T *      array_add_and_get   (Array<T> *array);
-template <typename T> void     array_add_elems     (Array<T> *array, T const *elems, isize elem_count);
-template <typename T> T        array_pop           (Array<T> *array);
-template <typename T> void     array_clear         (Array<T> *array);
-template <typename T> void     array_reserve       (Array<T> *array, isize capacity);
-template <typename T> void     array_resize        (Array<T> *array, isize count);
-template <typename T> void     array_set_capacity  (Array<T> *array, isize capacity);
-template <typename T> Array<T> array_slice         (Array<T> const &array, isize lo, isize hi);
-template <typename T> Array<T> array_clone         (gbAllocator const &a, Array<T> const &array);
-
-template <typename T> void array_ordered_remove  (Array<T> *array, isize index);
-template <typename T> void array_unordered_remove(Array<T> *array, isize index);
-
-template <typename T> void array_copy(Array<T> *array, Array<T> const &data, isize offset);
-template <typename T> void array_copy(Array<T> *array, Array<T> const &data, isize offset, isize count);
-
-template <typename T> T *array_end_ptr(Array<T> *array);
+template <typename T> gb_internal void     array_init          (Array<T> *array, gbAllocator const &a);
+template <typename T> gb_internal void     array_init          (Array<T> *array, gbAllocator const &a, isize count);
+template <typename T> gb_internal void     array_init          (Array<T> *array, gbAllocator const &a, isize count, isize capacity);
+template <typename T> gb_internal Array<T> array_make          (gbAllocator const &a);
+template <typename T> gb_internal Array<T> array_make          (gbAllocator const &a, isize count);
+template <typename T> gb_internal Array<T> array_make          (gbAllocator const &a, isize count, isize capacity);
+template <typename T> gb_internal Array<T> array_make_from_ptr (T *data, isize count, isize capacity);
+template <typename T> gb_internal void     array_free          (Array<T> *array);
+template <typename T> gb_internal void     array_add           (Array<T> *array, T const &t);
+template <typename T> gb_internal T *      array_add_and_get   (Array<T> *array);
+template <typename T> gb_internal void     array_add_elems     (Array<T> *array, T const *elems, isize elem_count);
+template <typename T> gb_internal T        array_pop           (Array<T> *array);
+template <typename T> gb_internal void     array_clear         (Array<T> *array);
+template <typename T> gb_internal void     array_reserve       (Array<T> *array, isize capacity);
+template <typename T> gb_internal void     array_resize        (Array<T> *array, isize count);
+template <typename T> gb_internal void     array_set_capacity  (Array<T> *array, isize capacity);
+template <typename T> gb_internal Array<T> array_slice         (Array<T> const &array, isize lo, isize hi);
+template <typename T> gb_internal Array<T> array_clone         (gbAllocator const &a, Array<T> const &array);
+
+template <typename T> gb_internal void array_ordered_remove  (Array<T> *array, isize index);
+template <typename T> gb_internal void array_unordered_remove(Array<T> *array, isize index);
+
+template <typename T> gb_internal void array_copy(Array<T> *array, Array<T> const &data, isize offset);
+template <typename T> gb_internal void array_copy(Array<T> *array, Array<T> const &data, isize offset, isize count);
+
+template <typename T> gb_internal T *array_end_ptr(Array<T> *array);
 
 
 template <typename T>
@@ -56,14 +56,14 @@ struct Slice {
 	T *data;
 	isize count;
 
-	T &operator[](isize index) {
+	gb_inline T &operator[](isize index) {
 		#if !defined(NO_ARRAY_BOUNDS_CHECK)
 			GB_ASSERT_MSG(0 <= index && index < count, "Index %td is out of bounds ranges 0..<%td", index, count);
 		#endif
 		return data[index];
 	}
 
-	T const &operator[](isize index) const {
+	gb_inline T const &operator[](isize index) const {
 		#if !defined(NO_ARRAY_BOUNDS_CHECK)
 			GB_ASSERT_MSG(0 <= index && index < count, "Index %td is out of bounds ranges 0..<%td", index, count);
 		#endif
@@ -71,12 +71,12 @@ struct Slice {
 	}
 };
 
-template <typename T> Slice<T> slice_from_array(Array<T> const &a);
+template <typename T> gb_internal Slice<T> slice_from_array(Array<T> const &a);
 
 
 
 template <typename T>
-Slice<T> slice_make(gbAllocator const &allocator, isize count) {
+gb_internal Slice<T> slice_make(gbAllocator const &allocator, isize count) {
 	GB_ASSERT(count >= 0);
 	Slice<T> s = {};
 	s.data = gb_alloc_array(allocator, T, count);
@@ -86,7 +86,7 @@ Slice<T> slice_make(gbAllocator const &allocator, isize count) {
 }
 
 template <typename T>
-void slice_init(Slice<T> *s, gbAllocator const &allocator, isize count) {
+gb_internal void slice_init(Slice<T> *s, gbAllocator const &allocator, isize count) {
 	GB_ASSERT(count >= 0);
 	s->data = gb_alloc_array(allocator, T, count);
 	if (count > 0) {
@@ -96,23 +96,23 @@ void slice_init(Slice<T> *s, gbAllocator const &allocator, isize count) {
 }
 
 template <typename T>
-void slice_free(Slice<T> *s, gbAllocator const &allocator) {
+gb_internal void slice_free(Slice<T> *s, gbAllocator const &allocator) {
 	gb_free(allocator, s->data);
 }
 
 template <typename T>
-void slice_resize(Slice<T> *s, gbAllocator const &allocator, isize new_count) {
+gb_internal void slice_resize(Slice<T> *s, gbAllocator const &allocator, isize new_count) {
 	resize_array_raw(&s->data, allocator, s->count, new_count);
 	s->count = new_count;
 }
 
 
 template <typename T>
-Slice<T> slice_from_array(Array<T> const &a) {
+gb_internal Slice<T> slice_from_array(Array<T> const &a) {
 	return {a.data, a.count};
 }
 template <typename T>
-Slice<T> slice_array(Array<T> const &array, isize lo, isize hi) {
+gb_internal Slice<T> slice_array(Array<T> const &array, isize lo, isize hi) {
 	GB_ASSERT(0 <= lo && lo <= hi && hi <= array.count);
 	Slice<T> out = {};
 	isize len = hi-lo;
@@ -125,30 +125,30 @@ Slice<T> slice_array(Array<T> const &array, isize lo, isize hi) {
 
 
 template <typename T>
-Slice<T> slice_clone(gbAllocator const &allocator, Slice<T> const &a) {
+gb_internal Slice<T> slice_clone(gbAllocator const &allocator, Slice<T> const &a) {
 	T *data = cast(T *)gb_alloc_copy_align(allocator, a.data, a.count*gb_size_of(T), gb_align_of(T));
 	return {data, a.count};
 }
 
 template <typename T>
-Slice<T> slice_clone_from_array(gbAllocator const &allocator, Array<T> const &a) {
+gb_internal Slice<T> slice_clone_from_array(gbAllocator const &allocator, Array<T> const &a) {
 	auto c = array_clone(allocator, a);
 	return {c.data, c.count};
 }
 
 
 template <typename T>
-void slice_copy(Slice<T> *slice, Slice<T> const &data) {
+gb_internal void slice_copy(Slice<T> *slice, Slice<T> const &data) {
 	isize n = gb_min(slice->count, data.count);
 	gb_memmove(slice->data, data.data, gb_size_of(T)*n);
 }
 template <typename T>
-void slice_copy(Slice<T> *slice, Slice<T> const &data, isize offset) {
+gb_internal void slice_copy(Slice<T> *slice, Slice<T> const &data, isize offset) {
 	isize n = gb_clamp(slice->count-offset, 0, data.count);
 	gb_memmove(slice->data+offset, data.data, gb_size_of(T)*n);
 }
 template <typename T>
-void slice_copy(Slice<T> *slice, Slice<T> const &data, isize offset, isize count) {
+gb_internal void slice_copy(Slice<T> *slice, Slice<T> const &data, isize offset, isize count) {
 	isize n = gb_clamp(slice->count-offset, 0, gb_min(data.count, count));
 	gb_memmove(slice->data+offset, data.data, gb_size_of(T)*n);
 }
@@ -156,7 +156,7 @@ void slice_copy(Slice<T> *slice, Slice<T> const &data, isize offset, isize count
 
 
 template <typename T>
-gb_inline Slice<T> slice(Slice<T> const &array, isize lo, isize hi) {
+gb_internal gb_inline Slice<T> slice(Slice<T> const &array, isize lo, isize hi) {
 	GB_ASSERT(0 <= lo && lo <= hi && hi <= array.count);
 	Slice<T> out = {};
 	isize len = hi-lo;
@@ -169,7 +169,7 @@ gb_inline Slice<T> slice(Slice<T> const &array, isize lo, isize hi) {
 
 
 template <typename T>
-void slice_ordered_remove(Slice<T> *array, isize index) {
+gb_internal void slice_ordered_remove(Slice<T> *array, isize index) {
 	GB_ASSERT(0 <= index && index < array->count);
 
 	isize bytes = gb_size_of(T) * (array->count-(index+1));
@@ -178,7 +178,7 @@ void slice_ordered_remove(Slice<T> *array, isize index) {
 }
 
 template <typename T>
-void slice_unordered_remove(Slice<T> *array, isize index) {
+gb_internal void slice_unordered_remove(Slice<T> *array, isize index) {
 	GB_ASSERT(0 <= index && index < array->count);
 
 	isize n = array->count-1;
@@ -190,18 +190,18 @@ void slice_unordered_remove(Slice<T> *array, isize index) {
 
 
 template <typename T>
-void array_copy(Array<T> *array, Array<T> const &data, isize offset) {
+gb_internal void array_copy(Array<T> *array, Array<T> const &data, isize offset) {
 	gb_memmove(array->data+offset, data.data, gb_size_of(T)*data.count);
 }
 template <typename T>
-void array_copy(Array<T> *array, Array<T> const &data, isize offset, isize count) {
+gb_internal void array_copy(Array<T> *array, Array<T> const &data, isize offset, isize count) {
 	gb_memmove(array->data+offset, data.data, gb_size_of(T)*gb_min(data.count, count));
 }
 
 
 
 template <typename T>
-T *array_end_ptr(Array<T> *array) {
+gb_internal T *array_end_ptr(Array<T> *array) {
 	if (array->count > 0) {
 		return &array->data[array->count-1];
 	}
@@ -210,18 +210,18 @@ T *array_end_ptr(Array<T> *array) {
 
 
 template <typename T>
-gb_inline void array_init(Array<T> *array, gbAllocator const &a) {
+gb_internal gb_inline void array_init(Array<T> *array, gbAllocator const &a) {
 	isize cap = ARRAY_GROW_FORMULA(0);
 	array_init(array, a, 0, cap);
 }
 
 template <typename T>
-gb_inline void array_init(Array<T> *array, gbAllocator const &a, isize count) {
+gb_internal gb_inline void array_init(Array<T> *array, gbAllocator const &a, isize count) {
 	array_init(array, a, count, count);
 }
 
 template <typename T>
-gb_inline void array_init(Array<T> *array, gbAllocator const &a, isize count, isize capacity) {
+gb_internal gb_inline void array_init(Array<T> *array, gbAllocator const &a, isize count, isize capacity) {
 	array->allocator = a;
 	array->data = nullptr;
 	if (capacity > 0) {
@@ -234,7 +234,7 @@ gb_inline void array_init(Array<T> *array, gbAllocator const &a, isize count, is
 
 
 template <typename T>
-gb_inline Array<T> array_make_from_ptr(T *data, isize count, isize capacity) {
+gb_internal gb_inline Array<T> array_make_from_ptr(T *data, isize count, isize capacity) {
 	Array<T> a = {0};
 	a.data = data;
 	a.count = count;
@@ -244,7 +244,7 @@ gb_inline Array<T> array_make_from_ptr(T *data, isize count, isize capacity) {
 
 
 template <typename T>
-gb_inline Array<T> array_make(gbAllocator const &a) {
+gb_internal gb_inline Array<T> array_make(gbAllocator const &a) {
 	isize capacity = ARRAY_GROW_FORMULA(0);
 	Array<T> array = {};
 	array.allocator = a;
@@ -254,7 +254,7 @@ gb_inline Array<T> array_make(gbAllocator const &a) {
 	return array;
 }
 template <typename T>
-gb_inline Array<T> array_make(gbAllocator const &a, isize count) {
+gb_internal gb_inline Array<T> array_make(gbAllocator const &a, isize count) {
 	Array<T> array = {};
 	array.allocator = a;
 	array.data = gb_alloc_array(a, T, count);
@@ -263,7 +263,7 @@ gb_inline Array<T> array_make(gbAllocator const &a, isize count) {
 	return array;
 }
 template <typename T>
-gb_inline Array<T> array_make(gbAllocator const &a, isize count, isize capacity) {
+gb_internal gb_inline Array<T> array_make(gbAllocator const &a, isize count, isize capacity) {
 	Array<T> array = {};
 	array.allocator = a;
 	array.data = gb_alloc_array(a, T, capacity);
@@ -275,7 +275,7 @@ gb_inline Array<T> array_make(gbAllocator const &a, isize count, isize capacity)
 
 
 template <typename T>
-gb_inline void array_free(Array<T> *array) {
+gb_internal gb_inline void array_free(Array<T> *array) {
 	if (array->allocator.proc != nullptr) {
 		gb_free(array->allocator, array->data);
 	}
@@ -284,7 +284,7 @@ gb_inline void array_free(Array<T> *array) {
 }
 
 template <typename T>
-void array__grow(Array<T> *array, isize min_capacity) {
+gb_internal void array__grow(Array<T> *array, isize min_capacity) {
 	isize new_capacity = ARRAY_GROW_FORMULA(array->capacity);
 	if (new_capacity < min_capacity) {
 		new_capacity = min_capacity;
@@ -293,7 +293,7 @@ void array__grow(Array<T> *array, isize min_capacity) {
 }
 
 template <typename T>
-void array_add(Array<T> *array, T const &t) {
+gb_internal void array_add(Array<T> *array, T const &t) {
 	if (array->capacity < array->count+1) {
 		array__grow(array, 0);
 	}
@@ -302,7 +302,7 @@ void array_add(Array<T> *array, T const &t) {
 }
 
 template <typename T>
-T *array_add_and_get(Array<T> *array) {
+gb_internal T *array_add_and_get(Array<T> *array) {
 	if (array->count < array->capacity) {
 		return &array->data[array->count++];
 	}
@@ -314,7 +314,7 @@ T *array_add_and_get(Array<T> *array) {
 
 
 template <typename T>
-void array_add_elems(Array<T> *array, T const *elems, isize elem_count) {
+gb_internal void array_add_elems(Array<T> *array, T const *elems, isize elem_count) {
 	GB_ASSERT(elem_count >= 0);
 	if (array->capacity < array->count+elem_count) {
 		array__grow(array, array->count+elem_count);
@@ -325,26 +325,26 @@ void array_add_elems(Array<T> *array, T const *elems, isize elem_count) {
 
 
 template <typename T>
-gb_inline T array_pop(Array<T> *array) {
+gb_internal gb_inline T array_pop(Array<T> *array) {
 	GB_ASSERT(array->count > 0);
 	array->count--;
 	return array->data[array->count];
 }
 
 template <typename T>
-void array_clear(Array<T> *array) {
+gb_internal void array_clear(Array<T> *array) {
 	array->count = 0;
 }
 
 template <typename T>
-void array_reserve(Array<T> *array, isize capacity) {
+gb_internal void array_reserve(Array<T> *array, isize capacity) {
 	if (array->capacity < capacity) {
 		array_set_capacity(array, capacity);
 	}
 }
 
 template <typename T>
-void array_resize(Array<T> *array, isize count) {
+gb_internal void array_resize(Array<T> *array, isize count) {
 	if (array->capacity < count) {
 		array__grow(array, count);
 	}
@@ -352,7 +352,7 @@ void array_resize(Array<T> *array, isize count) {
 }
 
 template <typename T>
-void array_set_capacity(Array<T> *array, isize capacity) {
+gb_internal void array_set_capacity(Array<T> *array, isize capacity) {
 	if (capacity == array->capacity) {
 		return;
 	}
@@ -381,7 +381,7 @@ void array_set_capacity(Array<T> *array, isize capacity) {
 
 
 template <typename T>
-gb_inline Array<T> array_slice(Array<T> const &array, isize lo, isize hi) {
+gb_internal gb_inline Array<T> array_slice(Array<T> const &array, isize lo, isize hi) {
 	GB_ASSERT(0 <= lo && lo <= hi && hi <= array.count);
 	Array<T> out = {};
 	isize len = hi-lo;
@@ -394,7 +394,7 @@ gb_inline Array<T> array_slice(Array<T> const &array, isize lo, isize hi) {
 }
 
 template <typename T>
-Array<T> array_clone(gbAllocator const &allocator, Array<T> const &array) {
+gb_internal Array<T> array_clone(gbAllocator const &allocator, Array<T> const &array) {
 	auto clone = array_make<T>(allocator, array.count, array.count);
 	array_copy(&clone, array, 0);
 	return clone;
@@ -402,7 +402,7 @@ Array<T> array_clone(gbAllocator const &allocator, Array<T> const &array) {
 
 
 template <typename T>
-void array_ordered_remove(Array<T> *array, isize index) {
+gb_internal void array_ordered_remove(Array<T> *array, isize index) {
 	GB_ASSERT(0 <= index && index < array->count);
 
 	isize bytes = gb_size_of(T) * (array->count-(index+1));
@@ -411,7 +411,7 @@ void array_ordered_remove(Array<T> *array, isize index) {
 }
 
 template <typename T>
-void array_unordered_remove(Array<T> *array, isize index) {
+gb_internal void array_unordered_remove(Array<T> *array, isize index) {
 	GB_ASSERT(0 <= index && index < array->count);
 
 	isize n = array->count-1;
@@ -424,35 +424,35 @@ void array_unordered_remove(Array<T> *array, isize index) {
 
 
 template <typename T>
-T *begin(Array<T> &array) {
+gb_internal T *begin(Array<T> &array) {
 	return array.data;
 }
 template <typename T>
-T const *begin(Array<T> const &array) {
+gb_internal T const *begin(Array<T> const &array) {
 	return array.data;
 }
 template <typename T>
-T *end(Array<T> &array) {
+gb_internal T *end(Array<T> &array) {
 	return array.data + array.count;
 }
 template <typename T>
-T const *end(Array<T> const &array) {
+gb_internal T const *end(Array<T> const &array) {
 	return array.data + array.count;
 }
 
 template <typename T>
-T *begin(Slice<T> &array) {
+gb_internal T *begin(Slice<T> &array) {
 	return array.data;
 }
 template <typename T>
-T const *begin(Slice<T> const &array) {
+gb_internal T const *begin(Slice<T> const &array) {
 	return array.data;
 }
 template <typename T>
-T *end(Slice<T> &array) {
+gb_internal T *end(Slice<T> &array) {
 	return array.data + array.count;
 }
 template <typename T>
-T const *end(Slice<T> const &array) {
+gb_internal T const *end(Slice<T> const &array) {
 	return array.data + array.count;
 }