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
error_category(const error_category&) = delete;
26
error_category& operator=(const error_category&) = delete;
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;
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;
39
const error_category& generic_category() noexcept;
40
const error_category& system_category() noexcept;
42
template <class T> struct is_error_code_enum
43
: public false_type {};
45
template <class T> struct is_error_condition_enum
46
: public false_type {};
52
error_code() noexcept;
53
error_code(int val, const error_category& cat) noexcept;
54
template <class ErrorCodeEnum>
55
error_code(ErrorCodeEnum e) noexcept;
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;
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;
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);
81
error_condition() noexcept;
82
error_condition(int val, const error_category& cat) noexcept;
83
template <class ErrorConditionEnum>
84
error_condition(ErrorConditionEnum e) noexcept;
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;
93
int value() const noexcept;
94
const error_category& category() const noexcept;
95
string message() const noexcept;
96
explicit operator bool() const noexcept;
99
bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
102
: public runtime_error
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);
112
const error_code& code() const noexcept;
113
const char* what() const noexcept;
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
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
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
198
template <> struct is_error_condition_enum<errc>
201
error_code make_error_code(errc e) noexcept;
202
error_condition make_error_condition(errc e) noexcept;
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;
214
template <> struct hash<std::error_code>;
222
#include <type_traits>
224
#include <__functional_base>
226
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
227
#pragma GCC system_header
230
_LIBCPP_BEGIN_NAMESPACE_STD
232
// is_error_code_enum
235
struct _LIBCPP_TYPE_VIS is_error_code_enum
236
: public false_type {};
238
// is_error_condition_enum
241
struct _LIBCPP_TYPE_VIS is_error_condition_enum
242
: public false_type {};
244
// Some error codes are not present on all platforms, so we provide equivalents
248
_LIBCPP_DECLARE_STRONG_ENUM(errc)
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,
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,
278
invalid_argument = EINVAL,
279
invalid_seek = ESPIPE,
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,
289
no_lock_available = ENOLCK,
291
no_message_available = ENODATA,
293
no_message_available = ENOMSG,
296
no_protocol_option = ENOPROTOOPT,
297
no_space_on_device = ENOSPC,
299
no_stream_resources = ENOSR,
301
no_stream_resources = ENOMEM,
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,
310
not_a_stream = ENOSTR,
312
not_a_stream = EINVAL,
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,
332
stream_timeout = ETIME,
334
stream_timeout = ETIMEDOUT,
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
345
_LIBCPP_DECLARE_STRONG_ENUM_EPILOG(errc)
348
struct _LIBCPP_TYPE_VIS is_error_condition_enum<errc>
351
#ifdef _LIBCPP_HAS_NO_STRONG_ENUMS
353
struct _LIBCPP_TYPE_VIS is_error_condition_enum<errc::__lx>
357
class _LIBCPP_TYPE_VIS error_condition;
358
class _LIBCPP_TYPE_VIS error_code;
360
// class error_category
362
class _LIBCPP_HIDDEN __do_message;
364
class _LIBCPP_TYPE_VIS error_category
367
virtual ~error_category() _NOEXCEPT;
369
error_category() _NOEXCEPT;
371
error_category(const error_category&);// = delete;
372
error_category& operator=(const error_category&);// = delete;
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;
381
_LIBCPP_ALWAYS_INLINE
382
bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
384
_LIBCPP_ALWAYS_INLINE
385
bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
387
_LIBCPP_ALWAYS_INLINE
388
bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
390
friend class _LIBCPP_HIDDEN __do_message;
393
class _LIBCPP_HIDDEN __do_message
394
: public error_category
397
virtual string message(int ev) const;
400
const error_category& generic_category() _NOEXCEPT;
401
const error_category& system_category() _NOEXCEPT;
403
class _LIBCPP_TYPE_VIS error_condition
406
const error_category* __cat_;
408
_LIBCPP_ALWAYS_INLINE
409
error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
411
_LIBCPP_ALWAYS_INLINE
412
error_condition(int __val, const error_category& __cat) _NOEXCEPT
413
: __val_(__val), __cat_(&__cat) {}
416
_LIBCPP_ALWAYS_INLINE
417
error_condition(_Ep __e,
418
typename enable_if<is_error_condition_enum<_Ep>::value>::type* = 0
420
{*this = make_error_condition(__e);}
422
_LIBCPP_ALWAYS_INLINE
423
void assign(int __val, const error_category& __cat) _NOEXCEPT
430
_LIBCPP_ALWAYS_INLINE
433
is_error_condition_enum<_Ep>::value,
436
operator=(_Ep __e) _NOEXCEPT
437
{*this = make_error_condition(__e); return *this;}
439
_LIBCPP_ALWAYS_INLINE
440
void clear() _NOEXCEPT
443
__cat_ = &generic_category();
446
_LIBCPP_ALWAYS_INLINE
447
int value() const _NOEXCEPT {return __val_;}
449
_LIBCPP_ALWAYS_INLINE
450
const error_category& category() const _NOEXCEPT {return *__cat_;}
451
string message() const;
453
_LIBCPP_ALWAYS_INLINE
455
operator bool() const _NOEXCEPT {return __val_ != 0;}
458
inline _LIBCPP_INLINE_VISIBILITY
460
make_error_condition(errc __e) _NOEXCEPT
462
return error_condition(static_cast<int>(__e), generic_category());
465
inline _LIBCPP_INLINE_VISIBILITY
467
operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
469
return __x.category() < __y.category()
470
|| (__x.category() == __y.category() && __x.value() < __y.value());
475
class _LIBCPP_TYPE_VIS error_code
478
const error_category* __cat_;
480
_LIBCPP_ALWAYS_INLINE
481
error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
483
_LIBCPP_ALWAYS_INLINE
484
error_code(int __val, const error_category& __cat) _NOEXCEPT
485
: __val_(__val), __cat_(&__cat) {}
488
_LIBCPP_ALWAYS_INLINE
490
typename enable_if<is_error_code_enum<_Ep>::value>::type* = 0
492
{*this = make_error_code(__e);}
494
_LIBCPP_ALWAYS_INLINE
495
void assign(int __val, const error_category& __cat) _NOEXCEPT
502
_LIBCPP_ALWAYS_INLINE
505
is_error_code_enum<_Ep>::value,
508
operator=(_Ep __e) _NOEXCEPT
509
{*this = make_error_code(__e); return *this;}
511
_LIBCPP_ALWAYS_INLINE
512
void clear() _NOEXCEPT
515
__cat_ = &system_category();
518
_LIBCPP_ALWAYS_INLINE
519
int value() const _NOEXCEPT {return __val_;}
521
_LIBCPP_ALWAYS_INLINE
522
const error_category& category() const _NOEXCEPT {return *__cat_;}
524
_LIBCPP_ALWAYS_INLINE
525
error_condition default_error_condition() const _NOEXCEPT
526
{return __cat_->default_error_condition(__val_);}
528
string message() const;
530
_LIBCPP_ALWAYS_INLINE
532
operator bool() const _NOEXCEPT {return __val_ != 0;}
535
inline _LIBCPP_INLINE_VISIBILITY
537
make_error_code(errc __e) _NOEXCEPT
539
return error_code(static_cast<int>(__e), generic_category());
542
inline _LIBCPP_INLINE_VISIBILITY
544
operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
546
return __x.category() < __y.category()
547
|| (__x.category() == __y.category() && __x.value() < __y.value());
550
inline _LIBCPP_INLINE_VISIBILITY
552
operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
554
return __x.category() == __y.category() && __x.value() == __y.value();
557
inline _LIBCPP_INLINE_VISIBILITY
559
operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
561
return __x.category().equivalent(__x.value(), __y)
562
|| __y.category().equivalent(__x, __y.value());
565
inline _LIBCPP_INLINE_VISIBILITY
567
operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
572
inline _LIBCPP_INLINE_VISIBILITY
574
operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
576
return __x.category() == __y.category() && __x.value() == __y.value();
579
inline _LIBCPP_INLINE_VISIBILITY
581
operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
582
{return !(__x == __y);}
584
inline _LIBCPP_INLINE_VISIBILITY
586
operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
587
{return !(__x == __y);}
589
inline _LIBCPP_INLINE_VISIBILITY
591
operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
592
{return !(__x == __y);}
594
inline _LIBCPP_INLINE_VISIBILITY
596
operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
597
{return !(__x == __y);}
600
struct _LIBCPP_TYPE_VIS hash<error_code>
601
: public unary_function<error_code, size_t>
603
_LIBCPP_INLINE_VISIBILITY
604
size_t operator()(const error_code& __ec) const _NOEXCEPT
606
return static_cast<size_t>(__ec.value());
612
class _LIBCPP_TYPE_VIS system_error
613
: public runtime_error
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;
625
_LIBCPP_ALWAYS_INLINE
626
const error_code& code() const _NOEXCEPT {return __ec_;}
629
static string __init(const error_code&, string);
632
void __throw_system_error(int ev, const char* what_arg);
634
_LIBCPP_END_NAMESPACE_STD
636
#endif // _LIBCPP_SYSTEM_ERROR