CMakeLua/Source/CTest/cmProcess.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmProcess.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2009-01-14 18:48:03 $
   7   Version:   $Revision: 1.6 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17
  18 #include <cmProcess.h>
  19 #include <cmSystemTools.h>
  20
  21 cmProcess::cmProcess()
  22 {
  23   this->Process = 0;
  24   this->Timeout = 0;
  25 }
  26
  27 cmProcess::~cmProcess()
  28 {
  29   cmsysProcess_Delete(this->Process);
  30 }
  31 void cmProcess::SetCommand(const char* command)
  32 {
  33   this->Command = command;
  34 }
  35
  36 void cmProcess::SetCommandArguments(std::vector<std::string> const& args)
  37 {
  38   this->Arguments = args;
  39 }
  40
  41 bool cmProcess::StartProcess()
  42 {
  43   if(this->Command.size() == 0)
  44     {
  45     return false;
  46     }
  47   this->StartTime = cmSystemTools::GetTime();
  48   this->ProcessArgs.clear();
  49   // put the command as arg0
  50   this->ProcessArgs.push_back(this->Command.c_str());
  51   // now put the command arguments in
  52   for(std::vector<std::string>::iterator i = this->Arguments.begin();
  53       i != this->Arguments.end(); ++i)
  54     {
  55     this->ProcessArgs.push_back(i->c_str());
  56     }
  57   this->ProcessArgs.push_back(0); // null terminate the list
  58   this->Process = cmsysProcess_New();
  59   cmsysProcess_SetCommand(this->Process, &*this->ProcessArgs.begin());
  60   if(this->WorkingDirectory.size())
  61     {
  62     cmsysProcess_SetWorkingDirectory(this->Process,
  63                                      this->WorkingDirectory.c_str());
  64     }
  65   cmsysProcess_SetOption(this->Process, cmsysProcess_Option_HideWindow, 1);
  66   cmsysProcess_SetTimeout(this->Process, this->Timeout);
  67   cmsysProcess_Execute(this->Process);
  68   return (cmsysProcess_GetState(this->Process)
  69           == cmsysProcess_State_Executing);
  70 }
  71
  72 // return true if there is a new line of data
  73 // return false if there is no new data
  74 int cmProcess::CheckOutput(double timeout,
  75                             std::string& stdOutLine,
  76                             std::string& stdErrLine)
  77 {
  78   stdOutLine = "";
  79   stdErrLine = "";
  80   std::vector<char>::iterator outiter =
  81     this->StdOutBuffer.begin();
  82   std::vector<char>::iterator erriter =
  83     this->StdErrorBuffer.begin();
  84   while(1)
  85     {
  86     // Check for a newline in stdout.
  87     for(;outiter != this->StdOutBuffer.end(); ++outiter)
  88       {
  89       if((*outiter == '\r') && ((outiter+1) == this->StdOutBuffer.end()))
  90         {
  91         break;
  92         }
  93       else if(*outiter == '\n' || *outiter == '\0')
  94         {
  95         int length = outiter-this->StdOutBuffer.begin();
  96         if(length > 1 && *(outiter-1) == '\r')
  97           {
  98           --length;
  99           }
 100         if(length > 0)
 101           {
 102           stdOutLine.append(&this->StdOutBuffer[0], length);
 103           }
 104         this->StdOutBuffer.erase(this->StdOutBuffer.begin(), outiter+1);
 105         this->LastOutputPipe = cmsysProcess_Pipe_STDOUT;
 106         return  this->LastOutputPipe;;
 107         }
 108       }
 109
 110     // Check for a newline in stderr.
 111     for(;erriter != this->StdErrorBuffer.end(); ++erriter)
 112       {
 113       if((*erriter == '\r') && ((erriter+1) == this->StdErrorBuffer.end()))
 114         {
 115         break;
 116         }
 117       else if(*erriter == '\n' || *erriter == '\0')
 118         {
 119         int length = erriter-this->StdErrorBuffer.begin();
 120         if(length > 1 && *(erriter-1) == '\r')
 121           {
 122           --length;
 123           }
 124         if(length > 0)
 125           {
 126           stdErrLine.append(&this->StdErrorBuffer[0], length);
 127           }
 128         this->StdErrorBuffer.erase(this->StdErrorBuffer.begin(), erriter+1);
 129         this->LastOutputPipe = cmsysProcess_Pipe_STDERR;
 130         return this->LastOutputPipe;
 131         }
 132       }
 133
 134     // No newlines found.  Wait for more data from the process.
 135     int length;
 136     char* data;
 137     int pipe = cmsysProcess_WaitForData(this->Process, &data,
 138                                         &length, &timeout);
 139     if(pipe == cmsysProcess_Pipe_Timeout)
 140       {
 141       // Timeout has been exceeded.
 142       this->LastOutputPipe = pipe;
 143       return pipe;
 144       }
 145     else if(pipe == cmsysProcess_Pipe_STDOUT)
 146       {
 147       // Append to the stdout buffer.
 148       std::vector<char>::size_type size = this->StdOutBuffer.size();
 149       this->StdOutBuffer.insert(this->StdOutBuffer.end(), data, data+length);
 150       outiter = this->StdOutBuffer.begin()+size;
 151       }
 152     else if(pipe == cmsysProcess_Pipe_STDERR)
 153       {
 154       // Append to the stderr buffer.
 155       std::vector<char>::size_type size = this->StdErrorBuffer.size();
 156       this->StdErrorBuffer.insert(this->StdErrorBuffer.end(),
 157                                   data, data+length);
 158       erriter = this->StdErrorBuffer.begin()+size;
 159       }
 160     else if(pipe == cmsysProcess_Pipe_None)
 161       {
 162       // Both stdout and stderr pipes have broken.  Return leftover data.
 163       if(!this->StdOutBuffer.empty())
 164         {
 165         stdOutLine.append(&this->StdOutBuffer[0],
 166                           outiter-this->StdOutBuffer.begin());
 167         this->StdOutBuffer.erase(this->StdOutBuffer.begin(),
 168                                  this->StdOutBuffer.end());
 169         this->LastOutputPipe = cmsysProcess_Pipe_STDOUT;
 170         return this->LastOutputPipe;
 171         }
 172       else if(!this->StdErrorBuffer.empty())
 173         {
 174         stdErrLine.append(&this->StdErrorBuffer[0],
 175                           erriter-this->StdErrorBuffer.begin());
 176         this->StdErrorBuffer.erase(this->StdErrorBuffer.begin(),
 177                                    this->StdErrorBuffer.end());
 178         this->LastOutputPipe = cmsysProcess_Pipe_STDERR;
 179         return this->LastOutputPipe;
 180         }
 181       else
 182         {
 183         this->LastOutputPipe = cmsysProcess_Pipe_None;
 184         return this->LastOutputPipe;
 185         }
 186       }
 187     }
 188 }
 189
 190
 191 // return the process status
 192 int cmProcess::GetProcessStatus()
 193 {
 194   if(!this->Process)
 195     {
 196     return cmsysProcess_State_Exited;
 197     }
 198   return cmsysProcess_GetState(this->Process);
 199 }
 200
 201 // return true if the process is running
 202 bool cmProcess::IsRunning()
 203 {
 204   int status = this->GetProcessStatus();
 205   if(status == cmsysProcess_State_Executing )
 206     {
 207     if(this->LastOutputPipe != 0)
 208       {
 209       return true;
 210       }
 211     }
 212   // if the process is done, then wait for it to exit
 213   cmsysProcess_WaitForExit(this->Process, 0);
 214   this->ExitValue = cmsysProcess_GetExitValue(this->Process);
 215   this->TotalTime = cmSystemTools::GetTime() - this->StartTime;
 216 //  std::cerr << "Time to run: " << this->TotalTime << "\n";
 217   return false;
 218 }
 219
 220
 221 int cmProcess::ReportStatus()
 222 {
 223   int result = 1;
 224   switch(cmsysProcess_GetState(this->Process))
 225     {
 226     case cmsysProcess_State_Starting:
 227       {
 228       std::cerr << "cmProcess: Never started "
 229            << this->Command << " process.\n";
 230       } break;
 231     case cmsysProcess_State_Error:
 232       {
 233       std::cerr << "cmProcess: Error executing " << this->Command
 234                 << " process: "
 235                 << cmsysProcess_GetErrorString(this->Process)
 236                 << "\n";
 237       } break;
 238     case cmsysProcess_State_Exception:
 239       {
 240       std::cerr << "cmProcess: " << this->Command
 241                       << " process exited with an exception: ";
 242       switch(cmsysProcess_GetExitException(this->Process))
 243         {
 244         case cmsysProcess_Exception_None:
 245           {
 246           std::cerr << "None";
 247           } break;
 248         case cmsysProcess_Exception_Fault:
 249           {
 250           std::cerr << "Segmentation fault";
 251           } break;
 252         case cmsysProcess_Exception_Illegal:
 253           {
 254           std::cerr << "Illegal instruction";
 255           } break;
 256         case cmsysProcess_Exception_Interrupt:
 257           {
 258           std::cerr << "Interrupted by user";
 259           } break;
 260         case cmsysProcess_Exception_Numerical:
 261           {
 262           std::cerr << "Numerical exception";
 263           } break;
 264         case cmsysProcess_Exception_Other:
 265           {
 266           std::cerr << "Unknown";
 267           } break;
 268         }
 269       std::cerr << "\n";
 270       } break;
 271     case cmsysProcess_State_Executing:
 272       {
 273       std::cerr << "cmProcess: Never terminated " <<
 274         this->Command << " process.\n";
 275       } break;
 276     case cmsysProcess_State_Exited:
 277       {
 278       result = cmsysProcess_GetExitValue(this->Process);
 279       std::cerr << "cmProcess: " << this->Command
 280                 << " process exited with code "
 281                 << result << "\n";
 282       } break;
 283     case cmsysProcess_State_Expired:
 284       {
 285       std::cerr << "cmProcess: killed " << this->Command
 286                 << " process due to timeout.\n";
 287       } break;
 288     case cmsysProcess_State_Killed:
 289       {
 290       std::cerr << "cmProcess: killed " << this->Command << " process.\n";
 291       } break;
 292     }
 293   return result;
 294
 295 }