ast.c

Go to the documentation of this file.

// Copyright (C) 2023 Ethan Uppal. All rights reserved.
 
#include "ast.h"
 
#include <stdio.h>       // printf
#include "util/arena.h"  // astalloc
 
struct ps_node* ps_node_let_new(struct ps_token* name, bool is_mutable,
    struct ps_type* type, struct ps_expr* value) {
    struct ps_node* node = astalloc(sizeof(*node));
    node->type = PS_NODE_LET;
 
    struct ps_node_let* let = &node->value.let;
    let->name = name;
    let->is_mutable = is_mutable;
    let->type = type;
    let->value = value;
 
    return node;
}
 
struct ps_node* ps_node_fn_new(struct ps_token* name, struct ps_type* ret_type,
    struct ps_type_field_arr* params, enum ps_fn_qualifiers qualifiers,
    struct ps_node_block* body) {
    struct ps_node* node = astalloc(sizeof(*node));
    node->type = PS_NODE_FN;
 
    struct ps_node_fn* fn = &node->value.fn;
    fn->name = name;
    fn->ret_type = ret_type;
    fn->params = params;
    fn->qualifiers = qualifiers;
    fn->body = body;
 
    return node;
}
 
PS_PRINT_IMPL(ps_name, {
    for (usize i = 0; i < self->length; i++) {
        if (i > 0) {
            printf("::");
        }
        ps_token_print(&self->contents[i], 0);
    }
})
 
struct ps_node* ps_node_import_new(struct ps_name* name) {
    struct ps_node* node = astalloc(sizeof(*node));
    node->type = PS_NODE_IMPORT;
 
    struct ps_node_import* import = &node->value.import;
    import->name = name;
 
    return node;
}
 
struct ps_node* ps_node_extern_new(struct ps_token* name,
    struct ps_type_tuple* sig) {
    struct ps_node* node = astalloc(sizeof(*node));
    node->type = PS_NODE_EXTERN;
 
    struct ps_node_extern* extern_ = &node->value.extern_;
    extern_->name = name;
    extern_->sig = sig;
 
    return node;
}
 
struct ps_node* ps_node_expr_stm_new(struct ps_expr* expr) {
    struct ps_node* node = astalloc(sizeof(*node));
    node->type = PS_NODE_EXPR_STM;
 
    struct ps_node_expr_stm* expr_stm = &node->value.expr_stm;
    expr_stm->expr = expr;
 
    return node;
}
 
struct ps_node* ps_node_block_stm_new(struct ps_node_block* block) {
    struct ps_node* node = astalloc(sizeof(*node));
    node->type = PS_NODE_BLOCK;
 
    node->value.block = block;
 
    return node;
}
 
struct ps_node* ps_node_struct_new(struct ps_type_struct* type,
    struct ps_node_fn_arr* methods) {
    struct ps_node* node = astalloc(sizeof(*node));
    node->type = PS_NODE_STRUCT;
 
    struct ps_node_struct* struct_ = &node->value.struct_;
    struct_->type = type;
    struct_->methods = methods;
 
    return node;
}
 
struct ps_node* ps_node_enum_new(struct ps_type_enum* type,
    struct ps_node_fn_arr* methods) {
    struct ps_node* node = astalloc(sizeof(*node));
    node->type = PS_NODE_ENUM;
 
    struct ps_node_enum* enum_ = &node->value.enum_;
    enum_->type = type;
    enum_->methods = methods;
 
    return node;
}
 
struct ps_node* ps_node_for_new(struct ps_node_let* init, struct ps_expr* cond,
    struct ps_node_expr_stm* step, struct ps_node_block* body) {
    struct ps_node* node = astalloc(sizeof(*node));
    node->type = PS_NODE_FOR;
 
    struct ps_node_for* for_ = &node->value.for_;
    for_->init = init;
    for_->cond = cond;
    for_->step = step;
    for_->body = body;
 
    return node;
}
 
struct ps_node* ps_node_while_new(struct ps_expr* cond,
    struct ps_node_block* body) {
    struct ps_node* node = astalloc(sizeof(*node));
    node->type = PS_NODE_WHILE;
 
    struct ps_node_while* while_ = &node->value.while_;
    while_->cond = cond;
    while_->body = body;
 
    return node;
}
 
struct ps_node* ps_node_if_new(struct ps_expr* cond, struct ps_node_block* body,
    struct ps_node_block* else_body) {
    struct ps_node* node = astalloc(sizeof(*node));
    node->type = PS_NODE_IF;
 
    struct ps_node_if* if_ = &node->value.if_;
    if_->cond = cond;
    if_->body = body;
    if_->else_body = else_body;
 
    return node;
}
 
