https://github.com/Kitware/CMake
Revision c1ad5118deb0eb52c2130e0fb3363f44c25bf42e authored by Brad King on 02 November 2018, 12:14:12 UTC, committed by Brad King on 02 November 2018, 12:14:12 UTC
Backport upstream curl commit 2c5ec339ea (Curl_follow: accept non-supported schemes for "fake" redirects, 2018-11-01) to get a fix to curl issue 3210, a regression in 7.62.0.
1 parent 03bf934
Tip revision: c1ad5118deb0eb52c2130e0fb3363f44c25bf42e authored by Brad King on 02 November 2018, 12:14:12 UTC
curl: backport upstream fix to 7.62.0 regression
curl: backport upstream fix to 7.62.0 regression
Tip revision: c1ad511
cmake.cxx
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
file Copyright.txt or https://cmake.org/licensing for details. */
#include "cmake.h"
#include "cmAlgorithms.h"
#include "cmCommands.h"
#include "cmDocumentation.h"
#include "cmDocumentationEntry.h"
#include "cmDocumentationFormatter.h"
#include "cmDuration.h"
#include "cmExternalMakefileProjectGenerator.h"
#include "cmFileTimeComparison.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalGenerator.h"
#include "cmGlobalGeneratorFactory.h"
#include "cmLinkLineComputer.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmMessenger.h"
#include "cmState.h"
#include "cmStateDirectory.h"
#include "cmSystemTools.h"
#include "cmTarget.h"
#include "cmTargetLinkLibraryType.h"
#include "cmUtils.hxx"
#include "cmVersionConfig.h"
#include "cmWorkingDirectory.h"
#include "cm_sys_stat.h"
#if defined(CMAKE_BUILD_WITH_CMAKE)
# include "cm_jsoncpp_writer.h"
# include "cmGraphVizWriter.h"
# include "cmVariableWatch.h"
# include <unordered_map>
#endif
#if defined(CMAKE_BUILD_WITH_CMAKE)
# define CMAKE_USE_ECLIPSE
#endif
#if defined(__MINGW32__) && !defined(CMAKE_BUILD_WITH_CMAKE)
# define CMAKE_BOOT_MINGW
#endif
// include the generator
#if defined(_WIN32) && !defined(__CYGWIN__)
# if !defined(CMAKE_BOOT_MINGW)
# include "cmGlobalBorlandMakefileGenerator.h"
# include "cmGlobalGhsMultiGenerator.h"
# include "cmGlobalJOMMakefileGenerator.h"
# include "cmGlobalNMakeMakefileGenerator.h"
# include "cmGlobalVisualStudio10Generator.h"
# include "cmGlobalVisualStudio11Generator.h"
# include "cmGlobalVisualStudio12Generator.h"
# include "cmGlobalVisualStudio14Generator.h"
# include "cmGlobalVisualStudio15Generator.h"
# include "cmGlobalVisualStudio9Generator.h"
# include "cmVSSetupHelper.h"
# define CMAKE_HAVE_VS_GENERATORS
# endif
# include "cmGlobalMSYSMakefileGenerator.h"
# include "cmGlobalMinGWMakefileGenerator.h"
#else
#endif
#if defined(CMAKE_USE_WMAKE)
# include "cmGlobalWatcomWMakeGenerator.h"
#endif
#include "cmGlobalUnixMakefileGenerator3.h"
#if defined(CMAKE_BUILD_WITH_CMAKE)
# include "cmGlobalNinjaGenerator.h"
#endif
#include "cmExtraCodeLiteGenerator.h"
#if !defined(CMAKE_BOOT_MINGW)
# include "cmExtraCodeBlocksGenerator.h"
#endif
#include "cmExtraKateGenerator.h"
#include "cmExtraSublimeTextGenerator.h"
#ifdef CMAKE_USE_ECLIPSE
# include "cmExtraEclipseCDT4Generator.h"
#endif
#if defined(__APPLE__)
# if defined(CMAKE_BUILD_WITH_CMAKE)
# include "cmGlobalXCodeGenerator.h"
# define CMAKE_USE_XCODE 1
# endif
# include <sys/resource.h>
# include <sys/time.h>
#endif
#include "cmsys/FStream.hxx"
#include "cmsys/Glob.hxx"
#include "cmsys/RegularExpression.hxx"
#include <algorithm>
#include <cstring>
#include <iostream>
#include <iterator>
#include <memory> // IWYU pragma: keep
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <utility>
namespace {
#if defined(CMAKE_BUILD_WITH_CMAKE)
typedef std::unordered_map<std::string, Json::Value> JsonValueMapType;
#endif
} // namespace
static bool cmakeCheckStampFile(const char* stampName, bool verbose = true);
static bool cmakeCheckStampList(const char* stampList, bool verbose = true);
void cmWarnUnusedCliWarning(const std::string& variable, int /*unused*/,
void* ctx, const char* /*unused*/,
const cmMakefile* /*unused*/)
{
cmake* cm = reinterpret_cast<cmake*>(ctx);
cm->MarkCliAsUsed(variable);
}
cmake::cmake(Role role)
{
this->Trace = false;
this->TraceExpand = false;
this->WarnUninitialized = false;
this->WarnUnused = false;
this->WarnUnusedCli = true;
this->CheckSystemVars = false;
this->DebugOutput = false;
this->DebugTryCompile = false;
this->ClearBuildSystem = false;
this->FileComparison = new cmFileTimeComparison;
this->State = new cmState;
this->CurrentSnapshot = this->State->CreateBaseSnapshot();
this->Messenger = new cmMessenger(this->State);
#ifdef __APPLE__
struct rlimit rlp;
if (!getrlimit(RLIMIT_STACK, &rlp)) {
if (rlp.rlim_cur != rlp.rlim_max) {
rlp.rlim_cur = rlp.rlim_max;
setrlimit(RLIMIT_STACK, &rlp);
}
}
#endif
this->GlobalGenerator = nullptr;
this->ProgressCallback = nullptr;
this->ProgressCallbackClientData = nullptr;
this->CurrentWorkingMode = NORMAL_MODE;
#ifdef CMAKE_BUILD_WITH_CMAKE
this->VariableWatch = new cmVariableWatch;
#endif
this->AddDefaultGenerators();
this->AddDefaultExtraGenerators();
if (role == RoleScript || role == RoleProject) {
this->AddScriptingCommands();
}
if (role == RoleProject) {
this->AddProjectCommands();
}
// Make sure we can capture the build tool output.
cmSystemTools::EnableVSConsoleOutput();
// Set up a list of source and header extensions
// these are used to find files when the extension
// is not given
// The "c" extension MUST precede the "C" extension.
this->SourceFileExtensions.push_back("c");
this->SourceFileExtensions.push_back("C");
this->SourceFileExtensions.push_back("c++");
this->SourceFileExtensions.push_back("cc");
this->SourceFileExtensions.push_back("cpp");
this->SourceFileExtensions.push_back("cxx");
this->SourceFileExtensions.push_back("cu");
this->SourceFileExtensions.push_back("m");
this->SourceFileExtensions.push_back("M");
this->SourceFileExtensions.push_back("mm");
std::copy(this->SourceFileExtensions.begin(),
this->SourceFileExtensions.end(),
std::inserter(this->SourceFileExtensionsSet,
this->SourceFileExtensionsSet.end()));
this->HeaderFileExtensions.push_back("h");
this->HeaderFileExtensions.push_back("hh");
this->HeaderFileExtensions.push_back("h++");
this->HeaderFileExtensions.push_back("hm");
this->HeaderFileExtensions.push_back("hpp");
this->HeaderFileExtensions.push_back("hxx");
this->HeaderFileExtensions.push_back("in");
this->HeaderFileExtensions.push_back("txx");
std::copy(this->HeaderFileExtensions.begin(),
this->HeaderFileExtensions.end(),
std::inserter(this->HeaderFileExtensionsSet,
this->HeaderFileExtensionsSet.end()));
}
cmake::~cmake()
{
delete this->State;
delete this->Messenger;
if (this->GlobalGenerator) {
delete this->GlobalGenerator;
this->GlobalGenerator = nullptr;
}
cmDeleteAll(this->Generators);
#ifdef CMAKE_BUILD_WITH_CMAKE
delete this->VariableWatch;
#endif
delete this->FileComparison;
}
#if defined(CMAKE_BUILD_WITH_CMAKE)
Json::Value cmake::ReportVersionJson() const
{
Json::Value version = Json::objectValue;
version["string"] = CMake_VERSION;
version["major"] = CMake_VERSION_MAJOR;
version["minor"] = CMake_VERSION_MINOR;
version["suffix"] = CMake_VERSION_SUFFIX;
version["isDirty"] = (CMake_VERSION_IS_DIRTY == 1);
version["patch"] = CMake_VERSION_PATCH;
return version;
}
Json::Value cmake::ReportCapabilitiesJson(bool haveServerMode) const
{
Json::Value obj = Json::objectValue;
// Version information:
obj["version"] = this->ReportVersionJson();
// Generators:
std::vector<cmake::GeneratorInfo> generatorInfoList;
this->GetRegisteredGenerators(generatorInfoList);
JsonValueMapType generatorMap;
for (cmake::GeneratorInfo const& gi : generatorInfoList) {
if (gi.isAlias) { // skip aliases, they are there for compatibility reasons
// only
continue;
}
if (gi.extraName.empty()) {
Json::Value gen = Json::objectValue;
gen["name"] = gi.name;
gen["toolsetSupport"] = gi.supportsToolset;
gen["platformSupport"] = gi.supportsPlatform;
gen["extraGenerators"] = Json::arrayValue;
generatorMap[gi.name] = gen;
} else {
Json::Value& gen = generatorMap[gi.baseName];
gen["extraGenerators"].append(gi.extraName);
}
}
Json::Value generators = Json::arrayValue;
for (auto const& i : generatorMap) {
generators.append(i.second);
}
obj["generators"] = generators;
obj["serverMode"] = haveServerMode;
return obj;
}
#endif
std::string cmake::ReportCapabilities(bool haveServerMode) const
{
std::string result;
#if defined(CMAKE_BUILD_WITH_CMAKE)
Json::FastWriter writer;
result = writer.write(this->ReportCapabilitiesJson(haveServerMode));
#else
result = "Not supported";
#endif
return result;
}
void cmake::CleanupCommandsAndMacros()
{
this->CurrentSnapshot = this->State->Reset();
this->State->RemoveUserDefinedCommands();
this->CurrentSnapshot.SetDefaultDefinitions();
}
// Parse the args
bool cmake::SetCacheArgs(const std::vector<std::string>& args)
{
bool findPackageMode = false;
for (unsigned int i = 1; i < args.size(); ++i) {
std::string const& arg = args[i];
if (arg.find("-D", 0) == 0) {
std::string entry = arg.substr(2);
if (entry.empty()) {
++i;
if (i < args.size()) {
entry = args[i];
} else {
cmSystemTools::Error("-D must be followed with VAR=VALUE.");
return false;
}
}
std::string var, value;
cmStateEnums::CacheEntryType type = cmStateEnums::UNINITIALIZED;
if (cmState::ParseCacheEntry(entry, var, value, type)) {
// The value is transformed if it is a filepath for example, so
// we can't compare whether the value is already in the cache until
// after we call AddCacheEntry.
bool haveValue = false;
std::string cachedValue;
if (this->WarnUnusedCli) {
if (const std::string* v =
this->State->GetInitializedCacheValue(var)) {
haveValue = true;
cachedValue = *v;
}
}
this->AddCacheEntry(var, value.c_str(),
"No help, variable specified on the command line.",
type);
if (this->WarnUnusedCli) {
if (!haveValue ||
cachedValue != *this->State->GetInitializedCacheValue(var)) {
this->WatchUnusedCli(var);
}
}
} else {
std::cerr << "Parse error in command line argument: " << arg << "\n"
<< "Should be: VAR:type=value\n";
cmSystemTools::Error("No cmake script provided.");
return false;
}
} else if (cmHasLiteralPrefix(arg, "-W")) {
std::string entry = arg.substr(2);
if (entry.empty()) {
++i;
if (i < args.size()) {
entry = args[i];
} else {
cmSystemTools::Error("-W must be followed with [no-]<name>.");
return false;
}
}
std::string name;
bool foundNo = false;
bool foundError = false;
unsigned int nameStartPosition = 0;
if (entry.find("no-", nameStartPosition) == 0) {
foundNo = true;
nameStartPosition += 3;
}
if (entry.find("error=", nameStartPosition) == 0) {
foundError = true;
nameStartPosition += 6;
}
name = entry.substr(nameStartPosition);
if (name.empty()) {
cmSystemTools::Error("No warning name provided.");
return false;
}
if (!foundNo && !foundError) {
// -W<name>
this->DiagLevels[name] = std::max(this->DiagLevels[name], DIAG_WARN);
} else if (foundNo && !foundError) {
// -Wno<name>
this->DiagLevels[name] = DIAG_IGNORE;
} else if (!foundNo && foundError) {
// -Werror=<name>
this->DiagLevels[name] = DIAG_ERROR;
} else {
// -Wno-error=<name>
this->DiagLevels[name] = std::min(this->DiagLevels[name], DIAG_WARN);
}
} else if (arg.find("-U", 0) == 0) {
std::string entryPattern = arg.substr(2);
if (entryPattern.empty()) {
++i;
if (i < args.size()) {
entryPattern = args[i];
} else {
cmSystemTools::Error("-U must be followed with VAR.");
return false;
}
}
cmsys::RegularExpression regex(
cmsys::Glob::PatternToRegex(entryPattern, true, true).c_str());
// go through all cache entries and collect the vars which will be
// removed
std::vector<std::string> entriesToDelete;
std::vector<std::string> cacheKeys = this->State->GetCacheEntryKeys();
for (std::string const& ck : cacheKeys) {
cmStateEnums::CacheEntryType t = this->State->GetCacheEntryType(ck);
if (t != cmStateEnums::STATIC) {
if (regex.find(ck)) {
entriesToDelete.push_back(ck);
}
}
}
// now remove them from the cache
for (std::string const& currentEntry : entriesToDelete) {
this->State->RemoveCacheEntry(currentEntry);
}
} else if (arg.find("-C", 0) == 0) {
std::string path = arg.substr(2);
if (path.empty()) {
++i;
if (i < args.size()) {
path = args[i];
} else {
cmSystemTools::Error("-C must be followed by a file name.");
return false;
}
}
std::cout << "loading initial cache file " << path << "\n";
this->ReadListFile(args, path.c_str());
} else if (arg.find("-P", 0) == 0) {
i++;
if (i >= args.size()) {
cmSystemTools::Error("-P must be followed by a file name.");
return false;
}
std::string path = args[i];
if (path.empty()) {
cmSystemTools::Error("No cmake script provided.");
return false;
}
// Register fake project commands that hint misuse in script mode.
GetProjectCommandsInScriptMode(this->State);
this->ReadListFile(args, path.c_str());
} else if (arg.find("--find-package", 0) == 0) {
findPackageMode = true;
}
}
if (findPackageMode) {
return this->FindPackage(args);
}
return true;
}
void cmake::ReadListFile(const std::vector<std::string>& args,
const char* path)
{
// if a generator was not yet created, temporarily create one
cmGlobalGenerator* gg = this->GetGlobalGenerator();
bool created = false;
// if a generator was not specified use a generic one
if (!gg) {
gg = new cmGlobalGenerator(this);
created = true;
}
// read in the list file to fill the cache
if (path) {
this->CurrentSnapshot = this->State->Reset();
std::string homeDir = this->GetHomeDirectory();
std::string homeOutputDir = this->GetHomeOutputDirectory();
this->SetHomeDirectory(cmSystemTools::GetCurrentWorkingDirectory());
this->SetHomeOutputDirectory(cmSystemTools::GetCurrentWorkingDirectory());
cmStateSnapshot snapshot = this->GetCurrentSnapshot();
snapshot.GetDirectory().SetCurrentBinary(
cmSystemTools::GetCurrentWorkingDirectory());
snapshot.GetDirectory().SetCurrentSource(
cmSystemTools::GetCurrentWorkingDirectory());
snapshot.SetDefaultDefinitions();
cmMakefile mf(gg, snapshot);
if (this->GetWorkingMode() != NORMAL_MODE) {
std::string file(cmSystemTools::CollapseFullPath(path));
cmSystemTools::ConvertToUnixSlashes(file);
mf.SetScriptModeFile(file);
mf.SetArgcArgv(args);
}
if (!mf.ReadListFile(path)) {
cmSystemTools::Error("Error processing file: ", path);
}
this->SetHomeDirectory(homeDir);
this->SetHomeOutputDirectory(homeOutputDir);
}
// free generic one if generated
if (created) {
delete gg;
}
}
bool cmake::FindPackage(const std::vector<std::string>& args)
{
this->SetHomeDirectory(cmSystemTools::GetCurrentWorkingDirectory());
this->SetHomeOutputDirectory(cmSystemTools::GetCurrentWorkingDirectory());
// if a generator was not yet created, temporarily create one
cmGlobalGenerator* gg = new cmGlobalGenerator(this);
this->SetGlobalGenerator(gg);
cmStateSnapshot snapshot = this->GetCurrentSnapshot();
snapshot.GetDirectory().SetCurrentBinary(
cmSystemTools::GetCurrentWorkingDirectory());
snapshot.GetDirectory().SetCurrentSource(
cmSystemTools::GetCurrentWorkingDirectory());
// read in the list file to fill the cache
snapshot.SetDefaultDefinitions();
cmMakefile* mf = new cmMakefile(gg, snapshot);
gg->AddMakefile(mf);
mf->SetArgcArgv(args);
std::string systemFile = mf->GetModulesFile("CMakeFindPackageMode.cmake");
mf->ReadListFile(systemFile.c_str());
std::string language = mf->GetSafeDefinition("LANGUAGE");
std::string mode = mf->GetSafeDefinition("MODE");
std::string packageName = mf->GetSafeDefinition("NAME");
bool packageFound = mf->IsOn("PACKAGE_FOUND");
bool quiet = mf->IsOn("PACKAGE_QUIET");
if (!packageFound) {
if (!quiet) {
printf("%s not found.\n", packageName.c_str());
}
} else if (mode == "EXIST") {
if (!quiet) {
printf("%s found.\n", packageName.c_str());
}
} else if (mode == "COMPILE") {
std::string includes = mf->GetSafeDefinition("PACKAGE_INCLUDE_DIRS");
std::vector<std::string> includeDirs;
cmSystemTools::ExpandListArgument(includes, includeDirs);
gg->CreateGenerationObjects();
cmLocalGenerator* lg = gg->LocalGenerators[0];
std::string includeFlags =
lg->GetIncludeFlags(includeDirs, nullptr, language);
std::string definitions = mf->GetSafeDefinition("PACKAGE_DEFINITIONS");
printf("%s %s\n", includeFlags.c_str(), definitions.c_str());
} else if (mode == "LINK") {
const char* targetName = "dummy";
std::vector<std::string> srcs;
cmTarget* tgt = mf->AddExecutable(targetName, srcs, true);
tgt->SetProperty("LINKER_LANGUAGE", language.c_str());
std::string libs = mf->GetSafeDefinition("PACKAGE_LIBRARIES");
std::vector<std::string> libList;
cmSystemTools::ExpandListArgument(libs, libList);
for (std::string const& lib : libList) {
tgt->AddLinkLibrary(*mf, lib, GENERAL_LibraryType);
}
std::string buildType = mf->GetSafeDefinition("CMAKE_BUILD_TYPE");
buildType = cmSystemTools::UpperCase(buildType);
std::string linkLibs;
std::string frameworkPath;
std::string linkPath;
std::string flags;
std::string linkFlags;
gg->CreateGenerationObjects();
cmGeneratorTarget* gtgt = gg->FindGeneratorTarget(tgt->GetName());
cmLocalGenerator* lg = gtgt->GetLocalGenerator();
cmLinkLineComputer linkLineComputer(lg,
lg->GetStateSnapshot().GetDirectory());
lg->GetTargetFlags(&linkLineComputer, buildType, linkLibs, flags,
linkFlags, frameworkPath, linkPath, gtgt);
linkLibs = frameworkPath + linkPath + linkLibs;
printf("%s\n", linkLibs.c_str());
/* if ( use_win32 )
{
tgt->SetProperty("WIN32_EXECUTABLE", "ON");
}
if ( use_macbundle)
{
tgt->SetProperty("MACOSX_BUNDLE", "ON");
}*/
}
// free generic one if generated
// this->SetGlobalGenerator(0); // setting 0-pointer is not possible
// delete gg; // this crashes inside the cmake instance
return packageFound;
}
// Parse the args
void cmake::SetArgs(const std::vector<std::string>& args,
bool directoriesSetBefore)
{
bool directoriesSet = directoriesSetBefore;
bool haveToolset = false;
bool havePlatform = false;
for (unsigned int i = 1; i < args.size(); ++i) {
std::string const& arg = args[i];
if (arg.find("-H", 0) == 0 || arg.find("-S", 0) == 0) {
directoriesSet = true;
std::string path = arg.substr(2);
if (path.empty()) {
++i;
if (i >= args.size()) {
cmSystemTools::Error("No source directory specified for -S");
return;
}
path = args[i];
if (path[0] == '-') {
cmSystemTools::Error("No source directory specified for -S");
return;
}
}
path = cmSystemTools::CollapseFullPath(path);
cmSystemTools::ConvertToUnixSlashes(path);
this->SetHomeDirectory(path);
} else if (arg.find("-O", 0) == 0) {
// There is no local generate anymore. Ignore -O option.
} else if (arg.find("-B", 0) == 0) {
directoriesSet = true;
std::string path = arg.substr(2);
if (path.empty()) {
++i;
if (i >= args.size()) {
cmSystemTools::Error("No build directory specified for -B");
return;
}
path = args[i];
if (path[0] == '-') {
cmSystemTools::Error("No build directory specified for -B");
return;
}
}
path = cmSystemTools::CollapseFullPath(path);
cmSystemTools::ConvertToUnixSlashes(path);
this->SetHomeOutputDirectory(path);
} else if ((i < args.size() - 2) &&
(arg.find("--check-build-system", 0) == 0)) {
this->CheckBuildSystemArgument = args[++i];
this->ClearBuildSystem = (atoi(args[++i].c_str()) > 0);
} else if ((i < args.size() - 1) &&
(arg.find("--check-stamp-file", 0) == 0)) {
this->CheckStampFile = args[++i];
} else if ((i < args.size() - 1) &&
(arg.find("--check-stamp-list", 0) == 0)) {
this->CheckStampList = args[++i];
}
#if defined(CMAKE_HAVE_VS_GENERATORS)
else if ((i < args.size() - 1) &&
(arg.find("--vs-solution-file", 0) == 0)) {
this->VSSolutionFile = args[++i];
}
#endif
else if (arg.find("-D", 0) == 0) {
// skip for now
} else if (arg.find("-U", 0) == 0) {
// skip for now
} else if (arg.find("-C", 0) == 0) {
// skip for now
} else if (arg.find("-P", 0) == 0) {
// skip for now
i++;
} else if (arg.find("--find-package", 0) == 0) {
// skip for now
i++;
} else if (arg.find("-W", 0) == 0) {
// skip for now
} else if (arg.find("--graphviz=", 0) == 0) {
std::string path = arg.substr(strlen("--graphviz="));
path = cmSystemTools::CollapseFullPath(path);
cmSystemTools::ConvertToUnixSlashes(path);
this->GraphVizFile = path;
if (this->GraphVizFile.empty()) {
cmSystemTools::Error("No file specified for --graphviz");
}
} else if (arg.find("--debug-trycompile", 0) == 0) {
std::cout << "debug trycompile on\n";
this->DebugTryCompileOn();
} else if (arg.find("--debug-output", 0) == 0) {
std::cout << "Running with debug output on.\n";
this->SetDebugOutputOn(true);
} else if (arg.find("--trace-expand", 0) == 0) {
std::cout << "Running with expanded trace output on.\n";
this->SetTrace(true);
this->SetTraceExpand(true);
} else if (arg.find("--trace-source=", 0) == 0) {
std::string file = arg.substr(strlen("--trace-source="));
cmSystemTools::ConvertToUnixSlashes(file);
this->AddTraceSource(file);
this->SetTrace(true);
} else if (arg.find("--trace", 0) == 0) {
std::cout << "Running with trace output on.\n";
this->SetTrace(true);
this->SetTraceExpand(false);
} else if (arg.find("--warn-uninitialized", 0) == 0) {
std::cout << "Warn about uninitialized values.\n";
this->SetWarnUninitialized(true);
} else if (arg.find("--warn-unused-vars", 0) == 0) {
std::cout << "Finding unused variables.\n";
this->SetWarnUnused(true);
} else if (arg.find("--no-warn-unused-cli", 0) == 0) {
std::cout << "Not searching for unused variables given on the "
<< "command line.\n";
this->SetWarnUnusedCli(false);
} else if (arg.find("--check-system-vars", 0) == 0) {
std::cout << "Also check system files when warning about unused and "
<< "uninitialized variables.\n";
this->SetCheckSystemVars(true);
} else if (arg.find("-A", 0) == 0) {
std::string value = arg.substr(2);
if (value.empty()) {
++i;
if (i >= args.size()) {
cmSystemTools::Error("No platform specified for -A");
return;
}
value = args[i];
}
if (havePlatform) {
cmSystemTools::Error("Multiple -A options not allowed");
return;
}
this->GeneratorPlatform = value;
havePlatform = true;
} else if (arg.find("-T", 0) == 0) {
std::string value = arg.substr(2);
if (value.empty()) {
++i;
if (i >= args.size()) {
cmSystemTools::Error("No toolset specified for -T");
return;
}
value = args[i];
}
if (haveToolset) {
cmSystemTools::Error("Multiple -T options not allowed");
return;
}
this->GeneratorToolset = value;
haveToolset = true;
} else if (arg.find("-G", 0) == 0) {
std::string value = arg.substr(2);
if (value.empty()) {
++i;
if (i >= args.size()) {
cmSystemTools::Error("No generator specified for -G");
this->PrintGeneratorList();
return;
}
value = args[i];
}
cmGlobalGenerator* gen = this->CreateGlobalGenerator(value);
if (!gen) {
const char* kdevError = nullptr;
if (value.find("KDevelop3", 0) != std::string::npos) {
kdevError = "\nThe KDevelop3 generator is not supported anymore.";
}
cmSystemTools::Error("Could not create named generator ",
value.c_str(), kdevError);
this->PrintGeneratorList();
} else {
this->SetGlobalGenerator(gen);
}
}
// no option assume it is the path to the source
else {
directoriesSet = true;
this->SetDirectoriesFromFile(arg.c_str());
}
}
if (!directoriesSet) {
this->SetHomeOutputDirectory(cmSystemTools::GetCurrentWorkingDirectory());
this->SetHomeDirectory(cmSystemTools::GetCurrentWorkingDirectory());
}
}
void cmake::SetDirectoriesFromFile(const char* arg)
{
// Check if the argument refers to a CMakeCache.txt or
// CMakeLists.txt file.
std::string listPath;
std::string cachePath;
bool argIsFile = false;
if (cmSystemTools::FileIsDirectory(arg)) {
std::string path = cmSystemTools::CollapseFullPath(arg);
cmSystemTools::ConvertToUnixSlashes(path);
std::string cacheFile = path;
cacheFile += "/CMakeCache.txt";
std::string listFile = path;
listFile += "/CMakeLists.txt";
if (cmSystemTools::FileExists(cacheFile)) {
cachePath = path;
}
if (cmSystemTools::FileExists(listFile)) {
listPath = path;
}
} else if (cmSystemTools::FileExists(arg)) {
argIsFile = true;
std::string fullPath = cmSystemTools::CollapseFullPath(arg);
std::string name = cmSystemTools::GetFilenameName(fullPath);
name = cmSystemTools::LowerCase(name);
if (name == "cmakecache.txt") {
cachePath = cmSystemTools::GetFilenamePath(fullPath);
} else if (name == "cmakelists.txt") {
listPath = cmSystemTools::GetFilenamePath(fullPath);
}
} else {
// Specified file or directory does not exist. Try to set things
// up to produce a meaningful error message.
std::string fullPath = cmSystemTools::CollapseFullPath(arg);
std::string name = cmSystemTools::GetFilenameName(fullPath);
name = cmSystemTools::LowerCase(name);
if (name == "cmakecache.txt" || name == "cmakelists.txt") {
argIsFile = true;
listPath = cmSystemTools::GetFilenamePath(fullPath);
} else {
listPath = fullPath;
}
}
// If there is a CMakeCache.txt file, use its settings.
if (!cachePath.empty()) {
if (this->LoadCache(cachePath)) {
const char* existingValue =
this->State->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
if (existingValue) {
this->SetHomeOutputDirectory(cachePath);
this->SetHomeDirectory(existingValue);
return;
}
}
}
// If there is a CMakeLists.txt file, use it as the source tree.
if (!listPath.empty()) {
this->SetHomeDirectory(listPath);
if (argIsFile) {
// Source CMakeLists.txt file given. It was probably dropped
// onto the executable in a GUI. Default to an in-source build.
this->SetHomeOutputDirectory(listPath);
} else {
// Source directory given on command line. Use current working
// directory as build tree if -B hasn't been given already
if (this->GetHomeOutputDirectory().empty()) {
std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
this->SetHomeOutputDirectory(cwd);
}
}
return;
}
if (this->GetHomeDirectory().empty()) {
// We didn't find a CMakeLists.txt and it wasn't specified
// with -S. Assume it is the path to the source tree
std::string full = cmSystemTools::CollapseFullPath(arg);
this->SetHomeDirectory(full);
}
if (this->GetHomeOutputDirectory().empty()) {
// We didn't find a CMakeCache.txt and it wasn't specified
// with -B. Assume the current working directory as the build tree.
std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
this->SetHomeOutputDirectory(cwd);
}
}
// at the end of this CMAKE_ROOT and CMAKE_COMMAND should be added to the
// cache
int cmake::AddCMakePaths()
{
// Save the value in the cache
this->AddCacheEntry("CMAKE_COMMAND",
cmSystemTools::GetCMakeCommand().c_str(),
"Path to CMake executable.", cmStateEnums::INTERNAL);
#ifdef CMAKE_BUILD_WITH_CMAKE
this->AddCacheEntry(
"CMAKE_CTEST_COMMAND", cmSystemTools::GetCTestCommand().c_str(),
"Path to ctest program executable.", cmStateEnums::INTERNAL);
this->AddCacheEntry(
"CMAKE_CPACK_COMMAND", cmSystemTools::GetCPackCommand().c_str(),
"Path to cpack program executable.", cmStateEnums::INTERNAL);
#endif
if (!cmSystemTools::FileExists(
(cmSystemTools::GetCMakeRoot() + "/Modules/CMake.cmake"))) {
// couldn't find modules
cmSystemTools::Error(
"Could not find CMAKE_ROOT !!!\n"
"CMake has most likely not been installed correctly.\n"
"Modules directory not found in\n",
cmSystemTools::GetCMakeRoot().c_str());
return 0;
}
this->AddCacheEntry("CMAKE_ROOT", cmSystemTools::GetCMakeRoot().c_str(),
"Path to CMake installation.", cmStateEnums::INTERNAL);
return 1;
}
void cmake::AddDefaultExtraGenerators()
{
#if defined(CMAKE_BUILD_WITH_CMAKE)
this->ExtraGenerators.push_back(cmExtraCodeBlocksGenerator::GetFactory());
this->ExtraGenerators.push_back(cmExtraCodeLiteGenerator::GetFactory());
this->ExtraGenerators.push_back(cmExtraSublimeTextGenerator::GetFactory());
this->ExtraGenerators.push_back(cmExtraKateGenerator::GetFactory());
# ifdef CMAKE_USE_ECLIPSE
this->ExtraGenerators.push_back(cmExtraEclipseCDT4Generator::GetFactory());
# endif
#endif
}
void cmake::GetRegisteredGenerators(
std::vector<GeneratorInfo>& generators) const
{
for (cmGlobalGeneratorFactory* gen : this->Generators) {
std::vector<std::string> names;
gen->GetGenerators(names);
for (std::string const& name : names) {
GeneratorInfo info;
info.supportsToolset = gen->SupportsToolset();
info.supportsPlatform = gen->SupportsPlatform();
info.name = name;
info.baseName = name;
info.isAlias = false;
generators.push_back(std::move(info));
}
}
for (cmExternalMakefileProjectGeneratorFactory* eg : this->ExtraGenerators) {
const std::vector<std::string> genList =
eg->GetSupportedGlobalGenerators();
for (std::string const& gen : genList) {
GeneratorInfo info;
info.name = cmExternalMakefileProjectGenerator::CreateFullGeneratorName(
gen, eg->GetName());
info.baseName = gen;
info.extraName = eg->GetName();
info.supportsPlatform = false;
info.supportsToolset = false;
info.isAlias = false;
generators.push_back(std::move(info));
}
for (std::string const& a : eg->Aliases) {
GeneratorInfo info;
info.name = a;
if (!genList.empty()) {
info.baseName = genList.at(0);
}
info.extraName = eg->GetName();
info.supportsPlatform = false;
info.supportsToolset = false;
info.isAlias = true;
generators.push_back(std::move(info));
}
}
}
static std::pair<cmExternalMakefileProjectGenerator*, std::string>
createExtraGenerator(
const std::vector<cmExternalMakefileProjectGeneratorFactory*>& in,
const std::string& name)
{
for (cmExternalMakefileProjectGeneratorFactory* i : in) {
const std::vector<std::string> generators =
i->GetSupportedGlobalGenerators();
if (i->GetName() == name) { // Match aliases
return std::make_pair(i->CreateExternalMakefileProjectGenerator(),
generators.at(0));
}
for (std::string const& g : generators) {
const std::string fullName =
cmExternalMakefileProjectGenerator::CreateFullGeneratorName(
g, i->GetName());
if (fullName == name) {
return std::make_pair(i->CreateExternalMakefileProjectGenerator(), g);
}
}
}
return std::make_pair(
static_cast<cmExternalMakefileProjectGenerator*>(nullptr), name);
}
cmGlobalGenerator* cmake::CreateGlobalGenerator(const std::string& gname)
{
std::pair<cmExternalMakefileProjectGenerator*, std::string> extra =
createExtraGenerator(this->ExtraGenerators, gname);
cmExternalMakefileProjectGenerator* extraGenerator = extra.first;
const std::string name = extra.second;
cmGlobalGenerator* generator = nullptr;
for (cmGlobalGeneratorFactory* g : this->Generators) {
generator = g->CreateGlobalGenerator(name, this);
if (generator) {
break;
}
}
if (generator) {
generator->SetExternalMakefileProjectGenerator(extraGenerator);
} else {
delete extraGenerator;
}
return generator;
}
void cmake::SetHomeDirectory(const std::string& dir)
{
this->State->SetSourceDirectory(dir);
if (this->CurrentSnapshot.IsValid()) {
this->CurrentSnapshot.SetDefinition("CMAKE_SOURCE_DIR", dir);
}
}
std::string const& cmake::GetHomeDirectory() const
{
return this->State->GetSourceDirectory();
}
void cmake::SetHomeOutputDirectory(const std::string& dir)
{
this->State->SetBinaryDirectory(dir);
if (this->CurrentSnapshot.IsValid()) {
this->CurrentSnapshot.SetDefinition("CMAKE_BINARY_DIR", dir);
}
}
std::string const& cmake::GetHomeOutputDirectory() const
{
return this->State->GetBinaryDirectory();
}
std::string cmake::FindCacheFile(const std::string& binaryDir)
{
std::string cachePath = binaryDir;
cmSystemTools::ConvertToUnixSlashes(cachePath);
std::string cacheFile = cachePath;
cacheFile += "/CMakeCache.txt";
if (!cmSystemTools::FileExists(cacheFile)) {
// search in parent directories for cache
std::string cmakeFiles = cachePath;
cmakeFiles += "/CMakeFiles";
if (cmSystemTools::FileExists(cmakeFiles)) {
std::string cachePathFound =
cmSystemTools::FileExistsInParentDirectories("CMakeCache.txt",
cachePath.c_str(), "/");
if (!cachePathFound.empty()) {
cachePath = cmSystemTools::GetFilenamePath(cachePathFound);
}
}
}
return cachePath;
}
void cmake::SetGlobalGenerator(cmGlobalGenerator* gg)
{
if (!gg) {
cmSystemTools::Error("Error SetGlobalGenerator called with null");
return;
}
// delete the old generator
if (this->GlobalGenerator) {
delete this->GlobalGenerator;
// restore the original environment variables CXX and CC
// Restore CC
std::string env = "CC=";
if (!this->CCEnvironment.empty()) {
env += this->CCEnvironment;
}
cmSystemTools::PutEnv(env);
env = "CXX=";
if (!this->CXXEnvironment.empty()) {
env += this->CXXEnvironment;
}
cmSystemTools::PutEnv(env);
}
// set the new
this->GlobalGenerator = gg;
// set the global flag for unix style paths on cmSystemTools as soon as
// the generator is set. This allows gmake to be used on windows.
cmSystemTools::SetForceUnixPaths(this->GlobalGenerator->GetForceUnixPaths());
// Save the environment variables CXX and CC
if (!cmSystemTools::GetEnv("CXX", this->CXXEnvironment)) {
this->CXXEnvironment.clear();
}
if (!cmSystemTools::GetEnv("CC", this->CCEnvironment)) {
this->CCEnvironment.clear();
}
}
int cmake::DoPreConfigureChecks()
{
// Make sure the Source directory contains a CMakeLists.txt file.
std::string srcList = this->GetHomeDirectory();
srcList += "/CMakeLists.txt";
if (!cmSystemTools::FileExists(srcList)) {
std::ostringstream err;
if (cmSystemTools::FileIsDirectory(this->GetHomeDirectory())) {
err << "The source directory \"" << this->GetHomeDirectory()
<< "\" does not appear to contain CMakeLists.txt.\n";
} else if (cmSystemTools::FileExists(this->GetHomeDirectory())) {
err << "The source directory \"" << this->GetHomeDirectory()
<< "\" is a file, not a directory.\n";
} else {
err << "The source directory \"" << this->GetHomeDirectory()
<< "\" does not exist.\n";
}
err << "Specify --help for usage, or press the help button on the CMake "
"GUI.";
cmSystemTools::Error(err.str().c_str());
return -2;
}
// do a sanity check on some values
if (this->State->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY")) {
std::string cacheStart =
*this->State->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY");
cacheStart += "/CMakeLists.txt";
std::string currentStart = this->GetHomeDirectory();
currentStart += "/CMakeLists.txt";
if (!cmSystemTools::SameFile(cacheStart, currentStart)) {
std::string message = "The source \"";
message += currentStart;
message += "\" does not match the source \"";
message += cacheStart;
message += "\" used to generate cache. ";
message += "Re-run cmake with a different source directory.";
cmSystemTools::Error(message.c_str());
return -2;
}
} else {
return 0;
}
return 1;
}
struct SaveCacheEntry
{
std::string key;
std::string value;
std::string help;
cmStateEnums::CacheEntryType type;
};
int cmake::HandleDeleteCacheVariables(const std::string& var)
{
std::vector<std::string> argsSplit;
cmSystemTools::ExpandListArgument(std::string(var), argsSplit, true);
// erase the property to avoid infinite recursion
this->State->SetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_", "");
if (this->State->GetIsInTryCompile()) {
return 0;
}
std::vector<SaveCacheEntry> saved;
std::ostringstream warning;
/* clang-format off */
warning
<< "You have changed variables that require your cache to be deleted.\n"
<< "Configure will be re-run and you may have to reset some variables.\n"
<< "The following variables have changed:\n";
/* clang-format on */
for (std::vector<std::string>::iterator i = argsSplit.begin();
i != argsSplit.end(); ++i) {
SaveCacheEntry save;
save.key = *i;
warning << *i << "= ";
i++;
save.value = *i;
warning << *i << "\n";
const char* existingValue = this->State->GetCacheEntryValue(save.key);
if (existingValue) {
save.type = this->State->GetCacheEntryType(save.key);
if (const char* help =
this->State->GetCacheEntryProperty(save.key, "HELPSTRING")) {
save.help = help;
}
}
saved.push_back(std::move(save));
}
// remove the cache
this->DeleteCache(this->GetHomeOutputDirectory());
// load the empty cache
this->LoadCache();
// restore the changed compilers
for (SaveCacheEntry const& i : saved) {
this->AddCacheEntry(i.key, i.value.c_str(), i.help.c_str(), i.type);
}
cmSystemTools::Message(warning.str().c_str());
// avoid reconfigure if there were errors
if (!cmSystemTools::GetErrorOccuredFlag()) {
// re-run configure
return this->Configure();
}
return 0;
}
int cmake::Configure()
{
DiagLevel diagLevel;
if (this->DiagLevels.count("deprecated") == 1) {
diagLevel = this->DiagLevels["deprecated"];
if (diagLevel == DIAG_IGNORE) {
this->SetSuppressDeprecatedWarnings(true);
this->SetDeprecatedWarningsAsErrors(false);
} else if (diagLevel == DIAG_WARN) {
this->SetSuppressDeprecatedWarnings(false);
this->SetDeprecatedWarningsAsErrors(false);
} else if (diagLevel == DIAG_ERROR) {
this->SetSuppressDeprecatedWarnings(false);
this->SetDeprecatedWarningsAsErrors(true);
}
}
if (this->DiagLevels.count("dev") == 1) {
bool setDeprecatedVariables = false;
const char* cachedWarnDeprecated =
this->State->GetCacheEntryValue("CMAKE_WARN_DEPRECATED");
const char* cachedErrorDeprecated =
this->State->GetCacheEntryValue("CMAKE_ERROR_DEPRECATED");
// don't overwrite deprecated warning setting from a previous invocation
if (!cachedWarnDeprecated && !cachedErrorDeprecated) {
setDeprecatedVariables = true;
}
diagLevel = this->DiagLevels["dev"];
if (diagLevel == DIAG_IGNORE) {
this->SetSuppressDevWarnings(true);
this->SetDevWarningsAsErrors(false);
if (setDeprecatedVariables) {
this->SetSuppressDeprecatedWarnings(true);
this->SetDeprecatedWarningsAsErrors(false);
}
} else if (diagLevel == DIAG_WARN) {
this->SetSuppressDevWarnings(false);
this->SetDevWarningsAsErrors(false);
if (setDeprecatedVariables) {
this->SetSuppressDeprecatedWarnings(false);
this->SetDeprecatedWarningsAsErrors(false);
}
} else if (diagLevel == DIAG_ERROR) {
this->SetSuppressDevWarnings(false);
this->SetDevWarningsAsErrors(true);
if (setDeprecatedVariables) {
this->SetSuppressDeprecatedWarnings(false);
this->SetDeprecatedWarningsAsErrors(true);
}
}
}
int ret = this->ActualConfigure();
const char* delCacheVars =
this->State->GetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_");
if (delCacheVars && delCacheVars[0] != 0) {
return this->HandleDeleteCacheVariables(delCacheVars);
}
return ret;
}
int cmake::ActualConfigure()
{
// Construct right now our path conversion table before it's too late:
this->UpdateConversionPathTable();
this->CleanupCommandsAndMacros();
int res = this->DoPreConfigureChecks();
if (res < 0) {
return -2;
}
if (!res) {
this->AddCacheEntry(
"CMAKE_HOME_DIRECTORY", this->GetHomeDirectory().c_str(),
"Source directory with the top level CMakeLists.txt file for this "
"project",
cmStateEnums::INTERNAL);
}
// no generator specified on the command line
if (!this->GlobalGenerator) {
const std::string* genName =
this->State->GetInitializedCacheValue("CMAKE_GENERATOR");
const std::string* extraGenName =
this->State->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
if (genName) {
std::string fullName =
cmExternalMakefileProjectGenerator::CreateFullGeneratorName(
*genName, extraGenName ? *extraGenName : "");
this->GlobalGenerator = this->CreateGlobalGenerator(fullName);
}
if (this->GlobalGenerator) {
// set the global flag for unix style paths on cmSystemTools as
// soon as the generator is set. This allows gmake to be used
// on windows.
cmSystemTools::SetForceUnixPaths(
this->GlobalGenerator->GetForceUnixPaths());
} else {
this->CreateDefaultGlobalGenerator();
}
if (!this->GlobalGenerator) {
cmSystemTools::Error("Could not create generator");
return -1;
}
}
const std::string* genName =
this->State->GetInitializedCacheValue("CMAKE_GENERATOR");
if (genName) {
if (!this->GlobalGenerator->MatchesGeneratorName(*genName)) {
std::string message = "Error: generator : ";
message += this->GlobalGenerator->GetName();
message += "\nDoes not match the generator used previously: ";
message += *genName;
message += "\nEither remove the CMakeCache.txt file and CMakeFiles "
"directory or choose a different binary directory.";
cmSystemTools::Error(message.c_str());
return -2;
}
}
if (!this->State->GetInitializedCacheValue("CMAKE_GENERATOR")) {
this->AddCacheEntry("CMAKE_GENERATOR",
this->GlobalGenerator->GetName().c_str(),
"Name of generator.", cmStateEnums::INTERNAL);
this->AddCacheEntry("CMAKE_EXTRA_GENERATOR",
this->GlobalGenerator->GetExtraGeneratorName().c_str(),
"Name of external makefile project generator.",
cmStateEnums::INTERNAL);
}
if (const std::string* instance =
this->State->GetInitializedCacheValue("CMAKE_GENERATOR_INSTANCE")) {
if (!this->GeneratorInstance.empty() &&
this->GeneratorInstance != *instance) {
std::string message = "Error: generator instance: ";
message += this->GeneratorInstance;
message += "\nDoes not match the instance used previously: ";
message += *instance;
message += "\nEither remove the CMakeCache.txt file and CMakeFiles "
"directory or choose a different binary directory.";
cmSystemTools::Error(message.c_str());
return -2;
}
} else {
this->AddCacheEntry(
"CMAKE_GENERATOR_INSTANCE", this->GeneratorInstance.c_str(),
"Generator instance identifier.", cmStateEnums::INTERNAL);
}
if (const std::string* platformName =
this->State->GetInitializedCacheValue("CMAKE_GENERATOR_PLATFORM")) {
if (!this->GeneratorPlatform.empty() &&
this->GeneratorPlatform != *platformName) {
std::string message = "Error: generator platform: ";
message += this->GeneratorPlatform;
message += "\nDoes not match the platform used previously: ";
message += *platformName;
message += "\nEither remove the CMakeCache.txt file and CMakeFiles "
"directory or choose a different binary directory.";
cmSystemTools::Error(message.c_str());
return -2;
}
} else {
this->AddCacheEntry("CMAKE_GENERATOR_PLATFORM",
this->GeneratorPlatform.c_str(),
"Name of generator platform.", cmStateEnums::INTERNAL);
}
if (const std::string* tsName =
this->State->GetInitializedCacheValue("CMAKE_GENERATOR_TOOLSET")) {
if (!this->GeneratorToolset.empty() && this->GeneratorToolset != *tsName) {
std::string message = "Error: generator toolset: ";
message += this->GeneratorToolset;
message += "\nDoes not match the toolset used previously: ";
message += *tsName;
message += "\nEither remove the CMakeCache.txt file and CMakeFiles "
"directory or choose a different binary directory.";
cmSystemTools::Error(message.c_str());
return -2;
}
} else {
this->AddCacheEntry("CMAKE_GENERATOR_TOOLSET",
this->GeneratorToolset.c_str(),
"Name of generator toolset.", cmStateEnums::INTERNAL);
}
// reset any system configuration information, except for when we are
// InTryCompile. With TryCompile the system info is taken from the parent's
// info to save time
if (!this->State->GetIsInTryCompile()) {
this->GlobalGenerator->ClearEnabledLanguages();
this->TruncateOutputLog("CMakeOutput.log");
this->TruncateOutputLog("CMakeError.log");
}
// actually do the configure
this->GlobalGenerator->Configure();
// Before saving the cache
// if the project did not define one of the entries below, add them now
// so users can edit the values in the cache:
// We used to always present LIBRARY_OUTPUT_PATH and
// EXECUTABLE_OUTPUT_PATH. They are now documented as old-style and
// should no longer be used. Therefore we present them only if the
// project requires compatibility with CMake 2.4. We detect this
// here by looking for the old CMAKE_BACKWARDS_COMPATIBILITY
// variable created when CMP0001 is not set to NEW.
if (this->State->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY")) {
if (!this->State->GetInitializedCacheValue("LIBRARY_OUTPUT_PATH")) {
this->AddCacheEntry(
"LIBRARY_OUTPUT_PATH", "",
"Single output directory for building all libraries.",
cmStateEnums::PATH);
}
if (!this->State->GetInitializedCacheValue("EXECUTABLE_OUTPUT_PATH")) {
this->AddCacheEntry(
"EXECUTABLE_OUTPUT_PATH", "",
"Single output directory for building all executables.",
cmStateEnums::PATH);
}
}
cmMakefile* mf = this->GlobalGenerator->GetMakefiles()[0];
if (mf->IsOn("CTEST_USE_LAUNCHERS") &&
!this->State->GetGlobalProperty("RULE_LAUNCH_COMPILE")) {
cmSystemTools::Error(
"CTEST_USE_LAUNCHERS is enabled, but the "
"RULE_LAUNCH_COMPILE global property is not defined.\n"
"Did you forget to include(CTest) in the toplevel "
"CMakeLists.txt ?");
}
this->State->SaveVerificationScript(this->GetHomeOutputDirectory());
this->SaveCache(this->GetHomeOutputDirectory());
if (cmSystemTools::GetErrorOccuredFlag()) {
return -1;
}
return 0;
}
void cmake::CreateDefaultGlobalGenerator()
{
#if defined(_WIN32) && !defined(__CYGWIN__) && !defined(CMAKE_BOOT_MINGW)
std::string found;
// Try to find the newest VS installed on the computer and
// use that as a default if -G is not specified
const std::string vsregBase = "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\";
static const char* const vsVariants[] = {
/* clang-format needs this comment to break after the opening brace */
"VisualStudio\\", "VCExpress\\", "WDExpress\\"
};
struct VSVersionedGenerator
{
const char* MSVersion;
const char* GeneratorName;
};
static VSVersionedGenerator const vsGenerators[] = {
{ "15.0", "Visual Studio 15 2017" }, //
{ "14.0", "Visual Studio 14 2015" }, //
{ "12.0", "Visual Studio 12 2013" }, //
{ "11.0", "Visual Studio 11 2012" }, //
{ "10.0", "Visual Studio 10 2010" }, //
{ "9.0", "Visual Studio 9 2008" }
};
static const char* const vsEntries[] = {
"\\Setup\\VC;ProductDir", //
";InstallDir" //
};
cmVSSetupAPIHelper vsSetupAPIHelper;
if (vsSetupAPIHelper.IsVS2017Installed()) {
found = "Visual Studio 15 2017";
} else {
for (VSVersionedGenerator const* g = cm::cbegin(vsGenerators);
found.empty() && g != cm::cend(vsGenerators); ++g) {
for (const char* const* v = cm::cbegin(vsVariants);
found.empty() && v != cm::cend(vsVariants); ++v) {
for (const char* const* e = cm::cbegin(vsEntries);
found.empty() && e != cm::cend(vsEntries); ++e) {
std::string const reg = vsregBase + *v + g->MSVersion + *e;
std::string dir;
if (cmSystemTools::ReadRegistryValue(reg, dir,
cmSystemTools::KeyWOW64_32) &&
cmSystemTools::PathExists(dir)) {
found = g->GeneratorName;
}
}
}
}
}
cmGlobalGenerator* gen = this->CreateGlobalGenerator(found);
if (!gen) {
gen = new cmGlobalNMakeMakefileGenerator(this);
}
this->SetGlobalGenerator(gen);
std::cout << "-- Building for: " << gen->GetName() << "\n";
#else
this->SetGlobalGenerator(new cmGlobalUnixMakefileGenerator3(this));
#endif
}
void cmake::PreLoadCMakeFiles()
{
std::vector<std::string> args;
std::string pre_load = this->GetHomeDirectory();
if (!pre_load.empty()) {
pre_load += "/PreLoad.cmake";
if (cmSystemTools::FileExists(pre_load)) {
this->ReadListFile(args, pre_load.c_str());
}
}
pre_load = this->GetHomeOutputDirectory();
if (!pre_load.empty()) {
pre_load += "/PreLoad.cmake";
if (cmSystemTools::FileExists(pre_load)) {
this->ReadListFile(args, pre_load.c_str());
}
}
}
// handle a command line invocation
int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
{
// Process the arguments
this->SetArgs(args);
if (cmSystemTools::GetErrorOccuredFlag()) {
return -1;
}
// If we are given a stamp list file check if it is really out of date.
if (!this->CheckStampList.empty() &&
cmakeCheckStampList(this->CheckStampList.c_str())) {
return 0;
}
// If we are given a stamp file check if it is really out of date.
if (!this->CheckStampFile.empty() &&
cmakeCheckStampFile(this->CheckStampFile.c_str())) {
return 0;
}
if (this->GetWorkingMode() == NORMAL_MODE) {
// load the cache
if (this->LoadCache() < 0) {
cmSystemTools::Error("Error executing cmake::LoadCache(). Aborting.\n");
return -1;
}
} else {
this->AddCMakePaths();
}
// Add any cache args
if (!this->SetCacheArgs(args)) {
cmSystemTools::Error("Problem processing arguments. Aborting.\n");
return -1;
}
// In script mode we terminate after running the script.
if (this->GetWorkingMode() != NORMAL_MODE) {
if (cmSystemTools::GetErrorOccuredFlag()) {
return -1;
}
return 0;
}
// If MAKEFLAGS are given in the environment, remove the environment
// variable. This will prevent try-compile from succeeding when it
// should fail (if "-i" is an option). We cannot simply test
// whether "-i" is given and remove it because some make programs
// encode the MAKEFLAGS variable in a strange way.
if (cmSystemTools::HasEnv("MAKEFLAGS")) {
cmSystemTools::PutEnv("MAKEFLAGS=");
}
this->PreLoadCMakeFiles();
if (noconfigure) {
return 0;
}
// now run the global generate
// Check the state of the build system to see if we need to regenerate.
if (!this->CheckBuildSystem()) {
return 0;
}
int ret = this->Configure();
if (ret) {
#if defined(CMAKE_HAVE_VS_GENERATORS)
if (!this->VSSolutionFile.empty() && this->GlobalGenerator) {
// CMake is running to regenerate a Visual Studio build tree
// during a build from the VS IDE. The build files cannot be
// regenerated, so we should stop the build.
cmSystemTools::Message("CMake Configure step failed. "
"Build files cannot be regenerated correctly. "
"Attempting to stop IDE build.");
cmGlobalVisualStudioGenerator* gg =
static_cast<cmGlobalVisualStudioGenerator*>(this->GlobalGenerator);
gg->CallVisualStudioMacro(cmGlobalVisualStudioGenerator::MacroStop,
this->VSSolutionFile.c_str());
}
#endif
return ret;
}
ret = this->Generate();
std::string message = "Build files have been written to: ";
message += this->GetHomeOutputDirectory();
this->UpdateProgress(message.c_str(), -1);
return ret;
}
int cmake::Generate()
{
if (!this->GlobalGenerator) {
return -1;
}
if (!this->GlobalGenerator->Compute()) {
return -1;
}
this->GlobalGenerator->Generate();
if (!this->GraphVizFile.empty()) {
std::cout << "Generate graphviz: " << this->GraphVizFile << std::endl;
this->GenerateGraphViz(this->GraphVizFile.c_str());
}
if (this->WarnUnusedCli) {
this->RunCheckForUnusedVariables();
}
if (cmSystemTools::GetErrorOccuredFlag()) {
return -1;
}
// Save the cache again after a successful Generate so that any internal
// variables created during Generate are saved. (Specifically target GUIDs
// for the Visual Studio and Xcode generators.)
this->SaveCache(this->GetHomeOutputDirectory());
return 0;
}
void cmake::AddCacheEntry(const std::string& key, const char* value,
const char* helpString, int type)
{
this->State->AddCacheEntry(key, value, helpString,
cmStateEnums::CacheEntryType(type));
this->UnwatchUnusedCli(key);
}
bool cmake::DoWriteGlobVerifyTarget() const
{
return this->State->DoWriteGlobVerifyTarget();
}
std::string const& cmake::GetGlobVerifyScript() const
{
return this->State->GetGlobVerifyScript();
}
std::string const& cmake::GetGlobVerifyStamp() const
{
return this->State->GetGlobVerifyStamp();
}
void cmake::AddGlobCacheEntry(bool recurse, bool listDirectories,
bool followSymlinks, const std::string& relative,
const std::string& expression,
const std::vector<std::string>& files,
const std::string& variable,
cmListFileBacktrace const& backtrace)
{
this->State->AddGlobCacheEntry(recurse, listDirectories, followSymlinks,
relative, expression, files, variable,
backtrace);
}
std::string cmake::StripExtension(const std::string& file) const
{
auto dotpos = file.rfind('.');
if (dotpos != std::string::npos) {
auto ext = file.substr(dotpos + 1);
#if defined(_WIN32) || defined(__APPLE__)
ext = cmSystemTools::LowerCase(ext);
#endif
if (this->IsSourceExtension(ext) || this->IsHeaderExtension(ext)) {
return file.substr(0, dotpos);
}
}
return file;
}
const char* cmake::GetCacheDefinition(const std::string& name) const
{
const std::string* p = this->State->GetInitializedCacheValue(name);
return p ? p->c_str() : nullptr;
}
void cmake::AddScriptingCommands()
{
GetScriptingCommands(this->State);
}
void cmake::AddProjectCommands()
{
GetProjectCommands(this->State);
}
void cmake::AddDefaultGenerators()
{
#if defined(_WIN32) && !defined(__CYGWIN__)
# if !defined(CMAKE_BOOT_MINGW)
this->Generators.push_back(cmGlobalVisualStudio15Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio14Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio12Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio11Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio10Generator::NewFactory());
this->Generators.push_back(cmGlobalVisualStudio9Generator::NewFactory());
this->Generators.push_back(cmGlobalBorlandMakefileGenerator::NewFactory());
this->Generators.push_back(cmGlobalNMakeMakefileGenerator::NewFactory());
this->Generators.push_back(cmGlobalJOMMakefileGenerator::NewFactory());
this->Generators.push_back(cmGlobalGhsMultiGenerator::NewFactory());
# endif
this->Generators.push_back(cmGlobalMSYSMakefileGenerator::NewFactory());
this->Generators.push_back(cmGlobalMinGWMakefileGenerator::NewFactory());
#endif
this->Generators.push_back(cmGlobalUnixMakefileGenerator3::NewFactory());
#if defined(CMAKE_BUILD_WITH_CMAKE)
this->Generators.push_back(cmGlobalNinjaGenerator::NewFactory());
#endif
#if defined(CMAKE_USE_WMAKE)
this->Generators.push_back(cmGlobalWatcomWMakeGenerator::NewFactory());
#endif
#ifdef CMAKE_USE_XCODE
this->Generators.push_back(cmGlobalXCodeGenerator::NewFactory());
#endif
}
bool cmake::ParseCacheEntry(const std::string& entry, std::string& var,
std::string& value,
cmStateEnums::CacheEntryType& type)
{
return cmState::ParseCacheEntry(entry, var, value, type);
}
int cmake::LoadCache()
{
// could we not read the cache
if (!this->LoadCache(this->GetHomeOutputDirectory())) {
// if it does exist, but isn't readable then warn the user
std::string cacheFile = this->GetHomeOutputDirectory();
cacheFile += "/CMakeCache.txt";
if (cmSystemTools::FileExists(cacheFile)) {
cmSystemTools::Error(
"There is a CMakeCache.txt file for the current binary tree but "
"cmake does not have permission to read it. Please check the "
"permissions of the directory you are trying to run CMake on.");
return -1;
}
}
// setup CMAKE_ROOT and CMAKE_COMMAND
if (!this->AddCMakePaths()) {
return -3;
}
return 0;
}
bool cmake::LoadCache(const std::string& path)
{
std::set<std::string> emptySet;
return this->LoadCache(path, true, emptySet, emptySet);
}
bool cmake::LoadCache(const std::string& path, bool internal,
std::set<std::string>& excludes,
std::set<std::string>& includes)
{
bool result = this->State->LoadCache(path, internal, excludes, includes);
static const char* entries[] = { "CMAKE_CACHE_MAJOR_VERSION",
"CMAKE_CACHE_MINOR_VERSION" };
for (const char* const* nameIt = cm::cbegin(entries);
nameIt != cm::cend(entries); ++nameIt) {
this->UnwatchUnusedCli(*nameIt);
}
return result;
}
bool cmake::SaveCache(const std::string& path)
{
bool result = this->State->SaveCache(path, this->GetMessenger());
static const char* entries[] = { "CMAKE_CACHE_MAJOR_VERSION",
"CMAKE_CACHE_MINOR_VERSION",
"CMAKE_CACHE_PATCH_VERSION",
"CMAKE_CACHEFILE_DIR" };
for (const char* const* nameIt = cm::cbegin(entries);
nameIt != cm::cend(entries); ++nameIt) {
this->UnwatchUnusedCli(*nameIt);
}
return result;
}
bool cmake::DeleteCache(const std::string& path)
{
return this->State->DeleteCache(path);
}
void cmake::SetProgressCallback(ProgressCallbackType f, void* cd)
{
this->ProgressCallback = f;
this->ProgressCallbackClientData = cd;
}
void cmake::UpdateProgress(const char* msg, float prog)
{
if (this->ProgressCallback && !this->State->GetIsInTryCompile()) {
(*this->ProgressCallback)(msg, prog, this->ProgressCallbackClientData);
return;
}
}
bool cmake::GetIsInTryCompile() const
{
return this->State->GetIsInTryCompile();
}
void cmake::SetIsInTryCompile(bool b)
{
this->State->SetIsInTryCompile(b);
}
void cmake::GetGeneratorDocumentation(std::vector<cmDocumentationEntry>& v)
{
for (cmGlobalGeneratorFactory* g : this->Generators) {
cmDocumentationEntry e;
g->GetDocumentation(e);
v.push_back(std::move(e));
}
for (cmExternalMakefileProjectGeneratorFactory* eg : this->ExtraGenerators) {
const std::string doc = eg->GetDocumentation();
const std::string name = eg->GetName();
// Aliases:
for (std::string const& a : eg->Aliases) {
cmDocumentationEntry e;
e.Name = a;
e.Brief = doc;
v.push_back(std::move(e));
}
// Full names:
const std::vector<std::string> generators =
eg->GetSupportedGlobalGenerators();
for (std::string const& g : generators) {
cmDocumentationEntry e;
e.Name =
cmExternalMakefileProjectGenerator::CreateFullGeneratorName(g, name);
e.Brief = doc;
v.push_back(std::move(e));
}
}
}
void cmake::PrintGeneratorList()
{
#ifdef CMAKE_BUILD_WITH_CMAKE
cmDocumentation doc;
std::vector<cmDocumentationEntry> generators;
this->GetGeneratorDocumentation(generators);
doc.AppendSection("Generators", generators);
std::cerr << "\n";
doc.PrintDocumentation(cmDocumentation::ListGenerators, std::cerr);
#endif
}
void cmake::UpdateConversionPathTable()
{
// Update the path conversion table with any specified file:
const std::string* tablepath =
this->State->GetInitializedCacheValue("CMAKE_PATH_TRANSLATION_FILE");
if (tablepath) {
cmsys::ifstream table(tablepath->c_str());
if (!table) {
cmSystemTools::Error("CMAKE_PATH_TRANSLATION_FILE set to ",
tablepath->c_str(), ". CMake can not open file.");
cmSystemTools::ReportLastSystemError("CMake can not open file.");
} else {
std::string a, b;
while (!table.eof()) {
// two entries per line
table >> a;
table >> b;
cmSystemTools::AddTranslationPath(a, b);
}
}
}
}
int cmake::CheckBuildSystem()
{
// We do not need to rerun CMake. Check dependency integrity.
const bool verbose = isCMakeVerbose();
// This method will check the integrity of the build system if the
// option was given on the command line. It reads the given file to
// determine whether CMake should rerun.
// If no file is provided for the check, we have to rerun.
if (this->CheckBuildSystemArgument.empty()) {
if (verbose) {
std::ostringstream msg;
msg << "Re-run cmake no build system arguments\n";
cmSystemTools::Stdout(msg.str().c_str());
}
return 1;
}
// If the file provided does not exist, we have to rerun.
if (!cmSystemTools::FileExists(this->CheckBuildSystemArgument)) {
if (verbose) {
std::ostringstream msg;
msg << "Re-run cmake missing file: " << this->CheckBuildSystemArgument
<< "\n";
cmSystemTools::Stdout(msg.str().c_str());
}
return 1;
}
// Read the rerun check file and use it to decide whether to do the
// global generate.
cmake cm(RoleScript); // Actually, all we need is the `set` command.
cm.SetHomeDirectory("");
cm.SetHomeOutputDirectory("");
cm.GetCurrentSnapshot().SetDefaultDefinitions();
cmGlobalGenerator gg(&cm);
cmMakefile mf(&gg, cm.GetCurrentSnapshot());
if (!mf.ReadListFile(this->CheckBuildSystemArgument.c_str()) ||
cmSystemTools::GetErrorOccuredFlag()) {
if (verbose) {
std::ostringstream msg;
msg << "Re-run cmake error reading : " << this->CheckBuildSystemArgument
<< "\n";
cmSystemTools::Stdout(msg.str().c_str());
}
// There was an error reading the file. Just rerun.
return 1;
}
if (this->ClearBuildSystem) {
// Get the generator used for this build system.
const char* genName = mf.GetDefinition("CMAKE_DEPENDS_GENERATOR");
if (!genName || genName[0] == '\0') {
genName = "Unix Makefiles";
}
// Create the generator and use it to clear the dependencies.
std::unique_ptr<cmGlobalGenerator> ggd(
this->CreateGlobalGenerator(genName));
if (ggd) {
cm.GetCurrentSnapshot().SetDefaultDefinitions();
cmMakefile mfd(ggd.get(), cm.GetCurrentSnapshot());
std::unique_ptr<cmLocalGenerator> lgd(ggd->CreateLocalGenerator(&mfd));
lgd->ClearDependencies(&mfd, verbose);
}
}
// If any byproduct of makefile generation is missing we must re-run.
std::vector<std::string> products;
if (const char* productStr = mf.GetDefinition("CMAKE_MAKEFILE_PRODUCTS")) {
cmSystemTools::ExpandListArgument(productStr, products);
}
for (std::string const& p : products) {
if (!(cmSystemTools::FileExists(p) || cmSystemTools::FileIsSymlink(p))) {
if (verbose) {
std::ostringstream msg;
msg << "Re-run cmake, missing byproduct: " << p << "\n";
cmSystemTools::Stdout(msg.str().c_str());
}
return 1;
}
}
// Get the set of dependencies and outputs.
std::vector<std::string> depends;
std::vector<std::string> outputs;
const char* dependsStr = mf.GetDefinition("CMAKE_MAKEFILE_DEPENDS");
const char* outputsStr = mf.GetDefinition("CMAKE_MAKEFILE_OUTPUTS");
if (dependsStr && outputsStr) {
cmSystemTools::ExpandListArgument(dependsStr, depends);
cmSystemTools::ExpandListArgument(outputsStr, outputs);
}
if (depends.empty() || outputs.empty()) {
// Not enough information was provided to do the test. Just rerun.
if (verbose) {
std::ostringstream msg;
msg << "Re-run cmake no CMAKE_MAKEFILE_DEPENDS "
"or CMAKE_MAKEFILE_OUTPUTS :\n";
cmSystemTools::Stdout(msg.str().c_str());
}
return 1;
}
// Find the newest dependency.
std::vector<std::string>::iterator dep = depends.begin();
std::string dep_newest = *dep++;
for (; dep != depends.end(); ++dep) {
int result = 0;
if (this->FileComparison->FileTimeCompare(dep_newest.c_str(), dep->c_str(),
&result)) {
if (result < 0) {
dep_newest = *dep;
}
} else {
if (verbose) {
std::ostringstream msg;
msg << "Re-run cmake: build system dependency is missing\n";
cmSystemTools::Stdout(msg.str().c_str());
}
return 1;
}
}
// Find the oldest output.
std::vector<std::string>::iterator out = outputs.begin();
std::string out_oldest = *out++;
for (; out != outputs.end(); ++out) {
int result = 0;
if (this->FileComparison->FileTimeCompare(out_oldest.c_str(), out->c_str(),
&result)) {
if (result > 0) {
out_oldest = *out;
}
} else {
if (verbose) {
std::ostringstream msg;
msg << "Re-run cmake: build system output is missing\n";
cmSystemTools::Stdout(msg.str().c_str());
}
return 1;
}
}
// If any output is older than any dependency then rerun.
{
int result = 0;
if (!this->FileComparison->FileTimeCompare(out_oldest.c_str(),
dep_newest.c_str(), &result) ||
result < 0) {
if (verbose) {
std::ostringstream msg;
msg << "Re-run cmake file: " << out_oldest
<< " older than: " << dep_newest << "\n";
cmSystemTools::Stdout(msg.str().c_str());
}
return 1;
}
}
// No need to rerun.
return 0;
}
void cmake::TruncateOutputLog(const char* fname)
{
std::string fullPath = this->GetHomeOutputDirectory();
fullPath += "/";
fullPath += fname;
struct stat st;
if (::stat(fullPath.c_str(), &st)) {
return;
}
if (!this->State->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR")) {
cmSystemTools::RemoveFile(fullPath);
return;
}
off_t fsize = st.st_size;
const off_t maxFileSize = 50 * 1024;
if (fsize < maxFileSize) {
// TODO: truncate file
return;
}
}
inline std::string removeQuotes(const std::string& s)
{
if (s[0] == '\"' && s[s.size() - 1] == '\"') {
return s.substr(1, s.size() - 2);
}
return s;
}
void cmake::MarkCliAsUsed(const std::string& variable)
{
this->UsedCliVariables[variable] = true;
}
void cmake::GenerateGraphViz(const char* fileName) const
{
#ifdef CMAKE_BUILD_WITH_CMAKE
cmGraphVizWriter gvWriter(this->GetGlobalGenerator()->GetLocalGenerators());
std::string settingsFile = this->GetHomeOutputDirectory();
settingsFile += "/CMakeGraphVizOptions.cmake";
std::string fallbackSettingsFile = this->GetHomeDirectory();
fallbackSettingsFile += "/CMakeGraphVizOptions.cmake";
gvWriter.ReadSettings(settingsFile.c_str(), fallbackSettingsFile.c_str());
gvWriter.WritePerTargetFiles(fileName);
gvWriter.WriteTargetDependersFiles(fileName);
gvWriter.WriteGlobalFile(fileName);
#endif
}
void cmake::SetProperty(const std::string& prop, const char* value)
{
this->State->SetGlobalProperty(prop, value);
}
void cmake::AppendProperty(const std::string& prop, const char* value,
bool asString)
{
this->State->AppendGlobalProperty(prop, value, asString);
}
const char* cmake::GetProperty(const std::string& prop)
{
return this->State->GetGlobalProperty(prop);
}
bool cmake::GetPropertyAsBool(const std::string& prop)
{
return this->State->GetGlobalPropertyAsBool(prop);
}
cmInstalledFile* cmake::GetOrCreateInstalledFile(cmMakefile* mf,
const std::string& name)
{
std::map<std::string, cmInstalledFile>::iterator i =
this->InstalledFiles.find(name);
if (i != this->InstalledFiles.end()) {
cmInstalledFile& file = i->second;
return &file;
}
cmInstalledFile& file = this->InstalledFiles[name];
file.SetName(mf, name);
return &file;
}
cmInstalledFile const* cmake::GetInstalledFile(const std::string& name) const
{
std::map<std::string, cmInstalledFile>::const_iterator i =
this->InstalledFiles.find(name);
if (i != this->InstalledFiles.end()) {
cmInstalledFile const& file = i->second;
return &file;
}
return nullptr;
}
int cmake::GetSystemInformation(std::vector<std::string>& args)
{
// so create the directory
std::string resultFile;
std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
std::string destPath = cwd + "/__cmake_systeminformation";
cmSystemTools::RemoveADirectory(destPath);
if (!cmSystemTools::MakeDirectory(destPath)) {
std::cerr << "Error: --system-information must be run from a "
"writable directory!\n";
return 1;
}
// process the arguments
bool writeToStdout = true;
for (unsigned int i = 1; i < args.size(); ++i) {
std::string const& arg = args[i];
if (arg.find("-G", 0) == 0) {
std::string value = arg.substr(2);
if (value.empty()) {
++i;
if (i >= args.size()) {
cmSystemTools::Error("No generator specified for -G");
this->PrintGeneratorList();
return -1;
}
value = args[i];
}
cmGlobalGenerator* gen = this->CreateGlobalGenerator(value);
if (!gen) {
cmSystemTools::Error("Could not create named generator ",
value.c_str());
this->PrintGeneratorList();
} else {
this->SetGlobalGenerator(gen);
}
}
// no option assume it is the output file
else {
if (!cmSystemTools::FileIsFullPath(arg)) {
resultFile = cwd;
resultFile += "/";
}
resultFile += arg;
writeToStdout = false;
}
}
// we have to find the module directory, so we can copy the files
this->AddCMakePaths();
std::string modulesPath = cmSystemTools::GetCMakeRoot();
modulesPath += "/Modules";
std::string inFile = modulesPath;
inFile += "/SystemInformation.cmake";
std::string outFile = destPath;
outFile += "/CMakeLists.txt";
// Copy file
if (!cmSystemTools::cmCopyFile(inFile.c_str(), outFile.c_str())) {
std::cerr << "Error copying file \"" << inFile << "\" to \"" << outFile
<< "\".\n";
return 1;
}
// do we write to a file or to stdout?
if (resultFile.empty()) {
resultFile = cwd;
resultFile += "/__cmake_systeminformation/results.txt";
}
{
// now run cmake on the CMakeLists file
cmWorkingDirectory workdir(destPath);
if (workdir.Failed()) {
// We created the directory and we were able to copy the CMakeLists.txt
// file to it, so we wouldn't expect to get here unless the default
// permissions are questionable or some other process has deleted the
// directory
std::cerr << "Failed to change to directory " << destPath << " : "
<< std::strerror(workdir.GetLastResult()) << std::endl;
return 1;
}
std::vector<std::string> args2;
args2.push_back(args[0]);
args2.push_back(destPath);
args2.push_back("-DRESULT_FILE=" + resultFile);
int res = this->Run(args2, false);
if (res != 0) {
std::cerr << "Error: --system-information failed on internal CMake!\n";
return res;
}
}
// echo results to stdout if needed
if (writeToStdout) {
FILE* fin = cmsys::SystemTools::Fopen(resultFile, "r");
if (fin) {
const int bufferSize = 4096;
char buffer[bufferSize];
size_t n;
while ((n = fread(buffer, 1, bufferSize, fin)) > 0) {
for (char* c = buffer; c < buffer + n; ++c) {
putc(*c, stdout);
}
fflush(stdout);
}
fclose(fin);
}
}
// clean up the directory
cmSystemTools::RemoveADirectory(destPath);
return 0;
}
static bool cmakeCheckStampFile(const char* stampName, bool verbose)
{
// The stamp file does not exist. Use the stamp dependencies to
// determine whether it is really out of date. This works in
// conjunction with cmLocalVisualStudio7Generator to avoid
// repeatedly re-running CMake when the user rebuilds the entire
// solution.
std::string stampDepends = stampName;
stampDepends += ".depend";
#if defined(_WIN32) || defined(__CYGWIN__)
cmsys::ifstream fin(stampDepends.c_str(), std::ios::in | std::ios::binary);
#else
cmsys::ifstream fin(stampDepends.c_str());
#endif
if (!fin) {
// The stamp dependencies file cannot be read. Just assume the
// build system is really out of date.
std::cout << "CMake is re-running because " << stampName
<< " dependency file is missing.\n";
return false;
}
// Compare the stamp dependencies against the dependency file itself.
cmFileTimeComparison ftc;
std::string dep;
while (cmSystemTools::GetLineFromStream(fin, dep)) {
int result;
if (!dep.empty() && dep[0] != '#' &&
(!ftc.FileTimeCompare(stampDepends.c_str(), dep.c_str(), &result) ||
result < 0)) {
// The stamp depends file is older than this dependency. The
// build system is really out of date.
std::cout << "CMake is re-running because " << stampName
<< " is out-of-date.\n";
std::cout << " the file '" << dep << "'\n";
std::cout << " is newer than '" << stampDepends << "'\n";
std::cout << " result='" << result << "'\n";
return false;
}
}
// The build system is up to date. The stamp file has been removed
// by the VS IDE due to a "rebuild" request. Restore it atomically.
std::ostringstream stampTempStream;
stampTempStream << stampName << ".tmp" << cmSystemTools::RandomSeed();
std::string stampTempString = stampTempStream.str();
const char* stampTemp = stampTempString.c_str();
{
// TODO: Teach cmGeneratedFileStream to use a random temp file (with
// multiple tries in unlikely case of conflict) and use that here.
cmsys::ofstream stamp(stampTemp);
stamp << "# CMake generation timestamp file for this directory.\n";
}
if (cmSystemTools::RenameFile(stampTemp, stampName)) {
if (verbose) {
// Notify the user why CMake is not re-running. It is safe to
// just print to stdout here because this code is only reachable
// through an undocumented flag used by the VS generator.
std::cout << "CMake does not need to re-run because " << stampName
<< " is up-to-date.\n";
}
return true;
}
cmSystemTools::RemoveFile(stampTemp);
cmSystemTools::Error("Cannot restore timestamp ", stampName);
return false;
}
static bool cmakeCheckStampList(const char* stampList, bool verbose)
{
// If the stamp list does not exist CMake must rerun to generate it.
if (!cmSystemTools::FileExists(stampList)) {
std::cout << "CMake is re-running because generate.stamp.list "
<< "is missing.\n";
return false;
}
cmsys::ifstream fin(stampList);
if (!fin) {
std::cout << "CMake is re-running because generate.stamp.list "
<< "could not be read.\n";
return false;
}
// Check each stamp.
std::string stampName;
while (cmSystemTools::GetLineFromStream(fin, stampName)) {
if (!cmakeCheckStampFile(stampName.c_str(), verbose)) {
return false;
}
}
return true;
}
void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
cmListFileBacktrace const& backtrace) const
{
this->Messenger->IssueMessage(t, text, backtrace);
}
std::vector<std::string> cmake::GetDebugConfigs()
{
std::vector<std::string> configs;
if (const char* config_list =
this->State->GetGlobalProperty("DEBUG_CONFIGURATIONS")) {
// Expand the specified list and convert to upper-case.
cmSystemTools::ExpandListArgument(config_list, configs);
std::transform(configs.begin(), configs.end(), configs.begin(),
cmSystemTools::UpperCase);
}
// If no configurations were specified, use a default list.
if (configs.empty()) {
configs.push_back("DEBUG");
}
return configs;
}
cmMessenger* cmake::GetMessenger() const
{
return this->Messenger;
}
int cmake::Build(int jobs, const std::string& dir, const std::string& target,
const std::string& config,
const std::vector<std::string>& nativeOptions, bool clean)
{
this->SetHomeDirectory("");
this->SetHomeOutputDirectory("");
if (!cmSystemTools::FileIsDirectory(dir)) {
std::cerr << "Error: " << dir << " is not a directory\n";
return 1;
}
std::string cachePath = FindCacheFile(dir);
if (!this->LoadCache(cachePath)) {
std::cerr << "Error: could not load cache\n";
return 1;
}
const char* cachedGenerator =
this->State->GetCacheEntryValue("CMAKE_GENERATOR");
if (!cachedGenerator) {
std::cerr << "Error: could not find CMAKE_GENERATOR in Cache\n";
return 1;
}
cmGlobalGenerator* gen = this->CreateGlobalGenerator(cachedGenerator);
if (!gen) {
std::cerr << "Error: could create CMAKE_GENERATOR \"" << cachedGenerator
<< "\"\n";
return 1;
}
this->SetGlobalGenerator(gen);
const char* cachedGeneratorInstance =
this->State->GetCacheEntryValue("CMAKE_GENERATOR_INSTANCE");
if (cachedGeneratorInstance) {
cmMakefile mf(gen, this->GetCurrentSnapshot());
if (!gen->SetGeneratorInstance(cachedGeneratorInstance, &mf)) {
return 1;
}
}
const char* cachedGeneratorPlatform =
this->State->GetCacheEntryValue("CMAKE_GENERATOR_PLATFORM");
if (cachedGeneratorPlatform) {
cmMakefile mf(gen, this->GetCurrentSnapshot());
if (!gen->SetGeneratorPlatform(cachedGeneratorPlatform, &mf)) {
return 1;
}
}
std::string output;
std::string projName;
const char* cachedProjectName =
this->State->GetCacheEntryValue("CMAKE_PROJECT_NAME");
if (!cachedProjectName) {
std::cerr << "Error: could not find CMAKE_PROJECT_NAME in Cache\n";
return 1;
}
projName = cachedProjectName;
bool verbose = false;
const char* cachedVerbose =
this->State->GetCacheEntryValue("CMAKE_VERBOSE_MAKEFILE");
if (cachedVerbose) {
verbose = cmSystemTools::IsOn(cachedVerbose);
}
#ifdef CMAKE_HAVE_VS_GENERATORS
// For VS generators, explicitly check if regeneration is necessary before
// actually starting the build. If not done separately from the build
// itself, there is the risk of building an out-of-date solution file due
// to limitations of the underlying build system.
std::string const stampList = cachePath + "/" +
GetCMakeFilesDirectoryPostSlash() +
cmGlobalVisualStudio9Generator::GetGenerateStampList();
// Note that the stampList file only exists for VS generators.
if (cmSystemTools::FileExists(stampList)) {
// Check if running for Visual Studio 9 - we need to explicitly run
// the glob verification script before starting the build
this->AddScriptingCommands();
if (this->GlobalGenerator->MatchesGeneratorName("Visual Studio 9 2008")) {
std::string const globVerifyScript = cachePath + "/" +
GetCMakeFilesDirectoryPostSlash() + "VerifyGlobs.cmake";
if (cmSystemTools::FileExists(globVerifyScript)) {
std::vector<std::string> args;
this->ReadListFile(args, globVerifyScript.c_str());
}
}
if (!cmakeCheckStampList(stampList.c_str(), false)) {
// Correctly initialize the home (=source) and home output (=binary)
// directories, which is required for running the generation step.
std::string homeOrig = this->GetHomeDirectory();
std::string homeOutputOrig = this->GetHomeOutputDirectory();
this->SetDirectoriesFromFile(cachePath.c_str());
this->AddProjectCommands();
int ret = this->Configure();
if (ret) {
cmSystemTools::Message("CMake Configure step failed. "
"Build files cannot be regenerated correctly.");
return ret;
}
ret = this->Generate();
if (ret) {
cmSystemTools::Message("CMake Generate step failed. "
"Build files cannot be regenerated correctly.");
return ret;
}
std::string message = "Build files have been written to: ";
message += this->GetHomeOutputDirectory();
this->UpdateProgress(message.c_str(), -1);
// Restore the previously set directories to their original value.
this->SetHomeDirectory(homeOrig);
this->SetHomeOutputDirectory(homeOutputOrig);
}
}
#endif
gen->PrintBuildCommandAdvice(std::cerr, jobs);
return gen->Build(jobs, "", dir, projName, target, output, "", config, clean,
false, verbose, cmDuration::zero(),
cmSystemTools::OUTPUT_PASSTHROUGH, nativeOptions);
}
bool cmake::Open(const std::string& dir, bool dryRun)
{
this->SetHomeDirectory("");
this->SetHomeOutputDirectory("");
if (!cmSystemTools::FileIsDirectory(dir)) {
std::cerr << "Error: " << dir << " is not a directory\n";
return false;
}
std::string cachePath = FindCacheFile(dir);
if (!this->LoadCache(cachePath)) {
std::cerr << "Error: could not load cache\n";
return false;
}
const char* genName = this->State->GetCacheEntryValue("CMAKE_GENERATOR");
if (!genName) {
std::cerr << "Error: could not find CMAKE_GENERATOR in Cache\n";
return false;
}
const std::string* extraGenName =
this->State->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
std::string fullName =
cmExternalMakefileProjectGenerator::CreateFullGeneratorName(
genName, extraGenName ? *extraGenName : "");
std::unique_ptr<cmGlobalGenerator> gen(
this->CreateGlobalGenerator(fullName));
if (!gen.get()) {
std::cerr << "Error: could create CMAKE_GENERATOR \"" << fullName
<< "\"\n";
return false;
}
const char* cachedProjectName =
this->State->GetCacheEntryValue("CMAKE_PROJECT_NAME");
if (!cachedProjectName) {
std::cerr << "Error: could not find CMAKE_PROJECT_NAME in Cache\n";
return false;
}
return gen->Open(dir, cachedProjectName, dryRun);
}
void cmake::WatchUnusedCli(const std::string& var)
{
#ifdef CMAKE_BUILD_WITH_CMAKE
this->VariableWatch->AddWatch(var, cmWarnUnusedCliWarning, this);
if (this->UsedCliVariables.find(var) == this->UsedCliVariables.end()) {
this->UsedCliVariables[var] = false;
}
#endif
}
void cmake::UnwatchUnusedCli(const std::string& var)
{
#ifdef CMAKE_BUILD_WITH_CMAKE
this->VariableWatch->RemoveWatch(var, cmWarnUnusedCliWarning);
this->UsedCliVariables.erase(var);
#endif
}
void cmake::RunCheckForUnusedVariables()
{
#ifdef CMAKE_BUILD_WITH_CMAKE
bool haveUnused = false;
std::ostringstream msg;
msg << "Manually-specified variables were not used by the project:";
for (auto const& it : this->UsedCliVariables) {
if (!it.second) {
haveUnused = true;
msg << "\n " << it.first;
}
}
if (haveUnused) {
this->IssueMessage(cmake::WARNING, msg.str());
}
#endif
}
bool cmake::GetSuppressDevWarnings() const
{
return this->Messenger->GetSuppressDevWarnings();
}
void cmake::SetSuppressDevWarnings(bool b)
{
std::string value;
// equivalent to -Wno-dev
if (b) {
value = "TRUE";
}
// equivalent to -Wdev
else {
value = "FALSE";
}
this->AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", value.c_str(),
"Suppress Warnings that are meant for"
" the author of the CMakeLists.txt files.",
cmStateEnums::INTERNAL);
}
bool cmake::GetSuppressDeprecatedWarnings() const
{
return this->Messenger->GetSuppressDeprecatedWarnings();
}
void cmake::SetSuppressDeprecatedWarnings(bool b)
{
std::string value;
// equivalent to -Wno-deprecated
if (b) {
value = "FALSE";
}
// equivalent to -Wdeprecated
else {
value = "TRUE";
}
this->AddCacheEntry("CMAKE_WARN_DEPRECATED", value.c_str(),
"Whether to issue warnings for deprecated "
"functionality.",
cmStateEnums::INTERNAL);
}
bool cmake::GetDevWarningsAsErrors() const
{
return this->Messenger->GetDevWarningsAsErrors();
}
void cmake::SetDevWarningsAsErrors(bool b)
{
std::string value;
// equivalent to -Werror=dev
if (b) {
value = "FALSE";
}
// equivalent to -Wno-error=dev
else {
value = "TRUE";
}
this->AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_ERRORS", value.c_str(),
"Suppress errors that are meant for"
" the author of the CMakeLists.txt files.",
cmStateEnums::INTERNAL);
}
bool cmake::GetDeprecatedWarningsAsErrors() const
{
return this->Messenger->GetDeprecatedWarningsAsErrors();
}
void cmake::SetDeprecatedWarningsAsErrors(bool b)
{
std::string value;
// equivalent to -Werror=deprecated
if (b) {
value = "TRUE";
}
// equivalent to -Wno-error=deprecated
else {
value = "FALSE";
}
this->AddCacheEntry("CMAKE_ERROR_DEPRECATED", value.c_str(),
"Whether to issue deprecation errors for macros"
" and functions.",
cmStateEnums::INTERNAL);
}
Computing file changes ...
