CMake/Source/cmTryRunCommand.cxx

417 lines
14 KiB
C++
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
2002-09-19 17:48:39 +04:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
2002-09-19 17:48:39 +04:00
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.
============================================================================*/
2002-09-19 17:48:39 +04:00
#include "cmTryRunCommand.h"
2002-09-19 17:48:39 +04:00
#include "cmTryCompileCommand.h"
#include <cmsys/FStream.hxx>
2002-09-19 17:48:39 +04:00
ENH: merge CMake-CrossCompileBasic to HEAD -add a RESULT_VARIABLE to INCLUDE() -add CMAKE_TOOLCHAIN_FILE for specifiying your (potentially crosscompiling) toolchain -have TRY_RUN() complain if you try to use it in crosscompiling mode (which were compiled but cannot run on this system) -use CMAKE_EXECUTABLE_SUFFIX in TRY_RUN(), probably TRY_RUN won't be able to run the executables if they have a different suffix because they are probably crosscompiled, but nevertheless it should be able to find them -make several cmake variables presettable by the user: CMAKE_C/CXX_COMPILER, CMAKE_C/CXX_OUTPUT_EXTENSION, CMAKE_SYSTEM_NAME, CMAKE_SYSTEM_INFO_FILE -support prefix for GNU toolchains (arm-elf-gcc, arm-elf-ar, arm-elf-strip etc.) -move ranlib on OSX from the file command to a command in executed in cmake_install.cmake -add support for stripping during install in cmake_install.cmake -split out cl.cmake from Windows-cl.cmake, first (very incomplete) step to support MS crosscompiling tools -remove stdio.h from the simple C program which checks if the compiler works, since this may not exist for some embedded platforms -create a new CMakeFindBinUtils.cmake which collects the search fro ar, ranlib, strip, ld, link, install_name_tool and other tools like these -add support for CMAKE_FIND_ROOT_PATH for all FIND_XXX commands, which is a list of directories which will be prepended to all search directories, right now as a cmake variable, turning it into a global cmake property may need some more work -remove cmTestTestHandler::TryExecutable(), it's unused -split cmFileCommand::HandleInstall() into slightly smaller functions Alex
2007-05-17 21:20:44 +04:00
// cmTryRunCommand
bool cmTryRunCommand
::InitialPass(std::vector<std::string> const& argv, cmExecutionStatus &)
2002-09-19 17:48:39 +04:00
{
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,
2002-09-19 17:48:39 +04:00
std::vector<std::string> tryCompile;
this->CompileResultVariable = "";
this->RunResultVariable = "";
this->OutputVariable = "";
this->RunOutputVariable = "";
this->CompileOutputVariable = "";
2002-09-19 17:48:39 +04:00
std::string runArgs;
2002-09-20 16:09:03 +04:00
unsigned int i;
2002-09-19 17:48:39 +04:00
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")
2002-09-19 17:48:39 +04:00
{
runArgs += " ";
runArgs += argv[i];
++i;
}
if (i < argv.size())
{
tryCompile.push_back(argv[i]);
}
2011-09-15 18:20:33 +04:00
}
else
2002-09-19 17:48:39 +04:00
{
if (argv[i] == "OUTPUT_VARIABLE")
{
if ( argv.size() <= (i+1) )
{
cmSystemTools::Error(
2006-03-10 21:54:57 +03:00
"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]);
}
2002-09-19 17:48:39 +04:00
}
}
// although they could be used together, don't allow it, because
// using OUTPUT_VARIABLE makes crosscompiling harder
2011-09-15 18:20:33 +04:00
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];
2002-09-19 17:48:39 +04:00
// do the try compile
int res = this->TryCompileCode(tryCompile, true);
2002-09-19 17:48:39 +04:00
// now try running the command if it compiled
if (!res)
2002-09-19 17:48:39 +04:00
{
if (this->OutputFile.empty())
2002-09-19 17:48:39 +04:00
{
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"))
{
2011-09-15 18:20:33 +04:00
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());
}
2002-09-19 17:48:39 +04:00
}
}
// if we created a directory etc, then cleanup after ourselves
2006-03-15 19:02:08 +03:00
if(!this->Makefile->GetCMakeInstance()->GetDebugTryCompile())
2004-08-05 01:21:19 +04:00
{
this->CleanupFiles(this->BinaryDirectory.c_str());
2004-08-05 01:21:19 +04:00
}
2002-09-19 17:48:39 +04:00
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
2011-09-15 18:20:33 +04:00
the executable would have produced.
*/
2011-09-15 18:20:33 +04:00
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);
2015-04-06 11:52:45 +03:00
cmState* state = this->Makefile->GetState();
const char* existingValue
2015-04-06 11:52:45 +03:00
= state->GetCacheEntryValue(this->RunResultVariable);
if (existingValue)
{
2015-04-06 11:52:45 +03:00
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);
2015-04-06 11:52:45 +03:00
cmState* state = this->Makefile->GetState();
const char* existing =
2015-04-06 11:52:45 +03:00
state->GetCacheEntryValue(internalRunOutputName);
if (existing)
{
2015-04-06 11:52:45 +03:00
state->SetCacheEntryProperty(internalRunOutputName,
"ADVANCED", "1");
}
error = true;
}
}
if (error)
{
static bool firstTryRun = true;
cmsys::ofstream file(resultFileName.c_str(),
2007-07-26 16:40:51 +04:00
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 ="\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->FormatListFileStack();
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);
}
}