CMake/Source/cmFindBase.cxx

354 lines
11 KiB
C++
Raw Normal View History

Simplify CMake per-source license notices Per-source copyright/license notice headers that spell out copyright holder names and years are hard to maintain and often out-of-date or plain wrong. Precise contributor information is already maintained automatically by the version control tool. Ultimately it is the receiver of a file who is responsible for determining its licensing status, and per-source notices are merely a convenience. Therefore it is simpler and more accurate for each source to have a generic notice of the license name and references to more detailed information on copyright holders and full license terms. Our `Copyright.txt` file now contains a list of Contributors whose names appeared source-level copyright notices. It also references version control history for more precise information. Therefore we no longer need to spell out the list of Contributors in each source file notice. Replace CMake per-source copyright/license notice headers with a short description of the license and links to `Copyright.txt` and online information available from "https://cmake.org/licensing". The online URL also handles cases of modules being copied out of our source into other projects, so we can drop our notices about replacing links with full license text. Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority of the replacements mechanically. Manually fix up shebang lines and trailing newlines in a few files. Manually update the notices in a few files that the script does not handle.
2016-09-27 19:01:08 +00:00
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
2006-02-27 21:38:22 +00:00
#include "cmFindBase.h"
#include <deque>
#include <iostream>
#include <iterator>
#include <map>
#include <stddef.h>
2015-03-08 12:51:20 +00:00
#include "cmAlgorithms.h"
2016-10-25 18:35:04 +00:00
#include "cmMakefile.h"
#include "cmSearchPath.h"
#include "cmState.h"
#include "cmStateTypes.h"
#include "cmSystemTools.h"
2015-03-08 12:51:20 +00:00
2006-02-27 21:38:22 +00:00
cmFindBase::cmFindBase()
{
this->AlreadyInCache = false;
this->AlreadyInCacheWithoutMetaInfo = false;
this->NamesPerDir = false;
this->NamesPerDirAllowed = false;
}
2006-02-27 21:38:22 +00:00
bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
{
if (argsIn.size() < 2) {
2006-02-27 21:38:22 +00:00
this->SetError("called with incorrect number of arguments");
return false;
}
2006-02-27 21:38:22 +00:00
// copy argsIn into args so it can be modified,
// in the process extract the DOC "documentation"
2006-02-27 21:38:22 +00:00
size_t size = argsIn.size();
std::vector<std::string> args;
bool foundDoc = false;
for (unsigned int j = 0; j < size; ++j) {
if (foundDoc || argsIn[j] != "DOC") {
if (argsIn[j] == "ENV") {
if (j + 1 < size) {
j++;
cmSystemTools::GetPath(args, argsIn[j].c_str());
}
} else {
args.push_back(argsIn[j]);
2006-02-27 21:38:22 +00:00
}
} else {
if (j + 1 < size) {
2006-02-27 21:38:22 +00:00
foundDoc = true;
this->VariableDocumentation = argsIn[j + 1];
2006-02-27 21:38:22 +00:00
j++;
if (j >= size) {
2006-02-27 21:38:22 +00:00
break;
}
}
}
}
if (args.size() < 2) {
this->SetError("called with incorrect number of arguments");
return false;
}
2006-02-27 21:38:22 +00:00
this->VariableName = args[0];
if (this->CheckForVariableInCache()) {
2006-02-27 21:38:22 +00:00
this->AlreadyInCache = true;
return true;
}
this->AlreadyInCache = false;
this->SelectDefaultNoPackageRootPath();
// Find the current root path mode.
this->SelectDefaultRootPathMode();
// Find the current bundle/framework search policy.
this->SelectDefaultMacMode();
ENH: merge CMake-CrossCompileBasic to HEAD -add a RESULT_VARIABLE to INCLUDE() -add CMAKE_TOOLCHAIN_FILE for specifiying your (potentially crosscompiling) toolchain -have TRY_RUN() complain if you try to use it in crosscompiling mode (which were compiled but cannot run on this system) -use CMAKE_EXECUTABLE_SUFFIX in TRY_RUN(), probably TRY_RUN won't be able to run the executables if they have a different suffix because they are probably crosscompiled, but nevertheless it should be able to find them -make several cmake variables presettable by the user: CMAKE_C/CXX_COMPILER, CMAKE_C/CXX_OUTPUT_EXTENSION, CMAKE_SYSTEM_NAME, CMAKE_SYSTEM_INFO_FILE -support prefix for GNU toolchains (arm-elf-gcc, arm-elf-ar, arm-elf-strip etc.) -move ranlib on OSX from the file command to a command in executed in cmake_install.cmake -add support for stripping during install in cmake_install.cmake -split out cl.cmake from Windows-cl.cmake, first (very incomplete) step to support MS crosscompiling tools -remove stdio.h from the simple C program which checks if the compiler works, since this may not exist for some embedded platforms -create a new CMakeFindBinUtils.cmake which collects the search fro ar, ranlib, strip, ld, link, install_name_tool and other tools like these -add support for CMAKE_FIND_ROOT_PATH for all FIND_XXX commands, which is a list of directories which will be prepended to all search directories, right now as a cmake variable, turning it into a global cmake property may need some more work -remove cmTestTestHandler::TryExecutable(), it's unused -split cmFileCommand::HandleInstall() into slightly smaller functions Alex
2007-05-17 17:20:44 +00:00
2006-02-27 21:38:22 +00:00
bool newStyle = false;
enum Doing
{
DoingNone,
DoingNames,
DoingPaths,
DoingPathSuffixes,
DoingHints
};
Doing doing = DoingNames; // assume it starts with a name
for (unsigned int j = 1; j < args.size(); ++j) {
if (args[j] == "NAMES") {
doing = DoingNames;
2006-02-27 21:38:22 +00:00
newStyle = true;
} else if (args[j] == "PATHS") {
doing = DoingPaths;
newStyle = true;
} else if (args[j] == "HINTS") {
doing = DoingHints;
2006-02-27 21:38:22 +00:00
newStyle = true;
} else if (args[j] == "PATH_SUFFIXES") {
doing = DoingPathSuffixes;
2006-02-27 21:38:22 +00:00
newStyle = true;
} else if (args[j] == "NAMES_PER_DIR") {
doing = DoingNone;
if (this->NamesPerDirAllowed) {
this->NamesPerDir = true;
} else {
this->SetError("does not support NAMES_PER_DIR");
return false;
}
} else if (args[j] == "NO_SYSTEM_PATH") {
doing = DoingNone;
this->NoDefaultPath = true;
} else if (this->CheckCommonArgument(args[j])) {
doing = DoingNone;
// Some common arguments were accidentally supported by CMake
// 2.4 and 2.6.0 in the short-hand form of the command, so we
// must support it even though it is not documented.
} else if (doing == DoingNames) {
this->Names.push_back(args[j]);
} else if (doing == DoingPaths) {
this->UserGuessArgs.push_back(args[j]);
} else if (doing == DoingHints) {
this->UserHintsArgs.push_back(args[j]);
} else if (doing == DoingPathSuffixes) {
this->AddPathSuffix(args[j]);
2006-02-27 21:38:22 +00:00
}
}
if (this->VariableDocumentation.empty()) {
ENH: merge CMake-CrossCompileBasic to HEAD -add a RESULT_VARIABLE to INCLUDE() -add CMAKE_TOOLCHAIN_FILE for specifiying your (potentially crosscompiling) toolchain -have TRY_RUN() complain if you try to use it in crosscompiling mode (which were compiled but cannot run on this system) -use CMAKE_EXECUTABLE_SUFFIX in TRY_RUN(), probably TRY_RUN won't be able to run the executables if they have a different suffix because they are probably crosscompiled, but nevertheless it should be able to find them -make several cmake variables presettable by the user: CMAKE_C/CXX_COMPILER, CMAKE_C/CXX_OUTPUT_EXTENSION, CMAKE_SYSTEM_NAME, CMAKE_SYSTEM_INFO_FILE -support prefix for GNU toolchains (arm-elf-gcc, arm-elf-ar, arm-elf-strip etc.) -move ranlib on OSX from the file command to a command in executed in cmake_install.cmake -add support for stripping during install in cmake_install.cmake -split out cl.cmake from Windows-cl.cmake, first (very incomplete) step to support MS crosscompiling tools -remove stdio.h from the simple C program which checks if the compiler works, since this may not exist for some embedded platforms -create a new CMakeFindBinUtils.cmake which collects the search fro ar, ranlib, strip, ld, link, install_name_tool and other tools like these -add support for CMAKE_FIND_ROOT_PATH for all FIND_XXX commands, which is a list of directories which will be prepended to all search directories, right now as a cmake variable, turning it into a global cmake property may need some more work -remove cmTestTestHandler::TryExecutable(), it's unused -split cmFileCommand::HandleInstall() into slightly smaller functions Alex
2007-05-17 17:20:44 +00:00
this->VariableDocumentation = "Where can ";
if (this->Names.empty()) {
2006-02-27 21:38:22 +00:00
this->VariableDocumentation += "the (unknown) library be found";
} else if (this->Names.size() == 1) {
this->VariableDocumentation +=
"the " + this->Names[0] + " library be found";
} else {
this->VariableDocumentation += "one of the ";
this->VariableDocumentation +=
cmJoin(cmMakeRange(this->Names).retreat(1), ", ");
this->VariableDocumentation +=
" or " + this->Names[this->Names.size() - 1] + " libraries be found";
2006-02-27 21:38:22 +00:00
}
}
2006-02-27 21:38:22 +00:00
// look for old style
// FIND_*(VAR name path1 path2 ...)
if (!newStyle) {
// All the short-hand arguments have been recorded as names.
std::vector<std::string> shortArgs = this->Names;
this->Names.clear(); // clear out any values in Names
this->Names.push_back(shortArgs[0]);
this->UserGuessArgs.insert(this->UserGuessArgs.end(),
shortArgs.begin() + 1, shortArgs.end());
}
this->ExpandPaths();
this->ComputeFinalPaths();
2006-02-27 21:38:22 +00:00
return true;
}
void cmFindBase::ExpandPaths()
2006-02-27 21:38:22 +00:00
{
if (!this->NoDefaultPath) {
if (!this->NoPackageRootPath) {
this->FillPackageRootPath();
}
if (!this->NoCMakePath) {
this->FillCMakeVariablePath();
}
if (!this->NoCMakeEnvironmentPath) {
this->FillCMakeEnvironmentPath();
}
}
this->FillUserHintsPath();
if (!this->NoDefaultPath) {
if (!this->NoSystemEnvironmentPath) {
this->FillSystemEnvironmentPath();
}
if (!this->NoCMakeSystemPath) {
this->FillCMakeSystemVariablePath();
}
}
this->FillUserGuessPath();
}
void cmFindBase::FillCMakeEnvironmentPath()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::CMakeEnvironment];
// Add CMAKE_*_PATH environment variables
std::string var = "CMAKE_";
var += this->CMakePathName;
var += "_PATH";
paths.AddEnvPrefixPath("CMAKE_PREFIX_PATH");
paths.AddEnvPath(var);
if (this->CMakePathName == "PROGRAM") {
paths.AddEnvPath("CMAKE_APPBUNDLE_PATH");
} else {
paths.AddEnvPath("CMAKE_FRAMEWORK_PATH");
}
paths.AddSuffixes(this->SearchPathSuffixes);
2006-02-27 21:38:22 +00:00
}
void cmFindBase::FillPackageRootPath()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::PackageRoot];
// Add package specific search prefixes
// NOTE: This should be using const_reverse_iterator but HP aCC and
// Oracle sunCC both currently have standard library issues
// with the reverse iterator APIs.
for (std::deque<std::string>::reverse_iterator pkg =
this->Makefile->FindPackageModuleStack.rbegin();
pkg != this->Makefile->FindPackageModuleStack.rend(); ++pkg) {
std::string varName = *pkg + "_ROOT";
paths.AddCMakePrefixPath(varName);
paths.AddEnvPrefixPath(varName);
}
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";
paths.AddCMakePrefixPath("CMAKE_PREFIX_PATH");
paths.AddCMakePath(var);
if (this->CMakePathName == "PROGRAM") {
paths.AddCMakePath("CMAKE_APPBUNDLE_PATH");
} else {
paths.AddCMakePath("CMAKE_FRAMEWORK_PATH");
}
paths.AddSuffixes(this->SearchPathSuffixes);
2006-02-27 21:38:22 +00:00
}
void cmFindBase::FillSystemEnvironmentPath()
2006-02-27 21:38:22 +00:00
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::SystemEnvironment];
// Add LIB or INCLUDE
if (!this->EnvironmentPath.empty()) {
paths.AddEnvPath(this->EnvironmentPath);
#if defined(_WIN32) || defined(__CYGWIN__)
paths.AddEnvPrefixPath("PATH", true);
#endif
}
// Add PATH
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";
paths.AddCMakePrefixPath("CMAKE_SYSTEM_PREFIX_PATH");
paths.AddCMakePath(var);
if (this->CMakePathName == "PROGRAM") {
paths.AddCMakePath("CMAKE_SYSTEM_APPBUNDLE_PATH");
} else {
paths.AddCMakePath("CMAKE_SYSTEM_FRAMEWORK_PATH");
}
paths.AddSuffixes(this->SearchPathSuffixes);
}
void cmFindBase::FillUserHintsPath()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::Hints];
for (std::string const& p : this->UserHintsArgs) {
paths.AddUserPath(p);
}
paths.AddSuffixes(this->SearchPathSuffixes);
}
void cmFindBase::FillUserGuessPath()
{
cmSearchPath& paths = this->LabeledPaths[PathLabel::Guess];
for (std::string const& p : this->UserGuessArgs) {
paths.AddUserPath(p);
}
paths.AddSuffixes(this->SearchPathSuffixes);
2006-02-27 21:38:22 +00:00
}
void cmFindBase::PrintFindStuff()
{
std::cerr << "SearchFrameworkLast: " << this->SearchFrameworkLast << "\n";
std::cerr << "SearchFrameworkOnly: " << this->SearchFrameworkOnly << "\n";
std::cerr << "SearchFrameworkFirst: " << this->SearchFrameworkFirst << "\n";
std::cerr << "SearchAppBundleLast: " << this->SearchAppBundleLast << "\n";
std::cerr << "SearchAppBundleOnly: " << this->SearchAppBundleOnly << "\n";
std::cerr << "SearchAppBundleFirst: " << this->SearchAppBundleFirst << "\n";
2006-02-27 21:38:22 +00:00
std::cerr << "VariableName " << this->VariableName << "\n";
std::cerr << "VariableDocumentation " << this->VariableDocumentation << "\n";
std::cerr << "NoDefaultPath " << this->NoDefaultPath << "\n";
std::cerr << "NoCMakeEnvironmentPath " << this->NoCMakeEnvironmentPath
<< "\n";
std::cerr << "NoCMakePath " << this->NoCMakePath << "\n";
std::cerr << "NoSystemEnvironmentPath " << this->NoSystemEnvironmentPath
<< "\n";
std::cerr << "NoCMakeSystemPath " << this->NoCMakeSystemPath << "\n";
2006-02-27 21:38:22 +00:00
std::cerr << "EnvironmentPath " << this->EnvironmentPath << "\n";
std::cerr << "CMakePathName " << this->CMakePathName << "\n";
2015-02-12 19:53:43 +00:00
std::cerr << "Names " << cmJoin(this->Names, " ") << "\n";
2006-02-27 21:38:22 +00:00
std::cerr << "\n";
std::cerr << "SearchPathSuffixes ";
2015-02-12 19:53:43 +00:00
std::cerr << cmJoin(this->SearchPathSuffixes, "\n") << "\n";
2006-02-27 21:38:22 +00:00
std::cerr << "SearchPaths\n";
2015-02-18 21:14:26 +00:00
std::cerr << cmWrap("[", this->SearchPaths, "]", "\n") << "\n";
2006-02-27 21:38:22 +00:00
}
bool cmFindBase::CheckForVariableInCache()
{
if (const char* cacheValue =
this->Makefile->GetDefinition(this->VariableName)) {
2015-04-06 08:52:45 +00:00
cmState* state = this->Makefile->GetState();
const char* cacheEntry = state->GetCacheEntryValue(this->VariableName);
bool found = !cmSystemTools::IsNOTFOUND(cacheValue);
2017-08-22 21:42:36 +00:00
bool cached = cacheEntry != nullptr;
if (found) {
// If the user specifies the entry on the command line without a
// type we should add the type and docstring but keep the
// original value. Tell the subclass implementations to do
// this.
if (cached &&
state->GetCacheEntryType(this->VariableName) ==
cmStateEnums::UNINITIALIZED) {
this->AlreadyInCacheWithoutMetaInfo = true;
2006-02-27 21:38:22 +00:00
}
return true;
2016-09-16 20:45:24 +00:00
}
if (cached) {
const char* hs =
state->GetCacheEntryProperty(this->VariableName, "HELPSTRING");
this->VariableDocumentation = hs ? hs : "(none)";
2006-02-27 21:38:22 +00:00
}
}
2006-02-27 21:38:22 +00:00
return false;
}