Added grouping

src/Expression.cpp

@@ -7,6 +7,8 @@ Expression::Expression(Kind kind, Token token, shared_ptr<Expression> left, shar
         case LITERAL:
             setupLiteral(token);
             break;
+        case GROUPING:
+            setupGrouping(token, left);
         case BINARY:
             setupBinary(token, left, right);
             break;
@@ -24,6 +26,17 @@ void Expression::setupLiteral(Token token) {
     integer = stoi(token.getLexme());
 }
 
+void Expression::setupGrouping(Token token, shared_ptr<Expression> expression) {
+    bool isKindValid = token.getKind() == Token::Kind::LEFT_PAREN;
+    bool isExpressionValid = expression != nullptr && expression->getKind() != Kind::INVALID;
+
+    if (!isKindValid || !isExpressionValid)
+        return;
+    
+    kind = GROUPING;
+    left = expression;
+}
+
 void Expression::setupBinary(Token token, shared_ptr<Expression> left, shared_ptr<Expression> right) {
     bool isKindValid = token.isOneOf({Token::Kind::PLUS, Token::Kind::MINUS, Token::Kind::STAR, Token::Kind::SLASH, Token::Kind::PERCENT});
     bool isLeftValid = left != nullptr && left->getKind() != Kind::INVALID;
@@ -90,6 +103,8 @@ std::string Expression::toString() {
     switch (kind) {
         case LITERAL:
             return to_string(integer);
+        case GROUPING:
+            return "<( " + left->toString() + " )>";
         case BINARY:
             switch (operation) {
                 case ADD:

src/Expression.h

@@ -9,6 +9,7 @@ class Expression {
 public:
     enum Kind {
         LITERAL,
+        GROUPING,
         BINARY,
         INVALID
     };
@@ -30,6 +31,7 @@ private:
     shared_ptr<Expression> right = nullptr;
 
     void setupLiteral(Token token);
+    void setupGrouping(Token token, shared_ptr<Expression> expression);
     void setupBinary(Token token, shared_ptr<Expression> left, shared_ptr<Expression> right);
 
 public:

src/ModuleBuilder.cpp

@@ -16,6 +16,8 @@ llvm::Value *ModuleBuilder::valueForExpression(shared_ptr<Expression> expression
     switch (expression->getKind()) {
         case Expression::Kind::LITERAL:
             return llvm::ConstantInt::get(int32Type, expression->getInteger(), true);
+        case Expression::Kind::GROUPING:
+            return valueForExpression(expression->getLeft());
         case Expression::Kind::BINARY:
             llvm::Value *leftValue = valueForExpression(expression->getLeft());
             llvm::Value *rightValue = valueForExpression(expression->getRight());

src/Parser.cpp

@@ -33,7 +33,9 @@ shared_ptr<Expression> Parser::primary() {
     do {
         if((expression = matchInteger()) != Expression::Invalid)
             break;
-    
+        
+        if((expression = matchGrouping()) != Expression::Invalid)
+            break;
     } while(false);
 
     return expression;
@@ -49,6 +51,20 @@ shared_ptr<Expression> Parser::matchInteger() {
     return Expression::Invalid;
 }
 
+shared_ptr<Expression> Parser::matchGrouping() {
+    Token token = tokens.at(currentIndex);
+    if (token.getKind() == Token::Kind::LEFT_PAREN) {
+        currentIndex++;
+        shared_ptr<Expression> expression = term();
+        if (tokens.at(currentIndex).getKind() == Token::Kind::RIGHT_PAREN) {
+            currentIndex++;
+            return make_shared<Expression>(Expression::Kind::GROUPING, token, expression, nullptr);
+        }
+    }
+
+    return Expression::Invalid;
+}
+
 shared_ptr<Expression> Parser::matchBinary(shared_ptr<Expression> left) {
     Token token = tokens.at(currentIndex);
     if (token.isOneOf({Token::Kind::PLUS, Token::Kind::MINUS, Token::Kind::STAR, Token::Kind::SLASH, Token::Kind::PERCENT})) {

src/Parser.h

@@ -17,6 +17,7 @@ private:
     shared_ptr<Expression> primary();
 
     shared_ptr<Expression> matchInteger();
+    shared_ptr<Expression> matchGrouping();
     shared_ptr<Expression> matchBinary(shared_ptr<Expression> left);
 
 public:

src/Token.cpp

@@ -43,7 +43,7 @@ std::string Token::toString() {
         case PERCENT:
             return "PERCENT";
         case LEFT_PAREN:
-            return "LEFT_PARENT";
+            return "LEFT_PAREN";
         case RIGHT_PAREN:
             return "RIGHT_PAREN";
         case DOT: