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 17 namespace std 18 { 19 20 class error_category 21 { 22 public: 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 40 const error_category& generic_category() noexcept; 41 const error_category& system_category() noexcept; 42 43 template <class T> struct is_error_code_enum 44 : public false_type {}; 45 46 template <class T> struct is_error_condition_enum 47 : public false_type {}; 48 49 class error_code 50 { 51 public: 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: 73 bool operator<(const error_code& lhs, const error_code& rhs) noexcept; 74 template <class charT, class traits> 75 basic_ostream<charT,traits>& 76 operator<<(basic_ostream<charT,traits>& os, const error_code& ec); 77 78 class error_condition 79 { 80 public: 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 100 bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept; 101 102 class system_error 103 : public runtime_error 104 { 105 public: 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 117 enum 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 199 template <> struct is_error_condition_enum<errc> 200 : true_type { } 201 202 error_code make_error_code(errc e) noexcept; 203 error_condition make_error_condition(errc e) noexcept; 204 205 // Comparison operators: 206 bool operator==(const error_code& lhs, const error_code& rhs) noexcept; 207 bool operator==(const error_code& lhs, const error_condition& rhs) noexcept; 208 bool operator==(const error_condition& lhs, const error_code& rhs) noexcept; 209 bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept; 210 bool operator!=(const error_code& lhs, const error_code& rhs) noexcept; 211 bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept; 212 bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept; 213 bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept; 214 215 template <> 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 235 template <class _Tp> 236 struct _LIBCPP_TYPE_VIS_ONLY is_error_code_enum 237 : public false_type {}; 238 239 // is_error_condition_enum 240 241 template <class _Tp> 242 struct _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 348 template <> 349 struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum<errc> 350 : true_type { }; 351 352 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS 353 template <> 354 struct _LIBCPP_TYPE_VIS_ONLY is_error_condition_enum<errc::__lx> 355 : true_type { }; 356 #endif 357 358 class _LIBCPP_TYPE_VIS error_condition; 359 class _LIBCPP_TYPE_VIS error_code; 360 361 // class error_category 362 363 class _LIBCPP_HIDDEN __do_message; 364 365 class _LIBCPP_TYPE_VIS error_category 366 { 367 public: 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 376 private: 377 error_category(const error_category&);// = delete; 378 error_category& operator=(const error_category&);// = delete; 379 380 public: 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 399 class _LIBCPP_HIDDEN __do_message 400 : public error_category 401 { 402 public: 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 409 class _LIBCPP_TYPE_VIS error_condition 410 { 411 int __val_; 412 const error_category* __cat_; 413 public: 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 464 inline _LIBCPP_INLINE_VISIBILITY 465 error_condition 466 make_error_condition(errc __e) _NOEXCEPT 467 { 468 return error_condition(static_cast<int>(__e), generic_category()); 469 } 470 471 inline _LIBCPP_INLINE_VISIBILITY 472 bool 473 operator<(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 481 class _LIBCPP_TYPE_VIS error_code 482 { 483 int __val_; 484 const error_category* __cat_; 485 public: 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 541 inline _LIBCPP_INLINE_VISIBILITY 542 error_code 543 make_error_code(errc __e) _NOEXCEPT 544 { 545 return error_code(static_cast<int>(__e), generic_category()); 546 } 547 548 inline _LIBCPP_INLINE_VISIBILITY 549 bool 550 operator<(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 556 inline _LIBCPP_INLINE_VISIBILITY 557 bool 558 operator==(const error_code& __x, const error_code& __y) _NOEXCEPT 559 { 560 return __x.category() == __y.category() && __x.value() == __y.value(); 561 } 562 563 inline _LIBCPP_INLINE_VISIBILITY 564 bool 565 operator==(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 571 inline _LIBCPP_INLINE_VISIBILITY 572 bool 573 operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT 574 { 575 return __y == __x; 576 } 577 578 inline _LIBCPP_INLINE_VISIBILITY 579 bool 580 operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT 581 { 582 return __x.category() == __y.category() && __x.value() == __y.value(); 583 } 584 585 inline _LIBCPP_INLINE_VISIBILITY 586 bool 587 operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT 588 {return !(__x == __y);} 589 590 inline _LIBCPP_INLINE_VISIBILITY 591 bool 592 operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT 593 {return !(__x == __y);} 594 595 inline _LIBCPP_INLINE_VISIBILITY 596 bool 597 operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT 598 {return !(__x == __y);} 599 600 inline _LIBCPP_INLINE_VISIBILITY 601 bool 602 operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT 603 {return !(__x == __y);} 604 605 template <> 606 struct _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 618 class _LIBCPP_TYPE_VIS system_error 619 : public runtime_error 620 { 621 error_code __ec_; 622 public: 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 634 private: 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
