Revision ad6ef6c1d5ba1434215bf9e891c87f71514446e9 authored by Brad King on 13 November 2018, 15:37:23 UTC, committed by Brad King on 13 November 2018, 15:37:23 UTC
Merge-request: !2601
cmFindCommon.cxx
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmFindCommon.h"
#include <algorithm>
#include <string.h>
#include <utility>
#include "cmMakefile.h"
#include "cmSystemTools.h"
cmFindCommon::PathGroup cmFindCommon::PathGroup::All("ALL");
cmFindCommon::PathLabel cmFindCommon::PathLabel::PackageRoot(
"PackageName_ROOT");
cmFindCommon::PathLabel cmFindCommon::PathLabel::CMake("CMAKE");
cmFindCommon::PathLabel cmFindCommon::PathLabel::CMakeEnvironment(
"CMAKE_ENVIRONMENT");
cmFindCommon::PathLabel cmFindCommon::PathLabel::Hints("HINTS");
cmFindCommon::PathLabel cmFindCommon::PathLabel::SystemEnvironment(
"SYSTM_ENVIRONMENT");
cmFindCommon::PathLabel cmFindCommon::PathLabel::CMakeSystem("CMAKE_SYSTEM");
cmFindCommon::PathLabel cmFindCommon::PathLabel::Guess("GUESS");
cmFindCommon::cmFindCommon()
{
this->FindRootPathMode = RootPathModeBoth;
this->NoDefaultPath = false;
this->NoPackageRootPath = false;
this->NoCMakePath = false;
this->NoCMakeEnvironmentPath = false;
this->NoSystemEnvironmentPath = false;
this->NoCMakeSystemPath = false;
// OS X Bundle and Framework search policy. The default is to
// search frameworks first on apple.
#if defined(__APPLE__)
this->SearchFrameworkFirst = true;
this->SearchAppBundleFirst = true;
#else
this->SearchFrameworkFirst = false;
this->SearchAppBundleFirst = false;
#endif
this->SearchFrameworkOnly = false;
this->SearchFrameworkLast = false;
this->SearchAppBundleOnly = false;
this->SearchAppBundleLast = false;
this->InitializeSearchPathGroups();
}
cmFindCommon::~cmFindCommon()
{
}
void cmFindCommon::InitializeSearchPathGroups()
{
std::vector<PathLabel>* labels;
// Define the various different groups of path types
// All search paths
labels = &this->PathGroupLabelMap[PathGroup::All];
labels->push_back(PathLabel::PackageRoot);
labels->push_back(PathLabel::CMake);
labels->push_back(PathLabel::CMakeEnvironment);
labels->push_back(PathLabel::Hints);
labels->push_back(PathLabel::SystemEnvironment);
labels->push_back(PathLabel::CMakeSystem);
labels->push_back(PathLabel::Guess);
// Define the search group order
this->PathGroupOrder.push_back(PathGroup::All);
// Create the individual labeled search paths
this->LabeledPaths.insert(
std::make_pair(PathLabel::PackageRoot, cmSearchPath(this)));
this->LabeledPaths.insert(
std::make_pair(PathLabel::CMake, cmSearchPath(this)));
this->LabeledPaths.insert(
std::make_pair(PathLabel::CMakeEnvironment, cmSearchPath(this)));
this->LabeledPaths.insert(
std::make_pair(PathLabel::Hints, cmSearchPath(this)));
this->LabeledPaths.insert(
std::make_pair(PathLabel::SystemEnvironment, cmSearchPath(this)));
this->LabeledPaths.insert(
std::make_pair(PathLabel::CMakeSystem, cmSearchPath(this)));
this->LabeledPaths.insert(
std::make_pair(PathLabel::Guess, cmSearchPath(this)));
}
void cmFindCommon::SelectDefaultRootPathMode()
{
// Check the policy variable for this find command type.
std::string findRootPathVar = "CMAKE_FIND_ROOT_PATH_MODE_";
findRootPathVar += this->CMakePathName;
std::string rootPathMode =
this->Makefile->GetSafeDefinition(findRootPathVar);
if (rootPathMode == "NEVER") {
this->FindRootPathMode = RootPathModeNever;
} else if (rootPathMode == "ONLY") {
this->FindRootPathMode = RootPathModeOnly;
} else if (rootPathMode == "BOTH") {
this->FindRootPathMode = RootPathModeBoth;
}
}
void cmFindCommon::SelectDefaultMacMode()
{
std::string ff = this->Makefile->GetSafeDefinition("CMAKE_FIND_FRAMEWORK");
if (ff == "NEVER") {
this->SearchFrameworkLast = false;
this->SearchFrameworkFirst = false;
this->SearchFrameworkOnly = false;
} else if (ff == "ONLY") {
this->SearchFrameworkLast = false;
this->SearchFrameworkFirst = false;
this->SearchFrameworkOnly = true;
} else if (ff == "FIRST") {
this->SearchFrameworkLast = false;
this->SearchFrameworkFirst = true;
this->SearchFrameworkOnly = false;
} else if (ff == "LAST") {
this->SearchFrameworkLast = true;
this->SearchFrameworkFirst = false;
this->SearchFrameworkOnly = false;
}
std::string fab = this->Makefile->GetSafeDefinition("CMAKE_FIND_APPBUNDLE");
if (fab == "NEVER") {
this->SearchAppBundleLast = false;
this->SearchAppBundleFirst = false;
this->SearchAppBundleOnly = false;
} else if (fab == "ONLY") {
this->SearchAppBundleLast = false;
this->SearchAppBundleFirst = false;
this->SearchAppBundleOnly = true;
} else if (fab == "FIRST") {
this->SearchAppBundleLast = false;
this->SearchAppBundleFirst = true;
this->SearchAppBundleOnly = false;
} else if (fab == "LAST") {
this->SearchAppBundleLast = true;
this->SearchAppBundleFirst = false;
this->SearchAppBundleOnly = false;
}
}
void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
{
#if 0
for(std::string const& p : paths)
{
fprintf(stderr, "[%s]\n", p.c_str());
}
#endif
// Short-circuit if there is nothing to do.
if (this->FindRootPathMode == RootPathModeNever) {
return;
}
const char* sysroot = this->Makefile->GetDefinition("CMAKE_SYSROOT");
const char* sysrootCompile =
this->Makefile->GetDefinition("CMAKE_SYSROOT_COMPILE");
const char* sysrootLink =
this->Makefile->GetDefinition("CMAKE_SYSROOT_LINK");
const char* rootPath = this->Makefile->GetDefinition("CMAKE_FIND_ROOT_PATH");
const bool noSysroot = !sysroot || !*sysroot;
const bool noCompileSysroot = !sysrootCompile || !*sysrootCompile;
const bool noLinkSysroot = !sysrootLink || !*sysrootLink;
const bool noRootPath = !rootPath || !*rootPath;
if (noSysroot && noCompileSysroot && noLinkSysroot && noRootPath) {
return;
}
// Construct the list of path roots with no trailing slashes.
std::vector<std::string> roots;
if (rootPath) {
cmSystemTools::ExpandListArgument(rootPath, roots);
}
if (sysrootCompile) {
roots.push_back(sysrootCompile);
}
if (sysrootLink) {
roots.push_back(sysrootLink);
}
if (sysroot) {
roots.push_back(sysroot);
}
for (std::string& r : roots) {
cmSystemTools::ConvertToUnixSlashes(r);
}
const char* stagePrefix =
this->Makefile->GetDefinition("CMAKE_STAGING_PREFIX");
// Copy the original set of unrooted paths.
std::vector<std::string> unrootedPaths = paths;
paths.clear();
for (std::string const& r : roots) {
for (std::string const& up : unrootedPaths) {
// Place the unrooted path under the current root if it is not
// already inside. Skip the unrooted path if it is relative to
// a user home directory or is empty.
std::string rootedDir;
if (cmSystemTools::IsSubDirectory(up, r) ||
(stagePrefix && cmSystemTools::IsSubDirectory(up, stagePrefix))) {
rootedDir = up;
} else if (!up.empty() && up[0] != '~') {
// Start with the new root.
rootedDir = r;
rootedDir += "/";
// Append the original path with its old root removed.
rootedDir += cmSystemTools::SplitPathRootComponent(up);
}
// Store the new path.
paths.push_back(rootedDir);
}
}
// If searching both rooted and unrooted paths add the original
// paths again.
if (this->FindRootPathMode == RootPathModeBoth) {
paths.insert(paths.end(), unrootedPaths.begin(), unrootedPaths.end());
}
}
void cmFindCommon::GetIgnoredPaths(std::vector<std::string>& ignore)
{
// null-terminated list of paths.
static const char* paths[] = { "CMAKE_SYSTEM_IGNORE_PATH",
"CMAKE_IGNORE_PATH", nullptr };
// Construct the list of path roots with no trailing slashes.
for (const char** pathName = paths; *pathName; ++pathName) {
// Get the list of paths to ignore from the variable.
const char* ignorePath = this->Makefile->GetDefinition(*pathName);
if ((ignorePath == nullptr) || (strlen(ignorePath) == 0)) {
continue;
}
cmSystemTools::ExpandListArgument(ignorePath, ignore);
}
for (std::string& i : ignore) {
cmSystemTools::ConvertToUnixSlashes(i);
}
}
void cmFindCommon::GetIgnoredPaths(std::set<std::string>& ignore)
{
std::vector<std::string> ignoreVec;
GetIgnoredPaths(ignoreVec);
ignore.insert(ignoreVec.begin(), ignoreVec.end());
}
bool cmFindCommon::CheckCommonArgument(std::string const& arg)
{
if (arg == "NO_DEFAULT_PATH") {
this->NoDefaultPath = true;
} else if (arg == "NO_PACKAGE_ROOT_PATH") {
this->NoPackageRootPath = true;
} else if (arg == "NO_CMAKE_PATH") {
this->NoCMakePath = true;
} else if (arg == "NO_CMAKE_ENVIRONMENT_PATH") {
this->NoCMakeEnvironmentPath = true;
} else if (arg == "NO_SYSTEM_ENVIRONMENT_PATH") {
this->NoSystemEnvironmentPath = true;
} else if (arg == "NO_CMAKE_SYSTEM_PATH") {
this->NoCMakeSystemPath = true;
} else if (arg == "NO_CMAKE_FIND_ROOT_PATH") {
this->FindRootPathMode = RootPathModeNever;
} else if (arg == "ONLY_CMAKE_FIND_ROOT_PATH") {
this->FindRootPathMode = RootPathModeOnly;
} else if (arg == "CMAKE_FIND_ROOT_PATH_BOTH") {
this->FindRootPathMode = RootPathModeBoth;
} else {
// The argument is not one of the above.
return false;
}
// The argument is one of the above.
return true;
}
void cmFindCommon::AddPathSuffix(std::string const& arg)
{
std::string suffix = arg;
// Strip leading and trailing slashes.
if (suffix.empty()) {
return;
}
if (suffix[0] == '/') {
suffix = suffix.substr(1);
}
if (suffix.empty()) {
return;
}
if (suffix[suffix.size() - 1] == '/') {
suffix = suffix.substr(0, suffix.size() - 1);
}
if (suffix.empty()) {
return;
}
// Store the suffix.
this->SearchPathSuffixes.push_back(std::move(suffix));
}
void AddTrailingSlash(std::string& s)
{
if (!s.empty() && *s.rbegin() != '/') {
s += '/';
}
}
void cmFindCommon::ComputeFinalPaths()
{
// Filter out ignored paths from the prefix list
std::set<std::string> ignored;
this->GetIgnoredPaths(ignored);
// Combine the separate path types, filtering out ignores
this->SearchPaths.clear();
std::vector<PathLabel>& allLabels = this->PathGroupLabelMap[PathGroup::All];
for (PathLabel const& l : allLabels) {
this->LabeledPaths[l].ExtractWithout(ignored, this->SearchPaths);
}
// Expand list of paths inside all search roots.
this->RerootPaths(this->SearchPaths);
// Add a trailing slash to all paths to aid the search process.
std::for_each(this->SearchPaths.begin(), this->SearchPaths.end(),
&AddTrailingSlash);
}
![swh spinner](/static/img/swh-spinner.gif)
Computing file changes ...