add boost on mac

macx64/include/boost/system/detail/config.hpp

@@ -0,0 +1,57 @@
+#ifndef BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED
+#define BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED
+
+// Copyright 2018 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)
+//
+// See http://www.boost.org/libs/system for documentation.
+
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+
+// BOOST_SYSTEM_HAS_SYSTEM_ERROR
+
+#if !defined(BOOST_NO_CXX11_HDR_SYSTEM_ERROR)
+# define BOOST_SYSTEM_HAS_SYSTEM_ERROR
+#endif
+
+#if BOOST_WORKAROUND(BOOST_GCC, < 40600)
+// g++ 4.4's <map> is not good enough
+# undef BOOST_SYSTEM_HAS_SYSTEM_ERROR
+#endif
+
+// BOOST_SYSTEM_NOEXCEPT
+// Retained for backward compatibility
+
+#define BOOST_SYSTEM_NOEXCEPT BOOST_NOEXCEPT
+
+// BOOST_SYSTEM_HAS_CONSTEXPR
+
+#if !defined(BOOST_NO_CXX14_CONSTEXPR)
+# define BOOST_SYSTEM_HAS_CONSTEXPR
+#endif
+
+#if BOOST_WORKAROUND(BOOST_GCC, < 60000)
+# undef BOOST_SYSTEM_HAS_CONSTEXPR
+#endif
+
+#if defined(BOOST_SYSTEM_HAS_CONSTEXPR)
+# define BOOST_SYSTEM_CONSTEXPR constexpr
+#else
+# define BOOST_SYSTEM_CONSTEXPR
+#endif
+
+// BOOST_SYSTEM_REQUIRE_CONST_INIT
+
+#define BOOST_SYSTEM_REQUIRE_CONST_INIT
+
+#if defined(__has_cpp_attribute)
+#if __has_cpp_attribute(clang::require_constant_initialization)
+# undef BOOST_SYSTEM_REQUIRE_CONST_INIT
+# define BOOST_SYSTEM_REQUIRE_CONST_INIT [[clang::require_constant_initialization]]
+#endif
+#endif
+
+#endif // BOOST_SYSTEM_DETAIL_CONFIG_HPP_INCLUDED

macx64/include/boost/system/detail/generic_category.hpp

@@ -0,0 +1,101 @@
+// Implementation details of generic_error_category
+//
+// Copyright 2018 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)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <cstring>
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace detail
+{
+
+#if defined(__GLIBC__)
+
+// glibc has two incompatible strerror_r definitions
+
+inline char const * strerror_r_helper( char const * r, char const * ) BOOST_NOEXCEPT
+{
+    return r;
+}
+
+inline char const * strerror_r_helper( int r, char const * buffer ) BOOST_NOEXCEPT
+{
+    return r == 0? buffer: "Unknown error";
+}
+
+inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
+{
+    return strerror_r_helper( strerror_r( ev, buffer, len ), buffer );
+}
+
+inline std::string generic_error_category_message( int ev )
+{
+    char buffer[ 128 ];
+    return generic_error_category_message( ev, buffer, sizeof( buffer ) );
+}
+
+#else
+
+// std::strerror is thread-safe on everything else, incl. Windows
+
+# if defined( BOOST_MSVC )
+#  pragma warning( push )
+#  pragma warning( disable: 4996 )
+# elif defined(__clang__) && defined(__has_warning)
+#  pragma clang diagnostic push
+#  if __has_warning("-Wdeprecated-declarations")
+#   pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#  endif
+# endif
+
+inline std::string generic_error_category_message( int ev )
+{
+    char const * m = std::strerror( ev );
+    return m? m: "Unknown error";
+}
+
+inline char const * generic_error_category_message( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
+{
+    if( len == 0 )
+    {
+        return buffer;
+    }
+
+    if( len == 1 )
+    {
+        buffer[0] = 0;
+        return buffer;
+    }
+
+    char const * m = std::strerror( ev );
+
+    if( m == 0 ) return "Unknown error";
+
+    std::strncpy( buffer, m, len - 1 );
+    buffer[ len-1 ] = 0;
+
+    return buffer;
+}
+
+# if defined( BOOST_MSVC )
+#  pragma warning( pop )
+# elif defined(__clang__) && defined(__has_warning)
+#  pragma clang diagnostic pop
+# endif
+
+#endif
+
+} // namespace detail
+
+} // namespace system
+
+} // namespace boost

macx64/include/boost/system/detail/std_interoperability.hpp

