1
0
mirror of https://github.com/Ed94/gencpp.git synced 2025-07-09 07:05:44 -07:00

Scripting updates, some refactors..

Made a package release script.

Did refactors based on some design considerations
Still need to make some major decisions...
This commit is contained in:
2023-08-09 18:47:59 -04:00
parent 5aff89262b
commit aa928ff446
46 changed files with 371 additions and 312 deletions

@ -0,0 +1 @@

@ -5,13 +5,13 @@ Code scan_file( char const* path )
FileError error = file_open_mode( & file, EFileMode_READ, path );
if ( error != EFileError_NONE )
{
fatal( "scan_file: Could not open: %s", path );
GEN_FATAL( "scan_file: Could not open: %s", path );
}
sw fsize = file_size( & file );
if ( fsize <= 0 )
{
fatal("scan_file: %s is empty", path );
GEN_FATAL("scan_file: %s is empty", path );
}
String str = String::make_reserve( GlobalAllocator, fsize );
@ -36,7 +36,6 @@ struct SymbolInfo
Code Signature;
};
struct Scanner
{
struct RequestEntry

@ -15,10 +15,10 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, sw size, sw a
Arena bucket = Arena::init_from_allocator( heap(), Global_BucketSize );
if ( bucket.PhysicalStart == nullptr )
fatal( "Failed to create bucket for Global_AllocatorBuckets");
GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
if ( ! Global_AllocatorBuckets.append( bucket ) )
fatal( "Failed to append bucket to Global_AllocatorBuckets");
GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
last = & Global_AllocatorBuckets.back();
}
@ -42,10 +42,10 @@ void* Global_Allocator_Proc( void* allocator_data, AllocType type, sw size, sw a
Arena bucket = Arena::init_from_allocator( heap(), Global_BucketSize );
if ( bucket.PhysicalStart == nullptr )
fatal( "Failed to create bucket for Global_AllocatorBuckets");
GEN_FATAL( "Failed to create bucket for Global_AllocatorBuckets");
if ( ! Global_AllocatorBuckets.append( bucket ) )
fatal( "Failed to append bucket to Global_AllocatorBuckets");
GEN_FATAL( "Failed to append bucket to Global_AllocatorBuckets");
last = & Global_AllocatorBuckets.back();
}
@ -68,7 +68,7 @@ internal
void define_constants()
{
Code::Global = make_code();
Code::Global->Name = get_cached_string( txt_StrC("Global Code") );
Code::Global->Name = get_cached_string( txt("Global Code") );
Code::Global->Content = Code::Global->Name;
Code::Invalid = make_code();
@ -76,22 +76,22 @@ void define_constants()
t_empty = (CodeType) make_code();
t_empty->Type = ECode::Typename;
t_empty->Name = get_cached_string( txt_StrC("") );
t_empty->Name = get_cached_string( txt("") );
t_empty.set_global();
access_private = make_code();
access_private->Type = ECode::Access_Private;
access_private->Name = get_cached_string( txt_StrC("private:") );
access_private->Name = get_cached_string( txt("private:") );
access_private.set_global();
access_protected = make_code();
access_protected->Type = ECode::Access_Protected;
access_protected->Name = get_cached_string( txt_StrC("protected:") );
access_protected->Name = get_cached_string( txt("protected:") );
access_protected.set_global();
access_public = make_code();
access_public->Type = ECode::Access_Public;
access_public->Name = get_cached_string( txt_StrC("public:") );
access_public->Name = get_cached_string( txt("public:") );
access_public.set_global();
attrib_api_export = def_attributes( code(GEN_API_Export_Code));
@ -102,13 +102,13 @@ void define_constants()
module_global_fragment = make_code();
module_global_fragment->Type = ECode::Untyped;
module_global_fragment->Name = get_cached_string( txt_StrC("module;") );
module_global_fragment->Name = get_cached_string( txt("module;") );
module_global_fragment->Content = module_global_fragment->Name;
module_global_fragment.set_global();
module_private_fragment = make_code();
module_private_fragment->Type = ECode::Untyped;
module_private_fragment->Name = get_cached_string( txt_StrC("module : private;") );
module_private_fragment->Name = get_cached_string( txt("module : private;") );
module_private_fragment->Content = module_private_fragment->Name;
module_private_fragment.set_global();
@ -118,13 +118,13 @@ void define_constants()
pragma_once = (CodePragma) make_code();
pragma_once->Type = ECode::Preprocess_Pragma;
pragma_once->Name = get_cached_string( txt_StrC("once") );
pragma_once->Name = get_cached_string( txt("once") );
pragma_once->Content = pragma_once->Name;
pragma_once.set_global();
param_varadic = (CodeType) make_code();
param_varadic->Type = ECode::Parameters;
param_varadic->Name = get_cached_string( txt_StrC("...") );
param_varadic->Name = get_cached_string( txt("...") );
param_varadic->ValueType = t_empty;
param_varadic.set_global();
@ -226,12 +226,12 @@ void init()
Global_AllocatorBuckets = Array<Arena>::init_reserve( heap(), 128 );
if ( Global_AllocatorBuckets == nullptr )
fatal( "Failed to reserve memory for Global_AllocatorBuckets");
GEN_FATAL( "Failed to reserve memory for Global_AllocatorBuckets");
Arena bucket = Arena::init_from_allocator( heap(), Global_BucketSize );
if ( bucket.PhysicalStart == nullptr )
fatal( "Failed to create first bucket for Global_AllocatorBuckets");
GEN_FATAL( "Failed to create first bucket for Global_AllocatorBuckets");
Global_AllocatorBuckets.append( bucket );
@ -242,12 +242,12 @@ void init()
CodePools = Array<Pool>::init_reserve( Allocator_DataArrays, InitSize_DataArrays );
if ( CodePools == nullptr )
fatal( "gen::init: Failed to initialize the CodePools array" );
GEN_FATAL( "gen::init: Failed to initialize the CodePools array" );
StringArenas = Array<Arena>::init_reserve( Allocator_DataArrays, InitSize_DataArrays );
if ( StringArenas == nullptr )
fatal( "gen::init: Failed to initialize the StringArenas array" );
GEN_FATAL( "gen::init: Failed to initialize the StringArenas array" );
}
// Setup the code pool and code entries arena.
@ -255,7 +255,7 @@ void init()
Pool code_pool = Pool::init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) );
if ( code_pool.PhysicalStart == nullptr )
fatal( "gen::init: Failed to initialize the code pool" );
GEN_FATAL( "gen::init: Failed to initialize the code pool" );
CodePools.append( code_pool );
@ -264,7 +264,7 @@ void init()
Arena string_arena = Arena::init_from_allocator( Allocator_StringArena, SizePer_StringArena );
if ( string_arena.PhysicalStart == nullptr )
fatal( "gen::init: Failed to initialize the string arena" );
GEN_FATAL( "gen::init: Failed to initialize the string arena" );
StringArenas.append( string_arena );
}
@ -274,7 +274,7 @@ void init()
StringCache = StringTable::init( Allocator_StringTable );
if ( StringCache.Entries == nullptr )
fatal( "gen::init: Failed to initialize the StringCache");
GEN_FATAL( "gen::init: Failed to initialize the StringCache");
}
define_constants();
@ -362,7 +362,7 @@ AllocatorInfo get_string_allocator( s32 str_length )
Arena new_arena = Arena::init_from_allocator( Allocator_StringArena, SizePer_StringArena );
if ( ! StringArenas.append( new_arena ) )
fatal( "gen::get_string_allocator: Failed to allocate a new string arena" );
GEN_FATAL( "gen::get_string_allocator: Failed to allocate a new string arena" );
last = & StringArenas.back();
}
@ -397,10 +397,10 @@ Code make_code()
Pool code_pool = Pool::init( Allocator_CodePool, CodePool_NumBlocks, sizeof(AST) );
if ( code_pool.PhysicalStart == nullptr )
fatal( "gen::make_code: Failed to allocate a new code pool - CodePool allcoator returned nullptr." );
GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePool allcoator returned nullptr." );
if ( ! CodePools.append( code_pool ) )
fatal( "gen::make_code: Failed to allocate a new code pool - CodePools failed to append new pool." );
GEN_FATAL( "gen::make_code: Failed to allocate a new code pool - CodePools failed to append new pool." );
allocator = & CodePools.back();
}

