Index: api_config.hpp =================================================================== --- api_config.hpp (revision 75797) +++ api_config.hpp (working copy) @@ -33,13 +33,12 @@ // Standalone MinGW and all other known Windows compilers do predefine _WIN32 // Compilers that predefine _WIN32 or __MINGW32__ do so for Windows 64-bit builds too. -# if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32) ) +# if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32)) # define BOOST_SYSTEM_WINDOWS_API # else # define BOOST_SYSTEM_POSIX_API # endif -//# if (defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__)) # if defined(_WIN32) || defined(__CYGWIN__) // Windows default, including MinGW and Cygwin # define BOOST_WINDOWS_API # else Index: config.hpp =================================================================== --- config.hpp (revision 75797) +++ config.hpp (working copy) @@ -11,11 +11,6 @@ #define BOOST_SYSTEM_CONFIG_HPP #include - -#if defined(BOOST_SYSTEM_SOURCE) && !defined(BOOST_USE_WINDOWS_H) -#define BOOST_USE_WINDOWS_H -#endif - #include // for BOOST_SYSTEM_POSIX_API or BOOST_SYSTEM_WINDOWS_API #ifdef BOOST_SYSTEM_INLINED Index: cygwin_error.hpp =================================================================== --- cygwin_error.hpp (revision 75797) +++ cygwin_error.hpp (working copy) @@ -7,8 +7,8 @@ // See library home page at http://www.boost.org/libs/system -#ifndef BOOST_SYSTEM_CYGWIN_ERROR_HPP -#define BOOST_SYSTEM_CYGWIN_ERROR_HPP +#ifndef BOOST_CYGWIN_ERROR_HPP +#define BOOST_CYGWIN_ERROR_HPP // This header is effectively empty for compiles on operating systems where // it is not applicable. @@ -53,4 +53,4 @@ #endif // __CYGWIN__ -#endif // BOOST_SYSTEM_CYGWIN_ERROR_HPP +#endif // BOOST_CYGWIN_ERROR_HPP Index: detail/inlined/error_code.hpp =================================================================== --- detail/inlined/error_code.hpp (revision 0) +++ detail/inlined/error_code.hpp (revision 0) @@ -0,0 +1,431 @@ +// error_code support implementation file ----------------------------------// + +// Copyright Beman Dawes 2002, 2006 + +// 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 + +//----------------------------------------------------------------------------// + +#ifndef BOOST_SYSTEM_DETAIL_INLINED_ERROR_CODE_HPP +#define BOOST_SYSTEM_DETAIL_INLINED_ERROR_CODE_HPP + +#include + +#include +#ifndef BOOST_SYSTEM_INLINED +#include +#endif +#include +#include +#include +#include + +//using namespace boost::system; +//using namespace boost::system::errc; + +#include // for strerror/strerror_r + +# if defined( BOOST_SYSTEM_WINDOWS_API ) +# include +# include "local_free_on_destruction.hpp" +# ifndef ERROR_INCORRECT_SIZE +# define ERROR_INCORRECT_SIZE ERROR_BAD_ARGUMENTS +# endif +# endif + +//----------------------------------------------------------------------------// + +namespace boost +{ +namespace system +{ +namespace system_detail +{ +#if defined(__PGI) + using boost::system::errc::invalid_argument; +#endif + // standard error categories ---------------------------------------------// + + class generic_error_category : public error_category + { + public: + generic_error_category(){} + BOOST_SYSTEM_INLINE const char * name() const; + BOOST_SYSTEM_INLINE std::string message( int ev ) const; + }; + + class system_error_category : public error_category + { + public: + system_error_category(){} + BOOST_SYSTEM_INLINE const char * name() const; + BOOST_SYSTEM_INLINE std::string message( int ev ) const; + BOOST_SYSTEM_INLINE error_condition default_error_condition( int ev ) const; + }; + + // generic_error_category implementation ---------------------------------// + + const char * generic_error_category::name() const + { + return "generic"; + } + + std::string generic_error_category::message( int ev ) const + { + 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_SYSTEM_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(std::malloc( sz ))) == 0 ) + return std::string( "ENOMEM" ); + } + } + std::string msg; + try + { + 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 + { + return "system"; + } + + error_condition system_error_category::default_error_condition( int ev ) const + { + switch ( ev ) + { + case 0: return make_error_condition( errc::success ); +# if defined(BOOST_SYSTEM_POSIX_API) + // POSIX-like O/S -> posix_errno decode table ---------------------------// + case E2BIG: return make_error_condition( errc::argument_list_too_long ); + case EACCES: return make_error_condition( errc::permission_denied ); + case EADDRINUSE: return make_error_condition( errc::address_in_use ); + case EADDRNOTAVAIL: return make_error_condition( errc::address_not_available ); + case EAFNOSUPPORT: return make_error_condition( errc::address_family_not_supported ); + case EAGAIN: return make_error_condition( errc::resource_unavailable_try_again ); +# if EALREADY != EBUSY // EALREADY and EBUSY are the same on QNX Neutrino + case EALREADY: return make_error_condition( errc::connection_already_in_progress ); +# endif + case EBADF: return make_error_condition( errc::bad_file_descriptor ); + case EBADMSG: return make_error_condition( errc::bad_message ); + case EBUSY: return make_error_condition( errc::device_or_resource_busy ); + case ECANCELED: return make_error_condition( errc::operation_canceled ); + case ECHILD: return make_error_condition( errc::no_child_process ); + case ECONNABORTED: return make_error_condition( errc::connection_aborted ); + case ECONNREFUSED: return make_error_condition( errc::connection_refused ); + case ECONNRESET: return make_error_condition( errc::connection_reset ); + case EDEADLK: return make_error_condition( errc::resource_deadlock_would_occur ); + case EDESTADDRREQ: return make_error_condition( errc::destination_address_required ); + case EDOM: return make_error_condition( errc::argument_out_of_domain ); + case EEXIST: return make_error_condition( errc::file_exists ); + case EFAULT: return make_error_condition( errc::bad_address ); + case EFBIG: return make_error_condition( errc::file_too_large ); + case EHOSTUNREACH: return make_error_condition( errc::host_unreachable ); + case EIDRM: return make_error_condition( errc::identifier_removed ); + case EILSEQ: return make_error_condition( errc::illegal_byte_sequence ); + case EINPROGRESS: return make_error_condition( errc::operation_in_progress ); + case EINTR: return make_error_condition( errc::interrupted ); + case EINVAL: return make_error_condition( errc::invalid_argument ); + case EIO: return make_error_condition( errc::io_error ); + case EISCONN: return make_error_condition( errc::already_connected ); + case EISDIR: return make_error_condition( errc::is_a_directory ); + case ELOOP: return make_error_condition( errc::too_many_symbolic_link_levels ); + case EMFILE: return make_error_condition( errc::too_many_files_open ); + case EMLINK: return make_error_condition( errc::too_many_links ); + case EMSGSIZE: return make_error_condition( errc::message_size ); + case ENAMETOOLONG: return make_error_condition( errc::filename_too_long ); + case ENETDOWN: return make_error_condition( errc::network_down ); + case ENETRESET: return make_error_condition( errc::network_reset ); + case ENETUNREACH: return make_error_condition( errc::network_unreachable ); + case ENFILE: return make_error_condition( errc::too_many_files_open_in_system ); + case ENOBUFS: return make_error_condition( errc::no_buffer_space ); + case ENODATA: return make_error_condition( errc::no_message_available ); + case ENODEV: return make_error_condition( errc::no_such_device ); + case ENOENT: return make_error_condition( errc::no_such_file_or_directory ); + case ENOEXEC: return make_error_condition( errc::executable_format_error ); + case ENOLCK: return make_error_condition( errc::no_lock_available ); + case ENOLINK: return make_error_condition( errc::no_link ); + case ENOMEM: return make_error_condition( errc::not_enough_memory ); + case ENOMSG: return make_error_condition( errc::no_message ); + case ENOPROTOOPT: return make_error_condition( errc::no_protocol_option ); + case ENOSPC: return make_error_condition( errc::no_space_on_device ); + case ENOSR: return make_error_condition( errc::no_stream_resources ); + case ENOSTR: return make_error_condition( errc::not_a_stream ); + case ENOSYS: return make_error_condition( errc::function_not_supported ); + case ENOTCONN: return make_error_condition( errc::not_connected ); + case ENOTDIR: return make_error_condition( errc::not_a_directory ); + # if ENOTEMPTY != EEXIST // AIX treats ENOTEMPTY and EEXIST as the same value + case ENOTEMPTY: return make_error_condition( errc::directory_not_empty ); + # endif // ENOTEMPTY != EEXIST + # if ENOTRECOVERABLE != ECONNRESET // the same on some Broadcom chips + case ENOTRECOVERABLE: return make_error_condition( errc::state_not_recoverable ); + # endif // ENOTRECOVERABLE != ECONNRESET + case ENOTSOCK: return make_error_condition( errc::not_a_socket ); + case ENOTSUP: return make_error_condition( errc::not_supported ); + case ENOTTY: return make_error_condition( errc::inappropriate_io_control_operation ); + case ENXIO: return make_error_condition( errc::no_such_device_or_address ); + # if EOPNOTSUPP != ENOTSUP + case EOPNOTSUPP: return make_error_condition( errc::operation_not_supported ); + # endif // EOPNOTSUPP != ENOTSUP + case EOVERFLOW: return make_error_condition( errc::value_too_large ); + # if EOWNERDEAD != ECONNABORTED // the same on some Broadcom chips + case EOWNERDEAD: return make_error_condition( errc::owner_dead ); + # endif // EOWNERDEAD != ECONNABORTED + case EPERM: return make_error_condition( errc::operation_not_permitted ); + case EPIPE: return make_error_condition( errc::broken_pipe ); + case EPROTO: return make_error_condition( errc::protocol_error ); + case EPROTONOSUPPORT: return make_error_condition( errc::protocol_not_supported ); + case EPROTOTYPE: return make_error_condition( errc::wrong_protocol_type ); + case ERANGE: return make_error_condition( errc::result_out_of_range ); + case EROFS: return make_error_condition( errc::read_only_file_system ); + case ESPIPE: return make_error_condition( errc::invalid_seek ); + case ESRCH: return make_error_condition( errc::no_such_process ); + case ETIME: return make_error_condition( errc::stream_timeout ); + case ETIMEDOUT: return make_error_condition( errc::timed_out ); + case ETXTBSY: return make_error_condition( errc::text_file_busy ); + # if EAGAIN != EWOULDBLOCK + case EWOULDBLOCK: return make_error_condition( errc::operation_would_block ); + # endif // EAGAIN != EWOULDBLOCK + case EXDEV: return make_error_condition( errc::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( errc::permission_denied ); + case ERROR_ALREADY_EXISTS: return make_error_condition( errc::file_exists ); + case ERROR_BAD_UNIT: return make_error_condition( errc::no_such_device ); + case ERROR_BUFFER_OVERFLOW: return make_error_condition( errc::filename_too_long ); + case ERROR_BUSY: return make_error_condition( errc::device_or_resource_busy ); + case ERROR_BUSY_DRIVE: return make_error_condition( errc::device_or_resource_busy ); + case ERROR_CANNOT_MAKE: return make_error_condition( errc::permission_denied ); + case ERROR_CANTOPEN: return make_error_condition( errc::io_error ); + case ERROR_CANTREAD: return make_error_condition( errc::io_error ); + case ERROR_CANTWRITE: return make_error_condition( errc::io_error ); + case ERROR_CURRENT_DIRECTORY: return make_error_condition( errc::permission_denied ); + case ERROR_DEV_NOT_EXIST: return make_error_condition( errc::no_such_device ); + case ERROR_DEVICE_IN_USE: return make_error_condition( errc::device_or_resource_busy ); + case ERROR_DIR_NOT_EMPTY: return make_error_condition( errc::directory_not_empty ); + case ERROR_DIRECTORY: return make_error_condition( errc::invalid_argument ); // WinError.h: "The directory name is invalid" + case ERROR_DISK_FULL: return make_error_condition( errc::no_space_on_device ); + case ERROR_FILE_EXISTS: return make_error_condition( errc::file_exists ); + case ERROR_FILE_NOT_FOUND: return make_error_condition( errc::no_such_file_or_directory ); + case ERROR_HANDLE_DISK_FULL: return make_error_condition( errc::no_space_on_device ); + case ERROR_INVALID_ACCESS: return make_error_condition( errc::permission_denied ); + case ERROR_INVALID_DRIVE: return make_error_condition( errc::no_such_device ); + case ERROR_INVALID_FUNCTION: return make_error_condition( errc::function_not_supported ); + case ERROR_INVALID_HANDLE: return make_error_condition( errc::invalid_argument ); + case ERROR_INVALID_NAME: return make_error_condition( errc::invalid_argument ); + case ERROR_LOCK_VIOLATION: return make_error_condition( errc::no_lock_available ); + case ERROR_LOCKED: return make_error_condition( errc::no_lock_available ); + case ERROR_NEGATIVE_SEEK: return make_error_condition( errc::invalid_argument ); + case ERROR_NOACCESS: return make_error_condition( errc::permission_denied ); + case ERROR_NOT_ENOUGH_MEMORY: return make_error_condition( errc::not_enough_memory ); + case ERROR_NOT_READY: return make_error_condition( errc::resource_unavailable_try_again ); + case ERROR_NOT_SAME_DEVICE: return make_error_condition( errc::cross_device_link ); + case ERROR_OPEN_FAILED: return make_error_condition( errc::io_error ); + case ERROR_OPEN_FILES: return make_error_condition( errc::device_or_resource_busy ); + case ERROR_OPERATION_ABORTED: return make_error_condition( errc::operation_canceled ); + case ERROR_OUTOFMEMORY: return make_error_condition( errc::not_enough_memory ); + case ERROR_PATH_NOT_FOUND: return make_error_condition( errc::no_such_file_or_directory ); + case ERROR_READ_FAULT: return make_error_condition( errc::io_error ); + case ERROR_RETRY: return make_error_condition( errc::resource_unavailable_try_again ); + case ERROR_SEEK: return make_error_condition( errc::io_error ); + case ERROR_SHARING_VIOLATION: return make_error_condition( errc::permission_denied ); + case ERROR_TOO_MANY_OPEN_FILES: return make_error_condition( errc::too_many_files_open ); + case ERROR_WRITE_FAULT: return make_error_condition( errc::io_error ); + case ERROR_WRITE_PROTECT: return make_error_condition( errc::permission_denied ); + case WSAEACCES: return make_error_condition( errc::permission_denied ); + case WSAEADDRINUSE: return make_error_condition( errc::address_in_use ); + case WSAEADDRNOTAVAIL: return make_error_condition( errc::address_not_available ); + case WSAEAFNOSUPPORT: return make_error_condition( errc::address_family_not_supported ); + case WSAEALREADY: return make_error_condition( errc::connection_already_in_progress ); + case WSAEBADF: return make_error_condition( errc::bad_file_descriptor ); + case WSAECONNABORTED: return make_error_condition( errc::connection_aborted ); + case WSAECONNREFUSED: return make_error_condition( errc::connection_refused ); + case WSAECONNRESET: return make_error_condition( errc::connection_reset ); + case WSAEDESTADDRREQ: return make_error_condition( errc::destination_address_required ); + case WSAEFAULT: return make_error_condition( errc::bad_address ); + case WSAEHOSTUNREACH: return make_error_condition( errc::host_unreachable ); + case WSAEINPROGRESS: return make_error_condition( errc::operation_in_progress ); + case WSAEINTR: return make_error_condition( errc::interrupted ); + case WSAEINVAL: return make_error_condition( errc::invalid_argument ); + case WSAEISCONN: return make_error_condition( errc::already_connected ); + case WSAEMFILE: return make_error_condition( errc::too_many_files_open ); + case WSAEMSGSIZE: return make_error_condition( errc::message_size ); + case WSAENAMETOOLONG: return make_error_condition( errc::filename_too_long ); + case WSAENETDOWN: return make_error_condition( errc::network_down ); + case WSAENETRESET: return make_error_condition( errc::network_reset ); + case WSAENETUNREACH: return make_error_condition( errc::network_unreachable ); + case WSAENOBUFS: return make_error_condition( errc::no_buffer_space ); + case WSAENOPROTOOPT: return make_error_condition( errc::no_protocol_option ); + case WSAENOTCONN: return make_error_condition( errc::not_connected ); + case WSAENOTSOCK: return make_error_condition( errc::not_a_socket ); + case WSAEOPNOTSUPP: return make_error_condition( errc::operation_not_supported ); + case WSAEPROTONOSUPPORT: return make_error_condition( errc::protocol_not_supported ); + case WSAEPROTOTYPE: return make_error_condition( errc::wrong_protocol_type ); + case WSAETIMEDOUT: return make_error_condition( errc::timed_out ); + case WSAEWOULDBLOCK: return make_error_condition( errc::operation_would_block ); + #endif + default: return error_condition( ev, system_category() ); + } + } + +# if !defined( BOOST_SYSTEM_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 + boost::detail::win32::LPVOID_ lpMsgBuf = 0; + boost::detail::win32::DWORD_ retval = boost::detail::win32::FormatMessageA( + boost::detail::win32::FORMAT_MESSAGE_ALLOCATE_BUFFER_ | + boost::detail::win32::FORMAT_MESSAGE_FROM_SYSTEM_ | + boost::detail::win32::FORMAT_MESSAGE_IGNORE_INSERTS_, + NULL, + ev, + boost::detail::win32::MAKELANGID_(boost::detail::win32::LANG_NEUTRAL_, boost::detail::win32::SUBLANG_DEFAULT_), // Default language + (boost::detail::win32::LPSTR_) &lpMsgBuf, + 0, + NULL + ); + detail::local_free_on_destruction lfod(lpMsgBuf); + if (retval == 0) + return std::string("Unknown error"); + + std::string str( static_cast(lpMsgBuf) ); +# else // WinCE workaround + boost::detail::win32::LPVOID_ lpMsgBuf = 0; + boost::detail::win32::DWORD retval = boost::detail::win32::FormatMessageW( + boost::detail::win32::FORMAT_MESSAGE_ALLOCATE_BUFFER_ | + boost::detail::win32::FORMAT_MESSAGE_FROM_SYSTEM_ | + boost::detail::win32::FORMAT_MESSAGE_IGNORE_INSERTS_, + NULL, + ev, + boost::detail::win32::MAKELANGID_(boost::detail::win32::LANG_NEUTRAL_, boost::detail::win32::SUBLANG_DEFAULT_), // Default language + (boost::detail::win32::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(lpMsgBuf) ) + 1) * 2; + boost::detail::win32::LPSTR_ narrow_buffer = (boost::detail::win32::LPSTR_)_alloca( num_chars ); + if (boost::detail::win32::WideCharToMultiByte(CP_ACP, 0, static_cast(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 + +} + +# 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() + { + static const system_detail::system_error_category system_category_const; + return system_category_const; + } + + BOOST_SYSTEM_DECL const error_category & generic_category() + { + static const system_detail::generic_error_category generic_category_const; + return generic_category_const; + } + + } // namespace system +} // namespace boost +#endif // BOOST_SYSTEM_DETAIL_INLINED_ERROR_CODE_HPP Property changes on: detail\inlined\error_code.hpp ___________________________________________________________________ Added: svn:mime-type + text/plain Added: svn:keywords + Id Added: svn:eol-style + native Index: detail/inlined/local_free_on_destruction.hpp =================================================================== --- detail/inlined/local_free_on_destruction.hpp (revision 0) +++ detail/inlined/local_free_on_destruction.hpp (revision 0) @@ -0,0 +1,42 @@ +// local_free_on_exit.hpp ------------------------------------------------------------// + +// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2010 Beman Dawes + +// Distributed under the Boost Software License, Version 1.0. +// See http://www.boost.org/LICENSE_1_0.txt + +// This is derived from boost/asio/detail/local_free_on_block_exit.hpp to avoid +// a dependency on asio. Thanks to Chris Kohlhoff for pointing it out. + +#ifndef BOOST_SYSTEM_DETAIL_INLINED_LOCAL_FREE_ON_DESTRUCTION_HPP +#define BOOST_SYSTEM_DETAIL_INLINED_LOCAL_FREE_ON_DESTRUCTION_HPP + +#include + +namespace boost { +namespace system { +namespace detail { + +class local_free_on_destruction +{ +public: + explicit local_free_on_destruction(void* p) + : p_(p) {} + + ~local_free_on_destruction() + { + boost::detail::win32::LocalFree(p_); + } + +private: + void* p_; + local_free_on_destruction(const local_free_on_destruction&); // = deleted + local_free_on_destruction& operator=(const local_free_on_destruction&); // = deleted +}; + +} // namespace detail +} // namespace system +} // namespace boost + +#endif // BOOST_SYSTEM_DETAIL_INLINED_LOCAL_FREE_ON_DESTRUCTION_HPP Property changes on: detail\inlined\local_free_on_destruction.hpp ___________________________________________________________________ Added: svn:mime-type + text/plain Added: svn:keywords + Id Added: svn:eol-style + native Index: error_code.hpp =================================================================== --- error_code.hpp (revision 75797) +++ error_code.hpp (working copy) @@ -21,15 +21,24 @@ #include #include #include +#include // TODO: undef these macros if not already defined -#include +#include -#if !defined(BOOST_POSIX_API) && !defined(BOOST_WINDOWS_API) -# error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined +#if !defined(BOOST_SYSTEM_POSIX_API) && !defined(BOOST_SYSTEM_WINDOWS_API) +# error BOOST_SYSTEM_POSIX_API or BOOST_SYSTEM_WINDOWS_API must be defined #endif +# ifdef BOOST_ERROR_CODE_HEADER_ONLY +# ifndef BOOST_SYSTEM_INLINED +# define BOOST_SYSTEM_INLINED +# endif +# endif + +#ifndef BOOST_SYSTEM_INLINED #include // must be the last #include +#endif namespace boost { @@ -187,7 +196,7 @@ virtual const char * name() const = 0; virtual std::string message( int ev ) const = 0; virtual error_condition default_error_condition( int ev ) const; - virtual bool equivalent( int code, + virtual bool equivalent( int code, const error_condition & condition ) const; virtual bool equivalent( const error_code & code, int condition ) const; @@ -202,8 +211,8 @@ // predefined error categories -----------------------------------------// - BOOST_SYSTEM_DECL const error_category & system_category(); - BOOST_SYSTEM_DECL const error_category & generic_category(); + BOOST_SYSTEM_DECL BOOST_SYSTEM_INLINE const error_category & system_category(); + BOOST_SYSTEM_DECL BOOST_SYSTEM_INLINE const error_category & generic_category(); // deprecated synonyms --------------------------------------------------// @@ -238,15 +247,15 @@ // modifiers: void assign( int val, const error_category & cat ) - { + { m_val = val; m_cat = &cat; } - + template typename boost::enable_if, error_condition>::type & operator=( ErrorConditionEnum val ) - { + { *this = make_error_condition(val); return *this; } @@ -266,7 +275,7 @@ static void unspecified_bool_true() {} operator unspecified_bool_type() const // true if error - { + { return m_val == 0 ? 0 : unspecified_bool_true; } @@ -282,7 +291,7 @@ const error_condition & rhs ) { return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val; - } + } inline friend bool operator<( const error_condition & lhs, const error_condition & rhs ) @@ -324,15 +333,15 @@ // modifiers: void assign( int val, const error_category & cat ) - { + { m_val = val; m_cat = &cat; } - + template typename boost::enable_if, error_code>::type & operator=( ErrorCodeEnum val ) - { + { *this = make_error_code(val); return *this; } @@ -353,7 +362,7 @@ static void unspecified_bool_true() {} operator unspecified_bool_type() const // true if error - { + { return m_val == 0 ? 0 : unspecified_bool_true; } @@ -379,7 +388,7 @@ return lhs.m_cat < rhs.m_cat || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val); } - + private: int m_val; const error_category * m_cat; @@ -397,7 +406,9 @@ } // namespace system - namespace detail { inline system::error_code * throws() { return 0; } } + namespace detail { + inline system::error_code * throws() { return 0; } + } // Misuse of the error_code object is turned into a noisy failure by // poisoning the reference. This particular implementation doesn't // produce warnings or errors from popular compilers, is very efficient @@ -405,7 +416,6 @@ // from order of initialization problems. In practice, it also seems // cause user function error handling implementation errors to be detected // very early in the development cycle. - inline system::error_code & throws() { return *detail::throws(); } @@ -431,26 +441,26 @@ return code.category().equivalent( code.value(), condition ) || condition.category().equivalent( code, condition.value() ); } - + inline bool operator!=( const error_code & lhs, const error_condition & rhs ) { return !(lhs == rhs); } - + inline bool operator==( const error_condition & condition, const error_code & code ) { return condition.category().equivalent( code, condition.value() ) || code.category().equivalent( code.value(), condition ); } - + inline bool operator!=( const error_condition & lhs, const error_code & rhs ) { return !(lhs == rhs); } - + // TODO: both of these may move elsewhere, but the LWG hasn't spoken yet. template @@ -483,7 +493,7 @@ // error_category default implementation -------------------------------// inline error_condition error_category::default_error_condition( int ev ) const - { + { return error_condition( ev, *this ); } @@ -502,11 +512,15 @@ } // namespace system } // namespace boost +//#include // pops abi_prefix.hpp pragmas +// + +#ifndef BOOST_SYSTEM_INLINED #include // pops abi_prefix.hpp pragmas +#else +#include +#endif -# ifdef BOOST_ERROR_CODE_HEADER_ONLY -# include -# endif #endif // BOOST_ERROR_CODE_HPP Index: linux_error.hpp =================================================================== --- linux_error.hpp (revision 75797) +++ linux_error.hpp (working copy) @@ -27,7 +27,7 @@ // User code should use the portable "posix" enums for POSIX errors; this // allows such code to be portable to non-POSIX systems. For the non-POSIX - // errno values that POSIX-based systems typically provide in addition to + // errno values that POSIX-based systems typically provide in addition to // POSIX values, use the system specific enums below. namespace linux_error @@ -103,7 +103,7 @@ } } // namespace system -} // namespace boost +} // namespace boost #endif // Linux Index: system_error.hpp =================================================================== --- system_error.hpp (revision 75797) +++ system_error.hpp (working copy) @@ -21,7 +21,7 @@ class BOOST_SYMBOL_VISIBLE system_error : public std::runtime_error // BOOST_SYMBOL_VISIBLE is needed by GCC to ensure system_error thrown from a shared - // library can be caught. See svn.boost.org/trac/boost/ticket/3697 + // library can be caught. See svn.boost.org/trac/boost/ticket/3697 { public: system_error( error_code ec ) @@ -47,7 +47,7 @@ virtual ~system_error() throw() {} const error_code & code() const throw() { return m_error_code; } - const char * what() const throw(); + inline const char * what() const throw(); private: error_code m_error_code; @@ -56,7 +56,7 @@ // implementation ------------------------------------------------------// - inline const char * system_error::what() const throw() + const char * system_error::what() const throw() // see http://www.boost.org/more/error_handling.html for lazy build rationale { if ( m_what.empty() ) Index: windows_error.hpp =================================================================== --- windows_error.hpp (revision 75797) +++ windows_error.hpp (working copy) @@ -15,7 +15,7 @@ #include -#ifdef BOOST_WINDOWS_API +#ifdef BOOST_SYSTEM_WINDOWS_API #include #include @@ -113,6 +113,6 @@ } // namespace system } // namespace boost -#endif // BOOST_WINDOWS_API +#endif // BOOST_SYSTEM_WINDOWS_API #endif // BOOST_WINDOWS_ERROR_HPP