CORE_Static

base.cpp

@@ -117,7 +117,7 @@ typedef double   F64;
 #define F64MIN DBL_MIN
 
 #define api
-#define function static
+#define CORE_Static static
 #define global static
 #define assert(x) do{if(!(x))Breakpoint;}while(0)
 #define assert_message(x,...) assert(x)
@@ -229,7 +229,7 @@ union Rect2I {
 //-----------------------------------------------------------------------------
 // Utilities
 //-----------------------------------------------------------------------------
-function size_t
+CORE_Static size_t
 get_align_offset(size_t size, size_t align){
   size_t mask = align - 1;
   size_t val = size & mask;
@@ -239,20 +239,20 @@ get_align_offset(size_t size, size_t align){
   return val;
 }
 
-function size_t
+CORE_Static size_t
 align_up(size_t size, size_t align){
   size_t result = size + get_align_offset(size, align);
   return result;
 }
 
-function size_t
+CORE_Static size_t
 align_down(size_t size, size_t align){
   size += 1; // Make sure 8 when align is 8 doesn't get rounded down to 0
   size_t result = size - (align - get_align_offset(size, align));
   return result;
 }
 
-function void
+CORE_Static void
 memory_copy(void *dst, void *src, size_t size){
   U8 *d = (U8*)dst;
   U8 *s = (U8*)src;
@@ -261,7 +261,7 @@ memory_copy(void *dst, void *src, size_t size){
   }
 }
 
-function void
+CORE_Static void
 memory_zero(void *p, size_t size){
   U8 *pp = (U8 *)p;
   for(size_t i = 0; i < size; i++)
@@ -306,7 +306,7 @@ T clamp(T min, T val, T max){
   return val;
 }
 
-function U64
+CORE_Static U64
 hash_string(String string) {
   U64 hash = (U64)14695981039346656037ULL;
   for (U64 i = 0; i < string.len; i++) {
@@ -316,19 +316,19 @@ hash_string(String string) {
   return hash;
 }
 
-function U64
+CORE_Static U64
 hash_u64(U64 x) {
   x *= 0xff51afd7ed558ccd;
   x ^= x >> 32;
   return x;
 }
 
-function U64
+CORE_Static U64
 hash_ptr(const void *ptr) {
   return hash_u64((uintptr_t)ptr);
 }
 
-function U64
+CORE_Static U64
 hash_mix(U64 x, U64 y) {
   // @note: murmur hash 3 mixer but I add the 'y'
   // which means it's probably bad, hopefully better
@@ -341,14 +341,14 @@ hash_mix(U64 x, U64 y) {
   return x;
 }
 
-function U64
+CORE_Static U64
 is_pow2(U64 x) {
   assert(x != 0);
   B32 result = (x & (x - 1llu)) == 0;
   return result;
 }
 
-function U64
+CORE_Static U64
 wrap_around_pow2(U64 x, U64 power_of_2) {
   assert(is_pow2(power_of_2));
   U64 r = (((x)&((power_of_2)-1llu)));
@@ -487,10 +487,10 @@ struct OS_Memory{
   size_t commit, reserve;
   U8 *data;
 };
-function OS_Memory os_reserve(size_t size);
-function B32 os_commit(OS_Memory *m, size_t size);
-function void os_release(OS_Memory *m);
-function B32 os_decommit_pos(OS_Memory *m, size_t pos);
+CORE_Static OS_Memory os_reserve(size_t size);
+CORE_Static B32 os_commit(OS_Memory *m, size_t size);
+CORE_Static void os_release(OS_Memory *m);
+CORE_Static B32 os_decommit_pos(OS_Memory *m, size_t pos);
 
 //-----------------------------------------------------------------------------
 // Memory arenas
@@ -504,34 +504,34 @@ struct Arena{
   size_t len;
   String debug_string;
 };
-function void arena_init(Arena *arena, String debug_name);
+CORE_Static void arena_init(Arena *arena, String debug_name);
 
-function void
+CORE_Static void
 arena_pop_pos(Arena *arena, size_t pos){
   pos = clamp_top(pos, arena->len);
   arena->len = pos;
 }
 
-function void *
+CORE_Static void *
 arena_pop(Arena *arena, size_t size){
   size = clamp_top(size, arena->len);
   arena->len -= size;
   return arena->memory.data + arena->len;
 }
 
-function void
+CORE_Static void
 arena_release(Arena *arena){
   os_release(&arena->memory);
 }
 
-function void
+CORE_Static void
 arena_clear(Arena *arena){
   arena_pop_pos(arena, 0);
 }
 
 #define arena_push_array(a, T, size,...) (T *)arena_push_size(a, sizeof(T)*(size),##__VA_ARGS__)
 #define arena_push_type(a, T, ...) arena_push_array(a, T, 1,##__VA_ARGS__)
-function void *
+CORE_Static void *
 arena_push_size(Arena *a, size_t size, Alloc_Flag flags = AF_None){
   size_t generous_size = size + a->alignment;
   if(a->len+generous_size>a->memory.commit){
@@ -554,7 +554,7 @@ arena_push_size(Arena *a, size_t size, Alloc_Flag flags = AF_None){
   return result;
 }
 
-function void
+CORE_Static void
 arena_init(Arena *a, String debug_name){
   a->memory     = os_reserve(default_reserve_size);
   a->alignment  = default_alignment;
@@ -615,7 +615,7 @@ struct Scratch{
   Scratch(Scratch &arena, Scratch &a2);
 };
 
-function void
+CORE_Static void
 thread_ctx_init(){
   arena_init(thread_ctx.scratch, "Scratch1"_s);
   arena_init(thread_ctx.scratch+1, "Scratch2"_s);
@@ -741,7 +741,7 @@ struct Array{
 
 
 template<class T>
-function Array<T>
+CORE_Static Array<T>
 array_make(Arena *a, S64 size = 16){
   Array<T> result = {};
   result.init(a, size);
@@ -756,7 +756,7 @@ array_make(Arena *a, S64 size = 16){
 #define log_info_no_nl(...) handle_log_message(Log_Kind_Normal_No_NewLine, __LINE__, __FILE__,##__VA_ARGS__)
 #define log_trace(...) handle_log_message(Log_Kind_Trace, __LINE__, __FILE__,##__VA_ARGS__)
 #define log_error(...) handle_log_message(Log_Kind_Error, __LINE__, __FILE__,##__VA_ARGS__)
-function void
+CORE_Static void
 handle_log_message(Log_Kind kind, int line, const char *file, const char *str, ...){
   if(kind == Log_Kind_Trace) return;
 
@@ -806,9 +806,9 @@ struct Map{
   S64 len;
   S64 cap;
 };
-function void map_insert(Map *map, U64 key, void *val);
+CORE_Static void map_insert(Map *map, U64 key, void *val);
 
-function void
+CORE_Static void
 map_grow(Map *map, S64 new_size){
   new_size = max((S64)16, new_size);
   assert(new_size > map->cap);
@@ -829,14 +829,14 @@ map_grow(Map *map, S64 new_size){
   *map = new_map;
 }
 
-function Map
+CORE_Static Map
 map_make(Arena *a, S64 size){
   Map result = {a};
   map_grow(&result, size);
   return result;
 }
 
-function void
+CORE_Static void
 map_insert(Map *map, U64 key, void *val){
   assert(val);
   assert(key);
@@ -869,7 +869,7 @@ map_insert(Map *map, U64 key, void *val){
   }
 }
 
-function Map_Key_Value *
+CORE_Static Map_Key_Value *
 map_base_get(Map *map, U64 key){
   if(map->len == 0) return 0;
   assert(key);
@@ -892,14 +892,14 @@ map_base_get(Map *map, U64 key){
   }
 }
 
-function void *
+CORE_Static void *
 map_get(Map *map, U64 key){
   Map_Key_Value *result = map_base_get(map, key);
   if(result && result->occupied) return result->value;
   return 0;
 }
 
-function void *
+CORE_Static void *
 map_remove(Map *map, U64 key){
   Map_Key_Value *kv = map_base_get(map, key);
   if(kv){
@@ -909,27 +909,27 @@ map_remove(Map *map, U64 key){
   return 0;
 }
 
-function void *
+CORE_Static void *
 map_get(Map *map, void *pointer){
   return map_get(map, (U64)pointer);
 }
 
-function void *
+CORE_Static void *
 map_get(Map *map, Intern_String string){
   return map_get(map, hash_string(string.s));
 }
 
-function void
+CORE_Static void
 map_insert(Map *map, void *key, void *value){
   map_insert(map, (U64)key, value);
 }
 
-function void
+CORE_Static void
 map_insert(Map *map, Intern_String key, void *value){
   map_insert(map, hash_string(key.s), value);
 }
 
-function void
+CORE_Static void
 map_test(){
   Scratch scratch;
   Map map = {scratch};
@@ -953,7 +953,7 @@ struct Intern_Table{
   U8 *last_keyword;
 };
 
-function Intern_Table
+CORE_Static Intern_Table
 intern_table_make(Arena *string_allocator, Arena *map_allocator, S64 initial_size = 32){
   Intern_Table result     = {};
   result.map              = map_make(map_allocator, initial_size);
@@ -961,7 +961,7 @@ intern_table_make(Arena *string_allocator, Arena *map_allocator, S64 initial_siz
   return result;
 }
 
-function Intern_String
+CORE_Static Intern_String
 intern_string(Intern_Table *t, String string){
   assert(t->string_allocator);
   U64 hash = hash_string(string);
@@ -984,7 +984,7 @@ intern_string(Intern_Table *t, String string){
   return result;
 }
 
-function void
+CORE_Static void
 test_intern_table(){
   Scratch scratch;
   Intern_Table table = intern_table_make(scratch, scratch);
@@ -995,7 +995,7 @@ test_intern_table(){
   assert(intern3.str != intern2.str);
 }
 
-function Arena
+CORE_Static Arena
 arena_sub(Arena *base, size_t size, String debug_name) {
   Arena result = {};
   result.memory.data = (U8 *)arena_push_size(base, size);