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

ENH: Major improvements to the FIND_PACKAGE command. See bug #3659.

Browse Source 
- Use CMAKE_PREFIX_PATH and CMAKE_SYSTEM_PREFIX_PATH among other means
    to locate package configuration files.
  - Create cmFindCommon as base for cmFindBase and cmFindPackageCommand
  - Move common functionality up to cmFindCommon
  - Improve documentation of FIND_* commands.
  - Fix FIND_* commands to not add framework/app paths in wrong place.
This commit is contained in:
Brad King 2008-01-17 09:02:31 -05:00
parent 491d5d0104
commit b424df917d
10 changed files with 1862 additions and 601 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Source/cmBootstrapCommands.cxx
View File

@ -42,6 +42,7 @@
#include "cmExecProgramCommand.cxx" #include "cmExecProgramCommand.cxx"
#include "cmExternalMakefileProjectGenerator.cxx" #include "cmExternalMakefileProjectGenerator.cxx"
#include "cmFindBase.cxx" #include "cmFindBase.cxx"
#include "cmFindCommon.cxx"
#include "cmFileCommand.cxx" #include "cmFileCommand.cxx"
#include "cmFindFileCommand.cxx" #include "cmFindFileCommand.cxx"
#include "cmFindLibraryCommand.cxx" #include "cmFindLibraryCommand.cxx"

386
Source/cmFindBase.cxx
View File

