Pasha/LXC
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added parser project

Browse Source
This commit is contained in:
Pasha Bibko
2025-07-23 19:33:33 +01:00
parent 6a534ba635
commit 86a178b7d5
10 changed files with 93 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@@ -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)

2
Common/modules/Result.h
View File

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

1
LXC/CMakeLists.txt
View File

@@ -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)

8
LXC/LXC.cpp
View File

@@ -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 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;
}

11
ast/inc/NodeBase.h
View File

@@ -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>

34
ast/inc/NodeTypes.h
View File

@@ -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;
};
}

12
ast/src/NodeTypes.cpp
View File

@@ -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))
{}
}

18
parser/CMakeLists.txt Normal file
View File

@@ -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)

19
parser/inc/Parser.h Normal file
View File

@@ -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);
}

11
parser/src/Parser.cpp Normal file
View File

@@ -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>();
}
}