1// -*- C++ -*- 2//===---------------------------- system_error ----------------------------===// 3// 4// The LLVM Compiler Infrastructure 5// 6// This file is dual licensed under the MIT and the University of Illinois Open 7// Source Licenses. See LICENSE.TXT for details. 8// 9//===----------------------------------------------------------------------===// 10 11#ifndef _LIBCPP_SYSTEM_ERROR 12#define _LIBCPP_SYSTEM_ERROR 13 14/* 15 system_error synopsis 16 17namespace std 18{ 19 20class error_category 21{ 22public: 23 virtual ~error_category() noexcept; 24 25 constexpr error_category(); 26 error_category(const error_category&) = delete; 27 error_category& operator=(const error_category&) = delete; 28 29 virtual const char* name() const noexcept = 0; 30 virtual error_condition default_error_condition(int ev) const noexcept; 31 virtual bool equivalent(int code, const error_condition& condition) const noexcept; 32 virtual bool equivalent(const error_code& code, int condition) const noexcept; 33 virtual string message(int ev) const = 0; 34 35 bool operator==(const error_category& rhs) const noexcept; 36 bool operator!=(const error_category& rhs) const noexcept; 37 bool operator<(const error_category& rhs) const noexcept; 38}; 39 40const error_category& generic_category() noexcept; 41const error_category& system_category() noexcept; 42 43template <class T> struct is_error_code_enum 44 : public false_type {}; 45 46template <class T> struct is_error_condition_enum 47 : public false_type {}; 48 49class error_code 50{ 51public: 52 // constructors: 53 error_code() noexcept; 54 error_code(int val, const error_category& cat) noexcept; 55 template <class ErrorCodeEnum> 56 error_code(ErrorCodeEnum e) noexcept; 57 58 // modifiers: 59 void assign(int val, const error_category& cat) noexcept; 60 template <class ErrorCodeEnum> 61 error_code& operator=(ErrorCodeEnum e) noexcept; 62 void clear() noexcept; 63 64 // observers: 65 int value() const noexcept; 66 const error_category& category() const noexcept; 67 error_condition default_error_condition() const noexcept; 68 string message() const; 69 explicit operator bool() const noexcept; 70}; 71 72// non-member functions: 73bool operator<(const error_code& lhs, const error_code& rhs) noexcept; 74template <class charT, class traits> 75 basic_ostream<charT,traits>& 76 operator<<(basic_ostream<charT,traits>& os, const error_code& ec); 77 78class error_condition 79{ 80public: 81 // constructors: 82 error_condition() noexcept; 83 error_condition(int val, const error_category& cat) noexcept; 84 template <class ErrorConditionEnum> 85 error_condition(ErrorConditionEnum e) noexcept; 86 87 // modifiers: 88 void assign(int val, const error_category& cat) noexcept; 89 template <class ErrorConditionEnum> 90 error_condition& operator=(ErrorConditionEnum e) noexcept; 91 void clear() noexcept; 92 93 // observers: 94 int value() const noexcept; 95 const error_category& category() const noexcept; 96 string message() const noexcept; 97 explicit operator bool() const noexcept; 98}; 99 100bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept; 101 102class system_error 103 : public runtime_error 104{ 105public: 106 system_error(error_code ec, const string& what_arg); 107 system_error(error_code ec, const char* what_arg); 108 system_error(error_code ec); 109 system_error(int ev, const error_category& ecat, const string& what_arg); 110 system_error(int ev, const error_category& ecat, const char* what_arg); 111 system_error(int ev, const error_category& ecat); 112 113 const error_code& code() const noexcept; 114 const char* what() const noexcept; 115}; 116 117enum class errc 118{ 119 address_family_not_supported, // EAFNOSUPPORT 120 address_in_use, // EADDRINUSE 121 address_not_available, // EADDRNOTAVAIL 122 already_connected, // EISCONN 123 argument_list_too_long, // E2BIG 124 argument_out_of_domain, // EDOM 125 bad_address, // EFAULT 126 bad_file_descriptor, // EBADF 127 bad_message, // EBADMSG 128 broken_pipe, // EPIPE 129 connection_aborted, // ECONNABORTED 130 connection_already_in_progress, // EALREADY 131 connection_refused, // ECONNREFUSED 132 connection_reset, // ECONNRESET 133 cross_device_link, // EXDEV 134 destination_address_required, // EDESTADDRREQ 135 device_or_resource_busy, // EBUSY 136 directory_not_empty, // ENOTEMPTY 137 executable_format_error, // ENOEXEC 138 file_exists, // EEXIST 139 file_too_large, // EFBIG 140 filename_too_long, // ENAMETOOLONG 141 function_not_supported, // ENOSYS 142 host_unreachable, // EHOSTUNREACH 143 identifier_removed, // EIDRM 144 illegal_byte_sequence, // EILSEQ 145 inappropriate_io_control_operation, // ENOTTY 146 interrupted, // EINTR 147 invalid_argument, // EINVAL 148 invalid_seek, // ESPIPE 149 io_error, // EIO 150 is_a_directory, // EISDIR 151 message_size, // EMSGSIZE 152 network_down, // ENETDOWN 153 network_reset, // ENETRESET 154 network_unreachable, // ENETUNREACH 155 no_buffer_space, // ENOBUFS 156 no_child_process, // ECHILD 157 no_link, // ENOLINK 158 no_lock_available, // ENOLCK 159 no_message_available, // ENODATA 160 no_message, // ENOMSG 161 no_protocol_option, // ENOPROTOOPT 162 no_space_on_device, // ENOSPC 163 no_stream_resources, // ENOSR 164 no_such_device_or_address, // ENXIO 165 no_such_device, // ENODEV 166 no_such_file_or_directory, // ENOENT 167 no_such_process, // ESRCH 168 not_a_directory, // ENOTDIR 169 not_a_socket, // ENOTSOCK 170 not_a_stream, // ENOSTR 171 not_connected, // ENOTCONN 172 not_enough_memory, // ENOMEM 173 not_supported, // ENOTSUP 174 operation_canceled, // ECANCELED 175 operation_in_progress, // EINPROGRESS 176 operation_not_permitted, // EPERM 177 operation_not_supported, // EOPNOTSUPP 178 operation_would_block, // EWOULDBLOCK 179 owner_dead, // EOWNERDEAD 180 permission_denied, // EACCES 181 protocol_error, // EPROTO 182 protocol_not_supported, // EPROTONOSUPPORT 183 read_only_file_system, // EROFS 184 resource_deadlock_would_occur, // EDEADLK 185 resource_unavailable_try_again, // EAGAIN 186 result_out_of_range, // ERANGE 187 state_not_recoverable, // ENOTRECOVERABLE 188 stream_timeout, // ETIME 189 text_file_busy, // ETXTBSY 190 timed_out, // ETIMEDOUT 191 too_many_files_open_in_system, // ENFILE 192 too_many_files_open, // EMFILE 193 too_many_links, // EMLINK 194 too_many_symbolic_link_levels, // ELOOP 195 value_too_large, // EOVERFLOW 196 wrong_protocol_type // EPROTOTYPE 197}; 198 199template <> struct is_error_condition_enum<errc> 200 : true_type { } 201 202error_code make_error_code(errc e) noexcept; 203error_condition make_error_condition(errc e) noexcept; 204 205// Comparison operators: 206bool operator==(const error_code& lhs, const error_code& rhs) noexcept; 207bool operator==(const error_code& lhs, const error_condition& rhs) noexcept; 208bool operator==(const error_condition& lhs, const error_code& rhs) noexcept; 209bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept; 210bool operator!=(const error_code& lhs, const error_code& rhs) noexcept; 211bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept; 212bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept; 213bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept; 214 215template <> struct hash<std::error_code>; 216 217} // std 218 219*/ 220 221#include <__config> 222#include <cerrno> 223#include <type_traits> 224#include <stdexcept> 225#include <__functional_base> 226 227#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 228#pragma GCC system_header 229#endif 230 231_LIBCPP_BEGIN_NAMESPACE_STD 232 233// is_error_code_enum 234 235template <class _Tp> 236struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum 237 : public false_type {}; 238 239// is_error_condition_enum 240 241template <class _Tp> 242struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum 243 : public false_type {}; 244 245// Some error codes are not present on all platforms, so we provide equivalents 246// for them: 247 248//enum class errc 249_LIBCPP_DECLARE_STRONG_ENUM(errc) 250{ 251 address_family_not_supported = EAFNOSUPPORT, 252 address_in_use = EADDRINUSE, 253 address_not_available = EADDRNOTAVAIL, 254 already_connected = EISCONN, 255 argument_list_too_long = E2BIG, 256 argument_out_of_domain = EDOM, 257 bad_address = EFAULT, 258 bad_file_descriptor = EBADF, 259 bad_message = EBADMSG, 260 broken_pipe = EPIPE, 261 connection_aborted = ECONNABORTED, 262 connection_already_in_progress = EALREADY, 263 connection_refused = ECONNREFUSED, 264 connection_reset = ECONNRESET, 265 cross_device_link = EXDEV, 266 destination_address_required = EDESTADDRREQ, 267 device_or_resource_busy = EBUSY, 268 directory_not_empty = ENOTEMPTY, 269 executable_format_error = ENOEXEC, 270 file_exists = EEXIST, 271 file_too_large = EFBIG, 272 filename_too_long = ENAMETOOLONG, 273 function_not_supported = ENOSYS, 274 host_unreachable = EHOSTUNREACH, 275 identifier_removed = EIDRM, 276 illegal_byte_sequence = EILSEQ, 277 inappropriate_io_control_operation = ENOTTY, 278 interrupted = EINTR, 279 invalid_argument = EINVAL, 280 invalid_seek = ESPIPE, 281 io_error = EIO, 282 is_a_directory = EISDIR, 283 message_size = EMSGSIZE, 284 network_down = ENETDOWN, 285 network_reset = ENETRESET, 286 network_unreachable = ENETUNREACH, 287 no_buffer_space = ENOBUFS, 288 no_child_process = ECHILD, 289 no_link = ENOLINK, 290 no_lock_available = ENOLCK, 291#ifdef ENODATA 292 no_message_available = ENODATA, 293#else 294 no_message_available = ENOMSG, 295#endif 296 no_message = ENOMSG, 297 no_protocol_option = ENOPROTOOPT, 298 no_space_on_device = ENOSPC, 299#ifdef ENOSR 300 no_stream_resources = ENOSR, 301#else 302 no_stream_resources = ENOMEM, 303#endif 304 no_such_device_or_address = ENXIO, 305 no_such_device = ENODEV, 306 no_such_file_or_directory = ENOENT, 307 no_such_process = ESRCH, 308 not_a_directory = ENOTDIR, 309 not_a_socket = ENOTSOCK, 310#ifdef ENOSTR 311 not_a_stream = ENOSTR, 312#else 313 not_a_stream = EINVAL, 314#endif 315 not_connected = ENOTCONN, 316 not_enough_memory = ENOMEM, 317 not_supported = ENOTSUP, 318 operation_canceled = ECANCELED, 319 operation_in_progress = EINPROGRESS, 320 operation_not_permitted = EPERM, 321 operation_not_supported = EOPNOTSUPP, 322 operation_would_block = EWOULDBLOCK, 323 owner_dead = EOWNERDEAD, 324 permission_denied = EACCES, 325 protocol_error = EPROTO, 326 protocol_not_supported = EPROTONOSUPPORT, 327 read_only_file_system = EROFS, 328 resource_deadlock_would_occur = EDEADLK, 329 resource_unavailable_try_again = EAGAIN, 330 result_out_of_range = ERANGE, 331 state_not_recoverable = ENOTRECOVERABLE, 332#ifdef ETIME 333 stream_timeout = ETIME, 334#else 335 stream_timeout = ETIMEDOUT, 336#endif 337 text_file_busy = ETXTBSY, 338 timed_out = ETIMEDOUT, 339 too_many_files_open_in_system = ENFILE, 340 too_many_files_open = EMFILE, 341 too_many_links = EMLINK, 342 too_many_symbolic_link_levels = ELOOP, 343 value_too_large = EOVERFLOW, 344 wrong_protocol_type = EPROTOTYPE 345}; 346_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc) 347 348template <> 349struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum<errc> 350 : true_type { }; 351 352#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS 353template <> 354struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum<errc::__lx> 355 : true_type { }; 356#endif 357 358class _LIBCPP_TYPE_VIS error_condition; 359class _LIBCPP_TYPE_VIS error_code; 360 361// class error_category 362 363class _LIBCPP_HIDDEN __do_message; 364 365class _LIBCPP_TYPE_VIS error_category 366{ 367public: 368 virtual ~error_category() _NOEXCEPT; 369 370#ifdef _LIBCPP_BUILDING_SYSTEM_ERROR 371 error_category() _NOEXCEPT; 372#else 373 _LIBCPP_ALWAYS_INLINE 374 _LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT _LIBCPP_DEFAULT; 375#endif 376private: 377 error_category(const error_category&);// = delete; 378 error_category& operator=(const error_category&);// = delete; 379 380public: 381 virtual const char* name() const _NOEXCEPT = 0; 382 virtual error_condition default_error_condition(int __ev) const _NOEXCEPT; 383 virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT; 384 virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT; 385 virtual string message(int __ev) const = 0; 386 387 _LIBCPP_ALWAYS_INLINE 388 bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;} 389 390 _LIBCPP_ALWAYS_INLINE 391 bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);} 392 393 _LIBCPP_ALWAYS_INLINE 394 bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;} 395 396 friend class _LIBCPP_HIDDEN __do_message; 397}; 398 399class _LIBCPP_HIDDEN __do_message 400 : public error_category 401{ 402public: 403 virtual string message(int ev) const; 404}; 405 406_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT; 407_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT; 408 409class _LIBCPP_TYPE_VIS error_condition 410{ 411 int __val_; 412 const error_category* __cat_; 413public: 414 _LIBCPP_ALWAYS_INLINE 415 error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {} 416 417 _LIBCPP_ALWAYS_INLINE 418 error_condition(int __val, const error_category& __cat) _NOEXCEPT 419 : __val_(__val), __cat_(&__cat) {} 420 421 template <class _Ep> 422 _LIBCPP_ALWAYS_INLINE 423 error_condition(_Ep __e, 424 typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0 425 ) _NOEXCEPT 426 {*this = make_error_condition(__e);} 427 428 _LIBCPP_ALWAYS_INLINE 429 void assign(int __val, const error_category& __cat) _NOEXCEPT 430 { 431 __val_ = __val; 432 __cat_ = &__cat; 433 } 434 435 template <class _Ep> 436 _LIBCPP_ALWAYS_INLINE 437 typename enable_if 438 < 439 is_error_condition_enum<_Ep>::value, 440 error_condition& 441 >::type 442 operator=(_Ep __e) _NOEXCEPT 443 {*this = make_error_condition(__e); return *this;} 444 445 _LIBCPP_ALWAYS_INLINE 446 void clear() _NOEXCEPT 447 { 448 __val_ = 0; 449 __cat_ = &generic_category(); 450 } 451 452 _LIBCPP_ALWAYS_INLINE 453 int value() const _NOEXCEPT {return __val_;} 454 455 _LIBCPP_ALWAYS_INLINE 456 const error_category& category() const _NOEXCEPT {return *__cat_;} 457 string message() const; 458 459 _LIBCPP_ALWAYS_INLINE 460 _LIBCPP_EXPLICIT 461 operator bool() const _NOEXCEPT {return __val_ != 0;} 462}; 463 464inline _LIBCPP_INLINE_VISIBILITY 465error_condition 466make_error_condition(errc __e) _NOEXCEPT 467{ 468 return error_condition(static_cast<int>(__e), generic_category()); 469} 470 471inline _LIBCPP_INLINE_VISIBILITY 472bool 473operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT 474{ 475 return __x.category() < __y.category() 476 || (__x.category() == __y.category() && __x.value() < __y.value()); 477} 478 479// error_code 480 481class _LIBCPP_TYPE_VIS error_code 482{ 483 int __val_; 484 const error_category* __cat_; 485public: 486 _LIBCPP_ALWAYS_INLINE 487 error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {} 488 489 _LIBCPP_ALWAYS_INLINE 490 error_code(int __val, const error_category& __cat) _NOEXCEPT 491 : __val_(__val), __cat_(&__cat) {} 492 493 template <class _Ep> 494 _LIBCPP_ALWAYS_INLINE 495 error_code(_Ep __e, 496 typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0 497 ) _NOEXCEPT 498 {*this = make_error_code(__e);} 499 500 _LIBCPP_ALWAYS_INLINE 501 void assign(int __val, const error_category& __cat) _NOEXCEPT 502 { 503 __val_ = __val; 504 __cat_ = &__cat; 505 } 506 507 template <class _Ep> 508 _LIBCPP_ALWAYS_INLINE 509 typename enable_if 510 < 511 is_error_code_enum<_Ep>::value, 512 error_code& 513 >::type 514 operator=(_Ep __e) _NOEXCEPT 515 {*this = make_error_code(__e); return *this;} 516 517 _LIBCPP_ALWAYS_INLINE 518 void clear() _NOEXCEPT 519 { 520 __val_ = 0; 521 __cat_ = &system_category(); 522 } 523 524 _LIBCPP_ALWAYS_INLINE 525 int value() const _NOEXCEPT {return __val_;} 526 527 _LIBCPP_ALWAYS_INLINE 528 const error_category& category() const _NOEXCEPT {return *__cat_;} 529 530 _LIBCPP_ALWAYS_INLINE 531 error_condition default_error_condition() const _NOEXCEPT 532 {return __cat_->default_error_condition(__val_);} 533 534 string message() const; 535 536 _LIBCPP_ALWAYS_INLINE 537 _LIBCPP_EXPLICIT 538 operator bool() const _NOEXCEPT {return __val_ != 0;} 539}; 540 541inline _LIBCPP_INLINE_VISIBILITY 542error_code 543make_error_code(errc __e) _NOEXCEPT 544{ 545 return error_code(static_cast<int>(__e), generic_category()); 546} 547 548inline _LIBCPP_INLINE_VISIBILITY 549bool 550operator<(const error_code& __x, const error_code& __y) _NOEXCEPT 551{ 552 return __x.category() < __y.category() 553 || (__x.category() == __y.category() && __x.value() < __y.value()); 554} 555 556inline _LIBCPP_INLINE_VISIBILITY 557bool 558operator==(const error_code& __x, const error_code& __y) _NOEXCEPT 559{ 560 return __x.category() == __y.category() && __x.value() == __y.value(); 561} 562 563inline _LIBCPP_INLINE_VISIBILITY 564bool 565operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT 566{ 567 return __x.category().equivalent(__x.value(), __y) 568 || __y.category().equivalent(__x, __y.value()); 569} 570 571inline _LIBCPP_INLINE_VISIBILITY 572bool 573operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT 574{ 575 return __y == __x; 576} 577 578inline _LIBCPP_INLINE_VISIBILITY 579bool 580operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT 581{ 582 return __x.category() == __y.category() && __x.value() == __y.value(); 583} 584 585inline _LIBCPP_INLINE_VISIBILITY 586bool 587operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT 588{return !(__x == __y);} 589 590inline _LIBCPP_INLINE_VISIBILITY 591bool 592operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT 593{return !(__x == __y);} 594 595inline _LIBCPP_INLINE_VISIBILITY 596bool 597operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT 598{return !(__x == __y);} 599 600inline _LIBCPP_INLINE_VISIBILITY 601bool 602operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT 603{return !(__x == __y);} 604 605template <> 606struct _LIBCPP_TYPE_VIS_ONLY hash<error_code> 607 : public unary_function<error_code, size_t> 608{ 609 _LIBCPP_INLINE_VISIBILITY 610 size_t operator()(const error_code& __ec) const _NOEXCEPT 611 { 612 return static_cast<size_t>(__ec.value()); 613 } 614}; 615 616// system_error 617 618class _LIBCPP_TYPE_VIS system_error 619 : public runtime_error 620{ 621 error_code __ec_; 622public: 623 system_error(error_code __ec, const string& __what_arg); 624 system_error(error_code __ec, const char* __what_arg); 625 system_error(error_code __ec); 626 system_error(int __ev, const error_category& __ecat, const string& __what_arg); 627 system_error(int __ev, const error_category& __ecat, const char* __what_arg); 628 system_error(int __ev, const error_category& __ecat); 629 ~system_error() _NOEXCEPT; 630 631 _LIBCPP_ALWAYS_INLINE 632 const error_code& code() const _NOEXCEPT {return __ec_;} 633 634private: 635 static string __init(const error_code&, string); 636}; 637 638_LIBCPP_FUNC_VIS void __throw_system_error(int ev, const char* what_arg); 639 640_LIBCPP_END_NAMESPACE_STD 641 642#endif // _LIBCPP_SYSTEM_ERROR 643