@ -18,26 +18,10 @@
cmFindBase::cmFindBase() cmFindBase::cmFindBase()
{ {
cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder,
"FIND_ARGS_XXX", "<VAR> NAMES name");
this->AlreadyInCache = false; this->AlreadyInCache = false;
this->AlreadyInCacheWithoutMetaInfo = false; this->AlreadyInCacheWithoutMetaInfo = false;
this->NoDefaultPath = false;
this->NoCMakePath = false;
this->NoCMakeEnvironmentPath = false;
this->NoSystemEnvironmentPath = false;
this->NoCMakeSystemPath = false;
this->FindRootPathMode = RootPathModeBoth;
// default is to search frameworks first on apple
#if defined(__APPLE__)
this->SearchFrameworkFirst = true;
this->SearchAppBundleFirst = true;
#else
this->SearchFrameworkFirst = false;
this->SearchAppBundleFirst = false;
#endif
this->SearchFrameworkOnly = false;
this->SearchFrameworkLast = false;
this->SearchAppBundleOnly = false;
this->SearchAppBundleLast = false;
this->GenericDocumentation = this->GenericDocumentation =
" FIND_XXX(<VAR> name1 path1 path2 ...)\n" " FIND_XXX(<VAR> name1 path1 path2 ...)\n"
"This is the short-hand signature for the command that " "This is the short-hand signature for the command that "
@ -54,8 +38,9 @@ cmFindBase::cmFindBase()
" [NO_CMAKE_PATH]\n" " [NO_CMAKE_PATH]\n"
" [NO_SYSTEM_ENVIRONMENT_PATH]\n" " [NO_SYSTEM_ENVIRONMENT_PATH]\n"
" [NO_CMAKE_SYSTEM_PATH]\n" " [NO_CMAKE_SYSTEM_PATH]\n"
" [CMAKE_FIND_ROOT_PATH_BOTH | ONLY_CMAKE_FIND_ROOT_PATH | " " [CMAKE_FIND_ROOT_PATH_BOTH |\n"
"NO_CMAKE_FIND_ROOT_PATH ]\n" " ONLY_CMAKE_FIND_ROOT_PATH |\n"
" NO_CMAKE_FIND_ROOT_PATH]\n"
" )\n" " )\n"
"" ""
"This command is used to find a SEARCH_XXX_DESC. " "This command is used to find a SEARCH_XXX_DESC. "
@ -84,9 +69,8 @@ cmFindBase::cmFindBase()
"can be skipped if NO_CMAKE_ENVIRONMENT_PATH is passed.\n" "can be skipped if NO_CMAKE_ENVIRONMENT_PATH is passed.\n"
"" ""
" <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_PREFIX_PATH\n" " <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_PREFIX_PATH\n"
" CMAKE_FRAMEWORK_PATH\n"
" CMAKE_APPBUNDLE_PATH\n"
" CMAKE_XXX_PATH\n" " CMAKE_XXX_PATH\n"
" CMAKE_XXX_MAC_PATH\n"
"2. Search cmake variables with the same names as " "2. Search cmake variables with the same names as "
"the cmake specific environment variables. These " "the cmake specific environment variables. These "
"are intended to be used on the command line with a " "are intended to be used on the command line with a "
@ -94,9 +78,8 @@ cmFindBase::cmFindBase()
"is passed.\n" "is passed.\n"
"" ""
" <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_PREFIX_PATH\n" " <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_PREFIX_PATH\n"
" CMAKE_FRAMEWORK_PATH\n"
" CMAKE_APPBUNDLE_PATH\n"
" CMAKE_XXX_PATH\n" " CMAKE_XXX_PATH\n"
" CMAKE_XXX_MAC_PATH\n"
"3. Search the standard system environment variables. " "3. Search the standard system environment variables. "
"This can be skipped if NO_SYSTEM_ENVIRONMENT_PATH is an argument.\n" "This can be skipped if NO_SYSTEM_ENVIRONMENT_PATH is an argument.\n"
" PATH\n" " PATH\n"
@ -105,51 +88,14 @@ cmFindBase::cmFindBase()
"for the current system. This can be skipped if NO_CMAKE_SYSTEM_PATH " "for the current system. This can be skipped if NO_CMAKE_SYSTEM_PATH "
"is passed.\n" "is passed.\n"
" <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH\n" " <prefix>/XXX_SUBDIR for each <prefix> in CMAKE_SYSTEM_PREFIX_PATH\n"
" CMAKE_SYSTEM_FRAMEWORK_PATH\n"
" CMAKE_SYSTEM_APPBUNDLE_PATH\n"
" CMAKE_SYSTEM_XXX_PATH\n" " CMAKE_SYSTEM_XXX_PATH\n"
" CMAKE_SYSTEM_XXX_MAC_PATH\n"
"5. Search the paths specified after PATHS or in the short-hand version " "5. Search the paths specified after PATHS or in the short-hand version "
"of the command.\n" "of the command.\n"
"On Darwin or systems supporting OSX Frameworks, the cmake variable" ;
" CMAKE_FIND_FRAMEWORK can be set to empty or one of the following:\n" this->GenericDocumentation += this->GenericDocumentationMacPolicy;
" \"FIRST\" - Try to find frameworks before standard\n" this->GenericDocumentation += this->GenericDocumentationRootPath;
" libraries or headers. This is the default on Darwin.\n" this->GenericDocumentation += this->GenericDocumentationPathsOrder;
" \"LAST\" - Try to find frameworks after standard\n"
" libraries or headers.\n"
" \"ONLY\" - Only try to find frameworks.\n"
" \"NEVER\". - Never try to find frameworks.\n"
"On Darwin or systems supporting OSX Application Bundles, the cmake "
"variable CMAKE_FIND_APPBUNDLE can be set to empty or one of the "
"following:\n"
" \"FIRST\" - Try to find application bundles before standard\n"
" programs. This is the default on Darwin.\n"
" \"LAST\" - Try to find application bundles after standard\n"
" programs.\n"
" \"ONLY\" - Only try to find application bundles.\n"
" \"NEVER\". - Never try to find application bundles.\n"
"The CMake variable CMAKE_FIND_ROOT_PATH specifies one or more "
"directories to be prepended to all other search directories. "
"This effectively \"re-roots\" the entire search under given locations. "
"By default it is empty. It is especially useful when "
"cross-compiling to point to the root directory of the "
"target environment and CMake will search there too. By default at first "
"the directories listed in CMAKE_FIND_ROOT_PATH and then the non-rooted "
"directories will be searched. "
"The default behavior can be adjusted by setting "
"CMAKE_FIND_ROOT_PATH_MODE_XXX. This behavior can be manually "
"overridden on a per-call basis. "
"By using CMAKE_FIND_ROOT_PATH_BOTH the search order will "
"be as described above. If NO_CMAKE_FIND_ROOT_PATH is used "
"then CMAKE_FIND_ROOT_PATH will not be used. If ONLY_CMAKE_FIND_ROOT_PATH "
"is used then only the re-rooted directories will be searched.\n"
"The reason the paths listed in the call to the command are searched "
"last is that most users of CMake would expect things to be found "
"first in the locations specified by their environment. Projects may "
"override this behavior by simply calling the command twice:\n"
" FIND_XXX(<VAR> NAMES name PATHS paths NO_DEFAULT_PATH)\n"
" FIND_XXX(<VAR> NAMES name)\n"
"Once one of these calls succeeds the result variable will be set "
"and stored in the cache so that neither call will search again.";
} }
bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn) bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
@ -159,57 +105,6 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
this->SetError("called with incorrect number of arguments"); this->SetError("called with incorrect number of arguments");
return false; return false;
} }
std::string ff = this->Makefile->GetSafeDefinition("CMAKE_FIND_FRAMEWORK");
if(ff == "NEVER")
{
this->SearchFrameworkLast = false;
this->SearchFrameworkFirst = false;
this->SearchFrameworkOnly = false;
}
else if (ff == "ONLY")
{
this->SearchFrameworkLast = false;
this->SearchFrameworkFirst = false;
this->SearchFrameworkOnly = true;
}
else if (ff == "FIRST")
{
this->SearchFrameworkLast = false;
this->SearchFrameworkFirst = true;
this->SearchFrameworkOnly = false;
}
else if (ff == "LAST")
{
this->SearchFrameworkLast = true;
this->SearchFrameworkFirst = false;
this->SearchFrameworkOnly = false;
}
std::string fab = this->Makefile->GetSafeDefinition("CMAKE_FIND_APPBUNDLE");
if(fab == "NEVER")
{
this->SearchAppBundleLast = false;
this->SearchAppBundleFirst = false;
this->SearchAppBundleOnly = false;
}
else if (fab == "ONLY")
{
this->SearchAppBundleLast = false;
this->SearchAppBundleFirst = false;
this->SearchAppBundleOnly = true;
}
else if (fab == "FIRST")
{
this->SearchAppBundleLast = false;
this->SearchAppBundleFirst = true;
this->SearchAppBundleOnly = false;
}
else if (fab == "LAST")
{
this->SearchAppBundleLast = true;
this->SearchAppBundleFirst = false;
this->SearchAppBundleOnly = false;
}
// CMake versions below 2.3 did not search all these extra // CMake versions below 2.3 did not search all these extra
// locations. Preserve compatibility unless a modern argument is // locations. Preserve compatibility unless a modern argument is
@ -271,23 +166,12 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
return true; return true;
} }
this->AlreadyInCache = false; this->AlreadyInCache = false;
std::string findRootPathVar = "CMAKE_FIND_ROOT_PATH_MODE_"; // Find the current root path mode.
findRootPathVar += this->CMakePathName; this->SelectDefaultRootPathMode();
std::string rootPathMode =
this->Makefile->GetSafeDefinition(findRootPathVar.c_str()); // Find the current bundle/framework search policy.
if (rootPathMode=="NEVER") this->SelectDefaultMacMode();
{
this->FindRootPathMode = RootPathModeNoRootPath;
}
else if (rootPathMode=="ONLY")
{
this->FindRootPathMode = RootPathModeOnlyRootPath;
}
else if (rootPathMode=="BOTH")
{
this->FindRootPathMode = RootPathModeBoth;
}
std::vector<std::string> userPaths; std::vector<std::string> userPaths;
std::string doc; std::string doc;
@ -327,60 +211,12 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
doingNames = false; doingNames = false;
this->NoDefaultPath = true; this->NoDefaultPath = true;
} }
else if (args[j] == "NO_DEFAULT_PATH") else if (this->CheckCommonArgument(args[j]))
{ {
compatibility = false; compatibility = false;
doingPaths = false; doingPaths = false;
doingPathSuf = false; doingPathSuf = false;
doingNames = false; doingNames = false;
this->NoDefaultPath = true;
}
else if (args[j] == "NO_CMAKE_ENVIRONMENT_PATH")
{
compatibility = false;
doingPaths = false;
doingPathSuf = false;
doingNames = false;
this->NoCMakeEnvironmentPath = true;
}
else if (args[j] == "NO_CMAKE_PATH")
{
compatibility = false;
doingPaths = false;
doingPathSuf = false;
doingNames = false;
this->NoCMakePath = true;
}
else if (args[j] == "NO_SYSTEM_ENVIRONMENT_PATH")
{
compatibility = false;
doingPaths = false;
doingPathSuf = false;
doingNames = false;
this->NoSystemEnvironmentPath = true;
}
else if (args[j] == "NO_CMAKE_SYSTEM_PATH")
{
compatibility = false;
doingPaths = false;
doingPathSuf = false;
doingNames = false;
this->NoCMakeSystemPath = true;
}
else if (args[j] == "NO_CMAKE_FIND_ROOT_PATH")
{
compatibility = false;
this->FindRootPathMode = RootPathModeNoRootPath;
}
else if (args[j] == "ONLY_CMAKE_FIND_ROOT_PATH")
{
compatibility = false;
this->FindRootPathMode = RootPathModeOnlyRootPath;
}
else if (args[j] == "CMAKE_FIND_ROOT_PATH_BOTH")
{
compatibility = false;
this->FindRootPathMode = RootPathModeBoth;
} }
else else
{ {
@ -393,8 +229,8 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
userPaths.push_back(args[j]); userPaths.push_back(args[j]);
} }
else if(doingPathSuf) else if(doingPathSuf)
{ {
this->SearchPathSuffixes.push_back(args[j]); this->AddPathSuffix(args[j]);
} }
} }
} }
@ -446,8 +282,9 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
} }
} }
this->ExpandPaths(userPaths); this->ExpandPaths(userPaths);
this->HandleCMakeFindRootPath(); // Handle search root stuff.
this->RerootPaths(this->SearchPaths);
return true; return true;
} }
@ -457,11 +294,11 @@ void cmFindBase::ExpandPaths(std::vector<std::string> userPaths)
// standard search paths. // standard search paths.
if(!this->NoDefaultPath) if(!this->NoDefaultPath)
{ {
if(this->SearchFrameworkFirst) if(this->SearchFrameworkFirst || this->SearchFrameworkOnly)
{ {
this->AddFrameWorkPaths(); this->AddFrameWorkPaths();
} }
if(this->SearchAppBundleFirst) if(this->SearchAppBundleFirst || this->SearchAppBundleOnly)
{ {
this->AddAppBundlePaths(); this->AddAppBundlePaths();
} }
@ -509,55 +346,7 @@ void cmFindBase::ExpandPaths(std::vector<std::string> userPaths)
this->AddPaths(paths); this->AddPaths(paths);
} }
void cmFindBase::HandleCMakeFindRootPath() //----------------------------------------------------------------------------
{
if (this->FindRootPathMode == RootPathModeNoRootPath)
{
return;
}
const char* rootPath = this->Makefile->GetDefinition("CMAKE_FIND_ROOT_PATH");
if ((rootPath == 0) || (strlen(rootPath) == 0))
{
return;
}
std::vector<std::string> roots;
cmSystemTools::ExpandListArgument(rootPath, roots);
std::vector<std::string> unrootedPaths=this->SearchPaths;
this->SearchPaths.clear();
for (std::vector<std::string>::const_iterator rootIt = roots.begin();
rootIt != roots.end();
++rootIt )
{
for (std::vector<std::string>::const_iterator it = unrootedPaths.begin();
it != unrootedPaths.end();
++it )
{
// if the current directory is already inside the current root, don't
// add the root again
std::string rootedDir;
if (cmSystemTools::IsSubDirectory(it->c_str(), rootIt->c_str()))
{
rootedDir = *it;
}
else
{
rootedDir=*rootIt;
rootedDir+=*it;
}
this->SearchPaths.push_back(rootedDir);
}
}
if (this->FindRootPathMode == RootPathModeBoth)
{
this->AddPaths(unrootedPaths);
}
}
void cmFindBase::AddEnvironmentVariables() void cmFindBase::AddEnvironmentVariables()
{ {
std::vector<std::string> paths; std::vector<std::string> paths;
@ -570,14 +359,6 @@ void cmFindBase::AddEnvironmentVariables()
var += this->CMakePathName; var += this->CMakePathName;
var += "_PATH"; var += "_PATH";
cmSystemTools::GetPath(paths, var.c_str()); cmSystemTools::GetPath(paths, var.c_str());
if(this->SearchAppBundleLast)
{
cmSystemTools::GetPath(paths, "CMAKE_APPBUNDLE_PATH");
}
if(this->SearchFrameworkLast)
{
cmSystemTools::GetPath(paths, "CMAKE_FRAMEWORK_PATH");
}
this->AddPaths(paths); this->AddPaths(paths);
} }
@ -585,15 +366,15 @@ void cmFindBase::AddFindPrefix(std::vector<std::string>& dest,
const std::vector<std::string>& src) const std::vector<std::string>& src)
{ {
// default for programs // default for programs
std::string subdir = "/bin"; std::string subdir = "bin";
if (this->CMakePathName == "INCLUDE") if (this->CMakePathName == "INCLUDE")
{ {
subdir = "/include"; subdir = "include";
} }
else if (this->CMakePathName == "LIBRARY") else if (this->CMakePathName == "LIBRARY")
{ {
subdir = "/lib"; subdir = "lib";
} }
else if (this->CMakePathName == "FRAMEWORK") else if (this->CMakePathName == "FRAMEWORK")
{ {
@ -604,14 +385,15 @@ void cmFindBase::AddFindPrefix(std::vector<std::string>& dest,
it != src.end(); it != src.end();
++it) ++it)
{ {
std::string dirWithSubdir = it->c_str(); std::string dir = it->c_str();
dirWithSubdir += subdir; if(!subdir.empty() && !dir.empty() && dir[dir.size()-1] != '/')
dest.push_back(dirWithSubdir);
if (subdir == "/bin")
{ {
dirWithSubdir = it->c_str(); dir += "/";
dirWithSubdir += "/sbin"; }
dest.push_back(dirWithSubdir); dest.push_back(dir + subdir);
if (subdir == "bin")
{
dest.push_back(dir + "sbin");
} }
if(!subdir.empty()) if(!subdir.empty())
{ {
@ -622,35 +404,9 @@ void cmFindBase::AddFindPrefix(std::vector<std::string>& dest,
void cmFindBase::AddFrameWorkPaths() void cmFindBase::AddFrameWorkPaths()
{ {
if(this->NoDefaultPath)
{
return;
}
std::vector<std::string> paths; std::vector<std::string> paths;
// first environment variables this->GetFrameworkPaths(paths);
if(!this->NoCMakeEnvironmentPath) this->AddPaths(paths);
{
cmSystemTools::GetPath(paths, "CMAKE_FRAMEWORK_PATH");
}
// add cmake variables
if(!this->NoCMakePath)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_FRAMEWORK_PATH"))
{
cmSystemTools::ExpandListArgument(path, paths);
}
}
// AddCMakeSystemVariables
if(!this->NoCMakeSystemPath)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_SYSTEM_FRAMEWORK_PATH"))
{
cmSystemTools::ExpandListArgument(path, paths);
}
}
this->AddPaths(paths);
} }
void cmFindBase::AddPaths(std::vector<std::string> & paths) void cmFindBase::AddPaths(std::vector<std::string> & paths)
@ -665,35 +421,9 @@ void cmFindBase::AddPaths(std::vector<std::string> & paths)
void cmFindBase::AddAppBundlePaths() void cmFindBase::AddAppBundlePaths()
{ {
if(this->NoDefaultPath)
{
return;
}
std::vector<std::string> paths; std::vector<std::string> paths;
// first environment variables this->GetAppBundlePaths(paths);
if(!this->NoCMakeEnvironmentPath) this->AddPaths(paths);
{
cmSystemTools::GetPath(paths, "CMAKE_APPBUNDLE_PATH");
}
// add cmake variables
if(!this->NoCMakePath)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_APPBUNDLE_PATH"))
{
cmSystemTools::ExpandListArgument(path, paths);
}
}
// AddCMakeSystemVariables
if(!this->NoCMakeSystemPath)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_SYSTEM_APPBUNDLE_PATH"))
{
cmSystemTools::ExpandListArgument(path, paths);
}
}
this->AddPaths(paths);
} }
void cmFindBase::AddCMakeVariables() void cmFindBase::AddCMakeVariables()
@ -715,22 +445,6 @@ void cmFindBase::AddCMakeVariables()
{ {
cmSystemTools::ExpandListArgument(path, paths); cmSystemTools::ExpandListArgument(path, paths);
} }
if(this->SearchAppBundleLast)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_APPBUNDLE_PATH"))
{
cmSystemTools::ExpandListArgument(path, paths);
}
}
if(this->SearchFrameworkLast)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_FRAMEWORK_PATH"))
{
cmSystemTools::ExpandListArgument(path, paths);
}
}
this->AddPaths(paths); this->AddPaths(paths);
} }
@ -764,22 +478,6 @@ void cmFindBase::AddCMakeSystemVariables()
{ {
cmSystemTools::ExpandListArgument(path, paths); cmSystemTools::ExpandListArgument(path, paths);
} }
if(this->SearchAppBundleLast)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_SYSTEM_APPBUNDLE_PATH"))
{
cmSystemTools::ExpandListArgument(path, paths);
}
}
if(this->SearchFrameworkLast)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_SYSTEM_FRAMEWORK_PATH"))
{
cmSystemTools::ExpandListArgument(path, paths);
}
}
this->AddPaths(paths); this->AddPaths(paths);
} }

