mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-21 18:29:46 +00:00
Replace use of PathV1.h in Program.cpp.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@183996 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
4ebf543b93
commit
fcba9c56a2
@ -342,6 +342,12 @@ inline bool exists(const Twine &path) {
|
||||
return !exists(path, result) && result;
|
||||
}
|
||||
|
||||
/// @brief Can we execute this file?
|
||||
///
|
||||
/// @param Path Input path.
|
||||
/// @returns True if we can execute it, false otherwise.
|
||||
bool can_execute(const Twine &Path);
|
||||
|
||||
/// @brief Do file_status's represent the same thing?
|
||||
///
|
||||
/// @param A Input file_status.
|
||||
|
@ -12,7 +12,6 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Support/Program.h"
|
||||
#include "llvm/Support/PathV1.h"
|
||||
#include "llvm/Config/config.h"
|
||||
#include "llvm/Support/system_error.h"
|
||||
using namespace llvm;
|
||||
@ -23,39 +22,12 @@ using namespace sys;
|
||||
//=== independent code.
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
static bool Execute(void **Data, const Path &path, const char **args,
|
||||
const char **env, const sys::Path **redirects,
|
||||
unsigned memoryLimit, std::string *ErrMsg);
|
||||
|
||||
static int Wait(void *&Data, const Path &path, unsigned secondsToWait,
|
||||
std::string *ErrMsg);
|
||||
|
||||
|
||||
static bool Execute(void **Data, StringRef Program, const char **args,
|
||||
const char **env, const StringRef **Redirects,
|
||||
unsigned memoryLimit, std::string *ErrMsg) {
|
||||
Path P(Program);
|
||||
if (!Redirects)
|
||||
return Execute(Data, P, args, env, 0, memoryLimit, ErrMsg);
|
||||
Path IO[3];
|
||||
const Path *IOP[3];
|
||||
for (int I = 0; I < 3; ++I) {
|
||||
if (Redirects[I]) {
|
||||
IO[I] = *Redirects[I];
|
||||
IOP[I] = &IO[I];
|
||||
} else {
|
||||
IOP[I] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
return Execute(Data, P, args, env, IOP, memoryLimit, ErrMsg);
|
||||
}
|
||||
unsigned memoryLimit, std::string *ErrMsg);
|
||||
|
||||
static int Wait(void *&Data, StringRef Program, unsigned secondsToWait,
|
||||
std::string *ErrMsg) {
|
||||
Path P(Program);
|
||||
return Wait(Data, P, secondsToWait, ErrMsg);
|
||||
}
|
||||
std::string *ErrMsg);
|
||||
|
||||
int sys::ExecuteAndWait(StringRef Program, const char **args, const char **envp,
|
||||
const StringRef **redirects, unsigned secondsToWait,
|
||||
|
@ -292,6 +292,13 @@ error_code exists(const Twine &path, bool &result) {
|
||||
return error_code::success();
|
||||
}
|
||||
|
||||
bool can_execute(const Twine &Path) {
|
||||
SmallString<128> PathStorage;
|
||||
StringRef P = Path.toNullTerminatedStringRef(PathStorage);
|
||||
|
||||
return ::access(P.begin(), X_OK) != -1;
|
||||
}
|
||||
|
||||
bool equivalent(file_status A, file_status B) {
|
||||
assert(status_known(A) && status_known(B));
|
||||
return A.fs_st_dev == B.fs_st_dev &&
|
||||
|
@ -54,13 +54,11 @@ sys::FindProgramByName(const std::string& progName) {
|
||||
// Check some degenerate cases
|
||||
if (progName.length() == 0) // no program
|
||||
return "";
|
||||
Path temp;
|
||||
if (!temp.set(progName)) // invalid name
|
||||
return "";
|
||||
std::string temp = progName;
|
||||
// Use the given path verbatim if it contains any slashes; this matches
|
||||
// the behavior of sh(1) and friends.
|
||||
if (progName.find('/') != std::string::npos)
|
||||
return temp.str();
|
||||
return temp;
|
||||
|
||||
// At this point, the file name is valid and does not contain slashes. Search
|
||||
// for it through the directories specified in the PATH environment variable.
|
||||
@ -77,12 +75,10 @@ sys::FindProgramByName(const std::string& progName) {
|
||||
const char *Colon = std::find(PathStr, PathStr+PathLen, ':');
|
||||
|
||||
// Check to see if this first directory contains the executable...
|
||||
Path FilePath;
|
||||
if (FilePath.set(std::string(PathStr,Colon))) {
|
||||
FilePath.appendComponent(progName);
|
||||
if (FilePath.canExecute())
|
||||
return FilePath.str(); // Found the executable!
|
||||
}
|
||||
SmallString<128> FilePath(PathStr,Colon);
|
||||
sys::path::append(FilePath, progName);
|
||||
if (sys::fs::can_execute(Twine(FilePath)))
|
||||
return FilePath.str(); // Found the executable!
|
||||
|
||||
// Nope it wasn't in this directory, check the next path in the list!
|
||||
PathLen -= Colon-PathStr;
|
||||
@ -97,20 +93,20 @@ sys::FindProgramByName(const std::string& progName) {
|
||||
return "";
|
||||
}
|
||||
|
||||
static bool RedirectIO(const Path *Path, int FD, std::string* ErrMsg) {
|
||||
static bool RedirectIO(const StringRef *Path, int FD, std::string* ErrMsg) {
|
||||
if (Path == 0) // Noop
|
||||
return false;
|
||||
const char *File;
|
||||
if (Path->isEmpty())
|
||||
std::string File;
|
||||
if (Path->empty())
|
||||
// Redirect empty paths to /dev/null
|
||||
File = "/dev/null";
|
||||
else
|
||||
File = Path->c_str();
|
||||
File = *Path;
|
||||
|
||||
// Open the file
|
||||
int InFD = open(File, FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
|
||||
int InFD = open(File.c_str(), FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666);
|
||||
if (InFD == -1) {
|
||||
MakeErrMsg(ErrMsg, "Cannot open file '" + std::string(File) + "' for "
|
||||
MakeErrMsg(ErrMsg, "Cannot open file '" + File + "' for "
|
||||
+ (FD == 0 ? "input" : "output"));
|
||||
return true;
|
||||
}
|
||||
@ -126,19 +122,20 @@ static bool RedirectIO(const Path *Path, int FD, std::string* ErrMsg) {
|
||||
}
|
||||
|
||||
#ifdef HAVE_POSIX_SPAWN
|
||||
static bool RedirectIO_PS(const Path *Path, int FD, std::string *ErrMsg,
|
||||
static bool RedirectIO_PS(const StringRef *Path, int FD, std::string *ErrMsg,
|
||||
posix_spawn_file_actions_t *FileActions) {
|
||||
if (Path == 0) // Noop
|
||||
return false;
|
||||
const char *File;
|
||||
if (Path->isEmpty())
|
||||
std::string File;
|
||||
if (Path->empty())
|
||||
// Redirect empty paths to /dev/null
|
||||
File = "/dev/null";
|
||||
else
|
||||
File = Path->c_str();
|
||||
File = *Path;
|
||||
|
||||
if (int Err = posix_spawn_file_actions_addopen(FileActions, FD,
|
||||
File, FD == 0 ? O_RDONLY : O_WRONLY|O_CREAT, 0666))
|
||||
if (int Err = posix_spawn_file_actions_addopen(
|
||||
FileActions, FD, File.c_str(),
|
||||
FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666))
|
||||
return MakeErrMsg(ErrMsg, "Cannot dup2", Err);
|
||||
return false;
|
||||
}
|
||||
@ -178,8 +175,8 @@ static void SetMemoryLimits (unsigned size)
|
||||
|
||||
}
|
||||
|
||||
static bool Execute(void **Data, const Path &path, const char **args,
|
||||
const char **envp, const Path **redirects,
|
||||
static bool Execute(void **Data, StringRef Program, const char **args,
|
||||
const char **envp, const StringRef **redirects,
|
||||
unsigned memoryLimit, std::string *ErrMsg) {
|
||||
// If this OS has posix_spawn and there is no memory limit being implied, use
|
||||
// posix_spawn. It is more efficient than fork/exec.
|
||||
@ -219,7 +216,7 @@ static bool Execute(void **Data, const Path &path, const char **args,
|
||||
// Explicitly initialized to prevent what appears to be a valgrind false
|
||||
// positive.
|
||||
pid_t PID = 0;
|
||||
int Err = posix_spawn(&PID, path.c_str(), FileActions, /*attrp*/0,
|
||||
int Err = posix_spawn(&PID, Program.str().c_str(), FileActions, /*attrp*/0,
|
||||
const_cast<char **>(args), const_cast<char **>(envp));
|
||||
|
||||
if (FileActions)
|
||||
@ -270,12 +267,13 @@ static bool Execute(void **Data, const Path &path, const char **args,
|
||||
}
|
||||
|
||||
// Execute!
|
||||
std::string PathStr = Program;
|
||||
if (envp != 0)
|
||||
execve(path.c_str(),
|
||||
execve(PathStr.c_str(),
|
||||
const_cast<char **>(args),
|
||||
const_cast<char **>(envp));
|
||||
else
|
||||
execv(path.c_str(),
|
||||
execv(PathStr.c_str(),
|
||||
const_cast<char **>(args));
|
||||
// If the execve() failed, we should exit. Follow Unix protocol and
|
||||
// return 127 if the executable was not found, and 126 otherwise.
|
||||
@ -297,7 +295,7 @@ static bool Execute(void **Data, const Path &path, const char **args,
|
||||
return true;
|
||||
}
|
||||
|
||||
static int Wait(void *&Data, const sys::Path &path, unsigned secondsToWait,
|
||||
static int Wait(void *&Data, StringRef Program, unsigned secondsToWait,
|
||||
std::string *ErrMsg) {
|
||||
#ifdef HAVE_SYS_WAIT_H
|
||||
struct sigaction Act, Old;
|
||||
@ -356,7 +354,7 @@ static int Wait(void *&Data, const sys::Path &path, unsigned secondsToWait,
|
||||
// itself apparently does not), check to see if the failure was due to some
|
||||
// reason other than the file not existing, and return 126 in this case.
|
||||
bool Exists;
|
||||
if (result == 127 && !llvm::sys::fs::exists(path.str(), Exists) && Exists)
|
||||
if (result == 127 && !llvm::sys::fs::exists(Program, Exists) && Exists)
|
||||
result = 126;
|
||||
#endif
|
||||
if (result == 127) {
|
||||
|
@ -362,6 +362,17 @@ error_code exists(const Twine &path, bool &result) {
|
||||
return error_code::success();
|
||||
}
|
||||
|
||||
bool can_execute(const Twine &Path) {
|
||||
SmallString<128> PathStorage;
|
||||
SmallVector<wchar_t, 128> PathUtf16;
|
||||
|
||||
if (UTF8ToUTF16(Path.toStringRef(PathStorage), PathUtf16))
|
||||
return false;
|
||||
|
||||
DWORD Attr = ::GetFileAttributesW(PathUtf16.begin());
|
||||
return Attr != INVALID_FILE_ATTRIBUTES;
|
||||
}
|
||||
|
||||
bool equivalent(file_status A, file_status B) {
|
||||
assert(status_known(A) && status_known(B));
|
||||
return A.FileIndexHigh == B.FileIndexHigh &&
|
||||
|
@ -12,6 +12,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "Windows.h"
|
||||
#include "llvm/Support/FileSystem.h"
|
||||
#include <cstdio>
|
||||
#include <fcntl.h>
|
||||
#include <io.h>
|
||||
@ -37,13 +38,11 @@ std::string sys::FindProgramByName(const std::string &progName) {
|
||||
// Check some degenerate cases
|
||||
if (progName.length() == 0) // no program
|
||||
return "";
|
||||
Path temp;
|
||||
if (!temp.set(progName)) // invalid name
|
||||
return "";
|
||||
std::string temp = progName;
|
||||
// Return paths with slashes verbatim.
|
||||
if (progName.find('\\') != std::string::npos ||
|
||||
progName.find('/') != std::string::npos)
|
||||
return temp.str();
|
||||
return temp;
|
||||
|
||||
// At this point, the file name is valid and does not contain slashes.
|
||||
// Let Windows search for it.
|
||||
@ -76,7 +75,7 @@ std::string sys::FindProgramByName(const std::string &progName) {
|
||||
}
|
||||
}
|
||||
|
||||
static HANDLE RedirectIO(const Path *path, int fd, std::string* ErrMsg) {
|
||||
static HANDLE RedirectIO(const StringRef *path, int fd, std::string* ErrMsg) {
|
||||
HANDLE h;
|
||||
if (path == 0) {
|
||||
DuplicateHandle(GetCurrentProcess(), (HANDLE)_get_osfhandle(fd),
|
||||
@ -85,19 +84,19 @@ static HANDLE RedirectIO(const Path *path, int fd, std::string* ErrMsg) {
|
||||
return h;
|
||||
}
|
||||
|
||||
const char *fname;
|
||||
if (path->isEmpty())
|
||||
std::string fname;
|
||||
if (path->empty())
|
||||
fname = "NUL";
|
||||
else
|
||||
fname = path->c_str();
|
||||
fname = *path;
|
||||
|
||||
SECURITY_ATTRIBUTES sa;
|
||||
sa.nLength = sizeof(sa);
|
||||
sa.lpSecurityDescriptor = 0;
|
||||
sa.bInheritHandle = TRUE;
|
||||
|
||||
h = CreateFile(fname, fd ? GENERIC_WRITE : GENERIC_READ, FILE_SHARE_READ,
|
||||
&sa, fd == 0 ? OPEN_EXISTING : CREATE_ALWAYS,
|
||||
h = CreateFile(fname.c_str(), fd ? GENERIC_WRITE : GENERIC_READ,
|
||||
FILE_SHARE_READ, &sa, fd == 0 ? OPEN_EXISTING : CREATE_ALWAYS,
|
||||
FILE_ATTRIBUTE_NORMAL, NULL);
|
||||
if (h == INVALID_HANDLE_VALUE) {
|
||||
MakeErrMsg(ErrMsg, std::string(fname) + ": Can't open file for " +
|
||||
@ -171,13 +170,13 @@ static unsigned int ArgLenWithQuotes(const char *Str) {
|
||||
}
|
||||
|
||||
static bool Execute(void **Data,
|
||||
const Path& path,
|
||||
StringRef Program,
|
||||
const char** args,
|
||||
const char** envp,
|
||||
const Path** redirects,
|
||||
const StringRef** redirects,
|
||||
unsigned memoryLimit,
|
||||
std::string* ErrMsg) {
|
||||
if (!path.canExecute()) {
|
||||
if (!sys::fs::can_execute(Program)) {
|
||||
if (ErrMsg)
|
||||
*ErrMsg = "program not executable";
|
||||
return false;
|
||||
@ -297,7 +296,8 @@ static bool Execute(void **Data,
|
||||
|
||||
fflush(stdout);
|
||||
fflush(stderr);
|
||||
BOOL rc = CreateProcess(path.c_str(), command, NULL, NULL, TRUE, 0,
|
||||
std::string ProgramStr = Program;
|
||||
BOOL rc = CreateProcess(ProgramStr.c_str(), command, NULL, NULL, TRUE, 0,
|
||||
envblock, NULL, &si, &pi);
|
||||
DWORD err = GetLastError();
|
||||
|
||||
@ -311,7 +311,7 @@ static bool Execute(void **Data,
|
||||
if (!rc) {
|
||||
SetLastError(err);
|
||||
MakeErrMsg(ErrMsg, std::string("Couldn't execute program '") +
|
||||
path.str() + "'");
|
||||
ProgramStr + "'");
|
||||
return false;
|
||||
}
|
||||
if (Data) {
|
||||
@ -398,7 +398,7 @@ static int WaitAux(Win32ProcessInfo *wpi, unsigned secondsToWait,
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int Wait(void *&Data, const Path &path, unsigned secondsToWait,
|
||||
static int Wait(void *&Data, StringRef Program, unsigned secondsToWait,
|
||||
std::string *ErrMsg) {
|
||||
Win32ProcessInfo *wpi = reinterpret_cast<Win32ProcessInfo *>(Data);
|
||||
int Ret = WaitAux(wpi, secondsToWait, ErrMsg);
|
||||
|
Loading…
Reference in New Issue
Block a user