From: troy_at_[hidden]
Date: 2008-07-01 12:52:04
Author: troy
Date: 2008-07-01 12:52:03 EDT (Tue, 01 Jul 2008)
New Revision: 46967
URL: http://svn.boost.org/trac/boost/changeset/46967
Log:
use modularize targets, not externals to manage modularization
Added:
branches/CMake/release/libs/system/include/boost/system/
branches/CMake/release/libs/system/include/boost/system/config.hpp (contents, props changed)
branches/CMake/release/libs/system/include/boost/system/cygwin_error.hpp (contents, props changed)
branches/CMake/release/libs/system/include/boost/system/error_code.hpp (contents, props changed)
branches/CMake/release/libs/system/include/boost/system/linux_error.hpp (contents, props changed)
branches/CMake/release/libs/system/include/boost/system/system_error.hpp (contents, props changed)
branches/CMake/release/libs/system/include/boost/system/windows_error.hpp (contents, props changed)
Properties modified:
branches/CMake/release/libs/system/include/boost/ (props changed)
Added: branches/CMake/release/libs/system/include/boost/system/config.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/system/include/boost/system/config.hpp 2008-07-01 12:52:03 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,75 @@
+// boost/system/config.hpp -------------------------------------------------//
+
+// Copyright Beman Dawes 2003, 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 http://www.boost.org/libs/system for documentation.
+
+#ifndef BOOST_SYSTEM_CONFIG_HPP
+#define BOOST_SYSTEM_CONFIG_HPP
+
+#include <boost/config.hpp>
+
+// BOOST_POSIX_API or BOOST_WINDOWS_API specify which API to use.
+// If not specified, a sensible default will be applied.
+
+# if defined( BOOST_WINDOWS_API ) && defined( BOOST_POSIX_API )
+# error both BOOST_WINDOWS_API and BOOST_POSIX_API are defined
+# elif !defined( BOOST_WINDOWS_API ) && !defined( BOOST_POSIX_API )
+# if defined(_WIN32) || defined(__WIN32__) || defined(WIN32) || defined(__CYGWIN__)
+# define BOOST_WINDOWS_API
+# else
+# define BOOST_POSIX_API
+# endif
+# endif
+
+// enable dynamic linking on Windows ---------------------------------------//
+
+//# if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)) && defined(__BORLANDC__) && defined(__WIN32__)
+//# error Dynamic linking Boost.System does not work for Borland; use static linking instead
+//# endif
+
+#ifdef BOOST_HAS_DECLSPEC // defined in config system
+// we need to import/export our code only if the user has specifically
+// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
+// libraries to be dynamically linked, or BOOST_SYSTEM_DYN_LINK
+// if they want just this one to be dynamically liked:
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)
+// export if this is our own source, otherwise import:
+#ifdef BOOST_SYSTEM_SOURCE
+# define BOOST_SYSTEM_DECL __declspec(dllexport)
+#else
+# define BOOST_SYSTEM_DECL __declspec(dllimport)
+#endif // BOOST_SYSTEM_SOURCE
+#endif // DYN_LINK
+#endif // BOOST_HAS_DECLSPEC
+//
+// if BOOST_SYSTEM_DECL isn't defined yet define it now:
+#ifndef BOOST_SYSTEM_DECL
+#define BOOST_SYSTEM_DECL
+#endif
+
+// enable automatic library variant selection ------------------------------//
+
+#if !defined(BOOST_SYSTEM_SOURCE) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SYSTEM_NO_LIB)
+//
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_system
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SYSTEM_DYN_LINK)
+# define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif // auto-linking disabled
+
+#endif // BOOST_SYSTEM_CONFIG_HPP
+
Added: branches/CMake/release/libs/system/include/boost/system/cygwin_error.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/system/include/boost/system/cygwin_error.hpp 2008-07-01 12:52:03 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,56 @@
+// boost/system/cygwin_error.hpp -------------------------------------------//
+
+// Copyright Beman Dawes 2007
+
+// 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_CYGWIN_ERROR_HPP
+#define BOOST_CYGWIN_ERROR_HPP
+
+// This header is effectively empty for compiles on operating systems where
+// it is not applicable.
+
+# ifdef __CYGWIN__
+
+#include <boost/system/error_code.hpp>
+
+namespace boost
+{
+ namespace system
+ {
+ // To construct an error_code after a API error:
+ //
+ // error_code( errno, system_category )
+
+ // 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
+ // POSIX values, use the system specific enums below.
+
+ namespace cygwin_error
+ {
+ enum cygwin_errno
+ {
+ no_net = ENONET,
+ no_package = ENOPKG,
+ no_share = ENOSHARE
+ };
+ } // namespace cygwin_error
+
+ template<> struct is_error_code_enum<cygwin_error::cygwin_errno>
+ { static const bool value = true; };
+
+ namespace cygwin_error
+ {
+ inline error_code make_error_code( cygwin_errno e )
+ { return error_code( e, get_system_category() ); }
+ }
+ }
+}
+
+#endif // __CYGWIN__
+
+#endif // BOOST_CYGWIN_ERROR_HPP
Added: branches/CMake/release/libs/system/include/boost/system/error_code.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/system/include/boost/system/error_code.hpp 2008-07-01 12:52:03 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,495 @@
+// boost/system/error_code.hpp ---------------------------------------------//
+
+// Copyright Beman Dawes 2006, 2007
+// Copyright Christoper Kohlhoff 2007
+
+// 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_ERROR_CODE_HPP
+#define BOOST_ERROR_CODE_HPP
+
+#include <boost/system/config.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/assert.hpp>
+#include <boost/operators.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <ostream>
+#include <string>
+#include <stdexcept>
+#include <functional>
+
+// TODO: undef these macros if not already defined
+#include <boost/cerrno.hpp>
+
+#if !defined(BOOST_POSIX_API) && !defined(BOOST_WINDOWS_API)
+# error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined
+#endif
+
+#include <boost/config/abi_prefix.hpp> // must be the last #include
+
+namespace boost
+{
+ namespace system
+ {
+
+ class error_code;
+ class error_condition;
+
+ // "Concept" helpers ---------------------------------------------------//
+
+ template< class T >
+ struct is_error_code_enum { static const bool value = false; };
+
+ template< class T >
+ struct is_error_condition_enum { static const bool value = false; };
+
+ // portable error_conditions -------------------------------------------//
+
+ namespace posix_error
+ {
+ enum posix_errno
+ {
+ success = 0,
+ address_family_not_supported = EAFNOSUPPORT,
+ address_in_use = EADDRINUSE,
+ address_not_available = EADDRNOTAVAIL,
+ already_connected = EISCONN,
+ argument_list_too_long = E2BIG,
+ argument_out_of_domain = EDOM,
+ bad_address = EFAULT,
+ bad_file_descriptor = EBADF,
+ bad_message = EBADMSG,
+ broken_pipe = EPIPE,
+ connection_aborted = ECONNABORTED,
+ connection_already_in_progress = EALREADY,
+ connection_refused = ECONNREFUSED,
+ connection_reset = ECONNRESET,
+ cross_device_link = EXDEV,
+ destination_address_required = EDESTADDRREQ,
+ device_or_resource_busy = EBUSY,
+ directory_not_empty = ENOTEMPTY,
+ executable_format_error = ENOEXEC,
+ file_exists = EEXIST,
+ file_too_large = EFBIG,
+ filename_too_long = ENAMETOOLONG,
+ function_not_supported = ENOSYS,
+ host_unreachable = EHOSTUNREACH,
+ identifier_removed = EIDRM,
+ illegal_byte_sequence = EILSEQ,
+ inappropriate_io_control_operation = ENOTTY,
+ interrupted = EINTR,
+ invalid_argument = EINVAL,
+ invalid_seek = ESPIPE,
+ io_error = EIO,
+ is_a_directory = EISDIR,
+ message_size = EMSGSIZE,
+ network_down = ENETDOWN,
+ network_reset = ENETRESET,
+ network_unreachable = ENETUNREACH,
+ no_buffer_space = ENOBUFS,
+ no_child_process = ECHILD,
+ no_link = ENOLINK,
+ no_lock_available = ENOLCK,
+ no_message_available = ENODATA,
+ no_message = ENOMSG,
+ no_protocol_option = ENOPROTOOPT,
+ no_space_on_device = ENOSPC,
+ no_stream_resources = ENOSR,
+ no_such_device_or_address = ENXIO,
+ no_such_device = ENODEV,
+ no_such_file_or_directory = ENOENT,
+ no_such_process = ESRCH,
+ not_a_directory = ENOTDIR,
+ not_a_socket = ENOTSOCK,
+ not_a_stream = ENOSTR,
+ not_connected = ENOTCONN,
+ not_enough_memory = ENOMEM,
+ not_supported = ENOTSUP,
+ operation_canceled = ECANCELED,
+ operation_in_progress = EINPROGRESS,
+ operation_not_permitted = EPERM,
+ operation_not_supported = EOPNOTSUPP,
+ operation_would_block = EWOULDBLOCK,
+ owner_dead = EOWNERDEAD,
+ permission_denied = EACCES,
+ protocol_error = EPROTO,
+ protocol_not_supported = EPROTONOSUPPORT,
+ read_only_file_system = EROFS,
+ resource_deadlock_would_occur = EDEADLK,
+ resource_unavailable_try_again = EAGAIN,
+ result_out_of_range = ERANGE,
+ state_not_recoverable = ENOTRECOVERABLE,
+ stream_timeout = ETIME,
+ text_file_busy = ETXTBSY,
+ timed_out = ETIMEDOUT,
+ too_many_files_open_in_system = ENFILE,
+ too_many_files_open = EMFILE,
+ too_many_links = EMLINK,
+ too_many_synbolic_link_levels = ELOOP,
+ value_too_large = EOVERFLOW,
+ wrong_protocol_type = EPROTOTYPE
+ };
+
+ } // namespace posix_error
+
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+ namespace posix = posix_error;
+# endif
+
+ template<> struct is_error_condition_enum<posix_error::posix_errno>
+ { static const bool value = true; };
+
+
+ // ----------------------------------------------------------------------//
+
+ // Operating system specific interfaces --------------------------------//
+
+
+ // The interface is divided into general and system-specific portions to
+ // meet these requirements:
+ //
+ // * Code calling an operating system API can create an error_code with
+ // a single category (system_category), even for POSIX-like operating
+ // systems that return some POSIX errno values and some native errno
+ // values. This code should not have to pay the cost of distinguishing
+ // between categories, since it is not yet known if that is needed.
+ //
+ // * Users wishing to write system-specific code should be given enums for
+ // at least the common error cases.
+ //
+ // * System specific code should fail at compile time if moved to another
+ // operating system.
+
+ // The system specific portions of the interface are located in headers
+ // with names reflecting the operating system. For example,
+ //
+ // <boost/system/cygwin_error.hpp>
+ // <boost/system/linux_error.hpp>
+ // <boost/system/windows_error.hpp>
+ //
+ // These headers are effectively empty for compiles on operating systems
+ // where they are not applicable.
+
+ // ----------------------------------------------------------------------//
+
+ // class error_category ------------------------------------------------//
+
+ class error_category : public noncopyable
+ {
+ public:
+ virtual ~error_category(){}
+ virtual inline const char * name() const; // see implementation note below
+ virtual inline std::string message( int ev ) const; // see implementation note below
+ virtual inline error_condition default_error_condition( int ev ) const;
+ virtual inline bool equivalent( int code, const error_condition & condition ) const;
+ virtual inline bool equivalent( const error_code & code, int condition ) const;
+
+ bool operator==(const error_category & rhs) const { return this == &rhs; }
+ bool operator!=(const error_category & rhs) const { return this != &rhs; }
+ bool operator<( const error_category & rhs ) const
+ {
+ return std::less<const error_category*>()( this, &rhs );
+ }
+ };
+
+ // predefined error categories -----------------------------------------//
+
+ BOOST_SYSTEM_DECL const error_category & get_system_category();
+ BOOST_SYSTEM_DECL const error_category & get_posix_category();
+
+ static const error_category & system_category = get_system_category();
+ static const error_category & posix_category = get_posix_category();
+
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+ // deprecated synonyms
+ static const error_category & errno_ecat = get_posix_category();
+ static const error_category & native_ecat = get_system_category();
+# endif
+
+ // class error_condition -----------------------------------------------//
+
+ // error_conditions are portable, error_codes are system or lib specific
+
+ class error_condition
+ {
+ public:
+
+ // constructors:
+ error_condition() : m_val(0), m_cat(&get_posix_category()) {}
+ error_condition( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
+
+ template <class ConditionEnum>
+ error_condition(ConditionEnum e,
+ typename boost::enable_if<is_error_condition_enum<ConditionEnum> >::type* = 0)
+ {
+ *this = make_error_condition(e);
+ }
+
+ // modifiers:
+
+ void assign( int val, const error_category & cat )
+ {
+ m_val = val;
+ m_cat = &cat;
+ }
+
+ template<typename ConditionEnum>
+ typename boost::enable_if<is_error_condition_enum<ConditionEnum>, error_condition>::type &
+ operator=( ConditionEnum val )
+ {
+ *this = make_error_condition(val);
+ return *this;
+ }
+
+ void clear()
+ {
+ m_val = 0;
+ m_cat = &get_posix_category();
+ }
+
+ // observers:
+ int value() const { return m_val; }
+ const error_category & category() const { return *m_cat; }
+ std::string message() const { return m_cat->message(value()); }
+
+ typedef void (*unspecified_bool_type)();
+ static void unspecified_bool_true() {}
+
+ operator unspecified_bool_type() const // true if error
+ {
+ return m_val == 0 ? 0 : unspecified_bool_true;
+ }
+
+ bool operator!() const // true if no error
+ {
+ return m_val == 0;
+ }
+
+ // relationals:
+ // the more symmetrical non-member syntax allows enum
+ // conversions work for both rhs and lhs.
+ inline friend bool operator==( const error_condition & lhs,
+ 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 )
+ // the more symmetrical non-member syntax allows enum
+ // conversions work for both rhs and lhs.
+ {
+ 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;
+
+ };
+
+ // class error_code ----------------------------------------------------//
+
+ // We want error_code to be a value type that can be copied without slicing
+ // and without requiring heap allocation, but we also want it to have
+ // polymorphic behavior based on the error category. This is achieved by
+ // abstract base class error_category supplying the polymorphic behavior,
+ // and error_code containing a pointer to an object of a type derived
+ // from error_category.
+ class error_code
+ {
+ public:
+
+ // constructors:
+ error_code() : m_val(0), m_cat(&get_system_category()) {}
+ error_code( int val, const error_category & cat ) : m_val(val), m_cat(&cat) {}
+
+ template <class CodeEnum>
+ error_code(CodeEnum e,
+ typename boost::enable_if<is_error_code_enum<CodeEnum> >::type* = 0)
+ {
+ *this = make_error_code(e);
+ }
+
+ // modifiers:
+ void assign( int val, const error_category & cat )
+ {
+ m_val = val;
+ m_cat = &cat;
+ }
+
+ template<typename CodeEnum>
+ typename boost::enable_if<is_error_code_enum<CodeEnum>, error_code>::type &
+ operator=( CodeEnum val )
+ {
+ *this = make_error_code(val);
+ return *this;
+ }
+
+ void clear()
+ {
+ m_val = 0;
+ m_cat = &get_system_category();
+ }
+
+ // observers:
+ int value() const { return m_val; }
+ const error_category & category() const { return *m_cat; }
+ error_condition default_error_condition() const { return m_cat->default_error_condition(value()); }
+ std::string message() const { return m_cat->message(value()); }
+
+ typedef void (*unspecified_bool_type)();
+ static void unspecified_bool_true() {}
+
+ operator unspecified_bool_type() const // true if error
+ {
+ return m_val == 0 ? 0 : unspecified_bool_true;
+ }
+
+ bool operator!() const // true if no error
+ {
+ return m_val == 0;
+ }
+
+ // relationals:
+ inline friend bool operator==( const error_code & lhs,
+ const error_code & rhs )
+ // the more symmetrical non-member syntax allows enum
+ // conversions work for both rhs and lhs.
+ {
+ return lhs.m_cat == rhs.m_cat && lhs.m_val == rhs.m_val;
+ }
+
+ inline friend bool operator<( const error_code & lhs,
+ const error_code & rhs )
+ // the more symmetrical non-member syntax allows enum
+ // conversions work for both rhs and lhs.
+ {
+ 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;
+
+ };
+
+ // non-member functions ------------------------------------------------//
+
+ inline bool operator!=( const error_code & lhs,
+ const error_code & rhs )
+ {
+ return !(lhs == rhs);
+ }
+
+ inline bool operator!=( const error_condition & lhs,
+ const error_condition & rhs )
+ {
+ return !(lhs == rhs);
+ }
+
+ inline bool operator==( const error_code & code,
+ const error_condition & condition )
+ {
+ 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 <class charT, class traits>
+ inline std::basic_ostream<charT,traits>&
+ operator<< (std::basic_ostream<charT,traits>& os, error_code ec)
+ {
+ os << ec.category().name() << ':' << ec.value();
+ return os;
+ }
+
+ inline std::size_t hash_value( const error_code & ec )
+ {
+ return static_cast<std::size_t>(ec.value())
+ + reinterpret_cast<std::size_t>(&ec.category());
+ }
+
+ // make_* functions for posix_error::posix_errno -----------------------------//
+
+ namespace posix_error
+ {
+ // explicit conversion:
+ inline error_code make_error_code( posix_errno e )
+ { return error_code( e, get_posix_category() ); }
+
+ // implicit conversion:
+ inline error_condition make_error_condition( posix_errno e )
+ { return error_condition( e, get_posix_category() ); }
+ }
+
+ // error_category default implementation -------------------------------//
+
+ inline error_condition error_category::default_error_condition( int ev ) const
+ {
+ return error_condition( ev, *this );
+ }
+
+ inline bool error_category::equivalent( int code,
+ const error_condition & condition ) const
+ {
+ return default_error_condition( code ) == condition;
+ }
+
+ inline bool error_category::equivalent( const error_code & code,
+ int condition ) const
+ {
+ return *this == code.category() && code.value() == condition;
+ }
+
+ // error_category implementation note: VC++ 8.0 objects to name() and
+ // message() being pure virtual functions. Thus these implementations.
+ inline const char * error_category::name() const
+ {
+ return "error: should never be called";
+ }
+
+ inline std::string error_category::message( int ) const
+ {
+ static std::string s("error: should never be called");
+ return s;
+ }
+
+ } // namespace system
+} // namespace boost
+
+#include <boost/config/abi_suffix.hpp> // pops abi_prefix.hpp pragmas
+
+# ifdef BOOST_ERROR_CODE_HEADER_ONLY
+# include <boost/../libs/system/src/error_code.cpp>
+# endif
+
+#endif // BOOST_ERROR_CODE_HPP
+
+
Added: branches/CMake/release/libs/system/include/boost/system/linux_error.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/system/include/boost/system/linux_error.hpp 2008-07-01 12:52:03 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,110 @@
+// boost/system/linux_error.hpp -------------------------------------------//
+
+// Copyright Beman Dawes 2007
+
+// 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_LINUX_ERROR_HPP
+#define BOOST_LINUX_ERROR_HPP
+
+// This header is effectively empty for compiles on operating systems where
+// it is not applicable.
+
+#if defined(linux) || defined(__linux) || defined(__linux__)
+
+#include <boost/system/error_code.hpp>
+
+namespace boost
+{
+ namespace system
+ {
+ // To construct an error_code after a API error:
+ //
+ // error_code( errno, system_category )
+
+ // 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
+ // POSIX values, use the system specific enums below.
+
+ namespace linux_error
+ {
+ enum linux_errno
+ {
+ advertise_error = EADV,
+ bad_exchange = EBADE,
+ bad_file_number = EBADFD,
+ bad_font_format = EBFONT,
+ bad_request_code = EBADRQC,
+ bad_request_descriptor = EBADR,
+ bad_slot = EBADSLT,
+ channel_range = ECHRNG,
+ communication_error = ECOMM,
+ dot_dot_error = EDOTDOT,
+ exchange_full = EXFULL,
+ host_down = EHOSTDOWN,
+ is_named_file_type= EISNAM,
+ key_expired = EKEYEXPIRED,
+ key_rejected = EKEYREJECTED,
+ key_revoked = EKEYREVOKED,
+ level2_halt= EL2HLT,
+ level2_no_syncronized= EL2NSYNC,
+ level3_halt = EL3HLT,
+ level3_reset = EL3RST,
+ link_range = ELNRNG,
+ medium_type = EMEDIUMTYPE,
+ no_anode= ENOANO,
+ no_block_device = ENOTBLK,
+ no_csi = ENOCSI,
+ no_key = ENOKEY,
+ no_medium = ENOMEDIUM,
+ no_network = ENONET,
+ no_package = ENOPKG,
+ not_avail = ENAVAIL,
+ not_named_file_type= ENOTNAM,
+ not_recoverable = ENOTRECOVERABLE,
+ not_unique = ENOTUNIQ,
+ owner_dead = EOWNERDEAD,
+ protocol_no_supported = EPFNOSUPPORT,
+ remote_address_changed = EREMCHG,
+ remote_io_error = EREMOTEIO,
+ remote_object = EREMOTE,
+ restart_needed = ERESTART,
+ shared_library_access = ELIBACC,
+ shared_library_bad = ELIBBAD,
+ shared_library_execute = ELIBEXEC,
+ shared_library_max_ = ELIBMAX,
+ shared_library_section= ELIBSCN,
+ shutdown = ESHUTDOWN,
+ socket_type_not_supported = ESOCKTNOSUPPORT,
+ srmount_error = ESRMNT,
+ stream_pipe_error = ESTRPIPE,
+ too_many_references = ETOOMANYREFS,
+ too_many_users = EUSERS,
+ unattached = EUNATCH,
+ unclean = EUCLEAN
+ };
+ } // namespace linux_error
+
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+ namespace Linux = linux_error;
+# endif
+
+ template<> struct is_error_code_enum<linux_error::linux_errno>
+ { static const bool value = true; };
+
+ namespace linux_error
+ {
+ inline error_code make_error_code( linux_errno e )
+ { return error_code( e, get_system_category() ); }
+ }
+
+ } // namespace system
+} // namespace boost
+
+#endif // Linux
+
+#endif // BOOST_LINUX_ERROR_HPP
Added: branches/CMake/release/libs/system/include/boost/system/system_error.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/system/include/boost/system/system_error.hpp 2008-07-01 12:52:03 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,71 @@
+// Boost system_error.hpp --------------------------------------------------//
+
+// Copyright Beman Dawes 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)
+
+#ifndef BOOST_SYSTEM_ERROR_HPP
+#define BOOST_SYSTEM_ERROR_HPP
+
+#include <string>
+#include <stdexcept>
+#include <cassert>
+#include <boost/system/error_code.hpp>
+
+namespace boost
+{
+ namespace system
+ {
+ // class system_error --------------------------------------------------//
+
+ class system_error : public std::runtime_error
+ {
+ public:
+ system_error( error_code ec )
+ : std::runtime_error(""), m_error_code(ec) {}
+ system_error( error_code ec, const std::string & what_arg )
+ : std::runtime_error(what_arg), m_error_code(ec) {}
+ system_error( int ev, const error_category & ecat,
+ const std::string & what_arg )
+ : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
+ system_error( int ev, const error_category & ecat )
+ : std::runtime_error(""), m_error_code(ev,ecat) {}
+
+ virtual ~system_error() throw() {}
+
+ const error_code & code() const throw() { return m_error_code; }
+ const char * what() const throw();
+
+ private:
+ error_code m_error_code;
+ mutable std::string m_what;
+ };
+
+ // implementation ------------------------------------------------------//
+
+ inline const char * system_error::what() const throw()
+ // see http://www.boost.org/more/error_handling.html for lazy build rationale
+ {
+ if ( m_what.empty() )
+ {
+ try
+ {
+ m_what = this->std::runtime_error::what();
+ if ( m_error_code )
+ {
+ if ( !m_what.empty() ) m_what += ": ";
+ m_what += m_error_code.message();
+ }
+ }
+ catch (...) { return std::runtime_error::what(); }
+ }
+ return m_what.c_str();
+ }
+
+ } // namespace system
+} // namespace boost
+
+#endif // BOOST_SYSTEM_ERROR_HPP
+
+
Added: branches/CMake/release/libs/system/include/boost/system/windows_error.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/system/include/boost/system/windows_error.hpp 2008-07-01 12:52:03 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,118 @@
+// boost/system/windows_error.hpp ------------------------------------------//
+
+// Copyright Beman Dawes 2007
+
+// 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_WINDOWS_ERROR_HPP
+#define BOOST_WINDOWS_ERROR_HPP
+
+// This header is effectively empty for compiles on operating systems where
+// it is not applicable.
+
+#include <boost/system/config.hpp>
+
+#ifdef BOOST_WINDOWS_API
+
+#include <boost/system/error_code.hpp>
+#include <winerror.h>
+
+namespace boost
+{
+ namespace system
+ {
+
+ // Microsoft Windows ---------------------------------------------------//
+
+ // To construct an error_code after a API error:
+ //
+ // error_code( ::GetLastError(), system_category )
+
+ namespace windows_error
+ {
+ enum windows_error_code
+ {
+ success = 0,
+ // These names and values are based on Windows winerror.h
+ invalid_function = ERROR_INVALID_FUNCTION,
+ file_not_found = ERROR_FILE_NOT_FOUND,
+ path_not_found = ERROR_PATH_NOT_FOUND,
+ too_many_open_files = ERROR_TOO_MANY_OPEN_FILES,
+ access_denied = ERROR_ACCESS_DENIED,
+ invalid_handle = ERROR_INVALID_HANDLE,
+ arena_trashed = ERROR_ARENA_TRASHED,
+ not_enough_memory = ERROR_NOT_ENOUGH_MEMORY,
+ invalid_block = ERROR_INVALID_BLOCK,
+ bad_environment = ERROR_BAD_ENVIRONMENT,
+ bad_format = ERROR_BAD_FORMAT,
+ invalid_access = ERROR_INVALID_ACCESS,
+ outofmemory = ERROR_OUTOFMEMORY,
+ invalid_drive = ERROR_INVALID_DRIVE,
+ current_directory = ERROR_CURRENT_DIRECTORY,
+ not_same_device = ERROR_NOT_SAME_DEVICE,
+ no_more_files = ERROR_NO_MORE_FILES,
+ write_protect = ERROR_WRITE_PROTECT,
+ bad_unit = ERROR_BAD_UNIT,
+ not_ready = ERROR_NOT_READY,
+ bad_command = ERROR_BAD_COMMAND,
+ crc = ERROR_CRC,
+ bad_length = ERROR_BAD_LENGTH,
+ seek = ERROR_SEEK,
+ not_dos_disk = ERROR_NOT_DOS_DISK,
+ sector_not_found = ERROR_SECTOR_NOT_FOUND,
+ out_of_paper = ERROR_OUT_OF_PAPER,
+ write_fault = ERROR_WRITE_FAULT,
+ read_fault = ERROR_READ_FAULT,
+ gen_failure = ERROR_GEN_FAILURE,
+ sharing_violation = ERROR_SHARING_VIOLATION,
+ lock_violation = ERROR_LOCK_VIOLATION,
+ wrong_disk = ERROR_WRONG_DISK,
+ sharing_buffer_exceeded = ERROR_SHARING_BUFFER_EXCEEDED,
+ handle_eof = ERROR_HANDLE_EOF,
+ handle_disk_full= ERROR_HANDLE_DISK_FULL,
+ rem_not_list = ERROR_REM_NOT_LIST,
+ dup_name = ERROR_DUP_NAME,
+ bad_net_path = ERROR_BAD_NETPATH,
+ network_busy = ERROR_NETWORK_BUSY,
+ // ...
+ file_exists = ERROR_FILE_EXISTS,
+ cannot_make = ERROR_CANNOT_MAKE,
+ // ...
+ broken_pipe = ERROR_BROKEN_PIPE,
+ open_failed = ERROR_OPEN_FAILED,
+ buffer_overflow = ERROR_BUFFER_OVERFLOW,
+ disk_full= ERROR_DISK_FULL,
+ // ...
+ lock_failed = ERROR_LOCK_FAILED,
+ busy = ERROR_BUSY,
+ cancel_violation = ERROR_CANCEL_VIOLATION,
+ already_exists = ERROR_ALREADY_EXISTS
+ // ...
+
+ // TODO: add more Windows errors
+ };
+
+ } // namespace windows
+
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+ namespace windows = windows_error;
+# endif
+
+ template<> struct is_error_code_enum<windows_error::windows_error_code>
+ { static const bool value = true; };
+
+ namespace windows_error
+ {
+ inline error_code make_error_code( windows_error_code e )
+ { return error_code( e, get_system_category() ); }
+ }
+
+ } // namespace system
+} // namespace boost
+
+#endif // BOOST_WINDOWS_API
+
+#endif // BOOST_WINDOWS_ERROR_HPP