Merge pull request #30 from sQeeZ-scripting-language/29-callback-functions

29 callback functions

Author: marcelnoehre

include/parser/ast_nodes.hpp

@@ -25,6 +25,7 @@ enum class NodeType {
   // EXPRESSIONS
   AssignmentExpr,
   CompoundAssignmentExpr,
+  CallbackFunctionExpr,
   TernaryExpr,
   BinaryExpr,
   UnaryExpr,
@@ -433,6 +434,37 @@ class CompoundAssignmentExpr : public Expr {
   }
 };
 
+class CallbackFunctionExpr : public Expr {
+public:
+  std::vector<Token> parameters;
+  std::vector<std::unique_ptr<Stmt>> body;
+
+  CallbackFunctionExpr(std::vector<Token> parameters, std::vector<std::unique_ptr<Stmt>> body)
+      : Expr(NodeType::CallbackFunctionExpr), parameters(std::move(parameters)), body(std::move(body)) {}
+
+  CallbackFunctionExpr(const CallbackFunctionExpr&) = delete;
+  CallbackFunctionExpr& operator=(const CallbackFunctionExpr&) = delete;
+  CallbackFunctionExpr(CallbackFunctionExpr&&) noexcept = default;
+  CallbackFunctionExpr& operator=(CallbackFunctionExpr&&) noexcept = default;
+
+  std::string toString() const override {
+    std::ostringstream oss;
+    oss << "CallbackFunctionExpr: (";
+    for (size_t i = 0; i < parameters.size(); ++i) {
+      oss << parameters[i].value;
+      if (i < parameters.size() - 1) {
+        oss << ", ";
+      }
+    }
+    oss << ") {\n";
+    for (const auto& stmt : body) {
+      oss << "  " << stmt->toString() << "\n";
+    }
+    oss << "}";
+    return oss.str();
+  }
+};
+
 class TernaryExpr : public Expr {
 public:
   std::unique_ptr<Expr> condition;

include/parser/parser.hpp

@@ -40,6 +40,7 @@ class Parser {
   std::unique_ptr<Expr> parsePipeExpr();
   std::unique_ptr<Expr> parseObjectExpr();
   std::unique_ptr<Expr> parseArrayExpr();
+  std::unique_ptr<Expr> parseCallbackFunctionExpr();
   std::unique_ptr<Expr> parseShortData();
   std::unique_ptr<Expr> parseAdditiveExpr();
   std::unique_ptr<Expr> parseMultiplicativeExpr();
@@ -55,6 +56,7 @@ class Parser {
   // Utility functions
   bool isEOF();
   Token peek(int steps = 1);
+  Token lookAhead(int steps);
   Token advance();
   Token assertToken(const std::string& expected, const std::string& errorMessage);
   void log(const std::unique_ptr<Program>& program, bool devMode);

src/parser/parser.cpp

@@ -405,6 +405,28 @@ std::unique_ptr<Expr> Parser::parseArrayExpr() {
   return std::make_unique<ArrayLiteral>(std::move(elements));
 }
 
+std::unique_ptr<Expr> Parser::parseCallbackFunctionExpr() {
+  std::vector<Token> params;
+  while (!(peek().tag == Token::TypeTag::SYNTAX && peek().type.syntaxToken == SyntaxToken::CLOSE_PARENTHESIS)) {
+    if (params.size() > 0) {
+      assertToken("SyntaxToken::COMMA", "Expected comma between callback function parameters.");
+    }
+    params.push_back(assertToken("DataToken::IDENTIFIER", "Expected identifier in callback function parameters."));
+  }
+  assertToken("SyntaxToken::CLOSE_PARENTHESIS", "Expected closing parenthesis after callback function parameters.");
+  assertToken("SyntaxToken::CALLBACK", "Expected '=>' to start callback function body.");
+  std::vector<std::unique_ptr<Stmt>> body = {};
+  if (peek().tag == Token::TypeTag::SYNTAX && peek().type.syntaxToken == SyntaxToken::OPEN_BRACE) {
+    assertToken("SyntaxToken::OPEN_BRACE", "Expected '{' to start callback function body.");
+    body = parseStatementBlock();
+  } else {
+    body.push_back(parseStatement());
+    skipSemicolon();
+  }
+  skipSemicolon();
+  return std::make_unique<CallbackFunctionExpr>(std::move(params), std::move(body));
+}
+
 std::unique_ptr<Expr> Parser::parseShortData() {
   assertToken("SyntaxToken::AT", "Expected '@' to start short data notation.");
   // Short Notation -> Object @ key:value, key:value
@@ -598,12 +620,31 @@ std::unique_ptr<Expr> Parser::parsePrimaryExpr() {
   } else if (token.tag == Token::TypeTag::SYNTAX) {
     std::unique_ptr<Expr> expression;
     std::string value;
+    int i, scope = 0;
     switch (token.type.syntaxToken) {
       case SyntaxToken::OPEN_PARENTHESIS:
         assertToken("SyntaxToken::OPEN_PARENTHESIS", "Expected '(' to start parenthesised expression.");
-        expression = parseExpression();
-        assertToken("SyntaxToken::CLOSE_PARENTHESIS",
-                    "Unexpected token found inside parenthesised expression. Expected closing parenthesis.");
+        while (true) {
+          i++;
+          if (lookAhead(i).tag == Token::TypeTag::SYNTAX &&
+              lookAhead(i).type.syntaxToken == SyntaxToken::OPEN_PARENTHESIS) {
+            scope++;
+          } else if (lookAhead(i).tag == Token::TypeTag::SYNTAX &&
+                     lookAhead(i).type.syntaxToken == SyntaxToken::CLOSE_PARENTHESIS) {
+            if (scope == 0) {
+              break;
+            }
+            scope--;
+          }
+        }
+        if (lookAhead(i + 1).tag == Token::TypeTag::SYNTAX &&
+            lookAhead(i + 1).type.syntaxToken == SyntaxToken::CALLBACK) {
+          expression = parseCallbackFunctionExpr();
+        } else {
+          expression = parseExpression();
+          assertToken("SyntaxToken::CLOSE_PARENTHESIS",
+                      "Unexpected token found inside parenthesised expression. Expected closing parenthesis.");
+        }
         return expression;
       case SyntaxToken::DOUBLE_QUOTE:
         assertToken("SyntaxToken::DOUBLE_QUOTE", "Expected opening double quote");
@@ -731,6 +772,14 @@ Token Parser::peek(int steps) {
   }
 }
 
+Token Parser::lookAhead(int steps) {
+  if (tokens.size() < steps) {
+    throw std::runtime_error("Unexpected end of file");
+  } else {
+    return tokens[steps - 1];
+  }
+}
+
 Token Parser::advance() {
   Token token = tokens.front();
   tokens.erase(tokens.begin());