From: Brendan Hansen Date: Tue, 11 Aug 2020 20:54:32 +0000 (-0500) Subject: moved pipe operator to being a binary operator X-Git-Url: https://git.brendanfh.com/?a=commitdiff_plain;h=646382f09f1379c4f51e4dc22aeedd2158a9c37e;p=onyx.git moved pipe operator to being a binary operator --- diff --git a/include/onyxastnodes.h b/include/onyxastnodes.h index 735df3b9..52032a45 100644 --- 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 4353307f..bbd03345 100755 Binary files a/onyx and b/onyx differ diff --git a/progs/stack_based.onyx b/progs/stack_based.onyx index 95d3efa7..a0643841 100644 --- 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 89148789..cbafcff7 100644 --- 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 262e3b40..32821b07 100644 --- 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;