kolan/CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge topic 'refactor-search-path-construction'

Browse Source 
1abd7cd9 Use containers of labeled search paths instead of individual members
2a9ac4bd Encapsulate search path manipulation functions into a seperate class.
32922840 Refactor and seperate search path construction for find commands
This commit is contained in:
Brad King 2014-11-13 10:08:27 -05:00 committed by CMake Topic Stage
commit dd89506c1e
12 changed files with 848 additions and 472 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Source/cmBootstrapCommands1.cxx
View File

@ -52,6 +52,8 @@
#include "cmFindProgramCommand.cxx" #include "cmFindProgramCommand.cxx"
#include "cmForEachCommand.cxx" #include "cmForEachCommand.cxx"
#include "cmFunctionCommand.cxx" #include "cmFunctionCommand.cxx"
#include "cmPathLabel.cxx"
#include "cmSearchPath.cxx"
void GetBootstrapCommands1(std::list<cmCommand*>& commands) void GetBootstrapCommands1(std::list<cmCommand*>& commands)
{ {

292
Source/cmFindBase.cxx
View File

@ -140,11 +140,11 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
} }
else if(doing == DoingPaths) else if(doing == DoingPaths)
{ {
this->AddUserPath(args[j], this->UserPaths); this->UserGuessArgs.push_back(args[j]);
} }
else if(doing == DoingHints) else if(doing == DoingHints)
{ {
this->AddUserPath(args[j], this->UserHints); this->UserHintsArgs.push_back(args[j]);
} }
else if(doing == DoingPathSuffixes) else if(doing == DoingPathSuffixes)
{ {
@ -186,16 +186,11 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
this->Names.push_back(shortArgs[0]); this->Names.push_back(shortArgs[0]);
for(unsigned int j = 1; j < shortArgs.size(); ++j) for(unsigned int j = 1; j < shortArgs.size(); ++j)
{ {
this->AddUserPath(shortArgs[j], this->UserPaths); this->UserGuessArgs.push_back(shortArgs[j]);
} }
} }
this->ExpandPaths(); this->ExpandPaths();
// Filter out ignored paths from the prefix list
std::set<std::string> ignored;
this->GetIgnoredPaths(ignored);
this->FilterPaths(this->SearchPaths, ignored);
this->ComputeFinalPaths(); this->ComputeFinalPaths();
return true; return true;
@ -203,226 +198,142 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
void cmFindBase::ExpandPaths() void cmFindBase::ExpandPaths()
{ {
this->AddCMakeVariablePath(); if(!this->NoDefaultPath)
this->AddCMakeEnvironmentPath(); {
this->AddUserHintsPath(); if(!this->NoCMakePath)
this->AddSystemEnvironmentPath(); {
this->AddCMakeSystemVariablePath(); this->FillCMakeVariablePath();
this->AddUserGuessPath(); }
if(!this->NoCMakeEnvironmentPath)
{
this->FillCMakeEnvironmentPath();
}
if(!this->NoSystemEnvironmentPath)
{
this->FillSystemEnvironmentPath();
}
if(!this->NoCMakeSystemPath)
{
this->FillCMakeSystemVariablePath();
}
}
// Add suffixes and clean up paths. this->FillUserHintsPath();
this->AddPathSuffixes(); this->FillUserGuessPath();
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindBase::AddPrefixPaths(std::vector<std::string> const& in_paths, void cmFindBase::FillCMakeEnvironmentPath()
PathType pathType)
{ {
// default for programs cmSearchPath &paths = this->LabeledPaths[PathLabel::CMakeEnvironment];
std::string subdir = "bin";
if (this->CMakePathName == "INCLUDE") // Add CMAKE_*_PATH environment variables
{ std::string var = "CMAKE_";
subdir = "include"; var += this->CMakePathName;
} var += "_PATH";
else if (this->CMakePathName == "LIBRARY") paths.AddEnvPrefixPath("CMAKE_PREFIX_PATH");
{ paths.AddEnvPath(var);
subdir = "lib";
}
else if (this->CMakePathName == "FRAMEWORK")
{
subdir = ""; // ? what to do for frameworks ?
}
for(std::vector<std::string>::const_iterator it = in_paths.begin(); if(this->CMakePathName == "PROGRAM")
it != in_paths.end(); ++it)
{ {
std::string dir = *it; paths.AddEnvPath("CMAKE_APPBUNDLE_PATH");
if(!subdir.empty() && !dir.empty() && dir[dir.size()-1] != '/')
{
dir += "/";
}
if(subdir == "include" || subdir == "lib")
{
const char* arch =
this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE");
if(arch && *arch)
{
this->AddPathInternal(dir+subdir+"/"+arch, pathType);
}
}
std::string add = dir + subdir;
if(add != "/")
{
this->AddPathInternal(add, pathType);
}
if (subdir == "bin")
{
this->AddPathInternal(dir+"sbin", pathType);
}
if(!subdir.empty() && *it != "/")
{
this->AddPathInternal(*it, pathType);
}
} }
else
{
paths.AddEnvPath("CMAKE_FRAMEWORK_PATH");
}
paths.AddSuffixes(this->SearchPathSuffixes);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindBase::AddCMakePrefixPath(const std::string& variable) void cmFindBase::FillCMakeVariablePath()
{ {
// Get a path from a CMake variable. cmSearchPath &paths = this->LabeledPaths[PathLabel::CMake];
if(const char* varPath = this->Makefile->GetDefinition(variable))
// 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";
paths.AddCMakePrefixPath("CMAKE_PREFIX_PATH");
paths.AddCMakePath(var);
if(this->CMakePathName == "PROGRAM")
{ {
std::vector<std::string> tmp; paths.AddCMakePath("CMAKE_APPBUNDLE_PATH");
cmSystemTools::ExpandListArgument(varPath, tmp);
this->AddPrefixPaths(tmp, CMakePath);
} }
} else
//----------------------------------------------------------------------------
void cmFindBase::AddEnvPrefixPath(const std::string& variable)
{
// Get a path from the environment.
std::vector<std::string> tmp;
cmSystemTools::GetPath(tmp, variable.c_str());
this->AddPrefixPaths(tmp, EnvPath);
}
//----------------------------------------------------------------------------
void cmFindBase::AddCMakeEnvironmentPath()
{
if(!this->NoCMakeEnvironmentPath && !this->NoDefaultPath)
{ {
// Add CMAKE_*_PATH environment variables paths.AddCMakePath("CMAKE_FRAMEWORK_PATH");
std::string var = "CMAKE_";
var += this->CMakePathName;
var += "_PATH";
this->AddEnvPrefixPath("CMAKE_PREFIX_PATH");
this->AddEnvPath(var.c_str());
if(this->CMakePathName == "PROGRAM")
{
this->AddEnvPath("CMAKE_APPBUNDLE_PATH");
}
else
{
this->AddEnvPath("CMAKE_FRAMEWORK_PATH");
}
} }
paths.AddSuffixes(this->SearchPathSuffixes);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindBase::AddCMakeVariablePath() void cmFindBase::FillSystemEnvironmentPath()
{ {
if(!this->NoCMakePath && !this->NoDefaultPath) cmSearchPath &paths = this->LabeledPaths[PathLabel::SystemEnvironment];
// Add LIB or INCLUDE
if(!this->EnvironmentPath.empty())
{ {
// Add CMake varibles of the same name as the previous environment paths.AddEnvPath(this->EnvironmentPath);
// 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);
if(this->CMakePathName == "PROGRAM")
{
this->AddCMakePath("CMAKE_APPBUNDLE_PATH");
}
else
{
this->AddCMakePath("CMAKE_FRAMEWORK_PATH");
}
} }
// Add PATH
paths.AddEnvPath("PATH");
paths.AddSuffixes(this->SearchPathSuffixes);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindBase::AddSystemEnvironmentPath() void cmFindBase::FillCMakeSystemVariablePath()
{ {
if(!this->NoSystemEnvironmentPath && !this->NoDefaultPath) cmSearchPath &paths = this->LabeledPaths[PathLabel::CMakeSystem];
std::string var = "CMAKE_SYSTEM_";
var += this->CMakePathName;
var += "_PATH";
paths.AddCMakePrefixPath("CMAKE_SYSTEM_PREFIX_PATH");
paths.AddCMakePath(var);
if(this->CMakePathName == "PROGRAM")
{ {
// Add LIB or INCLUDE paths.AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
if(!this->EnvironmentPath.empty())
{
this->AddEnvPath(this->EnvironmentPath.c_str());
}
// Add PATH
this->AddEnvPath(0);
} }
} else
//----------------------------------------------------------------------------
void cmFindBase::AddCMakeSystemVariablePath()
{
if(!this->NoCMakeSystemPath && !this->NoDefaultPath)
{ {
std::string var = "CMAKE_SYSTEM_"; paths.AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
var += this->CMakePathName;
var += "_PATH";
this->AddCMakePrefixPath("CMAKE_SYSTEM_PREFIX_PATH");
this->AddCMakePath(var);
if(this->CMakePathName == "PROGRAM")
{
this->AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
}
else
{
this->AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
}
} }
paths.AddSuffixes(this->SearchPathSuffixes);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindBase::AddUserHintsPath() void cmFindBase::FillUserHintsPath()
{ {
this->AddPathsInternal(this->UserHints, CMakePath); cmSearchPath &paths = this->LabeledPaths[PathLabel::Hints];
}
//---------------------------------------------------------------------------- for(std::vector<std::string>::const_iterator p = this->UserHintsArgs.begin();
void cmFindBase::AddUserGuessPath() p != this->UserHintsArgs.end(); ++p)
{
this->AddPathsInternal(this->UserPaths, CMakePath);
}
//----------------------------------------------------------------------------
void cmFindBase::AddPathSuffixes()
{
std::vector<std::string>& paths = this->SearchPaths;
std::vector<std::string> finalPath = paths;
std::vector<std::string>::iterator i;
// clear the path
paths.clear();
// convert all paths to unix slashes and add search path suffixes
// if there are any
for(i = finalPath.begin();
i != finalPath.end(); ++i)
{ {
cmSystemTools::ConvertToUnixSlashes(*i); paths.AddUserPath(*p);
// copy each finalPath combined with SearchPathSuffixes
// to the SearchPaths ivar
for(std::vector<std::string>::iterator j =
this->SearchPathSuffixes.begin();
j != this->SearchPathSuffixes.end(); ++j)
{
// if *i is only / then do not add a //
// this will get incorrectly considered a network
// path on windows and cause huge delays.
std::string p = *i;
if(p.size() && p[p.size()-1] != '/')
{
p += std::string("/");
}
p += *j;
// add to all paths because the search path may be modified
// later with lib being replaced for lib64 which may exist
paths.push_back(p);
}
// now put the path without the path suffixes in the SearchPaths
paths.push_back(*i);
} }
paths.AddSuffixes(this->SearchPathSuffixes);
} }
//----------------------------------------------------------------------------
void cmFindBase::FillUserGuessPath()
{
cmSearchPath &paths = this->LabeledPaths[PathLabel::Guess];
for(std::vector<std::string>::const_iterator p = this->UserGuessArgs.begin();
p != this->UserGuessArgs.end(); ++p)
{
paths.AddUserPath(*p);
}
paths.AddSuffixes(this->SearchPathSuffixes);
}
//----------------------------------------------------------------------------
void cmFindBase::PrintFindStuff() void cmFindBase::PrintFindStuff()
{ {
std::cerr << "SearchFrameworkLast: " << this->SearchFrameworkLast << "\n"; std::cerr << "SearchFrameworkLast: " << this->SearchFrameworkLast << "\n";
@ -457,9 +368,10 @@ void cmFindBase::PrintFindStuff()
} }
std::cerr << "\n"; std::cerr << "\n";
std::cerr << "SearchPaths\n"; std::cerr << "SearchPaths\n";
for(unsigned int i =0; i < this->SearchPaths.size(); ++i) for(std::vector<std::string>::const_iterator i = this->SearchPaths.begin();
i != this->SearchPaths.end(); ++i)
{ {
std::cerr << "[" << this->SearchPaths[i] << "]\n"; std::cerr << "[" << *i << "]\n";
} }
} }

19
Source/cmFindBase.h
View File

@ -34,7 +34,6 @@ public:
protected: protected:
void PrintFindStuff(); void PrintFindStuff();
void ExpandPaths(); void ExpandPaths();
void AddPathSuffixes();
// 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
@ -55,18 +54,12 @@ protected:
bool AlreadyInCacheWithoutMetaInfo; bool AlreadyInCacheWithoutMetaInfo;
private: private:
// Add pieces of the search. // Add pieces of the search.
void AddCMakeEnvironmentPath(); void FillCMakeVariablePath();
void AddCMakeVariablePath(); void FillCMakeEnvironmentPath();
void AddSystemEnvironmentPath(); void FillUserHintsPath();
void AddCMakeSystemVariablePath(); void FillSystemEnvironmentPath();
void AddUserHintsPath(); void FillCMakeSystemVariablePath();
void AddUserGuessPath(); void FillUserGuessPath();
// Helpers.
void AddCMakePrefixPath(const std::string& variable);
void AddEnvPrefixPath(const std::string& variable);
void AddPrefixPaths(std::vector<std::string> const& in_paths,
PathType pathType);
}; };

204
Source/cmFindCommon.cxx
View File

@ -10,6 +10,19 @@
See the License for more information. See the License for more information.
============================================================================*/ ============================================================================*/
#include "cmFindCommon.h" #include "cmFindCommon.h"
#include <functional>
#include <algorithm>
//----------------------------------------------------------------------------
cmFindCommon::PathGroup cmFindCommon::PathGroup::All("ALL");
cmFindCommon::PathLabel cmFindCommon::PathLabel::CMake("CMAKE");
cmFindCommon::PathLabel
cmFindCommon::PathLabel::CMakeEnvironment("CMAKE_ENVIRONMENT");
cmFindCommon::PathLabel cmFindCommon::PathLabel::Hints("HINTS");
cmFindCommon::PathLabel
cmFindCommon::PathLabel::SystemEnvironment("SYSTM_ENVIRONMENT");
cmFindCommon::PathLabel cmFindCommon::PathLabel::CMakeSystem("CMAKE_SYSTEM");
cmFindCommon::PathLabel cmFindCommon::PathLabel::Guess("GUESS");
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
cmFindCommon::cmFindCommon() cmFindCommon::cmFindCommon()
@ -34,6 +47,8 @@ cmFindCommon::cmFindCommon()
this->SearchFrameworkLast = false; this->SearchFrameworkLast = false;
this->SearchAppBundleOnly = false; this->SearchAppBundleOnly = false;
this->SearchAppBundleLast = false; this->SearchAppBundleLast = false;
this->InitializeSearchPathGroups();
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -41,12 +56,43 @@ cmFindCommon::~cmFindCommon()
{ {
} }
//----------------------------------------------------------------------------
void cmFindCommon::InitializeSearchPathGroups()
{
std::vector<PathLabel>* labels;
// Define the varoius different groups of path types
// All search paths
labels = &this->PathGroupLabelMap[PathGroup::All];
labels->push_back(PathLabel::CMake);
labels->push_back(PathLabel::CMakeEnvironment);
labels->push_back(PathLabel::Hints);
labels->push_back(PathLabel::SystemEnvironment);
labels->push_back(PathLabel::CMakeSystem);
labels->push_back(PathLabel::Guess);
// Define the search group order
this->PathGroupOrder.push_back(PathGroup::All);
// Create the idividual labeld search paths
this->LabeledPaths.insert(std::make_pair(PathLabel::CMake,
cmSearchPath(this)));
this->LabeledPaths.insert(std::make_pair(PathLabel::CMakeEnvironment,
cmSearchPath(this)));
this->LabeledPaths.insert(std::make_pair(PathLabel::Hints,
cmSearchPath(this)));
this->LabeledPaths.insert(std::make_pair(PathLabel::SystemEnvironment,
cmSearchPath(this)));
this->LabeledPaths.insert(std::make_pair(PathLabel::CMakeSystem,
cmSearchPath(this)));
this->LabeledPaths.insert(std::make_pair(PathLabel::Guess,
cmSearchPath(this)));
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindCommon::SelectDefaultRootPathMode() void cmFindCommon::SelectDefaultRootPathMode()
{ {
// Use both by default.
this->FindRootPathMode = RootPathModeBoth;
// Check the policy variable for this find command type. // Check the policy variable for this find command type.
std::string findRootPathVar = "CMAKE_FIND_ROOT_PATH_MODE_"; std::string findRootPathVar = "CMAKE_FIND_ROOT_PATH_MODE_";
findRootPathVar += this->CMakePathName; findRootPathVar += this->CMakePathName;
@ -54,11 +100,11 @@ void cmFindCommon::SelectDefaultRootPathMode()
this->Makefile->GetSafeDefinition(findRootPathVar); this->Makefile->GetSafeDefinition(findRootPathVar);
if (rootPathMode=="NEVER") if (rootPathMode=="NEVER")
{ {
this->FindRootPathMode = RootPathModeNoRootPath; this->FindRootPathMode = RootPathModeNever;
} }
else if (rootPathMode=="ONLY") else if (rootPathMode=="ONLY")
{ {
this->FindRootPathMode = RootPathModeOnlyRootPath; this->FindRootPathMode = RootPathModeOnly;
} }
else if (rootPathMode=="BOTH") else if (rootPathMode=="BOTH")
{ {
@ -132,12 +178,12 @@ void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
fprintf(stderr, "[%s]\n", i->c_str()); fprintf(stderr, "[%s]\n", i->c_str());
} }
#endif #endif
// Short-circuit if there is nothing to do. // Short-circuit if there is nothing to do.
if(this->FindRootPathMode == RootPathModeNoRootPath) if(this->FindRootPathMode == RootPathModeNever)
{ {
return; return;
} }
const char* sysroot = const char* sysroot =
this->Makefile->GetDefinition("CMAKE_SYSROOT"); this->Makefile->GetDefinition("CMAKE_SYSROOT");
const char* rootPath = const char* rootPath =
@ -212,24 +258,20 @@ void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindCommon::FilterPaths(std::vector<std::string>& paths, void cmFindCommon::FilterPaths(const std::vector<std::string>& inPaths,
const std::set<std::string>& ignore) const std::set<std::string>& ignore,
std::vector<std::string>& outPaths)
{ {
// Now filter out anything that's in the ignore set. for(std::vector<std::string>::const_iterator i = inPaths.begin();
std::vector<std::string> unfiltered; i != inPaths.end(); ++i)
unfiltered.swap(paths);
for(std::vector<std::string>::iterator pi = unfiltered.begin();
pi != unfiltered.end(); ++pi)
{ {
if (ignore.count(*pi) == 0) if(ignore.count(*i) == 0)
{ {
paths.push_back(*pi); outPaths.push_back(*i);
} }
} }
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindCommon::GetIgnoredPaths(std::vector<std::string>& ignore) void cmFindCommon::GetIgnoredPaths(std::vector<std::string>& ignore)
{ {
@ -266,8 +308,6 @@ void cmFindCommon::GetIgnoredPaths(std::set<std::string>& ignore)
ignore.insert(ignoreVec.begin(), ignoreVec.end()); ignore.insert(ignoreVec.begin(), ignoreVec.end());
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool cmFindCommon::CheckCommonArgument(std::string const& arg) bool cmFindCommon::CheckCommonArgument(std::string const& arg)
{ {
@ -291,13 +331,13 @@ bool cmFindCommon::CheckCommonArgument(std::string const& arg)
{ {
this->NoCMakeSystemPath = true; this->NoCMakeSystemPath = true;
} }
else if(arg == "NO_CMAKE_FIND_ROOT_PATH") else if(arg == "NO_CMAKE_FIND_ROOT_PATH")
{ {
this->FindRootPathMode = RootPathModeNoRootPath; this->FindRootPathMode = RootPathModeNever;
} }
else if(arg == "ONLY_CMAKE_FIND_ROOT_PATH") else if(arg == "ONLY_CMAKE_FIND_ROOT_PATH")
{ {
this->FindRootPathMode = RootPathModeOnlyRootPath; this->FindRootPathMode = RootPathModeOnly;
} }
else if(arg == "CMAKE_FIND_ROOT_PATH_BOTH") else if(arg == "CMAKE_FIND_ROOT_PATH_BOTH")
{ {
@ -345,116 +385,34 @@ void cmFindCommon::AddPathSuffix(std::string const& arg)
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindCommon::AddUserPath(std::string const& p, void AddTrailingSlash(std::string& s)
std::vector<std::string>& paths)
{ {
// We should view the registry as the target application would view if(!s.empty() && *s.rbegin() != '/')
// it.
cmSystemTools::KeyWOW64 view = cmSystemTools::KeyWOW64_32;
cmSystemTools::KeyWOW64 other_view = cmSystemTools::KeyWOW64_64;
if(this->Makefile->PlatformIs64Bit())
{ {
view = cmSystemTools::KeyWOW64_64; s += '/';
other_view = cmSystemTools::KeyWOW64_32;
}
// Expand using the view of the target application.
std::string expanded = p;
cmSystemTools::ExpandRegistryValues(expanded, view);
cmSystemTools::GlobDirs(expanded, paths);
// Executables can be either 32-bit or 64-bit, so expand using the
// alternative view.
if(expanded != p && this->CMakePathName == "PROGRAM")
{
expanded = p;
cmSystemTools::ExpandRegistryValues(expanded, other_view);
cmSystemTools::GlobDirs(expanded, paths);
} }
} }
//----------------------------------------------------------------------------
void cmFindCommon::AddCMakePath(const std::string& variable)
{
// Get a path from a CMake variable.
if(const char* varPath = this->Makefile->GetDefinition(variable))
{
std::vector<std::string> tmp;
cmSystemTools::ExpandListArgument(varPath, tmp);
// Relative paths are interpreted with respect to the current
// source directory.
this->AddPathsInternal(tmp, CMakePath);
}
}
//----------------------------------------------------------------------------
void cmFindCommon::AddEnvPath(const char* variable)
{
// Get a path from the environment.
std::vector<std::string> tmp;
cmSystemTools::GetPath(tmp, variable);
// Relative paths are interpreted with respect to the current
// working directory.
this->AddPathsInternal(tmp, EnvPath);
}
//----------------------------------------------------------------------------
void cmFindCommon::AddPathsInternal(std::vector<std::string> const& in_paths,
PathType pathType)
{
for(std::vector<std::string>::const_iterator i = in_paths.begin();
i != in_paths.end(); ++i)
{
this->AddPathInternal(*i, pathType);
}
}
//----------------------------------------------------------------------------
void cmFindCommon::AddPathInternal(std::string const& in_path,
PathType pathType)
{
if(in_path.empty())
{
return;
}
// Select the base path with which to interpret relative paths.
const char* relbase = 0;
if(pathType == CMakePath)
{
relbase = this->Makefile->GetCurrentDirectory();
}
// Convert to clean full path.
std::string fullPath =
cmSystemTools::CollapseFullPath(in_path, relbase);
// Insert the path if has not already been emitted.
if(this->SearchPathsEmitted.insert(fullPath).second)
{
this->SearchPaths.push_back(fullPath);
}
}
//----------------------------------------------------------------------------
void cmFindCommon::ComputeFinalPaths() void cmFindCommon::ComputeFinalPaths()
{ {
std::vector<std::string>& paths = this->SearchPaths; // Filter out ignored paths from the prefix list
std::set<std::string> ignored;
this->GetIgnoredPaths(ignored);
// Combine the seperate path types, filtering out ignores
this->SearchPaths.clear();
std::vector<PathLabel>& allLabels = this->PathGroupLabelMap[PathGroup::All];
for(std::vector<PathLabel>::const_iterator l = allLabels.begin();
l != allLabels.end(); ++l)
{
this->LabeledPaths[*l].ExtractWithout(ignored, this->SearchPaths);
}
// Expand list of paths inside all search roots. // Expand list of paths inside all search roots.
this->RerootPaths(paths); this->RerootPaths(this->SearchPaths);
// Add a trailing slash to all paths to aid the search process. // Add a trailing slash to all paths to aid the search process.
for(std::vector<std::string>::iterator i = paths.begin(); std::for_each(this->SearchPaths.begin(), this->SearchPaths.end(),
i != paths.end(); ++i) &AddTrailingSlash);
{
std::string& p = *i;
if(!p.empty() && p[p.size()-1] != '/')
{
p += "/";
}
}
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------

69
Source/cmFindCommon.h
View File

@ -13,6 +13,8 @@
#define cmFindCommon_h #define cmFindCommon_h
#include "cmCommand.h" #include "cmCommand.h"
#include "cmSearchPath.h"
#include "cmPathLabel.h"
/** \class cmFindCommon /** \class cmFindCommon
* \brief Base class for FIND_XXX implementations. * \brief Base class for FIND_XXX implementations.
@ -29,12 +31,46 @@ public:
cmTypeMacro(cmFindCommon, cmCommand); cmTypeMacro(cmFindCommon, cmCommand);
protected: protected:
friend class cmSearchPath;
enum RootPathMode { RootPathModeBoth, /* VS6 is broken and can't pass protected class definitions to child classes */
RootPathModeOnlyRootPath, #if defined(_MSC_VER) && (_MSC_VER < 1300)
RootPathModeNoRootPath }; public:
#endif
/** Used to define groups of path labels */
class PathGroup : public cmPathLabel
{
protected:
PathGroup();
public:
PathGroup(const std::string& label) : cmPathLabel(label) { }
static PathGroup All;
};
enum PathType { FullPath, CMakePath, EnvPath }; /* Individual path types */
class PathLabel : public cmPathLabel
{
protected:
PathLabel();
public:
PathLabel(const std::string& label) : cmPathLabel(label) { }
static PathLabel CMake;
static PathLabel CMakeEnvironment;
static PathLabel Hints;
static PathLabel SystemEnvironment;
static PathLabel CMakeSystem;
static PathLabel Guess;
};
#if defined(_MSC_VER) && (_MSC_VER < 1300)
protected:
#endif
enum RootPathMode { RootPathModeNever,
RootPathModeOnly,
RootPathModeBoth };
/** Construct the various path groups and labels */
void InitializeSearchPathGroups();
/** Place a set of search paths under the search roots. */ /** Place a set of search paths under the search roots. */
void RerootPaths(std::vector<std::string>& paths); void RerootPaths(std::vector<std::string>& paths);
@ -44,8 +80,9 @@ protected:
void GetIgnoredPaths(std::set<std::string>& ignore); void GetIgnoredPaths(std::set<std::string>& ignore);
/** Remove paths in the ignore set from the supplied vector. */ /** Remove paths in the ignore set from the supplied vector. */
void FilterPaths(std::vector<std::string>& paths, void FilterPaths(const std::vector<std::string>& inPaths,
const std::set<std::string>& ignore); const std::set<std::string>& ignore,
std::vector<std::string>& outPaths);
/** Compute final search path list (reroot + trailing slash). */ /** Compute final search path list (reroot + trailing slash). */
void ComputeFinalPaths(); void ComputeFinalPaths();
@ -56,19 +93,15 @@ protected:
/** Compute the current default bundle/framework search policy. */ /** Compute the current default bundle/framework search policy. */
void SelectDefaultMacMode(); void SelectDefaultMacMode();
// Path arguments prior to path manipulation routines
std::vector<std::string> UserHintsArgs;
std::vector<std::string> UserGuessArgs;
std::string CMakePathName; std::string CMakePathName;
RootPathMode FindRootPathMode; RootPathMode FindRootPathMode;
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 AddUserPath(std::string const& p,
std::vector<std::string>& paths);
void AddCMakePath(const std::string& variable);
void AddEnvPath(const char* variable);
void AddPathsInternal(std::vector<std::string> const& in_paths,
PathType pathType);
void AddPathInternal(std::string const& in_path, PathType pathType);
void SetMakefile(cmMakefile* makefile); void SetMakefile(cmMakefile* makefile);
bool NoDefaultPath; bool NoDefaultPath;
@ -78,8 +111,12 @@ protected:
bool NoCMakeSystemPath; bool NoCMakeSystemPath;
std::vector<std::string> SearchPathSuffixes; std::vector<std::string> SearchPathSuffixes;
std::vector<std::string> UserPaths;
std::vector<std::string> UserHints; std::map<PathGroup, std::vector<PathLabel> > PathGroupLabelMap;
std::vector<PathGroup> PathGroupOrder;
std::map<std::string, PathLabel> PathLabelStringMap;
std::map<PathLabel, cmSearchPath> LabeledPaths;
std::vector<std::string> SearchPaths; std::vector<std::string> SearchPaths;
std::set<std::string> SearchPathsEmitted; std::set<std::string> SearchPathsEmitted;

2
Source/cmFindLibraryCommand.cxx
View File

@ -88,7 +88,7 @@ void cmFindLibraryCommand::AddArchitecturePaths(const char* suffix)
{ {
std::vector<std::string> original; std::vector<std::string> original;
original.swap(this->SearchPaths); original.swap(this->SearchPaths);
for(std::vector<std::string>::iterator i = original.begin(); for(std::vector<std::string>::const_iterator i = original.begin();
i != original.end(); ++i) i != original.end(); ++i)
{ {
this->AddArchitecturePath(*i, 0, suffix); this->AddArchitecturePath(*i, 0, suffix);

298
Source/cmFindPackageCommand.cxx
View File

@ -25,6 +25,14 @@
#include <StorageDefs.h> #include <StorageDefs.h>
#endif #endif
//----------------------------------------------------------------------------
cmFindPackageCommand::PathLabel
cmFindPackageCommand::PathLabel::UserRegistry("PACKAGE_REGISTRY");
cmFindPackageCommand::PathLabel
cmFindPackageCommand::PathLabel::Builds("BUILDS");
cmFindPackageCommand::PathLabel
cmFindPackageCommand::PathLabel::SystemRegistry("SYSTEM_PACKAGE_REGISTRY");
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
cmFindPackageCommand::cmFindPackageCommand() cmFindPackageCommand::cmFindPackageCommand()
{ {
@ -51,6 +59,33 @@ cmFindPackageCommand::cmFindPackageCommand()
this->VersionFoundTweak = 0; this->VersionFoundTweak = 0;
this->VersionFoundCount = 0; this->VersionFoundCount = 0;
this->RequiredCMakeVersion = 0; this->RequiredCMakeVersion = 0;
this->AppendSearchPathGroups();
}
//----------------------------------------------------------------------------
void cmFindPackageCommand::AppendSearchPathGroups()
{
std::vector<cmFindCommon::PathLabel>* labels;
// Update the All group with new paths
labels = &this->PathGroupLabelMap[PathGroup::All];
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::UserRegistry,
cmSearchPath(this)));
this->LabeledPaths.insert(std::make_pair(PathLabel::Builds,
cmSearchPath(this)));
this->LabeledPaths.insert(std::make_pair(PathLabel::SystemRegistry,
cmSearchPath(this)));
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -248,11 +283,11 @@ bool cmFindPackageCommand
} }
else if(doing == DoingPaths) else if(doing == DoingPaths)
{ {
this->AddUserPath(args[i], this->UserPaths); this->UserGuessArgs.push_back(args[i]);
} }
else if(doing == DoingHints) else if(doing == DoingHints)
{ {
this->AddUserPath(args[i], this->UserHints); this->UserHintsArgs.push_back(args[i]);
} }
else if(doing == DoingPathSuffixes) else if(doing == DoingPathSuffixes)
{ {
@ -1111,86 +1146,97 @@ void cmFindPackageCommand::AppendSuccessInformation()
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindPackageCommand::ComputePrefixes() void cmFindPackageCommand::ComputePrefixes()
{ {
this->AddPrefixesCMakeVariable(); if(!this->NoDefaultPath)
this->AddPrefixesCMakeEnvironment(); {
this->AddPrefixesUserHints(); if(!this->NoCMakePath)
this->AddPrefixesSystemEnvironment(); {
this->AddPrefixesUserRegistry(); this->FillPrefixesCMakeVariable();
this->AddPrefixesBuilds(); }
this->AddPrefixesCMakeSystemVariable(); if(!this->NoCMakeEnvironmentPath)
this->AddPrefixesSystemRegistry(); {
this->AddPrefixesUserGuess(); this->FillPrefixesCMakeEnvironment();
}
if(!this->NoSystemEnvironmentPath)
{
this->FillPrefixesSystemEnvironment();
}
if(!this->NoUserRegistry)
{
this->FillPrefixesUserRegistry();
}
if(!this->NoBuilds)
{
this->FillPrefixesBuilds();
}
if(!this->NoCMakeSystemPath)
{
this->FillPrefixesCMakeSystemVariable();
}
if(!this->NoSystemRegistry)
{
this->FillPrefixesSystemRegistry();
}
}
this->FillPrefixesUserHints();
this->FillPrefixesUserGuess();
this->ComputeFinalPaths(); this->ComputeFinalPaths();
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesCMakeEnvironment() void cmFindPackageCommand::FillPrefixesCMakeEnvironment()
{ {
if(!this->NoCMakeEnvironmentPath && !this->NoDefaultPath) cmSearchPath &paths = this->LabeledPaths[PathLabel::CMakeEnvironment];
// Check the environment variable with the same name as the cache
// entry.
paths.AddEnvPath(this->Variable);
// And now the general CMake environment variables
paths.AddEnvPath("CMAKE_PREFIX_PATH");
paths.AddEnvPath("CMAKE_FRAMEWORK_PATH");
paths.AddEnvPath("CMAKE_APPBUNDLE_PATH");
}
//----------------------------------------------------------------------------
void cmFindPackageCommand::FillPrefixesCMakeVariable()
{
cmSearchPath &paths = this->LabeledPaths[PathLabel::CMake];
paths.AddCMakePath("CMAKE_PREFIX_PATH");
paths.AddCMakePath("CMAKE_FRAMEWORK_PATH");
paths.AddCMakePath("CMAKE_APPBUNDLE_PATH");
}
//----------------------------------------------------------------------------
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::vector<std::string>::iterator i = tmp.begin();
i != tmp.end(); ++i)
{ {
// Check the environment variable with the same name as the cache // If the path is a PREFIX/bin case then add its parent instead.
// entry. if((cmHasLiteralSuffix(*i, "/bin")) ||
std::string env; (cmHasLiteralSuffix(*i, "/sbin")))
if(cmSystemTools::GetEnv(this->Variable.c_str(), env) && env.length() > 0)
{ {
cmSystemTools::ConvertToUnixSlashes(env); paths.AddPath(cmSystemTools::GetFilenamePath(*i));
this->AddPathInternal(env, EnvPath);
} }
else
this->AddEnvPath("CMAKE_PREFIX_PATH");
this->AddEnvPath("CMAKE_FRAMEWORK_PATH");
this->AddEnvPath("CMAKE_APPBUNDLE_PATH");
}
}
//----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesCMakeVariable()
{
if(!this->NoCMakePath && !this->NoDefaultPath)
{
this->AddCMakePath("CMAKE_PREFIX_PATH");
this->AddCMakePath("CMAKE_FRAMEWORK_PATH");
this->AddCMakePath("CMAKE_APPBUNDLE_PATH");
}
}
//----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesSystemEnvironment()
{
if(!this->NoSystemEnvironmentPath && !this->NoDefaultPath)
{
// 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::vector<std::string>::iterator i = tmp.begin();
i != tmp.end(); ++i)
{ {
std::string const& d = *i; paths.AddPath(*i);
// If the path is a PREFIX/bin case then add its parent instead.
if((cmHasLiteralSuffix(d, "/bin")) ||
(cmHasLiteralSuffix(d, "/sbin")))
{
this->AddPathInternal(cmSystemTools::GetFilenamePath(d), EnvPath);
}
else
{
this->AddPathInternal(d, EnvPath);
}
} }
} }
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesUserRegistry() void cmFindPackageCommand::FillPrefixesUserRegistry()
{ {
if(this->NoUserRegistry || this->NoDefaultPath)
{
return;
}
#if defined(_WIN32) && !defined(__CYGWIN__) #if defined(_WIN32) && !defined(__CYGWIN__)
this->LoadPackageRegistryWinUser(); this->LoadPackageRegistryWinUser();
#elif defined(__HAIKU__) #elif defined(__HAIKU__)
@ -1201,7 +1247,8 @@ void cmFindPackageCommand::AddPrefixesUserRegistry()
std::string fname = dir; std::string fname = dir;
fname += "/cmake/packages/"; fname += "/cmake/packages/";
fname += Name; fname += Name;
this->LoadPackageRegistryDir(fname); this->LoadPackageRegistryDir(fname,
this->LabeledPaths[PathLabel::UserRegistry]);
} }
#else #else
if(const char* home = cmSystemTools::GetEnv("HOME")) if(const char* home = cmSystemTools::GetEnv("HOME"))
@ -1209,13 +1256,14 @@ void cmFindPackageCommand::AddPrefixesUserRegistry()
std::string dir = home; std::string dir = home;
dir += "/.cmake/packages/"; dir += "/.cmake/packages/";
dir += this->Name; dir += this->Name;
this->LoadPackageRegistryDir(dir); this->LoadPackageRegistryDir(dir,
this->LabeledPaths[PathLabel::UserRegistry]);
} }
#endif #endif
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesSystemRegistry() void cmFindPackageCommand::FillPrefixesSystemRegistry()
{ {
if(this->NoSystemRegistry || this->NoDefaultPath) if(this->NoSystemRegistry || this->NoDefaultPath)
{ {
@ -1241,29 +1289,32 @@ void cmFindPackageCommand::AddPrefixesSystemRegistry()
void cmFindPackageCommand::LoadPackageRegistryWinUser() void cmFindPackageCommand::LoadPackageRegistryWinUser()
{ {
// HKEY_CURRENT_USER\\Software shares 32-bit and 64-bit views. // HKEY_CURRENT_USER\\Software shares 32-bit and 64-bit views.
this->LoadPackageRegistryWin(true, 0); this->LoadPackageRegistryWin(true, 0,
this->LabeledPaths[PathLabel::UserRegistry]);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindPackageCommand::LoadPackageRegistryWinSystem() void cmFindPackageCommand::LoadPackageRegistryWinSystem()
{ {
cmSearchPath &paths = this->LabeledPaths[PathLabel::SystemRegistry];
// HKEY_LOCAL_MACHINE\\SOFTWARE has separate 32-bit and 64-bit views. // HKEY_LOCAL_MACHINE\\SOFTWARE has separate 32-bit and 64-bit views.
// Prefer the target platform view first. // Prefer the target platform view first.
if(this->Makefile->PlatformIs64Bit()) if(this->Makefile->PlatformIs64Bit())
{ {
this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY); this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY, paths);
this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY); this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY, paths);
} }
else else
{ {
this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY); this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY, paths);
this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY); this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY, paths);
} }
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindPackageCommand::LoadPackageRegistryWin(bool user, void cmFindPackageCommand::LoadPackageRegistryWin(bool user, unsigned int view,
unsigned int view) cmSearchPath& outPaths)
{ {
std::wstring key = L"Software\\Kitware\\CMake\\Packages\\"; std::wstring key = L"Software\\Kitware\\CMake\\Packages\\";
key += cmsys::Encoding::ToWide(this->Name); key += cmsys::Encoding::ToWide(this->Name);
@ -1289,8 +1340,8 @@ void cmFindPackageCommand::LoadPackageRegistryWin(bool user,
if(valueType == REG_SZ) if(valueType == REG_SZ)
{ {
data[dataSize] = 0; data[dataSize] = 0;
cmsys_ios::stringstream ss(cmsys::Encoding::ToNarrow(&data[0])); if(!this->CheckPackageRegistryEntry(
if(!this->CheckPackageRegistryEntry(ss)) cmsys::Encoding::ToNarrow(&data[0]), outPaths))
{ {
// The entry is invalid. // The entry is invalid.
bad.insert(name); bad.insert(name);
@ -1332,7 +1383,8 @@ public:
}; };
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir) void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir,
cmSearchPath& outPaths)
{ {
cmsys::Directory files; cmsys::Directory files;
if(!files.Load(dir)) if(!files.Load(dir))
@ -1354,7 +1406,9 @@ void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir)
// Load the file. // Load the file.
cmsys::ifstream fin(fname.c_str(), std::ios::in | cmsys_ios_binary); cmsys::ifstream fin(fname.c_str(), std::ios::in | cmsys_ios_binary);
if(fin && this->CheckPackageRegistryEntry(fin)) std::string fentry;
if(fin && cmSystemTools::GetLineFromStream(fin, fentry) &&
this->CheckPackageRegistryEntry(fentry, outPaths))
{ {
// The file references an existing package, so release it. // The file references an existing package, so release it.
holdFile.Release(); holdFile.Release();
@ -1367,12 +1421,11 @@ void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir)
#endif #endif
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool cmFindPackageCommand::CheckPackageRegistryEntry(std::istream& is) bool cmFindPackageCommand::CheckPackageRegistryEntry(const std::string& fname,
cmSearchPath& outPaths)
{ {
// Parse the content of one package registry entry. // Parse the content of one package registry entry.
std::string fname; if(cmSystemTools::FileIsFullPath(fname.c_str()))
if(cmSystemTools::GetLineFromStream(is, fname) &&
cmSystemTools::FileIsFullPath(fname.c_str()))
{ {
// The first line in the stream is the full path to a file or // The first line in the stream is the full path to a file or
// directory containing the package. // directory containing the package.
@ -1381,9 +1434,12 @@ bool cmFindPackageCommand::CheckPackageRegistryEntry(std::istream& is)
// The path exists. Look for the package here. // The path exists. Look for the package here.
if(!cmSystemTools::FileIsDirectory(fname)) if(!cmSystemTools::FileIsDirectory(fname))
{ {
fname = cmSystemTools::GetFilenamePath(fname); outPaths.AddPath(cmSystemTools::GetFilenamePath(fname));
}
else
{
outPaths.AddPath(fname);
} }
this->AddPathInternal(fname, FullPath);
return true; return true;
} }
else else
@ -1404,52 +1460,60 @@ bool cmFindPackageCommand::CheckPackageRegistryEntry(std::istream& is)
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesBuilds() void cmFindPackageCommand::FillPrefixesBuilds()
{ {
if(!this->NoBuilds && !this->NoDefaultPath) cmSearchPath &paths = this->LabeledPaths[PathLabel::Builds];
// It is likely that CMake will have recently built the project.
for(int i=0; i <= 10; ++i)
{ {
// It is likely that CMake will have recently built the project. cmOStringStream r;
for(int i=0; i <= 10; ++i) r <<
"[HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\"
"Settings\\StartPath;WhereBuild" << i << "]";
std::string f = r.str();
cmSystemTools::ExpandRegistryValues(f);
cmSystemTools::ConvertToUnixSlashes(f);
if(cmSystemTools::FileIsFullPath(f.c_str()) &&
cmSystemTools::FileIsDirectory(f.c_str()))
{ {
cmOStringStream r; paths.AddPath(f);
r <<
"[HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\"
"Settings\\StartPath;WhereBuild" << i << "]";
std::string f = r.str();
cmSystemTools::ExpandRegistryValues(f);
cmSystemTools::ConvertToUnixSlashes(f);
if(cmSystemTools::FileIsFullPath(f.c_str()) &&
cmSystemTools::FileIsDirectory(f))
{
this->AddPathInternal(f, FullPath);
}
} }
} }
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesCMakeSystemVariable() void cmFindPackageCommand::FillPrefixesCMakeSystemVariable()
{ {
if(!this->NoCMakeSystemPath && !this->NoDefaultPath) cmSearchPath &paths = this->LabeledPaths[PathLabel::CMakeSystem];
paths.AddCMakePath("CMAKE_SYSTEM_PREFIX_PATH");
paths.AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
paths.AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
}
//----------------------------------------------------------------------------
void cmFindPackageCommand::FillPrefixesUserGuess()
{
cmSearchPath &paths = this->LabeledPaths[PathLabel::Guess];
for(std::vector<std::string>::const_iterator p = this->UserGuessArgs.begin();
p != this->UserGuessArgs.end(); ++p)
{ {
this->AddCMakePath("CMAKE_SYSTEM_PREFIX_PATH"); paths.AddUserPath(*p);
this->AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
this->AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
} }
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmFindPackageCommand::AddPrefixesUserGuess() void cmFindPackageCommand::FillPrefixesUserHints()
{ {
// Add guesses specified by the caller. cmSearchPath &paths = this->LabeledPaths[PathLabel::Hints];
this->AddPathsInternal(this->UserPaths, CMakePath);
}
//---------------------------------------------------------------------------- for(std::vector<std::string>::const_iterator p = this->UserHintsArgs.begin();
void cmFindPackageCommand::AddPrefixesUserHints() p != this->UserHintsArgs.end(); ++p)
{ {
// Add hints specified by the caller. paths.AddUserPath(*p);
this->AddPathsInternal(this->UserHints, CMakePath); }
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------

41
Source/cmFindPackageCommand.h
View File

@ -53,6 +53,21 @@ public:
cmTypeMacro(cmFindPackageCommand, cmFindCommon); cmTypeMacro(cmFindPackageCommand, cmFindCommon);
private: private:
class PathLabel : public cmFindCommon::PathLabel
{
protected:
PathLabel();
public:
PathLabel(const std::string& label) : cmFindCommon::PathLabel(label) { }
static PathLabel UserRegistry;
static PathLabel Builds;
static PathLabel SystemRegistry;
};
// Add additional search path labels and groups not present in the
// parent class
void AppendSearchPathGroups();
void AppendSuccessInformation(); void AppendSuccessInformation();
void AppendToFoundProperty(bool found); void AppendToFoundProperty(bool found);
void SetModuleVariables(const std::string& components); void SetModuleVariables(const std::string& components);
@ -69,20 +84,22 @@ private:
void StoreVersionFound(); void StoreVersionFound();
void ComputePrefixes(); void ComputePrefixes();
void AddPrefixesCMakeEnvironment(); void FillPrefixesCMakeEnvironment();
void AddPrefixesCMakeVariable(); void FillPrefixesCMakeVariable();
void AddPrefixesSystemEnvironment(); void FillPrefixesSystemEnvironment();
void AddPrefixesUserRegistry(); void FillPrefixesUserRegistry();
void AddPrefixesSystemRegistry(); void FillPrefixesSystemRegistry();
void AddPrefixesBuilds(); void FillPrefixesBuilds();
void AddPrefixesCMakeSystemVariable(); void FillPrefixesCMakeSystemVariable();
void AddPrefixesUserGuess(); void FillPrefixesUserGuess();
void AddPrefixesUserHints(); void FillPrefixesUserHints();
void LoadPackageRegistryDir(std::string const& dir); void LoadPackageRegistryDir(std::string const& dir, cmSearchPath& outPaths);
void LoadPackageRegistryWinUser(); void LoadPackageRegistryWinUser();
void LoadPackageRegistryWinSystem(); void LoadPackageRegistryWinSystem();
void LoadPackageRegistryWin(bool user, unsigned int view); void LoadPackageRegistryWin(bool user, unsigned int view,
bool CheckPackageRegistryEntry(std::istream& is); cmSearchPath& outPaths);
bool CheckPackageRegistryEntry(const std::string& fname,
cmSearchPath& outPaths);
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);

41
Source/cmPathLabel.cxx Normal file
View File

@ -0,0 +1,41 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "cmPathLabel.h"
//----------------------------------------------------------------------------
cmPathLabel::cmPathLabel(const std::string& label)
: Label(label), Hash(0)
{
// Use a Jenkins one-at-a-time hash with under/over-flow protection
for(size_t i = 0; i < this->Label.size(); ++i)
{
this->Hash += this->Label[i];
this->Hash += ((this->Hash & 0x003FFFFF) << 10);
this->Hash ^= ((this->Hash & 0xFFFFFFC0) >> 6);
}
this->Hash += ((this->Hash & 0x1FFFFFFF) << 3);
this->Hash ^= ((this->Hash & 0xFFFFF800) >> 11);
this->Hash += ((this->Hash & 0x0001FFFF) << 15);
}
//----------------------------------------------------------------------------
bool cmPathLabel::operator < (const cmPathLabel& l) const
{
return this->Hash < l.Hash;
}
//----------------------------------------------------------------------------
bool cmPathLabel::operator == (const cmPathLabel& l) const
{
return this->Hash == l.Hash;
}

44
Source/cmPathLabel.h Normal file
View File

@ -0,0 +1,44 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#ifndef cmPathLabel_h
#define cmPathLabel_h
#include "cmStandardIncludes.h"
/** \class cmPathLabel
* \brief Helper class for text based labels
*
* cmPathLabel is extended in different classes to act as an inheritable
* enum. Comparisons are done on a precomputed Jenkins hash of the string
* label for indexing and searchig.
*/
class cmPathLabel
{
public:
cmPathLabel(const std::string& label);
// The comparison operators are only for quick sorting and searching and
// in no way imply any lexicographical order of the label
bool operator < (const cmPathLabel& l) const;
bool operator == (const cmPathLabel& l) const;
const std::string& GetLabel() const { return this->Label; }
const unsigned int& GetHash() const { return this->Hash; }
protected:
cmPathLabel();
std::string Label;
unsigned int Hash;
};
#endif

251
Source/cmSearchPath.cxx Normal file
View File

@ -0,0 +1,251 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "cmSearchPath.h"
#include "cmFindCommon.h"
//----------------------------------------------------------------------------
cmSearchPath::cmSearchPath(cmFindCommon* findCmd)
: FC(findCmd)
{
}
//----------------------------------------------------------------------------
cmSearchPath::~cmSearchPath()
{
}
//----------------------------------------------------------------------------
void cmSearchPath::ExtractWithout(const std::set<std::string>& ignore,
std::vector<std::string>& outPaths,
bool clear) const
{
if(clear)
{
outPaths.clear();
}
for(std::vector<std::string>::const_iterator p = this->Paths.begin();
p != this->Paths.end(); ++p)
{
if(ignore.count(*p) == 0)
{
outPaths.push_back(*p);
}
}
}
//----------------------------------------------------------------------------
void cmSearchPath::AddPath(const std::string& path)
{
this->AddPathInternal(path);
}
//----------------------------------------------------------------------------
void cmSearchPath::AddUserPath(const std::string& path)
{
assert(this->FC != NULL);
std::vector<std::string> outPaths;
// 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(this->FC->Makefile->PlatformIs64Bit())
{
view = cmSystemTools::KeyWOW64_64;
other_view = cmSystemTools::KeyWOW64_32;
}
// Expand using the view of the target application.
std::string expanded = path;
cmSystemTools::ExpandRegistryValues(expanded, view);
cmSystemTools::GlobDirs(expanded, outPaths);
// Executables can be either 32-bit or 64-bit, so expand using the
// alternative view.
if(expanded != path && this->FC->CMakePathName == "PROGRAM")
{
expanded = path;
cmSystemTools::ExpandRegistryValues(expanded, other_view);
cmSystemTools::GlobDirs(expanded, outPaths);
}
// Process them all from the current directory
for(std::vector<std::string>::const_iterator p = outPaths.begin();
p != outPaths.end(); ++p)
{
this->AddPathInternal(*p, this->FC->Makefile->GetCurrentDirectory());
}
}
//----------------------------------------------------------------------------
void cmSearchPath::AddCMakePath(const std::string& variable)
{
assert(this->FC != NULL);
// Get a path from a CMake variable.
if(const char* value = this->FC->Makefile->GetDefinition(variable))
{
std::vector<std::string> expanded;
cmSystemTools::ExpandListArgument(value, expanded);
for(std::vector<std::string>::const_iterator p = expanded.begin();
p!= expanded.end(); ++p)
{
this->AddPathInternal(*p, this->FC->Makefile->GetCurrentDirectory());
}
}
}
//----------------------------------------------------------------------------
void cmSearchPath::AddEnvPath(const std::string& variable)
{
std::vector<std::string> expanded;
cmSystemTools::GetPath(expanded, variable.c_str());
for(std::vector<std::string>::const_iterator p = expanded.begin();
p!= expanded.end(); ++p)
{
this->AddPathInternal(*p);
}
}
//----------------------------------------------------------------------------
void cmSearchPath::AddCMakePrefixPath(const std::string& variable)
{
assert(this->FC != NULL);
// Get a path from a CMake variable.
if(const char* value = this->FC->Makefile->GetDefinition(variable))
{
std::vector<std::string> expanded;
cmSystemTools::ExpandListArgument(value, expanded);
this->AddPrefixPaths(expanded, this->FC->Makefile->GetCurrentDirectory());
}
}
//----------------------------------------------------------------------------
void cmSearchPath::AddEnvPrefixPath(const std::string& variable)
{
std::vector<std::string> expanded;
cmSystemTools::GetPath(expanded, variable.c_str());
this->AddPrefixPaths(expanded);
}
//----------------------------------------------------------------------------
void cmSearchPath::AddSuffixes(const std::vector<std::string>& suffixes)
{
std::vector<std::string> inPaths;
inPaths.swap(this->Paths);
this->Paths.reserve(inPaths.size()*(suffixes.size()+1));
for(std::vector<std::string>::iterator ip = inPaths.begin();
ip != inPaths.end(); ++ip)
{
cmSystemTools::ConvertToUnixSlashes(*ip);
// if *i is only / then do not add a //
// this will get incorrectly considered a network
// path on windows and cause huge delays.
std::string p = *ip;
if(!p.empty() && *p.rbegin() != '/')
{
p += "/";
}
// Combine with all the suffixes
for(std::vector<std::string>::const_iterator s = suffixes.begin();
s != suffixes.end(); ++s)
{
this->Paths.push_back(p+*s);
}
// And now the original w/o any suffix
this->Paths.push_back(*ip);
}
}
//----------------------------------------------------------------------------
void cmSearchPath::AddPrefixPaths(const std::vector<std::string>& paths,
const char *base)
{
assert(this->FC != NULL);
// default for programs
std::string subdir = "bin";
if (this->FC->CMakePathName == "INCLUDE")
{
subdir = "include";
}
else if (this->FC->CMakePathName == "LIBRARY")
{
subdir = "lib";
}
else if (this->FC->CMakePathName == "FRAMEWORK")
{
subdir = ""; // ? what to do for frameworks ?
}
for(std::vector<std::string>::const_iterator p = paths.begin();
p != paths.end(); ++p)
{
std::string dir = *p;
if(!subdir.empty() && !dir.empty() && *dir.rbegin() != '/')
{
dir += "/";
}
if(subdir == "include" || subdir == "lib")
{
const char* arch =
this->FC->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE");
if(arch && *arch)
{
this->AddPathInternal(dir+subdir+"/"+arch, base);
}
}
std::string add = dir + subdir;
if(add != "/")
{
this->AddPathInternal(add, base);
}
if (subdir == "bin")
{
this->AddPathInternal(dir+"sbin", base);
}
if(!subdir.empty() && *p != "/")
{
this->AddPathInternal(*p, base);
}
}
}
//----------------------------------------------------------------------------
void cmSearchPath::AddPathInternal(const std::string& path, const char *base)
{
assert(this->FC != NULL);
std::string collapsed = cmSystemTools::CollapseFullPath(path, base);
if(collapsed.empty())
{
return;
}
// Insert the path if has not already been emitted.
if(this->FC->SearchPathsEmitted.insert(collapsed).second)
{
this->Paths.push_back(collapsed);
}
}

57
Source/cmSearchPath.h Normal file
View File

@ -0,0 +1,57 @@
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#ifndef cmSearchPath_h
#define cmSearchPath_h
#include "cmStandardIncludes.h"
class cmFindCommon;
/** \class cmSearchPath
* \brief Container for encapsulating a set of search paths
*
* cmSearchPath is a container that encapsulates search path construction and
* management
*/
class cmSearchPath
{
public:
// cmSearchPath must be initialized from a valid pointer. The only reason
// for teh default is to allow it to be easily used in stl containers.
// Attempting to initialize with a NULL value will fail an assertion
cmSearchPath(cmFindCommon* findCmd = 0);
~cmSearchPath();
const std::vector<std::string>& GetPaths() const { return this->Paths; }
void ExtractWithout(const std::set<std::string>& ignore,
std::vector<std::string>& outPaths,
bool clear = false) const;
void AddPath(const std::string& path);
void AddUserPath(const std::string& path);
void AddCMakePath(const std::string& variable);
void AddEnvPath(const std::string& variable);
void AddCMakePrefixPath(const std::string& variable);
void AddEnvPrefixPath(const std::string& variable);
void AddSuffixes(const std::vector<std::string>& suffixes);
protected:
void AddPrefixPaths(const std::vector<std::string>& paths,
const char *base = 0);
void AddPathInternal(const std::string& path, const char *base = 0);
cmFindCommon *FC;
std::vector<std::string> Paths;
};
#endif