parser.h

Go to the documentation of this file.

 
#pragma once
#include <vector>
 
#include "tokenizer.h"
 
char LETTER_EQ[] = "==";
 
char LETTER_NEQ[] = "!=";
 
char LETTER_LQ[] = "<";
 
char LETTER_LEQ[] = "<=";
 
char LETTER_GQ[] = ">";
 
char LETTER_GEQ[] = ">=";
 
char LETTER_PLUS[] = "+";
 
char LETTER_MINUS[] = "-";
 
char LETTER_MUL[] = "*";
 
char LETTER_DIV[] = "/";
 
char LETTER_AND[] = "&&";
 
char LETTER_OR[] = "||";
 
char LETTER_NOT[] = "!";
 
char LETTER_LP[] = "(";
 
char LETTER_RP[] = ")";
 
char LETTER_SC[] = ";";
 
char LETTER_ELSE[] = "else";
 
char LETTER_LB[] = "{";
 
char LETTER_RB[] = "}";
 
namespace gymbo {
 
typedef enum {
    ND_ADD,  // +
    ND_SUB,  // -
    ND_MUL,  // *
    ND_DIV,  // /
    ND_AND,  // &&
    ND_OR,   // ||
    ND_NOT,  // !
    ND_EQ,   // ==
    ND_NE,   // !=
    ND_LT,   // <
    ND_LE,   // <=
    ND_ASSIGN,
    ND_LVAR,
    ND_NUM,  // Integer
    ND_RETURN,
    ND_IF,
    ND_FOR,
    ND_BLOCK,
} NodeKind;
 
struct Node {
    NodeKind kind;               
    Node *lhs;                   
    Node *rhs;                   
    Node *cond;                  
    Node *then;                  
    Node *els;                   
    std::vector<Node *> blocks;  
    float val;                   
    int offset;                  
};
 
Node *assign(Token *&token, char *user_input);
Node *expr(Token *&token, char *user_input);
Node *equality(Token *&token, char *user_input);
Node *relational(Token *&token, char *user_input);
Node *logical(Token *&token, char *user_input);
Node *add(Token *&token, char *user_input);
Node *mul(Token *&token, char *user_input);
Node *unary(Token *&token, char *user_input);
Node *primary(Token *&token, char *user_input);
Node *stmt(Token *&token, char *user_input);
 
Node *new_node(NodeKind kind) {
    Node *node = new Node();
    node->kind = kind;
    return node;
}
 
Node *new_binary(NodeKind kind, Node *lhs, Node *rhs) {
    Node *node = new_node(kind);
    node->lhs = lhs;
    node->rhs = rhs;
    return node;
}
 
Node *new_num(float val) {
    Node *node = new_node(ND_NUM);
    node->val = val;
    return node;
}
 
Node *expr(Token *&token, char *user_input) {
    return assign(token, user_input);
}
 
Node *assign(Token *&token, char *user_input) {
    char LETTER_ASS[] = "=";
    Node *node = logical(token, user_input);
    if (consume(token, LETTER_ASS))
        node = new_binary(ND_ASSIGN, node, assign(token, user_input));
    return node;
}
 
Node *logical(Token *&token, char *user_input) {
    Node *node = equality(token, user_input);
 
    for (;;) {
        if (consume(token, LETTER_AND))
            node = new_binary(ND_AND, node, equality(token, user_input));
        else if (consume(token, LETTER_OR))
            node = new_binary(ND_OR, node, equality(token, user_input));
        else
            return node;
    }
}
 
Node *equality(Token *&token, char *user_input) {
    Node *node = relational(token, user_input);
 
    for (;;) {
        if (consume(token, LETTER_EQ))
            node = new_binary(ND_EQ, node, relational(token, user_input));
        else if (consume(token, LETTER_NEQ))
            node = new_binary(ND_NE, node, relational(token, user_input));
        else
            return node;
    }
}
 
Node *relational(Token *&token, char *user_input) {
    Node *node = add(token, user_input);
 
    for (;;) {
        if (consume(token, LETTER_LQ))
            node = new_binary(ND_LT, node, add(token, user_input));
        else if (consume(token, LETTER_LEQ))
            node = new_binary(ND_LE, node, add(token, user_input));
        else if (consume(token, LETTER_GQ))
            node = new_binary(ND_LT, add(token, user_input), node);
        else if (consume(token, LETTER_GEQ))
            node = new_binary(ND_LE, add(token, user_input), node);
        else
            return node;
    }
}
 
inline Node *add(Token *&token, char *user_input) {
    Node *node = mul(token, user_input);
 
    for (;;) {
        if (consume(token, LETTER_PLUS))
            node = new_binary(ND_ADD, node, mul(token, user_input));
        else if (consume(token, LETTER_MINUS))
            node = new_binary(ND_SUB, node, mul(token, user_input));
        else
            return node;
    }
}
 
inline Node *mul(Token *&token, char *user_input) {
    Node *node = unary(token, user_input);
 
    for (;;) {
        if (consume(token, LETTER_MUL))
            node = new_binary(ND_MUL, node, unary(token, user_input));
        else if (consume(token, LETTER_DIV))
            node = new_binary(ND_DIV, node, unary(token, user_input));
        else
            return node;
    }
}
 
inline Node *unary(Token *&token, char *user_input) {
    if (consume(token, LETTER_PLUS)) return unary(token, user_input);
    if (consume(token, LETTER_MINUS))
        return new_binary(ND_SUB, new_num(0), unary(token, user_input));
    return primary(token, user_input);
}
 
inline Node *primary(Token *&token, char *user_input) {
    if (consume(token, LETTER_LP)) {
        Node *node = expr(token, user_input);
        expect(token, user_input, LETTER_RP);
        return node;
    }
 
    Token *tok = consume_ident(token);
    if (tok) {
        Node *node = (Node *)std::calloc(1, sizeof(Node));
        node->kind = ND_LVAR;
        node->offset = tok->var_id;
        return node;
    }
 
    return new_num(expect_number(token, user_input));
}
 
inline Node *stmt(Token *&token, char *user_input) {
    Node *node;
 
    if (consume(token, LETTER_LB)) {
        node = new Node();
        node->kind = ND_BLOCK;
        while (true) {
            node->blocks.emplace_back(stmt(token, user_input));
            if (consume(token, LETTER_RB)) {
                break;
            }
        }
    } else if (consume_tok(token, TOKEN_RETURN)) {
        node = new Node();
        node->kind = ND_RETURN;
        node->lhs = expr(token, user_input);
        expect(token, user_input, LETTER_SC);
    } else if (consume_tok(token, TOKEN_IF)) {
        node = new Node();
        node->kind = ND_IF;
        expect(token, user_input, LETTER_LP);
        node->cond = expr(token, user_input);
        expect(token, user_input, LETTER_RP);
        node->then = stmt(token, user_input);
        if (consume_tok(token, TOKEN_ELSE)) {
            node->els = stmt(token, user_input);
        }
    } else {
        node = expr(token, user_input);
        expect(token, user_input, LETTER_SC);
    }
 
    return node;
}
 
inline void generate_ast(Token *&token, char *user_input,
                         std::vector<Node *> &code) {
    while (!at_eof(token)) code.emplace_back(stmt(token, user_input));
    code.emplace_back(nullptr);
}
}  // namespace gymbo