Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-06-21 01:01:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Import LLVM openFileForRead and openFileForWrite.

Browse Source
This commit is contained in:
Peter Johnson
2017-08-13 00:37:14 -07:00
parent 7d9e6b7e22
commit 1c1fbf14cf
7 changed files with 380 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/main/native/cpp/llvm/Path.cpp
View File

@@ -22,6 +22,7 @@
#include <io.h>
#endif
#include "llvm/FileSystem.h"
#include "llvm/SmallString.h"
using namespace llvm;

85
src/main/native/cpp/llvm/Unix/Path.inc
View File

@@ -16,11 +16,96 @@
//=== is guaranteed to work on *all* UNIX variants.
//===----------------------------------------------------------------------===//
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/param.h>
#include <sys/types.h>
#include <unistd.h>
namespace llvm {
namespace sys {
namespace fs {
#if !defined(F_GETPATH)
static bool hasProcSelfFD() {
// If we have a /proc filesystem mounted, we can quickly establish the
// real name of the file with readlink
static const bool Result = (::access("/proc/self/fd", R_OK) == 0);
return Result;
}
#endif
std::error_code openFileForRead(const Twine &Name, int &ResultFD,
SmallVectorImpl<char> *RealPath) {
SmallString<128> Storage;
StringRef P = Name.toNullTerminatedStringRef(Storage);
while ((ResultFD = open(P.begin(), O_RDONLY)) < 0) {
if (errno != EINTR)
return std::error_code(errno, std::generic_category());
}
// Attempt to get the real name of the file, if the user asked
if(!RealPath)
return std::error_code();
RealPath->clear();
#if defined(F_GETPATH)
// When F_GETPATH is availble, it is the quickest way to get
// the real path name.
char Buffer[MAXPATHLEN];
if (::fcntl(ResultFD, F_GETPATH, Buffer) != -1)
RealPath->append(Buffer, Buffer + strlen(Buffer));
#else
char Buffer[PATH_MAX];
if (hasProcSelfFD()) {
char ProcPath[64];
snprintf(ProcPath, sizeof(ProcPath), "/proc/self/fd/%d", ResultFD);
ssize_t CharCount = ::readlink(ProcPath, Buffer, sizeof(Buffer));
if (CharCount > 0)
RealPath->append(Buffer, Buffer + CharCount);
} else {
// Use ::realpath to get the real path name
if (::realpath(P.begin(), Buffer) != nullptr)
RealPath->append(Buffer, Buffer + strlen(Buffer));
}
#endif
return std::error_code();
}
std::error_code openFileForWrite(const Twine &Name, int &ResultFD,
OpenFlags Flags, unsigned Mode) {
// Verify that we don't have both "append" and "excl".
assert((!(Flags & F_Excl) || !(Flags & F_Append)) &&
"Cannot specify both 'excl' and 'append' file creation flags!");
int OpenFlags = O_CREAT;
if (Flags & F_RW)
OpenFlags |= O_RDWR;
else
OpenFlags |= O_WRONLY;
if (Flags & F_Append)
OpenFlags |= O_APPEND;
else
OpenFlags |= O_TRUNC;
if (Flags & F_Excl)
OpenFlags |= O_EXCL;
SmallString<128> Storage;
StringRef P = Name.toNullTerminatedStringRef(Storage);
while ((ResultFD = open(P.begin(), OpenFlags, Mode)) < 0) {
if (errno != EINTR)
return std::error_code(errno, std::generic_category());
}
return std::error_code();
}
} // end namespace fs
} // end namespace sys
} // end namespace llvm
namespace llvm {
namespace sys {
namespace path {

195
src/main/native/cpp/llvm/Windows/Path.inc
View File

@@ -105,6 +105,201 @@ std::error_code UTF16ToCurCP(const wchar_t *utf16, size_t utf16_len,
using llvm::sys::windows::UTF8ToUTF16;
using llvm::sys::windows::UTF16ToUTF8;
namespace fs {
std::error_code current_path(SmallVectorImpl<char> &result) {
SmallVector<wchar_t, MAX_PATH> cur_path;
DWORD len = MAX_PATH;
do {
cur_path.reserve(len);
len = ::GetCurrentDirectoryW(cur_path.capacity(), cur_path.data());
// A zero return value indicates a failure other than insufficient space.
if (len == 0)
return mapWindowsError(::GetLastError());
// If there's insufficient space, the len returned is larger than the len
// given.
} while (len > cur_path.capacity());
// On success, GetCurrentDirectoryW returns the number of characters not
// including the null-terminator.
cur_path.set_size(len);
return UTF16ToUTF8(cur_path.begin(), cur_path.size(), result);
}
} // end namespace fs
namespace path {
// Convert a UTF-8 path to UTF-16. Also, if the absolute equivalent of the
// path is longer than CreateDirectory can tolerate, make it absolute and
// prefixed by '\\?\'.
std::error_code widenPath(const Twine &Path8,
SmallVectorImpl<wchar_t> &Path16) {
const size_t MaxDirLen = MAX_PATH - 12; // Must leave room for 8.3 filename.
// Several operations would convert Path8 to SmallString; more efficient to
// do it once up front.
SmallString<128> Path8Str;
Path8.toVector(Path8Str);
// If we made this path absolute, how much longer would it get?
size_t CurPathLen;
if (llvm::sys::path::is_absolute(Twine(Path8Str)))
CurPathLen = 0; // No contribution from current_path needed.
else {
CurPathLen = ::GetCurrentDirectoryW(0, NULL);
if (CurPathLen == 0)
return mapWindowsError(::GetLastError());
}
// Would the absolute path be longer than our limit?
if ((Path8Str.size() + CurPathLen) >= MaxDirLen &&
!Path8Str.startswith("\\\\?\\")) {
SmallString<2*MAX_PATH> FullPath("\\\\?\\");
if (CurPathLen) {
SmallString<80> CurPath;
if (std::error_code EC = llvm::sys::fs::current_path(CurPath))
return EC;
FullPath.append(CurPath);
}
// Traverse the requested path, canonicalizing . and .. as we go (because
// the \\?\ prefix is documented to treat them as real components).
// The iterators don't report separators and append() always attaches
// preferred_separator so we don't need to call native() on the result.
for (llvm::sys::path::const_iterator I = llvm::sys::path::begin(Path8Str),
E = llvm::sys::path::end(Path8Str);
I != E; ++I) {
if (I->size() == 1 && *I == ".")
continue;
if (I->size() == 2 && *I == "..")
llvm::sys::path::remove_filename(FullPath);
else
llvm::sys::path::append(FullPath, *I);
}
return UTF8ToUTF16(FullPath, Path16);
}
// Just use the caller's original path.
return UTF8ToUTF16(Path8Str, Path16);
}
} // end namespace path
using llvm::sys::path::widenPath;
namespace fs {
std::error_code openFileForRead(const Twine &Name, int &ResultFD,
SmallVectorImpl<char> *RealPath) {
SmallVector<wchar_t, 128> PathUTF16;
if (std::error_code EC = widenPath(Name, PathUTF16))
return EC;
HANDLE H =
::CreateFileW(PathUTF16.begin(), GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (H == INVALID_HANDLE_VALUE) {
DWORD LastError = ::GetLastError();
std::error_code EC = mapWindowsError(LastError);
// Provide a better error message when trying to open directories.
// This only runs if we failed to open the file, so there is probably
// no performances issues.
//if (LastError != ERROR_ACCESS_DENIED)
// return EC;
//if (is_directory(Name))
// return make_error_code(errc::is_a_directory);
return EC;
}
int FD = ::_open_osfhandle(intptr_t(H), 0);
if (FD == -1) {
::CloseHandle(H);
return mapWindowsError(ERROR_INVALID_HANDLE);
}
// Fetch the real name of the file, if the user asked
if (RealPath) {
RealPath->clear();
wchar_t RealPathUTF16[MAX_PATH];
DWORD CountChars =
::GetFinalPathNameByHandleW(H, RealPathUTF16, MAX_PATH,
FILE_NAME_NORMALIZED);
if (CountChars > 0 && CountChars < MAX_PATH) {
// Convert the result from UTF-16 to UTF-8.
SmallString<MAX_PATH> RealPathUTF8;
if (!UTF16ToUTF8(RealPathUTF16, CountChars, RealPathUTF8))
RealPath->append(RealPathUTF8.data(),
RealPathUTF8.data() + strlen(RealPathUTF8.data()));
}
}
ResultFD = FD;
return std::error_code();
}
std::error_code openFileForWrite(const Twine &Name, int &ResultFD,
OpenFlags Flags, unsigned Mode) {
// Verify that we don't have both "append" and "excl".
assert((!(Flags & F_Excl) || !(Flags & F_Append)) &&
"Cannot specify both 'excl' and 'append' file creation flags!");
SmallVector<wchar_t, 128> PathUTF16;
if (std::error_code EC = widenPath(Name, PathUTF16))
return EC;
DWORD CreationDisposition;
if (Flags & F_Excl)
CreationDisposition = CREATE_NEW;
else if (Flags & F_Append)
CreationDisposition = OPEN_ALWAYS;
else
CreationDisposition = CREATE_ALWAYS;
DWORD Access = GENERIC_WRITE;
if (Flags & F_RW)
Access |= GENERIC_READ;
HANDLE H = ::CreateFileW(PathUTF16.begin(), Access,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
CreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL);
if (H == INVALID_HANDLE_VALUE) {
DWORD LastError = ::GetLastError();
std::error_code EC = mapWindowsError(LastError);
// Provide a better error message when trying to open directories.
// This only runs if we failed to open the file, so there is probably
// no performances issues.
//if (LastError != ERROR_ACCESS_DENIED)
// return EC;
//if (is_directory(Name))
// return make_error_code(errc::is_a_directory);
return EC;
}
int OpenFlags = 0;
if (Flags & F_Append)
OpenFlags |= _O_APPEND;
if (Flags & F_Text)
OpenFlags |= _O_TEXT;
int FD = ::_open_osfhandle(intptr_t(H), OpenFlags);
if (FD == -1) {
::CloseHandle(H);
return mapWindowsError(ERROR_INVALID_HANDLE);
}
ResultFD = FD;
return std::error_code();
}
} // end namespace fs
namespace path {
static bool getKnownFolderPath(KNOWNFOLDERID folderId,

103
src/main/native/cpp/llvm/raw_ostream.cpp
View File

@@ -74,32 +74,6 @@ static inline bool RunningWindows8OrGreater() {
Mask) != FALSE;
}
static std::error_code UTF8ToUTF16(llvm::StringRef utf8,
llvm::SmallVectorImpl<wchar_t> &utf16) {
if (!utf8.empty()) {
int len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(),
utf8.size(), utf16.begin(), 0);
if (len == 0)
return llvm::mapWindowsError(::GetLastError());
utf16.reserve(len + 1);
utf16.set_size(len);
len = ::MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, utf8.begin(),
utf8.size(), utf16.begin(), utf16.size());
if (len == 0)
return llvm::mapWindowsError(::GetLastError());
}
// Make utf16 null terminated.
utf16.push_back(0);
utf16.pop_back();
return std::error_code();
}
#endif
using namespace llvm;
@@ -548,82 +522,9 @@ static int getFD(StringRef Filename, std::error_code &EC,
int FD;
//EC = sys::fs::openFileForWrite(Filename, FD, Flags);
//if (EC)
// return -1;
#if defined(_WIN32)
// Verify that we don't have both "append" and "excl".
assert((!(Flags & sys::fs::F_Excl) || !(Flags & sys::fs::F_Append)) &&
"Cannot specify both 'excl' and 'append' file creation flags!");
SmallVector<wchar_t, 128> PathUTF16;
EC = UTF8ToUTF16(Filename, PathUTF16);
if (EC) return -1;
DWORD CreationDisposition;
if (Flags & sys::fs::F_Excl)
CreationDisposition = CREATE_NEW;
else if (Flags & sys::fs::F_Append)
CreationDisposition = OPEN_ALWAYS;
else
CreationDisposition = CREATE_ALWAYS;
DWORD Access = GENERIC_WRITE;
if (Flags & sys::fs::F_RW)
Access |= GENERIC_READ;
HANDLE H = ::CreateFileW(PathUTF16.begin(), Access,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
CreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL);
if (H == INVALID_HANDLE_VALUE) {
DWORD LastError = ::GetLastError();
EC = mapWindowsError(LastError);
EC = sys::fs::openFileForWrite(Filename, FD, Flags);
if (EC)
return -1;
}
int OpenFlags = 0;
if (Flags & sys::fs::F_Append)
OpenFlags |= _O_APPEND;
if (Flags & sys::fs::F_Text)
OpenFlags |= _O_TEXT;
FD = ::_open_osfhandle(intptr_t(H), OpenFlags);
if (FD == -1) {
::CloseHandle(H);
EC = mapWindowsError(ERROR_INVALID_HANDLE);
return -1;
}
#else
// Verify that we don't have both "append" and "excl".
assert((!(Flags & sys::fs::F_Excl) || !(Flags & sys::fs::F_Append)) &&
"Cannot specify both 'excl' and 'append' file creation flags!");
int OpenFlags = O_CREAT;
if (Flags & sys::fs::F_RW)
OpenFlags |= O_RDWR;
else
OpenFlags |= O_WRONLY;
if (Flags & sys::fs::F_Append)
OpenFlags |= O_APPEND;
else
OpenFlags |= O_TRUNC;
if (Flags & sys::fs::F_Excl)
OpenFlags |= O_EXCL;
SmallString<128> Storage{Filename};
while ((FD = open(Storage.c_str(), OpenFlags, 0666)) < 0) {
if (errno != EINTR) {
EC = std::error_code(errno, std::generic_category());
return -1;
}
}
#endif
EC = std::error_code();
return FD;

12
src/main/native/cpp/support/raw_istream.cpp
View File

@@ -19,6 +19,18 @@
#include "llvm/SmallVector.h"
#include "llvm/StringRef.h"
#if defined(_MSC_VER)
#ifndef STDIN_FILENO
# define STDIN_FILENO 0
#endif
#ifndef STDOUT_FILENO
# define STDOUT_FILENO 1
#endif
#ifndef STDERR_FILENO
# define STDERR_FILENO 2
#endif
#endif
using namespace wpi;
llvm::StringRef raw_istream::getline(llvm::SmallVectorImpl<char>& buf,