system_error revision 227825
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 248struct errc 249{ 250enum _ { 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 347 _ __v_; 348 349 _LIBCPP_ALWAYS_INLINE 350 errc(_ __v) : __v_(__v) {} 351 _LIBCPP_ALWAYS_INLINE 352 operator int() const {return __v_;} 353 354}; 355 356template <> 357struct _LIBCPP_VISIBLE is_error_condition_enum<errc> 358 : true_type { }; 359 360template <> 361struct _LIBCPP_VISIBLE is_error_condition_enum<errc::_> 362 : true_type { }; 363 364class error_condition; 365class error_code; 366 367// class error_category 368 369class __do_message; 370 371class _LIBCPP_VISIBLE error_category 372{ 373public: 374 virtual ~error_category() _NOEXCEPT; 375 376private: 377 error_category() _NOEXCEPT; 378 error_category(const error_category&);// = delete; 379 error_category& operator=(const error_category&);// = delete; 380 381public: 382 virtual const char* name() const _NOEXCEPT = 0; 383 virtual error_condition default_error_condition(int __ev) const _NOEXCEPT; 384 virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT; 385 virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT; 386 virtual string message(int __ev) const = 0; 387 388 _LIBCPP_ALWAYS_INLINE 389 bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;} 390 391 _LIBCPP_ALWAYS_INLINE 392 bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);} 393 394 _LIBCPP_ALWAYS_INLINE 395 bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;} 396 397 friend class __do_message; 398}; 399 400class _LIBCPP_HIDDEN __do_message 401 : public error_category 402{ 403public: 404 virtual string message(int ev) const; 405}; 406 407const error_category& generic_category() _NOEXCEPT; 408const error_category& system_category() _NOEXCEPT; 409 410class _LIBCPP_VISIBLE error_condition 411{ 412 int __val_; 413 const error_category* __cat_; 414public: 415 _LIBCPP_ALWAYS_INLINE 416 error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {} 417 418 _LIBCPP_ALWAYS_INLINE 419 error_condition(int __val, const error_category& __cat) _NOEXCEPT 420 : __val_(__val), __cat_(&__cat) {} 421 422 template <class _E> 423 _LIBCPP_ALWAYS_INLINE 424 error_condition(_E __e, 425 typename enable_if<is_error_condition_enum<_E>::value>::type* = 0 426 ) _NOEXCEPT 427 {*this = make_error_condition(__e);} 428 429 _LIBCPP_ALWAYS_INLINE 430 void assign(int __val, const error_category& __cat) _NOEXCEPT 431 { 432 __val_ = __val; 433 __cat_ = &__cat; 434 } 435 436 template <class _E> 437 _LIBCPP_ALWAYS_INLINE 438 typename enable_if 439 < 440 is_error_condition_enum<_E>::value, 441 error_condition& 442 >::type 443 operator=(_E __e) _NOEXCEPT 444 {*this = make_error_condition(__e); return *this;} 445 446 _LIBCPP_ALWAYS_INLINE 447 void clear() _NOEXCEPT 448 { 449 __val_ = 0; 450 __cat_ = &generic_category(); 451 } 452 453 _LIBCPP_ALWAYS_INLINE 454 int value() const _NOEXCEPT {return __val_;} 455 456 _LIBCPP_ALWAYS_INLINE 457 const error_category& category() const _NOEXCEPT {return *__cat_;} 458 string message() const; 459 460 _LIBCPP_ALWAYS_INLINE 461 //explicit 462 operator bool() const _NOEXCEPT {return __val_ != 0;} 463}; 464 465inline _LIBCPP_INLINE_VISIBILITY 466error_condition 467make_error_condition(errc __e) _NOEXCEPT 468{ 469 return error_condition(static_cast<int>(__e), generic_category()); 470} 471 472inline _LIBCPP_INLINE_VISIBILITY 473bool 474operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT 475{ 476 return __x.category() < __y.category() 477 || __x.category() == __y.category() && __x.value() < __y.value(); 478} 479 480// error_code 481 482class _LIBCPP_VISIBLE error_code 483{ 484 int __val_; 485 const error_category* __cat_; 486public: 487 _LIBCPP_ALWAYS_INLINE 488 error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {} 489 490 _LIBCPP_ALWAYS_INLINE 491 error_code(int __val, const error_category& __cat) _NOEXCEPT 492 : __val_(__val), __cat_(&__cat) {} 493 494 template <class _E> 495 _LIBCPP_ALWAYS_INLINE 496 error_code(_E __e, 497 typename enable_if<is_error_code_enum<_E>::value>::type* = 0 498 ) _NOEXCEPT 499 {*this = make_error_code(__e);} 500 501 _LIBCPP_ALWAYS_INLINE 502 void assign(int __val, const error_category& __cat) _NOEXCEPT 503 { 504 __val_ = __val; 505 __cat_ = &__cat; 506 } 507 508 template <class _E> 509 _LIBCPP_ALWAYS_INLINE 510 typename enable_if 511 < 512 is_error_code_enum<_E>::value, 513 error_code& 514 >::type 515 operator=(_E __e) _NOEXCEPT 516 {*this = make_error_code(__e); return *this;} 517 518 _LIBCPP_ALWAYS_INLINE 519 void clear() _NOEXCEPT 520 { 521 __val_ = 0; 522 __cat_ = &system_category(); 523 } 524 525 _LIBCPP_ALWAYS_INLINE 526 int value() const _NOEXCEPT {return __val_;} 527 528 _LIBCPP_ALWAYS_INLINE 529 const error_category& category() const _NOEXCEPT {return *__cat_;} 530 531 _LIBCPP_ALWAYS_INLINE 532 error_condition default_error_condition() const _NOEXCEPT 533 {return __cat_->default_error_condition(__val_);} 534 535 string message() const; 536 537 _LIBCPP_ALWAYS_INLINE 538 //explicit 539 operator bool() const _NOEXCEPT {return __val_ != 0;} 540}; 541 542inline _LIBCPP_INLINE_VISIBILITY 543error_code 544make_error_code(errc __e) _NOEXCEPT 545{ 546 return error_code(static_cast<int>(__e), generic_category()); 547} 548 549inline _LIBCPP_INLINE_VISIBILITY 550bool 551operator<(const error_code& __x, const error_code& __y) _NOEXCEPT 552{ 553 return __x.category() < __y.category() 554 || __x.category() == __y.category() && __x.value() < __y.value(); 555} 556 557inline _LIBCPP_INLINE_VISIBILITY 558bool 559operator==(const error_code& __x, const error_code& __y) _NOEXCEPT 560{ 561 return __x.category() == __y.category() && __x.value() == __y.value(); 562} 563 564inline _LIBCPP_INLINE_VISIBILITY 565bool 566operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT 567{ 568 return __x.category().equivalent(__x.value(), __y) 569 || __y.category().equivalent(__x, __y.value()); 570} 571 572inline _LIBCPP_INLINE_VISIBILITY 573bool 574operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT 575{ 576 return __y == __x; 577} 578 579inline _LIBCPP_INLINE_VISIBILITY 580bool 581operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT 582{ 583 return __x.category() == __y.category() && __x.value() == __y.value(); 584} 585 586inline _LIBCPP_INLINE_VISIBILITY 587bool 588operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT 589{return !(__x == __y);} 590 591inline _LIBCPP_INLINE_VISIBILITY 592bool 593operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT 594{return !(__x == __y);} 595 596inline _LIBCPP_INLINE_VISIBILITY 597bool 598operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT 599{return !(__x == __y);} 600 601inline _LIBCPP_INLINE_VISIBILITY 602bool 603operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT 604{return !(__x == __y);} 605 606template <> 607struct _LIBCPP_VISIBLE hash<error_code> 608 : public unary_function<error_code, size_t> 609{ 610 _LIBCPP_INLINE_VISIBILITY 611 size_t operator()(const error_code& __ec) const _NOEXCEPT 612 { 613 return static_cast<size_t>(__ec.value()); 614 } 615}; 616 617// system_error 618 619class _LIBCPP_VISIBLE system_error 620 : public runtime_error 621{ 622 error_code __ec_; 623public: 624 system_error(error_code __ec, const string& __what_arg); 625 system_error(error_code __ec, const char* __what_arg); 626 system_error(error_code __ec); 627 system_error(int __ev, const error_category& __ecat, const string& __what_arg); 628 system_error(int __ev, const error_category& __ecat, const char* __what_arg); 629 system_error(int __ev, const error_category& __ecat); 630 ~system_error() _NOEXCEPT; 631 632 _LIBCPP_ALWAYS_INLINE 633 const error_code& code() const _NOEXCEPT {return __ec_;} 634 635private: 636 static string __init(const error_code&, string); 637}; 638 639void __throw_system_error(int ev, const char* what_arg); 640 641_LIBCPP_END_NAMESPACE_STD 642 643#endif // _LIBCPP_SYSTEM_ERROR 644