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
2. Create a code object using `make_code`.
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.

View File

@ -15,7 +15,7 @@ Builder builder_open( char const* path )
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 );
return result;
@ -23,15 +23,15 @@ Builder builder_open( char const* path )
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 )
{
String str = code_to_string(code);
StrBuilder str = code_to_strbuilder(code);
// const ssize len = str.length();
// 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 )
@ -39,21 +39,21 @@ void builder_print_fmt_va( Builder* builder, char const* fmt, va_list va )
ssize res;
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)
{
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 )
log_failure("gen::File::write - Failed to write to file: %s\n", file_name( & builder->File ) );
log_fmt( "Generated: %s\n", builder->File.filename );
file_close( & builder->File );
string_free(& builder->Buffer);
strbuilder_free(& builder->Buffer);
}
#pragma endregion Builder

View File

@ -36,7 +36,7 @@ void builder_write( Builder* builder );
struct Builder
{
FileInfo File;
String Buffer;
StrBuilder Buffer;
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
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_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 );
}
String str = string_make_reserve( GlobalAllocator, fsize );
StrBuilder str = strbuilder_make_reserve( _ctx->Allocator_Temp, fsize );
file_read( & file, str, fsize );
string_get_header(str)->Length = fsize;
strbuilder_get_header(str)->Length = fsize;
// Skip GEN_INTELLISENSE_DIRECTIVES preprocessor blocks
// 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 matched 0
#define move_fwd() do { ++ scanner; -- left; } while (0)
const StrC directive_start = txt( "ifdef" );
const StrC directive_end = txt( "endif" );
const StrC def_intellisense = txt("GEN_INTELLISENSE_DIRECTIVES" );
const Str directive_start = txt( "ifdef" );
const Str directive_end = txt( "endif" );
const Str def_intellisense = txt("GEN_INTELLISENSE_DIRECTIVES" );
bool found_directive = false;
char const* scanner = (char const*)str;
@ -49,7 +49,7 @@ Code scan_file( char const* path )
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;
left -= directive_start.Len;
@ -57,7 +57,7 @@ Code scan_file( char const* path )
while ( left && char_is_space( current ) )
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;
left -= def_intellisense.Len;
@ -77,7 +77,7 @@ Code scan_file( char const* path )
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;
left -= directive_end.Len;
@ -94,12 +94,12 @@ Code scan_file( char const* path )
if ( (scanner + 2) >= ( (char const*) str + fsize ) )
{
mem_move( str, scanner, left );
string_get_header(str)->Length = left;
strbuilder_get_header(str)->Length = left;
break;
}
mem_move( str, scanner, left );
string_get_header(str)->Length = left;
strbuilder_get_header(str)->Length = left;
break;
}
@ -113,12 +113,12 @@ Code scan_file( char const* path )
}
file_close( & file );
return untyped_str( string_to_strc(str) );
return untyped_str( strbuilder_to_str(str) );
}
CodeBody parse_file( const char* path ) {
FileContents file = file_read_contents( GlobalAllocator, true, path );
StrC content = { file.size, (char const*)file.data };
FileContents file = file_read_contents( _ctx->Allocator_Temp, true, path );
Str content = { (char const*)file.data, file.size };
CodeBody code = parse_global_body( content );
log_fmt("\nParsed: %s\n", path);
return code;

View File

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

File diff suppressed because it is too large Load Diff

View File

@ -230,40 +230,25 @@ struct CodeUsing;
struct CodeVar;
#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
template< class Type> forceinline Type tmpl_cast( Code self ) { return * rcast( Type*, & self ); }
#endif
#pragma region Code C-Interface
void code_append (Code code, Code other );
StrC code_debug_str (Code code);
Code code_duplicate (Code code);
Code* code_entry (Code code, u32 idx );
bool code_has_entries (Code code);
bool code_is_body (Code code);
bool code_is_equal (Code code, Code other);
bool code_is_valid (Code code);
void code_set_global (Code code);
String code_to_string (Code self );
void code_to_string_ptr(Code self, String* result );
StrC code_type_str (Code self );
bool code_validate_body(Code self );
GEN_API void code_append (Code code, Code other );
GEN_API Str code_debug_str (Code code);
GEN_API Code code_duplicate (Code code);
GEN_API Code* code_entry (Code code, u32 idx );
GEN_API bool code_has_entries (Code code);
GEN_API bool code_is_body (Code code);
GEN_API bool code_is_equal (Code code, Code other);
GEN_API bool code_is_valid (Code code);
GEN_API void code_set_global (Code code);
GEN_API StrBuilder code_to_strbuilder (Code self );
GEN_API void code_to_strbuilder_ptr(Code self, StrBuilder* result );
GEN_API Str code_type_str (Code self );
GEN_API bool code_validate_body (Code self );
#pragma endregion Code C-Interface
@ -278,7 +263,7 @@ struct Code
AST* ast;
# 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 bool is_equal( Code other ) { return code_is_equal(* this, other); } \
forceinline bool is_body() { return code_is_body(* this); } \
@ -295,16 +280,17 @@ struct Code
#if ! GEN_C_LIKE_CPP
Using_Code( Code );
forceinline void append(Code other) { return code_append(* this, other); }
forceinline Code* entry(u32 idx) { return code_entry(* this, idx); }
forceinline bool has_entries() { return code_has_entries(* this); }
forceinline String to_string() { return code_to_string(* this); }
forceinline void to_string(String& result) { return code_to_string_ptr(* this, & result); }
forceinline StrC type_str() { return code_type_str(* this); }
forceinline bool validate_body() { return code_validate_body(*this); }
forceinline void append(Code other) { return code_append(* this, other); }
forceinline Code* entry(u32 idx) { return code_entry(* this, idx); }
forceinline bool has_entries() { return code_has_entries(* this); }
forceinline StrBuilder to_strbuilder() { return code_to_strbuilder(* this); }
forceinline void to_strbuilder(StrBuilder& result) { return code_to_strbuilder_ptr(* this, & result); }
forceinline Str type_str() { return code_type_str(* this); }
forceinline bool validate_body() { return code_validate_body(*this); }
#endif
Using_CodeOps( Code );
forceinline Code operator *() { return * this; } // Required to support for-range iteration.
forceinline AST* operator ->() { return ast; }
Code& operator ++();
@ -367,7 +353,7 @@ int AST_ArrSpecs_Cap =
(
AST_POD_Size
- sizeof(Code)
- sizeof(StringCached)
- sizeof(StrCached)
- sizeof(Code) * 2
- sizeof(Token*)
- sizeof(Code)
@ -413,13 +399,13 @@ struct AST
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 {
Specifier ArrSpecs[AST_ArrSpecs_Cap]; // Specifiers
Code NextSpecs; // Specifiers; If ArrSpecs is full, then NextSpecs is used.
};
};
StringCached Name;
StrCached Name;
union {
Code Prev;
Code Front;

View File

@ -31,7 +31,7 @@ struct AST_Body
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
Code Front;
Code Back;
Token* Tok;
@ -46,9 +46,9 @@ struct AST_Attributes
{
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content;
StrCached Content;
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -64,7 +64,7 @@ struct AST_BaseClass
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -79,9 +79,9 @@ struct AST_Comment
{
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content;
StrCached Content;
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -106,7 +106,7 @@ struct AST_Class
char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
};
};
StringCached Name;
StrCached Name;
CodeTypename Prev;
CodeTypename Next;
Token* Tok;
@ -132,7 +132,7 @@ struct AST_Constructor
char _PAD_PROPERTIES_2_ [ sizeof(AST*) * 2 ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -146,9 +146,9 @@ struct AST_Define
{
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content;
StrCached Content;
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -172,7 +172,7 @@ struct AST_Destructor
char _PAD_PROPERTIES_3_ [ sizeof(AST*) ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -197,7 +197,7 @@ struct AST_Enum
char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -212,9 +212,9 @@ struct AST_Exec
{
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content;
StrCached Content;
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -230,7 +230,7 @@ struct AST_Expr
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -245,7 +245,7 @@ struct AST_Expr_Assign
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -260,7 +260,7 @@ struct AST_Expr_Alignof
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -275,7 +275,7 @@ struct AST_Expr_Binary
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -290,7 +290,7 @@ struct AST_Expr_CStyleCast
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -305,7 +305,7 @@ struct AST_Expr_FunctionalCast
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -320,7 +320,7 @@ struct AST_Expr_CppCast
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -335,7 +335,7 @@ struct AST_Expr_ProcCall
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -350,7 +350,7 @@ struct AST_Expr_Decltype
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -365,7 +365,7 @@ struct AST_Expr_Comma
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -380,7 +380,7 @@ struct AST_Expr_AMS
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -395,7 +395,7 @@ struct AST_Expr_Sizeof
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -410,7 +410,7 @@ struct AST_Expr_Subscript
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -425,7 +425,7 @@ struct AST_Expr_Ternary
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -440,7 +440,7 @@ struct AST_Expr_UnaryPrefix
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -455,7 +455,7 @@ struct AST_Expr_UnaryPostfix
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -470,7 +470,7 @@ struct AST_Expr_Element
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -492,7 +492,7 @@ struct AST_Extern
char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -506,9 +506,9 @@ struct AST_Include
{
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content;
StrCached Content;
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -530,7 +530,7 @@ struct AST_Friend
char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -555,7 +555,7 @@ struct AST_Fn
char _PAD_PROPERTIES_ [ sizeof(AST*) ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -571,7 +571,7 @@ struct AST_Module
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -592,7 +592,7 @@ struct AST_NS
char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -618,7 +618,7 @@ struct AST_Operator
char _PAD_PROPERTIES_ [ sizeof(AST*) ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -644,7 +644,7 @@ struct AST_OpCast
char _PAD_PROPERTIES_3_[ sizeof(AST*) ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -668,7 +668,7 @@ struct AST_Params
// char _PAD_PROPERTIES_3_[sizeof( AST* )];
};
};
StringCached Name;
StrCached Name;
CodeParams Last;
CodeParams Next;
Token* Tok;
@ -683,9 +683,9 @@ struct AST_Pragma
{
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content;
StrCached Content;
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -699,9 +699,9 @@ struct AST_PreprocessCond
{
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
StringCached Content;
StrCached Content;
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -714,7 +714,7 @@ static_assert( sizeof(AST_PreprocessCond) == sizeof(AST), "ERROR: AST_Preprocess
struct AST_Specifiers
{
Specifier ArrSpecs[ AST_ArrSpecs_Cap ];
StringCached Name;
StrCached Name;
CodeSpecifiers NextSpecs;
Code Prev;
Code Next;
@ -732,7 +732,7 @@ struct AST_Stmt
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -747,7 +747,7 @@ struct AST_Stmt_Break
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -762,7 +762,7 @@ struct AST_Stmt_Case
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -777,7 +777,7 @@ struct AST_Stmt_Continue
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -792,7 +792,7 @@ struct AST_Stmt_Decl
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -807,7 +807,7 @@ struct AST_Stmt_Do
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -822,7 +822,7 @@ struct AST_Stmt_Expr
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -837,7 +837,7 @@ struct AST_Stmt_Else
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -852,7 +852,7 @@ struct AST_Stmt_If
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -867,7 +867,7 @@ struct AST_Stmt_For
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -882,7 +882,7 @@ struct AST_Stmt_Goto
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -897,7 +897,7 @@ struct AST_Stmt_Label
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -912,7 +912,7 @@ struct AST_Stmt_Switch
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -927,7 +927,7 @@ struct AST_Stmt_While
union {
char _PAD_[ sizeof(Specifier) * AST_ArrSpecs_Cap + sizeof(AST*) ];
};
StringCached Name;
StrCached Name;
CodeExpr Prev;
CodeExpr Next;
Token* Tok;
@ -953,7 +953,7 @@ struct AST_Struct
char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
};
};
StringCached Name;
StrCached Name;
CodeTypename Prev;
CodeTypename Next;
Token* Tok;
@ -976,7 +976,7 @@ struct AST_Template
char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -1005,7 +1005,7 @@ struct AST_Type
// CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -1032,7 +1032,7 @@ struct AST_Typename
CodeSpecifiers SpecsFuncSuffix; // Only used for function signatures
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -1058,7 +1058,7 @@ struct AST_Typedef
char _PAD_PROPERTIES_2_[ sizeof(AST*) * 3 ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -1082,7 +1082,7 @@ struct AST_Union
char _PAD_PROPERTIES_2_[ sizeof(AST*) ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -1106,7 +1106,7 @@ struct AST_Using
char _PAD_PROPERTIES_[ sizeof(AST*) * 3 ];
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -1132,7 +1132,7 @@ struct AST_Var
CodeVar NextVar;
};
};
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
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 )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -95,7 +95,7 @@ inline AST_Comment* CodeComment::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -126,7 +126,7 @@ inline AST_Constructor* CodeConstructor::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -173,7 +173,7 @@ inline AST_Define* CodeDefine::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -204,7 +204,7 @@ inline AST_Destructor* CodeDestructor::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -235,7 +235,7 @@ inline AST_Enum* CodeEnum::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -266,7 +266,7 @@ inline AST_Exec* CodeExec::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -297,7 +297,7 @@ inline AST_Extern* CodeExtern::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -328,7 +328,7 @@ inline AST_Friend* CodeFriend::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -359,7 +359,7 @@ inline AST_Fn* CodeFn::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -390,7 +390,7 @@ inline AST_Include* CodeInclude::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -421,7 +421,7 @@ inline AST_Module* CodeModule::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -452,7 +452,7 @@ inline AST_NS* CodeNS::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -483,7 +483,7 @@ inline AST_Operator* CodeOperator::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -514,7 +514,7 @@ inline AST_OpCast* CodeOpCast::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -561,7 +561,7 @@ inline AST_Pragma* CodePragma::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -592,7 +592,7 @@ inline AST_PreprocessCond* CodePreprocessCond::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -655,7 +655,7 @@ inline AST_Template* CodeTemplate::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -686,7 +686,7 @@ inline AST_Typename* CodeTypename::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -717,7 +717,7 @@ inline AST_Typedef* CodeTypedef::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -748,7 +748,7 @@ inline AST_Union* CodeUnion::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -779,7 +779,7 @@ inline AST_Using* CodeUsing::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -810,7 +810,7 @@ inline AST_Var* CodeVar::operator->()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;

View File

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

View File

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

View File

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

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
#ifndef GEN_GLOBAL_BUCKET_SIZE
# 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 Str enum_underlying_sig;
extern Code access_public;
extern Code access_protected;
@ -111,6 +64,7 @@ extern CodeTypename t_typename;
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
// Predefined typename codes. Are set to readonly and are setup during gen::init()
extern Context* _ctx;
extern CodeTypename t_b32;
@ -132,28 +86,3 @@ extern CodeTypename t_typename;
#endif
#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
forceinline
StrC code_type_str(Code self)
Str code_type_str(Code self)
{
GEN_ASSERT(self != nullptr);
return codetype_to_str( self->Type );
@ -397,7 +397,7 @@ CodeBody def_body( CodeType type )
}
inline
StrC token_fmt_impl( ssize num, ... )
Str token_fmt_impl( ssize num, ... )
{
local_persist thread_local
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);
va_end(va);
StrC str = { result, buf };
Str str = { buf, result };
return str;
}
#pragma endregion Interface

View File

@ -3,15 +3,15 @@
#include "code_serialization.cpp"
#endif
GEN_NS_PARSER_BEGIN
internal void parser_init();
internal void parser_deinit();
GEN_NS_PARSER_END
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 )
{
@ -19,15 +19,15 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s
{
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 )
GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
GEN_FATAL( "Failed to create bucket for Fallback_AllocatorBuckets");
if ( ! array_append( Global_AllocatorBuckets, bucket ) )
GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
if ( ! array_append( _ctx->Fallback_AllocatorBuckets, bucket ) )
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 );
@ -46,15 +46,15 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s
{
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 )
GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
GEN_FATAL( "Failed to create bucket for Fallback_AllocatorBuckets");
if ( ! array_append( Global_AllocatorBuckets, bucket ) )
GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
if ( ! array_append( _ctx->Fallback_AllocatorBuckets, bucket ) )
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 );
@ -74,8 +74,12 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s
internal
void define_constants()
{
// We only initalize these if there is no base context.
if ( context_counter > 0 )
return;
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_Invalid = make_code();
@ -83,41 +87,41 @@ void define_constants()
t_empty = (CodeTypename) make_code();
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));
access_private = make_code();
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));
access_protected = make_code();
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);
access_public = make_code();
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);
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 );
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 );
code_set_global(cast(Code, attrib_api_import));
module_global_fragment = make_code();
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;
code_set_global(cast(Code, module_global_fragment));
module_private_fragment = make_code();
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;
code_set_global(cast(Code, module_private_fragment));
@ -127,13 +131,13 @@ void define_constants()
pragma_once = (CodePragma) make_code();
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;
code_set_global((Code)pragma_once);
param_varadic = (CodeParams) make_code();
param_varadic->Type = CT_Parameters;
param_varadic->Name = get_cached_string( txt("...") );
param_varadic->Name = cache_str( txt("...") );
param_varadic->ValueType = t_empty;
code_set_global((Code)param_varadic);
@ -145,33 +149,33 @@ void define_constants()
preprocess_endif->Type = CT_Preprocess_EndIf;
code_set_global((Code)preprocess_endif);
StrC 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 );
StrC 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 );
StrC 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 );
StrC 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 auto_str = txt("auto"); t_auto = def_type( auto_str ); code_set_global( t_auto );
Str void_str = txt("void"); t_void = def_type( void_str ); code_set_global( t_void );
Str int_str = txt("int"); t_int = def_type( int_str ); code_set_global( t_int );
Str bool_str = txt("bool"); t_bool = def_type( bool_str ); code_set_global( t_bool );
Str char_str = txt("char"); t_char = def_type( char_str ); code_set_global( t_char );
Str wchar_str = txt("wchar_t"); t_wchar_t = def_type( wchar_str ); code_set_global( t_wchar_t );
Str class_str = txt("class"); t_class = def_type( class_str ); code_set_global( t_class );
Str typename_str = txt("typename"); t_typename = def_type( typename_str ); code_set_global( t_typename );
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
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 );
StrC 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 );
StrC s64_str = txt("s64"); t_s64 = def_type( s64_str ); code_set_global( t_s64 );
Str s8_str = txt("s8"); t_s8 = def_type( s8_str ); code_set_global( t_s8 );
Str s16_str = txt("s16"); t_s16 = def_type( s16_str ); code_set_global( t_s16 );
Str s32_str = txt("s32"); t_s32 = def_type( s32_str ); code_set_global( t_s32 );
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 );
StrC 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 );
StrC u64_str = txt("u64"); t_u64 = def_type( u64_str ); code_set_global( t_u64 );
Str u8_str = txt("u8"); t_u8 = def_type( u8_str ); code_set_global( t_u8 );
Str u16_str = txt("u16"); t_u16 = def_type( u16_str ); code_set_global( t_u16 );
Str u32_str = txt("u32"); t_u32 = def_type( u32_str ); code_set_global( t_u32 );
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 );
StrC usize_str = txt("usize"); t_usize = def_type( usize_str ); code_set_global( t_usize );
Str ssize_str = txt("ssize"); t_ssize = def_type( ssize_str ); code_set_global( t_ssize );
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 );
StrC f64_str = txt("f64"); t_f64 = def_type( f64_str ); code_set_global( t_f64 );
Str f32_str = txt("f32"); t_f32 = def_type( f32_str ); code_set_global( t_f32 );
Str f64_str = txt("f64"); t_f64 = def_type( f64_str ); code_set_global( t_f64 );
#endif
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) {
enum_underlying_sig = txt("enum_underlying(");
}
array_append(PreprocessorDefines, enum_underlying_sig);
# undef def_constant_spec
array_append( _ctx->PreprocessorDefines, enum_underlying_sig);
}
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 };
GlobalAllocator = becasue_C;
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 );
ctx->Fallback_AllocatorBuckets = array_init_reserve(Arena, heap(), 128 );
if ( ctx->Fallback_AllocatorBuckets == nullptr )
GEN_FATAL( "Failed to reserve memory for Fallback_AllocatorBuckets");
Arena bucket = arena_init_from_allocator( heap(), ctx->InitSize_Fallback_Allocator_Bucket_Size );
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) {
Allocator_DataArrays = GlobalAllocator;
if (ctx->Max_CommentLineLength == 0) {
ctx->Max_CommentLineLength = 1024;
}
if (Allocator_CodePool.Proc == nullptr ) {
Allocator_CodePool = GlobalAllocator;
if (ctx->Max_StrCacheLength == 0) {
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) {
Allocator_StringArena = GlobalAllocator;
if (ctx->InitSize_CodePoolsArray == 0) {
ctx->InitSize_CodePoolsArray = 16;
}
if (Allocator_StringTable.Proc == nullptr) {
Allocator_StringTable = GlobalAllocator;
if (ctx->InitSize_StringArenasArray == 0) {
ctx->InitSize_StringArenasArray = 16;
}
if (Allocator_TypeTable.Proc == nullptr) {
Allocator_TypeTable = GlobalAllocator;
if (ctx->CodePool_NumBlocks == 0) {
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
{
CodePools = array_init_reserve(Pool, Allocator_DataArrays, InitSize_DataArrays );
if ( CodePools == nullptr )
ctx->CodePools = array_init_reserve(Pool, ctx->Allocator_DyanmicContainers, ctx->InitSize_CodePoolsArray );
if ( ctx->CodePools == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the CodePools array" );
StringArenas = array_init_reserve(Arena, Allocator_DataArrays, InitSize_DataArrays );
if ( StringArenas == nullptr )
ctx->StringArenas = array_init_reserve(Arena, ctx->Allocator_DyanmicContainers, ctx->InitSize_StringArenasArray );
if ( ctx->StringArenas == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the StringArenas array" );
}
// 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 )
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 );
Arena string_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena );
if ( string_arena.PhysicalStart == nullptr )
// 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 );
if ( strbuilder_arena.PhysicalStart == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the string arena" );
array_append( StringArenas, string_arena );
array_append( ctx->StringArenas, strbuilder_arena );
}
// Setup the hash tables
{
StringCache = hashtable_init(StringCached, Allocator_StringTable);
if ( StringCache.Entries == nullptr )
ctx->StrCache = hashtable_init(StrCached, ctx->Allocator_DyanmicContainers);
if ( ctx->StrCache.Entries == nullptr )
GEN_FATAL( "gen::init: Failed to initialize the StringCache");
}
// Preprocessor Defines
PreprocessorDefines = array_init_reserve(StringCached, GlobalAllocator, kilobytes(1) );
ctx->PreprocessorDefines = array_init_reserve(StrCached, ctx->Allocator_DyanmicContainers, kilobytes(1) );
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 left = array_num(CodePools);
usize left = array_num(ctx->CodePools);
do
{
Pool* code_pool = & CodePools[index];
Pool* code_pool = & ctx->CodePools[index];
pool_free(code_pool);
index++;
}
while ( left--, left );
index = 0;
left = array_num(StringArenas);
left = array_num(ctx->StringArenas);
do
{
Arena* string_arena = & StringArenas[index];
arena_free(string_arena);
Arena* strbuilder_arena = & ctx->StringArenas[index];
arena_free(strbuilder_arena);
index++;
}
while ( left--, left );
hashtable_destroy(StringCache);
hashtable_destroy(ctx->StrCache);
array_free( CodePools);
array_free( StringArenas);
array_free( ctx->CodePools);
array_free( ctx->StringArenas);
arena_free(& LexArena);
arena_free(& ctx->LexArena);
array_free(PreprocessorDefines);
array_free(ctx->PreprocessorDefines);
index = 0;
left = array_num(Global_AllocatorBuckets);
do
left = array_num( ctx->Fallback_AllocatorBuckets);
if (left)
{
Arena* bucket = & Global_AllocatorBuckets[ index ];
arena_free(bucket);
index++;
index = 0;
do
{
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);
GEN_NS_PARSER parser_deinit();
if (_ctx == ctx)
_ctx = nullptr;
-- context_counter;
}
void reset()
void reset(Context* ctx)
{
s32 index = 0;
s32 left = array_num(CodePools);
s32 left = array_num(ctx->CodePools);
do
{
Pool* code_pool = & CodePools[index];
Pool* code_pool = & ctx->CodePools[index];
pool_clear(code_pool);
index++;
}
while ( left--, left );
index = 0;
left = array_num(StringArenas);
left = array_num(ctx->StringArenas);
do
{
Arena* string_arena = & StringArenas[index];
string_arena->TotalUsed = 0;;
Arena* strbuilder_arena = & ctx->StringArenas[index];
strbuilder_arena->TotalUsed = 0;;
index++;
}
while ( left--, left );
hashtable_clear(StringCache);
hashtable_clear(ctx->StrCache);
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);
usize size_req = str_length + sizeof(StringHeader) + sizeof(char*);
Arena* last = array_back(_ctx->StringArenas);
usize size_req = str_length + sizeof(StrBuilderHeader) + sizeof(char*);
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 ) )
GEN_FATAL( "gen::get_string_allocator: Failed to allocate a new string arena" );
last = array_back(StringArenas);
last = array_back( _ctx->StringArenas);
}
return arena_allocator_info(last);
}
// 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;
u64 key = crc32( str.Ptr, hash_length );
{
StringCached* result = hashtable_get(StringCache, key );
if (str.Len > _ctx->Max_StrCacheLength) {
// 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 ));
return result;
}
u64 key = crc32( str.Ptr, str.Len ); {
StrCached* result = hashtable_get( _ctx->StrCache, key );
if ( result )
return * result;
}
StrC result = string_to_strc( string_make_strc( get_string_allocator( str.Len ), str ));
hashtable_set(StringCache, key, result );
Str result = strbuilder_to_str( strbuilder_make_str( get_cached_str_allocator( str.Len ), str ));
hashtable_set( _ctx->StrCache, key, result );
return result;
}
// Used internally to retireve a Code object form the CodePool.
Code make_code()
{
Pool* allocator = array_back( CodePools);
Pool* allocator = array_back( _ctx->CodePools);
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 )
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." );
allocator = array_back( CodePools);
allocator = array_back( _ctx->CodePools);
}
Code result = { rcast( AST*, alloc( pool_allocator_info(allocator), sizeof(AST) )) };
mem_set( rcast(void*, cast(AST*, result)), 0, sizeof(AST) );
return result;
}
void set_allocator_data_arrays( AllocatorInfo allocator )
{
Allocator_DataArrays = allocator;
}
void set_allocator_code_pool( AllocatorInfo allocator )
{
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;
void set_preprocess_define( Str id, b32 is_functional ) {
StrBuilder builder = strbuilder_make_str( _ctx->Allocator_Temp, id );
if (is_functional) {
strbuilder_append_char( & builder, '(' );
}
array_append( _ctx->PreprocessorDefines, cache_str( strbuilder_to_str(builder)) );
}

View File

@ -15,41 +15,121 @@
\ \\ \ \\ \ \ \\ \ \ \ \
*/
// Initialize the library.
void init();
#if 0
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.
// 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.
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.
// 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.
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.
*/
Code make_code();
GEN_API Code make_code();
// 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
CodeAttributes def_attributes( StrC content );
CodeComment def_comment ( StrC content );
GEN_API CodeAttributes def_attributes( Str content );
GEN_API CodeComment def_comment ( Str content );
struct Opts_def_struct {
CodeBody body;
@ -60,25 +140,25 @@ struct Opts_def_struct {
s32 num_interfaces;
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 {
CodeParams params;
Code initializer_list;
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 {
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 {
Code body;
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 {
CodeBody body;
@ -88,11 +168,11 @@ struct Opts_def_enum {
ModuleFlag mflags;
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 );
CodeExtern def_extern_link( StrC name, CodeBody body );
CodeFriend def_friend ( Code symbol );
GEN_API CodeExec def_execution ( Str content );
GEN_API CodeExtern def_extern_link( Str name, CodeBody body );
GEN_API CodeFriend def_friend ( Code symbol );
struct Opts_def_function {
CodeParams params;
@ -102,14 +182,14 @@ struct Opts_def_function {
CodeAttributes attrs;
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_module { ModuleFlag mflags; };
struct Opts_def_namespace { ModuleFlag mflags; };
CodeInclude def_include ( StrC content, Opts_def_include opts GEN_PARAM_DEFAULT );
CodeModule def_module ( StrC name, Opts_def_module opts GEN_PARAM_DEFAULT );
CodeNS def_namespace( StrC name, CodeBody body, Opts_def_namespace opts GEN_PARAM_DEFAULT );
GEN_API CodeInclude def_include ( Str content, Opts_def_include opts GEN_PARAM_DEFAULT );
GEN_API CodeModule def_module ( Str name, Opts_def_module opts GEN_PARAM_DEFAULT );
GEN_API CodeNS def_namespace( Str name, CodeBody body, Opts_def_namespace opts GEN_PARAM_DEFAULT );
struct Opts_def_operator {
CodeParams params;
@ -119,26 +199,26 @@ struct Opts_def_operator {
CodeAttributes attributes;
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 {
CodeBody body;
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; };
CodeParams def_param ( CodeTypename type, StrC name, Opts_def_param opts GEN_PARAM_DEFAULT );
CodePragma def_pragma( StrC directive );
GEN_API CodeParams def_param ( CodeTypename type, Str name, Opts_def_param opts GEN_PARAM_DEFAULT );
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; };
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 {
ETypenameTag type_tag;
@ -146,27 +226,27 @@ struct Opts_def_type {
CodeSpecifiers specifiers;
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 {
CodeAttributes attributes;
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 {
CodeAttributes attributes;
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 {
CodeAttributes attributes;
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
{
@ -175,36 +255,36 @@ struct Opts_def_variable
CodeAttributes attributes;
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.
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,
/// or provide as an array of Code objects.
CodeBody def_class_body ( s32 num, ... );
CodeBody def_class_body ( s32 num, Code* codes );
CodeBody def_enum_body ( s32 num, ... );
CodeBody def_enum_body ( s32 num, Code* codes );
CodeBody def_export_body ( s32 num, ... );
CodeBody def_export_body ( s32 num, Code* codes);
CodeBody def_extern_link_body( s32 num, ... );
CodeBody def_extern_link_body( s32 num, Code* codes );
CodeBody def_function_body ( s32 num, ... );
CodeBody def_function_body ( s32 num, Code* codes );
CodeBody def_global_body ( s32 num, ... );
CodeBody def_global_body ( s32 num, Code* codes );
CodeBody def_namespace_body ( s32 num, ... );
CodeBody def_namespace_body ( s32 num, Code* codes );
CodeParams def_params ( s32 num, ... );
CodeParams def_params ( s32 num, CodeParams* params );
CodeSpecifiers def_specifiers ( s32 num, ... );
CodeSpecifiers def_specifiers ( s32 num, Specifier* specs );
CodeBody def_struct_body ( s32 num, ... );
CodeBody def_struct_body ( s32 num, Code* codes );
CodeBody def_union_body ( s32 num, ... );
CodeBody def_union_body ( s32 num, Code* codes );
GEN_API CodeBody def_class_body ( s32 num, ... );
GEN_API CodeBody def_class_body ( s32 num, Code* codes );
GEN_API CodeBody def_enum_body ( s32 num, ... );
GEN_API CodeBody def_enum_body ( s32 num, Code* codes );
GEN_API CodeBody def_export_body ( s32 num, ... );
GEN_API CodeBody def_export_body ( s32 num, Code* codes);
GEN_API CodeBody def_extern_link_body( s32 num, ... );
GEN_API CodeBody def_extern_link_body( s32 num, Code* codes );
GEN_API CodeBody def_function_body ( s32 num, ... );
GEN_API CodeBody def_function_body ( s32 num, Code* codes );
GEN_API CodeBody def_global_body ( s32 num, ... );
GEN_API CodeBody def_global_body ( s32 num, Code* codes );
GEN_API CodeBody def_namespace_body ( s32 num, ... );
GEN_API CodeBody def_namespace_body ( s32 num, Code* codes );
GEN_API CodeParams def_params ( s32 num, ... );
GEN_API CodeParams def_params ( s32 num, CodeParams* params );
GEN_API CodeSpecifiers def_specifiers ( s32 num, ... );
GEN_API CodeSpecifiers def_specifiers ( s32 num, Specifier* specs );
GEN_API CodeBody def_struct_body ( s32 num, ... );
GEN_API CodeBody def_struct_body ( s32 num, Code* codes );
GEN_API CodeBody def_union_body ( s32 num, ... );
GEN_API CodeBody def_union_body ( s32 num, Code* codes );
#pragma endregion Upfront
@ -213,23 +293,21 @@ CodeBody def_union_body ( s32 num, Code* codes );
// TODO(Ed) : Implmeent the new parser API design.
#if 0
GEN_NS_PARSER_BEGIN
struct StackNode
{
StackNode* Prev;
Token Start;
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
struct Error
{
String message;
StrBuilder message;
StackNode* context_stack;
};
GEN_NS_PARSER_END
struct ParseInfo
{
@ -243,40 +321,40 @@ struct ParseInfo
// Errors are allocated to a dedicated general arena.
};
CodeBody parse_file( StrC path );
CodeBody parse_file( Str path );
#endif
CodeClass parse_class ( StrC class_def );
CodeConstructor parse_constructor ( StrC constructor_def );
CodeDestructor parse_destructor ( StrC destructor_def );
CodeEnum parse_enum ( StrC enum_def );
CodeBody parse_export_body ( StrC export_def );
CodeExtern parse_extern_link ( StrC exten_link_def );
CodeFriend parse_friend ( StrC friend_def );
CodeFn parse_function ( StrC fn_def );
CodeBody parse_global_body ( StrC body_def );
CodeNS parse_namespace ( StrC namespace_def );
CodeOperator parse_operator ( StrC operator_def );
CodeOpCast parse_operator_cast( StrC operator_def );
CodeStruct parse_struct ( StrC struct_def );
CodeTemplate parse_template ( StrC template_def );
CodeTypename parse_type ( StrC type_def );
CodeTypedef parse_typedef ( StrC typedef_def );
CodeUnion parse_union ( StrC union_def );
CodeUsing parse_using ( StrC using_def );
CodeVar parse_variable ( StrC var_def );
GEN_API CodeClass parse_class ( Str class_def );
GEN_API CodeConstructor parse_constructor ( Str constructor_def );
GEN_API CodeDestructor parse_destructor ( Str destructor_def );
GEN_API CodeEnum parse_enum ( Str enum_def );
GEN_API CodeBody parse_export_body ( Str export_def );
GEN_API CodeExtern parse_extern_link ( Str exten_link_def );
GEN_API CodeFriend parse_friend ( Str friend_def );
GEN_API CodeFn parse_function ( Str fn_def );
GEN_API CodeBody parse_global_body ( Str body_def );
GEN_API CodeNS parse_namespace ( Str namespace_def );
GEN_API CodeOperator parse_operator ( Str operator_def );
GEN_API CodeOpCast parse_operator_cast( Str operator_def );
GEN_API CodeStruct parse_struct ( Str struct_def );
GEN_API CodeTemplate parse_template ( Str template_def );
GEN_API CodeTypename parse_type ( Str type_def );
GEN_API CodeTypedef parse_typedef ( Str typedef_def );
GEN_API CodeUnion parse_union ( Str union_def );
GEN_API CodeUsing parse_using ( Str using_def );
GEN_API CodeVar parse_variable ( Str var_def );
#pragma endregion Parsing
#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.
StrC token_fmt_impl( ssize, ... );
GEN_API Str token_fmt_impl( ssize, ... );
Code untyped_str ( StrC content);
Code untyped_fmt ( char const* fmt, ... );
Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
GEN_API Code untyped_str( Str content);
GEN_API Code untyped_fmt ( char const* fmt, ... );
GEN_API Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
#pragma endregion Untyped text
@ -289,12 +367,12 @@ Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
#ifndef name
// Convienence for defining any name used with the gen api.
// Lets you provide the length and string literal to the functions without the need for the DSL.
#define name( Id_ ) { sizeof(stringize( Id_ )) - 1, stringize(Id_) }
#define name( Id_ ) { stringize(Id_), sizeof(stringize( Id_ )) - 1 }
#endif
#ifndef code
// 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
#ifndef args
@ -317,21 +395,21 @@ Code untyped_token_fmt( s32 num_tokens, char const* 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)
---------------------------------------------------------
Example - A string with:
typedef <type> <name> <name>;
Will have a token_fmt arguments populated with:
"type", strc_for_type,
"name", strc_for_name,
"type", str_for_type,
"name", str_for_name,
and:
stringize( typedef <type> <name> <name>; )
-----------------------------------------------------------
So the full call for this example would be:
token_fmt(
"type", strc_for_type
, "name", strc_for_name
"type", str_for_type
, "name", str_for_name
, stringize(
typedef <type> <name> <name>
));

View File

@ -8,25 +8,23 @@
// Publically Exposed Interface
CodeClass parse_class( StrC def )
CodeClass parse_class( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
push_scope();
CodeClass result = (CodeClass) parse_class_struct( Tok_Decl_Class, parser_not_inplace_def );
parser_pop(& Context);
parser_pop(& _ctx->parser);
return result;
}
CodeConstructor parse_constructor( StrC def )
CodeConstructor parse_constructor( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
TokArray toks = lex( def );
@ -41,7 +39,7 @@ CodeConstructor parse_constructor( StrC def )
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;
@ -59,8 +57,8 @@ CodeConstructor parse_constructor( StrC def )
break;
default :
log_failure( "Invalid specifier %s for variable\n%s", spec_to_str( spec ), parser_to_string(Context) );
parser_pop(& Context);
log_failure( "Invalid specifier %s for variable\n%S", spec_to_str( spec ), parser_to_strbuilder(_ctx->parser) );
parser_pop(& _ctx->parser);
return InvalidCode;
}
@ -79,14 +77,13 @@ CodeConstructor parse_constructor( StrC def )
// <specifiers> ...
}
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
CodeConstructor result = parser_parse_constructor( specifiers );
return result;
}
CodeDestructor parse_destructor( StrC def )
CodeDestructor parse_destructor( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( 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 virtual
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
CodeDestructor result = parser_parse_destructor(NullCode);
return result;
}
CodeEnum parse_enum( StrC def )
CodeEnum parse_enum( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
{
parser_pop(& Context);
parser_pop(& _ctx->parser);
return InvalidCode;
}
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
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 );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
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 );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
return parser_parse_extern_link();
}
CodeFriend parse_friend( StrC def )
CodeFriend parse_friend( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
return parser_parse_friend();
}
CodeFn parse_function( StrC def )
CodeFn parse_function( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
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 );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
push_scope();
CodeBody result = parse_global_nspace( CT_Global_Body );
parser_pop(& Context);
parser_pop(& _ctx->parser);
return result;
}
CodeNS parse_namespace( StrC def )
CodeNS parse_namespace( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
return parser_parse_namespace();
}
CodeOperator parse_operator( StrC def )
CodeOperator parse_operator( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
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 );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
return parser_parse_operator_cast(NullCode);
}
CodeStruct parse_struct( StrC def )
CodeStruct parse_struct( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
push_scope();
CodeStruct result = (CodeStruct) parse_class_struct( Tok_Decl_Struct, parser_not_inplace_def );
parser_pop(& Context);
parser_pop(& _ctx->parser);
return result;
}
CodeTemplate parse_template( StrC def )
CodeTemplate parse_template( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
return parser_parse_template();
}
CodeTypename parse_type( StrC def )
CodeTypename parse_type( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
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 );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
return parser_parse_typedef();
}
CodeUnion parse_union( StrC def )
CodeUnion parse_union( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
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 );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
return parser_parse_using();
}
CodeVar parse_variable( StrC def )
CodeVar parse_variable( Str def )
{
GEN_USING_NS_PARSER;
check_parse_args( def );
TokArray toks = lex( def );
if ( toks.Arr == nullptr )
return InvalidCode;
Context.Tokens = toks;
_ctx->parser.Tokens = toks;
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;
ssize remaining = buf_size;
local_persist
TokenMap_FixedArena tok_map_arena;
fixed_arena_init( & tok_map_arena);
local_persist
StringTable tok_map;
local_persist StringTable tok_map;
do_once() {
tok_map = hashtable_init(Str, _ctx->Allocator_DyanmicContainers );
}
// Populate token pairs
{
tok_map = hashtable_init(StrC, fixed_arena_allocator_info(& tok_map_arena) );
s32 left = num_tokens - 1;
while ( left-- )
{
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 );
}
}
@ -61,7 +58,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
char const* token = fmt + 1;
u32 key = crc32( token, tok_len );
StrC* value = hashtable_get(tok_map, key );
Str* value = hashtable_get(tok_map, key );
if ( value )
{
@ -90,16 +87,12 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va )
current = * fmt;
}
}
hashtable_clear(tok_map);
fixed_arena_free(& tok_map_arena);
ssize result = buf_size - remaining;
return result;
}
Code untyped_str( StrC content )
Code untyped_str( Str content )
{
if ( content.Len == 0 )
{
@ -109,7 +102,7 @@ Code untyped_str( StrC content )
Code
result = make_code();
result->Name = get_cached_string( content );
result->Name = cache_str( content );
result->Type = CT_Untyped;
result->Content = result->Name;
@ -135,17 +128,14 @@ Code untyped_fmt( char const* fmt, ...)
va_list va;
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);
StrC buf_str = { str_len_capped(fmt, MaxNameLength), fmt };
StrC uncapped_str = { length, buf };
Str content = { buf, length };
Code
result = make_code();
result->Name = get_cached_string( buf_str );
result->Type = CT_Untyped;
result->Content = get_cached_string( uncapped_str );
result->Content = cache_str( content );
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);
va_end(va);
StrC buf_str = { length, buf };
Str buf_str = { buf, length };
Code
result = make_code();
result->Name = get_cached_string( buf_str );
result->Type = CT_Untyped;
result->Content = result->Name;
result->Content = cache_str( buf_str );
if ( result->Name.Len == 0 )
{

View File

@ -373,7 +373,7 @@ OpValidateResult operator__validate( Operator op, CodeParams params_code, CodeTy
}
forceinline
bool name__check( char const* context, StrC name )
bool name__check( char const* context, Str name )
{
if ( name.Len <= 0 ) {
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 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 ) {
log_failure( "gen::def_attributes: Invalid attributes provided" );
@ -419,12 +419,12 @@ CodeAttributes def_attributes( StrC content )
Code
result = make_code();
result->Type = CT_PlatformAttributes;
result->Name = get_cached_string( content );
result->Name = cache_str( content );
result->Content = result->Name;
return (CodeAttributes) result;
}
CodeComment def_comment( StrC content )
CodeComment def_comment( Str content )
{
if ( content.Len <= 0 || content.Ptr == nullptr )
{
@ -433,9 +433,7 @@ CodeComment def_comment( StrC content )
return InvalidCode;
}
static char line[ MaxCommentLineLength ];
String cmt_formatted = string_make_reserve( GlobalAllocator, kilobytes(1) );
StrBuilder cmt_formatted = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
char const* end = content.Ptr + content.Len;
char const* scanner = content.Ptr;
s32 curr = 0;
@ -450,26 +448,23 @@ CodeComment def_comment( StrC content )
}
length++;
str_copy( line, scanner, length );
string_append_fmt(& cmt_formatted, "//%.*s", length, line );
mem_set( line, 0, MaxCommentLineLength );
strbuilder_append_fmt(& cmt_formatted, "//%.*s", length, scanner );
scanner += length;
}
while ( scanner <= end );
if ( * string_back(cmt_formatted) != '\n' )
string_append_strc( & cmt_formatted, txt("\n") );
if ( * strbuilder_back(cmt_formatted) != '\n' )
strbuilder_append_str( & cmt_formatted, txt("\n") );
StrC name = { string_length(cmt_formatted), cmt_formatted };
Str name = strbuilder_to_str(cmt_formatted);
Code
result = make_code();
result->Type = CT_Comment;
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->Content = result->Name;
string_free(& cmt_formatted);
strbuilder_free(& cmt_formatted);
return (CodeComment) result;
}
@ -511,7 +506,7 @@ CodeConstructor def_constructor( Opts_def_constructor p )
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 ) ) {
GEN_DEBUG_TRAP();
@ -531,7 +526,7 @@ CodeClass def_class( StrC name, Opts_def_struct p )
CodeClass
result = (CodeClass) make_code();
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->ModuleFlags = p.mflags;
if ( p.body )
{
@ -564,7 +559,7 @@ CodeClass def_class( StrC name, Opts_def_struct p )
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 ) ) {
GEN_DEBUG_TRAP();
@ -574,12 +569,12 @@ CodeDefine def_define( StrC name, StrC content, Opts_def_define p )
CodeDefine
result = (CodeDefine) make_code();
result->Type = CT_Preprocess_Define;
result->Name = get_cached_string( name );
result->Name = cache_str( name );
if ( content.Len <= 0 || content.Ptr == nullptr )
result->Content = get_cached_string( txt("") );
result->Content = cache_str( txt("") );
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;
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] == '(' )
break;
}
StrC lex_id = { lex_id_len, result->Name.Ptr };
array_append(PreprocessorDefines, lex_id );
Str lex_id = { result->Name.Ptr, lex_id_len };
array_append(_ctx->PreprocessorDefines, cache_str(lex_id) );
}
return result;
}
@ -629,7 +624,7 @@ CodeDestructor def_destructor( Opts_def_destructor p )
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 ) ) {
GEN_DEBUG_TRAP();
@ -648,7 +643,7 @@ CodeEnum def_enum( StrC name, Opts_def_enum p )
CodeEnum
result = (CodeEnum) make_code();
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->ModuleFlags = p.mflags;
if ( p.body )
{
@ -690,7 +685,7 @@ CodeEnum def_enum( StrC name, Opts_def_enum p )
return result;
}
CodeExec def_execution( StrC content )
CodeExec def_execution( Str content )
{
if ( content.Len <= 0 || content.Ptr == nullptr ) {
log_failure( "gen::def_execution: Invalid execution provided" );
@ -700,11 +695,11 @@ CodeExec def_execution( StrC content )
CodeExec
result = (CodeExec) make_code();
result->Type = CT_Execution;
result->Content = get_cached_string( content );
result->Content = cache_str( content );
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) ) {
GEN_DEBUG_TRAP();
@ -718,7 +713,7 @@ CodeExtern def_extern_link( StrC name, CodeBody body )
CodeExtern
result = (CodeExtern)make_code();
result->Type = CT_Extern_Linkage;
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->Body = body;
return result;
}
@ -752,7 +747,7 @@ CodeFriend def_friend( Code declaration )
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 )) {
GEN_DEBUG_TRAP();
@ -781,7 +776,7 @@ CodeFn def_function( StrC name, Opts_def_function p )
CodeFn
result = (CodeFn) make_code();
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->ModuleFlags = p.mflags;
if ( p.body )
{
@ -812,26 +807,26 @@ CodeFn def_function( StrC name, Opts_def_function p )
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 ) {
log_failure( "gen::def_include: Invalid path provided - %d" );
GEN_DEBUG_TRAP();
return InvalidCode;
}
String content = p.foreign ?
string_fmt_buf( GlobalAllocator, "<%.*s>", path.Len, path.Ptr )
: string_fmt_buf( GlobalAllocator, "\"%.*s\"", path.Len, path.Ptr );
StrBuilder content = p.foreign ?
strbuilder_fmt_buf( _ctx->Allocator_Temp, "<%.*s>", path.Len, path.Ptr )
: strbuilder_fmt_buf( _ctx->Allocator_Temp, "\"%.*s\"", path.Len, path.Ptr );
CodeInclude
result = (CodeInclude) make_code();
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;
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 )) {
GEN_DEBUG_TRAP();
@ -840,12 +835,12 @@ CodeModule def_module( StrC name, Opts_def_module p )
CodeModule
result = (CodeModule) make_code();
result->Type = CT_Module;
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->ModuleFlags = p.mflags;
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 )) {
GEN_DEBUG_TRAP();
@ -863,13 +858,13 @@ CodeNS def_namespace( StrC name, CodeBody body, Opts_def_namespace p )
CodeNS
result = (CodeNS) make_code();
result->Type = CT_Namespace;
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->ModuleFlags = p.mflags;
result->Body = body;
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 ) {
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;
StrC op_str = operator_to_str( op );
Str op_str = operator_to_str( op );
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
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
result = (CodeOperator) make_code();
result->Name = get_cached_string( name_resolved );
result->Name = cache_str( name_resolved );
result->ModuleFlags = p.mflags;
result->Op = op;
if ( p.body )
@ -969,7 +964,7 @@ CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast p )
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 ) ) {
GEN_DEBUG_TRAP();
@ -986,14 +981,14 @@ CodeParams def_param( CodeTypename type, StrC name, Opts_def_param p )
CodeParams
result = (CodeParams) make_code();
result->Type = CT_Parameters;
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->ValueType = type;
result->Value = p.value;
result->NumEntries++;
return result;
}
CodePragma def_pragma( StrC directive )
CodePragma def_pragma( Str directive )
{
if ( directive.Len <= 0 || directive.Ptr == nullptr ) {
log_failure( "gen::def_comment: Invalid comment provided:" );
@ -1003,11 +998,11 @@ CodePragma def_pragma( StrC directive )
CodePragma
result = (CodePragma) make_code();
result->Type = CT_Preprocess_Pragma;
result->Content = get_cached_string( directive );
result->Content = cache_str( directive );
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 ) {
log_failure( "gen::def_comment: Invalid comment provided:" );
@ -1016,7 +1011,7 @@ CodePreprocessCond def_preprocess_cond( EPreprocessCond type, StrC expr )
}
CodePreprocessCond
result = (CodePreprocessCond) make_code();
result->Content = get_cached_string( expr );
result->Content = cache_str( expr );
switch (type)
{
case PreprocessCond_If:
@ -1044,7 +1039,7 @@ CodeSpecifiers def_specifier( Specifier spec )
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 ) {
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->ModuleFlags = p.mflags;
if ( name.Len )
result->Name = get_cached_string( name );
result->Name = cache_str( name );
if ( p.body ) {
result->Type = CT_Struct;
@ -1117,7 +1112,7 @@ CodeTemplate def_template( CodeParams params, Code declaration, Opts_def_templat
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 )) {
GEN_DEBUG_TRAP();
@ -1143,7 +1138,7 @@ CodeTypename def_type( StrC name, Opts_def_type p )
}
CodeTypename
result = (CodeTypename) make_code();
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->Type = CT_Typename;
result->Attributes = p.attributes;
result->Specs = p.specifiers;
@ -1152,7 +1147,7 @@ CodeTypename def_type( StrC name, Opts_def_type p )
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 ) ) {
GEN_DEBUG_TRAP();
@ -1204,18 +1199,18 @@ CodeTypedef def_typedef( StrC name, Code type, Opts_def_typedef p )
GEN_DEBUG_TRAP();
return InvalidCode;
}
result->Name = get_cached_string( type->Name );
result->Name = cache_str( type->Name );
result->IsFunction = true;
}
else
{
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->IsFunction = false;
}
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 ) ) {
GEN_DEBUG_TRAP();
@ -1238,11 +1233,11 @@ CodeUnion def_union( StrC name, CodeBody body, Opts_def_union p )
result->Body = body;
result->Attributes = p.attributes;
if ( name.Ptr )
result->Name = get_cached_string( name );
result->Name = cache_str( name );
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 ) ) {
GEN_DEBUG_TRAP();
@ -1262,7 +1257,7 @@ CodeUsing def_using( StrC name, CodeTypename type, Opts_def_using p )
}
CodeUsing
result = (CodeUsing) make_code();
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->ModuleFlags = p.mflags;
result->Type = CT_Using;
result->UnderlyingType = type;
@ -1270,7 +1265,7 @@ CodeUsing def_using( StrC name, CodeTypename type, Opts_def_using p )
return result;
}
CodeUsing def_using_namespace( StrC name )
CodeUsing def_using_namespace( Str name )
{
if ( ! name_check( def_using_namespace, name ) ) {
GEN_DEBUG_TRAP();
@ -1278,12 +1273,12 @@ CodeUsing def_using_namespace( StrC name )
}
CodeUsing
result = (CodeUsing) make_code();
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->Type = CT_Using_Namespace;
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 ) ) {
GEN_DEBUG_TRAP();
@ -1311,7 +1306,7 @@ CodeVar def_variable( CodeTypename type, StrC name, Opts_def_variable p )
}
CodeVar
result = (CodeVar) make_code();
result->Name = get_cached_string( name );
result->Name = cache_str( name );
result->Type = CT_Variable;
result->ModuleFlags = p.mflags;
result->ValueType = type;
@ -1357,15 +1352,12 @@ CodeBody def_class_body( s32 num, ... )
{
Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod);
if (!entry)
{
if ( ! entry) {
log_failure("gen::"
"def_class_body"
": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
GEN_AST_BODY_CLASS_UNALLOWED_TYPES:
@ -1375,7 +1367,6 @@ CodeBody def_class_body( s32 num, ... )
default:
break;
}
body_append(result, entry);
}
while (num--, num > 0);
@ -1391,18 +1382,14 @@ CodeBody def_class_body( s32 num, Code* codes )
CodeBody
result = (CodeBody) make_code();
result->Type = CT_Function_Body;
do
{
Code entry = *codes;
codes++;
if (!entry)
{
if ( ! entry) {
log_failure("gen::" "def_class_body" ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
GEN_AST_BODY_CLASS_UNALLOWED_TYPES:
@ -1412,7 +1399,6 @@ CodeBody def_class_body( s32 num, Code* codes )
default:
break;
}
body_append(result, entry);
}
while (num--, num > 0);
@ -1434,19 +1420,14 @@ CodeBody def_enum_body( s32 num, ... )
{
Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod);
if ( ! entry )
{
if ( ! entry ) {
log_failure("gen::def_enum_body: Provided a null entry");
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) );
return InvalidCode;
}
body_append(result, entry );
}
while ( num--, num > 0 );
@ -1462,23 +1443,17 @@ CodeBody def_enum_body( s32 num, Code* codes )
CodeBody
result = (CodeBody) make_code();
result->Type = CT_Enum_Body;
do
{
Code entry = *codes;
if ( ! entry )
{
if ( ! entry ) {
log_failure("gen::def_enum_body: Provided a null entry");
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) );
return InvalidCode;
}
body_append(result, entry );
}
while ( codes++, num--, num > 0 );
@ -1500,13 +1475,11 @@ CodeBody def_export_body( s32 num, ... )
{
Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod);
if (!entry)
if ( ! entry)
{
log_failure("gen::" "def_export_body" ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
GEN_AST_BODY_EXPORT_UNALLOWED_TYPES:
@ -1516,7 +1489,6 @@ CodeBody def_export_body( s32 num, ... )
default:
break;
}
body_append(result, entry);
}
while (num--, num > 0);
@ -1532,18 +1504,14 @@ CodeBody def_export_body( s32 num, Code* codes )
CodeBody
result = (CodeBody) make_code();
result->Type = CT_Export_Body;
do
{
Code entry = *codes;
codes++;
if (!entry)
{
if ( ! entry) {
log_failure("gen::" "def_export_body" ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
GEN_AST_BODY_EXPORT_UNALLOWED_TYPES:
@ -1553,7 +1521,6 @@ CodeBody def_export_body( s32 num, Code* codes )
default:
break;
}
body_append(result, entry);
}
while (num--, num > 0);
@ -1575,13 +1542,10 @@ CodeBody def_extern_link_body( s32 num, ... )
{
Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod);
if (!entry)
{
if ( ! entry) {
log_failure("gen::" "def_extern_linkage_body" ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES:
@ -1591,7 +1555,6 @@ CodeBody def_extern_link_body( s32 num, ... )
default:
break;
}
body_append(result, entry);
}
while (num--, num > 0);
@ -1607,18 +1570,15 @@ CodeBody def_extern_link_body( s32 num, Code* codes )
CodeBody
result = (CodeBody) make_code();
result->Type = CT_Extern_Linkage_Body;
do
{
Code entry = *codes;
codes++;
if (!entry)
{
log_failure("gen::" "def_extern_linkage_body" ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
GEN_AST_BODY_EXTERN_LINKAGE_UNALLOWED_TYPES:
@ -1628,7 +1588,6 @@ CodeBody def_extern_link_body( s32 num, Code* codes )
default:
break;
}
body_append(result, entry);
}
while (num--, num > 0);
@ -1650,16 +1609,12 @@ CodeBody def_function_body( s32 num, ... )
{
Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod);
if (!entry)
{
if ( ! entry) {
log_failure("gen::" stringize(def_function_body) ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
GEN_AST_BODY_FUNCTION_UNALLOWED_TYPES:
log_failure("gen::" stringize(def_function_body) ": Entry type is not allowed: %s", code_debug_str(entry));
return InvalidCode;
@ -1667,7 +1622,6 @@ CodeBody def_function_body( s32 num, ... )
default:
break;
}
body_append(result, entry);
}
while (num--, num > 0);
@ -1683,18 +1637,14 @@ CodeBody def_function_body( s32 num, Code* codes )
CodeBody
result = (CodeBody) make_code();
result->Type = CT_Function_Body;
do
{
Code entry = *codes;
codes++;
if (!entry)
{
if (!entry) {
log_failure("gen::" "def_function_body" ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
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 entry = pcast(Code, pod);
if (!entry)
{
if ( ! entry) {
log_failure("gen::" "def_global_body" ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
case CT_Global_Body:
@ -1746,7 +1693,6 @@ CodeBody def_global_body( s32 num, ... )
default:
break;
}
body_append(result, entry);
}
while (num--, num > 0);
@ -1762,18 +1708,14 @@ CodeBody def_global_body( s32 num, Code* codes )
CodeBody
result = (CodeBody) make_code();
result->Type = CT_Global_Body;
do
{
Code entry = *codes;
codes++;
if (!entry)
{
if ( ! entry) {
log_failure("gen::" "def_global_body" ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
case CT_Global_Body:
@ -1809,13 +1751,10 @@ CodeBody def_namespace_body( s32 num, ... )
{
Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod);
if (!entry)
{
if ( ! entry) {
log_failure("gen::" "def_namespace_body" ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES:
@ -1825,7 +1764,6 @@ CodeBody def_namespace_body( s32 num, ... )
default:
break;
}
body_append(result, entry);
}
while (num--, num > 0);
@ -1841,18 +1779,14 @@ CodeBody def_namespace_body( s32 num, Code* codes )
CodeBody
result = (CodeBody) make_code();
result->Type = CT_Global_Body;
do
{
Code entry = *codes;
codes++;
if (!entry)
{
if ( ! entry) {
log_failure("gen::" "def_namespace_body" ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
GEN_AST_BODY_NAMESPACE_UNALLOWED_TYPES:
@ -1861,7 +1795,6 @@ CodeBody def_namespace_body( s32 num, Code* codes )
default: break;
}
body_append(result, entry);
}
while (num--, num > 0);
@ -1880,26 +1813,20 @@ CodeParams def_params( s32 num, ... )
CodeParams param = pcast( CodeParams, pod );
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 );
return InvalidCode;
}
CodeParams result = (CodeParams) code_duplicate(param);
while ( -- num )
{
pod = va_arg(va, Code_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 );
return InvalidCode;
}
params_append(result, param );
}
va_end(va);
@ -1912,18 +1839,14 @@ CodeParams def_params( s32 num, CodeParams* codes )
def_body_code_array_start( def_params );
# define check_current(current) \
if ( current == nullptr ) \
{ \
if ( current == nullptr ) { \
log_failure("gen::def_params: Provide a null code in codes array"); \
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) ); \
return InvalidCode; \
}
CodeParams current = (CodeParams)code_duplicate(* codes);
check_current(current);
@ -1932,9 +1855,7 @@ CodeParams def_params( s32 num, CodeParams* codes )
result->Name = current->Name;
result->Type = current->Type;
result->ValueType = current->ValueType;
while( codes++, current = * codes, num--, num > 0 )
{
while( codes++, current = * codes, num--, num > 0 ) {
check_current(current);
params_append(result, current );
}
@ -1945,28 +1866,22 @@ CodeParams def_params( s32 num, CodeParams* codes )
CodeSpecifiers def_specifiers( s32 num, ... )
{
if ( num <= 0 )
{
if ( num <= 0 ) {
log_failure("gen::def_specifiers: num cannot be zero or less");
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);
return InvalidCode;
}
CodeSpecifiers
result = (CodeSpecifiers) make_code();
result->Type = CT_Specifiers;
va_list va;
va_start(va, num);
do
{
do {
Specifier type = (Specifier)va_arg(va, int);
specifiers_append(result, type );
}
while ( --num, num );
@ -1977,25 +1892,20 @@ CodeSpecifiers def_specifiers( s32 num, ... )
CodeSpecifiers def_specifiers( s32 num, Specifier* specs )
{
if ( num <= 0 )
{
if ( num <= 0 ) {
log_failure("gen::def_specifiers: num cannot be zero or less");
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);
return InvalidCode;
}
CodeSpecifiers
result = (CodeSpecifiers) make_code();
result->Type = CT_Specifiers;
s32 idx = 0;
do
{
do {
specifiers_append(result, specs[idx] );
idx++;
}
@ -2018,13 +1928,10 @@ CodeBody def_struct_body( s32 num, ... )
{
Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast(Code, pod);
if (!entry)
{
if ( ! entry) {
log_failure("gen::" "def_struct_body" ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
GEN_AST_BODY_STRUCT_UNALLOWED_TYPES:
@ -2034,7 +1941,6 @@ CodeBody def_struct_body( s32 num, ... )
default:
break;
}
body_append(result, entry);
}
while (num--, num > 0);
@ -2050,18 +1956,14 @@ CodeBody def_struct_body( s32 num, Code* codes )
CodeBody
result = (CodeBody) make_code();
result->Type = CT_Struct_Body;
do
{
Code entry = *codes;
codes++;
if (!entry)
{
if ( ! entry) {
log_failure("gen::" "def_struct_body" ": Provided an null entry");
return InvalidCode;
}
switch (entry->Type)
{
GEN_AST_BODY_STRUCT_UNALLOWED_TYPES:
@ -2071,7 +1973,6 @@ CodeBody def_struct_body( s32 num, Code* codes )
default:
break;
}
body_append(result, entry);
}
while (num--, num > 0);
@ -2093,19 +1994,14 @@ CodeBody def_union_body( s32 num, ... )
{
Code_POD pod = va_arg(va, Code_POD);
Code entry = pcast( Code, pod );
if ( ! entry )
{
if ( ! entry ) {
log_failure("gen::def_union_body: Provided a null entry");
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) );
return InvalidCode;
}
body_append(result, entry );
}
while ( num--, num > 0 );
@ -2121,23 +2017,17 @@ CodeBody def_union_body( s32 num, Code* codes )
CodeBody
result = (CodeBody) make_code();
result->Type = CT_Union_Body;
do
{
Code entry = *codes;
if ( ! entry )
{
if ( ! entry ) {
log_failure("gen::def_union_body: Provided a null entry");
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) );
return InvalidCode;
}
body_append(result, entry );
}
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
#pragma region StaticData
// 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
global Context* _ctx;
#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_protected;
@ -84,8 +68,6 @@ global CodeTypename t_wchar_t;
global CodeTypename t_class;
global CodeTypename t_typename;
global Array(StringCached) PreprocessorDefines;
#ifdef GEN_DEFINE_LIBRARY_CODE_CONSTANTS
global CodeTypename t_b32;
@ -107,3 +89,5 @@ global CodeTypename t_f64;
#endif
#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" );
inline
StrC access_spec_to_str( AccessSpec type )
Str access_spec_to_str( AccessSpec type )
{
local_persist
StrC lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
{ sizeof("") - 1, "" },
{ sizeof("prviate") - 1, "private" },
{ sizeof("protected") - 1, "private" },
{ sizeof("public") - 1, "public" },
Str lookup[ (u32)AccessSpec_Num_AccessSpec ] = {
{ "", sizeof( "" ) - 1 },
{ "private", sizeof("prviate") - 1 },
{ "private", sizeof("protected") - 1 },
{ "public", sizeof("public") - 1 },
};
StrC invalid = { sizeof("Invalid") - 1, "Invalid" };
Str invalid = { "Invalid", sizeof("Invalid") - 1 };
if ( type > AccessSpec_Public )
return invalid;
@ -97,17 +97,17 @@ enum ModuleFlag : u32
static_assert( size_of(ModuleFlag) == size_of(u32), "ModuleFlag not u32 size" );
inline
StrC module_flag_to_str( ModuleFlag flag )
Str module_flag_to_str( ModuleFlag flag )
{
local_persist
StrC lookup[ (u32)Num_ModuleFlags ] = {
{ sizeof("__none__"), "__none__" },
{ sizeof("export"), "export" },
{ sizeof("import"), "import" },
Str lookup[ (u32)Num_ModuleFlags ] = {
{ "__none__", sizeof("__none__") - 1 },
{ "export", sizeof("export") - 1 },
{ "import", sizeof("import") - 1 },
};
local_persist
StrC invalid_flag = { sizeof("invalid"), "invalid" };
Str invalid_flag = { "invalid", sizeof("invalid") };
if ( flag > ModuleFlag_Import )
return invalid_flag;

View File

@ -102,16 +102,16 @@ struct Array
#endif
#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, 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_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> 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 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 set_capacity(Array<Type>& array, usize new_capacity) { return set_capacity( & array, new_capacity); }
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* 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* 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> 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 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> forceinline Type* begin(Array<Type>& array) { return array; }
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 defined( GEN_COMPILER_MSVC )
# if _MSC_VER < 1300
#pragma message("GEN_BUILD_DEBUG: __asm int 3")
# define GEN_DEBUG_TRAP() __asm int 3 /* Trap to debugger! */
# else
#pragma message("GEN_BUILD_DEBUG: __debugbreak()")
# define GEN_DEBUG_TRAP() __debugbreak()
# endif
# elif defined( GEN_COMPILER_TINYC )
@ -21,6 +23,7 @@
# define GEN_DEBUG_TRAP() __builtin_trap()
# endif
#else
#pragma message("GEN_BUILD_DEBUG: omitted")
# define GEN_DEBUG_TRAP()
#endif
@ -48,7 +51,7 @@
local_persist thread_local \
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); \
} \
while (0)
@ -57,7 +60,8 @@
# define GEN_FATAL( ... ) \
do \
{ \
str_fmt_out_err( __VA_ARGS__ ); \
c_str_fmt_out_err( __VA_ARGS__ ); \
GEN_DEBUG_TRAP(); \
process_exit(1); \
} \
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;
return NULL;
}
len = str_len( text );
len = c_str_len( text );
if ( len == 0 )
{
if ( w_len_ )
@ -284,7 +284,7 @@ GEN_FILE_OPEN_PROC( _posix_file_open )
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 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 err = EFileError_NONE;
ssize len = str_len( filename );
ssize len = c_str_len( filename );
f->ops = ops;
f->fd = fd;

View File

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

View File

@ -5,6 +5,24 @@
#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
#define global static // Global variables
#endif
@ -69,7 +87,13 @@
#endif
#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 \
do \

View File

@ -8,7 +8,7 @@
#define _adt_fprintf( s_, fmt_, ... ) \
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; \
} 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++ )
{
if ( ! str_compare( node->nodes[ i ].name, name ) )
if ( ! c_str_compare( node->nodes[ i ].name, name ) )
{
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_STRING :
{
if ( node->string && ! str_compare( node->string, value ) )
if ( node->string && ! c_str_compare( node->string, value ) )
{
return node;
}
@ -115,7 +115,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value )
ssize fsize = 0;
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 );
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++ )
{
if ( ! str_compare( node->nodes[ i ].name, name ) )
if ( ! c_str_compare( node->nodes[ i ].name, name ) )
{
ADT_Node* child = &node->nodes[ i ];
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
str_fmt_out( "uri: %s\n", uri );
c_str_fmt_out( "uri: %s\n", uri );
#endif
char * p = ( char* )uri, *b = p, *e = p;
ADT_Node* found_node = NULL;
b = p;
p = e = ( char* )str_skip( p, '/' );
char* buf = str_fmt_buf( "%.*s", ( int )( e - b ), b );
p = e = ( char* )c_str_skip( p, '/' );
char* buf = c_str_fmt_buf( "%.*s", ( int )( e - b ), b );
/* handle field value lookup */
if ( *b == '[' )
{
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_e2 = ( char* )str_skip( l_p, ']' );
l_e = ( char* )c_str_skip( l_p, '=' );
l_e2 = ( char* )c_str_skip( l_p, ']' );
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 */
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)) )
{
found_node = &node->nodes[ idx ];
@ -511,7 +511,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
}
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;
}
@ -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 )
{
node->integer = str_to_i64( buf, 0, 0 );
node->integer = c_str_to_i64( buf, 0, 0 );
#ifndef GEN_PARSER_DISABLE_ANALYSIS
/* special case: negative zero */
if ( node->integer == 0 && buf[ 0 ] == '-' )
@ -595,19 +595,19 @@ char* adt_parse_number( ADT_Node* node, char* base_str )
}
else
{
node->real = str_to_f64( buf, 0 );
node->real = c_str_to_f64( buf, 0 );
#ifndef GEN_PARSER_DISABLE_ANALYSIS
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_string2 = base_string + 1;
char* base_string_off = base_string2;
while ( *base_string_off++ == '0' )
char* base_strbuilder_off = base_string2;
while ( *base_strbuilder_off++ == '0' )
base2_offset++;
base = ( s32 )str_to_i64( q, 0, 0 );
base2 = ( s32 )str_to_i64( base_string2, 0, 0 );
base = ( s32 )c_str_to_i64( q, 0, 0 );
base2 = ( s32 )c_str_to_i64( base_string2, 0, 0 );
if ( exp )
{
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
{
p = str_skip_any( p, escaped_chars );
p = c_str_skip_any( p, escaped_chars );
_adt_fprintf( file, "%.*s", pointer_diff( b, p ), b );
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;
}
ADT_Error adt_str_to_number( ADT_Node* node )
ADT_Error adt_c_str_to_number( ADT_Node* node )
{
GEN_ASSERT( node );
@ -779,7 +779,7 @@ ADT_Error adt_str_to_number( ADT_Node* node )
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 );
@ -826,7 +826,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
do
{
char delimiter = 0;
currentChar = ccast( char*, str_trim( currentChar, false ));
currentChar = ccast( char*, c_str_trim( currentChar, false ));
if ( *currentChar == 0 )
break;
@ -850,7 +850,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
#endif
do
{
endChar = ccast( char*, str_skip( endChar, '"' ));
endChar = ccast( char*, c_str_skip( endChar, '"' ));
if ( *endChar && *( endChar + 1 ) == '"' )
{
@ -869,7 +869,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
}
*endChar = 0;
currentChar = ccast( char*, str_trim( endChar + 1, true ));
currentChar = ccast( char*, c_str_trim( endChar + 1, true ));
delimiter = * currentChar;
/* 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 ) == '"' )
{
mem_move( escapedChar, escapedChar + 1, str_len( escapedChar ) );
mem_move( escapedChar, escapedChar + 1, c_str_len( escapedChar ) );
}
escapedChar++;
}
@ -906,7 +906,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
if ( * endChar )
{
currentChar = ccast( char*, str_trim( endChar, true ));
currentChar = ccast( char*, c_str_trim( endChar, true ));
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;
// 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
do
@ -946,7 +946,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b
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 :
{
str_fmt_file( file, "\"" );
c_str_fmt_file( file, "\"" );
adt_print_string( file, node, "\"", "\"" );
str_fmt_file( file, "\"" );
c_str_fmt_file( file, "\"" );
}
break;
case EADT_NAME_STYLE_NO_QUOTES :
{
#endif
str_fmt_file( file, "%s", node->string );
c_str_fmt_file( file, "%s", node->string );
#ifndef GEN_PARSER_DISABLE_ANALYSIS
}
break;
@ -1078,10 +1078,10 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
_csv_write_header( file, &obj->nodes[ i ] );
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++ )
@ -1091,14 +1091,14 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter )
_csv_write_record( file, &obj->nodes[ i ].nodes[ r ] );
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;
file_stream_new( &tmp, a );
@ -1106,7 +1106,7 @@ String csv_write_string_delimiter( AllocatorInfo a, CSV_Object* obj, char delimi
ssize 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 );
return output;
}

View File

@ -350,7 +350,7 @@ char* adt_parse_number_strict( ADT_Node* node, char* base_str );
* @param node
* @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.
@ -359,7 +359,7 @@ ADT_Error adt_str_to_number( ADT_Node* node );
* @param node
* @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.
@ -406,9 +406,9 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator,
void csv_free( 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 );
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 */
@ -425,9 +425,9 @@ void csv_write( FileInfo* file, CSV_Object* obj )
}
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

View File

@ -143,27 +143,15 @@
#if GEN_DONT_USE_NAMESPACE || 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_BEGIN
# define GEN_NS_END
# 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_BEGIN
# define GEN_NS_END
# endif
#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_BEGIN namespace gen {
# define GEN_NS_END }

View File

@ -1,6 +1,6 @@
#ifdef GEN_INTELLISENSE_DIRECTIVES
# pragma once
# include "string_ops.cpp"
# include "strbuilder_ops.cpp"
#endif
#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 )
{
res += str_copy_nulpad( text, "(null)", 6 );
res += c_str_copy_nulpad( text, "(null)", 6 );
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.
len = info->precision;
else
len = str_len( str );
len = c_str_len( str );
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;
if ( res + len > max_len )
return res;
res += str_copy_nulpad( text, str, len );
res += c_str_copy_nulpad( text, str, len );
text += 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 )
return res;
res += str_copy_nulpad( text, str, len );
res += c_str_copy_nulpad( text, str, len );
}
if ( info )
{
if ( info->flags & GEN_FMT_UPPER )
str_to_upper( begin );
c_str_to_upper( begin );
else if ( info->flags & GEN_FMT_LOWER )
str_to_lower( begin );
c_str_to_lower( begin );
}
return res;
@ -238,7 +238,7 @@ internal ssize _print_f64( char* text, ssize max_len, _format_info* info, b32 is
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;
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
{
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 )
{
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
{
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;
}
@ -419,19 +419,20 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis
case 'S':
{
if ( *(fmt + 1) == 'C' )
if ( *(fmt + 1) == 'B' )
{
++ fmt;
StrC gen_str = va_arg( va, StrC);
info.precision = gen_str.Len;
len = _print_string( text, remaining, &info, gen_str.Ptr );
StrBuilder gen_str = { va_arg( va, char*) };
info.precision = strbuilder_length(gen_str);
len = _print_string( text, remaining, &info, gen_str );
break;
}
String gen_str = { va_arg( va, char*) };
info.precision = string_length(gen_str);
len = _print_string( text, remaining, &info, gen_str );
Str gen_str = va_arg( va, Str);
info.precision = gen_str.Len;
len = _print_string( text, remaining, &info, gen_str.Ptr );
}
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;
}
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 ];
str_fmt_va( buffer, size_of( buffer ), fmt, va );
c_str_fmt_va( buffer, size_of( buffer ), fmt, va );
return buffer;
}
char* str_fmt_buf( char const* fmt, ... )
char* c_str_fmt_buf( char const* fmt, ... )
{
va_list va;
char* str;
va_start( va, fmt );
str = str_fmt_buf_va( fmt, va );
str = c_str_fmt_buf_va( fmt, va );
va_end( va );
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 ];
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
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;
va_list va;
va_start( va, fmt );
res = str_fmt_file_va( f, fmt, va );
res = c_str_fmt_file_va( f, fmt, va );
va_end( va );
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;
va_list va;
va_start( va, fmt );
res = str_fmt_va( str, n, fmt, va );
res = c_str_fmt_va( str, n, fmt, va );
va_end( va );
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;
va_list va;
va_start( va, fmt );
res = str_fmt_out_err_va( fmt, va );
res = c_str_fmt_out_err_va( fmt, va );
va_end( va );
return res;
}

View File

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

View File

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

View File

@ -18,7 +18,7 @@ ssize _scan_zpl_i64( const char* text, s32 base, s64* value )
text++;
}
if ( base == 16 && str_compare_len( text, "0x", 2 ) == 0 )
if ( base == 16 && c_str_compare_len( text, "0x", 2 ) == 0 )
text += 2;
for ( ;; )
@ -53,14 +53,14 @@ global const char _num_to_char_table[] =
"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;
s64 value;
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;
else
base = 10;
@ -100,7 +100,7 @@ void i64_to_str( s64 value, char* string, s32 base )
if ( negative )
*buf++ = '-';
*buf = '\0';
str_reverse( string );
c_str_reverse( string );
}
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';
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;
s32 frac;

View File

@ -18,25 +18,25 @@ char char_to_upper( char c );
s32 digit_to_int( char c );
s32 hex_digit_to_int( char c );
s32 str_compare( const char* s1, const char* s2 );
s32 str_compare_len( const char* s1, const char* s2, ssize len );
char* str_copy( char* dest, const char* source, ssize len );
ssize str_copy_nulpad( char* dest, const char* source, ssize len );
ssize str_len( const char* str );
ssize str_len_capped( const char* str, ssize max_len );
char* str_reverse( char* str ); // NOTE: ASCII only
char const* str_skip( char const* str, char c );
char const* str_skip_any( char const* str, char const* char_list );
char const* str_trim( char const* str, b32 catch_newline );
s32 c_str_compare( const char* s1, const char* s2 );
s32 c_str_compare_len( const char* s1, const char* s2, ssize len );
char* c_str_copy( char* dest, const char* source, ssize len );
ssize c_str_copy_nulpad( char* dest, const char* source, ssize len );
ssize c_str_len( const char* str );
ssize c_str_len_capped( const char* str, ssize max_len );
char* c_str_reverse( char* str ); // NOTE: ASCII only
char const* c_str_skip( char const* str, char c );
char const* c_str_skip_any( char const* str, char const* char_list );
char const* c_str_trim( char const* str, b32 catch_newline );
// NOTE: ASCII only
void str_to_lower( char* str );
void str_to_upper( char* str );
void c_str_to_lower( 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 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
const char* char_first_occurence( const char* s, char c )
@ -122,7 +122,7 @@ s32 hex_digit_to_int( char c )
}
inline
s32 str_compare( const char* s1, const char* s2 )
s32 c_str_compare( const char* s1, const char* s2 )
{
while ( *s1 && ( *s1 == *s2 ) )
{
@ -132,7 +132,7 @@ s32 str_compare( const char* s1, const char* s2 )
}
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-- )
{
@ -145,7 +145,7 @@ s32 str_compare_len( const char* s1, const char* s2, ssize len )
}
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 );
if ( source )
@ -166,7 +166,7 @@ char* str_copy( char* dest, const char* source, ssize len )
}
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;
GEN_ASSERT_NOT_NULL( dest );
@ -191,7 +191,7 @@ ssize str_copy_nulpad( char* dest, const char* source, ssize len )
}
inline
ssize str_len( const char* str )
ssize c_str_len( const char* str )
{
if ( str == NULL )
{
@ -204,7 +204,7 @@ ssize str_len( const char* str )
}
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 ));
if ( end )
@ -213,9 +213,9 @@ ssize str_len_capped( const char* str, ssize max_len )
}
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* b = str + len - 1;
len /= 2;
@ -228,7 +228,7 @@ char* str_reverse( char* str )
}
inline
char const* str_skip( char const* str, char c )
char const* c_str_skip( char const* str, char c )
{
while ( *str && *str != c )
{
@ -238,20 +238,20 @@ char const* str_skip( char const* str, char c )
}
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 ) ));
ssize char_list_count = str_len( char_list );
char const* closest_ptr = rcast( char const*, pointer_add_const( rcast(mem_ptr_const, str), c_str_len( str ) ));
ssize char_list_count = c_str_len( char_list );
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 );
}
return closest_ptr;
}
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' ) ) )
{
@ -261,7 +261,7 @@ char const* str_trim( char const* str, b32 catch_newline )
}
inline
void str_to_lower( char* str )
void c_str_to_lower( char* str )
{
if ( ! str )
return;
@ -273,7 +273,7 @@ void str_to_lower( char* str )
}
inline
void str_to_upper( char* str )
void c_str_to_upper( char* str )
{
if ( ! str )
return;

View File

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

View File

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

View File

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

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.upfront.cpp"
#include "components/gen/etoktype.cpp"
#include "components/lexer.cpp"
#include "components/parser.cpp"
#include "components/interface.parsing.cpp"

View File

@ -20,6 +20,8 @@ GEN_NS_BEGIN
#include "components/gen/ecodetypes.hpp"
#include "components/gen/eoperator.hpp"
#include "components/gen/especifier.hpp"
#include "components/gen/etoktype.hpp"
#include "components/parser_types.hpp"
#include "components/ast.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 )
{
FixedArena_32KB scratch; fixed_arena_init(& scratch);
FixedArena_32KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
String enum_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
String to_keyword_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) );
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
StrBuilder enum_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(1) );
StrBuilder to_c_str_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, 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 ) {
char const* code = csv_enum.Col_1[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.
string_append_fmt( & enum_entries, "CT_%s,\n", code );
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", code, code );
string_append_fmt( & to_keyword_str_entries, "{ sizeof(\"%s\") - 1, \"%s\" },\n", keyword, keyword );
// TODO(Ed): to_c_str_entries and the others in here didn't have proper sizing of the Str slice.
strbuilder_append_fmt( & enum_entries, "CT_%s,\n", code );
strbuilder_append_fmt( & to_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", code, code );
strbuilder_append_fmt( & to_keyword_c_str_entries, "{ \"%s\", sizeof(\"%s\") - 1 },\n", keyword, keyword );
}
CodeEnum enum_code;
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 };"
));
}
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 };"
));
}
#pragma push_macro("local_persist")
#undef local_persist
StrC lookup_size = string_to_strc(string_fmt_buf(GlobalAllocator, "%d", array_num(csv_enum.Col_1) ));
CodeBody to_str_fns = parse_global_body( token_fmt(
"entries", string_to_strc(to_str_entries)
, "keywords", string_to_strc(to_keyword_str_entries)
Str lookup_size = strbuilder_to_str(strbuilder_fmt_buf(_ctx->Allocator_Temp, "%d", array_num(csv_enum.Col_1) ));
CodeBody to_c_str_fns = parse_global_body( token_fmt(
"entries", strbuilder_to_str(to_c_str_entries)
, "keywords", strbuilder_to_str(to_keyword_c_str_entries)
, "num", lookup_size
, stringize(
inline
StrC codetype_to_str( CodeType type )
Str codetype_to_str( CodeType type )
{
local_persist
StrC lookup[<num>] = {
Str lookup[<num>] = {
<entries>
};
return lookup[ type ];
}
inline
StrC codetype_to_keyword_str( CodeType type )
Str codetype_to_keyword_str( CodeType type )
{
local_persist
StrC lookup[ <num> ] = {
Str lookup[ <num> ] = {
<keywords>
};
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, to_str_fns);
body_append(result, to_c_str_fns);
if (! use_c_definition) {
#pragma push_macro("forceinline")
#undef forceinline
CodeBody alias_mappings = parse_global_body(code(
forceinline StrC to_str (CodeType type) { return codetype_to_str(type); }
forceinline StrC to_keyword_str(CodeType type) { return codetype_to_keyword_str(type); }
forceinline Str to_str (CodeType type) { return codetype_to_str(type); }
forceinline Str to_keyword_str(CodeType type) { return codetype_to_keyword_str(type); }
));
#pragma pop_macro("forceinline")
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 )
{
FixedArena_16KB scratch; fixed_arena_init(& scratch);
FixedArena_16KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
String enum_entries = string_make_reserve( GlobalAllocator, 32 );
String to_str_entries = string_make_reserve( GlobalAllocator, 32 );
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
StrBuilder enum_entries = strbuilder_make_reserve( _ctx->Allocator_Temp, 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++) {
char const* enum_str = csv_enum.Col_1[idx].string;
char const* entry_to_str = csv_enum.Col_2[idx].string;
string_append_fmt( & enum_entries, "Op_%s,\n", enum_str );
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
strbuilder_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);
}
CodeEnum enum_code;
@ -113,7 +112,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
{
#pragma push_macro("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)
{
<entries>
@ -125,7 +124,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
}
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
{
<entries>
@ -137,16 +136,16 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
#pragma push_macro("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(
"entries", string_to_strc(to_str_entries)
"entries", strbuilder_to_str(to_c_str_entries)
, "num", lookup_size
, stringize(
inline
StrC operator_to_str( Operator op )
Str operator_to_str( Operator op )
{
local_persist
StrC lookup[<num>] = {
Str lookup[<num>] = {
<entries>
};
@ -169,7 +168,7 @@ CodeBody gen_eoperator( char const* path, bool use_c_definition = false )
#pragma push_macro("forceinline")
#undef forceinline
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")
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 )
{
FixedArena_16KB scratch; fixed_arena_init(& scratch);
FixedArena_16KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
String enum_entries = string_make_reserve( scratch_info, kilobytes(1) );
String to_str_entries = string_make_reserve( scratch_info, kilobytes(1) );
CSV_Columns2 csv_enum = parse_csv_two_columns( scratch_info, path );
StrBuilder enum_entries = strbuilder_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++)
{
char const* enum_str = csv_enum.Col_1[idx].string;
char const* entry_to_str = csv_enum.Col_2[idx].string;
string_append_fmt( & enum_entries, "Spec_%s,\n", enum_str );
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
strbuilder_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);
}
CodeEnum enum_code;
@ -200,7 +198,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
{
#pragma push_macro("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)
{
<entries>
@ -212,7 +210,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
}
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
{
<entries>
@ -221,8 +219,7 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
};
)));
}
CodeFn is_trailing = parse_function(token_fmt("specifier", string_to_strc(to_str_entries), stringize(
CodeFn is_trailing = parse_function(token_fmt("specifier", strbuilder_to_str(to_c_str_entries), stringize(
inline
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 forceinline
#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(
"entries", string_to_strc(to_str_entries)
"entries", strbuilder_to_str(to_c_str_entries)
, "num", lookup_size
, stringize(
inline
StrC spec_to_str( Specifier type )
Str spec_to_str( Specifier type )
{
local_persist
StrC lookup[<num>] = {
Str lookup[<num>] = {
<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
Specifier strc_to_specifier( StrC str )
Specifier str_to_specifier( Str str )
{
local_persist
u32 keymap[ Spec_NumSpecifiers ];
do_once_start
for ( u32 index = 0; index < Spec_NumSpecifiers; index++ )
{
StrC enum_str = spec_to_str( (Specifier)index );
Str enum_str = spec_to_str( (Specifier)index );
// We subtract 1 to remove the null terminator
// 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
@ -308,8 +305,8 @@ CodeBody gen_especifier( char const* path, bool use_c_definition = false )
#pragma push_macro("forceinline")
#undef forceinline
CodeBody alias_mappings = parse_global_body(code(
forceinline StrC to_str (Specifier spec) { return spec_to_str(spec); }
forceinline Specifier to_type( StrC str ) { return strc_to_specifier(str); }
forceinline Str to_str (Specifier spec) { return spec_to_str(spec); }
forceinline Specifier to_type( Str str ) { return str_to_specifier(str); }
forceinline bool is_trailing( Specifier specifier ) { return spec_is_trailing(specifier); }
));
#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 )
{
FixedArena_64KB scratch; fixed_arena_init(& scratch);
FixedArena_64KB scratch; fixed_arena_init(& scratch);
AllocatorInfo scratch_info = fixed_arena_allocator_info(& scratch);
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_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_str_strs = csv_enum_nodes.nodes[1].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> enum_strs = csv_enum_nodes.nodes[0].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_c_str_strs = csv_attr_nodes.nodes[1].nodes;
String enum_entries = string_make_reserve( scratch_info, kilobytes(2) );
String to_str_entries = string_make_reserve( scratch_info, kilobytes(4) );
String attribute_entries = string_make_reserve( scratch_info, kilobytes(2) );
String to_str_attributes = string_make_reserve( scratch_info, kilobytes(4) );
String attribute_define_entries = string_make_reserve( scratch_info, kilobytes(4) );
StrBuilder enum_entries = strbuilder_make_reserve( scratch_info, kilobytes(2) );
StrBuilder to_c_str_entries = strbuilder_make_reserve( scratch_info, kilobytes(4) );
StrBuilder attribute_entries = strbuilder_make_reserve( scratch_info, kilobytes(2) );
StrBuilder to_c_str_attributes = strbuilder_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++)
{
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 );
string_append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str);
strbuilder_append_fmt( & enum_entries, "Tok_%s,\n", enum_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++ )
{
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 );
string_append_fmt( & to_str_attributes, "{ sizeof(\"%s\"), \"%s\" },\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_entries, "Tok_Attribute_%s,\n", attribute_str );
strbuilder_append_fmt( & to_c_str_attributes, "{ \"%s\", sizeof(\"%s\") - 1 },\n", entry_to_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 )
string_append_strc( & attribute_define_entries, txt(" \\\n"));
strbuilder_append_str( & attribute_define_entries, txt(" \\\n"));
else
string_append_strc( & attribute_define_entries, txt("\n"));
strbuilder_append_str( & attribute_define_entries, txt("\n"));
}
#pragma push_macro("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")
// We cannot parse this enum, it has Attribute names as enums
CodeEnum enum_code;
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
{
<entries>
@ -389,7 +386,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
}
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
{
<entries>
@ -405,12 +402,12 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
#undef local_persist
#undef do_once_start
#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
StrC toktype_to_str( TokType type )
Str toktype_to_str( TokType type )
{
local_persist
StrC lookup[] = {
Str lookup[] = {
<entries>
<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
TokType strc_to_toktype( StrC str )
TokType str_to_toktype( Str 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 );
Str enum_str = toktype_to_str( (TokType)index );
// We subtract 1 to remove the null terminator
// 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
@ -452,7 +449,6 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path, bool use_c_
#pragma pop_macro("do_once_end")
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, enum_code);
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_type);
body_append(result, untyped_str(txt("\nGEN_NS_PARSER_END\n\n")));
return result;
}
@ -508,7 +503,7 @@ CodeBody gen_ast_inlines()
{
if ( ast == nullptr )
{
log_failure( "Attempt to dereference a nullptr!" );
log_failure( "Attempt to dereference a nullptr!\n" );
return nullptr;
}
return ast;
@ -518,59 +513,59 @@ CodeBody gen_ast_inlines()
#pragma pop_macro("GEN_NS")
#pragma pop_macro("CodeInvalid")
CodeBody impl_code = parse_global_body( token_fmt( "typename", StrC name(Code), code_impl_tmpl ));
CodeBody impl_code_body = parse_global_body( token_fmt( "typename", StrC name(CodeBody), code_impl_tmpl ));
CodeBody impl_code_attr = parse_global_body( token_fmt( "typename", StrC name(CodeAttributes), code_impl_tmpl ));
CodeBody impl_code_cmt = parse_global_body( token_fmt( "typename", StrC name(CodeComment), code_impl_tmpl ));
CodeBody impl_code_constr = parse_global_body( token_fmt( "typename", StrC name(CodeConstructor), code_impl_tmpl ));
CodeBody impl_code_class = parse_global_body( token_fmt( "typename", StrC name(CodeClass), code_impl_tmpl ));
CodeBody impl_code_define = parse_global_body( token_fmt( "typename", StrC name(CodeDefine), code_impl_tmpl ));
CodeBody impl_code_destruct = parse_global_body( token_fmt( "typename", StrC name(CodeDestructor), code_impl_tmpl ));
CodeBody impl_code_enum = parse_global_body( token_fmt( "typename", StrC name(CodeEnum), code_impl_tmpl ));
CodeBody impl_code_exec = parse_global_body( token_fmt( "typename", StrC name(CodeExec), code_impl_tmpl ));
CodeBody impl_code_extern = parse_global_body( token_fmt( "typename", StrC name(CodeExtern), code_impl_tmpl ));
CodeBody impl_code_include = parse_global_body( token_fmt( "typename", StrC name(CodeInclude), code_impl_tmpl ));
CodeBody impl_code_friend = parse_global_body( token_fmt( "typename", StrC name(CodeFriend), code_impl_tmpl ));
CodeBody impl_code_fn = parse_global_body( token_fmt( "typename", StrC name(CodeFn), code_impl_tmpl ));
CodeBody impl_code_module = parse_global_body( token_fmt( "typename", StrC name(CodeModule), code_impl_tmpl ));
CodeBody impl_code_ns = parse_global_body( token_fmt( "typename", StrC name(CodeNS), code_impl_tmpl ));
CodeBody impl_code_op = parse_global_body( token_fmt( "typename", StrC name(CodeOperator), code_impl_tmpl ));
CodeBody impl_code_opcast = parse_global_body( token_fmt( "typename", StrC name(CodeOpCast), code_impl_tmpl ));
CodeBody impl_code_params = parse_global_body( token_fmt( "typename", StrC name(CodeParams), code_impl_tmpl ));
CodeBody impl_code_pragma = parse_global_body( token_fmt( "typename", StrC name(CodePragma), code_impl_tmpl ));
CodeBody impl_code_precond = parse_global_body( token_fmt( "typename", StrC name(CodePreprocessCond), code_impl_tmpl ));
CodeBody impl_code_specs = parse_global_body( token_fmt( "typename", StrC name(CodeSpecifiers), code_impl_tmpl ));
CodeBody impl_code_struct = parse_global_body( token_fmt( "typename", StrC name(CodeStruct), code_impl_tmpl ));
CodeBody impl_code_tmpl = parse_global_body( token_fmt( "typename", StrC name(CodeTemplate), code_impl_tmpl ));
CodeBody impl_code_type = parse_global_body( token_fmt( "typename", StrC name(CodeTypename), code_impl_tmpl ));
CodeBody impl_code_typedef = parse_global_body( token_fmt( "typename", StrC name(CodeTypedef), code_impl_tmpl ));
CodeBody impl_code_union = parse_global_body( token_fmt( "typename", StrC name(CodeUnion), code_impl_tmpl ));
CodeBody impl_code_using = parse_global_body( token_fmt( "typename", StrC name(CodeUsing), code_impl_tmpl ));
CodeBody impl_code_var = parse_global_body( token_fmt( "typename", StrC name(CodeVar), 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", Str name(CodeBody), 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", Str name(CodeComment), 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", Str name(CodeClass), 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", Str name(CodeDestructor), 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", Str name(CodeExec), 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", Str name(CodeInclude), 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", Str name(CodeFn), 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", Str name(CodeNS), 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", Str name(CodeOpCast), 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", Str name(CodePragma), 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", Str name(CodeSpecifiers), 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", Str name(CodeTemplate), 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", Str name(CodeTypedef), 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", Str name(CodeUsing), 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_cmt, parse_global_body( token_fmt( "typename", StrC 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_define, parse_global_body( token_fmt( "typename", StrC 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_enum, parse_global_body( token_fmt( "typename", StrC 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_extern, parse_global_body( token_fmt( "typename", StrC 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_friend, parse_global_body( token_fmt( "typename", StrC 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_module, parse_global_body( token_fmt( "typename", StrC 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_op, parse_global_body( token_fmt( "typename", StrC 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_pragma, parse_global_body( token_fmt( "typename", StrC 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_tmpl, parse_global_body( token_fmt( "typename", StrC 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_typedef, parse_global_body( token_fmt( "typename", StrC 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_using, parse_global_body( token_fmt( "typename", StrC 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_attr, parse_global_body( token_fmt( "typename", Str name(Attributes), 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", Str name(Constructor), 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", Str name(Destructor), 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", Str name(Exec), 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", Str name(Include), 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", Str name(Fn), 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", Str name(NS), 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", Str name(OpCast), 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", Str name(PreprocessCond), 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", Str name(Typename), 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", Str name(Union), 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", Str name(Var), codetype_impl_tmpl )));
#pragma push_macro("forceinline")
#undef forceinline
@ -582,34 +577,34 @@ CodeBody gen_ast_inlines()
);
#pragma pop_macro("forceinline")
CodeBody impl_cast_body = parse_global_body( token_fmt( "typename", StrC name(Body), cast_tmpl ));
CodeBody impl_cast_attribute = parse_global_body( token_fmt( "typename", StrC name(Attributes), cast_tmpl ));
CodeBody impl_cast_cmt = parse_global_body( token_fmt( "typename", StrC name(Comment), cast_tmpl ));
CodeBody impl_cast_constr = parse_global_body( token_fmt( "typename", StrC name(Constructor), cast_tmpl ));
CodeBody impl_cast_class = parse_global_body( token_fmt( "typename", StrC name(Class), cast_tmpl ));
CodeBody impl_cast_define = parse_global_body( token_fmt( "typename", StrC name(Define), cast_tmpl ));
CodeBody impl_cast_destruct = parse_global_body( token_fmt( "typename", StrC name(Destructor), cast_tmpl ));
CodeBody impl_cast_enum = parse_global_body( token_fmt( "typename", StrC name(Enum), cast_tmpl ));
CodeBody impl_cast_exec = parse_global_body( token_fmt( "typename", StrC name(Exec), cast_tmpl ));
CodeBody impl_cast_extern = parse_global_body( token_fmt( "typename", StrC name(Extern), cast_tmpl ));
CodeBody impl_cast_friend = parse_global_body( token_fmt( "typename", StrC name(Friend), cast_tmpl ));
CodeBody impl_cast_fn = parse_global_body( token_fmt( "typename", StrC name(Fn), cast_tmpl ));
CodeBody impl_cast_include = parse_global_body( token_fmt( "typename", StrC name(Include), cast_tmpl ));
CodeBody impl_cast_module = parse_global_body( token_fmt( "typename", StrC name(Module), cast_tmpl ));
CodeBody impl_cast_ns = parse_global_body( token_fmt( "typename", StrC name(NS), cast_tmpl ));
CodeBody impl_cast_op = parse_global_body( token_fmt( "typename", StrC name(Operator), cast_tmpl ));
CodeBody impl_cast_opcast = parse_global_body( token_fmt( "typename", StrC name(OpCast), cast_tmpl ));
CodeBody impl_cast_params = parse_global_body( token_fmt( "typename", StrC name(Params), cast_tmpl ));
CodeBody impl_cast_pragma = parse_global_body( token_fmt( "typename", StrC name(Pragma), cast_tmpl ));
CodeBody impl_cast_precond = parse_global_body( token_fmt( "typename", StrC name(PreprocessCond), cast_tmpl ));
CodeBody impl_cast_specs = parse_global_body( token_fmt( "typename", StrC name(Specifiers), cast_tmpl ));
CodeBody impl_cast_struct = parse_global_body( token_fmt( "typename", StrC name(Struct), cast_tmpl ));
CodeBody impl_cast_tmpl = parse_global_body( token_fmt( "typename", StrC name(Template), cast_tmpl ));
CodeBody impl_cast_type = parse_global_body( token_fmt( "typename", StrC name(Typename), cast_tmpl ));
CodeBody impl_cast_typedef = parse_global_body( token_fmt( "typename", StrC name(Typedef), cast_tmpl ));
CodeBody impl_cast_union = parse_global_body( token_fmt( "typename", StrC name(Union), cast_tmpl ));
CodeBody impl_cast_using = parse_global_body( token_fmt( "typename", StrC name(Using), cast_tmpl ));
CodeBody impl_cast_var = parse_global_body( token_fmt( "typename", StrC name(Var), 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", Str name(Attributes), 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", Str name(Constructor), 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", Str name(Define), 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", Str name(Enum), 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", Str name(Extern), 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", Str name(Fn), 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", Str name(Module), 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", Str name(Operator), 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", Str name(Params), 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", Str name(PreprocessCond), 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", Str name(Struct), 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", Str name(Typename), 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", Str name(Union), 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", Str name(Var), cast_tmpl ));
CodeBody result = def_global_body( args(
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 )
{
GEN_ASSERT_NOT_NULL(path);
String resolved_path = string_make_strc(GlobalAllocator, to_strc_from_c_str(path));
String style_arg;
StrBuilder resolved_path = strbuilder_make_str(_ctx->Allocator_Temp, to_str_from_c_str(path));
StrBuilder style_arg;
if (style_path) {
style_arg = string_make_strc(GlobalAllocator, txt("-style=file:"));
string_append_fmt( & style_arg, "%s ", style_path );
style_arg = strbuilder_make_str(_ctx->Allocator_Temp, txt("-style=file:"));
strbuilder_append_fmt( & style_arg, "%s ", style_path );
}
StrC clang_format = txt("clang-format ");
StrC cf_format_inplace = txt("-i ");
StrC cf_verbose = txt("-verbose ");
Str clang_format = txt("clang-format ");
Str cf_format_inplace = txt("-i ");
Str cf_verbose = txt("-verbose ");
String command = string_make_strc( GlobalAllocator, clang_format );
string_append_strc( & command, cf_format_inplace );
string_append_strc( & command, cf_verbose );
string_append_string( & command, style_arg );
string_append_string( & command, resolved_path );
StrBuilder command = strbuilder_make_str( _ctx->Allocator_Temp, clang_format );
strbuilder_append_str( & command, cf_format_inplace );
strbuilder_append_str( & command, cf_verbose );
strbuilder_append_string( & command, style_arg );
strbuilder_append_string( & command, resolved_path );
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(refactor_script);
String command = string_make_strc(GlobalAllocator, txt("refactor "));
// string_append_strc( & command, txt("-debug ") );
string_append_strc( & command, txt("-num=1 ") );
string_append_fmt( & command, "-src=%s ", path );
string_append_fmt( & command,"-spec=%s ", refactor_script );
StrBuilder command = strbuilder_make_str(_ctx->Allocator_Temp, txt("refactor "));
// strbuilder_append_str( & command, txt("-debug ") );
strbuilder_append_str( & command, txt("-num=1 ") );
strbuilder_append_fmt( & command, "-src=%s ", path );
strbuilder_append_fmt( & command,"-spec=%s ", refactor_script );
system(command);
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:
```c
String <prefix>_to_string(Code code);
StrBuilder <prefix>_to_strbuilder(Code code);
// 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.
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).
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:
```cpp
StringCached Name;
StrCached Name;
Code Front;
Code Back;
Token* Tok;
@ -56,8 +56,8 @@ Represent standard or vendor specific C/C++ attributes.
Fields:
```cpp
StringCached Content;
StringCached Name;
StrCached Content;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -80,8 +80,8 @@ Stores a comment.
Fields:
```cpp
StringCached Content;
StringCached Name;
StrCached Content;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -109,7 +109,7 @@ CodeComment InlineCmt; // Only supported by forward declarations
CodeAttributes Attributes;
CodeType ParentType;
CodeBody Body;
StringCached Name;
StrCached Name;
CodeType Prev;
CodeType Next;
Token* Tok;
@ -143,7 +143,7 @@ CodeComment InlineCmt; // Only supported by forward declarations
Code InitializerList;
CodeParams Params;
Code Body;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -178,8 +178,8 @@ Represents a preprocessor define
Fields:
```cpp
StringCached Content;
StringCached Name;
StrCached Content;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -201,7 +201,7 @@ Fields:
CodeComment InlineCmt;
CodeSpecifiers Specs;
Code Body;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -242,13 +242,13 @@ Code Prev;
Code Next;
Token* Tok;
Code Parent;
StringCached Name;
StrCached Name;
CodeT Type;
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.
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:
@ -271,8 +271,8 @@ Will be obsolute when function body parsing is implemented.
Fields:
```cpp
StringCached Content;
StringCached Name;
StrCached Content;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -292,7 +292,7 @@ Fields:
```cpp
CodeBody Body;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -314,8 +314,8 @@ extern "<Name>"
Fields:
```cpp
StringCached Content;
StringCached Name;
StrCached Content;
StrCached Name;
Code Prev;
Code Next;
Code Parent;
@ -338,7 +338,7 @@ Fields:
```cpp
CodeComment InlineCmt;
Code Declaration;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -363,7 +363,7 @@ CodeSpecifiers Specs;
CodeType ReturnType;
CodeParams Params;
CodeBody Body;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -390,7 +390,7 @@ Serialization:
Fields:
```cpp
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -411,7 +411,7 @@ Fields:
```cpp
CodeBody Body;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -440,7 +440,7 @@ CodeSpecifiers Specs;
CodeType ReturnType;
CodeParams Params;
CodeBody Body;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -472,7 +472,7 @@ CodeComment InlineCmt;
CodeSpecifiers Specs;
CodeType ValueType;
CodeBody Body;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -502,7 +502,7 @@ CodeType ValueType;
Code Macro;
Code Value;
Code PostNameMacro;
StringCached Name;
StrCached Name;
CodeParams Last;
CodeParams Next;
Token* Tok;
@ -524,8 +524,8 @@ Serialization:
Fields:
```cpp
StringCached Content;
StringCached Name;
StrCached Content;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -544,8 +544,8 @@ Serialization:
Fields:
```cpp
StringCached Content;
StringCached Name;
StrCached Content;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -566,7 +566,7 @@ Fields:
```cpp
SpecifierT ArrSpecs[ AST_ArrSpecs_Cap ];
CodeSpecifiers NextSpecs;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -588,7 +588,7 @@ Fields:
```cpp
CodeParams Params;
Code Declaration;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -621,7 +621,7 @@ Code Prev;
Code Next;
Token* Tok;
Code Parent;
StringCached Name;
StrCached Name;
CodeT Type;
b32 IsParamPack;
ETypenameTag TypeTag;
@ -637,7 +637,7 @@ Serialization:
`<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
@ -649,7 +649,7 @@ Fields:
```cpp
CodeComment InlineCmt;
Code UnderlyingType;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok
@ -682,7 +682,7 @@ Fields:
```cpp
CodeAttributes Attributes;
CodeBody Body;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -708,7 +708,7 @@ Fields:
CodeComment InlineCmt;
CodeAttributes Attributes;
CodeType UnderlyingType;
StringCached Name;
StrCached Name;
Code Prev;
Code Next;
Token* Tok;
@ -740,7 +740,7 @@ CodeSpecifiers Specs;
CodeType ValueType;
Code BitfieldSize;
Code Value;
StringCached Name;
StrCached Name;
CodeVar NextVar;
Code Prev;
Code Next;

View File

@ -12,7 +12,7 @@ gencpp uses a hand-written recursive descent parser. Both the lexer and parser c
### 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`.
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:
```cpp
<code type> parse_<definition type>( StrC def )
<code type> parse_<definition type>( Str def )
{
check_parse_args( def );
using namespace Parser;
@ -287,7 +287,7 @@ In the future statements and expressions will be parsed.
1. Attributes ( Standard, GNU, MSVC, Macro ) : `parse_attributes`
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)
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`
3. Its an operator, function, or varaible : `parse_operator_function_or_varaible`
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:
```cpp
CodeClass parse_class ( StrC class_def );
CodeConstructor parse_constructor ( StrC constructor_def );
CodeDestructor parse_destructor ( StrC destructor_def );
CodeEnum parse_enum ( StrC enum_def );
CodeBody parse_export_body ( StrC export_def );
CodeExtern parse_extern_link ( StrC exten_link_def );
CodeFriend parse_friend ( StrC friend_def );
CodeFn parse_function ( StrC fn_def );
CodeBody parse_global_body ( StrC body_def );
CodeNS parse_namespace ( StrC namespace_def );
CodeOperator parse_operator ( StrC operator_def );
CodeOpCast parse_operator_cast( StrC operator_def );
CodeStruct parse_struct ( StrC struct_def );
CodeTemplate parse_template ( StrC template_def );
CodeType parse_type ( StrC type_def );
CodeTypedef parse_typedef ( StrC typedef_def );
CodeUnion parse_union ( StrC union_def );
CodeUsing parse_using ( StrC using_def );
CodeVar parse_variable ( StrC var_def );
CodeClass parse_class ( Str class_def );
CodeConstructor parse_constructor ( Str constructor_def );
CodeDestructor parse_destructor ( Str destructor_def );
CodeEnum parse_enum ( Str enum_def );
CodeBody parse_export_body ( Str export_def );
CodeExtern parse_extern_link ( Str exten_link_def );
CodeFriend parse_friend ( Str friend_def );
CodeFn parse_function ( Str fn_def );
CodeBody parse_global_body ( Str body_def );
CodeNS parse_namespace ( Str namespace_def );
CodeOperator parse_operator ( Str operator_def );
CodeOpCast parse_operator_cast( Str operator_def );
CodeStruct parse_struct ( Str struct_def );
CodeTemplate parse_template ( Str template_def );
CodeType parse_type ( Str type_def );
CodeTypedef parse_typedef ( Str typedef_def );
CodeUnion parse_union ( Str union_def );
CodeUsing parse_using ( Str using_def );
CodeVar parse_variable ( Str var_def );
```
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
*`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`*
*`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.
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
- sizeof(Code)
- sizeof(StringCached)
- sizeof(StrCached)
- sizeof(Code) * 2
- sizeof(Token*)
- sizeof(Code)
@ -79,7 +79,7 @@ int AST_ArrSpecs_Cap =
Data Notes:
* 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)
* 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.
* `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.
* 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.
* 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.
@ -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:
```cpp
StrC value = txt("Something");
Str value = txt("Something");
char const* template_str = txt(
Code with <key> to replace with token_values
@ -403,7 +403,7 @@ There are two provided auxillary interfaces:
* Builder
* 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.
* 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
```
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.**

View File

@ -24,24 +24,24 @@ constexpr char const* generation_notice =
"// This file was generated automatially by gencpp's c_library.cpp "
"(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.
// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
#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
#endif
)");
constexpr StrC implementation_guard_start = txt(R"(
constexpr Str implementation_guard_start = txt(R"(
#pragma region GENCPP IMPLEMENTATION GUARD
#if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
# define GEN_IMPLEMENTED
)");
constexpr StrC implementation_guard_end = txt(R"(
constexpr Str implementation_guard_end = txt(R"(
#endif
#pragma endregion GENCPP IMPLEMENTATION GUARD
)");
@ -62,20 +62,21 @@ constexpr bool helper_use_c_definition = true;
int gen_main()
{
gen::init();
Context ctx {};
gen::init(& ctx);
PreprocessorDefines.append(txt("GEN_API_C_BEGIN"));
PreprocessorDefines.append(txt("GEN_API_C_END"));
PreprocessorDefines.append(txt("Array("));
PreprocessorDefines.append(txt("HashTable("));
PreprocessorDefines.append(txt("GEN_NS_PARSER"));
PreprocessorDefines.append(txt("GEN_NS_PARSER_BEGIN"));
PreprocessorDefines.append(txt("GEN_NS_PARSER_END"));
PreprocessorDefines.append(txt("Using_Code("));
PreprocessorDefines.append(txt("Using_CodeOps("));
PreprocessorDefines.append(txt("GEN_OPTIMIZE_MAPPINGS_BEGIN"));
PreprocessorDefines.append(txt("GEN_OPITMIZE_MAPPINGS_END"));
PreprocessorDefines.append(txt("GEN_PARAM_DEFAULT"));
ctx.PreprocessorDefines.append(txt("GEN_API_C_BEGIN"));
ctx.PreprocessorDefines.append(txt("GEN_API_C_END"));
ctx.PreprocessorDefines.append(txt("Array("));
ctx.PreprocessorDefines.append(txt("HashTable("));
ctx.PreprocessorDefines.append(txt("GEN_NS_PARSER"));
ctx.PreprocessorDefines.append(txt("GEN_NS_PARSER_BEGIN"));
ctx.PreprocessorDefines.append(txt("GEN_NS_PARSER_END"));
ctx.PreprocessorDefines.append(txt("Using_Code("));
ctx.PreprocessorDefines.append(txt("Using_CodeOps("));
ctx.PreprocessorDefines.append(txt("GEN_OPTIMIZE_MAPPINGS_BEGIN"));
ctx.PreprocessorDefines.append(txt("GEN_OPITMIZE_MAPPINGS_END"));
ctx.PreprocessorDefines.append(txt("GEN_PARAM_DEFAULT"));
//PreprocessorDefines.append(txt("GEN_EXECUTION_EXPRESSION_SUPPORT"));
Code push_ignores = scan_file( path_base "helpers/push_ignores.inline.hpp" );
@ -87,7 +88,7 @@ int gen_main()
#pragma region Resolve Dependencies
Code header_platform = scan_file( path_base "dependencies/platform.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_debug = scan_file( path_base "dependencies/debug.hpp" );
Code header_string_ops = scan_file( path_base "dependencies/string_ops.hpp" );
@ -100,7 +101,7 @@ int gen_main()
{
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);
CodeTypedef typedef_ver = def_typedef(using_ver->Name, using_ver->UnderlyingType);
@ -126,7 +127,7 @@ int gen_main()
if (fn->Specs) {
s32 constexpr_found = fn->Specs.remove( Spec_Constexpr );
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);
}
}
@ -238,7 +239,7 @@ do \
break;
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);
header_printing.append(define);
@ -253,7 +254,7 @@ do \
}
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 header_strings = def_body(CT_Global_Body);
@ -292,16 +293,16 @@ do \
case CT_Preprocess_IfNotDef:
{
//log_fmt("\nIFNDEF: %SC\n", entry->Content);
//log_fmt("\nIFNDEF: %S\n", entry->Content);
header_strings.append(entry);
}
break;
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(fmt_newline);
++ entry;
@ -341,12 +342,12 @@ do \
case CT_Typedef:
{
StrC name_string_table = txt("StringTable");
Str name_string_table = txt("StringTable");
CodeTypedef td = cast(CodeTypedef, entry);
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);
break;
}
@ -388,8 +389,8 @@ do \
case CT_Union:
case CT_Union_Fwd:
{
StrC type_str = codetype_to_keyword_str(entry->Type);
StrC formated_tmpl = token_fmt_impl( 3,
Str type_str = codetype_to_keyword_str(entry->Type);
Str formated_tmpl = token_fmt_impl( 3,
"type", type_str
, "name", entry->Name,
stringize(
@ -490,8 +491,8 @@ do \
continue;
}
StrC type_str = codetype_to_keyword_str(entry->Type);
StrC formated_tmpl = token_fmt_impl( 3,
Str type_str = codetype_to_keyword_str(entry->Type);
Str formated_tmpl = token_fmt_impl( 3,
"type", type_str
, "name", entry->Name,
stringize(
@ -549,9 +550,9 @@ do \
{
CodeTypename type = using_ver->UnderlyingType;
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
, "Parameters", to_string(type->Params).to_strc()
, "Parameters", to_strbuilder(type->Params).to_str()
, stringize(
typedef <ReturnType>( * <Name>)(<Parameters>);
)));
@ -578,7 +579,7 @@ do \
types.append(entry_td);
continue;
}
//log_fmt("Detected ENUM: %S", entry->Name);
//log_fmt("Detected ENUM: %SB", entry->Name);
convert_cpp_enum_to_c(cast(CodeEnum, entry), types);
}
break;
@ -588,8 +589,102 @@ do \
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.
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 ast = def_body(CT_Global_Body);
@ -645,11 +740,11 @@ do \
CodeFn fn = cast(CodeFn, entry);
if (fn->Name.starts_with(txt("code_")))
{
StrC old_prefix = txt("code_");
StrC actual_name = { fn->Name.Len - old_prefix.Len, fn->Name.Ptr + old_prefix.Len };
String new_name = String::fmt_buf(GlobalAllocator, "code__%SC", actual_name );
Str old_prefix = txt("code_");
Str actual_name = { fn->Name.Ptr + old_prefix.Len, fn->Name.Len - old_prefix.Len };
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);
}
ast.append(entry);
@ -694,21 +789,21 @@ do \
s32 constexpr_found = var->Specs ? var->Specs.remove( Spec_Constexpr ) : - 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")))
{
Code def = untyped_str(txt(
R"(#define AST_ArrSpecs_Cap \
( \
AST_POD_Size \
- sizeof(Code) \
- sizeof(StringCached) \
- sizeof(Code) * 2 \
- sizeof(Token*) \
- sizeof(Code) \
- sizeof(CodeType) \
- sizeof(ModuleFlag) \
- sizeof(u32) \
AST_POD_Size \
- sizeof(Code) \
- sizeof(StrCached) \
- sizeof(Code) * 2 \
- sizeof(Token*) \
- sizeof(Code) \
- sizeof(CodeType) \
- sizeof(ModuleFlag) \
- sizeof(u32) \
) \
/ sizeof(Specifier) - 1
)"
@ -716,7 +811,7 @@ R"(#define AST_ArrSpecs_Cap \
ast.append(def);
break;
}
CodeDefine def = def_define(var->Name, var->Value.to_string());
CodeDefine def = def_define(var->Name, var->Value.to_strbuilder());
ast.append(def);
break;
}
@ -729,7 +824,7 @@ R"(#define AST_ArrSpecs_Cap \
break;
}
StrC code_typenames[] = {
Str code_typenames[] = {
txt("Code"),
txt("CodeBody"),
txt("CodeAttributes"),
@ -791,24 +886,24 @@ R"(#define AST_ArrSpecs_Cap \
default: gen_generic_selection (Fail case) \
) 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 )
{
generic_selector.clear();
StrC private_prefix = txt("code__");
StrC actual_name = { fn->Name.Len - private_prefix.Len, fn->Name.Ptr + private_prefix.Len };
String interface_name = String::fmt_buf(GlobalAllocator, "code_%SC", actual_name );
Str private_prefix = txt("code__");
Str actual_name = { fn->Name.Ptr + private_prefix.Len, fn->Name.Len - private_prefix.Len };
StrBuilder interface_name = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "code_%S", actual_name );
// Resolve generic's arguments
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) {
// We skip the first parameter as its always going to be the code for selection
if (param->Next == nullptr) {
params_str.append_fmt( "%SC", param->Name );
params_str.append_fmt( "%S", param->Name );
continue;
}
params_str.append_fmt( "%SC, ", param->Name );
params_str.append_fmt( "%S, ", param->Name );
}
char const* tmpl_def_start = nullptr;
@ -824,14 +919,14 @@ R"(#define <interface_name>( code ) _Generic( (code), \
}
// Definition start
generic_selector.append( token_fmt(
"interface_name", interface_name.to_strc()
, "params", params_str.to_strc() // Only used if has_args
"interface_name", interface_name.to_str()
, "params", params_str.to_str() // Only used if has_args
, tmpl_def_start
));
// Append slots
for(StrC type : code_typenames ) {
generic_selector.append_fmt("%SC : %SC,\\\n", type, fn->Name );
for(Str type : code_typenames ) {
generic_selector.append_fmt("%S : %S,\\\n", type, fn->Name );
}
generic_selector.append(txt("default: gen_generic_selection_fail \\\n"));
@ -844,7 +939,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
}
// Definition end
generic_selector.append( token_fmt(
"params", params_str.to_strc()
"params", params_str.to_str()
, "type", fn->Params->ValueType->Name
, tmpl_def_end ) );
@ -890,8 +985,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
char conversion_buf[32] = {};
u64_to_str(size_of(AST_Body::_PAD_), conversion_buf, 10);
StrC arr_exp = union_entry->ValueType->ArrExpr->Content;
StrC cpp_size = to_strc_from_c_str(conversion_buf);
Str arr_exp = union_entry->ValueType->ArrExpr->Content;
Str cpp_size = to_str_from_c_str(conversion_buf);
union_entry->ValueType->ArrExpr = untyped_str( cpp_size );
union_entry->InlineCmt = untyped_str(token_fmt("arr_exp", arr_exp,
"// 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;
}
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 interface = def_body(CT_Global_Body);
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)) {
// rename second definition so there isn't a symbol conflict
String postfix_arr = String::fmt_buf(GlobalAllocator, "%SC_arr", entry->Name);
entry->Name = get_cached_string(postfix_arr.to_strc());
StrBuilder postfix_arr = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%S_arr", entry->Name);
entry->Name = cache_str(postfix_arr.to_str());
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_")))
{
// Convert the definition to use a default struct: https://vxtwitter.com/vkrajacic/status/1749816169736073295
StrC prefix = txt("def_");
StrC actual_name = { fn->Name.Len - prefix.Len, fn->Name.Ptr + prefix.Len };
StrC new_name = String::fmt_buf(GlobalAllocator, "def__%SC", actual_name ).to_strc();
Str prefix = txt("def_");
Str actual_name = { fn->Name.Ptr + prefix.Len, fn->Name.Len - prefix.Len };
Str new_name = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "def__%S", actual_name ).to_str();
// Resolve define's arguments
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) {
if ( other_param == opt_param ) {
params_str.append_fmt( "%SC", other_param->Name );
params_str.append_fmt( "%S", other_param->Name );
break;
}
// 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;
if (params_str.length() > 0 ) {
@ -965,12 +1063,12 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code fn_macro = untyped_str(token_fmt(
"def_name", fn->Name
, "def__name", new_name
, "params", params_str.to_strc()
, "params", params_str.to_str()
, "opts_type", opt_param->ValueType->Name
, tmpl_fn_macro
));
fn->Name = get_cached_string(new_name);
fn->Name = cache_str(new_name);
interface.append(fn);
interface.append(fn_macro);
if (entry->Next && entry->Next->Type != CT_NewLine) {
@ -1019,11 +1117,11 @@ R"(#define <interface_name>( code ) _Generic( (code), \
CodeFn fn = cast(CodeFn, entry);
if (fn->Name.starts_with(txt("code_")))
{
StrC old_prefix = txt("code_");
StrC actual_name = { fn->Name.Len - old_prefix.Len, fn->Name.Ptr + old_prefix.Len };
String new_name = String::fmt_buf(GlobalAllocator, "code__%SC", actual_name );
Str old_prefix = txt("code_");
Str actual_name = { fn->Name.Ptr + old_prefix.Len, fn->Name.Len - old_prefix.Len };
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);
}
@ -1142,10 +1240,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
#pragma endregion Resolve Dependencies
#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_static_data = scan_file( path_base "components/static_data.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);
if (fn->Name.starts_with(txt("code_")))
{
StrC old_prefix = txt("code_");
StrC actual_name = { fn->Name.Len - old_prefix.Len, fn->Name.Ptr + old_prefix.Len };
String new_name = String::fmt_buf(GlobalAllocator, "code__%SC", actual_name );
Str old_prefix = txt("code_");
Str actual_name = { fn->Name.Ptr + old_prefix.Len, fn->Name.Len - old_prefix.Len };
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);
}
@ -1219,18 +1313,18 @@ R"(#define <interface_name>( code ) _Generic( (code), \
)
{
// rename second definition so there isn't a symbol conflict
String postfix_arr = String::fmt_buf(GlobalAllocator, "%SC_arr", fn->Name);
fn->Name = get_cached_string(postfix_arr.to_strc());
StrBuilder postfix_arr = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%S_arr", fn->Name);
fn->Name = cache_str(postfix_arr.to_str());
postfix_arr.free();
}
for ( CodeParams opt_param : fn->Params ) if (opt_param->ValueType->Name.starts_with(txt("Opts_")))
{
StrC prefix = txt("def_");
StrC actual_name = { fn->Name.Len - prefix.Len, fn->Name.Ptr + prefix.Len };
StrC new_name = String::fmt_buf(GlobalAllocator, "def__%SC", actual_name ).to_strc();
Str prefix = txt("def_");
Str actual_name = { fn->Name.Ptr + prefix.Len, fn->Name.Len - prefix.Len };
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);
@ -1267,51 +1361,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
}
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:
{
CodeVar var = cast(CodeVar, entry);
@ -1319,7 +1368,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code define_ver = untyped_str(token_fmt(
"name", var->Name
, "value", var->Value->Content
, "type", var->ValueType.to_string().to_strc()
, "type", var->ValueType.to_strbuilder().to_str()
, "#define <name> (<type>) <value>\n"
));
src_lexer.append(define_ver);
@ -1364,7 +1413,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code define_ver = untyped_str(token_fmt(
"name", var->Name
, "value", var->Value->Content
, "type", var->ValueType.to_string().to_strc()
, "type", var->ValueType.to_strbuilder().to_str()
, "#define <name> (<type>) <value>\n"
));
src_parser.append(define_ver);
@ -1416,13 +1465,14 @@ R"(#define <interface_name>( code ) _Generic( (code), \
Code r_header_timing = refactor(header_timing);
Code rf_header_parsing = refactor_and_format(header_parsing);
Code rf_types = refactor_and_format(types);
Code rf_ecode = refactor_and_format(ecode);
Code rf_eoperator = refactor_and_format(eoperator);
Code rf_especifier = refactor_and_format(especifier);
Code rf_ast = refactor_and_format(ast);
Code rf_code_types = refactor_and_format(code_types);
Code rf_ast_types = refactor_and_format(ast_types);
Code rf_types = refactor_and_format(types);
Code rf_parser_types = refactor_and_format(parser_types);
Code rf_ecode = refactor_and_format(ecode);
Code rf_eoperator = refactor_and_format(eoperator);
Code rf_especifier = refactor_and_format(especifier);
Code rf_ast = refactor_and_format(ast);
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_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( r_header_platform );
header.print_fmt( "\nGEN_NS_BEGIN\n" );
header.print( r_header_macros );
header.print( header_generic_macros );
header.print_fmt( "GEN_API_C_BEGIN\n" );
header.print( r_header_basic_types );
header.print( r_header_debug );
header.print( rf_header_memory );
@ -1497,7 +1549,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( r_header_timing );
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 );
#pragma endregion Print Dependencies
@ -1515,6 +1568,8 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( rf_eoperator );
header.print( fmt_newline );
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 region AST\n");
@ -1523,6 +1578,13 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( rf_ast_types );
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(fmt_newline);
@ -1531,7 +1593,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print_fmt("#pragma endregion Inlines\n");
header.print(fmt_newline);
header.print( rf_array_string_cached );
header.print( rf_header_end );
header.print( rf_header_builder );
@ -1548,7 +1609,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
#pragma region Print Dependencies
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( r_src_dep_start );
@ -1562,17 +1623,14 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( r_src_timing );
header.print( rf_src_parsing );
header.print_fmt( "\nGEN_API_C_END\n" );
header.print_fmt( "GEN_NS_END\n");
header.print_fmt( roll_own_dependencies_guard_end );
#pragma endregion Print Dependencies
#pragma region Print Components
header.print_fmt( "\nGEN_NS_BEGIN\n");
header.print( fmt_newline);
header.print( rf_array_arena );
header.print( fmt_newline);
header.print( rf_array_pool);
header.print_fmt( "GEN_API_C_BEGIN\n" );
header.print( r_src_static_data );
header.print( fmt_newline);
@ -1587,7 +1645,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( r_src_interface );
header.print( r_src_upfront );
header.print_fmt( "\n#pragma region Parsing\n\n" );
header.print( rf_etoktype );
header.print( r_src_lexer );
header.print( fmt_newline);
header.print( rf_array_code_typename );
@ -1596,12 +1653,13 @@ R"(#define <interface_name>( code ) _Generic( (code), \
header.print( r_src_parsing );
header.print_fmt( "\n#pragma endregion Parsing\n" );
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_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
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" );
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, "// 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( fmt_newline );
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 region AST\n");
@ -1732,7 +1791,6 @@ R"(#define <interface_name>( code ) _Generic( (code), \
src.print( r_src_interface );
src.print( r_src_upfront );
src.print_fmt( "\n#pragma region Parsing\n\n" );
src.print( rf_etoktype );
src.print( r_src_lexer );
src.print( fmt_newline);
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_scanner );
src.print_fmt( "GEN_API_C_END\n" );
src.print_fmt( "\nGEN_NS_END\n");
src.write();
}
#pragma endregion Segmented
gen::deinit();
gen::deinit( & ctx);
return 0;
}

View File

@ -167,7 +167,7 @@ namespace pool_, gen_pool_
// Printing
namespace str_, gen_str_
namespace c_str_, gen_c_str_
word PrintF_Buffer, gen_PrintF_Buffer
word Msg_Invalid_Value, gen_Msg_Invalid_Value
@ -211,20 +211,20 @@ word crc64, gen_crc64
// 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 String, gen_String
word StrBuilderHeader, gen_StrBuilderHeader
word StrBuilder, gen_StrBuilder
namespace string_, gen_string_
namespace strbuilder_, gen_strbuilder_
word StringCached, gen_StringCached
word StrCached, gen_StrCached
word StringTable, gen_StringTable
@ -308,7 +308,7 @@ word operator_to_str, gen_operator_to_str
word Specifier, gen_Specifier
word spec_to_str, gen_spec_to_str
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
@ -401,7 +401,7 @@ word init, gen_init
word deinit, gen_deinit
word reset, gen_reset
word get_cached_string, gen_get_cached_string
word cache_str, gen_cache_str
word make_code, gen_make_code
@ -414,20 +414,6 @@ namespace untyped_, gen_untyped_
// 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_protected, gen_access_protected
word access_private, gen_access_private
@ -446,28 +432,17 @@ word preprocess_else, gen_preprocess_else
namespace spec_, gen_spec_
namespace t_, gen_t_
word PreprocessorDefines, gen_PreprocessorDefines
// 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
word Builder, gen_Builder
namespace builder_, gen_builder_
// Scanner
word scan_file, gen_scan_file
// Implementation (prviate)
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_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 operator__validate, gen_operator__validate
@ -523,7 +498,6 @@ word parser_deinit, gen_parser_deinit
word TokType, gen_TokType
word toktype_to_str, gen_toktype_to_str
// word strc_to_toktype, gen_strc_to_toktype
word NullToken, gen_NullToken
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 );
String fn = String::fmt_buf( GlobalAllocator, "%.*s", array_name.Len, array_name.Ptr );
// str_to_lower(fn.Data);
StrBuilder array_type = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "%.*s", array_name.Len, array_name.Ptr );
StrBuilder fn = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "%.*s", array_name.Len, array_name.Ptr );
// c_str_to_lower(fn.Data);
#pragma push_macro( "GEN_ASSERT" )
#pragma push_macro( "rcast" )
@ -56,7 +56,7 @@ CodeBody gen_array( StrC type, StrC array_name )
#undef cast
#undef typeof
#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(
typedef <type>* <array_type>;
@ -375,9 +375,9 @@ CodeBody gen_array( StrC type, StrC array_name )
#pragma pop_macro( "forceinline" )
++ 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
#define GENERIC_SLOT_<slot>__array_init_reserve <type>, <array_type>_init_reserve
#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(
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,
generic_interface_slot,
fmt_newline,
result,
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
));
};

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));
}
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};
String fn = tbl_type.duplicate(GlobalAllocator);
// str_to_lower(fn.Data);
StrBuilder tbl_type = {(char*) hashtable_name.duplicate(_ctx->Allocator_Temp).Ptr};
StrBuilder fn = tbl_type.duplicate(_ctx->Allocator_Temp);
// c_str_to_lower(fn.Data);
String name_lower = String::make( GlobalAllocator, hashtable_name );
// str_to_lower( name_lower.Data );
StrBuilder name_lower = StrBuilder::make( _ctx->Allocator_Temp, hashtable_name );
// c_str_to_lower( name_lower.Data );
String hashtable_entry = String::fmt_buf( GlobalAllocator, "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 );
String entry_array_fn_ns = String::fmt_buf( GlobalAllocator, "arr_hte_%.*s", name_lower.length(), name_lower.Data );
StrBuilder hashtable_entry = StrBuilder::fmt_buf( _ctx->Allocator_Temp, "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 );
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(
"type", (StrC) type,
"tbl_name", (StrC) hashtable_name,
"tbl_type", (StrC) tbl_type,
"type", (Str) type,
"tbl_name", (Str) hashtable_name,
"tbl_type", (Str) tbl_type,
stringize(
typedef struct HashTable_<type> <tbl_type>;
typedef struct HTE_<tbl_name> HTE_<tbl_name>;
@ -74,13 +74,13 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
#undef typeof
#undef forceinline
CodeBody hashtable_def = parse_global_body( token_fmt(
"type", (StrC) type,
"tbl_name", (StrC) hashtable_name,
"tbl_type", (StrC) tbl_type,
"fn", (StrC) fn,
"entry_type", (StrC) hashtable_entry,
"array_entry", (StrC) entry_array_name,
"fn_array", (StrC) entry_array_fn_ns,
"type", (Str) type,
"tbl_name", (Str) hashtable_name,
"tbl_type", (Str) tbl_type,
"fn", (Str) fn,
"entry_type", (Str) hashtable_entry,
"array_entry", (Str) entry_array_name,
"fn_array", (Str) entry_array_fn_ns,
stringize(
struct HashTable_<type> {
Array_ssize Hashes;
@ -372,9 +372,9 @@ CodeBody gen_hashtable( StrC type, StrC hashtable_name )
#pragma pop_macro( "forceinline" )
++ 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
#define GENERIC_SLOT_<slot>__hashtable_init_reserve <type>, <tbl_type>_init_reserve
#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
, type.Len, type.Ptr );
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,
generic_interface_slot,
fmt_newline,
@ -409,7 +409,7 @@ R"(#define GENERIC_SLOT_<slot>__hashtable_init <type>, <tbl_type>_
entry_array,
hashtable_def,
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
));
}

View File

@ -3,9 +3,9 @@
// ____ _ ______ _ _ ____ _ __ _
// / ___} (_) | ____} | | (_) / __ \ | | | |(_)
// | | ___ ___ _ __ ___ _ __ _ ___ | |__ _ _ _ __ ___| |_ _ ___ _ __ | | | |_ _____ _ __ | | ___ __ _ __| | _ _ __ __ _
// | |{__ |/ _ \ '_ \ / _ \ '__} |/ __| | __} | | | '_ \ / __} __} |/ _ \| '_ \ | | | \ \ / / _ \ '_ \| |/ _ \ / _` |/ _` || | '_ \ / _` |
// | |__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|_|_| |_|\__, |
// | |{__ |/ _ \ '_ \ / _ \ '__} |/ __| | __} | | | '_ \ / __} __} |/ _ \| '_ \ | | | \ \ / / _ \ '_ }| |/ _ \ / _` |/ _` || | '_ \ / _` |
// | |__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|_|_| |_|\__, |
// 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 {___/
// 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> ,
#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
// 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:
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:
// ----------------------------------------------------------------------------------------------------------------------------------
#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg ) _Generic( \
(selector_arg), /* Select Via Expression*/ \
/* Extendibility slots: */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
default: gen_generic_selection_fail \
#define GEN_FUNCTION_GENERIC_EXAMPLE( selector_arg ) _Generic( \
(selector_arg), /* Select Via Expression*/ \
/* Extendibility slots: */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2__function_sig ) \
default: gen_generic_selection_fail \
) 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
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.
#define gen_hash_example( function_arguments ) _Generic( \
(function_arguments), /* Select Via Expression*/ \
/* Extendibility slots: */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_2 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_3 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_4 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_5 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_6 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_7 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_8 ) \
default: gen_generic_selection_fail \
#define gen_hash_example( function_arguments ) _Generic( \
(function_arguments), /* Select Via Expression*/ \
/* Extendibility slots: */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_2_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_3_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_4_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_5_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_6_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_7_gen_example_hash ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_8_gen_example_hash ) \
default: gen_generic_selection_fail \
) GEN_RESOLVED_FUNCTION_CALL( function_arguments )
// 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:
#define GEN_FUNCTION_GENERIC_EXAMPLE_VARADIC( selector_arg, ... ) _Generic( \
(selector_arg), \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_2 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig ) \
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 \
) GEN_RESOLVED_FUNCTION_CALL( selector_arg, __VA_ARG__ )
// If the function does not take the arugment as a parameter:
#define GEN_FUNCTION_GENERIC_EXAMPLE_DIRECT_TYPE( selector_arg ) _Generic( \
( GEN_TYPE_TO_EXP(selector_arg) ), \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_1 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( FunctionID__ARGS_SIG_2 ) \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( GENERIC_SLOT_1__function_sig ) \
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 \
) 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")
}
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;
CodePreprocessCond cond = cast(CodePreprocessCond, entry_iter);
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;
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;
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:
#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 )
*/
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();
StrC macro_begin;
Str macro_begin;
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 ), \
)"
);
}
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), \
)"
);
@ -104,73 +104,56 @@ R"(#define <macro_name>(selector_arg, ...) _Generic( (selector_arg), \
for ( s32 slot = 1; slot <= num_slots; ++ slot )
{
StrC slot_str = String::fmt_buf(GlobalAllocator, "%d", slot).to_strc();
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;
}
Str slot_str = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "%d", slot).to_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 (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)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL( __VA_ARGS__ )"));
define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL( __VA_ARGS__ )"));
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
{
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)
define_builder.append(txt("\t)\tGEN_RESOLVED_FUNCTION_CALL()"));
define_builder.append(txt(")\\\nGEN_RESOLVED_FUNCTION_CALL()"));
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
define_builder.append(txt("\n\n"));
Code macro = untyped_str(define_builder.to_strc());
Code macro = untyped_str(define_builder.to_str());
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
StrC old_name = fn->Name;
String new_name;
Str old_name = fn->Name;
StrBuilder new_name;
// Add prefix if provided
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
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
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
bool first_param = true;
@ -198,11 +181,11 @@ CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt(""
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)
{
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);
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;
CodePragma possible_region = cast(CodePragma, entry_iter);
String region_sig = string_fmt_buf(GlobalAllocator, "region %s", region_name.Ptr);
String endregion_sig = string_fmt_buf(GlobalAllocator, "endregion %s", region_name.Ptr);
StrBuilder region_sig = strbuilder_fmt_buf(_ctx->Allocator_Temp, "region %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))
{
found = true;

View File

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

View File

@ -32,7 +32,10 @@ Code format( Code code ) {
int gen_main()
{
gen::init();
Context ctx {
};
gen::init(& ctx);
Code push_ignores = scan_file( (path_base "helpers/push_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")),
preprocess_endif,
fmt_newline,
untyped_str( to_strc_from_c_str(generation_notice) )
untyped_str( to_str_from_c_str(generation_notice) )
));
// gen.hpp
{
Code header_start = scan_file( path_base "components/header_start.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_types = scan_file( path_base "components/ast_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 eoperator = gen_eoperator ( path_base "enums/EOperator.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();
Builder _header = builder_open( "gen/gen.hpp" );
@ -153,6 +158,8 @@ int gen_main()
builder_print( header, fmt_newline);
builder_print( header, format(especifier) );
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 region AST\n" );
@ -171,7 +178,7 @@ int gen_main()
builder_print_fmt( header, "#pragma endregion Inlines\n" );
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_write(header);
}
@ -190,12 +197,6 @@ int gen_main()
Code parsing_interface = scan_file( path_base "components/interface.parsing.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 = & _src;
builder_print_fmt( src, generation_notice );
@ -215,7 +216,6 @@ int gen_main()
builder_print( src, interface );
builder_print( src, upfront );
builder_print_fmt( src, "\n#pragma region Parsing\n\n" );
builder_print( src, formatted_toktype );
builder_print( src, lexer );
builder_print( src, parser );
builder_print( src, parsing_interface );
@ -238,7 +238,7 @@ int gen_main()
builder_print( & header, def_include( txt("gen.hpp") ));
builder_print_fmt( & header, "\nGEN_NS_BEGIN\n" );
builder_print( & header, builder );
builder_print_fmt( & header, "GEN_NS_END\n" );
builder_print_fmt( & header, "\nGEN_NS_END\n" );
builder_write( & header);
}
@ -278,10 +278,10 @@ int gen_main()
builder_print( & src, def_include( txt("gen.scanner.hpp") ) );
builder_print_fmt( & src, "\nGEN_NS_BEGIN\n" );
builder_print( & src, scanner );
builder_print_fmt( & src, "GEN_NS_END\n" );
builder_print_fmt( & src, "\nGEN_NS_END\n" );
builder_write( & src);
}
gen::deinit();
gen::deinit( & ctx);
return 0;
}

View File

@ -17,24 +17,24 @@ constexpr char const* generation_notice =
"// This file was generated automatially by gencpp's singleheader.cpp"
"(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
#if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
# define GEN_IMPLEMENTED
)");
constexpr StrC implementation_guard_end = txt(R"(
constexpr Str implementation_guard_end = txt(R"(
#endif
#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.
// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
#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
#endif
)");
@ -54,7 +54,8 @@ Code format( Code code ) {
int gen_main()
{
gen::init();
Context ctx {};
gen::init( & ctx);
Code push_ignores = scan_file( path_base "helpers/push_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 debug = scan_file( path_base "dependencies/debug.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 containers = scan_file( path_base "dependencies/containers.hpp" );
Code hashing = scan_file( path_base "dependencies/hashing.hpp" );
@ -93,7 +94,7 @@ int gen_main()
header.print( basic_types );
header.print( debug );
header.print( memory );
header.print( string_ops );
header.print( stirng_ops );
header.print( printing );
header.print( containers );
header.print( hashing );
@ -105,22 +106,25 @@ int gen_main()
header.print( scan_file( path_base "dependencies/parsing.hpp" ) );
}
header.print(fmt_newline);
header.print_fmt( "GEN_NS_END\n" );
header.print_fmt( roll_own_dependencies_guard_end );
header.print( fmt_newline );
}
Code types = scan_file( path_base "components/types.hpp" );
Code ast = scan_file( path_base "components/ast.hpp" );
Code ast_types = scan_file( path_base "components/ast_types.hpp" );
Code code_types = scan_file( path_base "components/code_types.hpp" );
Code interface = scan_file( path_base "components/interface.hpp" );
Code inlines = scan_file( path_base "components/inlines.hpp" );
Code header_end = scan_file( path_base "components/header_end.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_types = scan_file( path_base "components/ast_types.hpp" );
Code code_types = scan_file( path_base "components/code_types.hpp" );
Code interface = scan_file( path_base "components/interface.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 eoperator = gen_eoperator ( path_base "enums/EOperator.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();
header.print_fmt( "GEN_NS_BEGIN\n\n" );
@ -134,6 +138,9 @@ int gen_main()
header.print( fmt_newline );
header.print( format( especifier ));
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 region AST\n");
@ -155,7 +162,11 @@ int gen_main()
if ( generate_builder ) {
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" );
}
@ -176,9 +187,10 @@ int gen_main()
Code timing = scan_file( path_base "dependencies/timing.cpp" );
header.print_fmt( roll_own_dependencies_guard_start );
header.print_fmt( "GEN_NS_BEGIN\n\n");
header.print( impl_start );
header.print( fmt_newline );
header.print_fmt( "GEN_NS_BEGIN\n");
header.print( debug );
header.print( string_ops );
header.print( printing );
@ -209,11 +221,9 @@ int gen_main()
Code parsing_interface = scan_file( path_base "components/interface.parsing.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( static_data );
header.print( fmt_newline);
header.print_fmt( "#pragma region AST\n\n" );
header.print( ast_case_macros );
@ -225,27 +235,24 @@ int gen_main()
header.print( interface );
header.print( upfront );
header.print_fmt( "\n#pragma region Parsing\n\n" );
header.print( format(parser_nspace) );
header.print( lexer );
header.print( parser );
header.print( parsing_interface );
header.print_fmt( "\n#pragma endregion Parsing\n" );
header.print_fmt("\n#pragma region Untyped\n");
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 ) {
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 ) {
header.print( scan_file( path_base "auxillary/scanner.cpp" ) );
}
header.print( fmt_newline);
header.print_fmt( "GEN_NS_END\n");
header.print_fmt( "%s\n", (char const*) implementation_guard_end );
@ -254,6 +261,6 @@ int gen_main()
header.print( pop_ignores );
header.write();
gen::deinit();
gen::deinit( & ctx);
return 0;
}

View File

@ -7,12 +7,20 @@
https://github.com/Ed94/gencpp
This is a variant intended for use with Unreal Engine 5
! ----------------------------------------------------------------------- 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 !
! ============================================================================================ !
https://github.com/Ed94/gencpp --------------------------------------------------------------.
| _____ _____ _ _ |
| / ____) / ____} | | | |
| | / ___ ___ _ __ ___ _ __ _ __ | {___ | |__ _ _, __ _, ___ __| | |
| | |{_ |/ _ \ '_ \ / __} '_ 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)
# 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 "
"(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
#if defined(GEN_IMPLEMENTATION) && ! defined(GEN_IMPLEMENTED)
# define GEN_IMPLEMENTED
)");
constexpr StrC implementation_guard_end = txt(R"(
constexpr Str implementation_guard_end = txt(R"(
#endif
#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.
// Dependencies are derived from the c-zpl library: https://github.com/zpl-c/zpl
#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
#endif
)");
@ -55,7 +55,8 @@ Code format( Code code ) {
int gen_main()
{
gen::init();
Context ctx {};
gen::init( & ctx);
Code push_ignores = scan_file( path_base "helpers/push_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 );
{
FileContents content = file_read_contents( GlobalAllocator, true, path_base "dependencies/macros.hpp" );
CodeBody ori_macros = parse_global_body( StrC { content.size, (char const*)content.data });
FileContents content = file_read_contents( ctx.Allocator_Temp, file_zero_terminate, path_base "dependencies/macros.hpp" );
CodeBody ori_macros = parse_global_body( Str { (char const*)content.data, content.size });
for (Code code = ori_macros.begin();
code != ori_macros.end();
@ -175,6 +176,7 @@ int gen_main()
{
Code header_start = scan_file( "components/header_start.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_types = scan_file( path_base "components/ast_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 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
header = Builder::open( "gen/gen.hpp" );
header.print_fmt( generation_notice );
@ -205,6 +212,8 @@ int gen_main()
header.print( fmt_newline );
header.print( format(especifier) );
header.print( fmt_newline );
header.print( format(etoktype) );
header.print( parser_types );
header.print_fmt( "#pragma endregion Types\n\n" );
header.print_fmt( "#pragma region AST\n" );
@ -223,14 +232,14 @@ int gen_main()
header.print_fmt( "#pragma endregion Inlines\n" );
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.write();
}
// 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 ast_case_macros = scan_file( path_base "components/ast_case_macros.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 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
src = Builder::open( "gen/gen.cpp" );
src.print_fmt( generation_notice );
@ -268,7 +272,6 @@ int gen_main()
src.print( interface );
src.print( upfront );
src.print_fmt( "\n#pragma region Parsing\n\n" );
src.print( format(etoktype) );
src.print( lexer );
src.print( parser );
src.print( parsing_interface );
@ -294,7 +297,7 @@ int gen_main()
header.print( def_include( txt("gen.hpp") ));
header.print_fmt( "\nGEN_NS_BEGIN\n" );
header.print( builder );
header.print_fmt( "GEN_NS_END\n" );
header.print_fmt( "\nGEN_NS_END\n" );
header.print( fmt_newline );
header.print( pop_ignores );
header.write();
@ -333,7 +336,7 @@ int gen_main()
header.print_fmt( "\nGEN_NS_BEGIN\n" );
header.print( parsing );
header.print( scanner );
header.print_fmt( "GEN_NS_END\n" );
header.print_fmt( "\nGEN_NS_END\n" );
header.print( fmt_newline );
header.print( pop_ignores );
header.write();
@ -353,7 +356,7 @@ int gen_main()
src.print_fmt( "\nGEN_NS_BEGIN\n" );
src.print( parsing );
// src.print( scanner );
src.print_fmt( "GEN_NS_END\n" );
src.print_fmt( "\nGEN_NS_END\n" );
src.print( fmt_newline );
src.print( pop_ignores );
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">
<s:String x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=53AF600D_002DC09C_002D4F39_002D83E0_002DE022AA9479F2_002Fd_003Athirdparty_002Ff_003Azpl_002Eh/@EntryIndexedValue">ForceIncluded</s:String>
<s:String x:Key="/Default/CodeInspection/Highlighting/SweaWarningsMode/@EntryValue">ShowAndRun</s:String></wpf:ResourceDictionary>
<s:StrBuilder x:Key="/Default/CodeInspection/ExcludedFiles/FilesAndFoldersToSkip2/=53AF600D_002DC09C_002D4F39_002D83E0_002DE022AA9479F2_002Fd_003Athirdparty_002Ff_003Azpl_002Eh/@EntryIndexedValue">ForceIncluded</s:StrBuilder>
<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
---
# AttributeMacros: [
# ]
AttributeMacros: [
GEN_API
]
StatementMacros: [
GEN_NS_BEGIN,
GEN_NS_END,
@ -15,6 +16,8 @@ StatementMacros: [
Macros:
- enum_underlying(type)=type
- gen_enum_underlying(type)=type
# WhitespaceSensitiveMacros: [
# ]
TypenameMacros: [Array, Hashtable]
SkipMacroDefinitionBody: false

View File

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

View File

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

View File

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