doylet
/
Dqn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Dqn/dqn_cgen.cpp

967 lines
56 KiB
C++
Raw Permalink Blame History

////////////////////////////////////////////////////////////////////////////////////////////////////
//
// $$$$$$\ $$$$$$\ $$$$$$$$\ $$\ $$\
// $$ __$$\ $$ __$$\ $$ _____|$$$\ $$ |
// $$ / \__|$$ / \__|$$ | $$$$\ $$ |
// $$ | $$ |$$$$\ $$$$$\ $$ $$\$$ |
// $$ | $$ |\_$$ |$$ __| $$ \$$$$ |
// $$ | $$\ $$ | $$ |$$ | $$ |\$$$ |
// \$$$$$$ |\$$$$$$ |$$$$$$$$\ $$ | \$$ |
// \______/ \______/ \________|\__| \__|
//
// dqn_cgen.cpp
//
////////////////////////////////////////////////////////////////////////////////////////////////////
Dqn_CGenMapNodeToEnum const DQN_CGEN_TABLE_KEY_LIST[] =
{
{Dqn_CGenTableKeyType_Name, DQN_STR8("name")},
{Dqn_CGenTableKeyType_Type, DQN_STR8("type")},
};
Dqn_CGenMapNodeToEnum const DQN_CGEN_TABLE_TYPE_LIST[] =
{
{Dqn_CGenTableType_Data, DQN_STR8("data") },
{Dqn_CGenTableType_CodeGenBuiltinTypes, DQN_STR8("code_gen_builtin_types")},
{Dqn_CGenTableType_CodeGenStruct, DQN_STR8("code_gen_struct") },
{Dqn_CGenTableType_CodeGenEnum, DQN_STR8("code_gen_enum") },
};
Dqn_CGenMapNodeToEnum const DQN_CGEN_TABLE_ROW_TAG_LIST[] =
{
{Dqn_CGenTableRowTagType_CommentDivider, DQN_STR8("comment_divider")},
{Dqn_CGenTableRowTagType_EmptyLine, DQN_STR8("empty_line")},
};
Dqn_CGenMapNodeToEnum const DQN_CGEN_TABLE_ROW_TAG_COMMENT_DIVIDER_KEY_LIST[] =
{
{Dqn_CGenTableRowTagCommentDivider_Label, DQN_STR8("label")},
};
Dqn_CGenTableHeaderType const DQN_CGEN_TABLE_CODE_GEN_STRUCT_HEADER_LIST[] =
{
Dqn_CGenTableHeaderType_Name,
Dqn_CGenTableHeaderType_Table,
Dqn_CGenTableHeaderType_CppType,
Dqn_CGenTableHeaderType_CppName,
Dqn_CGenTableHeaderType_CppIsPtr,
Dqn_CGenTableHeaderType_CppOpEquals,
Dqn_CGenTableHeaderType_CppArraySize,
Dqn_CGenTableHeaderType_CppArraySizeField,
Dqn_CGenTableHeaderType_GenTypeInfo,
};
Dqn_CGenTableHeaderType const DQN_CGEN_TABLE_CODE_GEN_ENUM_HEADER_LIST[] =
{
Dqn_CGenTableHeaderType_Name,
Dqn_CGenTableHeaderType_Table,
Dqn_CGenTableHeaderType_CppName,
Dqn_CGenTableHeaderType_CppValue,
Dqn_CGenTableHeaderType_GenTypeInfo,
Dqn_CGenTableHeaderType_GenEnumCount,
};
Dqn_CGenTableHeaderType const DQN_CGEN_TABLE_CODE_GEN_BUILTIN_TYPES_HEADER_LIST[] =
{
Dqn_CGenTableHeaderType_Name,
};
static bool Dqn_CGen_GatherTables_(Dqn_CGen *cgen, Dqn_ErrorSink *error)
{
bool result = false;
if (!cgen || !cgen->file_list || !cgen->arena)
return result;
// NOTE: Gather the tables /////////////////////////////////////////////////////////////////////
for (MD_EachNode(ref, cgen->file_list->first_child)) {
MD_Node *root = MD_ResolveNodeFromReference(ref);
for (MD_EachNode(node, root->first_child)) {
MD_Node *table_tag = MD_TagFromString(node, MD_S8Lit("table"), 0);
if (MD_NodeIsNil(table_tag))
continue;
Dqn_CGenTable *table = MD_PushArray(cgen->arena, Dqn_CGenTable, 1);
table->node = node;
table->name = Dqn_CGen_MDToDqnStr8(table_tag->first_child->first_child->string);
MD_MapInsert(cgen->arena, &cgen->table_map, MD_MapKeyStr(Dqn_CGen_DqnToMDStr8(table->name)), table);
MD_QueuePush(cgen->first_table, cgen->last_table, table);
for (MD_EachNode(key, table_tag->first_child)) {
Dqn_CGenMapNodeToEnum key_mapping = Dqn_CGen_MapNodeToEnumOrExit(key,
DQN_CGEN_TABLE_KEY_LIST,
DQN_ARRAY_UCOUNT(DQN_CGEN_TABLE_KEY_LIST),
"Table specified invalid key");
switch (DQN_CAST(Dqn_CGenTableKeyType)key_mapping.enum_val) {
case Dqn_CGenTableKeyType_Nil: DQN_INVALID_CODE_PATH;
case Dqn_CGenTableKeyType_Name: {
table->name = Dqn_CGen_MDToDqnStr8(key->first_child->string);
} break;
case Dqn_CGenTableKeyType_Type: {
MD_Node *table_type_value = key->first_child;
Dqn_CGenMapNodeToEnum table_type_validator = Dqn_CGen_MapNodeToEnumOrExit(table_type_value,
DQN_CGEN_TABLE_TYPE_LIST,
DQN_ARRAY_UCOUNT(DQN_CGEN_TABLE_TYPE_LIST),
"Table 'type' specified invalid value");
table->type = DQN_CAST(Dqn_CGenTableType) table_type_validator.enum_val;
DQN_ASSERT(table->type <= Dqn_CGenTableType_Count);
cgen->table_counts[table->type]++;
} break;
}
}
}
}
// NOTE: Parse the tables //////////////////////////////////////////////////////////////////////
Dqn_usize const BEGIN_COLUMN_INDEX = 1; /*Reserve 0th slot for nil-entry*/
for (Dqn_CGenTable *table = cgen->first_table; table; table = table->next) {
table->column_count = BEGIN_COLUMN_INDEX;
table->headers_node = table->node->first_child;
for (MD_EachNode(column_node, table->headers_node->first_child))
table->column_count++;
if (table->column_count == BEGIN_COLUMN_INDEX)
continue;
MD_Node *row_it = table->headers_node->next;
for (MD_EachNode(row_node, row_it))
table->row_count++;
table->rows = MD_PushArray(cgen->arena, Dqn_CGenTableRow, table->row_count);
table->headers = MD_PushArray(cgen->arena, Dqn_CGenTableHeader, table->column_count);
for (Dqn_usize index = 0; index < table->row_count; index++) {
Dqn_CGenTableRow *row = table->rows + index;
row->columns = MD_PushArray(cgen->arena, Dqn_CGenTableColumn, table->column_count);
}
// NOTE: Collect table headers /////////////////////////////////////////////////////////////
table->headers_map = MD_MapMake(cgen->arena);
Dqn_usize column_index = BEGIN_COLUMN_INDEX;
for (MD_EachNode(header_column, table->headers_node->first_child)) {
DQN_ASSERT(column_index < table->column_count);
// NOTE: Detect builtin headers and cache the index for that table /////////////////////
for (Dqn_usize enum_index = 0; enum_index < Dqn_CGenTableHeaderType_Count; enum_index++) {
Dqn_Str8 decl_str8 = Dqn_CGen_TableHeaderTypeToDeclStr8(DQN_CAST(Dqn_CGenTableHeaderType)enum_index);
if (decl_str8 != Dqn_Str8_Init(header_column->string.str, header_column->string.size))
continue;
table->column_indexes[enum_index] = column_index;
break;
}
MD_MapInsert(cgen->arena, &table->headers_map, MD_MapKeyStr(header_column->string), DQN_CAST(void *)column_index);
table->headers[column_index++].name = header_column->string;
}
// NOTE: Validate table headers ////////////////////////////////////////////////////////////
switch (table->type) {
case Dqn_CGenTableType_Nil: DQN_INVALID_CODE_PATH;
case Dqn_CGenTableType_Data: {
} break;
case Dqn_CGenTableType_CodeGenStruct: {
for (Dqn_CGenTableHeaderType enum_val : DQN_CGEN_TABLE_CODE_GEN_STRUCT_HEADER_LIST) {
if (table->column_indexes[enum_val] == 0) {
Dqn_Str8 expected_value = Dqn_CGen_TableHeaderTypeToDeclStr8(enum_val);
Dqn_CGen_LogF(MD_MessageKind_Error, table->headers_node, error, "Struct code generation table is missing column '%.*s'", DQN_STR_FMT(expected_value));
return false;
}
}
} break;
case Dqn_CGenTableType_CodeGenEnum: {
for (Dqn_CGenTableHeaderType enum_val : DQN_CGEN_TABLE_CODE_GEN_ENUM_HEADER_LIST) {
if (table->column_indexes[enum_val] == 0) {
Dqn_Str8 expected_value = Dqn_CGen_TableHeaderTypeToDeclStr8(enum_val);
Dqn_CGen_LogF(MD_MessageKind_Error, table->headers_node, error, "Enum code generation table is missing column '%.*s'", DQN_STR_FMT(expected_value));
return false;
}
}
} break;
case Dqn_CGenTableType_CodeGenBuiltinTypes: {
for (Dqn_CGenTableHeaderType enum_val : DQN_CGEN_TABLE_CODE_GEN_BUILTIN_TYPES_HEADER_LIST) {
if (table->column_indexes[enum_val] == 0) {
Dqn_Str8 expected_value = Dqn_CGen_TableHeaderTypeToDeclStr8(enum_val);
Dqn_CGen_LogF(MD_MessageKind_Error, table->headers_node, error, "Enum code generation table is missing column '%.*s'", DQN_STR_FMT(expected_value));
return false;
}
}
} break;
}
// NOTE: Parse each row in table ///////////////////////////////////////////////////////////
Dqn_usize row_index = 0;
for (MD_EachNode(row_node, row_it)) {
column_index = BEGIN_COLUMN_INDEX;
DQN_ASSERT(row_index < table->row_count);
// NOTE: Parse any tags set on the row /////////////////////////////////////////////////
Dqn_CGenTableRow *row = table->rows + row_index++;
for (MD_EachNode(row_tag, row_node->first_tag)) {
Dqn_CGenMapNodeToEnum row_mapping = Dqn_CGen_MapNodeToEnumOrExit(row_tag,
DQN_CGEN_TABLE_ROW_TAG_LIST,
DQN_ARRAY_UCOUNT(DQN_CGEN_TABLE_ROW_TAG_LIST),
"Table specified invalid row tag");
Dqn_CGenTableRowTag *tag = MD_PushArray(cgen->arena, Dqn_CGenTableRowTag, 1);
tag->type = DQN_CAST(Dqn_CGenTableRowTagType) row_mapping.enum_val;
MD_QueuePush(row->first_tag, row->last_tag, tag);
switch (tag->type) {
case Dqn_CGenTableRowTagType_Nil: DQN_INVALID_CODE_PATH;
case Dqn_CGenTableRowTagType_CommentDivider: {
for (MD_EachNode(tag_key, row_tag->first_child)) {
Dqn_CGenMapNodeToEnum tag_mapping = Dqn_CGen_MapNodeToEnumOrExit(tag_key,
DQN_CGEN_TABLE_ROW_TAG_COMMENT_DIVIDER_KEY_LIST,
DQN_ARRAY_UCOUNT(DQN_CGEN_TABLE_ROW_TAG_COMMENT_DIVIDER_KEY_LIST),
"Table specified invalid row tag");
switch (DQN_CAST(Dqn_CGenTableRowTagCommentDivider)tag_mapping.enum_val) {
case Dqn_CGenTableRowTagCommentDivider_Nil: DQN_INVALID_CODE_PATH;
case Dqn_CGenTableRowTagCommentDivider_Label: {
tag->comment = tag_key->first_child->string;
} break;
}
}
} break;
case Dqn_CGenTableRowTagType_EmptyLine: break;
}
}
for (MD_EachNode(column_node, row_node->first_child)) {
table->headers[column_index].longest_string = DQN_MAX(table->headers[column_index].longest_string, DQN_CAST(int) column_node->string.size);
row->columns[column_index].string = Dqn_CGen_MDToDqnStr8(column_node->string);
row->columns[column_index].node = column_node;
column_index++;
}
}
}
// NOTE: Validate codegen //////////////////////////////////////////////////////////////////////
Dqn_CGenTableHeaderType const CHECK_COLUMN_LINKS[] = {
Dqn_CGenTableHeaderType_CppName,
Dqn_CGenTableHeaderType_CppType,
Dqn_CGenTableHeaderType_CppValue,
Dqn_CGenTableHeaderType_CppIsPtr,
Dqn_CGenTableHeaderType_CppArraySize,
Dqn_CGenTableHeaderType_CppArraySizeField,
};
result = true;
for (Dqn_CGenTable *table = cgen->first_table; table; table = table->next) {
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it);) {
for (Dqn_CGenTableHeaderType check_column : CHECK_COLUMN_LINKS) {
Dqn_CGenTableColumn column = it.cgen_table_row->columns[table->column_indexes[check_column]];
if (column.string.size == 0) {
// NOTE: The code generation table did not bind a code generation parameter to
// a column in the target table. We skip it.
continue;
}
// NOTE: Check if the column to bind to exists in the target table.
if (!MD_MapLookup(&it.table->headers_map, MD_MapKeyStr(Dqn_CGen_DqnToMDStr8(column.string)))) {
result = false;
Dqn_Str8 header_type_str8 = Dqn_CGen_TableHeaderTypeToDeclStr8(check_column);
Dqn_CGen_LogF(MD_MessageKind_Error, column.node, error,
"Code generation table binds '%.*s' to '%.*s', but the column '%.*s' does not exist in table '%.*s'\n"
"NOTE: If you want '%.*s' to omit the column '%.*s' you can bind to the empty string `` to skip it, otherwise, please ensure the table '%.*s' has the column '%.*s'"
,
DQN_STR_FMT(column.string),
DQN_STR_FMT(header_type_str8),
DQN_STR_FMT(column.string),
DQN_STR_FMT(it.table->name),
DQN_STR_FMT(it.table->name),
DQN_STR_FMT(header_type_str8),
DQN_STR_FMT(it.table->name),
DQN_STR_FMT(header_type_str8));
}
}
}
}
return result;
}
DQN_API Dqn_CGen Dqn_CGen_InitFilesArgV(int argc, char const **argv, Dqn_ErrorSink *error)
{
Dqn_CGen result = {};
result.arena = MD_ArenaAlloc();
result.file_list = MD_MakeList(result.arena);
result.table_map = MD_MapMake(result.arena);
bool has_error = false;
for (Dqn_isize arg_index = 0; arg_index < argc; arg_index++) {
MD_String8 file_name = MD_S8CString(DQN_CAST(char *)argv[arg_index]);
MD_ParseResult parse_result = MD_ParseWholeFile(result.arena, file_name);
for (MD_Message *message = parse_result.errors.first; message != 0; message = message->next) {
MD_CodeLoc code_loc = MD_CodeLocFromNode(message->node);
has_error = true;
Dqn_CGen_LogF(message->kind, message->node, error, "%.*s", MD_S8VArg(message->string));
}
MD_PushNewReference(result.arena, result.file_list, parse_result.node);
}
if (!has_error)
Dqn_CGen_GatherTables_(&result, error);
return result;
}
DQN_API Dqn_Str8 Dqn_CGen_TableHeaderTypeToDeclStr8(Dqn_CGenTableHeaderType type)
{
Dqn_Str8 result = {};
switch (type) {
case Dqn_CGenTableHeaderType_Name: result = DQN_STR8("name"); break;
case Dqn_CGenTableHeaderType_Table: result = DQN_STR8("table"); break;
case Dqn_CGenTableHeaderType_CppType: result = DQN_STR8("cpp_type"); break;
case Dqn_CGenTableHeaderType_CppName: result = DQN_STR8("cpp_name"); break;
case Dqn_CGenTableHeaderType_CppValue: result = DQN_STR8("cpp_value"); break;
case Dqn_CGenTableHeaderType_CppIsPtr: result = DQN_STR8("cpp_is_ptr"); break;
case Dqn_CGenTableHeaderType_CppOpEquals: result = DQN_STR8("cpp_op_equals"); break;
case Dqn_CGenTableHeaderType_CppArraySize: result = DQN_STR8("cpp_array_size"); break;
case Dqn_CGenTableHeaderType_CppArraySizeField: result = DQN_STR8("cpp_array_size_field"); break;
case Dqn_CGenTableHeaderType_GenTypeInfo: result = DQN_STR8("gen_type_info"); break;
case Dqn_CGenTableHeaderType_GenEnumCount: result = DQN_STR8("gen_enum_count"); break;
case Dqn_CGenTableHeaderType_Count: result = DQN_STR8("XX BAD ENUM VALUE XX"); break;
default: result = DQN_STR8("XX INVALID ENUM VALUE XX"); break;
}
return result;
}
DQN_API Dqn_CGenMapNodeToEnum Dqn_CGen_MapNodeToEnumOrExit(MD_Node const *node, Dqn_CGenMapNodeToEnum const *valid_keys, Dqn_usize valid_keys_size, char const *fmt, ...)
{
Dqn_CGenMapNodeToEnum result = {};
for (Dqn_usize index = 0; index < valid_keys_size; index++) {
Dqn_CGenMapNodeToEnum const *validator = valid_keys + index;
if (Dqn_Str8_Init(node->string.str, node->string.size) == validator->node_string) {
result = *validator;
break;
}
}
if (result.enum_val == 0) {
MD_CodeLoc loc = MD_CodeLocFromNode(DQN_CAST(MD_Node *)node);
Dqn_Scratch scratch = Dqn_Scratch_Get(nullptr);
va_list args;
va_start(args, fmt);
Dqn_Str8 user_msg = Dqn_Str8_InitFV(scratch.arena, fmt, args);
va_end(args);
Dqn_Str8Builder builder = {};
builder.arena = scratch.arena;
Dqn_Str8Builder_AppendF(&builder, "%.*s: '%.*s' is not recognised, the supported values are ", DQN_STR_FMT(user_msg), MD_S8VArg(node->string));
for (Dqn_usize index = 0; index < valid_keys_size; index++) {
Dqn_CGenMapNodeToEnum const *validator = valid_keys + index;
Dqn_Str8Builder_AppendF(&builder, DQN_CAST(char *)"%s'%.*s'", index ? ", " : "", DQN_STR_FMT(validator->node_string));
}
Dqn_Str8 error_msg = Dqn_Str8Builder_Build(&builder, scratch.arena);
MD_PrintMessageFmt(stderr, loc, MD_MessageKind_Error, DQN_CAST(char *) "%.*s", DQN_STR_FMT(error_msg));
Dqn_OS_Exit(DQN_CAST(uint32_t)-1);
}
return result;
}
DQN_API void Dqn_CGen_LogF(MD_MessageKind kind, MD_Node *node, Dqn_ErrorSink *error, char const *fmt, ...)
{
if (!error)
return;
Dqn_Scratch scratch = Dqn_Scratch_Get(nullptr);
Dqn_Str8Builder builder = {};
builder.arena = scratch.arena;
MD_String8 kind_string = MD_StringFromMessageKind(kind);
MD_CodeLoc loc = MD_CodeLocFromNode(node);
Dqn_Str8Builder_AppendF(&builder, "" MD_FmtCodeLoc " %.*s: ", MD_CodeLocVArg(loc), MD_S8VArg(kind_string));
va_list args;
va_start(args, fmt);
Dqn_Str8Builder_AppendFV(&builder, fmt, args);
va_end(args);
Dqn_Str8 msg = Dqn_Str8Builder_Build(&builder, scratch.arena);
Dqn_ErrorSink_MakeF(error, DQN_CAST(uint32_t)-1, "%.*s", DQN_STR_FMT(msg));
}
DQN_API bool Dqn_CGen_TableHasHeaders(Dqn_CGenTable const *table, Dqn_Str8 const *headers, Dqn_usize header_count, Dqn_ErrorSink *error)
{
bool result = true;
Dqn_Scratch scratch = Dqn_Scratch_Get(nullptr);
Dqn_Str8Builder builder = {};
builder.arena = scratch.arena;
for (Dqn_usize index = 0; index < header_count; index++) {
Dqn_Str8 header = headers[index];
MD_String8 header_md = {DQN_CAST(MD_u8 *) header.data, header.size};
MD_MapSlot *slot = MD_MapLookup(DQN_CAST(MD_Map *)&table->headers_map, MD_MapKeyStr(header_md));
if (!slot) {
result = false;
Dqn_Str8Builder_AppendF(&builder, "%s%.*s", builder.count ? ", " : "", DQN_STR_FMT(header));
}
}
if (!result) {
Dqn_Str8 missing_headers = Dqn_Str8Builder_Build(&builder, scratch.arena);
Dqn_CGen_LogF(MD_MessageKind_Error,
table->headers_node,
error,
"Table '%.*s' is missing the header(s): %.*s",
DQN_STR_FMT(table->name),
DQN_STR_FMT(missing_headers));
}
return result;
}
DQN_API Dqn_CGenLookupColumnAtHeader Dqn_CGen_LookupColumnAtHeader(Dqn_CGenTable *table, Dqn_Str8 header, Dqn_CGenTableRow const *row)
{
Dqn_CGenLookupColumnAtHeader result = {};
if (!table || !row)
return result;
MD_String8 header_md = {DQN_CAST(MD_u8 *) header.data, header.size};
MD_MapSlot *slot = MD_MapLookup(&table->headers_map, MD_MapKeyStr(header_md));
if (!slot)
return result;
Dqn_usize column_index = DQN_CAST(Dqn_usize) slot->val;
DQN_ASSERT(column_index < table->column_count);
{
Dqn_usize begin = DQN_CAST(uintptr_t)(table->rows);
Dqn_usize end = DQN_CAST(uintptr_t)(table->rows + table->row_count);
Dqn_usize ptr = DQN_CAST(uintptr_t)row;
DQN_ASSERTF(ptr >= begin && ptr <= end, "The row to lookup does not belong to the table passed in");
}
result.index = column_index;
result.column = row->columns[column_index];
result.header = table->headers[column_index];
return result;
}
DQN_API bool Dqn_CGen_LookupNextTableInCodeGenTable(Dqn_CGen *cgen, Dqn_CGenTable *cgen_table, Dqn_CGenLookupTableIterator *it)
{
if (!cgen_table)
return false;
if (it->row_index >= cgen_table->row_count)
return false;
if (cgen_table->type != Dqn_CGenTableType_CodeGenEnum && cgen_table->type != Dqn_CGenTableType_CodeGenStruct && cgen_table->type != Dqn_CGenTableType_CodeGenBuiltinTypes)
return false;
// NOTE: Lookup the table in this row that we will code generate from. Not
// applicable when we are doing builtin types as the types are just put
// in-line into the code generation table itself.
it->cgen_table = cgen_table;
it->cgen_table_row = cgen_table->rows + it->row_index++;
if (cgen_table->type != Dqn_CGenTableType_CodeGenBuiltinTypes) {
Dqn_CGenTableColumn cgen_table_column = it->cgen_table_row->columns[cgen_table->column_indexes[Dqn_CGenTableHeaderType_Table]];
MD_String8 key = {DQN_CAST(MD_u8 *)cgen_table_column.string.data, cgen_table_column.string.size};
MD_MapSlot *table_slot = MD_MapLookup(&cgen->table_map, MD_MapKeyStr(key));
if (!table_slot) {
MD_CodeLoc loc = MD_CodeLocFromNode(cgen_table_column.node);
MD_PrintMessageFmt(stderr,
loc,
MD_MessageKind_Warning,
DQN_CAST(char *) "Code generation table references non-existent table '%.*s'",
DQN_STR_FMT(cgen_table_column.string));
return false;
}
it->table = DQN_CAST(Dqn_CGenTable *) table_slot->val;
}
for (Dqn_usize type = 0; type < Dqn_CGenTableHeaderType_Count; type++)
it->cgen_table_column[type] = it->cgen_table_row->columns[cgen_table->column_indexes[type]];
return true;
}
static void Dqn_CGen_EmitRowWhitespace_(Dqn_CGenTableRow const *row, Dqn_CppFile *cpp)
{
for (Dqn_CGenTableRowTag *tag = row->first_tag; tag; tag = tag->next) {
switch (tag->type) {
case Dqn_CGenTableRowTagType_Nil: DQN_INVALID_CODE_PATH;
case Dqn_CGenTableRowTagType_CommentDivider: {
if (tag->comment.size <= 0)
break;
Dqn_Scratch scratch = Dqn_Scratch_Get(nullptr);
Dqn_Str8 prefix = Dqn_Str8_InitF(scratch.arena, "// NOTE: %.*s ", MD_S8VArg(tag->comment));
int line_padding = DQN_MAX(100 - (DQN_CAST(int) prefix.size + (Dqn_CppSpacePerIndent(cpp) * cpp->indent)), 0);
Dqn_CppPrint(cpp, "%.*s", DQN_STR_FMT(prefix));
for (int index = 0; index < line_padding; index++)
Dqn_CppAppend(cpp, "/");
Dqn_CppAppend(cpp, "\n");
} break;
case Dqn_CGenTableRowTagType_EmptyLine: {
Dqn_CppAppend(cpp, "\n");
} break;
}
}
}
DQN_API void Dqn_CGen_EmitCodeForTables(Dqn_CGen *cgen, Dqn_CGenEmit emit, Dqn_CppFile *cpp, Dqn_Str8 emit_prefix)
{
DQN_ASSERT(Dqn_Str8_HasData(emit_prefix));
if (emit & Dqn_CGenEmit_Prototypes) {
// NOTE: Generate type info enums //////////////////////////////////////////////////////////
Dqn_CppEnumBlock(cpp, "%.*s_Type", DQN_STR_FMT(emit_prefix)) {
Dqn_CppLine(cpp, "%.*s_Type_Nil,", DQN_STR_FMT(emit_prefix));
for (Dqn_CGenTable *table = cgen->first_table; table != 0; table = table->next) {
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it);)
Dqn_CppLine(cpp, "%.*s_Type_%.*s,", DQN_STR_FMT(emit_prefix), DQN_STR_FMT(it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string));
}
Dqn_CppLine(cpp, "%.*s_Type_Count,", DQN_STR_FMT(emit_prefix));
}
// NOTE: Generate structs + enums //////////////////////////////////////////////////////////////
for (Dqn_CGenTable *table = cgen->first_table; table != 0; table = table->next) {
switch (table->type) {
case Dqn_CGenTableType_Nil: DQN_INVALID_CODE_PATH;
case Dqn_CGenTableType_Data: continue;
case Dqn_CGenTableType_CodeGenStruct: {
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it); ) {
// TODO(doyle): Verify the codegen table has the headers from the table it references
Dqn_CppStructBlock(cpp, "%.*s", DQN_STR_FMT(it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string)) {
for (Dqn_usize row_index = 0; row_index < it.table->row_count; row_index++) {
Dqn_CGenTableRow const *row = it.table->rows + row_index;
Dqn_CGenLookupColumnAtHeader cpp_name = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppName].string, row);
Dqn_CGenLookupColumnAtHeader cpp_type = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppType].string, row);
Dqn_CGenLookupColumnAtHeader cpp_array_size = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppArraySize].string, row);
int name_to_type_padding = 1 + it.table->headers[cpp_type.index].longest_string - DQN_CAST(int) cpp_type.column.string.size;
if (cpp_name.column.string.size <= 0 || cpp_type.column.string.size <= 0)
continue;
Dqn_CGen_EmitRowWhitespace_(row, cpp);
Dqn_Scratch scratch = Dqn_Scratch_Get(nullptr);
Dqn_Str8 array_size = {};
if (cpp_array_size.column.string.size)
array_size = Dqn_Str8_InitF(scratch.arena, "[%.*s]", DQN_STR_FMT(cpp_array_size.column.string));
Dqn_CppLine(cpp,
"%.*s%*s%.*s%.*s;",
DQN_STR_FMT(cpp_type.column.string),
name_to_type_padding,
"",
DQN_STR_FMT(cpp_name.column.string),
DQN_STR_FMT(array_size));
}
}
}
} break;
case Dqn_CGenTableType_CodeGenEnum: {
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it); ) {
Dqn_CppEnumBlock(cpp, "%.*s", DQN_STR_FMT(it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string)) {
Dqn_usize enum_count = 0;
for (Dqn_usize row_index = 0; row_index < it.table->row_count; row_index++) {
Dqn_CGenTableRow const *row = it.table->rows + row_index;
Dqn_CGenLookupColumnAtHeader cpp_name = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppName].string, row);
Dqn_CGenLookupColumnAtHeader cpp_value = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppValue].string, row);
if (cpp_name.column.string.size <= 0)
continue;
Dqn_CGen_EmitRowWhitespace_(row, cpp);
if (cpp_value.column.string.size) {
Dqn_CppLine(cpp,
"%.*s_%.*s = %.*s,",
DQN_STR_FMT(it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string),
DQN_STR_FMT(cpp_name.column.string),
DQN_STR_FMT(cpp_value.column.string));
} else {
Dqn_CppLine(cpp,
"%.*s_%.*s = %zu,",
DQN_STR_FMT(it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string),
DQN_STR_FMT(cpp_name.column.string),
row_index);
}
enum_count++;
}
Dqn_CGenTableColumn gen_enum_count_column = it.cgen_table_column[Dqn_CGenTableHeaderType_GenEnumCount];
if (gen_enum_count_column.string.size)
Dqn_CppLine(cpp,
"%.*s_%.*s = %zu,",
DQN_STR_FMT(it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string),
DQN_STR_FMT(gen_enum_count_column.string),
enum_count);
}
}
} break;
}
}
// NOTE: Generate enums for struct fields //////////////////////////////////////////////////
for (Dqn_CGenTable *table = cgen->first_table; table != 0; table = table->next) {
switch (table->type) {
case Dqn_CGenTableType_Nil: DQN_INVALID_CODE_PATH;
case Dqn_CGenTableType_Data: continue;
case Dqn_CGenTableType_CodeGenEnum: continue;
case Dqn_CGenTableType_CodeGenStruct: {
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it); ) {
Dqn_Str8 struct_name = it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string;
Dqn_CppEnumBlock(cpp, "%.*sTypeField", DQN_STR_FMT(struct_name)) {
for (Dqn_usize row_index = 0; row_index < it.table->row_count; row_index++) {
Dqn_CGenTableRow const *row = it.table->rows + row_index;
Dqn_CGenLookupColumnAtHeader cpp_name = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppName].string, row);
if (cpp_name.column.string.size <= 0)
continue;
Dqn_CGen_EmitRowWhitespace_(row, cpp);
Dqn_CppLine(cpp, "%.*sTypeField_%.*s,", DQN_STR_FMT(struct_name), DQN_STR_FMT(cpp_name.column.string));
}
Dqn_CppLine(cpp, "%.*sTypeField_Count,", DQN_STR_FMT(struct_name));
}
}
} break;
}
}
// NOTE: Str8 to enum conversion ////////////////////////////////////////////////////////////
for (Dqn_CGenTable *table = cgen->first_table; table != 0; table = table->next) {
if (table->type != Dqn_CGenTableType_CodeGenEnum)
continue;
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it);) {
Dqn_Str8 type_name = it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string;
Dqn_CppStructBlock(cpp, "%.*sStr8ToEnumResult", DQN_STR_FMT(type_name)) {
Dqn_CppLine(cpp, "bool success;");
Dqn_CppLine(cpp, "%.*s value;", DQN_STR_FMT(type_name));
}
}
}
for (Dqn_CGenTable *table = cgen->first_table; table != 0; table = table->next) {
if (table->type != Dqn_CGenTableType_CodeGenEnum)
continue;
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it);) {
Dqn_Str8 type_name = it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string;
Dqn_CppLine(cpp, "%.*sStr8ToEnumResult %.*s_Str8ToEnum(Dqn_Str8 string);", DQN_STR_FMT(type_name), DQN_STR_FMT(type_name));
}
}
// NOTE: Operator == and != ////////////////////////////////////////////////////////////////
for (Dqn_CGenTable *table = cgen->first_table; table != 0; table = table->next) {
if (table->type != Dqn_CGenTableType_CodeGenStruct)
continue;
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it);) {
Dqn_Str8 cpp_op_equals = it.cgen_table_column[Dqn_CGenTableHeaderType_CppOpEquals].string;
if (cpp_op_equals != DQN_STR8("true"))
continue;
Dqn_Str8 type_name = it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string;
Dqn_CppLine(cpp, "bool operator==(%.*s const &lhs, %.*s const &rhs);", DQN_STR_FMT(type_name), DQN_STR_FMT(type_name));
Dqn_CppLine(cpp, "bool operator!=(%.*s const &lhs, %.*s const &rhs);", DQN_STR_FMT(type_name), DQN_STR_FMT(type_name));
}
}
}
if (emit & Dqn_CGenEmit_Implementation) {
// NOTE: Generate type info ////////////////////////////////////////////////////////////////////
for (Dqn_CGenTable *table = cgen->first_table; table != 0; table = table->next) {
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it);) {
if (table->type == Dqn_CGenTableType_CodeGenBuiltinTypes)
continue;
Dqn_Str8 struct_or_enum_name = it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string;
Dqn_CppBlock(cpp, ";\n\n", "Dqn_TypeField const g_%.*s_type_fields[] =", DQN_STR_FMT(struct_or_enum_name)) {
if (table->type == Dqn_CGenTableType_CodeGenStruct) {
for (Dqn_usize row_index = 0; row_index < it.table->row_count; row_index++) {
Dqn_CGenTableRow const *row = it.table->rows + row_index;
Dqn_CGenLookupColumnAtHeader cpp_name = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppName].string, row);
Dqn_CGenLookupColumnAtHeader cpp_type = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppType].string, row);
Dqn_CGenLookupColumnAtHeader cpp_is_ptr = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppIsPtr].string, row);
Dqn_CGenLookupColumnAtHeader cpp_array_size = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppArraySize].string, row);
Dqn_CGenLookupColumnAtHeader cpp_array_size_field = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppArraySizeField].string, row);
bool cpp_is_ptr_b32 = cpp_is_ptr.column.string == DQN_STR8("true");
Dqn_Str8 cpp_array_size_str8 = Dqn_Str8_HasData(cpp_array_size.column.string) ? cpp_array_size.column.string : DQN_STR8("0");
Dqn_CGenTableColumn struct_name = it.cgen_table_row->columns[table->column_indexes[Dqn_CGenTableHeaderType_Name]];
Dqn_Scratch scratch = Dqn_Scratch_Get(nullptr);
Dqn_Str8 cpp_array_size_field_str8 = DQN_STR8("NULL");
if (cpp_array_size_field.column.string.size) {
// TODO(doyle): Check that array_size_field references a valid field in the table
// NOTE: We use a raw index for the reference because the struct might
// not have type info being generated so we can't rely on the enum.
Dqn_usize index_the_field_references = 0;
for (Dqn_usize sub_row_index = 0; sub_row_index < it.table->row_count; sub_row_index++) {
Dqn_CGenTableRow const *sub_row = it.table->rows + sub_row_index;
Dqn_CGenTableColumn sub_cpp_name = sub_row->columns[cpp_name.index];
if (sub_cpp_name.string == cpp_array_size_field.column.string)
index_the_field_references = sub_row_index;
}
cpp_array_size_field_str8 = Dqn_Str8_InitF(scratch.arena,
"&g_%.*s_type_fields[%zu]",
DQN_STR_FMT(struct_name.string),
index_the_field_references);
}
Dqn_Str8 orig_cpp_type_info = Dqn_Str8_InitF(scratch.arena, "%.*s", DQN_STR_FMT(cpp_type.column.string));
Dqn_Str8 cpp_type_info = orig_cpp_type_info;
cpp_type_info = Dqn_Str8_Replace(cpp_type_info, /*find*/ DQN_STR8("*"), /*replace*/ DQN_STR8(""), /*start_index*/ 0, scratch.arena, Dqn_Str8EqCase_Sensitive);
cpp_type_info = Dqn_Str8_Replace(cpp_type_info, /*find*/ DQN_STR8("constexpr"), /*replace*/ DQN_STR8(""), /*start_index*/ 0, scratch.arena, Dqn_Str8EqCase_Sensitive);
cpp_type_info = Dqn_Str8_Replace(cpp_type_info, /*find*/ DQN_STR8("const"), /*replace*/ DQN_STR8(""), /*start_index*/ 0, scratch.arena, Dqn_Str8EqCase_Sensitive);
cpp_type_info = Dqn_Str8_Replace(cpp_type_info, /*find*/ DQN_STR8("static"), /*replace*/ DQN_STR8(""), /*start_index*/ 0, scratch.arena, Dqn_Str8EqCase_Sensitive);
cpp_type_info = Dqn_Str8_Replace(cpp_type_info, /*find*/ DQN_STR8(" "), /*replace*/ DQN_STR8(""), /*start_index*/ 0, scratch.arena, Dqn_Str8EqCase_Sensitive);
Dqn_Str8 cpp_type_enum = Dqn_Str8_InitF(scratch.arena, "%.*s_Type_%.*s", DQN_STR_FMT(emit_prefix), DQN_STR_FMT(cpp_type_info));
Dqn_usize cpp_name_padding = 1 + it.table->headers[cpp_name.index].longest_string - cpp_name.column.string.size;
Dqn_usize cpp_type_padding = 1 + it.table->headers[cpp_type.index].longest_string - cpp_type.column.string.size;
Dqn_usize cpp_type_enum_padding = cpp_type_padding + (orig_cpp_type_info.size - cpp_type_info.size);
Dqn_CppLine(cpp,
"{%2d, DQN_STR8(\"%.*s\"),%*s/*value*/ 0, offsetof(%.*s, %.*s),%*ssizeof(((%.*s*)0)->%.*s),%*salignof(%.*s),%*sDQN_STR8(\"%.*s\"),%*s%.*s,%*s/*is_pointer*/ %s,%s /*array_size*/ %.*s, /*array_size_field*/ %.*s},",
row_index,
DQN_STR_FMT(cpp_name.column.string),
cpp_name_padding, "",
// NOTE: offsetof(a, b)
DQN_STR_FMT(struct_or_enum_name),
DQN_STR_FMT(cpp_name.column.string),
cpp_name_padding, "",
// NOTE: sizeof(a->b)
DQN_STR_FMT(struct_or_enum_name),
DQN_STR_FMT(cpp_name.column.string),
cpp_name_padding, "",
// NOTE: alignof(a->b)
DQN_STR_FMT(cpp_type.column.string),
cpp_type_padding, "",
// NOTE: Type string
DQN_STR_FMT(cpp_type.column.string),
cpp_type_padding, "",
// NOTE: Type as enum
DQN_STR_FMT(cpp_type_enum),
cpp_type_enum_padding, "",
cpp_is_ptr_b32 ? "true" : "false",
cpp_is_ptr_b32 ? " " : "",
DQN_STR_FMT(cpp_array_size_str8),
DQN_STR_FMT(cpp_array_size_field_str8));
}
} else {
DQN_ASSERT(table->type == Dqn_CGenTableType_CodeGenEnum);
for (Dqn_usize row_index = 0; row_index < it.table->row_count; row_index++) {
Dqn_CGenTableRow const *row = it.table->rows + row_index;
Dqn_CGenLookupColumnAtHeader cpp_name = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppName].string, row);
Dqn_CGenLookupColumnAtHeader cpp_value = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppValue].string, row);
if (cpp_name.column.string.size <= 0)
continue;
Dqn_Scratch scratch = Dqn_Scratch_Get(nullptr);
Dqn_usize cpp_name_padding = 1 + it.table->headers[cpp_name.index].longest_string - cpp_name.column.string.size;
Dqn_Str8 cpp_value_str8 = Dqn_Str8_HasData(cpp_value.column.string) ? cpp_value.column.string : Dqn_Str8_InitF(scratch.arena, "%zu", row_index);
Dqn_CppLine(cpp,
"{%2d, DQN_STR8(\"%.*s\"),%*s/*value*/ %.*s, /*offset_of*/ 0, sizeof(%.*s), alignof(%.*s), DQN_STR8(\"\"), %.*s_Type_%.*s, /*is_pointer*/ false, /*array_size*/ 0, /*array_size_field*/ NULL},",
row_index,
// NOTE: Name string
DQN_STR_FMT(cpp_name.column.string),
cpp_name_padding, "",
// NOTE: Value
DQN_STR_FMT(cpp_value_str8),
// NOTE: sizeof(a)
DQN_STR_FMT(struct_or_enum_name),
// NOTE: alignof(a)
DQN_STR_FMT(struct_or_enum_name),
// NOTE: ..._Type_...
DQN_STR_FMT(emit_prefix),
DQN_STR_FMT(struct_or_enum_name));
}
}
}
}
}
int longest_name_across_all_tables = 0;
for (Dqn_CGenTable *table = cgen->first_table; table != 0; table = table->next) {
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it);) {
longest_name_across_all_tables = DQN_MAX(longest_name_across_all_tables, DQN_CAST(int)it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string.size);
}
}
Dqn_CppBlock(cpp, ";\n\n", "Dqn_TypeInfo const g_%.*s_types[] =", DQN_STR_FMT(emit_prefix)) {
Dqn_CppLine(cpp, "{DQN_STR8(\"\"),%*sDqn_TypeKind_Nil, 0, /*fields*/ NULL, /*count*/ 0},", 1 + longest_name_across_all_tables, "");
for (Dqn_CGenTable *table = cgen->first_table; table != 0; table = table->next) {
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it);) {
Dqn_Str8 type_name = it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string;
Dqn_Scratch scratch = Dqn_Scratch_Get(nullptr);
int name_padding = 1 + longest_name_across_all_tables - DQN_CAST(int) type_name.size;
Dqn_Str8 type_info_kind = {};
char const *type_info_kind_padding = "";
if (table->type == Dqn_CGenTableType_CodeGenEnum) {
type_info_kind = DQN_STR8("Dqn_TypeKind_Enum");
type_info_kind_padding = " ";
} else if (table->type == Dqn_CGenTableType_CodeGenStruct) {
type_info_kind = DQN_STR8("Dqn_TypeKind_Struct");
} else {
DQN_ASSERT(table->type == Dqn_CGenTableType_CodeGenBuiltinTypes);
type_info_kind = DQN_STR8("Dqn_TypeKind_Basic");
type_info_kind_padding = " ";
}
Dqn_Str8 fields_count = {};
if (table->type == Dqn_CGenTableType_CodeGenBuiltinTypes) {
fields_count = DQN_STR8("0");
} else {
DQN_ASSERT(table->type == Dqn_CGenTableType_CodeGenStruct || table->type == Dqn_CGenTableType_CodeGenEnum);
int fields_count_int = 0;
for (Dqn_usize row_index = 0; row_index < it.table->row_count; row_index++) {
Dqn_CGenTableRow const *row = it.table->rows + row_index;
Dqn_CGenLookupColumnAtHeader cpp_name = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppName].string, row);
fields_count_int += Dqn_Str8_HasData(cpp_name.column.string);
}
fields_count = Dqn_Str8_InitF(scratch.arena, "%d", fields_count_int);
}
Dqn_Str8 fields = DQN_STR8("NULL");
int fields_padding = 1;
if (table->type != Dqn_CGenTableType_CodeGenBuiltinTypes) {
fields_padding = name_padding;
fields = Dqn_Str8_InitF(scratch.arena, "g_%.*s_type_fields", DQN_STR_FMT(type_name));
}
Dqn_CppLine(cpp,
"{DQN_STR8(\"%.*s\"),%*s%.*s, %ssizeof(%.*s),%*s/*fields*/ %.*s,%*s/*count*/ %.*s},",
DQN_STR_FMT(type_name),
name_padding, "",
DQN_STR_FMT(type_info_kind),
type_info_kind_padding,
DQN_STR_FMT(type_name),
name_padding, "",
DQN_STR_FMT(fields),
fields_padding, "",
DQN_STR_FMT(fields_count));
}
}
}
// NOTE: Str8 to enum conversion ////////////////////////////////////////////////////////////
for (Dqn_CGenTable *table = cgen->first_table; table != 0; table = table->next) {
if (table->type != Dqn_CGenTableType_CodeGenEnum)
continue;
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it);) {
Dqn_Str8 type_name = it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string;
Dqn_CppFuncBlock(cpp, "%.*sStr8ToEnumResult %.*s_Str8ToEnum(Dqn_Str8 string)", DQN_STR_FMT(type_name), DQN_STR_FMT(type_name)) {
Dqn_CppLine(cpp, "%.*sStr8ToEnumResult result = {};", DQN_STR_FMT(type_name));
Dqn_CppForBlock(cpp, "Dqn_usize index = 0; !result.success && index < DQN_ARRAY_UCOUNT(g_%.*s_type_fields); index++", DQN_STR_FMT(type_name)) {
Dqn_CppIfChain(cpp) {
Dqn_CppLine(cpp, "Dqn_TypeField field = g_%.*s_type_fields[index];", DQN_STR_FMT(type_name));
Dqn_CppIfOrElseIfBlock(cpp, "string == field.name") {
Dqn_CppLine(cpp, "result.success = true;");
Dqn_CppLine(cpp, "result.value = (%.*s)index;", DQN_STR_FMT(type_name));
}
}
}
Dqn_CppLine(cpp, "return result;");
}
}
}
// NOTE: Operator == and != ////////////////////////////////////////////////////////////////
for (Dqn_CGenTable *table = cgen->first_table; table != 0; table = table->next) {
if (table->type != Dqn_CGenTableType_CodeGenStruct)
continue;
for (Dqn_CGenLookupTableIterator it = {}; Dqn_CGen_LookupNextTableInCodeGenTable(cgen, table, &it);) {
Dqn_Str8 cpp_op_equals = it.cgen_table_column[Dqn_CGenTableHeaderType_CppOpEquals].string;
if (cpp_op_equals != DQN_STR8("true"))
continue;
Dqn_Str8 type_name = it.cgen_table_column[Dqn_CGenTableHeaderType_Name].string;
Dqn_CppFuncBlock(cpp, "bool operator==(%.*s const &lhs, %.*s const &rhs)", DQN_STR_FMT(type_name), DQN_STR_FMT(type_name)) {
for (Dqn_usize row_index = 0; row_index < it.table->row_count; row_index++) {
Dqn_CGenTableRow const *row = it.table->rows + row_index;
Dqn_CGenLookupColumnAtHeader cpp_name = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppName].string, row);
Dqn_CGenLookupColumnAtHeader cpp_is_ptr = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppIsPtr].string, row);
Dqn_CGenLookupColumnAtHeader cpp_array_size = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppArraySize].string, row);
Dqn_CGenLookupColumnAtHeader cpp_array_size_field = Dqn_CGen_LookupColumnAtHeader(it.table, it.cgen_table_column[Dqn_CGenTableHeaderType_CppArraySizeField].string, row);
// TODO(doyle): Check if we're an integral type or not to double check if we
// can use memcmp or operator==
if (Dqn_Str8_HasData(cpp_array_size_field.column.string)) {
Dqn_CppIfChain(cpp) {
Dqn_CppIfOrElseIfBlock(cpp,
"lhs.%.*s != rhs.%.*s",
DQN_STR_FMT(cpp_array_size_field.column.string),
DQN_STR_FMT(cpp_array_size_field.column.string)) {
Dqn_CppLine(cpp, "return false;");
}
}
Dqn_CppIfChain(cpp) {
Dqn_CppIfOrElseIfBlock(cpp,
"DQN_MEMCMP(lhs.%.*s, rhs.%.*s, lhs.%.*s) != 0",
DQN_STR_FMT(cpp_name.column.string),
DQN_STR_FMT(cpp_name.column.string),
DQN_STR_FMT(cpp_array_size_field.column.string)) {
Dqn_CppLine(cpp, "return false;");
}
}
} else if (Dqn_Str8_HasData(cpp_array_size.column.string)) {
Dqn_CppIfChain(cpp) {
Dqn_CppIfOrElseIfBlock(cpp,
"DQN_MEMCMP(lhs.%.*s, rhs.%.*s, %.*s) != 0",
DQN_STR_FMT(cpp_name.column.string),
DQN_STR_FMT(cpp_name.column.string),
DQN_STR_FMT(cpp_array_size.column.string)) {
Dqn_CppLine(cpp, "return false;");
}
}
} else if (cpp_is_ptr.column.string == DQN_STR8("true")) {
Dqn_CppIfChain(cpp) {
Dqn_CppIfOrElseIfBlock(cpp,
"*lhs.%.*s != *rhs.%.*s",
DQN_STR_FMT(cpp_name.column.string),
DQN_STR_FMT(cpp_name.column.string)) {
Dqn_CppLine(cpp, "return false;");
}
}
} else {
Dqn_CppIfChain(cpp) {
Dqn_CppIfOrElseIfBlock(cpp,
"lhs.%.*s != rhs.%.*s",
DQN_STR_FMT(cpp_name.column.string),
DQN_STR_FMT(cpp_name.column.string)) {
Dqn_CppLine(cpp, "return false;");
}
}
}
}
Dqn_CppLine(cpp, "return true;");
}
Dqn_CppFuncBlock(cpp, "bool operator!=(%.*s const &lhs, %.*s const &rhs)", DQN_STR_FMT(type_name), DQN_STR_FMT(type_name)) {
Dqn_CppLine(cpp, "bool result = !(lhs == rhs);");
Dqn_CppLine(cpp, "return result;");
}
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink