Compare commits

..

14 Commits

Author SHA1 Message Date
Ed_
b5cf633e98 Updated c_library generation to support latest changes with context struct (also prepped for static/dynamic linkage) 2024-12-13 22:09:43 -05:00
Ed_
16d0e0834f All global vars (except concepts) have been retrofitetd to the library's new Context struct 2024-12-13 20:40:18 -05:00
Ed_
76ac3a0f93 Introduced the general context struct for gencpp 2024-12-13 19:16:52 -05:00
Ed_
78bcc21130 Merge branch 'string_distinctings_refactor' 2024-12-13 16:35:13 -05:00
Ed_
a125653448 attempted to fix formatting for _Generic macros in the c11 generation (failed) 2024-12-13 16:34:47 -05:00
Ed_
aa2170ba80
Merge pull request #63 from Ed94/string_distinctings_refactor
Resolved https://github.com/Ed94/gencpp/issues/56
2024-12-13 12:58:53 -08:00
Ed_
5705196710 formatting fixes to C library generator 2024-12-13 15:56:57 -05:00
Ed_
cf0d787196 corrected formatting for gen_segmented 2024-12-13 15:44:29 -05:00
Ed_
8d436fe546 correct formatting in singleheader.cpp 2024-12-13 15:42:13 -05:00
Ed_
e15ac22132 Made Token::Text/Length into Str Text; (Str slice) 2024-12-13 15:36:40 -05:00
Ed_
bac57a5872 Corrected enum serialization of ecodetypes, eoperator, especifier, and etoktype, some more naming refactors for strbuilder... formatting 2024-12-13 14:38:27 -05:00
Ed_
012fcb6bd5 Corrected order of Str to how the slice type is defined in Odin and RAD Debugger (my reference on slice types) 2024-12-13 13:20:16 -05:00
Ed_
6ffdca8595 formatting, fixes from testing latest in Odin fork 2024-12-13 11:56:07 -05:00
Ed_
e3172057d3 working to towards https://github.com/Ed94/gencpp/issues/56 2024-12-12 12:55:15 -05:00
73 changed files with 4102 additions and 4636 deletions

View File

View File

@ -148,9 +148,9 @@ The convention you'll see used throughout the upfront interface of the library i
1. Check name or parameters to make sure they are valid for the construction requested 1. Check name or parameters to make sure they are valid for the construction requested
2. Create a code object using `make_code`. 2. Create a code object using `make_code`.
3. Populate immediate fields (Name, Type, ModuleFlags, etc) 3. Populate immediate fields (Name, Type, ModuleFlags, etc)
4. Populate sub-entires using `add_entry`. If using the default serialization function `to_string`, follow the order at which entires are expected to appear (there is a strong ordering expected). 4. Populate sub-entires using `add_entry`. If using the default serialization function `to_strbuilder`, follow the order at which entires are expected to appear (there is a strong ordering expected).
Names or Content fields are interned strings and thus showed be cached using `get_cached_string` if its desired to preserve that behavior. Names or Content fields are interned strings and thus showed be cached using `cache_str` if its desired to preserve that behavior.
`def_operator` is the most sophisticated upfront constructor as it has multiple permutations of definitions that could be created that are not trivial to determine if valid. `def_operator` is the most sophisticated upfront constructor as it has multiple permutations of definitions that could be created that are not trivial to determine if valid.

View File

@ -15,7 +15,7 @@ Builder builder_open( char const* path )
return result; return result;
} }
result.Buffer = string_make_reserve( GlobalAllocator, Builder_StrBufferReserve ); result.Buffer = strbuilder_make_reserve( _ctx->Allocator_Temp, _ctx->InitSize_BuilderBuffer );
// log_fmt("$Builder - Opened file: %s\n", result.File.filename ); // log_fmt("$Builder - Opened file: %s\n", result.File.filename );
return result; return result;
@ -23,15 +23,15 @@ Builder builder_open( char const* path )
void builder_pad_lines( Builder* builder, s32 num ) void builder_pad_lines( Builder* builder, s32 num )
{ {
string_append_strc( & builder->Buffer, txt("\n") ); strbuilder_append_str( & builder->Buffer, txt("\n") );
} }
void builder_print( Builder* builder, Code code ) void builder_print( Builder* builder, Code code )
{ {
String str = code_to_string(code); StrBuilder str = code_to_strbuilder(code);
// const ssize len = str.length(); // const ssize len = str.length();
// log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data ); // log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data );
string_append_string( & builder->Buffer, str ); strbuilder_append_string( & builder->Buffer, str );
} }
void builder_print_fmt_va( Builder* builder, char const* fmt, va_list va ) void builder_print_fmt_va( Builder* builder, char const* fmt, va_list va )
@ -39,21 +39,21 @@ void builder_print_fmt_va( Builder* builder, char const* fmt, va_list va )
ssize res; ssize res;
char buf[ GEN_PRINTF_MAXLEN ] = { 0 }; char buf[ GEN_PRINTF_MAXLEN ] = { 0 };
res = str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1; res = c_str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1;
string_append_c_str_len( (String*) & (builder->Buffer), (char const*)buf, res); strbuilder_append_c_str_len( (StrBuilder*) & (builder->Buffer), (char const*)buf, res);
} }
void builder_write(Builder* builder) void builder_write(Builder* builder)
{ {
b32 result = file_write( & builder->File, builder->Buffer, string_length(builder->Buffer) ); b32 result = file_write( & builder->File, builder->Buffer, strbuilder_length(builder->Buffer) );
if ( result == false ) if ( result == false )
log_failure("gen::File::write - Failed to write to file: %s\n", file_name( & builder->File ) ); log_failure("gen::File::write - Failed to write to file: %s\n", file_name( & builder->File ) );
log_fmt( "Generated: %s\n", builder->File.filename ); log_fmt( "Generated: %s\n", builder->File.filename );
file_close( & builder->File ); file_close( & builder->File );
string_free(& builder->Buffer); strbuilder_free(& builder->Buffer);
} }
#pragma endregion Builder #pragma endregion Builder

View File

@ -36,7 +36,7 @@ void builder_write( Builder* builder );
struct Builder struct Builder
{ {
FileInfo File; FileInfo File;
String Buffer; StrBuilder Buffer;
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP #if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
forceinline static Builder open( char const* path ) { return builder_open(path); } forceinline static Builder open( char const* path ) { return builder_open(path); }

View File

@ -32,4 +32,4 @@ CodeFn gen_func_template( CodeTemplate template, ... );
Code gen_class_struct_template( CodeTemplate template, ... ); Code gen_class_struct_template( CodeTemplate template, ... );
Code gen_template( CodeTemplate template, ... ); Code gen_template( CodeTemplate template, ... );
Code gen_template( StrC template, StrC instantiation ); Code gen_template( Str template, Str instantiation );

View File

@ -20,9 +20,9 @@ Code scan_file( char const* path )
GEN_FATAL("scan_file: %s is empty", path ); GEN_FATAL("scan_file: %s is empty", path );
} }
String str = string_make_reserve( GlobalAllocator, fsize ); StrBuilder str = strbuilder_make_reserve( _ctx->Allocator_Temp, fsize );
file_read( & file, str, fsize ); file_read( & file, str, fsize );
string_get_header(str)->Length = fsize; strbuilder_get_header(str)->Length = fsize;
// Skip GEN_INTELLISENSE_DIRECTIVES preprocessor blocks // Skip GEN_INTELLISENSE_DIRECTIVES preprocessor blocks
// Its designed so that the directive should be the first thing in the file. // Its designed so that the directive should be the first thing in the file.
@ -31,9 +31,9 @@ Code scan_file( char const* path )
#define current (*scanner) #define current (*scanner)
#define matched 0 #define matched 0
#define move_fwd() do { ++ scanner; -- left; } while (0) #define move_fwd() do { ++ scanner; -- left; } while (0)
const StrC directive_start = txt( "ifdef" ); const Str directive_start = txt( "ifdef" );
const StrC directive_end = txt( "endif" ); const Str directive_end = txt( "endif" );
const StrC def_intellisense = txt("GEN_INTELLISENSE_DIRECTIVES" ); const Str def_intellisense = txt("GEN_INTELLISENSE_DIRECTIVES" );
bool found_directive = false; bool found_directive = false;
char const* scanner = (char const*)str; char const* scanner = (char const*)str;
@ -49,7 +49,7 @@ Code scan_file( char const* path )
if ( ! found_directive ) if ( ! found_directive )
{ {
if ( left && str_compare_len( scanner, directive_start.Ptr, directive_start.Len ) == matched ) if ( left && c_str_compare_len( scanner, directive_start.Ptr, directive_start.Len ) == matched )
{ {
scanner += directive_start.Len; scanner += directive_start.Len;
left -= directive_start.Len; left -= directive_start.Len;
@ -57,7 +57,7 @@ Code scan_file( char const* path )
while ( left && char_is_space( current ) ) while ( left && char_is_space( current ) )
move_fwd(); move_fwd();
if ( left && str_compare_len( scanner, def_intellisense.Ptr, def_intellisense.Len ) == matched ) if ( left && c_str_compare_len( scanner, def_intellisense.Ptr, def_intellisense.Len ) == matched )
{ {
scanner += def_intellisense.Len; scanner += def_intellisense.Len;
left -= def_intellisense.Len; left -= def_intellisense.Len;
@ -77,7 +77,7 @@ Code scan_file( char const* path )
continue; continue;
} }
if ( left && str_compare_len( scanner, directive_end.Ptr, directive_end.Len ) == matched ) if ( left && c_str_compare_len( scanner, directive_end.Ptr, directive_end.Len ) == matched )
{ {
scanner += directive_end.Len; scanner += directive_end.Len;
left -= directive_end.Len; left -= directive_end.Len;
@ -94,12 +94,12 @@ Code scan_file( char const* path )
if ( (scanner + 2) >= ( (char const*) str + fsize ) ) if ( (scanner + 2) >= ( (char const*) str + fsize ) )
{ {
mem_move( str, scanner, left ); mem_move( str, scanner, left );
string_get_header(str)->Length = left; strbuilder_get_header(str)->Length = left;
break; break;
} }
mem_move( str, scanner, left ); mem_move( str, scanner, left );
string_get_header(str)->Length = left; strbuilder_get_header(str)->Length = left;
break; break;
} }
@ -113,12 +113,12 @@ Code scan_file( char const* path )
} }
file_close( & file ); file_close( & file );
return untyped_str( string_to_strc(str) ); return untyped_str( strbuilder_to_str(str) );
} }
CodeBody parse_file( const char* path ) { CodeBody parse_file( const char* path ) {
FileContents file = file_read_contents( GlobalAllocator, true, path ); FileContents file = file_read_contents( _ctx->Allocator_Temp, true, path );
StrC content = { file.size, (char const*)file.data }; Str content = { (char const*)file.data, file.size };
CodeBody code = parse_global_body( content ); CodeBody code = parse_global_body( content );
log_fmt("\nParsed: %s\n", path); log_fmt("\nParsed: %s\n", path);
return code; return code;

View File

@ -27,7 +27,8 @@ constexpr char const* generation_notice =
int gen_main() int gen_main()
{ {
gen::init(); gen::Context ctx {};
gen::init( & ctx);
CodeBody gen_component_header = def_global_body( args( CodeBody gen_component_header = def_global_body( args(
def_preprocess_cond( PreprocessCond_IfDef, txt("GEN_INTELLISENSE_DIRECTIVES") ), def_preprocess_cond( PreprocessCond_IfDef, txt("GEN_INTELLISENSE_DIRECTIVES") ),
@ -35,12 +36,13 @@ int gen_main()
def_include(txt("components/types.hpp")), def_include(txt("components/types.hpp")),
preprocess_endif, preprocess_endif,
fmt_newline, fmt_newline,
untyped_str( to_strc_from_c_str(generation_notice) ) untyped_str( to_str_from_c_str(generation_notice) )
)); ));
CodeBody ecode = gen_ecode ( "enums/ECodeTypes.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 etoktype = gen_etoktype ( "enums/ETokType.csv", "enums/AttributeTokens.csv" );
CodeBody ast_inlines = gen_ast_inlines(); CodeBody ast_inlines = gen_ast_inlines();
Builder header_ecode = builder_open( "components/gen/ecodetypes.hpp" ); Builder header_ecode = builder_open( "components/gen/ecodetypes.hpp" );
@ -58,11 +60,16 @@ int gen_main()
builder_print( & header_especifier, format(especifier) ); builder_print( & header_especifier, format(especifier) );
builder_write( & header_especifier); builder_write( & header_especifier);
Builder header_etoktype = builder_open( "components/gen/etoktype.hpp" );
builder_print( & header_etoktype, gen_component_header );
builder_print( & header_etoktype, format(etoktype) );
builder_write( & header_etoktype);
Builder header_ast_inlines = builder_open( "components/gen/ast_inlines.hpp" ); Builder header_ast_inlines = builder_open( "components/gen/ast_inlines.hpp" );
builder_print( & header_ast_inlines, gen_component_header ); builder_print( & header_ast_inlines, gen_component_header );
builder_print( & header_ast_inlines, format(ast_inlines) ); builder_print( & header_ast_inlines, format(ast_inlines) );
builder_write( & header_ast_inlines); builder_write( & header_ast_inlines);
gen::deinit(); gen::deinit(& ctx);
return 0; return 0;
} }

File diff suppressed because it is too large Load Diff

View File

@ -230,40 +230,25 @@ struct CodeUsing;
struct CodeVar; struct CodeVar;
#endif #endif
GEN_NS_PARSER_BEGIN
struct Token;
GEN_NS_PARSER_END
#if GEN_COMPILER_CPP
// Note(Ed): This is to alleviate an edge case with parsing usings or typedefs where I don't really have it setup
// to parse a 'namespace' macro or a type with a macro.
// I have ideas for ways to pack that into the typedef/using ast, but for now just keeping it like this
#define ParserTokenType GEN_NS_PARSER Token
typedef ParserTokenType Token;
#undef ParserTokenType
#endif
#if GEN_COMPILER_CPP #if GEN_COMPILER_CPP
template< class Type> forceinline Type tmpl_cast( Code self ) { return * rcast( Type*, & self ); } template< class Type> forceinline Type tmpl_cast( Code self ) { return * rcast( Type*, & self ); }
#endif #endif
#pragma region Code C-Interface #pragma region Code C-Interface
void code_append (Code code, Code other ); GEN_API void code_append (Code code, Code other );
StrC code_debug_str (Code code); GEN_API Str code_debug_str (Code code);
Code code_duplicate (Code code); GEN_API Code code_duplicate (Code code);
Code* code_entry (Code code, u32 idx ); GEN_API Code* code_entry (Code code, u32 idx );
bool code_has_entries (Code code); GEN_API bool code_has_entries (Code code);
bool code_is_body (Code code); GEN_API bool code_is_body (Code code);
bool code_is_equal (Code code, Code other); GEN_API bool code_is_equal (Code code, Code other);
bool code_is_valid (Code code); GEN_API bool code_is_valid (Code code);
void code_set_global (Code code); GEN_API void code_set_global (Code code);
String code_to_string (Code self ); GEN_API StrBuilder code_to_strbuilder (Code self );
void code_to_string_ptr(Code self, String* result ); GEN_API void code_to_strbuilder_ptr(Code self, StrBuilder* result );
StrC code_type_str (Code self ); GEN_API Str code_type_str (Code self );
bool code_validate_body(Code self ); GEN_API bool code_validate_body (Code self );
#pragma endregion Code C-Interface #pragma endregion Code C-Interface
@ -278,7 +263,7 @@ struct Code
AST* ast; AST* ast;
# define Using_Code( Typename ) \ # define Using_Code( Typename ) \
forceinline StrC debug_str() { return code_debug_str(* this); } \ forceinline Str debug_str() { return code_debug_str(* this); } \
forceinline Code duplicate() { return code_duplicate(* this); } \ forceinline Code duplicate() { return code_duplicate(* this); } \
forceinline bool is_equal( Code other ) { return code_is_equal(* this, other); } \ forceinline bool is_equal( Code other ) { return code_is_equal(* this, other); } \
forceinline bool is_body() { return code_is_body(* this); } \ forceinline bool is_body() { return code_is_body(* this); } \
@ -295,16 +280,17 @@ struct Code
#if ! GEN_C_LIKE_CPP #if ! GEN_C_LIKE_CPP
Using_Code( Code ); Using_Code( Code );
forceinline void append(Code other) { return code_append(* this, other); } forceinline void append(Code other) { return code_append(* this, other); }
forceinline Code* entry(u32 idx) { return code_entry(* this, idx); } forceinline Code* entry(u32 idx) { return code_entry(* this, idx); }
forceinline bool has_entries() { return code_has_entries(* this); } forceinline bool has_entries() { return code_has_entries(* this); }
forceinline String to_string() { return code_to_string(* this); } forceinline StrBuilder to_strbuilder() { return code_to_strbuilder(* this); }
forceinline void to_string(String& result) { return code_to_string_ptr(* this, & result); } forceinline void to_strbuilder(StrBuilder& result) { return code_to_strbuilder_ptr(* this, & result); }
forceinline StrC type_str() { return code_type_str(* this); } forceinline Str type_str() { return code_type_str(* this); }
forceinline bool validate_body() { return code_validate_body(*this); } forceinline bool validate_body() { return code_validate_body(*this); }
#endif #endif
Using_CodeOps( Code ); Using_CodeOps( Code );
forceinline Code operator *() { return * this; } // Required to support for-range iteration.
forceinline AST* operator ->() { return ast; } forceinline AST* operator ->() { return ast; }
Code& operator ++(); Code& operator ++();
@ -367,7 +353,7 @@ int AST_ArrSpecs_Cap =
( (
AST_POD_Size AST_POD_Size
- sizeof(Code) - sizeof(Code)
- sizeof(StringCached) - sizeof(StrCached)
- sizeof(Code) * 2 - sizeof(Code) * 2
- sizeof(Token*) - sizeof(Token*)
- sizeof(Code) - sizeof(Code)
@ -413,13 +399,13 @@ struct AST
Code PostNameMacro; // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal) Code PostNameMacro; // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal)
}; };
}; };
StringCached Content; // Attributes, Comment, Execution, Include StrCached Content; // Attributes, Comment, Execution, Include
struct { struct {
Specifier ArrSpecs[AST_ArrSpecs_Cap]; // Specifiers Specifier ArrSpecs[AST_ArrSpecs_Cap]; // Specifiers
Code NextSpecs; // Specifiers; If ArrSpecs is full, then NextSpecs is used. Code NextSpecs; // Specifiers; If ArrSpecs is full, then NextSpecs is used.
}; };
}; };
StringCached Name; StrCached Name;
union { union {
Code Prev; Code Prev;
Code Front; Code Front;

View File

@ -31,7 +31,7 @@ struct AST_Body
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
Code Front; Code Front;
Code Back; Code Back;
Token* Tok; Token* Tok;
@ -46,9 +46,9 @@ struct AST_Attributes
{ {
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content; StrCached Content;
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -64,7 +64,7 @@ struct AST_BaseClass
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -79,9 +79,9 @@ struct AST_Comment
{ {
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content; StrCached Content;
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -106,7 +106,7 @@ struct AST_Class
char _PAD_PROPERTIES_2_[ sizeof(AST*) ]; char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
}; };
}; };
StringCached Name; StrCached Name;
CodeTypename Prev; CodeTypename Prev;
CodeTypename Next; CodeTypename Next;
Token* Tok; Token* Tok;
@ -132,7 +132,7 @@ struct AST_Constructor
char _PAD_PROPERTIES_2_ [ sizeof(AST*) * 2 ]; char _PAD_PROPERTIES_2_ [ sizeof(AST*) * 2 ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -146,9 +146,9 @@ struct AST_Define
{ {
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content; StrCached Content;
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -172,7 +172,7 @@ struct AST_Destructor
char _PAD_PROPERTIES_3_ [ sizeof(AST*) ]; char _PAD_PROPERTIES_3_ [ sizeof(AST*) ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -197,7 +197,7 @@ struct AST_Enum
char _PAD_PROPERTIES_2_[ sizeof(AST*) ]; char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -212,9 +212,9 @@ struct AST_Exec
{ {
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content; StrCached Content;
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -230,7 +230,7 @@ struct AST_Expr
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -245,7 +245,7 @@ struct AST_Expr_Assign
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -260,7 +260,7 @@ struct AST_Expr_Alignof
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -275,7 +275,7 @@ struct AST_Expr_Binary
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -290,7 +290,7 @@ struct AST_Expr_CStyleCast
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -305,7 +305,7 @@ struct AST_Expr_FunctionalCast
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -320,7 +320,7 @@ struct AST_Expr_CppCast
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -335,7 +335,7 @@ struct AST_Expr_ProcCall
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -350,7 +350,7 @@ struct AST_Expr_Decltype
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -365,7 +365,7 @@ struct AST_Expr_Comma
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -380,7 +380,7 @@ struct AST_Expr_AMS
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -395,7 +395,7 @@ struct AST_Expr_Sizeof
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -410,7 +410,7 @@ struct AST_Expr_Subscript
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -425,7 +425,7 @@ struct AST_Expr_Ternary
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -440,7 +440,7 @@ struct AST_Expr_UnaryPrefix
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -455,7 +455,7 @@ struct AST_Expr_UnaryPostfix
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -470,7 +470,7 @@ struct AST_Expr_Element
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -492,7 +492,7 @@ struct AST_Extern
char _PAD_PROPERTIES_2_[ sizeof(AST*) ]; char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -506,9 +506,9 @@ struct AST_Include
{ {
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content; StrCached Content;
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -530,7 +530,7 @@ struct AST_Friend
char _PAD_PROPERTIES_2_[ sizeof(AST*) ]; char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -555,7 +555,7 @@ struct AST_Fn
char _PAD_PROPERTIES_ [ sizeof(AST*) ]; char _PAD_PROPERTIES_ [ sizeof(AST*) ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -571,7 +571,7 @@ struct AST_Module
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -592,7 +592,7 @@ struct AST_NS
char _PAD_PROPERTIES_2_[ sizeof(AST*) ]; char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -618,7 +618,7 @@ struct AST_Operator
char _PAD_PROPERTIES_ [ sizeof(AST*) ]; char _PAD_PROPERTIES_ [ sizeof(AST*) ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -644,7 +644,7 @@ struct AST_OpCast
char _PAD_PROPERTIES_3_[ sizeof(AST*) ]; char _PAD_PROPERTIES_3_[ sizeof(AST*) ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -668,7 +668,7 @@ struct AST_Params
// char _PAD_PROPERTIES_3_[sizeof( AST* )]; // char _PAD_PROPERTIES_3_[sizeof( AST* )];
}; };
}; };
StringCached Name; StrCached Name;
CodeParams Last; CodeParams Last;
CodeParams Next; CodeParams Next;
Token* Tok; Token* Tok;
@ -683,9 +683,9 @@ struct AST_Pragma
{ {
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content; StrCached Content;
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -699,9 +699,9 @@ struct AST_PreprocessCond
{ {
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content; StrCached Content;
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -714,7 +714,7 @@ static_assert( sizeof(AST_PreprocessCond) == sizeof(AST), "ERROR: AST_Preprocess
struct AST_Specifiers struct AST_Specifiers
{ {
Specifier ArrSpecs[ AST_ArrSpecs_Cap ]; Specifier ArrSpecs[ AST_ArrSpecs_Cap ];
StringCached Name; StrCached Name;
CodeSpecifiers NextSpecs; CodeSpecifiers NextSpecs;
Code Prev; Code Prev;
Code Next; Code Next;
@ -732,7 +732,7 @@ struct AST_Stmt
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -747,7 +747,7 @@ struct AST_Stmt_Break
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -762,7 +762,7 @@ struct AST_Stmt_Case
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -777,7 +777,7 @@ struct AST_Stmt_Continue
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -792,7 +792,7 @@ struct AST_Stmt_Decl
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -807,7 +807,7 @@ struct AST_Stmt_Do
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -822,7 +822,7 @@ struct AST_Stmt_Expr
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -837,7 +837,7 @@ struct AST_Stmt_Else
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -852,7 +852,7 @@ struct AST_Stmt_If
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -867,7 +867,7 @@ struct AST_Stmt_For
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -882,7 +882,7 @@ struct AST_Stmt_Goto
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -897,7 +897,7 @@ struct AST_Stmt_Label
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -912,7 +912,7 @@ struct AST_Stmt_Switch
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -927,7 +927,7 @@ struct AST_Stmt_While
union { union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ]; char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
}; };
StringCached Name; StrCached Name;
CodeExpr Prev; CodeExpr Prev;
CodeExpr Next; CodeExpr Next;
Token* Tok; Token* Tok;
@ -953,7 +953,7 @@ struct AST_Struct
char _PAD_PROPERTIES_2_[ sizeof(AST*) ]; char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
}; };
}; };
StringCached Name; StrCached Name;
CodeTypename Prev; CodeTypename Prev;
CodeTypename Next; CodeTypename Next;
Token* Tok; Token* Tok;
@ -976,7 +976,7 @@ struct AST_Template
char _PAD_PROPERTIES_2_[ sizeof(AST*) ]; char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -1005,7 +1005,7 @@ struct AST_Type
// CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures // CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -1032,7 +1032,7 @@ struct AST_Typename
CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -1058,7 +1058,7 @@ struct AST_Typedef
char _PAD_PROPERTIES_2_[ sizeof(AST*) * 3 ]; char _PAD_PROPERTIES_2_[ sizeof(AST*) * 3 ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -1082,7 +1082,7 @@ struct AST_Union
char _PAD_PROPERTIES_2_[ sizeof(AST*) ]; char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -1106,7 +1106,7 @@ struct AST_Using
char _PAD_PROPERTIES_[ sizeof(AST*) * 3 ]; char _PAD_PROPERTIES_[ sizeof(AST*) * 3 ];
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -1132,7 +1132,7 @@ struct AST_Var
CodeVar NextVar; CodeVar NextVar;
}; };
}; };
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -64,7 +64,7 @@ inline AST_Attributes* CodeAttributes::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -95,7 +95,7 @@ inline AST_Comment* CodeComment::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -126,7 +126,7 @@ inline AST_Constructor* CodeConstructor::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -173,7 +173,7 @@ inline AST_Define* CodeDefine::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -204,7 +204,7 @@ inline AST_Destructor* CodeDestructor::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -235,7 +235,7 @@ inline AST_Enum* CodeEnum::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -266,7 +266,7 @@ inline AST_Exec* CodeExec::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -297,7 +297,7 @@ inline AST_Extern* CodeExtern::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -328,7 +328,7 @@ inline AST_Friend* CodeFriend::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -359,7 +359,7 @@ inline AST_Fn* CodeFn::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -390,7 +390,7 @@ inline AST_Include* CodeInclude::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -421,7 +421,7 @@ inline AST_Module* CodeModule::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -452,7 +452,7 @@ inline AST_NS* CodeNS::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -483,7 +483,7 @@ inline AST_Operator* CodeOperator::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -514,7 +514,7 @@ inline AST_OpCast* CodeOpCast::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -561,7 +561,7 @@ inline AST_Pragma* CodePragma::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -592,7 +592,7 @@ inline AST_PreprocessCond* CodePreprocessCond::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -655,7 +655,7 @@ inline AST_Template* CodeTemplate::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -686,7 +686,7 @@ inline AST_Typename* CodeTypename::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -717,7 +717,7 @@ inline AST_Typedef* CodeTypedef::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -748,7 +748,7 @@ inline AST_Union* CodeUnion::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -779,7 +779,7 @@ inline AST_Using* CodeUsing::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -810,7 +810,7 @@ inline AST_Var* CodeVar::operator->()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;

View File

@ -72,148 +72,148 @@ enum CodeType : u32
CT_UnderlyingType = GEN_U32_MAX CT_UnderlyingType = GEN_U32_MAX
}; };
inline StrC codetype_to_str( CodeType type ) inline Str codetype_to_str( CodeType type )
{ {
local_persist StrC lookup[61] = { local_persist Str lookup[61] = {
{ sizeof( "Invalid" ), "Invalid" }, { "Invalid", sizeof( "Invalid" ) - 1 },
{ sizeof( "Untyped" ), "Untyped" }, { "Untyped", sizeof( "Untyped" ) - 1 },
{ sizeof( "NewLine" ), "NewLine" }, { "NewLine", sizeof( "NewLine" ) - 1 },
{ sizeof( "Comment" ), "Comment" }, { "Comment", sizeof( "Comment" ) - 1 },
{ sizeof( "Access_Private" ), "Access_Private" }, { "Access_Private", sizeof( "Access_Private" ) - 1 },
{ sizeof( "Access_Protected" ), "Access_Protected" }, { "Access_Protected", sizeof( "Access_Protected" ) - 1 },
{ sizeof( "Access_Public" ), "Access_Public" }, { "Access_Public", sizeof( "Access_Public" ) - 1 },
{ sizeof( "PlatformAttributes" ), "PlatformAttributes" }, { "PlatformAttributes", sizeof( "PlatformAttributes" ) - 1 },
{ sizeof( "Class" ), "Class" }, { "Class", sizeof( "Class" ) - 1 },
{ sizeof( "Class_Fwd" ), "Class_Fwd" }, { "Class_Fwd", sizeof( "Class_Fwd" ) - 1 },
{ sizeof( "Class_Body" ), "Class_Body" }, { "Class_Body", sizeof( "Class_Body" ) - 1 },
{ sizeof( "Constructor" ), "Constructor" }, { "Constructor", sizeof( "Constructor" ) - 1 },
{ sizeof( "Constructor_Fwd" ), "Constructor_Fwd" }, { "Constructor_Fwd", sizeof( "Constructor_Fwd" ) - 1 },
{ sizeof( "Destructor" ), "Destructor" }, { "Destructor", sizeof( "Destructor" ) - 1 },
{ sizeof( "Destructor_Fwd" ), "Destructor_Fwd" }, { "Destructor_Fwd", sizeof( "Destructor_Fwd" ) - 1 },
{ sizeof( "Enum" ), "Enum" }, { "Enum", sizeof( "Enum" ) - 1 },
{ sizeof( "Enum_Fwd" ), "Enum_Fwd" }, { "Enum_Fwd", sizeof( "Enum_Fwd" ) - 1 },
{ sizeof( "Enum_Body" ), "Enum_Body" }, { "Enum_Body", sizeof( "Enum_Body" ) - 1 },
{ sizeof( "Enum_Class" ), "Enum_Class" }, { "Enum_Class", sizeof( "Enum_Class" ) - 1 },
{ sizeof( "Enum_Class_Fwd" ), "Enum_Class_Fwd" }, { "Enum_Class_Fwd", sizeof( "Enum_Class_Fwd" ) - 1 },
{ sizeof( "Execution" ), "Execution" }, { "Execution", sizeof( "Execution" ) - 1 },
{ sizeof( "Export_Body" ), "Export_Body" }, { "Export_Body", sizeof( "Export_Body" ) - 1 },
{ sizeof( "Extern_Linkage" ), "Extern_Linkage" }, { "Extern_Linkage", sizeof( "Extern_Linkage" ) - 1 },
{ sizeof( "Extern_Linkage_Body" ), "Extern_Linkage_Body" }, { "Extern_Linkage_Body", sizeof( "Extern_Linkage_Body" ) - 1 },
{ sizeof( "Friend" ), "Friend" }, { "Friend", sizeof( "Friend" ) - 1 },
{ sizeof( "Function" ), "Function" }, { "Function", sizeof( "Function" ) - 1 },
{ sizeof( "Function_Fwd" ), "Function_Fwd" }, { "Function_Fwd", sizeof( "Function_Fwd" ) - 1 },
{ sizeof( "Function_Body" ), "Function_Body" }, { "Function_Body", sizeof( "Function_Body" ) - 1 },
{ sizeof( "Global_Body" ), "Global_Body" }, { "Global_Body", sizeof( "Global_Body" ) - 1 },
{ sizeof( "Module" ), "Module" }, { "Module", sizeof( "Module" ) - 1 },
{ sizeof( "Namespace" ), "Namespace" }, { "Namespace", sizeof( "Namespace" ) - 1 },
{ sizeof( "Namespace_Body" ), "Namespace_Body" }, { "Namespace_Body", sizeof( "Namespace_Body" ) - 1 },
{ sizeof( "Operator" ), "Operator" }, { "Operator", sizeof( "Operator" ) - 1 },
{ sizeof( "Operator_Fwd" ), "Operator_Fwd" }, { "Operator_Fwd", sizeof( "Operator_Fwd" ) - 1 },
{ sizeof( "Operator_Member" ), "Operator_Member" }, { "Operator_Member", sizeof( "Operator_Member" ) - 1 },
{ sizeof( "Operator_Member_Fwd" ), "Operator_Member_Fwd" }, { "Operator_Member_Fwd", sizeof( "Operator_Member_Fwd" ) - 1 },
{ sizeof( "Operator_Cast" ), "Operator_Cast" }, { "Operator_Cast", sizeof( "Operator_Cast" ) - 1 },
{ sizeof( "Operator_Cast_Fwd" ), "Operator_Cast_Fwd" }, { "Operator_Cast_Fwd", sizeof( "Operator_Cast_Fwd" ) - 1 },
{ sizeof( "Parameters" ), "Parameters" }, { "Parameters", sizeof( "Parameters" ) - 1 },
{ sizeof( "Preprocess_Define" ), "Preprocess_Define" }, { "Preprocess_Define", sizeof( "Preprocess_Define" ) - 1 },
{ sizeof( "Preprocess_Include" ), "Preprocess_Include" }, { "Preprocess_Include", sizeof( "Preprocess_Include" ) - 1 },
{ sizeof( "Preprocess_If" ), "Preprocess_If" }, { "Preprocess_If", sizeof( "Preprocess_If" ) - 1 },
{ sizeof( "Preprocess_IfDef" ), "Preprocess_IfDef" }, { "Preprocess_IfDef", sizeof( "Preprocess_IfDef" ) - 1 },
{ sizeof( "Preprocess_IfNotDef" ), "Preprocess_IfNotDef" }, { "Preprocess_IfNotDef", sizeof( "Preprocess_IfNotDef" ) - 1 },
{ sizeof( "Preprocess_ElIf" ), "Preprocess_ElIf" }, { "Preprocess_ElIf", sizeof( "Preprocess_ElIf" ) - 1 },
{ sizeof( "Preprocess_Else" ), "Preprocess_Else" }, { "Preprocess_Else", sizeof( "Preprocess_Else" ) - 1 },
{ sizeof( "Preprocess_EndIf" ), "Preprocess_EndIf" }, { "Preprocess_EndIf", sizeof( "Preprocess_EndIf" ) - 1 },
{ sizeof( "Preprocess_Pragma" ), "Preprocess_Pragma" }, { "Preprocess_Pragma", sizeof( "Preprocess_Pragma" ) - 1 },
{ sizeof( "Specifiers" ), "Specifiers" }, { "Specifiers", sizeof( "Specifiers" ) - 1 },
{ sizeof( "Struct" ), "Struct" }, { "Struct", sizeof( "Struct" ) - 1 },
{ sizeof( "Struct_Fwd" ), "Struct_Fwd" }, { "Struct_Fwd", sizeof( "Struct_Fwd" ) - 1 },
{ sizeof( "Struct_Body" ), "Struct_Body" }, { "Struct_Body", sizeof( "Struct_Body" ) - 1 },
{ sizeof( "Template" ), "Template" }, { "Template", sizeof( "Template" ) - 1 },
{ sizeof( "Typedef" ), "Typedef" }, { "Typedef", sizeof( "Typedef" ) - 1 },
{ sizeof( "Typename" ), "Typename" }, { "Typename", sizeof( "Typename" ) - 1 },
{ sizeof( "Union" ), "Union" }, { "Union", sizeof( "Union" ) - 1 },
{ sizeof( "Union_Fwd" ), "Union_Fwd" }, { "Union_Fwd", sizeof( "Union_Fwd" ) - 1 },
{ sizeof( "Union_Body" ), "Union_Body" }, { "Union_Body", sizeof( "Union_Body" ) - 1 },
{ sizeof( "Using" ), "Using" }, { "Using", sizeof( "Using" ) - 1 },
{ sizeof( "Using_Namespace" ), "Using_Namespace" }, { "Using_Namespace", sizeof( "Using_Namespace" ) - 1 },
{ sizeof( "Variable" ), "Variable" }, { "Variable", sizeof( "Variable" ) - 1 },
}; };
return lookup[type]; return lookup[type];
} }
inline StrC codetype_to_keyword_str( CodeType type ) inline Str codetype_to_keyword_str( CodeType type )
{ {
local_persist StrC lookup[61] = { local_persist Str lookup[61] = {
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "//" ) - 1, "//" }, { "//", sizeof( "//" ) - 1 },
{ sizeof( "private" ) - 1, "private" }, { "private", sizeof( "private" ) - 1 },
{ sizeof( "protected" ) - 1, "protected" }, { "protected", sizeof( "protected" ) - 1 },
{ sizeof( "public" ) - 1, "public" }, { "public", sizeof( "public" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "class" ) - 1, "class" }, { "class", sizeof( "class" ) - 1 },
{ sizeof( "clsss" ) - 1, "clsss" }, { "clsss", sizeof( "clsss" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "enum" ) - 1, "enum" }, { "enum", sizeof( "enum" ) - 1 },
{ sizeof( "enum" ) - 1, "enum" }, { "enum", sizeof( "enum" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "enum class" ) - 1, "enum class" }, { "enum class", sizeof( "enum class" ) - 1 },
{ sizeof( "enum class" ) - 1, "enum class" }, { "enum class", sizeof( "enum class" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "extern" ) - 1, "extern" }, { "extern", sizeof( "extern" ) - 1 },
{ sizeof( "extern" ) - 1, "extern" }, { "extern", sizeof( "extern" ) - 1 },
{ sizeof( "friend" ) - 1, "friend" }, { "friend", sizeof( "friend" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "module" ) - 1, "module" }, { "module", sizeof( "module" ) - 1 },
{ sizeof( "namespace" ) - 1, "namespace" }, { "namespace", sizeof( "namespace" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "operator" ) - 1, "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "operator" ) - 1, "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "operator" ) - 1, "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "operator" ) - 1, "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "operator" ) - 1, "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "operator" ) - 1, "operator" }, { "operator", sizeof( "operator" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "define" ) - 1, "define" }, { "define", sizeof( "define" ) - 1 },
{ sizeof( "include" ) - 1, "include" }, { "include", sizeof( "include" ) - 1 },
{ sizeof( "if" ) - 1, "if" }, { "if", sizeof( "if" ) - 1 },
{ sizeof( "ifdef" ) - 1, "ifdef" }, { "ifdef", sizeof( "ifdef" ) - 1 },
{ sizeof( "ifndef" ) - 1, "ifndef" }, { "ifndef", sizeof( "ifndef" ) - 1 },
{ sizeof( "elif" ) - 1, "elif" }, { "elif", sizeof( "elif" ) - 1 },
{ sizeof( "else" ) - 1, "else" }, { "else", sizeof( "else" ) - 1 },
{ sizeof( "endif" ) - 1, "endif" }, { "endif", sizeof( "endif" ) - 1 },
{ sizeof( "pragma" ) - 1, "pragma" }, { "pragma", sizeof( "pragma" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "struct" ) - 1, "struct" }, { "struct", sizeof( "struct" ) - 1 },
{ sizeof( "struct" ) - 1, "struct" }, { "struct", sizeof( "struct" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "template" ) - 1, "template" }, { "template", sizeof( "template" ) - 1 },
{ sizeof( "typedef" ) - 1, "typedef" }, { "typedef", sizeof( "typedef" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "union" ) - 1, "union" }, { "union", sizeof( "union" ) - 1 },
{ sizeof( "union" ) - 1, "union" }, { "union", sizeof( "union" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
{ sizeof( "using" ) - 1, "using" }, { "using", sizeof( "using" ) - 1 },
{ sizeof( "using namespace" ) - 1, "using namespace" }, { "using namespace", sizeof( "using namespace" ) - 1 },
{ sizeof( "__NA__" ) - 1, "__NA__" }, { "__NA__", sizeof( "__NA__" ) - 1 },
}; };
return lookup[type]; return lookup[type];
} }
forceinline StrC to_str( CodeType type ) forceinline Str to_str( CodeType type )
{ {
return codetype_to_str( type ); return codetype_to_str( type );
} }
forceinline StrC to_keyword_str( CodeType type ) forceinline Str to_keyword_str( CodeType type )
{ {
return codetype_to_keyword_str( type ); return codetype_to_keyword_str( type );
} }

View File

@ -58,61 +58,61 @@ enum Operator : u32
Op_UnderlyingType = 0xffffffffu Op_UnderlyingType = 0xffffffffu
}; };
inline StrC operator_to_str( Operator op ) inline Str operator_to_str( Operator op )
{ {
local_persist StrC lookup[47] = { local_persist Str lookup[47] = {
{ sizeof( "INVALID" ), "INVALID" }, { "INVALID", sizeof( "INVALID" ) - 1 },
{ sizeof( "=" ), "=" }, { "=", sizeof( "=" ) - 1 },
{ sizeof( "+=" ), "+=" }, { "+=", sizeof( "+=" ) - 1 },
{ sizeof( "-=" ), "-=" }, { "-=", sizeof( "-=" ) - 1 },
{ sizeof( "*=" ), "*=" }, { "*=", sizeof( "*=" ) - 1 },
{ sizeof( "/=" ), "/=" }, { "/=", sizeof( "/=" ) - 1 },
{ sizeof( "%=" ), "%=" }, { "%=", sizeof( "%=" ) - 1 },
{ sizeof( "&=" ), "&=" }, { "&=", sizeof( "&=" ) - 1 },
{ sizeof( "|=" ), "|=" }, { "|=", sizeof( "|=" ) - 1 },
{ sizeof( "^=" ), "^=" }, { "^=", sizeof( "^=" ) - 1 },
{ sizeof( "<<=" ), "<<=" }, { "<<=", sizeof( "<<=" ) - 1 },
{ sizeof( ">>=" ), ">>=" }, { ">>=", sizeof( ">>=" ) - 1 },
{ sizeof( "++" ), "++" }, { "++", sizeof( "++" ) - 1 },
{ sizeof( "--" ), "--" }, { "--", sizeof( "--" ) - 1 },
{ sizeof( "+" ), "+" }, { "+", sizeof( "+" ) - 1 },
{ sizeof( "-" ), "-" }, { "-", sizeof( "-" ) - 1 },
{ sizeof( "!" ), "!" }, { "!", sizeof( "!" ) - 1 },
{ sizeof( "+" ), "+" }, { "+", sizeof( "+" ) - 1 },
{ sizeof( "-" ), "-" }, { "-", sizeof( "-" ) - 1 },
{ sizeof( "*" ), "*" }, { "*", sizeof( "*" ) - 1 },
{ sizeof( "/" ), "/" }, { "/", sizeof( "/" ) - 1 },
{ sizeof( "%" ), "%" }, { "%", sizeof( "%" ) - 1 },
{ sizeof( "~" ), "~" }, { "~", sizeof( "~" ) - 1 },
{ sizeof( "&" ), "&" }, { "&", sizeof( "&" ) - 1 },
{ sizeof( "|" ), "|" }, { "|", sizeof( "|" ) - 1 },
{ sizeof( "^" ), "^" }, { "^", sizeof( "^" ) - 1 },
{ sizeof( "<<" ), "<<" }, { "<<", sizeof( "<<" ) - 1 },
{ sizeof( ">>" ), ">>" }, { ">>", sizeof( ">>" ) - 1 },
{ sizeof( "&&" ), "&&" }, { "&&", sizeof( "&&" ) - 1 },
{ sizeof( "||" ), "||" }, { "||", sizeof( "||" ) - 1 },
{ sizeof( "==" ), "==" }, { "==", sizeof( "==" ) - 1 },
{ sizeof( "!=" ), "!=" }, { "!=", sizeof( "!=" ) - 1 },
{ sizeof( "<" ), "<" }, { "<", sizeof( "<" ) - 1 },
{ sizeof( ">" ), ">" }, { ">", sizeof( ">" ) - 1 },
{ sizeof( "<=" ), "<=" }, { "<=", sizeof( "<=" ) - 1 },
{ sizeof( ">=" ), ">=" }, { ">=", sizeof( ">=" ) - 1 },
{ sizeof( "[]" ), "[]" }, { "[]", sizeof( "[]" ) - 1 },
{ sizeof( "*" ), "*" }, { "*", sizeof( "*" ) - 1 },
{ sizeof( "&" ), "&" }, { "&", sizeof( "&" ) - 1 },
{ sizeof( "->" ), "->" }, { "->", sizeof( "->" ) - 1 },
{ sizeof( "->*" ), "->*" }, { "->*", sizeof( "->*" ) - 1 },
{ sizeof( "()" ), "()" }, { "()", sizeof( "()" ) - 1 },
{ sizeof( "," ), "," }, { ",", sizeof( "," ) - 1 },
{ sizeof( "new" ), "new" }, { "new", sizeof( "new" ) - 1 },
{ sizeof( "new[]" ), "new[]" }, { "new[]", sizeof( "new[]" ) - 1 },
{ sizeof( "delete" ), "delete" }, { "delete", sizeof( "delete" ) - 1 },
{ sizeof( "delete[]" ), "delete[]" }, { "delete[]", sizeof( "delete[]" ) - 1 },
}; };
return lookup[op]; return lookup[op];
} }
forceinline StrC to_str( Operator op ) forceinline Str to_str( Operator op )
{ {
return operator_to_str( op ); return operator_to_str( op );
} }

View File

@ -37,35 +37,35 @@ enum Specifier : u32
Spec_UnderlyingType = 0xffffffffu Spec_UnderlyingType = 0xffffffffu
}; };
inline StrC spec_to_str( Specifier type ) inline Str spec_to_str( Specifier type )
{ {
local_persist StrC lookup[26] = { local_persist Str lookup[26] = {
{ sizeof( "INVALID" ), "INVALID" }, { "INVALID", sizeof( "INVALID" ) - 1 },
{ sizeof( "consteval" ), "consteval" }, { "consteval", sizeof( "consteval" ) - 1 },
{ sizeof( "constexpr" ), "constexpr" }, { "constexpr", sizeof( "constexpr" ) - 1 },
{ sizeof( "constinit" ), "constinit" }, { "constinit", sizeof( "constinit" ) - 1 },
{ sizeof( "explicit" ), "explicit" }, { "explicit", sizeof( "explicit" ) - 1 },
{ sizeof( "extern" ), "extern" }, { "extern", sizeof( "extern" ) - 1 },
{ sizeof( "forceinline" ), "forceinline" }, { "forceinline", sizeof( "forceinline" ) - 1 },
{ sizeof( "global" ), "global" }, { "global", sizeof( "global" ) - 1 },
{ sizeof( "inline" ), "inline" }, { "inline", sizeof( "inline" ) - 1 },
{ sizeof( "internal" ), "internal" }, { "internal", sizeof( "internal" ) - 1 },
{ sizeof( "local_persist" ), "local_persist" }, { "local_persist", sizeof( "local_persist" ) - 1 },
{ sizeof( "mutable" ), "mutable" }, { "mutable", sizeof( "mutable" ) - 1 },
{ sizeof( "neverinline" ), "neverinline" }, { "neverinline", sizeof( "neverinline" ) - 1 },
{ sizeof( "*" ), "*" }, { "*", sizeof( "*" ) - 1 },
{ sizeof( "&" ), "&" }, { "&", sizeof( "&" ) - 1 },
{ sizeof( "register" ), "register" }, { "register", sizeof( "register" ) - 1 },
{ sizeof( "&&" ), "&&" }, { "&&", sizeof( "&&" ) - 1 },
{ sizeof( "static" ), "static" }, { "static", sizeof( "static" ) - 1 },
{ sizeof( "thread_local" ), "thread_local" }, { "thread_local", sizeof( "thread_local" ) - 1 },
{ sizeof( "virtual" ), "virtual" }, { "virtual", sizeof( "virtual" ) - 1 },
{ sizeof( "const" ), "const" }, { "const", sizeof( "const" ) - 1 },
{ sizeof( "final" ), "final" }, { "final", sizeof( "final" ) - 1 },
{ sizeof( "noexcept" ), "noexcept" }, { "noexcept", sizeof( "noexcept" ) - 1 },
{ sizeof( "override" ), "override" }, { "override", sizeof( "override" ) - 1 },
{ sizeof( "= 0" ), "= 0" }, { "= 0", sizeof( "= 0" ) - 1 },
{ sizeof( "volatile" ), "volatile" }, { "volatile", sizeof( "volatile" ) - 1 },
}; };
return lookup[type]; return lookup[type];
} }
@ -75,13 +75,13 @@ inline bool spec_is_trailing( Specifier specifier )
return specifier > Spec_Virtual; return specifier > Spec_Virtual;
} }
inline Specifier strc_to_specifier( StrC str ) inline Specifier str_to_specifier( Str str )
{ {
local_persist u32 keymap[Spec_NumSpecifiers]; local_persist u32 keymap[Spec_NumSpecifiers];
do_once_start for ( u32 index = 0; index < Spec_NumSpecifiers; index++ ) do_once_start for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
{ {
StrC enum_str = spec_to_str( (Specifier)index ); Str enum_str = spec_to_str( (Specifier)index );
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1 ); keymap[index] = crc32( enum_str.Ptr, enum_str.Len );
} }
do_once_end u32 hash = crc32( str.Ptr, str.Len ); do_once_end u32 hash = crc32( str.Ptr, str.Len );
for ( u32 index = 0; index < Spec_NumSpecifiers; index++ ) for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
@ -92,14 +92,14 @@ inline Specifier strc_to_specifier( StrC str )
return Spec_Invalid; return Spec_Invalid;
} }
forceinline StrC to_str( Specifier spec ) forceinline Str to_str( Specifier spec )
{ {
return spec_to_str( spec ); return spec_to_str( spec );
} }
forceinline Specifier to_type( StrC str ) forceinline Specifier to_type( Str str )
{ {
return strc_to_specifier( str ); return str_to_specifier( str );
} }
forceinline bool is_trailing( Specifier specifier ) forceinline bool is_trailing( Specifier specifier )

View File

@ -1,235 +0,0 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "components/types.hpp"
#endif
// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
GEN_NS_PARSER_BEGIN
#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( Tok_Attribute_API_Export, "GEN_API_Export_Code" ) Entry( Tok_Attribute_API_Import, "GEN_API_Import_Code" )
enum TokType : 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
};
inline StrC toktype_to_str( TokType type )
{
local_persist StrC lookup[] = {
{ sizeof( "__invalid__" ), "__invalid__" },
{ sizeof( "private" ), "private" },
{ sizeof( "protected" ), "protected" },
{ sizeof( "public" ), "public" },
{ sizeof( "." ), "." },
{ sizeof( "::" ), "::" },
{ sizeof( "&" ), "&" },
{ sizeof( "&&" ), "&&" },
{ sizeof( ":" ), ":" },
{ sizeof( "[[" ), "[[" },
{ sizeof( "]]" ), "]]" },
{ sizeof( "{" ), "{" },
{ sizeof( "}" ), "}" },
{ sizeof( "[" ), "[" },
{ sizeof( "]" ), "]" },
{ sizeof( "(" ), "(" },
{ sizeof( ")" ), ")" },
{ sizeof( "__comment__" ), "__comment__" },
{ sizeof( "__comment_end__" ), "__comment_end__" },
{ sizeof( "__comment_start__" ), "__comment_start__" },
{ sizeof( "__character__" ), "__character__" },
{ sizeof( "," ), "," },
{ sizeof( "class" ), "class" },
{ sizeof( "__attribute__" ), "__attribute__" },
{ sizeof( "__declspec" ), "__declspec" },
{ sizeof( "enum" ), "enum" },
{ sizeof( "extern" ), "extern" },
{ sizeof( "friend" ), "friend" },
{ sizeof( "module" ), "module" },
{ sizeof( "namespace" ), "namespace" },
{ sizeof( "operator" ), "operator" },
{ sizeof( "struct" ), "struct" },
{ sizeof( "template" ), "template" },
{ sizeof( "typedef" ), "typedef" },
{ sizeof( "using" ), "using" },
{ sizeof( "union" ), "union" },
{ sizeof( "__identifier__" ), "__identifier__" },
{ sizeof( "import" ), "import" },
{ sizeof( "export" ), "export" },
{ sizeof( "__new_line__" ), "__new_line__" },
{ sizeof( "__number__" ), "__number__" },
{ sizeof( "__operator__" ), "__operator__" },
{ sizeof( "#" ), "#" },
{ sizeof( "define" ), "define" },
{ sizeof( "if" ), "if" },
{ sizeof( "ifdef" ), "ifdef" },
{ sizeof( "ifndef" ), "ifndef" },
{ sizeof( "elif" ), "elif" },
{ sizeof( "else" ), "else" },
{ sizeof( "endif" ), "endif" },
{ sizeof( "include" ), "include" },
{ sizeof( "pragma" ), "pragma" },
{ sizeof( "__macro_content__" ), "__macro_content__" },
{ sizeof( "__macro__" ), "__macro__" },
{ sizeof( "__unsupported__" ), "__unsupported__" },
{ sizeof( "alignas" ), "alignas" },
{ sizeof( "const" ), "const" },
{ sizeof( "consteval" ), "consteval" },
{ sizeof( "constexpr" ), "constexpr" },
{ sizeof( "constinit" ), "constinit" },
{ sizeof( "explicit" ), "explicit" },
{ sizeof( "extern" ), "extern" },
{ sizeof( "final" ), "final" },
{ sizeof( "forceinline" ), "forceinline" },
{ sizeof( "global" ), "global" },
{ sizeof( "inline" ), "inline" },
{ sizeof( "internal" ), "internal" },
{ sizeof( "local_persist" ), "local_persist" },
{ sizeof( "mutable" ), "mutable" },
{ sizeof( "neverinline" ), "neverinline" },
{ sizeof( "override" ), "override" },
{ sizeof( "static" ), "static" },
{ sizeof( "thread_local" ), "thread_local" },
{ sizeof( "volatile" ), "volatile" },
{ sizeof( "virtual" ), "virtual" },
{ sizeof( "*" ), "*" },
{ sizeof( ";" ), ";" },
{ sizeof( "static_assert" ), "static_assert" },
{ sizeof( "__string__" ), "__string__" },
{ sizeof( "typename" ), "typename" },
{ sizeof( "unsigned" ), "unsigned" },
{ sizeof( "signed" ), "signed" },
{ sizeof( "short" ), "short" },
{ sizeof( "long" ), "long" },
{ sizeof( "bool" ), "bool" },
{ sizeof( "char" ), "char" },
{ sizeof( "int" ), "int" },
{ sizeof( "double" ), "double" },
{ sizeof( "__int8" ), "__int8" },
{ sizeof( "__int16" ), "__int16" },
{ sizeof( "__int32" ), "__int32" },
{ sizeof( "__int64" ), "__int64" },
{ sizeof( "_W64" ), "_W64" },
{ sizeof( "..." ), "..." },
{ sizeof( "__attrib_start__" ), "__attrib_start__" },
{ sizeof( "GEN_API_Export_Code" ), "GEN_API_Export_Code" },
{ sizeof( "GEN_API_Import_Code" ), "GEN_API_Import_Code" },
};
return lookup[type];
}
inline TokType strc_to_toktype( StrC str )
{
local_persist u32 keymap[Tok_NumTokens];
do_once_start for ( u32 index = 0; index < Tok_NumTokens; index++ )
{
StrC enum_str = toktype_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

View File

@ -0,0 +1,229 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "components/types.hpp"
#endif
// This file was generated automatially by gencpp's bootstrap.cpp (See: https://github.com/Ed94/gencpp)
#define GEN_DEFINE_ATTRIBUTE_TOKENS Entry( Tok_Attribute_GEN_API, "GEN_API" )
enum TokType : 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_GEN_API,
Tok_NumTokens
};
inline Str toktype_to_str( TokType type )
{
local_persist Str lookup[] = {
{ "__invalid__", sizeof( "__invalid__" ) - 1 },
{ "private", sizeof( "private" ) - 1 },
{ "protected", sizeof( "protected" ) - 1 },
{ "public", sizeof( "public" ) - 1 },
{ ".", sizeof( "." ) - 1 },
{ "::", sizeof( "::" ) - 1 },
{ "&", sizeof( "&" ) - 1 },
{ "&&", sizeof( "&&" ) - 1 },
{ ":", sizeof( ":" ) - 1 },
{ "[[", sizeof( "[[" ) - 1 },
{ "]]", sizeof( "]]" ) - 1 },
{ "{", sizeof( "{" ) - 1 },
{ "}", sizeof( "}" ) - 1 },
{ "[", sizeof( "[" ) - 1 },
{ "]", sizeof( "]" ) - 1 },
{ "(", sizeof( "(" ) - 1 },
{ ")", sizeof( ")" ) - 1 },
{ "__comment__", sizeof( "__comment__" ) - 1 },
{ "__comment_end__", sizeof( "__comment_end__" ) - 1 },
{ "__comment_start__", sizeof( "__comment_start__" ) - 1 },
{ "__character__", sizeof( "__character__" ) - 1 },
{ ",", sizeof( "," ) - 1 },
{ "class", sizeof( "class" ) - 1 },
{ "__attribute__", sizeof( "__attribute__" ) - 1 },
{ "__declspec", sizeof( "__declspec" ) - 1 },
{ "enum", sizeof( "enum" ) - 1 },
{ "extern", sizeof( "extern" ) - 1 },
{ "friend", sizeof( "friend" ) - 1 },
{ "module", sizeof( "module" ) - 1 },
{ "namespace", sizeof( "namespace" ) - 1 },
{ "operator", sizeof( "operator" ) - 1 },
{ "struct", sizeof( "struct" ) - 1 },
{ "template", sizeof( "template" ) - 1 },
{ "typedef", sizeof( "typedef" ) - 1 },
{ "using", sizeof( "using" ) - 1 },
{ "union", sizeof( "union" ) - 1 },
{ "__identifier__", sizeof( "__identifier__" ) - 1 },
{ "import", sizeof( "import" ) - 1 },
{ "export", sizeof( "export" ) - 1 },
{ "__new_line__", sizeof( "__new_line__" ) - 1 },
{ "__number__", sizeof( "__number__" ) - 1 },
{ "__operator__", sizeof( "__operator__" ) - 1 },
{ "#", sizeof( "#" ) - 1 },
{ "define", sizeof( "define" ) - 1 },
{ "if", sizeof( "if" ) - 1 },
{ "ifdef", sizeof( "ifdef" ) - 1 },
{ "ifndef", sizeof( "ifndef" ) - 1 },
{ "elif", sizeof( "elif" ) - 1 },
{ "else", sizeof( "else" ) - 1 },
{ "endif", sizeof( "endif" ) - 1 },
{ "include", sizeof( "include" ) - 1 },
{ "pragma", sizeof( "pragma" ) - 1 },
{ "__macro_content__", sizeof( "__macro_content__" ) - 1 },
{ "__macro__", sizeof( "__macro__" ) - 1 },
{ "__unsupported__", sizeof( "__unsupported__" ) - 1 },
{ "alignas", sizeof( "alignas" ) - 1 },
{ "const", sizeof( "const" ) - 1 },
{ "consteval", sizeof( "consteval" ) - 1 },
{ "constexpr", sizeof( "constexpr" ) - 1 },
{ "constinit", sizeof( "constinit" ) - 1 },
{ "explicit", sizeof( "explicit" ) - 1 },
{ "extern", sizeof( "extern" ) - 1 },
{ "final", sizeof( "final" ) - 1 },
{ "forceinline", sizeof( "forceinline" ) - 1 },
{ "global", sizeof( "global" ) - 1 },
{ "inline", sizeof( "inline" ) - 1 },
{ "internal", sizeof( "internal" ) - 1 },
{ "local_persist", sizeof( "local_persist" ) - 1 },
{ "mutable", sizeof( "mutable" ) - 1 },
{ "neverinline", sizeof( "neverinline" ) - 1 },
{ "override", sizeof( "override" ) - 1 },
{ "static", sizeof( "static" ) - 1 },
{ "thread_local", sizeof( "thread_local" ) - 1 },
{ "volatile", sizeof( "volatile" ) - 1 },
{ "virtual", sizeof( "virtual" ) - 1 },
{ "*", sizeof( "*" ) - 1 },
{ ";", sizeof( ";" ) - 1 },
{ "static_assert", sizeof( "static_assert" ) - 1 },
{ "__string__", sizeof( "__string__" ) - 1 },
{ "typename", sizeof( "typename" ) - 1 },
{ "unsigned", sizeof( "unsigned" ) - 1 },
{ "signed", sizeof( "signed" ) - 1 },
{ "short", sizeof( "short" ) - 1 },
{ "long", sizeof( "long" ) - 1 },
{ "bool", sizeof( "bool" ) - 1 },
{ "char", sizeof( "char" ) - 1 },
{ "int", sizeof( "int" ) - 1 },
{ "double", sizeof( "double" ) - 1 },
{ "__int8", sizeof( "__int8" ) - 1 },
{ "__int16", sizeof( "__int16" ) - 1 },
{ "__int32", sizeof( "__int32" ) - 1 },
{ "__int64", sizeof( "__int64" ) - 1 },
{ "_W64", sizeof( "_W64" ) - 1 },
{ "...", sizeof( "..." ) - 1 },
{ "__attrib_start__", sizeof( "__attrib_start__" ) - 1 },
{ "GEN_API", sizeof( "GEN_API" ) - 1 },
};
return lookup[type];
}
inline TokType str_to_toktype( Str str )
{
local_persist u32 keymap[Tok_NumTokens];
do_once_start for ( u32 index = 0; index < Tok_NumTokens; index++ )
{
Str enum_str = toktype_to_str( (TokType)index );
keymap[index] = crc32( enum_str.Ptr, enum_str.Len );
}
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;
}

View File

@ -6,54 +6,7 @@
#pragma region Constants #pragma region Constants
#ifndef GEN_GLOBAL_BUCKET_SIZE extern Str enum_underlying_sig;
# define GEN_GLOBAL_BUCKET_SIZE megabytes(8)
#endif
#ifndef GEN_CODEPOOL_NUM_BLOCKS
# define GEN_CODEPOOL_NUM_BLOCKS kilobytes(16)
#endif
#ifndef GEN_SIZE_PER_STRING_ARENA
# define GEN_SIZE_PER_STRING_ARENA megabytes(1)
#endif
#ifndef GEN_MAX_COMMENT_LINE_LENGTH
# define GEN_MAX_COMMENT_LINE_LENGTH 1024
#endif
#ifndef GEN_MAX_NAME_LENGTH
# define GEN_MAX_NAME_LENGTH 128
#endif
#ifndef GEN_MAX_UNTYPED_STR_LENGTH
# define GEN_MAX_UNTYPED_STR_LENGTH megabytes(1)
#endif
#ifndef TokenMap_FixedArena
# define TokenMap_FixedArena FixedArena_8KB
#endif
#ifndef GEN_LEX_ALLOCATOR_SIZE
# define GEN_LEX_ALLOCATOR_SIZE megabytes(4)
#endif
#ifndef GEN_BUILDER_STR_BUFFER_RESERVE
# define GEN_BUILDER_STR_BUFFER_RESERVE megabytes(2)
#endif
// These constexprs are used for allocation behavior of data structures
// or string handling while constructing or serializing.
// Change them to suit your needs.
constexpr s32 InitSize_DataArrays = 16;
// NOTE: This limits the maximum size of an allocation
// If you are generating a string larger than this, increase the size of the bucket here.
constexpr usize Global_BucketSize = GEN_GLOBAL_BUCKET_SIZE;
constexpr s32 CodePool_NumBlocks = GEN_CODEPOOL_NUM_BLOCKS;
constexpr s32 SizePer_StringArena = GEN_SIZE_PER_STRING_ARENA;
constexpr s32 MaxCommentLineLength = GEN_MAX_COMMENT_LINE_LENGTH;
constexpr s32 MaxNameLength = GEN_MAX_NAME_LENGTH;
constexpr s32 MaxUntypedStrLength = GEN_MAX_UNTYPED_STR_LENGTH;
// constexpr s32 TokenFmt_TokenMap_MemSize = GEN_TOKEN_FMT_TOKEN_MAP_MEM_SIZE;
constexpr s32 LexAllocator_Size = GEN_LEX_ALLOCATOR_SIZE;
constexpr s32 Builder_StrBufferReserve = GEN_BUILDER_STR_BUFFER_RESERVE;
extern StrC enum_underlying_sig;
extern Code access_public; extern Code access_public;
extern Code access_protected; extern Code access_protected;
@ -111,6 +64,7 @@ extern CodeTypename t_typename;
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS #ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
// Predefined typename codes. Are set to readonly and are setup during gen::init() // Predefined typename codes. Are set to readonly and are setup during gen::init()
extern Context* _ctx;
extern CodeTypename t_b32; extern CodeTypename t_b32;
@ -132,28 +86,3 @@ extern CodeTypename t_typename;
#endif #endif
#pragma endregion Constants #pragma endregion Constants
// Used by the lexer to persistently treat all these identifiers as preprocessor defines.
// 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.
extern Array(StringCached) PreprocessorDefines;
#ifdef GEN_EXPOSE_BACKEND
// Global allocator used for data with process lifetime.
extern AllocatorInfo GlobalAllocator;
extern Array(Arena) Global_AllocatorBuckets;
extern Array(Pool) CodePools;
extern Array(Arena) StringArenas;
extern StringTable StringCache;
extern Arena LexArena;
extern AllocatorInfo Allocator_DataArrays;
extern AllocatorInfo Allocator_CodePool;
extern AllocatorInfo Allocator_Lexer;
extern AllocatorInfo Allocator_StringArena;
extern AllocatorInfo Allocator_StringTable;
extern AllocatorInfo Allocator_TypeTable;
#endif

View File

@ -101,7 +101,7 @@ Code& Code::operator ++()
} }
#endif #endif
forceinline forceinline
StrC code_type_str(Code self) Str code_type_str(Code self)
{ {
GEN_ASSERT(self != nullptr); GEN_ASSERT(self != nullptr);
return codetype_to_str( self->Type ); return codetype_to_str( self->Type );
@ -397,7 +397,7 @@ CodeBody def_body( CodeType type )
} }
inline inline
StrC token_fmt_impl( ssize num, ... ) Str token_fmt_impl( ssize num, ... )
{ {
local_persist thread_local local_persist thread_local
char buf[GEN_PRINTF_MAXLEN] = { 0 }; char buf[GEN_PRINTF_MAXLEN] = { 0 };
@ -408,7 +408,7 @@ StrC token_fmt_impl( ssize num, ... )
ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va); ssize result = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num, va);
va_end(va); va_end(va);
StrC str = { result, buf }; Str str = { buf, result };
return str; return str;
} }
#pragma endregion Interface #pragma endregion Interface

View File

@ -3,15 +3,15 @@
#include "code_serialization.cpp" #include "code_serialization.cpp"
#endif #endif
GEN_NS_PARSER_BEGIN
internal void parser_init(); internal void parser_init();
internal void parser_deinit(); internal void parser_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* fallback_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
{ {
Arena* last = array_back(Global_AllocatorBuckets); GEN_ASSERT(_ctx);
GEN_ASSERT(_ctx->Fallback_AllocatorBuckets);
Arena* last = array_back(_ctx->Fallback_AllocatorBuckets);
switch ( type ) switch ( type )
{ {
@ -19,15 +19,15 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s
{ {
if ( ( last->TotalUsed + size ) > last->TotalSize ) if ( ( last->TotalUsed + size ) > last->TotalSize )
{ {
Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize ); Arena bucket = arena_init_from_allocator( heap(), _ctx->InitSize_Fallback_Allocator_Bucket_Size );
if ( bucket.PhysicalStart == nullptr ) if ( bucket.PhysicalStart == nullptr )
GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets"); GEN_FATAL( "Failed to create bucket for Fallback_AllocatorBuckets");
if ( ! array_append( Global_AllocatorBuckets, bucket ) ) if ( ! array_append( _ctx->Fallback_AllocatorBuckets, bucket ) )
GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets"); GEN_FATAL( "Failed to append bucket to Fallback_AllocatorBuckets");
last = array_back(Global_AllocatorBuckets); last = array_back(_ctx->Fallback_AllocatorBuckets);
} }
return alloc_align( arena_allocator_info(last), size, alignment ); return alloc_align( arena_allocator_info(last), size, alignment );
@ -46,15 +46,15 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s
{ {
if ( last->TotalUsed + size > last->TotalSize ) if ( last->TotalUsed + size > last->TotalSize )
{ {
Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize ); Arena bucket = arena_init_from_allocator( heap(), _ctx->InitSize_Fallback_Allocator_Bucket_Size );
if ( bucket.PhysicalStart == nullptr ) if ( bucket.PhysicalStart == nullptr )
GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets"); GEN_FATAL( "Failed to create bucket for Fallback_AllocatorBuckets");
if ( ! array_append( Global_AllocatorBuckets, bucket ) ) if ( ! array_append( _ctx->Fallback_AllocatorBuckets, bucket ) )
GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets"); GEN_FATAL( "Failed to append bucket to Fallback_AllocatorBuckets");
last = array_back(Global_AllocatorBuckets); last = array_back( _ctx->Fallback_AllocatorBuckets);
} }
void* result = alloc_align( last->Backing, size, alignment ); void* result = alloc_align( last->Backing, size, alignment );
@ -74,8 +74,12 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s
internal internal
void define_constants() void define_constants()
{ {
// We only initalize these if there is no base context.
if ( context_counter > 0 )
return;
Code_Global = make_code(); Code_Global = make_code();
Code_Global->Name = get_cached_string( txt("Global Code") ); Code_Global->Name = cache_str( txt("Global Code") );
Code_Global->Content = Code_Global->Name; Code_Global->Content = Code_Global->Name;
Code_Invalid = make_code(); Code_Invalid = make_code();
@ -83,41 +87,41 @@ void define_constants()
t_empty = (CodeTypename) make_code(); t_empty = (CodeTypename) make_code();
t_empty->Type = CT_Typename; t_empty->Type = CT_Typename;
t_empty->Name = get_cached_string( txt("") ); t_empty->Name = cache_str( txt("") );
code_set_global(cast(Code, t_empty)); code_set_global(cast(Code, t_empty));
access_private = make_code(); access_private = make_code();
access_private->Type = CT_Access_Private; access_private->Type = CT_Access_Private;
access_private->Name = get_cached_string( txt("private:\n") ); access_private->Name = cache_str( txt("private:\n") );
code_set_global(cast(Code, access_private)); code_set_global(cast(Code, access_private));
access_protected = make_code(); access_protected = make_code();
access_protected->Type = CT_Access_Protected; access_protected->Type = CT_Access_Protected;
access_protected->Name = get_cached_string( txt("protected:\n") ); access_protected->Name = cache_str( txt("protected:\n") );
code_set_global(access_protected); code_set_global(access_protected);
access_public = make_code(); access_public = make_code();
access_public->Type = CT_Access_Public; access_public->Type = CT_Access_Public;
access_public->Name = get_cached_string( txt("public:\n") ); access_public->Name = cache_str( txt("public:\n") );
code_set_global(access_public); code_set_global(access_public);
StrC api_export_str = code(GEN_API_Export_Code); Str api_export_str = code(GEN_API_Export_Code);
attrib_api_export = def_attributes( api_export_str ); attrib_api_export = def_attributes( api_export_str );
code_set_global(cast(Code, attrib_api_export)); code_set_global(cast(Code, attrib_api_export));
StrC api_import_str = code(GEN_API_Import_Code); Str api_import_str = code(GEN_API_Import_Code);
attrib_api_import = def_attributes( api_import_str ); attrib_api_import = def_attributes( api_import_str );
code_set_global(cast(Code, attrib_api_import)); code_set_global(cast(Code, attrib_api_import));
module_global_fragment = make_code(); module_global_fragment = make_code();
module_global_fragment->Type = CT_Untyped; module_global_fragment->Type = CT_Untyped;
module_global_fragment->Name = get_cached_string( txt("module;") ); module_global_fragment->Name = cache_str( txt("module;") );
module_global_fragment->Content = module_global_fragment->Name; module_global_fragment->Content = module_global_fragment->Name;
code_set_global(cast(Code, module_global_fragment)); code_set_global(cast(Code, module_global_fragment));
module_private_fragment = make_code(); module_private_fragment = make_code();
module_private_fragment->Type = CT_Untyped; module_private_fragment->Type = CT_Untyped;
module_private_fragment->Name = get_cached_string( txt("module : private;") ); module_private_fragment->Name = cache_str( txt("module : private;") );
module_private_fragment->Content = module_private_fragment->Name; module_private_fragment->Content = module_private_fragment->Name;
code_set_global(cast(Code, module_private_fragment)); code_set_global(cast(Code, module_private_fragment));
@ -127,13 +131,13 @@ void define_constants()
pragma_once = (CodePragma) make_code(); pragma_once = (CodePragma) make_code();
pragma_once->Type = CT_Preprocess_Pragma; pragma_once->Type = CT_Preprocess_Pragma;
pragma_once->Name = get_cached_string( txt("once") ); pragma_once->Name = cache_str( txt("once") );
pragma_once->Content = pragma_once->Name; pragma_once->Content = pragma_once->Name;
code_set_global((Code)pragma_once); code_set_global((Code)pragma_once);
param_varadic = (CodeParams) make_code(); param_varadic = (CodeParams) make_code();
param_varadic->Type = CT_Parameters; param_varadic->Type = CT_Parameters;
param_varadic->Name = get_cached_string( txt("...") ); param_varadic->Name = cache_str( txt("...") );
param_varadic->ValueType = t_empty; param_varadic->ValueType = t_empty;
code_set_global((Code)param_varadic); code_set_global((Code)param_varadic);
@ -145,33 +149,33 @@ void define_constants()
preprocess_endif->Type = CT_Preprocess_EndIf; preprocess_endif->Type = CT_Preprocess_EndIf;
code_set_global((Code)preprocess_endif); code_set_global((Code)preprocess_endif);
StrC auto_str = txt("auto"); t_auto = def_type( auto_str ); code_set_global( t_auto ); Str auto_str = txt("auto"); t_auto = def_type( auto_str ); code_set_global( t_auto );
StrC void_str = txt("void"); t_void = def_type( void_str ); code_set_global( t_void ); Str void_str = txt("void"); t_void = def_type( void_str ); code_set_global( t_void );
StrC int_str = txt("int"); t_int = def_type( int_str ); code_set_global( t_int ); Str int_str = txt("int"); t_int = def_type( int_str ); code_set_global( t_int );
StrC bool_str = txt("bool"); t_bool = def_type( bool_str ); code_set_global( t_bool ); Str bool_str = txt("bool"); t_bool = def_type( bool_str ); code_set_global( t_bool );
StrC char_str = txt("char"); t_char = def_type( char_str ); code_set_global( t_char ); Str char_str = txt("char"); t_char = def_type( char_str ); code_set_global( t_char );
StrC wchar_str = txt("wchar_t"); t_wchar_t = def_type( wchar_str ); code_set_global( t_wchar_t ); Str wchar_str = txt("wchar_t"); t_wchar_t = def_type( wchar_str ); code_set_global( t_wchar_t );
StrC class_str = txt("class"); t_class = def_type( class_str ); code_set_global( t_class ); Str class_str = txt("class"); t_class = def_type( class_str ); code_set_global( t_class );
StrC typename_str = txt("typename"); t_typename = def_type( typename_str ); code_set_global( t_typename ); Str typename_str = txt("typename"); t_typename = def_type( typename_str ); code_set_global( t_typename );
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS #ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
t_b32 = def_type( name(b32) ); code_set_global( t_b32 ); t_b32 = def_type( name(b32) ); code_set_global( t_b32 );
StrC s8_str = txt("s8"); t_s8 = def_type( s8_str ); code_set_global( t_s8 ); Str s8_str = txt("s8"); t_s8 = def_type( s8_str ); code_set_global( t_s8 );
StrC s16_str = txt("s16"); t_s16 = def_type( s16_str ); code_set_global( t_s16 ); Str s16_str = txt("s16"); t_s16 = def_type( s16_str ); code_set_global( t_s16 );
StrC s32_str = txt("s32"); t_s32 = def_type( s32_str ); code_set_global( t_s32 ); Str s32_str = txt("s32"); t_s32 = def_type( s32_str ); code_set_global( t_s32 );
StrC s64_str = txt("s64"); t_s64 = def_type( s64_str ); code_set_global( t_s64 ); Str s64_str = txt("s64"); t_s64 = def_type( s64_str ); code_set_global( t_s64 );
StrC u8_str = txt("u8"); t_u8 = def_type( u8_str ); code_set_global( t_u8 ); Str u8_str = txt("u8"); t_u8 = def_type( u8_str ); code_set_global( t_u8 );
StrC u16_str = txt("u16"); t_u16 = def_type( u16_str ); code_set_global( t_u16 ); Str u16_str = txt("u16"); t_u16 = def_type( u16_str ); code_set_global( t_u16 );
StrC u32_str = txt("u32"); t_u32 = def_type( u32_str ); code_set_global( t_u32 ); Str u32_str = txt("u32"); t_u32 = def_type( u32_str ); code_set_global( t_u32 );
StrC u64_str = txt("u64"); t_u64 = def_type( u64_str ); code_set_global( t_u64 ); Str u64_str = txt("u64"); t_u64 = def_type( u64_str ); code_set_global( t_u64 );
StrC ssize_str = txt("ssize"); t_ssize = def_type( ssize_str ); code_set_global( t_ssize ); Str ssize_str = txt("ssize"); t_ssize = def_type( ssize_str ); code_set_global( t_ssize );
StrC usize_str = txt("usize"); t_usize = def_type( usize_str ); code_set_global( t_usize ); Str usize_str = txt("usize"); t_usize = def_type( usize_str ); code_set_global( t_usize );
StrC f32_str = txt("f32"); t_f32 = def_type( f32_str ); code_set_global( t_f32 ); Str f32_str = txt("f32"); t_f32 = def_type( f32_str ); code_set_global( t_f32 );
StrC f64_str = txt("f64"); t_f64 = def_type( f64_str ); code_set_global( t_f64 ); Str f64_str = txt("f64"); t_f64 = def_type( f64_str ); code_set_global( t_f64 );
#endif #endif
spec_const = def_specifier( Spec_Const); code_set_global( cast(Code, spec_const )); spec_const = def_specifier( Spec_Const); code_set_global( cast(Code, spec_const ));
@ -205,249 +209,264 @@ void define_constants()
if (enum_underlying_sig.Len == 0) { if (enum_underlying_sig.Len == 0) {
enum_underlying_sig = txt("enum_underlying("); enum_underlying_sig = txt("enum_underlying(");
} }
array_append(PreprocessorDefines, enum_underlying_sig); array_append( _ctx->PreprocessorDefines, enum_underlying_sig);
# undef def_constant_spec
} }
void init() void init(Context* ctx)
{ {
// Setup global allocator do_once() {
context_counter = 0;
}
AllocatorInfo fallback_allocator = { & fallback_allocator_proc, nullptr };
b32 using_fallback_allocator = false;
if (ctx->Allocator_DyanmicContainers.Proc == nullptr) {
ctx->Allocator_DyanmicContainers = fallback_allocator;
using_fallback_allocator = true;
}
if (ctx->Allocator_Pool.Proc == nullptr ) {
ctx->Allocator_Pool = fallback_allocator;
using_fallback_allocator = true;
}
if (ctx->Allocator_StrCache.Proc == nullptr) {
ctx->Allocator_StrCache = fallback_allocator;
using_fallback_allocator = true;
}
if (ctx->Allocator_Temp.Proc == nullptr) {
ctx->Allocator_Temp = fallback_allocator;
using_fallback_allocator = true;
}
// Setup fallback allocator
if (using_fallback_allocator)
{ {
AllocatorInfo becasue_C = { & Global_Allocator_Proc, nullptr }; ctx->Fallback_AllocatorBuckets = array_init_reserve(Arena, heap(), 128 );
GlobalAllocator = becasue_C; if ( ctx->Fallback_AllocatorBuckets == nullptr )
GEN_FATAL( "Failed to reserve memory for Fallback_AllocatorBuckets");
Global_AllocatorBuckets = array_init_reserve(Arena, heap(), 128 );
if ( Global_AllocatorBuckets == nullptr )
GEN_FATAL( "Failed to reserve memory for Global_AllocatorBuckets");
Arena bucket = arena_init_from_allocator( heap(), Global_BucketSize );
Arena bucket = arena_init_from_allocator( heap(), ctx->InitSize_Fallback_Allocator_Bucket_Size );
if ( bucket.PhysicalStart == nullptr ) if ( bucket.PhysicalStart == nullptr )
GEN_FATAL( "Failed to create first bucket for Global_AllocatorBuckets"); GEN_FATAL( "Failed to create first bucket for Fallback_AllocatorBuckets");
array_append( Global_AllocatorBuckets, bucket ); array_append( ctx->Fallback_AllocatorBuckets, bucket );
} }
if (Allocator_DataArrays.Proc == nullptr) { if (ctx->Max_CommentLineLength == 0) {
Allocator_DataArrays = GlobalAllocator; ctx->Max_CommentLineLength = 1024;
} }
if (Allocator_CodePool.Proc == nullptr ) { if (ctx->Max_StrCacheLength == 0) {
Allocator_CodePool = GlobalAllocator; ctx->Max_StrCacheLength = kilobytes(512);
} }
if (Allocator_Lexer.Proc == nullptr) {
Allocator_Lexer = GlobalAllocator; if (ctx->InitSize_BuilderBuffer == 0) {
ctx->InitSize_BuilderBuffer = megabytes(2);
} }
if (Allocator_StringArena.Proc == nullptr) { if (ctx->InitSize_CodePoolsArray == 0) {
Allocator_StringArena = GlobalAllocator; ctx->InitSize_CodePoolsArray = 16;
} }
if (Allocator_StringTable.Proc == nullptr) { if (ctx->InitSize_StringArenasArray == 0) {
Allocator_StringTable = GlobalAllocator; ctx->InitSize_StringArenasArray = 16;
} }
if (Allocator_TypeTable.Proc == nullptr) { if (ctx->CodePool_NumBlocks == 0) {
Allocator_TypeTable = GlobalAllocator; ctx->CodePool_NumBlocks = kilobytes(16);
} }
if (ctx->InitSize_LexArena == 0 ) {
ctx->InitSize_LexArena = megabytes(4);
}
if (ctx->SizePer_StringArena == 0) {
ctx->SizePer_StringArena = megabytes(1);
}
if (ctx->InitSize_Fallback_Allocator_Bucket_Size == 0) {
ctx->InitSize_Fallback_Allocator_Bucket_Size = megabytes(8);
}
// Override the current context (user has to put it back if unwanted).
_ctx = ctx;
// Setup the arrays // Setup the arrays
{ {
CodePools = array_init_reserve(Pool, Allocator_DataArrays, InitSize_DataArrays ); ctx->CodePools = array_init_reserve(Pool, ctx->Allocator_DyanmicContainers, ctx->InitSize_CodePoolsArray );
if ( ctx->CodePools == nullptr )
if ( CodePools == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the CodePools array" ); GEN_FATAL( "gen::init: Failed to initialize the CodePools array" );
StringArenas = array_init_reserve(Arena, Allocator_DataArrays, InitSize_DataArrays ); ctx->StringArenas = array_init_reserve(Arena, ctx->Allocator_DyanmicContainers, ctx->InitSize_StringArenasArray );
if ( ctx->StringArenas == nullptr )
if ( StringArenas == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the StringArenas array" ); GEN_FATAL( "gen::init: Failed to initialize the StringArenas array" );
} }
// Setup the code pool and code entries arena. // Setup the code pool and code entries arena.
{ {
Pool code_pool = pool_init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) ); Pool code_pool = pool_init( ctx->Allocator_Pool, ctx->CodePool_NumBlocks, sizeof(AST) );
if ( code_pool.PhysicalStart == nullptr ) if ( code_pool.PhysicalStart == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the code pool" ); GEN_FATAL( "gen::init: Failed to initialize the code pool" );
array_append( ctx->CodePools, code_pool );
array_append( CodePools, code_pool ); // TODO(Ed): This is going to be phased out most likely.
ctx->LexArena = arena_init_from_allocator( ctx->Allocator_DyanmicContainers, ctx->InitSize_LexArena );
LexArena = arena_init_from_allocator( Allocator_Lexer, LexAllocator_Size ); // TODO(Ed): Eventually the string arenas needs to be phased out for a dedicated string slab allocator
Arena strbuilder_arena = arena_init_from_allocator( ctx->Allocator_StrCache, ctx->SizePer_StringArena );
Arena string_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena ); if ( strbuilder_arena.PhysicalStart == nullptr )
if ( string_arena.PhysicalStart == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the string arena" ); GEN_FATAL( "gen::init: Failed to initialize the string arena" );
array_append( ctx->StringArenas, strbuilder_arena );
array_append( StringArenas, string_arena );
} }
// Setup the hash tables // Setup the hash tables
{ {
StringCache = hashtable_init(StringCached, Allocator_StringTable); ctx->StrCache = hashtable_init(StrCached, ctx->Allocator_DyanmicContainers);
if ( ctx->StrCache.Entries == nullptr )
if ( StringCache.Entries == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the StringCache"); GEN_FATAL( "gen::init: Failed to initialize the StringCache");
} }
// Preprocessor Defines // Preprocessor Defines
PreprocessorDefines = array_init_reserve(StringCached, GlobalAllocator, kilobytes(1) ); ctx->PreprocessorDefines = array_init_reserve(StrCached, ctx->Allocator_DyanmicContainers, kilobytes(1) );
define_constants(); define_constants();
GEN_NS_PARSER parser_init(); parser_init();
++ context_counter;
} }
void deinit() void deinit(Context* ctx)
{ {
GEN_ASSERT(context_counter);
GEN_ASSERT_MSG(context_counter > 0, "Attempted to deinit a context that for some reason wan't accounted for!");
usize index = 0; usize index = 0;
usize left = array_num(CodePools); usize left = array_num(ctx->CodePools);
do do
{ {
Pool* code_pool = & CodePools[index]; Pool* code_pool = & ctx->CodePools[index];
pool_free(code_pool); pool_free(code_pool);
index++; index++;
} }
while ( left--, left ); while ( left--, left );
index = 0; index = 0;
left = array_num(StringArenas); left = array_num(ctx->StringArenas);
do do
{ {
Arena* string_arena = & StringArenas[index]; Arena* strbuilder_arena = & ctx->StringArenas[index];
arena_free(string_arena); arena_free(strbuilder_arena);
index++; index++;
} }
while ( left--, left ); while ( left--, left );
hashtable_destroy(StringCache); hashtable_destroy(ctx->StrCache);
array_free( CodePools); array_free( ctx->CodePools);
array_free( StringArenas); array_free( ctx->StringArenas);
arena_free(& LexArena); arena_free(& ctx->LexArena);
array_free(PreprocessorDefines); array_free(ctx->PreprocessorDefines);
index = 0; left = array_num( ctx->Fallback_AllocatorBuckets);
left = array_num(Global_AllocatorBuckets); if (left)
do
{ {
Arena* bucket = & Global_AllocatorBuckets[ index ]; index = 0;
arena_free(bucket); do
index++; {
Arena* bucket = & ctx->Fallback_AllocatorBuckets[ index ];
arena_free(bucket);
index++;
}
while ( left--, left );
array_free( ctx->Fallback_AllocatorBuckets);
} }
while ( left--, left ); parser_deinit();
array_free(Global_AllocatorBuckets); if (_ctx == ctx)
GEN_NS_PARSER parser_deinit(); _ctx = nullptr;
-- context_counter;
} }
void reset() void reset(Context* ctx)
{ {
s32 index = 0; s32 index = 0;
s32 left = array_num(CodePools); s32 left = array_num(ctx->CodePools);
do do
{ {
Pool* code_pool = & CodePools[index]; Pool* code_pool = & ctx->CodePools[index];
pool_clear(code_pool); pool_clear(code_pool);
index++; index++;
} }
while ( left--, left ); while ( left--, left );
index = 0; index = 0;
left = array_num(StringArenas); left = array_num(ctx->StringArenas);
do do
{ {
Arena* string_arena = & StringArenas[index]; Arena* strbuilder_arena = & ctx->StringArenas[index];
string_arena->TotalUsed = 0;; strbuilder_arena->TotalUsed = 0;;
index++; index++;
} }
while ( left--, left ); while ( left--, left );
hashtable_clear(StringCache); hashtable_clear(ctx->StrCache);
define_constants(); define_constants();
} }
AllocatorInfo get_string_allocator( s32 str_length ) void set_context(Context* new_ctx) {
GEN_ASSERT(new_ctx);
_ctx = new_ctx;
}
AllocatorInfo get_cached_str_allocator( s32 str_length )
{ {
Arena* last = array_back(StringArenas); Arena* last = array_back(_ctx->StringArenas);
usize size_req = str_length + sizeof(StrBuilderHeader) + sizeof(char*);
usize size_req = str_length + sizeof(StringHeader) + sizeof(char*);
if ( last->TotalUsed + scast(ssize, size_req) > last->TotalSize ) if ( last->TotalUsed + scast(ssize, size_req) > last->TotalSize )
{ {
Arena new_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena ); Arena new_arena = arena_init_from_allocator( _ctx->Allocator_StrCache, _ctx->SizePer_StringArena );
if ( ! array_append( _ctx->StringArenas, new_arena ) )
GEN_FATAL( "gen::get_cached_str_allocator: Failed to allocate a new string arena" );
if ( ! array_append( StringArenas, new_arena ) ) last = array_back( _ctx->StringArenas);
GEN_FATAL( "gen::get_string_allocator: Failed to allocate a new string arena" );
last = array_back(StringArenas);
} }
return arena_allocator_info(last); return arena_allocator_info(last);
} }
// Will either make or retrive a code string. // Will either make or retrive a code string.
StringCached get_cached_string( StrC str ) StrCached cache_str( Str str )
{ {
s32 hash_length = str.Len > kilobytes(1) ? kilobytes(1) : str.Len; if (str.Len > _ctx->Max_StrCacheLength) {
u64 key = crc32( str.Ptr, hash_length ); // Do not cache the string, just shove into the arena and and return it.
{ Str result = strbuilder_to_str( strbuilder_make_str( get_cached_str_allocator( str.Len ), str ));
StringCached* result = hashtable_get(StringCache, key ); return result;
}
u64 key = crc32( str.Ptr, str.Len ); {
StrCached* result = hashtable_get( _ctx->StrCache, key );
if ( result ) if ( result )
return * result; return * result;
} }
Str result = strbuilder_to_str( strbuilder_make_str( get_cached_str_allocator( str.Len ), str ));
StrC result = string_to_strc( string_make_strc( get_string_allocator( str.Len ), str )); hashtable_set( _ctx->StrCache, key, result );
hashtable_set(StringCache, key, result );
return result; return result;
} }
// Used internally to retireve a Code object form the CodePool. // Used internally to retireve a Code object form the CodePool.
Code make_code() Code make_code()
{ {
Pool* allocator = array_back( CodePools); Pool* allocator = array_back( _ctx->CodePools);
if ( allocator->FreeList == nullptr ) if ( allocator->FreeList == nullptr )
{ {
Pool code_pool = pool_init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) ); Pool code_pool = pool_init( _ctx->Allocator_Pool, _ctx->CodePool_NumBlocks, sizeof(AST) );
if ( code_pool.PhysicalStart == nullptr ) if ( code_pool.PhysicalStart == nullptr )
GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePool allcoator returned nullptr." ); GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePool allcoator returned nullptr." );
if ( ! array_append( CodePools, code_pool ) ) if ( ! array_append( _ctx->CodePools, code_pool ) )
GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePools failed to append new pool." ); GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePools failed to append new pool." );
allocator = array_back( CodePools); allocator = array_back( _ctx->CodePools);
} }
Code result = { rcast( AST*, alloc( pool_allocator_info(allocator), sizeof(AST) )) }; Code result = { rcast( AST*, alloc( pool_allocator_info(allocator), sizeof(AST) )) };
mem_set( rcast(void*, cast(AST*, result)), 0, sizeof(AST) ); mem_set( rcast(void*, cast(AST*, result)), 0, sizeof(AST) );
return result; return result;
} }
void set_allocator_data_arrays( AllocatorInfo allocator ) void set_preprocess_define( Str id, b32 is_functional ) {
{ StrBuilder builder = strbuilder_make_str( _ctx->Allocator_Temp, id );
Allocator_DataArrays = allocator; if (is_functional) {
} strbuilder_append_char( & builder, '(' );
}
void set_allocator_code_pool( AllocatorInfo allocator ) array_append( _ctx->PreprocessorDefines, cache_str( strbuilder_to_str(builder)) );
{
Allocator_CodePool = allocator;
}
void set_allocator_lexer( AllocatorInfo allocator )
{
Allocator_Lexer = allocator;
}
void set_allocator_string_arena( AllocatorInfo allocator )
{
Allocator_StringArena = allocator;
}
void set_allocator_string_table( AllocatorInfo allocator )
{
Allocator_StringArena = allocator;
} }

View File

@ -15,41 +15,121 @@
\ \\ \ \\ \ \ \\ \ \ \ \ \ \\ \ \\ \ \ \\ \ \ \ \
*/ */
// Initialize the library. #if 0
void init(); enum LogLevel : u32
{
Info,
Warning,
Panic,
};
struct LogEntry
{
Str msg;
u32 line_num;
void* data;
};
typedef void LoggerCallback(LogEntry entry);
#endif
// Note(Ed): This is subject to heavily change
// with upcoming changes to the library's fallback (default) allocations strategy;
// and major changes to lexer/parser context usage.
struct Context
{
// User Configuration
// Persistent Data Allocation
AllocatorInfo Allocator_DyanmicContainers; // By default will use a genral slab allocator (TODO(Ed): Currently does not)
AllocatorInfo Allocator_Pool; // By default will use the growing vmem reserve (TODO(Ed): Currently does not)
AllocatorInfo Allocator_StrCache; // By default will use a dedicated slab allocator (TODO(Ed): Currently does not)
// Temporary Allocation
AllocatorInfo Allocator_Temp;
// LoggerCallaback* log_callback; // TODO(Ed): Impl user logger callback as an option.
u32 Max_CommentLineLength; // Used by def_comment
u32 Max_StrCacheLength; // Any cached string longer than this is always allocated again.
u32 InitSize_BuilderBuffer;
u32 InitSize_CodePoolsArray;
u32 InitSize_StringArenasArray;
u32 CodePool_NumBlocks;
// TODO(Ed): Review these... (No longer needed if using the proper allocation strategy)
u32 InitSize_LexArena;
u32 SizePer_StringArena;
// TODO(Ed): Symbol Table
// Keep track of all resolved symbols (naemspaced identifiers)
// Parser
// Used by the lexer to persistently treat all these identifiers as preprocessor defines.
// Populate with strings via gen::cache_str.
// Functional defines must have format: id( ;at minimum to indicate that the define is only valid with arguments.
Array(StrCached) PreprocessorDefines;
// Backend
// The fallback allocator is utilized if any fo the three above allocators is not specified by the user.
u32 InitSize_Fallback_Allocator_Bucket_Size;
Array(Arena) Fallback_AllocatorBuckets;
// Array(Token) LexerTokens;
Array(Pool) CodePools;
Array(Arena) StringArenas;
StringTable StrCache;
// TODO(Ed): This needs to be just handled by a parser context
Arena LexArena;
StringTable Lexer_defines;
Array(Token) Lexer_Tokens;
// TODO(Ed): Active parse context vs a parse result need to be separated conceptually
ParseContext parser;
};
// Initialize the library. There first ctx initialized must exist for lifetime of other contextes that come after as its the one that
GEN_API void init(Context* ctx);
// Currently manually free's the arenas, code for checking for leaks. // Currently manually free's the arenas, code for checking for leaks.
// However on Windows at least, it doesn't need to occur as the OS will clean up after the process. // However on Windows at least, it doesn't need to occur as the OS will clean up after the process.
void deinit(); GEN_API void deinit(Context* ctx);
// Clears the allocations, but doesn't return to the heap, the calls init() again. // Clears the allocations, but doesn't free the memoery, then calls init() again.
// Ease of use. // Ease of use.
void reset(); GEN_API void reset(Context* ctx);
GEN_API void set_context(Context* ctx);
// Alternative way to add a preprocess define entry for the lexer & parser to utilize
// if the user doesn't want to use def_define
GEN_API void set_preprocess_define( Str id, b32 is_functional );
// Used internally to retrive or make string allocations. // Used internally to retrive or make string allocations.
// Strings are stored in a series of string arenas of fixed size (SizePer_StringArena) // Strings are stored in a series of string arenas of fixed size (SizePer_StringArena)
StringCached get_cached_string( StrC str ); GEN_API StrCached cache_str( Str str );
/* /*
This provides a fresh Code AST. This provides a fresh Code AST.
The gen interface use this as their method from getting a new AST object from the CodePool. The gen interface use this as their method from getting a new AST object from the CodePool.
Use this if you want to make your own API for formatting the supported Code Types. Use this if you want to make your own API for formatting the supported Code Types.
*/ */
Code make_code(); GEN_API Code make_code();
// Set these before calling gen's init() procedure. // Set these before calling gen's init() procedure.
void set_allocator_data_arrays ( AllocatorInfo data_array_allocator );
void set_allocator_code_pool ( AllocatorInfo pool_allocator );
void set_allocator_lexer ( AllocatorInfo lex_allocator );
void set_allocator_string_arena( AllocatorInfo string_allocator );
void set_allocator_string_table( AllocatorInfo string_allocator );
void set_allocator_type_table ( AllocatorInfo type_reg_allocator );
#pragma region Upfront #pragma region Upfront
CodeAttributes def_attributes( StrC content ); GEN_API CodeAttributes def_attributes( Str content );
CodeComment def_comment ( StrC content ); GEN_API CodeComment def_comment ( Str content );
struct Opts_def_struct { struct Opts_def_struct {
CodeBody body; CodeBody body;
@ -60,25 +140,25 @@ struct Opts_def_struct {
s32 num_interfaces; s32 num_interfaces;
ModuleFlag mflags; ModuleFlag mflags;
}; };
CodeClass def_class( StrC name, Opts_def_struct opts GEN_PARAM_DEFAULT ); GEN_API CodeClass def_class( Str name, Opts_def_struct opts GEN_PARAM_DEFAULT );
struct Opts_def_constructor { struct Opts_def_constructor {
CodeParams params; CodeParams params;
Code initializer_list; Code initializer_list;
Code body; Code body;
}; };
CodeConstructor def_constructor( Opts_def_constructor opts GEN_PARAM_DEFAULT ); GEN_API CodeConstructor def_constructor( Opts_def_constructor opts GEN_PARAM_DEFAULT );
struct Opts_def_define { struct Opts_def_define {
b32 dont_append_preprocess_defines; b32 dont_append_preprocess_defines;
}; };
CodeDefine def_define( StrC name, StrC content, Opts_def_define opts GEN_PARAM_DEFAULT ); GEN_API CodeDefine def_define( Str name, Str content, Opts_def_define opts GEN_PARAM_DEFAULT );
struct Opts_def_destructor { struct Opts_def_destructor {
Code body; Code body;
CodeSpecifiers specifiers; CodeSpecifiers specifiers;
}; };
CodeDestructor def_destructor( Opts_def_destructor opts GEN_PARAM_DEFAULT ); GEN_API CodeDestructor def_destructor( Opts_def_destructor opts GEN_PARAM_DEFAULT );
struct Opts_def_enum { struct Opts_def_enum {
CodeBody body; CodeBody body;
@ -88,11 +168,11 @@ struct Opts_def_enum {
ModuleFlag mflags; ModuleFlag mflags;
Code type_macro; Code type_macro;
}; };
CodeEnum def_enum( StrC name, Opts_def_enum opts GEN_PARAM_DEFAULT ); GEN_API CodeEnum def_enum( Str name, Opts_def_enum opts GEN_PARAM_DEFAULT );
CodeExec def_execution ( StrC content ); GEN_API CodeExec def_execution ( Str content );
CodeExtern def_extern_link( StrC name, CodeBody body ); GEN_API CodeExtern def_extern_link( Str name, CodeBody body );
CodeFriend def_friend ( Code symbol ); GEN_API CodeFriend def_friend ( Code symbol );
struct Opts_def_function { struct Opts_def_function {
CodeParams params; CodeParams params;
@ -102,14 +182,14 @@ struct Opts_def_function {
CodeAttributes attrs; CodeAttributes attrs;
ModuleFlag mflags; ModuleFlag mflags;
}; };
CodeFn def_function( StrC name, Opts_def_function opts GEN_PARAM_DEFAULT ); GEN_API CodeFn def_function( Str name, Opts_def_function opts GEN_PARAM_DEFAULT );
struct Opts_def_include { b32 foreign; }; struct Opts_def_include { b32 foreign; };
struct Opts_def_module { ModuleFlag mflags; }; struct Opts_def_module { ModuleFlag mflags; };
struct Opts_def_namespace { ModuleFlag mflags; }; struct Opts_def_namespace { ModuleFlag mflags; };
CodeInclude def_include ( StrC content, Opts_def_include opts GEN_PARAM_DEFAULT ); GEN_API CodeInclude def_include ( Str content, Opts_def_include opts GEN_PARAM_DEFAULT );
CodeModule def_module ( StrC name, Opts_def_module opts GEN_PARAM_DEFAULT ); GEN_API CodeModule def_module ( Str name, Opts_def_module opts GEN_PARAM_DEFAULT );
CodeNS def_namespace( StrC name, CodeBody body, Opts_def_namespace opts GEN_PARAM_DEFAULT ); GEN_API CodeNS def_namespace( Str name, CodeBody body, Opts_def_namespace opts GEN_PARAM_DEFAULT );
struct Opts_def_operator { struct Opts_def_operator {
CodeParams params; CodeParams params;
@ -119,26 +199,26 @@ struct Opts_def_operator {
CodeAttributes attributes; CodeAttributes attributes;
ModuleFlag mflags; ModuleFlag mflags;
}; };
CodeOperator def_operator( Operator op, StrC nspace, Opts_def_operator opts GEN_PARAM_DEFAULT ); GEN_API CodeOperator def_operator( Operator op, Str nspace, Opts_def_operator opts GEN_PARAM_DEFAULT );
struct Opts_def_operator_cast { struct Opts_def_operator_cast {
CodeBody body; CodeBody body;
CodeSpecifiers specs; CodeSpecifiers specs;
}; };
CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast opts GEN_PARAM_DEFAULT ); GEN_API CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast opts GEN_PARAM_DEFAULT );
struct Opts_def_param { Code value; }; struct Opts_def_param { Code value; };
CodeParams def_param ( CodeTypename type, StrC name, Opts_def_param opts GEN_PARAM_DEFAULT ); GEN_API CodeParams def_param ( CodeTypename type, Str name, Opts_def_param opts GEN_PARAM_DEFAULT );
CodePragma def_pragma( StrC directive ); GEN_API CodePragma def_pragma( Str directive );
CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC content ); GEN_API CodePreprocessCond def_preprocess_cond( EPreprocessCond type, Str content );
CodeSpecifiers def_specifier( Specifier specifier ); GEN_API CodeSpecifiers def_specifier( Specifier specifier );
CodeStruct def_struct( StrC name, Opts_def_struct opts GEN_PARAM_DEFAULT ); GEN_API CodeStruct def_struct( Str name, Opts_def_struct opts GEN_PARAM_DEFAULT );
struct Opts_def_template { ModuleFlag mflags; }; struct Opts_def_template { ModuleFlag mflags; };
CodeTemplate def_template( CodeParams params, Code definition, Opts_def_template opts GEN_PARAM_DEFAULT ); GEN_API CodeTemplate def_template( CodeParams params, Code definition, Opts_def_template opts GEN_PARAM_DEFAULT );
struct Opts_def_type { struct Opts_def_type {
ETypenameTag type_tag; ETypenameTag type_tag;
@ -146,27 +226,27 @@ struct Opts_def_type {
CodeSpecifiers specifiers; CodeSpecifiers specifiers;
CodeAttributes attributes; CodeAttributes attributes;
}; };
CodeTypename def_type( StrC name, Opts_def_type opts GEN_PARAM_DEFAULT ); GEN_API CodeTypename def_type( Str name, Opts_def_type opts GEN_PARAM_DEFAULT );
struct Opts_def_typedef { struct Opts_def_typedef {
CodeAttributes attributes; CodeAttributes attributes;
ModuleFlag mflags; ModuleFlag mflags;
}; };
CodeTypedef def_typedef( StrC name, Code type, Opts_def_typedef opts GEN_PARAM_DEFAULT ); GEN_API CodeTypedef def_typedef( Str name, Code type, Opts_def_typedef opts GEN_PARAM_DEFAULT );
struct Opts_def_union { struct Opts_def_union {
CodeAttributes attributes; CodeAttributes attributes;
ModuleFlag mflags; ModuleFlag mflags;
}; };
CodeUnion def_union( StrC name, CodeBody body, Opts_def_union opts GEN_PARAM_DEFAULT ); GEN_API CodeUnion def_union( Str name, CodeBody body, Opts_def_union opts GEN_PARAM_DEFAULT );
struct Opts_def_using { struct Opts_def_using {
CodeAttributes attributes; CodeAttributes attributes;
ModuleFlag mflags; ModuleFlag mflags;
}; };
CodeUsing def_using( StrC name, CodeTypename type, Opts_def_using opts GEN_PARAM_DEFAULT ); GEN_API CodeUsing def_using( Str name, CodeTypename type, Opts_def_using opts GEN_PARAM_DEFAULT );
CodeUsing def_using_namespace( StrC name ); GEN_API CodeUsing def_using_namespace( Str name );
struct Opts_def_variable struct Opts_def_variable
{ {
@ -175,36 +255,36 @@ struct Opts_def_variable
CodeAttributes attributes; CodeAttributes attributes;
ModuleFlag mflags; ModuleFlag mflags;
}; };
CodeVar def_variable( CodeTypename type, StrC name, Opts_def_variable opts GEN_PARAM_DEFAULT ); GEN_API CodeVar def_variable( CodeTypename type, Str name, Opts_def_variable opts GEN_PARAM_DEFAULT );
// Constructs an empty body. Use AST::validate_body() to check if the body is was has valid entries. // Constructs an empty body. Use AST::validate_body() to check if the body is was has valid entries.
CodeBody def_body( CodeType type ); GEN_API CodeBody def_body( CodeType type );
// There are two options for defining a struct body, either varadically provided with the args macro to auto-deduce the arg num, // There are two options for defining a struct body, either varadically provided with the args macro to auto-deduce the arg num,
/// or provide as an array of Code objects. /// or provide as an array of Code objects.
CodeBody def_class_body ( s32 num, ... ); GEN_API CodeBody def_class_body ( s32 num, ... );
CodeBody def_class_body ( s32 num, Code* codes ); GEN_API CodeBody def_class_body ( s32 num, Code* codes );
CodeBody def_enum_body ( s32 num, ... ); GEN_API CodeBody def_enum_body ( s32 num, ... );
CodeBody def_enum_body ( s32 num, Code* codes ); GEN_API CodeBody def_enum_body ( s32 num, Code* codes );
CodeBody def_export_body ( s32 num, ... ); GEN_API CodeBody def_export_body ( s32 num, ... );
CodeBody def_export_body ( s32 num, Code* codes); GEN_API CodeBody def_export_body ( s32 num, Code* codes);
CodeBody def_extern_link_body( s32 num, ... ); GEN_API CodeBody def_extern_link_body( s32 num, ... );
CodeBody def_extern_link_body( s32 num, Code* codes ); GEN_API CodeBody def_extern_link_body( s32 num, Code* codes );
CodeBody def_function_body ( s32 num, ... ); GEN_API CodeBody def_function_body ( s32 num, ... );
CodeBody def_function_body ( s32 num, Code* codes ); GEN_API CodeBody def_function_body ( s32 num, Code* codes );
CodeBody def_global_body ( s32 num, ... ); GEN_API CodeBody def_global_body ( s32 num, ... );
CodeBody def_global_body ( s32 num, Code* codes ); GEN_API CodeBody def_global_body ( s32 num, Code* codes );
CodeBody def_namespace_body ( s32 num, ... ); GEN_API CodeBody def_namespace_body ( s32 num, ... );
CodeBody def_namespace_body ( s32 num, Code* codes ); GEN_API CodeBody def_namespace_body ( s32 num, Code* codes );
CodeParams def_params ( s32 num, ... ); GEN_API CodeParams def_params ( s32 num, ... );
CodeParams def_params ( s32 num, CodeParams* params ); GEN_API CodeParams def_params ( s32 num, CodeParams* params );
CodeSpecifiers def_specifiers ( s32 num, ... ); GEN_API CodeSpecifiers def_specifiers ( s32 num, ... );
CodeSpecifiers def_specifiers ( s32 num, Specifier* specs ); GEN_API CodeSpecifiers def_specifiers ( s32 num, Specifier* specs );
CodeBody def_struct_body ( s32 num, ... ); GEN_API CodeBody def_struct_body ( s32 num, ... );
CodeBody def_struct_body ( s32 num, Code* codes ); GEN_API CodeBody def_struct_body ( s32 num, Code* codes );
CodeBody def_union_body ( s32 num, ... ); GEN_API CodeBody def_union_body ( s32 num, ... );
CodeBody def_union_body ( s32 num, Code* codes ); GEN_API CodeBody def_union_body ( s32 num, Code* codes );
#pragma endregion Upfront #pragma endregion Upfront
@ -213,23 +293,21 @@ CodeBody def_union_body ( s32 num, Code* codes );
// TODO(Ed) : Implmeent the new parser API design. // TODO(Ed) : Implmeent the new parser API design.
#if 0 #if 0
GEN_NS_PARSER_BEGIN
struct StackNode struct StackNode
{ {
StackNode* Prev; StackNode* Prev;
Token Start; Token Start;
Token Name; // The name of the AST node (if parsed) Token Name; // The name of the AST node (if parsed)
StrC FailedProc; // The name of the procedure that failed Str FailedProc; // The name of the procedure that failed
}; };
// Stack nodes are allocated the error's allocator // Stack nodes are allocated the error's allocator
struct Error struct Error
{ {
String message; StrBuilder message;
StackNode* context_stack; StackNode* context_stack;
}; };
GEN_NS_PARSER_END
struct ParseInfo struct ParseInfo
{ {
@ -243,40 +321,40 @@ struct ParseInfo
// Errors are allocated to a dedicated general arena. // Errors are allocated to a dedicated general arena.
}; };
CodeBody parse_file( StrC path ); CodeBody parse_file( Str path );
#endif #endif
CodeClass parse_class ( StrC class_def ); GEN_API CodeClass parse_class ( Str class_def );
CodeConstructor parse_constructor ( StrC constructor_def ); GEN_API CodeConstructor parse_constructor ( Str constructor_def );
CodeDestructor parse_destructor ( StrC destructor_def ); GEN_API CodeDestructor parse_destructor ( Str destructor_def );
CodeEnum parse_enum ( StrC enum_def ); GEN_API CodeEnum parse_enum ( Str enum_def );
CodeBody parse_export_body ( StrC export_def ); GEN_API CodeBody parse_export_body ( Str export_def );
CodeExtern parse_extern_link ( StrC exten_link_def ); GEN_API CodeExtern parse_extern_link ( Str exten_link_def );
CodeFriend parse_friend ( StrC friend_def ); GEN_API CodeFriend parse_friend ( Str friend_def );
CodeFn parse_function ( StrC fn_def ); GEN_API CodeFn parse_function ( Str fn_def );
CodeBody parse_global_body ( StrC body_def ); GEN_API CodeBody parse_global_body ( Str body_def );
CodeNS parse_namespace ( StrC namespace_def ); GEN_API CodeNS parse_namespace ( Str namespace_def );
CodeOperator parse_operator ( StrC operator_def ); GEN_API CodeOperator parse_operator ( Str operator_def );
CodeOpCast parse_operator_cast( StrC operator_def ); GEN_API CodeOpCast parse_operator_cast( Str operator_def );
CodeStruct parse_struct ( StrC struct_def ); GEN_API CodeStruct parse_struct ( Str struct_def );
CodeTemplate parse_template ( StrC template_def ); GEN_API CodeTemplate parse_template ( Str template_def );
CodeTypename parse_type ( StrC type_def ); GEN_API CodeTypename parse_type ( Str type_def );
CodeTypedef parse_typedef ( StrC typedef_def ); GEN_API CodeTypedef parse_typedef ( Str typedef_def );
CodeUnion parse_union ( StrC union_def ); GEN_API CodeUnion parse_union ( Str union_def );
CodeUsing parse_using ( StrC using_def ); GEN_API CodeUsing parse_using ( Str using_def );
CodeVar parse_variable ( StrC var_def ); GEN_API CodeVar parse_variable ( Str var_def );
#pragma endregion Parsing #pragma endregion Parsing
#pragma region Untyped text #pragma region Untyped text
ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va ); GEN_API ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va );
//! Do not use directly. Use the token_fmt macro instead. //! Do not use directly. Use the token_fmt macro instead.
StrC token_fmt_impl( ssize, ... ); GEN_API Str token_fmt_impl( ssize, ... );
Code untyped_str ( StrC content); GEN_API Code untyped_str( Str content);
Code untyped_fmt ( char const* fmt, ... ); GEN_API Code untyped_fmt ( char const* fmt, ... );
Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... ); GEN_API Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
#pragma endregion Untyped text #pragma endregion Untyped text
@ -289,12 +367,12 @@ Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
#ifndef name #ifndef name
// Convienence for defining any name used with the gen api. // 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. // 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_) } #define name( Id_ ) { stringize(Id_), sizeof(stringize( Id_ )) - 1 }
#endif #endif
#ifndef code #ifndef code
// Same as name just used to indicate intention of literal for code instead of names. // 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 code( ... ) { stringize( __VA_ARGS__ ), sizeof(stringize(__VA_ARGS__)) - 1 }
#endif #endif
#ifndef args #ifndef args
@ -317,21 +395,21 @@ Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
#ifndef token_fmt #ifndef token_fmt
/* /*
Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string. Takes a format string (char const*) and a list of tokens (Str) and returns a Str of the formatted string.
Tokens are provided in '<'identifier'>' format where '<' '>' are just angle brackets (you can change it in token_fmt_va) Tokens are provided in '<'identifier'>' format where '<' '>' are just angle brackets (you can change it in token_fmt_va)
--------------------------------------------------------- ---------------------------------------------------------
Example - A string with: Example - A string with:
typedef <type> <name> <name>; typedef <type> <name> <name>;
Will have a token_fmt arguments populated with: Will have a token_fmt arguments populated with:
"type", strc_for_type, "type", str_for_type,
"name", strc_for_name, "name", str_for_name,
and: and:
stringize( typedef <type> <name> <name>; ) stringize( typedef <type> <name> <name>; )
----------------------------------------------------------- -----------------------------------------------------------
So the full call for this example would be: So the full call for this example would be:
token_fmt( token_fmt(
"type", strc_for_type "type", str_for_type
, "name", strc_for_name , "name", str_for_name
, stringize( , stringize(
typedef <type> <name> <name> typedef <type> <name> <name>
)); ));

View File

@ -8,25 +8,23 @@
// Publically Exposed Interface // Publically Exposed Interface
CodeClass parse_class( StrC def ) CodeClass parse_class( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
push_scope(); push_scope();
CodeClass result = (CodeClass) parse_class_struct( Tok_Decl_Class, parser_not_inplace_def ); CodeClass result = (CodeClass) parse_class_struct( Tok_Decl_Class, parser_not_inplace_def );
parser_pop(& Context); parser_pop(& _ctx->parser);
return result; return result;
} }
CodeConstructor parse_constructor( StrC def ) CodeConstructor parse_constructor( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
@ -41,7 +39,7 @@ CodeConstructor parse_constructor( StrC def )
while ( left && tok_is_specifier(currtok) ) while ( left && tok_is_specifier(currtok) )
{ {
Specifier spec = strc_to_specifier( tok_to_str(currtok) ); Specifier spec = str_to_specifier( tok_to_str(currtok) );
b32 ignore_spec = false; b32 ignore_spec = false;
@ -59,8 +57,8 @@ CodeConstructor parse_constructor( StrC def )
break; break;
default : default :
log_failure( "Invalid specifier %s for variable\n%s", spec_to_str( spec ), parser_to_string(Context) ); log_failure( "Invalid specifier %s for variable\n%S", spec_to_str( spec ), parser_to_strbuilder(_ctx->parser) );
parser_pop(& Context); parser_pop(& _ctx->parser);
return InvalidCode; return InvalidCode;
} }
@ -79,14 +77,13 @@ CodeConstructor parse_constructor( StrC def )
// <specifiers> ... // <specifiers> ...
} }
Context.Tokens = toks; _ctx->parser.Tokens = toks;
CodeConstructor result = parser_parse_constructor( specifiers ); CodeConstructor result = parser_parse_constructor( specifiers );
return result; return result;
} }
CodeDestructor parse_destructor( StrC def ) CodeDestructor parse_destructor( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
@ -96,225 +93,209 @@ CodeDestructor parse_destructor( StrC def )
// TODO(Ed): Destructors can have prefix attributes // TODO(Ed): Destructors can have prefix attributes
// TODO(Ed): Destructors can have virtual // TODO(Ed): Destructors can have virtual
Context.Tokens = toks; _ctx->parser.Tokens = toks;
CodeDestructor result = parser_parse_destructor(NullCode); CodeDestructor result = parser_parse_destructor(NullCode);
return result; return result;
} }
CodeEnum parse_enum( StrC def ) CodeEnum parse_enum( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
{ {
parser_pop(& Context); parser_pop(& _ctx->parser);
return InvalidCode; return InvalidCode;
} }
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return parser_parse_enum( parser_not_inplace_def); return parser_parse_enum( parser_not_inplace_def);
} }
CodeBody parse_export_body( StrC def ) CodeBody parse_export_body( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return parser_parse_export_body(); return parser_parse_export_body();
} }
CodeExtern parse_extern_link( StrC def ) CodeExtern parse_extern_link( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return parser_parse_extern_link(); return parser_parse_extern_link();
} }
CodeFriend parse_friend( StrC def ) CodeFriend parse_friend( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return parser_parse_friend(); return parser_parse_friend();
} }
CodeFn parse_function( StrC def ) CodeFn parse_function( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return (CodeFn) parser_parse_function(); return (CodeFn) parser_parse_function();
} }
CodeBody parse_global_body( StrC def ) CodeBody parse_global_body( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
push_scope(); push_scope();
CodeBody result = parse_global_nspace( CT_Global_Body ); CodeBody result = parse_global_nspace( CT_Global_Body );
parser_pop(& Context); parser_pop(& _ctx->parser);
return result; return result;
} }
CodeNS parse_namespace( StrC def ) CodeNS parse_namespace( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return parser_parse_namespace(); return parser_parse_namespace();
} }
CodeOperator parse_operator( StrC def ) CodeOperator parse_operator( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return (CodeOperator) parser_parse_operator(); return (CodeOperator) parser_parse_operator();
} }
CodeOpCast parse_operator_cast( StrC def ) CodeOpCast parse_operator_cast( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return parser_parse_operator_cast(NullCode); return parser_parse_operator_cast(NullCode);
} }
CodeStruct parse_struct( StrC def ) CodeStruct parse_struct( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
push_scope(); push_scope();
CodeStruct result = (CodeStruct) parse_class_struct( Tok_Decl_Struct, parser_not_inplace_def ); CodeStruct result = (CodeStruct) parse_class_struct( Tok_Decl_Struct, parser_not_inplace_def );
parser_pop(& Context); parser_pop(& _ctx->parser);
return result; return result;
} }
CodeTemplate parse_template( StrC def ) CodeTemplate parse_template( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return parser_parse_template(); return parser_parse_template();
} }
CodeTypename parse_type( StrC def ) CodeTypename parse_type( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return parser_parse_type( parser_not_from_template, nullptr); return parser_parse_type( parser_not_from_template, nullptr);
} }
CodeTypedef parse_typedef( StrC def ) CodeTypedef parse_typedef( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return parser_parse_typedef(); return parser_parse_typedef();
} }
CodeUnion parse_union( StrC def ) CodeUnion parse_union( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return parser_parse_union( parser_not_inplace_def); return parser_parse_union( parser_not_inplace_def);
} }
CodeUsing parse_using( StrC def ) CodeUsing parse_using( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return parser_parse_using(); return parser_parse_using();
} }
CodeVar parse_variable( StrC def ) CodeVar parse_variable( Str def )
{ {
GEN_USING_NS_PARSER;
check_parse_args( def ); check_parse_args( def );
TokArray toks = lex( def ); TokArray toks = lex( def );
if ( toks.Arr == nullptr ) if ( toks.Arr == nullptr )
return InvalidCode; return InvalidCode;
Context.Tokens = toks; _ctx->parser.Tokens = toks;
return parser_parse_variable(); return parser_parse_variable();
} }

View File

@ -8,23 +8,20 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
char const* buf_begin = buf; char const* buf_begin = buf;
ssize remaining = buf_size; ssize remaining = buf_size;
local_persist local_persist StringTable tok_map;
TokenMap_FixedArena tok_map_arena; do_once() {
fixed_arena_init( & tok_map_arena); tok_map = hashtable_init(Str, _ctx->Allocator_DyanmicContainers );
}
local_persist // Populate token pairs
StringTable tok_map;
{ {
tok_map = hashtable_init(StrC, fixed_arena_allocator_info(& tok_map_arena) );
s32 left = num_tokens - 1; s32 left = num_tokens - 1;
while ( left-- ) while ( left-- )
{ {
char const* token = va_arg( va, char const* ); char const* token = va_arg( va, char const* );
StrC value = va_arg( va, StrC ); Str value = va_arg( va, Str );
u32 key = crc32( token, str_len(token) ); u32 key = crc32( token, c_str_len(token) );
hashtable_set( tok_map, key, value ); hashtable_set( tok_map, key, value );
} }
} }
@ -61,7 +58,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
char const* token = fmt + 1; char const* token = fmt + 1;
u32 key = crc32( token, tok_len ); u32 key = crc32( token, tok_len );
StrC* value = hashtable_get(tok_map, key ); Str* value = hashtable_get(tok_map, key );
if ( value ) if ( value )
{ {
@ -90,16 +87,12 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
current = * fmt; current = * fmt;
} }
} }
hashtable_clear(tok_map); hashtable_clear(tok_map);
fixed_arena_free(& tok_map_arena);
ssize result = buf_size - remaining; ssize result = buf_size - remaining;
return result; return result;
} }
Code untyped_str( StrC content ) Code untyped_str( Str content )
{ {
if ( content.Len == 0 ) if ( content.Len == 0 )
{ {
@ -109,7 +102,7 @@ Code untyped_str( StrC content )
Code Code
result = make_code(); result = make_code();
result->Name = get_cached_string( content ); result->Name = cache_str( content );
result->Type = CT_Untyped; result->Type = CT_Untyped;
result->Content = result->Name; result->Content = result->Name;
@ -135,17 +128,14 @@ Code untyped_fmt( char const* fmt, ...)
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
ssize length = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va); ssize length = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va);
va_end(va); va_end(va);
Str content = { buf, length };
StrC buf_str = { str_len_capped(fmt, MaxNameLength), fmt };
StrC uncapped_str = { length, buf };
Code Code
result = make_code(); result = make_code();
result->Name = get_cached_string( buf_str );
result->Type = CT_Untyped; result->Type = CT_Untyped;
result->Content = get_cached_string( uncapped_str ); result->Content = cache_str( content );
if ( result->Name.Len == 0 ) if ( result->Name.Len == 0 )
{ {
@ -172,13 +162,12 @@ Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... )
ssize length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va); ssize length = token_fmt_va(buf, GEN_PRINTF_MAXLEN, num_tokens, va);
va_end(va); va_end(va);
StrC buf_str = { length, buf }; Str buf_str = { buf, length };
Code Code
result = make_code(); result = make_code();
result->Name = get_cached_string( buf_str );
result->Type = CT_Untyped; result->Type = CT_Untyped;
result->Content = result->Name; result->Content = cache_str( buf_str );
if ( result->Name.Len == 0 ) if ( result->Name.Len == 0 )
{ {

View File

@ -373,7 +373,7 @@ OpValidateResult operator__validate( Operator op, CodeParams params_code, CodeTy
} }
forceinline forceinline
bool name__check( char const* context, StrC name ) bool name__check( char const* context, Str name )
{ {
if ( name.Len <= 0 ) { if ( name.Len <= 0 ) {
log_failure( "gen::%s: Invalid name length provided - %d", name.Len ); log_failure( "gen::%s: Invalid name length provided - %d", name.Len );
@ -409,7 +409,7 @@ identify the issue without having to debug too much (at least they can debug tho
The largest of the functions is related to operator overload definitions. The largest of the functions is related to operator overload definitions.
The library validates a good protion of their form and thus the argument processing for is quite a bit. The library validates a good protion of their form and thus the argument processing for is quite a bit.
*/ */
CodeAttributes def_attributes( StrC content ) CodeAttributes def_attributes( Str content )
{ {
if ( content.Len <= 0 || content.Ptr == nullptr ) { if ( content.Len <= 0 || content.Ptr == nullptr ) {
log_failure( "gen::def_attributes: Invalid attributes provided" ); log_failure( "gen::def_attributes: Invalid attributes provided" );
@ -419,12 +419,12 @@ CodeAttributes def_attributes( StrC content )
Code Code
result = make_code(); result = make_code();
result->Type = CT_PlatformAttributes; result->Type = CT_PlatformAttributes;
result->Name = get_cached_string( content ); result->Name = cache_str( content );
result->Content = result->Name; result->Content = result->Name;
return (CodeAttributes) result; return (CodeAttributes) result;
} }
CodeComment def_comment( StrC content ) CodeComment def_comment( Str content )
{ {
if ( content.Len <= 0 || content.Ptr == nullptr ) if ( content.Len <= 0 || content.Ptr == nullptr )
{ {
@ -433,9 +433,7 @@ CodeComment def_comment( StrC content )
return InvalidCode; return InvalidCode;
} }
static char line[ MaxCommentLineLength ]; StrBuilder cmt_formatted = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
String cmt_formatted = string_make_reserve( GlobalAllocator, kilobytes(1) );
char const* end = content.Ptr + content.Len; char const* end = content.Ptr + content.Len;
char const* scanner = content.Ptr; char const* scanner = content.Ptr;
s32 curr = 0; s32 curr = 0;
@ -450,26 +448,23 @@ CodeComment def_comment( StrC content )
} }
length++; length++;
str_copy( line, scanner, length ); strbuilder_append_fmt(& cmt_formatted, "//%.*s", length, scanner );
string_append_fmt(& cmt_formatted, "//%.*s", length, line );
mem_set( line, 0, MaxCommentLineLength );
scanner += length; scanner += length;
} }
while ( scanner <= end ); while ( scanner <= end );
if ( * string_back(cmt_formatted) != '\n' ) if ( * strbuilder_back(cmt_formatted) != '\n' )
string_append_strc( & cmt_formatted, txt("\n") ); strbuilder_append_str( & cmt_formatted, txt("\n") );
StrC name = { string_length(cmt_formatted), cmt_formatted }; Str name = strbuilder_to_str(cmt_formatted);
Code Code
result = make_code(); result = make_code();
result->Type = CT_Comment; result->Type = CT_Comment;
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->Content = result->Name; result->Content = result->Name;
string_free(& cmt_formatted); strbuilder_free(& cmt_formatted);
return (CodeComment) result; return (CodeComment) result;
} }
@ -511,7 +506,7 @@ CodeConstructor def_constructor( Opts_def_constructor p )
return result; return result;
} }
CodeClass def_class( StrC name, Opts_def_struct p ) CodeClass def_class( Str name, Opts_def_struct p )
{ {
if ( ! name_check( def_class, name ) ) { if ( ! name_check( def_class, name ) ) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -531,7 +526,7 @@ CodeClass def_class( StrC name, Opts_def_struct p )
CodeClass CodeClass
result = (CodeClass) make_code(); result = (CodeClass) make_code();
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->ModuleFlags = p.mflags; result->ModuleFlags = p.mflags;
if ( p.body ) if ( p.body )
{ {
@ -564,7 +559,7 @@ CodeClass def_class( StrC name, Opts_def_struct p )
return result; return result;
} }
CodeDefine def_define( StrC name, StrC content, Opts_def_define p ) CodeDefine def_define( Str name, Str content, Opts_def_define p )
{ {
if ( ! name_check( def_define, name ) ) { if ( ! name_check( def_define, name ) ) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -574,12 +569,12 @@ CodeDefine def_define( StrC name, StrC content, Opts_def_define p )
CodeDefine CodeDefine
result = (CodeDefine) make_code(); result = (CodeDefine) make_code();
result->Type = CT_Preprocess_Define; result->Type = CT_Preprocess_Define;
result->Name = get_cached_string( name ); result->Name = cache_str( name );
if ( content.Len <= 0 || content.Ptr == nullptr ) if ( content.Len <= 0 || content.Ptr == nullptr )
result->Content = get_cached_string( txt("") ); result->Content = cache_str( txt("") );
else else
result->Content = get_cached_string( string_to_strc(string_fmt_buf(GlobalAllocator, "%SC\n", content)) ); result->Content = cache_str( strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%S\n", content)) );
b32 append_preprocess_defines = ! p.dont_append_preprocess_defines; b32 append_preprocess_defines = ! p.dont_append_preprocess_defines;
if ( append_preprocess_defines ) { if ( append_preprocess_defines ) {
@ -589,8 +584,8 @@ CodeDefine def_define( StrC name, StrC content, Opts_def_define p )
if ( result->Name.Ptr[lex_id_len] == '(' ) if ( result->Name.Ptr[lex_id_len] == '(' )
break; break;
} }
StrC lex_id = { lex_id_len, result->Name.Ptr }; Str lex_id = { result->Name.Ptr, lex_id_len };
array_append(PreprocessorDefines, lex_id ); array_append(_ctx->PreprocessorDefines, cache_str(lex_id) );
} }
return result; return result;
} }
@ -629,7 +624,7 @@ CodeDestructor def_destructor( Opts_def_destructor p )
return result; return result;
} }
CodeEnum def_enum( StrC name, Opts_def_enum p ) CodeEnum def_enum( Str name, Opts_def_enum p )
{ {
if ( ! name_check( def_enum, name ) ) { if ( ! name_check( def_enum, name ) ) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -648,7 +643,7 @@ CodeEnum def_enum( StrC name, Opts_def_enum p )
CodeEnum CodeEnum
result = (CodeEnum) make_code(); result = (CodeEnum) make_code();
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->ModuleFlags = p.mflags; result->ModuleFlags = p.mflags;
if ( p.body ) if ( p.body )
{ {
@ -690,7 +685,7 @@ CodeEnum def_enum( StrC name, Opts_def_enum p )
return result; return result;
} }
CodeExec def_execution( StrC content ) CodeExec def_execution( Str content )
{ {
if ( content.Len <= 0 || content.Ptr == nullptr ) { if ( content.Len <= 0 || content.Ptr == nullptr ) {
log_failure( "gen::def_execution: Invalid execution provided" ); log_failure( "gen::def_execution: Invalid execution provided" );
@ -700,11 +695,11 @@ CodeExec def_execution( StrC content )
CodeExec CodeExec
result = (CodeExec) make_code(); result = (CodeExec) make_code();
result->Type = CT_Execution; result->Type = CT_Execution;
result->Content = get_cached_string( content ); result->Content = cache_str( content );
return result; return result;
} }
CodeExtern def_extern_link( StrC name, CodeBody body ) CodeExtern def_extern_link( Str name, CodeBody body )
{ {
if ( ! name_check(def_extern_link, name) || ! null_check(def_extern_link, body) ) { if ( ! name_check(def_extern_link, name) || ! null_check(def_extern_link, body) ) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -718,7 +713,7 @@ CodeExtern def_extern_link( StrC name, CodeBody body )
CodeExtern CodeExtern
result = (CodeExtern)make_code(); result = (CodeExtern)make_code();
result->Type = CT_Extern_Linkage; result->Type = CT_Extern_Linkage;
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->Body = body; result->Body = body;
return result; return result;
} }
@ -752,7 +747,7 @@ CodeFriend def_friend( Code declaration )
return result; return result;
} }
CodeFn def_function( StrC name, Opts_def_function p ) CodeFn def_function( Str name, Opts_def_function p )
{ {
if ( ! name_check( def_function, name )) { if ( ! name_check( def_function, name )) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -781,7 +776,7 @@ CodeFn def_function( StrC name, Opts_def_function p )
CodeFn CodeFn
result = (CodeFn) make_code(); result = (CodeFn) make_code();
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->ModuleFlags = p.mflags; result->ModuleFlags = p.mflags;
if ( p.body ) if ( p.body )
{ {
@ -812,26 +807,26 @@ CodeFn def_function( StrC name, Opts_def_function p )
return result; return result;
} }
CodeInclude def_include( StrC path, Opts_def_include p ) CodeInclude def_include( Str path, Opts_def_include p )
{ {
if ( path.Len <= 0 || path.Ptr == nullptr ) { if ( path.Len <= 0 || path.Ptr == nullptr ) {
log_failure( "gen::def_include: Invalid path provided - %d" ); log_failure( "gen::def_include: Invalid path provided - %d" );
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
return InvalidCode; return InvalidCode;
} }
String content = p.foreign ? StrBuilder content = p.foreign ?
string_fmt_buf( GlobalAllocator, "<%.*s>", path.Len, path.Ptr ) strbuilder_fmt_buf( _ctx->Allocator_Temp, "<%.*s>", path.Len, path.Ptr )
: string_fmt_buf( GlobalAllocator, "\"%.*s\"", path.Len, path.Ptr ); : strbuilder_fmt_buf( _ctx->Allocator_Temp, "\"%.*s\"", path.Len, path.Ptr );
CodeInclude CodeInclude
result = (CodeInclude) make_code(); result = (CodeInclude) make_code();
result->Type = CT_Preprocess_Include; result->Type = CT_Preprocess_Include;
result->Name = get_cached_string( string_to_strc(content) ); result->Name = cache_str( strbuilder_to_str(content) );
result->Content = result->Name; result->Content = result->Name;
return result; return result;
} }
CodeModule def_module( StrC name, Opts_def_module p ) CodeModule def_module( Str name, Opts_def_module p )
{ {
if ( ! name_check( def_module, name )) { if ( ! name_check( def_module, name )) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -840,12 +835,12 @@ CodeModule def_module( StrC name, Opts_def_module p )
CodeModule CodeModule
result = (CodeModule) make_code(); result = (CodeModule) make_code();
result->Type = CT_Module; result->Type = CT_Module;
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->ModuleFlags = p.mflags; result->ModuleFlags = p.mflags;
return result; return result;
} }
CodeNS def_namespace( StrC name, CodeBody body, Opts_def_namespace p ) CodeNS def_namespace( Str name, CodeBody body, Opts_def_namespace p )
{ {
if ( ! name_check( def_namespace, name )) { if ( ! name_check( def_namespace, name )) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -863,13 +858,13 @@ CodeNS def_namespace( StrC name, CodeBody body, Opts_def_namespace p )
CodeNS CodeNS
result = (CodeNS) make_code(); result = (CodeNS) make_code();
result->Type = CT_Namespace; result->Type = CT_Namespace;
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->ModuleFlags = p.mflags; result->ModuleFlags = p.mflags;
result->Body = body; result->Body = body;
return result; return result;
} }
CodeOperator def_operator( Operator op, StrC nspace, Opts_def_operator p ) CodeOperator def_operator( Operator op, Str nspace, Opts_def_operator p )
{ {
if ( p.attributes && p.attributes->Type != CT_PlatformAttributes ) { if ( p.attributes && p.attributes->Type != CT_PlatformAttributes ) {
log_failure( "gen::def_operator: PlatformAttributes was provided but its not of attributes type: %s", code_debug_str(p.attributes) ); log_failure( "gen::def_operator: PlatformAttributes was provided but its not of attributes type: %s", code_debug_str(p.attributes) );
@ -889,17 +884,17 @@ CodeOperator def_operator( Operator op, StrC nspace, Opts_def_operator p )
char const* name = nullptr; char const* name = nullptr;
StrC op_str = operator_to_str( op ); Str op_str = operator_to_str( op );
if ( nspace.Len > 0 ) if ( nspace.Len > 0 )
name = str_fmt_buf( "%.*soperator %.*s", nspace.Len, nspace.Ptr, op_str.Len, op_str.Ptr ); name = c_str_fmt_buf( "%.*soperator %.*s", nspace.Len, nspace.Ptr, op_str.Len, op_str.Ptr );
else else
name = str_fmt_buf( "operator %.*s", op_str.Len, op_str.Ptr ); name = c_str_fmt_buf( "operator %.*s", op_str.Len, op_str.Ptr );
StrC name_resolved = { str_len(name), name }; Str name_resolved = { name, c_str_len(name) };
CodeOperator CodeOperator
result = (CodeOperator) make_code(); result = (CodeOperator) make_code();
result->Name = get_cached_string( name_resolved ); result->Name = cache_str( name_resolved );
result->ModuleFlags = p.mflags; result->ModuleFlags = p.mflags;
result->Op = op; result->Op = op;
if ( p.body ) if ( p.body )
@ -969,7 +964,7 @@ CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast p )
return result; return result;
} }
CodeParams def_param( CodeTypename type, StrC name, Opts_def_param p ) CodeParams def_param( CodeTypename type, Str name, Opts_def_param p )
{ {
if ( ! name_check( def_param, name ) || ! null_check( def_param, type ) ) { if ( ! name_check( def_param, name ) || ! null_check( def_param, type ) ) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -986,14 +981,14 @@ CodeParams def_param( CodeTypename type, StrC name, Opts_def_param p )
CodeParams CodeParams
result = (CodeParams) make_code(); result = (CodeParams) make_code();
result->Type = CT_Parameters; result->Type = CT_Parameters;
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->ValueType = type; result->ValueType = type;
result->Value = p.value; result->Value = p.value;
result->NumEntries++; result->NumEntries++;
return result; return result;
} }
CodePragma def_pragma( StrC directive ) CodePragma def_pragma( Str directive )
{ {
if ( directive.Len <= 0 || directive.Ptr == nullptr ) { if ( directive.Len <= 0 || directive.Ptr == nullptr ) {
log_failure( "gen::def_comment: Invalid comment provided:" ); log_failure( "gen::def_comment: Invalid comment provided:" );
@ -1003,11 +998,11 @@ CodePragma def_pragma( StrC directive )
CodePragma CodePragma
result = (CodePragma) make_code(); result = (CodePragma) make_code();
result->Type = CT_Preprocess_Pragma; result->Type = CT_Preprocess_Pragma;
result->Content = get_cached_string( directive ); result->Content = cache_str( directive );
return result; return result;
} }
CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC expr ) CodePreprocessCond def_preprocess_cond( EPreprocessCond type, Str expr )
{ {
if ( expr.Len <= 0 || expr.Ptr == nullptr ) { if ( expr.Len <= 0 || expr.Ptr == nullptr ) {
log_failure( "gen::def_comment: Invalid comment provided:" ); log_failure( "gen::def_comment: Invalid comment provided:" );
@ -1016,7 +1011,7 @@ CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC expr )
} }
CodePreprocessCond CodePreprocessCond
result = (CodePreprocessCond) make_code(); result = (CodePreprocessCond) make_code();
result->Content = get_cached_string( expr ); result->Content = cache_str( expr );
switch (type) switch (type)
{ {
case PreprocessCond_If: case PreprocessCond_If:
@ -1044,7 +1039,7 @@ CodeSpecifiers def_specifier( Specifier spec )
return result; return result;
} }
CodeStruct def_struct( StrC name, Opts_def_struct p ) CodeStruct def_struct( Str name, Opts_def_struct p )
{ {
if ( p.attributes && p.attributes->Type != CT_PlatformAttributes ) { if ( p.attributes && p.attributes->Type != CT_PlatformAttributes ) {
log_failure( "gen::def_struct: attributes was not a `PlatformAttributes` type - %s", code_debug_str(cast(Code, p.attributes)) ); log_failure( "gen::def_struct: attributes was not a `PlatformAttributes` type - %s", code_debug_str(cast(Code, p.attributes)) );
@ -1066,7 +1061,7 @@ CodeStruct def_struct( StrC name, Opts_def_struct p )
result = (CodeStruct) make_code(); result = (CodeStruct) make_code();
result->ModuleFlags = p.mflags; result->ModuleFlags = p.mflags;
if ( name.Len ) if ( name.Len )
result->Name = get_cached_string( name ); result->Name = cache_str( name );
if ( p.body ) { if ( p.body ) {
result->Type = CT_Struct; result->Type = CT_Struct;
@ -1117,7 +1112,7 @@ CodeTemplate def_template( CodeParams params, Code declaration, Opts_def_templat
return result; return result;
} }
CodeTypename def_type( StrC name, Opts_def_type p ) CodeTypename def_type( Str name, Opts_def_type p )
{ {
if ( ! name_check( def_type, name )) { if ( ! name_check( def_type, name )) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -1143,7 +1138,7 @@ CodeTypename def_type( StrC name, Opts_def_type p )
} }
CodeTypename CodeTypename
result = (CodeTypename) make_code(); result = (CodeTypename) make_code();
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->Type = CT_Typename; result->Type = CT_Typename;
result->Attributes = p.attributes; result->Attributes = p.attributes;
result->Specs = p.specifiers; result->Specs = p.specifiers;
@ -1152,7 +1147,7 @@ CodeTypename def_type( StrC name, Opts_def_type p )
return result; return result;
} }
CodeTypedef def_typedef( StrC name, Code type, Opts_def_typedef p ) CodeTypedef def_typedef( Str name, Code type, Opts_def_typedef p )
{ {
if ( ! null_check( def_typedef, type ) ) { if ( ! null_check( def_typedef, type ) ) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -1204,18 +1199,18 @@ CodeTypedef def_typedef( StrC name, Code type, Opts_def_typedef p )
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
return InvalidCode; return InvalidCode;
} }
result->Name = get_cached_string( type->Name ); result->Name = cache_str( type->Name );
result->IsFunction = true; result->IsFunction = true;
} }
else else
{ {
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->IsFunction = false; result->IsFunction = false;
} }
return result; return result;
} }
CodeUnion def_union( StrC name, CodeBody body, Opts_def_union p ) CodeUnion def_union( Str name, CodeBody body, Opts_def_union p )
{ {
if ( ! null_check( def_union, body ) ) { if ( ! null_check( def_union, body ) ) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -1238,11 +1233,11 @@ CodeUnion def_union( StrC name, CodeBody body, Opts_def_union p )
result->Body = body; result->Body = body;
result->Attributes = p.attributes; result->Attributes = p.attributes;
if ( name.Ptr ) if ( name.Ptr )
result->Name = get_cached_string( name ); result->Name = cache_str( name );
return result; return result;
} }
CodeUsing def_using( StrC name, CodeTypename type, Opts_def_using p ) CodeUsing def_using( Str name, CodeTypename type, Opts_def_using p )
{ {
if ( ! name_check( def_using, name ) || null_check( def_using, type ) ) { if ( ! name_check( def_using, name ) || null_check( def_using, type ) ) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -1262,7 +1257,7 @@ CodeUsing def_using( StrC name, CodeTypename type, Opts_def_using p )
} }
CodeUsing CodeUsing
result = (CodeUsing) make_code(); result = (CodeUsing) make_code();
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->ModuleFlags = p.mflags; result->ModuleFlags = p.mflags;
result->Type = CT_Using; result->Type = CT_Using;
result->UnderlyingType = type; result->UnderlyingType = type;
@ -1270,7 +1265,7 @@ CodeUsing def_using( StrC name, CodeTypename type, Opts_def_using p )
return result; return result;
} }
CodeUsing def_using_namespace( StrC name ) CodeUsing def_using_namespace( Str name )
{ {
if ( ! name_check( def_using_namespace, name ) ) { if ( ! name_check( def_using_namespace, name ) ) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -1278,12 +1273,12 @@ CodeUsing def_using_namespace( StrC name )
} }
CodeUsing CodeUsing
result = (CodeUsing) make_code(); result = (CodeUsing) make_code();
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->Type = CT_Using_Namespace; result->Type = CT_Using_Namespace;
return result; return result;
} }
CodeVar def_variable( CodeTypename type, StrC name, Opts_def_variable p ) CodeVar def_variable( CodeTypename type, Str name, Opts_def_variable p )
{ {
if ( ! name_check( def_variable, name ) || null_check( def_variable, type ) ) { if ( ! name_check( def_variable, name ) || null_check( def_variable, type ) ) {
GEN_DEBUG_TRAP(); GEN_DEBUG_TRAP();
@ -1311,7 +1306,7 @@ CodeVar def_variable( CodeTypename type, StrC name, Opts_def_variable p )
} }
CodeVar CodeVar
result = (CodeVar) make_code(); result = (CodeVar) make_code();
result->Name = get_cached_string( name ); result->Name = cache_str( name );
result->Type = CT_Variable; result->Type = CT_Variable;
result->ModuleFlags = p.mflags; result->ModuleFlags = p.mflags;
result->ValueType = type; result->ValueType = type;
@ -1357,15 +1352,12 @@ CodeBody def_class_body( s32 num, ... )
{ {
Code_POD pod = va_arg(va, Code_POD); Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod); Code entry = pcast(Code, pod);
if ( ! entry) {
if (!entry)
{
log_failure("gen::" log_failure("gen::"
"def_class_body" "def_class_body"
": Provided an null entry"); ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
GEN_AST_BODY_CLASS_UNALLOWED_TYPES: GEN_AST_BODY_CLASS_UNALLOWED_TYPES:
@ -1375,7 +1367,6 @@ CodeBody def_class_body( s32 num, ... )
default: default:
break; break;
} }
body_append(result, entry); body_append(result, entry);
} }
while (num--, num > 0); while (num--, num > 0);
@ -1391,18 +1382,14 @@ CodeBody def_class_body( s32 num, Code* codes )
CodeBody CodeBody
result = (CodeBody) make_code(); result = (CodeBody) make_code();
result->Type = CT_Function_Body; result->Type = CT_Function_Body;
do do
{ {
Code entry = *codes; Code entry = *codes;
codes++; codes++;
if ( ! entry) {
if (!entry)
{
log_failure("gen::" "def_class_body" ": Provided an null entry"); log_failure("gen::" "def_class_body" ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
GEN_AST_BODY_CLASS_UNALLOWED_TYPES: GEN_AST_BODY_CLASS_UNALLOWED_TYPES:
@ -1412,7 +1399,6 @@ CodeBody def_class_body( s32 num, Code* codes )
default: default:
break; break;
} }
body_append(result, entry); body_append(result, entry);
} }
while (num--, num > 0); while (num--, num > 0);
@ -1434,19 +1420,14 @@ CodeBody def_enum_body( s32 num, ... )
{ {
Code_POD pod = va_arg(va, Code_POD); Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod); Code entry = pcast(Code, pod);
if ( ! entry ) {
if ( ! entry )
{
log_failure("gen::def_enum_body: Provided a null entry"); log_failure("gen::def_enum_body: Provided a null entry");
return InvalidCode; return InvalidCode;
} }
if ( entry->Type != CT_Untyped && entry->Type != CT_Comment ) {
if ( entry->Type != CT_Untyped && entry->Type != CT_Comment )
{
log_failure("gen::def_enum_body: Entry type is not allowed - %s. Must be of untyped or comment type.", code_debug_str(entry) ); log_failure("gen::def_enum_body: Entry type is not allowed - %s. Must be of untyped or comment type.", code_debug_str(entry) );
return InvalidCode; return InvalidCode;
} }
body_append(result, entry ); body_append(result, entry );
} }
while ( num--, num > 0 ); while ( num--, num > 0 );
@ -1462,23 +1443,17 @@ CodeBody def_enum_body( s32 num, Code* codes )
CodeBody CodeBody
result = (CodeBody) make_code(); result = (CodeBody) make_code();
result->Type = CT_Enum_Body; result->Type = CT_Enum_Body;
do do
{ {
Code entry = *codes; Code entry = *codes;
if ( ! entry ) {
if ( ! entry )
{
log_failure("gen::def_enum_body: Provided a null entry"); log_failure("gen::def_enum_body: Provided a null entry");
return InvalidCode; return InvalidCode;
} }
if ( entry->Type != CT_Untyped && entry->Type != CT_Comment ) {
if ( entry->Type != CT_Untyped && entry->Type != CT_Comment )
{
log_failure("gen::def_enum_body: Entry type is not allowed: %s", code_debug_str(entry) ); log_failure("gen::def_enum_body: Entry type is not allowed: %s", code_debug_str(entry) );
return InvalidCode; return InvalidCode;
} }
body_append(result, entry ); body_append(result, entry );
} }
while ( codes++, num--, num > 0 ); while ( codes++, num--, num > 0 );
@ -1500,13 +1475,11 @@ CodeBody def_export_body( s32 num, ... )
{ {
Code_POD pod = va_arg(va, Code_POD); Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod); Code entry = pcast(Code, pod);
if ( ! entry)
if (!entry)
{ {
log_failure("gen::" "def_export_body" ": Provided an null entry"); log_failure("gen::" "def_export_body" ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
GEN_AST_BODY_EXPORT_UNALLOWED_TYPES: GEN_AST_BODY_EXPORT_UNALLOWED_TYPES:
@ -1516,7 +1489,6 @@ CodeBody def_export_body( s32 num, ... )
default: default:
break; break;
} }
body_append(result, entry); body_append(result, entry);
} }
while (num--, num > 0); while (num--, num > 0);
@ -1532,18 +1504,14 @@ CodeBody def_export_body( s32 num, Code* codes )
CodeBody CodeBody
result = (CodeBody) make_code(); result = (CodeBody) make_code();
result->Type = CT_Export_Body; result->Type = CT_Export_Body;
do do
{ {
Code entry = *codes; Code entry = *codes;
codes++; codes++;
if ( ! entry) {
if (!entry)
{
log_failure("gen::" "def_export_body" ": Provided an null entry"); log_failure("gen::" "def_export_body" ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
GEN_AST_BODY_EXPORT_UNALLOWED_TYPES: GEN_AST_BODY_EXPORT_UNALLOWED_TYPES:
@ -1553,7 +1521,6 @@ CodeBody def_export_body( s32 num, Code* codes )
default: default:
break; break;
} }
body_append(result, entry); body_append(result, entry);
} }
while (num--, num > 0); while (num--, num > 0);
@ -1575,13 +1542,10 @@ CodeBody def_extern_link_body( s32 num, ... )
{ {
Code_POD pod = va_arg(va, Code_POD); Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod); Code entry = pcast(Code, pod);
if ( ! entry) {
if (!entry)
{
log_failure("gen::" "def_extern_linkage_body" ": Provided an null entry"); log_failure("gen::" "def_extern_linkage_body" ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES: GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES:
@ -1591,7 +1555,6 @@ CodeBody def_extern_link_body( s32 num, ... )
default: default:
break; break;
} }
body_append(result, entry); body_append(result, entry);
} }
while (num--, num > 0); while (num--, num > 0);
@ -1607,18 +1570,15 @@ CodeBody def_extern_link_body( s32 num, Code* codes )
CodeBody CodeBody
result = (CodeBody) make_code(); result = (CodeBody) make_code();
result->Type = CT_Extern_Linkage_Body; result->Type = CT_Extern_Linkage_Body;
do do
{ {
Code entry = *codes; Code entry = *codes;
codes++; codes++;
if (!entry) if (!entry)
{ {
log_failure("gen::" "def_extern_linkage_body" ": Provided an null entry"); log_failure("gen::" "def_extern_linkage_body" ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES: GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES:
@ -1628,7 +1588,6 @@ CodeBody def_extern_link_body( s32 num, Code* codes )
default: default:
break; break;
} }
body_append(result, entry); body_append(result, entry);
} }
while (num--, num > 0); while (num--, num > 0);
@ -1650,16 +1609,12 @@ CodeBody def_function_body( s32 num, ... )
{ {
Code_POD pod = va_arg(va, Code_POD); Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod); Code entry = pcast(Code, pod);
if ( ! entry) {
if (!entry)
{
log_failure("gen::" stringize(def_function_body) ": Provided an null entry"); log_failure("gen::" stringize(def_function_body) ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES: GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES:
log_failure("gen::" stringize(def_function_body) ": Entry type is not allowed: %s", code_debug_str(entry)); log_failure("gen::" stringize(def_function_body) ": Entry type is not allowed: %s", code_debug_str(entry));
return InvalidCode; return InvalidCode;
@ -1667,7 +1622,6 @@ CodeBody def_function_body( s32 num, ... )
default: default:
break; break;
} }
body_append(result, entry); body_append(result, entry);
} }
while (num--, num > 0); while (num--, num > 0);
@ -1683,18 +1637,14 @@ CodeBody def_function_body( s32 num, Code* codes )
CodeBody CodeBody
result = (CodeBody) make_code(); result = (CodeBody) make_code();
result->Type = CT_Function_Body; result->Type = CT_Function_Body;
do do
{ {
Code entry = *codes; Code entry = *codes;
codes++; codes++;
if (!entry) {
if (!entry)
{
log_failure("gen::" "def_function_body" ": Provided an null entry"); log_failure("gen::" "def_function_body" ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES: GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES:
@ -1725,13 +1675,10 @@ CodeBody def_global_body( s32 num, ... )
{ {
Code_POD pod = va_arg(va, Code_POD); Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod); Code entry = pcast(Code, pod);
if ( ! entry) {
if (!entry)
{
log_failure("gen::" "def_global_body" ": Provided an null entry"); log_failure("gen::" "def_global_body" ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
case CT_Global_Body: case CT_Global_Body:
@ -1746,7 +1693,6 @@ CodeBody def_global_body( s32 num, ... )
default: default:
break; break;
} }
body_append(result, entry); body_append(result, entry);
} }
while (num--, num > 0); while (num--, num > 0);
@ -1762,18 +1708,14 @@ CodeBody def_global_body( s32 num, Code* codes )
CodeBody CodeBody
result = (CodeBody) make_code(); result = (CodeBody) make_code();
result->Type = CT_Global_Body; result->Type = CT_Global_Body;
do do
{ {
Code entry = *codes; Code entry = *codes;
codes++; codes++;
if ( ! entry) {
if (!entry)
{
log_failure("gen::" "def_global_body" ": Provided an null entry"); log_failure("gen::" "def_global_body" ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
case CT_Global_Body: case CT_Global_Body:
@ -1809,13 +1751,10 @@ CodeBody def_namespace_body( s32 num, ... )
{ {
Code_POD pod = va_arg(va, Code_POD); Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod); Code entry = pcast(Code, pod);
if ( ! entry) {
if (!entry)
{
log_failure("gen::" "def_namespace_body" ": Provided an null entry"); log_failure("gen::" "def_namespace_body" ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES: GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES:
@ -1825,7 +1764,6 @@ CodeBody def_namespace_body( s32 num, ... )
default: default:
break; break;
} }
body_append(result, entry); body_append(result, entry);
} }
while (num--, num > 0); while (num--, num > 0);
@ -1841,18 +1779,14 @@ CodeBody def_namespace_body( s32 num, Code* codes )
CodeBody CodeBody
result = (CodeBody) make_code(); result = (CodeBody) make_code();
result->Type = CT_Global_Body; result->Type = CT_Global_Body;
do do
{ {
Code entry = *codes; Code entry = *codes;
codes++; codes++;
if ( ! entry) {
if (!entry)
{
log_failure("gen::" "def_namespace_body" ": Provided an null entry"); log_failure("gen::" "def_namespace_body" ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES: GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES:
@ -1861,7 +1795,6 @@ CodeBody def_namespace_body( s32 num, Code* codes )
default: break; default: break;
} }
body_append(result, entry); body_append(result, entry);
} }
while (num--, num > 0); while (num--, num > 0);
@ -1880,26 +1813,20 @@ CodeParams def_params( s32 num, ... )
CodeParams param = pcast( CodeParams, pod ); CodeParams param = pcast( CodeParams, pod );
null_check( def_params, param ); null_check( def_params, param );
if ( param->Type != CT_Parameters ) {
if ( param->Type != CT_Parameters )
{
log_failure( "gen::def_params: param %d is not a Parameters", num - num + 1 ); log_failure( "gen::def_params: param %d is not a Parameters", num - num + 1 );
return InvalidCode; return InvalidCode;
} }
CodeParams result = (CodeParams) code_duplicate(param); CodeParams result = (CodeParams) code_duplicate(param);
while ( -- num ) while ( -- num )
{ {
pod = va_arg(va, Code_POD); pod = va_arg(va, Code_POD);
param = pcast( CodeParams, pod ); param = pcast( CodeParams, pod );
if ( param->Type != CT_Parameters ) {
if ( param->Type != CT_Parameters )
{
log_failure( "gen::def_params: param %d is not a Parameters", num - num + 1 ); log_failure( "gen::def_params: param %d is not a Parameters", num - num + 1 );
return InvalidCode; return InvalidCode;
} }
params_append(result, param ); params_append(result, param );
} }
va_end(va); va_end(va);
@ -1912,18 +1839,14 @@ CodeParams def_params( s32 num, CodeParams* codes )
def_body_code_array_start( def_params ); def_body_code_array_start( def_params );
# define check_current(current) \ # define check_current(current) \
if ( current == nullptr ) \ if ( current == nullptr ) { \
{ \
log_failure("gen::def_params: Provide a null code in codes array"); \ log_failure("gen::def_params: Provide a null code in codes array"); \
return InvalidCode; \ return InvalidCode; \
} \ } \
\ if (current->Type != CT_Parameters ) { \
if (current->Type != CT_Parameters ) \
{ \
log_failure("gen::def_params: Code in coes array is not of paramter type - %s", code_debug_str(current) ); \ log_failure("gen::def_params: Code in coes array is not of paramter type - %s", code_debug_str(current) ); \
return InvalidCode; \ return InvalidCode; \
} }
CodeParams current = (CodeParams)code_duplicate(* codes); CodeParams current = (CodeParams)code_duplicate(* codes);
check_current(current); check_current(current);
@ -1932,9 +1855,7 @@ CodeParams def_params( s32 num, CodeParams* codes )
result->Name = current->Name; result->Name = current->Name;
result->Type = current->Type; result->Type = current->Type;
result->ValueType = current->ValueType; result->ValueType = current->ValueType;
while( codes++, current = * codes, num--, num > 0 ) {
while( codes++, current = * codes, num--, num > 0 )
{
check_current(current); check_current(current);
params_append(result, current ); params_append(result, current );
} }
@ -1945,28 +1866,22 @@ CodeParams def_params( s32 num, CodeParams* codes )
CodeSpecifiers def_specifiers( s32 num, ... ) CodeSpecifiers def_specifiers( s32 num, ... )
{ {
if ( num <= 0 ) if ( num <= 0 ) {
{
log_failure("gen::def_specifiers: num cannot be zero or less"); log_failure("gen::def_specifiers: num cannot be zero or less");
return InvalidCode; return InvalidCode;
} }
if ( num > AST_ArrSpecs_Cap ) {
if ( num > AST_ArrSpecs_Cap )
{
log_failure("gen::def_specifiers: num of speciifers to define AST larger than AST specicifier capacity - %d", num); log_failure("gen::def_specifiers: num of speciifers to define AST larger than AST specicifier capacity - %d", num);
return InvalidCode; return InvalidCode;
} }
CodeSpecifiers CodeSpecifiers
result = (CodeSpecifiers) make_code(); result = (CodeSpecifiers) make_code();
result->Type = CT_Specifiers; result->Type = CT_Specifiers;
va_list va; va_list va;
va_start(va, num); va_start(va, num);
do do {
{
Specifier type = (Specifier)va_arg(va, int); Specifier type = (Specifier)va_arg(va, int);
specifiers_append(result, type ); specifiers_append(result, type );
} }
while ( --num, num ); while ( --num, num );
@ -1977,25 +1892,20 @@ CodeSpecifiers def_specifiers( s32 num, ... )
CodeSpecifiers def_specifiers( s32 num, Specifier* specs ) CodeSpecifiers def_specifiers( s32 num, Specifier* specs )
{ {
if ( num <= 0 ) if ( num <= 0 ) {
{
log_failure("gen::def_specifiers: num cannot be zero or less"); log_failure("gen::def_specifiers: num cannot be zero or less");
return InvalidCode; return InvalidCode;
} }
if ( num > AST_ArrSpecs_Cap ) {
if ( num > AST_ArrSpecs_Cap )
{
log_failure("gen::def_specifiers: num of speciifers to define AST larger than AST specicifier capacity - %d", num); log_failure("gen::def_specifiers: num of speciifers to define AST larger than AST specicifier capacity - %d", num);
return InvalidCode; return InvalidCode;
} }
CodeSpecifiers CodeSpecifiers
result = (CodeSpecifiers) make_code(); result = (CodeSpecifiers) make_code();
result->Type = CT_Specifiers; result->Type = CT_Specifiers;
s32 idx = 0; s32 idx = 0;
do do {
{
specifiers_append(result, specs[idx] ); specifiers_append(result, specs[idx] );
idx++; idx++;
} }
@ -2018,13 +1928,10 @@ CodeBody def_struct_body( s32 num, ... )
{ {
Code_POD pod = va_arg(va, Code_POD); Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod); Code entry = pcast(Code, pod);
if ( ! entry) {
if (!entry)
{
log_failure("gen::" "def_struct_body" ": Provided an null entry"); log_failure("gen::" "def_struct_body" ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
GEN_AST_BODY_STRUCT_UNALLOWED_TYPES: GEN_AST_BODY_STRUCT_UNALLOWED_TYPES:
@ -2034,7 +1941,6 @@ CodeBody def_struct_body( s32 num, ... )
default: default:
break; break;
} }
body_append(result, entry); body_append(result, entry);
} }
while (num--, num > 0); while (num--, num > 0);
@ -2050,18 +1956,14 @@ CodeBody def_struct_body( s32 num, Code* codes )
CodeBody CodeBody
result = (CodeBody) make_code(); result = (CodeBody) make_code();
result->Type = CT_Struct_Body; result->Type = CT_Struct_Body;
do do
{ {
Code entry = *codes; Code entry = *codes;
codes++; codes++;
if ( ! entry) {
if (!entry)
{
log_failure("gen::" "def_struct_body" ": Provided an null entry"); log_failure("gen::" "def_struct_body" ": Provided an null entry");
return InvalidCode; return InvalidCode;
} }
switch (entry->Type) switch (entry->Type)
{ {
GEN_AST_BODY_STRUCT_UNALLOWED_TYPES: GEN_AST_BODY_STRUCT_UNALLOWED_TYPES:
@ -2071,7 +1973,6 @@ CodeBody def_struct_body( s32 num, Code* codes )
default: default:
break; break;
} }
body_append(result, entry); body_append(result, entry);
} }
while (num--, num > 0); while (num--, num > 0);
@ -2093,19 +1994,14 @@ CodeBody def_union_body( s32 num, ... )
{ {
Code_POD pod = va_arg(va, Code_POD); Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast( Code, pod ); Code entry = pcast( Code, pod );
if ( ! entry ) {
if ( ! entry )
{
log_failure("gen::def_union_body: Provided a null entry"); log_failure("gen::def_union_body: Provided a null entry");
return InvalidCode; return InvalidCode;
} }
if ( entry->Type != CT_Untyped && entry->Type != CT_Comment ) {
if ( entry->Type != CT_Untyped && entry->Type != CT_Comment )
{
log_failure("gen::def_union_body: Entry type is not allowed - %s. Must be of untyped or comment type.", code_debug_str(entry) ); log_failure("gen::def_union_body: Entry type is not allowed - %s. Must be of untyped or comment type.", code_debug_str(entry) );
return InvalidCode; return InvalidCode;
} }
body_append(result, entry ); body_append(result, entry );
} }
while ( num--, num > 0 ); while ( num--, num > 0 );
@ -2121,23 +2017,17 @@ CodeBody def_union_body( s32 num, Code* codes )
CodeBody CodeBody
result = (CodeBody) make_code(); result = (CodeBody) make_code();
result->Type = CT_Union_Body; result->Type = CT_Union_Body;
do do
{ {
Code entry = *codes; Code entry = *codes;
if ( ! entry ) {
if ( ! entry )
{
log_failure("gen::def_union_body: Provided a null entry"); log_failure("gen::def_union_body: Provided a null entry");
return InvalidCode; return InvalidCode;
} }
if ( entry->Type != CT_Untyped && entry->Type != CT_Comment ) {
if ( entry->Type != CT_Untyped && entry->Type != CT_Comment )
{
log_failure("gen::def_union_body: Entry type is not allowed: %s", code_debug_str(entry) ); log_failure("gen::def_union_body: Entry type is not allowed: %s", code_debug_str(entry) );
return InvalidCode; return InvalidCode;
} }
body_append(result, entry ); body_append(result, entry );
} }
while ( codes++, num--, num > 0 ); while ( codes++, num--, num > 0 );

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,125 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
#pragma once
#include "types.hpp"
#include "gen/ecode.hpp"
#include "gen/eoperator.hpp"
#include "gen/especifier.hpp"
#endif
enum TokFlags : u32
{
TF_Operator = bit(0),
TF_Assign = bit(1),
TF_Preprocess = bit(2),
TF_Preprocess_Cond = bit(3),
TF_Attribute = bit(6),
TF_AccessOperator = bit( 7 ),
TF_AccessSpecifier = bit( 8 ),
TF_Specifier = bit( 9 ),
TF_EndDefinition = bit( 10 ), // Either ; or }
TF_Formatting = bit( 11 ),
TF_Literal = bit( 12 ),
TF_Null = 0,
TF_UnderlyingType = GEN_U32_MAX,
};
struct Token
{
Str Text;
TokType Type;
s32 Line;
s32 Column;
u32 Flags;
};
constexpr Token NullToken { {}, Tok_Invalid, 0, 0, TF_Null };
forceinline
AccessSpec tok_to_access_specifier(Token tok) {
return scast(AccessSpec, tok.Type);
}
forceinline
Str tok_to_str(Token tok) {
return tok.Text;
}
forceinline
bool tok_is_valid( Token tok ) {
return tok.Text.Ptr && tok.Text.Len && tok.Type != Tok_Invalid;
}
forceinline
bool tok_is_access_operator(Token tok) {
return bitfield_is_equal( u32, tok.Flags, TF_AccessOperator );
}
forceinline
bool tok_is_access_specifier(Token tok) {
return bitfield_is_equal( u32, tok.Flags, TF_AccessSpecifier );
}
forceinline
bool tok_is_attribute(Token tok) {
return bitfield_is_equal( u32, tok.Flags, TF_Attribute );
}
forceinline
bool tok_is_operator(Token tok) {
return bitfield_is_equal( u32, tok.Flags, TF_Operator );
}
forceinline
bool tok_is_preprocessor(Token tok) {
return bitfield_is_equal( u32, tok.Flags, TF_Preprocess );
}
forceinline
bool tok_is_preprocess_cond(Token tok) {
return bitfield_is_equal( u32, tok.Flags, TF_Preprocess_Cond );
}
forceinline
bool tok_is_specifier(Token tok) {
return bitfield_is_equal( u32, tok.Flags, TF_Specifier );
}
forceinline
bool tok_is_end_definition(Token tok) {
return bitfield_is_equal( u32, tok.Flags, TF_EndDefinition );
}
StrBuilder tok_to_strbuilder(Token tok);
struct TokArray
{
Array(Token) Arr;
s32 Idx;
};
struct LexContext
{
Str content;
s32 left;
char const* scanner;
s32 line;
s32 column;
StringTable defines;
Token token;
};
struct StackNode
{
StackNode* Prev;
Token* Start;
Str Name; // The name of the AST node (if parsed)
Str ProcName; // The name of the procedure
};
struct ParseContext
{
TokArray Tokens;
StackNode* Scope;
};

View File

@ -4,31 +4,15 @@
#endif #endif
#pragma region StaticData #pragma region StaticData
global Context* _ctx;
// TODO : Convert global allocation strategy to use a slab allocation strategy.
global AllocatorInfo GlobalAllocator;
global Array( Arena ) Global_AllocatorBuckets;
// TODO(Ed) : Make the code pool a dynamic arena
global Array( Pool ) CodePools = { nullptr };
global Array( Arena ) StringArenas = { nullptr };
global StringTable StringCache;
global Arena LexArena;
global AllocatorInfo Allocator_DataArrays = {0};
global AllocatorInfo Allocator_CodePool = {0};
global AllocatorInfo Allocator_Lexer = {0};
global AllocatorInfo Allocator_StringArena = {0};
global AllocatorInfo Allocator_StringTable = {0};
global AllocatorInfo Allocator_TypeTable = {0};
#pragma endregion StaticData
#pragma region Constants #pragma region Constants
global u32 context_counter;
global StrC enum_underlying_sig; global Str enum_underlying_sig;
global Code Code_Global;
global Code Code_Invalid;
global Code access_public; global Code access_public;
global Code access_protected; global Code access_protected;
@ -84,8 +68,6 @@ global CodeTypename t_wchar_t;
global CodeTypename t_class; global CodeTypename t_class;
global CodeTypename t_typename; global CodeTypename t_typename;
global Array(StringCached) PreprocessorDefines;
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS #ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
global CodeTypename t_b32; global CodeTypename t_b32;
@ -107,3 +89,5 @@ global CodeTypename t_f64;
#endif #endif
#pragma endregion Constants #pragma endregion Constants
#pragma endregion StaticData

View File

@ -44,17 +44,17 @@ enum AccessSpec : 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
StrC access_spec_to_str( AccessSpec type ) Str access_spec_to_str( AccessSpec type )
{ {
local_persist local_persist
StrC lookup[ (u32)AccessSpec_Num_AccessSpec ] = { Str lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
{ sizeof("") - 1, "" }, { "", sizeof( "" ) - 1 },
{ sizeof("prviate") - 1, "private" }, { "private", sizeof("prviate") - 1 },
{ sizeof("protected") - 1, "private" }, { "private", sizeof("protected") - 1 },
{ sizeof("public") - 1, "public" }, { "public", sizeof("public") - 1 },
}; };
StrC invalid = { sizeof("Invalid") - 1, "Invalid" }; Str invalid = { "Invalid", sizeof("Invalid") - 1 };
if ( type > AccessSpec_Public ) if ( type > AccessSpec_Public )
return invalid; return invalid;
@ -97,17 +97,17 @@ enum ModuleFlag : 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 module_flag_to_str( ModuleFlag flag ) Str module_flag_to_str( ModuleFlag flag )
{ {
local_persist local_persist
StrC lookup[ (u32)Num_ModuleFlags ] = { Str lookup[ (u32)Num_ModuleFlags ] = {
{ sizeof("__none__"), "__none__" }, { "__none__", sizeof("__none__") - 1 },
{ sizeof("export"), "export" }, { "export", sizeof("export") - 1 },
{ sizeof("import"), "import" }, { "import", sizeof("import") - 1 },
}; };
local_persist local_persist
StrC invalid_flag = { sizeof("invalid"), "invalid" }; Str invalid_flag = { "invalid", sizeof("invalid") };
if ( flag > ModuleFlag_Import ) if ( flag > ModuleFlag_Import )
return invalid_flag; return invalid_flag;

View File

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

View File

@ -11,8 +11,10 @@
#if GEN_BUILD_DEBUG #if GEN_BUILD_DEBUG
# if defined( GEN_COMPILER_MSVC ) # if defined( GEN_COMPILER_MSVC )
# if _MSC_VER < 1300 # if _MSC_VER < 1300
#pragma message("GEN_BUILD_DEBUG: __asm int 3")
# define GEN_DEBUG_TRAP() __asm int 3 /* Trap to debugger! */ # define GEN_DEBUG_TRAP() __asm int 3 /* Trap to debugger! */
# else # else
#pragma message("GEN_BUILD_DEBUG: __debugbreak()")
# define GEN_DEBUG_TRAP() __debugbreak() # define GEN_DEBUG_TRAP() __debugbreak()
# endif # endif
# elif defined( GEN_COMPILER_TINYC ) # elif defined( GEN_COMPILER_TINYC )
@ -21,6 +23,7 @@
# define GEN_DEBUG_TRAP() __builtin_trap() # define GEN_DEBUG_TRAP() __builtin_trap()
# endif # endif
#else #else
#pragma message("GEN_BUILD_DEBUG: omitted")
# define GEN_DEBUG_TRAP() # define GEN_DEBUG_TRAP()
#endif #endif
@ -48,7 +51,7 @@
local_persist thread_local \ local_persist thread_local \
char buf[GEN_PRINTF_MAXLEN] = { 0 }; \ char buf[GEN_PRINTF_MAXLEN] = { 0 }; \
\ \
str_fmt(buf, GEN_PRINTF_MAXLEN, __VA_ARGS__); \ c_str_fmt(buf, GEN_PRINTF_MAXLEN, __VA_ARGS__); \
GEN_PANIC(buf); \ GEN_PANIC(buf); \
} \ } \
while (0) while (0)
@ -57,7 +60,8 @@
# define GEN_FATAL( ... ) \ # define GEN_FATAL( ... ) \
do \ do \
{ \ { \
str_fmt_out_err( __VA_ARGS__ ); \ c_str_fmt_out_err( __VA_ARGS__ ); \
GEN_DEBUG_TRAP(); \
process_exit(1); \ process_exit(1); \
} \ } \
while (0) while (0)

View File

@ -18,7 +18,7 @@ wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, ssize* w_len_ )
*w_len_ = w_len; *w_len_ = w_len;
return NULL; return NULL;
} }
len = str_len( text ); len = c_str_len( text );
if ( len == 0 ) if ( len == 0 )
{ {
if ( w_len_ ) if ( w_len_ )
@ -284,7 +284,7 @@ GEN_FILE_OPEN_PROC( _posix_file_open )
internal void _dirinfo_free_entry( DirEntry* entry ); internal void _dirinfo_free_entry( DirEntry* entry );
// TODO : Is this a bad idea? // TODO(zpl) : Is this a bad idea?
global b32 _std_file_set = false; global b32 _std_file_set = false;
global FileInfo _std_files[ EFileStandard_COUNT ] = { global FileInfo _std_files[ EFileStandard_COUNT ] = {
{ {
@ -375,7 +375,7 @@ FileError file_close( FileInfo* f )
FileError file_new( FileInfo* f, FileDescriptor fd, FileOperations ops, char const* filename ) FileError file_new( FileInfo* f, FileDescriptor fd, FileOperations ops, char const* filename )
{ {
FileError err = EFileError_NONE; FileError err = EFileError_NONE;
ssize len = str_len( filename ); ssize len = c_str_len( filename );
f->ops = ops; f->ops = ops;
f->fd = fd; f->fd = fd;

View File

@ -93,7 +93,7 @@ struct DirInfo
// Internals // Internals
char** filenames; // zpl_array char** filenames; // zpl_array
String buf; StrBuilder buf;
}; };
struct FileInfo struct FileInfo

View File

@ -5,6 +5,24 @@
#pragma region Macros #pragma region Macros
#if GEN_COMPILER_MSVC
#ifdef GEN_DYN_LINK
#ifdef GEN_EXPORTS
#define GEN_API __declspec(dllexport)
#else
#define GEN_API __declspec(dllimport)
#endif
#else
#define GEN_API // Empty for static builds
#endif
#else
#ifdef GEN_DYN_LINK
#define GEN_API __attribute__((visibility("default")))
#else
#define GEN_API // Empty for static builds
#endif
#endif
#ifndef global #ifndef global
#define global static // Global variables #define global static // Global variables
#endif #endif
@ -69,7 +87,13 @@
#endif #endif
#ifndef do_once #ifndef do_once
#define do_once( statement ) for ( local_persist b32 once = true; once; once = false, (statement) ) #define do_once() \
static int __do_once_counter_##__LINE__ = 0; \
for(; __do_once_counter_##__LINE__ != 1; __do_once_counter_##__LINE__ = 1 ) \
#define do_once_defer( expression ) \
static int __do_once_counter_##__LINE__ = 0; \
for(; __do_once_counter_##__LINE__ != 1; __do_once_counter_##__LINE__ = 1, (expression)) \
#define do_once_start \ #define do_once_start \
do \ do \

View File

@ -8,7 +8,7 @@
#define _adt_fprintf( s_, fmt_, ... ) \ #define _adt_fprintf( s_, fmt_, ... ) \
do \ do \
{ \ { \
if ( str_fmt_file( s_, fmt_, ##__VA_ARGS__ ) < 0 ) \ if ( c_str_fmt_file( s_, fmt_, ##__VA_ARGS__ ) < 0 ) \
return EADT_ERROR_OUT_OF_MEMORY; \ return EADT_ERROR_OUT_OF_MEMORY; \
} while ( 0 ) } while ( 0 )
@ -69,7 +69,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search )
for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ ) for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ )
{ {
if ( ! str_compare( node->nodes[ i ].name, name ) ) if ( ! c_str_compare( node->nodes[ i ].name, name ) )
{ {
return ( node->nodes + i ); return ( node->nodes + i );
} }
@ -96,7 +96,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value )
case EADT_TYPE_MULTISTRING : case EADT_TYPE_MULTISTRING :
case EADT_TYPE_STRING : case EADT_TYPE_STRING :
{ {
if ( node->string && ! str_compare( node->string, value ) ) if ( node->string && ! c_str_compare( node->string, value ) )
{ {
return node; return node;
} }
@ -115,7 +115,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value )
ssize fsize = 0; ssize fsize = 0;
u8* buf = file_stream_buf( &tmp, &fsize ); u8* buf = file_stream_buf( &tmp, &fsize );
if ( ! str_compare( ( char const* )buf, value ) ) if ( ! c_str_compare( ( char const* )buf, value ) )
{ {
file_close( &tmp ); file_close( &tmp );
return node; return node;
@ -135,7 +135,7 @@ internal ADT_Node* _adt_get_field( ADT_Node* node, char* name, char* value )
{ {
for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ ) for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ )
{ {
if ( ! str_compare( node->nodes[ i ].name, name ) ) if ( ! c_str_compare( node->nodes[ i ].name, name ) )
{ {
ADT_Node* child = &node->nodes[ i ]; ADT_Node* child = &node->nodes[ i ];
if ( _adt_get_value( child, value ) ) if ( _adt_get_value( child, value ) )
@ -168,22 +168,22 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
} }
#if defined EADT_URI_DEBUG || 0 #if defined EADT_URI_DEBUG || 0
str_fmt_out( "uri: %s\n", uri ); c_str_fmt_out( "uri: %s\n", uri );
#endif #endif
char * p = ( char* )uri, *b = p, *e = p; char * p = ( char* )uri, *b = p, *e = p;
ADT_Node* found_node = NULL; ADT_Node* found_node = NULL;
b = p; b = p;
p = e = ( char* )str_skip( p, '/' ); p = e = ( char* )c_str_skip( p, '/' );
char* buf = str_fmt_buf( "%.*s", ( int )( e - b ), b ); char* buf = c_str_fmt_buf( "%.*s", ( int )( e - b ), b );
/* handle field value lookup */ /* handle field value lookup */
if ( *b == '[' ) if ( *b == '[' )
{ {
char *l_p = buf + 1, *l_b = l_p, *l_e = l_p, *l_b2 = l_p, *l_e2 = l_p; char *l_p = buf + 1, *l_b = l_p, *l_e = l_p, *l_b2 = l_p, *l_e2 = l_p;
l_e = ( char* )str_skip( l_p, '=' ); l_e = ( char* )c_str_skip( l_p, '=' );
l_e2 = ( char* )str_skip( l_p, ']' ); l_e2 = ( char* )c_str_skip( l_p, ']' );
if ( ( ! *l_e && node->type != EADT_TYPE_ARRAY ) || ! *l_e2 ) if ( ( ! *l_e && node->type != EADT_TYPE_ARRAY ) || ! *l_e2 )
{ {
@ -257,7 +257,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri )
/* handle array index lookup */ /* handle array index lookup */
else else
{ {
ssize idx = ( ssize )str_to_i64( buf, NULL, 10 ); ssize idx = ( ssize )c_str_to_i64( buf, NULL, 10 );
if ( idx >= 0 && idx < scast(ssize, array_num(node->nodes)) ) if ( idx >= 0 && idx < scast(ssize, array_num(node->nodes)) )
{ {
found_node = &node->nodes[ idx ]; found_node = &node->nodes[ idx ];
@ -511,7 +511,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
} }
else else
{ {
if ( ! str_compare_len( e, "0x", 2 ) || ! str_compare_len( e, "0X", 2 ) ) if ( ! c_str_compare_len( e, "0x", 2 ) || ! c_str_compare_len( e, "0X", 2 ) )
{ {
node_props = EADT_PROPS_IS_HEX; node_props = EADT_PROPS_IS_HEX;
} }
@ -575,12 +575,12 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
} }
} }
orig_exp = exp = ( u8 )str_to_i64( expbuf, NULL, 10 ); orig_exp = exp = ( u8 )c_str_to_i64( expbuf, NULL, 10 );
} }
if ( node_type == EADT_TYPE_INTEGER ) if ( node_type == EADT_TYPE_INTEGER )
{ {
node->integer = str_to_i64( buf, 0, 0 ); node->integer = c_str_to_i64( buf, 0, 0 );
#ifndef GEN_PARSER_DISABLE_ANALYSIS #ifndef GEN_PARSER_DISABLE_ANALYSIS
/* special case: negative zero */ /* special case: negative zero */
if ( node->integer == 0 && buf[ 0 ] == '-' ) if ( node->integer == 0 && buf[ 0 ] == '-' )
@ -595,19 +595,19 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
} }
else else
{ {
node->real = str_to_f64( buf, 0 ); node->real = c_str_to_f64( buf, 0 );
#ifndef GEN_PARSER_DISABLE_ANALYSIS #ifndef GEN_PARSER_DISABLE_ANALYSIS
char *q = buf, *base_string = q, *base_string2 = q; char *q = buf, *base_string = q, *base_string2 = q;
base_string = ccast( char*, str_skip( base_string, '.' )); base_string = ccast( char*, c_str_skip( base_string, '.' ));
*base_string = '\0'; *base_string = '\0';
base_string2 = base_string + 1; base_string2 = base_string + 1;
char* base_string_off = base_string2; char* base_strbuilder_off = base_string2;
while ( *base_string_off++ == '0' ) while ( *base_strbuilder_off++ == '0' )
base2_offset++; base2_offset++;
base = ( s32 )str_to_i64( q, 0, 0 ); base = ( s32 )c_str_to_i64( q, 0, 0 );
base2 = ( s32 )str_to_i64( base_string2, 0, 0 ); base2 = ( s32 )c_str_to_i64( base_string2, 0, 0 );
if ( exp ) if ( exp )
{ {
exp = exp * ( ! ( eb == 10.0f ) ? -1 : 1 ); exp = exp * ( ! ( eb == 10.0f ) ? -1 : 1 );
@ -750,7 +750,7 @@ ADT_Error adt_print_string( FileInfo* file, ADT_Node* node, char const* escaped_
do do
{ {
p = str_skip_any( p, escaped_chars ); p = c_str_skip_any( p, escaped_chars );
_adt_fprintf( file, "%.*s", pointer_diff( b, p ), b ); _adt_fprintf( file, "%.*s", pointer_diff( b, p ), b );
if ( *p && ! ! char_first_occurence( escaped_chars, *p ) ) if ( *p && ! ! char_first_occurence( escaped_chars, *p ) )
{ {
@ -763,7 +763,7 @@ ADT_Error adt_print_string( FileInfo* file, ADT_Node* node, char const* escaped_
return EADT_ERROR_NONE; return EADT_ERROR_NONE;
} }
ADT_Error adt_str_to_number( ADT_Node* node ) ADT_Error adt_c_str_to_number( ADT_Node* node )
{ {
GEN_ASSERT( node ); GEN_ASSERT( node );
@ -779,7 +779,7 @@ ADT_Error adt_str_to_number( ADT_Node* node )
return EADT_ERROR_NONE; return EADT_ERROR_NONE;
} }
ADT_Error adt_str_to_number_strict( ADT_Node* node ) ADT_Error adt_c_str_to_number_strict( ADT_Node* node )
{ {
GEN_ASSERT( node ); GEN_ASSERT( node );
@ -826,7 +826,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
do do
{ {
char delimiter = 0; char delimiter = 0;
currentChar = ccast( char*, str_trim( currentChar, false )); currentChar = ccast( char*, c_str_trim( currentChar, false ));
if ( *currentChar == 0 ) if ( *currentChar == 0 )
break; break;
@ -850,7 +850,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
#endif #endif
do do
{ {
endChar = ccast( char*, str_skip( endChar, '"' )); endChar = ccast( char*, c_str_skip( endChar, '"' ));
if ( *endChar && *( endChar + 1 ) == '"' ) if ( *endChar && *( endChar + 1 ) == '"' )
{ {
@ -869,7 +869,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
} }
*endChar = 0; *endChar = 0;
currentChar = ccast( char*, str_trim( endChar + 1, true )); currentChar = ccast( char*, c_str_trim( endChar + 1, true ));
delimiter = * currentChar; delimiter = * currentChar;
/* unescape escaped quotes (so that unescaped text escapes :) */ /* unescape escaped quotes (so that unescaped text escapes :) */
@ -879,7 +879,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
{ {
if ( *escapedChar == '"' && *( escapedChar + 1 ) == '"' ) if ( *escapedChar == '"' && *( escapedChar + 1 ) == '"' )
{ {
mem_move( escapedChar, escapedChar + 1, str_len( escapedChar ) ); mem_move( escapedChar, escapedChar + 1, c_str_len( escapedChar ) );
} }
escapedChar++; escapedChar++;
} }
@ -906,7 +906,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
if ( * endChar ) if ( * endChar )
{ {
currentChar = ccast( char*, str_trim( endChar, true )); currentChar = ccast( char*, c_str_trim( endChar, true ));
while ( char_is_space( *( endChar - 1 ) ) ) while ( char_is_space( *( endChar - 1 ) ) )
{ {
@ -927,7 +927,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
char* num_p = beginChar; char* num_p = beginChar;
// We only consider hexadecimal values if they start with 0x // We only consider hexadecimal values if they start with 0x
if ( str_len(num_p) > 2 && num_p[0] == '0' && (num_p[1] == 'x' || num_p[1] == 'X') ) if ( c_str_len(num_p) > 2 && num_p[0] == '0' && (num_p[1] == 'x' || num_p[1] == 'X') )
{ {
num_p += 2; // skip '0x' prefix num_p += 2; // skip '0x' prefix
do do
@ -946,7 +946,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
if (!skip_number) if (!skip_number)
{ {
adt_str_to_number(&rowItem); adt_c_str_to_number(&rowItem);
} }
} }
@ -1021,16 +1021,16 @@ void _csv_write_record( FileInfo* file, CSV_Object* node )
{ {
case EADT_NAME_STYLE_DOUBLE_QUOTE : case EADT_NAME_STYLE_DOUBLE_QUOTE :
{ {
str_fmt_file( file, "\"" ); c_str_fmt_file( file, "\"" );
adt_print_string( file, node, "\"", "\"" ); adt_print_string( file, node, "\"", "\"" );
str_fmt_file( file, "\"" ); c_str_fmt_file( file, "\"" );
} }
break; break;
case EADT_NAME_STYLE_NO_QUOTES : case EADT_NAME_STYLE_NO_QUOTES :
{ {
#endif #endif
str_fmt_file( file, "%s", node->string ); c_str_fmt_file( file, "%s", node->string );
#ifndef GEN_PARSER_DISABLE_ANALYSIS #ifndef GEN_PARSER_DISABLE_ANALYSIS
} }
break; break;
@ -1078,10 +1078,10 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
_csv_write_header( file, &obj->nodes[ i ] ); _csv_write_header( file, &obj->nodes[ i ] );
if ( i + 1 != cols ) if ( i + 1 != cols )
{ {
str_fmt_file( file, "%c", delimiter ); c_str_fmt_file( file, "%c", delimiter );
} }
} }
str_fmt_file( file, "\n" ); c_str_fmt_file( file, "\n" );
} }
for ( ssize r = 0; r < rows; r++ ) for ( ssize r = 0; r < rows; r++ )
@ -1091,14 +1091,14 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
_csv_write_record( file, &obj->nodes[ i ].nodes[ r ] ); _csv_write_record( file, &obj->nodes[ i ].nodes[ r ] );
if ( i + 1 != cols ) if ( i + 1 != cols )
{ {
str_fmt_file( file, "%c", delimiter ); c_str_fmt_file( file, "%c", delimiter );
} }
} }
str_fmt_file( file, "\n" ); c_str_fmt_file( file, "\n" );
} }
} }
String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delimiter ) StrBuilder csv_write_strbuilder_delimiter( AllocatorInfo a, CSV_Object* obj, char delimiter )
{ {
FileInfo tmp; FileInfo tmp;
file_stream_new( &tmp, a ); file_stream_new( &tmp, a );
@ -1106,7 +1106,7 @@ String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delimi
ssize fsize; ssize fsize;
u8* buf = file_stream_buf( &tmp, &fsize ); u8* buf = file_stream_buf( &tmp, &fsize );
String output = string_make_length( a, ( char* )buf, fsize ); StrBuilder output = strbuilder_make_length( a, ( char* )buf, fsize );
file_close( &tmp ); file_close( &tmp );
return output; return output;
} }

View File

@ -350,7 +350,7 @@ char* adt_parse_number_strict( ADT_Node* node, char* base_str );
* @param node * @param node
* @return * @return
*/ */
ADT_Error adt_str_to_number( ADT_Node* node ); ADT_Error adt_c_str_to_number( ADT_Node* node );
/** /**
* @brief Parses and converts an existing string node into a number. * @brief Parses and converts an existing string node into a number.
@ -359,7 +359,7 @@ ADT_Error adt_str_to_number( ADT_Node* node );
* @param node * @param node
* @return * @return
*/ */
ADT_Error adt_str_to_number_strict( ADT_Node* node ); ADT_Error adt_c_str_to_number_strict( ADT_Node* node );
/** /**
* @brief Prints a number into a file stream. * @brief Prints a number into a file stream.
@ -406,9 +406,9 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator,
void csv_free( CSV_Object* obj ); void csv_free( CSV_Object* obj );
void csv_write( FileInfo* file, CSV_Object* obj ); void csv_write( FileInfo* file, CSV_Object* obj );
String csv_write_string( AllocatorInfo a, CSV_Object* obj ); StrBuilder csv_write_string( AllocatorInfo a, CSV_Object* obj );
void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delim ); void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delim );
String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delim ); StrBuilder csv_write_strbuilder_delimiter( AllocatorInfo a, CSV_Object* obj, char delim );
/* inline */ /* inline */
@ -425,9 +425,9 @@ void csv_write( FileInfo* file, CSV_Object* obj )
} }
inline inline
String csv_write_string( AllocatorInfo a, CSV_Object* obj ) StrBuilder csv_write_string( AllocatorInfo a, CSV_Object* obj )
{ {
return csv_write_string_delimiter( a, obj, ',' ); return csv_write_strbuilder_delimiter( a, obj, ',' );
} }
#pragma endregion CSV #pragma endregion CSV

View File

@ -143,27 +143,15 @@
#if GEN_DONT_USE_NAMESPACE || GEN_COMPILER_C #if GEN_DONT_USE_NAMESPACE || GEN_COMPILER_C
# if GEN_COMPILER_C # if GEN_COMPILER_C
# define GEN_NS_PARSER_BEGIN
# define GEN_NS_PARSER_END
# define GEN_USING_NS_PARSER
# define GEN_NS_PARSER
# define GEN_NS # define GEN_NS
# define GEN_NS_BEGIN # define GEN_NS_BEGIN
# define GEN_NS_END # define GEN_NS_END
# else # else
# define GEN_NS_PARSER_BEGIN namespace parser {
# define GEN_NS_PARSER_END }
# define GEN_USING_NS_PARSER using namespace parser
# define GEN_NS_PARSER parser::
# define GEN_NS :: # define GEN_NS ::
# define GEN_NS_BEGIN # define GEN_NS_BEGIN
# define GEN_NS_END # define GEN_NS_END
# endif # endif
#else #else
# define GEN_NS_PARSER_BEGIN namespace parser {
# define GEN_NS_PARSER_END }
# define GEN_NS_PARSER parser::
# define GEN_USING_NS_PARSER using namespace parser
# define GEN_NS gen:: # define GEN_NS gen::
# define GEN_NS_BEGIN namespace gen { # define GEN_NS_BEGIN namespace gen {
# define GEN_NS_END } # define GEN_NS_END }

View File

@ -1,6 +1,6 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES #ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once # pragma once
# include "string_ops.cpp" # include "strbuilder_ops.cpp"
#endif #endif
#pragma region Printing #pragma region Printing
@ -48,7 +48,7 @@ internal ssize _print_string( char* text, ssize max_len, _format_info* info, cha
if ( str == NULL && max_len >= 6 ) if ( str == NULL && max_len >= 6 )
{ {
res += str_copy_nulpad( text, "(null)", 6 ); res += c_str_copy_nulpad( text, "(null)", 6 );
return res; return res;
} }
@ -56,7 +56,7 @@ internal ssize _print_string( char* text, ssize max_len, _format_info* info, cha
// Made the design decision for this library that precision is the length of the string. // Made the design decision for this library that precision is the length of the string.
len = info->precision; len = info->precision;
else else
len = str_len( str ); len = c_str_len( str );
if ( info && ( info->width == 0 && info->flags & GEN_FMT_WIDTH ) ) if ( info && ( info->width == 0 && info->flags & GEN_FMT_WIDTH ) )
{ {
@ -69,7 +69,7 @@ internal ssize _print_string( char* text, ssize max_len, _format_info* info, cha
len = info->precision < len ? info->precision : len; len = info->precision < len ? info->precision : len;
if ( res + len > max_len ) if ( res + len > max_len )
return res; return res;
res += str_copy_nulpad( text, str, len ); res += c_str_copy_nulpad( text, str, len );
text += res; text += res;
if ( info->width > res ) if ( info->width > res )
@ -93,15 +93,15 @@ internal ssize _print_string( char* text, ssize max_len, _format_info* info, cha
if ( res + len > max_len ) if ( res + len > max_len )
return res; return res;
res += str_copy_nulpad( text, str, len ); res += c_str_copy_nulpad( text, str, len );
} }
if ( info ) if ( info )
{ {
if ( info->flags & GEN_FMT_UPPER ) if ( info->flags & GEN_FMT_UPPER )
str_to_upper( begin ); c_str_to_upper( begin );
else if ( info->flags & GEN_FMT_LOWER ) else if ( info->flags & GEN_FMT_LOWER )
str_to_lower( begin ); c_str_to_lower( begin );
} }
return res; return res;
@ -238,7 +238,7 @@ internal ssize _print_f64( char* text, ssize max_len, _format_info* info, b32 is
return ( text - text_begin ); return ( text - text_begin );
} }
neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_list va ) neverinline ssize c_str_fmt_va( char* text, ssize max_len, char const* fmt, va_list va )
{ {
char const* text_begin = text; char const* text_begin = text;
ssize remaining = max_len, res; ssize remaining = max_len, res;
@ -310,7 +310,7 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis
} }
else else
{ {
info.width = scast( s32, str_to_i64( fmt, ccast( char**, & fmt), 10 )); info.width = scast( s32, c_str_to_i64( fmt, ccast( char**, & fmt), 10 ));
if ( info.width != 0 ) if ( info.width != 0 )
{ {
info.flags |= GEN_FMT_WIDTH; info.flags |= GEN_FMT_WIDTH;
@ -328,7 +328,7 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis
} }
else else
{ {
info.precision = scast( s32, str_to_i64( fmt, ccast( char**, & fmt), 10 )); info.precision = scast( s32, c_str_to_i64( fmt, ccast( char**, & fmt), 10 ));
} }
info.flags &= ~GEN_FMT_ZERO; info.flags &= ~GEN_FMT_ZERO;
} }
@ -419,19 +419,20 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis
case 'S': case 'S':
{ {
if ( *(fmt + 1) == 'C' ) if ( *(fmt + 1) == 'B' )
{ {
++ fmt; ++ fmt;
StrC gen_str = va_arg( va, StrC); StrBuilder gen_str = { va_arg( va, char*) };
info.precision = gen_str.Len;
len = _print_string( text, remaining, &info, gen_str.Ptr ); info.precision = strbuilder_length(gen_str);
len = _print_string( text, remaining, &info, gen_str );
break; break;
} }
String gen_str = { va_arg( va, char*) }; Str gen_str = va_arg( va, Str);
info.precision = gen_str.Len;
info.precision = string_length(gen_str); len = _print_string( text, remaining, &info, gen_str.Ptr );
len = _print_string( text, remaining, &info, gen_str );
} }
break; break;
@ -531,67 +532,67 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis
return ( res >= max_len || res < 0 ) ? -1 : res; return ( res >= max_len || res < 0 ) ? -1 : res;
} }
char* str_fmt_buf_va( char const* fmt, va_list va ) char* c_str_fmt_buf_va( char const* fmt, va_list va )
{ {
local_persist thread_local char buffer[ GEN_PRINTF_MAXLEN ]; local_persist thread_local char buffer[ GEN_PRINTF_MAXLEN ];
str_fmt_va( buffer, size_of( buffer ), fmt, va ); c_str_fmt_va( buffer, size_of( buffer ), fmt, va );
return buffer; return buffer;
} }
char* str_fmt_buf( char const* fmt, ... ) char* c_str_fmt_buf( char const* fmt, ... )
{ {
va_list va; va_list va;
char* str; char* str;
va_start( va, fmt ); va_start( va, fmt );
str = str_fmt_buf_va( fmt, va ); str = c_str_fmt_buf_va( fmt, va );
va_end( va ); va_end( va );
return str; return str;
} }
ssize str_fmt_file_va( FileInfo* f, char const* fmt, va_list va ) ssize c_str_fmt_file_va( FileInfo* f, char const* fmt, va_list va )
{ {
local_persist thread_local char buf[ GEN_PRINTF_MAXLEN ]; local_persist thread_local char buf[ GEN_PRINTF_MAXLEN ];
ssize len = str_fmt_va( buf, size_of( buf ), fmt, va ); ssize len = c_str_fmt_va( buf, size_of( buf ), fmt, va );
b32 res = file_write( f, buf, len - 1 ); // NOTE: prevent extra whitespace b32 res = file_write( f, buf, len - 1 ); // NOTE: prevent extra whitespace
return res ? len : -1; return res ? len : -1;
} }
ssize str_fmt_file( FileInfo* f, char const* fmt, ... ) ssize c_str_fmt_file( FileInfo* f, char const* fmt, ... )
{ {
ssize res; ssize res;
va_list va; va_list va;
va_start( va, fmt ); va_start( va, fmt );
res = str_fmt_file_va( f, fmt, va ); res = c_str_fmt_file_va( f, fmt, va );
va_end( va ); va_end( va );
return res; return res;
} }
ssize str_fmt( char* str, ssize n, char const* fmt, ... ) ssize c_str_fmt( char* str, ssize n, char const* fmt, ... )
{ {
ssize res; ssize res;
va_list va; va_list va;
va_start( va, fmt ); va_start( va, fmt );
res = str_fmt_va( str, n, fmt, va ); res = c_str_fmt_va( str, n, fmt, va );
va_end( va ); va_end( va );
return res; return res;
} }
ssize str_fmt_out_va( char const* fmt, va_list va ) ssize c_str_fmt_out_va( char const* fmt, va_list va )
{ {
return str_fmt_file_va( file_get_standard( EFileStandard_OUTPUT ), fmt, va ); return c_str_fmt_file_va( file_get_standard( EFileStandard_OUTPUT ), fmt, va );
} }
ssize str_fmt_out_err_va( char const* fmt, va_list va ) ssize c_str_fmt_out_err_va( char const* fmt, va_list va )
{ {
return str_fmt_file_va( file_get_standard( EFileStandard_ERROR ), fmt, va ); return c_str_fmt_file_va( file_get_standard( EFileStandard_ERROR ), fmt, va );
} }
ssize str_fmt_out_err( char const* fmt, ... ) ssize c_str_fmt_out_err( char const* fmt, ... )
{ {
ssize res; ssize res;
va_list va; va_list va;
va_start( va, fmt ); va_start( va, fmt );
res = str_fmt_out_err_va( fmt, va ); res = c_str_fmt_out_err_va( fmt, va );
va_end( va ); va_end( va );
return res; return res;
} }

View File

@ -1,6 +1,6 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES #ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once # pragma once
# include "string_ops.hpp" # include "strbuilder_ops.hpp"
#endif #endif
#pragma region Printing #pragma region Printing
@ -13,15 +13,15 @@ typedef struct FileInfo FileInfo;
typedef char PrintF_Buffer[GEN_PRINTF_MAXLEN]; typedef char PrintF_Buffer[GEN_PRINTF_MAXLEN];
// NOTE: A locally persisting buffer is used internally // NOTE: A locally persisting buffer is used internally
char* str_fmt_buf ( char const* fmt, ... ); char* c_str_fmt_buf ( char const* fmt, ... );
char* str_fmt_buf_va ( char const* fmt, va_list va ); char* c_str_fmt_buf_va ( char const* fmt, va_list va );
ssize str_fmt ( char* str, ssize n, char const* fmt, ... ); ssize c_str_fmt ( char* str, ssize n, char const* fmt, ... );
ssize str_fmt_va ( char* str, ssize n, char const* fmt, va_list va ); ssize c_str_fmt_va ( char* str, ssize n, char const* fmt, va_list va );
ssize str_fmt_out_va ( char const* fmt, va_list va ); ssize c_str_fmt_out_va ( char const* fmt, va_list va );
ssize str_fmt_out_err ( char const* fmt, ... ); ssize c_str_fmt_out_err ( char const* fmt, ... );
ssize str_fmt_out_err_va( char const* fmt, va_list va ); ssize c_str_fmt_out_err_va( char const* fmt, va_list va );
ssize str_fmt_file ( FileInfo* f, char const* fmt, ... ); ssize c_str_fmt_file ( FileInfo* f, char const* fmt, ... );
ssize str_fmt_file_va ( FileInfo* f, char const* fmt, va_list va ); ssize c_str_fmt_file_va ( FileInfo* f, char const* fmt, va_list va );
constexpr constexpr
char const* Msg_Invalid_Value = "INVALID VALUE PROVIDED"; char const* Msg_Invalid_Value = "INVALID VALUE PROVIDED";
@ -33,7 +33,7 @@ ssize log_fmt(char const* fmt, ...)
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
res = str_fmt_out_va(fmt, va); res = c_str_fmt_out_va(fmt, va);
va_end(va); va_end(va);
return res; return res;

View File

@ -13,9 +13,9 @@
# define _printf_err( fmt, ... ) fprintf( stderr, fmt, __VA_ARGS__ ) # define _printf_err( fmt, ... ) fprintf( stderr, fmt, __VA_ARGS__ )
# define _printf_err_va( fmt, va ) vfprintf( stderr, fmt, va ) # define _printf_err_va( fmt, va ) vfprintf( stderr, fmt, va )
# else # else
# define _strlen str_len # define _strlen c_str_len
# define _printf_err( fmt, ... ) str_fmt_out_err( fmt, __VA_ARGS__ ) # define _printf_err( fmt, ... ) c_str_fmt_out_err( fmt, __VA_ARGS__ )
# define _printf_err_va( fmt, va ) str_fmt_out_err_va( fmt, va ) # define _printf_err_va( fmt, va ) c_str_fmt_out_err_va( fmt, va )
# endif # endif
# endif # endif
# #

View File

@ -18,7 +18,7 @@ ssize _scan_zpl_i64( const char* text, s32 base, s64* value )
text++; text++;
} }
if ( base == 16 && str_compare_len( text, "0x", 2 ) == 0 ) if ( base == 16 && c_str_compare_len( text, "0x", 2 ) == 0 )
text += 2; text += 2;
for ( ;; ) for ( ;; )
@ -53,14 +53,14 @@ global const char _num_to_char_table[] =
"abcdefghijklmnopqrstuvwxyz" "abcdefghijklmnopqrstuvwxyz"
"@$"; "@$";
s64 str_to_i64( const char* str, char** end_ptr, s32 base ) s64 c_str_to_i64( const char* str, char** end_ptr, s32 base )
{ {
ssize len; ssize len;
s64 value; s64 value;
if ( ! base ) if ( ! base )
{ {
if ( ( str_len( str ) > 2 ) && ( str_compare_len( str, "0x", 2 ) == 0 ) ) if ( ( c_str_len( str ) > 2 ) && ( c_str_compare_len( str, "0x", 2 ) == 0 ) )
base = 16; base = 16;
else else
base = 10; base = 10;
@ -100,7 +100,7 @@ void i64_to_str( s64 value, char* string, s32 base )
if ( negative ) if ( negative )
*buf++ = '-'; *buf++ = '-';
*buf = '\0'; *buf = '\0';
str_reverse( string ); c_str_reverse( string );
} }
void u64_to_str( u64 value, char* string, s32 base ) void u64_to_str( u64 value, char* string, s32 base )
@ -121,10 +121,10 @@ void u64_to_str( u64 value, char* string, s32 base )
} }
*buf = '\0'; *buf = '\0';
str_reverse( string ); c_str_reverse( string );
} }
f64 str_to_f64( const char* str, char** end_ptr ) f64 c_str_to_f64( const char* str, char** end_ptr )
{ {
f64 result, value, sign, scale; f64 result, value, sign, scale;
s32 frac; s32 frac;

View File

@ -18,25 +18,25 @@ char char_to_upper( char c );
s32 digit_to_int( char c ); s32 digit_to_int( char c );
s32 hex_digit_to_int( char c ); s32 hex_digit_to_int( char c );
s32 str_compare( const char* s1, const char* s2 ); s32 c_str_compare( const char* s1, const char* s2 );
s32 str_compare_len( const char* s1, const char* s2, ssize len ); s32 c_str_compare_len( const char* s1, const char* s2, ssize len );
char* str_copy( char* dest, const char* source, ssize len ); char* c_str_copy( char* dest, const char* source, ssize len );
ssize str_copy_nulpad( char* dest, const char* source, ssize len ); ssize c_str_copy_nulpad( char* dest, const char* source, ssize len );
ssize str_len( const char* str ); ssize c_str_len( const char* str );
ssize str_len_capped( const char* str, ssize max_len ); ssize c_str_len_capped( const char* str, ssize max_len );
char* str_reverse( char* str ); // NOTE: ASCII only char* c_str_reverse( char* str ); // NOTE: ASCII only
char const* str_skip( char const* str, char c ); char const* c_str_skip( char const* str, char c );
char const* str_skip_any( char const* str, char const* char_list ); char const* c_str_skip_any( char const* str, char const* char_list );
char const* str_trim( char const* str, b32 catch_newline ); char const* c_str_trim( char const* str, b32 catch_newline );
// NOTE: ASCII only // NOTE: ASCII only
void str_to_lower( char* str ); void c_str_to_lower( char* str );
void str_to_upper( char* str ); void c_str_to_upper( char* str );
s64 str_to_i64( const char* str, char** end_ptr, s32 base ); s64 c_str_to_i64( const char* str, char** end_ptr, s32 base );
void i64_to_str( s64 value, char* string, s32 base ); void i64_to_str( s64 value, char* string, s32 base );
void u64_to_str( u64 value, char* string, s32 base ); void u64_to_str( u64 value, char* string, s32 base );
f64 str_to_f64( const char* str, char** end_ptr ); f64 c_str_to_f64( const char* str, char** end_ptr );
inline inline
const char* char_first_occurence( const char* s, char c ) const char* char_first_occurence( const char* s, char c )
@ -122,7 +122,7 @@ s32 hex_digit_to_int( char c )
} }
inline inline
s32 str_compare( const char* s1, const char* s2 ) s32 c_str_compare( const char* s1, const char* s2 )
{ {
while ( *s1 && ( *s1 == *s2 ) ) while ( *s1 && ( *s1 == *s2 ) )
{ {
@ -132,7 +132,7 @@ s32 str_compare( const char* s1, const char* s2 )
} }
inline inline
s32 str_compare_len( const char* s1, const char* s2, ssize len ) s32 c_str_compare_len( const char* s1, const char* s2, ssize len )
{ {
for ( ; len > 0; s1++, s2++, len-- ) for ( ; len > 0; s1++, s2++, len-- )
{ {
@ -145,7 +145,7 @@ s32 str_compare_len( const char* s1, const char* s2, ssize len )
} }
inline inline
char* str_copy( char* dest, const char* source, ssize len ) char* c_str_copy( char* dest, const char* source, ssize len )
{ {
GEN_ASSERT_NOT_NULL( dest ); GEN_ASSERT_NOT_NULL( dest );
if ( source ) if ( source )
@ -166,7 +166,7 @@ char* str_copy( char* dest, const char* source, ssize len )
} }
inline inline
ssize str_copy_nulpad( char* dest, const char* source, ssize len ) ssize c_str_copy_nulpad( char* dest, const char* source, ssize len )
{ {
ssize result = 0; ssize result = 0;
GEN_ASSERT_NOT_NULL( dest ); GEN_ASSERT_NOT_NULL( dest );
@ -191,7 +191,7 @@ ssize str_copy_nulpad( char* dest, const char* source, ssize len )
} }
inline inline
ssize str_len( const char* str ) ssize c_str_len( const char* str )
{ {
if ( str == NULL ) if ( str == NULL )
{ {
@ -204,7 +204,7 @@ ssize str_len( const char* str )
} }
inline inline
ssize str_len_capped( const char* str, ssize max_len ) ssize c_str_len_capped( const char* str, ssize max_len )
{ {
const char* end = rcast(const char*, mem_find( str, 0, max_len )); const char* end = rcast(const char*, mem_find( str, 0, max_len ));
if ( end ) if ( end )
@ -213,9 +213,9 @@ ssize str_len_capped( const char* str, ssize max_len )
} }
inline inline
char* str_reverse( char* str ) char* c_str_reverse( char* str )
{ {
ssize len = str_len( str ); ssize len = c_str_len( str );
char* a = str + 0; char* a = str + 0;
char* b = str + len - 1; char* b = str + len - 1;
len /= 2; len /= 2;
@ -228,7 +228,7 @@ char* str_reverse( char* str )
} }
inline inline
char const* str_skip( char const* str, char c ) char const* c_str_skip( char const* str, char c )
{ {
while ( *str && *str != c ) while ( *str && *str != c )
{ {
@ -238,20 +238,20 @@ char const* str_skip( char const* str, char c )
} }
inline inline
char const* str_skip_any( char const* str, char const* char_list ) char const* c_str_skip_any( char const* str, char const* char_list )
{ {
char const* closest_ptr = rcast( char const*, pointer_add_const( rcast(mem_ptr_const, str), str_len( str ) )); char const* closest_ptr = rcast( char const*, pointer_add_const( rcast(mem_ptr_const, str), c_str_len( str ) ));
ssize char_list_count = str_len( char_list ); ssize char_list_count = c_str_len( char_list );
for ( ssize i = 0; i < char_list_count; i++ ) for ( ssize i = 0; i < char_list_count; i++ )
{ {
char const* p = str_skip( str, char_list[ i ] ); char const* p = c_str_skip( str, char_list[ i ] );
closest_ptr = min( closest_ptr, p ); closest_ptr = min( closest_ptr, p );
} }
return closest_ptr; return closest_ptr;
} }
inline inline
char const* str_trim( char const* str, b32 catch_newline ) char const* c_str_trim( char const* str, b32 catch_newline )
{ {
while ( *str && char_is_space( *str ) && ( ! catch_newline || ( catch_newline && *str != '\n' ) ) ) while ( *str && char_is_space( *str ) && ( ! catch_newline || ( catch_newline && *str != '\n' ) ) )
{ {
@ -261,7 +261,7 @@ char const* str_trim( char const* str, b32 catch_newline )
} }
inline inline
void str_to_lower( char* str ) void c_str_to_lower( char* str )
{ {
if ( ! str ) if ( ! str )
return; return;
@ -273,7 +273,7 @@ void str_to_lower( char* str )
} }
inline inline
void str_to_upper( char* str ) void c_str_to_upper( char* str )
{ {
if ( ! str ) if ( ! str )
return; return;

View File

@ -3,27 +3,27 @@
# include "hashing.cpp" # include "hashing.cpp"
#endif #endif
#pragma region String #pragma region StrBuilder
String string_make_length( AllocatorInfo allocator, char const* str, ssize length ) StrBuilder strbuilder_make_length( AllocatorInfo allocator, char const* str, ssize length )
{ {
ssize const header_size = sizeof( StringHeader ); ssize const header_size = sizeof( StrBuilderHeader );
s32 alloc_size = header_size + length + 1; s32 alloc_size = header_size + length + 1;
void* allocation = alloc( allocator, alloc_size ); void* allocation = alloc( allocator, alloc_size );
if ( allocation == nullptr ) { if ( allocation == nullptr ) {
String null_string = {nullptr}; StrBuilder null_string = {nullptr};
return null_string; return null_string;
} }
StringHeader* StrBuilderHeader*
header = rcast(StringHeader*, allocation); header = rcast(StrBuilderHeader*, allocation);
header->Allocator = allocator; header->Allocator = allocator;
header->Capacity = length; header->Capacity = length;
header->Length = length; header->Length = length;
String result = { rcast( char*, allocation) + header_size }; StrBuilder result = { rcast( char*, allocation) + header_size };
if ( length && str ) if ( length && str )
mem_copy( result, str, length ); mem_copy( result, str, length );
@ -35,27 +35,27 @@ String string_make_length( AllocatorInfo allocator, char const* str, ssize lengt
return result; return result;
} }
String string_make_reserve( AllocatorInfo allocator, ssize capacity ) StrBuilder strbuilder_make_reserve( AllocatorInfo allocator, ssize capacity )
{ {
ssize const header_size = sizeof( StringHeader ); ssize const header_size = sizeof( StrBuilderHeader );
s32 alloc_size = header_size + capacity + 1; s32 alloc_size = header_size + capacity + 1;
void* allocation = alloc( allocator, alloc_size ); void* allocation = alloc( allocator, alloc_size );
if ( allocation == nullptr ) { if ( allocation == nullptr ) {
String null_string = {nullptr}; StrBuilder null_string = {nullptr};
return null_string; return null_string;
} }
mem_set( allocation, 0, alloc_size ); mem_set( allocation, 0, alloc_size );
StringHeader* StrBuilderHeader*
header = rcast(StringHeader*, allocation); header = rcast(StrBuilderHeader*, allocation);
header->Allocator = allocator; header->Allocator = allocator;
header->Capacity = capacity; header->Capacity = capacity;
header->Length = 0; header->Length = 0;
String result = { rcast(char*, allocation) + header_size }; StrBuilder result = { rcast(char*, allocation) + header_size };
return result; return result;
} }
#pragma endregion String #pragma endregion StrBuilder

View File

@ -5,61 +5,61 @@
#pragma region Strings #pragma region Strings
struct StrC; struct Str;
StrC to_strc_from_c_str (char const* bad_string); Str to_str_from_c_str (char const* bad_string);
bool strc_are_equal (StrC lhs, StrC rhs); bool str_are_equal (Str lhs, Str rhs);
char const* strc_back (StrC str); char const* str_back (Str str);
bool strc_contains (StrC str, StrC substring); bool str_contains (Str str, Str substring);
StrC strc_duplicate (StrC str, AllocatorInfo allocator); Str str_duplicate (Str str, AllocatorInfo allocator);
b32 strc_starts_with (StrC str, StrC substring); b32 str_starts_with (Str str, Str substring);
StrC strc_visualize_whitespace(StrC str, AllocatorInfo allocator); Str str_visualize_whitespace(Str str, AllocatorInfo allocator);
// Constant string with length. // Constant string with length.
struct StrC struct Str
{ {
ssize Len;
char const* Ptr; char const* Ptr;
ssize Len;
#if GEN_COMPILER_CPP #if GEN_COMPILER_CPP
forceinline operator char const* () const { return Ptr; } forceinline operator char const* () const { return Ptr; }
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 strc_are_equal(* this, rhs); } forceinline bool is_equal (Str rhs) const { return str_are_equal(* this, rhs); }
forceinline char const* back () const { return strc_back(* this); } forceinline char const* back () const { return str_back(* this); }
forceinline bool contains (StrC substring) const { return strc_contains(* this, substring); } forceinline bool contains (Str substring) const { return str_contains(* this, substring); }
forceinline StrC duplicate (AllocatorInfo allocator) const { return strc_duplicate(* this, allocator); } forceinline Str duplicate (AllocatorInfo allocator) const { return str_duplicate(* this, allocator); }
forceinline b32 starts_with (StrC substring) const { return strc_starts_with(* this, substring); } forceinline b32 starts_with (Str substring) const { return str_starts_with(* this, substring); }
forceinline StrC visualize_whitespace(AllocatorInfo allocator) const { return strc_visualize_whitespace(* this, allocator); } forceinline Str visualize_whitespace(AllocatorInfo allocator) const { return str_visualize_whitespace(* this, allocator); }
#endif #endif
#endif #endif
}; };
#define cast_to_strc( str ) * rcast( StrC*, (str) - sizeof(ssize) ) #define cast_to_str( str ) * rcast( Str*, (str) - sizeof(ssize) )
#ifndef txt #ifndef txt
# if GEN_COMPILER_CPP # if GEN_COMPILER_CPP
# define txt( text ) StrC { sizeof( text ) - 1, ( text ) } # define txt( text ) Str { ( text ), sizeof( text ) - 1 }
# else # else
# define txt( text ) (StrC){ sizeof( text ) - 1, ( text ) } # define txt( text ) (Str){ ( text ), sizeof( text ) - 1 }
# endif # endif
#endif #endif
GEN_API_C_BEGIN GEN_API_C_BEGIN
forceinline char const* strc_begin(StrC str) { return str.Ptr; } forceinline char const* str_begin(Str str) { return str.Ptr; }
forceinline char const* strc_end (StrC str) { return str.Ptr + str.Len; } forceinline char const* str_end (Str str) { return str.Ptr + str.Len; }
forceinline char const* strc_next (StrC str, char const* iter) { return iter + 1; } forceinline char const* str_next (Str str, char const* iter) { return iter + 1; }
GEN_API_C_END GEN_API_C_END
#if GEN_COMPILER_CPP #if GEN_COMPILER_CPP
forceinline char const* begin(StrC str) { return str.Ptr; } forceinline char const* begin(Str str) { return str.Ptr; }
forceinline char const* end (StrC str) { return str.Ptr + str.Len; } forceinline char const* end (Str str) { return str.Ptr + str.Len; }
forceinline char const* next (StrC str, char const* iter) { return iter + 1; } forceinline char const* next (Str str, char const* iter) { return iter + 1; }
#endif #endif
inline inline
bool strc_are_equal(StrC lhs, StrC rhs) bool str_are_equal(Str lhs, Str rhs)
{ {
if (lhs.Len != rhs.Len) if (lhs.Len != rhs.Len)
return false; return false;
@ -72,12 +72,12 @@ bool strc_are_equal(StrC lhs, StrC rhs)
} }
inline inline
char const* strc_back(StrC str) { char const* str_back(Str str) {
return & str.Ptr[str.Len - 1]; return & str.Ptr[str.Len - 1];
} }
inline inline
bool strc_contains(StrC str, StrC substring) bool str_contains(Str str, Str substring)
{ {
if (substring.Len > str.Len) if (substring.Len > str.Len)
return false; return false;
@ -86,97 +86,97 @@ bool strc_contains(StrC str, StrC substring)
ssize sub_len = substring.Len; ssize sub_len = substring.Len;
for (ssize idx = 0; idx <= main_len - sub_len; ++idx) for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
{ {
if (str_compare_len(str.Ptr + idx, substring.Ptr, sub_len) == 0) if (c_str_compare_len(str.Ptr + idx, substring.Ptr, sub_len) == 0)
return true; return true;
} }
return false; return false;
} }
inline inline
b32 strc_starts_with(StrC str, StrC substring) { b32 str_starts_with(Str str, Str substring) {
if (substring.Len > str.Len) if (substring.Len > str.Len)
return false; return false;
b32 result = str_compare_len(str.Ptr, substring.Ptr, substring.Len) == 0; b32 result = c_str_compare_len(str.Ptr, substring.Ptr, substring.Len) == 0;
return result; return result;
} }
inline inline
StrC to_strc_from_c_str( char const* bad_str ) { Str to_str_from_c_str( char const* bad_str ) {
StrC result = { str_len( bad_str ), bad_str }; Str result = { bad_str, c_str_len( bad_str ) };
return result; return result;
} }
// Dynamic String // Dynamic StrBuilder
// This is directly based off the ZPL string api. // This is directly based off the ZPL string api.
// 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 StrBuilder
struct StringHeader; struct StrBuilderHeader;
#if GEN_COMPILER_C #if GEN_COMPILER_C
typedef char* String; typedef char* StrBuilder;
#else #else
struct String; struct StrBuilder;
#endif #endif
forceinline usize string_grow_formula(usize value); forceinline usize strbuilder_grow_formula(usize value);
String string_make_c_str (AllocatorInfo allocator, char const* str); StrBuilder strbuilder_make_c_str (AllocatorInfo allocator, char const* str);
String string_make_strc (AllocatorInfo allocator, StrC str); StrBuilder strbuilder_make_str (AllocatorInfo allocator, Str str);
String string_make_reserve (AllocatorInfo allocator, ssize capacity); StrBuilder strbuilder_make_reserve (AllocatorInfo allocator, ssize capacity);
String string_make_length (AllocatorInfo allocator, char const* str, ssize length); StrBuilder strbuilder_make_length (AllocatorInfo allocator, char const* str, ssize length);
String string_fmt (AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...); StrBuilder strbuilder_fmt (AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...);
String string_fmt_buf (AllocatorInfo allocator, char const* fmt, ...); StrBuilder strbuilder_fmt_buf (AllocatorInfo allocator, char const* fmt, ...);
String string_join (AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue); StrBuilder strbuilder_join (AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue);
bool string_are_equal (String const lhs, String const rhs); bool strbuilder_are_equal (StrBuilder const lhs, StrBuilder const rhs);
bool string_are_equal_strc (String const lhs, StrC rhs); bool strbuilder_are_equal_str (StrBuilder const lhs, Str rhs);
bool string_make_space_for (String* str, char const* to_append, ssize add_len); bool strbuilder_make_space_for (StrBuilder* str, char const* to_append, ssize add_len);
bool string_append_char (String* str, char c); bool strbuilder_append_char (StrBuilder* str, char c);
bool string_append_c_str (String* str, char const* str_to_append); bool strbuilder_append_c_str (StrBuilder* str, char const* c_str_to_append);
bool string_append_c_str_len (String* str, char const* str_to_append, ssize length); bool strbuilder_append_c_str_len (StrBuilder* str, char const* c_str_to_append, ssize length);
bool string_append_strc (String* str, StrC str_to_append); bool strbuilder_append_str (StrBuilder* str, Str c_str_to_append);
bool string_append_string (String* str, String const other); bool strbuilder_append_string (StrBuilder* str, StrBuilder const other);
bool string_append_fmt (String* str, char const* fmt, ...); bool strbuilder_append_fmt (StrBuilder* str, char const* fmt, ...);
ssize string_avail_space (String const str); ssize strbuilder_avail_space (StrBuilder const str);
char* string_back (String str); char* strbuilder_back (StrBuilder str);
bool string_contains_strc (String const str, StrC substring); bool strbuilder_contains_str (StrBuilder const str, Str substring);
bool string_contains_string (String const str, String const substring); bool strbuilder_contains_string (StrBuilder const str, StrBuilder const substring);
ssize string_capacity (String const str); ssize strbuilder_capacity (StrBuilder const str);
void string_clear (String str); void strbuilder_clear (StrBuilder str);
String string_duplicate (String const str, AllocatorInfo allocator); StrBuilder strbuilder_duplicate (StrBuilder const str, AllocatorInfo allocator);
void string_free (String* str); void strbuilder_free (StrBuilder* str);
StringHeader* string_get_header (String str); StrBuilderHeader* strbuilder_get_header (StrBuilder str);
ssize string_length (String const str); ssize strbuilder_length (StrBuilder const str);
b32 string_starts_with_strc (String const str, StrC substring); b32 strbuilder_starts_with_str (StrBuilder const str, Str substring);
b32 string_starts_with_string (String const str, String substring); b32 strbuilder_starts_with_string (StrBuilder const str, StrBuilder substring);
void string_skip_line (String str); void strbuilder_skip_line (StrBuilder str);
void string_strip_space (String str); void strbuilder_strip_space (StrBuilder str);
StrC string_to_strc (String str); Str strbuilder_to_str (StrBuilder str);
void string_trim (String str, char const* cut_set); void strbuilder_trim (StrBuilder str, char const* cut_set);
void string_trim_space (String str); void strbuilder_trim_space (StrBuilder str);
String string_visualize_whitespace(String const str); StrBuilder strbuilder_visualize_whitespace(StrBuilder const str);
struct StringHeader { struct StrBuilderHeader {
AllocatorInfo Allocator; AllocatorInfo Allocator;
ssize Capacity; ssize Capacity;
ssize Length; ssize Length;
}; };
#if GEN_COMPILER_CPP #if GEN_COMPILER_CPP
struct String struct StrBuilder
{ {
char* Data; char* Data;
forceinline operator char*() { return Data; } forceinline operator char*() { return Data; }
forceinline operator char const*() const { return Data; } forceinline operator char const*() const { return Data; }
forceinline operator StrC() const { return { string_length(* this), Data }; } forceinline operator Str() const { return { Data, strbuilder_length(* this) }; }
String const& operator=(String const& other) const { StrBuilder const& operator=(StrBuilder const& other) const {
if (this == &other) if (this == &other)
return *this; return *this;
String* this_ = ccast(String*, this); StrBuilder* this_ = ccast(StrBuilder*, this);
this_->Data = other.Data; this_->Data = other.Data;
return *this; return *this;
@ -185,69 +185,69 @@ struct String
forceinline char& operator[](ssize index) { return Data[index]; } forceinline char& operator[](ssize index) { return Data[index]; }
forceinline char const& operator[](ssize index) const { return Data[index]; } forceinline char const& operator[](ssize index) const { return Data[index]; }
forceinline bool operator==(std::nullptr_t) const { return Data == nullptr; } forceinline bool operator==(std::nullptr_t) const { return Data == nullptr; }
forceinline bool operator!=(std::nullptr_t) const { return Data != nullptr; } forceinline bool operator!=(std::nullptr_t) const { return Data != nullptr; }
friend forceinline bool operator==(std::nullptr_t, const String str) { return str.Data == nullptr; } friend forceinline bool operator==(std::nullptr_t, const StrBuilder str) { return str.Data == nullptr; }
friend forceinline bool operator!=(std::nullptr_t, const String str) { return str.Data != nullptr; } friend forceinline bool operator!=(std::nullptr_t, const StrBuilder str) { return str.Data != nullptr; }
#if ! GEN_C_LIKE_CPP #if ! GEN_C_LIKE_CPP
forceinline char* begin() const { return Data; } forceinline char* begin() const { return Data; }
forceinline char* end() const { return Data + string_length(* this); } forceinline char* end() const { return Data + strbuilder_length(* this); }
#pragma region Member Mapping #pragma region Member Mapping
forceinline static String make(AllocatorInfo allocator, char const* str) { return string_make_c_str(allocator, str); } forceinline static StrBuilder make(AllocatorInfo allocator, char const* str) { return strbuilder_make_c_str(allocator, str); }
forceinline static String make(AllocatorInfo allocator, StrC str) { return string_make_strc(allocator, str); } forceinline static StrBuilder make(AllocatorInfo allocator, Str str) { return strbuilder_make_str(allocator, str); }
forceinline static String make_reserve(AllocatorInfo allocator, ssize cap) { return string_make_reserve(allocator, cap); } forceinline static StrBuilder make_reserve(AllocatorInfo allocator, ssize cap) { return strbuilder_make_reserve(allocator, cap); }
forceinline static String make_length(AllocatorInfo a, char const* s, ssize l) { return string_make_length(a, s, l); } forceinline static StrBuilder make_length(AllocatorInfo a, char const* s, ssize l) { return strbuilder_make_length(a, s, l); }
forceinline static String join(AllocatorInfo a, char const** p, ssize n, char const* g) { return string_join(a, p, n, g); } forceinline static StrBuilder join(AllocatorInfo a, char const** p, ssize n, char const* g) { return strbuilder_join(a, p, n, g); }
forceinline static usize grow_formula(usize value) { return string_grow_formula(value); } forceinline static usize grow_formula(usize value) { return strbuilder_grow_formula(value); }
static static
String fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) { StrBuilder fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
ssize res = str_fmt_va(buf, buf_size, fmt, va) - 1; ssize res = c_str_fmt_va(buf, buf_size, fmt, va) - 1;
va_end(va); va_end(va);
return string_make_length(allocator, buf, res); return strbuilder_make_length(allocator, buf, res);
} }
static static
String fmt_buf(AllocatorInfo allocator, char const* fmt, ...) { StrBuilder fmt_buf(AllocatorInfo allocator, char const* fmt, ...) {
local_persist thread_local local_persist thread_local
char buf[GEN_PRINTF_MAXLEN] = { 0 }; char buf[GEN_PRINTF_MAXLEN] = { 0 };
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
ssize res = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) - 1; ssize res = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) - 1;
va_end(va); va_end(va);
return string_make_length(allocator, buf, res); return strbuilder_make_length(allocator, buf, res);
} }
forceinline bool make_space_for(char const* str, ssize add_len) { return string_make_space_for(this, str, add_len); } forceinline bool make_space_for(char const* str, ssize add_len) { return strbuilder_make_space_for(this, str, add_len); }
forceinline bool append(char c) { return string_append_char(this, c); } forceinline bool append(char c) { return strbuilder_append_char(this, c); }
forceinline bool append(char const* str) { return string_append_c_str(this, str); } forceinline bool append(char const* str) { return strbuilder_append_c_str(this, str); }
forceinline bool append(char const* str, ssize length) { return string_append_c_str_len(this, str, length); } forceinline bool append(char const* str, ssize length) { return strbuilder_append_c_str_len(this, str, length); }
forceinline bool append(StrC str) { return string_append_strc(this, str); } forceinline bool append(Str str) { return strbuilder_append_str(this, str); }
forceinline bool append(const String other) { return string_append_string(this, other); } forceinline bool append(const StrBuilder other) { return strbuilder_append_string(this, other); }
forceinline ssize avail_space() const { return string_avail_space(* this); } forceinline ssize avail_space() const { return strbuilder_avail_space(* this); }
forceinline char* back() { return string_back(* this); } forceinline char* back() { return strbuilder_back(* this); }
forceinline bool contains(StrC substring) const { return string_contains_strc(* this, substring); } forceinline bool contains(Str substring) const { return strbuilder_contains_str(* this, substring); }
forceinline bool contains(String const& substring) const { return string_contains_string(* this, substring); } forceinline bool contains(StrBuilder const& substring) const { return strbuilder_contains_string(* this, substring); }
forceinline ssize capacity() const { return string_capacity(* this); } forceinline ssize capacity() const { return strbuilder_capacity(* this); }
forceinline void clear() { string_clear(* this); } forceinline void clear() { strbuilder_clear(* this); }
forceinline String duplicate(AllocatorInfo allocator) const { return string_duplicate(* this, allocator); } forceinline StrBuilder duplicate(AllocatorInfo allocator) const { return strbuilder_duplicate(* this, allocator); }
forceinline void free() { string_free(this); } forceinline void free() { strbuilder_free(this); }
forceinline bool is_equal(String const& other) const { return string_are_equal(* this, other); } forceinline bool is_equal(StrBuilder const& other) const { return strbuilder_are_equal(* this, other); }
forceinline bool is_equal(StrC other) const { return string_are_equal_strc(* this, other); } forceinline bool is_equal(Str other) const { return strbuilder_are_equal_str(* this, other); }
forceinline ssize length() const { return string_length(* this); } forceinline ssize length() const { return strbuilder_length(* this); }
forceinline b32 starts_with(StrC substring) const { return string_starts_with_strc(* this, substring); } forceinline b32 starts_with(Str substring) const { return strbuilder_starts_with_str(* this, substring); }
forceinline b32 starts_with(String substring) const { return string_starts_with_string(* this, substring); } forceinline b32 starts_with(StrBuilder substring) const { return strbuilder_starts_with_string(* this, substring); }
forceinline void skip_line() { string_skip_line(* this); } forceinline void skip_line() { strbuilder_skip_line(* this); }
forceinline void strip_space() { string_strip_space(* this); } forceinline void strip_space() { strbuilder_strip_space(* this); }
forceinline StrC to_strc() { return { string_length(*this), Data}; } forceinline Str to_str() { return { Data, strbuilder_length(*this) }; }
forceinline void trim(char const* cut_set) { string_trim(* this, cut_set); } forceinline void trim(char const* cut_set) { strbuilder_trim(* this, cut_set); }
forceinline void trim_space() { string_trim_space(* this); } forceinline void trim_space() { strbuilder_trim_space(* this); }
forceinline String visualize_whitespace() const { return string_visualize_whitespace(* this); } forceinline StrBuilder visualize_whitespace() const { return strbuilder_visualize_whitespace(* this); }
forceinline StringHeader& get_header() { return * string_get_header(* this); } forceinline StrBuilderHeader& get_header() { return * strbuilder_get_header(* this); }
bool append_fmt(char const* fmt, ...) { bool append_fmt(char const* fmt, ...) {
ssize res; ssize res;
@ -255,163 +255,163 @@ struct String
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
res = str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1; res = c_str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
va_end(va); va_end(va);
return string_append_c_str_len(this, buf, res); return strbuilder_append_c_str_len(this, buf, res);
} }
#pragma endregion Member Mapping #pragma endregion Member Mapping
#endif #endif
}; };
#endif #endif
forceinline char* string_begin(String str) { return ((char*) str); } forceinline char* strbuilder_begin(StrBuilder str) { return ((char*) str); }
forceinline char* string_end (String str) { return ((char*) str + string_length(str)); } forceinline char* strbuilder_end (StrBuilder str) { return ((char*) str + strbuilder_length(str)); }
forceinline char* string_next (String str, char const* iter) { return ((char*) iter + 1); } forceinline char* strbuilder_next (StrBuilder str, char const* iter) { return ((char*) iter + 1); }
#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(StrBuilder str) { return ((char*) str); }
forceinline char* end (String str) { return ((char*) str + string_length(str)); } forceinline char* end (StrBuilder str) { return ((char*) str + strbuilder_length(str)); }
forceinline char* next (String str, char* iter) { return ((char*) iter + 1); } forceinline char* next (StrBuilder str, char* iter) { return ((char*) iter + 1); }
#endif #endif
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP #if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
forceinline bool make_space_for(String& str, char const* to_append, ssize add_len); forceinline bool make_space_for(StrBuilder& str, char const* to_append, ssize add_len);
forceinline bool append(String& str, char c); forceinline bool append(StrBuilder& str, char c);
forceinline bool append(String& str, char const* str_to_append); forceinline bool append(StrBuilder& str, char const* c_str_to_append);
forceinline bool append(String& str, char const* str_to_append, ssize length); forceinline bool append(StrBuilder& str, char const* c_str_to_append, ssize length);
forceinline bool append(String& str, StrC str_to_append); forceinline bool append(StrBuilder& str, Str c_str_to_append);
forceinline bool append(String& str, const String other); forceinline bool append(StrBuilder& str, const StrBuilder other);
forceinline bool append_fmt(String& str, char const* fmt, ...); forceinline bool append_fmt(StrBuilder& str, char const* fmt, ...);
forceinline char& back(String& str); forceinline char& back(StrBuilder& str);
forceinline void clear(String& str); forceinline void clear(StrBuilder& str);
forceinline void free(String& str); forceinline void free(StrBuilder& str);
#endif #endif
forceinline forceinline
usize string_grow_formula(usize value) { usize strbuilder_grow_formula(usize value) {
// Using a very aggressive growth formula to reduce time mem_copying with recursive calls to append in this library. // Using a very aggressive growth formula to reduce time mem_copying with recursive calls to append in this library.
return 4 * value + 8; return 4 * value + 8;
} }
forceinline forceinline
String string_make_c_str(AllocatorInfo allocator, char const* str) { StrBuilder strbuilder_make_c_str(AllocatorInfo allocator, char const* str) {
ssize length = str ? str_len(str) : 0; ssize length = str ? c_str_len(str) : 0;
return string_make_length(allocator, str, length); return strbuilder_make_length(allocator, str, length);
} }
forceinline forceinline
String string_make_strc(AllocatorInfo allocator, StrC str) { StrBuilder strbuilder_make_str(AllocatorInfo allocator, Str str) {
return string_make_length(allocator, str.Ptr, str.Len); return strbuilder_make_length(allocator, str.Ptr, str.Len);
} }
inline inline
String string_fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) { StrBuilder strbuilder_fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) {
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
ssize res = str_fmt_va(buf, buf_size, fmt, va) - 1; ssize res = c_str_fmt_va(buf, buf_size, fmt, va) - 1;
va_end(va); va_end(va);
return string_make_length(allocator, buf, res); return strbuilder_make_length(allocator, buf, res);
} }
inline inline
String string_fmt_buf(AllocatorInfo allocator, char const* fmt, ...) StrBuilder strbuilder_fmt_buf(AllocatorInfo allocator, char const* fmt, ...)
{ {
local_persist thread_local local_persist thread_local
PrintF_Buffer buf = struct_init(PrintF_Buffer, {0}); PrintF_Buffer buf = struct_init(PrintF_Buffer, {0});
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
ssize res = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) -1; ssize res = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) -1;
va_end(va); va_end(va);
return string_make_length(allocator, buf, res); return strbuilder_make_length(allocator, buf, res);
} }
inline inline
String string_join(AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue) StrBuilder strbuilder_join(AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue)
{ {
String result = string_make_c_str(allocator, ""); StrBuilder result = strbuilder_make_c_str(allocator, "");
for (ssize idx = 0; idx < num_parts; ++idx) for (ssize idx = 0; idx < num_parts; ++idx)
{ {
string_append_c_str(& result, parts[idx]); strbuilder_append_c_str(& result, parts[idx]);
if (idx < num_parts - 1) if (idx < num_parts - 1)
string_append_c_str(& result, glue); strbuilder_append_c_str(& result, glue);
} }
return result; return result;
} }
forceinline forceinline
bool string_append_char(String* str, char c) { bool strbuilder_append_char(StrBuilder* str, char c) {
GEN_ASSERT(str != nullptr); GEN_ASSERT(str != nullptr);
return string_append_c_str_len( str, (char const*)& c, (ssize)1); return strbuilder_append_c_str_len( str, (char const*)& c, (ssize)1);
} }
forceinline forceinline
bool string_append_c_str(String* str, char const* str_to_append) { bool strbuilder_append_c_str(StrBuilder* str, char const* c_str_to_append) {
GEN_ASSERT(str != nullptr); GEN_ASSERT(str != nullptr);
return string_append_c_str_len(str, str_to_append, str_len(str_to_append)); return strbuilder_append_c_str_len(str, c_str_to_append, c_str_len(c_str_to_append));
} }
inline inline
bool string_append_c_str_len(String* str, char const* str_to_append, ssize append_length) bool strbuilder_append_c_str_len(StrBuilder* str, char const* c_str_to_append, ssize append_length)
{ {
GEN_ASSERT(str != nullptr); GEN_ASSERT(str != nullptr);
if ( rcast(sptr, str_to_append) > 0) if ( rcast(sptr, c_str_to_append) > 0)
{ {
ssize curr_len = string_length(* str); ssize curr_len = strbuilder_length(* str);
if ( ! string_make_space_for(str, str_to_append, append_length)) if ( ! strbuilder_make_space_for(str, c_str_to_append, append_length))
return false; return false;
StringHeader* header = string_get_header(* str); StrBuilderHeader* header = strbuilder_get_header(* str);
char* Data = * str; char* Data = * str;
mem_copy( Data + curr_len, str_to_append, append_length); mem_copy( Data + curr_len, c_str_to_append, append_length);
Data[curr_len + append_length] = '\0'; Data[curr_len + append_length] = '\0';
header->Length = curr_len + append_length; header->Length = curr_len + append_length;
} }
return str_to_append != nullptr; return c_str_to_append != nullptr;
} }
forceinline forceinline
bool string_append_strc(String* str, StrC str_to_append) { bool strbuilder_append_str(StrBuilder* str, Str c_str_to_append) {
GEN_ASSERT(str != nullptr); GEN_ASSERT(str != nullptr);
return string_append_c_str_len(str, str_to_append.Ptr, str_to_append.Len); return strbuilder_append_c_str_len(str, c_str_to_append.Ptr, c_str_to_append.Len);
} }
forceinline forceinline
bool string_append_string(String* str, String const other) { bool strbuilder_append_string(StrBuilder* str, StrBuilder const other) {
GEN_ASSERT(str != nullptr); GEN_ASSERT(str != nullptr);
return string_append_c_str_len(str, (char const*)other, string_length(other)); return strbuilder_append_c_str_len(str, (char const*)other, strbuilder_length(other));
} }
bool string_append_fmt(String* str, char const* fmt, ...) { bool strbuilder_append_fmt(StrBuilder* str, char const* fmt, ...) {
GEN_ASSERT(str != nullptr); GEN_ASSERT(str != nullptr);
ssize res; ssize res;
char buf[GEN_PRINTF_MAXLEN] = { 0 }; char buf[GEN_PRINTF_MAXLEN] = { 0 };
va_list va; va_list va;
va_start(va, fmt); va_start(va, fmt);
res = str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1; res = c_str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1;
va_end(va); va_end(va);
return string_append_c_str_len(str, (char const*)buf, res); return strbuilder_append_c_str_len(str, (char const*)buf, res);
} }
inline inline
bool string_are_equal_string(String const lhs, String const rhs) bool strbuilder_are_equal_string(StrBuilder const lhs, StrBuilder const rhs)
{ {
if (string_length(lhs) != string_length(rhs)) if (strbuilder_length(lhs) != strbuilder_length(rhs))
return false; return false;
for (ssize idx = 0; idx < string_length(lhs); ++idx) for (ssize idx = 0; idx < strbuilder_length(lhs); ++idx)
if (lhs[idx] != rhs[idx]) if (lhs[idx] != rhs[idx])
return false; return false;
@ -419,12 +419,12 @@ bool string_are_equal_string(String const lhs, String const rhs)
} }
inline inline
bool string_are_equal_strc(String const lhs, StrC rhs) bool strbuilder_are_equal_str(StrBuilder const lhs, Str rhs)
{ {
if (string_length(lhs) != (rhs.Len)) if (strbuilder_length(lhs) != (rhs.Len))
return false; return false;
for (ssize idx = 0; idx < string_length(lhs); ++idx) for (ssize idx = 0; idx < strbuilder_length(lhs); ++idx)
if (lhs[idx] != rhs.Ptr[idx]) if (lhs[idx] != rhs.Ptr[idx])
return false; return false;
@ -432,20 +432,20 @@ bool string_are_equal_strc(String const lhs, StrC rhs)
} }
forceinline forceinline
ssize string_avail_space(String const str) { ssize strbuilder_avail_space(StrBuilder const str) {
StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader)); StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
return header->Capacity - header->Length; return header->Capacity - header->Length;
} }
forceinline forceinline
char* string_back(String str) { char* strbuilder_back(StrBuilder str) {
return & (str)[string_length(str) - 1]; return & (str)[strbuilder_length(str) - 1];
} }
inline inline
bool string_contains_StrC(String const str, StrC substring) bool strbuilder_contains_StrC(StrBuilder const str, Str substring)
{ {
StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader)); StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
if (substring.Len > header->Length) if (substring.Len > header->Length)
return false; return false;
@ -455,7 +455,7 @@ bool string_contains_StrC(String const str, StrC substring)
for (ssize idx = 0; idx <= main_len - sub_len; ++idx) for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
{ {
if (str_compare_len(str + idx, substring.Ptr, sub_len) == 0) if (c_str_compare_len(str + idx, substring.Ptr, sub_len) == 0)
return true; return true;
} }
@ -463,19 +463,19 @@ bool string_contains_StrC(String const str, StrC substring)
} }
inline inline
bool string_contains_string(String const str, String const substring) bool strbuilder_contains_string(StrBuilder const str, StrBuilder const substring)
{ {
StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader)); StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
if (string_length(substring) > header->Length) if (strbuilder_length(substring) > header->Length)
return false; return false;
ssize main_len = header->Length; ssize main_len = header->Length;
ssize sub_len = string_length(substring); ssize sub_len = strbuilder_length(substring);
for (ssize idx = 0; idx <= main_len - sub_len; ++idx) for (ssize idx = 0; idx <= main_len - sub_len; ++idx)
{ {
if (str_compare_len(str + idx, substring, sub_len) == 0) if (c_str_compare_len(str + idx, substring, sub_len) == 0)
return true; return true;
} }
@ -483,47 +483,47 @@ bool string_contains_string(String const str, String const substring)
} }
forceinline forceinline
ssize string_capacity(String const str) { ssize strbuilder_capacity(StrBuilder const str) {
StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader)); StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
return header->Capacity; return header->Capacity;
} }
forceinline forceinline
void string_clear(String str) { void strbuilder_clear(StrBuilder str) {
string_get_header(str)->Length = 0; strbuilder_get_header(str)->Length = 0;
} }
forceinline forceinline
String string_duplicate(String const str, AllocatorInfo allocator) { StrBuilder strbuilder_duplicate(StrBuilder const str, AllocatorInfo allocator) {
return string_make_length(allocator, str, string_length(str)); return strbuilder_make_length(allocator, str, strbuilder_length(str));
} }
forceinline forceinline
void string_free(String* str) { void strbuilder_free(StrBuilder* str) {
GEN_ASSERT(str != nullptr); GEN_ASSERT(str != nullptr);
if (! (* str)) if (! (* str))
return; return;
StringHeader* header = string_get_header(* str); StrBuilderHeader* header = strbuilder_get_header(* str);
allocator_free(header->Allocator, header); allocator_free(header->Allocator, header);
} }
forceinline forceinline
StringHeader* string_get_header(String str) { StrBuilderHeader* strbuilder_get_header(StrBuilder str) {
return (StringHeader*)(scast(char*, str) - sizeof(StringHeader)); return (StrBuilderHeader*)(scast(char*, str) - sizeof(StrBuilderHeader));
} }
forceinline forceinline
ssize string_length(String const str) ssize strbuilder_length(StrBuilder const str)
{ {
StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader)); StrBuilderHeader const* header = rcast(StrBuilderHeader const*, scast(char const*, str) - sizeof(StrBuilderHeader));
return header->Length; return header->Length;
} }
inline inline
bool string_make_space_for(String* str, char const* to_append, ssize add_len) bool strbuilder_make_space_for(StrBuilder* str, char const* to_append, ssize add_len)
{ {
ssize available = string_avail_space(* str); ssize available = strbuilder_avail_space(* str);
if (available >= add_len) { if (available >= add_len) {
return true; return true;
@ -534,20 +534,20 @@ bool string_make_space_for(String* str, char const* to_append, ssize add_len)
void* ptr; void* ptr;
void* new_ptr; void* new_ptr;
AllocatorInfo allocator = string_get_header(* str)->Allocator; AllocatorInfo allocator = strbuilder_get_header(* str)->Allocator;
StringHeader* header = nullptr; StrBuilderHeader* header = nullptr;
new_len = string_grow_formula(string_length(* str) + add_len); new_len = strbuilder_grow_formula(strbuilder_length(* str) + add_len);
ptr = string_get_header(* str); ptr = strbuilder_get_header(* str);
old_size = size_of(StringHeader) + string_length(* str) + 1; old_size = size_of(StrBuilderHeader) + strbuilder_length(* str) + 1;
new_size = size_of(StringHeader) + new_len + 1; new_size = size_of(StrBuilderHeader) + new_len + 1;
new_ptr = resize(allocator, ptr, old_size, new_size); new_ptr = resize(allocator, ptr, old_size, new_size);
if (new_ptr == nullptr) if (new_ptr == nullptr)
return false; return false;
header = rcast(StringHeader*, new_ptr); header = rcast(StrBuilderHeader*, new_ptr);
header->Allocator = allocator; header->Allocator = allocator;
header->Capacity = new_len; header->Capacity = new_len;
@ -559,25 +559,25 @@ bool string_make_space_for(String* str, char const* to_append, ssize add_len)
} }
forceinline forceinline
b32 string_starts_with_strc(String const str, StrC substring) { b32 strbuilder_starts_with_str(StrBuilder const str, Str substring) {
if (substring.Len > string_length(str)) if (substring.Len > strbuilder_length(str))
return false; return false;
b32 result = str_compare_len(str, substring.Ptr, substring.Len) == 0; b32 result = c_str_compare_len(str, substring.Ptr, substring.Len) == 0;
return result; return result;
} }
forceinline forceinline
b32 string_starts_with_string(String const str, String substring) { b32 strbuilder_starts_with_string(StrBuilder const str, StrBuilder substring) {
if (string_length(substring) > string_length(str)) if (strbuilder_length(substring) > strbuilder_length(str))
return false; return false;
b32 result = str_compare_len(str, substring, string_length(substring) - 1) == 0; b32 result = c_str_compare_len(str, substring, strbuilder_length(substring) - 1) == 0;
return result; return result;
} }
inline inline
void string_skip_line(String str) void strbuilder_skip_line(StrBuilder str)
{ {
#define current (*scanner) #define current (*scanner)
char* scanner = str; char* scanner = str;
@ -593,13 +593,13 @@ void string_skip_line(String str)
mem_move((char*)str, scanner, new_length); mem_move((char*)str, scanner, new_length);
StringHeader* header = string_get_header(str); StrBuilderHeader* header = strbuilder_get_header(str);
header->Length = new_length; header->Length = new_length;
#undef current #undef current
} }
inline inline
void strip_space(String str) void strip_space(StrBuilder str)
{ {
char* write_pos = str; char* write_pos = str;
char* read_pos = str; char* read_pos = str;
@ -616,22 +616,22 @@ void strip_space(String str)
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
string_get_header(str)->Length = write_pos - str; strbuilder_get_header(str)->Length = write_pos - str;
} }
forceinline forceinline
StrC string_to_strc(String str) { Str strbuilder_to_str(StrBuilder str) {
StrC result = { string_length(str), (char const*)str }; Str result = { (char const*)str, strbuilder_length(str) };
return result; return result;
} }
inline inline
void string_trim(String str, char const* cut_set) void strbuilder_trim(StrBuilder str, char const* cut_set)
{ {
ssize len = 0; ssize len = 0;
char* start_pos = str; char* start_pos = str;
char* end_pos = scast(char*, str) + string_length(str) - 1; char* end_pos = scast(char*, str) + strbuilder_length(str) - 1;
while (start_pos <= end_pos && char_first_occurence(cut_set, *start_pos)) while (start_pos <= end_pos && char_first_occurence(cut_set, *start_pos))
start_pos++; start_pos++;
@ -646,99 +646,99 @@ void string_trim(String str, char const* cut_set)
str[len] = '\0'; str[len] = '\0';
string_get_header(str)->Length = len; strbuilder_get_header(str)->Length = len;
} }
forceinline forceinline
void string_trim_space(String str) { void strbuilder_trim_space(StrBuilder str) {
string_trim(str, " \t\r\n\v\f"); strbuilder_trim(str, " \t\r\n\v\f");
} }
inline inline
String string_visualize_whitespace(String const str) StrBuilder strbuilder_visualize_whitespace(StrBuilder const str)
{ {
StringHeader* header = (StringHeader*)(scast(char const*, str) - sizeof(StringHeader)); StrBuilderHeader* header = (StrBuilderHeader*)(scast(char const*, str) - sizeof(StrBuilderHeader));
String result = string_make_reserve(header->Allocator, string_length(str) * 2); // Assume worst case for space requirements. StrBuilder result = strbuilder_make_reserve(header->Allocator, strbuilder_length(str) * 2); // Assume worst case for space requirements.
for (char const* c = string_begin(str); c != string_end(str); c = string_next(str, c)) for (char const* c = strbuilder_begin(str); c != strbuilder_end(str); c = strbuilder_next(str, c))
switch ( * c ) switch ( * c )
{ {
case ' ': case ' ':
string_append_strc(& result, txt("·")); strbuilder_append_str(& result, txt("·"));
break; break;
case '\t': case '\t':
string_append_strc(& result, txt("")); strbuilder_append_str(& result, txt(""));
break; break;
case '\n': case '\n':
string_append_strc(& result, txt("")); strbuilder_append_str(& result, txt(""));
break; break;
case '\r': case '\r':
string_append_strc(& result, txt("")); strbuilder_append_str(& result, txt(""));
break; break;
case '\v': case '\v':
string_append_strc(& result, txt("")); strbuilder_append_str(& result, txt(""));
break; break;
case '\f': case '\f':
string_append_strc(& result, txt("")); strbuilder_append_str(& result, txt(""));
break; break;
default: default:
string_append_char(& result, * c); strbuilder_append_char(& result, * c);
break; break;
} }
return result; return result;
} }
#pragma endregion String #pragma endregion StrBuilder
#if GEN_COMPILER_CPP #if GEN_COMPILER_CPP
struct String_POD { struct StrBuilder_POD {
char* Data; char* Data;
}; };
static_assert( sizeof( String_POD ) == sizeof( String ), "String is not a POD" ); static_assert( sizeof( StrBuilder_POD ) == sizeof( StrBuilder ), "StrBuilder is not a POD" );
#endif #endif
forceinline forceinline
StrC strc_duplicate(StrC str, AllocatorInfo allocator) { Str str_duplicate(Str str, AllocatorInfo allocator) {
StrC result = string_to_strc( string_make_length(allocator, str.Ptr, str.Len)); Str result = strbuilder_to_str( strbuilder_make_length(allocator, str.Ptr, str.Len));
return result; return result;
} }
inline inline
StrC strc_visualize_whitespace(StrC str, AllocatorInfo allocator) Str str_visualize_whitespace(Str str, AllocatorInfo allocator)
{ {
String result = string_make_reserve(allocator, str.Len * 2); // Assume worst case for space requirements. StrBuilder result = strbuilder_make_reserve(allocator, str.Len * 2); // Assume worst case for space requirements.
for (char const* c = strc_begin(str); c != strc_end(str); c = strc_next(str, c)) for (char const* c = str_begin(str); c != str_end(str); c = str_next(str, c))
switch ( * c ) switch ( * c )
{ {
case ' ': case ' ':
string_append_strc(& result, txt("·")); strbuilder_append_str(& result, txt("·"));
break; break;
case '\t': case '\t':
string_append_strc(& result, txt("")); strbuilder_append_str(& result, txt(""));
break; break;
case '\n': case '\n':
string_append_strc(& result, txt("")); strbuilder_append_str(& result, txt(""));
break; break;
case '\r': case '\r':
string_append_strc(& result, txt("")); strbuilder_append_str(& result, txt(""));
break; break;
case '\v': case '\v':
string_append_strc(& result, txt("")); strbuilder_append_str(& result, txt(""));
break; break;
case '\f': case '\f':
string_append_strc(& result, txt("")); strbuilder_append_str(& result, txt(""));
break; break;
default: default:
string_append_char(& result, * c); strbuilder_append_char(& result, * c);
break; break;
} }
return string_to_strc(result); return strbuilder_to_str(result);
} }
// Represents strings cached with the string table. // Represents strings cached with the string table.
// Should never be modified, if changed string is desired, cache_string( str ) another. // Should never be modified, if changed string is desired, cache_string( str ) another.
typedef StrC StringCached; typedef Str StrCached;
// Implements basic string interning. Data structure is based off the ZPL Hashtable. // Implements basic string interning. Data structure is based off the ZPL Hashtable.
typedef HashTable(StringCached) StringTable; typedef HashTable(StrCached) StringTable;
#pragma endregion Strings #pragma endregion Strings

View File

@ -1,2 +1 @@
API_Export, GEN_API_Export_Code GEN_API, GEN_API
API_Import, GEN_API_Import_Code

1 API_Export GEN_API GEN_API_Export_Code GEN_API
API_Import GEN_API_Import_Code

View File

@ -31,7 +31,6 @@ GEN_NS_BEGIN
#include "components/interface.cpp" #include "components/interface.cpp"
#include "components/interface.upfront.cpp" #include "components/interface.upfront.cpp"
#include "components/gen/etoktype.cpp"
#include "components/lexer.cpp" #include "components/lexer.cpp"
#include "components/parser.cpp" #include "components/parser.cpp"
#include "components/interface.parsing.cpp" #include "components/interface.parsing.cpp"

View File

@ -20,6 +20,8 @@ GEN_NS_BEGIN
#include "components/gen/ecodetypes.hpp" #include "components/gen/ecodetypes.hpp"
#include "components/gen/eoperator.hpp" #include "components/gen/eoperator.hpp"
#include "components/gen/especifier.hpp" #include "components/gen/especifier.hpp"
#include "components/gen/etoktype.hpp"
#include "components/parser_types.hpp"
#include "components/ast.hpp" #include "components/ast.hpp"
#include "components/code_types.hpp" #include "components/code_types.hpp"

View File

@ -1,423 +0,0 @@
__VERSION 1
// This is a example template to be used with the refactor program
// Use it to refactor the naming convention of this library to your own.
// Can be used as an aid to help use use your project's implementation if it fullfills the dependencies of this project.
// Example: Most likely have a memory and string library already, just rename the functions and make sure the args are the same.
// Program: https://github.com/Ed94/refactor
// NOTE: Due to the current limitations of the program, not every symbol in the library can be renamed.
// This is due to the program not actually parsing C/C++.
// not : Ignore
// include : #includes
// word : Alphanumeric or underscore
// namespace : Prefix search and replace (c-namspaces).
// regex : Unavailable in __VERSION 1.
// Precedence (highest to lowest):
// word, namespace, regex
// TODO(ED): THIS IS VERY OUTDATED
// Gen Macro namespace
// namespace GEN_, new_namespace_
// ---------- Dependency Macros
// Platform
// word GEN_ARCH_64_BIT, new_name
// word GEN_ARCH_32_BIT, new_name
// word GEN_SYSTEM_ANDROID, new_name
// word GEN_SYSTEM_CYGWIN, new_name
// word GEN_SYSTEM_EMSCRIPTEN, new_name
// word GEN_SYSTEM_FREEBSD, new_name
// word GEN_SYSTEM_IOS, new_name
// word GEN_SYSTEM_LINUX, new_name
// word GEN_SYSTEM_MACOS, new_name
// word GEN_SYSTEM_OPENBSD, new_name
// word GEN_SYSTEM_OSX, new_name
// word GEN_SYSTEM_UNIX, new_name
// word GEN_SYSTEM_WINDOWS, new_name
// word GEN_COMPILER_CLANG, new_name
// word GEN_COMPILER_GCC, new_name
// word GEN_COMPILER_MINGW, new_name
// word GEN_COMPILER_MSVC, new_name
// word global, new_name
// word internal, new_name
// word local_persist, new_name
// word forceinline, new_name
// word neverinline, new_name
// word bit, new_name
// word bitfield_is_equal, new_name
// word ccast, new_name
// word pcast, new_name
// word rcast, new_name
// word scast, new_name
// word num_args, new_name
// word num_args_impl, new_name
// word stringize, new_name
// word stringize_va, new_name
// word do_once, new_name
// word do_once_start, new_name
// word do_once_end, new_name
// word label_scope_start, new_name
// word label_scope_end, new_name
// word count_of, new_name
// word is_between, new_name
// word min, new_name
// word size_of, new_name
// word offset_of, new_name
// word swap, new_name
// Basic Types
// word GEN_U8_MIN, new_name
// word GEN_U8_MAX, new_name
// word GEN_I8_MIN, new_name
// word GEN_I8_MAX, new_name
// word GEN_U16_MIN, new_name
// word GEN_U16_MAX, new_name
// word GEN_I16_MIN, new_name
// word GEN_I16_MAX, new_name
// word GEN_U32_MIN, new_name
// word GEN_U32_MAX, new_name
// word GEN_I32_MIN, new_name
// word GEN_I32_MAX, new_name
// word GEN_U64_MIN, new_name
// word GEN_U64_MAX, new_name
// word GEN_I64_MIN, new_name
// word GEN_I64_MAX, new_name
// word GEN_USIZE_MIN, new_name
// word GEN_USIZE_MAX, new_name
// word GEN_ISIZE_MIN, new_name
// word GEN_ISIZE_MAX, new_name
// word GEN_F32_MIN, new_name
// word GEN_F32_MAX, new_name
// word GEN_F64_MIN, new_name
// word GEN_F64_MAX, new_name
// Debug
// word GEN_DEBUG_TRAP, new_name
// word GEN_ASSERT, new_name
// word GEN_ASSERT_MSG, new_name
// word GEN_ASSERT_NOT_NULL, new_name
// word GEN_PANIC, new_name
// word GEN_FATAL, new_name
// Memory
// word kilobytes, new_name
// word megabytes, new_name
// word gigabytes, new_name
// word terabytes, new_name
// word zero_item, new_name
// word zero_array, new_name
// word alloc_item, new_name
// word alloc_array, new_name
// word malloc, new_name
// word mfree, new_name
// Strings
// word txt, new_name
// word cast_to_strc, new_name
// ---------- Dependency Types
// word b8, new_name
// word b16, new_name
// word b32, new_name
// word s8, new_name
// word s16, new_name
// word s32, new_name
// word s64, new_name
// word u8, new_name
// word u16, new_name
// word u32, new_name
// word u64, new_name
// word usize, new_name
// word ssize, new_name
// word sptr, new_name
// word uptr, new_name
// word f32, new_name
// word f64, new_name
// namespace EAllocator_, new_namespace_
// namespace EFileMode_, new_namespace_
// namespace EFileError_, new_namespace_
// word AllocatorInfo, new_name
// word AllocatorProc, new_name
// word AllocFlag, new_name
// word AllocType, new_name
// word ArrayHeader, new_name
// word DirEntry, new_name
// word DirInfo, new_name
// word DirType, new_name
// word FileDescriptor, new_name
// word FileError, new_name
// word FileInfo, new_name
// word FileTime, new_name
// word FileModeFlag, new_name
// word FileOperations, new_name
// word FileStandardType, new_name
// word SeekWhenceType, new_name
// ---------- Dependency Data
// word default_file_operations, new_name
// ---------- Dependency Procedures
// word align_forward, new_name
// word align_fordward_i64, new_name
// word alloc, new_name
// word alloc_align, new_name
// word assert_handler, new_name
// word assert_crash, new_name
// word char_first_occurence, new_name
// word char_is_alpha, new_name
// word char_is_alphanumeric, new_name
// word char_is_digit, new_name
// word char_is_hex_digit, new_name
// word char_is_space, new_name
// word char_to_lower, new_name
// word char_to_upper, new_name
// word crc32, new_name
// word default_resize_align, new_name
// word digit_to_int, new_name
// word file_close, new_name
// word file_get_standard, new_name
// word file_name, new_name
// word file_open, new_name
// word file_open_mode, new_name
// word file_seek, new_name
// word file_tell, new_name
// word file_write, new_name
// word file_write_at, new_name
// word file_write_at_check, new_name
// word free, new_name
// word free_all, new_name
// word heap, new_name
// word heap_allocator_proc, new_name
// word heap_stats_check, new_name
// word heap_stats_alloc_count, new_name
// word heap_stats_init, new_name
// word heap_stats_used_memory, new_name
// word hex_digit_to_int, new_name
// word i64_to_str, new_name
// word is_power_of_two, new_name
// word log_fmt, new_name
// word mem_copy, new_name
// word mem_move, new_name
// word mem_set, new_name
// word pointer_add, new_name
// word mem_copy, new_name
// word mem_find, new_name
// word mem_move, new_name
// word mem_set, new_name
// word resize, new_name
// word resize_align, new_name
// word process_exit, new_name
// word str_compare, new_name
// word str_copy, new_name
// word str_copy_nulpad, new_name
// word str_fmt_buf, new_name
// word str_fmt_buf_va, new_name
// word str_fmt_file_va, new_name
// word str_fmt_out_va, new_name
// word str_fmt_out_err, new_name
// word str_fmt_out_err_va, new_name
// word str_fmt_va, new_name
// word str_len, new_name
// word str_reverse, new_name
// word str_to_i64, new_name
// word str_to_lower, new_name
// word str_to_upper, new_name
// word u64_to_str, new_name
// word zero_size, new_name
// ---------- gencpp Macros
// word log_failure, new_name
// word NullCode, new_name
// word CodeInvalid, new_name
// ------------ gencpp common
// word Arena, new_name
// word Array, new_name
// word HashTable, new_name
// word Pool, new_name
// word StrC, new_name
// word String, new_name
// word to_str, new_name
// word to_str, new_name
// word to_type, new_name
// ------------ gencpp Types & Constants
// word LogFailType, new_name
// word AccessSpec, new_name
// word ECode, new_name
// word EnumClass, new_name
// word EnumRegular, new_name
// word EnumT, new_name
// word EOperator, new_name
// word ESpecifier, new_name
// word OperatorT, new_name
// word ModuleFlag, new_name
// word SpecifierT, new_name
// word StringCached, new_name
// word StringTable, new_name
// word UsingRegular, new_name
// word UsingNamespace, new_name
// ------------ gencpp Data
// word API_Export, new_name
// word API_Import, new_name
// word AST_POD_Size, new_name
// word AST, new_name
// word AST_POD, new_name
// word Code, new_name
// word Code_POD, new_name
// word Keyword, new_name
// ------------ gencpp API
// word init, new_name
// word deinit, new_name
// word get_cached_string, new_name
// word make_code, new_name
// word make_code_entries, new_name
// word set_allocator_data_arrays, new_name
// word set_allocator_code_pool, new_name
// word set_allocator_code_entries_arena, new_name
// word set_allocator_string_arena, new_name
// word set_allocator_string_table, new_name
// word set_allocator_type_table, new_name
// ------------ upfront constructor namespace
// namespace def_ new_namespace_
// ------------ upfront constructor individual
// word def_attributes, new_name
// word def_comment, new_name
// word def_class, new_name
// word def_constructor, new_name
// word def_destructor, new_name
// word def_define, new_name
// word def_enum, new_name
// word def_execution, new_name
// word def_extern_link, new_name
// word def_friend, new_name
// word def_function, new_name
// word def_include, new_name
// word def_module, new_name
// word def_namespace, new_name
// word def_operator, new_name
// word def_operator_cast, new_name
// word def_param, new_name
// word def_pargma, new_name
// word def_preprocess_cond, new_name
// word def_specifier, new_name
// word def_struct, new_name
// word def_template, new_name
// word def_type, new_name
// word def_typedef, new_name
// word def_union, new_name
// word def_using, new_name
// word def_using_namespace, new_name
// word def_variable, new_name
// word def_body, new_name
// word def_class_body, new_name
// word def_enum_body, new_name
// word def_export_body, new_name
// word def_extern_link_body, new_name
// word def_function_body, new_name
// word def_global_body, new_name
// word def_namespace_body, new_name
// word def_params, new_name
// word def_specifiers, new_name
// word def_struct_body, new_name
// word def_union_body, new_name
// ------------ parse constructor namespace
// namespace parse_, new_namespace_
// ------------ parse constructor individual
// word parse_class, new_name
// word parse_enum, new_name
// word parse_export_body, new_name
// word parse_extern_link, new_name
// word parse_friend, new_name
// word parse_function, new_name
// word parse_global_body, new_name
// word parse_namespace, new_name
// word parse_operator, new_name
// word parse_struct, new_name
// word parse_template, new_name
// word parse_type, new_name
// word parse_typedef, new_name
// word parse_union, new_name
// word parse_using, new_name
// word parse_variable, new_name
// ------------ untyped constructor namespace
// namespace untyped_, new_namespace_
// ------------ untyped constructor individual
// word token_fmt_impl, new_name
// word token_fmt_va, new_name
// word untyped_str, new_name
// word untyped_fmt, new_name
// word untyped_token_fmt, new_name
// ------------ File Ops
// word Builder, new_name
// word Editor, new_name
// word Scanner, new_name
// ------------ gencpp user macros
// word gen_main, new_name
// word GEN_TIME, new_name
// word __, new_name
// word name, new_name
// word code, new_name
// word args, new_name
// word code_str, new_name
// word code_fmt, new_name
// word token_fmt, new_name
// ------------ Type AST namespace
// namespace t_, new_namespace_
// ------------ Specifier AST namespace
// namespace spec_, new_namespace_

View File

@ -9,58 +9,58 @@ 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 )
{ {
FixedArena_32KB scratch; fixed_arena_init(& scratch); FixedArena_32KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch); AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path ); CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
String enum_entries = string_make_reserve( GlobalAllocator, kilobytes(1) ); StrBuilder enum_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) ); StrBuilder to_c_str_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
String to_keyword_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) ); StrBuilder to_keyword_c_str_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
for ( ssize idx = 0; idx < array_num(csv_enum.Col_1); ++ idx ) { for ( ssize idx = 0; idx < array_num(csv_enum.Col_1); ++ idx ) {
char const* code = csv_enum.Col_1[idx].string; char const* code = csv_enum.Col_1[idx].string;
char const* keyword = csv_enum.Col_2[idx].string; char const* keyword = csv_enum.Col_2[idx].string;
// TODO(Ed): to_str_entries and the others in here didn't have proper sizing of the StrC slice. // TODO(Ed): to_c_str_entries and the others in here didn't have proper sizing of the Str slice.
string_append_fmt( & enum_entries, "CT_%s,\n", code ); strbuilder_append_fmt( & enum_entries, "CT_%s,\n", code );
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", code, code ); strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", code, code );
string_append_fmt( & to_keyword_str_entries, "{ sizeof(\"%s\") - 1, \"%s\" },\n", keyword, keyword ); strbuilder_append_fmt( & to_keyword_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", keyword, keyword );
} }
CodeEnum enum_code; CodeEnum enum_code;
if (use_c_definition) { if (use_c_definition) {
enum_code = parse_enum(token_fmt_impl((3 + 1) / 2, "entries", string_to_strc(enum_entries), enum_code = parse_enum(token_fmt_impl((3 + 1) / 2, "entries", strbuilder_to_str(enum_entries),
"enum CodeType enum_underlying(u32) { <entries> CT_NumTypes, CT_UnderlyingType = GEN_U32_MAX };" "enum CodeType enum_underlying(u32) { <entries> CT_NumTypes, CT_UnderlyingType = GEN_U32_MAX };"
)); ));
} }
else { else {
enum_code = parse_enum(token_fmt_impl((3 + 1) / 2, "entries", string_to_strc(enum_entries), enum_code = parse_enum(token_fmt_impl((3 + 1) / 2, "entries", strbuilder_to_str(enum_entries),
"enum CodeType : u32 { <entries> CT_NumTypes, CT_UnderlyingType = GEN_U32_MAX };" "enum CodeType : u32 { <entries> CT_NumTypes, CT_UnderlyingType = GEN_U32_MAX };"
)); ));
} }
#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(csv_enum.Col_1) )); Str lookup_size = strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%d", array_num(csv_enum.Col_1) ));
CodeBody to_str_fns = parse_global_body( token_fmt( CodeBody to_c_str_fns = parse_global_body( token_fmt(
"entries", string_to_strc(to_str_entries) "entries", strbuilder_to_str(to_c_str_entries)
, "keywords", string_to_strc(to_keyword_str_entries) , "keywords", strbuilder_to_str(to_keyword_c_str_entries)
, "num", lookup_size , "num", lookup_size
, stringize( , stringize(
inline inline
StrC codetype_to_str( CodeType type ) Str codetype_to_str( CodeType type )
{ {
local_persist local_persist
StrC lookup[<num>] = { Str lookup[<num>] = {
<entries> <entries>
}; };
return lookup[ type ]; return lookup[ type ];
} }
inline inline
StrC codetype_to_keyword_str( CodeType type ) Str codetype_to_keyword_str( CodeType type )
{ {
local_persist local_persist
StrC lookup[ <num> ] = { Str lookup[ <num> ] = {
<keywords> <keywords>
}; };
return lookup[ type ]; return lookup[ type ];
@ -76,14 +76,14 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
body_append(result, code_t); body_append(result, code_t);
} }
body_append(result, to_str_fns); body_append(result, to_c_str_fns);
if (! use_c_definition) { if (! use_c_definition) {
#pragma push_macro("forceinline") #pragma push_macro("forceinline")
#undef forceinline #undef forceinline
CodeBody alias_mappings = parse_global_body(code( CodeBody alias_mappings = parse_global_body(code(
forceinline StrC to_str (CodeType type) { return codetype_to_str(type); } forceinline Str to_str (CodeType type) { return codetype_to_str(type); }
forceinline StrC to_keyword_str(CodeType type) { return codetype_to_keyword_str(type); } forceinline Str to_keyword_str(CodeType type) { return codetype_to_keyword_str(type); }
)); ));
#pragma pop_macro("forceinline") #pragma pop_macro("forceinline")
body_append(result, alias_mappings); body_append(result, alias_mappings);
@ -93,19 +93,18 @@ CodeBody gen_ecode( char const* path, bool use_c_definition = false )
CodeBody gen_eoperator( char const* path, bool use_c_definition = false ) CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
{ {
FixedArena_16KB scratch; fixed_arena_init(& scratch); FixedArena_16KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch); AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path ); CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
String enum_entries = string_make_reserve( GlobalAllocator, 32 ); StrBuilder enum_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, 32 );
String to_str_entries = string_make_reserve( GlobalAllocator, 32 ); StrBuilder to_c_str_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, 32 );
for (usize idx = 0; idx < array_num(csv_enum.Col_1); idx++) { for (usize idx = 0; idx < array_num(csv_enum.Col_1); idx++) {
char const* enum_str = csv_enum.Col_1[idx].string; char const* enum_str = csv_enum.Col_1[idx].string;
char const* entry_to_str = csv_enum.Col_2[idx].string; char const* entry_to_str = csv_enum.Col_2[idx].string;
strbuilder_append_fmt( & enum_entries, "Op_%s,\n", enum_str );
string_append_fmt( & enum_entries, "Op_%s,\n", enum_str ); strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
} }
CodeEnum enum_code; CodeEnum enum_code;
@ -113,7 +112,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
{ {
#pragma push_macro("enum_underlying") #pragma push_macro("enum_underlying")
#undef enum_underlying #undef enum_underlying
enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize( enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
enum Operator enum_underlying(u32) enum Operator enum_underlying(u32)
{ {
<entries> <entries>
@ -125,7 +124,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
} }
else else
{ {
enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize( enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
enum Operator : u32 enum Operator : u32
{ {
<entries> <entries>
@ -137,16 +136,16 @@ CodeBody gen_eoperator( 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(csv_enum.Col_1) )); Str lookup_size = strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%d", array_num(csv_enum.Col_1) ));
CodeFn to_str = parse_function(token_fmt( CodeFn to_str = parse_function(token_fmt(
"entries", string_to_strc(to_str_entries) "entries", strbuilder_to_str(to_c_str_entries)
, "num", lookup_size , "num", lookup_size
, stringize( , stringize(
inline inline
StrC operator_to_str( Operator op ) Str operator_to_str( Operator op )
{ {
local_persist local_persist
StrC lookup[<num>] = { Str lookup[<num>] = {
<entries> <entries>
}; };
@ -169,7 +168,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
#pragma push_macro("forceinline") #pragma push_macro("forceinline")
#undef forceinline #undef forceinline
CodeBody alias_mappings = parse_global_body(code( CodeBody alias_mappings = parse_global_body(code(
forceinline StrC to_str(Operator op) { return operator_to_str(op); } forceinline Str to_str(Operator op) { return operator_to_str(op); }
)); ));
#pragma pop_macro("forceinline") #pragma pop_macro("forceinline")
body_append(result, alias_mappings); body_append(result, alias_mappings);
@ -179,20 +178,19 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
CodeBody gen_especifier( char const* path, bool use_c_definition = false ) CodeBody gen_especifier( char const* path, bool use_c_definition = false )
{ {
FixedArena_16KB scratch; fixed_arena_init(& scratch); FixedArena_16KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch); AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path ); CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
String enum_entries = string_make_reserve( scratch_info, kilobytes(1) ); StrBuilder enum_entries = strbuilder_make_reserve( scratch_info, kilobytes(1) );
String to_str_entries = string_make_reserve( scratch_info, kilobytes(1) ); StrBuilder to_c_str_entries = strbuilder_make_reserve( scratch_info, kilobytes(1) );
for (usize idx = 0; idx < array_num(csv_enum.Col_1); idx++) for (usize idx = 0; idx < array_num(csv_enum.Col_1); idx++)
{ {
char const* enum_str = csv_enum.Col_1[idx].string; char const* enum_str = csv_enum.Col_1[idx].string;
char const* entry_to_str = csv_enum.Col_2[idx].string; char const* entry_to_str = csv_enum.Col_2[idx].string;
strbuilder_append_fmt( & enum_entries, "Spec_%s,\n", enum_str );
string_append_fmt( & enum_entries, "Spec_%s,\n", enum_str ); strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
} }
CodeEnum enum_code; CodeEnum enum_code;
@ -200,7 +198,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
{ {
#pragma push_macro("enum_underlying") #pragma push_macro("enum_underlying")
#undef enum_underlying #undef enum_underlying
enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize( enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
enum Specifier enum_underlying(u32) enum Specifier enum_underlying(u32)
{ {
<entries> <entries>
@ -212,7 +210,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
} }
else else
{ {
enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize( enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), stringize(
enum Specifier : u32 enum Specifier : u32
{ {
<entries> <entries>
@ -221,8 +219,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
}; };
))); )));
} }
CodeFn is_trailing = parse_function(token_fmt("specifier", strbuilder_to_str(to_c_str_entries), stringize(
CodeFn is_trailing = parse_function(token_fmt("specifier", string_to_strc(to_str_entries), stringize(
inline inline
bool spec_is_trailing( Specifier specifier ) bool spec_is_trailing( Specifier specifier )
{ {
@ -240,16 +237,16 @@ 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(csv_enum.Col_1) )); Str lookup_size = strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%d", array_num(csv_enum.Col_1) ));
CodeFn to_str = parse_function(token_fmt( CodeFn to_str = parse_function(token_fmt(
"entries", string_to_strc(to_str_entries) "entries", strbuilder_to_str(to_c_str_entries)
, "num", lookup_size , "num", lookup_size
, stringize( , stringize(
inline inline
StrC spec_to_str( Specifier type ) Str spec_to_str( Specifier type )
{ {
local_persist local_persist
StrC lookup[<num>] = { Str lookup[<num>] = {
<entries> <entries>
}; };
@ -257,20 +254,20 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
} }
))); )));
CodeFn to_type = parse_function( token_fmt( "entries", string_to_strc(to_str_entries), stringize( CodeFn to_type = parse_function( token_fmt( "entries", strbuilder_to_str(to_c_str_entries), stringize(
inline inline
Specifier strc_to_specifier( StrC str ) Specifier str_to_specifier( Str str )
{ {
local_persist local_persist
u32 keymap[ Spec_NumSpecifiers ]; u32 keymap[ Spec_NumSpecifiers ];
do_once_start do_once_start
for ( u32 index = 0; index < Spec_NumSpecifiers; index++ ) for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
{ {
StrC enum_str = spec_to_str( (Specifier)index ); Str enum_str = spec_to_str( (Specifier)index );
// We subtract 1 to remove the null terminator // We subtract 1 to remove the null terminator
// This is because the tokens lexed are not null terminated. // This is because the tokens lexed are not null terminated.
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1); keymap[index] = crc32( enum_str.Ptr, enum_str.Len );
} }
do_once_end do_once_end
@ -308,8 +305,8 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
#pragma push_macro("forceinline") #pragma push_macro("forceinline")
#undef forceinline #undef forceinline
CodeBody alias_mappings = parse_global_body(code( CodeBody alias_mappings = parse_global_body(code(
forceinline StrC to_str (Specifier spec) { return spec_to_str(spec); } forceinline Str to_str (Specifier spec) { return spec_to_str(spec); }
forceinline Specifier to_type( StrC str ) { return strc_to_specifier(str); } forceinline Specifier to_type( Str str ) { return str_to_specifier(str); }
forceinline bool is_trailing( Specifier specifier ) { return spec_is_trailing(specifier); } forceinline bool is_trailing( Specifier specifier ) { return spec_is_trailing(specifier); }
)); ));
#pragma pop_macro("forceinline") #pragma pop_macro("forceinline")
@ -320,7 +317,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_definition = false ) CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_definition = false )
{ {
FixedArena_64KB scratch; fixed_arena_init(& scratch); FixedArena_64KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch); AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
FileContents enum_content = file_read_contents( scratch_info, file_zero_terminate, etok_path ); FileContents enum_content = file_read_contents( scratch_info, file_zero_terminate, etok_path );
@ -333,51 +330,51 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
CSV_Object csv_attr_nodes; CSV_Object csv_attr_nodes;
csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), scratch_info, false ); csv_parse( &csv_attr_nodes, rcast(char*, attrib_content.data), scratch_info, false );
Array<ADT_Node> enum_strs = csv_enum_nodes.nodes[0].nodes; Array<ADT_Node> enum_strs = csv_enum_nodes.nodes[0].nodes;
Array<ADT_Node> enum_str_strs = csv_enum_nodes.nodes[1].nodes; Array<ADT_Node> enum_c_str_strs = csv_enum_nodes.nodes[1].nodes;
Array<ADT_Node> attribute_strs = csv_attr_nodes.nodes[0].nodes; Array<ADT_Node> attribute_strs = csv_attr_nodes.nodes[0].nodes;
Array<ADT_Node> attribute_str_strs = csv_attr_nodes.nodes[1].nodes; Array<ADT_Node> attribute_c_str_strs = csv_attr_nodes.nodes[1].nodes;
String enum_entries = string_make_reserve( scratch_info, kilobytes(2) ); StrBuilder enum_entries = strbuilder_make_reserve( scratch_info, kilobytes(2) );
String to_str_entries = string_make_reserve( scratch_info, kilobytes(4) ); StrBuilder to_c_str_entries = strbuilder_make_reserve( scratch_info, kilobytes(4) );
String attribute_entries = string_make_reserve( scratch_info, kilobytes(2) ); StrBuilder attribute_entries = strbuilder_make_reserve( scratch_info, kilobytes(2) );
String to_str_attributes = string_make_reserve( scratch_info, kilobytes(4) ); StrBuilder to_c_str_attributes = strbuilder_make_reserve( scratch_info, kilobytes(4) );
String attribute_define_entries = string_make_reserve( scratch_info, kilobytes(4) ); StrBuilder attribute_define_entries = strbuilder_make_reserve( scratch_info, kilobytes(4) );
for (usize idx = 0; idx < array_num(enum_strs); idx++) for (usize idx = 0; idx < array_num(enum_strs); idx++)
{ {
char const* enum_str = enum_strs[idx].string; char const* enum_str = enum_strs[idx].string;
char const* entry_to_str = enum_str_strs [idx].string; char const* entry_to_str = enum_c_str_strs [idx].string;
string_append_fmt( & enum_entries, "Tok_%s,\n", enum_str ); strbuilder_append_fmt( & enum_entries, "Tok_%s,\n", enum_str );
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str); strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
} }
for ( usize idx = 0; idx < array_num(attribute_strs); idx++ ) for ( usize idx = 0; idx < array_num(attribute_strs); idx++ )
{ {
char const* attribute_str = attribute_strs[idx].string; char const* attribute_str = attribute_strs[idx].string;
char const* entry_to_str = attribute_str_strs [idx].string; char const* entry_to_str = attribute_c_str_strs [idx].string;
string_append_fmt( & attribute_entries, "Tok_Attribute_%s,\n", attribute_str ); strbuilder_append_fmt( & attribute_entries, "Tok_Attribute_%s,\n", attribute_str );
string_append_fmt( & to_str_attributes, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str); strbuilder_append_fmt( & to_c_str_attributes, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_str, entry_to_str);
string_append_fmt( & attribute_define_entries, "Entry( Tok_Attribute_%s, \"%s\" )", attribute_str, entry_to_str ); strbuilder_append_fmt( & attribute_define_entries, "Entry( Tok_Attribute_%s, \"%s\" )", attribute_str, entry_to_str );
if ( idx < array_num(attribute_strs) - 1 ) if ( idx < array_num(attribute_strs) - 1 )
string_append_strc( & attribute_define_entries, txt(" \\\n")); strbuilder_append_str( & attribute_define_entries, txt(" \\\n"));
else else
string_append_strc( & attribute_define_entries, txt("\n")); strbuilder_append_str( & attribute_define_entries, txt("\n"));
} }
#pragma push_macro("GEN_DEFINE_ATTRIBUTE_TOKENS") #pragma push_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")
#undef GEN_DEFINE_ATTRIBUTE_TOKENS #undef GEN_DEFINE_ATTRIBUTE_TOKENS
CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), string_to_strc(attribute_define_entries) ); CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), strbuilder_to_str(attribute_define_entries) );
#pragma pop_macro("GEN_DEFINE_ATTRIBUTE_TOKENS") #pragma pop_macro("GEN_DEFINE_ATTRIBUTE_TOKENS")
// We cannot parse this enum, it has Attribute names as enums // We cannot parse this enum, it has Attribute names as enums
CodeEnum enum_code; CodeEnum enum_code;
if (use_c_definition) if (use_c_definition)
{ {
enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), "attribute_toks", string_to_strc(attribute_entries), stringize( enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), "attribute_toks", strbuilder_to_str(attribute_entries), stringize(
enum TokType enum TokType
{ {
<entries> <entries>
@ -389,7 +386,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
} }
else else
{ {
enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), "attribute_toks", string_to_strc(attribute_entries), stringize( enum_code = parse_enum(token_fmt("entries", strbuilder_to_str(enum_entries), "attribute_toks", strbuilder_to_str(attribute_entries), stringize(
enum TokType : u32 enum TokType : u32
{ {
<entries> <entries>
@ -405,12 +402,12 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
#undef local_persist #undef local_persist
#undef do_once_start #undef do_once_start
#undef do_once_end #undef do_once_end
CodeFn to_str = parse_function(token_fmt("entries", string_to_strc(to_str_entries), "attribute_toks", string_to_strc(to_str_attributes), stringize( CodeFn to_str = parse_function(token_fmt("entries", strbuilder_to_str(to_c_str_entries), "attribute_toks", strbuilder_to_str(to_c_str_attributes), stringize(
inline inline
StrC toktype_to_str( TokType type ) Str toktype_to_str( TokType type )
{ {
local_persist local_persist
StrC lookup[] = { Str lookup[] = {
<entries> <entries>
<attribute_toks> <attribute_toks>
}; };
@ -419,20 +416,20 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
} }
))); )));
CodeFn to_type = parse_function( token_fmt( "entries", string_to_strc(to_str_entries), stringize( CodeFn to_type = parse_function( token_fmt( "entries", strbuilder_to_str(to_c_str_entries), stringize(
inline inline
TokType strc_to_toktype( StrC str ) TokType str_to_toktype( Str str )
{ {
local_persist local_persist
u32 keymap[ Tok_NumTokens ]; u32 keymap[ Tok_NumTokens ];
do_once_start do_once_start
for ( u32 index = 0; index < Tok_NumTokens; index++ ) for ( u32 index = 0; index < Tok_NumTokens; index++ )
{ {
StrC enum_str = toktype_to_str( (TokType)index ); Str enum_str = toktype_to_str( (TokType)index );
// We subtract 1 to remove the null terminator // We subtract 1 to remove the null terminator
// This is because the tokens lexed are not null terminated. // This is because the tokens lexed are not null terminated.
keymap[index] = crc32( enum_str.Ptr, enum_str.Len - 1); keymap[index] = crc32( enum_str.Ptr, enum_str.Len);
} }
do_once_end do_once_end
@ -452,7 +449,6 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
#pragma pop_macro("do_once_end") #pragma pop_macro("do_once_end")
CodeBody result = def_body(CT_Global_Body); CodeBody result = def_body(CT_Global_Body);
body_append(result, untyped_str(txt("GEN_NS_PARSER_BEGIN\n\n")));
body_append(result, attribute_entires_def); body_append(result, attribute_entires_def);
body_append(result, enum_code); body_append(result, enum_code);
if (use_c_definition) if (use_c_definition)
@ -462,7 +458,6 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
} }
body_append(result, to_str); body_append(result, to_str);
body_append(result, to_type); body_append(result, to_type);
body_append(result, untyped_str(txt("\nGEN_NS_PARSER_END\n\n")));
return result; return result;
} }
@ -508,7 +503,7 @@ CodeBody gen_ast_inlines()
{ {
if ( ast == nullptr ) if ( ast == nullptr )
{ {
log_failure( "Attempt to dereference a nullptr!" ); log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr; return nullptr;
} }
return ast; return ast;
@ -518,59 +513,59 @@ CodeBody gen_ast_inlines()
#pragma pop_macro("GEN_NS") #pragma pop_macro("GEN_NS")
#pragma pop_macro("CodeInvalid") #pragma pop_macro("CodeInvalid")
CodeBody impl_code = parse_global_body( token_fmt( "typename", StrC name(Code), code_impl_tmpl )); CodeBody impl_code = parse_global_body( token_fmt( "typename", Str name(Code), code_impl_tmpl ));
CodeBody impl_code_body = parse_global_body( token_fmt( "typename", StrC name(CodeBody), code_impl_tmpl )); CodeBody impl_code_body = parse_global_body( token_fmt( "typename", Str name(CodeBody), code_impl_tmpl ));
CodeBody impl_code_attr = parse_global_body( token_fmt( "typename", StrC name(CodeAttributes), code_impl_tmpl )); CodeBody impl_code_attr = parse_global_body( token_fmt( "typename", Str name(CodeAttributes), code_impl_tmpl ));
CodeBody impl_code_cmt = parse_global_body( token_fmt( "typename", StrC name(CodeComment), code_impl_tmpl )); CodeBody impl_code_cmt = parse_global_body( token_fmt( "typename", Str name(CodeComment), code_impl_tmpl ));
CodeBody impl_code_constr = parse_global_body( token_fmt( "typename", StrC name(CodeConstructor), code_impl_tmpl )); CodeBody impl_code_constr = parse_global_body( token_fmt( "typename", Str name(CodeConstructor), code_impl_tmpl ));
CodeBody impl_code_class = parse_global_body( token_fmt( "typename", StrC name(CodeClass), code_impl_tmpl )); CodeBody impl_code_class = parse_global_body( token_fmt( "typename", Str name(CodeClass), code_impl_tmpl ));
CodeBody impl_code_define = parse_global_body( token_fmt( "typename", StrC name(CodeDefine), code_impl_tmpl )); CodeBody impl_code_define = parse_global_body( token_fmt( "typename", Str name(CodeDefine), code_impl_tmpl ));
CodeBody impl_code_destruct = parse_global_body( token_fmt( "typename", StrC name(CodeDestructor), code_impl_tmpl )); CodeBody impl_code_destruct = parse_global_body( token_fmt( "typename", Str name(CodeDestructor), code_impl_tmpl ));
CodeBody impl_code_enum = parse_global_body( token_fmt( "typename", StrC name(CodeEnum), code_impl_tmpl )); CodeBody impl_code_enum = parse_global_body( token_fmt( "typename", Str name(CodeEnum), code_impl_tmpl ));
CodeBody impl_code_exec = parse_global_body( token_fmt( "typename", StrC name(CodeExec), code_impl_tmpl )); CodeBody impl_code_exec = parse_global_body( token_fmt( "typename", Str name(CodeExec), code_impl_tmpl ));
CodeBody impl_code_extern = parse_global_body( token_fmt( "typename", StrC name(CodeExtern), code_impl_tmpl )); CodeBody impl_code_extern = parse_global_body( token_fmt( "typename", Str name(CodeExtern), code_impl_tmpl ));
CodeBody impl_code_include = parse_global_body( token_fmt( "typename", StrC name(CodeInclude), code_impl_tmpl )); CodeBody impl_code_include = parse_global_body( token_fmt( "typename", Str name(CodeInclude), code_impl_tmpl ));
CodeBody impl_code_friend = parse_global_body( token_fmt( "typename", StrC name(CodeFriend), code_impl_tmpl )); CodeBody impl_code_friend = parse_global_body( token_fmt( "typename", Str name(CodeFriend), code_impl_tmpl ));
CodeBody impl_code_fn = parse_global_body( token_fmt( "typename", StrC name(CodeFn), code_impl_tmpl )); CodeBody impl_code_fn = parse_global_body( token_fmt( "typename", Str name(CodeFn), code_impl_tmpl ));
CodeBody impl_code_module = parse_global_body( token_fmt( "typename", StrC name(CodeModule), code_impl_tmpl )); CodeBody impl_code_module = parse_global_body( token_fmt( "typename", Str name(CodeModule), code_impl_tmpl ));
CodeBody impl_code_ns = parse_global_body( token_fmt( "typename", StrC name(CodeNS), code_impl_tmpl )); CodeBody impl_code_ns = parse_global_body( token_fmt( "typename", Str name(CodeNS), code_impl_tmpl ));
CodeBody impl_code_op = parse_global_body( token_fmt( "typename", StrC name(CodeOperator), code_impl_tmpl )); CodeBody impl_code_op = parse_global_body( token_fmt( "typename", Str name(CodeOperator), code_impl_tmpl ));
CodeBody impl_code_opcast = parse_global_body( token_fmt( "typename", StrC name(CodeOpCast), code_impl_tmpl )); CodeBody impl_code_opcast = parse_global_body( token_fmt( "typename", Str name(CodeOpCast), code_impl_tmpl ));
CodeBody impl_code_params = parse_global_body( token_fmt( "typename", StrC name(CodeParams), code_impl_tmpl )); CodeBody impl_code_params = parse_global_body( token_fmt( "typename", Str name(CodeParams), code_impl_tmpl ));
CodeBody impl_code_pragma = parse_global_body( token_fmt( "typename", StrC name(CodePragma), code_impl_tmpl )); CodeBody impl_code_pragma = parse_global_body( token_fmt( "typename", Str name(CodePragma), code_impl_tmpl ));
CodeBody impl_code_precond = parse_global_body( token_fmt( "typename", StrC name(CodePreprocessCond), code_impl_tmpl )); CodeBody impl_code_precond = parse_global_body( token_fmt( "typename", Str name(CodePreprocessCond), code_impl_tmpl ));
CodeBody impl_code_specs = parse_global_body( token_fmt( "typename", StrC name(CodeSpecifiers), code_impl_tmpl )); CodeBody impl_code_specs = parse_global_body( token_fmt( "typename", Str name(CodeSpecifiers), code_impl_tmpl ));
CodeBody impl_code_struct = parse_global_body( token_fmt( "typename", StrC name(CodeStruct), code_impl_tmpl )); CodeBody impl_code_struct = parse_global_body( token_fmt( "typename", Str name(CodeStruct), code_impl_tmpl ));
CodeBody impl_code_tmpl = parse_global_body( token_fmt( "typename", StrC name(CodeTemplate), code_impl_tmpl )); CodeBody impl_code_tmpl = parse_global_body( token_fmt( "typename", Str name(CodeTemplate), code_impl_tmpl ));
CodeBody impl_code_type = parse_global_body( token_fmt( "typename", StrC name(CodeTypename), code_impl_tmpl )); CodeBody impl_code_type = parse_global_body( token_fmt( "typename", Str name(CodeTypename), code_impl_tmpl ));
CodeBody impl_code_typedef = parse_global_body( token_fmt( "typename", StrC name(CodeTypedef), code_impl_tmpl )); CodeBody impl_code_typedef = parse_global_body( token_fmt( "typename", Str name(CodeTypedef), code_impl_tmpl ));
CodeBody impl_code_union = parse_global_body( token_fmt( "typename", StrC name(CodeUnion), code_impl_tmpl )); CodeBody impl_code_union = parse_global_body( token_fmt( "typename", Str name(CodeUnion), code_impl_tmpl ));
CodeBody impl_code_using = parse_global_body( token_fmt( "typename", StrC name(CodeUsing), code_impl_tmpl )); CodeBody impl_code_using = parse_global_body( token_fmt( "typename", Str name(CodeUsing), code_impl_tmpl ));
CodeBody impl_code_var = parse_global_body( token_fmt( "typename", StrC name(CodeVar), code_impl_tmpl )); CodeBody impl_code_var = parse_global_body( token_fmt( "typename", Str name(CodeVar), code_impl_tmpl ));
body_append(impl_code_attr, parse_global_body( token_fmt( "typename", StrC name(Attributes), codetype_impl_tmpl ))); body_append(impl_code_attr, parse_global_body( token_fmt( "typename", Str name(Attributes), codetype_impl_tmpl )));
body_append(impl_code_cmt, parse_global_body( token_fmt( "typename", StrC name(Comment), codetype_impl_tmpl ))); body_append(impl_code_cmt, parse_global_body( token_fmt( "typename", Str name(Comment), codetype_impl_tmpl )));
body_append(impl_code_constr, parse_global_body( token_fmt( "typename", StrC name(Constructor), codetype_impl_tmpl ))); body_append(impl_code_constr, parse_global_body( token_fmt( "typename", Str name(Constructor), codetype_impl_tmpl )));
body_append(impl_code_define, parse_global_body( token_fmt( "typename", StrC name(Define), codetype_impl_tmpl ))); body_append(impl_code_define, parse_global_body( token_fmt( "typename", Str name(Define), codetype_impl_tmpl )));
body_append(impl_code_destruct, parse_global_body( token_fmt( "typename", StrC name(Destructor), codetype_impl_tmpl ))); body_append(impl_code_destruct, parse_global_body( token_fmt( "typename", Str name(Destructor), codetype_impl_tmpl )));
body_append(impl_code_enum, parse_global_body( token_fmt( "typename", StrC name(Enum), codetype_impl_tmpl ))); body_append(impl_code_enum, parse_global_body( token_fmt( "typename", Str name(Enum), codetype_impl_tmpl )));
body_append(impl_code_exec, parse_global_body( token_fmt( "typename", StrC name(Exec), codetype_impl_tmpl ))); body_append(impl_code_exec, parse_global_body( token_fmt( "typename", Str name(Exec), codetype_impl_tmpl )));
body_append(impl_code_extern, parse_global_body( token_fmt( "typename", StrC name(Extern), codetype_impl_tmpl ))); body_append(impl_code_extern, parse_global_body( token_fmt( "typename", Str name(Extern), codetype_impl_tmpl )));
body_append(impl_code_include, parse_global_body( token_fmt( "typename", StrC name(Include), codetype_impl_tmpl ))); body_append(impl_code_include, parse_global_body( token_fmt( "typename", Str name(Include), codetype_impl_tmpl )));
body_append(impl_code_friend, parse_global_body( token_fmt( "typename", StrC name(Friend), codetype_impl_tmpl ))); body_append(impl_code_friend, parse_global_body( token_fmt( "typename", Str name(Friend), codetype_impl_tmpl )));
body_append(impl_code_fn, parse_global_body( token_fmt( "typename", StrC name(Fn), codetype_impl_tmpl ))); body_append(impl_code_fn, parse_global_body( token_fmt( "typename", Str name(Fn), codetype_impl_tmpl )));
body_append(impl_code_module, parse_global_body( token_fmt( "typename", StrC name(Module), codetype_impl_tmpl ))); body_append(impl_code_module, parse_global_body( token_fmt( "typename", Str name(Module), codetype_impl_tmpl )));
body_append(impl_code_ns, parse_global_body( token_fmt( "typename", StrC name(NS), codetype_impl_tmpl ))); body_append(impl_code_ns, parse_global_body( token_fmt( "typename", Str name(NS), codetype_impl_tmpl )));
body_append(impl_code_op, parse_global_body( token_fmt( "typename", StrC name(Operator), codetype_impl_tmpl ))); body_append(impl_code_op, parse_global_body( token_fmt( "typename", Str name(Operator), codetype_impl_tmpl )));
body_append(impl_code_opcast, parse_global_body( token_fmt( "typename", StrC name(OpCast), codetype_impl_tmpl ))); body_append(impl_code_opcast, parse_global_body( token_fmt( "typename", Str name(OpCast), codetype_impl_tmpl )));
body_append(impl_code_pragma, parse_global_body( token_fmt( "typename", StrC name(Pragma), codetype_impl_tmpl ))); body_append(impl_code_pragma, parse_global_body( token_fmt( "typename", Str name(Pragma), codetype_impl_tmpl )));
body_append(impl_code_precond, parse_global_body( token_fmt( "typename", StrC name(PreprocessCond), codetype_impl_tmpl ))); body_append(impl_code_precond, parse_global_body( token_fmt( "typename", Str name(PreprocessCond), codetype_impl_tmpl )));
body_append(impl_code_tmpl, parse_global_body( token_fmt( "typename", StrC name(Template), codetype_impl_tmpl ))); body_append(impl_code_tmpl, parse_global_body( token_fmt( "typename", Str name(Template), codetype_impl_tmpl )));
body_append(impl_code_type, parse_global_body( token_fmt( "typename", StrC name(Typename), codetype_impl_tmpl ))); body_append(impl_code_type, parse_global_body( token_fmt( "typename", Str name(Typename), codetype_impl_tmpl )));
body_append(impl_code_typedef, parse_global_body( token_fmt( "typename", StrC name(Typedef), codetype_impl_tmpl ))); body_append(impl_code_typedef, parse_global_body( token_fmt( "typename", Str name(Typedef), codetype_impl_tmpl )));
body_append(impl_code_union, parse_global_body( token_fmt( "typename", StrC name(Union), codetype_impl_tmpl ))); body_append(impl_code_union, parse_global_body( token_fmt( "typename", Str name(Union), codetype_impl_tmpl )));
body_append(impl_code_using, parse_global_body( token_fmt( "typename", StrC name(Using), codetype_impl_tmpl ))); body_append(impl_code_using, parse_global_body( token_fmt( "typename", Str name(Using), codetype_impl_tmpl )));
body_append(impl_code_var, parse_global_body( token_fmt( "typename", StrC name(Var), codetype_impl_tmpl ))); body_append(impl_code_var, parse_global_body( token_fmt( "typename", Str name(Var), codetype_impl_tmpl )));
#pragma push_macro("forceinline") #pragma push_macro("forceinline")
#undef forceinline #undef forceinline
@ -582,34 +577,34 @@ CodeBody gen_ast_inlines()
); );
#pragma pop_macro("forceinline") #pragma pop_macro("forceinline")
CodeBody impl_cast_body = parse_global_body( token_fmt( "typename", StrC name(Body), cast_tmpl )); CodeBody impl_cast_body = parse_global_body( token_fmt( "typename", Str name(Body), cast_tmpl ));
CodeBody impl_cast_attribute = parse_global_body( token_fmt( "typename", StrC name(Attributes), cast_tmpl )); CodeBody impl_cast_attribute = parse_global_body( token_fmt( "typename", Str name(Attributes), cast_tmpl ));
CodeBody impl_cast_cmt = parse_global_body( token_fmt( "typename", StrC name(Comment), cast_tmpl )); CodeBody impl_cast_cmt = parse_global_body( token_fmt( "typename", Str name(Comment), cast_tmpl ));
CodeBody impl_cast_constr = parse_global_body( token_fmt( "typename", StrC name(Constructor), cast_tmpl )); CodeBody impl_cast_constr = parse_global_body( token_fmt( "typename", Str name(Constructor), cast_tmpl ));
CodeBody impl_cast_class = parse_global_body( token_fmt( "typename", StrC name(Class), cast_tmpl )); CodeBody impl_cast_class = parse_global_body( token_fmt( "typename", Str name(Class), cast_tmpl ));
CodeBody impl_cast_define = parse_global_body( token_fmt( "typename", StrC name(Define), cast_tmpl )); CodeBody impl_cast_define = parse_global_body( token_fmt( "typename", Str name(Define), cast_tmpl ));
CodeBody impl_cast_destruct = parse_global_body( token_fmt( "typename", StrC name(Destructor), cast_tmpl )); CodeBody impl_cast_destruct = parse_global_body( token_fmt( "typename", Str name(Destructor), cast_tmpl ));
CodeBody impl_cast_enum = parse_global_body( token_fmt( "typename", StrC name(Enum), cast_tmpl )); CodeBody impl_cast_enum = parse_global_body( token_fmt( "typename", Str name(Enum), cast_tmpl ));
CodeBody impl_cast_exec = parse_global_body( token_fmt( "typename", StrC name(Exec), cast_tmpl )); CodeBody impl_cast_exec = parse_global_body( token_fmt( "typename", Str name(Exec), cast_tmpl ));
CodeBody impl_cast_extern = parse_global_body( token_fmt( "typename", StrC name(Extern), cast_tmpl )); CodeBody impl_cast_extern = parse_global_body( token_fmt( "typename", Str name(Extern), cast_tmpl ));
CodeBody impl_cast_friend = parse_global_body( token_fmt( "typename", StrC name(Friend), cast_tmpl )); CodeBody impl_cast_friend = parse_global_body( token_fmt( "typename", Str name(Friend), cast_tmpl ));
CodeBody impl_cast_fn = parse_global_body( token_fmt( "typename", StrC name(Fn), cast_tmpl )); CodeBody impl_cast_fn = parse_global_body( token_fmt( "typename", Str name(Fn), cast_tmpl ));
CodeBody impl_cast_include = parse_global_body( token_fmt( "typename", StrC name(Include), cast_tmpl )); CodeBody impl_cast_include = parse_global_body( token_fmt( "typename", Str name(Include), cast_tmpl ));
CodeBody impl_cast_module = parse_global_body( token_fmt( "typename", StrC name(Module), cast_tmpl )); CodeBody impl_cast_module = parse_global_body( token_fmt( "typename", Str name(Module), cast_tmpl ));
CodeBody impl_cast_ns = parse_global_body( token_fmt( "typename", StrC name(NS), cast_tmpl )); CodeBody impl_cast_ns = parse_global_body( token_fmt( "typename", Str name(NS), cast_tmpl ));
CodeBody impl_cast_op = parse_global_body( token_fmt( "typename", StrC name(Operator), cast_tmpl )); CodeBody impl_cast_op = parse_global_body( token_fmt( "typename", Str name(Operator), cast_tmpl ));
CodeBody impl_cast_opcast = parse_global_body( token_fmt( "typename", StrC name(OpCast), cast_tmpl )); CodeBody impl_cast_opcast = parse_global_body( token_fmt( "typename", Str name(OpCast), cast_tmpl ));
CodeBody impl_cast_params = parse_global_body( token_fmt( "typename", StrC name(Params), cast_tmpl )); CodeBody impl_cast_params = parse_global_body( token_fmt( "typename", Str name(Params), cast_tmpl ));
CodeBody impl_cast_pragma = parse_global_body( token_fmt( "typename", StrC name(Pragma), cast_tmpl )); CodeBody impl_cast_pragma = parse_global_body( token_fmt( "typename", Str name(Pragma), cast_tmpl ));
CodeBody impl_cast_precond = parse_global_body( token_fmt( "typename", StrC name(PreprocessCond), cast_tmpl )); CodeBody impl_cast_precond = parse_global_body( token_fmt( "typename", Str name(PreprocessCond), cast_tmpl ));
CodeBody impl_cast_specs = parse_global_body( token_fmt( "typename", StrC name(Specifiers), cast_tmpl )); CodeBody impl_cast_specs = parse_global_body( token_fmt( "typename", Str name(Specifiers), cast_tmpl ));
CodeBody impl_cast_struct = parse_global_body( token_fmt( "typename", StrC name(Struct), cast_tmpl )); CodeBody impl_cast_struct = parse_global_body( token_fmt( "typename", Str name(Struct), cast_tmpl ));
CodeBody impl_cast_tmpl = parse_global_body( token_fmt( "typename", StrC name(Template), cast_tmpl )); CodeBody impl_cast_tmpl = parse_global_body( token_fmt( "typename", Str name(Template), cast_tmpl ));
CodeBody impl_cast_type = parse_global_body( token_fmt( "typename", StrC name(Typename), cast_tmpl )); CodeBody impl_cast_type = parse_global_body( token_fmt( "typename", Str name(Typename), cast_tmpl ));
CodeBody impl_cast_typedef = parse_global_body( token_fmt( "typename", StrC name(Typedef), cast_tmpl )); CodeBody impl_cast_typedef = parse_global_body( token_fmt( "typename", Str name(Typedef), cast_tmpl ));
CodeBody impl_cast_union = parse_global_body( token_fmt( "typename", StrC name(Union), cast_tmpl )); CodeBody impl_cast_union = parse_global_body( token_fmt( "typename", Str name(Union), cast_tmpl ));
CodeBody impl_cast_using = parse_global_body( token_fmt( "typename", StrC name(Using), cast_tmpl )); CodeBody impl_cast_using = parse_global_body( token_fmt( "typename", Str name(Using), cast_tmpl ));
CodeBody impl_cast_var = parse_global_body( token_fmt( "typename", StrC name(Var), cast_tmpl )); CodeBody impl_cast_var = parse_global_body( token_fmt( "typename", Str name(Var), cast_tmpl ));
CodeBody result = def_global_body( args( CodeBody result = def_global_body( args(
def_pragma( txt("region generated code inline implementation")), def_pragma( txt("region generated code inline implementation")),

View File

@ -21,22 +21,22 @@ using namespace gen;
void clang_format_file( char const* path, char const* style_path ) void clang_format_file( char const* path, char const* style_path )
{ {
GEN_ASSERT_NOT_NULL(path); GEN_ASSERT_NOT_NULL(path);
String resolved_path = string_make_strc(GlobalAllocator, to_strc_from_c_str(path)); StrBuilder resolved_path = strbuilder_make_str(_ctx->Allocator_Temp, to_str_from_c_str(path));
String style_arg; StrBuilder style_arg;
if (style_path) { if (style_path) {
style_arg = string_make_strc(GlobalAllocator, txt("-style=file:")); style_arg = strbuilder_make_str(_ctx->Allocator_Temp, txt("-style=file:"));
string_append_fmt( & style_arg, "%s ", style_path ); strbuilder_append_fmt( & style_arg, "%s ", style_path );
} }
StrC clang_format = txt("clang-format "); Str clang_format = txt("clang-format ");
StrC cf_format_inplace = txt("-i "); Str cf_format_inplace = txt("-i ");
StrC cf_verbose = txt("-verbose "); Str cf_verbose = txt("-verbose ");
String command = string_make_strc( GlobalAllocator, clang_format ); StrBuilder command = strbuilder_make_str( _ctx->Allocator_Temp, clang_format );
string_append_strc( & command, cf_format_inplace ); strbuilder_append_str( & command, cf_format_inplace );
string_append_strc( & command, cf_verbose ); strbuilder_append_str( & command, cf_verbose );
string_append_string( & command, style_arg ); strbuilder_append_string( & command, style_arg );
string_append_string( & command, resolved_path ); strbuilder_append_string( & command, resolved_path );
system( command ); system( command );
} }
@ -48,11 +48,11 @@ void refactor_file( char const* path, char const* refactor_script )
GEN_ASSERT_NOT_NULL(path); GEN_ASSERT_NOT_NULL(path);
GEN_ASSERT_NOT_NULL(refactor_script); GEN_ASSERT_NOT_NULL(refactor_script);
String command = string_make_strc(GlobalAllocator, txt("refactor ")); StrBuilder command = strbuilder_make_str(_ctx->Allocator_Temp, txt("refactor "));
// string_append_strc( & command, txt("-debug ") ); // strbuilder_append_str( & command, txt("-debug ") );
string_append_strc( & command, txt("-num=1 ") ); strbuilder_append_str( & command, txt("-num=1 ") );
string_append_fmt( & command, "-src=%s ", path ); strbuilder_append_fmt( & command, "-src=%s ", path );
string_append_fmt( & command,"-spec=%s ", refactor_script ); strbuilder_append_fmt( & command,"-spec=%s ", refactor_script );
system(command); system(command);
log_fmt("\n"); log_fmt("\n");
} }

View File

@ -46,13 +46,13 @@ The C/C++ interface procedures are located with `ast.hpp` (for the Code type), a
All code types can either serialize using a function of the pattern: All code types can either serialize using a function of the pattern:
```c ```c
String <prefix>_to_string(Code code); StrBuilder <prefix>_to_strbuilder(Code code);
// or // or
<prefix>_to_string(Code code, String& result); <prefix>_to_strbuilder(Code code, StrBuilder& result);
``` ```
Where the first generates strings allocated using Allocator_StringArena and the other appends an existing strings with their backed allocator. Where the first generates strings allocated using Allocator_StringArena and the other appends an existing strings with their backed allocator.
Serialization of for the AST is defined for `Code` in [`ast.chpp`](../base/components/ast.cpp) with `code_to_string_ptr` & `code_to_string`. Serialization of for the AST is defined for `Code` in [`ast.chpp`](../base/components/ast.cpp) with `code_to_strbuilder_ptr` & `code_to_strbuilder`.
Serializtion for the rest of the code types is within [`code_serialization.cpp`](../base/components/code_serialization.cpp). Serializtion for the rest of the code types is within [`code_serialization.cpp`](../base/components/code_serialization.cpp).
Gencpp's serialization does not provide coherent formatting of the code. The user should use a formatter after serializing. Gencpp's serialization does not provide coherent formatting of the code. The user should use a formatter after serializing.

View File

@ -25,7 +25,7 @@ These are containers representing a scope body of a definition that can be of th
Fields: Fields:
```cpp ```cpp
StringCached Name; StrCached Name;
Code Front; Code Front;
Code Back; Code Back;
Token* Tok; Token* Tok;
@ -56,8 +56,8 @@ Represent standard or vendor specific C/C++ attributes.
Fields: Fields:
```cpp ```cpp
StringCached Content; StrCached Content;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -80,8 +80,8 @@ Stores a comment.
Fields: Fields:
```cpp ```cpp
StringCached Content; StrCached Content;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -109,7 +109,7 @@ CodeComment InlineCmt; // Only supported by forward declarations
CodeAttributes Attributes; CodeAttributes Attributes;
CodeType ParentType; CodeType ParentType;
CodeBody Body; CodeBody Body;
StringCached Name; StrCached Name;
CodeType Prev; CodeType Prev;
CodeType Next; CodeType Next;
Token* Tok; Token* Tok;
@ -143,7 +143,7 @@ CodeComment InlineCmt; // Only supported by forward declarations
Code InitializerList; Code InitializerList;
CodeParams Params; CodeParams Params;
Code Body; Code Body;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -178,8 +178,8 @@ Represents a preprocessor define
Fields: Fields:
```cpp ```cpp
StringCached Content; StrCached Content;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -201,7 +201,7 @@ Fields:
CodeComment InlineCmt; CodeComment InlineCmt;
CodeSpecifiers Specs; CodeSpecifiers Specs;
Code Body; Code Body;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -242,13 +242,13 @@ Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
Code Parent; Code Parent;
StringCached Name; StrCached Name;
CodeT Type; CodeT Type;
ModuleFlag ModuleFlags; ModuleFlag ModuleFlags;
``` ```
UnderlyingTypeMacro is a macro the library natively supports: `enum_underlying(type)` that is meant to behave as a wrapper for underlying type assignment. UnderlyingTypeMacro is a macro the library natively supports: `enum_underlying(type)` that is meant to behave as a wrapper for underlying type assignment.
The `enum_underlying_sig` is a `StrC` global var that can be set which will be defined within `PreprocessorDefines` and used in `parser_parse_enum` to identify a valid macro. The `enum_underlying_sig` is a `Str` global var that can be set which will be defined within `PreprocessorDefines` and used in `parser_parse_enum` to identify a valid macro.
Serialization: Serialization:
@ -271,8 +271,8 @@ Will be obsolute when function body parsing is implemented.
Fields: Fields:
```cpp ```cpp
StringCached Content; StrCached Content;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -292,7 +292,7 @@ Fields:
```cpp ```cpp
CodeBody Body; CodeBody Body;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -314,8 +314,8 @@ extern "<Name>"
Fields: Fields:
```cpp ```cpp
StringCached Content; StrCached Content;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Code Parent; Code Parent;
@ -338,7 +338,7 @@ Fields:
```cpp ```cpp
CodeComment InlineCmt; CodeComment InlineCmt;
Code Declaration; Code Declaration;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -363,7 +363,7 @@ CodeSpecifiers Specs;
CodeType ReturnType; CodeType ReturnType;
CodeParams Params; CodeParams Params;
CodeBody Body; CodeBody Body;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -390,7 +390,7 @@ Serialization:
Fields: Fields:
```cpp ```cpp
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -411,7 +411,7 @@ Fields:
```cpp ```cpp
CodeBody Body; CodeBody Body;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -440,7 +440,7 @@ CodeSpecifiers Specs;
CodeType ReturnType; CodeType ReturnType;
CodeParams Params; CodeParams Params;
CodeBody Body; CodeBody Body;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -472,7 +472,7 @@ CodeComment InlineCmt;
CodeSpecifiers Specs; CodeSpecifiers Specs;
CodeType ValueType; CodeType ValueType;
CodeBody Body; CodeBody Body;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -502,7 +502,7 @@ CodeType ValueType;
Code Macro; Code Macro;
Code Value; Code Value;
Code PostNameMacro; Code PostNameMacro;
StringCached Name; StrCached Name;
CodeParams Last; CodeParams Last;
CodeParams Next; CodeParams Next;
Token* Tok; Token* Tok;
@ -524,8 +524,8 @@ Serialization:
Fields: Fields:
```cpp ```cpp
StringCached Content; StrCached Content;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -544,8 +544,8 @@ Serialization:
Fields: Fields:
```cpp ```cpp
StringCached Content; StrCached Content;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -566,7 +566,7 @@ Fields:
```cpp ```cpp
SpecifierT ArrSpecs[ AST_ArrSpecs_Cap ]; SpecifierT ArrSpecs[ AST_ArrSpecs_Cap ];
CodeSpecifiers NextSpecs; CodeSpecifiers NextSpecs;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -588,7 +588,7 @@ Fields:
```cpp ```cpp
CodeParams Params; CodeParams Params;
Code Declaration; Code Declaration;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -621,7 +621,7 @@ Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
Code Parent; Code Parent;
StringCached Name; StrCached Name;
CodeT Type; CodeT Type;
b32 IsParamPack; b32 IsParamPack;
ETypenameTag TypeTag; ETypenameTag TypeTag;
@ -637,7 +637,7 @@ Serialization:
`<Name>` currently has the full serialization of anything with `<Name>` currently has the full serialization of anything with
*Note: ArrExpr is not used in serialization by `typename_to_string_ref` its instead handled by a parent AST's serailization (variable, typedef, using).* *Note: ArrExpr is not used in serialization by `typename_to_strbuilder_ref` its instead handled by a parent AST's serailization (variable, typedef, using).*
## Typedef ## Typedef
@ -649,7 +649,7 @@ Fields:
```cpp ```cpp
CodeComment InlineCmt; CodeComment InlineCmt;
Code UnderlyingType; Code UnderlyingType;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok Token* Tok
@ -682,7 +682,7 @@ Fields:
```cpp ```cpp
CodeAttributes Attributes; CodeAttributes Attributes;
CodeBody Body; CodeBody Body;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -708,7 +708,7 @@ Fields:
CodeComment InlineCmt; CodeComment InlineCmt;
CodeAttributes Attributes; CodeAttributes Attributes;
CodeType UnderlyingType; CodeType UnderlyingType;
StringCached Name; StrCached Name;
Code Prev; Code Prev;
Code Next; Code Next;
Token* Tok; Token* Tok;
@ -740,7 +740,7 @@ CodeSpecifiers Specs;
CodeType ValueType; CodeType ValueType;
Code BitfieldSize; Code BitfieldSize;
Code Value; Code Value;
StringCached Name; StrCached Name;
CodeVar NextVar; CodeVar NextVar;
Code Prev; Code Prev;
Code Next; Code Next;

View File

@ -12,7 +12,7 @@ gencpp uses a hand-written recursive descent parser. Both the lexer and parser c
### Lexer ### Lexer
The lex procedure does the lexical pass of content provided as a `StrC` type. The lex procedure does the lexical pass of content provided as a `Str` type.
The tokens are stored (for now) in `Lexer_Tokens`. The tokens are stored (for now) in `Lexer_Tokens`.
Fields: Fields:
@ -75,7 +75,7 @@ The parser has a limited user interface, only specific types of definitions or s
Each public user interface procedure has the following format: Each public user interface procedure has the following format:
```cpp ```cpp
<code type> parse_<definition type>( StrC def ) <code type> parse_<definition type>( Str def )
{ {
check_parse_args( def ); check_parse_args( def );
using namespace Parser; using namespace Parser;
@ -287,7 +287,7 @@ In the future statements and expressions will be parsed.
1. Attributes ( Standard, GNU, MSVC, Macro ) : `parse_attributes` 1. Attributes ( Standard, GNU, MSVC, Macro ) : `parse_attributes`
2. Specifiers ( consteval, constexpr, constinit, extern, forceinline, global, inline, internal_linkage, neverinline, static ) 2. Specifiers ( consteval, constexpr, constinit, extern, forceinline, global, inline, internal_linkage, neverinline, static )
3. Is either ( identifier, const specifier, long, short, signed, unsigned, bool, char, double, int) 3. Is either ( identifier, const specifier, long, short, signed, unsigned, bool, char, double, int)
1. Attempt to parse as constrcutor or destructor : `parse_global_nspace_constructor_destructor` 1. Attempt to parse as construtor or destructor : `parse_global_nspace_constructor_destructor`
2. If its an operator cast (definition outside class) : `parse_operator_cast` 2. If its an operator cast (definition outside class) : `parse_operator_cast`
3. Its an operator, function, or varaible : `parse_operator_function_or_varaible` 3. Its an operator, function, or varaible : `parse_operator_function_or_varaible`
4. If its not a global body, consume the closing curly brace 4. If its not a global body, consume the closing curly brace

View File

@ -15,25 +15,25 @@ You can think of this parser as *frontend parser* vs a *semantic parser*. Its in
User exposed interface: User exposed interface:
```cpp ```cpp
CodeClass parse_class ( StrC class_def ); CodeClass parse_class ( Str class_def );
CodeConstructor parse_constructor ( StrC constructor_def ); CodeConstructor parse_constructor ( Str constructor_def );
CodeDestructor parse_destructor ( StrC destructor_def ); CodeDestructor parse_destructor ( Str destructor_def );
CodeEnum parse_enum ( StrC enum_def ); CodeEnum parse_enum ( Str enum_def );
CodeBody parse_export_body ( StrC export_def ); CodeBody parse_export_body ( Str export_def );
CodeExtern parse_extern_link ( StrC exten_link_def ); CodeExtern parse_extern_link ( Str exten_link_def );
CodeFriend parse_friend ( StrC friend_def ); CodeFriend parse_friend ( Str friend_def );
CodeFn parse_function ( StrC fn_def ); CodeFn parse_function ( Str fn_def );
CodeBody parse_global_body ( StrC body_def ); CodeBody parse_global_body ( Str body_def );
CodeNS parse_namespace ( StrC namespace_def ); CodeNS parse_namespace ( Str namespace_def );
CodeOperator parse_operator ( StrC operator_def ); CodeOperator parse_operator ( Str operator_def );
CodeOpCast parse_operator_cast( StrC operator_def ); CodeOpCast parse_operator_cast( Str operator_def );
CodeStruct parse_struct ( StrC struct_def ); CodeStruct parse_struct ( Str struct_def );
CodeTemplate parse_template ( StrC template_def ); CodeTemplate parse_template ( Str template_def );
CodeType parse_type ( StrC type_def ); CodeType parse_type ( Str type_def );
CodeTypedef parse_typedef ( StrC typedef_def ); CodeTypedef parse_typedef ( Str typedef_def );
CodeUnion parse_union ( StrC union_def ); CodeUnion parse_union ( Str union_def );
CodeUsing parse_using ( StrC using_def ); CodeUsing parse_using ( Str using_def );
CodeVar parse_variable ( StrC var_def ); CodeVar parse_variable ( Str var_def );
``` ```
To parse file buffers, use the `parse_global_body` function. To parse file buffers, use the `parse_global_body` function.

View File

@ -49,10 +49,10 @@ However, the user may specifiy memory configuration.
https://github.com/Ed94/gencpp/blob/eea4ebf5c40d5d87baa465abfb1be30845b2377e/base/components/ast.hpp#L396-L461 https://github.com/Ed94/gencpp/blob/eea4ebf5c40d5d87baa465abfb1be30845b2377e/base/components/ast.hpp#L396-L461
*`StringCahced` is a typedef for `StrC` (a string slice), to denote it is an interned string* *`StringCahced` is a typedef for `Str` (a string slice), to denote it is an interned string*
*`CodeType` is enum taggin the type of code. Has an underlying type of `u32`* *`CodeType` is enum taggin the type of code. Has an underlying type of `u32`*
*`OperatorT` is a typedef for `EOperator::Type` which has an underlying type of `u32`* *`OperatorT` is a typedef for `EOperator::Type` which has an underlying type of `u32`*
*`String` is the dynamically allocated string type for the library* *`StrBuilder` is the dynamically allocated string type for the library*
AST widths are setup to be AST_POD_Size. AST widths are setup to be AST_POD_Size.
The width dictates how much the static array can hold before it must give way to using an allocated array: The width dictates how much the static array can hold before it must give way to using an allocated array:
@ -63,7 +63,7 @@ int AST_ArrSpecs_Cap =
( (
AST_POD_Size AST_POD_Size
- sizeof(Code) - sizeof(Code)
- sizeof(StringCached) - sizeof(StrCached)
- sizeof(Code) * 2 - sizeof(Code) * 2
- sizeof(Token*) - sizeof(Token*)
- sizeof(Code) - sizeof(Code)
@ -79,7 +79,7 @@ int AST_ArrSpecs_Cap =
Data Notes: Data Notes:
* The allocator definitions used are exposed to the user incase they want to dictate memory usage * The allocator definitions used are exposed to the user incase they want to dictate memory usage
* You'll find the memory handling in `init`, `deinit`, `reset`, `gen_string_allocator`, `get_cached_string`, `make_code`. * You'll find the memory handling in `init`, `deinit`, `reset`, `gen_strbuilder_allocator`, `cache_str`, `make_code`.
* Allocators are defined with the `AllocatorInfo` structure found in [`memory.hpp`](../base/dependencies/memory.hpp) * Allocators are defined with the `AllocatorInfo` structure found in [`memory.hpp`](../base/dependencies/memory.hpp)
* Most of the work is just defining the allocation procedure: * Most of the work is just defining the allocation procedure:
@ -93,7 +93,7 @@ Data Notes:
* Cached Strings are stored in their own set of arenas. AST constructors use cached strings for names, and content. * Cached Strings are stored in their own set of arenas. AST constructors use cached strings for names, and content.
* `StringArenas`, `StringCache`, `Allocator_StringArena`, and `Allocator_StringTable` are the associated containers or allocators. * `StringArenas`, `StringCache`, `Allocator_StringArena`, and `Allocator_StringTable` are the associated containers or allocators.
* Strings used for serialization and file buffers are not contained by those used for cached strings. * Strings used for serialization and file buffers are not contained by those used for cached strings.
* They are currently using `GlobalAllocator`, which are tracked array of arenas that grows as needed (adds buckets when one runs out). * They are currently using `FallbackAllocator`, which are tracked array of arenas that grows as needed (adds buckets when one runs out).
* Memory within the buckets is not reused, so its inherently wasteful. * Memory within the buckets is not reused, so its inherently wasteful.
* I will be augmenting the default allocator with virtual memory & a slab allocator in the [future](https://github.com/Ed94/gencpp/issues/12) * I will be augmenting the default allocator with virtual memory & a slab allocator in the [future](https://github.com/Ed94/gencpp/issues/12)
* Intrusive linked lists used children nodes on bodies, and parameters. * Intrusive linked lists used children nodes on bodies, and parameters.
@ -308,7 +308,7 @@ Code <name> = code_str( <some code without "" quotes > )
Template metaprogramming in the traditional sense becomes possible with the use of `token_fmt` and parse constructors: Template metaprogramming in the traditional sense becomes possible with the use of `token_fmt` and parse constructors:
```cpp ```cpp
StrC value = txt("Something"); Str value = txt("Something");
char const* template_str = txt( char const* template_str = txt(
Code with <key> to replace with token_values Code with <key> to replace with token_values
@ -403,7 +403,7 @@ There are two provided auxillary interfaces:
* Builder * Builder
* Scanner * Scanner
### Builder is a similar object to the jai language's string_builder ### Builder is a similar object to the jai language's strbuilder_builder
* The purpose of it is to generate a file. * The purpose of it is to generate a file.
* A file is specified and opened for writing using the open( file_path) function. * A file is specified and opened for writing using the open( file_path) function.

View File

@ -18,6 +18,6 @@ If using the library's provided build scripts:
.\build.ps1 <compiler> <debug or omit> c_library .\build.ps1 <compiler> <debug or omit> c_library
``` ```
All free from tag identifiers will be prefixed with `gen_` or `GEN_` as the namespace. This can either be changed after generation with a `.refactor` script (or your preferred subst method), OR by modifying c_library.refactor. All free from tag identifiers will be prefixed with `gen_` or `GEN_` as the namespace. This can either be changed after generation with a `.refactor` script (or your preferred subst method), OR by modifying [c_library.refactor](./c_library.refactor).
**If c_library.refactor is modified you may need to modify c_library.cpp and its [components](./components/). As some of the container generation relies on that prefix.** **If c_library.refactor is modified you may need to modify c_library.cpp and its [components](./components/). As some of the container generation relies on that prefix.**

View File

@ -24,24 +24,24 @@ constexpr char const* generation_notice =
"// This file was generated automatially by gencpp's c_library.cpp " "// This file was generated automatially by gencpp's c_library.cpp "
"(See: https://github.com/Ed94/gencpp)\n\n"; "(See: https://github.com/Ed94/gencpp)\n\n";
constexpr StrC roll_own_dependencies_guard_start = txt(R"( constexpr Str roll_own_dependencies_guard_start = txt(R"(
//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file. //! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl // Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
#ifndef GEN_ROLL_OWN_DEPENDENCIES #ifndef GEN_ROLL_OWN_DEPENDENCIES
)"); )");
constexpr StrC roll_own_dependencies_guard_end = txt(R"( constexpr Str roll_own_dependencies_guard_end = txt(R"(
// GEN_ROLL_OWN_DEPENDENCIES // GEN_ROLL_OWN_DEPENDENCIES
#endif #endif
)"); )");
constexpr StrC implementation_guard_start = txt(R"( constexpr Str implementation_guard_start = txt(R"(
#pragma region GENCPP IMPLEMENTATION GUARD #pragma region GENCPP IMPLEMENTATION GUARD
#if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED) #if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
# define GEN_IMPLEMENTED # define GEN_IMPLEMENTED
)"); )");
constexpr StrC implementation_guard_end = txt(R"( constexpr Str implementation_guard_end = txt(R"(
#endif #endif
#pragma endregion GENCPP IMPLEMENTATION GUARD #pragma endregion GENCPP IMPLEMENTATION GUARD
)"); )");
@ -62,20 +62,21 @@ constexpr bool helper_use_c_definition = true;
int gen_main() int gen_main()
{ {
gen::init(); Context ctx {};
gen::init(& ctx);
PreprocessorDefines.append(txt("GEN_API_C_BEGIN")); ctx.PreprocessorDefines.append(txt("GEN_API_C_BEGIN"));
PreprocessorDefines.append(txt("GEN_API_C_END")); ctx.PreprocessorDefines.append(txt("GEN_API_C_END"));
PreprocessorDefines.append(txt("Array(")); ctx.PreprocessorDefines.append(txt("Array("));
PreprocessorDefines.append(txt("HashTable(")); ctx.PreprocessorDefines.append(txt("HashTable("));
PreprocessorDefines.append(txt("GEN_NS_PARSER")); ctx.PreprocessorDefines.append(txt("GEN_NS_PARSER"));
PreprocessorDefines.append(txt("GEN_NS_PARSER_BEGIN")); ctx.PreprocessorDefines.append(txt("GEN_NS_PARSER_BEGIN"));
PreprocessorDefines.append(txt("GEN_NS_PARSER_END")); ctx.PreprocessorDefines.append(txt("GEN_NS_PARSER_END"));
PreprocessorDefines.append(txt("Using_Code(")); ctx.PreprocessorDefines.append(txt("Using_Code("));
PreprocessorDefines.append(txt("Using_CodeOps(")); ctx.PreprocessorDefines.append(txt("Using_CodeOps("));
PreprocessorDefines.append(txt("GEN_OPTIMIZE_MAPPINGS_BEGIN")); ctx.PreprocessorDefines.append(txt("GEN_OPTIMIZE_MAPPINGS_BEGIN"));
PreprocessorDefines.append(txt("GEN_OPITMIZE_MAPPINGS_END")); ctx.PreprocessorDefines.append(txt("GEN_OPITMIZE_MAPPINGS_END"));
PreprocessorDefines.append(txt("GEN_PARAM_DEFAULT")); ctx.PreprocessorDefines.append(txt("GEN_PARAM_DEFAULT"));
//PreprocessorDefines.append(txt("GEN_EXECUTION_EXPRESSION_SUPPORT")); //PreprocessorDefines.append(txt("GEN_EXECUTION_EXPRESSION_SUPPORT"));
Code push_ignores = scan_file( path_base "helpers/push_ignores.inline.hpp" ); Code push_ignores = scan_file( path_base "helpers/push_ignores.inline.hpp" );
@ -87,7 +88,7 @@ int gen_main()
#pragma region Resolve Dependencies #pragma region Resolve Dependencies
Code header_platform = scan_file( path_base "dependencies/platform.hpp" ); Code header_platform = scan_file( path_base "dependencies/platform.hpp" );
Code header_macros = scan_file( path_base "dependencies/macros.hpp" ); Code header_macros = scan_file( path_base "dependencies/macros.hpp" );
Code header_generic_macros = scan_file( "components/generic_macros.hpp" ); Code header_generic_macros = scan_file( "components/generic_macros.h" );
Code header_basic_types = scan_file( path_base "dependencies/basic_types.hpp" ); Code header_basic_types = scan_file( path_base "dependencies/basic_types.hpp" );
Code header_debug = scan_file( path_base "dependencies/debug.hpp" ); Code header_debug = scan_file( path_base "dependencies/debug.hpp" );
Code header_string_ops = scan_file( path_base "dependencies/string_ops.hpp" ); Code header_string_ops = scan_file( path_base "dependencies/string_ops.hpp" );
@ -100,7 +101,7 @@ int gen_main()
{ {
case CT_Using: case CT_Using:
{ {
log_fmt("REPLACE THIS MANUALLY: %SC\n", entry->Name); log_fmt("REPLACE THIS MANUALLY: %S\n", entry->Name);
CodeUsing using_ver = cast(CodeUsing, entry); CodeUsing using_ver = cast(CodeUsing, entry);
CodeTypedef typedef_ver = def_typedef(using_ver->Name, using_ver->UnderlyingType); CodeTypedef typedef_ver = def_typedef(using_ver->Name, using_ver->UnderlyingType);
@ -126,7 +127,7 @@ int gen_main()
if (fn->Specs) { if (fn->Specs) {
s32 constexpr_found = fn->Specs.remove( Spec_Constexpr ); s32 constexpr_found = fn->Specs.remove( Spec_Constexpr );
if (constexpr_found > -1) { if (constexpr_found > -1) {
//log_fmt("Found constexpr: %S\n", entry.to_string()); //log_fmt("Found constexpr: %SB\n", entry.to_strbuilder());
fn->Specs.append(Spec_Inline); fn->Specs.append(Spec_Inline);
} }
} }
@ -238,7 +239,7 @@ do \
break; break;
case CT_Variable: case CT_Variable:
{ {
if ( strc_contains(entry->Name, txt("Msg_Invalid_Value"))) if ( str_contains(entry->Name, txt("Msg_Invalid_Value")))
{ {
CodeDefine define = def_define(entry->Name, entry->Value->Content); CodeDefine define = def_define(entry->Name, entry->Value->Content);
header_printing.append(define); header_printing.append(define);
@ -253,7 +254,7 @@ do \
} }
Code array_ssize = gen_array(txt("gen_ssize"), txt("Array_gen_ssize")); Code array_ssize = gen_array(txt("gen_ssize"), txt("Array_gen_ssize"));
Code array_string_cached = gen_array(txt("gen_StringCached"), txt("Array_gen_StringCached")); Code array_string_cached = gen_array(txt("gen_StrCached"), txt("Array_gen_StrCached"));
CodeBody parsed_header_strings = parse_file( path_base "dependencies/strings.hpp" ); CodeBody parsed_header_strings = parse_file( path_base "dependencies/strings.hpp" );
CodeBody header_strings = def_body(CT_Global_Body); CodeBody header_strings = def_body(CT_Global_Body);
@ -292,16 +293,16 @@ do \
case CT_Preprocess_IfNotDef: case CT_Preprocess_IfNotDef:
{ {
//log_fmt("\nIFNDEF: %SC\n", entry->Content); //log_fmt("\nIFNDEF: %S\n", entry->Content);
header_strings.append(entry); header_strings.append(entry);
} }
break; break;
case CT_Struct_Fwd: case CT_Struct_Fwd:
{ {
if ( entry->Name.is_equal(txt("String")) ) if ( entry->Name.is_equal(txt("StrBuilder")) )
{ {
CodeTypedef c_def = parse_typedef(code( typedef char* String; )); CodeTypedef c_def = parse_typedef(code( typedef char* StrBuilder; ));
header_strings.append(c_def); header_strings.append(c_def);
header_strings.append(fmt_newline); header_strings.append(fmt_newline);
++ entry; ++ entry;
@ -341,12 +342,12 @@ do \
case CT_Typedef: case CT_Typedef:
{ {
StrC name_string_table = txt("StringTable"); Str name_string_table = txt("StringTable");
CodeTypedef td = cast(CodeTypedef, entry); CodeTypedef td = cast(CodeTypedef, entry);
if (td->Name.contains(name_string_table)) if (td->Name.contains(name_string_table))
{ {
CodeBody ht = gen_hashtable(txt("gen_StrC"), name_string_table); CodeBody ht = gen_hashtable(txt("gen_Str"), name_string_table);
header_strings.append(ht); header_strings.append(ht);
break; break;
} }
@ -388,8 +389,8 @@ do \
case CT_Union: case CT_Union:
case CT_Union_Fwd: case CT_Union_Fwd:
{ {
StrC type_str = codetype_to_keyword_str(entry->Type); Str type_str = codetype_to_keyword_str(entry->Type);
StrC formated_tmpl = token_fmt_impl( 3, Str formated_tmpl = token_fmt_impl( 3,
"type", type_str "type", type_str
, "name", entry->Name, , "name", entry->Name,
stringize( stringize(
@ -490,8 +491,8 @@ do \
continue; continue;
} }
StrC type_str = codetype_to_keyword_str(entry->Type); Str type_str = codetype_to_keyword_str(entry->Type);
StrC formated_tmpl = token_fmt_impl( 3, Str formated_tmpl = token_fmt_impl( 3,
"type", type_str "type", type_str
, "name", entry->Name, , "name", entry->Name,
stringize( stringize(
@ -549,9 +550,9 @@ do \
{ {
CodeTypename type = using_ver->UnderlyingType; CodeTypename type = using_ver->UnderlyingType;
CodeTypedef typedef_ver = parse_typedef(token_fmt( CodeTypedef typedef_ver = parse_typedef(token_fmt(
"ReturnType", to_string(type->ReturnType).to_strc() "ReturnType", to_strbuilder(type->ReturnType).to_str()
, "Name" , using_ver->Name , "Name" , using_ver->Name
, "Parameters", to_string(type->Params).to_strc() , "Parameters", to_strbuilder(type->Params).to_str()
, stringize( , stringize(
typedef <ReturnType>( * <Name>)(<Parameters>); typedef <ReturnType>( * <Name>)(<Parameters>);
))); )));
@ -578,7 +579,7 @@ do \
types.append(entry_td); types.append(entry_td);
continue; continue;
} }
//log_fmt("Detected ENUM: %S", entry->Name); //log_fmt("Detected ENUM: %SB", entry->Name);
convert_cpp_enum_to_c(cast(CodeEnum, entry), types); convert_cpp_enum_to_c(cast(CodeEnum, entry), types);
} }
break; break;
@ -588,8 +589,102 @@ do \
break; break;
} }
CodeBody array_token = gen_array(txt("gen_Token"), txt("Array_gen_Token"));
CodeBody parsed_parser_types = parse_file( path_base "components/parser_types.hpp" );
CodeBody parser_types = def_body(CT_Global_Body);
for ( Code entry = parsed_parser_types.begin(); entry != parsed_parser_types.end(); ++ entry ) switch(entry->Type)
{
case CT_Preprocess_IfDef:
{
b32 found = ignore_preprocess_cond_block(txt("GEN_INTELLISENSE_DIRECTIVES"), entry, parsed_parser_types, parser_types );
if (found) break;
parser_types.append(entry);
}
break;
case CT_Enum:
{
if (entry->Name.Len)
{
convert_cpp_enum_to_c(cast(CodeEnum, entry), parser_types);
break;
}
parser_types.append(entry);
}
break;
case CT_Struct:
{
if ( entry->Name.is_equal(txt("Token")))
{
// Add struct Token forward and typedef early.
CodeStruct token_fwd = parse_struct(code( struct Token; ));
CodeTypedef token_typedef = parse_typedef(code( typedef struct Token Token; ));
parser_types.append(token_fwd);
parser_types.append(token_typedef);
// Skip typedef since we added it
b32 continue_for = true;
for (Code array_entry = array_token.begin(); continue_for && array_entry != array_token.end(); ++ array_entry) switch (array_entry->Type)
{
case CT_Typedef:
{
// pop the array entry
array_token->NumEntries -= 1;
Code next = array_entry->Next;
Code prev = array_entry->Prev;
next->Prev = array_entry->Prev;
prev->Next = next;
if ( array_token->Front == array_entry )
array_token->Front = next;
parser_types.append(array_entry);
continue_for = false;
}
break;
}
// Append the struct
parser_types.append(entry);
// Append the token array
parser_types.append(array_token);
continue;
}
CodeTypedef struct_tdef = parse_typedef(token_fmt("name", entry->Name, stringize( typedef struct <name> <name>; )));
parser_types.append(struct_tdef);
parser_types.append(entry);
}
break;
case CT_Variable:
{
CodeVar var = cast(CodeVar, entry);
if (var->Specs && var->Specs.has(Spec_Constexpr) > -1) {
Code define_ver = untyped_str(token_fmt(
"name", var->Name
, "value", var->Value->Content
, "type", var->ValueType.to_strbuilder().to_str()
, "#define <name> (<type>) <value>\n"
));
parser_types.append(define_ver);
continue;
}
parser_types.append(entry);
}
break;
default:
parser_types.append(entry);
break;
}
// Used to track which functions need generic selectors. // Used to track which functions need generic selectors.
Array(CodeFn) code_c_interface = array_init_reserve<CodeFn>(GlobalAllocator, 16); Array(CodeFn) code_c_interface = array_init_reserve<CodeFn>(_ctx->Allocator_Temp, 16);
CodeBody parsed_ast = parse_file( path_base "components/ast.hpp" ); CodeBody parsed_ast = parse_file( path_base "components/ast.hpp" );
CodeBody ast = def_body(CT_Global_Body); CodeBody ast = def_body(CT_Global_Body);
@ -645,11 +740,11 @@ do \
CodeFn fn = cast(CodeFn, entry); CodeFn fn = cast(CodeFn, entry);
if (fn->Name.starts_with(txt("code_"))) if (fn->Name.starts_with(txt("code_")))
{ {
StrC old_prefix = txt("code_"); Str old_prefix = txt("code_");
StrC actual_name = { fn->Name.Len - old_prefix.Len, fn->Name.Ptr + old_prefix.Len }; Str actual_name = { fn->Name.Ptr + old_prefix.Len, fn->Name.Len - old_prefix.Len };
String new_name = String::fmt_buf(GlobalAllocator, "code__%SC", actual_name ); StrBuilder new_name = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "code__%S", actual_name );
fn->Name = get_cached_string(new_name); fn->Name = cache_str(new_name);
code_c_interface.append(fn); code_c_interface.append(fn);
} }
ast.append(entry); ast.append(entry);
@ -694,21 +789,21 @@ do \
s32 constexpr_found = var->Specs ? var->Specs.remove( Spec_Constexpr ) : - 1; 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: %SB\n", entry.to_strbuilder());
if (var->Name.contains(txt("AST_ArrSpecs_Cap"))) if (var->Name.contains(txt("AST_ArrSpecs_Cap")))
{ {
Code def = untyped_str(txt( Code def = untyped_str(txt(
R"(#define AST_ArrSpecs_Cap \ R"(#define AST_ArrSpecs_Cap \
( \ ( \
AST_POD_Size \ AST_POD_Size \
- sizeof(Code) \ - sizeof(Code) \
- sizeof(StringCached) \ - sizeof(StrCached) \
- sizeof(Code) * 2 \ - sizeof(Code) * 2 \
- sizeof(Token*) \ - sizeof(Token*) \
- sizeof(Code) \ - sizeof(Code) \
- sizeof(CodeType) \ - sizeof(CodeType) \
- sizeof(ModuleFlag) \ - sizeof(ModuleFlag) \
- sizeof(u32) \ - sizeof(u32) \
) \ ) \
/ sizeof(Specifier) - 1 / sizeof(Specifier) - 1
)" )"
@ -716,7 +811,7 @@ R"(#define AST_ArrSpecs_Cap \
ast.append(def); ast.append(def);
break; break;
} }
CodeDefine def = def_define(var->Name, var->Value.to_string()); CodeDefine def = def_define(var->Name, var->Value.to_strbuilder());
ast.append(def); ast.append(def);
break; break;
} }
@ -729,7 +824,7 @@ R"(#define AST_ArrSpecs_Cap \
break; break;
} }
StrC code_typenames[] = { Str code_typenames[] = {
txt("Code"), txt("Code"),
txt("CodeBody"), txt("CodeBody"),
txt("CodeAttributes"), txt("CodeAttributes"),
@ -791,24 +886,24 @@ R"(#define AST_ArrSpecs_Cap \
default: gen_generic_selection (Fail case) \ default: gen_generic_selection (Fail case) \
) GEN_RESOLVED_FUNCTION_CALL( code, ... ) \ ) GEN_RESOLVED_FUNCTION_CALL( code, ... ) \
*/ */
String generic_selector = String::make_reserve(GlobalAllocator, kilobytes(2)); StrBuilder generic_selector = StrBuilder::make_reserve(_ctx->Allocator_Temp, kilobytes(2));
for ( CodeFn fn : code_c_interface ) for ( CodeFn fn : code_c_interface )
{ {
generic_selector.clear(); generic_selector.clear();
StrC private_prefix = txt("code__"); Str private_prefix = txt("code__");
StrC actual_name = { fn->Name.Len - private_prefix.Len, fn->Name.Ptr + private_prefix.Len }; Str actual_name = { fn->Name.Ptr + private_prefix.Len, fn->Name.Len - private_prefix.Len };
String interface_name = String::fmt_buf(GlobalAllocator, "code_%SC", actual_name ); StrBuilder interface_name = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "code_%S", actual_name );
// Resolve generic's arguments // Resolve generic's arguments
b32 has_args = fn->Params->NumEntries > 1; b32 has_args = fn->Params->NumEntries > 1;
String params_str = String::make_reserve(GlobalAllocator, 32); StrBuilder params_str = StrBuilder::make_reserve(_ctx->Allocator_Temp, 32);
for (CodeParams param = fn->Params->Next; param != fn->Params.end(); ++ param) { for (CodeParams param = fn->Params->Next; param != fn->Params.end(); ++ param) {
// We skip the first parameter as its always going to be the code for selection // We skip the first parameter as its always going to be the code for selection
if (param->Next == nullptr) { if (param->Next == nullptr) {
params_str.append_fmt( "%SC", param->Name ); params_str.append_fmt( "%S", param->Name );
continue; continue;
} }
params_str.append_fmt( "%SC, ", param->Name ); params_str.append_fmt( "%S, ", param->Name );
} }
char const* tmpl_def_start = nullptr; char const* tmpl_def_start = nullptr;
@ -824,14 +919,14 @@ R"(#define <interface_name>( code ) _Generic( (code), \
} }
// Definition start // Definition start
generic_selector.append( token_fmt( generic_selector.append( token_fmt(
"interface_name", interface_name.to_strc() "interface_name", interface_name.to_str()
, "params", params_str.to_strc() // Only used if has_args , "params", params_str.to_str() // Only used if has_args
, tmpl_def_start , tmpl_def_start
)); ));
// Append slots // Append slots
for(StrC type : code_typenames ) { for(Str type : code_typenames ) {
generic_selector.append_fmt("%SC : %SC,\\\n", type, fn->Name ); generic_selector.append_fmt("%S : %S,\\\n", type, fn->Name );
} }
generic_selector.append(txt("default: gen_generic_selection_fail \\\n")); generic_selector.append(txt("default: gen_generic_selection_fail \\\n"));
@ -844,7 +939,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
} }
// Definition end // Definition end
generic_selector.append( token_fmt( generic_selector.append( token_fmt(
"params", params_str.to_strc() "params", params_str.to_str()
, "type", fn->Params->ValueType->Name , "type", fn->Params->ValueType->Name
, tmpl_def_end ) ); , tmpl_def_end ) );
@ -890,8 +985,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
char conversion_buf[32] = {}; char conversion_buf[32] = {};
u64_to_str(size_of(AST_Body::_PAD_), conversion_buf, 10); u64_to_str(size_of(AST_Body::_PAD_), conversion_buf, 10);
StrC arr_exp = union_entry->ValueType->ArrExpr->Content; Str arr_exp = union_entry->ValueType->ArrExpr->Content;
StrC cpp_size = to_strc_from_c_str(conversion_buf); Str cpp_size = to_str_from_c_str(conversion_buf);
union_entry->ValueType->ArrExpr = untyped_str( cpp_size ); union_entry->ValueType->ArrExpr = untyped_str( cpp_size );
union_entry->InlineCmt = untyped_str(token_fmt("arr_exp", arr_exp, union_entry->InlineCmt = untyped_str(token_fmt("arr_exp", arr_exp,
"// Had to hardcode _PAD_ because (<arr_exp>) was 67 bytes in C\n" "// Had to hardcode _PAD_ because (<arr_exp>) was 67 bytes in C\n"
@ -910,6 +1005,9 @@ R"(#define <interface_name>( code ) _Generic( (code), \
break; break;
} }
CodeBody array_arena = gen_array(txt("gen_Arena"), txt("Array_gen_Arena"));
CodeBody array_pool = gen_array(txt("gen_Pool"), txt("Array_gen_Pool"));
CodeBody parsed_interface = parse_file( path_base "components/interface.hpp" ); CodeBody parsed_interface = parse_file( path_base "components/interface.hpp" );
CodeBody interface = def_body(CT_Global_Body); CodeBody interface = def_body(CT_Global_Body);
for ( Code entry = parsed_interface.begin(); entry != parsed_interface.end(); ++ entry ) switch( entry->Type ) for ( Code entry = parsed_interface.begin(); entry != parsed_interface.end(); ++ entry ) switch( entry->Type )
@ -931,8 +1029,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
if (prev && prev->Name.is_equal(entry->Name)) { if (prev && prev->Name.is_equal(entry->Name)) {
// rename second definition so there isn't a symbol conflict // rename second definition so there isn't a symbol conflict
String postfix_arr = String::fmt_buf(GlobalAllocator, "%SC_arr", entry->Name); StrBuilder postfix_arr = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%S_arr", entry->Name);
entry->Name = get_cached_string(postfix_arr.to_strc()); entry->Name = cache_str(postfix_arr.to_str());
postfix_arr.free(); postfix_arr.free();
} }
@ -940,20 +1038,20 @@ R"(#define <interface_name>( code ) _Generic( (code), \
for ( CodeParams opt_param : fn->Params ) if (opt_param->ValueType->Name.starts_with(txt("Opts_"))) for ( CodeParams opt_param : fn->Params ) if (opt_param->ValueType->Name.starts_with(txt("Opts_")))
{ {
// Convert the definition to use a default struct: https://vxtwitter.com/vkrajacic/status/1749816169736073295 // Convert the definition to use a default struct: https://vxtwitter.com/vkrajacic/status/1749816169736073295
StrC prefix = txt("def_"); Str prefix = txt("def_");
StrC actual_name = { fn->Name.Len - prefix.Len, fn->Name.Ptr + prefix.Len }; Str actual_name = { fn->Name.Ptr + prefix.Len, fn->Name.Len - prefix.Len };
StrC new_name = String::fmt_buf(GlobalAllocator, "def__%SC", actual_name ).to_strc(); Str new_name = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "def__%S", actual_name ).to_str();
// Resolve define's arguments // Resolve define's arguments
b32 has_args = fn->Params->NumEntries > 1; b32 has_args = fn->Params->NumEntries > 1;
String params_str = String::make_reserve(GlobalAllocator, 32); StrBuilder params_str = StrBuilder::make_reserve(_ctx->Allocator_Temp, 32);
for (CodeParams other_param = fn->Params; other_param != opt_param; ++ other_param) { for (CodeParams other_param = fn->Params; other_param != opt_param; ++ other_param) {
if ( other_param == opt_param ) { if ( other_param == opt_param ) {
params_str.append_fmt( "%SC", other_param->Name ); params_str.append_fmt( "%S", other_param->Name );
break; break;
} }
// If there are arguments before the optional, prepare them here. // If there are arguments before the optional, prepare them here.
params_str.append_fmt( "%SC, ", other_param->Name ); params_str.append_fmt( "%S, ", other_param->Name );
} }
char const* tmpl_fn_macro = nullptr; char const* tmpl_fn_macro = nullptr;
if (params_str.length() > 0 ) { if (params_str.length() > 0 ) {
@ -965,12 +1063,12 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code fn_macro = untyped_str(token_fmt( Code fn_macro = untyped_str(token_fmt(
"def_name", fn->Name "def_name", fn->Name
, "def__name", new_name , "def__name", new_name
, "params", params_str.to_strc() , "params", params_str.to_str()
, "opts_type", opt_param->ValueType->Name , "opts_type", opt_param->ValueType->Name
, tmpl_fn_macro , tmpl_fn_macro
)); ));
fn->Name = get_cached_string(new_name); fn->Name = cache_str(new_name);
interface.append(fn); interface.append(fn);
interface.append(fn_macro); interface.append(fn_macro);
if (entry->Next && entry->Next->Type != CT_NewLine) { if (entry->Next && entry->Next->Type != CT_NewLine) {
@ -1019,11 +1117,11 @@ R"(#define <interface_name>( code ) _Generic( (code), \
CodeFn fn = cast(CodeFn, entry); CodeFn fn = cast(CodeFn, entry);
if (fn->Name.starts_with(txt("code_"))) if (fn->Name.starts_with(txt("code_")))
{ {
StrC old_prefix = txt("code_"); Str old_prefix = txt("code_");
StrC actual_name = { fn->Name.Len - old_prefix.Len, fn->Name.Ptr + old_prefix.Len }; Str actual_name = { fn->Name.Ptr + old_prefix.Len, fn->Name.Len - old_prefix.Len };
String new_name = String::fmt_buf(GlobalAllocator, "code__%SC", actual_name ); StrBuilder new_name = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "code__%S", actual_name );
fn->Name = get_cached_string(new_name); fn->Name = cache_str(new_name);
} }
inlines.append(entry); inlines.append(entry);
} }
@ -1142,10 +1240,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
#pragma endregion Resolve Dependencies #pragma endregion Resolve Dependencies
#pragma region Resolve Components #pragma region Resolve Components
CodeBody array_arena = gen_array(txt("gen_Arena"), txt("Array_gen_Arena"));
CodeBody array_pool = gen_array(txt("gen_Pool"), txt("Array_gen_Pool"));
CodeBody array_token = gen_array(txt("gen_Token"), txt("Array_gen_Token"));
Code src_start = scan_file( "components/src_start.c" ); Code src_start = scan_file( "components/src_start.c" );
Code src_static_data = scan_file( path_base "components/static_data.cpp" ); Code src_static_data = scan_file( path_base "components/static_data.cpp" );
Code src_ast_case_macros = scan_file( path_base "components/ast_case_macros.cpp" ); Code src_ast_case_macros = scan_file( path_base "components/ast_case_macros.cpp" );
@ -1174,11 +1268,11 @@ R"(#define <interface_name>( code ) _Generic( (code), \
CodeFn fn = cast(CodeFn, entry); CodeFn fn = cast(CodeFn, entry);
if (fn->Name.starts_with(txt("code_"))) if (fn->Name.starts_with(txt("code_")))
{ {
StrC old_prefix = txt("code_"); Str old_prefix = txt("code_");
StrC actual_name = { fn->Name.Len - old_prefix.Len, fn->Name.Ptr + old_prefix.Len }; Str actual_name = { fn->Name.Ptr + old_prefix.Len, fn->Name.Len - old_prefix.Len };
String new_name = String::fmt_buf(GlobalAllocator, "code__%SC", actual_name ); StrBuilder new_name = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "code__%S", actual_name );
fn->Name = get_cached_string(new_name); fn->Name = cache_str(new_name);
} }
src_ast.append(entry); src_ast.append(entry);
} }
@ -1219,18 +1313,18 @@ R"(#define <interface_name>( code ) _Generic( (code), \
) )
{ {
// rename second definition so there isn't a symbol conflict // rename second definition so there isn't a symbol conflict
String postfix_arr = String::fmt_buf(GlobalAllocator, "%SC_arr", fn->Name); StrBuilder postfix_arr = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%S_arr", fn->Name);
fn->Name = get_cached_string(postfix_arr.to_strc()); fn->Name = cache_str(postfix_arr.to_str());
postfix_arr.free(); postfix_arr.free();
} }
for ( CodeParams opt_param : fn->Params ) if (opt_param->ValueType->Name.starts_with(txt("Opts_"))) for ( CodeParams opt_param : fn->Params ) if (opt_param->ValueType->Name.starts_with(txt("Opts_")))
{ {
StrC prefix = txt("def_"); Str prefix = txt("def_");
StrC actual_name = { fn->Name.Len - prefix.Len, fn->Name.Ptr + prefix.Len }; Str actual_name = { fn->Name.Ptr + prefix.Len, fn->Name.Len - prefix.Len };
StrC new_name = String::fmt_buf(GlobalAllocator, "def__%SC", actual_name ).to_strc(); Str new_name = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "def__%S", actual_name ).to_str();
fn->Name = get_cached_string(new_name); fn->Name = cache_str(new_name);
} }
src_upfront.append(fn); src_upfront.append(fn);
@ -1267,51 +1361,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
} }
break; break;
case CT_Struct:
{
if ( entry->Name.is_equal(txt("Token")))
{
// Add struct Token forward and typedef early.
CodeStruct token_fwd = parse_struct(code( struct Token; ));
CodeTypedef token_typedef = parse_typedef(code( typedef struct Token Token; ));
src_lexer.append(token_fwd);
src_lexer.append(token_typedef);
// Skip typedef since we added it
b32 continue_for = true;
for (Code array_entry = array_token.begin(); continue_for && array_entry != array_token.end(); ++ array_entry) switch (array_entry->Type)
{
case CT_Typedef:
{
// pop the array entry
array_token->NumEntries -= 1;
Code next = array_entry->Next;
Code prev = array_entry->Prev;
next->Prev = array_entry->Prev;
prev->Next = next;
if ( array_token->Front == array_entry )
array_token->Front = next;
src_lexer.append(array_entry);
continue_for = false;
}
break;
}
// Append the struct
src_lexer.append(entry);
// Append the token array
src_lexer.append(array_token);
continue;
}
CodeTypedef struct_tdef = parse_typedef(token_fmt("name", entry->Name, stringize( typedef struct <name> <name>; )));
src_lexer.append(entry);
src_lexer.append(struct_tdef);
}
break;
case CT_Variable: case CT_Variable:
{ {
CodeVar var = cast(CodeVar, entry); CodeVar var = cast(CodeVar, entry);
@ -1319,7 +1368,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code define_ver = untyped_str(token_fmt( Code define_ver = untyped_str(token_fmt(
"name", var->Name "name", var->Name
, "value", var->Value->Content , "value", var->Value->Content
, "type", var->ValueType.to_string().to_strc() , "type", var->ValueType.to_strbuilder().to_str()
, "#define <name> (<type>) <value>\n" , "#define <name> (<type>) <value>\n"
)); ));
src_lexer.append(define_ver); src_lexer.append(define_ver);
@ -1364,7 +1413,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code define_ver = untyped_str(token_fmt( Code define_ver = untyped_str(token_fmt(
"name", var->Name "name", var->Name
, "value", var->Value->Content , "value", var->Value->Content
, "type", var->ValueType.to_string().to_strc() , "type", var->ValueType.to_strbuilder().to_str()
, "#define <name> (<type>) <value>\n" , "#define <name> (<type>) <value>\n"
)); ));
src_parser.append(define_ver); src_parser.append(define_ver);
@ -1416,13 +1465,14 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code r_header_timing = refactor(header_timing); Code r_header_timing = refactor(header_timing);
Code rf_header_parsing = refactor_and_format(header_parsing); Code rf_header_parsing = refactor_and_format(header_parsing);
Code rf_types = refactor_and_format(types); Code rf_types = refactor_and_format(types);
Code rf_ecode = refactor_and_format(ecode); Code rf_parser_types = refactor_and_format(parser_types);
Code rf_eoperator = refactor_and_format(eoperator); Code rf_ecode = refactor_and_format(ecode);
Code rf_especifier = refactor_and_format(especifier); Code rf_eoperator = refactor_and_format(eoperator);
Code rf_ast = refactor_and_format(ast); Code rf_especifier = refactor_and_format(especifier);
Code rf_code_types = refactor_and_format(code_types); Code rf_ast = refactor_and_format(ast);
Code rf_ast_types = refactor_and_format(ast_types); Code rf_code_types = refactor_and_format(code_types);
Code rf_ast_types = refactor_and_format(ast_types);
Code rf_interface = refactor_and_format(interface); Code rf_interface = refactor_and_format(interface);
Code rf_inlines = refactor_and_format(inlines); Code rf_inlines = refactor_and_format(inlines);
@ -1481,9 +1531,11 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print_fmt( roll_own_dependencies_guard_start ); header.print_fmt( roll_own_dependencies_guard_start );
header.print( r_header_platform ); header.print( r_header_platform );
header.print_fmt( "\nGEN_NS_BEGIN\n" ); header.print_fmt( "\nGEN_NS_BEGIN\n" );
header.print( r_header_macros ); header.print( r_header_macros );
header.print( header_generic_macros ); header.print( header_generic_macros );
header.print_fmt( "GEN_API_C_BEGIN\n" );
header.print( r_header_basic_types ); header.print( r_header_basic_types );
header.print( r_header_debug ); header.print( r_header_debug );
header.print( rf_header_memory ); header.print( rf_header_memory );
@ -1497,7 +1549,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( r_header_timing ); header.print( r_header_timing );
header.print(rf_header_parsing ); header.print(rf_header_parsing );
header.print_fmt( "\nGEN_NS_END\n" ); header.print_fmt( "\nGEN_API_C_END\n" );
header.print_fmt( "GEN_NS_END\n" );
header.print_fmt( roll_own_dependencies_guard_end ); header.print_fmt( roll_own_dependencies_guard_end );
#pragma endregion Print Dependencies #pragma endregion Print Dependencies
@ -1515,6 +1568,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( rf_eoperator ); header.print( rf_eoperator );
header.print( fmt_newline ); header.print( fmt_newline );
header.print( rf_especifier ); header.print( rf_especifier );
header.print( rf_etoktype );
header.print( rf_parser_types );
header.print_fmt("#pragma endregion Types\n\n"); header.print_fmt("#pragma endregion Types\n\n");
header.print_fmt("#pragma region AST\n"); header.print_fmt("#pragma region AST\n");
@ -1523,6 +1578,13 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( rf_ast_types ); header.print( rf_ast_types );
header.print_fmt("\n#pragma endregion AST\n"); header.print_fmt("\n#pragma endregion AST\n");
header.print( fmt_newline);
header.print( rf_array_arena );
header.print( fmt_newline);
header.print( rf_array_pool);
header.print( fmt_newline);
header.print( rf_array_string_cached );
header.print( rf_interface ); header.print( rf_interface );
header.print(fmt_newline); header.print(fmt_newline);
@ -1531,7 +1593,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print_fmt("#pragma endregion Inlines\n"); header.print_fmt("#pragma endregion Inlines\n");
header.print(fmt_newline); header.print(fmt_newline);
header.print( rf_array_string_cached );
header.print( rf_header_end ); header.print( rf_header_end );
header.print( rf_header_builder ); header.print( rf_header_builder );
@ -1548,7 +1609,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
#pragma region Print Dependencies #pragma region Print Dependencies
header.print_fmt( roll_own_dependencies_guard_start ); header.print_fmt( roll_own_dependencies_guard_start );
header.print_fmt( "GEN_NS_BEGIN\n"); header.print_fmt( "\nGEN_NS_BEGIN\n");
header.print_fmt( "GEN_API_C_BEGIN\n" ); header.print_fmt( "GEN_API_C_BEGIN\n" );
header.print( r_src_dep_start ); header.print( r_src_dep_start );
@ -1562,17 +1623,14 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( r_src_timing ); header.print( r_src_timing );
header.print( rf_src_parsing ); header.print( rf_src_parsing );
header.print_fmt( "\nGEN_API_C_END\n" );
header.print_fmt( "GEN_NS_END\n"); header.print_fmt( "GEN_NS_END\n");
header.print_fmt( roll_own_dependencies_guard_end ); header.print_fmt( roll_own_dependencies_guard_end );
#pragma endregion Print Dependencies #pragma endregion Print Dependencies
#pragma region Print Components #pragma region Print Components
header.print_fmt( "\nGEN_NS_BEGIN\n"); header.print_fmt( "\nGEN_NS_BEGIN\n");
header.print_fmt( "GEN_API_C_BEGIN\n" );
header.print( fmt_newline);
header.print( rf_array_arena );
header.print( fmt_newline);
header.print( rf_array_pool);
header.print( r_src_static_data ); header.print( r_src_static_data );
header.print( fmt_newline); header.print( fmt_newline);
@ -1587,7 +1645,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( r_src_interface ); header.print( r_src_interface );
header.print( r_src_upfront ); header.print( r_src_upfront );
header.print_fmt( "\n#pragma region Parsing\n\n" ); header.print_fmt( "\n#pragma region Parsing\n\n" );
header.print( rf_etoktype );
header.print( r_src_lexer ); header.print( r_src_lexer );
header.print( fmt_newline); header.print( fmt_newline);
header.print( rf_array_code_typename ); header.print( rf_array_code_typename );
@ -1596,12 +1653,13 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( r_src_parsing ); header.print( r_src_parsing );
header.print_fmt( "\n#pragma endregion Parsing\n" ); header.print_fmt( "\n#pragma endregion Parsing\n" );
header.print( r_src_untyped ); header.print( r_src_untyped );
header.print_fmt( "\n#pragma endregion Interface\n\n"); header.print_fmt( "\n#pragma endregion Interface\n");
header.print( rf_src_builder ); header.print( rf_src_builder );
header.print( rf_src_scanner ); header.print( rf_src_scanner );
header.print_fmt( "GEN_API_C_END\n" ); header.print_fmt( "\nGEN_API_C_END\n" );
header.print_fmt( "GEN_NS_END\n");
#pragma endregion Print Components #pragma endregion Print Components
header.print_fmt( implementation_guard_end ); header.print_fmt( implementation_guard_end );
@ -1641,7 +1699,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
{ {
Builder src = Builder::open( "gen/gen.dep.c" ); Builder src = Builder::open( "gen/gen.dep.c" );
src.print_fmt( "GEN_NS_BEGIN\n"); src.print_fmt( "GEN_NS_BEGIN\n");
src.print_fmt( "GEN_API_C_BEGIN\n" );
builder_print_fmt(src, generation_notice ); builder_print_fmt(src, generation_notice );
builder_print_fmt( src, "// This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)\n" ); builder_print_fmt( src, "// This file is intended to be included within gen.cpp (There is no pragma diagnostic ignores)\n" );
@ -1679,6 +1736,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( rf_eoperator ); header.print( rf_eoperator );
header.print( fmt_newline ); header.print( fmt_newline );
header.print( rf_especifier ); header.print( rf_especifier );
header.print( rf_etoktype );
header.print( rf_parser_types );
header.print_fmt("#pragma endregion Types\n\n"); header.print_fmt("#pragma endregion Types\n\n");
header.print_fmt("#pragma region AST\n"); header.print_fmt("#pragma region AST\n");
@ -1732,7 +1791,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
src.print( r_src_interface ); src.print( r_src_interface );
src.print( r_src_upfront ); src.print( r_src_upfront );
src.print_fmt( "\n#pragma region Parsing\n\n" ); src.print_fmt( "\n#pragma region Parsing\n\n" );
src.print( rf_etoktype );
src.print( r_src_lexer ); src.print( r_src_lexer );
src.print( fmt_newline); src.print( fmt_newline);
src.print( rf_array_code_typename ); src.print( rf_array_code_typename );
@ -1746,11 +1804,11 @@ R"(#define <interface_name>( code ) _Generic( (code), \
src.print( rf_src_builder ); src.print( rf_src_builder );
src.print( rf_src_scanner ); src.print( rf_src_scanner );
src.print_fmt( "GEN_API_C_END\n" ); src.print_fmt( "\nGEN_NS_END\n");
src.write(); src.write();
} }
#pragma endregion Segmented #pragma endregion Segmented
gen::deinit(); gen::deinit( & ctx);
return 0; return 0;
} }

View File

@ -167,7 +167,7 @@ namespace pool_, gen_pool_
// Printing // Printing
namespace str_, gen_str_ namespace c_str_, gen_c_str_
word PrintF_Buffer, gen_PrintF_Buffer word PrintF_Buffer, gen_PrintF_Buffer
word Msg_Invalid_Value, gen_Msg_Invalid_Value word Msg_Invalid_Value, gen_Msg_Invalid_Value
@ -211,20 +211,20 @@ word crc64, gen_crc64
// Strings // Strings
word StrC, gen_StrC word Str, gen_Str
word to_strc_from_c_str, gen_to_strc_from_c_str word to_str_from_c_str, gen_to_str_from_c_str
namespace strc_, gen_strc_ namespace str_, gen_str_
word cast_to_strc, gen_cast_to_strc word cast_to_str, gen_cast_to_str
word StringHeader, gen_StringHeader word StrBuilderHeader, gen_StrBuilderHeader
word String, gen_String word StrBuilder, gen_StrBuilder
namespace string_, gen_string_ namespace strbuilder_, gen_strbuilder_
word StringCached, gen_StringCached word StrCached, gen_StrCached
word StringTable, gen_StringTable word StringTable, gen_StringTable
@ -308,7 +308,7 @@ word operator_to_str, gen_operator_to_str
word Specifier, gen_Specifier word Specifier, gen_Specifier
word spec_to_str, gen_spec_to_str word spec_to_str, gen_spec_to_str
word spec_is_trailing, gen_spec_is_trailing word spec_is_trailing, gen_spec_is_trailing
// word strc_to_specifier, gen_strc_to_specifier // word str_to_specifier, gen_str_to_specifier
// AST // AST
@ -401,7 +401,7 @@ word init, gen_init
word deinit, gen_deinit word deinit, gen_deinit
word reset, gen_reset word reset, gen_reset
word get_cached_string, gen_get_cached_string word cache_str, gen_cache_str
word make_code, gen_make_code word make_code, gen_make_code
@ -414,20 +414,6 @@ namespace untyped_, gen_untyped_
// Constants // Constants
word TokenMap_FixedArena, gen_TokenMap_FixedArena
word InitSize_DataArrays, gen_InitSize_DataArrays
word Global_BucketSize, gen_Global_BucketSize
word CodePool_NumBlocks, gen_CodePool_NumBlocks
word SizePer_StringArena, gen_SizePer_StringArena
word MaxCommentLineLength, gen_MaxCommentLineLength
word MaxNameLength, gen_MaxNameLength
word MaxUntypedStrLength, gen_MaxUntypedStrLength
word LexAllocator_Size, gen_LexAllocator_Size
word Builder_StrBufferReserve, gen_Builder_StrBufferReserve
word access_public, gen_access_public word access_public, gen_access_public
word access_protected, gen_access_protected word access_protected, gen_access_protected
word access_private, gen_access_private word access_private, gen_access_private
@ -446,28 +432,17 @@ word preprocess_else, gen_preprocess_else
namespace spec_, gen_spec_ namespace spec_, gen_spec_
namespace t_, gen_t_ namespace t_, gen_t_
word PreprocessorDefines, gen_PreprocessorDefines
// Backend // Backend
word GlobalAllocator, gen_GlobalAllocator
word Global_AllocatorBuckets, gen_Global_AllocatorBuckets
word CodePools, gen_CodePools
word StringArenas, gen_StringArenas
word StringCache, gen_StringCache
word LexArena, gen_LexArena
word Allocator_DataArrays, gen_Allocator_DataArrays
word Allocator_CodePool, gen_Allocator_CodePool
word Allocator_Lexer, gen_Allocator_Lexer
word Allocator_StringArena, gen_Allocator_StringArena
word Allocator_StringTable, gen_Allocator_StringTable
word Allocator_TypeTable, gen_Allocator_TypeTable
// Builder // Builder
word Builder, gen_Builder word Builder, gen_Builder
namespace builder_, gen_builder_ namespace builder_, gen_builder_
// Scanner
word scan_file, gen_scan_file
// Implementation (prviate) // Implementation (prviate)
word _format_info, gen__format_info word _format_info, gen__format_info
@ -514,7 +489,7 @@ word _adt_get_field, gen__adt_get_field
word _csv_write_record, gen__csv_write_record word _csv_write_record, gen__csv_write_record
word _csv_write_header, gen__csv_write_header word _csv_write_header, gen__csv_write_header
word Global_Allocator_Proc, gen_Global_Allocator_Proc word fallback_allocator_proc, gen_Global_Allocator_Proc
word define_constants, gen_define_constants word define_constants, gen_define_constants
word operator__validate, gen_operator__validate word operator__validate, gen_operator__validate
@ -523,7 +498,6 @@ word parser_deinit, gen_parser_deinit
word TokType, gen_TokType word TokType, gen_TokType
word toktype_to_str, gen_toktype_to_str word toktype_to_str, gen_toktype_to_str
// word strc_to_toktype, gen_strc_to_toktype
word NullToken, gen_NullToken word NullToken, gen_NullToken
namespace tok_, gen_tok_ namespace tok_, gen_tok_

View File

@ -40,11 +40,11 @@ CodeBody gen_array_base()
)); ));
}; };
CodeBody gen_array( StrC type, StrC array_name ) CodeBody gen_array( Str type, Str array_name )
{ {
String array_type = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr ); StrBuilder array_type = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "%.*s", array_name.Len, array_name.Ptr );
String fn = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr ); StrBuilder fn = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "%.*s", array_name.Len, array_name.Ptr );
// str_to_lower(fn.Data); // c_str_to_lower(fn.Data);
#pragma push_macro( "GEN_ASSERT" ) #pragma push_macro( "GEN_ASSERT" )
#pragma push_macro( "rcast" ) #pragma push_macro( "rcast" )
@ -56,7 +56,7 @@ CodeBody gen_array( StrC type, StrC array_name )
#undef cast #undef cast
#undef typeof #undef typeof
#undef forceinline #undef forceinline
CodeBody result = parse_global_body( token_fmt( "array_type", (StrC)array_type, "fn", (StrC)fn, "type", (StrC)type CodeBody result = parse_global_body( token_fmt( "array_type", (Str)array_type, "fn", (Str)fn, "type", (Str)type
, stringize( , stringize(
typedef <type>* <array_type>; typedef <type>* <array_type>;
@ -375,9 +375,9 @@ CodeBody gen_array( StrC type, StrC array_name )
#pragma pop_macro( "forceinline" ) #pragma pop_macro( "forceinline" )
++ Array_DefinitionCounter; ++ Array_DefinitionCounter;
StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", Array_DefinitionCounter).to_strc(); Str slot_str = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%d", Array_DefinitionCounter).to_str();
Code generic_interface_slot = untyped_str(token_fmt( "type", type, "array_type", (StrC)array_type, "slot", (StrC)slot_str, Code generic_interface_slot = untyped_str(token_fmt( "type", type, "array_type", (Str)array_type, "slot", (Str)slot_str,
R"(#define GENERIC_SLOT_<slot>__array_init <type>, <array_type>_init R"(#define GENERIC_SLOT_<slot>__array_init <type>, <array_type>_init
#define GENERIC_SLOT_<slot>__array_init_reserve <type>, <array_type>_init_reserve #define GENERIC_SLOT_<slot>__array_init_reserve <type>, <array_type>_init_reserve
#define GENERIC_SLOT_<slot>__array_append <array_type>, <array_type>_append #define GENERIC_SLOT_<slot>__array_append <array_type>, <array_type>_append
@ -399,13 +399,13 @@ R"(#define GENERIC_SLOT_<slot>__array_init <type>, <array_type>_i
)); ));
return def_global_body( args( return def_global_body( args(
def_pragma( string_to_strc( string_fmt_buf( GlobalAllocator, "region %S", array_type ))), def_pragma( strbuilder_to_str( strbuilder_fmt_buf( _ctx->Allocator_Temp, "region %SB", array_type ))),
fmt_newline, fmt_newline,
generic_interface_slot, generic_interface_slot,
fmt_newline, fmt_newline,
result, result,
fmt_newline, fmt_newline,
def_pragma( string_to_strc(string_fmt_buf( GlobalAllocator, "endregion %S", array_type ))), def_pragma( strbuilder_to_str(strbuilder_fmt_buf( _ctx->Allocator_Temp, "endregion %SB", array_type ))),
fmt_newline fmt_newline
)); ));
}; };

View File

@ -27,24 +27,24 @@ R"(#define HashTable(_type) struct _type
return def_global_body(args(struct_def, define_type, define_critical_load_scale)); return def_global_body(args(struct_def, define_type, define_critical_load_scale));
} }
CodeBody gen_hashtable( StrC type, StrC hashtable_name ) CodeBody gen_hashtable( Str type, Str hashtable_name )
{ {
String tbl_type = {(char*) hashtable_name.duplicate(GlobalAllocator).Ptr}; StrBuilder tbl_type = {(char*) hashtable_name.duplicate(_ctx->Allocator_Temp).Ptr};
String fn = tbl_type.duplicate(GlobalAllocator); StrBuilder fn = tbl_type.duplicate(_ctx->Allocator_Temp);
// str_to_lower(fn.Data); // c_str_to_lower(fn.Data);
String name_lower = String::make( GlobalAllocator, hashtable_name ); StrBuilder name_lower = StrBuilder::make( _ctx->Allocator_Temp, hashtable_name );
// str_to_lower( name_lower.Data ); // c_str_to_lower( name_lower.Data );
String hashtable_entry = String::fmt_buf( GlobalAllocator, "HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr ); StrBuilder hashtable_entry = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr );
String entry_array_name = String::fmt_buf( GlobalAllocator, "Arr_HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr ); StrBuilder entry_array_name = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "Arr_HTE_%.*s", hashtable_name.Len, hashtable_name.Ptr );
String entry_array_fn_ns = String::fmt_buf( GlobalAllocator, "arr_hte_%.*s", name_lower.length(), name_lower.Data ); StrBuilder entry_array_fn_ns = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "arr_hte_%.*s", name_lower.length(), name_lower.Data );
CodeBody hashtable_types = parse_global_body( token_fmt( CodeBody hashtable_types = parse_global_body( token_fmt(
"type", (StrC) type, "type", (Str) type,
"tbl_name", (StrC) hashtable_name, "tbl_name", (Str) hashtable_name,
"tbl_type", (StrC) tbl_type, "tbl_type", (Str) tbl_type,
stringize( stringize(
typedef struct HashTable_<type> <tbl_type>; typedef struct HashTable_<type> <tbl_type>;
typedef struct HTE_<tbl_name> HTE_<tbl_name>; typedef struct HTE_<tbl_name> HTE_<tbl_name>;
@ -74,13 +74,13 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
#undef typeof #undef typeof
#undef forceinline #undef forceinline
CodeBody hashtable_def = parse_global_body( token_fmt( CodeBody hashtable_def = parse_global_body( token_fmt(
"type", (StrC) type, "type", (Str) type,
"tbl_name", (StrC) hashtable_name, "tbl_name", (Str) hashtable_name,
"tbl_type", (StrC) tbl_type, "tbl_type", (Str) tbl_type,
"fn", (StrC) fn, "fn", (Str) fn,
"entry_type", (StrC) hashtable_entry, "entry_type", (Str) hashtable_entry,
"array_entry", (StrC) entry_array_name, "array_entry", (Str) entry_array_name,
"fn_array", (StrC) entry_array_fn_ns, "fn_array", (Str) entry_array_fn_ns,
stringize( stringize(
struct HashTable_<type> { struct HashTable_<type> {
Array_ssize Hashes; Array_ssize Hashes;
@ -372,9 +372,9 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
#pragma pop_macro( "forceinline" ) #pragma pop_macro( "forceinline" )
++ HashTable_DefinitionCounter; ++ HashTable_DefinitionCounter;
StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", HashTable_DefinitionCounter).to_strc(); Str slot_str = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%d", HashTable_DefinitionCounter).to_str();
Code generic_interface_slot = untyped_str(token_fmt( "type", type, "tbl_type", (StrC)tbl_type, "slot", (StrC)slot_str, Code generic_interface_slot = untyped_str(token_fmt( "type", type, "tbl_type", (Str)tbl_type, "slot", (Str)slot_str,
R"(#define GENERIC_SLOT_<slot>__hashtable_init <type>, <tbl_type>_init R"(#define GENERIC_SLOT_<slot>__hashtable_init <type>, <tbl_type>_init
#define GENERIC_SLOT_<slot>__hashtable_init_reserve <type>, <tbl_type>_init_reserve #define GENERIC_SLOT_<slot>__hashtable_init_reserve <type>, <tbl_type>_init_reserve
#define GENERIC_SLOT_<slot>__hashtable_clear <tbl_type>, <tbl_type>_clear #define GENERIC_SLOT_<slot>__hashtable_clear <tbl_type>, <tbl_type>_clear
@ -395,12 +395,12 @@ R"(#define GENERIC_SLOT_<slot>__hashtable_init <type>, <tbl_type>_
)" )"
)); ));
char const* cmt_str = str_fmt_buf( "Name: %.*s Type: %.*s" char const* cmt_str = c_str_fmt_buf( "Name: %.*s Type: %.*s"
, tbl_type.length(), tbl_type.Data , tbl_type.length(), tbl_type.Data
, type.Len, type.Ptr ); , type.Len, type.Ptr );
return def_global_body(args( return def_global_body(args(
def_pragma( string_to_strc( string_fmt_buf( GlobalAllocator, "region %S", tbl_type ))), def_pragma( strbuilder_to_str( strbuilder_fmt_buf( _ctx->Allocator_Temp, "region %SB", tbl_type ))),
fmt_newline, fmt_newline,
generic_interface_slot, generic_interface_slot,
fmt_newline, fmt_newline,
@ -409,7 +409,7 @@ R"(#define GENERIC_SLOT_<slot>__hashtable_init <type>, <tbl_type>_
entry_array, entry_array,
hashtable_def, hashtable_def,
fmt_newline, fmt_newline,
def_pragma( string_to_strc( string_fmt_buf( GlobalAllocator, "endregion %S", tbl_type ))), def_pragma( strbuilder_to_str( strbuilder_fmt_buf( _ctx->Allocator_Temp, "endregion %SB", tbl_type ))),
fmt_newline fmt_newline
)); ));
} }

View File

@ -3,9 +3,9 @@
// ____ _ ______ _ _ ____ _ __ _ // ____ _ ______ _ _ ____ _ __ _
// / ___} (_) | ____} | | (_) / __ \ | | | |(_) // / ___} (_) | ____} | | (_) / __ \ | | | |(_)
// | | ___ ___ _ __ ___ _ __ _ ___ | |__ _ _ _ __ ___| |_ _ ___ _ __ | | | |_ _____ _ __ | | ___ __ _ __| | _ _ __ __ _ // | | ___ ___ _ __ ___ _ __ _ ___ | |__ _ _ _ __ ___| |_ _ ___ _ __ | | | |_ _____ _ __ | | ___ __ _ __| | _ _ __ __ _
// | |{__ |/ _ \ '_ \ / _ \ '__} |/ __| | __} | | | '_ \ / __} __} |/ _ \| '_ \ | | | \ \ / / _ \ '_ \| |/ _ \ / _` |/ _` || | '_ \ / _` | // | |{__ |/ _ \ '_ \ / _ \ '__} |/ __| | __} | | | '_ \ / __} __} |/ _ \| '_ \ | | | \ \ / / _ \ '_ }| |/ _ \ / _` |/ _` || | '_ \ / _` |
// | |__j | __/ | | | __/ | | | (__ | | | |_| | | | | (__| l_| | (_) | | | | | l__| |\ V / __/ | | | | (_) | (_| | (_| || | | | | (_| | // | |__j | __/ | | | __/ | | | (__ | | | |_| | | | | (__| l_| | (_) | | | | | l__| |\ V / __/ | | | (_) | (_| | (_| || | | | | (_| |
// \____/ \___}_l l_l\___}_l l_l\___| l_l \__,_l_l l_l\___}\__}_l\___/l_l l_l \____/ \_/ \___}_l l_l_l\___/ \__,_l\__,_l|_|_| |_|\__, | // \____/ \___}_l l_l\___}_l l_l\___| l_l \__,_l_l l_l\___}\__}_l\___/l_l l_l \____/ \_/ \___}_l l_l\___/ \__,_l\__,_l|_|_| |_|\__, |
// This implemnents macros for utilizing "The Naive Extendible _Generic Macro" explained in: __| | // This implemnents macros for utilizing "The Naive Extendible _Generic Macro" explained in: __| |
// https://github.com/JacksonAllan/CC/blob/main/articles/Better_C_Generics_Part_1_The_Extendible_Generic.md {___/ // https://github.com/JacksonAllan/CC/blob/main/articles/Better_C_Generics_Part_1_The_Extendible_Generic.md {___/
// Since gencpp is used to generate the c-library, it was choosen over the more novel implementations to keep the macros as easy to understand and unobfuscated as possible. // Since gencpp is used to generate the c-library, it was choosen over the more novel implementations to keep the macros as easy to understand and unobfuscated as possible.
@ -30,7 +30,7 @@
// Where GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER is specifically looking for that <comma> , // Where GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER is specifically looking for that <comma> ,
#define GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( slot_exp ) GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER( slot_exp, GEN_GENERIC_SEL_ENTRY_TYPE( slot_exp, ): GEN_GENERIC_SEL_ENTRY_FUNCTION( slot_exp, ) GEN_COMMA_OPERATOR, , ) #define GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( slot_exp ) GEN_GENERIC_SEL_ENTRY_COMMA_DELIMITER( slot_exp, GEN_GENERIC_SEL_ENTRY_TYPE( slot_exp, ): GEN_GENERIC_SEL_ENTRY_FUNCTION( slot_exp, ) GEN_COMMA_OPERATOR, , )
// ^ Selects the comma ^ is the type ^ is the function ^ Insert a comma // ^ Selects the comma ^ is the type ^ is the function ^ Insert a comma
// The slot won't exist if that comma is not found. | // The slot won't exist if that comma is not found.
// For the occastion where an expression didn't resolve to a selection option the "default: <value>" will be set to: // For the occastion where an expression didn't resolve to a selection option the "default: <value>" will be set to:
typedef struct GENCPP_NO_RESOLVED_GENERIC_SELECTION GENCPP_NO_RESOLVED_GENERIC_SELECTION; typedef struct GENCPP_NO_RESOLVED_GENERIC_SELECTION GENCPP_NO_RESOLVED_GENERIC_SELECTION;
@ -43,12 +43,12 @@ GENCPP_NO_RESOLVED_GENERIC_SELECTION const gen_generic_selection_fail = {0};
// Below are generated on demand for an overlaod depdendent on a type: // Below are generated on demand for an overlaod depdendent on a type:
// ---------------------------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------------------------
#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg ) _Generic( \ #define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg ) _Generic( \
(selector_arg), /* Select Via Expression*/ \ (selector_arg), /* Select Via Expression*/ \
/* Extendibility slots: */ \ /* Extendibility slots: */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig ) \
default: gen_generic_selection_fail \ default: gen_generic_selection_fail \
) GEN_RESOLVED_FUNCTION_CALL( selector_arg ) ) GEN_RESOLVED_FUNCTION_CALL( selector_arg )
// ---------------------------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------------------------
@ -68,20 +68,21 @@ size_t gen_example_hash__P_long( long val ) { return val * 2654435761ull; }
#define GENERIC_SLOT_2_gen_example_hash long long, gen_example_hash__P_long_long #define GENERIC_SLOT_2_gen_example_hash long long, gen_example_hash__P_long_long
size_t gen_example_hash__P_long_long( long long val ) { return val * 2654435761ull; } size_t gen_example_hash__P_long_long( long long val ) { return val * 2654435761ull; }
// If using an Editor with support for syntax hightlighting macros: HASH__ARGS_SIG_1 and HASH_ARGS_SIG_2 should show color highlighting indicating the slot is enabled, // If using an Editor with support for syntax hightlighting macros:
// GENERIC_SLOT_1_gen_example_hash and GENERIC_SLOT_2_gen_example_hash should show color highlighting indicating the slot is enabled,
// or, "defined" for usage during the compilation pass that handles the _Generic instrinsic. // or, "defined" for usage during the compilation pass that handles the _Generic instrinsic.
#define gen_hash_example( function_arguments ) _Generic( \ #define gen_hash_example( function_arguments ) _Generic( \
(function_arguments), /* Select Via Expression*/ \ (function_arguments), /* Select Via Expression*/ \
/* Extendibility slots: */ \ /* Extendibility slots: */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_1 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_2 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_3 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_3_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_4 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_4_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_5 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_5_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_6 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_6_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_7 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_7_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_8 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_8_gen_example_hash ) \
default: gen_generic_selection_fail \ default: gen_generic_selection_fail \
) GEN_RESOLVED_FUNCTION_CALL( function_arguments ) ) GEN_RESOLVED_FUNCTION_CALL( function_arguments )
// Additional Variations: // Additional Variations:
@ -89,20 +90,20 @@ size_t gen_example_hash__P_long_long( long long val ) { return val * 2654435761u
// If the function takes more than one argument the following is used: // If the function takes more than one argument the following is used:
#define GEN_FUNCTION_GENERIC_EXAMPLE_VARADIC( selector_arg, ... ) _Generic( \ #define GEN_FUNCTION_GENERIC_EXAMPLE_VARADIC( selector_arg, ... ) _Generic( \
(selector_arg), \ (selector_arg), \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_2 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig ) \
/* ... */ \ /* ... */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(FunctionID__ARGS_SIG_N ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(GENERIC_SLOT_N__function_sig ) \
default: gen_generic_selection_fail \ default: gen_generic_selection_fail \
) GEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARG__ ) ) GEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARG__ )
// If the function does not take the arugment as a parameter: // If the function does not take the arugment as a parameter:
#define GEN_FUNCTION_GENERIC_EXAMPLE_DIRECT_TYPE( selector_arg ) _Generic( \ #define GEN_FUNCTION_GENERIC_EXAMPLE_DIRECT_TYPE( selector_arg ) _Generic( \
( GEN_TYPE_TO_EXP(selector_arg) ), \ ( GEN_TYPE_TO_EXP(selector_arg) ), \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_2 ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig ) \
/* ... */ \ /* ... */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(FunctionID__ARGS_SIG_N ) \ GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT(GENERIC_SLOT_N__function_sig ) \
default: gen_generic_selection_fail \ default: gen_generic_selection_fail \
) GEN_RESOLVED_FUNCTION_CALL() ) GEN_RESOLVED_FUNCTION_CALL()

View File

@ -18,13 +18,13 @@ void convert_cpp_enum_to_c( CodeEnum to_convert, CodeBody to_append )
#pragma pop_macro("enum_underlying") #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( Str 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.is_equal(cond_sig) ) if ( cond->Content.is_equal(cond_sig) )
{ {
//log_fmt("Preprocess cond found: %SC\n", cond->Content); //log_fmt("Preprocess cond found: %S\n", cond->Content);
found = true; found = true;
s32 depth = 1; s32 depth = 1;
@ -72,7 +72,7 @@ b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& par
constexpr bool GenericSel_One_Arg = true; constexpr bool GenericSel_One_Arg = true;
enum GenericSelectionOpts : u32 { GenericSel_Default, GenericSel_By_Ref, GenericSel_Direct_Type }; enum GenericSelectionOpts : u32 { GenericSel_Default, GenericSel_By_Ref, GenericSel_Direct_Type };
Code gen_generic_selection_function_macro( s32 num_slots, StrC macro_name, GenericSelectionOpts opts = GenericSel_Default, bool one_arg = false ) Code gen_generic_selection_function_macro( s32 num_slots, Str macro_name, GenericSelectionOpts opts = GenericSel_Default, bool one_arg = false )
{ {
/* Implements: /* Implements:
#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg, ... ) _Generic( \ #define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg, ... ) _Generic( \
@ -84,18 +84,18 @@ Code gen_generic_selection_function_macro( s32 num_slots, StrC macro_name, Gener
) GEN_RESOLVED_FUNCTION_CALL( selector_arg ) ) GEN_RESOLVED_FUNCTION_CALL( selector_arg )
*/ */
local_persist local_persist
String define_builder = String::make_reserve(GlobalAllocator, kilobytes(64)); StrBuilder define_builder = StrBuilder::make_reserve(_ctx->Allocator_Temp, kilobytes(64));
define_builder.clear(); define_builder.clear();
StrC macro_begin; Str macro_begin;
if (opts == GenericSel_Direct_Type) { if (opts == GenericSel_Direct_Type) {
macro_begin = token_fmt( "macro_name", (StrC)macro_name, macro_begin = token_fmt( "macro_name", (Str)macro_name,
R"(#define <macro_name>(selector_arg, ...) _Generic( (*(selector_arg*)NULL ), \ R"(#define <macro_name>(selector_arg, ...) _Generic( (*(selector_arg*)NULL ), \
)" )"
); );
} }
else { else {
macro_begin = token_fmt( "macro_name", (StrC)macro_name, macro_begin = token_fmt( "macro_name", (Str)macro_name,
R"(#define <macro_name>(selector_arg, ...) _Generic( (selector_arg), \ R"(#define <macro_name>(selector_arg, ...) _Generic( (selector_arg), \
)" )"
); );
@ -104,73 +104,56 @@ R"(#define <macro_name>(selector_arg, ...) _Generic( (selector_arg), \
for ( s32 slot = 1; slot <= num_slots; ++ slot ) for ( s32 slot = 1; slot <= num_slots; ++ slot )
{ {
StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", slot).to_strc(); Str slot_str = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%d", slot).to_str();
if (slot == num_slots && false)
{
define_builder.append( token_fmt( "macro_name", macro_name, "slot", slot_str,
R"( GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT_LAST( GENERIC_SLOT_<slot>__<macro_name> ) \
)"
));
// if ( one_arg )
// define_builder.append(token_fmt( "macro_name", macro_name, stringize(
// default: static_assert(false, "<macro_name>: Failed to select correct function signature (Did you pass the type?)")
// )));
// else
// define_builder.append(token_fmt( "macro_name", macro_name, stringize(
// default: static_assert(false, "<macro_name>: Failed to select correct function signature")
// )));
continue;
}
define_builder.append( token_fmt( "macro_name", macro_name, "slot", slot_str, define_builder.append( token_fmt( "macro_name", macro_name, "slot", slot_str,
R"( GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_<slot>__<macro_name> ) \ R"(GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_<slot>__<macro_name> ) \
)" )"
)); ));
} }
define_builder.append( txt("default: gen_generic_selection_fail") ); define_builder.append( txt("default: gen_generic_selection_fail\\\n") );
if ( ! one_arg ) if ( ! one_arg )
{ {
if (opts == GenericSel_By_Ref) if (opts == GenericSel_By_Ref)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( & selector_arg, __VA_ARGS__ )")); define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( & selector_arg, __VA_ARGS__ )"));
else if (opts == GenericSel_Direct_Type) else if (opts == GenericSel_Direct_Type)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( __VA_ARGS__ )")); define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( __VA_ARGS__ )"));
else else
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARGS__ )")); define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARGS__ )"));
} }
else else
{ {
if (opts == GenericSel_By_Ref) if (opts == GenericSel_By_Ref)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( & selector_arg )")); define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( & selector_arg )"));
else if (opts == GenericSel_Direct_Type) else if (opts == GenericSel_Direct_Type)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL()")); define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL()"));
else else
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( selector_arg )")); define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( selector_arg )"));
} }
// Add gap for next definition // Add gap for next definition
define_builder.append(txt("\n\n")); define_builder.append(txt("\n\n"));
Code macro = untyped_str(define_builder.to_strc()); Code macro = untyped_str(define_builder.to_str());
return macro; return macro;
} }
CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt("")) CodeFn rename_function_to_unique_symbol(CodeFn fn, Str optional_prefix = txt(""))
{ {
// Get basic components for the name // Get basic components for the name
StrC old_name = fn->Name; Str old_name = fn->Name;
String new_name; StrBuilder new_name;
// Add prefix if provided // Add prefix if provided
if (optional_prefix.Len) if (optional_prefix.Len)
new_name = string_fmt_buf(GlobalAllocator, "%SC_%SC_", optional_prefix, old_name); new_name = strbuilder_fmt_buf(_ctx->Allocator_Temp, "%S_%S_", optional_prefix, old_name);
else else
new_name = string_fmt_buf(GlobalAllocator, "%SC_", old_name); new_name = strbuilder_fmt_buf(_ctx->Allocator_Temp, "%S_", old_name);
// Add return type to the signature // Add return type to the signature
if (fn->ReturnType) if (fn->ReturnType)
new_name.append_fmt("_%SC", fn->ReturnType->Name); new_name.append_fmt("_%S", fn->ReturnType->Name);
// Add parameter types to create a unique signature // Add parameter types to create a unique signature
bool first_param = true; bool first_param = true;
@ -198,11 +181,11 @@ CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt(""
continue; continue;
} }
new_name.append_fmt("%SC_", spec_to_str(spec)); new_name.append_fmt("%S_", spec_to_str(spec));
} }
} }
new_name.append_fmt("%SC", param->ValueType->Name); new_name.append_fmt("%S", param->ValueType->Name);
} }
} }
@ -214,7 +197,7 @@ CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt(""
spec != end(fn->Specs); spec != end(fn->Specs);
++spec) ++spec)
{ {
new_name.append_fmt("%SC_", spec_to_str(*spec)); new_name.append_fmt("%S_", spec_to_str(*spec));
} }
} }
@ -223,13 +206,13 @@ CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt(""
} }
using SwapContentProc = CodeBody(void); using SwapContentProc = CodeBody(void);
bool swap_pragma_region_implementation( StrC region_name, SwapContentProc* swap_content, Code& entry_iter, CodeBody& body ) bool swap_pragma_region_implementation( Str region_name, SwapContentProc* swap_content, Code& entry_iter, CodeBody& body )
{ {
bool found = false; bool found = false;
CodePragma possible_region = cast(CodePragma, entry_iter); CodePragma possible_region = cast(CodePragma, entry_iter);
String region_sig = string_fmt_buf(GlobalAllocator, "region %s", region_name.Ptr); StrBuilder region_sig = strbuilder_fmt_buf(_ctx->Allocator_Temp, "region %s", region_name.Ptr);
String endregion_sig = string_fmt_buf(GlobalAllocator, "endregion %s", region_name.Ptr); StrBuilder endregion_sig = strbuilder_fmt_buf(_ctx->Allocator_Temp, "endregion %s", region_name.Ptr);
if ( possible_region->Content.contains(region_sig)) if ( possible_region->Content.contains(region_sig))
{ {
found = true; found = true;

View File

@ -1,5 +1,5 @@
#define GEN_IMPLEMENTATION #define GEN_IMPLEMENTATION
#include "gen/gen.c" #include "gen/gen_singleheader.h"
int main() int main()
{ {

View File

@ -32,7 +32,10 @@ Code format( Code code ) {
int gen_main() int gen_main()
{ {
gen::init(); Context ctx {
};
gen::init(& ctx);
Code push_ignores = scan_file( (path_base "helpers/push_ignores.inline.hpp") ); Code push_ignores = scan_file( (path_base "helpers/push_ignores.inline.hpp") );
Code pop_ignores = scan_file( (path_base "helpers/pop_ignores.inline.hpp") ); Code pop_ignores = scan_file( (path_base "helpers/pop_ignores.inline.hpp") );
@ -117,13 +120,14 @@ int gen_main()
def_include(txt("components/types.hpp")), def_include(txt("components/types.hpp")),
preprocess_endif, preprocess_endif,
fmt_newline, fmt_newline,
untyped_str( to_strc_from_c_str(generation_notice) ) untyped_str( to_str_from_c_str(generation_notice) )
)); ));
// gen.hpp // gen.hpp
{ {
Code header_start = scan_file( path_base "components/header_start.hpp" ); Code header_start = scan_file( path_base "components/header_start.hpp" );
Code types = scan_file( path_base "components/types.hpp" ); Code types = scan_file( path_base "components/types.hpp" );
Code parser_types = scan_file( path_base "components/parser_types.hpp" );
Code ast = scan_file( path_base "components/ast.hpp" ); Code ast = scan_file( path_base "components/ast.hpp" );
Code ast_types = scan_file( path_base "components/ast_types.hpp" ); Code ast_types = scan_file( path_base "components/ast_types.hpp" );
Code code_types = scan_file( path_base "components/code_types.hpp" ); Code code_types = scan_file( path_base "components/code_types.hpp" );
@ -134,6 +138,7 @@ int gen_main()
CodeBody ecode = gen_ecode ( path_base "enums/ECodeTypes.csv" ); CodeBody ecode = gen_ecode ( path_base "enums/ECodeTypes.csv" );
CodeBody eoperator = gen_eoperator ( path_base "enums/EOperator.csv" ); CodeBody eoperator = gen_eoperator ( path_base "enums/EOperator.csv" );
CodeBody especifier = gen_especifier( path_base "enums/ESpecifier.csv" ); CodeBody especifier = gen_especifier( path_base "enums/ESpecifier.csv" );
CodeBody etoktype = gen_etoktype ( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" );
CodeBody ast_inlines = gen_ast_inlines(); CodeBody ast_inlines = gen_ast_inlines();
Builder _header = builder_open( "gen/gen.hpp" ); Builder _header = builder_open( "gen/gen.hpp" );
@ -153,6 +158,8 @@ int gen_main()
builder_print( header, fmt_newline); builder_print( header, fmt_newline);
builder_print( header, format(especifier) ); builder_print( header, format(especifier) );
builder_print( header, fmt_newline); builder_print( header, fmt_newline);
builder_print( header, format(etoktype));
builder_print( header, parser_types);
builder_print_fmt( header, "#pragma endregion Types\n\n" ); builder_print_fmt( header, "#pragma endregion Types\n\n" );
builder_print_fmt( header, "#pragma region AST\n" ); builder_print_fmt( header, "#pragma region AST\n" );
@ -171,7 +178,7 @@ int gen_main()
builder_print_fmt( header, "#pragma endregion Inlines\n" ); builder_print_fmt( header, "#pragma endregion Inlines\n" );
builder_print( header, header_end ); builder_print( header, header_end );
builder_print_fmt( header, "GEN_NS_END\n\n" ); builder_print_fmt( header, "\nGEN_NS_END\n\n" );
builder_print( header, pop_ignores ); builder_print( header, pop_ignores );
builder_write(header); builder_write(header);
} }
@ -190,12 +197,6 @@ int gen_main()
Code parsing_interface = scan_file( path_base "components/interface.parsing.cpp" ); Code parsing_interface = scan_file( path_base "components/interface.parsing.cpp" );
Code untyped = scan_file( path_base "components/interface.untyped.cpp" ); Code untyped = scan_file( path_base "components/interface.untyped.cpp" );
CodeBody etoktype = gen_etoktype( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" );
CodeBody nspaced_etoktype = def_global_body( args(
etoktype
));
Code formatted_toktype = format(nspaced_etoktype);
Builder _src = builder_open( "gen/gen.cpp" ); Builder _src = builder_open( "gen/gen.cpp" );
Builder* src = & _src; Builder* src = & _src;
builder_print_fmt( src, generation_notice ); builder_print_fmt( src, generation_notice );
@ -215,7 +216,6 @@ int gen_main()
builder_print( src, interface ); builder_print( src, interface );
builder_print( src, upfront ); builder_print( src, upfront );
builder_print_fmt( src, "\n#pragma region Parsing\n\n" ); builder_print_fmt( src, "\n#pragma region Parsing\n\n" );
builder_print( src, formatted_toktype );
builder_print( src, lexer ); builder_print( src, lexer );
builder_print( src, parser ); builder_print( src, parser );
builder_print( src, parsing_interface ); builder_print( src, parsing_interface );
@ -238,7 +238,7 @@ int gen_main()
builder_print( & header, def_include( txt("gen.hpp") )); builder_print( & header, def_include( txt("gen.hpp") ));
builder_print_fmt( & header, "\nGEN_NS_BEGIN\n" ); builder_print_fmt( & header, "\nGEN_NS_BEGIN\n" );
builder_print( & header, builder ); builder_print( & header, builder );
builder_print_fmt( & header, "GEN_NS_END\n" ); builder_print_fmt( & header, "\nGEN_NS_END\n" );
builder_write( & header); builder_write( & header);
} }
@ -278,10 +278,10 @@ int gen_main()
builder_print( & src, def_include( txt("gen.scanner.hpp") ) ); builder_print( & src, def_include( txt("gen.scanner.hpp") ) );
builder_print_fmt( & src, "\nGEN_NS_BEGIN\n" ); builder_print_fmt( & src, "\nGEN_NS_BEGIN\n" );
builder_print( & src, scanner ); builder_print( & src, scanner );
builder_print_fmt( & src, "GEN_NS_END\n" ); builder_print_fmt( & src, "\nGEN_NS_END\n" );
builder_write( & src); builder_write( & src);
} }
gen::deinit(); gen::deinit( & ctx);
return 0; return 0;
} }

View File

@ -17,24 +17,24 @@ constexpr char const* generation_notice =
"// This file was generated automatially by gencpp's singleheader.cpp" "// This file was generated automatially by gencpp's singleheader.cpp"
"(See: https://github.com/Ed94/gencpp)\n\n"; "(See: https://github.com/Ed94/gencpp)\n\n";
constexpr StrC implementation_guard_start = txt(R"( constexpr Str implementation_guard_start = txt(R"(
#pragma region GENCPP IMPLEMENTATION GUARD #pragma region GENCPP IMPLEMENTATION GUARD
#if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED) #if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
# define GEN_IMPLEMENTED # define GEN_IMPLEMENTED
)"); )");
constexpr StrC implementation_guard_end = txt(R"( constexpr Str implementation_guard_end = txt(R"(
#endif #endif
#pragma endregion GENCPP IMPLEMENTATION GUARD #pragma endregion GENCPP IMPLEMENTATION GUARD
)"); )");
constexpr StrC roll_own_dependencies_guard_start = txt(R"( constexpr Str roll_own_dependencies_guard_start = txt(R"(
//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file. //! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl // Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
#ifndef GEN_ROLL_OWN_DEPENDENCIES #ifndef GEN_ROLL_OWN_DEPENDENCIES
)"); )");
constexpr StrC roll_own_dependencies_guard_end = txt(R"( constexpr Str roll_own_dependencies_guard_end = txt(R"(
// GEN_ROLL_OWN_DEPENDENCIES // GEN_ROLL_OWN_DEPENDENCIES
#endif #endif
)"); )");
@ -54,7 +54,8 @@ Code format( Code code ) {
int gen_main() int gen_main()
{ {
gen::init(); Context ctx {};
gen::init( & ctx);
Code push_ignores = scan_file( path_base "helpers/push_ignores.inline.hpp" ); Code push_ignores = scan_file( path_base "helpers/push_ignores.inline.hpp" );
Code pop_ignores = scan_file( path_base "helpers/pop_ignores.inline.hpp" ); Code pop_ignores = scan_file( path_base "helpers/pop_ignores.inline.hpp" );
@ -77,7 +78,7 @@ int gen_main()
Code basic_types = scan_file( path_base "dependencies/basic_types.hpp" ); Code basic_types = scan_file( path_base "dependencies/basic_types.hpp" );
Code debug = scan_file( path_base "dependencies/debug.hpp" ); Code debug = scan_file( path_base "dependencies/debug.hpp" );
Code memory = scan_file( path_base "dependencies/memory.hpp" ); Code memory = scan_file( path_base "dependencies/memory.hpp" );
Code string_ops = scan_file( path_base "dependencies/string_ops.hpp" ); Code stirng_ops = scan_file( path_base "dependencies/string_ops.hpp" );
Code printing = scan_file( path_base "dependencies/printing.hpp" ); Code printing = scan_file( path_base "dependencies/printing.hpp" );
Code containers = scan_file( path_base "dependencies/containers.hpp" ); Code containers = scan_file( path_base "dependencies/containers.hpp" );
Code hashing = scan_file( path_base "dependencies/hashing.hpp" ); Code hashing = scan_file( path_base "dependencies/hashing.hpp" );
@ -93,7 +94,7 @@ int gen_main()
header.print( basic_types ); header.print( basic_types );
header.print( debug ); header.print( debug );
header.print( memory ); header.print( memory );
header.print( string_ops ); header.print( stirng_ops );
header.print( printing ); header.print( printing );
header.print( containers ); header.print( containers );
header.print( hashing ); header.print( hashing );
@ -105,22 +106,25 @@ int gen_main()
header.print( scan_file( path_base "dependencies/parsing.hpp" ) ); header.print( scan_file( path_base "dependencies/parsing.hpp" ) );
} }
header.print(fmt_newline);
header.print_fmt( "GEN_NS_END\n" ); header.print_fmt( "GEN_NS_END\n" );
header.print_fmt( roll_own_dependencies_guard_end ); header.print_fmt( roll_own_dependencies_guard_end );
header.print( fmt_newline ); header.print( fmt_newline );
} }
Code types = scan_file( path_base "components/types.hpp" ); Code types = scan_file( path_base "components/types.hpp" );
Code ast = scan_file( path_base "components/ast.hpp" ); Code parser_types = scan_file( path_base "components/parser_types.hpp");
Code ast_types = scan_file( path_base "components/ast_types.hpp" ); Code ast = scan_file( path_base "components/ast.hpp" );
Code code_types = scan_file( path_base "components/code_types.hpp" ); Code ast_types = scan_file( path_base "components/ast_types.hpp" );
Code interface = scan_file( path_base "components/interface.hpp" ); Code code_types = scan_file( path_base "components/code_types.hpp" );
Code inlines = scan_file( path_base "components/inlines.hpp" ); Code interface = scan_file( path_base "components/interface.hpp" );
Code header_end = scan_file( path_base "components/header_end.hpp" ); Code inlines = scan_file( path_base "components/inlines.hpp" );
Code header_end = scan_file( path_base "components/header_end.hpp" );
CodeBody ecode = gen_ecode ( path_base "enums/ECodeTypes.csv" ); CodeBody ecode = gen_ecode ( path_base "enums/ECodeTypes.csv" );
CodeBody eoperator = gen_eoperator ( path_base "enums/EOperator.csv" ); CodeBody eoperator = gen_eoperator ( path_base "enums/EOperator.csv" );
CodeBody especifier = gen_especifier( path_base "enums/ESpecifier.csv" ); CodeBody especifier = gen_especifier( path_base "enums/ESpecifier.csv" );
CodeBody etoktype = gen_etoktype ( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" );
CodeBody ast_inlines = gen_ast_inlines(); CodeBody ast_inlines = gen_ast_inlines();
header.print_fmt( "GEN_NS_BEGIN\n\n" ); header.print_fmt( "GEN_NS_BEGIN\n\n" );
@ -134,6 +138,9 @@ int gen_main()
header.print( fmt_newline ); header.print( fmt_newline );
header.print( format( especifier )); header.print( format( especifier ));
header.print( fmt_newline ); header.print( fmt_newline );
header.print( format( etoktype ));
header.print( parser_types );
header.print( fmt_newline );
header.print_fmt("#pragma endregion Types\n\n"); header.print_fmt("#pragma endregion Types\n\n");
header.print_fmt("#pragma region AST\n"); header.print_fmt("#pragma region AST\n");
@ -155,7 +162,11 @@ int gen_main()
if ( generate_builder ) { if ( generate_builder ) {
header.print( scan_file( path_base "auxillary/builder.hpp" ) ); header.print( scan_file( path_base "auxillary/builder.hpp" ) );
} }
if ( generate_scanner ) {
header.print( scan_file( path_base "auxillary/scanner.hpp" ) );
}
header.print(fmt_newline);
header.print_fmt( "GEN_NS_END\n" ); header.print_fmt( "GEN_NS_END\n" );
} }
@ -176,9 +187,10 @@ int gen_main()
Code timing = scan_file( path_base "dependencies/timing.cpp" ); Code timing = scan_file( path_base "dependencies/timing.cpp" );
header.print_fmt( roll_own_dependencies_guard_start ); header.print_fmt( roll_own_dependencies_guard_start );
header.print_fmt( "GEN_NS_BEGIN\n\n");
header.print( impl_start ); header.print( impl_start );
header.print( fmt_newline );
header.print_fmt( "GEN_NS_BEGIN\n");
header.print( debug ); header.print( debug );
header.print( string_ops ); header.print( string_ops );
header.print( printing ); header.print( printing );
@ -209,11 +221,9 @@ int gen_main()
Code parsing_interface = scan_file( path_base "components/interface.parsing.cpp" ); Code parsing_interface = scan_file( path_base "components/interface.parsing.cpp" );
Code untyped = scan_file( path_base "components/interface.untyped.cpp" ); Code untyped = scan_file( path_base "components/interface.untyped.cpp" );
CodeBody etoktype = gen_etoktype( path_base "enums/ETokType.csv", path_base "enums/AttributeTokens.csv" );
CodeNS parser_nspace = def_namespace( name(parser), def_namespace_body( args(etoktype)) );
header.print_fmt( "\nGEN_NS_BEGIN\n"); header.print_fmt( "\nGEN_NS_BEGIN\n");
header.print( static_data ); header.print( static_data );
header.print( fmt_newline);
header.print_fmt( "#pragma region AST\n\n" ); header.print_fmt( "#pragma region AST\n\n" );
header.print( ast_case_macros ); header.print( ast_case_macros );
@ -225,27 +235,24 @@ int gen_main()
header.print( interface ); header.print( interface );
header.print( upfront ); header.print( upfront );
header.print_fmt( "\n#pragma region Parsing\n\n" ); header.print_fmt( "\n#pragma region Parsing\n\n" );
header.print( format(parser_nspace) );
header.print( lexer ); header.print( lexer );
header.print( parser ); header.print( parser );
header.print( parsing_interface ); header.print( parsing_interface );
header.print_fmt( "\n#pragma endregion Parsing\n" ); header.print_fmt( "\n#pragma endregion Parsing\n" );
header.print_fmt("\n#pragma region Untyped\n");
header.print( untyped ); header.print( untyped );
header.print_fmt( "\n#pragma endregion Interface\n\n"); header.print_fmt("\n#pragma endregion Untyped\n");
header.print_fmt( "\n#pragma endregion Interface\n");
if ( generate_builder ) { if ( generate_builder ) {
header.print( scan_file( path_base "auxillary/builder.cpp" ) ); header.print( scan_file( path_base "auxillary/builder.cpp" ) );
} }
// Scanner header depends on implementation
if ( generate_scanner ) {
header.print( scan_file( path_base "auxillary/scanner.hpp" ) );
}
if ( generate_scanner ) { if ( generate_scanner ) {
header.print( scan_file( path_base "auxillary/scanner.cpp" ) ); header.print( scan_file( path_base "auxillary/scanner.cpp" ) );
} }
header.print( fmt_newline);
header.print_fmt( "GEN_NS_END\n"); header.print_fmt( "GEN_NS_END\n");
header.print_fmt( "%s\n", (char const*) implementation_guard_end ); header.print_fmt( "%s\n", (char const*) implementation_guard_end );
@ -254,6 +261,6 @@ int gen_main()
header.print( pop_ignores ); header.print( pop_ignores );
header.write(); header.write();
gen::deinit(); gen::deinit( & ctx);
return 0; return 0;
} }

View File

@ -7,12 +7,20 @@
https://github.com/Ed94/gencpp https://github.com/Ed94/gencpp
This is a variant intended for use with Unreal Engine 5 This is a variant intended for use with Unreal Engine 5
https://github.com/Ed94/gencpp --------------------------------------------------------------.
! ----------------------------------------------------------------------- VERSION: v0.20-Alpha ! | _____ _____ _ _ |
! ============================================================================================ ! | / ____) / ____} | | | |
! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION ! | | / ___ ___ _ __ ___ _ __ _ __ | {___ | |__ _ _, __ _, ___ __| | |
! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL ! | | |{_ |/ _ \ '_ \ / __} '_ l| '_ l `\___ \| __/ _` |/ _` |/ _ \/ _` | |
! ============================================================================================ ! | | l__j | ___/ | | | {__; |+l } |+l | ____) | l| (_| | {_| | ___/ (_| | |
| \_____|\___}_l |_|\___} ,__/| ,__/ (_____/ \__\__/_|\__, |\___}\__,_l |
| Unreal Engine | | | | __} | |
| l_l l_l {___/ |
! ----------------------------------------------------------------------- VERSION: v0.20-Alpha |
! ============================================================================================ |
! WARNING: THIS IS AN ALPHA VERSION OF THE LIBRARY, USE AT YOUR OWN DISCRETION |
! NEVER DO CODE GENERATION WITHOUT AT LEAST HAVING CONTENT IN A CODEBASE UNDER VERSION CONTROL |
! ============================================================================================ /
*/ */
#if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME) #if ! defined(GEN_DONT_ENFORCE_GEN_TIME_GUARD) && ! defined(GEN_TIME)
# error Gen.hpp : GEN_TIME not defined # error Gen.hpp : GEN_TIME not defined

View File

@ -17,25 +17,25 @@ constexpr char const* generation_notice =
"// This file was generated automatially by gencpp's unreal.cpp " "// This file was generated automatially by gencpp's unreal.cpp "
"(See: https://github.com/Ed94/gencpp)\n\n"; "(See: https://github.com/Ed94/gencpp)\n\n";
constexpr StrC implementation_guard_start = txt(R"( constexpr Str implementation_guard_start = txt(R"(
#pragma region GENCPP IMPLEMENTATION GUARD #pragma region GENCPP IMPLEMENTATION GUARD
#if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED) #if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
# define GEN_IMPLEMENTED # define GEN_IMPLEMENTED
)"); )");
constexpr StrC implementation_guard_end = txt(R"( constexpr Str implementation_guard_end = txt(R"(
#endif #endif
#pragma endregion GENCPP IMPLEMENTATION GUARD #pragma endregion GENCPP IMPLEMENTATION GUARD
)"); )");
constexpr StrC roll_own_dependencies_guard_start = txt(R"( constexpr Str roll_own_dependencies_guard_start = txt(R"(
//! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file. //! If its desired to roll your own dependencies, define GEN_ROLL_OWN_DEPENDENCIES before including this file.
// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl // Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
#ifndef GEN_ROLL_OWN_DEPENDENCIES #ifndef GEN_ROLL_OWN_DEPENDENCIES
)"); )");
constexpr StrC roll_own_dependencies_guard_end = txt(R"( constexpr Str roll_own_dependencies_guard_end = txt(R"(
// GEN_ROLL_OWN_DEPENDENCIES // GEN_ROLL_OWN_DEPENDENCIES
#endif #endif
)"); )");
@ -55,7 +55,8 @@ Code format( Code code ) {
int gen_main() int gen_main()
{ {
gen::init(); Context ctx {};
gen::init( & ctx);
Code push_ignores = scan_file( path_base "helpers/push_ignores.inline.hpp" ); Code push_ignores = scan_file( path_base "helpers/push_ignores.inline.hpp" );
Code pop_ignores = scan_file( path_base "helpers/pop_ignores.inline.hpp" ); Code pop_ignores = scan_file( path_base "helpers/pop_ignores.inline.hpp" );
@ -67,8 +68,8 @@ int gen_main()
{ {
CodeBody macros = def_body( CT_Global_Body ); CodeBody macros = def_body( CT_Global_Body );
{ {
FileContents content = file_read_contents( GlobalAllocator, true, path_base "dependencies/macros.hpp" ); FileContents content = file_read_contents( ctx.Allocator_Temp, file_zero_terminate, path_base "dependencies/macros.hpp" );
CodeBody ori_macros = parse_global_body( StrC { content.size, (char const*)content.data }); CodeBody ori_macros = parse_global_body( Str { (char const*)content.data, content.size });
for (Code code = ori_macros.begin(); for (Code code = ori_macros.begin();
code != ori_macros.end(); code != ori_macros.end();
@ -175,6 +176,7 @@ int gen_main()
{ {
Code header_start = scan_file( "components/header_start.hpp" ); Code header_start = scan_file( "components/header_start.hpp" );
Code types = scan_file( path_base "components/types.hpp" ); Code types = scan_file( path_base "components/types.hpp" );
Code parser_types = scan_file( path_base "components/parser_types.hpp");
Code ast = scan_file( path_base "components/ast.hpp" ); Code ast = scan_file( path_base "components/ast.hpp" );
Code ast_types = scan_file( path_base "components/ast_types.hpp" ); Code ast_types = scan_file( path_base "components/ast_types.hpp" );
Code code_types = scan_file( path_base "components/code_types.hpp" ); Code code_types = scan_file( path_base "components/code_types.hpp" );
@ -187,6 +189,11 @@ int gen_main()
CodeBody especifier = gen_especifier( path_base "enums/ESpecifier.csv" ); CodeBody especifier = gen_especifier( path_base "enums/ESpecifier.csv" );
CodeBody ast_inlines = gen_ast_inlines(); CodeBody ast_inlines = gen_ast_inlines();
// Note(Ed): The Attribute tokens need to be expanded and regenerated on a per-project/installation of this library for a specific codebase of Unreal.
// We can support an arbitrary set of modules or plugin apis for parsing
// but its up to the user to define them all (This will just provide whats I've used up till now).
CodeBody etoktype = gen_etoktype( path_base "enums/ETokType.csv", "enums/AttributeTokens.csv" );
Builder Builder
header = Builder::open( "gen/gen.hpp" ); header = Builder::open( "gen/gen.hpp" );
header.print_fmt( generation_notice ); header.print_fmt( generation_notice );
@ -205,6 +212,8 @@ int gen_main()
header.print( fmt_newline ); header.print( fmt_newline );
header.print( format(especifier) ); header.print( format(especifier) );
header.print( fmt_newline ); header.print( fmt_newline );
header.print( format(etoktype) );
header.print( parser_types );
header.print_fmt( "#pragma endregion Types\n\n" ); header.print_fmt( "#pragma endregion Types\n\n" );
header.print_fmt( "#pragma region AST\n" ); header.print_fmt( "#pragma region AST\n" );
@ -223,14 +232,14 @@ int gen_main()
header.print_fmt( "#pragma endregion Inlines\n" ); header.print_fmt( "#pragma endregion Inlines\n" );
header.print( header_end ); header.print( header_end );
header.print_fmt( "GEN_NS_END\n\n" ); header.print_fmt( "\nGEN_NS_END\n\n" );
header.print( pop_ignores ); header.print( pop_ignores );
header.write(); header.write();
} }
// gen.cpp // gen.cpp
{ {
Code src_start = scan_file( "components/src_start.cpp" ); Code src_start = scan_file( "components/src_start.cpp" );
Code static_data = scan_file( path_base "components/static_data.cpp" ); Code static_data = scan_file( path_base "components/static_data.cpp" );
Code ast_case_macros = scan_file( path_base "components/ast_case_macros.cpp" ); Code ast_case_macros = scan_file( path_base "components/ast_case_macros.cpp" );
Code ast = scan_file( path_base "components/ast.cpp" ); Code ast = scan_file( path_base "components/ast.cpp" );
@ -242,11 +251,6 @@ int gen_main()
Code parsing_interface = scan_file( path_base "components/interface.parsing.cpp" ); Code parsing_interface = scan_file( path_base "components/interface.parsing.cpp" );
Code untyped = scan_file( path_base "components/interface.untyped.cpp" ); Code untyped = scan_file( path_base "components/interface.untyped.cpp" );
// Note(Ed): The Attribute tokens need to be expanded and regenerated on a per-project/installation of this library for a specific codebase of Unreal.
// We can support an arbitrary set of modules or plugin apis for parsing
// but its up to the user to define them all (This will just provide whats I've used up till now).
CodeBody etoktype = gen_etoktype( path_base "enums/ETokType.csv", "enums/AttributeTokens.csv" );
Builder Builder
src = Builder::open( "gen/gen.cpp" ); src = Builder::open( "gen/gen.cpp" );
src.print_fmt( generation_notice ); src.print_fmt( generation_notice );
@ -268,7 +272,6 @@ int gen_main()
src.print( interface ); src.print( interface );
src.print( upfront ); src.print( upfront );
src.print_fmt( "\n#pragma region Parsing\n\n" ); src.print_fmt( "\n#pragma region Parsing\n\n" );
src.print( format(etoktype) );
src.print( lexer ); src.print( lexer );
src.print( parser ); src.print( parser );
src.print( parsing_interface ); src.print( parsing_interface );
@ -294,7 +297,7 @@ int gen_main()
header.print( def_include( txt("gen.hpp") )); header.print( def_include( txt("gen.hpp") ));
header.print_fmt( "\nGEN_NS_BEGIN\n" ); header.print_fmt( "\nGEN_NS_BEGIN\n" );
header.print( builder ); header.print( builder );
header.print_fmt( "GEN_NS_END\n" ); header.print_fmt( "\nGEN_NS_END\n" );
header.print( fmt_newline ); header.print( fmt_newline );
header.print( pop_ignores ); header.print( pop_ignores );
header.write(); header.write();
@ -333,7 +336,7 @@ int gen_main()
header.print_fmt( "\nGEN_NS_BEGIN\n" ); header.print_fmt( "\nGEN_NS_BEGIN\n" );
header.print( parsing ); header.print( parsing );
header.print( scanner ); header.print( scanner );
header.print_fmt( "GEN_NS_END\n" ); header.print_fmt( "\nGEN_NS_END\n" );
header.print( fmt_newline ); header.print( fmt_newline );
header.print( pop_ignores ); header.print( pop_ignores );
header.write(); header.write();
@ -353,7 +356,7 @@ int gen_main()
src.print_fmt( "\nGEN_NS_BEGIN\n" ); src.print_fmt( "\nGEN_NS_BEGIN\n" );
src.print( parsing ); src.print( parsing );
// src.print( scanner ); // src.print( scanner );
src.print_fmt( "GEN_NS_END\n" ); src.print_fmt( "\nGEN_NS_END\n" );
src.print( fmt_newline ); src.print( fmt_newline );
src.print( pop_ignores ); src.print( pop_ignores );
src.write(); src.write();

View File

@ -1,3 +1,3 @@
<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation"> <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=53AF600D_002DC09C_002D4F39_002D83E0_002DE022AA9479F2_002Fd_003Athirdparty_002Ff_003Azpl_002Eh/@EntryIndexedValue">ForceIncluded</s:String> <s:StrBuilder x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=53AF600D_002DC09C_002D4F39_002D83E0_002DE022AA9479F2_002Fd_003Athirdparty_002Ff_003Azpl_002Eh/@EntryIndexedValue">ForceIncluded</s:StrBuilder>
<s:String x:Key="/Default/CodeInspection/Highlighting/SweaWarningsMode/@EntryValue">ShowAndRun</s:String></wpf:ResourceDictionary> <s:StrBuilder x:Key="/Default/CodeInspection/Highlighting/SweaWarningsMode/@EntryValue">ShowAndRun</s:StrBuilder></wpf:ResourceDictionary>

View File

@ -1,8 +1,9 @@
# Format Style Options - Created with Clang Power Tools # Format Style Options - Created with Clang Power Tools
--- ---
# AttributeMacros: [ AttributeMacros: [
# ] GEN_API
]
StatementMacros: [ StatementMacros: [
GEN_NS_BEGIN, GEN_NS_BEGIN,
GEN_NS_END, GEN_NS_END,
@ -15,6 +16,8 @@ StatementMacros: [
Macros: Macros:
- enum_underlying(type)=type - enum_underlying(type)=type
- gen_enum_underlying(type)=type - gen_enum_underlying(type)=type
# WhitespaceSensitiveMacros: [
# ]
TypenameMacros: [Array, Hashtable] TypenameMacros: [Array, Hashtable]
SkipMacroDefinitionBody: false SkipMacroDefinitionBody: false

View File

@ -17,8 +17,10 @@ Push-Location $path_root
#region Arguments #region Arguments
$vendor = $null $vendor = $null
$release = $null $release = $null
$verbose = $false [bool] $verbose = $false
$base = $false [bool] $shared = $false
[bool] $dyn_link = $false
[bool] $base = $false
[bool] $segmented = $false [bool] $segmented = $false
[bool] $singleheader = $false [bool] $singleheader = $false
[bool] $c_library = $false [bool] $c_library = $false
@ -35,8 +37,10 @@ if ( $args ) { $args | ForEach-Object {
"verbose" { $verbose = $true } "verbose" { $verbose = $true }
"release" { $release = $true } "release" { $release = $true }
"debug" { $release = $false } "debug" { $release = $false }
"shared" { $shared = $true }
"dyn_link" { $dyn_link = $true }
"base" { $base = $true } "base" { $base = $true }
"segmented" { $segmented = $true } "segmented" { $segmented = $true }
"singleheader" { $singleheader = $true } "singleheader" { $singleheader = $true }
"c_library" { $c_library = $true } "c_library" { $c_library = $true }
"unreal" { $unreal = $true } "unreal" { $unreal = $true }

View File

@ -21,10 +21,10 @@
<Action>NoStepInto</Action> <Action>NoStepInto</Action>
</Function> </Function>
<Function> <Function>
<Name>gen::Code.*::to_string</Name> <Name>gen::Code.*::to_strbuilder</Name>
<Action>NoStepInto</Action> <Action>NoStepInto</Action>
</Function> </Function>
<Function> <Function>
<Name>gen::String::operator .*</Name> <Name>gen::StrBuilder::operator .*</Name>
</Function> </Function>
</StepFilter> </StepFilter>

View File

@ -36,11 +36,11 @@
</Expand> </Expand>
</Type> </Type>
<Type Name="gen::StrC"> <Type Name="gen::Str">
<DisplayString>Len:{Len} Ptr:{Ptr, [Len]s}</DisplayString> <DisplayString>Len:{Len} Ptr:{Ptr, [Len]s}</DisplayString>
</Type> </Type>
<Type Name="gen::String"> <Type Name="gen::StrBuilder">
<DisplayString Condition="Data == nullptr">null</DisplayString> <DisplayString Condition="Data == nullptr">null</DisplayString>
<DisplayString>{Data,na}</DisplayString> <DisplayString>{Data,na}</DisplayString>
<Expand> <Expand>
@ -55,7 +55,7 @@
</Expand> </Expand>
</Type> </Type>
<Type Name="gen::String::Header"> <Type Name="gen::StrBuilder::Header">
<DisplayString>Length: {Length}, Capacity: {Capacity}</DisplayString> <DisplayString>Length: {Length}, Capacity: {Capacity}</DisplayString>
<Expand> <Expand>
<Item Name="Allocator">Allocator</Item> <Item Name="Allocator">Allocator</Item>