Implemented parsing (merge to dev)

include/dragon/parser.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "token.h"
+#include "ast.h"
+
+#include "ast/variable_declaration_node.h"
+#include "ast/variable_assignment_node.h"
+#include "ast/while_loop_node.h"
+#include "ast/for_loop_node.h"
+#include "ast/if_else_node.h"
+#include "ast/function_call_node.h"
+
+
+class Parser {
+private:
+    std::vector<Token> tokens;
+    std::vector<Node> nodes;
+    size_t index;
+
+    std::optional<Token> peek() const;
+    std::optional<Token> peek_next() const;
+    std::optional<Token> advance(TokenType type);
+
+public: 
+    explicit Parser(std::vector<Token> tokens) : tokens(std::move(tokens)), index(0) {}
+    explicit Parser() : tokens(std::vector<Token>()), index(0) {}
+
+    void reset();
+
+    std::vector<Node> parse();
+    std::vector<Node> parse(const std::vector<Token>& tokens);
+
+    std::unique_ptr<VariableDeclarationNode> parse_variable_declaration();
+    std::unique_ptr<VariableAssignmentNode> parse_variable_assignment();
+    std::unique_ptr<WhileLoopNode> parse_while_loop();
+    std::unique_ptr<ForLoopNode> parse_for_loop();
+    std::unique_ptr<IfElseNode> parse_if_else();
+    std::unique_ptr<FunctionCallNode> parse_function_call();
+    std::unique_ptr<ExpressionNode> parse_expression();
+};

include/dragon/token.h

@@ -1,6 +1,8 @@
 #pragma once
 
 #include <string>
+#include <sstream>
+#include <vector>
 
 enum class TokenType {
     // Keywords
@@ -136,7 +138,7 @@ class Token {
         return this->type != other.type || this->value != other.value;
     }
 
-    inline std::string to_string() {
+    inline std::string to_string() const {
                 std::stringstream ss;
         ss << "Token(" << token_type_to_string(this->type);
         if (!this->value.empty()) {

src/parser.cpp

@@ -1 +1,32 @@
-#include "dragon/parser.h"
+#include "dragon/parser.h"
+
+std::optional<Token> Parser::peek() const {
+    if (index < tokens.size()) {
+        return tokens[index];
+    }
+
+    return std::nullopt;
+}
+
+std::optional<Token> Parser::peek_next() const {
+    if (index + 1 < tokens.size()) {
+        return tokens[index + 1];
+    }
+
+    return std::nullopt;
+}
+
+std::optional<Token> Parser::advance(TokenType type) {
+    if (index < tokens.size() && tokens[index].type == type) {
+        return tokens[index++];
+    }
+
+    return std::nullopt;
+}
+
+void Parser::reset() {
+    index = 0;
+    tokens.clear();
+    nodes.clear();
+}
+