@@ -0,0 +1,141 @@
+// Support for interoperability between Boost.System and <system_error>
+//
+// Copyright 2018 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)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <system_error>
+#include <map>
+#include <memory>
+
+//
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace detail
+{
+
+class BOOST_SYMBOL_VISIBLE std_category: public std::error_category
+{
+private:
+
+    boost::system::error_category const * pc_;
+
+public:
+
+    explicit std_category( boost::system::error_category const * pc ): pc_( pc )
+    {
+    }
+
+    virtual const char * name() const BOOST_NOEXCEPT
+    {
+        return pc_->name();
+    }
+
+    virtual std::string message( int ev ) const
+    {
+        return pc_->message( ev );
+    }
+
+    virtual std::error_condition default_error_condition( int ev ) const BOOST_NOEXCEPT
+    {
+        return pc_->default_error_condition( ev );
+    }
+
+    virtual bool equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT;
+    virtual bool equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT;
+};
+
+inline std::error_category const & to_std_category( boost::system::error_category const & cat )
+{
+    typedef std::map< boost::system::error_category const *, std::unique_ptr<std_category> > map_type;
+
+    static map_type map_;
+
+    map_type::iterator i = map_.find( &cat );
+
+    if( i == map_.end() )
+    {
+        std::unique_ptr<std_category> p( new std_category( &cat ) );
+
+        std::pair<map_type::iterator, bool> r = map_.insert( map_type::value_type( &cat, std::move( p ) ) );
+
+        i = r.first;
+    }
+
+    return *i->second;
+}
+
+inline bool std_category::equivalent( int code, const std::error_condition & condition ) const BOOST_NOEXCEPT
+{
+    if( condition.category() == *this )
+    {
+        boost::system::error_condition bn( condition.value(), *pc_ );
+        return pc_->equivalent( code, bn );
+    }
+    else if( condition.category() == std::generic_category() || condition.category() == boost::system::generic_category() )
+    {
+        boost::system::error_condition bn( condition.value(), boost::system::generic_category() );
+        return pc_->equivalent( code, bn );
+    }
+
+#ifndef BOOST_NO_RTTI
+
+    else if( std_category const* pc2 = dynamic_cast< std_category const* >( &condition.category() ) )
+    {
+        boost::system::error_condition bn( condition.value(), *pc2->pc_ );
+        return pc_->equivalent( code, bn );
+    }
+
+#endif
+
+    else
+    {
+        return default_error_condition( code ) == condition;
+    }
+}
+
+inline bool std_category::equivalent( const std::error_code & code, int condition ) const BOOST_NOEXCEPT
+{
+    if( code.category() == *this )
+    {
+        boost::system::error_code bc( code.value(), *pc_ );
+        return pc_->equivalent( bc, condition );
+    }
+    else if( code.category() == std::generic_category() || code.category() == boost::system::generic_category() )
+    {
+        boost::system::error_code bc( code.value(), boost::system::generic_category() );
+        return pc_->equivalent( bc, condition );
+    }
+
+#ifndef BOOST_NO_RTTI
+
+    else if( std_category const* pc2 = dynamic_cast< std_category const* >( &code.category() ) )
+    {
+        boost::system::error_code bc( code.value(), *pc2->pc_ );
+        return pc_->equivalent( bc, condition );
+    }
+#endif
+
+    else if( *pc_ == boost::system::generic_category() )
+    {
+        return std::generic_category().equivalent( code, condition );
+    }
+    else
+    {
+        return false;
+    }
+}
+
+} // namespace detail
+
+} // namespace system
+
+} // namespace boost

macx64/include/boost/system/detail/system_category_posix.hpp

@@ -0,0 +1,132 @@
+// POSIX-specific implementation details of system_error_category
+//
+// Copyright 2018 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)
+//
+// See library home page at http://www.boost.org/libs/system
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace detail
+{
+
+inline bool is_generic_value( int ev ) BOOST_NOEXCEPT
+{
+    using namespace errc;
+
+    static int const gen[] =
+    {
+        success,
+        address_family_not_supported,
+        address_in_use,
+        address_not_available,
+        already_connected,
+        argument_list_too_long,
+        argument_out_of_domain,
+        bad_address,
+        bad_file_descriptor,
+        bad_message,
+        broken_pipe,
+        connection_aborted,
+        connection_already_in_progress,
+        connection_refused,
+        connection_reset,
+        cross_device_link,
+        destination_address_required,
+        device_or_resource_busy,
+        directory_not_empty,
+        executable_format_error,
+        file_exists,
+        file_too_large,
+        filename_too_long,
+        function_not_supported,
+        host_unreachable,
+        identifier_removed,
+        illegal_byte_sequence,
+        inappropriate_io_control_operation,
+        interrupted,
+        invalid_argument,
+        invalid_seek,
+        io_error,
+        is_a_directory,
+        message_size,
+        network_down,
+        network_reset,
+        network_unreachable,
+        no_buffer_space,
+        no_child_process,
+        no_link,
+        no_lock_available,
+        no_message_available,
+        no_message,
+        no_protocol_option,
+        no_space_on_device,
+        no_stream_resources,
+        no_such_device_or_address,
+        no_such_device,
+        no_such_file_or_directory,
+        no_such_process,
+        not_a_directory,
+        not_a_socket,
+        not_a_stream,
+        not_connected,
+        not_enough_memory,
+        not_supported,
+        operation_canceled,
+        operation_in_progress,
+        operation_not_permitted,
+        operation_not_supported,
+        operation_would_block,
+        owner_dead,
+        permission_denied,
+        protocol_error,
+        protocol_not_supported,
+        read_only_file_system,
+        resource_deadlock_would_occur,
+        resource_unavailable_try_again,
+        result_out_of_range,
+        state_not_recoverable,
+        stream_timeout,
+        text_file_busy,
+        timed_out,
+        too_many_files_open_in_system,
+        too_many_files_open,
+        too_many_links,
+        too_many_symbolic_link_levels,
+        value_too_large,
+        wrong_protocol_type
+    };
+
+    int const n = sizeof( gen ) / sizeof( gen[0] );
+
+    for( int i = 0; i < n; ++i )
+    {
+        if( ev == gen[ i ] ) return true;
+    }
+
+    return false;
+}
+
+inline error_condition system_category_default_error_condition_posix( int ev ) BOOST_NOEXCEPT
+{
+    if( is_generic_value( ev ) )
+    {
+        return error_condition( ev, generic_category() );
+    }
+    else
+    {
+        return error_condition( ev, system_category() );
+    }
+}
+
+} // namespace detail
+
+} // namespace system
+
+} // namespace boost

macx64/include/boost/system/detail/system_category_win32.hpp

