[libcxx] r337684 - Cleanup name qualification in the filesystem internals.
Eric Fiselier via cfe-commits
cfe-commits at lists.llvm.org
Mon Jul 23 04:46:47 PDT 2018
Author: ericwf
Date: Mon Jul 23 04:46:47 2018
New Revision: 337684
URL: http://llvm.org/viewvc/llvm-project?rev=337684&view=rev
Log:
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
Modified:
libcxx/trunk/src/experimental/filesystem/directory_iterator.cpp
libcxx/trunk/src/experimental/filesystem/filesystem_common.h
libcxx/trunk/src/experimental/filesystem/operations.cpp
Modified: libcxx/trunk/src/experimental/filesystem/directory_iterator.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/src/experimental/filesystem/directory_iterator.cpp?rev=337684&r1=337683&r2=337684&view=diff
==============================================================================
--- libcxx/trunk/src/experimental/filesystem/directory_iterator.cpp (original)
+++ libcxx/trunk/src/experimental/filesystem/directory_iterator.cpp Mon Jul 23 04:46:47 2018
@@ -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(c
{
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::
_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_
{
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::__adv
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::__adv
}
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
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
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
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);
}
Modified: libcxx/trunk/src/experimental/filesystem/filesystem_common.h
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/src/experimental/filesystem/filesystem_common.h?rev=337684&r1=337683&r2=337684&view=diff
==============================================================================
--- libcxx/trunk/src/experimental/filesystem/filesystem_common.h (original)
+++ libcxx/trunk/src/experimental/filesystem/filesystem_common.h Mon Jul 23 04:46:47 2018
@@ -67,7 +67,7 @@ _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_FIL
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(con
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
Modified: libcxx/trunk/src/experimental/filesystem/operations.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/src/experimental/filesystem/operations.cpp?rev=337684&r1=337683&r2=337684&view=diff
==============================================================================
--- libcxx/trunk/src/experimental/filesystem/operations.cpp (original)
+++ libcxx/trunk/src/experimental/filesystem/operations.cpp Mon Jul 23 04:46:47 2018
@@ -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 ::sta
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::erro
}
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, c
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
}();
}
-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,
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, st
}
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
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
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(FileDescrip
__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
} // 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
}
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
__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,
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, s
}
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,
}
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
}
-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
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::e
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_wri
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 p
}
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, fi
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
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
}
-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::
}
-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_
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 cons
} // 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&
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::e
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_co
}
-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, s
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) c
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;
More information about the cfe-commits
mailing list