UsedExtensionsFinder.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
 
#pragma once
 
#include <set>
#include <vector>
 
#include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
#include "GDCore/Extensions/Metadata/SourceFileMetadata.h"
#include "GDCore/Extensions/Metadata/InGameEditorResourceMetadata.h"
#include "GDCore/Extensions/PlatformExtension.h"
#include "GDCore/IDE/Events/ArbitraryEventsWorker.h"
#include "GDCore/IDE/Project/ArbitraryObjectsWorker.h"
#include "GDCore/String.h"
 
namespace gd {
class Project;
class Object;
class Behavior;
}  // namespace gd
 
namespace gd {
 
class GD_CORE_API UsedExtensionsResult {
public:
  const std::set<gd::String> &GetUsedExtensions() const {
    return usedExtensions;
  }
 
  const std::set<gd::String> &GetUsedIncludeFiles() const {
    return usedIncludeFiles;
  }
 
  const std::set<gd::String> &GetUsedRequiredFiles() const {
    return usedRequiredFiles;
  }
 
  const std::vector<gd::SourceFileMetadata>& GetUsedSourceFiles() const {
    return usedSourceFiles;
  }
 
  const std::vector<gd::InGameEditorResourceMetadata>& GetUsedInGameEditorResources() const {
    return usedInGameEditorResources;
  }
 
  bool Has3DObjects() const {
    return has3DObjects;
  }
 
  void AddUsedExtension(const gd::PlatformExtension& extension);
  void AddUsedBuiltinExtension(const gd::Project& project, const gd::String& extensionName);
  void AddUsedIncludeFiles(const gd::String& includeFile) { usedIncludeFiles.insert(includeFile); }
  void AddUsedRequiredFiles(const gd::String& requiredFile) { usedRequiredFiles.insert(requiredFile); }
  void AddUsedInGameEditorResource(const gd::InGameEditorResourceMetadata& inGameEditorResource) {
    usedInGameEditorResources.push_back(inGameEditorResource);
  }
 
  void MarkAsHaving3DObjects() {
    has3DObjects = true;
  }
 
private:
  std::set<gd::String> usedExtensions;
  std::set<gd::String> usedIncludeFiles;
  std::set<gd::String> usedRequiredFiles;
  std::vector<gd::SourceFileMetadata> usedSourceFiles;
  std::vector<gd::InGameEditorResourceMetadata> usedInGameEditorResources;
  bool has3DObjects = false;
};
 
class GD_CORE_API UsedExtensionsFinder
    : public ArbitraryObjectsWorker,
      public ArbitraryEventsWorkerWithContext,
      public ExpressionParser2NodeWorker {
 public:
  static const UsedExtensionsResult ScanProject(gd::Project& project);
  static const UsedExtensionsResult ScanEventsFunctionsExtension(
      gd::Project &project,
      const gd::EventsFunctionsExtension &eventsFunctionsExtension);
  static const std::vector<gd::String> FindExtensionsDependentOn(
      gd::Project &project,
      const gd::EventsFunctionsExtension &eventsFunctionsExtension);
 
private:
  UsedExtensionsFinder(gd::Project& project_) : project(project_){};
  gd::Project& project;
  gd::String rootType;
  UsedExtensionsResult result;
 
  // Object Visitor
  void DoVisitObject(gd::Object& object) override;
 
  // Behavior Visitor
  void DoVisitBehavior(gd::Behavior& behavior) override;
 
  // Instructions Visitor
  bool DoVisitInstruction(gd::Instruction& instruction,
                          bool isCondition) override;
 
  // Expression Visitor
  void OnVisitSubExpressionNode(SubExpressionNode& node) override;
  void OnVisitOperatorNode(OperatorNode& node) override;
  void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override;
  void OnVisitNumberNode(NumberNode& node) override;
  void OnVisitTextNode(TextNode& node) override;
  void OnVisitVariableNode(VariableNode& node) override;
  void OnVisitVariableAccessorNode(VariableAccessorNode& node) override;
  void OnVisitVariableBracketAccessorNode(
      VariableBracketAccessorNode& node) override;
  void OnVisitIdentifierNode(IdentifierNode& node) override;
  void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override;
  void OnVisitFunctionCallNode(FunctionCallNode& node) override;
  void OnVisitEmptyNode(EmptyNode& node) override;
};
 
};  // namespace gd