removed old argument code; preparing for named arguments

diff --git a/bin/onyx b/bin/onyx
index 739ae347614d885902bcf955dc31a2d001078777..f3b6fd232377e35567e574df17181135bbb2c49d 100755 (executable)
Binary files a/bin/onyx and b/bin/onyx differ

diff --git a/include/onyxastnodes.h b/include/onyxastnodes.h
index 90daef4eee6414b376d2e6153d3bce0ea5ac043c..4ade1191565fd0908b8aef0f9da8447bed2b5c0b 100644 (file)
--- a/include/onyxastnodes.h
+++ b/include/onyxastnodes.h
@@ -496,10 +496,9 @@ struct AstRangeLiteral {
 struct AstCall {
     AstTyped_base;
 
-    AstArgument *arguments;
     u64 arg_count;
-
     bh_arr(AstArgument *) arg_arr;
+
     AstTyped *callee;
 
     VarArgKind va_kind;
@@ -507,9 +506,7 @@ struct AstCall {
 struct AstIntrinsicCall {
     AstTyped_base;
 
-    AstArgument *arguments;
     u64 arg_count;
-
     bh_arr(AstArgument *) arg_arr;
 
     OnyxIntrinsic intrinsic;

diff --git a/onyx.exe b/onyx.exe
index 0988e70770ce6608b280d5b1d660029239e67410..f7f0822f76199eafd6b5d5f4a8098bef1de8ae94 100644 (file)
Binary files a/onyx.exe and b/onyx.exe differ

diff --git a/src/onyxchecker.c b/src/onyxchecker.c
index 159cbaa5b8c93f686785294c6db7901f47f15d57..f324e1c8ec792bd28705599253a94fff57b225e4 100644 (file)
--- a/src/onyxchecker.c
+++ b/src/onyxchecker.c
@@ -286,19 +286,16 @@ static AstTyped* match_overloaded_function(AstCall* call, AstOverloadedFunction*
 
         if (call->arg_count < ol_type->needed_param_count) continue;
 
-        AstArgument* arg = call->arguments;
         Type** param_type = ol_type->params;
-        while (arg != NULL) {
-            fill_in_type((AstTyped *) arg);
-
+        bh_arr_each(AstArgument*, arg, call->arg_arr) {
+            fill_in_type((AstTyped *) *arg);
             if ((*param_type)->kind == Type_Kind_VarArgs) {
-                if (!type_check_or_auto_cast(&arg->value, (*param_type)->VarArgs.ptr_to_data->Pointer.elem))
+                if (!type_check_or_auto_cast(&(*arg)->value, (*param_type)->VarArgs.ptr_to_data->Pointer.elem))
                     goto no_match;
             }
-            else if (!type_check_or_auto_cast(&arg->value, *param_type)) goto no_match;
+            else if (!type_check_or_auto_cast(&(*arg)->value, *param_type)) goto no_match;
 
             param_type++;
-            arg = (AstArgument *) arg->next;
         }
 
         return (AstTyped *) overload;
@@ -309,14 +306,11 @@ no_match:
 
     char* arg_str = bh_alloc(global_scratch_allocator, 1024);
 
-    AstArgument* arg = call->arguments;
-    while (arg != NULL) {
-        strncat(arg_str, type_get_name(arg->value->type), 1023);
+    bh_arr_each(AstArgument *, arg, call->arg_arr) {
+        strncat(arg_str, type_get_name((*arg)->value->type), 1023);
 
-        if (arg->next != NULL)
+        if ((*arg)->next != NULL)
             strncat(arg_str, ", ", 1023);
-
-        arg = (AstArgument *) arg->next;
     }
 
     onyx_report_error(call->token->pos, "unable to match overloaded function with provided argument types: (%s)", arg_str);
@@ -348,23 +342,18 @@ CheckStatus check_call(AstCall* call) {
     CHECK(expression, &call->callee);
     AstFunction* callee = (AstFunction *) call->callee;
 
-    bh_arr(AstArgument *) arg_arr = NULL;
-    bh_arr_new(global_heap_allocator, arg_arr, call->arg_count);
+    bh_arr(AstArgument *) arg_arr = call->arg_arr;
 
     // NOTE: Check arguments
-    AstArgument* actual = call->arguments;
-    while (actual != NULL) {
-        CHECK(expression, (AstTyped **) &actual);
+    bh_arr_each (AstArgument *, actual, arg_arr) {
+        CHECK(expression, (AstTyped **) actual);
 
-        if (actual->value->kind == Ast_Kind_Overloaded_Function) {
-            onyx_report_error(actual->token->pos,
+        if ((*actual)->value->kind == Ast_Kind_Overloaded_Function) {
+            onyx_report_error((*actual)->token->pos,
                 "Cannot pass overloaded function '%b' as argument.",
-                actual->value->token->text, actual->value->token->length);
+                (*actual)->value->token->text, (*actual)->value->token->length);
             return Check_Error;
         }
-
-        bh_arr_push(arg_arr, actual);
-        actual = (AstArgument *) actual->next;
     }
 
     if (callee->kind == Ast_Kind_Overloaded_Function) {

diff --git a/src/onyxclone.c b/src/onyxclone.c
index 6ae1ccdafed6c83589da4a8b9409009ccd28d179..a982bbcff2458521659fecb01bdd7146c68eae9f 100644 (file)
--- a/src/onyxclone.c
+++ b/src/onyxclone.c
@@ -143,7 +143,11 @@ AstNode* ast_clone(bh_allocator a, void* n) {
                        break;
 
                case Ast_Kind_Call:
-                       ((AstCall *) nn)->arguments = (AstArgument *) ast_clone_list(a, ((AstCall *) node)->arguments);
+            ((AstCall *) nn)->arg_arr = NULL;
+            bh_arr_new(global_heap_allocator, ((AstCall *) nn)->arg_arr, bh_arr_length(((AstCall *) node)->arg_arr));
+            bh_arr_each(AstArgument *, arg, ((AstCall *) node)->arg_arr) {
+                bh_arr_push(((AstCall *) nn)->arg_arr, (AstArgument *) ast_clone(a, *arg));
+            }
                        break;
 
                case Ast_Kind_Argument:

diff --git a/src/onyxparser.c b/src/onyxparser.c
index 9e82ec79fa41b14c3f7de99f89cfd6aa3d773666..08e9ec83c39bbe70d92fc18e1115bac52830f613 100644 (file)
--- a/src/onyxparser.c
+++ b/src/onyxparser.c
@@ -599,19 +599,17 @@ static AstTyped* parse_factor(OnyxParser* parser) {
                 call_node->callee = retval;
                 call_node->arg_count = 0;
 
-                AstArgument** prev = &call_node->arguments;
-                AstArgument* curr = NULL;
+                bh_arr_new(global_heap_allocator, call_node->arg_arr, 2);
+
                 while (parser->curr->type != ')') {
                     if (parser->hit_unexpected_token) return retval;
 
-                    curr = make_node(AstArgument, Ast_Kind_Argument);
-                    curr->token = parser->curr;
-                    curr->value = parse_expression(parser);
-
-                    if (curr != NULL && curr->kind != Ast_Kind_Error) {
-                        *prev = curr;
-                        prev = (AstArgument **) &curr->next;
+                    AstArgument* arg = make_node(AstArgument, Ast_Kind_Argument);
+                    arg->token = parser->curr;
+                    arg->value = parse_expression(parser);
 
+                    if (arg != NULL && arg->kind != Ast_Kind_Error) {
+                        bh_arr_push(call_node->arg_arr, arg);
                         call_node->arg_count++;
                     }
 

diff --git a/src/onyxsymres.c b/src/onyxsymres.c
index 9773e6135785b28a2c5739c66e482d4b6c235ca6..4ae95bfe080cc7e643a50a4600a5ec1e5cce278b 100644 (file)
--- a/src/onyxsymres.c
+++ b/src/onyxsymres.c
@@ -230,7 +230,8 @@ static void symres_call(AstCall* call) {
     symres_expression((AstTyped **) &call->callee);
     if (call->callee == NULL) return;
 
-    symres_statement_chain((AstNode **) &call->arguments);
+    bh_arr_each(AstArgument *, arg, call->arg_arr)
+        symres_statement((AstNode **) arg);
 }
 
 static void symres_size_of(AstSizeOf* so) {
@@ -286,9 +287,9 @@ static void symres_pipe(AstBinaryOp** pipe) {
             Ast_Kind_Argument);
     implicit_arg->token = (*pipe)->left->token;
     implicit_arg->value = (*pipe)->left;
-    implicit_arg->next = (AstNode *) call_node->arguments;
 
-    call_node->arguments = implicit_arg;
+    bh_arr_insertn(call_node->arg_arr, 0, 1);
+    call_node->arg_arr[0] = implicit_arg;
     call_node->arg_count++;
     call_node->next = (*pipe)->next;
 

diff --git a/src/onyxutils.c b/src/onyxutils.c
index 00ccec2ae21344a70183c43470e7855e93221141..befb3f6e89cde8a6205bf9eea9e98a41b79bcff8 100644 (file)
--- a/src/onyxutils.c
+++ b/src/onyxutils.c
@@ -570,14 +570,13 @@ AstFunction* polymorphic_proc_lookup(AstPolyProc* pp, PolyProcLookupMethod pp_lo
         Type* actual_type;
 
         if (pp_lookup == PPLM_By_Call) {
-            AstArgument* arg = ((AstCall *) actual)->arguments;
             if (param->idx >= ((AstCall *) actual)->arg_count) {
                 onyx_report_error(pos, "Not enough arguments to polymorphic procedure.");
                 return NULL;
             }
 
-            fori (i, 0, (i64) param->idx) arg = (AstArgument *) arg->next;
-            actual_type = resolve_expression_type(arg->value);
+            bh_arr(AstArgument *) arg_arr = ((AstCall *) actual)->arg_arr;
+            actual_type = resolve_expression_type(arg_arr[param->idx]->value);
         }
 
         else if (pp_lookup == PPLM_By_Function_Type) {

diff --git a/src/onyxwasm.c b/src/onyxwasm.c
index fdd4b8427b3768ed9071d3a8368816728fc15ffa..fae576491741a52975f724822dfd280f750c343b 100644 (file)
--- a/src/onyxwasm.c
+++ b/src/onyxwasm.c
@@ -1378,42 +1378,38 @@ EMIT_FUNC(call, AstCall* call) {
 // little endian integers.
 #define SIMD_INT_CONST_INTRINSIC(type, count) { \
         type* byte_buffer = bh_alloc(mod->extended_instr_alloc, 16); \
-        AstArgument* arg = call->arguments; \
+        bh_arr(AstArgument *) arg_arr = call->arg_arr; \
         fori (i, 0, count) { \
-            if (arg->value->kind != Ast_Kind_NumLit) { \
-                onyx_report_error(arg->token->pos, \
+            if (arg_arr[i]->value->kind != Ast_Kind_NumLit) { \
+                onyx_report_error(arg_arr[i]->token->pos, \
                         "SIMD constants expect compile time constants as parameters. The %d%s parameter was not.", \
                         i, bh_num_suffix(i)); \
                 *pcode = code; \
                 return; \
             } \
-            byte_buffer[i] = (type) ((AstNumLit *) arg->value)->value.l; \
-            arg = (AstArgument *) arg->next; \
+            byte_buffer[i] = (type) ((AstNumLit *) arg_arr[i]->value)->value.l; \
         } \
         WIP(WI_V128_CONST, byte_buffer); \
     }
 
-#define SIMD_EXTRACT_LANE_INSTR(instr, arg) \
-    emit_expression(mod, &code, arg->value);\
-    arg = (AstArgument *) arg->next; \
-    if (arg->value->kind != Ast_Kind_NumLit) { \
-        onyx_report_error(arg->token->pos, "SIMD lane instructions expect a compile time lane number."); \
+#define SIMD_EXTRACT_LANE_INSTR(instr, arg_arr) \
+    emit_expression(mod, &code, arg_arr[1]->value);\
+    if (arg_arr[1]->value->kind != Ast_Kind_NumLit) { \
+        onyx_report_error(arg_arr[1]->token->pos, "SIMD lane instructions expect a compile time lane number."); \
         *pcode = code; \
         return; \
     } \
-    WID(instr, (u8) ((AstNumLit *) arg->value)->value.i);
+    WID(instr, (u8) ((AstNumLit *) arg_arr[1]->value)->value.i);
 
-#define SIMD_REPLACE_LANE_INSTR(instr, arg) { \
-        emit_expression(mod, &code, arg->value);\
-        arg = (AstArgument *) arg->next; \
-        if (arg->value->kind != Ast_Kind_NumLit) { \
-            onyx_report_error(arg->token->pos, "SIMD lane instructions expect a compile time lane number."); \
+#define SIMD_REPLACE_LANE_INSTR(instr, arg_arr) { \
+        emit_expression(mod, &code, arg_arr[1]->value);\
+        if (arg_arr[1]->value->kind != Ast_Kind_NumLit) { \
+            onyx_report_error(arg_arr[1]->token->pos, "SIMD lane instructions expect a compile time lane number."); \
             *pcode = code; \
             return; \
         } \
-        u8 lane = (u8) ((AstNumLit *) arg->value)->value.i; \
-        arg = (AstArgument *) arg->next; \
-        emit_expression(mod, &code, arg->value); \
+        u8 lane = (u8) ((AstNumLit *) arg_arr[1]->value)->value.i; \
+        emit_expression(mod, &code, arg_arr[2]->value); \
         WID(instr, lane); \
     }
 
@@ -1442,10 +1438,8 @@ EMIT_FUNC(intrinsic_call, AstIntrinsicCall* call) {
     }
 
     if (place_arguments_normally) {
-        for (AstArgument *arg = call->arguments;
-                arg != NULL;
-                arg = (AstArgument *) arg->next) {
-            emit_expression(mod, &code, arg->value);
+        bh_arr_each(AstArgument *, arg, call->arg_arr) {
+            emit_expression(mod, &code, (*arg)->value);
         }
     }
 
@@ -1504,17 +1498,16 @@ EMIT_FUNC(intrinsic_call, AstIntrinsicCall* call) {
         case ONYX_INTRINSIC_I64X2_CONST:  SIMD_INT_CONST_INTRINSIC(u64, 2);   break;
         case ONYX_INTRINSIC_F32X4_CONST: {
             f32* byte_buffer = bh_alloc(mod->extended_instr_alloc, 16);
-            AstArgument* arg = call->arguments;
+            bh_arr(AstArgument *) arg_arr = call->arg_arr;
             fori (i, 0, 4) {
-                if (arg->value->kind != Ast_Kind_NumLit) {
-                    onyx_report_error(arg->token->pos,
+                if (arg_arr[i]->value->kind != Ast_Kind_NumLit) {
+                    onyx_report_error(arg_arr[i]->token->pos,
                             "SIMD constants expect compile time constants as parameters. The %d%s parameter was not.",
                             i, bh_num_suffix(i));
                     *pcode = code;
                     return;
                 }
-                byte_buffer[i] = (f32) ((AstNumLit *) arg->value)->value.f;
-                arg = (AstArgument *) arg->next;
+                byte_buffer[i] = (f32) ((AstNumLit *) arg_arr[i]->value)->value.f;
             }
             WIP(WI_V128_CONST, byte_buffer);
             break;
@@ -1522,17 +1515,16 @@ EMIT_FUNC(intrinsic_call, AstIntrinsicCall* call) {
 
         case ONYX_INTRINSIC_F64X2_CONST: {
             f64* byte_buffer = bh_alloc(mod->extended_instr_alloc, 16);
-            AstArgument* arg = call->arguments;
+            bh_arr(AstArgument *) arg_arr = call->arg_arr;
             fori (i, 0, 2) {
-                if (arg->value->kind != Ast_Kind_NumLit) {
-                    onyx_report_error(arg->token->pos,
+                if (arg_arr[i]->value->kind != Ast_Kind_NumLit) {
+                    onyx_report_error(arg_arr[i]->token->pos,
                             "SIMD constants expect compile time constants as parameters. The %d%s parameter was not.",
                             i, bh_num_suffix(i));
                     *pcode = code;
                     return;
                 }
-                byte_buffer[i] = (f64) ((AstNumLit *) arg->value)->value.d;
-                arg = (AstArgument *) arg->next;
+                byte_buffer[i] = (f64) ((AstNumLit *) arg_arr[i]->value)->value.d;
             }
             WIP(WI_V128_CONST, byte_buffer);
             break;
@@ -1540,44 +1532,41 @@ EMIT_FUNC(intrinsic_call, AstIntrinsicCall* call) {
 
         case ONYX_INTRINSIC_I8X16_SHUFFLE: {
             u8* byte_buffer = bh_alloc(mod->extended_instr_alloc, 16);
-            AstArgument* arg = call->arguments;
+            bh_arr(AstArgument *) arg_arr = call->arg_arr;
 
             // NOTE: There are two parameters that have to be outputted before
             // the immediate bytes
-            emit_expression(mod, &code, arg->value);
-            arg = (AstArgument *) arg->next;
-            emit_expression(mod, &code, arg->value);
-            arg = (AstArgument *) arg->next;
+            emit_expression(mod, &code, arg_arr[0]->value);
+            emit_expression(mod, &code, arg_arr[1]->value);
 
             fori (i, 0, 16) {
-                if (arg->value->kind != Ast_Kind_NumLit) {
-                    onyx_report_error(arg->token->pos,
+                if (arg_arr[i + 2]->value->kind != Ast_Kind_NumLit) {
+                    onyx_report_error(arg_arr[i + 2]->token->pos,
                             "SIMD constants expect compile time constants as parameters. The %d%s parameter was not.",
                             i, bh_num_suffix(i));
                     *pcode = code;
                     return;
                 }
-                byte_buffer[i] = (u8) ((AstNumLit *) arg->value)->value.i;
-                arg = (AstArgument *) arg->next;
+                byte_buffer[i] = (u8) ((AstNumLit *) arg_arr[i + 2]->value)->value.i;
             }
             WIP(WI_I8X16_SHUFFLE, byte_buffer);
             break;
         }
 
-        case ONYX_INTRINSIC_I8X16_EXTRACT_LANE_S: SIMD_EXTRACT_LANE_INSTR(WI_I8X16_EXTRACT_LANE_S, call->arguments); break;
-        case ONYX_INTRINSIC_I8X16_EXTRACT_LANE_U: SIMD_EXTRACT_LANE_INSTR(WI_I8X16_EXTRACT_LANE_U, call->arguments); break;
-        case ONYX_INTRINSIC_I8X16_REPLACE_LANE:   SIMD_REPLACE_LANE_INSTR(WI_I8X16_REPLACE_LANE, call->arguments); break;
-        case ONYX_INTRINSIC_I16X8_EXTRACT_LANE_S: SIMD_EXTRACT_LANE_INSTR(WI_I16X8_EXTRACT_LANE_S, call->arguments); break;
-        case ONYX_INTRINSIC_I16X8_EXTRACT_LANE_U: SIMD_EXTRACT_LANE_INSTR(WI_I16X8_EXTRACT_LANE_U, call->arguments); break;
-        case ONYX_INTRINSIC_I16X8_REPLACE_LANE:   SIMD_REPLACE_LANE_INSTR(WI_I16X8_REPLACE_LANE, call->arguments); break;
-        case ONYX_INTRINSIC_I32X4_EXTRACT_LANE:   SIMD_EXTRACT_LANE_INSTR(WI_I32X4_EXTRACT_LANE, call->arguments); break;
-        case ONYX_INTRINSIC_I32X4_REPLACE_LANE:   SIMD_REPLACE_LANE_INSTR(WI_I32X4_REPLACE_LANE, call->arguments); break;
-        case ONYX_INTRINSIC_I64X2_EXTRACT_LANE:   SIMD_EXTRACT_LANE_INSTR(WI_I64X2_EXTRACT_LANE, call->arguments); break;
-        case ONYX_INTRINSIC_I64X2_REPLACE_LANE:   SIMD_REPLACE_LANE_INSTR(WI_I64X2_REPLACE_LANE, call->arguments); break;
-        case ONYX_INTRINSIC_F32X4_EXTRACT_LANE:   SIMD_EXTRACT_LANE_INSTR(WI_F32X4_EXTRACT_LANE, call->arguments); break;
-        case ONYX_INTRINSIC_F32X4_REPLACE_LANE:   SIMD_REPLACE_LANE_INSTR(WI_F32X4_REPLACE_LANE, call->arguments); break;
-        case ONYX_INTRINSIC_F64X2_EXTRACT_LANE:   SIMD_EXTRACT_LANE_INSTR(WI_F64X2_EXTRACT_LANE, call->arguments); break;
-        case ONYX_INTRINSIC_F64X2_REPLACE_LANE:   SIMD_REPLACE_LANE_INSTR(WI_F64X2_REPLACE_LANE, call->arguments); break;
+        case ONYX_INTRINSIC_I8X16_EXTRACT_LANE_S: SIMD_EXTRACT_LANE_INSTR(WI_I8X16_EXTRACT_LANE_S, call->arg_arr); break;
+        case ONYX_INTRINSIC_I8X16_EXTRACT_LANE_U: SIMD_EXTRACT_LANE_INSTR(WI_I8X16_EXTRACT_LANE_U, call->arg_arr); break;
+        case ONYX_INTRINSIC_I8X16_REPLACE_LANE:   SIMD_REPLACE_LANE_INSTR(WI_I8X16_REPLACE_LANE, call->arg_arr); break;
+        case ONYX_INTRINSIC_I16X8_EXTRACT_LANE_S: SIMD_EXTRACT_LANE_INSTR(WI_I16X8_EXTRACT_LANE_S, call->arg_arr); break;
+        case ONYX_INTRINSIC_I16X8_EXTRACT_LANE_U: SIMD_EXTRACT_LANE_INSTR(WI_I16X8_EXTRACT_LANE_U, call->arg_arr); break;
+        case ONYX_INTRINSIC_I16X8_REPLACE_LANE:   SIMD_REPLACE_LANE_INSTR(WI_I16X8_REPLACE_LANE, call->arg_arr); break;
+        case ONYX_INTRINSIC_I32X4_EXTRACT_LANE:   SIMD_EXTRACT_LANE_INSTR(WI_I32X4_EXTRACT_LANE, call->arg_arr); break;
+        case ONYX_INTRINSIC_I32X4_REPLACE_LANE:   SIMD_REPLACE_LANE_INSTR(WI_I32X4_REPLACE_LANE, call->arg_arr); break;
+        case ONYX_INTRINSIC_I64X2_EXTRACT_LANE:   SIMD_EXTRACT_LANE_INSTR(WI_I64X2_EXTRACT_LANE, call->arg_arr); break;
+        case ONYX_INTRINSIC_I64X2_REPLACE_LANE:   SIMD_REPLACE_LANE_INSTR(WI_I64X2_REPLACE_LANE, call->arg_arr); break;
+        case ONYX_INTRINSIC_F32X4_EXTRACT_LANE:   SIMD_EXTRACT_LANE_INSTR(WI_F32X4_EXTRACT_LANE, call->arg_arr); break;
+        case ONYX_INTRINSIC_F32X4_REPLACE_LANE:   SIMD_REPLACE_LANE_INSTR(WI_F32X4_REPLACE_LANE, call->arg_arr); break;
+        case ONYX_INTRINSIC_F64X2_EXTRACT_LANE:   SIMD_EXTRACT_LANE_INSTR(WI_F64X2_EXTRACT_LANE, call->arg_arr); break;
+        case ONYX_INTRINSIC_F64X2_REPLACE_LANE:   SIMD_REPLACE_LANE_INSTR(WI_F64X2_REPLACE_LANE, call->arg_arr); break;
 
         case ONYX_INTRINSIC_I8X16_SWIZZLE: WI(WI_I8X16_SWIZZLE); break;
         case ONYX_INTRINSIC_I8X16_SPLAT:   WI(WI_I8X16_SPLAT); break;