moved pipe operator to being a binary operator

diff --git a/include/onyxastnodes.h b/include/onyxastnodes.h
index 735df3b9718baf9459209d46419f0e8c66971ed9..52032a45c0da95d025da82ab40788c41c5169d15 100644 (file)
--- a/include/onyxastnodes.h
+++ b/include/onyxastnodes.h
@@ -20,7 +20,6 @@ typedef struct AstAddressOf AstAddressOf;
 typedef struct AstDereference AstDereference;
 typedef struct AstArrayAccess AstArrayAccess;
 typedef struct AstFieldAccess AstFieldAccess;
-typedef struct AstUfc AstUfc;
 typedef struct AstSizeOf AstSizeOf;
 typedef struct AstAlignOf AstAlignOf;
 typedef struct AstFileContents AstFileContents;
@@ -205,6 +204,8 @@ typedef enum BinaryOp {
     Binary_Op_Assign_Shr      = 30,
     Binary_Op_Assign_Sar      = 31,
     Binary_Op_Assign_End      = 32,
+
+    Binary_Op_Pipe            = 33,
 } BinaryOp;
 
 typedef enum OnyxIntrinsic {
@@ -278,7 +279,6 @@ struct AstAddressOf     { AstTyped_base; AstTyped *expr; };
 struct AstDereference   { AstTyped_base; AstTyped *expr; };
 struct AstArrayAccess   { AstTyped_base; AstTyped *addr; AstTyped *expr; u64 elem_size; };
 struct AstFieldAccess   { AstTyped_base; AstTyped *expr; u64 offset; };
-struct AstUfc           { AstTyped_base; AstTyped *object; AstTyped *call; };
 struct AstSizeOf        { AstTyped_base; AstType *so_type; u64 size; };
 struct AstAlignOf       { AstTyped_base; AstType *ao_type; u64 alignment; };
 struct AstFileContents  { AstTyped_base; OnyxToken *filename; };

diff --git a/onyx b/onyx
index 4353307ff5fbf47e5e1e7ea2cacbae1e174fdbef..bbd03345cb0c3d908e34606a373e3a9eb141acd4 100755 (executable)
Binary files a/onyx and b/onyx differ

diff --git a/progs/stack_based.onyx b/progs/stack_based.onyx
index 95d3efa7aed4955e765099baf3e6b9a36090ecdd..a0643841353ba93282b99820ae2e6a4ec156dd24 100644 (file)
--- a/progs/stack_based.onyx
+++ b/progs/stack_based.onyx
@@ -137,7 +137,8 @@ start :: proc #export {
 
     val := something
             |> sort(proc (a: i32, b: i32) -> i32 { return a - b; })
-            |> sumN();
+            |> sumN()
+            |> clamp(30, 100);
     print(val);
 
     for i: 0, N do print(something[i] |> clamp(3, 6));

diff --git a/src/onyxparser.c b/src/onyxparser.c
index 89148789897d9ce85f21b3e967868b2c61ae8393..cbafcff73680ac94fe966217d6795691759b3b47 100644 (file)
--- a/src/onyxparser.c
+++ b/src/onyxparser.c
@@ -415,26 +415,6 @@ static AstTyped* parse_factor(OnyxParser* parser) {
                 break;
             }
 
-            case Token_Type_Pipe: {
-                AstUfc* ufc_node = make_node(AstUfc, Ast_Kind_Ufc);
-                ufc_node->token = expect_token(parser, Token_Type_Pipe);
-                ufc_node->object = retval;
-
-                AstTyped* right = parse_factor(parser);
-
-                if (right->kind == Ast_Kind_Ufc) {
-                    ufc_node->call = ((AstUfc *) right)->object;
-                    ((AstUfc *) right)->object = (AstTyped *) ufc_node;
-                    retval = right;
-
-                } else {
-                    ufc_node->call = right;
-                    retval = (AstTyped *) ufc_node;
-                }
-
-                break;
-            }
-
             default: goto factor_parsed;
         }
     }
@@ -459,31 +439,33 @@ static inline i32 get_precedence(BinaryOp kind) {
         case Binary_Op_Assign_Shr:      return 1;
         case Binary_Op_Assign_Sar:      return 1;
 
-        case Binary_Op_Bool_And:        return 2;
-        case Binary_Op_Bool_Or:         return 2;
+        case Binary_Op_Pipe:            return 2;
 
-        case Binary_Op_Equal:           return 3;
-        case Binary_Op_Not_Equal:       return 3;
+        case Binary_Op_Bool_And:        return 3;
+        case Binary_Op_Bool_Or:         return 3;
 
-        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 Binary_Op_Equal:           return 4;
+        case Binary_Op_Not_Equal:       return 4;
 
-        case Binary_Op_And:             return 5;
-        case Binary_Op_Or:              return 5;
-        case Binary_Op_Xor:             return 5;
-        case Binary_Op_Shl:             return 5;
-        case Binary_Op_Shr:             return 5;
-        case Binary_Op_Sar:             return 5;
+        case Binary_Op_Less_Equal:      return 5;
+        case Binary_Op_Less:            return 5;
+        case Binary_Op_Greater_Equal:   return 5;
+        case Binary_Op_Greater:         return 5;
 
-        case Binary_Op_Add:             return 6;
-        case Binary_Op_Minus:           return 6;
+        case Binary_Op_And:             return 6;
+        case Binary_Op_Or:              return 6;
+        case Binary_Op_Xor:             return 6;
+        case Binary_Op_Shl:             return 6;
+        case Binary_Op_Shr:             return 6;
+        case Binary_Op_Sar:             return 6;
 
-        case Binary_Op_Multiply:        return 7;
-        case Binary_Op_Divide:          return 7;
+        case Binary_Op_Add:             return 7;
+        case Binary_Op_Minus:           return 7;
 
-        case Binary_Op_Modulus:         return 8;
+        case Binary_Op_Multiply:        return 8;
+        case Binary_Op_Divide:          return 8;
+
+        case Binary_Op_Modulus:         return 9;
 
         default:                        return -1;
     }
