core api redesign

build_file.c

@@ -16,9 +16,9 @@ int main(int argc, char **argv) {
     meta_app(arena);
 
     bool run_server = false;
-    bool core_test_target = false;
+    bool core_test_target = true;
     bool wasm_target = true;
-    bool win32_target = true;
+    bool win32_target = false;
 
     if (run_server) {
         os_systemf("start /D ..\\package ..\\package\\run_server.bat");

src/app/app_wasm.c

@@ -28,12 +28,11 @@ STACK(app_event_t, 64) wasm_events;
 b32 wasm_event_failed_to_queue;
 f64 wasm_last_time = 0;
 
-void write_to_console(char *string) {
+void write_to_console(s8_t string) {
-    i32 len = str_len(string);
+    wasm_write_to_console((isize)string.str, (i32)string.len);
-    wasm_write_to_console((isize)string, len);
 }
 
-f64 s8_deserial_f64(s8_t string) {
+f64 f64_from_s8(s8_t string) {
     return wasm_parse_float((isize)string.str, (i32)string.len);
 }
 

src/core/core.c

@@ -1,5 +1,3 @@
-#include <stdarg.h>
-
 #if PLATFORM_WINDOWS
 #define NOMINMAX
 #define WIN32_LEAN_AND_MEAN
@@ -25,17 +23,15 @@
 #include <stdlib.h>
 #endif
 
-#include "intrinsics.c"
+#include "core_intrin.c"
-#include "unicode.c"
+#include "core_unicode.c"
-#include "mathx.c"
+#include "core_math.c"
-#include "mathx.gen.c"
+#include "core_math.gen.c"
-#include "arena.c"
+#include "core_arena.c"
 
 #define STB_SPRINTF_IMPLEMENTATION
 #include "stb_sprintf.h"
-#include "string.c"
+#include "core_string.c"
-#include "string8.c"
-#include "scratch.c"
 #include "log.c"
-#include "lexer.c"
+#include "core_lexer.c"
-#include "type_info.c"
+#include "core_type_info.c"

src/core/core.h

@@ -1,5 +1,12 @@
-#include "platform_defines.h"
+#include "core_platform_defines.h"
 #include <stdint.h>
 #include <stddef.h>
-#include "types.h"
+#include <stdarg.h>
-#include "type_info.h"
+#include "core_defines.h"
+#include "core_unicode.h"
+#include "core_arena.h"
+#include "core_string.h"
+#include "core_lexer.h"
+#include "core_math.h"
+#include "core_intrin.h"
+#include "core_type_info.h"

src/core/core_arena.c

@@ -1,9 +1,9 @@
-b32 is_pow2(usize x) {
+fn b32 is_pow2(usize x) {
     b32 result = (((x) & ((x)-1)) == 0);
     return result;
 }
 
-usize get_align_offset(usize size, usize align) {
+fn usize get_align_offset(usize size, usize align) {
     assert(is_pow2(align));
     if (align == 0) return 0;
 
@@ -15,18 +15,18 @@ usize get_align_offset(usize size, usize align) {
     return val;
 }
 
-usize align_up(usize size, usize align) {
+fn usize align_up(usize size, usize align) {
     usize result = size + get_align_offset(size, align);
     return result;
 }
 
-usize align_down(usize size, usize align) {
+fn usize align_down(usize size, usize align) {
     size += 1; // Make sure when align is 8 doesn't get rounded down to 0
     usize result = size - (align - get_align_offset(size, align));
     return result;
 }
 
-void ma_init(ma_arena_t *arena, usize reserve) {
+fn void ma_init(ma_arena_t *arena, usize reserve) {
     reserve      = align_up(reserve, ma_page_size);
     arena->align = ma_default_alignment;
     arena->data  = (u8 *)vmem_reserve(reserve);
@@ -35,7 +35,7 @@ void ma_init(ma_arena_t *arena, usize reserve) {
     }
 }
 
-ma_arena_t *ma_create(usize reserve) {
+fn ma_arena_t *ma_create(usize reserve) {
     ma_arena_t *result = NULL;
 
     void *data = vmem_reserve(reserve);
@@ -56,7 +56,7 @@ ma_arena_t *ma_create(usize reserve) {
     return result;
 }
 
-void *ma_push_size_ex(ma_arena_t *arena, usize size) {
+fn void *ma_push_size_ex(ma_arena_t *arena, usize size) {
     // base_len is used for bootstraping arenas, it denotes the
     // space occupied by the arena. If len is smaller then base_len then
     // we start to overwrite the arena itself - pure barbarism.
@@ -92,13 +92,13 @@ void *ma_push_size_ex(ma_arena_t *arena, usize size) {
     return (void *)result;
 }
 
-void *ma_push_size(ma_arena_t *arena, usize size) {
+fn void *ma_push_size(ma_arena_t *arena, usize size) {
     void *result = ma_push_size_ex(arena, size);
     if (result) memory_zero(result, size);
     return result;
 }
 
-ma_arena_t *ma_push_arena(ma_arena_t *allocator, usize size) {
+fn ma_arena_t *ma_push_arena(ma_arena_t *allocator, usize size) {
     ma_arena_t *result   = ma_push_type(allocator, ma_arena_t);
     result->data    = (u8 *)ma_push_size(allocator, size);
     result->reserve = size;
@@ -107,14 +107,14 @@ ma_arena_t *ma_push_arena(ma_arena_t *allocator, usize size) {
     return result;
 }
 
-void ma_destroy(ma_arena_t *arena) {
+fn void ma_destroy(ma_arena_t *arena) {
     if (arena == NULL || arena->data == NULL) return;
     b32 zero_memory = (u8 *)arena != arena->data;
     vmem_release(arena->data);
     if (zero_memory) memory_zero(arena, sizeof(ma_arena_t));
 }
 
-void ma_set_len(ma_arena_t *arena, usize pos) {
+fn void ma_set_len(ma_arena_t *arena, usize pos) {
     // base_len is used for bootstraping arenas, it denotes the
     // space occupied by the arena. If len is smaller then base_len then
     // we start to overwrite the arena itself - pure barbarism.
@@ -126,7 +126,42 @@ void ma_set_len(ma_arena_t *arena, usize pos) {
     MA_ASAN_POISON_MEMORY_REGION(arena->data + arena->len, size);
 }
 
-void      ma_pop(ma_arena_t *arena, usize size) { ma_set_len(arena, arena->len - size); }
+fn void      ma_pop(ma_arena_t *arena, usize size) { ma_set_len(arena, arena->len - size); }
-ma_temp_t ma_begin_temp(ma_arena_t *arena) { return (ma_temp_t){arena, arena->len}; }
+fn ma_temp_t ma_begin_temp(ma_arena_t *arena) { return (ma_temp_t){arena, arena->len}; }
-void      ma_end_temp(ma_temp_t temp) { ma_set_len(temp.arena, temp.len); }
+fn void      ma_end_temp(ma_temp_t temp) { ma_set_len(temp.arena, temp.len); }
-void      ma_set0(ma_arena_t *arena) { ma_set_len(arena, 0); }
+fn void      ma_set0(ma_arena_t *arena) { ma_set_len(arena, 0); }
+
+//
+// Scratch arena
+fn ma_temp_t ma_begin_scratch_ex(ma_arena_t **conflicts, int conflict_count) {
+    ma_arena_t *unoccupied = 0;
+    for (int i = 0; i < lengthof(core_desc.scratch); i += 1) {
+        ma_arena_t *from_pool = core_desc.scratch + i;
+        unoccupied          = from_pool;
+        for (int conflict_i = 0; conflict_i < conflict_count; conflict_i += 1) {
+            ma_arena_t *from_conflict = conflicts[conflict_i];
+            if (from_pool == from_conflict) {
+                unoccupied = 0;
+                break;
+            }
+        }
+
+        if (unoccupied) {
+            break;
+        }
+    }
+
+    assertf(unoccupied, "Failed to get free scratch memory, this is a fatal error, this shouldnt happen");
+    ma_temp_t result = ma_begin_temp(unoccupied);
+    return result;
+}
+
+fn ma_temp_t ma_begin_scratch(void) {
+    ma_temp_t result = ma_begin_temp(core_desc.scratch + 0);
+    return result;
+}
+
+fn ma_temp_t ma_begin_scratch1(ma_arena_t *conflict) {
+    ma_arena_t *conflicts[] = {conflict};
+    return ma_begin_scratch_ex(conflicts, 1);
+}

src/core/core_arena.h

@@ -0,0 +1,53 @@
+const usize ma_page_size            = 4096;
+const usize ma_default_alignment    = sizeof(void *);
+const usize ma_default_reserve_size = mib(256);
+
+typedef struct ma_arena_t ma_arena_t;
+struct ma_arena_t {
+    u8     *data;
+    usize   len;
+    usize   base_len; // to prevent self deleting the arena
+    usize   reserve;
+    usize   commit;
+    usize   align;
+};
+
+typedef struct ma_temp_t ma_temp_t;
+struct ma_temp_t {
+    ma_arena_t *arena;
+    usize len;
+};
+
+//
+// constructors
+fn void        ma_init(ma_arena_t *arena, usize reserve);
+fn ma_arena_t *ma_create(usize reserve);
+fn void        ma_destroy(ma_arena_t *arena);
+
+//
+// push
+fn void       *ma_push_size_ex(ma_arena_t *arena, usize size);
+fn void       *ma_push_size(ma_arena_t *arena, usize size);
+fn ma_arena_t *ma_push_arena(ma_arena_t *allocator, usize size);
+#define ma_push_type(arena, Type) (Type *)ma_push_size((arena), sizeof(Type))
+#define ma_push_array(arena, Type, count) (Type *)ma_push_size((arena), sizeof(Type) * (count))
+
+//
+// pop
+fn void        ma_set_len(ma_arena_t *arena, usize pos);
+fn void        ma_pop(ma_arena_t *arena, usize size);
+fn void        ma_set0(ma_arena_t *arena);
+
+//
+// temp
+fn ma_temp_t   ma_begin_temp(ma_arena_t *arena);
+fn void        ma_end_temp(ma_temp_t temp);
+#define ma_temp_scope(name, InArena) for (ma_temp_t name = ma_begin_temp(InArena); name.arena; (ma_end_temp(name), name.arena = 0))
+
+//
+// scratch
+fn ma_temp_t ma_begin_scratch_ex(ma_arena_t **conflicts, int conflict_count);
+fn ma_temp_t ma_begin_scratch(void);
+fn ma_temp_t ma_begin_scratch1(ma_arena_t *conflict);
+#define ma_end_scratch(x) ma_end_temp(x)
+#define ma_scratch_scope(x) for (ma_temp_t x = ma_begin_scratch(); x.arena; (ma_end_temp(x), x.arena = 0))

src/core/core_defines.h

@@ -25,6 +25,10 @@ typedef double f64;
 #define false 0
 #endif
 
+#define fn
+#define glb
+#define locl
+
 #define MIN(x,y) ((x) > (y) ? (y) : (x))
 #define MAX(x,y) ((x) > (y) ? (x) : (y))
 
@@ -226,313 +230,6 @@ typedef double f64;
     } while (0)
 #define DLLS_REMOVE(first, node) DLLS_REMOVE_MOD(first, node, next, prev)
 
-const usize ma_page_size            = 4096;
-const usize ma_default_alignment    = sizeof(void *);
-const usize ma_default_reserve_size = mib(256);
-
-typedef struct ma_arena_t ma_arena_t;
-struct ma_arena_t {
-    u8     *data;
-    usize   len;
-    usize   base_len; // to prevent self deleting the arena
-    usize   reserve;
-    usize   commit;
-    usize   align;
-};
-
-typedef struct ma_temp_t ma_temp_t;
-struct ma_temp_t {
-    ma_arena_t *arena;
-    usize len;
-};
-
-void        ma_init(ma_arena_t *arena, usize reserve);
-ma_arena_t *ma_create(usize reserve);
-void        ma_destroy(ma_arena_t *arena);
-
-void       *ma_push_size_ex(ma_arena_t *arena, usize size);
-void       *ma_push_size(ma_arena_t *arena, usize size);
-ma_arena_t *ma_push_arena(ma_arena_t *allocator, usize size);
-
-#define ma_push_type(arena, Type) (Type *)ma_push_size((arena), sizeof(Type))
-#define ma_push_array(arena, Type, count) (Type *)ma_push_size((arena), sizeof(Type) * (count))
-
-void        ma_set_len(ma_arena_t *arena, usize pos);
-void        ma_pop(ma_arena_t *arena, usize size);
-void        ma_set0(ma_arena_t *arena);
-
-ma_temp_t   ma_begin_temp(ma_arena_t *arena);
-void        ma_end_temp(ma_temp_t temp);
-
-typedef struct s8_t s8_t;
-struct s8_t {
-    char *str;
-    int64_t len;
-};
-
-typedef struct s16_t s16_t;
-struct s16_t {
-    u16 *str;
-    i64 len;
-};
-
-typedef struct s32_t s32_t;
-struct s32_t {
-    u32 *str;
-    i64 len;
-};
-
-typedef struct sb8_node_t sb8_node_t;
-struct sb8_node_t {
-    sb8_node_t *next;
-    union {
-        struct { char *str; int64_t len; };
-        s8_t string;
-    };
-};
-
-typedef struct sb8_t sb8_t;
-struct sb8_t {
-    ma_arena_t *arena;
-    sb8_node_t *first;
-    sb8_node_t *last;
-
-    i32 indent;
-};
-
-i64 wstr_len(wchar_t *string);
-i32 str_len(char *str);
-
-char char_to_lower_case(char a);
-char char_to_upper_case(char a);
-b32 char_is_whitespace(char w);
-b32 char_is_alphabetic(char a);
-b32 char_is_ident(char a);
-b32 char_is_digit(char a);
-b32 char_is_alphanumeric(char a);
-
-b32 s8_equal(s8_t a, s8_t b);
-
-enum { s8_ignore_case = 1 };
-
-#define s8(str,len) (s8_t){str, len}
-#define s8_nil() (s8_t){0}
-#define s8_lit(string) (s8_t){(char *)string, sizeof(string) - 1}
-#define s8_const_lit(string) { string, sizeof(string) - 1 }
-#define s8_fmtspec(string) (int)(string).len, (string).str
-
-#define sb8_serial_begin(arena) &(sb8_t){.arena = arena}
-#define sb8_serial_end(sb) sb8_merge(sb)
-
-typedef struct core_desc_t core_desc_t;
-struct core_desc_t {
-    void (*print)(char *string);
-    void (*panic)(void);
-    void (*on_exit)(void);
-
-    ma_arena_t scratch[3];
-    b32 break_on_panic;
-};
-extern THREAD_LOCAL core_desc_t core_desc;
 void debugf(const char *string, ...);
 void panicf(const char *string, ...);
 
-
-typedef union v2f32_t v2f32_t;
-union v2f32_t {
-    struct { f32 x, y; };
-    f32 e[2];
-};
-
-typedef union v3f32_t v3f32_t;
-union v3f32_t {
-    struct { f32 x, y, z; };
-    struct { v2f32_t xy; };
-    struct { f32 _x0; v2f32_t zw; };
-    struct { f32 r, g, b; };
-    struct { f32 h, s, l; };
-    f32 e[3];
-};
-
-typedef union v4f32_t v4f32_t;
-union v4f32_t {
-    struct { f32 x, y, z, w; };
-    struct { v2f32_t xy; v2f32_t zw; };
-    struct { v3f32_t xyz; };
-    struct { f32 _x0; f32 yzw; };
-    struct { f32 r, g, b, a; };
-    struct { f32 h, s, l, _a; };
-    f32 e[4];
-};
-
-typedef union r1f32_t r1f32_t;
-union r1f32_t {
-    struct { f32 min, max; };
-    struct { f32 x0, x1; };
-    f32 e[2];
-};
-
-typedef union r2f32_t r2f32_t;
-union r2f32_t {
-    struct { v2f32_t min, max; };
-    struct { f32 x0, y0, x1, y1; };
-    v4f32_t e4;
-    f32 e[4];
-};
-
-typedef union r3f32_t r3f32_t;
-union r3f32_t {
-    struct { v3f32_t min, max; };
-    struct { f32 x0, y0, z0, x1, y1, z1; };
-    f32 e[6];
-};
-
-
-typedef union v2f64_t v2f64_t;
-union v2f64_t {
-    struct { f64 x, y; };
-    f64 e[2];
-};
-
-typedef union v3f64_t v3f64_t;
-union v3f64_t {
-    struct { f64 x, y, z; };
-    struct { v2f64_t xy; };
-    struct { f64 _x0; v2f64_t zw; };
-    struct { f64 r, g, b; };
-    struct { f64 h, s, l; };
-    f64 e[3];
-};
-
-typedef union v4f64_t v4f64_t;
-union v4f64_t {
-    struct { f64 x, y, z, w; };
-    struct { v2f64_t xy; v2f64_t zw; };
-    struct { v3f64_t xyz; };
-    struct { f64 _x0; f64 yzw; };
-    struct { f64 r, g, b, a; };
-    struct { f64 h, s, l, _a; };
-    f64 e[4];
-};
-
-typedef union r1f64_t r1f64_t;
-union r1f64_t {
-    struct { f64 min, max; };
-    struct { f64 x0, x1; };
-    f64 e[2];
-};
-
-typedef union r2f64_t r2f64_t;
-union r2f64_t {
-    struct { v2f64_t min, max; };
-    struct { f64 x0, y0, x1, y1; };
-    v4f64_t e4;
-    f64 e[4];
-};
-
-typedef union r3f64_t r3f64_t;
-union r3f64_t {
-    struct { v3f64_t min, max; };
-    struct { f64 x0, y0, z0, x1, y1, z1; };
-    f64 e[6];
-};
-
-
-typedef union v2i32_t v2i32_t;
-union v2i32_t {
-    struct { i32 x, y; };
-    i32 e[2];
-};
-
-typedef union v3i32_t v3i32_t;
-union v3i32_t {
-    struct { i32 x, y, z; };
-    struct { v2i32_t xy; };
-    struct { i32 _x0; v2i32_t zw; };
-    struct { i32 r, g, b; };
-    struct { i32 h, s, l; };
-    i32 e[3];
-};
-
-typedef union v4i32_t v4i32_t;
-union v4i32_t {
-    struct { i32 x, y, z, w; };
-    struct { v2i32_t xy; v2i32_t zw; };
-    struct { v3i32_t xyz; };
-    struct { i32 _x0; i32 yzw; };
-    struct { i32 r, g, b, a; };
-    struct { i32 h, s, l, _a; };
-    i32 e[4];
-};
-
-typedef union r1i32_t r1i32_t;
-union r1i32_t {
-    struct { i32 min, max; };
-    struct { i32 x0, x1; };
-    i32 e[2];
-};
-
-typedef union r2i32_t r2i32_t;
-union r2i32_t {
-    struct { v2i32_t min, max; };
-    struct { i32 x0, y0, x1, y1; };
-    v4i32_t e4;
-    i32 e[4];
-};
-
-typedef union r3i32_t r3i32_t;
-union r3i32_t {
-    struct { v3i32_t min, max; };
-    struct { i32 x0, y0, z0, x1, y1, z1; };
-    i32 e[6];
-};
-
-
-typedef union v2i64_t v2i64_t;
-union v2i64_t {
-    struct { i64 x, y; };
-    i64 e[2];
-};
-
-typedef union v3i64_t v3i64_t;
-union v3i64_t {
-    struct { i64 x, y, z; };
-    struct { v2i64_t xy; };
-    struct { i64 _x0; v2i64_t zw; };
-    struct { i64 r, g, b; };
-    struct { i64 h, s, l; };
-    i64 e[3];
-};
-
-typedef union v4i64_t v4i64_t;
-union v4i64_t {
-    struct { i64 x, y, z, w; };
-    struct { v2i64_t xy; v2i64_t zw; };
-    struct { v3i64_t xyz; };
-    struct { i64 _x0; i64 yzw; };
-    struct { i64 r, g, b, a; };
-    struct { i64 h, s, l, _a; };
-    i64 e[4];
-};
-
-typedef union r1i64_t r1i64_t;
-union r1i64_t {
-    struct { i64 min, max; };
-    struct { i64 x0, x1; };
-    i64 e[2];
-};
-
-typedef union r2i64_t r2i64_t;
-union r2i64_t {
-    struct { v2i64_t min, max; };
-    struct { i64 x0, y0, x1, y1; };
-    v4i64_t e4;
-    i64 e[4];
-};
-
-typedef union r3i64_t r3i64_t;
-union r3i64_t {
-    struct { v3i64_t min, max; };
-    struct { i64 x0, y0, z0, x1, y1, z1; };
-    i64 e[6];
-};

src/core/core_intrin.c

@@ -1,4 +1,4 @@
-void memory_copy(void *dst, void *src, usize n) {
+fn void memory_copy(void *dst, void *src, usize n) {
 #if PLATFORM_CLANG
     __builtin_memcpy(dst, src, n);
 #else
@@ -6,7 +6,7 @@ void memory_copy(void *dst, void *src, usize n) {
 #endif
 }
 
-void memory_move(void *dest, const void *src, usize n) {
+fn void memory_move(void *dest, const void *src, usize n) {
 #if PLATFORM_CLANG
     __builtin_memmove(dest, src, n);
 #else
@@ -14,14 +14,17 @@ void memory_move(void *dest, const void *src, usize n) {
 #endif
 }
 
-void memory_set(void *dst, i32 c, usize size) {
+fn void memory_set(void *dst, i32 c, usize size) {
 #if PLATFORM_CLANG
     __builtin_memset(dst, c, size);
 #else
     memset(dst, c, size);
 #endif
 }
-void memory_zero(void *dst, usize size) { memory_set(dst, 0, size); }
+
+fn void memory_zero(void *dst, usize size) {
+    memory_set(dst, 0, size);
+}
 
 
 #if PLATFORM_CLANG
@@ -38,34 +41,34 @@ f64 f64_round(f64 x) { return __builtin_round(x); }
 f64 f64_mod(f64 a, f64 b) { return __builtin_fmod(a, b); }
 f32 f32_mod(f32 a, f32 b) { return __builtin_fmodf(a, b); }
 #else
-f32 f32_sqrt(f32 x) { return sqrtf(x); }
+fn f32 f32_sqrt(f32 x) { return sqrtf(x); }
-f64 f64_sqrt(f64 x) { return sqrt(x); }
+fn f64 f64_sqrt(f64 x) { return sqrt(x); }
-f32 f32_ceil(f32 x) { return ceilf(x); }
+fn f32 f32_ceil(f32 x) { return ceilf(x); }
-f64 f64_ceil(f64 x) { return ceil(x); }
+fn f64 f64_ceil(f64 x) { return ceil(x); }
-f32 f32_floor(f32 x) { return floorf(x); }
+fn f32 f32_floor(f32 x) { return floorf(x); }
-f64 f64_floor(f64 x) { return floor(x); }
+fn f64 f64_floor(f64 x) { return floor(x); }
-f32 f32_abs(f32 x) { return fabsf(x); }
+fn f32 f32_abs(f32 x) { return fabsf(x); }
-f64 f64_abs(f64 x) { return fabs(x); }
+fn f64 f64_abs(f64 x) { return fabs(x); }
-f32 f32_round(f32 x) { return roundf(x); }
+fn f32 f32_round(f32 x) { return roundf(x); }
-f64 f64_round(f64 x) { return round(x); }
+fn f64 f64_round(f64 x) { return round(x); }
-f64 f64_mod(f64 a, f64 b) { return fmod(a, b); }
+fn f64 f64_mod(f64 a, f64 b) { return fmod(a, b); }
-f32 f32_mod(f32 a, f32 b) { return fmodf(a, b); }
+fn f32 f32_mod(f32 a, f32 b) { return fmodf(a, b); }
 #endif
 
 #if PLATFORM_WINDOWS
-void *vmem_reserve(usize size) {
+fn void *vmem_reserve(usize size) {
     void *result = (uint8_t *)VirtualAlloc(0, size, MEM_RESERVE, PAGE_READWRITE);
     return result;
 }
-b32 vmem_commit(void *p, usize size) {
+fn b32 vmem_commit(void *p, usize size) {
     void *result = VirtualAlloc(p, size, MEM_COMMIT, PAGE_READWRITE);
     return result ? true : false;
 }
-b32 vmem_release(void *p) {
+fn b32 vmem_release(void *p) {
     BOOL result = VirtualFree(p, 0, MEM_RELEASE);
     return result ? true : false;
 }
-b32 vmem_decommit(void *p, usize size) {
+fn b32 vmem_decommit(void *p, usize size) {
     BOOL result = VirtualFree(p, size, MEM_DECOMMIT);
     return result ? true : false;
 }
@@ -77,21 +80,32 @@ b32 vmem_decommit(void *p, usize size) { return true; }
 #endif
 
 #if PLATFORM_WASM
-f64 s8_deserial_f64(s8_t string);
+f64 f64_from_s8(s8_t string);
-void write_to_console(char *string);
+void write_to_console(s8_t string);
 #else
-f64 s8_deserial_f64(s8_t string) { return strtod(string.str, NULL); }
+fn f64 f64_from_s8(s8_t string) {
+    return strtod(string.str, NULL);
+}
 #endif
 
-void core_log_message(char *string) {
+fn void core_log_message(s8_t string) {
-    SWITCH_PLATFORM_WINDOWS_WASM_ELSE(
+#if PLATFORM_WINDOWS
-        if (IsDebuggerPresent()) OutputDebugStringA(string),
+    ma_temp_t scratch = ma_begin_scratch();
-        write_to_console(string),
+    s8_t copy = s8_copy(scratch.arena, string);
-        printf("%s", string); fflush(stdout)
+    OutputDebugStringA(copy.str);
-    );
+    ma_end_scratch(scratch);
+
+    printf("%.*s", (int)string.len, string.str);
+    fflush(stdout);
+#elif PLATFORM_WASM
+    write_to_console(string);
+#else
+    printf("%.*s", (int)string.len, string.str);
+    fflush(stdout);
+#endif
 }
 
-void core_panic(void) {
+fn void core_panic(void) {
     if (core_desc.on_exit) core_desc.on_exit();
     SWITCH_PLATFORM_WINDOWS_WASM_ELSE(
         ExitProcess(1),
@@ -100,13 +114,7 @@ void core_panic(void) {
     );
 }
 
-void core_on_exit(void) {
+fn void core_on_exit(void) {
     debugf("program panicked! exiting...");
 }
 
-THREAD_LOCAL core_desc_t core_desc = {
-    .print = core_log_message,
-    .panic = core_panic,
-    .break_on_panic = true,
-};
-

src/core/core_intrin.h

@@ -0,0 +1,46 @@
+typedef struct core_desc_t core_desc_t;
+struct core_desc_t {
+    void (*print)(s8_t string);
+    void (*panic)(void);
+    void (*on_exit)(void);
+
+    ma_arena_t scratch[3];
+    b32 break_on_panic;
+};
+
+fn void memory_copy(void *dst, void *src, usize n);
+fn void memory_move(void *dest, const void *src, usize n);
+fn void memory_set(void *dst, i32 c, usize size);
+fn void memory_zero(void *dst, usize size);
+
+fn void *vmem_reserve(usize size);
+fn b32   vmem_commit(void *p, usize size);
+fn b32   vmem_release(void *p);
+fn b32   vmem_decommit(void *p, usize size);
+
+fn f64 f64_from_s8(s8_t string);
+fn f32 f32_sqrt(f32 x);
+fn f64 f64_sqrt(f64 x);
+fn f32 f32_ceil(f32 x);
+fn f64 f64_ceil(f64 x);
+fn f32 f32_floor(f32 x);
+fn f64 f64_floor(f64 x);
+fn f32 f32_abs(f32 x);
+fn f64 f64_abs(f64 x);
+fn f32 f32_round(f32 x);
+fn f64 f64_round(f64 x);
+fn f64 f64_mod(f64 a, f64 b);
+fn f32 f32_mod(f32 a, f32 b);
+
+//
+// defaults
+fn void core_on_exit(void);
+fn void core_panic(void);
+fn void core_log_message(s8_t string);
+
+THREAD_LOCAL core_desc_t core_desc = {
+    .print = core_log_message,
+    .panic = core_panic,
+    .on_exit = core_on_exit,
+    .break_on_panic = true,
+};

src/core/core_lexer.c

@@ -1,134 +1,23 @@
-typedef enum lex_kind_t lex_kind_t;
+fn void lex_panicf(lex_t *token, const char *str, ...) {
-enum lex_kind_t {
-    #define LEX_KIND_XLIST\
-        X(eof, "end of file", "---")\
-        X(integer, "integer", "---")\
-        X(real, "real", "---")\
-        X(ident, "identifier", "---")\
-        X(string, "string", "---")\
-        X(comment, "comment", "---")\
-        X(open_brace, "'{' open brace", "{")\
-        X(close_brace, "'}' close brace", "}")\
-        X(open_paren, "'(' open parenthesis", "(")\
-        X(close_paren, "')' close parenthesis", ")")\
-        X(open_bracket, "'[' open bracket", "[")\
-        X(close_bracket, "']' close bracket", "]")\
-        X(plus, "'+' plus", "+")\
-        X(minus, "'-' minus", "-")\
-        X(divide, "'/' division sign", "/")\
-        X(multiply, "'*' multiplication sign", "*")\
-        X(modulo, "'%' modulo", "%")\
-        X(or, "'||' logical or", "||")\
-        X(and, "'&&' logical and", "&&")\
-        X(negation, "'!' logical negation", "!")\
-        X(bit_negation, "'~' bit negation", "~")\
-        X(bit_left_shift, "'<<' bit left shift", "<<")\
-        X(bit_right_shift, "'>>' bit right shift", ">>")\
-        X(bit_or, "'|' bit or", "|")\
-        X(bit_and, "'&' bit and", "&")\
-        X(bit_xor, "'^' bit xor", "^")\
-        X(decrement, "'--' decrement", "--")\
-        X(increment, "'++' increment", "++")\
-        X(post_decrement, "'--' post decrement", "--")\
-        X(post_increment, "'++' post increment", "++")\
-        X(assign, "'=' assignment", "=")\
-        X(divide_assign, "'/=' divide assignment", "/=")\
-        X(multiply_assign, "'*=' multiply assignment", "*=")\
-        X(plus_assign, "'+=' plus assignment", "+=")\
-        X(minus_assign, "'-=' minus assignment", "-=")\
-        X(modulo_assign, "'%=' modulo assignment", "%=")\
-        X(bit_and_assign, "&=", "&=")\
-        X(bit_or_assign, "'|=' bit or assignment", "|=")\
-        X(bit_xor_assign, "'^=' bit xor assignment", "^=")\
-        X(bit_left_shift_assign, "'<<=' bit left shift assignment", "<<=")\
-        X(bit_right_shift_assign, "'>>=' bit right shift assignment", ">>=")\
-        X(equals, "'==' equals sign", "==")\
-        X(not_equals, "'!=' not equals sign", "!=")\
-        X(lesser, "'<' lesser then", "<")\
-        X(greater, "'>' greater then", ">")\
-        X(lesser_or_equal, "'<=' lesser then or equal", "<=")\
-        X(greater_or_equal, "'>=' greater then or equal", ">=")\
-        X(comma, "',' comma", ",")\
-        X(dot, "'.' dot", ".")\
-        X(three_dots, "'...' three dots", "...")\
-        X(semicolon, "';' semicolon", ";")\
-        X(colon, "':' colon", ":")\
-        X(arrow, "'->' arrow", "->")\
-        X(question, "'?' question mark", "?")\
-
-
-    #define X(KIND, STR, SIMPLE) lex_kind_##KIND,
-    LEX_KIND_XLIST
-    #undef X
-
-    lex_kind_count,
-};
-
-typedef enum lex_suffix_t lex_suffix_t;
-enum lex_suffix_t {
-    #define LEX_SUFFIX_XLIST X(none) X(f) X(d) X(u) X(ul) X(ull) X(l) X(ll)
-    #define X(KIND) lex_suffix_##KIND,
-    LEX_SUFFIX_XLIST
-    #undef X
-
-    lex_suffix_count,
-};
-
-typedef struct lex_t lex_t;
-struct lex_t {
-    lex_kind_t kind;
-    lex_suffix_t suffix;
-
-    union {
-        struct {char *str; i64 len;};
-        s8_t string;
-    };
-
-    i32 line;
-    i32 column;
-    char *file_name;
-
-    union {
-        u64 integer;
-        f64 real;
-        char *error;
-    };
-};
-
-typedef struct lexer_t lexer_t;
-struct lexer_t {
-    char *at;
-    char *file_name;
-    i32 line;
-    i32 column;
-};
-
-typedef struct lex_array_t lex_array_t;
-struct lex_array_t {
-    lex_t *data;
-    i32 len;
-};
-
-void lex_panicf(lex_t *token, const char *str, ...) {
     ma_temp_t scratch = ma_begin_scratch();
     S8_FMT(scratch.arena, str, str8);
     panicf("%s(%d:%d): error: %S", token->file_name, token->line, token->column, str8);
     ma_end_scratch(scratch);
 }
 
-lexer_t lex_make(char *begin, char *file_name) {
+fn lexer_t lex_make(char *begin, char *file_name) {
     lexer_t result = {.at = begin, .file_name = file_name};
     return result;
 }
 
-void lex_advance(lexer_t *lex) {
+fn void lex_advance(lexer_t *lex) {
     if (lex->at[0] == 0) return;
     if (lex->at[0] == '\n') { lex->column = 0; lex->line += 1; }
     lex->column += 1;
     lex->at += 1;
 }
 
-b32 lex_match(lexer_t *lex, char c) {
+fn b32 lex_match(lexer_t *lex, char c) {
     if (lex->at[0] == c) {
         lex_advance(lex);
         return true;
@@ -136,54 +25,11 @@ b32 lex_match(lexer_t *lex, char c) {
     return false;
 }
 
-void lex_eat_whitespace(lexer_t *lex) {
+fn void lex_eat_whitespace(lexer_t *lex) {
     while (char_is_whitespace(lex->at[0])) lex_advance(lex);
 }
 
-u64 lex_map_char_to_int(char c) {
+fn void lex_eat_number(lexer_t *lex, lex_t *token) {
-    switch (c) {
-        case '0': return 0; break;
-        case '1': return 1; break;
-        case '2': return 2; break;
-        case '3': return 3; break;
-        case '4': return 4; break;
-        case '5': return 5; break;
-        case '6': return 6; break;
-        case '7': return 7; break;
-        case '8': return 8; break;
-        case '9': return 9; break;
-        case 'a':
-        case 'A': return 10; break;
-        case 'b':
-        case 'B': return 11; break;
-        case 'c':
-        case 'C': return 12; break;
-        case 'd':
-        case 'D': return 13; break;
-        case 'e':
-        case 'E': return 14; break;
-        case 'f':
-        case 'F': return 15; break;
-        default: return 255;
-    }
-}
-
-u64 lex_deserial_u64(char *string, i64 len, u64 base) {
-    assert(base >= 2 && base <= 16);
-    u64 acc = 0;
-    for (i64 i = 0; i < len; i++) {
-        u64 num = lex_map_char_to_int(string[i]);
-        if (num >= base) {
-            panicf("invalid number");
-            break;
-        }
-        acc *= base;
-        acc += num;
-    }
-    return acc;
-}
-
-void lex_eat_number(lexer_t *lex, lex_t *token) {
     token->kind = lex_kind_integer;
     for (;;) {
         if (char_is_digit(lex->at[0])) {
@@ -223,11 +69,11 @@ void lex_eat_number(lexer_t *lex, lex_t *token) {
     }
 }
 
-void lex_eat_until(lexer_t *lex, char c) {
+fn void lex_eat_until(lexer_t *lex, char c) {
     while (lex->at[0] != c && lex->at[0] != 0) lex_advance(lex);
 }
 
-void lex_eat_string(lexer_t *lex, lex_t *token) {
+fn void lex_eat_string(lexer_t *lex, lex_t *token) {
     token->kind = lex_kind_string;
     for (;;) {
         if (lex_match(lex, token->str[0])) {
@@ -254,7 +100,7 @@ case C1: {\
     }\
 } break
 
-void lex_token_ex(lexer_t *lex, lex_t *token) {
+fn void lex_token_ex(lexer_t *lex, lex_t *token) {
     lex_eat_whitespace(lex);
     *token = (lex_t){.str = lex->at, .file_name = lex->file_name, .line = lex->line, .column = lex->column};
     lex_advance(lex);
@@ -369,23 +215,23 @@ void lex_token_ex(lexer_t *lex, lex_t *token) {
     token->len = (i32)(lex->at - token->str);
 
     if (token->kind == lex_kind_integer) {
-        token->integer = lex_deserial_u64(token->str, token->len, 10);
+        token->integer = u64_from_s8(token->string, 10);
     } else if (token->kind == lex_kind_real) {
-        token->real = s8_deserial_f64(token->string);
+        token->real = f64_from_s8(token->string);
     } else if (token->kind == lex_kind_string) {
         token->str += 1;
         token->len -= 2;
     }
 }
 
-lex_t lex_token(lexer_t *lex) {
+fn lex_t lex_token(lexer_t *lex) {
     lex_t result = {0};
     lex_token_ex(lex, &result);
     return result;
 }
 
 // @todo: use s8_t  instead
-lex_array_t lex_tokens(ma_arena_t *arena, char *file_name, char *stream) {
+fn lex_array_t lex_tokens(ma_arena_t *arena, char *file_name, char *stream) {
     usize align = arena->align;
     arena->align = 0;
 
@@ -408,59 +254,35 @@ lex_array_t lex_tokens(ma_arena_t *arena, char *file_name, char *stream) {
     return token_array;
 }
 
-s8_t global_lex_kind_simple_strings[] = {
+glb s8_t global_lex_kind_simple_strings[] = {
 #define X(KIND, STR, SIMPLE) s8_const_lit(SIMPLE),
     LEX_KIND_XLIST
 #undef X
 };
 
-s8_t s8_serial_simple_lex_kind_t(lex_kind_t kind) {
+fn s8_t lex_kind_to_simple_s8(lex_kind_t kind) {
     assert(kind >= 0 && kind < lex_kind_count);
     return global_lex_kind_simple_strings[kind];
 }
 
-s8_t global_lex_kind_strings[] = {
+glb s8_t global_lex_kind_strings[] = {
 #define X(KIND, STR, SIMPLE) s8_const_lit(STR),
     LEX_KIND_XLIST
 #undef X
 };
 
-s8_t s8_serial_lex_kind_t(lex_kind_t kind) {
+fn s8_t lex_kind_to_s8(lex_kind_t kind) {
     assert(kind >= 0 && kind < lex_kind_count);
     return global_lex_kind_strings[kind];
 }
 
-type_member_t members__lex_kind_t[] = {
+fn lex_t *parser_next(parser_t *par) {
-#define X(KIND, STR, SIMPLE) {.name = s8_const_lit("lex_kind_" #KIND), .value = lex_kind_##KIND},
-    LEX_KIND_XLIST
-#undef X
-};
-DEFINE_ENUM(lex_kind_t);
-
-type_member_t members__lex_suffix_t[] = {
-#define X(KIND) {.name = s8_const_lit("lex_suffix_" #KIND), .value = lex_suffix_##KIND},
-    LEX_SUFFIX_XLIST
-#undef X
-};
-DEFINE_ENUM(lex_suffix_t);
-
-//
-//
-typedef struct parser_t parser_t;
-struct parser_t {
-    ma_arena_t *arena;
-    lex_t *at;
-};
-
-#define parser_make(ARENA, TOKEN) &(parser_t){.arena = ARENA, .at = TOKEN}
-
-lex_t *parser_next(parser_t *par) {
     lex_t *result = par->at;
     if (result->kind != lex_kind_eof) par->at += 1;
     return result;
 }
 
-lex_t *parser_match(parser_t *par, lex_kind_t kind) {
+fn lex_t *parser_match(parser_t *par, lex_kind_t kind) {
     if (par->at->kind == kind) {
         return parser_next(par);
     } else {
@@ -468,7 +290,7 @@ lex_t *parser_match(parser_t *par, lex_kind_t kind) {
     }
 }
 
-lex_t *parser_matchi(parser_t *par, s8_t str) {
+fn lex_t *parser_matchi(parser_t *par, s8_t str) {
     if (par->at->kind == lex_kind_ident && s8_equal(par->at->string, str)) {
         return parser_next(par);
     } else {
@@ -476,18 +298,19 @@ lex_t *parser_matchi(parser_t *par, s8_t str) {
     }
 }
 
-lex_t *parser_expect(parser_t *par, lex_kind_t kind) {
+fn lex_t *parser_expect(parser_t *par, lex_kind_t kind) {
     lex_t *token = parser_match(par, kind);
-    if (!token) lex_panicf(par->at, "expected token kind: %S, got instead: %S", s8_serial_lex_kind_t(kind), s8_serial_lex_kind_t(par->at->kind));
+    if (!token) lex_panicf(par->at, "expected token kind: %S, got instead: %S", lex_kind_to_s8(kind), lex_kind_to_s8(par->at->kind));
     return token;
 }
 
-void parser_eat_until(parser_t *par, lex_kind_t kind) {
+fn void parser_eat_until(parser_t *par, lex_kind_t kind) {
     while (par->at->kind != kind && par->at->kind != lex_kind_eof) {
         parser_next(par);
     }
 }
-void parser_eat_including(parser_t *par, lex_kind_t kind) {
+
+fn void parser_eat_including(parser_t *par, lex_kind_t kind) {
     parser_eat_until(par, kind);
     parser_next(par);
 }

src/core/core_lexer.h

@@ -0,0 +1,133 @@
+typedef enum lex_kind_t lex_kind_t;
+enum lex_kind_t {
+    #define LEX_KIND_XLIST\
+        X(eof, "end of file", "---")\
+        X(integer, "integer", "---")\
+        X(real, "real", "---")\
+        X(ident, "identifier", "---")\
+        X(string, "string", "---")\
+        X(comment, "comment", "---")\
+        X(open_brace, "'{' open brace", "{")\
+        X(close_brace, "'}' close brace", "}")\
+        X(open_paren, "'(' open parenthesis", "(")\
+        X(close_paren, "')' close parenthesis", ")")\
+        X(open_bracket, "'[' open bracket", "[")\
+        X(close_bracket, "']' close bracket", "]")\
+        X(plus, "'+' plus", "+")\
+        X(minus, "'-' minus", "-")\
+        X(divide, "'/' division sign", "/")\
+        X(multiply, "'*' multiplication sign", "*")\
+        X(modulo, "'%' modulo", "%")\
+        X(or, "'||' logical or", "||")\
+        X(and, "'&&' logical and", "&&")\
+        X(negation, "'!' logical negation", "!")\
+        X(bit_negation, "'~' bit negation", "~")\
+        X(bit_left_shift, "'<<' bit left shift", "<<")\
+        X(bit_right_shift, "'>>' bit right shift", ">>")\
+        X(bit_or, "'|' bit or", "|")\
+        X(bit_and, "'&' bit and", "&")\
+        X(bit_xor, "'^' bit xor", "^")\
+        X(decrement, "'--' decrement", "--")\
+        X(increment, "'++' increment", "++")\
+        X(post_decrement, "'--' post decrement", "--")\
+        X(post_increment, "'++' post increment", "++")\
+        X(assign, "'=' assignment", "=")\
+        X(divide_assign, "'/=' divide assignment", "/=")\
+        X(multiply_assign, "'*=' multiply assignment", "*=")\
+        X(plus_assign, "'+=' plus assignment", "+=")\
+        X(minus_assign, "'-=' minus assignment", "-=")\
+        X(modulo_assign, "'%=' modulo assignment", "%=")\
+        X(bit_and_assign, "&=", "&=")\
+        X(bit_or_assign, "'|=' bit or assignment", "|=")\
+        X(bit_xor_assign, "'^=' bit xor assignment", "^=")\
+        X(bit_left_shift_assign, "'<<=' bit left shift assignment", "<<=")\
+        X(bit_right_shift_assign, "'>>=' bit right shift assignment", ">>=")\
+        X(equals, "'==' equals sign", "==")\
+        X(not_equals, "'!=' not equals sign", "!=")\
+        X(lesser, "'<' lesser then", "<")\
+        X(greater, "'>' greater then", ">")\
+        X(lesser_or_equal, "'<=' lesser then or equal", "<=")\
+        X(greater_or_equal, "'>=' greater then or equal", ">=")\
+        X(comma, "',' comma", ",")\
+        X(dot, "'.' dot", ".")\
+        X(three_dots, "'...' three dots", "...")\
+        X(semicolon, "';' semicolon", ";")\
+        X(colon, "':' colon", ":")\
+        X(arrow, "'->' arrow", "->")\
+        X(question, "'?' question mark", "?")\
+
+
+    #define X(KIND, STR, SIMPLE) lex_kind_##KIND,
+    LEX_KIND_XLIST
+    #undef X
+
+    lex_kind_count,
+};
+
+typedef enum lex_suffix_t lex_suffix_t;
+enum lex_suffix_t {
+    #define LEX_SUFFIX_XLIST X(none) X(f) X(d) X(u) X(ul) X(ull) X(l) X(ll)
+    #define X(KIND) lex_suffix_##KIND,
+    LEX_SUFFIX_XLIST
+    #undef X
+
+    lex_suffix_count,
+};
+
+typedef struct lex_t lex_t;
+struct lex_t {
+    lex_kind_t kind;
+    lex_suffix_t suffix;
+
+    union {
+        struct {char *str; i64 len;};
+        s8_t string;
+    };
+
+    i32 line;
+    i32 column;
+    char *file_name;
+
+    union {
+        u64 integer;
+        f64 real;
+        char *error;
+    };
+};
+
+typedef struct lexer_t lexer_t;
+struct lexer_t {
+    char *at;
+    char *file_name;
+    i32 line;
+    i32 column;
+};
+
+typedef struct lex_array_t lex_array_t;
+struct lex_array_t {
+    lex_t *data;
+    i32 len;
+};
+
+// @todo: use s8
+fn void        lex_panicf(lex_t *token, const char *str, ...);
+fn lex_array_t lex_tokens(ma_arena_t *arena, char *file_name, char *stream);
+
+fn s8_t        lex_kind_to_simple_s8(lex_kind_t kind);
+fn s8_t        lex_kind_to_s8(lex_kind_t kind);
+
+typedef struct parser_t parser_t;
+struct parser_t {
+    ma_arena_t *arena;
+    lex_t *at;
+};
+
+#define parser_make(ARENA, TOKEN) &(parser_t){.arena = ARENA, .at = TOKEN}
+
+fn lex_t *parser_next(parser_t *par);
+fn lex_t *parser_match(parser_t *par, lex_kind_t kind);
+fn lex_t *parser_matchi(parser_t *par, s8_t str);
+fn lex_t *parser_expect(parser_t *par, lex_kind_t kind);
+fn void   parser_eat_until(parser_t *par, lex_kind_t kind);
+fn void   parser_eat_including(parser_t *par, lex_kind_t kind);
+

src/core/core_math.c

@@ -1,18 +1,3 @@
-#define F64_PI (3.1415926535897932384626433832795028841971693994)
-#define F64_DEG2RAD (F64_PI / 180.0); // @Usage: degree * DEG2RAD = radians;
-#define F64_RAD2DEG (180.0 / F64_PI);
-#define F32_PI ((f32)F64_PI)
-
-#define rgba_macro_const(r, g, b, a) { r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f }
-
-v4f32_t primary_color_global = rgba_macro_const(245, 238, 230, 255);
-v4f32_t secondary_color_global = rgba_macro_const(255, 248, 227, 255);
-v4f32_t accent1_color_global = rgba_macro_const(243, 215, 202, 255);
-v4f32_t accent2_color_global = rgba_macro_const(230, 164, 180, 255);
-
-v4f32_t white_color_global = rgba_macro_const(255, 255, 255, 255);
-v4f32_t black_color_global = rgba_macro_const(0, 0, 0, 255);
-
 /*
  * Converts an RGB color value to HSL. Conversion formula
  * adapted from http://en.wikipedia.org/wiki/HSL_color_space.

src/core/core_math.h

@@ -0,0 +1,213 @@
+
+typedef union v2f32_t v2f32_t;
+union v2f32_t {
+    struct { f32 x, y; };
+    f32 e[2];
+};
+
+typedef union v3f32_t v3f32_t;
+union v3f32_t {
+    struct { f32 x, y, z; };
+    struct { v2f32_t xy; };
+    struct { f32 _x0; v2f32_t zw; };
+    struct { f32 r, g, b; };
+    struct { f32 h, s, l; };
+    f32 e[3];
+};
+
+typedef union v4f32_t v4f32_t;
+union v4f32_t {
+    struct { f32 x, y, z, w; };
+    struct { v2f32_t xy; v2f32_t zw; };
+    struct { v3f32_t xyz; };
+    struct { f32 _x0; f32 yzw; };
+    struct { f32 r, g, b, a; };
+    struct { f32 h, s, l, _a; };
+    f32 e[4];
+};
+
+typedef union r1f32_t r1f32_t;
+union r1f32_t {
+    struct { f32 min, max; };
+    struct { f32 x0, x1; };
+    f32 e[2];
+};
+
+typedef union r2f32_t r2f32_t;
+union r2f32_t {
+    struct { v2f32_t min, max; };
+    struct { f32 x0, y0, x1, y1; };
+    v4f32_t e4;
+    f32 e[4];
+};
+
+typedef union r3f32_t r3f32_t;
+union r3f32_t {
+    struct { v3f32_t min, max; };
+    struct { f32 x0, y0, z0, x1, y1, z1; };
+    f32 e[6];
+};
+
+
+typedef union v2f64_t v2f64_t;
+union v2f64_t {
+    struct { f64 x, y; };
+    f64 e[2];
+};
+
+typedef union v3f64_t v3f64_t;
+union v3f64_t {
+    struct { f64 x, y, z; };
+    struct { v2f64_t xy; };
+    struct { f64 _x0; v2f64_t zw; };
+    struct { f64 r, g, b; };
+    struct { f64 h, s, l; };
+    f64 e[3];
+};
+
+typedef union v4f64_t v4f64_t;
+union v4f64_t {
+    struct { f64 x, y, z, w; };
+    struct { v2f64_t xy; v2f64_t zw; };
+    struct { v3f64_t xyz; };
+    struct { f64 _x0; f64 yzw; };
+    struct { f64 r, g, b, a; };
+    struct { f64 h, s, l, _a; };
+    f64 e[4];
+};
+
+typedef union r1f64_t r1f64_t;
+union r1f64_t {
+    struct { f64 min, max; };
+    struct { f64 x0, x1; };
+    f64 e[2];
+};
+
+typedef union r2f64_t r2f64_t;
+union r2f64_t {
+    struct { v2f64_t min, max; };
+    struct { f64 x0, y0, x1, y1; };
+    v4f64_t e4;
+    f64 e[4];
+};
+
+typedef union r3f64_t r3f64_t;
+union r3f64_t {
+    struct { v3f64_t min, max; };
+    struct { f64 x0, y0, z0, x1, y1, z1; };
+    f64 e[6];
+};
+
+
+typedef union v2i32_t v2i32_t;
+union v2i32_t {
+    struct { i32 x, y; };
+    i32 e[2];
+};
+
+typedef union v3i32_t v3i32_t;
+union v3i32_t {
+    struct { i32 x, y, z; };
+    struct { v2i32_t xy; };
+    struct { i32 _x0; v2i32_t zw; };
+    struct { i32 r, g, b; };
+    struct { i32 h, s, l; };
+    i32 e[3];
+};
+
+typedef union v4i32_t v4i32_t;
+union v4i32_t {
+    struct { i32 x, y, z, w; };
+    struct { v2i32_t xy; v2i32_t zw; };
+    struct { v3i32_t xyz; };
+    struct { i32 _x0; i32 yzw; };
+    struct { i32 r, g, b, a; };
+    struct { i32 h, s, l, _a; };
+    i32 e[4];
+};
+
+typedef union r1i32_t r1i32_t;
+union r1i32_t {
+    struct { i32 min, max; };
+    struct { i32 x0, x1; };
+    i32 e[2];
+};
+
+typedef union r2i32_t r2i32_t;
+union r2i32_t {
+    struct { v2i32_t min, max; };
+    struct { i32 x0, y0, x1, y1; };
+    v4i32_t e4;
+    i32 e[4];
+};
+
+typedef union r3i32_t r3i32_t;
+union r3i32_t {
+    struct { v3i32_t min, max; };
+    struct { i32 x0, y0, z0, x1, y1, z1; };
+    i32 e[6];
+};
+
+
+typedef union v2i64_t v2i64_t;
+union v2i64_t {
+    struct { i64 x, y; };
+    i64 e[2];
+};
+
+typedef union v3i64_t v3i64_t;
+union v3i64_t {
+    struct { i64 x, y, z; };
+    struct { v2i64_t xy; };
+    struct { i64 _x0; v2i64_t zw; };
+    struct { i64 r, g, b; };
+    struct { i64 h, s, l; };
+    i64 e[3];
+};
+
+typedef union v4i64_t v4i64_t;
+union v4i64_t {
+    struct { i64 x, y, z, w; };
+    struct { v2i64_t xy; v2i64_t zw; };
+    struct { v3i64_t xyz; };
+    struct { i64 _x0; i64 yzw; };
+    struct { i64 r, g, b, a; };
+    struct { i64 h, s, l, _a; };
+    i64 e[4];
+};
+
+typedef union r1i64_t r1i64_t;
+union r1i64_t {
+    struct { i64 min, max; };
+    struct { i64 x0, x1; };
+    i64 e[2];
+};
+
+typedef union r2i64_t r2i64_t;
+union r2i64_t {
+    struct { v2i64_t min, max; };
+    struct { i64 x0, y0, x1, y1; };
+    v4i64_t e4;
+    i64 e[4];
+};
+
+typedef union r3i64_t r3i64_t;
+union r3i64_t {
+    struct { v3i64_t min, max; };
+    struct { i64 x0, y0, z0, x1, y1, z1; };
+    i64 e[6];
+};
+
+#define F64_PI (3.1415926535897932384626433832795028841971693994)
+#define F64_DEG2RAD (F64_PI / 180.0); // @Usage: degree * DEG2RAD = radians;
+#define F64_RAD2DEG (180.0 / F64_PI);
+#define F32_PI ((f32)F64_PI)
+
+#define rgba_macro_const(r, g, b, a) { r / 255.0f, g / 255.0f, b / 255.0f, a / 255.0f }
+
+glb v4f32_t primary_color_global = rgba_macro_const(245, 238, 230, 255);
+glb v4f32_t secondary_color_global = rgba_macro_const(255, 248, 227, 255);
+glb v4f32_t accent1_color_global = rgba_macro_const(243, 215, 202, 255);
+glb v4f32_t accent2_color_global = rgba_macro_const(230, 164, 180, 255);
+glb v4f32_t white_color_global = rgba_macro_const(255, 255, 255, 255);
+glb v4f32_t black_color_global = rgba_macro_const(0, 0, 0, 255);

src/core/core_math_gen.py

@@ -33,7 +33,7 @@ rect_types = [
 struct_types = vec_types + rect_types
 
 
-# fd = open("mathx.gen.h", "w")
+# fd = open("core_math.gen.h", "w")
 # sys.stdout = fd
 
 # print("// auto generated using:", __file__)
@@ -143,7 +143,7 @@ struct_types = vec_types + rect_types
 #     print(s)
 
 
-fd = open("mathx.gen.c", "w")
+fd = open("core_math.gen.c", "w")
 sys.stdout = fd
 
 print("// auto generated using:", __file__)

src/core/core_string.c

@@ -1,20 +1,107 @@
 #define s8_vsnprintf stbsp_vsnprintf
 
-#define S8_FMT(ma, str, result)            \
+fn i32 str_len(char *str) {
-    va_list args1;                                \
+    i32 i = 0;
-    va_start(args1, str);                         \
+    while (str[i]) i += 1;
-    s8_t result = s8_vfmt(ma, str, args1); \
+    return i;
-    va_end(args1)
+}
 
+fn b32 str_eq(char *a, char *b) {
+    return s8_equal(s8_from_char(a), s8_from_char(b));
+}
 
-s8_t s8_range(char *begin, char *end) {
+fn char char_to_lower_case(char a) {
+    if (a >= 'A' && a <= 'Z') a += 32;
+    return a;
+}
+
+fn char char_to_upper_case(char a) {
+    if (a >= 'a' && a <= 'z') a -= 32;
+    return a;
+}
+
+fn b32 char_is_whitespace(char w) {
+    b32 result = w == '\n' || w == ' ' || w == '\t' || w == '\v' || w == '\r';
+    return result;
+}
+
+fn b32 char_is_alphabetic(char a) {
+    b32 result = (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z');
+    return result;
+}
+
+fn b32 char_is_ident(char a) {
+    b32 result = (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z') || a == '_';
+    return result;
+}
+
+fn b32 char_is_digit(char a) {
+    b32 result = a >= '0' && a <= '9';
+    return result;
+}
+
+fn b32 char_is_alphanumeric(char a) {
+    b32 result = char_is_digit(a) || char_is_alphabetic(a);
+    return result;
+}
+
+fn i64 wstr_len(wchar_t *string) {
+    i64 len = 0;
+    while (*string++ != 0)
+        len++;
+    return len;
+}
+
+fn s8_t s8_from_range(char *begin, char *end) {
     assert(end >= begin);
     intptr_t size = (intptr_t)end - (intptr_t)begin;
     s8_t result = {begin, size};
     return result;
 }
 
-b32 s8_equal_ex(s8_t a, s8_t b, b32 ignore_case) {
+fn s8_t s8_from_char(char *string) {
+    s8_t result;
+    result.str = (char *)string;
+    result.len = str_len(string);
+    return result;
+}
+
+fn s16_t s16_from_s8(ma_arena_t *ma, s8_t string) {
+    u16 *buffer = ma_push_array(ma, u16, string.len + 1);
+    i64 len = wstr_from_str(buffer, string.len + 1, string.str, string.len);
+    assert(len < string.len);
+    return (s16_t){buffer,len};
+}
+
+fn s8_t s8_from_s16(ma_arena_t *ma, s16_t string) {
+    i64 buffer_size = (string.len + 1) * 2;
+    char *buffer = ma_push_array(ma, char, buffer_size);
+    i64 len = str_from_wstr(buffer, buffer_size, string.str, string.len);
+    assert(len < buffer_size);
+    return (s8_t){buffer,len};
+}
+
+fn s8_t s8_copy(ma_arena_t *ma, s8_t string) {
+    char *copy = (char *)ma_push_size(ma, sizeof(char) * (string.len + 1));
+    if (copy) {
+        memory_copy(copy, string.str, string.len);
+        copy[string.len] = 0;
+        s8_t result = s8(copy, string.len);
+        return result;
+    }
+    return (s8_t){0};
+}
+
+s8_t s8_copy_char(ma_arena_t *ma, char *s) {
+    int64_t len = str_len(s);
+    char *copy = (char *)ma_push_size(ma, sizeof(char) * (len + 1));
+    memory_copy(copy, s, len);
+    copy[len] = 0;
+    s8_t result = s8(copy, len);
+    return result;
+}
+
+fn b32 s8_equal_ex(s8_t a, s8_t b, b32 ignore_case) {
     if (a.len != b.len) return false;
     for (int64_t i = 0; i < a.len; i++) {
         char A = a.str[i];
@@ -28,54 +115,57 @@ b32 s8_equal_ex(s8_t a, s8_t b, b32 ignore_case) {
     }
     return true;
 }
-b32 s8_equal(s8_t a, s8_t b)   {return s8_equal_ex(a, b, false);}
 
-s8_t s8_get_postfix(s8_t string, int64_t len) {
+fn b32 s8_equal(s8_t a, s8_t b) {
+    return s8_equal_ex(a, b, false);
+}
+
+fn s8_t s8_get_postfix(s8_t string, int64_t len) {
     len = CLAMP_TOP(len, string.len);
     int64_t remain_len = string.len - len;
     s8_t result = s8(string.str + remain_len, len);
     return result;
 }
 
-s8_t s8_get_prefix(s8_t string, int64_t len) {
+fn s8_t s8_get_prefix(s8_t string, int64_t len) {
     len = CLAMP_TOP(len, string.len);
     s8_t result = s8(string.str, len);
     return result;
 }
 
-s8_t s8_chop(s8_t string, int64_t len) {
+fn s8_t s8_chop(s8_t string, int64_t len) {
     len = CLAMP_TOP(len, string.len);
     s8_t result = s8(string.str, string.len - len);
     return result;
 }
 
-s8_t s8_skip(s8_t string, int64_t len) {
+fn s8_t s8_skip(s8_t string, int64_t len) {
     len = CLAMP_TOP(len, string.len);
     int64_t remain = string.len - len;
     s8_t result = s8(string.str + len, remain);
     return result;
 }
 
-b32 s8_ends_with(s8_t a, s8_t end, b32 ignore_case) {
+fn b32 s8_ends_with(s8_t a, s8_t end, b32 ignore_case) {
     s8_t a_end = s8_get_postfix(a, end.len);
     b32 result = s8_equal_ex(end, a_end, ignore_case);
     return result;
 }
 
-b32 s8_starts_with(s8_t a, s8_t start, b32 ignore_case) {
+fn b32 s8_starts_with(s8_t a, s8_t start, b32 ignore_case) {
     s8_t a_start = s8_get_prefix(a, start.len);
     b32 result = s8_equal_ex(start, a_start, ignore_case);
     return result;
 }
 
-void s8_normalize_path_unsafe(s8_t s) {
+fn void s8_normalize_path_unsafe(s8_t s) {
     for (int64_t i = 0; i < s.len; i++) {
         if (s.str[i] == '\\')
             s.str[i] = '/';
     }
 }
 
-b32 s8_is_pointer_inside(s8_t string, char *p) {
+fn b32 s8_is_pointer_inside(s8_t string, char *p) {
     uintptr_t pointer = (uintptr_t)p;
     uintptr_t start = (uintptr_t)string.str;
     uintptr_t stop = start + (uintptr_t)string.len;
@@ -83,6 +173,19 @@ b32 s8_is_pointer_inside(s8_t string, char *p) {
     return result;
 }
 
+fn s8_t s8_cut_start(s8_t *in, i64 size) {
+    s8_t result = s8_get_prefix(*in, size);
+    *in = s8_skip(*in, result.len);
+    return result;
+}
+
+fn s8_t s8_cut_end(s8_t *in, i64 size) {
+    s8_t result = s8_get_postfix(*in, size);
+    *in = s8_chop(*in, result.len);
+    return result;
+}
+
+#if 0
 s8_t s8_skip_to_p(s8_t string, char *p) {
     if (s8_is_pointer_inside(string, p)) {
         s8_t result = s8(p, p - string.str);
@@ -99,8 +202,9 @@ s8_t s8_skip_past(s8_t string, s8_t a) {
     }
     return string;
 }
+#endif
 
-s8_t s8_slice(s8_t string, int64_t first_index, int64_t one_past_last_index) {
+fn s8_t s8_slice(s8_t string, int64_t first_index, int64_t one_past_last_index) {
     if (one_past_last_index < 0) one_past_last_index = string.len + one_past_last_index + 1;
     if (first_index < 0) first_index = string.len + first_index;
     assert(first_index < one_past_last_index && "s8_slice, first_index is bigger then one_past_last_index");
@@ -120,7 +224,7 @@ s8_t s8_slice(s8_t string, int64_t first_index, int64_t one_past_last_index) {
     return result;
 }
 
-s8_t s8_trim(s8_t string) {
+fn s8_t s8_trim(s8_t string) {
     if (string.len == 0)
         return string;
 
@@ -148,7 +252,7 @@ s8_t s8_trim(s8_t string) {
     return string;
 }
 
-s8_t s8_trim_end(s8_t string) {
+fn s8_t s8_trim_end(s8_t string) {
     int64_t whitespace_end = string.len;
     for (; whitespace_end != 0; whitespace_end--) {
         if (!char_is_whitespace(string.str[whitespace_end - 1])) {
@@ -160,14 +264,7 @@ s8_t s8_trim_end(s8_t string) {
     return result;
 }
 
-typedef i32 s8_seek_t;
+fn b32 s8_seek(s8_t string, s8_t find, s8_seek_t flags, int64_t *index_out) {
-enum {
-    s8_seek_none            = 0,
-    s8_seek_ignore_case     = 1,
-    s8_seek_match_find_last = 2,
-};
-
-b32 s8_seek(s8_t string, s8_t find, s8_seek_t flags, int64_t *index_out) {
     b32 ignore_case = flags & s8_seek_ignore_case ? true : false;
     b32 result = false;
     if (flags & s8_seek_match_find_last) {
@@ -197,25 +294,25 @@ b32 s8_seek(s8_t string, s8_t find, s8_seek_t flags, int64_t *index_out) {
     return result;
 }
 
-int64_t s8_find(s8_t string, s8_t find, s8_seek_t flag) {
+fn int64_t s8_find(s8_t string, s8_t find, s8_seek_t flag) {
     int64_t result = -1;
     s8_seek(string, find, flag, &result);
     return result;
 }
 
-s8_t s8_chop_last_slash(s8_t s) {
+fn s8_t s8_chop_last_slash(s8_t s) {
     s8_t result = s;
     s8_seek(s, s8_lit("/"), s8_seek_match_find_last, &result.len);
     return result;
 }
 
-s8_t s8_chop_last_period(s8_t s) {
+fn s8_t s8_chop_last_period(s8_t s) {
     s8_t result = s;
     s8_seek(s, s8_lit("."), s8_seek_match_find_last, &result.len);
     return result;
 }
 
-s8_t s8_skip_to_last_slash(s8_t s) {
+fn s8_t s8_skip_to_last_slash(s8_t s) {
     int64_t pos;
     s8_t result = s;
     if (s8_seek(s, s8_lit("/"), s8_seek_match_find_last, &pos)) {
@@ -224,7 +321,7 @@ s8_t s8_skip_to_last_slash(s8_t s) {
     return result;
 }
 
-s8_t s8_skip_to_last_period(s8_t s) {
+fn s8_t s8_skip_to_last_period(s8_t s) {
     int64_t pos;
     s8_t result = s;
     if (s8_seek(s, s8_lit("."), s8_seek_match_find_last, &pos)) {
@@ -233,38 +330,11 @@ s8_t s8_skip_to_last_period(s8_t s) {
     return result;
 }
 
-s8_t s8_from_char(char *string) {
+fn s8_t s8_get_name_no_ext(s8_t s) {
-    s8_t result;
-    result.str = (char *)string;
-    result.len = str_len(string);
-    return result;
-}
-
-s8_t s8_get_name_no_ext(s8_t s) {
     return s8_skip_to_last_slash(s8_chop_last_period(s));
 }
 
-s8_t s8_copy(ma_arena_t *ma, s8_t string) {
+fn s8_t s8_normalize_path(ma_arena_t *ma, s8_t s) {
-    char *copy = (char *)ma_push_size(ma, sizeof(char) * (string.len + 1));
-    if (copy) {
-        memory_copy(copy, string.str, string.len);
-        copy[string.len] = 0;
-        s8_t result = s8(copy, string.len);
-        return result;
-    }
-    return (s8_t){0};
-}
-
-s8_t s8_copy_char(ma_arena_t *ma, char *s) {
-    int64_t len = str_len(s);
-    char *copy = (char *)ma_push_size(ma, sizeof(char) * (len + 1));
-    memory_copy(copy, s, len);
-    copy[len] = 0;
-    s8_t result = s8(copy, len);
-    return result;
-}
-
-s8_t s8_normalize_path(ma_arena_t *ma, s8_t s) {
     s8_t copy = s8_copy(ma, s);
     for (int64_t i = 0; i < copy.len; i++) {
         if (copy.str[i] == '\\')
@@ -273,7 +343,7 @@ s8_t s8_normalize_path(ma_arena_t *ma, s8_t s) {
     return copy;
 }
 
-s8_t s8_to_lower_case(ma_arena_t *ma, s8_t s) {
+fn s8_t s8_to_lower_case(ma_arena_t *ma, s8_t s) {
     s8_t copy = s8_copy(ma, s);
     for (int64_t i = 0; i < copy.len; i++) {
         copy.str[i] = char_to_lower_case(copy.str[i]);
@@ -281,7 +351,7 @@ s8_t s8_to_lower_case(ma_arena_t *ma, s8_t s) {
     return copy;
 }
 
-s8_t s8_to_upper_case(ma_arena_t *ma, s8_t s) {
+fn s8_t s8_to_upper_case(ma_arena_t *ma, s8_t s) {
     s8_t copy = s8_copy(ma, s);
     for (int64_t i = 0; i < copy.len; i++) {
         copy.str[i] = char_to_upper_case(copy.str[i]);
@@ -289,7 +359,7 @@ s8_t s8_to_upper_case(ma_arena_t *ma, s8_t s) {
     return copy;
 }
 
-s8_t s8_vfmt(ma_arena_t *ma, const char *str, va_list args1) {
+fn s8_t s8_vfmt(ma_arena_t *ma, const char *str, va_list args1) {
     va_list args2;
     va_copy(args2, args1);
     int64_t len = s8_vsnprintf(0, 0, str, args2);
@@ -301,44 +371,41 @@ s8_t s8_vfmt(ma_arena_t *ma, const char *str, va_list args1) {
     return res;
 }
 
-s8_t s8_fmt(ma_arena_t *ma, const char *str, ...) {
+fn s8_t s8_fmt(ma_arena_t *ma, const char *str, ...) {
     S8_FMT(ma, str, result);
     return result;
 }
 
-//
+fn sb8_node_t *sb8_create_node(ma_arena_t *ma, s8_t str) {
-// sb8_t
-//
-sb8_node_t *sb8_node(ma_arena_t *ma, s8_t str) {
     sb8_node_t *node = ma_push_type(ma, sb8_node_t);
     node->string = str;
     return node;
 }
 
-sb8_node_t *sb8_append(sb8_t *list, s8_t string) {
+fn sb8_node_t *sb8_append(sb8_t *list, s8_t string) {
-    sb8_node_t *node = sb8_node(list->arena, string);
+    sb8_node_t *node = sb8_create_node(list->arena, string);
     SLLQ_APPEND(list->first, list->last, node);
     return node;
 }
 
-s8_t sb8_printf(sb8_t *sb, const char *str, ...) {
+fn s8_t sb8_printf(sb8_t *sb, const char *str, ...) {
     S8_FMT(sb->arena, str, result);
     sb8_append(sb, result);
     return result;
 }
 
-void sb8_indent(sb8_t *sb) {
+fn void sb8_indent(sb8_t *sb) {
     sb8_printf(sb, "\n%.*s", sb->indent*4, "                                                                    ");
 }
 
-s8_t sb8_stmtf(sb8_t *sb, const char *str, ...) {
+fn s8_t sb8_stmtf(sb8_t *sb, const char *str, ...) {
     S8_FMT(sb->arena, str, result);
     sb8_indent(sb);
     sb8_append(sb, result);
     return result;
 }
 
-int64_t sb8_char_size(sb8_t *sb) {
+fn int64_t sb8_char_size(sb8_t *sb) {
     int64_t result = 0;
     for (sb8_node_t *it = sb->first; it; it = it->next) {
         result += it->len;
@@ -346,7 +413,7 @@ int64_t sb8_char_size(sb8_t *sb) {
     return result;
 }
 
-s8_t sb8_merge(sb8_t *sb) {
+fn s8_t sb8_merge(sb8_t *sb) {
     int64_t size = sb8_char_size(sb) + 1;
     char *str = ma_push_size(sb->arena, size);
     s8_t result = {str, 0};
@@ -358,14 +425,7 @@ s8_t sb8_merge(sb8_t *sb) {
     return result;
 }
 
-typedef i32 s8_split_t;
+fn sb8_t s8_split(ma_arena_t *ma, s8_t string, s8_t find, s8_split_t flags) {
-enum {
-    s8_split_none        = 0,
-    s8_split_ignore_case = 1,
-    s8_split_inclusive   = 2,
-};
-
-sb8_t s8_split(ma_arena_t *ma, s8_t string, s8_t find, s8_split_t flags) {
     sb8_t result = (sb8_t){ma};
     int64_t index = 0;
 
@@ -383,72 +443,45 @@ sb8_t s8_split(ma_arena_t *ma, s8_t string, s8_t find, s8_split_t flags) {
     return result;
 }
 
-s16_t s16_from_s8(ma_arena_t *ma, s8_t string) {
+fn u64 u64_from_hexchar(char c) {
-    u16 *buffer = ma_push_array(ma, u16, string.len + 1);
+    switch (c) {
-    i64 len = wstr_from_str(buffer, string.len + 1, string.str, string.len);
+        case '0': return 0; break;
-    assert(len < string.len);
+        case '1': return 1; break;
-    return (s16_t){buffer,len};
+        case '2': return 2; break;
+        case '3': return 3; break;
+        case '4': return 4; break;
+        case '5': return 5; break;
+        case '6': return 6; break;
+        case '7': return 7; break;
+        case '8': return 8; break;
+        case '9': return 9; break;
+        case 'a':
+        case 'A': return 10; break;
+        case 'b':
+        case 'B': return 11; break;
+        case 'c':
+        case 'C': return 12; break;
+        case 'd':
+        case 'D': return 13; break;
+        case 'e':
+        case 'E': return 14; break;
+        case 'f':
+        case 'F': return 15; break;
+        default: return 255;
+    }
 }
 
-s8_t s8_from_s16(ma_arena_t *ma, s16_t string) {
+fn u64 u64_from_s8(s8_t s, u64 base) {
-    i64 buffer_size = (string.len + 1) * 2;
+    assert(base >= 2 && base <= 16);
-    char *buffer = ma_push_array(ma, char, buffer_size);
+    u64 acc = 0;
-    i64 len = str_from_wstr(buffer, buffer_size, string.str, string.len);
+    for (i64 i = 0; i < s.len; i++) {
-    assert(len < buffer_size);
+        u64 num = u64_from_hexchar(s.str[i]);
-    return (s8_t){buffer,len};
+        if (num >= base) {
-}
+            panicf("invalid number");
-#if 0
+            break;
-
-s8_t S8_MergeWithSeparator(ma_arena_t *ma, S8_List list, s8_t separator) {
-    if (list.node_count == 0) return s8_makeEmpty();
-    if (list.char_count == 0) return s8_makeEmpty();
-
-    int64_t base_size = (list.char_count + 1);
-    int64_t sep_size = (list.node_count - 1) * separator.len;
-    int64_t size = base_size + sep_size;
-    char *buff = (char *)ma_push_size(ma, sizeof(char) * (size + 1));
-    s8_t string = s8(buff, 0);
-    for (S8_Node *it = list.first; it; it = it->next) {
-        assert(string.len + it->string.len <= size);
-        memory_copy(string.str + string.len, it->string.str, it->string.len);
-        string.len += it->string.len;
-        if (it != list.last) {
-            memory_copy(string.str + string.len, separator.str, separator.len);
-            string.len += separator.len;
         }
+        acc *= base;
+        acc += num;
     }
-    assert(string.len == size - 1);
+    return acc;
-    string.str[size] = 0;
-    return string;
 }
-
-s8_t S8_Merge(ma_arena_t *ma, S8_List list) {
-    return S8_MergeWithSeparator(ma, list, s8_lit(""));
-}
-
-s8_t S8_ReplaceAll(ma_arena_t *ma, s8_t string, s8_t replace, s8_t with, b32 ignore_case) {
-    s8_split_flag split_flag = ignore_case ? S8_SplitFlag_IgnoreCase : S8_SplitFlag_None;
-    S8_List list = S8_Split(ma, string, replace, split_flag | S8_SplitFlag_SplitInclusive);
-    for (S8_Node *it = list.first; it; it = it->next) {
-        if (s8_equal_ex(it->string, replace, ignore_case)) {
-            S8_ReplaceNodeString(&list, it, with);
-        }
-    }
-    s8_t result = S8_Merge(ma, list);
-    return result;
-}
-
-S8_List S8_FindAll(ma_arena_t *ma, s8_t string, s8_t find, b32 ignore_case) { // @untested
-    S8_List result = s8_makeEmptyList();
-    int64_t index = 0;
-
-    s8_seek find_flag = ignore_case ? s8_seek_ignore_case : 0;
-    while (s8_seek(string, find, find_flag, &index)) {
-        s8_t match = s8(string.str + index, find.len);
-        S8_AddNode(ma, &result, match);
-        string = s8_skip(string, index + find.len);
-    }
-    return result;
-}
-
-#endif

src/core/core_string.h

@@ -0,0 +1,147 @@
+typedef struct s8_t s8_t;
+struct s8_t {
+    char *str;
+    int64_t len;
+};
+
+typedef struct s16_t s16_t;
+struct s16_t {
+    u16 *str;
+    i64 len;
+};
+
+typedef struct s32_t s32_t;
+struct s32_t {
+    u32 *str;
+    i64 len;
+};
+
+typedef struct sb8_node_t sb8_node_t;
+struct sb8_node_t {
+    sb8_node_t *next;
+    union {
+        struct { char *str; int64_t len; };
+        s8_t string;
+    };
+};
+
+typedef struct sb8_t sb8_t;
+struct sb8_t {
+    ma_arena_t *arena;
+    sb8_node_t *first;
+    sb8_node_t *last;
+
+    i32 indent;
+};
+
+typedef i32 s8_seek_t;
+enum {
+    s8_seek_none            = 0,
+    s8_seek_ignore_case     = 1,
+    s8_seek_match_find_last = 2,
+};
+
+typedef i32 s8_split_t;
+enum {
+    s8_split_none        = 0,
+    s8_split_ignore_case = 1,
+    s8_split_inclusive   = 2,
+};
+
+enum { s8_ignore_case = 1 };
+
+//
+// char and char string operations
+fn i32  str_len(char *str);
+fn i64  wstr_len(wchar_t *string);
+fn b32  str_eq(char *a, char *b);
+fn char char_to_lower_case(char a);
+fn char char_to_upper_case(char a);
+fn b32  char_is_whitespace(char w);
+fn b32  char_is_alphabetic(char a);
+fn b32  char_is_ident(char a);
+fn b32  char_is_digit(char a);
+fn b32  char_is_alphanumeric(char a);
+
+//
+// string8 constructors
+#define s8(str,len) (s8_t){str, len}
+#define s8_nil() (s8_t){0}
+#define s8_lit(string) (s8_t){(char *)string, sizeof(string) - 1}
+#define s8_const_lit(string) { string, sizeof(string) - 1 }
+fn s8_t  s8_from_range(char *begin, char *end);
+fn s8_t  s8_from_char(char *string);
+fn s8_t  s8_copy(ma_arena_t *ma, s8_t string);
+fn s16_t s16_from_s8(ma_arena_t *ma, s8_t string);
+fn s8_t  s8_from_s16(ma_arena_t *ma, s16_t string);
+
+//
+// conditional
+fn b32 s8_equal_ex(s8_t a, s8_t b, b32 ignore_case);
+fn b32 s8_equal(s8_t a, s8_t b);
+fn b32 s8_ends_with(s8_t a, s8_t end, b32 ignore_case);
+fn b32 s8_starts_with(s8_t a, s8_t start, b32 ignore_case);
+fn b32 s8_is_pointer_inside(s8_t string, char *p);// @todo: maybe more general?
+
+//
+// search
+fn b32     s8_seek(s8_t string, s8_t find, s8_seek_t flags, int64_t *index_out);
+fn int64_t s8_find(s8_t string, s8_t find, s8_seek_t flag);
+fn sb8_t   s8_split(ma_arena_t *ma, s8_t string, s8_t find, s8_split_t flags);
+
+//
+// string view transforms
+fn s8_t s8_slice(s8_t string, int64_t first_index, int64_t one_past_last_index);
+fn s8_t s8_get_postfix(s8_t string, int64_t len);
+fn s8_t s8_get_prefix(s8_t string, int64_t len);
+fn s8_t s8_chop(s8_t string, int64_t len);
+fn s8_t s8_skip(s8_t string, int64_t len);
+fn s8_t s8_chop_last_slash(s8_t s);
+fn s8_t s8_chop_last_period(s8_t s);
+fn s8_t s8_skip_to_last_slash(s8_t s);
+fn s8_t s8_skip_to_last_period(s8_t s);
+fn s8_t s8_get_name_no_ext(s8_t s);
+fn s8_t s8_trim(s8_t string);
+fn s8_t s8_trim_end(s8_t string);
+fn s8_t s8_cut_start(s8_t *in, i64 size);
+fn s8_t s8_cut_end(s8_t *in, i64 size);
+//
+// formatting
+fn void s8_normalize_path_unsafe(s8_t s);
+fn s8_t s8_normalize_path(ma_arena_t *ma, s8_t s);
+fn s8_t s8_to_lower_case(ma_arena_t *ma, s8_t s);
+fn s8_t s8_to_upper_case(ma_arena_t *ma, s8_t s);
+fn s8_t s8_vfmt(ma_arena_t *ma, const char *str, va_list args1);
+fn s8_t s8_fmt(ma_arena_t *ma, const char *str, ...);
+
+//
+// string builder
+#define sb8_serial_begin(arena) &(sb8_t){.arena = arena}
+#define sb8_serial_end(sb) sb8_merge(sb)
+
+fn s8_t        sb8_printf(sb8_t *sb, const char *str, ...);
+fn sb8_node_t *sb8_append(sb8_t *list, s8_t string);
+fn sb8_node_t *sb8_create_node(ma_arena_t *ma, s8_t str);
+
+fn s8_t    sb8_merge(sb8_t *sb);
+fn void    sb8_indent(sb8_t *sb);
+fn s8_t    sb8_stmtf(sb8_t *sb, const char *str, ...);
+fn int64_t sb8_char_size(sb8_t *sb);
+
+//
+// other
+#define s8_fmtspec(string) (int)(string).len, (string).str
+fn u64 u64_from_hexchar(char c);
+fn u64 u64_from_s8(s8_t s, u64 base);
+
+#define S8_FMT(ma, str, result)            \
+    va_list args1;                         \
+    va_start(args1, str);                  \
+    s8_t result = s8_vfmt(ma, str, args1); \
+    va_end(args1)
+
+#define STR_FMT(buff, str)                                     \
+    va_list args1;                                             \
+    va_start(args1, str);                                      \
+    i32 len = stbsp_vsnprintf(buff, sizeof(buff), str, args1); \
+    va_end(args1)

src/core/core_type_info.c

@@ -1,4 +1,4 @@
-s8_t ti_enum_value_to_name(type_t *type, i64 value) {
+fn s8_t ti_enum_value_to_name(type_t *type, i64 value) {
     assert(type->kind == type_kind_enum);
     for (i32 i = 0; i < type->count; i += 1) {
         type_member_t *it = type->members + i;
@@ -9,7 +9,7 @@ s8_t ti_enum_value_to_name(type_t *type, i64 value) {
     return s8_lit("invalid");
 }
 
-i64 ti_enum_name_to_value(type_t *type, s8_t name) {
+fn i64 ti_enum_name_to_value(type_t *type, s8_t name) {
     assert(type->kind == type_kind_enum);
     for (i32 i = 0; i < type->count; i += 1) {
         type_member_t *it = type->members + i;
@@ -20,7 +20,7 @@ i64 ti_enum_name_to_value(type_t *type, s8_t name) {
     return -1;
 }
 
-type_member_t *ti_get_member(type_t *type, s8_t name) {
+fn type_member_t *ti_get_member(type_t *type, s8_t name) {
     for (i32 i = 0; i < type->count; i += 1) {
         type_member_t *it = type->members + i;
         if (s8_equal(it->name, name)) {
@@ -30,7 +30,7 @@ type_member_t *ti_get_member(type_t *type, s8_t name) {
     return NULL;
 }
 
-void sb8_serial_data(sb8_t *sb, void *p, type_t *type) {
+fn void ti__serial_data_ex(sb8_t *sb, void *p, type_t *type) {
     assert(type->kind != type_kind_invalid);
 
     switch(type->kind) {
@@ -165,7 +165,7 @@ void sb8_serial_data(sb8_t *sb, void *p, type_t *type) {
             u8 *mem_p = p8 + base->size * i;
 
             sb8_indent(sb);
-            sb8_serial_data(sb, mem_p, base);
+            ti__serial_data_ex(sb, mem_p, base);
             sb8_printf(sb, ",");
         }
         sb->indent -= 1;
@@ -183,7 +183,7 @@ void sb8_serial_data(sb8_t *sb, void *p, type_t *type) {
             u8 *mem_p = p8 + mem->offset;
             sb8_indent(sb);
             sb8_printf(sb, "%S: ", mem->name);
-            sb8_serial_data(sb, mem_p, mem->type);
+            ti__serial_data_ex(sb, mem_p, mem->type);
             sb8_printf(sb, ",");
         }
         sb->indent -= 1;
@@ -194,14 +194,14 @@ void sb8_serial_data(sb8_t *sb, void *p, type_t *type) {
     panicf("can't serialize: unhandled type");
 }
 
-s8_t s8_serial_data(ma_arena_t *arena, void *p, type_t *type) {
+fn s8_t ti__serial_data(ma_arena_t *arena, void *p, type_t *type) {
     sb8_t *sb = sb8_serial_begin(arena);
-    sb8_serial_data(sb, p, type);
+    ti__serial_data_ex(sb, p, type);
     s8_t string = sb8_serial_end(sb);
     return string;
 }
 
-i64 parser__match_i64(parser_t *par) {
+fn i64 ti__parser_match_i64(parser_t *par) {
     i64 minus = 1;
     if (parser_match(par, lex_kind_minus)) {
         minus = -1;
@@ -211,46 +211,46 @@ i64 parser__match_i64(parser_t *par) {
     return result;
 }
 
-void s8_deserial_data_ex(ma_arena_t *arena, parser_t *par, void *p, type_t *type)  {
+fn void ti__deserial_data_ex(ma_arena_t *arena, parser_t *par, void *p, type_t *type) {
     switch(type->kind) {
     case type_kind_i8: {
         i8 *n = (i8 *)p;
-        n[0] = (i8)parser__match_i64(par);
+        n[0] = (i8)ti__parser_match_i64(par);
         return;
     } break;
     case type_kind_i16: {
         i16 *n = (i16 *)p;
-        n[0] = (i16)parser__match_i64(par);
+        n[0] = (i16)ti__parser_match_i64(par);
         return;
     } break;
     case type_kind_i32: {
         i32 *n = (i32 *)p;
-        n[0] = (i32)parser__match_i64(par);
+        n[0] = (i32)ti__parser_match_i64(par);
         return;
     } break;
     case type_kind_i64: {
         i64 *n = (i64 *)p;
-        n[0] = (i64)parser__match_i64(par);
+        n[0] = (i64)ti__parser_match_i64(par);
         return;
     } break;
     case type_kind_b8: {
         b8 *n = (b8 *)p;
-        n[0] = (b8)parser__match_i64(par);
+        n[0] = (b8)ti__parser_match_i64(par);
         return;
     } break;
     case type_kind_b16: {
         b16 *n = (b16 *)p;
-        n[0] = (b16)parser__match_i64(par);
+        n[0] = (b16)ti__parser_match_i64(par);
         return;
     } break;
     case type_kind_b32: {
         b32 *n = (b32 *)p;
-        n[0] = (b32)parser__match_i64(par);
+        n[0] = (b32)ti__parser_match_i64(par);
         return;
     } break;
     case type_kind_b64: {
         b64 *n = (b64 *)p;
-        n[0] = (b64)parser__match_i64(par);
+        n[0] = (b64)ti__parser_match_i64(par);
         return;
     } break;
     case type_kind_u8: {
@@ -291,7 +291,7 @@ void s8_deserial_data_ex(ma_arena_t *arena, parser_t *par, void *p, type_t *type
     } break;
     case type_kind_isize: {
         isize *n = (isize *)p;
-        n[0] = (isize)parser__match_i64(par);
+        n[0] = (isize)ti__parser_match_i64(par);
         return;
     } break;
     case type_kind_usize: {
@@ -302,12 +302,12 @@ void s8_deserial_data_ex(ma_arena_t *arena, parser_t *par, void *p, type_t *type
     } break;
     case type_kind_int: {
         int *n = (int *)p;
-        n[0] = (int)parser__match_i64(par);
+        n[0] = (int)ti__parser_match_i64(par);
         return;
     } break;
     case type_kind_char: {
         char *n = (char *)p;
-        n[0] = (char)parser__match_i64(par);
+        n[0] = (char)ti__parser_match_i64(par);
         return;
     } break;
     }
@@ -351,7 +351,7 @@ void s8_deserial_data_ex(ma_arena_t *arena, parser_t *par, void *p, type_t *type
             type_member_t *mem = ti_get_member(type, ident->string);
             if (mem) {
                 u8 *mem_p = p8 + mem->offset;
-                s8_deserial_data_ex(arena, par, mem_p, mem->type);
+                ti__deserial_data_ex(arena, par, mem_p, mem->type);
             } else {
                 debugf("deserial - skipping field: %S", ident->string);
                 parser_eat_until(par, lex_kind_comma);
@@ -370,7 +370,7 @@ void s8_deserial_data_ex(ma_arena_t *arena, parser_t *par, void *p, type_t *type
             parser_expect(par, lex_kind_colon);
             assert(s8_equal(ident->string, mem->name));
 
-            s8_deserial_data_ex(arena, par, mem_p, mem->type);
+            ti__deserial_data_ex(arena, par, mem_p, mem->type);
             parser_expect(par, lex_kind_comma);
         }
         parser_expect(par, lex_kind_close_brace);
@@ -384,20 +384,19 @@ void s8_deserial_data_ex(ma_arena_t *arena, parser_t *par, void *p, type_t *type
             type_t *base = type->base;
             u8 *mem_p = p8 + base->size * i;
 
-            s8_deserial_data_ex(arena, par, mem_p, base);
+            ti__deserial_data_ex(arena, par, mem_p, base);
             parser_expect(par, lex_kind_comma);
         }
         parser_expect(par, lex_kind_close_brace);
     }
 }
 
-#define s8_deserial_data(ARENA, DATA, TYPE) (TYPE *)s8__deserial_data(ARENA, DATA, &type__##TYPE)
+fn void *ti__deserial_data(ma_arena_t *arena, s8_t data, type_t *type) {
-void *s8__deserial_data(ma_arena_t *arena, s8_t data, type_t *type) {
     void *p = ma_push_size(arena, type->size);
     ma_temp_t scratch = ma_begin_scratch();
     lex_array_t tokens = lex_tokens(scratch.arena, "data serializing", data.str);
     parser_t *par = parser_make(scratch.arena, tokens.data);
-    s8_deserial_data_ex(arena, par, p, type);
+    ti__deserial_data_ex(arena, par, p, type);
     ma_end_scratch(scratch);
     return p;
 }

src/core/core_type_info.h

@@ -48,56 +48,68 @@ struct type_member_t {
     u64 offset;
 };
 
+//
+// serialization to string
+#define ti_deserial_data(ARENA, DATA, TYPE) (TYPE *)ti__deserial_data(ARENA, DATA, type(TYPE))
+#define ti_serial_data(ARENA, DATA, TYPE) ti__serial_data(ARENA, DATA, type(TYPE))
+
+fn void *ti__deserial_data(ma_arena_t *arena, s8_t data, type_t *type);
+fn s8_t  ti__serial_data(ma_arena_t *arena, void *p, type_t *type);
+
+//
+// utilities
+fn s8_t           ti_enum_value_to_name(type_t *type, i64 value);
+fn i64            ti_enum_name_to_value(type_t *type, s8_t name);
+fn type_member_t *ti_get_member(type_t *type, s8_t name);
+
+//
+// core type info data
 #define type(X) &type__##X
 #define DEFINE_ENUM(x) type_t type__##x = {type_kind_enum, s8_const_lit(#x), sizeof(x), .members = members__##x, .count = lengthof(members__##x)}
 #define DEFINE_STRUCT(x) type_t type__##x = {type_kind_struct, s8_const_lit(#x), sizeof(x), .members = members__##x, .count = lengthof(members__##x)}
 #define POINTER(x) (type_t){type_kind_pointer, s8_const_lit(#x "*"), sizeof(void *), .base = &type__##x}
 
-s8_t ti_enum_value_to_name(type_t *type, i64 value);
+glb type_t type__i8    = {type_kind_i8, s8_const_lit("i8"), sizeof(i8)};
-i64 ti_enum_name_to_value(type_t *type, s8_t name);
+glb type_t type__i16   = {type_kind_i16, s8_const_lit("i16"), sizeof(i16)};
-type_member_t *ti_get_member(type_t *type, s8_t name);
+glb type_t type__i32   = {type_kind_i32, s8_const_lit("i32"), sizeof(i32)};
+glb type_t type__i64   = {type_kind_i64, s8_const_lit("i64"), sizeof(i64)};
+glb type_t type__u8    = {type_kind_u8, s8_const_lit("u8"), sizeof(u8)};
+glb type_t type__u16   = {type_kind_u16, s8_const_lit("u16"), sizeof(u16)};
+glb type_t type__u32   = {type_kind_u32, s8_const_lit("u32"), sizeof(u32)};
+glb type_t type__u64   = {type_kind_u64, s8_const_lit("u64"), sizeof(u64)};
+glb type_t type__b8    = {type_kind_b8, s8_const_lit("b8"), sizeof(b8)};
+glb type_t type__b16   = {type_kind_b16, s8_const_lit("b16"), sizeof(b16)};
+glb type_t type__b32   = {type_kind_b32, s8_const_lit("b32"), sizeof(b32)};
+glb type_t type__b64   = {type_kind_b64, s8_const_lit("b64"), sizeof(b64)};
+glb type_t type__f32   = {type_kind_f32, s8_const_lit("f32"), sizeof(f32)};
+glb type_t type__f64   = {type_kind_f64, s8_const_lit("f64"), sizeof(f64)};
+glb type_t type__isize = {type_kind_isize, s8_const_lit("isize"), sizeof(isize)};
+glb type_t type__usize = {type_kind_usize, s8_const_lit("usize"), sizeof(usize)};
+glb type_t type__int   = {type_kind_int, s8_const_lit("int"), sizeof(int)};
+glb type_t type__char  = {type_kind_char, s8_const_lit("char"), sizeof(char)};
 
-type_t type__i8    = {type_kind_i8, s8_const_lit("i8"), sizeof(i8)};
+glb type_t type__s8_t = { type_kind_struct, s8_const_lit("s8_t"), sizeof(s8_t), .count = 2,
-type_t type__i16   = {type_kind_i16, s8_const_lit("i16"), sizeof(i16)};
-type_t type__i32   = {type_kind_i32, s8_const_lit("i32"), sizeof(i32)};
-type_t type__i64   = {type_kind_i64, s8_const_lit("i64"), sizeof(i64)};
-type_t type__u8    = {type_kind_u8, s8_const_lit("u8"), sizeof(u8)};
-type_t type__u16   = {type_kind_u16, s8_const_lit("u16"), sizeof(u16)};
-type_t type__u32   = {type_kind_u32, s8_const_lit("u32"), sizeof(u32)};
-type_t type__u64   = {type_kind_u64, s8_const_lit("u64"), sizeof(u64)};
-type_t type__b8    = {type_kind_b8, s8_const_lit("b8"), sizeof(b8)};
-type_t type__b16   = {type_kind_b16, s8_const_lit("b16"), sizeof(b16)};
-type_t type__b32   = {type_kind_b32, s8_const_lit("b32"), sizeof(b32)};
-type_t type__b64   = {type_kind_b64, s8_const_lit("b64"), sizeof(b64)};
-type_t type__f32   = {type_kind_f32, s8_const_lit("f32"), sizeof(f32)};
-type_t type__f64   = {type_kind_f64, s8_const_lit("f64"), sizeof(f64)};
-type_t type__isize = {type_kind_isize, s8_const_lit("isize"), sizeof(isize)};
-type_t type__usize = {type_kind_usize, s8_const_lit("usize"), sizeof(usize)};
-type_t type__int   = {type_kind_int, s8_const_lit("int"), sizeof(int)};
-type_t type__char  = {type_kind_char, s8_const_lit("char"), sizeof(char)};
-
-type_t type__s8_t = { type_kind_struct, s8_const_lit("s8_t"), sizeof(s8_t), .count = 2,
     .members = (type_member_t[]){
         {s8_const_lit("str"), &POINTER(char), .offset = offsetof(s8_t, str)},
         {s8_const_lit("len"), &type__i64, .offset = offsetof(s8_t, len)},
     }
 };
 
-type_t type__s16_t = { type_kind_struct, s8_const_lit("s16_t"), sizeof(s16_t), .count = 2,
+glb type_t type__s16_t = { type_kind_struct, s8_const_lit("s16_t"), sizeof(s16_t), .count = 2,
     .members = (type_member_t[]){
         {s8_const_lit("str"), &POINTER(u16), .offset = offsetof(s16_t, str)},
         {s8_const_lit("len"), &type__i64, .offset = offsetof(s16_t, len)},
     }
 };
 
-type_t type__s32_t = { type_kind_struct, s8_const_lit("s32_t"), sizeof(s32_t), .count = 2,
+glb type_t type__s32_t = { type_kind_struct, s8_const_lit("s32_t"), sizeof(s32_t), .count = 2,
     .members = (type_member_t[]){
         {s8_const_lit("str"), &POINTER(u32), .offset = offsetof(s32_t, str)},
         {s8_const_lit("len"), &type__i64, .offset = offsetof(s32_t, len)},
     }
 };
 
-type_t type__ma_arena_t = { type_kind_struct, s8_const_lit("ma_arena_t"), sizeof(ma_arena_t), .count = 6,
+glb type_t type__ma_arena_t = { type_kind_struct, s8_const_lit("ma_arena_t"), sizeof(ma_arena_t), .count = 6,
     .members = (type_member_t[]){
         {s8_const_lit("data"), &POINTER(u8), .offset = offsetof(ma_arena_t, data)},
         {s8_const_lit("len"), &type__usize, .offset = offsetof(ma_arena_t, len)},
@@ -108,22 +120,21 @@ type_t type__ma_arena_t = { type_kind_struct, s8_const_lit("ma_arena_t"), sizeof
     }
 };
 
-type_t type__ma_temp_t = { type_kind_struct, s8_const_lit("ma_temp_t"), sizeof(ma_temp_t), .count = 2,
+glb type_t type__ma_temp_t = { type_kind_struct, s8_const_lit("ma_temp_t"), sizeof(ma_temp_t), .count = 2,
     .members = (type_member_t[]){
         {s8_const_lit("arena"), &POINTER(ma_arena_t), .offset = offsetof(ma_temp_t, arena)},
         {s8_const_lit("len"), &type__usize, .offset = offsetof(ma_temp_t, len)},
     }
 };
 
-
+glb type_t type__v2f32_t = { type_kind_struct, s8_const_lit("v2f32_t"), sizeof(v2f32_t), .count = 2,
-type_t type__v2f32_t = { type_kind_struct, s8_const_lit("v2f32_t"), sizeof(v2f32_t), .count = 2,
     .members = (type_member_t[]){
         {s8_const_lit("x"), &type__f32, .offset = offsetof(v2f32_t, x)},
         {s8_const_lit("y"), &type__f32, .offset = offsetof(v2f32_t, y)},
     }
 };
 
-type_t type__v3f32_t = { type_kind_struct, s8_const_lit("v3f32_t"), sizeof(v3f32_t), .count = 3,
+glb type_t type__v3f32_t = { type_kind_struct, s8_const_lit("v3f32_t"), sizeof(v3f32_t), .count = 3,
     .members = (type_member_t[]){
         {s8_const_lit("x"), &type__f32, .offset = offsetof(v3f32_t, x)},
         {s8_const_lit("y"), &type__f32, .offset = offsetof(v3f32_t, y)},
@@ -131,7 +142,7 @@ type_t type__v3f32_t = { type_kind_struct, s8_const_lit("v3f32_t"), sizeof(v3f32
     }
 };
 
-type_t type__v4f32_t = { type_kind_struct, s8_const_lit("v4f32_t"), sizeof(v4f32_t), .count = 4,
+glb type_t type__v4f32_t = { type_kind_struct, s8_const_lit("v4f32_t"), sizeof(v4f32_t), .count = 4,
     .members = (type_member_t[]){
         {s8_const_lit("x"), &type__f32, .offset = offsetof(v4f32_t, x)},
         {s8_const_lit("y"), &type__f32, .offset = offsetof(v4f32_t, y)},
@@ -140,7 +151,7 @@ type_t type__v4f32_t = { type_kind_struct, s8_const_lit("v4f32_t"), sizeof(v4f32
     }
 };
 
-type_t type__r3f32_t = { type_kind_struct, s8_const_lit("r3f32_t"), sizeof(r3f32_t), .count = 6,
+glb type_t type__r3f32_t = { type_kind_struct, s8_const_lit("r3f32_t"), sizeof(r3f32_t), .count = 6,
     .members = (type_member_t[]){
         {s8_const_lit("x0"), &type__f32, .offset = offsetof(r3f32_t, x0)},
         {s8_const_lit("y0"), &type__f32, .offset = offsetof(r3f32_t, y0)},
@@ -151,28 +162,28 @@ type_t type__r3f32_t = { type_kind_struct, s8_const_lit("r3f32_t"), sizeof(r3f32
     }
 };
 
-type_member_t members__r2f32_t[] = {
+glb type_member_t members__r2f32_t[] = {
     {s8_const_lit("x0"), &type__f32, .offset = offsetof(r2f32_t, x0)},
     {s8_const_lit("y0"), &type__f32, .offset = offsetof(r2f32_t, y0)},
     {s8_const_lit("x1"), &type__f32, .offset = offsetof(r2f32_t, x1)},
     {s8_const_lit("y1"), &type__f32, .offset = offsetof(r2f32_t, y1)},
 };
-DEFINE_STRUCT(r2f32_t);
+glb DEFINE_STRUCT(r2f32_t);
 
-type_member_t members__r1f32_t[] = {
+glb type_member_t members__r1f32_t[] = {
     {s8_const_lit("x0"), &type__f32, .offset = offsetof(r1f32_t, x0)},
     {s8_const_lit("x1"), &type__f32, .offset = offsetof(r1f32_t, x1)},
 };
-DEFINE_STRUCT(r1f32_t);
+glb DEFINE_STRUCT(r1f32_t);
 
-type_t type__v2f64_t = { type_kind_struct, s8_const_lit("v2f64_t"), sizeof(v2f64_t), .count = 2,
+glb type_t type__v2f64_t = { type_kind_struct, s8_const_lit("v2f64_t"), sizeof(v2f64_t), .count = 2,
     .members = (type_member_t[]){
         {s8_const_lit("x"), &type__f64, .offset = offsetof(v2f64_t, x)},
         {s8_const_lit("y"), &type__f64, .offset = offsetof(v2f64_t, y)},
     }
 };
 
-type_t type__v3f64_t = { type_kind_struct, s8_const_lit("v3f64_t"), sizeof(v3f64_t), .count = 3,
+glb type_t type__v3f64_t = { type_kind_struct, s8_const_lit("v3f64_t"), sizeof(v3f64_t), .count = 3,
     .members = (type_member_t[]){
         {s8_const_lit("x"), &type__f64, .offset = offsetof(v3f64_t, x)},
         {s8_const_lit("y"), &type__f64, .offset = offsetof(v3f64_t, y)},
@@ -180,7 +191,7 @@ type_t type__v3f64_t = { type_kind_struct, s8_const_lit("v3f64_t"), sizeof(v3f64
     }
 };
 
-type_t type__v4f64_t = { type_kind_struct, s8_const_lit("v4f64_t"), sizeof(v4f64_t), .count = 4,
+glb type_t type__v4f64_t = { type_kind_struct, s8_const_lit("v4f64_t"), sizeof(v4f64_t), .count = 4,
     .members = (type_member_t[]){
         {s8_const_lit("x"), &type__f64, .offset = offsetof(v4f64_t, x)},
         {s8_const_lit("y"), &type__f64, .offset = offsetof(v4f64_t, y)},
@@ -189,7 +200,7 @@ type_t type__v4f64_t = { type_kind_struct, s8_const_lit("v4f64_t"), sizeof(v4f64
     }
 };
 
-type_t type__r3f64_t = { type_kind_struct, s8_const_lit("r3f64_t"), sizeof(r3f64_t), .count = 6,
+glb type_t type__r3f64_t = { type_kind_struct, s8_const_lit("r3f64_t"), sizeof(r3f64_t), .count = 6,
     .members = (type_member_t[]){
         {s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, x0)},
         {s8_const_lit("y0"), &type__f64, .offset = offsetof(r3f64_t, y0)},
@@ -200,28 +211,28 @@ type_t type__r3f64_t = { type_kind_struct, s8_const_lit("r3f64_t"), sizeof(r3f64
     }
 };
 
-type_member_t members__r2f64_t[] = {
+glb type_member_t members__r2f64_t[] = {
     {s8_const_lit("x0"), &type__f64, .offset = offsetof(r2f64_t, x0)},
     {s8_const_lit("y0"), &type__f64, .offset = offsetof(r2f64_t, y0)},
     {s8_const_lit("x1"), &type__f64, .offset = offsetof(r2f64_t, x1)},
     {s8_const_lit("y1"), &type__f64, .offset = offsetof(r2f64_t, y1)},
 };
-DEFINE_STRUCT(r2f64_t);
+glb DEFINE_STRUCT(r2f64_t);
 
-type_member_t members__r1f64_t[] = {
+glb type_member_t members__r1f64_t[] = {
     {s8_const_lit("x0"), &type__f64, .offset = offsetof(r1f64_t, x0)},
     {s8_const_lit("x1"), &type__f64, .offset = offsetof(r1f64_t, x1)},
 };
-DEFINE_STRUCT(r1f64_t);
+glb DEFINE_STRUCT(r1f64_t);
 
-type_t type__v2i32_t = { type_kind_struct, s8_const_lit("v2i32_t"), sizeof(v2i32_t), .count = 2,
+glb type_t type__v2i32_t = { type_kind_struct, s8_const_lit("v2i32_t"), sizeof(v2i32_t), .count = 2,
     .members = (type_member_t[]){
         {s8_const_lit("x"), &type__i32, .offset = offsetof(v2i32_t, x)},
         {s8_const_lit("y"), &type__i32, .offset = offsetof(v2i32_t, y)},
     }
 };
 
-type_t type__v3i32_t = { type_kind_struct, s8_const_lit("v3i32_t"), sizeof(v3i32_t), .count = 3,
+glb type_t type__v3i32_t = { type_kind_struct, s8_const_lit("v3i32_t"), sizeof(v3i32_t), .count = 3,
     .members = (type_member_t[]){
         {s8_const_lit("x"), &type__i32, .offset = offsetof(v3i32_t, x)},
         {s8_const_lit("y"), &type__i32, .offset = offsetof(v3i32_t, y)},
@@ -229,7 +240,7 @@ type_t type__v3i32_t = { type_kind_struct, s8_const_lit("v3i32_t"), sizeof(v3i32
     }
 };
 
-type_t type__v4i32_t = { type_kind_struct, s8_const_lit("v4i32_t"), sizeof(v4i32_t), .count = 4,
+glb type_t type__v4i32_t = { type_kind_struct, s8_const_lit("v4i32_t"), sizeof(v4i32_t), .count = 4,
     .members = (type_member_t[]){
         {s8_const_lit("x"), &type__i32, .offset = offsetof(v4i32_t, x)},
         {s8_const_lit("y"), &type__i32, .offset = offsetof(v4i32_t, y)},
@@ -238,7 +249,7 @@ type_t type__v4i32_t = { type_kind_struct, s8_const_lit("v4i32_t"), sizeof(v4i32
     }
 };
 
-type_t type__r3i32_t = { type_kind_struct, s8_const_lit("r3i32_t"), sizeof(r3i32_t), .count = 6,
+glb type_t type__r3i32_t = { type_kind_struct, s8_const_lit("r3i32_t"), sizeof(r3i32_t), .count = 6,
     .members = (type_member_t[]){
         {s8_const_lit("x0"), &type__i32, .offset = offsetof(r3i32_t, x0)},
         {s8_const_lit("y0"), &type__i32, .offset = offsetof(r3i32_t, y0)},
@@ -249,29 +260,29 @@ type_t type__r3i32_t = { type_kind_struct, s8_const_lit("r3i32_t"), sizeof(r3i32
     }
 };
 
-type_member_t members__r2i32_t[] = {
+glb type_member_t members__r2i32_t[] = {
     {s8_const_lit("x0"), &type__i32, .offset = offsetof(r2i32_t, x0)},
     {s8_const_lit("y0"), &type__i32, .offset = offsetof(r2i32_t, y0)},
     {s8_const_lit("x1"), &type__i32, .offset = offsetof(r2i32_t, x1)},
     {s8_const_lit("y1"), &type__i32, .offset = offsetof(r2i32_t, y1)},
 };
-DEFINE_STRUCT(r2i32_t);
+glb DEFINE_STRUCT(r2i32_t);
 
-type_member_t members__r1i32_t[] = {
+glb type_member_t members__r1i32_t[] = {
     {s8_const_lit("x0"), &type__i32, .offset = offsetof(r1i32_t, x0)},
     {s8_const_lit("x1"), &type__i32, .offset = offsetof(r1i32_t, x1)},
 };
-DEFINE_STRUCT(r1i32_t);
+glb DEFINE_STRUCT(r1i32_t);
 
 
-type_t type__v2i64_t = { type_kind_struct, s8_const_lit("v2i64_t"), sizeof(v2i64_t), .count = 2,
+glb type_t type__v2i64_t = { type_kind_struct, s8_const_lit("v2i64_t"), sizeof(v2i64_t), .count = 2,
     .members = (type_member_t[]){
         {s8_const_lit("x"), &type__i64, .offset = offsetof(v2i64_t, x)},
         {s8_const_lit("y"), &type__i64, .offset = offsetof(v2i64_t, y)},
     }
 };
 
-type_t type__v3i64_t = { type_kind_struct, s8_const_lit("v3i64_t"), sizeof(v3i64_t), .count = 3,
+glb type_t type__v3i64_t = { type_kind_struct, s8_const_lit("v3i64_t"), sizeof(v3i64_t), .count = 3,
     .members = (type_member_t[]){
         {s8_const_lit("x"), &type__i64, .offset = offsetof(v3i64_t, x)},
         {s8_const_lit("y"), &type__i64, .offset = offsetof(v3i64_t, y)},
@@ -279,7 +290,7 @@ type_t type__v3i64_t = { type_kind_struct, s8_const_lit("v3i64_t"), sizeof(v3i64
     }
 };
 
-type_t type__v4i64_t = { type_kind_struct, s8_const_lit("v4i64_t"), sizeof(v4i64_t), .count = 4,
+glb type_t type__v4i64_t = { type_kind_struct, s8_const_lit("v4i64_t"), sizeof(v4i64_t), .count = 4,
     .members = (type_member_t[]){
         {s8_const_lit("x"), &type__i64, .offset = offsetof(v4i64_t, x)},
         {s8_const_lit("y"), &type__i64, .offset = offsetof(v4i64_t, y)},
@@ -288,7 +299,7 @@ type_t type__v4i64_t = { type_kind_struct, s8_const_lit("v4i64_t"), sizeof(v4i64
     }
 };
 
-type_t type__r3i64_t = { type_kind_struct, s8_const_lit("r3i64_t"), sizeof(r3i64_t), .count = 6,
+glb type_t type__r3i64_t = { type_kind_struct, s8_const_lit("r3i64_t"), sizeof(r3i64_t), .count = 6,
     .members = (type_member_t[]){
         {s8_const_lit("x0"), &type__i64, .offset = offsetof(r3i64_t, x0)},
         {s8_const_lit("y0"), &type__i64, .offset = offsetof(r3i64_t, y0)},
@@ -299,16 +310,30 @@ type_t type__r3i64_t = { type_kind_struct, s8_const_lit("r3i64_t"), sizeof(r3i64
     }
 };
 
-type_member_t members__r2i64_t[] = {
+glb type_member_t members__r2i64_t[] = {
     {s8_const_lit("x0"), &type__i64, .offset = offsetof(r2i64_t, x0)},
     {s8_const_lit("y0"), &type__i64, .offset = offsetof(r2i64_t, y0)},
     {s8_const_lit("x1"), &type__i64, .offset = offsetof(r2i64_t, x1)},
     {s8_const_lit("y1"), &type__i64, .offset = offsetof(r2i64_t, y1)},
 };
-DEFINE_STRUCT(r2i64_t);
+glb DEFINE_STRUCT(r2i64_t);
 
-type_member_t members__r1i64_t[] = {
+glb type_member_t members__r1i64_t[] = {
     {s8_const_lit("x0"), &type__i64, .offset = offsetof(r1i64_t, x0)},
     {s8_const_lit("x1"), &type__i64, .offset = offsetof(r1i64_t, x1)},
 };
-DEFINE_STRUCT(r1i64_t);
+glb DEFINE_STRUCT(r1i64_t);
+
+glb type_member_t members__lex_kind_t[] = {
+#define X(KIND, STR, SIMPLE) {.name = s8_const_lit("lex_kind_" #KIND), .value = lex_kind_##KIND},
+    LEX_KIND_XLIST
+#undef X
+};
+DEFINE_ENUM(lex_kind_t);
+
+glb type_member_t members__lex_suffix_t[] = {
+#define X(KIND) {.name = s8_const_lit("lex_suffix_" #KIND), .value = lex_suffix_##KIND},
+    LEX_SUFFIX_XLIST
+#undef X
+};
+DEFINE_ENUM(lex_suffix_t);

src/core/core_unicode.c

@@ -1,34 +1,4 @@
-typedef struct utf32_result_t utf32_result_t;
+fn utf32_result_t utf16_to_utf32(uint16_t *c, int max_advance) {
-struct utf32_result_t {
-    uint32_t out_str;
-    int      advance;
-    int      error;
-};
-
-typedef struct utf16_result_t utf16_result_t;
-struct utf16_result_t {
-    uint16_t out_str[2];
-    int      len;
-    int      error;
-};
-
-typedef struct utf8_result_t utf8_result_t;
-struct utf8_result_t {
-    uint8_t out_str[4];
-    int     len;
-    int     error;
-};
-
-typedef struct utf8_iter_t utf8_iter_t;
-struct utf8_iter_t {
-    char    *str;
-    int      len;
-    int      utf8_codepoint_byte_size;
-    int      i;
-    uint32_t item;
-};
-
-utf32_result_t utf16_to_utf32(uint16_t *c, int max_advance) {
     utf32_result_t result = {0};
     if (max_advance >= 1) {
         result.advance = 1;
@@ -49,7 +19,7 @@ utf32_result_t utf16_to_utf32(uint16_t *c, int max_advance) {
     return result;
 }
 
-utf8_result_t utf32_to_utf8(uint32_t codepoint) {
+fn utf8_result_t utf32_to_utf8(uint32_t codepoint) {
     utf8_result_t result = {0};
 
     if (codepoint <= 0x7F) {
@@ -81,7 +51,7 @@ utf8_result_t utf32_to_utf8(uint32_t codepoint) {
     return result;
 }
 
-utf32_result_t utf8_to_utf32(char *c, int max_advance) {
+fn utf32_result_t utf8_to_utf32(char *c, int max_advance) {
     utf32_result_t result = {0};
 
     if ((c[0] & 0x80) == 0) { // Check if leftmost zero of first byte is unset
@@ -129,7 +99,7 @@ utf32_result_t utf8_to_utf32(char *c, int max_advance) {
     return result;
 }
 
-utf16_result_t utf32_to_utf16(uint32_t codepoint) {
+fn utf16_result_t utf32_to_utf16(uint32_t codepoint) {
     utf16_result_t result = {0};
     if (codepoint < 0x10000) {
         result.out_str[0] = (uint16_t)codepoint;
@@ -155,7 +125,7 @@ utf16_result_t utf32_to_utf16(uint32_t codepoint) {
         break;                                                            \
     }
 
-int64_t str_from_wstr(char *buffer, int64_t buffer_size, uint16_t *in, int64_t inlen) {
+fn int64_t str_from_wstr(char *buffer, int64_t buffer_size, uint16_t *in, int64_t inlen) {
     int64_t outlen = 0;
     for (int64_t i = 0; i < inlen && in[i];) {
         utf32_result_t decode = utf16_to_utf32((uint16_t *)(in + i), (int)(inlen - i));
@@ -178,7 +148,7 @@ int64_t str_from_wstr(char *buffer, int64_t buffer_size, uint16_t *in, int64_t i
     return outlen;
 }
 
-int64_t wstr_from_str(uint16_t *buffer, int64_t buffer_size, char *in, int64_t inlen) {
+fn int64_t wstr_from_str(uint16_t *buffer, int64_t buffer_size, char *in, int64_t inlen) {
     int64_t outlen = 0;
     for (int64_t i = 0; i < inlen;) {
         utf32_result_t decode = utf8_to_utf32(in + i, (int)(inlen - i));
@@ -201,7 +171,7 @@ int64_t wstr_from_str(uint16_t *buffer, int64_t buffer_size, char *in, int64_t i
     return outlen;
 }
 
-void utf8_advance(utf8_iter_t *iter) {
+fn void utf8_advance(utf8_iter_t *iter) {
     iter->i += iter->utf8_codepoint_byte_size;
     utf32_result_t r = utf8_to_utf32(iter->str + iter->i, iter->len - iter->i);
     if (r.error) {
@@ -213,13 +183,13 @@ void utf8_advance(utf8_iter_t *iter) {
     iter->item = r.out_str;
 }
 
-utf8_iter_t utf8_iterate_ex(char *str, int len) {
+fn utf8_iter_t utf8_iterate_ex(char *str, int len) {
     utf8_iter_t result = {str, len};
     if (len) utf8_advance(&result);
     return result;
 }
 
-utf8_iter_t utf8_iterate(char *str) {
+fn utf8_iter_t utf8_iterate(char *str) {
     int length = 0;
     while (str[length]) length += 1;
     return utf8_iterate_ex(str, length);

src/core/core_unicode.h

@@ -0,0 +1,53 @@
+typedef struct utf32_result_t utf32_result_t;
+struct utf32_result_t {
+    uint32_t out_str;
+    int      advance;
+    int      error;
+};
+
+typedef struct utf16_result_t utf16_result_t;
+struct utf16_result_t {
+    uint16_t out_str[2];
+    int      len;
+    int      error;
+};
+
+typedef struct utf8_result_t utf8_result_t;
+struct utf8_result_t {
+    uint8_t out_str[4];
+    int     len;
+    int     error;
+};
+
+typedef struct utf8_iter_t utf8_iter_t;
+struct utf8_iter_t {
+    char    *str;
+    int      len;
+    int      utf8_codepoint_byte_size;
+    int      i;
+    uint32_t item;
+};
+
+//
+// codepoint conversions
+fn utf32_result_t utf16_to_utf32(uint16_t *c, int max_advance);
+fn utf8_result_t utf32_to_utf8(uint32_t codepoint);
+fn utf32_result_t utf8_to_utf32(char *c, int max_advance);
+fn utf16_result_t utf32_to_utf16(uint32_t codepoint);
+
+//
+// widestring / string conversions
+fn int64_t str_from_wstr(char *buffer, int64_t buffer_size, uint16_t *in, int64_t inlen);
+fn int64_t wstr_from_str(uint16_t *buffer, int64_t buffer_size, char *in, int64_t inlen);
+
+//
+// codepoint iterator
+fn utf8_iter_t utf8_iterate(char *str);
+fn utf8_iter_t utf8_iterate_ex(char *str, int len);
+fn void utf8_advance(utf8_iter_t *iter);
+/* example:
+for (utf8_iter_t iter = utf8_iterate(string); iter.item; utf8_advance(&iter)) {
+    u32 codepoint = iter.item;
+}
+
+*/

src/core/log.c

@@ -1,9 +1,12 @@
 void panicf(const char *_str, ...) {
     ma_temp_t scratch = ma_begin_scratch();
-    S8_FMT(scratch.arena, _str, str);
+    S8_FMT(scratch.arena, _str, str8);
-    core_desc.print(str.str);
+    core_desc.print(str8);
-    core_desc.print("\n");
+    core_desc.print(s8_lit("\n"));
     if (core_desc.break_on_panic) {
+        #if PLATFORM_WINDOWS
+        if (IsDebuggerPresent())
+        #endif
         debug_break();
     } else {
         core_desc.panic();
@@ -14,14 +17,14 @@ void panicf(const char *_str, ...) {
 void debugexf(const char *_str, ...) {
     ma_temp_t scratch = ma_begin_scratch();
     S8_FMT(scratch.arena, _str, str);
-    core_desc.print(str.str);
+    core_desc.print(str);
     ma_end_scratch(scratch);
 }
 
 void debugf(const char *_str, ...) {
     ma_temp_t scratch = ma_begin_scratch();
     S8_FMT(scratch.arena, _str, str);
-    core_desc.print(str.str);
+    core_desc.print(str);
-    core_desc.print("\n");
+    core_desc.print(s8_lit("\n"));
     ma_end_scratch(scratch);
 }

src/core/scratch.c

@@ -1,36 +0,0 @@
-ma_temp_t ma_begin_scratch_ex(ma_arena_t **conflicts, int conflict_count) {
-    ma_arena_t *unoccupied = 0;
-    for (int i = 0; i < lengthof(core_desc.scratch); i += 1) {
-        ma_arena_t *from_pool = core_desc.scratch + i;
-        unoccupied          = from_pool;
-        for (int conflict_i = 0; conflict_i < conflict_count; conflict_i += 1) {
-            ma_arena_t *from_conflict = conflicts[conflict_i];
-            if (from_pool == from_conflict) {
-                unoccupied = 0;
-                break;
-            }
-        }
-
-        if (unoccupied) {
-            break;
-        }
-    }
-
-    assertf(unoccupied, "Failed to get free scratch memory, this is a fatal error, this shouldnt happen");
-    ma_temp_t result = ma_begin_temp(unoccupied);
-    return result;
-}
-
-ma_temp_t ma_begin_scratch(void) {
-    ma_temp_t result = ma_begin_temp(core_desc.scratch + 0);
-    return result;
-}
-
-ma_temp_t ma_begin_scratch1(ma_arena_t *conflict) {
-    ma_arena_t *conflicts[] = {conflict};
-    return ma_begin_scratch_ex(conflicts, 1);
-}
-
-#define ma_end_scratch(x) ma_end_temp(x)
-#define ma_temp_scope(name, InArena) for (ma_temp_t name = ma_begin_temp(InArena); name.arena; (ma_end_temp(name), name.arena = 0))
-#define ma_scratch_scope(x) for (ma_temp_t x = ma_begin_scratch(); x.arena; (ma_end_temp(x), x.arena = 0))

src/core/string.c

@@ -1,59 +0,0 @@
-#define STR_FMT(buff, str)                                     \
-    va_list args1;                                             \
-    va_start(args1, str);                                      \
-    i32 len = stbsp_vsnprintf(buff, sizeof(buff), str, args1); \
-    va_end(args1)
-
-i32 str_len(char *str) {
-    i32 i = 0;
-    while (str[i]) i += 1;
-    return i;
-}
-
-b32 s8_equal(s8_t a, s8_t b);
-s8_t s8_from_char(char *string);
-b32 str_eq(char *a, char *b) {
-    return s8_equal(s8_from_char(a), s8_from_char(b));
-}
-
-char char_to_lower_case(char a) {
-    if (a >= 'A' && a <= 'Z') a += 32;
-    return a;
-}
-
-char char_to_upper_case(char a) {
-    if (a >= 'a' && a <= 'z') a -= 32;
-    return a;
-}
-
-b32 char_is_whitespace(char w) {
-    b32 result = w == '\n' || w == ' ' || w == '\t' || w == '\v' || w == '\r';
-    return result;
-}
-
-b32 char_is_alphabetic(char a) {
-    b32 result = (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z');
-    return result;
-}
-
-b32 char_is_ident(char a) {
-    b32 result = (a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z') || a == '_';
-    return result;
-}
-
-b32 char_is_digit(char a) {
-    b32 result = a >= '0' && a <= '9';
-    return result;
-}
-
-b32 char_is_alphanumeric(char a) {
-    b32 result = char_is_digit(a) || char_is_alphabetic(a);
-    return result;
-}
-
-i64 wstr_len(wchar_t *string) {
-    i64 len = 0;
-    while (*string++ != 0)
-        len++;
-    return len;
-}

src/core_test/core_test_entry.c

@@ -12,7 +12,7 @@ void test_s8(void) {
         sb8_printf(sb, "%S", memes);
         assert(sb->first == sb->last);
         assert(sb->first->len == 5);
-        assert(s8_equal(sb->first->s, memes));
+        assert(s8_equal(sb->first->string, memes));
 
         sb8_printf(sb, "%S", s8_lit("things are going fine"));
         s8_t string = sb8_merge(sb);
@@ -25,8 +25,8 @@ void test_s8(void) {
         s8_t str = s8_lit("thing|another|");
         sb8_t sb = s8_split(arena, str, s8_lit("|"), s8_split_none);
 
-        assert(s8_equal(sb.first->s, s8_lit("thing")));
+        assert(s8_equal(sb.first->string, s8_lit("thing")));
-        assert(s8_equal(sb.first->next->s, s8_lit("another")));
+        assert(s8_equal(sb.first->next->string, s8_lit("another")));
         assert(sb.first->next->next == NULL);
     }
 
@@ -34,10 +34,10 @@ void test_s8(void) {
         s8_t str = s8_lit("thing|another|");
         sb8_t sb = s8_split(arena, str, s8_lit("|"), s8_split_inclusive);
 
-        assert(s8_equal(sb.first->s, s8_lit("thing")));
+        assert(s8_equal(sb.first->string, s8_lit("thing")));
-        assert(s8_equal(sb.first->next->s, s8_lit("|")));
+        assert(s8_equal(sb.first->next->string, s8_lit("|")));
-        assert(s8_equal(sb.first->next->next->s, s8_lit("another")));
+        assert(s8_equal(sb.first->next->next->string, s8_lit("another")));
-        assert(s8_equal(sb.first->next->next->next->s, s8_lit("|")));
+        assert(s8_equal(sb.first->next->next->next->string, s8_lit("|")));
         assert(sb.first->next->next->next->next == NULL);
     }
 
@@ -45,11 +45,11 @@ void test_s8(void) {
         s8_t str = s8_lit("aabaaBaa");
         sb8_t sb = s8_split(arena, str, s8_lit("b"), s8_split_inclusive | s8_split_ignore_case);
 
-        assert(s8_equal(sb.first->s, s8_lit("aa")));
+        assert(s8_equal(sb.first->string, s8_lit("aa")));
-        assert(s8_equal(sb.first->next->s, s8_lit("b")));
+        assert(s8_equal(sb.first->next->string, s8_lit("b")));
-        assert(s8_equal(sb.first->next->next->s, s8_lit("aa")));
+        assert(s8_equal(sb.first->next->next->string, s8_lit("aa")));
-        assert(s8_equal(sb.first->next->next->next->s, s8_lit("B")));
+        assert(s8_equal(sb.first->next->next->next->string, s8_lit("B")));
-        assert(s8_equal(sb.first->next->next->next->next->s, s8_lit("aa")));
+        assert(s8_equal(sb.first->next->next->next->next->string, s8_lit("aa")));
         assert(sb.first->next->next->next->next->next == NULL);
     }
 
@@ -57,9 +57,9 @@ void test_s8(void) {
         s8_t str = s8_lit("aabaaBaa");
         sb8_t sb = s8_split(arena, str, s8_lit("b"), s8_split_inclusive);
 
-        assert(s8_equal(sb.first->s, s8_lit("aa")));
+        assert(s8_equal(sb.first->string, s8_lit("aa")));
-        assert(s8_equal(sb.first->next->s, s8_lit("b")));
+        assert(s8_equal(sb.first->next->string, s8_lit("b")));
-        assert(s8_equal(sb.first->next->next->s, s8_lit("aaBaa")));
+        assert(s8_equal(sb.first->next->next->string, s8_lit("aaBaa")));
     }
 
     {
@@ -87,6 +87,12 @@ void test_s8(void) {
         assert(s8_equal(s, s8_lit("32|v>")));
     }
 
+    {
+        s8_t s0 = s8_lit("0123456789");
+        s8_t s1 = s8_cut_start(&s0, 2);
+        assert(s8_equal(s0, s8_lit("23456789")));
+        assert(s8_equal(s1, s8_lit("01")));
+    }
     ma_destroy(arena);
 }
 

src/meta/parser.c

@@ -62,7 +62,7 @@ ast_t *create_ast_binary(parser_t *par, lex_t *pos, ast_t *left, lex_kind_t op,
     ast_append(result, left);
     ast_append(result, right);
     result->integer = op;
-    result->string = s8_serial_simple_lex_kind_t(op);
+    result->string = lex_kind_to_simple_s8(op);
     return result;
 }
 
@@ -84,7 +84,7 @@ ast_t *parse_lit_expr(parser_t *par) {
         parser_expect(par, lex_kind_close_paren);
         return result;
     } else {
-        lex_panicf(token, "got invalid token of kind: %S while parsing expression", s8_serial_lex_kind_t(token->kind));
+        lex_panicf(token, "got invalid token of kind: %S while parsing expression", lex_kind_to_s8(token->kind));
         return 0;
     }
 }
@@ -153,7 +153,7 @@ i64 eval_const_expr(ast_t *expr) {
             case lex_kind_modulo: return left % right;
             case lex_kind_and: return left && right;
             case lex_kind_or: return left || right;
-            default: lex_panicf(expr->pos, "unhandled binary operator: %S", s8_serial_lex_kind_t(expr->integer));
+            default: lex_panicf(expr->pos, "unhandled binary operator: %S", lex_kind_to_s8(expr->integer));
         }
     } else {
         ma_temp_t scratch = ma_begin_scratch();
@@ -299,7 +299,7 @@ ast_t *parse_table(ma_arena_t *arena, char *file, char *code) {
             } else if (parser_match(par, lex_kind_bit_or) || parser_match(par, lex_kind_eof)) {
                 break;
             } else {
-                lex_panicf(par->at, "invalid token: %S", s8_serial_lex_kind_t(par->at->kind));
+                lex_panicf(par->at, "invalid token: %S", lex_kind_to_s8(par->at->kind));
             }
         }
     }

src/wasm_app/main.c

@@ -15,10 +15,9 @@ void app_update(ma_arena_t *perm_arena, app_event_t *events, i32 event_count) {
     f64 pos = 0.0;
     f64 offset = get_font_height() + 8;
     for (i32 i = 0; i < event_count; i += 1) {
-        s8_t string = s8_serial_data(frame_arena, events + i, &type__app_event_t);
+        s8_t string = ti_serial_data(frame_arena, events + i, app_event_t);
         sb8_t split = s8_split(frame_arena, string, s8_lit("\n"), s8_split_none);
 
-
         for (sb8_node_t *it = split.first; it; it = it->next) {
             draw_text((v2f64_t){0, pos}, white_color_global, it->string);