path: root/Source/cmExecProgramCommand.cxx

/*============================================================================
  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 "cmExecProgramCommand.h"
#include "cmSystemTools.h"

#include <cmsys/Process.h>

// cmExecProgramCommand
bool cmExecProgramCommand
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
{
  if(args.size() < 1 )
    {
    this->SetError("called with incorrect number of arguments");
    return false;
    }
  std::string arguments;
  bool doingargs = false;
  int count = 0;
  std::string output_variable;
  bool haveoutput_variable = false;
  std::string return_variable;
  bool havereturn_variable = false;
  for(size_t i=0; i < args.size(); ++i)
    {
    if(args[i] == "OUTPUT_VARIABLE")
      {
      count++;
      doingargs = false;
      havereturn_variable = false;
      haveoutput_variable = true;
      }
    else if ( haveoutput_variable )
      {
      if (!output_variable.empty())
        {
        this->SetError("called with incorrect number of arguments");
        return false;
        }
      output_variable = args[i];
      haveoutput_variable = false;
      count ++;
      }
    else if(args[i] == "RETURN_VALUE")
      {
      count++;
      doingargs = false;
      haveoutput_variable = false;
      havereturn_variable = true;
      }
    else if ( havereturn_variable )
      {
      if (!return_variable.empty())
        {
        this->SetError("called with incorrect number of arguments");
        return false;
        }
      return_variable = args[i];
      havereturn_variable = false;
      count ++;
      }
    else if(args[i] == "ARGS")
      {
      count++;
      havereturn_variable = false;
      haveoutput_variable = false;
      doingargs = true;
      }
    else if(doingargs)
      {
      arguments += args[i];
      arguments += " ";
      count++;
      }
    }

  std::string command;
  if(!arguments.empty())
    {
    command = cmSystemTools::ConvertToRunCommandPath(args[0].c_str());
    command += " ";
    command += arguments;
    }
  else
    {
    command = args[0];
    }
  bool verbose = true;
  if(!output_variable.empty())
    {
    verbose = false;
    }
  int retVal = 0;
  std::string output;
  bool result = true;
  if(args.size() - count == 2)
    {
    cmSystemTools::MakeDirectory(args[1].c_str());
    result = cmExecProgramCommand::RunCommand(command.c_str(), output, retVal,
                                              args[1].c_str(), verbose);
    }
  else
    {
    result = cmExecProgramCommand::RunCommand(command.c_str(), output,
                                              retVal, 0, verbose);
    }
  if(!result)
    {
    retVal = -1;
    }

  if (!output_variable.empty())
    {
    std::string::size_type first = output.find_first_not_of(" \n\t\r");
    std::string::size_type last = output.find_last_not_of(" \n\t\r");
    if(first == std::string::npos)
      {
      first = 0;
      }
    if(last == std::string::npos)
      {
      last = output.size()-1;
      }

    std::string coutput = std::string(output, first, last-first+1);
    this->Makefile->AddDefinition(output_variable, coutput.c_str());
    }

  if (!return_variable.empty())
    {
    char buffer[100];
    sprintf(buffer, "%d", retVal);
    this->Makefile->AddDefinition(return_variable, buffer);
    }

  return true;
}

bool cmExecProgramCommand::RunCommand(const char* command,
                                      std::string& output,
                                      int &retVal,
                                      const char* dir,
                                      bool verbose)
{
  if(cmSystemTools::GetRunCommandOutput())
    {
    verbose = false;
    }

#if defined(WIN32) && !defined(__CYGWIN__)
  // if the command does not start with a quote, then
  // try to find the program, and if the program can not be
  // found use system to run the command as it must be a built in
  // shell command like echo or dir
  int count = 0;
  std::string shortCmd;
  if(command[0] == '\"')
    {
    // count the number of quotes
    for(const char* s = command; *s != 0; ++s)
      {
      if(*s == '\"')
        {
        count++;
        if(count > 2)
          {
          break;
          }
        }
      }
    // if there are more than two double quotes use
    // GetShortPathName, the cmd.exe program in windows which
    // is used by system fails to execute if there are more than
    // one set of quotes in the arguments
    if(count > 2)
      {
      cmsys::RegularExpression quoted("^\"([^\"]*)\"[ \t](.*)");
      if(quoted.find(command))
        {
        std::string cmd = quoted.match(1);
        std::string args = quoted.match(2);
        if(! cmSystemTools::FileExists(cmd.c_str()) )
          {
          shortCmd = cmd;
          }
        else if(!cmSystemTools::GetShortPath(cmd.c_str(), shortCmd))
          {
         cmSystemTools::Error("GetShortPath failed for " , cmd.c_str());
          return false;
          }
        shortCmd += " ";
        shortCmd += args;

        command = shortCmd.c_str();
        }
      else
        {
        cmSystemTools::Error("Could not parse command line with quotes ",
                             command);
        }
      }
    }
#endif

  // Allocate a process instance.
  cmsysProcess* cp = cmsysProcess_New();
  if(!cp)
    {
    cmSystemTools::Error("Error allocating process instance.");
    return false;
    }

#if defined(WIN32) && !defined(__CYGWIN__)
  if(dir)
    {
    cmsysProcess_SetWorkingDirectory(cp, dir);
    }
  if(cmSystemTools::GetRunCommandHideConsole())
    {
    cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1);
    }
  cmsysProcess_SetOption(cp, cmsysProcess_Option_Verbatim, 1);
  const char* cmd[] = {command, 0};
  cmsysProcess_SetCommand(cp, cmd);
#else
  std::string commandInDir;
  if(dir)
    {
    commandInDir = "cd \"";
    commandInDir += dir;
    commandInDir += "\" && ";
    commandInDir += command;
    }
  else
    {
    commandInDir = command;
    }
#ifndef __VMS
  commandInDir += " 2>&1";
#endif
  command = commandInDir.c_str();
  if(verbose)
    {
    cmSystemTools::Stdout("running ");
    cmSystemTools::Stdout(command);
    cmSystemTools::Stdout("\n");
    }
  fflush(stdout);
  fflush(stderr);
  const char* cmd[] = {"/bin/sh", "-c", command, 0};
  cmsysProcess_SetCommand(cp, cmd);
#endif

  cmsysProcess_Execute(cp);

  // Read the process output.
  int length;
  char* data;
  int p;
  while((p = cmsysProcess_WaitForData(cp, &data, &length, 0), p))
    {
    if(p == cmsysProcess_Pipe_STDOUT || p == cmsysProcess_Pipe_STDERR)
      {
      if(verbose)
        {
        cmSystemTools::Stdout(data, length);
        }
      output.append(data, length);
      }
    }

  // All output has been read.  Wait for the process to exit.
  cmsysProcess_WaitForExit(cp, 0);

  // Check the result of running the process.
  std::string msg;
  switch(cmsysProcess_GetState(cp))
    {
    case cmsysProcess_State_Exited:
      retVal = cmsysProcess_GetExitValue(cp);
      break;
    case cmsysProcess_State_Exception:
      retVal = -1;
      msg += "\nProcess terminated due to: ";
      msg += cmsysProcess_GetExceptionString(cp);
      break;
    case cmsysProcess_State_Error:
      retVal = -1;
      msg += "\nProcess failed because: ";
      msg += cmsysProcess_GetErrorString(cp);
      break;
    case cmsysProcess_State_Expired:
      retVal = -1;
      msg += "\nProcess terminated due to timeout.";
      break;
    }
  if(!msg.empty())
    {
#if defined(WIN32) && !defined(__CYGWIN__)
    // Old Windows process execution printed this info.
    msg += "\n\nfor command: ";
    msg += command;
    if(dir)
      {
      msg += "\nin dir: ";
      msg += dir;
      }
    msg += "\n";
    if(verbose)
      {
      cmSystemTools::Stdout(msg.c_str());
      }
    output += msg;
#else
    // Old UNIX process execution only put message in output.
    output += msg;
#endif
    }

  // Delete the process instance.
  cmsysProcess_Delete(cp);

  return true;
}