GitHub-Proxy/filesystem
1
0
Fork 0
mirror of https://git.mirrors.martin98.com/https://github.com/gulrak/filesystem synced 2025-07-21 11:54:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into feature-27-mingw-preferred_separator

Browse Source
This commit is contained in:
Steffen Schümann 2019-09-20 13:42:31 +02:00
commit 03b437cefb
2 changed files with 105 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

185
include/ghc/filesystem.hpp
View File

@ -1080,6 +1080,11 @@ enum class portable_error {
is_a_directory,
};
GHC_FS_API std::error_code make_error_code(portable_error err);
#ifdef GHC_OS_WINDOWS
GHC_FS_API std::error_code make_system_error(DWORD err = 0);
#else
GHC_FS_API std::error_code make_system_error(int err = 0);
#endif
} // namespace detail
namespace detail {
@ -1130,6 +1135,18 @@ GHC_INLINE std::error_code make_error_code(portable_error err)
return std::error_code();
}
#ifdef GHC_OS_WINDOWS
GHC_INLINE std::error_code make_system_error(DWORD err)
{
return std::error_code(err ? static_cast<int>(err) : static_cast<int>(::GetLastError()), std::system_category());
}
#else
GHC_INLINE std::error_code make_system_error(int err)
{
return std::error_code(err ? err : errno, std::system_category());
}
#endif
#endif // GHC_EXPAND_IMPL
template <typename Enum>
@ -1249,7 +1266,7 @@ GHC_INLINE unsigned consumeUtf8Fragment(const unsigned state, const uint8_t frag
0x88888880u, 0x22818108u, 0x88888881u, 0x88888882u, 0x88888884u, 0x88888887u, 0x88888886u, 0x82218108u, 0x82281108u, 0x88888888u, 0x88888883u, 0x88888885u, 0u, 0u, 0u, 0u,
};
uint8_t category = fragment < 128 ? 0 : (utf8_state_info[(fragment >> 3) & 0xf] >> ((fragment & 7) << 2)) & 0xf;
codepoint = (state ? (codepoint << 6) | (fragment & 0x3f) : (0xff >> category) & fragment);
codepoint = (state ? (codepoint << 6) | (fragment & 0x3fu) : (0xffu >> category) & fragment);
return state == S_RJCT ? static_cast<unsigned>(S_RJCT) : static_cast<unsigned>((utf8_state_info[category + 16] >> (state << 2)) & 0xf);
}
@ -1331,7 +1348,7 @@ inline StringType fromUtf8(const std::string& utf8String, const typename StringT
std::uint32_t codepoint = 0;
while (iter < utf8String.end()) {
if ((utf8_state = consumeUtf8Fragment(utf8_state, (uint8_t)*iter++, codepoint)) == S_STRT) {
result += codepoint;
result += static_cast<typename StringType::value_type>(codepoint);
codepoint = 0;
}
else if (utf8_state == S_RJCT) {
@ -1394,7 +1411,7 @@ inline std::string toUtf8(const std::basic_string<charT, traits, Alloc>& unicode
{
std::string result;
for (auto c : unicodeString) {
appendUTF8(result, c);
appendUTF8(result, static_cast<uint32_t>(c));
}
return result;
}
@ -1557,7 +1574,7 @@ GHC_INLINE std::string systemErrorText(ErrorNumber code = 0)
{
#if defined(GHC_OS_WINDOWS)
LPVOID msgBuf;
DWORD dw = code ? code : ::GetLastError();
DWORD dw = code ? static_cast<DWORD>(code) : ::GetLastError();
FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, dw, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPWSTR)&msgBuf, 0, NULL);
std::string msg = toUtf8(std::wstring((LPWSTR)msgBuf));
LocalFree(msgBuf);
@ -1587,11 +1604,11 @@ GHC_INLINE void create_symlink(const path& target_name, const path& new_symlink,
if (result == ERROR_PRIVILEGE_NOT_HELD && api_call(detail::fromUtf8<std::wstring>(new_symlink.u8string()).c_str(), detail::fromUtf8<std::wstring>(target_name.u8string()).c_str(), to_directory ? 3 : 2) != 0) {
return;
}
ec = std::error_code(result, std::system_category());
ec = detail::make_system_error(result);
}
}
else {
ec = std::error_code(ERROR_NOT_SUPPORTED, std::system_category());
ec = detail::make_system_error(ERROR_NOT_SUPPORTED);
}
}
@ -1600,25 +1617,25 @@ GHC_INLINE void create_hardlink(const path& target_name, const path& new_hardlin
static CreateHardLinkW_fp api_call = reinterpret_cast<CreateHardLinkW_fp>(GetProcAddress(GetModuleHandleW(L"kernel32.dll"), "CreateHardLinkW"));
if (api_call) {
if (api_call(detail::fromUtf8<std::wstring>(new_hardlink.u8string()).c_str(), detail::fromUtf8<std::wstring>(target_name.u8string()).c_str(), NULL) == 0) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
}
else {
ec = std::error_code(ERROR_NOT_SUPPORTED, std::system_category());
ec = detail::make_system_error(ERROR_NOT_SUPPORTED);
}
}
#else
GHC_INLINE void create_symlink(const path& target_name, const path& new_symlink, bool, std::error_code& ec)
{
if (::symlink(target_name.c_str(), new_symlink.c_str()) != 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
}
}
GHC_INLINE void create_hardlink(const path& target_name, const path& new_hardlink, std::error_code& ec)
{
if (::link(target_name.c_str(), new_hardlink.c_str()) != 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
}
}
#endif
@ -1708,7 +1725,7 @@ GHC_INLINE path resolveSymlink(const path& p, std::error_code& ec)
std::shared_ptr<void> file(CreateFileW(p.wstring().c_str(), 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 0, OPEN_EXISTING, FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, 0), CloseHandle);
if (file.get() == INVALID_HANDLE_VALUE) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
return path();
}
@ -1730,7 +1747,7 @@ GHC_INLINE path resolveSymlink(const path& p, std::error_code& ec)
}
}
else {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
return result;
#else
@ -1739,11 +1756,11 @@ GHC_INLINE path resolveSymlink(const path& p, std::error_code& ec)
std::vector<char> buffer(bufferSize, (char)0);
auto rc = ::readlink(p.c_str(), buffer.data(), buffer.size());
if (rc < 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return path();
}
else if (rc < static_cast<int>(bufferSize)) {
return path(std::string(buffer.data(), rc));
return path(std::string(buffer.data(), static_cast<std::string::size_type>(rc)));
}
bufferSize *= 2;
}
@ -1757,15 +1774,15 @@ GHC_INLINE time_t timeFromFILETIME(const FILETIME& ft)
ULARGE_INTEGER ull;
ull.LowPart = ft.dwLowDateTime;
ull.HighPart = ft.dwHighDateTime;
return ull.QuadPart / 10000000ULL - 11644473600ULL;
return static_cast<time_t>(ull.QuadPart / 10000000ULL - 11644473600ULL);
}
GHC_INLINE void timeToFILETIME(time_t t, FILETIME& ft)
{
LONGLONG ll;
ll = Int32x32To64(t, 10000000) + 116444736000000000;
ft.dwLowDateTime = (DWORD)ll;
ft.dwHighDateTime = ll >> 32;
ft.dwLowDateTime = static_cast<DWORD>(ll);
ft.dwHighDateTime = static_cast<DWORD>(ll >> 32);
}
template <typename INFO>
@ -1829,7 +1846,7 @@ GHC_INLINE file_status symlink_status_ex(const path& p, std::error_code& ec, uin
file_status fs;
WIN32_FILE_ATTRIBUTE_DATA attr;
if (!GetFileAttributesExW(detail::fromUtf8<std::wstring>(p.u8string()).c_str(), GetFileExInfoStandard, &attr)) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
else {
ec.clear();
@ -1856,7 +1873,7 @@ GHC_INLINE file_status symlink_status_ex(const path& p, std::error_code& ec, uin
file_status f_s = detail::file_status_from_st_mode(fs.st_mode);
return f_s;
}
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
if (detail::is_not_found_error(ec)) {
return file_status(file_type::not_found, perms::unknown);
}
@ -1869,12 +1886,12 @@ GHC_INLINE file_status status_ex(const path& p, std::error_code& ec, file_status
ec.clear();
#ifdef GHC_OS_WINDOWS
if (recurse_count > 16) {
ec = std::error_code(0x2A9 /*ERROR_STOPPED_ON_SYMLINK*/, std::system_category());
ec = detail::make_system_error(0x2A9 /*ERROR_STOPPED_ON_SYMLINK*/);
return file_status(file_type::unknown);
}
WIN32_FILE_ATTRIBUTE_DATA attr;
if (!::GetFileAttributesExW(p.wstring().c_str(), GetFileExInfoStandard, &attr)) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
else if (attr.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
path target = resolveSymlink(p, ec);
@ -1914,7 +1931,7 @@ GHC_INLINE file_status status_ex(const path& p, std::error_code& ec, file_status
}
}
if (sz) {
*sz = st.st_size;
*sz = static_cast<uintmax_t>(st.st_size);
}
if (nhl) {
*nhl = st.st_nlink;
@ -1925,7 +1942,7 @@ GHC_INLINE file_status status_ex(const path& p, std::error_code& ec, file_status
return fs;
}
else {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
if (detail::is_not_found_error(ec)) {
return file_status(file_type::not_found, perms::unknown);
}
@ -1946,8 +1963,8 @@ GHC_INLINE u8arguments::u8arguments(int& argc, char**& argv)
#ifdef GHC_OS_WINDOWS
LPWSTR* p;
p = ::CommandLineToArgvW(::GetCommandLineW(), &argc);
_args.reserve(argc);
_argp.reserve(argc);
_args.reserve(static_cast<size_t>(argc));
_argp.reserve(static_cast<size_t>(argc));
for (size_t i = 0; i < static_cast<size_t>(argc); ++i) {
_args.push_back(detail::toUtf8(std::wstring(p[i])));
_argp.push_back((char*)_args[i].data());
@ -3024,7 +3041,7 @@ GHC_INLINE path absolute(const path& p, std::error_code& ec)
return result;
}
}
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
return path();
#else
path base = current_path(ec);
@ -3049,7 +3066,7 @@ GHC_INLINE path absolute(const path& p, std::error_code& ec)
}
}
}
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return path();
#endif
}
@ -3261,12 +3278,12 @@ GHC_INLINE bool copy_file(const path& from, const path& to, copy_options options
if ((options & copy_options::update_existing) == copy_options::update_existing) {
auto from_time = last_write_time(from, ec);
if (ec) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return false;
}
auto to_time = last_write_time(to, ec);
if (ec) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return false;
}
if (from_time <= to_time) {
@ -3277,7 +3294,7 @@ GHC_INLINE bool copy_file(const path& from, const path& to, copy_options options
}
#ifdef GHC_OS_WINDOWS
if (!::CopyFileW(detail::fromUtf8<std::wstring>(from.u8string()).c_str(), detail::fromUtf8<std::wstring>(to.u8string()).c_str(), !overwrite)) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
return false;
}
return true;
@ -3285,7 +3302,7 @@ GHC_INLINE bool copy_file(const path& from, const path& to, copy_options options
std::vector<char> buffer(16384, '\0');
int in = -1, out = -1;
if ((in = ::open(from.c_str(), O_RDONLY)) < 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return false;
}
std::shared_ptr<void> guard_in(nullptr, [in](void*) { ::close(in); });
@ -3294,20 +3311,20 @@ GHC_INLINE bool copy_file(const path& from, const path& to, copy_options options
mode |= O_EXCL;
}
if ((out = ::open(to.c_str(), mode, static_cast<int>(sf.permissions() & perms::all))) < 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return false;
}
std::shared_ptr<void> guard_out(nullptr, [out](void*) { ::close(out); });
ssize_t br, bw;
while ((br = ::read(in, buffer.data(), buffer.size())) > 0) {
int offset = 0;
ssize_t offset = 0;
do {
if ((bw = ::write(out, buffer.data() + offset, br)) > 0) {
if ((bw = ::write(out, buffer.data() + offset, static_cast<size_t>(br))) > 0) {
br -= bw;
offset += bw;
}
else if (bw < 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return false;
}
} while (br);
@ -3421,12 +3438,12 @@ GHC_INLINE bool create_directory(const path& p, const path& attributes, std::err
#ifdef GHC_OS_WINDOWS
if (!attributes.empty()) {
if (!::CreateDirectoryExW(detail::fromUtf8<std::wstring>(attributes.u8string()).c_str(), detail::fromUtf8<std::wstring>(p.u8string()).c_str(), NULL)) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
return false;
}
}
else if (!::CreateDirectoryW(detail::fromUtf8<std::wstring>(p.u8string()).c_str(), NULL)) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
return false;
}
#else
@ -3434,13 +3451,13 @@ GHC_INLINE bool create_directory(const path& p, const path& attributes, std::err
if (!attributes.empty()) {
struct ::stat fileStat;
if (::stat(attributes.c_str(), &fileStat) != 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return false;
}
attribs = fileStat.st_mode;
}
if (::mkdir(p.c_str(), attribs) != 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return false;
}
#endif
@ -3506,7 +3523,7 @@ GHC_INLINE path current_path(std::error_code& ec)
DWORD pathlen = ::GetCurrentDirectoryW(0, 0);
std::unique_ptr<wchar_t[]> buffer(new wchar_t[size_t(pathlen) + 1]);
if (::GetCurrentDirectoryW(pathlen, buffer.get()) == 0) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
return path();
}
return path(std::wstring(buffer.get()), path::native_format);
@ -3514,7 +3531,7 @@ GHC_INLINE path current_path(std::error_code& ec)
size_t pathlen = static_cast<size_t>(std::max(int(::pathconf(".", _PC_PATH_MAX)), int(PATH_MAX)));
std::unique_ptr<char[]> buffer(new char[pathlen + 1]);
if (::getcwd(buffer.get(), pathlen) == NULL) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return path();
}
return path(buffer.get());
@ -3535,11 +3552,11 @@ GHC_INLINE void current_path(const path& p, std::error_code& ec) noexcept
ec.clear();
#ifdef GHC_OS_WINDOWS
if (!::SetCurrentDirectoryW(detail::fromUtf8<std::wstring>(p.u8string()).c_str())) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
#else
if (::chdir(p.string().c_str()) == -1) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
}
#endif
}
@ -3582,21 +3599,21 @@ GHC_INLINE bool equivalent(const path& p1, const path& p2, std::error_code& ec)
std::shared_ptr<void> file2(::CreateFileW(p2.wstring().c_str(), 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0), CloseHandle);
if (file1.get() == INVALID_HANDLE_VALUE || file2.get() == INVALID_HANDLE_VALUE) {
#ifdef LWG_2937_BEHAVIOUR
ec = std::error_code(e1 ? e1 : ::GetLastError(), std::system_category());
ec = detail::make_system_error(e1 ? e1 : ::GetLastError());
#else
if (file1 == file2) {
ec = std::error_code(e1 ? e1 : ::GetLastError(), std::system_category());
ec = detail::make_system_error(e1 ? e1 : ::GetLastError());
}
#endif
return false;
}
BY_HANDLE_FILE_INFORMATION inf1, inf2;
if (!::GetFileInformationByHandle(file1.get(), &inf1)) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
return false;
}
if (!::GetFileInformationByHandle(file2.get(), &inf2)) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
return false;
}
return inf1.ftLastWriteTime.dwLowDateTime == inf2.ftLastWriteTime.dwLowDateTime && inf1.ftLastWriteTime.dwHighDateTime == inf2.ftLastWriteTime.dwHighDateTime && inf1.nFileIndexHigh == inf2.nFileIndexHigh && inf1.nFileIndexLow == inf2.nFileIndexLow &&
@ -3608,10 +3625,10 @@ GHC_INLINE bool equivalent(const path& p1, const path& p2, std::error_code& ec)
auto rc2 = ::stat(p2.c_str(), &s2);
if (rc1 || rc2) {
#ifdef LWG_2937_BEHAVIOUR
ec = std::error_code(e1 ? e1 : errno, std::system_category());
ec = detail::make_system_error(e1 ? e1 : errno);
#else
if (rc1 && rc2) {
ec = std::error_code(e1 ? e1 : errno, std::system_category());
ec = detail::make_system_error(e1 ? e1 : errno);
}
#endif
return false;
@ -3636,14 +3653,14 @@ GHC_INLINE uintmax_t file_size(const path& p, std::error_code& ec) noexcept
#ifdef GHC_OS_WINDOWS
WIN32_FILE_ATTRIBUTE_DATA attr;
if (!GetFileAttributesExW(detail::fromUtf8<std::wstring>(p.u8string()).c_str(), GetFileExInfoStandard, &attr)) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
return static_cast<uintmax_t>(-1);
}
return static_cast<uintmax_t>(attr.nFileSizeHigh) << (sizeof(attr.nFileSizeHigh) * 8) | attr.nFileSizeLow;
#else
struct ::stat fileStat;
if (::stat(p.c_str(), &fileStat) == -1) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return static_cast<uintmax_t>(-1);
}
return static_cast<uintmax_t>(fileStat.st_size);
@ -3668,11 +3685,11 @@ GHC_INLINE uintmax_t hard_link_count(const path& p, std::error_code& ec) noexcep
std::shared_ptr<void> file(::CreateFileW(p.wstring().c_str(), 0, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 0, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0), CloseHandle);
BY_HANDLE_FILE_INFORMATION inf;
if (file.get() == INVALID_HANDLE_VALUE) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
else {
if (!::GetFileInformationByHandle(file.get(), &inf)) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
else {
result = inf.nNumberOfLinks;
@ -3876,10 +3893,10 @@ GHC_INLINE void last_write_time(const path& p, file_time_type new_time, std::err
std::shared_ptr<void> file(::CreateFileW(p.wstring().c_str(), FILE_WRITE_ATTRIBUTES, FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL), ::CloseHandle);
FILETIME ft;
auto tt = std::chrono::duration_cast<std::chrono::microseconds>(d).count() * 10 + 116444736000000000;
ft.dwLowDateTime = (unsigned long)tt;
ft.dwHighDateTime = tt >> 32;
ft.dwLowDateTime = static_cast<DWORD>(tt);
ft.dwHighDateTime = static_cast<DWORD>(tt >> 32);
if (!::SetFileTime(file.get(), 0, 0, &ft)) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
#elif defined(GHC_OS_MACOS)
#ifdef __MAC_OS_X_VERSION_MIN_REQUIRED
@ -3895,7 +3912,7 @@ GHC_INLINE void last_write_time(const path& p, file_time_type new_time, std::err
return;
}
}
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return;
#else
struct ::timespec times[2];
@ -3904,7 +3921,7 @@ GHC_INLINE void last_write_time(const path& p, file_time_type new_time, std::err
times[1].tv_sec = std::chrono::duration_cast<std::chrono::seconds>(d).count();
times[1].tv_nsec = std::chrono::duration_cast<std::chrono::nanoseconds>(d).count() % 1000000000;
if (::utimensat(AT_FDCWD, p.c_str(), times, AT_SYMLINK_NOFOLLOW) != 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
}
return;
#endif
@ -3916,7 +3933,7 @@ GHC_INLINE void last_write_time(const path& p, file_time_type new_time, std::err
times[1].tv_sec = std::chrono::duration_cast<std::chrono::seconds>(d).count();
times[1].tv_nsec = std::chrono::duration_cast<std::chrono::nanoseconds>(d).count() % 1000000000;
if (::utimensat(AT_FDCWD, p.c_str(), times, AT_SYMLINK_NOFOLLOW) != 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
}
return;
#endif
@ -3955,12 +3972,12 @@ GHC_INLINE void permissions(const path& p, perms prms, perm_options opts, std::e
#ifdef __GNUC__
auto oldAttr = GetFileAttributesW(p.wstring().c_str());
if (oldAttr != INVALID_FILE_ATTRIBUTES) {
DWORD newAttr = ((prms & perms::owner_write) == perms::owner_write) ? oldAttr & ~FILE_ATTRIBUTE_READONLY : oldAttr | FILE_ATTRIBUTE_READONLY;
DWORD newAttr = ((prms & perms::owner_write) == perms::owner_write) ? oldAttr & ~(static_cast<DWORD>(FILE_ATTRIBUTE_READONLY)) : oldAttr | FILE_ATTRIBUTE_READONLY;
if (oldAttr == newAttr || SetFileAttributesW(p.wstring().c_str(), newAttr)) {
return;
}
}
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
#else
int mode = 0;
if ((prms & perms::owner_read) == perms::owner_read) {
@ -3970,13 +3987,13 @@ GHC_INLINE void permissions(const path& p, perms prms, perm_options opts, std::e
mode |= _S_IWRITE;
}
if (::_wchmod(p.wstring().c_str(), mode) != 0) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
#endif
#else
if ((opts & perm_options::nofollow) != perm_options::nofollow) {
if (::chmod(p.c_str(), static_cast<mode_t>(prms)) != 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
}
}
#endif
@ -4054,17 +4071,17 @@ GHC_INLINE bool remove(const path& p, std::error_code& ec) noexcept
if (error == ERROR_FILE_NOT_FOUND || error == ERROR_PATH_NOT_FOUND) {
return false;
}
ec = std::error_code(error, std::system_category());
ec = detail::make_system_error(error);
}
if (!ec) {
if (attr & FILE_ATTRIBUTE_DIRECTORY) {
if (!RemoveDirectoryW(np.c_str())) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
}
else {
if (!DeleteFileW(np.c_str())) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
}
}
@ -4074,7 +4091,7 @@ GHC_INLINE bool remove(const path& p, std::error_code& ec) noexcept
if (error == ENOENT) {
return false;
}
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
}
#endif
return ec ? false : true;
@ -4146,13 +4163,13 @@ GHC_INLINE void rename(const path& from, const path& to, std::error_code& ec) no
#ifdef GHC_OS_WINDOWS
if (from != to) {
if (!MoveFileW(detail::fromUtf8<std::wstring>(from.u8string()).c_str(), detail::fromUtf8<std::wstring>(to.u8string()).c_str())) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
}
#else
if (from != to) {
if (::rename(from.c_str(), to.c_str()) != 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
}
}
#endif
@ -4172,17 +4189,21 @@ GHC_INLINE void resize_file(const path& p, uintmax_t size, std::error_code& ec)
ec.clear();
#ifdef GHC_OS_WINDOWS
LARGE_INTEGER lisize;
lisize.QuadPart = size;
lisize.QuadPart = static_cast<LONGLONG>(size);
if(lisize.QuadPart < 0) {
ec = detail::make_system_error(ERROR_FILE_TOO_LARGE);
return;
}
std::shared_ptr<void> file(CreateFileW(detail::fromUtf8<std::wstring>(p.u8string()).c_str(), GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL), CloseHandle);
if (file.get() == INVALID_HANDLE_VALUE) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
else if (SetFilePointerEx(file.get(), lisize, NULL, FILE_BEGIN) == 0 || SetEndOfFile(file.get()) == 0) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
}
#else
if (::truncate(p.c_str(), size) != 0) {
ec = std::error_code(errno, std::system_category());
if (::truncate(p.c_str(), static_cast<off_t>(size)) != 0) {
ec = detail::make_system_error();
}
#endif
}
@ -4205,14 +4226,14 @@ GHC_INLINE space_info space(const path& p, std::error_code& ec) noexcept
ULARGE_INTEGER totalNumberOfBytes = {0, 0};
ULARGE_INTEGER totalNumberOfFreeBytes = {0, 0};
if (!GetDiskFreeSpaceExW(detail::fromUtf8<std::wstring>(p.u8string()).c_str(), &freeBytesAvailableToCaller, &totalNumberOfBytes, &totalNumberOfFreeBytes)) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
return {static_cast<uintmax_t>(-1), static_cast<uintmax_t>(-1), static_cast<uintmax_t>(-1)};
}
return {static_cast<uintmax_t>(totalNumberOfBytes.QuadPart), static_cast<uintmax_t>(totalNumberOfFreeBytes.QuadPart), static_cast<uintmax_t>(freeBytesAvailableToCaller.QuadPart)};
#elif !defined(__ANDROID__) || __ANDROID_API__ >= 19
struct ::statvfs sfs;
if (::statvfs(p.c_str(), &sfs) != 0) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
return {static_cast<uintmax_t>(-1), static_cast<uintmax_t>(-1), static_cast<uintmax_t>(-1)};
}
return {static_cast<uintmax_t>(sfs.f_blocks * sfs.f_frsize), static_cast<uintmax_t>(sfs.f_bfree * sfs.f_frsize), static_cast<uintmax_t>(sfs.f_bavail * sfs.f_frsize)};
@ -4272,9 +4293,9 @@ GHC_INLINE path temp_directory_path(std::error_code& ec) noexcept
ec.clear();
#ifdef GHC_OS_WINDOWS
wchar_t buffer[512];
int rc = GetTempPathW(511, buffer);
auto rc = GetTempPathW(511, buffer);
if (!rc || rc > 511) {
ec = std::error_code(::GetLastError(), std::system_category());
ec = detail::make_system_error();
return path();
}
return path(std::wstring(buffer));
@ -4723,7 +4744,7 @@ public:
auto error = ::GetLastError();
_base = filesystem::path();
if (error != ERROR_ACCESS_DENIED || (options & directory_options::skip_permission_denied) == directory_options::none) {
_ec = std::error_code(::GetLastError(), std::system_category());
_ec = detail::make_system_error();
}
}
}
@ -4754,7 +4775,7 @@ public:
else {
auto err = ::GetLastError();
if(err != ERROR_NO_MORE_FILES) {
_ec = ec = std::error_code(err, std::system_category());
_ec = ec = detail::make_system_error(err);
}
FindClose(_dirHandle);
_dirHandle = INVALID_HANDLE_VALUE;
@ -4814,7 +4835,7 @@ public:
auto error = errno;
_base = filesystem::path();
if (error != EACCES || (options & directory_options::skip_permission_denied) == directory_options::none) {
_ec = std::error_code(errno, std::system_category());
_ec = detail::make_system_error();
}
}
else {
@ -4845,7 +4866,7 @@ public:
_dir = nullptr;
_current = path();
if (errno) {
ec = std::error_code(errno, std::system_category());
ec = detail::make_system_error();
}
break;
}

4
test/CMakeLists.txt
View File

@ -18,8 +18,8 @@ else()
add_executable(filesystem_test filesystem_test.cpp catch.hpp)
target_link_libraries(filesystem_test ghc_filesystem)
target_compile_options(filesystem_test PRIVATE
$<$<CXX_COMPILER_ID:Clang>:-Wall -Wextra -Wshadow -Werror>
$<$<CXX_COMPILER_ID:GNU>:-Wall -Wextra -Wshadow -Werror>
$<$<CXX_COMPILER_ID:Clang>:-Wall -Wextra -Wshadow -Wconversion -Wsign-conversion -Wpedantic -Werror>
$<$<CXX_COMPILER_ID:GNU>:-Wall -Wextra -Wshadow -Wconversion -Wsign-conversion -Wpedantic -Werror>
$<$<CXX_COMPILER_ID:MSVC>:/WX>)
if(CMAKE_CXX_COMPILER_ID MATCHES MSVC)
target_compile_definitions(filesystem_test PRIVATE _CRT_SECURE_NO_WARNINGS)