From 3a55af9ce4799a16d50913e0faf7e7ac423ab63f Mon Sep 17 00:00:00 2001 From: Ed_ Date: Wed, 4 Dec 2024 11:01:53 -0500 Subject: [PATCH] WIP(broken): Converting base library to use c-linkage symbols only --- .vscode/settings.json | 4 +- gen_c_library/c_library.cpp | 77 ++- gen_c_library/components/misc.hpp | 121 ++++- project/auxillary/builder.cpp | 10 +- project/auxillary/scanner.hpp | 14 +- project/bootstrap.cpp | 24 +- project/components/ast.cpp | 338 +++++++------- project/components/code_serialization.cpp | 540 +++++++++++----------- project/components/inlines.hpp | 2 +- project/components/interface.cpp | 66 +-- project/components/interface.untyped.cpp | 6 +- project/components/interface.upfront.cpp | 14 +- project/components/lexer.cpp | 40 +- project/components/parser.cpp | 124 ++--- project/dependencies/containers.hpp | 198 ++++---- project/dependencies/debug.hpp | 2 + project/dependencies/filesystem.cpp | 18 +- project/dependencies/filesystem.hpp | 2 +- project/dependencies/hashing.hpp | 4 + project/dependencies/macros.hpp | 23 +- project/dependencies/memory.cpp | 2 +- project/dependencies/memory.hpp | 122 ++--- project/dependencies/parsing.cpp | 46 +- project/dependencies/platform.hpp | 28 +- project/dependencies/printing.cpp | 2 +- project/dependencies/printing.hpp | 4 + project/dependencies/string_ops.cpp | 4 +- project/dependencies/string_ops.hpp | 14 +- project/dependencies/strings.hpp | 436 +++++++++-------- project/helpers/helper.hpp | 52 ++- scripts/build.ci.ps1 | 8 +- 31 files changed, 1283 insertions(+), 1062 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 3a32ceb..4914447 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -40,7 +40,9 @@ "*.m": "cpp", "atomic": "cpp", "gen.h": "c", - "string_ops.hpp": "c" + "string_ops.hpp": "c", + "assert.h": "c", + "intrin.h": "c" }, "C_Cpp.intelliSenseEngineFallback": "disabled", "mesonbuild.configureOnOpen": true, diff --git a/gen_c_library/c_library.cpp b/gen_c_library/c_library.cpp index 99363a0..4ff9726 100644 --- a/gen_c_library/c_library.cpp +++ b/gen_c_library/c_library.cpp @@ -127,8 +127,25 @@ int gen_main() header.print( basic_types ); header.print( debug ); + Array(StrC) to_rename = array_init_reserve(StrC, GlobalAllocator, 128); + to_rename.append(txt("align_forward")); + to_rename.append(txt("pointer_add")); + to_rename.append(txt("allocator_info")); + to_rename.append(txt("size_remaining")); + to_rename.append(txt("free")); + // to_rename.append(txt("clear")); + // to_rename.append(txt("init_sub")); + // to_rename.append(txt("check")); + + NeedsSelectors needs_selectors; + needs_selectors.table = hashtable_init_reserve(Array(CodeFn), GlobalAllocator, 1024); + for ( StrC id : to_rename ) { + needs_selectors.set(id, array_init_reserve(CodeFn, GlobalAllocator, 128)); + } + CodeBody parsed_memory = parse_file( project_dir "dependencies/memory.hpp" ); CodeBody memory = def_body(CT_Global_Body); + for ( Code entry = parsed_memory.begin(); entry != parsed_memory.end(); ++ entry ) { switch (entry->Type) @@ -145,11 +162,10 @@ int gen_main() case CT_Function_Fwd: { CodeFn fn = cast(CodeFn, entry); - if ( fn->Name.is_equal(txt("free")) ) - { - fn->Name = get_cached_string(txt("gen_free_ptr")); - } - memory.append(entry); + // for ( StrC id : to_rename ) if (fn->Name.is_equal(id)) { + // rename_function_to_unique_symbol(fn); + // } + memory.append(fn); } break; case CT_Function: @@ -160,11 +176,11 @@ int gen_main() log_fmt("Found constexpr: %S\n", entry.to_string()); fn->Specs.append(Spec_Inline); } - if ( fn->Name.is_equal(txt("free")) ) - { - fn->Name = get_cached_string(txt("gen_free_ptr")); - } - memory.append(entry); + // for ( StrC id : to_rename ) if (fn->Name.is_equal(id)) { + // Array(CodeFn) list = * needs_selectors.get(id); + // list.append(rename_function_to_unique_symbol(fn)); + // } + memory.append(fn); } break; case CT_Template: @@ -213,6 +229,9 @@ int gen_main() b32 found = ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_MEMBER_FEATURES"), entry, parsed_memory ); if (found) break; + found = ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_REFERENCES"), entry, parsed_memory ); + if (found) break; + memory.append(entry); } break; @@ -226,6 +245,12 @@ int gen_main() break; case CT_Preprocess_Pragma: { + CodePragma pragma = cast(CodePragma, entry); + // if (pragma->Content.starts_with(txt("region Memory"))) { + // memory.append(generic_test); + // break; + // } + b32 found = swap_pragma_region_implementation( txt("FixedArena"), gen_fixed_arenas, entry, memory); if (found) break; @@ -238,10 +263,15 @@ int gen_main() break; } } + + // CodeBody selectors = generate_generic_selectors(needs_selectors); + // memory.append_at(selectors, 0) + // memory.append(fmt_newline); + header.print( dump_to_scratch_and_retireve(memory) ); Code string_ops = scan_file( project_dir "dependencies/string_ops.hpp" ); - header.print( string_ops ); + // header.print( string_ops ); CodeBody printing_parsed = parse_file( project_dir "dependencies/printing.hpp" ); CodeBody printing = def_body(CT_Global_Body); @@ -273,7 +303,7 @@ int gen_main() break; } } - header.print(dump_to_scratch_and_retireve(printing)); + // header.print(dump_to_scratch_and_retireve(printing)); CodeBody containers = def_body(CT_Global_Body); { @@ -285,10 +315,10 @@ int gen_main() containers.append( def_pragma(code(endregion Containers))); } header.print(fmt_newline); - header.print(dump_to_scratch_and_retireve(containers)); + // header.print(dump_to_scratch_and_retireve(containers)); Code hashing = scan_file( project_dir "dependencies/hashing.hpp" ); - header.print( hashing ); + // header.print( hashing ); CodeBody parsed_strings = parse_file( project_dir "dependencies/strings.hpp" ); CodeBody strings = def_body(CT_Global_Body); @@ -298,7 +328,22 @@ int gen_main() { case CT_Preprocess_If: { - ignore_preprocess_cond_block(txt("! GEN_COMPILER_C"), entry, parsed_strings); + CodePreprocessCond cond = cast(CodePreprocessCond, entry); + if (cond->Content.starts_with(txt("GEN_COMPILER_C || ! GEN_SUPPORT_CPP_MEMBER_FEATURES"))) + { + ++ entry; + strings.append(entry); // typedef + strings.append(fmt_newline); + + for (; entry != end(parsed_strings) && entry->Type != CT_Preprocess_EndIf; ++ entry) {} + ++ entry; + break; + } + + bool found = ignore_preprocess_cond_block(txt("! GEN_COMPILER_C"), entry, parsed_strings); + if (found) break; + + found = ignore_preprocess_cond_block(txt("GEN_SUPPORT_CPP_REFERENCES"), entry, parsed_strings); } break; @@ -350,7 +395,7 @@ int gen_main() break; } } - header.print(dump_to_scratch_and_retireve(strings)); + // header.print(dump_to_scratch_and_retireve(strings)); Code filesystem = scan_file( project_dir "dependencies/filesystem.hpp" ); Code timing = scan_file( project_dir "dependencies/timing.hpp" ); diff --git a/gen_c_library/components/misc.hpp b/gen_c_library/components/misc.hpp index 933e7ab..2a707f0 100644 --- a/gen_c_library/components/misc.hpp +++ b/gen_c_library/components/misc.hpp @@ -5,22 +5,67 @@ using SwapContentProc = CodeBody(void); + +struct NeedsSelectors { + HashTable(Array(CodeFn)) table; + + void set(StrC sig, Array(CodeFn) list) { + u32 key = crc32(sig.Ptr, sig.Len); + table.set(key, list); + } + Array(CodeFn)* get(StrC sig) { + u32 key = crc32(sig.Ptr, sig.Len); + return table.get(key); + } +}; +CodeBody generate_generic_selectors(Array(Array(CodeFn)) listing) +{ + constexpr char const* tmpl_selector = +R"( #define () \ +_Generic(( +)) +); +)"; + + CodeBody result = def_body(CT_Global_Body); + for (Array(CodeFn) functions : listing) + { + + } + return result; +} + b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& body ) { b32 found = false; CodePreprocessCond cond = cast(CodePreprocessCond, entry_iter); if ( cond->Content.contains(cond_sig) ) { - log_fmt("Preprocess cond found: %S\n", cond->Content); + log_fmt("Preprocess cond found: %SC\n", cond->Content); found = true; s32 depth = 1; - ++ entry_iter; for(b32 continue_for = true; continue_for && entry_iter != body.end(); ) switch + ++ entry_iter; + for(b32 continue_for = true; continue_for && entry_iter != body.end(); ) switch (entry_iter->Type) { case CT_Preprocess_If: case CT_Preprocess_IfDef: case CT_Preprocess_IfNotDef: - depth ++; + ++ depth; + ++ entry_iter; + break; + + case CT_Preprocess_Else: + ++ entry_iter; + for(; continue_for && entry_iter != body.end(); ++ entry_iter) + { + if (entry_iter->Type == CT_Preprocess_EndIf) + { + continue_for = false; + break; + } + body.append(entry_iter); + } break; case CT_Preprocess_EndIf: @@ -30,6 +75,7 @@ b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& bod continue_for = false; break; } + ++ entry_iter; } break; default: @@ -41,6 +87,72 @@ b32 ignore_preprocess_cond_block( StrC cond_sig, Code& entry_iter, CodeBody& bod return found; } +CodeFn rename_function_to_unique_symbol(CodeFn fn, StrC optional_prefix = txt("")) +{ + // Get basic components for the name + StrC old_name = fn->Name; + String new_name; + + // Add prefix if provided + if (optional_prefix.Len) + new_name = string_fmt_buf(GlobalAllocator, "%SC_%SC_", optional_prefix, old_name); + else + new_name = string_fmt_buf(GlobalAllocator, "%SC_", old_name); + + // Add return type to the signature + if (fn->ReturnType) + new_name.append_fmt("_%SC", fn->ReturnType->Name); + + // Add parameter types to create a unique signature + bool first_param = true; + for (CodeParam param = fn->Params; param.ast; param = param->Next) + { + if (param->ValueType) + { + // Add separator for readability + if (first_param) + { + new_name.append("_P_"); + first_param = false; + } + else + new_name.append("_"); + + // Add parameter type, handle any specifiers + if (param->ValueType->Specs && param->ValueType->Specs->NumEntries > 0) + { + // Add specifiers (const, volatile, etc) + for (Specifier spec : param->ValueType->Specs) + { + if (spec == Spec_Ptr) { + new_name.append("ptr_"); + continue; + } + + new_name.append_fmt("%SC_", to_str(spec)); + } + } + + new_name.append_fmt("%SC", param->ValueType->Name); + } + } + + // Handle function specifiers if present + if (fn->Specs && fn->Specs->NumEntries > 0) + { + new_name.append("_S_"); + for (Specifier* spec = begin(fn->Specs); + spec != end(fn->Specs); + ++spec) + { + new_name.append_fmt("%SC_", to_str(*spec)); + } + } + + fn->Name = new_name; + return fn; +} + bool swap_pragma_region_implementation( StrC region_name, SwapContentProc* swap_content, Code& entry_iter, CodeBody& body ) { bool found = false; @@ -54,7 +166,8 @@ bool swap_pragma_region_implementation( StrC region_name, SwapContentProc* swap_ // body.append(possible_region); body.append(swap_content()); - ++ entry_iter; for(b32 continue_for = true; continue_for; ++entry_iter) switch + ++ entry_iter; + for(b32 continue_for = true; continue_for; ++entry_iter) switch (entry_iter->Type) { case CT_Preprocess_Pragma: { diff --git a/project/auxillary/builder.cpp b/project/auxillary/builder.cpp index f85cef0..2af0c5c 100644 --- a/project/auxillary/builder.cpp +++ b/project/auxillary/builder.cpp @@ -21,7 +21,7 @@ Builder Builder::open( char const* path ) void Builder::pad_lines( s32 num ) { - append( & Buffer, "\n" ); + string_append_strc( & Buffer, txt("\n") ); } void Builder::print( Code code ) @@ -29,7 +29,7 @@ void Builder::print( Code code ) String str = to_string(code); // const ssize len = str.length(); // log_fmt( "%s - print: %.*s\n", File.filename, len > 80 ? 80 : len, str.Data ); - append( & Buffer, str ); + string_append_string( & Buffer, str ); } void Builder::print_fmt( char const* fmt, ... ) @@ -43,17 +43,17 @@ void Builder::print_fmt( char const* fmt, ... ) va_end( va ); // log_fmt( "$%s - print_fmt: %.*s\n", File.filename, res > 80 ? 80 : res, buf ); - append( (String*) & Buffer, (char const*)buf, res ); + string_append_c_str_len( (String*) & Buffer, (char const*)buf, res ); } void Builder::write() { - b32 result = file_write( & File, Buffer, length(Buffer) ); + b32 result = file_write( & File, Buffer, string_length(Buffer) ); if ( result == false ) log_failure("gen::File::write - Failed to write to file: %s\n", file_name( & File ) ); log_fmt( "Generated: %s\n", File.filename ); file_close( & File ); - free(& Buffer); + string_free(& Buffer); } diff --git a/project/auxillary/scanner.hpp b/project/auxillary/scanner.hpp index 8ae44fa..f1aaeb6 100644 --- a/project/auxillary/scanner.hpp +++ b/project/auxillary/scanner.hpp @@ -25,7 +25,7 @@ Code scan_file( char const* path ) String str = string_make_reserve( GlobalAllocator, fsize ); file_read( & file, str, fsize ); - get_header(str)->Length = fsize; + string_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. @@ -52,7 +52,7 @@ Code scan_file( char const* path ) if ( ! found_directive ) { - if ( left && str_compare( scanner, directive_start.Ptr, directive_start.Len ) == matched ) + if ( left && str_compare_len( scanner, directive_start.Ptr, directive_start.Len ) == matched ) { scanner += directive_start.Len; left -= directive_start.Len; @@ -60,7 +60,7 @@ Code scan_file( char const* path ) while ( left && char_is_space( current ) ) move_fwd(); - if ( left && str_compare( scanner, def_intellisense.Ptr, def_intellisense.Len ) == matched ) + if ( left && str_compare_len( scanner, def_intellisense.Ptr, def_intellisense.Len ) == matched ) { scanner += def_intellisense.Len; left -= def_intellisense.Len; @@ -80,7 +80,7 @@ Code scan_file( char const* path ) continue; } - if ( left && str_compare( scanner, directive_end.Ptr, directive_end.Len ) == matched ) + if ( left && str_compare_len( scanner, directive_end.Ptr, directive_end.Len ) == matched ) { scanner += directive_end.Len; left -= directive_end.Len; @@ -97,12 +97,12 @@ Code scan_file( char const* path ) if ( (scanner + 2) >= ( (char const*) str + fsize ) ) { mem_move( str, scanner, left ); - get_header(str)->Length = left; + string_get_header(str)->Length = left; break; } mem_move( str, scanner, left ); - get_header(str)->Length = left; + string_get_header(str)->Length = left; break; } @@ -116,7 +116,7 @@ Code scan_file( char const* path ) } file_close( & file ); - return untyped_str( to_strc(str) ); + return untyped_str( string_to_strc(str) ); } #if 0 diff --git a/project/bootstrap.cpp b/project/bootstrap.cpp index 12ee7bb..7c24fe7 100644 --- a/project/bootstrap.cpp +++ b/project/bootstrap.cpp @@ -26,20 +26,20 @@ constexpr char const* generation_notice = void format_file( char const* path ) { - String resolved_path = string_make(GlobalAllocator, to_str(path)); + String resolved_path = string_make_strc(GlobalAllocator, to_strc_from_c_str(path)); - String style_arg = string_make(GlobalAllocator, txt("-style=file:")); - append( & style_arg, "../scripts/.clang-format "); + String style_arg = string_make_strc(GlobalAllocator, txt("-style=file:")); + string_append_strc( & style_arg, txt("../scripts/.clang-format ")); // Need to execute clang format on the generated file to get it to match the original. - #define clang_format "clang-format " - #define cf_format_inplace "-i " - #define cf_verbose "-verbose " - String command = string_make( GlobalAllocator, clang_format ); - append( & command, cf_format_inplace ); - append( & command, cf_verbose ); - append( & command, style_arg ); - append( & command, resolved_path ); + #define clang_format txt("clang-format ") + #define cf_format_inplace txt("-i ") + #define 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 ); log_fmt("\tRunning clang-format on file:\n"); system( command ); log_fmt("\tclang-format finished reformatting.\n"); @@ -145,7 +145,7 @@ int gen_main() def_include(txt("components/types.hpp")), preprocess_endif, fmt_newline, - untyped_str( to_str(generation_notice) ) + untyped_str( strc_to_str(generation_notice) ) )); // gen.hpp diff --git a/project/components/ast.cpp b/project/components/ast.cpp index 681c997..ca3d40f 100644 --- a/project/components/ast.cpp +++ b/project/components/ast.cpp @@ -14,13 +14,13 @@ char const* debug_str(Code self) String* result = & result_stack; if ( self->Parent ) - append_fmt( result, "\n\tParent : %S %S", type_str(self->Parent), self->Name ? self->Name : "" ); + string_append_fmt( result, "\n\tParent : %S %S", type_str(self->Parent), self->Name ? self->Name : "" ); else - append_fmt( result, "\n\tParent : %S", "Null" ); + string_append_fmt( result, "\n\tParent : %S", "Null" ); - append_fmt( result, "\n\tName : %S", self->Name ? self->Name : "Null" ); - append_fmt( result, "\n\tType : %S", type_str(self) ); - append_fmt( result, "\n\tModule Flags : %S", to_str( self->ModuleFlags ) ); + string_append_fmt( result, "\n\tName : %S", self->Name ? self->Name : "Null" ); + string_append_fmt( result, "\n\tType : %S", type_str(self) ); + string_append_fmt( result, "\n\tModule Flags : %S", to_str( self->ModuleFlags ) ); switch ( self->Type ) { @@ -30,9 +30,9 @@ char const* debug_str(Code self) case CT_Access_Protected: case CT_Access_Public: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); break; case CT_Untyped: @@ -48,74 +48,74 @@ char const* debug_str(Code self) case CT_Preprocess_IfDef: case CT_Preprocess_IfNotDef: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tContent: %S", self->Content ); + string_append_fmt( result, "\n\tContent: %S", self->Content ); break; case CT_Class: case CT_Struct: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); - append_fmt( result, "\n\tParentAccess: %s", self->ParentType ? to_str( self->ParentAccess ) : "No Parent" ); - append_fmt( result, "\n\tParentType : %s", self->ParentType ? type_str(self->ParentType) : "Null" ); - append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); + string_append_fmt( result, "\n\tParentAccess: %s", self->ParentType ? to_str( self->ParentAccess ) : "No Parent" ); + string_append_fmt( result, "\n\tParentType : %s", self->ParentType ? type_str(self->ParentType) : "Null" ); + string_append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); break; case CT_Class_Fwd: case CT_Struct_Fwd: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); - append_fmt( result, "\n\tParentAccess: %s", self->ParentType ? to_str( self->ParentAccess ) : "No Parent" ); - append_fmt( result, "\n\tParentType : %s", self->ParentType ? type_str(self->ParentType) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); + string_append_fmt( result, "\n\tParentAccess: %s", self->ParentType ? to_str( self->ParentAccess ) : "No Parent" ); + string_append_fmt( result, "\n\tParentType : %s", self->ParentType ? type_str(self->ParentType) : "Null" ); break; case CT_Constructor: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); - append_fmt( result, "\n\tInitializerList: %S", self->InitializerList ? to_string(self->InitializerList) : "Null" ); - append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); - append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); + string_append_fmt( result, "\n\tInitializerList: %S", self->InitializerList ? to_string(self->InitializerList) : "Null" ); + string_append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); + string_append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); break; case CT_Constructor_Fwd: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); - append_fmt( result, "\n\tInitializerList: %S", self->InitializerList ? to_string(self->InitializerList) : "Null" ); - append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); + string_append_fmt( result, "\n\tInitializerList: %S", self->InitializerList ? to_string(self->InitializerList) : "Null" ); + string_append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); break; case CT_Destructor: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); - append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); + string_append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); break; case CT_Destructor_Fwd: @@ -124,208 +124,208 @@ char const* debug_str(Code self) case CT_Enum: case CT_Enum_Class: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); - append_fmt( result, "\n\tUnderlying Type : %S", self->UnderlyingType ? to_string(self->UnderlyingType) : "Null" ); - append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); + string_append_fmt( result, "\n\tUnderlying Type : %S", self->UnderlyingType ? to_string(self->UnderlyingType) : "Null" ); + string_append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); break; case CT_Enum_Fwd: case CT_Enum_Class_Fwd: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); - append_fmt( result, "\n\tUnderlying Type : %S", self->UnderlyingType ? to_string(self->UnderlyingType) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); + string_append_fmt( result, "\n\tUnderlying Type : %S", self->UnderlyingType ? to_string(self->UnderlyingType) : "Null" ); break; case CT_Extern_Linkage: case CT_Namespace: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tBody: %S", self->Body ? debug_str(self->Body) : "Null" ); + string_append_fmt( result, "\n\tBody: %S", self->Body ? debug_str(self->Body) : "Null" ); break; case CT_Friend: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tDeclaration: %S", self->Declaration ? to_string(self->Declaration) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tDeclaration: %S", self->Declaration ? to_string(self->Declaration) : "Null" ); break; case CT_Function: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tAttributes: %S", self->Attributes ? to_string(self->Attributes) : "Null" ); - append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); - append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? to_string(self->ReturnType) : "Null" ); - append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); - append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? to_string(self->Attributes) : "Null" ); + string_append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); + string_append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? to_string(self->ReturnType) : "Null" ); + string_append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); + string_append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); break; case CT_Function_Fwd: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tAttributes: %S", self->Attributes ? to_string(self->Attributes) : "Null" ); - append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); - append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? to_string(self->ReturnType) : "Null" ); - append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? to_string(self->Attributes) : "Null" ); + string_append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); + string_append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? to_string(self->ReturnType) : "Null" ); + string_append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); break; case CT_Module: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); break; case CT_Operator: case CT_Operator_Member: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tAttributes: %S", self->Attributes ? to_string(self->Attributes) : "Null" ); - append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); - append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? to_string(self->ReturnType) : "Null" ); - append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); - append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); - append_fmt( result, "\n\tOp : %S", to_str( self->Op ) ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? to_string(self->Attributes) : "Null" ); + string_append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); + string_append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? to_string(self->ReturnType) : "Null" ); + string_append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); + string_append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); + string_append_fmt( result, "\n\tOp : %S", to_str( self->Op ) ); break; case CT_Operator_Fwd: case CT_Operator_Member_Fwd: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tAttributes: %S", self->Attributes ? to_string(self->Attributes) : "Null" ); - append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); - append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? to_string(self->ReturnType) : "Null" ); - append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); - append_fmt( result, "\n\tOp : %S", to_str( self->Op ) ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? to_string(self->Attributes) : "Null" ); + string_append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); + string_append_fmt( result, "\n\tReturnType: %S", self->ReturnType ? to_string(self->ReturnType) : "Null" ); + string_append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); + string_append_fmt( result, "\n\tOp : %S", to_str( self->Op ) ); break; case CT_Operator_Cast: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); - append_fmt( result, "\n\tValueType : %S", self->ValueType ? to_string(self->ValueType) : "Null" ); - append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); + string_append_fmt( result, "\n\tValueType : %S", self->ValueType ? to_string(self->ValueType) : "Null" ); + string_append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); break; case CT_Operator_Cast_Fwd: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); - append_fmt( result, "\n\tValueType : %S", self->ValueType ? to_string(self->ValueType) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); + string_append_fmt( result, "\n\tValueType : %S", self->ValueType ? to_string(self->ValueType) : "Null" ); break; case CT_Parameters: - append_fmt( result, "\n\tNumEntries: %d", self->NumEntries ); - append_fmt( result, "\n\tLast : %S", self->Last->Name ); - append_fmt( result, "\n\tNext : %S", self->Next->Name ); - append_fmt( result, "\n\tValueType : %S", self->ValueType ? to_string(self->ValueType) : "Null" ); - append_fmt( result, "\n\tValue : %S", self->Value ? to_string(self->Value) : "Null" ); + string_append_fmt( result, "\n\tNumEntries: %d", self->NumEntries ); + string_append_fmt( result, "\n\tLast : %S", self->Last->Name ); + string_append_fmt( result, "\n\tNext : %S", self->Next->Name ); + string_append_fmt( result, "\n\tValueType : %S", self->ValueType ? to_string(self->ValueType) : "Null" ); + string_append_fmt( result, "\n\tValue : %S", self->Value ? to_string(self->Value) : "Null" ); break; case CT_Specifiers: { - append_fmt( result, "\n\tNumEntries: %d", self->NumEntries ); - GEN_NS append( result, "\n\tArrSpecs: " ); + string_append_fmt( result, "\n\tNumEntries: %d", self->NumEntries ); + string_append_c_str( result, "\n\tArrSpecs: " ); s32 idx = 0; s32 left = self->NumEntries; while ( left-- ) { StrC spec = to_str( self->ArrSpecs[idx] ); - append_fmt( result, "%.*s, ", spec.Len, spec.Ptr ); + string_append_fmt( result, "%.*s, ", spec.Len, spec.Ptr ); idx++; } - append_fmt( result, "\n\tNextSpecs: %S", self->NextSpecs ? debug_str(self->NextSpecs) : "Null" ); + string_append_fmt( result, "\n\tNextSpecs: %S", self->NextSpecs ? debug_str(self->NextSpecs) : "Null" ); } break; case CT_Template: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); - append_fmt( result, "\n\tDeclaration: %S", self->Declaration ? to_string(self->Declaration) : "Null" ); + string_append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); + string_append_fmt( result, "\n\tDeclaration: %S", self->Declaration ? to_string(self->Declaration) : "Null" ); break; case CT_Typedef: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tUnderlyingType: %S", self->UnderlyingType ? to_string(self->UnderlyingType) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tUnderlyingType: %S", self->UnderlyingType ? to_string(self->UnderlyingType) : "Null" ); break; case CT_Typename: - append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); - append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); - append_fmt( result, "\n\tReturnType : %S", self->ReturnType ? to_string(self->ReturnType) : "Null" ); - append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); - append_fmt( result, "\n\tArrExpr : %S", self->ArrExpr ? to_string(self->ArrExpr) : "Null" ); + string_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); + string_append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); + string_append_fmt( result, "\n\tReturnType : %S", self->ReturnType ? to_string(self->ReturnType) : "Null" ); + string_append_fmt( result, "\n\tParams : %S", self->Params ? to_string(self->Params) : "Null" ); + string_append_fmt( result, "\n\tArrExpr : %S", self->ArrExpr ? to_string(self->ArrExpr) : "Null" ); break; case CT_Union: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tAttributes: %S", self->Attributes ? to_string(self->Attributes) : "Null" ); - append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); + string_append_fmt( result, "\n\tAttributes: %S", self->Attributes ? to_string(self->Attributes) : "Null" ); + string_append_fmt( result, "\n\tBody : %S", self->Body ? debug_str(self->Body) : "Null" ); break; case CT_Using: if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); - append_fmt( result, "\n\tUnderlyingType: %S", self->UnderlyingType ? to_string(self->UnderlyingType) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); + string_append_fmt( result, "\n\tUnderlyingType: %S", self->UnderlyingType ? to_string(self->UnderlyingType) : "Null" ); break; case CT_Variable: @@ -333,25 +333,25 @@ char const* debug_str(Code self) if ( self->Parent && self->Parent->Type == CT_Variable ) { // Its a NextVar - append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); - append_fmt( result, "\n\tValue : %S", self->Value ? to_string(self->Value) : "Null" ); - append_fmt( result, "\n\tBitfieldSize: %S", self->BitfieldSize ? to_string(self->BitfieldSize) : "Null" ); - append_fmt( result, "\n\tNextVar : %S", self->NextVar ? debug_str(self->NextVar) : "Null" ); + string_append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); + string_append_fmt( result, "\n\tValue : %S", self->Value ? to_string(self->Value) : "Null" ); + string_append_fmt( result, "\n\tBitfieldSize: %S", self->BitfieldSize ? to_string(self->BitfieldSize) : "Null" ); + string_append_fmt( result, "\n\tNextVar : %S", self->NextVar ? debug_str(self->NextVar) : "Null" ); break; } if ( self->Prev ) - append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tPrev: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); if ( self->Next ) - append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); + string_append_fmt( result, "\n\tNext: %S %S", type_str(self->Prev), self->Prev->Name ? self->Prev->Name : "Null" ); - append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); - append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); - append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); - append_fmt( result, "\n\tValueType : %S", self->ValueType ? to_string(self->ValueType) : "Null" ); - append_fmt( result, "\n\tBitfieldSize: %S", self->BitfieldSize ? to_string(self->BitfieldSize) : "Null" ); - append_fmt( result, "\n\tValue : %S", self->Value ? to_string(self->Value) : "Null" ); - append_fmt( result, "\n\tNextVar : %S", self->NextVar ? debug_str(self->NextVar) : "Null" ); + string_append_fmt( result, "\n\tInlineCmt : %S", self->InlineCmt ? self->InlineCmt->Content : "Null" ); + string_append_fmt( result, "\n\tAttributes : %S", self->Attributes ? to_string(self->Attributes) : "Null" ); + string_append_fmt( result, "\n\tSpecs : %S", self->Specs ? to_string(self->Specs) : "Null" ); + string_append_fmt( result, "\n\tValueType : %S", self->ValueType ? to_string(self->ValueType) : "Null" ); + string_append_fmt( result, "\n\tBitfieldSize: %S", self->BitfieldSize ? to_string(self->BitfieldSize) : "Null" ); + string_append_fmt( result, "\n\tValue : %S", self->Value ? to_string(self->Value) : "Null" ); + string_append_fmt( result, "\n\tNextVar : %S", self->NextVar ? debug_str(self->NextVar) : "Null" ); break; } @@ -370,7 +370,7 @@ Code duplicate(Code self) String to_string(Code self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_strc( GlobalAllocator, txt("") ); GEN_NS to_string( self, & result ); return result; } @@ -392,20 +392,20 @@ void to_string( Code self, String* result ) break; case CT_NewLine: - append( result,"\n"); + string_append_strc( result, txt("\n")); break; case CT_Untyped: case CT_Execution: case CT_Comment: case CT_PlatformAttributes: - append( result, self->Content ); + string_append_strc( result, self->Content ); break; case CT_Access_Private: case CT_Access_Protected: case CT_Access_Public: - append( result, self->Name ); + string_append_strc( result, self->Name ); break; case CT_Class: @@ -640,23 +640,23 @@ bool is_equal( Code self, Code other ) return false; \ } - #define check_member_content( content ) \ - if ( self->content != other->content ) \ - { \ - log_fmt("\nAST::is_equal: Member content - "#content " failed\n" \ - "AST : %S\n" \ - "Other: %S\n" \ - , debug_str(self) \ - ,debug_str(other) \ - ); \ - \ - log_fmt("Content cannot be trusted to be unique with this check " \ - "so it must be verified by eye for now\n" \ - "AST Content:\n%S\n" \ - "Other Content:\n%S\n" \ - , visualize_whitespace(self->content, GlobalAllocator) \ - , visualize_whitespace(other->content, GlobalAllocator) \ - ); \ + #define check_member_content( content ) \ + if ( self->content != other->content ) \ + { \ + log_fmt("\nAST::is_equal: Member content - "#content " failed\n" \ + "AST : %S\n" \ + "Other: %S\n" \ + , debug_str(self) \ + , debug_str(other) \ + ); \ + \ + log_fmt("Content cannot be trusted to be unique with this check " \ + "so it must be verified by eye for now\n" \ + "AST Content:\n%S\n" \ + "Other Content:\n%S\n" \ + , strc_visualize_whitespace(self->content, GlobalAllocator) \ + , strc_visualize_whitespace(other->content, GlobalAllocator) \ + ); \ } #define check_member_ast( ast ) \ diff --git a/project/components/code_serialization.cpp b/project/components/code_serialization.cpp index 47436ed..576df34 100644 --- a/project/components/code_serialization.cpp +++ b/project/components/code_serialization.cpp @@ -4,18 +4,18 @@ #endif String to_string(CodeAttributes attributes) { - return {(char*) duplicate( attributes->Content, GlobalAllocator ).Ptr}; + return {(char*) strc_duplicate( attributes->Content, GlobalAllocator ).Ptr}; } String to_string(CodeBody body) { GEN_ASSERT(body.ast != nullptr); - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 128 ); switch ( body.ast->Type ) { case CT_Untyped: case CT_Execution: - append( & result, rcast(AST*, body.ast)->Content ); + string_append_strc( & result, rcast(AST*, body.ast)->Content ); break; case CT_Enum_Body: @@ -44,7 +44,7 @@ void to_string( CodeBody body, String* result ) s32 left = body.ast->NumEntries; while ( left -- ) { - append_fmt( result, "%S", GEN_NS to_string(curr) ); + string_append_fmt( result, "%S", GEN_NS to_string(curr) ); ++curr; } } @@ -53,27 +53,27 @@ void to_string_export( CodeBody body, String* result ) { GEN_ASSERT(body.ast != nullptr); GEN_ASSERT(result != nullptr); - append_fmt( result, "export\n{\n" ); + string_append_fmt( result, "export\n{\n" ); Code curr = body; s32 left = body.ast->NumEntries; while ( left-- ) { - append_fmt( result, "%S", to_string(curr) ); + string_append_fmt( result, "%S", to_string(curr) ); ++curr; } - append_fmt( result, "};\n" ); + string_append_fmt( result, "};\n" ); } String to_string(CodeComment comment) { - return {(char*) duplicate( comment->Content, GlobalAllocator ).Ptr}; + return {(char*) strc_duplicate( comment->Content, GlobalAllocator ).Ptr}; } String to_string(CodeConstructor self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 128 ); switch (self->Type) { case CT_Constructor: @@ -90,53 +90,53 @@ void to_string_def(CodeConstructor self, String* result ) { Code ClassStructParent = self->Parent->Parent; if (ClassStructParent) { - append( result, ClassStructParent->Name ); + string_append_strc( result, ClassStructParent->Name ); } else { - append( result, self->Name ); + string_append_strc( result, self->Name ); } if ( self->Params ) - append_fmt( result, "( %S )", to_string(self->Params) ); + string_append_fmt( result, "( %S )", to_string(self->Params) ); else - append( result, "()" ); + string_append_strc( result, txt("()") ); if ( self->InitializerList ) - append_fmt( result, " : %S", to_string(self->InitializerList) ); + string_append_fmt( result, " : %S", to_string(self->InitializerList) ); if ( self->InlineCmt ) - append_fmt( result, " // %SC", self->InlineCmt->Content ); + string_append_fmt( result, " // %SC", self->InlineCmt->Content ); - append_fmt( result, "\n{\n%S\n}\n", to_string(self->Body) ); + string_append_fmt( result, "\n{\n%S\n}\n", to_string(self->Body) ); } void to_string_fwd(CodeConstructor self, String* result ) { Code ClassStructParent = self->Parent->Parent; if (ClassStructParent) { - append( result, ClassStructParent->Name ); + string_append_strc( result, ClassStructParent->Name ); } else { - append( result, self->Name ); + string_append_strc( result, self->Name ); } if ( self->Params ) - append_fmt( result, "( %S )", to_string(self->Params) ); + string_append_fmt( result, "( %S )", to_string(self->Params) ); else - append_fmt( result, "()"); + string_append_fmt( result, "()"); if (self->Body) - append_fmt( result, " = %S", to_string(self->Body) ); + string_append_fmt( result, " = %S", to_string(self->Body) ); if ( self->InlineCmt ) - append_fmt( result, "; // %SC\n", self->InlineCmt->Content ); + string_append_fmt( result, "; // %SC\n", self->InlineCmt->Content ); else - append( result, ";\n" ); + string_append_strc( result, txt(";\n") ); } String to_string( CodeClass self ) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 512 ); switch ( self->Type ) { case CT_Class: @@ -155,45 +155,45 @@ void to_string_def( CodeClass self, String* result ) AST_Class* ast = self.ast; if ( bitfield_is_equal( u32, ast->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); - append( result, "class " ); + string_append_strc( result, txt("class ") ); if ( ast->Attributes ) { - append_fmt( result, "%S ", GEN_NS to_string(ast->Attributes) ); + string_append_fmt( result, "%S ", GEN_NS to_string(ast->Attributes) ); } if ( ast->ParentType ) { char const* access_level = to_str( ast->ParentAccess ); - append_fmt( result, "%SC : %s %S", ast->Name, access_level, to_string(ast->ParentType) ); + string_append_fmt( result, "%SC : %s %S", ast->Name, access_level, to_string(ast->ParentType) ); CodeTypename interface = cast(CodeTypename, ast->ParentType->Next); if ( interface ) - append( result, "\n" ); + string_append_strc( result, txt("\n") ); while ( interface ) { - append_fmt( result, ", %S", to_string(interface) ); + string_append_fmt( result, ", %S", to_string(interface) ); interface = interface->Next ? cast(CodeTypename, interface->Next) : CodeTypename { nullptr }; } } else if ( ast->Name ) { - append( result, ast->Name ); + string_append_strc( result, ast->Name ); } if ( ast->InlineCmt ) { - append_fmt( result, " // %SC", ast->InlineCmt->Content ); + string_append_fmt( result, " // %SC", ast->InlineCmt->Content ); } - append_fmt( result, "\n{\n%S\n}", to_string(ast->Body) ); + string_append_fmt( result, "\n{\n%S\n}", to_string(ast->Body) ); if ( ast->Parent.ast == nullptr || ( ast->Parent->Type != CT_Typedef && ast->Parent->Type != CT_Variable ) ) - append( result, ";\n"); + string_append_strc( result, txt(";\n") ); } void to_string_fwd( CodeClass self, String* result ) @@ -202,20 +202,20 @@ void to_string_fwd( CodeClass self, String* result ) AST_Class* ast = self.ast; if ( bitfield_is_equal( u32, ast->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); if ( ast->Attributes ) - append_fmt( result, "class %S %SC", to_string(ast->Attributes), ast->Name ); + string_append_fmt( result, "class %S %SC", to_string(ast->Attributes), ast->Name ); - else append_fmt( result, "class %SC", ast->Name ); + else string_append_fmt( result, "class %SC", ast->Name ); // Check if it can have an end-statement if ( ast->Parent.ast == nullptr || ( ast->Parent->Type != CT_Typedef && ast->Parent->Type != CT_Variable ) ) { if ( ast->InlineCmt ) - append_fmt( result, "; // %SC\n", ast->InlineCmt->Content ); + string_append_fmt( result, "; // %SC\n", ast->InlineCmt->Content ); else - append( result,";\n"); + string_append_strc( result, txt(";\n") ); } } @@ -226,12 +226,12 @@ String to_string(CodeDefine define) void to_string(CodeDefine define, String* result ) { - append_fmt( result, "#define %SC %SC\n", define->Name, define->Content ); + string_append_fmt( result, "#define %SC %SC\n", define->Name, define->Content ); } String to_string(CodeDestructor self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 128 ); switch ( self->Type ) { case CT_Destructor: @@ -248,19 +248,19 @@ void to_string_def(CodeDestructor self, String* result ) { if ( self->Name ) { - append_fmt( result, "%SC()", self->Name ); + string_append_fmt( result, "%SC()", self->Name ); } else if ( self->Specs ) { if ( has(self->Specs, Spec_Virtual ) ) - append_fmt( result, "virtual ~%SC()", self->Parent->Name ); + string_append_fmt( result, "virtual ~%SC()", self->Parent->Name ); else - append_fmt( result, "~%SC()", self->Parent->Name ); + string_append_fmt( result, "~%SC()", self->Parent->Name ); } else - append_fmt( result, "~%SC()", self->Parent->Name ); + string_append_fmt( result, "~%SC()", self->Parent->Name ); - append_fmt( result, "\n{\n%S\n}\n", to_string(self->Body) ); + string_append_fmt( result, "\n{\n%S\n}\n", to_string(self->Body) ); } void to_string_fwd(CodeDestructor self, String* result ) @@ -268,27 +268,27 @@ void to_string_fwd(CodeDestructor self, String* result ) if ( self->Specs ) { if ( has(self->Specs, Spec_Virtual ) ) - append_fmt( result, "virtual ~%SC();\n", self->Parent->Name ); + string_append_fmt( result, "virtual ~%SC();\n", self->Parent->Name ); else - append_fmt( result, "~%SC()", self->Parent->Name ); + string_append_fmt( result, "~%SC()", self->Parent->Name ); if ( has(self->Specs, Spec_Pure ) ) - append( result, " = 0;" ); + string_append_strc( result, txt(" = 0;") ); else if (self->Body) - append_fmt( result, " = %S;", to_string(self->Body) ); + string_append_fmt( result, " = %S;", to_string(self->Body) ); } else - append_fmt( result, "~%SC();", self->Parent->Name ); + string_append_fmt( result, "~%SC();", self->Parent->Name ); if ( self->InlineCmt ) - append_fmt( result, " %SC", self->InlineCmt->Content ); + string_append_fmt( result, " %SC", self->InlineCmt->Content ); else - append( result, "\n"); + string_append_strc( result, txt("\n")); } String to_string(CodeEnum self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 512 ); switch ( self->Type ) { case CT_Enum: @@ -310,122 +310,122 @@ String to_string(CodeEnum self) void to_string_def(CodeEnum self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); if ( self->Attributes || self->UnderlyingType ) { - append( result, "enum " ); + string_append_strc( result, txt("enum ") ); if ( self->Attributes ) - append_fmt( result, "%S ", to_string(self->Attributes) ); + string_append_fmt( result, "%S ", to_string(self->Attributes) ); if ( self->UnderlyingType ) - append_fmt( result, "%SC : %S\n{\n%S\n}" + string_append_fmt( result, "%SC : %S\n{\n%S\n}" , self->Name , to_string(self->UnderlyingType) , to_string(self->Body) ); else if ( self->UnderlyingTypeMacro ) - append_fmt( result, "%SC : %S\n{\n%S\n}" + string_append_fmt( result, "%SC : %S\n{\n%S\n}" , self->Name , to_string(self->UnderlyingTypeMacro) , to_string(self->Body) ); - else append_fmt( result, "%SC\n{\n%S\n}", self->Name, to_string(self->Body) ); + else string_append_fmt( result, "%SC\n{\n%S\n}", self->Name, to_string(self->Body) ); } - else append_fmt( result, "enum %SC\n{\n%S\n}", self->Name, to_string(self->Body) ); + else string_append_fmt( result, "enum %SC\n{\n%S\n}", self->Name, to_string(self->Body) ); if ( self->Parent.ast == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) ) - append( result, ";\n"); + string_append_strc( result, txt(";\n")); } void to_string_fwd(CodeEnum self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); if ( self->Attributes ) - append_fmt( result, "%S ", to_string(self->Attributes) ); + string_append_fmt( result, "%S ", to_string(self->Attributes) ); if ( self->UnderlyingType ) - append_fmt( result, "enum %SC : %S", self->Name, to_string(self->UnderlyingType) ); + string_append_fmt( result, "enum %SC : %S", self->Name, to_string(self->UnderlyingType) ); else - append_fmt( result, "enum %SC", self->Name ); + string_append_fmt( result, "enum %SC", self->Name ); if ( self->Parent.ast == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) ) { if ( self->InlineCmt ) - append_fmt( result, "; %SC", self->InlineCmt->Content ); + string_append_fmt( result, "; %SC", self->InlineCmt->Content ); else - append( result, ";\n"); + string_append_strc( result, txt(";\n")); } } void to_string_class_def(CodeEnum self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); if ( self->Attributes || self->UnderlyingType ) { - append( result, "enum class " ); + string_append_strc( result, txt("enum class ") ); if ( self->Attributes ) { - append_fmt( result, "%S ", to_string(self->Attributes) ); + string_append_fmt( result, "%S ", to_string(self->Attributes) ); } if ( self->UnderlyingType ) { - append_fmt( result, "%SC : %S\n{\n%S\n}", self->Name, to_string(self->UnderlyingType), to_string(self->Body) ); + string_append_fmt( result, "%SC : %S\n{\n%S\n}", self->Name, to_string(self->UnderlyingType), to_string(self->Body) ); } else { - append_fmt( result, "%SC\n{\n%S\n}", self->Name, to_string(self->Body) ); + string_append_fmt( result, "%SC\n{\n%S\n}", self->Name, to_string(self->Body) ); } } else { - append_fmt( result, "enum %SC\n{\n%S\n}", self->Name, to_string(self->Body) ); + string_append_fmt( result, "enum %SC\n{\n%S\n}", self->Name, to_string(self->Body) ); } if ( self->Parent.ast == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) ) - append( result, ";\n"); + string_append_strc( result, txt(";\n")); } void to_string_class_fwd(CodeEnum self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); - append( result, "enum class " ); + string_append_strc( result, txt("enum class ") ); if ( self->Attributes ) - append_fmt( result, "%S ", to_string(self->Attributes) ); + string_append_fmt( result, "%S ", to_string(self->Attributes) ); - append_fmt( result, "%SC : %S", self->Name, to_string(self->UnderlyingType) ); + string_append_fmt( result, "%SC : %S", self->Name, to_string(self->UnderlyingType) ); if ( self->Parent.ast == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) ) { if ( self->InlineCmt ) - append_fmt( result, "; %SC", self->InlineCmt->Content ); + string_append_fmt( result, "; %SC", self->InlineCmt->Content ); else - append( result, ";\n"); + string_append_strc( result, txt(";\n")); } } String to_string(CodeExec exec) { - return {(char*) duplicate( exec->Content, GlobalAllocator ).Ptr}; + return {(char*) strc_duplicate( exec->Content, GlobalAllocator ).Ptr}; } void to_string(CodeExtern self, String* result ) { if ( self->Body ) - append_fmt( result, "extern \"%SC\"\n{\n%S\n}\n", self->Name, to_string(self->Body) ); + string_append_fmt( result, "extern \"%SC\"\n{\n%S\n}\n", self->Name, to_string(self->Body) ); else - append_fmt( result, "extern \"%SC\"\n{}\n", self->Name ); + string_append_fmt( result, "extern \"%SC\"\n{}\n", self->Name ); } String to_string(CodeInclude include) @@ -435,34 +435,34 @@ String to_string(CodeInclude include) void to_string( CodeInclude include, String* result ) { - append_fmt( result, "#include %SC\n", include->Content ); + string_append_fmt( result, "#include %SC\n", include->Content ); } String to_string(CodeFriend self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 256 ); to_string( self, & result ); return result; } void to_string(CodeFriend self, String* result ) { - append_fmt( result, "friend %S", to_string(self->Declaration) ); + string_append_fmt( result, "friend %S", to_string(self->Declaration) ); - if ( self->Declaration->Type != CT_Function && self->Declaration->Type != CT_Operator && (* result)[ length(* result) - 1 ] != ';' ) + if ( self->Declaration->Type != CT_Function && self->Declaration->Type != CT_Operator && (* result)[ string_length(* result) - 1 ] != ';' ) { - append( result, ";" ); + string_append_strc( result, txt(";") ); } if ( self->InlineCmt ) - append_fmt( result, " %SC", self->InlineCmt->Content ); + string_append_fmt( result, " %SC", self->InlineCmt->Content ); else - append( result, "\n"); + string_append_strc( result, txt("\n")); } String to_string(CodeFn self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 512 ); switch ( self->Type ) { case CT_Function: @@ -478,10 +478,10 @@ String to_string(CodeFn self) void to_string_def(CodeFn self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export" ); + string_append_strc( result, txt("export") ); if ( self->Attributes ) - append_fmt( result, " %S ", to_string(self->Attributes) ); + string_append_fmt( result, " %S ", to_string(self->Attributes) ); bool prefix_specs = false; if ( self->Specs ) @@ -491,7 +491,7 @@ void to_string_def(CodeFn self, String* result ) if ( ! is_trailing( spec ) ) { StrC spec_str = to_str( spec ); - append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); + string_append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); prefix_specs = true; } @@ -499,19 +499,19 @@ void to_string_def(CodeFn self, String* result ) } if ( self->Attributes || prefix_specs ) - append( result, "\n" ); + string_append_strc( result, txt("\n") ); if ( self->ReturnType ) - append_fmt( result, "%S %SC(", to_string(self->ReturnType), self->Name ); + string_append_fmt( result, "%S %SC(", to_string(self->ReturnType), self->Name ); else - append_fmt( result, "%SC(", self->Name ); + string_append_fmt( result, "%SC(", self->Name ); if ( self->Params ) - append_fmt( result, "%S)", to_string(self->Params) ); + string_append_fmt( result, "%S)", to_string(self->Params) ); else - append( result, ")" ); + string_append_strc( result, txt(")") ); if ( self->Specs ) { @@ -520,21 +520,21 @@ void to_string_def(CodeFn self, String* result ) if ( is_trailing( spec ) ) { StrC spec_str = to_str( spec ); - append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); + string_append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); } } } - append_fmt( result, "\n{\n%S\n}\n", to_string(self->Body) ); + string_append_fmt( result, "\n{\n%S\n}\n", to_string(self->Body) ); } void to_string_fwd(CodeFn self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); if ( self->Attributes ) - append_fmt( result, "%S ", to_string(self->Attributes) ); + string_append_fmt( result, "%S ", to_string(self->Attributes) ); b32 prefix_specs = false; if ( self->Specs ) @@ -544,7 +544,7 @@ void to_string_fwd(CodeFn self, String* result ) if ( ! is_trailing( spec ) || ! (spec != Spec_Pure) ) { StrC spec_str = to_str( spec ); - append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); + string_append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); prefix_specs = true; } @@ -553,20 +553,20 @@ void to_string_fwd(CodeFn self, String* result ) if ( self->Attributes || prefix_specs ) { - append( result, "\n" ); + string_append_strc( result, txt("\n") ); } if ( self->ReturnType ) - append_fmt( result, "%S %SC(", to_string(self->ReturnType), self->Name ); + string_append_fmt( result, "%S %SC(", to_string(self->ReturnType), self->Name ); else - append_fmt( result, "%SC(", self->Name ); + string_append_fmt( result, "%SC(", self->Name ); if ( self->Params ) - append_fmt( result, "%S)", to_string(self->Params) ); + string_append_fmt( result, "%S)", to_string(self->Params) ); else - append( result, ")" ); + string_append_strc( result, txt(")") ); if ( self->Specs ) { @@ -575,25 +575,25 @@ void to_string_fwd(CodeFn self, String* result ) if ( is_trailing( spec ) ) { StrC spec_str = to_str( spec ); - append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); + string_append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); } } } if ( self->Specs && has(self->Specs, Spec_Pure ) >= 0 ) - append( result, " = 0;" ); + string_append_strc( result, txt(" = 0;") ); else if (self->Body) - append_fmt( result, " = %S;", to_string(self->Body) ); + string_append_fmt( result, " = %S;", to_string(self->Body) ); if ( self->InlineCmt ) - append_fmt( result, "; %SC", self->InlineCmt->Content ); + string_append_fmt( result, "; %SC", self->InlineCmt->Content ); else - append( result, ";\n" ); + string_append_strc( result, txt(";\n") ); } String to_string(CodeModule self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 64 ); to_string( self, & result ); return result; } @@ -601,17 +601,17 @@ String to_string(CodeModule self) void to_string(CodeModule self, String* result ) { if (((u32(ModuleFlag_Export) & u32(self->ModuleFlags)) == u32(ModuleFlag_Export))) - append( result, "export "); + string_append_strc( result, txt("export ")); if (((u32(ModuleFlag_Import) & u32(self->ModuleFlags)) == u32(ModuleFlag_Import))) - append( result, "import "); + string_append_strc( result, txt("import ")); - append_fmt( result, "%SC;\n", self->Name ); + string_append_fmt( result, "%SC;\n", self->Name ); } String to_string(CodeNS self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 512 ); to_string( self, & result ); return result; } @@ -619,14 +619,14 @@ String to_string(CodeNS self) void to_string(CodeNS self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); - append_fmt( result, "namespace %SC\n{\n%S\n}\n", self->Name, to_string(self->Body) ); + string_append_fmt( result, "namespace %SC\n{\n%S\n}\n", self->Name, to_string(self->Body) ); } String to_string(CodeOperator self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 512 ); switch ( self->Type ) { case CT_Operator: @@ -644,13 +644,13 @@ String to_string(CodeOperator self) void to_string_def(CodeOperator self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); if ( self->Attributes ) - append_fmt( result, "%S ", to_string(self->Attributes) ); + string_append_fmt( result, "%S ", to_string(self->Attributes) ); if ( self->Attributes ) - append_fmt( result, "%S ", to_string(self->Attributes) ); + string_append_fmt( result, "%S ", to_string(self->Attributes) ); if ( self->Specs ) { @@ -659,24 +659,24 @@ void to_string_def(CodeOperator self, String* result ) if ( ! is_trailing( spec ) ) { StrC spec_str = to_str( spec ); - append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); + string_append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); } } } if ( self->Attributes || self->Specs ) { - append( result, "\n" ); + string_append_strc( result, txt("\n") ); } if ( self->ReturnType ) - append_fmt( result, "%S %SC (", to_string(self->ReturnType), self->Name ); + string_append_fmt( result, "%S %SC (", to_string(self->ReturnType), self->Name ); if ( self->Params ) - append_fmt( result, "%S)", to_string(self->Params) ); + string_append_fmt( result, "%S)", to_string(self->Params) ); else - append( result, ")" ); + string_append_strc( result, txt(")") ); if ( self->Specs ) { @@ -685,12 +685,12 @@ void to_string_def(CodeOperator self, String* result ) if ( is_trailing( spec ) ) { StrC spec_str = to_str( spec ); - append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); + string_append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); } } } - append_fmt( result, "\n{\n%S\n}\n" + string_append_fmt( result, "\n{\n%S\n}\n" , to_string(self->Body) ); } @@ -698,10 +698,10 @@ void to_string_def(CodeOperator self, String* result ) void to_string_fwd(CodeOperator self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); if ( self->Attributes ) - append_fmt( result, "%S\n", to_string(self->Attributes) ); + string_append_fmt( result, "%S\n", to_string(self->Attributes) ); if ( self->Specs ) { @@ -710,23 +710,23 @@ void to_string_fwd(CodeOperator self, String* result ) if ( ! is_trailing( spec ) ) { StrC spec_str = to_str( spec ); - append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); + string_append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); } } } if ( self->Attributes || self->Specs ) { - append( result, "\n" ); + string_append_strc( result, txt("\n") ); } - append_fmt( result, "%S %SC (", to_string(self->ReturnType), self->Name ); + string_append_fmt( result, "%S %SC (", to_string(self->ReturnType), self->Name ); if ( self->Params ) - append_fmt( result, "%S)", to_string(self->Params) ); + string_append_fmt( result, "%S)", to_string(self->Params) ); else - append_fmt( result, ")" ); + string_append_fmt( result, ")" ); if ( self->Specs ) { @@ -735,20 +735,20 @@ void to_string_fwd(CodeOperator self, String* result ) if ( is_trailing( spec ) ) { StrC spec_str = to_str( spec ); - append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); + string_append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); } } } if ( self->InlineCmt ) - append_fmt( result, "; %SC", self->InlineCmt->Content ); + string_append_fmt( result, "; %SC", self->InlineCmt->Content ); else - append( result, ";\n" ); + string_append_strc( result, txt(";\n") ); } String to_string(CodeOpCast self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 128 ); switch ( self->Type ) { case CT_Operator_Cast: @@ -770,32 +770,32 @@ void to_string_def(CodeOpCast self, String* result ) if ( ! is_trailing( spec ) ) { StrC spec_str = to_str( spec ); - append_fmt( result, "%*s ", spec_str.Len, spec_str.Ptr ); + string_append_fmt( result, "%*s ", spec_str.Len, spec_str.Ptr ); } } if ( self->Name && self->Name.Len ) - append_fmt( result, "%SC operator %S()", self->Name, to_string(self->ValueType) ); + string_append_fmt( result, "%SC operator %S()", self->Name, to_string(self->ValueType) ); else - append_fmt( result, "operator %S()", to_string(self->ValueType) ); + string_append_fmt( result, "operator %S()", to_string(self->ValueType) ); for ( Specifier spec : self->Specs ) { if ( is_trailing( spec ) ) { StrC spec_str = to_str( spec ); - append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); + string_append_fmt( result, " %.*s", spec_str.Len, spec_str.Ptr ); } } - append_fmt( result, "\n{\n%S\n}\n", to_string(self->Body) ); + string_append_fmt( result, "\n{\n%S\n}\n", to_string(self->Body) ); return; } if ( self->Name && self->Name.Len ) - append_fmt( result, "%SC operator %S()\n{\n%S\n}\n", self->Name, to_string(self->ValueType), to_string(self->Body) ); + string_append_fmt( result, "%SC operator %S()\n{\n%S\n}\n", self->Name, to_string(self->ValueType), to_string(self->Body) ); else - append_fmt( result, "operator %S()\n{\n%S\n}\n", to_string(self->ValueType), to_string(self->Body) ); + string_append_fmt( result, "operator %S()\n{\n%S\n}\n", to_string(self->ValueType), to_string(self->Body) ); } void to_string_fwd(CodeOpCast self, String* result ) @@ -807,37 +807,37 @@ void to_string_fwd(CodeOpCast self, String* result ) if ( ! is_trailing( spec ) ) { StrC spec_str = to_str( spec ); - append_fmt( result, "%*s ", spec_str.Len, spec_str.Ptr ); + string_append_fmt( result, "%*s ", spec_str.Len, spec_str.Ptr ); } } - append_fmt( result, "operator %S()", to_string(self->ValueType) ); + string_append_fmt( result, "operator %S()", to_string(self->ValueType) ); for ( Specifier spec : self->Specs ) { if ( is_trailing( spec ) ) { StrC spec_str = to_str( spec ); - append_fmt( result, " %*s", spec_str.Len, spec_str.Ptr ); + string_append_fmt( result, " %*s", spec_str.Len, spec_str.Ptr ); } } if ( self->InlineCmt ) - append_fmt( result, "; %SC", self->InlineCmt->Content ); + string_append_fmt( result, "; %SC", self->InlineCmt->Content ); else - append( result, ";\n" ); + string_append_strc( result, txt(";\n") ); return; } if ( self->InlineCmt ) - append_fmt( result, "operator %S(); %S", to_string(self->ValueType) ); + string_append_fmt( result, "operator %S(); %S", to_string(self->ValueType) ); else - append_fmt( result, "operator %S();\n", to_string(self->ValueType) ); + string_append_fmt( result, "operator %S();\n", to_string(self->ValueType) ); } String to_string(CodeParam self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 128 ); to_string( self, & result ); return result; } @@ -848,41 +848,41 @@ void to_string( CodeParam self, String* result ) if ( ast->Macro ) { // Related to parsing: ( , ... ) - append( result, ast->Macro.ast->Content ); + string_append_strc( result, ast->Macro.ast->Content ); // Could also be: ( , ... ) } if ( ast->Name ) { if ( ast->ValueType.ast == nullptr ) - append_fmt( result, " %SC", ast->Name ); + string_append_fmt( result, " %SC", ast->Name ); else - append_fmt( result, " %S %SC", to_string(ast->ValueType), ast->Name ); + string_append_fmt( result, " %S %SC", to_string(ast->ValueType), ast->Name ); } else if ( ast->ValueType ) - append_fmt( result, " %S", to_string(ast->ValueType) ); + string_append_fmt( result, " %S", to_string(ast->ValueType) ); if ( ast->PostNameMacro ) { - append_fmt( result, " %S", to_string(ast->PostNameMacro) ); + string_append_fmt( result, " %S", to_string(ast->PostNameMacro) ); } if ( ast->Value ) - append_fmt( result, " = %S", to_string(ast->Value) ); + string_append_fmt( result, " = %S", to_string(ast->Value) ); if ( ast->NumEntries - 1 > 0 ) { for ( CodeParam param : ast->Next ) { - append_fmt( result, ", %S", to_string(param) ); + string_append_fmt( result, ", %S", to_string(param) ); } } } String to_string(CodePreprocessCond self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 256 ); switch ( self->Type ) { case CT_Preprocess_If: @@ -909,49 +909,49 @@ String to_string(CodePreprocessCond self) void to_string_if(CodePreprocessCond cond, String* result ) { - append_fmt( result, "#if %SC\n", cond->Content ); + string_append_fmt( result, "#if %SC\n", cond->Content ); } void to_string_ifdef(CodePreprocessCond cond, String* result ) { - append_fmt( result, "#ifdef %SC\n", cond->Content ); + string_append_fmt( result, "#ifdef %SC\n", cond->Content ); } void to_string_ifndef(CodePreprocessCond cond, String* result ) { - append_fmt( result, "#ifndef %SC\n", cond->Content ); + string_append_fmt( result, "#ifndef %SC\n", cond->Content ); } void to_string_elif(CodePreprocessCond cond, String* result ) { - append_fmt( result, "#elif %SC\n", cond->Content ); + string_append_fmt( result, "#elif %SC\n", cond->Content ); } void to_string_else(CodePreprocessCond cond, String* result ) { - append_fmt( result, "#else\n" ); + string_append_strc( result, txt("#else\n") ); } void to_string_endif(CodePreprocessCond cond, String* result ) { - append_fmt( result, "#endif\n" ); + string_append_strc( result, txt("#endif\n") ); } String to_string(CodePragma self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 256 ); to_string( self, & result ); return result; } void to_string(CodePragma self, String* result ) { - append_fmt( result, "#pragma %SC\n", self->Content ); + string_append_fmt( result, "#pragma %SC\n", self->Content ); } String to_string(CodeSpecifiers self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 64 ); to_string( self, & result ); return result; } @@ -965,7 +965,7 @@ void to_string( CodeSpecifiers self, String* result ) while ( left-- ) { StrC spec = to_str( self->ArrSpecs[idx] ); - append_fmt( result, "%.*s ", spec.Len, spec.Ptr ); + string_append_fmt( result, "%.*s ", spec.Len, spec.Ptr ); idx++; } } @@ -973,7 +973,7 @@ void to_string( CodeSpecifiers self, String* result ) String to_string(CodeStruct self) { GEN_ASSERT(self.ast != nullptr); - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 512 ); switch ( self->Type ) { case CT_Struct: @@ -992,45 +992,45 @@ void to_string_def( CodeStruct self, String* result ) AST_Struct* ast = self.ast; if ( bitfield_is_equal( u32, ast->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); - append( result, "struct " ); + string_append_strc( result, txt("struct ") ); if ( ast->Attributes ) { - append_fmt( result, "%S ", to_string(ast->Attributes) ); + string_append_fmt( result, "%S ", to_string(ast->Attributes) ); } if ( ast->ParentType ) { char const* access_level = to_str( ast->ParentAccess ); - append_fmt( result, "%SC : %s %S", ast->Name, access_level, to_string(ast->ParentType) ); + string_append_fmt( result, "%SC : %s %S", ast->Name, access_level, to_string(ast->ParentType) ); CodeTypename interface = cast(CodeTypename, ast->ParentType->Next); if ( interface ) - append( result, "\n" ); + string_append_strc( result, txt("\n") ); while ( interface ) { - append_fmt( result, ", %S", to_string(interface) ); + string_append_fmt( result, ", %S", to_string(interface) ); interface = interface->Next ? cast( CodeTypename, interface->Next) : CodeTypename { nullptr }; } } else if ( ast->Name ) { - append( result, ast->Name ); + string_append_strc( result, ast->Name ); } if ( ast->InlineCmt ) { - append_fmt( result, " // %SC", ast->InlineCmt->Content ); + string_append_fmt( result, " // %SC", ast->InlineCmt->Content ); } - append_fmt( result, "\n{\n%S\n}", to_string(ast->Body) ); + string_append_fmt( result, "\n{\n%S\n}", to_string(ast->Body) ); if ( ast->Parent.ast == nullptr || ( ast->Parent->Type != CT_Typedef && ast->Parent->Type != CT_Variable ) ) - append( result, ";\n"); + string_append_strc( result, txt(";\n")); } void to_string_fwd( CodeStruct self, String* result ) @@ -1039,25 +1039,25 @@ void to_string_fwd( CodeStruct self, String* result ) AST_Struct* ast = self.ast; if ( bitfield_is_equal( u32, ast->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); if ( ast->Attributes ) - append_fmt( result, "struct %S %SC", to_string(ast->Attributes), ast->Name ); + string_append_fmt( result, "struct %S %SC", to_string(ast->Attributes), ast->Name ); - else append_fmt( result, "struct %SC", ast->Name ); + else string_append_fmt( result, "struct %SC", ast->Name ); if ( ast->Parent.ast == nullptr || ( ast->Parent->Type != CT_Typedef && ast->Parent->Type != CT_Variable ) ) { if ( ast->InlineCmt ) - append_fmt( result, "; %SC", ast->InlineCmt->Content ); + string_append_fmt( result, "; %SC", ast->InlineCmt->Content ); else - append( result, ";\n"); + string_append_strc( result, txt( ";\n") ); } } String to_string(CodeTemplate self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 1024 ); to_string( self, & result ); return result; } @@ -1065,17 +1065,17 @@ String to_string(CodeTemplate self) void to_string(CodeTemplate self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); if ( self->Params ) - append_fmt( result, "template< %S >\n%S", to_string(self->Params), to_string(self->Declaration) ); + string_append_fmt( result, "template< %S >\n%S", to_string(self->Params), to_string(self->Declaration) ); else - append_fmt( result, "template<>\n%S", to_string(self->Declaration) ); + string_append_fmt( result, "template<>\n%S", to_string(self->Declaration) ); } String to_string(CodeTypedef self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 128 ); to_string( self, & result ); return result; } @@ -1083,41 +1083,41 @@ String to_string(CodeTypedef self) void to_string(CodeTypedef self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); - append( result, "typedef "); + string_append_strc( result, txt("typedef ")); // Determines if the typedef is a function typename if ( self->UnderlyingType->ReturnType ) - append( result, to_string(self->UnderlyingType) ); + string_append_string( result, to_string(self->UnderlyingType) ); else - append_fmt( result, "%S %SC", to_string(self->UnderlyingType), self->Name ); + string_append_fmt( result, "%S %SC", to_string(self->UnderlyingType), self->Name ); if ( self->UnderlyingType->Type == CT_Typename && self->UnderlyingType->ArrExpr ) { - append_fmt( result, "[ %S ];", to_string(self->UnderlyingType->ArrExpr) ); + string_append_fmt( result, "[ %S ];", to_string(self->UnderlyingType->ArrExpr) ); Code next_arr_expr = self->UnderlyingType->ArrExpr->Next; while ( next_arr_expr ) { - append_fmt( result, "[ %S ];", to_string(next_arr_expr) ); + string_append_fmt( result, "[ %S ];", to_string(next_arr_expr) ); next_arr_expr = next_arr_expr->Next; } } else { - append( result, ";" ); + string_append_strc( result, txt(";") ); } if ( self->InlineCmt ) - append_fmt( result, " %SC", self->InlineCmt->Content); + string_append_fmt( result, " %SC", self->InlineCmt->Content); else - append( result, "\n"); + string_append_strc( result, txt("\n")); } String to_string(CodeTypename self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_strc( GlobalAllocator, txt("") ); to_string( self, & result ); return result; } @@ -1128,13 +1128,13 @@ void to_string(CodeTypename self, String* result ) if ( self->ReturnType && self->Params ) { if ( self->Attributes ) - append_fmt( result, "%S ", to_string(self->Attributes) ); + string_append_fmt( result, "%S ", to_string(self->Attributes) ); else { if ( self->Specs ) - append_fmt( result, "%S ( %SC ) ( %S ) %S", to_string(self->ReturnType), self->Name, to_string(self->Params), to_string(self->Specs) ); + string_append_fmt( result, "%S ( %SC ) ( %S ) %S", to_string(self->ReturnType), self->Name, to_string(self->Params), to_string(self->Specs) ); else - append_fmt( result, "%S ( %SC ) ( %S )", to_string(self->ReturnType), self->Name, to_string(self->Params) ); + string_append_fmt( result, "%S ( %SC ) ( %S )", to_string(self->ReturnType), self->Name, to_string(self->Params) ); } break; @@ -1143,13 +1143,13 @@ void to_string(CodeTypename self, String* result ) if ( self->ReturnType && self->Params ) { if ( self->Attributes ) - append_fmt( result, "%S ", to_string(self->Attributes) ); + string_append_fmt( result, "%S ", to_string(self->Attributes) ); else { if ( self->Specs ) - append_fmt( result, "%S %SC ( %S ) %S", to_string(self->ReturnType), self->Name, to_string(self->Params), to_string(self->Specs) ); + string_append_fmt( result, "%S %SC ( %S ) %S", to_string(self->ReturnType), self->Name, to_string(self->Params), to_string(self->Specs) ); else - append_fmt( result, "%S %SC ( %S )", to_string(self->ReturnType), self->Name, to_string(self->Params) ); + string_append_fmt( result, "%S %SC ( %S )", to_string(self->ReturnType), self->Name, to_string(self->Params) ); } return; @@ -1157,20 +1157,20 @@ void to_string(CodeTypename self, String* result ) #endif if ( self->Attributes ) - append_fmt( result, "%S ", to_string(self->Attributes) ); + string_append_fmt( result, "%S ", to_string(self->Attributes) ); if ( self->Specs ) - append_fmt( result, "%SC %S", self->Name, to_string(self->Specs) ); + string_append_fmt( result, "%SC %S", self->Name, to_string(self->Specs) ); else - append_fmt( result, "%SC", self->Name ); + string_append_fmt( result, "%SC", self->Name ); if ( self->IsParamPack ) - append( result, "..."); + string_append_strc( result, txt("...")); } String to_string(CodeUnion self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 512 ); to_string( self, & result ); return result; } @@ -1178,16 +1178,16 @@ String to_string(CodeUnion self) void to_string(CodeUnion self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); - append( result, "union " ); + string_append_strc( result, txt("union ") ); if ( self->Attributes ) - append_fmt( result, "%S ", to_string(self->Attributes) ); + string_append_fmt( result, "%S ", to_string(self->Attributes) ); if ( self->Name ) { - append_fmt( result, "%SC\n{\n%S\n}" + string_append_fmt( result, "%SC\n{\n%S\n}" , self->Name , GEN_NS to_string(self->Body) ); @@ -1195,18 +1195,18 @@ void to_string(CodeUnion self, String* result ) else { // Anonymous union - append_fmt( result, "\n{\n%S\n}" + string_append_fmt( result, "\n{\n%S\n}" , GEN_NS to_string(self->Body) ); } if ( self->Parent.ast == nullptr || ( self->Parent->Type != CT_Typedef && self->Parent->Type != CT_Variable ) ) - append( result, ";\n"); + string_append_strc( result, txt(";\n")); } String to_string(CodeUsing self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 128 ); switch ( self->Type ) { case CT_Using: @@ -1222,49 +1222,49 @@ String to_string(CodeUsing self) void to_string(CodeUsing self, String* result ) { if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); if ( self->Attributes ) - append_fmt( result, "%S ", to_string(self->Attributes) ); + string_append_fmt( result, "%S ", to_string(self->Attributes) ); if ( self->UnderlyingType ) { - append_fmt( result, "using %SC = %S", self->Name, to_string(self->UnderlyingType) ); + string_append_fmt( result, "using %SC = %S", self->Name, to_string(self->UnderlyingType) ); if ( self->UnderlyingType->ArrExpr ) { - append_fmt( result, "[ %S ]", to_string(self->UnderlyingType->ArrExpr) ); + string_append_fmt( result, "[ %S ]", to_string(self->UnderlyingType->ArrExpr) ); Code next_arr_expr = self->UnderlyingType->ArrExpr->Next; while ( next_arr_expr ) { - append_fmt( result, "[ %S ]", to_string(next_arr_expr) ); + string_append_fmt( result, "[ %S ]", to_string(next_arr_expr) ); next_arr_expr = next_arr_expr->Next; } } - append( result, ";" ); + string_append_strc( result, txt(";") ); } else - append_fmt( result, "using %SC;", self->Name ); + string_append_fmt( result, "using %SC;", self->Name ); if ( self->InlineCmt ) - append_fmt( result, " %SC\n", self->InlineCmt->Content ); + string_append_fmt( result, " %SC\n", self->InlineCmt->Content ); else - append( result, "\n"); + string_append_strc( result, txt("\n")); } void to_string_ns(CodeUsing self, String* result ) { if ( self->InlineCmt ) - append_fmt( result, "using namespace $SC; %SC", self->Name, self->InlineCmt->Content ); + string_append_fmt( result, "using namespace $SC; %SC", self->Name, self->InlineCmt->Content ); else - append_fmt( result, "using namespace %SC;\n", self->Name ); + string_append_fmt( result, "using namespace %SC;\n", self->Name ); } String to_string(CodeVar self) { - String result = string_make( GlobalAllocator, "" ); + String result = string_make_reserve( GlobalAllocator, 256 ); to_string( self, & result ); return result; } @@ -1276,18 +1276,18 @@ void to_string(CodeVar self, String* result ) // Its a comma-separated variable ( a NextVar ) if ( self->Specs ) - append_fmt( result, "%S ", to_string(self->Specs) ); + string_append_fmt( result, "%S ", to_string(self->Specs) ); - append( result, self->Name ); + string_append_strc( result, self->Name ); if ( self->ValueType->ArrExpr ) { - append_fmt( result, "[ %S ]", to_string(self->ValueType->ArrExpr) ); + string_append_fmt( result, "[ %S ]", to_string(self->ValueType->ArrExpr) ); Code next_arr_expr = self->ValueType->ArrExpr->Next; while ( next_arr_expr ) { - append_fmt( result, "[ %S ]", to_string(next_arr_expr) ); + string_append_fmt( result, "[ %S ]", to_string(next_arr_expr) ); next_arr_expr = next_arr_expr->Next; } } @@ -1295,107 +1295,107 @@ void to_string(CodeVar self, String* result ) if ( self->Value ) { if ( self->VarConstructorInit ) - append_fmt( result, "( %S ", to_string(self->Value) ); + string_append_fmt( result, "( %S ", to_string(self->Value) ); else - append_fmt( result, " = %S", to_string(self->Value) ); + string_append_fmt( result, " = %S", to_string(self->Value) ); } // Keep the chain going... if ( self->NextVar ) - append_fmt( result, ", %S", to_string(self->NextVar) ); + string_append_fmt( result, ", %S", to_string(self->NextVar) ); if ( self->VarConstructorInit ) - append( result, " )"); + string_append_strc( result, txt(" )")); return; } if ( bitfield_is_equal( u32, self->ModuleFlags, ModuleFlag_Export )) - append( result, "export " ); + string_append_strc( result, txt("export ") ); if ( self->Attributes || self->Specs ) { if ( self->Attributes ) - append_fmt( result, "%S ", to_string(self->Specs) ); + string_append_fmt( result, "%S ", to_string(self->Specs) ); if ( self->Specs ) - append_fmt( result, "%S\n", to_string(self->Specs) ); + string_append_fmt( result, "%S\n", to_string(self->Specs) ); - append_fmt( result, "%S %SC", to_string(self->ValueType), self->Name ); + string_append_fmt( result, "%S %SC", to_string(self->ValueType), self->Name ); if ( self->ValueType->ArrExpr ) { - append_fmt( result, "[ %S ]", to_string(self->ValueType->ArrExpr) ); + string_append_fmt( result, "[ %S ]", to_string(self->ValueType->ArrExpr) ); Code next_arr_expr = self->ValueType->ArrExpr->Next; while ( next_arr_expr ) { - append_fmt( result, "[ %S ]", to_string(next_arr_expr) ); + string_append_fmt( result, "[ %S ]", to_string(next_arr_expr) ); next_arr_expr = next_arr_expr->Next; } } if ( self->BitfieldSize ) - append_fmt( result, " : %S", to_string(self->BitfieldSize) ); + string_append_fmt( result, " : %S", to_string(self->BitfieldSize) ); if ( self->Value ) { if ( self->VarConstructorInit ) - append_fmt( result, "( %S ", to_string(self->Value) ); + string_append_fmt( result, "( %S ", to_string(self->Value) ); else - append_fmt( result, " = %S", to_string(self->Value) ); + string_append_fmt( result, " = %S", to_string(self->Value) ); } if ( self->NextVar ) - append_fmt( result, ", %S", to_string(self->NextVar) ); + string_append_fmt( result, ", %S", to_string(self->NextVar) ); if ( self->VarConstructorInit ) - append( result, " )"); + string_append_strc( result, txt(" )")); if ( self->InlineCmt ) - append_fmt( result, "; %SC", self->InlineCmt->Content); + string_append_fmt( result, "; %SC", self->InlineCmt->Content); else - append( result, ";\n" ); + string_append_strc( result, txt(";\n") ); return; } if ( self->BitfieldSize ) - append_fmt( result, "%S %SC : %S", to_string(self->ValueType), self->Name, to_string(self->BitfieldSize) ); + string_append_fmt( result, "%S %SC : %S", to_string(self->ValueType), self->Name, to_string(self->BitfieldSize) ); else if ( self->ValueType->ArrExpr ) { - append_fmt( result, "%S %SC[ %S ]", to_string(self->ValueType), self->Name, to_string(self->ValueType->ArrExpr) ); + string_append_fmt( result, "%S %SC[ %S ]", to_string(self->ValueType), self->Name, to_string(self->ValueType->ArrExpr) ); Code next_arr_expr = self->ValueType->ArrExpr->Next; while ( next_arr_expr ) { - append_fmt( result, "[ %S ]", to_string(next_arr_expr) ); + string_append_fmt( result, "[ %S ]", to_string(next_arr_expr) ); next_arr_expr = next_arr_expr->Next; } } else - append_fmt( result, "%S %SC", to_string(self->ValueType), self->Name ); + string_append_fmt( result, "%S %SC", to_string(self->ValueType), self->Name ); if ( self->Value ) { if ( self->VarConstructorInit ) - append_fmt( result, "( %S ", to_string(self->Value) ); + string_append_fmt( result, "( %S ", to_string(self->Value) ); else - append_fmt( result, " = %S", to_string(self->Value) ); + string_append_fmt( result, " = %S", to_string(self->Value) ); } if ( self->NextVar ) - append_fmt( result, ", %S", to_string( self->NextVar) ); + string_append_fmt( result, ", %S", to_string( self->NextVar) ); if ( self->VarConstructorInit ) - append( result, " )"); + string_append_strc( result, txt(" )")); - append( result, ";" ); + string_append_strc( result, txt(";") ); if ( self->InlineCmt ) - append_fmt( result, " %SC", self->InlineCmt->Content); + string_append_fmt( result, " %SC", self->InlineCmt->Content); else - append( result, "\n"); + string_append_strc( result, txt("\n")); } diff --git a/project/components/inlines.hpp b/project/components/inlines.hpp index c33819e..eff9d64 100644 --- a/project/components/inlines.hpp +++ b/project/components/inlines.hpp @@ -134,7 +134,7 @@ Code begin( CodeBody body) { } inline Code end(CodeBody body ){ - return { nullptr }; + return { rcast(AST*, body.ast)->Back->Next }; } #pragma endregion CodeBody diff --git a/project/components/interface.cpp b/project/components/interface.cpp index e0d6c69..79c329d 100644 --- a/project/components/interface.cpp +++ b/project/components/interface.cpp @@ -11,7 +11,7 @@ internal void deinit(); internal void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags ) { - Arena* last = back(& Global_AllocatorBuckets); + Arena* last = array_back(& Global_AllocatorBuckets); switch ( type ) { @@ -24,13 +24,13 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s if ( bucket.PhysicalStart == nullptr ) GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets"); - if ( ! append( & Global_AllocatorBuckets, bucket ) ) + if ( ! array_append( & Global_AllocatorBuckets, bucket ) ) GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets"); - last = back(& Global_AllocatorBuckets); + last = array_back(& Global_AllocatorBuckets); } - return alloc_align( allocator_info(last), size, alignment ); + return alloc_align( arena_allocator_info(last), size, alignment ); } case EAllocation_FREE: { @@ -51,10 +51,10 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, ssize size, s if ( bucket.PhysicalStart == nullptr ) GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets"); - if ( ! append( & Global_AllocatorBuckets, bucket ) ) + if ( ! array_append( & Global_AllocatorBuckets, bucket ) ) GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets"); - last = back(& Global_AllocatorBuckets); + last = array_back(& Global_AllocatorBuckets); } void* result = alloc_align( last->Backing, size, alignment ); @@ -249,7 +249,7 @@ void init() if ( bucket.PhysicalStart == nullptr ) GEN_FATAL( "Failed to create first bucket for Global_AllocatorBuckets"); - append( & Global_AllocatorBuckets, bucket ); + array_append( & Global_AllocatorBuckets, bucket ); } // Setup the arrays @@ -272,7 +272,7 @@ void init() if ( code_pool.PhysicalStart == nullptr ) GEN_FATAL( "gen::init: Failed to initialize the code pool" ); - append( & CodePools, code_pool ); + array_append( & CodePools, code_pool ); LexArena = arena_init_from_allocator( Allocator_Lexer, LexAllocator_Size ); @@ -281,7 +281,7 @@ void init() if ( string_arena.PhysicalStart == nullptr ) GEN_FATAL( "gen::init: Failed to initialize the string arena" ); - append( & StringArenas, string_arena ); + array_append( & StringArenas, string_arena ); } // Setup the hash tables @@ -302,52 +302,52 @@ void init() void deinit() { usize index = 0; - usize left = num(CodePools); + usize left = array_num(CodePools); do { Pool* code_pool = & CodePools[index]; - free(code_pool); + pool_free(code_pool); index++; } while ( left--, left ); index = 0; - left = num(StringArenas); + left = array_num(StringArenas); do { Arena* string_arena = & StringArenas[index]; - free(string_arena); + arena_free(string_arena); index++; } while ( left--, left ); destroy(& StringCache); - free( & CodePools); - free( & StringArenas); + array_free( & CodePools); + array_free( & StringArenas); - free(& LexArena); + arena_free(& LexArena); - free(& PreprocessorDefines); + array_free(& PreprocessorDefines); index = 0; - left = num(Global_AllocatorBuckets); + left = array_num(Global_AllocatorBuckets); do { Arena* bucket = & Global_AllocatorBuckets[ index ]; - free(bucket); + arena_free(bucket); index++; } while ( left--, left ); - free(Global_AllocatorBuckets); + array_free(& Global_AllocatorBuckets); parser::deinit(); } void reset() { s32 index = 0; - s32 left = num(CodePools); + s32 left = array_num(CodePools); do { Pool* code_pool = & CodePools[index]; @@ -357,7 +357,7 @@ void reset() while ( left--, left ); index = 0; - left = num(StringArenas); + left = array_num(StringArenas); do { Arena* string_arena = & StringArenas[index]; @@ -373,7 +373,7 @@ void reset() AllocatorInfo get_string_allocator( s32 str_length ) { - Arena* last = back(& StringArenas); + Arena* last = array_back(& StringArenas); usize size_req = str_length + sizeof(StringHeader) + sizeof(char*); @@ -381,13 +381,13 @@ AllocatorInfo get_string_allocator( s32 str_length ) { Arena new_arena = arena_init_from_allocator( Allocator_StringArena, SizePer_StringArena ); - if ( ! append( & StringArenas, new_arena ) ) + if ( ! array_append( & StringArenas, new_arena ) ) GEN_FATAL( "gen::get_string_allocator: Failed to allocate a new string arena" ); - last = back(& StringArenas); + last = array_back(& StringArenas); } - return allocator_info(last); + return arena_allocator_info(last); } // Will either make or retrive a code string. @@ -402,16 +402,16 @@ StringCached get_cached_string( StrC str ) return * result; } - String result = string_make( get_string_allocator( str.Len ), str ); - set(& StringCache, key, { length(result), result } ); + String result = string_make_strc( get_string_allocator( str.Len ), str ); + set(& StringCache, key, { str.Len, result } ); - return { length(result), result }; + return { str.Len, result }; } // Used internally to retireve a Code object form the CodePool. Code make_code() { - Pool* allocator = back( & CodePools); + Pool* allocator = array_back( & CodePools); if ( allocator->FreeList == nullptr ) { Pool code_pool = pool_init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) ); @@ -419,13 +419,13 @@ Code make_code() if ( code_pool.PhysicalStart == nullptr ) GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePool allcoator returned nullptr." ); - if ( ! append( & CodePools, code_pool ) ) + if ( ! array_append( & CodePools, code_pool ) ) GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePools failed to append new pool." ); - allocator = back( & CodePools); + allocator = array_back( & CodePools); } - Code result { rcast( AST*, alloc( allocator_info(allocator), sizeof(AST) )) }; + Code result { rcast( AST*, alloc( pool_allocator_info(allocator), sizeof(AST) )) }; mem_set( result.ast, 0, sizeof(AST) ); // result->Type = ECode::Invalid; diff --git a/project/components/interface.untyped.cpp b/project/components/interface.untyped.cpp index 2c1a976..afece45 100644 --- a/project/components/interface.untyped.cpp +++ b/project/components/interface.untyped.cpp @@ -17,7 +17,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va ) char tok_map_mem[ TokenFmt_TokenMap_MemSize ]; tok_map_arena = arena_init_from_memory( tok_map_mem, sizeof(tok_map_mem) ); - tok_map = hashtable_init(StrC, allocator_info(& tok_map_arena) ); + tok_map = hashtable_init(StrC, arena_allocator_info(& tok_map_arena) ); s32 left = num_tokens - 1; @@ -94,7 +94,7 @@ ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list va ) } clear(tok_map); - free(& tok_map_arena); + arena_free(& tok_map_arena); ssize result = buf_size - remaining; @@ -142,7 +142,7 @@ Code untyped_fmt( char const* fmt, ...) Code result = make_code(); - result->Name = get_cached_string( { str_len(fmt, MaxNameLength), fmt } ); + result->Name = get_cached_string( { str_len_capped(fmt, MaxNameLength), fmt } ); result->Type = CT_Untyped; result->Content = get_cached_string( { length, buf } ); diff --git a/project/components/interface.upfront.cpp b/project/components/interface.upfront.cpp index ae386b0..fe510b6 100644 --- a/project/components/interface.upfront.cpp +++ b/project/components/interface.upfront.cpp @@ -472,23 +472,23 @@ CodeComment def_comment( StrC content ) length++; str_copy( line, scanner, length ); - append_fmt(& cmt_formatted, "//%.*s", length, line ); + string_append_fmt(& cmt_formatted, "//%.*s", length, line ); mem_set( line, 0, MaxCommentLineLength ); scanner += length; } while ( scanner <= end ); - if ( * back(& cmt_formatted) != '\n' ) - append( & cmt_formatted, "\n" ); + if ( * string_back(cmt_formatted) != '\n' ) + string_append_strc( & cmt_formatted, txt("\n") ); Code result = make_code(); result->Type = CT_Comment; - result->Name = get_cached_string( { length(cmt_formatted), cmt_formatted } ); + result->Name = get_cached_string( { string_length(cmt_formatted), cmt_formatted } ); result->Content = result->Name; - free(& cmt_formatted); + string_free(& cmt_formatted); return (CodeComment) result; } @@ -908,8 +908,8 @@ CodeInclude def_include( StrC path, Opts_def_include p ) } StrC content = p.foreign ? - to_str( str_fmt_buf( "<%.*s>", path.Len, path.Ptr )) - : to_str( str_fmt_buf( "\"%.*s\"", path.Len, path.Ptr )); + string_to_strc( str_fmt_buf( "<%.*s>", path.Len, path.Ptr )) + : string_to_strc( str_fmt_buf( "\"%.*s\"", path.Len, path.Ptr )); Code result = make_code(); diff --git a/project/components/lexer.cpp b/project/components/lexer.cpp index 92bb0a9..04948ac 100644 --- a/project/components/lexer.cpp +++ b/project/components/lexer.cpp @@ -221,7 +221,7 @@ forceinline s32 lex_preprocessor_directive( LexContext* ctx ) { char const* hash = ctx->scanner; - append( & Tokens, { hash, 1, Tok_Preprocess_Hash, ctx->line, ctx->column, TF_Preprocess } ); + array_append( & Tokens, { hash, 1, Tok_Preprocess_Hash, ctx->line, ctx->column, TF_Preprocess } ); move_forward(); SkipWhitespace(); @@ -297,14 +297,14 @@ s32 lex_preprocessor_directive( LexContext* ctx ) ctx->token.Length = ctx->token.Length + ctx->token.Text - hash; ctx->token.Text = hash; - append( & Tokens, ctx->token ); + array_append( & Tokens, ctx->token ); return Lex_Continue; // Skip found token, its all handled here. } if ( ctx->token.Type == Tok_Preprocess_Else || ctx->token.Type == Tok_Preprocess_EndIf ) { ctx->token.Flags |= TF_Preprocess_Cond; - append( & Tokens, ctx->token ); + array_append( & Tokens, ctx->token ); end_line(); return Lex_Continue; } @@ -313,7 +313,7 @@ s32 lex_preprocessor_directive( LexContext* ctx ) ctx->token.Flags |= TF_Preprocess_Cond; } - append( & Tokens, ctx->token ); + array_append( & Tokens, ctx->token ); SkipWhitespace(); @@ -337,7 +337,7 @@ s32 lex_preprocessor_directive( LexContext* ctx ) name.Length++; } - append( & Tokens, name ); + array_append( & Tokens, name ); u64 key = crc32( name.Text, name.Length ); set(& ctx->defines, key, to_str(name) ); @@ -383,7 +383,7 @@ s32 lex_preprocessor_directive( LexContext* ctx ) move_forward(); } - append( & Tokens, preprocess_content ); + array_append( & Tokens, preprocess_content ); return Lex_Continue; // Skip found token, its all handled here. } @@ -445,7 +445,7 @@ s32 lex_preprocessor_directive( LexContext* ctx ) preprocess_content.Length++; } - append( & Tokens, preprocess_content ); + array_append( & Tokens, preprocess_content ); return Lex_Continue; // Skip found token, its all handled here. } @@ -454,7 +454,7 @@ void lex_found_token( LexContext* ctx ) { if ( ctx->token.Type != Tok_Invalid ) { - append( & Tokens, ctx->token ); + array_append( & Tokens, ctx->token ); return; } @@ -481,7 +481,7 @@ void lex_found_token( LexContext* ctx ) } ctx->token.Type = type; - append( & Tokens, ctx->token ); + array_append( & Tokens, ctx->token ); return; } @@ -491,7 +491,7 @@ void lex_found_token( LexContext* ctx ) { ctx->token.Type = type; ctx->token.Flags |= TF_Specifier; - append( & Tokens, ctx->token ); + array_append( & Tokens, ctx->token ); return; } @@ -499,7 +499,7 @@ void lex_found_token( LexContext* ctx ) if ( type != Tok_Invalid ) { ctx->token.Type = type; - append( & Tokens, ctx->token ); + array_append( & Tokens, ctx->token ); return; } @@ -551,7 +551,7 @@ void lex_found_token( LexContext* ctx ) ctx->token.Type = Tok_Identifier; } - append( & Tokens, ctx->token ); + array_append( & Tokens, ctx->token ); } @@ -578,7 +578,7 @@ TokArray lex( StrC content ) return { {}, 0 }; } - foreach( StringCached*, entry, PreprocessorDefines ) + for ( StringCached* entry = array_begin(PreprocessorDefines); entry != array_end(PreprocessorDefines); array_next(PreprocessorDefines, entry)) { s32 length = 0; char const* scanner = * entry; @@ -596,7 +596,7 @@ TokArray lex( StrC content ) set(& c.defines, key, (StrC) * entry ); } - clear(Tokens); + array_clear(Tokens); while (c.left ) { @@ -626,7 +626,7 @@ TokArray lex( StrC content ) c.token.Type = Tok_NewLine; c.token.Length++; - append( & Tokens, c.token ); + array_append( & Tokens, c.token ); continue; } } @@ -1095,7 +1095,7 @@ TokArray lex( StrC content ) move_forward(); c.token.Length++; } - append( & Tokens, c.token ); + array_append( & Tokens, c.token ); continue; } else if ( current == '*' ) @@ -1131,7 +1131,7 @@ TokArray lex( StrC content ) move_forward(); c.token.Length++; } - append( & Tokens, c.token ); + array_append( & Tokens, c.token ); // end_line(); continue; } @@ -1224,9 +1224,9 @@ TokArray lex( StrC content ) } else { - s32 start = max( 0, num(Tokens) - 100 ); + s32 start = max( 0, array_num(Tokens) - 100 ); log_fmt("\n%d\n", start); - for ( s32 idx = start; idx < num(Tokens); idx++ ) + for ( s32 idx = start; idx < array_num(Tokens); idx++ ) { log_fmt( "Token %d Type: %s : %.*s\n" , idx @@ -1249,7 +1249,7 @@ TokArray lex( StrC content ) lex_found_token( ctx ); } - if ( num(Tokens) == 0 ) + if ( array_num(Tokens) == 0 ) { log_failure( "Failed to lex any tokens" ); return { {}, 0 }; diff --git a/project/components/parser.cpp b/project/components/parser.cpp index ab21a61..ff38920 100644 --- a/project/components/parser.cpp +++ b/project/components/parser.cpp @@ -50,28 +50,28 @@ String to_string(ParseContext ctx) String result = string_make_reserve( GlobalAllocator, kilobytes(4) ); Token scope_start = ctx.Scope->Start; - Token last_valid = ctx.Tokens.Idx >= num(ctx.Tokens.Arr) ? ctx.Tokens.Arr[num(ctx.Tokens.Arr) -1] : (* current(& ctx.Tokens, true)); + Token last_valid = ctx.Tokens.Idx >= array_num(ctx.Tokens.Arr) ? ctx.Tokens.Arr[array_num(ctx.Tokens.Arr) -1] : (* current(& ctx.Tokens, true)); sptr length = scope_start.Length; char const* current = scope_start.Text + length; - while ( current <= back( & ctx.Tokens.Arr)->Text && *current != '\n' && length < 74 ) + while ( current <= array_back( & ctx.Tokens.Arr)->Text && *current != '\n' && length < 74 ) { current++; length++; } - String line = string_make( GlobalAllocator, { length, scope_start.Text } ); - append_fmt( & result, "\tScope : %s\n", line ); - free(& line); + String line = string_make_strc( GlobalAllocator, { length, scope_start.Text } ); + string_append_fmt( & result, "\tScope : %s\n", line ); + string_free(& line); sptr dist = (sptr)last_valid.Text - (sptr)scope_start.Text + 2; sptr length_from_err = dist; - String line_from_err = string_make( GlobalAllocator, { length_from_err, last_valid.Text } ); + String line_from_err = string_make_strc( GlobalAllocator, { length_from_err, last_valid.Text } ); if ( length_from_err < 100 ) - append_fmt(& result, "\t(%d, %d):%*c\n", last_valid.Line, last_valid.Column, length_from_err, '^' ); + string_append_fmt(& result, "\t(%d, %d):%*c\n", last_valid.Line, last_valid.Column, length_from_err, '^' ); else - append_fmt(& result, "\t(%d, %d)\n", last_valid.Line, last_valid.Column ); + string_append_fmt(& result, "\t(%d, %d)\n", last_valid.Line, last_valid.Column ); StackNode* curr_scope = ctx.Scope; s32 level = 0; @@ -79,11 +79,11 @@ String to_string(ParseContext ctx) { if ( is_valid(curr_scope->Name) ) { - append_fmt(& result, "\t%d: %s, AST Name: %.*s\n", level, curr_scope->ProcName.Ptr, curr_scope->Name.Length, curr_scope->Name.Text ); + string_append_fmt(& result, "\t%d: %s, AST Name: %.*s\n", level, curr_scope->ProcName.Ptr, curr_scope->Name.Length, curr_scope->Name.Text ); } else { - append_fmt(& result, "\t%d: %s\n", level, curr_scope->ProcName.Ptr ); + string_append_fmt(& result, "\t%d: %s\n", level, curr_scope->ProcName.Ptr ); } curr_scope = curr_scope->Prev; @@ -97,7 +97,7 @@ global ParseContext Context; bool __eat(TokArray* self, TokType type ) { - if ( num(self->Arr) - self->Idx <= 0 ) + if ( array_num(self->Arr) - self->Idx <= 0 ) { log_failure( "No tokens left.\n%s", to_string(Context) ); return false; @@ -136,12 +136,12 @@ bool __eat(TokArray* self, TokType type ) internal void init() { - Tokens = array_init_reserve( allocator_info( & LexArena) + Tokens = array_init_reserve(Token, arena_allocator_info( & LexArena) , ( LexAllocator_Size - sizeof( ArrayHeader ) ) / sizeof(Token) ); fixed_arena_init(& defines_map_arena); - defines = hashtable_init_reserve( allocator_info( & defines_map_arena), 256 ); + defines = hashtable_init_reserve(StrC, allocator_info( & defines_map_arena), 256 ); } internal @@ -175,7 +175,7 @@ bool _check_parse_args( StrC def, char const* func_name ) # define prevtok (* previous( Context.Tokens, dont_skip_formatting)) # define nexttok (* next( Context.Tokens, skip_formatting )) # define eat( Type_ ) __eat( & Context.Tokens, Type_ ) -# define left ( num(Context.Tokens.Arr) - Context.Tokens.Idx ) +# define left ( array_num(Context.Tokens.Arr) - Context.Tokens.Idx ) #ifdef check #define CHECK_WAS_DEFINED @@ -298,7 +298,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true ) if ( tokleft ) move_fwd(); - append( & content, cut_ptr, cut_length ); + string_append_c_str_len( & content, cut_ptr, cut_length ); last_cut = sptr( scanner ) - sptr( raw_text.Ptr ); continue; } @@ -320,7 +320,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true ) if ( tokleft ) move_fwd(); - append( & content, cut_ptr, cut_length ); + string_append_c_str_len( & content, cut_ptr, cut_length ); last_cut = sptr( scanner ) - sptr( raw_text.Ptr ); continue; } @@ -334,7 +334,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true ) scanner += 2; tokleft -= 2; - append( & content, cut_ptr, cut_length ); + string_append_c_str_len( & content, cut_ptr, cut_length ); last_cut = sptr( scanner ) - sptr( raw_text.Ptr ); continue; } @@ -353,7 +353,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true ) if (tokleft) move_fwd(); - append( & content, cut_ptr, cut_length ); + string_append_c_str_len( & content, cut_ptr, cut_length ); last_cut = sptr( scanner ) - sptr( raw_text.Ptr ); continue; } @@ -362,10 +362,10 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true ) if (scanner[0] == '\t') { if (pos > last_cut) - append( & content, cut_ptr, cut_length); + string_append_c_str_len( & content, cut_ptr, cut_length); - if ( * back( & content ) != ' ' ) - append( & content, ' '); + if ( * string_back( content ) != ' ' ) + string_append_strc( & content, txt(' ')); move_fwd(); last_cut = sptr(scanner) - sptr(raw_text.Ptr); @@ -381,17 +381,17 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true ) scanner += 2; tokleft -= 2; - append( & content, cut_ptr, cut_length ); + string_append_c_str_len( & content, cut_ptr, cut_length ); last_cut = sptr( scanner ) - sptr( raw_text.Ptr ); continue; } if ( pos > last_cut ) - append( & content, cut_ptr, cut_length ); + string_append_c_str_len( & content, cut_ptr, cut_length ); // Replace with a space - if ( * back( & content ) != ' ' ) - append( & content, ' ' ); + if ( * string_back( content ) != ' ' ) + string_append_strc( & content, txt(' ') ); scanner += 2; tokleft -= 2; @@ -408,17 +408,17 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true ) move_fwd(); - append( & content, cut_ptr, cut_length ); + string_append_c_str_len( & content, cut_ptr, cut_length ); last_cut = sptr( scanner ) - sptr( raw_text.Ptr ); continue; } if ( pos > last_cut ) - append( & content, cut_ptr, cut_length ); + string_append_c_str_len( & content, cut_ptr, cut_length ); // Replace with a space if ( * back( & content ) != ' ' ) - append( & content, ' ' ); + string_append_strc( & content, txt(' ') ); move_fwd(); @@ -429,7 +429,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true ) // Escaped newlines if ( scanner[0] == '\\' ) { - append( & content, cut_ptr, cut_length ); + string_append_c_str_len( & content, cut_ptr, cut_length ); s32 amount_to_skip = 1; if ( tokleft > 1 && scanner[1] == '\n' ) @@ -456,7 +456,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true ) // Consectuive spaces if ( tokleft > 1 && char_is_space( scanner[0] ) && char_is_space( scanner[ 1 ] ) ) { - append( & content, cut_ptr, cut_length ); + string_append_c_str_len( & content, cut_ptr, cut_length ); do { move_fwd(); @@ -468,7 +468,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true ) // Preserve only 1 space of formattting char* last = back(& content); if ( last == nullptr || * last != ' ' ) - append( & content, ' ' ); + string_append_strc( & content, txt(' ') ); continue; } @@ -478,7 +478,7 @@ String strip_formatting( StrC raw_text, bool preserve_newlines = true ) if ( last_cut < raw_text.Len ) { - append( & content, cut_ptr, raw_text.Len - last_cut ); + string_append_c_str_len( & content, cut_ptr, raw_text.Len - last_cut ); } #undef cut_ptr @@ -669,7 +669,7 @@ CodeAttributes parse_attributes() Code result = make_code(); result->Type = CT_PlatformAttributes; - result->Name = get_cached_string( { length(name_stripped), name_stripped } ); + result->Name = get_cached_string( { string_length(name_stripped), name_stripped } ); result->Content = result->Name; // result->Token = @@ -723,7 +723,7 @@ Code parse_class_struct( TokType which, bool inplace_def = false ) char interface_arr_mem[ kilobytes(4) ] {0}; Array interfaces; { Arena arena = arena_init_from_memory( interface_arr_mem, kilobytes(4) ); - interfaces = array_init_reserve( allocator_info(& arena), 4 ); + interfaces = array_init_reserve(CodeTypename, arena_allocator_info(& arena), 4 ); } // TODO(Ed) : Make an AST_DerivedType, we'll store any arbitary derived type into there as a linear linked list of them. @@ -754,7 +754,7 @@ Code parse_class_struct( TokType which, bool inplace_def = false ) } Token interface_tok = parse_identifier(); - append( & interfaces, def_type( to_str(interface_tok) ) ); + array_append( & interfaces, def_type( to_str(interface_tok) ) ); // : , ... } } @@ -786,7 +786,7 @@ Code parse_class_struct( TokType which, bool inplace_def = false ) if ( inline_cmt ) result->InlineCmt = inline_cmt; - free(& interfaces); + array_free(& interfaces); return result; } @@ -1048,9 +1048,9 @@ CodeBody parse_class_struct_body( TokType which, Token name ) if ( attributes ) { String fused = string_make_reserve( GlobalAllocator, attributes->Content.Len + more_attributes->Content.Len ); - append_fmt( & fused, "%S %S", attributes->Content, more_attributes->Content ); + string_append_fmt( & fused, "%S %S", attributes->Content, more_attributes->Content ); - attributes->Name = get_cached_string({ length(fused), fused }); + attributes->Name = get_cached_string( { string_length(fused), fused }); attributes->Content = attributes->Name; // } @@ -1086,7 +1086,7 @@ CodeBody parse_class_struct_body( TokType which, Token name ) { if ( nexttok.Type == Tok_Capture_Start && name.Length && currtok.Type == Tok_Identifier ) { - if ( str_compare( name.Text, currtok.Text, name.Length ) == 0 ) + if ( str_compare_len( name.Text, currtok.Text, name.Length ) == 0 ) { member = parse_constructor( specifiers ); // () @@ -1159,7 +1159,7 @@ Code parse_complicated_definition( TokType which ) s32 idx = tokens.Idx; s32 level = 0; - for ( ; idx < num(tokens.Arr); idx++ ) + for ( ; idx < array_num(tokens.Arr); idx++ ) { if ( tokens.Arr[ idx ].Type == Tok_BraceCurly_Open ) level++; @@ -1344,7 +1344,7 @@ CodeDefine parse_define() return define; } - define->Content = get_cached_string( to_strc( strip_formatting( to_str(currtok), strip_formatting_dont_preserve_newlines )) ); + define->Content = get_cached_string( string_to_strc( strip_formatting( to_str(currtok), strip_formatting_dont_preserve_newlines )) ); eat( Tok_Preprocess_Content ); // #define @@ -1489,12 +1489,12 @@ CodeFn parse_function_after_name( } String - name_stripped = string_make( GlobalAllocator, to_str(name) ); + name_stripped = string_make_strc( GlobalAllocator, to_str(name) ); strip_space(name_stripped); CodeFn result = (CodeFn) make_code(); - result->Name = get_cached_string( to_strc(name_stripped) ); + result->Name = get_cached_string( string_to_strc(name_stripped) ); result->ModuleFlags = mflags; if ( body ) @@ -1840,7 +1840,7 @@ CodeBody parse_global_nspace( CodeType which ) bool found_operator_cast_outside_class_implmentation = false; s32 idx = Context.Tokens.Idx; - for ( ; idx < num(Context.Tokens.Arr); idx++ ) + for ( ; idx < array_num(Context.Tokens.Arr); idx++ ) { Token tok = Context.Tokens.Arr[ idx ]; @@ -1912,14 +1912,14 @@ Code parse_global_nspace_constructor_destructor( CodeSpecifiers specifiers ) s32 idx = tokens.Idx; Token nav = tokens.Arr[ idx ]; - for ( ; idx < num(tokens.Arr); idx++, nav = tokens.Arr[ idx ] ) + for ( ; idx < array_num(tokens.Arr); idx++, nav = tokens.Arr[ idx ] ) { if ( nav.Text[0] == '<' ) { // Skip templated expressions as they mey have expressions with the () operators s32 capture_level = 0; s32 template_level = 0; - for ( ; idx < num(tokens.Arr); idx++, nav = tokens.Arr[idx] ) + for ( ; idx < array_num(tokens.Arr); idx++, nav = tokens.Arr[idx] ) { if (nav.Text[ 0 ] == '<') ++ template_level; @@ -2001,7 +2001,7 @@ Code parse_global_nspace_constructor_destructor( CodeSpecifiers specifiers ) tok_left = tokens.Arr[idx]; } - bool is_same = str_compare( tok_right.Text, tok_left.Text, tok_right.Length ) == 0; + bool is_same = str_compare_len( tok_right.Text, tok_left.Text, tok_right.Length ) == 0; if (tok_left.Type == Tok_Identifier && is_same) { // We have found the pattern we desired @@ -2357,7 +2357,7 @@ CodeOperator parse_operator_after_ret_type( { StrC str_new = to_str(Op_New); StrC str_delete = to_str(Op_Delete); - if ( str_compare( currtok.Text, str_new.Ptr, max(str_new.Len - 1, currtok.Length)) == 0) + if ( str_compare_len( currtok.Text, str_new.Ptr, max(str_new.Len - 1, currtok.Length)) == 0) { op = Op_New; eat( Tok_Identifier ); @@ -2369,7 +2369,7 @@ CodeOperator parse_operator_after_ret_type( idx++; } Token next = Context.Tokens.Arr[idx]; - if ( currtok.Type == Tok_Operator && str_compare(currtok.Text, "[]", 2) == 0) + if ( currtok.Type == Tok_Operator && str_compare_len(currtok.Text, "[]", 2) == 0) { eat(Tok_Operator); op = Op_NewArray; @@ -2381,7 +2381,7 @@ CodeOperator parse_operator_after_ret_type( op = Op_NewArray; } } - else if ( str_compare( currtok.Text, str_delete.Ptr, max(str_delete.Len - 1, currtok.Length )) == 0) + else if ( str_compare_len( currtok.Text, str_delete.Ptr, max(str_delete.Len - 1, currtok.Length )) == 0) { op = Op_Delete; eat(Tok_Identifier); @@ -2393,7 +2393,7 @@ CodeOperator parse_operator_after_ret_type( idx++; } Token next = Context.Tokens.Arr[idx]; - if ( currtok.Type == Tok_Operator && str_compare(currtok.Text, "[]", 2) == 0) + if ( currtok.Type == Tok_Operator && str_compare_len(currtok.Text, "[]", 2) == 0) { eat(Tok_Operator); op = Op_DeleteArray; @@ -2513,7 +2513,7 @@ Code parse_operator_function_or_variable( bool expects_function, CodeAttributes bool found_operator = false; s32 idx = Context.Tokens.Idx; - for ( ; idx < num(Context.Tokens.Arr); idx++ ) + for ( ; idx < array_num(Context.Tokens.Arr); idx++ ) { Token tok = Context.Tokens.Arr[ idx ]; @@ -2730,7 +2730,7 @@ CodeParam parse_params( bool use_template_capture ) eat( currtok.Type ); } - value = untyped_str( to_strc(strip_formatting( to_str(value_tok), strip_formatting_dont_preserve_newlines )) ); + value = untyped_str( string_to_strc(strip_formatting( to_str(value_tok), strip_formatting_dont_preserve_newlines )) ); // ( = } } @@ -2845,7 +2845,7 @@ CodeParam parse_params( bool use_template_capture ) eat( currtok.Type ); } - value = untyped_str( to_strc(strip_formatting( to_str(value_tok), strip_formatting_dont_preserve_newlines )) ); + value = untyped_str( string_to_strc(strip_formatting( to_str(value_tok), strip_formatting_dont_preserve_newlines )) ); // ( = , = } // ( = , = , .. @@ -2957,7 +2957,7 @@ Code parse_simple_preprocess( TokType which ) // { } StrC prev_proc = Context.Scope->Prev->ProcName; - if ( str_compare( prev_proc.Ptr, "parse_typedef", prev_proc.Len ) != 0 ) + if ( str_compare_len( prev_proc.Ptr, "parse_typedef", prev_proc.Len ) != 0 ) { if ( check( Tok_Statement_End )) { @@ -2975,7 +2975,7 @@ Code parse_simple_preprocess( TokType which ) } else { - if ( str_compare( Context.Scope->Prev->ProcName.Ptr, "parse_typedef", Context.Scope->Prev->ProcName.Len ) != 0 ) + if ( str_compare_len( Context.Scope->Prev->ProcName.Ptr, "parse_typedef", Context.Scope->Prev->ProcName.Len ) != 0 ) { if ( check( Tok_Statement_End )) { @@ -2994,7 +2994,7 @@ Code parse_simple_preprocess( TokType which ) char const* content = str_fmt_buf( "%.*s ", tok.Length, tok.Text ); - Code result = untyped_str( GEN_NS to_str(content) ); + Code result = untyped_str( to_strc_from_c_str(content) ); Context.Scope->Name = tok; pop(& Context); @@ -3494,7 +3494,7 @@ CodeDestructor parse_destructor( CodeSpecifiers specifiers ) append(specifiers, Spec_Pure ); } - else if ( left && str_compare( upcoming.Text, "default", sizeof("default") - 1 ) == 0) + else if ( left && str_compare_len( upcoming.Text, "default", sizeof("default") - 1 ) == 0) { body = parse_assignment_expression(); // ~< @@ -3609,7 +3609,7 @@ CodeEnum parse_enum( bool inplace_def ) // We'll support the enum_underlying macro StrC sig = txt("enum_underlying"); - if (currtok.Length >= sig.Len && str_compare(currtok.Text, sig.Ptr, sig.Len) == 0 ) + if (currtok.Length >= sig.Len && str_compare_len(currtok.Text, sig.Ptr, sig.Len) == 0 ) { use_macro_underlying = true; underlying_macro = parse_simple_preprocess( Tok_Preprocess_Macro); @@ -4375,7 +4375,7 @@ CodeTemplate parse_template() bool found_operator_cast_outside_class_implmentation = false; s32 idx = Context.Tokens.Idx; - for ( ; idx < num(Context.Tokens.Arr); idx++ ) + for ( ; idx < array_num(Context.Tokens.Arr); idx++ ) { Token tok = Context.Tokens.Arr[ idx ]; @@ -4829,7 +4829,7 @@ else if ( currtok.Type == Tok_DeclType ) } #endif - result->Name = get_cached_string( to_strc(name_stripped) ); + result->Name = get_cached_string( string_to_strc(name_stripped) ); if ( attributes ) result->Attributes = attributes; @@ -4924,7 +4924,7 @@ CodeTypedef parse_typedef() s32 idx = tokens.Idx; s32 level = 0; - for ( ; idx < num(tokens.Arr); idx ++ ) + for ( ; idx < array_num(tokens.Arr); idx ++ ) { if ( tokens.Arr[idx].Type == Tok_BraceCurly_Open ) level++; diff --git a/project/dependencies/containers.hpp b/project/dependencies/containers.hpp index 19c2e9b..acfa5c6 100644 --- a/project/dependencies/containers.hpp +++ b/project/dependencies/containers.hpp @@ -31,23 +31,23 @@ usize array_grow_formula(ssize value); template Array(Type) array_init (AllocatorInfo allocator); template Array(Type) array_init_reserve(AllocatorInfo allocator, ssize capacity); -template bool append (Array(Type)* array, Array(Type) other); -template bool append (Array(Type)* array, Type value); -template bool append (Array(Type)* array, Type* items, usize item_num); -template bool append_at (Array(Type)* array, Type item, usize idx); -template bool append_at (Array(Type)* array, Type* items, usize item_num, usize idx); -template Type* back (Array(Type) array); -template void clear (Array(Type) array); -template bool fill (Array(Type) array, usize begin, usize end, Type value); -template void free (Array(Type)* array); -template bool grow (Array(Type)* array, usize min_capacity); -template usize num (Array(Type) array); -template void pop (Array(Type) array); -template void remove_at (Array(Type) array, usize idx); -template bool reserve (Array(Type)* array, usize new_capacity); -template bool resize (Array(Type)* array, usize num); -template bool set_capacity (Array(Type)* array, usize new_capacity); -template ArrayHeader* get_header (Array(Type) array); +template bool array_append (Array(Type)* array, Array(Type) other); +template bool array_append (Array(Type)* array, Type value); +template bool array_append (Array(Type)* array, Type* items, usize item_num); +template bool array_append_at (Array(Type)* array, Type item, usize idx); +template bool array_append_at (Array(Type)* array, Type* items, usize item_num, usize idx); +template Type* array_back (Array(Type) array); +template void array_clear (Array(Type) array); +template bool array_fill (Array(Type) array, usize begin, usize end, Type value); +template void array_free (Array(Type)* array); +template bool arary_grow (Array(Type)* array, usize min_capacity); +template usize array_num (Array(Type) array); +template void arary_pop (Array(Type) array); +template void arary_remove_at (Array(Type) array, usize idx); +template bool arary_reserve (Array(Type)* array, usize new_capacity); +template bool arary_resize (Array(Type)* array, usize num); +template bool arary_set_capacity(Array(Type)* array, usize new_capacity); +template ArrayHeader* arary_get_header (Array(Type) array); struct ArrayHeader { AllocatorInfo Allocator; @@ -66,23 +66,23 @@ struct Array forceinline static Array init_reserve(AllocatorInfo allocator, ssize capacity) { return GEN_NS array_init_reserve(allocator, capacity); } forceinline static usize grow_formula(ssize value) { return GEN_NS array_grow_formula(value); } - forceinline bool append(Array other) { return GEN_NS append(this, other); } - forceinline bool append(Type value) { return GEN_NS append(this, value); } - forceinline bool append(Type* items, usize item_num) { return GEN_NS append(this, items, item_num); } - forceinline bool append_at(Type item, usize idx) { return GEN_NS append_at(this, item, idx); } - forceinline bool append_at(Type* items, usize item_num, usize idx) { return GEN_NS append_at(this, items, item_num, idx); } - forceinline Type* back() { return GEN_NS back(* this); } - forceinline void clear() { GEN_NS clear(* this); } - forceinline bool fill(usize begin, usize end, Type value) { return GEN_NS fill(* this, begin, end, value); } - forceinline void free() { GEN_NS free(this); } - forceinline ArrayHeader* get_header() { return GEN_NS get_header(* this); } - forceinline bool grow(usize min_capacity) { return GEN_NS grow(this, min_capacity); } - forceinline usize num() { return GEN_NS num(*this); } - forceinline void pop() { GEN_NS pop(* this); } - forceinline void remove_at(usize idx) { GEN_NS remove_at(* this, idx); } - forceinline bool reserve(usize new_capacity) { return GEN_NS reserve(this, new_capacity); } - forceinline bool resize(usize num) { return GEN_NS resize(this, num); } - forceinline bool set_capacity(usize new_capacity) { return GEN_NS set_capacity(this, new_capacity); } + forceinline bool append(Array other) { return GEN_NS array_append(this, other); } + forceinline bool append(Type value) { return GEN_NS array_append(this, value); } + forceinline bool append(Type* items, usize item_num) { return GEN_NS array_append(this, items, item_num); } + forceinline bool append_at(Type item, usize idx) { return GEN_NS array_append_at(this, item, idx); } + forceinline bool append_at(Type* items, usize item_num, usize idx) { return GEN_NS array_append_at(this, items, item_num, idx); } + forceinline Type* back() { return GEN_NS array_back(* this); } + forceinline void clear() { GEN_NS array_clear(* this); } + forceinline bool fill(usize begin, usize end, Type value) { return GEN_NS array_fill(* this, begin, end, value); } + forceinline void free() { GEN_NS array_free(this); } + forceinline ArrayHeader* get_header() { return GEN_NS array_get_header(* this); } + forceinline bool grow(usize min_capacity) { return GEN_NS array_grow(this, min_capacity); } + forceinline usize num() { return GEN_NS array_num(*this); } + forceinline void pop() { GEN_NS array_pop(* this); } + forceinline void remove_at(usize idx) { GEN_NS array_remove_at(* this, idx); } + forceinline bool reserve(usize new_capacity) { return GEN_NS array_reserve(this, new_capacity); } + forceinline bool resize(usize num) { return GEN_NS array_resize(this, num); } + forceinline bool set_capacity(usize new_capacity) { return GEN_NS array_set_capacity(this, new_capacity); } #pragma endregion Member Mapping forceinline operator Type*() { return Data; } @@ -108,14 +108,14 @@ template bool resize(Array& array, usize num) template bool set_capacity(Array& array, usize new_capacity) { return GEN_NS set_capacity( & array, new_capacity); } template forceinline Type* begin(Array& array) { return array; } -template forceinline Type* end(Array& array) { return array + get_header(array)->Num; } +template forceinline Type* end(Array& array) { return array + array_get_header(array)->Num; } template forceinline Type* next(Array& array, Type* entry) { return entry + 1; } -#else -template forceinline Type* begin(Array array) { return array; } -template forceinline Type* end(Array array) { return array + get_header(array)->Num; } -template forceinline Type* next(Array array, Type* entry) { return entry + 1; } #endif +template forceinline Type* array_begin(Array array) { return array; } +template forceinline Type* array_end(Array array) { return array + array_get_header(array)->Num; } +template forceinline Type* array_next(Array array, Type* entry) { return entry + 1; } + template inline Array array_init(AllocatorInfo allocator) { return array_init_reserve(allocator, array_grow_formula(0)); @@ -141,20 +141,20 @@ usize array_grow_formula(ssize value) { } template inline -bool append(Array* array, Array other) { +bool array_append(Array* array, Array other) { return append(array, other, num(other)); } template inline -bool append(Array* array, Type value) +bool array_append(Array* array, Type value) { - ArrayHeader* header = get_header(* array); + ArrayHeader* header = array_get_header(* array); if (header->Num == header->Capacity) { - if ( ! grow(array, header->Capacity)) + if ( ! array_grow(array, header->Capacity)) return false; - header = get_header(* array); + header = array_get_header(* array); } (*array)[ header->Num] = value; @@ -164,15 +164,15 @@ bool append(Array* array, Type value) } template inline -bool append(Array* array, Type* items, usize item_num) +bool array_append(Array* array, Type* items, usize item_num) { - ArrayHeader* header = get_header(array); + ArrayHeader* header = array_get_header(array); if (header->Num + item_num > header->Capacity) { if ( ! grow(array, header->Capacity + item_num)) return false; - header = get_header(array); + header = array_get_header(array); } mem_copy((Type*)array + header->Num, items, item_num * sizeof(Type)); @@ -182,9 +182,9 @@ bool append(Array* array, Type* items, usize item_num) } template inline -bool append_at(Array* array, Type item, usize idx) +bool array_append_at(Array* array, Type item, usize idx) { - ArrayHeader* header = get_header(* array); + ArrayHeader* header = array_get_header(* array); ssize slot = idx; if (slot >= header->Num) @@ -195,10 +195,10 @@ bool append_at(Array* array, Type item, usize idx) if (header->Capacity < header->Num + 1) { - if ( ! grow(array, header->Capacity + 1)) + if ( ! array_grow(array, header->Capacity + 1)) return false; - header = get_header(* array); + header = array_get_header(* array); } Type* target = &(*array)[slot]; @@ -206,13 +206,13 @@ bool append_at(Array* array, Type item, usize idx) mem_move(target + 1, target, (header->Num - slot) * sizeof(Type)); header->Num++; - header = get_header(* array); + header = array_get_header(* array); return true; } template inline -bool append_at(Array* array, Type* items, usize item_num, usize idx) +bool array_append_at(Array* array, Type* items, usize item_num, usize idx) { ArrayHeader* header = get_header(array); @@ -240,11 +240,11 @@ bool append_at(Array* array, Type* items, usize item_num, usize idx) } template inline -Type* back(Array* array) +Type* array_back(Array* array) { GEN_ASSERT(array != nullptr); - ArrayHeader* header = get_header(* array); + ArrayHeader* header = array_get_header(* array); if (header->Num <= 0) return nullptr; @@ -252,15 +252,15 @@ Type* back(Array* array) } template inline -void clear(Array array) { - ArrayHeader* header = get_header(array); +void array_clear(Array array) { + ArrayHeader* header = array_get_header(array); header->Num = 0; } template inline -bool fill(Array array, usize begin, usize end, Type value) +bool array_fill(Array array, usize begin, usize end, Type value) { - ArrayHeader* header = get_header(array); + ArrayHeader* header = array_get_header(array); if (begin < 0 || end > header->Num) return false; @@ -274,49 +274,49 @@ bool fill(Array array, usize begin, usize end, Type value) } template inline -void free(Array* array) { +void array_free(Array* array) { GEN_ASSERT(array != nullptr); - ArrayHeader* header = get_header(* array); - GEN_NS free(header->Allocator, header); + ArrayHeader* header = array_get_header(* array); + allocator_free(header->Allocator, header); Type** Data = (Type**)array; *Data = nullptr; } template forceinline -ArrayHeader* get_header(Array array) { +ArrayHeader* array_get_header(Array array) { Type* Data = array; using NonConstType = TRemoveConst; return rcast(ArrayHeader*, const_cast(Data)) - 1; } template inline -bool grow(Array* array, usize min_capacity) +bool array_grow(Array* array, usize min_capacity) { - ArrayHeader* header = get_header(* array); + ArrayHeader* header = array_get_header(* array); usize new_capacity = array_grow_formula(header->Capacity); if (new_capacity < min_capacity) new_capacity = min_capacity; - return set_capacity(array, new_capacity); + return array_set_capacity(array, new_capacity); } template inline -usize num(Array array) { - return get_header(array)->Num; +usize array_num(Array array) { + return array_get_header(array)->Num; } template inline -void pop(Array array) { - ArrayHeader* header = get_header(array); +void array_pop(Array array) { + ArrayHeader* header = array_get_header(array); GEN_ASSERT(header->Num > 0); header->Num--; } template inline -void remove_at(Array array, usize idx) +void array_remove_at(Array array, usize idx) { - ArrayHeader* header = get_header(array); + ArrayHeader* header = array_get_header(array); GEN_ASSERT(idx < header->Num); mem_move(array + idx, array + idx + 1, sizeof(Type) * (header->Num - idx - 1)); @@ -324,9 +324,9 @@ void remove_at(Array array, usize idx) } template inline -bool reserve(Array* array, usize new_capacity) +bool array_reserve(Array* array, usize new_capacity) { - ArrayHeader* header = get_header(array); + ArrayHeader* header = array_get_header(array); if (header->Capacity < new_capacity) return set_capacity(array, new_capacity); @@ -335,14 +335,14 @@ bool reserve(Array* array, usize new_capacity) } template inline -bool resize(Array* array, usize num) +bool array_resize(Array* array, usize num) { - ArrayHeader* header = get_header(* array); + ArrayHeader* header = array_get_header(* array); if (header->Capacity < num) { - if (! grow( array, num)) + if (! array_grow( array, num)) return false; - header = get_header(* array); + header = array_get_header(* array); } header->Num = num; @@ -350,9 +350,9 @@ bool resize(Array* array, usize num) } template inline -bool set_capacity(Array* array, usize new_capacity) +bool array_set_capacity(Array* array, usize new_capacity) { - ArrayHeader* header = get_header(* array); + ArrayHeader* header = array_get_header(* array); if (new_capacity == header->Capacity) return true; @@ -373,13 +373,15 @@ bool set_capacity(Array* array, usize new_capacity) new_header->Capacity = new_capacity; - GEN_NS free(header->Allocator, header); + allocator_free(header->Allocator, header); Type** Data = (Type**)array; * Data = rcast(Type*, new_header + 1); return true; } +#define array_init_reserve(type, allocator, cap) array_init_reserve(allocator, cap) + #pragma endregion Array // TODO(Ed) : This thing needs ALOT of work. @@ -471,9 +473,9 @@ HashTable hashtable_init_reserve(AllocatorInfo allocator, usize num) HashTable result = { { nullptr }, { nullptr } }; result.Hashes = array_init_reserve(allocator, num); - get_header(result.Hashes)->Num = num; - resize(& result.Hashes, num); - fill(result.Hashes, 0, num, -1); + array_get_header(result.Hashes)->Num = num; + array_resize(& result.Hashes, num); + array_fill(result.Hashes, 0, num, -1); result.Entries = array_init_reserve>(allocator, num); return result; @@ -481,15 +483,15 @@ HashTable hashtable_init_reserve(AllocatorInfo allocator, usize num) template inline void clear(HashTable table) { - clear(table.Entries); - fill(table.Hashes, 0, num(table.Hashes), -1); + array_clear(table.Entries); + array_fill(table.Hashes, 0, array_num(table.Hashes), (ssize)-1); } template inline void destroy(HashTable* table) { - if (table->Hashes && get_header(table->Hashes)->Capacity) { - free(& table->Hashes); - free(& table->Entries); + if (table->Hashes && array_get_header(table->Hashes)->Capacity) { + array_free(& table->Hashes); + array_free(& table->Entries); } } @@ -522,7 +524,7 @@ void map_mut(HashTable table, void (*map_proc)(u64 key, Type* value)) { template inline void grow(HashTable* table) { - ssize new_num = array_grow_formula(num(table->Entries)); + ssize new_num = array_grow_formula( array_num(table->Entries)); rehash(table, new_num); } @@ -530,9 +532,9 @@ template inline void rehash(HashTable* table, ssize new_num) { ssize last_added_index; - HashTable new_ht = hashtable_init_reserve(get_header(table->Hashes)->Allocator, new_num); + HashTable new_ht = hashtable_init_reserve( array_get_header(table->Hashes)->Allocator, new_num); - for (ssize idx = 0; idx < ssize(num(table->Entries)); ++idx) + for (ssize idx = 0; idx < ssize( array_num(table->Entries)); ++idx) { HashTableFindResult find_result; HashTableEntry& entry = table->Entries[idx]; @@ -639,8 +641,8 @@ ssize add_entry(HashTable* table, u64 key) { ssize idx; HashTableEntry entry = { key, -1 }; - idx = num(table->Entries); - append( & table->Entries, entry); + idx = array_num(table->Entries); + array_append( & table->Entries, entry); return idx; } @@ -649,9 +651,9 @@ HashTableFindResult find(HashTable table, u64 key) { HashTableFindResult result = { -1, -1, -1 }; - if (num(table.Hashes) > 0) + if (array_num(table.Hashes) > 0) { - result.HashIndex = key % num(table.Hashes); + result.HashIndex = key % array_num(table.Hashes); result.EntryIndex = table.Hashes[result.HashIndex]; while (result.EntryIndex >= 0) @@ -669,8 +671,8 @@ HashTableFindResult find(HashTable table, u64 key) template inline bool full(HashTable table) { - usize critical_load = usize(HashTable_CriticalLoadScale * f32(num(table.Hashes))); - b32 result = num(table.Entries) > critical_load; + usize critical_load = usize(HashTable_CriticalLoadScale * f32(array_num(table.Hashes))); + b32 result = array_num(table.Entries) > critical_load; return result; } diff --git a/project/dependencies/debug.hpp b/project/dependencies/debug.hpp index 3b041bd..3e20c74 100644 --- a/project/dependencies/debug.hpp +++ b/project/dependencies/debug.hpp @@ -56,8 +56,10 @@ while (0) #endif +GEN_API_C_BEGIN void assert_handler( char const* condition, char const* file, s32 line, char const* msg, ... ); s32 assert_crash( char const* condition ); void process_exit( u32 code ); +GEN_API_C_END #pragma endregion Debug diff --git a/project/dependencies/filesystem.cpp b/project/dependencies/filesystem.cpp index 683972b..832288d 100644 --- a/project/dependencies/filesystem.cpp +++ b/project/dependencies/filesystem.cpp @@ -36,7 +36,7 @@ wchar_t* _alloc_utf8_to_ucs2( AllocatorInfo a, char const* text, ssize* w_len_ ) w_len1 = MultiByteToWideChar( CP_UTF8, MB_ERR_INVALID_CHARS, text, scast( int, len), w_text, scast( int, w_len) ); if ( w_len1 == 0 ) { - free( a, w_text ); + allocator_free( a, w_text ); if ( w_len_ ) *w_len_ = 0; return NULL; @@ -145,7 +145,7 @@ GEN_FILE_OPEN_PROC( _win32_file_open ) w_text = _alloc_utf8_to_ucs2( heap(), filename, NULL ); handle = CreateFileW( w_text, desired_access, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, creation_disposition, FILE_ATTRIBUTE_NORMAL, NULL ); - free( heap(), w_text ); + allocator_free( heap(), w_text ); if ( handle == INVALID_HANDLE_VALUE ) { @@ -340,7 +340,7 @@ FileError file_close( FileInfo* f ) return EFileError_INVALID; if ( f->filename ) - free( heap(), ccast( char*, f->filename )); + allocator_free( heap(), ccast( char*, f->filename )); #if defined( GEN_SYSTEM_WINDOWS ) if ( f->fd.p == INVALID_HANDLE_VALUE ) @@ -540,7 +540,7 @@ b8 file_stream_open( FileInfo* file, AllocatorInfo allocator, u8* buffer, ssize mem_copy( d->buf, buffer, size ); d->cap = size; - get_header(arr)->Num = size; + array_get_header(arr)->Num = size; } else { @@ -610,9 +610,9 @@ GEN_FILE_WRITE_AT_PROC( _memory_file_write ) { Array arr = { d->buf }; - if ( get_header(arr)->Capacity < usize(new_cap) ) + if ( array_get_header(arr)->Capacity < usize(new_cap) ) { - if ( ! grow( & arr, ( s64 )( new_cap ) ) ) + if ( ! array_grow( & arr, ( s64 )( new_cap ) ) ) return false; d->buf = arr; } @@ -626,7 +626,7 @@ GEN_FILE_WRITE_AT_PROC( _memory_file_write ) mem_copy( d->buf + offset + rwlen, pointer_add_const( buffer, rwlen ), extralen ); d->cap = new_cap; - get_header(arr)->Capacity = new_cap; + array_get_header(arr)->Capacity = new_cap; } else { @@ -647,10 +647,10 @@ GEN_FILE_CLOSE_PROC( _memory_file_close ) if ( d->flags & EFileStream_CLONE_WRITABLE ) { Array arr = { d->buf }; - free(& arr); + array_free(& arr); } - free( allocator, d ); + allocator_free( allocator, d ); } FileOperations const memory_file_operations = { _memory_file_read, _memory_file_write, _memory_file_seek, _memory_file_close }; diff --git a/project/dependencies/filesystem.hpp b/project/dependencies/filesystem.hpp index 3e7ea41..c788ab6 100644 --- a/project/dependencies/filesystem.hpp +++ b/project/dependencies/filesystem.hpp @@ -49,7 +49,7 @@ typedef struct FileOperations FileOperations; #define GEN_FILE_OPEN_PROC( name ) FileError name( FileDescriptor* fd, FileOperations* ops, FileMode mode, char const* filename ) #define GEN_FILE_READ_AT_PROC( name ) b32 name( FileDescriptor fd, void* buffer, ssize size, s64 offset, ssize* bytes_read, b32 stop_at_newline ) -#define GEN_FILE_WRITE_AT_PROC( name ) b32 name( FileDescriptor fd, void const* buffer, ssize size, s64 offset, ssize* bytes_written ) +#define GEN_FILE_WRITE_AT_PROC( name ) b32 name( FileDescriptor fd, mem_ptr_const buffer, ssize size, s64 offset, ssize* bytes_written ) #define GEN_FILE_SEEK_PROC( name ) b32 name( FileDescriptor fd, s64 offset, SeekWhenceType whence, s64* new_offset ) #define GEN_FILE_CLOSE_PROC( name ) void name( FileDescriptor fd ) diff --git a/project/dependencies/hashing.hpp b/project/dependencies/hashing.hpp index f16a9df..57642a6 100644 --- a/project/dependencies/hashing.hpp +++ b/project/dependencies/hashing.hpp @@ -5,7 +5,11 @@ #pragma region Hashing +GEN_API_C_BEGIN + u32 crc32( void const* data, ssize len ); u64 crc64( void const* data, ssize len ); +GEN_API_C_END + #pragma endregion Hashing diff --git a/project/dependencies/macros.hpp b/project/dependencies/macros.hpp index ef686da..c603535 100644 --- a/project/dependencies/macros.hpp +++ b/project/dependencies/macros.hpp @@ -14,17 +14,12 @@ #define local_persist static // Local Persisting variables #endif -#ifndef api_c -#define api_c extern "C" -#endif - #ifndef bit #define bit( Value ) ( 1 << Value ) #define bitfield_is_equal( Type, Field, Mask ) ( (Type(Mask) & Type(Field)) == Type(Mask) ) #endif - -#if ! GEN_C_COMPILER +#if GEN_COMPILER_CPP # ifndef cast # define cast( type, value ) (tmpl_cast( value )) # endif @@ -198,7 +193,7 @@ # define GEN_SUPPORT_CPP_MEMBER_FEATURES 0 #endif -#if !defined(typeof) && (!GEN_COMPILER_C || __STDC_VERSION__ < 202311L) +#if ! defined(typeof) && (!GEN_COMPILER_C || __STDC_VERSION__ < 202311L) # if ! GEN_COMPILER_C # define typeof decltype # elif defined(_MSC_VER) @@ -210,9 +205,15 @@ # endif #endif -// This is intended to only really be used internally or with the C-library variant -// C++ users can just use the for-range directly. -#define foreach(Type, entry_id, iterable) for ( Type entry_id = begin(iterable); entry_id != end(iterable); entry_id = next(iterable, entry_id) ) +#ifndef GEN_API_C_BEGIN +# if GEN_COMPILER_C +# define GEN_API_C_BEGIN +# define GEN_API_C_END +# else +# define GEN_API_C_BEGIN extern "C" { +# define GEN_API_C_END } +# endif +#endif #if GEN_COMPILER_C # if __STDC_VERSION__ >= 202311L @@ -230,7 +231,7 @@ # endif #endif -#if ! defined(GEN_PARAM_DEFAULT) && ! GEN_COMPILER_C +#if ! defined(GEN_PARAM_DEFAULT) && GEN_COMPILER_CPP # define GEN_PARAM_DEFAULT = {} #else # define GEN_PARAM_DEFAULT diff --git a/project/dependencies/memory.cpp b/project/dependencies/memory.cpp index f11cb47..09a9023 100644 --- a/project/dependencies/memory.cpp +++ b/project/dependencies/memory.cpp @@ -346,7 +346,7 @@ void* arena_allocator_proc( void* allocator_data, AllocType type, ssize size, ss case EAllocation_ALLOC : { void* end = pointer_add( arena->PhysicalStart, arena->TotalUsed ); - ssize total_size = align_forward_i64( size, alignment ); + ssize total_size = align_forward_s64( size, alignment ); // NOTE: Out of memory if ( arena->TotalUsed + total_size > (ssize) arena->TotalSize ) diff --git a/project/dependencies/memory.hpp b/project/dependencies/memory.hpp index 0399248..a69b5bf 100644 --- a/project/dependencies/memory.hpp +++ b/project/dependencies/memory.hpp @@ -22,6 +22,8 @@ void swap( Type& a, Type& b ) b = tmp; } +GEN_API_C_BEGIN + //! Checks if value is power of 2. b32 is_power_of_two( ssize x ); @@ -29,7 +31,7 @@ b32 is_power_of_two( ssize x ); void* align_forward( void* ptr, ssize alignment ); //! Aligns value to a specified alignment. -s64 align_forward_i64( s64 value, ssize alignment ); +s64 align_forward_by_value( s64 value, ssize alignment ); //! Moves pointer forward by bytes. void* pointer_add( void* ptr, ssize bytes ); @@ -100,7 +102,7 @@ void* alloc( AllocatorInfo a, ssize size ); void* alloc_align( AllocatorInfo a, ssize size, ssize alignment ); //! Free allocated memory. -void free( AllocatorInfo a, void* ptr ); +void allocator_free( AllocatorInfo a, void* ptr ); //! Free all memory allocated by an allocator. void free_all( AllocatorInfo a ); @@ -142,11 +144,12 @@ constexpr AllocatorInfo heap( void ) { AllocatorInfo allocator = { heap_allocato //! Helper to free memory allocated by heap allocator. #define mfree( ptr ) free( heap(), ptr ) -struct VirtualMemory +struct VirtualMemory_Def { void* data; ssize size; }; +typedef struct VirtualMemory_Def VirtualMemory; //! Initialize virtual memory from existing data. VirtualMemory vm_from_memory( void* data, ssize size ); @@ -164,15 +167,16 @@ b32 vm_free( VirtualMemory vm ); VirtualMemory vm_trim( VirtualMemory vm, ssize lead_size, ssize size ); //! Purge virtual memory. -b32 gen_vm_purge( VirtualMemory vm ); +b32 vm_purge( VirtualMemory vm ); //! Retrieve VM's page size and alignment. -ssize gen_virtual_memory_page_size( ssize* alignment_out ); +ssize virtual_memory_page_size( ssize* alignment_out ); #pragma region Arena -struct Arena; +struct Arena_Def; +typedef struct Arena_Def Arena; -AllocatorInfo allocator_info( Arena* arena ); +AllocatorInfo arena_allocator_info( Arena* arena ); // Remove static keyword and rename allocator_proc void* arena_allocator_proc(void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags); @@ -181,18 +185,13 @@ void* arena_allocator_proc(void* allocator_data, AllocType type, ssize size, ssi Arena arena_init_from_allocator(AllocatorInfo backing, ssize size); Arena arena_init_from_memory ( void* start, ssize size ); -Arena init_sub (Arena* parent, ssize size); -ssize alignment_of (Arena* arena, ssize alignment); -void free (Arena* arena); -ssize size_remaining(Arena* arena, ssize alignment); +Arena arena_init_sub (Arena* parent, ssize size); +ssize arena_alignment_of (Arena* arena, ssize alignment); +void arena_check (Arena* arena); +void arena_free (Arena* arena); +ssize arena_size_remaining(Arena* arena, ssize alignment); -// This id is defined by Unreal for asserts -#pragma push_macro("check") -#undef check -void check(Arena* arena); -#pragma pop_macro("check") - -struct Arena +struct Arena_Def { AllocatorInfo Backing; void* PhysicalStart; @@ -202,20 +201,20 @@ struct Arena #if GEN_SUPPORT_CPP_MEMBER_FEATURES #pragma region Member Mapping - forceinline operator AllocatorInfo() { return GEN_NS allocator_info(this); } + forceinline operator AllocatorInfo() { return GEN_NS arena_allocator_info(this); } forceinline static void* allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags ) { return GEN_NS arena_allocator_proc( allocator_data, type, size, alignment, old_memory, old_size, flags ); } forceinline static Arena init_from_memory( void* start, ssize size ) { return GEN_NS arena_init_from_memory( start, size ); } forceinline static Arena init_from_allocator( AllocatorInfo backing, ssize size ) { return GEN_NS arena_init_from_allocator( backing, size ); } forceinline static Arena init_sub( Arena& parent, ssize size ) { return GEN_NS arena_init_from_allocator( parent.Backing, size ); } - forceinline ssize alignment_of( ssize alignment ) { return GEN_NS alignment_of(this, alignment); } - forceinline void free() { return GEN_NS free(this); } - forceinline ssize size_remaining( ssize alignment ) { return GEN_NS size_remaining(this, alignment); } + forceinline ssize alignment_of( ssize alignment ) { return GEN_NS arena_alignment_of(this, alignment); } + forceinline void free() { return GEN_NS arena_free(this); } + forceinline ssize size_remaining( ssize alignment ) { return GEN_NS arena_size_remaining(this, alignment); } // This id is defined by Unreal for asserts #pragma push_macro("check") #undef check - forceinline void check() { GEN_NS check(this); } + forceinline void check() { GEN_NS arena_check(this); } #pragma pop_macro("check") #pragma endregion Member Mapping @@ -223,11 +222,11 @@ struct Arena }; #if GEN_SUPPORT_CPP_REFERENCES -forceinline AllocatorInfo allocator_info(Arena& arena ) { return allocator_info(& arena); } -forceinline Arena init_sub (Arena& parent, ssize size) { return init_sub( & parent, size); } -forceinline ssize alignment_of (Arena& arena, ssize alignment) { return alignment_of( & arena, alignment); } -forceinline void free (Arena& arena) { return free(& arena); } -forceinline ssize size_remaining(Arena& arena, ssize alignment) { return size_remaining(& arena, alignment); } +forceinline AllocatorInfo allocator_info(Arena& arena ) { return arena_allocator_info(& arena); } +forceinline Arena init_sub (Arena& parent, ssize size) { return arena_init_sub( & parent, size); } +forceinline ssize alignment_of (Arena& arena, ssize alignment) { return arena_alignment_of( & arena, alignment); } +forceinline void free (Arena& arena) { return arena_free(& arena); } +forceinline ssize size_remaining(Arena& arena, ssize alignment) { return arena_size_remaining(& arena, alignment); } // This id is defined by Unreal for asserts #pragma push_macro("check") @@ -238,9 +237,10 @@ forceinline void check(Arena& arena) { return check(& arena); }; inline -AllocatorInfo allocator_info( Arena* arena ) { +AllocatorInfo arena_allocator_info( Arena* arena ) { GEN_ASSERT(arena != nullptr); - return { arena_allocator_proc, arena }; + AllocatorInfo info = { arena_allocator_proc, arena }; + return info; } inline @@ -269,13 +269,13 @@ Arena arena_init_from_allocator(AllocatorInfo backing, ssize size) { } inline -Arena init_sub(Arena* parent, ssize size) { +Arena arena_init_sub(Arena* parent, ssize size) { GEN_ASSERT(parent != nullptr); return arena_init_from_allocator(parent->Backing, size); } inline -ssize alignment_of(Arena* arena, ssize alignment) +ssize arena_alignment_of(Arena* arena, ssize alignment) { GEN_ASSERT(arena != nullptr); ssize alignment_offset, result_pointer, mask; @@ -291,36 +291,35 @@ ssize alignment_of(Arena* arena, ssize alignment) return alignment_offset; } -#pragma push_macro("check") -#undef check inline -void check(Arena* arena) +void arena_check(Arena* arena) { GEN_ASSERT(arena != nullptr ); GEN_ASSERT(arena->TempCount == 0); } -#pragma pop_macro("check") inline -void free(Arena* arena) +void arena_free(Arena* arena) { GEN_ASSERT(arena != nullptr); if (arena->Backing.Proc) { - GEN_NS free(arena->Backing, arena->PhysicalStart); + allocator_free(arena->Backing, arena->PhysicalStart); arena->PhysicalStart = nullptr; } } inline -ssize size_remaining(Arena* arena, ssize alignment) +ssize arena_size_remaining(Arena* arena, ssize alignment) { GEN_ASSERT(arena != nullptr); - ssize result = arena->TotalSize - (arena->TotalUsed + alignment_of(arena, alignment)); + ssize result = arena->TotalSize - (arena->TotalUsed + arena_alignment_of(arena, alignment)); return result; } #pragma endregion Arena +GEN_API_C_END + #pragma region FixedArena template struct FixedArena; @@ -383,24 +382,27 @@ using Arena_2MB = FixedArena< megabytes( 2 ) >; using Arena_4MB = FixedArena< megabytes( 4 ) >; #pragma endregion FixedArena +GEN_API_C_BEGIN + #pragma region Pool -struct Pool; +struct Pool_Def; +typedef struct Pool_Def Pool; void* pool_allocator_proc(void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags); Pool pool_init(AllocatorInfo backing, ssize num_blocks, ssize block_size); Pool pool_init_align(AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align); -AllocatorInfo allocator_info(Pool* pool); -void clear(Pool* pool); -void free(Pool* pool); +AllocatorInfo pool_allocator_info(Pool* pool); +void pool_clear(Pool* pool); +void pool_free(Pool* pool); #if GEN_SUPPORT_CPP_REFERENCES -AllocatorInfo allocator_info(Pool& pool); -void clear(Pool& pool); -void free(Pool& pool); +AllocatorInfo allocator_info(Pool& pool) { return GEN_NS allocator_info(& pool); } +void clear(Pool& pool) { return GEN_NS clear(& pool); } +void free(Pool& pool) { return GEN_NS free(& pool); } #endif -struct Pool +struct Pool_Def { AllocatorInfo Backing; void* PhysicalStart; @@ -412,19 +414,19 @@ struct Pool #if GEN_SUPPORT_CPP_MEMBER_FEATURES #pragma region Member Mapping - forceinline operator AllocatorInfo() { return GEN_NS allocator_info(this); } + forceinline operator AllocatorInfo() { return GEN_NS pool_allocator_info(this); } forceinline static void* allocator_proc(void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags) { return GEN_NS pool_allocator_proc(allocator_data, type, size, alignment, old_memory, old_size, flags); } forceinline static Pool init(AllocatorInfo backing, ssize num_blocks, ssize block_size) { return GEN_NS pool_init(backing, num_blocks, block_size); } forceinline static Pool init_align(AllocatorInfo backing, ssize num_blocks, ssize block_size, ssize block_align) { return GEN_NS pool_init_align(backing, num_blocks, block_size, block_align); } - forceinline void clear() { GEN_NS clear( this); } - forceinline void free() { GEN_NS free( this); } + forceinline void clear() { GEN_NS pool_clear( this); } + forceinline void free() { GEN_NS pool_free( this); } #pragma endregion #endif }; inline -AllocatorInfo allocator_info(Pool* pool) { +AllocatorInfo pool_allocator_info(Pool* pool) { return { pool_allocator_proc, pool }; } @@ -434,9 +436,9 @@ Pool pool_init(AllocatorInfo backing, ssize num_blocks, ssize block_size) { } inline -void free(Pool* pool) { +void pool_free(Pool* pool) { if(pool->Backing.Proc) { - GEN_NS free(pool->Backing, pool->PhysicalStart); + allocator_free(pool->Backing, pool->PhysicalStart); } } #pragma endregion Pool @@ -458,9 +460,9 @@ mem_ptr align_forward( void* ptr, ssize alignment ) return to_mem_ptr(forward); } -inline s64 align_forward_i64( s64 value, ssize alignment ) { return value + ( alignment - value % alignment ) % alignment; } +inline s64 align_forward_s64( s64 value, ssize alignment ) { return value + ( alignment - value % alignment ) % alignment; } -inline void* pointer_add ( void* ptr, ssize bytes ) { return rcast(void*, rcast( u8*, ptr) + bytes ); } +inline void* pointer_add ( void* ptr, ssize bytes ) { return rcast(void*, rcast( u8*, ptr) + bytes ); } inline void const* pointer_add_const( void const* ptr, ssize bytes ) { return rcast(void const*, rcast( u8 const*, ptr) + bytes ); } inline sptr pointer_diff( mem_ptr_const begin, mem_ptr_const end ) { @@ -616,7 +618,7 @@ void* alloc( AllocatorInfo a, ssize size ) { } inline -void free( AllocatorInfo a, void* ptr ) { +void allocator_free( AllocatorInfo a, void* ptr ) { if ( ptr != nullptr ) a.Proc( a.Data, EAllocation_FREE, 0, 0, ptr, 0, GEN_DEFAULT_ALLOCATOR_FLAGS ); } @@ -644,7 +646,7 @@ void* default_resize_align( AllocatorInfo a, void* old_memory, ssize old_size, s if ( new_size == 0 ) { - free( a, old_memory ); + allocator_free( a, old_memory ); return nullptr; } @@ -662,7 +664,7 @@ void* default_resize_align( AllocatorInfo a, void* old_memory, ssize old_size, s return nullptr; mem_move( new_memory, old_memory, min( new_size, old_size ) ); - free( a, old_memory ); + allocator_free( a, old_memory ); return new_memory; } } @@ -672,4 +674,6 @@ void zero_size( void* ptr, ssize size ) { mem_set( ptr, 0, size ); } +GEN_API_C_END + #pragma endregion Memory diff --git a/project/dependencies/parsing.cpp b/project/dependencies/parsing.cpp index fbe44b1..eb3338a 100644 --- a/project/dependencies/parsing.cpp +++ b/project/dependencies/parsing.cpp @@ -36,12 +36,12 @@ u8 adt_destroy_branch( ADT_Node* node ) GEN_ASSERT_NOT_NULL( node ); if ( ( node->type == EADT_TYPE_OBJECT || node->type == EADT_TYPE_ARRAY ) && node->nodes ) { - for ( ssize i = 0; i < scast(ssize, num(node->nodes)); ++i ) + for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); ++i ) { adt_destroy_branch( node->nodes + i ); } - free(& node->nodes); + array_free(& node->nodes); } return 0; } @@ -66,7 +66,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search ) return NULL; } - for ( ssize i = 0; i < scast(ssize, num(node->nodes)); i++ ) + for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ ) { if ( ! str_compare( node->nodes[ i ].name, name ) ) { @@ -76,7 +76,7 @@ ADT_Node* adt_find( ADT_Node* node, char const* name, b32 deep_search ) if ( deep_search ) { - for ( ssize i = 0; i < scast(ssize, num(node->nodes)); i++ ) + for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ ) { ADT_Node* res = adt_find( node->nodes + i, name, deep_search ); @@ -132,7 +132,7 @@ internal ADT_Node* _adt_get_value( ADT_Node* node, char const* value ) internal ADT_Node* _adt_get_field( ADT_Node* node, char* name, char* value ) { - for ( ssize i = 0; i < scast(ssize, num(node->nodes)); i++ ) + for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ ) { if ( ! str_compare( node->nodes[ i ].name, name ) ) { @@ -207,7 +207,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri ) /* run a value comparison against any child that is an object node */ else if ( node->type == EADT_TYPE_ARRAY ) { - for ( ssize i = 0; i < scast(ssize, num(node->nodes)); i++ ) + for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ ) { ADT_Node* child = &node->nodes[ i ]; if ( child->type != EADT_TYPE_OBJECT ) @@ -225,7 +225,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri ) /* [value] */ else { - for ( ssize i = 0; i < scast(ssize, num(node->nodes)); i++ ) + for ( ssize i = 0; i < scast(ssize, array_num(node->nodes)); i++ ) { ADT_Node* child = &node->nodes[ i ]; if ( _adt_get_value( child, l_b2 ) ) @@ -257,7 +257,7 @@ ADT_Node* adt_query( ADT_Node* node, char const* uri ) else { ssize idx = ( ssize )str_to_i64( buf, NULL, 10 ); - if ( idx >= 0 && idx < scast(ssize, num(node->nodes)) ) + if ( idx >= 0 && idx < scast(ssize, array_num(node->nodes)) ) { found_node = &node->nodes[ idx ]; @@ -282,12 +282,12 @@ ADT_Node* adt_alloc_at( ADT_Node* parent, ssize index ) if ( ! parent->nodes ) return NULL; - if ( index < 0 || index > scast(ssize, num(parent->nodes)) ) + if ( index < 0 || index > scast(ssize, array_num(parent->nodes)) ) return NULL; ADT_Node o = { 0 }; o.parent = parent; - if ( ! append_at( & parent->nodes, o, index ) ) + if ( ! array_append_at( & parent->nodes, o, index ) ) return NULL; ADT_Node* node = & parent->nodes[index]; @@ -304,7 +304,7 @@ ADT_Node* adt_alloc( ADT_Node* parent ) if ( ! parent->nodes ) return NULL; - return adt_alloc_at( parent, num(parent->nodes) ); + return adt_alloc_at( parent, array_num(parent->nodes) ); } b8 adt_set_obj( ADT_Node* obj, char const* name, AllocatorInfo backing ) @@ -358,7 +358,7 @@ ADT_Node* adt_move_node( ADT_Node* node, ADT_Node* new_parent ) GEN_ASSERT_NOT_NULL( node ); GEN_ASSERT_NOT_NULL( new_parent ); GEN_ASSERT( new_parent->type == EADT_TYPE_ARRAY || new_parent->type == EADT_TYPE_OBJECT ); - return adt_move_node_at( node, new_parent, num(new_parent->nodes) ); + return adt_move_node_at( node, new_parent, array_num(new_parent->nodes) ); } void adt_swap_nodes( ADT_Node* node, ADT_Node* other_node ) @@ -382,7 +382,7 @@ void adt_remove_node( ADT_Node* node ) GEN_ASSERT_NOT_NULL( node->parent ); ADT_Node* parent = node->parent; ssize index = ( pointer_diff( parent->nodes, node ) / size_of( ADT_Node ) ); - remove_at( parent->nodes, index ); + array_remove_at( parent->nodes, index ); } ADT_Node* adt_append_obj( ADT_Node* parent, char const* name ) @@ -390,7 +390,7 @@ ADT_Node* adt_append_obj( ADT_Node* parent, char const* name ) ADT_Node* o = adt_alloc( parent ); if ( ! o ) return NULL; - if ( adt_set_obj( o, name, get_header(parent->nodes)->Allocator ) ) + if ( adt_set_obj( o, name, array_get_header(parent->nodes)->Allocator ) ) { adt_remove_node( o ); return NULL; @@ -404,7 +404,7 @@ ADT_Node* adt_append_arr( ADT_Node* parent, char const* name ) if ( ! o ) return NULL; - ArrayHeader* node_header = get_header(parent->nodes); + ArrayHeader* node_header = array_get_header(parent->nodes); if ( adt_set_arr( o, name, node_header->Allocator ) ) { adt_remove_node( o ); @@ -510,7 +510,7 @@ char* adt_parse_number( ADT_Node* node, char* base_str ) } else { - if ( ! str_compare( e, "0x", 2 ) || ! str_compare( e, "0X", 2 ) ) + if ( ! str_compare_len( e, "0x", 2 ) || ! str_compare_len( e, "0X", 2 ) ) { node_props = EADT_PROPS_IS_HEX; } @@ -949,12 +949,12 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b } } - if ( columnIndex >= scast(ssize, num(root->nodes)) ) + if ( columnIndex >= scast(ssize, array_num(root->nodes)) ) { adt_append_arr( root, NULL ); } - append( & root->nodes[ columnIndex ].nodes, rowItem ); + array_append( & root->nodes[ columnIndex ].nodes, rowItem ); if ( delimiter == delim ) { @@ -982,7 +982,7 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b } while ( *currentChar ); - if (num( root->nodes) == 0 ) + if (array_num( root->nodes) == 0 ) { GEN_CSV_ASSERT( "unexpected end of input. stream is empty." ); error = ECSV_Error__UNEXPECTED_END_OF_INPUT; @@ -992,12 +992,12 @@ u8 csv_parse_delimiter( CSV_Object* root, char* text, AllocatorInfo allocator, b /* consider first row as a header. */ if ( has_header ) { - for ( ssize i = 0; i < scast(ssize, num(root->nodes)); i++ ) + for ( ssize i = 0; i < scast(ssize, array_num(root->nodes)); i++ ) { CSV_Object* col = root->nodes + i; CSV_Object* hdr = col->nodes; col->name = hdr->string; - remove_at(col->nodes, 0 ); + array_remove_at(col->nodes, 0 ); } } @@ -1060,11 +1060,11 @@ void csv_write_delimiter( FileInfo* file, CSV_Object* obj, char delimiter ) GEN_ASSERT_NOT_NULL( file ); GEN_ASSERT_NOT_NULL( obj ); GEN_ASSERT( obj->nodes ); - ssize cols = num(obj->nodes); + ssize cols = array_num(obj->nodes); if ( cols == 0 ) return; - ssize rows = num(obj->nodes[ 0 ].nodes); + ssize rows = array_num(obj->nodes[ 0 ].nodes); if ( rows == 0 ) return; diff --git a/project/dependencies/platform.hpp b/project/dependencies/platform.hpp index ba2e745..3aad481 100644 --- a/project/dependencies/platform.hpp +++ b/project/dependencies/platform.hpp @@ -106,12 +106,24 @@ # define GEN_GCC_VERSION_CHECK(major,minor,patch) (0) #endif -#ifndef GEN_COMPILER_C -# if defined(__STDC_VERSION__) -# define GEN_COMPILER_C 1 +#if !defined(GEN_COMPILER_C) +# ifdef __cplusplus +# define GEN_COMPILER_C 0 +# define GEN_COMPILER_CPP 1 # else -# define GEN_COMPILER_C 0 -# endif +# if defined(__STDC__) +# define GEN_COMPILER_C 1 +# define GEN_COMPILER_CPP 0 +# else + // Fallback for very old C compilers +# define GEN_COMPILER_C 1 +# define GEN_COMPILER_CPP 0 +# endif +# endif +#endif + +#if GEN_COMPILER_C +#pragma message("Detected C") #endif #pragma endregion Platform Detection @@ -136,8 +148,6 @@ # define GEN_NS_PARSER_BEGIN # define GEN_NS_PARSER_END # define GEN_USING_NS_PARSER -# define GEN_NS_ENUM_BEGIN -# define GEN_NS_ENUM_END # define GEN_NS # define GEN_NS_BEGIN # define GEN_NS_END @@ -145,8 +155,6 @@ # define GEN_NS_PARSER_BEGIN namespace parser { # define GEN_NS_PARSER_END } # define GEN_USING_NS_PARSER using namespace parser -# define GEN_NS_ENUM_BEGIN namespace gen_internal_enums { -# define GEN_NS_ENUM_END } # define GEN_NS :: # define GEN_NS_BEGIN # define GEN_NS_END @@ -155,8 +163,6 @@ # define GEN_NS_PARSER_BEGIN namespace parser { # define GEN_NS_PARSER_END } # define GEN_USING_NS_PARSER using namespace parser -# define GEN_NS_ENUM_BEGIN namespace gen_internal_enums { -# define GEN_NS_ENUM_END } # define GEN_NS gen:: # define GEN_NS_BEGIN namespace gen { # define GEN_NS_END } diff --git a/project/dependencies/printing.cpp b/project/dependencies/printing.cpp index 1107761..3bb495a 100644 --- a/project/dependencies/printing.cpp +++ b/project/dependencies/printing.cpp @@ -431,7 +431,7 @@ neverinline ssize str_fmt_va( char* text, ssize max_len, char const* fmt, va_lis String gen_str = String { va_arg( va, char*) }; - info.precision = length(gen_str); + info.precision = string_length(gen_str); len = _print_string( text, remaining, &info, gen_str ); } break; diff --git a/project/dependencies/printing.hpp b/project/dependencies/printing.hpp index b6a8e98..e5cecf2 100644 --- a/project/dependencies/printing.hpp +++ b/project/dependencies/printing.hpp @@ -5,6 +5,8 @@ #pragma region Printing +GEN_API_C_BEGIN + struct FileInfo; #ifndef GEN_PRINTF_MAXLEN @@ -38,4 +40,6 @@ ssize log_fmt(char const* fmt, ...) return res; } +GEN_API_C_END + #pragma endregion Printing diff --git a/project/dependencies/string_ops.cpp b/project/dependencies/string_ops.cpp index bdd2e6e..954d40a 100644 --- a/project/dependencies/string_ops.cpp +++ b/project/dependencies/string_ops.cpp @@ -19,7 +19,7 @@ ssize _scan_zpl_i64( const char* text, s32 base, s64* value ) text++; } - if ( base == 16 && str_compare( text, "0x", 2 ) == 0 ) + if ( base == 16 && str_compare_len( text, "0x", 2 ) == 0 ) text += 2; for ( ;; ) @@ -61,7 +61,7 @@ s64 str_to_i64( const char* str, char** end_ptr, s32 base ) if ( ! base ) { - if ( ( str_len( str ) > 2 ) && ( str_compare( str, "0x", 2 ) == 0 ) ) + if ( ( str_len( str ) > 2 ) && ( str_compare_len( str, "0x", 2 ) == 0 ) ) base = 16; else base = 10; diff --git a/project/dependencies/string_ops.hpp b/project/dependencies/string_ops.hpp index dc76b51..891fec2 100644 --- a/project/dependencies/string_ops.hpp +++ b/project/dependencies/string_ops.hpp @@ -5,6 +5,8 @@ #pragma region String Ops +GEN_API_C_BEGIN + const char* char_first_occurence( const char* str, char c ); b32 char_is_alpha( char c ); @@ -19,11 +21,11 @@ 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( const char* s1, const char* s2, ssize len ); +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( const char* str, ssize max_len ); +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 ); @@ -132,7 +134,7 @@ s32 str_compare( const char* s1, const char* s2 ) } inline -s32 str_compare( const char* s1, const char* s2, ssize len ) +s32 str_compare_len( const char* s1, const char* s2, ssize len ) { for ( ; len > 0; s1++, s2++, len-- ) { @@ -204,7 +206,7 @@ ssize str_len( const char* str ) } inline -ssize str_len( const char* str, ssize max_len ) +ssize str_len_capped( const char* str, ssize max_len ) { const char* end = rcast(const char*, mem_find( str, 0, max_len )); if ( end ) @@ -240,7 +242,7 @@ char const* str_skip( char const* str, char c ) inline char const* str_skip_any( char const* str, char const* char_list ) { - char const* closest_ptr = rcast( char const*, pointer_add_const( rcast(void const*, str), str_len( str ) )); + 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 ); for ( ssize i = 0; i < char_list_count; i++ ) { @@ -284,4 +286,6 @@ void str_to_upper( char* str ) } } +GEN_API_C_END + #pragma endregion String Ops diff --git a/project/dependencies/strings.hpp b/project/dependencies/strings.hpp index f7c98b9..b02437c 100644 --- a/project/dependencies/strings.hpp +++ b/project/dependencies/strings.hpp @@ -5,15 +5,19 @@ #pragma region Strings +GEN_API_C_BEGIN + struct StrC; -bool are_equal (StrC lhs, StrC rhs); -char const* back (StrC str); -bool contains (StrC str, StrC substring); -StrC duplicate (StrC str, AllocatorInfo allocator); -b32 starts_with (StrC str, StrC substring); -StrC to_str (char const* bad_string); -StrC visualize_whitespace(StrC str, AllocatorInfo allocator); +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_to_str (char const* bad_string); +StrC strc_visualize_whitespace(StrC str, AllocatorInfo allocator); + +GEN_API_C_END // Constant string with length. struct StrC @@ -21,17 +25,17 @@ struct StrC ssize Len; char const* Ptr; -#if ! GEN_COMPILER_C - operator char const* () const { return Ptr; } - char const& operator[]( ssize index ) const { return Ptr[index]; } +#if GEN_COMPILER_CPP + forceinline operator char const* () const { return Ptr; } + forceinline char const& operator[]( ssize index ) const { return Ptr[index]; } #if GEN_SUPPORT_CPP_MEMBER_FEATURES - bool is_equal (StrC rhs) const { return GEN_NS are_equal(* this, rhs); } - char const* back () const { return GEN_NS back(* this); } - bool contains (StrC substring) const { return GEN_NS contains(* this, substring); } - StrC duplicate (AllocatorInfo allocator) const { return GEN_NS duplicate(* this, allocator); } - b32 starts_with (StrC substring) const { return GEN_NS starts_with(* this, substring); } - StrC visualize_whitespace(AllocatorInfo allocator) const { return GEN_NS visualize_whitespace(* this, allocator); } + forceinline bool is_equal (StrC rhs) const { return GEN_NS strc_are_equal(* this, rhs); } + forceinline char const* back () const { return GEN_NS strc_back(* this); } + forceinline bool contains (StrC substring) const { return GEN_NS strc_contains(* this, substring); } + forceinline StrC duplicate (AllocatorInfo allocator) const { return GEN_NS strc_duplicate(* this, allocator); } + forceinline b32 starts_with (StrC substring) const { return GEN_NS strc_starts_with(* this, substring); } + forceinline StrC visualize_whitespace(AllocatorInfo allocator) const { return GEN_NS strc_visualize_whitespace(* this, allocator); } #endif #endif }; @@ -39,12 +43,21 @@ struct StrC #define cast_to_strc( str ) * rcast( StrC*, (str) - sizeof(ssize) ) #define txt( text ) StrC { sizeof( text ) - 1, ( text ) } -inline char const* begin(StrC str) { return str.Ptr; } -inline char const* end (StrC str) { return str.Ptr + str.Len; } -inline char const* next (StrC str, char const* iter) { return iter + 1; } +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; } +GEN_API_C_END +#if GEN_COMPILER_CPP && 0 +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; } +#endif + +GEN_API_C_BEGIN inline -bool are_equal(StrC lhs, StrC rhs) +bool strc_are_equal(StrC lhs, StrC rhs) { if (lhs.Len != rhs.Len) return false; @@ -57,12 +70,12 @@ bool are_equal(StrC lhs, StrC rhs) } inline -char const* back(StrC str) { +char const* strc_back(StrC str) { return & str.Ptr[str.Len - 1]; } inline -bool contains(StrC str, StrC substring) +bool strc_contains(StrC str, StrC substring) { if (substring.Len > str.Len) return false; @@ -71,25 +84,26 @@ bool contains(StrC str, StrC substring) ssize sub_len = substring.Len; for (ssize idx = 0; idx <= main_len - sub_len; ++idx) { - if (str_compare(str.Ptr + idx, substring.Ptr, sub_len) == 0) + if (str_compare_len(str.Ptr + idx, substring.Ptr, sub_len) == 0) return true; } return false; } inline -b32 starts_with(StrC str, StrC substring) { +b32 strc_starts_with(StrC str, StrC substring) { if (substring.Len > str.Len) return false; - b32 result = str_compare(str.Ptr, substring.Ptr, substring.Len) == 0; + b32 result = str_compare_len(str.Ptr, substring.Ptr, substring.Len) == 0; return result; } inline -StrC to_str( char const* bad_str ) { +StrC to_strc_from_c_str( char const* bad_str ) { return { str_len( bad_str ), bad_str }; } +GEN_API_C_END // Dynamic String // This is directly based off the ZPL string api. @@ -104,42 +118,44 @@ typedef char* String; struct String; #endif -usize string_grow_formula(usize value); +GEN_API_C_BEGIN +forceinline usize string_grow_formula(usize value); -String string_make (AllocatorInfo allocator, char const* str); -String string_make (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 are_equal (String const lhs, String const rhs); -bool are_equal (String const lhs, StrC rhs); -bool make_space_for (String* str, char const* to_append, ssize add_len); -bool append (String* str, char c); -bool append (String* str, char const* str_to_append); -bool append (String* str, char const* str_to_append, ssize length); -bool append (String* str, StrC str_to_append); -bool append (String* str, String const other); -bool append_fmt (String* str, char const* fmt, ...); -ssize avail_space (String const str); -char* back (String str); -bool contains (String const str, StrC substring); -bool contains (String const str, String const substring); -ssize capacity (String const str); -void clear (String str); -String duplicate (String const str, AllocatorInfo allocator); -void free (String* str); -StringHeader* get_header (String str); -ssize length (String const str); -b32 starts_with (String const str, StrC substring); -b32 starts_with (String const str, String substring); -void skip_line (String str); -void strip_space (String str); -StrC to_strc (String str); -void trim (String str, char const* cut_set); -void trim_space (String str); -String visualize_whitespace(String const str); +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); +GEN_API_C_END struct StringHeader { AllocatorInfo Allocator; @@ -147,7 +163,7 @@ struct StringHeader { ssize Length; }; -#if ! GEN_COMPILER_C && GEN_SUPPORT_CPP_MEMBER_FEATURES +#if GEN_COMPILER_CPP && GEN_SUPPORT_CPP_MEMBER_FEATURES struct String { char* Data; @@ -169,10 +185,10 @@ struct String forceinline char& operator[](ssize index) { return Data[index]; } forceinline char const& operator[](ssize index) const { return Data[index]; } - bool operator==(std::nullptr_t) const { return Data == nullptr; } - bool operator!=(std::nullptr_t) const { return Data != nullptr; } - friend bool operator==(std::nullptr_t, const String str) { return str.Data == nullptr; } - friend 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 String str) { return str.Data == nullptr; } + friend forceinline bool operator!=(std::nullptr_t, const String str) { return str.Data != nullptr; } forceinline char* begin() const { return Data; } forceinline char* end() const { return Data + GEN_NS length(* this); } @@ -206,29 +222,29 @@ struct String } forceinline bool make_space_for(char const* str, ssize add_len) { return GEN_NS make_space_for(this, str, add_len); } - forceinline bool append(char c) { return GEN_NS append(this, c); } - forceinline bool append(char const* str) { return GEN_NS append(this, str); } - forceinline bool append(char const* str, ssize length) { return GEN_NS append(this, str, length); } - forceinline bool append(StrC str) { return GEN_NS append(this, str); } - forceinline bool append(const String other) { return GEN_NS append(this, other); } - forceinline ssize avail_space() const { return GEN_NS avail_space(* this); } - forceinline char* back() { return GEN_NS back(* this); } - forceinline bool contains(StrC substring) const { return GEN_NS contains(* this, substring); } - forceinline bool contains(String const& substring) const { return GEN_NS contains(* this, substring); } + forceinline bool append(char c) { return GEN_NS string_append_char(this, c); } + forceinline bool append(char const* str) { return GEN_NS string_append_c_str(this, str); } + forceinline bool append(char const* str, ssize length) { return GEN_NS string_append_c_str_len(this, str, length); } + forceinline bool append(StrC str) { return GEN_NS string_append_strc(this, str); } + forceinline bool append(const String other) { return GEN_NS string_append_string(this, other); } + forceinline ssize avail_space() const { return GEN_NS string_avail_space(* this); } + forceinline char* back() { return GEN_NS string_back(* this); } + forceinline bool contains(StrC substring) const { return GEN_NS string_contains_strc(* this, substring); } + forceinline bool contains(String const& substring) const { return GEN_NS string_contains_string(* this, substring); } forceinline ssize capacity() const { return GEN_NS capacity(* this); } - forceinline void clear() { GEN_NS clear(* this); } + forceinline void clear() { GEN_NS clear(* this); } forceinline String duplicate(AllocatorInfo allocator) const { return GEN_NS duplicate(* this, allocator); } - forceinline void free() { GEN_NS free(this); } + forceinline void free() { GEN_NS free(this); } forceinline bool is_equal(String const& other) const { return GEN_NS are_equal(* this, other); } forceinline bool is_equal(StrC other) const { return GEN_NS are_equal(* this, other); } forceinline ssize length() const { return GEN_NS length(* this); } forceinline b32 starts_with(StrC substring) const { return GEN_NS starts_with(* this, substring); } forceinline b32 starts_with(String substring) const { return GEN_NS starts_with(* this, substring); } - forceinline void skip_line() { GEN_NS skip_line(* this); } - forceinline void strip_space() { GEN_NS strip_space(* this); } + forceinline void skip_line() { GEN_NS skip_line(* this); } + forceinline void strip_space() { GEN_NS strip_space(* this); } forceinline StrC to_strc() { return { length(), Data}; } - forceinline void trim(char const* cut_set) { GEN_NS trim(* this, cut_set); } - forceinline void trim_space() { GEN_NS trim_space(* this); } + forceinline void trim(char const* cut_set) { GEN_NS trim(* this, cut_set); } + forceinline void trim_space() { GEN_NS trim_space(* this); } forceinline String visualize_whitespace() const { return GEN_NS visualize_whitespace(* this); } forceinline StringHeader& get_header() { return * GEN_NS get_header(* this); } @@ -247,37 +263,47 @@ struct String }; #endif -inline char* begin(String str) { return ((char*) str); } -inline char* end (String str) { return ((char*) str + length(str)); } -inline char* next (String str, char* iter) { return ((char*) iter + 1); } +GEN_API_C_BEGIN +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); } +GEN_API_C_END -#if GEN_SUPPORT_CPP_REFERENCES -inline bool make_space_for(String& str, char const* to_append, ssize add_len); -inline bool append(String& str, char c); -inline bool append(String& str, char const* str_to_append); -inline bool append(String& str, char const* str_to_append, ssize length); -inline bool append(String& str, StrC str_to_append); -inline bool append(String& str, const String other); -inline bool append_fmt(String& str, char const* fmt, ...); -inline char& back(String& str); -inline void clear(String& str); -inline void free(String& str); +#if GEN_COMPILER_CPP && 0 +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); } #endif -inline +#if GEN_SUPPORT_CPP_REFERENCES +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); +#endif + +GEN_API_C_BEGIN + +forceinline usize string_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; } -inline -String string_make(AllocatorInfo allocator, char const* str) { +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); } -inline -String string_make(AllocatorInfo allocator, StrC str) { +forceinline +String string_make_strc(AllocatorInfo allocator, StrC str) { return string_make_length(allocator, str.Ptr, str.Len); } @@ -285,10 +311,10 @@ inline String string_fmt(AllocatorInfo allocator, char* buf, ssize buf_size, char const* fmt, ...) { va_list va; va_start(va, fmt); - str_fmt_va(buf, buf_size, fmt, va); + ssize res = str_fmt_va(buf, buf_size, fmt, va); va_end(va); - return string_make(allocator, buf); + return string_make_length(allocator, buf, res); } inline @@ -299,52 +325,52 @@ String string_fmt_buf(AllocatorInfo allocator, char const* fmt, ...) va_list va; va_start(va, fmt); - str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va); + ssize res = str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va); va_end(va); - return string_make(allocator, buf); + return string_make_length(allocator, buf, res); } inline String string_join(AllocatorInfo allocator, char const** parts, ssize num_parts, char const* glue) { - String result = string_make(allocator, ""); + String result = string_make_c_str(allocator, ""); for (ssize idx = 0; idx < num_parts; ++idx) { - append(& result, parts[idx]); + string_append_c_str(& result, parts[idx]); if (idx < num_parts - 1) - append(& result, glue); + string_append_c_str(& result, glue); } return result; } -inline -bool append(String* str, char c) { +forceinline +bool string_append_char(String* str, char c) { GEN_ASSERT(str != nullptr); - return append( str, (char const*)& c, (ssize)1); + return string_append_c_str_len( str, (char const*)& c, (ssize)1); +} + +forceinline +bool string_append_c_str(String* str, char const* str_to_append) { + GEN_ASSERT(str != nullptr); + return string_append_c_str_len(str, str_to_append, str_len(str_to_append)); } inline -bool append(String* str, char const* str_to_append) { - GEN_ASSERT(str != nullptr); - return append(str, str_to_append, str_len(str_to_append)); -} - -inline -bool append(String* str, char const* str_to_append, ssize append_length) +bool string_append_str_c_len(String* str, char const* str_to_append, ssize append_length) { GEN_ASSERT(str != nullptr); if (sptr(str_to_append) > 0) { - ssize curr_len = length(* str); + ssize curr_len = string_length(* str); - if ( ! make_space_for(str, str_to_append, append_length)) + if ( ! string_make_space_for(str, str_to_append, append_length)) return false; - StringHeader* header = get_header(* str); + StringHeader* header = string_get_header(* str); char* Data = * str; mem_copy( Data + curr_len, str_to_append, append_length); @@ -356,16 +382,16 @@ bool append(String* str, char const* str_to_append, ssize append_length) return str_to_append != nullptr; } -inline -bool append(String* str, StrC str_to_append) { +forceinline +bool string_append_strc(String* str, StrC str_to_append) { GEN_ASSERT(str != nullptr); - return append(str, str_to_append.Ptr, str_to_append.Len); + return string_append_c_str_len(str, str_to_append.Ptr, str_to_append.Len); } -inline -bool append(String* str, String const other) { +forceinline +bool string_append_string(String* str, String const other) { GEN_ASSERT(str != nullptr); - return append(str, (char const*)other, length(other)); + return string_append_c_str_len(str, (char const*)other, string_length(other)); } bool append_fmt(String* str, char const* fmt, ...) { @@ -378,16 +404,16 @@ bool append_fmt(String* str, char const* fmt, ...) { res = str_fmt_va(buf, count_of(buf) - 1, fmt, va) - 1; va_end(va); - return append(str, (char const*)buf, res); + return string_append_c_str_len(str, (char const*)buf, res); } inline -bool are_equal(String const lhs, String const rhs) +bool string_are_equal_string(String const lhs, String const rhs) { - if (length(lhs) != length(rhs)) + if (string_length(lhs) != string_length(rhs)) return false; - for (ssize idx = 0; idx < length(lhs); ++idx) + for (ssize idx = 0; idx < string_length(lhs); ++idx) if (lhs[idx] != rhs[idx]) return false; @@ -395,27 +421,27 @@ bool are_equal(String const lhs, String const rhs) } inline -bool are_equal(String const lhs, StrC rhs) +bool string_are_equal_strc(String const lhs, StrC rhs) { - if (length(lhs) != (rhs.Len)) + if (string_length(lhs) != (rhs.Len)) return false; - for (ssize idx = 0; idx < length(lhs); ++idx) + for (ssize idx = 0; idx < string_length(lhs); ++idx) if (lhs[idx] != rhs.Ptr[idx]) return false; return true; } -inline +forceinline ssize avail_space(String const str) { StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader)); return header->Capacity - header->Length; } -inline +forceinline char* back(String* str) { - return & (*str)[length(* str) - 1]; + return & (*str)[string_length(* str) - 1]; } inline @@ -431,7 +457,7 @@ bool contains(String const str, StrC substring) for (ssize idx = 0; idx <= main_len - sub_len; ++idx) { - if (str_compare(str + idx, substring.Ptr, sub_len) == 0) + if (str_compare_len(str + idx, substring.Ptr, sub_len) == 0) return true; } @@ -439,67 +465,67 @@ bool contains(String const str, StrC substring) } inline -bool contains(String const str, String const substring) +bool string_contains_string(String const str, String const substring) { StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader)); - if (length(substring) > header->Length) + if (string_length(substring) > header->Length) return false; ssize main_len = header->Length; - ssize sub_len = length(substring); + ssize sub_len = string_length(substring); for (ssize idx = 0; idx <= main_len - sub_len; ++idx) { - if (str_compare(str + idx, substring, sub_len) == 0) + if (str_compare_len(str + idx, substring, sub_len) == 0) return true; } return false; } -inline -ssize capacity(String const str) { +forceinline +ssize string_capacity(String const str) { StringHeader const* header = rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader)); return header->Capacity; } -inline -void clear(String str) { - get_header(str)->Length = 0; +forceinline +void string_clear(String str) { + string_get_header(str)->Length = 0; } -inline -String duplicate(String const str, AllocatorInfo allocator) { - return string_make_length(allocator, str, length(str)); +forceinline +String string_duplicate(String const str, AllocatorInfo allocator) { + return string_make_length(allocator, str, string_length(str)); } -inline -void free(String* str) { +forceinline +void string_free(String* str) { GEN_ASSERT(str != nullptr); if (! (* str)) return; - StringHeader* header = get_header(* str); - GEN_NS free(header->Allocator, header); + StringHeader* header = string_get_header(* str); + allocator_free(header->Allocator, header); } -inline -StringHeader* get_header(String str) { +forceinline +StringHeader* string_get_header(String str) { return (StringHeader*)(scast(char*, str) - sizeof(StringHeader)); } -inline -ssize length(String const str) +forceinline +ssize string_length(String const str) { StringHeader const& header = *rcast(StringHeader const*, scast(char const*, str) - sizeof(StringHeader)); return header.Length; } inline -bool make_space_for(String* str, char const* to_append, ssize add_len) +bool string_make_space_for(String* str, char const* to_append, ssize add_len) { - ssize available = avail_space(* str); + ssize available = string_avail_space(* str); if (available >= add_len) { return true; @@ -510,12 +536,12 @@ bool make_space_for(String* str, char const* to_append, ssize add_len) void* ptr; void* new_ptr; - AllocatorInfo allocator = get_header(* str)->Allocator; + AllocatorInfo allocator = string_get_header(* str)->Allocator; StringHeader* header = nullptr; - new_len = string_grow_formula(length(* str) + add_len); - ptr = get_header(* str); - old_size = size_of(StringHeader) + length(* str) + 1; + 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_ptr = resize(allocator, ptr, old_size, new_size); @@ -534,26 +560,26 @@ bool make_space_for(String* str, char const* to_append, ssize add_len) } } -inline -b32 starts_with(String const str, StrC substring) { - if (substring.Len > length(str)) +forceinline +b32 string_starts_with_strc(String const str, StrC substring) { + if (substring.Len > string_length(str)) return false; - b32 result = str_compare(str, substring.Ptr, substring.Len) == 0; + b32 result = str_compare_len(str, substring.Ptr, substring.Len) == 0; return result; } -inline -b32 starts_with(String const str, String substring) { - if (length(substring) > length(str)) +forceinline +b32 string_starts_with_string(String const str, String substring) { + if (string_length(substring) > string_length(str)) return false; - b32 result = str_compare(str, substring, length(substring) - 1) == 0; + b32 result = str_compare_len(str, substring, string_length(substring) - 1) == 0; return result; } inline -void skip_line(String str) +void string_skip_line(String str) { #define current (*scanner) char* scanner = str; @@ -569,7 +595,7 @@ void skip_line(String str) mem_move((char*)str, scanner, new_length); - StringHeader* header = get_header(str); + StringHeader* header = string_get_header(str); header->Length = new_length; #undef current } @@ -593,12 +619,12 @@ void strip_space(String str) write_pos[0] = '\0'; // Null-terminate the modified string // Update the length if needed - get_header(str)->Length = write_pos - str; + string_get_header(str)->Length = write_pos - str; } -inline -StrC to_strc(String str) { - return { length(str), (char const*)str }; +forceinline +StrC string_to_strc(String str) { + return { string_length(str), (char const*)str }; } inline @@ -607,7 +633,7 @@ void trim(String str, char const* cut_set) ssize len = 0; char* start_pos = str; - char* end_pos = scast(char*, str) + length(str) - 1; + char* end_pos = scast(char*, str) + string_length(str) - 1; while (start_pos <= end_pos && char_first_occurence(cut_set, *start_pos)) start_pos++; @@ -622,10 +648,10 @@ void trim(String str, char const* cut_set) str[len] = '\0'; - get_header(str)->Length = len; + string_get_header(str)->Length = len; } -inline +forceinline void trim_space(String str) { trim(str, " \t\r\n\v\f"); } @@ -634,30 +660,31 @@ inline String visualize_whitespace(String const str) { StringHeader* header = (StringHeader*)(scast(char const*, str) - sizeof(StringHeader)); - String result = string_make_reserve(header->Allocator, length(str) * 2); // Assume worst case for space requirements. + String result = string_make_reserve(header->Allocator, string_length(str) * 2); // Assume worst case for space requirements. - foreach (char*, c, str) switch ( * c ) + for (char const* c = string_begin(str); c != string_end(str); c = string_next(str, c)) + switch ( * c ) { case ' ': - append(& result, txt("·")); + string_append_strc(& result, txt("·")); break; case '\t': - append(& result, txt("→")); + string_append_strc(& result, txt("→")); break; case '\n': - append(& result, txt("↵")); + string_append_strc(& result, txt("↵")); break; case '\r': - append(& result, txt("⏎")); + string_append_strc(& result, txt("⏎")); break; case '\v': - append(& result, txt("⇕")); + string_append_strc(& result, txt("⇕")); break; case '\f': - append(& result, txt("⌂")); + string_append_strc(& result, txt("⌂")); break; default: - append(& result, c); + string_append_char(& result, * c); break; } @@ -670,47 +697,50 @@ struct String_POD { }; static_assert( sizeof( String_POD ) == sizeof( String ), "String is not a POD" ); -inline -StrC duplicate(StrC str, AllocatorInfo allocator) { +forceinline +StrC strc_duplicate(StrC str, AllocatorInfo allocator) { String result = string_make_length(allocator, str.Ptr, str.Len); - return { get_header(result)->Length, result }; + return { string_get_header(result)->Length, result }; } inline -StrC visualize_whitespace(StrC str, AllocatorInfo allocator) +StrC strc_visualize_whitespace(StrC str, AllocatorInfo allocator) { String result = string_make_reserve(allocator, str.Len * 2); // Assume worst case for space requirements. - foreach (char const*, c, str) switch ( * c ) + for (char const* c = strc_begin(str); c != strc_end(str); c = strc_next(str, c)) + switch ( * c ) { case ' ': - append(& result, txt("·")); + string_append_strc(& result, txt("·")); break; case '\t': - append(& result, txt("→")); + string_append_strc(& result, txt("→")); break; case '\n': - append(& result, txt("↵")); + string_append_strc(& result, txt("↵")); break; case '\r': - append(& result, txt("⏎")); + string_append_strc(& result, txt("⏎")); break; case '\v': - append(& result, txt("⇕")); + string_append_strc(& result, txt("⇕")); break; case '\f': - append(& result, txt("⌂")); + string_append_strc(& result, txt("⌂")); break; default: - append(& result, c); + string_append_char(& result, * c); break; - } - return to_strc(result); +} + return string_to_strc(result); } // Represents strings cached with the string table. // Should never be modified, if changed string is desired, cache_string( str ) another. typedef StrC StringCached; +GEN_API_C_END + // Implements basic string interning. Data structure is based off the ZPL Hashtable. typedef HashTable StringTable; #pragma endregion Strings diff --git a/project/helpers/helper.hpp b/project/helpers/helper.hpp index e27cc14..314fcc8 100644 --- a/project/helpers/helper.hpp +++ b/project/helpers/helper.hpp @@ -13,7 +13,7 @@ CodeBody gen_ecode( char const* path ) char scratch_mem[kilobytes(1)]; Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) ); - file_read_contents( allocator_info( & scratch), zero_terminate, path ); + file_read_contents( arena_allocator_info( & scratch), zero_terminate, path ); CSV_Object csv_nodes; csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false ); @@ -23,19 +23,21 @@ CodeBody gen_ecode( char const* path ) String enum_entries = string_make_reserve( GlobalAllocator, kilobytes(1) ); String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) ); - for ( ADT_Node& node : enum_strs ) + for ( ADT_Node* node = array_begin(enum_strs); node != array_end(enum_strs); node = array_next(enum_strs, node) ) { - char const* code = node.string; + char const* code = node->string; append_fmt( & enum_entries, "CT_%s,\n", code ); append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", code, code ); } - CodeEnum enum_code = parse_enum(gen::token_fmt_impl((3 + 1) / 2, "entries", to_strc(enum_entries), "enum CodeType_Def : u32 { CT_NumTypes };")); + CodeEnum enum_code = parse_enum(gen::token_fmt_impl((3 + 1) / 2, "entries", string_to_strc(enum_entries), + "enum CodeType_Def : u32 { CT_NumTypes };" + )); #pragma push_macro("local_persist") #undef local_persist - CodeFn to_str = parse_function( token_fmt( "entries", to_strc(to_str_entries), stringize( + CodeFn to_str = parse_function( token_fmt( "entries", string_to_strc(to_str_entries), stringize( inline StrC to_str( CodeType type ) { @@ -61,7 +63,7 @@ CodeBody gen_eoperator( char const* path ) char scratch_mem[kilobytes(4)]; Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) ); - file_read_contents( allocator_info(& scratch), zero_terminate, path ); + file_read_contents( arena_allocator_info(& scratch), zero_terminate, path ); CSV_Object csv_nodes; csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false ); @@ -72,7 +74,7 @@ CodeBody gen_eoperator( char const* path ) String enum_entries = string_make_reserve( GlobalAllocator, kilobytes(1) ); String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) ); - for (usize idx = 0; idx < num(enum_strs); idx++) + for (usize idx = 0; idx < array_num(enum_strs); idx++) { char const* enum_str = enum_strs[idx].string; char const* entry_to_str = str_strs [idx].string; @@ -81,7 +83,7 @@ CodeBody gen_eoperator( char const* path ) append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str); } - CodeEnum enum_code = parse_enum(token_fmt("entries", to_strc(enum_entries), stringize( + CodeEnum enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize( enum Operator_Def : u32 { @@ -91,7 +93,7 @@ CodeBody gen_eoperator( char const* path ) #pragma push_macro("local_persist") #undef local_persist - CodeFn to_str = parse_function(token_fmt("entries", to_strc(to_str_entries), stringize( + CodeFn to_str = parse_function(token_fmt("entries", string_to_strc(to_str_entries), stringize( inline StrC to_str( Operator op ) { @@ -117,7 +119,7 @@ CodeBody gen_especifier( char const* path ) char scratch_mem[kilobytes(4)]; Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) ); - file_read_contents( allocator_info(& scratch), zero_terminate, path ); + file_read_contents( arena_allocator_info(& scratch), zero_terminate, path ); CSV_Object csv_nodes; csv_parse( &csv_nodes, scratch_mem, GlobalAllocator, false ); @@ -128,7 +130,7 @@ CodeBody gen_especifier( char const* path ) String enum_entries = string_make_reserve( GlobalAllocator, kilobytes(1) ); String to_str_entries = string_make_reserve( GlobalAllocator, kilobytes(1) ); - for (usize idx = 0; idx < num(enum_strs); idx++) + for (usize idx = 0; idx < array_num(enum_strs); idx++) { char const* enum_str = enum_strs[idx].string; char const* entry_to_str = str_strs [idx].string; @@ -137,7 +139,7 @@ CodeBody gen_especifier( char const* path ) append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str); } - CodeEnum enum_code = parse_enum(token_fmt("entries", to_strc(enum_entries), stringize( + CodeEnum enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), stringize( enum Specifier_Def : u32 { @@ -145,7 +147,7 @@ CodeBody gen_especifier( char const* path ) }; ))); - CodeFn is_trailing = parse_function(token_fmt("specifier", to_strc(to_str_entries), stringize( + CodeFn is_trailing = parse_function(token_fmt("specifier", string_to_strc(to_str_entries), stringize( inline bool is_trailing( Specifier specifier ) { @@ -163,7 +165,7 @@ CodeBody gen_especifier( char const* path ) #undef do_once_end #undef forceinline #undef neverinline - CodeFn to_str = parse_function(token_fmt("entries", to_strc(to_str_entries), stringize( + CodeFn to_str = parse_function(token_fmt("entries", string_to_strc(to_str_entries), stringize( inline StrC to_str( Specifier type ) { @@ -176,7 +178,7 @@ CodeBody gen_especifier( char const* path ) } ))); - CodeFn to_type = parse_function( token_fmt( "entries", to_strc(to_str_entries), stringize( + CodeFn to_type = parse_function( token_fmt( "entries", string_to_strc(to_str_entries), stringize( inline Specifier to_specifier( StrC str ) { @@ -222,7 +224,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path ) char scratch_mem[kilobytes(16)]; Arena scratch = arena_init_from_memory( scratch_mem, sizeof(scratch_mem) ); - AllocatorInfo scratch_info = allocator_info(& scratch); + AllocatorInfo scratch_info = arena_allocator_info(& scratch); FileContents enum_content = file_read_contents( scratch_info, zero_terminate, etok_path ); @@ -245,7 +247,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path ) String to_str_attributes = string_make_reserve( GlobalAllocator, kilobytes(4) ); String attribute_define_entries = string_make_reserve( GlobalAllocator, kilobytes(4) ); - for (usize idx = 0; idx < num(enum_strs); idx++) + 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; @@ -254,7 +256,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path ) append_fmt( & to_str_entries, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str); } - for ( usize idx = 0; idx < num(attribute_strs); idx++ ) + 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; @@ -263,19 +265,19 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path ) append_fmt( & to_str_attributes, "{ sizeof(\"%s\"), \"%s\" },\n", entry_to_str, entry_to_str); append_fmt( & attribute_define_entries, "Entry( Tok_Attribute_%s, \"%s\" )", attribute_str, entry_to_str ); - if ( idx < num(attribute_strs) - 1 ) - append( & attribute_define_entries, " \\\n"); + if ( idx < array_num(attribute_strs) - 1 ) + string_append_strc( & attribute_define_entries, txt(" \\\n")); else - append( & attribute_define_entries, "\n"); + string_append_strc( & 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), to_strc(attribute_define_entries) ); + CodeDefine attribute_entires_def = def_define( name(GEN_DEFINE_ATTRIBUTE_TOKENS), string_to_strc(attribute_define_entries) ); #pragma pop_macro("GEN_DEFINE_ATTRIBUTE_TOKENS") // We cannot parse this enum, it has Attribute names as enums - CodeEnum enum_code = parse_enum(token_fmt("entries", to_str(enum_entries), "attribute_toks", to_str(attribute_entries), stringize( + CodeEnum enum_code = parse_enum(token_fmt("entries", string_to_strc(enum_entries), "attribute_toks", string_to_strc(attribute_entries), stringize( enum TokType_Def : u32 { @@ -290,7 +292,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path ) #undef local_persist #undef do_once_start #undef do_once_end - CodeFn to_str = parse_function(token_fmt("entries", to_strc(to_str_entries), "attribute_toks", to_strc(to_str_attributes), stringize( + CodeFn to_str = parse_function(token_fmt("entries", string_to_strc(to_str_entries), "attribute_toks", string_to_strc(to_str_attributes), stringize( inline StrC to_str( TokType type ) { @@ -304,7 +306,7 @@ CodeBody gen_etoktype( char const* etok_path, char const* attr_path ) } ))); - CodeFn to_type = parse_function( token_fmt( "entries", to_strc(to_str_entries), stringize( + CodeFn to_type = parse_function( token_fmt( "entries", string_to_strc(to_str_entries), stringize( inline TokType to_toktype( StrC str ) { diff --git a/scripts/build.ci.ps1 b/scripts/build.ci.ps1 index 2a4e63a..4fa2981 100644 --- a/scripts/build.ci.ps1 +++ b/scripts/build.ci.ps1 @@ -231,10 +231,12 @@ if ( $c_library ) $executable = join-path $path_build "gen_c_library_test.exe" if ($vendor -eq "clang") { - $compiler_args += "-x" - $compiler_args += "c" + $compiler_args += '-x' + $compiler_args += 'c' + $compiler_args += '-std=c11' } elseif ($vendor -eq "msvc") { - $compiler_args += "/TC" + $compiler_args += "/TC" # Compile as C + $compiler_args += "/Zc:__cplusplus" # Fix __cplusplus macro } build-simple $path_build $includes $compiler_args $linker_args $unit $executable