Add rudimentary catskill-to-C transpiler (yay!)

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

1 files changed, 417 insertions, 0 deletions

diff --git a/boot/transpile.c b/boot/transpile.c
new file mode 100644
index 0000000..bebcbbc
--- /dev/null
+++ b/boot/transpile.c
@@ -0,0 +1,417 @@
+/*
+ * transpiler from catskill to the c programming language.
+ * takes a direct catskill syntax tree and produces a c source file,
+ * without an intermediate representation.
+ *
+ * Copyright (c) 2025, Mel G. <mel@rnrd.eu>
+ *
+ * SPDX-License-Identifier: MPL-2.0
+ */
+
+#pragma once
+
+#include "catboot.h"
+#include "visit.c"
+#include <stdio.h>
+
+struct Transpile_Context
+{
+    bool in_function;
+    struct String function_name;
+    struct String function_return_type;
+};
+
+#define CONTEXT_START(name)        \
+    context = transpiler->context; \
+    transpiler->context.name = true;
+
+#define CONTEXT_END(name) transpiler->context.name = context.name;
+
+struct Transpiler
+{
+    FILE* output;
+    struct Transpile_Context context;
+};
+
+#define TRANSPILER_PREAMBLE                                 \
+    DATA_FOR_VISIT(struct Transpiler, transpiler)           \
+    struct Transpile_Context context = transpiler->context; \
+    (void)context;
+
+void
+transpiler_new(struct Transpiler* transpiler, FILE* output)
+{
+    *transpiler = (struct Transpiler){
+        .output = output,
+        .context = {
+            .in_function = false,
+            .function_name = string_empty(),
+            .function_return_type = string_empty(),
+        },
+    };
+}
+
+void
+transpiler_visit_type_node(struct Visit* visit, struct Type_Node* node)
+{
+    TRANSPILER_PREAMBLE
+
+    if (!node || node->type == TYPE_NODE_NONE) {
+        fprintf(transpiler->output, "void");
+        return;
+    }
+
+    switch (node->type) {
+    case TYPE_NODE_NAME: {
+        struct String name = node->value.name.name;
+        if (strcmp(name.data, "int") == 0) {
+            fprintf(transpiler->output, "int64_t");
+        } else if (strcmp(name.data, "string") == 0) {
+            fprintf(transpiler->output, "const char*");
+        } else if (strcmp(name.data, "bool") == 0) {
+            fprintf(transpiler->output, "bool");
+        } else if (strcmp(name.data, "float") == 0) {
+            fprintf(transpiler->output, "double");
+        } else {
+            fprintf(transpiler->output, "%.*s", (int)name.length, name.data);
+        }
+        break;
+    }
+    default:
+        fprintf(transpiler->output, "/* unknown type %d */", node->type);
+        break;
+    }
+}
+
+void
+transpiler_visit_function_header_node(struct Visit* visit, struct Function_Header_Node* header)
+{
+    TRANSPILER_PREAMBLE
+
+    fprintf(transpiler->output, "(");
+    struct Type_Node* param = header->parameters_type_and_name;
+    if (!param) {
+        fprintf(transpiler->output, "void");
+    } else {
+        bool first = true;
+        while (param) {
+            if (!first) { fprintf(transpiler->output, ", "); }
+            VISIT(visit_type_node, param);
+            fprintf(
+                transpiler->output, " %.*s", (int)param->value_name.length, param->value_name.data);
+            first = false;
+            param = param->next;
+        }
+    }
+    fprintf(transpiler->output, ")");
+}
+
+void
+transpiler_visit_block_node(struct Visit* visit, struct Block_Node* node)
+{
+    TRANSPILER_PREAMBLE
+
+    fprintf(transpiler->output, "{\n");
+    FOR_EACH (struct Statement*, statement, node->statements) { VISIT(visit_statement, statement); }
+    fprintf(transpiler->output, "}\n");
+}
+
+void
+transpiler_visit_argument_group_node(struct Visit* visit, struct Argument_Group_Node* node)
+{
+    TRANSPILER_PREAMBLE
+
+    struct Expression* arg = node->arguments;
+    bool first = true;
+    while (arg) {
+        if (!first) { fprintf(transpiler->output, ", "); }
+        VISIT(visit_expression, arg);
+        first = false;
+        arg = arg->next;
+    }
+}
+
+void
+transpiler_visit_statement_declaration(struct Visit* visit, struct Statement* stmt)
+{
+    TRANSPILER_PREAMBLE
+
+    struct Statement_Value_Declaration* declaration = &stmt->value.declaration;
+    struct 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;
+
+        VISIT(visit_type_node, header->return_type);
+        fprintf(transpiler->output, " %.*s", (int)declaration->inner.names.strings[0].length,
+                declaration->inner.names.strings[0].data);
+        VISIT(visit_function_header_node, header);
+        fprintf(transpiler->output, " ");
+        VISIT(visit_block_node, &fun->body);
+    } else {
+        if (declaration->kind == STATEMENT_DECLARATION_CONSTANT) {
+            fprintf(transpiler->output, "const ");
+        }
+        VISIT(visit_type_node, declaration->inner.type);
+        fprintf(transpiler->output, " %.*s", (int)declaration->inner.names.strings[0].length,
+                declaration->inner.names.strings[0].data);
+        if (initializer) {
+            fprintf(transpiler->output, " = ");
+            VISIT(visit_expression, initializer);
+        }
+    }
+}
+
+void
+transpiler_visit_statement_return(struct Visit* visit, struct Statement* stmt)
+{
+    TRANSPILER_PREAMBLE
+
+    fprintf(transpiler->output, "return");
+    if (stmt->value.return_value.value) {
+        fprintf(transpiler->output, " ");
+        VISIT(visit_expression, stmt->value.return_value.value);
+    }
+}
+
+void
+transpiler_visit_statement_conditional(struct Visit* visit, struct Statement* stmt)
+{
+    TRANSPILER_PREAMBLE
+
+    struct Statement_Value_Conditional* conditional = &stmt->value.conditional;
+    for (uint i = 0; i < conditional->condition_count; ++i) {
+        struct Statement_Conditional_Branch* branch = &conditional->conditions[i];
+        if (i > 0) { fprintf(transpiler->output, "else "); }
+        if (branch->when) {
+            fprintf(transpiler->output, "if (");
+            VISIT(visit_expression, branch->when);
+            fprintf(transpiler->output, ") ");
+        }
+        VISIT(visit_block_node, &branch->then);
+    }
+}
+
+void
+transpiler_visit_statement(struct Visit* visit, struct Statement* statement)
+{
+    TRANSPILER_PREAMBLE
+
+    switch (statement->kind) {
+    case STATEMENT_EXPRESSION:
+        VISIT(visit_expression, statement->value.expression.inner);
+        if (transpiler->context.in_function) fprintf(transpiler->output, ";\n");
+        break;
+    case STATEMENT_DECLARATION:
+        VISIT(visit_statement_declaration, statement);
+        if (transpiler->context.in_function) fprintf(transpiler->output, ";\n");
+        break;
+    case STATEMENT_RETURN:
+        VISIT(visit_statement_return, statement);
+        if (transpiler->context.in_function) fprintf(transpiler->output, ";\n");
+        break;
+    case STATEMENT_BLOCK:
+        VISIT(visit_block_node, &statement->value.block.inner);
+        break;
+    default:
+        walk_statement(visit, statement);
+        break;
+    }
+}
+
+void
+transpiler_visit_expression_integer_literal(struct Visit* visit, struct Expression* expr)
+{
+    TRANSPILER_PREAMBLE
+
+    fprintf(transpiler->output, "%ld", expr->value.integer_literal.value);
+}
+
+void
+transpiler_visit_expression_float_literal(struct Visit* visit, struct Expression* expr)
+{
+    TRANSPILER_PREAMBLE
+
+    fprintf(transpiler->output, "%f", expr->value.float_literal.value);
+}
+
+void
+transpiler_visit_expression_string_literal(struct Visit* visit, struct Expression* expr)
+{
+    TRANSPILER_PREAMBLE
+
+    fprintf(transpiler->output, "\"%.*s\"", (int)expr->value.string_literal.value.length,
+            expr->value.string_literal.value.data);
+}
+
+void
+transpiler_visit_expression_boolean_literal(struct Visit* visit, struct Expression* expr)
+{
+    TRANSPILER_PREAMBLE
+
+    fprintf(transpiler->output, "%s", expr->value.bool_literal.value ? "true" : "false");
+}
+
+void
+transpiler_visit_expression_name(struct Visit* visit, struct Expression* expr)
+{
+    TRANSPILER_PREAMBLE
+
+    fprintf(
+        transpiler->output, "%.*s", (int)expr->value.name.name.length, expr->value.name.name.data);
+}
+
+void
+transpiler_visit_expression_unary_operation(struct Visit* visit, struct Expression* expr)
+{
+    TRANSPILER_PREAMBLE
+
+    fprintf(
+        transpiler->output, "(%s", unary_operation_to_string(expr->value.unary_operator.operation));
+    VISIT(visit_expression, expr->value.unary_operator.operand);
+    fprintf(transpiler->output, ")");
+}
+
+void
+transpiler_visit_expression_binary_operation(struct Visit* visit, struct Expression* expr)
+{
+    TRANSPILER_PREAMBLE
+    struct 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;
+
+        VISIT(visit_type_node, header->return_type);
+        fprintf(transpiler->output, " ");
+        VISIT(visit_expression, name_expr);
+        VISIT(visit_function_header_node, header);
+        fprintf(transpiler->output, " ");
+
+        CONTEXT_START(in_function);
+        VISIT(visit_block_node, &fun->body);
+        CONTEXT_END(in_function);
+    } else {
+        enum Binary_Operation op = expr->value.binary_operator.operation;
+        if (op == BINARY_ASSIGN_AND || op == BINARY_ASSIGN_OR) {
+            fprintf(transpiler->output, "(");
+            VISIT(visit_expression, expr->value.binary_operator.left_operand);
+            fprintf(transpiler->output, " = ");
+            VISIT(visit_expression, expr->value.binary_operator.left_operand);
+            if (op == BINARY_ASSIGN_AND)
+                fprintf(transpiler->output, " && ");
+            else
+                fprintf(transpiler->output, " || ");
+            VISIT(visit_expression, expr->value.binary_operator.right_operand);
+            fprintf(transpiler->output, ")");
+        } else {
+            fprintf(transpiler->output, "(");
+            VISIT(visit_expression, expr->value.binary_operator.left_operand);
+            fprintf(transpiler->output, " %s ", binary_operation_to_string(op));
+            VISIT(visit_expression, expr->value.binary_operator.right_operand);
+            fprintf(transpiler->output, ")");
+        }
+    }
+}
+
+void
+transpiler_visit_expression_call(struct Visit* visit, struct Expression* expr)
+{
+    TRANSPILER_PREAMBLE
+
+    VISIT(visit_expression, expr->value.call.subject);
+    fprintf(transpiler->output, "(");
+    VISIT(visit_argument_group_node, &expr->value.call.argument_group);
+    fprintf(transpiler->output, ")");
+}
+
+void
+transpiler_visit_expression(struct Visit* visit, struct Expression* expression)
+{
+    TRANSPILER_PREAMBLE
+
+    switch (expression->kind) {
+    case EXPRESSION_INTEGER_LITERAL:
+        VISIT(visit_expression_integer_literal, expression);
+        break;
+    case EXPRESSION_FLOAT_LITERAL:
+        VISIT(visit_expression_float_literal, expression);
+        break;
+    case EXPRESSION_STRING_LITERAL:
+        VISIT(visit_expression_string_literal, expression);
+        break;
+    case EXPRESSION_BOOLEAN_LITERAL:
+        VISIT(visit_expression_boolean_literal, expression);
+        break;
+    case EXPRESSION_NAME:
+        VISIT(visit_expression_name, expression);
+        break;
+    case EXPRESSION_UNARY_OPERATION:
+        VISIT(visit_expression_unary_operation, expression);
+        break;
+    case EXPRESSION_BINARY_OPERATION:
+        VISIT(visit_expression_binary_operation, expression);
+        break;
+    case EXPRESSION_CALL:
+        VISIT(visit_expression_call, expression);
+        break;
+    default:
+        walk_expression(visit, expression);
+        break;
+    }
+}
+
+void
+transpiler_visit_tree(struct Visit* visit, struct Tree* tree)
+{
+    TRANSPILER_PREAMBLE
+
+    // include some standard c headers
+    // catskill should have it's own standard library,
+    // but until bootstrapping is complete, we will just use a
+    // normal libc (preferably musl).
+    // other headers can be included by the user
+    // with the pragma `| c-header "header.h"`.
+    fprintf(transpiler->output, "#include <stdio.h>\n");
+    fprintf(transpiler->output, "#include <stdint.h>\n");
+    fprintf(transpiler->output, "#include <stdbool.h>\n\n");
+
+    FOR_EACH (struct Statement*, statement, tree->top_level_statements) {
+        VISIT(visit_statement, statement);
+    }
+}
+
+struct Visit_Table transpiler_visit_functions = {
+    .visit_tree = transpiler_visit_tree,
+    .visit_statement = transpiler_visit_statement,
+    .visit_statement_declaration = transpiler_visit_statement_declaration,
+    .visit_statement_conditional = transpiler_visit_statement_conditional,
+    .visit_statement_return = transpiler_visit_statement_return,
+    .visit_expression = transpiler_visit_expression,
+    .visit_expression_integer_literal = transpiler_visit_expression_integer_literal,
+    .visit_expression_float_literal = transpiler_visit_expression_float_literal,
+    .visit_expression_string_literal = transpiler_visit_expression_string_literal,
+    .visit_expression_boolean_literal = transpiler_visit_expression_boolean_literal,
+    .visit_expression_name = transpiler_visit_expression_name,
+    .visit_expression_unary_operation = transpiler_visit_expression_unary_operation,
+    .visit_expression_binary_operation = transpiler_visit_expression_binary_operation,
+    .visit_expression_call = transpiler_visit_expression_call,
+    .visit_type_node = transpiler_visit_type_node,
+    .visit_function_header_node = transpiler_visit_function_header_node,
+    .visit_block_node = transpiler_visit_block_node,
+    .visit_argument_group_node = transpiler_visit_argument_group_node,
+};
+
+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);
+
+    walk(&visit, tree);
+
+    return 0;
+}