initial commit

src/parser/parser.hpp

@@ -0,0 +1,95 @@
+#pragma once
+
+#include <vector>
+#include <optional>
+
+#include "../lexer/lexer.hpp"
+
+namespace Solstice {
+
+    enum class NodeType {
+        Root, Literal, Identifier,
+        FunctionBind, Bind, Set, 
+        Lambda, FunctionCall,
+        Add, Subtract, Multiply, Divide,
+        Equal, NotEqual, GreaterThan, LesserThan
+    };
+
+    enum class Precedence {
+        NewLine,
+        Identifier,
+        If, 
+        While, 
+        Compare, 
+        Set,
+        FunctionCall,
+        Add,
+        Multiply,
+        Other,
+        Root
+    };
+    
+    extern std::unordered_map<TokenType, NodeType> tokToNodeType;
+
+    class Node {
+        public:
+        NodeType type = NodeType::Root;
+        std::vector<Node> children;
+        std::variant<Literal, std::string> data;
+
+        Node() = delete;
+        Node(NodeType type) : type(type) {}
+        Node(NodeType type, const std::vector<Node>& children) : type(type), children(children) {}
+        Node(const Literal& literal) : type(NodeType::Literal), data(literal) {}
+        Node(const std::string& id) : type(NodeType::Identifier), data(id) {}
+    };
+
+    class Parser {
+
+        std::vector<Token> input;
+        Node output{NodeType::Root};
+
+        size_t current = 0;
+
+        std::optional<Token> peek(int64_t ahead = 0);
+        std::optional<Token> consume();
+
+        std::optional<Node> getPreviousNode(Node& parent);
+
+        Node parseKwType();
+
+        Node parseHashCimport();
+        Node parseHashEffect();
+
+        Node parseAssignBind();
+        Node parseAssignSet();
+        Node parseAssignType();
+
+        Node parseActionFunction();
+
+        Node parseExpr(TokenType type);
+
+        Node parseOpenCurly();
+        Node parseOpenParen();
+        Node parseOpenSpiky();
+        Node parseCloseCurly();
+        Node parseCloseParen();
+        Node parseCloseSpiky();
+        Node parseNewLine();
+
+        Node parseLiteral();
+        Node parseIdentifier();
+
+        static Precedence getTokenPrecedence(const Token& token);
+
+        // Returns false when finished
+        std::optional<Node> parseOneNode(Precedence precedence = Precedence::Other);
+
+        public:
+        Parser() = delete;
+        Parser(const std::vector<Token>& input) : input(input) {}
+
+        const Node& parse();
+    };
+
+}