/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying file Copyright.txt or https://cmake.org/licensing for details. */ #include "cmFindPackageCommand.h" #include <algorithm> #include <cassert> #include <cstdio> #include <deque> #include <functional> #include <iterator> #include <sstream> #include <utility> #include <cm/optional> #include <cmext/string_view> #include "cmsys/Directory.hxx" #include "cmsys/FStream.hxx" #include "cmsys/Glob.hxx" #include "cmsys/RegularExpression.hxx" #include "cmsys/String.h" #include "cmAlgorithms.h" #include "cmDependencyProvider.h" #include "cmList.h" #include "cmListFileCache.h" #include "cmMakefile.h" #include "cmMessageType.h" #include "cmPolicies.h" #include "cmRange.h" #include "cmSearchPath.h" #include "cmState.h" #include "cmStateTypes.h" #include "cmStringAlgorithms.h" #include "cmSystemTools.h" #include "cmValue.h" #include "cmVersion.h" #include "cmWindowsRegistry.h" #if defined(__HAIKU__) # include <FindDirectory.h> # include <StorageDefs.h> #endif #if defined(_WIN32) && !defined(__CYGWIN__) # include <windows.h> // http://msdn.microsoft.com/en-us/library/aa384253%28v=vs.85%29.aspx # if !defined(KEY_WOW64_32KEY) # define KEY_WOW64_32KEY 0x0200 # endif # if !defined(KEY_WOW64_64KEY) # define KEY_WOW64_64KEY 0x0100 # endif #endif class cmExecutionStatus; namespace { template <template <typename> class Op> struct StrverscmpOp { bool operator()(const std::string& lhs, const std::string& rhs) const { return Op<int>()(cmSystemTools::strverscmp(lhs, rhs), 0); } }; std::size_t collectPathsForDebug(std::string& buffer, cmSearchPath const& searchPath, std::size_t const startIndex = 0) { const auto& paths = searchPath.GetPaths(); if (paths.empty()) { buffer += " none\n"; return 0; } for (auto i = startIndex; i < paths.size(); i++) { buffer += " " + paths[i].Path + "\n"; } return paths.size(); } #if !(defined(_WIN32) && !defined(__CYGWIN__)) class cmFindPackageCommandHoldFile { const char* File; public: cmFindPackageCommandHoldFile(const char* const f) : File(f) { } ~cmFindPackageCommandHoldFile() { if (this->File) { cmSystemTools::RemoveFile(this->File); } } cmFindPackageCommandHoldFile(const cmFindPackageCommandHoldFile&) = delete; cmFindPackageCommandHoldFile& operator=( const cmFindPackageCommandHoldFile&) = delete; void Release() { this->File = nullptr; } }; #endif bool isDirentryToIgnore(const char* const fname) { assert(fname != nullptr); assert(fname[0] != 0); return fname[0] == '.' && (fname[1] == 0 || (fname[1] == '.' && fname[2] == 0)); } class cmAppendPathSegmentGenerator { public: cmAppendPathSegmentGenerator(cm::string_view dirName) : DirName{ dirName } { } std::string GetNextCandidate(const std::string& parent) { if (this->NeedReset) { return {}; } this->NeedReset = true; return cmStrCat(parent, '/', this->DirName); } void Reset() { this->NeedReset = false; } private: const cm::string_view DirName; bool NeedReset = false; }; class cmEnumPathSegmentsGenerator { public: cmEnumPathSegmentsGenerator(const std::vector<cm::string_view>& init) : Names{ init } , Current{ this->Names.get().cbegin() } { } std::string GetNextCandidate(const std::string& parent) { if (this->Current != this->Names.get().cend()) { return cmStrCat(parent, '/', *this->Current++); } return {}; } void Reset() { this->Current = this->Names.get().cbegin(); } private: std::reference_wrapper<const std::vector<cm::string_view>> Names; std::vector<cm::string_view>::const_iterator Current; }; class cmCaseInsensitiveDirectoryListGenerator { public: cmCaseInsensitiveDirectoryListGenerator(cm::string_view name) : DirectoryLister{} , DirName{ name } { } std::string GetNextCandidate(const std::string& parent) { if (!this->Loaded) { this->CurrentIdx = 0ul; this->Loaded = true; if (!this->DirectoryLister.Load(parent)) { return {}; } } while (this->CurrentIdx < this->DirectoryLister.GetNumberOfFiles()) { const char* const fname = this->DirectoryLister.GetFile(this->CurrentIdx++); if (isDirentryToIgnore(fname)) { continue; } if (cmsysString_strcasecmp(fname, this->DirName.data()) == 0) { auto candidate = cmStrCat(parent, '/', fname); if (cmSystemTools::FileIsDirectory(candidate)) { return candidate; } } } return {}; } void Reset() { this->Loaded = false; } private: cmsys::Directory DirectoryLister; const cm::string_view DirName; unsigned long CurrentIdx = 0ul; bool Loaded = false; }; class cmDirectoryListGenerator { public: cmDirectoryListGenerator(std::vector<std::string> const& names) : Names{ names } , Matches{} , Current{ this->Matches.cbegin() } { } virtual ~cmDirectoryListGenerator() = default; std::string GetNextCandidate(const std::string& parent) { // Construct a list of matches if not yet if (this->Matches.empty()) { cmsys::Directory directoryLister; // ALERT `Directory::Load()` keeps only names // internally and LOST entry type from `dirent`. // So, `Directory::FileIsDirectory` gonna use // `SystemTools::FileIsDirectory()` and waste a syscall. // TODO Need to enhance the `Directory` class. directoryLister.Load(parent); // ATTENTION Is it guaranteed that first two entries are // `.` and `..`? // TODO If so, just start with index 2 and drop the // `isDirentryToIgnore(i)` condition to check. for (auto i = 0ul; i < directoryLister.GetNumberOfFiles(); ++i) { const char* const fname = directoryLister.GetFile(i); if (isDirentryToIgnore(fname)) { continue; } for (const auto& n : this->Names.get()) { // NOTE Customization point for `cmMacProjectDirectoryListGenerator` const auto name = this->TransformNameBeforeCmp(n); // Skip entries that don't match and non-directories. // ATTENTION BTW, original code also didn't check if it's a symlink // to a directory! const auto equal = (cmsysString_strncasecmp(fname, name.c_str(), name.length()) == 0); if (equal && directoryLister.FileIsDirectory(i)) { this->Matches.emplace_back(fname); } } } // NOTE Customization point for `cmProjectDirectoryListGenerator` this->OnMatchesLoaded(); this->Current = this->Matches.cbegin(); } if (this->Current != this->Matches.cend()) { auto candidate = cmStrCat(parent, '/', *this->Current++); return candidate; } return {}; } void Reset() { this->Matches.clear(); this->Current = this->Matches.cbegin(); } protected: virtual void OnMatchesLoaded() {} virtual std::string TransformNameBeforeCmp(std::string same) { return same; } std::reference_wrapper<const std::vector<std::string>> Names; std::vector<std::string> Matches; std::vector<std::string>::const_iterator Current; }; class cmProjectDirectoryListGenerator : public cmDirectoryListGenerator { public: cmProjectDirectoryListGenerator(std::vector<std::string> const& names, cmFindPackageCommand::SortOrderType so, cmFindPackageCommand::SortDirectionType sd) : cmDirectoryListGenerator{ names } , SortOrder{ so } , SortDirection{ sd } { } protected: void OnMatchesLoaded() override { // check if there is a specific sorting order to perform if (this->SortOrder != cmFindPackageCommand::None) { cmFindPackageCommand::Sort(this->Matches.begin(), this->Matches.end(), this->SortOrder, this->SortDirection); } } private: // sort parameters const cmFindPackageCommand::SortOrderType SortOrder; const cmFindPackageCommand::SortDirectionType SortDirection; }; class cmMacProjectDirectoryListGenerator : public cmDirectoryListGenerator { public: cmMacProjectDirectoryListGenerator(const std::vector<std::string>& names, cm::string_view ext) : cmDirectoryListGenerator{ names } , Extension{ ext } { } protected: std::string TransformNameBeforeCmp(std::string name) override { return cmStrCat(name, this->Extension); } private: const cm::string_view Extension; }; class cmFileListGeneratorGlob { public: cmFileListGeneratorGlob(cm::string_view pattern) : Pattern(pattern) , Files{} , Current{} { } std::string GetNextCandidate(const std::string& parent) { if (this->Files.empty()) { // Glob the set of matching files. std::string expr = cmStrCat(parent, this->Pattern); cmsys::Glob g; if (!g.FindFiles(expr)) { return {}; } this->Files = g.GetFiles(); this->Current = this->Files.cbegin(); } // Skip non-directories for (; this->Current != this->Files.cend() && !cmSystemTools::FileIsDirectory(*this->Current); ++this->Current) { } return (this->Current != this->Files.cend()) ? *this->Current++ : std::string{}; } void Reset() { this->Files.clear(); this->Current = this->Files.cbegin(); } private: cm::string_view Pattern; std::vector<std::string> Files; std::vector<std::string>::const_iterator Current; }; #if defined(__LCC__) # define CM_LCC_DIAG_SUPPRESS_1222 # pragma diag_suppress 1222 // invalid error number (3288, but works anyway) # define CM_LCC_DIAG_SUPPRESS_3288 # pragma diag_suppress 3288 // parameter was declared but never referenced # define CM_LCC_DIAG_SUPPRESS_3301 # pragma diag_suppress 3301 // parameter was declared but never referenced # define CM_LCC_DIAG_SUPPRESS_3308 # pragma diag_suppress 3308 // parameter was declared but never referenced #endif void ResetGenerator() { } template <typename Generator> void ResetGenerator(Generator&& generator) { std::forward<Generator&&>(generator).Reset(); } template <typename Generator, typename... Generators> void ResetGenerator(Generator&& generator, Generators&&... generators) { ResetGenerator(std::forward<Generator&&>(generator)); ResetGenerator(std::forward<Generators&&>(generators)...); } template <typename CallbackFn> bool TryGeneratedPaths(CallbackFn&& filesCollector, const std::string& fullPath) { assert(!fullPath.empty() && fullPath.back() != '/'); return std::forward<CallbackFn&&>(filesCollector)(fullPath + '/'); } template <typename CallbackFn, typename Generator, typename... Rest> bool TryGeneratedPaths(CallbackFn&& filesCollector, const std::string& startPath, Generator&& gen, Rest&&... tail) { ResetGenerator(std::forward<Generator&&>(gen)); for (auto path = gen.GetNextCandidate(startPath); !path.empty(); path = gen.GetNextCandidate(startPath)) { ResetGenerator(std::forward<Rest&&>(tail)...); if (TryGeneratedPaths(std::forward<CallbackFn&&>(filesCollector), path, std::forward<Rest&&>(tail)...)) { return true; } } return false; } #ifdef CM_LCC_DIAG_SUPPRESS_3308 # undef CM_LCC_DIAG_SUPPRESS_3308 # pragma diag_default 3308 #endif #ifdef CM_LCC_DIAG_SUPPRESS_3301 # undef CM_LCC_DIAG_SUPPRESS_3301 # pragma diag_default 3301 #endif #ifdef CM_LCC_DIAG_SUPPRESS_3288 # undef CM_LCC_DIAG_SUPPRESS_3288 # pragma diag_default 3288 #endif #ifdef CM_LCC_DIAG_SUPPRESS_1222 # undef CM_LCC_DIAG_SUPPRESS_1222 # pragma diag_default 1222 #endif // Parse the version number and store the results that were // successfully parsed. int parseVersion(const std::string& version, unsigned int& major, unsigned int& minor, unsigned int& patch, unsigned int& tweak) { return std::sscanf(version.c_str(), "%u.%u.%u.%u", &major, &minor, &patch, &tweak); } } // anonymous namespace class cmFindPackageCommand::FlushDebugBufferOnExit { cmFindPackageCommand& Command; public: FlushDebugBufferOnExit(cmFindPackageCommand& command) : Command(command) { } ~FlushDebugBufferOnExit() { if (!Command.DebugBuffer.empty()) { Command.DebugMessage(Command.DebugBuffer); } } }; class cmFindPackageCommand::PushPopRootPathStack { cmFindPackageCommand& Command; public: PushPopRootPathStack(cmFindPackageCommand& command) : Command(command) { Command.PushFindPackageRootPathStack(); } ~PushPopRootPathStack() { Command.PopFindPackageRootPathStack(); } }; class cmFindPackageCommand::SetRestoreFindDefinitions { cmFindPackageCommand& Command; public: SetRestoreFindDefinitions( cmFindPackageCommand& command, const std::string& components, const std::vector<std::pair<std::string, const char*>>& componentVarDefs) : Command(command) { Command.SetModuleVariables(components, componentVarDefs); } ~SetRestoreFindDefinitions() { Command.RestoreFindDefinitions(); } }; cmFindPackageCommand::PathLabel cmFindPackageCommand::PathLabel::PackageRedirect("PACKAGE_REDIRECT"); cmFindPackageCommand::PathLabel cmFindPackageCommand::PathLabel::UserRegistry( "PACKAGE_REGISTRY"); cmFindPackageCommand::PathLabel cmFindPackageCommand::PathLabel::Builds( "BUILDS"); cmFindPackageCommand::PathLabel cmFindPackageCommand::PathLabel::SystemRegistry("SYSTEM_PACKAGE_REGISTRY"); const cm::string_view cmFindPackageCommand::VERSION_ENDPOINT_INCLUDED( "INCLUDE"); const cm::string_view cmFindPackageCommand::VERSION_ENDPOINT_EXCLUDED( "EXCLUDE"); void cmFindPackageCommand::Sort(std::vector<std::string>::iterator begin, std::vector<std::string>::iterator end, SortOrderType const order, SortDirectionType const dir) { if (order == Name_order) { if (dir == Dec) { std::sort(begin, end, std::greater<std::string>()); } else { std::sort(begin, end); } } else if (order == Natural) { // natural order uses letters and numbers (contiguous numbers digit are // compared such that e.g. 000 00 < 01 < 010 < 09 < 0 < 1 < 9 < 10 if (dir == Dec) { std::sort(begin, end, StrverscmpOp<std::greater>()); } else { std::sort(begin, end, StrverscmpOp<std::less>()); } } // else do not sort } cmFindPackageCommand::cmFindPackageCommand(cmExecutionStatus& status) : cmFindCommon(status) , VersionRangeMin(VERSION_ENDPOINT_INCLUDED) , VersionRangeMax(VERSION_ENDPOINT_INCLUDED) { this->CMakePathName = "PACKAGE"; this->DebugMode = false; this->AppendSearchPathGroups(); this->DeprecatedFindModules["Boost"] = cmPolicies::CMP0167; this->DeprecatedFindModules["CUDA"] = cmPolicies::CMP0146; this->DeprecatedFindModules["Dart"] = cmPolicies::CMP0145; this->DeprecatedFindModules["PythonInterp"] = cmPolicies::CMP0148; this->DeprecatedFindModules["PythonLibs"] = cmPolicies::CMP0148; this->DeprecatedFindModules["Qt"] = cmPolicies::CMP0084; } void cmFindPackageCommand::AppendSearchPathGroups() { // Update the All group with new paths. Note that package redirection must // take precedence over everything else, so it has to be first in the array. std::vector<cmFindCommon::PathLabel>* const labels = &this->PathGroupLabelMap[PathGroup::All]; labels->insert(labels->begin(), PathLabel::PackageRedirect); labels->insert( std::find(labels->begin(), labels->end(), PathLabel::CMakeSystem), PathLabel::UserRegistry); labels->insert( std::find(labels->begin(), labels->end(), PathLabel::CMakeSystem), PathLabel::Builds); labels->insert(std::find(labels->begin(), labels->end(), PathLabel::Guess), PathLabel::SystemRegistry); // Create the new path objects this->LabeledPaths.insert( std::make_pair(PathLabel::PackageRedirect, cmSearchPath(this))); this->LabeledPaths.insert( std::make_pair(PathLabel::UserRegistry, cmSearchPath(this))); this->LabeledPaths.insert( std::make_pair(PathLabel::Builds, cmSearchPath(this))); this->LabeledPaths.insert( std::make_pair(PathLabel::SystemRegistry, cmSearchPath(this))); } bool cmFindPackageCommand::InitialPass(std::vector<std::string> const& args) { if (args.empty()) { this->SetError("called with incorrect number of arguments"); return false; } // Lookup required version of CMake. if (cmValue const rv = this->Makefile->GetDefinition("CMAKE_MINIMUM_REQUIRED_VERSION")) { unsigned int v[3] = { 0, 0, 0 }; std::sscanf(rv->c_str(), "%u.%u.%u", &v[0], &v[1], &v[2]); this->RequiredCMakeVersion = CMake_VERSION_ENCODE(v[0], v[1], v[2]); } // Lookup target architecture, if any. if (cmValue const arch = this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE")) { this->LibraryArchitecture = *arch; } // Lookup whether lib32 paths should be used. if (this->Makefile->PlatformIs32Bit() && this->Makefile->GetState()->GetGlobalPropertyAsBool( "FIND_LIBRARY_USE_LIB32_PATHS")) { this->UseLib32Paths = true; } // Lookup whether lib64 paths should be used. if (this->Makefile->PlatformIs64Bit() && this->Makefile->GetState()->GetGlobalPropertyAsBool( "FIND_LIBRARY_USE_LIB64_PATHS")) { this->UseLib64Paths = true; } // Lookup whether libx32 paths should be used. if (this->Makefile->PlatformIsx32() && this->Makefile->GetState()->GetGlobalPropertyAsBool( "FIND_LIBRARY_USE_LIBX32_PATHS")) { this->UseLibx32Paths = true; } // Check if User Package Registry should be disabled // The `CMAKE_FIND_USE_PACKAGE_REGISTRY` has // priority over the deprecated CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY if (cmValue const def = this->Makefile->GetDefinition("CMAKE_FIND_USE_PACKAGE_REGISTRY")) { this->NoUserRegistry = !def.IsOn(); } else if (this->Makefile->IsOn("CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY")) { this->NoUserRegistry = true; } // Check if System Package Registry should be disabled // The `CMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY` has // priority over the deprecated CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY if (cmValue const def = this->Makefile->GetDefinition( "CMAKE_FIND_USE_SYSTEM_PACKAGE_REGISTRY")) { this->NoSystemRegistry = !def.IsOn(); } else if (this->Makefile->IsOn( "CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY")) { this->NoSystemRegistry = true; } // Check whether we should resolve symlinks when finding packages if (this->Makefile->IsOn("CMAKE_FIND_PACKAGE_RESOLVE_SYMLINKS")) { this->UseRealPath = true; } // Check if Sorting should be enabled if (cmValue const so = this->Makefile->GetDefinition("CMAKE_FIND_PACKAGE_SORT_ORDER")) { if (*so == "NAME") { this->SortOrder = Name_order; } else if (*so == "NATURAL") { this->SortOrder = Natural; } else { this->SortOrder = None; } } if (cmValue const sd = this->Makefile->GetDefinition("CMAKE_FIND_PACKAGE_SORT_DIRECTION")) { this->SortDirection = (*sd == "ASC") ? Asc : Dec; } // Find what search path locations have been enabled/disable this->SelectDefaultSearchModes(); // Find the current root path mode. this->SelectDefaultRootPathMode(); // Find the current bundle/framework search policy. this->SelectDefaultMacMode(); // Record options. this->Name = args[0]; std::string components; const char* components_sep = ""; std::set<std::string> requiredComponents; std::set<std::string> optionalComponents; std::vector<std::pair<std::string, const char*>> componentVarDefs; bool bypassProvider = false; // Always search directly in a generated path. this->SearchPathSuffixes.emplace_back(); // Process debug mode cmMakefile::DebugFindPkgRAII debugFindPkgRAII(this->Makefile, this->Name); this->DebugMode = this->ComputeIfDebugModeWanted(); // Parse the arguments. enum Doing { DoingNone, DoingComponents, DoingOptionalComponents, DoingNames, DoingPaths, DoingPathSuffixes, DoingConfigs, DoingHints }; Doing doing = DoingNone; cmsys::RegularExpression versionRegex( R"V(^([0-9]+(\.[0-9]+)*)(\.\.\.(<?)([0-9]+(\.[0-9]+)*))?$)V"); bool haveVersion = false; std::vector<std::size_t> configArgs; std::vector<std::size_t> moduleArgs; for (std::size_t i = 1u; i < args.size(); ++i) { if (args[i] == "QUIET") { this->Quiet = true; doing = DoingNone; } else if (args[i] == "BYPASS_PROVIDER") { bypassProvider = true; doing = DoingNone; } else if (args[i] == "EXACT") { this->VersionExact = true; doing = DoingNone; } else if (args[i] == "GLOBAL") { this->GlobalScope = true; doing = DoingNone; } else if (args[i] == "MODULE") { moduleArgs.push_back(i); doing = DoingNone; // XXX(clang-tidy): https://bugs.llvm.org/show_bug.cgi?id=44165 // NOLINTNEXTLINE(bugprone-branch-clone) } else if (args[i] == "CONFIG") { configArgs.push_back(i); doing = DoingNone; // XXX(clang-tidy): https://bugs.llvm.org/show_bug.cgi?id=44165 // NOLINTNEXTLINE(bugprone-branch-clone) } else if (args[i] == "NO_MODULE") { configArgs.push_back(i); doing = DoingNone; } else if (args[i] == "REQUIRED") { this->Required = true; doing = DoingComponents; } else if (args[i] == "COMPONENTS") { doing = DoingComponents; } else if (args[i] == "OPTIONAL_COMPONENTS") { doing = DoingOptionalComponents; } else if (args[i] == "NAMES") { configArgs.push_back(i); doing = DoingNames; } else if (args[i] == "PATHS") { configArgs.push_back(i); doing = DoingPaths; } else if (args[i] == "HINTS") { configArgs.push_back(i); doing = DoingHints; } else if (args[i] == "PATH_SUFFIXES") { configArgs.push_back(i); doing = DoingPathSuffixes; } else if (args[i] == "CONFIGS") { configArgs.push_back(i); doing = DoingConfigs; } else if (args[i] == "NO_POLICY_SCOPE") { this->PolicyScope = false; doing = DoingNone; } else if (args[i] == "NO_CMAKE_PACKAGE_REGISTRY") { this->NoUserRegistry = true; configArgs.push_back(i); doing = DoingNone; } else if (args[i] == "NO_CMAKE_SYSTEM_PACKAGE_REGISTRY") { this->NoSystemRegistry = true; configArgs.push_back(i); doing = DoingNone; // XXX(clang-tidy): https://bugs.llvm.org/show_bug.cgi?id=44165 // NOLINTNEXTLINE(bugprone-branch-clone) } else if (args[i] == "NO_CMAKE_BUILDS_PATH") { // Ignore legacy option. configArgs.push_back(i); doing = DoingNone; } else if (args[i] == "REGISTRY_VIEW") { if (++i == args.size()) { this->SetError("missing required argument for \"REGISTRY_VIEW\""); return false; } auto view = cmWindowsRegistry::ToView(args[i]); if (view) { this->RegistryView = *view; this->RegistryViewDefined = true; } else { this->SetError( cmStrCat("given invalid value for \"REGISTRY_VIEW\": ", args[i])); return false; } } else if (this->CheckCommonArgument(args[i])) { configArgs.push_back(i); doing = DoingNone; } else if ((doing == DoingComponents) || (doing == DoingOptionalComponents)) { // Set a variable telling the find script whether this component // is required. const char* isRequired = "1"; if (doing == DoingOptionalComponents) { isRequired = "0"; optionalComponents.insert(args[i]); } else { requiredComponents.insert(args[i]); } componentVarDefs.emplace_back(this->Name + "_FIND_REQUIRED_" + args[i], isRequired); // Append to the list of required components. components += components_sep; components += args[i]; components_sep = ";"; } else if (doing == DoingNames) { this->Names.push_back(args[i]); } else if (doing == DoingPaths) { this->UserGuessArgs.push_back(args[i]); } else if (doing == DoingHints) { this->UserHintsArgs.push_back(args[i]); } else if (doing == DoingPathSuffixes) { this->AddPathSuffix(args[i]); } else if (doing == DoingConfigs) { if (args[i].find_first_of(":/\\") != std::string::npos || cmSystemTools::GetFilenameLastExtension(args[i]) != ".cmake") { this->SetError(cmStrCat( "given CONFIGS option followed by invalid file name \"", args[i], "\". The names given must be file names without " "a path and with a \".cmake\" extension.")); return false; } this->Configs.push_back(args[i]); } else if (!haveVersion && versionRegex.find(args[i])) { haveVersion = true; this->VersionComplete = args[i]; } else { this->SetError( cmStrCat("called with invalid argument \"", args[i], "\"")); return false; } } if (!this->GlobalScope) { cmValue value( this->Makefile->GetDefinition("CMAKE_FIND_PACKAGE_TARGETS_GLOBAL")); this->GlobalScope = value.IsOn(); } std::vector<std::string> doubledComponents; std::set_intersection(requiredComponents.begin(), requiredComponents.end(), optionalComponents.begin(), optionalComponents.end(), std::back_inserter(doubledComponents)); if (!doubledComponents.empty()) { this->SetError( cmStrCat("called with components that are both required and " "optional:\n", cmWrap(" ", doubledComponents, "", "\n"), "\n")); return false; } // Check and eliminate search modes not allowed by the args provided this->UseFindModules = configArgs.empty(); this->UseConfigFiles = moduleArgs.empty(); if (!this->UseFindModules && !this->UseConfigFiles) { std::ostringstream e; e << "given options exclusive to Module mode:\n"; for (auto si : moduleArgs) { e << " " << args[si] << "\n"; } e << "and options exclusive to Config mode:\n"; for (auto si : configArgs) { e << " " << args[si] << "\n"; } e << "The options are incompatible."; this->SetError(e.str()); return false; } // Ignore EXACT with no version. if (this->VersionComplete.empty() && this->VersionExact) { this->VersionExact = false; this->Makefile->IssueMessage( MessageType::AUTHOR_WARNING, "Ignoring EXACT since no version is requested."); } if (this->VersionComplete.empty() || components.empty()) { // Check whether we are recursing inside "Find<name>.cmake" within // another find_package(<name>) call. std::string const mod = cmStrCat(this->Name, "_FIND_MODULE"); if (this->Makefile->IsOn(mod)) { if (this->VersionComplete.empty()) { // Get version information from the outer call if necessary. // Requested version string. std::string const ver = cmStrCat(this->Name, "_FIND_VERSION_COMPLETE"); this->VersionComplete = this->Makefile->GetSafeDefinition(ver); // Whether an exact version is required. std::string const exact = cmStrCat(this->Name, "_FIND_VERSION_EXACT"); this->VersionExact = this->Makefile->IsOn(exact); } if (components.empty()) { std::string const components_var = this->Name + "_FIND_COMPONENTS"; components = this->Makefile->GetSafeDefinition(components_var); } } } // fill various parts of version specification if (!this->VersionComplete.empty()) { if (!versionRegex.find(this->VersionComplete)) { this->SetError("called with invalid version specification."); return false; } this->Version = versionRegex.match(1); this->VersionMax = versionRegex.match(5); if (versionRegex.match(4) == "<"_s) { this->VersionRangeMax = VERSION_ENDPOINT_EXCLUDED; } if (!this->VersionMax.empty()) { this->VersionRange = this->VersionComplete; } } if (!this->VersionRange.empty()) { // version range must not be empty if ((this->VersionRangeMax == VERSION_ENDPOINT_INCLUDED && cmSystemTools::VersionCompareGreater(this->Version, this->VersionMax)) || (this->VersionRangeMax == VERSION_ENDPOINT_EXCLUDED && cmSystemTools::VersionCompareGreaterEq(this->Version, this->VersionMax))) { this->SetError("specified version range is empty."); return false; } } if (this->VersionExact && !this->VersionRange.empty()) { this->SetError("EXACT cannot be specified with a version range."); return false; } if (!this->Version.empty()) { this->VersionCount = parseVersion(this->Version, this->VersionMajor, this->VersionMinor, this->VersionPatch, this->VersionTweak); } if (!this->VersionMax.empty()) { this->VersionMaxCount = parseVersion( this->VersionMax, this->VersionMaxMajor, this->VersionMaxMinor, this->VersionMaxPatch, this->VersionMaxTweak); } const std::string makePackageRequiredVar = cmStrCat("CMAKE_REQUIRE_FIND_PACKAGE_", this->Name); const bool makePackageRequiredSet = this->Makefile->IsOn(makePackageRequiredVar); if (makePackageRequiredSet) { if (this->Required) { this->Makefile->IssueMessage( MessageType::WARNING, cmStrCat("for module ", this->Name, " already called with REQUIRED, thus ", makePackageRequiredVar, " has no effect.")); } else { this->Required = true; } } std::string const disableFindPackageVar = cmStrCat("CMAKE_DISABLE_FIND_PACKAGE_", this->Name); if (this->Makefile->IsOn(disableFindPackageVar)) { if (this->Required) { this->SetError( cmStrCat("for module ", this->Name, (makePackageRequiredSet ? " was made REQUIRED with " + makePackageRequiredVar : " called with REQUIRED, "), " but ", disableFindPackageVar, " is enabled. A REQUIRED package cannot be disabled.")); return false; } return true; } // Restore PACKAGE_PREFIX_DIR to its pre-call value when we return. If our // caller is a file generated by configure_package_config_file(), and if // the package we are about to load also has a config file created by that // command, it will overwrite PACKAGE_PREFIX_DIR. We need to restore it in // case something still refers to it in our caller's scope after we return. class RestoreVariableOnLeavingScope { cmMakefile* makefile_; cm::optional<std::string> value_; public: RestoreVariableOnLeavingScope(cmMakefile* makefile) : makefile_(makefile) { cmValue v = makefile->GetDefinition("PACKAGE_PREFIX_DIR"); if (v) { value_ = *v; } } ~RestoreVariableOnLeavingScope() { if (this->value_) { makefile_->AddDefinition("PACKAGE_PREFIX_DIR", *value_); } else { makefile_->RemoveDefinition("PACKAGE_PREFIX_DIR"); } } }; RestoreVariableOnLeavingScope restorePackagePrefixDir(this->Makefile); // Now choose what method(s) we will use to satisfy the request. Note that // we still want all the above checking of arguments, etc. regardless of the // method used. This will ensure ill-formed arguments are caught earlier, // before things like dependency providers need to deal with them. // A dependency provider (if set) gets first look before other methods. // We do this before modifying the package root path stack because a // provider might use methods that ignore that. cmState* const state = this->Makefile->GetState(); cmState::Command const providerCommand = state->GetDependencyProviderCommand( cmDependencyProvider::Method::FindPackage); if (bypassProvider) { if (this->DebugMode && providerCommand) { this->DebugMessage( "BYPASS_PROVIDER given, skipping dependency provider"); } } else if (providerCommand) { if (this->DebugMode) { this->DebugMessage(cmStrCat("Trying dependency provider command: ", state->GetDependencyProvider()->GetCommand(), "()")); } std::vector<cmListFileArgument> listFileArgs(args.size() + 1); listFileArgs[0] = cmListFileArgument("FIND_PACKAGE", cmListFileArgument::Unquoted, 0); std::transform(args.begin(), args.end(), listFileArgs.begin() + 1, [](const std::string& arg) { return cmListFileArgument(arg, cmListFileArgument::Bracket, 0); }); if (!providerCommand(listFileArgs, this->Status)) { return false; } if (this->Makefile->IsOn(cmStrCat(this->Name, "_FOUND"))) { if (this->DebugMode) { this->DebugMessage("Package was found by the dependency provider"); } this->AppendSuccessInformation(); return true; } } // Limit package nesting depth well below the recursion depth limit because // find_package nesting uses more stack space than normal recursion. { static std::size_t const findPackageDepthMinMax = 100; std::size_t const findPackageDepthMax = std::max( this->Makefile->GetRecursionDepthLimit() / 2, findPackageDepthMinMax); std::size_t const findPackageDepth = this->Makefile->FindPackageRootPathStack.size() + 1; if (findPackageDepth > findPackageDepthMax) { this->SetError(cmStrCat("maximum nesting depth of ", findPackageDepthMax, " exceeded.")); return false; } } // RAII objects to ensure we leave this function with consistent state FlushDebugBufferOnExit flushDebugBufferOnExit(*this); PushPopRootPathStack pushPopRootPathStack(*this); SetRestoreFindDefinitions setRestoreFindDefinitions(*this, components, componentVarDefs); cmMakefile::FindPackageStackRAII findPackageStackRAII(this->Makefile, this->Name); // See if we have been told to delegate to FetchContent or some other // redirected config package first. We have to check all names that // find_package() may look for, but only need to invoke the override for the // first one that matches. auto overrideNames = this->Names; if (overrideNames.empty()) { overrideNames.push_back(this->Name); } bool forceConfigMode = false; const auto redirectsDir = this->Makefile->GetSafeDefinition("CMAKE_FIND_PACKAGE_REDIRECTS_DIR"); for (const auto& overrideName : overrideNames) { const auto nameLower = cmSystemTools::LowerCase(overrideName); const auto delegatePropName = cmStrCat("_FetchContent_", nameLower, "_override_find_package"); const cmValue delegateToFetchContentProp = this->Makefile->GetState()->GetGlobalProperty(delegatePropName); if (delegateToFetchContentProp.IsOn()) { // When this property is set, the FetchContent module has already been // included at least once, so we know the FetchContent_MakeAvailable() // command will be defined. Any future find_package() calls after this // one for this package will by-pass this once-only delegation. // The following call will typically create a <name>-config.cmake file // in the redirectsDir, which we still want to process like any other // config file to ensure we follow normal find_package() processing. cmListFileFunction func( "FetchContent_MakeAvailable", 0, 0, { cmListFileArgument(overrideName, cmListFileArgument::Unquoted, 0) }); if (!this->Makefile->ExecuteCommand(func, this->Status)) { return false; } } if (cmSystemTools::FileExists( cmStrCat(redirectsDir, '/', nameLower, "-config.cmake")) || cmSystemTools::FileExists( cmStrCat(redirectsDir, '/', overrideName, "Config.cmake"))) { // Force the use of this redirected config package file, regardless of // the type of find_package() call. Files in the redirectsDir must always // take priority over everything else. forceConfigMode = true; this->UseConfigFiles = true; this->UseFindModules = false; this->Names.clear(); this->Names.emplace_back(overrideName); // Force finding this one this->Variable = cmStrCat(this->Name, "_DIR"); this->SetConfigDirCacheVariable(redirectsDir); break; } } // See if there is a Find<PackageName>.cmake module. bool loadedPackage = false; if (forceConfigMode) { loadedPackage = this->FindPackageUsingConfigMode(); } else if (this->Makefile->IsOn("CMAKE_FIND_PACKAGE_PREFER_CONFIG")) { if (this->UseConfigFiles && this->FindPackageUsingConfigMode()) { loadedPackage = true; } else { if (this->FindPackageUsingModuleMode()) { loadedPackage = true; } else { // The package was not loaded. Report errors. if (this->HandlePackageMode(HandlePackageModeType::Module)) { loadedPackage = true; } } } } else { if (this->UseFindModules && this->FindPackageUsingModuleMode()) { loadedPackage = true; } else { // Handle CMAKE_FIND_PACKAGE_WARN_NO_MODULE (warn when CONFIG mode is // implicitly assumed) if (this->UseFindModules && this->UseConfigFiles && this->Makefile->IsOn("CMAKE_FIND_PACKAGE_WARN_NO_MODULE")) { std::ostringstream aw; if (this->RequiredCMakeVersion >= CMake_VERSION_ENCODE(2, 8, 8)) { aw << "find_package called without either MODULE or CONFIG option " "and " "no Find" << this->Name << ".cmake module is in CMAKE_MODULE_PATH. " "Add MODULE to exclusively request Module mode and fail if " "Find" << this->Name << ".cmake is missing. " "Add CONFIG to exclusively request Config mode and search for " "a " "package configuration file provided by " << this->Name << " (" << this->Name << "Config.cmake or " << cmSystemTools::LowerCase(this->Name) << "-config.cmake). "; } else { aw << "find_package called without NO_MODULE option and no " "Find" << this->Name << ".cmake module is in CMAKE_MODULE_PATH. " "Add NO_MODULE to exclusively request Config mode and search " "for a " "package configuration file provided by " << this->Name << " (" << this->Name << "Config.cmake or " << cmSystemTools::LowerCase(this->Name) << "-config.cmake). Otherwise make Find" << this->Name << ".cmake available in CMAKE_MODULE_PATH."; } aw << "\n" "(Variable CMAKE_FIND_PACKAGE_WARN_NO_MODULE enabled this " "warning.)"; this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, aw.str()); } if (this->FindPackageUsingConfigMode()) { loadedPackage = true; } } } this->AppendSuccessInformation(); return loadedPackage; } bool cmFindPackageCommand::FindPackageUsingModuleMode() { bool foundModule = false; if (!this->FindModule(foundModule)) { return false; } return foundModule; } bool cmFindPackageCommand::FindPackageUsingConfigMode() { this->Variable = cmStrCat(this->Name, "_DIR"); // Add the default name. if (this->Names.empty()) { this->Names.push_back(this->Name); } // Add the default configs. if (this->Configs.empty()) { for (std::string const& n : this->Names) { std::string config = cmStrCat(n, "Config.cmake"); this->Configs.push_back(config); config = cmStrCat(cmSystemTools::LowerCase(n), "-config.cmake"); this->Configs.push_back(std::move(config)); } } // get igonored paths from vars and reroot them. std::vector<std::string> ignored; this->GetIgnoredPaths(ignored); this->RerootPaths(ignored); // Construct a set of ignored paths this->IgnoredPaths.clear(); this->IgnoredPaths.insert(ignored.begin(), ignored.end()); // get igonored prefix paths from vars and reroot them. std::vector<std::string> ignoredPrefixes; this->GetIgnoredPrefixPaths(ignoredPrefixes); this->RerootPaths(ignoredPrefixes); // Construct a set of ignored prefix paths this->IgnoredPrefixPaths.clear(); this->IgnoredPrefixPaths.insert(ignoredPrefixes.begin(), ignoredPrefixes.end()); // Find and load the package. return this->HandlePackageMode(HandlePackageModeType::Config); } void cmFindPackageCommand::SetVersionVariables( const std::function<void(const std::string&, cm::string_view)>& addDefinition, const std::string& prefix, const std::string& version, const unsigned int count, const unsigned int major, const unsigned int minor, const unsigned int patch, const unsigned int tweak) { addDefinition(prefix, version); char buf[64]; snprintf(buf, sizeof(buf), "%u", major); addDefinition(prefix + "_MAJOR", buf); snprintf(buf, sizeof(buf), "%u", minor); addDefinition(prefix + "_MINOR", buf); snprintf(buf, sizeof(buf), "%u", patch); addDefinition(prefix + "_PATCH", buf); snprintf(buf, sizeof(buf), "%u", tweak); addDefinition(prefix + "_TWEAK", buf); snprintf(buf, sizeof(buf), "%u", count); addDefinition(prefix + "_COUNT", buf); } void cmFindPackageCommand::SetModuleVariables( const std::string& components, const std::vector<std::pair<std::string, const char*>>& componentVarDefs) { this->AddFindDefinition("CMAKE_FIND_PACKAGE_NAME", this->Name); // Store the list of components and associated variable definitions std::string components_var = this->Name + "_FIND_COMPONENTS"; this->AddFindDefinition(components_var, components); for (const auto& varDef : componentVarDefs) { this->AddFindDefinition(varDef.first, varDef.second); } if (this->Quiet) { // Tell the module that is about to be read that it should find // quietly. std::string quietly = cmStrCat(this->Name, "_FIND_QUIETLY"); this->AddFindDefinition(quietly, "1"_s); } if (this->Required) { // Tell the module that is about to be read that it should report // a fatal error if the package is not found. std::string req = cmStrCat(this->Name, "_FIND_REQUIRED"); this->AddFindDefinition(req, "1"_s); } if (!this->VersionComplete.empty()) { std::string req = cmStrCat(this->Name, "_FIND_VERSION_COMPLETE"); this->AddFindDefinition(req, this->VersionComplete); } // Tell the module that is about to be read what version of the // package has been requested. auto addDefinition = [this](const std::string& variable, cm::string_view value) { this->AddFindDefinition(variable, value); }; if (!this->Version.empty()) { auto prefix = cmStrCat(this->Name, "_FIND_VERSION"_s); this->SetVersionVariables(addDefinition, prefix, this->Version, this->VersionCount, this->VersionMajor, this->VersionMinor, this->VersionPatch, this->VersionTweak); // Tell the module whether an exact version has been requested. auto exact = cmStrCat(this->Name, "_FIND_VERSION_EXACT"); this->AddFindDefinition(exact, this->VersionExact ? "1"_s : "0"_s); } if (!this->VersionRange.empty()) { auto prefix = cmStrCat(this->Name, "_FIND_VERSION_MIN"_s); this->SetVersionVariables(addDefinition, prefix, this->Version, this->VersionCount, this->VersionMajor, this->VersionMinor, this->VersionPatch, this->VersionTweak); prefix = cmStrCat(this->Name, "_FIND_VERSION_MAX"_s); this->SetVersionVariables(addDefinition, prefix, this->VersionMax, this->VersionMaxCount, this->VersionMaxMajor, this->VersionMaxMinor, this->VersionMaxPatch, this->VersionMaxTweak); auto id = cmStrCat(this->Name, "_FIND_VERSION_RANGE"); this->AddFindDefinition(id, this->VersionRange); id = cmStrCat(this->Name, "_FIND_VERSION_RANGE_MIN"); this->AddFindDefinition(id, this->VersionRangeMin); id = cmStrCat(this->Name, "_FIND_VERSION_RANGE_MAX"); this->AddFindDefinition(id, this->VersionRangeMax); } if (this->RegistryViewDefined) { this->AddFindDefinition(cmStrCat(this->Name, "_FIND_REGISTRY_VIEW"), cmWindowsRegistry::FromView(this->RegistryView)); } } void cmFindPackageCommand::AddFindDefinition(const std::string& var, const cm::string_view value) { if (cmValue old = this->Makefile->GetDefinition(var)) { this->OriginalDefs[var].exists = true; this->OriginalDefs[var].value = *old; } else { this->OriginalDefs[var].exists = false; } this->Makefile->AddDefinition(var, value); } void cmFindPackageCommand::RestoreFindDefinitions() { for (auto const& i : this->OriginalDefs) { OriginalDef const& od = i.second; if (od.exists) { this->Makefile->AddDefinition(i.first, od.value); } else { this->Makefile->RemoveDefinition(i.first); } } } bool cmFindPackageCommand::FindModule(bool& found) { std::string moduleFileName = cmStrCat("Find", this->Name, ".cmake"); bool system = false; std::string debugBuffer = cmStrCat( "find_package considered the following paths for ", moduleFileName, ":\n"); std::string mfile = this->Makefile->GetModulesFile( moduleFileName, system, this->DebugMode, debugBuffer); if (this->DebugMode) { if (mfile.empty()) { debugBuffer = cmStrCat(debugBuffer, "The file was not found.\n"); } else { debugBuffer = cmStrCat(debugBuffer, "The file was found at\n ", mfile, "\n"); } this->DebugBuffer = cmStrCat(this->DebugBuffer, debugBuffer); } if (!mfile.empty()) { if (system) { auto const it = this->DeprecatedFindModules.find(this->Name); if (it != this->DeprecatedFindModules.end()) { cmPolicies::PolicyStatus status = this->Makefile->GetPolicyStatus(it->second); switch (status) { case cmPolicies::WARN: { this->Makefile->IssueMessage( MessageType::AUTHOR_WARNING, cmStrCat(cmPolicies::GetPolicyWarning(it->second), "\n")); CM_FALLTHROUGH; } case cmPolicies::OLD: break; case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_ALWAYS: case cmPolicies::NEW: return true; } } } // Load the module we found, and set "<name>_FIND_MODULE" to true // while inside it. found = true; std::string const var = cmStrCat(this->Name, "_FIND_MODULE"); this->Makefile->AddDefinition(var, "1"); bool result = this->ReadListFile(mfile, DoPolicyScope); this->Makefile->RemoveDefinition(var); if (this->DebugMode) { std::string const foundVar = cmStrCat(this->Name, "_FOUND"); if (this->Makefile->IsDefinitionSet(foundVar) && !this->Makefile->IsOn(foundVar)) { this->DebugBuffer = cmStrCat( this->DebugBuffer, "The module is considered not found due to ", foundVar, " being FALSE."); } } return result; } return true; } bool cmFindPackageCommand::HandlePackageMode( const HandlePackageModeType handlePackageModeType) { this->ConsideredConfigs.clear(); // Try to find the config file. cmValue def = this->Makefile->GetDefinition(this->Variable); // Try to load the config file if the directory is known bool fileFound = false; if (this->UseConfigFiles) { if (!def.IsOff()) { // Get the directory from the variable value. std::string dir = *def; cmSystemTools::ConvertToUnixSlashes(dir); // Treat relative paths with respect to the current source dir. if (!cmSystemTools::FileIsFullPath(dir)) { dir = "/" + dir; dir = this->Makefile->GetCurrentSourceDirectory() + dir; } // The file location was cached. Look for the correct file. std::string file; if (this->FindConfigFile(dir, file)) { this->FileFound = file; fileFound = true; } def = this->Makefile->GetDefinition(this->Variable); } // Search for the config file if it is not already found. if (def.IsOff() || !fileFound) { fileFound = this->FindConfig(); } // Sanity check. if (fileFound && this->FileFound.empty()) { this->Makefile->IssueMessage( MessageType::INTERNAL_ERROR, "fileFound is true but FileFound is empty!"); fileFound = false; } } std::string const foundVar = cmStrCat(this->Name, "_FOUND"); std::string const notFoundMessageVar = cmStrCat(this->Name, "_NOT_FOUND_MESSAGE"); std::string notFoundMessage; // If the directory for the config file was found, try to read the file. bool result = true; bool found = false; bool configFileSetFOUNDFalse = false; if (fileFound) { if (this->Makefile->IsDefinitionSet(foundVar) && !this->Makefile->IsOn(foundVar)) { // by removing Foo_FOUND here if it is FALSE, we don't really change // the situation for the Config file which is about to be included, // but we make it possible to detect later on whether the Config file // has set Foo_FOUND to FALSE itself: this->Makefile->RemoveDefinition(foundVar); } this->Makefile->RemoveDefinition(notFoundMessageVar); // Set the version variables before loading the config file. // It may override them. this->StoreVersionFound(); // Parse the configuration file. if (this->ReadListFile(this->FileFound, DoPolicyScope)) { // The package has been found. found = true; // Check whether the Config file has set Foo_FOUND to FALSE: if (this->Makefile->IsDefinitionSet(foundVar) && !this->Makefile->IsOn(foundVar)) { // we get here if the Config file has set Foo_FOUND actively to FALSE found = false; configFileSetFOUNDFalse = true; notFoundMessage = this->Makefile->GetSafeDefinition(notFoundMessageVar); } } else { // The configuration file is invalid. result = false; } } if (this->UseFindModules && !found && handlePackageModeType == HandlePackageModeType::Config && this->Makefile->IsOn("CMAKE_FIND_PACKAGE_PREFER_CONFIG")) { // Config mode failed. Allow Module case. result = false; } // package not found if (result && !found) { // warn if package required or neither quiet nor in config mode if (this->Required || !(this->Quiet || (this->UseConfigFiles && !this->UseFindModules && this->ConsideredConfigs.empty()))) { // The variable is not set. std::ostringstream e; std::ostringstream aw; if (configFileSetFOUNDFalse) { /* clang-format off */ e << "Found package configuration file:\n" " " << this->FileFound << "\n" "but it set " << foundVar << " to FALSE so package \"" << this->Name << "\" is considered to be NOT FOUND."; /* clang-format on */ if (!notFoundMessage.empty()) { e << " Reason given by package: \n" << notFoundMessage << "\n"; } } // If there are files in ConsideredConfigs, it means that FooConfig.cmake // have been found, but they didn't have appropriate versions. else if (!this->ConsideredConfigs.empty()) { auto duplicate_end = cmRemoveDuplicates(this->ConsideredConfigs); e << "Could not find a configuration file for package \"" << this->Name << "\" that " << (this->VersionExact ? "exactly matches" : "is compatible with") << " requested version " << (this->VersionRange.empty() ? "" : "range ") << "\"" << this->VersionComplete << "\".\n" "The following configuration files were considered but not " "accepted:\n"; for (ConfigFileInfo const& info : cmMakeRange(this->ConsideredConfigs.cbegin(), duplicate_end)) { e << " " << info.filename << ", version: " << info.version << "\n"; } } else { std::string requestedVersionString; if (!this->VersionComplete.empty()) { requestedVersionString = cmStrCat(" (requested version ", this->VersionComplete, ')'); } if (this->UseConfigFiles) { if (this->UseFindModules) { e << "By not providing \"Find" << this->Name << ".cmake\" in " "CMAKE_MODULE_PATH this project has asked CMake to find a " "package configuration file provided by \"" << this->Name << "\", " "but CMake did not find one.\n"; } if (this->Configs.size() == 1) { e << "Could not find a package configuration file named \"" << this->Configs[0] << "\" provided by package \"" << this->Name << "\"" << requestedVersionString << ".\n"; } else { e << "Could not find a package configuration file provided by \"" << this->Name << "\"" << requestedVersionString << " with any of the following names:\n" << cmWrap(" ", this->Configs, "", "\n") << "\n"; } e << "Add the installation prefix of \"" << this->Name << "\" to " "CMAKE_PREFIX_PATH or set \"" << this->Variable << "\" to a " "directory containing one of the above files. " "If \"" << this->Name << "\" provides a separate development " "package or SDK, be sure it has been installed."; } else // if(!this->UseFindModules && !this->UseConfigFiles) { e << "No \"Find" << this->Name << ".cmake\" found in " "CMAKE_MODULE_PATH."; aw << "Find" << this->Name << ".cmake must either be part of this " "project itself, in this case adjust CMAKE_MODULE_PATH so that " "it points to the correct location inside its source tree.\n" "Or it must be installed by a package which has already been " "found via find_package(). In this case make sure that " "package has indeed been found and adjust CMAKE_MODULE_PATH to " "contain the location where that package has installed " "Find" << this->Name << ".cmake. This must be a location " "provided by that package. This error in general means that " "the buildsystem of this project is relying on a Find-module " "without ensuring that it is actually available.\n"; } } this->Makefile->IssueMessage(this->Required ? MessageType::FATAL_ERROR : MessageType::WARNING, e.str()); if (this->Required) { cmSystemTools::SetFatalErrorOccurred(); } if (!aw.str().empty()) { this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, aw.str()); } } // output result if in config mode but not in quiet mode else if (!this->Quiet) { this->Makefile->DisplayStatus(cmStrCat("Could NOT find ", this->Name, " (missing: ", this->Name, "_DIR)"), -1); } } // Set a variable marking whether the package was found. this->Makefile->AddDefinition(foundVar, found ? "1" : "0"); // Set a variable naming the configuration file that was found. std::string const fileVar = cmStrCat(this->Name, "_CONFIG"); if (found) { this->Makefile->AddDefinition(fileVar, this->FileFound); } else { this->Makefile->RemoveDefinition(fileVar); } std::string const consideredConfigsVar = cmStrCat(this->Name, "_CONSIDERED_CONFIGS"); std::string const consideredVersionsVar = cmStrCat(this->Name, "_CONSIDERED_VERSIONS"); std::string consideredConfigFiles; std::string consideredVersions; const char* sep = ""; for (ConfigFileInfo const& i : this->ConsideredConfigs) { consideredConfigFiles += sep; consideredVersions += sep; consideredConfigFiles += i.filename; consideredVersions += i.version; sep = ";"; } this->Makefile->AddDefinition(consideredConfigsVar, consideredConfigFiles); this->Makefile->AddDefinition(consideredVersionsVar, consideredVersions); return result; } bool cmFindPackageCommand::FindConfig() { // Compute the set of search prefixes. this->ComputePrefixes(); // Look for the project's configuration file. bool found = false; if (this->DebugMode) { this->DebugBuffer = cmStrCat(this->DebugBuffer, "find_package considered the following " "locations for ", this->Name, "'s Config module:\n"); } // Search for frameworks. if (!found && (this->SearchFrameworkFirst || this->SearchFrameworkOnly)) { found = this->FindFrameworkConfig(); } // Search for apps. if (!found && (this->SearchAppBundleFirst || this->SearchAppBundleOnly)) { found = this->FindAppBundleConfig(); } // Search prefixes. if (!found && !(this->SearchFrameworkOnly || this->SearchAppBundleOnly)) { found = this->FindPrefixedConfig(); } // Search for frameworks. if (!found && this->SearchFrameworkLast) { found = this->FindFrameworkConfig(); } // Search for apps. if (!found && this->SearchAppBundleLast) { found = this->FindAppBundleConfig(); } if (this->DebugMode) { if (found) { this->DebugBuffer = cmStrCat( this->DebugBuffer, "The file was found at\n ", this->FileFound, "\n"); } else { this->DebugBuffer = cmStrCat(this->DebugBuffer, "The file was not found.\n"); } } // Store the entry in the cache so it can be set by the user. std::string init; if (found) { init = cmSystemTools::GetFilenamePath(this->FileFound); } else { init = this->Variable + "-NOTFOUND"; } // We force the value since we do not get here if it was already set. this->SetConfigDirCacheVariable(init); return found; } void cmFindPackageCommand::SetConfigDirCacheVariable(const std::string& value) { std::string const help = cmStrCat("The directory containing a CMake configuration file for ", this->Name, '.'); this->Makefile->AddCacheDefinition(this->Variable, value, help, cmStateEnums::PATH, true); if (this->Makefile->GetPolicyStatus(cmPolicies::CMP0126) == cmPolicies::NEW && this->Makefile->IsNormalDefinitionSet(this->Variable)) { this->Makefile->AddDefinition(this->Variable, value); } } bool cmFindPackageCommand::FindPrefixedConfig() { std::vector<std::string> const& prefixes = this->SearchPaths; return std::any_of( prefixes.begin(), prefixes.end(), [this](std::string const& p) -> bool { return this->SearchPrefix(p); }); } bool cmFindPackageCommand::FindFrameworkConfig() { std::vector<std::string> const& prefixes = this->SearchPaths; return std::any_of(prefixes.begin(), prefixes.end(), [this](std::string const& p) -> bool { return this->SearchFrameworkPrefix(p); }); } bool cmFindPackageCommand::FindAppBundleConfig() { std::vector<std::string> const& prefixes = this->SearchPaths; return std::any_of(prefixes.begin(), prefixes.end(), [this](std::string const& p) -> bool { return this->SearchAppBundlePrefix(p); }); } bool cmFindPackageCommand::ReadListFile(const std::string& f, const PolicyScopeRule psr) { const bool noPolicyScope = !this->PolicyScope || psr == NoPolicyScope; using ITScope = cmMakefile::ImportedTargetScope; ITScope scope = this->GlobalScope ? ITScope::Global : ITScope::Local; cmMakefile::SetGlobalTargetImportScope globScope(this->Makefile, scope); if (this->Makefile->ReadDependentFile(f, noPolicyScope)) { return true; } std::string const e = cmStrCat("Error reading CMake code from \"", f, "\"."); this->SetError(e); return false; } void cmFindPackageCommand::AppendToFoundProperty(const bool found) { cmList foundContents; cmValue foundProp = this->Makefile->GetState()->GetGlobalProperty("PACKAGES_FOUND"); if (!foundProp.IsEmpty()) { foundContents.assign(*foundProp); foundContents.remove_items({ this->Name }); } cmList notFoundContents; cmValue notFoundProp = this->Makefile->GetState()->GetGlobalProperty("PACKAGES_NOT_FOUND"); if (!notFoundProp.IsEmpty()) { notFoundContents.assign(*notFoundProp); notFoundContents.remove_items({ this->Name }); } if (found) { foundContents.push_back(this->Name); } else { notFoundContents.push_back(this->Name); } this->Makefile->GetState()->SetGlobalProperty("PACKAGES_FOUND", foundContents.to_string()); this->Makefile->GetState()->SetGlobalProperty("PACKAGES_NOT_FOUND", notFoundContents.to_string()); } void cmFindPackageCommand::AppendSuccessInformation() { { std::string const transitivePropName = cmStrCat("_CMAKE_", this->Name, "_TRANSITIVE_DEPENDENCY"); this->Makefile->GetState()->SetGlobalProperty(transitivePropName, "False"); } std::string const found = cmStrCat(this->Name, "_FOUND"); std::string const upperFound = cmSystemTools::UpperCase(found); bool const upperResult = this->Makefile->IsOn(upperFound); bool const result = this->Makefile->IsOn(found); bool const packageFound = (result || upperResult); this->AppendToFoundProperty(packageFound); // Record whether the find was quiet or not, so this can be used // e.g. in FeatureSummary.cmake std::string const quietInfoPropName = cmStrCat("_CMAKE_", this->Name, "_QUIET"); this->Makefile->GetState()->SetGlobalProperty( quietInfoPropName, this->Quiet ? "TRUE" : "FALSE"); // set a global property to record the required version of this package std::string const versionInfoPropName = cmStrCat("_CMAKE_", this->Name, "_REQUIRED_VERSION"); std::string versionInfo; if (!this->VersionRange.empty()) { versionInfo = this->VersionRange; } else if (!this->Version.empty()) { versionInfo = cmStrCat(this->VersionExact ? "==" : ">=", ' ', this->Version); } this->Makefile->GetState()->SetGlobalProperty(versionInfoPropName, versionInfo); if (this->Required) { std::string const requiredInfoPropName = cmStrCat("_CMAKE_", this->Name, "_TYPE"); this->Makefile->GetState()->SetGlobalProperty(requiredInfoPropName, "REQUIRED"); } } void cmFindPackageCommand::PushFindPackageRootPathStack() { // Allocate a PACKAGE_ROOT_PATH for the current find_package call. this->Makefile->FindPackageRootPathStack.emplace_back(); std::vector<std::string>& rootPaths = this->Makefile->FindPackageRootPathStack.back(); // Add root paths from <PackageName>_ROOT CMake and environment variables, // subject to CMP0074. std::string const rootVar = this->Name + "_ROOT"; cmValue rootDef = this->Makefile->GetDefinition(rootVar); if (rootDef && rootDef.IsEmpty()) { rootDef = nullptr; } cm::optional<std::string> rootEnv = cmSystemTools::GetEnvVar(rootVar); if (rootEnv && rootEnv->empty()) { rootEnv = cm::nullopt; } switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0074)) { case cmPolicies::WARN: this->Makefile->MaybeWarnCMP0074(rootVar, rootDef, rootEnv); CM_FALLTHROUGH; case cmPolicies::OLD: // OLD behavior is to ignore the <PackageName>_ROOT variables. return; case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_ALWAYS: this->Makefile->IssueMessage( MessageType::FATAL_ERROR, cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0074)); return; case cmPolicies::NEW: { // NEW behavior is to honor the <PackageName>_ROOT variables. } break; } // Add root paths from <PACKAGENAME>_ROOT CMake and environment variables, // if they are different than <PackageName>_ROOT, and subject to CMP0144. std::string const rootVAR = cmSystemTools::UpperCase(rootVar); cmValue rootDEF; cm::optional<std::string> rootENV; if (rootVAR != rootVar) { rootDEF = this->Makefile->GetDefinition(rootVAR); if (rootDEF && (rootDEF.IsEmpty() || rootDEF == rootDef)) { rootDEF = nullptr; } rootENV = cmSystemTools::GetEnvVar(rootVAR); if (rootENV && (rootENV->empty() || rootENV == rootEnv)) { rootENV = cm::nullopt; } } switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0144)) { case cmPolicies::WARN: this->Makefile->MaybeWarnCMP0144(rootVAR, rootDEF, rootENV); CM_FALLTHROUGH; case cmPolicies::OLD: // OLD behavior is to ignore the <PACKAGENAME>_ROOT variables. rootDEF = nullptr; rootENV = cm::nullopt; break; case cmPolicies::REQUIRED_IF_USED: case cmPolicies::REQUIRED_ALWAYS: this->Makefile->IssueMessage( MessageType::FATAL_ERROR, cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0144)); return; case cmPolicies::NEW: { // NEW behavior is to honor the <PACKAGENAME>_ROOT variables. } break; } if (rootDef) { cmExpandList(*rootDef, rootPaths); } if (rootDEF) { cmExpandList(*rootDEF, rootPaths); } if (rootEnv) { std::vector<std::string> p = cmSystemTools::SplitEnvPath(*rootEnv); std::move(p.begin(), p.end(), std::back_inserter(rootPaths)); } if (rootENV) { std::vector<std::string> p = cmSystemTools::SplitEnvPath(*rootENV); std::move(p.begin(), p.end(), std::back_inserter(rootPaths)); } } void cmFindPackageCommand::PopFindPackageRootPathStack() { this->Makefile->FindPackageRootPathStack.pop_back(); } void cmFindPackageCommand::ComputePrefixes() { this->FillPrefixesPackageRedirect(); if (!this->NoDefaultPath) { if (!this->NoPackageRootPath) { this->FillPrefixesPackageRoot(); } if (!this->NoCMakePath) { this->FillPrefixesCMakeVariable(); } if (!this->NoCMakeEnvironmentPath) { this->FillPrefixesCMakeEnvironment(); } } this->FillPrefixesUserHints(); if (!this->NoDefaultPath) { if (!this->NoSystemEnvironmentPath) { this->FillPrefixesSystemEnvironment(); } if (!this->NoUserRegistry) { this->FillPrefixesUserRegistry(); } if (!this->NoCMakeSystemPath) { this->FillPrefixesCMakeSystemVariable(); } if (!this->NoSystemRegistry) { this->FillPrefixesSystemRegistry(); } } this->FillPrefixesUserGuess(); this->ComputeFinalPaths(IgnorePaths::No, &this->DebugBuffer); } void cmFindPackageCommand::FillPrefixesPackageRedirect() { cmSearchPath& paths = this->LabeledPaths[PathLabel::PackageRedirect]; const auto redirectDir = this->Makefile->GetDefinition("CMAKE_FIND_PACKAGE_REDIRECTS_DIR"); if (redirectDir && !redirectDir->empty()) { paths.AddPath(*redirectDir); } if (this->DebugMode) { std::string debugBuffer = "The internally managed CMAKE_FIND_PACKAGE_REDIRECTS_DIR.\n"; collectPathsForDebug(debugBuffer, paths); this->DebugBuffer = cmStrCat(this->DebugBuffer, debugBuffer); } } void cmFindPackageCommand::FillPrefixesPackageRoot() { cmSearchPath& paths = this->LabeledPaths[PathLabel::PackageRoot]; // Add the PACKAGE_ROOT_PATH from each enclosing find_package call. for (auto pkgPaths = this->Makefile->FindPackageRootPathStack.rbegin(); pkgPaths != this->Makefile->FindPackageRootPathStack.rend(); ++pkgPaths) { for (std::string const& path : *pkgPaths) { paths.AddPath(path); } } if (this->DebugMode) { std::string debugBuffer = "<PackageName>_ROOT CMake variable " "[CMAKE_FIND_USE_PACKAGE_ROOT_PATH].\n"; collectPathsForDebug(debugBuffer, paths); this->DebugBuffer = cmStrCat(this->DebugBuffer, debugBuffer); } } void cmFindPackageCommand::FillPrefixesCMakeEnvironment() { cmSearchPath& paths = this->LabeledPaths[PathLabel::CMakeEnvironment]; std::string debugBuffer; std::size_t debugOffset = 0; // Check the environment variable with the same name as the cache // entry. paths.AddEnvPath(this->Variable); if (this->DebugMode) { debugBuffer = cmStrCat("Env variable ", this->Variable, " [CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH].\n"); debugOffset = collectPathsForDebug(debugBuffer, paths); } // And now the general CMake environment variables paths.AddEnvPath("CMAKE_PREFIX_PATH"); if (this->DebugMode) { debugBuffer = cmStrCat(debugBuffer, "CMAKE_PREFIX_PATH env variable " "[CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH].\n"); debugOffset = collectPathsForDebug(debugBuffer, paths, debugOffset); } paths.AddEnvPath("CMAKE_FRAMEWORK_PATH"); paths.AddEnvPath("CMAKE_APPBUNDLE_PATH"); if (this->DebugMode) { debugBuffer = cmStrCat(debugBuffer, "CMAKE_FRAMEWORK_PATH and CMAKE_APPBUNDLE_PATH env " "variables [CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH].\n"); collectPathsForDebug(debugBuffer, paths, debugOffset); this->DebugBuffer = cmStrCat(this->DebugBuffer, debugBuffer); } } void cmFindPackageCommand::FillPrefixesCMakeVariable() { cmSearchPath& paths = this->LabeledPaths[PathLabel::CMake]; std::string debugBuffer; std::size_t debugOffset = 0; paths.AddCMakePath("CMAKE_PREFIX_PATH"); if (this->DebugMode) { debugBuffer = "CMAKE_PREFIX_PATH variable [CMAKE_FIND_USE_CMAKE_PATH].\n"; debugOffset = collectPathsForDebug(debugBuffer, paths); } paths.AddCMakePath("CMAKE_FRAMEWORK_PATH"); paths.AddCMakePath("CMAKE_APPBUNDLE_PATH"); if (this->DebugMode) { debugBuffer = cmStrCat(debugBuffer, "CMAKE_FRAMEWORK_PATH and CMAKE_APPBUNDLE_PATH variables " "[CMAKE_FIND_USE_CMAKE_PATH].\n"); collectPathsForDebug(debugBuffer, paths, debugOffset); this->DebugBuffer = cmStrCat(this->DebugBuffer, debugBuffer); } } void cmFindPackageCommand::FillPrefixesSystemEnvironment() { cmSearchPath& paths = this->LabeledPaths[PathLabel::SystemEnvironment]; // Use the system search path to generate prefixes. // Relative paths are interpreted with respect to the current // working directory. std::vector<std::string> tmp; cmSystemTools::GetPath(tmp); for (std::string const& i : tmp) { // If the path is a PREFIX/bin case then add its parent instead. if ((cmHasLiteralSuffix(i, "/bin")) || (cmHasLiteralSuffix(i, "/sbin"))) { paths.AddPath(cmSystemTools::GetFilenamePath(i)); } else { paths.AddPath(i); } } if (this->DebugMode) { std::string debugBuffer = "Standard system environment variables " "[CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH].\n"; collectPathsForDebug(debugBuffer, paths); this->DebugBuffer = cmStrCat(this->DebugBuffer, debugBuffer); } } void cmFindPackageCommand::FillPrefixesUserRegistry() { #if defined(_WIN32) && !defined(__CYGWIN__) this->LoadPackageRegistryWinUser(); #elif defined(__HAIKU__) char dir[B_PATH_NAME_LENGTH]; if (find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, dir, sizeof(dir)) == B_OK) { std::string fname = cmStrCat(dir, "/cmake/packages/", Name); this->LoadPackageRegistryDir(fname, this->LabeledPaths[PathLabel::UserRegistry]); } #else std::string dir; if (cmSystemTools::GetEnv("HOME", dir)) { dir += "/.cmake/packages/"; dir += this->Name; this->LoadPackageRegistryDir(dir, this->LabeledPaths[PathLabel::UserRegistry]); } #endif if (this->DebugMode) { std::string debugBuffer = "CMake User Package Registry [CMAKE_FIND_USE_PACKAGE_REGISTRY].\n"; collectPathsForDebug(debugBuffer, this->LabeledPaths[PathLabel::UserRegistry]); this->DebugBuffer = cmStrCat(this->DebugBuffer, debugBuffer); } } void cmFindPackageCommand::FillPrefixesSystemRegistry() { if (this->NoSystemRegistry || this->NoDefaultPath) { return; } #if defined(_WIN32) && !defined(__CYGWIN__) this->LoadPackageRegistryWinSystem(); #endif if (this->DebugMode) { std::string debugBuffer = "CMake System Package Registry " "[CMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY].\n"; collectPathsForDebug(debugBuffer, this->LabeledPaths[PathLabel::SystemRegistry]); this->DebugBuffer = cmStrCat(this->DebugBuffer, debugBuffer); } } #if defined(_WIN32) && !defined(__CYGWIN__) void cmFindPackageCommand::LoadPackageRegistryWinUser() { // HKEY_CURRENT_USER\\Software shares 32-bit and 64-bit views. this->LoadPackageRegistryWin(true, 0, this->LabeledPaths[PathLabel::UserRegistry]); } void cmFindPackageCommand::LoadPackageRegistryWinSystem() { cmSearchPath& paths = this->LabeledPaths[PathLabel::SystemRegistry]; // HKEY_LOCAL_MACHINE\\SOFTWARE has separate 32-bit and 64-bit views. // Prefer the target platform view first. if (this->Makefile->PlatformIs64Bit()) { this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY, paths); this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY, paths); } else { this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY, paths); this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY, paths); } } void cmFindPackageCommand::LoadPackageRegistryWin(const bool user, const unsigned int view, cmSearchPath& outPaths) { std::wstring key = L"Software\\Kitware\\CMake\\Packages\\"; key += cmsys::Encoding::ToWide(this->Name); std::set<std::wstring> bad; HKEY hKey; if (RegOpenKeyExW(user ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, key.c_str(), 0, KEY_QUERY_VALUE | view, &hKey) == ERROR_SUCCESS) { DWORD valueType = REG_NONE; wchar_t name[16383]; // RegEnumValue docs limit name to 32767 _bytes_ std::vector<wchar_t> data(512); bool done = false; DWORD index = 0; while (!done) { DWORD nameSize = static_cast<DWORD>(sizeof(name)); DWORD dataSize = static_cast<DWORD>(data.size() * sizeof(data[0])); switch (RegEnumValueW(hKey, index, name, &nameSize, 0, &valueType, (BYTE*)&data[0], &dataSize)) { case ERROR_SUCCESS: ++index; if (valueType == REG_SZ) { data[dataSize] = 0; if (!this->CheckPackageRegistryEntry( cmsys::Encoding::ToNarrow(&data[0]), outPaths)) { // The entry is invalid. bad.insert(name); } } break; case ERROR_MORE_DATA: data.resize((dataSize + sizeof(data[0]) - 1) / sizeof(data[0])); break; case ERROR_NO_MORE_ITEMS: default: done = true; break; } } RegCloseKey(hKey); } // Remove bad values if possible. if (user && !bad.empty() && RegOpenKeyExW(HKEY_CURRENT_USER, key.c_str(), 0, KEY_SET_VALUE | view, &hKey) == ERROR_SUCCESS) { for (std::wstring const& v : bad) { RegDeleteValueW(hKey, v.c_str()); } RegCloseKey(hKey); } } #else void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir, cmSearchPath& outPaths) { cmsys::Directory files; if (!files.Load(dir)) { return; } std::string fname; for (unsigned long i = 0; i < files.GetNumberOfFiles(); ++i) { fname = cmStrCat(dir, '/', files.GetFile(i)); if (!cmSystemTools::FileIsDirectory(fname)) { // Hold this file hostage until it behaves. cmFindPackageCommandHoldFile holdFile(fname.c_str()); // Load the file. cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary); std::string fentry; if (fin && cmSystemTools::GetLineFromStream(fin, fentry) && this->CheckPackageRegistryEntry(fentry, outPaths)) { // The file references an existing package, so release it. holdFile.Release(); } } } // TODO: Wipe out the directory if it is empty. } #endif bool cmFindPackageCommand::CheckPackageRegistryEntry(const std::string& fname, cmSearchPath& outPaths) { // Parse the content of one package registry entry. if (cmSystemTools::FileIsFullPath(fname)) { // The first line in the stream is the full path to a file or // directory containing the package. if (cmSystemTools::FileExists(fname)) { // The path exists. Look for the package here. if (!cmSystemTools::FileIsDirectory(fname)) { outPaths.AddPath(cmSystemTools::GetFilenamePath(fname)); } else { outPaths.AddPath(fname); } return true; } // The path does not exist. Assume the stream content is // associated with an old package that no longer exists, and // delete it to keep the package registry clean. return false; } // The first line in the stream is not the full path to a file or // directory. Assume the stream content was created by a future // version of CMake that uses a different format, and leave it. return true; } void cmFindPackageCommand::FillPrefixesCMakeSystemVariable() { cmSearchPath& paths = this->LabeledPaths[PathLabel::CMakeSystem]; const bool install_prefix_in_list = !this->Makefile->IsOn("CMAKE_FIND_NO_INSTALL_PREFIX"); const bool remove_install_prefix = this->NoCMakeInstallPath; const bool add_install_prefix = !this->NoCMakeInstallPath && this->Makefile->IsDefinitionSet("CMAKE_FIND_USE_INSTALL_PREFIX"); // We have 3 possible states for `CMAKE_SYSTEM_PREFIX_PATH` and // `CMAKE_INSTALL_PREFIX`. // Either we need to remove `CMAKE_INSTALL_PREFIX`, add // `CMAKE_INSTALL_PREFIX`, or do nothing. // // When we need to remove `CMAKE_INSTALL_PREFIX` we remove the Nth occurrence // of `CMAKE_INSTALL_PREFIX` from `CMAKE_SYSTEM_PREFIX_PATH`, where `N` is // computed by `CMakeSystemSpecificInformation.cmake` while constructing // `CMAKE_SYSTEM_PREFIX_PATH`. This ensures that if projects / toolchains // have removed `CMAKE_INSTALL_PREFIX` from the list, we don't remove // some other entry by mistake long install_prefix_count = -1; std::string install_path_to_remove; if (cmValue to_skip = this->Makefile->GetDefinition( "_CMAKE_SYSTEM_PREFIX_PATH_INSTALL_PREFIX_COUNT")) { cmStrToLong(*to_skip, &install_prefix_count); } if (cmValue install_value = this->Makefile->GetDefinition( "_CMAKE_SYSTEM_PREFIX_PATH_INSTALL_PREFIX_VALUE")) { install_path_to_remove = *install_value; } if (remove_install_prefix && install_prefix_in_list && install_prefix_count > 0 && !install_path_to_remove.empty()) { cmValue prefix_paths = this->Makefile->GetDefinition("CMAKE_SYSTEM_PREFIX_PATH"); // remove entry from CMAKE_SYSTEM_PREFIX_PATH cmList expanded{ *prefix_paths }; long count = 0; for (const auto& path : expanded) { bool const to_add = !(path == install_path_to_remove && ++count == install_prefix_count); if (to_add) { paths.AddPath(path); } } } else if (add_install_prefix && !install_prefix_in_list) { paths.AddCMakePath("CMAKE_INSTALL_PREFIX"); paths.AddCMakePath("CMAKE_SYSTEM_PREFIX_PATH"); } else { // Otherwise the current setup of `CMAKE_SYSTEM_PREFIX_PATH` is correct paths.AddCMakePath("CMAKE_SYSTEM_PREFIX_PATH"); } paths.AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH"); paths.AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH"); if (this->DebugMode) { std::string debugBuffer = "CMake variables defined in the Platform file " "[CMAKE_FIND_USE_CMAKE_SYSTEM_PATH].\n"; collectPathsForDebug(debugBuffer, paths); this->DebugBuffer = cmStrCat(this->DebugBuffer, debugBuffer); } } void cmFindPackageCommand::FillPrefixesUserGuess() { cmSearchPath& paths = this->LabeledPaths[PathLabel::Guess]; for (std::string const& p : this->UserGuessArgs) { paths.AddUserPath(p); } if (this->DebugMode) { std::string debugBuffer = "Paths specified by the find_package PATHS option.\n"; collectPathsForDebug(debugBuffer, paths); this->DebugBuffer = cmStrCat(this->DebugBuffer, debugBuffer); } } void cmFindPackageCommand::FillPrefixesUserHints() { cmSearchPath& paths = this->LabeledPaths[PathLabel::Hints]; for (std::string const& p : this->UserHintsArgs) { paths.AddUserPath(p); } if (this->DebugMode) { std::string debugBuffer = "Paths specified by the find_package HINTS option.\n"; collectPathsForDebug(debugBuffer, paths); this->DebugBuffer = cmStrCat(this->DebugBuffer, debugBuffer); } } bool cmFindPackageCommand::SearchDirectory(std::string const& dir) { assert(!dir.empty() && dir.back() == '/'); // Check each path suffix on this directory. for (std::string const& s : this->SearchPathSuffixes) { std::string d = dir; if (!s.empty()) { d += s; d += '/'; } if (this->CheckDirectory(d)) { return true; } } return false; } bool cmFindPackageCommand::CheckDirectory(std::string const& dir) { assert(!dir.empty() && dir.back() == '/'); // Look for the file in this directory. std::string const d = dir.substr(0, dir.size() - 1); if (this->FindConfigFile(d, this->FileFound)) { // Remove duplicate slashes. cmSystemTools::ConvertToUnixSlashes(this->FileFound); return true; } return false; } bool cmFindPackageCommand::FindConfigFile(std::string const& dir, std::string& file) { if (this->IgnoredPaths.count(dir)) { return false; } for (std::string const& c : this->Configs) { file = cmStrCat(dir, '/', c); if (this->DebugMode) { this->DebugBuffer = cmStrCat(this->DebugBuffer, " ", file, "\n"); } if (cmSystemTools::FileExists(file, true) && this->CheckVersion(file)) { // Allow resolving symlinks when the config file is found through a link if (this->UseRealPath) { file = cmSystemTools::GetRealPath(file); } return true; } } return false; } bool cmFindPackageCommand::CheckVersion(std::string const& config_file) { bool result = false; // by default, assume the version is not ok. bool haveResult = false; std::string version = "unknown"; // Get the filename without the .cmake extension. std::string::size_type pos = config_file.rfind('.'); std::string version_file_base = config_file.substr(0, pos); // Look for foo-config-version.cmake std::string version_file = cmStrCat(version_file_base, "-version.cmake"); if (!haveResult && cmSystemTools::FileExists(version_file, true)) { result = this->CheckVersionFile(version_file, version); haveResult = true; } // Look for fooConfigVersion.cmake version_file = cmStrCat(version_file_base, "Version.cmake"); if (!haveResult && cmSystemTools::FileExists(version_file, true)) { result = this->CheckVersionFile(version_file, version); haveResult = true; } // If no version was requested a versionless package is acceptable. if (!haveResult && this->Version.empty()) { result = true; } ConfigFileInfo configFileInfo; configFileInfo.filename = config_file; configFileInfo.version = version; this->ConsideredConfigs.push_back(std::move(configFileInfo)); return result; } bool cmFindPackageCommand::CheckVersionFile(std::string const& version_file, std::string& result_version) { // The version file will be loaded in an isolated scope. cmMakefile::ScopePushPop const varScope(this->Makefile); cmMakefile::PolicyPushPop const polScope(this->Makefile); static_cast<void>(varScope); static_cast<void>(polScope); // Clear the output variables. this->Makefile->RemoveDefinition("PACKAGE_VERSION"); this->Makefile->RemoveDefinition("PACKAGE_VERSION_UNSUITABLE"); this->Makefile->RemoveDefinition("PACKAGE_VERSION_COMPATIBLE"); this->Makefile->RemoveDefinition("PACKAGE_VERSION_EXACT"); // Set the input variables. this->Makefile->AddDefinition("PACKAGE_FIND_NAME", this->Name); this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_COMPLETE", this->VersionComplete); auto addDefinition = [this](const std::string& variable, cm::string_view value) { this->Makefile->AddDefinition(variable, value); }; this->SetVersionVariables(addDefinition, "PACKAGE_FIND_VERSION", this->Version, this->VersionCount, this->VersionMajor, this->VersionMinor, this->VersionPatch, this->VersionTweak); if (!this->VersionRange.empty()) { this->SetVersionVariables(addDefinition, "PACKAGE_FIND_VERSION_MIN", this->Version, this->VersionCount, this->VersionMajor, this->VersionMinor, this->VersionPatch, this->VersionTweak); this->SetVersionVariables(addDefinition, "PACKAGE_FIND_VERSION_MAX", this->VersionMax, this->VersionMaxCount, this->VersionMaxMajor, this->VersionMaxMinor, this->VersionMaxPatch, this->VersionMaxTweak); this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_RANGE", this->VersionComplete); this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_RANGE_MIN", this->VersionRangeMin); this->Makefile->AddDefinition("PACKAGE_FIND_VERSION_RANGE_MAX", this->VersionRangeMax); } // Load the version check file. Pass NoPolicyScope because we do // our own policy push/pop independent of CMP0011. bool suitable = false; if (this->ReadListFile(version_file, NoPolicyScope)) { // Check the output variables. bool okay = this->Makefile->IsOn("PACKAGE_VERSION_EXACT"); bool const unsuitable = this->Makefile->IsOn("PACKAGE_VERSION_UNSUITABLE"); if (!okay && !this->VersionExact) { okay = this->Makefile->IsOn("PACKAGE_VERSION_COMPATIBLE"); } // The package is suitable if the version is okay and not // explicitly unsuitable. suitable = !unsuitable && (okay || this->Version.empty()); if (suitable) { // Get the version found. this->VersionFound = this->Makefile->GetSafeDefinition("PACKAGE_VERSION"); // Try to parse the version number and store the results that were // successfully parsed. unsigned int parsed_major; unsigned int parsed_minor; unsigned int parsed_patch; unsigned int parsed_tweak; this->VersionFoundCount = parseVersion(this->VersionFound, parsed_major, parsed_minor, parsed_patch, parsed_tweak); switch (this->VersionFoundCount) { case 4: this->VersionFoundTweak = parsed_tweak; CM_FALLTHROUGH; case 3: this->VersionFoundPatch = parsed_patch; CM_FALLTHROUGH; case 2: this->VersionFoundMinor = parsed_minor; CM_FALLTHROUGH; case 1: this->VersionFoundMajor = parsed_major; CM_FALLTHROUGH; default: break; } } } result_version = this->Makefile->GetSafeDefinition("PACKAGE_VERSION"); if (result_version.empty()) { result_version = "unknown"; } // Succeed if the version is suitable. return suitable; } void cmFindPackageCommand::StoreVersionFound() { // Store the whole version string. std::string const ver = cmStrCat(this->Name, "_VERSION"); auto addDefinition = [this](const std::string& variable, cm::string_view value) { this->Makefile->AddDefinition(variable, value); }; this->SetVersionVariables(addDefinition, ver, this->VersionFound, this->VersionFoundCount, this->VersionFoundMajor, this->VersionFoundMinor, this->VersionFoundPatch, this->VersionFoundTweak); if (this->VersionFound.empty()) { this->Makefile->RemoveDefinition(ver); } } bool cmFindPackageCommand::SearchPrefix(std::string const& prefix_in) { assert(!prefix_in.empty() && prefix_in.back() == '/'); // Skip this if the prefix does not exist. if (!cmSystemTools::FileIsDirectory(prefix_in)) { return false; } // Skip this if it's in ignored paths. std::string prefixWithoutSlash = prefix_in; if (prefixWithoutSlash != "/" && prefixWithoutSlash.back() == '/') { prefixWithoutSlash.erase(prefixWithoutSlash.length() - 1); } if (this->IgnoredPaths.count(prefixWithoutSlash) || this->IgnoredPrefixPaths.count(prefixWithoutSlash)) { return false; } // PREFIX/ (useful on windows or in build trees) if (this->SearchDirectory(prefix_in)) { return true; } // Strip the trailing slash because the path generator is about to // add one. std::string const prefix = prefix_in.substr(0, prefix_in.size() - 1); auto searchFn = [this](const std::string& fullPath) -> bool { return this->SearchDirectory(fullPath); }; auto iCMakeGen = cmCaseInsensitiveDirectoryListGenerator{ "cmake"_s }; auto firstPkgDirGen = cmProjectDirectoryListGenerator{ this->Names, this->SortOrder, this->SortDirection }; // PREFIX/(cmake|CMake)/ (useful on windows or in build trees) if (TryGeneratedPaths(searchFn, prefix, iCMakeGen)) { return true; } // PREFIX/(Foo|foo|FOO).*/ if (TryGeneratedPaths(searchFn, prefix, firstPkgDirGen)) { return true; } // PREFIX/(Foo|foo|FOO).*/(cmake|CMake)/ if (TryGeneratedPaths(searchFn, prefix, firstPkgDirGen, iCMakeGen)) { return true; } auto secondPkgDirGen = cmProjectDirectoryListGenerator{ this->Names, this->SortOrder, this->SortDirection }; // PREFIX/(Foo|foo|FOO).*/(cmake|CMake)/(Foo|foo|FOO).*/ if (TryGeneratedPaths(searchFn, prefix, firstPkgDirGen, iCMakeGen, secondPkgDirGen)) { return true; } // Construct list of common install locations (lib and share). std::vector<cm::string_view> common; std::string libArch; if (!this->LibraryArchitecture.empty()) { libArch = "lib/" + this->LibraryArchitecture; common.emplace_back(libArch); } if (this->UseLib32Paths) { common.emplace_back("lib32"_s); } if (this->UseLib64Paths) { common.emplace_back("lib64"_s); } if (this->UseLibx32Paths) { common.emplace_back("libx32"_s); } common.emplace_back("lib"_s); common.emplace_back("share"_s); auto cmnGen = cmEnumPathSegmentsGenerator{ common }; auto cmakeGen = cmAppendPathSegmentGenerator{ "cmake"_s }; // PREFIX/(lib/ARCH|lib*|share)/cmake/(Foo|foo|FOO).*/ if (TryGeneratedPaths(searchFn, prefix, cmnGen, cmakeGen, firstPkgDirGen)) { return true; } // PREFIX/(lib/ARCH|lib*|share)/(Foo|foo|FOO).*/ if (TryGeneratedPaths(searchFn, prefix, cmnGen, firstPkgDirGen)) { return true; } // PREFIX/(lib/ARCH|lib*|share)/(Foo|foo|FOO).*/(cmake|CMake)/ if (TryGeneratedPaths(searchFn, prefix, cmnGen, firstPkgDirGen, iCMakeGen)) { return true; } // PREFIX/(Foo|foo|FOO).*/(lib/ARCH|lib*|share)/cmake/(Foo|foo|FOO).*/ if (TryGeneratedPaths(searchFn, prefix, firstPkgDirGen, cmnGen, cmakeGen, secondPkgDirGen)) { return true; } // PREFIX/(Foo|foo|FOO).*/(lib/ARCH|lib*|share)/(Foo|foo|FOO).*/ if (TryGeneratedPaths(searchFn, prefix, firstPkgDirGen, cmnGen, secondPkgDirGen)) { return true; } // PREFIX/(Foo|foo|FOO).*/(lib/ARCH|lib*|share)/(Foo|foo|FOO).*/(cmake|CMake)/ return TryGeneratedPaths(searchFn, prefix, firstPkgDirGen, cmnGen, secondPkgDirGen, iCMakeGen); } bool cmFindPackageCommand::SearchFrameworkPrefix(std::string const& prefix_in) { assert(!prefix_in.empty() && prefix_in.back() == '/'); // Strip the trailing slash because the path generator is about to // add one. std::string const prefix = prefix_in.substr(0, prefix_in.size() - 1); auto searchFn = [this](const std::string& fullPath) -> bool { return this->SearchDirectory(fullPath); }; auto iCMakeGen = cmCaseInsensitiveDirectoryListGenerator{ "cmake"_s }; auto fwGen = cmMacProjectDirectoryListGenerator{ this->Names, ".framework"_s }; auto rGen = cmAppendPathSegmentGenerator{ "Resources"_s }; auto vGen = cmAppendPathSegmentGenerator{ "Versions"_s }; auto grGen = cmFileListGeneratorGlob{ "/*/Resources"_s }; // <prefix>/Foo.framework/Resources/ if (TryGeneratedPaths(searchFn, prefix, fwGen, rGen)) { return true; } // <prefix>/Foo.framework/Resources/CMake/ if (TryGeneratedPaths(searchFn, prefix, fwGen, rGen, iCMakeGen)) { return true; } // <prefix>/Foo.framework/Versions/*/Resources/ if (TryGeneratedPaths(searchFn, prefix, fwGen, vGen, grGen)) { return true; } // <prefix>/Foo.framework/Versions/*/Resources/CMake/ return TryGeneratedPaths(searchFn, prefix, fwGen, vGen, grGen, iCMakeGen); } bool cmFindPackageCommand::SearchAppBundlePrefix(std::string const& prefix_in) { assert(!prefix_in.empty() && prefix_in.back() == '/'); // Strip the trailing slash because the path generator is about to // add one. std::string const prefix = prefix_in.substr(0, prefix_in.size() - 1); auto searchFn = [this](const std::string& fullPath) -> bool { return this->SearchDirectory(fullPath); }; auto appGen = cmMacProjectDirectoryListGenerator{ this->Names, ".app"_s }; auto crGen = cmAppendPathSegmentGenerator{ "Contents/Resources"_s }; // <prefix>/Foo.app/Contents/Resources if (TryGeneratedPaths(searchFn, prefix, appGen, crGen)) { return true; } // <prefix>/Foo.app/Contents/Resources/CMake return TryGeneratedPaths( searchFn, prefix, appGen, crGen, cmCaseInsensitiveDirectoryListGenerator{ "cmake"_s }); } // TODO: Debug cmsys::Glob double slash problem. bool cmFindPackage(std::vector<std::string> const& args, cmExecutionStatus& status) { return cmFindPackageCommand(status).InitialPass(args); }