This is an archive of the discontinued LLVM Phabricator instance.

Differential D147886

[libc++] Formats the sytem_error headers.
ClosedPublic

Authored by Mordante on Apr 9 2023, 9:02 AM.

Details

Reviewers
Mordante
Group Reviewers
Restricted Project
Commits
rG51f0b809ca76: [libc++] Formats the sytem_error headers.

Diff Detail

Event Timeline

Mordante created this revision.Apr 9 2023, 9:02 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 9 2023, 9:02 AM
Herald added subscribers: fedor.sergeev, arichardson. · View Herald Transcript
Harbormaster completed remote builds in B224468: Diff 512018.Apr 9 2023, 9:28 AM
Mordante updated this revision to Diff 512022.Apr 9 2023, 9:38 AM

Fix CI.

Harbormaster completed remote builds in B224472: Diff 512022.Apr 9 2023, 12:41 PM
Mordante updated this revision to Diff 512464.Apr 11 2023, 8:13 AM

Resolve rebase conflicts and test CI.

Harbormaster completed remote builds in B224788: Diff 512464.Apr 11 2023, 9:34 AM
Mordante published this revision for review.Apr 11 2023, 9:38 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 11 2023, 9:38 AM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added a subscriber: libcxx-commits. · View Herald Transcript
Mordante accepted this revision.Apr 11 2023, 9:39 AM
This revision is now accepted and ready to land.Apr 11 2023, 9:39 AM
This revision was landed with ongoing or failed builds.Apr 11 2023, 9:40 AM
Closed by commit rG51f0b809ca76: [libc++] Formats the sytem_error headers. (authored by Mordante). · Explain Why
This revision was automatically updated to reflect the committed changes.
Mordante added a commit: rG51f0b809ca76: [libc++] Formats the sytem_error headers..

Revision Contents

PathSize
libcxx/
include/
__system_error/
48 lines
206 lines
167 lines
34 lines
utils/
data/
4 lines

Diff 512496

libcxx/include/__system_error/error_category.h

Show All 19 Lines
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_TYPE_VIS error_condition; class _LIBCPP_TYPE_VIS error_condition;
class _LIBCPP_TYPE_VIS error_code; class _LIBCPP_TYPE_VIS error_code;
class _LIBCPP_HIDDEN __do_message; class _LIBCPP_HIDDEN __do_message;
class _LIBCPP_TYPE_VIS error_category class _LIBCPP_TYPE_VIS error_category {
{
public: public:
virtual ~error_category() _NOEXCEPT; virtual ~error_category() _NOEXCEPT;
#if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS) #if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)
error_category() noexcept; error_category() noexcept;
#else #else
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 error_category() _NOEXCEPT = default;
_LIBCPP_CONSTEXPR_SINCE_CXX14 error_category() _NOEXCEPT = default;
#endif #endif
error_category(const error_category&) = delete; error_category(const error_category&) = delete;
error_category& operator=(const error_category&) = delete; error_category& operator=(const error_category&) = delete;
virtual const char* name() const _NOEXCEPT = 0; virtual const char* name() const _NOEXCEPT = 0;
virtual error_condition default_error_condition(int __ev) const _NOEXCEPT; virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT; virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT; virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
virtual string message(int __ev) const = 0; virtual string message(int __ev) const = 0;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY bool operator==(const error_category& __rhs) const _NOEXCEPT { return this == &__rhs; }
bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
#if _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 20
_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(const error_category& __rhs) const noexcept {
strong_ordering operator<=>(const error_category& __rhs) const noexcept {return compare_three_way()(this, std::addressof(__rhs));} return compare_three_way()(this, std::addressof(__rhs));
}
#else // _LIBCPP_STD_VER >= 20 #else // _LIBCPP_STD_VER >= 20
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY bool operator!=(const error_category& __rhs) const _NOEXCEPT { return !(*this == __rhs); }
bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY bool operator<(const error_category& __rhs) const _NOEXCEPT { return this < &__rhs; }
bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
#endif // _LIBCPP_STD_VER >= 20 #endif // _LIBCPP_STD_VER >= 20
friend class _LIBCPP_HIDDEN __do_message; friend class _LIBCPP_HIDDEN __do_message;
}; };
class _LIBCPP_HIDDEN __do_message class _LIBCPP_HIDDEN __do_message : public error_category {
: public error_category
{
public: public:
string message(int __ev) const override; string message(int __ev) const override;
}; };
_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT; _LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
_LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT; _LIBCPP_FUNC_VIS const error_category& system_category() _NOEXCEPT;
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___SYSTEM_ERROR_ERROR_CATEGORY_H #endif // _LIBCPP___SYSTEM_ERROR_ERROR_CATEGORY_H

