summaryrefslogtreecommitdiff
path: root/Source/cmExecuteProcessCommand.cxx
diff options
context:
space:
mode:
authorAnas Nashif <anas.nashif@intel.com>2012-10-30 22:39:57 (GMT)
committerAnas Nashif <anas.nashif@intel.com>2012-10-30 22:39:57 (GMT)
commit035c7fabc3b82cbc9a346c11abe2e9462b4c0379 (patch)
tree7e40f5a790eae329a8c5d3e59f046451767956ff /Source/cmExecuteProcessCommand.cxx
downloadcmake-035c7fabc3b82cbc9a346c11abe2e9462b4c0379.zip
cmake-035c7fabc3b82cbc9a346c11abe2e9462b4c0379.tar.gz
cmake-035c7fabc3b82cbc9a346c11abe2e9462b4c0379.tar.bz2
Imported Upstream version 2.8.9upstream/2.8.9
Diffstat (limited to 'Source/cmExecuteProcessCommand.cxx')
-rw-r--r--Source/cmExecuteProcessCommand.cxx422
1 files changed, 422 insertions, 0 deletions
diff --git a/Source/cmExecuteProcessCommand.cxx b/Source/cmExecuteProcessCommand.cxx
new file mode 100644
index 0000000..a0d9c9c
--- /dev/null
+++ b/Source/cmExecuteProcessCommand.cxx
@@ -0,0 +1,422 @@
+/*============================================================================
+ 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 "cmExecuteProcessCommand.h"
+#include "cmSystemTools.h"
+
+#include <cmsys/Process.h>
+
+#include <ctype.h> /* isspace */
+
+static bool cmExecuteProcessCommandIsWhitespace(char c)
+{
+ return (isspace((int)c) || c == '\n' || c == '\r');
+}
+
+void cmExecuteProcessCommandFixText(std::vector<char>& output,
+ bool strip_trailing_whitespace);
+void cmExecuteProcessCommandAppend(std::vector<char>& output,
+ const char* data, int length);
+
+// cmExecuteProcessCommand
+bool cmExecuteProcessCommand
+::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
+{
+ if(args.size() < 1 )
+ {
+ this->SetError("called with incorrect number of arguments");
+ return false;
+ }
+ std::vector< std::vector<const char*> > cmds;
+ std::string arguments;
+ bool doing_command = false;
+ size_t command_index = 0;
+ bool output_quiet = false;
+ bool error_quiet = false;
+ bool output_strip_trailing_whitespace = false;
+ bool error_strip_trailing_whitespace = false;
+ std::string timeout_string;
+ std::string input_file;
+ std::string output_file;
+ std::string error_file;
+ std::string output_variable;
+ std::string error_variable;
+ std::string result_variable;
+ std::string working_directory;
+ for(size_t i=0; i < args.size(); ++i)
+ {
+ if(args[i] == "COMMAND")
+ {
+ doing_command = true;
+ command_index = cmds.size();
+ cmds.push_back(std::vector<const char*>());
+ }
+ else if(args[i] == "OUTPUT_VARIABLE")
+ {
+ doing_command = false;
+ if(++i < args.size())
+ {
+ output_variable = args[i];
+ }
+ else
+ {
+ this->SetError(" called with no value for OUTPUT_VARIABLE.");
+ return false;
+ }
+ }
+ else if(args[i] == "ERROR_VARIABLE")
+ {
+ doing_command = false;
+ if(++i < args.size())
+ {
+ error_variable = args[i];
+ }
+ else
+ {
+ this->SetError(" called with no value for ERROR_VARIABLE.");
+ return false;
+ }
+ }
+ else if(args[i] == "RESULT_VARIABLE")
+ {
+ doing_command = false;
+ if(++i < args.size())
+ {
+ result_variable = args[i];
+ }
+ else
+ {
+ this->SetError(" called with no value for RESULT_VARIABLE.");
+ return false;
+ }
+ }
+ else if(args[i] == "WORKING_DIRECTORY")
+ {
+ doing_command = false;
+ if(++i < args.size())
+ {
+ working_directory = args[i];
+ }
+ else
+ {
+ this->SetError(" called with no value for WORKING_DIRECTORY.");
+ return false;
+ }
+ }
+ else if(args[i] == "INPUT_FILE")
+ {
+ doing_command = false;
+ if(++i < args.size())
+ {
+ input_file = args[i];
+ }
+ else
+ {
+ this->SetError(" called with no value for INPUT_FILE.");
+ return false;
+ }
+ }
+ else if(args[i] == "OUTPUT_FILE")
+ {
+ doing_command = false;
+ if(++i < args.size())
+ {
+ output_file = args[i];
+ }
+ else
+ {
+ this->SetError(" called with no value for OUTPUT_FILE.");
+ return false;
+ }
+ }
+ else if(args[i] == "ERROR_FILE")
+ {
+ doing_command = false;
+ if(++i < args.size())
+ {
+ error_file = args[i];
+ }
+ else
+ {
+ this->SetError(" called with no value for ERROR_FILE.");
+ return false;
+ }
+ }
+ else if(args[i] == "TIMEOUT")
+ {
+ doing_command = false;
+ if(++i < args.size())
+ {
+ timeout_string = args[i];
+ }
+ else
+ {
+ this->SetError(" called with no value for TIMEOUT.");
+ return false;
+ }
+ }
+ else if(args[i] == "OUTPUT_QUIET")
+ {
+ doing_command = false;
+ output_quiet = true;
+ }
+ else if(args[i] == "ERROR_QUIET")
+ {
+ doing_command = false;
+ error_quiet = true;
+ }
+ else if(args[i] == "OUTPUT_STRIP_TRAILING_WHITESPACE")
+ {
+ doing_command = false;
+ output_strip_trailing_whitespace = true;
+ }
+ else if(args[i] == "ERROR_STRIP_TRAILING_WHITESPACE")
+ {
+ doing_command = false;
+ error_strip_trailing_whitespace = true;
+ }
+ else if(doing_command)
+ {
+ cmds[command_index].push_back(args[i].c_str());
+ }
+ else
+ {
+ cmOStringStream e;
+ e << " given unknown argument \"" << args[i] << "\".";
+ this->SetError(e.str().c_str());
+ return false;
+ }
+ }
+
+ if ( !this->Makefile->CanIWriteThisFile(output_file.c_str()) )
+ {
+ std::string e = "attempted to output into a file: " + output_file
+ + " into a source directory.";
+ this->SetError(e.c_str());
+ cmSystemTools::SetFatalErrorOccured();
+ return false;
+ }
+
+ // Check for commands given.
+ if(cmds.empty())
+ {
+ this->SetError(" called with no COMMAND argument.");
+ return false;
+ }
+ for(unsigned int i=0; i < cmds.size(); ++i)
+ {
+ if(cmds[i].empty())
+ {
+ this->SetError(" given COMMAND argument with no value.");
+ return false;
+ }
+ else
+ {
+ // Add the null terminating pointer to the command argument list.
+ cmds[i].push_back(0);
+ }
+ }
+
+ // Parse the timeout string.
+ double timeout = -1;
+ if(!timeout_string.empty())
+ {
+ if(sscanf(timeout_string.c_str(), "%lg", &timeout) != 1)
+ {
+ this->SetError(" called with TIMEOUT value that could not be parsed.");
+ return false;
+ }
+ }
+
+ // Create a process instance.
+ cmsysProcess* cp = cmsysProcess_New();
+
+ // Set the command sequence.
+ for(unsigned int i=0; i < cmds.size(); ++i)
+ {
+ cmsysProcess_AddCommand(cp, &*cmds[i].begin());
+ }
+
+ // Set the process working directory.
+ if(!working_directory.empty())
+ {
+ cmsysProcess_SetWorkingDirectory(cp, working_directory.c_str());
+ }
+
+ // Always hide the process window.
+ cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
+
+ // Check the output variables.
+ bool merge_output = (output_variable == error_variable);
+ if(error_variable.empty() && !error_quiet)
+ {
+ cmsysProcess_SetPipeShared(cp, cmsysProcess_Pipe_STDERR, 1);
+ }
+ if(!input_file.empty())
+ {
+ cmsysProcess_SetPipeFile(cp, cmsysProcess_Pipe_STDIN, input_file.c_str());
+ }
+ if(!output_file.empty())
+ {
+ cmsysProcess_SetPipeFile(cp, cmsysProcess_Pipe_STDOUT,
+ output_file.c_str());
+ }
+ if(!error_file.empty())
+ {
+ cmsysProcess_SetPipeFile(cp, cmsysProcess_Pipe_STDERR,
+ error_file.c_str());
+ }
+
+ // Set the timeout if any.
+ if(timeout >= 0)
+ {
+ cmsysProcess_SetTimeout(cp, timeout);
+ }
+
+ // Start the process.
+ cmsysProcess_Execute(cp);
+
+ // Read the process output.
+ std::vector<char> tempOutput;
+ std::vector<char> tempError;
+ int length;
+ char* data;
+ int p;
+ while((p = cmsysProcess_WaitForData(cp, &data, &length, 0), p))
+ {
+ // Put the output in the right place.
+ if((p == cmsysProcess_Pipe_STDOUT && !output_quiet) ||
+ (p == cmsysProcess_Pipe_STDERR && !error_quiet && merge_output))
+ {
+ if(output_variable.empty())
+ {
+ cmSystemTools::Stdout(data, length);
+ }
+ else
+ {
+ cmExecuteProcessCommandAppend(tempOutput, data, length);
+ }
+ }
+ else if(p == cmsysProcess_Pipe_STDERR && !error_quiet)
+ {
+ if(!error_variable.empty())
+ {
+ cmExecuteProcessCommandAppend(tempError, data, length);
+ }
+ }
+ }
+
+ // All output has been read. Wait for the process to exit.
+ cmsysProcess_WaitForExit(cp, 0);
+
+ // Fix the text in the output strings.
+ cmExecuteProcessCommandFixText(tempOutput,
+ output_strip_trailing_whitespace);
+ cmExecuteProcessCommandFixText(tempError,
+ error_strip_trailing_whitespace);
+
+ // Store the output obtained.
+ if(!output_variable.empty() && tempOutput.size())
+ {
+ this->Makefile->AddDefinition(output_variable.c_str(),
+ &*tempOutput.begin());
+ }
+ if(!merge_output && !error_variable.empty() && tempError.size())
+ {
+ this->Makefile->AddDefinition(error_variable.c_str(),
+ &*tempError.begin());
+ }
+
+ // Store the result of running the process.
+ if(!result_variable.empty())
+ {
+ switch(cmsysProcess_GetState(cp))
+ {
+ case cmsysProcess_State_Exited:
+ {
+ int v = cmsysProcess_GetExitValue(cp);
+ char buf[100];
+ sprintf(buf, "%d", v);
+ this->Makefile->AddDefinition(result_variable.c_str(), buf);
+ }
+ break;
+ case cmsysProcess_State_Exception:
+ this->Makefile->AddDefinition(result_variable.c_str(),
+ cmsysProcess_GetExceptionString(cp));
+ break;
+ case cmsysProcess_State_Error:
+ this->Makefile->AddDefinition(result_variable.c_str(),
+ cmsysProcess_GetErrorString(cp));
+ break;
+ case cmsysProcess_State_Expired:
+ this->Makefile->AddDefinition(result_variable.c_str(),
+ "Process terminated due to timeout");
+ break;
+ }
+ }
+
+ // Delete the process instance.
+ cmsysProcess_Delete(cp);
+
+ return true;
+}
+
+//----------------------------------------------------------------------------
+void cmExecuteProcessCommandFixText(std::vector<char>& output,
+ bool strip_trailing_whitespace)
+{
+ // Remove \0 characters and the \r part of \r\n pairs.
+ unsigned int in_index = 0;
+ unsigned int out_index = 0;
+ while(in_index < output.size())
+ {
+ char c = output[in_index++];
+ if((c != '\r' || !(in_index < output.size() && output[in_index] == '\n'))
+ && c != '\0')
+ {
+ output[out_index++] = c;
+ }
+ }
+
+ // Remove trailing whitespace if requested.
+ if(strip_trailing_whitespace)
+ {
+ while(out_index > 0 &&
+ cmExecuteProcessCommandIsWhitespace(output[out_index-1]))
+ {
+ --out_index;
+ }
+ }
+
+ // Shrink the vector to the size needed.
+ output.resize(out_index);
+
+ // Put a terminator on the text string.
+ output.push_back('\0');
+}
+
+//----------------------------------------------------------------------------
+void cmExecuteProcessCommandAppend(std::vector<char>& output,
+ const char* data, int length)
+{
+#if defined(__APPLE__)
+ // HACK on Apple to work around bug with inserting at the
+ // end of an empty vector. This resulted in random failures
+ // that were hard to reproduce.
+ if(output.empty() && length > 0)
+ {
+ output.push_back(data[0]);
+ ++data;
+ --length;
+ }
+#endif
+ output.insert(output.end(), data, data+length);
+}