diff options
Diffstat (limited to 'boot/visit.c')
| -rw-r--r-- | boot/visit.c | 652 |
1 files changed, 326 insertions, 326 deletions
diff --git a/boot/visit.c b/boot/visit.c index f9ad51c..83de09a 100644 --- a/boot/visit.c +++ b/boot/visit.c @@ -13,60 +13,60 @@ #include "catboot.h" -struct Visit +struct Tree_Visit { - struct Visit_Table* table; + struct Tree_Visit_Table* table; void* user_data; }; -struct Visit_Table -{ - void (*visit_tree)(struct Visit* visitor, struct Tree* tree); - - void (*visit_statement)(struct Visit* visitor, struct Statement* stmt); - void (*visit_statement_declaration)(struct Visit* visitor, struct Statement* stmt); - void (*visit_statement_conditional)(struct Visit* visitor, struct Statement* stmt); - void (*visit_statement_loop)(struct Visit* visitor, struct Statement* stmt); - void (*visit_statement_return)(struct Visit* visitor, struct Statement* stmt); - void (*visit_statement_break)(struct Visit* visitor, struct Statement* stmt); - void (*visit_statement_continue)(struct Visit* visitor, struct Statement* stmt); - void (*visit_statement_defer)(struct Visit* visitor, struct Statement* stmt); - - void (*visit_expression)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_integer_literal)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_float_literal)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_string_literal)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_boolean_literal)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_name)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_unary_operation)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_binary_operation)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_group)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_call)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_construct)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_subscript)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_member)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_increment_decrement)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_try)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_must)(struct Visit* visitor, struct Expression* expr); - void (*visit_expression_function)(struct Visit* visitor, struct Expression* expr); - - void (*visit_type_node)(struct Visit* visitor, struct Type_Node* node); - void (*visit_type_node_name)(struct Visit* visitor, struct Type_Node* node); - void (*visit_type_node_array)(struct Visit* visitor, struct Type_Node* node); - void (*visit_type_node_reference)(struct Visit* visitor, struct Type_Node* node); - void (*visit_type_node_maybe)(struct Visit* visitor, struct Type_Node* node); - void (*visit_type_node_tuple)(struct Visit* visitor, struct Type_Node* node); - void (*visit_type_node_map)(struct Visit* visitor, struct Type_Node* node); - void (*visit_type_node_function)(struct Visit* visitor, struct Type_Node* node); - void (*visit_type_node_structure)(struct Visit* visitor, struct Type_Node* node); - void (*visit_type_node_variant)(struct Visit* visitor, struct Type_Node* node); - void (*visit_type_node_class)(struct Visit* visitor, struct Type_Node* node); - - void (*visit_block_node)(struct Visit* visitor, struct Block_Node* node); - void (*visit_bare_declaration_node)(struct Visit* visitor, struct Bare_Declaration_Node* node); - void (*visit_function_header_node)(struct Visit* visitor, struct Function_Header_Node* header); - void (*visit_argument_group_node)(struct Visit* visitor, struct Argument_Group_Node* node); - void (*visit_pragma_node)(struct Visit* visitor, struct Pragma_Node* node); +struct Tree_Visit_Table +{ + void (*visit_tree)(struct Tree_Visit* visitor, struct Tree* tree); + + void (*visit_statement)(struct Tree_Visit* visitor, struct Tree_Statement* stmt); + void (*visit_statement_declaration)(struct Tree_Visit* visitor, struct Tree_Statement* stmt); + void (*visit_statement_conditional)(struct Tree_Visit* visitor, struct Tree_Statement* stmt); + void (*visit_statement_loop)(struct Tree_Visit* visitor, struct Tree_Statement* stmt); + void (*visit_statement_return)(struct Tree_Visit* visitor, struct Tree_Statement* stmt); + void (*visit_statement_break)(struct Tree_Visit* visitor, struct Tree_Statement* stmt); + void (*visit_statement_continue)(struct Tree_Visit* visitor, struct Tree_Statement* stmt); + void (*visit_statement_defer)(struct Tree_Visit* visitor, struct Tree_Statement* stmt); + + void (*visit_expression)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_integer_literal)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_float_literal)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_string_literal)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_boolean_literal)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_name)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_unary_operation)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_binary_operation)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_group)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_call)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_construct)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_subscript)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_member)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_increment_decrement)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_try)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_must)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + void (*visit_expression_function)(struct Tree_Visit* visitor, struct Tree_Expression* expr); + + void (*visit_type_node)(struct Tree_Visit* visitor, struct Tree_Type* node); + void (*visit_type_node_name)(struct Tree_Visit* visitor, struct Tree_Type* node); + void (*visit_type_node_array)(struct Tree_Visit* visitor, struct Tree_Type* node); + void (*visit_type_node_reference)(struct Tree_Visit* visitor, struct Tree_Type* node); + void (*visit_type_node_maybe)(struct Tree_Visit* visitor, struct Tree_Type* node); + void (*visit_type_node_tuple)(struct Tree_Visit* visitor, struct Tree_Type* node); + void (*visit_type_node_map)(struct Tree_Visit* visitor, struct Tree_Type* node); + void (*visit_type_node_function)(struct Tree_Visit* visitor, struct Tree_Type* node); + void (*visit_type_node_structure)(struct Tree_Visit* visitor, struct Tree_Type* node); + void (*visit_type_node_variant)(struct Tree_Visit* visitor, struct Tree_Type* node); + void (*visit_type_node_class)(struct Tree_Visit* visitor, struct Tree_Type* node); + + void (*visit_block_node)(struct Tree_Visit* visitor, struct Tree_Block* node); + void (*visit_bare_declaration_node)(struct Tree_Visit* visitor, struct Tree_Bare_Declaration* node); + void (*visit_function_header_node)(struct Tree_Visit* visitor, struct Tree_Function_Header* header); + void (*visit_argument_group_node)(struct Tree_Visit* visitor, struct Tree_Argument_Group* node); + void (*visit_pragma_node)(struct Tree_Visit* visitor, struct Tree_Pragma* node); }; #define VISIT(visit_function, node) visit->table->visit_function(visit, node); @@ -78,76 +78,76 @@ struct Visit_Table type* name = (type*)visit->user_data; \ if (!name) { failure("visit user data is NULL for " #name); } -// walk functions are the default traversal mechanism +// tree_walk functions are the default traversal mechanism -// define a walk function which goes nowhere. -#define WALK_LEAF_FUNCTION(name, type) \ - void name(struct Visit* visit, type node) {} +// define a tree_walk function which goes nowhere. +#define TREE_WALK_LEAF_FUNCTION(name, type) \ + void name(struct Tree_Visit* visit, type node) {} -// top-level walk function for beginning the visit flow. +// top-level tree_walk function for beginning the visit flow. void -walk(struct Visit* visit, struct Tree* tree) +tree_walk(struct Tree_Visit* visit, struct Tree* tree) { VISIT(visit_tree, tree); } void -walk_tree(struct Visit* visit, struct Tree* tree) +tree_walk_tree(struct Tree_Visit* visit, struct Tree* tree) { - FOR_EACH (struct Statement*, statement, tree->top_level_statements) { + FOR_EACH (struct Tree_Statement*, statement, tree->top_level_statements) { VISIT(visit_statement, statement); } } void -walk_statement(struct Visit* visit, struct Statement* statement) +tree_walk_statement(struct Tree_Visit* visit, struct Tree_Statement* statement) { switch (statement->kind) { - case STATEMENT_EXPRESSION: + case TREE_STATEMENT_EXPRESSION: VISIT(visit_expression, statement->value.expression.inner); break; - case STATEMENT_DECLARATION: + case TREE_STATEMENT_DECLARATION: VISIT(visit_statement_declaration, statement); break; - case STATEMENT_BLOCK: + case TREE_STATEMENT_BLOCK: VISIT(visit_block_node, &statement->value.block.inner); break; - case STATEMENT_CONDITIONAL: + case TREE_STATEMENT_CONDITIONAL: VISIT(visit_statement_conditional, statement); break; - case STATEMENT_LOOP: + case TREE_STATEMENT_LOOP: VISIT(visit_statement_loop, statement); break; - case STATEMENT_RETURN: + case TREE_STATEMENT_RETURN: VISIT(visit_statement_return, statement); break; - case STATEMENT_BREAK: + case TREE_STATEMENT_BREAK: VISIT(visit_statement_break, statement); break; - case STATEMENT_CONTINUE: + case TREE_STATEMENT_CONTINUE: VISIT(visit_statement_continue, statement); break; - case STATEMENT_DEFER: + case TREE_STATEMENT_DEFER: VISIT(visit_statement_defer, statement); break; - case STATEMENT_PRAGMA: + case TREE_STATEMENT_PRAGMA: VISIT(visit_pragma_node, statement->value.pragma.inner); break; default: - failure("unexpected statement kind in `walk_statement`"); + failure("unexpected statement kind in `tree_walk_statement`"); } } void -walk_statement_declaration(struct Visit* visit, struct Statement* statement) +tree_walk_statement_declaration(struct Tree_Visit* visit, struct Tree_Statement* statement) { VISIT(visit_bare_declaration_node, &statement->value.declaration.inner); } void -walk_statement_conditional(struct Visit* visit, struct Statement* statement) +tree_walk_statement_conditional(struct Tree_Visit* visit, struct Tree_Statement* statement) { - struct Statement_Value_Conditional* conditional = &statement->value.conditional; + struct Tree_Statement_Value_Conditional* conditional = &statement->value.conditional; for (uint i = 0; i < conditional->condition_count; ++i) { VISIT_MAYBE(visit_expression, conditional->conditions[i].when); VISIT(visit_block_node, &conditional->conditions[i].then); @@ -155,16 +155,16 @@ walk_statement_conditional(struct Visit* visit, struct Statement* statement) } void -walk_statement_loop(struct Visit* visit, struct Statement* statement) +tree_walk_statement_loop(struct Tree_Visit* visit, struct Tree_Statement* statement) { - struct Statement_Value_Loop* loop = &statement->value.loop; + struct Tree_Statement_Value_Loop* loop = &statement->value.loop; VISIT_MAYBE(visit_expression, loop->condition); VISIT_MAYBE(visit_expression, loop->iteration); VISIT(visit_block_node, &loop->body); } void -walk_statement_return(struct Visit* visit, struct Statement* statement) +tree_walk_statement_return(struct Tree_Visit* visit, struct Tree_Statement* statement) { VISIT_MAYBE(visit_expression, statement->value.return_value.value); } @@ -172,358 +172,358 @@ walk_statement_return(struct Visit* visit, struct Statement* statement) // although.. maybe with `break` we could make a loop become an expression, // this returning the break value as the value of the loop? // something to think about. -WALK_LEAF_FUNCTION(walk_statement_break, struct Statement*); +TREE_WALK_LEAF_FUNCTION(tree_walk_statement_break, struct Tree_Statement*); -WALK_LEAF_FUNCTION(walk_statement_continue, struct Statement*); +TREE_WALK_LEAF_FUNCTION(tree_walk_statement_continue, struct Tree_Statement*); void -walk_statement_defer(struct Visit* visit, struct Statement* statement) +tree_walk_statement_defer(struct Tree_Visit* visit, struct Tree_Statement* statement) { VISIT_MAYBE(visit_expression, statement->value.defer.expression); VISIT(visit_block_node, &statement->value.defer.block); } void -walk_expression(struct Visit* visit, struct Expression* expression) +tree_walk_expression(struct Tree_Visit* visit, struct Tree_Expression* expression) { switch (expression->kind) { - case EXPRESSION_INTEGER_LITERAL: + case TREE_EXPRESSION_INTEGER_LITERAL: VISIT(visit_expression_integer_literal, expression); break; - case EXPRESSION_FLOAT_LITERAL: + case TREE_EXPRESSION_FLOAT_LITERAL: VISIT(visit_expression_float_literal, expression); break; - case EXPRESSION_STRING_LITERAL: + case TREE_EXPRESSION_STRING_LITERAL: VISIT(visit_expression_string_literal, expression); break; - case EXPRESSION_BOOLEAN_LITERAL: + case TREE_EXPRESSION_BOOLEAN_LITERAL: VISIT(visit_expression_boolean_literal, expression); break; - case EXPRESSION_NAME: + case TREE_EXPRESSION_NAME: VISIT(visit_expression_name, expression); break; - case EXPRESSION_UNARY_OPERATION: + case TREE_EXPRESSION_UNARY_OPERATION: VISIT(visit_expression_unary_operation, expression); break; - case EXPRESSION_BINARY_OPERATION: + case TREE_EXPRESSION_BINARY_OPERATION: VISIT(visit_expression_binary_operation, expression); break; - case EXPRESSION_GROUP: + case TREE_EXPRESSION_GROUP: VISIT(visit_expression_group, expression); break; - case EXPRESSION_CALL: + case TREE_EXPRESSION_CALL: VISIT(visit_expression_call, expression); break; - case EXPRESSION_CONSTRUCT: + case TREE_EXPRESSION_CONSTRUCT: VISIT(visit_expression_construct, expression); break; - case EXPRESSION_SUBSCRIPT: + case TREE_EXPRESSION_SUBSCRIPT: VISIT(visit_expression_subscript, expression); break; - case EXPRESSION_MEMBER: + case TREE_EXPRESSION_MEMBER: VISIT(visit_expression_member, expression); break; - case EXPRESSION_INCREMENT_DECREMENT: + case TREE_EXPRESSION_INCREMENT_DECREMENT: VISIT(visit_expression_increment_decrement, expression); break; - case EXPRESSION_TRY: + case TREE_EXPRESSION_TRY: VISIT(visit_expression_try, expression); break; - case EXPRESSION_MUST: + case TREE_EXPRESSION_MUST: VISIT(visit_expression_must, expression); break; - case EXPRESSION_FUNCTION: + case TREE_EXPRESSION_FUNCTION: VISIT(visit_expression_function, expression); break; - case EXPRESSION_TYPE: + case TREE_EXPRESSION_TYPE: VISIT(visit_type_node, expression->value.type.type); break; default: - failure("unexpected expression kind in `walk_expression`"); + failure("unexpected expression kind in `tree_walk_expression`"); } } -WALK_LEAF_FUNCTION(walk_expression_integer_literal, struct Expression*); +TREE_WALK_LEAF_FUNCTION(tree_walk_expression_integer_literal, struct Tree_Expression*); -WALK_LEAF_FUNCTION(walk_expression_float_literal, struct Expression*); +TREE_WALK_LEAF_FUNCTION(tree_walk_expression_float_literal, struct Tree_Expression*); -WALK_LEAF_FUNCTION(walk_expression_string_literal, struct Expression*); +TREE_WALK_LEAF_FUNCTION(tree_walk_expression_string_literal, struct Tree_Expression*); -WALK_LEAF_FUNCTION(walk_expression_boolean_literal, struct Expression*); +TREE_WALK_LEAF_FUNCTION(tree_walk_expression_boolean_literal, struct Tree_Expression*); -WALK_LEAF_FUNCTION(walk_expression_name, struct Expression*); +TREE_WALK_LEAF_FUNCTION(tree_walk_expression_name, struct Tree_Expression*); void -walk_expression_unary_operation(struct Visit* visit, struct Expression* expression) +tree_walk_expression_unary_operation(struct Tree_Visit* visit, struct Tree_Expression* expression) { VISIT(visit_expression, expression->value.unary_operator.operand); } void -walk_expression_binary_operation(struct Visit* visit, struct Expression* expression) +tree_walk_expression_binary_operation(struct Tree_Visit* visit, struct Tree_Expression* expression) { VISIT(visit_expression, expression->value.binary_operator.left_operand); VISIT(visit_expression, expression->value.binary_operator.right_operand); } void -walk_expression_group(struct Visit* visit, struct Expression* expression) +tree_walk_expression_group(struct Tree_Visit* visit, struct Tree_Expression* expression) { VISIT(visit_expression, expression->value.group.inner_expression); } void -walk_expression_call(struct Visit* visit, struct Expression* expression) +tree_walk_expression_call(struct Tree_Visit* visit, struct Tree_Expression* expression) { - struct Expression_Call* call = &expression->value.call; + struct Tree_Expression_Call* call = &expression->value.call; VISIT(visit_expression, call->subject); VISIT(visit_argument_group_node, &call->argument_group); } void -walk_expression_construct(struct Visit* visit, struct Expression* expression) +tree_walk_expression_construct(struct Tree_Visit* visit, struct Tree_Expression* expression) { - struct Expression_Construct* construct = &expression->value.construct; + struct Tree_Expression_Construct* construct = &expression->value.construct; VISIT(visit_expression, construct->subject); VISIT(visit_argument_group_node, &construct->argument_group); } void -walk_expression_subscript(struct Visit* visit, struct Expression* expression) +tree_walk_expression_subscript(struct Tree_Visit* visit, struct Tree_Expression* expression) { VISIT(visit_expression, expression->value.subscript.subject); VISIT(visit_expression, expression->value.subscript.index); } void -walk_expression_member(struct Visit* visit, struct Expression* expression) +tree_walk_expression_member(struct Tree_Visit* visit, struct Tree_Expression* expression) { VISIT(visit_expression, expression->value.member.subject); } void -walk_expression_increment_decrement(struct Visit* visit, struct Expression* expression) +tree_walk_expression_increment_decrement(struct Tree_Visit* visit, struct Tree_Expression* expression) { VISIT(visit_expression, expression->value.increment_decrement.subject); } -WALK_LEAF_FUNCTION(walk_expression_try, struct Expression*); +TREE_WALK_LEAF_FUNCTION(tree_walk_expression_try, struct Tree_Expression*); -WALK_LEAF_FUNCTION(walk_expression_must, struct Expression*); +TREE_WALK_LEAF_FUNCTION(tree_walk_expression_must, struct Tree_Expression*); void -walk_expression_function(struct Visit* visit, struct Expression* expression) +tree_walk_expression_function(struct Tree_Visit* visit, struct Tree_Expression* expression) { VISIT(visit_function_header_node, &expression->value.function.header); VISIT(visit_block_node, &expression->value.function.body); } void -walk_type_node(struct Visit* visit, struct Type_Node* node) +tree_walk_type(struct Tree_Visit* visit, struct Tree_Type* node) { switch (node->type) { - case TYPE_NODE_NONE: + case TREE_TYPE_NONE: break; - case TYPE_NODE_NAME: + case TREE_TYPE_NAME: VISIT(visit_type_node_name, node); break; - case TYPE_NODE_ARRAY: + case TREE_TYPE_ARRAY: VISIT(visit_type_node_array, node); break; - case TYPE_NODE_REFERENCE: + case TREE_TYPE_REFERENCE: VISIT(visit_type_node_reference, node); break; - case TYPE_NODE_MAYBE: + case TREE_TYPE_MAYBE: VISIT(visit_type_node_maybe, node); break; - case TYPE_NODE_TUPLE: + case TREE_TYPE_TUPLE: VISIT(visit_type_node_tuple, node); break; - case TYPE_NODE_MAP: + case TREE_TYPE_MAP: VISIT(visit_type_node_map, node); break; - case TYPE_NODE_FUNCTION: + case TREE_TYPE_FUNCTION: VISIT(visit_type_node_function, node); break; - case TYPE_NODE_STRUCTURE: + case TREE_TYPE_STRUCTURE: VISIT(visit_type_node_structure, node); break; - case TYPE_NODE_VARIANT: + case TREE_TYPE_VARIANT: VISIT(visit_type_node_variant, node); break; - case TYPE_NODE_CLASS: + case TREE_TYPE_CLASS: VISIT(visit_type_node_class, node); break; default: - failure("unexpected type node kind in `walk_type_node`"); + failure("unexpected type node kind in `tree_walk_type`"); } } -WALK_LEAF_FUNCTION(walk_type_node_name, struct Type_Node*); +TREE_WALK_LEAF_FUNCTION(tree_walk_type_name, struct Tree_Type*); void -walk_type_node_array(struct Visit* visit, struct Type_Node* node) +tree_walk_type_array(struct Tree_Visit* visit, struct Tree_Type* node) { VISIT(visit_type_node, node->value.array.element_type); } void -walk_type_node_reference(struct Visit* visit, struct Type_Node* node) +tree_walk_type_reference(struct Tree_Visit* visit, struct Tree_Type* node) { VISIT(visit_type_node, node->value.reference.referenced_type); } void -walk_type_node_maybe(struct Visit* visit, struct Type_Node* node) +tree_walk_type_maybe(struct Tree_Visit* visit, struct Tree_Type* node) { VISIT(visit_type_node, node->value.maybe.inner_type); } void -walk_type_node_tuple(struct Visit* visit, struct Type_Node* node) +tree_walk_type_tuple(struct Tree_Visit* visit, struct Tree_Type* node) { - FOR_EACH (struct Type_Node*, current, node->value.tuple.head) { + FOR_EACH (struct Tree_Type*, current, node->value.tuple.head) { VISIT(visit_type_node, current); } } void -walk_type_node_map(struct Visit* visit, struct Type_Node* node) +tree_walk_type_map(struct Tree_Visit* visit, struct Tree_Type* node) { VISIT(visit_type_node, node->value.map.key_type); VISIT(visit_type_node, node->value.map.value_type); } void -walk_type_node_function(struct Visit* visit, struct Type_Node* node) +tree_walk_type_function(struct Tree_Visit* visit, struct Tree_Type* node) { VISIT(visit_function_header_node, &node->value.function.header); } void -walk_type_node_structure(struct Visit* visit, struct Type_Node* node) +tree_walk_type_structure(struct Tree_Visit* visit, struct Tree_Type* node) { - FOR_EACH (struct Type_Node*, field, node->value.structure.fields) { + FOR_EACH (struct Tree_Type*, field, node->value.structure.fields) { VISIT(visit_type_node, field); } } void -walk_type_node_variant(struct Visit* visit, struct Type_Node* node) +tree_walk_type_variant(struct Tree_Visit* visit, struct Tree_Type* node) { - FOR_EACH (struct Type_Node*, method, node->value.variant.variants) { + FOR_EACH (struct Tree_Type*, method, node->value.variant.variants) { VISIT(visit_type_node, method); } } void -walk_type_node_class(struct Visit* visit, struct Type_Node* node) +tree_walk_type_class(struct Tree_Visit* visit, struct Tree_Type* node) { - FOR_EACH (struct Type_Node*, method, node->value.class.methods) { + FOR_EACH (struct Tree_Type*, method, node->value.class.methods) { VISIT(visit_type_node, method); } } void -walk_block_node(struct Visit* visit, struct Block_Node* node) +tree_walk_block(struct Tree_Visit* visit, struct Tree_Block* node) { - FOR_EACH (struct Statement*, statement, node->statements) { VISIT(visit_statement, statement); } + FOR_EACH (struct Tree_Statement*, statement, node->statements) { VISIT(visit_statement, statement); } } void -walk_bare_declaration_node(struct Visit* visit, struct Bare_Declaration_Node* node) +tree_walk_bare_declaration(struct Tree_Visit* visit, struct Tree_Bare_Declaration* node) { VISIT_MAYBE(visit_type_node, node->type); VISIT(visit_expression, node->initializer); } void -walk_function_header_node(struct Visit* visit, struct Function_Header_Node* header) +tree_walk_function_header(struct Tree_Visit* visit, struct Tree_Function_Header* header) { - FOR_EACH (struct Type_Node*, param_type, header->parameters_type_and_name) { + FOR_EACH (struct Tree_Type*, param_type, header->parameters_type_and_name) { VISIT(visit_type_node, param_type); } VISIT_MAYBE(visit_type_node, header->return_type); } void -walk_argument_group_node(struct Visit* visit, struct Argument_Group_Node* node) +tree_walk_argument_group(struct Tree_Visit* visit, struct Tree_Argument_Group* node) { - FOR_EACH (struct Expression*, argument, node->arguments) { VISIT(visit_expression, argument); } + FOR_EACH (struct Tree_Expression*, argument, node->arguments) { VISIT(visit_expression, argument); } } void -walk_pragma_node(struct Visit* visit, struct Pragma_Node* node) +tree_walk_pragma(struct Tree_Visit* visit, struct Tree_Pragma* node) { // visit each pragma node in the linked list. VISIT_MAYBE(visit_pragma_node, node->next); } -struct Visit_Table walk_functions = { - .visit_tree = walk_tree, - - .visit_statement = walk_statement, - .visit_statement_declaration = walk_statement_declaration, - .visit_statement_conditional = walk_statement_conditional, - .visit_statement_loop = walk_statement_loop, - .visit_statement_return = walk_statement_return, - .visit_statement_break = walk_statement_break, - .visit_statement_continue = walk_statement_continue, - .visit_statement_defer = walk_statement_defer, - - .visit_expression = walk_expression, - .visit_expression_integer_literal = walk_expression_integer_literal, - .visit_expression_float_literal = walk_expression_float_literal, - .visit_expression_string_literal = walk_expression_string_literal, - .visit_expression_boolean_literal = walk_expression_boolean_literal, - .visit_expression_name = walk_expression_name, - .visit_expression_unary_operation = walk_expression_unary_operation, - .visit_expression_binary_operation = walk_expression_binary_operation, - .visit_expression_group = walk_expression_group, - .visit_expression_call = walk_expression_call, - .visit_expression_construct = walk_expression_construct, - .visit_expression_subscript = walk_expression_subscript, - .visit_expression_member = walk_expression_member, - .visit_expression_increment_decrement = walk_expression_increment_decrement, - .visit_expression_function = walk_expression_function, - - .visit_type_node = walk_type_node, - .visit_type_node_name = walk_type_node_name, - .visit_type_node_array = walk_type_node_array, - .visit_type_node_reference = walk_type_node_reference, - .visit_type_node_maybe = walk_type_node_maybe, - .visit_type_node_tuple = walk_type_node_tuple, - .visit_type_node_map = walk_type_node_map, - .visit_type_node_function = walk_type_node_function, - .visit_type_node_structure = walk_type_node_structure, - .visit_type_node_variant = walk_type_node_variant, - .visit_type_node_class = walk_type_node_class, - - .visit_block_node = walk_block_node, - .visit_bare_declaration_node = walk_bare_declaration_node, - .visit_function_header_node = walk_function_header_node, - .visit_argument_group_node = walk_argument_group_node, - .visit_pragma_node = walk_pragma_node, +struct Tree_Visit_Table tree_walk_functions = { + .visit_tree = tree_walk_tree, + + .visit_statement = tree_walk_statement, + .visit_statement_declaration = tree_walk_statement_declaration, + .visit_statement_conditional = tree_walk_statement_conditional, + .visit_statement_loop = tree_walk_statement_loop, + .visit_statement_return = tree_walk_statement_return, + .visit_statement_break = tree_walk_statement_break, + .visit_statement_continue = tree_walk_statement_continue, + .visit_statement_defer = tree_walk_statement_defer, + + .visit_expression = tree_walk_expression, + .visit_expression_integer_literal = tree_walk_expression_integer_literal, + .visit_expression_float_literal = tree_walk_expression_float_literal, + .visit_expression_string_literal = tree_walk_expression_string_literal, + .visit_expression_boolean_literal = tree_walk_expression_boolean_literal, + .visit_expression_name = tree_walk_expression_name, + .visit_expression_unary_operation = tree_walk_expression_unary_operation, + .visit_expression_binary_operation = tree_walk_expression_binary_operation, + .visit_expression_group = tree_walk_expression_group, + .visit_expression_call = tree_walk_expression_call, + .visit_expression_construct = tree_walk_expression_construct, + .visit_expression_subscript = tree_walk_expression_subscript, + .visit_expression_member = tree_walk_expression_member, + .visit_expression_increment_decrement = tree_walk_expression_increment_decrement, + .visit_expression_function = tree_walk_expression_function, + + .visit_type_node = tree_walk_type, + .visit_type_node_name = tree_walk_type_name, + .visit_type_node_array = tree_walk_type_array, + .visit_type_node_reference = tree_walk_type_reference, + .visit_type_node_maybe = tree_walk_type_maybe, + .visit_type_node_tuple = tree_walk_type_tuple, + .visit_type_node_map = tree_walk_type_map, + .visit_type_node_function = tree_walk_type_function, + .visit_type_node_structure = tree_walk_type_structure, + .visit_type_node_variant = tree_walk_type_variant, + .visit_type_node_class = tree_walk_type_class, + + .visit_block_node = tree_walk_block, + .visit_bare_declaration_node = tree_walk_bare_declaration, + .visit_function_header_node = tree_walk_function_header, + .visit_argument_group_node = tree_walk_argument_group, + .visit_pragma_node = tree_walk_pragma, }; -// fills in the visit table with default walk functions +// fills in the visit table with default tree_walk functions void -visit_table_fill_defaults(struct Visit_Table* table) +tree_visit_table_fill_defaults(struct Tree_Visit_Table* table) { // not portable, nor safe, but sometimes you need to have a bit of fun! :3 // assumptions: - // - sizeof(struct Visit_Table) is a multiple of the size of a function pointer, + // - sizeof(struct Tree_Visit_Table) is a multiple of the size of a function pointer, // with no padding between function pointers. // - the size of a function pointer is the same across all platforms we care about. - // - casting struct Visit_Table to a function pointer array is undefined, but safe. - const uint function_count = sizeof(struct Visit_Table) / sizeof(void (*)()); + // - casting struct Tree_Visit_Table to a function pointer array is undefined, but safe. + const uint function_count = sizeof(struct Tree_Visit_Table) / sizeof(void (*)()); typedef void (*Function_Ptr)(); for (uint fi = 0; fi < function_count; ++fi) { Function_Ptr* function_slot = &((Function_Ptr*)table)[fi]; - Function_Ptr* walk = &((Function_Ptr*)&walk_functions)[fi]; - if (!*function_slot) *function_slot = *walk; + Function_Ptr* tree_walk = &((Function_Ptr*)&tree_walk_functions)[fi]; + if (!*function_slot) *function_slot = *tree_walk; } } @@ -572,33 +572,33 @@ tree_printer_indent(struct Tree_Printer* printer) } void -printer_visit_tree(struct Visit* visit, struct Tree* tree) +tree_printer_visit_tree(struct Tree_Visit* visit, struct Tree* tree) { TREE_PRINTER_PREAMBLE - FOR_EACH (struct Statement*, statement, tree->top_level_statements) { + FOR_EACH (struct Tree_Statement*, statement, tree->top_level_statements) { VISIT(visit_statement, statement); PRINT("\n"); } } void -printer_visit_statement(struct Visit* visit, struct Statement* statement) +tree_printer_visit_statement(struct Tree_Visit* visit, struct Tree_Statement* statement) { TREE_PRINTER_PREAMBLE tree_printer_indent(printer); - walk_statement(visit, statement); + tree_walk_statement(visit, statement); } void -printer_visit_statement_declaration(struct Visit* visit, struct Statement* stmt) +tree_printer_visit_statement_declaration(struct Tree_Visit* visit, struct Tree_Statement* stmt) { TREE_PRINTER_PREAMBLE - if (stmt->value.declaration.kind == STATEMENT_DECLARATION_VARIABLE) + if (stmt->value.declaration.kind == TREE_STATEMENT_DECLARATION_VARIABLE) PRINT("(variable "); - else if (stmt->value.declaration.kind == STATEMENT_DECLARATION_CONSTANT) + else if (stmt->value.declaration.kind == TREE_STATEMENT_DECLARATION_CONSTANT) PRINT("(constant "); VISIT(visit_bare_declaration_node, &stmt->value.declaration.inner); @@ -606,13 +606,13 @@ printer_visit_statement_declaration(struct Visit* visit, struct Statement* stmt) } void -printer_visit_statement_conditional(struct Visit* visit, struct Statement* stmt) +tree_printer_visit_statement_conditional(struct Tree_Visit* visit, struct Tree_Statement* stmt) { TREE_PRINTER_PREAMBLE PRINT("(conditional"); for (uint i = 0; i < stmt->value.conditional.condition_count; ++i) { - const struct Statement_Conditional_Branch* branch = &stmt->value.conditional.conditions[i]; + const struct Tree_Statement_Conditional_Branch* branch = &stmt->value.conditional.conditions[i]; PRINT(" "); if (branch->when) { PRINT("(when "); @@ -621,20 +621,20 @@ printer_visit_statement_conditional(struct Visit* visit, struct Statement* stmt) } else { PRINT("(always) "); } - VISIT(visit_block_node, (struct Block_Node*)&branch->then); + VISIT(visit_block_node, (struct Tree_Block*)&branch->then); } PRINT(")"); } void -printer_visit_statement_loop(struct Visit* visit, struct Statement* stmt) +tree_printer_visit_statement_loop(struct Tree_Visit* visit, struct Tree_Statement* stmt) { TREE_PRINTER_PREAMBLE PRINT("(loop "); switch (stmt->value.loop.style) { - case STATEMENT_LOOP_STYLE_C: + case TREE_STATEMENT_LOOP_STYLE_C: PRINT("c-style "); VISIT(visit_bare_declaration_node, &stmt->value.loop.declaration); PRINT(" (condition "); @@ -643,21 +643,21 @@ printer_visit_statement_loop(struct Visit* visit, struct Statement* stmt) VISIT(visit_expression, stmt->value.loop.iteration); PRINT(") "); break; - case STATEMENT_LOOP_STYLE_FOR_EACH: + case TREE_STATEMENT_LOOP_STYLE_FOR_EACH: PRINT("for-each "); VISIT(visit_bare_declaration_node, &stmt->value.loop.declaration); PRINT(" "); break; - case STATEMENT_LOOP_STYLE_WHILE: + case TREE_STATEMENT_LOOP_STYLE_WHILE: PRINT("while (condition "); VISIT(visit_expression, stmt->value.loop.condition); PRINT(") "); break; - case STATEMENT_LOOP_STYLE_ENDLESS: + case TREE_STATEMENT_LOOP_STYLE_ENDLESS: PRINT("endless "); break; default: - fprintf(stderr, "unexpected loop style in `printer_visit_statement_loop`"); + fprintf(stderr, "unexpected loop style in `tree_printer_visit_statement_loop`"); break; } @@ -666,7 +666,7 @@ printer_visit_statement_loop(struct Visit* visit, struct Statement* stmt) } void -printer_visit_statement_return(struct Visit* visit, struct Statement* stmt) +tree_printer_visit_statement_return(struct Tree_Visit* visit, struct Tree_Statement* stmt) { TREE_PRINTER_PREAMBLE @@ -679,7 +679,7 @@ printer_visit_statement_return(struct Visit* visit, struct Statement* stmt) } void -printer_visit_statement_break(struct Visit* visit, struct Statement* stmt) +tree_printer_visit_statement_break(struct Tree_Visit* visit, struct Tree_Statement* stmt) { TREE_PRINTER_PREAMBLE @@ -687,7 +687,7 @@ printer_visit_statement_break(struct Visit* visit, struct Statement* stmt) } void -printer_visit_statement_continue(struct Visit* visit, struct Statement* stmt) +tree_printer_visit_statement_continue(struct Tree_Visit* visit, struct Tree_Statement* stmt) { TREE_PRINTER_PREAMBLE @@ -695,7 +695,7 @@ printer_visit_statement_continue(struct Visit* visit, struct Statement* stmt) } void -printer_visit_statement_defer(struct Visit* visit, struct Statement* stmt) +tree_printer_visit_statement_defer(struct Tree_Visit* visit, struct Tree_Statement* stmt) { TREE_PRINTER_PREAMBLE @@ -709,16 +709,16 @@ printer_visit_statement_defer(struct Visit* visit, struct Statement* stmt) } void -printer_visit_expression(struct Visit* visit, struct Expression* expression) +tree_printer_visit_expression(struct Tree_Visit* visit, struct Tree_Expression* expression) { TREE_PRINTER_PREAMBLE PRINT("(expr "); - walk_expression(visit, expression); + tree_walk_expression(visit, expression); PRINT(")"); } void -printer_visit_expression_integer_literal(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_integer_literal(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE @@ -726,7 +726,7 @@ printer_visit_expression_integer_literal(struct Visit* visit, struct Expression* } void -printer_visit_expression_float_literal(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_float_literal(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE @@ -734,7 +734,7 @@ printer_visit_expression_float_literal(struct Visit* visit, struct Expression* e } void -printer_visit_expression_string_literal(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_string_literal(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE @@ -742,7 +742,7 @@ printer_visit_expression_string_literal(struct Visit* visit, struct Expression* } void -printer_visit_expression_boolean_literal(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_boolean_literal(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE @@ -750,7 +750,7 @@ printer_visit_expression_boolean_literal(struct Visit* visit, struct Expression* } void -printer_visit_expression_name(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_name(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE @@ -758,7 +758,7 @@ printer_visit_expression_name(struct Visit* visit, struct Expression* expr) } void -printer_visit_expression_unary_operation(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_unary_operation(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE @@ -768,7 +768,7 @@ printer_visit_expression_unary_operation(struct Visit* visit, struct Expression* } void -printer_visit_expression_binary_operation(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_binary_operation(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE @@ -780,7 +780,7 @@ printer_visit_expression_binary_operation(struct Visit* visit, struct Expression } void -printer_visit_expression_group(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_group(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE @@ -790,11 +790,11 @@ printer_visit_expression_group(struct Visit* visit, struct Expression* expr) } void -printer_visit_expression_call(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_call(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE - struct Expression_Call* call = &expr->value.call; + struct Tree_Expression_Call* call = &expr->value.call; PRINT("(call "); VISIT(visit_expression, call->subject); VISIT(visit_argument_group_node, &call->argument_group); @@ -803,11 +803,11 @@ printer_visit_expression_call(struct Visit* visit, struct Expression* expr) } void -printer_visit_expression_construct(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_construct(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE - struct Expression_Construct* construct = &expr->value.construct; + struct Tree_Expression_Construct* construct = &expr->value.construct; PRINT("(construct "); VISIT(visit_expression, construct->subject); VISIT(visit_argument_group_node, &construct->argument_group); @@ -816,7 +816,7 @@ printer_visit_expression_construct(struct Visit* visit, struct Expression* expr) } void -printer_visit_expression_subscript(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_subscript(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE @@ -828,7 +828,7 @@ printer_visit_expression_subscript(struct Visit* visit, struct Expression* expr) } void -printer_visit_expression_member(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_member(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE @@ -838,11 +838,11 @@ printer_visit_expression_member(struct Visit* visit, struct Expression* expr) } void -printer_visit_expression_increment_decrement(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_increment_decrement(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE - const struct Expression_Increment_Decrement* inc_dec = &expr->value.increment_decrement; + const struct Tree_Expression_Increment_Decrement* inc_dec = &expr->value.increment_decrement; const ascii* prefix_or_postfix = inc_dec->prefix ? "prefix" : "postfix"; PRINT("(increment/decrement %s %s ", increment_decrement_operation_to_string(inc_dec->operation), prefix_or_postfix); @@ -851,7 +851,7 @@ printer_visit_expression_increment_decrement(struct Visit* visit, struct Express } void -printer_visit_expression_try(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_try(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE @@ -861,7 +861,7 @@ printer_visit_expression_try(struct Visit* visit, struct Expression* expr) } void -printer_visit_expression_must(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_must(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE @@ -871,30 +871,30 @@ printer_visit_expression_must(struct Visit* visit, struct Expression* expr) } void -printer_visit_expression_function(struct Visit* visit, struct Expression* expr) +tree_printer_visit_expression_function(struct Tree_Visit* visit, struct Tree_Expression* expr) { TREE_PRINTER_PREAMBLE - struct Expression_Function* fun = &expr->value.function; + struct Tree_Expression_Function* fun = &expr->value.function; PRINT("(function "); VISIT(visit_function_header_node, &fun->header); PRINT_WHITESPACE_IF_NEEDED(" "); - VISIT(visit_block_node, (struct Block_Node*)&fun->body); + VISIT(visit_block_node, (struct Tree_Block*)&fun->body); PRINT(")"); } void -printer_visit_type_node(struct Visit* visit, struct Type_Node* node) +tree_printer_visit_type(struct Tree_Visit* visit, struct Tree_Type* node) { TREE_PRINTER_PREAMBLE PRINT("(type "); if (node->variadic) PRINT("variadic "); - walk_type_node(visit, node); + tree_walk_type(visit, node); PRINT(")"); } void -printer_visit_type_node_name(struct Visit* visit, struct Type_Node* node) +tree_printer_visit_type_name(struct Tree_Visit* visit, struct Tree_Type* node) { TREE_PRINTER_PREAMBLE @@ -902,7 +902,7 @@ printer_visit_type_node_name(struct Visit* visit, struct Type_Node* node) } void -printer_visit_type_node_array(struct Visit* visit, struct Type_Node* node) +tree_printer_visit_type_array(struct Tree_Visit* visit, struct Tree_Type* node) { TREE_PRINTER_PREAMBLE @@ -911,7 +911,7 @@ printer_visit_type_node_array(struct Visit* visit, struct Type_Node* node) } void -printer_visit_type_node_reference(struct Visit* visit, struct Type_Node* node) +tree_printer_visit_type_reference(struct Tree_Visit* visit, struct Tree_Type* node) { TREE_PRINTER_PREAMBLE @@ -920,7 +920,7 @@ printer_visit_type_node_reference(struct Visit* visit, struct Type_Node* node) } void -printer_visit_type_node_maybe(struct Visit* visit, struct Type_Node* node) +tree_printer_visit_type_maybe(struct Tree_Visit* visit, struct Tree_Type* node) { TREE_PRINTER_PREAMBLE @@ -929,19 +929,19 @@ printer_visit_type_node_maybe(struct Visit* visit, struct Type_Node* node) } void -printer_visit_type_node_tuple(struct Visit* visit, struct Type_Node* node) +tree_printer_visit_type_tuple(struct Tree_Visit* visit, struct Tree_Type* node) { TREE_PRINTER_PREAMBLE PRINT("tuple"); - FOR_EACH (struct Type_Node*, current, node->value.tuple.head) { + FOR_EACH (struct Tree_Type*, current, node->value.tuple.head) { PRINT(" "); VISIT(visit_type_node, current); } } void -printer_visit_type_node_map(struct Visit* visit, struct Type_Node* node) +tree_printer_visit_type_map(struct Tree_Visit* visit, struct Tree_Type* node) { TREE_PRINTER_PREAMBLE @@ -952,7 +952,7 @@ printer_visit_type_node_map(struct Visit* visit, struct Type_Node* node) } void -printer_visit_type_node_function(struct Visit* visit, struct Type_Node* node) +tree_printer_visit_type_function(struct Tree_Visit* visit, struct Tree_Type* node) { TREE_PRINTER_PREAMBLE @@ -961,25 +961,25 @@ printer_visit_type_node_function(struct Visit* visit, struct Type_Node* node) } void -printer_visit_type_node_structure(struct Visit* visit, struct Type_Node* node) +tree_printer_visit_type_structure(struct Tree_Visit* visit, struct Tree_Type* node) { TREE_PRINTER_PREAMBLE PRINT("structure"); - FOR_EACH (struct Type_Node*, current, node->value.structure.fields) { + FOR_EACH (struct Tree_Type*, current, node->value.structure.fields) { PRINT(" (field %s) ", current->value_name.data); VISIT(visit_type_node, current); } } void -printer_visit_type_node_variant(struct Visit* visit, struct Type_Node* node) +tree_printer_visit_type_variant(struct Tree_Visit* visit, struct Tree_Type* node) { TREE_PRINTER_PREAMBLE PRINT("variant"); - FOR_EACH (struct Type_Node*, current, node->value.variant.variants) { - if (current->type == TYPE_NODE_NONE) { + FOR_EACH (struct Tree_Type*, current, node->value.variant.variants) { + if (current->type == TREE_TYPE_NONE) { PRINT(" (variant %s)", current->value_name.data); } else { PRINT(" (variant %s of ", current->value_name.data); @@ -990,12 +990,12 @@ printer_visit_type_node_variant(struct Visit* visit, struct Type_Node* node) } void -printer_visit_type_node_class(struct Visit* visit, struct Type_Node* node) +tree_printer_visit_type_class(struct Tree_Visit* visit, struct Tree_Type* node) { TREE_PRINTER_PREAMBLE PRINT("class"); - FOR_EACH (struct Type_Node*, current, node->value.class.methods) { + FOR_EACH (struct Tree_Type*, current, node->value.class.methods) { PRINT(" (method %s ", current->value_name.data); VISIT(visit_function_header_node, ¤t->value.function.header); PRINT(")"); @@ -1003,7 +1003,7 @@ printer_visit_type_node_class(struct Visit* visit, struct Type_Node* node) } void -printer_visit_block_node(struct Visit* visit, struct Block_Node* node) +tree_printer_visit_block(struct Tree_Visit* visit, struct Tree_Block* node) { TREE_PRINTER_PREAMBLE @@ -1011,7 +1011,7 @@ printer_visit_block_node(struct Visit* visit, struct Block_Node* node) if (node->statements) { PRINT("\n"); printer->indentation_level++; - FOR_EACH (struct Statement*, statement, node->statements) { + FOR_EACH (struct Tree_Statement*, statement, node->statements) { VISIT(visit_statement, statement); PRINT("\n"); } @@ -1022,7 +1022,7 @@ printer_visit_block_node(struct Visit* visit, struct Block_Node* node) } void -printer_visit_bare_declaration_node(struct Visit* visit, struct Bare_Declaration_Node* node) +tree_printer_visit_bare_declaration(struct Tree_Visit* visit, struct Tree_Bare_Declaration* node) { TREE_PRINTER_PREAMBLE @@ -1031,7 +1031,7 @@ printer_visit_bare_declaration_node(struct Visit* visit, struct Bare_Declaration PRINT("%s ", name.data); }) - if (node->type && node->type->type != TYPE_NODE_NONE) { + if (node->type && node->type->type != TREE_TYPE_NONE) { VISIT(visit_type_node, node->type); PRINT(" "); } @@ -1045,11 +1045,11 @@ printer_visit_bare_declaration_node(struct Visit* visit, struct Bare_Declaration } void -printer_visit_function_header(struct Visit* visit, struct Function_Header_Node* header) +printer_visit_function_header(struct Tree_Visit* visit, struct Tree_Function_Header* header) { TREE_PRINTER_PREAMBLE - FOR_EACH (struct Type_Node*, current, header->parameters_type_and_name) { + FOR_EACH (struct Tree_Type*, current, header->parameters_type_and_name) { // if (current != header->parameters_type_and_name) PRINT(" "); PRINT_WHITESPACE_IF_NEEDED(" "); @@ -1071,27 +1071,27 @@ printer_visit_function_header(struct Visit* visit, struct Function_Header_Node* } void -printer_visit_pragma_node(struct Visit* visit, struct Pragma_Node* node) +tree_printer_visit_pragma(struct Tree_Visit* visit, struct Tree_Pragma* node) { TREE_PRINTER_PREAMBLE - const ascii* pragma_name = pragma_type_to_string(node->type); + const ascii* pragma_name = tree_pragma_type_to_string(node->type); PRINT("(pragma %s", pragma_name); for (uint ai = 0; ai < node->argument_count; ++ai) { - struct Pragma_Argument* arg = &node->arguments[ai]; + struct Tree_Pragma_Argument* arg = &node->arguments[ai]; switch (arg->type) { - case PRAGMA_ARGUMENT_NUMBER: + case TREE_PRAGMA_ARGUMENT_NUMBER: PRINT(" (number %ld)", arg->value.number); break; - case PRAGMA_ARGUMENT_DECIMAL: + case TREE_PRAGMA_ARGUMENT_DECIMAL: PRINT(" (decimal %lf)", arg->value.decimal); break; - case PRAGMA_ARGUMENT_NAME_OR_STRING: + case TREE_PRAGMA_ARGUMENT_NAME_OR_STRING: PRINT(" (name/string '%s')", arg->value.name_or_string.data); break; default: - failure("unexpected pragma argument type in `printer_visit_pragma_node`"); + failure("unexpected pragma argument type in `tree_printer_visit_pragma`"); } } PRINT(")"); @@ -1103,12 +1103,12 @@ printer_visit_pragma_node(struct Visit* visit, struct Pragma_Node* node) } void -printer_visit_argument_group_node(struct Visit* visit, struct Argument_Group_Node* node) +tree_printer_visit_argument_group(struct Tree_Visit* visit, struct Tree_Argument_Group* node) { TREE_PRINTER_PREAMBLE uint i = 0; - FOR_EACH (struct Expression*, argument, node->arguments) { + FOR_EACH (struct Tree_Expression*, argument, node->arguments) { struct String name = *array_at(struct String, &node->argument_names, i++); if (name.data && name.data[0] != '\0') { PRINT(" (named arg '%s' ", name.data); @@ -1120,53 +1120,53 @@ printer_visit_argument_group_node(struct Visit* visit, struct Argument_Group_Nod } } -struct Visit_Table printer_visit_functions = { - .visit_tree = printer_visit_tree, - - .visit_statement = printer_visit_statement, - .visit_statement_declaration = printer_visit_statement_declaration, - .visit_statement_conditional = printer_visit_statement_conditional, - .visit_statement_loop = printer_visit_statement_loop, - .visit_statement_return = printer_visit_statement_return, - .visit_statement_break = printer_visit_statement_break, - .visit_statement_continue = printer_visit_statement_continue, - .visit_statement_defer = printer_visit_statement_defer, - - .visit_expression = printer_visit_expression, - .visit_expression_integer_literal = printer_visit_expression_integer_literal, - .visit_expression_float_literal = printer_visit_expression_float_literal, - .visit_expression_string_literal = printer_visit_expression_string_literal, - .visit_expression_boolean_literal = printer_visit_expression_boolean_literal, - .visit_expression_name = printer_visit_expression_name, - .visit_expression_unary_operation = printer_visit_expression_unary_operation, - .visit_expression_binary_operation = printer_visit_expression_binary_operation, - .visit_expression_group = printer_visit_expression_group, - .visit_expression_call = printer_visit_expression_call, - .visit_expression_construct = printer_visit_expression_construct, - .visit_expression_subscript = printer_visit_expression_subscript, - .visit_expression_member = printer_visit_expression_member, - .visit_expression_increment_decrement = printer_visit_expression_increment_decrement, - .visit_expression_try = printer_visit_expression_try, - .visit_expression_must = printer_visit_expression_must, - .visit_expression_function = printer_visit_expression_function, - - .visit_type_node = printer_visit_type_node, - .visit_type_node_name = printer_visit_type_node_name, - .visit_type_node_array = printer_visit_type_node_array, - .visit_type_node_reference = printer_visit_type_node_reference, - .visit_type_node_maybe = printer_visit_type_node_maybe, - .visit_type_node_tuple = printer_visit_type_node_tuple, - .visit_type_node_map = printer_visit_type_node_map, - .visit_type_node_function = printer_visit_type_node_function, - .visit_type_node_structure = printer_visit_type_node_structure, - .visit_type_node_variant = printer_visit_type_node_variant, - .visit_type_node_class = printer_visit_type_node_class, - - .visit_block_node = printer_visit_block_node, - .visit_bare_declaration_node = printer_visit_bare_declaration_node, +struct Tree_Visit_Table tree_printer_visit_functions = { + .visit_tree = tree_printer_visit_tree, + + .visit_statement = tree_printer_visit_statement, + .visit_statement_declaration = tree_printer_visit_statement_declaration, + .visit_statement_conditional = tree_printer_visit_statement_conditional, + .visit_statement_loop = tree_printer_visit_statement_loop, + .visit_statement_return = tree_printer_visit_statement_return, + .visit_statement_break = tree_printer_visit_statement_break, + .visit_statement_continue = tree_printer_visit_statement_continue, + .visit_statement_defer = tree_printer_visit_statement_defer, + + .visit_expression = tree_printer_visit_expression, + .visit_expression_integer_literal = tree_printer_visit_expression_integer_literal, + .visit_expression_float_literal = tree_printer_visit_expression_float_literal, + .visit_expression_string_literal = tree_printer_visit_expression_string_literal, + .visit_expression_boolean_literal = tree_printer_visit_expression_boolean_literal, + .visit_expression_name = tree_printer_visit_expression_name, + .visit_expression_unary_operation = tree_printer_visit_expression_unary_operation, + .visit_expression_binary_operation = tree_printer_visit_expression_binary_operation, + .visit_expression_group = tree_printer_visit_expression_group, + .visit_expression_call = tree_printer_visit_expression_call, + .visit_expression_construct = tree_printer_visit_expression_construct, + .visit_expression_subscript = tree_printer_visit_expression_subscript, + .visit_expression_member = tree_printer_visit_expression_member, + .visit_expression_increment_decrement = tree_printer_visit_expression_increment_decrement, + .visit_expression_try = tree_printer_visit_expression_try, + .visit_expression_must = tree_printer_visit_expression_must, + .visit_expression_function = tree_printer_visit_expression_function, + + .visit_type_node = tree_printer_visit_type, + .visit_type_node_name = tree_printer_visit_type_name, + .visit_type_node_array = tree_printer_visit_type_array, + .visit_type_node_reference = tree_printer_visit_type_reference, + .visit_type_node_maybe = tree_printer_visit_type_maybe, + .visit_type_node_tuple = tree_printer_visit_type_tuple, + .visit_type_node_map = tree_printer_visit_type_map, + .visit_type_node_function = tree_printer_visit_type_function, + .visit_type_node_structure = tree_printer_visit_type_structure, + .visit_type_node_variant = tree_printer_visit_type_variant, + .visit_type_node_class = tree_printer_visit_type_class, + + .visit_block_node = tree_printer_visit_block, + .visit_bare_declaration_node = tree_printer_visit_bare_declaration, .visit_function_header_node = printer_visit_function_header, - .visit_argument_group_node = printer_visit_argument_group_node, - .visit_pragma_node = printer_visit_pragma_node, + .visit_argument_group_node = tree_printer_visit_argument_group, + .visit_pragma_node = tree_printer_visit_pragma, }; void @@ -1175,9 +1175,9 @@ tree_printer(struct Tree* tree) struct Tree_Printer printer = { .indentation_level = 0, .output = stdout, .did_print_last_visit = false }; - struct Visit visit = { .table = &printer_visit_functions, .user_data = &printer }; + struct Tree_Visit visit = { .table = &tree_printer_visit_functions, .user_data = &printer }; - walk(&visit, tree); + tree_walk(&visit, tree); } #undef PRINT |