mirror of
https://github.com/4ian/GDevelop.git
synced 2025-10-15 10:19:04 +00:00
288 lines
11 KiB
C++
288 lines
11 KiB
C++
/*
|
|
* GDevelop Core
|
|
* Copyright 2008-2016 Florian Rival (Florian.Rival@gmail.com). All rights
|
|
* reserved. This project is released under the MIT License.
|
|
*/
|
|
|
|
#include "EventsVariablesFinder.h"
|
|
#include "GDCore/Events/Event.h"
|
|
#include "GDCore/Events/Instruction.h"
|
|
#include "GDCore/Events/Parsers/ExpressionParser2NodePrinter.h"
|
|
#include "GDCore/Events/Parsers/ExpressionParser2NodeWorker.h"
|
|
#include "GDCore/Extensions/Metadata/ExpressionMetadata.h"
|
|
#include "GDCore/Extensions/Metadata/InstructionMetadata.h"
|
|
#include "GDCore/Extensions/Metadata/MetadataProvider.h"
|
|
#include "GDCore/Extensions/Platform.h"
|
|
#include "GDCore/IDE/Events/ArbitraryEventsWorker.h"
|
|
#include "GDCore/Project/Layout.h"
|
|
#include "GDCore/Project/Object.h"
|
|
#include "GDCore/Project/Project.h"
|
|
#include "GDCore/Project/ProjectScopedContainers.h"
|
|
#include "GDCore/Project/ExternalEvents.h"
|
|
#include "GDCore/IDE/DependenciesAnalyzer.h"
|
|
|
|
using namespace std;
|
|
|
|
namespace gd {
|
|
namespace {
|
|
/**
|
|
* \brief Go through the nodes to search for variable occurrences.
|
|
*
|
|
* \see gd::ExpressionParser2
|
|
*/
|
|
class GD_CORE_API VariableFinderExpressionNodeWorker
|
|
: public ExpressionParser2NodeWorker {
|
|
public:
|
|
VariableFinderExpressionNodeWorker(std::set<gd::String>& results_,
|
|
const gd::Platform &platform_,
|
|
const gd::ProjectScopedContainers &projectScopedContainers_,
|
|
const gd::String& parameterType_,
|
|
const gd::String& objectName_ = "")
|
|
: results(results_),
|
|
platform(platform_),
|
|
projectScopedContainers(projectScopedContainers_),
|
|
parameterType(parameterType_),
|
|
objectName(objectName_){};
|
|
virtual ~VariableFinderExpressionNodeWorker(){};
|
|
|
|
protected:
|
|
void OnVisitSubExpressionNode(SubExpressionNode& node) override {
|
|
node.expression->Visit(*this);
|
|
}
|
|
void OnVisitOperatorNode(OperatorNode& node) override {
|
|
node.leftHandSide->Visit(*this);
|
|
node.rightHandSide->Visit(*this);
|
|
}
|
|
void OnVisitUnaryOperatorNode(UnaryOperatorNode& node) override {
|
|
node.factor->Visit(*this);
|
|
}
|
|
void OnVisitNumberNode(NumberNode& node) override {}
|
|
void OnVisitTextNode(TextNode& node) override {}
|
|
void OnVisitVariableNode(VariableNode& node) override {
|
|
// We don't check variables or object variables here, because object variables only work
|
|
// if the variable is already declared.
|
|
|
|
if (node.child) node.child->Visit(*this);
|
|
}
|
|
void OnVisitVariableAccessorNode(VariableAccessorNode& node) override {
|
|
if (node.child) node.child->Visit(*this);
|
|
}
|
|
void OnVisitVariableBracketAccessorNode(
|
|
VariableBracketAccessorNode& node) override {
|
|
node.expression->Visit(*this);
|
|
if (node.child) node.child->Visit(*this);
|
|
}
|
|
void OnVisitIdentifierNode(IdentifierNode& node) override {
|
|
// We don't check object variables here, because object variables only work
|
|
// if the variable is already declared.
|
|
}
|
|
void OnVisitObjectFunctionNameNode(ObjectFunctionNameNode& node) override {}
|
|
void OnVisitFunctionCallNode(FunctionCallNode& node) override {
|
|
bool considerFunction = objectName.empty() || node.objectName == objectName;
|
|
|
|
const bool isObjectFunction = !node.objectName.empty();
|
|
const gd::ExpressionMetadata &metadata = isObjectFunction ?
|
|
MetadataProvider::GetObjectAnyExpressionMetadata(
|
|
platform,
|
|
projectScopedContainers.GetObjectsContainersList().GetTypeOfObject(objectName),
|
|
node.functionName):
|
|
MetadataProvider::GetAnyExpressionMetadata(platform, node.functionName);
|
|
|
|
if (gd::MetadataProvider::IsBadExpressionMetadata(metadata)) {
|
|
return;
|
|
}
|
|
|
|
size_t parameterIndex = 0;
|
|
for (size_t metadataIndex = (isObjectFunction ? 1 : 0);
|
|
metadataIndex < metadata.GetParameters().GetParametersCount() &&
|
|
parameterIndex < node.parameters.size();
|
|
++metadataIndex) {
|
|
auto& parameterMetadata = metadata.GetParameters().GetParameter(metadataIndex);
|
|
if (parameterMetadata.IsCodeOnly()) {
|
|
continue;
|
|
}
|
|
auto& parameterNode = node.parameters[parameterIndex];
|
|
++parameterIndex;
|
|
|
|
if (considerFunction && parameterMetadata.GetType() == parameterType) {
|
|
// Store the value of the parameter
|
|
results.insert(
|
|
gd::ExpressionParser2NodePrinter::PrintNode(*parameterNode));
|
|
} else {
|
|
parameterNode->Visit(*this);
|
|
}
|
|
}
|
|
}
|
|
void OnVisitEmptyNode(EmptyNode& node) override {}
|
|
|
|
private:
|
|
const gd::Platform &platform;
|
|
const gd::ProjectScopedContainers &projectScopedContainers;
|
|
|
|
std::set<gd::String>& results; ///< Reference to the std::set where argument
|
|
///< values must be stored.
|
|
gd::String parameterType; ///< The type of the parameters to be searched for.
|
|
gd::String objectName; ///< If not empty, parameters will be taken into
|
|
///< account only if related to this object.
|
|
};
|
|
|
|
/**
|
|
* \brief Go through the events to search for variable occurrences.
|
|
*/
|
|
class GD_CORE_API VariableFinderEventWorker
|
|
: public ReadOnlyArbitraryEventsWorkerWithContext {
|
|
public:
|
|
VariableFinderEventWorker(std::set<gd::String>& results_,
|
|
const gd::Platform &platform_,
|
|
const gd::String& parameterType_,
|
|
const gd::String& objectName_ = "")
|
|
: results(results_),
|
|
platform(platform_),
|
|
parameterType(parameterType_),
|
|
objectName(objectName_){};
|
|
virtual ~VariableFinderEventWorker(){};
|
|
|
|
void DoVisitInstructionList(const gd::InstructionsList& instructions,
|
|
bool areConditions) override {
|
|
for (std::size_t aId = 0; aId < instructions.size(); ++aId) {
|
|
auto& instruction = instructions[aId];
|
|
gd::String lastObjectParameter = "";
|
|
const gd::InstructionMetadata& instrInfos =
|
|
areConditions ? MetadataProvider::GetConditionMetadata(
|
|
platform, instruction.GetType())
|
|
: MetadataProvider::GetActionMetadata(
|
|
platform, instruction.GetType());
|
|
for (std::size_t pNb = 0; pNb < instrInfos.parameters.GetParametersCount(); ++pNb) {
|
|
// The parameter has the searched type...
|
|
if (instrInfos.parameters.GetParameter(pNb).GetType() == parameterType) {
|
|
//...remember the value of the parameter.
|
|
if (objectName.empty() || lastObjectParameter == objectName)
|
|
results.insert(instruction.GetParameter(pNb).GetPlainString());
|
|
}
|
|
// Search in expressions
|
|
else if (ParameterMetadata::IsExpression(
|
|
"number", instrInfos.parameters.GetParameter(pNb).GetType()) ||
|
|
ParameterMetadata::IsExpression(
|
|
"string", instrInfos.parameters.GetParameter(pNb).GetType())) {
|
|
auto node = instruction.GetParameter(pNb).GetRootNode();
|
|
|
|
VariableFinderExpressionNodeWorker searcher(
|
|
results,
|
|
platform,
|
|
GetProjectScopedContainers(),
|
|
parameterType,
|
|
objectName);
|
|
node->Visit(searcher);
|
|
}
|
|
// Remember the value of the last "object" parameter.
|
|
else if (gd::ParameterMetadata::IsObject(
|
|
instrInfos.parameters.GetParameter(pNb).GetType())) {
|
|
lastObjectParameter =
|
|
instruction.GetParameter(pNb).GetPlainString();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
private:
|
|
const gd::Platform &platform;
|
|
|
|
std::set<gd::String>& results; ///< Reference to the std::set where argument
|
|
///< values must be stored.
|
|
gd::String parameterType; ///< The type of the parameters to be searched for.
|
|
gd::String objectName; ///< If not empty, parameters will be taken into
|
|
///< account only if related to this object.
|
|
};
|
|
} // namespace
|
|
|
|
std::set<gd::String> EventsVariablesFinder::FindAllGlobalVariables(
|
|
const gd::Platform& platform, const gd::Project& project) {
|
|
std::set<gd::String> results;
|
|
|
|
for (std::size_t i = 0; i < project.GetLayoutsCount(); ++i) {
|
|
FindArgumentsInEventsAndDependencies(
|
|
results,
|
|
platform,
|
|
project,
|
|
project.GetLayout(i),
|
|
"globalvar");
|
|
}
|
|
|
|
return results;
|
|
}
|
|
|
|
std::set<gd::String> EventsVariablesFinder::FindAllLayoutVariables(
|
|
const gd::Platform& platform,
|
|
const gd::Project& project,
|
|
const gd::Layout& layout) {
|
|
std::set<gd::String> results;
|
|
|
|
FindArgumentsInEventsAndDependencies(
|
|
results,
|
|
platform,
|
|
project,
|
|
layout,
|
|
"scenevar");
|
|
|
|
return results;
|
|
}
|
|
|
|
std::set<gd::String> EventsVariablesFinder::FindAllObjectVariables(
|
|
const gd::Platform& platform,
|
|
const gd::Project& project,
|
|
const gd::Layout& layout,
|
|
const gd::String& objectName) {
|
|
std::set<gd::String> results;
|
|
|
|
FindArgumentsInEventsAndDependencies(
|
|
results,
|
|
platform,
|
|
project,
|
|
layout,
|
|
"objectvar",
|
|
objectName);
|
|
|
|
return results;
|
|
}
|
|
|
|
void EventsVariablesFinder::FindArgumentsInEventsAndDependencies(
|
|
std::set<gd::String>& results,
|
|
const gd::Platform& platform,
|
|
const gd::Project& project,
|
|
const gd::Layout& layout,
|
|
const gd::String& parameterType,
|
|
const gd::String& objectName) {
|
|
|
|
VariableFinderEventWorker eventWorker(results,
|
|
platform,
|
|
parameterType,
|
|
objectName);
|
|
eventWorker.Launch(layout.GetEvents(),
|
|
gd::ProjectScopedContainers::MakeNewProjectScopedContainersForProjectAndLayout(project, layout));
|
|
|
|
DependenciesAnalyzer dependenciesAnalyzer(project, layout);
|
|
dependenciesAnalyzer.Analyze();
|
|
for (const gd::String& externalEventName : dependenciesAnalyzer.GetExternalEventsDependencies()) {
|
|
const gd::ExternalEvents& externalEvents = project.GetExternalEvents(externalEventName);
|
|
|
|
VariableFinderEventWorker eventWorker(results,
|
|
platform,
|
|
parameterType,
|
|
objectName);
|
|
eventWorker.Launch(externalEvents.GetEvents(),
|
|
gd::ProjectScopedContainers::MakeNewProjectScopedContainersForProjectAndLayout(project, layout));
|
|
}
|
|
for (const gd::String& sceneName : dependenciesAnalyzer.GetScenesDependencies()) {
|
|
const gd::Layout& dependencyLayout = project.GetLayout(sceneName);
|
|
|
|
VariableFinderEventWorker eventWorker(results,
|
|
platform,
|
|
parameterType,
|
|
objectName);
|
|
eventWorker.Launch(dependencyLayout.GetEvents(),
|
|
gd::ProjectScopedContainers::MakeNewProjectScopedContainersForProjectAndLayout(project, dependencyLayout));
|
|
}
|
|
}
|
|
|
|
} // namespace gd
|