From cbd8daf2195c8d3de6d732a8089aff2d58eeb92c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Rafa=C5=82=20Grodzi=C5=84ski?= <rafal.grodzinski@gmail.com>
Date: Wed, 18 Jun 2025 15:31:04 +0900
Subject: [PATCH] Parse function call

---
 src/Expression.cpp | 28 ++++++++++++++++++++++++++++
 src/Expression.h   | 14 ++++++++++++++
 src/Parser.cpp     | 31 ++++++++++++++++++++++++++++++-
 src/Parser.h       |  1 +
 src/Types.h        |  1 +
 5 files changed, 74 insertions(+), 1 deletion(-)

diff --git a/src/Expression.cpp b/src/Expression.cpp
index 9b0ea31..b85d8df 100644
--- a/src/Expression.cpp
+++ b/src/Expression.cpp
@@ -246,6 +246,34 @@ string ExpressionVar::toString(int indent) {
     return "VAR(" + name + ")";
 }
 
+//
+// Expression Call
+ExpressionCall::ExpressionCall(string name, vector<shared_ptr<Expression>> argumentExpressions):
+Expression(ExpressionKind::CALL, ValueType::NONE), name(name), argumentExpressions(argumentExpressions) {
+}
+
+string ExpressionCall::getName() {
+    return name;
+}
+
+vector<shared_ptr<Expression>> ExpressionCall::getArgumentExpressions() {
+    return argumentExpressions;
+}
+
+string ExpressionCall::toString(int indent) {
+    string value;
+
+    value += "CALL(" + name + "):";
+    for (shared_ptr<Expression> &argumentExpression : argumentExpressions) {
+        value += "\n";
+        for (int ind=0; ind<indent+1; ind++)
+            value += "  ";
+        value += argumentExpression->toString(indent+1) + ",";
+    }
+
+    return value;
+}
+
 //
 // ExpressionInvalid
 ExpressionInvalid::ExpressionInvalid(shared_ptr<Token> token):
diff --git a/src/Expression.h b/src/Expression.h
index 9100629..6f3ec75 100644
--- a/src/Expression.h
+++ b/src/Expression.h
@@ -114,6 +114,20 @@ public:
     string toString(int indent) override;
 };
 
+//
+// Expression Call
+class ExpressionCall: public Expression {
+private:
+    string name;
+    vector<shared_ptr<Expression>> argumentExpressions;
+
+public:
+    ExpressionCall(string name, vector<shared_ptr<Expression>> argumentExpressions);
+    string getName();
+    vector<shared_ptr<Expression>> getArgumentExpressions();
+    string toString(int indent) override;
+};
+
 //
 // ExpressionInvalid
 class ExpressionInvalid: public Expression {
diff --git a/src/Parser.cpp b/src/Parser.cpp
index 7b8f513..e6f8492 100644
--- a/src/Parser.cpp
+++ b/src/Parser.cpp
@@ -264,6 +264,10 @@ shared_ptr<Expression> Parser::matchPrimary() {
     expression = matchExpressionLiteral();
     if (expression != nullptr)
         return expression;
+        
+    expression = matchExpressionCall();
+    if (expression != nullptr)
+        return expression;
     
     expression = matchExpressionVar();
     if (expression != nullptr)
@@ -359,7 +363,7 @@ shared_ptr<Expression> Parser::matchExpressionIfElse() {
     shared_ptr<Statement> elseBlock;
     if (tryMatchingTokenKinds({TokenKind::COLON}, true, true)) {
         bool isSingleLine = !tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true);
-        vector<TokenKind> terminalTokens = {TokenKind::SEMICOLON};
+        vector<TokenKind> terminalTokens = {TokenKind::SEMICOLON, TokenKind::COMMA, TokenKind::RIGHT_PAREN};
         if (isSingleLine)
             terminalTokens.push_back(TokenKind::NEW_LINE);
 
@@ -383,6 +387,31 @@ shared_ptr<Expression> Parser::matchExpressionVar() {
     return nullptr;
 }
 
+shared_ptr<Expression> Parser::matchExpressionCall() {
+    if (!tryMatchingTokenKinds({TokenKind::IDENTIFIER, TokenKind::LEFT_PAREN}, true, false))
+        return nullptr;
+
+    shared_ptr<Token> identifierToken = tokens.at(currentIndex);
+    currentIndex++; // identifier
+    currentIndex++; // left parenthesis
+
+    vector<shared_ptr<Expression>> argumentExpressions;
+    do {
+        tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // optional new line
+
+        shared_ptr<Expression> argumentExpression = nextExpression();
+        if (argumentExpression == nullptr || !argumentExpression->isValid())
+            return argumentExpression;
+        argumentExpressions.push_back(argumentExpression);
+    } while (tryMatchingTokenKinds({TokenKind::COMMA}, true, true));
+
+    tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true); // optional new line
+    if (!tryMatchingTokenKinds({TokenKind::RIGHT_PAREN}, true, true))
+        return matchExpressionInvalid();
+
+    return make_shared<ExpressionCall>(identifierToken->getLexme(), argumentExpressions);
+}
+
 shared_ptr<ExpressionInvalid> Parser::matchExpressionInvalid() {
     return make_shared<ExpressionInvalid>(tokens.at(currentIndex));
 }
diff --git a/src/Parser.h b/src/Parser.h
index f25faad..ee5eb38 100644
--- a/src/Parser.h
+++ b/src/Parser.h
@@ -34,6 +34,7 @@ private:
     shared_ptr<Expression> matchExpressionBinary(shared_ptr<Expression> left);
     shared_ptr<Expression> matchExpressionIfElse();
     shared_ptr<Expression> matchExpressionVar();
+    shared_ptr<Expression> matchExpressionCall();
     shared_ptr<ExpressionInvalid> matchExpressionInvalid();
 
     bool tryMatchingTokenKinds(vector<TokenKind> kinds, bool shouldMatchAll, bool shouldAdvance);
diff --git a/src/Types.h b/src/Types.h
index 9bbe44a..547efdf 100644
--- a/src/Types.h
+++ b/src/Types.h
@@ -46,6 +46,7 @@ enum class ExpressionKind {
     BINARY,
     IF_ELSE,
     VAR,
+    CALL,
     INVALID
 };