414 lines
14 KiB
C++
414 lines
14 KiB
C++
/*============================================================================
|
|
CMake - Cross Platform Makefile Generator
|
|
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
|
|
|
|
Distributed under the OSI-approved BSD License (the "License");
|
|
see accompanying file Copyright.txt for details.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even the
|
|
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
See the License for more information.
|
|
============================================================================*/
|
|
#include "cmTryRunCommand.h"
|
|
#include "cmTryCompileCommand.h"
|
|
#include <cmsys/FStream.hxx>
|
|
|
|
// cmTryRunCommand
|
|
bool cmTryRunCommand
|
|
::InitialPass(std::vector<std::string> const& argv, cmExecutionStatus &)
|
|
{
|
|
if(argv.size() < 4)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(this->Makefile->GetCMakeInstance()->GetWorkingMode() ==
|
|
cmake::FIND_PACKAGE_MODE)
|
|
{
|
|
this->Makefile->IssueMessage(cmake::FATAL_ERROR,
|
|
"The TRY_RUN() command is not supported in --find-package mode.");
|
|
return false;
|
|
}
|
|
|
|
// build an arg list for TryCompile and extract the runArgs,
|
|
std::vector<std::string> tryCompile;
|
|
|
|
this->CompileResultVariable = "";
|
|
this->RunResultVariable = "";
|
|
this->OutputVariable = "";
|
|
this->RunOutputVariable = "";
|
|
this->CompileOutputVariable = "";
|
|
|
|
std::string runArgs;
|
|
unsigned int i;
|
|
for (i = 1; i < argv.size(); ++i)
|
|
{
|
|
if (argv[i] == "ARGS")
|
|
{
|
|
++i;
|
|
while (i < argv.size() && argv[i] != "COMPILE_DEFINITIONS" &&
|
|
argv[i] != "CMAKE_FLAGS" &&
|
|
argv[i] != "LINK_LIBRARIES")
|
|
{
|
|
runArgs += " ";
|
|
runArgs += argv[i];
|
|
++i;
|
|
}
|
|
if (i < argv.size())
|
|
{
|
|
tryCompile.push_back(argv[i]);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (argv[i] == "OUTPUT_VARIABLE")
|
|
{
|
|
if ( argv.size() <= (i+1) )
|
|
{
|
|
cmSystemTools::Error(
|
|
"OUTPUT_VARIABLE specified but there is no variable");
|
|
return false;
|
|
}
|
|
i++;
|
|
this->OutputVariable = argv[i];
|
|
}
|
|
else if (argv[i] == "RUN_OUTPUT_VARIABLE")
|
|
{
|
|
if (argv.size() <= (i + 1))
|
|
{
|
|
cmSystemTools::Error(
|
|
"RUN_OUTPUT_VARIABLE specified but there is no variable");
|
|
return false;
|
|
}
|
|
i++;
|
|
this->RunOutputVariable = argv[i];
|
|
}
|
|
else if (argv[i] == "COMPILE_OUTPUT_VARIABLE")
|
|
{
|
|
if (argv.size() <= (i + 1))
|
|
{
|
|
cmSystemTools::Error(
|
|
"COMPILE_OUTPUT_VARIABLE specified but there is no variable");
|
|
return false;
|
|
}
|
|
i++;
|
|
this->CompileOutputVariable = argv[i];
|
|
}
|
|
else
|
|
{
|
|
tryCompile.push_back(argv[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// although they could be used together, don't allow it, because
|
|
// using OUTPUT_VARIABLE makes crosscompiling harder
|
|
if (this->OutputVariable.size()
|
|
&& (!this->RunOutputVariable.empty()
|
|
|| !this->CompileOutputVariable.empty()))
|
|
{
|
|
cmSystemTools::Error(
|
|
"You cannot use OUTPUT_VARIABLE together with COMPILE_OUTPUT_VARIABLE "
|
|
"or RUN_OUTPUT_VARIABLE. Please use only COMPILE_OUTPUT_VARIABLE and/or "
|
|
"RUN_OUTPUT_VARIABLE.");
|
|
return false;
|
|
}
|
|
|
|
bool captureRunOutput = false;
|
|
if (!this->OutputVariable.empty())
|
|
{
|
|
captureRunOutput = true;
|
|
tryCompile.push_back("OUTPUT_VARIABLE");
|
|
tryCompile.push_back(this->OutputVariable);
|
|
}
|
|
if (!this->CompileOutputVariable.empty())
|
|
{
|
|
tryCompile.push_back("OUTPUT_VARIABLE");
|
|
tryCompile.push_back(this->CompileOutputVariable);
|
|
}
|
|
if (!this->RunOutputVariable.empty())
|
|
{
|
|
captureRunOutput = true;
|
|
}
|
|
|
|
this->RunResultVariable = argv[0];
|
|
this->CompileResultVariable = argv[1];
|
|
|
|
// do the try compile
|
|
int res = this->TryCompileCode(tryCompile);
|
|
|
|
// now try running the command if it compiled
|
|
if (!res)
|
|
{
|
|
if (this->OutputFile.empty())
|
|
{
|
|
cmSystemTools::Error(this->FindErrorMessage.c_str());
|
|
}
|
|
else
|
|
{
|
|
// "run" it and capture the output
|
|
std::string runOutputContents;
|
|
if (this->Makefile->IsOn("CMAKE_CROSSCOMPILING") &&
|
|
!this->Makefile->IsDefinitionSet("CMAKE_CROSSCOMPILING_EMULATOR"))
|
|
{
|
|
this->DoNotRunExecutable(runArgs,
|
|
argv[3],
|
|
captureRunOutput ? &runOutputContents : 0);
|
|
}
|
|
else
|
|
{
|
|
this->RunExecutable(runArgs, &runOutputContents);
|
|
}
|
|
|
|
// now put the output into the variables
|
|
if(!this->RunOutputVariable.empty())
|
|
{
|
|
this->Makefile->AddDefinition(this->RunOutputVariable,
|
|
runOutputContents.c_str());
|
|
}
|
|
|
|
if(!this->OutputVariable.empty())
|
|
{
|
|
// if the TryCompileCore saved output in this outputVariable then
|
|
// prepend that output to this output
|
|
const char* compileOutput
|
|
= this->Makefile->GetDefinition(this->OutputVariable);
|
|
if (compileOutput)
|
|
{
|
|
runOutputContents = std::string(compileOutput) + runOutputContents;
|
|
}
|
|
this->Makefile->AddDefinition(this->OutputVariable,
|
|
runOutputContents.c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
// if we created a directory etc, then cleanup after ourselves
|
|
if(!this->Makefile->GetCMakeInstance()->GetDebugTryCompile())
|
|
{
|
|
this->CleanupFiles(this->BinaryDirectory.c_str());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void cmTryRunCommand::RunExecutable(const std::string& runArgs,
|
|
std::string* out)
|
|
{
|
|
int retVal = -1;
|
|
|
|
std::string finalCommand;
|
|
const std::string emulator =
|
|
this->Makefile->GetSafeDefinition("CMAKE_CROSSCOMPILING_EMULATOR");
|
|
if (!emulator.empty())
|
|
{
|
|
std::vector<std::string> emulatorWithArgs;
|
|
cmSystemTools::ExpandListArgument(emulator, emulatorWithArgs);
|
|
finalCommand += cmSystemTools::ConvertToRunCommandPath(
|
|
emulatorWithArgs[0].c_str());
|
|
finalCommand += " ";
|
|
for (std::vector<std::string>::const_iterator ei =
|
|
emulatorWithArgs.begin()+1;
|
|
ei != emulatorWithArgs.end(); ++ei)
|
|
{
|
|
finalCommand += "\"";
|
|
finalCommand += *ei;
|
|
finalCommand += "\"";
|
|
finalCommand += " ";
|
|
}
|
|
}
|
|
finalCommand += cmSystemTools::ConvertToRunCommandPath(
|
|
this->OutputFile.c_str());
|
|
if (!runArgs.empty())
|
|
{
|
|
finalCommand += runArgs;
|
|
}
|
|
int timeout = 0;
|
|
bool worked = cmSystemTools::RunSingleCommand(finalCommand.c_str(),
|
|
out, out, &retVal,
|
|
0, cmSystemTools::OUTPUT_NONE, timeout);
|
|
// set the run var
|
|
char retChar[1000];
|
|
if (worked)
|
|
{
|
|
sprintf(retChar, "%i", retVal);
|
|
}
|
|
else
|
|
{
|
|
strcpy(retChar, "FAILED_TO_RUN");
|
|
}
|
|
this->Makefile->AddCacheDefinition(this->RunResultVariable, retChar,
|
|
"Result of TRY_RUN",
|
|
cmState::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 cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
|
|
const std::string& srcFile,
|
|
std::string* out
|
|
)
|
|
{
|
|
// 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 = this->Makefile->GetHomeOutputDirectory();
|
|
copyDest += cmake::GetCMakeFilesDirectory();
|
|
copyDest += "/";
|
|
copyDest += cmSystemTools::GetFilenameWithoutExtension(
|
|
this->OutputFile);
|
|
copyDest += "-";
|
|
copyDest += this->RunResultVariable;
|
|
copyDest += cmSystemTools::GetFilenameExtension(this->OutputFile);
|
|
cmSystemTools::CopyFileAlways(this->OutputFile, copyDest);
|
|
|
|
std::string resultFileName = this->Makefile->GetHomeOutputDirectory();
|
|
resultFileName += "/TryRunResults.cmake";
|
|
|
|
std::string detailsString = "For details see ";
|
|
detailsString += resultFileName;
|
|
|
|
std::string internalRunOutputName=this->RunResultVariable+"__TRYRUN_OUTPUT";
|
|
bool error = false;
|
|
|
|
if (this->Makefile->GetDefinition(this->RunResultVariable) == 0)
|
|
{
|
|
// if the variables doesn't exist, create it with a helpful error text
|
|
// and mark it as advanced
|
|
std::string comment;
|
|
comment += "Run result of TRY_RUN(), indicates whether the executable "
|
|
"would have been able to run on its target platform.\n";
|
|
comment += detailsString;
|
|
this->Makefile->AddCacheDefinition(this->RunResultVariable,
|
|
"PLEASE_FILL_OUT-FAILED_TO_RUN",
|
|
comment.c_str(),
|
|
cmState::STRING);
|
|
|
|
cmState* state = this->Makefile->GetState();
|
|
const char* existingValue
|
|
= state->GetCacheEntryValue(this->RunResultVariable);
|
|
if (existingValue)
|
|
{
|
|
state->SetCacheEntryProperty(this->RunResultVariable, "ADVANCED", "1");
|
|
}
|
|
|
|
error = true;
|
|
}
|
|
|
|
// is the output from the executable used ?
|
|
if (out!=0)
|
|
{
|
|
if (this->Makefile->GetDefinition(internalRunOutputName) == 0)
|
|
{
|
|
// if the variables doesn't exist, create it with a helpful error text
|
|
// and mark it as advanced
|
|
std::string comment;
|
|
comment+="Output of TRY_RUN(), contains the text, which the executable "
|
|
"would have printed on stdout and stderr on its target platform.\n";
|
|
comment += detailsString;
|
|
|
|
this->Makefile->AddCacheDefinition(internalRunOutputName,
|
|
"PLEASE_FILL_OUT-NOTFOUND",
|
|
comment.c_str(),
|
|
cmState::STRING);
|
|
cmState* state = this->Makefile->GetState();
|
|
const char* 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)
|
|
{
|
|
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";
|
|
}
|
|
|
|
std::string comment ="\n";
|
|
comment += this->RunResultVariable;
|
|
comment += "\n indicates whether the executable would have been able "
|
|
"to run on its\n"
|
|
" target platform. If so, set ";
|
|
comment += this->RunResultVariable;
|
|
comment += " to\n"
|
|
" the exit code (in many cases 0 for success), otherwise "
|
|
"enter \"FAILED_TO_RUN\".\n";
|
|
if (out!=0)
|
|
{
|
|
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 += this->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->GetListFileStack();
|
|
cmsys::SystemTools::ReplaceString(comment, "\n", "\n# ");
|
|
file << comment << "\n\n";
|
|
|
|
file << "set( " << this->RunResultVariable << " \n \""
|
|
<< this->Makefile->GetDefinition(this->RunResultVariable)
|
|
<< "\"\n CACHE STRING \"Result from TRY_RUN\" FORCE)\n\n";
|
|
|
|
if (out!=0)
|
|
{
|
|
file << "set( " << internalRunOutputName << " \n \""
|
|
<< this->Makefile->GetDefinition(internalRunOutputName)
|
|
<< "\"\n CACHE STRING \"Output from TRY_RUN\" FORCE)\n\n";
|
|
}
|
|
file.close();
|
|
}
|
|
firstTryRun = false;
|
|
|
|
std::string errorMessage = "TRY_RUN() invoked in cross-compiling mode, "
|
|
"please set the following cache variables "
|
|
"appropriately:\n";
|
|
errorMessage += " " + this->RunResultVariable + " (advanced)\n";
|
|
if (out!=0)
|
|
{
|
|
errorMessage += " " + internalRunOutputName + " (advanced)\n";
|
|
}
|
|
errorMessage += detailsString;
|
|
cmSystemTools::Error(errorMessage.c_str());
|
|
return;
|
|
}
|
|
|
|
if (out!=0)
|
|
{
|
|
(*out) = this->Makefile->GetDefinition(internalRunOutputName);
|
|
}
|
|
}
|