diff options
Diffstat (limited to 'boot/parse.c')
| -rw-r--r-- | boot/parse.c | 500 |
1 files changed, 250 insertions, 250 deletions
diff --git a/boot/parse.c b/boot/parse.c index ea6b06b..157b73d 100644 --- a/boot/parse.c +++ b/boot/parse.c @@ -379,8 +379,8 @@ parser_panic(struct Parser* p) } } -struct Statement* parser_statement(struct Parser* p, struct Parser_Error* error); -struct Expression* parser_expression(struct Parser* p, struct Parser_Error* error); +struct Tree_Statement* parser_statement(struct Parser* p, struct Parser_Error* error); +struct Tree_Expression* parser_expression(struct Parser* p, struct Parser_Error* error); void parser_end_statement(struct Parser* p, struct Parser_Error* error) @@ -393,24 +393,24 @@ parser_end_statement(struct Parser* p, struct Parser_Error* error) parser_next(p); } -struct Block_Node +struct Tree_Block parser_block_node(struct Parser* p, struct Parser_Error* error) { struct Token start_token = - CHECK_RETURN(parser_need(p, TOKEN_CURLY_OPEN, error), struct Block_Node); + CHECK_RETURN(parser_need(p, TOKEN_CURLY_OPEN, error), struct Tree_Block); parser_unglue(p); - struct Statement* head = nil; - struct Statement* current = nil; + struct Tree_Statement* head = nil; + struct Tree_Statement* current = nil; while (!parser_probe(p, TOKEN_CURLY_CLOSE)) { - struct Statement* statement = CHECK_RETURN(parser_statement(p, error), struct Block_Node); + struct Tree_Statement* statement = CHECK_RETURN(parser_statement(p, error), struct Tree_Block); // statement ending token isn't required when the block ends on the same line, // as in e.g.: `if (true) { print("yes") }` if (!parser_probe(p, TOKEN_CURLY_CLOSE)) - CHECK_RETURN(parser_end_statement(p, error), struct Block_Node); + CHECK_RETURN(parser_end_statement(p, error), struct Tree_Block); if (!head) { head = statement; @@ -421,25 +421,25 @@ parser_block_node(struct Parser* p, struct Parser_Error* error) } struct Token end_token = - CHECK_RETURN(parser_need(p, TOKEN_CURLY_CLOSE, error), struct Block_Node); + CHECK_RETURN(parser_need(p, TOKEN_CURLY_CLOSE, error), struct Tree_Block); struct Span span = span_merge(start_token.span, end_token.span); - return (struct Block_Node){ + return (struct Tree_Block){ .statements = head, .span = span, .location = start_token.location, }; } -struct Type_Node* parser_node_type(struct Parser* p, struct Parser_Error* error); +struct Tree_Type* parser_node_type(struct Parser* p, struct Parser_Error* error); -struct Function_Header_Node +struct Tree_Function_Header parser_function_header_node(struct Parser* p, struct Parser_Error* error) { struct Token open_parameters_token = - CHECK_RETURN(parser_need(p, TOKEN_ROUND_OPEN, error), struct Function_Header_Node); + CHECK_RETURN(parser_need(p, TOKEN_ROUND_OPEN, error), struct Tree_Function_Header); - struct Function_Header_Node header = { 0 }; + struct Tree_Function_Header header = { 0 }; while (!parser_probe(p, TOKEN_ROUND_CLOSE)) { // TODO: correctly output parameter spans bool variadic = false; @@ -449,14 +449,14 @@ parser_function_header_node(struct Parser* p, struct Parser_Error* error) } struct Token name_token = - CHECK_RETURN(parser_need(p, TOKEN_NAME, error), struct Function_Header_Node); + CHECK_RETURN(parser_need(p, TOKEN_NAME, error), struct Tree_Function_Header); struct String name = name_token.value.name; - struct Type_Node* type; + struct Tree_Type* type; if (!parser_probe(p, TOKEN_ROUND_CLOSE) && !parser_probe(p, TOKEN_COMMA)) { - type = CHECK_RETURN(parser_node_type(p, error), struct Function_Header_Node); + type = CHECK_RETURN(parser_node_type(p, error), struct Tree_Function_Header); } else { - type = type_node_none(name_token.span, name_token.location); + type = tree_type_none(name_token.span, name_token.location); } type->value_name = name; @@ -489,18 +489,18 @@ parser_function_header_node(struct Parser* p, struct Parser_Error* error) // check away. if (token_is(&next, TOKEN_CURLY_OPEN) && token_is(&further, TOKEN_NEWLINE)) return header; - header.return_type = CHECK_RETURN(parser_node_type(p, error), struct Function_Header_Node); + header.return_type = CHECK_RETURN(parser_node_type(p, error), struct Tree_Function_Header); header.span = span_merge(header.span, header.return_type->span); } return header; } -struct Argument_Group_Node +struct Tree_Argument_Group parser_argument_group_node(struct Parser* p, struct Parser_Error* error) { Array(struct String) argument_names = array_new(struct String, 32); - struct Expression *arguments_head = nil, *arguments_current = nil; + struct Tree_Expression *arguments_head = nil, *arguments_current = nil; for (;;) { // check if we have a named argument. struct String name = string_empty(); @@ -511,8 +511,8 @@ parser_argument_group_node(struct Parser* p, struct Parser_Error* error) name = name_token.value.name; } - struct Expression* argument = - CHECK_RETURN(parser_expression(p, error), struct Argument_Group_Node); + struct Tree_Expression* argument = + CHECK_RETURN(parser_expression(p, error), struct Tree_Argument_Group); if (!arguments_head) arguments_head = argument; else @@ -530,12 +530,12 @@ parser_argument_group_node(struct Parser* p, struct Parser_Error* error) } } - return (struct Argument_Group_Node){ + return (struct Tree_Argument_Group){ .arguments = arguments_head, .argument_names = argument_names }; } -struct Bare_Declaration_Node +struct Tree_Bare_Declaration parser_bare_declaration_node(struct Parser* p, struct Parser_Error* error) { Array(struct String) names = array_new(struct String, 16); @@ -544,7 +544,7 @@ parser_bare_declaration_node(struct Parser* p, struct Parser_Error* error) struct Cursor location = parser_peek(p).location; for (;;) { struct Token name_token = - CHECK_RETURN(parser_need(p, TOKEN_NAME, error), struct Bare_Declaration_Node); + CHECK_RETURN(parser_need(p, TOKEN_NAME, error), struct Tree_Bare_Declaration); span = span_is_empty(span) ? name_token.span : span_merge(span, name_token.span); array_push(&names, &name_token.value.name); @@ -555,12 +555,12 @@ parser_bare_declaration_node(struct Parser* p, struct Parser_Error* error) } // for now, type is always required. - struct Type_Node* type = CHECK_RETURN(parser_node_type(p, error), struct Bare_Declaration_Node); - CHECK_RETURN(parser_need(p, TOKEN_ASSIGN, error), struct Bare_Declaration_Node); - struct Expression* initializer = - CHECK_RETURN(parser_expression(p, error), struct Bare_Declaration_Node); + struct Tree_Type* type = CHECK_RETURN(parser_node_type(p, error), struct Tree_Bare_Declaration); + CHECK_RETURN(parser_need(p, TOKEN_ASSIGN, error), struct Tree_Bare_Declaration); + struct Tree_Expression* initializer = + CHECK_RETURN(parser_expression(p, error), struct Tree_Bare_Declaration); - return (struct Bare_Declaration_Node){ + return (struct Tree_Bare_Declaration){ .names = names, .initializer = initializer, .type = type, @@ -570,27 +570,27 @@ parser_bare_declaration_node(struct Parser* p, struct Parser_Error* error) }; } -struct Type_Node* +struct Tree_Type* parser_node_type_name(struct Parser* p, struct Parser_Error* error) { struct Token name_token = CHECK(parser_need(p, TOKEN_NAME, error)); - return type_node_new( - TYPE_NODE_NAME, (union Type_Node_Value){ .name = { name_token.value.name } }, + return tree_type_new( + TREE_TYPE_NAME, (union Tree_Type_Value){ .name = { name_token.value.name } }, name_token.span, name_token.location); } -struct Type_Node* +struct Tree_Type* parser_node_type_structure(struct Parser* p, struct Parser_Error* error) { struct Token open_token = CHECK(parser_need(p, TOKEN_CURLY_OPEN, error)); parser_unglue(p); - struct Type_Node *head = nil, *current = nil; + struct Tree_Type *head = nil, *current = nil; while (!parser_probe(p, TOKEN_CURLY_CLOSE)) { struct Token field_name_token = CHECK(parser_need(p, TOKEN_NAME, error)); - struct Type_Node* field_type = CHECK(parser_node_type(p, error)); + struct Tree_Type* field_type = CHECK(parser_node_type(p, error)); field_type->value_name = field_name_token.value.name; if (!head) @@ -607,12 +607,12 @@ parser_node_type_structure(struct Parser* p, struct Parser_Error* error) struct Token close_token = CHECK(parser_need(p, TOKEN_CURLY_CLOSE, error)); struct Span span = span_merge(open_token.span, close_token.span); - return type_node_new( - TYPE_NODE_STRUCTURE, (union Type_Node_Value){ .structure = { head } }, span, + return tree_type_new( + TREE_TYPE_STRUCTURE, (union Tree_Type_Value){ .structure = { head } }, span, open_token.location); } -struct Type_Node* +struct Tree_Type* parser_node_type_variant(struct Parser* p, struct Parser_Error* error) { struct Token variant_token = CHECK(parser_need(p, TOKEN_WORD_VARIANT, error)); @@ -620,12 +620,12 @@ parser_node_type_variant(struct Parser* p, struct Parser_Error* error) parser_unglue(p); - struct Type_Node *head = nil, *current = nil; + struct Tree_Type *head = nil, *current = nil; while (!parser_probe(p, TOKEN_CURLY_CLOSE)) { struct Token variant_name_token = CHECK(parser_need(p, TOKEN_NAME, error)); struct String variant_name = variant_name_token.value.name; - struct Type_Node* backing_type = nil; + struct Tree_Type* backing_type = nil; struct Token next = parser_peek(p); bool has_backing_type = @@ -635,7 +635,7 @@ parser_node_type_variant(struct Parser* p, struct Parser_Error* error) if (has_backing_type) { backing_type = CHECK(parser_node_type(p, error)); } else { - backing_type = type_node_none(variant_name_token.span, variant_name_token.location); + backing_type = tree_type_none(variant_name_token.span, variant_name_token.location); } backing_type->value_name = variant_name; @@ -654,24 +654,24 @@ parser_node_type_variant(struct Parser* p, struct Parser_Error* error) struct Token close_token = CHECK(parser_need(p, TOKEN_CURLY_CLOSE, error)); struct Span span = span_merge(variant_token.span, close_token.span); - return type_node_new( - TYPE_NODE_VARIANT, (union Type_Node_Value){ .variant = { head } }, span, + return tree_type_new( + TREE_TYPE_VARIANT, (union Tree_Type_Value){ .variant = { head } }, span, variant_token.location); } -struct Type_Node* +struct Tree_Type* parser_node_type_function(struct Parser* p, struct Parser_Error* error) { struct Token fun_token = CHECK(parser_need(p, TOKEN_WORD_FUN, error)); - struct Function_Header_Node header = CHECK(parser_function_header_node(p, error)); + struct Tree_Function_Header header = CHECK(parser_function_header_node(p, error)); struct Span span = span_merge(fun_token.span, header.span); - return type_node_new( - TYPE_NODE_FUNCTION, (union Type_Node_Value){ .function = { header } }, span, + return tree_type_new( + TREE_TYPE_FUNCTION, (union Tree_Type_Value){ .function = { header } }, span, fun_token.location); } -struct Type_Node* +struct Tree_Type* parser_node_type_class(struct Parser* p, struct Parser_Error* error) { struct Token class_token = CHECK(parser_need(p, TOKEN_WORD_CLASS, error)); @@ -679,16 +679,16 @@ parser_node_type_class(struct Parser* p, struct Parser_Error* error) parser_unglue(p); - struct Type_Node *head = nil, *current = nil; + struct Tree_Type *head = nil, *current = nil; while (!parser_probe(p, TOKEN_CURLY_CLOSE)) { struct Token method_name_token = CHECK(parser_need(p, TOKEN_NAME, error)); struct String method_name = method_name_token.value.name; - struct Function_Header_Node header = CHECK(parser_function_header_node(p, error)); + struct Tree_Function_Header header = CHECK(parser_function_header_node(p, error)); // allocate a new type node for the method type, // for the sake of consistency and the built-in type node linked list. - struct Type_Node* method_type = type_node_new( - TYPE_NODE_FUNCTION, (union Type_Node_Value){ .function = { header } }, header.span, + struct Tree_Type* method_type = tree_type_new( + TREE_TYPE_FUNCTION, (union Tree_Type_Value){ .function = { header } }, header.span, header.location); method_type->value_name = method_name; @@ -705,18 +705,18 @@ parser_node_type_class(struct Parser* p, struct Parser_Error* error) struct Token close_token = CHECK(parser_need(p, TOKEN_CURLY_CLOSE, error)); struct Span span = span_merge(class_token.span, close_token.span); - return type_node_new( - TYPE_NODE_CLASS, (union Type_Node_Value){ .class = { head } }, span, class_token.location); + return tree_type_new( + TREE_TYPE_CLASS, (union Tree_Type_Value){ .class = { head } }, span, class_token.location); } -struct Type_Node* +struct Tree_Type* parser_node_type_tuple(struct Parser* p, struct Parser_Error* error) { struct Token open_token = CHECK(parser_need(p, TOKEN_ROUND_OPEN, error)); - struct Type_Node *head = nil, *current = nil; + struct Tree_Type *head = nil, *current = nil; while (!parser_probe(p, TOKEN_ROUND_CLOSE)) { - struct Type_Node* type = CHECK(parser_node_type(p, error)); + struct Tree_Type* type = CHECK(parser_node_type(p, error)); if (!head) head = type; @@ -732,69 +732,69 @@ parser_node_type_tuple(struct Parser* p, struct Parser_Error* error) struct Token close_token = CHECK(parser_need(p, TOKEN_ROUND_CLOSE, error)); struct Span span = span_merge(open_token.span, close_token.span); - return type_node_new( - TYPE_NODE_TUPLE, (union Type_Node_Value){ .tuple = { head } }, span, open_token.location); + return tree_type_new( + TREE_TYPE_TUPLE, (union Tree_Type_Value){ .tuple = { head } }, span, open_token.location); } -struct Type_Node* +struct Tree_Type* parser_node_type_array_or_map(struct Parser* p, struct Parser_Error* error) { struct Token open_token = CHECK(parser_need(p, TOKEN_SQUARE_OPEN, error)); - struct Type_Node* element_or_key_type = parser_node_type(p, error); + struct Tree_Type* element_or_key_type = parser_node_type(p, error); if (!element_or_key_type) { parser_error_wrap(error, PARSER_ERROR_EXPECTED_TYPE); return nil; } - enum Type_Node_Type type; - union Type_Node_Value value; + enum Tree_Type_Type type; + union Tree_Type_Value value; if (parser_probe(p, TOKEN_ASSIGN)) { // this is a map type, e.g. `[string = int]` parser_next(p); // consume the assignment token - struct Type_Node* key_type = element_or_key_type; - struct Type_Node* value_type = parser_node_type(p, error); + struct Tree_Type* key_type = element_or_key_type; + struct Tree_Type* value_type = parser_node_type(p, error); if (!value_type) { parser_error_wrap(error, PARSER_ERROR_EXPECTED_TYPE); return nil; } - type = TYPE_NODE_MAP; - value.map = (struct Type_Node_Map){ + type = TREE_TYPE_MAP; + value.map = (struct Tree_Type_Map){ .key_type = key_type, .value_type = value_type, }; } else { // this is an array type, e.g. `[int]` - type = TYPE_NODE_ARRAY; - value.array = (struct Type_Node_Array){ .element_type = element_or_key_type }; + type = TREE_TYPE_ARRAY; + value.array = (struct Tree_Type_Array){ .element_type = element_or_key_type }; } struct Token close_token = CHECK(parser_need(p, TOKEN_SQUARE_CLOSE, error)); struct Span span = span_merge(open_token.span, close_token.span); - return type_node_new(type, value, span, open_token.location); + return tree_type_new(type, value, span, open_token.location); } -struct Type_Node* +struct Tree_Type* parser_node_type_reference(struct Parser* p, struct Parser_Error* error) { struct Token ampersand_token = CHECK(parser_need(p, TOKEN_AMPERSAND, error)); - struct Type_Node* referenced_type = CHECK(parser_node_type(p, error)); + struct Tree_Type* referenced_type = CHECK(parser_node_type(p, error)); if (!referenced_type) { parser_error(error, PARSER_ERROR_EXPECTED_TYPE, ampersand_token); return nil; } struct Span span = span_merge(ampersand_token.span, referenced_type->span); - return type_node_new( - TYPE_NODE_REFERENCE, (union Type_Node_Value){ .reference = { referenced_type } }, span, + return tree_type_new( + TREE_TYPE_REFERENCE, (union Tree_Type_Value){ .reference = { referenced_type } }, span, ampersand_token.location); } -struct Type_Node* +struct Tree_Type* parser_node_type_inner(struct Parser* p, struct Parser_Error* error) { struct Token token = parser_peek(p); @@ -821,34 +821,34 @@ parser_node_type_inner(struct Parser* p, struct Parser_Error* error) } } -struct Type_Node* +struct Tree_Type* parser_node_type(struct Parser* p, struct Parser_Error* error) { - struct Type_Node* type = CHECK(parser_node_type_inner(p, error)); + struct Tree_Type* type = CHECK(parser_node_type_inner(p, error)); // check if the type is followed by a `?`, which means it may be nil. if (parser_probe(p, TOKEN_QUESTION)) { parser_next(p); // consume the question mark - type = type_node_new( - TYPE_NODE_MAYBE, (union Type_Node_Value){ .maybe = { type } }, type->span, + type = tree_type_new( + TREE_TYPE_MAYBE, (union Tree_Type_Value){ .maybe = { type } }, type->span, type->location); } return type; } -struct Pragma_Node* +struct Tree_Pragma* parser_pragma_node(struct Parser* p, struct Parser_Error* error) { // `| c_header "stdio.h"` // `| clone always, printable CHECK(parser_need(p, TOKEN_PIPE, error)); - struct Pragma_Node *head = nil, *current = nil; + struct Tree_Pragma *head = nil, *current = nil; struct Token token = parser_peek(p); while (!token_ends_statement(&token)) { struct Token pragma_token = CHECK(parser_need(p, TOKEN_NAME, error)); - enum Pragma_Type pragma_type = pragma_type_from_string(pragma_token.value.name); + enum Tree_Pragma_Type pragma_type = tree_pragma_type_from_string(pragma_token.value.name); if (!pragma_type) { parser_error(error, PARSER_ERROR_EXPECTED_PRAGMA, pragma_token); return nil; @@ -859,29 +859,29 @@ parser_pragma_node(struct Parser* p, struct Parser_Error* error) // parse the arguments until either statement end or comma // arguments can either be numbers, names or strings. uint argument_index = 0; - struct Pragma_Argument arguments[PRAGMA_ARGUMENT_MAX] = { 0 }; + struct Tree_Pragma_Argument arguments[TREE_PRAGMA_ARGUMENT_MAX] = { 0 }; token = parser_peek(p); while (!token_ends_statement(&token)) { - check(argument_index < PRAGMA_ARGUMENT_MAX, "too many pragma arguments"); - struct Pragma_Argument* argument = &arguments[argument_index]; + check(argument_index < TREE_PRAGMA_ARGUMENT_MAX, "too many pragma arguments"); + struct Tree_Pragma_Argument* argument = &arguments[argument_index]; union Token_Value* v = &token.value; switch (token.kind) { case TOKEN_LITERAL_INTEGER: - argument->type = PRAGMA_ARGUMENT_NUMBER; + argument->type = TREE_PRAGMA_ARGUMENT_NUMBER; argument->value.number = v->literal_integer; break; case TOKEN_LITERAL_FLOAT: - argument->type = PRAGMA_ARGUMENT_DECIMAL; + argument->type = TREE_PRAGMA_ARGUMENT_DECIMAL; argument->value.decimal = v->literal_float; break; case TOKEN_LITERAL_STRING: - argument->type = PRAGMA_ARGUMENT_NAME_OR_STRING; + argument->type = TREE_PRAGMA_ARGUMENT_NAME_OR_STRING; argument->value.name_or_string = v->literal_string; break; case TOKEN_NAME: - argument->type = PRAGMA_ARGUMENT_NAME_OR_STRING; + argument->type = TREE_PRAGMA_ARGUMENT_NAME_OR_STRING; argument->value.name_or_string = v->name; break; default: @@ -901,7 +901,7 @@ parser_pragma_node(struct Parser* p, struct Parser_Error* error) if (token_ends_statement(&token)) { break; } } - struct Pragma_Node* pragma = pragma_node_new(pragma_type, span, pragma_token.location); + struct Tree_Pragma* pragma = tree_pragma_new(pragma_type, span, pragma_token.location); pragma->argument_count = argument_index; memcpy(pragma->arguments, arguments, sizeof(arguments)); @@ -916,81 +916,81 @@ parser_pragma_node(struct Parser* p, struct Parser_Error* error) return head; } -struct Expression* +struct Tree_Expression* parser_expression_primary_name(struct Parser* p, struct Parser_Error* error) { struct Token token = CHECK(parser_need(p, TOKEN_NAME, error)); - union Expression_Value value = { .name = { token.value.name } }; - return expression_new(EXPRESSION_NAME, value, token.span, token.location); + union Tree_Expression_Value value = { .name = { token.value.name } }; + return tree_expression_new(TREE_EXPRESSION_NAME, value, token.span, token.location); } -struct Expression* +struct Tree_Expression* parser_expression_primary_integer(struct Parser* p, struct Parser_Error* error) { struct Token token = CHECK(parser_need(p, TOKEN_LITERAL_INTEGER, error)); - union Expression_Value value = { .integer_literal = { token.value.literal_integer } }; - return expression_new(EXPRESSION_INTEGER_LITERAL, value, token.span, token.location); + union Tree_Expression_Value value = { .integer_literal = { token.value.literal_integer } }; + return tree_expression_new(TREE_EXPRESSION_INTEGER_LITERAL, value, token.span, token.location); } -struct Expression* +struct Tree_Expression* parser_expression_primary_float(struct Parser* p, struct Parser_Error* error) { struct Token token = CHECK(parser_need(p, TOKEN_LITERAL_FLOAT, error)); - union Expression_Value value = { .float_literal = { token.value.literal_float } }; - return expression_new(EXPRESSION_FLOAT_LITERAL, value, token.span, token.location); + union Tree_Expression_Value value = { .float_literal = { token.value.literal_float } }; + return tree_expression_new(TREE_EXPRESSION_FLOAT_LITERAL, value, token.span, token.location); } -struct Expression* +struct Tree_Expression* parser_expression_primary_string(struct Parser* p, struct Parser_Error* error) { struct Token token = CHECK(parser_need(p, TOKEN_LITERAL_STRING, error)); - union Expression_Value value = { .string_literal = { token.value.literal_string } }; - return expression_new(EXPRESSION_STRING_LITERAL, value, token.span, token.location); + union Tree_Expression_Value value = { .string_literal = { token.value.literal_string } }; + return tree_expression_new(TREE_EXPRESSION_STRING_LITERAL, value, token.span, token.location); } -struct Expression* +struct Tree_Expression* parser_expression_primary_boolean(struct Parser* p, struct Parser_Error* error) { struct Token token = parser_next(p); check(token.kind == TOKEN_WORD_TRUE || token.kind == TOKEN_WORD_FALSE, "expected boolean literal"); bool literal = token.kind == TOKEN_WORD_TRUE; - union Expression_Value expr_value = { .bool_literal = { literal } }; - return expression_new(EXPRESSION_BOOLEAN_LITERAL, expr_value, token.span, token.location); + union Tree_Expression_Value expr_value = { .bool_literal = { literal } }; + return tree_expression_new(TREE_EXPRESSION_BOOLEAN_LITERAL, expr_value, token.span, token.location); } -struct Expression* +struct Tree_Expression* parser_expression_primary_group(struct Parser* p, struct Parser_Error* error) { struct Token start_token = CHECK(parser_need(p, TOKEN_ROUND_OPEN, error)); - struct Expression* expression = CHECK(parser_expression(p, error)); + struct Tree_Expression* expression = CHECK(parser_expression(p, error)); struct Token end_token = CHECK(parser_need(p, TOKEN_ROUND_CLOSE, error)); struct Span span = span_merge(start_token.span, end_token.span); - union Expression_Value value = { .group = { expression } }; - return expression_new(EXPRESSION_GROUP, value, span, start_token.location); + union Tree_Expression_Value value = { .group = { expression } }; + return tree_expression_new(TREE_EXPRESSION_GROUP, value, span, start_token.location); } -struct Expression* +struct Tree_Expression* parser_expression_function(struct Parser* p, struct Parser_Error* error) { struct Token fun_token = CHECK(parser_need(p, TOKEN_WORD_FUN, error)); - struct Expression_Function fun = { 0 }; + struct Tree_Expression_Function fun = { 0 }; fun.header = CHECK(parser_function_header_node(p, error)); fun.body = CHECK(parser_block_node(p, error)); - return expression_new( - EXPRESSION_FUNCTION, (union Expression_Value){ .function = fun }, + return tree_expression_new( + TREE_EXPRESSION_FUNCTION, (union Tree_Expression_Value){ .function = fun }, span_merge(fun_token.span, fun.body.span), fun_token.location); } -struct Expression* +struct Tree_Expression* parser_expression_type(struct Parser* p, struct Parser_Error* error) { struct Token start_token = parser_peek(p); - struct Type_Node* type = nil; + struct Tree_Type* type = nil; switch (start_token.kind) { case TOKEN_WORD_TYPE: parser_next(p); // skip the `type` keyword. @@ -1007,11 +1007,11 @@ parser_expression_type(struct Parser* p, struct Parser_Error* error) } struct Span span = span_merge(start_token.span, type->span); - return expression_new( - EXPRESSION_TYPE, (union Expression_Value){ .type = { type } }, span, start_token.location); + return tree_expression_new( + TREE_EXPRESSION_TYPE, (union Tree_Expression_Value){ .type = { type } }, span, start_token.location); } -struct Expression* +struct Tree_Expression* parser_expression_primary(struct Parser* p, struct Parser_Error* error) { struct Token token = parser_peek(p); @@ -1043,9 +1043,9 @@ parser_expression_primary(struct Parser* p, struct Parser_Error* error) } } -struct Expression* +struct Tree_Expression* parser_expression_postfix_member( - struct Parser* p, struct Expression* subject, struct Parser_Error* error) + struct Parser* p, struct Tree_Expression* subject, struct Parser_Error* error) { CHECK(parser_need(p, TOKEN_DOT, error)); @@ -1053,18 +1053,18 @@ parser_expression_postfix_member( struct String name = name_token.value.name; struct Span span = span_merge(subject->span, name_token.span); - union Expression_Value value = { .member = { subject, name } }; - return expression_new(EXPRESSION_MEMBER, value, span, name_token.location); + union Tree_Expression_Value value = { .member = { subject, name } }; + return tree_expression_new(TREE_EXPRESSION_MEMBER, value, span, name_token.location); } -struct Expression* +struct Tree_Expression* parser_expression_postfix_call( - struct Parser* p, struct Expression* subject, struct Parser_Error* error) + struct Parser* p, struct Tree_Expression* subject, struct Parser_Error* error) { CHECK(parser_need(p, TOKEN_ROUND_OPEN, error)); parser_unglue(p); - struct Argument_Group_Node argument_group = parser_argument_group_node(p, error); + struct Tree_Argument_Group argument_group = parser_argument_group_node(p, error); if (!parser_error_is_none(error)) { parser_error_wrap(error, PARSER_ERROR_EXPECTED_ARGUMENTS); return nil; @@ -1074,18 +1074,18 @@ parser_expression_postfix_call( struct Token close_token = CHECK(parser_need(p, TOKEN_ROUND_CLOSE, error)); struct Span span = span_merge(subject->span, close_token.span); - union Expression_Value value = { .call = { subject, argument_group } }; - return expression_new(EXPRESSION_CALL, value, span, close_token.location); + union Tree_Expression_Value value = { .call = { subject, argument_group } }; + return tree_expression_new(TREE_EXPRESSION_CALL, value, span, close_token.location); } -struct Expression* +struct Tree_Expression* parser_expression_postfix_construct( - struct Parser* p, struct Expression* subject, struct Parser_Error* error) + struct Parser* p, struct Tree_Expression* subject, struct Parser_Error* error) { CHECK(parser_need(p, TOKEN_CURLY_OPEN, error)); parser_unglue(p); - struct Argument_Group_Node argument_group = parser_argument_group_node(p, error); + struct Tree_Argument_Group argument_group = parser_argument_group_node(p, error); if (!parser_error_is_none(error)) { parser_error_wrap(error, PARSER_ERROR_EXPECTED_ARGUMENTS); return nil; @@ -1096,68 +1096,68 @@ parser_expression_postfix_construct( struct Span span = span_merge(subject->span, token.span); // TODO: convert the `subject` expression to a type node? somehow? - union Expression_Value value = { .construct = { subject, argument_group } }; - return expression_new(EXPRESSION_CONSTRUCT, value, span, token.location); + union Tree_Expression_Value value = { .construct = { subject, argument_group } }; + return tree_expression_new(TREE_EXPRESSION_CONSTRUCT, value, span, token.location); } -struct Expression* +struct Tree_Expression* parser_expression_postfix_subscript( - struct Parser* p, struct Expression* subject, struct Parser_Error* error) + struct Parser* p, struct Tree_Expression* subject, struct Parser_Error* error) { CHECK(parser_need(p, TOKEN_SQUARE_OPEN, error)); - struct Expression* index = CHECK(parser_expression(p, error)); + struct Tree_Expression* index = CHECK(parser_expression(p, error)); struct Token token = CHECK(parser_need(p, TOKEN_SQUARE_CLOSE, error)); struct Span span = span_merge(subject->span, span_merge(index->span, token.span)); - union Expression_Value value = { .subscript = { subject, index } }; - return expression_new(EXPRESSION_SUBSCRIPT, value, span, token.location); + union Tree_Expression_Value value = { .subscript = { subject, index } }; + return tree_expression_new(TREE_EXPRESSION_SUBSCRIPT, value, span, token.location); } -struct Expression* +struct Tree_Expression* parser_expression_postfix_increment_decrement( - struct Parser* p, struct Expression* subject, struct Parser_Error* error) + struct Parser* p, struct Tree_Expression* subject, struct Parser_Error* error) { struct Token token = parser_peek(p); enum Increment_Decrement_Operation operation = increment_decrement_operation_from_token(&token); - struct Expression_Increment_Decrement inc_dec = { + struct Tree_Expression_Increment_Decrement inc_dec = { .prefix = false, .subject = subject, .operation = operation, }; struct Span span = span_merge(subject->span, token.span); - union Expression_Value value = { .increment_decrement = inc_dec }; - return expression_new(EXPRESSION_INCREMENT_DECREMENT, value, span, token.location); + union Tree_Expression_Value value = { .increment_decrement = inc_dec }; + return tree_expression_new(TREE_EXPRESSION_INCREMENT_DECREMENT, value, span, token.location); } -struct Expression* +struct Tree_Expression* parser_expression_postfix_try( - struct Parser* p, struct Expression* subject, struct Parser_Error* error) + struct Parser* p, struct Tree_Expression* subject, struct Parser_Error* error) { struct Token question_token = parser_next(p); struct Span span = span_merge(subject->span, question_token.span); - union Expression_Value value = { .try = { subject } }; - return expression_new(EXPRESSION_TRY, value, span, subject->location); + union Tree_Expression_Value value = { .try = { subject } }; + return tree_expression_new(TREE_EXPRESSION_TRY, value, span, subject->location); } -struct Expression* +struct Tree_Expression* parser_expression_postfix_must( - struct Parser* p, struct Expression* subject, struct Parser_Error* error) + struct Parser* p, struct Tree_Expression* subject, struct Parser_Error* error) { struct Token bang_token = CHECK(parser_need(p, TOKEN_BANG, error)); struct Span span = span_merge(subject->span, bang_token.span); - union Expression_Value value = { .try = { subject } }; - return expression_new(EXPRESSION_MUST, value, span, subject->location); + union Tree_Expression_Value value = { .try = { subject } }; + return tree_expression_new(TREE_EXPRESSION_MUST, value, span, subject->location); } -struct Expression* +struct Tree_Expression* parser_expression_postfix(struct Parser* p, struct Parser_Error* error) { - struct Expression* expression = CHECK(parser_expression_primary(p, error)); + struct Tree_Expression* expression = CHECK(parser_expression_primary(p, error)); // NOTE: we have to parse all subsequent postfix expressions non-recursively. for (;;) { @@ -1190,16 +1190,16 @@ parser_expression_postfix(struct Parser* p, struct Parser_Error* error) increment_decrement_operation_from_token(&token); if (inc_dec_op) { parser_next(p); - struct Expression_Increment_Decrement inc_dec = { + struct Tree_Expression_Increment_Decrement inc_dec = { .prefix = false, .subject = expression, .operation = inc_dec_op, }; struct Span span = span_merge(expression->span, token.span); - union Expression_Value value = { .increment_decrement = inc_dec }; + union Tree_Expression_Value value = { .increment_decrement = inc_dec }; expression = - expression_new(EXPRESSION_INCREMENT_DECREMENT, value, span, token.location); + tree_expression_new(TREE_EXPRESSION_INCREMENT_DECREMENT, value, span, token.location); continue; } @@ -1207,34 +1207,34 @@ parser_expression_postfix(struct Parser* p, struct Parser_Error* error) } } -struct Expression* +struct Tree_Expression* parser_expression_unary_operation(struct Parser* p, struct Parser_Error* error) { struct Token token = parser_peek(p); enum Unary_Operation operation = unary_operation_from_token(&token); if (operation) { parser_next(p); - struct Expression* operand = CHECK(parser_expression_unary_operation(p, error)); + struct Tree_Expression* operand = CHECK(parser_expression_unary_operation(p, error)); struct Span span = span_merge(token.span, operand->span); - union Expression_Value value = { .unary_operator = { operation, operand } }; - return expression_new(EXPRESSION_UNARY_OPERATION, value, span, token.location); + union Tree_Expression_Value value = { .unary_operator = { operation, operand } }; + return tree_expression_new(TREE_EXPRESSION_UNARY_OPERATION, value, span, token.location); } enum Increment_Decrement_Operation inc_dec_op = increment_decrement_operation_from_token(&token); if (inc_dec_op) { parser_next(p); - struct Expression* subject = CHECK(parser_expression_unary_operation(p, error)); - struct Expression_Increment_Decrement inc_dec = { + struct Tree_Expression* subject = CHECK(parser_expression_unary_operation(p, error)); + struct Tree_Expression_Increment_Decrement inc_dec = { .prefix = true, .subject = subject, .operation = inc_dec_op, }; struct Span span = span_merge(token.span, inc_dec.subject->span); - union Expression_Value value = { .increment_decrement = inc_dec }; - return expression_new(EXPRESSION_INCREMENT_DECREMENT, value, span, token.location); + union Tree_Expression_Value value = { .increment_decrement = inc_dec }; + return tree_expression_new(TREE_EXPRESSION_INCREMENT_DECREMENT, value, span, token.location); } return parser_expression_postfix(p, error); @@ -1243,16 +1243,16 @@ parser_expression_unary_operation(struct Parser* p, struct Parser_Error* error) // given two expressions and some kind of binary operation between them, // merge them into a single binary expression, with attention to operator precedence // and associativity. -struct Expression_Binary_Operator +struct Tree_Expression_Binary_Operator parser_merge_into_single_binary_expression( - struct Parser* p, struct Expression* left, enum Binary_Operation operation, - struct Expression* right) + struct Parser* p, struct Tree_Expression* left, enum Binary_Operation operation, + struct Tree_Expression* right) { // NOTE: due to the parser structure, the left expression is never a binary operation // so we can worry about fixing up the right side only. - check(left->kind != EXPRESSION_BINARY_OPERATION, "left expression is a binary operation"); - if (right->kind == EXPRESSION_BINARY_OPERATION) { - struct Expression_Binary_Operator right_binary = right->value.binary_operator; + check(left->kind != TREE_EXPRESSION_BINARY_OPERATION, "left expression is a binary operation"); + if (right->kind == TREE_EXPRESSION_BINARY_OPERATION) { + struct Tree_Expression_Binary_Operator right_binary = right->value.binary_operator; uint right_precedence = binary_operation_precedence(right_binary.operation); uint precedence = binary_operation_precedence(operation); @@ -1268,15 +1268,15 @@ parser_merge_into_single_binary_expression( // since we only use static memory, we need to switch the operands around // without allocating more expressions, thus we have to reuse the allocation // slots of the previous expressions. - struct Expression* operands[3] = { + struct Tree_Expression* operands[3] = { left, right_binary.left_operand, right_binary.right_operand }; - struct Expression* slots[2] = { right, right_binary.right_operand }; + struct Tree_Expression* slots[2] = { right, right_binary.right_operand }; - struct Expression_Binary_Operator new_binary_operator = + struct Tree_Expression_Binary_Operator new_binary_operator = parser_merge_into_single_binary_expression(p, operands[0], operation, operands[1]); - *slots[0] = (struct Expression){ - .kind = EXPRESSION_BINARY_OPERATION, + *slots[0] = (struct Tree_Expression){ + .kind = TREE_EXPRESSION_BINARY_OPERATION, .value = { .binary_operator = new_binary_operator }, .span = span_merge(left->span, right->span), .location = left->location @@ -1290,103 +1290,103 @@ parser_merge_into_single_binary_expression( } } - return (struct Expression_Binary_Operator){ + return (struct Tree_Expression_Binary_Operator){ .operation = operation, .left_operand = left, .right_operand = right, }; } -struct Expression* +struct Tree_Expression* parser_expression_binary_operation(struct Parser* p, struct Parser_Error* error) { - struct Expression* left = CHECK(parser_expression_unary_operation(p, error)); + struct Tree_Expression* left = CHECK(parser_expression_unary_operation(p, error)); struct Token token = parser_peek(p); enum Binary_Operation operation = binary_operation_from_token(&token); if (operation) { parser_next(p); - struct Expression* right = CHECK(parser_expression_binary_operation(p, error)); + struct Tree_Expression* right = CHECK(parser_expression_binary_operation(p, error)); struct Span span = span_merge(left->span, right->span); - struct Expression_Binary_Operator binary_value = + struct Tree_Expression_Binary_Operator binary_value = parser_merge_into_single_binary_expression(p, left, operation, right); - union Expression_Value value = { .binary_operator = binary_value }; - return expression_new(EXPRESSION_BINARY_OPERATION, value, span, left->location); + union Tree_Expression_Value value = { .binary_operator = binary_value }; + return tree_expression_new(TREE_EXPRESSION_BINARY_OPERATION, value, span, left->location); } return left; } -struct Expression* +struct Tree_Expression* parser_expression(struct Parser* p, struct Parser_Error* error) { return parser_expression_binary_operation(p, error); } -struct Statement* +struct Tree_Statement* parser_statement_declaration(struct Parser* p, struct Parser_Error* error) { struct Token declaration_token = parser_next(p); - enum Statement_Declaration_Kind declaration_kind = - statement_declaration_kind_from_token(&declaration_token); + enum Tree_Statement_Declaration_Kind declaration_kind = + tree_statement_declaration_kind_from_token(&declaration_token); check(declaration_kind, "expected valid declaration token"); - struct Bare_Declaration_Node inner = CHECK(parser_bare_declaration_node(p, error)); + struct Tree_Bare_Declaration inner = CHECK(parser_bare_declaration_node(p, error)); struct Span span = span_merge(declaration_token.span, inner.span); - union Statement_Value value = { + union Tree_Statement_Value value = { .declaration = { .kind = declaration_kind, .inner = inner, }, }; - return statement_new(STATEMENT_DECLARATION, value, span, declaration_token.location); + return tree_statement_new(TREE_STATEMENT_DECLARATION, value, span, declaration_token.location); } -struct Statement* +struct Tree_Statement* parser_statement_conditional(struct Parser* p, struct Parser_Error* error) { - struct Statement_Value_Conditional conditional = { 0 }; + struct Tree_Statement_Value_Conditional conditional = { 0 }; struct Token if_token = parser_need(p, TOKEN_WORD_IF, error); // primary if condition + block. CONTEXT_START(in_statement_clause); - struct Expression* if_condition = CHECK(parser_expression(p, error)); + struct Tree_Expression* if_condition = CHECK(parser_expression(p, error)); CONTEXT_END(in_statement_clause); - struct Block_Node then_block = CHECK(parser_block_node(p, error)); - conditional.conditions[conditional.condition_count++] = (struct Statement_Conditional_Branch){ + struct Tree_Block then_block = CHECK(parser_block_node(p, error)); + conditional.conditions[conditional.condition_count++] = (struct Tree_Statement_Conditional_Branch){ .when = if_condition, .then = then_block, }; struct Span span = span_merge(if_token.span, then_block.span); while (parser_probe(p, TOKEN_WORD_ELSE)) { - check(conditional.condition_count < STATEMENT_VALUE_CONDITIONAL_MAX, + check(conditional.condition_count < TREE_STATEMENT_VALUE_CONDITIONAL_MAX, "too many conditional branches"); parser_next(p); - struct Statement_Conditional_Branch branch = { 0 }; + struct Tree_Statement_Conditional_Branch branch = { 0 }; if (parser_probe(p, TOKEN_WORD_IF)) { // else if condition + block. parser_next(p); CONTEXT_START(in_statement_clause); - struct Expression* else_condition = CHECK(parser_expression(p, error)); + struct Tree_Expression* else_condition = CHECK(parser_expression(p, error)); CONTEXT_END(in_statement_clause); - struct Block_Node else_block = CHECK(parser_block_node(p, error)); + struct Tree_Block else_block = CHECK(parser_block_node(p, error)); - branch = (struct Statement_Conditional_Branch){ + branch = (struct Tree_Statement_Conditional_Branch){ .when = else_condition, .then = else_block, }; } else { // else block. - struct Block_Node else_block = CHECK(parser_block_node(p, error)); - branch = (struct Statement_Conditional_Branch){ + struct Tree_Block else_block = CHECK(parser_block_node(p, error)); + branch = (struct Tree_Statement_Conditional_Branch){ .when = nil, .then = else_block, }; @@ -1396,12 +1396,12 @@ parser_statement_conditional(struct Parser* p, struct Parser_Error* error) span = span_merge(span, branch.then.span); } - return statement_new( - STATEMENT_CONDITIONAL, (union Statement_Value){ .conditional = conditional }, span, + return tree_statement_new( + TREE_STATEMENT_CONDITIONAL, (union Tree_Statement_Value){ .conditional = conditional }, span, if_token.location); } -struct Statement* +struct Tree_Statement* parser_statement_for(struct Parser* p, struct Parser_Error* error) { struct Token for_token = CHECK(parser_need(p, TOKEN_WORD_FOR, error)); @@ -1412,13 +1412,13 @@ parser_statement_for(struct Parser* p, struct Parser_Error* error) // a declaration without a signifier like `var` or `let`. CONTEXT_START(in_statement_clause); - struct Bare_Declaration_Node declaration = CHECK(parser_bare_declaration_node(p, error)); + struct Tree_Bare_Declaration declaration = CHECK(parser_bare_declaration_node(p, error)); CONTEXT_END(in_statement_clause); - enum Statement_Loop_Style style = STATEMENT_LOOP_STYLE_FOR_EACH; + enum Tree_Statement_Loop_Style style = TREE_STATEMENT_LOOP_STYLE_FOR_EACH; // c-style semi-semi loop. - struct Expression *condition = nil, *iteration = nil; + struct Tree_Expression *condition = nil, *iteration = nil; if (parser_probe(p, TOKEN_COMMA)) { parser_next(p); condition = CHECK(parser_expression(p, error)); @@ -1428,13 +1428,13 @@ parser_statement_for(struct Parser* p, struct Parser_Error* error) iteration = CHECK(parser_expression(p, error)); CONTEXT_END(in_statement_clause) - style = STATEMENT_LOOP_STYLE_C; + style = TREE_STATEMENT_LOOP_STYLE_C; } - struct Block_Node body = CHECK(parser_block_node(p, error)); + struct Tree_Block body = CHECK(parser_block_node(p, error)); struct Span span = span_merge(for_token.span, body.span); - union Statement_Value value = { + union Tree_Statement_Value value = { .loop = { .style = style, .declaration = declaration, @@ -1443,113 +1443,113 @@ parser_statement_for(struct Parser* p, struct Parser_Error* error) .body = body, }, }; - return statement_new(STATEMENT_LOOP, value, span, for_token.location); + return tree_statement_new(TREE_STATEMENT_LOOP, value, span, for_token.location); } -struct Statement* +struct Tree_Statement* parser_statement_while(struct Parser* p, struct Parser_Error* error) { struct Token while_token = CHECK(parser_need(p, TOKEN_WORD_WHILE, error)); - enum Statement_Loop_Style style = STATEMENT_LOOP_STYLE_ENDLESS; - struct Expression* condition = nil; + enum Tree_Statement_Loop_Style style = TREE_STATEMENT_LOOP_STYLE_ENDLESS; + struct Tree_Expression* condition = nil; if (!parser_probe(p, TOKEN_CURLY_OPEN)) { CONTEXT_START(in_statement_clause); condition = CHECK(parser_expression(p, error)); CONTEXT_END(in_statement_clause); - style = STATEMENT_LOOP_STYLE_WHILE; + style = TREE_STATEMENT_LOOP_STYLE_WHILE; } - struct Block_Node body = CHECK(parser_block_node(p, error)); + struct Tree_Block body = CHECK(parser_block_node(p, error)); struct Span span = span_merge(while_token.span, body.span); - union Statement_Value value = { + union Tree_Statement_Value value = { .loop = { .style = style, .condition = condition, .body = body } }; - return statement_new(STATEMENT_LOOP, value, span, while_token.location); + return tree_statement_new(TREE_STATEMENT_LOOP, value, span, while_token.location); } -struct Statement* +struct Tree_Statement* parser_statement_block(struct Parser* p, struct Parser_Error* error) { - struct Block_Node block = CHECK(parser_block_node(p, error)); - return statement_new( - STATEMENT_BLOCK, (union Statement_Value){ .block = { block } }, block.span, block.location); + struct Tree_Block block = CHECK(parser_block_node(p, error)); + return tree_statement_new( + TREE_STATEMENT_BLOCK, (union Tree_Statement_Value){ .block = { block } }, block.span, block.location); } -struct Statement* +struct Tree_Statement* parser_statement_return(struct Parser* p, struct Parser_Error* error) { struct Token return_token = CHECK(parser_need(p, TOKEN_WORD_RETURN, error)); - struct Expression* value = nil; + struct Tree_Expression* value = nil; if (!token_ends_statement(&return_token)) { value = CHECK(parser_expression(p, error)); } struct Span span = value ? return_token.span : span_merge(return_token.span, value->span); - union Statement_Value statement_value = { .return_value = { value } }; - return statement_new(STATEMENT_RETURN, statement_value, span, return_token.location); + union Tree_Statement_Value statement_value = { .return_value = { value } }; + return tree_statement_new(TREE_STATEMENT_RETURN, statement_value, span, return_token.location); } -struct Statement* +struct Tree_Statement* parser_statement_break(struct Parser* p, struct Parser_Error* error) { struct Token break_token = CHECK(parser_need(p, TOKEN_WORD_BREAK, error)); struct Span span = break_token.span; - return statement_new(STATEMENT_BREAK, (union Statement_Value){ 0 }, span, break_token.location); + return tree_statement_new(TREE_STATEMENT_BREAK, (union Tree_Statement_Value){ 0 }, span, break_token.location); } -struct Statement* +struct Tree_Statement* parser_statement_continue(struct Parser* p, struct Parser_Error* error) { struct Token continue_token = CHECK(parser_need(p, TOKEN_WORD_CONTINUE, error)); struct Span span = continue_token.span; - return statement_new( - STATEMENT_CONTINUE, (union Statement_Value){ 0 }, span, continue_token.location); + return tree_statement_new( + TREE_STATEMENT_CONTINUE, (union Tree_Statement_Value){ 0 }, span, continue_token.location); } -struct Statement* +struct Tree_Statement* parser_statement_defer(struct Parser* p, struct Parser_Error* error) { struct Token defer_token = CHECK(parser_need(p, TOKEN_WORD_DEFER, error)); struct Span span = defer_token.span; - struct Statement_Value_Defer defer = { 0 }; + struct Tree_Statement_Value_Defer defer = { 0 }; if (parser_probe(p, TOKEN_CURLY_OPEN)) { - struct Block_Node block = CHECK(parser_block_node(p, error)); + struct Tree_Block block = CHECK(parser_block_node(p, error)); span = span_merge(span, block.span); defer.block = block; } else { - struct Expression* expression = CHECK(parser_expression(p, error)); + struct Tree_Expression* expression = CHECK(parser_expression(p, error)); span = span_merge(span, expression->span); defer.expression = expression; } - union Statement_Value value = { .defer = defer }; - return statement_new(STATEMENT_DEFER, value, span, defer_token.location); + union Tree_Statement_Value value = { .defer = defer }; + return tree_statement_new(TREE_STATEMENT_DEFER, value, span, defer_token.location); } -struct Statement* +struct Tree_Statement* parser_statement_pragma(struct Parser* p, struct Parser_Error* error) { struct Token pipe_token = parser_peek(p); - struct Pragma_Node* pragma_node = parser_pragma_node(p, error); + struct Tree_Pragma* tree_pragma = parser_pragma_node(p, error); if (!parser_error_is_none(error)) { parser_error_wrap(error, PARSER_ERROR_EXPECTED_PRAGMA); return nil; } struct Span span = {}; - FOR_EACH (struct Pragma_Node*, node, pragma_node) { + FOR_EACH (struct Tree_Pragma*, node, tree_pragma) { span = span_is_empty(span) ? node->span : span_merge(span, node->span); } - union Statement_Value value = { .pragma.inner = pragma_node }; - return statement_new(STATEMENT_PRAGMA, value, span, pipe_token.location); + union Tree_Statement_Value value = { .pragma.inner = tree_pragma }; + return tree_statement_new(TREE_STATEMENT_PRAGMA, value, span, pipe_token.location); } -struct Statement* +struct Tree_Statement* parser_statement(struct Parser* p, struct Parser_Error* error) { struct Token token = parser_peek(p); @@ -1586,12 +1586,12 @@ parser_statement(struct Parser* p, struct Parser_Error* error) break; } - struct Expression* expression = CHECK(parser_expression(p, error)); + struct Tree_Expression* expression = CHECK(parser_expression(p, error)); // expand by one byte to include the statement terminator. struct Span span = span_expand(expression->span, 1); - union Statement_Value value = { .expression.inner = expression }; - return statement_new(STATEMENT_EXPRESSION, value, span, expression->location); + union Tree_Statement_Value value = { .expression.inner = expression }; + return tree_statement_new(TREE_STATEMENT_EXPRESSION, value, span, expression->location); } void @@ -1613,10 +1613,10 @@ parser_do_your_thing(struct Parser* p, struct Tree* tree) struct Parser_Error error; parser_error_none(&error); - struct Statement* head = nil; - struct Statement* current = nil; + struct Tree_Statement* head = nil; + struct Tree_Statement* current = nil; while (!parser_reached_end(p)) { - struct Statement* next = parser_statement(p, &error); + struct Tree_Statement* next = parser_statement(p, &error); parser_handle_error(p, &error); if (next) { |