krzosa/wasm_transcript_browser
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

string16 improvements

Browse Source
This commit is contained in:
Krzosa Karol
2025-04-04 08:25:47 +02:00
parent f6d5a1cf81
commit f3aa52ba3d
34 changed files with 637 additions and 699 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
build_file.c
View File

@@ -24,12 +24,12 @@
#include "src/testing/testing.meta.c" #include "src/testing/testing.meta.c"
void build_testing_target(void) { void build_testing_target(void) {
if (!cache_code_modified(s8_lit("../src/testing/testing_main.c"), s8_lit("testing.exe"))) { if (!cache_code_modified(s8("../src/testing/testing_main.c"), s8("testing.exe"))) {
return; return;
} }
if (PLATFORM_WINDOWS) { if (PLATFORM_WINDOWS) {
os_delete_file(s8_lit("testing.pdb")); os_delete_file(s8("testing.pdb"));
int ok = os_systemf( int ok = os_systemf(
"cl ../src/testing/testing_main.c -Fe:testing.exe -Fd:testing.pdb" "cl ../src/testing/testing_main.c -Fe:testing.exe -Fd:testing.pdb"
" -I ../src" " -I ../src"
@@ -57,7 +57,7 @@ void build_testing_target(void) {
} }
void build_win32_app_base_target(void) { void build_win32_app_base_target(void) {
if (!cache_code_modified(s8_lit("../src/app/app_win32_exe.c"), s8_lit("app_win32.exe"))) { if (!cache_code_modified(s8("../src/app/app_win32_exe.c"), s8("app_win32.exe"))) {
return; return;
} }
int ok = os_systemf( int ok = os_systemf(
@@ -71,7 +71,7 @@ void build_win32_app_base_target(void) {
} }
void build_text_editor_dll_target(void) { void build_text_editor_dll_target(void) {
if (!cache_code_modified(s8_lit("../src/text_editor/text_editor_main.c"), s8_lit("app.dll"))) { if (!cache_code_modified(s8("../src/text_editor/text_editor_main.c"), s8("app.dll"))) {
return; return;
} }
int ok = os_systemf( int ok = os_systemf(
@@ -85,7 +85,7 @@ void build_text_editor_dll_target(void) {
} }
void build_prototype_dll_target(void) { void build_prototype_dll_target(void) {
if (!cache_code_modified(s8_lit("../src/wasm_app/main.c"), s8_lit("app.dll"))) { if (!cache_code_modified(s8("../src/wasm_app/main.c"), s8("app.dll"))) {
return; return;
} }
int ok = os_systemf( int ok = os_systemf(
@@ -99,8 +99,8 @@ void build_prototype_dll_target(void) {
} }
void build_prototype_wasm_target(void) { void build_prototype_wasm_target(void) {
b32 html_code_modified = cache_code_modified(s8_lit("../src/app/app_wasm.html"), s8_lit("../package/index.html")); b32 html_code_modified = cache_code_modified(s8("../src/app/app_wasm.html"), s8("../package/index.html"));
b32 wasm_code_modified = cache_code_modified(s8_lit("../src/wasm_app/main.c"), s8_lit("main.wasm")); b32 wasm_code_modified = cache_code_modified(s8("../src/wasm_app/main.c"), s8("main.wasm"));
if (html_code_modified) { if (html_code_modified) {
os_copy("../src/app/app_wasm.html", "../package/index.html", os_copy_overwrite); os_copy("../src/app/app_wasm.html", "../package/index.html", os_copy_overwrite);
} }
@@ -119,7 +119,7 @@ void build_prototype_wasm_target(void) {
} }
void build_prototype_standalone_target(void) { void build_prototype_standalone_target(void) {
if (!cache_code_modified(s8_lit("../src/wasm_app/main.c"), s8_lit("standalone_app.exe"))) { if (!cache_code_modified(s8("../src/wasm_app/main.c"), s8("standalone_app.exe"))) {
return; return;
} }
@@ -134,7 +134,7 @@ void build_prototype_standalone_target(void) {
} }
void generate_math_code(ma_arena_t *arena) { void generate_math_code(ma_arena_t *arena) {
if (!cache_code_modified(s8_lit("../src/core/core_math_gen.py"), s8_null)) { if (!cache_code_modified(s8("../src/core/core_math_gen.py"), s8_null)) {
return; return;
} }
@@ -153,9 +153,9 @@ int main(int argc, char **argv) {
core_init(); core_init();
int ok = 0; int ok = 0;
SRC_SearchPaths.include_path = (char*[]){OS_GetAbsolutePath(&Perm, s8_lit("../src")).str}; SRC_SearchPaths.include_path = (char*[]){OS_GetAbsolutePath(&Perm, s8("../src")).str};
SRC_SearchPaths.include_path_count = 1; SRC_SearchPaths.include_path_count = 1;
cache_init(&Perm, s8_lit("cache_build_file")); cache_init(&Perm, s8("cache_build_file"));
generate_math_code(tcx->temp); generate_math_code(tcx->temp);
generate_ui_code(tcx->temp); generate_ui_code(tcx->temp);
@@ -177,6 +177,10 @@ int main(int argc, char **argv) {
os_systemf("start /D ..\\package ..\\package\\run_server.bat"); os_systemf("start /D ..\\package ..\\package\\run_server.bat");
} }
if (run_testing_target) {
build_testing_target();
}
if (run_prototype_standalone_target) { if (run_prototype_standalone_target) {
build_prototype_standalone_target(); build_prototype_standalone_target();
} }
@@ -193,10 +197,6 @@ int main(int argc, char **argv) {
build_text_editor_dll_target(); build_text_editor_dll_target();
} }
if (run_testing_target) {
build_testing_target();
}
if (run_prototype_wasm_target) { if (run_prototype_wasm_target) {
build_prototype_wasm_target(); build_prototype_wasm_target();
} }

362
src/app/app.gen.c
View File

@@ -1,76 +1,76 @@
// automatically generated using: C:\dev\wasm\src/app/app.meta.c // automatically generated using: C:\dev\wasm\src/app/app.meta.c
type_t type__app_key_t = { type_kind_enum, s8_const_lit("app_key_t"), sizeof(app_key_t), type_t type__app_key_t = { type_kind_enum, s8_const("app_key_t"), sizeof(app_key_t),
.members = (type_member_t[]){ .members = (type_member_t[]){
{.name = s8_const_lit("app_key_null"), .value = app_key_null}, {.name = s8_const("app_key_null"), .value = app_key_null},
{.name = s8_const_lit("app_key_1"), .value = app_key_1}, {.name = s8_const("app_key_1"), .value = app_key_1},
{.name = s8_const_lit("app_key_2"), .value = app_key_2}, {.name = s8_const("app_key_2"), .value = app_key_2},
{.name = s8_const_lit("app_key_3"), .value = app_key_3}, {.name = s8_const("app_key_3"), .value = app_key_3},
{.name = s8_const_lit("app_key_4"), .value = app_key_4}, {.name = s8_const("app_key_4"), .value = app_key_4},
{.name = s8_const_lit("app_key_5"), .value = app_key_5}, {.name = s8_const("app_key_5"), .value = app_key_5},
{.name = s8_const_lit("app_key_6"), .value = app_key_6}, {.name = s8_const("app_key_6"), .value = app_key_6},
{.name = s8_const_lit("app_key_7"), .value = app_key_7}, {.name = s8_const("app_key_7"), .value = app_key_7},
{.name = s8_const_lit("app_key_8"), .value = app_key_8}, {.name = s8_const("app_key_8"), .value = app_key_8},
{.name = s8_const_lit("app_key_9"), .value = app_key_9}, {.name = s8_const("app_key_9"), .value = app_key_9},
{.name = s8_const_lit("app_key_0"), .value = app_key_0}, {.name = s8_const("app_key_0"), .value = app_key_0},
{.name = s8_const_lit("app_key_f1"), .value = app_key_f1}, {.name = s8_const("app_key_f1"), .value = app_key_f1},
{.name = s8_const_lit("app_key_f2"), .value = app_key_f2}, {.name = s8_const("app_key_f2"), .value = app_key_f2},
{.name = s8_const_lit("app_key_f3"), .value = app_key_f3}, {.name = s8_const("app_key_f3"), .value = app_key_f3},
{.name = s8_const_lit("app_key_f4"), .value = app_key_f4}, {.name = s8_const("app_key_f4"), .value = app_key_f4},
{.name = s8_const_lit("app_key_f5"), .value = app_key_f5}, {.name = s8_const("app_key_f5"), .value = app_key_f5},
{.name = s8_const_lit("app_key_f6"), .value = app_key_f6}, {.name = s8_const("app_key_f6"), .value = app_key_f6},
{.name = s8_const_lit("app_key_f7"), .value = app_key_f7}, {.name = s8_const("app_key_f7"), .value = app_key_f7},
{.name = s8_const_lit("app_key_f8"), .value = app_key_f8}, {.name = s8_const("app_key_f8"), .value = app_key_f8},
{.name = s8_const_lit("app_key_f9"), .value = app_key_f9}, {.name = s8_const("app_key_f9"), .value = app_key_f9},
{.name = s8_const_lit("app_key_f10"), .value = app_key_f10}, {.name = s8_const("app_key_f10"), .value = app_key_f10},
{.name = s8_const_lit("app_key_f11"), .value = app_key_f11}, {.name = s8_const("app_key_f11"), .value = app_key_f11},
{.name = s8_const_lit("app_key_f12"), .value = app_key_f12}, {.name = s8_const("app_key_f12"), .value = app_key_f12},
{.name = s8_const_lit("app_key_a"), .value = app_key_a}, {.name = s8_const("app_key_a"), .value = app_key_a},
{.name = s8_const_lit("app_key_b"), .value = app_key_b}, {.name = s8_const("app_key_b"), .value = app_key_b},
{.name = s8_const_lit("app_key_c"), .value = app_key_c}, {.name = s8_const("app_key_c"), .value = app_key_c},
{.name = s8_const_lit("app_key_d"), .value = app_key_d}, {.name = s8_const("app_key_d"), .value = app_key_d},
{.name = s8_const_lit("app_key_e"), .value = app_key_e}, {.name = s8_const("app_key_e"), .value = app_key_e},
{.name = s8_const_lit("app_key_f"), .value = app_key_f}, {.name = s8_const("app_key_f"), .value = app_key_f},
{.name = s8_const_lit("app_key_g"), .value = app_key_g}, {.name = s8_const("app_key_g"), .value = app_key_g},
{.name = s8_const_lit("app_key_h"), .value = app_key_h}, {.name = s8_const("app_key_h"), .value = app_key_h},
{.name = s8_const_lit("app_key_i"), .value = app_key_i}, {.name = s8_const("app_key_i"), .value = app_key_i},
{.name = s8_const_lit("app_key_j"), .value = app_key_j}, {.name = s8_const("app_key_j"), .value = app_key_j},
{.name = s8_const_lit("app_key_k"), .value = app_key_k}, {.name = s8_const("app_key_k"), .value = app_key_k},
{.name = s8_const_lit("app_key_l"), .value = app_key_l}, {.name = s8_const("app_key_l"), .value = app_key_l},
{.name = s8_const_lit("app_key_m"), .value = app_key_m}, {.name = s8_const("app_key_m"), .value = app_key_m},
{.name = s8_const_lit("app_key_n"), .value = app_key_n}, {.name = s8_const("app_key_n"), .value = app_key_n},
{.name = s8_const_lit("app_key_o"), .value = app_key_o}, {.name = s8_const("app_key_o"), .value = app_key_o},
{.name = s8_const_lit("app_key_p"), .value = app_key_p}, {.name = s8_const("app_key_p"), .value = app_key_p},
{.name = s8_const_lit("app_key_q"), .value = app_key_q}, {.name = s8_const("app_key_q"), .value = app_key_q},
{.name = s8_const_lit("app_key_r"), .value = app_key_r}, {.name = s8_const("app_key_r"), .value = app_key_r},
{.name = s8_const_lit("app_key_s"), .value = app_key_s}, {.name = s8_const("app_key_s"), .value = app_key_s},
{.name = s8_const_lit("app_key__t"), .value = app_key__t}, {.name = s8_const("app_key__t"), .value = app_key__t},
{.name = s8_const_lit("app_key_u"), .value = app_key_u}, {.name = s8_const("app_key_u"), .value = app_key_u},
{.name = s8_const_lit("app_key_v"), .value = app_key_v}, {.name = s8_const("app_key_v"), .value = app_key_v},
{.name = s8_const_lit("app_key_w"), .value = app_key_w}, {.name = s8_const("app_key_w"), .value = app_key_w},
{.name = s8_const_lit("app_key_x"), .value = app_key_x}, {.name = s8_const("app_key_x"), .value = app_key_x},
{.name = s8_const_lit("app_key_y"), .value = app_key_y}, {.name = s8_const("app_key_y"), .value = app_key_y},
{.name = s8_const_lit("app_key_z"), .value = app_key_z}, {.name = s8_const("app_key_z"), .value = app_key_z},
{.name = s8_const_lit("app_key_space"), .value = app_key_space}, {.name = s8_const("app_key_space"), .value = app_key_space},
{.name = s8_const_lit("app_key_enter"), .value = app_key_enter}, {.name = s8_const("app_key_enter"), .value = app_key_enter},
{.name = s8_const_lit("app_key_escape"), .value = app_key_escape}, {.name = s8_const("app_key_escape"), .value = app_key_escape},
{.name = s8_const_lit("app_key_left"), .value = app_key_left}, {.name = s8_const("app_key_left"), .value = app_key_left},
{.name = s8_const_lit("app_key_up"), .value = app_key_up}, {.name = s8_const("app_key_up"), .value = app_key_up},
{.name = s8_const_lit("app_key_right"), .value = app_key_right}, {.name = s8_const("app_key_right"), .value = app_key_right},
{.name = s8_const_lit("app_key_down"), .value = app_key_down}, {.name = s8_const("app_key_down"), .value = app_key_down},
{.name = s8_const_lit("app_key_tab"), .value = app_key_tab}, {.name = s8_const("app_key_tab"), .value = app_key_tab},
{.name = s8_const_lit("app_key_backspace"), .value = app_key_backspace}, {.name = s8_const("app_key_backspace"), .value = app_key_backspace},
{.name = s8_const_lit("app_key_control"), .value = app_key_control}, {.name = s8_const("app_key_control"), .value = app_key_control},
{.name = s8_const_lit("app_key_shift"), .value = app_key_shift}, {.name = s8_const("app_key_shift"), .value = app_key_shift},
{.name = s8_const_lit("app_key_alt"), .value = app_key_alt}, {.name = s8_const("app_key_alt"), .value = app_key_alt},
{.name = s8_const_lit("app_key_meta"), .value = app_key_meta}, {.name = s8_const("app_key_meta"), .value = app_key_meta},
{.name = s8_const_lit("app_key_caps_lock"), .value = app_key_caps_lock}, {.name = s8_const("app_key_caps_lock"), .value = app_key_caps_lock},
{.name = s8_const_lit("app_key_delete"), .value = app_key_delete}, {.name = s8_const("app_key_delete"), .value = app_key_delete},
{.name = s8_const_lit("app_key_home"), .value = app_key_home}, {.name = s8_const("app_key_home"), .value = app_key_home},
{.name = s8_const_lit("app_key_end"), .value = app_key_end}, {.name = s8_const("app_key_end"), .value = app_key_end},
{.name = s8_const_lit("app_key_insert"), .value = app_key_insert}, {.name = s8_const("app_key_insert"), .value = app_key_insert},
{.name = s8_const_lit("app_key_page_up"), .value = app_key_page_up}, {.name = s8_const("app_key_page_up"), .value = app_key_page_up},
{.name = s8_const_lit("app_key_page_down"), .value = app_key_page_down}, {.name = s8_const("app_key_page_down"), .value = app_key_page_down},
}, },
.count = 69, .count = 69,
}; };
@@ -79,75 +79,75 @@ type_t type__app_key_t = { type_kind_enum, s8_const_lit("app_key_t"), sizeof(app
typedef struct { app_key_t key; b32 filter_out; } wasm_key_map_t; typedef struct { app_key_t key; b32 filter_out; } wasm_key_map_t;
wasm_key_map_t wasm_map_key_string_to_app_key(s8_t key) { wasm_key_map_t wasm_map_key_string_to_app_key(s8_t key) {
if (0) {} if (0) {}
else if (s8_are_equal_ex(key, s8_lit("1"), s8_ignore_case)) return (wasm_key_map_t){app_key_1, 0}; else if (s8_are_equal_ex(key, s8("1"), s8_ignore_case)) return (wasm_key_map_t){app_key_1, 0};
else if (s8_are_equal_ex(key, s8_lit("2"), s8_ignore_case)) return (wasm_key_map_t){app_key_2, 0}; else if (s8_are_equal_ex(key, s8("2"), s8_ignore_case)) return (wasm_key_map_t){app_key_2, 0};
else if (s8_are_equal_ex(key, s8_lit("3"), s8_ignore_case)) return (wasm_key_map_t){app_key_3, 0}; else if (s8_are_equal_ex(key, s8("3"), s8_ignore_case)) return (wasm_key_map_t){app_key_3, 0};
else if (s8_are_equal_ex(key, s8_lit("4"), s8_ignore_case)) return (wasm_key_map_t){app_key_4, 0}; else if (s8_are_equal_ex(key, s8("4"), s8_ignore_case)) return (wasm_key_map_t){app_key_4, 0};
else if (s8_are_equal_ex(key, s8_lit("5"), s8_ignore_case)) return (wasm_key_map_t){app_key_5, 0}; else if (s8_are_equal_ex(key, s8("5"), s8_ignore_case)) return (wasm_key_map_t){app_key_5, 0};
else if (s8_are_equal_ex(key, s8_lit("6"), s8_ignore_case)) return (wasm_key_map_t){app_key_6, 0}; else if (s8_are_equal_ex(key, s8("6"), s8_ignore_case)) return (wasm_key_map_t){app_key_6, 0};
else if (s8_are_equal_ex(key, s8_lit("7"), s8_ignore_case)) return (wasm_key_map_t){app_key_7, 0}; else if (s8_are_equal_ex(key, s8("7"), s8_ignore_case)) return (wasm_key_map_t){app_key_7, 0};
else if (s8_are_equal_ex(key, s8_lit("8"), s8_ignore_case)) return (wasm_key_map_t){app_key_8, 0}; else if (s8_are_equal_ex(key, s8("8"), s8_ignore_case)) return (wasm_key_map_t){app_key_8, 0};
else if (s8_are_equal_ex(key, s8_lit("9"), s8_ignore_case)) return (wasm_key_map_t){app_key_9, 0}; else if (s8_are_equal_ex(key, s8("9"), s8_ignore_case)) return (wasm_key_map_t){app_key_9, 0};
else if (s8_are_equal_ex(key, s8_lit("0"), s8_ignore_case)) return (wasm_key_map_t){app_key_0, 0}; else if (s8_are_equal_ex(key, s8("0"), s8_ignore_case)) return (wasm_key_map_t){app_key_0, 0};
else if (s8_are_equal_ex(key, s8_lit("F1"), s8_ignore_case)) return (wasm_key_map_t){app_key_f1, 1}; else if (s8_are_equal_ex(key, s8("F1"), s8_ignore_case)) return (wasm_key_map_t){app_key_f1, 1};
else if (s8_are_equal_ex(key, s8_lit("F2"), s8_ignore_case)) return (wasm_key_map_t){app_key_f2, 1}; else if (s8_are_equal_ex(key, s8("F2"), s8_ignore_case)) return (wasm_key_map_t){app_key_f2, 1};
else if (s8_are_equal_ex(key, s8_lit("F3"), s8_ignore_case)) return (wasm_key_map_t){app_key_f3, 1}; else if (s8_are_equal_ex(key, s8("F3"), s8_ignore_case)) return (wasm_key_map_t){app_key_f3, 1};
else if (s8_are_equal_ex(key, s8_lit("F4"), s8_ignore_case)) return (wasm_key_map_t){app_key_f4, 1}; else if (s8_are_equal_ex(key, s8("F4"), s8_ignore_case)) return (wasm_key_map_t){app_key_f4, 1};
else if (s8_are_equal_ex(key, s8_lit("F5"), s8_ignore_case)) return (wasm_key_map_t){app_key_f5, 1}; else if (s8_are_equal_ex(key, s8("F5"), s8_ignore_case)) return (wasm_key_map_t){app_key_f5, 1};
else if (s8_are_equal_ex(key, s8_lit("F6"), s8_ignore_case)) return (wasm_key_map_t){app_key_f6, 1}; else if (s8_are_equal_ex(key, s8("F6"), s8_ignore_case)) return (wasm_key_map_t){app_key_f6, 1};
else if (s8_are_equal_ex(key, s8_lit("F7"), s8_ignore_case)) return (wasm_key_map_t){app_key_f7, 1}; else if (s8_are_equal_ex(key, s8("F7"), s8_ignore_case)) return (wasm_key_map_t){app_key_f7, 1};
else if (s8_are_equal_ex(key, s8_lit("F8"), s8_ignore_case)) return (wasm_key_map_t){app_key_f8, 1}; else if (s8_are_equal_ex(key, s8("F8"), s8_ignore_case)) return (wasm_key_map_t){app_key_f8, 1};
else if (s8_are_equal_ex(key, s8_lit("F9"), s8_ignore_case)) return (wasm_key_map_t){app_key_f9, 1}; else if (s8_are_equal_ex(key, s8("F9"), s8_ignore_case)) return (wasm_key_map_t){app_key_f9, 1};
else if (s8_are_equal_ex(key, s8_lit("F10"), s8_ignore_case)) return (wasm_key_map_t){app_key_f10, 1}; else if (s8_are_equal_ex(key, s8("F10"), s8_ignore_case)) return (wasm_key_map_t){app_key_f10, 1};
else if (s8_are_equal_ex(key, s8_lit("F11"), s8_ignore_case)) return (wasm_key_map_t){app_key_f11, 1}; else if (s8_are_equal_ex(key, s8("F11"), s8_ignore_case)) return (wasm_key_map_t){app_key_f11, 1};
else if (s8_are_equal_ex(key, s8_lit("F12"), s8_ignore_case)) return (wasm_key_map_t){app_key_f12, 1}; else if (s8_are_equal_ex(key, s8("F12"), s8_ignore_case)) return (wasm_key_map_t){app_key_f12, 1};
else if (s8_are_equal_ex(key, s8_lit("a"), s8_ignore_case)) return (wasm_key_map_t){app_key_a, 0}; else if (s8_are_equal_ex(key, s8("a"), s8_ignore_case)) return (wasm_key_map_t){app_key_a, 0};
else if (s8_are_equal_ex(key, s8_lit("b"), s8_ignore_case)) return (wasm_key_map_t){app_key_b, 0}; else if (s8_are_equal_ex(key, s8("b"), s8_ignore_case)) return (wasm_key_map_t){app_key_b, 0};
else if (s8_are_equal_ex(key, s8_lit("c"), s8_ignore_case)) return (wasm_key_map_t){app_key_c, 0}; else if (s8_are_equal_ex(key, s8("c"), s8_ignore_case)) return (wasm_key_map_t){app_key_c, 0};
else if (s8_are_equal_ex(key, s8_lit("d"), s8_ignore_case)) return (wasm_key_map_t){app_key_d, 0}; else if (s8_are_equal_ex(key, s8("d"), s8_ignore_case)) return (wasm_key_map_t){app_key_d, 0};
else if (s8_are_equal_ex(key, s8_lit("e"), s8_ignore_case)) return (wasm_key_map_t){app_key_e, 0}; else if (s8_are_equal_ex(key, s8("e"), s8_ignore_case)) return (wasm_key_map_t){app_key_e, 0};
else if (s8_are_equal_ex(key, s8_lit("f"), s8_ignore_case)) return (wasm_key_map_t){app_key_f, 0}; else if (s8_are_equal_ex(key, s8("f"), s8_ignore_case)) return (wasm_key_map_t){app_key_f, 0};
else if (s8_are_equal_ex(key, s8_lit("g"), s8_ignore_case)) return (wasm_key_map_t){app_key_g, 0}; else if (s8_are_equal_ex(key, s8("g"), s8_ignore_case)) return (wasm_key_map_t){app_key_g, 0};
else if (s8_are_equal_ex(key, s8_lit("h"), s8_ignore_case)) return (wasm_key_map_t){app_key_h, 0}; else if (s8_are_equal_ex(key, s8("h"), s8_ignore_case)) return (wasm_key_map_t){app_key_h, 0};
else if (s8_are_equal_ex(key, s8_lit("i"), s8_ignore_case)) return (wasm_key_map_t){app_key_i, 0}; else if (s8_are_equal_ex(key, s8("i"), s8_ignore_case)) return (wasm_key_map_t){app_key_i, 0};
else if (s8_are_equal_ex(key, s8_lit("j"), s8_ignore_case)) return (wasm_key_map_t){app_key_j, 0}; else if (s8_are_equal_ex(key, s8("j"), s8_ignore_case)) return (wasm_key_map_t){app_key_j, 0};
else if (s8_are_equal_ex(key, s8_lit("k"), s8_ignore_case)) return (wasm_key_map_t){app_key_k, 0}; else if (s8_are_equal_ex(key, s8("k"), s8_ignore_case)) return (wasm_key_map_t){app_key_k, 0};
else if (s8_are_equal_ex(key, s8_lit("l"), s8_ignore_case)) return (wasm_key_map_t){app_key_l, 0}; else if (s8_are_equal_ex(key, s8("l"), s8_ignore_case)) return (wasm_key_map_t){app_key_l, 0};
else if (s8_are_equal_ex(key, s8_lit("m"), s8_ignore_case)) return (wasm_key_map_t){app_key_m, 0}; else if (s8_are_equal_ex(key, s8("m"), s8_ignore_case)) return (wasm_key_map_t){app_key_m, 0};
else if (s8_are_equal_ex(key, s8_lit("n"), s8_ignore_case)) return (wasm_key_map_t){app_key_n, 0}; else if (s8_are_equal_ex(key, s8("n"), s8_ignore_case)) return (wasm_key_map_t){app_key_n, 0};
else if (s8_are_equal_ex(key, s8_lit("o"), s8_ignore_case)) return (wasm_key_map_t){app_key_o, 0}; else if (s8_are_equal_ex(key, s8("o"), s8_ignore_case)) return (wasm_key_map_t){app_key_o, 0};
else if (s8_are_equal_ex(key, s8_lit("p"), s8_ignore_case)) return (wasm_key_map_t){app_key_p, 0}; else if (s8_are_equal_ex(key, s8("p"), s8_ignore_case)) return (wasm_key_map_t){app_key_p, 0};
else if (s8_are_equal_ex(key, s8_lit("q"), s8_ignore_case)) return (wasm_key_map_t){app_key_q, 0}; else if (s8_are_equal_ex(key, s8("q"), s8_ignore_case)) return (wasm_key_map_t){app_key_q, 0};
else if (s8_are_equal_ex(key, s8_lit("r"), s8_ignore_case)) return (wasm_key_map_t){app_key_r, 0}; else if (s8_are_equal_ex(key, s8("r"), s8_ignore_case)) return (wasm_key_map_t){app_key_r, 0};
else if (s8_are_equal_ex(key, s8_lit("s"), s8_ignore_case)) return (wasm_key_map_t){app_key_s, 0}; else if (s8_are_equal_ex(key, s8("s"), s8_ignore_case)) return (wasm_key_map_t){app_key_s, 0};
else if (s8_are_equal_ex(key, s8_lit("t"), s8_ignore_case)) return (wasm_key_map_t){app_key__t, 0}; else if (s8_are_equal_ex(key, s8("t"), s8_ignore_case)) return (wasm_key_map_t){app_key__t, 0};
else if (s8_are_equal_ex(key, s8_lit("u"), s8_ignore_case)) return (wasm_key_map_t){app_key_u, 0}; else if (s8_are_equal_ex(key, s8("u"), s8_ignore_case)) return (wasm_key_map_t){app_key_u, 0};
else if (s8_are_equal_ex(key, s8_lit("v"), s8_ignore_case)) return (wasm_key_map_t){app_key_v, 0}; else if (s8_are_equal_ex(key, s8("v"), s8_ignore_case)) return (wasm_key_map_t){app_key_v, 0};
else if (s8_are_equal_ex(key, s8_lit("w"), s8_ignore_case)) return (wasm_key_map_t){app_key_w, 0}; else if (s8_are_equal_ex(key, s8("w"), s8_ignore_case)) return (wasm_key_map_t){app_key_w, 0};
else if (s8_are_equal_ex(key, s8_lit("x"), s8_ignore_case)) return (wasm_key_map_t){app_key_x, 0}; else if (s8_are_equal_ex(key, s8("x"), s8_ignore_case)) return (wasm_key_map_t){app_key_x, 0};
else if (s8_are_equal_ex(key, s8_lit("y"), s8_ignore_case)) return (wasm_key_map_t){app_key_y, 0}; else if (s8_are_equal_ex(key, s8("y"), s8_ignore_case)) return (wasm_key_map_t){app_key_y, 0};
else if (s8_are_equal_ex(key, s8_lit("z"), s8_ignore_case)) return (wasm_key_map_t){app_key_z, 0}; else if (s8_are_equal_ex(key, s8("z"), s8_ignore_case)) return (wasm_key_map_t){app_key_z, 0};
else if (s8_are_equal_ex(key, s8_lit(" "), s8_ignore_case)) return (wasm_key_map_t){app_key_space, 0}; else if (s8_are_equal_ex(key, s8(" "), s8_ignore_case)) return (wasm_key_map_t){app_key_space, 0};
else if (s8_are_equal_ex(key, s8_lit("Enter"), s8_ignore_case)) return (wasm_key_map_t){app_key_enter, 1}; else if (s8_are_equal_ex(key, s8("Enter"), s8_ignore_case)) return (wasm_key_map_t){app_key_enter, 1};
else if (s8_are_equal_ex(key, s8_lit("Escape"), s8_ignore_case)) return (wasm_key_map_t){app_key_escape, 1}; else if (s8_are_equal_ex(key, s8("Escape"), s8_ignore_case)) return (wasm_key_map_t){app_key_escape, 1};
else if (s8_are_equal_ex(key, s8_lit("ArrowLeft"), s8_ignore_case)) return (wasm_key_map_t){app_key_left, 1}; else if (s8_are_equal_ex(key, s8("ArrowLeft"), s8_ignore_case)) return (wasm_key_map_t){app_key_left, 1};
else if (s8_are_equal_ex(key, s8_lit("ArrowUp"), s8_ignore_case)) return (wasm_key_map_t){app_key_up, 1}; else if (s8_are_equal_ex(key, s8("ArrowUp"), s8_ignore_case)) return (wasm_key_map_t){app_key_up, 1};
else if (s8_are_equal_ex(key, s8_lit("ArrowRight"), s8_ignore_case)) return (wasm_key_map_t){app_key_right, 1}; else if (s8_are_equal_ex(key, s8("ArrowRight"), s8_ignore_case)) return (wasm_key_map_t){app_key_right, 1};
else if (s8_are_equal_ex(key, s8_lit("ArrowDown"), s8_ignore_case)) return (wasm_key_map_t){app_key_down, 1}; else if (s8_are_equal_ex(key, s8("ArrowDown"), s8_ignore_case)) return (wasm_key_map_t){app_key_down, 1};
else if (s8_are_equal_ex(key, s8_lit("Tab"), s8_ignore_case)) return (wasm_key_map_t){app_key_tab, 1}; else if (s8_are_equal_ex(key, s8("Tab"), s8_ignore_case)) return (wasm_key_map_t){app_key_tab, 1};
else if (s8_are_equal_ex(key, s8_lit("Backspace"), s8_ignore_case)) return (wasm_key_map_t){app_key_backspace, 1}; else if (s8_are_equal_ex(key, s8("Backspace"), s8_ignore_case)) return (wasm_key_map_t){app_key_backspace, 1};
else if (s8_are_equal_ex(key, s8_lit("Control"), s8_ignore_case)) return (wasm_key_map_t){app_key_control, 1}; else if (s8_are_equal_ex(key, s8("Control"), s8_ignore_case)) return (wasm_key_map_t){app_key_control, 1};
else if (s8_are_equal_ex(key, s8_lit("Shift"), s8_ignore_case)) return (wasm_key_map_t){app_key_shift, 1}; else if (s8_are_equal_ex(key, s8("Shift"), s8_ignore_case)) return (wasm_key_map_t){app_key_shift, 1};
else if (s8_are_equal_ex(key, s8_lit("Alt"), s8_ignore_case)) return (wasm_key_map_t){app_key_alt, 1}; else if (s8_are_equal_ex(key, s8("Alt"), s8_ignore_case)) return (wasm_key_map_t){app_key_alt, 1};
else if (s8_are_equal_ex(key, s8_lit("AltGraph"), s8_ignore_case)) return (wasm_key_map_t){app_key_alt, 1}; else if (s8_are_equal_ex(key, s8("AltGraph"), s8_ignore_case)) return (wasm_key_map_t){app_key_alt, 1};
else if (s8_are_equal_ex(key, s8_lit("Meta"), s8_ignore_case)) return (wasm_key_map_t){app_key_meta, 1}; else if (s8_are_equal_ex(key, s8("Meta"), s8_ignore_case)) return (wasm_key_map_t){app_key_meta, 1};
else if (s8_are_equal_ex(key, s8_lit("CapsLock"), s8_ignore_case)) return (wasm_key_map_t){app_key_caps_lock, 1}; else if (s8_are_equal_ex(key, s8("CapsLock"), s8_ignore_case)) return (wasm_key_map_t){app_key_caps_lock, 1};
else if (s8_are_equal_ex(key, s8_lit("Delete"), s8_ignore_case)) return (wasm_key_map_t){app_key_delete, 1}; else if (s8_are_equal_ex(key, s8("Delete"), s8_ignore_case)) return (wasm_key_map_t){app_key_delete, 1};
else if (s8_are_equal_ex(key, s8_lit("Home"), s8_ignore_case)) return (wasm_key_map_t){app_key_home, 1}; else if (s8_are_equal_ex(key, s8("Home"), s8_ignore_case)) return (wasm_key_map_t){app_key_home, 1};
else if (s8_are_equal_ex(key, s8_lit("End"), s8_ignore_case)) return (wasm_key_map_t){app_key_end, 1}; else if (s8_are_equal_ex(key, s8("End"), s8_ignore_case)) return (wasm_key_map_t){app_key_end, 1};
else if (s8_are_equal_ex(key, s8_lit("Insert"), s8_ignore_case)) return (wasm_key_map_t){app_key_insert, 1}; else if (s8_are_equal_ex(key, s8("Insert"), s8_ignore_case)) return (wasm_key_map_t){app_key_insert, 1};
else if (s8_are_equal_ex(key, s8_lit("PageUp"), s8_ignore_case)) return (wasm_key_map_t){app_key_page_up, 1}; else if (s8_are_equal_ex(key, s8("PageUp"), s8_ignore_case)) return (wasm_key_map_t){app_key_page_up, 1};
else if (s8_are_equal_ex(key, s8_lit("PageDown"), s8_ignore_case)) return (wasm_key_map_t){app_key_page_down, 1}; else if (s8_are_equal_ex(key, s8("PageDown"), s8_ignore_case)) return (wasm_key_map_t){app_key_page_down, 1};
return (wasm_key_map_t){0}; return (wasm_key_map_t){0};
} }
#endif #endif
@@ -229,61 +229,61 @@ app_key_t w32_map_wparam_to_app_key(WPARAM wparam) {
} }
} }
#endif/*C:\dev\wasm\src/app/app.meta.c(135)*/ #endif/*C:\dev\wasm\src/app/app.meta.c(135)*/
type_t type__app_mouse_button_t = { type_kind_enum, s8_const_lit("app_mouse_button_t"), sizeof(app_mouse_button_t), type_t type__app_mouse_button_t = { type_kind_enum, s8_const("app_mouse_button_t"), sizeof(app_mouse_button_t),
.members = (type_member_t[]){ .members = (type_member_t[]){
{.name = s8_const_lit("app_mouse_button_null"), .value = app_mouse_button_null}, {.name = s8_const("app_mouse_button_null"), .value = app_mouse_button_null},
{.name = s8_const_lit("app_mouse_button_left"), .value = app_mouse_button_left}, {.name = s8_const("app_mouse_button_left"), .value = app_mouse_button_left},
{.name = s8_const_lit("app_mouse_button_middle"), .value = app_mouse_button_middle}, {.name = s8_const("app_mouse_button_middle"), .value = app_mouse_button_middle},
{.name = s8_const_lit("app_mouse_button_right"), .value = app_mouse_button_right}, {.name = s8_const("app_mouse_button_right"), .value = app_mouse_button_right},
{.name = s8_const_lit("app_mouse_button_count"), .value = app_mouse_button_count}, {.name = s8_const("app_mouse_button_count"), .value = app_mouse_button_count},
}, },
.count = 5, .count = 5,
}; };
type_t type__app_event_kind_t = { type_kind_enum, s8_const_lit("app_event_kind_t"), sizeof(app_event_kind_t), type_t type__app_event_kind_t = { type_kind_enum, s8_const("app_event_kind_t"), sizeof(app_event_kind_t),
.members = (type_member_t[]){ .members = (type_member_t[]){
{.name = s8_const_lit("app_event_kind_null"), .value = app_event_kind_null}, {.name = s8_const("app_event_kind_null"), .value = app_event_kind_null},
{.name = s8_const_lit("app_event_kind_update"), .value = app_event_kind_update}, {.name = s8_const("app_event_kind_update"), .value = app_event_kind_update},
{.name = s8_const_lit("app_event_kind_init"), .value = app_event_kind_init}, {.name = s8_const("app_event_kind_init"), .value = app_event_kind_init},
{.name = s8_const_lit("app_event_kind_reload"), .value = app_event_kind_reload}, {.name = s8_const("app_event_kind_reload"), .value = app_event_kind_reload},
{.name = s8_const_lit("app_event_kind_unload"), .value = app_event_kind_unload}, {.name = s8_const("app_event_kind_unload"), .value = app_event_kind_unload},
{.name = s8_const_lit("app_event_kind_text"), .value = app_event_kind_text}, {.name = s8_const("app_event_kind_text"), .value = app_event_kind_text},
{.name = s8_const_lit("app_event_kind_key_down"), .value = app_event_kind_key_down}, {.name = s8_const("app_event_kind_key_down"), .value = app_event_kind_key_down},
{.name = s8_const_lit("app_event_kind_key_up"), .value = app_event_kind_key_up}, {.name = s8_const("app_event_kind_key_up"), .value = app_event_kind_key_up},
{.name = s8_const_lit("app_event_kind_mouse_down"), .value = app_event_kind_mouse_down}, {.name = s8_const("app_event_kind_mouse_down"), .value = app_event_kind_mouse_down},
{.name = s8_const_lit("app_event_kind_mouse_up"), .value = app_event_kind_mouse_up}, {.name = s8_const("app_event_kind_mouse_up"), .value = app_event_kind_mouse_up},
{.name = s8_const_lit("app_event_kind_mouse_wheel"), .value = app_event_kind_mouse_wheel}, {.name = s8_const("app_event_kind_mouse_wheel"), .value = app_event_kind_mouse_wheel},
{.name = s8_const_lit("app_event_kind_mouse_move"), .value = app_event_kind_mouse_move}, {.name = s8_const("app_event_kind_mouse_move"), .value = app_event_kind_mouse_move},
{.name = s8_const_lit("app_event_kind_count"), .value = app_event_kind_count}, {.name = s8_const("app_event_kind_count"), .value = app_event_kind_count},
}, },
.count = 13, .count = 13,
}; };
type_t type__app_event_t = { type_kind_struct, s8_const_lit("app_event_t"), sizeof(app_event_t), type_t type__app_event_t = { type_kind_struct, s8_const("app_event_t"), sizeof(app_event_t),
.members = (type_member_t[]){ .members = (type_member_t[]){
{.name = s8_const_lit("id"), .type = &type__u64, .offset = offsetof(app_event_t, id), .dont_serialize = 0}, {.name = s8_const("id"), .type = &type__u64, .offset = offsetof(app_event_t, id), .dont_serialize = 0},
{.name = s8_const_lit("next"), .type = &(type_t){type_kind_pointer, s8_const_lit("app_event_t*"), sizeof(void *), .base = &type__app_event_t}, .offset = offsetof(app_event_t, next), .dont_serialize = 0}, {.name = s8_const("next"), .type = &(type_t){type_kind_pointer, s8_const("app_event_t*"), sizeof(void *), .base = &type__app_event_t}, .offset = offsetof(app_event_t, next), .dont_serialize = 0},
{.name = s8_const_lit("kind"), .type = &type__app_event_kind_t, .offset = offsetof(app_event_t, kind), .dont_serialize = 0}, {.name = s8_const("kind"), .type = &type__app_event_kind_t, .offset = offsetof(app_event_t, kind), .dont_serialize = 0},
{.name = s8_const_lit("mouse_button"), .type = &type__app_mouse_button_t, .offset = offsetof(app_event_t, mouse_button), .dont_serialize = 0}, {.name = s8_const("mouse_button"), .type = &type__app_mouse_button_t, .offset = offsetof(app_event_t, mouse_button), .dont_serialize = 0},
{.name = s8_const_lit("key"), .type = &type__app_key_t, .offset = offsetof(app_event_t, key), .dont_serialize = 0}, {.name = s8_const("key"), .type = &type__app_key_t, .offset = offsetof(app_event_t, key), .dont_serialize = 0},
{.name = s8_const_lit("text"), .type = &type__s8_t, .offset = offsetof(app_event_t, text), .dont_serialize = 0}, {.name = s8_const("text"), .type = &type__s8_t, .offset = offsetof(app_event_t, text), .dont_serialize = 0},
{.name = s8_const_lit("mouse_wheel_delta"), .type = &type__v3f32_t, .offset = offsetof(app_event_t, mouse_wheel_delta), .dont_serialize = 0}, {.name = s8_const("mouse_wheel_delta"), .type = &type__v3f32_t, .offset = offsetof(app_event_t, mouse_wheel_delta), .dont_serialize = 0},
{.name = s8_const_lit("ctrl"), .type = &type__b8, .offset = offsetof(app_event_t, ctrl), .dont_serialize = 0}, {.name = s8_const("ctrl"), .type = &type__b8, .offset = offsetof(app_event_t, ctrl), .dont_serialize = 0},
{.name = s8_const_lit("shift"), .type = &type__b8, .offset = offsetof(app_event_t, shift), .dont_serialize = 0}, {.name = s8_const("shift"), .type = &type__b8, .offset = offsetof(app_event_t, shift), .dont_serialize = 0},
{.name = s8_const_lit("alt"), .type = &type__b8, .offset = offsetof(app_event_t, alt), .dont_serialize = 0}, {.name = s8_const("alt"), .type = &type__b8, .offset = offsetof(app_event_t, alt), .dont_serialize = 0},
{.name = s8_const_lit("mouse_pos"), .type = &type__v2f32_t, .offset = offsetof(app_event_t, mouse_pos), .dont_serialize = 0}, {.name = s8_const("mouse_pos"), .type = &type__v2f32_t, .offset = offsetof(app_event_t, mouse_pos), .dont_serialize = 0},
{.name = s8_const_lit("mouse_delta"), .type = &type__v2f32_t, .offset = offsetof(app_event_t, mouse_delta), .dont_serialize = 0}, {.name = s8_const("mouse_delta"), .type = &type__v2f32_t, .offset = offsetof(app_event_t, mouse_delta), .dont_serialize = 0},
}, },
.count = 12, .count = 12,
}; };
type_t type__app_frame_t = { type_kind_struct, s8_const_lit("app_frame_t"), sizeof(app_frame_t), type_t type__app_frame_t = { type_kind_struct, s8_const("app_frame_t"), sizeof(app_frame_t),
.members = (type_member_t[]){ .members = (type_member_t[]){
{.name = s8_const_lit("window_size"), .type = &type__v2f32_t, .offset = offsetof(app_frame_t, window_size), .dont_serialize = 0}, {.name = s8_const("window_size"), .type = &type__v2f32_t, .offset = offsetof(app_frame_t, window_size), .dont_serialize = 0},
{.name = s8_const_lit("mouse_pos"), .type = &type__v2f32_t, .offset = offsetof(app_frame_t, mouse_pos), .dont_serialize = 0}, {.name = s8_const("mouse_pos"), .type = &type__v2f32_t, .offset = offsetof(app_frame_t, mouse_pos), .dont_serialize = 0},
{.name = s8_const_lit("dpr"), .type = &type__f32, .offset = offsetof(app_frame_t, dpr), .dont_serialize = 0}, {.name = s8_const("dpr"), .type = &type__f32, .offset = offsetof(app_frame_t, dpr), .dont_serialize = 0},
{.name = s8_const_lit("delta"), .type = &type__f64, .offset = offsetof(app_frame_t, delta), .dont_serialize = 0}, {.name = s8_const("delta"), .type = &type__f64, .offset = offsetof(app_frame_t, delta), .dont_serialize = 0},
{.name = s8_const_lit("frame"), .type = &type__u64, .offset = offsetof(app_frame_t, frame), .dont_serialize = 0}, {.name = s8_const("frame"), .type = &type__u64, .offset = offsetof(app_frame_t, frame), .dont_serialize = 0},
{.name = s8_const_lit("event_count"), .type = &type__i32, .offset = offsetof(app_frame_t, event_count), .dont_serialize = 0}, {.name = s8_const("event_count"), .type = &type__i32, .offset = offsetof(app_frame_t, event_count), .dont_serialize = 0},
{.name = s8_const_lit("first_event"), .type = &(type_t){type_kind_pointer, s8_const_lit("app_event_t*"), sizeof(void *), .base = &type__app_event_t}, .offset = offsetof(app_frame_t, first_event), .dont_serialize = 0}, {.name = s8_const("first_event"), .type = &(type_t){type_kind_pointer, s8_const("app_event_t*"), sizeof(void *), .base = &type__app_event_t}, .offset = offsetof(app_frame_t, first_event), .dont_serialize = 0},
{.name = s8_const_lit("last_event"), .type = &(type_t){type_kind_pointer, s8_const_lit("app_event_t*"), sizeof(void *), .base = &type__app_event_t}, .offset = offsetof(app_frame_t, last_event), .dont_serialize = 0}, {.name = s8_const("last_event"), .type = &(type_t){type_kind_pointer, s8_const("app_event_t*"), sizeof(void *), .base = &type__app_event_t}, .offset = offsetof(app_frame_t, last_event), .dont_serialize = 0},
}, },
.count = 8, .count = 8,
}; };

8
src/app/app.meta.c
View File

@@ -78,7 +78,7 @@ void generate_app_code(ma_arena_t *arena) {
{ page_up PageUp XXX 1 VK_INSERT XXX } { page_up PageUp XXX 1 VK_INSERT XXX }
{ page_down PageDown XXX 1 VK_PRIOR XXX } { page_down PageDown XXX 1 VK_PRIOR XXX }
)); ));
mtt_serial_enum(c, h, keys, s8_lit("app_key")); mtt_serial_enum(c, h, keys, s8("app_key"));
/////////////////////////////// ///////////////////////////////
// generate mappings // generate mappings
@@ -95,8 +95,8 @@ void generate_app_code(ma_arena_t *arena) {
assert(mtt(it, "jf")->integer == 0 || mtt(it, "jf")->integer == 1); assert(mtt(it, "jf")->integer == 0 || mtt(it, "jf")->integer == 1);
s8_t js[] = {mtts(it, "js1"), mtts(it, "js2")}; s8_t js[] = {mtts(it, "js1"), mtts(it, "js2")};
for (i32 i = 0; i < lengthof(js); i += 1) { for (i32 i = 0; i < lengthof(js); i += 1) {
if (s8_are_equal(js[i], s8_lit("XXX"))) continue; if (s8_are_equal(js[i], s8("XXX"))) continue;
sb8_stmtf(c, "else if (s8_are_equal_ex(key, s8_lit(\"%S\"), s8_ignore_case)) return (wasm_key_map_t){app_key_%S, %d};", js[i], mtts(it, "name"), (int)mtt(it, "jf")->integer); sb8_stmtf(c, "else if (s8_are_equal_ex(key, s8(\"%S\"), s8_ignore_case)) return (wasm_key_map_t){app_key_%S, %d};", js[i], mtts(it, "name"), (int)mtt(it, "jf")->integer);
} }
} }
sb8_stmtf(c, "return (wasm_key_map_t){0};"); sb8_stmtf(c, "return (wasm_key_map_t){0};");
@@ -116,7 +116,7 @@ void generate_app_code(ma_arena_t *arena) {
for (ast_t *it = keys->first; it; it = it->next) { for (ast_t *it = keys->first; it; it = it->next) {
s8_t w[] = {mtts(it, "windows1"), mtts(it, "windows2")}; s8_t w[] = {mtts(it, "windows1"), mtts(it, "windows2")};
for (i32 i = 0; i < lengthof(w); i += 1) { for (i32 i = 0; i < lengthof(w); i += 1) {
if (s8_are_equal(w[i], s8_lit("XXX"))) continue; if (s8_are_equal(w[i], s8("XXX"))) continue;
sb8_stmtf(c, "case %S: return app_key_%S; break;", w[i], mtts(it, "name")); sb8_stmtf(c, "case %S: return app_key_%S; break;", w[i], mtts(it, "name"));
} }
} }

16
src/app/app_win32.c
View File

@@ -82,12 +82,12 @@ fn void w32_push_event(app_frame_t *frame, app_event_t event) {
fn void w32_push_wm_char_event(WPARAM wparam) { fn void w32_push_wm_char_event(WPARAM wparam) {
if (wparam < 32 || wparam == 127) return; if (wparam < 32 || wparam == 127) return;
s8_t string = s8_lit("?"); s8_t string = s8("?");
utf32_result_t encode = utf16_to_utf32((u16 *)&wparam, 1); utf32_result_t encode = utf16_to_utf32((u16 *)&wparam, 1);
if (!encode.error) { if (!encode.error) {
utf8_result_t encode8 = utf32_to_utf8(encode.out_str); utf8_result_t encode8 = utf32_to_utf8(encode.out_str);
if (!encode8.error) { if (!encode8.error) {
string = s8(encode8.out_str, encode8.len); string = s8_make(encode8.out_str, encode8.len);
string = s8_copy(w32_event_arena, string); string = s8_copy(w32_event_arena, string);
} }
} }
@@ -350,10 +350,10 @@ int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int n
ma_temp_t scratch = ma_begin_scratch(); ma_temp_t scratch = ma_begin_scratch();
s8_t dir = os_exe_dir(scratch.arena); s8_t dir = os_exe_dir(scratch.arena);
for (os_iter_t *it = os_iter(scratch.arena, dir); it->is_valid; os_advance(it)) { for (os_iter_t *it = os_iter(scratch.arena, dir); it->is_valid; os_advance(it)) {
b32 is_dll = s8_ends_with(it->name, s8_lit(".dll")); b32 is_dll = s8_ends_with(it->name, s8(".dll"));
b32 is_pdb = s8_ends_with(it->name, s8_lit(".pdb")); b32 is_pdb = s8_ends_with(it->name, s8(".pdb"));
b32 is_rdi = s8_ends_with(it->name, s8_lit(".rdi")); b32 is_rdi = s8_ends_with(it->name, s8(".rdi"));
b32 is_temp = s8_find(it->name, s8_lit("_temp_"), s8_seek_none) != -1; b32 is_temp = s8_find(it->name, s8("_temp_"), s8_seek_none) != -1;
if (is_temp && (is_dll || is_pdb || is_rdi)) { if (is_temp && (is_dll || is_pdb || is_rdi)) {
b32 ok = os_delete(it->abs); b32 ok = os_delete(it->abs);
assert(ok); assert(ok);
@@ -461,8 +461,8 @@ int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int n
w32_library_t lib = {0}; w32_library_t lib = {0};
lib.dll_name = s8_lit("app.dll"); lib.dll_name = s8("app.dll");
lib.update_fn_name = s8_lit("app_update"); lib.update_fn_name = s8("app_update");
tcx->data[tcx_slot_app] = w32_load_opengl_fn; tcx->data[tcx_slot_app] = w32_load_opengl_fn;
// Set VSync // Set VSync

2
src/core/core_hash_table.c
View File

@@ -145,7 +145,7 @@ fn_test void test_hash_table(void) {
assert(s8_are_equal(node->kv.key_string, s)); assert(s8_are_equal(node->kv.key_string, s));
} }
ht_node_t *node = ht_search_string_ex(ht, s8_lit("memes")); ht_node_t *node = ht_search_string_ex(ht, s8("memes"));
assert(node == NULL); assert(node == NULL);
} }

32
src/core/core_lexer.c
View File

@@ -1,7 +1,7 @@
#define lex_error(TOKEN, STRING) do {\ #define lex_error(TOKEN, STRING) do {\
errorf(STRING);\ errorf(STRING);\
TOKEN->kind = lex_kind_error;\ TOKEN->kind = lex_kind_error;\
TOKEN->string = s8_lit(STRING);\ TOKEN->string = s8(STRING);\
} while (0) } while (0)
fn lexer_t lex_make(s8_t stream, char *file_name) { fn lexer_t lex_make(s8_t stream, char *file_name) {
@@ -121,13 +121,13 @@ fn b32 lex_macro(lexer_t *lex, lex_t *token) {
while (char_is_alphabetic(lex->at[0])) lex_advance(lex); while (char_is_alphabetic(lex->at[0])) lex_advance(lex);
token->len = (i32)(lex->at - token->str); token->len = (i32)(lex->at - token->str);
if (s8_are_equal(token->string, s8_lit("define"))) { if (s8_are_equal(token->string, s8("define"))) {
token->kind = lex_kind_preproc_define; token->kind = lex_kind_preproc_define;
} else if (s8_are_equal(token->string, s8_lit("ifdef"))) { } else if (s8_are_equal(token->string, s8("ifdef"))) {
token->kind = lex_kind_preproc_ifdef; token->kind = lex_kind_preproc_ifdef;
} else if (s8_are_equal(token->string, s8_lit("ifndef"))) { } else if (s8_are_equal(token->string, s8("ifndef"))) {
token->kind = lex_kind_preproc_ifndef; token->kind = lex_kind_preproc_ifndef;
} else if (s8_are_equal(token->string, s8_lit("include"))) { } else if (s8_are_equal(token->string, s8("include"))) {
token->kind = lex_kind_preproc_include; token->kind = lex_kind_preproc_include;
lex_eat_macro_whitespace(lex); lex_eat_macro_whitespace(lex);
char end = 0; char end = 0;
@@ -154,22 +154,22 @@ fn b32 lex_macro(lexer_t *lex, lex_t *token) {
lex_advance(lex); lex_advance(lex);
} }
lex_advance(lex); lex_advance(lex);
} else if (s8_are_equal(token->string, s8_lit("if"))) { } else if (s8_are_equal(token->string, s8("if"))) {
token->kind = lex_kind_preproc_if; token->kind = lex_kind_preproc_if;
} else if (s8_are_equal(token->string, s8_lit("endif"))) { } else if (s8_are_equal(token->string, s8("endif"))) {
token->kind = lex_kind_preproc_endif; token->kind = lex_kind_preproc_endif;
} else if (s8_are_equal(token->string, s8_lit("error"))) { } else if (s8_are_equal(token->string, s8("error"))) {
token->kind = lex_kind_preproc_error; token->kind = lex_kind_preproc_error;
lex_eat_macro_whitespace(lex); lex_eat_macro_whitespace(lex);
token->str = lex->at; token->str = lex->at;
lex_eat_until(lex, '\n'); lex_eat_until(lex, '\n');
} else if (s8_are_equal(token->string, s8_lit("else"))) { } else if (s8_are_equal(token->string, s8("else"))) {
token->kind = lex_kind_preproc_else; token->kind = lex_kind_preproc_else;
} else if (s8_are_equal(token->string, s8_lit("elif"))) { } else if (s8_are_equal(token->string, s8("elif"))) {
token->kind = lex_kind_preproc_elif; token->kind = lex_kind_preproc_elif;
} else if (s8_are_equal(token->string, s8_lit("pragma"))) { } else if (s8_are_equal(token->string, s8("pragma"))) {
token->kind = lex_kind_preproc_pragma; token->kind = lex_kind_preproc_pragma;
} else if (s8_are_equal(token->string, s8_lit("undef"))) { } else if (s8_are_equal(token->string, s8("undef"))) {
token->kind = lex_kind_preproc_undef; token->kind = lex_kind_preproc_undef;
} else { } else {
return false; return false;
@@ -329,7 +329,7 @@ fn void lex_token_ex(lexer_t *lex, lex_t *token) {
s8_t string_to_lex = token->string; s8_t string_to_lex = token->string;
if (token->suffix != lex_suffix_none) { if (token->suffix != lex_suffix_none) {
s8_t string_value = ti_enum_value_to_name(token->suffix, type(lex_suffix_t)); s8_t string_value = ti_enum_value_to_name(token->suffix, type(lex_suffix_t));
s8_t prefix = s8_lit("lex_suffix_"); s8_t prefix = s8("lex_suffix_");
string_to_lex.len -= string_value.len - prefix.len; string_to_lex.len -= string_value.len - prefix.len;
} }
token->integer = u64_from_s8(string_to_lex, 10); token->integer = u64_from_s8(string_to_lex, 10);
@@ -337,7 +337,7 @@ fn void lex_token_ex(lexer_t *lex, lex_t *token) {
s8_t string_to_lex = token->string; s8_t string_to_lex = token->string;
if (token->suffix != lex_suffix_none) { if (token->suffix != lex_suffix_none) {
s8_t string_value = ti_enum_value_to_name(token->suffix, type(lex_suffix_t)); s8_t string_value = ti_enum_value_to_name(token->suffix, type(lex_suffix_t));
s8_t prefix = s8_lit("lex_suffix_"); s8_t prefix = s8("lex_suffix_");
string_to_lex.len -= string_value.len - prefix.len; string_to_lex.len -= string_value.len - prefix.len;
} }
token->real = f64_from_s8(string_to_lex); token->real = f64_from_s8(string_to_lex);
@@ -380,7 +380,7 @@ fn lex_array_t lex_tokens(ma_arena_t *arena, char *file_name, s8_t stream) {
} }
gb_read_only s8_t lex_kind_simple_strings[] = { gb_read_only s8_t lex_kind_simple_strings[] = {
#define X(KIND, STR, SIMPLE) s8_const_lit(SIMPLE), #define X(KIND, STR, SIMPLE) s8_const(SIMPLE),
LEX_KIND_XLIST LEX_KIND_XLIST
#undef X #undef X
}; };
@@ -391,7 +391,7 @@ fn s8_t lex_kind_to_simple_s8(lex_kind_t kind) {
} }
gb_read_only s8_t lex_kind_strings[] = { gb_read_only s8_t lex_kind_strings[] = {
#define X(KIND, STR, SIMPLE) s8_const_lit(STR), #define X(KIND, STR, SIMPLE) s8_const(STR),
LEX_KIND_XLIST LEX_KIND_XLIST
#undef X #undef X
}; };

4
src/core/core_lexer.h
View File

@@ -164,14 +164,14 @@ fn void parser_eat_including(parser_t *par, lex_kind_t kind);
gb_read_only lex_t lex_null; gb_read_only lex_t lex_null;
gb_read_only type_member_t members__lex_kind_t[] = { gb_read_only type_member_t members__lex_kind_t[] = {
#define X(KIND, STR, SIMPLE) {.name = s8_const_lit("lex_kind_" #KIND), .value = KIND}, #define X(KIND, STR, SIMPLE) {.name = s8_const("lex_kind_" #KIND), .value = KIND},
LEX_KIND_XLIST LEX_KIND_XLIST
#undef X #undef X
}; };
DEFINE_ENUM(lex_kind_t); DEFINE_ENUM(lex_kind_t);
gb_read_only type_member_t members__lex_suffix_t[] = { gb_read_only type_member_t members__lex_suffix_t[] = {
#define X(KIND) {.name = s8_const_lit(#KIND), .value = KIND}, #define X(KIND) {.name = s8_const(#KIND), .value = KIND},
LEX_SUFFIX_XLIST LEX_SUFFIX_XLIST
#undef X #undef X
}; };

8
src/core/core_math.gen.c
View File

@@ -399,7 +399,7 @@ fn r2f32_t r2f32_fix(r2f32_t n) {
}; };
return result; return result;
} }
fn r2f64_t r2f64_cut_left(r2f64_t *r, f64 value) { fn r2f64_t r2f64_cut_left(r2f64_t *r, f64 value) {
f64 minx = r->min.x; f64 minx = r->min.x;
@@ -544,7 +544,7 @@ fn r2f64_t r2f64_fix(r2f64_t n) {
}; };
return result; return result;
} }
fn r2i32_t r2i32_cut_left(r2i32_t *r, i32 value) { fn r2i32_t r2i32_cut_left(r2i32_t *r, i32 value) {
i32 minx = r->min.x; i32 minx = r->min.x;
@@ -689,7 +689,7 @@ fn r2i32_t r2i32_fix(r2i32_t n) {
}; };
return result; return result;
} }
fn r2i64_t r2i64_cut_left(r2i64_t *r, i64 value) { fn r2i64_t r2i64_cut_left(r2i64_t *r, i64 value) {
i64 minx = r->min.x; i64 minx = r->min.x;
@@ -834,7 +834,7 @@ fn r2i64_t r2i64_fix(r2i64_t n) {
}; };
return result; return result;
} }
fn_inline v2f64_t v2f32_to_v2f64(v2f32_t v) { return (v2f64_t){ (f64)v.x, (f64)v.y }; } fn_inline v2f64_t v2f32_to_v2f64(v2f32_t v) { return (v2f64_t){ (f64)v.x, (f64)v.y }; }
fn_inline v3f64_t v3f32_to_v3f64(v3f32_t v) { return (v3f64_t){ (f64)v.x, (f64)v.y, (f64)v.z }; } fn_inline v3f64_t v3f32_to_v3f64(v3f32_t v) { return (v3f64_t){ (f64)v.x, (f64)v.y, (f64)v.z }; }
fn_inline v4f64_t v4f32_to_v4f64(v4f32_t v) { return (v4f64_t){ (f64)v.x, (f64)v.y, (f64)v.z, (f64)v.w }; } fn_inline v4f64_t v4f32_to_v4f64(v4f32_t v) { return (v4f64_t){ (f64)v.x, (f64)v.y, (f64)v.z, (f64)v.w }; }

50
src/core/core_math_gen.py
View File

@@ -90,52 +90,52 @@ struct_types = vec_types + rect_types
# }; # };
# #
# #
# type_t type__v2f64_t = { type_kind_struct, s8_const_lit("v2f64_t"), sizeof(v2f64_t), .count = 2, # type_t type__v2f64_t = { type_kind_struct, s8_const("v2f64_t"), sizeof(v2f64_t), .count = 2,
# .members = (type_member_t[]){ # .members = (type_member_t[]){
# {s8_const_lit("x"), &type__f64, .offset = offsetof(v2f64_t, x)}, # {s8_const("x"), &type__f64, .offset = offsetof(v2f64_t, x)},
# {s8_const_lit("y"), &type__f64, .offset = offsetof(v2f64_t, y)}, # {s8_const("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, # type_t type__v3f64_t = { type_kind_struct, s8_const("v3f64_t"), sizeof(v3f64_t), .count = 3,
# .members = (type_member_t[]){ # .members = (type_member_t[]){
# {s8_const_lit("x"), &type__f64, .offset = offsetof(v3f64_t, x)}, # {s8_const("x"), &type__f64, .offset = offsetof(v3f64_t, x)},
# {s8_const_lit("y"), &type__f64, .offset = offsetof(v3f64_t, y)}, # {s8_const("y"), &type__f64, .offset = offsetof(v3f64_t, y)},
# {s8_const_lit("z"), &type__f64, .offset = offsetof(v3f64_t, z)}, # {s8_const("z"), &type__f64, .offset = offsetof(v3f64_t, z)},
# } # }
# }; # };
# type_t type__v4f64_t = { type_kind_struct, s8_const_lit("v4f64_t"), sizeof(v4f64_t), .count = 4, # type_t type__v4f64_t = { type_kind_struct, s8_const("v4f64_t"), sizeof(v4f64_t), .count = 4,
# .members = (type_member_t[]){ # .members = (type_member_t[]){
# {s8_const_lit("x"), &type__f64, .offset = offsetof(v4f64_t, x)}, # {s8_const("x"), &type__f64, .offset = offsetof(v4f64_t, x)},
# {s8_const_lit("y"), &type__f64, .offset = offsetof(v4f64_t, y)}, # {s8_const("y"), &type__f64, .offset = offsetof(v4f64_t, y)},
# {s8_const_lit("z"), &type__f64, .offset = offsetof(v4f64_t, z)}, # {s8_const("z"), &type__f64, .offset = offsetof(v4f64_t, z)},
# {s8_const_lit("w"), &type__f64, .offset = offsetof(v4f64_t, w)}, # {s8_const("w"), &type__f64, .offset = offsetof(v4f64_t, w)},
# } # }
# }; # };
# type_t type__r3f64_t = { type_kind_struct, s8_const_lit("r3f64_t"), sizeof(r3f64_t), .count = 6, # type_t type__r3f64_t = { type_kind_struct, s8_const("r3f64_t"), sizeof(r3f64_t), .count = 6,
# .members = (type_member_t[]){ # .members = (type_member_t[]){
# {s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, x0)}, # {s8_const("x0"), &type__f64, .offset = offsetof(r3f64_t, x0)},
# {s8_const_lit("y0"), &type__f64, .offset = offsetof(r3f64_t, y0)}, # {s8_const("y0"), &type__f64, .offset = offsetof(r3f64_t, y0)},
# {s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, z0)}, # {s8_const("x0"), &type__f64, .offset = offsetof(r3f64_t, z0)},
# {s8_const_lit("x1"), &type__f64, .offset = offsetof(r3f64_t, x1)}, # {s8_const("x1"), &type__f64, .offset = offsetof(r3f64_t, x1)},
# {s8_const_lit("y1"), &type__f64, .offset = offsetof(r3f64_t, y1)}, # {s8_const("y1"), &type__f64, .offset = offsetof(r3f64_t, y1)},
# {s8_const_lit("x1"), &type__f64, .offset = offsetof(r3f64_t, z1)}, # {s8_const("x1"), &type__f64, .offset = offsetof(r3f64_t, z1)},
# } # }
# }; # };
# type_member_t members__r2f64_t[] = { # type_member_t members__r2f64_t[] = {
# {s8_const_lit("x0"), &type__f64, .offset = offsetof(r2f64_t, x0)}, # {s8_const("x0"), &type__f64, .offset = offsetof(r2f64_t, x0)},
# {s8_const_lit("y0"), &type__f64, .offset = offsetof(r2f64_t, y0)}, # {s8_const("y0"), &type__f64, .offset = offsetof(r2f64_t, y0)},
# {s8_const_lit("x1"), &type__f64, .offset = offsetof(r2f64_t, x1)}, # {s8_const("x1"), &type__f64, .offset = offsetof(r2f64_t, x1)},
# {s8_const_lit("y1"), &type__f64, .offset = offsetof(r2f64_t, y1)}, # {s8_const("y1"), &type__f64, .offset = offsetof(r2f64_t, y1)},
# }; # };
# DEFINE_STRUCT(r2f64_t); # DEFINE_STRUCT(r2f64_t);
# type_member_t members__r1f64_t[] = { # type_member_t members__r1f64_t[] = {
# {s8_const_lit("x0"), &type__f64, .offset = offsetof(r1f64_t, x0)}, # {s8_const("x0"), &type__f64, .offset = offsetof(r1f64_t, x0)},
# {s8_const_lit("x1"), &type__f64, .offset = offsetof(r1f64_t, x1)}, # {s8_const("x1"), &type__f64, .offset = offsetof(r1f64_t, x1)},
# }; # };
# DEFINE_STRUCT(r1f64_t); # DEFINE_STRUCT(r1f64_t);
# """ # """

2
src/core/core_platform_wasm.c
View File

@@ -30,7 +30,7 @@ fn void os_error_box(char *str) {
fn void os_console_log(char *str) { fn void os_console_log(char *str) {
s8_t string = s8_from_char(str); s8_t string = s8_from_char(str);
if (s8_ends_with(string, s8_lit("\n"))) { if (s8_ends_with(string, s8("\n"))) {
string = s8_chop(string, 1); string = s8_chop(string, 1);
} }
wasm_write_to_console((isize)string.str, (i32)string.len); wasm_write_to_console((isize)string.str, (i32)string.len);

30
src/core/core_string.c
View File

@@ -63,7 +63,7 @@ fn s8_t s8_copy(ma_arena_t *ma, s8_t string) {
char *copy = (char *)ma_push_size(ma, sizeof(char) * (string.len + 1)); char *copy = (char *)ma_push_size(ma, sizeof(char) * (string.len + 1));
memory_copy(copy, string.str, string.len); memory_copy(copy, string.str, string.len);
copy[string.len] = 0; copy[string.len] = 0;
s8_t result = s8(copy, string.len); s8_t result = s8_make(copy, string.len);
return result; return result;
} }
@@ -72,7 +72,7 @@ fn s8_t s8_copy_char(ma_arena_t *ma, char *s) {
char *copy = (char *)ma_push_size(ma, sizeof(char) * (len + 1)); char *copy = (char *)ma_push_size(ma, sizeof(char) * (len + 1));
memory_copy(copy, s, len); memory_copy(copy, s, len);
copy[len] = 0; copy[len] = 0;
s8_t result = s8(copy, len); s8_t result = s8_make(copy, len);
return result; return result;
} }
@@ -98,26 +98,26 @@ fn b32 s8_are_equal(s8_t a, s8_t b) {
fn s8_t s8_get_postfix(s8_t string, int64_t len) { fn s8_t s8_get_postfix(s8_t string, int64_t len) {
len = CLAMP_TOP(len, string.len); len = CLAMP_TOP(len, string.len);
int64_t remain_len = string.len - len; int64_t remain_len = string.len - len;
s8_t result = s8(string.str + remain_len, len); s8_t result = s8_make(string.str + remain_len, len);
return result; return result;
} }
fn 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); len = CLAMP_TOP(len, string.len);
s8_t result = s8(string.str, len); s8_t result = s8_make(string.str, len);
return result; return result;
} }
fn 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); len = CLAMP_TOP(len, string.len);
s8_t result = s8(string.str, string.len - len); s8_t result = s8_make(string.str, string.len - len);
return result; return result;
} }
fn 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); len = CLAMP_TOP(len, string.len);
int64_t remain = string.len - len; int64_t remain = string.len - len;
s8_t result = s8(string.str + len, remain); s8_t result = s8_make(string.str + len, remain);
return result; return result;
} }
@@ -171,7 +171,7 @@ fn s8_t s8_cut_end(s8_t *in, i64 size) {
#if 0 #if 0
s8_t s8_skip_to_p(s8_t string, char *p) { s8_t s8_skip_to_p(s8_t string, char *p) {
if (s8_is_pointer_inside(string, p)) { if (s8_is_pointer_inside(string, p)) {
s8_t result = s8(p, p - string.str); s8_t result = s8_make(p, p - string.str);
return result; return result;
} }
return string; return string;
@@ -179,7 +179,7 @@ s8_t s8_skip_to_p(s8_t string, char *p) {
s8_t s8_skip_past(s8_t string, s8_t a) { s8_t s8_skip_past(s8_t string, s8_t a) {
if (s8_is_pointer_inside(string, a.str)) { if (s8_is_pointer_inside(string, a.str)) {
s8_t on_p = s8(a.str, a.str - string.str); s8_t on_p = s8_make(a.str, a.str - string.str);
s8_t result = s8_skip(on_p, a.len); s8_t result = s8_skip(on_p, a.len);
return result; return result;
} }
@@ -290,11 +290,11 @@ fn s8_t s8_chop_last_char(s8_t s, s8_t ch) {
} }
fn s8_t s8_chop_last_slash(s8_t s) { fn s8_t s8_chop_last_slash(s8_t s) {
return s8_chop_last_char(s, s8_lit("/")); return s8_chop_last_char(s, s8("/"));
} }
fn s8_t s8_chop_last_period(s8_t s) { fn s8_t s8_chop_last_period(s8_t s) {
return s8_chop_last_char(s, s8_lit(".")); return s8_chop_last_char(s, s8("."));
} }
fn s8_t s8_skip_to_last_char(s8_t s, s8_t ch) { fn s8_t s8_skip_to_last_char(s8_t s, s8_t ch) {
@@ -307,11 +307,11 @@ fn s8_t s8_skip_to_last_char(s8_t s, s8_t ch) {
} }
fn s8_t s8_skip_to_last_slash(s8_t s) { fn s8_t s8_skip_to_last_slash(s8_t s) {
return s8_skip_to_last_char(s, s8_lit("/")); return s8_skip_to_last_char(s, s8("/"));
} }
fn s8_t s8_skip_to_last_period(s8_t s) { fn s8_t s8_skip_to_last_period(s8_t s) {
return s8_skip_to_last_char(s, s8_lit(".")); return s8_skip_to_last_char(s, s8("."));
} }
fn s8_t s8_get_name_no_ext(s8_t s) { fn s8_t s8_get_name_no_ext(s8_t s) {
@@ -348,7 +348,7 @@ fn s8_t s8_vfmt(ma_arena_t *ma, const char *str, va_list args1) {
char *result = (char *)ma_push_size(ma, sizeof(char) * (len + 1)); char *result = (char *)ma_push_size(ma, sizeof(char) * (len + 1));
s8_vsnprintf(result, (i32)(len + 1), str, args1); s8_vsnprintf(result, (i32)(len + 1), str, args1);
s8_t res = s8(result, len); s8_t res = s8_make(result, len);
return res; return res;
} }
@@ -413,10 +413,10 @@ fn sb8_t s8_split(ma_arena_t *ma, s8_t string, s8_t find, s8_split_t flags) {
s8_seek_t find_flag = flags & s8_split_ignore_case ? s8_seek_ignore_case : s8_seek_none; s8_seek_t find_flag = flags & s8_split_ignore_case ? s8_seek_ignore_case : s8_seek_none;
while (s8_seek(string, find, find_flag, &index)) { while (s8_seek(string, find, find_flag, &index)) {
s8_t before_match = s8(string.str, index); s8_t before_match = s8_make(string.str, index);
sb8_append(&result, before_match); sb8_append(&result, before_match);
if (flags & s8_split_inclusive) { if (flags & s8_split_inclusive) {
s8_t match = s8(string.str + index, find.len); s8_t match = s8_make(string.str + index, find.len);
sb8_append(&result, match); sb8_append(&result, match);
} }
string = s8_skip(string, index + find.len); string = s8_skip(string, index + find.len);

14
src/core/core_string.h
View File

@@ -57,11 +57,11 @@ fn f64 f64_from_s8(s8_t string);
// //
// string8 constructors // string8 constructors
#define s8(str,len) (s8_t){str, len} #define s8_make(str,len) (s8_t){str, len}
#define s8_null (s8_t){0} #define s8_null (s8_t){0}
#define s8_invalid s8_lit("<INVALID>") #define s8_invalid s8("<INVALID>")
#define s8_lit(string) (s8_t){(char *)string, sizeof(string) - 1} #define s8(string) (s8_t){(char *)string, sizeof(string) - 1}
#define s8_const_lit(string) { string, sizeof(string) - 1 } #define s8_const(string) { string, sizeof(string) - 1 }
#define s8_struct(DATA) (s8_t){.str = (char *)&(DATA), .len = sizeof(DATA)} #define s8_struct(DATA) (s8_t){.str = (char *)&(DATA), .len = sizeof(DATA)}
#define s8_array(DATA) (s8_t){.str = (char *)(DATA), .len = lengthof(DATA)} #define s8_array(DATA) (s8_t){.str = (char *)(DATA), .len = lengthof(DATA)}
#define s8_array_lit(DATA) {.str = (char *)(DATA), .len = lengthof(DATA)} #define s8_array_lit(DATA) {.str = (char *)(DATA), .len = lengthof(DATA)}
@@ -146,9 +146,9 @@ void *sbin_read_data(stream_t *stream, i64 size);
// //
// other // other
#define s8_fmtspec(string) (int)(string).len, (string).str #define s8_fmtspec(string) (int)(string).len, (string).str
#define S8_CODE(...) s8_lit(#__VA_ARGS__) #define S8_CODE(...) s8(#__VA_ARGS__)
#define S8_FILE s8_lit(__FILE__) #define S8_FILE s8(__FILE__)
#define S8_FILE_AND_LINE s8_lit(FILE_AND_LINE) #define S8_FILE_AND_LINE s8(FILE_AND_LINE)
#define S8_FMT(ma, str, result) \ #define S8_FMT(ma, str, result) \
va_list args1; \ va_list args1; \

119
src/core/core_string16.c
View File

@@ -1,4 +1,4 @@
fn i64 wstr_len(wchar_t *string) { fn i64 str16_len(u16 *string) {
i64 len = 0; i64 len = 0;
while (*string++ != 0) while (*string++ != 0)
len++; len++;
@@ -47,32 +47,24 @@ fn s16_t s16_from_range(u16 *begin, u16 *end) {
return result; return result;
} }
fn s16_t s16_from_u16(u16 *string) { fn s16_t s16_from_str16(u16 *string) {
s16_t result; s16_t result;
result.str = string; result.str = string;
result.len = wstr_len(string); result.len = str16_len(string);
return result; return result;
} }
fn s16_t s16_from_wstr(wchar_t *string) {
return s16_from_u16((u16 *)string);
}
fn s16_t s16_copy(ma_arena_t *ma, s16_t string) { fn s16_t s16_copy(ma_arena_t *ma, s16_t string) {
i64 byte_size = sizeof(u16) * string.len; i64 byte_size = sizeof(u16) * string.len;
u16 *copy = (u16 *)ma_push_size(ma, byte_size + sizeof(u16)); u16 *copy = (u16 *)ma_push_size(ma, byte_size + sizeof(u16));
memory_copy(copy, string.str, byte_size); memory_copy(copy, string.str, byte_size);
copy[string.len] = 0; copy[string.len] = 0;
s16_t result = s16(copy, string.len); s16_t result = s16_make(copy, string.len);
return result; return result;
} }
fn s16_t s16_copy_u16(ma_arena_t *ma, u16 *s) { fn s16_t s16_copy_str16(ma_arena_t *ma, u16 *s) {
return s16_copy(ma, s16(s, wstr_len(s))); return s16_copy(ma, s16_make(s, str16_len(s)));
}
fn s16_t s16_copy_wstr(ma_arena_t *ma, wchar_t *s) {
return s16_copy(ma, s16(s, wstr_len(s)));
} }
fn b32 s16_are_equal_ex(s16_t a, s16_t b, b32 ignore_case) { fn b32 s16_are_equal_ex(s16_t a, s16_t b, b32 ignore_case) {
@@ -112,26 +104,26 @@ fn s8_t s8_from_s16(ma_arena_t *ma, s16_t string) {
fn s16_t s16_get_postfix(s16_t string, i64 len) { fn s16_t s16_get_postfix(s16_t string, i64 len) {
len = CLAMP_TOP(len, string.len); len = CLAMP_TOP(len, string.len);
i64 remain_len = string.len - len; i64 remain_len = string.len - len;
s16_t result = s16(string.str + remain_len, len); s16_t result = s16_make(string.str + remain_len, len);
return result; return result;
} }
fn s16_t s16_get_prefix(s16_t string, i64 len) { fn s16_t s16_get_prefix(s16_t string, i64 len) {
len = CLAMP_TOP(len, string.len); len = CLAMP_TOP(len, string.len);
s16_t result = s16(string.str, len); s16_t result = s16_make(string.str, len);
return result; return result;
} }
fn s16_t s16_chop(s16_t string, i64 len) { fn s16_t s16_chop(s16_t string, i64 len) {
len = CLAMP_TOP(len, string.len); len = CLAMP_TOP(len, string.len);
s16_t result = s16(string.str, string.len - len); s16_t result = s16_make(string.str, string.len - len);
return result; return result;
} }
fn s16_t s16_skip(s16_t string, i64 len) { fn s16_t s16_skip(s16_t string, i64 len) {
len = CLAMP_TOP(len, string.len); len = CLAMP_TOP(len, string.len);
i64 remain = string.len - len; i64 remain = string.len - len;
s16_t result = s16(string.str + len, remain); s16_t result = s16_make(string.str + len, remain);
return result; return result;
} }
@@ -291,11 +283,11 @@ fn s16_t s16_chop_last_char(s16_t s, s16_t ch) {
} }
fn s16_t s16_chop_last_slash(s16_t s) { fn s16_t s16_chop_last_slash(s16_t s) {
return s16_chop_last_char(s, s16_lit("/")); return s16_chop_last_char(s, s16("/"));
} }
fn s16_t s16_chop_last_period(s16_t s) { fn s16_t s16_chop_last_period(s16_t s) {
return s16_chop_last_char(s, s16_lit(".")); return s16_chop_last_char(s, s16("."));
} }
fn s16_t s16_skip_to_last_char(s16_t s, s16_t ch) { fn s16_t s16_skip_to_last_char(s16_t s, s16_t ch) {
@@ -308,11 +300,11 @@ fn s16_t s16_skip_to_last_char(s16_t s, s16_t ch) {
} }
fn s16_t s16_skip_to_last_slash(s16_t s) { fn s16_t s16_skip_to_last_slash(s16_t s) {
return s16_skip_to_last_char(s, s16_lit("/")); return s16_skip_to_last_char(s, s16("/"));
} }
fn s16_t s16_skip_to_last_period(s16_t s) { fn s16_t s16_skip_to_last_period(s16_t s) {
return s16_skip_to_last_char(s, s16_lit(".")); return s16_skip_to_last_char(s, s16("."));
} }
fn s16_t s16_get_name_no_ext(s16_t s) { fn s16_t s16_get_name_no_ext(s16_t s) {
@@ -470,10 +462,10 @@ fn sb16_t s16_split(ma_arena_t *ma, s16_t string, s16_t find, s16_split_t flags)
s16_seek_t find_flag = flags & s16_split_ignore_case ? s16_seek_ignore_case : s16_seek_none; s16_seek_t find_flag = flags & s16_split_ignore_case ? s16_seek_ignore_case : s16_seek_none;
while (s16_seek(string, find, find_flag, &index)) { while (s16_seek(string, find, find_flag, &index)) {
s16_t before_match = s16(string.str, index); s16_t before_match = s16_make(string.str, index);
sb16_append(&result, before_match); sb16_append(&result, before_match);
if (flags & s16_split_inclusive) { if (flags & s16_split_inclusive) {
s16_t match = s16(string.str + index, find.len); s16_t match = s16_make(string.str + index, find.len);
sb16_append(&result, match); sb16_append(&result, match);
} }
string = s16_skip(string, index + find.len); string = s16_skip(string, index + find.len);
@@ -487,29 +479,28 @@ fn_test void test_string16(void) {
// string16 lit basic tests // string16 lit basic tests
{ {
s16_t a = s16_lit("memes"); s16_t a = s16("memes");
s16_t b = s16_lit("not memes");
s16_t c = s16_lit("MEMES");
assert(a.len == 5); assert(a.len == 5);
assert(a.str[0] == L'm'); assert(a.str[0] == char16('m'));
assert(a.str[4] == L's'); assert(a.str[4] == char16('s'));
s16_t b = s16("not memes");
s16_t c = s16("MEMES");
assert(s16_are_equal(a, b) == false); assert(s16_are_equal(a, b) == false);
assert(s16_are_equal(a, a) == true); assert(s16_are_equal(a, a) == true);
assert(s16_are_equal_ex(a, c, true) == true); assert(s16_are_equal_ex(a, c, true) == true);
assert(sizeof(wchar_t) == sizeof(u16));
} }
{ {
assert(u16_to_upper_case('a') == L'A'); assert(u16_to_upper_case('a') == char16('A'));
assert(u16_to_upper_case('a') == 'A'); assert(u16_to_upper_case('a') == 'A');
assert(u16_to_upper_case(L'a') == 'A'); assert(u16_to_upper_case(char16('a')) == 'A');
assert(u16_is_digit('3')); assert(u16_is_digit('3'));
} }
{ {
s16_t a = s16_from_wstr(L"memes"); s16_t a = s16_from_str16(str16("memes"));
assert(a.len == 5); assert(a.len == 5);
assert(s16_are_equal(a, s16_lit("memes")) == true); assert(s16_are_equal(a, s16("memes")) == true);
s16_t b = s16_copy(scratch.arena, a); s16_t b = s16_copy(scratch.arena, a);
assert(a.str != b.str); assert(a.str != b.str);
@@ -521,40 +512,40 @@ fn_test void test_string16(void) {
} }
{ {
s16_t a = s16_lit("thing itself"); s16_t a = s16("thing itself");
assert(s16_starts_with_ex(a, s16_lit("thing"), false)); assert(s16_starts_with_ex(a, s16("thing"), false));
assert(!s16_starts_with_ex(a, s16_lit("thing itself and"), false)); assert(!s16_starts_with_ex(a, s16("thing itself and"), false));
assert(!s16_starts_with_ex(a, s16_lit("thing itself "), false)); assert(!s16_starts_with_ex(a, s16("thing itself "), false));
assert(s16_starts_with_ex(a, s16_lit("THING"), true)); assert(s16_starts_with_ex(a, s16("THING"), true));
assert(!s16_starts_with_ex(a, s16_lit("a"), false)); assert(!s16_starts_with_ex(a, s16("a"), false));
assert(s16_ends_with_ex(a, s16_lit("itself"), false)); assert(s16_ends_with_ex(a, s16("itself"), false));
assert(s16_ends_with_ex(a, s16_lit("thing itself"), false)); assert(s16_ends_with_ex(a, s16("thing itself"), false));
assert(!s16_ends_with_ex(a, s16_lit("thing itselfa"), false)); assert(!s16_ends_with_ex(a, s16("thing itselfa"), false));
s16_t b = s16_lit("memes"); s16_t b = s16("memes");
assert(s16_is_pointer_inside(b, b.str)); assert(s16_is_pointer_inside(b, b.str));
assert(s16_is_pointer_inside(b, b.str + 4)); assert(s16_is_pointer_inside(b, b.str + 4));
assert(!s16_is_pointer_inside(b, b.str + 5)); assert(!s16_is_pointer_inside(b, b.str + 5));
} }
{ {
s16_t a = s16_lit("C:\\Program Files\\Memes"); s16_t a = s16("C:\\Program Files\\Memes");
s16_normalize_path_unsafe(a); s16_normalize_path_unsafe(a);
assert(a.str[2] == '/'); assert(a.str[2] == '/');
} }
{ {
s16_t a = s16_lit(" thing "); s16_t a = s16(" thing ");
s16_t b = s16_trim(a); s16_t b = s16_trim(a);
assert(s16_are_equal(b, s16_lit("thing"))); assert(s16_are_equal(b, s16("thing")));
} }
{ {
s16_t a = s16_printf(scratch.arena, "%d", 432); s16_t a = s16_printf(scratch.arena, "%d", 432);
assert(s16_are_equal(a, s16_lit("432"))); assert(s16_are_equal(a, s16("432")));
assert(f64_from_s16(s16_lit("432.0")) == 432.0); assert(f64_from_s16(s16("432.0")) == 432.0);
assert(u64_from_s16(s16_lit("432"), 10) == 432); assert(u64_from_s16(s16("432"), 10) == 432);
} }
{ {
@@ -563,31 +554,31 @@ fn_test void test_string16(void) {
sb16_printf(list, "ter "); sb16_printf(list, "ter ");
sb16_printf(list, "|"); sb16_printf(list, "|");
s16_t string = sb16_serial_end(scratch.arena, list); s16_t string = sb16_serial_end(scratch.arena, list);
assert(s16_are_equal(string, s16_lit("987 ter |"))); assert(s16_are_equal(string, s16("987 ter |")));
} }
{ {
s16_t a = s16_lit("A|B|dek|mek|vek|"); s16_t a = s16("A|B|dek|mek|vek|");
sb16_t b = s16_split(scratch.arena, a, s16_lit("|"), s16_split_none); sb16_t b = s16_split(scratch.arena, a, s16("|"), s16_split_none);
assert(s16_are_equal(b.first->string, s16_lit("A"))); assert(s16_are_equal(b.first->string, s16("A")));
assert(s16_are_equal(b.first->next->string, s16_lit("B"))); assert(s16_are_equal(b.first->next->string, s16("B")));
assert(s16_are_equal(b.first->next->next->string, s16_lit("dek"))); assert(s16_are_equal(b.first->next->next->string, s16("dek")));
assert(s16_are_equal(b.first->next->next->next->string, s16_lit("mek"))); assert(s16_are_equal(b.first->next->next->next->string, s16("mek")));
assert(s16_are_equal(b.first->next->next->next->next->string, s16_lit("vek"))); assert(s16_are_equal(b.first->next->next->next->next->string, s16("vek")));
assert(b.first->next->next->next->next->next == NULL); assert(b.first->next->next->next->next->next == NULL);
} }
{ {
s16_t a = s16_to_upper_case(scratch.arena, s16_lit("thing Meme")); s16_t a = s16_to_upper_case(scratch.arena, s16("thing Meme"));
assert(s16_are_equal(a, s16_lit("THING MEME"))); assert(s16_are_equal(a, s16("THING MEME")));
a = s16_to_lower_case(scratch.arena, s16_lit("THING Meme")); a = s16_to_lower_case(scratch.arena, s16("THING Meme"));
assert(s16_are_equal(a, s16_lit("thing meme"))); assert(s16_are_equal(a, s16("thing meme")));
} }
{ {
s16_t a = s16_lit("C:/thing/itself"); s16_t a = s16("C:/thing/itself");
assert(s16_are_equal(s16_chop_last_slash(a), s16_lit("C:/thing"))); assert(s16_are_equal(s16_chop_last_slash(a), s16("C:/thing")));
} }
ma_end_scratch(scratch); ma_end_scratch(scratch);

69
src/core/core_string16.h
View File

@@ -46,69 +46,16 @@ struct s32_t {
i64 len; i64 len;
}; };
#define s16(str,len) (s16_t){str, len} #define s16_make(str,len) (s16_t){str, len}
#define s16_lit(str) (s16_t){L##str, sizeof(L##str) / sizeof(u16) - 1}
#define s16(str) (s16_t){(u16 *)u##str, lengthof(str) - 1}
#define s16_const(string) { (u16 *)u##string, lengthof(string) - 1 }
#define s16_invalid s16_lit("<INVALID>") #define s16_invalid s16_lit("<INVALID>")
#define s16_null (s16_t){0}
#define str16(str) ((u16 *)u##str)
#define char16(str) ((u16)u##str)
#define sb16(ARENA) &(sb16_t){.arena = arena} #define sb16(ARENA) &(sb16_t){.arena = arena}
#define sb16_serial_begin(ARENA) &(sb16_t){.arena = ARENA} #define sb16_serial_begin(ARENA) &(sb16_t){.arena = ARENA}
#define sb16_serial_end(ARENA, SB) sb16_merge(ARENA, SB) #define sb16_serial_end(ARENA, SB) sb16_merge(ARENA, SB)
fn i64 wstr_len(wchar_t *string);
fn u16 u16_to_lower_case(u16 a);
fn u16 u16_to_upper_case(u16 a);
fn b32 u16_is_whitespace(u16 w);
fn b32 u16_is_alphabetic(u16 a);
fn b32 u16_is_ident(u16 a);
fn b32 u16_is_digit(u16 a);
fn b32 u16_is_alphanumeric(u16 a);
fn s16_t s16_from_range(u16 *begin, u16 *end);
fn s16_t s16_from_u16(u16 *string);
fn s16_t s16_from_wstr(wchar_t *string);
fn s16_t s16_copy(ma_arena_t *ma, s16_t string);
fn s16_t s16_copy_u16(ma_arena_t *ma, u16 *s);
fn s16_t s16_copy_wstr(ma_arena_t *ma, wchar_t *s);
fn b32 s16_are_equal_ex(s16_t a, s16_t b, b32 ignore_case);
fn b32 s16_are_equal(s16_t a, s16_t b);
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);
fn s16_t s16_get_postfix(s16_t string, i64 len);
fn s16_t s16_get_prefix(s16_t string, i64 len);
fn s16_t s16_chop(s16_t string, i64 len);
fn s16_t s16_skip(s16_t string, i64 len);
fn b32 s16_ends_with_ex(s16_t a, s16_t end, b32 ignore_case);
fn b32 s16_starts_with_ex(s16_t a, s16_t start, b32 ignore_case);
fn b32 s16_ends_with(s16_t a, s16_t end);
fn b32 s16_starts_with(s16_t a, s16_t start);
fn void s16_normalize_path_unsafe(s16_t s);
fn s16_t s16_normalize_path(ma_arena_t *ma, s16_t s);
fn b32 s16_is_pointer_inside(s16_t string, u16 *p);
fn s16_t s16_cut_start(s16_t *in, i64 size);
fn s16_t s16_cut_end(s16_t *in, i64 size);
fn s16_t s16_slice(s16_t string, i64 first_index, i64 one_past_last_index);
fn s16_t s16_trim(s16_t string);
fn s16_t s16_trim_end(s16_t string);
fn b32 s16_seek(s16_t string, s16_t find, s16_seek_t flags, int64_t *index_out);
fn int64_t s16_find(s16_t string, s16_t find, s16_seek_t flag);
fn s16_t s16_chop_last_char(s16_t s, s16_t ch);
fn s16_t s16_chop_last_slash(s16_t s);
fn s16_t s16_chop_last_period(s16_t s);
fn s16_t s16_skip_to_last_char(s16_t s, s16_t ch);
fn s16_t s16_skip_to_last_slash(s16_t s);
fn s16_t s16_skip_to_last_period(s16_t s);
fn s16_t s16_get_name_no_ext(s16_t s);
fn s16_t s16_to_lower_case(ma_arena_t *ma, s16_t s);
fn s16_t s16_to_upper_case(ma_arena_t *ma, s16_t s);
fn s16_t s16_printf(ma_arena_t *ma, const char *str, ...);
fn u64 u64_from_s16(s16_t s, u64 base);
fn f64 f64_from_s16(s16_t string);
fn i64 s16_fuzzy_rate(s16_t string, s16_t with);
fn fuzzy_pair_t *s16_fuzzy_rate_array(ma_arena_t *arena, s16_t needle, s16_t *array, i32 len);
fn sb16_node_t *sb16_create_node(ma_arena_t *ma, s16_t str);
fn sb16_node_t *sb16_append(sb16_t *list, s16_t string);
fn s16_t sb16_printf(sb16_t *sb, const char *str, ...);
fn void sb16_indent(sb16_t *sb);
fn s16_t sb16_stmtf(sb16_t *sb, const char *str, ...);
fn int64_t sb16_char_size(sb16_t *sb);
fn s16_t sb16_merge(ma_arena_t *arena, sb16_t *sb);
fn sb16_t s16_split(ma_arena_t *ma, s16_t string, s16_t find, s16_split_t flags);

2
src/core/core_type_info.c
View File

@@ -6,7 +6,7 @@ fn s8_t ti_enum_value_to_name(i64 value, type_t *type) {
return it->name; return it->name;
} }
} }
return s8_lit("invalid"); return s8("invalid");
} }
fn i64 ti_enum_name_to_value(s8_t name, type_t *type) { fn i64 ti_enum_name_to_value(s8_t name, type_t *type) {

298
src/core/core_type_info.h
View File

@@ -80,278 +80,278 @@ fn type_member_t *ti_get_member(s8_t name, type_t *type);
// //
// core type info data // core type info data
#define type(X) (&type__##X) #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_ENUM(x) type_t type__##x = {type_kind_enum, s8_const(#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 DEFINE_STRUCT(x) type_t type__##x = {type_kind_struct, s8_const(#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} #define POINTER(x) (type_t){type_kind_pointer, s8_const(#x "*"), sizeof(void *), .base = &type__##x}
gb_read_only type_t type__i8 = {type_kind_i8, s8_const_lit("i8"), sizeof(i8)}; gb_read_only type_t type__i8 = {type_kind_i8, s8_const("i8"), sizeof(i8)};
gb_read_only type_t type__i16 = {type_kind_i16, s8_const_lit("i16"), sizeof(i16)}; gb_read_only type_t type__i16 = {type_kind_i16, s8_const("i16"), sizeof(i16)};
gb_read_only type_t type__i32 = {type_kind_i32, s8_const_lit("i32"), sizeof(i32)}; gb_read_only type_t type__i32 = {type_kind_i32, s8_const("i32"), sizeof(i32)};
gb_read_only type_t type__i64 = {type_kind_i64, s8_const_lit("i64"), sizeof(i64)}; gb_read_only type_t type__i64 = {type_kind_i64, s8_const("i64"), sizeof(i64)};
gb_read_only type_t type__u8 = {type_kind_u8, s8_const_lit("u8"), sizeof(u8)}; gb_read_only type_t type__u8 = {type_kind_u8, s8_const("u8"), sizeof(u8)};
gb_read_only type_t type__u16 = {type_kind_u16, s8_const_lit("u16"), sizeof(u16)}; gb_read_only type_t type__u16 = {type_kind_u16, s8_const("u16"), sizeof(u16)};
gb_read_only type_t type__u32 = {type_kind_u32, s8_const_lit("u32"), sizeof(u32)}; gb_read_only type_t type__u32 = {type_kind_u32, s8_const("u32"), sizeof(u32)};
gb_read_only type_t type__u64 = {type_kind_u64, s8_const_lit("u64"), sizeof(u64)}; gb_read_only type_t type__u64 = {type_kind_u64, s8_const("u64"), sizeof(u64)};
gb_read_only type_t type__b8 = {type_kind_b8, s8_const_lit("b8"), sizeof(b8)}; gb_read_only type_t type__b8 = {type_kind_b8, s8_const("b8"), sizeof(b8)};
gb_read_only type_t type__b16 = {type_kind_b16, s8_const_lit("b16"), sizeof(b16)}; gb_read_only type_t type__b16 = {type_kind_b16, s8_const("b16"), sizeof(b16)};
gb_read_only type_t type__b32 = {type_kind_b32, s8_const_lit("b32"), sizeof(b32)}; gb_read_only type_t type__b32 = {type_kind_b32, s8_const("b32"), sizeof(b32)};
gb_read_only type_t type__b64 = {type_kind_b64, s8_const_lit("b64"), sizeof(b64)}; gb_read_only type_t type__b64 = {type_kind_b64, s8_const("b64"), sizeof(b64)};
gb_read_only type_t type__f32 = {type_kind_f32, s8_const_lit("f32"), sizeof(f32)}; gb_read_only type_t type__f32 = {type_kind_f32, s8_const("f32"), sizeof(f32)};
gb_read_only type_t type__f64 = {type_kind_f64, s8_const_lit("f64"), sizeof(f64)}; gb_read_only type_t type__f64 = {type_kind_f64, s8_const("f64"), sizeof(f64)};
gb_read_only type_t type__isize = {type_kind_isize, s8_const_lit("isize"), sizeof(isize)}; gb_read_only type_t type__isize = {type_kind_isize, s8_const("isize"), sizeof(isize)};
gb_read_only type_t type__usize = {type_kind_usize, s8_const_lit("usize"), sizeof(usize)}; gb_read_only type_t type__usize = {type_kind_usize, s8_const("usize"), sizeof(usize)};
gb_read_only type_t type__int = {type_kind_int, s8_const_lit("int"), sizeof(int)}; gb_read_only type_t type__int = {type_kind_int, s8_const("int"), sizeof(int)};
gb_read_only type_t type__char = {type_kind_char, s8_const_lit("char"), sizeof(char)}; gb_read_only type_t type__char = {type_kind_char, s8_const("char"), sizeof(char)};
gb_read_only type_t type__void = {type_kind_void, s8_const_lit("void")}; gb_read_only type_t type__void = {type_kind_void, s8_const("void")};
gb_read_only type_t type__s8_t = { type_kind_struct, s8_const_lit("s8_t"), sizeof(s8_t), .count = 2, gb_read_only type_t type__s8_t = { type_kind_struct, s8_const("s8_t"), sizeof(s8_t), .count = 2,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("str"), &POINTER(char), .offset = offsetof(s8_t, str)}, {s8_const("str"), &POINTER(char), .offset = offsetof(s8_t, str)},
{s8_const_lit("len"), &type__i64, .offset = offsetof(s8_t, len)}, {s8_const("len"), &type__i64, .offset = offsetof(s8_t, len)},
} }
}; };
gb_read_only type_t type__s16_t = { type_kind_struct, s8_const_lit("s16_t"), sizeof(s16_t), .count = 2, gb_read_only type_t type__s16_t = { type_kind_struct, s8_const("s16_t"), sizeof(s16_t), .count = 2,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("str"), &POINTER(u16), .offset = offsetof(s16_t, str)}, {s8_const("str"), &POINTER(u16), .offset = offsetof(s16_t, str)},
{s8_const_lit("len"), &type__i64, .offset = offsetof(s16_t, len)}, {s8_const("len"), &type__i64, .offset = offsetof(s16_t, len)},
} }
}; };
gb_read_only type_t type__s32_t = { type_kind_struct, s8_const_lit("s32_t"), sizeof(s32_t), .count = 2, gb_read_only type_t type__s32_t = { type_kind_struct, s8_const("s32_t"), sizeof(s32_t), .count = 2,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("str"), &POINTER(u32), .offset = offsetof(s32_t, str)}, {s8_const("str"), &POINTER(u32), .offset = offsetof(s32_t, str)},
{s8_const_lit("len"), &type__i64, .offset = offsetof(s32_t, len)}, {s8_const("len"), &type__i64, .offset = offsetof(s32_t, len)},
} }
}; };
gb_read_only type_t type__ma_arena_t = { type_kind_struct, s8_const_lit("ma_arena_t"), sizeof(ma_arena_t), .count = 6, gb_read_only type_t type__ma_arena_t = { type_kind_struct, s8_const("ma_arena_t"), sizeof(ma_arena_t), .count = 6,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("data"), &POINTER(u8), .offset = offsetof(ma_arena_t, data)}, {s8_const("data"), &POINTER(u8), .offset = offsetof(ma_arena_t, data)},
{s8_const_lit("len"), &type__usize, .offset = offsetof(ma_arena_t, len)}, {s8_const("len"), &type__usize, .offset = offsetof(ma_arena_t, len)},
{s8_const_lit("base_len"), &type__usize, .offset = offsetof(ma_arena_t, base_len)}, {s8_const("base_len"), &type__usize, .offset = offsetof(ma_arena_t, base_len)},
{s8_const_lit("reserve"), &type__usize, .offset = offsetof(ma_arena_t, reserve)}, {s8_const("reserve"), &type__usize, .offset = offsetof(ma_arena_t, reserve)},
{s8_const_lit("commit"), &type__usize, .offset = offsetof(ma_arena_t, commit)}, {s8_const("commit"), &type__usize, .offset = offsetof(ma_arena_t, commit)},
{s8_const_lit("align"), &type__usize, .offset = offsetof(ma_arena_t, align)}, {s8_const("align"), &type__usize, .offset = offsetof(ma_arena_t, align)},
} }
}; };
gb_read_only type_t type__sb8_node_t = {type_kind_struct, s8_const_lit("sb8_node_t"), sizeof(sb8_t), .count = 2, gb_read_only type_t type__sb8_node_t = {type_kind_struct, s8_const("sb8_node_t"), sizeof(sb8_t), .count = 2,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("next"), &POINTER(sb8_node_t), .offset = offsetof(sb8_node_t, next)}, {s8_const("next"), &POINTER(sb8_node_t), .offset = offsetof(sb8_node_t, next)},
{s8_const_lit("string"), &type__s8_t, .offset = offsetof(sb8_node_t, string)}, {s8_const("string"), &type__s8_t, .offset = offsetof(sb8_node_t, string)},
} }
}; };
gb_read_only type_t type__sb8_t = { type_kind_struct, s8_const_lit("sb8_t"), sizeof(sb8_t), .count = 4, gb_read_only type_t type__sb8_t = { type_kind_struct, s8_const("sb8_t"), sizeof(sb8_t), .count = 4,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("arena"), &POINTER(ma_arena_t), .offset = offsetof(sb8_t, arena)}, {s8_const("arena"), &POINTER(ma_arena_t), .offset = offsetof(sb8_t, arena)},
{s8_const_lit("first"), &POINTER(sb8_node_t), .offset = offsetof(sb8_t, first)}, {s8_const("first"), &POINTER(sb8_node_t), .offset = offsetof(sb8_t, first)},
{s8_const_lit("last"), &POINTER(sb8_node_t), .offset = offsetof(sb8_t, last)}, {s8_const("last"), &POINTER(sb8_node_t), .offset = offsetof(sb8_t, last)},
{s8_const_lit("indent"), &type__i32, .offset = offsetof(sb8_t, indent)}, {s8_const("indent"), &type__i32, .offset = offsetof(sb8_t, indent)},
} }
}; };
gb_read_only type_t type__ma_temp_t = { type_kind_struct, s8_const_lit("ma_temp_t"), sizeof(ma_temp_t), .count = 2, gb_read_only type_t type__ma_temp_t = { type_kind_struct, s8_const("ma_temp_t"), sizeof(ma_temp_t), .count = 2,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("arena"), &POINTER(ma_arena_t), .offset = offsetof(ma_temp_t, arena)}, {s8_const("arena"), &POINTER(ma_arena_t), .offset = offsetof(ma_temp_t, arena)},
{s8_const_lit("len"), &type__usize, .offset = offsetof(ma_temp_t, len)}, {s8_const("len"), &type__usize, .offset = offsetof(ma_temp_t, len)},
} }
}; };
gb_read_only type_t type__v2f32_t = { type_kind_struct, s8_const_lit("v2f32_t"), sizeof(v2f32_t), .count = 2, gb_read_only type_t type__v2f32_t = { type_kind_struct, s8_const("v2f32_t"), sizeof(v2f32_t), .count = 2,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x"), &type__f32, .offset = offsetof(v2f32_t, x)}, {s8_const("x"), &type__f32, .offset = offsetof(v2f32_t, x)},
{s8_const_lit("y"), &type__f32, .offset = offsetof(v2f32_t, y)}, {s8_const("y"), &type__f32, .offset = offsetof(v2f32_t, y)},
} }
}; };
gb_read_only type_t type__v3f32_t = { type_kind_struct, s8_const_lit("v3f32_t"), sizeof(v3f32_t), .count = 3, gb_read_only type_t type__v3f32_t = { type_kind_struct, s8_const("v3f32_t"), sizeof(v3f32_t), .count = 3,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x"), &type__f32, .offset = offsetof(v3f32_t, x)}, {s8_const("x"), &type__f32, .offset = offsetof(v3f32_t, x)},
{s8_const_lit("y"), &type__f32, .offset = offsetof(v3f32_t, y)}, {s8_const("y"), &type__f32, .offset = offsetof(v3f32_t, y)},
{s8_const_lit("z"), &type__f32, .offset = offsetof(v3f32_t, z)}, {s8_const("z"), &type__f32, .offset = offsetof(v3f32_t, z)},
} }
}; };
gb_read_only type_t type__v4f32_t = { type_kind_struct, s8_const_lit("v4f32_t"), sizeof(v4f32_t), .count = 4, gb_read_only type_t type__v4f32_t = { type_kind_struct, s8_const("v4f32_t"), sizeof(v4f32_t), .count = 4,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x"), &type__f32, .offset = offsetof(v4f32_t, x)}, {s8_const("x"), &type__f32, .offset = offsetof(v4f32_t, x)},
{s8_const_lit("y"), &type__f32, .offset = offsetof(v4f32_t, y)}, {s8_const("y"), &type__f32, .offset = offsetof(v4f32_t, y)},
{s8_const_lit("z"), &type__f32, .offset = offsetof(v4f32_t, z)}, {s8_const("z"), &type__f32, .offset = offsetof(v4f32_t, z)},
{s8_const_lit("w"), &type__f32, .offset = offsetof(v4f32_t, w)}, {s8_const("w"), &type__f32, .offset = offsetof(v4f32_t, w)},
} }
}; };
gb_read_only type_t type__r3f32_t = { type_kind_struct, s8_const_lit("r3f32_t"), sizeof(r3f32_t), .count = 6, gb_read_only type_t type__r3f32_t = { type_kind_struct, s8_const("r3f32_t"), sizeof(r3f32_t), .count = 6,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x0"), &type__f32, .offset = offsetof(r3f32_t, x0)}, {s8_const("x0"), &type__f32, .offset = offsetof(r3f32_t, x0)},
{s8_const_lit("y0"), &type__f32, .offset = offsetof(r3f32_t, y0)}, {s8_const("y0"), &type__f32, .offset = offsetof(r3f32_t, y0)},
{s8_const_lit("x0"), &type__f32, .offset = offsetof(r3f32_t, z0)}, {s8_const("x0"), &type__f32, .offset = offsetof(r3f32_t, z0)},
{s8_const_lit("x1"), &type__f32, .offset = offsetof(r3f32_t, x1)}, {s8_const("x1"), &type__f32, .offset = offsetof(r3f32_t, x1)},
{s8_const_lit("y1"), &type__f32, .offset = offsetof(r3f32_t, y1)}, {s8_const("y1"), &type__f32, .offset = offsetof(r3f32_t, y1)},
{s8_const_lit("x1"), &type__f32, .offset = offsetof(r3f32_t, z1)}, {s8_const("x1"), &type__f32, .offset = offsetof(r3f32_t, z1)},
} }
}; };
gb_read_only type_member_t members__r2f32_t[] = { gb_read_only type_member_t members__r2f32_t[] = {
{s8_const_lit("x0"), &type__f32, .offset = offsetof(r2f32_t, x0)}, {s8_const("x0"), &type__f32, .offset = offsetof(r2f32_t, x0)},
{s8_const_lit("y0"), &type__f32, .offset = offsetof(r2f32_t, y0)}, {s8_const("y0"), &type__f32, .offset = offsetof(r2f32_t, y0)},
{s8_const_lit("x1"), &type__f32, .offset = offsetof(r2f32_t, x1)}, {s8_const("x1"), &type__f32, .offset = offsetof(r2f32_t, x1)},
{s8_const_lit("y1"), &type__f32, .offset = offsetof(r2f32_t, y1)}, {s8_const("y1"), &type__f32, .offset = offsetof(r2f32_t, y1)},
}; };
gb_read_only DEFINE_STRUCT(r2f32_t); gb_read_only DEFINE_STRUCT(r2f32_t);
gb_read_only type_member_t members__r1f32_t[] = { gb_read_only type_member_t members__r1f32_t[] = {
{s8_const_lit("x0"), &type__f32, .offset = offsetof(r1f32_t, x0)}, {s8_const("x0"), &type__f32, .offset = offsetof(r1f32_t, x0)},
{s8_const_lit("x1"), &type__f32, .offset = offsetof(r1f32_t, x1)}, {s8_const("x1"), &type__f32, .offset = offsetof(r1f32_t, x1)},
}; };
gb_read_only DEFINE_STRUCT(r1f32_t); gb_read_only DEFINE_STRUCT(r1f32_t);
gb_read_only type_t type__v2f64_t = { type_kind_struct, s8_const_lit("v2f64_t"), sizeof(v2f64_t), .count = 2, gb_read_only type_t type__v2f64_t = { type_kind_struct, s8_const("v2f64_t"), sizeof(v2f64_t), .count = 2,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x"), &type__f64, .offset = offsetof(v2f64_t, x)}, {s8_const("x"), &type__f64, .offset = offsetof(v2f64_t, x)},
{s8_const_lit("y"), &type__f64, .offset = offsetof(v2f64_t, y)}, {s8_const("y"), &type__f64, .offset = offsetof(v2f64_t, y)},
} }
}; };
gb_read_only type_t type__v3f64_t = { type_kind_struct, s8_const_lit("v3f64_t"), sizeof(v3f64_t), .count = 3, gb_read_only type_t type__v3f64_t = { type_kind_struct, s8_const("v3f64_t"), sizeof(v3f64_t), .count = 3,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x"), &type__f64, .offset = offsetof(v3f64_t, x)}, {s8_const("x"), &type__f64, .offset = offsetof(v3f64_t, x)},
{s8_const_lit("y"), &type__f64, .offset = offsetof(v3f64_t, y)}, {s8_const("y"), &type__f64, .offset = offsetof(v3f64_t, y)},
{s8_const_lit("z"), &type__f64, .offset = offsetof(v3f64_t, z)}, {s8_const("z"), &type__f64, .offset = offsetof(v3f64_t, z)},
} }
}; };
gb_read_only type_t type__v4f64_t = { type_kind_struct, s8_const_lit("v4f64_t"), sizeof(v4f64_t), .count = 4, gb_read_only type_t type__v4f64_t = { type_kind_struct, s8_const("v4f64_t"), sizeof(v4f64_t), .count = 4,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x"), &type__f64, .offset = offsetof(v4f64_t, x)}, {s8_const("x"), &type__f64, .offset = offsetof(v4f64_t, x)},
{s8_const_lit("y"), &type__f64, .offset = offsetof(v4f64_t, y)}, {s8_const("y"), &type__f64, .offset = offsetof(v4f64_t, y)},
{s8_const_lit("z"), &type__f64, .offset = offsetof(v4f64_t, z)}, {s8_const("z"), &type__f64, .offset = offsetof(v4f64_t, z)},
{s8_const_lit("w"), &type__f64, .offset = offsetof(v4f64_t, w)}, {s8_const("w"), &type__f64, .offset = offsetof(v4f64_t, w)},
} }
}; };
gb_read_only type_t type__r3f64_t = { type_kind_struct, s8_const_lit("r3f64_t"), sizeof(r3f64_t), .count = 6, gb_read_only type_t type__r3f64_t = { type_kind_struct, s8_const("r3f64_t"), sizeof(r3f64_t), .count = 6,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, x0)}, {s8_const("x0"), &type__f64, .offset = offsetof(r3f64_t, x0)},
{s8_const_lit("y0"), &type__f64, .offset = offsetof(r3f64_t, y0)}, {s8_const("y0"), &type__f64, .offset = offsetof(r3f64_t, y0)},
{s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, z0)}, {s8_const("x0"), &type__f64, .offset = offsetof(r3f64_t, z0)},
{s8_const_lit("x1"), &type__f64, .offset = offsetof(r3f64_t, x1)}, {s8_const("x1"), &type__f64, .offset = offsetof(r3f64_t, x1)},
{s8_const_lit("y1"), &type__f64, .offset = offsetof(r3f64_t, y1)}, {s8_const("y1"), &type__f64, .offset = offsetof(r3f64_t, y1)},
{s8_const_lit("x1"), &type__f64, .offset = offsetof(r3f64_t, z1)}, {s8_const("x1"), &type__f64, .offset = offsetof(r3f64_t, z1)},
} }
}; };
gb_read_only type_member_t members__r2f64_t[] = { gb_read_only type_member_t members__r2f64_t[] = {
{s8_const_lit("x0"), &type__f64, .offset = offsetof(r2f64_t, x0)}, {s8_const("x0"), &type__f64, .offset = offsetof(r2f64_t, x0)},
{s8_const_lit("y0"), &type__f64, .offset = offsetof(r2f64_t, y0)}, {s8_const("y0"), &type__f64, .offset = offsetof(r2f64_t, y0)},
{s8_const_lit("x1"), &type__f64, .offset = offsetof(r2f64_t, x1)}, {s8_const("x1"), &type__f64, .offset = offsetof(r2f64_t, x1)},
{s8_const_lit("y1"), &type__f64, .offset = offsetof(r2f64_t, y1)}, {s8_const("y1"), &type__f64, .offset = offsetof(r2f64_t, y1)},
}; };
gb_read_only DEFINE_STRUCT(r2f64_t); gb_read_only DEFINE_STRUCT(r2f64_t);
gb_read_only type_member_t members__r1f64_t[] = { gb_read_only type_member_t members__r1f64_t[] = {
{s8_const_lit("x0"), &type__f64, .offset = offsetof(r1f64_t, x0)}, {s8_const("x0"), &type__f64, .offset = offsetof(r1f64_t, x0)},
{s8_const_lit("x1"), &type__f64, .offset = offsetof(r1f64_t, x1)}, {s8_const("x1"), &type__f64, .offset = offsetof(r1f64_t, x1)},
}; };
gb_read_only DEFINE_STRUCT(r1f64_t); gb_read_only DEFINE_STRUCT(r1f64_t);
gb_read_only type_t type__v2i32_t = { type_kind_struct, s8_const_lit("v2i32_t"), sizeof(v2i32_t), .count = 2, gb_read_only type_t type__v2i32_t = { type_kind_struct, s8_const("v2i32_t"), sizeof(v2i32_t), .count = 2,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x"), &type__i32, .offset = offsetof(v2i32_t, x)}, {s8_const("x"), &type__i32, .offset = offsetof(v2i32_t, x)},
{s8_const_lit("y"), &type__i32, .offset = offsetof(v2i32_t, y)}, {s8_const("y"), &type__i32, .offset = offsetof(v2i32_t, y)},
} }
}; };
gb_read_only type_t type__v3i32_t = { type_kind_struct, s8_const_lit("v3i32_t"), sizeof(v3i32_t), .count = 3, gb_read_only type_t type__v3i32_t = { type_kind_struct, s8_const("v3i32_t"), sizeof(v3i32_t), .count = 3,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x"), &type__i32, .offset = offsetof(v3i32_t, x)}, {s8_const("x"), &type__i32, .offset = offsetof(v3i32_t, x)},
{s8_const_lit("y"), &type__i32, .offset = offsetof(v3i32_t, y)}, {s8_const("y"), &type__i32, .offset = offsetof(v3i32_t, y)},
{s8_const_lit("z"), &type__i32, .offset = offsetof(v3i32_t, z)}, {s8_const("z"), &type__i32, .offset = offsetof(v3i32_t, z)},
} }
}; };
gb_read_only type_t type__v4i32_t = { type_kind_struct, s8_const_lit("v4i32_t"), sizeof(v4i32_t), .count = 4, gb_read_only type_t type__v4i32_t = { type_kind_struct, s8_const("v4i32_t"), sizeof(v4i32_t), .count = 4,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x"), &type__i32, .offset = offsetof(v4i32_t, x)}, {s8_const("x"), &type__i32, .offset = offsetof(v4i32_t, x)},
{s8_const_lit("y"), &type__i32, .offset = offsetof(v4i32_t, y)}, {s8_const("y"), &type__i32, .offset = offsetof(v4i32_t, y)},
{s8_const_lit("z"), &type__i32, .offset = offsetof(v4i32_t, z)}, {s8_const("z"), &type__i32, .offset = offsetof(v4i32_t, z)},
{s8_const_lit("w"), &type__i32, .offset = offsetof(v4i32_t, w)}, {s8_const("w"), &type__i32, .offset = offsetof(v4i32_t, w)},
} }
}; };
gb_read_only type_t type__r3i32_t = { type_kind_struct, s8_const_lit("r3i32_t"), sizeof(r3i32_t), .count = 6, gb_read_only type_t type__r3i32_t = { type_kind_struct, s8_const("r3i32_t"), sizeof(r3i32_t), .count = 6,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x0"), &type__i32, .offset = offsetof(r3i32_t, x0)}, {s8_const("x0"), &type__i32, .offset = offsetof(r3i32_t, x0)},
{s8_const_lit("y0"), &type__i32, .offset = offsetof(r3i32_t, y0)}, {s8_const("y0"), &type__i32, .offset = offsetof(r3i32_t, y0)},
{s8_const_lit("x0"), &type__i32, .offset = offsetof(r3i32_t, z0)}, {s8_const("x0"), &type__i32, .offset = offsetof(r3i32_t, z0)},
{s8_const_lit("x1"), &type__i32, .offset = offsetof(r3i32_t, x1)}, {s8_const("x1"), &type__i32, .offset = offsetof(r3i32_t, x1)},
{s8_const_lit("y1"), &type__i32, .offset = offsetof(r3i32_t, y1)}, {s8_const("y1"), &type__i32, .offset = offsetof(r3i32_t, y1)},
{s8_const_lit("x1"), &type__i32, .offset = offsetof(r3i32_t, z1)}, {s8_const("x1"), &type__i32, .offset = offsetof(r3i32_t, z1)},
} }
}; };
gb_read_only type_member_t members__r2i32_t[] = { gb_read_only type_member_t members__r2i32_t[] = {
{s8_const_lit("x0"), &type__i32, .offset = offsetof(r2i32_t, x0)}, {s8_const("x0"), &type__i32, .offset = offsetof(r2i32_t, x0)},
{s8_const_lit("y0"), &type__i32, .offset = offsetof(r2i32_t, y0)}, {s8_const("y0"), &type__i32, .offset = offsetof(r2i32_t, y0)},
{s8_const_lit("x1"), &type__i32, .offset = offsetof(r2i32_t, x1)}, {s8_const("x1"), &type__i32, .offset = offsetof(r2i32_t, x1)},
{s8_const_lit("y1"), &type__i32, .offset = offsetof(r2i32_t, y1)}, {s8_const("y1"), &type__i32, .offset = offsetof(r2i32_t, y1)},
}; };
gb_read_only DEFINE_STRUCT(r2i32_t); gb_read_only DEFINE_STRUCT(r2i32_t);
gb_read_only type_member_t members__r1i32_t[] = { gb_read_only type_member_t members__r1i32_t[] = {
{s8_const_lit("x0"), &type__i32, .offset = offsetof(r1i32_t, x0)}, {s8_const("x0"), &type__i32, .offset = offsetof(r1i32_t, x0)},
{s8_const_lit("x1"), &type__i32, .offset = offsetof(r1i32_t, x1)}, {s8_const("x1"), &type__i32, .offset = offsetof(r1i32_t, x1)},
}; };
gb_read_only DEFINE_STRUCT(r1i32_t); gb_read_only DEFINE_STRUCT(r1i32_t);
gb_read_only type_t type__v2i64_t = { type_kind_struct, s8_const_lit("v2i64_t"), sizeof(v2i64_t), .count = 2, gb_read_only type_t type__v2i64_t = { type_kind_struct, s8_const("v2i64_t"), sizeof(v2i64_t), .count = 2,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x"), &type__i64, .offset = offsetof(v2i64_t, x)}, {s8_const("x"), &type__i64, .offset = offsetof(v2i64_t, x)},
{s8_const_lit("y"), &type__i64, .offset = offsetof(v2i64_t, y)}, {s8_const("y"), &type__i64, .offset = offsetof(v2i64_t, y)},
} }
}; };
gb_read_only type_t type__v3i64_t = { type_kind_struct, s8_const_lit("v3i64_t"), sizeof(v3i64_t), .count = 3, gb_read_only type_t type__v3i64_t = { type_kind_struct, s8_const("v3i64_t"), sizeof(v3i64_t), .count = 3,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x"), &type__i64, .offset = offsetof(v3i64_t, x)}, {s8_const("x"), &type__i64, .offset = offsetof(v3i64_t, x)},
{s8_const_lit("y"), &type__i64, .offset = offsetof(v3i64_t, y)}, {s8_const("y"), &type__i64, .offset = offsetof(v3i64_t, y)},
{s8_const_lit("z"), &type__i64, .offset = offsetof(v3i64_t, z)}, {s8_const("z"), &type__i64, .offset = offsetof(v3i64_t, z)},
} }
}; };
gb_read_only type_t type__v4i64_t = { type_kind_struct, s8_const_lit("v4i64_t"), sizeof(v4i64_t), .count = 4, gb_read_only type_t type__v4i64_t = { type_kind_struct, s8_const("v4i64_t"), sizeof(v4i64_t), .count = 4,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x"), &type__i64, .offset = offsetof(v4i64_t, x)}, {s8_const("x"), &type__i64, .offset = offsetof(v4i64_t, x)},
{s8_const_lit("y"), &type__i64, .offset = offsetof(v4i64_t, y)}, {s8_const("y"), &type__i64, .offset = offsetof(v4i64_t, y)},
{s8_const_lit("z"), &type__i64, .offset = offsetof(v4i64_t, z)}, {s8_const("z"), &type__i64, .offset = offsetof(v4i64_t, z)},
{s8_const_lit("w"), &type__i64, .offset = offsetof(v4i64_t, w)}, {s8_const("w"), &type__i64, .offset = offsetof(v4i64_t, w)},
} }
}; };
gb_read_only type_t type__r3i64_t = { type_kind_struct, s8_const_lit("r3i64_t"), sizeof(r3i64_t), .count = 6, gb_read_only type_t type__r3i64_t = { type_kind_struct, s8_const("r3i64_t"), sizeof(r3i64_t), .count = 6,
.members = (type_member_t[]){ .members = (type_member_t[]){
{s8_const_lit("x0"), &type__i64, .offset = offsetof(r3i64_t, x0)}, {s8_const("x0"), &type__i64, .offset = offsetof(r3i64_t, x0)},
{s8_const_lit("y0"), &type__i64, .offset = offsetof(r3i64_t, y0)}, {s8_const("y0"), &type__i64, .offset = offsetof(r3i64_t, y0)},
{s8_const_lit("x0"), &type__i64, .offset = offsetof(r3i64_t, z0)}, {s8_const("x0"), &type__i64, .offset = offsetof(r3i64_t, z0)},
{s8_const_lit("x1"), &type__i64, .offset = offsetof(r3i64_t, x1)}, {s8_const("x1"), &type__i64, .offset = offsetof(r3i64_t, x1)},
{s8_const_lit("y1"), &type__i64, .offset = offsetof(r3i64_t, y1)}, {s8_const("y1"), &type__i64, .offset = offsetof(r3i64_t, y1)},
{s8_const_lit("x1"), &type__i64, .offset = offsetof(r3i64_t, z1)}, {s8_const("x1"), &type__i64, .offset = offsetof(r3i64_t, z1)},
} }
}; };
gb_read_only type_member_t members__r2i64_t[] = { gb_read_only type_member_t members__r2i64_t[] = {
{s8_const_lit("x0"), &type__i64, .offset = offsetof(r2i64_t, x0)}, {s8_const("x0"), &type__i64, .offset = offsetof(r2i64_t, x0)},
{s8_const_lit("y0"), &type__i64, .offset = offsetof(r2i64_t, y0)}, {s8_const("y0"), &type__i64, .offset = offsetof(r2i64_t, y0)},
{s8_const_lit("x1"), &type__i64, .offset = offsetof(r2i64_t, x1)}, {s8_const("x1"), &type__i64, .offset = offsetof(r2i64_t, x1)},
{s8_const_lit("y1"), &type__i64, .offset = offsetof(r2i64_t, y1)}, {s8_const("y1"), &type__i64, .offset = offsetof(r2i64_t, y1)},
}; };
gb_read_only DEFINE_STRUCT(r2i64_t); gb_read_only DEFINE_STRUCT(r2i64_t);
gb_read_only type_member_t members__r1i64_t[] = { gb_read_only type_member_t members__r1i64_t[] = {
{s8_const_lit("x0"), &type__i64, .offset = offsetof(r1i64_t, x0)}, {s8_const("x0"), &type__i64, .offset = offsetof(r1i64_t, x0)},
{s8_const_lit("x1"), &type__i64, .offset = offsetof(r1i64_t, x1)}, {s8_const("x1"), &type__i64, .offset = offsetof(r1i64_t, x1)},
}; };
gb_read_only DEFINE_STRUCT(r1i64_t); gb_read_only DEFINE_STRUCT(r1i64_t);

