lib/System/Unix/Program.inc

   1 //===- llvm/System/Unix/Program.cpp -----------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by Reid Spencer and is distributed under the
   6 // University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the Unix specific portion of the Program class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 //===----------------------------------------------------------------------===//
  15 //=== WARNING: Implementation here must contain only generic UNIX code that
  16 //===          is guaranteed to work on *all* UNIX variants.
  17 //===----------------------------------------------------------------------===//
  18
  19 #include <llvm/Config/config.h>
  20 #include "Unix.h"
  21 #include <sys/stat.h>
  22 #include <fcntl.h>
  23 #ifdef HAVE_SYS_WAIT_H
  24 #include <sys/wait.h>
  25 #endif
  26
  27 extern char** environ;
  28
  29 namespace llvm {
  30 using namespace sys;
  31
  32 // This function just uses the PATH environment variable to find the program.
  33 Path
  34 Program::FindProgramByName(const std::string& progName) {
  35
  36   // Check some degenerate cases
  37   if (progName.length() == 0) // no program
  38     return Path();
  39   Path temp;
  40   if (!temp.setFile(progName)) // invalid name
  41     return Path();
  42   if (temp.executable()) // already executable as is
  43     return temp;
  44
  45   // At this point, the file name is valid and its not executable
  46
  47   // Get the path. If its empty, we can't do anything to find it.
  48   const char *PathStr = getenv("PATH");
  49   if (PathStr == 0)
  50     return Path();
  51
  52   // Now we have a colon separated list of directories to search; try them.
  53   unsigned PathLen = strlen(PathStr);
  54   while (PathLen) {
  55     // Find the first colon...
  56     const char *Colon = std::find(PathStr, PathStr+PathLen, ':');
  57
  58     // Check to see if this first directory contains the executable...
  59     Path FilePath;
  60     if (FilePath.setDirectory(std::string(PathStr,Colon))) {
  61       FilePath.appendFile(progName);
  62       if (FilePath.executable())
  63         return FilePath;                    // Found the executable!
  64     }
  65
  66     // Nope it wasn't in this directory, check the next path in the list!
  67     PathLen -= Colon-PathStr;
  68     PathStr = Colon;
  69
  70     // Advance past duplicate colons
  71     while (*PathStr == ':') {
  72       PathStr++;
  73       PathLen--;
  74     }
  75   }
  76   return Path();
  77 }
  78
  79 //
  80 int
  81 Program::ExecuteAndWait(const Path& path,
  82                         const std::vector<std::string>& args) {
  83   if (!path.executable())
  84     throw path.toString() + " is not executable";
  85
  86 #ifdef HAVE_SYS_WAIT_H
  87   // Create local versions of the parameters that can be passed into execve()
  88   // without creating const problems.
  89   const char* argv[ args.size() + 2 ];
  90   unsigned index = 0;
  91   std::string progname(path.getLast());
  92   argv[index++] = progname.c_str();
  93   for (unsigned i = 0; i < args.size(); i++)
  94     argv[index++] = args[i].c_str();
  95   argv[index] = 0;
  96
  97   // Create a child process.
  98   switch (fork()) {
  99     // An error occured:  Return to the caller.
 100     case -1:
 101       ThrowErrno(std::string("Couldn't execute program '") + path.toString() +
 102                  "'");
 103       break;
 104
 105     // Child process: Execute the program.
 106     case 0:
 107       execve (path.c_str(), (char** const)argv, environ);
 108       // If the execve() failed, we should exit and let the parent pick up
 109       // our non-zero exit status.
 110       exit (errno);
 111
 112     // Parent process: Break out of the switch to do our processing.
 113     default:
 114       break;
 115   }
 116
 117   // Parent process: Wait for the child process to terminate.
 118   int status;
 119   if ((::wait (&status)) == -1)
 120     ThrowErrno(std::string("Failed waiting for program '") + path.toString()
 121                + "'");
 122
 123   // If the program exited normally with a zero exit status, return success!
 124   if (WIFEXITED (status))
 125     return WEXITSTATUS(status);
 126   else if (WIFSIGNALED(status))
 127     throw std::string("Program '") + path.toString() +
 128           "' received terminating signal.";
 129   else
 130     return 0;
 131
 132 #else
 133   throw std::string("Program::ExecuteAndWait not implemented on this platform!\n");
 134 #endif
 135
 136 }
 137
 138 }
 139 // vim: sw=2 smartindent smarttab tw=80 autoindent expandtab