ed/metadesk
1
0
Fork 0
mirror of https://github.com/Ed94/metadesk.git synced 2026-08-30 04:50:07 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
1d0045b7599b39b6bfd58bff8874caf13be3ca9e
metadesk/metagen/metagen_main.c
T

657 lines
26 KiB
C
Raw Blame History

// Copyright (c) 2024 Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: Build Options
#define BUILD_CONSOLE_INTERFACE 1
////////////////////////////////
//~ rjf: Includes
//- rjf: headers
#include "metagen/metagen_base/metagen_base_inc.h"
#include "metagen/metagen_os/metagen_os_inc.h"
#include "mdesk/mdesk.h"
#include "metagen.h"
//- rjf: impls
#include "metagen/metagen_base/metagen_base_inc.c"
#include "metagen/metagen_os/metagen_os_inc.c"
#include "mdesk/mdesk.c"
#include "metagen.c"
////////////////////////////////
//~ rjf: Entry Point
internal void
entry_point(CmdLine *cmdline)
{
//////////////////////////////
//- rjf: set up state
//
MG_MsgList msgs = {0};
mg_arena = arena_alloc(.reserve_size = GB(64), .commit_size = MB(64));
mg_state = push_array(mg_arena, MG_State, 1);
mg_state->slots_count = 256;
mg_state->slots = push_array(mg_arena, MG_LayerSlot, mg_state->slots_count);
//////////////////////////////
//- rjf: extract paths
//
String8 build_dir_path = os_get_process_info()->binary_path;
String8 project_dir_path = str8_chop_last_slash(build_dir_path);
String8 code_dir_path = push_str8f(mg_arena, "%S/src", project_dir_path);
//////////////////////////////
//- rjf: search code directories for all files to consider
//
String8List file_paths = {0};
DeferLoop(printf("searching %.*s...", str8_varg(code_dir_path)), printf(" %i files found\n", (int)file_paths.node_count))
{
typedef struct Task Task;
struct Task
{
Task *next;
String8 path;
};
Task start_task = {0, code_dir_path};
Task *first_task = &start_task;
Task *last_task = &start_task;
for(Task *task = first_task; task != 0; task = task->next)
{
OS_FileIter *it = os_file_iter_begin(mg_arena, task->path, 0);
for(OS_FileInfo info = {0}; os_file_iter_next(mg_arena, it, &info);)
{
String8 file_path = push_str8f(mg_arena, "%S/%S", task->path, info.name);
if(info.props.flags & FilePropertyFlag_IsFolder)
{
Task *next_task = push_array(mg_arena, Task, 1);
SLLQueuePush(first_task, last_task, next_task);
next_task->path = file_path;
}
else
{
str8_list_push(mg_arena, &file_paths, file_path);
}
}
os_file_iter_end(it);
}
}
//////////////////////////////
//- rjf: parse all metadesk files
//
MG_FileParseList parses = {0};
DeferLoop(printf("parsing metadesk..."), printf(" %i metadesk files parsed\n", (int)parses.count))
{
for(String8Node *n = file_paths.first; n != 0; n = n->next)
{
String8 file_path = n->string;
String8 file_ext = str8_skip_last_dot(file_path);
if(str8_match(file_ext, str8_lit("mdesk"), 0))
{
String8 data = os_data_from_file_path(mg_arena, file_path);
MD_TokenizeResult tokenize = md_tokenize_from_text(mg_arena, data);
MD_ParseResult parse = md_parse_from_text_tokens(mg_arena, file_path, data, tokenize.tokens);
for(MD_Msg *m = parse.msgs.first; m != 0; m = m->next)
{
TxtPt pt = mg_txt_pt_from_string_off(data, m->node->src_offset);
String8 msg_kind_string = {0};
switch(m->kind)
{
default:{}break;
case MD_MsgKind_Note: {msg_kind_string = str8_lit("note");}break;
case MD_MsgKind_Warning: {msg_kind_string = str8_lit("warning");}break;
case MD_MsgKind_Error: {msg_kind_string = str8_lit("error");}break;
case MD_MsgKind_FatalError: {msg_kind_string = str8_lit("fatal error");}break;
}
String8 location = push_str8f(mg_arena, "%S:%I64d:%I64d", file_path, pt.line, pt.column);
MG_Msg dst_m = {location, msg_kind_string, m->string};
mg_msg_list_push(mg_arena, &msgs, &dst_m);
}
MG_FileParseNode *parse_n = push_array(mg_arena, MG_FileParseNode, 1);
SLLQueuePush(parses.first, parses.last, parse_n);
parse_n->v.root = parse.root;
parses.count += 1;
}
}
}
//////////////////////////////
//- rjf: gather tables
//
MG_Map table_grid_map = mg_push_map(mg_arena, 1024);
MG_Map table_col_map = mg_push_map(mg_arena, 1024);
U64 table_count = 0;
DeferLoop(printf("gathering tables..."), printf(" %i tables found\n", (int)table_count))
{
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{
MD_Node *file = n->v.root;
for MD_EachNode(node, file->first)
{
MD_Node *table_tag = md_tag_from_string(node, str8_lit("table"), 0);
if(!md_node_is_nil(table_tag))
{
MG_NodeGrid *table = push_array(mg_arena, MG_NodeGrid, 1);
MG_ColumnDescArray *col_descs = push_array(mg_arena, MG_ColumnDescArray, 1);
*table = mg_node_grid_make_from_node(mg_arena, node);
*col_descs = mg_column_desc_array_from_tag(mg_arena, table_tag);
mg_map_insert_ptr(mg_arena, &table_grid_map, node->string, table);
mg_map_insert_ptr(mg_arena, &table_col_map, node->string, col_descs);
table_count += 1;
}
}
}
}
//////////////////////////////
//- rjf: gather layer options
//
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{
MD_Node *file = n->v.root;
String8 layer_key = mg_layer_key_from_path(file->string);
MG_Layer *layer = mg_layer_from_key(layer_key);
for MD_EachNode(node, file->first)
{
if(md_node_has_tag(node, str8_lit("option"), 0))
{
if(str8_match(node->string, str8_lit("library"), 0))
{
layer->is_library = 1;
}
}
if(md_node_has_tag(node, str8_lit("gen_folder"), 0))
{
layer->gen_folder_name = node->string;
}
if(md_node_has_tag(node, str8_lit("h_name"), 0))
{
layer->h_name_override = node->string;
}
if(md_node_has_tag(node, str8_lit("c_name"), 0))
{
layer->c_name_override = node->string;
}
if(md_node_has_tag(node, str8_lit("h_header"), 0))
{
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
{
str8_list_push(mg_arena, &layer->h_header, n->string);
str8_list_push(mg_arena, &layer->h_header, str8_lit("\n"));
}
}
if(md_node_has_tag(node, str8_lit("h_footer"), 0))
{
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
{
str8_list_push(mg_arena, &layer->h_footer, n->string);
str8_list_push(mg_arena, &layer->h_footer, str8_lit("\n"));
}
}
if(md_node_has_tag(node, str8_lit("c_header"), 0))
{
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
{
str8_list_push(mg_arena, &layer->c_header, n->string);
str8_list_push(mg_arena, &layer->c_header, str8_lit("\n"));
}
}
if(md_node_has_tag(node, str8_lit("c_footer"), 0))
{
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
{
str8_list_push(mg_arena, &layer->c_footer, n->string);
str8_list_push(mg_arena, &layer->c_footer, str8_lit("\n"));
}
}
}
}
//////////////////////////////
//- rjf: generate enums
//
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{
MD_Node *file = n->v.root;
for MD_EachNode(node, file->first)
{
MD_Node *tag = md_tag_from_string(node, str8_lit("enum"), 0);
if(!md_node_is_nil(tag))
{
String8 enum_name = node->string;
String8 enum_member_prefix = enum_name;
if(str8_match(str8_postfix(enum_name, 5), str8_lit("Flags"), 0))
{
enum_member_prefix = str8_chop(enum_name, 1);
}
String8 enum_base_type_name = tag->first->string;
String8 layer_key = mg_layer_key_from_path(file->string);
MG_Layer *layer = mg_layer_from_key(layer_key);
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
if(enum_base_type_name.size == 0)
{
str8_list_pushf(mg_arena, &layer->enums, "typedef enum %S\n{\n", enum_name);
}
else
{
str8_list_pushf(mg_arena, &layer->enums, "typedef %S %S;\n", enum_base_type_name, enum_name);
str8_list_pushf(mg_arena, &layer->enums, "typedef enum %SEnum\n{\n", enum_name);
}
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
{
String8 escaped = mg_escaped_from_str8(mg_arena, n->string);
str8_list_pushf(mg_arena, &layer->enums, "%S_%S,\n", enum_member_prefix, escaped);
}
if(enum_base_type_name.size == 0)
{
str8_list_pushf(mg_arena, &layer->enums, "} %S;\n\n", enum_name);
}
else
{
str8_list_pushf(mg_arena, &layer->enums, "} %SEnum;\n\n", enum_name);
}
}
}
}
//////////////////////////////
//- rjf: generate xlists
//
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{
MD_Node *file = n->v.root;
for MD_EachNode(node, file->first)
{
MD_Node *tag = md_tag_from_string(node, str8_lit("xlist"), 0);
if(!md_node_is_nil(tag))
{
String8 layer_key = mg_layer_key_from_path(file->string);
MG_Layer *layer = mg_layer_from_key(layer_key);
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
str8_list_pushf(mg_arena, &layer->enums, "#define %S \\\n", node->string);
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
{
String8 escaped = mg_escaped_from_str8(mg_arena, n->string);
str8_list_pushf(mg_arena, &layer->enums, "X(%S)\\\n", escaped);
}
str8_list_push(mg_arena, &layer->enums, str8_lit("\n"));
}
}
}
//////////////////////////////
//- rjf: generate structs
//
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{
MD_Node *file = n->v.root;
for MD_EachNode(node, file->first)
{
if(md_node_has_tag(node, str8_lit("struct"), 0))
{
String8 layer_key = mg_layer_key_from_path(file->string);
MG_Layer *layer = mg_layer_from_key(layer_key);
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
str8_list_pushf(mg_arena, &layer->structs, "typedef struct %S %S;\n", node->string, node->string);
str8_list_pushf(mg_arena, &layer->structs, "struct %S\n{\n", node->string);
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
{
String8 escaped = mg_escaped_from_str8(mg_arena, n->string);
str8_list_pushf(mg_arena, &layer->structs, "%S;\n", escaped);
}
str8_list_pushf(mg_arena, &layer->structs, "};\n\n");
}
}
}
//////////////////////////////
//- rjf: generate data tables
//
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{
MD_Node *file = n->v.root;
for MD_EachNode(node, file->first)
{
MD_Node *tag = md_tag_from_string(node, str8_lit("data"), 0);
if(!md_node_is_nil(tag))
{
String8 element_type = tag->first->string;
String8 layer_key = mg_layer_key_from_path(file->string);
MG_Layer *layer = mg_layer_from_key(layer_key);
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
if(!md_node_has_tag(node, str8_lit("c_file"), 0))
{
str8_list_pushf(mg_arena, &layer->h_tables, "extern %S %S[%I64u];\n", element_type, node->string, gen_strings.node_count);
}
str8_list_pushf(mg_arena, &layer->c_tables, "%S %S[%I64u] =\n{\n", element_type, node->string, gen_strings.node_count);
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
{
String8 escaped = mg_escaped_from_str8(mg_arena, n->string);
str8_list_pushf(mg_arena, &layer->c_tables, "%S,\n", escaped);
}
str8_list_push(mg_arena, &layer->c_tables, str8_lit("};\n\n"));
}
}
}
//////////////////////////////
//- rjf: generate enum -> string mapping functions
//
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{
MD_Node *file = n->v.root;
for MD_EachNode(node, file->first)
{
MD_Node *tag = md_tag_from_string(node, str8_lit("enum2string_switch"), 0);
if(!md_node_is_nil(tag))
{
String8 enum_type = tag->first->string;
String8 layer_key = mg_layer_key_from_path(file->string);
MG_Layer *layer = mg_layer_from_key(layer_key);
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
str8_list_pushf(mg_arena, &layer->h_functions, "internal String8 %S(%S v);\n", node->string, enum_type);
str8_list_pushf(mg_arena, &layer->c_functions, "internal String8\n%S(%S v)\n{\n", node->string, enum_type);
str8_list_pushf(mg_arena, &layer->c_functions, "String8 result = str8_lit(\"<Unknown %S>\");\n", enum_type);
str8_list_pushf(mg_arena, &layer->c_functions, "switch(v)\n");
str8_list_pushf(mg_arena, &layer->c_functions, "{\n");
str8_list_pushf(mg_arena, &layer->c_functions, "default:{}break;\n");
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
{
String8 escaped = mg_escaped_from_str8(mg_arena, n->string);
str8_list_pushf(mg_arena, &layer->c_functions, "%S;\n", escaped);
}
str8_list_pushf(mg_arena, &layer->c_functions, "}\n");
str8_list_pushf(mg_arena, &layer->c_functions, "return result;\n");
str8_list_pushf(mg_arena, &layer->c_functions, "}\n\n");
}
}
}
//////////////////////////////
//- rjf: generate catch-all generations
//
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{
MD_Node *file = n->v.root;
for MD_EachNode(node, file->first)
{
MD_Node *tag = md_tag_from_string(node, str8_lit("gen"), 0);
if(!md_node_is_nil(tag))
{
String8 layer_key = mg_layer_key_from_path(file->string);
MG_Layer *layer = mg_layer_from_key(layer_key);
B32 prefer_c_file = md_node_has_tag(node, str8_lit("c_file"), 0);
String8List *out = prefer_c_file ? &layer->c_catchall : &layer->h_catchall;
if(tag->first->string.size == 0){}
else if(str8_match(tag->first->string, str8_lit("enums"), 0)) { out = &layer->enums; }
else if(str8_match(tag->first->string, str8_lit("structs"), 0)) { out = &layer->structs; }
else if(str8_match(tag->first->string, str8_lit("functions"), 0)) { out = prefer_c_file ? &layer->c_functions : &layer->h_functions; }
else if(str8_match(tag->first->string, str8_lit("tables"), 0)) { out = prefer_c_file ? &layer->c_tables : &layer->h_tables; }
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), node);
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
{
String8 trimmed = str8_skip_chop_whitespace(n->string);
String8 escaped = mg_escaped_from_str8(mg_arena, trimmed);
str8_list_push(mg_arena, out, escaped);
str8_list_push(mg_arena, out, str8_lit("\n"));
}
}
}
}
//////////////////////////////
//- rjf: gather & generate all embeds
//
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{
MD_Node *file = n->v.root;
for MD_EachNode(node, file->first)
{
if(md_node_has_tag(node, str8_lit("embed_string"), 0))
{
String8 layer_key = mg_layer_key_from_path(file->string);
MG_Layer *layer = mg_layer_from_key(layer_key);
String8 embed_string = mg_c_string_literal_from_multiline_string(node->first->string);
str8_list_pushf(mg_arena, &layer->h_tables, "read_only global String8 %S =\nstr8_lit_comp(\n", node->string);
str8_list_push (mg_arena, &layer->h_tables, embed_string);
str8_list_pushf(mg_arena, &layer->h_tables, ");\n\n");
}
if(md_node_has_tag(node, str8_lit("embed_file"), 0))
{
String8 layer_key = mg_layer_key_from_path(file->string);
MG_Layer *layer = mg_layer_from_key(layer_key);
String8 data = os_data_from_file_path(mg_arena, node->first->string);
String8 embed_string = mg_c_array_literal_contents_from_data(data);
str8_list_pushf(mg_arena, &layer->h_tables, "read_only global U8 %S__data[] =\n{\n", node->string);
str8_list_push (mg_arena, &layer->h_tables, embed_string);
str8_list_pushf(mg_arena, &layer->h_tables, "};\n\n");
str8_list_pushf(mg_arena, &layer->h_tables, "read_only global String8 %S = {%S__data, sizeof(%S__data)};\n",
node->string,
node->string,
node->string);
}
}
}
//////////////////////////////
//- rjf: generate all markdown in build folder
//
for(MG_FileParseNode *n = parses.first; n != 0; n = n->next)
{
MD_Node *file = n->v.root;
for MD_EachNode(node, file->first)
{
//- rjf: generate markdown page
if(md_node_has_tag(node, str8_lit("markdown"), 0))
{
String8List md_strs = {0};
for(MD_Node *piece = node->first; !md_node_is_nil(piece); piece = piece->next)
{
if(md_node_has_tag(piece, str8_lit("title"), 0))
{
str8_list_pushf(mg_arena, &md_strs, "# %S\n\n", piece->string);
}
if(md_node_has_tag(piece, str8_lit("subtitle"), 0))
{
str8_list_pushf(mg_arena, &md_strs, "## %S\n\n", piece->string);
}
if(md_node_has_tag(piece, str8_lit("p"), 0))
{
String8 paragraph_text = piece->string;
String8List paragraph_lines = mg_wrapped_lines_from_string(mg_arena, paragraph_text, 80, 80, 0);
for(String8Node *n = paragraph_lines.first; n != 0; n = n->next)
{
str8_list_push(mg_arena, &md_strs, n->string);
str8_list_push(mg_arena, &md_strs, str8_lit("\n"));
}
str8_list_push(mg_arena, &md_strs, str8_lit("\n"));
}
if(md_node_has_tag(piece, str8_lit("unordered_list"), 0))
{
String8List gen_strings = mg_string_list_from_table_gen(mg_arena, table_grid_map, table_col_map, str8_lit(""), piece);
for(String8Node *n = gen_strings.first; n != 0; n = n->next)
{
str8_list_pushf(mg_arena, &md_strs, " - ");
String8 item_text = n->string;
String8List item_lines = mg_wrapped_lines_from_string(mg_arena, item_text, 80-3, 80, 3);
for(String8Node *line_n = item_lines.first; line_n != 0; line_n = line_n->next)
{
str8_list_push(mg_arena, &md_strs, line_n->string);
str8_list_pushf(mg_arena, &md_strs, "\n");
}
}
str8_list_pushf(mg_arena, &md_strs, "\n");
}
}
String8 output_path = push_str8f(mg_arena, "%S/%S.md", build_dir_path, node->string);
FILE *file = fopen((char *)output_path.str, "w");
for(String8Node *n = md_strs.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, file);
}
fclose(file);
}
}
}
//////////////////////////////
//- rjf: write all layer output files
//
DeferLoop(printf("generating layer code..."), printf("\n"))
{
for(U64 slot_idx = 0; slot_idx < mg_state->slots_count; slot_idx += 1)
{
MG_LayerSlot *slot = &mg_state->slots[slot_idx];
for(MG_LayerNode *n = slot->first; n != 0; n = n->next)
{
MG_Layer *layer = &n->v;
String8 layer_generated_folder = {0};
if(layer->gen_folder_name.size != 0)
{
String8 gen_folder = layer->gen_folder_name;
layer_generated_folder = push_str8f(mg_arena, "%S/%S", code_dir_path, gen_folder);
}
else
{
String8 gen_folder = str8_lit("generated");
layer_generated_folder = push_str8f(mg_arena, "%S/%S/%S", code_dir_path, layer->key, gen_folder);
}
if(os_make_directory(layer_generated_folder))
{
String8List layer_key_parts = str8_split_path(mg_arena, layer->key);
StringJoin join = {0};
join.sep = str8_lit("_");
String8 layer_key_filename = str8_list_join(mg_arena, &layer_key_parts, &join);
String8 layer_key_filename_upper = upper_from_str8(mg_arena, layer_key_filename);
String8 h_path = push_str8f(mg_arena, "%S/%S.meta.h", layer_generated_folder, layer_key_filename);
String8 c_path = push_str8f(mg_arena, "%S/%S.meta.c", layer_generated_folder, layer_key_filename);
if(layer->h_name_override.size != 0)
{
h_path = push_str8f(mg_arena, "%S/%S", layer_generated_folder, str8_skip_last_slash(layer->h_name_override));
}
if(layer->c_name_override.size != 0)
{
c_path = push_str8f(mg_arena, "%S/%S", layer_generated_folder, str8_skip_last_slash(layer->c_name_override));
}
{
FILE *h = fopen((char *)h_path.str, "w");
fprintf(h, "// Copyright (c) 2024 Epic Games Tools\n");
fprintf(h, "// Licensed under the MIT license (https://opensource.org/license/mit/)\n\n");
if(layer->h_header.first == 0)
{
fprintf(h, "//- GENERATED CODE\n\n");
fprintf(h, "#ifndef %.*s_META_H\n", str8_varg(layer_key_filename_upper));
fprintf(h, "#define %.*s_META_H\n\n", str8_varg(layer_key_filename_upper));
}
else for(String8Node *n = layer->h_header.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, h);
}
for(String8Node *n = layer->enums.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, h);
}
for(String8Node *n = layer->structs.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, h);
}
for(String8Node *n = layer->h_catchall.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, h);
}
for(String8Node *n = layer->h_functions.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, h);
}
if(layer->h_tables.first != 0)
{
if(!layer->is_library)
{
fprintf(h, "C_LINKAGE_BEGIN\n");
}
for(String8Node *n = layer->h_tables.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, h);
}
fprintf(h, "\n");
if(!layer->is_library)
{
fprintf(h, "C_LINKAGE_END\n\n");
}
}
if(layer->h_footer.first == 0)
{
fprintf(h, "#endif // %.*s_META_H\n", str8_varg(layer_key_filename_upper));
}
else for(String8Node *n = layer->h_footer.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, h);
}
fclose(h);
}
{
FILE *c = fopen((char *)c_path.str, "w");
fprintf(c, "// Copyright (c) 2024 Epic Games Tools\n");
fprintf(c, "// Licensed under the MIT license (https://opensource.org/license/mit/)\n\n");
if(layer->c_header.first == 0)
{
fprintf(c, "//- GENERATED CODE\n\n");
}
else for(String8Node *n = layer->c_header.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, c);
}
for(String8Node *n = layer->c_catchall.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, c);
}
if(layer->c_tables.first != 0)
{
if(!layer->is_library)
{
fprintf(c, "C_LINKAGE_BEGIN\n");
}
for(String8Node *n = layer->c_tables.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, c);
}
if(!layer->is_library)
{
fprintf(c, "C_LINKAGE_END\n\n");
}
}
for(String8Node *n = layer->c_functions.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, c);
}
if(layer->c_footer.first != 0)
{
for(String8Node *n = layer->c_footer.first; n != 0; n = n->next)
{
fwrite(n->string.str, n->string.size, 1, c);
}
}
fclose(c);
}
}
}
}
}
//////////////////////////////
//- rjf: write out all messages to stderr
//
for(MG_MsgNode *n = msgs.first; n != 0; n = n->next)
{
MG_Msg *msg = &n->v;
fprintf(stderr, "%.*s: %.*s: %.*s\n", str8_varg(msg->location), str8_varg(msg->kind), str8_varg(msg->msg));
}
}
Reference in New Issue View Git Blame Copy Permalink