@@ -560,6 +542,8 @@ static AstTyped* parse_expression(OnyxParser* parser) {
             case Token_Type_Shl_Equal:         bin_op_kind = Binary_Op_Assign_Shl; break;
             case Token_Type_Shr_Equal:         bin_op_kind = Binary_Op_Assign_Shr; break;
             case Token_Type_Sar_Equal:         bin_op_kind = Binary_Op_Assign_Sar; break;
+
+            case Token_Type_Pipe:              bin_op_kind = Binary_Op_Pipe; break;
             default: goto expression_done;
         }
 
@@ -567,9 +551,16 @@ static AstTyped* parse_expression(OnyxParser* parser) {
             bin_op_tok = parser->curr;
             consume_token(parser);
 
-            AstBinaryOp* bin_op = make_node(AstBinaryOp, Ast_Kind_Binary_Op);
-            bin_op->operation = bin_op_kind;
-            bin_op->token = bin_op_tok;
+            AstBinaryOp* bin_op;
+            if (bin_op_kind != Binary_Op_Pipe) {
+                bin_op = make_node(AstBinaryOp, Ast_Kind_Binary_Op);
+                bin_op->operation = bin_op_kind;
+                bin_op->token = bin_op_tok;
+
+            } else {
+                bin_op = make_node(AstBinaryOp, Ast_Kind_Ufc);
+                bin_op->token = bin_op_tok;
+            }
 
             while ( !bh_arr_is_empty(tree_stack) &&
                     get_precedence(bh_arr_last(tree_stack)->operation) >= get_precedence(bin_op_kind))

diff --git a/src/onyxsymres.c b/src/onyxsymres.c
index 262e3b4026f87be11ab6d68366e85c37a9ed8536..32821b07f50ea9348908d6196fb059e3dc2b74ad 100644 (file)
--- a/src/onyxsymres.c
+++ b/src/onyxsymres.c
@@ -222,32 +222,32 @@ static void symres_field_access(AstFieldAccess** fa) {
     }
 }
 
-static void symres_ufc(AstUfc** ufc) {
-    AstCall* call_node = (AstCall *) (*ufc)->call;
+static void symres_ufc(AstBinaryOp** ufc) {
+    AstCall* call_node = (AstCall *) (*ufc)->right;
     symres_expression((AstTyped **) &call_node);
-    symres_expression(&(*ufc)->object);
+    symres_expression(&(*ufc)->left);
 
-    if ((*ufc)->call->kind != Ast_Kind_Call) {
+    if (call_node->kind != Ast_Kind_Call) {
         onyx_message_add(Msg_Type_Literal,
                 (*ufc)->token->pos,
                 "universal function call expected call on right side");
         return;
     }
 
-    if ((*ufc)->object == NULL) return;
+    if ((*ufc)->left == NULL) return;
 
     AstArgument* implicit_arg = onyx_ast_node_new(semstate.node_allocator,
             sizeof(AstArgument),
             Ast_Kind_Argument);
-    implicit_arg->value = (*ufc)->object;
+    implicit_arg->value = (*ufc)->left;
     implicit_arg->next = (AstNode *) call_node->arguments;
 
     call_node->arguments = implicit_arg;
     call_node->arg_count++;
     call_node->next = (*ufc)->next;
 
-    // NOTE: Not a UFC node
-    *ufc = (AstUfc *) call_node;
+    // NOTE: Not a BinaryOp node
+    *ufc = (AstBinaryOp *) call_node;
 }
 
 static void symres_unaryop(AstUnaryOp** unaryop) {
@@ -280,7 +280,7 @@ static void symres_expression(AstTyped** expr) {
         case Ast_Kind_Address_Of:   symres_expression(&((AstAddressOf *)(*expr))->expr); break;
         case Ast_Kind_Dereference:  symres_expression(&((AstDereference *)(*expr))->expr); break;
         case Ast_Kind_Field_Access: symres_field_access((AstFieldAccess **) expr); break;
-        case Ast_Kind_Ufc:          symres_ufc((AstUfc **) expr); break;
+        case Ast_Kind_Ufc:          symres_ufc((AstBinaryOp **) expr); break;
         case Ast_Kind_Size_Of:      symres_size_of((AstSizeOf *)*expr); break;
         case Ast_Kind_Align_Of:     symres_align_of((AstAlignOf *)*expr); break;