ed/gencpp
1
0
Fork 0
mirror of https://github.com/Ed94/gencpp.git synced 2025-07-01 19:31:02 -07:00
Code Issues Packages Projects Releases Wiki Activity

c_library refacotring works, and compiles with all content from the base project.

Browse Source 
I need to make the refactor step happen before formatting with clang-format in the metaprogram instead of calling it from powershell
This commit is contained in:
Edward R. Gonzalez
2024-12-10 13:56:56 -05:00
parent 5aaef0f1a2
commit 0046c4a223
19 changed files with 793 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
project/auxillary/builder.cpp
View File

@ -39,7 +39,7 @@ void builder_print_fmt_va( Builder* builder, char const* fmt, va_list va )
res = str_fmt_va( buf, count_of( buf ) - 1, fmt, va ) - 1;
string_append_c_str_len( (String*) & builder->Buffer, (char const*)buf, res);
string_append_c_str_len( (String*) & (builder->Buffer), (char const*)buf, res);
}
void builder_write(Builder* builder)

5
project/auxillary/builder.hpp
View File

@ -30,7 +30,10 @@ struct Builder
forceinline void print( Code code ) { return builder_print(this, code); }
forceinline void print_fmt( char const* fmt, ... ) {
va_list va;
va_start( va, fmt );
builder_print_fmt_va( this, fmt, va );
va_end( va );
}
forceinline void write() { return builder_write(this); }

13
project/bootstrap.cpp
View File

@ -206,22 +206,22 @@ int gen_main()
Builder header_ecode = builder_open( "components/gen/ecode.hpp" );
builder_print( & header_ecode, gen_component_header );
builder_print( & header_ecode, ecode );
builder_print( & header_ecode, dump_to_scratch_and_retireve(ecode) );
builder_write( & header_ecode);
Builder header_eoperator = builder_open( "components/gen/eoperator.hpp" );
builder_print( & header_eoperator, gen_component_header );
builder_print( & header_eoperator, eoperator );
builder_print( & header_eoperator, dump_to_scratch_and_retireve(eoperator) );
builder_write( & header_eoperator );
Builder header_especifier = builder_open( "components/gen/especifier.hpp" );
builder_print( & header_especifier, gen_component_header );
builder_print( & header_especifier, especifier );
builder_print( & header_especifier, dump_to_scratch_and_retireve(especifier) );
builder_write( & header_especifier);
Builder header_ast_inlines = builder_open( "components/gen/ast_inlines.hpp" );
builder_print( & header_ast_inlines, gen_component_header );
builder_print( & header_ast_inlines, ast_inlines );
builder_print( & header_ast_inlines, dump_to_scratch_and_retireve(ast_inlines) );
builder_write( & header_ast_inlines);
}
@ -244,6 +244,7 @@ int gen_main()
CodeBody nspaced_etoktype = def_global_body( args(
etoktype
));
Code formatted_toktype = dump_to_scratch_and_retireve(nspaced_etoktype);
Builder _src = builder_open( "gen/gen.cpp" );
Builder* src = & _src;
@ -264,7 +265,7 @@ int gen_main()
builder_print( src, interface );
builder_print( src, upfront );
builder_print_fmt( src, "\n#pragma region Parsing\n\n" );
builder_print( src, dump_to_scratch_and_retireve(nspaced_etoktype) );
builder_print( src, formatted_toktype );
builder_print( src, lexer );
builder_print( src, parser );
builder_print( src, parsing_interface );
@ -278,7 +279,7 @@ int gen_main()
Builder src_etoktype = builder_open( "components/gen/etoktype.cpp" );
builder_print( & src_etoktype, gen_component_header );
builder_print( & src_etoktype, nspaced_etoktype );
builder_print( & src_etoktype, formatted_toktype );
builder_write( & src_etoktype);
}

42
project/components/ast.hpp
View File