34
Source/cmFindBase.h
View File

@ -17,15 +17,15 @@
#ifndef cmFindBase_h #ifndef cmFindBase_h
#define cmFindBase_h #define cmFindBase_h
#include "cmCommand.h" #include "cmFindCommon.h"
/** \class cmFindBase /** \class cmFindBase
* \brief Define a command to search for an executable program. * \brief Base class for most FIND_XXX commands.
* *
* cmFindBase is a parent class for cmFindProgramCommand, cmFindPathCommand, * cmFindBase is a parent class for cmFindProgramCommand, cmFindPathCommand,
* and cmFindLibraryCommand, cmFindFile * and cmFindLibraryCommand, cmFindFileCommand
*/ */
class cmFindBase : public cmCommand class cmFindBase : public cmFindCommon
{ {
public: public:
cmFindBase(); cmFindBase();
@ -34,20 +34,15 @@ public:
* the CMakeLists.txt file. * the CMakeLists.txt file.
*/ */
virtual bool ParseArguments(std::vector<std::string> const& args); virtual bool ParseArguments(std::vector<std::string> const& args);
cmTypeMacro(cmFindBase, cmCommand); cmTypeMacro(cmFindBase, cmFindCommon);
virtual const char* GetFullDocumentation() virtual const char* GetFullDocumentation()
{return this->GenericDocumentation.c_str();} {return this->GenericDocumentation.c_str();}
enum RootPathMode { RootPathModeBoth,
RootPathModeOnlyRootPath,
RootPathModeNoRootPath };
protected: protected:
void PrintFindStuff(); void PrintFindStuff();
void ExpandPaths(std::vector<std::string> userPaths); void ExpandPaths(std::vector<std::string> userPaths);
void HandleCMakeFindRootPath();
// add to the SearchPaths // add to the SearchPaths
void AddPaths(std::vector<std::string>& paths); void AddPaths(std::vector<std::string>& paths);
void AddFrameWorkPaths(); void AddFrameWorkPaths();
@ -70,29 +65,12 @@ protected:
cmStdString VariableName; cmStdString VariableName;
std::vector<std::string> Names; std::vector<std::string> Names;
std::vector<std::string> SearchPaths; std::vector<std::string> SearchPaths;
std::vector<std::string> SearchPathSuffixes;
// CMAKE_*_PATH CMAKE_SYSTEM_*_PATH FRAMEWORK|LIBRARY|INCLUDE|PROGRAM // CMAKE_*_PATH CMAKE_SYSTEM_*_PATH FRAMEWORK|LIBRARY|INCLUDE|PROGRAM
cmStdString CMakePathName;
cmStdString EnvironmentPath; // LIB,INCLUDE cmStdString EnvironmentPath; // LIB,INCLUDE
bool AlreadyInCache; bool AlreadyInCache;
bool AlreadyInCacheWithoutMetaInfo; bool AlreadyInCacheWithoutMetaInfo;
bool NoDefaultPath;
bool NoCMakePath;
bool NoCMakeEnvironmentPath;
bool NoSystemEnvironmentPath;
bool NoCMakeSystemPath;
RootPathMode FindRootPathMode;
bool SearchFrameworkFirst;
bool SearchFrameworkOnly;
bool SearchFrameworkLast;
bool SearchAppBundleFirst;
bool SearchAppBundleOnly;
bool SearchAppBundleLast;
}; };

