Rename tree nodes to add consistent prefix, de-node, clean-up names

Signed-off-by: Mel <mel@rnrd.eu>

1 files changed, 58 insertions, 58 deletions

diff --git a/boot/transpile.c b/boot/transpile.c
index 05aa5c4..798be85 100644
--- a/boot/transpile.c
+++ b/boot/transpile.c
@@ -130,17 +130,17 @@ transpiler_new(struct Transpiler* transpiler, struct Transpile_Output output)
 }
 
 void
-transpiler_visit_type_node(struct Visit* visit, struct Type_Node* node)
+transpiler_visit_type_node(struct Tree_Visit* visit, struct Tree_Type* node)
 {
     TRANSPILER_PREAMBLE
 
-    if (!node || node->type == TYPE_NODE_NONE) {
+    if (!node || node->type == TREE_TYPE_NONE) {
         TRANSPILE_WRITE("void");
         return;
     }
 
     switch (node->type) {
-    case TYPE_NODE_NAME: {
+    case TREE_TYPE_NAME: {
         struct String name = node->value.name.name;
         if (strcmp(name.data, "int") == 0) {
             TRANSPILE_WRITE("integer");
@@ -168,12 +168,12 @@ transpiler_visit_type_node(struct Visit* visit, struct Type_Node* node)
 }
 
 void
-transpiler_visit_function_header_node(struct Visit* visit, struct Function_Header_Node* header)
+transpiler_visit_function_header_node(struct Tree_Visit* visit, struct Tree_Function_Header* header)
 {
     TRANSPILER_PREAMBLE
 
     TRANSPILE_WRITE("(");
-    struct Type_Node* param = header->parameters_type_and_name;
+    struct Tree_Type* param = header->parameters_type_and_name;
     if (!param) {
         TRANSPILE_WRITE("void");
     } else {
@@ -190,21 +190,21 @@ transpiler_visit_function_header_node(struct Visit* visit, struct Function_Heade
 }
 
 void
-transpiler_visit_block_node(struct Visit* visit, struct Block_Node* node)
+transpiler_visit_block_node(struct Tree_Visit* visit, struct Tree_Block* node)
 {
     TRANSPILER_PREAMBLE
 
     TRANSPILE_WRITE("{\n");
-    FOR_EACH (struct Statement*, statement, node->statements) { VISIT(visit_statement, statement); }
+    FOR_EACH (struct Tree_Statement*, statement, node->statements) { VISIT(visit_statement, statement); }
     TRANSPILE_WRITE("}\n");
 }
 
 void
-transpiler_visit_argument_group_node(struct Visit* visit, struct Argument_Group_Node* node)
+transpiler_visit_argument_group_node(struct Tree_Visit* visit, struct Tree_Argument_Group* node)
 {
     TRANSPILER_PREAMBLE
 
-    struct Expression* arg = node->arguments;
+    struct Tree_Expression* arg = node->arguments;
     bool first = true;
     while (arg) {
         if (!first) { TRANSPILE_WRITE(", "); }
@@ -215,16 +215,16 @@ transpiler_visit_argument_group_node(struct Visit* visit, struct Argument_Group_
 }
 
 void
-transpiler_visit_statement_declaration(struct Visit* visit, struct Statement* stmt)
+transpiler_visit_statement_declaration(struct Tree_Visit* visit, struct Tree_Statement* stmt)
 {
     TRANSPILER_PREAMBLE
 
-    struct Statement_Value_Declaration* declaration = &stmt->value.declaration;
-    struct Expression* initializer = declaration->inner.initializer;
+    struct Tree_Statement_Value_Declaration* declaration = &stmt->value.declaration;
+    struct Tree_Expression* initializer = declaration->inner.initializer;
 
-    if (initializer && initializer->kind == EXPRESSION_FUNCTION) {
-        struct Expression_Function* fun = &initializer->value.function;
-        struct Function_Header_Node* header = &fun->header;
+    if (initializer && initializer->kind == TREE_EXPRESSION_FUNCTION) {
+        struct Tree_Expression_Function* fun = &initializer->value.function;
+        struct Tree_Function_Header* header = &fun->header;
 
         VISIT(visit_type_node, header->return_type);
         struct String name = *array_at(struct String, &declaration->inner.names, 0);
@@ -233,7 +233,7 @@ transpiler_visit_statement_declaration(struct Visit* visit, struct Statement* st
         TRANSPILE_WRITE(" ");
         VISIT(visit_block_node, &fun->body);
     } else {
-        if (declaration->kind == STATEMENT_DECLARATION_CONSTANT) {
+        if (declaration->kind == TREE_STATEMENT_DECLARATION_CONSTANT) {
             TRANSPILE_WRITE("const ");
         }
         VISIT(visit_type_node, declaration->inner.type);
@@ -247,7 +247,7 @@ transpiler_visit_statement_declaration(struct Visit* visit, struct Statement* st
 }
 
 void
-transpiler_visit_statement_return(struct Visit* visit, struct Statement* stmt)
+transpiler_visit_statement_return(struct Tree_Visit* visit, struct Tree_Statement* stmt)
 {
     TRANSPILER_PREAMBLE
 
@@ -259,13 +259,13 @@ transpiler_visit_statement_return(struct Visit* visit, struct Statement* stmt)
 }
 
 void
-transpiler_visit_statement_conditional(struct Visit* visit, struct Statement* stmt)
+transpiler_visit_statement_conditional(struct Tree_Visit* visit, struct Tree_Statement* stmt)
 {
     TRANSPILER_PREAMBLE
 
-    struct Statement_Value_Conditional* conditional = &stmt->value.conditional;
+    struct Tree_Statement_Value_Conditional* conditional = &stmt->value.conditional;
     for (uint i = 0; i < conditional->condition_count; ++i) {
-        struct Statement_Conditional_Branch* branch = &conditional->conditions[i];
+        struct Tree_Statement_Conditional_Branch* branch = &conditional->conditions[i];
         if (i > 0) { TRANSPILE_WRITE("else "); }
         if (branch->when) {
             TRANSPILE_WRITE("if (");
@@ -277,34 +277,34 @@ transpiler_visit_statement_conditional(struct Visit* visit, struct Statement* st
 }
 
 void
-transpiler_visit_statement(struct Visit* visit, struct Statement* statement)
+transpiler_visit_statement(struct Tree_Visit* visit, struct Tree_Statement* statement)
 {
     TRANSPILER_PREAMBLE
 
     switch (statement->kind) {
-    case STATEMENT_EXPRESSION:
+    case TREE_STATEMENT_EXPRESSION:
         VISIT(visit_expression, statement->value.expression.inner);
         if (transpiler->context.in_function) TRANSPILE_WRITE(";\n");
         break;
-    case STATEMENT_DECLARATION:
+    case TREE_STATEMENT_DECLARATION:
         VISIT(visit_statement_declaration, statement);
         if (transpiler->context.in_function) TRANSPILE_WRITE(";\n");
         break;
-    case STATEMENT_RETURN:
+    case TREE_STATEMENT_RETURN:
         VISIT(visit_statement_return, statement);
         if (transpiler->context.in_function) TRANSPILE_WRITE(";\n");
         break;
-    case STATEMENT_BLOCK:
+    case TREE_STATEMENT_BLOCK:
         VISIT(visit_block_node, &statement->value.block.inner);
         break;
     default:
-        walk_statement(visit, statement);
+        tree_walk_statement(visit, statement);
         break;
     }
 }
 
 void
-transpiler_visit_expression_integer_literal(struct Visit* visit, struct Expression* expr)
+transpiler_visit_expression_integer_literal(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TRANSPILER_PREAMBLE
 
@@ -312,7 +312,7 @@ transpiler_visit_expression_integer_literal(struct Visit* visit, struct Expressi
 }
 
 void
-transpiler_visit_expression_float_literal(struct Visit* visit, struct Expression* expr)
+transpiler_visit_expression_float_literal(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TRANSPILER_PREAMBLE
 
@@ -320,7 +320,7 @@ transpiler_visit_expression_float_literal(struct Visit* visit, struct Expression
 }
 
 void
-transpiler_visit_expression_string_literal(struct Visit* visit, struct Expression* expr)
+transpiler_visit_expression_string_literal(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TRANSPILER_PREAMBLE
 
@@ -329,7 +329,7 @@ transpiler_visit_expression_string_literal(struct Visit* visit, struct Expressio
 }
 
 void
-transpiler_visit_expression_boolean_literal(struct Visit* visit, struct Expression* expr)
+transpiler_visit_expression_boolean_literal(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TRANSPILER_PREAMBLE
 
@@ -337,7 +337,7 @@ transpiler_visit_expression_boolean_literal(struct Visit* visit, struct Expressi
 }
 
 void
-transpiler_visit_expression_name(struct Visit* visit, struct Expression* expr)
+transpiler_visit_expression_name(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TRANSPILER_PREAMBLE
 
@@ -345,7 +345,7 @@ transpiler_visit_expression_name(struct Visit* visit, struct Expression* expr)
 }
 
 void
-transpiler_visit_expression_unary_operation(struct Visit* visit, struct Expression* expr)
+transpiler_visit_expression_unary_operation(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TRANSPILER_PREAMBLE
 
@@ -355,23 +355,23 @@ transpiler_visit_expression_unary_operation(struct Visit* visit, struct Expressi
 }
 
 void
-transpiler_visit_expression_binary_operation(struct Visit* visit, struct Expression* expr)
+transpiler_visit_expression_binary_operation(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TRANSPILER_PREAMBLE
-    struct Expression_Binary_Operator* bin_op = &expr->value.binary_operator;
+    struct Tree_Expression_Binary_Operator* bin_op = &expr->value.binary_operator;
 
-    if (bin_op->operation == BINARY_ASSIGN && bin_op->right_operand->kind == EXPRESSION_FUNCTION) {
-        struct Expression* fun_expr = bin_op->right_operand;
-        struct Expression_Function* fun = &fun_expr->value.function;
-        struct Function_Header_Node* header = &fun->header;
-        struct Expression* name_expr = bin_op->left_operand;
+    if (bin_op->operation == BINARY_ASSIGN && bin_op->right_operand->kind == TREE_EXPRESSION_FUNCTION) {
+        struct Tree_Expression* fun_expr = bin_op->right_operand;
+        struct Tree_Expression_Function* fun = &fun_expr->value.function;
+        struct Tree_Function_Header* header = &fun->header;
+        struct Tree_Expression* name_expr = bin_op->left_operand;
 
         VISIT(visit_type_node, header->return_type);
         TRANSPILE_WRITE(" ");
 
         // check if this is a main function assignment
-        if (name_expr && name_expr->kind == EXPRESSION_NAME) {
-            struct Expression_Name* name = &name_expr->value.name;
+        if (name_expr && name_expr->kind == TREE_EXPRESSION_NAME) {
+            struct Tree_Expression_Name* name = &name_expr->value.name;
             if (string_equals_c_str(name->name, "main")) {
                 transpiler->context.main_function_found = true;
                 transpiler->context.main_function_takes_args =
@@ -413,7 +413,7 @@ transpiler_visit_expression_binary_operation(struct Visit* visit, struct Express
 }
 
 void
-transpiler_visit_expression_call(struct Visit* visit, struct Expression* expr)
+transpiler_visit_expression_call(struct Tree_Visit* visit, struct Tree_Expression* expr)
 {
     TRANSPILER_PREAMBLE
 
@@ -424,43 +424,43 @@ transpiler_visit_expression_call(struct Visit* visit, struct Expression* expr)
 }
 
 void
-transpiler_visit_expression(struct Visit* visit, struct Expression* expression)
+transpiler_visit_expression(struct Tree_Visit* visit, struct Tree_Expression* expression)
 {
     TRANSPILER_PREAMBLE
 
     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_CALL:
+    case TREE_EXPRESSION_CALL:
         VISIT(visit_expression_call, expression);
         break;
     default:
-        walk_expression(visit, expression);
+        tree_walk_expression(visit, expression);
         break;
     }
 }
 
 void
-transpiler_visit_tree(struct Visit* visit, struct Tree* tree)
+transpiler_visit_tree(struct Tree_Visit* visit, struct Tree* tree)
 {
     TRANSPILER_PREAMBLE
 
@@ -475,7 +475,7 @@ transpiler_visit_tree(struct Visit* visit, struct Tree* tree)
     // this executable and then write them out into the temporary build directory.
     TRANSPILE_WRITE("#include \"core.c\"\n");
 
-    FOR_EACH (struct Statement*, statement, tree->top_level_statements) {
+    FOR_EACH (struct Tree_Statement*, statement, tree->top_level_statements) {
         VISIT(visit_statement, statement);
     }
 
@@ -490,7 +490,7 @@ transpiler_visit_tree(struct Visit* visit, struct Tree* tree)
     }
 }
 
-struct Visit_Table transpiler_visit_functions = {
+struct Tree_Visit_Table transpiler_visit_functions = {
     .visit_tree = transpiler_visit_tree,
     .visit_statement = transpiler_visit_statement,
     .visit_statement_declaration = transpiler_visit_statement_declaration,
@@ -514,10 +514,10 @@ struct Visit_Table transpiler_visit_functions = {
 int
 transpiler_catskill_to_c(struct Transpiler* transpiler, struct Tree* tree)
 {
-    struct Visit visit = { .table = &transpiler_visit_functions, .user_data = transpiler };
-    visit_table_fill_defaults(visit.table);
+    struct Tree_Visit visit = { .table = &transpiler_visit_functions, .user_data = transpiler };
+    tree_visit_table_fill_defaults(visit.table);
 
-    walk(&visit, tree);
+    tree_walk(&visit, tree);
 
     return 0;
 }