osl./codegen.cpp at main · mshandilya/osl. · GitHub

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include "codegen.hpp"

void CodeGenerator::codifyNext(std::unique_ptr<ast::ASTNode>& node) {
    switch(node->type()) {
        case ast::PROG_AST:
            return codifyProg(node);
        case ast::BLOCK_AST:
            return codifyBlock(node);
        case ast::LOOP_AST:
            return codifyLoop(node);
        case ast::COND_AST:
            return codifyCond(node);
        case ast::RET_AST:
            return codifyReturn(node);
        case ast::LOG_AST:
            return codifyLog(node);
        case ast::LETFUN_AST:
            return codifyLetFun(node);
        case ast::LETVAR_AST:
            return codifyLetVar(node);
        case ast::LETCONST_AST:
            return codifyLetConst(node);
        case ast::ASSIGN_AST:
            return codifyAssign(node);
        case ast::BOP_AST:
            return codifyBinOp(node);
        case ast::UOP_AST:
            return codifyUnOp(node);
        case ast::FUNCALL_AST:
            return codifyFunCall(node);
        case ast::ARR_AST:
            return codifyArray(node);
        case ast::NUM_AST:
            return codifyNumber(node);
        case ast::CHAR_AST:
            return codifyChar(node);
        case ast::BOOL_AST:
            return codifyBool(node);
        case ast::NULL_AST:
            return codifyNull(node);
        case ast::IDEN_AST:
            return codifyIden(node);
    }
}

void CodeGenerator::codifyProg(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::Prog*>(node.get());
}

void CodeGenerator::codifyBlock(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::Block*>(node.get());
}

void CodeGenerator::codifyLoop(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::Loop*>(node.get());
}

void CodeGenerator::codifyCond(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::Conditional*>(node.get());
}

void CodeGenerator::codifyReturn(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::Return*>(node.get());
}

void CodeGenerator::codifyLog(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::Log*>(node.get());
}

void CodeGenerator::codifyLetFun(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::LetFun*>(node.get());
}

void CodeGenerator::codifyLetVar(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::LetVar*>(node.get());
}

void CodeGenerator::codifyLetConst(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::LetConst*>(node.get());
}

void CodeGenerator::codifyAssign(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::Assign*>(node.get());
}

void CodeGenerator::codifyBinOp(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::BinaryOperator*>(node.get());
}

void CodeGenerator::codifyUnOp(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::UnaryOperator*>(node.get());
}

void CodeGenerator::codifyFunCall(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::FunctionCall*>(node.get());
}

void CodeGenerator::codifyArray(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::ArrValue*>(node.get());
}

void CodeGenerator::codifyNumber(std::unique_ptr<ast::ASTNode>& node) {
    auto npnode = dynamic_cast<ast::AtomicASTNode*>(node.get());
    // transform further to Number after types design

}

void CodeGenerator::codifyChar(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::CharValue*>(node.get());
}

void CodeGenerator::codifyBool(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::BoolValue*>(node.get());
}

void CodeGenerator::codifyNull(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::NullValue*>(node.get());
}

void CodeGenerator::codifyIden(std::unique_ptr<ast::ASTNode>& node) {
    auto nnode = dynamic_cast<ast::Identifier*>(node.get());
}