Restoring authorship annotation for Andrey Khalyavin <halyavin@gmail.com>. Commit 2 of 2.

1 files changed, 399 insertions, 399 deletions

diff --git a/contrib/libs/cxxsupp/libcxx/src/filesystem/directory_iterator.cpp b/contrib/libs/cxxsupp/libcxx/src/filesystem/directory_iterator.cpp
index 764acfb256..a098dd163b 100644
--- a/contrib/libs/cxxsupp/libcxx/src/filesystem/directory_iterator.cpp
+++ b/contrib/libs/cxxsupp/libcxx/src/filesystem/directory_iterator.cpp
@@ -1,158 +1,158 @@
-//===------------------ directory_iterator.cpp ----------------------------===// 
-// 
+//===------------------ directory_iterator.cpp ----------------------------===//
+//
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-// 
-//===----------------------------------------------------------------------===// 
- 
-#include "filesystem" 
-#include "__config" 
-#if defined(_LIBCPP_WIN32API) 
-#define WIN32_LEAN_AND_MEAN 
-#define NOMINMAX 
-#include <windows.h> 
-#else 
-#include <dirent.h> 
-#endif 
-#include <errno.h> 
- 
-#include "filesystem_common.h" 
- 
-_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM 
- 
-namespace detail { 
-namespace { 
- 
-#if !defined(_LIBCPP_WIN32API) 
+//
+//===----------------------------------------------------------------------===//
+
+#include "filesystem"
+#include "__config"
+#if defined(_LIBCPP_WIN32API)
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+#include <windows.h>
+#else
+#include <dirent.h>
+#endif
+#include <errno.h>
+
+#include "filesystem_common.h"
+
+_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
+
+namespace detail {
+namespace {
+
+#if !defined(_LIBCPP_WIN32API)
 
 #if defined(DT_BLK)
-template <class DirEntT, class = decltype(DirEntT::d_type)> 
-static file_type get_file_type(DirEntT* ent, int) { 
-  switch (ent->d_type) { 
-  case DT_BLK: 
-    return file_type::block; 
-  case DT_CHR: 
-    return file_type::character; 
-  case DT_DIR: 
-    return file_type::directory; 
-  case DT_FIFO: 
-    return file_type::fifo; 
-  case DT_LNK: 
-    return file_type::symlink; 
-  case DT_REG: 
-    return file_type::regular; 
-  case DT_SOCK: 
-    return file_type::socket; 
-  // Unlike in lstat, hitting "unknown" here simply means that the underlying 
-  // filesystem doesn't support d_type. Report is as 'none' so we correctly 
-  // set the cache to empty. 
-  case DT_UNKNOWN: 
-    break; 
-  } 
-  return file_type::none; 
-} 
+template <class DirEntT, class = decltype(DirEntT::d_type)>
+static file_type get_file_type(DirEntT* ent, int) {
+  switch (ent->d_type) {
+  case DT_BLK:
+    return file_type::block;
+  case DT_CHR:
+    return file_type::character;
+  case DT_DIR:
+    return file_type::directory;
+  case DT_FIFO:
+    return file_type::fifo;
+  case DT_LNK:
+    return file_type::symlink;
+  case DT_REG:
+    return file_type::regular;
+  case DT_SOCK:
+    return file_type::socket;
+  // Unlike in lstat, hitting "unknown" here simply means that the underlying
+  // filesystem doesn't support d_type. Report is as 'none' so we correctly
+  // set the cache to empty.
+  case DT_UNKNOWN:
+    break;
+  }
+  return file_type::none;
+}
 #endif // defined(DT_BLK)
- 
-template <class DirEntT> 
+
+template <class DirEntT>
 static file_type get_file_type(DirEntT*, long) {
-  return file_type::none; 
-} 
- 
-static pair<string_view, file_type> posix_readdir(DIR* dir_stream, 
-                                                  error_code& ec) { 
-  struct dirent* dir_entry_ptr = nullptr; 
-  errno = 0; // zero errno in order to detect errors 
-  ec.clear(); 
-  if ((dir_entry_ptr = ::readdir(dir_stream)) == nullptr) { 
-    if (errno) 
-      ec = capture_errno(); 
-    return {}; 
-  } else { 
-    return {dir_entry_ptr->d_name, get_file_type(dir_entry_ptr, 0)}; 
-  } 
-} 
-#else 
-// defined(_LIBCPP_WIN32API) 
- 
-static file_type get_file_type(const WIN32_FIND_DATAW& data) { 
-  if (data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT && 
-      data.dwReserved0 == IO_REPARSE_TAG_SYMLINK) 
-    return file_type::symlink; 
-  if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) 
-    return file_type::directory; 
-  return file_type::regular; 
-} 
-static uintmax_t get_file_size(const WIN32_FIND_DATAW& data) { 
-  return (static_cast<uint64_t>(data.nFileSizeHigh) << 32) + data.nFileSizeLow; 
-} 
-static file_time_type get_write_time(const WIN32_FIND_DATAW& data) { 
-  ULARGE_INTEGER tmp; 
-  const FILETIME& time = data.ftLastWriteTime; 
-  tmp.u.LowPart = time.dwLowDateTime; 
-  tmp.u.HighPart = time.dwHighDateTime; 
-  return file_time_type(file_time_type::duration(tmp.QuadPart)); 
-} 
- 
-#endif 
- 
-} // namespace 
-} // namespace detail 
- 
-using detail::ErrorHandler; 
- 
-#if defined(_LIBCPP_WIN32API) 
-class __dir_stream { 
-public: 
-  __dir_stream() = delete; 
-  __dir_stream& operator=(const __dir_stream&) = delete; 
- 
-  __dir_stream(__dir_stream&& __ds) noexcept : __stream_(__ds.__stream_), 
-                                               __root_(move(__ds.__root_)), 
-                                               __entry_(move(__ds.__entry_)) { 
-    __ds.__stream_ = INVALID_HANDLE_VALUE; 
-  } 
- 
-  __dir_stream(const path& root, directory_options opts, error_code& ec) 
-      : __stream_(INVALID_HANDLE_VALUE), __root_(root) { 
-    if (root.native().empty()) { 
-      ec = make_error_code(errc::no_such_file_or_directory); 
-      return; 
-    } 
-    __stream_ = ::FindFirstFileW((root / "*").c_str(), &__data_); 
-    if (__stream_ == INVALID_HANDLE_VALUE) { 
-      ec = detail::make_windows_error(GetLastError()); 
-      const bool ignore_permission_denied = 
-          bool(opts & directory_options::skip_permission_denied); 
-      if (ignore_permission_denied && 
-          ec.value() == static_cast<int>(errc::permission_denied)) 
-        ec.clear(); 
-      return; 
-    } 
-    if (!assign()) 
-      advance(ec); 
-  } 
- 
-  ~__dir_stream() noexcept { 
-    if (__stream_ == INVALID_HANDLE_VALUE) 
-      return; 
-    close(); 
-  } 
- 
-  bool good() const noexcept { return __stream_ != INVALID_HANDLE_VALUE; } 
- 
-  bool advance(error_code& ec) { 
-    while (::FindNextFileW(__stream_, &__data_)) { 
-      if (assign()) 
-        return true; 
-    } 
-    close(); 
-    return false; 
-  } 
- 
-  bool assign() { 
-    if (!wcscmp(__data_.cFileName, L".") || !wcscmp(__data_.cFileName, L"..")) 
-      return false; 
+  return file_type::none;
+}
+
+static pair<string_view, file_type> posix_readdir(DIR* dir_stream,
+                                                  error_code& ec) {
+  struct dirent* dir_entry_ptr = nullptr;
+  errno = 0; // zero errno in order to detect errors
+  ec.clear();
+  if ((dir_entry_ptr = ::readdir(dir_stream)) == nullptr) {
+    if (errno)
+      ec = capture_errno();
+    return {};
+  } else {
+    return {dir_entry_ptr->d_name, get_file_type(dir_entry_ptr, 0)};
+  }
+}
+#else
+// defined(_LIBCPP_WIN32API)
+
+static file_type get_file_type(const WIN32_FIND_DATAW& data) {
+  if (data.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT &&
+      data.dwReserved0 == IO_REPARSE_TAG_SYMLINK)
+    return file_type::symlink;
+  if (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+    return file_type::directory;
+  return file_type::regular;
+}
+static uintmax_t get_file_size(const WIN32_FIND_DATAW& data) {
+  return (static_cast<uint64_t>(data.nFileSizeHigh) << 32) + data.nFileSizeLow;
+}
+static file_time_type get_write_time(const WIN32_FIND_DATAW& data) {
+  ULARGE_INTEGER tmp;
+  const FILETIME& time = data.ftLastWriteTime;
+  tmp.u.LowPart = time.dwLowDateTime;
+  tmp.u.HighPart = time.dwHighDateTime;
+  return file_time_type(file_time_type::duration(tmp.QuadPart));
+}
+
+#endif
+
+} // namespace
+} // namespace detail
+
+using detail::ErrorHandler;
+
+#if defined(_LIBCPP_WIN32API)
+class __dir_stream {
+public:
+  __dir_stream() = delete;
+  __dir_stream& operator=(const __dir_stream&) = delete;
+
+  __dir_stream(__dir_stream&& __ds) noexcept : __stream_(__ds.__stream_),
+                                               __root_(move(__ds.__root_)),
+                                               __entry_(move(__ds.__entry_)) {
+    __ds.__stream_ = INVALID_HANDLE_VALUE;
+  }
+
+  __dir_stream(const path& root, directory_options opts, error_code& ec)
+      : __stream_(INVALID_HANDLE_VALUE), __root_(root) {
+    if (root.native().empty()) {
+      ec = make_error_code(errc::no_such_file_or_directory);
+      return;
+    }
+    __stream_ = ::FindFirstFileW((root / "*").c_str(), &__data_);
+    if (__stream_ == INVALID_HANDLE_VALUE) {
+      ec = detail::make_windows_error(GetLastError());
+      const bool ignore_permission_denied =
+          bool(opts & directory_options::skip_permission_denied);
+      if (ignore_permission_denied &&
+          ec.value() == static_cast<int>(errc::permission_denied))
+        ec.clear();
+      return;
+    }
+    if (!assign())
+      advance(ec);
+  }
+
+  ~__dir_stream() noexcept {
+    if (__stream_ == INVALID_HANDLE_VALUE)
+      return;
+    close();
+  }
+
+  bool good() const noexcept { return __stream_ != INVALID_HANDLE_VALUE; }
+
+  bool advance(error_code& ec) {
+    while (::FindNextFileW(__stream_, &__data_)) {
+      if (assign())
+        return true;
+    }
+    close();
+    return false;
+  }
+
+  bool assign() {
+    if (!wcscmp(__data_.cFileName, L".") || !wcscmp(__data_.cFileName, L".."))
+      return false;
     // FIXME: Cache more of this
     //directory_entry::__cached_data cdata;
     //cdata.__type_ = get_file_type(__data_);
@@ -160,256 +160,256 @@ public:
     //cdata.__write_time_ = get_write_time(__data_);
     __entry_.__assign_iter_entry(
         __root_ / __data_.cFileName,
-        directory_entry::__create_iter_result(detail::get_file_type(__data_))); 
+        directory_entry::__create_iter_result(detail::get_file_type(__data_)));
     return true;
   }
- 
-private: 
-  error_code close() noexcept { 
-    error_code ec; 
-    if (!::FindClose(__stream_)) 
-      ec = detail::make_windows_error(GetLastError()); 
-    __stream_ = INVALID_HANDLE_VALUE; 
-    return ec; 
-  } 
- 
-  HANDLE __stream_{INVALID_HANDLE_VALUE}; 
-  WIN32_FIND_DATAW __data_; 
- 
-public: 
-  path __root_; 
-  directory_entry __entry_; 
-}; 
-#else 
-class __dir_stream { 
-public: 
-  __dir_stream() = delete; 
-  __dir_stream& operator=(const __dir_stream&) = delete; 
- 
-  __dir_stream(__dir_stream&& other) noexcept : __stream_(other.__stream_), 
-                                                __root_(move(other.__root_)), 
-                                                __entry_(move(other.__entry_)) { 
-    other.__stream_ = nullptr; 
-  } 
- 
-  __dir_stream(const path& root, directory_options opts, error_code& ec) 
-      : __stream_(nullptr), __root_(root) { 
-    if ((__stream_ = ::opendir(root.c_str())) == nullptr) { 
-      ec = detail::capture_errno(); 
-      const bool allow_eacess = 
-          bool(opts & directory_options::skip_permission_denied); 
-      if (allow_eacess && ec.value() == EACCES) 
-        ec.clear(); 
-      return; 
-    } 
-    advance(ec); 
-  } 
- 
-  ~__dir_stream() noexcept { 
-    if (__stream_) 
-      close(); 
-  } 
- 
-  bool good() const noexcept { return __stream_ != nullptr; } 
- 
-  bool advance(error_code& ec) { 
-    while (true) { 
-      auto str_type_pair = detail::posix_readdir(__stream_, ec); 
-      auto& str = str_type_pair.first; 
-      if (str == "." || str == "..") { 
-        continue; 
-      } else if (ec || str.empty()) { 
-        close(); 
-        return false; 
-      } else { 
-        __entry_.__assign_iter_entry( 
-            __root_ / str, 
-            directory_entry::__create_iter_result(str_type_pair.second)); 
-        return true; 
-      } 
-    } 
-  } 
- 
-private: 
-  error_code close() noexcept { 
-    error_code m_ec; 
-    if (::closedir(__stream_) == -1) 
-      m_ec = detail::capture_errno(); 
-    __stream_ = nullptr; 
-    return m_ec; 
-  } 
- 
-  DIR* __stream_{nullptr}; 
- 
-public: 
-  path __root_; 
-  directory_entry __entry_; 
-}; 
-#endif 
- 
-// directory_iterator 
- 
-directory_iterator::directory_iterator(const path& p, error_code* ec, 
-                                       directory_options opts) { 
-  ErrorHandler<void> err("directory_iterator::directory_iterator(...)", ec, &p); 
- 
-  error_code m_ec; 
-  __imp_ = make_shared<__dir_stream>(p, opts, m_ec); 
-  if (ec) 
-    *ec = m_ec; 
-  if (!__imp_->good()) { 
-    __imp_.reset(); 
-    if (m_ec) 
-      err.report(m_ec); 
-  } 
-} 
- 
-directory_iterator& directory_iterator::__increment(error_code* ec) { 
-  _LIBCPP_ASSERT(__imp_, "Attempting to increment an invalid iterator"); 
-  ErrorHandler<void> err("directory_iterator::operator++()", ec); 
- 
-  error_code m_ec; 
-  if (!__imp_->advance(m_ec)) { 
-    path root = move(__imp_->__root_); 
-    __imp_.reset(); 
-    if (m_ec) 
-      err.report(m_ec, "at root " PATH_CSTR_FMT, root.c_str()); 
-  } 
-  return *this; 
-} 
- 
-directory_entry const& directory_iterator::__dereference() const { 
-  _LIBCPP_ASSERT(__imp_, "Attempting to dereference an invalid iterator"); 
-  return __imp_->__entry_; 
-} 
- 
-// recursive_directory_iterator 
- 
-struct recursive_directory_iterator::__shared_imp { 
-  stack<__dir_stream> __stack_; 
-  directory_options __options_; 
-}; 
- 
-recursive_directory_iterator::recursive_directory_iterator( 
-    const path& p, directory_options opt, error_code* ec) 
-    : __imp_(nullptr), __rec_(true) { 
-  ErrorHandler<void> err("recursive_directory_iterator", ec, &p); 
- 
-  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_ = make_shared<__shared_imp>(); 
-  __imp_->__options_ = opt; 
-  __imp_->__stack_.push(move(new_s)); 
-} 
- 
-void recursive_directory_iterator::__pop(error_code* ec) { 
-  _LIBCPP_ASSERT(__imp_, "Popping the end iterator"); 
-  if (ec) 
-    ec->clear(); 
-  __imp_->__stack_.pop(); 
-  if (__imp_->__stack_.size() == 0) 
-    __imp_.reset(); 
-  else 
-    __advance(ec); 
-} 
- 
-directory_options recursive_directory_iterator::options() const { 
-  return __imp_->__options_; 
-} 
- 
-int recursive_directory_iterator::depth() const { 
-  return __imp_->__stack_.size() - 1; 
-} 
- 
-const directory_entry& recursive_directory_iterator::__dereference() const { 
-  return __imp_->__stack_.top().__entry_; 
-} 
- 
-recursive_directory_iterator& 
-recursive_directory_iterator::__increment(error_code* ec) { 
-  if (ec) 
-    ec->clear(); 
-  if (recursion_pending()) { 
-    if (__try_recursion(ec) || (ec && *ec)) 
-      return *this; 
-  } 
-  __rec_ = true; 
-  __advance(ec); 
-  return *this; 
-} 
- 
-void recursive_directory_iterator::__advance(error_code* ec) { 
-  ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec); 
- 
-  const directory_iterator end_it; 
-  auto& stack = __imp_->__stack_; 
-  error_code m_ec; 
-  while (stack.size() > 0) { 
-    if (stack.top().advance(m_ec)) 
-      return; 
-    if (m_ec) 
-      break; 
-    stack.pop(); 
-  } 
- 
-  if (m_ec) { 
-    path root = move(stack.top().__root_); 
-    __imp_.reset(); 
-    err.report(m_ec, "at root " PATH_CSTR_FMT, root.c_str()); 
-  } else { 
-    __imp_.reset(); 
-  } 
-} 
- 
-bool recursive_directory_iterator::__try_recursion(error_code* ec) { 
-  ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec); 
- 
-  bool rec_sym = bool(options() & directory_options::follow_directory_symlink); 
- 
-  auto& curr_it = __imp_->__stack_.top(); 
- 
-  bool skip_rec = false; 
-  error_code m_ec; 
-  if (!rec_sym) { 
-    file_status st(curr_it.__entry_.__get_sym_ft(&m_ec)); 
-    if (m_ec && status_known(st)) 
-      m_ec.clear(); 
-    if (m_ec || is_symlink(st) || !is_directory(st)) 
-      skip_rec = true; 
-  } else { 
-    file_status st(curr_it.__entry_.__get_ft(&m_ec)); 
-    if (m_ec && status_known(st)) 
-      m_ec.clear(); 
-    if (m_ec || !is_directory(st)) 
-      skip_rec = true; 
-  } 
- 
-  if (!skip_rec) { 
-    __dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec); 
-    if (new_it.good()) { 
-      __imp_->__stack_.push(move(new_it)); 
-      return true; 
-    } 
-  } 
-  if (m_ec) { 
-    const bool allow_eacess = 
-        bool(__imp_->__options_ & directory_options::skip_permission_denied); 
-    if (m_ec.value() == EACCES && allow_eacess) { 
-      if (ec) 
-        ec->clear(); 
-    } else { 
-      path at_ent = move(curr_it.__entry_.__p_); 
-      __imp_.reset(); 
-      err.report(m_ec, "attempting recursion into " PATH_CSTR_FMT, 
-                 at_ent.c_str()); 
-    } 
-  } 
-  return false; 
-} 
- 
-_LIBCPP_END_NAMESPACE_FILESYSTEM 
+
+private:
+  error_code close() noexcept {
+    error_code ec;
+    if (!::FindClose(__stream_))
+      ec = detail::make_windows_error(GetLastError());
+    __stream_ = INVALID_HANDLE_VALUE;
+    return ec;
+  }
+
+  HANDLE __stream_{INVALID_HANDLE_VALUE};
+  WIN32_FIND_DATAW __data_;
+
+public:
+  path __root_;
+  directory_entry __entry_;
+};
+#else
+class __dir_stream {
+public:
+  __dir_stream() = delete;
+  __dir_stream& operator=(const __dir_stream&) = delete;
+
+  __dir_stream(__dir_stream&& other) noexcept : __stream_(other.__stream_),
+                                                __root_(move(other.__root_)),
+                                                __entry_(move(other.__entry_)) {
+    other.__stream_ = nullptr;
+  }
+
+  __dir_stream(const path& root, directory_options opts, error_code& ec)
+      : __stream_(nullptr), __root_(root) {
+    if ((__stream_ = ::opendir(root.c_str())) == nullptr) {
+      ec = detail::capture_errno();
+      const bool allow_eacess =
+          bool(opts & directory_options::skip_permission_denied);
+      if (allow_eacess && ec.value() == EACCES)
+        ec.clear();
+      return;
+    }
+    advance(ec);
+  }
+
+  ~__dir_stream() noexcept {
+    if (__stream_)
+      close();
+  }
+
+  bool good() const noexcept { return __stream_ != nullptr; }
+
+  bool advance(error_code& ec) {
+    while (true) {
+      auto str_type_pair = detail::posix_readdir(__stream_, ec);
+      auto& str = str_type_pair.first;
+      if (str == "." || str == "..") {
+        continue;
+      } else if (ec || str.empty()) {
+        close();
+        return false;
+      } else {
+        __entry_.__assign_iter_entry(
+            __root_ / str,
+            directory_entry::__create_iter_result(str_type_pair.second));
+        return true;
+      }
+    }
+  }
+
+private:
+  error_code close() noexcept {
+    error_code m_ec;
+    if (::closedir(__stream_) == -1)
+      m_ec = detail::capture_errno();
+    __stream_ = nullptr;
+    return m_ec;
+  }
+
+  DIR* __stream_{nullptr};
+
+public:
+  path __root_;
+  directory_entry __entry_;
+};
+#endif
+
+// directory_iterator
+
+directory_iterator::directory_iterator(const path& p, error_code* ec,
+                                       directory_options opts) {
+  ErrorHandler<void> err("directory_iterator::directory_iterator(...)", ec, &p);
+
+  error_code m_ec;
+  __imp_ = make_shared<__dir_stream>(p, opts, m_ec);
+  if (ec)
+    *ec = m_ec;
+  if (!__imp_->good()) {
+    __imp_.reset();
+    if (m_ec)
+      err.report(m_ec);
+  }
+}
+
+directory_iterator& directory_iterator::__increment(error_code* ec) {
+  _LIBCPP_ASSERT(__imp_, "Attempting to increment an invalid iterator");
+  ErrorHandler<void> err("directory_iterator::operator++()", ec);
+
+  error_code m_ec;
+  if (!__imp_->advance(m_ec)) {
+    path root = move(__imp_->__root_);
+    __imp_.reset();
+    if (m_ec)
+      err.report(m_ec, "at root " PATH_CSTR_FMT, root.c_str());
+  }
+  return *this;
+}
+
+directory_entry const& directory_iterator::__dereference() const {
+  _LIBCPP_ASSERT(__imp_, "Attempting to dereference an invalid iterator");
+  return __imp_->__entry_;
+}
+
+// recursive_directory_iterator
+
+struct recursive_directory_iterator::__shared_imp {
+  stack<__dir_stream> __stack_;
+  directory_options __options_;
+};
+
+recursive_directory_iterator::recursive_directory_iterator(
+    const path& p, directory_options opt, error_code* ec)
+    : __imp_(nullptr), __rec_(true) {
+  ErrorHandler<void> err("recursive_directory_iterator", ec, &p);
+
+  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_ = make_shared<__shared_imp>();
+  __imp_->__options_ = opt;
+  __imp_->__stack_.push(move(new_s));
+}
+
+void recursive_directory_iterator::__pop(error_code* ec) {
+  _LIBCPP_ASSERT(__imp_, "Popping the end iterator");
+  if (ec)
+    ec->clear();
+  __imp_->__stack_.pop();
+  if (__imp_->__stack_.size() == 0)
+    __imp_.reset();
+  else
+    __advance(ec);
+}
+
+directory_options recursive_directory_iterator::options() const {
+  return __imp_->__options_;
+}
+
+int recursive_directory_iterator::depth() const {
+  return __imp_->__stack_.size() - 1;
+}
+
+const directory_entry& recursive_directory_iterator::__dereference() const {
+  return __imp_->__stack_.top().__entry_;
+}
+
+recursive_directory_iterator&
+recursive_directory_iterator::__increment(error_code* ec) {
+  if (ec)
+    ec->clear();
+  if (recursion_pending()) {
+    if (__try_recursion(ec) || (ec && *ec))
+      return *this;
+  }
+  __rec_ = true;
+  __advance(ec);
+  return *this;
+}
+
+void recursive_directory_iterator::__advance(error_code* ec) {
+  ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec);
+
+  const directory_iterator end_it;
+  auto& stack = __imp_->__stack_;
+  error_code m_ec;
+  while (stack.size() > 0) {
+    if (stack.top().advance(m_ec))
+      return;
+    if (m_ec)
+      break;
+    stack.pop();
+  }
+
+  if (m_ec) {
+    path root = move(stack.top().__root_);
+    __imp_.reset();
+    err.report(m_ec, "at root " PATH_CSTR_FMT, root.c_str());
+  } else {
+    __imp_.reset();
+  }
+}
+
+bool recursive_directory_iterator::__try_recursion(error_code* ec) {
+  ErrorHandler<void> err("recursive_directory_iterator::operator++()", ec);
+
+  bool rec_sym = bool(options() & directory_options::follow_directory_symlink);
+
+  auto& curr_it = __imp_->__stack_.top();
+
+  bool skip_rec = false;
+  error_code m_ec;
+  if (!rec_sym) {
+    file_status st(curr_it.__entry_.__get_sym_ft(&m_ec));
+    if (m_ec && status_known(st))
+      m_ec.clear();
+    if (m_ec || is_symlink(st) || !is_directory(st))
+      skip_rec = true;
+  } else {
+    file_status st(curr_it.__entry_.__get_ft(&m_ec));
+    if (m_ec && status_known(st))
+      m_ec.clear();
+    if (m_ec || !is_directory(st))
+      skip_rec = true;
+  }
+
+  if (!skip_rec) {
+    __dir_stream new_it(curr_it.__entry_.path(), __imp_->__options_, m_ec);
+    if (new_it.good()) {
+      __imp_->__stack_.push(move(new_it));
+      return true;
+    }
+  }
+  if (m_ec) {
+    const bool allow_eacess =
+        bool(__imp_->__options_ & directory_options::skip_permission_denied);
+    if (m_ec.value() == EACCES && allow_eacess) {
+      if (ec)
+        ec->clear();
+    } else {
+      path at_ent = move(curr_it.__entry_.__p_);
+      __imp_.reset();
+      err.report(m_ec, "attempting recursion into " PATH_CSTR_FMT,
+                 at_ent.c_str());
+    }
+  }
+  return false;
+}
+
+_LIBCPP_END_NAMESPACE_FILESYSTEM