479
Source/cmFindCommon.cxx Normal file
View File

@ -0,0 +1,479 @@
/*=========================================================================
Program: CMake - Cross-Platform Makefile Generator
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#include "cmFindCommon.h"
//----------------------------------------------------------------------------
cmFindCommon::cmFindCommon()
{
this->FindRootPathMode = RootPathModeBoth;
this->NoDefaultPath = false;
this->NoCMakePath = false;
this->NoCMakeEnvironmentPath = false;
this->NoSystemEnvironmentPath = false;
this->NoCMakeSystemPath = false;
// OS X Bundle and Framework search policy. The default is to
// search frameworks first on apple.
#if defined(__APPLE__)
this->SearchFrameworkFirst = true;
this->SearchAppBundleFirst = true;
#else
this->SearchFrameworkFirst = false;
this->SearchAppBundleFirst = false;
#endif
this->SearchFrameworkOnly = false;
this->SearchFrameworkLast = false;
this->SearchAppBundleOnly = false;
this->SearchAppBundleLast = false;
// Documentation components.
this->GenericDocumentationMacPolicy =
"On Darwin or systems supporting OS X Frameworks, the cmake variable"
" CMAKE_FIND_FRAMEWORK can be set to empty or one of the following:\n"
" \"FIRST\" - Try to find frameworks before standard\n"
" libraries or headers. This is the default on Darwin.\n"
" \"LAST\" - Try to find frameworks after standard\n"
" libraries or headers.\n"
" \"ONLY\" - Only try to find frameworks.\n"
" \"NEVER\". - Never try to find frameworks.\n"
"On Darwin or systems supporting OS X Application Bundles, the cmake "
"variable CMAKE_FIND_APPBUNDLE can be set to empty or one of the "
"following:\n"
" \"FIRST\" - Try to find application bundles before standard\n"
" programs. This is the default on Darwin.\n"
" \"LAST\" - Try to find application bundles after standard\n"
" programs.\n"
" \"ONLY\" - Only try to find application bundles.\n"
" \"NEVER\". - Never try to find application bundles.\n";
this->GenericDocumentationRootPath =
"The CMake variable CMAKE_FIND_ROOT_PATH specifies one or more "
"directories to be prepended to all other search directories. "
"This effectively \"re-roots\" the entire search under given locations. "
"By default it is empty. It is especially useful when "
"cross-compiling to point to the root directory of the "
"target environment and CMake will search there too. By default at first "
"the directories listed in CMAKE_FIND_ROOT_PATH and then the non-rooted "
"directories will be searched. "
"The default behavior can be adjusted by setting "
"CMAKE_FIND_ROOT_PATH_MODE_XXX. This behavior can be manually "
"overridden on a per-call basis. "
"By using CMAKE_FIND_ROOT_PATH_BOTH the search order will "
"be as described above. If NO_CMAKE_FIND_ROOT_PATH is used "
"then CMAKE_FIND_ROOT_PATH will not be used. If ONLY_CMAKE_FIND_ROOT_PATH "
"is used then only the re-rooted directories will be searched.\n";
this->GenericDocumentationPathsOrder =
"The reason the paths listed in the call to the command are searched "
"last is that most users of CMake would expect things to be found "
"first in the locations specified by their environment. Projects may "
"override this behavior by simply calling the command twice:\n"
" FIND_XXX(FIND_ARGS_XXX PATHS paths... NO_DEFAULT_PATH)\n"
" FIND_XXX(FIND_ARGS_XXX)\n"
"Once one of these calls succeeds the result variable will be set "
"and stored in the cache so that neither call will search again.";
}
//----------------------------------------------------------------------------
cmFindCommon::~cmFindCommon()
{
}
//----------------------------------------------------------------------------
void cmFindCommon::SelectDefaultRootPathMode()
{
// Use both by default.
this->FindRootPathMode = RootPathModeBoth;
// Check the policy variable for this find command type.
std::string findRootPathVar = "CMAKE_FIND_ROOT_PATH_MODE_";
findRootPathVar += this->CMakePathName;
std::string rootPathMode =
this->Makefile->GetSafeDefinition(findRootPathVar.c_str());
if (rootPathMode=="NEVER")
{
this->FindRootPathMode = RootPathModeNoRootPath;
}
else if (rootPathMode=="ONLY")
{
this->FindRootPathMode = RootPathModeOnlyRootPath;
}
else if (rootPathMode=="BOTH")
{
this->FindRootPathMode = RootPathModeBoth;
}
}
//----------------------------------------------------------------------------
void cmFindCommon::SelectDefaultMacMode()
{
std::string ff = this->Makefile->GetSafeDefinition("CMAKE_FIND_FRAMEWORK");
if(ff == "NEVER")
{
this->SearchFrameworkLast = false;
this->SearchFrameworkFirst = false;
this->SearchFrameworkOnly = false;
}
else if(ff == "ONLY")
{
this->SearchFrameworkLast = false;
this->SearchFrameworkFirst = false;
this->SearchFrameworkOnly = true;
}
else if(ff == "FIRST")
{
this->SearchFrameworkLast = false;
this->SearchFrameworkFirst = true;
this->SearchFrameworkOnly = false;
}
else if(ff == "LAST")
{
this->SearchFrameworkLast = true;
this->SearchFrameworkFirst = false;
this->SearchFrameworkOnly = false;
}
std::string fab = this->Makefile->GetSafeDefinition("CMAKE_FIND_APPBUNDLE");
if(fab == "NEVER")
{
this->SearchAppBundleLast = false;
this->SearchAppBundleFirst = false;
this->SearchAppBundleOnly = false;
}
else if(fab == "ONLY")
{
this->SearchAppBundleLast = false;
this->SearchAppBundleFirst = false;
this->SearchAppBundleOnly = true;
}
else if(fab == "FIRST")
{
this->SearchAppBundleLast = false;
this->SearchAppBundleFirst = true;
this->SearchAppBundleOnly = false;
}
else if(fab == "LAST")
{
this->SearchAppBundleLast = true;
this->SearchAppBundleFirst = false;
this->SearchAppBundleOnly = false;
}
}
//----------------------------------------------------------------------------
void cmFindCommon::RerootPaths(std::vector<std::string>& paths)
{
#if 0
for(std::vector<std::string>::const_iterator i = paths.begin();
i != paths.end(); ++i)
{
fprintf(stderr, "[%s]\n", i->c_str());
}
#endif
// Short-circuit if there is nothing to do.
if(this->FindRootPathMode == RootPathModeNoRootPath)
{
return;
}
const char* rootPath =
this->Makefile->GetDefinition("CMAKE_FIND_ROOT_PATH");
if((rootPath == 0) || (strlen(rootPath) == 0))
{
return;
}
// Construct the list of path roots with no trailing slashes.
std::vector<std::string> roots;
cmSystemTools::ExpandListArgument(rootPath, roots);
for(std::vector<std::string>::iterator ri = roots.begin();
ri != roots.end(); ++ri)
{
cmSystemTools::ConvertToUnixSlashes(*ri);
}
// Copy the original set of unrooted paths.
std::vector<std::string> unrootedPaths = paths;
paths.clear();
for(std::vector<std::string>::const_iterator ri = roots.begin();
ri != roots.end(); ++ri)
{
for(std::vector<std::string>::const_iterator ui = unrootedPaths.begin();
ui != unrootedPaths.end(); ++ui)
{
// Place the unrooted path under the current root if it is not
// already inside. Skip the unrooted path if it is relative to
// a user home directory or is empty.
std::string rootedDir;
if(cmSystemTools::IsSubDirectory(ui->c_str(), ri->c_str()))
{
rootedDir = *ui;
}
else if(!ui->empty() && (*ui)[0] != '~')
{
// Start with the new root.
rootedDir = *ri;
rootedDir += "/";
// Append the original path with its old root removed.
rootedDir += cmSystemTools::SplitPathRootComponent(ui->c_str());
}
// Store the new path.
paths.push_back(rootedDir);
}
}
// If searching both rooted and unrooted paths add the original
// paths again.
if(this->FindRootPathMode == RootPathModeBoth)
{
paths.insert(paths.end(), unrootedPaths.begin(), unrootedPaths.end());
}
}
//----------------------------------------------------------------------------
bool cmFindCommon::CheckCommonArgument(std::string const& arg)
{
if(arg == "NO_DEFAULT_PATH")
{
this->NoDefaultPath = true;
}
else if(arg == "NO_CMAKE_ENVIRONMENT_PATH")
{
this->NoCMakeEnvironmentPath = true;
}
else if(arg == "NO_CMAKE_PATH")
{
this->NoCMakePath = true;
}
else if(arg == "NO_SYSTEM_ENVIRONMENT_PATH")
{
this->NoSystemEnvironmentPath = true;
}
else if(arg == "NO_CMAKE_SYSTEM_PATH")
{
this->NoCMakeSystemPath = true;
}
else if(arg == "NO_CMAKE_FIND_ROOT_PATH")
{
this->FindRootPathMode = RootPathModeNoRootPath;
}
else if(arg == "ONLY_CMAKE_FIND_ROOT_PATH")
{
this->FindRootPathMode = RootPathModeOnlyRootPath;
}
else if(arg == "CMAKE_FIND_ROOT_PATH_BOTH")
{
this->FindRootPathMode = RootPathModeBoth;
}
else
{
// The argument is not one of the above.
return false;
}
// The argument is one of the above.
return true;
}
//----------------------------------------------------------------------------
void cmFindCommon::AddPathSuffix(std::string const& arg)
{
std::string suffix = arg;
// Strip leading and trailing slashes.
if(suffix.empty())
{
return;
}
if(suffix[0] == '/')
{
suffix = suffix.substr(1, suffix.npos);
}
if(suffix.empty())
{
return;
}
if(suffix[suffix.size()-1] == '/')
{
suffix = suffix.substr(0, suffix.size()-1);
}
if(suffix.empty())
{
return;
}
// Store the suffix.
this->SearchPathSuffixes.push_back(suffix);
}
//----------------------------------------------------------------------------
void cmFindCommon::GetAppBundlePaths(std::vector<std::string>& paths)
{
if(this->NoDefaultPath)
{
return;
}
std::vector<std::string> tmp;
// first environment variables
if(!this->NoCMakeEnvironmentPath)
{
cmSystemTools::GetPath(tmp, "CMAKE_APPBUNDLE_PATH");
this->AddPathsInternal(paths, tmp, EnvPath);
tmp.clear();
}
// add cmake variables
if(!this->NoCMakePath)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_APPBUNDLE_PATH"))
{
cmSystemTools::ExpandListArgument(path, tmp);
this->AddPathsInternal(paths, tmp, CMakePath);
tmp.clear();
}
}
// add cmake system variables
if(!this->NoCMakeSystemPath)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_SYSTEM_APPBUNDLE_PATH"))
{
cmSystemTools::ExpandListArgument(path, tmp);
this->AddPathsInternal(paths, tmp, CMakePath);
tmp.clear();
}
}
}
//----------------------------------------------------------------------------
void cmFindCommon::GetFrameworkPaths(std::vector<std::string>& paths)
{
if(this->NoDefaultPath)
{
return;
}
std::vector<std::string> tmp;
// first environment variables
if(!this->NoCMakeEnvironmentPath)
{
cmSystemTools::GetPath(tmp, "CMAKE_FRAMEWORK_PATH");
this->AddPathsInternal(paths, tmp, EnvPath);
tmp.clear();
}
// add cmake variables
if(!this->NoCMakePath)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_FRAMEWORK_PATH"))
{
cmSystemTools::ExpandListArgument(path, tmp);
this->AddPathsInternal(paths, tmp, CMakePath);
tmp.clear();
}
}
// add cmake system variables
if(!this->NoCMakeSystemPath)
{
if(const char* path =
this->Makefile->GetDefinition("CMAKE_SYSTEM_FRAMEWORK_PATH"))
{
cmSystemTools::ExpandListArgument(path, tmp);
this->AddPathsInternal(paths, tmp, CMakePath);
tmp.clear();
}
}
}
//----------------------------------------------------------------------------
void cmFindCommon::AddCMakePath(std::vector<std::string>& out_paths,
const char* variable,
std::set<cmStdString>* emmitted)
{
// Get a path from a CMake variable.
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(out_paths, tmp, CMakePath, emmitted);
}
}
//----------------------------------------------------------------------------
void cmFindCommon::AddEnvPath(std::vector<std::string>& out_paths,
const char* variable,
std::set<cmStdString>* emmitted)
{
// 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(out_paths, tmp, EnvPath, emmitted);
}
//----------------------------------------------------------------------------
void cmFindCommon::AddPathsInternal(std::vector<std::string>& out_paths,
std::vector<std::string> const& in_paths,
PathType pathType,
std::set<cmStdString>* emmitted)
{
for(std::vector<std::string>::const_iterator i = in_paths.begin();
i != in_paths.end(); ++i)
{
this->AddPathInternal(out_paths, *i, pathType, emmitted);
}
}
//----------------------------------------------------------------------------
void cmFindCommon::AddPathInternal(std::vector<std::string>& out_paths,
std::string const& in_path,
PathType pathType,
std::set<cmStdString>* emmitted)
{
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.c_str(), relbase);
// Insert the path if has not already been emmitted.
if(!emmitted || emmitted->insert(fullPath).second)
{
out_paths.push_back(fullPath.c_str());
}
}

95
Source/cmFindCommon.h Normal file
View File

@ -0,0 +1,95 @@
/*=========================================================================
Program: CMake - Cross-Platform Makefile Generator
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#ifndef cmFindCommon_h
#define cmFindCommon_h
#include "cmCommand.h"
/** \class cmFindCommon
* \brief Base class for FIND_XXX implementations.
*
* cmFindCommon is a parent class for cmFindBase,
* cmFindProgramCommand, cmFindPathCommand, cmFindLibraryCommand,
* cmFindFileCommand, and cmFindPackageCommand.
*/
class cmFindCommon : public cmCommand
{
public:
cmFindCommon();
~cmFindCommon();
cmTypeMacro(cmFindCommon, cmCommand);
protected:
enum RootPathMode { RootPathModeBoth,
RootPathModeOnlyRootPath,
RootPathModeNoRootPath };
enum PathType { FullPath, CMakePath, EnvPath };
/** Place a set of search paths under the search roots. */
void RerootPaths(std::vector<std::string>& paths);
/** Compute the current default root path mode. */
void SelectDefaultRootPathMode();
/** Compute the current default bundle/framework search policy. */
void SelectDefaultMacMode();
cmStdString CMakePathName;
RootPathMode FindRootPathMode;
bool CheckCommonArgument(std::string const& arg);
void AddPathSuffix(std::string const& arg);
void GetAppBundlePaths(std::vector<std::string>& paths);
void GetFrameworkPaths(std::vector<std::string>& paths);
void AddCMakePath(std::vector<std::string>& out_paths,
const char* variable, std::set<cmStdString>* emmitted = 0);
void AddEnvPath(std::vector<std::string>& out_paths,
const char* variable, std::set<cmStdString>* emmitted = 0);
void AddPathsInternal(std::vector<std::string>& out_paths,
std::vector<std::string> const& in_paths,
PathType pathType,
std::set<cmStdString>* emmitted = 0);
void AddPathInternal(std::vector<std::string>& out_paths,
std::string const& in_path,
PathType pathType,
std::set<cmStdString>* emmitted = 0);
bool NoDefaultPath;
bool NoCMakePath;
bool NoCMakeEnvironmentPath;
bool NoSystemEnvironmentPath;
bool NoCMakeSystemPath;
std::vector<std::string> SearchPathSuffixes;
std::string GenericDocumentationMacPolicy;
std::string GenericDocumentationRootPath;
std::string GenericDocumentationPathsOrder;
bool SearchFrameworkFirst;
bool SearchFrameworkOnly;
bool SearchFrameworkLast;
bool SearchAppBundleFirst;
bool SearchAppBundleOnly;
bool SearchAppBundleLast;
};
#endif

