#include <llvm/Config/config.h>
#include "Unix.h"
+#include <iostream>
+#if HAVE_SYS_STAT_H
#include <sys/stat.h>
+#endif
+#if HAVE_SIGNAL_H
#include <signal.h>
+#endif
+#if HAVE_FCNTL_H
#include <fcntl.h>
-#ifdef HAVE_SYS_WAIT_H
-#include <sys/wait.h>
#endif
-#include <iostream>
-
-extern char** environ;
namespace llvm {
using namespace sys;
if (progName.length() == 0) // no program
return Path();
Path temp;
- if (!temp.setFile(progName)) // invalid name
+ if (!temp.set(progName)) // invalid name
return Path();
- if (temp.executable()) // already executable as is
+ // FIXME: have to check for absolute filename - we cannot assume anything
+ // about "." being in $PATH
+ if (temp.canExecute()) // already executable as is
return temp;
// At this point, the file name is valid and its not executable
// Check to see if this first directory contains the executable...
Path FilePath;
- if (FilePath.setDirectory(std::string(PathStr,Colon))) {
- FilePath.appendFile(progName);
- if (FilePath.executable())
+ if (FilePath.set(std::string(PathStr,Colon))) {
+ FilePath.appendComponent(progName);
+ if (FilePath.canExecute())
return FilePath; // Found the executable!
}
return Path();
}
-static void RedirectFD(const std::string &File, int FD) {
- if (File.empty()) return; // Noop
+static bool RedirectFD(const std::string &File, int FD, std::string* ErrMsg) {
+ if (File.empty()) return false; // Noop
// Open the file
int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
if (InFD == -1) {
- ThrowErrno("Cannot open file '" + File + "' for "
+ MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for "
+ (FD == 0 ? "input" : "output") + "!\n");
+ return true;
}
- dup2(InFD, FD); // Install it as the requested FD
+ // Install it as the requested FD
+ if (-1 == dup2(InFD, FD)) {
+ MakeErrMsg(ErrMsg, "Cannot dup2");
+ return true;
+ }
close(InFD); // Close the original FD
+ return false;
}
static bool Timeout = false;
const char** args,
const char** envp,
const Path** redirects,
- unsigned secondsToWait
-) {
- if (!path.executable())
- throw path.toString() + " is not executable";
+ unsigned secondsToWait,
+ std::string* ErrMsg)
+{
+ if (!path.canExecute()) {
+ if (ErrMsg)
+ *ErrMsg = path.toString() + " is not executable";
+ return -1;
+ }
#ifdef HAVE_SYS_WAIT_H
// Create a child process.
switch (child) {
// An error occured: Return to the caller.
case -1:
- ThrowErrno(std::string("Couldn't execute program '") + path.toString() +
- "'");
- break;
+ MakeErrMsg(ErrMsg, "Couldn't fork");
+ return -1;
// Child process: Execute the program.
case 0: {
// Redirect file descriptors...
if (redirects) {
- if (redirects[0])
- if (redirects[0]->isEmpty())
- RedirectFD("/dev/null",0);
- else
- RedirectFD(redirects[0]->toString(), 0);
- if (redirects[1])
- if (redirects[1]->isEmpty())
- RedirectFD("/dev/null",1);
- else
- RedirectFD(redirects[1]->toString(), 1);
+ if (redirects[0]) {
+ if (redirects[0]->isEmpty()) {
+ if (RedirectFD("/dev/null",0,ErrMsg)) { return -1; }
+ } else {
+ if (RedirectFD(redirects[0]->toString(), 0,ErrMsg)) { return -1; }
+ }
+ }
+ if (redirects[1]) {
+ if (redirects[1]->isEmpty()) {
+ if (RedirectFD("/dev/null",1,ErrMsg)) { return -1; }
+ } else {
+ if (RedirectFD(redirects[1]->toString(),1,ErrMsg)) { return -1; }
+ }
+ }
if (redirects[1] && redirects[2] &&
*(redirects[1]) != *(redirects[2])) {
- if (redirects[2]->isEmpty())
- RedirectFD("/dev/null",2);
- else
- RedirectFD(redirects[2]->toString(), 2);
- } else {
- dup2(1, 2);
+ if (redirects[2]->isEmpty()) {
+ if (RedirectFD("/dev/null",2,ErrMsg)) { return -1; }
+ } else {
+ if (RedirectFD(redirects[2]->toString(), 2,ErrMsg)) { return -1; }
+ }
+ } else if (-1 == dup2(1,2)) {
+ MakeErrMsg(ErrMsg, "Can't redirect");
+ return -1;
}
}
- // Set up the environment
- char** env = environ;
- if (envp != 0)
- env = (char**) envp;
-
// Execute!
- execve (path.c_str(), (char** const)args, env);
+ if (envp != 0)
+ execve (path.c_str(), (char** const)args, (char**)envp);
+ else
+ execv (path.c_str(), (char** const)args);
// If the execve() failed, we should exit and let the parent pick up
// our non-zero exit status.
exit (errno);
// Wait for child to die
if (wait(&status) != child)
- ThrowErrno("Child timedout but wouldn't die");
+ MakeErrMsg(ErrMsg, "Child timed out but wouldn't die");
return -1; // Timeout detected
} else {
- ThrowErrno("Error waiting for child process");
+ MakeErrMsg(ErrMsg, "Error waiting for child process");
+ return -1;
}
// We exited normally without timeout, so turn off the timer.
sigaction(SIGALRM, &Old, 0);
}
- // If the program exited normally with a zero exit status, return success!
- if (WIFEXITED (status))
- return WEXITSTATUS(status);
+ // Return the proper exit status. 0=success, >0 is programs' exit status,
+ // <0 means a signal was returned, -9999999 means the program dumped core.
+ int result = 0;
+ if (WIFEXITED(status))
+ result = WEXITSTATUS(status);
else if (WIFSIGNALED(status))
- throw std::string("Program '") + path.toString() +
- "' received terminating signal.";
-
+ result = 0 - WTERMSIG(status);
+#ifdef WCOREDUMP
+ else if (WCOREDUMP(status))
+ result |= 0x01000000;
+#endif
+ return result;
#else
- throw std::string(
- "Program::ExecuteAndWait not implemented on this platform!\n");
+ return -99;
#endif
- return 0;
+
+}
+
+bool Program::ChangeStdinToBinary(){
+ // Do nothing, as Unix doesn't differentiate between text and binary.
+ return false;
+}
+
+bool Program::ChangeStdoutToBinary(){
+ // Do nothing, as Unix doesn't differentiate between text and binary.
+ return false;
}
}
-// vim: sw=2 smartindent smarttab tw=80 autoindent expandtab