From f3aa52ba3d92fa268556b5d2a3364a0c2c518af5 Mon Sep 17 00:00:00 2001 From: Krzosa Karol Date: Fri, 4 Apr 2025 08:25:47 +0200 Subject: [PATCH] string16 improvements --- build_file.c | 30 +-- src/app/app.gen.c | 362 ++++++++++++++--------------- src/app/app.meta.c | 8 +- src/app/app_win32.c | 16 +- src/core/core_hash_table.c | 2 +- src/core/core_lexer.c | 32 +-- src/core/core_lexer.h | 4 +- src/core/core_math.gen.c | 8 +- src/core/core_math_gen.py | 50 ++-- src/core/core_platform_wasm.c | 2 +- src/core/core_string.c | 30 +-- src/core/core_string.h | 14 +- src/core/core_string16.c | 119 +++++----- src/core/core_string16.h | 69 +----- src/core/core_type_info.c | 2 +- src/core/core_type_info.h | 298 ++++++++++++------------ src/meta/meta_cfiles.c | 6 +- src/meta/meta_format.c | 16 +- src/meta/meta_serialize_format.c | 12 +- src/meta/meta_table_format.c | 6 +- src/os/os_unix.c | 4 +- src/os/os_win32.c | 8 +- src/render/render.meta.c | 4 +- src/render/render_opengl.c | 2 +- src/render/render_wasm_canvas.c | 4 +- src/testing/testing.meta.c | 4 +- src/testing/testing_main.c | 82 +++---- src/text_editor/text_editor.gen.c | 4 +- src/text_editor/text_editor.meta.c | 24 +- src/ui/ui.c | 44 ++-- src/ui/ui.gen.c | 26 +-- src/ui/ui.meta.c | 16 +- src/wasm_app/wasm_app.gen.c | 4 +- src/wasm_app/wasm_app.meta.c | 24 +- 34 files changed, 637 insertions(+), 699 deletions(-) diff --git a/build_file.c b/build_file.c index 29416a7..8b25a77 100644 --- a/build_file.c +++ b/build_file.c @@ -24,12 +24,12 @@ #include "src/testing/testing.meta.c" 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; } if (PLATFORM_WINDOWS) { - os_delete_file(s8_lit("testing.pdb")); + os_delete_file(s8("testing.pdb")); int ok = os_systemf( "cl ../src/testing/testing_main.c -Fe:testing.exe -Fd:testing.pdb" " -I ../src" @@ -57,7 +57,7 @@ void build_testing_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; } int ok = os_systemf( @@ -71,7 +71,7 @@ void build_win32_app_base_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; } int ok = os_systemf( @@ -85,7 +85,7 @@ void build_text_editor_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; } int ok = os_systemf( @@ -99,8 +99,8 @@ void build_prototype_dll_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 wasm_code_modified = cache_code_modified(s8_lit("../src/wasm_app/main.c"), s8_lit("main.wasm")); + 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("../src/wasm_app/main.c"), s8("main.wasm")); if (html_code_modified) { 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) { - 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; } @@ -134,7 +134,7 @@ void build_prototype_standalone_target(void) { } 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; } @@ -153,9 +153,9 @@ int main(int argc, char **argv) { core_init(); 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; - cache_init(&Perm, s8_lit("cache_build_file")); + cache_init(&Perm, s8("cache_build_file")); generate_math_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"); } + if (run_testing_target) { + build_testing_target(); + } + if (run_prototype_standalone_target) { build_prototype_standalone_target(); } @@ -193,10 +197,6 @@ int main(int argc, char **argv) { build_text_editor_dll_target(); } - if (run_testing_target) { - build_testing_target(); - } - if (run_prototype_wasm_target) { build_prototype_wasm_target(); } diff --git a/src/app/app.gen.c b/src/app/app.gen.c index a555b09..c4b3f48 100644 --- a/src/app/app.gen.c +++ b/src/app/app.gen.c @@ -1,76 +1,76 @@ // 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[]){ - {.name = s8_const_lit("app_key_null"), .value = app_key_null}, - {.name = s8_const_lit("app_key_1"), .value = app_key_1}, - {.name = s8_const_lit("app_key_2"), .value = app_key_2}, - {.name = s8_const_lit("app_key_3"), .value = app_key_3}, - {.name = s8_const_lit("app_key_4"), .value = app_key_4}, - {.name = s8_const_lit("app_key_5"), .value = app_key_5}, - {.name = s8_const_lit("app_key_6"), .value = app_key_6}, - {.name = s8_const_lit("app_key_7"), .value = app_key_7}, - {.name = s8_const_lit("app_key_8"), .value = app_key_8}, - {.name = s8_const_lit("app_key_9"), .value = app_key_9}, - {.name = s8_const_lit("app_key_0"), .value = app_key_0}, - {.name = s8_const_lit("app_key_f1"), .value = app_key_f1}, - {.name = s8_const_lit("app_key_f2"), .value = app_key_f2}, - {.name = s8_const_lit("app_key_f3"), .value = app_key_f3}, - {.name = s8_const_lit("app_key_f4"), .value = app_key_f4}, - {.name = s8_const_lit("app_key_f5"), .value = app_key_f5}, - {.name = s8_const_lit("app_key_f6"), .value = app_key_f6}, - {.name = s8_const_lit("app_key_f7"), .value = app_key_f7}, - {.name = s8_const_lit("app_key_f8"), .value = app_key_f8}, - {.name = s8_const_lit("app_key_f9"), .value = app_key_f9}, - {.name = s8_const_lit("app_key_f10"), .value = app_key_f10}, - {.name = s8_const_lit("app_key_f11"), .value = app_key_f11}, - {.name = s8_const_lit("app_key_f12"), .value = app_key_f12}, - {.name = s8_const_lit("app_key_a"), .value = app_key_a}, - {.name = s8_const_lit("app_key_b"), .value = app_key_b}, - {.name = s8_const_lit("app_key_c"), .value = app_key_c}, - {.name = s8_const_lit("app_key_d"), .value = app_key_d}, - {.name = s8_const_lit("app_key_e"), .value = app_key_e}, - {.name = s8_const_lit("app_key_f"), .value = app_key_f}, - {.name = s8_const_lit("app_key_g"), .value = app_key_g}, - {.name = s8_const_lit("app_key_h"), .value = app_key_h}, - {.name = s8_const_lit("app_key_i"), .value = app_key_i}, - {.name = s8_const_lit("app_key_j"), .value = app_key_j}, - {.name = s8_const_lit("app_key_k"), .value = app_key_k}, - {.name = s8_const_lit("app_key_l"), .value = app_key_l}, - {.name = s8_const_lit("app_key_m"), .value = app_key_m}, - {.name = s8_const_lit("app_key_n"), .value = app_key_n}, - {.name = s8_const_lit("app_key_o"), .value = app_key_o}, - {.name = s8_const_lit("app_key_p"), .value = app_key_p}, - {.name = s8_const_lit("app_key_q"), .value = app_key_q}, - {.name = s8_const_lit("app_key_r"), .value = app_key_r}, - {.name = s8_const_lit("app_key_s"), .value = app_key_s}, - {.name = s8_const_lit("app_key__t"), .value = app_key__t}, - {.name = s8_const_lit("app_key_u"), .value = app_key_u}, - {.name = s8_const_lit("app_key_v"), .value = app_key_v}, - {.name = s8_const_lit("app_key_w"), .value = app_key_w}, - {.name = s8_const_lit("app_key_x"), .value = app_key_x}, - {.name = s8_const_lit("app_key_y"), .value = app_key_y}, - {.name = s8_const_lit("app_key_z"), .value = app_key_z}, - {.name = s8_const_lit("app_key_space"), .value = app_key_space}, - {.name = s8_const_lit("app_key_enter"), .value = app_key_enter}, - {.name = s8_const_lit("app_key_escape"), .value = app_key_escape}, - {.name = s8_const_lit("app_key_left"), .value = app_key_left}, - {.name = s8_const_lit("app_key_up"), .value = app_key_up}, - {.name = s8_const_lit("app_key_right"), .value = app_key_right}, - {.name = s8_const_lit("app_key_down"), .value = app_key_down}, - {.name = s8_const_lit("app_key_tab"), .value = app_key_tab}, - {.name = s8_const_lit("app_key_backspace"), .value = app_key_backspace}, - {.name = s8_const_lit("app_key_control"), .value = app_key_control}, - {.name = s8_const_lit("app_key_shift"), .value = app_key_shift}, - {.name = s8_const_lit("app_key_alt"), .value = app_key_alt}, - {.name = s8_const_lit("app_key_meta"), .value = app_key_meta}, - {.name = s8_const_lit("app_key_caps_lock"), .value = app_key_caps_lock}, - {.name = s8_const_lit("app_key_delete"), .value = app_key_delete}, - {.name = s8_const_lit("app_key_home"), .value = app_key_home}, - {.name = s8_const_lit("app_key_end"), .value = app_key_end}, - {.name = s8_const_lit("app_key_insert"), .value = app_key_insert}, - {.name = s8_const_lit("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_null"), .value = app_key_null}, + {.name = s8_const("app_key_1"), .value = app_key_1}, + {.name = s8_const("app_key_2"), .value = app_key_2}, + {.name = s8_const("app_key_3"), .value = app_key_3}, + {.name = s8_const("app_key_4"), .value = app_key_4}, + {.name = s8_const("app_key_5"), .value = app_key_5}, + {.name = s8_const("app_key_6"), .value = app_key_6}, + {.name = s8_const("app_key_7"), .value = app_key_7}, + {.name = s8_const("app_key_8"), .value = app_key_8}, + {.name = s8_const("app_key_9"), .value = app_key_9}, + {.name = s8_const("app_key_0"), .value = app_key_0}, + {.name = s8_const("app_key_f1"), .value = app_key_f1}, + {.name = s8_const("app_key_f2"), .value = app_key_f2}, + {.name = s8_const("app_key_f3"), .value = app_key_f3}, + {.name = s8_const("app_key_f4"), .value = app_key_f4}, + {.name = s8_const("app_key_f5"), .value = app_key_f5}, + {.name = s8_const("app_key_f6"), .value = app_key_f6}, + {.name = s8_const("app_key_f7"), .value = app_key_f7}, + {.name = s8_const("app_key_f8"), .value = app_key_f8}, + {.name = s8_const("app_key_f9"), .value = app_key_f9}, + {.name = s8_const("app_key_f10"), .value = app_key_f10}, + {.name = s8_const("app_key_f11"), .value = app_key_f11}, + {.name = s8_const("app_key_f12"), .value = app_key_f12}, + {.name = s8_const("app_key_a"), .value = app_key_a}, + {.name = s8_const("app_key_b"), .value = app_key_b}, + {.name = s8_const("app_key_c"), .value = app_key_c}, + {.name = s8_const("app_key_d"), .value = app_key_d}, + {.name = s8_const("app_key_e"), .value = app_key_e}, + {.name = s8_const("app_key_f"), .value = app_key_f}, + {.name = s8_const("app_key_g"), .value = app_key_g}, + {.name = s8_const("app_key_h"), .value = app_key_h}, + {.name = s8_const("app_key_i"), .value = app_key_i}, + {.name = s8_const("app_key_j"), .value = app_key_j}, + {.name = s8_const("app_key_k"), .value = app_key_k}, + {.name = s8_const("app_key_l"), .value = app_key_l}, + {.name = s8_const("app_key_m"), .value = app_key_m}, + {.name = s8_const("app_key_n"), .value = app_key_n}, + {.name = s8_const("app_key_o"), .value = app_key_o}, + {.name = s8_const("app_key_p"), .value = app_key_p}, + {.name = s8_const("app_key_q"), .value = app_key_q}, + {.name = s8_const("app_key_r"), .value = app_key_r}, + {.name = s8_const("app_key_s"), .value = app_key_s}, + {.name = s8_const("app_key__t"), .value = app_key__t}, + {.name = s8_const("app_key_u"), .value = app_key_u}, + {.name = s8_const("app_key_v"), .value = app_key_v}, + {.name = s8_const("app_key_w"), .value = app_key_w}, + {.name = s8_const("app_key_x"), .value = app_key_x}, + {.name = s8_const("app_key_y"), .value = app_key_y}, + {.name = s8_const("app_key_z"), .value = app_key_z}, + {.name = s8_const("app_key_space"), .value = app_key_space}, + {.name = s8_const("app_key_enter"), .value = app_key_enter}, + {.name = s8_const("app_key_escape"), .value = app_key_escape}, + {.name = s8_const("app_key_left"), .value = app_key_left}, + {.name = s8_const("app_key_up"), .value = app_key_up}, + {.name = s8_const("app_key_right"), .value = app_key_right}, + {.name = s8_const("app_key_down"), .value = app_key_down}, + {.name = s8_const("app_key_tab"), .value = app_key_tab}, + {.name = s8_const("app_key_backspace"), .value = app_key_backspace}, + {.name = s8_const("app_key_control"), .value = app_key_control}, + {.name = s8_const("app_key_shift"), .value = app_key_shift}, + {.name = s8_const("app_key_alt"), .value = app_key_alt}, + {.name = s8_const("app_key_meta"), .value = app_key_meta}, + {.name = s8_const("app_key_caps_lock"), .value = app_key_caps_lock}, + {.name = s8_const("app_key_delete"), .value = app_key_delete}, + {.name = s8_const("app_key_home"), .value = app_key_home}, + {.name = s8_const("app_key_end"), .value = app_key_end}, + {.name = s8_const("app_key_insert"), .value = app_key_insert}, + {.name = s8_const("app_key_page_up"), .value = app_key_page_up}, + {.name = s8_const("app_key_page_down"), .value = app_key_page_down}, }, .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; wasm_key_map_t wasm_map_key_string_to_app_key(s8_t key) { 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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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("1"), s8_ignore_case)) return (wasm_key_map_t){app_key_1, 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("3"), s8_ignore_case)) return (wasm_key_map_t){app_key_3, 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("5"), s8_ignore_case)) return (wasm_key_map_t){app_key_5, 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("7"), s8_ignore_case)) return (wasm_key_map_t){app_key_7, 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("9"), s8_ignore_case)) return (wasm_key_map_t){app_key_9, 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("F1"), s8_ignore_case)) return (wasm_key_map_t){app_key_f1, 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("F3"), s8_ignore_case)) return (wasm_key_map_t){app_key_f3, 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("F5"), s8_ignore_case)) return (wasm_key_map_t){app_key_f5, 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("F7"), s8_ignore_case)) return (wasm_key_map_t){app_key_f7, 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("F9"), s8_ignore_case)) return (wasm_key_map_t){app_key_f9, 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("F11"), s8_ignore_case)) return (wasm_key_map_t){app_key_f11, 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("a"), s8_ignore_case)) return (wasm_key_map_t){app_key_a, 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("c"), s8_ignore_case)) return (wasm_key_map_t){app_key_c, 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("e"), s8_ignore_case)) return (wasm_key_map_t){app_key_e, 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("g"), s8_ignore_case)) return (wasm_key_map_t){app_key_g, 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("i"), s8_ignore_case)) return (wasm_key_map_t){app_key_i, 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("k"), s8_ignore_case)) return (wasm_key_map_t){app_key_k, 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("m"), s8_ignore_case)) return (wasm_key_map_t){app_key_m, 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("o"), s8_ignore_case)) return (wasm_key_map_t){app_key_o, 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("q"), s8_ignore_case)) return (wasm_key_map_t){app_key_q, 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("s"), s8_ignore_case)) return (wasm_key_map_t){app_key_s, 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("u"), s8_ignore_case)) return (wasm_key_map_t){app_key_u, 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("w"), s8_ignore_case)) return (wasm_key_map_t){app_key_w, 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("y"), s8_ignore_case)) return (wasm_key_map_t){app_key_y, 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(" "), s8_ignore_case)) return (wasm_key_map_t){app_key_space, 0}; + 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("Escape"), s8_ignore_case)) return (wasm_key_map_t){app_key_escape, 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("ArrowUp"), s8_ignore_case)) return (wasm_key_map_t){app_key_up, 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("ArrowDown"), s8_ignore_case)) return (wasm_key_map_t){app_key_down, 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("Backspace"), s8_ignore_case)) return (wasm_key_map_t){app_key_backspace, 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("Shift"), s8_ignore_case)) return (wasm_key_map_t){app_key_shift, 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("AltGraph"), s8_ignore_case)) return (wasm_key_map_t){app_key_alt, 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("CapsLock"), s8_ignore_case)) return (wasm_key_map_t){app_key_caps_lock, 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("Home"), s8_ignore_case)) return (wasm_key_map_t){app_key_home, 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("Insert"), s8_ignore_case)) return (wasm_key_map_t){app_key_insert, 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("PageDown"), s8_ignore_case)) return (wasm_key_map_t){app_key_page_down, 1}; return (wasm_key_map_t){0}; } #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)*/ -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[]){ - {.name = s8_const_lit("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_lit("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_lit("app_mouse_button_count"), .value = app_mouse_button_count}, + {.name = s8_const("app_mouse_button_null"), .value = app_mouse_button_null}, + {.name = s8_const("app_mouse_button_left"), .value = app_mouse_button_left}, + {.name = s8_const("app_mouse_button_middle"), .value = app_mouse_button_middle}, + {.name = s8_const("app_mouse_button_right"), .value = app_mouse_button_right}, + {.name = s8_const("app_mouse_button_count"), .value = app_mouse_button_count}, }, .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[]){ - {.name = s8_const_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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_lit("app_event_kind_count"), .value = app_event_kind_count}, + {.name = s8_const("app_event_kind_null"), .value = app_event_kind_null}, + {.name = s8_const("app_event_kind_update"), .value = app_event_kind_update}, + {.name = s8_const("app_event_kind_init"), .value = app_event_kind_init}, + {.name = s8_const("app_event_kind_reload"), .value = app_event_kind_reload}, + {.name = s8_const("app_event_kind_unload"), .value = app_event_kind_unload}, + {.name = s8_const("app_event_kind_text"), .value = app_event_kind_text}, + {.name = s8_const("app_event_kind_key_down"), .value = app_event_kind_key_down}, + {.name = s8_const("app_event_kind_key_up"), .value = app_event_kind_key_up}, + {.name = s8_const("app_event_kind_mouse_down"), .value = app_event_kind_mouse_down}, + {.name = s8_const("app_event_kind_mouse_up"), .value = app_event_kind_mouse_up}, + {.name = s8_const("app_event_kind_mouse_wheel"), .value = app_event_kind_mouse_wheel}, + {.name = s8_const("app_event_kind_mouse_move"), .value = app_event_kind_mouse_move}, + {.name = s8_const("app_event_kind_count"), .value = app_event_kind_count}, }, .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[]){ - {.name = s8_const_lit("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_lit("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_lit("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_lit("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_lit("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_lit("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("id"), .type = &type__u64, .offset = offsetof(app_event_t, id), .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("kind"), .type = &type__app_event_kind_t, .offset = offsetof(app_event_t, kind), .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("key"), .type = &type__app_key_t, .offset = offsetof(app_event_t, key), .dont_serialize = 0}, + {.name = s8_const("text"), .type = &type__s8_t, .offset = offsetof(app_event_t, text), .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("ctrl"), .type = &type__b8, .offset = offsetof(app_event_t, ctrl), .dont_serialize = 0}, + {.name = s8_const("shift"), .type = &type__b8, .offset = offsetof(app_event_t, shift), .dont_serialize = 0}, + {.name = s8_const("alt"), .type = &type__b8, .offset = offsetof(app_event_t, alt), .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("mouse_delta"), .type = &type__v2f32_t, .offset = offsetof(app_event_t, mouse_delta), .dont_serialize = 0}, }, .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[]){ - {.name = s8_const_lit("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_lit("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_lit("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_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_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("window_size"), .type = &type__v2f32_t, .offset = offsetof(app_frame_t, window_size), .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("dpr"), .type = &type__f32, .offset = offsetof(app_frame_t, dpr), .dont_serialize = 0}, + {.name = s8_const("delta"), .type = &type__f64, .offset = offsetof(app_frame_t, delta), .dont_serialize = 0}, + {.name = s8_const("frame"), .type = &type__u64, .offset = offsetof(app_frame_t, frame), .dont_serialize = 0}, + {.name = s8_const("event_count"), .type = &type__i32, .offset = offsetof(app_frame_t, event_count), .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("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, }; \ No newline at end of file diff --git a/src/app/app.meta.c b/src/app/app.meta.c index afa9de4..e73b5e5 100644 --- a/src/app/app.meta.c +++ b/src/app/app.meta.c @@ -78,7 +78,7 @@ void generate_app_code(ma_arena_t *arena) { { page_up PageUp XXX 1 VK_INSERT 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 @@ -95,8 +95,8 @@ void generate_app_code(ma_arena_t *arena) { assert(mtt(it, "jf")->integer == 0 || mtt(it, "jf")->integer == 1); s8_t js[] = {mtts(it, "js1"), mtts(it, "js2")}; for (i32 i = 0; i < lengthof(js); i += 1) { - if (s8_are_equal(js[i], s8_lit("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); + if (s8_are_equal(js[i], s8("XXX"))) continue; + 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};"); @@ -116,7 +116,7 @@ void generate_app_code(ma_arena_t *arena) { for (ast_t *it = keys->first; it; it = it->next) { s8_t w[] = {mtts(it, "windows1"), mtts(it, "windows2")}; 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")); } } diff --git a/src/app/app_win32.c b/src/app/app_win32.c index a994500..4c75033 100644 --- a/src/app/app_win32.c +++ b/src/app/app_win32.c @@ -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) { 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); if (!encode.error) { utf8_result_t encode8 = utf32_to_utf8(encode.out_str); 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); } } @@ -350,10 +350,10 @@ int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int n ma_temp_t scratch = ma_begin_scratch(); s8_t dir = os_exe_dir(scratch.arena); 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_pdb = s8_ends_with(it->name, s8_lit(".pdb")); - b32 is_rdi = s8_ends_with(it->name, s8_lit(".rdi")); - b32 is_temp = s8_find(it->name, s8_lit("_temp_"), s8_seek_none) != -1; + b32 is_dll = s8_ends_with(it->name, s8(".dll")); + b32 is_pdb = s8_ends_with(it->name, s8(".pdb")); + b32 is_rdi = s8_ends_with(it->name, s8(".rdi")); + b32 is_temp = s8_find(it->name, s8("_temp_"), s8_seek_none) != -1; if (is_temp && (is_dll || is_pdb || is_rdi)) { b32 ok = os_delete(it->abs); assert(ok); @@ -461,8 +461,8 @@ int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int n w32_library_t lib = {0}; - lib.dll_name = s8_lit("app.dll"); - lib.update_fn_name = s8_lit("app_update"); + lib.dll_name = s8("app.dll"); + lib.update_fn_name = s8("app_update"); tcx->data[tcx_slot_app] = w32_load_opengl_fn; // Set VSync diff --git a/src/core/core_hash_table.c b/src/core/core_hash_table.c index 20f6ded..093e504 100644 --- a/src/core/core_hash_table.c +++ b/src/core/core_hash_table.c @@ -145,7 +145,7 @@ fn_test void test_hash_table(void) { 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); } diff --git a/src/core/core_lexer.c b/src/core/core_lexer.c index ff4120d..6095cf1 100644 --- a/src/core/core_lexer.c +++ b/src/core/core_lexer.c @@ -1,7 +1,7 @@ #define lex_error(TOKEN, STRING) do {\ errorf(STRING);\ TOKEN->kind = lex_kind_error;\ - TOKEN->string = s8_lit(STRING);\ + TOKEN->string = s8(STRING);\ } while (0) 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); 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; - } 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; - } 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; - } 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; lex_eat_macro_whitespace(lex); char end = 0; @@ -154,22 +154,22 @@ fn b32 lex_macro(lexer_t *lex, lex_t *token) { 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; - } 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; - } 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; lex_eat_macro_whitespace(lex); token->str = lex->at; 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; - } 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; - } 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; - } 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; } else { return false; @@ -329,7 +329,7 @@ fn void lex_token_ex(lexer_t *lex, lex_t *token) { s8_t string_to_lex = token->string; if (token->suffix != lex_suffix_none) { 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; } 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; if (token->suffix != lex_suffix_none) { 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; } 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[] = { -#define X(KIND, STR, SIMPLE) s8_const_lit(SIMPLE), +#define X(KIND, STR, SIMPLE) s8_const(SIMPLE), LEX_KIND_XLIST #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[] = { -#define X(KIND, STR, SIMPLE) s8_const_lit(STR), +#define X(KIND, STR, SIMPLE) s8_const(STR), LEX_KIND_XLIST #undef X }; diff --git a/src/core/core_lexer.h b/src/core/core_lexer.h index ed2f92d..5f16c1d 100644 --- a/src/core/core_lexer.h +++ b/src/core/core_lexer.h @@ -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 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 #undef X }; DEFINE_ENUM(lex_kind_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 #undef X }; diff --git a/src/core/core_math.gen.c b/src/core/core_math.gen.c index 193fa87..b2f8526 100644 --- a/src/core/core_math.gen.c +++ b/src/core/core_math.gen.c @@ -399,7 +399,7 @@ fn r2f32_t r2f32_fix(r2f32_t n) { }; return result; } - + fn r2f64_t r2f64_cut_left(r2f64_t *r, f64 value) { f64 minx = r->min.x; @@ -544,7 +544,7 @@ fn r2f64_t r2f64_fix(r2f64_t n) { }; return result; } - + fn r2i32_t r2i32_cut_left(r2i32_t *r, i32 value) { i32 minx = r->min.x; @@ -689,7 +689,7 @@ fn r2i32_t r2i32_fix(r2i32_t n) { }; return result; } - + fn r2i64_t r2i64_cut_left(r2i64_t *r, i64 value) { i64 minx = r->min.x; @@ -834,7 +834,7 @@ fn r2i64_t r2i64_fix(r2i64_t n) { }; return result; } - + 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 v4f64_t v4f32_to_v4f64(v4f32_t v) { return (v4f64_t){ (f64)v.x, (f64)v.y, (f64)v.z, (f64)v.w }; } diff --git a/src/core/core_math_gen.py b/src/core/core_math_gen.py index 38a6448..8cb09ea 100644 --- a/src/core/core_math_gen.py +++ b/src/core/core_math_gen.py @@ -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[]){ -# {s8_const_lit("x"), &type__f64, .offset = offsetof(v2f64_t, x)}, -# {s8_const_lit("y"), &type__f64, .offset = offsetof(v2f64_t, y)}, +# {s8_const("x"), &type__f64, .offset = offsetof(v2f64_t, x)}, +# {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[]){ -# {s8_const_lit("x"), &type__f64, .offset = offsetof(v3f64_t, x)}, -# {s8_const_lit("y"), &type__f64, .offset = offsetof(v3f64_t, y)}, -# {s8_const_lit("z"), &type__f64, .offset = offsetof(v3f64_t, z)}, +# {s8_const("x"), &type__f64, .offset = offsetof(v3f64_t, x)}, +# {s8_const("y"), &type__f64, .offset = offsetof(v3f64_t, y)}, +# {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[]){ -# {s8_const_lit("x"), &type__f64, .offset = offsetof(v4f64_t, x)}, -# {s8_const_lit("y"), &type__f64, .offset = offsetof(v4f64_t, y)}, -# {s8_const_lit("z"), &type__f64, .offset = offsetof(v4f64_t, z)}, -# {s8_const_lit("w"), &type__f64, .offset = offsetof(v4f64_t, w)}, +# {s8_const("x"), &type__f64, .offset = offsetof(v4f64_t, x)}, +# {s8_const("y"), &type__f64, .offset = offsetof(v4f64_t, y)}, +# {s8_const("z"), &type__f64, .offset = offsetof(v4f64_t, z)}, +# {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[]){ -# {s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, x0)}, -# {s8_const_lit("y0"), &type__f64, .offset = offsetof(r3f64_t, y0)}, -# {s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, z0)}, -# {s8_const_lit("x1"), &type__f64, .offset = offsetof(r3f64_t, x1)}, -# {s8_const_lit("y1"), &type__f64, .offset = offsetof(r3f64_t, y1)}, -# {s8_const_lit("x1"), &type__f64, .offset = offsetof(r3f64_t, z1)}, +# {s8_const("x0"), &type__f64, .offset = offsetof(r3f64_t, x0)}, +# {s8_const("y0"), &type__f64, .offset = offsetof(r3f64_t, y0)}, +# {s8_const("x0"), &type__f64, .offset = offsetof(r3f64_t, z0)}, +# {s8_const("x1"), &type__f64, .offset = offsetof(r3f64_t, x1)}, +# {s8_const("y1"), &type__f64, .offset = offsetof(r3f64_t, y1)}, +# {s8_const("x1"), &type__f64, .offset = offsetof(r3f64_t, z1)}, # } # }; # type_member_t members__r2f64_t[] = { -# {s8_const_lit("x0"), &type__f64, .offset = offsetof(r2f64_t, x0)}, -# {s8_const_lit("y0"), &type__f64, .offset = offsetof(r2f64_t, y0)}, -# {s8_const_lit("x1"), &type__f64, .offset = offsetof(r2f64_t, x1)}, -# {s8_const_lit("y1"), &type__f64, .offset = offsetof(r2f64_t, y1)}, +# {s8_const("x0"), &type__f64, .offset = offsetof(r2f64_t, x0)}, +# {s8_const("y0"), &type__f64, .offset = offsetof(r2f64_t, y0)}, +# {s8_const("x1"), &type__f64, .offset = offsetof(r2f64_t, x1)}, +# {s8_const("y1"), &type__f64, .offset = offsetof(r2f64_t, y1)}, # }; # DEFINE_STRUCT(r2f64_t); # type_member_t members__r1f64_t[] = { -# {s8_const_lit("x0"), &type__f64, .offset = offsetof(r1f64_t, x0)}, -# {s8_const_lit("x1"), &type__f64, .offset = offsetof(r1f64_t, x1)}, +# {s8_const("x0"), &type__f64, .offset = offsetof(r1f64_t, x0)}, +# {s8_const("x1"), &type__f64, .offset = offsetof(r1f64_t, x1)}, # }; # DEFINE_STRUCT(r1f64_t); # """ diff --git a/src/core/core_platform_wasm.c b/src/core/core_platform_wasm.c index bc44417..b0b43f4 100644 --- a/src/core/core_platform_wasm.c +++ b/src/core/core_platform_wasm.c @@ -30,7 +30,7 @@ fn void os_error_box(char *str) { fn void os_console_log(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); } wasm_write_to_console((isize)string.str, (i32)string.len); diff --git a/src/core/core_string.c b/src/core/core_string.c index 17f8484..0ff4c38 100644 --- a/src/core/core_string.c +++ b/src/core/core_string.c @@ -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)); memory_copy(copy, string.str, string.len); copy[string.len] = 0; - s8_t result = s8(copy, string.len); + s8_t result = s8_make(copy, string.len); 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)); memory_copy(copy, s, len); copy[len] = 0; - s8_t result = s8(copy, len); + s8_t result = s8_make(copy, len); 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) { len = CLAMP_TOP(len, string.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; } fn s8_t s8_get_prefix(s8_t string, int64_t len) { len = CLAMP_TOP(len, string.len); - s8_t result = s8(string.str, len); + s8_t result = s8_make(string.str, len); return result; } fn s8_t s8_chop(s8_t string, int64_t len) { len = CLAMP_TOP(len, string.len); - s8_t result = s8(string.str, string.len - len); + s8_t result = s8_make(string.str, string.len - len); return result; } fn s8_t s8_skip(s8_t string, int64_t len) { len = CLAMP_TOP(len, string.len); int64_t remain = string.len - len; - s8_t result = s8(string.str + len, remain); + s8_t result = s8_make(string.str + len, remain); return result; } @@ -171,7 +171,7 @@ fn s8_t s8_cut_end(s8_t *in, i64 size) { #if 0 s8_t s8_skip_to_p(s8_t string, char *p) { if (s8_is_pointer_inside(string, p)) { - s8_t result = s8(p, p - string.str); + s8_t result = s8_make(p, p - string.str); return result; } 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) { 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); 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) { - 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) { - 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) { @@ -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) { - 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) { - 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) { @@ -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)); s8_vsnprintf(result, (i32)(len + 1), str, args1); - s8_t res = s8(result, len); + s8_t res = s8_make(result, len); 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; 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); 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); } string = s8_skip(string, index + find.len); diff --git a/src/core/core_string.h b/src/core/core_string.h index 5ec8566..a660c61 100644 --- a/src/core/core_string.h +++ b/src/core/core_string.h @@ -57,11 +57,11 @@ fn f64 f64_from_s8(s8_t string); // // 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_invalid s8_lit("") -#define s8_lit(string) (s8_t){(char *)string, sizeof(string) - 1} -#define s8_const_lit(string) { string, sizeof(string) - 1 } +#define s8_invalid s8("") +#define s8(string) (s8_t){(char *)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_array(DATA) (s8_t){.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 #define s8_fmtspec(string) (int)(string).len, (string).str -#define S8_CODE(...) s8_lit(#__VA_ARGS__) -#define S8_FILE s8_lit(__FILE__) -#define S8_FILE_AND_LINE s8_lit(FILE_AND_LINE) +#define S8_CODE(...) s8(#__VA_ARGS__) +#define S8_FILE s8(__FILE__) +#define S8_FILE_AND_LINE s8(FILE_AND_LINE) #define S8_FMT(ma, str, result) \ va_list args1; \ diff --git a/src/core/core_string16.c b/src/core/core_string16.c index d04b84b..f7837da 100644 --- a/src/core/core_string16.c +++ b/src/core/core_string16.c @@ -1,4 +1,4 @@ -fn i64 wstr_len(wchar_t *string) { +fn i64 str16_len(u16 *string) { i64 len = 0; while (*string++ != 0) len++; @@ -47,32 +47,24 @@ fn s16_t s16_from_range(u16 *begin, u16 *end) { return result; } -fn s16_t s16_from_u16(u16 *string) { +fn s16_t s16_from_str16(u16 *string) { s16_t result; result.str = string; - result.len = wstr_len(string); + result.len = str16_len(string); 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) { i64 byte_size = sizeof(u16) * string.len; u16 *copy = (u16 *)ma_push_size(ma, byte_size + sizeof(u16)); memory_copy(copy, string.str, byte_size); copy[string.len] = 0; - s16_t result = s16(copy, string.len); + s16_t result = s16_make(copy, string.len); return result; } -fn s16_t s16_copy_u16(ma_arena_t *ma, u16 *s) { - return s16_copy(ma, s16(s, wstr_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 s16_t s16_copy_str16(ma_arena_t *ma, u16 *s) { + return s16_copy(ma, s16_make(s, str16_len(s))); } 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) { len = CLAMP_TOP(len, string.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; } fn s16_t s16_get_prefix(s16_t string, i64 len) { len = CLAMP_TOP(len, string.len); - s16_t result = s16(string.str, len); + s16_t result = s16_make(string.str, len); return result; } fn s16_t s16_chop(s16_t string, i64 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; } fn s16_t s16_skip(s16_t string, i64 len) { len = CLAMP_TOP(len, string.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; } @@ -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) { - 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) { - 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) { @@ -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) { - 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) { - 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) { @@ -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; 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); 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); } string = s16_skip(string, index + find.len); @@ -487,29 +479,28 @@ fn_test void test_string16(void) { // string16 lit basic tests { - s16_t a = s16_lit("memes"); - s16_t b = s16_lit("not memes"); - s16_t c = s16_lit("MEMES"); + s16_t a = s16("memes"); assert(a.len == 5); - assert(a.str[0] == L'm'); - assert(a.str[4] == L's'); + assert(a.str[0] == char16('m')); + 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, a) == 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(L'a') == 'A'); + assert(u16_to_upper_case(char16('a')) == 'A'); 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(s16_are_equal(a, s16_lit("memes")) == true); + assert(s16_are_equal(a, s16("memes")) == true); s16_t b = s16_copy(scratch.arena, a); assert(a.str != b.str); @@ -521,40 +512,40 @@ fn_test void test_string16(void) { } { - s16_t a = s16_lit("thing itself"); - assert(s16_starts_with_ex(a, s16_lit("thing"), false)); - assert(!s16_starts_with_ex(a, s16_lit("thing itself and"), false)); - assert(!s16_starts_with_ex(a, s16_lit("thing itself "), false)); - assert(s16_starts_with_ex(a, s16_lit("THING"), true)); - assert(!s16_starts_with_ex(a, s16_lit("a"), false)); + s16_t a = s16("thing itself"); + assert(s16_starts_with_ex(a, s16("thing"), false)); + assert(!s16_starts_with_ex(a, s16("thing itself and"), false)); + assert(!s16_starts_with_ex(a, s16("thing itself "), false)); + assert(s16_starts_with_ex(a, s16("THING"), true)); + 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_lit("thing itself"), false)); - assert(!s16_ends_with_ex(a, s16_lit("thing itselfa"), false)); + assert(s16_ends_with_ex(a, s16("itself"), false)); + assert(s16_ends_with_ex(a, s16("thing itself"), 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 + 4)); 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); assert(a.str[2] == '/'); } { - s16_t a = s16_lit(" thing "); + s16_t a = s16(" thing "); 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); - assert(s16_are_equal(a, s16_lit("432"))); - assert(f64_from_s16(s16_lit("432.0")) == 432.0); - assert(u64_from_s16(s16_lit("432"), 10) == 432); + assert(s16_are_equal(a, s16("432"))); + assert(f64_from_s16(s16("432.0")) == 432.0); + 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, "|"); 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|"); - sb16_t b = s16_split(scratch.arena, a, s16_lit("|"), s16_split_none); - assert(s16_are_equal(b.first->string, s16_lit("A"))); - assert(s16_are_equal(b.first->next->string, s16_lit("B"))); - assert(s16_are_equal(b.first->next->next->string, s16_lit("dek"))); - assert(s16_are_equal(b.first->next->next->next->string, s16_lit("mek"))); - assert(s16_are_equal(b.first->next->next->next->next->string, s16_lit("vek"))); + s16_t a = s16("A|B|dek|mek|vek|"); + sb16_t b = s16_split(scratch.arena, a, s16("|"), s16_split_none); + assert(s16_are_equal(b.first->string, s16("A"))); + assert(s16_are_equal(b.first->next->string, s16("B"))); + assert(s16_are_equal(b.first->next->next->string, s16("dek"))); + assert(s16_are_equal(b.first->next->next->next->string, s16("mek"))); + assert(s16_are_equal(b.first->next->next->next->next->string, s16("vek"))); assert(b.first->next->next->next->next->next == NULL); } { - s16_t a = s16_to_upper_case(scratch.arena, s16_lit("thing Meme")); - assert(s16_are_equal(a, s16_lit("THING MEME"))); + s16_t a = s16_to_upper_case(scratch.arena, s16("thing Meme")); + assert(s16_are_equal(a, s16("THING MEME"))); - a = s16_to_lower_case(scratch.arena, s16_lit("THING Meme")); - assert(s16_are_equal(a, s16_lit("thing meme"))); + a = s16_to_lower_case(scratch.arena, s16("THING Meme")); + assert(s16_are_equal(a, s16("thing meme"))); } { - s16_t a = s16_lit("C:/thing/itself"); - assert(s16_are_equal(s16_chop_last_slash(a), s16_lit("C:/thing"))); + s16_t a = s16("C:/thing/itself"); + assert(s16_are_equal(s16_chop_last_slash(a), s16("C:/thing"))); } ma_end_scratch(scratch); diff --git a/src/core/core_string16.h b/src/core/core_string16.h index 530c793..d6bb838 100644 --- a/src/core/core_string16.h +++ b/src/core/core_string16.h @@ -46,69 +46,16 @@ struct s32_t { i64 len; }; -#define s16(str,len) (s16_t){str, len} -#define s16_lit(str) (s16_t){L##str, sizeof(L##str) / sizeof(u16) - 1} +#define s16_make(str,len) (s16_t){str, len} + +#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("") +#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_serial_begin(ARENA) &(sb16_t){.arena = ARENA} #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); \ No newline at end of file diff --git a/src/core/core_type_info.c b/src/core/core_type_info.c index a9ad22b..b8bb36d 100644 --- a/src/core/core_type_info.c +++ b/src/core/core_type_info.c @@ -6,7 +6,7 @@ fn s8_t ti_enum_value_to_name(i64 value, type_t *type) { return it->name; } } - return s8_lit("invalid"); + return s8("invalid"); } fn i64 ti_enum_name_to_value(s8_t name, type_t *type) { diff --git a/src/core/core_type_info.h b/src/core/core_type_info.h index f52b507..175a1d5 100644 --- a/src/core/core_type_info.h +++ b/src/core/core_type_info.h @@ -80,278 +80,278 @@ fn type_member_t *ti_get_member(s8_t name, type_t *type); // // core type info data #define type(X) (&type__##X) -#define DEFINE_ENUM(x) type_t type__##x = {type_kind_enum, s8_const_lit(#x), sizeof(x), .members = members__##x, .count = lengthof(members__##x)} -#define DEFINE_STRUCT(x) type_t type__##x = {type_kind_struct, s8_const_lit(#x), sizeof(x), .members = members__##x, .count = lengthof(members__##x)} -#define POINTER(x) (type_t){type_kind_pointer, s8_const_lit(#x "*"), sizeof(void *), .base = &type__##x} +#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(#x), sizeof(x), .members = members__##x, .count = lengthof(members__##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__i16 = {type_kind_i16, s8_const_lit("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__i64 = {type_kind_i64, s8_const_lit("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__u16 = {type_kind_u16, s8_const_lit("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__u64 = {type_kind_u64, s8_const_lit("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__b16 = {type_kind_b16, s8_const_lit("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__b64 = {type_kind_b64, s8_const_lit("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__f64 = {type_kind_f64, s8_const_lit("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__usize = {type_kind_usize, s8_const_lit("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__char = {type_kind_char, s8_const_lit("char"), sizeof(char)}; -gb_read_only type_t type__void = {type_kind_void, s8_const_lit("void")}; +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("i16"), sizeof(i16)}; +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("i64"), sizeof(i64)}; +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("u16"), sizeof(u16)}; +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("u64"), sizeof(u64)}; +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("b16"), sizeof(b16)}; +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("b64"), sizeof(b64)}; +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("f64"), sizeof(f64)}; +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("usize"), sizeof(usize)}; +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("char"), sizeof(char)}; +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[]){ - {s8_const_lit("str"), &POINTER(char), .offset = offsetof(s8_t, str)}, - {s8_const_lit("len"), &type__i64, .offset = offsetof(s8_t, len)}, + {s8_const("str"), &POINTER(char), .offset = offsetof(s8_t, str)}, + {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[]){ - {s8_const_lit("str"), &POINTER(u16), .offset = offsetof(s16_t, str)}, - {s8_const_lit("len"), &type__i64, .offset = offsetof(s16_t, len)}, + {s8_const("str"), &POINTER(u16), .offset = offsetof(s16_t, str)}, + {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[]){ - {s8_const_lit("str"), &POINTER(u32), .offset = offsetof(s32_t, str)}, - {s8_const_lit("len"), &type__i64, .offset = offsetof(s32_t, len)}, + {s8_const("str"), &POINTER(u32), .offset = offsetof(s32_t, str)}, + {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[]){ - {s8_const_lit("data"), &POINTER(u8), .offset = offsetof(ma_arena_t, data)}, - {s8_const_lit("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_lit("reserve"), &type__usize, .offset = offsetof(ma_arena_t, reserve)}, - {s8_const_lit("commit"), &type__usize, .offset = offsetof(ma_arena_t, commit)}, - {s8_const_lit("align"), &type__usize, .offset = offsetof(ma_arena_t, align)}, + {s8_const("data"), &POINTER(u8), .offset = offsetof(ma_arena_t, data)}, + {s8_const("len"), &type__usize, .offset = offsetof(ma_arena_t, len)}, + {s8_const("base_len"), &type__usize, .offset = offsetof(ma_arena_t, base_len)}, + {s8_const("reserve"), &type__usize, .offset = offsetof(ma_arena_t, reserve)}, + {s8_const("commit"), &type__usize, .offset = offsetof(ma_arena_t, commit)}, + {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[]){ - {s8_const_lit("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("next"), &POINTER(sb8_node_t), .offset = offsetof(sb8_node_t, next)}, + {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[]){ - {s8_const_lit("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_lit("last"), &POINTER(sb8_node_t), .offset = offsetof(sb8_t, last)}, - {s8_const_lit("indent"), &type__i32, .offset = offsetof(sb8_t, indent)}, + {s8_const("arena"), &POINTER(ma_arena_t), .offset = offsetof(sb8_t, arena)}, + {s8_const("first"), &POINTER(sb8_node_t), .offset = offsetof(sb8_t, first)}, + {s8_const("last"), &POINTER(sb8_node_t), .offset = offsetof(sb8_t, last)}, + {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[]){ - {s8_const_lit("arena"), &POINTER(ma_arena_t), .offset = offsetof(ma_temp_t, arena)}, - {s8_const_lit("len"), &type__usize, .offset = offsetof(ma_temp_t, len)}, + {s8_const("arena"), &POINTER(ma_arena_t), .offset = offsetof(ma_temp_t, arena)}, + {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[]){ - {s8_const_lit("x"), &type__f32, .offset = offsetof(v2f32_t, x)}, - {s8_const_lit("y"), &type__f32, .offset = offsetof(v2f32_t, y)}, + {s8_const("x"), &type__f32, .offset = offsetof(v2f32_t, x)}, + {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[]){ - {s8_const_lit("x"), &type__f32, .offset = offsetof(v3f32_t, x)}, - {s8_const_lit("y"), &type__f32, .offset = offsetof(v3f32_t, y)}, - {s8_const_lit("z"), &type__f32, .offset = offsetof(v3f32_t, z)}, + {s8_const("x"), &type__f32, .offset = offsetof(v3f32_t, x)}, + {s8_const("y"), &type__f32, .offset = offsetof(v3f32_t, y)}, + {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[]){ - {s8_const_lit("x"), &type__f32, .offset = offsetof(v4f32_t, x)}, - {s8_const_lit("y"), &type__f32, .offset = offsetof(v4f32_t, y)}, - {s8_const_lit("z"), &type__f32, .offset = offsetof(v4f32_t, z)}, - {s8_const_lit("w"), &type__f32, .offset = offsetof(v4f32_t, w)}, + {s8_const("x"), &type__f32, .offset = offsetof(v4f32_t, x)}, + {s8_const("y"), &type__f32, .offset = offsetof(v4f32_t, y)}, + {s8_const("z"), &type__f32, .offset = offsetof(v4f32_t, z)}, + {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[]){ - {s8_const_lit("x0"), &type__f32, .offset = offsetof(r3f32_t, x0)}, - {s8_const_lit("y0"), &type__f32, .offset = offsetof(r3f32_t, y0)}, - {s8_const_lit("x0"), &type__f32, .offset = offsetof(r3f32_t, z0)}, - {s8_const_lit("x1"), &type__f32, .offset = offsetof(r3f32_t, x1)}, - {s8_const_lit("y1"), &type__f32, .offset = offsetof(r3f32_t, y1)}, - {s8_const_lit("x1"), &type__f32, .offset = offsetof(r3f32_t, z1)}, + {s8_const("x0"), &type__f32, .offset = offsetof(r3f32_t, x0)}, + {s8_const("y0"), &type__f32, .offset = offsetof(r3f32_t, y0)}, + {s8_const("x0"), &type__f32, .offset = offsetof(r3f32_t, z0)}, + {s8_const("x1"), &type__f32, .offset = offsetof(r3f32_t, x1)}, + {s8_const("y1"), &type__f32, .offset = offsetof(r3f32_t, y1)}, + {s8_const("x1"), &type__f32, .offset = offsetof(r3f32_t, z1)}, } }; gb_read_only type_member_t members__r2f32_t[] = { - {s8_const_lit("x0"), &type__f32, .offset = offsetof(r2f32_t, x0)}, - {s8_const_lit("y0"), &type__f32, .offset = offsetof(r2f32_t, y0)}, - {s8_const_lit("x1"), &type__f32, .offset = offsetof(r2f32_t, x1)}, - {s8_const_lit("y1"), &type__f32, .offset = offsetof(r2f32_t, y1)}, + {s8_const("x0"), &type__f32, .offset = offsetof(r2f32_t, x0)}, + {s8_const("y0"), &type__f32, .offset = offsetof(r2f32_t, y0)}, + {s8_const("x1"), &type__f32, .offset = offsetof(r2f32_t, x1)}, + {s8_const("y1"), &type__f32, .offset = offsetof(r2f32_t, y1)}, }; gb_read_only DEFINE_STRUCT(r2f32_t); gb_read_only type_member_t members__r1f32_t[] = { - {s8_const_lit("x0"), &type__f32, .offset = offsetof(r1f32_t, x0)}, - {s8_const_lit("x1"), &type__f32, .offset = offsetof(r1f32_t, x1)}, + {s8_const("x0"), &type__f32, .offset = offsetof(r1f32_t, x0)}, + {s8_const("x1"), &type__f32, .offset = offsetof(r1f32_t, x1)}, }; 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[]){ - {s8_const_lit("x"), &type__f64, .offset = offsetof(v2f64_t, x)}, - {s8_const_lit("y"), &type__f64, .offset = offsetof(v2f64_t, y)}, + {s8_const("x"), &type__f64, .offset = offsetof(v2f64_t, x)}, + {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[]){ - {s8_const_lit("x"), &type__f64, .offset = offsetof(v3f64_t, x)}, - {s8_const_lit("y"), &type__f64, .offset = offsetof(v3f64_t, y)}, - {s8_const_lit("z"), &type__f64, .offset = offsetof(v3f64_t, z)}, + {s8_const("x"), &type__f64, .offset = offsetof(v3f64_t, x)}, + {s8_const("y"), &type__f64, .offset = offsetof(v3f64_t, y)}, + {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[]){ - {s8_const_lit("x"), &type__f64, .offset = offsetof(v4f64_t, x)}, - {s8_const_lit("y"), &type__f64, .offset = offsetof(v4f64_t, y)}, - {s8_const_lit("z"), &type__f64, .offset = offsetof(v4f64_t, z)}, - {s8_const_lit("w"), &type__f64, .offset = offsetof(v4f64_t, w)}, + {s8_const("x"), &type__f64, .offset = offsetof(v4f64_t, x)}, + {s8_const("y"), &type__f64, .offset = offsetof(v4f64_t, y)}, + {s8_const("z"), &type__f64, .offset = offsetof(v4f64_t, z)}, + {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[]){ - {s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, x0)}, - {s8_const_lit("y0"), &type__f64, .offset = offsetof(r3f64_t, y0)}, - {s8_const_lit("x0"), &type__f64, .offset = offsetof(r3f64_t, z0)}, - {s8_const_lit("x1"), &type__f64, .offset = offsetof(r3f64_t, x1)}, - {s8_const_lit("y1"), &type__f64, .offset = offsetof(r3f64_t, y1)}, - {s8_const_lit("x1"), &type__f64, .offset = offsetof(r3f64_t, z1)}, + {s8_const("x0"), &type__f64, .offset = offsetof(r3f64_t, x0)}, + {s8_const("y0"), &type__f64, .offset = offsetof(r3f64_t, y0)}, + {s8_const("x0"), &type__f64, .offset = offsetof(r3f64_t, z0)}, + {s8_const("x1"), &type__f64, .offset = offsetof(r3f64_t, x1)}, + {s8_const("y1"), &type__f64, .offset = offsetof(r3f64_t, y1)}, + {s8_const("x1"), &type__f64, .offset = offsetof(r3f64_t, z1)}, } }; gb_read_only type_member_t members__r2f64_t[] = { - {s8_const_lit("x0"), &type__f64, .offset = offsetof(r2f64_t, x0)}, - {s8_const_lit("y0"), &type__f64, .offset = offsetof(r2f64_t, y0)}, - {s8_const_lit("x1"), &type__f64, .offset = offsetof(r2f64_t, x1)}, - {s8_const_lit("y1"), &type__f64, .offset = offsetof(r2f64_t, y1)}, + {s8_const("x0"), &type__f64, .offset = offsetof(r2f64_t, x0)}, + {s8_const("y0"), &type__f64, .offset = offsetof(r2f64_t, y0)}, + {s8_const("x1"), &type__f64, .offset = offsetof(r2f64_t, x1)}, + {s8_const("y1"), &type__f64, .offset = offsetof(r2f64_t, y1)}, }; gb_read_only DEFINE_STRUCT(r2f64_t); gb_read_only type_member_t members__r1f64_t[] = { - {s8_const_lit("x0"), &type__f64, .offset = offsetof(r1f64_t, x0)}, - {s8_const_lit("x1"), &type__f64, .offset = offsetof(r1f64_t, x1)}, + {s8_const("x0"), &type__f64, .offset = offsetof(r1f64_t, x0)}, + {s8_const("x1"), &type__f64, .offset = offsetof(r1f64_t, x1)}, }; 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[]){ - {s8_const_lit("x"), &type__i32, .offset = offsetof(v2i32_t, x)}, - {s8_const_lit("y"), &type__i32, .offset = offsetof(v2i32_t, y)}, + {s8_const("x"), &type__i32, .offset = offsetof(v2i32_t, x)}, + {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[]){ - {s8_const_lit("x"), &type__i32, .offset = offsetof(v3i32_t, x)}, - {s8_const_lit("y"), &type__i32, .offset = offsetof(v3i32_t, y)}, - {s8_const_lit("z"), &type__i32, .offset = offsetof(v3i32_t, z)}, + {s8_const("x"), &type__i32, .offset = offsetof(v3i32_t, x)}, + {s8_const("y"), &type__i32, .offset = offsetof(v3i32_t, y)}, + {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[]){ - {s8_const_lit("x"), &type__i32, .offset = offsetof(v4i32_t, x)}, - {s8_const_lit("y"), &type__i32, .offset = offsetof(v4i32_t, y)}, - {s8_const_lit("z"), &type__i32, .offset = offsetof(v4i32_t, z)}, - {s8_const_lit("w"), &type__i32, .offset = offsetof(v4i32_t, w)}, + {s8_const("x"), &type__i32, .offset = offsetof(v4i32_t, x)}, + {s8_const("y"), &type__i32, .offset = offsetof(v4i32_t, y)}, + {s8_const("z"), &type__i32, .offset = offsetof(v4i32_t, z)}, + {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[]){ - {s8_const_lit("x0"), &type__i32, .offset = offsetof(r3i32_t, x0)}, - {s8_const_lit("y0"), &type__i32, .offset = offsetof(r3i32_t, y0)}, - {s8_const_lit("x0"), &type__i32, .offset = offsetof(r3i32_t, z0)}, - {s8_const_lit("x1"), &type__i32, .offset = offsetof(r3i32_t, x1)}, - {s8_const_lit("y1"), &type__i32, .offset = offsetof(r3i32_t, y1)}, - {s8_const_lit("x1"), &type__i32, .offset = offsetof(r3i32_t, z1)}, + {s8_const("x0"), &type__i32, .offset = offsetof(r3i32_t, x0)}, + {s8_const("y0"), &type__i32, .offset = offsetof(r3i32_t, y0)}, + {s8_const("x0"), &type__i32, .offset = offsetof(r3i32_t, z0)}, + {s8_const("x1"), &type__i32, .offset = offsetof(r3i32_t, x1)}, + {s8_const("y1"), &type__i32, .offset = offsetof(r3i32_t, y1)}, + {s8_const("x1"), &type__i32, .offset = offsetof(r3i32_t, z1)}, } }; gb_read_only type_member_t members__r2i32_t[] = { - {s8_const_lit("x0"), &type__i32, .offset = offsetof(r2i32_t, x0)}, - {s8_const_lit("y0"), &type__i32, .offset = offsetof(r2i32_t, y0)}, - {s8_const_lit("x1"), &type__i32, .offset = offsetof(r2i32_t, x1)}, - {s8_const_lit("y1"), &type__i32, .offset = offsetof(r2i32_t, y1)}, + {s8_const("x0"), &type__i32, .offset = offsetof(r2i32_t, x0)}, + {s8_const("y0"), &type__i32, .offset = offsetof(r2i32_t, y0)}, + {s8_const("x1"), &type__i32, .offset = offsetof(r2i32_t, x1)}, + {s8_const("y1"), &type__i32, .offset = offsetof(r2i32_t, y1)}, }; gb_read_only DEFINE_STRUCT(r2i32_t); gb_read_only type_member_t members__r1i32_t[] = { - {s8_const_lit("x0"), &type__i32, .offset = offsetof(r1i32_t, x0)}, - {s8_const_lit("x1"), &type__i32, .offset = offsetof(r1i32_t, x1)}, + {s8_const("x0"), &type__i32, .offset = offsetof(r1i32_t, x0)}, + {s8_const("x1"), &type__i32, .offset = offsetof(r1i32_t, x1)}, }; 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[]){ - {s8_const_lit("x"), &type__i64, .offset = offsetof(v2i64_t, x)}, - {s8_const_lit("y"), &type__i64, .offset = offsetof(v2i64_t, y)}, + {s8_const("x"), &type__i64, .offset = offsetof(v2i64_t, x)}, + {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[]){ - {s8_const_lit("x"), &type__i64, .offset = offsetof(v3i64_t, x)}, - {s8_const_lit("y"), &type__i64, .offset = offsetof(v3i64_t, y)}, - {s8_const_lit("z"), &type__i64, .offset = offsetof(v3i64_t, z)}, + {s8_const("x"), &type__i64, .offset = offsetof(v3i64_t, x)}, + {s8_const("y"), &type__i64, .offset = offsetof(v3i64_t, y)}, + {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[]){ - {s8_const_lit("x"), &type__i64, .offset = offsetof(v4i64_t, x)}, - {s8_const_lit("y"), &type__i64, .offset = offsetof(v4i64_t, y)}, - {s8_const_lit("z"), &type__i64, .offset = offsetof(v4i64_t, z)}, - {s8_const_lit("w"), &type__i64, .offset = offsetof(v4i64_t, w)}, + {s8_const("x"), &type__i64, .offset = offsetof(v4i64_t, x)}, + {s8_const("y"), &type__i64, .offset = offsetof(v4i64_t, y)}, + {s8_const("z"), &type__i64, .offset = offsetof(v4i64_t, z)}, + {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[]){ - {s8_const_lit("x0"), &type__i64, .offset = offsetof(r3i64_t, x0)}, - {s8_const_lit("y0"), &type__i64, .offset = offsetof(r3i64_t, y0)}, - {s8_const_lit("x0"), &type__i64, .offset = offsetof(r3i64_t, z0)}, - {s8_const_lit("x1"), &type__i64, .offset = offsetof(r3i64_t, x1)}, - {s8_const_lit("y1"), &type__i64, .offset = offsetof(r3i64_t, y1)}, - {s8_const_lit("x1"), &type__i64, .offset = offsetof(r3i64_t, z1)}, + {s8_const("x0"), &type__i64, .offset = offsetof(r3i64_t, x0)}, + {s8_const("y0"), &type__i64, .offset = offsetof(r3i64_t, y0)}, + {s8_const("x0"), &type__i64, .offset = offsetof(r3i64_t, z0)}, + {s8_const("x1"), &type__i64, .offset = offsetof(r3i64_t, x1)}, + {s8_const("y1"), &type__i64, .offset = offsetof(r3i64_t, y1)}, + {s8_const("x1"), &type__i64, .offset = offsetof(r3i64_t, z1)}, } }; gb_read_only type_member_t members__r2i64_t[] = { - {s8_const_lit("x0"), &type__i64, .offset = offsetof(r2i64_t, x0)}, - {s8_const_lit("y0"), &type__i64, .offset = offsetof(r2i64_t, y0)}, - {s8_const_lit("x1"), &type__i64, .offset = offsetof(r2i64_t, x1)}, - {s8_const_lit("y1"), &type__i64, .offset = offsetof(r2i64_t, y1)}, + {s8_const("x0"), &type__i64, .offset = offsetof(r2i64_t, x0)}, + {s8_const("y0"), &type__i64, .offset = offsetof(r2i64_t, y0)}, + {s8_const("x1"), &type__i64, .offset = offsetof(r2i64_t, x1)}, + {s8_const("y1"), &type__i64, .offset = offsetof(r2i64_t, y1)}, }; gb_read_only DEFINE_STRUCT(r2i64_t); gb_read_only type_member_t members__r1i64_t[] = { - {s8_const_lit("x0"), &type__i64, .offset = offsetof(r1i64_t, x0)}, - {s8_const_lit("x1"), &type__i64, .offset = offsetof(r1i64_t, x1)}, + {s8_const("x0"), &type__i64, .offset = offsetof(r1i64_t, x0)}, + {s8_const("x1"), &type__i64, .offset = offsetof(r1i64_t, x1)}, }; gb_read_only DEFINE_STRUCT(r1i64_t); diff --git a/src/meta/meta_cfiles.c b/src/meta/meta_cfiles.c index 3bbfa5b..60704fd 100644 --- a/src/meta/meta_cfiles.c +++ b/src/meta/meta_cfiles.c @@ -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; } -#define mt_cpath(arena) mt_gen_filename(arena, S8_FILE, s8_lit("c")) -#define mt_hpath(arena) mt_gen_filename(arena, S8_FILE, s8_lit("h")) +#define mt_cpath(arena) mt_gen_filename(arena, S8_FILE, s8("c")) +#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) { 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); @@ -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) { sb8_t *result = ma_push_type(arena, sb8_t); result->arena = arena; - sb8_append(result, OS_GetAbsolutePath(&Perm, s8_lit("../src"))); + sb8_append(result, OS_GetAbsolutePath(&Perm, s8("../src"))); return result; } \ No newline at end of file diff --git a/src/meta/meta_format.c b/src/meta/meta_format.c index 574bdc4..a26fcc7 100644 --- a/src/meta/meta_format.c +++ b/src/meta/meta_format.c @@ -211,9 +211,9 @@ fn ast_t *mt_parse_decls(ma_arena_t *arena, char *file, s8_t code) { lex_t *pos = par->at; 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)); 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; parser_expect(par, lex_kind_semicolon); - if (parser_matchi(par, s8_lit("mt_tag")) && parser_expect(par, lex_kind_open_paren)) { - if (parser_expecti(par, s8_lit("flags"))) { + if (parser_matchi(par, s8("mt_tag")) && parser_expect(par, lex_kind_open_paren)) { + if (parser_expecti(par, s8("flags"))) { n->flags |= set_bit(ast_flag_flag_enum); } 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; } - 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_semicolon); 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)); mt_ast_append(result, n); 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); - if (parser_matchi(par, s8_lit("mt_tag")) && parser_expect(par, lex_kind_open_paren)) { - if (parser_expecti(par, s8_lit("dont_serialize"))) { + if (parser_matchi(par, s8("mt_tag")) && parser_expect(par, lex_kind_open_paren)) { + if (parser_expecti(par, s8("dont_serialize"))) { n->flags |= set_bit(ast_flag_dont_serialize); } parser_expect(par, lex_kind_close_paren); diff --git a/src/meta/meta_serialize_format.c b/src/meta/meta_serialize_format.c index db8b5fe..86d6902 100644 --- a/src/meta/meta_serialize_format.c +++ b/src/meta/meta_serialize_format.c @@ -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); } else if (n->flags & set_bit(ast_flag_type_pointer)) { 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)) { 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 { 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) { 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; sb8_stmtf(sb, ".members = (type_member_t[]){"); sb->indent += 1; 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; sb8_stmtf(sb, "},"); @@ -131,7 +131,7 @@ fn void mt_serialb_ast_to_type_info(sb8_t *sb, ast_t *n) { sb->indent -= 1; sb8_stmtf(sb, "};"); } 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; 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 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; - 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; sb8_stmtf(sb, "},"); diff --git a/src/meta/meta_table_format.c b/src/meta/meta_table_format.c index bc6c558..229c448 100644 --- a/src/meta/meta_table_format.c +++ b/src/meta/meta_table_format.c @@ -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;) { 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; continue; } @@ -185,14 +185,14 @@ fn void mtt_serial_enum(sb8_t *c, sb8_t *h, ast_t *table, s8_t decl) { /////////////////////////////// // 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; { sb8_stmtf(c, ".members = (type_member_t[]){"); c->indent += 1; { 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; diff --git a/src/os/os_unix.c b/src/os/os_unix.c index a0feda5..347c1b3 100644 --- a/src/os/os_unix.c +++ b/src/os/os_unix.c @@ -45,7 +45,7 @@ fn s8_t os_exe(ma_arena_t *arena) { ssize_t size = readlink("/proc/self/exe", buffer, buffer_size); assert(size < buffer_size); // @todo:? 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); return string; } @@ -122,7 +122,7 @@ fn s8_t os_read(ma_arena_t *arena, s8_t path) { fread(string, size, 1, fd); fclose(fd); - result = s8(string, size); + result = s8_make(string, size); result.str[result.len] = 0; } ma_end_scratch(temp); diff --git a/src/os/os_win32.c b/src/os/os_win32.c index 77b949c..f4ef992 100644 --- a/src/os/os_win32.c +++ b/src/os/os_win32.c @@ -151,7 +151,7 @@ fn void os_advance(os_iter_t *it) { if (data->cFileName[0] == '.' && data->cFileName[1] == 0) continue; 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 *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); @@ -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); assert(written != 0); 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); 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); DWORD wsize = GetModuleFileNameW(0, buffer, buffer_size); 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); ma_end_scratch(scratch); return result; @@ -283,7 +283,7 @@ fn s8_t os_cwd(ma_arena_t *arena) { DWORD wsize = GetCurrentDirectoryW(buffer_size, buffer); assert(wsize != 0); 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_t result = s8_printf(arena, "%S/", path); ma_end_scratch(scratch); diff --git a/src/render/render.meta.c b/src/render/render.meta.c index eceb0bb..eb0c914 100644 --- a/src/render/render.meta.c +++ b/src/render/render.meta.c @@ -3,8 +3,8 @@ void generate_render_code(ma_arena_t *arena) { sb8_printf(sb, "// automatically generated using: " __FILE__ "\n"); 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_lit("C:/Windows/Fonts/arial.ttf")); + s8_t content = OS_ReadFile(&Perm, s8("../package/FiraCode-Regular.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")); 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)); diff --git a/src/render/render_opengl.c b/src/render/render_opengl.c index 951a3f3..a19e923 100644 --- a/src/render/render_opengl.c +++ b/src/render/render_opengl.c @@ -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); 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->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); } diff --git a/src/render/render_wasm_canvas.c b/src/render/render_wasm_canvas.c index ae4ae7c..7ff3add 100644 --- a/src/render/render_wasm_canvas.c +++ b/src/render/render_wasm_canvas.c @@ -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 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); 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) { 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) { diff --git a/src/testing/testing.meta.c b/src/testing/testing.meta.c index 0e58c44..3284f2d 100644 --- a/src/testing/testing.meta.c +++ b/src/testing/testing.meta.c @@ -7,8 +7,8 @@ void generate_testing_code(ma_arena_t *arena) { for (;par->at->kind != lex_kind_eof;) { b32 matched = false; - if (par->at->inside_macro == false && parser_matchi(par, s8_lit("fn_test"))) { - parser_expecti(par, s8_lit("void")); + if (par->at->inside_macro == false && parser_matchi(par, s8("fn_test"))) { + parser_expecti(par, s8("void")); lex_t *ident = parser_match(par, lex_kind_ident); sb8_append(tests, ident->string); matched = true; diff --git a/src/testing/testing_main.c b/src/testing/testing_main.c index 6c5b73c..83c040f 100644 --- a/src/testing/testing_main.c +++ b/src/testing/testing_main.c @@ -24,10 +24,10 @@ fn void os_test(void) { assert(os_is_abs(exe_dir)); assert(os_is_abs(exe)); 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); - 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.len != 0); } @@ -39,90 +39,90 @@ fn void test_s8(void) { ma_temp_t temp = ma_begin_temp(arena); sb8_t *sb = &(sb8_t){arena}; - s8_t memes = s8_lit("memes"); + s8_t memes = s8("memes"); sb8_printf(sb, "%S", memes); assert(sb->first == sb->last); assert(sb->first->len == 5); 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); - 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); } { - s8_t str = s8_lit("thing|another|"); - sb8_t sb = s8_split(arena, str, s8_lit("|"), s8_split_none); + s8_t str = s8("thing|another|"); + 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->next->string, s8_lit("another"))); + assert(s8_are_equal(sb.first->string, s8("thing"))); + assert(s8_are_equal(sb.first->next->string, s8("another"))); assert(sb.first->next->next == NULL); } { - s8_t str = s8_lit("thing|another|"); - sb8_t sb = s8_split(arena, str, s8_lit("|"), s8_split_inclusive); + s8_t str = s8("thing|another|"); + 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->next->string, s8_lit("|"))); - assert(s8_are_equal(sb.first->next->next->string, s8_lit("another"))); - assert(s8_are_equal(sb.first->next->next->next->string, s8_lit("|"))); + assert(s8_are_equal(sb.first->string, s8("thing"))); + assert(s8_are_equal(sb.first->next->string, s8("|"))); + assert(s8_are_equal(sb.first->next->next->string, s8("another"))); + assert(s8_are_equal(sb.first->next->next->next->string, s8("|"))); assert(sb.first->next->next->next->next == NULL); } { - s8_t str = s8_lit("aabaaBaa"); - sb8_t sb = s8_split(arena, str, s8_lit("b"), s8_split_inclusive | s8_split_ignore_case); + s8_t str = s8("aabaaBaa"); + 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->next->string, s8_lit("b"))); - assert(s8_are_equal(sb.first->next->next->string, s8_lit("aa"))); - assert(s8_are_equal(sb.first->next->next->next->string, s8_lit("B"))); - assert(s8_are_equal(sb.first->next->next->next->next->string, s8_lit("aa"))); + assert(s8_are_equal(sb.first->string, s8("aa"))); + assert(s8_are_equal(sb.first->next->string, s8("b"))); + assert(s8_are_equal(sb.first->next->next->string, s8("aa"))); + assert(s8_are_equal(sb.first->next->next->next->string, s8("B"))); + assert(s8_are_equal(sb.first->next->next->next->next->string, s8("aa"))); assert(sb.first->next->next->next->next->next == NULL); } { - s8_t str = s8_lit("aabaaBaa"); - sb8_t sb = s8_split(arena, str, s8_lit("b"), s8_split_inclusive); + s8_t str = s8("aabaaBaa"); + 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->next->string, s8_lit("b"))); - assert(s8_are_equal(sb.first->next->next->string, s8_lit("aaBaa"))); + assert(s8_are_equal(sb.first->string, s8("aa"))); + assert(s8_are_equal(sb.first->next->string, s8("b"))); + assert(s8_are_equal(sb.first->next->next->string, s8("aaBaa"))); } { - s8_t s = s8_lit("0123456789"); - assert(s8_are_equal(s8_slice(s, 0, 4), s8_lit("0123"))); - assert(s8_are_equal(s8_slice(s, -2, -1), s8_lit("89"))); - assert(s8_are_equal(s8_slice(s, -2, 10), s8_lit("89"))); - assert(s8_are_equal(s8_slice(s, 8, 10), s8_lit("89"))); + s8_t s = s8("0123456789"); + assert(s8_are_equal(s8_slice(s, 0, 4), s8("0123"))); + assert(s8_are_equal(s8_slice(s, -2, -1), s8("89"))); + assert(s8_are_equal(s8_slice(s, -2, 10), s8("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); - 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); - 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("|"), ">"); - assert(s8_are_equal(s, s8_lit("32|v>"))); + s8_t s = s8_printf(arena, "%d%Sv%s", 32, s8("|"), ">"); + 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); - assert(s8_are_equal(s0, s8_lit("23456789"))); - assert(s8_are_equal(s1, s8_lit("01"))); + assert(s8_are_equal(s0, s8("23456789"))); + assert(s8_are_equal(s1, s8("01"))); } ma_destroy(arena); diff --git a/src/text_editor/text_editor.gen.c b/src/text_editor/text_editor.gen.c index a48a534..774cb0e 100644 --- a/src/text_editor/text_editor.gen.c +++ b/src/text_editor/text_editor.gen.c @@ -2,8 +2,8 @@ gb f32 font_size = 30; gb f32 _font_size = 30; gb_read_only mt_tweak_t tweak_table[] = { - {type(f32), s8_const_lit("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, 4, 200}, + {type(f32), s8_const("_font_size"), &_font_size, 30, 30}, }; void run_all_tests(void) { diff --git a/src/text_editor/text_editor.meta.c b/src/text_editor/text_editor.meta.c index 6818434..bf1420c 100644 --- a/src/text_editor/text_editor.meta.c +++ b/src/text_editor/text_editor.meta.c @@ -1,7 +1,7 @@ void generate_text_editor_code(ma_arena_t *arena) { sb8_t *include_paths = sb8(arena); - sb8_append(include_paths, OS_GetAbsolutePath(&Perm, s8_lit("../src"))); - mt_files_t files = mt_lex_files(arena, s8_lit("../src/text_editor/text_editor_main.c"), include_paths); + sb8_append(include_paths, OS_GetAbsolutePath(&Perm, s8("../src"))); + 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; struct cg_tweak_t { @@ -24,14 +24,14 @@ void generate_text_editor_code(ma_arena_t *arena) { for (;par->at->kind != lex_kind_eof;) { b32 matched = false; - if (par->at->inside_macro == false && parser_matchi(par, s8_lit("fn_test"))) { - parser_expecti(par, s8_lit("void")); + if (par->at->inside_macro == false && parser_matchi(par, s8("fn_test"))) { + parser_expecti(par, s8("void")); lex_t *ident = parser_match(par, lex_kind_ident); sb8_append(tests, ident->string); 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); lex_t *var_name = parser_expect(par, lex_kind_ident); parser_expect(par, lex_kind_comma); @@ -46,10 +46,10 @@ void generate_text_editor_code(ma_arena_t *arena) { 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); tweak->type = type(b32); - tweak->min = tweak->max = s8_lit("0"); + tweak->min = tweak->max = s8("0"); parser_expect(par, lex_kind_open_paren); tweak->name = parser_expect(par, lex_kind_ident)->string; parser_expect(par, lex_kind_comma); @@ -59,7 +59,7 @@ void generate_text_editor_code(ma_arena_t *arena) { 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); tweak->type = type(f32); parser_expect(par, lex_kind_open_paren); @@ -75,11 +75,11 @@ void generate_text_editor_code(ma_arena_t *arena) { 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); tweak->type = type(v4f32_t); - tweak->min = s8_lit("0.0f"); - tweak->max = s8_lit("1.0f"); + tweak->min = s8("0.0f"); + tweak->max = s8("1.0f"); parser_expect(par, lex_kind_open_paren); tweak->name = parser_expect(par, lex_kind_ident)->string; 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"); 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"); } diff --git a/src/ui/ui.c b/src/ui/ui.c index bec679c..bc6e717 100644 --- a/src/ui/ui.c +++ b/src/ui/ui.c @@ -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) { 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; } fn s8_t ui_get_hash_string(s8_t string) { 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); } return string; @@ -435,14 +435,14 @@ fn void ui_text_input_draw(ui_box_t *box) { rn_draw_rect(co.rect, co.background_color); 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)); rn_draw_string(rn->main_font, pos, co.text_color, string); 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_max = s8(ti->str, ti->caret.range.max); + s8_t string_min = s8_make(ti->str, ti->caret.range.min); + 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_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}; ti.str = buff; ti.cap = lengthof(buff); - ui_text_replace(&ti, r1i32(0,0), s8_lit("astfpo")); - assert(s8_are_equal(ti.string, s8_lit("astf"))); + ui_text_replace(&ti, r1i32(0,0), s8("astfpo")); + assert(s8_are_equal(ti.string, s8("astf"))); - ui_text_replace(&ti, r1i32(0,4), s8_lit("qwer")); - assert(s8_are_equal(ti.string, s8_lit("qwer"))); + ui_text_replace(&ti, r1i32(0,4), s8("qwer")); + assert(s8_are_equal(ti.string, s8("qwer"))); - ui_text_replace(&ti, r1i32(1,2), s8_lit("a")); - assert(s8_are_equal(ti.string, s8_lit("qaer"))); + ui_text_replace(&ti, r1i32(1,2), s8("a")); + assert(s8_are_equal(ti.string, s8("qaer"))); } #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) { - 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->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; if (ev->ctrl) { if (sel_size) { - ui_text_replace(ti, ti->caret.range, s8_lit("")); + ui_text_replace(ti, ti->caret.range, s8("")); } 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 { if (sel_size) { - ui_text_replace(ti, ti->caret.range, s8_lit("")); + ui_text_replace(ti, ti->caret.range, s8("")); } else { 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); @@ -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) { signal.text_changed = true; if (sel_size) { - ui_text_replace(ti, ti->caret.range, s8_lit("")); + ui_text_replace(ti, ti->caret.range, s8("")); } else { 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; } } - 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); i32 p = (i32)f32_round(pos.x / size.x); 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_lit("show data tab"), - s8_lit("show log tab"), - s8_lit("show menus tab"), + s8("show data tab"), + s8("show log tab"), + s8("show menus tab"), }; if (lister_open) { @@ -1292,7 +1292,7 @@ fn void ui_demo_everything_lister(void) { if (lister_just_opened) text_input.len = 0; 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)); 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)); for (i32 i = 0; i < tweak_count; i += 1) { 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; } diff --git a/src/ui/ui.gen.c b/src/ui/ui.gen.c index 3210f0b..1f98ff2 100644 --- a/src/ui/ui.gen.c +++ b/src/ui/ui.gen.c @@ -1,19 +1,19 @@ // 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[]){ - {.name = s8_const_lit("ui_color_rect"), .value = ui_color_rect}, - {.name = s8_const_lit("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_lit("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_lit("ui_color_text"), .value = ui_color_text}, - {.name = s8_const_lit("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_lit("ui_color_focused_rect"), .value = ui_color_focused_rect}, - {.name = s8_const_lit("ui_color_scroller"), .value = ui_color_scroller}, - {.name = s8_const_lit("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_rect"), .value = ui_color_rect}, + {.name = s8_const("ui_color_rect_hot"), .value = ui_color_rect_hot}, + {.name = s8_const("ui_color_rect_active"), .value = ui_color_rect_active}, + {.name = s8_const("ui_color_rect_turned_on"), .value = ui_color_rect_turned_on}, + {.name = s8_const("ui_color_border"), .value = ui_color_border}, + {.name = s8_const("ui_color_text"), .value = ui_color_text}, + {.name = s8_const("ui_color_text_hot"), .value = ui_color_text_hot}, + {.name = s8_const("ui_color_text_active"), .value = ui_color_text_active}, + {.name = s8_const("ui_color_focused_rect"), .value = ui_color_focused_rect}, + {.name = s8_const("ui_color_scroller"), .value = ui_color_scroller}, + {.name = s8_const("ui_color_scroller_hot"), .value = ui_color_scroller_hot}, + {.name = s8_const("ui_color_scroller_active"), .value = ui_color_scroller_active}, }, .count = 12, }; diff --git a/src/ui/ui.meta.c b/src/ui/ui.meta.c index 0057a5e..aeae74f 100644 --- a/src/ui/ui.meta.c +++ b/src/ui/ui.meta.c @@ -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})` } )); - 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[] = {"); 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 for (ast_t *it = table->first; it; it = it->next) { 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); } 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); } s8_t node = s8_printf(arena, "%S_node_t", ui_type); 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_lit("stack"), stack)); + mt_ast_append(it, mt_kv(arena, s8("node"), node)); + 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) {"); 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; } 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) {"); 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; } 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) {"); 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; } mt_stmtf(c, it, "box->@name = ui_top_@name();"); diff --git a/src/wasm_app/wasm_app.gen.c b/src/wasm_app/wasm_app.gen.c index dda8164..4d1fab2 100644 --- a/src/wasm_app/wasm_app.gen.c +++ b/src/wasm_app/wasm_app.gen.c @@ -2,8 +2,8 @@ gb f32 font_size = 30; gb f32 _font_size = 30; gb_read_only mt_tweak_t tweak_table[] = { - {type(f32), s8_const_lit("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, 4, 200}, + {type(f32), s8_const("_font_size"), &_font_size, 30, 30}, }; void run_all_tests(void) { diff --git a/src/wasm_app/wasm_app.meta.c b/src/wasm_app/wasm_app.meta.c index 7b46866..fbbf11e 100644 --- a/src/wasm_app/wasm_app.meta.c +++ b/src/wasm_app/wasm_app.meta.c @@ -1,7 +1,7 @@ void generate_wasm_app_code(ma_arena_t *arena) { sb8_t *include_paths = sb8(arena); - sb8_append(include_paths, OS_GetAbsolutePath(&Perm, s8_lit("../src"))); - mt_files_t files = mt_lex_files(arena, s8_lit("../src/wasm_app/main.c"), include_paths); + sb8_append(include_paths, OS_GetAbsolutePath(&Perm, s8("../src"))); + mt_files_t files = mt_lex_files(arena, s8("../src/wasm_app/main.c"), include_paths); typedef struct cg_tweak_t 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;) { b32 matched = false; - if (par->at->inside_macro == false && parser_matchi(par, s8_lit("fn_test"))) { - parser_expecti(par, s8_lit("void")); + if (par->at->inside_macro == false && parser_matchi(par, s8("fn_test"))) { + parser_expecti(par, s8("void")); lex_t *ident = parser_match(par, lex_kind_ident); sb8_append(tests, ident->string); 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); lex_t *var_name = parser_expect(par, lex_kind_ident); parser_expect(par, lex_kind_comma); @@ -46,10 +46,10 @@ void generate_wasm_app_code(ma_arena_t *arena) { 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); tweak->type = type(b32); - tweak->min = tweak->max = s8_lit("0"); + tweak->min = tweak->max = s8("0"); parser_expect(par, lex_kind_open_paren); tweak->name = parser_expect(par, lex_kind_ident)->string; parser_expect(par, lex_kind_comma); @@ -59,7 +59,7 @@ void generate_wasm_app_code(ma_arena_t *arena) { 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); tweak->type = type(f32); parser_expect(par, lex_kind_open_paren); @@ -75,11 +75,11 @@ void generate_wasm_app_code(ma_arena_t *arena) { 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); tweak->type = type(v4f32_t); - tweak->min = s8_lit("0.0f"); - tweak->max = s8_lit("1.0f"); + tweak->min = s8("0.0f"); + tweak->max = s8("1.0f"); parser_expect(par, lex_kind_open_paren); tweak->name = parser_expect(par, lex_kind_ident)->string; 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"); 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"); }