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 std::vector<std::string>& args) {
  73   if (!path.executable())
  74     throw path.get() + " is not executable";
  75
  76   // Windows wants a command line, not an array of args, to pass to the new
  77   // process.  We have to concatenate them all, while quoting the args that
  78   // have embedded spaces.
  79
  80   // First, determine the length of the command line.
  81   std::string progname(path.getLast());
  82   unsigned len = progname.length() + 1;
  83   if (progname.find(' ') != std::string::npos)
  84     len += 2;
  85
  86   for (unsigned i = 0; i < args.size(); i++) {
  87     len += args[i].length() + 1;
  88     if (args[i].find(' ') != std::string::npos)
  89       len += 2;
  90   }
  91
  92   // Now build the command line.
  93   char *command = reinterpret_cast<char *>(_alloca(len));
  94   char *p = command;
  95
  96   bool needsQuoting = progname.find(' ') != std::string::npos;
  97   if (needsQuoting)
  98     *p++ = '"';
  99   memcpy(p, progname.c_str(), progname.length());
 100   p += progname.length();
 101   if (needsQuoting)
 102     *p++ = '"';
 103   *p++ = ' ';
 104
 105   for (unsigned i = 0; i < args.size(); i++) {
 106     const std::string& arg = args[i];
 107     needsQuoting = arg.find(' ') != std::string::npos;
 108     if (needsQuoting)
 109       *p++ = '"';
 110     memcpy(p, arg.c_str(), arg.length());
 111     p += arg.length();
 112     if (needsQuoting)
 113       *p++ = '"';
 114     *p++ = ' ';
 115   }
 116
 117   *p = 0;
 118
 119   // Create a child process.
 120   STARTUPINFO si;
 121   memset(&si, 0, sizeof(si));
 122   si.cb = sizeof(si);
 123
 124   PROCESS_INFORMATION pi;
 125   memset(&pi, 0, sizeof(pi));
 126
 127   if (!CreateProcess(path.get().c_str(), command, NULL, NULL, FALSE, 0,
 128                      NULL, NULL, &si, &pi))
 129   {
 130     ThrowError(std::string("Couldn't execute program '") + path.get() + "'");
 131   }
 132
 133   // Wait for it to terminate.
 134   WaitForSingleObject(pi.hProcess, INFINITE);
 135
 136   // Get its exit status.
 137   DWORD status;
 138   BOOL rc = GetExitCodeProcess(pi.hProcess, &status);
 139
 140   // Done with the handles; go close them.
 141   CloseHandle(pi.hProcess);
 142   CloseHandle(pi.hThread);
 143
 144   if (!rc)
 145     ThrowError(std::string("Failed getting status for program '") + path.get() + "'");
 146
 147   return status;
 148 }
 149
 150 }
 151 // vim: sw=2 smartindent smarttab tw=80 autoindent expandtab