mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-04-29 02:19:18 -05:00
Code Issues Packages Projects Releases Wiki Activity

find_*: Add debug logging infrastructure

Browse Source 
Enable debug messages a new `--find-debug` command-line option or via
the `CMAKE_FIND_DEBUG_MODE` variable.

This work was started by Chris Wilson, continued by Ray Donnelly, and
then refactored by Robert Maynard to collect information into a single
message per find query.

Co-Author: Ray Donnelly <mingw.android@gmail.com>
Co-Author: Chris Wilson <chris+github@qwirx.com>
This commit is contained in:
Robert Maynard
2019-10-04 17:18:26 -04:00
parent 3289322e4f
commit a7ea20649d
11 changed files with 193 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/cmFindBase.cxx
+95 -36
View File
@@ -4,8 +4,8 @@
#include <cstddef>
#include <deque>
#include <iostream>
#include <map>
#include <utility>
#include "cmAlgorithms.h"
#include "cmMakefile.h"
@@ -116,17 +116,19 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
this->NoDefaultPath = true;
} else if (this->CheckCommonArgument(args[j])) {
doing = DoingNone;
} else {
// 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]);
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]);
}
}
}
@@ -288,33 +290,6 @@ void cmFindBase::FillUserGuessPath()
paths.AddSuffixes(this->SearchPathSuffixes);
}
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";
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";
std::cerr << "EnvironmentPath " << this->EnvironmentPath << "\n";
std::cerr << "CMakePathName " << this->CMakePathName << "\n";
std::cerr << "Names " << cmJoin(this->Names, " ") << "\n";
std::cerr << "\n";
std::cerr << "SearchPathSuffixes ";
std::cerr << cmJoin(this->SearchPathSuffixes, "\n") << "\n";
std::cerr << "SearchPaths\n";
std::cerr << cmWrap("[", this->SearchPaths, "]", "\n") << "\n";
}
bool cmFindBase::CheckForVariableInCache()
{
if (const char* cacheValue =
@@ -343,3 +318,87 @@ bool cmFindBase::CheckForVariableInCache()
}
return false;
}
cmFindBaseDebugState::cmFindBaseDebugState(std::string commandName,
cmFindBase const* findBase)
: FindCommand(findBase)
, CommandName(std::move(commandName))
{
}
cmFindBaseDebugState::~cmFindBaseDebugState()
{
if (this->FindCommand->DebugMode) {
std::string buffer =
cmStrCat(this->CommandName, " called with the following settings:\n");
buffer += cmStrCat(" VAR: ", this->FindCommand->VariableName, "\n");
buffer += cmStrCat(
" NAMES: ", cmWrap("\"", this->FindCommand->Names, "\"", "\n "),
"\n");
buffer += cmStrCat(
" Documentation: ", this->FindCommand->VariableDocumentation, "\n");
buffer += " Framework\n";
buffer += cmStrCat(" Only Search Frameworks: ",
this->FindCommand->SearchFrameworkOnly, "\n");
buffer += cmStrCat(" Search Frameworks Last: ",
this->FindCommand->SearchFrameworkLast, "\n");
buffer += cmStrCat(" Search Frameworks First: ",
this->FindCommand->SearchFrameworkFirst, "\n");
buffer += " AppBundle\n";
buffer += cmStrCat(" Only Search AppBundle: ",
this->FindCommand->SearchAppBundleOnly, "\n");
buffer += cmStrCat(" Search AppBundle Last: ",
this->FindCommand->SearchAppBundleLast, "\n");
buffer += cmStrCat(" Search AppBundle First: ",
this->FindCommand->SearchAppBundleFirst, "\n");
if (this->FindCommand->NoDefaultPath) {
buffer += " NO_DEFAULT_PATH Enabled\n";
} else {
buffer += cmStrCat(
" CMAKE_FIND_USE_CMAKE_PATH: ", !this->FindCommand->NoCMakePath, "\n",
" CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: ",
!this->FindCommand->NoCMakeEnvironmentPath, "\n",
" CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: ",
!this->FindCommand->NoSystemEnvironmentPath, "\n",
" CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: ",
!this->FindCommand->NoCMakeSystemPath, "\n");
}
buffer +=
cmStrCat(this->CommandName, " considered the following locations:\n");
for (auto const& state : this->FailedSearchLocations) {
std::string path = cmStrCat(" ", state.path);
if (!state.regexName.empty()) {
path = cmStrCat(path, "/", state.regexName);
}
buffer += cmStrCat(path, "\n");
}
if (!this->FoundSearchLocation.path.empty()) {
buffer += cmStrCat("The item was found at\n ",
this->FoundSearchLocation.path, "\n");
} else {
buffer += "The item was not found.\n";
}
this->FindCommand->DebugMessage(buffer);
}
}
void cmFindBaseDebugState::FoundAt(std::string const& path,
std::string regexName)
{
if (this->FindCommand->DebugMode) {
this->FoundSearchLocation = DebugLibState{ std::move(regexName), path };
}
}
void cmFindBaseDebugState::FailedAt(std::string const& path,
std::string regexName)
{
if (this->FindCommand->DebugMode) {
this->FailedSearchLocations.emplace_back(std::move(regexName), path);
}
}