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

meta refactorings

Browse Source
This commit is contained in:
Krzosa Karol
2025-01-20 11:00:33 +01:00
parent 6f53fa4db0
commit f221ccfcf9
10 changed files with 268 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
build_file.c
View File

@@ -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/serialize.c"
#include "src/meta/cgen.c"
#include "src/meta/meta_format.c"
#include "src/meta/meta_serialize_format.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");

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

@@ -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 js1_idx = row_findi(keys->first, "js1");
i32 js2_idx = row_findi(keys->first, "js2");
i32 filter_out_idx = row_findi(keys->first, "jf");
i32 name_idx = mt_table_find_rowi(keys->first, "name");
i32 js1_idx = mt_table_find_rowi(keys->first, "js1");
i32 js2_idx = mt_table_find_rowi(keys->first, "js2");
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;
i64 filter_out = row_geti(row, filter_out_idx)->integer;
s8_t name = mt_table_get_rowi(row, name_idx)->string;
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 w1i = row_findi(keys->first, "windows1");
i32 w2i = row_findi(keys->first, "windows2");
i32 name_idx = mt_table_find_rowi(keys->first, "name");
i32 w1i = mt_table_find_rowi(keys->first, "windows1");
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 w[] = {row_geti(row, w1i)->string, row_geti(row, w2i)->string};
s8_t name = mt_table_get_rowi(row, name_idx)->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);
sb8_serial_ast_to_type_info(c, decls);
mt_serialb_ast_to_code(h, decls);
mt_serialb_ast_to_type_info(c, decls);
}
os_write_file(cg_cpath(arena), sb8_serial_end(arena, c));
os_write_file(cg_hpath(arena), sb8_serial_end(arena, h));
os_write_file(mt_cpath(arena), sb8_serial_end(arena, c));
os_write_file(mt_hpath(arena), sb8_serial_end(arena, h));
}

26
src/core/core_hash_table.h
View File

@@ -32,19 +32,19 @@ struct ht_t {
ht_bucket_t *buckets;
};
fn ht_t *ht_create(ma_arena_t *arena, i32 size);
fn ht_node_t *ht_insert_kv(ht_t *ht, u64 hash, ht_key_value_t kv);
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_t *ht_create (ma_arena_t *arena, i32 size);
fn ht_node_t *ht_insert_kv (ht_t *ht, u64 hash, ht_key_value_t kv);
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 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

56
src/meta/cgen.c → src/meta/meta_cfiles.c
View File

@@ -1,18 +1,18 @@
typedef struct cg_file_t cg_file_t;
struct cg_file_t {
cg_file_t *next;
typedef struct mt_file_t mt_file_t;
struct mt_file_t {
mt_file_t *next;
s8_t path;
s8_t content;
lex_array_t tokens;
};
typedef struct cg_files_t cg_files_t;
struct cg_files_t {
cg_file_t *first;
cg_file_t *last;
typedef struct mt_files_t mt_files_t;
struct mt_files_t {
mt_file_t *first;
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) {
for (cg_file_t *it = root->first; it; it = it->next) {
fn mt_file_t *mt_find_file_exact(mt_files_t *root, s8_t path) {
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) {
for (cg_file_t *it = root->first; it; it = it->next) {
fn mt_file_t *mt_find_file(mt_files_t *root, s8_t name) {
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);
if (inc_path.len && cg_find_file_exact(root, inc_path) == NULL) {
s8_t inc_path = mt_resolve_path(arena, include_paths, token->string, s8_from_char(token->file), token->system_include);
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) {
cg_files_t files = {0};
fn mt_files_t mt_lex_files(ma_arena_t *arena, s8_t path, sb8_t *include_paths) {
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 cg_hpath(arena) cg_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) {
#define mt_cpath(arena) mt_gen_filename(arena, s8_lit(__FILE__), s8_lit("c"))
#define mt_hpath(arena) mt_gen_filename(arena, s8_lit(__FILE__), s8_lit("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);
return file;

159
src/meta/parser.c → src/meta/meta_format.c
View File

@@ -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) {
ast_t *result = create_ast(par, pos, set_bit(ast_flag_string) | set_bit(ast_flag_binary) | set_bit(ast_flag_integer));
ast_append(result, left);
ast_append(result, 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 = mt_create_ast(par, pos, set_bit(ast_flag_string) | set_bit(ast_flag_binary) | set_bit(ast_flag_integer));
mt_ast_append(result, left);
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);
ast_t *parse_lit_expr(parser_t *par) {
fn ast_t *mt_parse_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) {
ast_t *left = parse_lit_expr(par);
fn ast_t *mt_parse_mul_expr(parser_t *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) {
ast_t *left = parse_mul_expr(par);
fn ast_t *mt_parse_add_expr(parser_t *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) {
ast_t *left = parse_add_expr(par);
fn ast_t *mt_parse_logical_and_expr(parser_t *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) {
ast_t *left = parse_logical_and_expr(par);
fn ast_t *parse_logical_or_expr(parser_t *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 right = eval_const_expr(expr->last);
i64 left = mt_eval_const_expr(expr->first);
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_append(pointer, type);
ast_t *pointer = mt_create_ast(par, par->at, set_bit(ast_flag_type_pointer) | set_bit(ast_flag_string));
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_append(array, type);
ast_t *array = mt_create_ast(par, par->at, set_bit(ast_flag_type_array) | set_bit(ast_flag_string));
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_append(result, n);
ast_t *n = mt_create_ast(par, pos, set_bit(ast_flag_string) | set_bit(ast_flag_enum));
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_append(result, n);
ast_t *n = mt_create_ast(par, 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;
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_append(n, mem);
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));
mt_ast_append(n, mem);
ast_t *type = parse_struct_mem(par, &mem->string);
ast_append(mem, type);
ast_t *type = mt_parse_struct_mem(par, &mem->string);
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;
}

104
src/meta/serialize.c → src/meta/meta_serialize_format.c
View File

@@ -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);
void sb8_serial_ast_to_code(sb8_t *sb, ast_t *n) {
fn s8_t mt_serial_ast_to_code(ma_arena_t *arena, 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, "};");
}

93
src/meta/meta_table_format.c Normal file
View File

@@ -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, "};");
}

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

@@ -1,6 +1,6 @@
void mt_ui(ma_arena_t *arena) {
typedef struct cg_ui_stacks_t cg_ui_stacks_t;
struct cg_ui_stacks_t {
typedef struct mt_ui_stacks_t mt_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 (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 *it = stacks; it < stacks + lengthof(stacks); it += 1) {
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));
os_write_file(cg_hpath(arena), sb8_serial_end(arena, h_sb));
///////////////////////////////
// write to disk
os_write_file(mt_cpath(arena), sb8_serial_end(arena, c_sb));
os_write_file(mt_hpath(arena), sb8_serial_end(arena, h_sb));
}

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

@@ -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);
}

6
todo.txt
View File

@@ -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
[ ] intern table
[x] hash table
[x] intern table