From 69153bb13fc7d0cb6d08f059909e484ecea6e5e7 Mon Sep 17 00:00:00 2001 From: Brendan Hansen Date: Fri, 17 Jul 2020 08:45:05 -0500 Subject: [PATCH] Code cleanup --- include/onyxastnodes.h | 120 +++++++++++++++-------------- include/onyxsempass.h | 20 ++--- onyx | Bin 240984 -> 246824 bytes src/onyx.c | 15 +--- src/onyxchecker.c | 168 ++++++++++++++++++++--------------------- src/onyxparser.c | 112 +++++++++++++-------------- src/onyxsempass.c | 14 ++-- src/onyxsymres.c | 152 ++++++++++++++++++------------------- src/onyxwasm.c | 52 ++++++------- 9 files changed, 327 insertions(+), 326 deletions(-) diff --git a/include/onyxastnodes.h b/include/onyxastnodes.h index 7f6278f0..78f484c2 100644 --- a/include/onyxastnodes.h +++ b/include/onyxastnodes.h @@ -4,8 +4,6 @@ #include "onyxlex.h" #include "onyxtypes.h" -typedef struct AstNode AstNode; -typedef struct AstTyped AstTyped; typedef struct AstUnaryOp AstUnaryOp; typedef struct AstBinOp AstBinaryOp; typedef struct AstAssign AstAssign; @@ -21,7 +19,6 @@ typedef struct AstIf AstIf; typedef struct AstWhile AstWhile; typedef struct AstLocalGroup AstLocalGroup; -typedef struct AstType AstType; typedef struct AstBasicType AstBasicType; typedef struct AstPointerType AstPointerType; typedef struct AstFunctionType AstFunctionType; @@ -115,50 +112,69 @@ typedef enum BinaryOp { // arguments existing in AstNode. I do this to avoid a nested // "inheiritance" where you would have to say node.base.base.next // for example -struct AstNode { - AstKind kind; - u32 flags; - OnyxToken *token; - AstNode *next; -}; -struct AstTyped { - AstKind kind; - u32 flags; - OnyxToken *token; - AstNode *next; - - // NOTE: 'type_node' is filled out by the parser. - // For a type such as '^^i32', the tree would look something like - // - // Typed Thing -> AstPointerType -> AstPointerType -> AstNode (symbol node) - // - // The symbol node will be filled out during symbol resolution. - // It will end up pointing to an AstBasicType that corresponds to - // the underlying type. - // - // 'type' is filled out afterwards. If it is NULL, the Type* is built - // using the type_node. This can then be used to typecheck this node. - AstType *type_node; - Type *type; +#define AstNode_members { \ + AstKind kind; \ + u32 flags; \ + OnyxToken *token; \ + AstNode *next; \ }; +#define AstNode_base struct AstNode_members; + +typedef struct AstNode AstNode; +struct AstNode AstNode_members; + +// Type Nodes +// NOTE: This node is very similar to an AstNode, just +// without the 'next' member. This is because types +// can't be in expressions so a 'next' thing +// doesn't make sense. +#define AstType_members { AstKind kind; u32 flags; char* name; } +#define AstType_base struct AstType_members; + +typedef struct AstType AstType; +struct AstType AstType_members; + +// NOTE: 'type_node' is filled out by the parser. \ +// For a type such as '^^i32', the tree would look something like +// +// Typed Thing -> AstPointerType -> AstPointerType -> AstNode (symbol node) +// +// The symbol node will be filled out during symbol resolution. +// It will end up pointing to an AstBasicType that corresponds to +// the underlying type. +// +// 'type' is filled out afterwards. If it is NULL, the Type* is built +// using the type_node. This can then be used to typecheck this node. +#define AstTyped_members { \ + AstKind kind; \ + u32 flags; \ + OnyxToken *token; \ + AstNode *next; \ + AstType *type_node; \ + Type *type; \ +} +#define AstTyped_base struct AstTyped_members; + +typedef struct AstTyped AstTyped; +struct AstTyped AstTyped_members; // Expression Nodes -struct AstBinOp { AstTyped base; BinaryOp operation; AstTyped *left, *right; }; -struct AstUnaryOp { AstTyped base; UnaryOp operation; AstTyped *expr; }; -struct AstAssign { AstNode base; AstTyped* lval; AstTyped* expr; }; -struct AstNumLit { AstTyped base; union { i32 i; i64 l; f32 f; f64 d; } value; }; -struct AstLocal { AstTyped base; AstLocal *prev_local; }; -struct AstReturn { AstNode base; AstTyped* expr; }; -struct AstCall { AstTyped base; AstArgument *arguments; AstNode *callee; }; -struct AstArgument { AstTyped base; AstTyped *value; }; +struct AstBinOp { AstTyped_base; BinaryOp operation; AstTyped *left, *right; }; +struct AstUnaryOp { AstTyped_base; UnaryOp operation; AstTyped *expr; }; +struct AstAssign { AstNode_base; AstTyped* lval; AstTyped* expr; }; +struct AstNumLit { AstTyped_base; union { i32 i; i64 l; f32 f; f64 d; } value; }; +struct AstLocal { AstTyped_base; AstLocal *prev_local; }; +struct AstReturn { AstNode_base; AstTyped* expr; }; +struct AstCall { AstTyped_base; AstArgument *arguments; AstNode *callee; }; +struct AstArgument { AstTyped_base; AstTyped *value; }; // Structure Nodes -struct AstLocalGroup { AstNode base; AstLocalGroup *prev_group; AstLocal *last_local; }; -struct AstBlock { AstNode base; AstNode *body; AstLocalGroup *locals; }; -struct AstWhile { AstNode base; AstTyped *cond; AstBlock *body; }; +struct AstLocalGroup { AstNode_base; AstLocalGroup *prev_group; AstLocal *last_local; }; +struct AstBlock { AstNode_base; AstNode *body; AstLocalGroup *locals; }; +struct AstWhile { AstNode_base; AstTyped *cond; AstBlock *body; }; struct AstIf { - AstNode base; + AstNode_base; AstTyped *cond; union { @@ -167,22 +183,16 @@ struct AstIf { } true_block, false_block; }; -// Type Nodes -// NOTE: This node is very similar to an AstNode, just -// without the 'next' member. This is because types -// can't be in expressions so a 'next' thing -// doesn't make sense. -struct AstType { AstKind kind; u32 flags; char* name; }; -struct AstBasicType { AstType base; Type* type; }; -struct AstPointerType { AstType base; AstType* elem; }; -struct AstFunctionType { AstType base; AstType* return_type; u64 param_count; AstType* params[]; }; +struct AstBasicType { AstType_base; Type* type; }; +struct AstPointerType { AstType_base; AstType* elem; }; +struct AstFunctionType { AstType_base; AstType* return_type; u64 param_count; AstType* params[]; }; // Top level nodes -struct AstBinding { AstTyped base; AstNode* node; }; -struct AstForeign { AstNode base; OnyxToken *mod_token, *name_token; AstNode *import; }; -struct AstUse { AstNode base; OnyxToken *filename; }; +struct AstBinding { AstTyped_base; AstNode* node; }; +struct AstForeign { AstNode_base; OnyxToken *mod_token, *name_token; AstNode *import; }; +struct AstUse { AstNode_base; OnyxToken *filename; }; struct AstGlobal { - AstTyped base; + AstTyped_base; union { // NOTE: Used when a global is exported with a specific name @@ -196,7 +206,7 @@ struct AstGlobal { }; }; struct AstFunction { - AstTyped base; + AstTyped_base; AstBlock *body; AstLocal *params; @@ -244,7 +254,7 @@ typedef enum OnyxIntrinsic { // NOTE: This needs to have 'arguments' in the // same position as AstNodeCall -struct AstIntrinsicCall { AstTyped base; AstArgument *arguments; OnyxIntrinsic intrinsic; }; +struct AstIntrinsicCall { AstTyped_base; AstArgument *arguments; OnyxIntrinsic intrinsic; }; // NOTE: Simple data structure for storing what comes out of the parser typedef struct ParserOutput { diff --git a/include/onyxsempass.h b/include/onyxsempass.h index c2d1a529..c5780fa6 100644 --- a/include/onyxsempass.h +++ b/include/onyxsempass.h @@ -7,12 +7,12 @@ #include "onyxastnodes.h" #include "onyxmsgs.h" -typedef struct SemPassSymbol { +typedef struct SemSymbol { AstNode *node; - struct SemPassSymbol *shadowed; -} SemPassSymbol; + struct SemSymbol *shadowed; +} SemSymbol; -typedef struct OnyxSemPassState { +typedef struct SemState { // NOTE: Adding node_allocator in case we need // to make any more node in the tree bh_allocator allocator, node_allocator; @@ -25,17 +25,17 @@ typedef struct OnyxSemPassState { Type* expected_return_type; // NOTE: All symbols a given point that we can resolve - bh_table(SemPassSymbol *) symbols; -} OnyxSemPassState; + bh_table(SemSymbol *) symbols; +} SemState; // NOTE: Resolving all symbols in the tree -void onyx_resolve_symbols(OnyxSemPassState* state, ParserOutput* program); +void onyx_resolve_symbols(SemState* state, ParserOutput* program); // NOTE: Inferring and checking types in the tree -void onyx_type_check(OnyxSemPassState* state, ParserOutput* program); +void onyx_type_check(SemState* state, ParserOutput* program); // NOTE: Full semantic pass -OnyxSemPassState onyx_sempass_create(bh_allocator alloc, bh_allocator node_alloc, OnyxMessages* msgs); -void onyx_sempass(OnyxSemPassState* state, ParserOutput* program); +SemState onyx_sempass_create(bh_allocator alloc, bh_allocator node_alloc, OnyxMessages* msgs); +void onyx_sempass(SemState* state, ParserOutput* program); #endif diff --git a/onyx b/onyx index fd4bedcb20862c19a59c7121606cc59296155794..6140e20321da21c08d85908a2aebca4de0e5cf56 100755 GIT binary patch delta 52999 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 delta 46975 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 bh_printf("[Checking semantics]\n"); - OnyxSemPassState sp_state = onyx_sempass_create(compiler_state->sp_alloc, compiler_state->ast_alloc, &compiler_state->msgs); + SemState sp_state = onyx_sempass_create(compiler_state->sp_alloc, compiler_state->ast_alloc, &compiler_state->msgs); onyx_sempass(&sp_state, &compiler_state->parse_output); if (onyx_message_has_errors(&compiler_state->msgs)) { @@ -266,17 +266,8 @@ int main(int argc, char *argv[]) { global_heap_allocator = bh_managed_heap_allocator(&global_heap); OnyxCompileOptions compile_opts = compile_opts_parse(global_heap_allocator, argc, argv); - CompilerState compile_state = { - .parse_output = { - .top_level_bindings = NULL, - .nodes_to_process = NULL, - - .functions = NULL, - .globals = NULL, - }, - .wasm_mod = { 0 } - }; + CompilerState compile_state = { 0 }; compiler_state_init(&compile_state, &compile_opts); CompilerProgress compiler_progress = ONYX_COMPILER_PROGRESS_FAILED_READ; diff --git a/src/onyxchecker.c b/src/onyxchecker.c index 05f34e44..a41720b7 100644 --- a/src/onyxchecker.c +++ b/src/onyxchecker.c @@ -1,20 +1,20 @@ #define BH_DEBUG #include "onyxsempass.h" -static b32 check_function(OnyxSemPassState* state, AstFunction* func); -static b32 check_block(OnyxSemPassState* state, AstBlock* block); -static b32 check_statement_chain(OnyxSemPassState* state, AstNode* start); -static b32 check_statement(OnyxSemPassState* state, AstNode* stmt); -static b32 check_assignment(OnyxSemPassState* state, AstAssign* assign); -static b32 check_return(OnyxSemPassState* state, AstReturn* retnode); -static b32 check_if(OnyxSemPassState* state, AstIf* ifnode); -static b32 check_while(OnyxSemPassState* state, AstWhile* whilenode); -static b32 check_call(OnyxSemPassState* state, AstCall* call); -static b32 check_binaryop(OnyxSemPassState* state, AstBinaryOp* binop); -static b32 check_expression(OnyxSemPassState* state, AstTyped* expr); -static b32 check_global(OnyxSemPassState* state, AstGlobal* global); - -static b32 check_assignment(OnyxSemPassState* state, AstAssign* assign) { +static b32 check_function(SemState* state, AstFunction* func); +static b32 check_block(SemState* state, AstBlock* block); +static b32 check_statement_chain(SemState* state, AstNode* start); +static b32 check_statement(SemState* state, AstNode* stmt); +static b32 check_assignment(SemState* state, AstAssign* assign); +static b32 check_return(SemState* state, AstReturn* retnode); +static b32 check_if(SemState* state, AstIf* ifnode); +static b32 check_while(SemState* state, AstWhile* whilenode); +static b32 check_call(SemState* state, AstCall* call); +static b32 check_binaryop(SemState* state, AstBinaryOp* binop); +static b32 check_expression(SemState* state, AstTyped* expr); +static b32 check_global(SemState* state, AstGlobal* global); + +static b32 check_assignment(SemState* state, AstAssign* assign) { if (assign->lval->kind == Ast_Kind_Symbol) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNRESOLVED_SYMBOL, @@ -26,7 +26,7 @@ static b32 check_assignment(OnyxSemPassState* state, AstAssign* assign) { if ((assign->lval->flags & Ast_Flag_Const) != 0 && assign->lval->type != NULL) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_ASSIGN_CONST, - assign->base.token->pos, + assign->token->pos, assign->lval->token->text, assign->lval->token->length); return 1; } @@ -34,7 +34,7 @@ static b32 check_assignment(OnyxSemPassState* state, AstAssign* assign) { if ((assign->lval->flags & Ast_Flag_Lval) == 0) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_NOT_LVAL, - assign->base.token->pos, + assign->token->pos, assign->lval->token->text, assign->lval->token->length); return 1; } @@ -51,7 +51,7 @@ static b32 check_assignment(OnyxSemPassState* state, AstAssign* assign) { if (!types_are_compatible(assign->lval->type, assign->expr->type)) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_ASSIGNMENT_TYPE_MISMATCH, - assign->base.token->pos, + assign->token->pos, type_get_name(assign->lval->type), type_get_name(assign->expr->type)); return 1; @@ -61,7 +61,7 @@ static b32 check_assignment(OnyxSemPassState* state, AstAssign* assign) { return 0; } -static b32 check_return(OnyxSemPassState* state, AstReturn* retnode) { +static b32 check_return(SemState* state, AstReturn* retnode) { if (retnode->expr) { if (check_expression(state, retnode->expr)) return 1; @@ -77,7 +77,7 @@ static b32 check_return(OnyxSemPassState* state, AstReturn* retnode) { if (state->expected_return_type->Basic.size > 0) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, - retnode->base.token->pos, + retnode->token->pos, "returning from non-void function without value"); return 1; } @@ -86,7 +86,7 @@ static b32 check_return(OnyxSemPassState* state, AstReturn* retnode) { return 0; } -static b32 check_if(OnyxSemPassState* state, AstIf* ifnode) { +static b32 check_if(SemState* state, AstIf* ifnode) { if (check_expression(state, ifnode->cond)) return 1; if (!type_is_bool(ifnode->cond->type)) { @@ -103,7 +103,7 @@ static b32 check_if(OnyxSemPassState* state, AstIf* ifnode) { return 0; } -static b32 check_while(OnyxSemPassState* state, AstWhile* whilenode) { +static b32 check_while(SemState* state, AstWhile* whilenode) { if (check_expression(state, whilenode->cond)) return 1; if (!type_is_bool(whilenode->cond->type)) { @@ -117,33 +117,33 @@ static b32 check_while(OnyxSemPassState* state, AstWhile* whilenode) { return check_block(state, whilenode->body); } -static b32 check_call(OnyxSemPassState* state, AstCall* call) { +static b32 check_call(SemState* state, AstCall* call) { AstFunction* callee = (AstFunction *) call->callee; - if (callee->base.kind == Ast_Kind_Symbol) { + if (callee->kind == Ast_Kind_Symbol) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNRESOLVED_SYMBOL, - callee->base.token->pos, - callee->base.token->text, callee->base.token->length); + callee->token->pos, + callee->token->text, callee->token->length); return 1; } - if (callee->base.type == NULL) { - callee->base.type = type_build_from_ast(state->node_allocator, callee->base.type_node); + if (callee->type == NULL) { + callee->type = type_build_from_ast(state->node_allocator, callee->type_node); } - if (callee->base.type->kind != Type_Kind_Function) { + if (callee->type->kind != Type_Kind_Function) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_CALL_NON_FUNCTION, - call->base.token->pos, - callee->base.token->text, callee->base.token->length); + call->token->pos, + callee->token->text, callee->token->length); return 1; } // NOTE: If we calling an intrinsic function, translate the // call into an intrinsic call node. - if (callee->base.flags & Ast_Flag_Intrinsic) { - call->base.kind = Ast_Kind_Intrinsic_Call; + if (callee->flags & Ast_Flag_Intrinsic) { + call->kind = Ast_Kind_Intrinsic_Call; call->callee = NULL; token_toggle_end(callee->intrinsic_name); @@ -203,7 +203,7 @@ static b32 check_call(OnyxSemPassState* state, AstCall* call) { token_toggle_end(callee->intrinsic_name); } - call->base.type = callee->base.type->Function.return_type; + call->type = callee->type->Function.return_type; AstLocal* formal_param = callee->params; AstArgument* actual_param = call->arguments; @@ -212,30 +212,30 @@ static b32 check_call(OnyxSemPassState* state, AstCall* call) { while (formal_param != NULL && actual_param != NULL) { if (check_expression(state, (AstTyped *) actual_param)) return 1; - if (formal_param->base.type == NULL) { - formal_param->base.type = type_build_from_ast(state->node_allocator, formal_param->base.type_node); + if (formal_param->type == NULL) { + formal_param->type = type_build_from_ast(state->node_allocator, formal_param->type_node); } - if (!types_are_compatible(formal_param->base.type, actual_param->base.type)) { + if (!types_are_compatible(formal_param->type, actual_param->type)) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_FUNCTION_PARAM_TYPE_MISMATCH, - actual_param->base.token->pos, - callee->base.token->text, callee->base.token->length, - type_get_name(formal_param->base.type), + actual_param->token->pos, + callee->token->text, callee->token->length, + type_get_name(formal_param->type), arg_pos, - type_get_name(actual_param->base.type)); + type_get_name(actual_param->type)); return 1; } arg_pos++; - formal_param = (AstLocal *) formal_param->base.next; - actual_param = (AstArgument *) actual_param->base.next; + formal_param = (AstLocal *) formal_param->next; + actual_param = (AstArgument *) actual_param->next; } if (formal_param != NULL && actual_param == NULL) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, - call->base.token->pos, + call->token->pos, "too few arguments to function call"); return 1; } @@ -243,7 +243,7 @@ static b32 check_call(OnyxSemPassState* state, AstCall* call) { if (formal_param == NULL && actual_param != NULL) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, - call->base.token->pos, + call->token->pos, "too many arguments to function call"); return 1; } @@ -251,14 +251,14 @@ static b32 check_call(OnyxSemPassState* state, AstCall* call) { return 0; } -static b32 check_binaryop(OnyxSemPassState* state, AstBinaryOp* binop) { +static b32 check_binaryop(SemState* state, AstBinaryOp* binop) { if (check_expression(state, binop->left)) return 1; if (check_expression(state, binop->right)) return 1; if (binop->left->type == NULL) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNRESOLVED_TYPE, - binop->base.token->pos, + binop->token->pos, NULL, 0); return 1; } @@ -266,7 +266,7 @@ static b32 check_binaryop(OnyxSemPassState* state, AstBinaryOp* binop) { if (binop->right->type == NULL) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNRESOLVED_TYPE, - binop->base.token->pos, + binop->token->pos, NULL, 0); return 1; } @@ -275,7 +275,7 @@ static b32 check_binaryop(OnyxSemPassState* state, AstBinaryOp* binop) { || type_is_pointer(binop->right->type)) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, - binop->base.token->pos, + binop->token->pos, "binary operations are not supported for pointers (yet)."); return 1; } @@ -283,7 +283,7 @@ static b32 check_binaryop(OnyxSemPassState* state, AstBinaryOp* binop) { if (!types_are_compatible(binop->left->type, binop->right->type)) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_BINOP_MISMATCH_TYPE, - binop->base.token->pos, + binop->token->pos, type_get_name(binop->left->type), type_get_name(binop->right->type)); return 1; @@ -291,15 +291,15 @@ static b32 check_binaryop(OnyxSemPassState* state, AstBinaryOp* binop) { if (binop->operation >= Binary_Op_Equal && binop->operation <= Binary_Op_Greater_Equal) { - binop->base.type = &basic_types[Basic_Kind_Bool]; + binop->type = &basic_types[Basic_Kind_Bool]; } else { - binop->base.type = binop->left->type; + binop->type = binop->left->type; } return 0; } -static b32 check_expression(OnyxSemPassState* state, AstTyped* expr) { +static b32 check_expression(SemState* state, AstTyped* expr) { if (expr->kind > Ast_Kind_Type_Start && expr->kind < Ast_Kind_Type_End) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, @@ -378,14 +378,14 @@ static b32 check_expression(OnyxSemPassState* state, AstTyped* expr) { return retval; } -static b32 check_global(OnyxSemPassState* state, AstGlobal* global) { - if (global->base.type == NULL) - global->base.type = type_build_from_ast(state->allocator, global->base.type_node); +static b32 check_global(SemState* state, AstGlobal* global) { + if (global->type == NULL) + global->type = type_build_from_ast(state->allocator, global->type_node); - if (global->base.type == NULL) { + if (global->type == NULL) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNRESOLVED_TYPE, - global->base.token->pos, + global->token->pos, global->exported_name->text, global->exported_name->length); @@ -395,7 +395,7 @@ static b32 check_global(OnyxSemPassState* state, AstGlobal* global) { return 0; } -static b32 check_statement(OnyxSemPassState* state, AstNode* stmt) { +static b32 check_statement(SemState* state, AstNode* stmt) { switch (stmt->kind) { case Ast_Kind_Assignment: return check_assignment(state, (AstAssign *) stmt); case Ast_Kind_Return: return check_return(state, (AstReturn *) stmt); @@ -408,7 +408,7 @@ static b32 check_statement(OnyxSemPassState* state, AstNode* stmt) { } } -static b32 check_statement_chain(OnyxSemPassState* state, AstNode* start) { +static b32 check_statement_chain(SemState* state, AstNode* start) { while (start) { if (check_statement(state, start)) return 1; start = start->next; @@ -417,15 +417,15 @@ static b32 check_statement_chain(OnyxSemPassState* state, AstNode* start) { return 0; } -static b32 check_block(OnyxSemPassState* state, AstBlock* block) { +static b32 check_block(SemState* state, AstBlock* block) { if (check_statement_chain(state, block->body)) return 1; forll(AstLocal, local, block->locals->last_local, prev_local) { - if (local->base.type == NULL) { + if (local->type == NULL) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNRESOLVED_TYPE, - local->base.token->pos, - local->base.token->text, local->base.token->length); + local->token->pos, + local->token->text, local->token->length); return 1; } } @@ -433,54 +433,54 @@ static b32 check_block(OnyxSemPassState* state, AstBlock* block) { return 0; } -static b32 check_function(OnyxSemPassState* state, AstFunction* func) { - for (AstLocal *param = func->params; param != NULL; param = (AstLocal *) param->base.next) { - if (param->base.type == NULL) { - param->base.type = type_build_from_ast(state->node_allocator, param->base.type_node); +static b32 check_function(SemState* state, AstFunction* func) { + for (AstLocal *param = func->params; param != NULL; param = (AstLocal *) param->next) { + if (param->type == NULL) { + param->type = type_build_from_ast(state->node_allocator, param->type_node); } - if (param->base.type == NULL) { + if (param->type == NULL) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, - param->base.token->pos, + param->token->pos, "function parameter types must be known"); return 1; } - if (param->base.type->Basic.size == 0) { + if (param->type->Basic.size == 0) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, - param->base.token->pos, + param->token->pos, "function parameters must have non-void types"); return 1; } } - if (func->base.type == NULL) { - func->base.type = type_build_from_ast(state->node_allocator, func->base.type_node); + if (func->type == NULL) { + func->type = type_build_from_ast(state->node_allocator, func->type_node); } - if ((func->base.flags & Ast_Flag_Exported) != 0) { - if ((func->base.flags & Ast_Flag_Foreign) != 0) { + if ((func->flags & Ast_Flag_Exported) != 0) { + if ((func->flags & Ast_Flag_Foreign) != 0) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, - func->base.token->pos, + func->token->pos, "exporting a foreign function"); return 1; } - if ((func->base.flags & Ast_Flag_Intrinsic) != 0) { + if ((func->flags & Ast_Flag_Intrinsic) != 0) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, - func->base.token->pos, + func->token->pos, "exporting a intrinsic function"); return 1; } - if ((func->base.flags & Ast_Flag_Inline) != 0) { + if ((func->flags & Ast_Flag_Inline) != 0) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, - func->base.token->pos, + func->token->pos, "exporting a inlined function"); return 1; } @@ -488,13 +488,13 @@ static b32 check_function(OnyxSemPassState* state, AstFunction* func) { if (func->exported_name == NULL) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, - func->base.token->pos, + func->token->pos, "exporting function without a name"); return 1; } } - state->expected_return_type = func->base.type->Function.return_type; + state->expected_return_type = func->type->Function.return_type; if (func->body) { return check_block(state, func->body); } @@ -502,7 +502,7 @@ static b32 check_function(OnyxSemPassState* state, AstFunction* func) { return 0; } -static b32 check_node(OnyxSemPassState* state, AstNode* node) { +static b32 check_node(SemState* state, AstNode* node) { switch (node->kind) { case Ast_Kind_Function: return check_function(state, (AstFunction *) node); case Ast_Kind_Block: return check_block(state, (AstBlock *) node); @@ -516,7 +516,7 @@ static b32 check_node(OnyxSemPassState* state, AstNode* node) { } } -void onyx_type_check(OnyxSemPassState* state, ParserOutput* program) { +void onyx_type_check(SemState* state, ParserOutput* program) { bh_arr_each(AstNode *, node, program->nodes_to_process) { check_node(state, *node); diff --git a/src/onyxparser.c b/src/onyxparser.c index a8ef82ec..6e860082 100644 --- a/src/onyxparser.c +++ b/src/onyxparser.c @@ -88,18 +88,18 @@ static OnyxToken* expect_token(OnyxParser* parser, TokenType token_type) { static AstNumLit* parse_numeric_literal(OnyxParser* parser) { AstNumLit* lit_node = make_node(AstNumLit, Ast_Kind_Literal); - lit_node->base.token = expect_token(parser, Token_Type_Literal_Numeric); - lit_node->base.flags |= Ast_Flag_Comptime; + lit_node->token = expect_token(parser, Token_Type_Literal_Numeric); + lit_node->flags |= Ast_Flag_Comptime; lit_node->value.l = 0ll; AstType* type; - token_toggle_end(lit_node->base.token); - char* tok = lit_node->base.token->text; + token_toggle_end(lit_node->token); + char* tok = lit_node->token->text; // NOTE: charset_contains() behaves more like string_contains() // so I'm using it in this case if (charset_contains(tok, '.')) { - if (tok[lit_node->base.token->length - 1] == 'f') { + if (tok[lit_node->token->length - 1] == 'f') { type = (AstType *) &basic_type_f32; lit_node->value.f = strtof(tok, NULL); } else { @@ -117,8 +117,8 @@ static AstNumLit* parse_numeric_literal(OnyxParser* parser) { lit_node->value.l = value; } - lit_node->base.type_node = type; - token_toggle_end(lit_node->base.token); + lit_node->type_node = type; + token_toggle_end(lit_node->token); return lit_node; } @@ -154,7 +154,7 @@ static AstTyped* parse_factor(OnyxParser* parser) { negate_node->expr = factor; if ((factor->flags & Ast_Flag_Comptime) != 0) { - negate_node->base.flags |= Ast_Flag_Comptime; + negate_node->flags |= Ast_Flag_Comptime; } retval = (AstTyped *) negate_node; @@ -165,11 +165,11 @@ static AstTyped* parse_factor(OnyxParser* parser) { { AstUnaryOp* not_node = make_node(AstUnaryOp, Ast_Kind_Unary_Op); not_node->operation = Unary_Op_Not; - not_node->base.token = expect_token(parser, '!'); + not_node->token = expect_token(parser, '!'); not_node->expr = parse_factor(parser); if ((not_node->expr->flags & Ast_Flag_Comptime) != 0) { - not_node->base.flags |= Ast_Flag_Comptime; + not_node->flags |= Ast_Flag_Comptime; } retval = (AstTyped *) not_node; @@ -189,19 +189,19 @@ static AstTyped* parse_factor(OnyxParser* parser) { // NOTE: Function call AstCall* call_node = make_node(AstCall, Ast_Kind_Call); - call_node->base.token = expect_token(parser, '('); + call_node->token = expect_token(parser, '('); call_node->callee = (AstNode *) sym_node; AstArgument** prev = &call_node->arguments; AstArgument* curr = NULL; while (parser->curr->type != ')') { curr = make_node(AstArgument, Ast_Kind_Argument); - curr->base.token = parser->curr; + curr->token = parser->curr; curr->value = parse_expression(parser); - if (curr != NULL && curr->base.kind != Ast_Kind_Error) { + if (curr != NULL && curr->kind != Ast_Kind_Error) { *prev = curr; - prev = (AstArgument **) &curr->base.next; + prev = (AstArgument **) &curr->next; } if (parser->curr->type == ')') @@ -231,8 +231,8 @@ static AstTyped* parse_factor(OnyxParser* parser) { case Token_Type_Literal_True: { AstNumLit* bool_node = make_node(AstNumLit, Ast_Kind_Literal); - bool_node->base.type_node = (AstType *) &basic_type_bool; - bool_node->base.token = expect_token(parser, Token_Type_Literal_True); + bool_node->type_node = (AstType *) &basic_type_bool; + bool_node->token = expect_token(parser, Token_Type_Literal_True); bool_node->value.i = 1; retval = (AstTyped *) bool_node; break; @@ -241,8 +241,8 @@ static AstTyped* parse_factor(OnyxParser* parser) { case Token_Type_Literal_False: { AstNumLit* bool_node = make_node(AstNumLit, Ast_Kind_Literal); - bool_node->base.type_node = (AstType *) &basic_type_bool; - bool_node->base.token = expect_token(parser, Token_Type_Literal_False); + bool_node->type_node = (AstType *) &basic_type_bool; + bool_node->token = expect_token(parser, Token_Type_Literal_False); bool_node->value.i = 0; retval = (AstTyped *) bool_node; break; @@ -260,7 +260,7 @@ static AstTyped* parse_factor(OnyxParser* parser) { consume_token(parser); AstUnaryOp* cast_node = make_node(AstUnaryOp, Ast_Kind_Unary_Op); - cast_node->base.type_node = parse_type(parser); + cast_node->type_node = parse_type(parser); cast_node->operation = Unary_Op_Cast; cast_node->expr = retval; retval = (AstTyped *) cast_node; @@ -338,7 +338,7 @@ static AstTyped* parse_expression(OnyxParser* parser) { AstBinaryOp* bin_op = make_node(AstBinaryOp, Ast_Kind_Binary_Op); bin_op->operation = bin_op_kind; - bin_op->base.token = bin_op_tok; + bin_op->token = bin_op_tok; while ( !bh_arr_is_empty(tree_stack) && get_precedence(bh_arr_last(tree_stack)->operation) >= get_precedence(bin_op_kind)) @@ -359,7 +359,7 @@ static AstTyped* parse_expression(OnyxParser* parser) { bin_op->right = right; if ((left->flags & Ast_Flag_Comptime) != 0 && (right->flags & Ast_Flag_Comptime) != 0) { - bin_op->base.flags |= Ast_Flag_Comptime; + bin_op->flags |= Ast_Flag_Comptime; } } } @@ -416,7 +416,7 @@ static AstWhile* parse_while_stmt(OnyxParser* parser) { AstBlock* body = parse_block(parser); AstWhile* while_node = make_node(AstWhile, Ast_Kind_While); - while_node->base.token = while_token; + while_node->token = while_token; while_node->cond = cond; while_node->body = body; @@ -453,19 +453,19 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) { } AstLocal* local = make_node(AstLocal, Ast_Kind_Local); - local->base.token = symbol; - local->base.type_node = type_node; - local->base.flags |= Ast_Flag_Lval; // NOTE: DELETE + local->token = symbol; + local->type_node = type_node; + local->flags |= Ast_Flag_Lval; // NOTE: DELETE *ret = (AstNode *) local; if (parser->curr->type == '=' || parser->curr->type == ':') { if (parser->curr->type == ':') { - local->base.flags |= Ast_Flag_Const; + local->flags |= Ast_Flag_Const; } AstAssign* assignment = make_node(AstAssign, Ast_Kind_Assignment); - local->base.next = (AstNode *) assignment; - assignment->base.token = parser->curr; + local->next = (AstNode *) assignment; + assignment->token = parser->curr; consume_token(parser); AstTyped* expr = parse_expression(parser); @@ -473,7 +473,7 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) { token_toggle_end(parser->curr); onyx_message_add(parser->msgs, ONYX_MESSAGE_TYPE_EXPECTED_EXPRESSION, - assignment->base.token->pos, + assignment->token->pos, parser->curr->text); token_toggle_end(parser->curr); return 1; @@ -491,7 +491,7 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) { case '=': { AstAssign* assignment = make_node(AstAssign, Ast_Kind_Assignment); - assignment->base.token = parser->curr; + assignment->token = parser->curr; consume_token(parser); AstNode* lval = make_node(AstNode, Ast_Kind_Symbol); @@ -519,7 +519,7 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) { AstBinaryOp* bin_op_node = make_node(AstBinaryOp, Ast_Kind_Binary_Op); bin_op_node->operation = bin_op; - bin_op_node->base.token = parser->curr; + bin_op_node->token = parser->curr; consume_token(parser); AstTyped* expr = parse_expression(parser); @@ -530,7 +530,7 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) { bin_op_node->right = expr; AstAssign* assign_node = make_node(AstAssign, Ast_Kind_Assignment); - assign_node->base.token = bin_op_node->base.token; + assign_node->token = bin_op_node->token; // TODO: Maybe I don't need to make another lval node? AstNode* lval = make_node(AstNode, Ast_Kind_Symbol); @@ -553,7 +553,7 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) { // 'return' ? static AstReturn* parse_return_statement(OnyxParser* parser) { AstReturn* return_node = make_node(AstReturn, Ast_Kind_Return); - return_node->base.token = expect_token(parser, Token_Type_Keyword_Return); + return_node->token = expect_token(parser, Token_Type_Keyword_Return); AstTyped* expr = NULL; @@ -688,7 +688,7 @@ static AstType* parse_type(OnyxParser* parser) { if (parser->curr->type == '^') { consume_token(parser); AstPointerType* new = make_node(AstPointerType, Ast_Kind_Pointer_Type); - new->base.flags |= Basic_Flag_Pointer; + new->flags |= Basic_Flag_Pointer; *next_insertion = (AstType *) new; next_insertion = &new->elem; } @@ -743,14 +743,14 @@ static AstLocal* parse_function_params(OnyxParser* parser) { expect_token(parser, ':'); curr_param = make_node(AstLocal, Ast_Kind_Param); - curr_param->base.token = symbol; - curr_param->base.flags |= Ast_Flag_Const; - curr_param->base.type_node = parse_type(parser); + curr_param->token = symbol; + curr_param->flags |= Ast_Flag_Const; + curr_param->type_node = parse_type(parser); if (first_param == NULL) first_param = curr_param; - curr_param->base.next = NULL; - if (trailer) trailer->base.next = (AstNode *) curr_param; + curr_param->next = NULL; + if (trailer) trailer->next = (AstNode *) curr_param; trailer = curr_param; } @@ -779,11 +779,11 @@ static b32 parse_possible_directive(OnyxParser* parser, const char* dir) { static AstFunction* parse_function_definition(OnyxParser* parser) { AstFunction* func_def = make_node(AstFunction, Ast_Kind_Function); - func_def->base.token = expect_token(parser, Token_Type_Keyword_Proc); + func_def->token = expect_token(parser, Token_Type_Keyword_Proc); while (parser->curr->type == '#') { if (parse_possible_directive(parser, "intrinsic")) { - func_def->base.flags |= Ast_Flag_Intrinsic; + func_def->flags |= Ast_Flag_Intrinsic; if (parser->curr->type == Token_Type_Literal_String) { OnyxToken* str_token = expect_token(parser, Token_Type_Literal_String); @@ -792,18 +792,18 @@ static AstFunction* parse_function_definition(OnyxParser* parser) { } else if (parse_possible_directive(parser, "inline")) { - func_def->base.flags |= Ast_Flag_Inline; + func_def->flags |= Ast_Flag_Inline; } else if (parse_possible_directive(parser, "foreign")) { func_def->foreign_module = expect_token(parser, Token_Type_Literal_String); func_def->foreign_name = expect_token(parser, Token_Type_Literal_String); - func_def->base.flags |= Ast_Flag_Foreign; + func_def->flags |= Ast_Flag_Foreign; } else if (parse_possible_directive(parser, "export")) { - func_def->base.flags |= Ast_Flag_Exported; + func_def->flags |= Ast_Flag_Exported; if (parser->curr->type == Token_Type_Literal_String) { OnyxToken* str_token = expect_token(parser, Token_Type_Literal_String); @@ -835,23 +835,23 @@ static AstFunction* parse_function_definition(OnyxParser* parser) { u64 param_count = 0; for (AstLocal* param = params; param != NULL; - param = (AstLocal *) param->base.next) + param = (AstLocal *) param->next) param_count++; AstFunctionType* type_node = bh_alloc(parser->allocator, sizeof(AstFunctionType) + param_count * sizeof(AstType *)); - type_node->base.kind = Ast_Kind_Function_Type; + type_node->kind = Ast_Kind_Function_Type; type_node->param_count = param_count; type_node->return_type = return_type; u32 i = 0; for (AstLocal* param = params; param != NULL; - param = (AstLocal *) param->base.next) { - type_node->params[i] = param->base.type_node; + param = (AstLocal *) param->next) { + type_node->params[i] = param->type_node; i++; } - func_def->base.type_node = (AstType *) type_node; + func_def->type_node = (AstType *) type_node; func_def->body = parse_block(parser); @@ -861,18 +861,18 @@ static AstFunction* parse_function_definition(OnyxParser* parser) { // 'global' static AstTyped* parse_global_declaration(OnyxParser* parser) { AstGlobal* global_node = make_node(AstGlobal, Ast_Kind_Global); - global_node->base.token = expect_token(parser, Token_Type_Keyword_Global); + global_node->token = expect_token(parser, Token_Type_Keyword_Global); while (parser->curr->type == '#') { if (parse_possible_directive(parser, "foreign")) { global_node->foreign_module = expect_token(parser, Token_Type_Literal_String); global_node->foreign_name = expect_token(parser, Token_Type_Literal_String); - global_node->base.flags |= Ast_Flag_Foreign; + global_node->flags |= Ast_Flag_Foreign; } else if (parse_possible_directive(parser, "export")) { - global_node->base.flags |= Ast_Flag_Exported; + global_node->flags |= Ast_Flag_Exported; if (parser->curr->type == Token_Type_Literal_String) { OnyxToken* str_token = expect_token(parser, Token_Type_Literal_String); @@ -891,8 +891,8 @@ static AstTyped* parse_global_declaration(OnyxParser* parser) { } } - global_node->base.type_node = parse_type(parser); - global_node->base.flags |= Ast_Flag_Lval; + global_node->type_node = parse_type(parser); + global_node->flags |= Ast_Flag_Lval; bh_arr_push(parser->results.nodes_to_process, (AstNode *) global_node); @@ -923,7 +923,7 @@ static AstNode* parse_top_level_statement(OnyxParser* parser) { case Token_Type_Keyword_Use: { AstUse* use_node = make_node(AstUse, Ast_Kind_Use); - use_node->base.token = expect_token(parser, Token_Type_Keyword_Use); + use_node->token = expect_token(parser, Token_Type_Keyword_Use); use_node->filename = expect_token(parser, Token_Type_Literal_String); return (AstNode *) use_node; @@ -957,7 +957,7 @@ static AstNode* parse_top_level_statement(OnyxParser* parser) { } AstBinding* binding = make_node(AstBinding, Ast_Kind_Binding); - binding->base.token = symbol; + binding->token = symbol; binding->node = (AstNode *) node; return (AstNode *) binding; diff --git a/src/onyxsempass.c b/src/onyxsempass.c index 68ea2e2d..bc1d8524 100644 --- a/src/onyxsempass.c +++ b/src/onyxsempass.c @@ -2,8 +2,8 @@ #include "onyxsempass.h" #include "onyxutils.h" -OnyxSemPassState onyx_sempass_create(bh_allocator alloc, bh_allocator node_alloc, OnyxMessages* msgs) { - OnyxSemPassState state = { +SemState onyx_sempass_create(bh_allocator alloc, bh_allocator node_alloc, OnyxMessages* msgs) { + SemState state = { .allocator = alloc, .node_allocator = node_alloc, @@ -23,13 +23,13 @@ OnyxSemPassState onyx_sempass_create(bh_allocator alloc, bh_allocator node_alloc // WASM, this function may not be needed. It brings all of the locals // defined in sub-scopes up to the function-block level. This is a // requirement of WASM, but not of other targets. -static void collapse_scopes(ParserOutput* program) { +static void hoist_locals(ParserOutput* program) { bh_arr(AstBlock*) traversal_queue = NULL; bh_arr_new(global_scratch_allocator, traversal_queue, 4); bh_arr_set_length(traversal_queue, 0); bh_arr_each(AstFunction *, func, program->functions) { - if ((*func)->base.flags & Ast_Flag_Intrinsic) continue; + if ((*func)->flags & Ast_Flag_Intrinsic) continue; AstLocalGroup* top_locals = (*func)->body->locals; @@ -37,7 +37,7 @@ static void collapse_scopes(ParserOutput* program) { while (!bh_arr_is_empty(traversal_queue)) { AstBlock* block = traversal_queue[0]; - if (block->base.kind == Ast_Kind_If) { + if (block->kind == Ast_Kind_If) { AstIf* if_node = (AstIf *) block; if (if_node->true_block.as_block != NULL) bh_arr_push(traversal_queue, if_node->true_block.as_block); @@ -81,12 +81,12 @@ static void collapse_scopes(ParserOutput* program) { } } -void onyx_sempass(OnyxSemPassState* state, ParserOutput* program) { +void onyx_sempass(SemState* state, ParserOutput* program) { onyx_resolve_symbols(state, program); if (onyx_message_has_errors(state->msgs)) return; onyx_type_check(state, program); if (onyx_message_has_errors(state->msgs)) return; - collapse_scopes(program); + hoist_locals(program); } diff --git a/src/onyxsymres.c b/src/onyxsymres.c index 2aa84b35..0db1bb0b 100644 --- a/src/onyxsymres.c +++ b/src/onyxsymres.c @@ -1,40 +1,40 @@ #define BH_DEBUG #include "onyxsempass.h" -static void symbol_introduce(OnyxSemPassState* state, OnyxToken* tkn, AstNode* symbol); -static void symbol_basic_type_introduce(OnyxSemPassState* state, AstBasicType* basic_type); -static b32 symbol_unique_introduce(OnyxSemPassState* state, OnyxToken* tkn, AstNode* symbol); -static void symbol_remove(OnyxSemPassState* state, OnyxToken* tkn); -static AstNode* symbol_resolve(OnyxSemPassState* state, OnyxToken* tkn); -static void local_group_enter(OnyxSemPassState* state, AstLocalGroup* local_group); -static void local_group_leave(OnyxSemPassState* state); - -static AstType* symres_type(OnyxSemPassState* state, AstType* type); -static void symres_local(OnyxSemPassState* state, AstLocal** local); -static void symres_call(OnyxSemPassState* state, AstCall* call); -static void symres_expression(OnyxSemPassState* state, AstTyped** expr); -static void symres_assignment(OnyxSemPassState* state, AstAssign* assign); -static void symres_return(OnyxSemPassState* state, AstReturn* ret); -static void symres_if(OnyxSemPassState* state, AstIf* ifnode); -static void symres_while(OnyxSemPassState* state, AstWhile* whilenode); -static void symres_statement_chain(OnyxSemPassState* state, AstNode* walker, AstNode** trailer); -static b32 symres_statement(OnyxSemPassState* state, AstNode* stmt); -static void symres_block(OnyxSemPassState* state, AstBlock* block); -static void symres_function(OnyxSemPassState* state, AstFunction* func); -static void symres_global(OnyxSemPassState* state, AstGlobal* global); - -static void symbol_introduce(OnyxSemPassState* state, OnyxToken* tkn, AstNode* symbol) { +static void symbol_introduce(SemState* state, OnyxToken* tkn, AstNode* symbol); +static void symbol_basic_type_introduce(SemState* state, AstBasicType* basic_type); +static b32 symbol_unique_introduce(SemState* state, OnyxToken* tkn, AstNode* symbol); +static void symbol_remove(SemState* state, OnyxToken* tkn); +static AstNode* symbol_resolve(SemState* state, OnyxToken* tkn); +static void local_group_enter(SemState* state, AstLocalGroup* local_group); +static void local_group_leave(SemState* state); + +static AstType* symres_type(SemState* state, AstType* type); +static void symres_local(SemState* state, AstLocal** local); +static void symres_call(SemState* state, AstCall* call); +static void symres_expression(SemState* state, AstTyped** expr); +static void symres_assignment(SemState* state, AstAssign* assign); +static void symres_return(SemState* state, AstReturn* ret); +static void symres_if(SemState* state, AstIf* ifnode); +static void symres_while(SemState* state, AstWhile* whilenode); +static void symres_statement_chain(SemState* state, AstNode* walker, AstNode** trailer); +static b32 symres_statement(SemState* state, AstNode* stmt); +static void symres_block(SemState* state, AstBlock* block); +static void symres_function(SemState* state, AstFunction* func); +static void symres_global(SemState* state, AstGlobal* global); + +static void symbol_introduce(SemState* state, OnyxToken* tkn, AstNode* symbol) { token_toggle_end(tkn); - SemPassSymbol* sp_sym = (SemPassSymbol *) bh_alloc_item(state->allocator, SemPassSymbol); + SemSymbol* sp_sym = (SemSymbol *) bh_alloc_item(state->allocator, SemSymbol); sp_sym->node = symbol; sp_sym->shadowed = NULL; - if (bh_table_has(SemPassSymbol *, state->symbols, tkn->text)) { - sp_sym->shadowed = bh_table_get(SemPassSymbol *, state->symbols, tkn->text); + if (bh_table_has(SemSymbol *, state->symbols, tkn->text)) { + sp_sym->shadowed = bh_table_get(SemSymbol *, state->symbols, tkn->text); } - bh_table_put(SemPassSymbol *, state->symbols, tkn->text, sp_sym); + bh_table_put(SemSymbol *, state->symbols, tkn->text, sp_sym); if (symbol->kind == Ast_Kind_Local) { AstLocal* local = (AstLocal *) symbol; @@ -45,27 +45,27 @@ static void symbol_introduce(OnyxSemPassState* state, OnyxToken* tkn, AstNode* s token_toggle_end(tkn); } -static void symbol_remove(OnyxSemPassState* state, OnyxToken* tkn) { +static void symbol_remove(SemState* state, OnyxToken* tkn) { token_toggle_end(tkn); - SemPassSymbol* sp_sym = bh_table_get(SemPassSymbol *, state->symbols, tkn->text); + SemSymbol* sp_sym = bh_table_get(SemSymbol *, state->symbols, tkn->text); if (sp_sym->shadowed) { - bh_table_put(SemPassSymbol *, state->symbols, tkn->text, sp_sym->shadowed); + bh_table_put(SemSymbol *, state->symbols, tkn->text, sp_sym->shadowed); } else { - bh_table_delete(SemPassSymbol *, state->symbols, tkn->text); + bh_table_delete(SemSymbol *, state->symbols, tkn->text); } token_toggle_end(tkn); } -static AstNode* symbol_resolve(OnyxSemPassState* state, OnyxToken* tkn) { +static AstNode* symbol_resolve(SemState* state, OnyxToken* tkn) { AstNode* res = NULL; while (res == NULL || res->kind == Ast_Kind_Symbol) { token_toggle_end(tkn); - if (!bh_table_has(SemPassSymbol *, state->symbols, tkn->text)) { + if (!bh_table_has(SemSymbol *, state->symbols, tkn->text)) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNKNOWN_SYMBOL, tkn->pos, @@ -75,7 +75,7 @@ static AstNode* symbol_resolve(OnyxSemPassState* state, OnyxToken* tkn) { return NULL; } - res = bh_table_get(SemPassSymbol *, state->symbols, tkn->text)->node; + res = bh_table_get(SemSymbol *, state->symbols, tkn->text)->node; token_toggle_end(tkn); tkn = res->token; @@ -84,37 +84,37 @@ static AstNode* symbol_resolve(OnyxSemPassState* state, OnyxToken* tkn) { return res; } -static void local_group_enter(OnyxSemPassState* state, AstLocalGroup* local_group) { +static void local_group_enter(SemState* state, AstLocalGroup* local_group) { local_group->prev_group = state->curr_local_group; state->curr_local_group = local_group; } -static void local_group_leave(OnyxSemPassState* state) { +static void local_group_leave(SemState* state) { assert(state->curr_local_group != NULL); for (AstLocal *walker = state->curr_local_group->last_local; walker != NULL; walker = walker->prev_local) { - symbol_remove(state, walker->base.token); + symbol_remove(state, walker->token); } state->curr_local_group = state->curr_local_group->prev_group; } -static void symbol_basic_type_introduce(OnyxSemPassState* state, AstBasicType* basic_type) { - SemPassSymbol* sp_sym = bh_alloc_item(state->allocator, SemPassSymbol); +static void symbol_basic_type_introduce(SemState* state, AstBasicType* basic_type) { + SemSymbol* sp_sym = bh_alloc_item(state->allocator, SemSymbol); sp_sym->node = (AstNode *) basic_type; sp_sym->shadowed = NULL; - bh_table_put(SemPassSymbol *, state->symbols, basic_type->base.name, sp_sym); + bh_table_put(SemSymbol *, state->symbols, basic_type->name, sp_sym); } -static b32 symbol_unique_introduce(OnyxSemPassState* state, OnyxToken* tkn, AstNode* symbol) { +static b32 symbol_unique_introduce(SemState* state, OnyxToken* tkn, AstNode* symbol) { token_toggle_end(tkn); // NOTE: If the function hasn't already been defined - if (!bh_table_has(SemPassSymbol *, state->symbols, tkn->text)) { - SemPassSymbol* sp_sym = bh_alloc_item(state->allocator, SemPassSymbol); + if (!bh_table_has(SemSymbol *, state->symbols, tkn->text)) { + SemSymbol* sp_sym = bh_alloc_item(state->allocator, SemSymbol); sp_sym->node = symbol; sp_sym->shadowed = NULL; - bh_table_put(SemPassSymbol *, state->symbols, tkn->text, sp_sym); + bh_table_put(SemSymbol *, state->symbols, tkn->text, sp_sym); } else { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_CONFLICTING_GLOBALS, @@ -130,7 +130,7 @@ static b32 symbol_unique_introduce(OnyxSemPassState* state, OnyxToken* tkn, AstN return 1; } -static AstType* symres_type(OnyxSemPassState* state, AstType* type) { +static AstType* symres_type(SemState* state, AstType* type) { if (type == NULL) return NULL; if (type->kind == Ast_Kind_Symbol) { @@ -162,12 +162,12 @@ static AstType* symres_type(OnyxSemPassState* state, AstType* type) { return NULL; } -static void symres_local(OnyxSemPassState* state, AstLocal** local) { - (*local)->base.type_node = symres_type(state, (*local)->base.type_node); - symbol_introduce(state, (*local)->base.token, (AstNode *) *local); +static void symres_local(SemState* state, AstLocal** local) { + (*local)->type_node = symres_type(state, (*local)->type_node); + symbol_introduce(state, (*local)->token, (AstNode *) *local); } -static void symres_call(OnyxSemPassState* state, AstCall* call) { +static void symres_call(SemState* state, AstCall* call) { AstNode* callee = symbol_resolve(state, call->callee->token); if (callee) call->callee = callee; @@ -184,15 +184,15 @@ static void symres_call(OnyxSemPassState* state, AstCall* call) { symres_statement_chain(state, (AstNode *) call->arguments, (AstNode **) &call->arguments); } -static void symres_unaryop(OnyxSemPassState* state, AstUnaryOp** unaryop) { +static void symres_unaryop(SemState* state, AstUnaryOp** unaryop) { if ((*unaryop)->operation == Unary_Op_Cast) { - (*unaryop)->base.type_node = symres_type(state, (*unaryop)->base.type_node); + (*unaryop)->type_node = symres_type(state, (*unaryop)->type_node); } symres_expression(state, &(*unaryop)->expr); } -static void symres_expression(OnyxSemPassState* state, AstTyped** expr) { +static void symres_expression(SemState* state, AstTyped** expr) { switch ((*expr)->kind) { case Ast_Kind_Binary_Op: symres_expression(state, &((AstBinaryOp *)(*expr))->left); @@ -225,7 +225,7 @@ static void symres_expression(OnyxSemPassState* state, AstTyped** expr) { } } -static void symres_assignment(OnyxSemPassState* state, AstAssign* assign) { +static void symres_assignment(SemState* state, AstAssign* assign) { AstTyped* lval = (AstTyped *) symbol_resolve(state, assign->lval->token); if (lval == NULL) return; assign->lval = lval; @@ -233,41 +233,41 @@ static void symres_assignment(OnyxSemPassState* state, AstAssign* assign) { symres_expression(state, &assign->expr); } -static void symres_return(OnyxSemPassState* state, AstReturn* ret) { +static void symres_return(SemState* state, AstReturn* ret) { if (ret->expr) symres_expression(state, &ret->expr); } -static void symres_if(OnyxSemPassState* state, AstIf* ifnode) { +static void symres_if(SemState* state, AstIf* ifnode) { symres_expression(state, &ifnode->cond); if (ifnode->true_block.as_if != NULL) { - if (ifnode->true_block.as_if->base.kind == Ast_Kind_Block) + if (ifnode->true_block.as_if->kind == Ast_Kind_Block) symres_block(state, ifnode->true_block.as_block); - else if (ifnode->true_block.as_if->base.kind == Ast_Kind_If) + else if (ifnode->true_block.as_if->kind == Ast_Kind_If) symres_if(state, ifnode->true_block.as_if); else DEBUG_HERE; } if (ifnode->false_block.as_if != NULL) { - if (ifnode->false_block.as_if->base.kind == Ast_Kind_Block) + if (ifnode->false_block.as_if->kind == Ast_Kind_Block) symres_block(state, ifnode->false_block.as_block); - else if (ifnode->false_block.as_if->base.kind == Ast_Kind_If) + else if (ifnode->false_block.as_if->kind == Ast_Kind_If) symres_if(state, ifnode->false_block.as_if); else DEBUG_HERE; } } -static void symres_while(OnyxSemPassState* state, AstWhile* whilenode) { +static void symres_while(SemState* state, AstWhile* whilenode) { symres_expression(state, &whilenode->cond); symres_block(state, whilenode->body); } // NOTE: Returns 1 if the statment should be removed -static b32 symres_statement(OnyxSemPassState* state, AstNode* stmt) { +static b32 symres_statement(SemState* state, AstNode* stmt) { switch (stmt->kind) { case Ast_Kind_Local: symres_local(state, (AstLocal **) &stmt); return 1; case Ast_Kind_Assignment: symres_assignment(state, (AstAssign *) stmt); return 0; @@ -282,7 +282,7 @@ static b32 symres_statement(OnyxSemPassState* state, AstNode* stmt) { } } -static void symres_statement_chain(OnyxSemPassState* state, AstNode* walker, AstNode** trailer) { +static void symres_statement_chain(SemState* state, AstNode* walker, AstNode** trailer) { while (walker) { if (symres_statement(state, walker)) { *trailer = walker->next; @@ -297,36 +297,36 @@ static void symres_statement_chain(OnyxSemPassState* state, AstNode* walker, Ast } } -static void symres_block(OnyxSemPassState* state, AstBlock* block) { +static void symres_block(SemState* state, AstBlock* block) { local_group_enter(state, block->locals); if (block->body) symres_statement_chain(state, block->body, &block->body); local_group_leave(state); } -static void symres_function(OnyxSemPassState* state, AstFunction* func) { - for (AstLocal *param = func->params; param != NULL; param = (AstLocal *) param->base.next) { - param->base.type_node = symres_type(state, param->base.type_node); +static void symres_function(SemState* state, AstFunction* func) { + for (AstLocal *param = func->params; param != NULL; param = (AstLocal *) param->next) { + param->type_node = symres_type(state, param->type_node); - symbol_introduce(state, param->base.token, (AstNode *) param); + symbol_introduce(state, param->token, (AstNode *) param); } - if (func->base.type_node != NULL) { - func->base.type_node = symres_type(state, func->base.type_node); + if (func->type_node != NULL) { + func->type_node = symres_type(state, func->type_node); } symres_block(state, func->body); - for (AstLocal *param = func->params; param != NULL; param = (AstLocal *) param->base.next) { - symbol_remove(state, param->base.token); + for (AstLocal *param = func->params; param != NULL; param = (AstLocal *) param->next) { + symbol_remove(state, param->token); } } -static void symres_global(OnyxSemPassState* state, AstGlobal* global) { - global->base.type_node = symres_type(state, global->base.type_node); +static void symres_global(SemState* state, AstGlobal* global) { + global->type_node = symres_type(state, global->type_node); } -static void symres_top_node(OnyxSemPassState* state, AstNode** node) { +static void symres_top_node(SemState* state, AstNode** node) { switch ((*node)->kind) { case Ast_Kind_Call: case Ast_Kind_Unary_Op: @@ -350,7 +350,7 @@ static void symres_top_node(OnyxSemPassState* state, AstNode** node) { } } -void onyx_resolve_symbols(OnyxSemPassState* state, ParserOutput* program) { +void onyx_resolve_symbols(SemState* state, ParserOutput* program) { // NOTE: Add types to global scope symbol_basic_type_introduce(state, &basic_type_void); @@ -368,7 +368,7 @@ void onyx_resolve_symbols(OnyxSemPassState* state, ParserOutput* program) { symbol_basic_type_introduce(state, &basic_type_rawptr); bh_arr_each(AstBinding *, binding, program->top_level_bindings) - if (!symbol_unique_introduce(state, (*binding)->base.token, (*binding)->node)) return; + if (!symbol_unique_introduce(state, (*binding)->token, (*binding)->node)) return; bh_arr_each(AstNode *, node, program->nodes_to_process) symres_top_node(state, node); diff --git a/src/onyxwasm.c b/src/onyxwasm.c index 56a9a025..752e4aaf 100644 --- a/src/onyxwasm.c +++ b/src/onyxwasm.c @@ -347,11 +347,11 @@ COMPILE_FUNC(if, AstIf* if_node) { if (if_node->true_block.as_if) { // NOTE: This is kind of gross, but making a function for this doesn't feel right - if (if_node->true_block.as_if->base.kind == Ast_Kind_If) { + if (if_node->true_block.as_if->kind == Ast_Kind_If) { forll (AstNode, stmt, (AstNode *) if_node->true_block.as_if, next) { compile_statement(mod, &code, stmt); } - } else if (if_node->true_block.as_if->base.kind == Ast_Kind_Block) { + } else if (if_node->true_block.as_if->kind == Ast_Kind_Block) { forll (AstNode, stmt, if_node->true_block.as_block->body, next) { compile_statement(mod, &code, stmt); } @@ -361,11 +361,11 @@ COMPILE_FUNC(if, AstIf* if_node) { if (if_node->false_block.as_if) { WI(WI_ELSE); - if (if_node->false_block.as_if->base.kind == Ast_Kind_If) { + if (if_node->false_block.as_if->kind == Ast_Kind_If) { forll (AstNode, stmt, (AstNode *) if_node->false_block.as_if, next) { compile_statement(mod, &code, stmt); } - } else if (if_node->false_block.as_if->base.kind == Ast_Kind_Block) { + } else if (if_node->false_block.as_if->kind == Ast_Kind_Block) { forll (AstNode, stmt, if_node->false_block.as_block->body, next) { compile_statement(mod, &code, stmt); } @@ -487,7 +487,7 @@ COMPILE_FUNC(unaryop, AstUnaryOp* unop) { switch (unop->operation) { case Unary_Op_Negate: { - TypeBasic* type = &unop->base.type->Basic; + TypeBasic* type = &unop->type->Basic; if (type->kind == Basic_Kind_I32 || type->kind == Basic_Kind_I16 @@ -533,7 +533,7 @@ COMPILE_FUNC(call, AstCall* call) { for (AstArgument *arg = call->arguments; arg != NULL; - arg = (AstArgument *) arg->base.next) { + arg = (AstArgument *) arg->next) { compile_expression(mod, &code, arg->value); } @@ -555,7 +555,7 @@ COMPILE_FUNC(intrinsic_call, AstIntrinsicCall* call) { if (place_arguments_normally) { for (AstArgument *arg = call->arguments; arg != NULL; - arg = (AstArgument *) arg->base.next) { + arg = (AstArgument *) arg->next) { compile_expression(mod, &code, arg->value); } } @@ -646,7 +646,7 @@ COMPILE_FUNC(expression, AstTyped* expr) { case Ast_Kind_Literal: { AstNumLit* lit = (AstNumLit *) expr; - WasmType lit_type = onyx_type_to_wasm_type(lit->base.type); + WasmType lit_type = onyx_type_to_wasm_type(lit->type); WasmInstruction instr = { WI_NOP, 0 }; if (lit_type == WASM_TYPE_INT32) { @@ -703,7 +703,7 @@ COMPILE_FUNC(cast, AstUnaryOp* cast) { compile_expression(mod, &code, cast->expr); Type* from = cast->expr->type; - Type* to = cast->base.type; + Type* to = cast->type; i32 fromidx = 0, toidx = 0; if (from->Basic.flags & Basic_Flag_Integer) { @@ -756,8 +756,8 @@ static i32 generate_type_idx(OnyxWasmModule* mod, AstFunction* fd) { static char type_repr_buf[128]; char* t = type_repr_buf; - Type** param_type = fd->base.type->Function.params; - i32 param_count = fd->base.type->Function.param_count; + Type** param_type = fd->type->Function.params; + i32 param_count = fd->type->Function.param_count; i32 params_left = param_count; while (params_left-- > 0) { // HACK: Using these directly as part of a string feels weird but they are @@ -767,7 +767,7 @@ static i32 generate_type_idx(OnyxWasmModule* mod, AstFunction* fd) { } *(t++) = ':'; - WasmType return_type = onyx_type_to_wasm_type(fd->base.type->Function.return_type); + WasmType return_type = onyx_type_to_wasm_type(fd->type->Function.return_type); *(t++) = (char) return_type; *t = '\0'; @@ -796,11 +796,11 @@ static i32 generate_type_idx(OnyxWasmModule* mod, AstFunction* fd) { static void compile_function(OnyxWasmModule* mod, AstFunction* fd) { // NOTE: Don't compile intrinsics - if (fd->base.flags & Ast_Flag_Intrinsic) return; + if (fd->flags & Ast_Flag_Intrinsic) return; i32 type_idx = generate_type_idx(mod, fd); - if (fd->base.flags & Ast_Flag_Foreign) { + if (fd->flags & Ast_Flag_Foreign) { WasmImport import = { .kind = WASM_FOREIGN_FUNCTION, .idx = type_idx, @@ -825,7 +825,7 @@ static void compile_function(OnyxWasmModule* mod, AstFunction* fd) { bh_arr_new(mod->allocator, wasm_func.code, 4); - if (fd->base.flags & Ast_Flag_Exported) { + if (fd->flags & Ast_Flag_Exported) { token_toggle_end(fd->exported_name); i32 func_idx = (i32) bh_imap_get(&mod->func_map, (u64) fd); @@ -844,7 +844,7 @@ static void compile_function(OnyxWasmModule* mod, AstFunction* fd) { if (fd->body != NULL) { // NOTE: Generate the local map i32 localidx = 0; - for (AstLocal *param = fd->params; param != NULL; param = (AstLocal *) param->base.next) { + for (AstLocal *param = fd->params; param != NULL; param = (AstLocal *) param->next) { bh_imap_put(&mod->local_map, (u64) param, localidx++); } @@ -855,7 +855,7 @@ static void compile_function(OnyxWasmModule* mod, AstFunction* fd) { u8* count = &wasm_func.locals.i32_count; fori (ti, 0, 3) { forll (AstLocal, local, fd->body->locals->last_local, prev_local) { - if (onyx_type_to_wasm_type(local->base.type) == local_types[ti]) { + if (onyx_type_to_wasm_type(local->type) == local_types[ti]) { bh_imap_put(&mod->local_map, (u64) local, localidx++); (*count)++; @@ -880,9 +880,9 @@ static void compile_function(OnyxWasmModule* mod, AstFunction* fd) { } static void compile_global_declaration(OnyxWasmModule* module, AstGlobal* global) { - WasmType global_type = onyx_type_to_wasm_type(global->base.type); + WasmType global_type = onyx_type_to_wasm_type(global->type); - if (global->base.flags & Ast_Flag_Foreign) { + if (global->flags & Ast_Flag_Foreign) { WasmImport import = { .kind = WASM_FOREIGN_GLOBAL, .idx = global_type, @@ -896,11 +896,11 @@ static void compile_global_declaration(OnyxWasmModule* module, AstGlobal* global WasmGlobal glob = { .type = global_type, - .mutable = (global->base.flags & Ast_Flag_Const) == 0, + .mutable = (global->flags & Ast_Flag_Const) == 0, .initial_value = NULL, }; - if ((global->base.flags & Ast_Flag_Exported) != 0) { + if ((global->flags & Ast_Flag_Exported) != 0) { token_toggle_end(global->exported_name); i32 global_idx = (i32) bh_imap_get(&module->func_map, (u64) global); @@ -973,26 +973,26 @@ OnyxWasmModule onyx_wasm_module_create(bh_allocator alloc, OnyxMessages* msgs) { void onyx_wasm_module_compile(OnyxWasmModule* module, ParserOutput* program) { bh_arr_each(AstFunction *, function, program->functions) { - if ((*function)->base.flags & Ast_Flag_Foreign) { + if ((*function)->flags & Ast_Flag_Foreign) { bh_imap_put(&module->func_map, (u64) *function, module->next_func_idx++); } } bh_arr_each(AstGlobal *, global, program->globals) { - if ((*global)->base.flags & Ast_Flag_Foreign) { + if ((*global)->flags & Ast_Flag_Foreign) { bh_imap_put(&module->global_map, (u64) *global, module->next_global_idx++); } } bh_arr_each(AstFunction *, function, program->functions) { - if ((*function)->base.flags & Ast_Flag_Foreign) continue; + if ((*function)->flags & Ast_Flag_Foreign) continue; - if (((*function)->base.flags & Ast_Flag_Intrinsic) == 0) + if (((*function)->flags & Ast_Flag_Intrinsic) == 0) bh_imap_put(&module->func_map, (u64) *function, module->next_func_idx++); } bh_arr_each(AstGlobal *, global, program->globals) { - if ((*global)->base.flags & Ast_Flag_Foreign) continue; + if ((*global)->flags & Ast_Flag_Foreign) continue; bh_imap_put(&module->global_map, (u64) *global, module->next_global_idx++); } -- 2.25.1