meta refactorings

build_file.c

@@ -6,23 +6,24 @@
 #define BUILD_TOOL_LIB
 #define S8_String s8_t
 #include "src/meta/build_tool.c"
-#include "src/meta/parser.c"
+#include "src/meta/meta_format.c"
-#include "src/meta/serialize.c"
+#include "src/meta/meta_serialize_format.c"
-#include "src/meta/cgen.c"
+#include "src/meta/meta_table_format.c"
+#include "src/meta/meta_cfiles.c"
 
 #include "src/app/app.meta.c"
 #include "src/ui/ui.meta.c"
 #include "src/wasm_app/wasm_app.meta.c"
 
 int main(int argc, char **argv) {
+    int ok = 0;
+    ma_arena_t *arena = ma_create(ma_default_reserve_size);
+
     SRC_SearchPaths.include_path = (char*[]){OS_GetAbsolutePath(&Perm, s8_lit("../src")).str};
     SRC_SearchPaths.include_path_count = 1;
     cache_init(&Perm, s8_lit("cache_build_file"));
-    ma_arena_t *arena = ma_create(ma_default_reserve_size);
-    int ok = 0;
 
     b32 generate_math = true;
-
     if (generate_math && cache_code_modified(s8_lit("../src/core/core_math_gen.py"), s8_null)) {
         os_set_working_dir("../src/core");
         os_systemf("py core_math_gen.py");

src/app/app.meta.c

@@ -3,7 +3,7 @@ void mt_app(ma_arena_t *arena) {
     sb8_t *c = sb8_serial_begin(arena);
 
 
-    ast_t *keys = parse_table(arena, __FILE__, S8_CODE(
+    ast_t *keys = mt_table_parse(arena, __FILE__, S8_CODE(
         //                                    javascript filter out
         | name      | js1        | js2      | jf | windows1   | windows2 |
         | null      | XXX        | XXX      | 1  | XXX        | XXX      |
@@ -76,14 +76,14 @@ void mt_app(ma_arena_t *arena) {
         | page_up   | PageUp     | XXX      | 1  | VK_INSERT  | XXX      |
         | page_down | PageDown   | XXX      | 1  | VK_PRIOR   | XXX      |
     ));
-    sb8_serial_table_enum(c, h, keys, s8_lit("app_key"));
+    mt_table_serial(c, h, keys, s8_lit("app_key"));
 
     // Javascript
     {
-        i32 name_idx = row_findi(keys->first, "name");
+        i32 name_idx = mt_table_find_rowi(keys->first, "name");
-        i32 js1_idx = row_findi(keys->first, "js1");
+        i32 js1_idx = mt_table_find_rowi(keys->first, "js1");
-        i32 js2_idx = row_findi(keys->first, "js2");
+        i32 js2_idx = mt_table_find_rowi(keys->first, "js2");
-        i32 filter_out_idx = row_findi(keys->first, "jf");
+        i32 filter_out_idx = mt_table_find_rowi(keys->first, "jf");
 
 
         sb8_stmtf(c, "\n#if PLATFORM_WASM");
@@ -92,11 +92,11 @@ void mt_app(ma_arena_t *arena) {
         c->indent += 1;
         sb8_stmtf(c, "if (0) {}");
         for (ast_t *row = keys->first->next; row; row = row->next) {
-            s8_t name = row_geti(row, name_idx)->string;
+            s8_t name = mt_table_get_rowi(row, name_idx)->string;
-            i64 filter_out = row_geti(row, filter_out_idx)->integer;
+            i64 filter_out = mt_table_get_rowi(row, filter_out_idx)->integer;
             assert(filter_out == 0 || filter_out == 1);
 
-            s8_t js[] = {row_geti(row, js1_idx)->string, row_geti(row, js2_idx)->string};
+            s8_t js[] = {mt_table_get_rowi(row, js1_idx)->string, mt_table_get_rowi(row, js2_idx)->string};
             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], name, (i32)filter_out);
@@ -110,9 +110,9 @@ void mt_app(ma_arena_t *arena) {
 
     // Windows
     {
-        i32 name_idx = row_findi(keys->first, "name");
+        i32 name_idx = mt_table_find_rowi(keys->first, "name");
-        i32 w1i = row_findi(keys->first, "windows1");
+        i32 w1i = mt_table_find_rowi(keys->first, "windows1");
-        i32 w2i = row_findi(keys->first, "windows2");
+        i32 w2i = mt_table_find_rowi(keys->first, "windows2");
 
         sb8_stmtf(c, "\n#if PLATFORM_WINDOWS");
         sb8_stmtf(c, "app_key_t w32_map_wparam_to_app_key(WPARAM wparam) {");
@@ -120,8 +120,8 @@ void mt_app(ma_arena_t *arena) {
         sb8_stmtf(c, "switch(wparam) {");
         c->indent += 1;
         for (ast_t *row = keys->first->next; row; row = row->next) {
-            s8_t name = row_geti(row, name_idx)->string;
+            s8_t name = mt_table_get_rowi(row, name_idx)->string;
-            s8_t w[] = {row_geti(row, w1i)->string, row_geti(row, w2i)->string};
+            s8_t w[] = {mt_table_get_rowi(row, w1i)->string, mt_table_get_rowi(row, w2i)->string};
             for (i32 i = 0; i < lengthof(w); i += 1) {
                 if (s8_are_equal(w[i], s8_lit("XXX"))) continue;
                 sb8_stmtf(c, "case %S: return app_key_%S; break;", w[i], name);
@@ -136,7 +136,7 @@ void mt_app(ma_arena_t *arena) {
     }
 
     {
-        ast_t *decls = parse_decls(arena, __FILE__, S8_CODE(
+        ast_t *decls = mt_parse_decls(arena, __FILE__, S8_CODE(
             typedef enum {
                 app_mouse_button_null,
                 app_mouse_button_left,
@@ -195,10 +195,10 @@ void mt_app(ma_arena_t *arena) {
             };
         ));
 
-        sb8_serial_ast_to_code(h, decls);
+        mt_serialb_ast_to_code(h, decls);
-        sb8_serial_ast_to_type_info(c, decls);
+        mt_serialb_ast_to_type_info(c, decls);
     }
 
-    os_write_file(cg_cpath(arena), sb8_serial_end(arena, c));
+    os_write_file(mt_cpath(arena), sb8_serial_end(arena, c));
-    os_write_file(cg_hpath(arena), sb8_serial_end(arena, h));
+    os_write_file(mt_hpath(arena), sb8_serial_end(arena, h));
 }

src/core/core_hash_table.h

@@ -38,13 +38,13 @@ fn ht_node_t *ht_insert_u64(ht_t *ht, u64 key, u64 value);
 fn ht_node_t *ht_insert_ptr        (ht_t *ht, void *key, void *value);
 fn ht_node_t *ht_insert_string     (ht_t *ht, s8_t key, s8_t value);
 fn ht_node_t *ht_insert_string_ptr (ht_t *ht, s8_t key, void *value);
-fn ht_node_t *ht_search_u64_ex(ht_t *ht, u64 key);
-fn ht_node_t *ht_search_ptr_ex(ht_t *ht, void *key);
-fn ht_node_t *ht_search_string_ex(ht_t *ht, s8_t key);
 fn u64       *ht_search_u64        (ht_t *ht, u64 key);
 fn void     **ht_search_ptr        (ht_t *ht, void *key);
 fn s8_t      *ht_search_string     (ht_t *ht, s8_t key);
 fn void     **ht_search_string_ptr (ht_t *ht, s8_t key);
+fn ht_node_t *ht_search_u64_ex     (ht_t *ht, u64 key);
+fn ht_node_t *ht_search_ptr_ex     (ht_t *ht, void *key);
+fn ht_node_t *ht_search_string_ex  (ht_t *ht, s8_t key);
 
 ///////////////////////////////
 // string interning

src/meta/meta_cfiles.c

@@ -1,18 +1,18 @@
-typedef struct cg_file_t cg_file_t;
+typedef struct mt_file_t mt_file_t;
-struct cg_file_t {
+struct mt_file_t {
-    cg_file_t *next;
+    mt_file_t *next;
     s8_t path;
     s8_t content;
     lex_array_t tokens;
 };
 
-typedef struct cg_files_t cg_files_t;
+typedef struct mt_files_t mt_files_t;
-struct cg_files_t {
+struct mt_files_t {
-    cg_file_t *first;
+    mt_file_t *first;
-    cg_file_t *last;
+    mt_file_t *last;
 };
 
-fn s8_t cg_resolve_path(ma_arena_t *arena, sb8_t *include_paths, s8_t filename, s8_t parent_file, b32 is_system_include) {
+fn s8_t mt_resolve_path(ma_arena_t *arena, sb8_t *include_paths, s8_t filename, s8_t parent_file, b32 is_system_include) {
     if (OS_IsAbsolute(filename) && os_file_exists(filename)) {
         return filename;
     }
@@ -39,28 +39,28 @@ fn s8_t cg_resolve_path(ma_arena_t *arena, sb8_t *include_paths, s8_t filename,
     return s8_null;
 }
 
-fn cg_file_t *cg_find_file_exact(cg_files_t *root, s8_t path) {
+fn mt_file_t *mt_find_file_exact(mt_files_t *root, s8_t path) {
-    for (cg_file_t *it = root->first; it; it = it->next) {
+    for (mt_file_t *it = root->first; it; it = it->next) {
         if (s8_are_equal(path, it->path)) return it;
     }
     return NULL;
 }
 
-fn cg_file_t *cg_find_file(cg_files_t *root, s8_t name) {
+fn mt_file_t *mt_find_file(mt_files_t *root, s8_t name) {
-    for (cg_file_t *it = root->first; it; it = it->next) {
+    for (mt_file_t *it = root->first; it; it = it->next) {
         if (s8_ends_with(name, it->path, false)) return it;
     }
     return NULL;
 }
 
-fn void cg__lex_files(ma_arena_t *arena, cg_files_t *root, s8_t path, sb8_t *include_paths) {
+fn void mt__lex_files(ma_arena_t *arena, mt_files_t *root, s8_t path, sb8_t *include_paths) {
     s8_t content = OS_ReadFile(&Perm, path);
     if (content.len == 0) {
         return;
     }
 
     lex_array_t array = lex_tokens(arena, path.str, content);
-    cg_file_t *file = ma_push_type(arena, cg_file_t);
+    mt_file_t *file = ma_push_type(arena, mt_file_t);
     file->tokens = array;
     file->content = content;
     file->path = path;
@@ -72,32 +72,32 @@ fn void cg__lex_files(ma_arena_t *arena, cg_files_t *root, s8_t path, sb8_t *inc
             continue;
         }
 
-        s8_t inc_path = cg_resolve_path(arena, include_paths, token->string, s8_from_char(token->file), token->system_include);
+        s8_t inc_path = mt_resolve_path(arena, include_paths, token->string, s8_from_char(token->file), token->system_include);
-        if (inc_path.len && cg_find_file_exact(root, inc_path) == NULL) {
+        if (inc_path.len && mt_find_file_exact(root, inc_path) == NULL) {
             // debugf("%s:%d %S, %S", token->file, token->line + 1, token->string, inc_path);
-            cg__lex_files(arena, root, inc_path, include_paths);
+            mt__lex_files(arena, root, inc_path, include_paths);
         }
     }
 }
 
-fn cg_files_t cg_lex_files(ma_arena_t *arena, s8_t path, sb8_t *include_paths) {
+fn mt_files_t mt_lex_files(ma_arena_t *arena, s8_t path, sb8_t *include_paths) {
-    cg_files_t files = {0};
+    mt_files_t files = {0};
     path = OS_GetAbsolutePath(&Perm, path);
-    cg__lex_files(arena, &files, path, include_paths);
+    mt__lex_files(arena, &files, path, include_paths);
     return files;
 }
 
-fn void cg_list_files_recursive(sb8_t *sb, s8_t path) {
+fn void mt_list_files_recursive(sb8_t *sb, s8_t path) {
     for (OS_FileIter iter = OS_IterateFiles(&Perm, path); OS_IsValid(iter); OS_Advance(&iter)) {
         if (iter.is_directory) {
-            cg_list_files_recursive(sb, iter.absolute_path);
+            mt_list_files_recursive(sb, iter.absolute_path);
         } else {
             sb8_append(sb, iter.absolute_path);
         }
     }
 }
 
-fn void cg_byte_array_from_data_ex(sb8_t *sb, s8_t file, s8_t var_name) {
+fn void mt_serial_to_cbyte_array_ex(sb8_t *sb, s8_t file, s8_t var_name) {
     sb8_printf(sb, "u8 %S[] = {", var_name);
     for (i64 i = 0; i < file.len; i += 1) {
         if ((i % 64) == 0) sb8_printf(sb, "\n");
@@ -107,18 +107,18 @@ fn void cg_byte_array_from_data_ex(sb8_t *sb, s8_t file, s8_t var_name) {
     sb8_printf(sb, "\n};\n");
 }
 
-fn s8_t cg_byte_array_from_data(ma_arena_t *arena, s8_t file, s8_t var_name) {
+fn s8_t mt_serial_to_cbyte_array(ma_arena_t *arena, s8_t file, s8_t var_name) {
     ma_temp_t scratch = ma_begin_scratch1(arena);
     sb8_t *sb = sb8_serial_begin(scratch.arena);
-    cg_byte_array_from_data_ex(sb, file, var_name);
+    mt_serial_to_cbyte_array_ex(sb, file, var_name);
     s8_t result = sb8_serial_end(arena, sb);
     ma_end_scratch(scratch);
     return result;
 }
 
-#define cg_cpath(arena) cg_gen_filename(arena, s8_lit(__FILE__), s8_lit("c"))
+#define mt_cpath(arena) mt_gen_filename(arena, s8_lit(__FILE__), s8_lit("c"))
-#define cg_hpath(arena) cg_gen_filename(arena, s8_lit(__FILE__), s8_lit("h"))
+#define mt_hpath(arena) mt_gen_filename(arena, s8_lit(__FILE__), s8_lit("h"))
-fn s8_t cg_gen_filename(ma_arena_t *arena, s8_t lit_file, s8_t ext) {
+fn s8_t mt_gen_filename(ma_arena_t *arena, s8_t lit_file, s8_t ext) {
     s8_t file_noext = s8_chop_last_period(s8_chop_last_period(lit_file));
     s8_t file = s8_printf(arena, "%S.gen.%S", file_noext, ext);
     return file;

src/meta/meta_format.c

@@ -1,6 +1,6 @@
 typedef enum {
 
-#define AST_FLAG_XLIST          \
+#define MT_AST_FLAG_XLIST       \
     X(ast_flag_null)            \
     X(ast_flag_string)          \
     X(ast_flag_integer)         \
@@ -19,7 +19,7 @@ typedef enum {
 
 
 #define X(NAME) NAME,
-    AST_FLAG_XLIST
+    MT_AST_FLAG_XLIST
 #undef X
 } ast_flag_t;
 
@@ -38,18 +38,18 @@ struct ast_t {
     i64 integer;
 };
 
-s8_t s8_serial_ast_flag_t(ma_arena_t *arena, ast_flag_t flag) {
+fn s8_t s8_serial_ast_flag_t(ma_arena_t *arena, ast_flag_t flag) {
     ma_temp_t scratch = ma_begin_scratch1(arena);
     sb8_t *sb = sb8_serial_begin(scratch.arena);
 #define X(NAME) if (flag & set_bit(NAME)) sb8_printf(sb, #NAME);
-    AST_FLAG_XLIST
+    MT_AST_FLAG_XLIST
 #undef X
     s8_t result = sb8_serial_end(arena, sb);
     ma_end_scratch(scratch);
     return result;
 }
 
-ast_t *create_ast(parser_t *par, lex_t *pos, ast_flag_t flags) {
+fn ast_t *mt_create_ast(parser_t *par, lex_t *pos, ast_flag_t flags) {
     ast_t *result = ma_push_type(par->arena, ast_t);
     memset(result, 0, sizeof(ast_t));
     result->flags = flags;
@@ -57,35 +57,35 @@ ast_t *create_ast(parser_t *par, lex_t *pos, ast_flag_t flags) {
     return result;
 }
 
-void ast_append(ast_t *parent, ast_t *node) {
+fn void mt_ast_append(ast_t *parent, ast_t *node) {
     SLLQ_APPEND(parent->first, parent->last, node);
     parent->len += 1;
 }
 
-ast_t *create_ast_binary(parser_t *par, lex_t *pos, ast_t *left, lex_kind_t op, ast_t *right) {
+fn ast_t *mt_create_ast_binary(parser_t *par, lex_t *pos, ast_t *left, lex_kind_t op, ast_t *right) {
-    ast_t *result = create_ast(par, pos, set_bit(ast_flag_string) | set_bit(ast_flag_binary) | set_bit(ast_flag_integer));
+    ast_t *result = mt_create_ast(par, pos, set_bit(ast_flag_string) | set_bit(ast_flag_binary) | set_bit(ast_flag_integer));
-    ast_append(result, left);
+    mt_ast_append(result, left);
-    ast_append(result, right);
+    mt_ast_append(result, right);
     result->integer = op;
     result->string = lex_kind_to_simple_s8(op);
     return result;
 }
 
-ast_t *parse_expr(parser_t *par);
+fn ast_t *mt_parse_expr(parser_t *par);
-ast_t *parse_lit_expr(parser_t *par) {
+fn ast_t *mt_parse_lit_expr(parser_t *par) {
     lex_t *token = parser_next(par);
     if (token->kind == lex_kind_integer) {
-        ast_t *result = create_ast(par, token, set_bit(ast_flag_integer) | set_bit(ast_flag_string));
+        ast_t *result = mt_create_ast(par, token, set_bit(ast_flag_integer) | set_bit(ast_flag_string));
         result->integer = token->integer;
         result->string = token->string;
         return result;
     } else if (token->kind == lex_kind_real) {
-        ast_t *result = create_ast(par, token, set_bit(ast_flag_real) | set_bit(ast_flag_string));
+        ast_t *result = mt_create_ast(par, token, set_bit(ast_flag_real) | set_bit(ast_flag_string));
         result->real = (double)token->real;
         result->string = token->string;
         return result;
     } else if (token->kind == lex_kind_open_paren) {
-        ast_t *result = parse_expr(par);
+        ast_t *result = mt_parse_expr(par);
         parser_expect(par, lex_kind_close_paren);
         return result;
     } else {
@@ -94,61 +94,61 @@ ast_t *parse_lit_expr(parser_t *par) {
     }
 }
 
-ast_t *parse_mul_expr(parser_t *par) {
+fn ast_t *mt_parse_mul_expr(parser_t *par) {
-    ast_t *left = parse_lit_expr(par);
+    ast_t *left = mt_parse_lit_expr(par);
     while (par->at->kind == lex_kind_multiply || par->at->kind == lex_kind_divide || par->at->kind == lex_kind_modulo) {
         lex_t *op = parser_next(par);
-        left = create_ast_binary(par, op, left, op->kind, parse_lit_expr(par));
+        left = mt_create_ast_binary(par, op, left, op->kind, mt_parse_lit_expr(par));
     }
     return left;
 }
 
-ast_t *parse_add_expr(parser_t *par) {
+fn ast_t *mt_parse_add_expr(parser_t *par) {
-    ast_t *left = parse_mul_expr(par);
+    ast_t *left = mt_parse_mul_expr(par);
     while (par->at->kind == lex_kind_plus || par->at->kind == lex_kind_minus) {
         lex_t *op = parser_next(par);
-        left = create_ast_binary(par, op, left, op->kind, parse_lit_expr(par));
+        left = mt_create_ast_binary(par, op, left, op->kind, mt_parse_lit_expr(par));
     }
     return left;
 }
 
-ast_t *parse_logical_and_expr(parser_t *par) {
+fn ast_t *mt_parse_logical_and_expr(parser_t *par) {
-    ast_t *left = parse_add_expr(par);
+    ast_t *left = mt_parse_add_expr(par);
     while (par->at->kind == lex_kind_or) {
         lex_t *op = parser_next(par);
-        left = create_ast_binary(par, op, left, op->kind, parse_lit_expr(par));
+        left = mt_create_ast_binary(par, op, left, op->kind, mt_parse_lit_expr(par));
     }
     return left;
 }
 
-ast_t *parse_logical_or_expr(parser_t *par) {
+fn ast_t *parse_logical_or_expr(parser_t *par) {
-    ast_t *left = parse_logical_and_expr(par);
+    ast_t *left = mt_parse_logical_and_expr(par);
     while (par->at->kind == lex_kind_or) {
         lex_t *op = parser_next(par);
-        left = create_ast_binary(par, op, left, op->kind, parse_lit_expr(par));
+        left = mt_create_ast_binary(par, op, left, op->kind, mt_parse_lit_expr(par));
     }
     return left;
 }
 
-ast_t *parse_expr(parser_t *par) {
+fn ast_t *mt_parse_expr(parser_t *par) {
     ast_t *expr = parse_logical_or_expr(par);
     return expr;
 }
 
-ast_t *parse_expr_str(ma_arena_t *arena, char *file_name, s8_t stream) {
+fn ast_t *mt_parse_expr_str(ma_arena_t *arena, char *file_name, s8_t stream) {
     lex_array_t tokens = lex_tokens(arena, file_name, stream);
     parser_t *par = parser_make(arena, tokens.data);
-    ast_t *result = parse_expr(par);
+    ast_t *result = mt_parse_expr(par);
     return result;
 }
 
-i64 eval_const_expr(ast_t *expr) {
+fn i64 mt_eval_const_expr(ast_t *expr) {
     if (expr->flags & set_bit(ast_flag_integer)) {
         return expr->integer;
     } else if (expr->flags & set_bit(ast_flag_binary)) {
         assert(expr->first != expr->last);
-        i64 left = eval_const_expr(expr->first);
+        i64 left = mt_eval_const_expr(expr->first);
-        i64 right = eval_const_expr(expr->last);
+        i64 right = mt_eval_const_expr(expr->last);
 
         switch(expr->integer) {
             case lex_kind_plus: return left + right;
@@ -171,13 +171,13 @@ i64 eval_const_expr(ast_t *expr) {
 #define test_expr(x) do {\
     lex_array_t tokens = lex_tokens(scratch.arena, "parser_test", s8_lit(#x));\
     parser_t *par = parser_make(scratch.arena, tokens.data);\
-    ast_t *expr = parse_expr(par);\
+    ast_t *expr = mt_parse_expr(par);\
     assert(expr != NULL);\
-    i64 value = eval_const_expr(expr);\
+    i64 value = mt_eval_const_expr(expr);\
     assert(value == x);\
 } while (0)
 
-void run_parser_test() {
+fn void run_parser_test() {
     ma_temp_t scratch = ma_begin_scratch();
     test_expr(32 + 2 + 5 + 5);
     test_expr(32 - 2 + 5 - 5);
@@ -191,14 +191,14 @@ void run_parser_test() {
     ma_end_scratch(scratch);
 }
 
-ast_t *parse_struct_mem(parser_t *par, s8_t *name) {
+fn ast_t *mt_parse_struct_mem(parser_t *par, s8_t *name) {
     lex_t *type_name = parser_expect(par, lex_kind_ident);
-    ast_t *type = create_ast(par, type_name, set_bit(ast_flag_type_name) | set_bit(ast_flag_string));
+    ast_t *type = mt_create_ast(par, type_name, set_bit(ast_flag_type_name) | set_bit(ast_flag_string));
     type->string = type_name->string;
 
     while (parser_match(par, lex_kind_multiply)) {
-        ast_t *pointer = create_ast(par, par->at, set_bit(ast_flag_type_pointer) | set_bit(ast_flag_string));
+        ast_t *pointer = mt_create_ast(par, par->at, set_bit(ast_flag_type_pointer) | set_bit(ast_flag_string));
-        ast_append(pointer, type);
+        mt_ast_append(pointer, type);
         pointer->string = s8_printf(par->arena, "%S*", type->string);
         type = pointer;
     }
@@ -206,8 +206,8 @@ ast_t *parse_struct_mem(parser_t *par, s8_t *name) {
     *name = parser_expect(par, lex_kind_ident)->string;
 
     while (parser_match(par, lex_kind_open_bracket)) {
-        ast_t *array = create_ast(par, par->at, set_bit(ast_flag_type_array) | set_bit(ast_flag_string));
+        ast_t *array = mt_create_ast(par, par->at, set_bit(ast_flag_type_array) | set_bit(ast_flag_string));
-        ast_append(array, type);
+        mt_ast_append(array, type);
         lex_t *num = parser_match(par, lex_kind_integer);
         if (num) {
             array->flags |= set_bit(ast_flag_integer);
@@ -223,10 +223,10 @@ ast_t *parse_struct_mem(parser_t *par, s8_t *name) {
     return type;
 }
 
-ast_t *parse_decls(ma_arena_t *arena, char *file, s8_t code) {
+fn ast_t *mt_parse_decls(ma_arena_t *arena, char *file, s8_t code) {
     lex_array_t tokens = lex_tokens(arena, file, code);
     parser_t *par = parser_make(arena, tokens.data);
-    ast_t *result = create_ast(par, par->at, set_bit(ast_flag_string));
+    ast_t *result = mt_create_ast(par, par->at, set_bit(ast_flag_string));
     result->string = s8_copy_char(arena, file);
     for (;par->at->kind != lex_kind_eof;) {
         lex_t *pos = par->at;
@@ -235,18 +235,18 @@ ast_t *parse_decls(ma_arena_t *arena, char *file, s8_t code) {
         b32 is_typedef = !!parser_matchi(par, s8_lit("typedef"));
 
         if (is_typedef && parser_matchi(par, s8_lit("enum"))) {
-            ast_t *n = create_ast(par, pos, set_bit(ast_flag_string) | set_bit(ast_flag_enum));
+            ast_t *n = mt_create_ast(par, pos, set_bit(ast_flag_string) | set_bit(ast_flag_enum));
-            ast_append(result, n);
+            mt_ast_append(result, n);
 
             parser_expect(par, lex_kind_open_brace);
             while (par->at->kind == lex_kind_ident) {
                 lex_t *val = parser_expect(par, lex_kind_ident);
-                ast_t *mem = create_ast(par, val, set_bit(ast_flag_enum_member) | set_bit(ast_flag_string));
+                ast_t *mem = mt_create_ast(par, val, set_bit(ast_flag_enum_member) | set_bit(ast_flag_string));
                 mem->string = val->string;
-                ast_append(n, mem);
+                mt_ast_append(n, mem);
 
                 // if (parser_match(par, lex_kind_assign)) {
-                //     parse_expr();
+                //     mt_parse_expr();
                 // }
 
                 if (!parser_match(par, lex_kind_comma)) break;
@@ -254,11 +254,13 @@ ast_t *parse_decls(ma_arena_t *arena, char *file, s8_t code) {
             parser_expect(par, lex_kind_close_brace);
             n->string = parser_expect(par, lex_kind_ident)->string;
             parser_expect(par, lex_kind_semicolon);
-            if (parser_match(par, lex_kind_tag) && parser_expecti(par, s8_lit("flags"))) {
+
+            if (parser_matchi(par, s8_lit("mt_tag")) && parser_expect(par, lex_kind_open_paren)) {
+                if (parser_expecti(par, s8_lit("flags"))) {
                     n->flags |= set_bit(ast_flag_flag_enum);
                 }
-
+                parser_expect(par, lex_kind_close_paren);
-
+            }
 
             matched = true;
         }
@@ -271,23 +273,25 @@ ast_t *parse_decls(ma_arena_t *arena, char *file, s8_t code) {
         }
 
         if (parser_matchi(par, s8_lit("struct"))) {
-            ast_t *n = create_ast(par, pos, set_bit(ast_flag_string) | set_bit(ast_flag_struct));
+            ast_t *n = mt_create_ast(par, pos, set_bit(ast_flag_string) | set_bit(ast_flag_struct));
-            ast_append(result, n);
+            mt_ast_append(result, n);
             n->string = parser_expect(par, lex_kind_ident)->string;
 
             parser_expect(par, lex_kind_open_brace);
             while (par->at->kind != lex_kind_close_brace) {
-                ast_t *mem = create_ast(par, par->at, set_bit(ast_flag_struct_member) | set_bit(ast_flag_var) | set_bit(ast_flag_string));
+                ast_t *mem = mt_create_ast(par, par->at, set_bit(ast_flag_struct_member) | set_bit(ast_flag_var) | set_bit(ast_flag_string));
-                ast_append(n, mem);
+                mt_ast_append(n, mem);
 
-                ast_t *type = parse_struct_mem(par, &mem->string);
+                ast_t *type = mt_parse_struct_mem(par, &mem->string);
-                ast_append(mem, type);
+                mt_ast_append(mem, type);
 
                 parser_expect(par, lex_kind_semicolon);
-                if (parser_match(par, lex_kind_tag)) {
+
+                if (parser_matchi(par, s8_lit("mt_tag")) && parser_expect(par, lex_kind_open_paren)) {
                     if (parser_expecti(par, s8_lit("dont_serialize"))) {
-                        mem->flags |= set_bit(ast_flag_dont_serialize);
+                        n->flags |= set_bit(ast_flag_dont_serialize);
                     }
+                    parser_expect(par, lex_kind_close_paren);
                 }
             }
             parser_expect(par, lex_kind_close_brace);
@@ -300,38 +304,3 @@ ast_t *parse_decls(ma_arena_t *arena, char *file, s8_t code) {
 
     return result;
 }
-
-ast_t *parse_table(ma_arena_t *arena, char *file, s8_t code) {
-    lex_array_t tokens = lex_tokens(arena, file, code);
-    parser_t *par = parser_make(arena, tokens.data);
-    ast_t *table = create_ast(par, par->at, 0);
-    while (par->at->kind != lex_kind_eof) {
-        ast_t *row = create_ast(par, par->at, 0);
-        ast_append(table, row);
-        while (par->at->kind != lex_kind_eof) {
-            parser_match(par, lex_kind_bit_or);
-
-            lex_t *token = par->at;
-            if (parser_match(par, lex_kind_ident) || parser_match(par, lex_kind_string)) {
-                ast_t *col = create_ast(par, par->at, set_bit(ast_flag_string));
-                ast_append(row, col);
-                col->string = token->string;
-            } else if (parser_match(par, lex_kind_integer)) {
-                ast_t *col = create_ast(par, par->at, set_bit(ast_flag_string) | set_bit(ast_flag_integer));
-                ast_append(row, col);
-                col->string = token->string;
-                col->integer = token->integer;
-            } else if (parser_match(par, lex_kind_real)) {
-                ast_t *col = create_ast(par, par->at, set_bit(ast_flag_string) | set_bit(ast_flag_real));
-                ast_append(row, col);
-                col->string = token->string;
-                col->real = token->real;
-            } else if (parser_match(par, lex_kind_bit_or) || parser_match(par, lex_kind_eof)) {
-                break;
-            } else {
-                parser_panicf(par->at, "invalid token: %S", lex_kind_to_s8(par->at->kind));
-            }
-        }
-    }
-    return table;
-}

src/meta/meta_serialize_format.c

@@ -1,8 +1,8 @@
-s8_t s8_ast_to_cvar(ma_arena_t *arena, ast_t *ast, s8_t *name) {
+fn s8_t mt_serial_ast_to_cvar(ma_arena_t *arena, ast_t *ast, s8_t *name) {
     if (ast->flags & set_bit(ast_flag_type_name)) {
         return ast->string;
     } else if (ast->flags & set_bit(ast_flag_type_pointer)) {
-        s8_t base = s8_ast_to_cvar(arena, ast->first, name);
+        s8_t base = mt_serial_ast_to_cvar(arena, ast->first, name);
         return s8_printf(arena, "%S*", base);
     } else if (ast->flags & set_bit(ast_flag_type_array)) {
         if (ast->flags & set_bit(ast_flag_integer)) {
@@ -11,7 +11,7 @@ s8_t s8_ast_to_cvar(ma_arena_t *arena, ast_t *ast, s8_t *name) {
             *name = s8_printf(arena, "%S[%d]", *name, ast->integer);
         }
 
-        s8_t base = s8_ast_to_cvar(arena, ast->first, name);
+        s8_t base = mt_serial_ast_to_cvar(arena, ast->first, name);
         return base;
     } else {
         assert(!"invalid ast_str case");
@@ -19,7 +19,7 @@ s8_t s8_ast_to_cvar(ma_arena_t *arena, ast_t *ast, s8_t *name) {
     }
 }
 
-void sb8_serial_ast(sb8_t *sb, ast_t *n) {
+fn void mt_serialb_ast(sb8_t *sb, ast_t *n) {
     if (n->flags & set_bit(ast_flag_string)) {
         sb8_stmtf(sb, "%S", n->string);
     }
@@ -28,24 +28,24 @@ void sb8_serial_ast(sb8_t *sb, ast_t *n) {
         sb8_printf(sb, "{");
         sb->indent += 1;
         for (ast_t *it = n->first; it; it = it->next) {
-            sb8_serial_ast(sb, it);
+            mt_serialb_ast(sb, it);
         }
         sb->indent -= 1;
         sb8_stmtf(sb, "}");
     }
 }
 
-s8_t s8_serial_ast(ma_arena_t *arena, ast_t *n) {
+fn s8_t mt_serial_ast(ma_arena_t *arena, ast_t *n) {
     ma_temp_t scratch = ma_begin_scratch1(arena);
     sb8_t *sb = sb8_serial_begin(scratch.arena);
-    sb8_serial_ast(sb, n);
+    mt_serialb_ast(sb, n);
     s8_t result = sb8_serial_end(arena, sb);
     ma_end_scratch(scratch);
     return result;
 }
 
-s8_t s8_serial_ast_to_code(ma_arena_t *arena, ast_t *n);
+fn s8_t mt_serial_ast_to_code(ma_arena_t *arena, ast_t *n);
-void sb8_serial_ast_to_code(sb8_t *sb, ast_t *n) {
+fn void mt_serialb_ast_to_code(sb8_t *sb, ast_t *n) {
     if (n->flags & set_bit(ast_flag_flag_enum)) {
         sb8_stmtf(sb, "typedef u32 %S;", n->string);
         sb8_stmtf(sb, "enum {");
@@ -70,7 +70,7 @@ void sb8_serial_ast_to_code(sb8_t *sb, ast_t *n) {
         sb->indent += 1;
         for (ast_t *it = n->first; it; it = it->next) {
             s8_t name = it->string;
-            s8_t type = s8_ast_to_cvar(sb->arena, it->first, &name);
+            s8_t type = mt_serial_ast_to_cvar(sb->arena, it->first, &name);
             sb8_stmtf(sb, "%S %S;", type, name);
         }
         sb->indent -= 1;
@@ -85,28 +85,28 @@ void sb8_serial_ast_to_code(sb8_t *sb, ast_t *n) {
 
         for (ast_t *it = n->first; it; it = it->next) {
             sb8_indent(sb);
-            sb8_serial_ast_to_code(sb, it);
+            mt_serialb_ast_to_code(sb, it);
         }
     }
 }
 
-s8_t s8_serial_ast_to_code(ma_arena_t *arena, ast_t *n) {
+fn s8_t mt_serial_ast_to_code(ma_arena_t *arena, ast_t *n) {
     ma_temp_t scratch = ma_begin_scratch1(arena);
     sb8_t *sb = sb8_serial_begin(scratch.arena);
-    sb8_serial_ast_to_code(sb, n);
+    mt_serialb_ast_to_code(sb, n);
     s8_t result = sb8_serial_end(arena, sb);
     ma_end_scratch(scratch);
     return result;
 }
 
-s8_t s8_serial_ast_type_to_type_info(ma_arena_t *arena, ast_t *n) {
+fn s8_t mt_serial_ast_type_to_type_info(ma_arena_t *arena, ast_t *n) {
     if (n->flags & set_bit(ast_flag_type_name)) {
         return s8_printf(arena, "type__%S", n->string);
     } else if (n->flags & set_bit(ast_flag_type_pointer)) {
-        s8_t base = s8_serial_ast_type_to_type_info(arena, n->first);
+        s8_t base = mt_serial_ast_type_to_type_info(arena, n->first);
         return s8_printf(arena, "(type_t){type_kind_pointer, s8_const_lit(\"%S\"), sizeof(void *), .base = &%S}", n->string, base);
     } else if (n->flags & set_bit(ast_flag_type_array)) {
-        s8_t base = s8_serial_ast_type_to_type_info(arena, n->first);
+        s8_t base = mt_serial_ast_type_to_type_info(arena, n->first);
         return s8_printf(arena, "(type_t){type_kind_array, s8_const_lit(\"%S\"), sizeof(%S), %d, .base = &%S}", n->string, n->string, (int)n->integer, base);
     } else {
         parser_panicf(n->pos, "expected type");
@@ -114,7 +114,7 @@ s8_t s8_serial_ast_type_to_type_info(ma_arena_t *arena, ast_t *n) {
     return (s8_t){0};
 }
 
-void sb8_serial_ast_to_type_info(sb8_t *sb, ast_t *n) {
+fn void mt_serialb_ast_to_type_info(sb8_t *sb, ast_t *n) {
     if (n->flags & set_bit(ast_flag_enum)) {
         sb8_printf(sb, "type_t type__%S = { type_kind_enum, s8_const_lit(\"%S\"), sizeof(%S),", n->string, n->string, n->string);
         sb->indent += 1;
@@ -138,7 +138,7 @@ void sb8_serial_ast_to_type_info(sb8_t *sb, ast_t *n) {
         sb->indent += 1;
         for (ast_t *it = n->first; it; it = it->next) {
             s8_t name = it->string;
-            s8_t type_info = s8_serial_ast_type_to_type_info(sb->arena, it->first);
+            s8_t type_info = mt_serial_ast_type_to_type_info(sb->arena, it->first);
             b32 dont_serialize = (it->flags & set_bit(ast_flag_dont_serialize)) ? true : false;
             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);
         }
@@ -157,78 +157,16 @@ void sb8_serial_ast_to_type_info(sb8_t *sb, ast_t *n) {
 
         for (ast_t *it = n->first; it; it = it->next) {
             sb8_indent(sb);
-            sb8_serial_ast_to_type_info(sb, it);
+            mt_serialb_ast_to_type_info(sb, it);
         }
     }
 }
 
-s8_t s8_serial_ast_to_type_info(ma_arena_t *arena, ast_t *n) {
+fn s8_t mt_serial_ast_to_type_info(ma_arena_t *arena, ast_t *n) {
     ma_temp_t scratch = ma_begin_scratch1(arena);
     sb8_t *sb = sb8_serial_begin(scratch.arena);
-    sb8_serial_ast_to_type_info(sb, n);
+    mt_serialb_ast_to_type_info(sb, n);
     s8_t result = sb8_serial_end(arena, sb);
     ma_end_scratch(scratch);
     return result;
 }
-
-//
-//
-//
-int row_findi(ast_t *row, char *name) {
-    s8_t s = s8_from_char(name);
-    int i = 0;
-    for (ast_t *col = row->first; col; col = col->next) {
-        if (s8_are_equal(col->string, s)) {
-            return i;
-        }
-        i += 1;
-    }
-    return -1;
-}
-
-ast_t *row_geti(ast_t *row, int idx) {
-    if (idx == -1) return NULL;
-
-    int i = 0;
-    for (ast_t *col = row->first; col; col = col->next, i+=1) {
-        if (i == idx) return col;
-    }
-    return false;
-}
-
-void sb8_serial_table_enum(sb8_t *c, sb8_t *h, ast_t *table, s8_t decl) {
-    int name_idx = row_findi(table->first, "name");
-    int value_idx = row_findi(table->first, "value");
-
-    s8_t name_t = s8_printf(c->arena, "%S_t", decl);
-
-    sb8_printf(h, "typedef enum {\n");
-    for (ast_t *row = table->first->next; row; row = row->next) {
-        s8_t name = row_geti(row, name_idx)->string;
-        ast_t *value = row_geti(row, value_idx);
-        sb8_printf(h, "%S_%S", decl, name);
-        if (value) sb8_printf(h, " = %S", value->string);
-        sb8_printf(h, ",\n");
-    }
-    sb8_printf(h, "%S_count,\n", decl);
-    sb8_printf(h, "} %S;\n", name_t);
-
-    sb8_stmtf(c, "type_t type__%S = { type_kind_enum, s8_const_lit(\"%S\"), sizeof(%S),", name_t, name_t, name_t);
-    c->indent += 1;
-
-    sb8_stmtf(c, ".members = (type_member_t[]){");
-    c->indent += 1;
-    int item_count = 0;
-    for (ast_t *row = table->first->next; row; row = row->next) {
-        s8_t name = row_geti(row, name_idx)->string;
-        ast_t *value = row_geti(row, value_idx);
-        sb8_stmtf(c, "{.name = s8_const_lit(\"%S_%S\"), .value = %S_%S},", decl, name, decl, name);
-        item_count += 1;
-    }
-    c->indent -= 1;
-    sb8_stmtf(c, "},");
-
-    sb8_stmtf(c, ".count = %d,", item_count);
-    c->indent -= 1;
-    sb8_stmtf(c, "};");
-}

src/meta/meta_table_format.c

@@ -0,0 +1,93 @@
+fn ast_t *mt_table_parse(ma_arena_t *arena, char *file, s8_t code) {
+    lex_array_t tokens = lex_tokens(arena, file, code);
+    parser_t *par = parser_make(arena, tokens.data);
+    ast_t *table = mt_create_ast(par, par->at, 0);
+    while (par->at->kind != lex_kind_eof) {
+        ast_t *row = mt_create_ast(par, par->at, 0);
+        mt_ast_append(table, row);
+        while (par->at->kind != lex_kind_eof) {
+            parser_match(par, lex_kind_bit_or);
+
+            lex_t *token = par->at;
+            if (parser_match(par, lex_kind_ident) || parser_match(par, lex_kind_string)) {
+                ast_t *col = mt_create_ast(par, par->at, set_bit(ast_flag_string));
+                mt_ast_append(row, col);
+                col->string = token->string;
+            } else if (parser_match(par, lex_kind_integer)) {
+                ast_t *col = mt_create_ast(par, par->at, set_bit(ast_flag_string) | set_bit(ast_flag_integer));
+                mt_ast_append(row, col);
+                col->string = token->string;
+                col->integer = token->integer;
+            } else if (parser_match(par, lex_kind_real)) {
+                ast_t *col = mt_create_ast(par, par->at, set_bit(ast_flag_string) | set_bit(ast_flag_real));
+                mt_ast_append(row, col);
+                col->string = token->string;
+                col->real = token->real;
+            } else if (parser_match(par, lex_kind_bit_or) || parser_match(par, lex_kind_eof)) {
+                break;
+            } else {
+                parser_panicf(par->at, "invalid token: %S", lex_kind_to_s8(par->at->kind));
+            }
+        }
+    }
+    return table;
+}
+
+fn int mt_table_find_rowi(ast_t *row, char *name) {
+    s8_t s = s8_from_char(name);
+    int i = 0;
+    for (ast_t *col = row->first; col; col = col->next) {
+        if (s8_are_equal(col->string, s)) {
+            return i;
+        }
+        i += 1;
+    }
+    return -1;
+}
+
+fn ast_t *mt_table_get_rowi(ast_t *row, int idx) {
+    if (idx == -1) return NULL;
+
+    int i = 0;
+    for (ast_t *col = row->first; col; col = col->next, i+=1) {
+        if (i == idx) return col;
+    }
+    return false;
+}
+
+fn void mt_table_serial(sb8_t *c, sb8_t *h, ast_t *table, s8_t decl) {
+    int name_idx = mt_table_find_rowi(table->first, "name");
+    int value_idx = mt_table_find_rowi(table->first, "value");
+
+    s8_t name_t = s8_printf(c->arena, "%S_t", decl);
+
+    sb8_printf(h, "typedef enum {\n");
+    for (ast_t *row = table->first->next; row; row = row->next) {
+        s8_t name = mt_table_get_rowi(row, name_idx)->string;
+        ast_t *value = mt_table_get_rowi(row, value_idx);
+        sb8_printf(h, "%S_%S", decl, name);
+        if (value) sb8_printf(h, " = %S", value->string);
+        sb8_printf(h, ",\n");
+    }
+    sb8_printf(h, "%S_count,\n", decl);
+    sb8_printf(h, "} %S;\n", name_t);
+
+    sb8_stmtf(c, "type_t type__%S = { type_kind_enum, s8_const_lit(\"%S\"), sizeof(%S),", name_t, name_t, name_t);
+    c->indent += 1;
+
+    sb8_stmtf(c, ".members = (type_member_t[]){");
+    c->indent += 1;
+    int item_count = 0;
+    for (ast_t *row = table->first->next; row; row = row->next) {
+        s8_t name = mt_table_get_rowi(row, name_idx)->string;
+        ast_t *value = mt_table_get_rowi(row, value_idx);
+        sb8_stmtf(c, "{.name = s8_const_lit(\"%S_%S\"), .value = %S_%S},", decl, name, decl, name);
+        item_count += 1;
+    }
+    c->indent -= 1;
+    sb8_stmtf(c, "},");
+
+    sb8_stmtf(c, ".count = %d,", item_count);
+    c->indent -= 1;
+    sb8_stmtf(c, "};");
+}

src/ui/ui.meta.c

@@ -1,6 +1,6 @@
 void mt_ui(ma_arena_t *arena) {
-    typedef struct cg_ui_stacks_t cg_ui_stacks_t;
+    typedef struct mt_ui_stacks_t mt_ui_stacks_t;
-    struct cg_ui_stacks_t {
+    struct mt_ui_stacks_t {
         s8_t type;
         s8_t name;
         b32 skip_box_member;
@@ -9,7 +9,7 @@ void mt_ui(ma_arena_t *arena) {
         s8_t node;
     };
 
-    cg_ui_stacks_t stacks[] = {
+    mt_ui_stacks_t stacks[] = {
         {s8_lit("ui_id_t")         , s8_lit("id")                , .skip_box_member = true} ,
         {s8_lit("ui_lop_t")        , s8_lit("lop")               , .skip_box_member = true} ,
         {s8_lit("f32")             , s8_lit("border_thickness")} ,
@@ -22,7 +22,7 @@ void mt_ui(ma_arena_t *arena) {
 
     ///////////////////////////////
     // fill stack and node
-    for (cg_ui_stacks_t *it = stacks; it < stacks + lengthof(stacks); it += 1) {
+    for (mt_ui_stacks_t *it = stacks; it < stacks + lengthof(stacks); it += 1) {
         s8_t core_type = it->type;
         if (s8_ends_with(core_type, s8_lit("_t"), false)) core_type = s8_chop(core_type, 2);
         it->stack = s8_printf(arena, "%S_stack", it->name);
@@ -35,8 +35,8 @@ void mt_ui(ma_arena_t *arena) {
 
     ///////////////////////////////
     // generate types
-    for (cg_ui_stacks_t *it = stacks; it < stacks + lengthof(stacks); it += 1) {
+    for (mt_ui_stacks_t *it = stacks; it < stacks + lengthof(stacks); it += 1) {
-        for (cg_ui_stacks_t *jt = it - 1; jt >= stacks; jt -= 1) if (s8_are_equal(it->type, jt->type)) goto type_already_gened;
+        for (mt_ui_stacks_t *jt = it - 1; jt >= stacks; jt -= 1) if (s8_are_equal(it->type, jt->type)) goto type_already_gened;
         sb8_stmtf(h_sb, "typedef struct %S %S; struct %S { %S value; %S *next; };", it->node, it->node, it->node, it->type, it->node);
     type_already_gened:;
     }
@@ -45,33 +45,34 @@ void mt_ui(ma_arena_t *arena) {
     ///////////////////////////////
     // generate field embeds
     sb8_stmtf(h_sb, "#define UI_DECL_BOX_MEMBERS \\");
-    for (cg_ui_stacks_t *it = stacks; it < stacks + lengthof(stacks); it += 1) {
+    for (mt_ui_stacks_t *it = stacks; it < stacks + lengthof(stacks); it += 1) {
         if (it->skip_box_member) continue;
         sb8_stmtf(h_sb, "%S %S;\\", it->type, it->name);
     }
     sb8_printf(h_sb, "\n");
 
     sb8_stmtf(h_sb, "#define UI_DECL_STACKS \\");
-    for (cg_ui_stacks_t *it = stacks; it < stacks + lengthof(stacks); it += 1) {
+    for (mt_ui_stacks_t *it = stacks; it < stacks + lengthof(stacks); it += 1) {
         sb8_stmtf(h_sb, "%S *%S;\\", it->node, it->stack);
     }
     sb8_printf(h_sb, "\n");
 
     ///////////////////////////////
     // generate stack functions
-    for (cg_ui_stacks_t *it = stacks; it < stacks + lengthof(stacks); it += 1) {
+    for (mt_ui_stacks_t *it = stacks; it < stacks + lengthof(stacks); it += 1) {
         sb8_stmtf(c_sb, "fn void ui_push_%S(%S v) { %S *n = ma_push_type(tcx.temp, %S); n->value = v; SLLS_PUSH(ui->%S, n); }", it->name, it->type, it->node, it->node, it->stack);
         sb8_stmtf(c_sb, "fn void ui_pop_%S(void) { SLLS_POP(ui->%S); }", it->name, it->stack);
         sb8_stmtf(c_sb, "#define ui_set_%S(x) defer_block(ui_push_%S(x), ui_pop_%S())", it->name, it->name, it->name);
     }
 
     sb8_stmtf(c_sb, "fn void ui_assert_stacks_are_null(void) {");
-    for (cg_ui_stacks_t *it = stacks; it < stacks + lengthof(stacks); it += 1) {
+    for (mt_ui_stacks_t *it = stacks; it < stacks + lengthof(stacks); it += 1) {
         sb8_stmtf(c_sb, "assert(ui->%S == NULL);", it->stack);
     }
     sb8_stmtf(c_sb, "}");
 
-
+    ///////////////////////////////
-    os_write_file(cg_cpath(arena), sb8_serial_end(arena, c_sb));
+    // write to disk
-    os_write_file(cg_hpath(arena), sb8_serial_end(arena, h_sb));
+    os_write_file(mt_cpath(arena), sb8_serial_end(arena, c_sb));
+    os_write_file(mt_hpath(arena), sb8_serial_end(arena, h_sb));
 }

src/wasm_app/wasm_app.meta.c

@@ -10,13 +10,13 @@ struct cg_tweak_t {
 void mt_wasm_app(ma_arena_t *arena) {
     sb8_t *include_paths = sb8(arena);
     sb8_append(include_paths, OS_GetAbsolutePath(&Perm, s8_lit("../src")));
-    cg_files_t files = cg_lex_files(arena, s8_lit("../src/wasm_app/main.c"), include_paths);
+    mt_files_t files = mt_lex_files(arena, s8_lit("../src/wasm_app/main.c"), include_paths);
 
     cg_tweak_t *first_tweak = NULL;
     cg_tweak_t *last_tweak  = NULL;
 
     sb8_t *sb_embeds = sb8_serial_begin(arena);
-    for (cg_file_t *it = files.first; it; it = it->next) {
+    for (mt_file_t *it = files.first; it; it = it->next) {
         parser_t *par = parser_make(arena, it->tokens.data);
         for (;par->at->kind != lex_kind_eof;) {
             b32 matched = false;
@@ -31,7 +31,7 @@ void mt_wasm_app(ma_arena_t *arena) {
                 s8_t content = OS_ReadFile(&Perm, relpath);
 
                 sb8_printf(sb_embeds, "gb_read_only ");
-                cg_byte_array_from_data_ex(sb_embeds, content, s8_printf(arena, "%S_data", var_name->string));
+                mt_serial_to_cbyte_array_ex(sb_embeds, content, s8_printf(arena, "%S_data", var_name->string));
                 sb8_printf(sb_embeds, "gb_read_only s8_t %S = s8_array_lit(%S_data);\n", var_name->string, var_name->string);
                 matched = true;
             }
@@ -98,5 +98,5 @@ void mt_wasm_app(ma_arena_t *arena) {
 
 
     s8_t embeds = sb8_serial_end(arena, sb_embeds);
-    os_write_file(cg_cpath(arena), embeds);
+    os_write_file(mt_cpath(arena), embeds);
 }

todo.txt

@@ -27,8 +27,8 @@
         [x] somehow index properly the meta files and ignore generated files
             [x] extract declarations from c files meta(introspect)
             [x] tweak variables and embeds declared in c code
-        [ ] new simple format with tags
+        [x] replace @tags with mt_tag(dont_serialize)
     [x] revisit api
     [ ] s8_bin
-    [ ] hash table
+    [x] hash table
-    [ ] intern table
+    [x] intern table