Add hxx extension for headers and lib prefix for library dir

1 files changed, 0 insertions, 1396 deletions

diff --git a/butl/filesystem.cxx b/butl/filesystem.cxx
deleted file mode 100644
index d6e1f63..0000000
--- a/butl/filesystem.cxx
+++ /dev/null
@@ -1,1396 +0,0 @@
-// file      : butl/filesystem.cxx -*- C++ -*-
-// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd
-// license   : MIT; see accompanying LICENSE file
-
-#include <butl/filesystem>
-
-#ifndef _WIN32
-#  include <stdio.h>     // rename()
-#  include <dirent.h>    // struct dirent, *dir()
-#  include <unistd.h>    // symlink(), link(), stat(), rmdir(), unlink()
-#  include <sys/time.h>  // utimes()
-#  include <sys/types.h> // stat
-#  include <sys/stat.h>  // stat(), lstat(), S_I*, mkdir(), chmod()
-#else
-#  include <butl/win32-utility>
-
-#  include <io.h>        // _find*(), _unlink(), _chmod()
-#  include <direct.h>    // _mkdir(), _rmdir()
-#  include <sys/types.h> // _stat
-#  include <sys/stat.h>  // _stat(), S_I*
-
-#  ifdef _MSC_VER // Unlikely to be fixed in newer versions.
-#    define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
-#    define S_ISDIR(m) (((m) & S_IFMT) == S_IFDIR)
-#  endif
-
-#  include <butl/utility> // lcase()
-#endif
-
-#include <errno.h> // errno, E*
-
-#include <string>
-#include <vector>
-#include <memory>       // unique_ptr
-#include <utility>      // pair
-#include <iterator>     // reverse_iterator
-#include <system_error>
-
-#include <butl/path>
-#include <butl/utility>      // throw_generic_error()
-#include <butl/fdstream>
-#include <butl/small-vector>
-
-using namespace std;
-
-namespace butl
-{
-  bool
-  file_exists (const char* p, bool fl)
-  {
-    auto pe (path_entry (p, fl));
-    return pe.first && (pe.second == entry_type::regular ||
-                        (!fl && pe.second == entry_type::symlink));
-  }
-
-  bool
-  entry_exists (const char* p, bool fl)
-  {
-    return path_entry (p, fl).first;
-  }
-
-  bool
-  dir_exists (const char* p)
-  {
-    auto pe (path_entry (p, true));
-    return pe.first && pe.second == entry_type::directory;
-  }
-
-#ifndef _WIN32
-  pair<bool, entry_type>
-  path_entry (const char* p, bool fl)
-  {
-    struct stat s;
-    if ((fl ? stat (p, &s) : lstat (p, &s)) != 0)
-    {
-      if (errno == ENOENT || errno == ENOTDIR)
-        return make_pair (false, entry_type::unknown);
-      else
-        throw_generic_error (errno);
-    }
-
-    auto m (s.st_mode);
-    entry_type t (entry_type::unknown);
-
-    if (S_ISREG (m))
-      t = entry_type::regular;
-    else if (S_ISDIR (m))
-      t = entry_type::directory;
-    else if (S_ISLNK (m))
-      t = entry_type::symlink;
-    else if (S_ISBLK (m) || S_ISCHR (m) || S_ISFIFO (m) || S_ISSOCK (m))
-      t = entry_type::other;
-
-    return make_pair (true, t);
-  }
-#else
-  pair<bool, entry_type>
-  path_entry (const char* p, bool)
-  {
-    // A path like 'C:', while being a root path in our terminology, is not as
-    // such for Windows, that maintains current directory for each drive, and
-    // so C: means the current directory on the drive C. This is not what we
-    // mean here, so need to append the trailing directory separator in such a
-    // case.
-    //
-    string d;
-    if (path::traits::root (p, string::traits_type::length (p)))
-    {
-      d = p;
-      d += path::traits::directory_separator;
-      p = d.c_str ();
-    }
-
-    DWORD attr (GetFileAttributesA (p));
-    if (attr == INVALID_FILE_ATTRIBUTES) // Presumably not exists.
-      return make_pair (false, entry_type::unknown);
-
-    entry_type t (entry_type::unknown);
-
-    // S_ISLNK/S_IFDIR are not defined for Win32 but it does have symlinks.
-    // We will consider symlink entry to be of the unknown type. Note that
-    // S_ISREG() and S_ISDIR() return as they would do for a symlink target.
-    //
-    if ((attr & FILE_ATTRIBUTE_REPARSE_POINT) == 0)
-    {
-      struct _stat s;
-
-      if (_stat (p, &s) != 0)
-      {
-        if (errno == ENOENT || errno == ENOTDIR)
-          return make_pair (false, entry_type::unknown);
-        else
-          throw_generic_error (errno);
-      }
-
-      auto m (s.st_mode);
-
-      if (S_ISREG (m))
-        t = entry_type::regular;
-      else if (S_ISDIR (m))
-        t = entry_type::directory;
-      //
-      //else if (S_ISLNK (m))
-      //  t = entry_type::symlink;
-    }
-
-    return make_pair (true, t);
-  }
-#endif
-
-  mkdir_status
-#ifndef _WIN32
-  try_mkdir (const dir_path& p, mode_t m)
-  {
-    if (mkdir (p.string ().c_str (), m) != 0)
-#else
-  try_mkdir (const dir_path& p, mode_t)
-  {
-    if (_mkdir (p.string ().c_str ()) != 0)
-#endif
-    {
-      int e (errno);
-
-      // EEXIST means the path already exists but not necessarily as
-      // a directory.
-      //
-      if (e == EEXIST && dir_exists (p))
-        return mkdir_status::already_exists;
-      else
-        throw_generic_error (e);
-    }
-
-    return mkdir_status::success;
-  }
-
-  mkdir_status
-  try_mkdir_p (const dir_path& p, mode_t m)
-  {
-    if (!p.root ())
-    {
-      dir_path d (p.directory ());
-
-      if (!d.empty () && !dir_exists (d))
-        try_mkdir_p (d, m);
-    }
-
-    return try_mkdir (p, m);
-  }
-
-  rmdir_status
-  try_rmdir (const dir_path& p, bool ignore_error)
-  {
-    rmdir_status r (rmdir_status::success);
-
-#ifndef _WIN32
-    if (rmdir (p.string ().c_str ()) != 0)
-#else
-    if (_rmdir (p.string ().c_str ()) != 0)
-#endif
-    {
-      if (errno == ENOENT)
-        r = rmdir_status::not_exist;
-      else if (errno == ENOTEMPTY || errno == EEXIST)
-        r = rmdir_status::not_empty;
-      else if (!ignore_error)
-        throw_generic_error (errno);
-    }
-
-    return r;
-  }
-
-  void
-  rmdir_r (const dir_path& p, bool dir, bool ignore_error)
-  {
-    // An nftw()-based implementation (for platforms that support it)
-    // might be a faster way.
-    //
-    for (const dir_entry& de: dir_iterator (p))
-    {
-      path ep (p / de.path ()); //@@ Would be good to reuse the buffer.
-
-      if (de.ltype () == entry_type::directory)
-        rmdir_r (path_cast<dir_path> (move (ep)), true, ignore_error);
-      else
-        try_rmfile (ep, ignore_error);
-    }
-
-    if (dir)
-    {
-      rmdir_status r (try_rmdir (p));
-
-      if (r != rmdir_status::success && !ignore_error)
-        throw_generic_error (r == rmdir_status::not_empty
-                             ? ENOTEMPTY
-                             : ENOENT);
-    }
-  }
-
-  rmfile_status
-  try_rmfile (const path& p, bool ignore_error)
-  {
-    rmfile_status r (rmfile_status::success);
-
-#ifndef _WIN32
-    if (unlink (p.string ().c_str ()) != 0)
-#else
-    if (_unlink (p.string ().c_str ()) != 0)
-#endif
-    {
-      // Strangely on Linux unlink() removes a dangling symlink but returns
-      // ENOENT.
-      //
-      if (errno == ENOENT || errno == ENOTDIR)
-        r = rmfile_status::not_exist;
-      else if (!ignore_error)
-        throw_generic_error (errno);
-    }
-
-    return r;
-  }
-
-#ifndef _WIN32
-  void
-  mksymlink (const path& target, const path& link, bool)
-  {
-    if (symlink (target.string ().c_str (), link.string ().c_str ()) == -1)
-      throw_generic_error (errno);
-  }
-
-  void
-  mkhardlink (const path& target, const path& link, bool)
-  {
-    if (::link (target.string ().c_str (), link.string ().c_str ()) == -1)
-      throw_generic_error (errno);
-  }
-
-#else
-
-  void
-  mksymlink (const path&, const path&, bool)
-  {
-    throw_generic_error (ENOSYS, "symlinks not supported");
-  }
-
-  void
-  mkhardlink (const path& target, const path& link, bool dir)
-  {
-    if (!dir)
-    {
-      if (!CreateHardLinkA (link.string ().c_str (),
-                            target.string ().c_str (),
-                            nullptr))
-        throw_system_error (GetLastError ());
-    }
-    else
-      throw_generic_error (ENOSYS, "directory hard links not supported");
-  }
-#endif
-
-  // For I/O operations cpfile() can throw ios_base::failure exception that is
-  // not derived from system_error for old versions of g++ (as of 4.9). From
-  // the other hand cpfile() must throw system_error only. Let's catch
-  // ios_base::failure and rethrow as system_error in such a case.
-  //
-  template <bool v>
-  static inline typename enable_if<v>::type
-  cpfile (const path& from, const path& to,
-          cpflags fl,
-          permissions perm,
-          auto_rmfile& rm)
-  {
-    ifdstream ifs (from, fdopen_mode::binary);
-
-    fdopen_mode om (fdopen_mode::out      |
-                    fdopen_mode::truncate |
-                    fdopen_mode::create   |
-                    fdopen_mode::binary);
-
-    if ((fl & cpflags::overwrite_content) != cpflags::overwrite_content)
-      om |= fdopen_mode::exclusive;
-
-    ofdstream ofs (fdopen (to, om, perm));
-
-    rm = auto_rmfile (to);
-
-    // Throws ios::failure on fdbuf read/write failures.
-    //
-    // Note that the eof check is important: if the stream is at eof (empty
-    // file) then this write will fail.
-    //
-    if (ifs.peek () != ifdstream::traits_type::eof ())
-      ofs << ifs.rdbuf ();
-
-    ifs.close (); // Throws ios::failure on failure.
-    ofs.close (); // Throws ios::failure on flush/close failure.
-  }
-
-  template <bool v>
-  static inline typename enable_if<!v>::type
-  cpfile (const path& from, const path& to,
-          cpflags fl,
-          permissions perm,
-          auto_rmfile& rm)
-  {
-    try
-    {
-      cpfile<true> (from, to, fl, perm, rm);
-    }
-    catch (const ios_base::failure& e)
-    {
-      // While we try to preserve the original error information, we can not
-      // make the description to be exactly the same, for example
-      //
-      // Is a directory
-      //
-      // becomes
-      //
-      // Is a directory: Input/output error
-      //
-      // Note that our custom operator<<(ostream, exception) doesn't strip this
-      // suffix. This is a temporary code after all.
-      //
-      throw_generic_error (EIO, e.what ());
-    }
-  }
-
-  void
-  cpfile (const path& from, const path& to, cpflags fl)
-  {
-    permissions perm (path_permissions (from));
-    auto_rmfile rm;
-
-    cpfile<is_base_of<system_error, ios_base::failure>::value> (
-      from, to, fl, perm, rm);
-
-    if ((fl & cpflags::overwrite_permissions) ==
-        cpflags::overwrite_permissions)
-      path_permissions (to, perm);
-
-    rm.cancel ();
-  }
-
-  // Figuring out whether we have the nanoseconds in struct stat. Some
-  // platforms (e.g., FreeBSD), may provide some "compatibility" #define's,
-  // so use the second argument to not end up with the same signatures.
-  //
-  template <typename S>
-  inline constexpr auto
-  mnsec (const S* s, bool) -> decltype(s->st_mtim.tv_nsec)
-  {
-    return s->st_mtim.tv_nsec; // POSIX (GNU/Linux, Solaris).
-  }
-
-  template <typename S>
-  inline constexpr auto
-  mnsec (const S* s, int) -> decltype(s->st_mtimespec.tv_nsec)
-  {
-    return s->st_mtimespec.tv_nsec; // *BSD, MacOS.
-  }
-
-  template <typename S>
-  inline constexpr auto
-  mnsec (const S* s, float) -> decltype(s->st_mtime_n)
-  {
-    return s->st_mtime_n; // AIX 5.2 and later.
-  }
-
-  // Things are not going to end up well with only seconds resolution so
-  // let's make it a compile error.
-  //
-  // template <typename S>
-  // inline constexpr int
-  // mnsec (...) {return 0;}
-
-  template <typename S>
-  inline constexpr auto
-  ansec (const S* s, bool) -> decltype(s->st_atim.tv_nsec)
-  {
-    return s->st_atim.tv_nsec; // POSIX (GNU/Linux, Solaris).
-  }
-
-  template <typename S>
-  inline constexpr auto
-  ansec (const S* s, int) -> decltype(s->st_atimespec.tv_nsec)
-  {
-    return s->st_atimespec.tv_nsec; // *BSD, MacOS.
-  }
-
-  template <typename S>
-  inline constexpr auto
-  ansec (const S* s, float) -> decltype(s->st_atime_n)
-  {
-    return s->st_atime_n; // AIX 5.2 and later.
-  }
-
-  // template <typename S>
-  // inline constexpr int
-  // ansec (...) {return 0;}
-
-  void
-  mventry (const path& from, const path& to, cpflags fl)
-  {
-    assert ((fl & cpflags::overwrite_permissions) ==
-            cpflags::overwrite_permissions);
-
-    bool ovr ((fl & cpflags::overwrite_content) == cpflags::overwrite_content);
-
-    const char* f (from.string ().c_str ());
-    const char* t (to.string ().c_str ());
-
-#ifndef _WIN32
-
-    if (!ovr && path_entry (to).first)
-      throw_generic_error (EEXIST);
-
-    if (::rename (f, t) == 0) // POSIX implementation.
-      return;
-
-    // If source and destination paths are on different file systems we need to
-    // move the file ourselves.
-    //
-    if (errno != EXDEV)
-      throw_generic_error (errno);
-
-    // Note that cpfile() follows symlinks, so we need to remove destination if
-    // exists.
-    //
-    try_rmfile (to);
-
-    // Note that permissions are copied unconditionally to a new file.
-    //
-    cpfile (from, to, cpflags::none);
-
-    // Copy file access and modification times.
-    //
-    struct stat s;
-    if (stat (f, &s) != 0)
-      throw_generic_error (errno);
-
-    timeval times[2];
-    times[0].tv_sec = s.st_atime;
-    times[0].tv_usec = ansec<struct stat> (&s, true) / 1000;
-    times[1].tv_sec = s.st_mtime;
-    times[1].tv_usec = mnsec<struct stat> (&s, true) / 1000;
-
-    if (utimes (t, times) != 0)
-      throw_generic_error (errno);
-
-    // Finally, remove the source file.
-    //
-    try_rmfile (from);
-
-#else
-
-    // While ::rename() is present on Windows, it is not POSIX but ISO C
-    // implementation, that doesn't fit our needs well.
-    //
-    auto te (path_entry (to));
-
-    if (!ovr && te.first)
-      throw_generic_error (EEXIST);
-
-    bool td (te.first && te.second == entry_type::directory);
-
-    auto fe (path_entry (from));
-    bool fd (fe.first && fe.second == entry_type::directory);
-
-    // If source and destination filesystem entries exist, they both must be
-    // either directories or not directories.
-    //
-    if (fe.first && te.first && fd != td)
-      throw_generic_error (ENOTDIR);
-
-    DWORD mfl (fd ? 0 : (MOVEFILE_COPY_ALLOWED | MOVEFILE_REPLACE_EXISTING));
-
-    if (MoveFileExA (f, t, mfl))
-      return;
-
-    // If the destination already exists, then MoveFileExA() succeeds only if
-    // it is a regular file or a symlink. Lets also support an empty directory
-    // special case to comply with POSIX. If the destination is an empty
-    // directory we will just remove it and retry the move operation.
-    //
-    // Note that under Wine we endup with ERROR_ACCESS_DENIED error code in
-    // that case, and with ERROR_ALREADY_EXISTS when run natively.
-    //
-    DWORD ec (GetLastError ());
-    if ((ec == ERROR_ALREADY_EXISTS || ec == ERROR_ACCESS_DENIED) && td &&
-	try_rmdir (path_cast<dir_path> (to)) != rmdir_status::not_empty &&
-	MoveFileExA (f, t, mfl))
-      return;
-
-    throw_system_error (ec);
-
-#endif
-  }
-
-  timestamp
-  file_mtime (const char* p)
-  {
-#ifndef _WIN32
-    struct stat s;
-    if (stat (p, &s) != 0)
-    {
-      if (errno == ENOENT || errno == ENOTDIR)
-        return timestamp_nonexistent;
-      else
-        throw_generic_error (errno);
-    }
-
-    if (!S_ISREG (s.st_mode))
-      return timestamp_nonexistent;
-
-    return system_clock::from_time_t (s.st_mtime) +
-      chrono::duration_cast<duration> (
-        chrono::nanoseconds (mnsec<struct stat> (&s, true)));
-#else
-
-    WIN32_FILE_ATTRIBUTE_DATA s;
-
-    if (!GetFileAttributesExA (p, GetFileExInfoStandard, &s))
-    {
-      DWORD ec (GetLastError ());
-
-      if (ec == ERROR_FILE_NOT_FOUND ||
-          ec == ERROR_PATH_NOT_FOUND ||
-          ec == ERROR_INVALID_NAME   ||
-          ec == ERROR_INVALID_DRIVE  ||
-          ec == ERROR_BAD_PATHNAME   ||
-          ec == ERROR_BAD_NETPATH)
-        return timestamp_nonexistent;
-
-      throw_system_error (ec);
-    }
-
-    if ((s.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
-      return timestamp_nonexistent;
-
-    // Time in FILETIME is in 100 nanosecond "ticks" since "Windows epoch"
-    // (1601-01-01T00:00:00Z). To convert it to "UNIX epoch"
-    // (1970-01-01T00:00:00Z) we need to subtract 11644473600 seconds.
-    //
-    const FILETIME& t (s.ftLastWriteTime);
-
-    uint64_t ns ((static_cast<uint64_t> (t.dwHighDateTime) << 32) |
-                 t.dwLowDateTime);
-
-    ns -= 11644473600ULL * 10000000; // Now in UNIX epoch.
-    ns *= 100;                       // Now in nanoseconds.
-
-    return timestamp (
-      chrono::duration_cast<duration> (
-        chrono::nanoseconds (ns)));
-#endif
-  }
-
-  permissions
-  path_permissions (const path& p)
-  {
-#ifndef _WIN32
-    struct stat s;
-    if (stat (p.string ().c_str (), &s) != 0)
-#else
-    struct _stat s;
-    if (_stat (p.string ().c_str (), &s) != 0)
-#endif
-      throw_generic_error (errno);
-
-    // VC++ has no S_IRWXU defined. MINGW GCC <= 4.9 has no S_IRWXG, S_IRWXO
-    // defined.
-    //
-    // We could extrapolate user permissions to group/other permissions if
-    // S_IRWXG/S_IRWXO are undefined. That is, we could consider their absence
-    // as meaning that the platform does not distinguish between permissions
-    // for different kinds of users. Let's wait for a use-case first.
-    //
-    mode_t f (S_IREAD | S_IWRITE | S_IEXEC);
-
-#ifdef S_IRWXG
-    f |= S_IRWXG;
-#endif
-
-#ifdef S_IRWXO
-    f |= S_IRWXO;
-#endif
-
-    return static_cast<permissions> (s.st_mode & f);
-  }
-
-  void
-  path_permissions (const path& p, permissions f)
-  {
-    mode_t m (S_IREAD | S_IWRITE | S_IEXEC);
-
-#ifdef S_IRWXG
-    m |= S_IRWXG;
-#endif
-
-#ifdef S_IRWXO
-    m |= S_IRWXO;
-#endif
-
-    m &= static_cast<mode_t> (f);
-
-#ifndef _WIN32
-    if (chmod (p.string ().c_str (), m) == -1)
-#else
-    if (_chmod (p.string ().c_str (), m) == -1)
-#endif
-      throw_generic_error (errno);
-  }
-
-  // dir_{entry,iterator}
-  //
-#ifndef _WIN32
-
-  // dir_entry
-  //
-  dir_iterator::
-  ~dir_iterator ()
-  {
-    if (h_ != nullptr)
-      closedir (h_); // Ignore any errors.
-  }
-
-  dir_iterator& dir_iterator::
-  operator= (dir_iterator&& x)
-  {
-    if (this != &x)
-    {
-      e_ = move (x.e_);
-
-      if (h_ != nullptr && closedir (h_) == -1)
-        throw_generic_error (errno);
-
-      h_ = x.h_;
-      x.h_ = nullptr;
-    }
-    return *this;
-  }
-
-  entry_type dir_entry::
-  type (bool link) const
-  {
-    path_type p (b_ / p_);
-    struct stat s;
-    if ((link
-         ? stat (p.string ().c_str (), &s)
-         : lstat (p.string ().c_str (), &s)) != 0)
-    {
-      throw_generic_error (errno);
-    }
-
-    entry_type r;
-
-    if (S_ISREG (s.st_mode))
-      r = entry_type::regular;
-    else if (S_ISDIR (s.st_mode))
-      r = entry_type::directory;
-    else if (S_ISLNK (s.st_mode))
-      r = entry_type::symlink;
-    else
-      r = entry_type::other;
-
-    return r;
-  }
-
-  // dir_iterator
-  //
-  struct dir_deleter
-  {
-    void operator() (DIR* p) const {if (p != nullptr) closedir (p);}
-  };
-
-  dir_iterator::
-  dir_iterator (const dir_path& d)
-  {
-    unique_ptr<DIR, dir_deleter> h (opendir (d.string ().c_str ()));
-    h_ = h.get ();
-
-    if (h_ == nullptr)
-      throw_generic_error (errno);
-
-    next ();
-
-    if (h_ != nullptr)
-      e_.b_ = d;
-
-    h.release ();
-  }
-
-  template <typename D>
-  inline /*constexpr*/ entry_type d_type (const D* d, decltype(d->d_type)*)
-  {
-    switch (d->d_type)
-    {
-#ifdef DT_DIR
-    case DT_DIR: return entry_type::directory;
-#endif
-#ifdef DT_REG
-    case DT_REG: return entry_type::regular;
-#endif
-#ifdef DT_LNK
-    case DT_LNK: return entry_type::symlink;
-#endif
-#ifdef DT_BLK
-    case DT_BLK:
-#endif
-#ifdef DT_CHR
-    case DT_CHR:
-#endif
-#ifdef DT_FIFO
-    case DT_FIFO:
-#endif
-#ifdef DT_SOCK
-    case DT_SOCK:
-#endif
-      return entry_type::other;
-
-    default: return entry_type::unknown;
-    }
-  }
-
-  template <typename D>
-  inline constexpr entry_type d_type (...) {return entry_type::unknown;}
-
-  void dir_iterator::
-  next ()
-  {
-    for (;;)
-    {
-      errno = 0;
-      if (struct dirent* de = readdir (h_))
-      {
-        // We can accept some overhead for '.' and '..' (relying on short
-        // string optimization) in favor of a more compact code.
-        //
-        path p (de->d_name);
-
-        // Skip '.' and '..'.
-        //
-       if (p.current () || p.parent ())
-          continue;
-
-        e_.p_ = move (p);
-        e_.t_ = d_type<struct dirent> (de, nullptr);
-        e_.lt_ = entry_type::unknown;
-      }
-      else if (errno == 0)
-      {
-        // End of stream.
-        //
-        closedir (h_);
-        h_ = nullptr;
-      }
-      else
-        throw_generic_error (errno);
-
-      break;
-    }
-  }
-
-#else
-
-  // dir_entry
-  //
-  dir_iterator::
-  ~dir_iterator ()
-  {
-    if (h_ != -1)
-      _findclose (h_); // Ignore any errors.
-  }
-
-  dir_iterator& dir_iterator::
-  operator= (dir_iterator&& x)
-  {
-    if (this != &x)
-    {
-      e_ = move (x.e_);
-
-      if (h_ != -1 && _findclose (h_) == -1)
-        throw_generic_error (errno);
-
-      h_ = x.h_;
-      x.h_ = -1;
-    }
-    return *this;
-  }
-
-  entry_type dir_entry::
-  type (bool) const
-  {
-    // Note that we currently do not support symlinks (yes, there is symlink
-    // support since Vista).
-    //
-    path_type p (b_ / p_);
-
-    struct _stat s;
-    if (_stat (p.string ().c_str (), &s) != 0)
-      throw_generic_error (errno);
-
-    entry_type r;
-    if (S_ISREG (s.st_mode))
-      r = entry_type::regular;
-    else if (S_ISDIR (s.st_mode))
-      r = entry_type::directory;
-    else
-      r = entry_type::other;
-
-    return r;
-  }
-
-  // dir_iterator
-  //
-  struct auto_dir
-  {
-    explicit
-    auto_dir (intptr_t& h): h_ (&h) {}
-
-    auto_dir (const auto_dir&) = delete;
-    auto_dir& operator= (const auto_dir&) = delete;
-
-    ~auto_dir ()
-    {
-      if (h_ != nullptr && *h_ != -1)
-        _findclose (*h_);
-    }
-
-    void release () {h_ = nullptr;}
-
-  private:
-    intptr_t* h_;
-  };
-
-  dir_iterator::
-  dir_iterator (const dir_path& d)
-  {
-    auto_dir h (h_);
-    e_.b_ = d; // Used by next() to call _findfirst().
-
-    next ();
-    h.release ();
-  }
-
-  void dir_iterator::
-  next ()
-  {
-    for (;;)
-    {
-      bool r;
-      _finddata_t fi;
-
-      if (h_ == -1)
-      {
-        // The call is made from the constructor. Any other call with h_ == -1
-        // is illegal.
-        //
-
-        // Check to distinguish non-existent vs empty directories.
-        //
-        if (!dir_exists (e_.b_))
-          throw_generic_error (ENOENT);
-
-        h_ = _findfirst ((e_.b_ / path ("*")).string ().c_str (), &fi);
-        r = h_ != -1;
-      }
-      else
-        r = _findnext (h_, &fi) == 0;
-
-      if (r)
-      {
-        // We can accept some overhead for '.' and '..' (relying on short
-        // string optimization) in favor of a more compact code.
-        //
-        path p (fi.name);
-
-        // Skip '.' and '..'.
-        //
-        if (p.current () || p.parent ())
-          continue;
-
-        e_.p_ = move (p);
-
-        // We do not support symlinks at the moment.
-        //
-        e_.t_ = fi.attrib & _A_SUBDIR
-          ? entry_type::directory
-          : entry_type::regular;
-
-        e_.lt_ = entry_type::unknown;
-      }
-      else if (errno == ENOENT)
-      {
-        // End of stream.
-        //
-        if (h_ != -1)
-        {
-          _findclose (h_);
-          h_ = -1;
-        }
-      }
-      else
-        throw_generic_error (errno);
-
-      break;
-    }
-  }
-#endif
-
-  // Match the name [ni, ne) to the pattern [pi, pe). Ranges can be empty.
-  //
-  static bool
-  match (string::const_iterator pi, string::const_iterator pe,
-         string::const_iterator ni, string::const_iterator ne)
-  {
-    using reverse_iterator = std::reverse_iterator<string::const_iterator>;
-
-    reverse_iterator rpi (pe);
-    reverse_iterator rpe (pi);
-
-    reverse_iterator rni (ne);
-    reverse_iterator rne (ni);
-
-    // Match the pattern suffix (follows the last *) to the name trailing
-    // characters.
-    //
-    char pc;
-    for (; rpi != rpe && (pc = *rpi) != '*' && rni != rne; ++rpi, ++rni)
-    {
-#ifndef _WIN32
-      if (*rni != pc && pc != '?')
-#else
-      if (lcase (*rni) != lcase (pc) && pc != '?')
-#endif
-        return false;
-    }
-
-    // If we got to the (reversed) end of the pattern (no * is encountered)
-    // than we are done. The success depends on if we got to the (reversed) end
-    // of the name as well.
-    //
-    if (rpi == rpe)
-      return rni == rne;
-
-    // If we didn't reach * in the pattern then we reached the (reversed) end
-    // of the name. That means we have unmatched non-star characters in the
-    // pattern, and so match failed.
-    //
-    if (pc != '*')
-    {
-      assert (rni == rne);
-      return false;
-    }
-
-    // Match the pattern prefix (ends with the first *) to the name leading
-    // characters. If they mismatch we failed. Otherwise if this is an only *
-    // in the pattern (matches whatever is left in the name) then we succeed,
-    // otherwise we perform backtracking (recursively).
-    //
-    pe = rpi.base ();
-    ne = rni.base ();
-
-    // Compare the pattern and the name char by char until the name suffix or
-    // * is encountered in the pattern (whichever happens first). Fail if a
-    // char mismatches.
-    //
-    for (; (pc = *pi) != '*' && ni != ne; ++pi, ++ni)
-    {
-#ifndef _WIN32
-      if (*ni != pc && pc != '?')
-#else
-        if (lcase (*ni) != lcase (pc) && pc != '?')
-#endif
-        return false;
-    }
-
-    // If we didn't get to * in the pattern then we got to the name suffix.
-    // That means that the pattern has unmatched non-star characters, and so
-    // match failed.
-    //
-    if (pc != '*')
-    {
-      assert (ni == ne);
-      return false;
-    }
-
-    // If * that we have reached is the last one, then it matches whatever is
-    // left in the name (including an empty range).
-    //
-    if (++pi == pe)
-      return true;
-
-    // Perform backtracking.
-    //
-    // From now on, we will call the pattern not-yet-matched part (starting
-    // the leftmost * and ending the rightmost one inclusively) as pattern, and
-    // the name not-yet-matched part as name.
-    //
-    // Here we sequentially assume that * that starts the pattern matches the
-    // name leading part (staring from an empty one and iterating till the full
-    // name). So if, at some iteration, the pattern trailing part (that follows
-    // the leftmost *) matches the name trailing part, then the pattern matches
-    // the name.
-    //
-    bool r;
-    for (; !(r = match (pi, pe, ni, ne)) && ni != ne; ++ni) ;
-    return r;
-  }
-
-  bool
-  path_match (const string& pattern, const string& name)
-  {
-    // Implementation notes:
-    //
-    // - This has a good potential of becoming hairy quickly so need to strive
-    //   for an elegant way to implement this.
-    //
-    // - Most patterns will contains a single * wildcard with a prefix and/or
-    //   suffix (e.g., *.txt, foo*, f*.txt). Something like this is not very
-    //   common: *foo*.
-    //
-    //   So it would be nice to have a clever implementation that first
-    //   "anchors" itself with a literal prefix and/or suffix and only then
-    //   continue with backtracking. In other words, reduce:
-    //
-    //   *.txt  vs foo.txt -> * vs foo
-    //   foo*   vs foo.txt -> * vs .txt
-    //   f*.txt vs foo.txt -> * vs oo
-    //
-
-    auto pi (pattern.rbegin ());
-    auto pe (pattern.rend ());
-
-    auto ni (name.rbegin ());
-    auto ne (name.rend ());
-
-    // The name doesn't match the pattern if it is of a different type than the
-    // pattern is.
-    //
-    bool pd (pi != pe && path::traits::is_separator (*pi));
-    bool nd (ni != ne && path::traits::is_separator (*ni));
-
-    if (pd != nd)
-      return false;
-
-    // Skip trailing separators if present.
-    //
-    if (pd)
-    {
-      ++pi;
-      ++ni;
-    }
-
-    return match (pattern.begin (), pi.base (), name.begin (), ni.base ());
-  }
-
-  // Iterate over directory sub-entries, recursively and including itself if
-  // requested. Note that recursive iterating goes depth-first which make
-  // sense for the cleanup use cases (@@ maybe this should be controllable
-  // since for directory creation it won't make sense).
-  //
-  // Prior to recursively opening a directory for iterating the preopen
-  // callback function is called. If false is returned, then the directory is
-  // not traversed but still returned by the next() call.
-  //
-  // Note that iterating over non-existent directory is not en error. The
-  // subsequent next() call returns false for such a directory.
-  //
-  using preopen = std::function<bool (const dir_path&)>;
-
-  class recursive_dir_iterator
-  {
-  public:
-    recursive_dir_iterator (dir_path p,
-                            bool recursive,
-                            bool self,
-                            bool fs,
-                            preopen po)
-        : start_ (move (p)),
-          recursive_ (recursive),
-          self_ (self),
-          follow_symlinks_ (fs),
-          preopen_ (move (po))
-    {
-      open (dir_path (), self_);
-    }
-
-    // Non-copyable, non-movable type.
-    //
-    recursive_dir_iterator (const recursive_dir_iterator&) = delete;
-    recursive_dir_iterator& operator= (const recursive_dir_iterator&) = delete;
-
-    // Return false if no more entries left. Otherwise save the next entry path
-    // and return true. The path is relative against the directory being
-    // traversed and contains a trailing separator for sub-directories. Throw
-    // std::system_error in case of a failure (insufficient permissions,
-    // dangling symlink encountered, etc).
-    //
-    bool
-    next (path& p)
-    {
-      if (iters_.empty ())
-        return false;
-
-      auto& i (iters_.back ());
-
-      // If we got to the end of directory sub-entries, then go one level up
-      // and return this directory path.
-      //
-      if (i.first == dir_iterator ())
-      {
-        path d (move (i.second));
-        iters_.pop_back ();
-
-        // Return the path unless it is the last one (the directory we started
-        // to iterate from) and the self flag is not set.
-        //
-        if (iters_.empty () && !self_)
-          return false;
-
-        p = move (d);
-        return true;
-      }
-
-      const dir_entry& de (*i.first);
-
-      // Append separator if a directory. Note that dir_entry::type() can
-      // throw.
-      //
-      entry_type et (follow_symlinks_ ? de.type () : de.ltype ());
-      path pe (et == entry_type::directory
-               ? path_cast<dir_path> (i.second / de.path ())
-               : i.second / de.path ());
-
-      ++i.first;
-
-      if (recursive_ && pe.to_directory ())
-      {
-        open (path_cast<dir_path> (move (pe)), true);
-        return next (p);
-      }
-
-      p = move (pe);
-      return true;
-    }
-
-  private:
-    void
-    open (dir_path p, bool preopen)
-    {
-      // We should consider a racing condition here. The directory can be
-      // removed before we create an iterator for it. In this case we just do
-      // nothing, so the directory is silently skipped.
-      //
-      try
-      {
-        // If preopen_() returns false, then the directory will not be
-        // traversed (as we leave iterator with end semantics) but still be
-        // returned by the next() call as a sub-entry.
-        //
-        dir_iterator i;
-        if (!preopen || preopen_ (p))
-        {
-          dir_path d (start_ / p);
-          i = dir_iterator (!d.empty () ? d : dir_path ("."));
-        }
-
-        iters_.emplace_back (move (i), move (p));
-      }
-      catch (const system_error& e)
-      {
-        // Ignore non-existent directory (ENOENT or ENOTDIR). Rethrow for any
-        // other error. We consider ENOTDIR as a variety of removal, with a
-        // new filesystem entry being created afterwards.
-        //
-        // Make sure that the error denotes errno portable code.
-        //
-        assert (e.code ().category () == generic_category ());
-
-        int ec (e.code ().value ());
-        if (ec != ENOENT && ec != ENOTDIR)
-          throw;
-      }
-    }
-
-  private:
-    dir_path start_;
-    bool recursive_;
-    bool self_;
-    bool follow_symlinks_;
-    preopen preopen_;
-    small_vector<pair<dir_iterator, dir_path>, 1> iters_;
-  };
-
-  // Search for paths matching the pattern and call the specified function for
-  // each matching path. Return false if the underlying func() call returns
-  // false. Otherwise the function conforms to the path_search() description.
-  //
-  static const string any_dir ("*/");
-
-  static bool
-  search (
-    path pattern,
-    dir_path pattern_dir,
-    const dir_path start_dir,
-    bool follow_symlinks,
-    const function<bool (path&&, const string& pattern, bool interm)>& func)
-  {
-    // Fast-forward the leftmost pattern non-wildcard components. So, for
-    // example, search for foo/f* in /bar/ becomes search for f* in /bar/foo/.
-    //
-    {
-      auto b (pattern.begin ());
-      auto e (pattern.end ());
-      auto i (b);
-      for (; i != e && (*i).find_first_of ("*?") == string::npos; ++i) ;
-
-      // If the pattern has no wildcards then we reduce to checking for the
-      // filesystem entry existence. It matches if exists and is of the proper
-      // type.
-      //
-      if (i == e)
-      {
-        path p (pattern_dir / pattern);
-        auto pe (path_entry (start_dir / p, true));
-
-        if (pe.first &&
-            ((pe.second == entry_type::directory) == p.to_directory ()))
-          return func (move (p), string (), false);
-
-        return true;
-      }
-      else if (i != b) // There are non-wildcard components, so fast-forward.
-      {
-        path p (b, i);
-        pattern = pattern.leaf (p);
-        pattern_dir /= path_cast<dir_path> (move (p));
-      }
-    }
-
-    assert (!pattern.empty ());
-
-    // The pattern leftmost component. Will use it to match the start directory
-    // sub-entries.
-    //
-    path pc (pattern.begin (), ++pattern.begin ());
-    string pcr (pc.representation ());
-
-    // Note that if the pattern has multiple components (is not a simple path),
-    // then the leftmost one has a trailing separator, and so will match
-    // sub-directories only.
-    //
-    bool simple (pattern.simple ());
-
-    // Note that we rely on "small function object" optimization here.
-    //
-    recursive_dir_iterator i (
-      start_dir / pattern_dir,
-      pcr.find ("**") != string::npos,                  // Recursive.
-      pcr.find ("***") != string::npos,                 // Self-inclusive.
-      follow_symlinks,
-      [&pattern_dir, &func] (const dir_path& p) -> bool // Preopen.
-      {
-        return func (pattern_dir / p, any_dir, true);
-      });
-
-    // Canonicalize the pattern component collapsing consecutive stars (used to
-    // express that it is recursive) into a single one.
-    //
-    size_t j (0);
-    size_t n (pcr.size ());
-    for (size_t i (0); i < n; ++i)
-    {
-      char c (pcr[i]);
-      if (!(c == '*' && i > 0 && pcr[i - 1] == '*'))
-        pcr[j++] = c;
-    }
-
-    if (j != n)
-      pcr.resize (j);
-
-    // Note that the callback function can be called for the same directory
-    // twice: first time as intermediate match from iterator's preopen() call,
-    // and then, if the first call succeed, from the iterating loop (possibly
-    // as the final match).
-    //
-    path p;
-    while (i.next (p))
-    {
-      // Skip sub-entry if its name doesn't match the pattern leftmost
-      // component.
-      //
-      // Matching the directory we are iterating through (as for a pattern
-      // component containing ***) is a bit tricky. This directory is
-      // represented by the iterator as an empty path, and so we need to
-      // compute it (the leaf would actually be enough) for matching. This
-      // leaf can be aquired from the pattern_dir / start_dir path except the
-      // case when both directories are empty. This is the case when we search
-      // in the current directory (start_dir is empty) with a pattern that
-      // starts with *** wildcard (for example f***/bar). All we can do here is
-      // to fallback to path::current_directory() call. Note that this will be
-      // the only call per path_search() as the next time pattern_dir will not
-      // be empty.
-      //
-      const path& se (!p.empty ()
-                      ? p
-                      : path_cast<path> (!pattern_dir.empty ()
-                                         ? pattern_dir
-                                         : !start_dir.empty ()
-                                           ? start_dir
-                                           : path::current_directory ()));
-
-      if (!path_match (pcr, se.leaf ().representation ()))
-        continue;
-
-      // If the callback function returns false, then we stop the entire search
-      // for the final match, or do not search below the path for the
-      // intermediate one.
-      //
-      if (!func (pattern_dir / p, pcr, !simple))
-      {
-        if (simple) // Final match.
-          return false;
-        else
-          continue;
-      }
-
-      // If the pattern is not a simple one, and it's leftmost component
-      // matches the sub-entry, then the sub-entry is a directory (see the note
-      // above), and we search in it using the trailing part of the pattern.
-      //
-      if (!simple && !search (pattern.leaf (pc),
-                              pattern_dir / path_cast<dir_path> (move (p)),
-                              start_dir,
-                              follow_symlinks,
-                              func))
-        return false;
-    }
-
-    return true;
-  }
-
-  void
-  path_search (
-    const path& pattern,
-    const function<bool (path&&, const string& pattern, bool interm)>& func,
-    const dir_path& start,
-    bool follow_symlinks)
-  {
-    search (pattern,
-            dir_path (),
-            pattern.relative () ? start : dir_path (),
-            follow_symlinks,
-            func);
-  }
-}