mirror of
https://github.com/Ed94/gencpp.git
synced 2024-12-22 15:54:45 -08:00
WIP: Broken af
This commit is contained in:
parent
4d638a7255
commit
451b71884c
@ -155,12 +155,14 @@ int gen_main()
|
|||||||
|
|
||||||
case CT_Enum:
|
case CT_Enum:
|
||||||
{
|
{
|
||||||
CodeEnum enum_def = cast(CodeEnum, entry);
|
log_fmt("Detected ENUM: %S", entry->Name);
|
||||||
CodeTypedef typedef_enum = parse_typedef(token_fmt("name", enum_def->Name, stringize( typedef enum <name> <name>; )));
|
convert_cpp_enum_to_c(cast(CodeEnum, entry), types);
|
||||||
types.append(enum_def);
|
|
||||||
types.append(typedef_enum);
|
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
|
|
||||||
|
default:
|
||||||
|
types.append(entry);
|
||||||
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
@ -170,7 +172,7 @@ int gen_main()
|
|||||||
Code inlines = scan_file( project_dir "components/inlines.hpp" );
|
Code inlines = scan_file( project_dir "components/inlines.hpp" );
|
||||||
Code header_end = scan_file( project_dir "components/header_end.hpp" );
|
Code header_end = scan_file( project_dir "components/header_end.hpp" );
|
||||||
|
|
||||||
CodeBody ecode = gen_ecode ( project_dir "enums/ECode.csv", helper_use_c_definition );
|
CodeBody ecode = gen_ecode ( project_dir "enums/ECodeTypes.csv", helper_use_c_definition );
|
||||||
CodeBody eoperator = gen_eoperator ( project_dir "enums/EOperator.csv", helper_use_c_definition );
|
CodeBody eoperator = gen_eoperator ( project_dir "enums/EOperator.csv", helper_use_c_definition );
|
||||||
CodeBody especifier = gen_especifier( project_dir "enums/ESpecifier.csv", helper_use_c_definition );
|
CodeBody especifier = gen_especifier( project_dir "enums/ESpecifier.csv", helper_use_c_definition );
|
||||||
|
|
||||||
@ -193,13 +195,7 @@ int gen_main()
|
|||||||
//++ entry; // Consume endif
|
//++ entry; // Consume endif
|
||||||
}
|
}
|
||||||
|
|
||||||
b32 found = ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_MEMBER_FEATURES"), entry, parsed_ast, ast );
|
b32 found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP"), entry, parsed_ast, ast);
|
||||||
if (found) break;
|
|
||||||
|
|
||||||
found = ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_REFERENCES"), entry, parsed_ast, ast);
|
|
||||||
if (found) break;
|
|
||||||
|
|
||||||
found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP"), entry, parsed_ast, ast);
|
|
||||||
if (found) break;
|
if (found) break;
|
||||||
|
|
||||||
ast.append(entry);
|
ast.append(entry);
|
||||||
@ -209,10 +205,21 @@ int gen_main()
|
|||||||
case CT_Struct_Fwd:
|
case CT_Struct_Fwd:
|
||||||
{
|
{
|
||||||
CodeStruct fwd = cast(CodeStruct, entry);
|
CodeStruct fwd = cast(CodeStruct, entry);
|
||||||
if (fwd->Name.starts_with(txt("AST"))) {
|
CodeTypedef tdef = parse_typedef(token_fmt("name", fwd->Name, stringize( typedef struct <name> <name>; )));
|
||||||
ast.append(fwd);
|
ast.append(fwd);
|
||||||
CodeTypedef td = parse_typedef(token_fmt("name", fwd->Name, stringize( typedef struct <name> <name>; )));
|
ast.append(tdef);
|
||||||
ast.append(td);
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
|
case CT_Struct:
|
||||||
|
{
|
||||||
|
|
||||||
|
CodeStruct struct_def = cast(CodeStruct, entry);
|
||||||
|
ast.append(struct_def);
|
||||||
|
if ( ! entry->Name.is_equal(txt("AST")))
|
||||||
|
{
|
||||||
|
CodeTypedef tdef = parse_typedef(token_fmt("name", struct_def->Name, stringize( typedef struct <name> <name>; )));
|
||||||
|
ast.append(tdef);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
@ -221,7 +228,7 @@ int gen_main()
|
|||||||
{
|
{
|
||||||
CodeVar var = cast(CodeVar, entry);
|
CodeVar var = cast(CodeVar, entry);
|
||||||
|
|
||||||
s32 constexpr_found = var->Specs.remove( Spec_Constexpr );
|
s32 constexpr_found = var->Specs ? var->Specs.remove( Spec_Constexpr ) : - 1;
|
||||||
if (constexpr_found > -1) {
|
if (constexpr_found > -1) {
|
||||||
log_fmt("Found constexpr: %S\n", entry.to_string());
|
log_fmt("Found constexpr: %S\n", entry.to_string());
|
||||||
if (var->Name.contains(txt("AST_ArrSpecs_Cap")))
|
if (var->Name.contains(txt("AST_ArrSpecs_Cap")))
|
||||||
@ -323,6 +330,18 @@ R"(#define AST_ArrSpecs_Cap \
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
|
case CT_Enum:
|
||||||
|
{
|
||||||
|
convert_cpp_enum_to_c(cast(CodeEnum, entry), memory);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case CT_Struct_Fwd:
|
||||||
|
{
|
||||||
|
CodeTypedef tdef = parse_typedef(token_fmt("name", entry->Name, stringize( typedef struct <name> <name>; )));
|
||||||
|
memory.append(entry);
|
||||||
|
memory.append(tdef);
|
||||||
|
}
|
||||||
|
break;
|
||||||
case CT_Class:
|
case CT_Class:
|
||||||
case CT_Struct:
|
case CT_Struct:
|
||||||
{
|
{
|
||||||
@ -332,7 +351,7 @@ R"(#define AST_ArrSpecs_Cap \
|
|||||||
(body_entry->Type) {
|
(body_entry->Type) {
|
||||||
case CT_Preprocess_If:
|
case CT_Preprocess_If:
|
||||||
{
|
{
|
||||||
ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_MEMBER_FEATURES"), body_entry, body, new_body );
|
ignore_preprocess_cond_block(txt("! GEN_C_LIKE_CPP"), body_entry, body, new_body );
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
|
|
||||||
@ -340,17 +359,16 @@ R"(#define AST_ArrSpecs_Cap \
|
|||||||
new_body.append(body_entry);
|
new_body.append(body_entry);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
entry->Body = new_body;
|
entry->Body = new_body;
|
||||||
|
|
||||||
|
CodeTypedef tdef = parse_typedef(token_fmt("name", entry->Name, stringize( typedef struct <name> <name>; )));
|
||||||
memory.append(entry);
|
memory.append(entry);
|
||||||
|
memory.append(tdef);
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
case CT_Preprocess_If:
|
case CT_Preprocess_If:
|
||||||
{
|
{
|
||||||
b32 found = ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_MEMBER_FEATURES"), entry, parsed_memory, memory );
|
b32 found = ignore_preprocess_cond_block(txt("! GEN_C_LIKE_CPP"), entry, parsed_memory, memory );
|
||||||
if (found) break;
|
|
||||||
|
|
||||||
found = ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_REFERENCES"), entry, parsed_memory, memory );
|
|
||||||
if (found) break;
|
if (found) break;
|
||||||
|
|
||||||
memory.append(entry);
|
memory.append(entry);
|
||||||
@ -418,28 +436,28 @@ R"(#define AST_ArrSpecs_Cap \
|
|||||||
|
|
||||||
CodeBody parsed_strings = parse_file( project_dir "dependencies/strings.hpp" );
|
CodeBody parsed_strings = parse_file( project_dir "dependencies/strings.hpp" );
|
||||||
CodeBody strings = def_body(CT_Global_Body);
|
CodeBody strings = def_body(CT_Global_Body);
|
||||||
for ( Code entry = parsed_strings.begin(); entry != parsed_strings.end(); ++ entry )
|
for ( Code entry = parsed_strings.begin(); entry != parsed_strings.end(); ++ entry ) switch (entry->Type)
|
||||||
{
|
|
||||||
switch (entry->Type)
|
|
||||||
{
|
{
|
||||||
case CT_Preprocess_If:
|
case CT_Preprocess_If:
|
||||||
{
|
{
|
||||||
CodePreprocessCond cond = cast(CodePreprocessCond, entry);
|
CodePreprocessCond cond = cast(CodePreprocessCond, entry);
|
||||||
if (cond->Content.starts_with(txt("GEN_COMPILER_C || ! GEN_SUPPORT_CPP_MEMBER_FEATURES")))
|
if (cond->Content.is_equal(txt("GEN_COMPILER_C")))
|
||||||
{
|
{
|
||||||
for (; entry != end(parsed_strings) && entry->Type != CT_Typedef; ++ entry) {}
|
++ entry; // Remove #if GEN_COMPILER_C
|
||||||
strings.append(entry);
|
for ( ; entry->Type != CT_Preprocess_Else
|
||||||
strings.append(fmt_newline);
|
&& entry->Type != CT_Preprocess_EndIf; ++ entry ) {
|
||||||
|
strings.append(entry); // Preserve content
|
||||||
for (; entry != end(parsed_strings) && entry->Type != CT_Preprocess_EndIf; ++ entry) {}
|
}
|
||||||
++ entry;
|
for ( ; entry->Type != CT_Preprocess_EndIf; ++ entry ) {} // Discard C++
|
||||||
|
// #endif discarded by for loop
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
bool found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP"), entry, parsed_strings, strings);
|
bool found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP"), entry, parsed_strings, strings);
|
||||||
if (found) break;
|
if (found) break;
|
||||||
|
|
||||||
found = ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_REFERENCES"), entry, parsed_strings, strings );
|
found = ignore_preprocess_cond_block(txt("GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP"), entry, parsed_strings, strings);
|
||||||
|
if (found) break;
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
|
|
||||||
@ -449,6 +467,13 @@ R"(#define AST_ArrSpecs_Cap \
|
|||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
|
|
||||||
|
case CT_Preprocess_IfNotDef:
|
||||||
|
{
|
||||||
|
log_fmt("\nIFNDEF: %SC\n", entry->Content);
|
||||||
|
strings.append(entry);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
case CT_Struct_Fwd:
|
case CT_Struct_Fwd:
|
||||||
{
|
{
|
||||||
if ( entry->Name.is_equal(txt("String")) )
|
if ( entry->Name.is_equal(txt("String")) )
|
||||||
@ -459,6 +484,11 @@ R"(#define AST_ArrSpecs_Cap \
|
|||||||
++ entry;
|
++ entry;
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
CodeTypedef c_def = parse_typedef(token_fmt("name", entry->Name, stringize( typedef struct <name> <name>; )));
|
||||||
|
strings.append(c_def);
|
||||||
|
}
|
||||||
strings.append(entry);
|
strings.append(entry);
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
@ -505,7 +535,6 @@ R"(#define AST_ArrSpecs_Cap \
|
|||||||
strings.append(entry);
|
strings.append(entry);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
|
||||||
|
|
||||||
CodeBody parsed_filesystem = parse_file( project_dir "dependencies/filesystem.hpp" );
|
CodeBody parsed_filesystem = parse_file( project_dir "dependencies/filesystem.hpp" );
|
||||||
CodeBody filesystem = def_body(CT_Global_Body);
|
CodeBody filesystem = def_body(CT_Global_Body);
|
||||||
@ -521,6 +550,30 @@ R"(#define AST_ArrSpecs_Cap \
|
|||||||
filesystem.append(entry);
|
filesystem.append(entry);
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
|
|
||||||
|
case CT_Enum:
|
||||||
|
case CT_Enum_Fwd:
|
||||||
|
case CT_Struct_Fwd:
|
||||||
|
case CT_Struct:
|
||||||
|
case CT_Union:
|
||||||
|
case CT_Union_Fwd:
|
||||||
|
{
|
||||||
|
if (entry->Name.is_equal(txt("FileOperations")))
|
||||||
|
continue;
|
||||||
|
|
||||||
|
// StrC type_str = codetype_to_keyword_str(entry->Type);
|
||||||
|
// StrC formated_tmpl = token_fmt_impl( 3,
|
||||||
|
// "type", type_str
|
||||||
|
// , "name", entry->Name,
|
||||||
|
// stringize(
|
||||||
|
// typedef <type> <name> <name>;
|
||||||
|
// ));
|
||||||
|
// CodeTypedef tdef = parse_typedef(formated_tmpl);
|
||||||
|
// filesystem.append(entry);
|
||||||
|
// filesystem.append(tdef);
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
|
||||||
case CT_Variable:
|
case CT_Variable:
|
||||||
{
|
{
|
||||||
CodeVar var = cast(CodeVar, entry);
|
CodeVar var = cast(CodeVar, entry);
|
||||||
|
@ -3,11 +3,26 @@
|
|||||||
|
|
||||||
using namespace gen;
|
using namespace gen;
|
||||||
|
|
||||||
|
void convert_cpp_enum_to_c( CodeEnum to_convert, CodeBody to_append )
|
||||||
|
{
|
||||||
|
#pragma push_macro("enum_underlying")
|
||||||
|
#undef enum_underlying
|
||||||
|
if (to_convert->UnderlyingType)
|
||||||
|
{
|
||||||
|
to_convert->UnderlyingTypeMacro = untyped_str(token_fmt("type", to_convert->UnderlyingType->Name, stringize(enum_underlying(<type>))));
|
||||||
|
to_convert->UnderlyingType = CodeTypename{nullptr};
|
||||||
|
}
|
||||||
|
CodeTypedef tdef = parse_typedef(token_fmt("name", to_convert->Name, stringize( typedef enum <name> <name>; )));
|
||||||
|
to_append.append(to_convert);
|
||||||
|
to_append.append(tdef);
|
||||||
|
#pragma pop_macro("enum_underlying")
|
||||||
|
}
|
||||||
|
|
||||||
b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& parsed_body, CodeBody& body )
|
b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& parsed_body, CodeBody& body )
|
||||||
{
|
{
|
||||||
b32 found = false;
|
b32 found = false;
|
||||||
CodePreprocessCond cond = cast(CodePreprocessCond, entry_iter);
|
CodePreprocessCond cond = cast(CodePreprocessCond, entry_iter);
|
||||||
if ( cond->Content.contains(cond_sig) )
|
if ( cond->Content.is_equal(cond_sig) )
|
||||||
{
|
{
|
||||||
log_fmt("Preprocess cond found: %SC\n", cond->Content);
|
log_fmt("Preprocess cond found: %SC\n", cond->Content);
|
||||||
found = true;
|
found = true;
|
||||||
|
@ -155,7 +155,7 @@ int gen_main()
|
|||||||
Code inlines = scan_file( project_dir "components/inlines.hpp" );
|
Code inlines = scan_file( project_dir "components/inlines.hpp" );
|
||||||
Code header_end = scan_file( project_dir "components/header_end.hpp" );
|
Code header_end = scan_file( project_dir "components/header_end.hpp" );
|
||||||
|
|
||||||
CodeBody ecode = gen_ecode ( project_dir "enums/ECode.csv" );
|
CodeBody ecode = gen_ecode ( project_dir "enums/ECodeTypes.csv" );
|
||||||
CodeBody eoperator = gen_eoperator ( project_dir "enums/EOperator.csv" );
|
CodeBody eoperator = gen_eoperator ( project_dir "enums/EOperator.csv" );
|
||||||
CodeBody especifier = gen_especifier( project_dir "enums/ESpecifier.csv" );
|
CodeBody especifier = gen_especifier( project_dir "enums/ESpecifier.csv" );
|
||||||
CodeBody ast_inlines = gen_ast_inlines();
|
CodeBody ast_inlines = gen_ast_inlines();
|
||||||
|
@ -217,7 +217,7 @@ int gen_main()
|
|||||||
Code inlines = scan_file( project_dir "components/inlines.hpp" );
|
Code inlines = scan_file( project_dir "components/inlines.hpp" );
|
||||||
Code header_end = scan_file( project_dir "components/header_end.hpp" );
|
Code header_end = scan_file( project_dir "components/header_end.hpp" );
|
||||||
|
|
||||||
CodeBody ecode = gen_ecode ( project_dir "enums/ECode.csv" );
|
CodeBody ecode = gen_ecode ( project_dir "enums/ECodeTypes.csv" );
|
||||||
CodeBody eoperator = gen_eoperator ( project_dir "enums/EOperator.csv" );
|
CodeBody eoperator = gen_eoperator ( project_dir "enums/EOperator.csv" );
|
||||||
CodeBody especifier = gen_especifier( project_dir "enums/ESpecifier.csv" );
|
CodeBody especifier = gen_especifier( project_dir "enums/ESpecifier.csv" );
|
||||||
CodeBody ast_inlines = gen_ast_inlines();
|
CodeBody ast_inlines = gen_ast_inlines();
|
||||||
|
@ -160,7 +160,7 @@ int gen_main()
|
|||||||
Code inlines = scan_file( "components/inlines.hpp" );
|
Code inlines = scan_file( "components/inlines.hpp" );
|
||||||
Code header_end = scan_file( "components/header_end.hpp" );
|
Code header_end = scan_file( "components/header_end.hpp" );
|
||||||
|
|
||||||
CodeBody ecode = gen_ecode ( "enums/ECode.csv" );
|
CodeBody ecode = gen_ecode ( "enums/ECodeTypes.csv" );
|
||||||
CodeBody eoperator = gen_eoperator ( "enums/EOperator.csv" );
|
CodeBody eoperator = gen_eoperator ( "enums/EOperator.csv" );
|
||||||
CodeBody especifier = gen_especifier( "enums/ESpecifier.csv" );
|
CodeBody especifier = gen_especifier( "enums/ESpecifier.csv" );
|
||||||
CodeBody ast_inlines = gen_ast_inlines();
|
CodeBody ast_inlines = gen_ast_inlines();
|
||||||
|
@ -20,7 +20,7 @@ char const* code_debug_str(Code self)
|
|||||||
|
|
||||||
string_append_fmt( result, "\n\tName : %S", self->Name ? self->Name : "Null" );
|
string_append_fmt( result, "\n\tName : %S", self->Name ? self->Name : "Null" );
|
||||||
string_append_fmt( result, "\n\tType : %S", code_type_str(self) );
|
string_append_fmt( result, "\n\tType : %S", code_type_str(self) );
|
||||||
string_append_fmt( result, "\n\tModule Flags : %S", to_str( self->ModuleFlags ) );
|
string_append_fmt( result, "\n\tModule Flags : %S", module_flag_to_str( self->ModuleFlags ) );
|
||||||
|
|
||||||
switch ( self->Type )
|
switch ( self->Type )
|
||||||
{
|
{
|
||||||
@ -64,7 +64,7 @@ char const* code_debug_str(Code self)
|
|||||||
|
|
||||||
string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" );
|
string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" );
|
||||||
string_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? code_to_string(self->Attributes) : "Null" );
|
string_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? code_to_string(self->Attributes) : "Null" );
|
||||||
string_append_fmt( result, "\n\tParentAccess: %s", self->ParentType ? to_str( self->ParentAccess ) : "No Parent" );
|
string_append_fmt( result, "\n\tParentAccess: %s", self->ParentType ? access_spec_to_str( self->ParentAccess ) : "No Parent" );
|
||||||
string_append_fmt( result, "\n\tParentType : %s", self->ParentType ? code_type_str(self->ParentType) : "Null" );
|
string_append_fmt( result, "\n\tParentType : %s", self->ParentType ? code_type_str(self->ParentType) : "Null" );
|
||||||
string_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : "Null" );
|
string_append_fmt( result, "\n\tBody : %S", self->Body ? code_debug_str(self->Body) : "Null" );
|
||||||
break;
|
break;
|
||||||
@ -78,7 +78,7 @@ char const* code_debug_str(Code self)
|
|||||||
|
|
||||||
string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" );
|
string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" );
|
||||||
string_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? code_to_string(self->Attributes) : "Null" );
|
string_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? code_to_string(self->Attributes) : "Null" );
|
||||||
string_append_fmt( result, "\n\tParentAccess: %s", self->ParentType ? to_str( self->ParentAccess ) : "No Parent" );
|
string_append_fmt( result, "\n\tParentAccess: %s", self->ParentType ? access_spec_to_str( self->ParentAccess ) : "No Parent" );
|
||||||
string_append_fmt( result, "\n\tParentType : %s", self->ParentType ? code_type_str(self->ParentType) : "Null" );
|
string_append_fmt( result, "\n\tParentType : %s", self->ParentType ? code_type_str(self->ParentType) : "Null" );
|
||||||
break;
|
break;
|
||||||
|
|
||||||
|
@ -153,7 +153,9 @@ Define_Code(Var);
|
|||||||
#undef Define_Code
|
#undef Define_Code
|
||||||
|
|
||||||
GEN_NS_PARSER_BEGIN
|
GEN_NS_PARSER_BEGIN
|
||||||
|
|
||||||
struct Token;
|
struct Token;
|
||||||
|
|
||||||
GEN_NS_PARSER_END
|
GEN_NS_PARSER_END
|
||||||
|
|
||||||
#if GEN_COMPILER_CPP
|
#if GEN_COMPILER_CPP
|
||||||
@ -380,12 +382,13 @@ static_assert( sizeof(AST) == AST_POD_Size, "ERROR: AST POD is not size of AST_P
|
|||||||
struct InvalidCode_ImplictCaster;
|
struct InvalidCode_ImplictCaster;
|
||||||
#define InvalidCode (InvalidCode_ImplictCaster{})
|
#define InvalidCode (InvalidCode_ImplictCaster{})
|
||||||
#else
|
#else
|
||||||
#define InvalidCode { (AST*)Code_Invalid }
|
#define InvalidCode { (void*)Code_Invalid }
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if GEN_COMPILER_CPP
|
#if GEN_COMPILER_CPP
|
||||||
|
struct NullCode_ImplicitCaster;
|
||||||
// Used when the its desired when omission is allowed in a definition.
|
// Used when the its desired when omission is allowed in a definition.
|
||||||
#define NullCode { nullptr }
|
#define NullCode (NullCode_ImplicitCaster{})
|
||||||
#else
|
#else
|
||||||
#define NullCode nullptr
|
#define NullCode nullptr
|
||||||
#endif
|
#endif
|
||||||
|
@ -184,7 +184,7 @@ void class_to_string_def( CodeClass self, String* result )
|
|||||||
|
|
||||||
if ( self->ParentType )
|
if ( self->ParentType )
|
||||||
{
|
{
|
||||||
char const* access_level = to_str( self->ParentAccess );
|
char const* access_level = access_spec_to_str( self->ParentAccess );
|
||||||
|
|
||||||
string_append_fmt( result, "%SC : %s %S", self->Name, access_level, typename_to_string(self->ParentType) );
|
string_append_fmt( result, "%SC : %s %S", self->Name, access_level, typename_to_string(self->ParentType) );
|
||||||
|
|
||||||
@ -368,7 +368,10 @@ void enum_to_string_fwd(CodeEnum self, String* result )
|
|||||||
if ( self->UnderlyingType )
|
if ( self->UnderlyingType )
|
||||||
string_append_fmt( result, "enum %SC : %S", self->Name, typename_to_string(self->UnderlyingType) );
|
string_append_fmt( result, "enum %SC : %S", self->Name, typename_to_string(self->UnderlyingType) );
|
||||||
else if (self->UnderlyingTypeMacro)
|
else if (self->UnderlyingTypeMacro)
|
||||||
string_append_fmt( result, "enum %SC %S", self->Name, typename_to_string(self->UnderlyingType) );
|
{
|
||||||
|
log_fmt("IDENTIFIED A UNDERLYING ENUM MACRO");
|
||||||
|
string_append_fmt( result, "enum %SC %S", self->Name, code_to_string(self->UnderlyingTypeMacro) );
|
||||||
|
}
|
||||||
else
|
else
|
||||||
string_append_fmt( result, "enum %SC", self->Name );
|
string_append_fmt( result, "enum %SC", self->Name );
|
||||||
|
|
||||||
@ -1033,7 +1036,7 @@ void struct_to_string_def( CodeStruct self, String* result )
|
|||||||
|
|
||||||
if ( self->ParentType )
|
if ( self->ParentType )
|
||||||
{
|
{
|
||||||
char const* access_level = to_str( self->ParentAccess );
|
char const* access_level = access_spec_to_str( self->ParentAccess );
|
||||||
|
|
||||||
string_append_fmt( result, "%SC : %s %S", self->Name, access_level, typename_to_string(self->ParentType) );
|
string_append_fmt( result, "%SC : %s %S", self->Name, access_level, typename_to_string(self->ParentType) );
|
||||||
|
|
||||||
|
@ -911,10 +911,6 @@ struct CodeVar
|
|||||||
#undef Using_Code
|
#undef Using_Code
|
||||||
#undef Using_CodeOps
|
#undef Using_CodeOps
|
||||||
|
|
||||||
#if GEN_SUPPORT_CPP_REFERENCES
|
|
||||||
void to_string_export( CodeBody body, String& result ) { return body_to_string_export(body, & result); };
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#undef Verify_POD
|
#undef Verify_POD
|
||||||
|
|
||||||
struct InvalidCode_ImplictCaster
|
struct InvalidCode_ImplictCaster
|
||||||
@ -951,6 +947,38 @@ struct InvalidCode_ImplictCaster
|
|||||||
operator CodeVar () const { return cast(CodeVar, Code_Invalid); }
|
operator CodeVar () const { return cast(CodeVar, Code_Invalid); }
|
||||||
};
|
};
|
||||||
|
|
||||||
|
struct NullCode_ImplicitCaster
|
||||||
|
{
|
||||||
|
operator Code () const { return {nullptr}; }
|
||||||
|
operator CodeBody () const { return {(AST_Body*) nullptr}; }
|
||||||
|
operator CodeAttributes () const { return {(AST_Attributes*)nullptr}; }
|
||||||
|
operator CodeComment () const { return {nullptr}; }
|
||||||
|
operator CodeClass () const { return {nullptr}; }
|
||||||
|
operator CodeConstructor () const { return {nullptr}; }
|
||||||
|
operator CodeDefine () const { return {nullptr}; }
|
||||||
|
operator CodeDestructor () const { return {nullptr}; }
|
||||||
|
operator CodeExec () const { return {nullptr}; }
|
||||||
|
operator CodeEnum () const { return {nullptr}; }
|
||||||
|
operator CodeExtern () const { return {nullptr}; }
|
||||||
|
operator CodeInclude () const { return {nullptr}; }
|
||||||
|
operator CodeFriend () const { return {nullptr}; }
|
||||||
|
operator CodeFn () const { return {nullptr}; }
|
||||||
|
operator CodeModule () const { return {nullptr}; }
|
||||||
|
operator CodeNS () const { return {nullptr}; }
|
||||||
|
operator CodeOperator () const { return {nullptr}; }
|
||||||
|
operator CodeOpCast () const { return {nullptr}; }
|
||||||
|
operator CodeParam () const { return {nullptr}; }
|
||||||
|
operator CodePragma () const { return {nullptr}; }
|
||||||
|
operator CodePreprocessCond() const { return {nullptr}; }
|
||||||
|
operator CodeSpecifiers () const { return {nullptr}; }
|
||||||
|
operator CodeStruct () const { return {nullptr}; }
|
||||||
|
operator CodeTemplate () const { return {nullptr}; }
|
||||||
|
operator CodeTypename () const { return CodeTypename{(AST_Typename*)nullptr}; }
|
||||||
|
operator CodeTypedef () const { return {nullptr}; }
|
||||||
|
operator CodeUnion () const { return {nullptr}; }
|
||||||
|
operator CodeUsing () const { return {nullptr}; }
|
||||||
|
operator CodeVar () const { return {nullptr}; }
|
||||||
|
};
|
||||||
|
|
||||||
#if ! GEN_C_LIKE_CPP
|
#if ! GEN_C_LIKE_CPP
|
||||||
GEN_OPTIMIZE_MAPPINGS_BEGIN
|
GEN_OPTIMIZE_MAPPINGS_BEGIN
|
||||||
|
File diff suppressed because it is too large
Load Diff
@ -7,73 +7,212 @@
|
|||||||
|
|
||||||
enum CodeType : u32
|
enum CodeType : u32
|
||||||
{
|
{
|
||||||
CT_Invalid,CT_Untyped,CT_NewLine,CT_Comment,CT_Access_Private,CT_Access_Protected,CT_Access_Public,CT_PlatformAttributes,CT_Class,CT_Class_Fwd,CT_Class_Body,CT_Constructor,CT_Constructor_Fwd,CT_Destructor,CT_Destructor_Fwd,CT_Enum,CT_Enum_Fwd,CT_Enum_Body,CT_Enum_Class,CT_Enum_Class_Fwd,CT_Execution,CT_Export_Body,CT_Extern_Linkage,CT_Extern_Linkage_Body,CT_Friend,CT_Function,CT_Function_Fwd,CT_Function_Body,CT_Global_Body,CT_Module,CT_Namespace,CT_Namespace_Body,CT_Operator,CT_Operator_Fwd,CT_Operator_Member,CT_Operator_Member_Fwd,CT_Operator_Cast,CT_Operator_Cast_Fwd,CT_Parameters,CT_Preprocess_Define,CT_Preprocess_Include,CT_Preprocess_If,CT_Preprocess_IfDef,CT_Preprocess_IfNotDef,CT_Preprocess_ElIf,CT_Preprocess_Else,CT_Preprocess_EndIf,CT_Preprocess_Pragma,CT_Specifiers,CT_Struct,CT_Struct_Fwd,CT_Struct_Body,CT_Template,CT_Typedef,CT_Typename,CT_Union,CT_Union_Fwd,CT_Union_Body,CT_Using,CT_Using_Namespace,CT_Variable,CT_NumTypes
|
CT_Invalid,
|
||||||
|
CT_Untyped,
|
||||||
|
CT_NewLine,
|
||||||
|
CT_Comment,
|
||||||
|
CT_Access_Private,
|
||||||
|
CT_Access_Protected,
|
||||||
|
CT_Access_Public,
|
||||||
|
CT_PlatformAttributes,
|
||||||
|
CT_Class,
|
||||||
|
CT_Class_Fwd,
|
||||||
|
CT_Class_Body,
|
||||||
|
CT_Constructor,
|
||||||
|
CT_Constructor_Fwd,
|
||||||
|
CT_Destructor,
|
||||||
|
CT_Destructor_Fwd,
|
||||||
|
CT_Enum,
|
||||||
|
CT_Enum_Fwd,
|
||||||
|
CT_Enum_Body,
|
||||||
|
CT_Enum_Class,
|
||||||
|
CT_Enum_Class_Fwd,
|
||||||
|
CT_Execution,
|
||||||
|
CT_Export_Body,
|
||||||
|
CT_Extern_Linkage,
|
||||||
|
CT_Extern_Linkage_Body,
|
||||||
|
CT_Friend,
|
||||||
|
CT_Function,
|
||||||
|
CT_Function_Fwd,
|
||||||
|
CT_Function_Body,
|
||||||
|
CT_Global_Body,
|
||||||
|
CT_Module,
|
||||||
|
CT_Namespace,
|
||||||
|
CT_Namespace_Body,
|
||||||
|
CT_Operator,
|
||||||
|
CT_Operator_Fwd,
|
||||||
|
CT_Operator_Member,
|
||||||
|
CT_Operator_Member_Fwd,
|
||||||
|
CT_Operator_Cast,
|
||||||
|
CT_Operator_Cast_Fwd,
|
||||||
|
CT_Parameters,
|
||||||
|
CT_Preprocess_Define,
|
||||||
|
CT_Preprocess_Include,
|
||||||
|
CT_Preprocess_If,
|
||||||
|
CT_Preprocess_IfDef,
|
||||||
|
CT_Preprocess_IfNotDef,
|
||||||
|
CT_Preprocess_ElIf,
|
||||||
|
CT_Preprocess_Else,
|
||||||
|
CT_Preprocess_EndIf,
|
||||||
|
CT_Preprocess_Pragma,
|
||||||
|
CT_Specifiers,
|
||||||
|
CT_Struct,
|
||||||
|
CT_Struct_Fwd,
|
||||||
|
CT_Struct_Body,
|
||||||
|
CT_Template,
|
||||||
|
CT_Typedef,
|
||||||
|
CT_Typename,
|
||||||
|
CT_Union,
|
||||||
|
CT_Union_Fwd,
|
||||||
|
CT_Union_Body,
|
||||||
|
CT_Using,
|
||||||
|
CT_Using_Namespace,
|
||||||
|
CT_Variable,
|
||||||
|
CT_NumTypes
|
||||||
};
|
};
|
||||||
typedef enum CodeType CodeType;
|
|
||||||
inline
|
inline StrC codetype_to_str( CodeType type )
|
||||||
StrC codetype_to_str( CodeType type)
|
|
||||||
{
|
{
|
||||||
local_persist StrC lookup[61] = { { sizeof("Invalid"), "Invalid" },
|
local_persist StrC lookup[61] = {
|
||||||
{ sizeof("Untyped"), "Untyped" },
|
{ sizeof( "Invalid" ), "Invalid" },
|
||||||
{ sizeof("NewLine"), "NewLine" },
|
{ sizeof( "Untyped" ), "Untyped" },
|
||||||
{ sizeof("Comment"), "Comment" },
|
{ sizeof( "NewLine" ), "NewLine" },
|
||||||
{ sizeof("Access_Private"), "Access_Private" },
|
{ sizeof( "Comment" ), "Comment" },
|
||||||
{ sizeof("Access_Protected"), "Access_Protected" },
|
{ sizeof( "Access_Private" ), "Access_Private" },
|
||||||
{ sizeof("Access_Public"), "Access_Public" },
|
{ sizeof( "Access_Protected" ), "Access_Protected" },
|
||||||
{ sizeof("PlatformAttributes"), "PlatformAttributes" },
|
{ sizeof( "Access_Public" ), "Access_Public" },
|
||||||
{ sizeof("Class"), "Class" },
|
{ sizeof( "PlatformAttributes" ), "PlatformAttributes" },
|
||||||
{ sizeof("Class_Fwd"), "Class_Fwd" },
|
{ sizeof( "Class" ), "Class" },
|
||||||
{ sizeof("Class_Body"), "Class_Body" },
|
{ sizeof( "Class_Fwd" ), "Class_Fwd" },
|
||||||
{ sizeof("Constructor"), "Constructor" },
|
{ sizeof( "Class_Body" ), "Class_Body" },
|
||||||
{ sizeof("Constructor_Fwd"), "Constructor_Fwd" },
|
{ sizeof( "Constructor" ), "Constructor" },
|
||||||
{ sizeof("Destructor"), "Destructor" },
|
{ sizeof( "Constructor_Fwd" ), "Constructor_Fwd" },
|
||||||
{ sizeof("Destructor_Fwd"), "Destructor_Fwd" },
|
{ sizeof( "Destructor" ), "Destructor" },
|
||||||
{ sizeof("Enum"), "Enum" },
|
{ sizeof( "Destructor_Fwd" ), "Destructor_Fwd" },
|
||||||
{ sizeof("Enum_Fwd"), "Enum_Fwd" },
|
{ sizeof( "Enum" ), "Enum" },
|
||||||
{ sizeof("Enum_Body"), "Enum_Body" },
|
{ sizeof( "Enum_Fwd" ), "Enum_Fwd" },
|
||||||
{ sizeof("Enum_Class"), "Enum_Class" },
|
{ sizeof( "Enum_Body" ), "Enum_Body" },
|
||||||
{ sizeof("Enum_Class_Fwd"), "Enum_Class_Fwd" },
|
{ sizeof( "Enum_Class" ), "Enum_Class" },
|
||||||
{ sizeof("Execution"), "Execution" },
|
{ sizeof( "Enum_Class_Fwd" ), "Enum_Class_Fwd" },
|
||||||
{ sizeof("Export_Body"), "Export_Body" },
|
{ sizeof( "Execution" ), "Execution" },
|
||||||
{ sizeof("Extern_Linkage"), "Extern_Linkage" },
|
{ sizeof( "Export_Body" ), "Export_Body" },
|
||||||
{ sizeof("Extern_Linkage_Body"), "Extern_Linkage_Body" },
|
{ sizeof( "Extern_Linkage" ), "Extern_Linkage" },
|
||||||
{ sizeof("Friend"), "Friend" },
|
{ sizeof( "Extern_Linkage_Body" ), "Extern_Linkage_Body" },
|
||||||
{ sizeof("Function"), "Function" },
|
{ sizeof( "Friend" ), "Friend" },
|
||||||
{ sizeof("Function_Fwd"), "Function_Fwd" },
|
{ sizeof( "Function" ), "Function" },
|
||||||
{ sizeof("Function_Body"), "Function_Body" },
|
{ sizeof( "Function_Fwd" ), "Function_Fwd" },
|
||||||
{ sizeof("Global_Body"), "Global_Body" },
|
{ sizeof( "Function_Body" ), "Function_Body" },
|
||||||
{ sizeof("Module"), "Module" },
|
{ sizeof( "Global_Body" ), "Global_Body" },
|
||||||
{ sizeof("Namespace"), "Namespace" },
|
{ sizeof( "Module" ), "Module" },
|
||||||
{ sizeof("Namespace_Body"), "Namespace_Body" },
|
{ sizeof( "Namespace" ), "Namespace" },
|
||||||
{ sizeof("Operator"), "Operator" },
|
{ sizeof( "Namespace_Body" ), "Namespace_Body" },
|
||||||
{ sizeof("Operator_Fwd"), "Operator_Fwd" },
|
{ sizeof( "Operator" ), "Operator" },
|
||||||
{ sizeof("Operator_Member"), "Operator_Member" },
|
{ sizeof( "Operator_Fwd" ), "Operator_Fwd" },
|
||||||
{ sizeof("Operator_Member_Fwd"), "Operator_Member_Fwd" },
|
{ sizeof( "Operator_Member" ), "Operator_Member" },
|
||||||
{ sizeof("Operator_Cast"), "Operator_Cast" },
|
{ sizeof( "Operator_Member_Fwd" ), "Operator_Member_Fwd" },
|
||||||
{ sizeof("Operator_Cast_Fwd"), "Operator_Cast_Fwd" },
|
{ sizeof( "Operator_Cast" ), "Operator_Cast" },
|
||||||
{ sizeof("Parameters"), "Parameters" },
|
{ sizeof( "Operator_Cast_Fwd" ), "Operator_Cast_Fwd" },
|
||||||
{ sizeof("Preprocess_Define"), "Preprocess_Define" },
|
{ sizeof( "Parameters" ), "Parameters" },
|
||||||
{ sizeof("Preprocess_Include"), "Preprocess_Include" },
|
{ sizeof( "Preprocess_Define" ), "Preprocess_Define" },
|
||||||
{ sizeof("Preprocess_If"), "Preprocess_If" },
|
{ sizeof( "Preprocess_Include" ), "Preprocess_Include" },
|
||||||
{ sizeof("Preprocess_IfDef"), "Preprocess_IfDef" },
|
{ sizeof( "Preprocess_If" ), "Preprocess_If" },
|
||||||
{ sizeof("Preprocess_IfNotDef"), "Preprocess_IfNotDef" },
|
{ sizeof( "Preprocess_IfDef" ), "Preprocess_IfDef" },
|
||||||
{ sizeof("Preprocess_ElIf"), "Preprocess_ElIf" },
|
{ sizeof( "Preprocess_IfNotDef" ), "Preprocess_IfNotDef" },
|
||||||
{ sizeof("Preprocess_Else"), "Preprocess_Else" },
|
{ sizeof( "Preprocess_ElIf" ), "Preprocess_ElIf" },
|
||||||
{ sizeof("Preprocess_EndIf"), "Preprocess_EndIf" },
|
{ sizeof( "Preprocess_Else" ), "Preprocess_Else" },
|
||||||
{ sizeof("Preprocess_Pragma"), "Preprocess_Pragma" },
|
{ sizeof( "Preprocess_EndIf" ), "Preprocess_EndIf" },
|
||||||
{ sizeof("Specifiers"), "Specifiers" },
|
{ sizeof( "Preprocess_Pragma" ), "Preprocess_Pragma" },
|
||||||
{ sizeof("Struct"), "Struct" },
|
{ sizeof( "Specifiers" ), "Specifiers" },
|
||||||
{ sizeof("Struct_Fwd"), "Struct_Fwd" },
|
{ sizeof( "Struct" ), "Struct" },
|
||||||
{ sizeof("Struct_Body"), "Struct_Body" },
|
{ sizeof( "Struct_Fwd" ), "Struct_Fwd" },
|
||||||
{ sizeof("Template"), "Template" },
|
{ sizeof( "Struct_Body" ), "Struct_Body" },
|
||||||
{ sizeof("Typedef"), "Typedef" },
|
{ sizeof( "Template" ), "Template" },
|
||||||
{ sizeof("Typename"), "Typename" },
|
{ sizeof( "Typedef" ), "Typedef" },
|
||||||
{ sizeof("Union"), "Union" },
|
{ sizeof( "Typename" ), "Typename" },
|
||||||
{ sizeof("Union_Fwd"), "Union_Fwd" },
|
{ sizeof( "Union" ), "Union" },
|
||||||
{ sizeof("Union_Body"), "Union_Body" },
|
{ sizeof( "Union_Fwd" ), "Union_Fwd" },
|
||||||
{ sizeof("Using"), "Using" },
|
{ sizeof( "Union_Body" ), "Union_Body" },
|
||||||
{ sizeof("Using_Namespace"), "Using_Namespace" },
|
{ sizeof( "Using" ), "Using" },
|
||||||
{ sizeof("Variable"), "Variable" },
|
{ sizeof( "Using_Namespace" ), "Using_Namespace" },
|
||||||
}; return lookup[ type ];
|
{ sizeof( "Variable" ), "Variable" },
|
||||||
|
};
|
||||||
|
return lookup[type];
|
||||||
}
|
}
|
||||||
|
|
||||||
|
inline StrC codetype_to_keyword_str( CodeType type )
|
||||||
|
{
|
||||||
|
local_persist StrC lookup[61] = {
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "//" ), "//" },
|
||||||
|
{ sizeof( "private" ), "private" },
|
||||||
|
{ sizeof( "protected" ), "protected" },
|
||||||
|
{ sizeof( "public" ), "public" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "class" ), "class" },
|
||||||
|
{ sizeof( "clsss" ), "clsss" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "enum" ), "enum" },
|
||||||
|
{ sizeof( "enum" ), "enum" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "enum class" ), "enum class" },
|
||||||
|
{ sizeof( "enum class" ), "enum class" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "extern" ), "extern" },
|
||||||
|
{ sizeof( "extern" ), "extern" },
|
||||||
|
{ sizeof( "friend" ), "friend" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "module" ), "module" },
|
||||||
|
{ sizeof( "namespace" ), "namespace" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "operator" ), "operator" },
|
||||||
|
{ sizeof( "operator" ), "operator" },
|
||||||
|
{ sizeof( "operator" ), "operator" },
|
||||||
|
{ sizeof( "operator" ), "operator" },
|
||||||
|
{ sizeof( "operator" ), "operator" },
|
||||||
|
{ sizeof( "operator" ), "operator" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "define" ), "define" },
|
||||||
|
{ sizeof( "include" ), "include" },
|
||||||
|
{ sizeof( "if" ), "if" },
|
||||||
|
{ sizeof( "ifdef" ), "ifdef" },
|
||||||
|
{ sizeof( "ifndef" ), "ifndef" },
|
||||||
|
{ sizeof( "elif" ), "elif" },
|
||||||
|
{ sizeof( "else" ), "else" },
|
||||||
|
{ sizeof( "endif" ), "endif" },
|
||||||
|
{ sizeof( "pragma" ), "pragma" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "struct" ), "struct" },
|
||||||
|
{ sizeof( "struct" ), "struct" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "template" ), "template" },
|
||||||
|
{ sizeof( "typedef" ), "typedef" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "union" ), "union" },
|
||||||
|
{ sizeof( "union" ), "union" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
{ sizeof( "using" ), "using" },
|
||||||
|
{ sizeof( "using namespace" ), "using namespace" },
|
||||||
|
{ sizeof( "__NA__" ), "__NA__" },
|
||||||
|
};
|
||||||
|
return lookup[type];
|
||||||
|
}
|
||||||
|
|
||||||
|
forceinline StrC to_str( CodeType type )
|
||||||
|
{
|
||||||
|
return codetype_to_str( type );
|
||||||
|
}
|
||||||
|
|
||||||
|
forceinline StrC to_keyword_str( CodeType type )
|
||||||
|
{
|
||||||
|
return codetype_to_keyword_str( type );
|
||||||
|
}
|
||||||
|
@ -7,59 +7,111 @@
|
|||||||
|
|
||||||
enum Operator : u32
|
enum Operator : u32
|
||||||
{
|
{
|
||||||
Op_Invalid,Op_Assign,Op_Assign_Add,Op_Assign_Subtract,Op_Assign_Multiply,Op_Assign_Divide,Op_Assign_Modulo,Op_Assign_BAnd,Op_Assign_BOr,Op_Assign_BXOr,Op_Assign_LShift,Op_Assign_RShift,Op_Increment,Op_Decrement,Op_Unary_Plus,Op_Unary_Minus,Op_UnaryNot,Op_Add,Op_Subtract,Op_Multiply,Op_Divide,Op_Modulo,Op_BNot,Op_BAnd,Op_BOr,Op_BXOr,Op_LShift,Op_RShift,Op_LAnd,Op_LOr,Op_LEqual,Op_LNot,Op_Lesser,Op_Greater,Op_LesserEqual,Op_GreaterEqual,Op_Subscript,Op_Indirection,Op_AddressOf,Op_MemberOfPointer,Op_PtrToMemOfPtr,Op_FunctionCall,Op_Comma,Op_New,Op_NewArray,Op_Delete,Op_DeleteArray,NumOps
|
Op_Invalid,
|
||||||
|
Op_Assign,
|
||||||
|
Op_Assign_Add,
|
||||||
|
Op_Assign_Subtract,
|
||||||
|
Op_Assign_Multiply,
|
||||||
|
Op_Assign_Divide,
|
||||||
|
Op_Assign_Modulo,
|
||||||
|
Op_Assign_BAnd,
|
||||||
|
Op_Assign_BOr,
|
||||||
|
Op_Assign_BXOr,
|
||||||
|
Op_Assign_LShift,
|
||||||
|
Op_Assign_RShift,
|
||||||
|
Op_Increment,
|
||||||
|
Op_Decrement,
|
||||||
|
Op_Unary_Plus,
|
||||||
|
Op_Unary_Minus,
|
||||||
|
Op_UnaryNot,
|
||||||
|
Op_Add,
|
||||||
|
Op_Subtract,
|
||||||
|
Op_Multiply,
|
||||||
|
Op_Divide,
|
||||||
|
Op_Modulo,
|
||||||
|
Op_BNot,
|
||||||
|
Op_BAnd,
|
||||||
|
Op_BOr,
|
||||||
|
Op_BXOr,
|
||||||
|
Op_LShift,
|
||||||
|
Op_RShift,
|
||||||
|
Op_LAnd,
|
||||||
|
Op_LOr,
|
||||||
|
Op_LEqual,
|
||||||
|
Op_LNot,
|
||||||
|
Op_Lesser,
|
||||||
|
Op_Greater,
|
||||||
|
Op_LesserEqual,
|
||||||
|
Op_GreaterEqual,
|
||||||
|
Op_Subscript,
|
||||||
|
Op_Indirection,
|
||||||
|
Op_AddressOf,
|
||||||
|
Op_MemberOfPointer,
|
||||||
|
Op_PtrToMemOfPtr,
|
||||||
|
Op_FunctionCall,
|
||||||
|
Op_Comma,
|
||||||
|
Op_New,
|
||||||
|
Op_NewArray,
|
||||||
|
Op_Delete,
|
||||||
|
Op_DeleteArray,
|
||||||
|
NumOps
|
||||||
};
|
};
|
||||||
typedef enum Operator Operator;
|
|
||||||
inline
|
inline StrC operator_to_str( Operator op )
|
||||||
StrC operator_to_str( Operator op)
|
|
||||||
{
|
{
|
||||||
local_persist StrC lookup[47] = { { sizeof("INVALID"), "INVALID" },
|
local_persist StrC lookup[47] = {
|
||||||
{ sizeof("="), "=" },
|
{ sizeof( "INVALID" ), "INVALID" },
|
||||||
{ sizeof("+="), "+=" },
|
{ sizeof( "=" ), "=" },
|
||||||
{ sizeof("-="), "-=" },
|
{ sizeof( "+=" ), "+=" },
|
||||||
{ sizeof("*="), "*=" },
|
{ sizeof( "-=" ), "-=" },
|
||||||
{ sizeof("/="), "/=" },
|
{ sizeof( "*=" ), "*=" },
|
||||||
{ sizeof("%="), "%=" },
|
{ sizeof( "/=" ), "/=" },
|
||||||
{ sizeof("&="), "&=" },
|
{ sizeof( "%=" ), "%=" },
|
||||||
{ sizeof("|="), "|=" },
|
{ sizeof( "&=" ), "&=" },
|
||||||
{ sizeof("^="), "^=" },
|
{ sizeof( "|=" ), "|=" },
|
||||||
{ sizeof("<<="), "<<=" },
|
{ sizeof( "^=" ), "^=" },
|
||||||
{ sizeof(">>="), ">>=" },
|
{ sizeof( "<<=" ), "<<=" },
|
||||||
{ sizeof("++"), "++" },
|
{ sizeof( ">>=" ), ">>=" },
|
||||||
{ sizeof("--"), "--" },
|
{ sizeof( "++" ), "++" },
|
||||||
{ sizeof("+"), "+" },
|
{ sizeof( "--" ), "--" },
|
||||||
{ sizeof("-"), "-" },
|
{ sizeof( "+" ), "+" },
|
||||||
{ sizeof("!"), "!" },
|
{ sizeof( "-" ), "-" },
|
||||||
{ sizeof("+"), "+" },
|
{ sizeof( "!" ), "!" },
|
||||||
{ sizeof("-"), "-" },
|
{ sizeof( "+" ), "+" },
|
||||||
{ sizeof("*"), "*" },
|
{ sizeof( "-" ), "-" },
|
||||||
{ sizeof("/"), "/" },
|
{ sizeof( "*" ), "*" },
|
||||||
{ sizeof("%"), "%" },
|
{ sizeof( "/" ), "/" },
|
||||||
{ sizeof("~"), "~" },
|
{ sizeof( "%" ), "%" },
|
||||||
{ sizeof("&"), "&" },
|
{ sizeof( "~" ), "~" },
|
||||||
{ sizeof("|"), "|" },
|
{ sizeof( "&" ), "&" },
|
||||||
{ sizeof("^"), "^" },
|
{ sizeof( "|" ), "|" },
|
||||||
{ sizeof("<<"), "<<" },
|
{ sizeof( "^" ), "^" },
|
||||||
{ sizeof(">>"), ">>" },
|
{ sizeof( "<<" ), "<<" },
|
||||||
{ sizeof("&&"), "&&" },
|
{ sizeof( ">>" ), ">>" },
|
||||||
{ sizeof("||"), "||" },
|
{ sizeof( "&&" ), "&&" },
|
||||||
{ sizeof("=="), "==" },
|
{ sizeof( "||" ), "||" },
|
||||||
{ sizeof("!="), "!=" },
|
{ sizeof( "==" ), "==" },
|
||||||
{ sizeof("<"), "<" },
|
{ sizeof( "!=" ), "!=" },
|
||||||
{ sizeof(">"), ">" },
|
{ sizeof( "<" ), "<" },
|
||||||
{ sizeof("<="), "<=" },
|
{ sizeof( ">" ), ">" },
|
||||||
{ sizeof(">="), ">=" },
|
{ sizeof( "<=" ), "<=" },
|
||||||
{ sizeof("[]"), "[]" },
|
{ sizeof( ">=" ), ">=" },
|
||||||
{ sizeof("*"), "*" },
|
{ sizeof( "[]" ), "[]" },
|
||||||
{ sizeof("&"), "&" },
|
{ sizeof( "*" ), "*" },
|
||||||
{ sizeof("->"), "->" },
|
{ sizeof( "&" ), "&" },
|
||||||
{ sizeof("->*"), "->*" },
|
{ sizeof( "->" ), "->" },
|
||||||
{ sizeof("()"), "()" },
|
{ sizeof( "->*" ), "->*" },
|
||||||
{ sizeof(","), "," },
|
{ sizeof( "()" ), "()" },
|
||||||
{ sizeof("new"), "new" },
|
{ sizeof( "," ), "," },
|
||||||
{ sizeof("new[]"), "new[]" },
|
{ sizeof( "new" ), "new" },
|
||||||
{ sizeof("delete"), "delete" },
|
{ sizeof( "new[]" ), "new[]" },
|
||||||
{ sizeof("delete[]"), "delete[]" },
|
{ sizeof( "delete" ), "delete" },
|
||||||
}; return lookup[ op ];
|
{ sizeof( "delete[]" ), "delete[]" },
|
||||||
|
};
|
||||||
|
return lookup[op];
|
||||||
}
|
}
|
||||||
|
|
||||||
|
forceinline StrC to_str( Operator op )
|
||||||
|
{
|
||||||
|
return operator_to_str( op );
|
||||||
|
}
|
||||||
|
@ -7,48 +7,101 @@
|
|||||||
|
|
||||||
enum Specifier : u32
|
enum Specifier : u32
|
||||||
{
|
{
|
||||||
Spec_Invalid,Spec_Consteval,Spec_Constexpr,Spec_Constinit,Spec_Explicit,Spec_External_Linkage,Spec_ForceInline,Spec_Global,Spec_Inline,Spec_Internal_Linkage,Spec_Local_Persist,Spec_Mutable,Spec_NeverInline,Spec_Ptr,Spec_Ref,Spec_Register,Spec_RValue,Spec_Static,Spec_Thread_Local,Spec_Virtual,Spec_Const,Spec_Final,Spec_NoExceptions,Spec_Override,Spec_Pure,Spec_Volatile,Spec_NumSpecifiers
|
Spec_Invalid,
|
||||||
|
Spec_Consteval,
|
||||||
|
Spec_Constexpr,
|
||||||
|
Spec_Constinit,
|
||||||
|
Spec_Explicit,
|
||||||
|
Spec_External_Linkage,
|
||||||
|
Spec_ForceInline,
|
||||||
|
Spec_Global,
|
||||||
|
Spec_Inline,
|
||||||
|
Spec_Internal_Linkage,
|
||||||
|
Spec_Local_Persist,
|
||||||
|
Spec_Mutable,
|
||||||
|
Spec_NeverInline,
|
||||||
|
Spec_Ptr,
|
||||||
|
Spec_Ref,
|
||||||
|
Spec_Register,
|
||||||
|
Spec_RValue,
|
||||||
|
Spec_Static,
|
||||||
|
Spec_Thread_Local,
|
||||||
|
Spec_Virtual,
|
||||||
|
Spec_Const,
|
||||||
|
Spec_Final,
|
||||||
|
Spec_NoExceptions,
|
||||||
|
Spec_Override,
|
||||||
|
Spec_Pure,
|
||||||
|
Spec_Volatile,
|
||||||
|
Spec_NumSpecifiers
|
||||||
};
|
};
|
||||||
typedef enum Specifier Specifier;
|
|
||||||
inline
|
inline StrC spec_to_str( Specifier type )
|
||||||
bool spec_is_trailing( Specifier specifier)
|
|
||||||
{
|
{
|
||||||
return specifier > Spec_Virtual;
|
local_persist StrC lookup[26] = {
|
||||||
}
|
{ sizeof( "INVALID" ), "INVALID" },
|
||||||
inline
|
{ sizeof( "consteval" ), "consteval" },
|
||||||
StrC spec_to_str( Specifier type)
|
{ sizeof( "constexpr" ), "constexpr" },
|
||||||
{
|
{ sizeof( "constinit" ), "constinit" },
|
||||||
local_persist StrC lookup[26] = { { sizeof("INVALID"), "INVALID" },
|
{ sizeof( "explicit" ), "explicit" },
|
||||||
{ sizeof("consteval"), "consteval" },
|
{ sizeof( "extern" ), "extern" },
|
||||||
{ sizeof("constexpr"), "constexpr" },
|
{ sizeof( "forceinline" ), "forceinline" },
|
||||||
{ sizeof("constinit"), "constinit" },
|
{ sizeof( "global" ), "global" },
|
||||||
{ sizeof("explicit"), "explicit" },
|
{ sizeof( "inline" ), "inline" },
|
||||||
{ sizeof("extern"), "extern" },
|
{ sizeof( "internal" ), "internal" },
|
||||||
{ sizeof("forceinline"), "forceinline" },
|
{ sizeof( "local_persist" ), "local_persist" },
|
||||||
{ sizeof("global"), "global" },
|
{ sizeof( "mutable" ), "mutable" },
|
||||||
{ sizeof("inline"), "inline" },
|
{ sizeof( "neverinline" ), "neverinline" },
|
||||||
{ sizeof("internal"), "internal" },
|
{ sizeof( "*" ), "*" },
|
||||||
{ sizeof("local_persist"), "local_persist" },
|
{ sizeof( "&" ), "&" },
|
||||||
{ sizeof("mutable"), "mutable" },
|
{ sizeof( "register" ), "register" },
|
||||||
{ sizeof("neverinline"), "neverinline" },
|
{ sizeof( "&&" ), "&&" },
|
||||||
{ sizeof("*"), "*" },
|
{ sizeof( "static" ), "static" },
|
||||||
{ sizeof("&"), "&" },
|
{ sizeof( "thread_local" ), "thread_local" },
|
||||||
{ sizeof("register"), "register" },
|
{ sizeof( "virtual" ), "virtual" },
|
||||||
{ sizeof("&&"), "&&" },
|
{ sizeof( "const" ), "const" },
|
||||||
{ sizeof("static"), "static" },
|
{ sizeof( "final" ), "final" },
|
||||||
{ sizeof("thread_local"), "thread_local" },
|
{ sizeof( "noexcept" ), "noexcept" },
|
||||||
{ sizeof("virtual"), "virtual" },
|
{ sizeof( "override" ), "override" },
|
||||||
{ sizeof("const"), "const" },
|
{ sizeof( "= 0" ), "= 0" },
|
||||||
{ sizeof("final"), "final" },
|
{ sizeof( "volatile" ), "volatile" },
|
||||||
{ sizeof("noexcept"), "noexcept" },
|
};
|
||||||
{ sizeof("override"), "override" },
|
return lookup[type];
|
||||||
{ sizeof("= 0"), "= 0" },
|
|
||||||
{ sizeof("volatile"), "volatile" },
|
|
||||||
}; return lookup[ type ];
|
|
||||||
}
|
|
||||||
inline
|
|
||||||
Specifier strc_to_specifier( StrC str)
|
|
||||||
{
|
|
||||||
local_persist u32 keymap[ Spec_NumSpecifiers ]; do_once_start for ( u32 index = 0; index < Spec_NumSpecifiers; index++ ) { StrC enum_str = spec_to_str( (Specifier)index ); keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1); } do_once_end u32 hash = crc32( str.Ptr, str.Len ); for ( u32 index = 0; index < Spec_NumSpecifiers; index++ ) { if ( keymap[index] == hash ) return (Specifier)index; } return Spec_Invalid;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
inline bool spec_is_trailing( Specifier specifier )
|
||||||
|
{
|
||||||
|
return specifier > Spec_Virtual;
|
||||||
|
}
|
||||||
|
|
||||||
|
inline Specifier strc_to_specifier( StrC str )
|
||||||
|
{
|
||||||
|
local_persist u32 keymap[Spec_NumSpecifiers];
|
||||||
|
do_once_start for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
|
||||||
|
{
|
||||||
|
StrC enum_str = spec_to_str( (Specifier)index );
|
||||||
|
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
|
||||||
|
}
|
||||||
|
do_once_end u32 hash = crc32( str.Ptr, str.Len );
|
||||||
|
for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
|
||||||
|
{
|
||||||
|
if ( keymap[index] == hash )
|
||||||
|
return (Specifier)index;
|
||||||
|
}
|
||||||
|
return Spec_Invalid;
|
||||||
|
}
|
||||||
|
|
||||||
|
forceinline StrC to_str( Specifier spec )
|
||||||
|
{
|
||||||
|
return spec_to_str( spec );
|
||||||
|
}
|
||||||
|
|
||||||
|
forceinline Specifier to_type( StrC str )
|
||||||
|
{
|
||||||
|
return strc_to_specifier( str );
|
||||||
|
}
|
||||||
|
|
||||||
|
forceinline bool is_trailing( Specifier specifier )
|
||||||
|
{
|
||||||
|
return spec_is_trailing( specifier );
|
||||||
|
}
|
||||||
|
@ -6,119 +6,230 @@
|
|||||||
// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
|
// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
|
||||||
|
|
||||||
GEN_NS_PARSER_BEGIN
|
GEN_NS_PARSER_BEGIN
|
||||||
#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( Tok_Attribute_API_Export, "GEN_API_Export_Code" ) \
|
#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( Tok_Attribute_API_Export, "GEN_API_Export_Code" ) Entry( Tok_Attribute_API_Import, "GEN_API_Import_Code" )
|
||||||
Entry( Tok_Attribute_API_Import, "GEN_API_Import_Code" )
|
|
||||||
|
|
||||||
enum TokType_Def : u32
|
enum TokType_Def : u32
|
||||||
{
|
{
|
||||||
Tok_Invalid,Tok_Access_Private,Tok_Access_Protected,Tok_Access_Public,Tok_Access_MemberSymbol,Tok_Access_StaticSymbol,Tok_Ampersand,Tok_Ampersand_DBL,Tok_Assign_Classifer,Tok_Attribute_Open,Tok_Attribute_Close,Tok_BraceCurly_Open,Tok_BraceCurly_Close,Tok_BraceSquare_Open,Tok_BraceSquare_Close,Tok_Capture_Start,Tok_Capture_End,Tok_Comment,Tok_Comment_End,Tok_Comment_Start,Tok_Char,Tok_Comma,Tok_Decl_Class,Tok_Decl_GNU_Attribute,Tok_Decl_MSVC_Attribute,Tok_Decl_Enum,Tok_Decl_Extern_Linkage,Tok_Decl_Friend,Tok_Decl_Module,Tok_Decl_Namespace,Tok_Decl_Operator,Tok_Decl_Struct,Tok_Decl_Template,Tok_Decl_Typedef,Tok_Decl_Using,Tok_Decl_Union,Tok_Identifier,Tok_Module_Import,Tok_Module_Export,Tok_NewLine,Tok_Number,Tok_Operator,Tok_Preprocess_Hash,Tok_Preprocess_Define,Tok_Preprocess_If,Tok_Preprocess_IfDef,Tok_Preprocess_IfNotDef,Tok_Preprocess_ElIf,Tok_Preprocess_Else,Tok_Preprocess_EndIf,Tok_Preprocess_Include,Tok_Preprocess_Pragma,Tok_Preprocess_Content,Tok_Preprocess_Macro,Tok_Preprocess_Unsupported,Tok_Spec_Alignas,Tok_Spec_Const,Tok_Spec_Consteval,Tok_Spec_Constexpr,Tok_Spec_Constinit,Tok_Spec_Explicit,Tok_Spec_Extern,Tok_Spec_Final,Tok_Spec_ForceInline,Tok_Spec_Global,Tok_Spec_Inline,Tok_Spec_Internal_Linkage,Tok_Spec_LocalPersist,Tok_Spec_Mutable,Tok_Spec_NeverInline,Tok_Spec_Override,Tok_Spec_Static,Tok_Spec_ThreadLocal,Tok_Spec_Volatile,Tok_Spec_Virtual,Tok_Star,Tok_Statement_End,Tok_StaticAssert,Tok_String,Tok_Type_Typename,Tok_Type_Unsigned,Tok_Type_Signed,Tok_Type_Short,Tok_Type_Long,Tok_Type_bool,Tok_Type_char,Tok_Type_int,Tok_Type_double,Tok_Type_MS_int8,Tok_Type_MS_int16,Tok_Type_MS_int32,Tok_Type_MS_int64,Tok_Type_MS_W64,Tok_Varadic_Argument,Tok___Attributes_Start,Tok_Attribute_API_Export,Tok_Attribute_API_Import,Tok_NumTokens
|
Tok_Invalid,
|
||||||
|
Tok_Access_Private,
|
||||||
|
Tok_Access_Protected,
|
||||||
|
Tok_Access_Public,
|
||||||
|
Tok_Access_MemberSymbol,
|
||||||
|
Tok_Access_StaticSymbol,
|
||||||
|
Tok_Ampersand,
|
||||||
|
Tok_Ampersand_DBL,
|
||||||
|
Tok_Assign_Classifer,
|
||||||
|
Tok_Attribute_Open,
|
||||||
|
Tok_Attribute_Close,
|
||||||
|
Tok_BraceCurly_Open,
|
||||||
|
Tok_BraceCurly_Close,
|
||||||
|
Tok_BraceSquare_Open,
|
||||||
|
Tok_BraceSquare_Close,
|
||||||
|
Tok_Capture_Start,
|
||||||
|
Tok_Capture_End,
|
||||||
|
Tok_Comment,
|
||||||
|
Tok_Comment_End,
|
||||||
|
Tok_Comment_Start,
|
||||||
|
Tok_Char,
|
||||||
|
Tok_Comma,
|
||||||
|
Tok_Decl_Class,
|
||||||
|
Tok_Decl_GNU_Attribute,
|
||||||
|
Tok_Decl_MSVC_Attribute,
|
||||||
|
Tok_Decl_Enum,
|
||||||
|
Tok_Decl_Extern_Linkage,
|
||||||
|
Tok_Decl_Friend,
|
||||||
|
Tok_Decl_Module,
|
||||||
|
Tok_Decl_Namespace,
|
||||||
|
Tok_Decl_Operator,
|
||||||
|
Tok_Decl_Struct,
|
||||||
|
Tok_Decl_Template,
|
||||||
|
Tok_Decl_Typedef,
|
||||||
|
Tok_Decl_Using,
|
||||||
|
Tok_Decl_Union,
|
||||||
|
Tok_Identifier,
|
||||||
|
Tok_Module_Import,
|
||||||
|
Tok_Module_Export,
|
||||||
|
Tok_NewLine,
|
||||||
|
Tok_Number,
|
||||||
|
Tok_Operator,
|
||||||
|
Tok_Preprocess_Hash,
|
||||||
|
Tok_Preprocess_Define,
|
||||||
|
Tok_Preprocess_If,
|
||||||
|
Tok_Preprocess_IfDef,
|
||||||
|
Tok_Preprocess_IfNotDef,
|
||||||
|
Tok_Preprocess_ElIf,
|
||||||
|
Tok_Preprocess_Else,
|
||||||
|
Tok_Preprocess_EndIf,
|
||||||
|
Tok_Preprocess_Include,
|
||||||
|
Tok_Preprocess_Pragma,
|
||||||
|
Tok_Preprocess_Content,
|
||||||
|
Tok_Preprocess_Macro,
|
||||||
|
Tok_Preprocess_Unsupported,
|
||||||
|
Tok_Spec_Alignas,
|
||||||
|
Tok_Spec_Const,
|
||||||
|
Tok_Spec_Consteval,
|
||||||
|
Tok_Spec_Constexpr,
|
||||||
|
Tok_Spec_Constinit,
|
||||||
|
Tok_Spec_Explicit,
|
||||||
|
Tok_Spec_Extern,
|
||||||
|
Tok_Spec_Final,
|
||||||
|
Tok_Spec_ForceInline,
|
||||||
|
Tok_Spec_Global,
|
||||||
|
Tok_Spec_Inline,
|
||||||
|
Tok_Spec_Internal_Linkage,
|
||||||
|
Tok_Spec_LocalPersist,
|
||||||
|
Tok_Spec_Mutable,
|
||||||
|
Tok_Spec_NeverInline,
|
||||||
|
Tok_Spec_Override,
|
||||||
|
Tok_Spec_Static,
|
||||||
|
Tok_Spec_ThreadLocal,
|
||||||
|
Tok_Spec_Volatile,
|
||||||
|
Tok_Spec_Virtual,
|
||||||
|
Tok_Star,
|
||||||
|
Tok_Statement_End,
|
||||||
|
Tok_StaticAssert,
|
||||||
|
Tok_String,
|
||||||
|
Tok_Type_Typename,
|
||||||
|
Tok_Type_Unsigned,
|
||||||
|
Tok_Type_Signed,
|
||||||
|
Tok_Type_Short,
|
||||||
|
Tok_Type_Long,
|
||||||
|
Tok_Type_bool,
|
||||||
|
Tok_Type_char,
|
||||||
|
Tok_Type_int,
|
||||||
|
Tok_Type_double,
|
||||||
|
Tok_Type_MS_int8,
|
||||||
|
Tok_Type_MS_int16,
|
||||||
|
Tok_Type_MS_int32,
|
||||||
|
Tok_Type_MS_int64,
|
||||||
|
Tok_Type_MS_W64,
|
||||||
|
Tok_Varadic_Argument,
|
||||||
|
Tok___Attributes_Start,
|
||||||
|
Tok_Attribute_API_Export,
|
||||||
|
Tok_Attribute_API_Import,
|
||||||
|
Tok_NumTokens
|
||||||
};
|
};
|
||||||
typedef enum TokType_Def TokType;
|
typedef enum TokType_Def TokType;
|
||||||
inline
|
|
||||||
StrC to_str( TokType type)
|
inline StrC to_str( TokType type )
|
||||||
{
|
{
|
||||||
local_persist StrC lookup[] { { sizeof("__invalid__"), "__invalid__" },
|
local_persist StrC lookup[] {
|
||||||
{ sizeof("private"), "private" },
|
{ sizeof( "__invalid__" ), "__invalid__" },
|
||||||
{ sizeof("protected"), "protected" },
|
{ sizeof( "private" ), "private" },
|
||||||
{ sizeof("public"), "public" },
|
{ sizeof( "protected" ), "protected" },
|
||||||
{ sizeof("."), "." },
|
{ sizeof( "public" ), "public" },
|
||||||
{ sizeof("::"), "::" },
|
{ sizeof( "." ), "." },
|
||||||
{ sizeof("&"), "&" },
|
{ sizeof( "::" ), "::" },
|
||||||
{ sizeof("&&"), "&&" },
|
{ sizeof( "&" ), "&" },
|
||||||
{ sizeof(":"), ":" },
|
{ sizeof( "&&" ), "&&" },
|
||||||
{ sizeof("[["), "[[" },
|
{ sizeof( ":" ), ":" },
|
||||||
{ sizeof("]]"), "]]" },
|
{ sizeof( "[[" ), "[[" },
|
||||||
{ sizeof("{"), "{" },
|
{ sizeof( "]]" ), "]]" },
|
||||||
{ sizeof("}"), "}" },
|
{ sizeof( "{" ), "{" },
|
||||||
{ sizeof("["), "[" },
|
{ sizeof( "}" ), "}" },
|
||||||
{ sizeof("]"), "]" },
|
{ sizeof( "[" ), "[" },
|
||||||
{ sizeof("("), "(" },
|
{ sizeof( "]" ), "]" },
|
||||||
{ sizeof(")"), ")" },
|
{ sizeof( "(" ), "(" },
|
||||||
{ sizeof("__comment__"), "__comment__" },
|
{ sizeof( ")" ), ")" },
|
||||||
{ sizeof("__comment_end__"), "__comment_end__" },
|
{ sizeof( "__comment__" ), "__comment__" },
|
||||||
{ sizeof("__comment_start__"), "__comment_start__" },
|
{ sizeof( "__comment_end__" ), "__comment_end__" },
|
||||||
{ sizeof("__character__"), "__character__" },
|
{ sizeof( "__comment_start__" ), "__comment_start__" },
|
||||||
{ sizeof(","), "," },
|
{ sizeof( "__character__" ), "__character__" },
|
||||||
{ sizeof("class"), "class" },
|
{ sizeof( "," ), "," },
|
||||||
{ sizeof("__attribute__"), "__attribute__" },
|
{ sizeof( "class" ), "class" },
|
||||||
{ sizeof("__declspec"), "__declspec" },
|
{ sizeof( "__attribute__" ), "__attribute__" },
|
||||||
{ sizeof("enum"), "enum" },
|
{ sizeof( "__declspec" ), "__declspec" },
|
||||||
{ sizeof("extern"), "extern" },
|
{ sizeof( "enum" ), "enum" },
|
||||||
{ sizeof("friend"), "friend" },
|
{ sizeof( "extern" ), "extern" },
|
||||||
{ sizeof("module"), "module" },
|
{ sizeof( "friend" ), "friend" },
|
||||||
{ sizeof("namespace"), "namespace" },
|
{ sizeof( "module" ), "module" },
|
||||||
{ sizeof("operator"), "operator" },
|
{ sizeof( "namespace" ), "namespace" },
|
||||||
{ sizeof("struct"), "struct" },
|
{ sizeof( "operator" ), "operator" },
|
||||||
{ sizeof("template"), "template" },
|
{ sizeof( "struct" ), "struct" },
|
||||||
{ sizeof("typedef"), "typedef" },
|
{ sizeof( "template" ), "template" },
|
||||||
{ sizeof("using"), "using" },
|
{ sizeof( "typedef" ), "typedef" },
|
||||||
{ sizeof("union"), "union" },
|
{ sizeof( "using" ), "using" },
|
||||||
{ sizeof("__identifier__"), "__identifier__" },
|
{ sizeof( "union" ), "union" },
|
||||||
{ sizeof("import"), "import" },
|
{ sizeof( "__identifier__" ), "__identifier__" },
|
||||||
{ sizeof("export"), "export" },
|
{ sizeof( "import" ), "import" },
|
||||||
{ sizeof("__new_line__"), "__new_line__" },
|
{ sizeof( "export" ), "export" },
|
||||||
{ sizeof("__number__"), "__number__" },
|
{ sizeof( "__new_line__" ), "__new_line__" },
|
||||||
{ sizeof("__operator__"), "__operator__" },
|
{ sizeof( "__number__" ), "__number__" },
|
||||||
{ sizeof("#"), "#" },
|
{ sizeof( "__operator__" ), "__operator__" },
|
||||||
{ sizeof("define"), "define" },
|
{ sizeof( "#" ), "#" },
|
||||||
{ sizeof("if"), "if" },
|
{ sizeof( "define" ), "define" },
|
||||||
{ sizeof("ifdef"), "ifdef" },
|
{ sizeof( "if" ), "if" },
|
||||||
{ sizeof("ifndef"), "ifndef" },
|
{ sizeof( "ifdef" ), "ifdef" },
|
||||||
{ sizeof("elif"), "elif" },
|
{ sizeof( "ifndef" ), "ifndef" },
|
||||||
{ sizeof("else"), "else" },
|
{ sizeof( "elif" ), "elif" },
|
||||||
{ sizeof("endif"), "endif" },
|
{ sizeof( "else" ), "else" },
|
||||||
{ sizeof("include"), "include" },
|
{ sizeof( "endif" ), "endif" },
|
||||||
{ sizeof("pragma"), "pragma" },
|
{ sizeof( "include" ), "include" },
|
||||||
{ sizeof("__macro_content__"), "__macro_content__" },
|
{ sizeof( "pragma" ), "pragma" },
|
||||||
{ sizeof("__macro__"), "__macro__" },
|
{ sizeof( "__macro_content__" ), "__macro_content__" },
|
||||||
{ sizeof("__unsupported__"), "__unsupported__" },
|
{ sizeof( "__macro__" ), "__macro__" },
|
||||||
{ sizeof("alignas"), "alignas" },
|
{ sizeof( "__unsupported__" ), "__unsupported__" },
|
||||||
{ sizeof("const"), "const" },
|
{ sizeof( "alignas" ), "alignas" },
|
||||||
{ sizeof("consteval"), "consteval" },
|
{ sizeof( "const" ), "const" },
|
||||||
{ sizeof("constexpr"), "constexpr" },
|
{ sizeof( "consteval" ), "consteval" },
|
||||||
{ sizeof("constinit"), "constinit" },
|
{ sizeof( "constexpr" ), "constexpr" },
|
||||||
{ sizeof("explicit"), "explicit" },
|
{ sizeof( "constinit" ), "constinit" },
|
||||||
{ sizeof("extern"), "extern" },
|
{ sizeof( "explicit" ), "explicit" },
|
||||||
{ sizeof("final"), "final" },
|
{ sizeof( "extern" ), "extern" },
|
||||||
{ sizeof("forceinline"), "forceinline" },
|
{ sizeof( "final" ), "final" },
|
||||||
{ sizeof("global"), "global" },
|
{ sizeof( "forceinline" ), "forceinline" },
|
||||||
{ sizeof("inline"), "inline" },
|
{ sizeof( "global" ), "global" },
|
||||||
{ sizeof("internal"), "internal" },
|
{ sizeof( "inline" ), "inline" },
|
||||||
{ sizeof("local_persist"), "local_persist" },
|
{ sizeof( "internal" ), "internal" },
|
||||||
{ sizeof("mutable"), "mutable" },
|
{ sizeof( "local_persist" ), "local_persist" },
|
||||||
{ sizeof("neverinline"), "neverinline" },
|
{ sizeof( "mutable" ), "mutable" },
|
||||||
{ sizeof("override"), "override" },
|
{ sizeof( "neverinline" ), "neverinline" },
|
||||||
{ sizeof("static"), "static" },
|
{ sizeof( "override" ), "override" },
|
||||||
{ sizeof("thread_local"), "thread_local" },
|
{ sizeof( "static" ), "static" },
|
||||||
{ sizeof("volatile"), "volatile" },
|
{ sizeof( "thread_local" ), "thread_local" },
|
||||||
{ sizeof("virtual"), "virtual" },
|
{ sizeof( "volatile" ), "volatile" },
|
||||||
{ sizeof("*"), "*" },
|
{ sizeof( "virtual" ), "virtual" },
|
||||||
{ sizeof(";"), ";" },
|
{ sizeof( "*" ), "*" },
|
||||||
{ sizeof("static_assert"), "static_assert" },
|
{ sizeof( ";" ), ";" },
|
||||||
{ sizeof("__string__"), "__string__" },
|
{ sizeof( "static_assert" ), "static_assert" },
|
||||||
{ sizeof("typename"), "typename" },
|
{ sizeof( "__string__" ), "__string__" },
|
||||||
{ sizeof("unsigned"), "unsigned" },
|
{ sizeof( "typename" ), "typename" },
|
||||||
{ sizeof("signed"), "signed" },
|
{ sizeof( "unsigned" ), "unsigned" },
|
||||||
{ sizeof("short"), "short" },
|
{ sizeof( "signed" ), "signed" },
|
||||||
{ sizeof("long"), "long" },
|
{ sizeof( "short" ), "short" },
|
||||||
{ sizeof("bool"), "bool" },
|
{ sizeof( "long" ), "long" },
|
||||||
{ sizeof("char"), "char" },
|
{ sizeof( "bool" ), "bool" },
|
||||||
{ sizeof("int"), "int" },
|
{ sizeof( "char" ), "char" },
|
||||||
{ sizeof("double"), "double" },
|
{ sizeof( "int" ), "int" },
|
||||||
{ sizeof("__int8"), "__int8" },
|
{ sizeof( "double" ), "double" },
|
||||||
{ sizeof("__int16"), "__int16" },
|
{ sizeof( "__int8" ), "__int8" },
|
||||||
{ sizeof("__int32"), "__int32" },
|
{ sizeof( "__int16" ), "__int16" },
|
||||||
{ sizeof("__int64"), "__int64" },
|
{ sizeof( "__int32" ), "__int32" },
|
||||||
{ sizeof("_W64"), "_W64" },
|
{ sizeof( "__int64" ), "__int64" },
|
||||||
{ sizeof("..."), "..." },
|
{ sizeof( "_W64" ), "_W64" },
|
||||||
{ sizeof("__attrib_start__"), "__attrib_start__" },
|
{ sizeof( "..." ), "..." },
|
||||||
{ sizeof("GEN_API_Export_Code"), "GEN_API_Export_Code" },
|
{ sizeof( "__attrib_start__" ), "__attrib_start__" },
|
||||||
{ sizeof("GEN_API_Import_Code"), "GEN_API_Import_Code" },
|
{ sizeof( "GEN_API_Export_Code" ), "GEN_API_Export_Code" },
|
||||||
}; return lookup[ type ];
|
{ sizeof( "GEN_API_Import_Code" ), "GEN_API_Import_Code" },
|
||||||
|
};
|
||||||
|
return lookup[type];
|
||||||
}
|
}
|
||||||
inline
|
|
||||||
TokType to_toktype( StrC str)
|
inline TokType to_toktype( StrC str )
|
||||||
{
|
{
|
||||||
local_persist u32 keymap[ Tok_NumTokens ]; do_once_start for ( u32 index = 0; index < Tok_NumTokens; index++ ) { StrC enum_str = to_str( (TokType)index ); keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1); } do_once_end u32 hash = crc32( str.Ptr, str.Len ); for ( u32 index = 0; index < Tok_NumTokens; index++ ) { if ( keymap[index] == hash ) return (TokType)index; } return Tok_Invalid;
|
local_persist u32 keymap[Tok_NumTokens];
|
||||||
|
do_once_start for ( u32 index = 0; index < Tok_NumTokens; index++ )
|
||||||
|
{
|
||||||
|
StrC enum_str = to_str( (TokType)index );
|
||||||
|
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 );
|
||||||
|
}
|
||||||
|
do_once_end u32 hash = crc32( str.Ptr, str.Len );
|
||||||
|
for ( u32 index = 0; index < Tok_NumTokens; index++ )
|
||||||
|
{
|
||||||
|
if ( keymap[index] == hash )
|
||||||
|
return (TokType)index;
|
||||||
|
}
|
||||||
|
return Tok_Invalid;
|
||||||
}
|
}
|
||||||
|
|
||||||
GEN_NS_PARSER_END
|
GEN_NS_PARSER_END
|
||||||
|
@ -25,7 +25,7 @@
|
|||||||
# define GEN_MAX_UNTYPED_STR_LENGTH megabytes(1)
|
# define GEN_MAX_UNTYPED_STR_LENGTH megabytes(1)
|
||||||
#endif
|
#endif
|
||||||
#ifndef GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE
|
#ifndef GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE
|
||||||
# define GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE kilobytes(4)
|
# define GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE kilobytes(8)
|
||||||
#endif
|
#endif
|
||||||
#ifndef GEN_LEX_ALLOCATOR_SIZE
|
#ifndef GEN_LEX_ALLOCATOR_SIZE
|
||||||
# define GEN_LEX_ALLOCATOR_SIZE megabytes(4)
|
# define GEN_LEX_ALLOCATOR_SIZE megabytes(4)
|
||||||
@ -131,38 +131,12 @@ extern CodeTypename t_typename;
|
|||||||
|
|
||||||
#pragma endregion Constants
|
#pragma endregion Constants
|
||||||
|
|
||||||
#pragma region Macros
|
|
||||||
|
|
||||||
#ifndef token_fmt
|
|
||||||
# define gen_main main
|
|
||||||
|
|
||||||
# define __ NullCode
|
|
||||||
|
|
||||||
// Convienence for defining any name used with the gen api.
|
|
||||||
// Lets you provide the length and string literal to the functions without the need for the DSL.
|
|
||||||
# define name( Id_ ) { sizeof(stringize( Id_ )) - 1, stringize(Id_) }
|
|
||||||
|
|
||||||
// Same as name just used to indicate intention of literal for code instead of names.
|
|
||||||
# define code( ... ) { sizeof(stringize(__VA_ARGS__)) - 1, stringize( __VA_ARGS__ ) }
|
|
||||||
|
|
||||||
# define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__
|
|
||||||
|
|
||||||
# define code_str( ... ) GEN_NS untyped_str( code( __VA_ARGS__ ) )
|
|
||||||
# define code_fmt( ... ) GEN_NS untyped_str( token_fmt( __VA_ARGS__ ) )
|
|
||||||
|
|
||||||
// Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
|
|
||||||
# define token_fmt( ... ) GEN_NS token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#pragma endregion Macros
|
|
||||||
|
|
||||||
// Used by the lexer to persistently treat all these identifiers as preprocessor defines.
|
// Used by the lexer to persistently treat all these identifiers as preprocessor defines.
|
||||||
// Populate with strings via gen::get_cached_string.
|
// Populate with strings via gen::get_cached_string.
|
||||||
// Functional defines must have format: id( ;at minimum to indicate that the define is only valid with arguments.
|
// Functional defines must have format: id( ;at minimum to indicate that the define is only valid with arguments.
|
||||||
extern Array(StringCached) PreprocessorDefines;
|
extern Array(StringCached) PreprocessorDefines;
|
||||||
|
|
||||||
#ifdef GEN_EXPOSE_BACKEND
|
#ifdef GEN_EXPOSE_BACKEND
|
||||||
|
|
||||||
// Global allocator used for data with process lifetime.
|
// Global allocator used for data with process lifetime.
|
||||||
extern AllocatorInfo GlobalAllocator;
|
extern AllocatorInfo GlobalAllocator;
|
||||||
extern Array(Arena) Global_AllocatorBuckets;
|
extern Array(Arena) Global_AllocatorBuckets;
|
||||||
@ -180,5 +154,4 @@ extern Array(StringCached) PreprocessorDefines;
|
|||||||
extern AllocatorInfo Allocator_StringArena;
|
extern AllocatorInfo Allocator_StringArena;
|
||||||
extern AllocatorInfo Allocator_StringTable;
|
extern AllocatorInfo Allocator_StringTable;
|
||||||
extern AllocatorInfo Allocator_TypeTable;
|
extern AllocatorInfo Allocator_TypeTable;
|
||||||
|
|
||||||
#endif
|
#endif
|
||||||
|
@ -183,6 +183,7 @@ void params_append( CodeParam appendee, CodeParam other )
|
|||||||
{
|
{
|
||||||
GEN_ASSERT(appendee);
|
GEN_ASSERT(appendee);
|
||||||
GEN_ASSERT(other);
|
GEN_ASSERT(other);
|
||||||
|
GEN_ASSERT_MSG(appendee != other, "Attempted to append parameter to itself.");
|
||||||
Code self = cast(Code, appendee);
|
Code self = cast(Code, appendee);
|
||||||
Code entry = cast(Code, other);
|
Code entry = cast(Code, other);
|
||||||
|
|
||||||
@ -250,7 +251,8 @@ CodeParam end_CodeParam(CodeParam params)
|
|||||||
forceinline
|
forceinline
|
||||||
CodeParam next_CodeParam(CodeParam params, CodeParam param_iter)
|
CodeParam next_CodeParam(CodeParam params, CodeParam param_iter)
|
||||||
{
|
{
|
||||||
return params->Next;
|
GEN_ASSERT(param_iter);
|
||||||
|
return param_iter->Next;
|
||||||
}
|
}
|
||||||
#pragma endregion CodeParam
|
#pragma endregion CodeParam
|
||||||
|
|
||||||
|
@ -3,10 +3,10 @@
|
|||||||
#include "code_serialization.cpp"
|
#include "code_serialization.cpp"
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
namespace parser {
|
GEN_NS_PARSER_BEGIN
|
||||||
internal void init();
|
internal void init();
|
||||||
internal void deinit();
|
internal void deinit();
|
||||||
}
|
GEN_NS_PARSER_END
|
||||||
|
|
||||||
internal
|
internal
|
||||||
void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
|
void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
|
||||||
|
@ -266,4 +266,55 @@ Code untyped_token_fmt( char const* fmt, s32 num_tokens, ... );
|
|||||||
|
|
||||||
#pragma endregion Untyped text
|
#pragma endregion Untyped text
|
||||||
|
|
||||||
|
#pragma region Macros
|
||||||
|
|
||||||
|
#ifndef token_fmt
|
||||||
|
# define gen_main main
|
||||||
|
|
||||||
|
# define __ NullCode
|
||||||
|
|
||||||
|
// Convienence for defining any name used with the gen api.
|
||||||
|
// Lets you provide the length and string literal to the functions without the need for the DSL.
|
||||||
|
# define name( Id_ ) { sizeof(stringize( Id_ )) - 1, stringize(Id_) }
|
||||||
|
|
||||||
|
// Same as name just used to indicate intention of literal for code instead of names.
|
||||||
|
# define code( ... ) { sizeof(stringize(__VA_ARGS__)) - 1, stringize( __VA_ARGS__ ) }
|
||||||
|
|
||||||
|
// Provides the number of arguments while passing args inplace.
|
||||||
|
# define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__
|
||||||
|
|
||||||
|
// Just wrappers over common untyped code definition constructions.
|
||||||
|
# define code_str( ... ) GEN_NS untyped_str( code( __VA_ARGS__ ) )
|
||||||
|
# define code_fmt( ... ) GEN_NS untyped_str( token_fmt( __VA_ARGS__ ) )
|
||||||
|
|
||||||
|
# define parse_fmt( type, ... ) GEN_NS parse_##type( token_fmt( __VA_ARGS__ ) )
|
||||||
|
|
||||||
|
/*
|
||||||
|
Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
|
||||||
|
Tokens are provided in '<'identifier'>' format where '<' '>' are just angle brakcets (you can change it in token_fmt_va)
|
||||||
|
---------------------------------------------------------
|
||||||
|
Example - A string with:
|
||||||
|
typedef <type> <name> <name>;
|
||||||
|
Will have a token_fmt arguments populated with:
|
||||||
|
"type", strc_for_type,
|
||||||
|
"name", strc_for_name,
|
||||||
|
and:
|
||||||
|
stringize( typedef <type> <name> <name>; ) )
|
||||||
|
-----------------------------------------------------------
|
||||||
|
So the full call for this example would be:
|
||||||
|
token_fmt(
|
||||||
|
"type", strc_for_type
|
||||||
|
, "name", strc_for_name
|
||||||
|
, stringize(
|
||||||
|
typedef <type> <name> <name>
|
||||||
|
));
|
||||||
|
!----------------------------------------------------------
|
||||||
|
! Note: token_fmt_va is whitespace sensitive for the tokens.
|
||||||
|
! This can be alleviated by skipping whitespace between brackets but it was choosen to not have that implementation by default.
|
||||||
|
*/
|
||||||
|
# define token_fmt( ... ) GEN_NS token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#pragma endregion Macros
|
||||||
|
|
||||||
#pragma endregion Gen Interface
|
#pragma endregion Gen Interface
|
||||||
|
@ -1614,6 +1614,13 @@ CodeBody parse_global_nspace( CodeType which )
|
|||||||
|
|
||||||
switch ( currtok_noskip.Type )
|
switch ( currtok_noskip.Type )
|
||||||
{
|
{
|
||||||
|
case Tok_Comma:
|
||||||
|
{
|
||||||
|
log_failure("Dangling comma found: %S\nContext:\n%S", to_string(currtok), to_string(Context));
|
||||||
|
pop( & Context);
|
||||||
|
return InvalidCode;
|
||||||
|
}
|
||||||
|
break;
|
||||||
case Tok_Statement_End:
|
case Tok_Statement_End:
|
||||||
{
|
{
|
||||||
// TODO(Ed): Convert this to a general warning procedure
|
// TODO(Ed): Convert this to a general warning procedure
|
||||||
@ -1885,7 +1892,7 @@ CodeBody parse_global_nspace( CodeType which )
|
|||||||
|
|
||||||
if ( member == Code_Invalid )
|
if ( member == Code_Invalid )
|
||||||
{
|
{
|
||||||
log_failure( "Failed to parse member\n%s", to_string(Context) );
|
log_failure( "Failed to parse member\nToken: %s\nContext:\n%s", to_string(currtok_noskip), to_string(Context) );
|
||||||
pop(& Context);
|
pop(& Context);
|
||||||
return InvalidCode;
|
return InvalidCode;
|
||||||
}
|
}
|
||||||
|
@ -13,7 +13,7 @@ using LogFailType = ssize(*)(char const*, ...);
|
|||||||
#define log_failure GEN_FATAL
|
#define log_failure GEN_FATAL
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
enum AccessSpec enum_underlying(u32)
|
enum AccessSpec : u32
|
||||||
{
|
{
|
||||||
AccessSpec_Default,
|
AccessSpec_Default,
|
||||||
AccessSpec_Private,
|
AccessSpec_Private,
|
||||||
@ -28,7 +28,7 @@ enum AccessSpec enum_underlying(u32)
|
|||||||
static_assert( size_of(AccessSpec) == size_of(u32), "AccessSpec not u32 size" );
|
static_assert( size_of(AccessSpec) == size_of(u32), "AccessSpec not u32 size" );
|
||||||
|
|
||||||
inline
|
inline
|
||||||
char const* to_str( AccessSpec type )
|
char const* access_spec_to_str( AccessSpec type )
|
||||||
{
|
{
|
||||||
local_persist
|
local_persist
|
||||||
char const* lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
|
char const* lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
|
||||||
@ -44,7 +44,7 @@ char const* to_str( AccessSpec type )
|
|||||||
return lookup[ (u32)type ];
|
return lookup[ (u32)type ];
|
||||||
}
|
}
|
||||||
|
|
||||||
enum CodeFlag enum_underlying(u32)
|
enum CodeFlag : u32
|
||||||
{
|
{
|
||||||
CodeFlag_None = 0,
|
CodeFlag_None = 0,
|
||||||
CodeFlag_FunctionType = bit(0),
|
CodeFlag_FunctionType = bit(0),
|
||||||
@ -57,7 +57,7 @@ enum CodeFlag enum_underlying(u32)
|
|||||||
static_assert( size_of(CodeFlag) == size_of(u32), "CodeFlag not u32 size" );
|
static_assert( size_of(CodeFlag) == size_of(u32), "CodeFlag not u32 size" );
|
||||||
|
|
||||||
// Used to indicate if enum definitoin is an enum class or regular enum.
|
// Used to indicate if enum definitoin is an enum class or regular enum.
|
||||||
enum EnumDecl enum_underlying(u8)
|
enum EnumDecl : u8
|
||||||
{
|
{
|
||||||
EnumDecl_Regular,
|
EnumDecl_Regular,
|
||||||
EnumDecl_Class,
|
EnumDecl_Class,
|
||||||
@ -66,7 +66,7 @@ enum EnumDecl enum_underlying(u8)
|
|||||||
};
|
};
|
||||||
typedef u8 EnumT;
|
typedef u8 EnumT;
|
||||||
|
|
||||||
enum ModuleFlag enum_underlying(u32)
|
enum ModuleFlag : u32
|
||||||
{
|
{
|
||||||
ModuleFlag_None = 0,
|
ModuleFlag_None = 0,
|
||||||
ModuleFlag_Export = bit(0),
|
ModuleFlag_Export = bit(0),
|
||||||
@ -80,28 +80,24 @@ enum ModuleFlag enum_underlying(u32)
|
|||||||
static_assert( size_of(ModuleFlag) == size_of(u32), "ModuleFlag not u32 size" );
|
static_assert( size_of(ModuleFlag) == size_of(u32), "ModuleFlag not u32 size" );
|
||||||
|
|
||||||
inline
|
inline
|
||||||
StrC to_str( ModuleFlag flag )
|
StrC module_flag_to_str( ModuleFlag flag )
|
||||||
{
|
{
|
||||||
local_persist
|
local_persist
|
||||||
StrC lookup[ (u32)ModuleFlag::Num_ModuleFlags ] = {
|
StrC lookup[ (u32)Num_ModuleFlags ] = {
|
||||||
{ sizeof("__none__"), "__none__" },
|
{ sizeof("__none__"), "__none__" },
|
||||||
{ sizeof("export"), "export" },
|
{ sizeof("export"), "export" },
|
||||||
{ sizeof("import"), "import" },
|
{ sizeof("import"), "import" },
|
||||||
};
|
};
|
||||||
|
|
||||||
|
local_persist
|
||||||
|
StrC invalid_flag = { sizeof("invalid"), "invalid" };
|
||||||
if ( flag > ModuleFlag_Import )
|
if ( flag > ModuleFlag_Import )
|
||||||
return { sizeof("invalid"), "invalid" };
|
return invalid_flag;
|
||||||
|
|
||||||
return lookup[ (u32)flag ];
|
return lookup[ (u32)flag ];
|
||||||
}
|
}
|
||||||
|
|
||||||
inline
|
enum EPreprocessCond : u32
|
||||||
ModuleFlag operator|( ModuleFlag A, ModuleFlag B)
|
|
||||||
{
|
|
||||||
return (ModuleFlag)( (u32)A | (u32)B );
|
|
||||||
}
|
|
||||||
|
|
||||||
enum EPreprocessCond enum_underlying(u32)
|
|
||||||
{
|
{
|
||||||
PreprocessCond_If,
|
PreprocessCond_If,
|
||||||
PreprocessCond_IfDef,
|
PreprocessCond_IfDef,
|
||||||
|
@ -66,27 +66,27 @@ struct Array
|
|||||||
Type* Data;
|
Type* Data;
|
||||||
|
|
||||||
#pragma region Member Mapping
|
#pragma region Member Mapping
|
||||||
forceinline static Array init(AllocatorInfo allocator) { return GEN_NS array_init<Type>(allocator); }
|
forceinline static Array init(AllocatorInfo allocator) { return array_init<Type>(allocator); }
|
||||||
forceinline static Array init_reserve(AllocatorInfo allocator, ssize capacity) { return GEN_NS array_init_reserve<Type>(allocator, capacity); }
|
forceinline static Array init_reserve(AllocatorInfo allocator, ssize capacity) { return array_init_reserve<Type>(allocator, capacity); }
|
||||||
forceinline static usize grow_formula(ssize value) { return GEN_NS array_grow_formula<Type>(value); }
|
forceinline static usize grow_formula(ssize value) { return array_grow_formula<Type>(value); }
|
||||||
|
|
||||||
forceinline bool append(Array other) { return GEN_NS array_append_array<Type>(this, other); }
|
forceinline bool append(Array other) { return array_append_array<Type>(this, other); }
|
||||||
forceinline bool append(Type value) { return GEN_NS array_append<Type>(this, value); }
|
forceinline bool append(Type value) { return array_append<Type>(this, value); }
|
||||||
forceinline bool append(Type* items, usize item_num) { return GEN_NS array_append_items<Type>(this, items, item_num); }
|
forceinline bool append(Type* items, usize item_num) { return array_append_items<Type>(this, items, item_num); }
|
||||||
forceinline bool append_at(Type item, usize idx) { return GEN_NS array_append_at<Type>(this, item, idx); }
|
forceinline bool append_at(Type item, usize idx) { return array_append_at<Type>(this, item, idx); }
|
||||||
forceinline bool append_at(Type* items, usize item_num, usize idx) { return GEN_NS array_append_items_at<Type>(this, items, item_num, idx); }
|
forceinline bool append_at(Type* items, usize item_num, usize idx) { return array_append_items_at<Type>(this, items, item_num, idx); }
|
||||||
forceinline Type* back() { return GEN_NS array_back<Type>(* this); }
|
forceinline Type* back() { return array_back<Type>(* this); }
|
||||||
forceinline void clear() { GEN_NS array_clear<Type>(* this); }
|
forceinline void clear() { array_clear<Type>(* this); }
|
||||||
forceinline bool fill(usize begin, usize end, Type value) { return GEN_NS array_fill<Type>(* this, begin, end, value); }
|
forceinline bool fill(usize begin, usize end, Type value) { return array_fill<Type>(* this, begin, end, value); }
|
||||||
forceinline void free() { GEN_NS array_free<Type>(this); }
|
forceinline void free() { array_free<Type>(this); }
|
||||||
forceinline ArrayHeader* get_header() { return GEN_NS array_get_header<Type>(* this); }
|
forceinline ArrayHeader* get_header() { return array_get_header<Type>(* this); }
|
||||||
forceinline bool grow(usize min_capacity) { return GEN_NS array_grow<Type>(this, min_capacity); }
|
forceinline bool grow(usize min_capacity) { return array_grow<Type>(this, min_capacity); }
|
||||||
forceinline usize num() { return GEN_NS array_num<Type>(*this); }
|
forceinline usize num() { return array_num<Type>(*this); }
|
||||||
forceinline void pop() { GEN_NS array_pop<Type>(* this); }
|
forceinline void pop() { array_pop<Type>(* this); }
|
||||||
forceinline void remove_at(usize idx) { GEN_NS array_remove_at<Type>(* this, idx); }
|
forceinline void remove_at(usize idx) { array_remove_at<Type>(* this, idx); }
|
||||||
forceinline bool reserve(usize new_capacity) { return GEN_NS array_reserve<Type>(this, new_capacity); }
|
forceinline bool reserve(usize new_capacity) { return array_reserve<Type>(this, new_capacity); }
|
||||||
forceinline bool resize(usize num) { return GEN_NS array_resize<Type>(this, num); }
|
forceinline bool resize(usize num) { return array_resize<Type>(this, num); }
|
||||||
forceinline bool set_capacity(usize new_capacity) { return GEN_NS array_set_capacity<Type>(this, new_capacity); }
|
forceinline bool set_capacity(usize new_capacity) { return array_set_capacity<Type>(this, new_capacity); }
|
||||||
#pragma endregion Member Mapping
|
#pragma endregion Member Mapping
|
||||||
|
|
||||||
forceinline operator Type*() { return Data; }
|
forceinline operator Type*() { return Data; }
|
||||||
@ -102,16 +102,16 @@ struct Array
|
|||||||
#endif
|
#endif
|
||||||
|
|
||||||
#if GEN_COMPILER_CPP && 0
|
#if GEN_COMPILER_CPP && 0
|
||||||
template<class Type> bool append(Array<Type>& array, Array<Type> other) { return GEN_NS append( & array, other ); }
|
template<class Type> bool append(Array<Type>& array, Array<Type> other) { return append( & array, other ); }
|
||||||
template<class Type> bool append(Array<Type>& array, Type value) { return GEN_NS append( & array, value ); }
|
template<class Type> bool append(Array<Type>& array, Type value) { return append( & array, value ); }
|
||||||
template<class Type> bool append(Array<Type>& array, Type* items, usize item_num) { return GEN_NS append( & array, items, item_num ); }
|
template<class Type> bool append(Array<Type>& array, Type* items, usize item_num) { return append( & array, items, item_num ); }
|
||||||
template<class Type> bool append_at(Array<Type>& array, Type item, usize idx) { return GEN_NS append_at( & array, item, idx ); }
|
template<class Type> bool append_at(Array<Type>& array, Type item, usize idx) { return append_at( & array, item, idx ); }
|
||||||
template<class Type> bool append_at(Array<Type>& array, Type* items, usize item_num, usize idx) { return GEN_NS append_at( & array, items, item_num, idx ); }
|
template<class Type> bool append_at(Array<Type>& array, Type* items, usize item_num, usize idx) { return append_at( & array, items, item_num, idx ); }
|
||||||
template<class Type> void free(Array<Type>& array) { return GEN_NS free( & array ); }
|
template<class Type> void free(Array<Type>& array) { return free( & array ); }
|
||||||
template<class Type> bool grow(Array<Type>& array, usize min_capacity) { return GEN_NS grow( & array, min_capacity); }
|
template<class Type> bool grow(Array<Type>& array, usize min_capacity) { return grow( & array, min_capacity); }
|
||||||
template<class Type> bool reserve(Array<Type>& array, usize new_capacity) { return GEN_NS reserve( & array, new_capacity); }
|
template<class Type> bool reserve(Array<Type>& array, usize new_capacity) { return reserve( & array, new_capacity); }
|
||||||
template<class Type> bool resize(Array<Type>& array, usize num) { return GEN_NS resize( & array, num); }
|
template<class Type> bool resize(Array<Type>& array, usize num) { return resize( & array, num); }
|
||||||
template<class Type> bool set_capacity(Array<Type>& array, usize new_capacity) { return GEN_NS set_capacity( & array, new_capacity); }
|
template<class Type> bool set_capacity(Array<Type>& array, usize new_capacity) { return set_capacity( & array, new_capacity); }
|
||||||
|
|
||||||
template<class Type> forceinline Type* begin(Array<Type>& array) { return array; }
|
template<class Type> forceinline Type* begin(Array<Type>& array) { return array; }
|
||||||
template<class Type> forceinline Type* end(Array<Type>& array) { return array + array_get_header(array)->Num; }
|
template<class Type> forceinline Type* end(Array<Type>& array) { return array + array_get_header(array)->Num; }
|
||||||
@ -493,23 +493,23 @@ struct HashTable
|
|||||||
Array<ssize> Hashes;
|
Array<ssize> Hashes;
|
||||||
Array<HashTableEntry<Type>> Entries;
|
Array<HashTableEntry<Type>> Entries;
|
||||||
|
|
||||||
#if GEN_SUPPORT_CPP_MEMBER_FEATURES
|
#if ! GEN_C_LIKE_CPP
|
||||||
#pragma region Member Mapping
|
#pragma region Member Mapping
|
||||||
forceinline static HashTable init(AllocatorInfo allocator) { return GEN_NS hashtable_init<Type>(allocator); }
|
forceinline static HashTable init(AllocatorInfo allocator) { return hashtable_init<Type>(allocator); }
|
||||||
forceinline static HashTable init_reserve(AllocatorInfo allocator, usize num) { return GEN_NS hashtable_init_reserve<Type>(allocator, num); }
|
forceinline static HashTable init_reserve(AllocatorInfo allocator, usize num) { return hashtable_init_reserve<Type>(allocator, num); }
|
||||||
|
|
||||||
forceinline void clear() { GEN_NS clear<Type>(*this); }
|
forceinline void clear() { clear<Type>(*this); }
|
||||||
forceinline void destroy() { GEN_NS destroy<Type>(*this); }
|
forceinline void destroy() { destroy<Type>(*this); }
|
||||||
forceinline Type* get(u64 key) { return GEN_NS get<Type>(*this, key); }
|
forceinline Type* get(u64 key) { return get<Type>(*this, key); }
|
||||||
forceinline void grow() { GEN_NS grow<Type>(*this); }
|
forceinline void grow() { grow<Type>(*this); }
|
||||||
forceinline void rehash(ssize new_num) { GEN_NS rehash<Type>(*this, new_num); }
|
forceinline void rehash(ssize new_num) { rehash<Type>(*this, new_num); }
|
||||||
forceinline void rehash_fast() { GEN_NS rehash_fast<Type>(*this); }
|
forceinline void rehash_fast() { rehash_fast<Type>(*this); }
|
||||||
forceinline void remove(u64 key) { GEN_NS remove<Type>(*this, key); }
|
forceinline void remove(u64 key) { remove<Type>(*this, key); }
|
||||||
forceinline void remove_entry(ssize idx) { GEN_NS remove_entry<Type>(*this, idx); }
|
forceinline void remove_entry(ssize idx) { remove_entry<Type>(*this, idx); }
|
||||||
forceinline void set(u64 key, Type value) { GEN_NS set<Type>(*this, key, value); }
|
forceinline void set(u64 key, Type value) { set<Type>(*this, key, value); }
|
||||||
forceinline ssize slot(u64 key) { return GEN_NS slot<Type>(*this, key); }
|
forceinline ssize slot(u64 key) { return slot<Type>(*this, key); }
|
||||||
forceinline void map(void (*proc)(u64, Type)) { GEN_NS map<Type>(*this, proc); }
|
forceinline void map(void (*proc)(u64, Type)) { map<Type>(*this, proc); }
|
||||||
forceinline void map_mut(void (*proc)(u64, Type*)) { GEN_NS map_mut<Type>(*this, proc); }
|
forceinline void map_mut(void (*proc)(u64, Type*)) { map_mut<Type>(*this, proc); }
|
||||||
#pragma endregion Member Mapping
|
#pragma endregion Member Mapping
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
|
@ -7,9 +7,9 @@
|
|||||||
|
|
||||||
#pragma region Debug
|
#pragma region Debug
|
||||||
|
|
||||||
void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... )
|
void assert_handler( char const* condition, char const* file, char const* function, s32 line, char const* msg, ... )
|
||||||
{
|
{
|
||||||
_printf_err( "%s:(%d): Assert Failure: ", file, line );
|
_printf_err( "%s - %s:(%d): Assert Failure: ", file, function, line );
|
||||||
|
|
||||||
if ( condition )
|
if ( condition )
|
||||||
_printf_err( "`%s` \n", condition );
|
_printf_err( "`%s` \n", condition );
|
||||||
|
@ -24,7 +24,7 @@
|
|||||||
{ \
|
{ \
|
||||||
if ( ! ( cond ) ) \
|
if ( ! ( cond ) ) \
|
||||||
{ \
|
{ \
|
||||||
assert_handler( #cond, __FILE__, scast( s64, __LINE__ ), msg, ##__VA_ARGS__ ); \
|
assert_handler( #cond, __FILE__, __func__, scast( s64, __LINE__ ), msg, ##__VA_ARGS__ ); \
|
||||||
GEN_DEBUG_TRAP(); \
|
GEN_DEBUG_TRAP(); \
|
||||||
} \
|
} \
|
||||||
} while ( 0 )
|
} while ( 0 )
|
||||||
@ -56,7 +56,7 @@
|
|||||||
while (0)
|
while (0)
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... );
|
void assert_handler( char const* condition, char const* file, char const* function, s32 line, char const* msg, ... );
|
||||||
s32 assert_crash( char const* condition );
|
s32 assert_crash( char const* condition );
|
||||||
void process_exit( u32 code );
|
void process_exit( u32 code );
|
||||||
|
|
||||||
|
@ -5,8 +5,6 @@
|
|||||||
|
|
||||||
#pragma region File Handling
|
#pragma region File Handling
|
||||||
|
|
||||||
typedef u32 FileMode;
|
|
||||||
|
|
||||||
enum FileModeFlag
|
enum FileModeFlag
|
||||||
{
|
{
|
||||||
EFileMode_READ = bit( 0 ),
|
EFileMode_READ = bit( 0 ),
|
||||||
@ -45,6 +43,7 @@ union FileDescriptor
|
|||||||
uptr u;
|
uptr u;
|
||||||
};
|
};
|
||||||
|
|
||||||
|
typedef u32 FileMode;
|
||||||
typedef struct FileOperations FileOperations;
|
typedef struct FileOperations FileOperations;
|
||||||
|
|
||||||
#define GEN_FILE_OPEN_PROC( name ) FileError name( FileDescriptor* fd, FileOperations* ops, FileMode mode, char const* filename )
|
#define GEN_FILE_OPEN_PROC( name ) FileError name( FileDescriptor* fd, FileOperations* ops, FileMode mode, char const* filename )
|
||||||
@ -107,7 +106,6 @@ struct FileInfo
|
|||||||
FileTime last_write_time;
|
FileTime last_write_time;
|
||||||
DirEntry* dir;
|
DirEntry* dir;
|
||||||
};
|
};
|
||||||
typedef struct FileInfo FileInfo;
|
|
||||||
|
|
||||||
enum FileStandardType
|
enum FileStandardType
|
||||||
{
|
{
|
||||||
@ -117,7 +115,6 @@ enum FileStandardType
|
|||||||
|
|
||||||
EFileStandard_COUNT,
|
EFileStandard_COUNT,
|
||||||
};
|
};
|
||||||
typedef enum FileStandardType FileStandardType;
|
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* Get standard file I/O.
|
* Get standard file I/O.
|
||||||
|
@ -193,17 +193,17 @@ struct Arena
|
|||||||
ssize TotalUsed;
|
ssize TotalUsed;
|
||||||
ssize TempCount;
|
ssize TempCount;
|
||||||
|
|
||||||
#if GEN_COMPILER_CPP
|
#if ! GEN_C_LIKE_CPP
|
||||||
#pragma region Member Mapping
|
#pragma region Member Mapping
|
||||||
forceinline operator AllocatorInfo() { return GEN_NS arena_allocator_info(this); }
|
forceinline operator AllocatorInfo() { return arena_allocator_info(this); }
|
||||||
|
|
||||||
forceinline static void* allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags ) { return GEN_NS arena_allocator_proc( allocator_data, type, size, alignment, old_memory, old_size, flags ); }
|
forceinline static void* allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags ) { return arena_allocator_proc( allocator_data, type, size, alignment, old_memory, old_size, flags ); }
|
||||||
forceinline static Arena init_from_memory( void* start, ssize size ) { return GEN_NS arena_init_from_memory( start, size ); }
|
forceinline static Arena init_from_memory( void* start, ssize size ) { return arena_init_from_memory( start, size ); }
|
||||||
forceinline static Arena init_from_allocator( AllocatorInfo backing, ssize size ) { return GEN_NS arena_init_from_allocator( backing, size ); }
|
forceinline static Arena init_from_allocator( AllocatorInfo backing, ssize size ) { return arena_init_from_allocator( backing, size ); }
|
||||||
forceinline static Arena init_sub( Arena& parent, ssize size ) { return GEN_NS arena_init_from_allocator( parent.Backing, size ); }
|
forceinline static Arena init_sub( Arena& parent, ssize size ) { return arena_init_from_allocator( parent.Backing, size ); }
|
||||||
forceinline ssize alignment_of( ssize alignment ) { return GEN_NS arena_alignment_of(this, alignment); }
|
forceinline ssize alignment_of( ssize alignment ) { return arena_alignment_of(this, alignment); }
|
||||||
forceinline void free() { return GEN_NS arena_free(this); }
|
forceinline void free() { return arena_free(this); }
|
||||||
forceinline ssize size_remaining( ssize alignment ) { return GEN_NS arena_size_remaining(this, alignment); }
|
forceinline ssize size_remaining( ssize alignment ) { return arena_size_remaining(this, alignment); }
|
||||||
|
|
||||||
// This id is defined by Unreal for asserts
|
// This id is defined by Unreal for asserts
|
||||||
#pragma push_macro("check")
|
#pragma push_macro("check")
|
||||||
@ -320,7 +320,7 @@ template<s32 Size> FixedArena<Size> fixed_arena_init();
|
|||||||
template<s32 Size> AllocatorInfo fixed_arena_allocator_info(FixedArena<Size>* fixed_arena );
|
template<s32 Size> AllocatorInfo fixed_arena_allocator_info(FixedArena<Size>* fixed_arena );
|
||||||
template<s32 Size> ssize fixed_arena_size_remaining(FixedArena<Size>* fixed_arena, ssize alignment);
|
template<s32 Size> ssize fixed_arena_size_remaining(FixedArena<Size>* fixed_arena, ssize alignment);
|
||||||
|
|
||||||
#if 0
|
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
|
||||||
template<s32 Size> AllocatorInfo allocator_info( FixedArena<Size>& fixed_arena ) { return allocator_info(& fixed_arena); }
|
template<s32 Size> AllocatorInfo allocator_info( FixedArena<Size>& fixed_arena ) { return allocator_info(& fixed_arena); }
|
||||||
template<s32 Size> ssize size_remaining(FixedArena<Size>& fixed_arena, ssize alignment) { return size_remaining( & fixed_arena, alignment); }
|
template<s32 Size> ssize size_remaining(FixedArena<Size>& fixed_arena, ssize alignment) { return size_remaining( & fixed_arena, alignment); }
|
||||||
#endif
|
#endif
|
||||||
@ -333,12 +333,12 @@ struct FixedArena
|
|||||||
char memory[Size];
|
char memory[Size];
|
||||||
Arena arena;
|
Arena arena;
|
||||||
|
|
||||||
#if 0
|
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
|
||||||
#pragma region Member Mapping
|
#pragma region Member Mapping
|
||||||
forceinline operator AllocatorInfo() { return GEN_NS allocator_info(this); }
|
forceinline operator AllocatorInfo() { return GEN_NS allocator_info(this); }
|
||||||
|
|
||||||
forceinline static FixedArena init() { FixedArena result; GEN_NS fixed_arena_init<Size>(result); return result; }
|
forceinline static FixedArena init() { FixedArena result; fixed_arena_init<Size>(result); return result; }
|
||||||
forceinline ssize size_remaining(ssize alignment) { GEN_NS size_remaining(this, alignment); }
|
forceinline ssize size_remaining(ssize alignment) { fixed_arena_size_remaining(this, alignment); }
|
||||||
#pragma endregion Member Mapping
|
#pragma endregion Member Mapping
|
||||||
#endif
|
#endif
|
||||||
};
|
};
|
||||||
@ -390,7 +390,7 @@ AllocatorInfo pool_allocator_info(Pool* pool);
|
|||||||
void pool_clear(Pool* pool);
|
void pool_clear(Pool* pool);
|
||||||
void pool_free(Pool* pool);
|
void pool_free(Pool* pool);
|
||||||
|
|
||||||
#if 0
|
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
|
||||||
AllocatorInfo allocator_info(Pool& pool) { return pool_allocator_info(& pool); }
|
AllocatorInfo allocator_info(Pool& pool) { return pool_allocator_info(& pool); }
|
||||||
void clear(Pool& pool) { return pool_clear(& pool); }
|
void clear(Pool& pool) { return pool_clear(& pool); }
|
||||||
void free(Pool& pool) { return pool_free(& pool); }
|
void free(Pool& pool) { return pool_free(& pool); }
|
||||||
@ -406,15 +406,15 @@ struct Pool
|
|||||||
ssize TotalSize;
|
ssize TotalSize;
|
||||||
ssize NumBlocks;
|
ssize NumBlocks;
|
||||||
|
|
||||||
#if ! GEN_C_LIKE_CPP
|
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
|
||||||
#pragma region Member Mapping
|
#pragma region Member Mapping
|
||||||
forceinline operator AllocatorInfo() { return GEN_NS pool_allocator_info(this); }
|
forceinline operator AllocatorInfo() { return pool_allocator_info(this); }
|
||||||
|
|
||||||
forceinline static void* allocator_proc(void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags) { return GEN_NS pool_allocator_proc(allocator_data, type, size, alignment, old_memory, old_size, flags); }
|
forceinline static void* allocator_proc(void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags) { return pool_allocator_proc(allocator_data, type, size, alignment, old_memory, old_size, flags); }
|
||||||
forceinline static Pool init(AllocatorInfo backing, ssize num_blocks, ssize block_size) { return GEN_NS pool_init(backing, num_blocks, block_size); }
|
forceinline static Pool init(AllocatorInfo backing, ssize num_blocks, ssize block_size) { return pool_init(backing, num_blocks, block_size); }
|
||||||
forceinline static Pool init_align(AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align) { return GEN_NS pool_init_align(backing, num_blocks, block_size, block_align); }
|
forceinline static Pool init_align(AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align) { return pool_init_align(backing, num_blocks, block_size, block_align); }
|
||||||
forceinline void clear() { GEN_NS pool_clear( this); }
|
forceinline void clear() { pool_clear( this); }
|
||||||
forceinline void free() { GEN_NS pool_free( this); }
|
forceinline void free() { pool_free( this); }
|
||||||
#pragma endregion
|
#pragma endregion
|
||||||
#endif
|
#endif
|
||||||
};
|
};
|
||||||
|
@ -5,8 +5,7 @@
|
|||||||
|
|
||||||
#pragma region Strings
|
#pragma region Strings
|
||||||
|
|
||||||
struct StrC_Def;
|
struct StrC;
|
||||||
typedef struct StrC_Def StrC;
|
|
||||||
|
|
||||||
bool strc_are_equal (StrC lhs, StrC rhs);
|
bool strc_are_equal (StrC lhs, StrC rhs);
|
||||||
char const* strc_back (StrC str);
|
char const* strc_back (StrC str);
|
||||||
@ -17,7 +16,7 @@ StrC strc_to_str (char const* bad_string);
|
|||||||
StrC strc_visualize_whitespace(StrC str, AllocatorInfo allocator);
|
StrC strc_visualize_whitespace(StrC str, AllocatorInfo allocator);
|
||||||
|
|
||||||
// Constant string with length.
|
// Constant string with length.
|
||||||
struct StrC_Def
|
struct StrC
|
||||||
{
|
{
|
||||||
ssize Len;
|
ssize Len;
|
||||||
char const* Ptr;
|
char const* Ptr;
|
||||||
@ -27,12 +26,12 @@ struct StrC_Def
|
|||||||
forceinline char const& operator[]( ssize index ) const { return Ptr[index]; }
|
forceinline char const& operator[]( ssize index ) const { return Ptr[index]; }
|
||||||
|
|
||||||
#if ! GEN_C_LIKE_CPP
|
#if ! GEN_C_LIKE_CPP
|
||||||
forceinline bool is_equal (StrC rhs) const { return GEN_NS strc_are_equal(* this, rhs); }
|
forceinline bool is_equal (StrC rhs) const { return strc_are_equal(* this, rhs); }
|
||||||
forceinline char const* back () const { return GEN_NS strc_back(* this); }
|
forceinline char const* back () const { return strc_back(* this); }
|
||||||
forceinline bool contains (StrC substring) const { return GEN_NS strc_contains(* this, substring); }
|
forceinline bool contains (StrC substring) const { return strc_contains(* this, substring); }
|
||||||
forceinline StrC duplicate (AllocatorInfo allocator) const { return GEN_NS strc_duplicate(* this, allocator); }
|
forceinline StrC duplicate (AllocatorInfo allocator) const { return strc_duplicate(* this, allocator); }
|
||||||
forceinline b32 starts_with (StrC substring) const { return GEN_NS strc_starts_with(* this, substring); }
|
forceinline b32 starts_with (StrC substring) const { return strc_starts_with(* this, substring); }
|
||||||
forceinline StrC visualize_whitespace(AllocatorInfo allocator) const { return GEN_NS strc_visualize_whitespace(* this, allocator); }
|
forceinline StrC visualize_whitespace(AllocatorInfo allocator) const { return strc_visualize_whitespace(* this, allocator); }
|
||||||
#endif
|
#endif
|
||||||
#endif
|
#endif
|
||||||
};
|
};
|
||||||
@ -113,8 +112,7 @@ StrC to_strc_from_c_str( char const* bad_str ) {
|
|||||||
// They used a header pattern
|
// They used a header pattern
|
||||||
// I kept it for simplicty of porting but its not necessary to keep it that way.
|
// I kept it for simplicty of porting but its not necessary to keep it that way.
|
||||||
#pragma region String
|
#pragma region String
|
||||||
struct StringHeader;
|
struct StringHeader;
|
||||||
typedef struct StringHeader StringHeader;
|
|
||||||
|
|
||||||
#if GEN_COMPILER_C
|
#if GEN_COMPILER_C
|
||||||
typedef char* String;
|
typedef char* String;
|
||||||
@ -267,11 +265,9 @@ struct String
|
|||||||
};
|
};
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
GEN_API_C_BEGIN
|
|
||||||
forceinline char* string_begin(String str) { return ((char*) str); }
|
forceinline char* string_begin(String str) { return ((char*) str); }
|
||||||
forceinline char* string_end (String str) { return ((char*) str + string_length(str)); }
|
forceinline char* string_end (String str) { return ((char*) str + string_length(str)); }
|
||||||
forceinline char* string_next (String str, char const* iter) { return ((char*) iter + 1); }
|
forceinline char* string_next (String str, char const* iter) { return ((char*) iter + 1); }
|
||||||
GEN_API_C_END
|
|
||||||
|
|
||||||
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
|
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
|
||||||
forceinline char* begin(String str) { return ((char*) str); }
|
forceinline char* begin(String str) { return ((char*) str); }
|
||||||
@ -617,7 +613,6 @@ void strip_space(String str)
|
|||||||
}
|
}
|
||||||
read_pos++;
|
read_pos++;
|
||||||
}
|
}
|
||||||
|
|
||||||
write_pos[0] = '\0'; // Null-terminate the modified string
|
write_pos[0] = '\0'; // Null-terminate the modified string
|
||||||
|
|
||||||
// Update the length if needed
|
// Update the length if needed
|
||||||
|
@ -1,61 +0,0 @@
|
|||||||
Invalid
|
|
||||||
Untyped
|
|
||||||
NewLine
|
|
||||||
Comment
|
|
||||||
Access_Private
|
|
||||||
Access_Protected
|
|
||||||
Access_Public
|
|
||||||
PlatformAttributes
|
|
||||||
Class
|
|
||||||
Class_Fwd
|
|
||||||
Class_Body
|
|
||||||
Constructor
|
|
||||||
Constructor_Fwd
|
|
||||||
Destructor
|
|
||||||
Destructor_Fwd
|
|
||||||
Enum
|
|
||||||
Enum_Fwd
|
|
||||||
Enum_Body
|
|
||||||
Enum_Class
|
|
||||||
Enum_Class_Fwd
|
|
||||||
Execution
|
|
||||||
Export_Body
|
|
||||||
Extern_Linkage
|
|
||||||
Extern_Linkage_Body
|
|
||||||
Friend
|
|
||||||
Function
|
|
||||||
Function_Fwd
|
|
||||||
Function_Body
|
|
||||||
Global_Body
|
|
||||||
Module
|
|
||||||
Namespace
|
|
||||||
Namespace_Body
|
|
||||||
Operator
|
|
||||||
Operator_Fwd
|
|
||||||
Operator_Member
|
|
||||||
Operator_Member_Fwd
|
|
||||||
Operator_Cast
|
|
||||||
Operator_Cast_Fwd
|
|
||||||
Parameters
|
|
||||||
Preprocess_Define
|
|
||||||
Preprocess_Include
|
|
||||||
Preprocess_If
|
|
||||||
Preprocess_IfDef
|
|
||||||
Preprocess_IfNotDef
|
|
||||||
Preprocess_ElIf
|
|
||||||
Preprocess_Else
|
|
||||||
Preprocess_EndIf
|
|
||||||
Preprocess_Pragma
|
|
||||||
Specifiers
|
|
||||||
Struct
|
|
||||||
Struct_Fwd
|
|
||||||
Struct_Body
|
|
||||||
Template
|
|
||||||
Typedef
|
|
||||||
Typename
|
|
||||||
Union
|
|
||||||
Union_Fwd
|
|
||||||
Union_Body
|
|
||||||
Using
|
|
||||||
Using_Namespace
|
|
||||||
Variable
|
|
|
61
project/enums/ECodeTypes.csv
Normal file
61
project/enums/ECodeTypes.csv
Normal file
@ -0,0 +1,61 @@
|
|||||||
|
Invalid, "__NA__"
|
||||||
|
Untyped, "__NA__"
|
||||||
|
NewLine, "__NA__"
|
||||||
|
Comment, "//"
|
||||||
|
Access_Private, "private"
|
||||||
|
Access_Protected, "protected"
|
||||||
|
Access_Public, "public"
|
||||||
|
PlatformAttributes, "__NA__"
|
||||||
|
Class, "class"
|
||||||
|
Class_Fwd, "clsss"
|
||||||
|
Class_Body, "__NA__"
|
||||||
|
Constructor, "__NA__"
|
||||||
|
Constructor_Fwd, "__NA__"
|
||||||
|
Destructor, "__NA__"
|
||||||
|
Destructor_Fwd, "__NA__"
|
||||||
|
Enum, "enum"
|
||||||
|
Enum_Fwd, "enum"
|
||||||
|
Enum_Body, "__NA__"
|
||||||
|
Enum_Class, "enum class"
|
||||||
|
Enum_Class_Fwd, "enum class"
|
||||||
|
Execution, "__NA__"
|
||||||
|
Export_Body, "__NA__"
|
||||||
|
Extern_Linkage, "extern"
|
||||||
|
Extern_Linkage_Body, "extern"
|
||||||
|
Friend, "friend"
|
||||||
|
Function, "__NA__"
|
||||||
|
Function_Fwd, "__NA__"
|
||||||
|
Function_Body, "__NA__"
|
||||||
|
Global_Body, "__NA__"
|
||||||
|
Module, "module"
|
||||||
|
Namespace, "namespace"
|
||||||
|
Namespace_Body, "__NA__"
|
||||||
|
Operator, "operator"
|
||||||
|
Operator_Fwd, "operator"
|
||||||
|
Operator_Member, "operator"
|
||||||
|
Operator_Member_Fwd, "operator"
|
||||||
|
Operator_Cast, "operator"
|
||||||
|
Operator_Cast_Fwd, "operator"
|
||||||
|
Parameters, "__NA__"
|
||||||
|
Preprocess_Define, "define"
|
||||||
|
Preprocess_Include, "include"
|
||||||
|
Preprocess_If, "if"
|
||||||
|
Preprocess_IfDef, "ifdef"
|
||||||
|
Preprocess_IfNotDef, "ifndef"
|
||||||
|
Preprocess_ElIf, "elif"
|
||||||
|
Preprocess_Else, "else"
|
||||||
|
Preprocess_EndIf, "endif"
|
||||||
|
Preprocess_Pragma, "pragma"
|
||||||
|
Specifiers, "__NA__"
|
||||||
|
Struct, "struct"
|
||||||
|
Struct_Fwd, "struct"
|
||||||
|
Struct_Body, "__NA__"
|
||||||
|
Template, "template"
|
||||||
|
Typedef, "typedef"
|
||||||
|
Typename, "__NA__"
|
||||||
|
Union, "union"
|
||||||
|
Union_Fwd, "union"
|
||||||
|
Union_Body, "__NA__"
|
||||||
|
Using, "using"
|
||||||
|
Using_Namespace, "using namespace"
|
||||||
|
Variable, "__NA__"
|
|
@ -10,7 +10,7 @@ using namespace gen;
|
|||||||
|
|
||||||
CodeBody gen_ecode( char const* path, bool use_c_definition = false )
|
CodeBody gen_ecode( char const* path, bool use_c_definition = false )
|
||||||
{
|
{
|
||||||
char scratch_mem[kilobytes(1)];
|
char scratch_mem[kilobytes(4)];
|
||||||
Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
|
Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) );
|
||||||
|
|
||||||
file_read_contents( arena_allocator_info( & scratch), file_zero_terminate, path );
|
file_read_contents( arena_allocator_info( & scratch), file_zero_terminate, path );
|
||||||
@ -19,16 +19,20 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
|
|||||||
csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false );
|
csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false );
|
||||||
|
|
||||||
Array<ADT_Node> enum_strs = csv_nodes.nodes[0].nodes;
|
Array<ADT_Node> enum_strs = csv_nodes.nodes[0].nodes;
|
||||||
|
Array<ADT_Node> keyword_strs = csv_nodes.nodes[1].nodes;
|
||||||
|
|
||||||
String enum_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
|
String enum_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
|
||||||
String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
|
String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
|
||||||
|
String to_keyword_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
|
||||||
|
|
||||||
for ( ADT_Node* node = array_begin(enum_strs); node != array_end(enum_strs); node = array_next(enum_strs, node) )
|
for ( ssize idx = 0; idx < array_num(enum_strs); ++ idx )
|
||||||
{
|
{
|
||||||
char const* code = node->string;
|
char const* code = enum_strs [idx].string;
|
||||||
|
char const* keyword = keyword_strs[idx].string;
|
||||||
|
|
||||||
string_append_fmt( & enum_entries, "CT_%s,\n", code );
|
string_append_fmt( & enum_entries, "CT_%s,\n", code );
|
||||||
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", code, code );
|
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", code, code );
|
||||||
|
string_append_fmt( & to_keyword_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", keyword, keyword );
|
||||||
}
|
}
|
||||||
|
|
||||||
CodeEnum enum_code;
|
CodeEnum enum_code;
|
||||||
@ -48,8 +52,9 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
|
|||||||
#pragma push_macro("local_persist")
|
#pragma push_macro("local_persist")
|
||||||
#undef local_persist
|
#undef local_persist
|
||||||
StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(enum_strs) ));
|
StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(enum_strs) ));
|
||||||
CodeFn to_str = parse_function( token_fmt(
|
CodeBody to_str_fns = parse_global_body( token_fmt(
|
||||||
"entries", string_to_strc(to_str_entries)
|
"entries", string_to_strc(to_str_entries)
|
||||||
|
, "keywords", string_to_strc(to_keyword_str_entries)
|
||||||
, "num", lookup_size
|
, "num", lookup_size
|
||||||
, stringize(
|
, stringize(
|
||||||
inline
|
inline
|
||||||
@ -59,17 +64,41 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
|
|||||||
StrC lookup[<num>] = {
|
StrC lookup[<num>] = {
|
||||||
<entries>
|
<entries>
|
||||||
};
|
};
|
||||||
|
return lookup[ type ];
|
||||||
|
}
|
||||||
|
|
||||||
|
inline
|
||||||
|
StrC codetype_to_keyword_str( CodeType type )
|
||||||
|
{
|
||||||
|
local_persist
|
||||||
|
StrC lookup[ <num> ] = {
|
||||||
|
<keywords>
|
||||||
|
};
|
||||||
return lookup[ type ];
|
return lookup[ type ];
|
||||||
}
|
}
|
||||||
)));
|
)));
|
||||||
#pragma pop_macro("local_persist")
|
#pragma pop_macro("local_persist")
|
||||||
|
|
||||||
//CodeNS nspace = def_namespace( name(ECode), def_namespace_body( args( enum_code, to_str ) ) );
|
CodeBody result = def_body(CT_Global_Body);
|
||||||
//CodeUsing code_t = def_using( name(CodeT), def_type( name(ECode::Type) ) );
|
body_append(result, enum_code);
|
||||||
|
body_append(result, to_str_fns);
|
||||||
|
if (! use_c_definition)
|
||||||
|
{
|
||||||
|
#pragma push_macro("forceinline")
|
||||||
|
#undef forceinline
|
||||||
|
CodeBody alias_mappings = parse_global_body(code(
|
||||||
|
forceinline StrC to_str (CodeType type) { return codetype_to_str(type); }
|
||||||
|
forceinline StrC to_keyword_str(CodeType type) { return codetype_to_keyword_str(type); }
|
||||||
|
));
|
||||||
|
#pragma pop_macro("forceinline")
|
||||||
|
body_append(result, alias_mappings);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
CodeTypedef code_t = parse_typedef(code(typedef enum CodeType CodeType; ));
|
CodeTypedef code_t = parse_typedef(code(typedef enum CodeType CodeType; ));
|
||||||
|
body_append(result, code_t);
|
||||||
return def_global_body( args( enum_code, code_t, to_str, fmt_newline ) );
|
}
|
||||||
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
|
CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
|
||||||
@ -142,11 +171,25 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
|
|||||||
)));
|
)));
|
||||||
#pragma pop_macro("local_persist")
|
#pragma pop_macro("local_persist")
|
||||||
|
|
||||||
//CodeNS nspace = def_namespace( name(EOperator), def_namespace_body( args( enum_code, to_str ) ) );
|
CodeBody result = def_body(CT_Global_Body);
|
||||||
//CodeUsing operator_t = def_using( name(OperatorT), def_type( name(EOperator::Type) ) );
|
body_append(result, enum_code);
|
||||||
|
body_append(result, to_str);
|
||||||
|
if (! use_c_definition)
|
||||||
|
{
|
||||||
|
#pragma push_macro("forceinline")
|
||||||
|
#undef forceinline
|
||||||
|
CodeBody alias_mappings = parse_global_body(code(
|
||||||
|
forceinline StrC to_str(Operator op) { return operator_to_str(op); }
|
||||||
|
));
|
||||||
|
#pragma pop_macro("forceinline")
|
||||||
|
body_append(result, alias_mappings);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
CodeTypedef operator_t = parse_typedef(code( typedef enum Operator Operator; ));
|
CodeTypedef operator_t = parse_typedef(code( typedef enum Operator Operator; ));
|
||||||
|
body_append(result, operator_t);
|
||||||
return def_global_body( args( enum_code, operator_t, to_str, fmt_newline ) );
|
}
|
||||||
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
CodeBody gen_especifier( char const* path, bool use_c_definition = false )
|
CodeBody gen_especifier( char const* path, bool use_c_definition = false )
|
||||||
@ -217,7 +260,6 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
|
|||||||
#undef do_once_end
|
#undef do_once_end
|
||||||
#undef forceinline
|
#undef forceinline
|
||||||
#undef neverinline
|
#undef neverinline
|
||||||
|
|
||||||
StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(enum_strs) ));
|
StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(enum_strs) ));
|
||||||
CodeFn to_str = parse_function(token_fmt(
|
CodeFn to_str = parse_function(token_fmt(
|
||||||
"entries", string_to_strc(to_str_entries)
|
"entries", string_to_strc(to_str_entries)
|
||||||
@ -269,11 +311,29 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
|
|||||||
#pragma pop_macro("forceinline")
|
#pragma pop_macro("forceinline")
|
||||||
#pragma pop_macro("neverinline")
|
#pragma pop_macro("neverinline")
|
||||||
|
|
||||||
//CodeNS nspace = def_namespace( name(ESpecifier), def_namespace_body( args( enum_code, is_trailing, to_str, to_type ) ) );
|
CodeBody result = def_body(CT_Global_Body);
|
||||||
//CodeUsing specifier_t = def_using( name(SpecifierT), def_type( name(ESpecifier::Type) ) );
|
body_append(result, enum_code);
|
||||||
|
body_append(result, to_str);
|
||||||
|
body_append(result, is_trailing);
|
||||||
|
body_append(result, to_type);
|
||||||
|
if (! use_c_definition)
|
||||||
|
{
|
||||||
|
#pragma push_macro("forceinline")
|
||||||
|
#undef forceinline
|
||||||
|
CodeBody alias_mappings = parse_global_body(code(
|
||||||
|
forceinline StrC to_str (Specifier spec) { return spec_to_str(spec); }
|
||||||
|
forceinline Specifier to_type( StrC str ) { return strc_to_specifier(str); }
|
||||||
|
forceinline bool is_trailing( Specifier specifier ) { return spec_is_trailing(specifier); }
|
||||||
|
));
|
||||||
|
#pragma pop_macro("forceinline")
|
||||||
|
body_append(result, alias_mappings);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
CodeTypedef specifier_t = parse_typedef( code(typedef enum Specifier Specifier; ));
|
CodeTypedef specifier_t = parse_typedef( code(typedef enum Specifier Specifier; ));
|
||||||
|
body_append(result, specifier_t);
|
||||||
return def_global_body( args( enum_code, specifier_t, is_trailing, to_str, to_type, fmt_newline ) );
|
}
|
||||||
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
|
CodeBody gen_etoktype( char const* etok_path, char const* attr_path )
|
||||||
|
@ -2,7 +2,6 @@
|
|||||||
# It will most likely need a partial rewrite to segment the build process into separate script invocations based on the OS.
|
# It will most likely need a partial rewrite to segment the build process into separate script invocations based on the OS.
|
||||||
# That or just rewrite it in an sh script and call it a day.
|
# That or just rewrite it in an sh script and call it a day.
|
||||||
|
|
||||||
$target_arch = Join-Path $PSScriptRoot 'helpers/target_arch.psm1'
|
|
||||||
$devshell = Join-Path $PSScriptRoot 'helpers/devshell.ps1'
|
$devshell = Join-Path $PSScriptRoot 'helpers/devshell.ps1'
|
||||||
$format_cpp = Join-Path $PSScriptRoot 'helpers/format_cpp.psm1'
|
$format_cpp = Join-Path $PSScriptRoot 'helpers/format_cpp.psm1'
|
||||||
$refactor_unreal = Join-Path $PSScriptRoot 'refactor_unreal.ps1'
|
$refactor_unreal = Join-Path $PSScriptRoot 'refactor_unreal.ps1'
|
||||||
@ -92,7 +91,6 @@ if ( $bootstrap -eq $false -and $singleheader -eq $false -and $c_library -eq $fa
|
|||||||
throw "No build target specified. One must be specified, this script will not assume one"
|
throw "No build target specified. One must be specified, this script will not assume one"
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
. $vendor_toolchain
|
. $vendor_toolchain
|
||||||
. $incremental_checks
|
. $incremental_checks
|
||||||
|
|
||||||
|
@ -1,4 +1,7 @@
|
|||||||
# This is meant to be used with build.ps1, and is not a standalone script.
|
# This is meant to be used with build.ps1, and is not a standalone script.
|
||||||
|
$target_arch = Join-Path $PSScriptRoot 'target_arch.psm1'
|
||||||
|
|
||||||
|
import-module $target_arch
|
||||||
|
|
||||||
if ($IsWindows) {
|
if ($IsWindows) {
|
||||||
# This HandmadeHero implementation is only designed for 64-bit systems
|
# This HandmadeHero implementation is only designed for 64-bit systems
|
||||||
|
Loading…
Reference in New Issue
Block a user