Small bugfixes

diff --git a/include/onyxtypes.h b/include/onyxtypes.h
index 3f9a1094f8d268b2896e8dc6f075200e9cf59f2e..e6fccbb7c8acb0764bcd1f044c13dff8ec40588c 100644 (file)
--- a/include/onyxtypes.h
+++ b/include/onyxtypes.h
@@ -87,4 +87,6 @@ b32 types_are_compatible(Type* t1, Type* t2);
 Type* type_build_from_ast(bh_allocator alloc, struct AstType* type_node);
 const char* type_get_name(Type* type);
 
+b32 type_is_pointer(Type* type);
+
 #endif // #ifndef ONYX_TYPES

diff --git a/onyx b/onyx
index 34f7c89e5d0ca9c8614a0ececba1f62a7cbf5ed7..5fd9c1d9896ce7f1df5d904d5112793d6b75bcfb 100755 (executable)
Binary files a/onyx and b/onyx differ

diff --git a/progs/basic.onyx b/progs/basic.onyx
index 2ce18950bd1fb0cf5d0074e8926489b1e74b227a..5b4ad454ea0364c29e6e8840cce56f6310ee0d10 100644 (file)
--- a/progs/basic.onyx
+++ b/progs/basic.onyx
@@ -1,7 +1,7 @@
 use "progs/intrinsics"
 
 pointer_test :: proc {
-    p : ^i32 = 0 as ^i32;
+    p := 0 as ^i32;
 }
 
 print :: foreign "host" "print" proc (val: i32) ---

diff --git a/src/onyxchecker.c b/src/onyxchecker.c
index 5b14f880c42c533ebc7e8399dd61e7fe037e97ae..531ebd32801938d378dd5b95be94c498e8afbb11 100644 (file)
--- a/src/onyxchecker.c
+++ b/src/onyxchecker.c
@@ -23,10 +23,6 @@ static void check_assignment(OnyxSemPassState* state, AstAssign* assign) {
         return;
     }
 
