You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
496 lines
18 KiB
496 lines
18 KiB
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
#include "cmTryRunCommand.h"
|
|
|
|
#include <cstdio>
|
|
|
|
#include <cm/optional>
|
|
|
|
#include "cmsys/FStream.hxx"
|
|
|
|
#include "cmArgumentParserTypes.h"
|
|
#include "cmCoreTryCompile.h"
|
|
#include "cmDuration.h"
|
|
#include "cmExecutionStatus.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmMessageType.h"
|
|
#include "cmRange.h"
|
|
#include "cmState.h"
|
|
#include "cmStateTypes.h"
|
|
#include "cmStringAlgorithms.h"
|
|
#include "cmSystemTools.h"
|
|
#include "cmValue.h"
|
|
#include "cmake.h"
|
|
|
|
namespace {
|
|
|
|
class TryRunCommandImpl : public cmCoreTryCompile
|
|
{
|
|
public:
|
|
TryRunCommandImpl(cmMakefile* mf)
|
|
: cmCoreTryCompile(mf)
|
|
{
|
|
}
|
|
|
|
bool TryRunCode(std::vector<std::string> const& args);
|
|
|
|
void RunExecutable(const std::string& runArgs,
|
|
cm::optional<std::string> const& workDir,
|
|
std::string* runOutputContents,
|
|
std::string* runOutputStdOutContents,
|
|
std::string* runOutputStdErrContents);
|
|
void DoNotRunExecutable(const std::string& runArgs,
|
|
const std::string& srcFile,
|
|
std::string const& compileResultVariable,
|
|
std::string* runOutputContents,
|
|
std::string* runOutputStdOutContents,
|
|
std::string* runOutputStdErrContents);
|
|
|
|
bool NoCache;
|
|
std::string RunResultVariable;
|
|
};
|
|
|
|
bool TryRunCommandImpl::TryRunCode(std::vector<std::string> const& argv)
|
|
{
|
|
this->RunResultVariable = argv[0];
|
|
cmCoreTryCompile::Arguments arguments =
|
|
this->ParseArgs(cmMakeRange(argv).advance(1), true);
|
|
if (!arguments) {
|
|
return true;
|
|
}
|
|
this->NoCache = arguments.NoCache;
|
|
|
|
// although they could be used together, don't allow it, because
|
|
// using OUTPUT_VARIABLE makes crosscompiling harder
|
|
if (arguments.OutputVariable &&
|
|
(arguments.CompileOutputVariable || arguments.RunOutputVariable ||
|
|
arguments.RunOutputStdOutVariable ||
|
|
arguments.RunOutputStdErrVariable)) {
|
|
cmSystemTools::Error(
|
|
"You cannot use OUTPUT_VARIABLE together with COMPILE_OUTPUT_VARIABLE "
|
|
", RUN_OUTPUT_VARIABLE, RUN_OUTPUT_STDOUT_VARIABLE or "
|
|
"RUN_OUTPUT_STDERR_VARIABLE. "
|
|
"Please use only COMPILE_OUTPUT_VARIABLE, RUN_OUTPUT_VARIABLE, "
|
|
"RUN_OUTPUT_STDOUT_VARIABLE "
|
|
"and/or RUN_OUTPUT_STDERR_VARIABLE.");
|
|
return false;
|
|
}
|
|
|
|
if ((arguments.RunOutputStdOutVariable ||
|
|
arguments.RunOutputStdErrVariable) &&
|
|
arguments.RunOutputVariable) {
|
|
cmSystemTools::Error(
|
|
"You cannot use RUN_OUTPUT_STDOUT_VARIABLE or "
|
|
"RUN_OUTPUT_STDERR_VARIABLE together "
|
|
"with RUN_OUTPUT_VARIABLE. Please use only COMPILE_OUTPUT_VARIABLE or "
|
|
"RUN_OUTPUT_STDOUT_VARIABLE and/or RUN_OUTPUT_STDERR_VARIABLE.");
|
|
return false;
|
|
}
|
|
|
|
if (arguments.RunWorkingDirectory) {
|
|
if (!cmSystemTools::MakeDirectory(*arguments.RunWorkingDirectory)) {
|
|
cmSystemTools::Error(cmStrCat("Error creating working directory \"",
|
|
*arguments.RunWorkingDirectory, "\"."));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool captureRunOutput = false;
|
|
bool captureRunOutputStdOutErr = false;
|
|
if (arguments.OutputVariable) {
|
|
captureRunOutput = true;
|
|
} else if (arguments.CompileOutputVariable) {
|
|
arguments.OutputVariable = arguments.CompileOutputVariable;
|
|
}
|
|
if (arguments.RunOutputStdOutVariable || arguments.RunOutputStdErrVariable) {
|
|
captureRunOutputStdOutErr = true;
|
|
} else if (arguments.RunOutputVariable) {
|
|
captureRunOutput = true;
|
|
}
|
|
|
|
// do the try compile
|
|
bool compiled = this->TryCompileCode(arguments, cmStateEnums::EXECUTABLE);
|
|
|
|
// now try running the command if it compiled
|
|
if (compiled) {
|
|
if (this->OutputFile.empty()) {
|
|
cmSystemTools::Error(this->FindErrorMessage);
|
|
} else {
|
|
std::string runArgs;
|
|
if (arguments.RunArgs) {
|
|
runArgs = cmStrCat(" ", cmJoin(*arguments.RunArgs, " "));
|
|
}
|
|
|
|
// "run" it and capture the output
|
|
std::string runOutputContents;
|
|
std::string runOutputStdOutContents;
|
|
std::string runOutputStdErrContents;
|
|
if (this->Makefile->IsOn("CMAKE_CROSSCOMPILING") &&
|
|
!this->Makefile->IsDefinitionSet("CMAKE_CROSSCOMPILING_EMULATOR")) {
|
|
this->DoNotRunExecutable(
|
|
runArgs, *arguments.SourceDirectoryOrFile,
|
|
*arguments.CompileResultVariable,
|
|
captureRunOutput ? &runOutputContents : nullptr,
|
|
captureRunOutputStdOutErr && arguments.RunOutputStdOutVariable
|
|
? &runOutputStdOutContents
|
|
: nullptr,
|
|
captureRunOutputStdOutErr && arguments.RunOutputStdErrVariable
|
|
? &runOutputStdErrContents
|
|
: nullptr);
|
|
} else {
|
|
this->RunExecutable(
|
|
runArgs, arguments.RunWorkingDirectory,
|
|
captureRunOutput ? &runOutputContents : nullptr,
|
|
captureRunOutputStdOutErr && arguments.RunOutputStdOutVariable
|
|
? &runOutputStdOutContents
|
|
: nullptr,
|
|
captureRunOutputStdOutErr && arguments.RunOutputStdErrVariable
|
|
? &runOutputStdErrContents
|
|
: nullptr);
|
|
}
|
|
|
|
// now put the output into the variables
|
|
if (arguments.RunOutputVariable) {
|
|
this->Makefile->AddDefinition(*arguments.RunOutputVariable,
|
|
runOutputContents);
|
|
}
|
|
if (arguments.RunOutputStdOutVariable) {
|
|
this->Makefile->AddDefinition(*arguments.RunOutputStdOutVariable,
|
|
runOutputStdOutContents);
|
|
}
|
|
if (arguments.RunOutputStdErrVariable) {
|
|
this->Makefile->AddDefinition(*arguments.RunOutputStdErrVariable,
|
|
runOutputStdErrContents);
|
|
}
|
|
|
|
if (arguments.OutputVariable && !arguments.CompileOutputVariable) {
|
|
// if the TryCompileCore saved output in this outputVariable then
|
|
// prepend that output to this output
|
|
cmValue compileOutput =
|
|
this->Makefile->GetDefinition(*arguments.OutputVariable);
|
|
if (compileOutput) {
|
|
runOutputContents = *compileOutput + runOutputContents;
|
|
}
|
|
this->Makefile->AddDefinition(*arguments.OutputVariable,
|
|
runOutputContents);
|
|
}
|
|
}
|
|
}
|
|
|
|
// if we created a directory etc, then cleanup after ourselves
|
|
if (!this->Makefile->GetCMakeInstance()->GetDebugTryCompile()) {
|
|
this->CleanupFiles(this->BinaryDirectory);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void TryRunCommandImpl::RunExecutable(const std::string& runArgs,
|
|
cm::optional<std::string> const& workDir,
|
|
std::string* out, std::string* stdOut,
|
|
std::string* stdErr)
|
|
{
|
|
int retVal = -1;
|
|
|
|
std::string finalCommand;
|
|
const std::string& emulator =
|
|
this->Makefile->GetSafeDefinition("CMAKE_CROSSCOMPILING_EMULATOR");
|
|
if (!emulator.empty()) {
|
|
std::vector<std::string> emulatorWithArgs = cmExpandedList(emulator);
|
|
finalCommand +=
|
|
cmSystemTools::ConvertToRunCommandPath(emulatorWithArgs[0]);
|
|
finalCommand += " ";
|
|
for (std::string const& arg : cmMakeRange(emulatorWithArgs).advance(1)) {
|
|
finalCommand += "\"";
|
|
finalCommand += arg;
|
|
finalCommand += "\"";
|
|
finalCommand += " ";
|
|
}
|
|
}
|
|
finalCommand += cmSystemTools::ConvertToRunCommandPath(this->OutputFile);
|
|
if (!runArgs.empty()) {
|
|
finalCommand += runArgs;
|
|
}
|
|
bool worked = cmSystemTools::RunSingleCommand(
|
|
finalCommand, stdOut || stdErr ? stdOut : out,
|
|
stdOut || stdErr ? stdErr : out, &retVal,
|
|
workDir ? workDir->c_str() : nullptr, cmSystemTools::OUTPUT_NONE,
|
|
cmDuration::zero());
|
|
// set the run var
|
|
char retChar[16];
|
|
const char* retStr;
|
|
if (worked) {
|
|
snprintf(retChar, sizeof(retChar), "%i", retVal);
|
|
retStr = retChar;
|
|
} else {
|
|
retStr = "FAILED_TO_RUN";
|
|
}
|
|
if (this->NoCache) {
|
|
this->Makefile->AddDefinition(this->RunResultVariable, retStr);
|
|
} else {
|
|
this->Makefile->AddCacheDefinition(this->RunResultVariable, retStr,
|
|
"Result of try_run()",
|
|
cmStateEnums::INTERNAL);
|
|
}
|
|
}
|
|
|
|
/* This is only used when cross compiling. Instead of running the
|
|
executable, two cache variables are created which will hold the results
|
|
the executable would have produced.
|
|
*/
|
|
void TryRunCommandImpl::DoNotRunExecutable(
|
|
const std::string& runArgs, const std::string& srcFile,
|
|
std::string const& compileResultVariable, std::string* out,
|
|
std::string* stdOut, std::string* stdErr)
|
|
{
|
|
// copy the executable out of the CMakeFiles/ directory, so it is not
|
|
// removed at the end of try_run() and the user can run it manually
|
|
// on the target platform.
|
|
std::string copyDest =
|
|
cmStrCat(this->Makefile->GetHomeOutputDirectory(), "/CMakeFiles/",
|
|
cmSystemTools::GetFilenameWithoutExtension(this->OutputFile), '-',
|
|
this->RunResultVariable,
|
|
cmSystemTools::GetFilenameExtension(this->OutputFile));
|
|
cmSystemTools::CopyFileAlways(this->OutputFile, copyDest);
|
|
|
|
std::string resultFileName =
|
|
cmStrCat(this->Makefile->GetHomeOutputDirectory(), "/TryRunResults.cmake");
|
|
|
|
std::string detailsString = cmStrCat("For details see ", resultFileName);
|
|
|
|
std::string internalRunOutputName =
|
|
this->RunResultVariable + "__TRYRUN_OUTPUT";
|
|
std::string internalRunOutputStdOutName =
|
|
this->RunResultVariable + "__TRYRUN_OUTPUT_STDOUT";
|
|
std::string internalRunOutputStdErrName =
|
|
this->RunResultVariable + "__TRYRUN_OUTPUT_STDERR";
|
|
bool error = false;
|
|
|
|
if (!this->Makefile->GetDefinition(this->RunResultVariable)) {
|
|
// if the variables doesn't exist, create it with a helpful error text
|
|
// and mark it as advanced
|
|
std::string comment =
|
|
cmStrCat("Run result of try_run(), indicates whether the executable "
|
|
"would have been able to run on its target platform.\n",
|
|
detailsString);
|
|
this->Makefile->AddCacheDefinition(this->RunResultVariable,
|
|
"PLEASE_FILL_OUT-FAILED_TO_RUN",
|
|
comment.c_str(), cmStateEnums::STRING);
|
|
|
|
cmState* state = this->Makefile->GetState();
|
|
cmValue existingValue = state->GetCacheEntryValue(this->RunResultVariable);
|
|
if (existingValue) {
|
|
state->SetCacheEntryProperty(this->RunResultVariable, "ADVANCED", "1");
|
|
}
|
|
|
|
error = true;
|
|
}
|
|
|
|
// is the output from the executable used ?
|
|
if (stdOut || stdErr) {
|
|
if (!this->Makefile->GetDefinition(internalRunOutputStdOutName)) {
|
|
// if the variables doesn't exist, create it with a helpful error text
|
|
// and mark it as advanced
|
|
std::string comment = cmStrCat(
|
|
"Output of try_run(), contains the text, which the executable "
|
|
"would have printed on stdout on its target platform.\n",
|
|
detailsString);
|
|
|
|
this->Makefile->AddCacheDefinition(
|
|
internalRunOutputStdOutName, "PLEASE_FILL_OUT-NOTFOUND",
|
|
comment.c_str(), cmStateEnums::STRING);
|
|
cmState* state = this->Makefile->GetState();
|
|
cmValue existing =
|
|
state->GetCacheEntryValue(internalRunOutputStdOutName);
|
|
if (existing) {
|
|
state->SetCacheEntryProperty(internalRunOutputStdOutName, "ADVANCED",
|
|
"1");
|
|
}
|
|
|
|
error = true;
|
|
}
|
|
|
|
if (!this->Makefile->GetDefinition(internalRunOutputStdErrName)) {
|
|
// if the variables doesn't exist, create it with a helpful error text
|
|
// and mark it as advanced
|
|
std::string comment = cmStrCat(
|
|
"Output of try_run(), contains the text, which the executable "
|
|
"would have printed on stderr on its target platform.\n",
|
|
detailsString);
|
|
|
|
this->Makefile->AddCacheDefinition(
|
|
internalRunOutputStdErrName, "PLEASE_FILL_OUT-NOTFOUND",
|
|
comment.c_str(), cmStateEnums::STRING);
|
|
cmState* state = this->Makefile->GetState();
|
|
cmValue existing =
|
|
state->GetCacheEntryValue(internalRunOutputStdErrName);
|
|
if (existing) {
|
|
state->SetCacheEntryProperty(internalRunOutputStdErrName, "ADVANCED",
|
|
"1");
|
|
}
|
|
|
|
error = true;
|
|
}
|
|
} else if (out) {
|
|
if (!this->Makefile->GetDefinition(internalRunOutputName)) {
|
|
// if the variables doesn't exist, create it with a helpful error text
|
|
// and mark it as advanced
|
|
std::string comment = cmStrCat(
|
|
"Output of try_run(), contains the text, which the executable "
|
|
"would have printed on stdout and stderr on its target platform.\n",
|
|
detailsString);
|
|
|
|
this->Makefile->AddCacheDefinition(
|
|
internalRunOutputName, "PLEASE_FILL_OUT-NOTFOUND", comment.c_str(),
|
|
cmStateEnums::STRING);
|
|
cmState* state = this->Makefile->GetState();
|
|
cmValue existing = state->GetCacheEntryValue(internalRunOutputName);
|
|
if (existing) {
|
|
state->SetCacheEntryProperty(internalRunOutputName, "ADVANCED", "1");
|
|
}
|
|
|
|
error = true;
|
|
}
|
|
}
|
|
|
|
if (error) {
|
|
static bool firstTryRun = true;
|
|
cmsys::ofstream file(resultFileName.c_str(),
|
|
firstTryRun ? std::ios::out : std::ios::app);
|
|
if (file) {
|
|
if (firstTryRun) {
|
|
/* clang-format off */
|
|
file << "# This file was generated by CMake because it detected "
|
|
"try_run() commands\n"
|
|
"# in crosscompiling mode. It will be overwritten by the next "
|
|
"CMake run.\n"
|
|
"# Copy it to a safe location, set the variables to "
|
|
"appropriate values\n"
|
|
"# and use it then to preset the CMake cache (using -C).\n\n";
|
|
/* clang-format on */
|
|
}
|
|
|
|
std::string comment =
|
|
cmStrCat('\n', this->RunResultVariable,
|
|
"\n indicates whether the executable would have been able "
|
|
"to run on its\n"
|
|
" target platform. If so, set ",
|
|
this->RunResultVariable,
|
|
" to\n"
|
|
" the exit code (in many cases 0 for success), otherwise "
|
|
"enter \"FAILED_TO_RUN\".\n");
|
|
if (stdOut || stdErr) {
|
|
if (stdOut) {
|
|
comment += internalRunOutputStdOutName;
|
|
comment +=
|
|
"\n contains the text the executable "
|
|
"would have printed on stdout.\n"
|
|
" If the executable would not have been able to run, set ";
|
|
comment += internalRunOutputStdOutName;
|
|
comment += " empty.\n"
|
|
" Otherwise check if the output is evaluated by the "
|
|
"calling CMake code. If so,\n"
|
|
" check what the source file would have printed when "
|
|
"called with the given arguments.\n";
|
|
}
|
|
if (stdErr) {
|
|
comment += internalRunOutputStdErrName;
|
|
comment +=
|
|
"\n contains the text the executable "
|
|
"would have printed on stderr.\n"
|
|
" If the executable would not have been able to run, set ";
|
|
comment += internalRunOutputStdErrName;
|
|
comment += " empty.\n"
|
|
" Otherwise check if the output is evaluated by the "
|
|
"calling CMake code. If so,\n"
|
|
" check what the source file would have printed when "
|
|
"called with the given arguments.\n";
|
|
}
|
|
} else if (out) {
|
|
comment += internalRunOutputName;
|
|
comment +=
|
|
"\n contains the text the executable "
|
|
"would have printed on stdout and stderr.\n"
|
|
" If the executable would not have been able to run, set ";
|
|
comment += internalRunOutputName;
|
|
comment += " empty.\n"
|
|
" Otherwise check if the output is evaluated by the "
|
|
"calling CMake code. If so,\n"
|
|
" check what the source file would have printed when "
|
|
"called with the given arguments.\n";
|
|
}
|
|
|
|
comment += "The ";
|
|
comment += compileResultVariable;
|
|
comment += " variable holds the build result for this try_run().\n\n"
|
|
"Source file : ";
|
|
comment += srcFile + "\n";
|
|
comment += "Executable : ";
|
|
comment += copyDest + "\n";
|
|
comment += "Run arguments : ";
|
|
comment += runArgs;
|
|
comment += "\n";
|
|
comment += " Called from: " + this->Makefile->FormatListFileStack();
|
|
cmsys::SystemTools::ReplaceString(comment, "\n", "\n# ");
|
|
file << comment << "\n\n";
|
|
|
|
file << "set( " << this->RunResultVariable << " \n \""
|
|
<< this->Makefile->GetSafeDefinition(this->RunResultVariable)
|
|
<< "\"\n CACHE STRING \"Result from try_run\" FORCE)\n\n";
|
|
|
|
if (out) {
|
|
file << "set( " << internalRunOutputName << " \n \""
|
|
<< this->Makefile->GetSafeDefinition(internalRunOutputName)
|
|
<< "\"\n CACHE STRING \"Output from try_run\" FORCE)\n\n";
|
|
}
|
|
file.close();
|
|
}
|
|
firstTryRun = false;
|
|
|
|
std::string errorMessage =
|
|
cmStrCat("try_run() invoked in cross-compiling mode, "
|
|
"please set the following cache variables "
|
|
"appropriately:\n ",
|
|
this->RunResultVariable, " (advanced)\n");
|
|
if (out) {
|
|
errorMessage += " " + internalRunOutputName + " (advanced)\n";
|
|
}
|
|
errorMessage += detailsString;
|
|
cmSystemTools::Error(errorMessage);
|
|
return;
|
|
}
|
|
|
|
if (stdOut || stdErr) {
|
|
if (stdOut) {
|
|
(*stdOut) = *this->Makefile->GetDefinition(internalRunOutputStdOutName);
|
|
}
|
|
if (stdErr) {
|
|
(*stdErr) = *this->Makefile->GetDefinition(internalRunOutputStdErrName);
|
|
}
|
|
} else if (out) {
|
|
(*out) = *this->Makefile->GetDefinition(internalRunOutputName);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool cmTryRunCommand(std::vector<std::string> const& args,
|
|
cmExecutionStatus& status)
|
|
{
|
|
cmMakefile& mf = status.GetMakefile();
|
|
|
|
if (args.size() < 4) {
|
|
mf.IssueMessage(MessageType::FATAL_ERROR,
|
|
"The try_run() command requires at least 4 arguments.");
|
|
return false;
|
|
}
|
|
|
|
if (mf.GetCMakeInstance()->GetWorkingMode() == cmake::FIND_PACKAGE_MODE) {
|
|
mf.IssueMessage(
|
|
MessageType::FATAL_ERROR,
|
|
"The try_run() command is not supported in --find-package mode.");
|
|
return false;
|
|
}
|
|
|
|
TryRunCommandImpl tr(&mf);
|
|
return tr.TryRunCode(args);
|
|
}
|