ExpressionParser2Node.h

/*
 * GDevelop Core
 * Copyright 2008-present Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <memory>
#include <vector>
 
#include "ExpressionParser2NodeWorker.h"
#include "GDCore/String.h"
 
namespace gd {
class Expression;
class ObjectsContainer;
class Platform;
class ParameterMetadata;
class ExpressionMetadata;
struct FunctionCallNode;
}  // namespace gd
 
namespace gd {
 
struct GD_CORE_API ExpressionParserLocation {
  ExpressionParserLocation() : isValid(false){};
  ExpressionParserLocation(size_t position)
      : isValid(true), startPosition(position), endPosition(position){};
  ExpressionParserLocation(size_t startPosition_, size_t endPosition_)
      : isValid(true),
        startPosition(startPosition_),
        endPosition(endPosition_){};
  size_t GetStartPosition() const { return startPosition; }
  size_t GetEndPosition() const { return endPosition; }
  bool IsValid() const { return isValid; }
 
 private:
  bool isValid;
  size_t startPosition = 0;
  size_t endPosition = 0;
};
 
struct GD_CORE_API ExpressionParserError {
  enum ErrorType {
    SyntaxError,
    InvalidOperator,
    MismatchedType,
    UndeclaredVariable,
    UnknownIdentifier,
    BracketsNotAllowedForObjects,
    TooFewParameters,
    TooManyParameters,
    InvalidFunctionName,
    MalformedVariableParameter,
    MalformedObjectParameter,
    UnknownParameterType,
    MissingBehavior,
    VariableNameCollision,
    DeprecatedExpression,
  };
 
  ExpressionParserError(gd::ExpressionParserError::ErrorType type_,
                        const gd::String &message_,
                        const ExpressionParserLocation &location_,
                        const gd::String &actualValue_ = "",
                        const gd::String &objectName_ = "")
      : type(type_), message(message_), location(location_),
        actualValue(actualValue_), objectName(objectName_){};
  ExpressionParserError(gd::ExpressionParserError::ErrorType type_,
                        const gd::String &message_, size_t position_)
      : type(type_), message(message_), location(position_){};
  ExpressionParserError(gd::ExpressionParserError::ErrorType type_,
                        const gd::String &message_, size_t startPosition_,
                        size_t endPosition_)
      : type(type_), message(message_),
        location(startPosition_, endPosition_){};
  virtual ~ExpressionParserError(){};
 
  gd::ExpressionParserError::ErrorType GetType() const { return type; }
  const gd::String &GetMessage() { return message; }
  const gd::String &GetObjectName() { return objectName; }
  const gd::String &GetActualValue() { return actualValue; }
  size_t GetStartPosition() { return location.GetStartPosition(); }
  size_t GetEndPosition() { return location.GetEndPosition(); }
 
private:
  gd::ExpressionParserError::ErrorType type;
  gd::String message;
  ExpressionParserLocation location;
  gd::String objectName;
  gd::String actualValue;
};
 
struct GD_CORE_API ExpressionNode {
  ExpressionNode() : parent(nullptr) {};
  virtual ~ExpressionNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker){};
 
  std::unique_ptr<ExpressionParserError> diagnostic;
  ExpressionParserLocation location;  
  ExpressionNode *parent;
};
 
struct GD_CORE_API SubExpressionNode : public ExpressionNode {
  SubExpressionNode(std::unique_ptr<ExpressionNode> expression_)
      : ExpressionNode(), expression(std::move(expression_)){};
  virtual ~SubExpressionNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
    worker.OnVisitSubExpressionNode(*this);
  };
 
  std::unique_ptr<ExpressionNode> expression;
};
 
struct GD_CORE_API OperatorNode : public ExpressionNode {
  OperatorNode(gd::String::value_type op_)
      : ExpressionNode(), op(op_){};
  virtual ~OperatorNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
    worker.OnVisitOperatorNode(*this);
  };
 
  std::unique_ptr<ExpressionNode> leftHandSide;
  std::unique_ptr<ExpressionNode> rightHandSide;
  gd::String::value_type op;
};
 
struct GD_CORE_API UnaryOperatorNode : public ExpressionNode {
  UnaryOperatorNode(gd::String::value_type op_)
      : ExpressionNode(), op(op_){};
  virtual ~UnaryOperatorNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
    worker.OnVisitUnaryOperatorNode(*this);
  };
 
  std::unique_ptr<ExpressionNode> factor;
  gd::String::value_type op;
};
 
struct GD_CORE_API NumberNode : public ExpressionNode {
  NumberNode(const gd::String &number_)
      : ExpressionNode(), number(number_){};
  virtual ~NumberNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
    worker.OnVisitNumberNode(*this);
  };
 
  //
  gd::String number;
};
 
struct GD_CORE_API TextNode : public ExpressionNode {
  TextNode(const gd::String &text_) : ExpressionNode(), text(text_){};
  virtual ~TextNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
    worker.OnVisitTextNode(*this);
  };
 
  gd::String text;
};
 
struct GD_CORE_API IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode
    : public ExpressionNode {
  IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode()
      : ExpressionNode(){};
};
 
struct GD_CORE_API IdentifierNode
    : public IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode {
  IdentifierNode(
  const gd::String &identifierName_)
      : IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode(),
        identifierName(identifierName_),
        childIdentifierName(""){};
  IdentifierNode(
  const gd::String &identifierName_,
  const gd::String &childIdentifierName_)
      : IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode(),
        identifierName(identifierName_),
        childIdentifierName(childIdentifierName_){};
  virtual ~IdentifierNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
    worker.OnVisitIdentifierNode(*this);
  };
 
  gd::String identifierName;  
  gd::String childIdentifierName;  
 
 
  ExpressionParserLocation
      identifierNameLocation;  
  ExpressionParserLocation
      identifierNameDotLocation;  
  ExpressionParserLocation childIdentifierNameLocation;  
};
 
struct GD_CORE_API FunctionCallOrObjectFunctionNameOrEmptyNode
    : public IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode {
  FunctionCallOrObjectFunctionNameOrEmptyNode()
      : IdentifierOrFunctionCallOrObjectFunctionNameOrEmptyNode(){};
  virtual ~FunctionCallOrObjectFunctionNameOrEmptyNode(){};
  void Visit(ExpressionParser2NodeWorker &worker) override{};
};
 
struct GD_CORE_API VariableAccessorOrVariableBracketAccessorNode : public ExpressionNode {
  VariableAccessorOrVariableBracketAccessorNode() : ExpressionNode(){};
 
  std::unique_ptr<VariableAccessorOrVariableBracketAccessorNode> child;
};
 
struct GD_CORE_API VariableNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
  VariableNode(const gd::String &name_)
      : FunctionCallOrObjectFunctionNameOrEmptyNode(), name(name_){};
  virtual ~VariableNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
    worker.OnVisitVariableNode(*this);
  };
 
  gd::String name;
 
  std::unique_ptr<VariableAccessorOrVariableBracketAccessorNode>
      child;  // Can be nullptr if no accessor
 
  ExpressionParserLocation nameLocation;
};
 
struct GD_CORE_API VariableAccessorNode
    : public VariableAccessorOrVariableBracketAccessorNode {
  VariableAccessorNode(const gd::String &name_)
      : VariableAccessorOrVariableBracketAccessorNode(), name(name_){};
  virtual ~VariableAccessorNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
    worker.OnVisitVariableAccessorNode(*this);
  };
 
  gd::String name;
  ExpressionParserLocation nameLocation;
  ExpressionParserLocation dotLocation;
};
 
struct GD_CORE_API VariableBracketAccessorNode
    : public VariableAccessorOrVariableBracketAccessorNode {
  VariableBracketAccessorNode(std::unique_ptr<ExpressionNode> expression_)
      : VariableAccessorOrVariableBracketAccessorNode(), expression(std::move(expression_)){};
  virtual ~VariableBracketAccessorNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
    worker.OnVisitVariableBracketAccessorNode(*this);
  };
 
  std::unique_ptr<ExpressionNode> expression;
};
 
struct GD_CORE_API ObjectFunctionNameNode
    : public FunctionCallOrObjectFunctionNameOrEmptyNode {
  ObjectFunctionNameNode(const gd::String &objectName_,
                         const gd::String &objectFunctionOrBehaviorName_)
      : FunctionCallOrObjectFunctionNameOrEmptyNode(),
        objectName(objectName_),
        objectFunctionOrBehaviorName(objectFunctionOrBehaviorName_) {}
  ObjectFunctionNameNode(const gd::String &objectName_,
                         const gd::String &behaviorName_,
                         const gd::String &behaviorFunctionName_)
      : FunctionCallOrObjectFunctionNameOrEmptyNode(),
        objectName(objectName_),
        objectFunctionOrBehaviorName(behaviorName_),
        behaviorFunctionName(behaviorFunctionName_) {}
  virtual ~ObjectFunctionNameNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
    worker.OnVisitObjectFunctionNameNode(*this);
  };
 
  gd::String objectName;
  gd::String objectFunctionOrBehaviorName;  
  gd::String behaviorFunctionName;          
 
  ExpressionParserLocation
      objectNameLocation;  
  ExpressionParserLocation
      objectNameDotLocation;  
  ExpressionParserLocation objectFunctionOrBehaviorNameLocation;  
  ExpressionParserLocation
      behaviorNameNamespaceSeparatorLocation;  
  ExpressionParserLocation behaviorFunctionNameLocation;  
};
 
struct GD_CORE_API FunctionCallNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
  FunctionCallNode(const gd::String &functionName_)
      : FunctionCallOrObjectFunctionNameOrEmptyNode(),
        functionName(functionName_){};
 
  FunctionCallNode(const gd::String &objectName_,
                   const gd::String &functionName_)
      : FunctionCallOrObjectFunctionNameOrEmptyNode(),
        objectName(objectName_),
        functionName(functionName_){};
 
  FunctionCallNode(const gd::String &objectName_,
                   const gd::String &behaviorName_,
                   const gd::String &functionName_)
      : FunctionCallOrObjectFunctionNameOrEmptyNode(),
        objectName(objectName_),
        behaviorName(behaviorName_),
        functionName(functionName_){};
  virtual ~FunctionCallNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
    worker.OnVisitFunctionCallNode(*this);
  };
 
  gd::String objectName;
  gd::String behaviorName;
  std::vector<std::unique_ptr<ExpressionNode>> parameters;
  gd::String functionName;
 
  ExpressionParserLocation
      functionNameLocation;  
  ExpressionParserLocation
      objectNameLocation;  
  ExpressionParserLocation
      objectNameDotLocation;  
  ExpressionParserLocation
      behaviorNameLocation;  
  ExpressionParserLocation
      behaviorNameNamespaceSeparatorLocation;  
  ExpressionParserLocation
      openingParenthesisLocation;  
  ExpressionParserLocation
      closingParenthesisLocation;  
};
 
struct GD_CORE_API EmptyNode : public FunctionCallOrObjectFunctionNameOrEmptyNode {
  EmptyNode(const gd::String &text_ = "")
      : FunctionCallOrObjectFunctionNameOrEmptyNode(), text(text_){};
  virtual ~EmptyNode(){};
  virtual void Visit(ExpressionParser2NodeWorker &worker) {
    worker.OnVisitEmptyNode(*this);
  };
 
  gd::String text;
};
 
}  // namespace gd