add ExecuteNode

include/rift/nodes/execute.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "node.hpp"
+#include "../value.hpp"
+
+#include <string>
+#include <utility>
+
+namespace rift {
+
+    /// @brief A node in the AST that should be evaluated as a sub-expression. (used for sub-string interpolation)
+    class ExecuteNode : public Node {
+    public:
+        /// @brief Construct the execute node.
+        /// @param child The child node to execute.
+        explicit ExecuteNode(Node* child) : m_child(child) {}
+
+        ~ExecuteNode() override {
+            delete m_child;
+        }
+
+        /// @brief Get the child node to execute.
+        /// @return The child node to execute.
+        [[nodiscard]] const Node* getChild() const { return m_child; }
+
+        /// @copydoc Node::getType
+        [[nodiscard]] Type getType() const override { return Type::Execute; }
+
+        /// @copydoc Node::accept
+        void accept(Visitor* visitor) override;
+
+        /// @copydoc Node::getValue
+        [[nodiscard]] Value getValue(Visitor* visitor) const override;
+
+        /// @copydoc Node::print
+        std::ostream& print(std::ostream& out) const override {
+            out << "ExecuteNode(" << *m_child << ')';
+            return out;
+        }
+
+    private:
+        Node* m_child;
+    };
+
+}

include/rift/nodes/node.hpp

@@ -18,6 +18,7 @@ namespace rift {
             BinaryOp,
             FunctionCall,
             TernaryOp,
+            Execute
         };
 
         /// @brief Destruct the node.

include/rift/parser.hpp

@@ -31,6 +31,8 @@ namespace rift {
      *
      * power                 : call ('^' factor)*
      *
+     * interpolate           : '$' call
+     *
      * call                  : atom ('(' (expression (',' expression)*)? ')')?
      *
      * atom                  : number | string | identifier
@@ -60,14 +62,15 @@ namespace rift {
         // Parse functions
 
         Result<Node*> parseBlock();
-        inline Result<Node*> parseExpression() { return parseTernaryOp(); }
+        Result<Node*> parseExpression() { return parseTernaryOp(); }
         Result<Node*> parseTernaryOp();
         Result<Node*> parseBooleanMath();
         Result<Node*> parseComparisonExpression();
         Result<Node*> parseArithmeticExpression();
         Result<Node*> parseTerm();
         Result<Node*> parseFactor();
         Result<Node*> parsePower();
+        Result<Node*> parseInterpolate();
         Result<Node*> parseCall();
         Result<Node*> parseAtom();
 

include/rift/token.hpp

@@ -20,6 +20,7 @@ namespace rift {
         PLUS, MINUS, STAR, SLASH, PERCENT, CARET,
         QUESTION, COLON, NULL_COALESCE, ASSIGN,
         LESS, GREATER, LESS_EQUAL, GREATER_EQUAL, EQUAL_EQUAL, NOT_EQUAL,
+        DOLLAR,
 
         // Logical operators
         AND, OR, NOT,

include/rift/visitor.hpp

@@ -22,6 +22,10 @@ namespace rift {
         /// @return The value of the variable.
         [[nodiscard]] Value getVariable(const std::string& name) const;
 
+        /// @brief Get all the variables.
+        /// @return The variables.
+        [[nodiscard]] const std::unordered_map<std::string, Value>* getVariables() const { return m_variables; }
+
         /// @brief Visit a node.
         void visit(Node* node);
 
@@ -49,6 +53,9 @@ namespace rift {
         /// @brief Visit a ternary operation node.
         void visit(class TernaryNode* node);
 
+        /// @brief Visit an execute node.
+        void visit(class ExecuteNode* node);
+
         /// @brief Write a string to the output.
         /// @param text The text to write.
         void write(std::string_view text);

src/lexer.cpp

@@ -71,6 +71,7 @@ namespace rift {
                 case '/': return createToken(TokenType::SLASH, "/");
                 case '%': return createToken(TokenType::PERCENT, "%");
                 case '^': return createToken(TokenType::CARET, "^");
+                case '$': return createToken(TokenType::DOLLAR, "$");
                 case ':': {
                     if (peek() == '=') {
                         advance();

src/nodes/execute.cpp

@@ -0,0 +1,17 @@
+#include <rift/nodes/execute.hpp>
+#include <rift/visitor.hpp>
+
+namespace rift {
+
+    void ExecuteNode::accept(Visitor* visitor) {
+        visitor->visit(this);
+    }
+
+    Value ExecuteNode::getValue(Visitor* visitor) const {
+        auto value = m_child->getValue(visitor);
+        if (value.isString()) {
+            return Value::from(rift::format(value.getString(), *visitor->getVariables()));
+        }
+        return value;
+    }
+}

src/parser.cpp

@@ -1,6 +1,7 @@
 #include <rift/parser.hpp>
 
 #include <rift/nodes/binaryop.hpp>
+#include <rift/nodes/execute.hpp>
 #include <rift/nodes/functioncall.hpp>
 #include <rift/nodes/identifier.hpp>
 #include <rift/nodes/segment.hpp>
@@ -175,7 +176,7 @@ namespace rift {
     }
 
     Result<Node*> Parser::parsePower() {
-        auto res = parseCall();
+        auto res = parseInterpolate();
         if (!res) return res;
         auto* expression = res.getValue();
         while (m_currentToken.type == TokenType::CARET) {
@@ -190,6 +191,20 @@ namespace rift {
         return Result<Node*>::success(expression);
     }
 
+    Result<Node*> Parser::parseInterpolate() {
+        if (m_currentToken.type != TokenType::DOLLAR) {
+            return parseCall();
+        }
+        advance();
+        auto res = parseCall();
+        if (!res) {
+            return res;
+        }
+        auto* expression = res.getValue();
+        auto* execute = new ExecuteNode(expression);
+        return Result<Node*>::success(execute);
+    }
+
     Result<Node*> Parser::parseCall() {
         auto res = parseAtom();
         if (m_currentToken.type != TokenType::LEFT_PAREN || !res) {

src/visitor.cpp

@@ -1,6 +1,7 @@
 #include <rift/visitor.hpp>
 
 #include <rift/nodes/binaryop.hpp>
+#include <rift/nodes/execute.hpp>
 #include <rift/nodes/functioncall.hpp>
 #include <rift/nodes/identifier.hpp>
 #include <rift/nodes/root.hpp>
@@ -74,6 +75,11 @@ namespace rift {
         write(value.toString());
     }
 
+    void Visitor::visit(ExecuteNode* node) {
+        auto value = node->getValue(this);
+        write(value.toString());
+    }
+
     const std::string& Visitor::evaluate() {
         for (auto& node : m_script->m_nodes) {
             node->accept(this);

test/main.cpp

@@ -91,6 +91,7 @@ int main() {
         RIFT_TEST_CASE("{duration(123.456)}", "2:03.456");
 
         RIFT_TEST_CASE("{myCustomFunc('World')}", "Hello, World!");
+        RIFT_TEST_CASE("{$'string interpolation: {2 + 2}'}", "string interpolation: 4");
     }
 
     // Show the results