From d8f28ec8a2faabad3aabb9f7a26755971424ef05 Mon Sep 17 00:00:00 2001 From: theraven Date: Tue, 22 Nov 2011 17:30:41 +0000 Subject: Import libcxxrt / libc++ into a vendor branch. Approved by: dim (mentor) --- include/system_error | 643 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 643 insertions(+) create mode 100644 include/system_error (limited to 'include/system_error') diff --git a/include/system_error b/include/system_error new file mode 100644 index 0000000..ea96a66 --- /dev/null +++ b/include/system_error @@ -0,0 +1,643 @@ +// -*- C++ -*- +//===---------------------------- system_error ----------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_SYSTEM_ERROR +#define _LIBCPP_SYSTEM_ERROR + +/* + system_error synopsis + +namespace std +{ + +class error_category +{ +public: + virtual ~error_category() noexcept; + + error_category(const error_category&) = delete; + error_category& operator=(const error_category&) = delete; + + virtual const char* name() const noexcept = 0; + virtual error_condition default_error_condition(int ev) const noexcept; + virtual bool equivalent(int code, const error_condition& condition) const noexcept; + virtual bool equivalent(const error_code& code, int condition) const noexcept; + virtual string message(int ev) const = 0; + + bool operator==(const error_category& rhs) const noexcept; + bool operator!=(const error_category& rhs) const noexcept; + bool operator<(const error_category& rhs) const noexcept; +}; + +const error_category& generic_category() noexcept; +const error_category& system_category() noexcept; + +template struct is_error_code_enum + : public false_type {}; + +template struct is_error_condition_enum + : public false_type {}; + +class error_code +{ +public: + // constructors: + error_code() noexcept; + error_code(int val, const error_category& cat) noexcept; + template + error_code(ErrorCodeEnum e) noexcept; + + // modifiers: + void assign(int val, const error_category& cat) noexcept; + template + error_code& operator=(ErrorCodeEnum e) noexcept; + void clear() noexcept; + + // observers: + int value() const noexcept; + const error_category& category() const noexcept; + error_condition default_error_condition() const noexcept; + string message() const; + explicit operator bool() const noexcept; +}; + +// non-member functions: +bool operator<(const error_code& lhs, const error_code& rhs) noexcept; +template + basic_ostream& + operator<<(basic_ostream& os, const error_code& ec); + +class error_condition +{ +public: + // constructors: + error_condition() noexcept; + error_condition(int val, const error_category& cat) noexcept; + template + error_condition(ErrorConditionEnum e) noexcept; + + // modifiers: + void assign(int val, const error_category& cat) noexcept; + template + error_condition& operator=(ErrorConditionEnum e) noexcept; + void clear() noexcept; + + // observers: + int value() const noexcept; + const error_category& category() const noexcept; + string message() const noexcept; + explicit operator bool() const noexcept; +}; + +bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept; + +class system_error + : public runtime_error +{ +public: + system_error(error_code ec, const string& what_arg); + system_error(error_code ec, const char* what_arg); + system_error(error_code ec); + system_error(int ev, const error_category& ecat, const string& what_arg); + system_error(int ev, const error_category& ecat, const char* what_arg); + system_error(int ev, const error_category& ecat); + + const error_code& code() const noexcept; + const char* what() const noexcept; +}; + +enum class errc +{ + 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_symbolic_link_levels, // ELOOP + value_too_large, // EOVERFLOW + wrong_protocol_type // EPROTOTYPE +}; + +template <> struct is_error_condition_enum + : true_type { } + +error_code make_error_code(errc e) noexcept; +error_condition make_error_condition(errc e) noexcept; + +// Comparison operators: +bool operator==(const error_code& lhs, const error_code& rhs) noexcept; +bool operator==(const error_code& lhs, const error_condition& rhs) noexcept; +bool operator==(const error_condition& lhs, const error_code& rhs) noexcept; +bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept; +bool operator!=(const error_code& lhs, const error_code& rhs) noexcept; +bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept; +bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept; +bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept; + +template <> struct hash; + +} // std + +*/ + +#include <__config> +#include +#include +#include +#include <__functional_base> + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +_LIBCPP_BEGIN_NAMESPACE_STD + +// is_error_code_enum + +template +struct _LIBCPP_VISIBLE is_error_code_enum + : public false_type {}; + +// is_error_condition_enum + +template +struct _LIBCPP_VISIBLE is_error_condition_enum + : public false_type {}; + +// Some error codes are not present on all platforms, so we provide equivalents +// for them: + +//enum class errc +struct errc +{ +enum _ { + 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, +#ifdef ENODATA + no_message_available = ENODATA, +#else + no_message_available = ENOMSG, +#endif + no_message = ENOMSG, + no_protocol_option = ENOPROTOOPT, + no_space_on_device = ENOSPC, +#ifdef ENOSR + no_stream_resources = ENOSR, +#else + no_stream_resources = ENOMEM, +#endif + 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, +#ifdef ENOSTR + not_a_stream = ENOSTR, +#else + not_a_stream = EINVAL, +#endif + 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, +#ifdef ETIME + stream_timeout = ETIME, +#else + stream_timeout = ETIMEDOUT, +#endif + 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_symbolic_link_levels = ELOOP, + value_too_large = EOVERFLOW, + wrong_protocol_type = EPROTOTYPE +}; + + _ __v_; + + _LIBCPP_ALWAYS_INLINE + errc(_ __v) : __v_(__v) {} + _LIBCPP_ALWAYS_INLINE + operator int() const {return __v_;} + +}; + +template <> +struct _LIBCPP_VISIBLE is_error_condition_enum + : true_type { }; + +template <> +struct _LIBCPP_VISIBLE is_error_condition_enum + : true_type { }; + +class error_condition; +class error_code; + +// class error_category + +class __do_message; + +class _LIBCPP_VISIBLE error_category +{ +public: + virtual ~error_category() _NOEXCEPT; + +private: + error_category() _NOEXCEPT; + error_category(const error_category&);// = delete; + error_category& operator=(const error_category&);// = delete; + +public: + virtual const char* name() const _NOEXCEPT = 0; + virtual error_condition default_error_condition(int __ev) const _NOEXCEPT; + virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT; + virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT; + virtual string message(int __ev) const = 0; + + _LIBCPP_ALWAYS_INLINE + bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;} + + _LIBCPP_ALWAYS_INLINE + bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);} + + _LIBCPP_ALWAYS_INLINE + bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;} + + friend class __do_message; +}; + +class _LIBCPP_HIDDEN __do_message + : public error_category +{ +public: + virtual string message(int ev) const; +}; + +const error_category& generic_category() _NOEXCEPT; +const error_category& system_category() _NOEXCEPT; + +class _LIBCPP_VISIBLE error_condition +{ + int __val_; + const error_category* __cat_; +public: + _LIBCPP_ALWAYS_INLINE + error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {} + + _LIBCPP_ALWAYS_INLINE + error_condition(int __val, const error_category& __cat) _NOEXCEPT + : __val_(__val), __cat_(&__cat) {} + + template + _LIBCPP_ALWAYS_INLINE + error_condition(_E __e, + typename enable_if::value>::type* = 0 + ) _NOEXCEPT + {*this = make_error_condition(__e);} + + _LIBCPP_ALWAYS_INLINE + void assign(int __val, const error_category& __cat) _NOEXCEPT + { + __val_ = __val; + __cat_ = &__cat; + } + + template + _LIBCPP_ALWAYS_INLINE + typename enable_if + < + is_error_condition_enum<_E>::value, + error_condition& + >::type + operator=(_E __e) _NOEXCEPT + {*this = make_error_condition(__e); return *this;} + + _LIBCPP_ALWAYS_INLINE + void clear() _NOEXCEPT + { + __val_ = 0; + __cat_ = &generic_category(); + } + + _LIBCPP_ALWAYS_INLINE + int value() const _NOEXCEPT {return __val_;} + + _LIBCPP_ALWAYS_INLINE + const error_category& category() const _NOEXCEPT {return *__cat_;} + string message() const; + + _LIBCPP_ALWAYS_INLINE + //explicit + operator bool() const _NOEXCEPT {return __val_ != 0;} +}; + +inline _LIBCPP_INLINE_VISIBILITY +error_condition +make_error_condition(errc __e) _NOEXCEPT +{ + return error_condition(static_cast(__e), generic_category()); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT +{ + return __x.category() < __y.category() + || __x.category() == __y.category() && __x.value() < __y.value(); +} + +// error_code + +class _LIBCPP_VISIBLE error_code +{ + int __val_; + const error_category* __cat_; +public: + _LIBCPP_ALWAYS_INLINE + error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {} + + _LIBCPP_ALWAYS_INLINE + error_code(int __val, const error_category& __cat) _NOEXCEPT + : __val_(__val), __cat_(&__cat) {} + + template + _LIBCPP_ALWAYS_INLINE + error_code(_E __e, + typename enable_if::value>::type* = 0 + ) _NOEXCEPT + {*this = make_error_code(__e);} + + _LIBCPP_ALWAYS_INLINE + void assign(int __val, const error_category& __cat) _NOEXCEPT + { + __val_ = __val; + __cat_ = &__cat; + } + + template + _LIBCPP_ALWAYS_INLINE + typename enable_if + < + is_error_code_enum<_E>::value, + error_code& + >::type + operator=(_E __e) _NOEXCEPT + {*this = make_error_code(__e); return *this;} + + _LIBCPP_ALWAYS_INLINE + void clear() _NOEXCEPT + { + __val_ = 0; + __cat_ = &system_category(); + } + + _LIBCPP_ALWAYS_INLINE + int value() const _NOEXCEPT {return __val_;} + + _LIBCPP_ALWAYS_INLINE + const error_category& category() const _NOEXCEPT {return *__cat_;} + + _LIBCPP_ALWAYS_INLINE + error_condition default_error_condition() const _NOEXCEPT + {return __cat_->default_error_condition(__val_);} + + string message() const; + + _LIBCPP_ALWAYS_INLINE + //explicit + operator bool() const _NOEXCEPT {return __val_ != 0;} +}; + +inline _LIBCPP_INLINE_VISIBILITY +error_code +make_error_code(errc __e) _NOEXCEPT +{ + return error_code(static_cast(__e), generic_category()); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +operator<(const error_code& __x, const error_code& __y) _NOEXCEPT +{ + return __x.category() < __y.category() + || __x.category() == __y.category() && __x.value() < __y.value(); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +operator==(const error_code& __x, const error_code& __y) _NOEXCEPT +{ + return __x.category() == __y.category() && __x.value() == __y.value(); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT +{ + return __x.category().equivalent(__x.value(), __y) + || __y.category().equivalent(__x, __y.value()); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT +{ + return __y == __x; +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT +{ + return __x.category() == __y.category() && __x.value() == __y.value(); +} + +inline _LIBCPP_INLINE_VISIBILITY +bool +operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT +{return !(__x == __y);} + +inline _LIBCPP_INLINE_VISIBILITY +bool +operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT +{return !(__x == __y);} + +inline _LIBCPP_INLINE_VISIBILITY +bool +operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT +{return !(__x == __y);} + +inline _LIBCPP_INLINE_VISIBILITY +bool +operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT +{return !(__x == __y);} + +template <> +struct _LIBCPP_VISIBLE hash + : public unary_function +{ + _LIBCPP_INLINE_VISIBILITY + size_t operator()(const error_code& __ec) const _NOEXCEPT + { + return static_cast(__ec.value()); + } +}; + +// system_error + +class _LIBCPP_VISIBLE system_error + : public runtime_error +{ + error_code __ec_; +public: + system_error(error_code __ec, const string& __what_arg); + system_error(error_code __ec, const char* __what_arg); + system_error(error_code __ec); + system_error(int __ev, const error_category& __ecat, const string& __what_arg); + system_error(int __ev, const error_category& __ecat, const char* __what_arg); + system_error(int __ev, const error_category& __ecat); + ~system_error() _NOEXCEPT; + + _LIBCPP_ALWAYS_INLINE + const error_code& code() const _NOEXCEPT {return __ec_;} + +private: + static string __init(const error_code&, string); +}; + +void __throw_system_error(int ev, const char* what_arg); + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_SYSTEM_ERROR -- cgit v1.1