From 11450a445da4bd7a835fe53ec90411044040c53a Mon Sep 17 00:00:00 2001 From: krzosa Date: Sun, 29 Dec 2024 13:30:13 +0100 Subject: [PATCH] core api redesign --- build_file.c | 4 +- src/app/app_wasm.c | 7 +- src/core/core.c | 20 +- src/core/core.h | 13 +- src/core/{arena.c => core_arena.c} | 65 +++- src/core/core_arena.h | 53 +++ src/core/{types.h => core_defines.h} | 311 +---------------- src/core/{intrinsics.c => core_intrin.c} | 82 +++-- src/core/core_intrin.h | 46 +++ src/core/{lexer.c => core_lexer.c} | 227 ++---------- src/core/core_lexer.h | 133 +++++++ src/core/{mathx.c => core_math.c} | 15 - src/core/{mathx.gen.c => core_math.gen.c} | 0 src/core/core_math.h | 213 ++++++++++++ src/core/{math_gen.py => core_math_gen.py} | 4 +- ...form_defines.h => core_platform_defines.h} | 0 src/core/{string8.c => core_string.c} | 329 ++++++++++-------- src/core/core_string.h | 147 ++++++++ src/core/{type_info.c => core_type_info.c} | 53 ++- src/core/{type_info.h => core_type_info.h} | 145 ++++---- src/core/{unicode.c => core_unicode.c} | 48 +-- src/core/core_unicode.h | 53 +++ src/core/log.c | 15 +- src/core/scratch.c | 36 -- src/core/string.c | 59 ---- src/core_test/core_test_entry.c | 36 +- src/meta/parser.c | 8 +- src/wasm_app/main.c | 3 +- 28 files changed, 1130 insertions(+), 995 deletions(-) rename src/core/{arena.c => core_arena.c} (65%) create mode 100644 src/core/core_arena.h rename src/core/{types.h => core_defines.h} (56%) rename src/core/{intrinsics.c => core_intrin.c} (53%) create mode 100644 src/core/core_intrin.h rename src/core/{lexer.c => core_lexer.c} (60%) create mode 100644 src/core/core_lexer.h rename src/core/{mathx.c => core_math.c} (94%) rename src/core/{mathx.gen.c => core_math.gen.c} (100%) create mode 100644 src/core/core_math.h rename src/core/{math_gen.py => core_math_gen.py} (99%) rename src/core/{platform_defines.h => core_platform_defines.h} (100%) rename src/core/{string8.c => core_string.c} (66%) create mode 100644 src/core/core_string.h rename src/core/{type_info.c => core_type_info.c} (87%) rename src/core/{type_info.h => core_type_info.h} (65%) rename src/core/{unicode.c => core_unicode.c} (84%) create mode 100644 src/core/core_unicode.h delete mode 100644 src/core/scratch.c delete mode 100644 src/core/string.c diff --git a/build_file.c b/build_file.c index 30b85c7..5e8831c 100644 --- a/build_file.c +++ b/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"); diff --git a/src/app/app_wasm.c b/src/app/app_wasm.c index 4f83659..4a90be6 100644 --- a/src/app/app_wasm.c +++ b/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) { - i32 len = str_len(string); - wasm_write_to_console((isize)string, len); +void write_to_console(s8_t string) { + wasm_write_to_console((isize)string.str, (i32)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); } diff --git a/src/core/core.c b/src/core/core.c index 961abc8..8c60f21 100644 --- a/src/core/core.c +++ b/src/core/core.c @@ -1,5 +1,3 @@ -#include - #if PLATFORM_WINDOWS #define NOMINMAX #define WIN32_LEAN_AND_MEAN @@ -25,17 +23,15 @@ #include #endif -#include "intrinsics.c" -#include "unicode.c" -#include "mathx.c" -#include "mathx.gen.c" -#include "arena.c" +#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 #include "stb_sprintf.h" -#include "string.c" -#include "string8.c" -#include "scratch.c" +#include "core_string.c" #include "log.c" -#include "lexer.c" -#include "type_info.c" \ No newline at end of file +#include "core_lexer.c" +#include "core_type_info.c" \ No newline at end of file diff --git a/src/core/core.h b/src/core/core.h index 44ff12c..5ca991b 100644 --- a/src/core/core.h +++ b/src/core/core.h @@ -1,5 +1,12 @@ -#include "platform_defines.h" +#include "core_platform_defines.h" #include #include -#include "types.h" -#include "type_info.h" +#include +#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" \ No newline at end of file diff --git a/src/core/arena.c b/src/core/core_arena.c similarity index 65% rename from src/core/arena.c rename to src/core/core_arena.c index 90565a9..cebd62e 100644 --- a/src/core/arena.c +++ b/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); } -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); } -void ma_set0(ma_arena_t *arena) { ma_set_len(arena, 0); } +fn void ma_pop(ma_arena_t *arena, usize size) { ma_set_len(arena, arena->len - size); } +fn ma_temp_t ma_begin_temp(ma_arena_t *arena) { return (ma_temp_t){arena, arena->len}; } +fn void ma_end_temp(ma_temp_t temp) { ma_set_len(temp.arena, temp.len); } +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); +} diff --git a/src/core/core_arena.h b/src/core/core_arena.h new file mode 100644 index 0000000..bdd2227 --- /dev/null +++ b/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)) \ No newline at end of file diff --git a/src/core/types.h b/src/core/core_defines.h similarity index 56% rename from src/core/types.h rename to src/core/core_defines.h index 685139a..0833d62 100644 --- a/src/core/types.h +++ b/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]; -}; diff --git a/src/core/intrinsics.c b/src/core/core_intrin.c similarity index 53% rename from src/core/intrinsics.c rename to src/core/core_intrin.c index de4b325..2b43151 100644 --- a/src/core/intrinsics.c +++ b/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); } -f64 f64_sqrt(f64 x) { return sqrt(x); } -f32 f32_ceil(f32 x) { return ceilf(x); } -f64 f64_ceil(f64 x) { return ceil(x); } -f32 f32_floor(f32 x) { return floorf(x); } -f64 f64_floor(f64 x) { return floor(x); } -f32 f32_abs(f32 x) { return fabsf(x); } -f64 f64_abs(f64 x) { return fabs(x); } -f32 f32_round(f32 x) { return roundf(x); } -f64 f64_round(f64 x) { return round(x); } -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_sqrt(f32 x) { return sqrtf(x); } +fn f64 f64_sqrt(f64 x) { return sqrt(x); } +fn f32 f32_ceil(f32 x) { return ceilf(x); } +fn f64 f64_ceil(f64 x) { return ceil(x); } +fn f32 f32_floor(f32 x) { return floorf(x); } +fn f64 f64_floor(f64 x) { return floor(x); } +fn f32 f32_abs(f32 x) { return fabsf(x); } +fn f64 f64_abs(f64 x) { return fabs(x); } +fn f32 f32_round(f32 x) { return roundf(x); } +fn f64 f64_round(f64 x) { return round(x); } +fn f64 f64_mod(f64 a, f64 b) { return fmod(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); -void write_to_console(char *string); +f64 f64_from_s8(s8_t 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) { - SWITCH_PLATFORM_WINDOWS_WASM_ELSE( - if (IsDebuggerPresent()) OutputDebugStringA(string), - write_to_console(string), - printf("%s", string); fflush(stdout) - ); +fn void core_log_message(s8_t string) { +#if PLATFORM_WINDOWS + ma_temp_t scratch = ma_begin_scratch(); + s8_t copy = s8_copy(scratch.arena, string); + 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, -}; - diff --git a/src/core/core_intrin.h b/src/core/core_intrin.h new file mode 100644 index 0000000..164d458 --- /dev/null +++ b/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, +}; diff --git a/src/core/lexer.c b/src/core/core_lexer.c similarity index 60% rename from src/core/lexer.c rename to src/core/core_lexer.c index 1d4d229..cce5fad 100644 --- a/src/core/lexer.c +++ b/src/core/core_lexer.c @@ -1,134 +1,23 @@ -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; -}; - -void lex_panicf(lex_t *token, const char *str, ...) { +fn 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) { - 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) { +fn 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[] = { -#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) { +fn 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); } \ No newline at end of file diff --git a/src/core/core_lexer.h b/src/core/core_lexer.h new file mode 100644 index 0000000..dea1586 --- /dev/null +++ b/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); + diff --git a/src/core/mathx.c b/src/core/core_math.c similarity index 94% rename from src/core/mathx.c rename to src/core/core_math.c index daa7fac..d8ba317 100644 --- a/src/core/mathx.c +++ b/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. diff --git a/src/core/mathx.gen.c b/src/core/core_math.gen.c similarity index 100% rename from src/core/mathx.gen.c rename to src/core/core_math.gen.c diff --git a/src/core/core_math.h b/src/core/core_math.h new file mode 100644 index 0000000..4589965 --- /dev/null +++ b/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); diff --git a/src/core/math_gen.py b/src/core/core_math_gen.py similarity index 99% rename from src/core/math_gen.py rename to src/core/core_math_gen.py index 0a4ef07..c12478e 100644 --- a/src/core/math_gen.py +++ b/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__) diff --git a/src/core/platform_defines.h b/src/core/core_platform_defines.h similarity index 100% rename from src/core/platform_defines.h rename to src/core/core_platform_defines.h diff --git a/src/core/string8.c b/src/core/core_string.c similarity index 66% rename from src/core/string8.c rename to src/core/core_string.c index 6673224..24c50df 100644 --- a/src/core/string8.c +++ b/src/core/core_string.c @@ -1,20 +1,107 @@ #define s8_vsnprintf stbsp_vsnprintf -#define S8_FMT(ma, str, result) \ - va_list args1; \ - va_start(args1, str); \ - s8_t result = s8_vfmt(ma, str, args1); \ - va_end(args1) +fn i32 str_len(char *str) { + i32 i = 0; + while (str[i]) i += 1; + return i; +} +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; -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) { +fn 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) { - s8_t result; - result.str = (char *)string; - result.len = str_len(string); - return result; -} - -s8_t s8_get_name_no_ext(s8_t s) { +fn 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) { - 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) { +fn 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; } -// -// sb8_t -// -sb8_node_t *sb8_node(ma_arena_t *ma, s8_t str) { +fn sb8_node_t *sb8_create_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) { - sb8_node_t *node = sb8_node(list->arena, string); +fn sb8_node_t *sb8_append(sb8_t *list, s8_t 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; -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) { +fn 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) { - 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 u64 u64_from_hexchar(char c) { + 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; + } } -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}; -} -#if 0 - -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; +fn u64 u64_from_s8(s8_t s, u64 base) { + assert(base >= 2 && base <= 16); + u64 acc = 0; + for (i64 i = 0; i < s.len; i++) { + u64 num = u64_from_hexchar(s.str[i]); + if (num >= base) { + panicf("invalid number"); + break; } + acc *= base; + acc += num; } - assert(string.len == size - 1); - string.str[size] = 0; - return string; + return acc; } - -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 \ No newline at end of file diff --git a/src/core/core_string.h b/src/core/core_string.h new file mode 100644 index 0000000..7a23c36 --- /dev/null +++ b/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) diff --git a/src/core/type_info.c b/src/core/core_type_info.c similarity index 87% rename from src/core/type_info.c rename to src/core/core_type_info.c index 83f7f78..d0c59da 100644 --- a/src/core/type_info.c +++ b/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) -void *s8__deserial_data(ma_arena_t *arena, s8_t data, type_t *type) { +fn void *ti__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; } \ No newline at end of file diff --git a/src/core/type_info.h b/src/core/core_type_info.h similarity index 65% rename from src/core/type_info.h rename to src/core/core_type_info.h index 0ad68a1..12dbe86 100644 --- a/src/core/type_info.h +++ b/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); -i64 ti_enum_name_to_value(type_t *type, s8_t name); -type_member_t *ti_get_member(type_t *type, s8_t name); +glb type_t type__i8 = {type_kind_i8, s8_const_lit("i8"), sizeof(i8)}; +glb type_t type__i16 = {type_kind_i16, s8_const_lit("i16"), sizeof(i16)}; +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)}; -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, +glb 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)}, } }; - -type_t type__v2f32_t = { type_kind_struct, s8_const_lit("v2f32_t"), sizeof(v2f32_t), .count = 2, +glb 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); \ No newline at end of file +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); diff --git a/src/core/unicode.c b/src/core/core_unicode.c similarity index 84% rename from src/core/unicode.c rename to src/core/core_unicode.c index 367ddc6..2ae2ad1 100644 --- a/src/core/unicode.c +++ b/src/core/core_unicode.c @@ -1,34 +1,4 @@ -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; -}; - -utf32_result_t utf16_to_utf32(uint16_t *c, int max_advance) { +fn 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); diff --git a/src/core/core_unicode.h b/src/core/core_unicode.h new file mode 100644 index 0000000..9615fa8 --- /dev/null +++ b/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; +} + +*/ \ No newline at end of file diff --git a/src/core/log.c b/src/core/log.c index 690def4..5656279 100644 --- a/src/core/log.c +++ b/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); - core_desc.print(str.str); - core_desc.print("\n"); + S8_FMT(scratch.arena, _str, str8); + core_desc.print(str8); + 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("\n"); + core_desc.print(str); + core_desc.print(s8_lit("\n")); ma_end_scratch(scratch); } \ No newline at end of file diff --git a/src/core/scratch.c b/src/core/scratch.c deleted file mode 100644 index 2b0ed0f..0000000 --- a/src/core/scratch.c +++ /dev/null @@ -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)) \ No newline at end of file diff --git a/src/core/string.c b/src/core/string.c deleted file mode 100644 index f58969b..0000000 --- a/src/core/string.c +++ /dev/null @@ -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; -} \ No newline at end of file diff --git a/src/core_test/core_test_entry.c b/src/core_test/core_test_entry.c index 799c6ed..4be3ab0 100644 --- a/src/core_test/core_test_entry.c +++ b/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->next->s, s8_lit("another"))); + assert(s8_equal(sb.first->string, s8_lit("thing"))); + 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->next->s, s8_lit("|"))); - assert(s8_equal(sb.first->next->next->s, s8_lit("another"))); - assert(s8_equal(sb.first->next->next->next->s, s8_lit("|"))); + 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(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->next->s, s8_lit("b"))); - assert(s8_equal(sb.first->next->next->s, s8_lit("aa"))); - assert(s8_equal(sb.first->next->next->next->s, s8_lit("B"))); - assert(s8_equal(sb.first->next->next->next->next->s, s8_lit("aa"))); + 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(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->next->s, s8_lit("b"))); - assert(s8_equal(sb.first->next->next->s, s8_lit("aaBaa"))); + 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"))); } { @@ -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); } diff --git a/src/meta/parser.c b/src/meta/parser.c index d964659..737e444 100644 --- a/src/meta/parser.c +++ b/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)); } } } diff --git a/src/wasm_app/main.c b/src/wasm_app/main.c index 4a4c18a..9acde2d 100644 --- a/src/wasm_app/main.c +++ b/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);