find_*(): Add CMAKE_IGNORE_PREFIX_PATH variable

Fixes: #20878

6 files changed, 61 insertions, 12 deletions

diff --git a/Source/cmFindCommon.cxx b/Source/cmFindCommon.cxx
index c58db1e..1bb98ea 100644
--- a/Source/cmFindCommon.cxx
+++ b/Source/cmFindCommon.cxx
@@ -262,11 +262,13 @@ void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
           (stagePrefix && isSameDirectoryOrSubDirectory(up, *stagePrefix))) {
         rootedDir = up;
       } else if (!up.empty() && up[0] != '~') {
-        // Start with the new root.
-        rootedDir = cmStrCat(r, '/');
-
-        // Append the original path with its old root removed.
-        rootedDir += cmSystemTools::SplitPathRootComponent(up);
+        auto const* split = cmSystemTools::SplitPathRootComponent(up);
+        if (split && *split) {
+          // Start with the new root.
+          rootedDir = cmStrCat(r, '/', split);
+        } else {
+          rootedDir = r;
+        }
       }
 
       // Store the new path.
@@ -306,6 +308,31 @@ void cmFindCommon::GetIgnoredPaths(std::set<std::string>& ignore)
   ignore.insert(ignoreVec.begin(), ignoreVec.end());
 }
 
+void cmFindCommon::GetIgnoredPrefixPaths(std::vector<std::string>& ignore)
+{
+  static constexpr const char* paths[] = {
+    "CMAKE_SYSTEM_IGNORE_PREFIX_PATH",
+    "CMAKE_IGNORE_PREFIX_PATH",
+  };
+
+  // Construct the list of path roots with no trailing slashes.
+  for (const char* pathName : paths) {
+    // Get the list of paths to ignore from the variable.
+    this->Makefile->GetDefExpandList(pathName, ignore);
+  }
+
+  for (std::string& i : ignore) {
+    cmSystemTools::ConvertToUnixSlashes(i);
+  }
+}
+
+void cmFindCommon::GetIgnoredPrefixPaths(std::set<std::string>& ignore)
+{
+  std::vector<std::string> ignoreVec;
+  this->GetIgnoredPrefixPaths(ignoreVec);
+  ignore.insert(ignoreVec.begin(), ignoreVec.end());
+}
+
 bool cmFindCommon::CheckCommonArgument(std::string const& arg)
 {
   if (arg == "NO_DEFAULT_PATH") {
@@ -369,16 +396,19 @@ static void AddTrailingSlash(std::string& s)
 void cmFindCommon::ComputeFinalPaths(IgnorePaths ignorePaths)
 {
   // Filter out ignored paths from the prefix list
-  std::set<std::string> ignored;
+  std::set<std::string> ignoredPaths;
+  std::set<std::string> ignoredPrefixes;
   if (ignorePaths == IgnorePaths::Yes) {
-    this->GetIgnoredPaths(ignored);
+    this->GetIgnoredPaths(ignoredPaths);
+    this->GetIgnoredPrefixPaths(ignoredPrefixes);
   }
 
   // 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);
+    this->LabeledPaths[l].ExtractWithout(ignoredPaths, ignoredPrefixes,
+                                         this->SearchPaths);
   }
 
   // Expand list of paths inside all search roots.
diff --git a/Source/cmFindCommon.h b/Source/cmFindCommon.h
index 6649c35..5d9b3e1 100644
--- a/Source/cmFindCommon.h
+++ b/Source/cmFindCommon.h
@@ -86,6 +86,10 @@ protected:
   void GetIgnoredPaths(std::vector<std::string>& ignore);
   void GetIgnoredPaths(std::set<std::string>& ignore);
 
+  /** Get ignored paths from CMAKE_[SYSTEM_]IGNORE_PREFIX_PATH variables.  */
+  void GetIgnoredPrefixPaths(std::vector<std::string>& ignore);
+  void GetIgnoredPrefixPaths(std::set<std::string>& ignore);
+
   /** Compute final search path list (reroot + trailing slash).  */
   enum class IgnorePaths
   {
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index 85badf6..fac0e08 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -665,6 +665,16 @@ bool cmFindPackageCommand::FindPackageUsingConfigMode()
   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);
 }
@@ -2291,7 +2301,8 @@ bool cmFindPackageCommand::SearchPrefix(std::string const& prefix_in)
   if (prefixWithoutSlash != "/" && prefixWithoutSlash.back() == '/') {
     prefixWithoutSlash.erase(prefixWithoutSlash.length() - 1);
   }
-  if (this->IgnoredPaths.count(prefixWithoutSlash)) {
+  if (this->IgnoredPaths.count(prefixWithoutSlash) ||
+      this->IgnoredPrefixPaths.count(prefixWithoutSlash)) {
     return false;
   }
 
diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h
index 9d6eddf..439d934 100644
--- a/Source/cmFindPackageCommand.h
+++ b/Source/cmFindPackageCommand.h
@@ -205,6 +205,7 @@ private:
   std::vector<std::string> Names;
   std::vector<std::string> Configs;
   std::set<std::string> IgnoredPaths;
+  std::set<std::string> IgnoredPrefixPaths;
   std::string DebugBuffer;
 
   /*! the selected sortOrder (None by default)*/
diff --git a/Source/cmSearchPath.cxx b/Source/cmSearchPath.cxx
index ff54a8a..bfee64c 100644
--- a/Source/cmSearchPath.cxx
+++ b/Source/cmSearchPath.cxx
@@ -19,7 +19,8 @@ cmSearchPath::cmSearchPath(cmFindCommon* findCmd)
 
 cmSearchPath::~cmSearchPath() = default;
 
-void cmSearchPath::ExtractWithout(const std::set<std::string>& ignore,
+void cmSearchPath::ExtractWithout(const std::set<std::string>& ignorePaths,
+                                  const std::set<std::string>& ignorePrefixes,
                                   std::vector<std::string>& outPaths,
                                   bool clear) const
 {
@@ -27,7 +28,8 @@ void cmSearchPath::ExtractWithout(const std::set<std::string>& ignore,
     outPaths.clear();
   }
   for (auto const& path : this->Paths) {
-    if (ignore.count(path.Path) == 0) {
+    if (ignorePaths.count(path.Path) == 0 &&
+        ignorePrefixes.count(path.Prefix) == 0) {
       outPaths.push_back(path.Path);
     }
   }
diff --git a/Source/cmSearchPath.h b/Source/cmSearchPath.h
index 08f9cfa..4c0cabb 100644
--- a/Source/cmSearchPath.h
+++ b/Source/cmSearchPath.h
@@ -43,7 +43,8 @@ public:
   const std::vector<PathWithPrefix>& GetPaths() const { return this->Paths; }
   std::size_t size() const { return this->Paths.size(); }
 
-  void ExtractWithout(const std::set<std::string>& ignore,
+  void ExtractWithout(const std::set<std::string>& ignorePaths,
+                      const std::set<std::string>& ignorePrefixes,
                       std::vector<std::string>& outPaths,
                       bool clear = false) const;