CMake/Source/cmExecuteProcessCommand.cxx

423 lines
11 KiB
C++
Raw Normal View History

/*============================================================================
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
2006-05-10 23:08:38 +04:00
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
{
std::ostringstream e;
e << " given unknown argument \"" << args[i] << "\".";
this->SetError(e.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);
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(!input_file.empty())
{
cmsysProcess_SetPipeFile(cp, cmsysProcess_Pipe_STDIN, input_file.c_str());
}
if(!output_file.empty())
{
cmsysProcess_SetPipeFile(cp, cmsysProcess_Pipe_STDOUT,
2006-05-10 23:08:38 +04:00
output_file.c_str());
}
if(!error_file.empty())
{
cmsysProcess_SetPipeFile(cp, cmsysProcess_Pipe_STDERR,
2006-05-10 23:08:38 +04:00
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())
{
cmSystemTools::Stderr(data, length);
}
else
{
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.empty())
{
this->Makefile->AddDefinition(output_variable,
2006-05-10 23:08:38 +04:00
&*tempOutput.begin());
}
if(!merge_output && !error_variable.empty() && !tempError.empty())
{
this->Makefile->AddDefinition(error_variable,
2006-05-10 23:08:38 +04:00
&*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, buf);
}
break;
case cmsysProcess_State_Exception:
this->Makefile->AddDefinition(result_variable,
cmsysProcess_GetExceptionString(cp));
break;
case cmsysProcess_State_Error:
this->Makefile->AddDefinition(result_variable,
cmsysProcess_GetErrorString(cp));
break;
case cmsysProcess_State_Expired:
this->Makefile->AddDefinition(result_variable,
"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);
}