2 //===---------------------------- system_error ----------------------------===//
4 // The LLVM Compiler Infrastructure
6 // This file is dual licensed under the MIT and the University of Illinois Open
7 // Source Licenses. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
11 #ifndef _LIBCPP_SYSTEM_ERROR
12 #define _LIBCPP_SYSTEM_ERROR
23 virtual ~error_category() noexcept;
25 constexpr error_category();
26 error_category(const error_category&) = delete;
27 error_category& operator=(const error_category&) = delete;
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;
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;
40 const error_category& generic_category() noexcept;
41 const error_category& system_category() noexcept;
43 template <class T> struct is_error_code_enum
44 : public false_type {};
46 template <class T> struct is_error_condition_enum
47 : public false_type {};
50 inline constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; // C++17
53 inline constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value; // C++17
59 error_code() noexcept;
60 error_code(int val, const error_category& cat) noexcept;
61 template <class ErrorCodeEnum>
62 error_code(ErrorCodeEnum e) noexcept;
65 void assign(int val, const error_category& cat) noexcept;
66 template <class ErrorCodeEnum>
67 error_code& operator=(ErrorCodeEnum e) noexcept;
68 void clear() noexcept;
71 int value() const noexcept;
72 const error_category& category() const noexcept;
73 error_condition default_error_condition() const noexcept;
74 string message() const;
75 explicit operator bool() const noexcept;
78 // non-member functions:
79 bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
80 template <class charT, class traits>
81 basic_ostream<charT,traits>&
82 operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
88 error_condition() noexcept;
89 error_condition(int val, const error_category& cat) noexcept;
90 template <class ErrorConditionEnum>
91 error_condition(ErrorConditionEnum e) noexcept;
94 void assign(int val, const error_category& cat) noexcept;
95 template <class ErrorConditionEnum>
96 error_condition& operator=(ErrorConditionEnum e) noexcept;
97 void clear() noexcept;
100 int value() const noexcept;
101 const error_category& category() const noexcept;
102 string message() const noexcept;
103 explicit operator bool() const noexcept;
106 bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
109 : public runtime_error
112 system_error(error_code ec, const string& what_arg);
113 system_error(error_code ec, const char* what_arg);
114 system_error(error_code ec);
115 system_error(int ev, const error_category& ecat, const string& what_arg);
116 system_error(int ev, const error_category& ecat, const char* what_arg);
117 system_error(int ev, const error_category& ecat);
119 const error_code& code() const noexcept;
120 const char* what() const noexcept;
125 address_family_not_supported, // EAFNOSUPPORT
126 address_in_use, // EADDRINUSE
127 address_not_available, // EADDRNOTAVAIL
128 already_connected, // EISCONN
129 argument_list_too_long, // E2BIG
130 argument_out_of_domain, // EDOM
131 bad_address, // EFAULT
132 bad_file_descriptor, // EBADF
133 bad_message, // EBADMSG
134 broken_pipe, // EPIPE
135 connection_aborted, // ECONNABORTED
136 connection_already_in_progress, // EALREADY
137 connection_refused, // ECONNREFUSED
138 connection_reset, // ECONNRESET
139 cross_device_link, // EXDEV
140 destination_address_required, // EDESTADDRREQ
141 device_or_resource_busy, // EBUSY
142 directory_not_empty, // ENOTEMPTY
143 executable_format_error, // ENOEXEC
144 file_exists, // EEXIST
145 file_too_large, // EFBIG
146 filename_too_long, // ENAMETOOLONG
147 function_not_supported, // ENOSYS
148 host_unreachable, // EHOSTUNREACH
149 identifier_removed, // EIDRM
150 illegal_byte_sequence, // EILSEQ
151 inappropriate_io_control_operation, // ENOTTY
152 interrupted, // EINTR
153 invalid_argument, // EINVAL
154 invalid_seek, // ESPIPE
156 is_a_directory, // EISDIR
157 message_size, // EMSGSIZE
158 network_down, // ENETDOWN
159 network_reset, // ENETRESET
160 network_unreachable, // ENETUNREACH
161 no_buffer_space, // ENOBUFS
162 no_child_process, // ECHILD
164 no_lock_available, // ENOLCK
165 no_message_available, // ENODATA
166 no_message, // ENOMSG
167 no_protocol_option, // ENOPROTOOPT
168 no_space_on_device, // ENOSPC
169 no_stream_resources, // ENOSR
170 no_such_device_or_address, // ENXIO
171 no_such_device, // ENODEV
172 no_such_file_or_directory, // ENOENT
173 no_such_process, // ESRCH
174 not_a_directory, // ENOTDIR
175 not_a_socket, // ENOTSOCK
176 not_a_stream, // ENOSTR
177 not_connected, // ENOTCONN
178 not_enough_memory, // ENOMEM
179 not_supported, // ENOTSUP
180 operation_canceled, // ECANCELED
181 operation_in_progress, // EINPROGRESS
182 operation_not_permitted, // EPERM
183 operation_not_supported, // EOPNOTSUPP
184 operation_would_block, // EWOULDBLOCK
185 owner_dead, // EOWNERDEAD
186 permission_denied, // EACCES
187 protocol_error, // EPROTO
188 protocol_not_supported, // EPROTONOSUPPORT
189 read_only_file_system, // EROFS
190 resource_deadlock_would_occur, // EDEADLK
191 resource_unavailable_try_again, // EAGAIN
192 result_out_of_range, // ERANGE
193 state_not_recoverable, // ENOTRECOVERABLE
194 stream_timeout, // ETIME
195 text_file_busy, // ETXTBSY
196 timed_out, // ETIMEDOUT
197 too_many_files_open_in_system, // ENFILE
198 too_many_files_open, // EMFILE
199 too_many_links, // EMLINK
200 too_many_symbolic_link_levels, // ELOOP
201 value_too_large, // EOVERFLOW
202 wrong_protocol_type // EPROTOTYPE
205 template <> struct is_error_condition_enum<errc>
208 error_code make_error_code(errc e) noexcept;
209 error_condition make_error_condition(errc e) noexcept;
211 // Comparison operators:
212 bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
213 bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
214 bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
215 bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
216 bool operator!=(const error_code& lhs, const error_code& rhs) noexcept;
217 bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
218 bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
219 bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
221 template <> struct hash<std::error_code>;
222 template <> struct hash<std::error_condition>;
230 #include <type_traits>
232 #include <__functional_base>
235 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
236 #pragma GCC system_header
239 _LIBCPP_BEGIN_NAMESPACE_STD
241 // is_error_code_enum
244 struct _LIBCPP_TEMPLATE_VIS is_error_code_enum
245 : public false_type {};
247 #if _LIBCPP_STD_VER > 14
249 _LIBCPP_INLINE_VAR constexpr size_t is_error_code_enum_v = is_error_code_enum<_Tp>::value;
252 // is_error_condition_enum
255 struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum
256 : public false_type {};
258 #if _LIBCPP_STD_VER > 14
260 _LIBCPP_INLINE_VAR constexpr size_t is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
263 // Some error codes are not present on all platforms, so we provide equivalents
267 _LIBCPP_DECLARE_STRONG_ENUM(errc)
269 address_family_not_supported = EAFNOSUPPORT,
270 address_in_use = EADDRINUSE,
271 address_not_available = EADDRNOTAVAIL,
272 already_connected = EISCONN,
273 argument_list_too_long = E2BIG,
274 argument_out_of_domain = EDOM,
275 bad_address = EFAULT,
276 bad_file_descriptor = EBADF,
277 bad_message = EBADMSG,
279 connection_aborted = ECONNABORTED,
280 connection_already_in_progress = EALREADY,
281 connection_refused = ECONNREFUSED,
282 connection_reset = ECONNRESET,
283 cross_device_link = EXDEV,
284 destination_address_required = EDESTADDRREQ,
285 device_or_resource_busy = EBUSY,
286 directory_not_empty = ENOTEMPTY,
287 executable_format_error = ENOEXEC,
288 file_exists = EEXIST,
289 file_too_large = EFBIG,
290 filename_too_long = ENAMETOOLONG,
291 function_not_supported = ENOSYS,
292 host_unreachable = EHOSTUNREACH,
293 identifier_removed = EIDRM,
294 illegal_byte_sequence = EILSEQ,
295 inappropriate_io_control_operation = ENOTTY,
297 invalid_argument = EINVAL,
298 invalid_seek = ESPIPE,
300 is_a_directory = EISDIR,
301 message_size = EMSGSIZE,
302 network_down = ENETDOWN,
303 network_reset = ENETRESET,
304 network_unreachable = ENETUNREACH,
305 no_buffer_space = ENOBUFS,
306 no_child_process = ECHILD,
308 no_lock_available = ENOLCK,
310 no_message_available = ENODATA,
312 no_message_available = ENOMSG,
315 no_protocol_option = ENOPROTOOPT,
316 no_space_on_device = ENOSPC,
318 no_stream_resources = ENOSR,
320 no_stream_resources = ENOMEM,
322 no_such_device_or_address = ENXIO,
323 no_such_device = ENODEV,
324 no_such_file_or_directory = ENOENT,
325 no_such_process = ESRCH,
326 not_a_directory = ENOTDIR,
327 not_a_socket = ENOTSOCK,
329 not_a_stream = ENOSTR,
331 not_a_stream = EINVAL,
333 not_connected = ENOTCONN,
334 not_enough_memory = ENOMEM,
335 not_supported = ENOTSUP,
336 operation_canceled = ECANCELED,
337 operation_in_progress = EINPROGRESS,
338 operation_not_permitted = EPERM,
339 operation_not_supported = EOPNOTSUPP,
340 operation_would_block = EWOULDBLOCK,
341 owner_dead = EOWNERDEAD,
342 permission_denied = EACCES,
343 protocol_error = EPROTO,
344 protocol_not_supported = EPROTONOSUPPORT,
345 read_only_file_system = EROFS,
346 resource_deadlock_would_occur = EDEADLK,
347 resource_unavailable_try_again = EAGAIN,
348 result_out_of_range = ERANGE,
349 state_not_recoverable = ENOTRECOVERABLE,
351 stream_timeout = ETIME,
353 stream_timeout = ETIMEDOUT,
355 text_file_busy = ETXTBSY,
356 timed_out = ETIMEDOUT,
357 too_many_files_open_in_system = ENFILE,
358 too_many_files_open = EMFILE,
359 too_many_links = EMLINK,
360 too_many_symbolic_link_levels = ELOOP,
361 value_too_large = EOVERFLOW,
362 wrong_protocol_type = EPROTOTYPE
364 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc)
367 struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc>
370 #ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
372 struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx>
376 class _LIBCPP_TYPE_VIS error_condition;
377 class _LIBCPP_TYPE_VIS error_code;
379 // class error_category
381 class _LIBCPP_HIDDEN __do_message;
383 class _LIBCPP_TYPE_VIS error_category
386 virtual ~error_category() _NOEXCEPT;
388 #if defined(_LIBCPP_BUILDING_SYSTEM_ERROR) && \
389 defined(_LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS)
390 error_category() _NOEXCEPT;
392 _LIBCPP_ALWAYS_INLINE
393 _LIBCPP_CONSTEXPR_AFTER_CXX11 error_category() _NOEXCEPT _LIBCPP_DEFAULT
396 error_category(const error_category&);// = delete;
397 error_category& operator=(const error_category&);// = delete;
400 virtual const char* name() const _NOEXCEPT = 0;
401 virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
402 virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
403 virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
404 virtual string message(int __ev) const = 0;
406 _LIBCPP_ALWAYS_INLINE
407 bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
409 _LIBCPP_ALWAYS_INLINE
410 bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
412 _LIBCPP_ALWAYS_INLINE
413 bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
415 friend class _LIBCPP_HIDDEN __do_message;
418 class _LIBCPP_HIDDEN __do_message
419 : public error_category
422 virtual string message(int ev) const;
425 _LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
426 _LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
428 class _LIBCPP_TYPE_VIS error_condition
431 const error_category* __cat_;
433 _LIBCPP_ALWAYS_INLINE
434 error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
436 _LIBCPP_ALWAYS_INLINE
437 error_condition(int __val, const error_category& __cat) _NOEXCEPT
438 : __val_(__val), __cat_(&__cat) {}
441 _LIBCPP_ALWAYS_INLINE
442 error_condition(_Ep __e,
443 typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0
445 {*this = make_error_condition(__e);}
447 _LIBCPP_ALWAYS_INLINE
448 void assign(int __val, const error_category& __cat) _NOEXCEPT
455 _LIBCPP_ALWAYS_INLINE
458 is_error_condition_enum<_Ep>::value,
461 operator=(_Ep __e) _NOEXCEPT
462 {*this = make_error_condition(__e); return *this;}
464 _LIBCPP_ALWAYS_INLINE
465 void clear() _NOEXCEPT
468 __cat_ = &generic_category();
471 _LIBCPP_ALWAYS_INLINE
472 int value() const _NOEXCEPT {return __val_;}
474 _LIBCPP_ALWAYS_INLINE
475 const error_category& category() const _NOEXCEPT {return *__cat_;}
476 string message() const;
478 _LIBCPP_ALWAYS_INLINE
480 operator bool() const _NOEXCEPT {return __val_ != 0;}
483 inline _LIBCPP_INLINE_VISIBILITY
485 make_error_condition(errc __e) _NOEXCEPT
487 return error_condition(static_cast<int>(__e), generic_category());
490 inline _LIBCPP_INLINE_VISIBILITY
492 operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
494 return __x.category() < __y.category()
495 || (__x.category() == __y.category() && __x.value() < __y.value());
500 class _LIBCPP_TYPE_VIS error_code
503 const error_category* __cat_;
505 _LIBCPP_ALWAYS_INLINE
506 error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
508 _LIBCPP_ALWAYS_INLINE
509 error_code(int __val, const error_category& __cat) _NOEXCEPT
510 : __val_(__val), __cat_(&__cat) {}
513 _LIBCPP_ALWAYS_INLINE
515 typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0
517 {*this = make_error_code(__e);}
519 _LIBCPP_ALWAYS_INLINE
520 void assign(int __val, const error_category& __cat) _NOEXCEPT
527 _LIBCPP_ALWAYS_INLINE
530 is_error_code_enum<_Ep>::value,
533 operator=(_Ep __e) _NOEXCEPT
534 {*this = make_error_code(__e); return *this;}
536 _LIBCPP_ALWAYS_INLINE
537 void clear() _NOEXCEPT
540 __cat_ = &system_category();
543 _LIBCPP_ALWAYS_INLINE
544 int value() const _NOEXCEPT {return __val_;}
546 _LIBCPP_ALWAYS_INLINE
547 const error_category& category() const _NOEXCEPT {return *__cat_;}
549 _LIBCPP_ALWAYS_INLINE
550 error_condition default_error_condition() const _NOEXCEPT
551 {return __cat_->default_error_condition(__val_);}
553 string message() const;
555 _LIBCPP_ALWAYS_INLINE
557 operator bool() const _NOEXCEPT {return __val_ != 0;}
560 inline _LIBCPP_INLINE_VISIBILITY
562 make_error_code(errc __e) _NOEXCEPT
564 return error_code(static_cast<int>(__e), generic_category());
567 inline _LIBCPP_INLINE_VISIBILITY
569 operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
571 return __x.category() < __y.category()
572 || (__x.category() == __y.category() && __x.value() < __y.value());
575 inline _LIBCPP_INLINE_VISIBILITY
577 operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
579 return __x.category() == __y.category() && __x.value() == __y.value();
582 inline _LIBCPP_INLINE_VISIBILITY
584 operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
586 return __x.category().equivalent(__x.value(), __y)
587 || __y.category().equivalent(__x, __y.value());
590 inline _LIBCPP_INLINE_VISIBILITY
592 operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
597 inline _LIBCPP_INLINE_VISIBILITY
599 operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
601 return __x.category() == __y.category() && __x.value() == __y.value();
604 inline _LIBCPP_INLINE_VISIBILITY
606 operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
607 {return !(__x == __y);}
609 inline _LIBCPP_INLINE_VISIBILITY
611 operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
612 {return !(__x == __y);}
614 inline _LIBCPP_INLINE_VISIBILITY
616 operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
617 {return !(__x == __y);}
619 inline _LIBCPP_INLINE_VISIBILITY
621 operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
622 {return !(__x == __y);}
625 struct _LIBCPP_TEMPLATE_VIS hash<error_code>
626 : public unary_function<error_code, size_t>
628 _LIBCPP_INLINE_VISIBILITY
629 size_t operator()(const error_code& __ec) const _NOEXCEPT
631 return static_cast<size_t>(__ec.value());
636 struct _LIBCPP_TEMPLATE_VIS hash<error_condition>
637 : public unary_function<error_condition, size_t>
639 _LIBCPP_INLINE_VISIBILITY
640 size_t operator()(const error_condition& __ec) const _NOEXCEPT
642 return static_cast<size_t>(__ec.value());
648 class _LIBCPP_TYPE_VIS system_error
649 : public runtime_error
653 system_error(error_code __ec, const string& __what_arg);
654 system_error(error_code __ec, const char* __what_arg);
655 system_error(error_code __ec);
656 system_error(int __ev, const error_category& __ecat, const string& __what_arg);
657 system_error(int __ev, const error_category& __ecat, const char* __what_arg);
658 system_error(int __ev, const error_category& __ecat);
659 ~system_error() _NOEXCEPT;
661 _LIBCPP_ALWAYS_INLINE
662 const error_code& code() const _NOEXCEPT {return __ec_;}
665 static string __init(const error_code&, string);
668 _LIBCPP_NORETURN _LIBCPP_FUNC_VIS
669 void __throw_system_error(int ev, const char* what_arg);
671 _LIBCPP_END_NAMESPACE_STD
673 #endif // _LIBCPP_SYSTEM_ERROR