struct ps_node* ps_node_return_new(struct ps_expr* value) {
    struct ps_node* node = astalloc(sizeof(*node));
    node->type = PS_NODE_RETURN;
 
    struct ps_node_return* return_ = &node->value.return_;
    return_->value = value;
 
    return node;
}
 
PS_IPRINT_IMPL(ps_node_let, {
    ps_print_indent();
    printf("let %s%s", self->is_mutable ? "mut " : "", self->name->start);
    if (self->type) {
        printf(": ");
        ps_type_print(self->type, 0);
    }
    printf(" = ");
    ps_expr_print(self->value, 0);
})
 
PS_IPRINT_IMPL(ps_node_fn, {
    ps_print_indent();
    if (self->qualifiers & PS_FN_PUBLIC) {
        printf("public ");
    }
    if (self->qualifiers & PS_FN_PRIVATE) {
        printf("private ");
    }
    if (self->qualifiers & PS_FN_STATIC) {
        printf("static ");
    }
    if (self->qualifiers & PS_FN_INLINE) {
        printf("inline ");
    }
    printf("fn %s", self->name->start);
    ps_type_field_arr_print(self->params, 0);
    if (self->ret_type) {
        printf(" -> ");
        ps_type_print(self->ret_type, 0);
    }
    printf(" ");
    ps_node_block_print(self->body, 0, indent);
})
 
PS_IPRINT_IMPL(ps_node_import, {
    ps_print_indent();
    printf("import ");
    for (usize i = 0; i < self->name->length; i++) {
        if (i) printf("::");
        printf("%s", $arr(self->name)[i]->start);
    }
})
 
PS_IPRINT_IMPL(ps_node_extern, {
    ps_print_indent();
    printf("extern %s", self->name->start);
    ps_type_tuple_print(self->sig, 0);
})
 
PS_IPRINT_IMPL(ps_node_expr_stm, {
    ps_print_indent();
    ps_expr_print(self->expr, 0);
})
 
PS_IPRINT_IMPL(ps_node_block, {
    printf("{\n");
    for (size_t i = 0; i < self->length; i++) {
        ps_node_print(self->contents[i], '\n', ps_next_indent());
    }
    ps_print_indent();
    printf("}");
})
 
PS_IPRINT_IMPL(ps_node_struct, {
    ps_print_indent();
    ps_type_struct_print(self->type, 0, ps_next_indent());
})
 
PS_IPRINT_IMPL(ps_node_enum, {
    ps_print_indent();
    ps_type_enum_print(self->type, 0, ps_next_indent());
})
 
PS_IPRINT_IMPL(ps_node_for, {
    ps_print_indent();
    // printf("for ");
    // ps_node_let_print(self->init, 0, 0);
    // printf("; ");
    // ps_expr_print(self->cond, 0);
    // printf("; ");
    // ps_node_expr_stm_print(self->step, 0, 0);
    // printf(" ");
    // ps_node_block_print(self->body, 0, indent);
})
 
PS_IPRINT_IMPL(ps_node_while, {
    ps_print_indent();
    printf("while ");
    ps_expr_print(self->cond, 0);
    printf(" ");
    ps_node_block_print(self->body, 0, indent);
})
 
PS_IPRINT_IMPL(ps_node_if, {
    ps_print_indent();
    printf("if ");
    ps_expr_print(self->cond, 0);
    printf(" ");
    ps_node_block_print(self->body, 0, indent);
    if (self->else_body) {
        printf(" else ");
        ps_node_block_print(self->else_body, 0, indent);
    }
})
 
PS_IPRINT_IMPL(ps_node_return, {
    ps_print_indent();
    printf("return");
    if (self->value) {
        printf(" ");
        ps_expr_print(self->value, 0);
    }
})
 
