mirror of
https://github.com/Ed94/gencpp.git
synced 2025-04-02 15:17:57 -07:00
Ed_
1c7dd4ab32
Lexer tokens now tracked using TokenSlice. ParserContext as the id for current token during traversal. Last progress on errors needs updates to interface.parsing.cpp Not adding message support yet as that will need to revamped with the logging, right now just focused on getting both lexer on parser to use proper info data structures. Thinking of separating ParseContext from the general lib Context, plan is to just have the parser context have its allocator and other references it needs. So there will seem to be redundant parameter passing to some procedures for now. The big endgoal of this other than the parser's compression is the ability to support mult-threading. Immediate concern other than making sure everything necessary is only within ParseContext, etc is things related to logging, or otherwise that is not thread dependent. Those can get guarded but I don't have full intuition on what will have that (most likely the library's provided allocator/s as well will need guards introduced). I'll concern myself more with charting those out once things are at least lifted properly. Worst case a trivial situation can be achived by the user by just abusing multiple contextes/allocators/etc as we already have in place.
447 lines
8.5 KiB
C++
447 lines
8.5 KiB
C++
#ifdef INTELLISENSE_DIRECTIVES
|
|
#pragma once
|
|
#include "gen/etoktype.hpp"
|
|
#include "interface.upfront.cpp"
|
|
#include "lexer.cpp"
|
|
#include "parser.cpp"
|
|
#endif
|
|
|
|
// Publically Exposed Interface
|
|
|
|
ParseInfo wip_parse_str(LexedInfo lexed, ParseOpts* opts)
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
if (lexed.tokens.num == 0 && lexed.tokens.ptr == nullptr) {
|
|
check_parse_args(lexed.text);
|
|
lexed = lex(ctx, lexed.text);
|
|
}
|
|
ParseInfo info = struct_zero(ParseInfo);
|
|
info.lexed = lexed;
|
|
|
|
// TODO(Ed): ParseInfo should be set to the parser context.
|
|
|
|
ctx->parser.tokens = lexed.tokens;
|
|
|
|
ParseStackNode scope = NullScope;
|
|
parser_push(& ctx->parser, & scope);
|
|
|
|
CodeBody result = parse_global_nspace(ctx,CT_Global_Body);
|
|
|
|
parser_pop(& ctx->parser);
|
|
return info;
|
|
}
|
|
|
|
CodeClass parse_class( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
|
|
ParseStackNode scope = NullScope;
|
|
parser_push(& ctx->parser, & scope);
|
|
|
|
CodeClass result = (CodeClass) parse_class_struct( ctx, Tok_Decl_Class, parser_not_inplace_def );
|
|
|
|
parser_pop(& ctx->parser);
|
|
return result;
|
|
}
|
|
|
|
CodeConstructor parse_constructor(Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
// TODO(Ed): Constructors can have prefix attributes
|
|
|
|
CodeSpecifiers specifiers = NullCode;
|
|
Specifier specs_found[ 16 ] = { Spec_NumSpecifiers };
|
|
s32 NumSpecifiers = 0;
|
|
|
|
while ( left && tok_is_specifier(currtok) )
|
|
{
|
|
Specifier spec = str_to_specifier( currtok.Text );
|
|
|
|
b32 ignore_spec = false;
|
|
|
|
switch ( spec )
|
|
{
|
|
case Spec_Constexpr :
|
|
case Spec_Explicit:
|
|
case Spec_Inline :
|
|
case Spec_ForceInline :
|
|
case Spec_NeverInline :
|
|
break;
|
|
|
|
case Spec_Const :
|
|
ignore_spec = true;
|
|
break;
|
|
|
|
default :
|
|
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);
|
|
return InvalidCode;
|
|
}
|
|
|
|
// Every specifier after would be considered part of the type type signature
|
|
if (ignore_spec)
|
|
break;
|
|
|
|
specs_found[ NumSpecifiers ] = spec;
|
|
NumSpecifiers++;
|
|
eat( currtok.Type );
|
|
}
|
|
|
|
if ( NumSpecifiers )
|
|
{
|
|
specifiers = def_specifiers_arr( NumSpecifiers, specs_found );
|
|
// <specifiers> ...
|
|
}
|
|
|
|
ctx->parser.Tokens = toks;
|
|
CodeConstructor result = parser_parse_constructor(ctx, specifiers);
|
|
return result;
|
|
}
|
|
|
|
CodeDefine parse_define( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
|
|
ParseStackNode scope = NullScope;
|
|
parser_push(& ctx->parser, & scope);
|
|
|
|
CodeDefine result = parser_parse_define(ctx);
|
|
|
|
parser_pop(& ctx->parser);
|
|
return result;
|
|
}
|
|
|
|
CodeDestructor parse_destructor( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
// TODO(Ed): Destructors can have prefix attributes
|
|
// TODO(Ed): Destructors can have virtual
|
|
|
|
ctx->parser.Tokens = toks;
|
|
CodeDestructor result = parser_parse_destructor(ctx, NullCode);
|
|
return result;
|
|
}
|
|
|
|
CodeEnum parse_enum( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
ParseStackNode scope = NullScope;
|
|
parser_push(& ctx->parser, & scope);
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
{
|
|
parser_pop(& ctx->parser);
|
|
return InvalidCode;
|
|
}
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return parser_parse_enum(ctx, parser_not_inplace_def);
|
|
}
|
|
|
|
CodeBody parse_export_body( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return parser_parse_export_body(ctx);
|
|
}
|
|
|
|
CodeExtern parse_extern_link( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return parser_parse_extern_link(ctx);
|
|
}
|
|
|
|
CodeFriend parse_friend( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return parser_parse_friend(ctx);
|
|
}
|
|
|
|
CodeFn parse_function( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return (CodeFn) parser_parse_function(ctx);
|
|
}
|
|
|
|
CodeBody parse_global_body( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
|
|
ParseStackNode scope = NullScope;
|
|
parser_push(& ctx->parser, & scope);
|
|
|
|
CodeBody result = parse_global_nspace(ctx, CT_Global_Body );
|
|
|
|
parser_pop(& ctx->parser);
|
|
return result;
|
|
}
|
|
|
|
CodeNS parse_namespace( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return parser_parse_namespace(ctx);
|
|
}
|
|
|
|
CodeOperator parse_operator( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return (CodeOperator) parser_parse_operator(ctx);
|
|
}
|
|
|
|
CodeOpCast parse_operator_cast( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return parser_parse_operator_cast(ctx, NullCode);
|
|
}
|
|
|
|
CodeStruct parse_struct( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
|
|
ParseStackNode scope = NullScope;
|
|
parser_push(& ctx->parser, & scope);
|
|
|
|
CodeStruct result = (CodeStruct) parse_class_struct( ctx, Tok_Decl_Struct, parser_not_inplace_def );
|
|
|
|
parser_pop(& ctx->parser);
|
|
return result;
|
|
}
|
|
|
|
CodeTemplate parse_template( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return parser_parse_template(ctx);
|
|
}
|
|
|
|
CodeTypename parse_type( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return parser_parse_type( ctx, parser_not_from_template, nullptr);
|
|
}
|
|
|
|
CodeTypedef parse_typedef( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return parser_parse_typedef(ctx);
|
|
}
|
|
|
|
CodeUnion parse_union( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return parser_parse_union(ctx, parser_not_inplace_def);
|
|
}
|
|
|
|
CodeUsing parse_using( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return parser_parse_using(ctx);
|
|
}
|
|
|
|
CodeVar parse_variable( Str def )
|
|
{
|
|
// TODO(Ed): Lift this.
|
|
Context* ctx = _ctx;
|
|
|
|
check_parse_args( def );
|
|
|
|
TokArray toks = lex( def );
|
|
if ( toks.Arr == nullptr )
|
|
return InvalidCode;
|
|
|
|
ctx->parser.Tokens = toks;
|
|
return parser_parse_variable(ctx);
|
|
}
|
|
|
|
// Undef helper macros
|
|
#undef check_parse_args
|
|
#undef currtok_noskip
|
|
#undef currtok
|
|
#undef peektok
|
|
#undef prevtok
|
|
#undef nexttok
|
|
#undef nexttok_noskip
|
|
#undef eat
|
|
#undef left
|
|
#undef check
|
|
#undef push_scope
|
|
#undef NullScope
|
|
#undef def_assign
|
|
|
|
// Here for C Variant
|
|
#undef lex_dont_skip_formatting
|
|
#undef lex_skip_formatting
|
|
|
|
#undef parser_inplace_def
|
|
#undef parser_not_inplace_def
|
|
#undef parser_dont_consume_braces
|
|
#undef parser_consume_braces
|
|
#undef parser_not_from_template
|
|
#undef parser_use_parenthesis
|
|
#undef parser_strip_formatting_dont_preserve_newlines
|