libcxx/include/__system_error/error_code.h

Show All 21 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_error_code_enum struct _LIBCPP_TEMPLATE_VIS is_error_code_enum : public false_type {};
: public false_type {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value; inline constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value;
#endif #endif
namespace __adl_only { namespace __adl_only {
// Those cause ADL to trigger but they are not viable candidates, // Those cause ADL to trigger but they are not viable candidates,
// so they are never actually selected. // so they are never actually selected.
void make_error_code() = delete; void make_error_code() = delete;
} // namespace __adl_only } // namespace __adl_only
class _LIBCPP_TYPE_VIS error_code class _LIBCPP_TYPE_VIS error_code {
{
int __val_; int __val_;
const error_category* __cat_; const error_category* __cat_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY error_code(int __val, const error_category& __cat) _NOEXCEPT
error_code(int __val, const error_category& __cat) _NOEXCEPT : __val_(__val),
: __val_(__val), __cat_(&__cat) {} __cat_(&__cat) {}
template <class _Ep> template <class _Ep>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
error_code(_Ep __e, error_code(_Ep __e, typename enable_if<is_error_code_enum<_Ep>::value>::type* = nullptr) _NOEXCEPT {
typename enable_if<is_error_code_enum<_Ep>::value>::type* = nullptr
) _NOEXCEPT
{
using __adl_only::make_error_code; using __adl_only::make_error_code;
*this = make_error_code(__e); *this = make_error_code(__e);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY void assign(int __val, const error_category& __cat) _NOEXCEPT {
void assign(int __val, const error_category& __cat) _NOEXCEPT
{
__val_ = __val; __val_ = __val;
__cat_ = &__cat; __cat_ = &__cat;
} }
template <class _Ep> template <class _Ep>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY typename enable_if< is_error_code_enum<_Ep>::value, error_code& >::type
typename enable_if operator=(_Ep __e) _NOEXCEPT {
<
is_error_code_enum<_Ep>::value,
error_code&
>::type
operator=(_Ep __e) _NOEXCEPT
{
using __adl_only::make_error_code; using __adl_only::make_error_code;
*this = make_error_code(__e); *this = make_error_code(__e);
return *this; return *this;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY void clear() _NOEXCEPT {
void clear() _NOEXCEPT
{
__val_ = 0; __val_ = 0;
__cat_ = &system_category(); __cat_ = &system_category();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY int value() const _NOEXCEPT { return __val_; }
int value() const _NOEXCEPT {return __val_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY const error_category& category() const _NOEXCEPT { return *__cat_; }
const error_category& category() const _NOEXCEPT {return *__cat_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY error_condition default_error_condition() const _NOEXCEPT {
error_condition default_error_condition() const _NOEXCEPT return __cat_->default_error_condition(__val_);
{return __cat_->default_error_condition(__val_);} }
string message() const; string message() const;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY explicit operator bool() const _NOEXCEPT { return __val_ != 0; }
explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
}; };
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY error_code make_error_code(errc __e) _NOEXCEPT {
error_code
make_error_code(errc __e) _NOEXCEPT
{
return error_code(static_cast<int>(__e), generic_category()); return error_code(static_cast<int>(__e), generic_category());
} }
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY bool operator==(const error_code& __x, const error_code& __y) _NOEXCEPT {
bool
operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
{
return __x.category() == __y.category() && __x.value() == __y.value(); return __x.category() == __y.category() && __x.value() == __y.value();
} }
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY bool operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT {
bool return __x.category().equivalent(__x.value(), __y) || __y.category().equivalent(__x, __y.value());
operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
{
return __x.category().equivalent(__x.value(), __y)
|| __y.category().equivalent(__x, __y.value());
} }
#if _LIBCPP_STD_VER <= 17 #if _LIBCPP_STD_VER <= 17
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY bool operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT {
bool
operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
{
return __y == __x; return __y == __x;
} }
#endif #endif
#if _LIBCPP_STD_VER <= 17 #if _LIBCPP_STD_VER <= 17
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT {
bool return !(__x == __y);
operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT }
{return !(__x == __y);}
inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT {
inline _LIBCPP_INLINE_VISIBILITY return !(__x == __y);
bool }
operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
{return !(__x == __y);} inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT {
return !(__x == __y);
inline _LIBCPP_INLINE_VISIBILITY }
bool
operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT inline _LIBCPP_INLINE_VISIBILITY bool operator<(const error_code& __x, const error_code& __y) _NOEXCEPT {
{return !(__x == __y);} return __x.category() < __y.category() || (__x.category() == __y.category() && __x.value() < __y.value());
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
{
return __x.category() < __y.category()
|| (__x.category() == __y.category() && __x.value() < __y.value());
} }
#else // _LIBCPP_STD_VER <= 17 #else // _LIBCPP_STD_VER <= 17
inline _LIBCPP_HIDE_FROM_ABI strong_ordering inline _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(const error_code& __x, const error_code& __y) noexcept {
operator<=>(const error_code& __x, const error_code& __y) noexcept
{
if (auto __c = __x.category() <=> __y.category(); __c != 0) if (auto __c = __x.category() <=> __y.category(); __c != 0)
return __c; return __c;
return __x.value() <=> __y.value(); return __x.value() <=> __y.value();
} }
#endif // _LIBCPP_STD_VER <= 17 #endif // _LIBCPP_STD_VER <= 17
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<error_code> struct _LIBCPP_TEMPLATE_VIS hash<error_code> : public __unary_function<error_code, size_t> {
: public __unary_function<error_code, size_t> _LIBCPP_INLINE_VISIBILITY size_t operator()(const error_code& __ec) const _NOEXCEPT {
{
_LIBCPP_INLINE_VISIBILITY
size_t operator()(const error_code& __ec) const _NOEXCEPT
{
return static_cast<size_t>(__ec.value()); return static_cast<size_t>(__ec.value());
} }
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H #endif // _LIBCPP___SYSTEM_ERROR_ERROR_CODE_H

libcxx/include/__system_error/error_condition.h

Show All 19 Lines
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Tp> template <class _Tp>
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum : public false_type {};
: public false_type {};
#if _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 17
template <class _Tp> template <class _Tp>
inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value; inline constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Tp>::value;
#endif #endif
template <> template <>
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc> struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc> : true_type {};
: true_type { };
#ifdef _LIBCPP_CXX03_LANG #ifdef _LIBCPP_CXX03_LANG
template <> template <>
struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx> struct _LIBCPP_TEMPLATE_VIS is_error_condition_enum<errc::__lx> : true_type {};
: true_type { };
#endif #endif
namespace __adl_only { namespace __adl_only {
// Those cause ADL to trigger but they are not viable candidates, // Those cause ADL to trigger but they are not viable candidates,
// so they are never actually selected. // so they are never actually selected.
void make_error_condition() = delete; void make_error_condition() = delete;
} // namespace __adl_only } // namespace __adl_only
class _LIBCPP_TYPE_VIS error_condition class _LIBCPP_TYPE_VIS error_condition {
{
int __val_; int __val_;
const error_category* __cat_; const error_category* __cat_;
public: public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY error_condition(int __val, const error_category& __cat) _NOEXCEPT
error_condition(int __val, const error_category& __cat) _NOEXCEPT : __val_(__val),
: __val_(__val), __cat_(&__cat) {} __cat_(&__cat) {}
template <class _Ep> template <class _Ep>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY
error_condition(_Ep __e, error_condition(_Ep __e, typename enable_if<is_error_condition_enum<_Ep>::value>::type* = nullptr) _NOEXCEPT {
typename enable_if<is_error_condition_enum<_Ep>::value>::type* = nullptr
) _NOEXCEPT
{
using __adl_only::make_error_condition; using __adl_only::make_error_condition;
*this = make_error_condition(__e); *this = make_error_condition(__e);
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY void assign(int __val, const error_category& __cat) _NOEXCEPT {
void assign(int __val, const error_category& __cat) _NOEXCEPT
{
__val_ = __val; __val_ = __val;
__cat_ = &__cat; __cat_ = &__cat;
} }
template <class _Ep> template <class _Ep>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY typename enable_if< is_error_condition_enum<_Ep>::value, error_condition& >::type
typename enable_if operator=(_Ep __e) _NOEXCEPT {
<
is_error_condition_enum<_Ep>::value,
error_condition&
>::type
operator=(_Ep __e) _NOEXCEPT
{
using __adl_only::make_error_condition; using __adl_only::make_error_condition;
*this = make_error_condition(__e); *this = make_error_condition(__e);
return *this; return *this;
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY void clear() _NOEXCEPT {
void clear() _NOEXCEPT
{
__val_ = 0; __val_ = 0;
__cat_ = &generic_category(); __cat_ = &generic_category();
} }
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY int value() const _NOEXCEPT { return __val_; }
int value() const _NOEXCEPT {return __val_;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY const error_category& category() const _NOEXCEPT { return *__cat_; }
const error_category& category() const _NOEXCEPT {return *__cat_;}
string message() const; string message() const;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY explicit operator bool() const _NOEXCEPT { return __val_ != 0; }
explicit operator bool() const _NOEXCEPT {return __val_ != 0;}
}; };
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY error_condition make_error_condition(errc __e) _NOEXCEPT {
error_condition
make_error_condition(errc __e) _NOEXCEPT
{
return error_condition(static_cast<int>(__e), generic_category()); return error_condition(static_cast<int>(__e), generic_category());
} }
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY bool operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT {
bool
operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
{
return __x.category() == __y.category() && __x.value() == __y.value(); return __x.category() == __y.category() && __x.value() == __y.value();
} }
#if _LIBCPP_STD_VER <= 17 #if _LIBCPP_STD_VER <= 17
inline _LIBCPP_INLINE_VISIBILITY inline _LIBCPP_INLINE_VISIBILITY bool operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT {
bool return !(__x == __y);
operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
{return !(__x == __y);}
inline _LIBCPP_INLINE_VISIBILITY
bool
operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
{
return __x.category() < __y.category()
|| (__x.category() == __y.category() && __x.value() < __y.value());
} }
inline _LIBCPP_INLINE_VISIBILITY bool operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT {
return __x.category() < __y.category() || (__x.category() == __y.category() && __x.value() < __y.value());
}
#else // _LIBCPP_STD_VER <= 17 #else // _LIBCPP_STD_VER <= 17
inline _LIBCPP_HIDE_FROM_ABI strong_ordering inline _LIBCPP_HIDE_FROM_ABI strong_ordering
operator<=>(const error_condition& __x, const error_condition& __y) noexcept operator<=>(const error_condition& __x, const error_condition& __y) noexcept {
{
if (auto __c = __x.category() <=> __y.category(); __c != 0) if (auto __c = __x.category() <=> __y.category(); __c != 0)
return __c; return __c;
return __x.value() <=> __y.value(); return __x.value() <=> __y.value();
} }
#endif // _LIBCPP_STD_VER <= 17 #endif // _LIBCPP_STD_VER <= 17
template <> template <>
struct _LIBCPP_TEMPLATE_VIS hash<error_condition> struct _LIBCPP_TEMPLATE_VIS hash<error_condition> : public __unary_function<error_condition, size_t> {
: public __unary_function<error_condition, size_t> _LIBCPP_INLINE_VISIBILITY size_t operator()(const error_condition& __ec) const _NOEXCEPT {
{
_LIBCPP_INLINE_VISIBILITY
size_t operator()(const error_condition& __ec) const _NOEXCEPT
{
return static_cast<size_t>(__ec.value()); return static_cast<size_t>(__ec.value());
} }
}; };
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___SYSTEM_ERROR_ERROR_CONDITION_H #endif // _LIBCPP___SYSTEM_ERROR_ERROR_CONDITION_H

libcxx/include/__system_error/system_error.h

Show All 16 Lines
#include <string> #include <string>
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
# pragma GCC system_header # pragma GCC system_header
#endif #endif
_LIBCPP_BEGIN_NAMESPACE_STD _LIBCPP_BEGIN_NAMESPACE_STD
class _LIBCPP_TYPE_VIS system_error class _LIBCPP_TYPE_VIS system_error : public runtime_error {
: public runtime_error
{
error_code __ec_; error_code __ec_;
public: public:
system_error(error_code __ec, const string& __what_arg); system_error(error_code __ec, const string& __what_arg);
system_error(error_code __ec, const char* __what_arg); system_error(error_code __ec, const char* __what_arg);
system_error(error_code __ec); system_error(error_code __ec);
system_error(int __ev, const error_category& __ecat, const string& __what_arg); system_error(int __ev, const error_category& __ecat, const string& __what_arg);
system_error(int __ev, const error_category& __ecat, const char* __what_arg); system_error(int __ev, const error_category& __ecat, const char* __what_arg);
system_error(int __ev, const error_category& __ecat); system_error(int __ev, const error_category& __ecat);
system_error(const system_error&) _NOEXCEPT = default; system_error(const system_error&) _NOEXCEPT = default;
~system_error() _NOEXCEPT override; ~system_error() _NOEXCEPT override;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_INLINE_VISIBILITY const error_code& code() const _NOEXCEPT { return __ec_; }
const error_code& code() const _NOEXCEPT {return __ec_;}
private: private:
static string __init(const error_code&, string); static string __init(const error_code&, string);
}; };
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS _LIBCPP_NORETURN _LIBCPP_FUNC_VIS void __throw_system_error(int __ev, const char* __what_arg);
void __throw_system_error(int __ev, const char* __what_arg);
_LIBCPP_END_NAMESPACE_STD _LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP___SYSTEM_ERROR_SYSTEM_ERROR_H #endif // _LIBCPP___SYSTEM_ERROR_SYSTEM_ERROR_H

libcxx/utils/data/ignore_format.txt

Show First 20 Lines • Show All 605 Lines • ▼ Show 20 Lines
libcxx/include/__support/ibm/locale_mgmt_zos.h libcxx/include/__support/ibm/locale_mgmt_zos.h
libcxx/include/__support/ibm/nanosleep.h libcxx/include/__support/ibm/nanosleep.h
libcxx/include/__support/ibm/xlocale.h libcxx/include/__support/ibm/xlocale.h
libcxx/include/__support/newlib/xlocale.h libcxx/include/__support/newlib/xlocale.h
libcxx/include/__support/solaris/xlocale.h libcxx/include/__support/solaris/xlocale.h
libcxx/include/__support/win32/locale_win32.h libcxx/include/__support/win32/locale_win32.h
libcxx/include/__support/xlocale/__nop_locale_mgmt.h libcxx/include/__support/xlocale/__nop_locale_mgmt.h
libcxx/include/__system_error/errc.h libcxx/include/__system_error/errc.h
libcxx/include/__system_error/error_category.h
libcxx/include/__system_error/error_code.h
libcxx/include/__system_error/error_condition.h
libcxx/include/__system_error/system_error.h
libcxx/include/thread libcxx/include/thread
libcxx/include/__threading_support libcxx/include/__threading_support
libcxx/include/__thread/poll_with_backoff.h libcxx/include/__thread/poll_with_backoff.h
libcxx/include/__thread/timed_backoff_policy.h libcxx/include/__thread/timed_backoff_policy.h
libcxx/include/__tree libcxx/include/__tree
libcxx/include/tuple libcxx/include/tuple
libcxx/include/__tuple_dir/apply_cv.h libcxx/include/__tuple_dir/apply_cv.h
libcxx/include/__tuple_dir/make_tuple_types.h libcxx/include/__tuple_dir/make_tuple_types.h
▲ Show 20 Lines • Show All 217 Lines • Show Last 20 Lines