6
src/meta/meta_cfiles.c
View File

@@ -116,8 +116,8 @@ fn s8_t mt_serial_to_cbyte_array(ma_arena_t *arena, s8_t file, s8_t var_name) {
return result; return result;
} }
#define mt_cpath(arena) mt_gen_filename(arena, S8_FILE, s8_lit("c")) #define mt_cpath(arena) mt_gen_filename(arena, S8_FILE, s8("c"))
#define mt_hpath(arena) mt_gen_filename(arena, S8_FILE, s8_lit("h")) #define mt_hpath(arena) mt_gen_filename(arena, S8_FILE, s8("h"))
fn s8_t mt_gen_filename(ma_arena_t *arena, s8_t lit_file, s8_t ext) { fn s8_t mt_gen_filename(ma_arena_t *arena, s8_t lit_file, s8_t ext) {
s8_t file_noext = s8_chop_last_period(s8_chop_last_period(lit_file)); s8_t file_noext = s8_chop_last_period(s8_chop_last_period(lit_file));
s8_t file = s8_printf(arena, "%S.gen.%S", file_noext, ext); s8_t file = s8_printf(arena, "%S.gen.%S", file_noext, ext);
@@ -134,6 +134,6 @@ fn s8_t mt__main_path(ma_arena_t *arena, s8_t file) {
fn sb8_t *mt_get_include_paths(ma_arena_t *arena) { fn sb8_t *mt_get_include_paths(ma_arena_t *arena) {
sb8_t *result = ma_push_type(arena, sb8_t); sb8_t *result = ma_push_type(arena, sb8_t);
result->arena = arena; result->arena = arena;
sb8_append(result, OS_GetAbsolutePath(&Perm, s8_lit("../src"))); sb8_append(result, OS_GetAbsolutePath(&Perm, s8("../src")));
return result; return result;
} }

16
src/meta/meta_format.c
View File

@@ -211,9 +211,9 @@ fn ast_t *mt_parse_decls(ma_arena_t *arena, char *file, s8_t code) {
lex_t *pos = par->at; lex_t *pos = par->at;
b32 matched = false; b32 matched = false;
b32 is_typedef = !!parser_matchi(par, s8_lit("typedef")); b32 is_typedef = !!parser_matchi(par, s8("typedef"));
if (is_typedef && parser_matchi(par, s8_lit("enum"))) { if (is_typedef && parser_matchi(par, s8("enum"))) {
ast_t *n = mt_create_ast(arena, pos, set_bit(ast_flag_string) | set_bit(ast_flag_enum)); ast_t *n = mt_create_ast(arena, pos, set_bit(ast_flag_string) | set_bit(ast_flag_enum));
mt_ast_append(result, n); mt_ast_append(result, n);
@@ -234,8 +234,8 @@ fn ast_t *mt_parse_decls(ma_arena_t *arena, char *file, s8_t code) {
n->string = parser_expect(par, lex_kind_ident)->string; n->string = parser_expect(par, lex_kind_ident)->string;
parser_expect(par, lex_kind_semicolon); parser_expect(par, lex_kind_semicolon);
if (parser_matchi(par, s8_lit("mt_tag")) && parser_expect(par, lex_kind_open_paren)) { if (parser_matchi(par, s8("mt_tag")) && parser_expect(par, lex_kind_open_paren)) {
if (parser_expecti(par, s8_lit("flags"))) { if (parser_expecti(par, s8("flags"))) {
n->flags |= set_bit(ast_flag_flag_enum); n->flags |= set_bit(ast_flag_flag_enum);
} }
parser_expect(par, lex_kind_close_paren); parser_expect(par, lex_kind_close_paren);
@@ -244,14 +244,14 @@ fn ast_t *mt_parse_decls(ma_arena_t *arena, char *file, s8_t code) {
matched = true; matched = true;
} }
if (is_typedef && parser_matchi(par, s8_lit("struct"))) { if (is_typedef && parser_matchi(par, s8("struct"))) {
parser_match(par, lex_kind_ident); parser_match(par, lex_kind_ident);
parser_match(par, lex_kind_ident); parser_match(par, lex_kind_ident);
parser_match(par, lex_kind_semicolon); parser_match(par, lex_kind_semicolon);
matched = true; matched = true;
} }
if (parser_matchi(par, s8_lit("struct"))) { if (parser_matchi(par, s8("struct"))) {
ast_t *n = mt_create_ast(arena, pos, set_bit(ast_flag_string) | set_bit(ast_flag_struct)); ast_t *n = mt_create_ast(arena, pos, set_bit(ast_flag_string) | set_bit(ast_flag_struct));
mt_ast_append(result, n); mt_ast_append(result, n);
n->string = parser_expect(par, lex_kind_ident)->string; n->string = parser_expect(par, lex_kind_ident)->string;
@@ -266,8 +266,8 @@ fn ast_t *mt_parse_decls(ma_arena_t *arena, char *file, s8_t code) {
parser_expect(par, lex_kind_semicolon); parser_expect(par, lex_kind_semicolon);
if (parser_matchi(par, s8_lit("mt_tag")) && parser_expect(par, lex_kind_open_paren)) { if (parser_matchi(par, s8("mt_tag")) && parser_expect(par, lex_kind_open_paren)) {
if (parser_expecti(par, s8_lit("dont_serialize"))) { if (parser_expecti(par, s8("dont_serialize"))) {
n->flags |= set_bit(ast_flag_dont_serialize); n->flags |= set_bit(ast_flag_dont_serialize);
} }
parser_expect(par, lex_kind_close_paren); parser_expect(par, lex_kind_close_paren);

12
src/meta/meta_serialize_format.c
View File

@@ -104,10 +104,10 @@ fn s8_t mt_serial_ast_type_to_type_info(ma_arena_t *arena, ast_t *n) {
return s8_printf(arena, "type__%S", n->string); return s8_printf(arena, "type__%S", n->string);
} else if (n->flags & set_bit(ast_flag_type_pointer)) { } else if (n->flags & set_bit(ast_flag_type_pointer)) {
s8_t base = mt_serial_ast_type_to_type_info(arena, n->first); s8_t base = mt_serial_ast_type_to_type_info(arena, n->first);
return s8_printf(arena, "(type_t){type_kind_pointer, s8_const_lit(\"%S\"), sizeof(void *), .base = &%S}", n->string, base); return s8_printf(arena, "(type_t){type_kind_pointer, s8_const(\"%S\"), sizeof(void *), .base = &%S}", n->string, base);
} else if (n->flags & set_bit(ast_flag_type_array)) { } else if (n->flags & set_bit(ast_flag_type_array)) {
s8_t base = mt_serial_ast_type_to_type_info(arena, n->first); s8_t base = mt_serial_ast_type_to_type_info(arena, n->first);
return s8_printf(arena, "(type_t){type_kind_array, s8_const_lit(\"%S\"), sizeof(%S), %d, .base = &%S}", n->string, n->string, (int)n->integer, base); return s8_printf(arena, "(type_t){type_kind_array, s8_const(\"%S\"), sizeof(%S), %d, .base = &%S}", n->string, n->string, (int)n->integer, base);
} else { } else {
parser_panicf(false, n->pos, "expected type"); parser_panicf(false, n->pos, "expected type");
} }
@@ -116,13 +116,13 @@ fn s8_t mt_serial_ast_type_to_type_info(ma_arena_t *arena, ast_t *n) {
fn void mt_serialb_ast_to_type_info(sb8_t *sb, ast_t *n) { fn void mt_serialb_ast_to_type_info(sb8_t *sb, ast_t *n) {
if (n->flags & set_bit(ast_flag_enum)) { if (n->flags & set_bit(ast_flag_enum)) {
sb8_printf(sb, "type_t type__%S = { type_kind_enum, s8_const_lit(\"%S\"), sizeof(%S),", n->string, n->string, n->string); sb8_printf(sb, "type_t type__%S = { type_kind_enum, s8_const(\"%S\"), sizeof(%S),", n->string, n->string, n->string);
sb->indent += 1; sb->indent += 1;
sb8_stmtf(sb, ".members = (type_member_t[]){"); sb8_stmtf(sb, ".members = (type_member_t[]){");
sb->indent += 1; sb->indent += 1;
for (ast_t *it = n->first; it; it = it->next) { for (ast_t *it = n->first; it; it = it->next) {
sb8_stmtf(sb, "{.name = s8_const_lit(\"%S\"), .value = %S},", it->string, it->string); sb8_stmtf(sb, "{.name = s8_const(\"%S\"), .value = %S},", it->string, it->string);
} }
sb->indent -= 1; sb->indent -= 1;
sb8_stmtf(sb, "},"); sb8_stmtf(sb, "},");
@@ -131,7 +131,7 @@ fn void mt_serialb_ast_to_type_info(sb8_t *sb, ast_t *n) {
sb->indent -= 1; sb->indent -= 1;
sb8_stmtf(sb, "};"); sb8_stmtf(sb, "};");
} else if (n->flags & set_bit(ast_flag_struct)) { } else if (n->flags & set_bit(ast_flag_struct)) {
sb8_printf(sb, "type_t type__%S = { type_kind_struct, s8_const_lit(\"%S\"), sizeof(%S),", n->string, n->string, n->string); sb8_printf(sb, "type_t type__%S = { type_kind_struct, s8_const(\"%S\"), sizeof(%S),", n->string, n->string, n->string);
sb->indent += 1; sb->indent += 1;
sb8_stmtf(sb, ".members = (type_member_t[]){"); sb8_stmtf(sb, ".members = (type_member_t[]){");
@@ -140,7 +140,7 @@ fn void mt_serialb_ast_to_type_info(sb8_t *sb, ast_t *n) {
s8_t name = it->string; s8_t name = it->string;
s8_t type_info = mt_serial_ast_type_to_type_info(sb->arena, it->first); s8_t type_info = mt_serial_ast_type_to_type_info(sb->arena, it->first);
b32 dont_serialize = (it->flags & set_bit(ast_flag_dont_serialize)) ? true : false; b32 dont_serialize = (it->flags & set_bit(ast_flag_dont_serialize)) ? true : false;
sb8_stmtf(sb, "{.name = s8_const_lit(\"%S\"), .type = &%S, .offset = offsetof(%S, %S), .dont_serialize = %d},", name, type_info, n->string, name, dont_serialize); sb8_stmtf(sb, "{.name = s8_const(\"%S\"), .type = &%S, .offset = offsetof(%S, %S), .dont_serialize = %d},", name, type_info, n->string, name, dont_serialize);
} }
sb->indent -= 1; sb->indent -= 1;
sb8_stmtf(sb, "},"); sb8_stmtf(sb, "},");

6
src/meta/meta_table_format.c
View File

@@ -98,7 +98,7 @@ fn s8_t mt_templatize_string(ma_arena_t *arena, s8_t string, lex_array_t tokens,
for (i64 i = 0; i < string.len;) { for (i64 i = 0; i < string.len;) {
if (par->at->str != string.str + i) { if (par->at->str != string.str + i) {
sb8_append(sb, s8(string.str + i, 1)); sb8_append(sb, s8_make(string.str + i, 1));
i += 1; i += 1;
continue; continue;
} }
@@ -185,14 +185,14 @@ fn void mtt_serial_enum(sb8_t *c, sb8_t *h, ast_t *table, s8_t decl) {
/////////////////////////////// ///////////////////////////////
// type info // type info
sb8_stmtf(c, "type_t type__%S = { type_kind_enum, s8_const_lit(\"%S\"), sizeof(%S),", name_t, name_t, name_t); sb8_stmtf(c, "type_t type__%S = { type_kind_enum, s8_const(\"%S\"), sizeof(%S),", name_t, name_t, name_t);
c->indent += 1; c->indent += 1;
{ {
sb8_stmtf(c, ".members = (type_member_t[]){"); sb8_stmtf(c, ".members = (type_member_t[]){");
c->indent += 1; c->indent += 1;
{ {
for (ast_t *it = table->first; it; it = it->next) { for (ast_t *it = table->first; it; it = it->next) {
sb8_stmtf(c, "{.name = s8_const_lit(\"%S_%S\"), .value = %S_%S},", decl, mtts(it, "name"), decl, mtts(it, "name")); sb8_stmtf(c, "{.name = s8_const(\"%S_%S\"), .value = %S_%S},", decl, mtts(it, "name"), decl, mtts(it, "name"));
} }
} }
c->indent -= 1; c->indent -= 1;

4
src/os/os_unix.c
View File

@@ -45,7 +45,7 @@ fn s8_t os_exe(ma_arena_t *arena) {
ssize_t size = readlink("/proc/self/exe", buffer, buffer_size); ssize_t size = readlink("/proc/self/exe", buffer, buffer_size);
assert(size < buffer_size); // @todo:? assert(size < buffer_size); // @todo:?
assert(size != -1); assert(size != -1);
s8_t string = s8_copy(arena, s8(buffer, size)); s8_t string = s8_copy(arena, s8_make(buffer, size));
ma_end_scratch(temp); ma_end_scratch(temp);
return string; return string;
} }
@@ -122,7 +122,7 @@ fn s8_t os_read(ma_arena_t *arena, s8_t path) {
fread(string, size, 1, fd); fread(string, size, 1, fd);
fclose(fd); fclose(fd);
result = s8(string, size); result = s8_make(string, size);
result.str[result.len] = 0; result.str[result.len] = 0;
} }
ma_end_scratch(temp); ma_end_scratch(temp);

8
src/os/os_win32.c
View File

@@ -151,7 +151,7 @@ fn void os_advance(os_iter_t *it) {
if (data->cFileName[0] == '.' && data->cFileName[1] == 0) continue; if (data->cFileName[0] == '.' && data->cFileName[1] == 0) continue;
it->is_directory = data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY; it->is_directory = data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
it->name = s8_from_s16(it->arena, s16(data->cFileName, wstr_len(data->cFileName))); it->name = s8_from_s16(it->arena, s16_make(data->cFileName, str16_len(data->cFileName)));
char *is_dir = it->is_directory ? "/" : ""; char *is_dir = it->is_directory ? "/" : "";
char *separator = it->path.str[it->path.len - 1] == '/' ? "" : "/"; char *separator = it->path.str[it->path.len - 1] == '/' ? "" : "/";
it->rel = s8_printf(it->arena, "%S%s%S%s", it->path, separator, it->name, is_dir); it->rel = s8_printf(it->arena, "%S%s%S%s", it->path, separator, it->name, is_dir);
@@ -220,7 +220,7 @@ fn s8_t os_abs(ma_arena_t *arena, s8_t rel) {
DWORD written = GetFullPathNameW(rel16.str, buffer_size, buffer, 0); DWORD written = GetFullPathNameW(rel16.str, buffer_size, buffer, 0);
assert(written != 0); assert(written != 0);
assert((i64)written < (i64)buffer_size); assert((i64)written < (i64)buffer_size);
s8_t result = s8_from_s16(arena, s16(buffer, written)); s8_t result = s8_from_s16(arena, s16_make(buffer, written));
ma_end_scratch(scratch); ma_end_scratch(scratch);
return result; return result;
} }
@@ -231,7 +231,7 @@ fn s8_t os_exe(ma_arena_t *arena) {
wchar_t *buffer = ma_push_array(scratch.arena, wchar_t, buffer_size); wchar_t *buffer = ma_push_array(scratch.arena, wchar_t, buffer_size);
DWORD wsize = GetModuleFileNameW(0, buffer, buffer_size); DWORD wsize = GetModuleFileNameW(0, buffer, buffer_size);
assert(wsize != 0); assert(wsize != 0);
s8_t result = s8_from_s16(arena, s16(buffer, wsize)); s8_t result = s8_from_s16(arena, s16_make(buffer, wsize));
s8_normalize_path_unsafe(result); s8_normalize_path_unsafe(result);
ma_end_scratch(scratch); ma_end_scratch(scratch);
return result; return result;
@@ -283,7 +283,7 @@ fn s8_t os_cwd(ma_arena_t *arena) {
DWORD wsize = GetCurrentDirectoryW(buffer_size, buffer); DWORD wsize = GetCurrentDirectoryW(buffer_size, buffer);
assert(wsize != 0); assert(wsize != 0);
assert(wsize <= buffer_size); assert(wsize <= buffer_size);
s8_t path = s8_from_s16(scratch.arena, s16(buffer, wsize)); s8_t path = s8_from_s16(scratch.arena, s16_make(buffer, wsize));
s8_normalize_path_unsafe(path); s8_normalize_path_unsafe(path);
s8_t result = s8_printf(arena, "%S/", path); s8_t result = s8_printf(arena, "%S/", path);
ma_end_scratch(scratch); ma_end_scratch(scratch);

4
src/render/render.meta.c
View File

@@ -3,8 +3,8 @@ void generate_render_code(ma_arena_t *arena) {
sb8_printf(sb, "// automatically generated using: " __FILE__ "\n"); sb8_printf(sb, "// automatically generated using: " __FILE__ "\n");
sb8_printf(sb, "gb_read_only "); sb8_printf(sb, "gb_read_only ");
s8_t content = OS_ReadFile(&Perm, s8_lit("../package/FiraCode-Regular.ttf")); s8_t content = OS_ReadFile(&Perm, s8("../package/FiraCode-Regular.ttf"));
// s8_t content = OS_ReadFile(&Perm, s8_lit("C:/Windows/Fonts/arial.ttf")); // s8_t content = OS_ReadFile(&Perm, s8("C:/Windows/Fonts/arial.ttf"));
mt_serial_to_cbyte_array_ex(sb, content, s8_printf(arena, "main_font_data")); mt_serial_to_cbyte_array_ex(sb, content, s8_printf(arena, "main_font_data"));
sb8_printf(sb, "gb_read_only s8_t main_font = s8_array_lit(main_font_data);\n"); sb8_printf(sb, "gb_read_only s8_t main_font = s8_array_lit(main_font_data);\n");
os_write_file(mt_cpath(arena), sb8_serial_end(arena, sb)); os_write_file(mt_cpath(arena), sb8_serial_end(arena, sb));

2
src/render/render_opengl.c
View File

@@ -50,7 +50,7 @@ fn void rn_reload_font(f32 font_size, f32 dpr) {
glTextureStorage2D(atlas->texture_id, 1, GL_R8, (GLsizei)atlas->size.x, (GLsizei)atlas->size.y); glTextureStorage2D(atlas->texture_id, 1, GL_R8, (GLsizei)atlas->size.x, (GLsizei)atlas->size.y);
glTextureSubImage2D(atlas->texture_id, 0, 0, 0, (GLsizei)atlas->size.x, (GLsizei)atlas->size.y, GL_RED, GL_UNSIGNED_BYTE, atlas->bitmap); glTextureSubImage2D(atlas->texture_id, 0, 0, 0, (GLsizei)atlas->size.x, (GLsizei)atlas->size.y, GL_RED, GL_UNSIGNED_BYTE, atlas->bitmap);
rn->main_font->texture_id = atlas->texture_id; rn->main_font->texture_id = atlas->texture_id;
rn->main_font->computed_xchar_size = rn_measure_string(rn->main_font, s8_lit("_")).x; rn->main_font->computed_xchar_size = rn_measure_string(rn->main_font, s8("_")).x;
ma_end_scratch(scratch); ma_end_scratch(scratch);
} }

4
src/render/render_wasm_canvas.c
View File

@@ -4,7 +4,7 @@ fn_wasm_import void wasm_draw_rect(f32 x, f32 y, f32 w, f32 h, f32 r, f32 g, f32
fn_wasm_import f32 wasm_measure_text(isize str, i32 len, isize font_str, i32 font_len, i32 font_size); fn_wasm_import f32 wasm_measure_text(isize str, i32 len, isize font_str, i32 font_len, i32 font_size);
fn_wasm_import void wasm_set_clip(f32 x, f32 y, f32 w, f32 h); fn_wasm_import void wasm_set_clip(f32 x, f32 y, f32 w, f32 h);
gb_read_only s8_t font_face = s8_const_lit("main_font"); gb_read_only s8_t font_face = s8_const("main_font");
fn void rn_reload_font(f32 font_size, f32 dpr); fn void rn_reload_font(f32 font_size, f32 dpr);
typedef struct rn_font_t rn_font_t; typedef struct rn_font_t rn_font_t;
@@ -50,7 +50,7 @@ fn v2f32_t rn_measure_string(rn_font_t *font, s8_t string) {
fn void rn_reload_font(f32 font_size, f32 dpr) { fn void rn_reload_font(f32 font_size, f32 dpr) {
rn->main_font->size = font_size * dpr; rn->main_font->size = font_size * dpr;
rn->main_font->computed_xchar_size = rn_measure_string(rn->main_font, s8_lit("_")).x; rn->main_font->computed_xchar_size = rn_measure_string(rn->main_font, s8("_")).x;
} }
fn v2f32_t rn_draw_string(rn_font_t *font, v2f32_t pos, v4f32_t color, s8_t string) { fn v2f32_t rn_draw_string(rn_font_t *font, v2f32_t pos, v4f32_t color, s8_t string) {

4
src/testing/testing.meta.c
View File

@@ -7,8 +7,8 @@ void generate_testing_code(ma_arena_t *arena) {
for (;par->at->kind != lex_kind_eof;) { for (;par->at->kind != lex_kind_eof;) {
b32 matched = false; b32 matched = false;
if (par->at->inside_macro == false && parser_matchi(par, s8_lit("fn_test"))) { if (par->at->inside_macro == false && parser_matchi(par, s8("fn_test"))) {
parser_expecti(par, s8_lit("void")); parser_expecti(par, s8("void"));
lex_t *ident = parser_match(par, lex_kind_ident); lex_t *ident = parser_match(par, lex_kind_ident);
sb8_append(tests, ident->string); sb8_append(tests, ident->string);
matched = true; matched = true;

82
src/testing/testing_main.c
View File

@@ -24,10 +24,10 @@ fn void os_test(void) {
assert(os_is_abs(exe_dir)); assert(os_is_abs(exe_dir));
assert(os_is_abs(exe)); assert(os_is_abs(exe));
assert(os_is_abs(cwd)); assert(os_is_abs(cwd));
assert(!os_is_abs(s8_lit("../path/"))); assert(!os_is_abs(s8("../path/")));
debugf("OS paths %S %S %S", exe_dir, exe, cwd); debugf("OS paths %S %S %S", exe_dir, exe, cwd);
s8_t file = os_read(tcx->temp, s8_lit("../.gitignore")); s8_t file = os_read(tcx->temp, s8("../.gitignore"));
assert(file.str != 0); assert(file.str != 0);
assert(file.len != 0); assert(file.len != 0);
} }
@@ -39,90 +39,90 @@ fn void test_s8(void) {
ma_temp_t temp = ma_begin_temp(arena); ma_temp_t temp = ma_begin_temp(arena);
sb8_t *sb = &(sb8_t){arena}; sb8_t *sb = &(sb8_t){arena};
s8_t memes = s8_lit("memes"); s8_t memes = s8("memes");
sb8_printf(sb, "%S", memes); sb8_printf(sb, "%S", memes);
assert(sb->first == sb->last); assert(sb->first == sb->last);
assert(sb->first->len == 5); assert(sb->first->len == 5);
assert(s8_are_equal(sb->first->string, memes)); assert(s8_are_equal(sb->first->string, memes));
sb8_printf(sb, "%S", s8_lit("things are going fine")); sb8_printf(sb, "%S", s8("things are going fine"));
s8_t string = sb8_merge(temp.arena, sb); s8_t string = sb8_merge(temp.arena, sb);
assert(s8_are_equal(string, s8_lit("memesthings are going fine"))); assert(s8_are_equal(string, s8("memesthings are going fine")));
ma_end_temp(temp); ma_end_temp(temp);
} }
{ {
s8_t str = s8_lit("thing|another|"); s8_t str = s8("thing|another|");
sb8_t sb = s8_split(arena, str, s8_lit("|"), s8_split_none); sb8_t sb = s8_split(arena, str, s8("|"), s8_split_none);
assert(s8_are_equal(sb.first->string, s8_lit("thing"))); assert(s8_are_equal(sb.first->string, s8("thing")));
assert(s8_are_equal(sb.first->next->string, s8_lit("another"))); assert(s8_are_equal(sb.first->next->string, s8("another")));
assert(sb.first->next->next == NULL); assert(sb.first->next->next == NULL);
} }
{ {
s8_t str = s8_lit("thing|another|"); s8_t str = s8("thing|another|");
sb8_t sb = s8_split(arena, str, s8_lit("|"), s8_split_inclusive); sb8_t sb = s8_split(arena, str, s8("|"), s8_split_inclusive);
assert(s8_are_equal(sb.first->string, s8_lit("thing"))); assert(s8_are_equal(sb.first->string, s8("thing")));
assert(s8_are_equal(sb.first->next->string, s8_lit("|"))); assert(s8_are_equal(sb.first->next->string, s8("|")));
assert(s8_are_equal(sb.first->next->next->string, s8_lit("another"))); assert(s8_are_equal(sb.first->next->next->string, s8("another")));
assert(s8_are_equal(sb.first->next->next->next->string, s8_lit("|"))); assert(s8_are_equal(sb.first->next->next->next->string, s8("|")));
assert(sb.first->next->next->next->next == NULL); assert(sb.first->next->next->next->next == NULL);
} }
{ {
s8_t str = s8_lit("aabaaBaa"); s8_t str = s8("aabaaBaa");
sb8_t sb = s8_split(arena, str, s8_lit("b"), s8_split_inclusive | s8_split_ignore_case); sb8_t sb = s8_split(arena, str, s8("b"), s8_split_inclusive | s8_split_ignore_case);
assert(s8_are_equal(sb.first->string, s8_lit("aa"))); assert(s8_are_equal(sb.first->string, s8("aa")));
assert(s8_are_equal(sb.first->next->string, s8_lit("b"))); assert(s8_are_equal(sb.first->next->string, s8("b")));
assert(s8_are_equal(sb.first->next->next->string, s8_lit("aa"))); assert(s8_are_equal(sb.first->next->next->string, s8("aa")));
assert(s8_are_equal(sb.first->next->next->next->string, s8_lit("B"))); assert(s8_are_equal(sb.first->next->next->next->string, s8("B")));
assert(s8_are_equal(sb.first->next->next->next->next->string, s8_lit("aa"))); assert(s8_are_equal(sb.first->next->next->next->next->string, s8("aa")));
assert(sb.first->next->next->next->next->next == NULL); assert(sb.first->next->next->next->next->next == NULL);
} }
{ {
s8_t str = s8_lit("aabaaBaa"); s8_t str = s8("aabaaBaa");
sb8_t sb = s8_split(arena, str, s8_lit("b"), s8_split_inclusive); sb8_t sb = s8_split(arena, str, s8("b"), s8_split_inclusive);
assert(s8_are_equal(sb.first->string, s8_lit("aa"))); assert(s8_are_equal(sb.first->string, s8("aa")));
assert(s8_are_equal(sb.first->next->string, s8_lit("b"))); assert(s8_are_equal(sb.first->next->string, s8("b")));
assert(s8_are_equal(sb.first->next->next->string, s8_lit("aaBaa"))); assert(s8_are_equal(sb.first->next->next->string, s8("aaBaa")));
} }
{ {
s8_t s = s8_lit("0123456789"); s8_t s = s8("0123456789");
assert(s8_are_equal(s8_slice(s, 0, 4), s8_lit("0123"))); assert(s8_are_equal(s8_slice(s, 0, 4), s8("0123")));
assert(s8_are_equal(s8_slice(s, -2, -1), s8_lit("89"))); assert(s8_are_equal(s8_slice(s, -2, -1), s8("89")));
assert(s8_are_equal(s8_slice(s, -2, 10), s8_lit("89"))); assert(s8_are_equal(s8_slice(s, -2, 10), s8("89")));
assert(s8_are_equal(s8_slice(s, 8, 10), s8_lit("89"))); assert(s8_are_equal(s8_slice(s, 8, 10), s8("89")));
} }
{ {
s8_t s = s8_lit(" a \n"); s8_t s = s8(" a \n");
s = s8_trim(s); s = s8_trim(s);
assert(s8_are_equal(s, s8_lit("a"))); assert(s8_are_equal(s, s8("a")));
} }
{ {
s8_t s = s8_lit("C:/memes/the_thing.c"); s8_t s = s8("C:/memes/the_thing.c");
s8_t ss = s8_get_name_no_ext(s); s8_t ss = s8_get_name_no_ext(s);
assert(s8_are_equal(ss, s8_lit("the_thing"))); assert(s8_are_equal(ss, s8("the_thing")));
} }
{ {
s8_t s = s8_printf(arena, "%d%Sv%s", 32, s8_lit("|"), ">"); s8_t s = s8_printf(arena, "%d%Sv%s", 32, s8("|"), ">");
assert(s8_are_equal(s, s8_lit("32|v>"))); assert(s8_are_equal(s, s8("32|v>")));
} }
{ {
s8_t s0 = s8_lit("0123456789"); s8_t s0 = s8("0123456789");
s8_t s1 = s8_cut_start(&s0, 2); s8_t s1 = s8_cut_start(&s0, 2);
assert(s8_are_equal(s0, s8_lit("23456789"))); assert(s8_are_equal(s0, s8("23456789")));
assert(s8_are_equal(s1, s8_lit("01"))); assert(s8_are_equal(s1, s8("01")));
} }
ma_destroy(arena); ma_destroy(arena);

4
src/text_editor/text_editor.gen.c
View File

@@ -2,8 +2,8 @@
gb f32 font_size = 30; gb f32 font_size = 30;
gb f32 _font_size = 30; gb f32 _font_size = 30;
gb_read_only mt_tweak_t tweak_table[] = { gb_read_only mt_tweak_t tweak_table[] = {
{type(f32), s8_const_lit("font_size"), &font_size, 4, 200}, {type(f32), s8_const("font_size"), &font_size, 4, 200},
{type(f32), s8_const_lit("_font_size"), &_font_size, 30, 30}, {type(f32), s8_const("_font_size"), &_font_size, 30, 30},
}; };
void run_all_tests(void) { void run_all_tests(void) {

24
src/text_editor/text_editor.meta.c
View File

@@ -1,7 +1,7 @@
void generate_text_editor_code(ma_arena_t *arena) { void generate_text_editor_code(ma_arena_t *arena) {
sb8_t *include_paths = sb8(arena); sb8_t *include_paths = sb8(arena);
sb8_append(include_paths, OS_GetAbsolutePath(&Perm, s8_lit("../src"))); sb8_append(include_paths, OS_GetAbsolutePath(&Perm, s8("../src")));
mt_files_t files = mt_lex_files(arena, s8_lit("../src/text_editor/text_editor_main.c"), include_paths); mt_files_t files = mt_lex_files(arena, s8("../src/text_editor/text_editor_main.c"), include_paths);
typedef struct cg_tweak_t cg_tweak_t; typedef struct cg_tweak_t cg_tweak_t;
struct cg_tweak_t { struct cg_tweak_t {
@@ -24,14 +24,14 @@ void generate_text_editor_code(ma_arena_t *arena) {
for (;par->at->kind != lex_kind_eof;) { for (;par->at->kind != lex_kind_eof;) {
b32 matched = false; b32 matched = false;
if (par->at->inside_macro == false && parser_matchi(par, s8_lit("fn_test"))) { if (par->at->inside_macro == false && parser_matchi(par, s8("fn_test"))) {
parser_expecti(par, s8_lit("void")); parser_expecti(par, s8("void"));
lex_t *ident = parser_match(par, lex_kind_ident); lex_t *ident = parser_match(par, lex_kind_ident);
sb8_append(tests, ident->string); sb8_append(tests, ident->string);
matched = true; matched = true;
} }
if (par->at->inside_macro == false && parser_matchi(par, s8_lit("mt_embed_file"))) { if (par->at->inside_macro == false && parser_matchi(par, s8("mt_embed_file"))) {
parser_expect(par, lex_kind_open_paren); parser_expect(par, lex_kind_open_paren);
lex_t *var_name = parser_expect(par, lex_kind_ident); lex_t *var_name = parser_expect(par, lex_kind_ident);
parser_expect(par, lex_kind_comma); parser_expect(par, lex_kind_comma);
@@ -46,10 +46,10 @@ void generate_text_editor_code(ma_arena_t *arena) {
matched = true; matched = true;
} }
if (par->at->inside_macro == false && parser_matchi(par, s8_lit("mt_tweak_b32"))) { if (par->at->inside_macro == false && parser_matchi(par, s8("mt_tweak_b32"))) {
cg_tweak_t *tweak = ma_push_type(arena, cg_tweak_t); cg_tweak_t *tweak = ma_push_type(arena, cg_tweak_t);
tweak->type = type(b32); tweak->type = type(b32);
tweak->min = tweak->max = s8_lit("0"); tweak->min = tweak->max = s8("0");
parser_expect(par, lex_kind_open_paren); parser_expect(par, lex_kind_open_paren);
tweak->name = parser_expect(par, lex_kind_ident)->string; tweak->name = parser_expect(par, lex_kind_ident)->string;
parser_expect(par, lex_kind_comma); parser_expect(par, lex_kind_comma);
@@ -59,7 +59,7 @@ void generate_text_editor_code(ma_arena_t *arena) {
matched = true; matched = true;
} }
if (par->at->inside_macro == false && parser_matchi(par, s8_lit("mt_tweak_f32"))) { if (par->at->inside_macro == false && parser_matchi(par, s8("mt_tweak_f32"))) {
cg_tweak_t *tweak = ma_push_type(arena, cg_tweak_t); cg_tweak_t *tweak = ma_push_type(arena, cg_tweak_t);
tweak->type = type(f32); tweak->type = type(f32);
parser_expect(par, lex_kind_open_paren); parser_expect(par, lex_kind_open_paren);
@@ -75,11 +75,11 @@ void generate_text_editor_code(ma_arena_t *arena) {
matched = true; matched = true;
} }
if (par->at->inside_macro == false && parser_matchi(par, s8_lit("mt_tweak_color"))) { if (par->at->inside_macro == false && parser_matchi(par, s8("mt_tweak_color"))) {
cg_tweak_t *tweak = ma_push_type(arena, cg_tweak_t); cg_tweak_t *tweak = ma_push_type(arena, cg_tweak_t);
tweak->type = type(v4f32_t); tweak->type = type(v4f32_t);
tweak->min = s8_lit("0.0f"); tweak->min = s8("0.0f");
tweak->max = s8_lit("1.0f"); tweak->max = s8("1.0f");
parser_expect(par, lex_kind_open_paren); parser_expect(par, lex_kind_open_paren);
tweak->name = parser_expect(par, lex_kind_ident)->string; tweak->name = parser_expect(par, lex_kind_ident)->string;
parser_expect(par, lex_kind_comma); parser_expect(par, lex_kind_comma);
@@ -105,7 +105,7 @@ void generate_text_editor_code(ma_arena_t *arena) {
} }
sb8_printf(sb_embeds, "gb_read_only mt_tweak_t tweak_table[] = {\n"); sb8_printf(sb_embeds, "gb_read_only mt_tweak_t tweak_table[] = {\n");
for (cg_tweak_t *it = first_tweak; it; it = it->next) { for (cg_tweak_t *it = first_tweak; it; it = it->next) {
sb8_printf(sb_embeds, " {type(%S), s8_const_lit(\"%S\"), &%S, %S, %S},\n", it->type->name, it->name, it->name, it->min, it->max); sb8_printf(sb_embeds, " {type(%S), s8_const(\"%S\"), &%S, %S, %S},\n", it->type->name, it->name, it->name, it->min, it->max);
} }
sb8_printf(sb_embeds, "\n};\n"); sb8_printf(sb_embeds, "\n};\n");
} }

44
src/ui/ui.c
View File

@@ -43,13 +43,13 @@ fn s8_t ui_tprint_loc(ui_code_loc_t loc) {
fn s8_t ui_get_display_string(s8_t string) { fn s8_t ui_get_display_string(s8_t string) {
s8_t result = string; s8_t result = string;
s8_seek(result, s8_lit("##"), s8_seek_none, &result.len); s8_seek(result, s8("##"), s8_seek_none, &result.len);
return result; return result;
} }
fn s8_t ui_get_hash_string(s8_t string) { fn s8_t ui_get_hash_string(s8_t string) {
i64 len = 0; i64 len = 0;
if (s8_seek(string, s8_lit("##"), s8_seek_none, &len)) { if (s8_seek(string, s8("##"), s8_seek_none, &len)) {
string = s8_skip(string, len + 2); string = s8_skip(string, len + 2);
} }
return string; return string;
@@ -435,14 +435,14 @@ fn void ui_text_input_draw(ui_box_t *box) {
rn_draw_rect(co.rect, co.background_color); rn_draw_rect(co.rect, co.background_color);
ui_text_input_t *ti = box->text_input; ui_text_input_t *ti = box->text_input;
s8_t string = s8(ti->str, ti->len); s8_t string = s8_make(ti->str, ti->len);
v2f32_t pos = ui_aligned_text_pos(box->string_pos_offset, box->text_align, co.rect, string, rn_measure_string(rn->main_font, string)); v2f32_t pos = ui_aligned_text_pos(box->string_pos_offset, box->text_align, co.rect, string, rn_measure_string(rn->main_font, string));
rn_draw_string(rn->main_font, pos, co.text_color, string); rn_draw_string(rn->main_font, pos, co.text_color, string);
ti->caret = ui_caret_clamp(ti->caret, 0, (i32)ti->len); ti->caret = ui_caret_clamp(ti->caret, 0, (i32)ti->len);
{ {
s8_t string_min = s8(ti->str, ti->caret.range.min); s8_t string_min = s8_make(ti->str, ti->caret.range.min);
s8_t string_max = s8(ti->str, ti->caret.range.max); s8_t string_max = s8_make(ti->str, ti->caret.range.max);
v2f32_t size_min = rn_measure_string(rn->main_font, string_min); v2f32_t size_min = rn_measure_string(rn->main_font, string_min);
v2f32_t size_max = rn_measure_string(rn->main_font, string_max); v2f32_t size_max = rn_measure_string(rn->main_font, string_max);
@@ -507,19 +507,19 @@ fn_test void ui_test_text_replace(void) {
char buff[4] = {0}; char buff[4] = {0};
ti.str = buff; ti.str = buff;
ti.cap = lengthof(buff); ti.cap = lengthof(buff);
ui_text_replace(&ti, r1i32(0,0), s8_lit("astfpo")); ui_text_replace(&ti, r1i32(0,0), s8("astfpo"));
assert(s8_are_equal(ti.string, s8_lit("astf"))); assert(s8_are_equal(ti.string, s8("astf")));
ui_text_replace(&ti, r1i32(0,4), s8_lit("qwer")); ui_text_replace(&ti, r1i32(0,4), s8("qwer"));
assert(s8_are_equal(ti.string, s8_lit("qwer"))); assert(s8_are_equal(ti.string, s8("qwer")));
ui_text_replace(&ti, r1i32(1,2), s8_lit("a")); ui_text_replace(&ti, r1i32(1,2), s8("a"));
assert(s8_are_equal(ti.string, s8_lit("qaer"))); assert(s8_are_equal(ti.string, s8("qaer")));
} }
#define ui_text_input(...) ui__text_input(UILOC, __VA_ARGS__) #define ui_text_input(...) ui__text_input(UILOC, __VA_ARGS__)
fn ui_signal_t ui__text_input(ui_code_loc_t loc, ui_text_input_t *ti, b32 sim_even_if_no_focus) { fn ui_signal_t ui__text_input(ui_code_loc_t loc, ui_text_input_t *ti, b32 sim_even_if_no_focus) {
ui_box_t *box = ui_box(.loc = loc, .string = s8_lit("text_input"), .flags = { .draw_border = true, .draw_rect = true, .draw_text = true, .keyboard_nav = true }); ui_box_t *box = ui_box(.loc = loc, .string = s8("text_input"), .flags = { .draw_border = true, .draw_rect = true, .draw_text = true, .keyboard_nav = true });
box->text_input = ti; box->text_input = ti;
box->custom_draw = ui_text_input_draw; box->custom_draw = ui_text_input_draw;
@@ -542,13 +542,13 @@ fn ui_signal_t ui__text_input(ui_code_loc_t loc, ui_text_input_t *ti, b32 sim_ev
signal.text_changed = true; signal.text_changed = true;
if (ev->ctrl) { if (ev->ctrl) {
if (sel_size) { if (sel_size) {
ui_text_replace(ti, ti->caret.range, s8_lit("")); ui_text_replace(ti, ti->caret.range, s8(""));
} else { } else {
ui_text_replace(ti, r1i32(0, ti->caret.range.max), s8_lit("")); ui_text_replace(ti, r1i32(0, ti->caret.range.max), s8(""));
} }
} else { } else {
if (sel_size) { if (sel_size) {
ui_text_replace(ti, ti->caret.range, s8_lit("")); ui_text_replace(ti, ti->caret.range, s8(""));
} else { } else {
ui_text_replace(ti, r1i32(ti->caret.e[0] - 1, ti->caret.e[0]), s8_null); ui_text_replace(ti, r1i32(ti->caret.e[0] - 1, ti->caret.e[0]), s8_null);
ti->caret = ui_carets(ti->caret.range.min - 1); ti->caret = ui_carets(ti->caret.range.min - 1);
@@ -557,7 +557,7 @@ fn ui_signal_t ui__text_input(ui_code_loc_t loc, ui_text_input_t *ti, b32 sim_ev
} else if (ev->key == app_key_delete) { } else if (ev->key == app_key_delete) {
signal.text_changed = true; signal.text_changed = true;
if (sel_size) { if (sel_size) {
ui_text_replace(ti, ti->caret.range, s8_lit("")); ui_text_replace(ti, ti->caret.range, s8(""));
} else { } else {
ui_text_replace(ti, r1i32(ti->caret.e[0], ti->caret.e[0] + 1), s8_null); ui_text_replace(ti, r1i32(ti->caret.e[0], ti->caret.e[0] + 1), s8_null);
} }
@@ -579,7 +579,7 @@ fn ui_signal_t ui__text_input(ui_code_loc_t loc, ui_text_input_t *ti, b32 sim_ev
signal.text_commit = true; signal.text_commit = true;
} }
} }
v2f32_t size = rn_measure_string(rn->main_font, s8_lit("_")); v2f32_t size = rn_measure_string(rn->main_font, s8("_"));
v2f32_t pos = v2f32_sub(ev->mouse_pos, box->final_rect.min); v2f32_t pos = v2f32_sub(ev->mouse_pos, box->final_rect.min);
i32 p = (i32)f32_round(pos.x / size.x); i32 p = (i32)f32_round(pos.x / size.x);
if (ev->kind == app_event_kind_mouse_down && ev->mouse_button == app_mouse_button_left) { if (ev->kind == app_event_kind_mouse_down && ev->mouse_button == app_mouse_button_left) {
@@ -1262,9 +1262,9 @@ fn void ui_demo_everything_lister(void) {
} }
s8_t cmds[] = { s8_t cmds[] = {
s8_lit("show data tab"), s8("show data tab"),
s8_lit("show log tab"), s8("show log tab"),
s8_lit("show menus tab"), s8("show menus tab"),
}; };
if (lister_open) { if (lister_open) {
@@ -1292,7 +1292,7 @@ fn void ui_demo_everything_lister(void) {
if (lister_just_opened) text_input.len = 0; if (lister_just_opened) text_input.len = 0;
ma_temp_t scratch = ma_begin_scratch(); ma_temp_t scratch = ma_begin_scratch();
s8_t needle = s8(text_input.str, text_input.len); s8_t needle = s8_make(text_input.str, text_input.len);
fuzzy_pair_t *pairs = fuzzy_rate_array(scratch.arena, needle, cmds, lengthof(cmds)); fuzzy_pair_t *pairs = fuzzy_rate_array(scratch.arena, needle, cmds, lengthof(cmds));
b32 set_focus = lister_just_opened || ti_sig.text_changed; b32 set_focus = lister_just_opened || ti_sig.text_changed;
@@ -1370,7 +1370,7 @@ fn void ui_demo_update(app_frame_t *frame, mt_tweak_t *tweak_table, i32 tweak_co
ui_top_rectp()[0] = r2f32_shrinks(ui_top_rect(), ui_em(1)); ui_top_rectp()[0] = r2f32_shrinks(ui_top_rect(), ui_em(1));
for (i32 i = 0; i < tweak_count; i += 1) { for (i32 i = 0; i < tweak_count; i += 1) {
mt_tweak_t *tweak = tweak_table + i; mt_tweak_t *tweak = tweak_table + i;
if (s8_starts_with(tweak->name, s8_lit("_"), false)) { if (s8_starts_with(tweak->name, s8("_"), false)) {
continue; continue;
} }

26
src/ui/ui.gen.c
View File

@@ -1,19 +1,19 @@
// automatically generated using: C:\dev\wasm\src/ui/ui.meta.c // automatically generated using: C:\dev\wasm\src/ui/ui.meta.c
type_t type__ui_color_t = { type_kind_enum, s8_const_lit("ui_color_t"), sizeof(ui_color_t), type_t type__ui_color_t = { type_kind_enum, s8_const("ui_color_t"), sizeof(ui_color_t),
.members = (type_member_t[]){ .members = (type_member_t[]){
{.name = s8_const_lit("ui_color_rect"), .value = ui_color_rect}, {.name = s8_const("ui_color_rect"), .value = ui_color_rect},
{.name = s8_const_lit("ui_color_rect_hot"), .value = ui_color_rect_hot}, {.name = s8_const("ui_color_rect_hot"), .value = ui_color_rect_hot},
{.name = s8_const_lit("ui_color_rect_active"), .value = ui_color_rect_active}, {.name = s8_const("ui_color_rect_active"), .value = ui_color_rect_active},
{.name = s8_const_lit("ui_color_rect_turned_on"), .value = ui_color_rect_turned_on}, {.name = s8_const("ui_color_rect_turned_on"), .value = ui_color_rect_turned_on},
{.name = s8_const_lit("ui_color_border"), .value = ui_color_border}, {.name = s8_const("ui_color_border"), .value = ui_color_border},
{.name = s8_const_lit("ui_color_text"), .value = ui_color_text}, {.name = s8_const("ui_color_text"), .value = ui_color_text},
{.name = s8_const_lit("ui_color_text_hot"), .value = ui_color_text_hot}, {.name = s8_const("ui_color_text_hot"), .value = ui_color_text_hot},
{.name = s8_const_lit("ui_color_text_active"), .value = ui_color_text_active}, {.name = s8_const("ui_color_text_active"), .value = ui_color_text_active},
{.name = s8_const_lit("ui_color_focused_rect"), .value = ui_color_focused_rect}, {.name = s8_const("ui_color_focused_rect"), .value = ui_color_focused_rect},
{.name = s8_const_lit("ui_color_scroller"), .value = ui_color_scroller}, {.name = s8_const("ui_color_scroller"), .value = ui_color_scroller},
{.name = s8_const_lit("ui_color_scroller_hot"), .value = ui_color_scroller_hot}, {.name = s8_const("ui_color_scroller_hot"), .value = ui_color_scroller_hot},
{.name = s8_const_lit("ui_color_scroller_active"), .value = ui_color_scroller_active}, {.name = s8_const("ui_color_scroller_active"), .value = ui_color_scroller_active},
}, },
.count = 12, .count = 12,
}; };

16
src/ui/ui.meta.c
View File

@@ -15,7 +15,7 @@ fn void mt_ui_colors(ma_arena_t *arena, sb8_t *c, sb8_t *h) {
{ scroller_active `v4f32_hsla_to_rgba((v4f32_t){0.1f, 0.2f, 0.5f, 1.0f})` } { scroller_active `v4f32_hsla_to_rgba((v4f32_t){0.1f, 0.2f, 0.5f, 1.0f})` }
)); ));
mtt_serial_enum(c, h, table, s8_lit("ui_color")); mtt_serial_enum(c, h, table, s8("ui_color"));
sb8_stmtf(c, "gb v4f32_t ui_color_table[] = {"); sb8_stmtf(c, "gb v4f32_t ui_color_table[] = {");
for (ast_t *it = table->first; it; it = it->next) { for (ast_t *it = table->first; it; it = it->next) {
@@ -55,20 +55,20 @@ fn void mt_ui_stacks(ma_arena_t *arena, sb8_t *c, sb8_t *h) {
// create `stack` and `node` columns // create `stack` and `node` columns
for (ast_t *it = table->first; it; it = it->next) { for (ast_t *it = table->first; it; it = it->next) {
s8_t type = mtts(it, "type"); s8_t type = mtts(it, "type");
if (s8_ends_with(type, s8_lit("_t"))) { if (s8_ends_with(type, s8("_t"))) {
type = s8_chop(type, 2); type = s8_chop(type, 2);
} }
s8_t ui_type = type; s8_t ui_type = type;
if (!s8_starts_with(ui_type, s8_lit("ui_"))) { if (!s8_starts_with(ui_type, s8("ui_"))) {
ui_type = s8_printf(arena, "ui_%S", ui_type); ui_type = s8_printf(arena, "ui_%S", ui_type);
} }
s8_t node = s8_printf(arena, "%S_node_t", ui_type); s8_t node = s8_printf(arena, "%S_node_t", ui_type);
s8_t stack = s8_printf(arena, "%S_stack", mtts(it, "name")); s8_t stack = s8_printf(arena, "%S_stack", mtts(it, "name"));
mt_ast_append(it, mt_kv(arena, s8_lit("node"), node)); mt_ast_append(it, mt_kv(arena, s8("node"), node));
mt_ast_append(it, mt_kv(arena, s8_lit("stack"), stack)); mt_ast_append(it, mt_kv(arena, s8("stack"), stack));
} }
@@ -118,7 +118,7 @@ fn void mt_ui_stacks(ma_arena_t *arena, sb8_t *c, sb8_t *h) {
sb8_stmtf(c, "fn void ui_push_init_values(void) {"); sb8_stmtf(c, "fn void ui_push_init_values(void) {");
for (ast_t *it = table->first; it; it = it->next) { for (ast_t *it = table->first; it; it = it->next) {
if (s8_are_equal(mtts(it, "init"), s8_lit("x"))) { if (s8_are_equal(mtts(it, "init"), s8("x"))) {
continue; continue;
} }
mt_stmtf(c, it, "ui_push_@name(@init);"); mt_stmtf(c, it, "ui_push_@name(@init);");
@@ -127,7 +127,7 @@ fn void mt_ui_stacks(ma_arena_t *arena, sb8_t *c, sb8_t *h) {
sb8_stmtf(c, "fn void ui_pop_init_values(void) {"); sb8_stmtf(c, "fn void ui_pop_init_values(void) {");
for (ast_t *it = table->first; it; it = it->next) { for (ast_t *it = table->first; it; it = it->next) {
if (s8_are_equal(mtts(it, "init"), s8_lit("x"))) { if (s8_are_equal(mtts(it, "init"), s8("x"))) {
continue; continue;
} }
mt_stmtf(c, it, "ui_pop_@name();"); mt_stmtf(c, it, "ui_pop_@name();");
@@ -136,7 +136,7 @@ fn void mt_ui_stacks(ma_arena_t *arena, sb8_t *c, sb8_t *h) {
sb8_stmtf(c, "fn void ui_box_fill_with_colors(ui_box_t *box) {"); sb8_stmtf(c, "fn void ui_box_fill_with_colors(ui_box_t *box) {");
for (ast_t *it = table->first; it; it = it->next) { for (ast_t *it = table->first; it; it = it->next) {
if (!s8_ends_with(mtts(it, "name"), s8_lit("_color"))) { if (!s8_ends_with(mtts(it, "name"), s8("_color"))) {
continue; continue;
} }
mt_stmtf(c, it, "box->@name = ui_top_@name();"); mt_stmtf(c, it, "box->@name = ui_top_@name();");

4
src/wasm_app/wasm_app.gen.c
View File

@@ -2,8 +2,8 @@
gb f32 font_size = 30; gb f32 font_size = 30;
gb f32 _font_size = 30; gb f32 _font_size = 30;
gb_read_only mt_tweak_t tweak_table[] = { gb_read_only mt_tweak_t tweak_table[] = {
{type(f32), s8_const_lit("font_size"), &font_size, 4, 200}, {type(f32), s8_const("font_size"), &font_size, 4, 200},
{type(f32), s8_const_lit("_font_size"), &_font_size, 30, 30}, {type(f32), s8_const("_font_size"), &_font_size, 30, 30},
}; };
void run_all_tests(void) { void run_all_tests(void) {

24
src/wasm_app/wasm_app.meta.c
View File

@@ -1,7 +1,7 @@
void generate_wasm_app_code(ma_arena_t *arena) { void generate_wasm_app_code(ma_arena_t *arena) {
sb8_t *include_paths = sb8(arena); sb8_t *include_paths = sb8(arena);
sb8_append(include_paths, OS_GetAbsolutePath(&Perm, s8_lit("../src"))); sb8_append(include_paths, OS_GetAbsolutePath(&Perm, s8("../src")));
mt_files_t files = mt_lex_files(arena, s8_lit("../src/wasm_app/main.c"), include_paths); mt_files_t files = mt_lex_files(arena, s8("../src/wasm_app/main.c"), include_paths);
typedef struct cg_tweak_t cg_tweak_t; typedef struct cg_tweak_t cg_tweak_t;
struct cg_tweak_t { struct cg_tweak_t {
@@ -24,14 +24,14 @@ void generate_wasm_app_code(ma_arena_t *arena) {
for (;par->at->kind != lex_kind_eof;) { for (;par->at->kind != lex_kind_eof;) {
b32 matched = false; b32 matched = false;
if (par->at->inside_macro == false && parser_matchi(par, s8_lit("fn_test"))) { if (par->at->inside_macro == false && parser_matchi(par, s8("fn_test"))) {
parser_expecti(par, s8_lit("void")); parser_expecti(par, s8("void"));
lex_t *ident = parser_match(par, lex_kind_ident); lex_t *ident = parser_match(par, lex_kind_ident);
sb8_append(tests, ident->string); sb8_append(tests, ident->string);
matched = true; matched = true;
} }
if (par->at->inside_macro == false && parser_matchi(par, s8_lit("mt_embed_file"))) { if (par->at->inside_macro == false && parser_matchi(par, s8("mt_embed_file"))) {
parser_expect(par, lex_kind_open_paren); parser_expect(par, lex_kind_open_paren);
lex_t *var_name = parser_expect(par, lex_kind_ident); lex_t *var_name = parser_expect(par, lex_kind_ident);
parser_expect(par, lex_kind_comma); parser_expect(par, lex_kind_comma);
@@ -46,10 +46,10 @@ void generate_wasm_app_code(ma_arena_t *arena) {
matched = true; matched = true;
} }
if (par->at->inside_macro == false && parser_matchi(par, s8_lit("mt_tweak_b32"))) { if (par->at->inside_macro == false && parser_matchi(par, s8("mt_tweak_b32"))) {
cg_tweak_t *tweak = ma_push_type(arena, cg_tweak_t); cg_tweak_t *tweak = ma_push_type(arena, cg_tweak_t);
tweak->type = type(b32); tweak->type = type(b32);
tweak->min = tweak->max = s8_lit("0"); tweak->min = tweak->max = s8("0");
parser_expect(par, lex_kind_open_paren); parser_expect(par, lex_kind_open_paren);
tweak->name = parser_expect(par, lex_kind_ident)->string; tweak->name = parser_expect(par, lex_kind_ident)->string;
parser_expect(par, lex_kind_comma); parser_expect(par, lex_kind_comma);
@@ -59,7 +59,7 @@ void generate_wasm_app_code(ma_arena_t *arena) {
matched = true; matched = true;
} }
if (par->at->inside_macro == false && parser_matchi(par, s8_lit("mt_tweak_f32"))) { if (par->at->inside_macro == false && parser_matchi(par, s8("mt_tweak_f32"))) {
cg_tweak_t *tweak = ma_push_type(arena, cg_tweak_t); cg_tweak_t *tweak = ma_push_type(arena, cg_tweak_t);
tweak->type = type(f32); tweak->type = type(f32);
parser_expect(par, lex_kind_open_paren); parser_expect(par, lex_kind_open_paren);
@@ -75,11 +75,11 @@ void generate_wasm_app_code(ma_arena_t *arena) {
matched = true; matched = true;
} }
if (par->at->inside_macro == false && parser_matchi(par, s8_lit("mt_tweak_color"))) { if (par->at->inside_macro == false && parser_matchi(par, s8("mt_tweak_color"))) {
cg_tweak_t *tweak = ma_push_type(arena, cg_tweak_t); cg_tweak_t *tweak = ma_push_type(arena, cg_tweak_t);
tweak->type = type(v4f32_t); tweak->type = type(v4f32_t);
tweak->min = s8_lit("0.0f"); tweak->min = s8("0.0f");
tweak->max = s8_lit("1.0f"); tweak->max = s8("1.0f");
parser_expect(par, lex_kind_open_paren); parser_expect(par, lex_kind_open_paren);
tweak->name = parser_expect(par, lex_kind_ident)->string; tweak->name = parser_expect(par, lex_kind_ident)->string;
parser_expect(par, lex_kind_comma); parser_expect(par, lex_kind_comma);
@@ -105,7 +105,7 @@ void generate_wasm_app_code(ma_arena_t *arena) {
} }
sb8_printf(sb_embeds, "gb_read_only mt_tweak_t tweak_table[] = {\n"); sb8_printf(sb_embeds, "gb_read_only mt_tweak_t tweak_table[] = {\n");
for (cg_tweak_t *it = first_tweak; it; it = it->next) { for (cg_tweak_t *it = first_tweak; it; it = it->next) {
sb8_printf(sb_embeds, " {type(%S), s8_const_lit(\"%S\"), &%S, %S, %S},\n", it->type->name, it->name, it->name, it->min, it->max); sb8_printf(sb_embeds, " {type(%S), s8_const(\"%S\"), &%S, %S, %S},\n", it->type->name, it->name, it->name, it->min, it->max);
} }
sb8_printf(sb_embeds, "\n};\n"); sb8_printf(sb_embeds, "\n};\n");
} }