-    if (assign->lval->type == NULL) {
-        assign->lval->type = type_build_from_ast(state->node_allocator, assign->lval->type_node);
-    }
-
     if ((assign->lval->flags & Ast_Flag_Const) != 0 && assign->lval->type != NULL) {
         onyx_message_add(state->msgs,
                 ONYX_MESSAGE_TYPE_ASSIGN_CONST,
@@ -43,6 +39,10 @@ static void check_assignment(OnyxSemPassState* state, AstAssign* assign) {
         return;
     }
 
+    if (assign->lval->type == NULL) {
+        assign->lval->type = type_build_from_ast(state->node_allocator, assign->lval->type_node);
+    }
+
     check_expression(state, assign->expr);
 
     if (assign->lval->type == NULL) {
@@ -216,7 +216,7 @@ static void check_call(OnyxSemPassState* state, AstCall* call) {
         if (!types_are_compatible(formal_param->base.type, actual_param->base.type)) {
             onyx_message_add(state->msgs,
                     ONYX_MESSAGE_TYPE_FUNCTION_PARAM_TYPE_MISMATCH,
-                    actual_param->value->token->pos,
+                    actual_param->base.token->pos,
                     callee->base.token->text, callee->base.token->length,
                     type_get_name(formal_param->base.type),
                     arg_pos,
@@ -266,10 +266,8 @@ static void check_binaryop(OnyxSemPassState* state, AstBinaryOp* binop) {
         return;
     }
 
-    if (binop->left->type->kind == Type_Kind_Pointer
-            || binop->right->type->kind == Type_Kind_Pointer
-            || (binop->left->type->Basic.flags & Basic_Flag_Pointer)
-            || (binop->right->type->Basic.flags & Basic_Flag_Pointer)) {
+    if (type_is_pointer(binop->left->type)
+            || type_is_pointer(binop->right->type)) {
         onyx_message_add(state->msgs,
                 ONYX_MESSAGE_TYPE_LITERAL,
                 binop->base.token->pos,
@@ -309,8 +307,6 @@ static void check_expression(OnyxSemPassState* state, AstTyped* expr) {
 
             if (((AstUnaryOp *) expr)->operation != Unary_Op_Cast) {
                 expr->type = ((AstUnaryOp *) expr)->expr->type;
-            } else {
-                expr->type = type_build_from_ast(state->node_allocator, expr->type_node);
             }
             break;
 

diff --git a/src/onyxmsgs.c b/src/onyxmsgs.c
index 949adcf15754301c8946aca3b6b3880d889a5759..5b1d8c57cf3f6c7874fd6f8f8b8e259ce5dba4cf 100644 (file)
--- a/src/onyxmsgs.c
+++ b/src/onyxmsgs.c
@@ -2,6 +2,8 @@
 #include "onyxmsgs.h"
 #include "onyxutils.h"
 
+#define MAX_MSGS 5
+
 static const char* msg_formats[] = {
     "%s",
     "expected token '%s', got '%s'",
@@ -63,7 +65,7 @@ static void print_detailed_message(OnyxMessage* msg, bh_file_contents* fc) {
 
 void onyx_message_print(OnyxMessages* msgs) {
     OnyxMessage* msg = msgs->first;
-    i32 msg_count = 1000;
+    i32 msg_count = MAX_MSGS;
 
     while (msg && msg_count-- > 0) {
         if (msg->pos.filename) {

diff --git a/src/onyxparser.c b/src/onyxparser.c
index 1659875015f1f26f2c2911c024405a2f6e4efc5e..6744d477fa3b0a0bf9fe8949dabef36873961262 100644 (file)
--- a/src/onyxparser.c
+++ b/src/onyxparser.c
@@ -169,6 +169,7 @@ static AstTyped* parse_factor(OnyxParser* parser) {
                 AstArgument* curr = NULL;
                 while (parser->curr_token->type != ')') {
                     curr = make_node(AstArgument, Ast_Kind_Argument);
+                    curr->base.token = parser->curr_token;
                     curr->value = parse_expression(parser);
 
                     if (curr != NULL && curr->base.kind != Ast_Kind_Error) {
@@ -203,7 +204,7 @@ static AstTyped* parse_factor(OnyxParser* parser) {
         case Token_Type_Literal_True:
             {
                 AstNumLit* bool_node = make_node(AstNumLit, Ast_Kind_Literal);
-                bool_node->base.type_node = (AstType *) &basic_type_i8;
+                bool_node->base.type_node = (AstType *) &basic_type_bool;
                 bool_node->base.token = expect(parser, Token_Type_Literal_True);
                 bool_node->value.i = 1;
                 retval = (AstTyped *) bool_node;
@@ -213,7 +214,7 @@ static AstTyped* parse_factor(OnyxParser* parser) {
         case Token_Type_Literal_False:
             {
                 AstNumLit* bool_node = make_node(AstNumLit, Ast_Kind_Literal);
-                bool_node->base.type_node = (AstType *) &basic_type_i8;
+                bool_node->base.type_node = (AstType *) &basic_type_bool;
                 bool_node->base.token = expect(parser, Token_Type_Literal_False);
                 bool_node->value.i = 0;
                 retval = (AstTyped *) bool_node;
@@ -465,12 +466,12 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) {
                 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);
-
-                AstTyped* expr = parse_expression(parser);
-
                 AstBinaryOp* bin_op_node = make_node(AstBinaryOp, Ast_Kind_Binary_Op);
                 bin_op_node->operation = bin_op;
+                bin_op_node->base.token = parser->curr_token;
+
+                parser_next_token(parser);
+                AstTyped* expr = parse_expression(parser);
 
                 AstNode* bin_op_left = make_node(AstNode, Ast_Kind_Symbol);
                 bin_op_left->token = symbol;
@@ -478,6 +479,7 @@ static b32 parse_symbol_statement(OnyxParser* parser, AstNode** ret) {
                 bin_op_node->right = expr;
 
                 AstAssign* assign_node = make_node(AstAssign, Ast_Kind_Assignment);
+                assign_node->base.token = bin_op_node->base.token;
 
                 // TODO: Maybe I don't need to make another lval node?
                 AstNode* lval = make_node(AstNode, Ast_Kind_Symbol);
@@ -624,6 +626,7 @@ static AstType* parse_type(OnyxParser* parser) {
         if (parser->curr_token->type == '^') {
             parser_next_token(parser);
             AstPointerType* new = make_node(AstPointerType, Ast_Kind_Pointer_Type);
+            new->base.flags |= Basic_Flag_Pointer;
             *next_insertion = (AstType *) new;
             next_insertion = &new->elem;
         }

diff --git a/src/onyxsymres.c b/src/onyxsymres.c
index fa72c3488370b19f45261c9ee591cc97e0be0386..ee1c7155cebfca9a37e5fea3013bb28ba6a38881 100644 (file)
--- a/src/onyxsymres.c
+++ b/src/onyxsymres.c
@@ -324,14 +324,13 @@ void onyx_resolve_symbols(OnyxSemPassState* state, OnyxProgram* program) {
             if (!symbol_unique_introduce(state, (*foreign)->import)) return;
     }
 
+    // NOTE: Then, resolve all symbols in all functions
     bh_arr_each(AstForeign *, foreign, program->foreigns) {
         if ((*foreign)->import->kind == Ast_Kind_Function) {
             symres_function(state, (AstFunction *) (*foreign)->import);
         }
     }
 
-
-    // NOTE: Then, resolve all symbols in all functions
     bh_arr_each(AstFunction *, function, program->functions)
         symres_function(state, *function);
 }

diff --git a/src/onyxtypes.c b/src/onyxtypes.c
index 1960b76737b7348fc535ecd3d1e12bd448277ba1..908ae1cc7a3308c9c419068bd4bf6b02678b9cf0 100644 (file)
--- a/src/onyxtypes.c
+++ b/src/onyxtypes.c
@@ -84,3 +84,7 @@ const char* type_get_name(Type* type) {
         default: return "unknown";
     }
 }
+
+b32 type_is_pointer(Type* type) {
+    return type->kind == Type_Kind_Pointer || (type->Basic.flags & Basic_Flag_Pointer) != 0;
+}

diff --git a/src/onyxwasm.c b/src/onyxwasm.c
index bac645d34f91081c53d5ed097773b58cb6bf5b2d..7c81780845d06dba3845180c3270c3a7874d9bc5 100644 (file)
--- a/src/onyxwasm.c
+++ b/src/onyxwasm.c
@@ -252,6 +252,7 @@ static void compile_function_body(OnyxWasmModule* mod, bh_arr(WasmInstruction)*
 static void compile_block(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, AstBlock* block) {
     bh_arr(WasmInstruction) code = *pcode;
 
+    bh_arr_push(mod->structured_jump_target, 1);
     WID(WI_BLOCK_START, 0x40);
 
     forll (AstNode, stmt, block->body, next) {
@@ -259,6 +260,7 @@ static void compile_block(OnyxWasmModule* mod, bh_arr(WasmInstruction)* pcode, A
     }
 
     WI(WI_BLOCK_END);
+    bh_arr_pop(mod->structured_jump_target);
 
     *pcode = code;
 }
@@ -424,7 +426,7 @@ static const WasmInstructionType binop_map[][4] = {
     /* REM */ { WI_I32_REM_S, WI_I64_REM_S, WI_NOP,     WI_NOP     },
 
     /* EQ  */ { WI_I32_EQ,    WI_I64_EQ,    WI_F32_EQ,  WI_F64_EQ },
-    /* NEQ */ { WI_NOP,       WI_NOP,       WI_F32_NE , WI_F64_NE },
+    /* NEQ */ { WI_I32_NE,    WI_I64_NE,    WI_F32_NE , WI_F64_NE },
     /* LT  */ { WI_I32_LT_S,  WI_I64_LT_S,  WI_F32_LT,  WI_F64_LT },
     /* LTE */ { WI_I32_LE_S,  WI_I64_LE_S,  WI_F32_LE,  WI_F64_LE },
     /* GT  */ { WI_I32_GT_S,  WI_I64_GT_S,  WI_F32_GT,  WI_F64_GT },