maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Cleanup name qualification in the filesystem internals. 

In most cases there is no reason why the filesystem internals
use the qualifier std:: or _VSTD::. This patch removes the unneeded
qualifiers, making the sources files more consistent

llvm-svn: 337684
This commit is contained in:
Eric Fiselier 2018-07-23 11:46:47 +00:00
parent e33d691990
commit c48dba4c6d
3 changed files with 118 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
libcxx/src/experimental/filesystem/directory_iterator.cpp
View File

@ -98,8 +98,8 @@ public:
__dir_stream& operator=(const __dir_stream&) = delete;
__dir_stream(__dir_stream&& __ds) noexcept
: __stream_(__ds.__stream_), __root_(std::move(__ds.__root_)),
__entry_(std::move(__ds.__entry_)) {
: __stream_(__ds.__stream_), __root_(move(__ds.__root_)),
__entry_(move(__ds.__entry_)) {
__ds.__stream_ = INVALID_HANDLE_VALUE;
}
@ -107,7 +107,7 @@ public:
: __stream_(INVALID_HANDLE_VALUE), __root_(root) {
__stream_ = ::FindFirstFileEx(root.c_str(), &__data_);
if (__stream_ == INVALID_HANDLE_VALUE) {
ec = error_code(::GetLastError(), std::generic_category());
ec = error_code(::GetLastError(), generic_category());
const bool ignore_permission_denied =
bool(opts & directory_options::skip_permission_denied);
if (ignore_permission_denied && ec.value() == ERROR_ACCESS_DENIED)
@ -138,16 +138,16 @@ public:
directory_entry::__create_iter_result(get_file_type(__data)));
return true;
}
ec = error_code(::GetLastError(), std::generic_category());
ec = error_code(::GetLastError(), generic_category());
close();
return false;
}
private:
std::error_code close() noexcept {
std::error_code ec;
error_code close() noexcept {
error_code ec;
if (!::FindClose(__stream_))
ec = error_code(::GetLastError(), std::generic_category());
ec = error_code(::GetLastError(), generic_category());
__stream_ = INVALID_HANDLE_VALUE;
return ec;
}
@ -166,8 +166,8 @@ public:
__dir_stream& operator=(const __dir_stream&) = delete;
__dir_stream(__dir_stream&& other) noexcept
: __stream_(other.__stream_), __root_(std::move(other.__root_)),
__entry_(std::move(other.__entry_))
: __stream_(other.__stream_), __root_(move(other.__root_)),
__entry_(move(other.__entry_))
{
other.__stream_ = nullptr;
}
@ -211,8 +211,8 @@ public:
}
}
private:
std::error_code close() noexcept {
std::error_code m_ec;
error_code close() noexcept {
error_code m_ec;
if (::closedir(__stream_) == -1)
m_ec = detail::capture_errno();
__stream_ = nullptr;
@ -233,7 +233,7 @@ directory_iterator::directory_iterator(const path& p, error_code *ec,
{
ErrorHandler<void> err("directory_iterator::directory_iterator(...)", ec, &p);
std::error_code m_ec;
error_code m_ec;
__imp_ = make_shared<__dir_stream>(p, opts, m_ec);
if (ec)
*ec = m_ec;
@ -249,9 +249,9 @@ directory_iterator& directory_iterator::__increment(error_code *ec)
_LIBCPP_ASSERT(__imp_, "Attempting to increment an invalid iterator");
ErrorHandler<void> err("directory_iterator::operator++()", ec);
std::error_code m_ec;
error_code m_ec;
if (!__imp_->advance(m_ec)) {
path root = std::move(__imp_->__root_);
path root = move(__imp_->__root_);
__imp_.reset();
if (m_ec)
err.report(m_ec, "at root \"%s\"", root);
@ -278,16 +278,16 @@ recursive_directory_iterator::recursive_directory_iterator(const path& p,
{
ErrorHandler<void> err("recursive_directory_iterator", ec, &p);
std::error_code m_ec;
error_code m_ec;
__dir_stream new_s(p, opt, m_ec);
if (m_ec)
err.report(m_ec);
if (m_ec || !new_s.good())
return;
__imp_ = _VSTD::make_shared<__shared_imp>();
__imp_ = make_shared<__shared_imp>();
__imp_->__options_ = opt;
__imp_->__stack_.push(_VSTD::move(new_s));
__imp_->__stack_.push(move(new_s));
}
void recursive_directory_iterator::__pop(error_code* ec)
@ -331,7 +331,7 @@ void recursive_directory_iterator::__advance(error_code* ec) {
const directory_iterator end_it;
auto& stack = __imp_->__stack_;
std::error_code m_ec;
error_code m_ec;
while (stack.size() > 0) {
if (stack.top().advance(m_ec))
return;
@ -341,7 +341,7 @@ void recursive_directory_iterator::__advance(error_code* ec) {
}
if (m_ec) {
path root = std::move(stack.top().__root_);
path root = move(stack.top().__root_);
__imp_.reset();
err.report(m_ec, "at root \"%s\"", root);
} else {
@ -357,7 +357,7 @@ bool recursive_directory_iterator::__try_recursion(error_code *ec) {
auto& curr_it = __imp_->__stack_.top();
bool skip_rec = false;
std::error_code m_ec;
error_code m_ec;
if (!rec_sym) {
file_status st(curr_it.__entry_.__get_sym_ft(&m_ec));
if (m_ec && status_known(st))
@ -375,7 +375,7 @@ bool recursive_directory_iterator::__try_recursion(error_code *ec) {
if (!skip_rec) {
__dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec);
if (new_it.good()) {
__imp_->__stack_.push(_VSTD::move(new_it));
__imp_->__stack_.push(move(new_it));
return true;
}
}
@ -385,7 +385,7 @@ bool recursive_directory_iterator::__try_recursion(error_code *ec) {
if (m_ec.value() == EACCES && allow_eacess) {
if (ec) ec->clear();
} else {
path at_ent = std::move(curr_it.__entry_.__p_);
path at_ent = move(curr_it.__entry_.__p_);
__imp_.reset();
err.report(m_ec, "attempting recursion into \"%s\"", at_ent);
}

26
libcxx/src/experimental/filesystem/filesystem_common.h
View File

@ -67,7 +67,7 @@ _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FILESYSTEM
namespace detail {
namespace {
static std::string format_string_imp(const char* msg, ...) {
static string format_string_imp(const char* msg, ...) {
// we might need a second shot at this, so pre-emptivly make a copy
struct GuardVAList {
va_list& target;
@ -91,24 +91,24 @@ static std::string format_string_imp(const char* msg, ...) {
va_copy(args_cp, args);
GuardVAList args_copy_guard(args_cp);
std::array<char, 256> local_buff;
std::size_t size = local_buff.size();
array<char, 256> local_buff;
size_t size = local_buff.size();
auto ret = ::vsnprintf(local_buff.data(), size, msg, args_cp);
args_copy_guard.clear();
// handle empty expansion
if (ret == 0)
return std::string{};
if (static_cast<std::size_t>(ret) < size)
return std::string(local_buff.data());
return string{};
if (static_cast<size_t>(ret) < size)
return string(local_buff.data());
// we did not provide a long enough buffer on our first attempt.
// add 1 to size to account for null-byte in size cast to prevent overflow
size = static_cast<std::size_t>(ret) + 1;
auto buff_ptr = std::unique_ptr<char[]>(new char[size]);
size = static_cast<size_t>(ret) + 1;
auto buff_ptr = unique_ptr<char[]>(new char[size]);
ret = ::vsnprintf(buff_ptr.get(), size, msg, args);
return std::string(buff_ptr.get());
return string(buff_ptr.get());
}
const char* unwrap(string const& s) { return s.c_str(); }
@ -120,13 +120,13 @@ Arg const& unwrap(Arg const& a) {
}
template <class... Args>
std::string format_string(const char* fmt, Args const&... args) {
string format_string(const char* fmt, Args const&... args) {
return format_string_imp(fmt, unwrap(args)...);
}
std::error_code capture_errno() {
error_code capture_errno() {
_LIBCPP_ASSERT(errno, "Expected errno to be non-zero");
return std::error_code(errno, std::generic_category());
return error_code(errno, generic_category());
}
template <class T>
@ -375,7 +375,7 @@ using TimeStructArray = TimeStruct[2];
#endif
bool SetFileTimes(const path& p, TimeStructArray const& TS,
std::error_code& ec) {
error_code& ec) {
#if !defined(_LIBCXX_USE_UTIMENSAT)
if (::utimes(p.c_str(), TS) == -1)
#else

166
libcxx/src/experimental/filesystem/operations.cpp
View File

@ -330,7 +330,7 @@ struct FileDescriptor {
bool status_known() const { return _VSTD_FS::status_known(m_status); }
file_status refresh_status(std::error_code& ec);
file_status refresh_status(error_code& ec);
void close() noexcept {
if (fd != -1)
@ -363,9 +363,9 @@ perms posix_get_perms(const struct ::stat& st) noexcept {
return static_cast< ::mode_t>(prms & perms::mask);
}
file_status create_file_status(std::error_code& m_ec, path const& p,
file_status create_file_status(error_code& m_ec, path const& p,
const struct ::stat& path_stat,
std::error_code* ec) {
error_code* ec) {
if (ec)
*ec = m_ec;
if (m_ec && (m_ec.value() == ENOENT || m_ec.value() == ENOTDIR)) {
@ -401,33 +401,33 @@ file_status create_file_status(std::error_code& m_ec, path const& p,
}
file_status posix_stat(path const& p, struct ::stat& path_stat,
std::error_code* ec) {
std::error_code m_ec;
error_code* ec) {
error_code m_ec;
if (::stat(p.c_str(), &path_stat) == -1)
m_ec = detail::capture_errno();
return create_file_status(m_ec, p, path_stat, ec);
}
file_status posix_stat(path const& p, std::error_code* ec) {
file_status posix_stat(path const& p, error_code* ec) {
struct ::stat path_stat;
return posix_stat(p, path_stat, ec);
}
file_status posix_lstat(path const& p, struct ::stat& path_stat,
std::error_code* ec) {
std::error_code m_ec;
error_code* ec) {
error_code m_ec;
if (::lstat(p.c_str(), &path_stat) == -1)
m_ec = detail::capture_errno();
return create_file_status(m_ec, p, path_stat, ec);
}
file_status posix_lstat(path const& p, std::error_code* ec) {
file_status posix_lstat(path const& p, error_code* ec) {
struct ::stat path_stat;
return posix_lstat(p, path_stat, ec);
}
bool posix_ftruncate(const FileDescriptor& fd, size_t to_size,
std::error_code& ec) {
error_code& ec) {
if (::ftruncate(fd.fd, to_size) == -1) {
ec = capture_errno();
return false;
@ -449,11 +449,11 @@ bool stat_equivalent(const StatT& st1, const StatT& st2) {
return (st1.st_dev == st2.st_dev && st1.st_ino == st2.st_ino);
}
file_status FileDescriptor::refresh_status(std::error_code& ec) {
file_status FileDescriptor::refresh_status(error_code& ec) {
// FD must be open and good.
m_status = file_status{};
m_stat = {};
std::error_code m_ec;
error_code m_ec;
if (::fstat(fd, &m_stat) == -1)
m_ec = capture_errno();
m_status = create_file_status(m_ec, name, m_stat, &ec);
@ -486,7 +486,7 @@ void filesystem_error::__create_what(int __num_paths) {
}();
}
static path __do_absolute(const path& p, path *cwd, std::error_code *ec) {
static path __do_absolute(const path& p, path *cwd, error_code *ec) {
if (ec) ec->clear();
if (p.is_absolute())
return p;
@ -496,12 +496,12 @@ static path __do_absolute(const path& p, path *cwd, std::error_code *ec) {
return (*cwd) / p;
}
path __absolute(const path& p, std::error_code *ec) {
path __absolute(const path& p, error_code *ec) {
path cwd;
return __do_absolute(p, &cwd, ec);
}
path __canonical(path const & orig_p, std::error_code *ec)
path __canonical(path const & orig_p, error_code *ec)
{
path cwd;
ErrorHandler<path> err("canonical", ec, &orig_p, &cwd);
@ -515,7 +515,7 @@ path __canonical(path const & orig_p, std::error_code *ec)
}
void __copy(const path& from, const path& to, copy_options options,
std::error_code *ec)
error_code *ec)
{
ErrorHandler<void> err("copy", ec, &from, &to);
@ -524,7 +524,7 @@ void __copy(const path& from, const path& to, copy_options options,
const bool sym_status2 = bool(options & copy_options::copy_symlinks);
std::error_code m_ec1;
error_code m_ec1;
struct ::stat f_st = {};
const file_status f = sym_status || sym_status2
? detail::posix_lstat(from, f_st, &m_ec1)
@ -588,7 +588,7 @@ void __copy(const path& from, const path& to, copy_options options,
directory_iterator it = ec ? directory_iterator(from, *ec)
: directory_iterator(from);
if (ec && *ec) { return; }
std::error_code m_ec2;
error_code m_ec2;
for (; it != directory_iterator(); it.increment(m_ec2)) {
if (m_ec2) {
return err.report(m_ec2);
@ -651,27 +651,27 @@ bool copy_file_impl_copyfile(FileDescriptor& read_fd, FileDescriptor& write_fd,
__attribute__((unused)) bool copy_file_impl_default(FileDescriptor& read_fd,
FileDescriptor& write_fd,
error_code& ec) {
std::ifstream in;
in.__open(read_fd.fd, std::ios::binary);
ifstream in;
in.__open(read_fd.fd, ios::binary);
if (!in.is_open()) {
// This assumes that __open didn't reset the error code.
ec = capture_errno();
return false;
}
std::ofstream out;
out.__open(write_fd.fd, std::ios::binary);
ofstream out;
out.__open(write_fd.fd, ios::binary);
if (!out.is_open()) {
ec = capture_errno();
return false;
}
if (in.good() && out.good()) {
using InIt = std::istreambuf_iterator<char>;
using OutIt = std::ostreambuf_iterator<char>;
using InIt = istreambuf_iterator<char>;
using OutIt = ostreambuf_iterator<char>;
InIt bin(in);
InIt ein;
OutIt bout(out);
std::copy(bin, ein, bout);
copy(bin, ein, bout);
}
if (out.fail() || in.fail()) {
ec = make_error_code(errc::io_error);
@ -696,12 +696,12 @@ bool copy_file_impl(FileDescriptor& from, FileDescriptor& to, error_code& ec) {
} // namespace detail
bool __copy_file(const path& from, const path& to, copy_options options,
std::error_code *ec)
error_code *ec)
{
using detail::FileDescriptor;
ErrorHandler<bool> err("copy_file", ec, &to, &from);
std::error_code m_ec;
error_code m_ec;
FileDescriptor from_fd =
FileDescriptor::create_with_status(&from, m_ec, O_RDONLY | O_NONBLOCK);
if (m_ec)
@ -786,7 +786,7 @@ bool __copy_file(const path& from, const path& to, copy_options options,
}
void __copy_symlink(const path& existing_symlink, const path& new_symlink,
std::error_code *ec)
error_code *ec)
{
const path real_path(__read_symlink(existing_symlink, ec));
if (ec && *ec) { return; }
@ -796,11 +796,11 @@ void __copy_symlink(const path& existing_symlink, const path& new_symlink,
__create_symlink(real_path, new_symlink, ec);
}
bool __create_directories(const path& p, std::error_code *ec)
bool __create_directories(const path& p, error_code *ec)
{
ErrorHandler<bool> err("create_directories", ec, &p);
std::error_code m_ec;
error_code m_ec;
auto const st = detail::posix_stat(p, &m_ec);
if (!status_known(st))
return err.report(m_ec);
@ -824,7 +824,7 @@ bool __create_directories(const path& p, std::error_code *ec)
return __create_directory(p, ec);
}
bool __create_directory(const path& p, std::error_code *ec)
bool __create_directory(const path& p, error_code *ec)
{
ErrorHandler<bool> err("create_directory", ec, &p);
@ -836,12 +836,12 @@ bool __create_directory(const path& p, std::error_code *ec)
}
bool __create_directory(path const & p, path const & attributes,
std::error_code *ec)
error_code *ec)
{
ErrorHandler<bool> err("create_directory", ec, &p, &attributes);
StatT attr_stat;
std::error_code mec;
error_code mec;
auto st = detail::posix_stat(attributes, attr_stat, &mec);
if (!status_known(st))
return err.report(mec);
@ -854,31 +854,31 @@ bool __create_directory(path const & p, path const & attributes,
}
void __create_directory_symlink(path const& from, path const& to,
std::error_code* ec) {
error_code* ec) {
ErrorHandler<void> err("create_directory_symlink", ec, &from, &to);
if (::symlink(from.c_str(), to.c_str()) != 0)
return err.report(capture_errno());
}
void __create_hard_link(const path& from, const path& to, std::error_code *ec){
void __create_hard_link(const path& from, const path& to, error_code *ec){
ErrorHandler<void> err("create_hard_link", ec, &from, &to);
if (::link(from.c_str(), to.c_str()) == -1)
return err.report(capture_errno());
}
void __create_symlink(path const & from, path const & to, std::error_code *ec) {
void __create_symlink(path const & from, path const & to, error_code *ec) {
ErrorHandler<void> err("create_symlink", ec, &from, &to);
if (::symlink(from.c_str(), to.c_str()) == -1)
return err.report(capture_errno());
}
path __current_path(std::error_code *ec) {
path __current_path(error_code *ec) {
ErrorHandler<path> err("current_path", ec);
auto size = ::pathconf(".", _PC_PATH_MAX);
_LIBCPP_ASSERT(size >= 0, "pathconf returned a 0 as max size");
auto buff = std::unique_ptr<char[]>(new char[size + 1]);
auto buff = unique_ptr<char[]>(new char[size + 1]);
char* ret;
if ((ret = ::getcwd(buff.get(), static_cast<size_t>(size))) == nullptr)
return err.report(capture_errno(), "call to getcwd failed");
@ -886,17 +886,17 @@ path __current_path(std::error_code *ec) {
return {buff.get()};
}
void __current_path(const path& p, std::error_code *ec) {
void __current_path(const path& p, error_code *ec) {
ErrorHandler<void> err("current_path", ec, &p);
if (::chdir(p.c_str()) == -1)
err.report(capture_errno());
}
bool __equivalent(const path& p1, const path& p2, std::error_code *ec)
bool __equivalent(const path& p1, const path& p2, error_code *ec)
{
ErrorHandler<bool> err("equivalent", ec, &p1, &p2);
std::error_code ec1, ec2;
error_code ec1, ec2;
StatT st1 = {}, st2 = {};
auto s1 = detail::posix_stat(p1.native(), st1, &ec1);
if (!exists(s1))
@ -909,11 +909,11 @@ bool __equivalent(const path& p1, const path& p2, std::error_code *ec)
}
std::uintmax_t __file_size(const path& p, std::error_code *ec)
uintmax_t __file_size(const path& p, error_code *ec)
{
ErrorHandler<uintmax_t> err("file_size", ec, &p);
std::error_code m_ec;
error_code m_ec;
struct ::stat st;
file_status fst = detail::posix_stat(p, st, &m_ec);
if (!exists(fst) || !is_regular_file(fst)) {
@ -924,27 +924,27 @@ std::uintmax_t __file_size(const path& p, std::error_code *ec)
return err.report(m_ec);
}
// is_regular_file(p) == true
return static_cast<std::uintmax_t>(st.st_size);
return static_cast<uintmax_t>(st.st_size);
}
std::uintmax_t __hard_link_count(const path& p, std::error_code *ec)
uintmax_t __hard_link_count(const path& p, error_code *ec)
{
ErrorHandler<uintmax_t> err("hard_link_count", ec, &p);
std::error_code m_ec;
error_code m_ec;
StatT st;
detail::posix_stat(p, st, &m_ec);
if (m_ec)
return err.report(m_ec);
return static_cast<std::uintmax_t>(st.st_nlink);
return static_cast<uintmax_t>(st.st_nlink);
}
bool __fs_is_empty(const path& p, std::error_code *ec)
bool __fs_is_empty(const path& p, error_code *ec)
{
ErrorHandler<bool> err("is_empty", ec, &p);
std::error_code m_ec;
error_code m_ec;
StatT pst;
auto st = detail::posix_stat(p, pst, &m_ec);
if (m_ec)
@ -957,7 +957,7 @@ bool __fs_is_empty(const path& p, std::error_code *ec)
return false;
return it == directory_iterator{};
} else if (is_regular_file(st))
return static_cast<std::uintmax_t>(pst.st_size) == 0;
return static_cast<uintmax_t>(pst.st_size) == 0;
_LIBCPP_UNREACHABLE();
}
@ -974,12 +974,12 @@ static file_time_type __extract_last_write_time(const path& p, const StatT& st,
return FSTime::convert_timespec(ts);
}
file_time_type __last_write_time(const path& p, std::error_code *ec)
file_time_type __last_write_time(const path& p, error_code *ec)
{
using namespace ::std::chrono;
using namespace chrono;
ErrorHandler<file_time_type> err("last_write_time", ec, &p);
std::error_code m_ec;
error_code m_ec;
StatT st;
detail::posix_stat(p, st, &m_ec);
if (m_ec)
@ -988,14 +988,14 @@ file_time_type __last_write_time(const path& p, std::error_code *ec)
}
void __last_write_time(const path& p, file_time_type new_time,
std::error_code *ec)
error_code *ec)
{
using namespace std::chrono;
using namespace chrono;
using namespace detail;
ErrorHandler<void> err("last_write_time", ec, &p);
std::error_code m_ec;
error_code m_ec;
TimeStructArray tbuf;
#if !defined(_LIBCXX_USE_UTIMENSAT)
// This implementation has a race condition between determining the
@ -1020,7 +1020,7 @@ void __last_write_time(const path& p, file_time_type new_time,
void __permissions(const path& p, perms prms, perm_options opts,
std::error_code *ec)
error_code *ec)
{
ErrorHandler<void> err("permissions", ec, &p);
@ -1036,7 +1036,7 @@ void __permissions(const path& p, perms prms, perm_options opts,
bool set_sym_perms = false;
prms &= perms::mask;
if (!resolve_symlinks || (add_perms || remove_perms)) {
std::error_code m_ec;
error_code m_ec;
file_status st = resolve_symlinks ? detail::posix_stat(p, &m_ec)
: detail::posix_lstat(p, &m_ec);
set_sym_perms = is_symlink(st);
@ -1066,11 +1066,11 @@ void __permissions(const path& p, perms prms, perm_options opts,
}
path __read_symlink(const path& p, std::error_code *ec) {
path __read_symlink(const path& p, error_code *ec) {
ErrorHandler<path> err("read_symlink", ec, &p);
char buff[PATH_MAX + 1];
std::error_code m_ec;
error_code m_ec;
::ssize_t ret;
if ((ret = ::readlink(p.c_str(), buff, PATH_MAX)) == -1) {
return err.report(capture_errno());
@ -1082,7 +1082,7 @@ path __read_symlink(const path& p, std::error_code *ec) {
}
bool __remove(const path& p, std::error_code *ec) {
bool __remove(const path& p, error_code *ec) {
ErrorHandler<bool> err("remove", ec, &p);
if (::remove(p.c_str()) == -1) {
if (errno != ENOENT)
@ -1094,12 +1094,12 @@ bool __remove(const path& p, std::error_code *ec) {
namespace {
std::uintmax_t remove_all_impl(path const & p, std::error_code& ec)
uintmax_t remove_all_impl(path const & p, error_code& ec)
{
const auto npos = static_cast<std::uintmax_t>(-1);
const auto npos = static_cast<uintmax_t>(-1);
const file_status st = __symlink_status(p, &ec);
if (ec) return npos;
std::uintmax_t count = 1;
uintmax_t count = 1;
if (is_directory(st)) {
for (directory_iterator it(p, ec); !ec && it != directory_iterator();
it.increment(ec)) {
@ -1115,10 +1115,10 @@ std::uintmax_t remove_all_impl(path const & p, std::error_code& ec)
} // end namespace
std::uintmax_t __remove_all(const path& p, std::error_code *ec) {
uintmax_t __remove_all(const path& p, error_code *ec) {
ErrorHandler<uintmax_t> err("remove_all", ec, &p);
std::error_code mec;
error_code mec;
auto count = remove_all_impl(p, mec);
if (mec) {
if (mec == errc::no_such_file_or_directory)
@ -1128,32 +1128,32 @@ std::uintmax_t __remove_all(const path& p, std::error_code *ec) {
return count;
}
void __rename(const path& from, const path& to, std::error_code *ec) {
void __rename(const path& from, const path& to, error_code *ec) {
ErrorHandler<void> err("rename", ec, &from, &to);
if (::rename(from.c_str(), to.c_str()) == -1)
err.report(capture_errno());
}
void __resize_file(const path& p, std::uintmax_t size, std::error_code *ec) {
void __resize_file(const path& p, uintmax_t size, error_code *ec) {
ErrorHandler<void> err("resize_file", ec, &p);
if (::truncate(p.c_str(), static_cast< ::off_t>(size)) == -1)
return err.report(capture_errno());
}
space_info __space(const path& p, std::error_code *ec) {
space_info __space(const path& p, error_code *ec) {
ErrorHandler<void> err("space", ec, &p);
space_info si;
struct statvfs m_svfs = {};
if (::statvfs(p.c_str(), &m_svfs) == -1) {
err.report(capture_errno());
si.capacity = si.free = si.available = static_cast<std::uintmax_t>(-1);
si.capacity = si.free = si.available = static_cast<uintmax_t>(-1);
return si;
}
// Multiply with overflow checking.
auto do_mult = [&](std::uintmax_t& out, std::uintmax_t other) {
auto do_mult = [&](uintmax_t& out, uintmax_t other) {
out = other * m_svfs.f_frsize;
if (other == 0 || out / other != m_svfs.f_frsize)
out = static_cast<std::uintmax_t>(-1);
out = static_cast<uintmax_t>(-1);
};
do_mult(si.capacity, m_svfs.f_blocks);
do_mult(si.free, m_svfs.f_bfree);
@ -1161,28 +1161,28 @@ space_info __space(const path& p, std::error_code *ec) {
return si;
}
file_status __status(const path& p, std::error_code *ec) {
file_status __status(const path& p, error_code *ec) {
return detail::posix_stat(p, ec);
}
file_status __symlink_status(const path& p, std::error_code *ec) {
file_status __symlink_status(const path& p, error_code *ec) {
return detail::posix_lstat(p, ec);
}
path __temp_directory_path(std::error_code* ec) {
path __temp_directory_path(error_code* ec) {
ErrorHandler<path> err("temp_directory_path", ec);
const char* env_paths[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
const char* ret = nullptr;
for (auto& ep : env_paths)
if ((ret = std::getenv(ep)))
if ((ret = getenv(ep)))
break;
if (ret == nullptr)
ret = "/tmp";
path p(ret);
std::error_code m_ec;
error_code m_ec;
file_status st = detail::posix_stat(p, &m_ec);
if (!status_known(st))
return err.report(m_ec, "cannot access path \"%s\"", p);
@ -1195,7 +1195,7 @@ path __temp_directory_path(std::error_code* ec) {
}
path __weakly_canonical(const path& p, std::error_code *ec) {
path __weakly_canonical(const path& p, error_code *ec) {
ErrorHandler<path> err("weakly_canonical", ec, &p);
if (p.empty())
@ -1206,11 +1206,11 @@ path __weakly_canonical(const path& p, std::error_code *ec) {
tmp.__reserve(p.native().size());
auto PP = PathParser::CreateEnd(p.native());
--PP;
std::vector<string_view_t> DNEParts;
vector<string_view_t> DNEParts;
while (PP.State != PathParser::PS_BeforeBegin) {
tmp.assign(createView(p.native().data(), &PP.RawEntry.back()));
std::error_code m_ec;
error_code m_ec;
file_status st = __status(tmp, &m_ec);
if (!status_known(st)) {
return err.report(m_ec);
@ -1376,8 +1376,8 @@ path path::lexically_normal() const {
if (__pn_.empty())
return *this;
using PartKindPair = std::pair<string_view_t, PathPartKind>;
std::vector<PartKindPair> Parts;
using PartKindPair = pair<string_view_t, PathPartKind>;
vector<PartKindPair> Parts;
// Guess as to how many elements the path has to avoid reallocating.
Parts.reserve(32);
@ -1533,7 +1533,7 @@ int path::__compare(string_view_t __s) const {
size_t hash_value(const path& __p) noexcept {
auto PP = PathParser::CreateBegin(__p.native());
size_t hash_value = 0;
std::hash<string_view_t> hasher;
hash<string_view_t> hasher;
while (PP) {
hash_value = __hash_combine(hash_value, hasher(*PP));
++PP;