[cmake-commits] alex committed cmTryRunCommand.cxx 1.31 1.32
cmTryRunCommand.h 1.11 1.12
cmake-commits at cmake.org
cmake-commits at cmake.org
Fri Jun 1 11:16:32 EDT 2007
Update of /cvsroot/CMake/CMake/Source
In directory public:/mounts/ram/cvs-serv6882/Source
Modified Files:
cmTryRunCommand.cxx cmTryRunCommand.h
Log Message:
ENH: improve TRY_RUN() for crosscompiling: instead of just failing, it now
creates two cache variables, one for the RUN_RESULT, one for the RUN_OUTPUT
(if required), which can be set or preset by the user. It has now also two
new arguments: RUN_OUTPUT_VARIABLE and COMPILE_OUTPUT_VARIABLE (the old
OUTPUT_VARIABLE merges both), so if only COMPILE_OUTPUT_VARIABLE is used the
run time output of the TRY_RUN is unused and the user doesn't have to care
about the output when crosscompiling. This is now used in FindThreads.cmake,
CheckC/CXXSourceRuns.cmake and TestBigEndian.cmake, which used the output
only for the logfile (compile output is still there). Test/TryCompile/ now
also tests the behaviour of OUTPUT_VARIABLE, RUN_OUTPUT_VARIABLE and
COMPILE_OUTPUT_VARIABLE.
Alex
Index: cmTryRunCommand.h
===================================================================
RCS file: /cvsroot/CMake/CMake/Source/cmTryRunCommand.h,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -d -r1.11 -r1.12
--- cmTryRunCommand.h 24 May 2007 15:27:51 -0000 1.11
+++ cmTryRunCommand.h 1 Jun 2007 15:16:29 -0000 1.12
@@ -61,22 +61,55 @@
{
return
" TRY_RUN(RUN_RESULT_VAR COMPILE_RESULT_VAR\n"
- " bindir srcfile <CMAKE_FLAGS <Flags>>\n"
- " <COMPILE_DEFINITIONS <flags>>\n"
- " <OUTPUT_VARIABLE var>\n"
- " <ARGS <arg1> <arg2>...>)\n"
- "Try compiling a srcfile. Return the success or failure in "
- "COMPILE_RESULT_VAR. Then if the compile succeeded, run the "
- "executable and return the result in RUN_RESULT_VAR. "
- "If the executable was built, but failed to run for some"
- "reason, then RUN_RESULT_VAR will be set to FAILED_TO_RUN, and "
- "the output will be in the COMPILE_RESULT_VAR. OUTPUT_VARIABLE "
- "specifies the name of the variable to put all of the standard "
- "output and standard error into.";
+ " bindir srcfile [CMAKE_FLAGS <Flags>]\n"
+ " [COMPILE_DEFINITIONS <flags>]\n"
+ " [COMPILE_OUTPUT_VARIABLE comp]\n"
+ " [RUN_OUTPUT_VARIABLE run]\n"
+ " [OUTPUT_VARIABLE var]\n"
+ " [ARGS <arg1> <arg2>...])\n"
+ "Try compiling a srcfile. Return TRUE or FALSE for success or failure "
+ "in COMPILE_RESULT_VAR. Then if the compile succeeded, run the "
+ "executable and return its exit code in RUN_RESULT_VAR. "
+ "If the executable was built, but failed to run, then RUN_RESULT_VAR "
+ "will be set to FAILED_TO_RUN. "
+ "COMPILE_OUTPUT_VARIABLE specifies the variable where the output from "
+ "the compile step goes. RUN_OUTPUT_VARIABLE specifies the variable "
+ "where the output from the running executable goes.\n"
+ "For compatibility reasons OUTPUT_VARIABLE is still supported, which "
+ "gives you the output from the compile and run step combined.\n\n"
+ "Cross compiling issues\n"
+ "When cross compiling, the executable compiled in the first step "
+ "usually cannot be run on the build host. TRY_RUN() checks the "
+ "CMAKE_CROSSCOMPILING variable to detect whether CMake is in "
+ "crosscompiling mode. If that's the case, it will still try to compile "
+ "the executable, but it will not try to run the executable. Instead it "
+ "will create cache variables which must be filled by the user or by "
+ "presetting them in some CMake script file to the values the "
+ "executable would have produced if it would have been run on its actual "
+ "target platform. These variables are RUN_RESULT_VAR (explanation see "
+ "above) and if RUN_OUTPUT_VARIABLE (or OUTPUT_VARIABLE) was used, an "
+ "additional cache variable "
+ "RUN_RESULT_VAR__COMPILE_RESULT_VAR__TRYRUN_OUTPUT."
+ "This is intended to hold stdout and stderr from the executable.\n"
+ "In order to make cross compiling your project easier, use TRY_RUN "
+ "only if really required. If you use TRY_RUN, use RUN_OUTPUT_VARIABLE "
+ "(or OUTPUT_VARIABLE) only if really required. Using them will require "
+ "that when crosscompiling, the cache variables will have to be set "
+ "manually to the output of the executable. You can also \"guard\" the "
+ "calls to TRY_RUN with IF(CMAKE_CROSSCOMPILING) and provide an "
+ "easy-to-preset alternative for this case.\n";
}
-
+
cmTypeMacro(cmTryRunCommand, cmCoreTryCompile);
+private:
+ void RunExecutable(const std::string& runArgs, std::string* runOutputContents);
+ void DoNotRunExecutable(const std::string& runArgs, const std::string& srcFile, std::string* runOutputContents);
+ std::string CompileResultVariable;
+ std::string RunResultVariable;
+ std::string OutputVariable;
+ std::string RunOutputVariable;
+ std::string CompileOutputVariable;
};
Index: cmTryRunCommand.cxx
===================================================================
RCS file: /cvsroot/CMake/CMake/Source/cmTryRunCommand.cxx,v
retrieving revision 1.31
retrieving revision 1.32
diff -u -d -r1.31 -r1.32
--- cmTryRunCommand.cxx 25 May 2007 16:05:59 -0000 1.31
+++ cmTryRunCommand.cxx 1 Jun 2007 15:16:29 -0000 1.32
@@ -25,17 +25,16 @@
{
return false;
}
-
- if (this->Makefile->IsOn("CMAKE_CROSSCOMPILING"))
- {
- this->SetError("doesn't work when crosscompiling.");
- cmSystemTools::SetFatalErrorOccured();
- return false;
- }
// build an arg list for TryCompile and extract the runArgs
std::vector<std::string> tryCompile;
- std::string outputVariable;
+
+ this->CompileResultVariable = "";
+ this->RunResultVariable = "";
+ this->OutputVariable = "";
+ this->RunOutputVariable = "";
+ this->CompileOutputVariable = "";
+
std::string runArgs;
unsigned int i;
for (i = 1; i < argv.size(); ++i)
@@ -57,19 +56,79 @@
}
else
{
- tryCompile.push_back(argv[i]);
if (argv[i] == "OUTPUT_VARIABLE")
- {
+ {
if ( argv.size() <= (i+1) )
{
cmSystemTools::Error(
"OUTPUT_VARIABLE specified but there is no variable");
return false;
}
- outputVariable = argv[i+1];
+ 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.size())
+ || (this->CompileOutputVariable.size())))
+ {
+ 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.size())
+ {
+ captureRunOutput = true;
+ tryCompile.push_back("OUTPUT_VARIABLE");
+ tryCompile.push_back(this->OutputVariable);
+ }
+ if (this->CompileOutputVariable.size())
+ {
+ tryCompile.push_back("OUTPUT_VARIABLE");
+ tryCompile.push_back(this->CompileOutputVariable);
+ }
+ if (this->RunOutputVariable.size())
+ {
+ captureRunOutput = true;
+ }
+
+ this->RunResultVariable = argv[0];
+ this->CompileResultVariable = argv[1];
+
// do the try compile
int res = this->TryCompileCode(tryCompile);
@@ -82,46 +141,42 @@
}
else
{
- int retVal = -1;
- std::string output;
- std::string finalCommand = cmSystemTools::ConvertToRunCommandPath(
- this->OutputFile.c_str());
- if(runArgs.size())
+ // "run" it and capture the output
+ std::string runOutputContents;
+ if (this->Makefile->IsOn("CMAKE_CROSSCOMPILING"))
{
- finalCommand += runArgs;
+ this->DoNotRunExecutable(runArgs,
+ argv[3],
+ captureRunOutput ? &runOutputContents : 0);
}
- int timeout = 0;
- bool worked = cmSystemTools::RunSingleCommand(finalCommand.c_str(),
- &output, &retVal,
- 0, false, timeout);
- if(outputVariable.size())
+ else
+ {
+ this->RunExecutable(runArgs, &runOutputContents);
+ }
+
+ // now put the output into the variables
+ if(this->RunOutputVariable.size())
+ {
+ this->Makefile->AddDefinition(this->RunOutputVariable.c_str(),
+ runOutputContents.c_str());
+ }
+
+ if(this->OutputVariable.size())
{
// if the TryCompileCore saved output in this outputVariable then
// prepend that output to this output
const char* compileOutput
- = this->Makefile->GetDefinition(outputVariable.c_str());
- if(compileOutput)
+ = this->Makefile->GetDefinition(this->OutputVariable.c_str());
+ if (compileOutput)
{
- output = std::string(compileOutput) + output;
+ runOutputContents = std::string(compileOutput) + runOutputContents;
}
- this->Makefile->AddDefinition(outputVariable.c_str(), output.c_str());
- }
- // set the run var
- char retChar[1000];
- if(worked)
- {
- sprintf(retChar,"%i",retVal);
- }
- else
- {
- strcpy(retChar, "FAILED_TO_RUN");
+ this->Makefile->AddDefinition(this->OutputVariable.c_str(),
+ runOutputContents.c_str());
}
- this->Makefile->AddCacheDefinition(argv[0].c_str(), retChar,
- "Result of TRY_RUN",
- cmCacheManager::INTERNAL);
}
- }
-
+ }
+
// if we created a directory etc, then cleanup after ourselves
if(!this->Makefile->GetCMakeInstance()->GetDebugTryCompile())
{
@@ -129,3 +184,149 @@
}
return true;
}
+
+void cmTryRunCommand::RunExecutable(const std::string& runArgs,
+ std::string* out)
+{
+ int retVal = -1;
+ std::string finalCommand = cmSystemTools::ConvertToRunCommandPath(
+ this->OutputFile.c_str());
+ if (runArgs.size())
+ {
+ finalCommand += runArgs;
+ }
+ int timeout = 0;
+ bool worked = cmSystemTools::RunSingleCommand(finalCommand.c_str(),
+ out, &retVal,
+ 0, false, 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.c_str(), retChar,
+ "Result of TRY_RUN",
+ cmCacheManager::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
+ )
+{
+
+ std::string internalRunOutputName = this->RunResultVariable+"__"
+ +this->CompileResultVariable+"__TRYRUN_OUTPUT";
+ bool error = false;
+ std::string info = "Source file: ";
+ info += srcFile + "\n";
+ if (runArgs.size())
+ {
+ info += "Run arguments: ";
+ info += runArgs;
+ info += "\n";
+ }
+ info += "Current CMake stack: " + this->Makefile->GetListFileStack();
+
+ if (this->Makefile->GetDefinition(this->RunResultVariable.c_str()) == 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().\n"
+ "This variable should indicate whether the executable would "
+ "have been able to run if it was executed on its target "
+ "platform.\n"
+ "If it would have been able to run, enter the exit code here "
+ "(in many cases 0 for success). If not, enter "
+ "\"FAILED_TO_RUN\" here.";
+ if (out!=0)
+ {
+ comment += "If it was able to run, also check the variable ";
+ comment += internalRunOutputName;
+ comment += " and set it appropriately.";
+ }
+ comment += "\n";
+ comment += info;
+ this->Makefile->AddCacheDefinition(this->RunResultVariable.c_str(),
+ "PLEASE_FILL_OUT-FAILED_TO_RUN",
+ comment.c_str(),
+ cmCacheManager::STRING);
+
+ cmCacheManager::CacheIterator it = this->Makefile->GetCacheManager()->
+ GetCacheIterator(this->RunResultVariable.c_str());
+ if ( !it.IsAtEnd() )
+ {
+ it.SetProperty("ADVANCED", "1");
+ }
+
+ error = true;
+ }
+
+ if (out!=0)
+ {
+ if (this->Makefile->GetDefinition(internalRunOutputName.c_str()) == 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().\n"
+ "This variable should contain the text, which the executable "
+ "run by TRY_RUN() would have printed on stdout and stderr, "
+ "if it was executed on its target platform.\n"
+ "The accompanying variable ";
+ comment += this->RunResultVariable;
+ comment += " indicates whether the executable would have been able to "
+ "run and its exit code."
+ "If the executable would not have been able to run, set ";
+ comment += internalRunOutputName;
+ comment += " empty. Otherwise check if the output is evaluated by the "
+ "calling CMake code. If this is the case, check the source "
+ "file what it would have printed if called with the given "
+ "arguments.\n";
+ comment += info;
+
+ this->Makefile->AddCacheDefinition(internalRunOutputName.c_str(),
+ "PLEASE_FILL_OUT-NOTFOUND",
+ comment.c_str(),
+ cmCacheManager::STRING);
+ cmCacheManager::CacheIterator it = this->Makefile->GetCacheManager()->
+ GetCacheIterator(internalRunOutputName.c_str());
+ if ( !it.IsAtEnd() )
+ {
+ it.SetProperty("ADVANCED", "1");
+ }
+
+ error = true;
+ }
+ }
+
+ if (error)
+ {
+ std::string errorMessage = "TRY_RUN() invoked in cross-compiling mode, "
+ "please set the following cache variables "
+ "appropriatly:\n";
+ errorMessage += " " + this->RunResultVariable + " (advanced)\n";
+ if (out!=0)
+ {
+ errorMessage += " " + internalRunOutputName + " (advanced)\n";
+ }
+ errorMessage += info;
+ cmSystemTools::Error(errorMessage.c_str());
+ return;
+ }
+
+ if (out!=0)
+ {
+ (*out) = this->Makefile->GetDefinition(internalRunOutputName.c_str());
+ }
+}
More information about the Cmake-commits
mailing list