@ -1122,7 +1122,7 @@ if ( def.Ptr == nullptr ) \
# define check( Type_ ) ( left && currtok.Type == Type_ )
# define push_scope() \
StackNode scope { nullptr, currtok, NullToken, txt_StrC( __func__ ) }; \
StackNode scope { nullptr, currtok, NullToken, txt( __func__ ) }; \
Context.push( & scope )
#pragma endregion Helper Macros
@ -1329,7 +1329,7 @@ Code parse_static_assert()
char const* result = str_fmt_buf( "%.*s\n", content.Length, content.Text );
assert->Content = get_cached_string( to_StrC( result ) );
assert->Content = get_cached_string( to_str( result ) );
assert->Name = assert->Content;
Context.pop();
@ -2264,7 +2264,7 @@ Code parse_simple_preprocess( Parser::TokType which )
char const* content = str_fmt_buf( "%.*s\n", tok.Length, tok.Text );
Code result = untyped_str( to_StrC( content ) );
Code result = untyped_str( to_str( content ) );
Context.Scope->Name = tok;
if ( str_compare( Context.Scope->Prev->ProcName.Ptr, "parse_typedef", Context.Scope->Prev->ProcName.Len ) != 0 )

@ -89,4 +89,5 @@ namespace ECode
# undef Define_Types
}
using CodeT = ECode::Type;
using ECode::to_str;