PS_IPRINT_IMPL(ps_node, {
    switch (self->type) {
        case PS_NODE_LET:
            ps_node_let_print(&self->value.let, 0, indent);
            break;
        case PS_NODE_FN:
            ps_node_fn_print(&self->value.fn, 0, indent);
            break;
        case PS_NODE_IMPORT:
            ps_node_import_print(&self->value.import, 0, indent);
            break;
        case PS_NODE_EXTERN:
            ps_node_extern_print(&self->value.extern_, 0, indent);
            break;
        case PS_NODE_EXPR_STM:
            ps_node_expr_stm_print(&self->value.expr_stm, 0, indent);
            break;
        case PS_NODE_BLOCK:
            ps_print_indent();
            ps_node_block_print(self->value.block, 0, indent);
            break;
        case PS_NODE_STRUCT:
            ps_node_struct_print(&self->value.struct_, 0, indent);
            break;
        case PS_NODE_ENUM:
            ps_node_enum_print(&self->value.enum_, 0, indent);
            break;
        case PS_NODE_FOR:
            ps_node_for_print(&self->value.for_, 0, indent);
            break;
        case PS_NODE_WHILE:
            ps_node_while_print(&self->value.while_, 0, indent);
            break;
        case PS_NODE_IF:
            ps_node_if_print(&self->value.if_, 0, indent);
            break;
        case PS_NODE_RETURN:
            ps_node_return_print(&self->value.return_, 0, indent);
            break;
        case PS_NODE_TRAIT:
            PS_NO_IMPL();
        case PS_NODE_EXPR:
            ps_abort("idk what this is");
        default:
            ps_abort("you're missing a case here");
    }
})
 
struct ps_expr* ps_expr_id_new(struct ps_token* name) {
    struct ps_expr* expr = astalloc(sizeof(*expr));
    expr->expr_type = PS_EXPR_ID_EXPR;
    expr->type = NULL;
 
    struct ps_expr_id* id = &expr->value.id_expr;
    id->name = name;
 
    return expr;
}
 
struct ps_expr* ps_expr_lit_new_u64(u64 value, struct ps_token* token) {
    struct ps_expr* expr = astalloc(sizeof(*expr));
    expr->expr_type = PS_EXPR_LIT_EXPR;
    expr->type = NULL;
 
    struct ps_expr_lit* lit = &expr->value.lit_expr;
    lit->type = PS_EXPR_LIT_U64;
    lit->value.uint_val = value;
    lit->token = token;
 
    return expr;
}
 
struct ps_expr* ps_expr_lit_new_i64(i64 value, struct ps_token* token) {
    struct ps_expr* expr = astalloc(sizeof(*expr));
    expr->expr_type = PS_EXPR_LIT_EXPR;
    expr->type = NULL;
 
    struct ps_expr_lit* lit = &expr->value.lit_expr;
    lit->type = PS_EXPR_LIT_I64;
    lit->value.int_val = value;
    lit->token = token;
 
    return expr;
}
 
struct ps_expr* ps_expr_lit_new_f64(f64 value, struct ps_token* token) {
    struct ps_expr* expr = astalloc(sizeof(*expr));
    expr->expr_type = PS_EXPR_LIT_EXPR;
    expr->type = NULL;
 
    struct ps_expr_lit* lit = &expr->value.lit_expr;
    lit->type = PS_EXPR_LIT_F64;
    lit->value.float_val = value;
    lit->token = token;
 
    return expr;
}
 
struct ps_expr* ps_expr_lit_new_bool(bool value, struct ps_token* token) {
    struct ps_expr* expr = astalloc(sizeof(*expr));
    expr->expr_type = PS_EXPR_LIT_EXPR;
    expr->type = NULL;
 
    struct ps_expr_lit* lit = &expr->value.lit_expr;
    lit->type = PS_EXPR_LIT_BOOL;
    lit->value.bool_val = value;
    lit->token = token;
 
    return expr;
}
 
struct ps_expr* ps_expr_lit_new_str(STR value, struct ps_token* token) {
    struct ps_expr* expr = astalloc(sizeof(*expr));
    expr->expr_type = PS_EXPR_LIT_EXPR;
    expr->type = NULL;
 
    struct ps_expr_lit* lit = &expr->value.lit_expr;
    lit->type = PS_EXPR_LIT_STR;
    lit->value.str_val = value;
    lit->token = token;
 
    return expr;
}
 
struct ps_expr* ps_expr_lit_new_interp_str(struct ps_interp_str* value) {
    struct ps_expr* expr = astalloc(sizeof(*expr));
    expr->expr_type = PS_EXPR_LIT_EXPR;
    expr->type = NULL;
 
    struct ps_expr_lit* lit = &expr->value.lit_expr;
    lit->type = PS_EXPR_LIT_INTERP_STR;
    lit->value.interp_str_val = value;
    lit->token = NULL;  // not sure if good idea
 
    return expr;
}
 
struct ps_expr* ps_expr_lit_new_unit(struct ps_token* token) {
    struct ps_expr* expr = astalloc(sizeof(*expr));
    expr->expr_type = PS_EXPR_LIT_EXPR;
    expr->type = NULL;
 
