Added parser project

CMakeLists.txt

@@ -18,6 +18,7 @@ add_subdirectory(external/googletest)
 # The order is equivalent to which order they are compiled #
 add_subdirectory(lexer)
 add_subdirectory(ast)
+add_subdirectory(parser)
 
 # Executable directories #
 add_subdirectory(LXC)

Common/modules/Result.h

@@ -74,7 +74,7 @@ namespace LXC::Util
             {}
 
             // Destructor //
-            ~ReturnVal() {}
+            ~ReturnVal() {};
 
             // Different getters of the class //
 

LXC/CMakeLists.txt

@@ -4,6 +4,7 @@ add_executable(LXC LXC.cpp)
 # Links the other binaries #
 target_link_libraries(LXC PRIVATE Lexer)
 target_link_libraries(LXC PRIVATE AST)
+target_link_libraries(LXC PRIVATE Parser)
 
 # Creates the precompiled header for the binary #
 target_include_directories(LXC PRIVATE ${CMAKE_SOURCE_DIR}/common)

LXC/LXC.cpp

@@ -1,6 +1,7 @@
 #include <LXC.h>
 
 #include <NodeTypes.h>
+#include <Parser.h>
 #include <Lexer.h>
 
 int main(int argc, char** argv)
@@ -57,12 +58,17 @@ int main(int argc, char** argv)
         Util::Log("Error occured in Lexer: ", Lexer::LexerError::ReasonStr(err.reason));
         Util::Stop();
     }
-
+    else
-    // Prints all of the tokens to the log //
+    {
+        // Prints all of the tokensto the log //
         for (const auto& token : tokens.Result())
         {
             Util::Log(token);
         }
+    }
+
+    // Turns the tokens into into an abstract syntax tree //
+    Util::ReturnVal functionsAST = Parser::TurnTokensIntoAST(tokens);
 
     return 0;
 }

ast/inc/NodeBase.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <LXC.h>
 
 namespace LXC::AST
@@ -55,6 +57,15 @@ namespace LXC::AST
             {}
     };
 
+    // Typedefs for easier use with the AST //
+    typedef std::unique_ptr<Node> NodePtr;
+    typedef std::unique_ptr<NodeValue> NodeValuePtr;
+    typedef std::vector<NodePtr> SyntaxBranch;
+    typedef std::vector<NodeValuePtr> ValueList;
+
+    // Will be replaced later to account for things like namespaces //
+    typedef std::string Identifier;
+
     // Returns a pointer to the actual type of the node //
     template<typename T>
         requires std::is_base_of_v<Node, T>

ast/inc/NodeTypes.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include <LXC.h>
 
 #include <NodeBase.h>