@ -64,7 +64,7 @@ namespace EOperator
# define Entry( Type_, Token_ ) { sizeof(stringize(Token_)), stringize(Token_) },
Define_Operators
# undef Entry
txt_StrC(",")
txt(",")
};
return lookup[ op ];
@ -73,4 +73,5 @@ namespace EOperator
# undef Define_Operators
}
using OperatorT = EOperator::Type;
using EOperator::to_str;

@ -107,4 +107,5 @@ namespace ESpecifier
# undef Define_Specifiers
}
using SpecifierT = ESpecifier::Type;
using ESpecifier::to_str;

@ -165,6 +165,7 @@ namespace Parser
};
using TokType = ETokType::Type;
using ETokType::to_str;
} // Parser

@ -1,11 +1,11 @@
using LogFailType = sw(*)(char const*, ...);
// By default this library will either crash or exit if an error is detected while generating codes.
// Even if set to not use fatal, fatal will still be used for memory failures as the library is unusable when they occur.
// Even if set to not use GEN_FATAL, GEN_FATAL will still be used for memory failures as the library is unusable when they occur.
#ifdef GEN_DONT_USE_FATAL
#define log_failure log_fmt
#else
#define log_failure fatal
#define log_failure GEN_FATAL
#endif
enum class AccessSpec : u32
@ -46,7 +46,6 @@ enum class EnumT : u8
constexpr EnumT EnumClass = EnumT::Class;
constexpr EnumT EnumRegular = EnumT::Regular;
enum class ModuleFlag : u32
{
None = 0,
@ -76,50 +75,3 @@ constexpr EPreprocessCond PreprocessCond_IfDef = EPreprocessCond::IfDef;
constexpr EPreprocessCond PreprocessCond_IfNotDef = EPreprocessCond::IfNotDef;
constexpr EPreprocessCond PreprocessCond_ElIf = EPreprocessCond::ElIf;
/*
Predefined attributes
Used for the parser constructors to identify non-standard attributes
Override these to change the attribute to your own unique identifier convention.
The tokenizer identifies attribute defines with the GEN_DEFINE_ATTRIBUTE_TOKENS macros.
See the example below and the Define_TokType macro used in gen.cpp to know the format.
While the library can parse raw attributes, most projects use defines to wrap them for compiler
platform indendence. The token define allows support for them without having to modify the library.
*/
#if defined(GEN_SYSTEM_WINDOWS) || defined( __CYGWIN__ )
#ifndef GEN_Attribute_Keyword
# define GEN_API_Export_Code __declspec(dllexport)
# define GEN_API_Import_Code __declspec(dllimport)
# define GEN_Attribute_Keyword __declspec
#endif
constexpr char const* Attribute_Keyword = stringize( GEN_Attribute_Keyword);
#elif GEN_HAS_ATTRIBUTE( visibility ) || GEN_GCC_VERSION_CHECK( 3, 3, 0 )
#ifndef GEN_Attribute_Keyword
# define GEN_API_Export_Code __attribute__ ((visibility ("default")))
# define GEN_API_Import_Code __attribute__ ((visibility ("default")))
# define GEN_Attribute_Keyword __attribute__
#endif
constexpr char const* Attribute_Keyword = stringize( GEN_Attribute_Keyword );
#else
#ifndef GEN_Attribute_Keyword
# define GEN_API_Export_Code
# define GEN_API_Import_Code
# define GEN_Attribute_Keyword
#endif
constexpr char const* Attribute_Keyword = "";
#endif
// Implements basic string interning. Data structure is based off the ZPL Hashtable.
using StringTable = HashTable<String const>;
// Represents strings cached with the string table.
// Should never be modified, if changed string is desired, cache_string( str ) another.
using StringCached = String const;

@ -34,7 +34,7 @@ s32 assert_crash( char const* condition );
void process_exit( u32 code );
#if Build_Debug
#define fatal( fmt, ... ) \
#define GEN_FATAL( fmt, ... ) \
do \
{ \
local_persist thread_local \
@ -46,7 +46,7 @@ void process_exit( u32 code );
while (0)
#else
# define fatal( fmt, ... ) \
# define GEN_FATAL( fmt, ... ) \
do \
{ \
str_fmt_out_err( fmt, __VA_ARGS__ ); \

@ -100,25 +100,6 @@
#define GEN_DEF_INLINE static
#define GEN_IMPL_INLINE static inline
#ifdef GEN_COMPILER_MSVC
# define forceinline __forceinline
# define neverinline __declspec( noinline )
#elif defined(GEN_COMPILER_GCC)
# define forceinline inline __attribute__((__always_inline__))
# define neverinline __attribute__( ( __noinline__ ) )
#elif defined(GEN_COMPILER_CLANG)
#if __has_attribute(__always_inline__)
# define forceinline inline __attribute__((__always_inline__))
# define neverinline __attribute__( ( __noinline__ ) )
#else
# define forceinline
# define neverinline
#endif
#else
# define forceinline
# define neverinline
#endif
#pragma endregion Platform Detection
#pragma region Mandatory Includes

@ -8,6 +8,25 @@
#define internal static // Internal linkage
#define local_persist static // Local Persisting variables
#ifdef GEN_COMPILER_MSVC
# define forceinline __forceinline
# define neverinline __declspec( noinline )
#elif defined(GEN_COMPILER_GCC)
# define forceinline inline __attribute__((__always_inline__))
# define neverinline __attribute__( ( __noinline__ ) )
#elif defined(GEN_COMPILER_CLANG)
#if __has_attribute(__always_inline__)
# define forceinline inline __attribute__((__always_inline__))
# define neverinline __attribute__( ( __noinline__ ) )
#else
# define forceinline
# define neverinline
#endif
#else
# define forceinline
# define neverinline
#endif
// Bits
#define bit( Value ) ( 1 << Value )
@ -125,6 +144,12 @@
#define min( a, b ) ( ( a ) < ( b ) ? ( a ) : ( b ) )
#define size_of( x ) ( sw )( sizeof( x ) )
#if defined( _MSC_VER ) || defined( GEN_COMPILER_TINYC )
# define offset_of( Type, element ) ( ( GEN_NS( gen_sw ) ) & ( ( ( Type* )0 )->element ) )
#else
# define offset_of( Type, element ) __builtin_offsetof( Type, element )
#endif
template< class Type >
void swap( Type& a, Type& b )
{

@ -221,7 +221,7 @@ void* Arena::allocator_proc( void* allocator_data, AllocType type, sw size, sw a
if ( arena->TotalUsed + total_size > (sw) arena->TotalSize )
{
// zpl__printf_err("%s", "Arena out of memory\n");
fatal("Arena out of memory! (Possibly could not fit for the largest size Arena!!)");
GEN_FATAL("Arena out of memory! (Possibly could not fit for the largest size Arena!!)");
return nullptr;
}

@ -1,4 +1,4 @@
#pragma region String
#pragma region Strings
// Constant string with length.
struct StrC
@ -12,18 +12,14 @@ struct StrC
}
};
#define txt_StrC( text ) StrC { sizeof( text ) - 1, text }
#define cast_to_strc( str ) * rcast( StrC*, str - sizeof(sw) )
#define txt( text ) StrC { sizeof( text ) - 1, text }
StrC to_StrC( char const* str )
StrC to_str( char const* str )
{
return { str_len( str ), str };
}
sw StrC_len( char const* str )
{
return (sw) ( str - 1 );
}
// Dynamic String
// This is directly based off the ZPL string api.
// They used a header pattern
@ -33,8 +29,8 @@ struct String
struct Header
{
AllocatorInfo Allocator;
sw Length;
sw Capacity;
sw Length;
};
static
@ -92,7 +88,7 @@ struct String
return { nullptr };
Header&
header = * rcast(Header*, allocation);
header = * rcast(Header*, allocation);
header = { allocator, length, length };
String result = { rcast( char*, allocation) + header_size };
@ -332,11 +328,7 @@ struct String
operator StrC() const
{
return
{
length(),
Data
};
return { length(), Data };
}
// Used with cached strings
@ -363,19 +355,21 @@ struct String
return Data[ index ];
}
char* Data = nullptr;
char* Data;
};
struct String_POD
{
char* Data;
operator String()
{
return * rcast(String*, this);
}
};
static_assert( sizeof( String_POD ) == sizeof( String ), "String is not a POD" );
#pragma endregion String
// Implements basic string interning. Data structure is based off the ZPL Hashtable.
using StringTable = HashTable<String const>;
// Represents strings cached with the string table.
// Should never be modified, if changed string is desired, cache_string( str ) another.
using StringCached = String const;
#pragma endregion Strings

@ -3,15 +3,16 @@
#define GEN_EXPOSE_BACKEND
#include "gen.cpp"
#include "helpers/push_ignores.inline.hpp"
#include "helpers/helper.hpp"
GEN_NS_BEGIN
#include "dependencies/parsing.cpp"
GEN_NS_END
#include "file_processors/builder.hpp"
#include "file_processors/builder.cpp"
#include "file_processors/scanner.hpp"
#include "auxillary/builder.hpp"
#include "auxillary/builder.cpp"
#include "auxillary/scanner.hpp"
using namespace gen;
@ -28,18 +29,18 @@ int gen_main()
// gen_dep.hpp
{
Code header_start = scan_file( "dependencies/header_start.hpp" );
Code macros = scan_file( "dependencies/macros.hpp" );
Code basic_types = scan_file( "dependencies/basic_types.hpp" );
Code debug = scan_file( "dependencies/debug.hpp" );
Code memory = scan_file( "dependencies/memory.hpp" );
Code string_ops = scan_file( "dependencies/string_ops.hpp" );
Code printing = scan_file( "dependencies/printing.hpp" );
Code containers = scan_file( "dependencies/containers.hpp" );
Code hashing = scan_file( "dependencies/hashing.hpp" );
Code string = scan_file( "dependencies/string.hpp" );
Code file_handling = scan_file( "dependencies/file_handling.hpp" );
Code timing = scan_file( "dependencies/timing.hpp" );
Code header_start = scan_file( "dependencies/header_start.hpp" );
Code macros = scan_file( "dependencies/macros.hpp" );
Code basic_types = scan_file( "dependencies/basic_types.hpp" );
Code debug = scan_file( "dependencies/debug.hpp" );
Code memory = scan_file( "dependencies/memory.hpp" );
Code string_ops = scan_file( "dependencies/string_ops.hpp" );
Code printing = scan_file( "dependencies/printing.hpp" );
Code containers = scan_file( "dependencies/containers.hpp" );
Code hashing = scan_file( "dependencies/hashing.hpp" );
Code strings = scan_file( "dependencies/strings.hpp" );
Code filesystem = scan_file( "dependencies/filesystem.hpp" );
Code timing = scan_file( "dependencies/timing.hpp" );
Builder
header = Builder::open("gen/gen.dep.hpp");
@ -56,8 +57,8 @@ int gen_main()
header.print( printing );
header.print( containers );
header.print( hashing );
header.print( string );
header.print( file_handling );
header.print( strings );
header.print( filesystem );
header.print( timing );
header.print_fmt( "GEN_NS_END\n\n" );
@ -66,15 +67,15 @@ int gen_main()
// gen_dep.cpp
{
Code src_start = scan_file( "dependencies/src_start.cpp" );
Code debug = scan_file( "dependencies/debug.cpp" );
Code string_ops = scan_file( "dependencies/string_ops.cpp" );
Code printing = scan_file( "dependencies/printing.cpp" );
Code memory = scan_file( "dependencies/memory.cpp" );
Code hashing = scan_file( "dependencies/hashing.cpp" );
Code string = scan_file( "dependencies/string.cpp" );
Code file_handling = scan_file( "dependencies/file_handling.cpp" );
Code timing = scan_file( "dependencies/timing.cpp" );
Code src_start = scan_file( "dependencies/src_start.cpp" );
Code debug = scan_file( "dependencies/debug.cpp" );
Code string_ops = scan_file( "dependencies/string_ops.cpp" );
Code printing = scan_file( "dependencies/printing.cpp" );
Code memory = scan_file( "dependencies/memory.cpp" );
Code hashing = scan_file( "dependencies/hashing.cpp" );
Code strings = scan_file( "dependencies/strings.cpp" );
Code filesystem = scan_file( "dependencies/filesystem.cpp" );
Code timing = scan_file( "dependencies/timing.cpp" );
Builder
src = Builder::open( "gen/gen.dep.cpp" );
@ -88,8 +89,8 @@ int gen_main()
src.print( printing );
src.print( hashing );
src.print( memory );
src.print( string );
src.print( file_handling );
src.print( strings );
src.print( filesystem );
src.print( timing );
src.print_fmt( "GEN_NS_END\n\n" );
@ -189,13 +190,13 @@ int gen_main()
// gen_builder.hpp
{
Code builder = scan_file( "file_processors/builder.hpp" );
Code builder = scan_file( "auxillary/builder.hpp" );
Builder
header = Builder::open( "gen/gen.builder.hpp" );
header.print_fmt( generation_notice );
header.print_fmt( "#pragma once\n\n" );
header.print( def_include( txt_StrC("gen.hpp") ));
header.print( def_include( txt("gen.hpp") ));
header.print_fmt( "\nGEN_NS_BEGIN\n\n" );
header.print( builder );
header.print_fmt( "\nGEN_NS_END\n\n" );
@ -204,12 +205,12 @@ int gen_main()
// gen_builder.cpp
{
Code builder = scan_file( "file_processors/builder.cpp" );
Code builder = scan_file( "auxillary/builder.cpp" );
Builder
src = Builder::open( "gen/gen.builder.cpp" );
src.print_fmt( generation_notice );
src.print( def_include( txt_StrC("gen.builder.hpp") ) );
src.print( def_include( txt("gen.builder.hpp") ) );
src.print_fmt( "\nGEN_NS_BEGIN\n\n" );
src.print( builder );
src.print_fmt( "\nGEN_NS_END\n\n" );
@ -219,13 +220,13 @@ int gen_main()
// gen_scanner.hpp
{
Code parsing = scan_file( "dependencies/parsing.hpp" );
Code scanner = scan_file( "file_processors/scanner.hpp" );
Code scanner = scan_file( "auxillary/scanner.hpp" );
Builder
header = Builder::open( "gen/gen.scanner.hpp" );
header.print_fmt( generation_notice );
header.print_fmt( "#pragma once\n\n" );
header.print( def_include( txt_StrC("gen.hpp") ) );
header.print( def_include( txt("gen.hpp") ) );
header.print_fmt( "\nGEN_NS_BEGIN\n\n" );
header.print( parsing );
header.print( scanner );
@ -236,15 +237,15 @@ int gen_main()
// gen_scanner.cpp
{
Code parsing = scan_file( "dependencies/parsing.cpp" );
// Code scanner = scan_file( "file_processors/scanner.cpp" );
Code scanner = scan_file( "auxillary/scanner.cpp" );
Builder
src = Builder::open( "gen/gen.scanner.cpp" );
src.print_fmt( generation_notice );
src.print( def_include( txt_StrC("gen.scanner.hpp") ) );
src.print( def_include( txt("gen.scanner.hpp") ) );
src.print_fmt( "\nGEN_NS_BEGIN\n\n" );
src.print( parsing );
// src.print( scanner );
src.print( scanner );
src.print_fmt( "\nGEN_NS_END\n\n" );
src.write();
}

@ -10,8 +10,8 @@ GEN_NS_BEGIN
#include "dependencies/printing.cpp"
#include "dependencies/memory.cpp"
#include "dependencies/hashing.cpp"
#include "dependencies/string.cpp"
#include "dependencies/file_handling.cpp"
#include "dependencies/strings.cpp"
#include "dependencies/filesystem.cpp"
#include "dependencies/timing.cpp"
GEN_NS_END

@ -13,8 +13,8 @@ GEN_NS_BEGIN
#include "dependencies/printing.hpp"
#include "dependencies/containers.hpp"
#include "dependencies/hashing.hpp"
#include "dependencies/string.hpp"
#include "dependencies/file_handling.hpp"
#include "dependencies/strings.hpp"
#include "dependencies/filesystem.hpp"
#include "dependencies/timing.hpp"
GEN_NS_END

@ -531,7 +531,7 @@ CodeBody gen_ast_inlines()
CodeBody impl_cast_var = parse_global_body( token_fmt( "typename", StrC name(Var), cast_tmpl ));
CodeBody result = def_global_body( args(
def_pragma( txt_StrC("region generated code inline implementation")),
def_pragma( txt("region generated code inline implementation")),
fmt_newline,
impl_code,
impl_code_body,
@ -563,9 +563,9 @@ CodeBody gen_ast_inlines()
impl_code_using,
impl_code_var,
fmt_newline,
def_pragma( txt_StrC("endregion generated code inline implementation")),
def_pragma( txt("endregion generated code inline implementation")),
fmt_newline,
def_pragma( txt_StrC("region generated AST/Code cast implementation")),
def_pragma( txt("region generated AST/Code cast implementation")),
fmt_newline,
impl_cast_body,
impl_cast_attribute,
@ -596,7 +596,7 @@ CodeBody gen_ast_inlines()
impl_cast_using,
impl_cast_var,
fmt_newline,
def_pragma( txt_StrC("endregion generated AST/Code cast implementation")),
def_pragma( txt("endregion generated AST/Code cast implementation")),
fmt_newline
));

@ -64,7 +64,7 @@
#undef stringize
#undef stringize
#undef stringize_va
#undef txt_StrC
#undef txt
#undef GEN_TIME
#undef gen_main