6
Source/cmFindLibraryCommand.cxx
View File

@ -23,6 +23,12 @@ cmFindLibraryCommand::cmFindLibraryCommand()
"FIND_XXX", "find_library"); "FIND_XXX", "find_library");
cmSystemTools::ReplaceString(this->GenericDocumentation, cmSystemTools::ReplaceString(this->GenericDocumentation,
"CMAKE_XXX_PATH", "CMAKE_LIBRARY_PATH"); "CMAKE_XXX_PATH", "CMAKE_LIBRARY_PATH");
cmSystemTools::ReplaceString(this->GenericDocumentation,
"CMAKE_XXX_MAC_PATH",
"CMAKE_FRAMEWORK_PATH");
cmSystemTools::ReplaceString(this->GenericDocumentation,
"CMAKE_SYSTEM_XXX_MAC_PATH",
"CMAKE_SYSTEM_FRAMEWORK_PATH");
cmSystemTools::ReplaceString(this->GenericDocumentation, cmSystemTools::ReplaceString(this->GenericDocumentation,
"XXX_SYSTEM", "LIB"); "XXX_SYSTEM", "LIB");
cmSystemTools::ReplaceString(this->GenericDocumentation, cmSystemTools::ReplaceString(this->GenericDocumentation,

1372
Source/cmFindPackageCommand.cxx
View File

File diff suppressed because it is too large Load Diff

78
Source/cmFindPackageCommand.h
View File

@ -17,16 +17,20 @@
#ifndef cmFindPackageCommand_h #ifndef cmFindPackageCommand_h
#define cmFindPackageCommand_h #define cmFindPackageCommand_h
#include "cmCommand.h" #include "cmFindCommon.h"
class cmFindPackageFileList;
/** \class cmFindPackageCommand /** \class cmFindPackageCommand
* \brief Load settings from an external project. * \brief Load settings from an external project.
* *
* cmFindPackageCommand * cmFindPackageCommand
*/ */
class cmFindPackageCommand : public cmCommand class cmFindPackageCommand : public cmFindCommon
{ {
public: public:
cmFindPackageCommand();
/** /**
* This is a virtual constructor for the command. * This is a virtual constructor for the command.
*/ */
@ -62,51 +66,45 @@ public:
/** /**
* More documentation. * More documentation.
*/ */
virtual const char* GetFullDocumentation() virtual const char* GetFullDocumentation();
{
return
" find_package(<name> [major.minor] [QUIET] [NO_MODULE]\n"
" [[REQUIRED|COMPONENTS] [components...]])\n"
"Finds and loads settings from an external project. <name>_FOUND will "
"be set to indicate whether the package was found. Settings that "
"can be used when <name>_FOUND is true are package-specific. The "
"package is found through several steps. "
"Directories listed in CMAKE_MODULE_PATH are searched for files called "
"\"Find<name>.cmake\". If such a file is found, it is read and "
"processed by CMake, and is responsible for finding the package. "
"This first step may be skipped by using the NO_MODULE option. "
"If no such file is found, it is expected that the package is another "
"project built by CMake that has a \"<name>Config.cmake\" file. "
"A cache entry called <name>_DIR is created and is expected to be set "
"to the directory containing this file. If the file is found, it is "
"read and processed by CMake to load the settings of the package. If "
"<name>_DIR has not been set during a configure step, the command "
"will generate an error describing the problem unless the QUIET "
"argument is specified. If <name>_DIR has been set to a directory "
"not containing a \"<name>Config.cmake\" file, an error is always "
"generated. If REQUIRED is specified and the package is not found, "
"a FATAL_ERROR is generated and the configure step stops executing. "
"A package-specific list of components may be listed after the "
"REQUIRED option, or after the COMPONENTS option if no REQUIRED "
"option is given.";
}
cmTypeMacro(cmFindPackageCommand, cmCommand); cmTypeMacro(cmFindPackageCommand, cmFindCommon);
private: private:
void AppendSuccessInformation(bool quiet); void AppendSuccessInformation();
void AppendToProperty(const char* propertyName); void AppendToProperty(const char* propertyName);
bool FindModule(bool& found, bool quiet, bool required); bool FindModule(bool& found);
bool FindConfig(); bool HandlePackageMode();
std::string SearchForConfig() const; void FindConfig();
bool FindPrefixedConfig();
bool FindFrameworkConfig();
bool FindAppBundleConfig();
bool ReadListFile(const char* f); bool ReadListFile(const char* f);
void AddUserPath(std::string const& p);
void ComputePrefixes();
bool SearchDirectory(std::string const& dir);
bool CheckDirectory(std::string const& dir);
bool FindConfigFile(std::string const& dir, std::string& file);
bool SearchPrefix(std::string const& prefix);
bool SearchFrameworkPrefix(std::string const& prefix_in);
bool SearchAppBundlePrefix(std::string const& prefix_in);
friend class cmFindPackageFileList;
std::string CommandDocumentation;
cmStdString Name; cmStdString Name;
cmStdString Variable; cmStdString Variable;
cmStdString Config; cmStdString FileFound;
std::vector<cmStdString> Builds; bool Quiet;
std::vector<cmStdString> Prefixes; bool Required;
std::vector<cmStdString> Relatives; bool Compatibility_1_6;
bool NoModule;
bool NoBuilds;
bool DebugMode;
std::vector<std::string> Names;
std::vector<std::string> Configs;
std::vector<std::string> Prefixes;
std::vector<std::string> UserPaths;
}; };
#endif #endif

6
Source/cmFindPathCommand.cxx
View File

@ -27,6 +27,12 @@ cmFindPathCommand::cmFindPathCommand()
"FIND_XXX", "find_path"); "FIND_XXX", "find_path");
cmSystemTools::ReplaceString(this->GenericDocumentation, cmSystemTools::ReplaceString(this->GenericDocumentation,
"CMAKE_XXX_PATH", "CMAKE_INCLUDE_PATH"); "CMAKE_XXX_PATH", "CMAKE_INCLUDE_PATH");
cmSystemTools::ReplaceString(this->GenericDocumentation,
"CMAKE_XXX_MAC_PATH",
"CMAKE_FRAMEWORK_PATH");
cmSystemTools::ReplaceString(this->GenericDocumentation,
"CMAKE_SYSTEM_XXX_MAC_PATH",
"CMAKE_SYSTEM_FRAMEWORK_PATH");
cmSystemTools::ReplaceString(this->GenericDocumentation, cmSystemTools::ReplaceString(this->GenericDocumentation,
"XXX_SYSTEM", "INCLUDE"); "XXX_SYSTEM", "INCLUDE");
cmSystemTools::ReplaceString(this->GenericDocumentation, cmSystemTools::ReplaceString(this->GenericDocumentation,

6
Source/cmFindProgramCommand.cxx
View File

@ -28,6 +28,12 @@ cmFindProgramCommand::cmFindProgramCommand()
"FIND_XXX", "find_program"); "FIND_XXX", "find_program");
cmSystemTools::ReplaceString(this->GenericDocumentation, cmSystemTools::ReplaceString(this->GenericDocumentation,
"CMAKE_XXX_PATH", "CMAKE_PROGRAM_PATH"); "CMAKE_XXX_PATH", "CMAKE_PROGRAM_PATH");
cmSystemTools::ReplaceString(this->GenericDocumentation,
"CMAKE_XXX_MAC_PATH",
"CMAKE_APPBUNDLE_PATH");
cmSystemTools::ReplaceString(this->GenericDocumentation,
"CMAKE_SYSTEM_XXX_MAC_PATH",
"CMAKE_SYSTEM_APPBUNDLE_PATH");
cmSystemTools::ReplaceString(this->GenericDocumentation, cmSystemTools::ReplaceString(this->GenericDocumentation,
"XXX_SYSTEM", ""); "XXX_SYSTEM", "");
cmSystemTools::ReplaceString(this->GenericDocumentation, cmSystemTools::ReplaceString(this->GenericDocumentation,