passenger 5.0.24 → 5.0.25

data/src/cxx_supportlib/vendor-modified/boost/libs/regex/src/regex.cpp

@@ -64,7 +64,7 @@ regex_error::regex_error(const std::string& s, regex_constants::error_type err,
 }
 
 regex_error::regex_error(regex_constants::error_type err) 
-   : std::runtime_error(::boost::re_detail::get_default_error_string(err))
+   : std::runtime_error(::boost::BOOST_REGEX_DETAIL_NS::get_default_error_string(err))
    , m_error_code(err)
    , m_position(0) 
 {
@@ -83,7 +83,7 @@ void regex_error::raise()const
 
 
 
-namespace re_detail{
+namespace BOOST_REGEX_DETAIL_NS{
 
 BOOST_REGEX_DECL void BOOST_REGEX_CALL raise_runtime_error(const std::runtime_error& ex)
 {
@@ -211,7 +211,7 @@ BOOST_REGEX_DECL void BOOST_REGEX_CALL put_mem_block(void* p)
 
 #endif
 
-} // namespace re_detail
+} // namespace BOOST_REGEX_DETAIL_NS
 
 
 

data/src/cxx_supportlib/vendor-modified/boost/libs/regex/src/regex_raw_buffer.cpp

@@ -3,8 +3,8 @@
  * Copyright (c) 2004
  * John Maddock
  *
- * Use, modification and distribution are subject to the
- * Boost Software License, Version 1.0. (See accompanying file
+ * Use, modification and distribution are subject to the 
+ * Boost Software License, Version 1.0. (See accompanying file 
  * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  *
  */
@@ -32,7 +32,7 @@ namespace std{
 #endif
 
 
-namespace boost{ namespace re_detail{
+namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
 
 void BOOST_REGEX_CALL raw_storage::resize(size_type n)
 {

data/src/cxx_supportlib/vendor-modified/boost/libs/regex/src/regex_traits_defaults.cpp

@@ -36,7 +36,7 @@ namespace std{
 #endif
 
 
-namespace boost{ namespace re_detail{
+namespace boost{ namespace BOOST_REGEX_DETAIL_NS{
 
 BOOST_REGEX_DECL const char* BOOST_REGEX_CALL get_default_syntax(regex_constants::syntax_type n)
 {
@@ -688,5 +688,5 @@ BOOST_REGEX_DECL regex_constants::syntax_type BOOST_REGEX_CALL get_default_synta
 }
 
 
-} // re_detail
+} // BOOST_REGEX_DETAIL_NS
 } // boost

data/src/cxx_supportlib/vendor-modified/boost/libs/regex/src/static_mutex.cpp

@@ -18,6 +18,7 @@
 
 #define BOOST_REGEX_SOURCE
 #include <boost/config.hpp>
+#include <boost/assert.hpp>
 
 #ifdef BOOST_HAS_THREADS
 
@@ -54,8 +55,8 @@ void scoped_static_mutex_lock::lock()
 {
    if(0 == m_have_lock)
    {
-      pthread_mutex_lock(&(m_mutex.m_mutex));
-      m_have_lock = true;
+      // Client code will throw if this fails:
+      m_have_lock = (pthread_mutex_lock(&(m_mutex.m_mutex)) == 0);
    }
 }
 
@@ -63,7 +64,10 @@ void scoped_static_mutex_lock::unlock()
 {
    if(m_have_lock)
    {
-      pthread_mutex_unlock(&(m_mutex.m_mutex));
+      // If this fails there's nothing we can do except assert,
+      // exceptions are out of the question as this code is called
+      // from the lock's destructor:
+      BOOST_VERIFY(pthread_mutex_unlock(&(m_mutex.m_mutex)) == 0);
       m_have_lock = false;
    }
 }
@@ -157,7 +161,7 @@ void scoped_static_mutex_lock::lock()
    {
        boost::call_once(static_mutex::m_once,&static_mutex::init);
       if(0 == m_plock)
-         m_plock = new boost::recursive_mutex::scoped_lock(*static_mutex::m_pmutex, boost::defer_lock);
+         m_plock = new boost::unique_lock<boost::recursive_mutex>(*static_mutex::m_pmutex, boost::defer_lock);
       m_plock->lock();
       m_have_lock = true;
    }

data/src/cxx_supportlib/vendor-modified/boost/libs/regex/src/wc_regex_traits.cpp

@@ -94,6 +94,19 @@ c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::t
    std::wstring result(s, L' ');
    while(s < (r = std::wcsxfrm(&*result.begin(), src.c_str(), s)))
    {
+#if defined(_CPPLIB_VER)
+      //
+      // A bug in VC11 and 12 causes the program to hang if we pass a null-string
+      // to std::strxfrm, but only for certain locales :-(
+      // Probably effects Intel and Clang or any compiler using the VC std library (Dinkumware).
+      //
+      if(r == INT_MAX)
+      {
+         result.erase();
+         result.insert(result.begin(), static_cast<wchar_t>(0));
+         return result;
+      }
+#endif
       result.append(r - s + 3, L' ');
       s = result.size();
    }
@@ -104,7 +117,7 @@ c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::t
 c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::transform_primary(const wchar_t* p1, const wchar_t* p2) 
 {
    static wchar_t s_delim;
-   static const int s_collate_type = ::boost::re_detail::find_sort_syntax(static_cast<const c_regex_traits<wchar_t>*>(0), &s_delim);
+   static const int s_collate_type = ::boost::BOOST_REGEX_DETAIL_NS::find_sort_syntax(static_cast<const c_regex_traits<wchar_t>*>(0), &s_delim);
    std::wstring result;
    //
    // What we do here depends upon the format of the sort key returned by
@@ -112,8 +125,8 @@ c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::t
    //
    switch(s_collate_type)
    {
-   case ::boost::re_detail::sort_C:
-   case ::boost::re_detail::sort_unknown:
+   case ::boost::BOOST_REGEX_DETAIL_NS::sort_C:
+   case ::boost::BOOST_REGEX_DETAIL_NS::sort_unknown:
       // the best we can do is translate to lower case, then get a regular sort key:
       {
          result.assign(p1, p2);
@@ -122,14 +135,14 @@ c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::t
          result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
          break;
       }
-   case ::boost::re_detail::sort_fixed:
+   case ::boost::BOOST_REGEX_DETAIL_NS::sort_fixed:
       {
          // get a regular sort key, and then truncate it:
          result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
          result.erase(s_delim);
          break;
       }
-   case ::boost::re_detail::sort_delim:
+   case ::boost::BOOST_REGEX_DETAIL_NS::sort_delim:
          // get a regular sort key, and then truncate everything after the delim:
          result = c_regex_traits<wchar_t>::transform(&*result.begin(), &*result.begin() + result.size());
          if(result.size() && (result[0] == s_delim))
@@ -176,13 +189,13 @@ c_regex_traits<wchar_t>::char_class_type BOOST_REGEX_CALL c_regex_traits<wchar_t
       char_class_xdigit,
    };
 
-   int idx = ::boost::re_detail::get_default_class_id(p1, p2);
+   int idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(p1, p2);
    if(idx < 0)
    {
       std::wstring s(p1, p2);
       for(std::wstring::size_type i = 0; i < s.size(); ++i)
          s[i] = (std::towlower)(s[i]);
-      idx = ::boost::re_detail::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
+      idx = ::boost::BOOST_REGEX_DETAIL_NS::get_default_class_id(&*s.begin(), &*s.begin() + s.size());
    }
    BOOST_ASSERT(idx+1 < static_cast<int>(sizeof(masks) / sizeof(masks[0])));
    return masks[idx+1];
@@ -200,11 +213,11 @@ bool BOOST_REGEX_CALL c_regex_traits<wchar_t>::isctype(wchar_t c, char_class_typ
       || ((mask & char_class_digit) && (std::iswdigit)(c))
       || ((mask & char_class_punct) && (std::iswpunct)(c))
       || ((mask & char_class_xdigit) && (std::iswxdigit)(c))
-      || ((mask & char_class_blank) && (std::iswspace)(c) && !::boost::re_detail::is_separator(c))
+      || ((mask & char_class_blank) && (std::iswspace)(c) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c))
       || ((mask & char_class_word) && (c == '_'))
       || ((mask & char_class_unicode) && (c & ~static_cast<wchar_t>(0xff)))
-      || ((mask & char_class_vertical) && (::boost::re_detail::is_separator(c) || (c == L'\v')))
-      || ((mask & char_class_horizontal) && (std::iswspace)(c) && !::boost::re_detail::is_separator(c) && (c != L'\v'));
+      || ((mask & char_class_vertical) && (::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) || (c == L'\v')))
+      || ((mask & char_class_horizontal) && (std::iswspace)(c) && !::boost::BOOST_REGEX_DETAIL_NS::is_separator(c) && (c != L'\v'));
 }
 
 c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::lookup_collatename(const wchar_t* p1, const wchar_t* p2) 
@@ -219,7 +232,7 @@ c_regex_traits<wchar_t>::string_type BOOST_REGEX_CALL c_regex_traits<wchar_t>::l
    while(p0 != p2)
       name.append(1, char(*p0++));
 #endif
-   name = ::boost::re_detail::lookup_default_collate_name(name);
+   name = ::boost::BOOST_REGEX_DETAIL_NS::lookup_default_collate_name(name);
 #if !defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)\
                && !BOOST_WORKAROUND(BOOST_MSVC, < 1300)\
                && !BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)

data/src/cxx_supportlib/vendor-modified/boost/libs/regex/src/wide_posix_api.cpp

@@ -78,23 +78,20 @@ typedef boost::basic_regex<wchar_t, c_regex_traits<wchar_t> > wc_regex_type;
 
 BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompW(regex_tW* expression, const wchar_t* ptr, int f)
 {
-   if(expression->re_magic != wmagic_value)
-   {
-      expression->guts = 0;
 #ifndef BOOST_NO_EXCEPTIONS
-      try{
+   try{
 #endif
       expression->guts = new wc_regex_type();
 #ifndef BOOST_NO_EXCEPTIONS
-      } catch(...)
-      {
-         return REG_ESPACE;
-      }
+   } catch(...)
+   {
+      expression->guts = 0;
+      return REG_ESPACE;
+   }
 #else
-      if(0 == expression->guts)
-         return REG_E_MEMORY;
+   if(0 == expression->guts)
+      return REG_E_MEMORY;
 #endif
-   }
    // set default flags:
    boost::uint_fast32_t flags = (f & REG_PERLEX) ? 0 : ((f & REG_EXTENDED) ? wregex::extended : wregex::basic);
    expression->eflags = (f & REG_NEWLINE) ? match_not_dot_newline : match_default;
@@ -135,7 +132,7 @@ BOOST_REGEX_DECL int BOOST_REGEX_CCALL regcompW(regex_tW* expression, const wcha
 #endif
       expression->re_magic = wmagic_value;
       static_cast<wc_regex_type*>(expression->guts)->set_expression(ptr, p2, flags);
-      expression->re_nsub = static_cast<wc_regex_type*>(expression->guts)->mark_count() - 1;
+      expression->re_nsub = static_cast<wc_regex_type*>(expression->guts)->mark_count();
       result = static_cast<wc_regex_type*>(expression->guts)->error_code();
 #ifndef BOOST_NO_EXCEPTIONS
    } 
@@ -218,12 +215,12 @@ BOOST_REGEX_DECL regsize_t BOOST_REGEX_CCALL regerrorW(int code, const regex_tW*
          p = static_cast<wc_regex_type*>(e->guts)->get_traits().error_string(static_cast< ::boost::regex_constants::error_type>(code));
       else
       {
-         p = re_detail::get_default_error_string(static_cast< ::boost::regex_constants::error_type>(code));
+         p = BOOST_REGEX_DETAIL_NS::get_default_error_string(static_cast< ::boost::regex_constants::error_type>(code));
       }
       std::size_t len = p.size();
       if(len < buf_size)
       {
-         re_detail::copy(p.c_str(), p.c_str() + p.size() + 1, buf);
+         BOOST_REGEX_DETAIL_NS::copy(p.c_str(), p.c_str() + p.size() + 1, buf);
       }
       return len + 1;
    }

data/src/cxx_supportlib/vendor-modified/boost/libs/system/src/error_code.cpp

@@ -9,429 +9,12 @@
 
 //----------------------------------------------------------------------------//
 
-#include <boost/config/warning_disable.hpp>
-
 // define BOOST_SYSTEM_SOURCE so that <boost/system/config.hpp> knows
 // the library is being built (possibly exporting rather than importing code)
-#define BOOST_SYSTEM_SOURCE 
+#define BOOST_SYSTEM_SOURCE
 
-#include <boost/system/config.hpp>
 #include <boost/system/error_code.hpp>
-#include <boost/cerrno.hpp>
-#include <vector>
-#include <cstdlib>
-#include <cassert>
-
-#include <cstring> // for strerror/strerror_r
-
-# if defined( BOOST_WINDOWS_API )
-#   include <windows.h>
-#   include "local_free_on_destruction.hpp"
-#   ifndef ERROR_INCORRECT_SIZE
-#     define ERROR_INCORRECT_SIZE ERROR_BAD_ARGUMENTS
-#   endif
-# endif
-
-//----------------------------------------------------------------------------//
-namespace boost
-{
-    namespace system
-    {
-
-namespace
-{
-    
-  //  standard error categories  ---------------------------------------------//
-
-  class generic_error_category : public error_category
-  {
-  public:
-    generic_error_category(){}
-    const char *   name() const BOOST_SYSTEM_NOEXCEPT;
-    std::string    message( int ev ) const;
-  };
-
-  class system_error_category : public error_category
-  {
-  public:
-    system_error_category(){}
-    const char *        name() const BOOST_SYSTEM_NOEXCEPT;
-    std::string         message( int ev ) const;
-    error_condition     default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT;
-  };
-
-  //  generic_error_category implementation  ---------------------------------//
-
-  const char * generic_error_category::name() const BOOST_SYSTEM_NOEXCEPT
-  {
-    return "generic";
-  }
-
-  std::string generic_error_category::message( int ev ) const
-  {
-    using namespace boost::system::errc;
-#if defined(__PGI)
-      using boost::system::errc::invalid_argument;
-#endif
-      
-    static std::string unknown_err( "Unknown error" );
-  // strerror_r is preferred because it is always thread safe,
-  // however, we fallback to strerror in certain cases because:
-  //   -- Windows doesn't provide strerror_r.
-  //   -- HP and Sun do provide strerror_r on newer systems, but there is
-  //      no way to tell if is available at runtime and in any case their
-  //      versions of strerror are thread safe anyhow.
-  //   -- Linux only sometimes provides strerror_r.
-  //   -- Tru64 provides strerror_r only when compiled -pthread.
-  //   -- VMS doesn't provide strerror_r, but on this platform, strerror is
-  //      thread safe.
-  # if defined(BOOST_WINDOWS_API) || defined(__hpux) || defined(__sun)\
-     || (defined(__linux) && (!defined(__USE_XOPEN2K) || defined(BOOST_SYSTEM_USE_STRERROR)))\
-     || (defined(__osf__) && !defined(_REENTRANT))\
-     || (defined(__INTEGRITY))\
-     || (defined(__vms))\
-     || (defined(__QNXNTO__))
-      const char * c_str = std::strerror( ev );
-      return  c_str
-        ? std::string( c_str )
-        : unknown_err;
-  # else  // use strerror_r
-      char buf[64];
-      char * bp = buf;
-      std::size_t sz = sizeof(buf);
-  #  if defined(__CYGWIN__) || defined(__USE_GNU)
-      // Oddball version of strerror_r
-      const char * c_str = strerror_r( ev, bp, sz );
-      return  c_str
-        ? std::string( c_str )
-        : unknown_err;
-  #  else
-      // POSIX version of strerror_r
-      int result;
-      for (;;)
-      {
-        // strerror_r returns 0 on success, otherwise ERANGE if buffer too small,
-        // invalid_argument if ev not a valid error number
-  #  if defined (__sgi)
-        const char * c_str = strerror( ev );
-        result = 0;
-      return  c_str
-        ? std::string( c_str )
-        : unknown_err;
-  #  else
-        result = strerror_r( ev, bp, sz );
-  #  endif
-        if (result == 0 )
-          break;
-        else
-        {
-  #  if defined(__linux)
-          // Linux strerror_r returns -1 on error, with error number in errno
-          result = errno;
-  #  endif
-          if ( result !=  ERANGE ) break;
-          if ( sz > sizeof(buf) ) std::free( bp );
-          sz *= 2;
-          if ( (bp = static_cast<char*>(std::malloc( sz ))) == 0 )
-            return std::string( "ENOMEM" );
-        }
-      }
-      std::string msg;
-#   ifndef BOOST_NO_EXCEPTIONS
-      try
-#   endif
-      {
-        msg = ( ( result == invalid_argument ) ? "Unknown error" : bp );
-      }
-
-#   ifndef BOOST_NO_EXCEPTIONS
-      // See ticket #2098
-      catch(...)
-      {
-        // just eat the exception
-      }
-#   endif
 
-      if ( sz > sizeof(buf) ) std::free( bp );
-      sz = 0;
-      return msg;
-  #  endif   // else POSIX version of strerror_r
-  # endif  // else use strerror_r
-  }
-  //  system_error_category implementation  --------------------------------// 
-
-  const char * system_error_category::name() const BOOST_SYSTEM_NOEXCEPT
-  {
-    return "system";
-  }
-
-  error_condition system_error_category::default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT
-  {
-    using namespace boost::system::errc;
-#if defined(__PGI)
-      using boost::system::errc::invalid_argument;
+#ifndef BOOST_ERROR_CODE_HEADER_ONLY
+#include <boost/system/detail/error_code.ipp>
 #endif
-
-    switch ( ev )
-    {
-    case 0: return make_error_condition( success );
-# if defined(BOOST_POSIX_API)
-    // POSIX-like O/S -> posix_errno decode table  ---------------------------//
-    case E2BIG: return make_error_condition( argument_list_too_long );
-    case EACCES: return make_error_condition( permission_denied );
-    case EADDRINUSE: return make_error_condition( address_in_use );
-    case EADDRNOTAVAIL: return make_error_condition( address_not_available );
-    case EAFNOSUPPORT: return make_error_condition( address_family_not_supported );
-    case EAGAIN: return make_error_condition( resource_unavailable_try_again );
-#   if EALREADY != EBUSY  //  EALREADY and EBUSY are the same on QNX Neutrino
-    case EALREADY: return make_error_condition( connection_already_in_progress );
-#   endif
-    case EBADF: return make_error_condition( bad_file_descriptor );
-    case EBADMSG: return make_error_condition( bad_message );
-    case EBUSY: return make_error_condition( device_or_resource_busy );
-    case ECANCELED: return make_error_condition( operation_canceled );
-    case ECHILD: return make_error_condition( no_child_process );
-    case ECONNABORTED: return make_error_condition( connection_aborted );
-    case ECONNREFUSED: return make_error_condition( connection_refused );
-    case ECONNRESET: return make_error_condition( connection_reset );
-    case EDEADLK: return make_error_condition( resource_deadlock_would_occur );
-    case EDESTADDRREQ: return make_error_condition( destination_address_required );
-    case EDOM: return make_error_condition( argument_out_of_domain );
-    case EEXIST: return make_error_condition( file_exists );
-    case EFAULT: return make_error_condition( bad_address );
-    case EFBIG: return make_error_condition( file_too_large );
-    case EHOSTUNREACH: return make_error_condition( host_unreachable );
-    case EIDRM: return make_error_condition( identifier_removed );
-    case EILSEQ: return make_error_condition( illegal_byte_sequence );
-    case EINPROGRESS: return make_error_condition( operation_in_progress );
-    case EINTR: return make_error_condition( interrupted );
-    case EINVAL: return make_error_condition( invalid_argument );
-    case EIO: return make_error_condition( io_error );
-    case EISCONN: return make_error_condition( already_connected );
-    case EISDIR: return make_error_condition( is_a_directory );
-    case ELOOP: return make_error_condition( too_many_symbolic_link_levels );
-    case EMFILE: return make_error_condition( too_many_files_open );
-    case EMLINK: return make_error_condition( too_many_links );
-    case EMSGSIZE: return make_error_condition( message_size );
-    case ENAMETOOLONG: return make_error_condition( filename_too_long );
-    case ENETDOWN: return make_error_condition( network_down );
-    case ENETRESET: return make_error_condition( network_reset );
-    case ENETUNREACH: return make_error_condition( network_unreachable );
-    case ENFILE: return make_error_condition( too_many_files_open_in_system );
-    case ENOBUFS: return make_error_condition( no_buffer_space );
-    case ENODATA: return make_error_condition( no_message_available );
-    case ENODEV: return make_error_condition( no_such_device );
-    case ENOENT: return make_error_condition( no_such_file_or_directory );
-    case ENOEXEC: return make_error_condition( executable_format_error );
-    case ENOLCK: return make_error_condition( no_lock_available );
-    case ENOLINK: return make_error_condition( no_link );
-    case ENOMEM: return make_error_condition( not_enough_memory );
-    case ENOMSG: return make_error_condition( no_message );
-    case ENOPROTOOPT: return make_error_condition( no_protocol_option );
-    case ENOSPC: return make_error_condition( no_space_on_device );
-    case ENOSR: return make_error_condition( no_stream_resources );
-    case ENOSTR: return make_error_condition( not_a_stream );
-    case ENOSYS: return make_error_condition( function_not_supported );
-    case ENOTCONN: return make_error_condition( not_connected );
-    case ENOTDIR: return make_error_condition( not_a_directory );
-  # if ENOTEMPTY != EEXIST // AIX treats ENOTEMPTY and EEXIST as the same value
-    case ENOTEMPTY: return make_error_condition( directory_not_empty );
-  # endif // ENOTEMPTY != EEXIST
-  # if ENOTRECOVERABLE != ECONNRESET // the same on some Broadcom chips 
-    case ENOTRECOVERABLE: return make_error_condition( state_not_recoverable ); 
-  # endif // ENOTRECOVERABLE != ECONNRESET 
-    case ENOTSOCK: return make_error_condition( not_a_socket );
-    case ENOTSUP: return make_error_condition( not_supported );
-    case ENOTTY: return make_error_condition( inappropriate_io_control_operation );
-    case ENXIO: return make_error_condition( no_such_device_or_address );
-  # if EOPNOTSUPP != ENOTSUP
-    case EOPNOTSUPP: return make_error_condition( operation_not_supported );
-  # endif // EOPNOTSUPP != ENOTSUP
-    case EOVERFLOW: return make_error_condition( value_too_large );
-  # if EOWNERDEAD != ECONNABORTED // the same on some Broadcom chips 
-    case EOWNERDEAD: return make_error_condition( owner_dead ); 
-  # endif // EOWNERDEAD != ECONNABORTED 
-    case EPERM: return make_error_condition( operation_not_permitted );
-    case EPIPE: return make_error_condition( broken_pipe );
-    case EPROTO: return make_error_condition( protocol_error );
-    case EPROTONOSUPPORT: return make_error_condition( protocol_not_supported );
-    case EPROTOTYPE: return make_error_condition( wrong_protocol_type );
-    case ERANGE: return make_error_condition( result_out_of_range );
-    case EROFS: return make_error_condition( read_only_file_system );
-    case ESPIPE: return make_error_condition( invalid_seek );
-    case ESRCH: return make_error_condition( no_such_process );
-    case ETIME: return make_error_condition( stream_timeout );
-    case ETIMEDOUT: return make_error_condition( timed_out );
-    case ETXTBSY: return make_error_condition( text_file_busy );
-  # if EAGAIN != EWOULDBLOCK
-    case EWOULDBLOCK: return make_error_condition( operation_would_block );
-  # endif // EAGAIN != EWOULDBLOCK
-    case EXDEV: return make_error_condition( cross_device_link );
-  #else
-    // Windows system -> posix_errno decode table  ---------------------------//
-    // see WinError.h comments for descriptions of errors
-    case ERROR_ACCESS_DENIED: return make_error_condition( permission_denied );
-    case ERROR_ALREADY_EXISTS: return make_error_condition( file_exists );
-    case ERROR_BAD_UNIT: return make_error_condition( no_such_device );
-    case ERROR_BUFFER_OVERFLOW: return make_error_condition( filename_too_long );
-    case ERROR_BUSY: return make_error_condition( device_or_resource_busy );
-    case ERROR_BUSY_DRIVE: return make_error_condition( device_or_resource_busy );
-    case ERROR_CANNOT_MAKE: return make_error_condition( permission_denied );
-    case ERROR_CANTOPEN: return make_error_condition( io_error );
-    case ERROR_CANTREAD: return make_error_condition( io_error );
-    case ERROR_CANTWRITE: return make_error_condition( io_error );
-    case ERROR_CURRENT_DIRECTORY: return make_error_condition( permission_denied );
-    case ERROR_DEV_NOT_EXIST: return make_error_condition( no_such_device );
-    case ERROR_DEVICE_IN_USE: return make_error_condition( device_or_resource_busy );
-    case ERROR_DIR_NOT_EMPTY: return make_error_condition( directory_not_empty );
-    case ERROR_DIRECTORY: return make_error_condition( invalid_argument ); // WinError.h: "The directory name is invalid"
-    case ERROR_DISK_FULL: return make_error_condition( no_space_on_device );
-    case ERROR_FILE_EXISTS: return make_error_condition( file_exists );
-    case ERROR_FILE_NOT_FOUND: return make_error_condition( no_such_file_or_directory );
-    case ERROR_HANDLE_DISK_FULL: return make_error_condition( no_space_on_device );
-    case ERROR_INVALID_ACCESS: return make_error_condition( permission_denied );
-    case ERROR_INVALID_DRIVE: return make_error_condition( no_such_device );
-    case ERROR_INVALID_FUNCTION: return make_error_condition( function_not_supported );
-    case ERROR_INVALID_HANDLE: return make_error_condition( invalid_argument );
-    case ERROR_INVALID_NAME: return make_error_condition( invalid_argument );
-    case ERROR_LOCK_VIOLATION: return make_error_condition( no_lock_available );
-    case ERROR_LOCKED: return make_error_condition( no_lock_available );
-    case ERROR_NEGATIVE_SEEK: return make_error_condition( invalid_argument );
-    case ERROR_NOACCESS: return make_error_condition( permission_denied );
-    case ERROR_NOT_ENOUGH_MEMORY: return make_error_condition( not_enough_memory );
-    case ERROR_NOT_READY: return make_error_condition( resource_unavailable_try_again );
-    case ERROR_NOT_SAME_DEVICE: return make_error_condition( cross_device_link );
-    case ERROR_OPEN_FAILED: return make_error_condition( io_error );
-    case ERROR_OPEN_FILES: return make_error_condition( device_or_resource_busy );
-    case ERROR_OPERATION_ABORTED: return make_error_condition( operation_canceled );
-    case ERROR_OUTOFMEMORY: return make_error_condition( not_enough_memory );
-    case ERROR_PATH_NOT_FOUND: return make_error_condition( no_such_file_or_directory );
-    case ERROR_READ_FAULT: return make_error_condition( io_error );
-    case ERROR_RETRY: return make_error_condition( resource_unavailable_try_again );
-    case ERROR_SEEK: return make_error_condition( io_error );
-    case ERROR_SHARING_VIOLATION: return make_error_condition( permission_denied );
-    case ERROR_TOO_MANY_OPEN_FILES: return make_error_condition( too_many_files_open );
-    case ERROR_WRITE_FAULT: return make_error_condition( io_error );
-    case ERROR_WRITE_PROTECT: return make_error_condition( permission_denied );
-    case WSAEACCES: return make_error_condition( permission_denied );
-    case WSAEADDRINUSE: return make_error_condition( address_in_use );
-    case WSAEADDRNOTAVAIL: return make_error_condition( address_not_available );
-    case WSAEAFNOSUPPORT: return make_error_condition( address_family_not_supported );
-    case WSAEALREADY: return make_error_condition( connection_already_in_progress );
-    case WSAEBADF: return make_error_condition( bad_file_descriptor );
-    case WSAECONNABORTED: return make_error_condition( connection_aborted );
-    case WSAECONNREFUSED: return make_error_condition( connection_refused );
-    case WSAECONNRESET: return make_error_condition( connection_reset );
-    case WSAEDESTADDRREQ: return make_error_condition( destination_address_required );
-    case WSAEFAULT: return make_error_condition( bad_address );
-    case WSAEHOSTUNREACH: return make_error_condition( host_unreachable );
-    case WSAEINPROGRESS: return make_error_condition( operation_in_progress );
-    case WSAEINTR: return make_error_condition( interrupted );
-    case WSAEINVAL: return make_error_condition( invalid_argument );
-    case WSAEISCONN: return make_error_condition( already_connected );
-    case WSAEMFILE: return make_error_condition( too_many_files_open );
-    case WSAEMSGSIZE: return make_error_condition( message_size );
-    case WSAENAMETOOLONG: return make_error_condition( filename_too_long );
-    case WSAENETDOWN: return make_error_condition( network_down );
-    case WSAENETRESET: return make_error_condition( network_reset );
-    case WSAENETUNREACH: return make_error_condition( network_unreachable );
-    case WSAENOBUFS: return make_error_condition( no_buffer_space );
-    case WSAENOPROTOOPT: return make_error_condition( no_protocol_option );
-    case WSAENOTCONN: return make_error_condition( not_connected );
-    case WSAENOTSOCK: return make_error_condition( not_a_socket );
-    case WSAEOPNOTSUPP: return make_error_condition( operation_not_supported );
-    case WSAEPROTONOSUPPORT: return make_error_condition( protocol_not_supported );
-    case WSAEPROTOTYPE: return make_error_condition( wrong_protocol_type );
-    case WSAETIMEDOUT: return make_error_condition( timed_out );
-    case WSAEWOULDBLOCK: return make_error_condition( operation_would_block );
-  #endif
-    default: return error_condition( ev, system_category() );
-    }
-  }
-
-# if !defined( BOOST_WINDOWS_API )
-
-  std::string system_error_category::message( int ev ) const
-  {
-    return generic_category().message( ev );
-  }
-# else
-
-  std::string system_error_category::message( int ev ) const
-  {
-# ifndef BOOST_NO_ANSI_APIS  
-    LPVOID lpMsgBuf = 0;
-    DWORD retval = ::FormatMessageA( 
-        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
-        FORMAT_MESSAGE_FROM_SYSTEM | 
-        FORMAT_MESSAGE_IGNORE_INSERTS,
-        NULL,
-        ev,
-        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
-        (LPSTR) &lpMsgBuf,
-        0,
-        NULL 
-    );
-    detail::local_free_on_destruction lfod(lpMsgBuf);
-    if (retval == 0)
-        return std::string("Unknown error");
-        
-    std::string str( static_cast<LPCSTR>(lpMsgBuf) );
-# else  // WinCE workaround
-    LPVOID lpMsgBuf = 0;
-    DWORD retval = ::FormatMessageW( 
-        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
-        FORMAT_MESSAGE_FROM_SYSTEM | 
-        FORMAT_MESSAGE_IGNORE_INSERTS,
-        NULL,
-        ev,
-        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
-        (LPWSTR) &lpMsgBuf,
-        0,
-        NULL 
-    );
-    detail::local_free_on_destruction lfod(lpMsgBuf);
-    if (retval == 0)
-        return std::string("Unknown error");
-    
-    int num_chars = (wcslen( static_cast<LPCWSTR>(lpMsgBuf) ) + 1) * 2;
-    LPSTR narrow_buffer = (LPSTR)_alloca( num_chars );
-    if (::WideCharToMultiByte(CP_ACP, 0, static_cast<LPCWSTR>(lpMsgBuf), -1, narrow_buffer, num_chars, NULL, NULL) == 0)
-        return std::string("Unknown error");
-
-    std::string str( narrow_buffer );
-# endif
-    while ( str.size()
-      && (str[str.size()-1] == '\n' || str[str.size()-1] == '\r') )
-        str.erase( str.size()-1 );
-    if ( str.size() && str[str.size()-1] == '.' ) 
-      { str.erase( str.size()-1 ); }
-    return str;
-  }
-# endif
-
-} // unnamed namespace
-
-
-# ifndef BOOST_SYSTEM_NO_DEPRECATED
-    BOOST_SYSTEM_DECL error_code throws; // "throw on error" special error_code;
-                                         //  note that it doesn't matter if this
-                                         //  isn't initialized before use since
-                                         //  the only use is to take its
-                                         //  address for comparison purposes
-# endif
-
-    BOOST_SYSTEM_DECL const error_category & system_category() BOOST_SYSTEM_NOEXCEPT
-    {
-      static const system_error_category  system_category_const;
-      return system_category_const;
-    }
-
-    BOOST_SYSTEM_DECL const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
-    {
-      static const generic_error_category generic_category_const;
-      return generic_category_const;
-    }
-
-  } // namespace system
-} // namespace boost