[Cmake-commits] CMake branch, next, updated. v3.1.0-rc1-181-gdba2698
Chuck Atkins
chuck.atkins at kitware.com
Tue Oct 28 19:09:43 EDT 2014
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "CMake".
The branch, next has been updated
via dba26980d614a72c9bb66a3cacc5a1ab4aceaf0d (commit)
via 98e2144e93b37a4175b0e9bf7489044fb0b8ffdd (commit)
via 4061f25c52e8c7593808836f2f76031943e43884 (commit)
from 51177678a0dea12229af368bfc6bf0f75b6090fc (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=dba26980d614a72c9bb66a3cacc5a1ab4aceaf0d
commit dba26980d614a72c9bb66a3cacc5a1ab4aceaf0d
Merge: 5117767 98e2144
Author: Chuck Atkins <chuck.atkins at kitware.com>
AuthorDate: Tue Oct 28 19:09:42 2014 -0400
Commit: CMake Topic Stage <kwrobot at kitware.com>
CommitDate: Tue Oct 28 19:09:42 2014 -0400
Merge topic 'refactor-search-path-construction' into next
98e2144e Add workaround for VS6.
4061f25c Use containers of labeled search paths instead of individual members
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=98e2144e93b37a4175b0e9bf7489044fb0b8ffdd
commit 98e2144e93b37a4175b0e9bf7489044fb0b8ffdd
Author: Chuck Atkins <chuck.atkins at kitware.com>
AuthorDate: Tue Oct 28 16:51:38 2014 -0400
Commit: Chuck Atkins <chuck.atkins at kitware.com>
CommitDate: Tue Oct 28 19:09:09 2014 -0400
Add workaround for VS6.
VS6 fails to lookup protected class definitions in a parent class. The
workaround is to make them public instead only when compiling for VS6.
diff --git a/Source/cmFindCommon.h b/Source/cmFindCommon.h
index 3fefc8d..e65b2fc 100644
--- a/Source/cmFindCommon.h
+++ b/Source/cmFindCommon.h
@@ -33,6 +33,10 @@ public:
protected:
friend class cmSearchPath;
+/* VS6 is broken and can't pass protected class definitions to child classes */
+#if defined(_MSC_VER) && (_MSC_VER < 1300)
+public:
+#endif
/** Used to define groups of path labels */
class PathGroup : public cmPathLabel
{
@@ -57,6 +61,9 @@ protected:
static PathLabel CMakeSystem;
static PathLabel Guess;
};
+#if defined(_MSC_VER) && (_MSC_VER < 1300)
+protected:
+#endif
enum RootPathMode { RootPathModeNever,
RootPathModeOnly,
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=4061f25c52e8c7593808836f2f76031943e43884
commit 4061f25c52e8c7593808836f2f76031943e43884
Author: Chuck Atkins <chuck.atkins at kitware.com>
AuthorDate: Fri Oct 17 13:07:26 2014 -0400
Commit: Chuck Atkins <chuck.atkins at kitware.com>
CommitDate: Tue Oct 28 19:08:59 2014 -0400
Use containers of labeled search paths instead of individual members
Manage classes of search paths in labeled containers. This removes the
need to have a seperate member variable for each type of search path, but
also allows path types to be grouped togethor in various different ways
and manipulated as subsets of the full set of search paths.
diff --git a/Source/cmBootstrapCommands1.cxx b/Source/cmBootstrapCommands1.cxx
index 29d3671..5502609 100644
--- a/Source/cmBootstrapCommands1.cxx
+++ b/Source/cmBootstrapCommands1.cxx
@@ -43,7 +43,6 @@
#include "cmExecuteProcessCommand.cxx"
#include "cmExternalMakefileProjectGenerator.cxx"
#include "cmFindBase.cxx"
-#include "cmSearchPath.cxx"
#include "cmFindCommon.cxx"
#include "cmFileCommand.cxx"
#include "cmFindFileCommand.cxx"
@@ -53,6 +52,8 @@
#include "cmFindProgramCommand.cxx"
#include "cmForEachCommand.cxx"
#include "cmFunctionCommand.cxx"
+#include "cmPathLabel.cxx"
+#include "cmSearchPath.cxx"
void GetBootstrapCommands1(std::list<cmCommand*>& commands)
{
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx
index 52f04ad..beb6dde 100644
--- a/Source/cmFindBase.cxx
+++ b/Source/cmFindBase.cxx
@@ -225,102 +225,112 @@ void cmFindBase::ExpandPaths()
//----------------------------------------------------------------------------
void cmFindBase::FillCMakeEnvironmentPath()
{
+ cmSearchPath &paths = this->LabeledPaths[PathLabel::CMakeEnvironment];
+
// Add CMAKE_*_PATH environment variables
std::string var = "CMAKE_";
var += this->CMakePathName;
var += "_PATH";
- this->CMakeEnvironmentPaths.AddEnvPrefixPath("CMAKE_PREFIX_PATH");
- this->CMakeEnvironmentPaths.AddEnvPath(var);
+ paths.AddEnvPrefixPath("CMAKE_PREFIX_PATH");
+ paths.AddEnvPath(var);
if(this->CMakePathName == "PROGRAM")
{
- this->CMakeEnvironmentPaths.AddEnvPath("CMAKE_APPBUNDLE_PATH");
+ paths.AddEnvPath("CMAKE_APPBUNDLE_PATH");
}
else
{
- this->CMakeEnvironmentPaths.AddEnvPath("CMAKE_FRAMEWORK_PATH");
+ paths.AddEnvPath("CMAKE_FRAMEWORK_PATH");
}
- this->CMakeEnvironmentPaths.AddSuffixes(this->SearchPathSuffixes);
+ paths.AddSuffixes(this->SearchPathSuffixes);
}
//----------------------------------------------------------------------------
void cmFindBase::FillCMakeVariablePath()
{
+ cmSearchPath &paths = this->LabeledPaths[PathLabel::CMake];
+
// 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->CMakeVariablePaths.AddCMakePrefixPath("CMAKE_PREFIX_PATH");
- this->CMakeVariablePaths.AddCMakePath(var);
+ paths.AddCMakePrefixPath("CMAKE_PREFIX_PATH");
+ paths.AddCMakePath(var);
if(this->CMakePathName == "PROGRAM")
{
- this->CMakeVariablePaths.AddCMakePath("CMAKE_APPBUNDLE_PATH");
+ paths.AddCMakePath("CMAKE_APPBUNDLE_PATH");
}
else
{
- this->CMakeVariablePaths.AddCMakePath("CMAKE_FRAMEWORK_PATH");
+ paths.AddCMakePath("CMAKE_FRAMEWORK_PATH");
}
- this->CMakeVariablePaths.AddSuffixes(this->SearchPathSuffixes);
+ paths.AddSuffixes(this->SearchPathSuffixes);
}
//----------------------------------------------------------------------------
void cmFindBase::FillSystemEnvironmentPath()
{
+ cmSearchPath &paths = this->LabeledPaths[PathLabel::SystemEnvironment];
+
// Add LIB or INCLUDE
if(!this->EnvironmentPath.empty())
{
- this->SystemEnvironmentPaths.AddEnvPath(this->EnvironmentPath);
+ paths.AddEnvPath(this->EnvironmentPath);
}
// Add PATH
- this->SystemEnvironmentPaths.AddEnvPath("PATH");
- this->SystemEnvironmentPaths.AddSuffixes(this->SearchPathSuffixes);
+ paths.AddEnvPath("PATH");
+ paths.AddSuffixes(this->SearchPathSuffixes);
}
//----------------------------------------------------------------------------
void cmFindBase::FillCMakeSystemVariablePath()
{
+ cmSearchPath &paths = this->LabeledPaths[PathLabel::CMakeSystem];
+
std::string var = "CMAKE_SYSTEM_";
var += this->CMakePathName;
var += "_PATH";
- this->CMakeSystemVariablePaths.AddCMakePrefixPath(
- "CMAKE_SYSTEM_PREFIX_PATH");
- this->CMakeSystemVariablePaths.AddCMakePath(var);
+ paths.AddCMakePrefixPath("CMAKE_SYSTEM_PREFIX_PATH");
+ paths.AddCMakePath(var);
if(this->CMakePathName == "PROGRAM")
{
- this->CMakeSystemVariablePaths.AddCMakePath(
- "CMAKE_SYSTEM_APPBUNDLE_PATH");
+ paths.AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
}
else
{
- this->CMakeSystemVariablePaths.AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
+ paths.AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
}
- this->CMakeSystemVariablePaths.AddSuffixes(this->SearchPathSuffixes);
+ paths.AddSuffixes(this->SearchPathSuffixes);
}
//----------------------------------------------------------------------------
void cmFindBase::FillUserHintsPath()
{
+ cmSearchPath &paths = this->LabeledPaths[PathLabel::Hints];
+
for(std::vector<std::string>::const_iterator p = this->UserHintsArgs.begin();
p != this->UserHintsArgs.end(); ++p)
{
- this->UserHintsPaths.AddUserPath(*p);
+ paths.AddUserPath(*p);
}
- this->UserHintsPaths.AddSuffixes(this->SearchPathSuffixes);
+ 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)
{
- this->UserGuessPaths.AddUserPath(*p);
+ paths.AddUserPath(*p);
}
- this->UserGuessPaths.AddSuffixes(this->SearchPathSuffixes);
+ paths.AddSuffixes(this->SearchPathSuffixes);
}
//----------------------------------------------------------------------------
diff --git a/Source/cmFindCommon.cxx b/Source/cmFindCommon.cxx
index 87e98c1..913985f 100644
--- a/Source/cmFindCommon.cxx
+++ b/Source/cmFindCommon.cxx
@@ -14,16 +14,18 @@
#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()
-: CMakeVariablePaths(this, "CMAKE"),
- CMakeEnvironmentPaths(this, "CMAKE_ENVIRONMENT"),
- UserHintsPaths(this, "HINTS"),
- SystemEnvironmentPaths(this, "SYSTEM_ENVIRONMENT"),
- UserRegistryPaths(this, "USER_REGISTRY"),
- BuildPaths(this, "BUILD"),
- CMakeSystemVariablePaths(this, "CMAKE_SYSTEM_VARIABLE"),
- SystemRegistryPaths(this, "SYSTEM_REGISTRY"),
- UserGuessPaths(this, "GUESS")
{
this->FindRootPathMode = RootPathModeBoth;
this->NoDefaultPath = false;
@@ -45,6 +47,8 @@ cmFindCommon::cmFindCommon()
this->SearchFrameworkLast = false;
this->SearchAppBundleOnly = false;
this->SearchAppBundleLast = false;
+
+ this->InitializeSearchPathGroups();
}
//----------------------------------------------------------------------------
@@ -53,6 +57,40 @@ 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()
{
// Check the policy variable for this find command type.
@@ -140,12 +178,12 @@ void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
fprintf(stderr, "[%s]\n", i->c_str());
}
#endif
-
// Short-circuit if there is nothing to do.
if(this->FindRootPathMode == RootPathModeNever)
{
return;
}
+
const char* sysroot =
this->Makefile->GetDefinition("CMAKE_SYSROOT");
const char* rootPath =
@@ -293,7 +331,7 @@ bool cmFindCommon::CheckCommonArgument(std::string const& arg)
{
this->NoCMakeSystemPath = true;
}
- else if(arg == "NO_CMAKE_FIND_ROOT_PATH")
+ else if(arg == "NO_CMAKE_FIND_ROOT_PATH")
{
this->FindRootPathMode = RootPathModeNever;
}
@@ -361,15 +399,13 @@ void cmFindCommon::ComputeFinalPaths()
this->GetIgnoredPaths(ignored);
// Combine the seperate path types, filtering out ignores
- this->CMakeVariablePaths.ExtractWithout(ignored, this->SearchPaths, true);
- this->CMakeEnvironmentPaths.ExtractWithout(ignored, this->SearchPaths);
- this->UserHintsPaths.ExtractWithout(ignored, this->SearchPaths);
- this->SystemEnvironmentPaths.ExtractWithout(ignored, this->SearchPaths);
- this->UserRegistryPaths.ExtractWithout(ignored, this->SearchPaths);
- this->BuildPaths.ExtractWithout(ignored, this->SearchPaths);
- this->CMakeSystemVariablePaths.ExtractWithout(ignored, this->SearchPaths);
- this->SystemRegistryPaths.ExtractWithout(ignored, this->SearchPaths);
- this->UserGuessPaths.ExtractWithout(ignored, this->SearchPaths);
+ 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.
this->RerootPaths(this->SearchPaths);
diff --git a/Source/cmFindCommon.h b/Source/cmFindCommon.h
index 8102392..3fefc8d 100644
--- a/Source/cmFindCommon.h
+++ b/Source/cmFindCommon.h
@@ -14,6 +14,7 @@
#include "cmCommand.h"
#include "cmSearchPath.h"
+#include "cmPathLabel.h"
/** \class cmFindCommon
* \brief Base class for FIND_XXX implementations.
@@ -32,10 +33,38 @@ public:
protected:
friend class cmSearchPath;
+ /** Used to define groups of path labels */
+ class PathGroup : public cmPathLabel
+ {
+ protected:
+ PathGroup();
+ public:
+ PathGroup(const std::string& label) : cmPathLabel(label) { }
+ static PathGroup All;
+ };
+
+ /* 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;
+ };
+
enum RootPathMode { RootPathModeNever,
RootPathModeOnly,
RootPathModeBoth };
+ /** Construct the various path groups and labels */
+ void InitializeSearchPathGroups();
+
/** Place a set of search paths under the search roots. */
void RerootPaths(std::vector<std::string>& paths);
@@ -75,15 +104,11 @@ protected:
bool NoCMakeSystemPath;
std::vector<std::string> SearchPathSuffixes;
- cmSearchPath CMakeVariablePaths;
- cmSearchPath CMakeEnvironmentPaths;
- cmSearchPath UserHintsPaths;
- cmSearchPath SystemEnvironmentPaths;
- cmSearchPath UserRegistryPaths;
- cmSearchPath BuildPaths;
- cmSearchPath CMakeSystemVariablePaths;
- cmSearchPath SystemRegistryPaths;
- cmSearchPath UserGuessPaths;
+
+ 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::set<std::string> SearchPathsEmitted;
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index 258678d..51f33fd 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -26,6 +26,14 @@
#endif
//----------------------------------------------------------------------------
+cmFindPackageCommand::PathLabel
+ cmFindPackageCommand::PathLabel::UserRegistry("PACKAGE_REGISTRY");
+cmFindPackageCommand::PathLabel
+ cmFindPackageCommand::PathLabel::Builds("BUILDS");
+cmFindPackageCommand::PathLabel
+ cmFindPackageCommand::PathLabel::SystemRegistry("SYSTEM_PACKAGE_REGISTRY");
+
+//----------------------------------------------------------------------------
cmFindPackageCommand::cmFindPackageCommand()
{
this->CMakePathName = "PACKAGE";
@@ -51,6 +59,33 @@ cmFindPackageCommand::cmFindPackageCommand()
this->VersionFoundTweak = 0;
this->VersionFoundCount = 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)));
}
//----------------------------------------------------------------------------
@@ -1151,27 +1186,33 @@ void cmFindPackageCommand::ComputePrefixes()
//----------------------------------------------------------------------------
void cmFindPackageCommand::FillPrefixesCMakeEnvironment()
{
+ cmSearchPath &paths = this->LabeledPaths[PathLabel::CMakeEnvironment];
+
// Check the environment variable with the same name as the cache
// entry.
- this->CMakeEnvironmentPaths.AddEnvPath(this->Variable);
+ paths.AddEnvPath(this->Variable);
// And now the general CMake environment variables
- this->CMakeEnvironmentPaths.AddEnvPath("CMAKE_PREFIX_PATH");
- this->CMakeEnvironmentPaths.AddEnvPath("CMAKE_FRAMEWORK_PATH");
- this->CMakeEnvironmentPaths.AddEnvPath("CMAKE_APPBUNDLE_PATH");
+ paths.AddEnvPath("CMAKE_PREFIX_PATH");
+ paths.AddEnvPath("CMAKE_FRAMEWORK_PATH");
+ paths.AddEnvPath("CMAKE_APPBUNDLE_PATH");
}
//----------------------------------------------------------------------------
void cmFindPackageCommand::FillPrefixesCMakeVariable()
{
- this->CMakeVariablePaths.AddCMakePath("CMAKE_PREFIX_PATH");
- this->CMakeVariablePaths.AddCMakePath("CMAKE_FRAMEWORK_PATH");
- this->CMakeVariablePaths.AddCMakePath("CMAKE_APPBUNDLE_PATH");
+ 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.
@@ -1184,12 +1225,11 @@ void cmFindPackageCommand::FillPrefixesSystemEnvironment()
if((cmHasLiteralSuffix(*i, "/bin")) ||
(cmHasLiteralSuffix(*i, "/sbin")))
{
- this->SystemEnvironmentPaths.AddPath(
- cmSystemTools::GetFilenamePath(*i));
+ paths.AddPath(cmSystemTools::GetFilenamePath(*i));
}
else
{
- this->SystemEnvironmentPaths.AddPath(*i);
+ paths.AddPath(*i);
}
}
}
@@ -1207,7 +1247,8 @@ void cmFindPackageCommand::FillPrefixesUserRegistry()
std::string fname = dir;
fname += "/cmake/packages/";
fname += Name;
- this->LoadPackageRegistryDir(fname, this->UserRegistryPaths);
+ this->LoadPackageRegistryDir(fname,
+ this->LabeledPaths[PathLabel::UserRegistry]);
}
#else
if(const char* home = cmSystemTools::GetEnv("HOME"))
@@ -1215,7 +1256,8 @@ void cmFindPackageCommand::FillPrefixesUserRegistry()
std::string dir = home;
dir += "/.cmake/packages/";
dir += this->Name;
- this->LoadPackageRegistryDir(dir, this->UserRegistryPaths);
+ this->LoadPackageRegistryDir(dir,
+ this->LabeledPaths[PathLabel::UserRegistry]);
}
#endif
}
@@ -1247,27 +1289,26 @@ void cmFindPackageCommand::FillPrefixesSystemRegistry()
void cmFindPackageCommand::LoadPackageRegistryWinUser()
{
// HKEY_CURRENT_USER\\Software shares 32-bit and 64-bit views.
- this->LoadPackageRegistryWin(true, 0, this->UserRegistryPaths);
+ this->LoadPackageRegistryWin(true, 0,
+ this->LabeledPaths[PathLabel::UserRegistry]);
}
//----------------------------------------------------------------------------
void cmFindPackageCommand::LoadPackageRegistryWinSystem()
{
+ cmSearchPath &paths = this->LabeledPaths[PathLabel::SystemRegistry];
+
// HKEY_LOCAL_MACHINE\\SOFTWARE has separate 32-bit and 64-bit views.
// Prefer the target platform view first.
if(this->Makefile->PlatformIs64Bit())
{
- this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY,
- this->SystemRegistryPaths);
- this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY,
- this->SystemRegistryPaths);
+ this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY, paths);
+ this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY, paths);
}
else
{
- this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY,
- this->SystemRegistryPaths);
- this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY,
- this->SystemRegistryPaths);
+ this->LoadPackageRegistryWin(false, KEY_WOW64_32KEY, paths);
+ this->LoadPackageRegistryWin(false, KEY_WOW64_64KEY, paths);
}
}
@@ -1421,6 +1462,8 @@ bool cmFindPackageCommand::CheckPackageRegistryEntry(const std::string& fname,
//----------------------------------------------------------------------------
void cmFindPackageCommand::FillPrefixesBuilds()
{
+ cmSearchPath &paths = this->LabeledPaths[PathLabel::Builds];
+
// It is likely that CMake will have recently built the project.
for(int i=0; i <= 10; ++i)
{
@@ -1434,7 +1477,7 @@ void cmFindPackageCommand::FillPrefixesBuilds()
if(cmSystemTools::FileIsFullPath(f.c_str()) &&
cmSystemTools::FileIsDirectory(f.c_str()))
{
- this->BuildPaths.AddPath(f);
+ paths.AddPath(f);
}
}
}
@@ -1442,28 +1485,34 @@ void cmFindPackageCommand::FillPrefixesBuilds()
//----------------------------------------------------------------------------
void cmFindPackageCommand::FillPrefixesCMakeSystemVariable()
{
- this->CMakeSystemVariablePaths.AddCMakePath("CMAKE_SYSTEM_PREFIX_PATH");
- this->CMakeSystemVariablePaths.AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
- this->CMakeSystemVariablePaths.AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
+ 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->UserGuessPaths.AddUserPath(*p);
+ paths.AddUserPath(*p);
}
}
//----------------------------------------------------------------------------
void cmFindPackageCommand::FillPrefixesUserHints()
{
+ cmSearchPath &paths = this->LabeledPaths[PathLabel::Hints];
+
for(std::vector<std::string>::const_iterator p = this->UserHintsArgs.begin();
p != this->UserHintsArgs.end(); ++p)
{
- this->UserHintsPaths.AddUserPath(*p);
+ paths.AddUserPath(*p);
}
}
diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h
index 17bc456..949dcb1 100644
--- a/Source/cmFindPackageCommand.h
+++ b/Source/cmFindPackageCommand.h
@@ -53,6 +53,21 @@ public:
cmTypeMacro(cmFindPackageCommand, cmFindCommon);
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 AppendToFoundProperty(bool found);
void SetModuleVariables(const std::string& components);
diff --git a/Source/cmPathLabel.cxx b/Source/cmPathLabel.cxx
new file mode 100644
index 0000000..f9bbb7a
--- /dev/null
+++ b/Source/cmPathLabel.cxx
@@ -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 Jenkeins 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;
+}
diff --git a/Source/cmPathLabel.h b/Source/cmPathLabel.h
new file mode 100644
index 0000000..1d4e181
--- /dev/null
+++ b/Source/cmPathLabel.h
@@ -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 differnt 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
diff --git a/Source/cmSearchPath.cxx b/Source/cmSearchPath.cxx
index 19f2c3f..1551127 100644
--- a/Source/cmSearchPath.cxx
+++ b/Source/cmSearchPath.cxx
@@ -14,11 +14,10 @@
#include "cmFindCommon.h"
//----------------------------------------------------------------------------
-cmSearchPath::cmSearchPath(cmFindCommon* findCmd,
- const std::string& groupLabel)
-: FindName(findCmd->CMakePathName), Makefile(findCmd->Makefile),
- Emitted(findCmd->SearchPathsEmitted), Label(groupLabel)
+cmSearchPath::cmSearchPath(cmFindCommon* findCmd)
+: FC(findCmd)
{
+ assert(findCmd != NULL);
}
//----------------------------------------------------------------------------
@@ -61,7 +60,7 @@ void cmSearchPath::AddUserPath(const std::string& path)
// it.
cmSystemTools::KeyWOW64 view = cmSystemTools::KeyWOW64_32;
cmSystemTools::KeyWOW64 other_view = cmSystemTools::KeyWOW64_64;
- if(this->Makefile->PlatformIs64Bit())
+ if(this->FC->Makefile->PlatformIs64Bit())
{
view = cmSystemTools::KeyWOW64_64;
other_view = cmSystemTools::KeyWOW64_32;
@@ -74,7 +73,7 @@ void cmSearchPath::AddUserPath(const std::string& path)
// Executables can be either 32-bit or 64-bit, so expand using the
// alternative view.
- if(expanded != path && this->FindName == "PROGRAM")
+ if(expanded != path && this->FC->CMakePathName == "PROGRAM")
{
expanded = path;
cmSystemTools::ExpandRegistryValues(expanded, other_view);
@@ -85,7 +84,7 @@ void cmSearchPath::AddUserPath(const std::string& path)
for(std::vector<std::string>::const_iterator p = outPaths.begin();
p != outPaths.end(); ++p)
{
- this->AddPathInternal(*p, this->Makefile->GetCurrentDirectory());
+ this->AddPathInternal(*p, this->FC->Makefile->GetCurrentDirectory());
}
}
@@ -93,7 +92,7 @@ void cmSearchPath::AddUserPath(const std::string& path)
void cmSearchPath::AddCMakePath(const std::string& variable)
{
// Get a path from a CMake variable.
- if(const char* value = this->Makefile->GetDefinition(variable))
+ if(const char* value = this->FC->Makefile->GetDefinition(variable))
{
std::vector<std::string> expanded;
cmSystemTools::ExpandListArgument(value, expanded);
@@ -101,7 +100,7 @@ void cmSearchPath::AddCMakePath(const std::string& variable)
for(std::vector<std::string>::const_iterator p = expanded.begin();
p!= expanded.end(); ++p)
{
- this->AddPathInternal(*p, this->Makefile->GetCurrentDirectory());
+ this->AddPathInternal(*p, this->FC->Makefile->GetCurrentDirectory());
}
}
}
@@ -122,12 +121,12 @@ void cmSearchPath::AddEnvPath(const std::string& variable)
void cmSearchPath::AddCMakePrefixPath(const std::string& variable)
{
// Get a path from a CMake variable.
- if(const char* value = this->Makefile->GetDefinition(variable))
+ if(const char* value = this->FC->Makefile->GetDefinition(variable))
{
std::vector<std::string> expanded;
cmSystemTools::ExpandListArgument(value, expanded);
- this->AddPrefixPaths(expanded, this->Makefile->GetCurrentDirectory());
+ this->AddPrefixPaths(expanded, this->FC->Makefile->GetCurrentDirectory());
}
}
@@ -179,15 +178,15 @@ void cmSearchPath::AddPrefixPaths(const std::vector<std::string>& paths,
// default for programs
std::string subdir = "bin";
- if (this->FindName == "INCLUDE")
+ if (this->FC->CMakePathName == "INCLUDE")
{
subdir = "include";
}
- else if (this->FindName == "LIBRARY")
+ else if (this->FC->CMakePathName == "LIBRARY")
{
subdir = "lib";
}
- else if (this->FindName == "FRAMEWORK")
+ else if (this->FC->CMakePathName == "FRAMEWORK")
{
subdir = ""; // ? what to do for frameworks ?
}
@@ -203,7 +202,7 @@ void cmSearchPath::AddPrefixPaths(const std::vector<std::string>& paths,
if(subdir == "include" || subdir == "lib")
{
const char* arch =
- this->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE");
+ this->FC->Makefile->GetDefinition("CMAKE_LIBRARY_ARCHITECTURE");
if(arch && *arch)
{
this->AddPathInternal(dir+subdir+"/"+arch, base);
@@ -236,7 +235,7 @@ void cmSearchPath::AddPathInternal(const std::string& path, const char *base)
}
// Insert the path if has not already been emitted.
- if(this->Emitted.insert(collapsed).second)
+ if(this->FC->SearchPathsEmitted.insert(collapsed).second)
{
this->Paths.push_back(collapsed);
}
diff --git a/Source/cmSearchPath.h b/Source/cmSearchPath.h
index 88ef0ff..51a6149 100644
--- a/Source/cmSearchPath.h
+++ b/Source/cmSearchPath.h
@@ -17,7 +17,7 @@
class cmFindCommon;
/** \class cmSearchPath
- * \brief Base class for FIND_XXX implementations.
+ * \brief Container for encapsulating a set of search paths
*
* cmSearchPath is a container that encapsulates search path construction and
* management
@@ -25,10 +25,12 @@ class cmFindCommon;
class cmSearchPath
{
public:
- cmSearchPath(cmFindCommon* findCmd, const std::string& groupLabel);
+ // 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::string& GetLabel() const { return this->Label; }
const std::vector<std::string>& GetPaths() const { return this->Paths; }
void ExtractWithout(const std::set<std::string>& ignore,
@@ -48,12 +50,7 @@ protected:
const char *base = 0);
void AddPathInternal(const std::string& path, const char *base = 0);
- // Members collected from the calling find command
- const std::string& FindName;
- cmMakefile* const& Makefile;
- std::set<std::string>& Emitted;
-
- std::string Label;
+ cmFindCommon *FC;
std::vector<std::string> Paths;
};
-----------------------------------------------------------------------
Summary of changes:
hooks/post-receive
--
CMake
More information about the Cmake-commits
mailing list