mirrors/cmake
2
0
Fork 0
mirror of https://gitlab.kitware.com/cmake/cmake.git synced 2026-09-25 04:09:36 +03:00
Code Activity

cmFileCommand: port to cmExecutionStatus

Browse Source
This commit is contained in:
Daniel Pfeifer
2019-08-06 11:42:25 +02:00
committed by Regina Pfeifer
parent 53fc083d37
commit 64f987c174
6 changed files with 408 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/cmFileCommand.cxx
+306 -283
View File
@@ -25,6 +25,7 @@
#include "cmAlgorithms.h"
#include "cmArgumentParser.h"
#include "cmCryptoHash.h"
#include "cmExecutionStatus.h"
#include "cmFileCopier.h"
#include "cmFileInstaller.h"
#include "cmFileLockPool.h"
@@ -86,121 +87,121 @@ static std::string fix_file_url_windows(const std::string& url)
// cmLibraryCommand
bool cmFileCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&)
cmExecutionStatus& status)
{
if (args.size() < 2) {
this->SetError("must be called with at least two arguments.");
status.SetError("must be called with at least two arguments.");
return false;
}
std::string const& subCommand = args[0];
if (subCommand == "WRITE") {
return this->HandleWriteCommand(args, false);
return this->HandleWriteCommand(args, false, status);
}
if (subCommand == "APPEND") {
return this->HandleWriteCommand(args, true);
return this->HandleWriteCommand(args, true, status);
}
if (subCommand == "DOWNLOAD") {
return this->HandleDownloadCommand(args);
return this->HandleDownloadCommand(args, status);
}
if (subCommand == "UPLOAD") {
return this->HandleUploadCommand(args);
return this->HandleUploadCommand(args, status);
}
if (subCommand == "READ") {
return this->HandleReadCommand(args);
return this->HandleReadCommand(args, status);
}
if (subCommand == "MD5" || subCommand == "SHA1" || subCommand == "SHA224" ||
subCommand == "SHA256" || subCommand == "SHA384" ||
subCommand == "SHA512" || subCommand == "SHA3_224" ||
subCommand == "SHA3_256" || subCommand == "SHA3_384" ||
subCommand == "SHA3_512") {
return this->HandleHashCommand(args);
return this->HandleHashCommand(args, status);
}
if (subCommand == "STRINGS") {
return this->HandleStringsCommand(args);
return this->HandleStringsCommand(args, status);
}
if (subCommand == "GLOB") {
return this->HandleGlobCommand(args, false);
return this->HandleGlobCommand(args, false, status);
}
if (subCommand == "GLOB_RECURSE") {
return this->HandleGlobCommand(args, true);
return this->HandleGlobCommand(args, true, status);
}
if (subCommand == "MAKE_DIRECTORY") {
return this->HandleMakeDirectoryCommand(args);
return this->HandleMakeDirectoryCommand(args, status);
}
if (subCommand == "RENAME") {
return this->HandleRename(args);
return this->HandleRename(args, status);
}
if (subCommand == "REMOVE") {
return this->HandleRemove(args, false);
return this->HandleRemove(args, false, status);
}
if (subCommand == "REMOVE_RECURSE") {
return this->HandleRemove(args, true);
return this->HandleRemove(args, true, status);
}
if (subCommand == "COPY") {
return this->HandleCopyCommand(args);
return this->HandleCopyCommand(args, status);
}
if (subCommand == "INSTALL") {
return this->HandleInstallCommand(args);
return this->HandleInstallCommand(args, status);
}
if (subCommand == "DIFFERENT") {
return this->HandleDifferentCommand(args);
return this->HandleDifferentCommand(args, status);
}
if (subCommand == "RPATH_CHANGE" || subCommand == "CHRPATH") {
return this->HandleRPathChangeCommand(args);
return this->HandleRPathChangeCommand(args, status);
}
if (subCommand == "RPATH_CHECK") {
return this->HandleRPathCheckCommand(args);
return this->HandleRPathCheckCommand(args, status);
}
if (subCommand == "RPATH_REMOVE") {
return this->HandleRPathRemoveCommand(args);
return this->HandleRPathRemoveCommand(args, status);
}
if (subCommand == "READ_ELF") {
return this->HandleReadElfCommand(args);
return this->HandleReadElfCommand(args, status);
}
if (subCommand == "RELATIVE_PATH") {
return this->HandleRelativePathCommand(args);
return this->HandleRelativePathCommand(args, status);
}
if (subCommand == "TO_CMAKE_PATH") {
return this->HandleCMakePathCommand(args, false);
return this->HandleCMakePathCommand(args, false, status);
}
if (subCommand == "TO_NATIVE_PATH") {
return this->HandleCMakePathCommand(args, true);
return this->HandleCMakePathCommand(args, true, status);
}
if (subCommand == "TOUCH") {
return this->HandleTouchCommand(args, true);
return this->HandleTouchCommand(args, true, status);
}
if (subCommand == "TOUCH_NOCREATE") {
return this->HandleTouchCommand(args, false);
return this->HandleTouchCommand(args, false, status);
}
if (subCommand == "TIMESTAMP") {
return this->HandleTimestampCommand(args);
return this->HandleTimestampCommand(args, status);
}
if (subCommand == "GENERATE") {
return this->HandleGenerateCommand(args);
return this->HandleGenerateCommand(args, status);
}
if (subCommand == "LOCK") {
return this->HandleLockCommand(args);
return this->HandleLockCommand(args, status);
}
if (subCommand == "SIZE") {
return this->HandleSizeCommand(args);
return this->HandleSizeCommand(args, status);
}
if (subCommand == "READ_SYMLINK") {
return this->HandleReadSymlinkCommand(args);
return this->HandleReadSymlinkCommand(args, status);
}
if (subCommand == "CREATE_LINK") {
return this->HandleCreateLinkCommand(args);
return this->HandleCreateLinkCommand(args, status);
}
if (subCommand == "GET_RUNTIME_DEPENDENCIES") {
return this->HandleGetRuntimeDependenciesCommand(args);
return this->HandleGetRuntimeDependenciesCommand(args, status);
}
std::string e = "does not recognize sub-command " + subCommand;
this->SetError(e);
status.SetError(e);
return false;
}
bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
bool append)
bool append, cmExecutionStatus& status)
{
std::vector<std::string>::const_iterator i = args.begin();
@@ -208,16 +209,16 @@ bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
std::string fileName = *i;
if (!cmsys::SystemTools::FileIsFullPath(*i)) {
fileName = this->Makefile->GetCurrentSourceDirectory();
fileName = status.GetMakefile().GetCurrentSourceDirectory();
fileName += "/" + *i;
}
i++;
if (!this->Makefile->CanIWriteThisFile(fileName)) {
if (!status.GetMakefile().CanIWriteThisFile(fileName)) {
std::string e =
"attempted to write a file: " + fileName + " into a source directory.";
this->SetError(e);
status.SetError(e);
cmSystemTools::SetFatalErrorOccured();
return false;
}
@@ -249,7 +250,7 @@ bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
error += cmSystemTools::GetLastSystemError();
error += "):\n ";
error += fileName;
this->SetError(error);
status.SetError(error);
return false;
}
std::string message = cmJoin(cmMakeRange(i, args.end()), std::string());
@@ -259,7 +260,7 @@ bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
error += cmSystemTools::GetLastSystemError();
error += "):\n ";
error += fileName;
this->SetError(error);
status.SetError(error);
return false;
}
file.close();
@@ -269,11 +270,12 @@ bool cmFileCommand::HandleWriteCommand(std::vector<std::string> const& args,
return true;
}
bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 3) {
this->SetError("READ must be called with at least two additional "
"arguments");
status.SetError("READ must be called with at least two additional "
"arguments");
return false;
}
@@ -296,7 +298,7 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
std::string fileName = fileNameArg;
if (!cmsys::SystemTools::FileIsFullPath(fileName)) {
fileName = this->Makefile->GetCurrentSourceDirectory();
fileName = status.GetMakefile().GetCurrentSourceDirectory();
fileName += "/" + fileNameArg;
}
@@ -314,7 +316,7 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
error += cmSystemTools::GetLastSystemError();
error += "):\n ";
error += fileName;
this->SetError(error);
status.SetError(error);
return false;
}
@@ -366,17 +368,18 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args)
}
}
}
this->Makefile->AddDefinition(variable, output);
status.GetMakefile().AddDefinition(variable, output);
return true;
}
bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args)
bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
#if defined(CMAKE_BUILD_WITH_CMAKE)
if (args.size() != 3) {
std::ostringstream e;
e << args[0] << " requires a file name and output variable";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
@@ -384,34 +387,35 @@ bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args)
if (hash) {
std::string out = hash->HashFile(args[1]);
if (!out.empty()) {
this->Makefile->AddDefinition(args[2], out);
status.GetMakefile().AddDefinition(args[2], out);
return true;
}
std::ostringstream e;
e << args[0] << " failed to read file \"" << args[1]
<< "\": " << cmSystemTools::GetLastSystemError();
this->SetError(e.str());
status.SetError(e.str());
}
return false;
#else
std::ostringstream e;
e << args[0] << " not available during bootstrap";
this->SetError(e.str());
status.SetError(e.str());
return false;
#endif
}
bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 3) {
this->SetError("STRINGS requires a file name and output variable");
status.SetError("STRINGS requires a file name and output variable");
return false;
}
// Get the file to read.
std::string fileName = args[1];
if (!cmsys::SystemTools::FileIsFullPath(fileName)) {
fileName = this->Makefile->GetCurrentSourceDirectory();
fileName = status.GetMakefile().GetCurrentSourceDirectory();
fileName += "/" + args[1];
}
@@ -478,7 +482,7 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
std::ostringstream e;
e << "STRINGS option LIMIT_INPUT value \"" << args[i]
<< "\" is not an unsigned integer.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
arg_mode = arg_none;
@@ -488,7 +492,7 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
std::ostringstream e;
e << "STRINGS option LIMIT_OUTPUT value \"" << args[i]
<< "\" is not an unsigned integer.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
arg_mode = arg_none;
@@ -498,7 +502,7 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
std::ostringstream e;
e << "STRINGS option LIMIT_COUNT value \"" << args[i]
<< "\" is not an unsigned integer.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
limit_count = count;
@@ -509,7 +513,7 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
std::ostringstream e;
e << "STRINGS option LENGTH_MINIMUM value \"" << args[i]
<< "\" is not an unsigned integer.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
minlen = len;
@@ -520,7 +524,7 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
std::ostringstream e;
e << "STRINGS option LENGTH_MAXIMUM value \"" << args[i]
<< "\" is not an unsigned integer.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
maxlen = len;
@@ -530,7 +534,7 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
std::ostringstream e;
e << "STRINGS option REGEX value \"" << args[i]
<< "\" could not be compiled.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
have_regex = true;
@@ -549,21 +553,22 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
} else {
std::ostringstream e;
e << "STRINGS option ENCODING \"" << args[i] << "\" not recognized.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
arg_mode = arg_none;
} else {
std::ostringstream e;
e << "STRINGS given unknown argument \"" << args[i] << "\"";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
}
if (hex_conversion_enabled) {
// TODO: should work without temp file, but just on a memory buffer
std::string binaryFileName = this->Makefile->GetCurrentBinaryDirectory();
std::string binaryFileName =
status.GetMakefile().GetCurrentBinaryDirectory();
binaryFileName += "/CMakeFiles";
binaryFileName += "/FileCommandStringsBinaryFile";
if (cmHexFileConverter::TryConvert(fileName, binaryFileName)) {
@@ -580,7 +585,7 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
if (!fin) {
std::ostringstream e;
e << "STRINGS file \"" << fileName << "\" cannot be read.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
@@ -752,12 +757,12 @@ bool cmFileCommand::HandleStringsCommand(std::vector<std::string> const& args)
}
// Save the output in a makefile variable.
this->Makefile->AddDefinition(outVar, output);
status.GetMakefile().AddDefinition(outVar, output);
return true;
}
bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
bool recurse)
bool recurse, cmExecutionStatus& status)
{
// File commands has at least one argument
assert(args.size() > 1);
@@ -772,10 +777,10 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
g.SetRecurse(recurse);
bool explicitFollowSymlinks = false;
cmPolicies::PolicyStatus status =
this->Makefile->GetPolicyStatus(cmPolicies::CMP0009);
cmPolicies::PolicyStatus policyStatus =
status.GetMakefile().GetPolicyStatus(cmPolicies::CMP0009);
if (recurse) {
switch (status) {
switch (policyStatus) {
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
case cmPolicies::NEW:
@@ -793,7 +798,7 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
bool warnConfigureLate = false;
bool warnFollowedSymlinks = false;
const cmake::WorkingMode workingMode =
this->Makefile->GetCMakeInstance()->GetWorkingMode();
status.GetMakefile().GetCMakeInstance()->GetWorkingMode();
while (i != args.end()) {
if (*i == "LIST_DIRECTORIES") {
++i; // skip LIST_DIRECTORIES
@@ -805,12 +810,12 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
g.SetListDirs(false);
g.SetRecurseListDirs(false);
} else {
this->SetError("LIST_DIRECTORIES missing bool value.");
status.SetError("LIST_DIRECTORIES missing bool value.");
return false;
}
++i;
} else {
this->SetError("LIST_DIRECTORIES missing bool value.");
status.SetError("LIST_DIRECTORIES missing bool value.");
return false;
}
} else if (*i == "FOLLOW_SYMLINKS") {
@@ -819,7 +824,7 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
explicitFollowSymlinks = true;
g.RecurseThroughSymlinksOn();
if (i == args.end()) {
this->SetError(
status.SetError(
"GLOB_RECURSE requires a glob expression after FOLLOW_SYMLINKS.");
return false;
}
@@ -827,25 +832,26 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
} else if (*i == "RELATIVE") {
++i; // skip RELATIVE
if (i == args.end()) {
this->SetError("GLOB requires a directory after the RELATIVE tag.");
status.SetError("GLOB requires a directory after the RELATIVE tag.");
return false;
}
g.SetRelative(i->c_str());
++i;
if (i == args.end()) {
this->SetError("GLOB requires a glob expression after the directory.");
status.SetError(
"GLOB requires a glob expression after the directory.");
return false;
}
} else if (*i == "CONFIGURE_DEPENDS") {
// Generated build system depends on glob results
if (!configureDepends && warnConfigureLate) {
this->Makefile->IssueMessage(
status.GetMakefile().IssueMessage(
MessageType::AUTHOR_WARNING,
"CONFIGURE_DEPENDS flag was given after a glob expression was "
"already evaluated.");
}
if (workingMode != cmake::NORMAL_MODE) {
this->Makefile->IssueMessage(
status.GetMakefile().IssueMessage(
MessageType::FATAL_ERROR,
"CONFIGURE_DEPENDS is invalid for script and find package modes.");
return false;
@@ -853,14 +859,14 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
configureDepends = true;
++i;
if (i == args.end()) {
this->SetError(
status.SetError(
"GLOB requires a glob expression after CONFIGURE_DEPENDS.");
return false;
}
} else {
std::string expr = *i;
if (!cmsys::SystemTools::FileIsFullPath(*i)) {
expr = this->Makefile->GetCurrentSourceDirectory();
expr = status.GetMakefile().GetCurrentSourceDirectory();
// Handle script mode
if (!expr.empty()) {
expr += "/" + *i;
@@ -876,12 +882,12 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
bool shouldExit = false;
for (cmsys::Glob::Message const& globMessage : globMessages) {
if (globMessage.type == cmsys::Glob::cyclicRecursion) {
this->Makefile->IssueMessage(
status.GetMakefile().IssueMessage(
MessageType::AUTHOR_WARNING,
"Cyclic recursion detected while globbing for '" + *i + "':\n" +
globMessage.content);
} else {
this->Makefile->IssueMessage(
status.GetMakefile().IssueMessage(
MessageType::FATAL_ERROR,
"Error has occurred while globbing for '" + *i + "' - " +
globMessage.content);
@@ -905,11 +911,11 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
std::sort(foundFiles.begin(), foundFiles.end());
foundFiles.erase(std::unique(foundFiles.begin(), foundFiles.end()),
foundFiles.end());
this->Makefile->GetCMakeInstance()->AddGlobCacheEntry(
status.GetMakefile().GetCMakeInstance()->AddGlobCacheEntry(
recurse, (recurse ? g.GetRecurseListDirs() : g.GetListDirs()),
(recurse ? g.GetRecurseThroughSymlinks() : false),
(g.GetRelative() ? g.GetRelative() : ""), expr, foundFiles, variable,
this->Makefile->GetBacktrace());
status.GetMakefile().GetBacktrace());
} else {
warnConfigureLate = true;
}
@@ -917,7 +923,7 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
}
}
switch (status) {
switch (policyStatus) {
case cmPolicies::REQUIRED_IF_USED:
case cmPolicies::REQUIRED_ALWAYS:
case cmPolicies::NEW:
@@ -930,7 +936,7 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
// Possibly unexpected old behavior *and* we actually traversed
// symlinks without being explicitly asked to: warn the author.
if (warnFollowedSymlinks) {
this->Makefile->IssueMessage(
status.GetMakefile().IssueMessage(
MessageType::AUTHOR_WARNING,
cmPolicies::GetPolicyWarning(cmPolicies::CMP0009));
}
@@ -939,12 +945,12 @@ bool cmFileCommand::HandleGlobCommand(std::vector<std::string> const& args,
std::sort(files.begin(), files.end());
files.erase(std::unique(files.begin(), files.end()), files.end());
this->Makefile->AddDefinition(variable, cmJoin(files, ";"));
status.GetMakefile().AddDefinition(variable, cmJoin(files, ";"));
return true;
}
bool cmFileCommand::HandleMakeDirectoryCommand(
std::vector<std::string> const& args)
std::vector<std::string> const& args, cmExecutionStatus& status)
{
// File command has at least one argument
assert(args.size() > 1);
@@ -955,20 +961,20 @@ bool cmFileCommand::HandleMakeDirectoryCommand(
{
const std::string* cdir = &arg;
if (!cmsys::SystemTools::FileIsFullPath(arg)) {
expr = this->Makefile->GetCurrentSourceDirectory();
expr = status.GetMakefile().GetCurrentSourceDirectory();
expr += "/" + arg;
cdir = &expr;
}
if (!this->Makefile->CanIWriteThisFile(*cdir)) {
if (!status.GetMakefile().CanIWriteThisFile(*cdir)) {
std::string e = "attempted to create a directory: " + *cdir +
" into a source directory.";
this->SetError(e);
status.SetError(e);
cmSystemTools::SetFatalErrorOccured();
return false;
}
if (!cmSystemTools::MakeDirectory(*cdir)) {
std::string error = "problem creating directory: " + *cdir;
this->SetError(error);
status.SetError(error);
return false;
}
}
@@ -976,7 +982,7 @@ bool cmFileCommand::HandleMakeDirectoryCommand(
}
bool cmFileCommand::HandleTouchCommand(std::vector<std::string> const& args,
bool create)
bool create, cmExecutionStatus& status)
{
// File command has at least one argument
assert(args.size() > 1);
@@ -986,19 +992,19 @@ bool cmFileCommand::HandleTouchCommand(std::vector<std::string> const& args,
{
std::string tfile = arg;
if (!cmsys::SystemTools::FileIsFullPath(tfile)) {
tfile = this->Makefile->GetCurrentSourceDirectory();
tfile = status.GetMakefile().GetCurrentSourceDirectory();
tfile += "/" + arg;
}
if (!this->Makefile->CanIWriteThisFile(tfile)) {
if (!status.GetMakefile().CanIWriteThisFile(tfile)) {
std::string e =
"attempted to touch a file: " + tfile + " in a source directory.";
this->SetError(e);
status.SetError(e);
cmSystemTools::SetFatalErrorOccured();
return false;
}
if (!cmSystemTools::Touch(tfile, create)) {
std::string error = "problem touching file: " + tfile;
this->SetError(error);
status.SetError(error);
return false;
}
}
@@ -1006,7 +1012,7 @@ bool cmFileCommand::HandleTouchCommand(std::vector<std::string> const& args,
}
bool cmFileCommand::HandleDifferentCommand(
std::vector<std::string> const& args)
std::vector<std::string> const& args, cmExecutionStatus& status)
{
/*
FILE(DIFFERENT <variable> FILES <lhs> <rhs>)
@@ -1039,34 +1045,35 @@ bool cmFileCommand::HandleDifferentCommand(
} else {
std::ostringstream e;
e << "DIFFERENT given unknown argument " << args[i];
this->SetError(e.str());
status.SetError(e.str());
return false;
}
}
if (!var) {
this->SetError("DIFFERENT not given result variable name.");
status.SetError("DIFFERENT not given result variable name.");
return false;
}
if (!file_lhs || !file_rhs) {
this->SetError("DIFFERENT not given FILES option with two file names.");
status.SetError("DIFFERENT not given FILES option with two file names.");
return false;
}
// Compare the files.
const char* result =
cmSystemTools::FilesDiffer(file_lhs, file_rhs) ? "1" : "0";
this->Makefile->AddDefinition(var, result);
status.GetMakefile().AddDefinition(var, result);
return true;
}
bool cmFileCommand::HandleCopyCommand(std::vector<std::string> const& args)
bool cmFileCommand::HandleCopyCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
cmFileCopier copier(this);
cmFileCopier copier(status);
return copier.Run(args);
}
bool cmFileCommand::HandleRPathChangeCommand(
std::vector<std::string> const& args)
std::vector<std::string> const& args, cmExecutionStatus& status)
{
// Evaluate arguments.
std::string file;
@@ -1102,26 +1109,26 @@ bool cmFileCommand::HandleRPathChangeCommand(
} else {
std::ostringstream e;
e << "RPATH_CHANGE given unknown argument " << args[i];
this->SetError(e.str());
status.SetError(e.str());
return false;
}
}
if (file.empty()) {
this->SetError("RPATH_CHANGE not given FILE option.");
status.SetError("RPATH_CHANGE not given FILE option.");
return false;
}
if (!oldRPath) {
this->SetError("RPATH_CHANGE not given OLD_RPATH option.");
status.SetError("RPATH_CHANGE not given OLD_RPATH option.");
return false;
}
if (!newRPath) {
this->SetError("RPATH_CHANGE not given NEW_RPATH option.");
status.SetError("RPATH_CHANGE not given NEW_RPATH option.");
return false;
}
if (!cmSystemTools::FileExists(file, true)) {
std::ostringstream e;
e << "RPATH_CHANGE given FILE \"" << file << "\" that does not exist.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
bool success = true;
@@ -1139,7 +1146,7 @@ bool cmFileCommand::HandleRPathChangeCommand(
<< " " << file << "\n"
<< emsg;
/* clang-format on */
this->SetError(e.str());
status.SetError(e.str());
success = false;
}
if (success) {
@@ -1149,7 +1156,7 @@ bool cmFileCommand::HandleRPathChangeCommand(
message += "\" to \"";
message += newRPath;
message += "\"";
this->Makefile->DisplayStatus(message, -1);
status.GetMakefile().DisplayStatus(message, -1);
}
ft.Store(file);
}
@@ -1157,7 +1164,7 @@ bool cmFileCommand::HandleRPathChangeCommand(
}
bool cmFileCommand::HandleRPathRemoveCommand(
std::vector<std::string> const& args)
std::vector<std::string> const& args, cmExecutionStatus& status)
{
// Evaluate arguments.
std::string file;
@@ -1176,18 +1183,18 @@ bool cmFileCommand::HandleRPathRemoveCommand(
} else {
std::ostringstream e;
e << "RPATH_REMOVE given unknown argument " << args[i];
this->SetError(e.str());
status.SetError(e.str());
return false;
}
}
if (file.empty()) {
this->SetError("RPATH_REMOVE not given FILE option.");
status.SetError("RPATH_REMOVE not given FILE option.");
return false;
}
if (!cmSystemTools::FileExists(file, true)) {
std::ostringstream e;
e << "RPATH_REMOVE given FILE \"" << file << "\" that does not exist.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
bool success = true;
@@ -1201,7 +1208,7 @@ bool cmFileCommand::HandleRPathRemoveCommand(
<< " " << file << "\n"
<< emsg;
/* clang-format on */
this->SetError(e.str());
status.SetError(e.str());
success = false;
}
if (success) {
@@ -1209,7 +1216,7 @@ bool cmFileCommand::HandleRPathRemoveCommand(
std::string message = "Removed runtime path from \"";
message += file;
message += "\"";
this->Makefile->DisplayStatus(message, -1);
status.GetMakefile().DisplayStatus(message, -1);
}
ft.Store(file);
}
@@ -1217,7 +1224,7 @@ bool cmFileCommand::HandleRPathRemoveCommand(
}
bool cmFileCommand::HandleRPathCheckCommand(
std::vector<std::string> const& args)
std::vector<std::string> const& args, cmExecutionStatus& status)
{
// Evaluate arguments.
std::string file;
@@ -1243,16 +1250,16 @@ bool cmFileCommand::HandleRPathCheckCommand(
} else {
std::ostringstream e;
e << "RPATH_CHECK given unknown argument " << args[i];
this->SetError(e.str());
status.SetError(e.str());
return false;
}
}
if (file.empty()) {
this->SetError("RPATH_CHECK not given FILE option.");
status.SetError("RPATH_CHECK not given FILE option.");
return false;
}
if (!rpath) {
this->SetError("RPATH_CHECK not given RPATH option.");
status.SetError("RPATH_CHECK not given RPATH option.");
return false;
}
@@ -1267,11 +1274,12 @@ bool cmFileCommand::HandleRPathCheckCommand(
return true;
}
bool cmFileCommand::HandleReadElfCommand(std::vector<std::string> const& args)
bool cmFileCommand::HandleReadElfCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 4) {
this->SetError("READ_ELF must be called with at least three additional "
"arguments.");
status.SetError("READ_ELF must be called with at least three additional "
"arguments.");
return false;
}
@@ -1293,7 +1301,7 @@ bool cmFileCommand::HandleReadElfCommand(std::vector<std::string> const& args)
if (!cmSystemTools::FileExists(fileNameArg, true)) {
std::ostringstream e;
e << "READ_ELF given FILE \"" << fileNameArg << "\" that does not exist.";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
@@ -1304,14 +1312,14 @@ bool cmFileCommand::HandleReadElfCommand(std::vector<std::string> const& args)
if (cmELF::StringEntry const* se_rpath = elf.GetRPath()) {
std::string rpath(se_rpath->Value);
std::replace(rpath.begin(), rpath.end(), ':', ';');
this->Makefile->AddDefinition(arguments.RPath, rpath);
status.GetMakefile().AddDefinition(arguments.RPath, rpath);
}
}
if (!arguments.RunPath.empty()) {
if (cmELF::StringEntry const* se_runpath = elf.GetRunPath()) {
std::string runpath(se_runpath->Value);
std::replace(runpath.begin(), runpath.end(), ':', ';');
this->Makefile->AddDefinition(arguments.RunPath, runpath);
status.GetMakefile().AddDefinition(arguments.RunPath, runpath);
}
}
@@ -1319,25 +1327,26 @@ bool cmFileCommand::HandleReadElfCommand(std::vector<std::string> const& args)
#else
std::string error = "ELF parser not available on this platform.";
if (arguments.Error.empty()) {
this->SetError(error);
status.SetError(error);
return false;
}
this->Makefile->AddDefinition(arguments.Error, error);
status.GetMakefile().AddDefinition(arguments.Error, error);
return true;
#endif
}
bool cmFileCommand::HandleInstallCommand(std::vector<std::string> const& args)
bool cmFileCommand::HandleInstallCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
cmFileInstaller installer(this);
cmFileInstaller installer(status);
return installer.Run(args);
}
bool cmFileCommand::HandleRelativePathCommand(
std::vector<std::string> const& args)
std::vector<std::string> const& args, cmExecutionStatus& status)
{
if (args.size() != 4) {
this->SetError("RELATIVE_PATH called with incorrect number of arguments");
status.SetError("RELATIVE_PATH called with incorrect number of arguments");
return false;
}
@@ -1349,37 +1358,38 @@ bool cmFileCommand::HandleRelativePathCommand(
std::string errstring =
"RELATIVE_PATH must be passed a full path to the directory: " +
directoryName;
this->SetError(errstring);
status.SetError(errstring);
return false;
}
if (!cmSystemTools::FileIsFullPath(fileName)) {
std::string errstring =
"RELATIVE_PATH must be passed a full path to the file: " + fileName;
this->SetError(errstring);
status.SetError(errstring);
return false;
}
std::string res = cmSystemTools::RelativePath(directoryName, fileName);
this->Makefile->AddDefinition(outVar, res);
status.GetMakefile().AddDefinition(outVar, res);
return true;
}
bool cmFileCommand::HandleRename(std::vector<std::string> const& args)
bool cmFileCommand::HandleRename(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 3) {
this->SetError("RENAME given incorrect number of arguments.");
status.SetError("RENAME given incorrect number of arguments.");
return false;
}
// Compute full path for old and new names.
std::string oldname = args[1];
if (!cmsys::SystemTools::FileIsFullPath(oldname)) {
oldname = this->Makefile->GetCurrentSourceDirectory();
oldname = status.GetMakefile().GetCurrentSourceDirectory();
oldname += "/" + args[1];
}
std::string newname = args[2];
if (!cmsys::SystemTools::FileIsFullPath(newname)) {
newname = this->Makefile->GetCurrentSourceDirectory();
newname = status.GetMakefile().GetCurrentSourceDirectory();
newname += "/" + args[2];
}
@@ -1393,14 +1403,14 @@ bool cmFileCommand::HandleRename(std::vector<std::string> const& args)
<< " " << newname << "\n"
<< "because: " << err << "\n";
/* clang-format on */
this->SetError(e.str());
status.SetError(e.str());
return false;
}
return true;
}
bool cmFileCommand::HandleRemove(std::vector<std::string> const& args,
bool recurse)
bool recurse, cmExecutionStatus& status)
{
std::string message;
@@ -1411,12 +1421,12 @@ bool cmFileCommand::HandleRemove(std::vector<std::string> const& args,
std::string fileName = arg;
if (fileName.empty()) {
std::string const r = recurse ? "REMOVE_RECURSE" : "REMOVE";
this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING,
"Ignoring empty file name in " + r + ".");
status.GetMakefile().IssueMessage(
MessageType::AUTHOR_WARNING, "Ignoring empty file name in " + r + ".");
continue;
}
if (!cmsys::SystemTools::FileIsFullPath(fileName)) {
fileName = this->Makefile->GetCurrentSourceDirectory();
fileName = status.GetMakefile().GetCurrentSourceDirectory();
fileName += "/" + arg;
}
@@ -1450,11 +1460,12 @@ std::string ToCMakePath(const std::string& path)
}
bool cmFileCommand::HandleCMakePathCommand(
std::vector<std::string> const& args, bool nativePath)
std::vector<std::string> const& args, bool nativePath,
cmExecutionStatus& status)
{
if (args.size() != 3) {
this->SetError("FILE([TO_CMAKE_PATH|TO_NATIVE_PATH] path result) must be "
"called with exactly three arguments.");
status.SetError("FILE([TO_CMAKE_PATH|TO_NATIVE_PATH] path result) must be "
"called with exactly three arguments.");
return false;
}
#if defined(_WIN32) && !defined(__CYGWIN__)
@@ -1466,7 +1477,7 @@ bool cmFileCommand::HandleCMakePathCommand(
std::string value = cmJoin(
cmMakeRange(path).transform(nativePath ? ToNativePath : ToCMakePath), ";");
this->Makefile->AddDefinition(args[2], value);
status.GetMakefile().AddDefinition(args[2], value);
return true;
}
@@ -1636,17 +1647,18 @@ private:
if (result != CURLE_OK) { \
std::string e(errstr); \
e += ::curl_easy_strerror(result); \
this->SetError(e); \
status.SetError(e); \
return false; \
} \
} while (false)
bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
#if defined(CMAKE_BUILD_WITH_CMAKE)
std::vector<std::string>::const_iterator i = args.begin();
if (args.size() < 3) {
this->SetError("DOWNLOAD must be called with at least three arguments.");
status.SetError("DOWNLOAD must be called with at least three arguments.");
return false;
}
++i; // Get rid of subcommand
@@ -1659,11 +1671,12 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
long inactivity_timeout = 0;
std::string logVar;
std::string statusVar;
bool tls_verify = this->Makefile->IsOn("CMAKE_TLS_VERIFY");
const char* cainfo = this->Makefile->GetDefinition("CMAKE_TLS_CAINFO");
std::string netrc_level = this->Makefile->GetSafeDefinition("CMAKE_NETRC");
bool tls_verify = status.GetMakefile().IsOn("CMAKE_TLS_VERIFY");
const char* cainfo = status.GetMakefile().GetDefinition("CMAKE_TLS_CAINFO");
std::string netrc_level =
status.GetMakefile().GetSafeDefinition("CMAKE_NETRC");
std::string netrc_file =
this->Makefile->GetSafeDefinition("CMAKE_NETRC_FILE");
status.GetMakefile().GetSafeDefinition("CMAKE_NETRC_FILE");
std::string expectedHash;
std::string hashMatchMSG;
std::unique_ptr<cmCryptoHash> hash;
@@ -1678,7 +1691,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
if (i != args.end()) {
timeout = atol(i->c_str());
} else {
this->SetError("DOWNLOAD missing time for TIMEOUT.");
status.SetError("DOWNLOAD missing time for TIMEOUT.");
return false;
}
} else if (*i == "INACTIVITY_TIMEOUT") {
@@ -1686,20 +1699,20 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
if (i != args.end()) {
inactivity_timeout = atol(i->c_str());
} else {
this->SetError("DOWNLOAD missing time for INACTIVITY_TIMEOUT.");
status.SetError("DOWNLOAD missing time for INACTIVITY_TIMEOUT.");
return false;
}
} else if (*i == "LOG") {
++i;
if (i == args.end()) {
this->SetError("DOWNLOAD missing VAR for LOG.");
status.SetError("DOWNLOAD missing VAR for LOG.");
return false;
}
logVar = *i;
} else if (*i == "STATUS") {
++i;
if (i == args.end()) {
this->SetError("DOWNLOAD missing VAR for STATUS.");
status.SetError("DOWNLOAD missing VAR for STATUS.");
return false;
}
statusVar = *i;
@@ -1708,7 +1721,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
if (i != args.end()) {
tls_verify = cmSystemTools::IsOn(*i);
} else {
this->SetError("TLS_VERIFY missing bool value.");
status.SetError("TLS_VERIFY missing bool value.");
return false;
}
} else if (*i == "TLS_CAINFO") {
@@ -1716,7 +1729,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
if (i != args.end()) {
cainfo = i->c_str();
} else {
this->SetError("TLS_CAFILE missing file value.");
status.SetError("TLS_CAFILE missing file value.");
return false;
}
} else if (*i == "NETRC_FILE") {
@@ -1724,7 +1737,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
if (i != args.end()) {
netrc_file = *i;
} else {
this->SetError("DOWNLOAD missing file value for NETRC_FILE.");
status.SetError("DOWNLOAD missing file value for NETRC_FILE.");
return false;
}
} else if (*i == "NETRC") {
@@ -1732,13 +1745,13 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
if (i != args.end()) {
netrc_level = *i;
} else {
this->SetError("DOWNLOAD missing level value for NETRC.");
status.SetError("DOWNLOAD missing level value for NETRC.");
return false;
}
} else if (*i == "EXPECTED_MD5") {
++i;
if (i == args.end()) {
this->SetError("DOWNLOAD missing sum value for EXPECTED_MD5.");
status.SetError("DOWNLOAD missing sum value for EXPECTED_MD5.");
return false;
}
hash = cm::make_unique<cmCryptoHash>(cmCryptoHash::AlgoMD5);
@@ -1749,7 +1762,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
} else if (*i == "EXPECTED_HASH") {
++i;
if (i == args.end()) {
this->SetError("DOWNLOAD missing ALGO=value for EXPECTED_HASH.");
status.SetError("DOWNLOAD missing ALGO=value for EXPECTED_HASH.");
return false;
}
std::string::size_type pos = i->find("=");
@@ -1757,7 +1770,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
std::string err =
"DOWNLOAD EXPECTED_HASH expects ALGO=value but got: ";
err += *i;
this->SetError(err);
status.SetError(err);
return false;
}
std::string algo = i->substr(0, pos);
@@ -1766,21 +1779,21 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
if (!hash) {
std::string err = "DOWNLOAD EXPECTED_HASH given unknown ALGO: ";
err += algo;
this->SetError(err);
status.SetError(err);
return false;
}
hashMatchMSG = algo + " hash";
} else if (*i == "USERPWD") {
++i;
if (i == args.end()) {
this->SetError("DOWNLOAD missing string for USERPWD.");
status.SetError("DOWNLOAD missing string for USERPWD.");
return false;
}
userpwd = *i;
} else if (*i == "HTTPHEADER") {
++i;
if (i == args.end()) {
this->SetError("DOWNLOAD missing string for HTTPHEADER.");
status.SetError("DOWNLOAD missing string for HTTPHEADER.");
return false;
}
curl_headers.push_back(*i);
@@ -1788,7 +1801,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
// Do not return error for compatibility reason.
std::string err = "Unexpected argument: ";
err += *i;
this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, err);
status.GetMakefile().IssueMessage(MessageType::AUTHOR_WARNING, err);
}
++i;
}
@@ -1806,7 +1819,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
if (!statusVar.empty()) {
std::ostringstream result;
result << 0 << ";\"" << msg;
this->Makefile->AddDefinition(statusVar, result.str());
status.GetMakefile().AddDefinition(statusVar, result.str());
}
return true;
}
@@ -1819,13 +1832,13 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
std::string errstring = "DOWNLOAD error: cannot create directory '" + dir +
"' - Specify file by full path name and verify that you "
"have directory creation and file write privileges.";
this->SetError(errstring);
status.SetError(errstring);
return false;
}
cmsys::ofstream fout(file.c_str(), std::ios::binary);
if (!fout) {
this->SetError("DOWNLOAD cannot open file for write.");
status.SetError("DOWNLOAD cannot open file for write.");
return false;
}
@@ -1837,7 +1850,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
::curl_global_init(CURL_GLOBAL_DEFAULT);
curl = ::curl_easy_init();
if (!curl) {
this->SetError("DOWNLOAD error initializing curl.");
status.SetError("DOWNLOAD error initializing curl.");
return false;
}
@@ -1871,7 +1884,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
// command arg comes first
std::string const& cainfo_err = cmCurlSetCAInfo(curl, cainfo);
if (!cainfo_err.empty()) {
this->SetError(cainfo_err);
status.SetError(cainfo_err);
return false;
}
@@ -1881,7 +1894,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
std::string const& netrc_option_err =
cmCurlSetNETRCOption(curl, netrc_level, netrc_file);
if (!netrc_option_err.empty()) {
this->SetError(netrc_option_err);
status.SetError(netrc_option_err);
return false;
}
@@ -1955,7 +1968,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
std::ostringstream result;
result << static_cast<int>(res) << ";\"" << ::curl_easy_strerror(res)
<< "\"";
this->Makefile->AddDefinition(statusVar, result.str());
status.GetMakefile().AddDefinition(statusVar, result.str());
}
::curl_global_cleanup();
@@ -1970,7 +1983,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
if (hash) {
std::string actualHash = hash->HashFile(file);
if (actualHash.empty()) {
this->SetError("DOWNLOAD cannot compute hash on downloaded file");
status.SetError("DOWNLOAD cannot compute hash on downloaded file");
return false;
}
@@ -1984,34 +1997,36 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
<< ::curl_easy_strerror(res) << "\"]" << std::endl;
if (!statusVar.empty() && res == 0) {
std::string status = "1;HASH mismatch: "
"expected: " +
expectedHash + " actual: " + actualHash;
this->Makefile->AddDefinition(statusVar, status);
status.GetMakefile().AddDefinition(statusVar,
"1;HASH mismatch: "
"expected: " +
expectedHash +
" actual: " + actualHash);
}
this->SetError(oss.str());
status.SetError(oss.str());
return false;
}
}
if (!logVar.empty()) {
chunkDebug.push_back(0);
this->Makefile->AddDefinition(logVar, chunkDebug.data());
status.GetMakefile().AddDefinition(logVar, chunkDebug.data());
}
return true;
#else
this->SetError("DOWNLOAD not supported by bootstrap cmake.");
status.SetError("DOWNLOAD not supported by bootstrap cmake.");
return false;
#endif
}
bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
#if defined(CMAKE_BUILD_WITH_CMAKE)
if (args.size() < 3) {
this->SetError("UPLOAD must be called with at least three arguments.");
status.SetError("UPLOAD must be called with at least three arguments.");
return false;
}
std::vector<std::string>::const_iterator i = args.begin();
@@ -2027,9 +2042,10 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
std::string statusVar;
bool showProgress = false;
std::string userpwd;
std::string netrc_level = this->Makefile->GetSafeDefinition("CMAKE_NETRC");
std::string netrc_level =
status.GetMakefile().GetSafeDefinition("CMAKE_NETRC");
std::string netrc_file =
this->Makefile->GetSafeDefinition("CMAKE_NETRC_FILE");
status.GetMakefile().GetSafeDefinition("CMAKE_NETRC_FILE");
std::vector<std::string> curl_headers;
@@ -2039,7 +2055,7 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
if (i != args.end()) {
timeout = atol(i->c_str());
} else {
this->SetError("UPLOAD missing time for TIMEOUT.");
status.SetError("UPLOAD missing time for TIMEOUT.");
return false;
}
} else if (*i == "INACTIVITY_TIMEOUT") {
@@ -2047,20 +2063,20 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
if (i != args.end()) {
inactivity_timeout = atol(i->c_str());
} else {
this->SetError("UPLOAD missing time for INACTIVITY_TIMEOUT.");
status.SetError("UPLOAD missing time for INACTIVITY_TIMEOUT.");
return false;
}
} else if (*i == "LOG") {
++i;
if (i == args.end()) {
this->SetError("UPLOAD missing VAR for LOG.");
status.SetError("UPLOAD missing VAR for LOG.");
return false;
}
logVar = *i;
} else if (*i == "STATUS") {
++i;
if (i == args.end()) {
this->SetError("UPLOAD missing VAR for STATUS.");
status.SetError("UPLOAD missing VAR for STATUS.");
return false;
}
statusVar = *i;
@@ -2071,7 +2087,7 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
if (i != args.end()) {
netrc_file = *i;
} else {
this->SetError("UPLOAD missing file value for NETRC_FILE.");
status.SetError("UPLOAD missing file value for NETRC_FILE.");
return false;
}
} else if (*i == "NETRC") {
@@ -2079,20 +2095,20 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
if (i != args.end()) {
netrc_level = *i;
} else {
this->SetError("UPLOAD missing level value for NETRC.");
status.SetError("UPLOAD missing level value for NETRC.");
return false;
}
} else if (*i == "USERPWD") {
++i;
if (i == args.end()) {
this->SetError("UPLOAD missing string for USERPWD.");
status.SetError("UPLOAD missing string for USERPWD.");
return false;
}
userpwd = *i;
} else if (*i == "HTTPHEADER") {
++i;
if (i == args.end()) {
this->SetError("UPLOAD missing string for HTTPHEADER.");
status.SetError("UPLOAD missing string for HTTPHEADER.");
return false;
}
curl_headers.push_back(*i);
@@ -2100,7 +2116,7 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
// Do not return error for compatibility reason.
std::string err = "Unexpected argument: ";
err += *i;
this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING, err);
status.GetMakefile().IssueMessage(MessageType::AUTHOR_WARNING, err);
}
++i;
@@ -2112,7 +2128,7 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
if (!fin) {
std::string errStr = "UPLOAD cannot open file '";
errStr += filename + "' for reading.";
this->SetError(errStr);
status.SetError(errStr);
return false;
}
@@ -2126,7 +2142,7 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
::curl_global_init(CURL_GLOBAL_DEFAULT);
curl = ::curl_easy_init();
if (!curl) {
this->SetError("UPLOAD error initializing curl.");
status.SetError("UPLOAD error initializing curl.");
fclose(fin);
return false;
}
@@ -2220,7 +2236,7 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
std::string const& netrc_option_err =
cmCurlSetNETRCOption(curl, netrc_level, netrc_file);
if (!netrc_option_err.empty()) {
this->SetError(netrc_option_err);
status.SetError(netrc_option_err);
return false;
}
@@ -2242,7 +2258,7 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
std::ostringstream result;
result << static_cast<int>(res) << ";\"" << ::curl_easy_strerror(res)
<< "\"";
this->Makefile->AddDefinition(statusVar, result.str());
status.GetMakefile().AddDefinition(statusVar, result.str());
}
::curl_global_cleanup();
@@ -2267,12 +2283,12 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
log += "\n";
}
this->Makefile->AddDefinition(logVar, log);
status.GetMakefile().AddDefinition(logVar, log);
}
return true;
#else
this->SetError("UPLOAD not supported by bootstrap cmake.");
status.SetError("UPLOAD not supported by bootstrap cmake.");
return false;
#endif
}
@@ -2280,9 +2296,10 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
void cmFileCommand::AddEvaluationFile(const std::string& inputName,
const std::string& outputExpr,
const std::string& condition,
bool inputIsContent)
bool inputIsContent,
cmExecutionStatus& status)
{
cmListFileBacktrace lfbt = this->Makefile->GetBacktrace();
cmListFileBacktrace lfbt = status.GetMakefile().GetBacktrace();
cmGeneratorExpression outputGe(lfbt);
std::unique_ptr<cmCompiledGeneratorExpression> outputCge =
@@ -2292,50 +2309,52 @@ void cmFileCommand::AddEvaluationFile(const std::string& inputName,
std::unique_ptr<cmCompiledGeneratorExpression> conditionCge =
conditionGe.Parse(condition);
this->Makefile->AddEvaluationFile(inputName, std::move(outputCge),
std::move(conditionCge), inputIsContent);
status.GetMakefile().AddEvaluationFile(
inputName, std::move(outputCge), std::move(conditionCge), inputIsContent);
}
bool cmFileCommand::HandleGenerateCommand(std::vector<std::string> const& args)
bool cmFileCommand::HandleGenerateCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() < 5) {
this->SetError("Incorrect arguments to GENERATE subcommand.");
status.SetError("Incorrect arguments to GENERATE subcommand.");
return false;
}
if (args[1] != "OUTPUT") {
this->SetError("Incorrect arguments to GENERATE subcommand.");
status.SetError("Incorrect arguments to GENERATE subcommand.");
return false;
}
std::string condition;
if (args.size() > 5) {
if (args[5] != "CONDITION") {
this->SetError("Incorrect arguments to GENERATE subcommand.");
status.SetError("Incorrect arguments to GENERATE subcommand.");
return false;
}
if (args.size() != 7) {
this->SetError("Incorrect arguments to GENERATE subcommand.");
status.SetError("Incorrect arguments to GENERATE subcommand.");
return false;
}
condition = args[6];
if (condition.empty()) {
this->SetError("CONDITION of sub-command GENERATE must not be empty if "
"specified.");
status.SetError("CONDITION of sub-command GENERATE must not be empty if "
"specified.");
return false;
}
}
std::string output = args[2];
const bool inputIsContent = args[3] != "INPUT";
if (inputIsContent && args[3] != "CONTENT") {
this->SetError("Incorrect arguments to GENERATE subcommand.");
status.SetError("Incorrect arguments to GENERATE subcommand.");
return false;
}
std::string input = args[4];
this->AddEvaluationFile(input, output, condition, inputIsContent);
this->AddEvaluationFile(input, output, condition, inputIsContent, status);
return true;
}
bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
#if defined(CMAKE_BUILD_WITH_CMAKE)
// Default values
@@ -2353,7 +2372,7 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
// Parse arguments
if (args.size() < 2) {
this->Makefile->IssueMessage(
status.GetMakefile().IssueMessage(
MessageType::FATAL_ERROR,
"sub-command LOCK requires at least two arguments.");
return false;
@@ -2369,7 +2388,7 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
++i;
const char* merr = "expected FUNCTION, FILE or PROCESS after GUARD";
if (i >= args.size()) {
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, merr);
status.GetMakefile().IssueMessage(MessageType::FATAL_ERROR, merr);
return false;
}
if (args[i] == "FUNCTION") {
@@ -2381,14 +2400,14 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
} else {
std::ostringstream e;
e << merr << ", but got:\n \"" << args[i] << "\".";
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
status.GetMakefile().IssueMessage(MessageType::FATAL_ERROR, e.str());
return false;
}
} else if (args[i] == "RESULT_VARIABLE") {
++i;
if (i >= args.size()) {
this->Makefile->IssueMessage(
status.GetMakefile().IssueMessage(
MessageType::FATAL_ERROR,
"expected variable name after RESULT_VARIABLE");
return false;
@@ -2397,8 +2416,8 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
} else if (args[i] == "TIMEOUT") {
++i;
if (i >= args.size()) {
this->Makefile->IssueMessage(MessageType::FATAL_ERROR,
"expected timeout value after TIMEOUT");
status.GetMakefile().IssueMessage(
MessageType::FATAL_ERROR, "expected timeout value after TIMEOUT");
return false;
}
long scanned;
@@ -2406,7 +2425,7 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
scanned < 0) {
std::ostringstream e;
e << "TIMEOUT value \"" << args[i] << "\" is not an unsigned integer.";
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
status.GetMakefile().IssueMessage(MessageType::FATAL_ERROR, e.str());
return false;
}
timeout = static_cast<unsigned long>(scanned);
@@ -2414,7 +2433,7 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
std::ostringstream e;
e << "expected DIRECTORY, RELEASE, GUARD, RESULT_VARIABLE or TIMEOUT\n";
e << "but got: \"" << args[i] << "\".";
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
status.GetMakefile().IssueMessage(MessageType::FATAL_ERROR, e.str());
return false;
}
}
@@ -2424,7 +2443,7 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
}
if (!cmsys::SystemTools::FileIsFullPath(path)) {
path = this->Makefile->GetCurrentSourceDirectory() + "/" + path;
path = status.GetMakefile().GetCurrentSourceDirectory() + "/" + path;
}
// Unify path (remove '//', '/../', ...)
@@ -2436,7 +2455,7 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
std::ostringstream e;
e << "directory\n \"" << parentDir << "\"\ncreation failed ";
e << "(check permissions).";
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
status.GetMakefile().IssueMessage(MessageType::FATAL_ERROR, e.str());
cmSystemTools::SetFatalErrorOccured();
return false;
}
@@ -2444,7 +2463,7 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
if (!file) {
std::ostringstream e;
e << "file\n \"" << path << "\"\ncreation failed (check permissions).";
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
status.GetMakefile().IssueMessage(MessageType::FATAL_ERROR, e.str());
cmSystemTools::SetFatalErrorOccured();
return false;
}
@@ -2452,7 +2471,7 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
// Actual lock/unlock
cmFileLockPool& lockPool =
this->Makefile->GetGlobalGenerator()->GetFileLockPool();
status.GetMakefile().GetGlobalGenerator()->GetFileLockPool();
cmFileLockResult fileLockResult(cmFileLockResult::MakeOk());
if (release) {
@@ -2479,32 +2498,32 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
if (resultVariable.empty() && !fileLockResult.IsOk()) {
std::ostringstream e;
e << "error locking file\n \"" << path << "\"\n" << result << ".";
this->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
status.GetMakefile().IssueMessage(MessageType::FATAL_ERROR, e.str());
cmSystemTools::SetFatalErrorOccured();
return false;
}
if (!resultVariable.empty()) {
this->Makefile->AddDefinition(resultVariable, result);
status.GetMakefile().AddDefinition(resultVariable, result);
}
return true;
#else
static_cast<void>(args);
this->SetError("sub-command LOCK not implemented in bootstrap cmake");
status.SetError("sub-command LOCK not implemented in bootstrap cmake");
return false;
#endif
}
bool cmFileCommand::HandleTimestampCommand(
std::vector<std::string> const& args)
std::vector<std::string> const& args, cmExecutionStatus& status)
{
if (args.size() < 3) {
this->SetError("sub-command TIMESTAMP requires at least two arguments.");
status.SetError("sub-command TIMESTAMP requires at least two arguments.");
return false;
}
if (args.size() > 5) {
this->SetError("sub-command TIMESTAMP takes at most four arguments.");
status.SetError("sub-command TIMESTAMP takes at most four arguments.");
return false;
}
@@ -2526,7 +2545,7 @@ bool cmFileCommand::HandleTimestampCommand(
} else {
std::string e = " TIMESTAMP sub-command does not recognize option " +
args[argsIndex] + ".";
this->SetError(e);
status.SetError(e);
return false;
}
}
@@ -2534,17 +2553,18 @@ bool cmFileCommand::HandleTimestampCommand(
cmTimestamp timestamp;
std::string result =
timestamp.FileModificationTime(filename.c_str(), formatString, utcFlag);
this->Makefile->AddDefinition(outputVariable, result);
status.GetMakefile().AddDefinition(outputVariable, result);
return true;
}
bool cmFileCommand::HandleSizeCommand(std::vector<std::string> const& args)
bool cmFileCommand::HandleSizeCommand(std::vector<std::string> const& args,
cmExecutionStatus& status)
{
if (args.size() != 3) {
std::ostringstream e;
e << args[0] << " requires a file name and output variable";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
@@ -2557,23 +2577,23 @@ bool cmFileCommand::HandleSizeCommand(std::vector<std::string> const& args)
if (!cmSystemTools::FileExists(filename, true)) {
std::ostringstream e;
e << "SIZE requested of path that is not readable:\n " << filename;
this->SetError(e.str());
status.SetError(e.str());
return false;
}
this->Makefile->AddDefinition(
status.GetMakefile().AddDefinition(
outputVariable, std::to_string(cmSystemTools::FileLength(filename)));
return true;
}
bool cmFileCommand::HandleReadSymlinkCommand(
std::vector<std::string> const& args)
std::vector<std::string> const& args, cmExecutionStatus& status)
{
if (args.size() != 3) {
std::ostringstream e;
e << args[0] << " requires a file name and output variable";
this->SetError(e.str());
status.SetError(e.str());
return false;
}
@@ -2585,21 +2605,21 @@ bool cmFileCommand::HandleReadSymlinkCommand(
std::ostringstream e;
e << "READ_SYMLINK requested of path that is not a symlink:\n "
<< filename;
this->SetError(e.str());
status.SetError(e.str());
return false;
}
this->Makefile->AddDefinition(outputVariable, result);
status.GetMakefile().AddDefinition(outputVariable, result);
return true;
}
bool cmFileCommand::HandleCreateLinkCommand(
std::vector<std::string> const& args)
std::vector<std::string> const& args, cmExecutionStatus& status)
{
if (args.size() < 3) {
this->SetError("CREATE_LINK must be called with at least two additional "
"arguments");
status.SetError("CREATE_LINK must be called with at least two additional "
"arguments");
return false;
}
@@ -2624,7 +2644,7 @@ bool cmFileCommand::HandleCreateLinkCommand(
parser.Parse(cmMakeRange(args).advance(3), &unconsumedArgs);
if (!unconsumedArgs.empty()) {
this->SetError("unknown argument: \"" + unconsumedArgs.front() + '\"');
status.SetError("unknown argument: \"" + unconsumedArgs.front() + '\"');
return false;
}
@@ -2635,10 +2655,10 @@ bool cmFileCommand::HandleCreateLinkCommand(
if (fileName == newFileName) {
result = "CREATE_LINK cannot use same file and newfile";
if (!arguments.Result.empty()) {
this->Makefile->AddDefinition(arguments.Result, result);
status.GetMakefile().AddDefinition(arguments.Result, result);
return true;
}
this->SetError(result);
status.SetError(result);
return false;
}
@@ -2646,10 +2666,10 @@ bool cmFileCommand::HandleCreateLinkCommand(
if (!arguments.Symbolic && !cmSystemTools::FileExists(fileName)) {
result = "Cannot hard link \'" + fileName + "\' as it does not exist.";
if (!arguments.Result.empty()) {
this->Makefile->AddDefinition(arguments.Result, result);
status.GetMakefile().AddDefinition(arguments.Result, result);
return true;
}
this->SetError(result);
status.SetError(result);
return false;
}
@@ -2663,10 +2683,10 @@ bool cmFileCommand::HandleCreateLinkCommand(
<< cmSystemTools::GetLastSystemError() << "\n";
if (!arguments.Result.empty()) {
this->Makefile->AddDefinition(arguments.Result, e.str());
status.GetMakefile().AddDefinition(arguments.Result, e.str());
return true;
}
this->SetError(e.str());
status.SetError(e.str());
return false;
}
@@ -2693,45 +2713,46 @@ bool cmFileCommand::HandleCreateLinkCommand(
result = "0";
} else if (arguments.Result.empty()) {
// The operation failed and the result is not reported in a variable.
this->SetError(result);
status.SetError(result);
return false;
}
if (!arguments.Result.empty()) {
this->Makefile->AddDefinition(arguments.Result, result);
status.GetMakefile().AddDefinition(arguments.Result, result);
}
return true;
}
bool cmFileCommand::HandleGetRuntimeDependenciesCommand(
std::vector<std::string> const& args)
std::vector<std::string> const& args, cmExecutionStatus& status)
{
static const std::set<std::string> supportedPlatforms = { "Windows", "Linux",
"Darwin" };
std::string platform =
this->Makefile->GetSafeDefinition("CMAKE_HOST_SYSTEM_NAME");
status.GetMakefile().GetSafeDefinition("CMAKE_HOST_SYSTEM_NAME");
if (!supportedPlatforms.count(platform)) {
std::ostringstream e;
e << "GET_RUNTIME_DEPENDENCIES is not supported on system \"" << platform
<< "\"";
this->SetError(e.str());
status.SetError(e.str());
cmSystemTools::SetFatalErrorOccured();
return false;
}
if (this->Makefile->GetState()->GetMode() == cmState::Project) {
this->Makefile->IssueMessage(MessageType::AUTHOR_WARNING,
"You have used file(GET_RUNTIME_DEPENDENCIES)"
" in project mode. This is probably not what "
"you intended to do. Instead, please consider"
" using it in an install(CODE) or "
"install(SCRIPT) command. For example:"
"\n install(CODE [["
"\n file(GET_RUNTIME_DEPENDENCIES"
"\n # ..."
"\n )"
"\n ]])");
if (status.GetMakefile().GetState()->GetMode() == cmState::Project) {
status.GetMakefile().IssueMessage(
MessageType::AUTHOR_WARNING,
"You have used file(GET_RUNTIME_DEPENDENCIES)"
" in project mode. This is probably not what "
"you intended to do. Instead, please consider"
" using it in an install(CODE) or "
"install(SCRIPT) command. For example:"
"\n install(CODE [["
"\n file(GET_RUNTIME_DEPENDENCIES"
"\n # ..."
"\n )"
"\n ]])");
}
struct Arguments
@@ -2776,7 +2797,7 @@ bool cmFileCommand::HandleGetRuntimeDependenciesCommand(
if (argIt != unrecognizedArguments.end()) {
std::ostringstream e;
e << "Unrecognized argument: \"" << *argIt << "\"";
this->SetError(e.str());
status.SetError(e.str());
cmSystemTools::SetFatalErrorOccured();
return false;
}
@@ -2784,7 +2805,7 @@ bool cmFileCommand::HandleGetRuntimeDependenciesCommand(
if (argIt != keywordsMissingValues.end()) {
std::ostringstream e;
e << "Keyword missing value: " << *argIt;
this->SetError(e.str());
status.SetError(e.str());
cmSystemTools::SetFatalErrorOccured();
return false;
}
@@ -2826,14 +2847,14 @@ bool cmFileCommand::HandleGetRuntimeDependenciesCommand(
std::string varName =
parsedArgs.ConflictingDependenciesPrefix + "_" + val.first;
std::string pathsStr = cmJoin(paths, ";");
this->Makefile->AddDefinition(varName, pathsStr);
status.GetMakefile().AddDefinition(varName, pathsStr);
} else {
std::ostringstream e;
e << "Multiple conflicting paths found for " << val.first << ":";
for (auto const& path : val.second) {
e << "\n " << path;
}
this->SetError(e.str());
status.SetError(e.str());
cmSystemTools::SetFatalErrorOccured();
return false;
}
@@ -2848,7 +2869,7 @@ bool cmFileCommand::HandleGetRuntimeDependenciesCommand(
assert(it != archive.GetUnresolvedPaths().end());
std::ostringstream e;
e << "Could not resolve file " << *it;
this->SetError(e.str());
status.SetError(e.str());
cmSystemTools::SetFatalErrorOccured();
return false;
}
@@ -2856,15 +2877,17 @@ bool cmFileCommand::HandleGetRuntimeDependenciesCommand(
if (!parsedArgs.ResolvedDependenciesVar.empty()) {
std::string val = cmJoin(deps, ";");
this->Makefile->AddDefinition(parsedArgs.ResolvedDependenciesVar, val);
status.GetMakefile().AddDefinition(parsedArgs.ResolvedDependenciesVar,
val);
}
if (!parsedArgs.UnresolvedDependenciesVar.empty()) {
std::string val = cmJoin(unresolvedDeps, ";");
this->Makefile->AddDefinition(parsedArgs.UnresolvedDependenciesVar, val);
status.GetMakefile().AddDefinition(parsedArgs.UnresolvedDependenciesVar,
val);
}
if (!parsedArgs.ConflictingDependenciesPrefix.empty()) {
std::string val = cmJoin(conflictingDeps, ";");
this->Makefile->AddDefinition(
status.GetMakefile().AddDefinition(
parsedArgs.ConflictingDependenciesPrefix + "_FILENAMES", val);
}
return true;
Source/cmFileCommand.h
+54 -28
View File
@@ -37,43 +37,69 @@ public:
cmExecutionStatus& status) override;
protected:
bool HandleRename(std::vector<std::string> const& args);
bool HandleRemove(std::vector<std::string> const& args, bool recurse);
bool HandleWriteCommand(std::vector<std::string> const& args, bool append);
bool HandleReadCommand(std::vector<std::string> const& args);
bool HandleHashCommand(std::vector<std::string> const& args);
bool HandleStringsCommand(std::vector<std::string> const& args);
bool HandleGlobCommand(std::vector<std::string> const& args, bool recurse);
bool HandleTouchCommand(std::vector<std::string> const& args, bool create);
bool HandleMakeDirectoryCommand(std::vector<std::string> const& args);
bool HandleRename(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleRemove(std::vector<std::string> const& args, bool recurse,
cmExecutionStatus& status);
bool HandleWriteCommand(std::vector<std::string> const& args, bool append,
cmExecutionStatus& status);
bool HandleReadCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleHashCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleStringsCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleGlobCommand(std::vector<std::string> const& args, bool recurse,
cmExecutionStatus& status);
bool HandleTouchCommand(std::vector<std::string> const& args, bool create,
cmExecutionStatus& status);
bool HandleMakeDirectoryCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleRelativePathCommand(std::vector<std::string> const& args);
bool HandleRelativePathCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleCMakePathCommand(std::vector<std::string> const& args,
bool nativePath);
bool HandleReadElfCommand(std::vector<std::string> const& args);
bool HandleRPathChangeCommand(std::vector<std::string> const& args);
bool HandleRPathCheckCommand(std::vector<std::string> const& args);
bool HandleRPathRemoveCommand(std::vector<std::string> const& args);
bool HandleDifferentCommand(std::vector<std::string> const& args);
bool nativePath, cmExecutionStatus& status);
bool HandleReadElfCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleRPathChangeCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleRPathCheckCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleRPathRemoveCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleDifferentCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleCopyCommand(std::vector<std::string> const& args);
bool HandleInstallCommand(std::vector<std::string> const& args);
bool HandleDownloadCommand(std::vector<std::string> const& args);
bool HandleUploadCommand(std::vector<std::string> const& args);
bool HandleCopyCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleInstallCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleDownloadCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleUploadCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleTimestampCommand(std::vector<std::string> const& args);
bool HandleGenerateCommand(std::vector<std::string> const& args);
bool HandleLockCommand(std::vector<std::string> const& args);
bool HandleSizeCommand(std::vector<std::string> const& args);
bool HandleReadSymlinkCommand(std::vector<std::string> const& args);
bool HandleCreateLinkCommand(std::vector<std::string> const& args);
bool HandleTimestampCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleGenerateCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleLockCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleSizeCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleReadSymlinkCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleCreateLinkCommand(std::vector<std::string> const& args,
cmExecutionStatus& status);
bool HandleGetRuntimeDependenciesCommand(
std::vector<std::string> const& args);
std::vector<std::string> const& args, cmExecutionStatus& status);
private:
void AddEvaluationFile(const std::string& inputName,
const std::string& outputExpr,
const std::string& condition, bool inputIsContent);
const std::string& condition, bool inputIsContent,
cmExecutionStatus& status);
};
#endif
Source/cmFileCopier.cxx
+23 -23
View File
@@ -3,8 +3,8 @@
#include "cmFileCopier.h"
#include "cmExecutionStatus.h"
#include "cmFSPermissions.h"
#include "cmFileCommand.h"
#include "cmFileTimes.h"
#include "cmMakefile.h"
#include "cmSystemTools.h"
@@ -20,9 +20,9 @@
using namespace cmFSPermissions;
cmFileCopier::cmFileCopier(cmFileCommand* command, const char* name)
: FileCommand(command)
, Makefile(command->GetMakefile())
cmFileCopier::cmFileCopier(cmExecutionStatus& status, const char* name)
: Status(status)
, Makefile(&status.GetMakefile())
, Name(name)
, Always(false)
, MatchlessFiles(true)
@@ -91,7 +91,7 @@ bool cmFileCopier::SetPermissions(const std::string& toFile,
if (!cmSystemTools::SetPermissions(toFile, permissions)) {
std::ostringstream e;
e << this->Name << " cannot set permissions on \"" << toFile << "\"";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
}
@@ -105,7 +105,7 @@ bool cmFileCopier::CheckPermissions(std::string const& arg,
if (!cmFSPermissions::stringToModeT(arg, permissions)) {
std::ostringstream e;
e << this->Name << " given invalid permission \"" << arg << "\".";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
return true;
@@ -121,7 +121,7 @@ bool cmFileCopier::ReportMissing(const std::string& fromFile)
// The input file does not exist and installation is not optional.
std::ostringstream e;
e << this->Name << " cannot find \"" << fromFile << "\".";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
@@ -129,7 +129,7 @@ void cmFileCopier::NotBeforeMatch(std::string const& arg)
{
std::ostringstream e;
e << "option " << arg << " may not appear before PATTERN or REGEX.";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
this->Doing = DoingError;
}
@@ -137,7 +137,7 @@ void cmFileCopier::NotAfterMatch(std::string const& arg)
{
std::ostringstream e;
e << "option " << arg << " may not appear after PATTERN or REGEX.";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
this->Doing = DoingError;
}
@@ -174,7 +174,7 @@ bool cmFileCopier::GetDefaultDirectoryPermissions(mode_t** mode)
cmSystemTools::ExpandListArgument(default_dir_install_permissions, items);
for (const auto& arg : items) {
if (!this->CheckPermissions(arg, **mode)) {
this->FileCommand->SetError(
this->Status.SetError(
" Set with CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS variable.");
return false;
}
@@ -194,7 +194,7 @@ bool cmFileCopier::Parse(std::vector<std::string> const& args)
if (!this->CheckKeyword(args[i]) && !this->CheckValue(args[i])) {
std::ostringstream e;
e << "called with unknown argument \"" << args[i] << "\".";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
@@ -208,7 +208,7 @@ bool cmFileCopier::Parse(std::vector<std::string> const& args)
if (this->Destination.empty()) {
std::ostringstream e;
e << this->Name << " given no DESTINATION";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
@@ -341,7 +341,7 @@ bool cmFileCopier::CheckValue(std::string const& arg)
} else {
std::ostringstream e;
e << "could not compile PATTERN \"" << arg << "\".";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
this->Doing = DoingError;
}
} break;
@@ -353,7 +353,7 @@ bool cmFileCopier::CheckValue(std::string const& arg)
} else {
std::ostringstream e;
e << "could not compile REGEX \"" << arg << "\".";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
this->Doing = DoingError;
}
break;
@@ -396,8 +396,8 @@ bool cmFileCopier::Run(std::vector<std::string> const& args)
file += "/";
file += f;
} else if (!this->FilesFromDir.empty()) {
this->FileCommand->SetError("option FILES_FROM_DIR requires all files "
"to be specified as relative paths.");
this->Status.SetError("option FILES_FROM_DIR requires all files "
"to be specified as relative paths.");
return false;
} else {
file = f;
@@ -446,7 +446,7 @@ bool cmFileCopier::Install(const std::string& fromFile,
if (fromFile.empty()) {
std::ostringstream e;
e << "INSTALL encountered an empty string input file name.";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
@@ -514,7 +514,7 @@ bool cmFileCopier::InstallSymlinkChain(std::string& fromFile,
if (!cmSystemTools::CreateSymlink(symlinkTarget, toFile)) {
std::ostringstream e;
e << this->Name << " cannot create symlink \"" << toFile << "\".";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
}
@@ -535,7 +535,7 @@ bool cmFileCopier::InstallSymlink(const std::string& fromFile,
std::ostringstream e;
e << this->Name << " cannot read symlink \"" << fromFile
<< "\" to duplicate at \"" << toFile << "\".";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
@@ -566,7 +566,7 @@ bool cmFileCopier::InstallSymlink(const std::string& fromFile,
std::ostringstream e;
e << this->Name << " cannot duplicate symlink \"" << fromFile
<< "\" at \"" << toFile << "\".";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
}
@@ -595,7 +595,7 @@ bool cmFileCopier::InstallFile(const std::string& fromFile,
std::ostringstream e;
e << this->Name << " cannot copy file \"" << fromFile << "\" to \""
<< toFile << "\".";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
@@ -611,7 +611,7 @@ bool cmFileCopier::InstallFile(const std::string& fromFile,
std::ostringstream e;
e << this->Name << " cannot set modification time on \"" << toFile
<< "\"";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
}
@@ -648,7 +648,7 @@ bool cmFileCopier::InstallDirectory(const std::string& source,
std::ostringstream e;
e << this->Name << " cannot make directory \"" << destination
<< "\": " << cmSystemTools::GetLastSystemError();
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
Source/cmFileCopier.h
+3 -3
View File
@@ -12,19 +12,19 @@
#include <string>
#include <vector>
class cmFileCommand;
class cmExecutionStatus;
class cmMakefile;
// File installation helper class.
struct cmFileCopier
{
cmFileCopier(cmFileCommand* command, const char* name = "COPY");
cmFileCopier(cmExecutionStatus& status, const char* name = "COPY");
virtual ~cmFileCopier();
bool Run(std::vector<std::string> const& args);
protected:
cmFileCommand* FileCommand;
cmExecutionStatus& Status;
cmMakefile* Makefile;
const char* Name;
bool Always;
Source/cmFileInstaller.cxx
+20 -20
View File
@@ -3,8 +3,8 @@
#include "cmFileInstaller.h"
#include "cmExecutionStatus.h"
#include "cmFSPermissions.h"
#include "cmFileCommand.h"
#include "cmMakefile.h"
#include "cmSystemTools.h"
@@ -14,8 +14,8 @@
using namespace cmFSPermissions;
cmFileInstaller::cmFileInstaller(cmFileCommand* command)
: cmFileCopier(command, "INSTALL")
cmFileInstaller::cmFileInstaller(cmExecutionStatus& status)
: cmFileCopier(status, "INSTALL")
, InstallType(cmInstallType_FILES)
, Optional(false)
, MessageAlways(false)
@@ -111,19 +111,19 @@ bool cmFileInstaller::Parse(std::vector<std::string> const& args)
if (!this->Rename.empty()) {
if (!this->FilesFromDir.empty()) {
this->FileCommand->SetError("INSTALL option RENAME may not be "
"combined with FILES_FROM_DIR.");
this->Status.SetError("INSTALL option RENAME may not be "
"combined with FILES_FROM_DIR.");
return false;
}
if (this->InstallType != cmInstallType_FILES &&
this->InstallType != cmInstallType_PROGRAMS) {
this->FileCommand->SetError("INSTALL option RENAME may be used "
"only with FILES or PROGRAMS.");
this->Status.SetError("INSTALL option RENAME may be used "
"only with FILES or PROGRAMS.");
return false;
}
if (this->Files.size() > 1) {
this->FileCommand->SetError("INSTALL option RENAME may be used "
"only with one file.");
this->Status.SetError("INSTALL option RENAME may be used "
"only with one file.");
return false;
}
}
@@ -134,9 +134,9 @@ bool cmFileInstaller::Parse(std::vector<std::string> const& args)
if (((this->MessageAlways ? 1 : 0) + (this->MessageLazy ? 1 : 0) +
(this->MessageNever ? 1 : 0)) > 1) {
this->FileCommand->SetError("INSTALL options MESSAGE_ALWAYS, "
"MESSAGE_LAZY, and MESSAGE_NEVER "
"are mutually exclusive.");
this->Status.SetError("INSTALL options MESSAGE_ALWAYS, "
"MESSAGE_LAZY, and MESSAGE_NEVER "
"are mutually exclusive.");
return false;
}
@@ -213,7 +213,7 @@ bool cmFileInstaller::CheckKeyword(std::string const& arg)
e << "INSTALL called with old-style " << arg << " argument. "
<< "This script was generated with an older version of CMake. "
<< "Re-run this cmake version on your build tree.";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
this->Doing = DoingError;
} else {
return this->cmFileCopier::CheckKeyword(arg);
@@ -257,7 +257,7 @@ bool cmFileInstaller::GetTargetTypeFromString(const std::string& stype)
} else {
std::ostringstream e;
e << "Option TYPE given unknown value \"" << stype << "\".";
this->FileCommand->SetError(e.str());
this->Status.SetError(e.str());
return false;
}
return true;
@@ -269,8 +269,8 @@ bool cmFileInstaller::HandleInstallDestination()
// allow for / to be a valid destination
if (destination.size() < 2 && destination != "/") {
this->FileCommand->SetError("called with inappropriate arguments. "
"No DESTINATION provided or .");
this->Status.SetError("called with inappropriate arguments. "
"No DESTINATION provided or .");
return false;
}
@@ -300,7 +300,7 @@ bool cmFileInstaller::HandleInstallDestination()
if (relative) {
// This is relative path on unix or windows. Since we are doing
// destdir, this case does not make sense.
this->FileCommand->SetError(
this->Status.SetError(
"called with relative DESTINATION. This "
"does not make sense when using DESTDIR. Specify "
"absolute path or remove DESTDIR environment variable.");
@@ -315,7 +315,7 @@ bool cmFileInstaller::HandleInstallDestination()
"absolute path or remove DESTDIR environment variable."
"\nDESTINATION=\n";
message += destination;
this->FileCommand->SetError(message);
this->Status.SetError(message);
return false;
}
}
@@ -335,14 +335,14 @@ bool cmFileInstaller::HandleInstallDestination()
if (!cmSystemTools::MakeDirectory(destination, default_dir_mode)) {
std::string errstring = "cannot create directory: " + destination +
". Maybe need administrative privileges.";
this->FileCommand->SetError(errstring);
this->Status.SetError(errstring);
return false;
}
}
if (!cmSystemTools::FileIsDirectory(destination)) {
std::string errstring =
"INSTALL destination: " + destination + " is not a directory.";
this->FileCommand->SetError(errstring);
this->Status.SetError(errstring);
return false;
}
}
Source/cmFileInstaller.h
+2 -2
View File
@@ -12,11 +12,11 @@
#include <string>
#include <vector>
class cmFileCommand;
class cmExecutionStatus;
struct cmFileInstaller : public cmFileCopier
{
cmFileInstaller(cmFileCommand* command);
cmFileInstaller(cmExecutionStatus& status);
~cmFileInstaller() override;
protected: