aboutsummaryrefslogtreecommitdiff
path: root/src/ast.c
blob: c28b31400ac6675f6712f227c95503764dd27eda (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#include "../include/ast.h"
#include "../include/std/log.h"
#include <assert.h>

static void ast_resolve(Ast *self);

Ast ast_none() {
    Ast ast;
    ast.value.func_decl = NULL;
    ast.type = AST_NONE;
    return ast;
}

int funcdecl_init(FunctionDecl *self, ScopedAllocator *allocator) {
    self->name = create_buffer_view_null();
    return buffer_init(&self->body, allocator);
}

int funccall_init(FunctionCall *self, BufferView name, ScopedAllocator *allocator) {
    self->name = name;
    return buffer_init(&self->args, allocator);
}

void lhsexpr_init(LhsExpr *self, int isConst, BufferView var_name) {
    self->isConst = isConst;
    self->type_name = create_buffer_view_null();
    self->var_name = var_name;
    self->rhs_expr = ast_none();
}

void import_init(Import *self, BufferView path) {
    self->path = path;
}

int string_init(String *self, BufferView str) {
    /* TODO: Convert special characters. For example \n should be converted to binary newline etc */
    self->str = str;
    return 0;
}

void number_init(Number *self, i64 value, bool is_integer) {
    self->value.integer = value;
    self->is_integer = is_integer;
}

void binop_init(Binop *self) {
    self->lhs = ast_none();
    self->rhs = ast_none();
    self->type = BINOP_ADD;
    self->grouped = bool_false;
}

int scope_init(Scope *self, ScopedAllocator *allocator) {
    return buffer_init(&self->ast_objects, allocator);
}

void scope_resolve(Scope *self) {
    Ast *ast;
    Ast *ast_end;
    ast = buffer_start(&self->ast_objects);
    ast_end = buffer_end(&self->ast_objects);
    for(; ast != ast_end; ++ast) {
        ast_resolve(ast);
    }
}

static void lhs_resolve(LhsExpr *self) {
    amal_log_debug("Lhs resolve var name: %.*s", self->var_name.size, self->var_name.data);
}

void ast_resolve(Ast *self) {
    switch(self->type) {
        case AST_LHS:
            lhs_resolve(self->value.lhs_expr);
            break;
        default:
            assert(bool_false && "ast_resolve not implemented for type");
            break;
    }
}