Add hxx extension for headers and lib prefix for library dir

1 files changed, 0 insertions, 1085 deletions

diff --git a/butl/fdstream.cxx b/butl/fdstream.cxx
deleted file mode 100644
index 68168f3..0000000
--- a/butl/fdstream.cxx
+++ /dev/null
@@ -1,1085 +0,0 @@
-// file      : butl/fdstream.cxx -*- C++ -*-
-// copyright : Copyright (c) 2014-2017 Code Synthesis Ltd
-// license   : MIT; see accompanying LICENSE file
-
-#include <butl/fdstream>
-
-#ifndef _WIN32
-#  include <fcntl.h>     // open(), O_*, fcntl()
-#  include <unistd.h>    // close(), read(), write(), lseek(), dup(), pipe(),
-                         // ssize_t, STD*_FILENO
-#  include <sys/uio.h>   // writev(), iovec
-#  include <sys/stat.h>  // S_I*
-#  include <sys/types.h> // off_t
-#else
-#  include <butl/win32-utility>
-
-#  include <io.h>       // _close(), _read(), _write(), _setmode(), _sopen(),
-                        // _lseek(), _dup(), _pipe(), _get_osfhandle()
-#  include <share.h>    // _SH_DENYNO
-#  include <stdio.h>    // _fileno(), stdin, stdout, stderr
-#  include <fcntl.h>    // _O_*
-#  include <sys/stat.h> // S_I*
-#endif
-
-#include <errno.h> // errno, E*
-
-#include <ios>          // ios_base::openmode, ios_base::failure
-#include <new>          // bad_alloc
-#include <limits>       // numeric_limits
-#include <cassert>
-#include <cstring>      // memcpy(), memmove()
-#include <exception>    // uncaught_exception()
-#include <stdexcept>    // invalid_argument
-#include <type_traits>
-#include <system_error>
-
-#include <butl/process-details>
-
-using namespace std;
-
-#ifdef _WIN32
-using namespace butl::win32;
-#endif
-
-namespace butl
-{
-  // throw_ios_failure
-  //
-  template <bool v>
-  [[noreturn]] static inline typename enable_if<v>::type
-  throw_ios_failure (error_code e, const char* m)
-  {
-    // The idea here is to make an error code to be saved into failure
-    // exception and to make a string returned by what() to contain the error
-    // description plus an optional custom message if provided. Unfortunatelly
-    // there is no way to say that the custom message is absent. Passing an
-    // empty string results for libstdc++ (as of version 5.3.1) with a
-    // description like this (note the ': ' prefix):
-    //
-    // : No such file or directory
-    //
-    // Note that our custom operator<<(ostream, exception) strips this prefix.
-    //
-    throw ios_base::failure (m != nullptr ? m : "", e);
-  }
-
-  template <bool v>
-  [[noreturn]] static inline typename enable_if<!v>::type
-  throw_ios_failure (error_code e, const char* m)
-  {
-    throw ios_base::failure (m != nullptr ? m : e.message ().c_str ());
-  }
-
-  // Throw system_error with generic_category.
-  //
-  [[noreturn]] static inline void
-  throw_ios_failure (int errno_code, const char* m = nullptr)
-  {
-    error_code ec (errno_code, generic_category ());
-    throw_ios_failure<is_base_of<system_error, ios_base::failure>::value> (
-      ec, m);
-  }
-
-#ifdef _WIN32
-  // Throw system_error with system_category.
-  //
-  static inline void
-  throw_ios_system_failure (int system_code)
-  {
-    // Here we work around MinGW libstdc++ that interprets Windows system error
-    // codes (for example those returned by GetLastError()) as errno codes.
-    //
-    // Note that the resulting system_error description will have ': Success.'
-    // suffix that is stripped by our custom operator<<(ostream, exception).
-    //
-    error_code ec (0, system_category ());
-    string m (win32::error_msg (system_code));
-
-    throw_ios_failure<is_base_of<system_error, ios_base::failure>::value> (
-      ec, m.c_str ());
-  }
-#endif
-
-  // auto_fd
-  //
-  void auto_fd::
-  close ()
-  {
-    if (fd_ >= 0)
-    {
-      bool r (fdclose (fd_));
-
-      // If fdclose() failed then no reason to expect it to succeed the next
-      // time.
-      //
-      fd_ = -1;
-
-      if (!r)
-        throw_ios_failure (errno);
-    }
-  }
-
-  // fdbuf
-  //
-  fdbuf::
-  fdbuf (auto_fd&& fd)
-  {
-    if (fd.get () >= 0)
-      open (move (fd));
-  }
-
-  void fdbuf::
-  open (auto_fd&& fd)
-  {
-    close ();
-
-#ifndef _WIN32
-    int flags (fcntl (fd.get (), F_GETFL));
-
-    if (flags == -1)
-      throw_ios_failure (errno);
-
-    non_blocking_ = (flags & O_NONBLOCK) == O_NONBLOCK;
-#endif
-
-    setg (buf_, buf_, buf_);
-    setp (buf_, buf_ + sizeof (buf_) - 1); // Keep space for overflow's char.
-
-    fd_ = move (fd);
-  }
-
-  streamsize fdbuf::
-  showmanyc ()
-  {
-    if (!is_open ())
-      return -1;
-
-    streamsize n (egptr () - gptr ());
-
-    if (n > 0)
-      return n;
-
-#ifndef _WIN32
-    if (non_blocking_)
-    {
-      ssize_t n (read (fd_.get (), buf_, sizeof (buf_)));
-
-      if (n == -1)
-      {
-        if (errno == EAGAIN || errno == EINTR)
-          return 0;
-
-        throw_ios_failure (errno);
-      }
-
-      if (n == 0) // EOF.
-        return -1;
-
-      setg (buf_, buf_, buf_ + n);
-      return n;
-    }
-#endif
-
-    return 0;
-  }
-
-  fdbuf::int_type fdbuf::
-  underflow ()
-  {
-    int_type r (traits_type::eof ());
-
-    if (is_open ())
-    {
-      // The underflow() function interface doesn't support the non-blocking
-      // semantics as it must return either the next character or EOF. In the
-      // future we may implement the blocking behavior for a non-blocking file
-      // descriptor.
-      //
-      if (non_blocking_)
-        throw_ios_failure (ENOTSUP);
-
-      if (gptr () < egptr () || load ())
-        r = traits_type::to_int_type (*gptr ());
-    }
-
-    return r;
-  }
-
-  bool fdbuf::
-  load ()
-  {
-    // Doesn't handle blocking mode and so should not be called.
-    //
-    assert (!non_blocking_);
-
-#ifndef _WIN32
-    ssize_t n (read (fd_.get (), buf_, sizeof (buf_)));
-#else
-    int n (_read (fd_.get (), buf_, sizeof (buf_)));
-#endif
-
-    if (n == -1)
-      throw_ios_failure (errno);
-
-    setg (buf_, buf_, buf_ + n);
-    return n != 0;
-  }
-
-  fdbuf::int_type fdbuf::
-  overflow (int_type c)
-  {
-    int_type r (traits_type::eof ());
-
-    if (is_open () && c != traits_type::eof ())
-    {
-      // The overflow() function interface doesn't support the non-blocking
-      // semantics since being unable to serialize the character is supposed
-      // to be an error. In the future we may implement the blocking behavior
-      // for a non-blocking file descriptor.
-      //
-      if (non_blocking_)
-        throw_ios_failure (ENOTSUP);
-
-      // Store last character in the space we reserved in open(). Note
-      // that pbump() doesn't do any checks.
-      //
-      *pptr () = traits_type::to_char_type (c);
-      pbump (1);
-
-      if (save ())
-        r = c;
-    }
-
-    return r;
-  }
-
-  int fdbuf::
-  sync ()
-  {
-    if (!is_open ())
-      return -1;
-
-    // The sync() function interface doesn't support the non-blocking
-    // semantics since it should either completely sync the data or fail. In
-    // the future we may implement the blocking behavior for a non-blocking
-    // file descriptor.
-    //
-    if (non_blocking_)
-      throw_ios_failure (ENOTSUP);
-
-    return save () ? 0 : -1;
-  }
-
-  bool fdbuf::
-  save ()
-  {
-    size_t n (pptr () - pbase ());
-
-    if (n != 0)
-    {
-      // Note that for MinGW GCC (5.2.0) _write() returns 0 for a file
-      // descriptor opened for read-only access (while -1 with errno EBADF is
-      // expected). This is in contrast with VC's _write() and POSIX's write().
-      //
-#ifndef _WIN32
-      ssize_t m (write (fd_.get (), buf_, n));
-#else
-      int m (_write (fd_.get (), buf_, n));
-#endif
-
-      if (m == -1)
-        throw_ios_failure (errno);
-
-      if (n != static_cast<size_t> (m))
-        return false;
-
-      setp (buf_, buf_ + sizeof (buf_) - 1);
-    }
-
-    return true;
-  }
-
-  streamsize fdbuf::
-  xsputn (const char_type* s, streamsize sn)
-  {
-    // The xsputn() function interface doesn't support the non-blocking
-    // semantics since the only excuse not to fully serialize the data is
-    // encountering EOF (the default behaviour is defined as a sequence of
-    // sputc() calls which stops when either sn characters are written or a
-    // call would have returned EOF). In the future we may implement the
-    // blocking behavior for a non-blocking file descriptor.
-    //
-    if (non_blocking_)
-      throw_ios_failure (ENOTSUP);
-
-    // To avoid futher 'signed/unsigned comparison' compiler warnings.
-    //
-    size_t n (static_cast<size_t> (sn));
-
-    // Buffer the data if there is enough space.
-    //
-    size_t an (epptr () - pptr ()); // Amount of free space in the buffer.
-    if (n <= an)
-    {
-      memcpy (pptr (), s, n);
-      pbump (n);
-      return n;
-    }
-
-    size_t bn (pptr () - pbase ()); // Buffered data size.
-
-#ifndef _WIN32
-
-    ssize_t r;
-    if (bn > 0)
-    {
-      // Write both buffered and new data with a single system call.
-      //
-      iovec iov[2] = {{pbase (), bn}, {const_cast<char*> (s), n}};
-      r = writev (fd_.get (), iov, 2);
-    }
-    else
-      r = write (fd_.get (), s, n);
-
-    if (r == -1)
-      throw_ios_failure (errno);
-
-    size_t m (static_cast<size_t> (r));
-
-    // If the buffered data wasn't fully written then move the unwritten part
-    // to the beginning of the buffer.
-    //
-    if (m < bn)
-    {
-      memmove (pbase (), pbase () + m, bn - m);
-      pbump (-m); // Note that pbump() accepts negatives.
-      return 0;
-    }
-
-    setp (buf_, buf_ + sizeof (buf_) - 1);
-    return m - bn;
-
-#else
-
-    // On Windows there is no writev() available so sometimes we will make two
-    // system calls. Fill and flush the buffer, then try to fit the data tail
-    // into the empty buffer. If the data tail is too long then just write it
-    // to the file and keep the buffer empty.
-    //
-    // We will end up with two _write() calls if the total data size to be
-    // written exceeds double the buffer size. In this case the buffer filling
-    // is redundant so let's pretend there is no free space in the buffer, and
-    // so buffered and new data will be written separatelly.
-    //
-    if (bn + n > 2 * (bn + an))
-      an = 0;
-    else
-    {
-      memcpy (pptr (), s, an);
-      pbump (an);
-    }
-
-    // Flush the buffer.
-    //
-    size_t wn (bn + an);
-    int r (wn > 0 ? _write (fd_.get (), buf_, wn) : 0);
-
-    if (r == -1)
-      throw_ios_failure (errno);
-
-    size_t m (static_cast<size_t> (r));
-
-    // If the buffered data wasn't fully written then move the unwritten part
-    // to the beginning of the buffer.
-    //
-    if (m < wn)
-    {
-      memmove (pbase (), pbase () + m, wn - m);
-      pbump (-m); // Note that pbump() accepts negatives.
-      return m < bn ? 0 : m - bn;
-    }
-
-    setp (buf_, buf_ + sizeof (buf_) - 1);
-
-    // Now 'an' holds the size of the data portion written as a part of the
-    // buffer flush.
-    //
-    s += an;
-    n -= an;
-
-    // Buffer the data tail if it fits the buffer.
-    //
-    if (n <= static_cast<size_t> (epptr () - pbase ()))
-    {
-      memcpy (pbase (), s, n);
-      pbump (n);
-      return sn;
-    }
-
-    // The data tail doesn't fit the buffer so write it to the file.
-    //
-    r = _write (fd_.get (), s, n);
-
-    if (r == -1)
-      throw_ios_failure (errno);
-
-    return an + r;
-#endif
-  }
-
-  inline static bool
-  flag (fdstream_mode m, fdstream_mode flag)
-  {
-    return (m & flag) == flag;
-  }
-
-  inline static auto_fd
-  mode (auto_fd fd, fdstream_mode m)
-  {
-    if (fd.get () >= 0 &&
-        (flag (m, fdstream_mode::text) ||
-         flag (m, fdstream_mode::binary) ||
-         flag (m, fdstream_mode::blocking) ||
-         flag (m, fdstream_mode::non_blocking)))
-      fdmode (fd.get (), m);
-
-    return fd;
-  }
-
-  // fdstream_base
-  //
-  fdstream_base::
-  fdstream_base (auto_fd&& fd, fdstream_mode m)
-      : fdstream_base (mode (move (fd), m)) // Delegate.
-  {
-  }
-
-  static fdopen_mode
-  translate_mode (ios_base::openmode m)
-  {
-    enum
-    {
-      in    = ios_base::in,
-      out   = ios_base::out,
-      app   = ios_base::app,
-      bin   = ios_base::binary,
-      trunc = ios_base::trunc,
-      ate   = ios_base::ate
-    };
-
-    const fdopen_mode fd_in     (fdopen_mode::in);
-    const fdopen_mode fd_out    (fdopen_mode::out);
-    const fdopen_mode fd_inout  (fdopen_mode::in | fdopen_mode::out);
-    const fdopen_mode fd_app    (fdopen_mode::append);
-    const fdopen_mode fd_trunc  (fdopen_mode::truncate);
-    const fdopen_mode fd_create (fdopen_mode::create);
-    const fdopen_mode fd_bin    (fdopen_mode::binary);
-    const fdopen_mode fd_ate    (fdopen_mode::at_end);
-
-    fdopen_mode r;
-    switch (m & ~(ate | bin))
-    {
-    case in               : r = fd_in                           ; break;
-    case out              :
-    case out | trunc      : r = fd_out   | fd_trunc | fd_create ; break;
-    case app              :
-    case out | app        : r = fd_out   | fd_app   | fd_create ; break;
-    case out | in         : r = fd_inout                        ; break;
-    case out | in | trunc : r = fd_inout | fd_trunc | fd_create ; break;
-    case out | in | app   :
-    case in  | app        : r = fd_inout | fd_app   | fd_create ; break;
-
-    default: throw invalid_argument ("invalid open mode");
-    }
-
-    if (m & ate)
-      r |= fd_ate;
-
-    if (m & bin)
-      r |= fd_bin;
-
-    return r;
-  }
-
-  // ifdstream
-  //
-  ifdstream::
-  ifdstream (const char* f, openmode m, iostate e)
-      : ifdstream (f, translate_mode (m | in), e) // Delegate.
-  {
-  }
-
-  ifdstream::
-  ifdstream (const char* f, fdopen_mode m, iostate e)
-      : ifdstream (fdopen (f, m | fdopen_mode::in), e) // Delegate.
-  {
-  }
-
-  ifdstream::
-  ~ifdstream ()
-  {
-    if (skip_ && is_open () && good ())
-    {
-      // Clear the exception mask to prevent ignore() from throwing.
-      //
-      exceptions (goodbit);
-      ignore (numeric_limits<streamsize>::max ());
-    }
-
-    // Underlying file descriptor is closed by fdbuf dtor with errors (if any)
-    // being ignored.
-    //
-  }
-
-  void ifdstream::
-  open (const char* f, openmode m)
-  {
-    open (f, translate_mode (m | in));
-  }
-
-  void ifdstream::
-  open (const char* f, fdopen_mode m)
-  {
-    open (fdopen (f, m | fdopen_mode::in));
-  }
-
-  void ifdstream::
-  close ()
-  {
-    if (skip_ && is_open () && good ())
-      ignore (numeric_limits<streamsize>::max ());
-
-    buf_.close ();
-  }
-
-  ifdstream&
-  getline (ifdstream& is, string& s, char delim)
-  {
-    ifdstream::iostate eb (is.exceptions ());
-    assert (eb & ifdstream::badbit);
-
-    // Amend the exception mask to prevent exceptions being thrown by the C++
-    // IO runtime to avoid incompatibility issues due to ios_base::failure ABI
-    // fiasco (#66145). We will not restore the mask when ios_base::failure is
-    // thrown by fdbuf since there is no way to "silently" restore it if the
-    // corresponding bits are in the error state without the exceptions() call
-    // throwing ios_base::failure. Not restoring exception mask on throwing
-    // because of badbit should probably be ok since the stream is no longer
-    // usable.
-    //
-    if (eb != ifdstream::badbit)
-      is.exceptions (ifdstream::badbit);
-
-    std::getline (is, s, delim);
-
-    // Throw if any of the newly set bits are present in the exception mask.
-    //
-    if ((is.rdstate () & eb) != ifdstream::goodbit)
-      throw_ios_failure (EIO, "getline failure");
-
-    if (eb != ifdstream::badbit)
-      is.exceptions (eb); // Restore exception mask.
-
-    return is;
-  }
-
-  // ofdstream
-  //
-  ofdstream::
-  ofdstream (const char* f, openmode m, iostate e)
-      : ofdstream (f, translate_mode (m | out), e) // Delegate.
-  {
-  }
-
-  ofdstream::
-  ofdstream (const char* f, fdopen_mode m, iostate e)
-      : ofdstream (fdopen (f, m | fdopen_mode::out), e) // Delegate.
-  {
-  }
-
-  ofdstream::
-  ~ofdstream ()
-  {
-    // Enforce explicit close(). Note that we may have false negatives but not
-    // false positives. Specifically, we will fail to enforce if someone is
-    // using ofdstream in a dtor being called while unwinding the stack due to
-    // an exception.
-    //
-    assert (!is_open () || !good () || uncaught_exception ());
-  }
-
-  void ofdstream::
-  open (const char* f, openmode m)
-  {
-    open (f, translate_mode (m | out));
-  }
-
-  void ofdstream::
-  open (const char* f, fdopen_mode m)
-  {
-    open (fdopen (f, m | fdopen_mode::out));
-  }
-
-  // Utility functions
-  //
-  auto_fd
-  fdopen (const char* f, fdopen_mode m, permissions p)
-  {
-    mode_t pf (S_IREAD | S_IWRITE | S_IEXEC);
-
-#ifdef S_IRWXG
-    pf |= S_IRWXG;
-#endif
-
-#ifdef S_IRWXO
-    pf |= S_IRWXO;
-#endif
-
-    pf &= static_cast<mode_t> (p);
-
-    // Return true if the open mode contains a specific flag.
-    //
-    auto mode = [m](fdopen_mode flag) -> bool {return (m & flag) == flag;};
-
-    int of (0);
-    bool in (mode (fdopen_mode::in));
-    bool out (mode (fdopen_mode::out));
-
-#ifndef _WIN32
-
-    if (in && out)
-      of |= O_RDWR;
-    else if (in)
-      of |= O_RDONLY;
-    else if (out)
-      of |= O_WRONLY;
-
-    if (out)
-    {
-      if (mode (fdopen_mode::append))
-        of |= O_APPEND;
-
-      if (mode (fdopen_mode::truncate))
-        of |= O_TRUNC;
-    }
-
-    if (mode (fdopen_mode::create))
-    {
-      of |= O_CREAT;
-
-      if (mode (fdopen_mode::exclusive))
-        of |= O_EXCL;
-    }
-
-#ifdef O_LARGEFILE
-    of |= O_LARGEFILE;
-#endif
-
-    int fd (open (f, of | O_CLOEXEC, pf));
-
-#else
-
-    if (in && out)
-      of |= _O_RDWR;
-    else if (in)
-      of |= _O_RDONLY;
-    else if (out)
-      of |= _O_WRONLY;
-
-    if (out)
-    {
-      if (mode (fdopen_mode::append))
-        of |= _O_APPEND;
-
-      if (mode (fdopen_mode::truncate))
-        of |= _O_TRUNC;
-    }
-
-    if (mode (fdopen_mode::create))
-    {
-      of |= _O_CREAT;
-
-      if (mode (fdopen_mode::exclusive))
-        of |= _O_EXCL;
-    }
-
-    of |= mode (fdopen_mode::binary) ? _O_BINARY : _O_TEXT;
-
-    // According to Microsoft _sopen() should not change the permissions of an
-    // existing file. However it does if we pass them (reproduced on Windows
-    // XP, 7, and 8). And we must pass them if we have _O_CREATE. So we need
-    // to take care of preserving the permissions ourselves. Note that Wine's
-    // implementation of _sopen() works properly.
-    //
-    bool pass_perm (of & _O_CREAT);
-
-    if (pass_perm && file_exists (path (f)))
-    {
-      // If the _O_CREAT flag is set then we need to clear it so that we can
-      // omit the permissions. But if the _O_EXCL flag is set as well we can't
-      // do that as fdopen() wouldn't fail as expected.
-      //
-      if (of & _O_EXCL)
-        throw_ios_failure (EEXIST);
-
-      of &= ~_O_CREAT;
-      pass_perm = false;
-    }
-
-    // Make sure the file descriptor is not inheritable by default.
-    //
-    of |= _O_NOINHERIT;
-
-    int fd (pass_perm
-            ? _sopen (f, of, _SH_DENYNO, pf)
-            : _sopen (f, of, _SH_DENYNO));
-
-#endif
-
-    if (fd == -1)
-      throw_ios_failure (errno);
-
-    if (mode (fdopen_mode::at_end))
-    {
-#ifndef _WIN32
-      bool r (lseek (fd, 0, SEEK_END) != static_cast<off_t> (-1));
-#else
-      bool r (_lseek (fd, 0, SEEK_END) != -1);
-#endif
-
-      // Note that in the case of an error we don't delete the newly created
-      // file as we have no indication if it is a new one.
-      //
-      if (!r)
-      {
-        int e (errno);
-        fdclose (fd); // Doesn't throw, but can change errno.
-        throw_ios_failure (e);
-      }
-    }
-
-    return auto_fd (fd);
-  }
-
-#ifndef _WIN32
-
-  auto_fd
-  fddup (int fd)
-  {
-    // dup() doesn't copy FD_CLOEXEC flag, so we need to do it ourselves. Note
-    // that the new descriptor can leak into child processes before we copy the
-    // flag. To prevent this we will acquire the process_spawn_mutex (see
-    // process-details header) prior to duplicating the descriptor. Also note
-    // there is dup3() (available on Linux and FreeBSD but not on Max OS) that
-    // takes flags, but it's usage tends to be hairy (need to preopen a dummy
-    // file descriptor to pass as a second argument).
-    //
-    auto dup = [fd] () -> auto_fd
-    {
-      auto_fd nfd (::dup (fd));
-      if (nfd.get () == -1)
-        throw_ios_failure (errno);
-
-      return nfd;
-    };
-
-    int f (fcntl (fd, F_GETFD));
-    if (f == -1)
-      throw_ios_failure (errno);
-
-    // If the source descriptor has no FD_CLOEXEC flag set then no flag copy is
-    // required (as the duplicate will have no flag by default).
-    //
-    if ((f & FD_CLOEXEC) == 0)
-      return dup ();
-
-    slock l (process_spawn_mutex);
-    auto_fd nfd (dup ());
-
-    f = fcntl (nfd.get (), F_GETFD);
-    if (f == -1 || fcntl (nfd.get (), F_SETFD, f | FD_CLOEXEC) == -1)
-      throw_ios_failure (errno);
-
-    return nfd;
-  }
-
-  bool
-  fdclose (int fd) noexcept
-  {
-    return close (fd) == 0;
-  }
-
-  auto_fd
-  fdnull () noexcept
-  {
-    int fd (open ("/dev/null", O_RDWR | O_CLOEXEC));
-
-    if (fd == -1)
-      throw_ios_failure (errno);
-
-    return auto_fd (fd);
-  }
-
-  fdstream_mode
-  fdmode (int fd, fdstream_mode m)
-  {
-    int flags (fcntl (fd, F_GETFL));
-
-    if (flags == -1)
-      throw_ios_failure (errno);
-
-    if (flag (m, fdstream_mode::blocking) ||
-        flag (m, fdstream_mode::non_blocking))
-    {
-      m &= fdstream_mode::blocking | fdstream_mode::non_blocking;
-
-      // Should be exactly one blocking mode flag specified.
-      //
-      if (m != fdstream_mode::blocking && m != fdstream_mode::non_blocking)
-        throw invalid_argument ("invalid blocking mode");
-
-      int new_flags (
-        m == fdstream_mode::non_blocking
-        ? flags | O_NONBLOCK
-        : flags & ~O_NONBLOCK);
-
-      if (fcntl (fd, F_SETFL, new_flags) == -1)
-        throw_ios_failure (errno);
-    }
-
-    return fdstream_mode::binary |
-      ((flags & O_NONBLOCK) == O_NONBLOCK
-       ? fdstream_mode::non_blocking
-       : fdstream_mode::blocking);
-  }
-
-  fdstream_mode
-  stdin_fdmode (fdstream_mode m)
-  {
-    return fdmode (STDIN_FILENO, m);
-  }
-
-  fdstream_mode
-  stdout_fdmode (fdstream_mode m)
-  {
-    return fdmode (STDOUT_FILENO, m);
-  }
-
-  fdstream_mode
-  stderr_fdmode (fdstream_mode m)
-  {
-    return fdmode (STDERR_FILENO, m);
-  }
-
-  fdpipe
-  fdopen_pipe (fdopen_mode m)
-  {
-    assert (m == fdopen_mode::none || m == fdopen_mode::binary);
-
-    // Note that the pipe file descriptors can leak into child processes before
-    // we set FD_CLOEXEC flag for them. To prevent this we will acquire the
-    // process_spawn_mutex (see process-details header) prior to creating the
-    // pipe. Also note there is pipe2() (available on Linux and FreeBSD but not
-    // on Max OS) that takes flags.
-    //
-    slock l (process_spawn_mutex);
-
-    int pd[2];
-    if (pipe (pd) == -1)
-      throw_ios_failure (errno);
-
-    fdpipe r {auto_fd (pd[0]), auto_fd (pd[1])};
-
-    for (size_t i (0); i < 2; ++i)
-    {
-      int f (fcntl (pd[i], F_GETFD));
-      if (f == -1 || fcntl (pd[i], F_SETFD, f | FD_CLOEXEC) == -1)
-        throw_ios_failure (errno);
-    }
-
-    return r;
-  }
-
-#else
-
-  auto_fd
-  fddup (int fd)
-  {
-    // _dup() doesn't copy _O_NOINHERIT flag, so we need to do it ourselves.
-    // Note that the new descriptor can leak into child processes before we
-    // copy the flag. To prevent this we will acquire the process_spawn_mutex
-    // (see process-details header) prior to duplicating the descriptor.
-    //
-    // We can not ammend file descriptors directly (nor obtain the flag value),
-    // so need to resolve them to Windows HANDLE first. Such handles are closed
-    // either when CloseHandle() is called for them or when _close() is called
-    // for the associated file descriptors. Make sure that either the original
-    // file descriptor or the resulting HANDLE is closed but not both of them.
-    //
-    auto handle = [] (int fd) -> HANDLE
-    {
-      HANDLE h (reinterpret_cast<HANDLE> (_get_osfhandle (fd)));
-      if (h == INVALID_HANDLE_VALUE)
-        throw_ios_failure (errno); // EBADF (POSIX value).
-
-      return h;
-    };
-
-    auto dup = [fd] () -> auto_fd
-    {
-      auto_fd nfd (_dup (fd));
-      if (nfd.get () == -1)
-        throw_ios_failure (errno);
-
-      return nfd;
-    };
-
-    DWORD f;
-    if (!GetHandleInformation (handle (fd), &f))
-      throw_ios_system_failure (GetLastError ());
-
-    // If the source handle is inheritable then no flag copy is required (as
-    // the duplicate handle will be inheritable by default).
-    //
-    if (f & HANDLE_FLAG_INHERIT)
-      return dup ();
-
-    slock l (process_spawn_mutex);
-
-    auto_fd nfd (dup ());
-    if (!SetHandleInformation (handle (nfd.get ()), HANDLE_FLAG_INHERIT, 0))
-      throw_ios_system_failure (GetLastError ());
-
-    return nfd;
-  }
-
-  bool
-  fdclose (int fd) noexcept
-  {
-    return _close (fd) == 0;
-  }
-
-  auto_fd
-  fdnull (bool temp) noexcept
-  {
-    // No need to translate \r\n before sending it to void.
-    //
-    if (!temp)
-    {
-      int fd (_sopen ("nul", _O_RDWR | _O_BINARY | _O_NOINHERIT, _SH_DENYNO));
-
-      if (fd == -1)
-        throw_ios_failure (errno);
-
-      return auto_fd (fd);
-    }
-
-    try
-    {
-      // We could probably implement a Windows-specific version of getting
-      // the temporary file that avoid any allocations and exceptions.
-      //
-      path p (path::temp_path ("null")); // Can throw.
-      int fd (_sopen (p.string ().c_str (),
-                      (_O_CREAT       |
-                       _O_RDWR        |
-                       _O_BINARY      | // Don't translate.
-                       _O_TEMPORARY   | // Remove on close.
-                       _O_SHORT_LIVED | // Don't flush to disk.
-                       _O_NOINHERIT),   // Don't inherit by child process.
-                      _SH_DENYNO,
-                      _S_IREAD | _S_IWRITE));
-
-      if (fd == -1)
-        throw_ios_failure (errno);
-
-      return auto_fd (fd);
-    }
-    catch (const bad_alloc&)
-    {
-      throw_ios_failure (ENOMEM);
-    }
-    catch (const system_error& e)
-    {
-      // Make sure that the error denotes errno portable code.
-      //
-      assert (e.code ().category () == generic_category ());
-
-      throw_ios_failure (e.code ().value ());
-    }
-  }
-
-  fdstream_mode
-  fdmode (int fd, fdstream_mode m)
-  {
-    m &= fdstream_mode::text | fdstream_mode::binary;
-
-    // Should be exactly one translation flag specified.
-    //
-    // It would have been natural not to change translation mode if none of
-    // text or binary flags are passed. Unfortunatelly there is no (easy) way
-    // to obtain the current mode for the file descriptor without setting a
-    // new one. This is why not specifying one of the modes is an error.
-    //
-    if (m != fdstream_mode::binary && m != fdstream_mode::text)
-      throw invalid_argument ("invalid translation mode");
-
-    // Note that _setmode() preserves the _O_NOINHERIT flag value.
-    //
-    int r (_setmode (fd, m == fdstream_mode::binary ? _O_BINARY : _O_TEXT));
-    if (r == -1)
-      throw_ios_failure (errno); // EBADF or EINVAL (POSIX values).
-
-    return fdstream_mode::blocking |
-      ((r & _O_BINARY) == _O_BINARY
-       ? fdstream_mode::binary
-       : fdstream_mode::text);
-  }
-
-  fdstream_mode
-  stdin_fdmode (fdstream_mode m)
-  {
-    int fd (_fileno (stdin));
-    if (fd == -1)
-      throw_ios_failure (errno);
-
-    return fdmode (fd, m);
-  }
-
-  fdstream_mode
-  stdout_fdmode (fdstream_mode m)
-  {
-    int fd (_fileno (stdout));
-    if (fd == -1)
-      throw_ios_failure (errno);
-
-    return fdmode (fd, m);
-  }
-
-  fdstream_mode
-  stderr_fdmode (fdstream_mode m)
-  {
-    int fd (_fileno (stderr));
-    if (fd == -1)
-      throw_ios_failure (errno);
-
-    return fdmode (fd, m);
-  }
-
-  fdpipe
-  fdopen_pipe (fdopen_mode m)
-  {
-    assert (m == fdopen_mode::none || m == fdopen_mode::binary);
-
-    int pd[2];
-    if (_pipe (
-          pd,
-          64 * 1024, // Set buffer size to 64K.
-          _O_NOINHERIT | (m == fdopen_mode::none ? _O_TEXT : _O_BINARY)) == -1)
-      throw_ios_failure (errno);
-
-    return {auto_fd (pd[0]), auto_fd (pd[1])};
-  }
-#endif
-}