added expression parsing

.clang-format

@@ -0,0 +1,28 @@
+---
+Language:        Cpp
+BasedOnStyle:    Google
+
+# Basic Formatting
+IndentWidth:     4
+ColumnLimit:     100
+TabWidth:        4
+UseTab:          Never
+
+# Braces and Spacing
+BreakBeforeBraces: Attach
+AllowShortBlocksOnASingleLine: Empty
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+
+# Pointers and References (e.g., int* ptr instead of int *ptr)
+PointerAlignment: Left
+
+# Alignment for readability
+AlignConsecutiveAssignments: true
+AlignConsecutiveDeclarations: false
+AlignOperands:   Align
+AlignTrailingComments: true
+
+# Includes
+SortIncludes:    true

.gitignore

@@ -1,6 +1,9 @@
 #build directory
 build/
 
+# Config files
+.vscode
+
 # Prerequisites
 *.d
 

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "makefile.configureOnOpen": true
+}

Makefile

@@ -33,10 +33,16 @@ $(BUILD_DIR)/%.o: $(SRC_DIR)/%.cpp
 #for change in header files
 -include $(DEPS)
 
-.PHONY: all clean run
+.PHONY: all clean run format check-format
 
 run: all
 	./$(BUILD_DIR)/$(TARGET_EXEC)
 
 clean:
 	rm -rf $(BUILD_DIR)
+
+format:
+	find $(SRC_DIR)/ -name '*.cpp' -o -name '*.h' | xargs clang-format -i
+
+check-format:
+	find $(SRC_DIR)/ -name '*.cpp' -o -name '*.h' | xargs clang-format --dry-run --Werror

src/common/ast/astexpr.cpp

@@ -0,0 +1,22 @@
+#include "astexpr.hpp"
+
+ASTExprNode::ASTExprNode(ASTExprNodeType type) : type(type) {}
+
+BinaryOperatorNode::BinaryOperatorNode(OperatorType op, std::unique_ptr<ASTExprNode> lhs,
+                                       std::unique_ptr<ASTExprNode> rhs)
+    : ASTExprNode(ASTExprNodeType::BINARY), op(op), lhs(std::move(lhs)), rhs(std::move(rhs)) {}
+
+UnaryOperatorNode::UnaryOperatorNode(OperatorType op, std::unique_ptr<ASTExprNode> rhs)
+    : ASTExprNode(ASTExprNodeType::UNARY), op(op), rhs(std::move(rhs)) {}
+
+StringNode::StringNode(std::string value)
+    : ASTExprNode(ASTExprNodeType::STRING), value(std::move(value)) {}
+
+NumberNode::NumberNode(double value) : ASTExprNode(ASTExprNodeType::NUMBER), value(value) {}
+
+BooleanNode::BooleanNode(bool value) : ASTExprNode(ASTExprNodeType::BOOLEAN), value(value) {}
+
+NoneNode::NoneNode() : ASTExprNode(ASTExprNodeType::NONE) {}
+
+ReferenceNode::ReferenceNode(std::string name)
+    : ASTExprNode(ASTExprNodeType::REFERENCE), name(std::move(name)) {}

src/common/ast/astexpr.hpp

@@ -0,0 +1,104 @@
+#pragma once
+
+#include <string>
+#include <memory>
+
+enum class ASTExprNodeType {
+    BINARY, //binary operators
+    UNARY, //unary operators
+    STRING, //string literals
+    NUMBER, //number literals
+    BOOLEAN, //boolean literals
+    NONE, //None
+    REFERENCE //variable(identifier) references
+};
+
+enum class OperatorType {
+    //logical
+    OR, // or
+    AND, // and
+    NOT, // not
+
+    //comparisons
+    GREATERTHAN, // >
+    GREATEREQUAL, // >=
+    LESSEQUAL, // <=
+    LESSERTHAN, // <
+    EQEQUAL, // ==
+    NOTEQUAL, // !=
+
+    //additive/unary
+    PLUS, // +
+    MINUS, // -
+
+    //multiplicative
+    STAR, // *
+    SLASH, // /
+    DOUBLESLASH, // //
+    MODULO, // %
+
+    //power
+    POWER, // **
+};
+
+//abstract ASTExprNode class
+class ASTExprNode {
+public:
+    ASTExprNode(ASTExprNodeType type);
+    virtual ~ASTNode() = default;
+
+    //type
+    ASTExprNodeType type;
+};
+
+class BinaryOperatorNode : public ASTExprNode {
+public:
+    BinaryOperatorNode(OperatorType op, std::unique_ptr<ASTExprNode> lhs, std::unique_ptr<ASTExprNode> rhs);
+
+    //operator type
+    OperatorType op;
+    std::unique_ptr<ASTExprNode> lhs;
+    std::unique_ptr<ASTExprNode> rhs;
+};
+
+class UnaryOperatorNode : public ASTExprNode {
+public:
+    UnaryOperatorNode(OperatorType op, std::unique_ptr<ASTExprNode> rhs);
+
+    //operator type
+    OperatorType op;
+    std::unique_ptr<ASTExprNode> rhs;
+};
+
+class StringNode : public ASTExprNode {
+public:
+    StringNode(std::string value);
+
+    std::string value;
+};
+
+class NumberNode : public ASTExprNode {
+public:
+    NumberNode(double value);
+
+    double value;
+};
+
+class BooleanNode : public ASTExprNode {
+public:
+    BooleanNode(bool value);
+
+    bool value;
+}
+
+class NoneNode : public ASTExprNode {
+public:
+    NoneNode();
+}
+
+class ReferenceNode : public ASTExprNode {
+public:
+    ReferenceNode(std::string name);
+
+    std::string name;
+};

src/common/token/token.cpp

@@ -0,0 +1,6 @@
+#include "token.hpp"
+
+#include <string>
+
+Token::Token(TokenType type, std::string val, int l, int c)
+    : type(type), value(val), line(l), column(c) {}

src/common/token/token.hpp

@@ -33,7 +33,11 @@ enum class TokenType {
     COLON, // :
     INDENT,
     DEDENT,
-    COMMENT // #
+    COMMENT, // #
+    PRINT,
+    AMPERSAND, // &
+    PIPE, // |
+    SPACE,
 };
 
 

src/lexer/keywords.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <unordered_map>
+#include <string>
+#include <vector>
+
+#include "token.hpp"
+
+inline const std::unordered_map<std::string, TokenType> keywords = {
+        {"def",    TokenType::DEF},
+        {"return", TokenType::RETURN},
+        {"if",     TokenType::IF},
+        {"else",   TokenType::ELSE},
+        {"print",  TokenType::PRINT},
+        {"=",      TokenType::ASSIGN},
+        {"+",      TokenType::PLUS},
+        {"-",      TokenType::MINUS},
+        {"*",      TokenType::STAR},
+        {"/",      TokenType::SLASH},
+        {"(",      TokenType::LPAREN},
+        {")",      TokenType::RPAREN},
+        {":",      TokenType::COLON},
+        {",",      TokenType::COMMA},
+        {"\n",     TokenType::NEWLINE},
+        {"\t",     TokenType::INDENT},
+        {" ",     TokenType::SPACE}
+    };