You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
639 lines
24 KiB
639 lines
24 KiB
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
|
|
#include "cmDebuggerVariablesHelper.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <functional>
|
|
#include <iomanip>
|
|
#include <iterator>
|
|
#include <map>
|
|
#include <sstream>
|
|
|
|
#include "cm_codecvt_Encoding.hxx"
|
|
|
|
#include "cmDebuggerStackFrame.h"
|
|
#include "cmDebuggerVariables.h"
|
|
#include "cmFileSet.h"
|
|
#include "cmGlobalGenerator.h"
|
|
#include "cmList.h"
|
|
#include "cmListFileCache.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmPropertyMap.h"
|
|
#include "cmState.h"
|
|
#include "cmStateSnapshot.h"
|
|
#include "cmTarget.h"
|
|
#include "cmTest.h"
|
|
#include "cmValue.h"
|
|
#include "cmake.h"
|
|
|
|
namespace cmDebugger {
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::Create(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType,
|
|
cmPolicies::PolicyMap const& policyMap)
|
|
{
|
|
static std::map<cmPolicies::PolicyStatus, std::string> policyStatusString = {
|
|
{ cmPolicies::PolicyStatus::OLD, "OLD" },
|
|
{ cmPolicies::PolicyStatus::WARN, "WARN" },
|
|
{ cmPolicies::PolicyStatus::NEW, "NEW" },
|
|
{ cmPolicies::PolicyStatus::REQUIRED_IF_USED, "REQUIRED_IF_USED" },
|
|
{ cmPolicies::PolicyStatus::REQUIRED_ALWAYS, "REQUIRED_ALWAYS" }
|
|
};
|
|
|
|
return std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret;
|
|
ret.reserve(cmPolicies::CMPCOUNT);
|
|
for (int i = 0; i < cmPolicies::CMPCOUNT; ++i) {
|
|
if (policyMap.IsDefined(static_cast<cmPolicies::PolicyID>(i))) {
|
|
auto status = policyMap.Get(static_cast<cmPolicies::PolicyID>(i));
|
|
std::ostringstream ss;
|
|
ss << "CMP" << std::setfill('0') << std::setw(4) << i;
|
|
ret.emplace_back(ss.str(), policyStatusString[status]);
|
|
}
|
|
}
|
|
return ret;
|
|
});
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::CreateIfAny(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType,
|
|
std::vector<std::pair<std::string, std::string>> const& list)
|
|
{
|
|
if (list.empty()) {
|
|
return {};
|
|
}
|
|
|
|
auto listVariables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret;
|
|
ret.reserve(list.size());
|
|
for (auto const& kv : list) {
|
|
ret.emplace_back(kv.first, kv.second);
|
|
}
|
|
return ret;
|
|
});
|
|
|
|
listVariables->SetValue(std::to_string(list.size()));
|
|
return listVariables;
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::CreateIfAny(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType,
|
|
cmBTStringRange const& entries)
|
|
{
|
|
if (entries.empty()) {
|
|
return {};
|
|
}
|
|
|
|
auto sourceEntries = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType);
|
|
|
|
for (auto const& entry : entries) {
|
|
auto arrayVariables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, entry.Value, supportsVariableType, [=]() {
|
|
cmList items{ entry.Value };
|
|
std::vector<cmDebuggerVariableEntry> ret;
|
|
ret.reserve(items.size());
|
|
int i = 0;
|
|
for (std::string const& item : items) {
|
|
ret.emplace_back("[" + std::to_string(i++) + "]", item);
|
|
}
|
|
return ret;
|
|
});
|
|
arrayVariables->SetEnableSorting(false);
|
|
sourceEntries->AddSubVariables(arrayVariables);
|
|
}
|
|
|
|
sourceEntries->SetValue(std::to_string(entries.size()));
|
|
return sourceEntries;
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::CreateIfAny(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType,
|
|
std::set<std::string> const& values)
|
|
{
|
|
if (values.empty()) {
|
|
return {};
|
|
}
|
|
|
|
auto arrayVariables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret;
|
|
ret.reserve(values.size());
|
|
int i = 0;
|
|
for (std::string const& value : values) {
|
|
ret.emplace_back("[" + std::to_string(i++) + "]", value);
|
|
}
|
|
return ret;
|
|
});
|
|
arrayVariables->SetValue(std::to_string(values.size()));
|
|
arrayVariables->SetEnableSorting(false);
|
|
return arrayVariables;
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::CreateIfAny(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType,
|
|
std::vector<std::string> const& values)
|
|
{
|
|
if (values.empty()) {
|
|
return {};
|
|
}
|
|
|
|
auto arrayVariables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret;
|
|
ret.reserve(values.size());
|
|
int i = 0;
|
|
for (std::string const& value : values) {
|
|
ret.emplace_back("[" + std::to_string(i++) + "]", value);
|
|
}
|
|
return ret;
|
|
});
|
|
|
|
arrayVariables->SetValue(std::to_string(values.size()));
|
|
arrayVariables->SetEnableSorting(false);
|
|
return arrayVariables;
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::CreateIfAny(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType,
|
|
std::vector<BT<std::string>> const& list)
|
|
{
|
|
if (list.empty()) {
|
|
return {};
|
|
}
|
|
|
|
auto variables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret;
|
|
ret.reserve(list.size());
|
|
int i = 0;
|
|
for (auto const& item : list) {
|
|
ret.emplace_back("[" + std::to_string(i++) + "]", item.Value);
|
|
}
|
|
|
|
return ret;
|
|
});
|
|
|
|
variables->SetValue(std::to_string(list.size()));
|
|
variables->SetEnableSorting(false);
|
|
return variables;
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::CreateIfAny(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType, cmFileSet* fileSet)
|
|
{
|
|
if (!fileSet) {
|
|
return {};
|
|
}
|
|
|
|
static auto visibilityString = [](cmFileSetVisibility visibility) {
|
|
switch (visibility) {
|
|
case cmFileSetVisibility::Private:
|
|
return "Private";
|
|
case cmFileSetVisibility::Public:
|
|
return "Public";
|
|
case cmFileSetVisibility::Interface:
|
|
return "Interface";
|
|
default:
|
|
return "Unknown";
|
|
}
|
|
};
|
|
|
|
auto variables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret{
|
|
{ "Name", fileSet->GetName() },
|
|
{ "Type", fileSet->GetType() },
|
|
{ "Visibility", visibilityString(fileSet->GetVisibility()) },
|
|
};
|
|
|
|
return ret;
|
|
});
|
|
|
|
variables->AddSubVariables(CreateIfAny(variablesManager, "Directories",
|
|
supportsVariableType,
|
|
fileSet->GetDirectoryEntries()));
|
|
variables->AddSubVariables(CreateIfAny(variablesManager, "Files",
|
|
supportsVariableType,
|
|
fileSet->GetFileEntries()));
|
|
return variables;
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::CreateIfAny(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType,
|
|
std::vector<cmFileSet*> const& fileSets)
|
|
{
|
|
if (fileSets.empty()) {
|
|
return {};
|
|
}
|
|
|
|
auto fileSetsVariables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType);
|
|
|
|
for (auto const& fileSet : fileSets) {
|
|
fileSetsVariables->AddSubVariables(CreateIfAny(
|
|
variablesManager, fileSet->GetName(), supportsVariableType, fileSet));
|
|
}
|
|
|
|
return fileSetsVariables;
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::CreateIfAny(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType,
|
|
std::vector<cmTarget*> const& targets)
|
|
{
|
|
if (targets.empty()) {
|
|
return {};
|
|
}
|
|
|
|
auto targetsVariables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType);
|
|
|
|
for (auto const& target : targets) {
|
|
auto targetVariables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, target->GetName(), supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret = {
|
|
{ "InstallPath", target->GetInstallPath() },
|
|
{ "IsAIX", target->IsAIX() },
|
|
{ "IsAndroidGuiExecutable", target->IsAndroidGuiExecutable() },
|
|
{ "IsAppBundleOnApple", target->IsAppBundleOnApple() },
|
|
{ "IsDLLPlatform", target->IsDLLPlatform() },
|
|
{ "IsExecutableWithExports", target->IsExecutableWithExports() },
|
|
{ "IsFrameworkOnApple", target->IsFrameworkOnApple() },
|
|
{ "IsImported", target->IsImported() },
|
|
{ "IsImportedGloballyVisible", target->IsImportedGloballyVisible() },
|
|
{ "IsPerConfig", target->IsPerConfig() },
|
|
{ "Name", target->GetName() },
|
|
{ "RuntimeInstallPath", target->GetRuntimeInstallPath() },
|
|
{ "Type", cmState::GetTargetTypeName(target->GetType()) },
|
|
};
|
|
|
|
return ret;
|
|
});
|
|
targetVariables->SetValue(cmState::GetTargetTypeName(target->GetType()));
|
|
|
|
targetVariables->AddSubVariables(Create(variablesManager, "PolicyMap",
|
|
supportsVariableType,
|
|
target->GetPolicyMap()));
|
|
targetVariables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "Properties", supportsVariableType,
|
|
target->GetProperties().GetList()));
|
|
|
|
targetVariables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "IncludeDirectories", supportsVariableType,
|
|
target->GetIncludeDirectoriesEntries()));
|
|
targetVariables->AddSubVariables(CreateIfAny(variablesManager, "Sources",
|
|
supportsVariableType,
|
|
target->GetSourceEntries()));
|
|
targetVariables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "CompileDefinitions", supportsVariableType,
|
|
target->GetCompileDefinitionsEntries()));
|
|
targetVariables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "CompileFeatures", supportsVariableType,
|
|
target->GetCompileFeaturesEntries()));
|
|
targetVariables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "CompileOptions", supportsVariableType,
|
|
target->GetCompileOptionsEntries()));
|
|
targetVariables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "CxxModuleSets", supportsVariableType,
|
|
target->GetCxxModuleSetsEntries()));
|
|
targetVariables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "HeaderSets", supportsVariableType,
|
|
target->GetHeaderSetsEntries()));
|
|
targetVariables->AddSubVariables(CreateIfAny(
|
|
variablesManager, "InterfaceHeaderSets", supportsVariableType,
|
|
target->GetInterfaceHeaderSetsEntries()));
|
|
targetVariables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "LinkDirectories", supportsVariableType,
|
|
target->GetLinkDirectoriesEntries()));
|
|
targetVariables->AddSubVariables(CreateIfAny(
|
|
variablesManager, "LinkImplementations", supportsVariableType,
|
|
target->GetLinkImplementationEntries()));
|
|
targetVariables->AddSubVariables(CreateIfAny(
|
|
variablesManager, "LinkInterfaceDirects", supportsVariableType,
|
|
target->GetLinkInterfaceDirectEntries()));
|
|
targetVariables->AddSubVariables(CreateIfAny(
|
|
variablesManager, "LinkInterfaceDirectExcludes", supportsVariableType,
|
|
target->GetLinkInterfaceDirectExcludeEntries()));
|
|
targetVariables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "LinkInterfaces", supportsVariableType,
|
|
target->GetLinkInterfaceEntries()));
|
|
targetVariables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "LinkOptions", supportsVariableType,
|
|
target->GetLinkOptionsEntries()));
|
|
targetVariables->AddSubVariables(CreateIfAny(
|
|
variablesManager, "SystemIncludeDirectories", supportsVariableType,
|
|
target->GetSystemIncludeDirectories()));
|
|
targetVariables->AddSubVariables(CreateIfAny(variablesManager, "Makefile",
|
|
supportsVariableType,
|
|
target->GetMakefile()));
|
|
targetVariables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "GlobalGenerator", supportsVariableType,
|
|
target->GetGlobalGenerator()));
|
|
|
|
std::vector<cmFileSet*> allFileSets;
|
|
auto allFileSetNames = target->GetAllFileSetNames();
|
|
allFileSets.reserve(allFileSetNames.size());
|
|
for (auto const& fileSetName : allFileSetNames) {
|
|
allFileSets.emplace_back(target->GetFileSet(fileSetName));
|
|
}
|
|
targetVariables->AddSubVariables(CreateIfAny(
|
|
variablesManager, "AllFileSets", supportsVariableType, allFileSets));
|
|
|
|
std::vector<cmFileSet*> allInterfaceFileSets;
|
|
auto allInterfaceFileSetNames = target->GetAllInterfaceFileSets();
|
|
allInterfaceFileSets.reserve(allInterfaceFileSetNames.size());
|
|
for (auto const& interfaceFileSetName : allInterfaceFileSetNames) {
|
|
allInterfaceFileSets.emplace_back(
|
|
target->GetFileSet(interfaceFileSetName));
|
|
}
|
|
targetVariables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "AllInterfaceFileSets",
|
|
supportsVariableType, allInterfaceFileSets));
|
|
|
|
targetVariables->SetIgnoreEmptyStringEntries(true);
|
|
targetsVariables->AddSubVariables(targetVariables);
|
|
}
|
|
|
|
targetsVariables->SetValue(std::to_string(targets.size()));
|
|
return targetsVariables;
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::Create(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType,
|
|
std::shared_ptr<cmDebuggerStackFrame> const& frame)
|
|
{
|
|
auto variables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType, [=]() {
|
|
return std::vector<cmDebuggerVariableEntry>{ { "CurrentLine",
|
|
frame->GetLine() } };
|
|
});
|
|
|
|
auto closureKeys = frame->GetMakefile()->GetStateSnapshot().ClosureKeys();
|
|
auto locals = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, "Locals", supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret;
|
|
ret.reserve(closureKeys.size());
|
|
for (auto const& key : closureKeys) {
|
|
ret.emplace_back(
|
|
key, frame->GetMakefile()->GetStateSnapshot().GetDefinition(key));
|
|
}
|
|
return ret;
|
|
});
|
|
locals->SetValue(std::to_string(closureKeys.size()));
|
|
variables->AddSubVariables(locals);
|
|
|
|
std::function<bool(std::string const&)> isDirectory =
|
|
[](std::string const& key) {
|
|
size_t pos1 = key.rfind("_DIR");
|
|
size_t pos2 = key.rfind("_DIRECTORY");
|
|
return !((pos1 == std::string::npos || pos1 != key.size() - 4) &&
|
|
(pos2 == std::string::npos || pos2 != key.size() - 10));
|
|
};
|
|
auto directorySize =
|
|
std::count_if(closureKeys.begin(), closureKeys.end(), isDirectory);
|
|
auto directories = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, "Directories", supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret;
|
|
ret.reserve(directorySize);
|
|
for (auto const& key : closureKeys) {
|
|
if (isDirectory(key)) {
|
|
ret.emplace_back(
|
|
key, frame->GetMakefile()->GetStateSnapshot().GetDefinition(key));
|
|
}
|
|
}
|
|
return ret;
|
|
});
|
|
directories->SetValue(std::to_string(directorySize));
|
|
variables->AddSubVariables(directories);
|
|
|
|
auto cacheVariables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, "CacheVariables", supportsVariableType);
|
|
auto* state = frame->GetMakefile()->GetCMakeInstance()->GetState();
|
|
auto keys = state->GetCacheEntryKeys();
|
|
for (auto const& key : keys) {
|
|
auto entry = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager,
|
|
key + ":" +
|
|
cmState::CacheEntryTypeToString(state->GetCacheEntryType(key)),
|
|
supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret;
|
|
auto properties = state->GetCacheEntryPropertyList(key);
|
|
ret.reserve(properties.size() + 2);
|
|
for (auto const& propertyName : properties) {
|
|
ret.emplace_back(propertyName,
|
|
state->GetCacheEntryProperty(key, propertyName));
|
|
}
|
|
|
|
ret.emplace_back(
|
|
"TYPE",
|
|
cmState::CacheEntryTypeToString(state->GetCacheEntryType(key)));
|
|
ret.emplace_back("VALUE", state->GetCacheEntryValue(key));
|
|
return ret;
|
|
});
|
|
|
|
entry->SetValue(state->GetCacheEntryValue(key));
|
|
cacheVariables->AddSubVariables(entry);
|
|
}
|
|
|
|
cacheVariables->SetValue(std::to_string(keys.size()));
|
|
variables->AddSubVariables(cacheVariables);
|
|
|
|
auto targetVariables =
|
|
CreateIfAny(variablesManager, "Targets", supportsVariableType,
|
|
frame->GetMakefile()->GetOrderedTargets());
|
|
|
|
variables->AddSubVariables(targetVariables);
|
|
std::vector<cmTest*> tests;
|
|
frame->GetMakefile()->GetTests(
|
|
frame->GetMakefile()->GetDefaultConfiguration(), tests);
|
|
variables->AddSubVariables(
|
|
CreateIfAny(variablesManager, "Tests", supportsVariableType, tests));
|
|
|
|
return variables;
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::CreateIfAny(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType, cmTest* test)
|
|
{
|
|
if (!test) {
|
|
return {};
|
|
}
|
|
|
|
auto variables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret{
|
|
{ "CommandExpandLists", test->GetCommandExpandLists() },
|
|
{ "Name", test->GetName() },
|
|
{ "OldStyle", test->GetOldStyle() },
|
|
};
|
|
|
|
return ret;
|
|
});
|
|
|
|
variables->AddSubVariables(CreateIfAny(
|
|
variablesManager, "Command", supportsVariableType, test->GetCommand()));
|
|
|
|
variables->AddSubVariables(CreateIfAny(variablesManager, "Properties",
|
|
supportsVariableType,
|
|
test->GetProperties().GetList()));
|
|
return variables;
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::CreateIfAny(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType,
|
|
std::vector<cmTest*> const& tests)
|
|
{
|
|
if (tests.empty()) {
|
|
return {};
|
|
}
|
|
|
|
auto variables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType);
|
|
|
|
for (auto const& test : tests) {
|
|
variables->AddSubVariables(CreateIfAny(variablesManager, test->GetName(),
|
|
supportsVariableType, test));
|
|
}
|
|
variables->SetValue(std::to_string(tests.size()));
|
|
return variables;
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::CreateIfAny(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType, cmMakefile* mf)
|
|
{
|
|
if (!mf) {
|
|
return {};
|
|
}
|
|
|
|
auto AppleSDKTypeString = [&](cmMakefile::AppleSDK sdk) {
|
|
switch (sdk) {
|
|
case cmMakefile::AppleSDK::MacOS:
|
|
return "MacOS";
|
|
case cmMakefile::AppleSDK::IPhoneOS:
|
|
return "IPhoneOS";
|
|
case cmMakefile::AppleSDK::IPhoneSimulator:
|
|
return "IPhoneSimulator";
|
|
case cmMakefile::AppleSDK::AppleTVOS:
|
|
return "AppleTVOS";
|
|
case cmMakefile::AppleSDK::AppleTVSimulator:
|
|
return "AppleTVSimulator";
|
|
default:
|
|
return "Unknown";
|
|
}
|
|
};
|
|
|
|
auto variables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret = {
|
|
{ "DefineFlags", mf->GetDefineFlags() },
|
|
{ "DirectoryId", mf->GetDirectoryId().String },
|
|
{ "IsRootMakefile", mf->IsRootMakefile() },
|
|
{ "HomeDirectory", mf->GetHomeDirectory() },
|
|
{ "HomeOutputDirectory", mf->GetHomeOutputDirectory() },
|
|
{ "CurrentSourceDirectory", mf->GetCurrentSourceDirectory() },
|
|
{ "CurrentBinaryDirectory", mf->GetCurrentBinaryDirectory() },
|
|
{ "PlatformIs32Bit", mf->PlatformIs32Bit() },
|
|
{ "PlatformIs64Bit", mf->PlatformIs64Bit() },
|
|
{ "PlatformIsx32", mf->PlatformIsx32() },
|
|
{ "AppleSDKType", AppleSDKTypeString(mf->GetAppleSDKType()) },
|
|
{ "PlatformIsAppleEmbedded", mf->PlatformIsAppleEmbedded() }
|
|
};
|
|
|
|
return ret;
|
|
});
|
|
|
|
variables->AddSubVariables(CreateIfAny(
|
|
variablesManager, "ListFiles", supportsVariableType, mf->GetListFiles()));
|
|
variables->AddSubVariables(CreateIfAny(variablesManager, "OutputFiles",
|
|
supportsVariableType,
|
|
mf->GetOutputFiles()));
|
|
|
|
variables->SetIgnoreEmptyStringEntries(true);
|
|
variables->SetValue(mf->GetDirectoryId().String);
|
|
return variables;
|
|
}
|
|
|
|
std::shared_ptr<cmDebuggerVariables> cmDebuggerVariablesHelper::CreateIfAny(
|
|
std::shared_ptr<cmDebuggerVariablesManager> const& variablesManager,
|
|
std::string const& name, bool supportsVariableType, cmGlobalGenerator* gen)
|
|
{
|
|
if (!gen) {
|
|
return {};
|
|
}
|
|
|
|
auto makeFileEncodingString = [](codecvt_Encoding encoding) {
|
|
switch (encoding) {
|
|
case codecvt_Encoding::None:
|
|
return "None";
|
|
case codecvt_Encoding::UTF8:
|
|
return "UTF8";
|
|
case codecvt_Encoding::UTF8_WITH_BOM:
|
|
return "UTF8_WITH_BOM";
|
|
case codecvt_Encoding::ANSI:
|
|
return "ANSI";
|
|
case codecvt_Encoding::ConsoleOutput:
|
|
return "ConsoleOutput";
|
|
default:
|
|
return "Unknown";
|
|
}
|
|
};
|
|
|
|
auto variables = std::make_shared<cmDebuggerVariables>(
|
|
variablesManager, name, supportsVariableType, [=]() {
|
|
std::vector<cmDebuggerVariableEntry> ret = {
|
|
{ "AllTargetName", gen->GetAllTargetName() },
|
|
{ "CleanTargetName", gen->GetCleanTargetName() },
|
|
{ "EditCacheCommand", gen->GetEditCacheCommand() },
|
|
{ "EditCacheTargetName", gen->GetEditCacheTargetName() },
|
|
{ "ExtraGeneratorName", gen->GetExtraGeneratorName() },
|
|
{ "ForceUnixPaths", gen->GetForceUnixPaths() },
|
|
{ "InstallLocalTargetName", gen->GetInstallLocalTargetName() },
|
|
{ "InstallStripTargetName", gen->GetInstallStripTargetName() },
|
|
{ "InstallTargetName", gen->GetInstallTargetName() },
|
|
{ "IsMultiConfig", gen->IsMultiConfig() },
|
|
{ "Name", gen->GetName() },
|
|
{ "MakefileEncoding",
|
|
makeFileEncodingString(gen->GetMakefileEncoding()) },
|
|
{ "PackageSourceTargetName", gen->GetPackageSourceTargetName() },
|
|
{ "PackageTargetName", gen->GetPackageTargetName() },
|
|
{ "PreinstallTargetName", gen->GetPreinstallTargetName() },
|
|
{ "NeedSymbolicMark", gen->GetNeedSymbolicMark() },
|
|
{ "RebuildCacheTargetName", gen->GetRebuildCacheTargetName() },
|
|
{ "TestTargetName", gen->GetTestTargetName() },
|
|
{ "UseLinkScript", gen->GetUseLinkScript() },
|
|
};
|
|
|
|
return ret;
|
|
});
|
|
|
|
if (const auto* ic = gen->GetInstallComponents()) {
|
|
variables->AddSubVariables(CreateIfAny(
|
|
variablesManager, "InstallComponents", supportsVariableType, *ic));
|
|
}
|
|
|
|
variables->SetIgnoreEmptyStringEntries(true);
|
|
variables->SetValue(gen->GetName());
|
|
|
|
return variables;
|
|
}
|
|
|
|
} // namespace cmDebugger
|