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