passenger 5.3.3 → 5.3.4

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/weak_ptr.hpp

@@ -6,11 +6,11 @@
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov
 //
-// Distributed under 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)
+//  Distributed under 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)
 //
-//  See http://www.boost.org/libs/smart_ptr/weak_ptr.htm for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <memory> // boost.TR1 include order fix
@@ -32,7 +32,7 @@ public:
 
     typedef typename boost::detail::sp_element< T >::type element_type;
 
-    weak_ptr() BOOST_SP_NOEXCEPT : px(0), pn() // never throws in 1.30+
+    BOOST_CONSTEXPR weak_ptr() BOOST_SP_NOEXCEPT : px(0), pn()
     {
     }
 
@@ -59,7 +59,7 @@ public:
 //  The "obvious" converting constructor implementation:
 //
 //  template<class Y>
-//  weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+//  weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn)
 //  {
 //  }
 //
@@ -82,7 +82,7 @@ public:
     weak_ptr( weak_ptr<Y> const & r )
 
 #endif
-    BOOST_NOEXCEPT : px(r.lock().get()), pn(r.pn)
+    BOOST_SP_NOEXCEPT : px(r.lock().get()), pn(r.pn)
     {
         boost::detail::sp_assert_convertible< Y, T >();
     }
@@ -99,7 +99,7 @@ public:
     weak_ptr( weak_ptr<Y> && r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
+    BOOST_SP_NOEXCEPT : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
     {
         boost::detail::sp_assert_convertible< Y, T >();
         r.px = 0;
@@ -132,7 +132,7 @@ public:
     weak_ptr( shared_ptr<Y> const & r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
+    BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
         boost::detail::sp_assert_convertible< Y, T >();
     }
@@ -140,7 +140,7 @@ public:
 #if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
 
     template<class Y>
-    weak_ptr & operator=( weak_ptr<Y> const & r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( weak_ptr<Y> const & r ) BOOST_SP_NOEXCEPT
     {
         boost::detail::sp_assert_convertible< Y, T >();
 
@@ -153,7 +153,7 @@ public:
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
     template<class Y>
-    weak_ptr & operator=( weak_ptr<Y> && r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( weak_ptr<Y> && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< weak_ptr<Y> && >( r ) ).swap( *this );
         return *this;
@@ -162,7 +162,7 @@ public:
 #endif
 
     template<class Y>
-    weak_ptr & operator=( shared_ptr<Y> const & r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( shared_ptr<Y> const & r ) BOOST_SP_NOEXCEPT
     {
         boost::detail::sp_assert_convertible< Y, T >();
 
@@ -174,50 +174,50 @@ public:
 
 #endif
 
-    shared_ptr<T> lock() const BOOST_NOEXCEPT
+    shared_ptr<T> lock() const BOOST_SP_NOEXCEPT
     {
         return shared_ptr<T>( *this, boost::detail::sp_nothrow_tag() );
     }
 
-    long use_count() const BOOST_NOEXCEPT
+    long use_count() const BOOST_SP_NOEXCEPT
     {
         return pn.use_count();
     }
 
-    bool expired() const BOOST_NOEXCEPT
+    bool expired() const BOOST_SP_NOEXCEPT
     {
         return pn.use_count() == 0;
     }
 
-    bool _empty() const // extension, not in std::weak_ptr
+    bool _empty() const BOOST_SP_NOEXCEPT // extension, not in std::weak_ptr
     {
         return pn.empty();
     }
 
-    void reset() BOOST_NOEXCEPT // never throws in 1.30+
+    void reset() BOOST_SP_NOEXCEPT
     {
         this_type().swap(*this);
     }
 
-    void swap(this_type & other) BOOST_NOEXCEPT
+    void swap(this_type & other) BOOST_SP_NOEXCEPT
     {
         std::swap(px, other.px);
         pn.swap(other.pn);
     }
 
     template<typename Y>
-    void _internal_aliasing_assign(weak_ptr<Y> const & r, element_type * px2)
+    void _internal_aliasing_assign(weak_ptr<Y> const & r, element_type * px2) BOOST_SP_NOEXCEPT
     {
         px = px2;
         pn = r.pn;
     }
 
-    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
+    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
     {
         return pn < rhs.pn;
     }
 
-    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
+    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
     {
         return pn < rhs.pn;
     }
@@ -239,12 +239,12 @@ private:
 
 };  // weak_ptr
 
-template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) BOOST_NOEXCEPT
+template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.owner_before( b );
 }
 
-template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) BOOST_NOEXCEPT
+template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) BOOST_SP_NOEXCEPT
 {
     a.swap(b);
 }

data/src/cxx_supportlib/vendor-modified/boost/system/detail/error_code.ipp

@@ -1,4 +1,4 @@
-//  error_code support implementation file  ----------------------------------//
+//  error_code support implementation file  --------------------------------------------//
 
 //  Copyright Beman Dawes 2002, 2006
 //  Copyright (c) Microsoft Corporation 2014
@@ -7,7 +7,7 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-//----------------------------------------------------------------------------//
+//--------------------------------------------------------------------------------------//
 
 #include <boost/config/warning_disable.hpp>
 
@@ -21,7 +21,9 @@
 #include <cstring> // for strerror/strerror_r
 
 # if defined( BOOST_WINDOWS_API )
-#   include <windows.h>
+#   include <boost/winapi/error_codes.hpp>
+#   include <boost/winapi/error_handling.hpp>
+#   include <boost/winapi/character_code_conversion.hpp>
 #   if !BOOST_PLAT_WINDOWS_RUNTIME
 #     include <boost/system/detail/local_free_on_destruction.hpp>
 #   endif
@@ -30,16 +32,16 @@
 #   endif
 # endif
 
-//----------------------------------------------------------------------------//
+//--------------------------------------------------------------------------------------//
 namespace boost
 {
     namespace system
     {
 
-namespace
+namespace detail
 {
 
-  //  standard error categories  ---------------------------------------------//
+  //  standard error categories  -------------------------------------------------------//
 
   class generic_error_category : public error_category
   {
@@ -58,14 +60,20 @@ namespace
     error_condition     default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT;
   };
 
+#ifdef BOOST_ERROR_CODE_HEADER_ONLY
+# define BOOST_SYSTEM_INLINE inline
+#else
+# define BOOST_SYSTEM_INLINE
+#endif
+
   //  generic_error_category implementation  ---------------------------------//
 
-  const char * generic_error_category::name() const BOOST_SYSTEM_NOEXCEPT
+  BOOST_SYSTEM_INLINE const char * generic_error_category::name() const BOOST_SYSTEM_NOEXCEPT
   {
     return "generic";
   }
 
-  std::string generic_error_category::message( int ev ) const
+  BOOST_SYSTEM_INLINE std::string generic_error_category::message( int ev ) const
   {
     using namespace boost::system::errc;
 #if defined(__PGI)
@@ -84,7 +92,8 @@ namespace
   //   -- 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(__linux) && (!defined(__USE_XOPEN2K)\
+     || defined(BOOST_SYSTEM_USE_STRERROR)))\
      || (defined(__osf__) && !defined(_REENTRANT))\
      || (defined(__INTEGRITY))\
      || (defined(__vms))\
@@ -151,19 +160,19 @@ namespace
 #   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  --------------------------------//
+  //  system_error_category implementation  --------------------------------------------//
 
-  const char * system_error_category::name() const BOOST_SYSTEM_NOEXCEPT
+  BOOST_SYSTEM_INLINE 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
+  BOOST_SYSTEM_INLINE error_condition system_error_category::default_error_condition( int ev ) const
+    BOOST_SYSTEM_NOEXCEPT
   {
     using namespace boost::system::errc;
 #if defined(__PGI)
@@ -179,13 +188,19 @@ namespace
       if ( HRESULT_FACILITY( ev ) == FACILITY_WIN32 )
         ev = HRESULT_CODE( ev );
 #   endif
+# endif
+
+# if defined(BOOST_WINDOWS_API)
+
+    using namespace boost::winapi; // for error codes
+
 # endif
 
     switch ( ev )
     {
     case 0: return make_error_condition( success );
 # if defined(BOOST_POSIX_API)
-    // POSIX-like O/S -> posix_errno decode table  ---------------------------//
+    // 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 );
@@ -279,80 +294,81 @@ namespace
   #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 );
+    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() );
     }
@@ -360,26 +376,27 @@ namespace
 
 # if !defined( BOOST_WINDOWS_API )
 
-  std::string system_error_category::message( int ev ) const
+  BOOST_SYSTEM_INLINE std::string system_error_category::message( int ev ) const
   {
     return generic_category().message( ev );
   }
 # else
 
-  std::string system_error_category::message( int ev ) const
+  BOOST_SYSTEM_INLINE std::string system_error_category::message( int ev ) const
   {
 #if defined(UNDER_CE) || BOOST_PLAT_WINDOWS_RUNTIME || defined(BOOST_NO_ANSI_APIS)
     std::wstring buf(128, wchar_t());
     for (;;)
     {
-        DWORD retval = ::FormatMessageW(
-            FORMAT_MESSAGE_FROM_SYSTEM |
-            FORMAT_MESSAGE_IGNORE_INSERTS,
+        boost::winapi::DWORD_ retval = boost::winapi::FormatMessageW(
+            boost::winapi::FORMAT_MESSAGE_FROM_SYSTEM_ |
+            boost::winapi::FORMAT_MESSAGE_IGNORE_INSERTS_,
             NULL,
             ev,
-            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+            boost::winapi::MAKELANGID_(boost::winapi::LANG_NEUTRAL_,
+            boost::winapi::SUBLANG_DEFAULT_), // Default language
             &buf[0],
-            buf.size(),
+            static_cast<boost::winapi::DWORD_>(buf.size()),
             NULL
         );
         
@@ -388,7 +405,8 @@ namespace
             buf.resize(retval);
             break;
         }
-        else if ( ::GetLastError() != ERROR_INSUFFICIENT_BUFFER )
+        else if (boost::winapi::GetLastError() !=
+          boost::winapi::ERROR_INSUFFICIENT_BUFFER_)
         {
             return std::string("Unknown error");
         }
@@ -398,24 +416,33 @@ namespace
         }
     }
     
-    int num_chars = (buf.size() + 1) * 2;
-    LPSTR narrow_buffer = (LPSTR)_alloca( num_chars );
-    if (::WideCharToMultiByte(CP_ACP, 0, buf.c_str(), -1, narrow_buffer, num_chars, NULL, NULL) == 0)
+    int num_chars = static_cast<int>(buf.size() + 1) * 2;
+
+    boost::winapi::LPSTR_ narrow_buffer =
+#if defined(__GNUC__)
+      (boost::winapi::LPSTR_)__builtin_alloca(num_chars);
+#else
+      (boost::winapi::LPSTR_)_alloca(num_chars);
+#endif
+
+    if (boost::winapi::WideCharToMultiByte(boost::winapi::CP_ACP_, 0,
+      buf.c_str(), -1, narrow_buffer, num_chars, NULL, NULL) == 0)
     {
         return std::string("Unknown error");
     }
 
     std::string str( narrow_buffer );
 #else
-    LPVOID lpMsgBuf = 0;
-    DWORD retval = ::FormatMessageA(
-        FORMAT_MESSAGE_ALLOCATE_BUFFER |
-        FORMAT_MESSAGE_FROM_SYSTEM |
-        FORMAT_MESSAGE_IGNORE_INSERTS,
+    boost::winapi::LPVOID_ lpMsgBuf = 0;
+    boost::winapi::DWORD_ retval = boost::winapi::FormatMessageA(
+        boost::winapi::FORMAT_MESSAGE_ALLOCATE_BUFFER_ |
+        boost::winapi::FORMAT_MESSAGE_FROM_SYSTEM_ |
+        boost::winapi::FORMAT_MESSAGE_IGNORE_INSERTS_,
         NULL,
         ev,
-        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
-        (LPSTR) &lpMsgBuf,
+        boost::winapi::MAKELANGID_(boost::winapi::LANG_NEUTRAL_,
+        boost::winapi::SUBLANG_DEFAULT_), // Default language
+        (boost::winapi::LPSTR_) &lpMsgBuf,
         0,
         NULL
     );
@@ -423,7 +450,7 @@ namespace
     if (retval == 0)
         return std::string("Unknown error");
 
-    std::string str( static_cast<LPCSTR>(lpMsgBuf) );
+    std::string str(static_cast<boost::winapi::LPCSTR_>(lpMsgBuf));
 # endif
     while ( str.size()
       && (str[str.size()-1] == '\n' || str[str.size()-1] == '\r') )
@@ -434,10 +461,12 @@ namespace
   }
 # endif
 
-} // unnamed namespace
+#undef BOOST_SYSTEM_INLINE
+
+} // namespace detail
 
 
-# ifndef BOOST_SYSTEM_NO_DEPRECATED
+# ifdef BOOST_SYSTEM_ENABLE_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
@@ -453,13 +482,13 @@ namespace
 
     BOOST_SYSTEM_LINKAGE const error_category & system_category() BOOST_SYSTEM_NOEXCEPT
     {
-      static const system_error_category  system_category_const;
+      static const detail::system_error_category  system_category_const;
       return system_category_const;
     }
 
     BOOST_SYSTEM_LINKAGE const error_category & generic_category() BOOST_SYSTEM_NOEXCEPT
     {
-      static const generic_error_category generic_category_const;
+      static const detail::generic_error_category generic_category_const;
       return generic_category_const;
     }