Compare commits
28
Commits
main
...
050019c8c0
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
050019c8c0 | ||
|
|
cc7fdac795 | ||
|
|
4140e7e237 | ||
|
|
1a60fd54fc | ||
|
|
b754adcd96 | ||
|
|
61d53362e8 | ||
|
|
f044c6d5eb | ||
|
|
a2b5163341 | ||
|
|
286552c3c3 | ||
|
|
822a3b07dc | ||
|
|
685bba36d5 | ||
|
|
346e8e3305 | ||
|
|
bfc754e66c | ||
|
|
84f4fc5ae9 | ||
|
|
ad5cb6597b | ||
|
|
1c7dd4ab32 | ||
|
|
1e7fdcec16 | ||
|
|
2ed36506b1 | ||
|
|
790087aa3c | ||
|
|
441a46daaa | ||
|
|
26623075ad | ||
|
|
7ea90ef349 | ||
|
|
6d531fdf97 | ||
|
|
3b81eea688 | ||
|
|
844d431e1c | ||
|
|
727b54c341 | ||
|
|
ef72d27f3e | ||
|
|
75b1d42cca |
No files matched your search
@@ -3,7 +3,7 @@
|
||||
# include "helpers/push_ignores.inline.hpp"
|
||||
# include "components/header_start.hpp"
|
||||
# include "components/types.hpp"
|
||||
# include "components/gen/ecode.hpp"
|
||||
# include "components/gen/ecodetypes.hpp"
|
||||
# include "components/gen/eoperator.hpp"
|
||||
# include "components/gen/especifier.hpp"
|
||||
# include "components/ast.hpp"
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
# include "helpers/push_ignores.inline.hpp"
|
||||
# include "components/header_start.hpp"
|
||||
# include "components/types.hpp"
|
||||
# include "components/gen/ecode.hpp"
|
||||
# include "components/gen/ecodetypes.hpp"
|
||||
# include "components/gen/eoperator.hpp"
|
||||
# include "components/gen/especifier.hpp"
|
||||
# include "components/ast.hpp"
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
#ifdef INTELLISENSE_DIRECTIVES
|
||||
#pragma once
|
||||
#include "types.hpp"
|
||||
#include "gen/ecode.hpp"
|
||||
#include "gen/eoperator.hpp"
|
||||
#include "gen/especifier.hpp"
|
||||
#include "parser_types.hpp"
|
||||
#endif
|
||||
|
||||
/*
|
||||
@@ -406,7 +403,8 @@ struct AST
|
||||
Code PostNameMacro; // Only used with parameters for specifically UE_REQUIRES (Thanks Unreal)
|
||||
};
|
||||
};
|
||||
StrCached Content; // Attributes, Comment, Execution, Include
|
||||
StrCached Content; // Attributes, Comment, Execution, Include
|
||||
TokenSlice ContentToks; // TODO(Ed): Use a token slice for content
|
||||
struct {
|
||||
Specifier ArrSpecs[AST_ArrSpecs_Cap]; // Specifiers
|
||||
Code NextSpecs; // Specifiers; If ArrSpecs is full, then NextSpecs is used.
|
||||
@@ -422,7 +420,7 @@ struct AST
|
||||
Code Next;
|
||||
Code Back;
|
||||
};
|
||||
Token* Token; // Reference to starting token, only available if it was derived from parsing.
|
||||
Token* Token; // Reference to starting token, only available if it was derived from parsing. // TODO(Ed): Change this to a token slice.
|
||||
Code Parent;
|
||||
CodeType Type;
|
||||
// CodeFlag CodeFlags;
|
||||
|
||||
@@ -1077,7 +1077,8 @@ struct AST_Typedef
|
||||
struct
|
||||
{
|
||||
CodeComment InlineCmt;
|
||||
char _PAD_PROPERTIES_[ sizeof(AST*) * 2 ];
|
||||
CodeAttributes Attributes;
|
||||
char _PAD_PROPERTIES_[ sizeof(AST*) ];
|
||||
Code UnderlyingType;
|
||||
char _PAD_PROPERTIES_2_[ sizeof(AST*) * 3 ];
|
||||
};
|
||||
|
||||
@@ -38,13 +38,13 @@ void body_to_strbuilder_export( CodeBody body, StrBuilder* result )
|
||||
GEN_ASSERT(result != nullptr);
|
||||
strbuilder_append_fmt( result, "export\n{\n" );
|
||||
|
||||
Code curr = cast(Code, body);
|
||||
Code curr = body->Front;
|
||||
s32 left = body->NumEntries;
|
||||
while ( left-- )
|
||||
{
|
||||
code_to_strbuilder_ref(curr, result);
|
||||
// strbuilder_append_fmt( result, "%SB", code_to_strbuilder(curr) );
|
||||
++curr;
|
||||
curr = curr->Next;
|
||||
}
|
||||
|
||||
strbuilder_append_fmt( result, "};\n" );
|
||||
@@ -158,7 +158,7 @@ void class_to_strbuilder_def( CodeClass self, StrBuilder* result )
|
||||
if ( self->ParentType )
|
||||
{
|
||||
Str access_level = access_spec_to_str( self->ParentAccess );
|
||||
strbuilder_append_fmt( result, " : %S %SB", self->Name, access_level, typename_to_strbuilder(self->ParentType) );
|
||||
strbuilder_append_fmt( result, " : %S %SB", access_level, typename_to_strbuilder(self->ParentType) );
|
||||
|
||||
CodeTypename interface = cast(CodeTypename, self->ParentType->Next);
|
||||
if ( interface )
|
||||
@@ -263,12 +263,12 @@ void destructor_to_strbuilder_def(CodeDestructor self, StrBuilder* result )
|
||||
else if ( self->Specs )
|
||||
{
|
||||
if ( specifiers_has(self->Specs, Spec_Virtual ) )
|
||||
strbuilder_append_fmt( result, "virtual ~%S()", self->Parent->Name );
|
||||
strbuilder_append_fmt( result, "virtual ~%S()", self->Parent->Parent->Name );
|
||||
else
|
||||
strbuilder_append_fmt( result, "~%S()", self->Parent->Name );
|
||||
strbuilder_append_fmt( result, "~%S()", self->Parent->Parent->Name );
|
||||
}
|
||||
else
|
||||
strbuilder_append_fmt( result, "~%S()", self->Parent->Name );
|
||||
strbuilder_append_fmt( result, "~%S()", self->Parent->Parent->Name );
|
||||
|
||||
strbuilder_append_fmt( result, "\n{\n%SB\n}\n", code_to_strbuilder(self->Body) );
|
||||
}
|
||||
@@ -629,9 +629,6 @@ void code_op_to_strbuilder_def(CodeOperator self, StrBuilder* result )
|
||||
if ( self->Attributes )
|
||||
strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
|
||||
|
||||
if ( self->Attributes )
|
||||
strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
|
||||
|
||||
if ( self->Specs )
|
||||
{
|
||||
for ( Specifier* spec = begin_CodeSpecifiers(self->Specs); spec != end_CodeSpecifiers(self->Specs); spec = next_CodeSpecifiers(self->Specs, spec) )
|
||||
@@ -644,8 +641,7 @@ void code_op_to_strbuilder_def(CodeOperator self, StrBuilder* result )
|
||||
}
|
||||
}
|
||||
|
||||
if ( self->Attributes || self->Specs )
|
||||
{
|
||||
if ( self->Attributes || self->Specs ) {
|
||||
strbuilder_append_str( result, txt("\n") );
|
||||
}
|
||||
|
||||
@@ -1021,6 +1017,9 @@ void typedef_to_strbuilder_ref(CodeTypedef self, StrBuilder* result )
|
||||
if ( bitfield_is_set( u32, self->ModuleFlags, ModuleFlag_Export ))
|
||||
strbuilder_append_str( result, txt("export ") );
|
||||
|
||||
if ( self->Attributes )
|
||||
strbuilder_append_fmt( result, "%SB ", attributes_to_strbuilder(self->Attributes) );
|
||||
|
||||
strbuilder_append_str( result, txt("typedef "));
|
||||
|
||||
// Determines if the typedef is a function typename
|
||||
|
||||
@@ -253,7 +253,7 @@ struct CodeSpecifiers
|
||||
Using_Code( CodeSpecifiers );
|
||||
bool append( Specifier spec ) { return specifiers_append(* this, spec); }
|
||||
bool has( Specifier spec ) { return specifiers_has(* this, spec); }
|
||||
s32 index_of(Specifier spec) { return specifiers_index_of(* this, spec); }
|
||||
s32 index_of( Specifier spec ) { return specifiers_index_of(* this, spec); }
|
||||
s32 remove( Specifier to_remove ) { return specifiers_remove(* this, to_remove); }
|
||||
StrBuilder to_strbuilder() { return specifiers_to_strbuilder(* this ); }
|
||||
void to_strbuilder( StrBuilder& result ) { return specifiers_to_strbuilder_ref(* this, & result); }
|
||||
@@ -1074,12 +1074,12 @@ forceinline bool has_entries (CodeParams params ) {
|
||||
forceinline StrBuilder to_strbuilder(CodeParams params ) { return params_to_strbuilder(params); }
|
||||
forceinline void to_strbuilder(CodeParams params, StrBuilder& result ) { return params_to_strbuilder_ref(params, & result); }
|
||||
|
||||
forceinline bool append (CodeSpecifiers specifiers, Specifier spec) { return specifiers_append(specifiers, spec); }
|
||||
forceinline bool has (CodeSpecifiers specifiers, Specifier spec) { return specifiers_has(specifiers, spec); }
|
||||
forceinline s32 index_of (CodeSpecifiers specifiers, Specifier spec) { return specifiers_index_of(specifiers, spec); }
|
||||
forceinline s32 remove (CodeSpecifiers specifiers, Specifier to_remove ) { return specifiers_remove(specifiers, to_remove); }
|
||||
forceinline StrBuilder to_strbuilder(CodeSpecifiers specifiers) { return specifiers_to_strbuilder(specifiers); }
|
||||
forceinline void to_strbuilder(CodeSpecifiers specifiers, StrBuilder& result) { return specifiers_to_strbuilder_ref(specifiers, & result); }
|
||||
forceinline bool append (CodeSpecifiers specifiers, Specifier spec) { return specifiers_append(specifiers, spec); }
|
||||
forceinline bool has (CodeSpecifiers specifiers, Specifier spec) { return specifiers_has(specifiers, spec); }
|
||||
forceinline s32 index_of (CodeSpecifiers specifiers, Specifier spec) { return specifiers_index_of(specifiers, spec); }
|
||||
forceinline s32 remove (CodeSpecifiers specifiers, Specifier to_remove ) { return specifiers_remove(specifiers, to_remove); }
|
||||
forceinline StrBuilder to_strbuilder (CodeSpecifiers specifiers) { return specifiers_to_strbuilder(specifiers); }
|
||||
forceinline void to_strbuilder (CodeSpecifiers specifiers, StrBuilder& result) { return specifiers_to_strbuilder_ref(specifiers, & result); }
|
||||
|
||||
forceinline void add_interface (CodeStruct self, CodeTypename interface) { return struct_add_interface(self, interface); }
|
||||
forceinline StrBuilder to_strbuilder (CodeStruct self) { return struct_to_strbuilder(self); }
|
||||
|
||||
@@ -6,6 +6,8 @@
|
||||
#pragma region Constants
|
||||
// Predefined typename codes. Are set to readonly and are setup during gen::init()
|
||||
|
||||
GEN_API extern Token NullToken;
|
||||
|
||||
GEN_API extern Macro enum_underlying_macro;
|
||||
|
||||
GEN_API extern Code access_public;
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#ifdef INTELLISENSE_DIRECTIVES
|
||||
#pragma once
|
||||
#include "interface.hpp"
|
||||
#include "constants.hpp"
|
||||
#endif
|
||||
|
||||
#pragma region Serialization
|
||||
@@ -38,7 +38,7 @@ void body_to_strbuilder_ref( CodeBody body, StrBuilder* result )
|
||||
{
|
||||
code_to_strbuilder_ref(curr, result);
|
||||
// strbuilder_append_fmt( result, "%SB", code_to_strbuilder(curr) );
|
||||
++curr;
|
||||
curr = curr->Next;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -3,8 +3,8 @@
|
||||
#include "code_serialization.cpp"
|
||||
#endif
|
||||
|
||||
internal void parser_init();
|
||||
internal void parser_deinit();
|
||||
internal void parser_init(Context* ctx);
|
||||
internal void parser_deinit(Context* ctx);
|
||||
|
||||
internal
|
||||
void* fallback_allocator_proc( void* allocator_data, AllocType type, ssize size, ssize alignment, void* old_memory, ssize old_size, u64 flags )
|
||||
@@ -71,6 +71,14 @@ void* fallback_allocator_proc( void* allocator_data, AllocType type, ssize size,
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
internal
|
||||
void fallback_logger(LogEntry entry)
|
||||
{
|
||||
GEN_ASSERT(entry.msg.Len > 0);
|
||||
GEN_ASSERT(entry.msg.Ptr);
|
||||
log_fmt("%S: %S", loglevel_to_str(entry.level), entry.msg);
|
||||
}
|
||||
|
||||
internal
|
||||
void define_constants()
|
||||
{
|
||||
@@ -283,6 +291,19 @@ void init(Context* ctx)
|
||||
ctx->InitSize_Fallback_Allocator_Bucket_Size = megabytes(8);
|
||||
}
|
||||
|
||||
if (ctx->InitSize_StrCacheTable == 0)
|
||||
{
|
||||
ctx->InitSize_StrCacheTable = kilobytes(8);
|
||||
}
|
||||
if (ctx->InitSize_MacrosTable == 0)
|
||||
{
|
||||
ctx->InitSize_MacrosTable = kilobytes(8);
|
||||
}
|
||||
|
||||
if (ctx->Logger == nullptr) {
|
||||
ctx->Logger = & fallback_logger;
|
||||
}
|
||||
|
||||
// Override the current context (user has to put it back if unwanted).
|
||||
_ctx = ctx;
|
||||
|
||||
@@ -298,7 +319,7 @@ void init(Context* ctx)
|
||||
}
|
||||
// Setup the code pool and code entries arena.
|
||||
{
|
||||
Pool code_pool = pool_init( ctx->Allocator_Pool, ctx->CodePool_NumBlocks, sizeof(AST) );
|
||||
Pool code_pool = pool_init( ctx->Allocator_Pool, ctx->CodePool_NumBlocks, size_of(AST) );
|
||||
if ( code_pool.PhysicalStart == nullptr )
|
||||
GEN_FATAL( "gen::init: Failed to initialize the code pool" );
|
||||
array_append( ctx->CodePools, code_pool );
|
||||
@@ -311,18 +332,18 @@ void init(Context* ctx)
|
||||
}
|
||||
// Setup the hash tables
|
||||
{
|
||||
ctx->StrCache = hashtable_init(StrCached, ctx->Allocator_DyanmicContainers);
|
||||
ctx->StrCache = hashtable_init_reserve(StrCached, ctx->Allocator_DyanmicContainers, ctx->InitSize_StrCacheTable);
|
||||
if ( ctx->StrCache.Entries == nullptr )
|
||||
GEN_FATAL( "gen::init: Failed to initialize the StringCache");
|
||||
|
||||
ctx->Macros = hashtable_init(Macro, ctx->Allocator_DyanmicContainers);
|
||||
ctx->Macros = hashtable_init_reserve(Macro, ctx->Allocator_DyanmicContainers, ctx->InitSize_MacrosTable);
|
||||
if (ctx->Macros.Hashes == nullptr || ctx->Macros.Entries == nullptr) {
|
||||
GEN_FATAL( "gen::init: Failed to initialize the PreprocessMacros table" );
|
||||
}
|
||||
}
|
||||
|
||||
define_constants();
|
||||
parser_init();
|
||||
parser_init(ctx);
|
||||
|
||||
++ context_counter;
|
||||
}
|
||||
@@ -371,7 +392,7 @@ void deinit(Context* ctx)
|
||||
while ( left--, left );
|
||||
array_free( ctx->Fallback_AllocatorBuckets);
|
||||
}
|
||||
parser_deinit();
|
||||
parser_deinit(ctx);
|
||||
|
||||
if (_ctx == ctx)
|
||||
_ctx = nullptr;
|
||||
|
||||
@@ -15,24 +15,13 @@
|
||||
\▓▓▓▓▓▓ \▓▓▓▓▓▓▓\▓▓ \▓▓ \▓▓▓▓▓▓\▓▓ \▓▓ \▓▓▓▓ \▓▓▓▓▓▓▓\▓▓ \▓▓ \▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓ \▓▓▓▓▓▓▓
|
||||
*/
|
||||
|
||||
#if 0
|
||||
enum LogLevel : u32
|
||||
struct ParseInfo
|
||||
{
|
||||
Info,
|
||||
Warning,
|
||||
Panic,
|
||||
ParseMessage* messages;
|
||||
LexedInfo lexed;
|
||||
Code result;
|
||||
};
|
||||
|
||||
struct LogEntry
|
||||
{
|
||||
Str msg;
|
||||
u32 line_num;
|
||||
void* data;
|
||||
};
|
||||
|
||||
typedef void LoggerCallback(LogEntry entry);
|
||||
#endif
|
||||
|
||||
// Note(Ed): This is subject to heavily change
|
||||
// with upcoming changes to the library's fallback (default) allocations strategy;
|
||||
// and major changes to lexer/parser context usage.
|
||||
@@ -64,9 +53,16 @@ struct Context
|
||||
u32 InitSize_LexerTokens;
|
||||
u32 SizePer_StringArena;
|
||||
|
||||
u32 InitSize_StrCacheTable;
|
||||
u32 InitSize_MacrosTable;
|
||||
|
||||
// TODO(Ed): Symbol Table
|
||||
// Keep track of all resolved symbols (naemspaced identifiers)
|
||||
|
||||
// Logging
|
||||
|
||||
LoggerProc* Logger;
|
||||
|
||||
// Parser
|
||||
|
||||
// Used by the lexer to persistently treat all these identifiers as preprocessor defines.
|
||||
@@ -89,11 +85,9 @@ struct Context
|
||||
|
||||
StringTable StrCache;
|
||||
|
||||
// TODO(Ed): This needs to be just handled by a parser context
|
||||
Array(Token) Lexer_Tokens;
|
||||
|
||||
// TODO(Ed): Active parse context vs a parse result need to be separated conceptually
|
||||
ParseContext parser;
|
||||
ParseInfo parse_info;
|
||||
|
||||
// TODO(Ed): Formatting - This will eventually be in a separate struct when in the process of serialization of the builder.
|
||||
s32 temp_serialize_indent;
|
||||
@@ -104,6 +98,37 @@ struct Context
|
||||
// An implicit context interface will be provided instead as wrapper procedures as convience.
|
||||
GEN_API extern Context* _ctx;
|
||||
|
||||
// TODO(Ed): Swap all usage of this with logger_fmt (then rename logger_fmt to log_fmt)
|
||||
inline
|
||||
ssize log_fmt(char const* fmt, ...)
|
||||
{
|
||||
ssize res;
|
||||
va_list va;
|
||||
|
||||
va_start(va, fmt);
|
||||
res = c_str_fmt_out_va(fmt, va);
|
||||
va_end(va);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
inline
|
||||
void logger_fmt(Context* ctx, LogLevel level, char const* fmt, ...)
|
||||
{
|
||||
local_persist thread_local
|
||||
PrintF_Buffer buf = struct_zero_init();
|
||||
|
||||
va_list va;
|
||||
va_start(va, fmt);
|
||||
ssize res = c_str_fmt_va(buf, GEN_PRINTF_MAXLEN, fmt, va) -1;
|
||||
va_end(va);
|
||||
|
||||
StrBuilder msg = strbuilder_make_length(ctx->Allocator_Temp, buf, res);
|
||||
|
||||
LogEntry entry = { strbuilder_to_str(msg), level };
|
||||
ctx->Logger(entry);
|
||||
}
|
||||
|
||||
// Initialize the library. There first ctx initialized must exist for lifetime of other contextes that come after as its the one that
|
||||
GEN_API void init(Context* ctx);
|
||||
|
||||
@@ -114,7 +139,7 @@ GEN_API void deinit(Context* ctx);
|
||||
// Retrieves the active context (not usually needed, but here in case...)
|
||||
GEN_API Context* get_context();
|
||||
|
||||
// Clears the allocations, but doesn't free the memoery, then calls init() again.
|
||||
// Clears the allocations, but doesn't free the memory, then calls init() again.
|
||||
// Ease of use.
|
||||
GEN_API void reset(Context* ctx);
|
||||
|
||||
@@ -334,37 +359,26 @@ forceinline CodeBody def_union_body ( s32 num, Code* codes )
|
||||
|
||||
#pragma region Parsing
|
||||
|
||||
#if 0
|
||||
struct StackNode
|
||||
struct ParseStackNode
|
||||
{
|
||||
StackNode* Prev;
|
||||
ParseStackNode* prev;
|
||||
|
||||
Token Start;
|
||||
Token Name; // The name of the AST node (if parsed)
|
||||
Str FailedProc; // The name of the procedure that failed
|
||||
};
|
||||
// Stack nodes are allocated the error's allocator
|
||||
|
||||
struct Error
|
||||
{
|
||||
StrBuilder message;
|
||||
StackNode* context_stack;
|
||||
TokenSlice tokens;
|
||||
Token* start;
|
||||
Str name; // The name of the AST node (if parsed)
|
||||
Str proc_name; // The name of the procedure
|
||||
Code code_rel; // Relevant AST node
|
||||
// TODO(Ed): When an error occurs, the parse stack is not released and instead the scope is left dangling.
|
||||
};
|
||||
|
||||
struct ParseInfo
|
||||
struct ParseOpts
|
||||
{
|
||||
Arena FileMem;
|
||||
Arena TokMem;
|
||||
Arena CodeMem;
|
||||
|
||||
FileContents FileContent;
|
||||
Array<Token> Tokens;
|
||||
Array<Error> Errors;
|
||||
// Errors are allocated to a dedicated general arena.
|
||||
AllocatorInfo backing_msgs;
|
||||
AllocatorInfo backing_tokens;
|
||||
AllocatorInfo backing_ast;
|
||||
};
|
||||
|
||||
CodeBody parse_file( Str path );
|
||||
#endif
|
||||
ParseInfo wip_parse_str( LexedInfo lexed, ParseOpts* opts GEN_PARAM_DEFAULT );
|
||||
|
||||
GEN_API CodeClass parse_class ( Str class_def );
|
||||
GEN_API CodeConstructor parse_constructor ( Str constructor_def );
|
||||
@@ -375,7 +389,15 @@ GEN_API CodeBody parse_export_body ( Str export_def );
|
||||
GEN_API CodeExtern parse_extern_link ( Str exten_link_def );
|
||||
GEN_API CodeFriend parse_friend ( Str friend_def );
|
||||
GEN_API CodeFn parse_function ( Str fn_def );
|
||||
GEN_API CodeBody parse_global_body ( Str body_def );
|
||||
|
||||
struct Opts_parse_global_body
|
||||
{
|
||||
Context* ctx;
|
||||
ParseInfo* info;
|
||||
};
|
||||
GEN_API void parse_global_body_base( Context* ctx, Str body_def, ParseInfo* info );
|
||||
GEN_API CodeBody parse_global_body( Str body_def, Opts_parse_global_body opts GEN_PARAM_DEFAULT );
|
||||
|
||||
GEN_API CodeNS parse_namespace ( Str namespace_def );
|
||||
GEN_API CodeOperator parse_operator ( Str operator_def );
|
||||
GEN_API CodeOpCast parse_operator_cast( Str operator_def );
|
||||
@@ -395,9 +417,10 @@ GEN_API ssize token_fmt_va( char* buf, usize buf_size, s32 num_tokens, va_list v
|
||||
//! Do not use directly. Use the token_fmt macro instead.
|
||||
Str token_fmt_impl( ssize, ... );
|
||||
|
||||
GEN_API Code untyped_str( Str content);
|
||||
GEN_API Code untyped_str ( Str content);
|
||||
GEN_API Code untyped_fmt ( char const* fmt, ... );
|
||||
GEN_API Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... );
|
||||
GEN_API Code untyped_toks ( TokenSlice tokens );
|
||||
|
||||
#pragma endregion Untyped text
|
||||
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#ifdef INTELLISENSE_DIRECTIVES
|
||||
#pragma once
|
||||
#include "gen/etoktype.cpp"
|
||||
#include "gen/etoktype.hpp"
|
||||
#include "interface.upfront.cpp"
|
||||
#include "lexer.cpp"
|
||||
#include "parser.cpp"
|
||||
@@ -8,28 +8,95 @@
|
||||
|
||||
// Publically Exposed Interface
|
||||
|
||||
ParseInfo wip_parse_str(LexedInfo lexed, ParseOpts* opts)
|
||||
{
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
ParseInfo info = struct_zero(ParseInfo);
|
||||
|
||||
if (lexed.tokens.num == 0 && lexed.tokens.ptr == nullptr) {
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(lexed.text) == false) {
|
||||
info.messages = ctx->parser.messages;
|
||||
goto done;
|
||||
}
|
||||
lexed = lex(ctx, lexed.text);
|
||||
}
|
||||
info.lexed = lexed;
|
||||
|
||||
// TODO(Ed): ParseInfo should be set to the parser context.
|
||||
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
|
||||
{
|
||||
ParseStackNode scope = NullScope;
|
||||
parser_push(& ctx->parser, & scope);
|
||||
|
||||
CodeBody result = parse_global_nspace(ctx,CT_Global_Body);
|
||||
(void)result;
|
||||
|
||||
parser_pop(& ctx->parser);
|
||||
}
|
||||
done:
|
||||
return info;
|
||||
}
|
||||
|
||||
CodeClass parse_class( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeClass result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
push_scope();
|
||||
CodeClass result = (CodeClass) parse_class_struct( Tok_Decl_Class, parser_not_inplace_def );
|
||||
parser_pop(& _ctx->parser);
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
{
|
||||
ParseStackNode scope = NullScope;
|
||||
parser_push(& ctx->parser, & scope);
|
||||
result = (CodeClass) parse_class_struct( ctx, Tok_Decl_Class, parser_not_inplace_def );
|
||||
parser_pop(& ctx->parser);
|
||||
}
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeConstructor parse_constructor( Str def )
|
||||
CodeConstructor parse_constructor(Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeConstructor result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
{
|
||||
ParseStackNode scope = NullScope;
|
||||
parser_push(& ctx->parser, & scope);
|
||||
|
||||
// TODO(Ed): Constructors can have prefix attributes
|
||||
|
||||
@@ -57,9 +124,9 @@ CodeConstructor parse_constructor( Str def )
|
||||
break;
|
||||
|
||||
default :
|
||||
log_failure( "Invalid specifier %s for variable\n%S", spec_to_str( spec ), parser_to_strbuilder(_ctx->parser) );
|
||||
parser_pop(& _ctx->parser);
|
||||
return InvalidCode;
|
||||
log_failure( "Invalid specifier %s for variable\n%S", spec_to_str( spec ), parser_to_strbuilder(& ctx->parser, ctx->Allocator_Temp) );
|
||||
parser_pop(& ctx->parser);
|
||||
goto done;
|
||||
}
|
||||
|
||||
// Every specifier after would be considered part of the type type signature
|
||||
@@ -71,247 +138,526 @@ CodeConstructor parse_constructor( Str def )
|
||||
eat( currtok.Type );
|
||||
}
|
||||
|
||||
if ( NumSpecifiers )
|
||||
{
|
||||
if ( NumSpecifiers ) {
|
||||
specifiers = def_specifiers_arr( NumSpecifiers, specs_found );
|
||||
// <specifiers> ...
|
||||
}
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
CodeConstructor result = parser_parse_constructor( specifiers );
|
||||
result = parser_parse_constructor(ctx, specifiers);
|
||||
parser_pop(& ctx->parser);
|
||||
}
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeDefine parse_define( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeDefine result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
push_scope();
|
||||
CodeDefine result = parser_parse_define();
|
||||
parser_pop(& _ctx->parser);
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
{
|
||||
ParseStackNode scope = NullScope;
|
||||
parser_push(& ctx->parser, & scope);
|
||||
result = parser_parse_define(ctx);
|
||||
parser_pop(& ctx->parser);
|
||||
}
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeDestructor parse_destructor( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeDestructor result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
// TODO(Ed): Destructors can have prefix attributes
|
||||
// TODO(Ed): Destructors can have virtual
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
CodeDestructor result = parser_parse_destructor(NullCode);
|
||||
result = parser_parse_destructor(ctx, NullCode);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeEnum parse_enum( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeEnum result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
{
|
||||
parser_pop(& _ctx->parser);
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return parser_parse_enum( parser_not_inplace_def);
|
||||
result = parser_parse_enum(ctx, parser_not_inplace_def);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeBody parse_export_body( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeBody result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return parser_parse_export_body();
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = parser_parse_export_body(ctx);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeExtern parse_extern_link( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeExtern result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return parser_parse_extern_link();
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = parser_parse_extern_link(ctx);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeFriend parse_friend( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeFriend result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return parser_parse_friend();
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = parser_parse_friend(ctx);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeFn parse_function( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeFn result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return (CodeFn) parser_parse_function();
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = (CodeFn) parser_parse_function(ctx);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeBody parse_global_body( Str def )
|
||||
void parse_global_body_base( Context* ctx, Str def, ParseInfo* info )
|
||||
{
|
||||
check_parse_args( def );
|
||||
LexedInfo lexed;
|
||||
CodeBody body;
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
if ( ctx == nullptr || info == nullptr )
|
||||
GEN_FATAL( "parse_global_body_base: null context or info" );
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
push_scope();
|
||||
CodeBody result = parse_global_nspace( CT_Global_Body );
|
||||
parser_pop(& _ctx->parser);
|
||||
return result;
|
||||
info[0] = struct_zero( ParseInfo );
|
||||
lexed = struct_zero( LexedInfo );
|
||||
body = (CodeBody) make_code();
|
||||
body->Type = CT_Global_Body;
|
||||
|
||||
ctx->parser = struct_zero( ParseContext );
|
||||
if ( check_parse_args( def ) == false ) {
|
||||
info->result = cast( Code, body );
|
||||
info->messages = ctx->parser.messages;
|
||||
return;
|
||||
}
|
||||
|
||||
lexed = lex( ctx, def );
|
||||
info->lexed = lexed;
|
||||
if ( lexed.tokens.num == 0 ) {
|
||||
info->result = cast( Code, body );
|
||||
info->messages = ctx->parser.messages;
|
||||
return;
|
||||
}
|
||||
|
||||
ctx->parser.tokens = lexed.tokens; {
|
||||
ParseStackNode scope = NullScope;
|
||||
parser_push( & ctx->parser, & scope );
|
||||
body = parse_global_nspace( ctx, CT_Global_Body );
|
||||
parser_pop( & ctx->parser );
|
||||
}
|
||||
info->result = cast( Code, body );
|
||||
info->messages = ctx->parser.messages;
|
||||
}
|
||||
|
||||
CodeBody parse_global_body( Str def, Opts_parse_global_body opts ) {
|
||||
Opts_parse_global_body resolved = get_optional( opts );
|
||||
Context* ctx = resolved.ctx;
|
||||
ParseInfo* info;
|
||||
|
||||
if ( ctx == nullptr ) ctx = _ctx;
|
||||
if ( ctx == nullptr ) GEN_FATAL( "parse_global_body: no context" );
|
||||
info = resolved.info; if ( info == nullptr ) info = & ctx->parse_info;
|
||||
|
||||
parse_global_body_base( ctx, def, info );
|
||||
return cast( CodeBody, info->result );
|
||||
}
|
||||
|
||||
CodeNS parse_namespace( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeNS result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return parser_parse_namespace();
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = parser_parse_namespace(ctx);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeOperator parse_operator( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeOperator result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return (CodeOperator) parser_parse_operator();
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = (CodeOperator) parser_parse_operator(ctx);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeOpCast parse_operator_cast( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeOpCast result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return parser_parse_operator_cast(NullCode);
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = parser_parse_operator_cast(ctx, NullCode);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeStruct parse_struct( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeStruct result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
push_scope();
|
||||
CodeStruct result = (CodeStruct) parse_class_struct( Tok_Decl_Struct, parser_not_inplace_def );
|
||||
parser_pop(& _ctx->parser);
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
{
|
||||
ParseStackNode scope = NullScope;
|
||||
parser_push(& ctx->parser, & scope);
|
||||
result = (CodeStruct) parse_class_struct( ctx, Tok_Decl_Struct, parser_not_inplace_def );
|
||||
parser_pop(& ctx->parser);
|
||||
}
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeTemplate parse_template( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeTemplate result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return parser_parse_template();
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = parser_parse_template(ctx);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeTypename parse_type( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeTypename result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return parser_parse_type( parser_not_from_template, nullptr);
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = parser_parse_type( ctx, parser_not_from_template, nullptr);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeTypedef parse_typedef( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeTypedef result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return parser_parse_typedef();
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = parser_parse_typedef(ctx);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeUnion parse_union( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeUnion result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return parser_parse_union( parser_not_inplace_def);
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = parser_parse_union(ctx, parser_not_inplace_def);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeUsing parse_using( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeUsing result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return parser_parse_using();
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = parser_parse_using(ctx);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeVar parse_variable( Str def )
|
||||
{
|
||||
check_parse_args( def );
|
||||
// TODO(Ed): Lift this.
|
||||
Context* ctx = _ctx;
|
||||
CodeVar result = InvalidCode;
|
||||
LexedInfo lexed = struct_zero(LexedInfo);
|
||||
|
||||
TokArray toks = lex( def );
|
||||
if ( toks.Arr == nullptr )
|
||||
return InvalidCode;
|
||||
ctx->parser = struct_zero(ParseContext);
|
||||
if (check_parse_args(def) == false)
|
||||
goto done;
|
||||
|
||||
_ctx->parser.Tokens = toks;
|
||||
return parser_parse_variable();
|
||||
lexed = lex(ctx, def);
|
||||
ctx->parser.tokens = lexed.tokens;
|
||||
if (lexed.messages != nullptr || ctx->parser.tokens.num == 0) {
|
||||
if (lexed.messages != nullptr && lexed.messages->content.Ptr != nullptr)
|
||||
parser_record_failure(ctx, lexed.messages->content);
|
||||
else
|
||||
parser_record_failure(ctx, txt("parse: lex produced no tokens"));
|
||||
goto done;
|
||||
}
|
||||
if (parser_slice_is_formatting_only(&ctx->parser)) {
|
||||
parser_record_failure(ctx, txt("parse_variable: only formatting tokens"));
|
||||
goto done;
|
||||
}
|
||||
|
||||
result = parser_parse_variable(ctx);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
// Undef helper macros
|
||||
@@ -326,6 +672,7 @@ CodeVar parse_variable( Str def )
|
||||
#undef left
|
||||
#undef check
|
||||
#undef push_scope
|
||||
#undef NullScope
|
||||
#undef def_assign
|
||||
|
||||
// Here for C Variant
|
||||
|
||||
@@ -176,3 +176,16 @@ Code untyped_token_fmt( s32 num_tokens, char const* fmt, ... )
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
Code untyped_toks( TokenSlice tokens )
|
||||
{
|
||||
if ( tokens.num == 0 ) {
|
||||
log_failure( "untyped_toks: empty token slice" );
|
||||
return InvalidCode;
|
||||
}
|
||||
Code
|
||||
result = make_code();
|
||||
result->Type = CT_Untyped;
|
||||
result->ContentToks = tokens;
|
||||
return result;
|
||||
}
|
||||
@@ -473,8 +473,10 @@ CodeComment def_comment( Str content )
|
||||
return (CodeComment) result;
|
||||
}
|
||||
|
||||
CodeConstructor def_constructor( Opts_def_constructor p )
|
||||
CodeConstructor def_constructor( Opts_def_constructor opt )
|
||||
{
|
||||
Opts_def_constructor p = get_optional(opt);
|
||||
|
||||
if ( p.params && p.params->Type != CT_Parameters ) {
|
||||
log_failure("gen::def_constructor: params must be of Parameters type - %s", code_debug_str((Code)p.params));
|
||||
GEN_DEBUG_TRAP();
|
||||
@@ -510,8 +512,10 @@ CodeConstructor def_constructor( Opts_def_constructor p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeClass def_class( Str name, Opts_def_struct p )
|
||||
CodeClass def_class( Str name, Opts_def_struct opt )
|
||||
{
|
||||
Opts_def_struct p = get_optional(opt);
|
||||
|
||||
if ( ! name_check( def_class, name ) ) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
@@ -561,8 +565,10 @@ CodeClass def_class( Str name, Opts_def_struct p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeDefine def_define( Str name, MacroType type, Opts_def_define p )
|
||||
CodeDefine def_define( Str name, MacroType type, Opts_def_define opt )
|
||||
{
|
||||
Opts_def_define p = get_optional(opt);
|
||||
|
||||
if ( ! name_check( def_define, name ) ) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
@@ -585,8 +591,10 @@ CodeDefine def_define( Str name, MacroType type, Opts_def_define p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeDestructor def_destructor( Opts_def_destructor p )
|
||||
CodeDestructor def_destructor( Opts_def_destructor opt )
|
||||
{
|
||||
Opts_def_destructor p = get_optional(opt);
|
||||
|
||||
if ( p.specifiers && p.specifiers->Type != CT_Specifiers ) {
|
||||
log_failure( "gen::def_destructor: specifiers was not a 'Specifiers' type: %s", code_debug_str(p.specifiers) );
|
||||
GEN_DEBUG_TRAP();
|
||||
@@ -619,8 +627,10 @@ CodeDestructor def_destructor( Opts_def_destructor p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeEnum def_enum( Str name, Opts_def_enum p )
|
||||
CodeEnum def_enum( Str name, Opts_def_enum opt )
|
||||
{
|
||||
Opts_def_enum p = get_optional(opt);
|
||||
|
||||
if ( ! name_check( def_enum, name ) ) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
@@ -742,8 +752,10 @@ CodeFriend def_friend( Code declaration )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeFn def_function( Str name, Opts_def_function p )
|
||||
CodeFn def_function( Str name, Opts_def_function opt )
|
||||
{
|
||||
Opts_def_function p = get_optional(opt);
|
||||
|
||||
if ( ! name_check( def_function, name )) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
@@ -802,8 +814,10 @@ CodeFn def_function( Str name, Opts_def_function p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeInclude def_include( Str path, Opts_def_include p )
|
||||
CodeInclude def_include( Str path, Opts_def_include opt )
|
||||
{
|
||||
Opts_def_include p = get_optional(opt);
|
||||
|
||||
if ( path.Len <= 0 || path.Ptr == nullptr ) {
|
||||
log_failure( "gen::def_include: Invalid path provided - %d" );
|
||||
GEN_DEBUG_TRAP();
|
||||
@@ -821,8 +835,10 @@ CodeInclude def_include( Str path, Opts_def_include p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeModule def_module( Str name, Opts_def_module p )
|
||||
CodeModule def_module( Str name, Opts_def_module opt )
|
||||
{
|
||||
Opts_def_module p = get_optional(opt);
|
||||
|
||||
if ( ! name_check( def_module, name )) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
@@ -835,8 +851,10 @@ CodeModule def_module( Str name, Opts_def_module p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeNS def_namespace( Str name, CodeBody body, Opts_def_namespace p )
|
||||
CodeNS def_namespace( Str name, CodeBody body, Opts_def_namespace opt )
|
||||
{
|
||||
Opts_def_namespace p = get_optional(opt);
|
||||
|
||||
if ( ! name_check( def_namespace, name )) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
@@ -859,8 +877,10 @@ CodeNS def_namespace( Str name, CodeBody body, Opts_def_namespace p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeOperator def_operator( Operator op, Str nspace, Opts_def_operator p )
|
||||
CodeOperator def_operator( Operator op, Str nspace, Opts_def_operator opt )
|
||||
{
|
||||
Opts_def_operator p = get_optional(opt);
|
||||
|
||||
if ( p.attributes && p.attributes->Type != CT_PlatformAttributes ) {
|
||||
log_failure( "gen::def_operator: PlatformAttributes was provided but its not of attributes type: %s", code_debug_str(p.attributes) );
|
||||
GEN_DEBUG_TRAP();
|
||||
@@ -926,8 +946,10 @@ CodeOperator def_operator( Operator op, Str nspace, Opts_def_operator p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast p )
|
||||
CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast opt )
|
||||
{
|
||||
Opts_def_operator_cast p = get_optional(opt);
|
||||
|
||||
if ( ! null_check( def_operator_cast, type )) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
@@ -959,8 +981,10 @@ CodeOpCast def_operator_cast( CodeTypename type, Opts_def_operator_cast p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeParams def_param( CodeTypename type, Str name, Opts_def_param p )
|
||||
CodeParams def_param( CodeTypename type, Str name, Opts_def_param opt )
|
||||
{
|
||||
Opts_def_param p = get_optional(opt);
|
||||
|
||||
if ( ! name_check( def_param, name ) || ! null_check( def_param, type ) ) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
@@ -1034,8 +1058,10 @@ CodeSpecifiers def_specifier( Specifier spec )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeStruct def_struct( Str name, Opts_def_struct p )
|
||||
CodeStruct def_struct( Str name, Opts_def_struct opt )
|
||||
{
|
||||
Opts_def_struct p = get_optional(opt);
|
||||
|
||||
if ( p.attributes && p.attributes->Type != CT_PlatformAttributes ) {
|
||||
log_failure( "gen::def_struct: attributes was not a `PlatformAttributes` type - %s", code_debug_str(cast(Code, p.attributes)) );
|
||||
GEN_DEBUG_TRAP();
|
||||
@@ -1076,8 +1102,10 @@ CodeStruct def_struct( Str name, Opts_def_struct p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeTemplate def_template( CodeParams params, Code declaration, Opts_def_template p )
|
||||
CodeTemplate def_template( CodeParams params, Code declaration, Opts_def_template opt )
|
||||
{
|
||||
Opts_def_template p = get_optional(opt);
|
||||
|
||||
if ( ! null_check( def_template, declaration ) ) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
@@ -1108,8 +1136,10 @@ CodeTemplate def_template( CodeParams params, Code declaration, Opts_def_templat
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeTypename def_type( Str name, Opts_def_type p )
|
||||
CodeTypename def_type( Str name, Opts_def_type opt )
|
||||
{
|
||||
Opts_def_type p = get_optional(opt);
|
||||
|
||||
if ( ! name_check( def_type, name )) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
@@ -1128,7 +1158,7 @@ CodeTypename def_type( Str name, Opts_def_type p )
|
||||
return InvalidCode;
|
||||
}
|
||||
if ( p.array_expr && p.array_expr->Type != CT_Untyped ) {
|
||||
log_failure( "gen::def_type: arrayexpr is not of untyped type - %s", code_debug_str((Code)p.array_expr) );
|
||||
log_failure( "gen::def_type: arrayexpr is not of untyped type - %S", code_debug_str((Code)p.array_expr) );
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
}
|
||||
@@ -1143,8 +1173,10 @@ CodeTypename def_type( Str name, Opts_def_type p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeTypedef def_typedef( Str name, Code type, Opts_def_typedef p )
|
||||
CodeTypedef def_typedef( Str name, Code type, Opts_def_typedef opt )
|
||||
{
|
||||
Opts_def_typedef p = get_optional(opt);
|
||||
|
||||
if ( ! null_check( def_typedef, type ) ) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
@@ -1186,6 +1218,7 @@ CodeTypedef def_typedef( Str name, Code type, Opts_def_typedef p )
|
||||
result = (CodeTypedef) make_code();
|
||||
result->Type = CT_Typedef;
|
||||
result->ModuleFlags = p.mflags;
|
||||
result->Attributes = p.attributes;
|
||||
result->UnderlyingType = type;
|
||||
|
||||
if ( name.Len <= 0 )
|
||||
@@ -1206,8 +1239,10 @@ CodeTypedef def_typedef( Str name, Code type, Opts_def_typedef p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeUnion def_union( Str name, CodeBody body, Opts_def_union p )
|
||||
CodeUnion def_union( Str name, CodeBody body, Opts_def_union opt )
|
||||
{
|
||||
Opts_def_union p = get_optional(opt);
|
||||
|
||||
if ( ! null_check( def_union, body ) ) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
@@ -1233,9 +1268,11 @@ CodeUnion def_union( Str name, CodeBody body, Opts_def_union p )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeUsing def_using( Str name, CodeTypename type, Opts_def_using p )
|
||||
CodeUsing def_using( Str name, CodeTypename type, Opts_def_using opt )
|
||||
{
|
||||
if ( ! name_check( def_using, name ) || null_check( def_using, type ) ) {
|
||||
Opts_def_using p = get_optional(opt);
|
||||
|
||||
if ( ! name_check( def_using, name ) || ! null_check( def_using, type ) ) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
}
|
||||
@@ -1274,8 +1311,10 @@ CodeUsing def_using_namespace( Str name )
|
||||
return result;
|
||||
}
|
||||
|
||||
CodeVar def_variable( CodeTypename type, Str name, Opts_def_variable p )
|
||||
CodeVar def_variable( CodeTypename type, Str name, Opts_def_variable opt )
|
||||
{
|
||||
Opts_def_variable p = get_optional(opt);
|
||||
|
||||
if ( ! name_check( def_variable, name ) || ! null_check( def_variable, type ) ) {
|
||||
GEN_DEBUG_TRAP();
|
||||
return InvalidCode;
|
||||
|
||||
+176
-146
@@ -1,14 +1,12 @@
|
||||
#ifdef INTELLISENSE_DIRECTIVES
|
||||
#pragma once
|
||||
#include "interface.upfront.cpp"
|
||||
#include "gen/etoktype.cpp"
|
||||
#include "gen/etoktype.hpp"
|
||||
#endif
|
||||
|
||||
StrBuilder tok_to_strbuilder(Token tok)
|
||||
{
|
||||
StrBuilder result = strbuilder_make_reserve( _ctx->Allocator_Temp, kilobytes(4) );
|
||||
StrBuilder tok_to_strbuilder(AllocatorInfo ainfo, Token tok) {
|
||||
StrBuilder result = strbuilder_make_reserve( ainfo, kilobytes(4) );
|
||||
Str type_str = toktype_to_str( tok.Type );
|
||||
|
||||
strbuilder_append_fmt( & result, "Line: %d Column: %d, Type: %.*s Content: %.*s"
|
||||
, tok.Line, tok.Column
|
||||
, type_str.Len, type_str.Ptr
|
||||
@@ -17,59 +15,70 @@ StrBuilder tok_to_strbuilder(Token tok)
|
||||
return result;
|
||||
}
|
||||
|
||||
bool lex__eat( TokArray* self, TokType type );
|
||||
bool lex__eat(Context* ctx, ParseContext* self, TokType type );
|
||||
|
||||
Token* lex_current(TokArray* self, bool skip_formatting )
|
||||
{
|
||||
if ( skip_formatting )
|
||||
{
|
||||
while ( self->Arr[self->Idx].Type == Tok_NewLine || self->Arr[self->Idx].Type == Tok_Comment )
|
||||
self->Idx++;
|
||||
}
|
||||
return & self->Arr[self->Idx];
|
||||
forceinline
|
||||
b32 lex_index_in_range(ParseContext const* self, s32 idx) {
|
||||
return self->tokens.ptr != nullptr
|
||||
&& idx >= 0
|
||||
&& idx < self->tokens.num;
|
||||
}
|
||||
|
||||
Token* lex_peek(TokArray self, bool skip_formatting)
|
||||
{
|
||||
s32 idx = self.Idx;
|
||||
if ( skip_formatting )
|
||||
{
|
||||
while ( self.Arr[idx].Type == Tok_NewLine )
|
||||
idx++;
|
||||
|
||||
return & self.Arr[idx];
|
||||
}
|
||||
return & self.Arr[idx];
|
||||
forceinline
|
||||
Token* lex_token_at(ParseContext const* self, s32 idx) {
|
||||
Token* result = & NullToken;
|
||||
if (lex_index_in_range(self, idx)) result = & self->tokens.ptr[idx];
|
||||
return result;
|
||||
}
|
||||
|
||||
Token* lex_previous(TokArray self, bool skip_formatting)
|
||||
{
|
||||
s32 idx = self.Idx;
|
||||
if ( skip_formatting )
|
||||
{
|
||||
while ( self.Arr[idx].Type == Tok_NewLine )
|
||||
idx --;
|
||||
|
||||
return & self.Arr[idx];
|
||||
Token* lex_current(ParseContext* self, bool skip_formatting) {
|
||||
if (skip_formatting) while (lex_index_in_range(self, self->token_id)) {
|
||||
TokType type = self->tokens.ptr[self->token_id].Type;
|
||||
if (type != Tok_NewLine && type != Tok_Comment) break;
|
||||
++ self->token_id;
|
||||
}
|
||||
return & self.Arr[idx - 1];
|
||||
return lex_token_at(self, self->token_id);
|
||||
}
|
||||
|
||||
Token* lex_next(TokArray self, bool skip_formatting)
|
||||
{
|
||||
s32 idx = self.Idx;
|
||||
if ( skip_formatting )
|
||||
{
|
||||
while ( self.Arr[idx].Type == Tok_NewLine )
|
||||
idx++;
|
||||
|
||||
return & self.Arr[idx + 1];
|
||||
Token* lex_peek(ParseContext const* self, bool skip_formatting) {
|
||||
s32 idx = self->token_id;
|
||||
if (skip_formatting) {
|
||||
while (lex_index_in_range(self, idx) && self->tokens.ptr[idx].Type == Tok_NewLine)
|
||||
++ idx;
|
||||
}
|
||||
return & self.Arr[idx + 1];
|
||||
return lex_token_at(self, idx);
|
||||
}
|
||||
|
||||
enum
|
||||
Token* lex_previous(ParseContext const* self, bool skip_formatting)
|
||||
{
|
||||
Token* result = & NullToken;
|
||||
s32 idx = self->token_id;
|
||||
if (skip_formatting)
|
||||
{
|
||||
if (self->tokens.num > 0 && idx >= self->tokens.num)
|
||||
idx = self->tokens.num - 1;
|
||||
while (lex_index_in_range(self, idx) && self->tokens.ptr[idx].Type == Tok_NewLine && idx > 0)
|
||||
-- idx;
|
||||
if (lex_index_in_range(self, idx) && self->tokens.ptr[idx].Type != Tok_NewLine)
|
||||
result = &self->tokens.ptr[idx];
|
||||
goto done;
|
||||
}
|
||||
if (self->tokens.num > 0 && idx >= self->tokens.num) result = lex_token_at(self, self->tokens.num - 1);
|
||||
else result = lex_token_at(self, idx - 1);
|
||||
done:
|
||||
return result;
|
||||
}
|
||||
|
||||
Token* lex_next(ParseContext const* self, bool skip_formatting) {
|
||||
s32 idx = self->token_id;
|
||||
if (skip_formatting) {
|
||||
while (lex_index_in_range(self, idx) && self->tokens.ptr[idx].Type == Tok_NewLine)
|
||||
-- idx;
|
||||
}
|
||||
return lex_token_at(self, idx + 1);
|
||||
}
|
||||
|
||||
enum {
|
||||
Lex_Continue,
|
||||
Lex_ReturnNull,
|
||||
};
|
||||
@@ -90,19 +99,16 @@ void lexer_move_forward( LexContext* ctx )
|
||||
#define move_forward() lexer_move_forward(ctx)
|
||||
|
||||
forceinline
|
||||
void lexer_skip_whitespace( LexContext* ctx )
|
||||
{
|
||||
void lexer_skip_whitespace( LexContext* ctx ) {
|
||||
while ( ctx->left && char_is_space( * ctx->scanner ) )
|
||||
move_forward();
|
||||
}
|
||||
#define skip_whitespace() lexer_skip_whitespace(ctx)
|
||||
|
||||
forceinline
|
||||
void lexer_end_line( LexContext* ctx )
|
||||
{
|
||||
void lexer_end_line( LexContext* ctx ) {
|
||||
while ( ctx->left && (* ctx->scanner) == ' ' )
|
||||
move_forward();
|
||||
|
||||
if ( ctx->left && (* ctx->scanner) == '\r' ) {
|
||||
move_forward();
|
||||
move_forward();
|
||||
@@ -113,7 +119,9 @@ void lexer_end_line( LexContext* ctx )
|
||||
#define end_line() lexer_end_line(ctx)
|
||||
|
||||
// TODO(Ed): We need to to attempt to recover from a lex failure?
|
||||
s32 lex_preprocessor_define( LexContext* ctx )
|
||||
internal void lexer_record_failure_fmt(Context* lib_ctx, LexContext* ctx, char const* fmt, ...);
|
||||
|
||||
s32 lex_preprocessor_define(Context* lib_ctx, LexContext* ctx)
|
||||
{
|
||||
Token name = { { ctx->scanner, 1 }, Tok_Identifier, ctx->line, ctx->column, TF_Preprocess };
|
||||
move_forward();
|
||||
@@ -137,7 +145,7 @@ s32 lex_preprocessor_define( LexContext* ctx )
|
||||
);
|
||||
// GEN_DEBUG_TRAP();
|
||||
}
|
||||
array_append( _ctx->Lexer_Tokens, name );
|
||||
array_append(ctx->tokens, name);
|
||||
|
||||
if ( ctx->left && (* ctx->scanner) == '(' )
|
||||
{
|
||||
@@ -152,7 +160,7 @@ s32 lex_preprocessor_define( LexContext* ctx )
|
||||
}
|
||||
|
||||
Token opening_paren = { { ctx->scanner, 1 }, Tok_Paren_Open, ctx->line, ctx->column, TF_Preprocess };
|
||||
array_append( _ctx->Lexer_Tokens, opening_paren );
|
||||
array_append(ctx->tokens, opening_paren);
|
||||
move_forward();
|
||||
|
||||
Token last_parameter = {};
|
||||
@@ -168,7 +176,7 @@ s32 lex_preprocessor_define( LexContext* ctx )
|
||||
move_forward();
|
||||
move_forward();
|
||||
|
||||
array_append(_ctx->Lexer_Tokens, parameter);
|
||||
array_append(ctx->tokens, parameter);
|
||||
skip_whitespace();
|
||||
last_parameter = parameter;
|
||||
|
||||
@@ -178,7 +186,7 @@ s32 lex_preprocessor_define( LexContext* ctx )
|
||||
}
|
||||
if (* ctx->scanner != ')' )
|
||||
{
|
||||
log_failure("lex_preprocessor_define(%d, %d): Expected a ')' after '...' (varaidc macro param) %S\n"
|
||||
lexer_record_failure_fmt(lib_ctx, ctx, "lex_preprocessor_define(%d, %d): Expected a ')' after '...' (varaidc macro param) %S\n"
|
||||
, ctx->line
|
||||
, ctx->column
|
||||
, name.Text
|
||||
@@ -202,12 +210,12 @@ s32 lex_preprocessor_define( LexContext* ctx )
|
||||
move_forward();
|
||||
parameter.Text.Len++;
|
||||
}
|
||||
array_append(_ctx->Lexer_Tokens, parameter);
|
||||
array_append(ctx->tokens, parameter);
|
||||
skip_whitespace();
|
||||
last_parameter = parameter;
|
||||
}
|
||||
else {
|
||||
log_failure("lex_preprocessor_define(%d, %d): Expected a '_' or alpha character for a parameter name for %S\n"
|
||||
lexer_record_failure_fmt(lib_ctx, ctx, "lex_preprocessor_define(%d, %d): Expected a '_' or alpha character for a parameter name for %S\n"
|
||||
, ctx->line
|
||||
, ctx->column
|
||||
, name.Text
|
||||
@@ -220,7 +228,7 @@ s32 lex_preprocessor_define( LexContext* ctx )
|
||||
|
||||
// There should be a comma
|
||||
if ( * ctx->scanner != ',' ) {
|
||||
log_failure("lex_preprocessor_define(%d, %d): Expected a comma after parameter %S for %S\n"
|
||||
lexer_record_failure_fmt(lib_ctx, ctx, "lex_preprocessor_define(%d, %d): Expected a comma after parameter %S for %S\n"
|
||||
, ctx->line
|
||||
, ctx->column
|
||||
, last_parameter.Text
|
||||
@@ -229,12 +237,12 @@ s32 lex_preprocessor_define( LexContext* ctx )
|
||||
return Lex_ReturnNull;
|
||||
}
|
||||
Token comma = { { ctx->scanner, 1 }, Tok_Comma, ctx->line, ctx->column, TF_Preprocess };
|
||||
array_append(_ctx->Lexer_Tokens, comma);
|
||||
array_append(ctx->tokens, comma);
|
||||
move_forward();
|
||||
}
|
||||
|
||||
if ( * ctx->scanner != ')' ) {
|
||||
log_failure("lex_preprocessor_define(%d, %d): Expected a ')' after last_parameter %S for %S (ran out of characters...)\n"
|
||||
lexer_record_failure_fmt(lib_ctx, ctx, "lex_preprocessor_define(%d, %d): Expected a ')' after last_parameter %S for %S (ran out of characters...)\n"
|
||||
, ctx->line
|
||||
, ctx->column
|
||||
, last_parameter.Text
|
||||
@@ -243,7 +251,7 @@ s32 lex_preprocessor_define( LexContext* ctx )
|
||||
return Lex_ReturnNull;
|
||||
}
|
||||
Token closing_paren = { { ctx->scanner, 1 }, Tok_Paren_Close, ctx->line, ctx->column, TF_Preprocess };
|
||||
array_append(_ctx->Lexer_Tokens, closing_paren);
|
||||
array_append(ctx->tokens, closing_paren);
|
||||
move_forward();
|
||||
}
|
||||
else if ( registered_macro && macro_is_functional( * registered_macro) ) {
|
||||
@@ -264,11 +272,11 @@ s32 lex_preprocessor_define( LexContext* ctx )
|
||||
}
|
||||
|
||||
// TODO(Ed): We need to to attempt to recover from a lex failure?
|
||||
s32 lex_preprocessor_directive( LexContext* ctx )
|
||||
s32 lex_preprocessor_directive(Context* lib_ctx, LexContext* ctx)
|
||||
{
|
||||
char const* hash = ctx->scanner;
|
||||
Token hash_tok = { { hash, 1 }, Tok_Preprocess_Hash, ctx->line, ctx->column, TF_Preprocess };
|
||||
array_append( _ctx->Lexer_Tokens, hash_tok );
|
||||
array_append(ctx->tokens, hash_tok);
|
||||
|
||||
move_forward();
|
||||
skip_whitespace();
|
||||
@@ -317,11 +325,11 @@ s32 lex_preprocessor_directive( LexContext* ctx )
|
||||
}
|
||||
else
|
||||
{
|
||||
log_failure( "gen::Parser::lex: Invalid escape sequence '\\%c' (%d, %d)"
|
||||
lexer_record_failure_fmt(lib_ctx, ctx, "gen::Parser::lex: Invalid escape sequence '\\%c' (%d, %d)"
|
||||
" in preprocessor directive (%d, %d)\n%.100s"
|
||||
, (* ctx->scanner), ctx->line, ctx->column
|
||||
, ctx->token.Line, ctx->token.Column, ctx->token.Text );
|
||||
break;
|
||||
return Lex_ReturnNull;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -344,14 +352,14 @@ s32 lex_preprocessor_directive( LexContext* ctx )
|
||||
|
||||
ctx->token.Text.Len = ctx->token.Text.Len + ctx->token.Text.Ptr - hash;
|
||||
ctx->token.Text.Ptr = hash;
|
||||
array_append( _ctx->Lexer_Tokens, ctx->token );
|
||||
array_append(ctx->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;
|
||||
array_append( _ctx->Lexer_Tokens, ctx->token );
|
||||
array_append(ctx->tokens, ctx->token);
|
||||
end_line();
|
||||
return Lex_Continue;
|
||||
}
|
||||
@@ -360,13 +368,13 @@ s32 lex_preprocessor_directive( LexContext* ctx )
|
||||
ctx->token.Flags |= TF_Preprocess_Cond;
|
||||
}
|
||||
|
||||
array_append( _ctx->Lexer_Tokens, ctx->token );
|
||||
array_append(ctx->tokens, ctx->token);
|
||||
|
||||
skip_whitespace();
|
||||
|
||||
if ( ctx->token.Type == Tok_Preprocess_Define )
|
||||
{
|
||||
u32 result = lex_preprocessor_define(ctx); // handles: #define <name>( <params> ) - define's content handled later on within this scope.
|
||||
u32 result = lex_preprocessor_define(lib_ctx, ctx); // handles: #define <name>( <params> ) - define's content handled later on within this scope.
|
||||
if (result != Lex_Continue)
|
||||
return Lex_ReturnNull;
|
||||
}
|
||||
@@ -379,9 +387,9 @@ s32 lex_preprocessor_directive( LexContext* ctx )
|
||||
|
||||
if ( (* ctx->scanner) != '"' && (* ctx->scanner) != '<' )
|
||||
{
|
||||
StrBuilder directive_str = strbuilder_fmt_buf( _ctx->Allocator_Temp, "%.*s", min( 80, ctx->left + preprocess_content.Text.Len ), ctx->token.Text.Ptr );
|
||||
StrBuilder directive_str = strbuilder_fmt_buf( ctx->allocator_temp, "%.*s", min( 80, ctx->left + preprocess_content.Text.Len ), ctx->token.Text.Ptr );
|
||||
|
||||
log_failure( "gen::Parser::lex: Expected '\"' or '<' after #include, not '%c' (%d, %d)\n%s"
|
||||
lexer_record_failure_fmt(lib_ctx, ctx, "gen::Parser::lex: Expected '\"' or '<' after #include, not '%c' (%d, %d)\n%s"
|
||||
, (* ctx->scanner)
|
||||
, preprocess_content.Line
|
||||
, preprocess_content.Column
|
||||
@@ -411,7 +419,7 @@ s32 lex_preprocessor_directive( LexContext* ctx )
|
||||
move_forward();
|
||||
}
|
||||
|
||||
array_append( _ctx->Lexer_Tokens, preprocess_content );
|
||||
array_append(ctx->tokens, preprocess_content);
|
||||
return Lex_Continue; // Skip found token, its all handled here.
|
||||
}
|
||||
|
||||
@@ -446,16 +454,15 @@ s32 lex_preprocessor_directive( LexContext* ctx )
|
||||
}
|
||||
else
|
||||
{
|
||||
StrBuilder directive_str = strbuilder_make_length( _ctx->Allocator_Temp, ctx->token.Text.Ptr, ctx->token.Text.Len );
|
||||
StrBuilder content_str = strbuilder_fmt_buf( _ctx->Allocator_Temp, "%.*s", min( 400, ctx->left + preprocess_content.Text.Len ), preprocess_content.Text.Ptr );
|
||||
StrBuilder directive_str = strbuilder_make_length( ctx->allocator_temp, ctx->token.Text.Ptr, ctx->token.Text.Len );
|
||||
StrBuilder content_str = strbuilder_fmt_buf( ctx->allocator_temp, "%.*s", min( 400, ctx->left + preprocess_content.Text.Len ), preprocess_content.Text.Ptr );
|
||||
|
||||
log_failure( "gen::Parser::lex: Invalid escape sequence '\\%c' (%d, %d)"
|
||||
lexer_record_failure_fmt(lib_ctx, ctx, "gen::Parser::lex: Invalid escape sequence '\\%c' (%d, %d)"
|
||||
" in preprocessor directive '%s' (%d, %d)\n%s"
|
||||
, (* ctx->scanner), ctx->line, ctx->column
|
||||
, directive_str, preprocess_content.Line, preprocess_content.Column
|
||||
, content_str );
|
||||
return Lex_ReturnNull;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -475,14 +482,14 @@ s32 lex_preprocessor_directive( LexContext* ctx )
|
||||
preprocess_content.Text.Len++;
|
||||
}
|
||||
|
||||
array_append( _ctx->Lexer_Tokens, preprocess_content );
|
||||
array_append(ctx->tokens, preprocess_content);
|
||||
return Lex_Continue; // Skip found token, its all handled here.
|
||||
}
|
||||
|
||||
void lex_found_token( LexContext* ctx )
|
||||
{
|
||||
if ( ctx->token.Type != Tok_Invalid ) {
|
||||
array_append( _ctx->Lexer_Tokens, ctx->token );
|
||||
array_append(ctx->tokens, ctx->token);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -508,7 +515,7 @@ void lex_found_token( LexContext* ctx )
|
||||
}
|
||||
|
||||
ctx->token.Type = type;
|
||||
array_append( _ctx->Lexer_Tokens, ctx->token );
|
||||
array_append(ctx->tokens, ctx->token);
|
||||
return;
|
||||
}
|
||||
if ( ( type <= Tok_Star && type >= Tok_Spec_Alignas)
|
||||
@@ -517,13 +524,13 @@ void lex_found_token( LexContext* ctx )
|
||||
{
|
||||
ctx->token.Type = type;
|
||||
ctx->token.Flags |= TF_Specifier;
|
||||
array_append( _ctx->Lexer_Tokens, ctx->token );
|
||||
array_append(ctx->tokens, ctx->token);
|
||||
return;
|
||||
}
|
||||
if ( type != Tok_Invalid )
|
||||
{
|
||||
ctx->token.Type = type;
|
||||
array_append( _ctx->Lexer_Tokens, ctx->token );
|
||||
array_append(ctx->tokens, ctx->token);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -534,11 +541,16 @@ void lex_found_token( LexContext* ctx )
|
||||
ctx->token.Type = macrotype_to_toktype(macro->Type);
|
||||
b32 is_functional = macro_is_functional(* macro);
|
||||
resolved_to_macro = has_args ? is_functional : ! is_functional;
|
||||
if ( ! resolved_to_macro && GEN_BUILD_DEBUG ) {
|
||||
log_fmt("Info(%d, %d): %S identified as a macro but usage here does not resolve to one (interpreting as identifier)\n"
|
||||
, ctx->token.Line
|
||||
if ( ! resolved_to_macro && GEN_BUILD_DEBUG && ! bitfield_is_set(MacroFlags, macro->Flags, MF_Allow_As_Identifier) ) {
|
||||
log_fmt("Info(%d, %d): %S identified as a macro but usage here does not resolve to one (functional=%d, has_args=%d, flags=%u, next='%.*s')\n"
|
||||
, ctx->token.Line
|
||||
, ctx->token.Column
|
||||
, macro->Name
|
||||
, is_functional
|
||||
, has_args
|
||||
, macro->Flags
|
||||
, min(16, ctx->left)
|
||||
, ctx->scanner
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -561,50 +573,66 @@ void lex_found_token( LexContext* ctx )
|
||||
ctx->token.Type = Tok_Identifier;
|
||||
}
|
||||
|
||||
array_append( _ctx->Lexer_Tokens, ctx->token );
|
||||
array_append(ctx->tokens, ctx->token);
|
||||
}
|
||||
|
||||
// TODO(Ed): We should dynamically allocate the lexer's array in Allocator_DyanmicContainers.
|
||||
|
||||
// TODO(Ed): We need to to attempt to recover from a lex failure?
|
||||
|
||||
internal
|
||||
void lexer_record_failure(Context* lib_ctx, LexContext* ctx, Str text) {
|
||||
LexerMessage* msg = rcast(LexerMessage*, alloc(lib_ctx->Allocator_DyanmicContainers, size_of(LexerMessage)));
|
||||
if (msg == nullptr) GEN_FATAL("lexer_record_failure: allocation failed");
|
||||
msg->next = ctx->messages;
|
||||
msg->content = cache_str(text);
|
||||
msg->level = LL_Error;
|
||||
ctx->messages = msg;
|
||||
}
|
||||
|
||||
internal
|
||||
void lexer_record_failure_fmt(Context* lib_ctx, LexContext* ctx, char const* fmt, ...) {
|
||||
va_list va;
|
||||
char* buf;
|
||||
Str text;
|
||||
va_start(va, fmt);
|
||||
buf = c_str_fmt_buf_va(fmt, va);
|
||||
va_end(va);
|
||||
text.Ptr = buf;
|
||||
text.Len = c_str_len(buf);
|
||||
lexer_record_failure(lib_ctx, ctx, text);
|
||||
}
|
||||
|
||||
neverinline
|
||||
// TokArray lex( Array<Token> tokens, Str content )
|
||||
TokArray lex( Str content )
|
||||
LexedInfo lex(Context* lib_ctx, Str content)
|
||||
{
|
||||
LexContext c; LexContext* ctx = & c;
|
||||
c.content = content;
|
||||
c.left = content.Len;
|
||||
c.scanner = content.Ptr;
|
||||
LexedInfo info = struct_zero(LexedInfo);
|
||||
|
||||
char const* word = c.scanner;
|
||||
s32 word_length = 0;
|
||||
LexContext c = struct_zero(LexContext); LexContext* ctx = & c;
|
||||
c.allocator_temp = lib_ctx->Allocator_Temp;
|
||||
c.content = content;
|
||||
c.left = content.Len;
|
||||
c.scanner = content.Ptr;
|
||||
c.line = 1;
|
||||
c.column = 1;
|
||||
c.tokens = array_init_reserve(Token, lib_ctx->Allocator_DyanmicContainers, lib_ctx->InitSize_LexerTokens );
|
||||
|
||||
c.line = 1;
|
||||
c.column = 1;
|
||||
|
||||
skip_whitespace();
|
||||
if ( c.left <= 0 )
|
||||
{
|
||||
log_failure( "gen::lex: no tokens found (only whitespace provided)" );
|
||||
TokArray null_array = {};
|
||||
return null_array;
|
||||
}
|
||||
|
||||
array_clear(_ctx->Lexer_Tokens);
|
||||
// TODO(Ed): Re-implement to new constraints:
|
||||
// 1. Ability to continue on error
|
||||
// 2. Return a lexed info.
|
||||
|
||||
b32 preprocess_args = true;
|
||||
|
||||
skip_whitespace();
|
||||
if ( c.left <= 0 ) {
|
||||
lexer_record_failure(lib_ctx, ctx, txt("gen::lex: no tokens found (only whitespace provided)"));
|
||||
info.messages = c.messages;
|
||||
goto Lex_Done;
|
||||
}
|
||||
|
||||
while (c.left )
|
||||
{
|
||||
#if 0
|
||||
if (Tokens.num())
|
||||
{
|
||||
log_fmt("\nLastTok: %SB", Tokens.back().to_strbuilder());
|
||||
}
|
||||
#endif
|
||||
|
||||
{
|
||||
Token thanks_c = { { c.scanner, 0 }, Tok_Invalid, c.line, c.column, TF_Null };
|
||||
c.token = thanks_c;
|
||||
}
|
||||
c.token = struct_init(Token) { { c.scanner, 0 }, Tok_Invalid, c.line, c.column, TF_Null };
|
||||
|
||||
bool is_define = false;
|
||||
|
||||
@@ -623,7 +651,7 @@ TokArray lex( Str content )
|
||||
c.token.Type = Tok_NewLine;
|
||||
c.token.Text.Len++;
|
||||
|
||||
array_append( _ctx->Lexer_Tokens, c.token );
|
||||
array_append(c.tokens, c.token);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
@@ -638,7 +666,7 @@ TokArray lex( Str content )
|
||||
{
|
||||
case '#':
|
||||
{
|
||||
s32 result = lex_preprocessor_directive( ctx );
|
||||
s32 result = lex_preprocessor_directive(lib_ctx, ctx);
|
||||
switch ( result )
|
||||
{
|
||||
case Lex_Continue:
|
||||
@@ -662,7 +690,7 @@ TokArray lex( Str content )
|
||||
c.token.Text.Len++;
|
||||
move_forward();
|
||||
|
||||
array_append( _ctx->Lexer_Tokens, c.token );
|
||||
array_append(c.tokens, c.token);
|
||||
}
|
||||
}
|
||||
continue;
|
||||
@@ -670,8 +698,8 @@ TokArray lex( Str content )
|
||||
|
||||
case Lex_ReturnNull:
|
||||
{
|
||||
TokArray tok_array = {};
|
||||
return tok_array;
|
||||
info.messages = c.messages;
|
||||
goto Lex_Done;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -698,9 +726,11 @@ TokArray lex( Str content )
|
||||
}
|
||||
else
|
||||
{
|
||||
StrBuilder context_str = strbuilder_fmt_buf( _ctx->Allocator_Temp, "%s", c.scanner, min( 100, c.left ) );
|
||||
StrBuilder context_str = strbuilder_fmt_buf( lib_ctx->Allocator_Temp, "%s", c.scanner, min( 100, c.left ) );
|
||||
|
||||
log_failure( "gen::lex: invalid varadic argument, expected '...' got '..%c' (%d, %d)\n%s", (* ctx->scanner), c.line, c.column, context_str );
|
||||
lexer_record_failure_fmt(lib_ctx, ctx, "gen::lex: invalid varadic argument, expected '...' got '..%c' (%d, %d)\n%s", (* ctx->scanner), c.line, c.column, context_str );
|
||||
info.messages = c.messages;
|
||||
goto Lex_Done;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1119,7 +1149,7 @@ TokArray lex( Str content )
|
||||
move_forward();
|
||||
c.token.Text.Len++;
|
||||
}
|
||||
array_append( _ctx->Lexer_Tokens, c.token );
|
||||
array_append(c.tokens, c.token);
|
||||
continue;
|
||||
}
|
||||
else if ( (* ctx->scanner) == '*' )
|
||||
@@ -1155,7 +1185,7 @@ TokArray lex( Str content )
|
||||
move_forward();
|
||||
c.token.Text.Len++;
|
||||
}
|
||||
array_append( _ctx->Lexer_Tokens, c.token );
|
||||
array_append(c.tokens, c.token);
|
||||
// end_line();
|
||||
continue;
|
||||
}
|
||||
@@ -1243,30 +1273,27 @@ TokArray lex( Str content )
|
||||
}
|
||||
else
|
||||
{
|
||||
s32 start = max( 0, array_num(_ctx->Lexer_Tokens) - 100 );
|
||||
s32 start = max( 0, array_num(c.tokens) - 100 );
|
||||
log_fmt("\n%d\n", start);
|
||||
for ( s32 idx = start; idx < array_num(_ctx->Lexer_Tokens); idx++ )
|
||||
for ( s32 idx = start; idx < array_num(c.tokens); idx++ )
|
||||
{
|
||||
log_fmt( "Token %d Type: %s : %.*s\n"
|
||||
, idx
|
||||
, toktype_to_str( _ctx->Lexer_Tokens[ idx ].Type ).Ptr
|
||||
, _ctx->Lexer_Tokens[ idx ].Text.Len, _ctx->Lexer_Tokens[ idx ].Text.Ptr
|
||||
, toktype_to_str( c.tokens[ idx ].Type ).Ptr
|
||||
, c.tokens[ idx ].Text.Len, c.tokens[ idx ].Text.Ptr
|
||||
);
|
||||
}
|
||||
|
||||
StrBuilder context_str = strbuilder_fmt_buf( _ctx->Allocator_Temp, "%.*s", min( 100, c.left ), c.scanner );
|
||||
log_failure( "Failed to lex token '%c' (%d, %d)\n%s", (* ctx->scanner), c.line, c.column, context_str );
|
||||
|
||||
// Skip to next whitespace since we can't know if anything else is valid until then.
|
||||
while ( c.left && ! char_is_space( (* ctx->scanner) ) ) {
|
||||
move_forward();
|
||||
}
|
||||
StrBuilder context_str = strbuilder_fmt_buf( lib_ctx->Allocator_Temp, "%.*s", min( 100, c.left ), c.scanner );
|
||||
lexer_record_failure_fmt(lib_ctx, ctx, "Failed to lex token '%c' (%d, %d)\n%s", (* ctx->scanner), c.line, c.column, context_str );
|
||||
info.messages = c.messages;
|
||||
goto Lex_Done;
|
||||
}
|
||||
|
||||
FoundToken:
|
||||
{
|
||||
lex_found_token( ctx );
|
||||
TokType last_type = array_back(_ctx->Lexer_Tokens)->Type;
|
||||
TokType last_type = array_back(c.tokens)->Type;
|
||||
if ( last_type == Tok_Preprocess_Macro_Stmt || last_type == Tok_Preprocess_Macro_Expr )
|
||||
{
|
||||
Token thanks_c = { { c.scanner, 0 }, Tok_Invalid, c.line, c.column, TF_Null };
|
||||
@@ -1281,21 +1308,24 @@ TokArray lex( Str content )
|
||||
c.token.Text.Len++;
|
||||
move_forward();
|
||||
|
||||
array_append( _ctx->Lexer_Tokens, c.token );
|
||||
array_append(c.tokens, c.token);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if ( array_num(_ctx->Lexer_Tokens) == 0 ) {
|
||||
log_failure( "Failed to lex any tokens" );
|
||||
TokArray tok_array = {};
|
||||
return tok_array;
|
||||
if ( array_num(c.tokens) == 0 ) {
|
||||
lexer_record_failure(lib_ctx, ctx, txt("gen::lex: failed to lex any tokens"));
|
||||
info.messages = c.messages;
|
||||
goto Lex_Done;
|
||||
}
|
||||
|
||||
TokArray result = { _ctx->Lexer_Tokens, 0 };
|
||||
return result;
|
||||
|
||||
info.messages = c.messages;
|
||||
info.text = content;
|
||||
Lex_Done:
|
||||
info.tokens = struct_init(TokenSlice) { pcast(Token*, c.tokens), scast(s32, array_num(c.tokens)) };
|
||||
return info;
|
||||
}
|
||||
|
||||
#undef move_forward
|
||||
|
||||
+943
-771
File diff suppressed because it is too large.
Load diff
@@ -1,7 +1,7 @@
|
||||
#ifdef INTELLISENSE_DIRECTIVES
|
||||
#pragma once
|
||||
#include "types.hpp"
|
||||
#include "gen/ecode.hpp"
|
||||
#include "gen/ecodetypes.hpp"
|
||||
#include "gen/eoperator.hpp"
|
||||
#include "gen/especifier.hpp"
|
||||
#include "gen/etoktype.hpp"
|
||||
@@ -37,8 +37,6 @@ struct Token
|
||||
u32 Flags;
|
||||
};
|
||||
|
||||
constexpr Token NullToken { {}, Tok_Invalid, 0, 0, TF_Null };
|
||||
|
||||
forceinline
|
||||
AccessSpec tok_to_access_specifier(Token tok) {
|
||||
return scast(AccessSpec, tok.Type);
|
||||
@@ -89,7 +87,28 @@ bool tok_is_end_definition(Token tok) {
|
||||
return bitfield_is_set( u32, tok.Flags, TF_EndDefinition );
|
||||
}
|
||||
|
||||
StrBuilder tok_to_strbuilder(Token tok);
|
||||
StrBuilder tok_to_strbuilder(AllocatorInfo ainfo, Token tok);
|
||||
|
||||
struct TokenSlice
|
||||
{
|
||||
Token* ptr;
|
||||
s32 num;
|
||||
|
||||
#if GEN_COMPILER_CPP
|
||||
forceinline operator Token* () const { return ptr; }
|
||||
forceinline Token& operator[]( ssize index ) const { return ptr[index]; }
|
||||
#endif
|
||||
};
|
||||
|
||||
forceinline
|
||||
Str token_range_to_str(Token start, Token end)
|
||||
{
|
||||
Str result = {
|
||||
start.Text.Ptr,
|
||||
(scast(sptr, rcast(uptr, end.Text.Ptr)) + end.Text.Len) - scast(sptr, rcast(uptr, start.Text.Ptr))
|
||||
};
|
||||
return result;
|
||||
}
|
||||
|
||||
struct TokArray
|
||||
{
|
||||
@@ -97,30 +116,52 @@ struct TokArray
|
||||
s32 Idx;
|
||||
};
|
||||
|
||||
typedef struct LexerMessage LexerMessage;
|
||||
struct LexerMessage
|
||||
{
|
||||
LexerMessage* next;
|
||||
Str content;
|
||||
LogLevel level;
|
||||
};
|
||||
|
||||
struct LexContext
|
||||
{
|
||||
AllocatorInfo allocator_temp;
|
||||
LexerMessage* messages;
|
||||
Str content;
|
||||
s32 left;
|
||||
char const* scanner;
|
||||
s32 line;
|
||||
s32 column;
|
||||
// StringTable defines;
|
||||
Token token;
|
||||
Array(Token) tokens;
|
||||
};
|
||||
|
||||
struct StackNode
|
||||
struct LexedInfo
|
||||
{
|
||||
StackNode* Prev;
|
||||
LexerMessage* messages;
|
||||
Str text;
|
||||
TokenSlice tokens;
|
||||
};
|
||||
|
||||
Token* Start;
|
||||
Str Name; // The name of the AST node (if parsed)
|
||||
Str ProcName; // The name of the procedure
|
||||
typedef struct ParseStackNode ParseStackNode;
|
||||
|
||||
typedef struct ParseMessage ParseMessage;
|
||||
struct ParseMessage
|
||||
{
|
||||
ParseMessage* Next;
|
||||
ParseStackNode* Scope;
|
||||
Str Content;
|
||||
LogLevel Level;
|
||||
};
|
||||
|
||||
struct ParseContext
|
||||
{
|
||||
TokArray Tokens;
|
||||
StackNode* Scope;
|
||||
ParseMessage* messages;
|
||||
ParseStackNode* scope;
|
||||
// TokArray Tokens;
|
||||
TokenSlice tokens;
|
||||
s32 token_id;
|
||||
};
|
||||
|
||||
enum MacroType : u16
|
||||
@@ -168,26 +209,36 @@ Str macrotype_to_str( MacroType type )
|
||||
|
||||
enum EMacroFlags : u16
|
||||
{
|
||||
MF_Functional = bit(0), // Macro has parameters (args expected to be passed)
|
||||
MF_Expects_Body = bit(1), // Expects to assign a braced scope to its body.
|
||||
// Macro has parameters (args expected to be passed)
|
||||
MF_Functional = bit(0),
|
||||
|
||||
// Expects to assign a braced scope to its body.
|
||||
MF_Expects_Body = bit(1),
|
||||
|
||||
// lex__eat wil treat this macro as an identifier if the parser attempts to consume it as one.
|
||||
// ^^^ This is a kludge because we don't support push/pop macro pragmas rn.
|
||||
// This is a kludge because we don't support push/pop macro pragmas rn.
|
||||
MF_Allow_As_Identifier = bit(2),
|
||||
|
||||
// When parsing identifiers, it will allow the consumption of the macro parameters (as its expected to be a part of constructing the identifier)
|
||||
// Example of a decarator macro from stb_sprintf.h:
|
||||
// STBSP__PUBLICDEC int STB_SPRINTF_DECORATE(sprintf)(char* buf, char const *fmt, ...) STBSP__ATTRIBUTE_FORMAT(2,3);
|
||||
// ^^ STB_SPRINTF_DECORATE is decorating sprintf
|
||||
MF_Identifier_Decorator = bit(3),
|
||||
|
||||
// lex__eat wil treat this macro as an attribute if the parser attempts to consume it as one.
|
||||
// ^^^ This a kludge because unreal has a macro that behaves as both a 'statement' and an attribute (UE_DEPRECATED, PRAGMA_ENABLE_DEPRECATION_WARNINGS, etc)
|
||||
// This a kludge because unreal has a macro that behaves as both a 'statement' and an attribute (UE_DEPRECATED, PRAGMA_ENABLE_DEPRECATION_WARNINGS, etc)
|
||||
// TODO(Ed): We can keep the MF_Allow_As_Attribute flag for macros, however, we need to add the ability of AST_Attributes to chain themselves.
|
||||
// Its thats already a thing in the standard language anyway
|
||||
// & it would allow UE_DEPRECATED, (UE_PROPERTY / UE_FUNCTION) to chain themselves as attributes of a resolved member function/variable definition
|
||||
MF_Allow_As_Attribute = bit(3),
|
||||
MF_Allow_As_Attribute = bit(4),
|
||||
|
||||
// When a macro is encountered after attributes and specifiers while parsing a function, or variable:
|
||||
// It will consume the macro and treat it as resolving the definition. (Yes this is for Unreal Engine)
|
||||
// It will consume the macro and treat it as resolving the definition.
|
||||
// (MUST BE OF MT_Statement TYPE)
|
||||
MF_Allow_As_Definition = bit(4),
|
||||
MF_Allow_As_Definition = bit(5),
|
||||
|
||||
MF_Allow_As_Specifier = bit(5), // Created for Unreal's PURE_VIRTUAL
|
||||
// Created for Unreal's PURE_VIRTUAL
|
||||
MF_Allow_As_Specifier = bit(6),
|
||||
|
||||
MF_Null = 0,
|
||||
MF_UnderlyingType = GEN_U16_MAX,
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#ifdef INTELLISENSE_DIRECTIVES
|
||||
#pragma once
|
||||
#include "../gen.hpp"
|
||||
#include "interface.hpp"
|
||||
#endif
|
||||
|
||||
#pragma region StaticData
|
||||
@@ -8,6 +8,8 @@ GEN_API global Context* _ctx;
|
||||
GEN_API global u32 context_counter;
|
||||
|
||||
#pragma region Constants
|
||||
GEN_API read_only global Token NullToken = { { 0, 0 }, Tok_Invalid, 0, 0, TF_Null };
|
||||
|
||||
GEN_API global Macro enum_underlying_macro;
|
||||
|
||||
GEN_API global Code Code_Global;
|
||||
|
||||
@@ -1,6 +1,18 @@
|
||||
#ifdef INTELLISENSE_DIRECTIVES
|
||||
#pragma once
|
||||
#include "header_start.hpp"
|
||||
#include "dependencies/platform.hpp"
|
||||
#include "dependencies/macros.hpp"
|
||||
#include "dependencies/basic_types.hpp"
|
||||
#include "dependencies/debug.hpp"
|
||||
#include "dependencies/memory.hpp"
|
||||
#include "dependencies/string_ops.hpp"
|
||||
#include "dependencies/printing.hpp"
|
||||
#include "dependencies/containers.hpp"
|
||||
#include "dependencies/hashing.hpp"
|
||||
#include "dependencies/strings.hpp"
|
||||
#include "dependencies/filesystem.hpp"
|
||||
#include "dependencies/timing.hpp"
|
||||
#include "dependencies/parsing.hpp"
|
||||
#endif
|
||||
|
||||
/*
|
||||
@@ -19,14 +31,45 @@
|
||||
|
||||
*/
|
||||
|
||||
using LogFailType = ssize(*)(char const*, ...);
|
||||
enum LogLevel //: u32
|
||||
{
|
||||
LL_Null,
|
||||
LL_Note,
|
||||
LL_Warning,
|
||||
LL_Error,
|
||||
LL_Fatal,
|
||||
LL_UnderlyingType = GEN_U32_MAX,
|
||||
};
|
||||
typedef enum LogLevel LogLevel;
|
||||
|
||||
Str loglevel_to_str(LogLevel level)
|
||||
{
|
||||
local_persist
|
||||
Str lookup[] = {
|
||||
{ "Null", sizeof("Null") - 1 },
|
||||
{ "Note", sizeof("Note") - 1 },
|
||||
{ "Warning", sizeof("Info") - 1 },
|
||||
{ "Error", sizeof("Error") - 1 },
|
||||
{ "Fatal", sizeof("Fatal") - 1 },
|
||||
};
|
||||
return lookup[level];
|
||||
}
|
||||
|
||||
typedef struct LogEntry LogEntry;
|
||||
struct LogEntry
|
||||
{
|
||||
Str msg;
|
||||
LogLevel level;
|
||||
};
|
||||
|
||||
typedef void LoggerProc(LogEntry entry);
|
||||
|
||||
// By default this library will either crash or exit if an error is detected while generating codes.
|
||||
// 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
|
||||
#define log_failure( ... ) log_fmt( __VA_ARGS__ )
|
||||
#else
|
||||
#define log_failure GEN_FATAL
|
||||
#define log_failure( ... ) GEN_FATAL( __VA_ARGS__ )
|
||||
#endif
|
||||
|
||||
enum AccessSpec : u32
|
||||
|
||||
@@ -17,6 +17,39 @@ template <class TType> struct RemovePtr<TType*> { typedef TType Type; };
|
||||
|
||||
template <class TType> using TRemovePtr = typename RemovePtr<TType>::Type;
|
||||
|
||||
#pragma region Slice
|
||||
#if 0
|
||||
#define Slice(Type) Slice<Type>
|
||||
|
||||
template<class Type> struct Slice;
|
||||
|
||||
template<class Type>
|
||||
Type* slice_get(Slice<Type> self, ssize id) {
|
||||
GEN_ASSERT(id > -1);
|
||||
GEN_ASSERT(id < self.len);
|
||||
return self.ptr[id];
|
||||
}
|
||||
|
||||
template<class Type>
|
||||
struct Slice
|
||||
{
|
||||
Type* ptr;
|
||||
ssize len;
|
||||
|
||||
#if GEN_COMPILER_CPP
|
||||
forceinline operator Token* () const { return ptr; }
|
||||
forceinline Token& operator[]( ssize index ) const { return ptr[index]; }
|
||||
|
||||
forceinline Type* begin() { return ptr; }
|
||||
forceinline Type* end() { return ptr + len; }
|
||||
#endif
|
||||
|
||||
#if ! GEN_C_LIKE_CPP && GEN_COMPILER_CPP
|
||||
forceinline Type& back() { return ptr[len - 1]; }
|
||||
#endif
|
||||
};
|
||||
#endif
|
||||
#pragma endregion Slice
|
||||
|
||||
#pragma region Array
|
||||
#define Array(Type) Array<Type>
|
||||
@@ -26,10 +59,8 @@ template <class TType> using TRemovePtr = typename RemovePtr<TType>::Type;
|
||||
|
||||
struct ArrayHeader;
|
||||
|
||||
#if GEN_COMPILER_CPP
|
||||
template<class Type> struct Array;
|
||||
# define get_array_underlying_type(array) typename TRemovePtr<typeof(array)>:: DataType
|
||||
#endif
|
||||
template<class Type> struct Array;
|
||||
#define get_array_underlying_type(array) typename TRemovePtr<typeof(array)>:: DataType
|
||||
|
||||
usize array_grow_formula(ssize value);
|
||||
|
||||
@@ -59,12 +90,12 @@ struct ArrayHeader {
|
||||
usize Num;
|
||||
};
|
||||
|
||||
#if GEN_COMPILER_CPP
|
||||
template<class Type>
|
||||
struct Array
|
||||
{
|
||||
Type* Data;
|
||||
|
||||
#if ! GEN_C_LIKE_CPP
|
||||
#pragma region Member Mapping
|
||||
forceinline static Array init(AllocatorInfo allocator) { return array_init<Type>(allocator); }
|
||||
forceinline static Array init_reserve(AllocatorInfo allocator, ssize capacity) { return array_init_reserve<Type>(allocator, capacity); }
|
||||
@@ -88,6 +119,7 @@ struct Array
|
||||
forceinline bool resize(usize num) { return array_resize<Type>(this, num); }
|
||||
forceinline bool set_capacity(usize new_capacity) { return array_set_capacity<Type>(this, new_capacity); }
|
||||
#pragma endregion Member Mapping
|
||||
#endif
|
||||
|
||||
forceinline operator Type*() { return Data; }
|
||||
forceinline operator Type const*() const { return Data; }
|
||||
@@ -99,9 +131,8 @@ struct Array
|
||||
|
||||
using DataType = Type;
|
||||
};
|
||||
#endif
|
||||
|
||||
#if GEN_COMPILER_CPP && 0
|
||||
#if 0
|
||||
template<class Type> bool append(Array<Type>& array, Array<Type> other) { return append( & array, other ); }
|
||||
template<class Type> bool append(Array<Type>& array, Type value) { return append( & array, value ); }
|
||||
template<class Type> bool append(Array<Type>& array, Type* items, usize item_num) { return append( & array, items, item_num ); }
|
||||
|
||||
@@ -1,9 +1,6 @@
|
||||
#ifdef INTELLISENSE_DIRECTIVES
|
||||
# pragma once
|
||||
# include "dependencies/platform.hpp"
|
||||
# include "dependencies/macros.hpp"
|
||||
# include "basic_types.hpp"
|
||||
# include "macros.hpp"
|
||||
#endif
|
||||
|
||||
#pragma region Debug
|
||||
|
||||
@@ -187,7 +187,7 @@ struct FileContents
|
||||
{
|
||||
AllocatorInfo allocator;
|
||||
void* data;
|
||||
ssize size;
|
||||
ssize size;
|
||||
};
|
||||
|
||||
constexpr b32 file_zero_terminate = true;
|
||||
|
||||
@@ -38,6 +38,16 @@
|
||||
#ifndef local_persist
|
||||
#define local_persist static // Local Persisting variables
|
||||
#endif
|
||||
#ifndef read_only
|
||||
# if GEN_COMPILER_MSVC || ( defined(GEN_COMPILER_CLANG) && GEN_COMPILER_CLANG && GEN_SYSTEM_WINDOWS )
|
||||
# pragma section(".rdata$", read)
|
||||
# define read_only __declspec(allocate(".rdata$"))
|
||||
# elif defined(GEN_COMPILER_CLANG) && GEN_COMPILER_CLANG
|
||||
# define read_only __attribute__((section(".rodata")))
|
||||
# else
|
||||
# define read_only
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef bit
|
||||
#define bit( Value ) ( 1 << Value )
|
||||
@@ -98,9 +108,9 @@
|
||||
#define src_line_str stringize(__LINE__)
|
||||
|
||||
#ifndef do_once
|
||||
#define do_once() \
|
||||
local_persist int __do_once_counter_##src_line_str = 0; \
|
||||
for(; __do_once_counter_##src_line_str != 1; __do_once_counter_##src_line_str = 1 ) \
|
||||
#define do_once() \
|
||||
local_persist int __do_once_counter_##src_line_str = 0; \
|
||||
for(; __do_once_counter_##src_line_str != 1; __do_once_counter_##src_line_str = 1 ) \
|
||||
|
||||
#define do_once_defer( expression ) \
|
||||
local_persist int __do_once_counter_##src_line_str = 0; \
|
||||
@@ -198,21 +208,16 @@
|
||||
#ifndef forceinline
|
||||
# if GEN_COMPILER_MSVC
|
||||
# define forceinline __forceinline
|
||||
# define neverinline __declspec( noinline )
|
||||
# elif GEN_COMPILER_GCC
|
||||
# define forceinline inline __attribute__((__always_inline__))
|
||||
# define neverinline __attribute__( ( __noinline__ ) )
|
||||
# elif 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
|
||||
#endif
|
||||
|
||||
@@ -303,10 +308,28 @@
|
||||
# define GEN_PARAM_DEFAULT
|
||||
#endif
|
||||
|
||||
#if GEN_COMPILER_CPP
|
||||
#define struct_init(type, value) {value}
|
||||
#else
|
||||
#define struct_init(type, value) {value}
|
||||
#ifndef struct_init
|
||||
# if GEN_COMPILER_CPP
|
||||
# define struct_init(type)
|
||||
# else
|
||||
# define struct_init(type) (type)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef struct_zero
|
||||
# if GEN_COMPILER_CPP
|
||||
# define struct_zero(type) {}
|
||||
# else
|
||||
# define struct_zero(type) (type) {0}
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#ifndef struct_zero_init
|
||||
# if GEN_COMPILER_CPP
|
||||
# define struct_zero_init() {}
|
||||
# else
|
||||
# define struct_zero_init() {0}
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
@@ -319,4 +342,12 @@
|
||||
# define GEN_OPITMIZE_MAPPINGS_END
|
||||
#endif
|
||||
|
||||
#ifndef get_optional
|
||||
# if GEN_COMPILER_C
|
||||
# define get_optional(opt) opt ? *opt : (typeof(*opt)){0}
|
||||
# else
|
||||
# define get_optional(opt) opt
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#pragma endregion Macros
|
||||
@@ -134,12 +134,6 @@ GEN_API void* heap_allocator_proc( void* allocator_data, AllocType type, ssize s
|
||||
//! The heap allocator backed by operating system's memory manager.
|
||||
constexpr AllocatorInfo heap( void ) { AllocatorInfo allocator = { heap_allocator_proc, nullptr }; return allocator; }
|
||||
|
||||
//! Helper to allocate memory using heap allocator.
|
||||
#define malloc( sz ) alloc( heap(), sz )
|
||||
|
||||
//! Helper to free memory allocated by heap allocator.
|
||||
#define mfree( ptr ) free( heap(), ptr )
|
||||
|
||||
struct VirtualMemory
|
||||
{
|
||||
void* data;
|
||||
@@ -185,6 +179,8 @@ void arena_check (Arena* arena);
|
||||
void arena_free (Arena* arena);
|
||||
ssize arena_size_remaining(Arena* arena, ssize alignment);
|
||||
|
||||
// TODO(Ed): Add arena_pos, arena_pop, and arena_pop_to
|
||||
|
||||
struct Arena
|
||||
{
|
||||
AllocatorInfo Backing;
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#ifdef INTELLISENSE_DIRECTIVES
|
||||
# pragma once
|
||||
# include "strbuilder_ops.cpp"
|
||||
# include "string_ops.cpp"
|
||||
#endif
|
||||
|
||||
#pragma region Printing
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#ifdef INTELLISENSE_DIRECTIVES
|
||||
# pragma once
|
||||
# include "strbuilder_ops.hpp"
|
||||
# include "string_ops.hpp"
|
||||
#endif
|
||||
|
||||
#pragma region Printing
|
||||
@@ -26,17 +26,4 @@ GEN_API ssize c_str_fmt_file_va ( FileInfo* f, char const* fmt, va_list va );
|
||||
constexpr
|
||||
char const* Msg_Invalid_Value = "INVALID VALUE PROVIDED";
|
||||
|
||||
inline
|
||||
ssize log_fmt(char const* fmt, ...)
|
||||
{
|
||||
ssize res;
|
||||
va_list va;
|
||||
|
||||
va_start(va, fmt);
|
||||
res = c_str_fmt_out_va(fmt, va);
|
||||
va_end(va);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
#pragma endregion Printing
|
||||
@@ -320,7 +320,7 @@ inline
|
||||
StrBuilder strbuilder_fmt_buf(AllocatorInfo allocator, char const* fmt, ...)
|
||||
{
|
||||
local_persist thread_local
|
||||
PrintF_Buffer buf = struct_init(PrintF_Buffer, {0});
|
||||
PrintF_Buffer buf = struct_zero_init();
|
||||
|
||||
va_list va;
|
||||
va_start(va, fmt);
|
||||
|
||||
@@ -11,9 +11,6 @@
|
||||
#include "helpers/push_ignores.inline.hpp"
|
||||
#include "components/header_start.hpp"
|
||||
|
||||
// Has container defines pushed
|
||||
#include "gen.dep.hpp"
|
||||
|
||||
GEN_NS_BEGIN
|
||||
|
||||
#include "components/types.hpp"
|
||||
|
||||
+15
-3
@@ -37,7 +37,11 @@ void clang_format_file( char const* path, char const* style_path )
|
||||
strbuilder_append_str( & command, cf_verbose );
|
||||
strbuilder_append_string( & command, style_arg );
|
||||
strbuilder_append_string( & command, resolved_path );
|
||||
system( command );
|
||||
int command_result = system( command );
|
||||
if ( command_result != 0 ) {
|
||||
log_fmt( "clang-format failed with status %d\n", command_result );
|
||||
process_exit( 1 );
|
||||
}
|
||||
}
|
||||
|
||||
// Will refactor a file with the given script at the provided path.
|
||||
@@ -48,12 +52,20 @@ void refactor_file( char const* path, char const* refactor_script )
|
||||
GEN_ASSERT_NOT_NULL(path);
|
||||
GEN_ASSERT_NOT_NULL(refactor_script);
|
||||
|
||||
StrBuilder command = strbuilder_make_str(_ctx->Allocator_Temp, txt("refactor "));
|
||||
Str refactor_exe = GEN_SYSTEM_WINDOWS ?
|
||||
txt("\"..\\scripts\\helpers\\refactor.exe\" ")
|
||||
: txt("../scripts/helpers/refactor ");
|
||||
|
||||
StrBuilder command = strbuilder_make_str(_ctx->Allocator_Temp, refactor_exe);
|
||||
// strbuilder_append_str( & command, txt("-debug ") );
|
||||
strbuilder_append_str( & command, txt("-num=1 ") );
|
||||
strbuilder_append_fmt( & command, "-src=%s ", path );
|
||||
strbuilder_append_fmt( & command,"-spec=%s ", refactor_script );
|
||||
system(command);
|
||||
int command_result = system( command );
|
||||
if ( command_result != 0 ) {
|
||||
log_fmt( "refactor failed with status %d\n", command_result );
|
||||
process_exit( 1 );
|
||||
}
|
||||
log_fmt("\n");
|
||||
}
|
||||
|
||||
|
||||
+3
-3
@@ -15,6 +15,9 @@ You can think of this parser as *frontend parser* vs a *semantic parser*. Its in
|
||||
User exposed interface:
|
||||
|
||||
```cpp
|
||||
CodeBody parse_global_body ( Str body_def, Opts_parse_global_body opts );
|
||||
void parse_global_body_base( Context* ctx, Str body_def, ParseInfo* info );
|
||||
|
||||
CodeClass parse_class ( Str class_def );
|
||||
CodeConstructor parse_constructor ( Str constructor_def );
|
||||
CodeDefine parse_define ( Str define_def );
|
||||
@@ -24,7 +27,6 @@ CodeBody parse_export_body ( Str export_def );
|
||||
CodeExtern parse_extern_link ( Str exten_link_def );
|
||||
CodeFriend parse_friend ( Str friend_def );
|
||||
CodeFn parse_function ( Str fn_def );
|
||||
CodeBody parse_global_body ( Str body_def );
|
||||
CodeNS parse_namespace ( Str namespace_def );
|
||||
CodeOperator parse_operator ( Str operator_def );
|
||||
CodeOpCast parse_operator_cast( Str operator_def );
|
||||
@@ -155,5 +157,3 @@ typedef HashTable(Macro) MacroTable;
|
||||
* typedefs have attributes with the type (`parse_type`)
|
||||
* Parsing attributes can be extended to support user defined macros by defining `GEN_DEFINE_ATTRIBUTE_TOKENS` (see `gen.hpp` for the formatting)
|
||||
* This is useful for example: parsing Unreal `Module_API` macros.
|
||||
|
||||
**The lexer & parser do not gracefully attempt to continue when it comes across incorrect code, and doesn't properly track errors into a listing (yet).**
|
||||
+65
-30
@@ -129,7 +129,8 @@ int gen_main()
|
||||
(Macro { txt("GEN_FILE_WRITE_AT_PROC"), MT_Statement, MF_Functional | MF_Expects_Body }),
|
||||
(Macro { txt("GEN_FILE_SEEK_PROC"), MT_Statement, MF_Functional | MF_Expects_Body }),
|
||||
(Macro { txt("GEN_FILE_CLOSE_PROC"), MT_Statement, MF_Functional | MF_Expects_Body }),
|
||||
(Macro { txt("log_failure"), MT_Expression, MF_Null }),
|
||||
(Macro { txt("log_failure"), MT_Statement, MF_Functional }),
|
||||
(Macro { txt("NullScope"), MT_Expression, MF_Null }),
|
||||
(Macro { txt("operator"), MT_Expression, MF_Null }),
|
||||
(Macro { txt("InvalidCode"), MT_Expression, MF_Null }),
|
||||
(Macro { txt("NullCode"), MT_Expression, MF_Null }),
|
||||
@@ -137,8 +138,8 @@ int gen_main()
|
||||
(Macro { txt("gen_main"), MT_Statement, MF_Null })
|
||||
));
|
||||
register_macros( args(
|
||||
(Macro { txt("name"), MT_Expression, MF_Functional }),
|
||||
(Macro { txt("code"), MT_Expression, MF_Functional }),
|
||||
(Macro { txt("name"), MT_Expression, MF_Functional | MF_Allow_As_Identifier }),
|
||||
(Macro { txt("code"), MT_Expression, MF_Functional | MF_Allow_As_Identifier }),
|
||||
(Macro { txt("args"), MT_Expression, MF_Functional }),
|
||||
(Macro { txt("code_str"), MT_Expression, MF_Functional }),
|
||||
(Macro { txt("code_fmt"), MT_Expression, MF_Functional }),
|
||||
@@ -494,10 +495,10 @@ do \
|
||||
case CT_Union_Fwd:
|
||||
{
|
||||
Str type_str = codetype_to_keyword_str(entry->Type);
|
||||
Str formated_tmpl = token_fmt_impl( 3,
|
||||
"type", type_str
|
||||
, "name", entry->Name,
|
||||
stringize(
|
||||
Str formated_tmpl = token_fmt_impl( 3
|
||||
, "type", type_str
|
||||
, "name", entry->Name
|
||||
, stringize(
|
||||
typedef <type> <name> <name>;
|
||||
));
|
||||
CodeTypedef tdef = parse_typedef(formated_tmpl);
|
||||
@@ -597,10 +598,10 @@ do \
|
||||
}
|
||||
|
||||
Str type_str = codetype_to_keyword_str(entry->Type);
|
||||
Str formated_tmpl = token_fmt_impl( 3,
|
||||
"type", type_str
|
||||
, "name", entry->Name,
|
||||
stringize(
|
||||
Str formated_tmpl = token_fmt_impl( 3
|
||||
, "type", type_str
|
||||
, "name", entry->Name
|
||||
, stringize(
|
||||
typedef <type> <name> <name>;
|
||||
));
|
||||
CodeTypedef tdef = parse_typedef(formated_tmpl);
|
||||
@@ -739,10 +740,10 @@ do \
|
||||
{
|
||||
// pop the array entry
|
||||
array_token->NumEntries -= 1;
|
||||
Code next = array_entry->Next;
|
||||
Code prev = array_entry->Prev;
|
||||
next->Prev = array_entry->Prev;
|
||||
prev->Next = next;
|
||||
Code next = array_entry->Next;
|
||||
Code prev = array_entry->Prev;
|
||||
next->Prev = array_entry->Prev;
|
||||
prev->Next = next;
|
||||
if ( array_token->Front == array_entry )
|
||||
array_token->Front = next;
|
||||
|
||||
@@ -767,20 +768,7 @@ do \
|
||||
break;
|
||||
|
||||
case CT_Variable:
|
||||
{
|
||||
CodeVar var = cast(CodeVar, entry);
|
||||
if (var->Specs && var->Specs.has(Spec_Constexpr)) {
|
||||
Code define_ver = untyped_str(token_fmt(
|
||||
"name", var->Name
|
||||
, "value", var->Value->Content
|
||||
, "type", var->ValueType.to_strbuilder().to_str()
|
||||
, "#define <name> (<type>) <value>\n"
|
||||
));
|
||||
parser_types.append(define_ver);
|
||||
continue;
|
||||
}
|
||||
parser_types.append(entry);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
@@ -1155,10 +1143,33 @@ R"(#define <interface_name>( code ) _Generic( (code), \
|
||||
for ( CodeParams opt_param : fn->Params ) if (opt_param->ValueType->Name.starts_with(txt("Opts_")))
|
||||
{
|
||||
// Convert the definition to use a default struct: https://vxtwitter.com/vkrajacic/status/1749816169736073295
|
||||
if ( fn->Name.is_equal( txt("parse_global_body") ) )
|
||||
{
|
||||
Str new_name = txt("parse_global_body_opts");
|
||||
char const* tmpl_fn_macro = "#define <def_name>( <params> ... ) <def__name>( <params> & (<opts_type>) { __VA_ARGS__ } )\n";
|
||||
Code fn_macro;
|
||||
|
||||
opt_param->ValueType->Specs = def_specifier( Spec_Ptr );
|
||||
fn_macro = untyped_str( token_fmt(
|
||||
"def_name", fn->Name
|
||||
, "def__name", new_name
|
||||
, "params", txt("def, ")
|
||||
, "opts_type", opt_param->ValueType->Name
|
||||
, tmpl_fn_macro
|
||||
));
|
||||
fn->Name = cache_str( new_name );
|
||||
interface.append( fn );
|
||||
interface.append( fn_macro );
|
||||
handled = true;
|
||||
break;
|
||||
}
|
||||
|
||||
Str prefix = txt("def_");
|
||||
Str actual_name = { fn->Name.Ptr + prefix.Len, fn->Name.Len - prefix.Len };
|
||||
Str new_name = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "def__%S", actual_name ).to_str();
|
||||
|
||||
opt_param->ValueType->Specs = def_specifier(Spec_Ptr);
|
||||
|
||||
// Resolve define's arguments
|
||||
b32 has_args = fn->Params->NumEntries > 1;
|
||||
StrBuilder params_str = StrBuilder::make_reserve(_ctx->Allocator_Temp, 32);
|
||||
@@ -1172,10 +1183,10 @@ R"(#define <interface_name>( code ) _Generic( (code), \
|
||||
}
|
||||
char const* tmpl_fn_macro = nullptr;
|
||||
if (params_str.length() > 0 ) {
|
||||
tmpl_fn_macro= "#define <def_name>( <params> ... ) <def__name>( <params> (<opts_type>) { __VA_ARGS__ } )\n";
|
||||
tmpl_fn_macro= "#define <def_name>( <params> ... ) <def__name>( <params> & (<opts_type>) { __VA_ARGS__ } )\n";
|
||||
}
|
||||
else {
|
||||
tmpl_fn_macro= "#define <def_name>( ... ) <def__name>( (<opts_type>) { __VA_ARGS__ } )\n";
|
||||
tmpl_fn_macro= "#define <def_name>( ... ) <def__name>( & (<opts_type>) { __VA_ARGS__ } )\n";
|
||||
}
|
||||
Code fn_macro = untyped_str(token_fmt(
|
||||
"def_name", fn->Name
|
||||
@@ -1420,6 +1431,29 @@ R"(#define <interface_name>( code ) _Generic( (code), \
|
||||
Code src_code_serialization = scan_file( path_base "components/code_serialization.cpp" );
|
||||
|
||||
Code src_parsing_interface = scan_file( path_base "components/interface.parsing.cpp" );
|
||||
{
|
||||
Str needle = txt("CodeBody parse_global_body( Str def, Opts_parse_global_body opts )");
|
||||
Str scanned = src_parsing_interface->Content;
|
||||
ssize signature_at = -1;
|
||||
ssize scan_offset;
|
||||
ssize last_offset = scanned.Len - needle.Len;
|
||||
for ( scan_offset = 0; scan_offset <= last_offset; ++ scan_offset )
|
||||
{
|
||||
if ( c_str_compare_len( scanned.Ptr + scan_offset, needle.Ptr, needle.Len ) == 0 ) {
|
||||
signature_at = scan_offset;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ( signature_at < 0 ) GEN_FATAL( "c_library: parse_global_body signature missing from scanned interface.parsing.cpp" );
|
||||
/*Resolved replacement*/ {
|
||||
Str replacement = txt("CodeBody parse_global_body_opts( Str def, Opts_parse_global_body* opts )");
|
||||
StrBuilder rebuilt = strbuilder_make_reserve( _ctx->Allocator_Temp, scanned.Len + replacement.Len );
|
||||
strbuilder_append_str( & rebuilt, Str { scanned.Ptr, signature_at } );
|
||||
strbuilder_append_str( & rebuilt, replacement );
|
||||
strbuilder_append_str( & rebuilt, Str { scanned.Ptr + signature_at + needle.Len, scanned.Len - signature_at - needle.Len } );
|
||||
src_parsing_interface = untyped_str( strbuilder_to_str( rebuilt ) );
|
||||
}
|
||||
}
|
||||
Code src_untyped = scan_file( path_base "components/interface.untyped.cpp" );
|
||||
Code src_parser_case_macros = scan_file( path_base "components/parser_case_macros.cpp" );
|
||||
|
||||
@@ -1504,6 +1538,7 @@ R"(#define <interface_name>( code ) _Generic( (code), \
|
||||
Str actual_name = { fn->Name.Ptr + prefix.Len, fn->Name.Len - prefix.Len };
|
||||
Str new_name = StrBuilder::fmt_buf(_ctx->Allocator_Temp, "def__%S", actual_name ).to_str();
|
||||
fn->Name = cache_str(new_name);
|
||||
opt_param->ValueType->Specs = def_specifier(Spec_Ptr);
|
||||
}
|
||||
src_upfront.append(fn);
|
||||
}
|
||||
|
||||
@@ -20,6 +20,7 @@
|
||||
word global, gen_global
|
||||
word internal, gen_internal
|
||||
word local_persist, gen_local_persist
|
||||
word read_only, gen_read_only
|
||||
word bit, gen_bit
|
||||
word bitfield_is_set, gen_bitfield_is_set
|
||||
word cast, gen_cast
|
||||
@@ -53,6 +54,7 @@ word enum_underlying, gen_enum_underlying
|
||||
word nullptr, gen_nullptr
|
||||
word struct_init, gen_struct_init
|
||||
word hash, gen_hash
|
||||
word txt, gen_txt
|
||||
|
||||
// Basic Types
|
||||
|
||||
@@ -410,6 +412,8 @@ namespace var_, gen_var_
|
||||
|
||||
word _ctx, gen__ctx
|
||||
|
||||
word get_context, gen_get_context
|
||||
|
||||
word init, gen_init
|
||||
word deinit, gen_deinit
|
||||
word reset, gen_reset
|
||||
@@ -532,7 +536,7 @@ namespace Lexer_, gen_Lexer_
|
||||
word LexContext, gen_LexContext
|
||||
word lex, gen_lex
|
||||
|
||||
word StackNode, gen_StackNode
|
||||
word ParseStackNode, gen_ParseStackNode
|
||||
word ParseContext, gen_ParseContext
|
||||
|
||||
// namespace parse_, gen_parse_
|
||||
|
||||
@@ -25,6 +25,11 @@ args:
|
||||
segmented
|
||||
singleheader
|
||||
unreal
|
||||
test
|
||||
parser_bounds
|
||||
lexer_failures
|
||||
parse_body_messages
|
||||
dogfood_parse
|
||||
clang
|
||||
msvc : By default this project builds with clang, specifying msvc will build with MSVC.
|
||||
debug
|
||||
|
||||
+234
-133
@@ -10,22 +10,76 @@ $vendor_toolchain = Join-Path $PSScriptRoot 'helpers/vendor_toolchain.ps1'
|
||||
|
||||
Import-Module $misc
|
||||
|
||||
$path_root = Get-ScriptRepoRoot
|
||||
function stop-stage {
|
||||
param([string]$stage, [int]$code_exit = 1)
|
||||
Write-Host "FAILED: $stage" -ForegroundColor Red
|
||||
exit $code_exit
|
||||
}
|
||||
|
||||
function invoke-stageTool {
|
||||
param(
|
||||
[string]$stage,
|
||||
[bool]$compiled,
|
||||
[string]$executable,
|
||||
[string]$path_work
|
||||
)
|
||||
if (-not $compiled) {
|
||||
stop-stage "$stage compile/link"
|
||||
}
|
||||
if (-not (Test-Path -LiteralPath $executable)) {
|
||||
stop-stage "$stage missing output $executable"
|
||||
}
|
||||
$code_exit = 1
|
||||
push-location $path_work
|
||||
try {
|
||||
& $executable
|
||||
$code_exit = $LASTEXITCODE
|
||||
}
|
||||
finally {
|
||||
pop-location
|
||||
}
|
||||
if ($code_exit -ne 0) {
|
||||
stop-stage "$stage run" $code_exit
|
||||
}
|
||||
Write-Host "PASSED: $stage"
|
||||
}
|
||||
|
||||
if ($env:GENCPP_SOURCE_ROOT) {
|
||||
$path_root = (Resolve-Path -LiteralPath $env:GENCPP_SOURCE_ROOT).Path
|
||||
$probe = Join-Path $path_root "base\base.cpp"
|
||||
if (-not (Test-Path -LiteralPath $probe)) {
|
||||
stop-stage "GENCPP_SOURCE_ROOT is not a gencpp tree: $path_root"
|
||||
}
|
||||
}
|
||||
else {
|
||||
$path_root = Get-ScriptRepoRoot
|
||||
}
|
||||
Write-Host "SOURCE_ROOT: $path_root"
|
||||
if ($null -eq $is_windows) {
|
||||
$is_windows = [System.Environment]::OSVersion.Platform -eq 'Win32NT'
|
||||
}
|
||||
if ($null -eq $is_linux) {
|
||||
$is_linux = [System.Environment]::OSVersion.Platform -eq 'Unix'
|
||||
}
|
||||
|
||||
Push-Location $path_root
|
||||
|
||||
#region Arguments
|
||||
$vendor = $null
|
||||
$release = $null
|
||||
[bool] $verbose = $false
|
||||
[bool] $base = $false
|
||||
[bool] $segmented = $false
|
||||
[bool] $singleheader = $false
|
||||
[bool] $c_lib = $false
|
||||
[bool] $c_lib_static = $false
|
||||
[bool] $c_lib_dyn = $false
|
||||
[bool] $unreal = $false
|
||||
[bool] $test = $false
|
||||
$vendor = $null
|
||||
$release = $null
|
||||
[bool] $verbose = $false
|
||||
[bool] $base = $false
|
||||
[bool] $segmented = $false
|
||||
[bool] $singleheader = $false
|
||||
[bool] $c_lib = $false
|
||||
[bool] $c_lib_static = $false
|
||||
[bool] $c_lib_dyn = $false
|
||||
[bool] $unreal = $false
|
||||
[bool] $test = $false
|
||||
[bool] $parser_bounds = $false
|
||||
[bool] $lexer_failures = $false
|
||||
[bool] $parse_body_messages = $false
|
||||
[bool] $dogfood_parse = $false
|
||||
|
||||
[array] $vendors = @( "clang", "msvc" )
|
||||
|
||||
@@ -33,24 +87,28 @@ Push-Location $path_root
|
||||
|
||||
if ( $args ) { $args | ForEach-Object {
|
||||
switch ($_){
|
||||
{ $_ -in $vendors } { $vendor = $_; break }
|
||||
"verbose" { $verbose = $true }
|
||||
"release" { $release = $true }
|
||||
"debug" { $release = $false }
|
||||
"base" { $base = $true }
|
||||
"segmented" { $segmented = $true }
|
||||
"singleheader" { $singleheader = $true }
|
||||
"c_lib" { $c_lib = $true }
|
||||
"c_lib_static" { $c_lib_static = $true }
|
||||
"c_lib_dyn" { $c_lib_dyn = $true }
|
||||
"unreal" { $unreal = $true }
|
||||
"test" { $test = $true }
|
||||
{ $_ -in $vendors } { $vendor = $_; break }
|
||||
"verbose" { $verbose = $true }
|
||||
"release" { $release = $true }
|
||||
"debug" { $release = $false }
|
||||
"base" { $base = $true }
|
||||
"segmented" { $segmented = $true }
|
||||
"singleheader" { $singleheader = $true }
|
||||
"c_lib" { $c_lib = $true }
|
||||
"c_lib_static" { $c_lib_static = $true }
|
||||
"c_lib_dyn" { $c_lib_dyn = $true }
|
||||
"unreal" { $unreal = $true }
|
||||
"test" { $test = $true }
|
||||
"parser_bounds" { $parser_bounds = $true }
|
||||
"lexer_failures" { $lexer_failures = $true }
|
||||
"parse_body_messages" { $parse_body_messages = $true }
|
||||
"dogfood_parse" { $dogfood_parse = $true }
|
||||
}
|
||||
}}
|
||||
#endregion Arguments
|
||||
|
||||
#region Configuration
|
||||
if ($IsWindows) {
|
||||
if ($is_windows) {
|
||||
# This library was really designed to only run on 64-bit systems.
|
||||
# (Its a development tool after all)
|
||||
& $devshell -arch amd64
|
||||
@@ -64,6 +122,7 @@ if ( $vendor -eq $null ) {
|
||||
if ( $release -eq $null ) {
|
||||
write-host "No build type specified, assuming debug"
|
||||
$release = $false
|
||||
$debug = $true
|
||||
}
|
||||
elseif ( $release -eq $false ) {
|
||||
$debug = $true
|
||||
@@ -72,16 +131,20 @@ else {
|
||||
$optimize = $true
|
||||
}
|
||||
|
||||
$cannot_build = $base -eq $false
|
||||
$cannot_build = $cannot_build -and $segmented -eq $false
|
||||
$cannot_build = $cannot_build -and $singleheader -eq $false
|
||||
$cannot_build = $cannot_build -and $c_lib -eq $false
|
||||
$cannot_build = $cannot_build -and $c_lib_static -eq $false
|
||||
$cannot_build = $cannot_build -and $c_lib_dyn -eq $false
|
||||
$cannot_build = $cannot_build -and $unreal -eq $false
|
||||
$cannot_build = $cannot_build -and $test -eq $false
|
||||
$cannot_build = $base -eq $false
|
||||
$cannot_build = $cannot_build -and $segmented -eq $false
|
||||
$cannot_build = $cannot_build -and $singleheader -eq $false
|
||||
$cannot_build = $cannot_build -and $c_lib -eq $false
|
||||
$cannot_build = $cannot_build -and $c_lib_static -eq $false
|
||||
$cannot_build = $cannot_build -and $c_lib_dyn -eq $false
|
||||
$cannot_build = $cannot_build -and $unreal -eq $false
|
||||
$cannot_build = $cannot_build -and $test -eq $false
|
||||
$cannot_build = $cannot_build -and $parser_bounds -eq $false
|
||||
$cannot_build = $cannot_build -and $lexer_failures -eq $false
|
||||
$cannot_build = $cannot_build -and $parse_body_messages -eq $false
|
||||
$cannot_build = $cannot_build -and $dogfood_parse -eq $false
|
||||
if ( $cannot_build ) {
|
||||
throw "No build target specified. One must be specified, this script will not assume one"
|
||||
Stop-stage "No build target specified"
|
||||
}
|
||||
|
||||
. $vendor_toolchain
|
||||
@@ -125,18 +188,7 @@ if ( $base )
|
||||
$executable = join-path $path_build "base.exe"
|
||||
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
|
||||
|
||||
Push-Location $path_base
|
||||
if ( Test-Path( $executable ) ) {
|
||||
write-host "`nRunning base"
|
||||
$time_taken = Measure-Command { & $executable
|
||||
| ForEach-Object {
|
||||
write-host `t $_ -ForegroundColor Green
|
||||
}
|
||||
}
|
||||
write-host "`nbase completed in $($time_taken.TotalMilliseconds) ms"
|
||||
}
|
||||
Pop-Location
|
||||
invoke-stageTool -stage "base" -compiled $result -executable $executable -path_work $path_base
|
||||
}
|
||||
|
||||
if ( $segmented )
|
||||
@@ -163,18 +215,7 @@ if ( $segmented )
|
||||
$executable = join-path $path_build "segmented.exe"
|
||||
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
|
||||
|
||||
Push-Location $path_segmented
|
||||
if ( Test-Path( $executable ) ) {
|
||||
write-host "`nRunning segmented"
|
||||
$time_taken = Measure-Command { & $executable
|
||||
| ForEach-Object {
|
||||
write-host `t $_ -ForegroundColor Green
|
||||
}
|
||||
}
|
||||
write-host "`nSegmented completed in $($time_taken.TotalMilliseconds) ms"
|
||||
}
|
||||
Pop-Location
|
||||
invoke-stageTool -stage "segmented" -compiled $result -executable $executable -path_work $path_segmented
|
||||
}
|
||||
|
||||
if ( $singleheader )
|
||||
@@ -201,18 +242,7 @@ if ( $singleheader )
|
||||
)
|
||||
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
|
||||
|
||||
Push-Location $path_singleheader
|
||||
if ( Test-Path( $executable ) ) {
|
||||
write-host "`nRunning singleheader generator"
|
||||
$time_taken = Measure-Command { & $executable
|
||||
| ForEach-Object {
|
||||
write-host `t $_ -ForegroundColor Green
|
||||
}
|
||||
}
|
||||
write-host "`nSingleheader generator completed in $($time_taken.TotalMilliseconds) ms"
|
||||
}
|
||||
Pop-Location
|
||||
invoke-stageTool -stage "singleheader" -compiled $result -executable $executable -path_work $path_singleheader
|
||||
}
|
||||
|
||||
if ( $c_lib -or $c_lib_static -or $c_lib_dyn )
|
||||
@@ -239,18 +269,7 @@ if ( $c_lib -or $c_lib_static -or $c_lib_dyn )
|
||||
)
|
||||
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
|
||||
|
||||
Push-Location $path_c_library
|
||||
if ( Test-Path( $executable ) ) {
|
||||
write-host "`nRunning c_library generator"
|
||||
$time_taken = Measure-Command { & $executable
|
||||
| ForEach-Object {
|
||||
write-host `t $_ -ForegroundColor Green
|
||||
}
|
||||
}
|
||||
write-host "`nc_library generator completed in $($time_taken.TotalMilliseconds) ms"
|
||||
}
|
||||
Pop-Location
|
||||
invoke-stageTool -stage "c_lib" -compiled $result -executable $executable -path_work $path_c_library
|
||||
}
|
||||
|
||||
if ( $c_lib_static )
|
||||
@@ -267,6 +286,7 @@ if ( $c_lib_static )
|
||||
|
||||
$linker_args = @()
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $path_lib
|
||||
if (-not $result) { Stop-stage "c_lib_static compile/link" }
|
||||
}
|
||||
|
||||
if ( $c_lib_dyn )
|
||||
@@ -285,6 +305,7 @@ if ( $c_lib_dyn )
|
||||
|
||||
$linker_args = @()
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $path_dll
|
||||
if (-not $result) { Stop-stage "c_lib_dyn compile/link" }
|
||||
}
|
||||
|
||||
if ( $unreal )
|
||||
@@ -311,23 +332,27 @@ if ( $unreal )
|
||||
)
|
||||
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
|
||||
|
||||
Push-Location $path_unreal
|
||||
if ( Test-Path( $executable ) ) {
|
||||
write-host "`nRunning unreal variant generator"
|
||||
$time_taken = Measure-Command { & $executable
|
||||
| ForEach-Object {
|
||||
write-host `t $_ -ForegroundColor Green
|
||||
}
|
||||
}
|
||||
write-host "`n Unreal variant generator completed in $($time_taken.TotalMilliseconds) ms"
|
||||
}
|
||||
Pop-Location
|
||||
invoke-stageTool -stage "unreal" -compiled $result -executable $executable -path_work $path_unreal
|
||||
|
||||
. $refactor_unreal
|
||||
}
|
||||
|
||||
# C Library testing
|
||||
if ($test) {
|
||||
$consumer_headers = @(
|
||||
(Join-Path $path_c_library 'gen\gen_singleheader.h'),
|
||||
(Join-Path $path_singleheader 'gen\gen.hpp')
|
||||
)
|
||||
$header_hashes_before = @{}
|
||||
foreach ($header in $consumer_headers) {
|
||||
if (-not (Test-Path -LiteralPath $header -PathType Leaf)) {
|
||||
Stop-stage "test missing generated header $header"
|
||||
}
|
||||
$header_hashes_before[$header] = (Get-FileHash -LiteralPath $header -Algorithm SHA256).Hash
|
||||
Write-Host "HEADER_SHA256_GENERATED: $($header_hashes_before[$header]) $header"
|
||||
}
|
||||
}
|
||||
|
||||
if ( $test -and $true )
|
||||
{
|
||||
$path_test_c = join-path $path_test c_library
|
||||
@@ -356,18 +381,7 @@ if ( $test -and $true )
|
||||
)
|
||||
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
|
||||
|
||||
Push-Location $path_test_c
|
||||
if ( Test-Path( $executable ) ) {
|
||||
write-host "`nRunning c_library test"
|
||||
$time_taken = Measure-Command { & $executable
|
||||
| ForEach-Object {
|
||||
write-host `t $_ -ForegroundColor Green
|
||||
}
|
||||
}
|
||||
write-host "`nc_library generator completed in $($time_taken.TotalMilliseconds) ms"
|
||||
}
|
||||
Pop-Location
|
||||
invoke-stageTool -stage "test-c11" -compiled $result -executable $executable -path_work $path_test_c
|
||||
}
|
||||
|
||||
if ( $test -and $false )
|
||||
@@ -398,30 +412,18 @@ if ( $test -and $false )
|
||||
)
|
||||
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
|
||||
|
||||
Push-Location $path_test_c
|
||||
if ( Test-Path( $executable ) ) {
|
||||
write-host "`nRunning c_library test"
|
||||
$time_taken = Measure-Command { & $executable
|
||||
| ForEach-Object {
|
||||
write-host `t $_ -ForegroundColor Green
|
||||
}
|
||||
}
|
||||
write-host "`nc_library generator completed in $($time_taken.TotalMilliseconds) ms"
|
||||
}
|
||||
Pop-Location
|
||||
}
|
||||
|
||||
if ($test -and $false)
|
||||
if ($test)
|
||||
{
|
||||
$path_test_cpp = join-path $path_test cpp_library
|
||||
$path_build = join-path $path_test_cpp build
|
||||
$path_gen = join-path $path_test_cpp gen
|
||||
if ( -not(Test-Path($path_build) )) {
|
||||
New-Item -ItemType Directory -Path $path_build
|
||||
new-item -ItemType Directory -Path $path_build
|
||||
}
|
||||
if ( -not(Test-Path($path_gen) )) {
|
||||
New-Item -ItemType Directory -Path $path_gen
|
||||
new-item -ItemType Directory -Path $path_gen
|
||||
}
|
||||
|
||||
$path_singleheader_include = join-path $path_singleheader gen
|
||||
@@ -431,25 +433,124 @@ if ($test -and $false)
|
||||
|
||||
$compiler_args = @()
|
||||
$compiler_args += ( $flag_define + 'GEN_TIME' )
|
||||
$compiler_args += $flag_all_cpp
|
||||
$compiler_args += $flag_cpp17
|
||||
$compiler_args += ($flag_define + "GEN_BUILD_DEBUG=1")
|
||||
|
||||
$linker_args = @(
|
||||
$flag_link_win_subsystem_console
|
||||
)
|
||||
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
|
||||
invoke-stageTool -stage "test-cpp" -compiled $result -executable $executable -path_work $path_test_cpp
|
||||
}
|
||||
if ($test) {
|
||||
foreach ($header in $consumer_headers) {
|
||||
$hash = (Get-FileHash -LiteralPath $header -Algorithm SHA256).Hash
|
||||
write-host "HEADER_SHA256_CONSUMED: $hash $header"
|
||||
if ($hash -ne $header_hashes_before[$header]) {
|
||||
Stop-stage "test header changed after generation $header"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Push-Location $path_test_cpp
|
||||
if ( Test-Path( $executable ) ) {
|
||||
write-host "`nRunning cpp_library test"
|
||||
$time_taken = Measure-Command { & $executable
|
||||
| ForEach-Object {
|
||||
write-host `t $_ -ForegroundColor Green
|
||||
}
|
||||
}
|
||||
write-host "`nc_library generator completed in $($time_taken.TotalMilliseconds) ms"
|
||||
}
|
||||
Pop-Location
|
||||
if ($parser_bounds)
|
||||
{
|
||||
$path_probe = join-path $path_test parser_bounds
|
||||
$path_build = join-path $path_probe build
|
||||
if ( -not(Test-Path($path_build) )) {
|
||||
new-item -ItemType Directory -Path $path_build | Out-Null
|
||||
}
|
||||
|
||||
$includes = @( $path_base )
|
||||
$unit = join-path $path_probe "test.cpp"
|
||||
$executable = join-path $path_build "parser_bounds.exe"
|
||||
|
||||
$compiler_args = @()
|
||||
$compiler_args += ( $flag_define + 'GEN_TIME' )
|
||||
$compiler_args += $flag_cpp17
|
||||
|
||||
$linker_args = @(
|
||||
$flag_link_win_subsystem_console
|
||||
)
|
||||
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
|
||||
invoke-stageTool -stage "parser_bounds" -compiled $result -executable $executable -path_work $path_probe
|
||||
}
|
||||
|
||||
if ($lexer_failures)
|
||||
{
|
||||
$path_probe = join-path $path_test lexer_failures
|
||||
$path_build = join-path $path_probe build
|
||||
if ( -not(Test-Path($path_build) )) {
|
||||
new-item -ItemType Directory -Path $path_build | Out-Null
|
||||
}
|
||||
|
||||
$includes = @( $path_base )
|
||||
$unit = join-path $path_probe "test.cpp"
|
||||
$executable = join-path $path_build "lexer_failures.exe"
|
||||
|
||||
$compiler_args = @()
|
||||
$compiler_args += ( $flag_define + 'GEN_TIME' )
|
||||
$compiler_args += $flag_cpp17
|
||||
|
||||
$linker_args = @(
|
||||
$flag_link_win_subsystem_console
|
||||
)
|
||||
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
|
||||
invoke-stageTool -stage "lexer_failures" -compiled $result -executable $executable -path_work $path_probe
|
||||
}
|
||||
|
||||
if ($parse_body_messages)
|
||||
{
|
||||
$path_probe = join-path $path_test parse_body_messages
|
||||
$path_build = join-path $path_probe build
|
||||
if ( -not(Test-Path($path_build) )) {
|
||||
new-item -ItemType Directory -Path $path_build | Out-Null
|
||||
}
|
||||
|
||||
$includes = @( $path_base )
|
||||
$unit = join-path $path_probe "test.cpp"
|
||||
$executable = join-path $path_build "parse_body_messages.exe"
|
||||
|
||||
$compiler_args = @()
|
||||
$compiler_args += ( $flag_define + 'GEN_TIME' )
|
||||
$compiler_args += $flag_cpp17
|
||||
|
||||
$linker_args = @(
|
||||
$flag_link_win_subsystem_console
|
||||
)
|
||||
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
|
||||
invoke-stageTool -stage "parse_body_messages" -compiled $result -executable $executable -path_work $path_probe
|
||||
}
|
||||
|
||||
if ($dogfood_parse)
|
||||
{
|
||||
$path_probe = join-path $path_test dogfood_parse
|
||||
$path_build = join-path $path_probe build
|
||||
if ( -not(Test-Path($path_build) )) {
|
||||
new-item -ItemType Directory -Path $path_build | Out-Null
|
||||
}
|
||||
|
||||
$includes = @( $path_base )
|
||||
$unit = join-path $path_probe "test.cpp"
|
||||
$executable = join-path $path_build "dogfood_parse.exe"
|
||||
|
||||
$compiler_args = @()
|
||||
$compiler_args += ( $flag_define + 'GEN_TIME' )
|
||||
$compiler_args += $flag_cpp17
|
||||
|
||||
$linker_args = @(
|
||||
$flag_link_win_subsystem_console
|
||||
)
|
||||
|
||||
$result = build-simple $path_build $includes $compiler_args $linker_args $unit $executable
|
||||
invoke-stageTool -stage "dogfood_parse" -compiled $result -executable $executable -path_work $path_probe
|
||||
}
|
||||
#endregion Building
|
||||
|
||||
Pop-Location # $path_root
|
||||
pop-location # $path_root
|
||||
write-host "PASSED: build.ci.ps1"
|
||||
exit 0
|
||||
+1
-1
@@ -1,3 +1,3 @@
|
||||
cls
|
||||
$build = Join-Path $PSScriptRoot 'build.ci.ps1'
|
||||
& $build @args
|
||||
exit $LASTEXITCODE
|
||||
+36
-20
@@ -1,26 +1,30 @@
|
||||
$misc = Join-Path $PSScriptRoot 'helpers/misc.psm1'
|
||||
Import-Module $misc
|
||||
|
||||
$path_root = Get-ScriptRepoRoot
|
||||
$path_base = Join-Path $path_root base
|
||||
$path_base_build = Join-Path $path_base build
|
||||
$path_c_library = Join-Path $path_root gen_c_library
|
||||
$path_c_library_build = Join-Path $path_c_library build
|
||||
$path_c_library_gen = Join-Path $path_c_library gen
|
||||
$path_segmented = Join-Path $path_root gen_segmented
|
||||
$path_segmented_build = Join-Path $path_segmented build
|
||||
$path_segmented_gen = Join-Path $path_segmented gen
|
||||
$path_singleheader = Join-Path $path_root gen_singleheader
|
||||
$path_singleheader_build = Join-Path $path_singleheader build
|
||||
$path_singleheader_gen = Join-Path $path_singleheader gen
|
||||
$path_unreal = Join-Path $path_root gen_unreal_engine
|
||||
$path_unreal_build = Join-Path $path_unreal build
|
||||
$path_unreal_gen = Join-Path $path_unreal gen
|
||||
$path_test = Join-Path $path_root test
|
||||
$path_test_build = Join-Path $path_test build
|
||||
$path_test_gen = Join-Path $path_test gen
|
||||
$path_x64 = Join-Path $path_root x64
|
||||
$path_release = Join-Path $path_root release
|
||||
$path_root = Get-ScriptRepoRoot
|
||||
$path_base = Join-Path $path_root base
|
||||
$path_base_build = Join-Path $path_base build
|
||||
$path_c_library = Join-Path $path_root gen_c_library
|
||||
$path_c_library_build = Join-Path $path_c_library build
|
||||
$path_c_library_gen = Join-Path $path_c_library gen
|
||||
$path_segmented = Join-Path $path_root gen_segmented
|
||||
$path_segmented_build = Join-Path $path_segmented build
|
||||
$path_segmented_gen = Join-Path $path_segmented gen
|
||||
$path_singleheader = Join-Path $path_root gen_singleheader
|
||||
$path_singleheader_build = Join-Path $path_singleheader build
|
||||
$path_singleheader_gen = Join-Path $path_singleheader gen
|
||||
$path_unreal = Join-Path $path_root gen_unreal_engine
|
||||
$path_unreal_build = Join-Path $path_unreal build
|
||||
$path_unreal_gen = Join-Path $path_unreal gen
|
||||
$path_test = Join-Path $path_root test
|
||||
$path_test_build = Join-Path $path_test build
|
||||
$path_test_gen = Join-Path $path_test gen
|
||||
$path_parser_bounds_build = Join-Path $path_test "parser_bounds\build"
|
||||
$path_lexer_failures_build = Join-Path $path_test "lexer_failures\build"
|
||||
$path_parse_body_messages_build = Join-Path $path_test "parse_body_messages\build"
|
||||
$path_dogfood_parse_build = Join-Path $path_test "dogfood_parse\build"
|
||||
$path_x64 = Join-Path $path_root x64
|
||||
$path_release = Join-Path $path_root release
|
||||
|
||||
if ( Test-Path $path_base_build) {
|
||||
Remove-Item $path_base_build -Recurse -Verbose
|
||||
@@ -58,6 +62,18 @@ if ( Test-Path $path_test_build ) {
|
||||
if ( Test-Path $path_test_gen ) {
|
||||
Remove-Item $path_test_gen -Recurse -Verbose
|
||||
}
|
||||
if ( Test-Path $path_parser_bounds_build ) {
|
||||
Remove-Item $path_parser_bounds_build -Recurse -Verbose
|
||||
}
|
||||
if ( Test-Path $path_lexer_failures_build ) {
|
||||
Remove-Item $path_lexer_failures_build -Recurse -Verbose
|
||||
}
|
||||
if ( Test-Path $path_parse_body_messages_build ) {
|
||||
Remove-Item $path_parse_body_messages_build -Recurse -Verbose
|
||||
}
|
||||
if ( Test-Path $path_dogfood_parse_build ) {
|
||||
Remove-Item $path_dogfood_parse_build -Recurse -Verbose
|
||||
}
|
||||
if ( Test-Path $path_x64) {
|
||||
Remove-Item $path_x64 -Recurse -Verbose
|
||||
}
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
|
||||
import-module $target_arch
|
||||
|
||||
if ($IsWindows) {
|
||||
if ($is_windows) {
|
||||
# This HandmadeHero implementation is only designed for 64-bit systems
|
||||
& $devshell -arch amd64
|
||||
}
|
||||
@@ -27,6 +27,12 @@ function run-archiver
|
||||
{
|
||||
param( $archiver, $library, $lib_args )
|
||||
|
||||
if (-not (Get-Command $archiver -ErrorAction SilentlyContinue)) {
|
||||
Write-Host "FAILED: archiver launch $archiver" -ForegroundColor Red
|
||||
return $false
|
||||
}
|
||||
Write-Host ("ARCHIVER_ARGV: " + ($lib_args -join " "))
|
||||
|
||||
write-host "`Creating library $library"
|
||||
if ( $verbose ) {
|
||||
write-host "Lib manager config:"
|
||||
@@ -60,9 +66,15 @@ function run-compiler
|
||||
{
|
||||
param( $compiler, $unit, $compiler_args )
|
||||
|
||||
if (-not (Get-Command $compiler -ErrorAction SilentlyContinue)) {
|
||||
Write-Host "FAILED: compiler launch $compiler" -ForegroundColor Red
|
||||
return $false
|
||||
}
|
||||
|
||||
if ( $analysis ) {
|
||||
$compiler_args += $flag_syntax_only
|
||||
}
|
||||
Write-Host ("COMPILER_ARGV: " + ($compiler_args -join " "))
|
||||
|
||||
write-host "`Compiling $unit"
|
||||
if ( $verbose ) {
|
||||
@@ -97,6 +109,12 @@ function run-linker
|
||||
{
|
||||
param( $linker, $binary, $linker_args )
|
||||
|
||||
if (-not (Get-Command $linker -ErrorAction SilentlyContinue)) {
|
||||
Write-Host "FAILED: linker launch $linker" -ForegroundColor Red
|
||||
return $false
|
||||
}
|
||||
Write-Host ("LINKER_ARGV: " + ($linker_args -join " "))
|
||||
|
||||
write-host "`Linking $binary"
|
||||
if ( $verbose ) {
|
||||
write-host "Linker config:"
|
||||
@@ -131,7 +149,9 @@ if ( $vendor -match "clang" )
|
||||
# https://clang.llvm.org/docs/ClangCommandLineReference.html
|
||||
$flag_all_c = @('-x', 'c')
|
||||
$flag_c11 = '-std=c11'
|
||||
$flag_all_cpp = '-x c++'
|
||||
$flag_cpp17 = '-std=c++17'
|
||||
$flag_all_cpp = @('-x', 'c++')
|
||||
$flag_charset_utf8 = '-utf-8'
|
||||
$flag_compile = '-c'
|
||||
$flag_color_diagnostics = '-fcolor-diagnostics'
|
||||
$flag_no_color_diagnostics = '-fno-color-diagnostics'
|
||||
@@ -146,12 +166,12 @@ if ( $vendor -match "clang" )
|
||||
$flag_library = '-l'
|
||||
$flag_library_path = '-L'
|
||||
$flag_linker = '-Wl,'
|
||||
if ( $IsWindows ) {
|
||||
if ( $is_windows ) {
|
||||
$flag_link_dll = '/DLL'
|
||||
$flag_link_mapfile = '/MAP:'
|
||||
$flag_link_optimize_references = '/OPT:REF'
|
||||
}
|
||||
if ( $IsLinux ) {
|
||||
if ( $is_linux ) {
|
||||
$flag_link_mapfile = '--Map='
|
||||
$flag_link_optimize_references = '--gc-sections'
|
||||
}
|
||||
@@ -190,7 +210,7 @@ if ( $vendor -match "clang" )
|
||||
)
|
||||
|
||||
# https://learn.microsoft.com/en-us/cpp/c-runtime-library/crt-library-features?view=msvc-170
|
||||
if ( $IsWindows ) {
|
||||
if ( $is_windows ) {
|
||||
$libraries = @(
|
||||
'Kernel32' # For Windows API
|
||||
# 'msvcrt', # For the C Runtime (Dynamically Linked)
|
||||
@@ -370,7 +390,9 @@ if ( $vendor -match "msvc" )
|
||||
# https://learn.microsoft.com/en-us/cpp/build/reference/compiler-options-listed-by-category?view=msvc-170
|
||||
$flag_all_c = '/TC'
|
||||
$flag_c11 = '/std:c11'
|
||||
$flag_cpp17 = '/std:c++17'
|
||||
$flag_all_cpp = '/TP'
|
||||
$flag_charset_utf8 = '/utf-8'
|
||||
$flag_compile = '/c'
|
||||
$flag_debug = '/Zi'
|
||||
$flag_define = '/D'
|
||||
@@ -404,7 +426,7 @@ if ( $vendor -match "msvc" )
|
||||
$flag_optimize_intrinsics = '/Oi'
|
||||
$flag_optimized_debug_forceinline = '/d2Obforceinline'
|
||||
$flag_optimized_debug = '/Zo'
|
||||
$flag_
|
||||
# $flag_
|
||||
# $flag_out_name = '/OUT:'
|
||||
$flag_path_interm = '/Fo'
|
||||
$flag_path_debug = '/Fd'
|
||||
|
||||
@@ -0,0 +1,267 @@
|
||||
param(
|
||||
[Parameter(Mandatory = $true)][Alias('MirrorRoot')][string]$path_mirror,
|
||||
[ValidateSet(
|
||||
"measure",
|
||||
"positive",
|
||||
"negative-compile",
|
||||
"negative-link",
|
||||
"negative-launch",
|
||||
"negative-stale",
|
||||
"negative-stale-header",
|
||||
"negative-format",
|
||||
"negative-refactor",
|
||||
"negative-assert"
|
||||
)]
|
||||
[string]$mode = "positive",
|
||||
[Alias('SourceRoot')][string]$path_source_root = "C:\projects\gencpp",
|
||||
[Alias('ReuseMirror')][switch]$reuse_mirror
|
||||
)
|
||||
|
||||
$ErrorActionPreference = "Stop"
|
||||
$path_source = (Resolve-Path -LiteralPath $path_source_root).Path
|
||||
$path_mirror = [System.IO.Path]::GetFullPath($path_mirror)
|
||||
$path_verification_root = Join-Path $path_mirror 'test\verification'
|
||||
if ($path_mirror -eq $path_source) { throw "MirrorRoot must not be the project checkout" }
|
||||
$prefix_source = $path_source.TrimEnd('\') + '\'
|
||||
$prefix_mirror = $path_mirror.TrimEnd('\') + '\'
|
||||
if ($path_source.StartsWith($prefix_mirror, [System.StringComparison]::OrdinalIgnoreCase) -or
|
||||
$path_mirror.StartsWith($prefix_source, [System.StringComparison]::OrdinalIgnoreCase)) {
|
||||
throw "path_mirror and path_source_root must not overlap"
|
||||
}
|
||||
if ($reuse_mirror -and $mode -ne "positive") { throw "reuse_mirror is for the positive mode only" }
|
||||
if ($reuse_mirror -and -not (Test-Path -LiteralPath (Join-Path $path_mirror 'base\base.cpp'))) {
|
||||
throw "reuse_mirror needs an existing baseline mirror"
|
||||
}
|
||||
|
||||
function Copy-Snapshot([string]$path_destination)
|
||||
{
|
||||
if (Test-Path -LiteralPath $path_destination) { Remove-Item -LiteralPath $path_destination -Recurse -Force }
|
||||
New-Item -ItemType Directory -Path $path_destination | Out-Null
|
||||
& robocopy $path_source $path_destination /E /NFL /NDL /NJH /NJS /XD .git
|
||||
if ($LASTEXITCODE -ge 8) { throw "robocopy failed: $LASTEXITCODE" }
|
||||
$global:LASTEXITCODE = 0
|
||||
@(
|
||||
"gen_segmented\gen",
|
||||
"gen_segmented\build",
|
||||
"gen_singleheader\gen",
|
||||
"gen_singleheader\build",
|
||||
"gen_c_library\gen",
|
||||
"gen_c_library\build",
|
||||
"gen_unreal_engine\gen",
|
||||
"gen_unreal_engine\build",
|
||||
"test\c_library\build",
|
||||
"test\c_library\gen",
|
||||
"test\cpp_library\build",
|
||||
"test\cpp_library\gen",
|
||||
"base\build"
|
||||
) | ForEach-Object {
|
||||
$path_item = Join-Path $path_destination $_
|
||||
if (Test-Path -LiteralPath $path_item) { Remove-Item -LiteralPath $path_item -Recurse -Force }
|
||||
}
|
||||
}
|
||||
|
||||
function Copy-VerificationFixture([string]$name_fixture, [string]$path_destination) {
|
||||
$path_fixture = Join-Path $path_verification_root $name_fixture
|
||||
if (-not (Test-Path -LiteralPath $path_fixture -PathType Leaf)) {
|
||||
throw "Missing verification fixture: $path_fixture"
|
||||
}
|
||||
Copy-Item -LiteralPath $path_fixture -Destination $path_destination -Force
|
||||
}
|
||||
|
||||
function Invoke-Driver([string]$path_tree, [string[]]$list_targets) {
|
||||
$path_driver = Join-Path $path_tree "scripts\build.ci.ps1"
|
||||
$name_log = if ($reuse_mirror) { 'verify_driver.repeat.log' } else { 'verify_driver.log' }
|
||||
$path_log = Join-Path $path_tree $name_log
|
||||
$path_previous_root = $env:GENCPP_SOURCE_ROOT
|
||||
$env:GENCPP_SOURCE_ROOT = $path_tree
|
||||
$line_args = $list_targets -join ' '
|
||||
try {
|
||||
$text_output = & powershell.exe -NoProfile -Command "& '$path_driver' clang debug $line_args; exit `$LASTEXITCODE" *>&1
|
||||
$code_exit = $LASTEXITCODE
|
||||
}
|
||||
finally {
|
||||
$env:GENCPP_SOURCE_ROOT = $path_previous_root
|
||||
}
|
||||
$text_output | Tee-Object -FilePath $path_log | Out-Host
|
||||
$script:path_last_driver_log = $path_log
|
||||
$script:code_last_driver = $code_exit
|
||||
return $code_exit
|
||||
}
|
||||
|
||||
function Get-DriverLogText {
|
||||
if (-not $script:path_last_driver_log) { return "" }
|
||||
if (-not (Test-Path -LiteralPath $script:path_last_driver_log)) { return "" }
|
||||
return Get-Content -LiteralPath $script:path_last_driver_log -Raw
|
||||
}
|
||||
|
||||
function Assert-PositiveOutputs([string]$path_tree) {
|
||||
$list_outputs = @(
|
||||
'base\components\gen\ecodetypes.hpp',
|
||||
'base\components\gen\eoperator.hpp',
|
||||
'base\components\gen\especifier.hpp',
|
||||
'base\components\gen\etoktype.hpp',
|
||||
'base\components\gen\ast_inlines.hpp',
|
||||
'gen_segmented\gen\gen.hpp',
|
||||
'gen_segmented\gen\gen.cpp',
|
||||
'gen_segmented\gen\gen.dep.hpp',
|
||||
'gen_segmented\gen\gen.dep.cpp',
|
||||
'gen_segmented\gen\gen.builder.hpp',
|
||||
'gen_segmented\gen\gen.builder.cpp',
|
||||
'gen_segmented\gen\gen.scanner.hpp',
|
||||
'gen_segmented\gen\gen.scanner.cpp',
|
||||
'gen_singleheader\gen\gen.hpp',
|
||||
'gen_c_library\gen\gen.h',
|
||||
'gen_c_library\gen\gen.c',
|
||||
'gen_c_library\gen\gen.dep.h',
|
||||
'gen_c_library\gen\gen.dep.c',
|
||||
'gen_c_library\gen\gen_singleheader.h'
|
||||
)
|
||||
$list_hashes = foreach ($path_relative in $list_outputs) {
|
||||
$path_output = Join-Path $path_tree $path_relative
|
||||
if (-not (Test-Path -LiteralPath $path_output -PathType Leaf)) { throw "Missing output: $path_output" }
|
||||
if ((Get-Item -LiteralPath $path_output).Length -eq 0) { throw "Empty output: $path_output" }
|
||||
"{0} {1}" -f (Get-FileHash -LiteralPath $path_output -Algorithm SHA256).Hash, $path_relative
|
||||
}
|
||||
$text_log = (Get-DriverLogText).Replace('\\', '\')
|
||||
foreach ($path_relative in @('gen_singleheader\gen\gen.hpp', 'gen_c_library\gen\gen_singleheader.h')) {
|
||||
$path_header = Join-Path $path_tree $path_relative
|
||||
if ($text_log -notmatch [regex]::Escape($path_header)) { throw "Compiler trace missing $path_header" }
|
||||
}
|
||||
$name_hash_file = if ($reuse_mirror) { 'verify_outputs.repeat.sha256' } else { 'verify_outputs.sha256' }
|
||||
$list_hashes | Set-Content -LiteralPath (Join-Path $path_tree $name_hash_file)
|
||||
Write-Host "PASSED: outputs and consumer header traces ($name_hash_file)"
|
||||
}
|
||||
|
||||
$list_targets = @("base", "segmented", "singleheader", "c_lib", "test")
|
||||
if (-not $reuse_mirror) { Copy-Snapshot $path_mirror }
|
||||
|
||||
if ($mode -eq "measure" -or $mode -eq "positive") {
|
||||
$code_exit = Invoke-Driver $path_mirror $list_targets
|
||||
if ($mode -eq "positive" -and $code_exit -ne 0) { exit $code_exit }
|
||||
if ($mode -eq "positive") { Assert-PositiveOutputs $path_mirror }
|
||||
exit $code_exit
|
||||
}
|
||||
|
||||
if ($mode -eq "negative-compile") {
|
||||
Copy-VerificationFixture 'failure_compile.cpp' (Join-Path $path_mirror 'base\base.cpp')
|
||||
$code_exit = Invoke-Driver $path_mirror @("base")
|
||||
if ($code_exit -eq 0) { throw "negative-compile returned 0" }
|
||||
exit 0
|
||||
}
|
||||
|
||||
if ($mode -eq "negative-link") {
|
||||
Copy-VerificationFixture 'failure_link.cpp' (Join-Path $path_mirror 'base\base.cpp')
|
||||
$code_exit = Invoke-Driver $path_mirror @("base")
|
||||
$text_log = Get-DriverLogText
|
||||
if ($code_exit -eq 0 -or $text_log -notmatch "Linking failed") {
|
||||
throw "negative-link did not fail at the linker"
|
||||
}
|
||||
exit 0
|
||||
}
|
||||
|
||||
if ($mode -eq "negative-launch") {
|
||||
$path_toolchain = Join-Path $path_mirror "scripts\helpers\vendor_toolchain.ps1"
|
||||
$text_toolchain = Get-Content -LiteralPath $path_toolchain -Raw
|
||||
$text_patched = $text_toolchain.Replace(
|
||||
"`$linker = 'lld-link'",
|
||||
"`$linker = 'gencpp-missing-linker'"
|
||||
)
|
||||
if ($text_patched -eq $text_toolchain) { throw "negative-launch could not replace the linker path" }
|
||||
|
||||
Set-Content -LiteralPath $path_toolchain -Value $text_patched -NoNewline
|
||||
$code_exit = Invoke-Driver $path_mirror @("base")
|
||||
$text_log = Get-DriverLogText
|
||||
if ($code_exit -eq 0 -or $text_log -notmatch "FAILED: linker launch gencpp-missing-linker") {
|
||||
throw "negative-launch did not report a missing linker"
|
||||
}
|
||||
exit 0
|
||||
}
|
||||
|
||||
if ($mode -eq "negative-stale") {
|
||||
$path_stale_source = Join-Path $path_mirror "stale_marker.c"
|
||||
$path_stale_executable = Join-Path $path_mirror "stale_marker.exe"
|
||||
Copy-VerificationFixture 'stale_executable.c' $path_stale_source
|
||||
|
||||
& clang -o $path_stale_executable $path_stale_source
|
||||
if ($LASTEXITCODE -ne 0) { throw "failed to compile stale marker" }
|
||||
|
||||
$path_base_build = Join-Path $path_mirror "base\build"
|
||||
New-Item -ItemType Directory -Path $path_base_build -Force | Out-Null
|
||||
Copy-Item -LiteralPath $path_stale_executable -Destination (Join-Path $path_base_build "base.exe") -Force
|
||||
Copy-VerificationFixture 'failure_compile.cpp' (Join-Path $path_mirror 'base\base.cpp')
|
||||
|
||||
$code_exit = Invoke-Driver $path_mirror @("base")
|
||||
if ($code_exit -eq 0) { throw "negative-stale returned 0" }
|
||||
if ($code_exit -eq 73) { throw "negative-stale ran the stale executable" }
|
||||
exit 0
|
||||
}
|
||||
|
||||
if ($mode -eq "negative-stale-header") {
|
||||
$code_exit = Invoke-Driver $path_mirror @("base", "segmented", "singleheader", "c_lib")
|
||||
if ($code_exit -ne 0) { throw "negative-stale-header setup generation failed: $code_exit" }
|
||||
|
||||
Copy-Item -LiteralPath $script:path_last_driver_log -Destination (Join-Path $path_mirror 'verify_driver.setup.log')
|
||||
$path_header = Join-Path $path_mirror 'gen_c_library\gen\gen_singleheader.h'
|
||||
if (-not (Test-Path -LiteralPath $path_header)) { throw 'negative-stale-header missing setup header' }
|
||||
|
||||
Copy-VerificationFixture 'failure_compile.cpp' (Join-Path $path_mirror 'gen_c_library\c_library.cpp')
|
||||
$code_exit = Invoke-Driver $path_mirror @('c_lib', 'test')
|
||||
$text_log = Get-DriverLogText
|
||||
if ($code_exit -eq 0 -or $text_log -notmatch 'FAILED: c_lib compile/link') {
|
||||
throw 'negative-stale-header did not fail at c_lib'
|
||||
}
|
||||
if ($text_log -match 'Compiling .*test[.]c|PASSED: test-c11|PASSED: test-cpp') {
|
||||
throw 'negative-stale-header consumed a prior header'
|
||||
}
|
||||
exit 0
|
||||
}
|
||||
|
||||
if ($mode -eq "negative-format") {
|
||||
$path_fake_tools = Join-Path $path_mirror "fake-tools"
|
||||
New-Item -ItemType Directory -Path $path_fake_tools -Force | Out-Null
|
||||
Copy-VerificationFixture 'failure_format.cmd' (Join-Path $path_fake_tools 'clang-format.cmd')
|
||||
$path_saved = $env:PATH
|
||||
$env:PATH = "$path_fake_tools;$env:PATH"
|
||||
try {
|
||||
$code_exit = Invoke-Driver $path_mirror @("base")
|
||||
}
|
||||
finally {
|
||||
$env:PATH = $path_saved
|
||||
}
|
||||
$text_log = Get-DriverLogText
|
||||
if ($code_exit -eq 0) { throw "negative-format returned 0" }
|
||||
if ($text_log -notmatch "clang-format failed") { throw "negative-format log missing clang-format failed" }
|
||||
exit 0
|
||||
}
|
||||
|
||||
if ($mode -eq "negative-refactor") {
|
||||
$path_fake_source = Join-Path $path_mirror 'failing_refactor.c'
|
||||
$path_fake_executable = Join-Path $path_mirror 'scripts\helpers\refactor.exe'
|
||||
Copy-VerificationFixture 'failure_refactor.c' $path_fake_source
|
||||
& clang -o $path_fake_executable $path_fake_source
|
||||
if ($LASTEXITCODE -ne 0) { throw 'negative-refactor failed to compile the stub' }
|
||||
|
||||
$code_exit = Invoke-Driver $path_mirror @('c_lib')
|
||||
$text_log = Get-DriverLogText
|
||||
if ($code_exit -eq 0 -or $text_log -notmatch 'refactor failed') {
|
||||
throw 'negative-refactor did not propagate subprocess failure'
|
||||
}
|
||||
exit 0
|
||||
}
|
||||
|
||||
if ($mode -eq "negative-assert") {
|
||||
$path_header = Join-Path $path_mirror "gen_singleheader\gen\gen.hpp"
|
||||
if (-not (Test-Path -LiteralPath $path_header)) {
|
||||
$code_exit = Invoke-Driver $path_mirror $list_targets
|
||||
if ($code_exit -ne 0) { throw "negative-assert setup generation failed: $code_exit" }
|
||||
}
|
||||
|
||||
Copy-VerificationFixture 'failure_assert.cpp' (Join-Path $path_mirror 'test\cpp_library\test.cpp')
|
||||
$code_exit = Invoke-Driver $path_mirror @("test")
|
||||
$text_log = Get-DriverLogText
|
||||
if ($code_exit -eq 0) { throw "negative-assert returned 0" }
|
||||
if ($text_log -notmatch "FAIL forced assertion") { throw "negative-assert log missing forced assertion marker" }
|
||||
exit 0
|
||||
}
|
||||
|
||||
throw "unhandled mode $mode"
|
||||
+38
-2
@@ -1,3 +1,39 @@
|
||||
# Test
|
||||
# Baseline verification
|
||||
|
||||
The implementation here has been gutted and will be rewritten...
|
||||
The implementation smoke is `verify_baseline.ps1`. It is not a parser corpus.
|
||||
|
||||
From the project root, in a fresh PowerShell process:
|
||||
|
||||
```powershell
|
||||
.\scripts\verify_baseline.ps1 -Mode positive -MirrorRoot ..\gencpp-verify-positive
|
||||
.\scripts\verify_baseline.ps1 -Mode positive -MirrorRoot ..\gencpp-verify-positive -ReuseMirror
|
||||
```
|
||||
|
||||
The first command generates base component tables, segmented C++, single-header C++, and both C11 layouts.
|
||||
It compiles and runs the C++17 and C11 single-header host smokes. The second command reuses the same mirror.
|
||||
|
||||
The verification wrapper copies them into the disposable mirror; it does not embed C or C++ source text.
|
||||
|
||||
## Parser bounds probe
|
||||
|
||||
`test/parser_bounds/test.cpp` is a GEN_TIME program. It includes `base/gen.cpp`. It is not part of `verify_baseline.ps1`.
|
||||
|
||||
From the project root:
|
||||
|
||||
```powershell
|
||||
.\scripts\build.ps1 clang parser_bounds
|
||||
```
|
||||
|
||||
The script builds and runs the probe. A pass prints `parser bounds passed` and `PASSED: parser_bounds`.
|
||||
The probe covers helper positions, formatting skip at the slice end, empty and whitespace `parse_variable`, and two direct end-of-slice reads.
|
||||
It does not prove in-slice syntax errors return.
|
||||
|
||||
## Lexer failure probe
|
||||
|
||||
```powershell
|
||||
.\scripts\build.ps1 clang lexer_failures
|
||||
```
|
||||
|
||||
A pass prints `lexer failures passed` and `PASSED: lexer_failures`.
|
||||
The probe covers nine lexer failures, six successful sibling inputs, and a baseline variable after each failure.
|
||||
It does not prove in-slice parser errors return.
|
||||
+486
-23
@@ -1,36 +1,499 @@
|
||||
#if INTELLISENSE_DIRECTIVES
|
||||
#include "../../gen_c_library/gen/gen_singleheader.h"
|
||||
#endif
|
||||
|
||||
#define GEN_DONT_USE_FATAL
|
||||
#define GEN_IMPLEMENTATION
|
||||
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
|
||||
#include "gen_singleheader.h"
|
||||
|
||||
#define gen_iterator( Type, container, iter ) \
|
||||
gen_begin_ ## Type(container); \
|
||||
iter != gen_end_ ## Type(container); \
|
||||
code = gen_next_ ## Type(container, iter)
|
||||
gen_global gen_s32 g_failures = 0;
|
||||
|
||||
gen_internal void expect(int condition, gen_Str name) {
|
||||
if (condition == false) { gen_log_fmt("FAIL %S\n", name); ++ g_failures; }
|
||||
}
|
||||
|
||||
gen_internal void expect_fragments(gen_Str text, gen_Str label) {
|
||||
expect(text.Ptr != 0 && text.Len > 0, label);
|
||||
expect(gen_str_contains(text, gen_txt("baseline_message")), label);
|
||||
expect(gen_str_contains(text, gen_txt("char")), label);
|
||||
expect(gen_str_contains(text, gen_txt("const")), label);
|
||||
expect(gen_str_contains(text, gen_txt("*")), label);
|
||||
expect(gen_str_contains(text, gen_txt("GENCPP_BASELINE")), label);
|
||||
}
|
||||
|
||||
gen_internal void expect_variable(gen_CodeVar var, gen_Str label) {
|
||||
expect(var != 0, label); if (var == 0) return;
|
||||
expect(var->Type == CT_Variable, label);
|
||||
expect(gen_str_contains(var->Name, gen_txt("baseline_message")), label);
|
||||
expect(var->ValueType != 0, label);
|
||||
expect(var->Value != 0, label);
|
||||
if (var->Value != 0) {
|
||||
expect(gen_str_contains(var->Value->Content, gen_txt("GENCPP_BASELINE")), label);
|
||||
}
|
||||
}
|
||||
|
||||
gen_internal gen_Code_POD code_pod(gen_Code code) {
|
||||
gen_Code_POD result = { (gen_AST*)code };
|
||||
return result;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
gen_Context ctx = {0};
|
||||
gen_init(& ctx);
|
||||
gen_Context ctx = {0}; gen_init(&ctx);
|
||||
|
||||
gen_Builder src_hello = gen_builder_open("gen/hello.c");
|
||||
gen_CodeVar hello_var = gen_parse_variable(code(
|
||||
char const* hello_gencpp_str = "HELLO GENCPP C11 !";
|
||||
));
|
||||
gen_builder_print( & src_hello, hello_var );
|
||||
gen_builder_write(& src_hello);
|
||||
gen_CodeTypename type = gen_def_type(name(char), .specifiers = gen_def_specifiers(2, Spec_Const, Spec_Ptr) );
|
||||
gen_CodeVar upfront = gen_def_variable(type, name(baseline_message),
|
||||
.value = gen_untyped_str(code("\"GENCPP_BASELINE\""))
|
||||
);
|
||||
expect_variable(upfront, gen_txt("c11 upfront"));
|
||||
expect_fragments(gen_strbuilder_to_str(gen_code_to_strbuilder(upfront)), gen_txt("c11 upfront serialized"));
|
||||
|
||||
gen_CodeBody body = gen_parse_file("gen/hello.c");
|
||||
for (gen_Code code = gen_iterator(CodeBody, body, code)) switch (code->Type) {
|
||||
case CT_Variable:
|
||||
gen_CodeVar var = (gen_CodeVar) code;
|
||||
gen_log_fmt("%S", var->Value);
|
||||
break;
|
||||
gen_Code array_expr = gen_untyped_str(gen_txt("3"));
|
||||
gen_CodeSpecifiers type_specs = gen_def_specifier(Spec_Const);
|
||||
gen_CodeAttributes type_attrs = gen_def_attributes(gen_txt("[[maybe_unused]]"));
|
||||
gen_CodeTypename option_type = gen_def_type(name(Payload),
|
||||
.type_tag = Tag_Struct,
|
||||
.gen_array_expr = array_expr,
|
||||
.specifiers = type_specs,
|
||||
.attributes = type_attrs
|
||||
);
|
||||
expect(option_type != 0, gen_txt("c11 type options"));
|
||||
if (option_type != 0) {
|
||||
expect(option_type->TypeTag == Tag_Struct, gen_txt("c11 type tag"));
|
||||
expect((gen_Code)option_type->ArrExpr == array_expr, gen_txt("c11 type array expression"));
|
||||
expect((gen_Code)option_type->Specs == (gen_Code)type_specs, gen_txt("c11 type specifiers"));
|
||||
expect((gen_Code)option_type->Attributes == (gen_Code)type_attrs, gen_txt("c11 type attributes"));
|
||||
gen_Str type_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_type));
|
||||
expect(gen_str_contains(type_text, gen_txt("struct Payload")), gen_txt("c11 type tag serialization"));
|
||||
expect(gen_str_contains(type_text, gen_txt("const")), gen_txt("c11 type specifier serialization"));
|
||||
expect(gen_str_contains(type_text, gen_txt("[[maybe_unused]]")), gen_txt("c11 type attribute serialization"));
|
||||
}
|
||||
|
||||
gen_deinit(& ctx);
|
||||
gen_Code value = gen_untyped_str(code("\"UPFRONT_OPTION\""));
|
||||
gen_CodeSpecifiers variable_specs = gen_def_specifier(Spec_Static);
|
||||
gen_CodeAttributes variable_attrs = gen_def_attributes(gen_txt("[[maybe_unused]]"));
|
||||
gen_CodeVar option_variable = gen_def_variable(option_type, name(option_payload),
|
||||
.value = value,
|
||||
.specifiers = variable_specs,
|
||||
.attributes = variable_attrs,
|
||||
.mflags = ModuleFlag_Export
|
||||
);
|
||||
expect(option_variable != 0, gen_txt("c11 variable options"));
|
||||
if (option_variable != 0) {
|
||||
expect((gen_Code)option_variable->ValueType == (gen_Code)option_type, gen_txt("c11 variable type"));
|
||||
expect( option_variable->Value == value, gen_txt("c11 variable value"));
|
||||
expect((gen_Code)option_variable->Specs == (gen_Code)variable_specs, gen_txt("c11 variable specifiers"));
|
||||
expect((gen_Code)option_variable->Attributes == (gen_Code)variable_attrs, gen_txt("c11 variable attributes"));
|
||||
expect( option_variable->ModuleFlags == ModuleFlag_Export, gen_txt("c11 variable module flags"));
|
||||
gen_Str variable_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_variable));
|
||||
expect(gen_str_contains(variable_text, gen_txt("option_payload")), gen_txt("c11 variable name serialization"));
|
||||
expect(gen_str_contains(variable_text, gen_txt("UPFRONT_OPTION")), gen_txt("c11 variable value serialization"));
|
||||
expect(gen_str_contains(variable_text, gen_txt("static")), gen_txt("c11 variable specifier serialization"));
|
||||
expect(gen_str_contains(variable_text, gen_txt("[[maybe_unused]]")), gen_txt("c11 variable attribute serialization"));
|
||||
expect(gen_str_contains(variable_text, gen_txt("[ 3 ]")), gen_txt("c11 variable array serialization"));
|
||||
expect(gen_str_contains(variable_text, gen_txt("export")), gen_txt("c11 variable module flag serialization"));
|
||||
}
|
||||
|
||||
gen_CodeVar class_member = gen_def_variable(gen_def_type(name(u32)), name(class_option_member));
|
||||
gen_CodeBody class_body = gen_def_class_body(1, code_pod((gen_Code)class_member));
|
||||
gen_CodeTypename class_parent = gen_def_type(name(ClassOptionBase));
|
||||
gen_CodeTypename class_interfaces[] = { gen_def_type(name(IClassOption)) };
|
||||
gen_CodeAttributes class_attributes = gen_def_attributes(gen_txt("[[maybe_unused]]"));
|
||||
gen_CodeSpecifiers class_specifiers = gen_def_specifier(Spec_Final);
|
||||
gen_CodeClass option_class = gen_def_class(name(ClassOption),
|
||||
.body = class_body,
|
||||
.parent = class_parent,
|
||||
.parent_access = AccessSpec_Public,
|
||||
.attributes = class_attributes,
|
||||
.interfaces = class_interfaces,
|
||||
.num_interfaces = 1,
|
||||
.specifiers = class_specifiers,
|
||||
.mflags = ModuleFlag_Export
|
||||
);
|
||||
expect(option_class != 0, gen_txt("c11 class options"));
|
||||
if (option_class != 0) {
|
||||
expect((gen_Code)option_class->Body == (gen_Code)class_body, gen_txt("c11 class body"));
|
||||
expect((gen_Code)option_class->ParentType == (gen_Code)class_parent, gen_txt("c11 class parent"));
|
||||
expect( option_class->ParentAccess == AccessSpec_Public, gen_txt("c11 class parent access"));
|
||||
expect((gen_Code)option_class->Attributes == (gen_Code)class_attributes, gen_txt("c11 class attributes"));
|
||||
expect((gen_Code)option_class->ParentType->Next == (gen_Code)class_interfaces[0], gen_txt("c11 class interface"));
|
||||
expect((gen_Code)option_class->Specs == (gen_Code)class_specifiers, gen_txt("c11 class specifiers"));
|
||||
expect( option_class->ModuleFlags == ModuleFlag_Export, gen_txt("c11 class module flags"));
|
||||
gen_Str class_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_class));
|
||||
expect(gen_str_contains(class_text, gen_txt("ClassOption")), gen_txt("c11 class name serialization"));
|
||||
expect(gen_str_contains(class_text, gen_txt("ClassOptionBase")), gen_txt("c11 class parent serialization"));
|
||||
expect(gen_str_contains(class_text, gen_txt("IClassOption")), gen_txt("c11 class interface serialization"));
|
||||
expect(gen_str_contains(class_text, gen_txt("public")), gen_txt("c11 class access serialization"));
|
||||
expect(gen_str_contains(class_text, gen_txt("class_option_member")), gen_txt("c11 class body serialization"));
|
||||
expect(gen_str_contains(class_text, gen_txt("[[maybe_unused]]")), gen_txt("c11 class attribute serialization"));
|
||||
expect(gen_str_contains(class_text, gen_txt("final")), gen_txt("c11 class final specifier serialization"));
|
||||
expect(gen_str_contains(class_text, gen_txt("export")), gen_txt("c11 class module flag serialization"));
|
||||
}
|
||||
|
||||
gen_CodeVar struct_member = gen_def_variable(gen_def_type(name(u32)), name(struct_option_member));
|
||||
gen_CodeBody struct_body = gen_def_struct_body(1, code_pod((gen_Code)struct_member));
|
||||
gen_CodeTypename struct_parent = gen_def_type(name(StructOptionBase));
|
||||
gen_CodeTypename struct_interfaces[] = { gen_def_type(name(IStructOption)) };
|
||||
gen_CodeAttributes struct_attributes = gen_def_attributes(gen_txt("[[maybe_unused]]"));
|
||||
gen_CodeSpecifiers struct_specifiers = gen_def_specifier(Spec_Final);
|
||||
gen_CodeStruct option_struct = gen_def_struct(name(StructOption),
|
||||
.body = struct_body,
|
||||
.parent = struct_parent,
|
||||
.parent_access = AccessSpec_Public,
|
||||
.attributes = struct_attributes,
|
||||
.interfaces = struct_interfaces,
|
||||
.num_interfaces = 1,
|
||||
.specifiers = struct_specifiers,
|
||||
.mflags = ModuleFlag_Export
|
||||
);
|
||||
expect(option_struct != 0, gen_txt("c11 struct options"));
|
||||
if (option_struct != 0) {
|
||||
expect((gen_Code)option_struct->Body == (gen_Code)struct_body, gen_txt("c11 struct body"));
|
||||
expect((gen_Code)option_struct->ParentType == (gen_Code)struct_parent, gen_txt("c11 struct parent"));
|
||||
expect( option_struct->ParentAccess == AccessSpec_Public, gen_txt("c11 struct parent access"));
|
||||
expect((gen_Code)option_struct->Attributes == (gen_Code)struct_attributes, gen_txt("c11 struct attributes"));
|
||||
expect((gen_Code)option_struct->ParentType->Next == (gen_Code)struct_interfaces[0], gen_txt("c11 struct interface"));
|
||||
expect((gen_Code)option_struct->Specs == (gen_Code)struct_specifiers, gen_txt("c11 struct specifiers"));
|
||||
expect( option_struct->ModuleFlags == ModuleFlag_Export, gen_txt("c11 struct module flags"));
|
||||
gen_Str struct_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_struct));
|
||||
expect(gen_str_contains(struct_text, gen_txt("StructOption")), gen_txt("c11 struct name serialization"));
|
||||
expect(gen_str_contains(struct_text, gen_txt("StructOptionBase")), gen_txt("c11 struct parent serialization"));
|
||||
expect(gen_str_contains(struct_text, gen_txt("IStructOption")), gen_txt("c11 struct interface serialization"));
|
||||
expect(gen_str_contains(struct_text, gen_txt("public")), gen_txt("c11 struct access serialization"));
|
||||
expect(gen_str_contains(struct_text, gen_txt("struct_option_member")), gen_txt("c11 struct body serialization"));
|
||||
expect(gen_str_contains(struct_text, gen_txt("[[maybe_unused]]")), gen_txt("c11 struct attribute serialization"));
|
||||
expect(gen_str_contains(struct_text, gen_txt("final")), gen_txt("c11 struct final specifier serialization"));
|
||||
expect(gen_str_contains(struct_text, gen_txt("export")), gen_txt("c11 struct module flag serialization"));
|
||||
}
|
||||
|
||||
gen_CodeBody enum_body = gen_def_enum_body(1, code_pod((gen_Code)gen_untyped_str(gen_txt("Option_None"))));
|
||||
gen_CodeTypename enum_underlying = gen_def_type(name(u32));
|
||||
gen_CodeAttributes enum_attributes = gen_def_attributes(gen_txt("[[maybe_unused]]"));
|
||||
gen_CodeEnum option_enum = gen_def_enum(name(OptionEnum),
|
||||
.body = enum_body,
|
||||
.type = enum_underlying,
|
||||
.specifier = EnumDecl_Class,
|
||||
.attributes = enum_attributes,
|
||||
.mflags = ModuleFlag_Export
|
||||
);
|
||||
expect(option_enum != 0, gen_txt("c11 enum options"));
|
||||
if (option_enum != 0) {
|
||||
expect((gen_Code)option_enum->Body == (gen_Code)enum_body, gen_txt("c11 enum body"));
|
||||
expect((gen_Code)option_enum->UnderlyingType == (gen_Code)enum_underlying, gen_txt("c11 enum underlying type"));
|
||||
expect( option_enum->Type == CT_Enum_Class, gen_txt("c11 enum specifier"));
|
||||
expect((gen_Code)option_enum->Attributes == (gen_Code)enum_attributes, gen_txt("c11 enum attributes"));
|
||||
expect( option_enum->ModuleFlags == ModuleFlag_Export, gen_txt("c11 enum module flags"));
|
||||
gen_Str enum_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_enum));
|
||||
expect(gen_str_contains(enum_text, gen_txt("export")), gen_txt("c11 enum module flag serialization"));
|
||||
expect(gen_str_contains(enum_text, gen_txt("enum class")), gen_txt("c11 enum specifier serialization"));
|
||||
expect(gen_str_contains(enum_text, gen_txt("[[maybe_unused]]")), gen_txt("c11 enum attribute serialization"));
|
||||
expect(gen_str_contains(enum_text, gen_txt("u32")), gen_txt("c11 enum type serialization"));
|
||||
expect(gen_str_contains(enum_text, gen_txt("Option_None")), gen_txt("c11 enum body serialization"));
|
||||
}
|
||||
|
||||
gen_Code enum_macro = gen_untyped_str(gen_txt("ENUM_BASE_TYPE"));
|
||||
gen_CodeEnum macro_enum = gen_def_enum(name(MacroOptionEnum),
|
||||
.body = gen_def_enum_body(1, code_pod((gen_Code)gen_untyped_str(gen_txt("Macro_None")))),
|
||||
.type_macro = enum_macro
|
||||
);
|
||||
expect(macro_enum != 0, gen_txt("c11 enum type macro option"));
|
||||
if (macro_enum != 0) {
|
||||
expect(macro_enum->UnderlyingTypeMacro == enum_macro, gen_txt("c11 enum type macro"));
|
||||
expect(gen_str_contains(gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)macro_enum)), gen_txt("ENUM_BASE_TYPE")), gen_txt("c11 enum type macro serialization"));
|
||||
}
|
||||
|
||||
gen_CodeBody union_body = gen_def_union_body(1, code_pod((gen_Code)gen_untyped_str(gen_txt("u32 union_option_value;"))));
|
||||
gen_CodeAttributes union_attributes = gen_def_attributes(gen_txt("[[maybe_unused]]"));
|
||||
gen_CodeUnion option_union = gen_def_union(name(OptionUnion), union_body,
|
||||
.attributes = union_attributes,
|
||||
.mflags = ModuleFlag_Export
|
||||
);
|
||||
expect(option_union != 0, gen_txt("c11 union options"));
|
||||
if (option_union != 0) {
|
||||
expect((gen_Code)option_union->Body == (gen_Code)union_body, gen_txt("c11 union body"));
|
||||
expect((gen_Code)option_union->Attributes == (gen_Code)union_attributes, gen_txt("c11 union attributes"));
|
||||
expect( option_union->ModuleFlags == ModuleFlag_Export, gen_txt("c11 union module flags"));
|
||||
gen_Str union_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_union));
|
||||
expect(gen_str_contains(union_text, gen_txt("OptionUnion")), gen_txt("c11 union name serialization"));
|
||||
expect(gen_str_contains(union_text, gen_txt("union_option_value")), gen_txt("c11 union body serialization"));
|
||||
expect(gen_str_contains(union_text, gen_txt("[[maybe_unused]]")), gen_txt("c11 union attribute serialization"));
|
||||
expect(gen_str_contains(union_text, gen_txt("export")), gen_txt("c11 union module flag serialization"));
|
||||
}
|
||||
|
||||
gen_Code typedef_type = (gen_Code)gen_def_type(name(u32));
|
||||
gen_CodeAttributes typedef_attributes = gen_def_attributes(gen_txt("[[maybe_unused]]"));
|
||||
gen_CodeTypedef option_typedef = gen_def_typedef(name(OptionTypedef), typedef_type,
|
||||
.attributes = typedef_attributes,
|
||||
.mflags = ModuleFlag_Export
|
||||
);
|
||||
expect(option_typedef != 0, gen_txt("c11 typedef options"));
|
||||
if (option_typedef != 0) {
|
||||
expect( option_typedef->UnderlyingType == typedef_type, gen_txt("c11 typedef underlying type"));
|
||||
expect((gen_Code)option_typedef->Attributes == (gen_Code)typedef_attributes, gen_txt("c11 typedef attributes"));
|
||||
expect( option_typedef->ModuleFlags == ModuleFlag_Export, gen_txt("c11 typedef module flags"));
|
||||
gen_Str typedef_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_typedef));
|
||||
expect(gen_str_contains(typedef_text, gen_txt("OptionTypedef")), gen_txt("c11 typedef name serialization"));
|
||||
expect(gen_str_contains(typedef_text, gen_txt("u32")), gen_txt("c11 typedef type serialization"));
|
||||
expect(gen_str_contains(typedef_text, gen_txt("[[maybe_unused]]")), gen_txt("c11 typedef attribute serialization"));
|
||||
expect(gen_str_contains(typedef_text, gen_txt("export")), gen_txt("c11 typedef module flag serialization"));
|
||||
}
|
||||
|
||||
gen_CodeTypename using_type = gen_def_type(name(u32));
|
||||
gen_CodeAttributes using_attributes = gen_def_attributes(gen_txt("[[maybe_unused]]"));
|
||||
gen_CodeUsing option_using = gen_def_using(name(OptionUsing), using_type,
|
||||
.attributes = using_attributes,
|
||||
.mflags = ModuleFlag_Export
|
||||
);
|
||||
expect(option_using != 0, gen_txt("c11 using options"));
|
||||
if (option_using != 0) {
|
||||
expect((gen_Code)option_using->UnderlyingType == (gen_Code)using_type, gen_txt("c11 using underlying type"));
|
||||
expect((gen_Code)option_using->Attributes == (gen_Code)using_attributes, gen_txt("c11 using attributes"));
|
||||
expect( option_using->ModuleFlags == ModuleFlag_Export, gen_txt("c11 using module flags"));
|
||||
gen_Str using_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_using));
|
||||
expect(gen_str_contains(using_text, gen_txt("OptionUsing")), gen_txt("c11 using name serialization"));
|
||||
expect(gen_str_contains(using_text, gen_txt("[[maybe_unused]]")), gen_txt("c11 using attribute serialization"));
|
||||
expect(gen_str_contains(using_text, gen_txt("export")), gen_txt("c11 using module flag serialization"));
|
||||
}
|
||||
|
||||
gen_CodeParams template_params = gen_def_param(gen_def_type(name(class)), name(T));
|
||||
gen_CodeTemplate option_template = gen_def_template(template_params, (gen_Code)option_struct, .mflags = ModuleFlag_Export);
|
||||
expect(option_template != 0, gen_txt("c11 template options"));
|
||||
if (option_template != 0) {
|
||||
expect((gen_Code)option_template->Params == (gen_Code)template_params, gen_txt("c11 template parameters"));
|
||||
expect( option_template->Declaration == (gen_Code)option_struct, gen_txt("c11 template declaration"));
|
||||
expect( option_template->ModuleFlags == ModuleFlag_Export, gen_txt("c11 template module flags"));
|
||||
gen_Str template_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_template));
|
||||
expect(gen_str_contains(template_text, gen_txt("export")), gen_txt("c11 template module flag serialization"));
|
||||
expect(gen_str_contains(template_text, gen_txt("template")), gen_txt("c11 template serialization"));
|
||||
expect(gen_str_contains(template_text, gen_txt("StructOption")), gen_txt("c11 template declaration serialization"));
|
||||
}
|
||||
|
||||
gen_Macro source_macro = { gen_txt("OptionParamSource"), MT_Expression, MF_Functional }; gen_register_macro(source_macro);
|
||||
gen_CodeDefine parsed_macro_source = gen_parse_define(gen_txt("#define OptionParamSource(param) param\n"));
|
||||
expect(parsed_macro_source != 0, gen_txt("c11 define parameter source"));
|
||||
gen_MacroFlags define_flags = MF_Functional | MF_Allow_As_Identifier;
|
||||
gen_CodeDefine option_define = gen_def_define(name(OptionMacro), MT_Expression,
|
||||
.params = parsed_macro_source->Params,
|
||||
.content = gen_txt("param + 1"),
|
||||
.flags = define_flags
|
||||
);
|
||||
expect(option_define != 0, gen_txt("c11 define options"));
|
||||
if (option_define != 0) {
|
||||
expect(option_define->Params == parsed_macro_source->Params, gen_txt("c11 define parameters"));
|
||||
expect(gen_str_contains(option_define->Body->Content, gen_txt("param + 1")), gen_txt("c11 define content"));
|
||||
gen_Macro* option_macro = lookup_macro(name(OptionMacro));
|
||||
expect(option_macro != 0, gen_txt("c11 define registration"));
|
||||
if (option_macro != 0) expect(option_macro->Flags == define_flags, gen_txt("c11 define flags"));
|
||||
gen_Str define_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_define));
|
||||
expect(gen_str_contains(define_text, gen_txt("OptionMacro")), gen_txt("c11 define name serialization"));
|
||||
expect(gen_str_contains(define_text, gen_txt("OptionMacro( param)")), gen_txt("c11 define parameters serialization"));
|
||||
expect(gen_str_contains(define_text, gen_txt("param + 1")), gen_txt("c11 define content serialization"));
|
||||
}
|
||||
|
||||
gen_CodeDefine no_register_define = gen_def_define(name(OptionMacroNoRegister), MT_Expression,
|
||||
.dont_register_to_preprocess_macros = true
|
||||
);
|
||||
expect(no_register_define != 0, gen_txt("c11 define registration suppression"));
|
||||
expect(lookup_macro(name(OptionMacroNoRegister)) == 0, gen_txt("c11 define suppression flag"));
|
||||
|
||||
gen_CodeInclude local_include = gen_def_include(gen_txt("option_local.h"));
|
||||
expect(local_include != 0, gen_txt("c11 local include option"));
|
||||
if (local_include != 0) {
|
||||
expect(gen_str_contains(local_include->Content, gen_txt("\"option_local.h\"")), gen_txt("c11 quoted include"));
|
||||
}
|
||||
|
||||
gen_CodeInclude foreign_include = gen_def_include(gen_txt("option_system.h"), .foreign = true);
|
||||
expect(foreign_include != 0, gen_txt("c11 foreign include option"));
|
||||
if (foreign_include != 0) {
|
||||
expect(gen_str_contains(foreign_include->Content, gen_txt("<option_system.h>")), gen_txt("c11 foreign include path"));
|
||||
gen_Str include_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)foreign_include));
|
||||
expect(gen_str_contains(include_text, gen_txt("#include <option_system.h>")), gen_txt("c11 foreign include directive serialization"));
|
||||
}
|
||||
|
||||
gen_CodeModule option_module = gen_def_module(name(OptionModule), .mflags = ModuleFlag_Export);
|
||||
expect(option_module != 0, gen_txt("c11 module options"));
|
||||
if (option_module != 0) {
|
||||
expect(option_module->ModuleFlags == ModuleFlag_Export, gen_txt("c11 module flags"));
|
||||
expect(gen_str_contains(gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_module)), gen_txt("export")), gen_txt("c11 module serialization"));
|
||||
}
|
||||
|
||||
gen_CodeVar namespace_member = gen_def_variable(gen_def_type(name(u32)), name(namespace_option_value));
|
||||
gen_CodeBody namespace_body = gen_def_namespace_body(1, code_pod((gen_Code)namespace_member));
|
||||
gen_CodeNS option_namespace = gen_def_namespace(name(OptionNamespace), namespace_body, .mflags = ModuleFlag_Export);
|
||||
expect(option_namespace != 0, gen_txt("c11 namespace options"));
|
||||
if (option_namespace != 0) {
|
||||
expect((gen_Code)option_namespace->Body == (gen_Code)namespace_body, gen_txt("c11 namespace body"));
|
||||
expect( option_namespace->ModuleFlags == ModuleFlag_Export, gen_txt("c11 namespace flags"));
|
||||
gen_Str namespace_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_namespace));
|
||||
expect(gen_str_contains(namespace_text, gen_txt("OptionNamespace")), gen_txt("c11 namespace name serialization"));
|
||||
expect(gen_str_contains(namespace_text, gen_txt("namespace_option_value")), gen_txt("c11 namespace body serialization"));
|
||||
expect(gen_str_contains(namespace_text, gen_txt("export")), gen_txt("c11 namespace serialization"));
|
||||
}
|
||||
|
||||
gen_Code parameter_value = gen_untyped_str(code(7));
|
||||
gen_CodeParams option_parameter = gen_def_param(gen_def_type(name(u32)), name(option_parameter_value), .value = parameter_value);
|
||||
expect(option_parameter != 0, gen_txt("c11 parameter options"));
|
||||
if (option_parameter != 0) {
|
||||
expect(option_parameter->Value == parameter_value, gen_txt("c11 parameter value"));
|
||||
gen_Str parameter_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_parameter));
|
||||
expect(gen_str_contains(parameter_text, gen_txt("= 7")), gen_txt("c11 parameter value serialization"));
|
||||
}
|
||||
|
||||
gen_CodeParams function_params = gen_def_param(gen_def_type(name(u32)), name(function_option_arg));
|
||||
gen_CodeTypename function_return = gen_def_type(name(FunctionOptionReturn));
|
||||
gen_CodeBody function_body = gen_def_function_body(1, code_pod((gen_Code)gen_untyped_str(gen_txt("return function_option_arg;"))));
|
||||
gen_CodeAttributes function_attributes = gen_def_attributes(gen_txt("[[maybe_unused]]"));
|
||||
gen_CodeSpecifiers function_specs = gen_def_specifier(Spec_Inline);
|
||||
gen_CodeFn option_function = gen_def_function(name(OptionFunction),
|
||||
.params = function_params,
|
||||
.ret_type = function_return,
|
||||
.body = function_body,
|
||||
.specs = function_specs,
|
||||
.attrs = function_attributes,
|
||||
.mflags = ModuleFlag_Export
|
||||
);
|
||||
expect(option_function != 0, gen_txt("c11 function options"));
|
||||
if (option_function != 0) {
|
||||
expect((gen_Code)option_function->Params == (gen_Code)function_params, gen_txt("c11 function parameters"));
|
||||
expect((gen_Code)option_function->ReturnType == (gen_Code)function_return, gen_txt("c11 function return type"));
|
||||
expect((gen_Code)option_function->Body == (gen_Code)function_body, gen_txt("c11 function body"));
|
||||
expect((gen_Code)option_function->Specs == (gen_Code)function_specs, gen_txt("c11 function specifiers"));
|
||||
expect((gen_Code)option_function->Attributes == (gen_Code)function_attributes, gen_txt("c11 function attributes"));
|
||||
expect( option_function->ModuleFlags == ModuleFlag_Export, gen_txt("c11 function module flags"));
|
||||
gen_Str function_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_function));
|
||||
expect(gen_str_contains(function_text, gen_txt("OptionFunction")), gen_txt("c11 function name serialization"));
|
||||
expect(gen_str_contains(function_text, gen_txt("FunctionOptionReturn OptionFunction(")), gen_txt("c11 function return type serialization"));
|
||||
expect(gen_str_contains(function_text, gen_txt("function_option_arg")), gen_txt("c11 function parameters serialization"));
|
||||
expect(gen_str_contains(function_text, gen_txt("return function_option_arg")), gen_txt("c11 function body serialization"));
|
||||
expect(gen_str_contains(function_text, gen_txt("inline")), gen_txt("c11 function specifier serialization"));
|
||||
expect(gen_str_contains(function_text, gen_txt("[[maybe_unused]]")), gen_txt("c11 function attribute serialization"));
|
||||
expect(gen_str_contains(function_text, gen_txt("export")), gen_txt("c11 function module flag serialization"));
|
||||
}
|
||||
|
||||
gen_CodeParams constructor_params = gen_def_param(gen_def_type(name(u32)), name(constructor_option_arg));
|
||||
gen_Code initializer_list = gen_untyped_str(gen_txt("option_member( 0 )"));
|
||||
gen_CodeBody constructor_body = gen_def_function_body(1, code_pod((gen_Code)gen_untyped_str(gen_txt("option_member = constructor_option_arg;"))));
|
||||
gen_CodeConstructor option_constructor = gen_def_constructor(
|
||||
.params = constructor_params,
|
||||
.initializer_list = initializer_list,
|
||||
.body = (gen_Code)constructor_body
|
||||
);
|
||||
expect(option_constructor != 0, gen_txt("c11 constructor options"));
|
||||
if (option_constructor != 0) {
|
||||
expect((gen_Code)option_constructor->Params == (gen_Code)constructor_params, gen_txt("c11 constructor parameters"));
|
||||
expect( option_constructor->InitializerList == initializer_list, gen_txt("c11 constructor initializer list"));
|
||||
expect( option_constructor->Body == (gen_Code)constructor_body, gen_txt("c11 constructor body"));
|
||||
}
|
||||
|
||||
gen_Code_POD constructor_pod = code_pod((gen_Code)option_constructor);
|
||||
gen_CodeBody constructor_class_body = gen_def_class_body(1, constructor_pod);
|
||||
gen_CodeClass constructor_class = gen_def_class(name(ConstructorOptions), .body = constructor_class_body);
|
||||
expect(constructor_class != 0, gen_txt("c11 constructor serialization parent"));
|
||||
if (constructor_class != 0) {
|
||||
gen_Str constructor_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)constructor_class));
|
||||
expect(gen_str_contains(constructor_text, gen_txt("ConstructorOptions(")), gen_txt("c11 constructor name serialization"));
|
||||
expect(gen_str_contains(constructor_text, gen_txt("u32 constructor_option_arg")), gen_txt("c11 constructor parameter serialization"));
|
||||
expect(gen_str_contains(constructor_text, gen_txt("option_member( 0 )")), gen_txt("c11 constructor initializer serialization"));
|
||||
expect(gen_str_contains(constructor_text, gen_txt("constructor_option_arg")), gen_txt("c11 constructor body serialization"));
|
||||
}
|
||||
|
||||
gen_Code destructor_body = gen_untyped_str(gen_txt("release_option_resource();"));
|
||||
gen_CodeSpecifiers destructor_specs = gen_def_specifier(Spec_Virtual);
|
||||
gen_CodeDestructor option_destructor = gen_def_destructor(
|
||||
.body = destructor_body,
|
||||
.specifiers = destructor_specs
|
||||
);
|
||||
expect(option_destructor != 0, gen_txt("c11 destructor options"));
|
||||
if (option_destructor != 0) {
|
||||
expect(option_destructor->Body == destructor_body, gen_txt("c11 destructor body"));
|
||||
expect((gen_Code)option_destructor->Specs == (gen_Code)destructor_specs, gen_txt("c11 destructor specifiers"));
|
||||
gen_Code_POD destructor_pod = code_pod((gen_Code)option_destructor);
|
||||
gen_CodeBody destructor_class_body = gen_def_class_body(1, destructor_pod);
|
||||
gen_CodeClass destructor_class = gen_def_class(name(DestructorOptions), .body = destructor_class_body);
|
||||
expect(destructor_class != 0, gen_txt("c11 destructor serialization parent"));
|
||||
if (destructor_class != 0) {
|
||||
gen_Str destructor_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)destructor_class));
|
||||
if (gen_str_contains(destructor_text, gen_txt("virtual ~DestructorOptions()")) == false) gen_log_fmt("%S\n", destructor_text);
|
||||
expect(gen_str_contains(destructor_text, gen_txt("virtual ~DestructorOptions()")), gen_txt("c11 destructor signature serialization"));
|
||||
expect(gen_str_contains(destructor_text, gen_txt("release_option_resource();")), gen_txt("c11 destructor body serialization"));
|
||||
}
|
||||
}
|
||||
|
||||
gen_CodeTypename operator_type = gen_def_type(name(OperatorOptionType));
|
||||
gen_CodeTypename operator_return = gen_def_type(name(OperatorOptionReturn));
|
||||
gen_CodeParams operator_lhs = gen_def_param(operator_type, name(operator_option_lhs));
|
||||
gen_CodeParams operator_rhs = gen_def_param(operator_type, name(operator_option_rhs));
|
||||
gen_CodeParams operator_params = gen_def_params(2, code_pod((gen_Code)operator_lhs), code_pod((gen_Code)operator_rhs));
|
||||
gen_CodeBody operator_body = gen_def_function_body(1, code_pod((gen_Code)gen_untyped_str(gen_txt("return operator_option_lhs;"))));
|
||||
gen_CodeSpecifiers operator_specs = gen_def_specifier(Spec_Inline);
|
||||
gen_CodeAttributes operator_attributes = gen_def_attributes(gen_txt("[[maybe_unused]]"));
|
||||
gen_CodeOperator option_operator = gen_def_operator(Op_Add, gen_txt(""),
|
||||
.params = operator_params,
|
||||
.ret_type = operator_return,
|
||||
.body = operator_body,
|
||||
.specifiers = operator_specs,
|
||||
.attributes = operator_attributes,
|
||||
.mflags = ModuleFlag_Export
|
||||
);
|
||||
expect(option_operator != 0, gen_txt("c11 operator options"));
|
||||
if (option_operator != 0) {
|
||||
expect((gen_Code)option_operator->Params == (gen_Code)operator_params, gen_txt("c11 operator parameters"));
|
||||
expect((gen_Code)option_operator->ReturnType == (gen_Code)operator_return, gen_txt("c11 operator return type"));
|
||||
expect((gen_Code)option_operator->Body == (gen_Code)operator_body, gen_txt("c11 operator body"));
|
||||
expect((gen_Code)option_operator->Specs == (gen_Code)operator_specs, gen_txt("c11 operator specifiers"));
|
||||
expect((gen_Code)option_operator->Attributes == (gen_Code)operator_attributes, gen_txt("c11 operator attributes"));
|
||||
expect( option_operator->ModuleFlags == ModuleFlag_Export, gen_txt("c11 operator module flags"));
|
||||
gen_Str operator_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_operator));
|
||||
expect(gen_str_contains(operator_text, gen_txt("OperatorOptionReturn")), gen_txt("c11 operator return type serialization"));
|
||||
expect(gen_str_contains(operator_text, gen_txt("operator +")), gen_txt("c11 operator name serialization"));
|
||||
expect(gen_str_contains(operator_text, gen_txt("operator_option_lhs")), gen_txt("c11 operator parameters serialization"));
|
||||
expect(gen_str_contains(operator_text, gen_txt("operator_option_rhs")), gen_txt("c11 operator second parameter serialization"));
|
||||
expect(gen_str_contains(operator_text, gen_txt("return operator_option_lhs")), gen_txt("c11 operator body serialization"));
|
||||
expect(gen_str_contains(operator_text, gen_txt("inline")), gen_txt("c11 operator specifier serialization"));
|
||||
expect(gen_str_contains(operator_text, gen_txt("[[maybe_unused]]")), gen_txt("c11 operator attribute serialization"));
|
||||
expect(gen_str_contains(operator_text, gen_txt("export")), gen_txt("c11 operator module flag serialization"));
|
||||
if (gen_str_starts_with(operator_text, gen_txt("export [[maybe_unused]] inline\nOperatorOptionReturn")) == false) gen_log_fmt("%S\n", operator_text);
|
||||
expect(gen_str_starts_with(operator_text, gen_txt("export [[maybe_unused]] inline\nOperatorOptionReturn")), gen_txt("c11 operator one-attribute prefix serialization"));
|
||||
}
|
||||
|
||||
gen_CodeTypename cast_type = gen_def_type(name(s32));
|
||||
gen_CodeBody cast_body = gen_def_function_body(1, code_pod((gen_Code)gen_untyped_str(gen_txt("return 0;"))));
|
||||
gen_CodeSpecifiers cast_specs = gen_def_specifier(Spec_Const);
|
||||
gen_CodeOpCast option_cast = gen_def_operator_cast(cast_type,
|
||||
.body = cast_body,
|
||||
.specs = cast_specs
|
||||
);
|
||||
expect(option_cast != 0, gen_txt("c11 operator cast options"));
|
||||
if (option_cast != 0) {
|
||||
expect((gen_Code)option_cast->ValueType == (gen_Code)cast_type, gen_txt("c11 operator cast type"));
|
||||
expect((gen_Code)option_cast->Body == (gen_Code)cast_body, gen_txt("c11 operator cast body"));
|
||||
expect((gen_Code)option_cast->Specs == (gen_Code)cast_specs, gen_txt("c11 operator cast specifiers"));
|
||||
gen_Str cast_text = gen_strbuilder_to_str(gen_code_to_strbuilder((gen_Code)option_cast));
|
||||
expect(gen_str_contains(cast_text, gen_txt("operator s32")), gen_txt("c11 operator cast serialization"));
|
||||
expect(gen_str_contains(cast_text, gen_txt("const")), gen_txt("c11 operator cast specifier serialization"));
|
||||
expect(gen_str_contains(cast_text, gen_txt("return 0")), gen_txt("c11 operator cast body serialization"));
|
||||
}
|
||||
|
||||
gen_Code untyped = gen_code_str(char const* baseline_message = "GENCPP_BASELINE"; );
|
||||
expect(untyped != 0, gen_txt("c11 untyped"));
|
||||
|
||||
gen_Str untyped_text = gen_strbuilder_to_str(gen_code_to_strbuilder(untyped));
|
||||
expect_fragments(untyped_text, gen_txt("c11 untyped content"));
|
||||
expect_variable(gen_parse_variable(untyped_text), gen_txt("c11 untyped reparsed"));
|
||||
|
||||
gen_CodeVar parsed = gen_parse_variable(code(char const* baseline_message = "GENCPP_BASELINE"; ));
|
||||
expect_variable(parsed, gen_txt("c11 parsed"));
|
||||
expect_fragments(gen_strbuilder_to_str(gen_code_to_strbuilder(parsed)), gen_txt("c11 parsed serialized"));
|
||||
|
||||
#if ! GEN_BUILD_DEBUG
|
||||
gen_CodeVar wrong_array_value = gen_def_variable(gen_def_type(name(u32)), name(invalid_array_expr));
|
||||
gen_CodeTypename invalid_array_type = gen_def_type(name(InvalidArrayOption), .gen_array_expr = (gen_Code)wrong_array_value);
|
||||
expect((gen_Code)invalid_array_type == gen_Code_Invalid, gen_txt("c11 wrong type invalid code"));
|
||||
|
||||
gen_CodeBody missing_union_body = 0;
|
||||
gen_CodeUnion missing_union = gen_def_union(name(MissingUnionBody), missing_union_body);
|
||||
expect((gen_Code)missing_union == gen_Code_Invalid, gen_txt("c11 missing body invalid code"));
|
||||
#endif
|
||||
|
||||
gen_deinit(&ctx);
|
||||
if (g_failures != 0) { gen_log_fmt("c11 baseline smoke failed: %d\n", g_failures); return 1; }
|
||||
gen_log_fmt("c11 baseline smoke passed\n");
|
||||
return 0;
|
||||
}
|
||||
+465
-15
@@ -1,29 +1,479 @@
|
||||
#define GEN_DONT_USE_FATAL
|
||||
#define GEN_IMPLEMENTATION
|
||||
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
|
||||
#define GEN_ENFORCE_STRONG_CODE_TYPES
|
||||
#include "gen.hpp"
|
||||
|
||||
global int g_failures = 0;
|
||||
|
||||
internal void expect(int condition, gen::Str name) {
|
||||
if (condition == false) { gen::log_fmt("FAIL %S\n", name); ++ g_failures; }
|
||||
}
|
||||
|
||||
internal void expect_fragments(gen::Str text, gen::Str label) {
|
||||
expect(text.Ptr != nullptr && text.Len > 0, label);
|
||||
expect(gen::str_contains(text, txt("baseline_message")), label);
|
||||
expect(gen::str_contains(text, txt("char")), label);
|
||||
expect(gen::str_contains(text, txt("const")), label);
|
||||
expect(gen::str_contains(text, txt("*")), label);
|
||||
expect(gen::str_contains(text, txt("GENCPP_BASELINE")), label);
|
||||
}
|
||||
|
||||
internal void expect_variable(gen::CodeVar var, gen::Str label) {
|
||||
expect(var.ast != nullptr, label); if (var.ast == nullptr) return;
|
||||
expect(var->Type == gen::CT_Variable, label);
|
||||
expect(gen::str_contains(var->Name, txt("baseline_message")), label);
|
||||
expect(var->ValueType.ast != nullptr, label);
|
||||
expect(var->Value.ast != nullptr, label);
|
||||
if (var->Value.ast != nullptr) {
|
||||
expect(gen::str_contains(var->Value->Content, txt("GENCPP_BASELINE")), label);
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
using namespace gen;
|
||||
Context ctx = {};
|
||||
gen::init( & ctx);
|
||||
Context ctx = {}; init(&ctx);
|
||||
|
||||
Builder src_hello = builder_open("gen/hello.cpp");
|
||||
CodeVar hello_var = parse_variable( code(
|
||||
constexpr char const* hello_gencpp_str = "HELLO GENCPP !";
|
||||
));
|
||||
src_hello.print(hello_var);
|
||||
src_hello.write();
|
||||
Opts_def_type type_opts = {};
|
||||
type_opts.specifiers = def_specifiers(args(Spec_Const, Spec_Ptr));
|
||||
CodeTypename type = def_type(name(char), type_opts);
|
||||
Opts_def_variable opts = {}; opts.value = untyped_str(code("\"GENCPP_BASELINE\""));
|
||||
CodeVar upfront = def_variable(type, name(baseline_message), opts);
|
||||
expect_variable(upfront, txt("cpp upfront"));
|
||||
expect_fragments(strbuilder_to_str(code_to_strbuilder((Code)upfront)), txt("cpp upfront serialized"));
|
||||
|
||||
CodeBody body = parse_file("gen/hello.cpp");
|
||||
for ( Code code : body ) switch (code->Type) {
|
||||
case CT_Variable:
|
||||
CodeVar var = cast(CodeVar, code);
|
||||
log_fmt("%S", var->Value);
|
||||
break;
|
||||
Opts_def_type type_options = {};
|
||||
Code array_expr = untyped_str(txt("3"));
|
||||
CodeSpecifiers type_specs = def_specifier(Spec_Const);
|
||||
CodeAttributes type_attrs = def_attributes(txt("[[maybe_unused]]"));
|
||||
type_options.type_tag = Tag_Struct;
|
||||
type_options.array_expr = array_expr;
|
||||
type_options.specifiers = type_specs;
|
||||
type_options.attributes = type_attrs;
|
||||
CodeTypename option_type = def_type(name(Payload), type_options);
|
||||
expect(option_type.ast != nullptr, txt("cpp type options"));
|
||||
if (option_type.ast != nullptr) {
|
||||
expect(option_type->TypeTag == Tag_Struct, txt("cpp type tag"));
|
||||
expect(option_type->ArrExpr.ast == array_expr.ast, txt("cpp type array expression"));
|
||||
expect(option_type->Specs.ast == type_specs.ast, txt("cpp type specifiers"));
|
||||
expect(option_type->Attributes.ast == type_attrs.ast, txt("cpp type attributes"));
|
||||
Str type_text = strbuilder_to_str(code_to_strbuilder((Code)option_type));
|
||||
expect(str_contains(type_text, txt("struct Payload")), txt("cpp type tag serialization"));
|
||||
expect(str_contains(type_text, txt("const")), txt("cpp type specifier serialization"));
|
||||
expect(str_contains(type_text, txt("[[maybe_unused]]")), txt("cpp type attribute serialization"));
|
||||
}
|
||||
|
||||
gen::deinit(& ctx);
|
||||
Opts_def_variable variable_options = {};
|
||||
Code value = untyped_str(code("\"UPFRONT_OPTION\""));
|
||||
CodeSpecifiers variable_specs = def_specifier(Spec_Static);
|
||||
CodeAttributes variable_attrs = def_attributes(txt("[[maybe_unused]]"));
|
||||
variable_options.value = value;
|
||||
variable_options.specifiers = variable_specs;
|
||||
variable_options.attributes = variable_attrs;
|
||||
variable_options.mflags = ModuleFlag_Export;
|
||||
CodeVar option_variable = def_variable(option_type, name(option_payload), variable_options);
|
||||
expect(option_variable.ast != nullptr, txt("cpp variable options"));
|
||||
if (option_variable.ast != nullptr) {
|
||||
expect(option_variable->ValueType.ast == option_type.ast, txt("cpp variable type"));
|
||||
expect(option_variable->Value.ast == value.ast, txt("cpp variable value"));
|
||||
expect(option_variable->Specs.ast == variable_specs.ast, txt("cpp variable specifiers"));
|
||||
expect(option_variable->Attributes.ast == variable_attrs.ast, txt("cpp variable attributes"));
|
||||
expect(option_variable->ModuleFlags == ModuleFlag_Export, txt("cpp variable module flags"));
|
||||
Str variable_text = strbuilder_to_str(code_to_strbuilder((Code)option_variable));
|
||||
expect(str_contains(variable_text, txt("option_payload")), txt("cpp variable name serialization"));
|
||||
expect(str_contains(variable_text, txt("UPFRONT_OPTION")), txt("cpp variable value serialization"));
|
||||
expect(str_contains(variable_text, txt("static")), txt("cpp variable specifier serialization"));
|
||||
expect(str_contains(variable_text, txt("[[maybe_unused]]")), txt("cpp variable attribute serialization"));
|
||||
expect(str_contains(variable_text, txt("[ 3 ]")), txt("cpp variable array serialization"));
|
||||
expect(str_contains(variable_text, txt("export")), txt("cpp variable module flag serialization"));
|
||||
}
|
||||
|
||||
CodeVar class_member = def_variable(def_type(name(u32)), name(class_option_member));
|
||||
CodeBody class_body = def_class_body(args(class_member));
|
||||
CodeTypename class_parent = def_type(name(ClassOptionBase));
|
||||
CodeTypename class_interfaces[] = { def_type(name(IClassOption)) };
|
||||
Opts_def_struct class_options = {};
|
||||
class_options.body = class_body;
|
||||
class_options.parent = class_parent;
|
||||
class_options.parent_access = AccessSpec_Public;
|
||||
class_options.attributes = def_attributes(txt("[[maybe_unused]]"));
|
||||
class_options.interfaces = class_interfaces;
|
||||
class_options.num_interfaces = 1;
|
||||
class_options.specifiers = def_specifier(Spec_Final);
|
||||
class_options.mflags = ModuleFlag_Export;
|
||||
CodeClass option_class = def_class(name(ClassOption), class_options);
|
||||
expect(option_class.ast != nullptr, txt("cpp class options"));
|
||||
if (option_class.ast != nullptr) {
|
||||
expect(option_class->Body.ast == class_body.ast, txt("cpp class body"));
|
||||
expect(option_class->ParentType.ast == class_parent.ast, txt("cpp class parent"));
|
||||
expect(option_class->ParentAccess == AccessSpec_Public, txt("cpp class parent access"));
|
||||
expect(option_class->Attributes.ast == class_options.attributes.ast, txt("cpp class attributes"));
|
||||
expect(option_class->ParentType->Next.ast == ((Code)class_interfaces[0]).ast, txt("cpp class interface"));
|
||||
expect(option_class->Specs.ast == class_options.specifiers.ast, txt("cpp class specifiers"));
|
||||
expect(option_class->ModuleFlags == ModuleFlag_Export, txt("cpp class module flags"));
|
||||
Str class_text = strbuilder_to_str(code_to_strbuilder((Code)option_class));
|
||||
expect(str_contains(class_text, txt("ClassOption")), txt("cpp class name serialization"));
|
||||
expect(str_contains(class_text, txt("ClassOptionBase")), txt("cpp class parent serialization"));
|
||||
expect(str_contains(class_text, txt("IClassOption")), txt("cpp class interface serialization"));
|
||||
expect(str_contains(class_text, txt("public")), txt("cpp class access serialization"));
|
||||
expect(str_contains(class_text, txt("class_option_member")), txt("cpp class body serialization"));
|
||||
expect(str_contains(class_text, txt("[[maybe_unused]]")), txt("cpp class attribute serialization"));
|
||||
expect(str_contains(class_text, txt("final")), txt("cpp class final specifier serialization"));
|
||||
expect(str_contains(class_text, txt("export")), txt("cpp class module flag serialization"));
|
||||
}
|
||||
|
||||
CodeVar struct_member = def_variable(def_type(name(u32)), name(struct_option_member));
|
||||
CodeBody struct_body = def_struct_body(args(struct_member));
|
||||
CodeTypename struct_parent = def_type(name(StructOptionBase));
|
||||
CodeTypename struct_interfaces[] = { def_type(name(IStructOption)) };
|
||||
Opts_def_struct struct_options = {};
|
||||
struct_options.body = struct_body;
|
||||
struct_options.parent = struct_parent;
|
||||
struct_options.parent_access = AccessSpec_Public;
|
||||
struct_options.attributes = def_attributes(txt("[[maybe_unused]]"));
|
||||
struct_options.interfaces = struct_interfaces;
|
||||
struct_options.num_interfaces = 1;
|
||||
struct_options.specifiers = def_specifier(Spec_Final);
|
||||
struct_options.mflags = ModuleFlag_Export;
|
||||
CodeStruct option_struct = def_struct(name(StructOption), struct_options);
|
||||
expect(option_struct.ast != nullptr, txt("cpp struct options"));
|
||||
if (option_struct.ast != nullptr) {
|
||||
expect(option_struct->Body.ast == struct_body.ast, txt("cpp struct body"));
|
||||
expect(option_struct->ParentType.ast == struct_parent.ast, txt("cpp struct parent"));
|
||||
expect(option_struct->ParentAccess == AccessSpec_Public, txt("cpp struct parent access"));
|
||||
expect(option_struct->Attributes.ast == struct_options.attributes.ast, txt("cpp struct attributes"));
|
||||
expect(option_struct->ParentType->Next.ast == ((Code)struct_interfaces[0]).ast, txt("cpp struct interface"));
|
||||
expect(option_struct->Specs.ast == struct_options.specifiers.ast, txt("cpp struct specifiers"));
|
||||
expect(option_struct->ModuleFlags == ModuleFlag_Export, txt("cpp struct module flags"));
|
||||
Str struct_text = strbuilder_to_str(code_to_strbuilder((Code)option_struct));
|
||||
expect(str_contains(struct_text, txt("StructOption")), txt("cpp struct name serialization"));
|
||||
expect(str_contains(struct_text, txt("StructOptionBase")), txt("cpp struct parent serialization"));
|
||||
expect(str_contains(struct_text, txt("IStructOption")), txt("cpp struct interface serialization"));
|
||||
expect(str_contains(struct_text, txt("public")), txt("cpp struct access serialization"));
|
||||
expect(str_contains(struct_text, txt("struct_option_member")), txt("cpp struct body serialization"));
|
||||
expect(str_contains(struct_text, txt("[[maybe_unused]]")), txt("cpp struct attribute serialization"));
|
||||
expect(str_contains(struct_text, txt("final")), txt("cpp struct final specifier serialization"));
|
||||
expect(str_contains(struct_text, txt("export")), txt("cpp struct module flag serialization"));
|
||||
}
|
||||
|
||||
CodeBody enum_body = def_enum_body(args(untyped_str(txt("Option_None"))));
|
||||
Opts_def_enum enum_options = {};
|
||||
enum_options.body = enum_body;
|
||||
enum_options.type = def_type(name(u32));
|
||||
enum_options.specifier = EnumDecl_Class;
|
||||
enum_options.attributes = def_attributes(txt("[[maybe_unused]]"));
|
||||
enum_options.mflags = ModuleFlag_Export;
|
||||
CodeEnum option_enum = def_enum(name(OptionEnum), enum_options);
|
||||
expect(option_enum.ast != nullptr, txt("cpp enum options"));
|
||||
if (option_enum.ast != nullptr) {
|
||||
expect(option_enum->Body.ast == enum_body.ast, txt("cpp enum body"));
|
||||
expect(option_enum->UnderlyingType.ast == enum_options.type.ast, txt("cpp enum underlying type"));
|
||||
expect(option_enum->Type == CT_Enum_Class, txt("cpp enum specifier"));
|
||||
expect(option_enum->Attributes.ast == enum_options.attributes.ast, txt("cpp enum attributes"));
|
||||
expect(option_enum->ModuleFlags == ModuleFlag_Export, txt("cpp enum module flags"));
|
||||
Str enum_text = strbuilder_to_str(code_to_strbuilder((Code)option_enum));
|
||||
expect(str_contains(enum_text, txt("export")), txt("cpp enum module flag serialization"));
|
||||
expect(str_contains(enum_text, txt("enum class")), txt("cpp enum specifier serialization"));
|
||||
expect(str_contains(enum_text, txt("[[maybe_unused]]")), txt("cpp enum attribute serialization"));
|
||||
expect(str_contains(enum_text, txt("u32")), txt("cpp enum type serialization"));
|
||||
expect(str_contains(enum_text, txt("Option_None")), txt("cpp enum body serialization"));
|
||||
}
|
||||
Code enum_macro = untyped_str(txt("ENUM_BASE_TYPE"));
|
||||
CodeEnum macro_enum = def_enum(name(MacroOptionEnum), {
|
||||
.body = def_enum_body(args(untyped_str(txt("Macro_None")))),
|
||||
.type_macro = enum_macro,
|
||||
});
|
||||
expect(macro_enum.ast != nullptr, txt("cpp enum type macro option"));
|
||||
if (macro_enum.ast != nullptr) {
|
||||
expect(macro_enum->UnderlyingTypeMacro.ast == enum_macro.ast, txt("cpp enum type macro"));
|
||||
expect(str_contains(strbuilder_to_str(code_to_strbuilder((Code)macro_enum)), txt("ENUM_BASE_TYPE")), txt("cpp enum type macro serialization"));
|
||||
}
|
||||
|
||||
CodeBody union_body = def_union_body(args(untyped_str(txt("u32 union_option_value;"))));
|
||||
Opts_def_union union_options = {};
|
||||
union_options.attributes = def_attributes(txt("[[maybe_unused]]"));
|
||||
union_options.mflags = ModuleFlag_Export;
|
||||
CodeUnion option_union = def_union(name(OptionUnion), union_body, union_options);
|
||||
expect(option_union.ast != nullptr, txt("cpp union options"));
|
||||
if (option_union.ast != nullptr) {
|
||||
expect(option_union->Body.ast == union_body.ast, txt("cpp union body"));
|
||||
expect(option_union->Attributes.ast == union_options.attributes.ast, txt("cpp union attributes"));
|
||||
expect(option_union->ModuleFlags == ModuleFlag_Export, txt("cpp union module flags"));
|
||||
Str union_text = strbuilder_to_str(code_to_strbuilder((Code)option_union));
|
||||
expect(str_contains(union_text, txt("OptionUnion")), txt("cpp union name serialization"));
|
||||
expect(str_contains(union_text, txt("union_option_value")), txt("cpp union body serialization"));
|
||||
expect(str_contains(union_text, txt("[[maybe_unused]]")), txt("cpp union attribute serialization"));
|
||||
expect(str_contains(union_text, txt("export")), txt("cpp union module flag serialization"));
|
||||
}
|
||||
|
||||
CodeAttributes typedef_attrs = def_attributes(txt("[[maybe_unused]]"));
|
||||
Code typedef_type = (Code)def_type(name(u32));
|
||||
Opts_def_typedef typedef_options = {};
|
||||
typedef_options.attributes = typedef_attrs;
|
||||
typedef_options.mflags = ModuleFlag_Export;
|
||||
CodeTypedef option_typedef = def_typedef(name(OptionTypedef), typedef_type, typedef_options);
|
||||
expect(option_typedef.ast != nullptr, txt("cpp typedef options"));
|
||||
if (option_typedef.ast != nullptr) {
|
||||
expect(option_typedef->UnderlyingType.ast == typedef_type.ast, txt("cpp typedef underlying type"));
|
||||
expect(option_typedef->Attributes.ast == typedef_attrs.ast, txt("cpp typedef attributes"));
|
||||
expect(option_typedef->ModuleFlags == ModuleFlag_Export, txt("cpp typedef module flags"));
|
||||
Str typedef_text = strbuilder_to_str(code_to_strbuilder((Code)option_typedef));
|
||||
expect(str_contains(typedef_text, txt("OptionTypedef")), txt("cpp typedef name serialization"));
|
||||
expect(str_contains(typedef_text, txt("u32")), txt("cpp typedef type serialization"));
|
||||
expect(str_contains(typedef_text, txt("[[maybe_unused]]")), txt("cpp typedef attribute serialization"));
|
||||
expect(str_contains(typedef_text, txt("export")), txt("cpp typedef module flag serialization"));
|
||||
}
|
||||
|
||||
Opts_def_using using_options = {};
|
||||
using_options.attributes = def_attributes(txt("[[maybe_unused]]"));
|
||||
using_options.mflags = ModuleFlag_Export;
|
||||
CodeTypename using_type = def_type(name(u32));
|
||||
CodeUsing option_using = def_using(name(OptionUsing), using_type, using_options);
|
||||
expect(option_using.ast != nullptr, txt("cpp using options"));
|
||||
if (option_using.ast != nullptr) {
|
||||
expect(option_using->UnderlyingType.ast == using_type.ast, txt("cpp using underlying type"));
|
||||
expect(option_using->Attributes.ast == using_options.attributes.ast, txt("cpp using attributes"));
|
||||
expect(option_using->ModuleFlags == ModuleFlag_Export, txt("cpp using module flags"));
|
||||
Str using_text = strbuilder_to_str(code_to_strbuilder((Code)option_using));
|
||||
expect(str_contains(using_text, txt("OptionUsing")), txt("cpp using name serialization"));
|
||||
expect(str_contains(using_text, txt("[[maybe_unused]]")), txt("cpp using attribute serialization"));
|
||||
expect(str_contains(using_text, txt("export")), txt("cpp using module flag serialization"));
|
||||
}
|
||||
|
||||
CodeParams template_params = def_param(def_type(name(class)), name(T));
|
||||
CodeTemplate option_template = def_template(template_params, (Code)option_struct, { .mflags = ModuleFlag_Export });
|
||||
expect(option_template.ast != nullptr, txt("cpp template options"));
|
||||
if (option_template.ast != nullptr) {
|
||||
expect(option_template->Params.ast == template_params.ast, txt("cpp template parameters"));
|
||||
expect(option_template->Declaration.ast == ((Code)option_struct).ast, txt("cpp template declaration"));
|
||||
expect(option_template->ModuleFlags == ModuleFlag_Export, txt("cpp template module flags"));
|
||||
Str template_text = strbuilder_to_str(code_to_strbuilder((Code)option_template));
|
||||
expect(str_contains(template_text, txt("export")), txt("cpp template module flag serialization"));
|
||||
expect(str_contains(template_text, txt("template")), txt("cpp template serialization"));
|
||||
expect(str_contains(template_text, txt("StructOption")), txt("cpp template declaration serialization"));
|
||||
}
|
||||
|
||||
Macro source_macro = { txt("OptionParamSource"), MT_Expression, MF_Functional };
|
||||
register_macro(source_macro);
|
||||
CodeDefine parsed_macro_source = parse_define(txt("#define OptionParamSource(param) param\n"));
|
||||
expect(parsed_macro_source.ast != nullptr, txt("cpp define parameter source"));
|
||||
Opts_def_define define_options = {};
|
||||
define_options.params = parsed_macro_source->Params;
|
||||
define_options.content = txt("param + 1");
|
||||
define_options.flags = MF_Functional | MF_Allow_As_Identifier;
|
||||
CodeDefine option_define = def_define(name(OptionMacro), MT_Expression, define_options);
|
||||
expect(option_define.ast != nullptr, txt("cpp define options"));
|
||||
if (option_define.ast != nullptr) {
|
||||
expect(option_define->Params.ast == define_options.params.ast, txt("cpp define parameters"));
|
||||
expect(str_contains(option_define->Body->Content, txt("param + 1")), txt("cpp define content"));
|
||||
Macro* option_macro = lookup_macro(name(OptionMacro));
|
||||
expect(option_macro != nullptr, txt("cpp define registration"));
|
||||
if (option_macro != nullptr) expect(option_macro->Flags == define_options.flags, txt("cpp define flags"));
|
||||
Str define_text = strbuilder_to_str(code_to_strbuilder((Code)option_define));
|
||||
expect(str_contains(define_text, txt("OptionMacro")), txt("cpp define name serialization"));
|
||||
expect(str_contains(define_text, txt("OptionMacro( param)")), txt("cpp define parameters serialization"));
|
||||
expect(str_contains(define_text, txt("param + 1")), txt("cpp define content serialization"));
|
||||
}
|
||||
Opts_def_define no_register_options = {};
|
||||
no_register_options.dont_register_to_preprocess_macros = true;
|
||||
CodeDefine no_register_define = def_define(name(OptionMacroNoRegister), MT_Expression, no_register_options);
|
||||
expect(no_register_define.ast != nullptr, txt("cpp define registration suppression"));
|
||||
expect(lookup_macro(name(OptionMacroNoRegister)) == nullptr, txt("cpp define suppression flag"));
|
||||
|
||||
CodeInclude local_include = def_include(txt("option_local.h"));
|
||||
expect(local_include.ast != nullptr, txt("cpp local include option"));
|
||||
if (local_include.ast != nullptr) {
|
||||
expect(str_contains(local_include->Content, txt("\"option_local.h\"")), txt("cpp quoted include"));
|
||||
}
|
||||
Opts_def_include foreign_include_options = {};
|
||||
foreign_include_options.foreign = true;
|
||||
CodeInclude foreign_include = def_include(txt("option_system.h"), foreign_include_options);
|
||||
expect(foreign_include.ast != nullptr, txt("cpp foreign include option"));
|
||||
if (foreign_include.ast != nullptr) {
|
||||
expect(str_contains(foreign_include->Content, txt("<option_system.h>")), txt("cpp foreign include path"));
|
||||
Str include_text = strbuilder_to_str(code_to_strbuilder((Code)foreign_include));
|
||||
expect(str_contains(include_text, txt("#include <option_system.h>")), txt("cpp foreign include directive serialization"));
|
||||
}
|
||||
|
||||
CodeModule option_module = def_module(name(OptionModule), { .mflags = ModuleFlag_Export });
|
||||
expect(option_module.ast != nullptr, txt("cpp module options"));
|
||||
if (option_module.ast != nullptr) {
|
||||
expect(option_module->ModuleFlags == ModuleFlag_Export, txt("cpp module flags"));
|
||||
expect(str_contains(strbuilder_to_str(code_to_strbuilder((Code)option_module)), txt("export")), txt("cpp module serialization"));
|
||||
}
|
||||
CodeVar namespace_member = def_variable(def_type(name(u32)), name(namespace_option_value));
|
||||
CodeBody namespace_body = def_namespace_body(args(namespace_member));
|
||||
CodeNS option_namespace = def_namespace(name(OptionNamespace), namespace_body, { .mflags = ModuleFlag_Export });
|
||||
expect(option_namespace.ast != nullptr, txt("cpp namespace options"));
|
||||
if (option_namespace.ast != nullptr) {
|
||||
expect(option_namespace->Body.ast == namespace_body.ast, txt("cpp namespace body"));
|
||||
expect(option_namespace->ModuleFlags == ModuleFlag_Export, txt("cpp namespace flags"));
|
||||
Str namespace_text = strbuilder_to_str(code_to_strbuilder((Code)option_namespace));
|
||||
expect(str_contains(namespace_text, txt("OptionNamespace")), txt("cpp namespace name serialization"));
|
||||
expect(str_contains(namespace_text, txt("namespace_option_value")), txt("cpp namespace body serialization"));
|
||||
expect(str_contains(namespace_text, txt("export")), txt("cpp namespace serialization"));
|
||||
}
|
||||
|
||||
Code parameter_value = untyped_str(code(7));
|
||||
Opts_def_param parameter_options = {};
|
||||
parameter_options.value = parameter_value;
|
||||
CodeParams option_parameter = def_param(def_type(name(u32)), name(option_parameter_value), parameter_options);
|
||||
expect(option_parameter.ast != nullptr, txt("cpp parameter options"));
|
||||
if (option_parameter.ast != nullptr) {
|
||||
expect(option_parameter->Value.ast == parameter_value.ast, txt("cpp parameter value"));
|
||||
Str parameter_text = strbuilder_to_str(code_to_strbuilder((Code)option_parameter));
|
||||
expect(str_contains(parameter_text, txt("= 7")), txt("cpp parameter value serialization"));
|
||||
}
|
||||
|
||||
CodeParams function_params = def_param(def_type(name(u32)), name(function_option_arg));
|
||||
CodeTypename function_return = def_type(name(FunctionOptionReturn));
|
||||
CodeBody function_body = def_function_body(args(untyped_str(txt("return function_option_arg;"))));
|
||||
Opts_def_function function_options = {};
|
||||
function_options.params = function_params;
|
||||
function_options.ret_type = function_return;
|
||||
function_options.body = function_body;
|
||||
function_options.specs = def_specifier(Spec_Inline);
|
||||
function_options.attrs = def_attributes(txt("[[maybe_unused]]"));
|
||||
function_options.mflags = ModuleFlag_Export;
|
||||
CodeFn option_function = def_function(name(OptionFunction), function_options);
|
||||
expect(option_function.ast != nullptr, txt("cpp function options"));
|
||||
if (option_function.ast != nullptr) {
|
||||
expect(option_function->Params.ast == function_params.ast, txt("cpp function parameters"));
|
||||
expect(option_function->ReturnType.ast == function_return.ast, txt("cpp function return type"));
|
||||
expect(option_function->Body.ast == function_body.ast, txt("cpp function body"));
|
||||
expect(option_function->Specs.ast == function_options.specs.ast, txt("cpp function specifiers"));
|
||||
expect(option_function->Attributes.ast == function_options.attrs.ast, txt("cpp function attributes"));
|
||||
expect(option_function->ModuleFlags == ModuleFlag_Export, txt("cpp function module flags"));
|
||||
Str function_text = strbuilder_to_str(code_to_strbuilder((Code)option_function));
|
||||
expect(str_contains(function_text, txt("OptionFunction")), txt("cpp function name serialization"));
|
||||
expect(str_contains(function_text, txt("FunctionOptionReturn OptionFunction(")), txt("cpp function return type serialization"));
|
||||
expect(str_contains(function_text, txt("function_option_arg")), txt("cpp function parameters serialization"));
|
||||
expect(str_contains(function_text, txt("return function_option_arg")), txt("cpp function body serialization"));
|
||||
expect(str_contains(function_text, txt("inline")), txt("cpp function specifier serialization"));
|
||||
expect(str_contains(function_text, txt("[[maybe_unused]]")), txt("cpp function attribute serialization"));
|
||||
expect(str_contains(function_text, txt("export")), txt("cpp function module flag serialization"));
|
||||
}
|
||||
|
||||
CodeParams constructor_params = def_param(def_type(name(u32)), name(constructor_option_arg));
|
||||
Code initializer_list = untyped_str(txt("option_member( 0 )"));
|
||||
CodeBody constructor_body = def_function_body(args(untyped_str(txt("option_member = constructor_option_arg;"))));
|
||||
Opts_def_constructor constructor_options = {};
|
||||
constructor_options.params = constructor_params;
|
||||
constructor_options.initializer_list = initializer_list;
|
||||
constructor_options.body = constructor_body;
|
||||
CodeConstructor option_constructor = def_constructor(constructor_options);
|
||||
expect(option_constructor.ast != nullptr, txt("cpp constructor options"));
|
||||
if (option_constructor.ast != nullptr) {
|
||||
expect(option_constructor->Params.ast == constructor_params.ast, txt("cpp constructor parameters"));
|
||||
expect(option_constructor->InitializerList.ast == initializer_list.ast, txt("cpp constructor initializer list"));
|
||||
expect(option_constructor->Body.ast == ((Code)constructor_body).ast, txt("cpp constructor body"));
|
||||
}
|
||||
CodeBody constructor_class_body = def_class_body(args(option_constructor));
|
||||
CodeClass constructor_class = def_class(name(ConstructorOptions), { .body = constructor_class_body });
|
||||
expect(constructor_class.ast != nullptr, txt("cpp constructor serialization parent"));
|
||||
if (constructor_class.ast != nullptr) {
|
||||
Str constructor_text = strbuilder_to_str(code_to_strbuilder((Code)constructor_class));
|
||||
expect(str_contains(constructor_text, txt("ConstructorOptions(")), txt("cpp constructor name serialization"));
|
||||
expect(str_contains(constructor_text, txt("u32 constructor_option_arg")), txt("cpp constructor parameter serialization"));
|
||||
expect(str_contains(constructor_text, txt("option_member( 0 )")), txt("cpp constructor initializer serialization"));
|
||||
expect(str_contains(constructor_text, txt("constructor_option_arg")), txt("cpp constructor body serialization"));
|
||||
}
|
||||
Code destructor_body = untyped_str(txt("release_option_resource();"));
|
||||
CodeSpecifiers destructor_specs = def_specifier(Spec_Virtual);
|
||||
Opts_def_destructor destructor_options = {};
|
||||
destructor_options.body = destructor_body;
|
||||
destructor_options.specifiers = destructor_specs;
|
||||
CodeDestructor option_destructor = def_destructor(destructor_options);
|
||||
expect(option_destructor.ast != nullptr, txt("cpp destructor options"));
|
||||
if (option_destructor.ast != nullptr) {
|
||||
expect(option_destructor->Body.ast == destructor_body.ast, txt("cpp destructor body"));
|
||||
expect(option_destructor->Specs.ast == destructor_specs.ast, txt("cpp destructor specifiers"));
|
||||
CodeBody destructor_class_body = def_class_body(args(option_destructor));
|
||||
CodeClass destructor_class = def_class(name(DestructorOptions), { .body = destructor_class_body });
|
||||
expect(destructor_class.ast != nullptr, txt("cpp destructor serialization parent"));
|
||||
if (destructor_class.ast != nullptr) {
|
||||
Str destructor_text = strbuilder_to_str(code_to_strbuilder((Code)destructor_class));
|
||||
expect(str_contains(destructor_text, txt("virtual ~DestructorOptions()")), txt("cpp destructor signature serialization"));
|
||||
expect(str_contains(destructor_text, txt("release_option_resource();")), txt("cpp destructor body serialization"));
|
||||
}
|
||||
}
|
||||
|
||||
CodeTypename operator_type = def_type(name(OperatorOptionType));
|
||||
CodeTypename operator_return = def_type(name(OperatorOptionReturn));
|
||||
CodeParams operator_lhs = def_param(operator_type, name(operator_option_lhs));
|
||||
CodeParams operator_rhs = def_param(operator_type, name(operator_option_rhs));
|
||||
CodeParams operator_params = def_params(args(operator_lhs, operator_rhs));
|
||||
CodeBody operator_body = def_function_body(args(untyped_str(txt("return operator_option_lhs;"))));
|
||||
Opts_def_operator operator_options = {};
|
||||
operator_options.params = operator_params;
|
||||
operator_options.ret_type = operator_return;
|
||||
operator_options.body = operator_body;
|
||||
operator_options.specifiers = def_specifier(Spec_Inline);
|
||||
operator_options.attributes = def_attributes(txt("[[maybe_unused]]"));
|
||||
operator_options.mflags = ModuleFlag_Export;
|
||||
CodeOperator option_operator = def_operator(Op_Add, txt(""), operator_options);
|
||||
expect(option_operator.ast != nullptr, txt("cpp operator options"));
|
||||
if (option_operator.ast != nullptr) {
|
||||
expect(option_operator->Params.ast == operator_params.ast, txt("cpp operator parameters"));
|
||||
expect(option_operator->ReturnType.ast == operator_return.ast, txt("cpp operator return type"));
|
||||
expect(option_operator->Body.ast == operator_body.ast, txt("cpp operator body"));
|
||||
expect(option_operator->Specs.ast == operator_options.specifiers.ast, txt("cpp operator specifiers"));
|
||||
expect(option_operator->Attributes.ast == operator_options.attributes.ast, txt("cpp operator attributes"));
|
||||
expect(option_operator->ModuleFlags == ModuleFlag_Export, txt("cpp operator module flags"));
|
||||
Str operator_text = strbuilder_to_str(code_to_strbuilder((Code)option_operator));
|
||||
expect(str_contains(operator_text, txt("OperatorOptionReturn")), txt("cpp operator return type serialization"));
|
||||
expect(str_contains(operator_text, txt("operator +")), txt("cpp operator name serialization"));
|
||||
expect(str_contains(operator_text, txt("operator_option_lhs")), txt("cpp operator parameters serialization"));
|
||||
expect(str_contains(operator_text, txt("operator_option_rhs")), txt("cpp operator second parameter serialization"));
|
||||
expect(str_contains(operator_text, txt("return operator_option_lhs")), txt("cpp operator body serialization"));
|
||||
expect(str_contains(operator_text, txt("inline")), txt("cpp operator specifier serialization"));
|
||||
expect(str_contains(operator_text, txt("[[maybe_unused]]")), txt("cpp operator attribute serialization"));
|
||||
expect(str_contains(operator_text, txt("export")), txt("cpp operator module flag serialization"));
|
||||
if (!str_starts_with(operator_text, txt("export [[maybe_unused]] inline\nOperatorOptionReturn"))) log_fmt("%S\n", operator_text);
|
||||
expect(str_starts_with(operator_text, txt("export [[maybe_unused]] inline\nOperatorOptionReturn")), txt("cpp operator one-attribute prefix serialization"));
|
||||
}
|
||||
|
||||
CodeTypename cast_type = def_type(name(s32));
|
||||
CodeBody cast_body = def_function_body(args(untyped_str(txt("return 0;"))));
|
||||
CodeSpecifiers cast_specs = def_specifier(Spec_Const);
|
||||
Opts_def_operator_cast cast_options = {};
|
||||
cast_options.body = cast_body;
|
||||
cast_options.specs = cast_specs;
|
||||
CodeOpCast option_cast = def_operator_cast(cast_type, cast_options);
|
||||
expect(option_cast.ast != nullptr, txt("cpp operator cast options"));
|
||||
if (option_cast.ast != nullptr) {
|
||||
expect(option_cast->ValueType.ast == cast_type.ast, txt("cpp operator cast type"));
|
||||
expect(option_cast->Body.ast == cast_body.ast, txt("cpp operator cast body"));
|
||||
expect(option_cast->Specs.ast == cast_specs.ast, txt("cpp operator cast specifiers"));
|
||||
Str cast_text = strbuilder_to_str(code_to_strbuilder((Code)option_cast));
|
||||
expect(str_contains(cast_text, txt("operator s32")), txt("cpp operator cast serialization"));
|
||||
expect(str_contains(cast_text, txt("const")), txt("cpp operator cast specifier serialization"));
|
||||
expect(str_contains(cast_text, txt("return 0")), txt("cpp operator cast body serialization"));
|
||||
}
|
||||
|
||||
Code untyped = code_str(char const* baseline_message = "GENCPP_BASELINE";); expect(untyped.ast != nullptr, txt("cpp untyped"));
|
||||
Str untyped_text = strbuilder_to_str(code_to_strbuilder(untyped)); expect_fragments(untyped_text, txt("cpp untyped content"));
|
||||
CodeVar parsed_untyped = parse_variable(untyped_text); expect_variable(parsed_untyped, txt("cpp untyped reparsed"));
|
||||
|
||||
CodeVar parsed = parse_variable(code(char const* baseline_message = "GENCPP_BASELINE"; ));
|
||||
expect_variable(parsed, txt("cpp parsed"));
|
||||
expect_fragments(strbuilder_to_str(code_to_strbuilder((Code)parsed)), txt("cpp parsed serialized"));
|
||||
|
||||
#if ! GEN_BUILD_DEBUG
|
||||
CodeVar wrong_array_value = def_variable(def_type(name(u32)), name(invalid_array_expr));
|
||||
Opts_def_type wrong_array_options = {};
|
||||
wrong_array_options.array_expr = (Code)wrong_array_value;
|
||||
CodeTypename invalid_array_type = def_type(name(InvalidArrayOption), wrong_array_options);
|
||||
expect(((Code)invalid_array_type).ast == Code_Invalid.ast, txt("cpp wrong type invalid code"));
|
||||
|
||||
CodeBody missing_union_body = {};
|
||||
CodeUnion missing_union = def_union(name(MissingUnionBody), missing_union_body);
|
||||
expect(((Code)missing_union).ast == Code_Invalid.ast, txt("cpp missing body invalid code"));
|
||||
#endif
|
||||
|
||||
deinit(&ctx);
|
||||
if (g_failures != 0) { log_fmt("cpp baseline smoke failed: %d\n", g_failures); return 1; }
|
||||
log_fmt("cpp baseline smoke passed\n");
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
#define GEN_TIME
|
||||
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
|
||||
#define GEN_ENFORCE_STRONG_CODE_TYPES
|
||||
#include "gen.cpp"
|
||||
|
||||
using namespace gen;
|
||||
|
||||
global int g_failures = 0;
|
||||
|
||||
internal void expect(int condition, Str label) {
|
||||
if (condition == false) { log_fmt("FAIL %S\n", label); ++g_failures; }
|
||||
}
|
||||
|
||||
internal Str body_text(CodeBody body) {
|
||||
return strbuilder_to_str(code_to_strbuilder(cast(Code, body)));
|
||||
}
|
||||
|
||||
internal b32 body_has_variable(CodeBody body, Str name) { for (Code member : body) {
|
||||
if (member->Type == CT_Variable && member->Name.is_equal(name)) return true;
|
||||
if ((member->Type == CT_Struct || member->Type == CT_Union) && member->Body.ast != nullptr) {
|
||||
if (body_has_variable(cast(CodeBody, member->Body), name))
|
||||
return true;
|
||||
}
|
||||
} return false; }
|
||||
|
||||
internal Str bad_at(Str good) {
|
||||
StrBuilder built = strbuilder_make_reserve(_ctx->Allocator_Temp, good.Len + 2);
|
||||
strbuilder_append_str(& built, good);
|
||||
strbuilder_append_str(& built, txt("\n@"));
|
||||
return strbuilder_to_str(built);
|
||||
}
|
||||
|
||||
internal void expect_context_good(Context* ctx, Str label) {
|
||||
Str def = txt("struct Context\n{\n\tContext* parent;\n};\n\nContext* make_context();\n");
|
||||
CodeBody body = parse_global_body(def);
|
||||
Code found = InvalidCode;
|
||||
for (Code code : body) if (code->Type == CT_Struct && code->Name.is_equal(txt("Context")))
|
||||
found = code;
|
||||
expect(found.ast != nullptr, label); if (found.ast != nullptr) {
|
||||
Code member = InvalidCode;
|
||||
for (Code code : cast(CodeBody, found->Body)) {
|
||||
if (code->Type == CT_Variable && code->Name.is_equal(txt("parent")))
|
||||
member = code;
|
||||
}
|
||||
expect(member.ast != nullptr, label);
|
||||
}
|
||||
expect(ctx->parse_info.messages == nullptr, label);
|
||||
expect(ctx->parse_info.lexed.messages == nullptr, label);
|
||||
}
|
||||
|
||||
internal void expect_context_bad(Str label) {
|
||||
Context ctx = {}; init(& ctx);
|
||||
Str good = txt("struct Context\n{\n\tContext* parent;\n};\n\nContext* make_context();\n");
|
||||
CodeBody body = parse_global_body(bad_at(good));
|
||||
Str text = body_text(body);
|
||||
expect(str_contains(text, txt("Context")), label);
|
||||
expect(str_contains(text, txt("parent")), label);
|
||||
expect(ctx.parse_info.lexed.messages != nullptr, label);
|
||||
if (ctx.parse_info.lexed.messages != nullptr) expect(str_contains(ctx.parse_info.lexed.messages->content, txt("Failed to lex token")), label);
|
||||
expect_context_good(&ctx, txt("context-reuse"));
|
||||
deinit(& ctx);
|
||||
}
|
||||
|
||||
internal Str vec_def() {
|
||||
Str type = txt("Vec2f");
|
||||
Str unit_type = txt("f32");
|
||||
return token_fmt("type", type, "unit_type", unit_type, stringize(
|
||||
struct <type>
|
||||
{
|
||||
union {
|
||||
struct {
|
||||
<unit_type> x;
|
||||
<unit_type> y;
|
||||
};
|
||||
<unit_type> Basis[2];
|
||||
};
|
||||
};
|
||||
));
|
||||
}
|
||||
|
||||
internal void expect_vec_good(Context* ctx, Str label) {
|
||||
Str def = vec_def();
|
||||
expect(str_contains(def, txt("struct Vec2f")), txt("vec-def-struct"));
|
||||
expect(str_contains(def, txt("union")), txt("vec-def-union"));
|
||||
expect(str_contains(def, txt("f32 x;")), txt("vec-def-x"));
|
||||
expect(str_contains(def, txt("f32 y;")), txt("vec-def-y"));
|
||||
expect(str_contains(def, txt("f32 Basis[2]")), txt("vec-def-Basis"));
|
||||
CodeBody body = parse_global_body(def);
|
||||
expect(body_has_variable(body, txt("x")), txt("vec-ast-x"));
|
||||
expect(body_has_variable(body, txt("y")), txt("vec-ast-y"));
|
||||
Str text = body_text(body);
|
||||
expect(str_contains(text, txt("Vec2f")), txt("vec-name"));
|
||||
expect(str_contains(text, txt("x")), txt("vec-x"));
|
||||
expect(str_contains(text, txt("y")), txt("vec-y"));
|
||||
expect(ctx->parse_info.messages == nullptr, txt("vec-parser-messages"));
|
||||
expect(ctx->parse_info.lexed.messages == nullptr, txt("vec-lexer-messages"));
|
||||
}
|
||||
|
||||
internal void expect_vec_bad(Str label) {
|
||||
Context ctx = {}; init(& ctx);
|
||||
CodeBody body = parse_global_body(bad_at(vec_def()));
|
||||
Str text = body_text(body);
|
||||
expect(str_contains(text, txt("Vec2f")), label);
|
||||
expect(ctx.parse_info.lexed.messages != nullptr, label);
|
||||
if (ctx.parse_info.lexed.messages != nullptr) expect(str_contains(ctx.parse_info.lexed.messages->content, txt("Failed to lex token")), label);
|
||||
expect_vec_good(& ctx, txt("vec-reuse"));
|
||||
deinit(& ctx);
|
||||
}
|
||||
|
||||
internal Str unreal_def() { return txt("UCLASS()\nclass UGasaFixture\n{\n\tUPROPERTY()\n\tint Health;\n};\n"); }
|
||||
|
||||
internal void expect_unreal_good(Context* ctx, Str label) {
|
||||
CodeBody body = parse_global_body(unreal_def());
|
||||
Code found = InvalidCode;
|
||||
for (Code code : body) if (code->Type == CT_Class && code->Name.is_equal(txt("UGasaFixture")))
|
||||
found = code;
|
||||
expect(found.ast != nullptr, label); if (found.ast != nullptr) {
|
||||
b32 saw_prop = false;
|
||||
b32 saw_health = false;
|
||||
for (Code member : cast(CodeBody, found->Body)) {
|
||||
if ( member->Type == CT_Untyped && member->Name.starts_with(txt("UPROPERTY"))) saw_prop = true;
|
||||
if (saw_prop && member->Type == CT_Variable && member->Name.is_equal(txt("Health"))) saw_health = true;
|
||||
}
|
||||
expect(saw_prop, label);
|
||||
expect(saw_health, label);
|
||||
}
|
||||
expect(ctx->parse_info.messages == nullptr, label);
|
||||
expect(ctx->parse_info.lexed.messages == nullptr, label);
|
||||
}
|
||||
|
||||
internal void expect_unreal_bad(Str label) {
|
||||
Context ctx = {}; init(& ctx);
|
||||
register_macros(args(
|
||||
(Macro { txt("UCLASS"), MT_Statement, MF_Functional }),
|
||||
(Macro { txt("UPROPERTY"), MT_Statement, MF_Functional })
|
||||
));
|
||||
CodeBody body = parse_global_body(bad_at(unreal_def()));
|
||||
Str text = body_text(body);
|
||||
expect(str_contains(text, txt("UGasaFixture")), label);
|
||||
expect(ctx.parse_info.lexed.messages != nullptr, label);
|
||||
if (ctx.parse_info.lexed.messages != nullptr) expect(str_contains(ctx.parse_info.lexed.messages->content, txt("Failed to lex token")), label);
|
||||
expect_unreal_good(&ctx, txt("unreal-reuse"));
|
||||
deinit(& ctx);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
Context ctx = {}; init(& ctx);
|
||||
expect_context_good(&ctx, txt("context"));
|
||||
deinit(& ctx);
|
||||
expect_context_bad(txt("context-at"));
|
||||
|
||||
init(& ctx);
|
||||
expect_vec_good(& ctx, txt("vec"));
|
||||
deinit(& ctx);
|
||||
expect_vec_bad(txt("vec-at"));
|
||||
|
||||
init(& ctx);
|
||||
register_macros(args(
|
||||
(Macro { txt("UCLASS"), MT_Statement, MF_Functional }),
|
||||
(Macro { txt("UPROPERTY"), MT_Statement, MF_Functional })
|
||||
));
|
||||
expect_unreal_good(& ctx, txt("unreal"));
|
||||
deinit(& ctx);
|
||||
expect_unreal_bad(txt("unreal-at"));
|
||||
|
||||
if (g_failures != 0) { log_fmt("dogfood parse fixtures failed: %d\n", g_failures); return 1; }
|
||||
log_fmt("dogfood parse fixtures passed\n");
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
#define GEN_TIME
|
||||
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
|
||||
#define GEN_ENFORCE_STRONG_CODE_TYPES
|
||||
#include "gen.cpp"
|
||||
|
||||
using namespace gen;
|
||||
|
||||
global int g_failures = 0;
|
||||
|
||||
internal void expect(int condition, Str label) {
|
||||
if (condition == false) { log_fmt("FAIL %S\n", label); ++g_failures; }
|
||||
}
|
||||
|
||||
internal void expect_public(Str def, Str needle, Str label) {
|
||||
Context ctx = {}; init(&ctx);
|
||||
CodeVar parsed = parse_variable(def); expect(cast(Code, parsed) == Code_Invalid, label);
|
||||
expect(_ctx->parser.messages != nullptr, label);
|
||||
expect(_ctx->parser.messages->Scope == nullptr, label);
|
||||
expect(_ctx->parser.messages->Content.Ptr != nullptr, label);
|
||||
expect(str_contains(_ctx->parser.messages->Content, needle), label);
|
||||
|
||||
CodeVar again = parse_variable(txt("char const* baseline_message = \"GENCPP_BASELINE\";")); expect(again.ast != nullptr, label);
|
||||
if (again.ast != nullptr) {
|
||||
expect(again->Type == CT_Variable, label);
|
||||
expect(str_contains(again->Name, txt("baseline_message")), label);
|
||||
}
|
||||
deinit(&ctx);
|
||||
}
|
||||
|
||||
internal void expect_lex_fail(Str def, Str needle, Str label) {
|
||||
Context ctx = {}; init(&ctx);
|
||||
LexedInfo lexed = lex(&ctx, def);
|
||||
expect(lexed.tokens.ptr != nullptr, label);
|
||||
expect(lexed.messages != nullptr, label);
|
||||
if (lexed.messages != nullptr) expect(str_contains(lexed.messages->content, needle), label);
|
||||
deinit(&ctx);
|
||||
}
|
||||
|
||||
internal void expect_lex_ok(Str def, Str label) {
|
||||
Context ctx = {}; init(&ctx);
|
||||
LexedInfo lexed = lex(&ctx, def);
|
||||
expect(lexed.tokens.ptr != nullptr, label);
|
||||
expect(lexed.tokens.num > 0, label);
|
||||
expect(lexed.messages == nullptr, label);
|
||||
deinit(&ctx);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
expect_public(txt("#define FOO(... x)"), txt("Expected a ')' after '...'"), txt("L01-public"));
|
||||
expect_public(txt("#define FOO(1)"), txt("Expected a '_' or alpha character"), txt("L02-public"));
|
||||
expect_public(txt("#define FOO(a b)"), txt("Expected a comma after parameter"), txt("L03-public"));
|
||||
expect_public(txt("#define FOO(a,"), txt("Expected a ')' after last_parameter"), txt("L04-public"));
|
||||
expect_public(txt("#foo \\q"), txt("in preprocessor directive ("), txt("L05-public"));
|
||||
expect_public(txt("#include foo"), txt("after #include"), txt("L06-public"));
|
||||
expect_public(txt("#pragma \\q"), txt("in preprocessor directive '"), txt("L07-public"));
|
||||
expect_public(txt("..x"), txt("invalid varadic argument"), txt("L08-public"));
|
||||
expect_public(txt("@"), txt("Failed to lex token"), txt("L09-public"));
|
||||
|
||||
expect_lex_fail(txt("#define FOO(... x)"), txt("Expected a ')' after '...'"), txt("L01-lex"));
|
||||
expect_lex_fail(txt("#define FOO(1)"), txt("Expected a '_' or alpha character"), txt("L02-lex"));
|
||||
expect_lex_fail(txt("#define FOO(a b)"), txt("Expected a comma after parameter"), txt("L03-lex"));
|
||||
expect_lex_fail(txt("#define FOO(a,"), txt("Expected a ')' after last_parameter"), txt("L04-lex"));
|
||||
expect_lex_fail(txt("#foo \\q"), txt("in preprocessor directive ("), txt("L05-lex"));
|
||||
expect_lex_fail(txt("#include foo"), txt("after #include"), txt("L06-lex"));
|
||||
expect_lex_fail(txt("#pragma \\q"), txt("in preprocessor directive '"), txt("L07-lex"));
|
||||
expect_lex_fail(txt("..x"), txt("invalid varadic argument"), txt("L08-lex"));
|
||||
expect_lex_fail(txt("@"), txt("Failed to lex token"), txt("L09-lex"));
|
||||
|
||||
expect_lex_ok(txt("#define FOO(a, b) a"), txt("S01"));
|
||||
expect_lex_ok(txt("#define FOO(...)"), txt("S02"));
|
||||
expect_lex_ok(txt("#include \"a.h\""), txt("S03"));
|
||||
expect_lex_ok(txt("#pragma once"), txt("S04"));
|
||||
expect_lex_ok(txt("#foo bar"), txt("S05"));
|
||||
expect_lex_ok(txt("..."), txt("S06"));
|
||||
|
||||
if (g_failures != 0) { log_fmt("lexer failures failed: %d\n", g_failures); return 1; }
|
||||
log_fmt("lexer failures passed\n");
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
#define GEN_TIME
|
||||
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
|
||||
#define GEN_ENFORCE_STRONG_CODE_TYPES
|
||||
#include "gen.cpp"
|
||||
|
||||
using namespace gen;
|
||||
|
||||
global int g_failures = 0;
|
||||
|
||||
internal void expect(int condition, Str label) {
|
||||
if (condition == false) { log_fmt("FAIL %S\n", label); ++g_failures; }
|
||||
}
|
||||
|
||||
internal Str body_text(CodeBody body) {
|
||||
return strbuilder_to_str(code_to_strbuilder(cast(Code, body)));
|
||||
}
|
||||
|
||||
internal void expect_good_base(Context* ctx, Str label) {
|
||||
ParseInfo info = {};
|
||||
Str def = txt("struct Context { int a; int b; };");
|
||||
parse_global_body_base(ctx, def, &info);
|
||||
CodeBody body = cast(CodeBody, info.result);
|
||||
Str text = body_text(body);
|
||||
expect(body.ast != nullptr, label);
|
||||
expect(str_contains(text, txt("Context")), label);
|
||||
expect(str_contains(text, txt("a")), label);
|
||||
expect(str_contains(text, txt("b")), label);
|
||||
expect(info.messages == nullptr, label);
|
||||
expect(info.lexed.messages == nullptr, label);
|
||||
expect(info.lexed.tokens.ptr != nullptr, label);
|
||||
expect(info.lexed.tokens.num > 0, label);
|
||||
}
|
||||
|
||||
internal void expect_at(Str label) {
|
||||
Context ctx = {};
|
||||
ParseInfo info = {};
|
||||
Str def = txt("struct Context { int a; int b; };\n@");
|
||||
init(&ctx);
|
||||
parse_global_body_base(&ctx, def, &info);
|
||||
CodeBody body = cast(CodeBody, info.result);
|
||||
Str text = body_text(body);
|
||||
expect(body.ast != nullptr, label);
|
||||
expect(str_contains(text, txt("Context")), label);
|
||||
expect(info.lexed.messages != nullptr, label);
|
||||
if (info.lexed.messages != nullptr)
|
||||
expect(str_contains(info.lexed.messages->content, txt("Failed to lex token")), label);
|
||||
expect(info.lexed.tokens.ptr != nullptr, label);
|
||||
expect(info.lexed.tokens.num > 0, label);
|
||||
expect_good_base(&ctx, txt("at-reuse"));
|
||||
deinit(&ctx);
|
||||
}
|
||||
|
||||
internal void expect_comma(Str label) {
|
||||
Context ctx = {};
|
||||
ParseInfo info = {};
|
||||
Str def = txt("struct Context { int a; int b; };\n,");
|
||||
init(&ctx);
|
||||
parse_global_body_base(&ctx, def, &info);
|
||||
CodeBody body = cast(CodeBody, info.result);
|
||||
Str text = body_text(body);
|
||||
expect(str_contains(text, txt("Context")), label);
|
||||
expect(info.messages != nullptr, label);
|
||||
if (info.messages != nullptr)
|
||||
expect(str_contains(info.messages->Content, txt("Dangling comma")), label);
|
||||
expect_good_base(&ctx, txt("comma-reuse"));
|
||||
deinit(&ctx);
|
||||
}
|
||||
|
||||
internal void expect_space(Str label) {
|
||||
Context ctx = {};
|
||||
ParseInfo info = {};
|
||||
init(&ctx);
|
||||
parse_global_body_base(&ctx, txt(" \t\n"), &info);
|
||||
CodeBody body = cast(CodeBody, info.result);
|
||||
expect(body.ast != nullptr, label);
|
||||
expect(body->Type == CT_Global_Body, label);
|
||||
expect(info.lexed.tokens.num == 0, label);
|
||||
expect(info.lexed.messages != nullptr, label);
|
||||
if (info.lexed.messages != nullptr)
|
||||
expect(str_contains(info.lexed.messages->content, txt("no tokens found")), label);
|
||||
expect_good_base(&ctx, txt("space-reuse"));
|
||||
deinit(&ctx);
|
||||
}
|
||||
|
||||
internal void expect_empty(Str label) {
|
||||
Context ctx = {};
|
||||
ParseInfo info = {};
|
||||
Str def = { nullptr, 0 };
|
||||
init(&ctx);
|
||||
parse_global_body_base(&ctx, def, &info);
|
||||
CodeBody body = cast(CodeBody, info.result);
|
||||
expect(body.ast != nullptr, label);
|
||||
expect(info.messages != nullptr, label);
|
||||
if (info.messages != nullptr)
|
||||
expect(str_contains(info.messages->Content, txt("length must greater than 0")), label);
|
||||
expect_good_base(&ctx, txt("empty-reuse"));
|
||||
deinit(&ctx);
|
||||
}
|
||||
|
||||
internal void expect_wrapper(Str label) {
|
||||
Context ctx = {};
|
||||
CodeBody body;
|
||||
Str text;
|
||||
init(&ctx);
|
||||
body = parse_global_body(txt("struct Context { int a; int b; };"));
|
||||
text = body_text(body);
|
||||
expect(str_contains(text, txt("Context")), label);
|
||||
expect(ctx.parse_info.messages == nullptr, label);
|
||||
expect(str_contains(body_text(cast(CodeBody, ctx.parse_info.result)), txt("Context")), label);
|
||||
deinit(&ctx);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
Context ctx = {}; init(& ctx);
|
||||
expect_good_base(&ctx, txt("good"));
|
||||
deinit(& ctx);
|
||||
expect_at(txt("at"));
|
||||
expect_comma(txt("comma"));
|
||||
expect_space(txt("space"));
|
||||
expect_empty(txt("empty"));
|
||||
expect_wrapper(txt("wrapper"));
|
||||
if (g_failures != 0) { log_fmt("parse body messages failed: %d\n", g_failures); return 1; }
|
||||
log_fmt("parse body messages passed\n");
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,238 @@
|
||||
#define GEN_TIME
|
||||
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
|
||||
#define GEN_ENFORCE_STRONG_CODE_TYPES
|
||||
#include "gen.cpp"
|
||||
|
||||
using namespace gen;
|
||||
|
||||
global s32 g_failures = 0;
|
||||
|
||||
internal inline void expect(int condition, Str label) {
|
||||
if (condition == false) { log_fmt("FAIL %S\n", label); ++ g_failures; }
|
||||
}
|
||||
|
||||
internal inline Token canary_at(Str text) {
|
||||
Token tok = NullToken;
|
||||
tok.Type = Tok_Comma;
|
||||
tok.Text = text;
|
||||
tok.Line = 99;
|
||||
tok.Column = 99;
|
||||
return tok;
|
||||
}
|
||||
|
||||
internal inline Token ident(Str text) {
|
||||
Token tok = NullToken;
|
||||
tok.Type = Tok_Identifier;
|
||||
tok.Text = text;
|
||||
tok.Line = 1;
|
||||
tok.Column = 1;
|
||||
return tok;
|
||||
}
|
||||
|
||||
internal b32 canaries_intact(Token* storage, s32 logical) {
|
||||
Token expected = canary_at(txt("CANARY"));
|
||||
for (s32 id = 0; id < 3; ++id) {
|
||||
Token got = storage[logical + id];
|
||||
if (got.Type != expected.Type || got.Text.Ptr != expected.Text.Ptr || got.Line != 99)
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
internal inline b32 points_at_canary(Token* got, Token* storage, s32 logical) {
|
||||
return got == & storage[logical] || got == & storage[logical + 1] || got == & storage[logical + 2];
|
||||
}
|
||||
|
||||
internal void plant(Token* storage, s32 logical, Token* src, s32 src_num) {
|
||||
for (s32 id = 0; id < src_num; ++id) storage[id] = src[id];
|
||||
for (s32 id = 0; id < 3; ++id) storage[logical + id] = canary_at(txt("CANARY"));
|
||||
}
|
||||
|
||||
internal void bind(ParseContext* parser, Token* storage, s32 logical, s32 token_id) {
|
||||
parser->tokens.ptr = storage;
|
||||
parser->tokens.num = logical;
|
||||
parser->token_id = token_id;
|
||||
parser->scope = nullptr;
|
||||
parser->messages = nullptr;
|
||||
}
|
||||
|
||||
internal void expect_helper(ParseContext* parser, Token* storage, s32 logical, Str label) {
|
||||
s32 before = parser->token_id;
|
||||
Token* cur = lex_current (parser, lex_dont_skip_formatting);
|
||||
Token* peek = lex_peek (parser, lex_dont_skip_formatting);
|
||||
Token* next = lex_next (parser, lex_dont_skip_formatting);
|
||||
Token* prev = lex_previous(parser, lex_dont_skip_formatting);
|
||||
expect(parser->token_id == before, label);
|
||||
expect(canaries_intact(storage, logical), label);
|
||||
expect(points_at_canary(cur, storage, logical) == false, label);
|
||||
expect(points_at_canary(peek, storage, logical) == false, label);
|
||||
expect(points_at_canary(next, storage, logical) == false, label);
|
||||
expect(points_at_canary(prev, storage, logical) == false, label);
|
||||
expect(cur != nullptr && peek != nullptr && next != nullptr && prev != nullptr, label);
|
||||
}
|
||||
|
||||
internal void expect_row_empty(Str label) {
|
||||
Token storage[3] = {}; plant(storage, 0, nullptr, 0);
|
||||
ParseContext parser = {}; bind(& parser, storage, 0, 0);
|
||||
expect_helper(& parser, storage, 0, label);
|
||||
expect(lex_current (& parser, lex_dont_skip_formatting)->Type == Tok_Invalid, label);
|
||||
expect(lex_peek (& parser, lex_dont_skip_formatting)->Type == Tok_Invalid, label);
|
||||
expect(lex_next (& parser, lex_dont_skip_formatting)->Type == Tok_Invalid, label);
|
||||
expect(lex_previous(& parser, lex_dont_skip_formatting)->Type == Tok_Invalid, label);
|
||||
}
|
||||
|
||||
internal void expect_row_single(Str label) {
|
||||
Token src [1] = { ident(txt("only")) };
|
||||
Token storage[4] = {}; plant(storage, 1, src, 1);
|
||||
ParseContext parser = {}; bind(& parser, storage, 1, 0);
|
||||
expect_helper(& parser, storage, 1, label);
|
||||
expect(lex_current (& parser, lex_dont_skip_formatting)->Text.Ptr == src[0].Text.Ptr, label);
|
||||
expect(lex_peek (& parser, lex_dont_skip_formatting)->Text.Ptr == src[0].Text.Ptr, label);
|
||||
expect(lex_next (& parser, lex_dont_skip_formatting)->Type == Tok_Invalid, label);
|
||||
expect(lex_previous(& parser, lex_dont_skip_formatting)->Type == Tok_Invalid, label);
|
||||
}
|
||||
|
||||
internal void expect_row_ends(Str label) {
|
||||
Token src [2] = { ident(txt("first")), ident(txt("last")) };
|
||||
Token storage[5] = {}; plant(storage, 2, src, 2);
|
||||
|
||||
ParseContext parser = {};
|
||||
bind(& parser, storage, 2, 0);
|
||||
expect_helper(& parser, storage, 2, label);
|
||||
expect(lex_current (& parser, lex_dont_skip_formatting)->Text.Ptr == src[0].Text.Ptr, label);
|
||||
expect(lex_next (& parser, lex_dont_skip_formatting)->Text.Ptr == src[1].Text.Ptr, label);
|
||||
expect(lex_previous(& parser, lex_dont_skip_formatting)->Type == Tok_Invalid, label);
|
||||
|
||||
bind(& parser, storage, 2, 1);
|
||||
expect_helper(& parser, storage, 2, label);
|
||||
expect(lex_current (& parser, lex_dont_skip_formatting)->Text.Ptr == src[1].Text.Ptr, label);
|
||||
expect(lex_next (& parser, lex_dont_skip_formatting)->Type == Tok_Invalid, label);
|
||||
expect(lex_previous(& parser, lex_dont_skip_formatting)->Text.Ptr == src[0].Text.Ptr, label);
|
||||
|
||||
bind(& parser, storage, 2, 2);
|
||||
expect_helper(& parser, storage, 2, label);
|
||||
expect(lex_current (& parser, lex_dont_skip_formatting)->Type == Tok_Invalid, label);
|
||||
expect(lex_peek (& parser, lex_dont_skip_formatting)->Type == Tok_Invalid, label);
|
||||
expect(lex_next (& parser, lex_dont_skip_formatting)->Type == Tok_Invalid, label);
|
||||
expect(lex_previous(& parser, lex_dont_skip_formatting)->Text.Ptr == src[1].Text.Ptr, label);
|
||||
}
|
||||
|
||||
internal void expect_skip_end(Str label)
|
||||
{
|
||||
Token newlines[2] = { NullToken, NullToken };
|
||||
newlines[0].Type = Tok_NewLine; newlines[0].Text = txt("\n");
|
||||
newlines[1].Type = Tok_NewLine; newlines[1].Text = txt("\n");
|
||||
Token storage[5] = {}; plant(storage, 2, newlines, 2);
|
||||
|
||||
ParseContext parser = {}; bind(& parser, storage, 2, 0);
|
||||
Token* got = lex_current(&parser, lex_skip_formatting);
|
||||
expect(got->Type == Tok_Invalid, label);
|
||||
expect(parser.token_id == 2, label);
|
||||
expect(canaries_intact(storage, 2), label);
|
||||
expect(points_at_canary(got, storage, 2) == false, label);
|
||||
|
||||
bind(& parser, storage, 2, 0); got = lex_peek(&parser, lex_skip_formatting);
|
||||
expect(parser.token_id == 0, label);
|
||||
expect(got->Type == Tok_Invalid, label);
|
||||
expect(canaries_intact(storage, 2), label);
|
||||
|
||||
Token comments[1] = { NullToken };
|
||||
comments[0].Type = Tok_Comment; comments[0].Text = txt("// note");
|
||||
plant(storage, 1, comments, 1); bind(& parser, storage, 1, 0);
|
||||
got = lex_current(&parser, lex_skip_formatting);
|
||||
expect(got->Type == Tok_Invalid, label);
|
||||
expect(parser.token_id == 1, label);
|
||||
expect(canaries_intact(storage, 1), label);
|
||||
expect(points_at_canary(got, storage, 1) == false, label);
|
||||
}
|
||||
|
||||
internal void expect_boundary(Str def, Str label, Str mark) {
|
||||
Context ctx = {};
|
||||
init(&ctx);
|
||||
CodeVar parsed = parse_variable(def);
|
||||
expect(cast(Code, parsed) == Code_Invalid, label);
|
||||
expect(_ctx->parser.messages != nullptr, label);
|
||||
expect(_ctx->parser.messages->Scope == nullptr, label);
|
||||
expect(_ctx->parser.messages->Content.Ptr != nullptr && _ctx->parser.messages->Content.Len > 0, label);
|
||||
expect(str_contains(_ctx->parser.messages->Content, mark), label);
|
||||
CodeVar again = parse_variable(txt("char const* baseline_message = \"GENCPP_BASELINE\";"));
|
||||
expect(again.ast != nullptr, label);
|
||||
if (again.ast != nullptr) {
|
||||
expect(again->Type == CT_Variable, label);
|
||||
expect(str_contains(again->Name, txt("baseline_message")), label);
|
||||
}
|
||||
deinit(&ctx);
|
||||
}
|
||||
|
||||
internal void expect_eat_end(Str label) {
|
||||
Context ctx = {}; init(&ctx);
|
||||
Token src [1] = { ident(txt("x")) };
|
||||
Token storage[4] = {};
|
||||
plant(storage, 1, src, 1); bind(& ctx.parser, storage, 1, 1);
|
||||
b32 ate = lex__eat(&ctx, & ctx.parser, Tok_Identifier);
|
||||
expect(ate == false, label);
|
||||
expect(ctx.parser.token_id <= ctx.parser.tokens.num, label);
|
||||
expect(canaries_intact(storage, 1), label);
|
||||
deinit(& ctx);
|
||||
}
|
||||
|
||||
internal void expect_direct(Str label) {
|
||||
Context ctx = {}; init(& ctx);
|
||||
Token src [2] = { ident(txt("int")), ident(txt("name")) };
|
||||
Token storage[5] = {}; plant(storage, 2, src, 2);
|
||||
bind(& ctx.parser, storage, 2, 0);
|
||||
Code got = parse_operator_function_or_variable(& ctx, false, NullCode, NullCode);
|
||||
expect(canaries_intact(storage, 2), label);
|
||||
(void)got;
|
||||
|
||||
Token op[2] = {};
|
||||
op[0] = NullToken;
|
||||
op[0].Type = Tok_Decl_Operator;
|
||||
op[0].Text = txt("operator");
|
||||
op[0].Line = 1;
|
||||
op[1] = ident(operator_to_str(Op_Delete));
|
||||
plant(storage, 2, op, 2);
|
||||
ctx.parser = {}; bind(& ctx.parser, storage, 2, 0);
|
||||
CodeOperator op_got = parse_operator_after_ret_type(& ctx, ModuleFlag_None, NullCode, NullCode, NullCode);
|
||||
expect(cast(Code, op_got) == Code_Invalid, label);
|
||||
expect(canaries_intact(storage, 2), label);
|
||||
deinit(& ctx);
|
||||
}
|
||||
|
||||
internal void expect_builder(Str label) {
|
||||
Token storage[3] = {}; plant(storage, 0, nullptr, 0);
|
||||
ParseContext parser = {}; bind(& parser, storage, 0, 0);
|
||||
StrBuilder built = parser_to_strbuilder(& parser, _ctx->Allocator_Temp);
|
||||
Str text = strbuilder_to_str(built);
|
||||
expect(str_contains(text, txt("empty")), label);
|
||||
expect(canaries_intact(storage, 0), label);
|
||||
strbuilder_free(& built);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
using namespace gen;
|
||||
Context ctx = {}; init(& ctx);
|
||||
expect_row_empty (txt("empty"));
|
||||
expect_row_single(txt("single"));
|
||||
expect_row_ends (txt("ends"));
|
||||
expect_skip_end (txt("skip"));
|
||||
expect_builder (txt("builder"));
|
||||
deinit(& ctx);
|
||||
|
||||
Str null_def = { nullptr, 0 };
|
||||
Str null_ptr = { nullptr, 4 };
|
||||
expect_boundary(null_def, txt("null-len"), txt("gen::parse_variable: length must greater than 0"));
|
||||
expect_boundary(null_ptr, txt("null-ptr"), txt("gen::parse_variable: def was null"));
|
||||
expect_boundary(txt(""), txt("zero-len"), txt("gen::parse_variable: length must greater than 0"));
|
||||
expect_boundary(txt(" \n\t"), txt("whitespace"), txt("no tokens found"));
|
||||
expect_boundary(txt("// note\n"), txt("comment"), txt("only formatting tokens"));
|
||||
expect_eat_end (txt("eat"));
|
||||
expect_direct (txt("direct"));
|
||||
|
||||
if (g_failures != 0) {
|
||||
log_fmt("parser bounds failed: %d\n", g_failures); return 1;
|
||||
}
|
||||
log_fmt("parser bounds passed\n");
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
#define GEN_IMPLEMENTATION
|
||||
#define GEN_DEFINE_LIBRARY_CODE_CONSTANTS
|
||||
#define GEN_ENFORCE_STRONG_CODE_TYPES
|
||||
#include "gen.hpp"
|
||||
|
||||
int main()
|
||||
{
|
||||
gen::log_fmt("FAIL forced assertion\n");
|
||||
return 1;
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
int main( {
|
||||
return 1;
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
@echo off
|
||||
exit /b 1
|
||||
@@ -0,0 +1,7 @@
|
||||
extern "C" void baseline_missing_link_target(void);
|
||||
|
||||
int main()
|
||||
{
|
||||
baseline_missing_link_target();
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
int main(void)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
int main(void)
|
||||
{
|
||||
return 73;
|
||||
}
|
||||
Reference in new issue
Block a user