    struct ps_expr_lit* lit = &expr->value.lit_expr;
    lit->type = PS_EXPR_LIT_UNIT;
    lit->token = token;
 
    return expr;
}
 
struct ps_expr* ps_expr_binary_new(struct ps_expr* lhs, struct ps_token* op,
    struct ps_expr* rhs) {
    struct ps_expr* expr = astalloc(sizeof(*expr));
    expr->expr_type = PS_EXPR_BIN_EXPR;
    expr->type = NULL;
 
    struct ps_expr_binary* binary = &expr->value.bin_expr;
    binary->op = op;
    binary->lhs = lhs;
    binary->rhs = rhs;
 
    return expr;
}
 
struct ps_expr* ps_expr_unary_new(struct ps_token* op, struct ps_expr* rhs) {
    struct ps_expr* expr = astalloc(sizeof(*expr));
    expr->expr_type = PS_EXPR_UN_EXPR;
    expr->type = NULL;
 
    struct ps_expr_unary* unary = &expr->value.un_expr;
    unary->op = op;
    unary->rhs = rhs;
 
    return expr;
}
 
struct ps_expr* ps_expr_call_new(struct ps_token* callee,
    struct ps_expr_arr* args) {
    struct ps_expr* expr = astalloc(sizeof(*expr));
    expr->expr_type = PS_EXPR_CALL_EXPR;
    expr->type = NULL;
 
    struct ps_expr_call* call = &expr->value.call_expr;
    call->callee = callee;
    call->args = args;
 
    return expr;
}
 
PS_PRINT_IMPL(ps_interp_str, {
    putchar('"');
    for (usize i = 0; i < self->length; i++) {
        struct ps_expr* part = self->contents[i];
        if (part->expr_type == PS_EXPR_LIT_EXPR
            && part->value.lit_expr.type == PS_EXPR_LIT_STR) {
            printf("%s", part->value.lit_expr.value.str_val);
        } else {
            printf("\\(");
            ps_expr_print(part, ')');
        }
    }
    putchar('"');
})
 
PS_PRINT_IMPL(ps_expr_lit, {
    switch (self->type) {
        case PS_EXPR_LIT_U64:
            printf("%llu", self->value.uint_val);
            break;
        case PS_EXPR_LIT_I64:
            printf("%lld", self->value.int_val);
            break;
        case PS_EXPR_LIT_F64:
            printf("%f", self->value.float_val);
            break;
        case PS_EXPR_LIT_BOOL:
            printf("%s", self->value.bool_val ? "true" : "false");
            break;
        case PS_EXPR_LIT_STR:
            printf("\"%s\"", self->value.str_val);
            break;
        case PS_EXPR_LIT_INTERP_STR:
            ps_interp_str_print(self->value.interp_str_val, 0);
            break;
        case PS_EXPR_LIT_UNIT:
            printf("()");
            break;
    }
})
 
PS_PRINT_IMPL(ps_expr_id, { printf("%s", self->name->start); })
 
PS_PRINT_IMPL(ps_expr_binary, {
    putchar('(');
    ps_expr_print(self->lhs, 0);
    printf(" %s ", self->op->start);
    ps_expr_print(self->rhs, 0);
    putchar(')');
})
 
PS_PRINT_IMPL(ps_expr_unary, {
    printf("%s ", self->op->start);
    ps_expr_print(self->rhs, 0);
})
 
PS_PRINT_IMPL(ps_expr_call, {
    printf("%s(", self->callee->start);
    for (usize i = 0; i < self->args->length; i++) {
        if (i > 0) {
            printf(", ");
        }
        ps_expr_print(self->args->contents[i], 0);
    }
    putchar(')');
})
 
PS_PRINT_IMPL(ps_expr, {
    switch (self->expr_type) {
        case PS_EXPR_ID_EXPR:
            ps_expr_id_print(&self->value.id_expr, 0);
            break;
        case PS_EXPR_LIT_EXPR:
            ps_expr_lit_print(&self->value.lit_expr, 0);
            break;
        case PS_EXPR_BIN_EXPR:
            ps_expr_binary_print(&self->value.bin_expr, 0);
            break;
        case PS_EXPR_UN_EXPR:
            ps_expr_unary_print(&self->value.un_expr, 0);
            break;
        case PS_EXPR_CALL_EXPR:
            ps_expr_call_print(&self->value.call_expr, 0);
            break;
    }
})