diff options
Diffstat (limited to 'Source/cmTryRunCommand.cxx')
| -rw-r--r-- | Source/cmTryRunCommand.cxx | 283 |
1 files changed, 242 insertions, 41 deletions
diff --git a/Source/cmTryRunCommand.cxx b/Source/cmTryRunCommand.cxx index 54e7a2da0b..1781e9c002 100644 --- a/Source/cmTryRunCommand.cxx +++ b/Source/cmTryRunCommand.cxx @@ -25,17 +25,16 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv) { 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 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv) } 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 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv) } 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")) + { + this->DoNotRunExecutable(runArgs, + argv[3], + captureRunOutput ? &runOutputContents : 0); + } + else { - finalCommand += runArgs; + this->RunExecutable(runArgs, &runOutputContents); } - int timeout = 0; - bool worked = cmSystemTools::RunSingleCommand(finalCommand.c_str(), - &output, &retVal, - 0, false, timeout); - if(outputVariable.size()) + + // 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 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv) } 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()); + } +} |