From: Brendan Hansen Date: Thu, 9 Jul 2020 22:40:19 +0000 (-0500) Subject: MAJOR BREAKING CHANGES X-Git-Url: https://git.brendanfh.com/?a=commitdiff_plain;h=b6b9fb6be7e228909904c9ed8518561d30d0d828;p=onyx.git MAJOR BREAKING CHANGES Everything is broken right now --- diff --git a/Makefile b/Makefile index 36a8fbd2..3dbbbe5e 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,7 @@ OBJ_FILES=\ build/onyxlex.o \ build/onyxparser.o \ + build/onyxtypes.o \ build/onyxsempass.o \ build/onyxsymres.o \ build/onyxchecker.o \ diff --git a/include/onyxastnodes.h b/include/onyxastnodes.h index ecc36099..a19b4954 100644 --- a/include/onyxastnodes.h +++ b/include/onyxastnodes.h @@ -2,249 +2,221 @@ #define ONYXASTNODES_H #include "onyxlex.h" +#include "onyxtypes.h" typedef struct AstNode AstNode; -typedef struct AstNodeTyped AstNodeTyped; -typedef struct AstNodeUnaryOp AstNodeUnaryOp; -typedef struct AstNodeBinOp AstNodeBinOp; -typedef struct AstNodeAssign AstNodeAssign; -typedef struct AstNodeNumLit AstNodeNumLit; -typedef struct AstNodeLocal AstNodeLocal; -typedef struct AstNodeLocalGroup AstNodeLocalGroup; -typedef struct AstNodeReturn AstNodeReturn; -typedef struct AstNodeBlock AstNodeBlock; -typedef struct AstNodeIf AstNodeIf; -typedef struct AstNodeWhile AstNodeWhile; -typedef struct AstNodeFunction AstNodeFunction; -typedef struct AstNodeForeign AstNodeForeign; -typedef struct AstNodeGlobal AstNodeGlobal; -typedef struct AstNodeCall AstNodeCall; -typedef struct AstNodeIntrinsicCall AstNodeIntrinsicCall; -typedef struct AstNodeArgument AstNodeArgument; -typedef struct AstNodeUse AstNodeUse; - -typedef enum AstNodeKind { - AST_NODE_KIND_ERROR, - AST_NODE_KIND_PROGRAM, - AST_NODE_KIND_USE, - - AST_NODE_KIND_FUNCTION, - AST_NODE_KIND_FOREIGN, - AST_NODE_KIND_BLOCK, - AST_NODE_KIND_LOCAL_GROUP, - AST_NODE_KIND_LOCAL, - AST_NODE_KIND_GLOBAL, - AST_NODE_KIND_SYMBOL, - - AST_NODE_KIND_UNARY_OP, - AST_NODE_KIND_BIN_OP, - - AST_NODE_KIND_TYPE, - AST_NODE_KIND_LITERAL, - AST_NODE_KIND_PARAM, - AST_NODE_KIND_ARGUMENT, - AST_NODE_KIND_CALL, - AST_NODE_KIND_INTRINSIC_CALL, - AST_NODE_KIND_ASSIGNMENT, - AST_NODE_KIND_RETURN, - - AST_NODE_KIND_IF, - AST_NODE_KIND_WHILE, - AST_NODE_KIND_BREAK, - AST_NODE_KIND_CONTINUE, - - AST_NODE_KIND_COUNT -} AstNodeKind; - -typedef enum TypeInfoKind { - TYPE_INFO_KIND_UNKNOWN, - TYPE_INFO_KIND_VOID, - TYPE_INFO_KIND_BOOL, - - TYPE_INFO_KIND_UINT32, - TYPE_INFO_KIND_UINT64, - - TYPE_INFO_KIND_INT32, - TYPE_INFO_KIND_INT64, - - TYPE_INFO_KIND_FLOAT32, - TYPE_INFO_KIND_FLOAT64, - TYPE_INFO_KIND_SOFT_FLOAT, // 64-bits of data but could be treated as 32-bit -} TypeInfoKind; - -typedef struct TypeInfo { - TypeInfoKind kind; - u32 size; // in bytes - const char* name; - u32 is_int : 1; - u32 is_unsigned : 1; - u32 is_float : 1; - u32 is_bool : 1; - u32 is_known : 1; -} TypeInfo; - -extern TypeInfo builtin_types[]; +typedef struct AstTyped AstTyped; +typedef struct AstUnaryOp AstUnaryOp; +typedef struct AstBinOp AstBinaryOp; +typedef struct AstAssign AstAssign; +typedef struct AstNumLit AstNumLit; +typedef struct AstLocal AstLocal; +typedef struct AstLocalGroup AstLocalGroup; +typedef struct AstReturn AstReturn; +typedef struct AstBlock AstBlock; +typedef struct AstIf AstIf; +typedef struct AstWhile AstWhile; +typedef struct AstFunction AstFunction; +typedef struct AstForeign AstForeign; +typedef struct AstGlobal AstGlobal; +typedef struct AstCall AstCall; +typedef struct AstIntrinsicCall AstIntrinsicCall; +typedef struct AstArgument AstArgument; +typedef struct AstUse AstUse; + +typedef enum AstKind { + Ast_Kind_Error, + Ast_Kind_Program, + Ast_Kind_Use, + + Ast_Kind_Function, + Ast_Kind_Foreign, + Ast_Kind_Block, + Ast_Kind_Local_Group, + Ast_Kind_Local, + Ast_Kind_Global, + Ast_Kind_Symbol, + + Ast_Kind_Unary_Op, + Ast_Kind_Binary_Op, + + Ast_Kind_Type, + Ast_Kind_Literal, + Ast_Kind_Param, + Ast_Kind_Argument, + Ast_Kind_Call, + Ast_Kind_Intrinsic_Call, + Ast_Kind_Assignment, + Ast_Kind_Return, + + Ast_Kind_If, + Ast_Kind_While, + Ast_Kind_Break, + Ast_Kind_Continue, + + Ast_Kind_Count +} AstKind; // NOTE: Some of these flags will overlap since there are // only 32-bits of flags to play with -typedef enum OnyxAstFlags { +typedef enum AstFlags { // Top-level flags - ONYX_AST_FLAG_EXPORTED = BH_BIT(0), - ONYX_AST_FLAG_LVAL = BH_BIT(1), - ONYX_AST_FLAG_CONST = BH_BIT(2), - ONYX_AST_FLAG_COMPTIME = BH_BIT(3), + Ast_Flag_Exported = BH_BIT(0), + Ast_Flag_Lval = BH_BIT(1), + Ast_Flag_Const = BH_BIT(2), + Ast_Flag_Comptime = BH_BIT(3), // Function flags - ONYX_AST_FLAG_INLINE = BH_BIT(8), - ONYX_AST_FLAG_INTRINSIC = BH_BIT(9), -} OnyxAstFlags; - -typedef enum OnyxUnaryOp { - ONYX_UNARY_OP_NEGATE, - ONYX_UNARY_OP_NOT, - ONYX_UNARY_OP_CAST, -} OnyxUnaryOp; - -typedef enum OnyxBinaryOp { - ONYX_BINARY_OP_ADD = 0, - ONYX_BINARY_OP_MINUS = 1, - ONYX_BINARY_OP_MULTIPLY = 2, - ONYX_BINARY_OP_DIVIDE = 3, - ONYX_BINARY_OP_MODULUS = 4, - - ONYX_BINARY_OP_EQUAL = 5, - ONYX_BINARY_OP_NOT_EQUAL = 6, - ONYX_BINARY_OP_LESS = 7, - ONYX_BINARY_OP_LESS_EQUAL = 8, - ONYX_BINARY_OP_GREATER = 9, - ONYX_BINARY_OP_GREATER_EQUAL = 10, -} OnyxBinaryOp; - -// NOTE: AstNode and AstNodeTyped need to be EXACTLY the same for -// all arguments existing in AstNode. I do this to avoid a nested + Ast_Flag_Inline = BH_BIT(8), + Ast_Flag_Intrinsic = BH_BIT(9), +} AstFlags; + +typedef enum UnaryOp { + Unary_Op_Negate, + Unary_Op_Not, + Unary_Op_Cast, +} UnaryOp; + +typedef enum BinaryOp { + Binary_Op_Add = 0, + Binary_Op_Minus = 1, + Binary_Op_Multiply = 2, + Binary_Op_Divide = 3, + Binary_Op_Modulus = 4, + + Binary_Op_Equal = 5, + Binary_Op_Not_Equal = 6, + Binary_Op_Less = 7, + Binary_Op_Less_Equal = 8, + Binary_Op_Greater = 9, + Binary_Op_Greater_Equal = 10, +} BinaryOp; + +// NOTE: AstNode and AstTyped need to be EXACTLY the same for all +// 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 { - AstNodeKind kind; + AstKind kind; u32 flags; OnyxToken *token; AstNode *next; }; -struct AstNodeTyped { - AstNodeKind kind; +struct AstTyped { + AstKind kind; u32 flags; OnyxToken *token; AstNode *next; - TypeInfo *type; + Type *type; }; -struct AstNodeBinOp { - AstNodeTyped base; +struct AstBinOp { + AstTyped base; - OnyxBinaryOp operation; + BinaryOp operation; - AstNodeTyped *left, *right; + AstTyped *left, *right; }; -struct AstNodeUnaryOp { - AstNodeTyped base; +struct AstUnaryOp { + AstTyped base; - OnyxUnaryOp operation; + UnaryOp operation; - AstNodeTyped *expr; + AstTyped *expr; }; -struct AstNodeAssign { +struct AstAssign { AstNode base; - AstNodeTyped* lval; - AstNodeTyped* expr; + AstTyped* lval; + AstTyped* expr; }; -struct AstNodeNumLit { - AstNodeTyped base; +struct AstNumLit { + AstTyped base; union { i32 i; i64 l; f32 f; f64 d; } value; }; -struct AstNodeLocal { - AstNodeTyped base; +struct AstLocal { + AstTyped base; - AstNodeLocal *prev_local; + AstLocal *prev_local; }; -struct AstNodeReturn { +struct AstReturn { AstNode base; - AstNodeTyped* expr; + AstTyped* expr; }; -struct AstNodeLocalGroup { +struct AstLocalGroup { AstNode base; - AstNodeLocalGroup *prev_group; - AstNodeLocal *last_local; + AstLocalGroup *prev_group; + AstLocal *last_local; }; -struct AstNodeBlock { +struct AstBlock { AstNode base; AstNode *body; - AstNodeLocalGroup *locals; + AstLocalGroup *locals; }; -struct AstNodeIf { +struct AstIf { AstNode base; - AstNodeTyped *cond; + AstTyped *cond; union { - AstNodeIf *as_if; - AstNodeBlock* as_block; + AstIf *as_if; + AstBlock* as_block; } true_block, false_block; }; -struct AstNodeWhile { +struct AstWhile { AstNode base; - AstNodeTyped *cond; - AstNodeBlock *body; + AstTyped *cond; + AstBlock *body; }; -struct AstNodeFunction { - AstNodeTyped base; +struct AstFunction { + AstTyped base; - AstNodeBlock *body; - AstNodeLocal *params; + AstBlock *body; + AstLocal *params; }; -struct AstNodeForeign { +struct AstForeign { AstNode base; OnyxToken *mod_token, *name_token; AstNode *import; }; -struct AstNodeGlobal { - AstNodeTyped base; +struct AstGlobal { + AstTyped base; - AstNodeTyped *initial_value; + AstTyped *initial_value; }; -struct AstNodeCall { - AstNodeTyped base; +struct AstCall { + AstTyped base; - AstNodeArgument *arguments; // NOTE: Expressions that form the actual param list + AstArgument *arguments; // NOTE: Expressions that form the actual param list // They will be chained down using the "next" property // unless this becomes used by something else AstNode *callee; // NOTE: Function definition node }; -struct AstNodeArgument { - AstNodeTyped base; +struct AstArgument { + AstTyped base; - AstNodeTyped *value; + AstTyped *value; }; typedef enum OnyxIntrinsic { @@ -300,23 +272,23 @@ typedef enum OnyxIntrinsic { // NOTE: This needs to have 'arguments' in the // same position as AstNodeCall -struct AstNodeIntrinsicCall { - AstNodeTyped base; +struct AstIntrinsicCall { + AstTyped base; - AstNodeArgument *arguments; + AstArgument *arguments; OnyxIntrinsic intrinsic; }; -struct AstNodeUse { +struct AstUse { AstNode base; OnyxToken *filename; }; typedef struct OnyxProgram { - bh_arr(AstNodeGlobal *) globals; - bh_arr(AstNodeFunction *) functions; - bh_arr(AstNodeForeign *) foreigns; + bh_arr(AstGlobal *) globals; + bh_arr(AstFunction *) functions; + bh_arr(AstForeign *) foreigns; } OnyxProgram; #endif // #ifndef ONYXASTNODES_H diff --git a/include/onyxlex.h b/include/onyxlex.h index f145b410..d6b64092 100644 --- a/include/onyxlex.h +++ b/include/onyxlex.h @@ -4,46 +4,46 @@ #include "bh.h" typedef enum TokenType { - TOKEN_TYPE_ASCII_END = 256, - TOKEN_TYPE_UNKNOWN = 256, - TOKEN_TYPE_END_STREAM = 257, - - TOKEN_TYPE_COMMENT = 258, - - TOKEN_TYPE_KEYWORD_STRUCT = 259, - TOKEN_TYPE_KEYWORD_USE = 260, - TOKEN_TYPE_KEYWORD_EXPORT = 261, - TOKEN_TYPE_KEYWORD_IF = 262, - TOKEN_TYPE_KEYWORD_ELSE = 263, - TOKEN_TYPE_KEYWORD_ELSEIF = 264, - TOKEN_TYPE_KEYWORD_RETURN = 265, - TOKEN_TYPE_KEYWORD_FOREIGN = 266, - TOKEN_TYPE_KEYWORD_PROC = 267, - TOKEN_TYPE_KEYWORD_CAST = 268, - TOKEN_TYPE_KEYWORD_WHILE = 269, - TOKEN_TYPE_KEYWORD_BREAK = 270, - TOKEN_TYPE_KEYWORD_CONTINUE = 271, - - TOKEN_TYPE_RIGHT_ARROW = 272, - TOKEN_TYPE_LEFT_ARROW = 273, - - TOKEN_TYPE_GREATER_EQUAL = 274, - TOKEN_TYPE_LESS_EQUAL = 275, - TOKEN_TYPE_EQUAL_EQUAL = 276, - TOKEN_TYPE_NOT_EQUAL = 277, - TOKEN_TYPE_PLUS_EQUAL = 278, - TOKEN_TYPE_MINUS_EQUAL = 279, - TOKEN_TYPE_STAR_EQUAL = 280, - TOKEN_TYPE_FSLASH_EQUAL = 281, - TOKEN_TYPE_PERCENT_EQUAL = 282, - - TOKEN_TYPE_SYMBOL = 283, - TOKEN_TYPE_LITERAL_STRING = 284, - TOKEN_TYPE_LITERAL_NUMERIC = 285, - TOKEN_TYPE_LITERAL_BOOL_TRUE = 286, - TOKEN_TYPE_LITERAL_BOOL_FALSE = 287, - - TOKEN_TYPE_COUNT = 288 + Token_Type_Ascii_End = 256, + Token_Type_Unknown = 256, + Token_Type_End_Stream = 257, + + Token_Type_Comment = 258, + + Token_Type_Keyword_Struct = 259, + Token_Type_Keyword_Use = 260, + Token_Type_Keyword_Export = 261, + Token_Type_Keyword_If = 262, + Token_Type_Keyword_Else = 263, + Token_Type_Keyword_Elseif = 264, + Token_Type_Keyword_Return = 265, + Token_Type_Keyword_Foreign = 266, + Token_Type_Keyword_Proc = 267, + Token_Type_Keyword_Cast = 268, + Token_Type_Keyword_While = 269, + Token_Type_Keyword_Break = 270, + Token_Type_Keyword_Continue = 271, + + Token_Type_Right_Arrow = 272, + Token_Type_Left_Arrow = 273, + + Token_Type_Greater_Equal = 274, + Token_Type_Less_Equal = 275, + Token_Type_Equal_Equal = 276, + Token_Type_Not_Equal = 277, + Token_Type_Plus_Equal = 278, + Token_Type_Minus_Equal = 279, + Token_Type_Star_Equal = 280, + Token_Type_Fslash_Equal = 281, + Token_Type_Percent_Equal = 282, + + Token_Type_Symbol = 283, + Token_Type_Literal_String = 284, + Token_Type_Literal_Numeric = 285, + Token_Type_Literal_True = 286, + Token_Type_Literal_False = 287, + + Token_Type_Count = 288 } TokenType; typedef struct OnyxFilePos { diff --git a/include/onyxparser.h b/include/onyxparser.h index 37743009..98c67d43 100644 --- a/include/onyxparser.h +++ b/include/onyxparser.h @@ -20,8 +20,8 @@ typedef struct OnyxParser { bh_allocator allocator; } OnyxParser; -const char* onyx_ast_node_kind_string(AstNodeKind kind); -void* onyx_ast_node_new(bh_allocator alloc, i32 size, AstNodeKind kind); +const char* onyx_ast_node_kind_string(AstKind kind); +void* onyx_ast_node_new(bh_allocator alloc, i32 size, AstKind kind); OnyxParser onyx_parser_create(bh_allocator alloc, OnyxTokenizer *tokenizer, OnyxMessages* msgs); void onyx_parser_free(OnyxParser* parser); bh_arr(AstNode *) onyx_parse(OnyxParser *parser); diff --git a/include/onyxsempass.h b/include/onyxsempass.h index 220fe8b2..287c4b33 100644 --- a/include/onyxsempass.h +++ b/include/onyxsempass.h @@ -19,7 +19,7 @@ typedef struct OnyxSemPassState { OnyxMessages *msgs; // NOTE: Used in symbol resolution phase - AstNodeLocalGroup* curr_local_group; + AstLocalGroup* curr_local_group; // NOTE: Used in type checking phase TypeInfo* expected_return_type; diff --git a/include/onyxtypes.h b/include/onyxtypes.h new file mode 100644 index 00000000..5a50ba4b --- /dev/null +++ b/include/onyxtypes.h @@ -0,0 +1,86 @@ +#ifndef ONYXTYPES_H +#define ONYXTYPES_H + +#include "bh.h" + +enum BasicKind { + Basic_Kind_Void, + + Basic_Kind_Bool, + + Basic_Kind_I8, + Basic_Kind_U8, + Basic_Kind_I16, + Basic_Kind_U16, + Basic_Kind_I32, + Basic_Kind_U32, + Basic_Kind_I64, + Basic_Kind_U64, + + Basic_Kind_F32, + Basic_Kind_F64, + + Basic_Kind_Rawptr, +}; + +enum BasicFlag { + Basic_Flag_Boolean = BH_BIT(0), + Basic_Flag_Integer = BH_BIT(1), + Basic_Flag_Unsigned = BH_BIT(2), + Basic_Flag_Float = BH_BIT(3), + Basic_Flag_Pointer = BH_BIT(4), + + Basic_Flag_Numeric = Basic_Flag_Integer | Basic_Flag_Float, + Basic_Flag_Ordered = Basic_Flag_Integer | Basic_Flag_Float | Basic_Flag_Pointer, + Basic_Flag_Constant_Type = Basic_Flag_Boolean | Basic_Flag_Numeric | Basic_Flag_Pointer, + Basic_Flag_Numeric_Ordered = Basic_Flag_Numeric | Basic_Flag_Ordered, +}; + +typedef struct TypeBasic { + enum BasicKind kind; + u32 flags; + i64 size; // NOTE: In bytes + const char* name; +} TypeBasic; + +// NOTE: Forward declaration for some of the types below +typedef struct Type Type; + +#define TYPE_KINDS \ + TYPE_KIND(Basic, TypeBasic) \ + TYPE_KIND(Pointer, struct { Type *elem; }) + +typedef enum TypeKind { + Type_Kind_Invalid, + +#define TYPE_KIND(k, ...) Type_Kind_##k, + TYPE_KINDS +#undef TYPE_KIND + + Type_Kind_Count, +} TypeKind; + +#define TYPE_KIND(k, ...) typedef __VA_ARGS__ Type ## k; + TYPE_KINDS +#undef TYPE_KIND + +enum TypeFlag { + Type_Flag_Default +}; + +struct Type { + TypeKind kind; + + union { +#define TYPE_KIND(k, ...) Type##k k; + TYPE_KINDS +#undef TYPE_KIND + }; + + u32 flags; +}; + +extern Type basic_types[]; + + +#endif // #ifndef ONYX_TYPES diff --git a/include/onyxutils.h b/include/onyxutils.h index 86cac2fa..5154227c 100644 --- a/include/onyxutils.h +++ b/include/onyxutils.h @@ -8,6 +8,6 @@ extern bh_allocator global_scratch_allocator; extern bh_managed_heap global_heap; extern bh_allocator global_heap_allocator; -const char* onyx_ast_node_kind_string(AstNodeKind kind); +const char* onyx_ast_node_kind_string(AstKind kind); void onyx_ast_print(AstNode* program, i32 indent); diff --git a/onyx b/onyx index aeaff62d..6d137519 100755 Binary files a/onyx and b/onyx differ diff --git a/progs/test.onyx b/progs/test.onyx index 5da6fd85..db16c2b9 100644 --- a/progs/test.onyx +++ b/progs/test.onyx @@ -62,6 +62,7 @@ export main2 :: proc { // } export main :: proc { + print_i32(clz_i32(16)); print_f32(sqrt_f32(2.0f)); print_i32(5 * 6 + 2 * 3); diff --git a/src/onyx.c b/src/onyx.c index 680cff77..7c2abd82 100644 --- a/src/onyx.c +++ b/src/onyx.c @@ -144,24 +144,24 @@ static CompilerProgress process_source_file(CompilerState* compiler_state, char* bh_arr(AstNode *) top_nodes = parse_source_file(compiler_state, &fc); - bh_arr(AstNodeUse *) uses = NULL; + bh_arr(AstUse *) uses = NULL; bh_arr_each(AstNode *, node, top_nodes) { switch ((*node)->kind) { - case AST_NODE_KIND_USE: - bh_arr_push(uses, (AstNodeUse *) *node); + case Ast_Kind_Use: + bh_arr_push(uses, (AstUse *) *node); break; - case AST_NODE_KIND_GLOBAL: - bh_arr_push(compiler_state->program.globals, (AstNodeGlobal *) (*node)); + case Ast_Kind_Global: + bh_arr_push(compiler_state->program.globals, (AstGlobal *) (*node)); break; - case AST_NODE_KIND_FOREIGN: - bh_arr_push(compiler_state->program.foreigns, (AstNodeForeign *) (*node)); + case Ast_Kind_Foreign: + bh_arr_push(compiler_state->program.foreigns, (AstForeign *) (*node)); break; - case AST_NODE_KIND_FUNCTION: - bh_arr_push(compiler_state->program.functions, (AstNodeFunction *) (*node)); + case Ast_Kind_Function: + bh_arr_push(compiler_state->program.functions, (AstFunction *) (*node)); break; default: @@ -170,7 +170,7 @@ static CompilerProgress process_source_file(CompilerState* compiler_state, char* } } - bh_arr_each(AstNodeUse *, use_node, uses) { + bh_arr_each(AstUse *, use_node, uses) { char* formatted_name = bh_aprintf( global_heap_allocator, "%b.onyx", diff --git a/src/onyxchecker.c b/src/onyxchecker.c index 1361d78a..c7d0fcd7 100644 --- a/src/onyxchecker.c +++ b/src/onyxchecker.c @@ -1,20 +1,20 @@ #define BH_DEBUG #include "onyxsempass.h" -static void check_function(OnyxSemPassState* state, AstNodeFunction* func); -static void check_block(OnyxSemPassState* state, AstNodeBlock* block); +static void check_function(OnyxSemPassState* state, AstFunction* func); +static void check_block(OnyxSemPassState* state, AstBlock* block); static void check_statement_chain(OnyxSemPassState* state, AstNode* start); static void check_statement(OnyxSemPassState* state, AstNode* stmt); -static void check_assignment(OnyxSemPassState* state, AstNodeAssign* assign); -static void check_return(OnyxSemPassState* state, AstNodeReturn* retnode); -static void check_if(OnyxSemPassState* state, AstNodeIf* ifnode); -static void check_while(OnyxSemPassState* state, AstNodeWhile* whilenode); -static void check_call(OnyxSemPassState* state, AstNodeCall* call); -static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr); -static void check_global(OnyxSemPassState* state, AstNodeGlobal* global); - -static void check_assignment(OnyxSemPassState* state, AstNodeAssign* assign) { - if (assign->lval->kind == AST_NODE_KIND_SYMBOL) { +static void check_assignment(OnyxSemPassState* state, AstAssign* assign); +static void check_return(OnyxSemPassState* state, AstReturn* retnode); +static void check_if(OnyxSemPassState* state, AstIf* ifnode); +static void check_while(OnyxSemPassState* state, AstWhile* whilenode); +static void check_call(OnyxSemPassState* state, AstCall* call); +static void check_expression(OnyxSemPassState* state, AstTyped* expr); +static void check_global(OnyxSemPassState* state, AstGlobal* global); + +static void check_assignment(OnyxSemPassState* state, AstAssign* assign) { + if (assign->lval->kind == Ast_Kind_Symbol) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNRESOLVED_SYMBOL, assign->lval->token->pos, @@ -22,7 +22,7 @@ static void check_assignment(OnyxSemPassState* state, AstNodeAssign* assign) { return; } - if ((assign->lval->flags & ONYX_AST_FLAG_CONST) != 0 && assign->lval->type->is_known) { + if ((assign->lval->flags & Ast_Flag_Const) != 0 && assign->lval->type->is_known) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_ASSIGN_CONST, assign->base.token->pos, @@ -30,7 +30,7 @@ static void check_assignment(OnyxSemPassState* state, AstNodeAssign* assign) { return; } - if ((assign->lval->flags & ONYX_AST_FLAG_LVAL) == 0) { + if ((assign->lval->flags & Ast_Flag_Lval) == 0) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_NOT_LVAL, assign->base.token->pos, @@ -53,7 +53,7 @@ static void check_assignment(OnyxSemPassState* state, AstNodeAssign* assign) { } } -static void check_return(OnyxSemPassState* state, AstNodeReturn* retnode) { +static void check_return(OnyxSemPassState* state, AstReturn* retnode) { if (retnode->expr) { check_expression(state, retnode->expr); @@ -73,7 +73,7 @@ static void check_return(OnyxSemPassState* state, AstNodeReturn* retnode) { } } -static void check_if(OnyxSemPassState* state, AstNodeIf* ifnode) { +static void check_if(OnyxSemPassState* state, AstIf* ifnode) { check_expression(state, ifnode->cond); if (ifnode->cond->type != &builtin_types[TYPE_INFO_KIND_BOOL]) { onyx_message_add(state->msgs, @@ -87,7 +87,7 @@ static void check_if(OnyxSemPassState* state, AstNodeIf* ifnode) { if (ifnode->false_block.as_if) check_statement(state, (AstNode *) ifnode->false_block.as_block); } -static void check_while(OnyxSemPassState* state, AstNodeWhile* whilenode) { +static void check_while(OnyxSemPassState* state, AstWhile* whilenode) { check_expression(state, whilenode->cond); if (whilenode->cond->type != &builtin_types[TYPE_INFO_KIND_BOOL]) { onyx_message_add(state->msgs, @@ -100,10 +100,10 @@ static void check_while(OnyxSemPassState* state, AstNodeWhile* whilenode) { check_block(state, whilenode->body); } -static void check_call(OnyxSemPassState* state, AstNodeCall* call) { - AstNodeFunction* callee = (AstNodeFunction *) call->callee; +static void check_call(OnyxSemPassState* state, AstCall* call) { + AstFunction* callee = (AstFunction *) call->callee; - if (callee->base.kind == AST_NODE_KIND_SYMBOL) { + if (callee->base.kind == Ast_Kind_Symbol) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNRESOLVED_SYMBOL, callee->base.token->pos, @@ -111,7 +111,7 @@ static void check_call(OnyxSemPassState* state, AstNodeCall* call) { return; } - if (callee->base.kind != AST_NODE_KIND_FUNCTION) { + if (callee->base.kind != Ast_Kind_Function) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_CALL_NON_FUNCTION, call->base.token->pos, @@ -121,8 +121,8 @@ static void check_call(OnyxSemPassState* state, AstNodeCall* call) { // NOTE: If we calling an intrinsic function, translate the // call into an intrinsic call node. - if (callee->base.flags & ONYX_AST_FLAG_INTRINSIC) { - call->base.kind = AST_NODE_KIND_INTRINSIC_CALL; + if (callee->base.flags & Ast_Flag_Intrinsic) { + call->base.kind = Ast_Kind_Intrinsic_Call; call->callee = NULL; onyx_token_null_toggle(callee->base.token); @@ -177,19 +177,19 @@ static void check_call(OnyxSemPassState* state, AstNodeCall* call) { else if (!strcmp("max_f64", intr_name)) intrinsic = ONYX_INTRINSIC_F64_MAX; else if (!strcmp("copysign_f64", intr_name)) intrinsic = ONYX_INTRINSIC_F64_COPYSIGN; - ((AstNodeIntrinsicCall *)call)->intrinsic = intrinsic; + ((AstIntrinsicCall *)call)->intrinsic = intrinsic; onyx_token_null_toggle(callee->base.token); } call->base.type = callee->base.type; - AstNodeLocal* formal_param = callee->params; - AstNodeArgument* actual_param = call->arguments; + AstLocal* formal_param = callee->params; + AstArgument* actual_param = call->arguments; i32 arg_pos = 0; while (formal_param != NULL && actual_param != NULL) { - check_expression(state, (AstNodeTyped *) actual_param); + check_expression(state, (AstTyped *) actual_param); if (formal_param->base.type != actual_param->base.type) { onyx_message_add(state->msgs, @@ -202,8 +202,8 @@ static void check_call(OnyxSemPassState* state, AstNodeCall* call) { } arg_pos++; - formal_param = (AstNodeLocal *) formal_param->base.next; - actual_param = (AstNodeArgument *) actual_param->base.next; + formal_param = (AstLocal *) formal_param->base.next; + actual_param = (AstArgument *) actual_param->base.next; } if (formal_param != NULL && actual_param == NULL) { @@ -223,15 +223,15 @@ static void check_call(OnyxSemPassState* state, AstNodeCall* call) { } } -static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr) { +static void check_expression(OnyxSemPassState* state, AstTyped* expr) { switch (expr->kind) { - case AST_NODE_KIND_BIN_OP: + case Ast_Kind_Binary_Op: expr->type = &builtin_types[TYPE_INFO_KIND_UNKNOWN]; - check_expression(state, ((AstNodeBinOp *) expr)->left); - check_expression(state, ((AstNodeBinOp *) expr)->right); + check_expression(state, ((AstBinaryOp *) expr)->left); + check_expression(state, ((AstBinaryOp *) expr)->right); - if (((AstNodeBinOp *) expr)->left->type == NULL) { + if (((AstBinaryOp *) expr)->left->type == NULL) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNRESOLVED_TYPE, expr->token->pos, @@ -239,7 +239,7 @@ static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr) { return; } - if (((AstNodeBinOp *) expr)->right->type == NULL) { + if (((AstBinaryOp *) expr)->right->type == NULL) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNRESOLVED_TYPE, expr->token->pos, @@ -247,48 +247,48 @@ static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr) { return; } - if (((AstNodeBinOp *) expr)->left->type != ((AstNodeBinOp *) expr)->right->type) { + if (((AstBinaryOp *) expr)->left->type != ((AstBinaryOp *) expr)->right->type) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_BINOP_MISMATCH_TYPE, expr->token->pos, - ((AstNodeBinOp *) expr)->left->type->name, - ((AstNodeBinOp *) expr)->right->type->name); + ((AstBinaryOp *) expr)->left->type->name, + ((AstBinaryOp *) expr)->right->type->name); return; } - if (((AstNodeBinOp *) expr)->operation >= ONYX_BINARY_OP_EQUAL - && ((AstNodeBinOp *) expr)->operation <= ONYX_BINARY_OP_GREATER_EQUAL) { + if (((AstBinaryOp *) expr)->operation >= Binary_Op_Equal + && ((AstBinaryOp *) expr)->operation <= Binary_Op_Greater_Equal) { expr->type = &builtin_types[TYPE_INFO_KIND_BOOL]; } else { - expr->type = ((AstNodeBinOp *) expr)->left->type; + expr->type = ((AstBinaryOp *) expr)->left->type; } break; - case AST_NODE_KIND_UNARY_OP: - if (((AstNodeUnaryOp *) expr)->operation != ONYX_UNARY_OP_CAST) { - check_expression(state, ((AstNodeUnaryOp *) expr)->expr); - expr->type = ((AstNodeUnaryOp *) expr)->expr->type; + case Ast_Kind_Unary_Op: + if (((AstUnaryOp *) expr)->operation != Unary_Op_Cast) { + check_expression(state, ((AstUnaryOp *) expr)->expr); + expr->type = ((AstUnaryOp *) expr)->expr->type; } break; - case AST_NODE_KIND_CALL: - check_call(state, (AstNodeCall *) expr); + case Ast_Kind_Call: + check_call(state, (AstCall *) expr); break; - case AST_NODE_KIND_BLOCK: - check_block(state, (AstNodeBlock *) expr); + case Ast_Kind_Block: + check_block(state, (AstBlock *) expr); break; - case AST_NODE_KIND_SYMBOL: + case Ast_Kind_Symbol: onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNRESOLVED_SYMBOL, expr->token->pos, expr->token->text, expr->token->length); break; - case AST_NODE_KIND_LOCAL: - case AST_NODE_KIND_PARAM: + case Ast_Kind_Local: + case Ast_Kind_Param: if (!expr->type->is_known) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, @@ -297,7 +297,7 @@ static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr) { } break; - case AST_NODE_KIND_GLOBAL: + case Ast_Kind_Global: if (!expr->type->is_known) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, @@ -306,12 +306,12 @@ static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr) { } break; - case AST_NODE_KIND_ARGUMENT: - check_expression(state, ((AstNodeArgument *) expr)->value); - expr->type = ((AstNodeArgument *) expr)->value->type; + case Ast_Kind_Argument: + check_expression(state, ((AstArgument *) expr)->value); + expr->type = ((AstArgument *) expr)->value->type; break; - case AST_NODE_KIND_LITERAL: + case Ast_Kind_Literal: // NOTE: Literal types should have been decided // in the parser (for now). assert(expr->type->is_known); @@ -323,7 +323,7 @@ static void check_expression(OnyxSemPassState* state, AstNodeTyped* expr) { } } -static void check_global(OnyxSemPassState* state, AstNodeGlobal* global) { +static void check_global(OnyxSemPassState* state, AstGlobal* global) { if (global->initial_value) { check_expression(state, global->initial_value); @@ -353,12 +353,12 @@ static void check_global(OnyxSemPassState* state, AstNodeGlobal* global) { static void check_statement(OnyxSemPassState* state, AstNode* stmt) { switch (stmt->kind) { - case AST_NODE_KIND_ASSIGNMENT: check_assignment(state, (AstNodeAssign *) stmt); break; - case AST_NODE_KIND_RETURN: check_return(state, (AstNodeReturn *) stmt); break; - case AST_NODE_KIND_IF: check_if(state, (AstNodeIf *) stmt); break; - case AST_NODE_KIND_WHILE: check_while(state, (AstNodeWhile *) stmt); break; - case AST_NODE_KIND_CALL: check_call(state, (AstNodeCall *) stmt); break; - case AST_NODE_KIND_BLOCK: check_block(state, (AstNodeBlock *) stmt); break; + case Ast_Kind_Assignment: check_assignment(state, (AstAssign *) stmt); break; + case Ast_Kind_Return: check_return(state, (AstReturn *) stmt); break; + case Ast_Kind_If: check_if(state, (AstIf *) stmt); break; + case Ast_Kind_While: check_while(state, (AstWhile *) stmt); break; + case Ast_Kind_Call: check_call(state, (AstCall *) stmt); break; + case Ast_Kind_Block: check_block(state, (AstBlock *) stmt); break; default: break; } @@ -371,10 +371,10 @@ static void check_statement_chain(OnyxSemPassState* state, AstNode* start) { } } -static void check_block(OnyxSemPassState* state, AstNodeBlock* block) { +static void check_block(OnyxSemPassState* state, AstBlock* block) { check_statement_chain(state, block->body); - forll(AstNodeLocal, local, block->locals->last_local, prev_local) { + forll(AstLocal, local, block->locals->last_local, prev_local) { if (!local->base.type->is_known) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_UNRESOLVED_TYPE, @@ -385,8 +385,8 @@ static void check_block(OnyxSemPassState* state, AstNodeBlock* block) { } } -static void check_function(OnyxSemPassState* state, AstNodeFunction* func) { - for (AstNodeLocal *param = func->params; param != NULL; param = (AstNodeLocal *) param->base.next) { +static void check_function(OnyxSemPassState* state, AstFunction* func) { + for (AstLocal *param = func->params; param != NULL; param = (AstLocal *) param->base.next) { if (!param->base.type->is_known) { onyx_message_add(state->msgs, ONYX_MESSAGE_TYPE_LITERAL, @@ -412,9 +412,9 @@ static void check_function(OnyxSemPassState* state, AstNodeFunction* func) { void onyx_type_check(OnyxSemPassState* state, OnyxProgram* program) { - bh_arr_each(AstNodeGlobal *, global, program->globals) + bh_arr_each(AstGlobal *, global, program->globals) check_global(state, *global); - bh_arr_each(AstNodeFunction *, function, program->functions) + bh_arr_each(AstFunction *, function, program->functions) check_function(state, *function); } diff --git a/src/onyxlex.c b/src/onyxlex.c index ae206870..7d6eabaf 100644 --- a/src/onyxlex.c +++ b/src/onyxlex.c @@ -79,10 +79,10 @@ static b32 token_lit(OnyxTokenizer* tokenizer, OnyxToken* tk, char* lit, b32 is_ } const char* onyx_get_token_type_name(TokenType tkn_type) { - if (tkn_type < TOKEN_TYPE_ASCII_END) { + if (tkn_type < Token_Type_Ascii_End) { return bh_aprintf(global_scratch_allocator, "%c", (char) tkn_type); } else { - return token_type_names[tkn_type - TOKEN_TYPE_ASCII_END]; + return token_type_names[tkn_type - Token_Type_Ascii_End]; } } @@ -100,7 +100,7 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) { while (char_is_whitespace(*tokenizer->curr) && tokenizer->curr != tokenizer->end) INCREMENT_CURR_TOKEN(tokenizer) - tk.type = TOKEN_TYPE_UNKNOWN; + tk.type = Token_Type_Unknown; tk.text = tokenizer->curr; tk.length = 1; tk.pos.line_start = tokenizer->line_start; @@ -109,14 +109,14 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) { tk.pos.column = (i32)(tokenizer->curr - tokenizer->line_start) + 1; if (tokenizer->curr == tokenizer->end) { - tk.type = TOKEN_TYPE_END_STREAM; + tk.type = Token_Type_End_Stream; goto token_parsed; } // Comments if (*tokenizer->curr == '/' && *(tokenizer->curr + 1) == '/') { tokenizer->curr += 2; - tk.type = TOKEN_TYPE_COMMENT; + tk.type = Token_Type_Comment; tk.text = tokenizer->curr; while (*tokenizer->curr != '\n') { @@ -127,32 +127,32 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) { goto token_parsed; } - LITERAL_TOKEN("struct", 1, TOKEN_TYPE_KEYWORD_STRUCT); - LITERAL_TOKEN("export", 1, TOKEN_TYPE_KEYWORD_EXPORT); - LITERAL_TOKEN("use", 1, TOKEN_TYPE_KEYWORD_USE); - LITERAL_TOKEN("if", 1, TOKEN_TYPE_KEYWORD_IF); - LITERAL_TOKEN("elseif", 1, TOKEN_TYPE_KEYWORD_ELSEIF); - LITERAL_TOKEN("else", 1, TOKEN_TYPE_KEYWORD_ELSE); - LITERAL_TOKEN("foreign", 1, TOKEN_TYPE_KEYWORD_FOREIGN); - LITERAL_TOKEN("return", 1, TOKEN_TYPE_KEYWORD_RETURN); - LITERAL_TOKEN("proc", 1, TOKEN_TYPE_KEYWORD_PROC); - LITERAL_TOKEN("as", 1, TOKEN_TYPE_KEYWORD_CAST); - LITERAL_TOKEN("while", 1, TOKEN_TYPE_KEYWORD_WHILE); - LITERAL_TOKEN("break", 1, TOKEN_TYPE_KEYWORD_BREAK); - LITERAL_TOKEN("continue", 1, TOKEN_TYPE_KEYWORD_CONTINUE); - LITERAL_TOKEN("true", 1, TOKEN_TYPE_LITERAL_BOOL_TRUE); - LITERAL_TOKEN("false", 1, TOKEN_TYPE_LITERAL_BOOL_FALSE); - LITERAL_TOKEN("->", 0, TOKEN_TYPE_RIGHT_ARROW); - LITERAL_TOKEN("<-", 0, TOKEN_TYPE_RIGHT_ARROW); - LITERAL_TOKEN("<=", 0, TOKEN_TYPE_LESS_EQUAL); - LITERAL_TOKEN(">=", 0, TOKEN_TYPE_GREATER_EQUAL); - LITERAL_TOKEN("==", 0, TOKEN_TYPE_EQUAL_EQUAL); - LITERAL_TOKEN("!=", 0, TOKEN_TYPE_NOT_EQUAL); - LITERAL_TOKEN("+=", 0, TOKEN_TYPE_PLUS_EQUAL); - LITERAL_TOKEN("-=", 0, TOKEN_TYPE_MINUS_EQUAL); - LITERAL_TOKEN("*=", 0, TOKEN_TYPE_STAR_EQUAL); - LITERAL_TOKEN("/=", 0, TOKEN_TYPE_FSLASH_EQUAL); - LITERAL_TOKEN("%=", 0, TOKEN_TYPE_PERCENT_EQUAL); + LITERAL_TOKEN("struct", 1, Token_Type_Keyword_Struct); + LITERAL_TOKEN("export", 1, Token_Type_Keyword_Export); + LITERAL_TOKEN("use", 1, Token_Type_Keyword_Use); + LITERAL_TOKEN("if", 1, Token_Type_Keyword_If); + LITERAL_TOKEN("elseif", 1, Token_Type_Keyword_Elseif); + LITERAL_TOKEN("else", 1, Token_Type_Keyword_Else); + LITERAL_TOKEN("foreign", 1, Token_Type_Keyword_Foreign); + LITERAL_TOKEN("return", 1, Token_Type_Keyword_Return); + LITERAL_TOKEN("proc", 1, Token_Type_Keyword_Proc); + LITERAL_TOKEN("as", 1, Token_Type_Keyword_Cast); + LITERAL_TOKEN("while", 1, Token_Type_Keyword_While); + LITERAL_TOKEN("break", 1, Token_Type_Keyword_Break); + LITERAL_TOKEN("continue", 1, Token_Type_Keyword_Continue); + LITERAL_TOKEN("true", 1, Token_Type_Literal_True); + LITERAL_TOKEN("false", 1, Token_Type_Literal_False); + LITERAL_TOKEN("->", 0, Token_Type_Right_Arrow); + LITERAL_TOKEN("<-", 0, Token_Type_Right_Arrow); + LITERAL_TOKEN("<=", 0, Token_Type_Less_Equal); + LITERAL_TOKEN(">=", 0, Token_Type_Greater_Equal); + LITERAL_TOKEN("==", 0, Token_Type_Equal_Equal); + LITERAL_TOKEN("!=", 0, Token_Type_Not_Equal); + LITERAL_TOKEN("+=", 0, Token_Type_Plus_Equal); + LITERAL_TOKEN("-=", 0, Token_Type_Minus_Equal); + LITERAL_TOKEN("*=", 0, Token_Type_Star_Equal); + LITERAL_TOKEN("/=", 0, Token_Type_Fslash_Equal); + LITERAL_TOKEN("%=", 0, Token_Type_Percent_Equal); // Symbols if (char_is_alpha(*tk.text)) { @@ -163,7 +163,7 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) { } tk.length = len; - tk.type = TOKEN_TYPE_SYMBOL; + tk.type = Token_Type_Symbol; goto token_parsed; } @@ -190,7 +190,7 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) { INCREMENT_CURR_TOKEN(tokenizer); tk.text++; - tk.type = TOKEN_TYPE_LITERAL_STRING; + tk.type = Token_Type_Literal_String; tk.length = len; goto token_parsed; } @@ -208,7 +208,7 @@ OnyxToken* onyx_get_token(OnyxTokenizer* tokenizer) { INCREMENT_CURR_TOKEN(tokenizer); } - tk.type = TOKEN_TYPE_LITERAL_NUMERIC; + tk.type = Token_Type_Literal_Numeric; tk.length = len; INCREMENT_CURR_TOKEN(tokenizer); @@ -249,5 +249,5 @@ void onyx_lex_tokens(OnyxTokenizer* tokenizer) { OnyxToken* tk; do { tk = onyx_get_token(tokenizer); - } while (tk->type != TOKEN_TYPE_END_STREAM); + } while (tk->type != Token_Type_End_Stream); } diff --git a/src/onyxparser.c b/src/onyxparser.c index 260217a7..0f5fb536 100644 --- a/src/onyxparser.c +++ b/src/onyxparser.c @@ -25,36 +25,36 @@ struct TypeInfo builtin_types[] = { { 0xffffffff } // Sentinel }; -static AstNode error_node = { AST_NODE_KIND_ERROR, 0, NULL, NULL }; +static AstNode error_node = { Ast_Kind_Error, 0, NULL, NULL }; // NOTE: Forward declarations static void parser_next_token(OnyxParser* parser); static void parser_prev_token(OnyxParser* parser); static b32 is_terminating_token(TokenType token_type); static OnyxToken* expect(OnyxParser* parser, TokenType token_type); -static AstNodeNumLit* parse_numeric_literal(OnyxParser* parser); -static AstNodeTyped* parse_factor(OnyxParser* parser); -static AstNodeTyped* parse_expression(OnyxParser* parser); -static AstNodeIf* parse_if_stmt(OnyxParser* parser); -static AstNodeWhile* parse_while_stmt(OnyxParser* parser); +static AstNumLit* parse_numeric_literal(OnyxParser* parser); +static AstTyped* parse_factor(OnyxParser* parser); +static AstTyped* parse_expression(OnyxParser* parser); +static AstIf* parse_if_stmt(OnyxParser* parser); +static AstWhile* parse_while_stmt(OnyxParser* parser); static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret); -static AstNodeReturn* parse_return_statement(OnyxParser* parser); -static AstNodeBlock* parse_block(OnyxParser* parser); +static AstReturn* parse_return_statement(OnyxParser* parser); +static AstBlock* parse_block(OnyxParser* parser); static AstNode* parse_statement(OnyxParser* parser); -static TypeInfo* parse_type(OnyxParser* parser); -static AstNodeLocal* parse_function_params(OnyxParser* parser); -static AstNodeFunction* parse_function_definition(OnyxParser* parser); +static AstNode* parse_type(OnyxParser* parser); +static AstLocal* parse_function_params(OnyxParser* parser); +static AstFunction* parse_function_definition(OnyxParser* parser); static AstNode* parse_top_level_statement(OnyxParser* parser); static void parser_next_token(OnyxParser* parser) { parser->prev_token = parser->curr_token; parser->curr_token++; - while (parser->curr_token->type == TOKEN_TYPE_COMMENT) parser->curr_token++; + while (parser->curr_token->type == Token_Type_Comment) parser->curr_token++; } static void parser_prev_token(OnyxParser* parser) { // TODO: This is probably wrong - while (parser->prev_token->type == TOKEN_TYPE_COMMENT) parser->prev_token--; + while (parser->prev_token->type == Token_Type_Comment) parser->prev_token--; parser->curr_token = parser->prev_token; parser->prev_token--; } @@ -63,7 +63,7 @@ static b32 is_terminating_token(TokenType token_type) { return (token_type == ';') || (token_type == '}') || (token_type == '{') - || (token_type == TOKEN_TYPE_END_STREAM); + || (token_type == Token_Type_End_Stream); } static void find_token(OnyxParser* parser, TokenType token_type) { @@ -88,10 +88,10 @@ static OnyxToken* expect(OnyxParser* parser, TokenType token_type) { return token; } -static AstNodeNumLit* parse_numeric_literal(OnyxParser* parser) { - AstNodeNumLit* lit_node = make_node(AstNodeNumLit, AST_NODE_KIND_LITERAL); - lit_node->base.token = expect(parser, TOKEN_TYPE_LITERAL_NUMERIC); - lit_node->base.flags |= ONYX_AST_FLAG_COMPTIME; +static AstNumLit* parse_numeric_literal(OnyxParser* parser) { + AstNumLit* lit_node = make_node(AstNumLit, Ast_Kind_Literal); + lit_node->base.token = expect(parser, Token_Type_Literal_Numeric); + lit_node->base.flags |= Ast_Flag_Comptime; lit_node->value.l = 0ll; onyx_token_null_toggle(lit_node->base.token); @@ -125,14 +125,14 @@ static AstNodeNumLit* parse_numeric_literal(OnyxParser* parser) { return lit_node; } -static AstNodeTyped* parse_factor(OnyxParser* parser) { - AstNodeTyped* retval = NULL; +static AstTyped* parse_factor(OnyxParser* parser) { + AstTyped* retval = NULL; switch ((u16) parser->curr_token->type) { case '(': { parser_next_token(parser); - AstNodeTyped* expr = parse_expression(parser); + AstTyped* expr = parse_expression(parser); expect(parser, ')'); retval = expr; break; @@ -141,24 +141,24 @@ static AstNodeTyped* parse_factor(OnyxParser* parser) { case '-': { parser_next_token(parser); - AstNodeTyped* factor = parse_factor(parser); + AstTyped* factor = parse_factor(parser); - AstNodeUnaryOp* negate_node = make_node(AstNodeUnaryOp, AST_NODE_KIND_UNARY_OP); - negate_node->operation = ONYX_UNARY_OP_NEGATE; + AstUnaryOp* negate_node = make_node(AstUnaryOp, Ast_Kind_Unary_Op); + negate_node->operation = Unary_Op_Negate; negate_node->expr = factor; - if ((factor->flags & ONYX_AST_FLAG_COMPTIME) != 0) { - negate_node->base.flags |= ONYX_AST_FLAG_COMPTIME; + if ((factor->flags & Ast_Flag_Comptime) != 0) { + negate_node->base.flags |= Ast_Flag_Comptime; } - retval = (AstNodeTyped *) negate_node; + retval = (AstTyped *) negate_node; break; } - case TOKEN_TYPE_SYMBOL: + case Token_Type_Symbol: { - OnyxToken* sym_token = expect(parser, TOKEN_TYPE_SYMBOL); - AstNodeTyped* sym_node = make_node(AstNode, AST_NODE_KIND_SYMBOL); + OnyxToken* sym_token = expect(parser, Token_Type_Symbol); + AstTyped* sym_node = make_node(AstTyped, Ast_Kind_Symbol); sym_node->token = sym_token; if (parser->curr_token->type != '(') { @@ -167,19 +167,19 @@ static AstNodeTyped* parse_factor(OnyxParser* parser) { } // NOTE: Function call - AstNodeCall* call_node = make_node(AstNodeCall, AST_NODE_KIND_CALL); + AstCall* call_node = make_node(AstCall, Ast_Kind_Call); call_node->base.token = expect(parser, '('); call_node->callee = (AstNode *) sym_node; - AstNodeArgument** prev = &call_node->arguments; - AstNodeArgument* curr = NULL; + AstArgument** prev = &call_node->arguments; + AstArgument* curr = NULL; while (parser->curr_token->type != ')') { - curr = make_node(AstNodeArgument, AST_NODE_KIND_ARGUMENT); + curr = make_node(AstArgument, Ast_Kind_Argument); curr->value = parse_expression(parser); - if (curr != NULL && curr->base.kind != AST_NODE_KIND_ERROR) { + if (curr != NULL && curr->base.kind != Ast_Kind_Error) { *prev = curr; - prev = (AstNodeArgument **) &curr->base.next; + prev = (AstArgument **) &curr->base.next; } if (parser->curr_token->type == ')') @@ -191,38 +191,38 @@ static AstNodeTyped* parse_factor(OnyxParser* parser) { parser->curr_token->pos, onyx_get_token_type_name(','), onyx_get_token_type_name(parser->curr_token->type)); - return (AstNodeTyped *) &error_node; + return (AstTyped *) &error_node; } parser_next_token(parser); } parser_next_token(parser); - retval = (AstNodeTyped *) call_node; + retval = (AstTyped *) call_node; break; } - case TOKEN_TYPE_LITERAL_NUMERIC: - retval = (AstNodeTyped *) parse_numeric_literal(parser); + case Token_Type_Literal_Numeric: + retval = (AstTyped *) parse_numeric_literal(parser); break; - case TOKEN_TYPE_LITERAL_BOOL_TRUE: + case Token_Type_Literal_True: { - AstNodeNumLit* bool_node = make_node(AstNodeNumLit, AST_NODE_KIND_LITERAL); + AstNumLit* bool_node = make_node(AstNumLit, Ast_Kind_Literal); bool_node->base.type = &builtin_types[TYPE_INFO_KIND_BOOL]; - bool_node->base.token = expect(parser, TOKEN_TYPE_LITERAL_BOOL_TRUE); + bool_node->base.token = expect(parser, Token_Type_Literal_True); bool_node->value.i = 1; - retval = (AstNodeTyped *) bool_node; + retval = (AstTyped *) bool_node; break; } - case TOKEN_TYPE_LITERAL_BOOL_FALSE: + case Token_Type_Literal_False: { - AstNodeNumLit* bool_node = make_node(AstNodeNumLit, AST_NODE_KIND_LITERAL); + AstNumLit* bool_node = make_node(AstNumLit, Ast_Kind_Literal); bool_node->base.type = &builtin_types[TYPE_INFO_KIND_BOOL]; - bool_node->base.token = expect(parser, TOKEN_TYPE_LITERAL_BOOL_FALSE); + bool_node->base.token = expect(parser, Token_Type_Literal_False); bool_node->value.i = 0; - retval = (AstNodeTyped *) bool_node; + retval = (AstTyped *) bool_node; break; } @@ -234,67 +234,67 @@ static AstNodeTyped* parse_factor(OnyxParser* parser) { return NULL; } - if (parser->curr_token->type == TOKEN_TYPE_KEYWORD_CAST) { + if (parser->curr_token->type == Token_Type_Keyword_Cast) { parser_next_token(parser); - AstNodeUnaryOp* cast_node = make_node(AstNodeUnaryOp, AST_NODE_KIND_UNARY_OP); + AstUnaryOp* cast_node = make_node(AstUnaryOp, Ast_Kind_Unary_Op); cast_node->base.type = parse_type(parser); - cast_node->operation = ONYX_UNARY_OP_CAST; + cast_node->operation = Unary_Op_Cast; cast_node->expr = retval; - retval = (AstNodeTyped *) cast_node; + retval = (AstTyped *) cast_node; } return retval; } -static inline i32 get_precedence(OnyxBinaryOp kind) { +static inline i32 get_precedence(BinaryOp kind) { switch (kind) { - case ONYX_BINARY_OP_EQUAL: return 3; - case ONYX_BINARY_OP_NOT_EQUAL: return 3; + case Binary_Op_Equal: return 3; + case Binary_Op_Not_Equal: return 3; - case ONYX_BINARY_OP_LESS_EQUAL: return 4; - case ONYX_BINARY_OP_LESS: return 4; - case ONYX_BINARY_OP_GREATER_EQUAL: return 4; - case ONYX_BINARY_OP_GREATER: return 4; + case Binary_Op_Less_Equal: return 4; + case Binary_Op_Less: return 4; + case Binary_Op_Greater_Equal: return 4; + case Binary_Op_Greater: return 4; - case ONYX_BINARY_OP_ADD: return 5; - case ONYX_BINARY_OP_MINUS: return 5; + case Binary_Op_Add: return 5; + case Binary_Op_Minus: return 5; - case ONYX_BINARY_OP_MULTIPLY: return 6; - case ONYX_BINARY_OP_DIVIDE: return 6; + case Binary_Op_Multiply: return 6; + case Binary_Op_Divide: return 6; - case ONYX_BINARY_OP_MODULUS: return 7; + case Binary_Op_Modulus: return 7; default: return -1; } } -static AstNodeTyped* parse_expression(OnyxParser* parser) { - bh_arr(AstNodeBinOp*) tree_stack = NULL; +static AstTyped* parse_expression(OnyxParser* parser) { + bh_arr(AstBinaryOp*) tree_stack = NULL; bh_arr_new(global_scratch_allocator, tree_stack, 4); bh_arr_set_length(tree_stack, 0); - AstNodeTyped* left = parse_factor(parser); - AstNodeTyped* right; - AstNodeTyped* root = left; + AstTyped* left = parse_factor(parser); + AstTyped* right; + AstTyped* root = left; - OnyxBinaryOp bin_op_kind; + BinaryOp bin_op_kind; OnyxToken* bin_op_tok; while (1) { bin_op_kind = -1; switch ((u16) parser->curr_token->type) { - case TOKEN_TYPE_EQUAL_EQUAL: bin_op_kind = ONYX_BINARY_OP_EQUAL; break; - case TOKEN_TYPE_NOT_EQUAL: bin_op_kind = ONYX_BINARY_OP_NOT_EQUAL; break; - case TOKEN_TYPE_LESS_EQUAL: bin_op_kind = ONYX_BINARY_OP_LESS_EQUAL; break; - case TOKEN_TYPE_GREATER_EQUAL: bin_op_kind = ONYX_BINARY_OP_GREATER_EQUAL; break; - case '<': bin_op_kind = ONYX_BINARY_OP_LESS; break; - case '>': bin_op_kind = ONYX_BINARY_OP_GREATER; break; - - case '+': bin_op_kind = ONYX_BINARY_OP_ADD; break; - case '-': bin_op_kind = ONYX_BINARY_OP_MINUS; break; - case '*': bin_op_kind = ONYX_BINARY_OP_MULTIPLY; break; - case '/': bin_op_kind = ONYX_BINARY_OP_DIVIDE; break; - case '%': bin_op_kind = ONYX_BINARY_OP_MODULUS; break; + case Token_Type_Equal_Equal: bin_op_kind = Binary_Op_Equal; break; + case Token_Type_Not_Equal: bin_op_kind = Binary_Op_Not_Equal; break; + case Token_Type_Less_Equal: bin_op_kind = Binary_Op_Less_Equal; break; + case Token_Type_Greater_Equal: bin_op_kind = Binary_Op_Greater_Equal; break; + case '<': bin_op_kind = Binary_Op_Less; break; + case '>': bin_op_kind = Binary_Op_Greater; break; + + case '+': bin_op_kind = Binary_Op_Add; break; + case '-': bin_op_kind = Binary_Op_Minus; break; + case '*': bin_op_kind = Binary_Op_Multiply; break; + case '/': bin_op_kind = Binary_Op_Divide; break; + case '%': bin_op_kind = Binary_Op_Modulus; break; default: goto expression_done; } @@ -302,7 +302,7 @@ static AstNodeTyped* parse_expression(OnyxParser* parser) { bin_op_tok = parser->curr_token; parser_next_token(parser); - AstNodeBinOp* bin_op = make_node(AstNodeBinOp, AST_NODE_KIND_BIN_OP); + AstBinaryOp* bin_op = make_node(AstBinaryOp, Ast_Kind_Binary_Op); bin_op->operation = bin_op_kind; bin_op->base.token = bin_op_tok; @@ -313,10 +313,10 @@ static AstNodeTyped* parse_expression(OnyxParser* parser) { if (bh_arr_is_empty(tree_stack)) { // NOTE: new is now the root node bin_op->left = root; - root = (AstNodeTyped *) bin_op; + root = (AstTyped *) bin_op; } else { bin_op->left = bh_arr_last(tree_stack)->right; - bh_arr_last(tree_stack)->right = (AstNodeTyped *) bin_op; + bh_arr_last(tree_stack)->right = (AstTyped *) bin_op; } bh_arr_push(tree_stack, bin_op); @@ -324,8 +324,8 @@ static AstNodeTyped* parse_expression(OnyxParser* parser) { right = parse_factor(parser); bin_op->right = right; - if ((left->flags & ONYX_AST_FLAG_COMPTIME) != 0 && (right->flags & ONYX_AST_FLAG_COMPTIME) != 0) { - bin_op->base.flags |= ONYX_AST_FLAG_COMPTIME; + if ((left->flags & Ast_Flag_Comptime) != 0 && (right->flags & Ast_Flag_Comptime) != 0) { + bin_op->base.flags |= Ast_Flag_Comptime; } } } @@ -334,22 +334,22 @@ expression_done: return root; } -static AstNodeIf* parse_if_stmt(OnyxParser* parser) { - expect(parser, TOKEN_TYPE_KEYWORD_IF); +static AstIf* parse_if_stmt(OnyxParser* parser) { + expect(parser, Token_Type_Keyword_If); - AstNodeTyped* cond = parse_expression(parser); - AstNodeBlock* true_block = parse_block(parser); + AstTyped* cond = parse_expression(parser); + AstBlock* true_block = parse_block(parser); - AstNodeIf* if_node = make_node(AstNodeIf, AST_NODE_KIND_IF); - AstNodeIf* root_if = if_node; + AstIf* if_node = make_node(AstIf, Ast_Kind_If); + AstIf* root_if = if_node; if_node->cond = cond; if (true_block != NULL) if_node->true_block.as_block = true_block; - while (parser->curr_token->type == TOKEN_TYPE_KEYWORD_ELSEIF) { + while (parser->curr_token->type == Token_Type_Keyword_Elseif) { parser_next_token(parser); - AstNodeIf* elseif_node = make_node(AstNodeIf, AST_NODE_KIND_IF); + AstIf* elseif_node = make_node(AstIf, Ast_Kind_If); cond = parse_expression(parser); true_block = parse_block(parser); @@ -362,10 +362,10 @@ static AstNodeIf* parse_if_stmt(OnyxParser* parser) { if_node = elseif_node; } - if (parser->curr_token->type == TOKEN_TYPE_KEYWORD_ELSE) { + if (parser->curr_token->type == Token_Type_Keyword_Else) { parser_next_token(parser); - AstNodeBlock* false_block = parse_block(parser); + AstBlock* false_block = parse_block(parser); if (false_block != NULL) if_node->false_block.as_block = false_block; } @@ -373,13 +373,13 @@ static AstNodeIf* parse_if_stmt(OnyxParser* parser) { return root_if; } -static AstNodeWhile* parse_while_stmt(OnyxParser* parser) { - OnyxToken* while_token = expect(parser, TOKEN_TYPE_KEYWORD_WHILE); +static AstWhile* parse_while_stmt(OnyxParser* parser) { + OnyxToken* while_token = expect(parser, Token_Type_Keyword_While); - AstNodeTyped* cond = parse_expression(parser); - AstNodeBlock* body = parse_block(parser); + AstTyped* cond = parse_expression(parser); + AstBlock* body = parse_block(parser); - AstNodeWhile* while_node = make_node(AstNodeWhile, AST_NODE_KIND_WHILE); + AstWhile* while_node = make_node(AstWhile, Ast_Kind_While); while_node->base.token = while_token; while_node->cond = cond; while_node->body = body; @@ -390,8 +390,8 @@ static AstNodeWhile* parse_while_stmt(OnyxParser* parser) { // Returns 1 if the symbol was consumed. Returns 0 otherwise // ret is set to the statement to insert static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) { - if (parser->curr_token->type != TOKEN_TYPE_SYMBOL) return 0; - OnyxToken* symbol = expect(parser, TOKEN_TYPE_SYMBOL); + if (parser->curr_token->type != Token_Type_Symbol) return 0; + OnyxToken* symbol = expect(parser, Token_Type_Symbol); switch ((u16) parser->curr_token->type) { // NOTE: Declaration @@ -401,27 +401,27 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) { TypeInfo* type = &builtin_types[TYPE_INFO_KIND_UNKNOWN]; // NOTE: var: type - if (parser->curr_token->type == TOKEN_TYPE_SYMBOL) { + if (parser->curr_token->type == Token_Type_Symbol) { type = parse_type(parser); } - AstNodeLocal* local = make_node(AstNodeLocal, AST_NODE_KIND_LOCAL); + AstLocal* local = make_node(AstLocal, Ast_Kind_Local); local->base.token = symbol; local->base.type = type; - local->base.flags |= ONYX_AST_FLAG_LVAL; // NOTE: DELETE + local->base.flags |= Ast_Flag_Lval; // NOTE: DELETE *ret = (AstNode *) local; if (parser->curr_token->type == '=' || parser->curr_token->type == ':') { if (parser->curr_token->type == ':') { - local->base.flags |= ONYX_AST_FLAG_CONST; + local->base.flags |= Ast_Flag_Const; } - AstNodeAssign* assignment = make_node(AstNodeAssign, AST_NODE_KIND_ASSIGNMENT); + AstAssign* assignment = make_node(AstAssign, Ast_Kind_Assignment); local->base.next = (AstNode *) assignment; assignment->base.token = parser->curr_token; parser_next_token(parser); - AstNodeTyped* expr = parse_expression(parser); + AstTyped* expr = parse_expression(parser); if (expr == NULL) { onyx_token_null_toggle(parser->curr_token); onyx_message_add(parser->msgs, @@ -433,9 +433,9 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) { } assignment->expr = expr; - AstNode* left_symbol = make_node(AstNode, AST_NODE_KIND_SYMBOL); + AstNode* left_symbol = make_node(AstNode, Ast_Kind_Symbol); left_symbol->token = symbol; - assignment->lval = (AstNodeTyped *) left_symbol; + assignment->lval = (AstTyped *) left_symbol; } return 1; } @@ -443,52 +443,52 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) { // NOTE: Assignment case '=': { - AstNodeAssign* assignment = make_node(AstNodeAssign, AST_NODE_KIND_ASSIGNMENT); + AstAssign* assignment = make_node(AstAssign, Ast_Kind_Assignment); assignment->base.token = parser->curr_token; parser_next_token(parser); - AstNode* lval = make_node(AstNode, AST_NODE_KIND_SYMBOL); + AstNode* lval = make_node(AstNode, Ast_Kind_Symbol); lval->token = symbol; - AstNodeTyped* rval = parse_expression(parser); + AstTyped* rval = parse_expression(parser); assignment->expr = rval; - assignment->lval = (AstNodeTyped *) lval; + assignment->lval = (AstTyped *) lval; *ret = (AstNode *) assignment; return 1; } - case TOKEN_TYPE_PLUS_EQUAL: - case TOKEN_TYPE_MINUS_EQUAL: - case TOKEN_TYPE_STAR_EQUAL: - case TOKEN_TYPE_FSLASH_EQUAL: - case TOKEN_TYPE_PERCENT_EQUAL: + case Token_Type_Plus_Equal: + case Token_Type_Minus_Equal: + case Token_Type_Star_Equal: + case Token_Type_Fslash_Equal: + case Token_Type_Percent_Equal: { - OnyxBinaryOp bin_op; - if (parser->curr_token->type == TOKEN_TYPE_PLUS_EQUAL) bin_op = ONYX_BINARY_OP_ADD; - else if (parser->curr_token->type == TOKEN_TYPE_MINUS_EQUAL) bin_op = ONYX_BINARY_OP_MINUS; - else if (parser->curr_token->type == TOKEN_TYPE_STAR_EQUAL) bin_op = ONYX_BINARY_OP_MULTIPLY; - else if (parser->curr_token->type == TOKEN_TYPE_FSLASH_EQUAL) bin_op = ONYX_BINARY_OP_DIVIDE; - else if (parser->curr_token->type == TOKEN_TYPE_PERCENT_EQUAL) bin_op = ONYX_BINARY_OP_MODULUS; + BinaryOp bin_op; + if (parser->curr_token->type == Token_Type_Plus_Equal) bin_op = Binary_Op_Add; + else if (parser->curr_token->type == Token_Type_Minus_Equal) bin_op = Binary_Op_Minus; + else if (parser->curr_token->type == Token_Type_Star_Equal) bin_op = Binary_Op_Multiply; + else if (parser->curr_token->type == Token_Type_Fslash_Equal) bin_op = Binary_Op_Divide; + else if (parser->curr_token->type == Token_Type_Percent_Equal) bin_op = Binary_Op_Modulus; parser_next_token(parser); - AstNodeTyped* expr = parse_expression(parser); + AstTyped* expr = parse_expression(parser); - AstNodeBinOp* bin_op_node = make_node(AstNodeBinOp, AST_NODE_KIND_BIN_OP); + AstBinaryOp* bin_op_node = make_node(AstBinaryOp, Ast_Kind_Binary_Op); bin_op_node->operation = bin_op; - AstNode* bin_op_left = make_node(AstNode, AST_NODE_KIND_SYMBOL); + AstNode* bin_op_left = make_node(AstNode, Ast_Kind_Symbol); bin_op_left->token = symbol; - bin_op_node->left = (AstNodeTyped *) bin_op_left; + bin_op_node->left = (AstTyped *) bin_op_left; bin_op_node->right = expr; - AstNodeAssign* assign_node = make_node(AstNodeAssign, AST_NODE_KIND_ASSIGNMENT); + AstAssign* assign_node = make_node(AstAssign, Ast_Kind_Assignment); // TODO: Maybe I don't need to make another lval node? - AstNode* lval = make_node(AstNode, AST_NODE_KIND_SYMBOL); + AstNode* lval = make_node(AstNode, Ast_Kind_Symbol); lval->token = symbol; - assign_node->lval = (AstNodeTyped *) lval; - assign_node->expr = (AstNodeTyped *) bin_op_node; + assign_node->lval = (AstTyped *) lval; + assign_node->expr = (AstTyped *) bin_op_node; *ret = (AstNode *) assign_node; @@ -502,17 +502,17 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) { return 0; } -static AstNodeReturn* parse_return_statement(OnyxParser* parser) { - AstNodeReturn* return_node = make_node(AstNodeReturn, AST_NODE_KIND_RETURN); - return_node->base.token = expect(parser, TOKEN_TYPE_KEYWORD_RETURN); +static AstReturn* parse_return_statement(OnyxParser* parser) { + AstReturn* return_node = make_node(AstReturn, Ast_Kind_Return); + return_node->base.token = expect(parser, Token_Type_Keyword_Return); - AstNodeTyped* expr = NULL; + AstTyped* expr = NULL; if (parser->curr_token->type != ';') { expr = parse_expression(parser); - if (expr == NULL || expr == (AstNodeTyped *) &error_node) { - return (AstNodeReturn *) &error_node; + if (expr == NULL || expr == (AstTyped *) &error_node) { + return (AstReturn *) &error_node; } else { return_node->expr = expr; } @@ -526,7 +526,7 @@ static AstNode* parse_statement(OnyxParser* parser) { AstNode* retval = NULL; switch ((u16) parser->curr_token->type) { - case TOKEN_TYPE_KEYWORD_RETURN: + case Token_Type_Keyword_Return: retval = (AstNode *) parse_return_statement(parser); break; @@ -535,7 +535,7 @@ static AstNode* parse_statement(OnyxParser* parser) { retval = (AstNode *) parse_block(parser); break; - case TOKEN_TYPE_SYMBOL: + case Token_Type_Symbol: if (parse_symbol_statement(parser, &retval)) break; // fallthrough @@ -543,29 +543,29 @@ static AstNode* parse_statement(OnyxParser* parser) { case '+': case '-': case '!': - case TOKEN_TYPE_LITERAL_NUMERIC: - case TOKEN_TYPE_LITERAL_STRING: + case Token_Type_Literal_Numeric: + case Token_Type_Literal_String: retval = (AstNode *) parse_expression(parser); break; - case TOKEN_TYPE_KEYWORD_IF: + case Token_Type_Keyword_If: needs_semicolon = 0; retval = (AstNode *) parse_if_stmt(parser); break; - case TOKEN_TYPE_KEYWORD_WHILE: + case Token_Type_Keyword_While: needs_semicolon = 0; retval = (AstNode *) parse_while_stmt(parser); break; - case TOKEN_TYPE_KEYWORD_BREAK: - retval = make_node(AstNode, AST_NODE_KIND_BREAK); - retval->token = expect(parser, TOKEN_TYPE_KEYWORD_BREAK); + case Token_Type_Keyword_Break: + retval = make_node(AstNode, Ast_Kind_Break); + retval->token = expect(parser, Token_Type_Keyword_Break); break; - case TOKEN_TYPE_KEYWORD_CONTINUE: - retval = make_node(AstNode, AST_NODE_KIND_BREAK); - retval->token = expect(parser, TOKEN_TYPE_KEYWORD_CONTINUE); + case Token_Type_Keyword_Continue: + retval = make_node(AstNode, Ast_Kind_Break); + retval->token = expect(parser, Token_Type_Keyword_Continue); break; default: @@ -588,9 +588,9 @@ static AstNode* parse_statement(OnyxParser* parser) { return retval; } -static AstNodeBlock* parse_block(OnyxParser* parser) { - AstNodeBlock* block = make_node(AstNodeBlock, AST_NODE_KIND_BLOCK); - AstNodeLocalGroup* lg = make_node(AstNodeLocalGroup, AST_NODE_KIND_LOCAL_GROUP); +static AstBlock* parse_block(OnyxParser* parser) { + AstBlock* block = make_node(AstBlock, Ast_Kind_Block); + AstLocalGroup* lg = make_node(AstLocalGroup, Ast_Kind_Local_Group); block->locals = lg; // --- is for an empty block @@ -608,7 +608,7 @@ static AstNodeBlock* parse_block(OnyxParser* parser) { while (parser->curr_token->type != '}') { stmt = parse_statement(parser); - if (stmt != NULL && stmt->kind != AST_NODE_KIND_ERROR) { + if (stmt != NULL && stmt->kind != Ast_Kind_Error) { *next = stmt; while (stmt->next != NULL) stmt = stmt->next; @@ -624,7 +624,7 @@ static AstNodeBlock* parse_block(OnyxParser* parser) { static TypeInfo* parse_type(OnyxParser* parser) { TypeInfo* type_info = &builtin_types[TYPE_INFO_KIND_UNKNOWN]; - OnyxToken* symbol = expect(parser, TOKEN_TYPE_SYMBOL); + OnyxToken* symbol = expect(parser, Token_Type_Symbol); if (symbol == NULL) return type_info; onyx_token_null_toggle(symbol); @@ -632,9 +632,9 @@ static TypeInfo* parse_type(OnyxParser* parser) { if (!bh_table_has(AstNode*, parser->identifiers, symbol->text)) { onyx_message_add(parser->msgs, ONYX_MESSAGE_TYPE_UNKNOWN_TYPE, symbol->pos, symbol->text); } else { - AstNodeTyped* type_info_node = bh_table_get(AstNodeTyped*, parser->identifiers, symbol->text); + AstTyped* type_info_node = bh_table_get(AstTyped*, parser->identifiers, symbol->text); - if (type_info_node->kind == AST_NODE_KIND_TYPE) { + if (type_info_node->kind == Ast_Kind_Type) { type_info = type_info_node->type; } } @@ -643,7 +643,7 @@ static TypeInfo* parse_type(OnyxParser* parser) { return type_info; } -static AstNodeLocal* parse_function_params(OnyxParser* parser) { +static AstLocal* parse_function_params(OnyxParser* parser) { if (parser->curr_token->type != '(') return NULL; @@ -654,20 +654,20 @@ static AstNodeLocal* parse_function_params(OnyxParser* parser) { return NULL; } - AstNodeLocal* first_param = NULL; - AstNodeLocal* curr_param = NULL; - AstNodeLocal* trailer = NULL; + AstLocal* first_param = NULL; + AstLocal* curr_param = NULL; + AstLocal* trailer = NULL; OnyxToken* symbol; while (parser->curr_token->type != ')') { if (parser->curr_token->type == ',') parser_next_token(parser); - symbol = expect(parser, TOKEN_TYPE_SYMBOL); + symbol = expect(parser, Token_Type_Symbol); expect(parser, ':'); - curr_param = make_node(AstNodeLocal, AST_NODE_KIND_PARAM); + curr_param = make_node(AstLocal, Ast_Kind_Param); curr_param->base.token = symbol; - curr_param->base.flags |= ONYX_AST_FLAG_CONST; + curr_param->base.flags |= Ast_Flag_Const; curr_param->base.type = parse_type(parser); if (first_param == NULL) first_param = curr_param; @@ -686,7 +686,7 @@ static b32 parse_possible_directive(OnyxParser* parser, const char* dir) { if (parser->curr_token->type != '#') return 0; expect(parser, '#'); - OnyxToken* sym = expect(parser, TOKEN_TYPE_SYMBOL); + OnyxToken* sym = expect(parser, Token_Type_Symbol); b32 match = (strlen(dir) == sym->length) && (strncmp(dir, sym->text, sym->length) == 0); if (!match) { @@ -696,23 +696,23 @@ static b32 parse_possible_directive(OnyxParser* parser, const char* dir) { return match; } -static AstNodeFunction* parse_function_definition(OnyxParser* parser) { - expect(parser, TOKEN_TYPE_KEYWORD_PROC); +static AstFunction* parse_function_definition(OnyxParser* parser) { + expect(parser, Token_Type_Keyword_Proc); - AstNodeFunction* func_def = make_node(AstNodeFunction, AST_NODE_KIND_FUNCTION); + AstFunction* func_def = make_node(AstFunction, Ast_Kind_Function); while (parser->curr_token->type == '#') { if (parse_possible_directive(parser, "intrinsic")) { - func_def->base.flags |= ONYX_AST_FLAG_INTRINSIC; + func_def->base.flags |= Ast_Flag_Intrinsic; } else if (parse_possible_directive(parser, "inline")) { - func_def->base.flags |= ONYX_AST_FLAG_INLINE; + func_def->base.flags |= Ast_Flag_Inline; } else { OnyxToken* directive_token = expect(parser, '#'); - OnyxToken* symbol_token = expect(parser, TOKEN_TYPE_SYMBOL); + OnyxToken* symbol_token = expect(parser, Token_Type_Symbol); onyx_message_add(parser->msgs, ONYX_MESSAGE_TYPE_UNKNOWN_DIRECTIVE, @@ -721,11 +721,11 @@ static AstNodeFunction* parse_function_definition(OnyxParser* parser) { } } - AstNodeLocal* params = parse_function_params(parser); + AstLocal* params = parse_function_params(parser); func_def->params = params; - if (parser->curr_token->type == TOKEN_TYPE_RIGHT_ARROW) { - expect(parser, TOKEN_TYPE_RIGHT_ARROW); + if (parser->curr_token->type == Token_Type_Right_Arrow) { + expect(parser, Token_Type_Right_Arrow); TypeInfo* return_type = parse_type(parser); func_def->base.type = return_type; @@ -739,21 +739,21 @@ static AstNodeFunction* parse_function_definition(OnyxParser* parser) { } static AstNode* parse_foreign(OnyxParser* parser) { - expect(parser, TOKEN_TYPE_KEYWORD_FOREIGN); + expect(parser, Token_Type_Keyword_Foreign); - AstNodeForeign* foreign = make_node(AstNodeForeign, AST_NODE_KIND_FOREIGN); - foreign->mod_token = expect(parser, TOKEN_TYPE_LITERAL_STRING); - foreign->name_token = expect(parser, TOKEN_TYPE_LITERAL_STRING); + AstForeign* foreign = make_node(AstForeign, Ast_Kind_Foreign); + foreign->mod_token = expect(parser, Token_Type_Literal_String); + foreign->name_token = expect(parser, Token_Type_Literal_String); - if (parser->curr_token->type == TOKEN_TYPE_KEYWORD_PROC) { + if (parser->curr_token->type == Token_Type_Keyword_Proc) { foreign->import = (AstNode *) parse_function_definition(parser); } else { TypeInfo* type = parse_type(parser); - AstNodeGlobal* global = make_node(AstNodeGlobal, AST_NODE_KIND_GLOBAL); + AstGlobal* global = make_node(AstGlobal, Ast_Kind_Global); global->base.type = type; - global->base.flags |= ONYX_AST_FLAG_LVAL; + global->base.flags |= Ast_Flag_Lval; foreign->import = (AstNode *) global; } @@ -762,24 +762,24 @@ static AstNode* parse_foreign(OnyxParser* parser) { } static AstNode* parse_top_level_constant_symbol(OnyxParser* parser) { - if (parser->curr_token->type == TOKEN_TYPE_KEYWORD_PROC) { + if (parser->curr_token->type == Token_Type_Keyword_Proc) { return (AstNode *) parse_function_definition(parser); - } else if (parser->curr_token->type == TOKEN_TYPE_KEYWORD_STRUCT) { + } else if (parser->curr_token->type == Token_Type_Keyword_Struct) { // Handle struct case assert(0); - } else if (parser->curr_token->type == TOKEN_TYPE_KEYWORD_FOREIGN) { + } else if (parser->curr_token->type == Token_Type_Keyword_Foreign) { return (AstNode *) parse_foreign(parser); } else { // Global constant with initial value - AstNodeGlobal* global = make_node(AstNodeGlobal, AST_NODE_KIND_GLOBAL); + AstGlobal* global = make_node(AstGlobal, Ast_Kind_Global); global->initial_value = parse_expression(parser); global->base.type = &builtin_types[TYPE_INFO_KIND_UNKNOWN]; - global->base.flags |= ONYX_AST_FLAG_CONST; - global->base.flags |= ONYX_AST_FLAG_LVAL; - global->base.flags |= ONYX_AST_FLAG_COMPTIME; + global->base.flags |= Ast_Flag_Const; + global->base.flags |= Ast_Flag_Lval; + global->base.flags |= Ast_Flag_Comptime; return (AstNode *) global; } @@ -787,33 +787,33 @@ static AstNode* parse_top_level_constant_symbol(OnyxParser* parser) { static AstNode* parse_top_level_statement(OnyxParser* parser) { switch (parser->curr_token->type) { - case TOKEN_TYPE_KEYWORD_USE: + case Token_Type_Keyword_Use: { - AstNodeUse* use_node = make_node(AstNodeUse, AST_NODE_KIND_USE); - use_node->base.token = expect(parser, TOKEN_TYPE_KEYWORD_USE); - use_node->filename = expect(parser, TOKEN_TYPE_LITERAL_STRING); + AstUse* use_node = make_node(AstUse, Ast_Kind_Use); + use_node->base.token = expect(parser, Token_Type_Keyword_Use); + use_node->filename = expect(parser, Token_Type_Literal_String); return (AstNode *) use_node; } - case TOKEN_TYPE_KEYWORD_EXPORT: + case Token_Type_Keyword_Export: { - expect(parser, TOKEN_TYPE_KEYWORD_EXPORT); - if (parser->curr_token->type != TOKEN_TYPE_SYMBOL) { + expect(parser, Token_Type_Keyword_Export); + if (parser->curr_token->type != Token_Type_Symbol) { onyx_message_add(parser->msgs, ONYX_MESSAGE_TYPE_EXPECTED_TOKEN, parser->curr_token->pos, - onyx_get_token_type_name(TOKEN_TYPE_SYMBOL), + onyx_get_token_type_name(Token_Type_Symbol), onyx_get_token_type_name(parser->curr_token->type)); break; } AstNode* top_level_decl = parse_top_level_statement(parser); - top_level_decl->flags |= ONYX_AST_FLAG_EXPORTED; + top_level_decl->flags |= Ast_Flag_Exported; return top_level_decl; } - case TOKEN_TYPE_SYMBOL: + case Token_Type_Symbol: { OnyxToken* symbol = parser->curr_token; parser_next_token(parser); @@ -822,7 +822,7 @@ static AstNode* parse_top_level_statement(OnyxParser* parser) { TypeInfo* type = &builtin_types[TYPE_INFO_KIND_UNKNOWN]; - if (parser->curr_token->type == TOKEN_TYPE_SYMBOL) { + if (parser->curr_token->type == Token_Type_Symbol) { type = parse_type(parser); } @@ -831,12 +831,12 @@ static AstNode* parse_top_level_statement(OnyxParser* parser) { AstNode* node = parse_top_level_constant_symbol(parser); - if (node->kind == AST_NODE_KIND_GLOBAL) { - ((AstNodeGlobal *) node)->base.type = type; + if (node->kind == Ast_Kind_Global) { + ((AstGlobal *) node)->base.type = type; } - if (node->kind == AST_NODE_KIND_FOREIGN) { - ((AstNodeForeign *) node)->import->token = symbol; + if (node->kind == Ast_Kind_Foreign) { + ((AstForeign *) node)->import->token = symbol; } else { node->token = symbol; @@ -847,9 +847,9 @@ static AstNode* parse_top_level_statement(OnyxParser* parser) { } else if (parser->curr_token->type == '=') { parser_next_token(parser); - AstNodeGlobal* global = make_node(AstNodeGlobal, AST_NODE_KIND_GLOBAL); + AstGlobal* global = make_node(AstGlobal, Ast_Kind_Global); global->base.token = symbol; - global->base.flags |= ONYX_AST_FLAG_LVAL; + global->base.flags |= Ast_Flag_Lval; global->initial_value = parse_expression(parser); global->base.type = type; @@ -879,11 +879,11 @@ static AstNode* parse_top_level_statement(OnyxParser* parser) { // NOTE: This returns a void* so I don't need to cast it everytime I use it -void* onyx_ast_node_new(bh_allocator alloc, i32 size, AstNodeKind kind) { +void* onyx_ast_node_new(bh_allocator alloc, i32 size, AstKind kind) { void* node = bh_alloc(alloc, size); memset(node, 0, size); - *(AstNodeKind *) node = kind; + *(AstKind *) node = kind; return node; } @@ -895,7 +895,7 @@ OnyxParser onyx_parser_create(bh_allocator alloc, OnyxTokenizer *tokenizer, Onyx TypeInfo* it = &builtin_types[0]; while (it->kind != 0xffffffff) { - AstNodeTyped* tmp = onyx_ast_node_new(alloc, sizeof(AstNodeTyped), AST_NODE_KIND_TYPE); + AstTyped* tmp = onyx_ast_node_new(alloc, sizeof(AstTyped), Ast_Kind_Type); tmp->type = it; bh_table_put(AstNode*, parser.identifiers, (char *)it->name, tmp); it++; @@ -916,7 +916,7 @@ bh_arr(AstNode *) onyx_parse(OnyxParser *parser) { bh_arr(AstNode *) top_level_nodes = NULL; bh_arr_new(global_heap_allocator, top_level_nodes, 4); - while (parser->curr_token->type != TOKEN_TYPE_END_STREAM) { + while (parser->curr_token->type != Token_Type_End_Stream) { AstNode* curr_stmt = parse_top_level_statement(parser); // Building a linked list of statements down the "next" chain diff --git a/src/onyxsempass.c b/src/onyxsempass.c index df81f551..7f2b4bc8 100644 --- a/src/onyxsempass.c +++ b/src/onyxsempass.c @@ -24,19 +24,19 @@ OnyxSemPassState onyx_sempass_create(bh_allocator alloc, bh_allocator node_alloc // 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(OnyxProgram* program) { - bh_arr(AstNodeBlock*) traversal_queue = NULL; + 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(AstNodeFunction *, func, program->functions) { - AstNodeLocalGroup* top_locals = (*func)->body->locals; + bh_arr_each(AstFunction *, func, program->functions) { + AstLocalGroup* top_locals = (*func)->body->locals; bh_arr_push(traversal_queue, (*func)->body); while (!bh_arr_is_empty(traversal_queue)) { - AstNodeBlock* block = traversal_queue[0]; + AstBlock* block = traversal_queue[0]; - if (block->base.kind == AST_NODE_KIND_IF) { - AstNodeIf* if_node = (AstNodeIf *) block; + if (block->base.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); @@ -46,7 +46,7 @@ static void collapse_scopes(OnyxProgram* program) { } else { if (block->locals != top_locals && block->locals->last_local != NULL) { - AstNodeLocal* last_local = block->locals->last_local; + AstLocal* last_local = block->locals->last_local; while (last_local && last_local->prev_local != NULL) last_local = last_local->prev_local; last_local->prev_local = top_locals->last_local; @@ -56,18 +56,18 @@ static void collapse_scopes(OnyxProgram* program) { AstNode* walker = block->body; while (walker) { - if (walker->kind == AST_NODE_KIND_BLOCK) { - bh_arr_push(traversal_queue, (AstNodeBlock *) walker); + if (walker->kind == Ast_Kind_Block) { + bh_arr_push(traversal_queue, (AstBlock *) walker); - } else if (walker->kind == AST_NODE_KIND_WHILE) { - bh_arr_push(traversal_queue, ((AstNodeWhile *) walker)->body); + } else if (walker->kind == Ast_Kind_While) { + bh_arr_push(traversal_queue, ((AstWhile *) walker)->body); - } else if (walker->kind == AST_NODE_KIND_IF) { - if (((AstNodeIf *) walker)->true_block.as_block != NULL) - bh_arr_push(traversal_queue, ((AstNodeIf *) walker)->true_block.as_block); + } else if (walker->kind == Ast_Kind_If) { + if (((AstIf *) walker)->true_block.as_block != NULL) + bh_arr_push(traversal_queue, ((AstIf *) walker)->true_block.as_block); - if (((AstNodeIf *) walker)->false_block.as_block != NULL) - bh_arr_push(traversal_queue, ((AstNodeIf *) walker)->false_block.as_block); + if (((AstIf *) walker)->false_block.as_block != NULL) + bh_arr_push(traversal_queue, ((AstIf *) walker)->false_block.as_block); } walker = walker->next; diff --git a/src/onyxsymres.c b/src/onyxsymres.c index accec6e5..e3a19b5d 100644 --- a/src/onyxsymres.c +++ b/src/onyxsymres.c @@ -5,19 +5,19 @@ static void symbol_introduce(OnyxSemPassState* state, AstNode* symbol); static b32 symbol_unique_introduce(OnyxSemPassState* state, AstNode* symbol); static void symbol_remove(OnyxSemPassState* state, AstNode* symbol); static AstNode* symbol_resolve(OnyxSemPassState* state, AstNode* symbol); -static void local_group_enter(OnyxSemPassState* state, AstNodeLocalGroup* local_group); +static void local_group_enter(OnyxSemPassState* state, AstLocalGroup* local_group); static void local_group_leave(OnyxSemPassState* state); -static void symres_local(OnyxSemPassState* state, AstNodeLocal** local); -static void symres_call(OnyxSemPassState* state, AstNodeCall* call); +static void symres_local(OnyxSemPassState* state, AstLocal** local); +static void symres_call(OnyxSemPassState* state, AstCall* call); static void symres_expression(OnyxSemPassState* state, AstNode** expr); -static void symres_assignment(OnyxSemPassState* state, AstNodeAssign* assign); -static void symres_return(OnyxSemPassState* state, AstNodeReturn* ret); -static void symres_if(OnyxSemPassState* state, AstNodeIf* ifnode); -static void symres_while(OnyxSemPassState* state, AstNodeWhile* whilenode); +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, AstNodeBlock* block); -static void symres_function(OnyxSemPassState* state, AstNodeFunction* func); +static void symres_block(OnyxSemPassState* state, AstBlock* block); +static void symres_function(OnyxSemPassState* state, AstFunction* func); static void symbol_introduce(OnyxSemPassState* state, AstNode* symbol) { onyx_token_null_toggle(symbol->token); @@ -32,8 +32,8 @@ static void symbol_introduce(OnyxSemPassState* state, AstNode* symbol) { bh_table_put(SemPassSymbol *, state->symbols, symbol->token->text, sp_sym); - if (symbol->kind == AST_NODE_KIND_LOCAL) { - AstNodeLocal* local = (AstNodeLocal *) symbol; + if (symbol->kind == Ast_Kind_Local) { + AstLocal* local = (AstLocal *) symbol; local->prev_local = state->curr_local_group->last_local; state->curr_local_group->last_local = local; } @@ -74,7 +74,7 @@ static AstNode* symbol_resolve(OnyxSemPassState* state, AstNode* symbol) { return sp_sym->node; } -static void local_group_enter(OnyxSemPassState* state, AstNodeLocalGroup* local_group) { +static void local_group_enter(OnyxSemPassState* state, AstLocalGroup* local_group) { local_group->prev_group = state->curr_local_group; state->curr_local_group = local_group; } @@ -82,7 +82,7 @@ static void local_group_enter(OnyxSemPassState* state, AstNodeLocalGroup* local_ static void local_group_leave(OnyxSemPassState* state) { assert(state->curr_local_group != NULL); - for (AstNodeLocal *walker = state->curr_local_group->last_local; walker != NULL; walker = walker->prev_local) { + for (AstLocal *walker = state->curr_local_group->last_local; walker != NULL; walker = walker->prev_local) { symbol_remove(state, (AstNode *) walker); } @@ -113,11 +113,11 @@ static b32 symbol_unique_introduce(OnyxSemPassState* state, AstNode* symbol) { return 1; } -static void symres_local(OnyxSemPassState* state, AstNodeLocal** local) { +static void symres_local(OnyxSemPassState* state, AstLocal** local) { symbol_introduce(state, (AstNode *) *local); } -static void symres_call(OnyxSemPassState* state, AstNodeCall* call) { +static void symres_call(OnyxSemPassState* state, AstCall* call) { AstNode* callee = symbol_resolve(state, call->callee); if (callee) call->callee = callee; else DEBUG_HERE; @@ -127,27 +127,27 @@ static void symres_call(OnyxSemPassState* state, AstNodeCall* call) { static void symres_expression(OnyxSemPassState* state, AstNode** expr) { switch ((*expr)->kind) { - case AST_NODE_KIND_BIN_OP: - symres_expression(state, (AstNode **) &((AstNodeBinOp *)(*expr))->left); - symres_expression(state, (AstNode **) &((AstNodeBinOp *)(*expr))->right); + case Ast_Kind_Binary_Op: + symres_expression(state, (AstNode **) &((AstBinaryOp *)(*expr))->left); + symres_expression(state, (AstNode **) &((AstBinaryOp *)(*expr))->right); break; - case AST_NODE_KIND_UNARY_OP: - symres_expression(state, (AstNode **) &((AstNodeUnaryOp *)(*expr))->expr); + case Ast_Kind_Unary_Op: + symres_expression(state, (AstNode **) &((AstUnaryOp *)(*expr))->expr); break; - case AST_NODE_KIND_CALL: symres_call(state, (AstNodeCall *) *expr); break; + case Ast_Kind_Call: symres_call(state, (AstCall *) *expr); break; - case AST_NODE_KIND_BLOCK: symres_block(state, (AstNodeBlock *) *expr); break; + case Ast_Kind_Block: symres_block(state, (AstBlock *) *expr); break; - case AST_NODE_KIND_SYMBOL: + case Ast_Kind_Symbol: *expr = symbol_resolve(state, *expr); break; // NOTE: This is a good case, since it means the symbol is already resolved - case AST_NODE_KIND_LOCAL: break; + case Ast_Kind_Local: break; - case AST_NODE_KIND_LITERAL: break; + case Ast_Kind_Literal: break; default: DEBUG_HERE; @@ -155,43 +155,43 @@ static void symres_expression(OnyxSemPassState* state, AstNode** expr) { } } -static void symres_assignment(OnyxSemPassState* state, AstNodeAssign* assign) { - AstNodeTyped* lval = (AstNodeTyped *) symbol_resolve(state, (AstNode *) assign->lval); +static void symres_assignment(OnyxSemPassState* state, AstAssign* assign) { + AstTyped* lval = (AstTyped *) symbol_resolve(state, (AstNode *) assign->lval); if (lval == NULL) return; assign->lval = lval; symres_expression(state, (AstNode **) &assign->expr); } -static void symres_return(OnyxSemPassState* state, AstNodeReturn* ret) { +static void symres_return(OnyxSemPassState* state, AstReturn* ret) { if (ret->expr) symres_expression(state, (AstNode **) &ret->expr); } -static void symres_if(OnyxSemPassState* state, AstNodeIf* ifnode) { +static void symres_if(OnyxSemPassState* state, AstIf* ifnode) { symres_expression(state, (AstNode **) &ifnode->cond); if (ifnode->true_block.as_if != NULL) { - if (ifnode->true_block.as_if->base.kind == AST_NODE_KIND_BLOCK) + if (ifnode->true_block.as_if->base.kind == Ast_Kind_Block) symres_block(state, ifnode->true_block.as_block); - else if (ifnode->true_block.as_if->base.kind == AST_NODE_KIND_IF) + else if (ifnode->true_block.as_if->base.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_NODE_KIND_BLOCK) + if (ifnode->false_block.as_if->base.kind == Ast_Kind_Block) symres_block(state, ifnode->false_block.as_block); - else if (ifnode->false_block.as_if->base.kind == AST_NODE_KIND_IF) + else if (ifnode->false_block.as_if->base.kind == Ast_Kind_If) symres_if(state, ifnode->false_block.as_if); else DEBUG_HERE; } } -static void symres_while(OnyxSemPassState* state, AstNodeWhile* whilenode) { +static void symres_while(OnyxSemPassState* state, AstWhile* whilenode) { symres_expression(state, (AstNode **) &whilenode->cond); symres_block(state, whilenode->body); } @@ -199,14 +199,14 @@ static void symres_while(OnyxSemPassState* state, AstNodeWhile* whilenode) { // NOTE: Returns 1 if the statment should be removed static b32 symres_statement(OnyxSemPassState* state, AstNode* stmt) { switch (stmt->kind) { - case AST_NODE_KIND_LOCAL: symres_local(state, (AstNodeLocal **) &stmt); return 1; - case AST_NODE_KIND_ASSIGNMENT: symres_assignment(state, (AstNodeAssign *) stmt); return 0; - case AST_NODE_KIND_RETURN: symres_return(state, (AstNodeReturn *) stmt); return 0; - case AST_NODE_KIND_IF: symres_if(state, (AstNodeIf *) stmt); return 0; - case AST_NODE_KIND_WHILE: symres_while(state, (AstNodeWhile *) stmt); return 0; - case AST_NODE_KIND_CALL: symres_call(state, (AstNodeCall *) stmt); return 0; - case AST_NODE_KIND_ARGUMENT: symres_expression(state, (AstNode **) &((AstNodeArgument *)stmt)->value); return 0; - case AST_NODE_KIND_BLOCK: symres_block(state, (AstNodeBlock *) stmt); return 0; + case Ast_Kind_Local: symres_local(state, (AstLocal **) &stmt); return 1; + case Ast_Kind_Assignment: symres_assignment(state, (AstAssign *) stmt); return 0; + case Ast_Kind_Return: symres_return(state, (AstReturn *) stmt); return 0; + case Ast_Kind_If: symres_if(state, (AstIf *) stmt); return 0; + case Ast_Kind_While: symres_while(state, (AstWhile *) stmt); return 0; + case Ast_Kind_Call: symres_call(state, (AstCall *) stmt); return 0; + case Ast_Kind_Argument: symres_expression(state, (AstNode **) &((AstArgument *)stmt)->value); return 0; + case Ast_Kind_Block: symres_block(state, (AstBlock *) stmt); return 0; default: return 0; } @@ -227,21 +227,21 @@ static void symres_statement_chain(OnyxSemPassState* state, AstNode* walker, Ast } } -static void symres_block(OnyxSemPassState* state, AstNodeBlock* block) { +static void symres_block(OnyxSemPassState* 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, AstNodeFunction* func) { - for (AstNodeLocal *param = func->params; param != NULL; param = (AstNodeLocal *) param->base.next) { +static void symres_function(OnyxSemPassState* state, AstFunction* func) { + for (AstLocal *param = func->params; param != NULL; param = (AstLocal *) param->base.next) { symbol_introduce(state, (AstNode *) param); } symres_block(state, func->body); - for (AstNodeLocal *param = func->params; param != NULL; param = (AstNodeLocal *) param->base.next) { + for (AstLocal *param = func->params; param != NULL; param = (AstLocal *) param->base.next) { symbol_remove(state, (AstNode *) param); } } @@ -249,21 +249,21 @@ static void symres_function(OnyxSemPassState* state, AstNodeFunction* func) { void onyx_resolve_symbols(OnyxSemPassState* state, OnyxProgram* program) { // NOTE: First, introduce all global symbols - bh_arr_each(AstNodeGlobal *, global, program->globals) + bh_arr_each(AstGlobal *, global, program->globals) if (!symbol_unique_introduce(state, (AstNode *) *global)) return; - bh_arr_each(AstNodeFunction *, function, program->functions) + bh_arr_each(AstFunction *, function, program->functions) if (!symbol_unique_introduce(state, (AstNode *) *function)) return; - bh_arr_each(AstNodeForeign *, foreign, program->foreigns) { - AstNodeKind import_kind = (*foreign)->import->kind; + bh_arr_each(AstForeign *, foreign, program->foreigns) { + AstKind import_kind = (*foreign)->import->kind; - if (import_kind == AST_NODE_KIND_FUNCTION || import_kind == AST_NODE_KIND_GLOBAL) + if (import_kind == Ast_Kind_Function || import_kind == Ast_Kind_Global) if (!symbol_unique_introduce(state, (*foreign)->import)) return; } // NOTE: Then, resolve all symbols in all functions - bh_arr_each(AstNodeFunction *, function, program->functions) + bh_arr_each(AstFunction *, function, program->functions) symres_function(state, *function); } diff --git a/src/onyxtypes.c b/src/onyxtypes.c new file mode 100644 index 00000000..eee00a7d --- /dev/null +++ b/src/onyxtypes.c @@ -0,0 +1,49 @@ +#include "onyxtypes.h" + +Type basic_types[] = { + { Type_Kind_Basic, { Basic_Kind_Void, 0, 0, "void" } }, + + { Type_Kind_Basic, { Basic_Kind_Bool, Basic_Flag_Boolean, 1, "bool" } }, + + { Type_Kind_Basic, { Basic_Kind_I8, Basic_Flag_Integer, 1, "i8" } }, + { Type_Kind_Basic, { Basic_Kind_I16, Basic_Flag_Integer, 2, "i16" } }, + { Type_Kind_Basic, { Basic_Kind_I32, Basic_Flag_Integer, 4, "i32" } }, + { Type_Kind_Basic, { Basic_Kind_I64, Basic_Flag_Integer, 8, "i64" } }, + + { Type_Kind_Basic, { Basic_Kind_U8, Basic_Flag_Integer | Basic_Flag_Unsigned, 1, "u8" } }, + { Type_Kind_Basic, { Basic_Kind_U16, Basic_Flag_Integer | Basic_Flag_Unsigned, 2, "u16" } }, + { Type_Kind_Basic, { Basic_Kind_U32, Basic_Flag_Integer | Basic_Flag_Unsigned, 4, "u32" } }, + { Type_Kind_Basic, { Basic_Kind_U64, Basic_Flag_Integer | Basic_Flag_Unsigned, 8, "u64" } }, + + { Type_Kind_Basic, { Basic_Kind_F32, Basic_Flag_Float, 4, "f32" } }, + { Type_Kind_Basic, { Basic_Kind_F64, Basic_Flag_Float, 8, "f64" } }, + + { Type_Kind_Basic, { Basic_Kind_Rawptr, Basic_Flag_Pointer, 4, "rawptr" } }, +}; + +b32 types_are_compatible(Type* t1, Type* t2) { + // NOTE: If they are pointing to the same thing, + // it is safe to assume they are the same type + if (t1 == t2) return 1; + + switch (t1->kind) { + case Type_Kind_Basic: + if (t2->kind == Type_Kind_Basic) { + // HACK: Not sure if this is right way to check this? + return t1 == t2; + } + break; + + case Type_Kind_Pointer: + if (t2->kind == Type_Kind_Pointer) { + return types_are_compatible(t1->Pointer.elem, t2->Pointer.elem); + } + break; + + default: + assert(("Invalid type", 0)); + break; + } + + return 0; +} diff --git a/src/onyxutils.c b/src/onyxutils.c index 3e55d696..b98f5dd8 100644 --- a/src/onyxutils.c +++ b/src/onyxutils.c @@ -41,7 +41,7 @@ static const char* ast_node_names[] = { "AST_NODE_KIND_COUNT", }; -const char* onyx_ast_node_kind_string(AstNodeKind kind) { +const char* onyx_ast_node_kind_string(AstKind kind) { return ast_node_names[kind]; } diff --git a/src/onyxwasm.c b/src/onyxwasm.c index 3b4de695..aaee1bbb 100644 --- a/src/onyxwasm.c +++ b/src/onyxwasm.c @@ -212,22 +212,22 @@ static WasmType onyx_type_to_wasm_type(TypeInfo* type) { #define WI(instr) bh_arr_push(code, ((WasmInstruction){ instr, 0x00 })); #define WID(instr, data) bh_arr_push(code, ((WasmInstruction){ instr, data })); -static void compile_function_body(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeFunction* fd); -static void compile_block(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeBlock* block); +static void compile_function_body(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstFunction* fd); +static void compile_block(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstBlock* block); static void compile_statement(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNode* stmt); -static void compile_assign_lval(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeTyped* lval); -static void compile_assignment(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeAssign* assign); -static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeIf* if_node); -static void compile_while(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeWhile* while_node); -static void compile_binop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeBinOp* binop); -static void compile_unaryop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeUnaryOp* unop); -static void compile_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeCall* call); -static void compile_intrinsic_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeIntrinsicCall* call); -static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeTyped* expr); -static void compile_cast(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeUnaryOp* cast); -static void compile_return(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeReturn* ret); - -static void compile_function_body(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeFunction* fd) { +static void compile_assign_lval(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstTyped* lval); +static void compile_assignment(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstAssign* assign); +static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstIf* if_node); +static void compile_while(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstWhile* while_node); +static void compile_binop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstBinaryOp* binop); +static void compile_unaryop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstUnaryOp* unop); +static void compile_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstCall* call); +static void compile_intrinsic_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstIntrinsicCall* call); +static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstTyped* expr); +static void compile_cast(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstUnaryOp* cast); +static void compile_return(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstReturn* ret); + +static void compile_function_body(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstFunction* fd) { if (fd->body == NULL) return; bh_arr(WasmInstruction) code = *pcode; @@ -241,7 +241,7 @@ static void compile_function_body(OnyxWasmModule* mod, bh_arr(WasmInstruction)* *pcode = code; } -static void compile_block(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeBlock* block) { +static void compile_block(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstBlock* block) { bh_arr(WasmInstruction) code = *pcode; WID(WI_BLOCK_START, 0x40); @@ -285,17 +285,17 @@ static void compile_statement(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcod bh_arr(WasmInstruction) code = *pcode; switch (stmt->kind) { - case AST_NODE_KIND_RETURN: compile_return(mod, &code, (AstNodeReturn *) stmt); break; - case AST_NODE_KIND_ASSIGNMENT: compile_assignment(mod, &code, (AstNodeAssign *) stmt); break; - case AST_NODE_KIND_IF: compile_if(mod, &code, (AstNodeIf *) stmt); break; - case AST_NODE_KIND_WHILE: compile_while(mod, &code, (AstNodeWhile *) stmt); break; - case AST_NODE_KIND_BREAK: compile_structured_jump(mod, &code, 0); break; - case AST_NODE_KIND_CONTINUE: compile_structured_jump(mod, &code, 1); break; - case AST_NODE_KIND_BLOCK: compile_block(mod, &code, (AstNodeBlock *) stmt); break; - - case AST_NODE_KIND_CALL: - case AST_NODE_KIND_INTRINSIC_CALL: - compile_expression(mod, &code, (AstNodeTyped *) stmt); + case Ast_Kind_Return: compile_return(mod, &code, (AstReturn *) stmt); break; + case Ast_Kind_Assignment: compile_assignment(mod, &code, (AstAssign *) stmt); break; + case Ast_Kind_If: compile_if(mod, &code, (AstIf *) stmt); break; + case Ast_Kind_While: compile_while(mod, &code, (AstWhile *) stmt); break; + case Ast_Kind_Break: compile_structured_jump(mod, &code, 0); break; + case Ast_Kind_Continue: compile_structured_jump(mod, &code, 1); break; + case Ast_Kind_Block: compile_block(mod, &code, (AstBlock *) stmt); break; + + case Ast_Kind_Call: + case Ast_Kind_Intrinsic_Call: + compile_expression(mod, &code, (AstTyped *) stmt); break; @@ -305,15 +305,15 @@ static void compile_statement(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcod *pcode = code; } -static void compile_assign_lval(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeTyped* lval) { +static void compile_assign_lval(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstTyped* lval) { bh_arr(WasmInstruction) code = *pcode; - if (lval->kind == AST_NODE_KIND_LOCAL || lval->kind == AST_NODE_KIND_PARAM) { + if (lval->kind == Ast_Kind_Local || lval->kind == Ast_Kind_Param) { i32 localidx = (i32) bh_imap_get(&mod->local_map, (u64) lval); WID(WI_LOCAL_SET, localidx); - } else if (lval->kind == AST_NODE_KIND_GLOBAL) { + } else if (lval->kind == Ast_Kind_Global) { i32 globalidx = (i32) bh_imap_get(&mod->global_map, (u64) lval); WID(WI_GLOBAL_SET, globalidx); @@ -325,7 +325,7 @@ static void compile_assign_lval(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pc *pcode = code; } -static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeIf* if_node) { +static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstIf* if_node) { bh_arr(WasmInstruction) code = *pcode; compile_expression(mod, &code, if_node->cond); @@ -336,11 +336,11 @@ static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstN 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_NODE_KIND_IF) { + if (if_node->true_block.as_if->base.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_NODE_KIND_BLOCK) { + } else if (if_node->true_block.as_if->base.kind == Ast_Kind_Block) { forll (AstNode, stmt, if_node->true_block.as_block->body, next) { compile_statement(mod, &code, stmt); } @@ -350,11 +350,11 @@ static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstN if (if_node->false_block.as_if) { WI(WI_ELSE); - if (if_node->false_block.as_if->base.kind == AST_NODE_KIND_IF) { + if (if_node->false_block.as_if->base.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_NODE_KIND_BLOCK) { + } else if (if_node->false_block.as_if->base.kind == Ast_Kind_Block) { forll (AstNode, stmt, if_node->false_block.as_block->body, next) { compile_statement(mod, &code, stmt); } @@ -368,7 +368,7 @@ static void compile_if(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstN *pcode = code; } -static void compile_while(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeWhile* while_node) { +static void compile_while(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstWhile* while_node) { bh_arr(WasmInstruction) code = *pcode; WID(WI_BLOCK_START, 0x40); @@ -396,7 +396,7 @@ static void compile_while(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, A *pcode = code; } -static void compile_assignment(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeAssign* assign) { +static void compile_assignment(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstAssign* assign) { bh_arr(WasmInstruction) code = *pcode; compile_expression(mod, &code, assign->expr); @@ -423,18 +423,18 @@ static const WasmInstructionType binop_map[][4] = { /* GTE */ { WI_I32_GE_S, WI_I64_GE_S, WI_F32_GE, WI_F64_GE }, }; -static void compile_binop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeBinOp* binop) { +static void compile_binop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstBinaryOp* binop) { bh_arr(WasmInstruction) code = *pcode; b32 is_sign_significant = 0; switch (binop->operation) { - case ONYX_BINARY_OP_DIVIDE: - case ONYX_BINARY_OP_MODULUS: - case ONYX_BINARY_OP_LESS: - case ONYX_BINARY_OP_LESS_EQUAL: - case ONYX_BINARY_OP_GREATER: - case ONYX_BINARY_OP_GREATER_EQUAL: + case Binary_Op_Divide: + case Binary_Op_Modulus: + case Binary_Op_Less: + case Binary_Op_Less_Equal: + case Binary_Op_Greater: + case Binary_Op_Greater_Equal: is_sign_significant = 1; default: break; @@ -470,11 +470,11 @@ static void compile_binop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, A *pcode = code; } -static void compile_unaryop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeUnaryOp* unop) { +static void compile_unaryop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstUnaryOp* unop) { bh_arr(WasmInstruction) code = *pcode; switch (unop->operation) { - case ONYX_UNARY_OP_NEGATE: + case Unary_Op_Negate: { TypeInfoKind type_kind = unop->base.type->kind; @@ -501,24 +501,24 @@ static void compile_unaryop(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, break; } - case ONYX_UNARY_OP_NOT: + case Unary_Op_Not: compile_expression(mod, &code, unop->expr); WI(WI_I32_EQZ); break; - case ONYX_UNARY_OP_CAST: compile_cast(mod, &code, unop); break; + case Unary_Op_Cast: compile_cast(mod, &code, unop); break; } *pcode = code; } -static void compile_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeCall* call) { +static void compile_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstCall* call) { bh_arr(WasmInstruction) code = *pcode; - for (AstNodeArgument *arg = call->arguments; + for (AstArgument *arg = call->arguments; arg != NULL; - arg = (AstNodeArgument *) arg->base.next) { + arg = (AstArgument *) arg->base.next) { compile_expression(mod, &code, arg->value); } @@ -528,7 +528,7 @@ static void compile_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, As *pcode = code; } -static void compile_intrinsic_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeIntrinsicCall* call) { +static void compile_intrinsic_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstIntrinsicCall* call) { bh_arr(WasmInstruction) code = *pcode; i32 place_arguments_normally = 1; @@ -538,9 +538,9 @@ static void compile_intrinsic_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* if (0) place_arguments_normally = 0; if (place_arguments_normally) { - for (AstNodeArgument *arg = call->arguments; + for (AstArgument *arg = call->arguments; arg != NULL; - arg = (AstNodeArgument *) arg->base.next) { + arg = (AstArgument *) arg->base.next) { compile_expression(mod, &code, arg->value); } } @@ -599,20 +599,20 @@ static void compile_intrinsic_call(OnyxWasmModule* mod, bh_arr(WasmInstruction)* *pcode = code; } -static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeTyped* expr) { +static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstTyped* expr) { bh_arr(WasmInstruction) code = *pcode; switch (expr->kind) { - case AST_NODE_KIND_BIN_OP: - compile_binop(mod, &code, (AstNodeBinOp *) expr); + case Ast_Kind_Binary_Op: + compile_binop(mod, &code, (AstBinaryOp *) expr); break; - case AST_NODE_KIND_UNARY_OP: - compile_unaryop(mod, &code, (AstNodeUnaryOp *) expr); + case Ast_Kind_Unary_Op: + compile_unaryop(mod, &code, (AstUnaryOp *) expr); break; - case AST_NODE_KIND_LOCAL: - case AST_NODE_KIND_PARAM: + case Ast_Kind_Local: + case Ast_Kind_Param: { i32 localidx = (i32) bh_imap_get(&mod->local_map, (u64) expr); @@ -620,7 +620,7 @@ static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pco break; } - case AST_NODE_KIND_GLOBAL: + case Ast_Kind_Global: { i32 globalidx = (i32) bh_imap_get(&mod->global_map, (u64) expr); @@ -628,9 +628,9 @@ static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pco break; } - case AST_NODE_KIND_LITERAL: + case Ast_Kind_Literal: { - AstNodeNumLit* lit = (AstNodeNumLit *) expr; + AstNumLit* lit = (AstNumLit *) expr; WasmType lit_type = onyx_type_to_wasm_type(lit->base.type); WasmInstruction instr = { WI_NOP, 0 }; @@ -652,15 +652,15 @@ static void compile_expression(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pco break; } - case AST_NODE_KIND_BLOCK: compile_block(mod, &code, (AstNodeBlock *) expr); break; + case Ast_Kind_Block: compile_block(mod, &code, (AstBlock *) expr); break; - case AST_NODE_KIND_CALL: - compile_call(mod, &code, (AstNodeCall *) expr); + case Ast_Kind_Call: + compile_call(mod, &code, (AstCall *) expr); break; - case AST_NODE_KIND_INTRINSIC_CALL: - compile_intrinsic_call(mod, &code, (AstNodeIntrinsicCall *) expr); + case Ast_Kind_Intrinsic_Call: + compile_intrinsic_call(mod, &code, (AstIntrinsicCall *) expr); break; default: @@ -682,7 +682,7 @@ static const WasmInstructionType cast_map[][6] = { /* F64 */ { WI_I32_FROM_F64_S, WI_I32_FROM_F64_U, WI_I64_FROM_F64_S, WI_I64_FROM_F64_U, WI_F32_FROM_F64, WI_NOP, }, }; -static void compile_cast(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeUnaryOp* cast) { +static void compile_cast(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstUnaryOp* cast) { bh_arr(WasmInstruction) code = *pcode; compile_expression(mod, &code, cast->expr); @@ -719,7 +719,7 @@ static void compile_cast(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, As *pcode = code; } -static void compile_return(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstNodeReturn* ret) { +static void compile_return(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstReturn* ret) { bh_arr(WasmInstruction) code = *pcode; if (ret->expr) { @@ -731,18 +731,18 @@ static void compile_return(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, *pcode = code; } -static i32 generate_type_idx(OnyxWasmModule* mod, AstNodeFunction* fd) { +static i32 generate_type_idx(OnyxWasmModule* mod, AstFunction* fd) { static char type_repr_buf[128]; char* t = type_repr_buf; - AstNodeLocal* param = fd->params; + AstLocal* param = fd->params; i32 param_count = 0; while (param) { // HACK: Using these directly as part of a string feels weird but they are // valid characters so I don't think it is going to be much of an issue *(t++) = (char) onyx_type_to_wasm_type(param->base.type); param_count++; - param = (AstNodeLocal *) param->base.next; + param = (AstLocal *) param->base.next; } *(t++) = ':'; @@ -773,9 +773,9 @@ static i32 generate_type_idx(OnyxWasmModule* mod, AstNodeFunction* fd) { return type_idx; } -static void compile_function(OnyxWasmModule* mod, AstNodeFunction* fd) { +static void compile_function(OnyxWasmModule* mod, AstFunction* fd) { // NOTE: Don't compile intrinsics - if (fd->base.flags & ONYX_AST_FLAG_INTRINSIC) return; + if (fd->base.flags & Ast_Flag_Intrinsic) return; i32 type_idx = generate_type_idx(mod, fd); @@ -792,7 +792,7 @@ static void compile_function(OnyxWasmModule* mod, AstNodeFunction* fd) { bh_arr_new(mod->allocator, wasm_func.code, 4); - if (fd->base.flags & ONYX_AST_FLAG_EXPORTED) { + if (fd->base.flags & Ast_Flag_Exported) { onyx_token_null_toggle(fd->base.token); i32 func_idx = (i32) bh_imap_get(&mod->func_map, (u64) fd); @@ -811,7 +811,7 @@ static void compile_function(OnyxWasmModule* mod, AstNodeFunction* fd) { if (fd->body != NULL) { // NOTE: Generate the local map i32 localidx = 0; - for (AstNodeLocal *param = fd->params; param != NULL; param = (AstNodeLocal *) param->base.next) { + for (AstLocal *param = fd->params; param != NULL; param = (AstLocal *) param->base.next) { bh_imap_put(&mod->local_map, (u64) param, localidx++); } @@ -821,7 +821,7 @@ static void compile_function(OnyxWasmModule* mod, AstNodeFunction* fd) { // is the same as the order of the local_types above u8* count = &wasm_func.locals.i32_count; fori (ti, 0, 3) { - forll (AstNodeLocal, local, fd->body->locals->last_local, prev_local) { + forll (AstLocal, local, fd->body->locals->last_local, prev_local) { if (onyx_type_to_wasm_type(local->base.type) == local_types[ti]) { bh_imap_put(&mod->local_map, (u64) local, localidx++); @@ -846,10 +846,10 @@ static void compile_function(OnyxWasmModule* mod, AstNodeFunction* fd) { bh_imap_clear(&mod->local_map); } -static void compile_global_declaration(OnyxWasmModule* module, AstNodeGlobal* global) { +static void compile_global_declaration(OnyxWasmModule* module, AstGlobal* global) { WasmGlobal glob = { .type = onyx_type_to_wasm_type(global->base.type), - .mutable = (global->base.flags & ONYX_AST_FLAG_CONST) == 0, + .mutable = (global->base.flags & Ast_Flag_Const) == 0, .initial_value = NULL, }; @@ -861,7 +861,7 @@ static void compile_global_declaration(OnyxWasmModule* module, AstNodeGlobal* gl return; } - if ((global->base.flags & ONYX_AST_FLAG_EXPORTED) != 0) { + if ((global->base.flags & Ast_Flag_Exported) != 0) { onyx_token_null_toggle(global->base.token); i32 global_idx = (i32) bh_imap_get(&module->func_map, (u64) global); @@ -880,9 +880,9 @@ static void compile_global_declaration(OnyxWasmModule* module, AstNodeGlobal* gl bh_arr_push(module->globals, glob); } -static void compile_foreign(OnyxWasmModule* module, AstNodeForeign* foreign) { - if (foreign->import->kind == AST_NODE_KIND_FUNCTION) { - i32 type_idx = generate_type_idx(module, (AstNodeFunction *) foreign->import); +static void compile_foreign(OnyxWasmModule* module, AstForeign* foreign) { + if (foreign->import->kind == Ast_Kind_Function) { + i32 type_idx = generate_type_idx(module, (AstFunction *) foreign->import); WasmImport import = { .kind = WASM_FOREIGN_FUNCTION, @@ -893,8 +893,8 @@ static void compile_foreign(OnyxWasmModule* module, AstNodeForeign* foreign) { bh_arr_push(module->imports, import); - } else if (foreign->import->kind == AST_NODE_KIND_GLOBAL) { - WasmType global_type = onyx_type_to_wasm_type(((AstNodeGlobal *) foreign->import)->base.type); + } else if (foreign->import->kind == Ast_Kind_Global) { + WasmType global_type = onyx_type_to_wasm_type(((AstGlobal *) foreign->import)->base.type); WasmImport import = { .kind = WASM_FOREIGN_GLOBAL, @@ -959,14 +959,14 @@ OnyxWasmModule onyx_wasm_module_create(bh_allocator alloc, OnyxMessages* msgs) { void onyx_wasm_module_compile(OnyxWasmModule* module, OnyxProgram* program) { // NOTE: First, introduce all indicies for globals and functions - bh_arr_each(AstNodeForeign *, foreign, program->foreigns) { - AstNodeKind import_kind = (*foreign)->import->kind; + bh_arr_each(AstForeign *, foreign, program->foreigns) { + AstKind import_kind = (*foreign)->import->kind; - if (import_kind == AST_NODE_KIND_FUNCTION) { + if (import_kind == Ast_Kind_Function) { module->next_func_idx++; bh_imap_put(&module->func_map, (u64) (*foreign)->import, module->next_import_func_idx++); } - else if (import_kind == AST_NODE_KIND_GLOBAL) { + else if (import_kind == Ast_Kind_Global) { module->next_global_idx++; bh_imap_put(&module->global_map, (u64) (*foreign)->import, module->next_import_global_idx++); } @@ -974,20 +974,20 @@ void onyx_wasm_module_compile(OnyxWasmModule* module, OnyxProgram* program) { compile_foreign(module, *foreign); } - bh_arr_each(AstNodeFunction *, function, program->functions) { - if (((*function)->base.flags & ONYX_AST_FLAG_INTRINSIC) == 0) + bh_arr_each(AstFunction *, function, program->functions) { + if (((*function)->base.flags & Ast_Flag_Intrinsic) == 0) bh_imap_put(&module->func_map, (u64) *function, module->next_func_idx++); } - bh_arr_each(AstNodeGlobal *, global, program->globals) + bh_arr_each(AstGlobal *, global, program->globals) bh_imap_put(&module->global_map, (u64) *global, module->next_global_idx++); // NOTE: Then, compile everything - bh_arr_each(AstNodeFunction *, function, program->functions) + bh_arr_each(AstFunction *, function, program->functions) compile_function(module, *function); - bh_arr_each(AstNodeGlobal *, global, program->globals) + bh_arr_each(AstGlobal *, global, program->globals) compile_global_declaration(module, *global); }