1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
|
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file LICENSE.rst or https://cmake.org/licensing for details. */
#pragma once
#include "cmConfigure.h" // IWYU pragma: keep
#include <map>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
#include "cmPathLabel.h"
#include "cmSearchPath.h"
#include "cmWindowsRegistry.h"
class cmConfigureLog;
class cmFindCommonDebugState;
class cmExecutionStatus;
class cmMakefile;
/** \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:
cmFindCommon(cmExecutionStatus& status);
virtual ~cmFindCommon();
void SetError(std::string const& e);
bool DebugModeEnabled() const;
protected:
friend class cmSearchPath;
friend class cmFindBaseDebugState;
friend class cmFindCommonDebugState;
friend class cmFindPackageDebugState;
/** Used to define groups of path labels */
class PathGroup : public cmPathLabel
{
protected:
PathGroup();
public:
PathGroup(std::string const& label)
: cmPathLabel(label)
{
}
static PathGroup All;
};
/* Individual path types */
class PathLabel : public cmPathLabel
{
protected:
PathLabel();
public:
PathLabel(std::string const& label)
: cmPathLabel(label)
{
}
static PathLabel PackageRoot;
static PathLabel CMake;
static PathLabel CMakeEnvironment;
static PathLabel Hints;
static PathLabel SystemEnvironment;
static PathLabel CMakeSystem;
static PathLabel Guess;
};
enum RootPathMode
{
RootPathModeNever,
RootPathModeOnly,
RootPathModeBoth
};
virtual bool IsFound() const = 0;
virtual bool IsDefined() const = 0;
/** 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,
std::string* debugBuffer = nullptr);
/** Get ignored paths from CMAKE_[SYSTEM_]IGNORE_PATH variables. */
void GetIgnoredPaths(std::vector<std::string>& ignore);
void GetIgnoredPaths(std::set<std::string>& ignore);
/** Get ignored paths from CMAKE_[SYSTEM_]IGNORE_PREFIX_PATH variables. */
void GetIgnoredPrefixPaths(std::vector<std::string>& ignore);
void GetIgnoredPrefixPaths(std::set<std::string>& ignore);
/** Compute final search path list (reroot + trailing slash). */
enum class IgnorePaths
{
No,
Yes,
};
void ComputeFinalPaths(IgnorePaths ignorePaths,
std::string* debugBuffer = nullptr);
/** Compute the current default root path mode. */
void SelectDefaultRootPathMode();
/** Compute the current default bundle/framework search policy. */
void SelectDefaultMacMode();
/** Compute the current default search modes based on global variables. */
void SelectDefaultSearchModes();
/** The `InitialPass` functions of the child classes should set
this->FullDebugMode to the result of these. */
bool ComputeIfDebugModeWanted();
bool ComputeIfDebugModeWanted(std::string const& var);
/** The `InitialPass` functions of the child classes should not initialize
`DebugState` if there is not a debug mode wanted and these return `true`.
*/
bool ComputeIfImplicitDebugModeSuppressed();
// Path arguments prior to path manipulation routines
std::vector<std::string> UserHintsArgs;
std::vector<std::string> UserGuessArgs;
std::string CMakePathName;
RootPathMode FindRootPathMode;
bool CheckCommonArgument(std::string const& arg);
void AddPathSuffix(std::string const& arg);
void DebugMessage(std::string const& msg) const;
bool FullDebugMode;
std::unique_ptr<cmFindCommonDebugState> DebugState;
bool NoDefaultPath;
bool NoPackageRootPath;
bool NoCMakePath;
bool NoCMakeEnvironmentPath;
bool NoSystemEnvironmentPath;
bool NoCMakeSystemPath;
bool NoCMakeInstallPath;
cmWindowsRegistry::View RegistryView = cmWindowsRegistry::View::Target;
std::vector<std::string> SearchPathSuffixes;
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<cmSearchPath::PathWithPrefix> SearchPathsEmitted;
bool SearchFrameworkFirst;
bool SearchFrameworkOnly;
bool SearchFrameworkLast;
bool SearchAppBundleFirst;
bool SearchAppBundleOnly;
bool SearchAppBundleLast;
cmMakefile* Makefile;
cmExecutionStatus& Status;
};
class cmFindCommonDebugState
{
public:
cmFindCommonDebugState(std::string name, cmFindCommon const* findCommand);
virtual ~cmFindCommonDebugState() = default;
void FoundAt(std::string const& path, std::string regexName = std::string());
void FailedAt(std::string const& path,
std::string regexName = std::string());
void Write();
protected:
virtual void FoundAtImpl(std::string const& path, std::string regexName) = 0;
virtual void FailedAtImpl(std::string const& path,
std::string regexName) = 0;
virtual bool ShouldImplicitlyLogEvents() const;
virtual void WriteDebug() const = 0;
#ifndef CMAKE_BOOTSTRAP
virtual void WriteEvent(cmConfigureLog& log, cmMakefile const& mf) const = 0;
void WriteSearchVariables(cmConfigureLog& log, cmMakefile const& mf) const;
enum class VariableSource
{
String,
PathList,
EnvironmentList,
};
virtual std::vector<std::pair<VariableSource, std::string>>
ExtraSearchVariables() const;
#endif
cmFindCommon const* const FindCommand;
std::string const CommandName;
std::string const Mode;
bool HasBeenFound() const { return this->IsFound; }
private:
bool TrackSearchProgress() const;
bool IsFound{ false };
};
|