@@ -5,23 +7,17 @@
 
 namespace LXC::AST
 {
-    // Will be replaced later to account for things like namespaces //
-    typedef std::string Identifier;
-
-    // Foward declares so it can be used in VarDecl //
-    class VarAssignment;
-
     class FunctionCall final : public NodeValue
     {
         public:
-            FunctionCall(Identifier& functionName, std::vector<std::unique_ptr<NodeValue>>& arguments);
+            FunctionCall(Identifier& functionName, ValueList& arguments);
     
         private:
             // The name of the function //
             Identifier m_FuncName;
 
             // The arguments of the function //
-            std::vector<std::unique_ptr<NodeValue>> m_Arguments;
+            ValueList m_Arguments;
     };
 
     class IntLiteral final : public NodeValue
@@ -37,11 +33,11 @@ namespace LXC::AST
     class Operation final : public NodeValue
     {
         public:
-            Operation(std::unique_ptr<NodeValue>& left, Lexer::Token::TokenType operand, std::unique_ptr<NodeValue>& right);
+            Operation(NodeValuePtr& left, Lexer::Token::TokenType operand, NodeValuePtr& right);
 
         private:
             // The sides of the operation //
-            std::unique_ptr<NodeValue> m_Lhs, m_Rhs;
+            NodeValuePtr m_Lhs, m_Rhs;
 
             // The operand of the operation //
             Lexer::Token::TokenType m_Operand;
@@ -51,27 +47,27 @@ namespace LXC::AST
     {
         public:
             VarDeclaration(Identifier& name);
-            VarDeclaration(Identifier& name, std::unique_ptr<VarAssignment>& value);
+            VarDeclaration(Identifier& name, NodeValuePtr& value);
 
         private:
             // The name of the variable //
             Identifier m_Name;
 
             // Default value of the variable (nullable) //
-            std::unique_ptr<VarAssignment> m_Value;
+            NodeValuePtr m_Value;
     };
 
     class VarAssignment final : public Node
     {
         public:
-            VarAssignment(Identifier& name, std::unique_ptr<NodeValue>& value);
+            VarAssignment(Identifier& name, NodeValuePtr& value);
         
         private:
             // The name of the variable //
             Identifier m_Name;
 
             // Value to assign to the variable //
-            std::unique_ptr<NodeValue> m_Value;
+            NodeValuePtr m_Value;
     };
 
     class VarAccess final : public NodeValue
@@ -87,23 +83,23 @@ namespace LXC::AST
     class IfBranch final : public Node
     {
         public:
-            IfBranch(std::unique_ptr<NodeValue>& condition, std::vector<std::unique_ptr<Node>>& body);
+            IfBranch(NodeValuePtr& condition, SyntaxBranch& body);
         
         private:
             // The condition of the branch //
-            std::unique_ptr<NodeValue> m_Condition;
+            NodeValuePtr m_Condition;
 
             // The body of the if-statement //
-            std::vector<std::unique_ptr<Node>> m_Body;
+            SyntaxBranch m_Body;
     };
 
     class ReturnStatement final : public Node
     {
         public:
-            ReturnStatement(std::unique_ptr<NodeValue>& value);
+            ReturnStatement(NodeValuePtr& value);
 
         private:
             // The value to return (nullable) //
-            std::unique_ptr<NodeValue> m_ReturnValue;
+            NodeValuePtr m_ReturnValue;
     };
 }

ast/src/NodeTypes.cpp

@@ -4,7 +4,7 @@
 
 namespace LXC::AST
 {
-    FunctionCall::FunctionCall (Identifier& functionName, std::vector<std::unique_ptr<NodeValue>>& arguments)
+    FunctionCall::FunctionCall (Identifier& functionName, ValueList& arguments)
         : NodeValue(NodeType::FunctionCall), m_FuncName(std::move(functionName)), m_Arguments(std::move(arguments))
     {}
 
@@ -12,7 +12,7 @@ namespace LXC::AST
         : NodeValue(NodeType::IntLiteral), m_NumberValue(std::move(value))
     {}
 
-    Operation::Operation(std::unique_ptr<NodeValue>& left, Lexer::Token::TokenType operand, std::unique_ptr<NodeValue>& right)
+    Operation::Operation(NodeValuePtr& left, Lexer::Token::TokenType operand, NodeValuePtr& right)
         : NodeValue(NodeType::Operation), m_Lhs(std::move(left)), m_Operand(operand), m_Rhs(std::move(right))
     {}
 
@@ -20,11 +20,11 @@ namespace LXC::AST
         : Node(NodeType::Var_Declare), m_Name(std::move(name)), m_Value(nullptr)
     {}
 
-    VarDeclaration::VarDeclaration(Identifier& name, std::unique_ptr<VarAssignment>& value)
+    VarDeclaration::VarDeclaration(Identifier& name, NodeValuePtr& value)
         : Node(NodeType::Var_Declare), m_Name(std::move(name)), m_Value(std::move(value))
     {}
 
-    VarAssignment::VarAssignment(Identifier& name, std::unique_ptr<NodeValue>& value)
+    VarAssignment::VarAssignment(Identifier& name, NodeValuePtr& value)
         : Node(NodeType::Var_Assign), m_Value(std::move(value))
     {}
 
@@ -32,11 +32,11 @@ namespace LXC::AST
         : NodeValue(NodeType::Var_Access), m_Name(std::move(m_Name))
     {}
 
-    IfBranch::IfBranch(std::unique_ptr<NodeValue>& condition, std::vector<std::unique_ptr<Node>>& body)
+    IfBranch::IfBranch(NodeValuePtr& condition, SyntaxBranch& body)
         : Node(NodeType::IfBranch), m_Condition(std::move(condition)), m_Body(std::move(body))
     {}
 
-    ReturnStatement::ReturnStatement(std::unique_ptr<NodeValue>& value)
+    ReturnStatement::ReturnStatement(NodeValuePtr& value)
         : Node(NodeType::ReturnVal), m_ReturnValue(std::move(m_ReturnValue))
     {}
 }

parser/CMakeLists.txt

@@ -0,0 +1,18 @@
+# Fetches all .cpp files for the binary #
+add_library(Parser STATIC
+	src/Parser.cpp
+ "inc/Parser.h")
+
+# Adds the headers in the current directory #
+target_include_directories (
+	Parser PUBLIC
+	${CMAKE_CURRENT_SOURCE_DIR}/inc
+)
+
+# Links to the Lexer and AST so it can use their data types #
+target_link_libraries(Parser PUBLIC Lexer)
+target_link_libraries(Parser PUBLIC AST)
+
+# Creates the precompiled header of the binary #
+target_include_directories(Parser PRIVATE ${CMAKE_SOURCE_DIR}/common)
+target_precompile_headers(Parser PRIVATE ${CMAKE_SOURCE_DIR}/common/LXC.h)

parser/inc/Parser.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <LXC.h>
+
+#include <NodeTypes.h>
+#include <Lexer.h>
+
+namespace LXC::Parser
+{
+    struct ParserError {};
+
+    struct FunctionAST
+    {
+        std::string name;
+        AST::SyntaxBranch contents;
+    };
+
+    Util::ReturnVal<std::vector<FunctionAST>, ParserError> TurnTokensIntoAST(const Lexer::LexerOutput& input);
+}

parser/src/Parser.cpp

@@ -0,0 +1,11 @@
+#include <LXC.h>
+
+#include <Parser.h>
+
+namespace LXC::Parser
+{
+    Util::ReturnVal<std::vector<FunctionAST>, ParserError> TurnTokensIntoAST(const Lexer::LexerOutput& input)
+    {
+        return Util::FunctionFail<ParserError>();
+    }
+}