don't include generated math into build_file, use cache, ui

src/core/core_hash_table.c

@@ -85,7 +85,7 @@ ht_node_t *ht_search_string(ht_dict_t *ht, s8_t key) {
     i64 idx = hash % ht->bucket_count;
     ht_bucket_t *bucket = ht->buckets + idx;
     for (ht_node_t *it = bucket->first; it; it = it->next) {
-        if (s8_equal(it->kv.key_string, key)) {
+        if (s8_are_equal(it->kv.key_string, key)) {
             return it;
         }
     }

src/core/core_inc.c

@@ -35,7 +35,6 @@
 #include "core_intrin.c"
 #include "core_unicode.c"
 #include "core_math.c"
-#include "core_math.gen.c"
 #include "core_arena.c"
 
 #define STB_SPRINTF_IMPLEMENTATION
@@ -45,4 +44,7 @@
 #include "core_lexer.c"
 #include "core_type_info.c"
 #include "core_hash.c"
-#include "core_hash_table.c"
+#include "core_hash_table.c"
+#ifndef DONT_INCLUDE_GENERATED_MATH
+#include "core_math.gen.c"
+#endif

src/core/core_intrin.c

@@ -10,6 +10,11 @@ fn void memory_set(void *dst, i32 c, usize size) {
     IF_PLATFORM_CLANG_ELSE(__builtin_memset(dst, c, size), memset(dst, c, size));
 }
 
+fn b32 memory_equal(void *left, void *right, usize size) {
+    int cmp = IF_PLATFORM_CLANG_ELSE(__builtin_memcmp(left, right, size), memcmp(left, right, size));
+    return cmp == 0;
+}
+
 fn void memory_zero(void *dst, usize size) {
     memory_set(dst, 0, size);
 }

src/core/core_lexer.c

@@ -299,7 +299,7 @@ fn lex_t *parser_match(parser_t *par, lex_kind_t kind) {
 }
 
 fn lex_t *parser_matchi(parser_t *par, s8_t str) {
-    if (par->at->kind == lex_kind_ident && s8_equal(par->at->string, str)) {
+    if (par->at->kind == lex_kind_ident && s8_are_equal(par->at->string, str)) {
         return parser_next(par);
     } else {
         return NULL;

src/core/core_math.gen.c

@@ -1,5 +1,8 @@
 // auto generated using: C:\dev\wasm\src\core\core_math_gen.py
 v2f32_t v2f32(f32 x, f32 y) { return (v2f32_t){  x,  y }; }
+gb_read_only v2f32_t v2f32_null = {0};
+b32 v2f32_is_null(v2f32_t a) { return memory_equal(&a, &v2f32_null, sizeof(a)); }
+b32 v2f32_are_equal(v2f32_t a, v2f32_t b) { return memory_equal(&a, &b, sizeof(a)); }
 v2f32_t v2f32_add(v2f32_t a, v2f32_t b) { return (v2f32_t){ a.x + b.x, a.y + b.y }; }
 v2f32_t v2f32_adds(v2f32_t a, f32 b) { return (v2f32_t){ a.x + b, a.y + b }; }
 v2f32_t v2f32_sub(v2f32_t a, v2f32_t b) { return (v2f32_t){ a.x - b.x, a.y - b.y }; }
@@ -9,6 +12,9 @@ v2f32_t v2f32_muls(v2f32_t a, f32 b) { return (v2f32_t){ a.x * b, a.y * b }; }
 v2f32_t v2f32_div(v2f32_t a, v2f32_t b) { return (v2f32_t){ a.x / b.x, a.y / b.y }; }
 v2f32_t v2f32_divs(v2f32_t a, f32 b) { return (v2f32_t){ a.x / b, a.y / b }; }
 v3f32_t v3f32(f32 x, f32 y, f32 z) { return (v3f32_t){  x,  y,  z }; }
+gb_read_only v3f32_t v3f32_null = {0};
+b32 v3f32_is_null(v3f32_t a) { return memory_equal(&a, &v3f32_null, sizeof(a)); }
+b32 v3f32_are_equal(v3f32_t a, v3f32_t b) { return memory_equal(&a, &b, sizeof(a)); }
 v3f32_t v3f32_add(v3f32_t a, v3f32_t b) { return (v3f32_t){ a.x + b.x, a.y + b.y, a.z + b.z }; }
 v3f32_t v3f32_adds(v3f32_t a, f32 b) { return (v3f32_t){ a.x + b, a.y + b, a.z + b }; }
 v3f32_t v3f32_sub(v3f32_t a, v3f32_t b) { return (v3f32_t){ a.x - b.x, a.y - b.y, a.z - b.z }; }
@@ -18,6 +24,9 @@ v3f32_t v3f32_muls(v3f32_t a, f32 b) { return (v3f32_t){ a.x * b, a.y * b, a.z *
 v3f32_t v3f32_div(v3f32_t a, v3f32_t b) { return (v3f32_t){ a.x / b.x, a.y / b.y, a.z / b.z }; }
 v3f32_t v3f32_divs(v3f32_t a, f32 b) { return (v3f32_t){ a.x / b, a.y / b, a.z / b }; }
 v4f32_t v4f32(f32 x, f32 y, f32 z, f32 w) { return (v4f32_t){  x,  y,  z,  w }; }
+gb_read_only v4f32_t v4f32_null = {0};
+b32 v4f32_is_null(v4f32_t a) { return memory_equal(&a, &v4f32_null, sizeof(a)); }
+b32 v4f32_are_equal(v4f32_t a, v4f32_t b) { return memory_equal(&a, &b, sizeof(a)); }
 v4f32_t v4f32_add(v4f32_t a, v4f32_t b) { return (v4f32_t){ a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w }; }
 v4f32_t v4f32_adds(v4f32_t a, f32 b) { return (v4f32_t){ a.x + b, a.y + b, a.z + b, a.w + b }; }
 v4f32_t v4f32_sub(v4f32_t a, v4f32_t b) { return (v4f32_t){ a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w }; }
@@ -27,6 +36,9 @@ v4f32_t v4f32_muls(v4f32_t a, f32 b) { return (v4f32_t){ a.x * b, a.y * b, a.z *
 v4f32_t v4f32_div(v4f32_t a, v4f32_t b) { return (v4f32_t){ a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w }; }
 v4f32_t v4f32_divs(v4f32_t a, f32 b) { return (v4f32_t){ a.x / b, a.y / b, a.z / b, a.w / b }; }
 r2f32_t r2f32(f32 x0, f32 y0, f32 x1, f32 y1) { return (r2f32_t){  x0,  y0,  x1,  y1 }; }
+gb_read_only r2f32_t r2f32_null = {0};
+b32 r2f32_is_null(r2f32_t a) { return memory_equal(&a, &r2f32_null, sizeof(a)); }
+b32 r2f32_are_equal(r2f32_t a, r2f32_t b) { return memory_equal(&a, &b, sizeof(a)); }
 r2f32_t r2f32_add(r2f32_t a, r2f32_t b) { return (r2f32_t){ a.x0 + b.x0, a.y0 + b.y0, a.x1 + b.x1, a.y1 + b.y1 }; }
 r2f32_t r2f32_adds(r2f32_t a, f32 b) { return (r2f32_t){ a.x0 + b, a.y0 + b, a.x1 + b, a.y1 + b }; }
 r2f32_t r2f32_sub(r2f32_t a, r2f32_t b) { return (r2f32_t){ a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1 }; }
@@ -36,6 +48,9 @@ r2f32_t r2f32_muls(r2f32_t a, f32 b) { return (r2f32_t){ a.x0 * b, a.y0 * b, a.x
 r2f32_t r2f32_div(r2f32_t a, r2f32_t b) { return (r2f32_t){ a.x0 / b.x0, a.y0 / b.y0, a.x1 / b.x1, a.y1 / b.y1 }; }
 r2f32_t r2f32_divs(r2f32_t a, f32 b) { return (r2f32_t){ a.x0 / b, a.y0 / b, a.x1 / b, a.y1 / b }; }
 r3f32_t r3f32(f32 x0, f32 y0, f32 z0, f32 x1, f32 y1, f32 z1) { return (r3f32_t){  x0,  y0,  z0,  x1,  y1,  z1 }; }
+gb_read_only r3f32_t r3f32_null = {0};
+b32 r3f32_is_null(r3f32_t a) { return memory_equal(&a, &r3f32_null, sizeof(a)); }
+b32 r3f32_are_equal(r3f32_t a, r3f32_t b) { return memory_equal(&a, &b, sizeof(a)); }
 r3f32_t r3f32_add(r3f32_t a, r3f32_t b) { return (r3f32_t){ a.x0 + b.x0, a.y0 + b.y0, a.z0 + b.z0, a.x1 + b.x1, a.y1 + b.y1, a.z1 + b.z1 }; }
 r3f32_t r3f32_adds(r3f32_t a, f32 b) { return (r3f32_t){ a.x0 + b, a.y0 + b, a.z0 + b, a.x1 + b, a.y1 + b, a.z1 + b }; }
 r3f32_t r3f32_sub(r3f32_t a, r3f32_t b) { return (r3f32_t){ a.x0 - b.x0, a.y0 - b.y0, a.z0 - b.z0, a.x1 - b.x1, a.y1 - b.y1, a.z1 - b.z1 }; }
@@ -45,6 +60,9 @@ r3f32_t r3f32_muls(r3f32_t a, f32 b) { return (r3f32_t){ a.x0 * b, a.y0 * b, a.z
 r3f32_t r3f32_div(r3f32_t a, r3f32_t b) { return (r3f32_t){ a.x0 / b.x0, a.y0 / b.y0, a.z0 / b.z0, a.x1 / b.x1, a.y1 / b.y1, a.z1 / b.z1 }; }
 r3f32_t r3f32_divs(r3f32_t a, f32 b) { return (r3f32_t){ a.x0 / b, a.y0 / b, a.z0 / b, a.x1 / b, a.y1 / b, a.z1 / b }; }
 v2f64_t v2f64(f64 x, f64 y) { return (v2f64_t){  x,  y }; }
+gb_read_only v2f64_t v2f64_null = {0};
+b32 v2f64_is_null(v2f64_t a) { return memory_equal(&a, &v2f64_null, sizeof(a)); }
+b32 v2f64_are_equal(v2f64_t a, v2f64_t b) { return memory_equal(&a, &b, sizeof(a)); }
 v2f64_t v2f64_add(v2f64_t a, v2f64_t b) { return (v2f64_t){ a.x + b.x, a.y + b.y }; }
 v2f64_t v2f64_adds(v2f64_t a, f64 b) { return (v2f64_t){ a.x + b, a.y + b }; }
 v2f64_t v2f64_sub(v2f64_t a, v2f64_t b) { return (v2f64_t){ a.x - b.x, a.y - b.y }; }
@@ -54,6 +72,9 @@ v2f64_t v2f64_muls(v2f64_t a, f64 b) { return (v2f64_t){ a.x * b, a.y * b }; }
 v2f64_t v2f64_div(v2f64_t a, v2f64_t b) { return (v2f64_t){ a.x / b.x, a.y / b.y }; }
 v2f64_t v2f64_divs(v2f64_t a, f64 b) { return (v2f64_t){ a.x / b, a.y / b }; }
 v3f64_t v3f64(f64 x, f64 y, f64 z) { return (v3f64_t){  x,  y,  z }; }
+gb_read_only v3f64_t v3f64_null = {0};
+b32 v3f64_is_null(v3f64_t a) { return memory_equal(&a, &v3f64_null, sizeof(a)); }
+b32 v3f64_are_equal(v3f64_t a, v3f64_t b) { return memory_equal(&a, &b, sizeof(a)); }
 v3f64_t v3f64_add(v3f64_t a, v3f64_t b) { return (v3f64_t){ a.x + b.x, a.y + b.y, a.z + b.z }; }
 v3f64_t v3f64_adds(v3f64_t a, f64 b) { return (v3f64_t){ a.x + b, a.y + b, a.z + b }; }
 v3f64_t v3f64_sub(v3f64_t a, v3f64_t b) { return (v3f64_t){ a.x - b.x, a.y - b.y, a.z - b.z }; }
@@ -63,6 +84,9 @@ v3f64_t v3f64_muls(v3f64_t a, f64 b) { return (v3f64_t){ a.x * b, a.y * b, a.z *
 v3f64_t v3f64_div(v3f64_t a, v3f64_t b) { return (v3f64_t){ a.x / b.x, a.y / b.y, a.z / b.z }; }
 v3f64_t v3f64_divs(v3f64_t a, f64 b) { return (v3f64_t){ a.x / b, a.y / b, a.z / b }; }
 v4f64_t v4f64(f64 x, f64 y, f64 z, f64 w) { return (v4f64_t){  x,  y,  z,  w }; }
+gb_read_only v4f64_t v4f64_null = {0};
+b32 v4f64_is_null(v4f64_t a) { return memory_equal(&a, &v4f64_null, sizeof(a)); }
+b32 v4f64_are_equal(v4f64_t a, v4f64_t b) { return memory_equal(&a, &b, sizeof(a)); }
 v4f64_t v4f64_add(v4f64_t a, v4f64_t b) { return (v4f64_t){ a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w }; }
 v4f64_t v4f64_adds(v4f64_t a, f64 b) { return (v4f64_t){ a.x + b, a.y + b, a.z + b, a.w + b }; }
 v4f64_t v4f64_sub(v4f64_t a, v4f64_t b) { return (v4f64_t){ a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w }; }
@@ -72,6 +96,9 @@ v4f64_t v4f64_muls(v4f64_t a, f64 b) { return (v4f64_t){ a.x * b, a.y * b, a.z *
 v4f64_t v4f64_div(v4f64_t a, v4f64_t b) { return (v4f64_t){ a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w }; }
 v4f64_t v4f64_divs(v4f64_t a, f64 b) { return (v4f64_t){ a.x / b, a.y / b, a.z / b, a.w / b }; }
 r2f64_t r2f64(f64 x0, f64 y0, f64 x1, f64 y1) { return (r2f64_t){  x0,  y0,  x1,  y1 }; }
+gb_read_only r2f64_t r2f64_null = {0};
+b32 r2f64_is_null(r2f64_t a) { return memory_equal(&a, &r2f64_null, sizeof(a)); }
+b32 r2f64_are_equal(r2f64_t a, r2f64_t b) { return memory_equal(&a, &b, sizeof(a)); }
 r2f64_t r2f64_add(r2f64_t a, r2f64_t b) { return (r2f64_t){ a.x0 + b.x0, a.y0 + b.y0, a.x1 + b.x1, a.y1 + b.y1 }; }
 r2f64_t r2f64_adds(r2f64_t a, f64 b) { return (r2f64_t){ a.x0 + b, a.y0 + b, a.x1 + b, a.y1 + b }; }
 r2f64_t r2f64_sub(r2f64_t a, r2f64_t b) { return (r2f64_t){ a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1 }; }
@@ -81,6 +108,9 @@ r2f64_t r2f64_muls(r2f64_t a, f64 b) { return (r2f64_t){ a.x0 * b, a.y0 * b, a.x
 r2f64_t r2f64_div(r2f64_t a, r2f64_t b) { return (r2f64_t){ a.x0 / b.x0, a.y0 / b.y0, a.x1 / b.x1, a.y1 / b.y1 }; }
 r2f64_t r2f64_divs(r2f64_t a, f64 b) { return (r2f64_t){ a.x0 / b, a.y0 / b, a.x1 / b, a.y1 / b }; }
 r3f64_t r3f64(f64 x0, f64 y0, f64 z0, f64 x1, f64 y1, f64 z1) { return (r3f64_t){  x0,  y0,  z0,  x1,  y1,  z1 }; }
+gb_read_only r3f64_t r3f64_null = {0};
+b32 r3f64_is_null(r3f64_t a) { return memory_equal(&a, &r3f64_null, sizeof(a)); }
+b32 r3f64_are_equal(r3f64_t a, r3f64_t b) { return memory_equal(&a, &b, sizeof(a)); }
 r3f64_t r3f64_add(r3f64_t a, r3f64_t b) { return (r3f64_t){ a.x0 + b.x0, a.y0 + b.y0, a.z0 + b.z0, a.x1 + b.x1, a.y1 + b.y1, a.z1 + b.z1 }; }
 r3f64_t r3f64_adds(r3f64_t a, f64 b) { return (r3f64_t){ a.x0 + b, a.y0 + b, a.z0 + b, a.x1 + b, a.y1 + b, a.z1 + b }; }
 r3f64_t r3f64_sub(r3f64_t a, r3f64_t b) { return (r3f64_t){ a.x0 - b.x0, a.y0 - b.y0, a.z0 - b.z0, a.x1 - b.x1, a.y1 - b.y1, a.z1 - b.z1 }; }
@@ -90,6 +120,9 @@ r3f64_t r3f64_muls(r3f64_t a, f64 b) { return (r3f64_t){ a.x0 * b, a.y0 * b, a.z
 r3f64_t r3f64_div(r3f64_t a, r3f64_t b) { return (r3f64_t){ a.x0 / b.x0, a.y0 / b.y0, a.z0 / b.z0, a.x1 / b.x1, a.y1 / b.y1, a.z1 / b.z1 }; }
 r3f64_t r3f64_divs(r3f64_t a, f64 b) { return (r3f64_t){ a.x0 / b, a.y0 / b, a.z0 / b, a.x1 / b, a.y1 / b, a.z1 / b }; }
 v2i32_t v2i32(i32 x, i32 y) { return (v2i32_t){  x,  y }; }
+gb_read_only v2i32_t v2i32_null = {0};
+b32 v2i32_is_null(v2i32_t a) { return memory_equal(&a, &v2i32_null, sizeof(a)); }
+b32 v2i32_are_equal(v2i32_t a, v2i32_t b) { return memory_equal(&a, &b, sizeof(a)); }
 v2i32_t v2i32_add(v2i32_t a, v2i32_t b) { return (v2i32_t){ a.x + b.x, a.y + b.y }; }
 v2i32_t v2i32_adds(v2i32_t a, i32 b) { return (v2i32_t){ a.x + b, a.y + b }; }
 v2i32_t v2i32_sub(v2i32_t a, v2i32_t b) { return (v2i32_t){ a.x - b.x, a.y - b.y }; }
@@ -99,6 +132,9 @@ v2i32_t v2i32_muls(v2i32_t a, i32 b) { return (v2i32_t){ a.x * b, a.y * b }; }
 v2i32_t v2i32_div(v2i32_t a, v2i32_t b) { return (v2i32_t){ a.x / b.x, a.y / b.y }; }
 v2i32_t v2i32_divs(v2i32_t a, i32 b) { return (v2i32_t){ a.x / b, a.y / b }; }
 v3i32_t v3i32(i32 x, i32 y, i32 z) { return (v3i32_t){  x,  y,  z }; }
+gb_read_only v3i32_t v3i32_null = {0};
+b32 v3i32_is_null(v3i32_t a) { return memory_equal(&a, &v3i32_null, sizeof(a)); }
+b32 v3i32_are_equal(v3i32_t a, v3i32_t b) { return memory_equal(&a, &b, sizeof(a)); }
 v3i32_t v3i32_add(v3i32_t a, v3i32_t b) { return (v3i32_t){ a.x + b.x, a.y + b.y, a.z + b.z }; }
 v3i32_t v3i32_adds(v3i32_t a, i32 b) { return (v3i32_t){ a.x + b, a.y + b, a.z + b }; }
 v3i32_t v3i32_sub(v3i32_t a, v3i32_t b) { return (v3i32_t){ a.x - b.x, a.y - b.y, a.z - b.z }; }
@@ -108,6 +144,9 @@ v3i32_t v3i32_muls(v3i32_t a, i32 b) { return (v3i32_t){ a.x * b, a.y * b, a.z *
 v3i32_t v3i32_div(v3i32_t a, v3i32_t b) { return (v3i32_t){ a.x / b.x, a.y / b.y, a.z / b.z }; }
 v3i32_t v3i32_divs(v3i32_t a, i32 b) { return (v3i32_t){ a.x / b, a.y / b, a.z / b }; }
 v4i32_t v4i32(i32 x, i32 y, i32 z, i32 w) { return (v4i32_t){  x,  y,  z,  w }; }
+gb_read_only v4i32_t v4i32_null = {0};
+b32 v4i32_is_null(v4i32_t a) { return memory_equal(&a, &v4i32_null, sizeof(a)); }
+b32 v4i32_are_equal(v4i32_t a, v4i32_t b) { return memory_equal(&a, &b, sizeof(a)); }
 v4i32_t v4i32_add(v4i32_t a, v4i32_t b) { return (v4i32_t){ a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w }; }
 v4i32_t v4i32_adds(v4i32_t a, i32 b) { return (v4i32_t){ a.x + b, a.y + b, a.z + b, a.w + b }; }
 v4i32_t v4i32_sub(v4i32_t a, v4i32_t b) { return (v4i32_t){ a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w }; }
@@ -117,6 +156,9 @@ v4i32_t v4i32_muls(v4i32_t a, i32 b) { return (v4i32_t){ a.x * b, a.y * b, a.z *
 v4i32_t v4i32_div(v4i32_t a, v4i32_t b) { return (v4i32_t){ a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w }; }
 v4i32_t v4i32_divs(v4i32_t a, i32 b) { return (v4i32_t){ a.x / b, a.y / b, a.z / b, a.w / b }; }
 r2i32_t r2i32(i32 x0, i32 y0, i32 x1, i32 y1) { return (r2i32_t){  x0,  y0,  x1,  y1 }; }
+gb_read_only r2i32_t r2i32_null = {0};
+b32 r2i32_is_null(r2i32_t a) { return memory_equal(&a, &r2i32_null, sizeof(a)); }
+b32 r2i32_are_equal(r2i32_t a, r2i32_t b) { return memory_equal(&a, &b, sizeof(a)); }
 r2i32_t r2i32_add(r2i32_t a, r2i32_t b) { return (r2i32_t){ a.x0 + b.x0, a.y0 + b.y0, a.x1 + b.x1, a.y1 + b.y1 }; }
 r2i32_t r2i32_adds(r2i32_t a, i32 b) { return (r2i32_t){ a.x0 + b, a.y0 + b, a.x1 + b, a.y1 + b }; }
 r2i32_t r2i32_sub(r2i32_t a, r2i32_t b) { return (r2i32_t){ a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1 }; }
@@ -126,6 +168,9 @@ r2i32_t r2i32_muls(r2i32_t a, i32 b) { return (r2i32_t){ a.x0 * b, a.y0 * b, a.x
 r2i32_t r2i32_div(r2i32_t a, r2i32_t b) { return (r2i32_t){ a.x0 / b.x0, a.y0 / b.y0, a.x1 / b.x1, a.y1 / b.y1 }; }
 r2i32_t r2i32_divs(r2i32_t a, i32 b) { return (r2i32_t){ a.x0 / b, a.y0 / b, a.x1 / b, a.y1 / b }; }
 r3i32_t r3i32(i32 x0, i32 y0, i32 z0, i32 x1, i32 y1, i32 z1) { return (r3i32_t){  x0,  y0,  z0,  x1,  y1,  z1 }; }
+gb_read_only r3i32_t r3i32_null = {0};
+b32 r3i32_is_null(r3i32_t a) { return memory_equal(&a, &r3i32_null, sizeof(a)); }
+b32 r3i32_are_equal(r3i32_t a, r3i32_t b) { return memory_equal(&a, &b, sizeof(a)); }
 r3i32_t r3i32_add(r3i32_t a, r3i32_t b) { return (r3i32_t){ a.x0 + b.x0, a.y0 + b.y0, a.z0 + b.z0, a.x1 + b.x1, a.y1 + b.y1, a.z1 + b.z1 }; }
 r3i32_t r3i32_adds(r3i32_t a, i32 b) { return (r3i32_t){ a.x0 + b, a.y0 + b, a.z0 + b, a.x1 + b, a.y1 + b, a.z1 + b }; }
 r3i32_t r3i32_sub(r3i32_t a, r3i32_t b) { return (r3i32_t){ a.x0 - b.x0, a.y0 - b.y0, a.z0 - b.z0, a.x1 - b.x1, a.y1 - b.y1, a.z1 - b.z1 }; }
@@ -135,6 +180,9 @@ r3i32_t r3i32_muls(r3i32_t a, i32 b) { return (r3i32_t){ a.x0 * b, a.y0 * b, a.z
 r3i32_t r3i32_div(r3i32_t a, r3i32_t b) { return (r3i32_t){ a.x0 / b.x0, a.y0 / b.y0, a.z0 / b.z0, a.x1 / b.x1, a.y1 / b.y1, a.z1 / b.z1 }; }
 r3i32_t r3i32_divs(r3i32_t a, i32 b) { return (r3i32_t){ a.x0 / b, a.y0 / b, a.z0 / b, a.x1 / b, a.y1 / b, a.z1 / b }; }
 v2i64_t v2i64(i64 x, i64 y) { return (v2i64_t){  x,  y }; }
+gb_read_only v2i64_t v2i64_null = {0};
+b32 v2i64_is_null(v2i64_t a) { return memory_equal(&a, &v2i64_null, sizeof(a)); }
+b32 v2i64_are_equal(v2i64_t a, v2i64_t b) { return memory_equal(&a, &b, sizeof(a)); }
 v2i64_t v2i64_add(v2i64_t a, v2i64_t b) { return (v2i64_t){ a.x + b.x, a.y + b.y }; }
 v2i64_t v2i64_adds(v2i64_t a, i64 b) { return (v2i64_t){ a.x + b, a.y + b }; }
 v2i64_t v2i64_sub(v2i64_t a, v2i64_t b) { return (v2i64_t){ a.x - b.x, a.y - b.y }; }
@@ -144,6 +192,9 @@ v2i64_t v2i64_muls(v2i64_t a, i64 b) { return (v2i64_t){ a.x * b, a.y * b }; }
 v2i64_t v2i64_div(v2i64_t a, v2i64_t b) { return (v2i64_t){ a.x / b.x, a.y / b.y }; }
 v2i64_t v2i64_divs(v2i64_t a, i64 b) { return (v2i64_t){ a.x / b, a.y / b }; }
 v3i64_t v3i64(i64 x, i64 y, i64 z) { return (v3i64_t){  x,  y,  z }; }
+gb_read_only v3i64_t v3i64_null = {0};
+b32 v3i64_is_null(v3i64_t a) { return memory_equal(&a, &v3i64_null, sizeof(a)); }
+b32 v3i64_are_equal(v3i64_t a, v3i64_t b) { return memory_equal(&a, &b, sizeof(a)); }
 v3i64_t v3i64_add(v3i64_t a, v3i64_t b) { return (v3i64_t){ a.x + b.x, a.y + b.y, a.z + b.z }; }
 v3i64_t v3i64_adds(v3i64_t a, i64 b) { return (v3i64_t){ a.x + b, a.y + b, a.z + b }; }
 v3i64_t v3i64_sub(v3i64_t a, v3i64_t b) { return (v3i64_t){ a.x - b.x, a.y - b.y, a.z - b.z }; }
@@ -153,6 +204,9 @@ v3i64_t v3i64_muls(v3i64_t a, i64 b) { return (v3i64_t){ a.x * b, a.y * b, a.z *
 v3i64_t v3i64_div(v3i64_t a, v3i64_t b) { return (v3i64_t){ a.x / b.x, a.y / b.y, a.z / b.z }; }
 v3i64_t v3i64_divs(v3i64_t a, i64 b) { return (v3i64_t){ a.x / b, a.y / b, a.z / b }; }
 v4i64_t v4i64(i64 x, i64 y, i64 z, i64 w) { return (v4i64_t){  x,  y,  z,  w }; }
+gb_read_only v4i64_t v4i64_null = {0};
+b32 v4i64_is_null(v4i64_t a) { return memory_equal(&a, &v4i64_null, sizeof(a)); }
+b32 v4i64_are_equal(v4i64_t a, v4i64_t b) { return memory_equal(&a, &b, sizeof(a)); }
 v4i64_t v4i64_add(v4i64_t a, v4i64_t b) { return (v4i64_t){ a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w }; }
 v4i64_t v4i64_adds(v4i64_t a, i64 b) { return (v4i64_t){ a.x + b, a.y + b, a.z + b, a.w + b }; }
 v4i64_t v4i64_sub(v4i64_t a, v4i64_t b) { return (v4i64_t){ a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w }; }
@@ -162,6 +216,9 @@ v4i64_t v4i64_muls(v4i64_t a, i64 b) { return (v4i64_t){ a.x * b, a.y * b, a.z *
 v4i64_t v4i64_div(v4i64_t a, v4i64_t b) { return (v4i64_t){ a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w }; }
 v4i64_t v4i64_divs(v4i64_t a, i64 b) { return (v4i64_t){ a.x / b, a.y / b, a.z / b, a.w / b }; }
 r2i64_t r2i64(i64 x0, i64 y0, i64 x1, i64 y1) { return (r2i64_t){  x0,  y0,  x1,  y1 }; }
+gb_read_only r2i64_t r2i64_null = {0};
+b32 r2i64_is_null(r2i64_t a) { return memory_equal(&a, &r2i64_null, sizeof(a)); }
+b32 r2i64_are_equal(r2i64_t a, r2i64_t b) { return memory_equal(&a, &b, sizeof(a)); }
 r2i64_t r2i64_add(r2i64_t a, r2i64_t b) { return (r2i64_t){ a.x0 + b.x0, a.y0 + b.y0, a.x1 + b.x1, a.y1 + b.y1 }; }
 r2i64_t r2i64_adds(r2i64_t a, i64 b) { return (r2i64_t){ a.x0 + b, a.y0 + b, a.x1 + b, a.y1 + b }; }
 r2i64_t r2i64_sub(r2i64_t a, r2i64_t b) { return (r2i64_t){ a.x0 - b.x0, a.y0 - b.y0, a.x1 - b.x1, a.y1 - b.y1 }; }
@@ -171,6 +228,9 @@ r2i64_t r2i64_muls(r2i64_t a, i64 b) { return (r2i64_t){ a.x0 * b, a.y0 * b, a.x
 r2i64_t r2i64_div(r2i64_t a, r2i64_t b) { return (r2i64_t){ a.x0 / b.x0, a.y0 / b.y0, a.x1 / b.x1, a.y1 / b.y1 }; }
 r2i64_t r2i64_divs(r2i64_t a, i64 b) { return (r2i64_t){ a.x0 / b, a.y0 / b, a.x1 / b, a.y1 / b }; }
 r3i64_t r3i64(i64 x0, i64 y0, i64 z0, i64 x1, i64 y1, i64 z1) { return (r3i64_t){  x0,  y0,  z0,  x1,  y1,  z1 }; }
+gb_read_only r3i64_t r3i64_null = {0};
+b32 r3i64_is_null(r3i64_t a) { return memory_equal(&a, &r3i64_null, sizeof(a)); }
+b32 r3i64_are_equal(r3i64_t a, r3i64_t b) { return memory_equal(&a, &b, sizeof(a)); }
 r3i64_t r3i64_add(r3i64_t a, r3i64_t b) { return (r3i64_t){ a.x0 + b.x0, a.y0 + b.y0, a.z0 + b.z0, a.x1 + b.x1, a.y1 + b.y1, a.z1 + b.z1 }; }
 r3i64_t r3i64_adds(r3i64_t a, i64 b) { return (r3i64_t){ a.x0 + b, a.y0 + b, a.z0 + b, a.x1 + b, a.y1 + b, a.z1 + b }; }
 r3i64_t r3i64_sub(r3i64_t a, r3i64_t b) { return (r3i64_t){ a.x0 - b.x0, a.y0 - b.y0, a.z0 - b.z0, a.x1 - b.x1, a.y1 - b.y1, a.z1 - b.z1 }; }

src/core/core_math_gen.py

@@ -163,6 +163,9 @@ for basic_type in basic_types:
             return result
 
         print(f"""{type}_t {type}({members_as_func_params(members, basic_type)}) {{ return ({type}_t){{ {members_as_func_params(members, "")} }}; }}""")
+        print(f"""gb_read_only {type}_t {type}_null = {{0}};""")
+        print(f"""b32 {type}_is_null({type}_t a) {{ return memory_equal(&a, &{type}_null, sizeof(a)); }}""")
+        print(f"""b32 {type}_are_equal({type}_t a, {type}_t b) {{ return memory_equal(&a, &b, sizeof(a)); }}""")
 
         for sym in symbols:
             op = sym[op_idx]
@@ -183,7 +186,6 @@ for basic_type in basic_types:
                 return result
 
 
-
             print(f"{type}_t {type}_{opname}({type}_t a, {type}_t b) {{ return ({type}_t){{ {op_str(members, op)} }}; }}")
             print(f"{type}_t {type}_{opname}s({type}_t a, {basic_type} b) {{ return ({type}_t){{ {op_str(members, op, skip_right = True)} }}; }}")
 

src/core/core_string.c

@@ -7,7 +7,7 @@ fn i32 str_len(char *str) {
 }
 
 fn b32 str_eq(char *a, char *b) {
-    return s8_equal(s8_from_char(a), s8_from_char(b));
+    return s8_are_equal(s8_from_char(a), s8_from_char(b));
 }
 
 fn char char_to_lower_case(char a) {
@@ -98,7 +98,7 @@ s8_t s8_copy_char(ma_arena_t *ma, char *s) {
     return result;
 }
 
-fn b32 s8_equal_ex(s8_t a, s8_t b, b32 ignore_case) {
+fn b32 s8_are_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];
@@ -113,8 +113,8 @@ fn b32 s8_equal_ex(s8_t a, s8_t b, b32 ignore_case) {
     return true;
 }
 
-fn b32 s8_equal(s8_t a, s8_t b) {
-    return s8_equal_ex(a, b, false);
+fn b32 s8_are_equal(s8_t a, s8_t b) {
+    return s8_are_equal_ex(a, b, false);
 }
 
 fn s8_t s8_get_postfix(s8_t string, int64_t len) {
@@ -145,13 +145,13 @@ fn s8_t s8_skip(s8_t string, int64_t len) {
 
 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);
+    b32 result = s8_are_equal_ex(end, a_end, ignore_case);
     return result;
 }
 
 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);
+    b32 result = s8_are_equal_ex(start, a_start, ignore_case);
     return result;
 }
 
@@ -268,7 +268,7 @@ fn b32 s8_seek(s8_t string, s8_t find, s8_seek_t flags, int64_t *index_out) {
         for (int64_t i = string.len; i != 0; i--) {
             int64_t index = i - 1;
             s8_t substring = s8_slice(string, index, index + find.len);
-            if (s8_equal_ex(substring, find, ignore_case)) {
+            if (s8_are_equal_ex(substring, find, ignore_case)) {
                 if (index_out)
                     *index_out = index;
                 result = true;
@@ -279,7 +279,7 @@ fn b32 s8_seek(s8_t string, s8_t find, s8_seek_t flags, int64_t *index_out) {
     else {
         for (int64_t i = 0; i < string.len; i++) {
             s8_t substring = s8_slice(string, i, i + find.len);
-            if (s8_equal_ex(substring, find, ignore_case)) {
+            if (s8_are_equal_ex(substring, find, ignore_case)) {
                 if (index_out)
                     *index_out = i;
                 result = true;

src/core/core_string.h

@@ -83,8 +83,8 @@ 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_are_equal_ex(s8_t a, s8_t b, b32 ignore_case);
+fn b32 s8_are_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?

src/core/core_test_entry.c

@@ -12,11 +12,11 @@ void test_s8(void) {
         sb8_printf(sb, "%S", memes);
         assert(sb->first == sb->last);
         assert(sb->first->len == 5);
-        assert(s8_equal(sb->first->string, memes));
+        assert(s8_are_equal(sb->first->string, memes));
 
         sb8_printf(sb, "%S", s8_lit("things are going fine"));
         s8_t string = sb8_merge(sb);
-        assert(s8_equal(string, s8_lit("memesthings are going fine")));
+        assert(s8_are_equal(string, s8_lit("memesthings are going fine")));
 
         ma_end_temp(temp);
     }
@@ -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->string, s8_lit("thing")));
-        assert(s8_equal(sb.first->next->string, s8_lit("another")));
+        assert(s8_are_equal(sb.first->string, s8_lit("thing")));
+        assert(s8_are_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->string, s8_lit("thing")));
-        assert(s8_equal(sb.first->next->string, s8_lit("|")));
-        assert(s8_equal(sb.first->next->next->string, s8_lit("another")));
-        assert(s8_equal(sb.first->next->next->next->string, s8_lit("|")));
+        assert(s8_are_equal(sb.first->string, s8_lit("thing")));
+        assert(s8_are_equal(sb.first->next->string, s8_lit("|")));
+        assert(s8_are_equal(sb.first->next->next->string, s8_lit("another")));
+        assert(s8_are_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->string, s8_lit("aa")));
-        assert(s8_equal(sb.first->next->string, s8_lit("b")));
-        assert(s8_equal(sb.first->next->next->string, s8_lit("aa")));
-        assert(s8_equal(sb.first->next->next->next->string, s8_lit("B")));
-        assert(s8_equal(sb.first->next->next->next->next->string, s8_lit("aa")));
+        assert(s8_are_equal(sb.first->string, s8_lit("aa")));
+        assert(s8_are_equal(sb.first->next->string, s8_lit("b")));
+        assert(s8_are_equal(sb.first->next->next->string, s8_lit("aa")));
+        assert(s8_are_equal(sb.first->next->next->next->string, s8_lit("B")));
+        assert(s8_are_equal(sb.first->next->next->next->next->string, s8_lit("aa")));
         assert(sb.first->next->next->next->next->next == NULL);
     }
 
@@ -57,41 +57,41 @@ 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->string, s8_lit("aa")));
-        assert(s8_equal(sb.first->next->string, s8_lit("b")));
-        assert(s8_equal(sb.first->next->next->string, s8_lit("aaBaa")));
+        assert(s8_are_equal(sb.first->string, s8_lit("aa")));
+        assert(s8_are_equal(sb.first->next->string, s8_lit("b")));
+        assert(s8_are_equal(sb.first->next->next->string, s8_lit("aaBaa")));
     }
 
     {
         s8_t s = s8_lit("0123456789");
-        assert(s8_equal(s8_slice(s, 0, 4), s8_lit("0123")));
-        assert(s8_equal(s8_slice(s, -2, -1), s8_lit("89")));
-        assert(s8_equal(s8_slice(s, -2, 10), s8_lit("89")));
-        assert(s8_equal(s8_slice(s, 8, 10), s8_lit("89")));
+        assert(s8_are_equal(s8_slice(s, 0, 4), s8_lit("0123")));
+        assert(s8_are_equal(s8_slice(s, -2, -1), s8_lit("89")));
+        assert(s8_are_equal(s8_slice(s, -2, 10), s8_lit("89")));
+        assert(s8_are_equal(s8_slice(s, 8, 10), s8_lit("89")));
     }
 
     {
         s8_t s = s8_lit("    a                  \n");
         s = s8_trim(s);
-        assert(s8_equal(s, s8_lit("a")));
+        assert(s8_are_equal(s, s8_lit("a")));
     }
 
     {
         s8_t s = s8_lit("C:/memes/the_thing.c");
         s8_t ss = s8_get_name_no_ext(s);
-        assert(s8_equal(ss, s8_lit("the_thing")));
+        assert(s8_are_equal(ss, s8_lit("the_thing")));
     }
 
     {
         s8_t s = s8_printf(arena, "%d%Sv%s", 32, s8_lit("|"), ">");
-        assert(s8_equal(s, s8_lit("32|v>")));
+        assert(s8_are_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")));
+        assert(s8_are_equal(s0, s8_lit("23456789")));
+        assert(s8_are_equal(s1, s8_lit("01")));
     }
     ma_destroy(arena);
 }
@@ -123,8 +123,8 @@ void test_hash_table(void) {
             s8_t s = s8_printf(scratch.arena, "%d", i);
             ht_insert_string(ht, s, s);
             ht_node_t *node = ht_search_string(ht, s);
-            assert(s8_equal(node->kv.value_string, s));
-            assert(s8_equal(node->kv.key_string, s));
+            assert(s8_are_equal(node->kv.value_string, s));
+            assert(s8_are_equal(node->kv.key_string, s));
         }
 
         ht_node_t *node = ht_search_string(ht, s8_lit("memes"));

src/core/core_type_info.c

@@ -13,7 +13,7 @@ fn i64 ti_enum_name_to_value(s8_t name, type_t *type) {
     assert(type->kind == type_kind_enum);
     for (i32 i = 0; i < type->count; i += 1) {
         type_member_t *it = type->members + i;
-        if (s8_equal(it->name, name)) {
+        if (s8_are_equal(it->name, name)) {
             return it->value;
         }
     }
@@ -55,7 +55,7 @@ fn void ti_enum_write_value(void *p, i64 value, type_t *type) {
 fn type_member_t *ti_get_member(s8_t name, type_t *type) {
     for (i32 i = 0; i < type->count; i += 1) {
         type_member_t *it = type->members + i;
-        if (s8_equal(it->name, name)) {
+        if (s8_are_equal(it->name, name)) {
             return it;
         }
     }
@@ -390,7 +390,7 @@ fn void ti__deserial_data_ex(ma_arena_t *arena, parser_t *par, void *p, type_t *
             lex_t *ident = parser_expect(par, lex_kind_ident);
             parser_expect(par, lex_kind_colon);
 
-            expect (s8_equal(ident->string, mem->name)) fatalf("expected identifier: %S, got instead %S", mem->name, ident->string);
+            expect (s8_are_equal(ident->string, mem->name)) fatalf("expected identifier: %S, got instead %S", mem->name, ident->string);
 
             ti__deserial_data_ex(arena, par, memp, mem->type);
             parser_expect(par, lex_kind_comma);