echo/CMake
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ENH: Refactor cmFindCommon, cmFindBase, and cmFindPackageCommand

Browse Source 
- Add each part of the search order in a separate method.
  - Collect added paths in an ivar in cmFindCommon.
  - Move user path storage up to cmFindCommon and share
    between cmFindBase and cmFindPackageCommand.
  - Expand user path registry values up in cmFindCommon
    - Enables 32-/64-bit registry view for find_package
    - Disables registry expansion for paths not specified
      with the PATHS argument, which is not expected.
This commit is contained in:
Brad King 2008-06-05 18:20:16 -04:00
parent 3ecfb5f7e8
commit 789c167b6f
6 changed files with 260 additions and 314 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

260
Source/cmFindBase.cxx
View File

@ -161,7 +161,6 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
// Find the current bundle/framework search policy. // Find the current bundle/framework search policy.
this->SelectDefaultMacMode(); this->SelectDefaultMacMode();
std::vector<std::string> userPaths;
std::string doc; std::string doc;
bool doingNames = true; // assume it starts with a name bool doingNames = true; // assume it starts with a name
bool doingPaths = false; bool doingPaths = false;
@ -214,7 +213,7 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
} }
else if(doingPaths) else if(doingPaths)
{ {
userPaths.push_back(args[j]); this->AddUserPath(args[j]);
} }
else if(doingPathSuf) else if(doingPathSuf)
{ {
@ -266,17 +265,17 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
this->Names.push_back(args[1]); this->Names.push_back(args[1]);
for(unsigned int j = 2; j < args.size(); ++j) for(unsigned int j = 2; j < args.size(); ++j)
{ {
userPaths.push_back(args[j]); this->AddUserPath(args[j]);
} }
} }
this->ExpandPaths(userPaths); this->ExpandPaths();
// Handle search root stuff. // Handle search root stuff.
this->RerootPaths(this->SearchPaths); this->RerootPaths(this->SearchPaths);
return true; return true;
} }
void cmFindBase::ExpandPaths(std::vector<std::string> userPaths) void cmFindBase::ExpandPaths()
{ {
// if NO Default paths was not specified add the // if NO Default paths was not specified add the
// standard search paths. // standard search paths.
@ -284,74 +283,36 @@ void cmFindBase::ExpandPaths(std::vector<std::string> userPaths)
{ {
if(this->SearchFrameworkFirst || this->SearchFrameworkOnly) if(this->SearchFrameworkFirst || this->SearchFrameworkOnly)
{ {
this->AddFrameWorkPaths(); this->AddFrameworkPath();
} }
if(this->SearchAppBundleFirst || this->SearchAppBundleOnly) if(this->SearchAppBundleFirst || this->SearchAppBundleOnly)
{ {
this->AddAppBundlePaths(); this->AddAppBundlePath();
}
if(!this->NoCMakeEnvironmentPath &&
!(this->SearchFrameworkOnly || this->SearchAppBundleOnly))
{
// Add CMAKE_*_PATH environment variables
this->AddEnvironmentVariables();
}
if(!this->NoCMakePath &&
!(this->SearchFrameworkOnly || this->SearchAppBundleOnly))
{
// Add CMake varibles of the same name as the previous environment
// varibles CMAKE_*_PATH to be used most of the time with -D
// command line options
this->AddCMakeVariables();
}
if(!this->NoSystemEnvironmentPath &&
!(this->SearchFrameworkOnly || this->SearchAppBundleOnly))
{
// add System environment PATH and (LIB or INCLUDE)
this->AddSystemEnvironmentVariables();
}
if(!this->NoCMakeSystemPath &&
!(this->SearchFrameworkOnly || this->SearchAppBundleOnly))
{
// Add CMAKE_SYSTEM_*_PATH variables which are defined in platform files
this->AddCMakeSystemVariables();
} }
this->AddCMakeEnvironmentPath();
this->AddCMakeVariablePath();
this->AddSystemEnvironmentPath();
this->AddCMakeSystemVariablePath();
if(this->SearchAppBundleLast) if(this->SearchAppBundleLast)
{ {
this->AddAppBundlePaths(); this->AddAppBundlePath();
} }
if(this->SearchFrameworkLast) if(this->SearchFrameworkLast)
{ {
this->AddFrameWorkPaths(); this->AddFrameworkPath();
} }
} }
std::vector<std::string> paths;
// add the paths specified in the FIND_* call // Add paths specified by the caller.
for(unsigned int i =0; i < userPaths.size(); ++i) this->AddPathsInternal(this->UserPaths, CMakePath);
{
paths.push_back(userPaths[i]); // Add suffixes and clean up paths.
} this->AddPathSuffixes();
this->AddPaths(paths);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindBase::AddEnvironmentVariables() void cmFindBase::AddPrefixPaths(std::vector<std::string> const& in_paths,
{ PathType pathType)
std::vector<std::string> paths;
std::vector<std::string> prefixPaths;
cmSystemTools::GetPath(prefixPaths, "CMAKE_PREFIX_PATH");
this->AddFindPrefix(paths, prefixPaths);
std::string var = "CMAKE_";
var += this->CMakePathName;
var += "_PATH";
cmSystemTools::GetPath(paths, var.c_str());
this->AddPaths(paths);
}
void cmFindBase::AddFindPrefix(std::vector<std::string>& dest,
const std::vector<std::string>& src)
{ {
// default for programs // default for programs
std::string subdir = "bin"; std::string subdir = "bin";
@ -369,9 +330,8 @@ void cmFindBase::AddFindPrefix(std::vector<std::string>& dest,
subdir = ""; // ? what to do for frameworks ? subdir = ""; // ? what to do for frameworks ?
} }
for (std::vector<std::string>::const_iterator it = src.begin(); for(std::vector<std::string>::const_iterator it = in_paths.begin();
it != src.end(); it != in_paths.end(); ++it)
++it)
{ {
std::string dir = it->c_str(); std::string dir = it->c_str();
if(!subdir.empty() && !dir.empty() && dir[dir.size()-1] != '/') if(!subdir.empty() && !dir.empty() && dir[dir.size()-1] != '/')
@ -381,131 +341,147 @@ void cmFindBase::AddFindPrefix(std::vector<std::string>& dest,
std::string add = dir + subdir; std::string add = dir + subdir;
if(add != "/") if(add != "/")
{ {
dest.push_back(add); this->AddPathInternal(add, pathType);
} }
if (subdir == "bin") if (subdir == "bin")
{ {
dest.push_back(dir + "sbin"); this->AddPathInternal(dir+"sbin", pathType);
} }
if(!subdir.empty() && *it != "/") if(!subdir.empty() && *it != "/")
{ {
dest.push_back(*it); this->AddPathInternal(*it, pathType);
} }
} }
} }
void cmFindBase::AddFrameWorkPaths() //----------------------------------------------------------------------------
void cmFindBase::AddCMakePrefixPath(const char* variable)
{ {
std::vector<std::string> paths; // Get a path from a CMake variable.
this->GetFrameworkPaths(paths); if(const char* varPath = this->Makefile->GetDefinition(variable))
this->AddPaths(paths); {
std::vector<std::string> tmp;
cmSystemTools::ExpandListArgument(varPath, tmp);
this->AddPrefixPaths(tmp, CMakePath);
}
} }
void cmFindBase::AddPaths(std::vector<std::string> & paths) //----------------------------------------------------------------------------
void cmFindBase::AddEnvPrefixPath(const char* variable)
{ {
// add suffixes and clean up paths // Get a path from the environment.
this->ExpandRegistryAndCleanPath(paths); std::vector<std::string> tmp;
// add the paths to the search paths cmSystemTools::GetPath(tmp, variable);
this->SearchPaths.insert(this->SearchPaths.end(), this->AddPrefixPaths(tmp, EnvPath);
paths.begin(),
paths.end());
} }
void cmFindBase::AddAppBundlePaths() //----------------------------------------------------------------------------
void cmFindBase::AddMacPath(const char* var, const char* sysvar)
{ {
std::vector<std::string> paths; if(this->NoDefaultPath)
this->GetAppBundlePaths(paths); {
this->AddPaths(paths); return;
} }
void cmFindBase::AddCMakeVariables() // first environment variables
if(!this->NoCMakeEnvironmentPath)
{ {
this->AddEnvPath("CMAKE_FRAMEWORK_PATH");
}
// add cmake variables
if(!this->NoCMakePath)
{
this->AddCMakePath("CMAKE_FRAMEWORK_PATH");
}
// add cmake system variables
if(!this->NoCMakeSystemPath)
{
this->AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
}
}
//----------------------------------------------------------------------------
void cmFindBase::AddFrameworkPath()
{
this->AddMacPath("CMAKE_FRAMEWORK_PATH", "CMAKE_SYSTEM_FRAMEWORK_PATH");
}
//----------------------------------------------------------------------------
void cmFindBase::AddAppBundlePath()
{
this->AddMacPath("CMAKE_APPBUNDLE_PATH", "CMAKE_SYSTEM_APPBUNDLE_PATH");
}
//----------------------------------------------------------------------------
void cmFindBase::AddCMakeEnvironmentPath()
{
if(!this->NoCMakeEnvironmentPath &&
!(this->SearchFrameworkOnly || this->SearchAppBundleOnly))
{
// Add CMAKE_*_PATH environment variables
std::string var = "CMAKE_"; std::string var = "CMAKE_";
var += this->CMakePathName; var += this->CMakePathName;
var += "_PATH"; var += "_PATH";
std::vector<std::string> paths; this->AddEnvPrefixPath("CMAKE_PREFIX_PATH");
this->AddEnvPath(var.c_str());
}
}
if(const char* prefixPath = //----------------------------------------------------------------------------
this->Makefile->GetDefinition("CMAKE_PREFIX_PATH")) void cmFindBase::AddCMakeVariablePath()
{ {
std::vector<std::string> prefixPaths; if(!this->NoCMakePath &&
cmSystemTools::ExpandListArgument(prefixPath, prefixPaths); !(this->SearchFrameworkOnly || this->SearchAppBundleOnly))
this->AddFindPrefix(paths, prefixPaths);
}
if(const char* path = this->Makefile->GetDefinition(var.c_str()))
{ {
cmSystemTools::ExpandListArgument(path, paths); // Add CMake varibles of the same name as the previous environment
// varibles CMAKE_*_PATH to be used most of the time with -D
// command line options
std::string var = "CMAKE_";
var += this->CMakePathName;
var += "_PATH";
this->AddCMakePrefixPath("CMAKE_PREFIX_PATH");
this->AddCMakePath(var.c_str());
} }
this->AddPaths(paths);
} }
void cmFindBase::AddSystemEnvironmentVariables() //----------------------------------------------------------------------------
void cmFindBase::AddSystemEnvironmentPath()
{
if(!this->NoSystemEnvironmentPath &&
!(this->SearchFrameworkOnly || this->SearchAppBundleOnly))
{ {
// Add LIB or INCLUDE // Add LIB or INCLUDE
std::vector<std::string> paths; if(!this->EnvironmentPath.empty())
if(this->EnvironmentPath.size())
{ {
cmSystemTools::GetPath(paths, this->EnvironmentPath.c_str()); this->AddEnvPath(this->EnvironmentPath.c_str());
} }
// Add PATH // Add PATH
cmSystemTools::GetPath(paths); this->AddEnvPath(0);
this->AddPaths(paths); }
} }
void cmFindBase::AddCMakeSystemVariables() //----------------------------------------------------------------------------
void cmFindBase::AddCMakeSystemVariablePath()
{
if(!this->NoCMakeSystemPath &&
!(this->SearchFrameworkOnly || this->SearchAppBundleOnly))
{ {
std::string var = "CMAKE_SYSTEM_"; std::string var = "CMAKE_SYSTEM_";
var += this->CMakePathName; var += this->CMakePathName;
var += "_PATH"; var += "_PATH";
std::vector<std::string> paths; this->AddCMakePrefixPath("CMAKE_SYSTEM_PREFIX_PATH");
if(const char* prefixPath = this->AddCMakePath(var.c_str());
this->Makefile->GetDefinition("CMAKE_SYSTEM_PREFIX_PATH"))
{
std::vector<std::string> prefixPaths;
cmSystemTools::ExpandListArgument(prefixPath, prefixPaths);
this->AddFindPrefix(paths, prefixPaths);
} }
if(const char* path = this->Makefile->GetDefinition(var.c_str()))
{
cmSystemTools::ExpandListArgument(path, paths);
}
this->AddPaths(paths);
} }
void cmFindBase::ExpandRegistryAndCleanPath(std::vector<std::string>& paths) //----------------------------------------------------------------------------
void cmFindBase::AddPathSuffixes()
{ {
// We should view the registry as the target application would view std::vector<std::string>& paths = this->SearchPaths;
// it. std::vector<std::string> finalPath = paths;
cmSystemTools::KeyWOW64 view = cmSystemTools::KeyWOW64_32;
cmSystemTools::KeyWOW64 other_view = cmSystemTools::KeyWOW64_64;
if(const char* psize =
this->Makefile->GetDefinition("CMAKE_SIZEOF_VOID_P"))
{
if(atoi(psize) == 8)
{
view = cmSystemTools::KeyWOW64_64;
other_view = cmSystemTools::KeyWOW64_32;
}
}
std::vector<std::string> finalPath;
std::vector<std::string>::iterator i; std::vector<std::string>::iterator i;
// glob and expand registry stuff from paths and put
// into finalPath
for(i = paths.begin();
i != paths.end(); ++i)
{
std::string expanded = *i;
cmSystemTools::ExpandRegistryValues(expanded, view);
cmSystemTools::GlobDirs(expanded.c_str(), finalPath);
if(expanded != *i && this->CMakePathName == "PROGRAM")
{
// Executables can be either 32-bit or 64-bit.
expanded = *i;
cmSystemTools::ExpandRegistryValues(expanded, other_view);
cmSystemTools::GlobDirs(expanded.c_str(), finalPath);
}
}
// clear the path // clear the path
paths.clear(); paths.clear();
// convert all paths to unix slashes and add search path suffixes // convert all paths to unix slashes and add search path suffixes

30
Source/cmFindBase.h
View File

@ -41,19 +41,9 @@ public:
protected: protected:
void PrintFindStuff(); void PrintFindStuff();
void ExpandPaths(std::vector<std::string> userPaths); void ExpandPaths();
void AddPathSuffixes();
// add to the SearchPaths
void AddPaths(std::vector<std::string>& paths);
void AddFrameWorkPaths();
void AddAppBundlePaths();
void AddEnvironmentVariables();
void AddFindPrefix(std::vector<std::string>& dest,
const std::vector<std::string>& src);
void AddCMakeVariables();
void AddSystemEnvironmentVariables();
void AddCMakeSystemVariables();
void ExpandRegistryAndCleanPath(std::vector<std::string>& paths);
// see if the VariableName is already set in the cache, // see if the VariableName is already set in the cache,
// also copy the documentation from the cache to VariableDocumentation // also copy the documentation from the cache to VariableDocumentation
// if it has documentation in the cache // if it has documentation in the cache
@ -64,13 +54,27 @@ protected:
cmStdString VariableDocumentation; cmStdString VariableDocumentation;
cmStdString VariableName; cmStdString VariableName;
std::vector<std::string> Names; std::vector<std::string> Names;
std::vector<std::string> SearchPaths;
// CMAKE_*_PATH CMAKE_SYSTEM_*_PATH FRAMEWORK|LIBRARY|INCLUDE|PROGRAM // CMAKE_*_PATH CMAKE_SYSTEM_*_PATH FRAMEWORK|LIBRARY|INCLUDE|PROGRAM
cmStdString EnvironmentPath; // LIB,INCLUDE cmStdString EnvironmentPath; // LIB,INCLUDE
bool AlreadyInCache; bool AlreadyInCache;
bool AlreadyInCacheWithoutMetaInfo; bool AlreadyInCacheWithoutMetaInfo;
private:
// Add pieces of the search.
void AddFrameworkPath();
void AddAppBundlePath();
void AddCMakeEnvironmentPath();
void AddCMakeVariablePath();
void AddSystemEnvironmentPath();
void AddCMakeSystemVariablePath();
// Helpers.
void AddMacPath(const char* var, const char* sysvar);
void AddCMakePrefixPath(const char* variable);
void AddEnvPrefixPath(const char* variable);
void AddPrefixPaths(std::vector<std::string> const& in_paths,
PathType pathType);
}; };

126
Source/cmFindCommon.cxx
View File

@ -322,93 +322,39 @@ void cmFindCommon::AddPathSuffix(std::string const& arg)
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindCommon::GetAppBundlePaths(std::vector<std::string>& paths) void cmFindCommon::AddUserPath(std::string const& p)
{ {
if(this->NoDefaultPath) // We should view the registry as the target application would view
// it.
cmSystemTools::KeyWOW64 view = cmSystemTools::KeyWOW64_32;
cmSystemTools::KeyWOW64 other_view = cmSystemTools::KeyWOW64_64;
if(const char* psize =
this->Makefile->GetDefinition("CMAKE_SIZEOF_VOID_P"))
{ {
return; if(atoi(psize) == 8)
}
std::vector<std::string> tmp;
// first environment variables
if(!this->NoCMakeEnvironmentPath)
{ {
cmSystemTools::GetPath(tmp, "CMAKE_APPBUNDLE_PATH"); view = cmSystemTools::KeyWOW64_64;
this->AddPathsInternal(paths, tmp, EnvPath); other_view = cmSystemTools::KeyWOW64_32;
tmp.clear();
}
// add cmake variables
if(!this->NoCMakePath)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_APPBUNDLE_PATH"))
{
cmSystemTools::ExpandListArgument(path, tmp);
this->AddPathsInternal(paths, tmp, CMakePath);
tmp.clear();
} }
} }
// add cmake system variables // Expand using the view of the target application.
if(!this->NoCMakeSystemPath) std::string expanded = p;
cmSystemTools::ExpandRegistryValues(expanded, view);
cmSystemTools::GlobDirs(expanded.c_str(), this->UserPaths);
// Executables can be either 32-bit or 64-bit, so expand using the
// alternative view.
if(expanded != p && this->CMakePathName == "PROGRAM")
{ {
if(const char* path = expanded = p;
this->Makefile->GetDefinition("CMAKE_SYSTEM_APPBUNDLE_PATH")) cmSystemTools::ExpandRegistryValues(expanded, other_view);
{ cmSystemTools::GlobDirs(expanded.c_str(), this->UserPaths);
cmSystemTools::ExpandListArgument(path, tmp);
this->AddPathsInternal(paths, tmp, CMakePath);
tmp.clear();
}
} }
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindCommon::GetFrameworkPaths(std::vector<std::string>& paths) void cmFindCommon::AddCMakePath(const char* variable)
{
if(this->NoDefaultPath)
{
return;
}
std::vector<std::string> tmp;
// first environment variables
if(!this->NoCMakeEnvironmentPath)
{
cmSystemTools::GetPath(tmp, "CMAKE_FRAMEWORK_PATH");
this->AddPathsInternal(paths, tmp, EnvPath);
tmp.clear();
}
// add cmake variables
if(!this->NoCMakePath)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_FRAMEWORK_PATH"))
{
cmSystemTools::ExpandListArgument(path, tmp);
this->AddPathsInternal(paths, tmp, CMakePath);
tmp.clear();
}
}
// add cmake system variables
if(!this->NoCMakeSystemPath)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_SYSTEM_FRAMEWORK_PATH"))
{
cmSystemTools::ExpandListArgument(path, tmp);
this->AddPathsInternal(paths, tmp, CMakePath);
tmp.clear();
}
}
}
//----------------------------------------------------------------------------
void cmFindCommon::AddCMakePath(std::vector<std::string>& out_paths,
const char* variable,
std::set<cmStdString>* emmitted)
{ {
// Get a path from a CMake variable. // Get a path from a CMake variable.
if(const char* varPath = this->Makefile->GetDefinition(variable)) if(const char* varPath = this->Makefile->GetDefinition(variable))
@ -418,14 +364,12 @@ void cmFindCommon::AddCMakePath(std::vector<std::string>& out_paths,
// Relative paths are interpreted with respect to the current // Relative paths are interpreted with respect to the current
// source directory. // source directory.
this->AddPathsInternal(out_paths, tmp, CMakePath, emmitted); this->AddPathsInternal(tmp, CMakePath);
} }
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindCommon::AddEnvPath(std::vector<std::string>& out_paths, void cmFindCommon::AddEnvPath(const char* variable)
const char* variable,
std::set<cmStdString>* emmitted)
{ {
// Get a path from the environment. // Get a path from the environment.
std::vector<std::string> tmp; std::vector<std::string> tmp;
@ -433,27 +377,23 @@ void cmFindCommon::AddEnvPath(std::vector<std::string>& out_paths,
// Relative paths are interpreted with respect to the current // Relative paths are interpreted with respect to the current
// working directory. // working directory.
this->AddPathsInternal(out_paths, tmp, EnvPath, emmitted); this->AddPathsInternal(tmp, EnvPath);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindCommon::AddPathsInternal(std::vector<std::string>& out_paths, void cmFindCommon::AddPathsInternal(std::vector<std::string> const& in_paths,
std::vector<std::string> const& in_paths, PathType pathType)
PathType pathType,
std::set<cmStdString>* emmitted)
{ {
for(std::vector<std::string>::const_iterator i = in_paths.begin(); for(std::vector<std::string>::const_iterator i = in_paths.begin();
i != in_paths.end(); ++i) i != in_paths.end(); ++i)
{ {
this->AddPathInternal(out_paths, *i, pathType, emmitted); this->AddPathInternal(*i, pathType);
} }
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindCommon::AddPathInternal(std::vector<std::string>& out_paths, void cmFindCommon::AddPathInternal(std::string const& in_path,
std::string const& in_path, PathType pathType)
PathType pathType,
std::set<cmStdString>* emmitted)
{ {
if(in_path.empty()) if(in_path.empty())
{ {
@ -471,9 +411,9 @@ void cmFindCommon::AddPathInternal(std::vector<std::string>& out_paths,
std::string fullPath = std::string fullPath =
cmSystemTools::CollapseFullPath(in_path.c_str(), relbase); cmSystemTools::CollapseFullPath(in_path.c_str(), relbase);
// Insert the path if has not already been emmitted. // Insert the path if has not already been emitted.
if(!emmitted || emmitted->insert(fullPath).second) if(this->SearchPathsEmitted.insert(fullPath).second)
{ {
out_paths.push_back(fullPath.c_str()); this->SearchPaths.push_back(fullPath.c_str());
} }
} }

24
Source/cmFindCommon.h
View File

@ -55,21 +55,12 @@ protected:
bool CheckCommonArgument(std::string const& arg); bool CheckCommonArgument(std::string const& arg);
void AddPathSuffix(std::string const& arg); void AddPathSuffix(std::string const& arg);
void GetAppBundlePaths(std::vector<std::string>& paths); void AddUserPath(std::string const& p);
void GetFrameworkPaths(std::vector<std::string>& paths); void AddCMakePath(const char* variable);
void AddEnvPath(const char* variable);
void AddCMakePath(std::vector<std::string>& out_paths, void AddPathsInternal(std::vector<std::string> const& in_paths,
const char* variable, std::set<cmStdString>* emmitted = 0); PathType pathType);
void AddEnvPath(std::vector<std::string>& out_paths, void AddPathInternal(std::string const& in_path, PathType pathType);
const char* variable, std::set<cmStdString>* emmitted = 0);
void AddPathsInternal(std::vector<std::string>& out_paths,
std::vector<std::string> const& in_paths,
PathType pathType,
std::set<cmStdString>* emmitted = 0);
void AddPathInternal(std::vector<std::string>& out_paths,
std::string const& in_path,
PathType pathType,
std::set<cmStdString>* emmitted = 0);
bool NoDefaultPath; bool NoDefaultPath;
bool NoCMakePath; bool NoCMakePath;
@ -78,6 +69,9 @@ protected:
bool NoCMakeSystemPath; bool NoCMakeSystemPath;
std::vector<std::string> SearchPathSuffixes; std::vector<std::string> SearchPathSuffixes;
std::vector<std::string> UserPaths;
std::vector<std::string> SearchPaths;
std::set<cmStdString> SearchPathsEmitted;
std::string GenericDocumentationMacPolicy; std::string GenericDocumentationMacPolicy;
std::string GenericDocumentationRootPath; std::string GenericDocumentationRootPath;

88
Source/cmFindPackageCommand.cxx
View File

@ -821,8 +821,9 @@ void cmFindPackageCommand::FindConfig()
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool cmFindPackageCommand::FindPrefixedConfig() bool cmFindPackageCommand::FindPrefixedConfig()
{ {
for(std::vector<std::string>::const_iterator pi = this->Prefixes.begin(); std::vector<std::string>& prefixes = this->SearchPaths;
pi != this->Prefixes.end(); ++pi) for(std::vector<std::string>::const_iterator pi = prefixes.begin();
pi != prefixes.end(); ++pi)
{ {
if(this->SearchPrefix(*pi)) if(this->SearchPrefix(*pi))
{ {
@ -835,8 +836,9 @@ bool cmFindPackageCommand::FindPrefixedConfig()
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool cmFindPackageCommand::FindFrameworkConfig() bool cmFindPackageCommand::FindFrameworkConfig()
{ {
for(std::vector<std::string>::const_iterator i = this->Prefixes.begin(); std::vector<std::string>& prefixes = this->SearchPaths;
i != this->Prefixes.end(); ++i) for(std::vector<std::string>::const_iterator i = prefixes.begin();
i != prefixes.end(); ++i)
{ {
if(this->SearchFrameworkPrefix(*i)) if(this->SearchFrameworkPrefix(*i))
{ {
@ -849,8 +851,9 @@ bool cmFindPackageCommand::FindFrameworkConfig()
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool cmFindPackageCommand::FindAppBundleConfig() bool cmFindPackageCommand::FindAppBundleConfig()
{ {
for(std::vector<std::string>::const_iterator i = this->Prefixes.begin(); std::vector<std::string>& prefixes = this->SearchPaths;
i != this->Prefixes.end(); ++i) for(std::vector<std::string>::const_iterator i = prefixes.begin();
i != prefixes.end(); ++i)
{ {
if(this->SearchAppBundlePrefix(*i)) if(this->SearchAppBundlePrefix(*i))
{ {
@ -939,19 +942,20 @@ void cmFindPackageCommand::AppendSuccessInformation()
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindPackageCommand::AddUserPath(std::string const& p) void cmFindPackageCommand::ComputePrefixes()
{ {
std::string userPath = p; this->AddPrefixesCMakeEnvironment();
cmSystemTools::ExpandRegistryValues(userPath); this->AddPrefixesCMakeVariable();
this->UserPaths.push_back(userPath); this->AddPrefixesSystemEnvironment();
this->AddPrefixesBuilds();
this->AddPrefixesCMakeSystemVariable();
this->AddPrefixesUser();
this->ComputeFinalPrefixes();
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindPackageCommand::ComputePrefixes() void cmFindPackageCommand::AddPrefixesCMakeEnvironment()
{ {
std::vector<std::string>& prefixes = this->Prefixes;
std::set<cmStdString> emmitted;
if(!this->NoCMakeEnvironmentPath && !this->NoDefaultPath) if(!this->NoCMakeEnvironmentPath && !this->NoDefaultPath)
{ {
// Check the environment variable with the same name as the cache // Check the environment variable with the same name as the cache
@ -960,21 +964,29 @@ void cmFindPackageCommand::ComputePrefixes()
if(cmSystemTools::GetEnv(this->Variable.c_str(), env) && env.length() > 0) if(cmSystemTools::GetEnv(this->Variable.c_str(), env) && env.length() > 0)
{ {
cmSystemTools::ConvertToUnixSlashes(env); cmSystemTools::ConvertToUnixSlashes(env);
this->AddPathInternal(prefixes, env, EnvPath, &emmitted); this->AddPathInternal(env, EnvPath);
} }
this->AddEnvPath(prefixes, "CMAKE_PREFIX_PATH", &emmitted); this->AddEnvPath("CMAKE_PREFIX_PATH");
this->AddEnvPath(prefixes, "CMAKE_FRAMEWORK_PATH", &emmitted); this->AddEnvPath("CMAKE_FRAMEWORK_PATH");
this->AddEnvPath(prefixes, "CMAKE_APPBUNDLE_PATH", &emmitted); this->AddEnvPath("CMAKE_APPBUNDLE_PATH");
}
} }
//----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesCMakeVariable()
{
if(!this->NoCMakePath && !this->NoDefaultPath) if(!this->NoCMakePath && !this->NoDefaultPath)
{ {
this->AddCMakePath(prefixes, "CMAKE_PREFIX_PATH", &emmitted); this->AddCMakePath("CMAKE_PREFIX_PATH");
this->AddCMakePath(prefixes, "CMAKE_FRAMEWORK_PATH", &emmitted); this->AddCMakePath("CMAKE_FRAMEWORK_PATH");
this->AddCMakePath(prefixes, "CMAKE_APPBUNDLE_PATH", &emmitted); this->AddCMakePath("CMAKE_APPBUNDLE_PATH");
}
} }
//----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesSystemEnvironment()
{
if(!this->NoSystemEnvironmentPath && !this->NoDefaultPath) if(!this->NoSystemEnvironmentPath && !this->NoDefaultPath)
{ {
// Use the system search path to generate prefixes. // Use the system search path to generate prefixes.
@ -991,17 +1003,19 @@ void cmFindPackageCommand::ComputePrefixes()
if(d.size() >= 4 && strcmp(d.c_str()+d.size()-4, "/bin") == 0 || if(d.size() >= 4 && strcmp(d.c_str()+d.size()-4, "/bin") == 0 ||
d.size() >= 5 && strcmp(d.c_str()+d.size()-5, "/sbin") == 0) d.size() >= 5 && strcmp(d.c_str()+d.size()-5, "/sbin") == 0)
{ {
this->AddPathInternal(prefixes, this->AddPathInternal(cmSystemTools::GetFilenamePath(d), EnvPath);
cmSystemTools::GetFilenamePath(d),
EnvPath, &emmitted);
} }
else else
{ {
this->AddPathInternal(prefixes, d, EnvPath, &emmitted); this->AddPathInternal(d, EnvPath);
}
} }
} }
} }
//----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesBuilds()
{
if(!this->NoBuilds && !this->NoDefaultPath) if(!this->NoBuilds && !this->NoDefaultPath)
{ {
// It is likely that CMake will have recently built the project. // It is likely that CMake will have recently built the project.
@ -1017,23 +1031,37 @@ void cmFindPackageCommand::ComputePrefixes()
if(cmSystemTools::FileIsFullPath(f.c_str()) && if(cmSystemTools::FileIsFullPath(f.c_str()) &&
cmSystemTools::FileIsDirectory(f.c_str())) cmSystemTools::FileIsDirectory(f.c_str()))
{ {
this->AddPathInternal(prefixes, f, FullPath, &emmitted); this->AddPathInternal(f, FullPath);
}
} }
} }
} }
//----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesCMakeSystemVariable()
{
if(!this->NoCMakeSystemPath && !this->NoDefaultPath) if(!this->NoCMakeSystemPath && !this->NoDefaultPath)
{ {
this->AddCMakePath(prefixes, "CMAKE_SYSTEM_PREFIX_PATH", &emmitted); this->AddCMakePath("CMAKE_SYSTEM_PREFIX_PATH");
this->AddCMakePath(prefixes, "CMAKE_SYSTEM_FRAMEWORK_PATH", &emmitted); this->AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
this->AddCMakePath(prefixes, "CMAKE_SYSTEM_APPBUNDLE_PATH", &emmitted); this->AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
}
} }
//----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesUser()
{
if(!this->UserPaths.empty()) if(!this->UserPaths.empty())
{ {
// Add paths specified by the caller. // Add paths specified by the caller.
this->AddPathsInternal(prefixes, this->UserPaths, CMakePath, &emmitted); this->AddPathsInternal(this->UserPaths, CMakePath);
} }
}
//----------------------------------------------------------------------------
void cmFindPackageCommand::ComputeFinalPrefixes()
{
std::vector<std::string>& prefixes = this->SearchPaths;
// Construct the final set of prefixes. // Construct the final set of prefixes.
this->RerootPaths(prefixes); this->RerootPaths(prefixes);

10
Source/cmFindPackageCommand.h
View File

@ -82,8 +82,14 @@ private:
bool ReadListFile(const char* f); bool ReadListFile(const char* f);
void StoreVersionFound(); void StoreVersionFound();
void AddUserPath(std::string const& p);
void ComputePrefixes(); void ComputePrefixes();
void AddPrefixesCMakeEnvironment();
void AddPrefixesCMakeVariable();
void AddPrefixesSystemEnvironment();
void AddPrefixesBuilds();
void AddPrefixesCMakeSystemVariable();
void AddPrefixesUser();
void ComputeFinalPrefixes();
bool SearchDirectory(std::string const& dir); bool SearchDirectory(std::string const& dir);
bool CheckDirectory(std::string const& dir); bool CheckDirectory(std::string const& dir);
bool FindConfigFile(std::string const& dir, std::string& file); bool FindConfigFile(std::string const& dir, std::string& file);
@ -119,8 +125,6 @@ private:
bool DebugMode; bool DebugMode;
std::vector<std::string> Names; std::vector<std::string> Names;
std::vector<std::string> Configs; std::vector<std::string> Configs;
std::vector<std::string> Prefixes;
std::vector<std::string> UserPaths;
}; };
#endif #endif