Failing expression for condition

src/Expression.cpp

@@ -127,6 +127,38 @@ string ExpressionGrouping::toString() {
     return "( " + expression->toString() + " )";
 }
 
+//
+// ExpressionIfElse
+ExpressionIfElse::ExpressionIfElse(shared_ptr<Expression> condition, shared_ptr<StatementBlock> thenBlock, shared_ptr<StatementBlock> elseBlock):
+    Expression(Expression::Kind::IF_ELSE), condition(condition), thenBlock(thenBlock), elseBlock(elseBlock) {
+}
+
+shared_ptr<Expression> ExpressionIfElse::getCondition() {
+    return condition;
+}
+
+shared_ptr<StatementBlock> ExpressionIfElse::getThenBlock() {
+    return thenBlock;
+}
+
+shared_ptr<StatementBlock> ExpressionIfElse::getElseBlock() {
+    return elseBlock;
+}
+
+string ExpressionIfElse::toString() {
+    string value = "";
+
+    value += "IF(" + condition->toString() + ")\n";
+    value += thenBlock->toString();
+    if (elseBlock != nullptr) {
+        value += "ELSE\n";
+        value += elseBlock->toString();
+    }
+    value += ";";
+
+    return  value;
+}
+
 //
 // ExpressionInvalid
 ExpressionInvalid::ExpressionInvalid(shared_ptr<Token> token):

src/Expression.h

@@ -2,6 +2,9 @@
 #define EXPRESSION_H
 
 #include "Token.h"
+#include "Statement.h"
+
+class StatementBlock;
 
 using namespace std;
 
@@ -11,6 +14,7 @@ public:
         LITERAL,
         GROUPING,
         BINARY,
+        IF_ELSE,
         INVALID
     };
 
@@ -73,6 +77,20 @@ public:
     string toString() override;
 };
 
+class ExpressionIfElse: public Expression {
+private:
+    shared_ptr<Expression> condition;
+    shared_ptr<StatementBlock> thenBlock;
+    shared_ptr<StatementBlock> elseBlock;
+
+public:
+    ExpressionIfElse(shared_ptr<Expression> condition, shared_ptr<StatementBlock> thenBlock, shared_ptr<StatementBlock> elseBlock);
+    shared_ptr<Expression> getCondition();
+    shared_ptr<StatementBlock> getThenBlock();
+    shared_ptr<StatementBlock> getElseBlock();
+    string toString() override;
+};
+
 class ExpressionInvalid: public Expression {
 private:
     shared_ptr<Token> token;

src/Lexer.cpp

@@ -161,6 +161,14 @@ shared_ptr<Token> Lexer::nextToken() {
     token = match(Token::Kind::SEMICOLON, ";", false);
     if (token != nullptr)
         return token;
+    
+    token = match(Token::Kind::QUESTION_QUESTION, "??", false);
+    if (token != nullptr)
+        return token;
+    
+    token = match(Token::Kind::QUESTION, "?", false);
+    if (token != nullptr)
+        return token;
 
     // keywords
     token = match(Token::Kind::FUNCTION, "fun", true);

src/Parser.cpp

@@ -122,7 +122,17 @@ shared_ptr<StatementInvalid> Parser::matchStatementInvalid() {
 // Expression
 //
 shared_ptr<Expression> Parser::nextExpression() {
-    return matchEquality();
+    shared_ptr<Expression> expression;
+
+    expression = matchEquality();
+    if (expression != nullptr)
+        return expression;
+    
+    expression = matchExpressionIfElse();
+    if (expression != nullptr)
+        return expression;
+
+    return nullptr;
 }
 
 shared_ptr<Expression> Parser::matchEquality() {
@@ -243,6 +253,10 @@ shared_ptr<Expression> Parser::matchExpressionBinary(shared_ptr<Expression> left
     return nullptr;
 }
 
+shared_ptr<Expression> Parser::matchExpressionIfElse() {
+    return nullptr;
+}
+
 shared_ptr<ExpressionInvalid> Parser::matchExpressionInvalid() {
     return make_shared<ExpressionInvalid>(tokens.at(currentIndex));
 }

src/Parser.h

@@ -31,6 +31,7 @@ private:
     shared_ptr<Expression> matchExpressionLiteral();
     shared_ptr<Expression> matchExpressionGrouping();
     shared_ptr<Expression> matchExpressionBinary(shared_ptr<Expression> left);
+    shared_ptr<Expression> matchExpressionIfElse();
     shared_ptr<ExpressionInvalid> matchExpressionInvalid();
 
     bool matchesTokenKinds(vector<Token::Kind> kinds);

src/Statement.h

@@ -6,6 +6,8 @@
 #include "Token.h"
 #include "Expression.h"
 
+class Expression;
+
 using namespace std;
 
 class Statement;

src/Token.cpp

@@ -103,6 +103,10 @@ string Token::toString() {
             return "COLON";
         case SEMICOLON:
             return "SEMICOLON";
+        case QUESTION_QUESTION:
+            return "QUESTION_QUESTION";
+        case QUESTION:
+            return "QUESTION";
 
         case INTEGER:
             return "INTEGER(" + lexme + ")";

src/Token.h

@@ -25,6 +25,8 @@ public:
         RIGHT_PAREN,
         COLON,
         SEMICOLON,
+        QUESTION,
+        QUESTION_QUESTION,
 
         FUNCTION,
         RETURN,