@ -92,27 +92,27 @@ struct Code;
#endif
#if GEN_COMPILER_C
typdef AST_Body* CodeBody;
typdef AST_Attributes* CodeAttributes;
typdef AST_Comment* CodeComment;
typdef AST_Class* CodeClass;
typdef AST_Constructor* CodeConstructor;
typdef AST_Define* CodeDefine;
typdef AST_Destructor* CodeDestructor;
typdef AST_Enum* CodeEnum;
typdef AST_Exec* CodeExec;
typdef AST_Extern* CodeExtern;
typdef AST_Include* CodeInclude;
typdef AST_Friend* CodeFriend;
typdef AST_Fn* CodeFn;
typdef AST_Module* CodeModule;
typdef AST_NS* CodeNS;
typdef AST_Operator* CodeOperator;
typdef AST_OpCast* CodeOpCast;
typdef AST_Param* CodeParam;
typdef AST_PreprocessCond* CodePreprocessCond;
typdef AST_Pragma* CodePragma;
typdef AST_Specifiers* CodeSpecifiers;
typedef AST_Body* CodeBody;
typedef AST_Attributes* CodeAttributes;
typedef AST_Comment* CodeComment;
typedef AST_Class* CodeClass;
typedef AST_Constructor* CodeConstructor;
typedef AST_Define* CodeDefine;
typedef AST_Destructor* CodeDestructor;
typedef AST_Enum* CodeEnum;
typedef AST_Exec* CodeExec;
typedef AST_Extern* CodeExtern;
typedef AST_Include* CodeInclude;
typedef AST_Friend* CodeFriend;
typedef AST_Fn* CodeFn;
typedef AST_Module* CodeModule;
typedef AST_NS* CodeNS;
typedef AST_Operator* CodeOperator;
typedef AST_OpCast* CodeOpCast;
typedef AST_Param* CodeParam;
typedef AST_PreprocessCond* CodePreprocessCond;
typedef AST_Pragma* CodePragma;
typedef AST_Specifiers* CodeSpecifiers;
#else
struct CodeBody;
struct CodeAttributes;

68
project/components/interface.cpp
View File

@ -184,54 +184,34 @@ void define_constants()
# undef def_constant_code_type
# define def_constant_spec( Type_, ... ) \
spec_##Type_ = def_specifiers( num_args(__VA_ARGS__), __VA_ARGS__); \
code_set_global( cast(Code, spec_##Type_));
# pragma push_macro("forceinline")
# pragma push_macro("global")
# pragma push_macro("internal")
# pragma push_macro("local_persist")
# pragma push_macro("neverinline")
# undef forceinline
# undef global
# undef internal
# undef local_persist
# undef neverinline
def_constant_spec( const, Spec_Const );
def_constant_spec( consteval, Spec_Consteval );
def_constant_spec( constexpr, Spec_Constexpr );
def_constant_spec( constinit, Spec_Constinit );
def_constant_spec( extern_linkage, Spec_External_Linkage );
def_constant_spec( final, Spec_Final );
def_constant_spec( forceinline, Spec_ForceInline );
def_constant_spec( global, Spec_Global );
def_constant_spec( inline, Spec_Inline );
def_constant_spec( internal_linkage, Spec_Internal_Linkage );
def_constant_spec( local_persist, Spec_Local_Persist );
def_constant_spec( mutable, Spec_Mutable );
def_constant_spec( neverinline, Spec_NeverInline );
def_constant_spec( noexcept, Spec_NoExceptions );
def_constant_spec( override, Spec_Override );
def_constant_spec( ptr, Spec_Ptr );
def_constant_spec( pure, Spec_Pure )
def_constant_spec( ref, Spec_Ref );
def_constant_spec( register, Spec_Register );
def_constant_spec( rvalue, Spec_RValue );
def_constant_spec( static_member, Spec_Static );
def_constant_spec( thread_local, Spec_Thread_Local );
def_constant_spec( virtual, Spec_Virtual );
def_constant_spec( volatile, Spec_Volatile)
spec_const = def_specifier( Spec_Const); code_set_global( cast(Code, spec_const ));
spec_consteval = def_specifier( Spec_Consteval); code_set_global( cast(Code, spec_consteval ));;
spec_constexpr = def_specifier( Spec_Constexpr); code_set_global( cast(Code, spec_constexpr ));;
spec_constinit = def_specifier( Spec_Constinit); code_set_global( cast(Code, spec_constinit ));;
spec_extern_linkage = def_specifier( Spec_External_Linkage); code_set_global( cast(Code, spec_extern_linkage ));;
spec_final = def_specifier( Spec_Final); code_set_global( cast(Code, spec_final ));;
spec_forceinline = def_specifier( Spec_ForceInline); code_set_global( cast(Code, spec_forceinline ));;
spec_global = def_specifier( Spec_Global); code_set_global( cast(Code, spec_global ));;
spec_inline = def_specifier( Spec_Inline); code_set_global( cast(Code, spec_inline ));;
spec_internal_linkage = def_specifier( Spec_Internal_Linkage); code_set_global( cast(Code, spec_internal_linkage ));;
spec_local_persist = def_specifier( Spec_Local_Persist); code_set_global( cast(Code, spec_local_persist ));;
spec_mutable = def_specifier( Spec_Mutable); code_set_global( cast(Code, spec_mutable ));;
spec_neverinline = def_specifier( Spec_NeverInline); code_set_global( cast(Code, spec_neverinline ));;
spec_noexcept = def_specifier( Spec_NoExceptions); code_set_global( cast(Code, spec_noexcept ));;
spec_override = def_specifier( Spec_Override); code_set_global( cast(Code, spec_override ));;
spec_ptr = def_specifier( Spec_Ptr); code_set_global( cast(Code, spec_ptr ));;
spec_pure = def_specifier( Spec_Pure); code_set_global( cast(Code, spec_pure ));
spec_ref = def_specifier( Spec_Ref); code_set_global( cast(Code, spec_ref ));;
spec_register = def_specifier( Spec_Register); code_set_global( cast(Code, spec_register ));;
spec_rvalue = def_specifier( Spec_RValue); code_set_global( cast(Code, spec_rvalue ));;
spec_static_member = def_specifier( Spec_Static); code_set_global( cast(Code, spec_static_member ));;
spec_thread_local = def_specifier( Spec_Thread_Local); code_set_global( cast(Code, spec_thread_local ));;
spec_virtual = def_specifier( Spec_Virtual); code_set_global( cast(Code, spec_virtual ));;
spec_volatile = def_specifier( Spec_Volatile); code_set_global( cast(Code, spec_volatile ));
spec_local_persist = def_specifiers( 1, Spec_Local_Persist );
code_set_global(cast(Code, spec_local_persist));
# pragma pop_macro("forceinline")
# pragma pop_macro("global")
# pragma pop_macro("internal")
# pragma pop_macro("local_persist")
# pragma pop_macro("neverinline")
# pragma push_macro("enum_underlying")
array_append(PreprocessorDefines, txt("enum_underlying("));
# pragma pop_macro("enum_underlying")

101
project/components/interface.hpp
View File

@ -278,51 +278,64 @@ Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
#pragma region Macros
#ifndef gen_main
#define gen_main main
#endif
#ifndef name
// Convienence for defining any name used with the gen api.
// Lets you provide the length and string literal to the functions without the need for the DSL.
#define name( Id_ ) { sizeof(stringize( Id_ )) - 1, stringize(Id_) }
#endif
#ifndef code
// Same as name just used to indicate intention of literal for code instead of names.
#define code( ... ) { sizeof(stringize(__VA_ARGS__)) - 1, stringize( __VA_ARGS__ ) }
#endif
#ifndef args
// Provides the number of arguments while passing args inplace.
#define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__
#endif
#ifndef code_str
// Just wrappers over common untyped code definition constructions.
#define code_str( ... ) GEN_NS untyped_str( code( __VA_ARGS__ ) )
#endif
#ifndef code_fmt
#define code_fmt( ... ) GEN_NS untyped_str( token_fmt( __VA_ARGS__ ) )
#endif
#ifndef parse_fmt
#define parse_fmt( type, ... ) GEN_NS parse_##type( token_fmt( __VA_ARGS__ ) )
#endif
#ifndef token_fmt
# define gen_main main
# define __ NullCode
// Convienence for defining any name used with the gen api.
// Lets you provide the length and string literal to the functions without the need for the DSL.
# define name( Id_ ) { sizeof(stringize( Id_ )) - 1, stringize(Id_) }
// Same as name just used to indicate intention of literal for code instead of names.
# define code( ... ) { sizeof(stringize(__VA_ARGS__)) - 1, stringize( __VA_ARGS__ ) }
// Provides the number of arguments while passing args inplace.
# define args( ... ) num_args( __VA_ARGS__ ), __VA_ARGS__
// Just wrappers over common untyped code definition constructions.
# define code_str( ... ) GEN_NS untyped_str( code( __VA_ARGS__ ) )
# define code_fmt( ... ) GEN_NS untyped_str( token_fmt( __VA_ARGS__ ) )
# define parse_fmt( type, ... ) GEN_NS parse_##type( token_fmt( __VA_ARGS__ ) )
/*
Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
Tokens are provided in '<'identifier'>' format where '<' '>' are just angle brackets (you can change it in token_fmt_va)
---------------------------------------------------------
Example - A string with:
typedef <type> <name> <name>;
Will have a token_fmt arguments populated with:
"type", strc_for_type,
"name", strc_for_name,
and:
stringize( typedef <type> <name> <name>; )
-----------------------------------------------------------
So the full call for this example would be:
token_fmt(
"type", strc_for_type
, "name", strc_for_name
, stringize(
typedef <type> <name> <name>
));
!----------------------------------------------------------
! Note: token_fmt_va is whitespace sensitive for the tokens.
! This can be alleviated by skipping whitespace between brackets but it was choosen to not have that implementation by default.
*/
# define token_fmt( ... ) GEN_NS token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
/*
Takes a format string (char const*) and a list of tokens (StrC) and returns a StrC of the formatted string.
Tokens are provided in '<'identifier'>' format where '<' '>' are just angle brackets (you can change it in token_fmt_va)
---------------------------------------------------------
Example - A string with:
typedef <type> <name> <name>;
Will have a token_fmt arguments populated with:
"type", strc_for_type,
"name", strc_for_name,
and:
stringize( typedef <type> <name> <name>; )
-----------------------------------------------------------
So the full call for this example would be:
token_fmt(
"type", strc_for_type
, "name", strc_for_name
, stringize(
typedef <type> <name> <name>
));
!----------------------------------------------------------
! Note: token_fmt_va is whitespace sensitive for the tokens.
! This can be alleviated by skipping whitespace between brackets but it was choosen to not have that implementation by default.
*/
#define token_fmt( ... ) GEN_NS token_fmt_impl( (num_args( __VA_ARGS__ ) + 1) / 2, __VA_ARGS__ )
#endif
#pragma endregion Macros

36
project/components/interface.parsing.cpp
View File

@ -319,15 +319,27 @@ CodeVar parse_variable( StrC def )
}
// Undef helper macros
# undef check_parse_args
# undef currtok_noskip
# undef currtok
# undef peektok
# undef prevtok
# undef nexttok
# undef nexttok_noskip
# undef eat
# undef left
# undef check
# undef push_scope
# undef def_assign
#undef check_parse_args
#undef currtok_noskip
#undef currtok
#undef peektok
#undef prevtok
#undef nexttok
#undef nexttok_noskip
#undef eat
#undef left
#undef check
#undef push_scope
#undef def_assign
// Here for C Variant
#undef lex_dont_skip_formatting
#undef lex_skip_formatting
#undef parser_inplace_def
#undef parser_not_inplace_def
#undef parser_dont_consume_braces
#undef parser_consume_braces
#undef parser_not_from_template
#undef parser_use_parenthesis
#undef parser_strip_formatting_dont_preserve_newlines

1
project/components/interface.upfront.cpp
View File

@ -12,6 +12,7 @@ enum OpValidateResult : u32
OpValResult_Member
};
internal neverinline
OpValidateResult operator__validate( Operator op, CodeParam params_code, CodeTypename ret_type, CodeSpecifiers specifier )
{
if ( op == Op_Invalid )

2
project/dependencies/macros.hpp
View File

@ -355,7 +355,7 @@ size_t gen_example_hash__P_long_long( long long val ) { return val * 2654435761u
// If using an Editor with support for syntax hightlighting macros: HASH__ARGS_SIG_1 and HASH_ARGS_SIG_2 should show color highlighting indicating the slot is enabled,
// or, "defined" for usage during the compilation pass that handles the _Generic instrinsic.
#define hash( function_arguments ) _Generic( \
#define gen_hash_example( function_arguments ) _Generic( \
(function_arguments), /* Select Via Expression*/ \
/* Extendibility slots: */ \
GEN_IF_MACRO_DEFINED_INCLUDE_THIS_SLOT( HASH__ARGS_SIG_1 ) \

2
project/dependencies/memory.hpp
View File

@ -215,7 +215,7 @@ struct Arena
#endif
};
#if GEN_COMPILER_CPP && ! GEN_C_LIKECPP
#if GEN_COMPILER_CPP && ! GEN_C_LIKE_CPP
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); }

8
project/dependencies/strings.hpp
View File

@ -626,7 +626,7 @@ StrC string_to_strc(String str) {
}
inline
void trim(String str, char const* cut_set)
void string_trim(String str, char const* cut_set)
{
ssize len = 0;
@ -650,12 +650,12 @@ void trim(String str, char const* cut_set)
}
forceinline
void trim_space(String str) {
trim(str, " \t\r\n\v\f");
void string_trim_space(String str) {
string_trim(str, " \t\r\n\v\f");
}
inline
String visualize_whitespace(String const str)
String string_visualize_whitespace(String const str)
{
StringHeader* header = (StringHeader*)(scast(char const*, str) - sizeof(StringHeader));
String result = string_make_reserve(header->Allocator, string_length(str) * 2); // Assume worst case for space requirements.