EventsCodeGenerator.h

/*
 * GDevelop Core
 * Copyright 2008-present Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <set>
#include <utility>
#include <vector>
 
#include "GDCore/Events/CodeGeneration/DiagnosticReport.h"
#include "GDCore/Events/Event.h"
#include "GDCore/Events/Instruction.h"
#include "GDCore/Project/ProjectScopedContainers.h"
#include "GDCore/String.h"
 
namespace gd {
class EventsList;
class Expression;
class Project;
class Layout;
class ObjectsContainer;
class ObjectsContainersList;
class ExternalEvents;
class ParameterMetadata;
class ObjectMetadata;
class BehaviorMetadata;
class InstructionMetadata;
class EventsCodeGenerationContext;
class ExpressionCodeGenerationInformation;
class InstructionMetadata;
class Platform;
}  // namespace gd
 
namespace gd {
 
class GD_CORE_API EventsCodeGenerator {
  friend class ExpressionCodeGenerator;
 
 public:
  static void DeleteUselessEvents(gd::EventsList& events);
 
  EventsCodeGenerator(const gd::Project& project_,
                      const gd::Layout& layout,
                      const gd::Platform& platform_);
 
  EventsCodeGenerator(
      const gd::Platform& platform,
      const gd::ProjectScopedContainers& projectScopedContainers_);
  virtual ~EventsCodeGenerator() {};
 
  void PreprocessEventList(gd::EventsList& listEvent);
 
  virtual gd::String GenerateEventsListCode(
      gd::EventsList& events, EventsCodeGenerationContext& context);
 
  virtual gd::String GenerateConditionsListCode(
      gd::InstructionsList& conditions, EventsCodeGenerationContext& context);
 
  virtual gd::String GenerateActionsListCode(
      gd::InstructionsList& actions, EventsCodeGenerationContext& context);
 
  std::vector<gd::String> GenerateParametersCodes(
      const std::vector<gd::Expression>& parameters,
      const ParameterMetadataContainer& parametersInfo,
      EventsCodeGenerationContext& context,
      std::vector<std::pair<gd::String, gd::String> >*
          supplementaryParametersTypes = 0);
 
  gd::String GenerateConditionCode(gd::Instruction& condition,
                                   gd::String returnBoolean,
                                   EventsCodeGenerationContext& context);
 
  gd::String GenerateActionCode(
      gd::Instruction& action,
      EventsCodeGenerationContext& context,
      const gd::String& optionalAsyncCallbackName = "",
      const gd::String& optionalAsyncCallbackId = "");
 
  struct CallbackDescriptor {
    CallbackDescriptor(const gd::String functionName_,
                       const gd::String argumentsList_,
                       const std::set<gd::String> requiredObjects_)
        : functionName(functionName_),
          argumentsList(argumentsList_),
          requiredObjects(requiredObjects_) {};
    const gd::String functionName;
    const gd::String argumentsList;
    const std::set<gd::String> requiredObjects;
  };
 
  virtual const CallbackDescriptor GenerateCallback(
      const gd::String& callbackFunctionName,
      gd::EventsCodeGenerationContext& parentContext,
      gd::InstructionsList& actions,
      gd::EventsList* subEvents = nullptr);
 
  const gd::String GenerateEventsParameters(
      const gd::EventsCodeGenerationContext& context);
 
  virtual gd::String GenerateObjectsDeclarationCode(
      EventsCodeGenerationContext& context);
 
  static gd::String ConvertToString(gd::String plainString);
 
  static gd::String ConvertToStringExplicit(gd::String plainString);
 
  void AddIncludeFile(gd::String file) {
    if (!file.empty()) includeFiles.insert(file);
  };
 
  void AddIncludeFiles(std::vector<gd::String> files) {
    for (std::size_t i = 0; i < files.size(); ++i) AddIncludeFile(files[i]);
  };
 
  void AddGlobalDeclaration(gd::String declaration) {
    customGlobalDeclarations.insert(declaration);
  };
 
  void AddCustomCodeOutsideMain(gd::String code) {
    customCodeOutsideMain += code;
  };
 
  const std::set<gd::String>& GetIncludeFiles() const { return includeFiles; }
 
  const gd::String& GetCustomCodeOutsideMain() const {
    return customCodeOutsideMain;
  }
 
  const std::set<gd::String>& GetCustomGlobalDeclaration() const {
    return customGlobalDeclarations;
  }
 
  bool GenerateCodeForRuntime() { return compilationForRuntime; }
 
  void SetGenerateCodeForRuntime(bool compilationForRuntime_) {
    compilationForRuntime = compilationForRuntime_;
  }
 
  void ReportError();
 
  bool ErrorOccurred() const { return errorOccurred; };
 
  const gd::ObjectsContainersList& GetObjectsContainersList() const {
    return projectScopedContainers.GetObjectsContainersList();
  };
 
  const gd::ProjectScopedContainers& GetProjectScopedContainers() const {
    return projectScopedContainers;
  }
 
  gd::ProjectScopedContainers& GetProjectScopedContainers() {
    return projectScopedContainers;
  }
 
  bool HasProjectAndLayout() const { return hasProjectAndLayout; }
 
  const gd::Project& GetProject() const { return *project; }
 
  const gd::Layout& GetLayout() const { return *scene; }
 
  const gd::Platform& GetPlatform() const { return platform; }
 
  size_t GetMaxCustomConditionsDepth() const {
    return maxCustomConditionsDepth;
  }
 
  size_t GetMaxConditionsListsSize() const { return maxConditionsListsSize; }
 
  void SetDiagnosticReport(gd::DiagnosticReport* diagnosticReport_) {
    diagnosticReport = diagnosticReport_;
  }
 
  gd::DiagnosticReport* GetDiagnosticReport() { return diagnosticReport; }
 
  virtual gd::String GenerateBooleanFullName(
      const gd::String& boolName,
      const gd::EventsCodeGenerationContext& context) {
    return boolName;
  }
 
  virtual gd::String GenerateUpperScopeBooleanFullName(
      const gd::String& boolName,
      const gd::EventsCodeGenerationContext& context) {
    return boolName;
  }
 
  virtual gd::String GenerateBooleanInitializationToFalse(
      const gd::String& boolName,
      const gd::EventsCodeGenerationContext& context) {
    return "bool " + boolName + " = false;\n";
  }
 
  virtual gd::String GetObjectListName(
      const gd::String& name, const gd::EventsCodeGenerationContext& context);
 
  virtual gd::String GenerateProfilerSectionBegin(const gd::String& section) {
    return "";
  };
 
  virtual gd::String GenerateProfilerSectionEnd(const gd::String& section) {
    return "";
  };
 
  virtual gd::String GetCodeNamespaceAccessor() { return ""; };
 
  virtual gd::String GetCodeNamespace() { return ""; };
 
  enum VariableScope {
    LAYOUT_VARIABLE = 0,
    PROJECT_VARIABLE,
    OBJECT_VARIABLE,
    ANY_VARIABLE,
    VARIABLE_OR_PROPERTY,
    VARIABLE_OR_PROPERTY_OR_PARAMETER
  };
 
  size_t GenerateSingleUsageUniqueIdFor(const gd::Instruction* instruction);
 
  size_t GenerateSingleUsageUniqueIdForEventsList();
 
  virtual gd::String GenerateRelationalOperation(
      const gd::String& relationalOperator,
      const gd::String& lhs,
      const gd::String& rhs);
 
  virtual gd::String GenerateLocalVariablesStackAccessor();
 
  gd::String GenerateAnyOrSceneVariableGetter(
      const gd::Expression& variableExpression,
      EventsCodeGenerationContext& context);
 
  virtual gd::String GeneratePropertySetterWithoutCasting(
      const gd::PropertiesContainer& propertiesContainer,
      const gd::NamedPropertyDescriptor& property,
      const gd::String& operandCode);
 
 protected:
  virtual const gd::String GenerateRelationalOperatorCodes(
      const gd::String& operatorString);
 
  virtual gd::String GenerateParameterCodes(
      const gd::Expression& parameter,
      const gd::ParameterMetadata& metadata,
      gd::EventsCodeGenerationContext& context,
      const gd::String& lastObjectName,
      std::vector<std::pair<gd::String, gd::String> >*
          supplementaryParametersTypes);
 
  virtual gd::String GenerateGetVariable(
      const gd::String& variableName,
      const VariableScope& scope,
      gd::EventsCodeGenerationContext& context,
      const gd::String& objectName,
      bool hasChild) {
    // This code is only used as a mock.
    // See the real implementation in GDJS.
    if (scope == LAYOUT_VARIABLE) {
      return "getLayoutVariable(" + variableName + ")";
 
    } else if (scope == PROJECT_VARIABLE) {
      return "getProjectVariable(" + variableName + ")";
    } else if (scope == ANY_VARIABLE || scope == VARIABLE_OR_PROPERTY ||
               scope == VARIABLE_OR_PROPERTY_OR_PARAMETER) {
      // TODO Split the 3 cases to make tests stronger.
      return "getAnyVariable(" + variableName + ")";
    }
 
    return "getVariableForObject(" + objectName + ", " + variableName + ")";
  }
 
  virtual gd::String GenerateVariableAccessor(gd::String childName) {
    return ".getChild(" + ConvertToStringExplicit(childName) + ")";
  };
 
  virtual gd::String GenerateVariableValueAs(const gd::String& type) {
    return type == "number|string" ? ".getAsNumberOrString()"
           : type == "string"      ? ".getAsString()"
                                   : ".getAsNumber()";
  }
 
  virtual gd::String GenerateVariableBracketAccessor(
      gd::String expressionCode) {
    return ".getChild(" + expressionCode + ")";
  };
 
  virtual gd::String GenerateBadVariable() { return "fakeBadVariable"; }
 
  virtual gd::String GenerateObject(const gd::String& objectName,
                                    const gd::String& type,
                                    gd::EventsCodeGenerationContext& context) {
    return "fakeObjectListOf_" + objectName;
  }
 
  virtual gd::String GeneratePropertyGetter(
      const gd::PropertiesContainer& propertiesContainer,
      const gd::NamedPropertyDescriptor& property,
      const gd::String& type,
      gd::EventsCodeGenerationContext& context);
 
  virtual gd::String GeneratePropertyGetterWithoutCasting(
      const gd::PropertiesContainer& propertiesContainer,
      const gd::NamedPropertyDescriptor& property);
 
  virtual gd::String GenerateParameterGetter(
      const gd::ParameterMetadata& parameter,
      const gd::String& type,
      gd::EventsCodeGenerationContext& context);
 
  virtual gd::String GenerateParameterGetterWithoutCasting(
      const gd::ParameterMetadata& parameter);
 
  virtual gd::String GenerateBadObject() { return "fakeNullObject"; }
 
  virtual gd::String GenerateObjectFunctionCall(
      gd::String objectListName,
      const ObjectMetadata& objMetadata,
      const gd::ExpressionCodeGenerationInformation& codeInfo,
      gd::String parametersStr,
      gd::String defaultOutput,
      gd::EventsCodeGenerationContext& context);
 
  virtual gd::String GenerateObjectBehaviorFunctionCall(
      gd::String objectListName,
      gd::String behaviorName,
      const gd::BehaviorMetadata& autoInfo,
      const gd::ExpressionCodeGenerationInformation& codeInfo,
      gd::String parametersStr,
      gd::String defaultOutput,
      gd::EventsCodeGenerationContext& context);
 
  virtual gd::String GenerateScopeBegin(
      gd::EventsCodeGenerationContext& context,
      const gd::String& extraVariable = "") {
    return "{\n";
  };
 
  virtual gd::String GenerateScopeEnd(gd::EventsCodeGenerationContext& context,
                                      const gd::String& extraVariable = "") {
    return "}\n";
  };
 
  virtual gd::String GenerateNegatedPredicate(
      const gd::String& predicate) const {
    return "!(" + predicate + ")";
  };
 
  virtual gd::String GenerateFreeCondition(
      const std::vector<gd::String>& arguments,
      const gd::InstructionMetadata& instrInfos,
      const gd::String& returnBoolean,
      bool conditionInverted,
      gd::EventsCodeGenerationContext& context);
 
  virtual gd::String GenerateObjectCondition(
      const gd::String& objectName,
      const gd::ObjectMetadata& objInfo,
      const std::vector<gd::String>& arguments,
      const gd::InstructionMetadata& instrInfos,
      const gd::String& returnBoolean,
      bool conditionInverted,
      gd::EventsCodeGenerationContext& context);
 
  virtual gd::String GenerateBehaviorCondition(
      const gd::String& objectName,
      const gd::String& behaviorName,
      const gd::BehaviorMetadata& autoInfo,
      const std::vector<gd::String>& arguments,
      const gd::InstructionMetadata& instrInfos,
      const gd::String& returnBoolean,
      bool conditionInverted,
      gd::EventsCodeGenerationContext& context);
 
  virtual gd::String GenerateFreeAction(
      const gd::String& functionCallName,
      const std::vector<gd::String>& arguments,
      const gd::InstructionMetadata& instrInfos,
      gd::EventsCodeGenerationContext& context,
      const gd::String& optionalAsyncCallbackName = "",
      const gd::String& optionalAsyncCallbackId = "");
 
  virtual gd::String GenerateObjectAction(
      const gd::String& objectName,
      const gd::ObjectMetadata& objInfo,
      const gd::String& functionCallName,
      const std::vector<gd::String>& arguments,
      const gd::InstructionMetadata& instrInfos,
      gd::EventsCodeGenerationContext& context,
      const gd::String& optionalAsyncCallbackName = "",
      const gd::String& optionalAsyncCallbackId = "");
 
  virtual gd::String GenerateBehaviorAction(
      const gd::String& objectName,
      const gd::String& behaviorName,
      const gd::BehaviorMetadata& autoInfo,
      const gd::String& functionCallName,
      const std::vector<gd::String>& arguments,
      const gd::InstructionMetadata& instrInfos,
      gd::EventsCodeGenerationContext& context,
      const gd::String& optionalAsyncCallbackName = "",
      const gd::String& optionalAsyncCallbackId = "");
 
  gd::String GenerateRelationalOperatorCall(
      const gd::InstructionMetadata& instrInfos,
      const std::vector<gd::String>& arguments,
      const gd::String& callStartString,
      std::size_t startFromArgument = 0);
 
  gd::String GenerateOperatorCall(const gd::InstructionMetadata& instrInfos,
                                  const std::vector<gd::String>& arguments,
                                  const gd::String& callStartString,
                                  const gd::String& getterStartString,
                                  std::size_t startFromArgument = 0);
  gd::String GenerateCompoundOperatorCall(
      const gd::InstructionMetadata& instrInfos,
      const std::vector<gd::String>& arguments,
      const gd::String& callStartString,
      std::size_t startFromArgument = 0);
  gd::String GenerateMutatorCall(const gd::InstructionMetadata& instrInfos,
                                 const std::vector<gd::String>& arguments,
                                 const gd::String& callStartString,
                                 std::size_t startFromArgument = 0);
 
  gd::String GenerateTrue() const { return "true"; };
 
  gd::String GenerateFalse() const { return "false"; };
 
  virtual gd::String GenerateArgumentsList(
      const std::vector<gd::String>& arguments, size_t startFrom = 0);
 
  virtual gd::String GenerateGetBehaviorNameCode(
      const gd::String& behaviorName);
 
  bool CheckBehaviorParameters(const gd::Instruction& instruction,
                               const gd::InstructionMetadata& instrInfos);
 
  const gd::Platform& platform;  
 
  gd::ProjectScopedContainers projectScopedContainers;
 
  bool hasProjectAndLayout;  
  const gd::Project* project;  
  const gd::Layout* scene;     
 
  bool errorOccurred;          
  bool compilationForRuntime;  
 
  std::set<gd::String>
      includeFiles;  
  gd::String customCodeOutsideMain;  
  std::set<gd::String>
      customGlobalDeclarations;     
  size_t maxCustomConditionsDepth;  
  size_t maxConditionsListsSize;  
 
  std::set<size_t>
      instructionUniqueIds;  
  size_t eventsListNextUniqueId;  
 
  gd::DiagnosticReport* diagnosticReport;
};
 
}  // namespace gd