lib/System/Win32/Program.inc

   1 //===- Win32/Program.cpp - Win32 Program Implementation ------- -*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Jeff Cohen and is distributed under the
   6 // University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file provides the Win32 specific implementation of the Program class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "Win32.h"
  15 #include <malloc.h>
  16
  17 //===----------------------------------------------------------------------===//
  18 //=== WARNING: Implementation here must contain only Win32 specific code
  19 //===          and must not be UNIX code
  20 //===----------------------------------------------------------------------===//
  21
  22 namespace llvm {
  23 using namespace sys;
  24
  25 // This function just uses the PATH environment variable to find the program.
  26 Path
  27 Program::FindProgramByName(const std::string& progName) {
  28
  29   // Check some degenerate cases
  30   if (progName.length() == 0) // no program
  31     return Path();
  32   Path temp;
  33   if (!temp.setFile(progName)) // invalid name
  34     return Path();
  35   if (temp.executable()) // already executable as is
  36     return temp;
  37
  38   // At this point, the file name is valid and its not executable.
  39   // Let Windows search for it.
  40   char buffer[MAX_PATH];
  41   char *dummy = NULL;
  42   DWORD len = SearchPath(NULL, progName.c_str(), ".exe", MAX_PATH,
  43                          buffer, &dummy);
  44
  45   // See if it wasn't found.
  46   if (len == 0)
  47     return Path();
  48
  49   // See if we got the entire path.
  50   if (len < MAX_PATH)
  51     return Path(buffer);
  52
  53   // Buffer was too small; grow and retry.
  54   while (true) {
  55     char *b = reinterpret_cast<char *>(_alloca(len+1));
  56     DWORD len2 = SearchPath(NULL, progName.c_str(), ".exe", len+1, b, &dummy);
  57
  58     // It is unlikely the search failed, but it's always possible some file
  59     // was added or removed since the last search, so be paranoid...
  60     if (len2 == 0)
  61       return Path();
  62     else if (len2 <= len)
  63       return Path(b);
  64
  65     len = len2;
  66   }
  67 }
  68
  69 //
  70 int
  71 Program::ExecuteAndWait(const Path& path,
  72                         const char** args,
  73                         const char** envp,
  74                         const Path** redirects,
  75                         unsigned secondsToWait) {
  76   if (!path.executable())
  77     throw path.toString() + " is not executable";
  78
  79   // Windows wants a command line, not an array of args, to pass to the new
  80   // process.  We have to concatenate them all, while quoting the args that
  81   // have embedded spaces.
  82
  83   // First, determine the length of the command line.
  84   std::string progname(path.getLast());
  85   unsigned len = progname.length() + 1;
  86   if (progname.find(' ') != std::string::npos)
  87     len += 2;
  88
  89   for (unsigned i = 0; args[i]; i++) {
  90     len += strlen(args[i]) + 1;
  91     if (strchr(args[i], ' '))
  92       len += 2;
  93   }
  94
  95   // Now build the command line.
  96   char *command = reinterpret_cast<char *>(_alloca(len));
  97   char *p = command;
  98
  99   bool needsQuoting = progname.find(' ') != std::string::npos;
 100   if (needsQuoting)
 101     *p++ = '"';
 102   memcpy(p, progname.c_str(), progname.length());
 103   p += progname.length();
 104   if (needsQuoting)
 105     *p++ = '"';
 106   *p++ = ' ';
 107
 108   for (unsigned i = 0; args[i]; i++) {
 109     const char *arg = args[i];
 110         size_t len = strlen(arg);
 111     needsQuoting = strchr(arg, ' ') != 0;
 112     if (needsQuoting)
 113       *p++ = '"';
 114     memcpy(p, arg, len);
 115     p += len;
 116     if (needsQuoting)
 117       *p++ = '"';
 118     *p++ = ' ';
 119   }
 120
 121   *p = 0;
 122
 123   // Create a child process.
 124   STARTUPINFO si;
 125   memset(&si, 0, sizeof(si));
 126   si.cb = sizeof(si);
 127
 128   // TODO: do replacement of standard input/output/error handles.
 129
 130   PROCESS_INFORMATION pi;
 131   memset(&pi, 0, sizeof(pi));
 132
 133   if (!CreateProcess(path.c_str(), command, NULL, NULL, FALSE, 0,
 134                      envp, NULL, &si, &pi))
 135   {
 136     ThrowError(std::string("Couldn't execute program '") +
 137                path.toString() + "'");
 138   }
 139
 140   // Wait for it to terminate.
 141   DWORD millisecondsToWait = INFINITE;
 142   if (secondsToWait > 0)
 143     millisecondsToWait = secondsToWait * 1000;
 144
 145   if (WaitForSingleObject(pi.hProcess, millisecondsToWait) == WAIT_TIMEOUT) {
 146     if (!TerminateProcess(pi.hProcess, 1)) {
 147       ThrowError(std::string("Failed to terminate timed-out program '") +
 148                  path.toString() + "'");
 149     }
 150     WaitForSingleObject(pi.hProcess, INFINITE);
 151   }
 152
 153   // Get its exit status.
 154   DWORD status;
 155   BOOL rc = GetExitCodeProcess(pi.hProcess, &status);
 156
 157   // Done with the handles; go close them.
 158   CloseHandle(pi.hProcess);
 159   CloseHandle(pi.hThread);
 160
 161   if (!rc)
 162     ThrowError(std::string("Failed getting status for program '") +
 163                path.toString() + "'");
 164
 165   return status;
 166 }
 167
 168 }
 169 // vim: sw=2 smartindent smarttab tw=80 autoindent expandtab