solid-lang/Parser.h at main · m-maresch/solid-lang · 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
#ifndef SOLID_LANG_PARSER_H
#define SOLID_LANG_PARSER_H

#include <utility>
#include <map>

#include "Lexer.h"
#include "Expression.h"

class Parser {
public:
    explicit Parser(Lexer &Lexer) : Lexer(Lexer) {}

    std::unique_ptr<Expression> ParseExpression();

    std::unique_ptr<Expression> ParsePrimaryExpression();

    std::unique_ptr<Expression> ParseIdExpression();

    std::unique_ptr<Expression> ParseNumExpression();

    std::unique_ptr<Expression> ParseParenthesisExpression();

    std::unique_ptr<Expression> ParseUnaryExpression();

    std::unique_ptr<Expression> ParseConditionalExpression();

    std::unique_ptr<Expression> ParseLoopExpression();

    std::unique_ptr<Expression> ParseVariableDefinition();

    std::unique_ptr<FunctionDeclaration> ParseFunctionDeclaration();

    std::unique_ptr<FunctionDefinition> ParseFunctionDefinition();

    std::unique_ptr<FunctionDeclaration> ParseNative();

    std::unique_ptr<FunctionDefinition> ParseTopLevelExpression();

private:
    Lexer &Lexer;
    std::map<char, int> BinaryOperatorPrecedences = {{'*', 40},
                                                     {'+', 20},
                                                     {'-', 20},
                                                     {'<', 10},
                                                     {'=', 3}};

    int GetTokenPrecedence();

    std::unique_ptr<Expression> ParseRightSideOfBinaryOperator(int Precedence, std::unique_ptr<Expression> LeftSide);

    template<class T>
    std::unique_ptr<T> LogError(const char *Message) {
        fprintf(stderr, "Error: %s\n", Message);
        return nullptr;
    }
};


#endif