contrib/libc++/include/system_error

   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     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
  39 const error_category& generic_category() noexcept;
  40 const error_category& system_category() noexcept;
  41
  42 template <class T> struct is_error_code_enum
  43     : public false_type {};
  44
  45 template <class T> struct is_error_condition_enum
  46     : public false_type {};
  47
  48 class error_code
  49 {
  50 public:
  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:
  72 bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
  73 template <class charT, class traits>
  74     basic_ostream<charT,traits>&
  75     operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
  76
  77 class error_condition
  78 {
  79 public:
  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
  99 bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
 100
 101 class system_error
 102     : public runtime_error
 103 {
 104 public:
 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
 116 enum 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
 198 template <> struct is_error_condition_enum<errc>
 199     : true_type { }
 200
 201 error_code make_error_code(errc e) noexcept;
 202 error_condition make_error_condition(errc e) noexcept;
 203
 204 // Comparison operators:
 205 bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
 206 bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
 207 bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
 208 bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
 209 bool operator!=(const error_code& lhs, const error_code& rhs) noexcept;
 210 bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
 211 bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
 212 bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
 213
 214 template <> 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
 234 template <class _Tp>
 235 struct _LIBCPP_TYPE_VIS is_error_code_enum
 236     : public false_type {};
 237
 238 // is_error_condition_enum
 239
 240 template <class _Tp>
 241 struct _LIBCPP_TYPE_VIS 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
 347 template <>
 348 struct _LIBCPP_TYPE_VIS is_error_condition_enum<errc>
 349     : true_type { };
 350
 351 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
 352 template <>
 353 struct _LIBCPP_TYPE_VIS is_error_condition_enum<errc::__lx>
 354     : true_type { };
 355 #endif
 356
 357 class _LIBCPP_TYPE_VIS error_condition;
 358 class _LIBCPP_TYPE_VIS error_code;
 359
 360 // class error_category
 361
 362 class _LIBCPP_HIDDEN __do_message;
 363
 364 class _LIBCPP_TYPE_VIS error_category
 365 {
 366 public:
 367     virtual ~error_category() _NOEXCEPT;
 368
 369     error_category() _NOEXCEPT;
 370 private:
 371     error_category(const error_category&);// = delete;
 372     error_category& operator=(const error_category&);// = delete;
 373
 374 public:
 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
 393 class _LIBCPP_HIDDEN __do_message
 394     : public error_category
 395 {
 396 public:
 397     virtual string message(int ev) const;
 398 };
 399
 400 const error_category& generic_category() _NOEXCEPT;
 401 const error_category& system_category() _NOEXCEPT;
 402
 403 class _LIBCPP_TYPE_VIS error_condition
 404 {
 405     int __val_;
 406     const error_category* __cat_;
 407 public:
 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
 458 inline _LIBCPP_INLINE_VISIBILITY
 459 error_condition
 460 make_error_condition(errc __e) _NOEXCEPT
 461 {
 462     return error_condition(static_cast<int>(__e), generic_category());
 463 }
 464
 465 inline _LIBCPP_INLINE_VISIBILITY
 466 bool
 467 operator<(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
 475 class _LIBCPP_TYPE_VIS error_code
 476 {
 477     int __val_;
 478     const error_category* __cat_;
 479 public:
 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
 535 inline _LIBCPP_INLINE_VISIBILITY
 536 error_code
 537 make_error_code(errc __e) _NOEXCEPT
 538 {
 539     return error_code(static_cast<int>(__e), generic_category());
 540 }
 541
 542 inline _LIBCPP_INLINE_VISIBILITY
 543 bool
 544 operator<(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
 550 inline _LIBCPP_INLINE_VISIBILITY
 551 bool
 552 operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
 553 {
 554     return __x.category() == __y.category() && __x.value() == __y.value();
 555 }
 556
 557 inline _LIBCPP_INLINE_VISIBILITY
 558 bool
 559 operator==(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
 565 inline _LIBCPP_INLINE_VISIBILITY
 566 bool
 567 operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
 568 {
 569     return __y == __x;
 570 }
 571
 572 inline _LIBCPP_INLINE_VISIBILITY
 573 bool
 574 operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
 575 {
 576     return __x.category() == __y.category() && __x.value() == __y.value();
 577 }
 578
 579 inline _LIBCPP_INLINE_VISIBILITY
 580 bool
 581 operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
 582 {return !(__x == __y);}
 583
 584 inline _LIBCPP_INLINE_VISIBILITY
 585 bool
 586 operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
 587 {return !(__x == __y);}
 588
 589 inline _LIBCPP_INLINE_VISIBILITY
 590 bool
 591 operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
 592 {return !(__x == __y);}
 593
 594 inline _LIBCPP_INLINE_VISIBILITY
 595 bool
 596 operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
 597 {return !(__x == __y);}
 598
 599 template <>
 600 struct _LIBCPP_TYPE_VIS 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
 612 class _LIBCPP_TYPE_VIS system_error
 613     : public runtime_error
 614 {
 615     error_code __ec_;
 616 public:
 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
 628 private:
 629     static string __init(const error_code&, string);
 630 };
 631
 632 void __throw_system_error(int ev, const char* what_arg);
 633
 634 _LIBCPP_END_NAMESPACE_STD
 635
 636 #endif  // _LIBCPP_SYSTEM_ERROR