@@ -0,0 +1,340 @@
+// Windows implementation of system_error_category
+//
+// Copyright Beman Dawes 2002, 2006
+// Copyright (c) Microsoft Corporation 2014
+// Copyright 2018 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)
+//
+// See library home page at http://www.boost.org/libs/system
+
+#include <boost/winapi/error_codes.hpp>
+#include <boost/winapi/error_handling.hpp>
+#include <boost/winapi/character_code_conversion.hpp>
+#include <boost/winapi/local_memory.hpp>
+#include <cstdio>
+
+//
+
+namespace boost
+{
+
+namespace system
+{
+
+namespace detail
+{
+
+#if ( defined(_MSC_VER) && _MSC_VER < 1900 ) || ( defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) )
+
+inline char const * unknown_message_win32( int ev, char * buffer, std::size_t len )
+{
+# if defined( BOOST_MSVC )
+#  pragma warning( push )
+#  pragma warning( disable: 4996 )
+# endif
+
+    _snprintf( buffer, len - 1, "Unknown error (%d)", ev );
+
+    buffer[ len - 1 ] = 0;
+    return buffer;
+
+# if defined( BOOST_MSVC )
+#  pragma warning( pop )
+# endif
+}
+
+#else
+
+inline char const * unknown_message_win32( int ev, char * buffer, std::size_t len )
+{
+    std::snprintf( buffer, len, "Unknown error (%d)", ev );
+    return buffer;
+}
+
+#endif
+
+inline boost::winapi::UINT_ message_cp_win32()
+{
+#if defined(BOOST_SYSTEM_USE_UTF8)
+
+    return boost::winapi::CP_UTF8_;
+
+#else
+
+    return boost::winapi::CP_ACP_;
+
+#endif
+}
+
+inline char const * system_category_message_win32( int ev, char * buffer, std::size_t len ) BOOST_NOEXCEPT
+{
+    if( len == 0 )
+    {
+        return buffer;
+    }
+
+    if( len == 1 )
+    {
+        buffer[0] = 0;
+        return buffer;
+    }
+
+    boost::winapi::UINT_ const code_page = message_cp_win32();
+
+    int r = 0;
+
+#if !defined(BOOST_NO_ANSI_APIS)
+
+    if( code_page == boost::winapi::CP_ACP_ )
+    {
+        using namespace boost::winapi;
+
+        DWORD_ retval = boost::winapi::FormatMessageA(
+            FORMAT_MESSAGE_FROM_SYSTEM_ | FORMAT_MESSAGE_IGNORE_INSERTS_,
+            NULL,
+            ev,
+            MAKELANGID_( LANG_NEUTRAL_, SUBLANG_DEFAULT_ ), // Default language
+            buffer,
+            static_cast<DWORD_>( len ),
+            NULL
+        );
+
+        r = static_cast<int>( retval );
+    }
+    else
+
+#endif
+
+    {
+        using namespace boost::winapi;
+
+        wchar_t * lpMsgBuf = 0;
+
+        DWORD_ retval = boost::winapi::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
+        );
+
+        if( retval != 0 )
+        {
+            r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, buffer, static_cast<int>( len ), NULL, NULL );
+            boost::winapi::LocalFree( lpMsgBuf );
+            if ( r != 0 ) --r; // exclude null terminator
+        }
+    }
+
+    if( r == 0 )
+    {
+        return unknown_message_win32( ev, buffer, len );
+    }
+
+    while( r > 0 && ( buffer[ r-1 ] == '\n' || buffer[ r-1 ] == '\r' ) )
+    {
+        buffer[ --r ] = 0;
+    }
+
+    if( r > 0 && buffer[ r-1 ] == '.' )
+    {
+        buffer[ --r ] = 0;
+    }
+
+    return buffer;
+}
+
+struct local_free
+{
+    void * p_;
+
+    ~local_free()
+    {
+        boost::winapi::LocalFree( p_ );
+    }
+};
+
+inline std::string unknown_message_win32( int ev )
+{
+    char buffer[ 38 ];
+    return unknown_message_win32( ev, buffer, sizeof( buffer ) );
+}
+
+inline std::string system_category_message_win32( int ev )
+{
+    using namespace boost::winapi;
+
+    wchar_t * lpMsgBuf = 0;
+
+    DWORD_ retval = boost::winapi::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
+    );
+
+    if( retval == 0 )
+    {
+        return unknown_message_win32( ev );
+    }
+
+    local_free lf_ = { lpMsgBuf };
+    (void)lf_;
+
+    UINT_ const code_page = message_cp_win32();
+
+    int r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, 0, 0, NULL, NULL );
+
+    if( r == 0 )
+    {
+        return unknown_message_win32( ev );
+    }
+
+    std::string buffer( r, char() );
+
+    r = boost::winapi::WideCharToMultiByte( code_page, 0, lpMsgBuf, -1, &buffer[0], r, NULL, NULL );
+
+    if( r == 0 )
+    {
+        return unknown_message_win32( ev );
+    }
+
+    --r; // exclude null terminator
+
+    while( r > 0 && ( buffer[ r-1 ] == '\n' || buffer[ r-1 ] == '\r' ) )
+    {
+        --r;
+    }
+
+    if( r > 0 && buffer[ r-1 ] == '.' )
+    {
+        --r;
+    }
+
+    buffer.resize( r );
+
+    return buffer;
+}
+
+inline error_condition system_category_default_error_condition_win32( int ev ) BOOST_NOEXCEPT
+{
+    // When using the Windows Runtime, most system errors are reported as HRESULTs.
+    // We want to map the common Win32 errors to their equivalent error condition,
+    // whether or not they are reported via an HRESULT.
+
+#define BOOST_SYSTEM_FAILED(hr)           ((hr) < 0)
+#define BOOST_SYSTEM_HRESULT_FACILITY(hr) (((hr) >> 16) & 0x1fff)
+#define BOOST_SYSTEM_HRESULT_CODE(hr)     ((hr) & 0xFFFF)
+#define BOOST_SYSTEM_FACILITY_WIN32       7
+
+    if( BOOST_SYSTEM_FAILED( ev ) && BOOST_SYSTEM_HRESULT_FACILITY( ev ) == BOOST_SYSTEM_FACILITY_WIN32 )
+    {
+        ev = BOOST_SYSTEM_HRESULT_CODE( ev );
+    }
+
+#undef BOOST_SYSTEM_FAILED
+#undef BOOST_SYSTEM_HRESULT_FACILITY
+#undef BOOST_SYSTEM_HRESULT_CODE
+#undef BOOST_SYSTEM_FACILITY_WIN32
+
+    using namespace boost::winapi;
+    using namespace errc;
+
+    // Windows system -> posix_errno decode table
+    // see WinError.h comments for descriptions of errors
+
+    switch ( ev )
+    {
+    case 0: return make_error_condition( success );
+
+    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 );
+
+    default: return error_condition( ev, system_category() );
+    }
+}
+
+} // namespace detail
+
+} // namespace system
+
+} // namespace boost