shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity

[libc++] Qualify calls to nullary functions like __throw_foo (#122465)

Browse Source 
This is technically not necessary in most cases to prevent issues with ADL,
but let's be consistent. This allows us to remove the libcpp-qualify-declval
clang-tidy check, which is now enforced by the robust-against-adl clang-tidy check.
This commit is contained in:
Louis Dionne 2025-02-21 07:59:46 -05:00 committed by GitHub
parent e11ca593a2
commit 5e26fb1699
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
58 changed files with 313 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libcxx/docs/CodingGuidelines.rst
View File

@ -36,7 +36,7 @@ Function overloading also applies to operators. Using ``&user_object`` may call
...
}
This is mostly enforced by the clang-tidy checks ``libcpp-robust-against-adl`` and ``libcpp-qualify-declval``.
This is mostly enforced by the clang-tidy check ``libcpp-robust-against-adl``.
Avoid including public headers
==============================

2
libcxx/include/__algorithm/ranges_iterator_concept.h
View File

@ -44,7 +44,7 @@ consteval auto __get_iterator_concept() {
}
template <class _Iter>
using __iterator_concept _LIBCPP_NODEBUG = decltype(__get_iterator_concept<_Iter>());
using __iterator_concept _LIBCPP_NODEBUG = decltype(ranges::__get_iterator_concept<_Iter>());
} // namespace ranges
_LIBCPP_END_NAMESPACE_STD

4
libcxx/include/__algorithm/stable_sort.h
View File

@ -252,8 +252,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX26 void __stable_sort(
is_integral_v<value_type > && is_same_v< value_type&, __iter_reference<_RandomAccessIterator>>;
constexpr auto __allowed_radix_sort = __default_comp && __integral_value;
if constexpr (__allowed_radix_sort) {
if (__len <= __buff_size && __len >= static_cast<difference_type>(__radix_sort_min_bound<value_type>()) &&
__len <= static_cast<difference_type>(__radix_sort_max_bound<value_type>())) {
if (__len <= __buff_size && __len >= static_cast<difference_type>(std::__radix_sort_min_bound<value_type>()) &&
__len <= static_cast<difference_type>(std::__radix_sort_max_bound<value_type>())) {
if (__libcpp_is_constant_evaluated()) {
for (auto* __p = __buff; __p < __buff + __buff_size; ++__p) {
std::__construct_at(__p);

4
libcxx/include/__chrono/formatter.h
View File

@ -315,7 +315,7 @@ _LIBCPP_HIDE_FROM_ABI void __format_chrono_using_chrono_specs(
case _CharT('T'):
__facet.put(
{__sstr}, __sstr, _CharT(' '), std::addressof(__t), std::to_address(__s), std::to_address(__it + 1));
if constexpr (__use_fraction<_Tp>())
if constexpr (__formatter::__use_fraction<_Tp>())
__formatter::__format_sub_seconds(__sstr, __value);
break;
@ -378,7 +378,7 @@ _LIBCPP_HIDE_FROM_ABI void __format_chrono_using_chrono_specs(
break;
case _CharT('O'):
if constexpr (__use_fraction<_Tp>()) {
if constexpr (__formatter::__use_fraction<_Tp>()) {
// Handle OS using the normal representation for the non-fractional
// part. There seems to be no locale information regarding how the
// fractional part should be formatted.

2
libcxx/include/__compare/common_comparison_category.h
View File

@ -55,7 +55,7 @@ __compute_comp_type(const _ClassifyCompCategory (&__types)[_Size]) {
template <class... _Ts, bool _False = false>
_LIBCPP_HIDE_FROM_ABI constexpr auto __get_comp_type() {
using _CCC = _ClassifyCompCategory;
constexpr _CCC __type_kinds[] = {_StrongOrd, __type_to_enum<_Ts>()...};
constexpr _CCC __type_kinds[] = {_StrongOrd, __comp_detail::__type_to_enum<_Ts>()...};
constexpr _CCC __cat = __comp_detail::__compute_comp_type(__type_kinds);
if constexpr (__cat == _None)
return void();

4
libcxx/include/__condition_variable/condition_variable.h
View File

@ -210,7 +210,7 @@ inline void condition_variable::__do_timed_wait(
unique_lock<mutex>& __lk, chrono::time_point<chrono::steady_clock, chrono::nanoseconds> __tp) _NOEXCEPT {
using namespace chrono;
if (!__lk.owns_lock())
__throw_system_error(EPERM, "condition_variable::timed wait: mutex not locked");
std::__throw_system_error(EPERM, "condition_variable::timed wait: mutex not locked");
nanoseconds __d = __tp.time_since_epoch();
timespec __ts;
seconds __s = duration_cast<seconds>(__d);
@ -225,7 +225,7 @@ inline void condition_variable::__do_timed_wait(
}
int __ec = pthread_cond_clockwait(&__cv_, __lk.mutex()->native_handle(), CLOCK_MONOTONIC, &__ts);
if (__ec != 0 && __ec != ETIMEDOUT)
__throw_system_error(__ec, "condition_variable timed_wait failed");
std::__throw_system_error(__ec, "condition_variable timed_wait failed");
}
# endif // _LIBCPP_HAS_COND_CLOCKWAIT

2
libcxx/include/__filesystem/directory_entry.h
View File

@ -286,7 +286,7 @@ private:
return;
}
if (__ec && (!__allow_dne || !__is_dne_error(__ec)))
__throw_filesystem_error(__msg, __p_, __ec);
filesystem::__throw_filesystem_error(__msg, __p_, __ec);
}
_LIBCPP_HIDE_FROM_ABI void __refresh(error_code* __ec = nullptr) {

2
libcxx/include/__format/format_arg_store.h
View File

@ -164,7 +164,7 @@ consteval __arg_t __determine_arg_t() {
template <class _Context, class _Tp>
_LIBCPP_HIDE_FROM_ABI basic_format_arg<_Context> __create_format_arg(_Tp& __value) noexcept {
using _Dp = remove_const_t<_Tp>;
constexpr __arg_t __arg = __determine_arg_t<_Context, _Dp>();
constexpr __arg_t __arg = __format::__determine_arg_t<_Context, _Dp>();
static_assert(__arg != __arg_t::__none, "the supplied type is not formattable");
static_assert(__formattable_with<_Tp, _Context>);

4
libcxx/include/__functional/function.h
View File

@ -432,7 +432,7 @@ public:
_LIBCPP_HIDE_FROM_ABI _Rp operator()(_ArgTypes&&... __args) const {
if (__f_ == nullptr)
__throw_bad_function_call();
std::__throw_bad_function_call();
return (*__f_)(std::forward<_ArgTypes>(__args)...);
}
@ -607,7 +607,7 @@ private:
_LIBCPP_HIDE_FROM_ABI explicit __policy_invoker(__Call __c) : __call_(__c) {}
_LIBCPP_HIDE_FROM_ABI static _Rp __call_empty(const __policy_storage*, __fast_forward<_ArgTypes>...) {
__throw_bad_function_call();
std::__throw_bad_function_call();
}
template <typename _Fun>

10
libcxx/include/__locale
View File

@ -154,7 +154,7 @@ inline _LIBCPP_HIDE_FROM_ABI locale::locale(const locale& __other, _Facet* __f)
template <class _Facet>
locale locale::combine(const locale& __other) const {
if (!std::has_facet<_Facet>(__other))
__throw_runtime_error("locale::combine: locale missing facet");
std::__throw_runtime_error("locale::combine: locale missing facet");
return locale(*this, &const_cast<_Facet&>(std::use_facet<_Facet>(__other)));
}
@ -1298,7 +1298,7 @@ struct _LIBCPP_EXPORTED_FROM_ABI __narrow_to_utf8<16> : public codecvt<char16_t,
const char16_t* __wn = (const char16_t*)__wb;
__r = do_out(__mb, (const char16_t*)__wb, (const char16_t*)__we, __wn, __buf, __buf + __sz, __bn);
if (__r == codecvt_base::error || __wn == (const char16_t*)__wb)
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
*__s = *__p;
__wb = (const _CharT*)__wn;
@ -1326,7 +1326,7 @@ struct _LIBCPP_EXPORTED_FROM_ABI __narrow_to_utf8<32> : public codecvt<char32_t,
const char32_t* __wn = (const char32_t*)__wb;
__r = do_out(__mb, (const char32_t*)__wb, (const char32_t*)__we, __wn, __buf, __buf + __sz, __bn);
if (__r == codecvt_base::error || __wn == (const char32_t*)__wb)
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
*__s = *__p;
__wb = (const _CharT*)__wn;
@ -1370,7 +1370,7 @@ struct _LIBCPP_EXPORTED_FROM_ABI __widen_from_utf8<16> : public codecvt<char16_t
const char* __nn = __nb;
__r = do_in(__mb, __nb, __ne - __nb > __sz ? __nb + __sz : __ne, __nn, __buf, __buf + __sz, __bn);
if (__r == codecvt_base::error || __nn == __nb)
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
for (const char16_t* __p = __buf; __p < __bn; ++__p, ++__s)
*__s = *__p;
__nb = __nn;
@ -1398,7 +1398,7 @@ struct _LIBCPP_EXPORTED_FROM_ABI __widen_from_utf8<32> : public codecvt<char32_t
const char* __nn = __nb;
__r = do_in(__mb, __nb, __ne - __nb > __sz ? __nb + __sz : __ne, __nn, __buf, __buf + __sz, __bn);
if (__r == codecvt_base::error || __nn == __nb)
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
for (const char32_t* __p = __buf; __p < __bn; ++__p, ++__s)
*__s = *__p;
__nb = __nn;

2
libcxx/include/__locale_dir/support/windows.h
View File

@ -317,7 +317,7 @@ struct __locale_guard {
if (std::strcmp(__l.__get_locale(), __lc) != 0) {
__locale_all = _strdup(__lc);
if (__locale_all == nullptr)
__throw_bad_alloc();
std::__throw_bad_alloc();
__locale::__setlocale(LC_ALL, __l.__get_locale());
}
}

2
libcxx/include/__memory/allocator.h
View File

@ -98,7 +98,7 @@ public:
[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp* allocate(size_t __n) {
static_assert(sizeof(_Tp) >= 0, "cannot allocate memory for an incomplete type");
if (__n > allocator_traits<allocator>::max_size(*this))
__throw_bad_array_new_length();
std::__throw_bad_array_new_length();
if (__libcpp_is_constant_evaluated()) {
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
} else {

2
libcxx/include/__memory/shared_ptr.h
View File

@ -497,7 +497,7 @@ public:
_LIBCPP_HIDE_FROM_ABI explicit shared_ptr(const weak_ptr<_Yp>& __r)
: __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_) {
if (__cntrl_ == nullptr)
__throw_bad_weak_ptr();
std::__throw_bad_weak_ptr();
}
#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)

2
libcxx/include/__memory_resource/polymorphic_allocator.h
View File

@ -64,7 +64,7 @@ public:
[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ValueType* allocate(size_t __n) {
if (__n > __max_size()) {
__throw_bad_array_new_length();
std::__throw_bad_array_new_length();
}
return static_cast<_ValueType*>(__res_->allocate(__n * sizeof(_ValueType), alignof(_ValueType)));
}

18
libcxx/include/__mutex/unique_lock.h
View File

@ -116,9 +116,9 @@ _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(unique_lock);
template <class _Mutex>
_LIBCPP_HIDE_FROM_ABI void unique_lock<_Mutex>::lock() {
if (__m_ == nullptr)
__throw_system_error(EPERM, "unique_lock::lock: references null mutex");
std::__throw_system_error(EPERM, "unique_lock::lock: references null mutex");
if (__owns_)
__throw_system_error(EDEADLK, "unique_lock::lock: already locked");
std::__throw_system_error(EDEADLK, "unique_lock::lock: already locked");
__m_->lock();
__owns_ = true;
}
@ -126,9 +126,9 @@ _LIBCPP_HIDE_FROM_ABI void unique_lock<_Mutex>::lock() {
template <class _Mutex>
_LIBCPP_HIDE_FROM_ABI bool unique_lock<_Mutex>::try_lock() {
if (__m_ == nullptr)
__throw_system_error(EPERM, "unique_lock::try_lock: references null mutex");
std::__throw_system_error(EPERM, "unique_lock::try_lock: references null mutex");
if (__owns_)
__throw_system_error(EDEADLK, "unique_lock::try_lock: already locked");
std::__throw_system_error(EDEADLK, "unique_lock::try_lock: already locked");
__owns_ = __m_->try_lock();
return __owns_;
}
@ -137,9 +137,9 @@ template <class _Mutex>
template <class _Rep, class _Period>
_LIBCPP_HIDE_FROM_ABI bool unique_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
if (__m_ == nullptr)
__throw_system_error(EPERM, "unique_lock::try_lock_for: references null mutex");
std::__throw_system_error(EPERM, "unique_lock::try_lock_for: references null mutex");
if (__owns_)
__throw_system_error(EDEADLK, "unique_lock::try_lock_for: already locked");
std::__throw_system_error(EDEADLK, "unique_lock::try_lock_for: already locked");
__owns_ = __m_->try_lock_for(__d);
return __owns_;
}
@ -148,9 +148,9 @@ template <class _Mutex>
template <class _Clock, class _Duration>
_LIBCPP_HIDE_FROM_ABI bool unique_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
if (__m_ == nullptr)
__throw_system_error(EPERM, "unique_lock::try_lock_until: references null mutex");
std::__throw_system_error(EPERM, "unique_lock::try_lock_until: references null mutex");
if (__owns_)
__throw_system_error(EDEADLK, "unique_lock::try_lock_until: already locked");
std::__throw_system_error(EDEADLK, "unique_lock::try_lock_until: already locked");
__owns_ = __m_->try_lock_until(__t);
return __owns_;
}
@ -158,7 +158,7 @@ _LIBCPP_HIDE_FROM_ABI bool unique_lock<_Mutex>::try_lock_until(const chrono::tim
template <class _Mutex>
_LIBCPP_HIDE_FROM_ABI void unique_lock<_Mutex>::unlock() {
if (!__owns_)
__throw_system_error(EPERM, "unique_lock::unlock: not locked");
std::__throw_system_error(EPERM, "unique_lock::unlock: not locked");
__m_->unlock();
__owns_ = false;
}

2
libcxx/include/__ostream/basic_ostream.h
View File

@ -407,7 +407,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, const char* __strn) {
if (__len > __bs) {
__wb = (_CharT*)malloc(__len * sizeof(_CharT));
if (__wb == 0)
__throw_bad_alloc();
std::__throw_bad_alloc();
__h.reset(__wb);
}
for (_CharT* __p = __wb; *__strn != '\0'; ++__strn, ++__p)

2
libcxx/include/__random/clamp_to_integral.h
View File

@ -43,7 +43,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _IntT __max_representable_int_for_float(
template <class _IntT, class _RealT>
_LIBCPP_HIDE_FROM_ABI _IntT __clamp_to_integral(_RealT __r) _NOEXCEPT {
using _Lim = numeric_limits<_IntT>;
const _IntT __max_val = __max_representable_int_for_float<_IntT, _RealT>();
const _IntT __max_val = std::__max_representable_int_for_float<_IntT, _RealT>();
if (__r >= ::nextafter(static_cast<_RealT>(__max_val), INFINITY)) {
return _Lim::max();
} else if (__r <= _Lim::lowest()) {

2
libcxx/include/__ranges/elements_view.h
View File

@ -197,7 +197,7 @@ class elements_view<_View, _Np>::__iterator
}
public:
using iterator_concept = decltype(__get_iterator_concept());
using iterator_concept = decltype(__iterator::__get_iterator_concept());
using value_type = remove_cvref_t<tuple_element_t<_Np, range_value_t<_Base>>>;
using difference_type = range_difference_t<_Base>;

2
libcxx/include/__ranges/zip_view.h
View File

@ -252,7 +252,7 @@ class zip_view<_Views...>::__iterator : public __zip_view_iterator_category_base
friend class zip_view<_Views...>;
public:
using iterator_concept = decltype(__get_zip_view_iterator_tag<_Const, _Views...>());
using iterator_concept = decltype(ranges::__get_zip_view_iterator_tag<_Const, _Views...>());
using value_type = tuple<range_value_t<__maybe_const<_Const, _Views>>...>;
using difference_type = common_type_t<range_difference_t<__maybe_const<_Const, _Views>>...>;

6
libcxx/include/__thread/thread.h
View File

@ -100,7 +100,7 @@ template <class _Tp>
__thread_specific_ptr<_Tp>::__thread_specific_ptr() {
int __ec = __libcpp_tls_create(&__key_, &__thread_specific_ptr::__at_thread_exit);
if (__ec)
__throw_system_error(__ec, "__thread_specific_ptr construction failed");
std::__throw_system_error(__ec, "__thread_specific_ptr construction failed");
}
template <class _Tp>
@ -219,7 +219,7 @@ thread::thread(_Fp&& __f, _Args&&... __args) {
if (__ec == 0)
__p.release();
else
__throw_system_error(__ec, "thread constructor failed");
std::__throw_system_error(__ec, "thread constructor failed");
}
# else // _LIBCPP_CXX03_LANG
@ -251,7 +251,7 @@ thread::thread(_Fp __f) {
if (__ec == 0)
__pp.release();
else
__throw_system_error(__ec, "thread constructor failed");
std::__throw_system_error(__ec, "thread constructor failed");
}
# endif // _LIBCPP_CXX03_LANG

2
libcxx/include/__type_traits/is_nothrow_convertible.h
View File

@ -43,7 +43,7 @@ template <typename _Fm, typename _To>
bool_constant<noexcept(std::__test_noexcept<_To>(std::declval<_Fm>()))> __is_nothrow_convertible_test();
template <typename _Fm, typename _To>
struct __is_nothrow_convertible_helper : decltype(__is_nothrow_convertible_test<_Fm, _To>()) {};
struct __is_nothrow_convertible_helper : decltype(std::__is_nothrow_convertible_test<_Fm, _To>()) {};
template <typename _Fm, typename _To>
struct is_nothrow_convertible

2
libcxx/include/__vector/vector.h
View File

@ -555,7 +555,7 @@ private:
// Postcondition: size() == 0
_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __vallocate(size_type __n) {
if (__n > max_size())
__throw_length_error();
this->__throw_length_error();
auto __allocation = std::__allocate_at_least(this->__alloc_, __n);
__begin_ = __allocation.ptr;
__end_ = __allocation.ptr;

2
libcxx/include/__vector/vector_bool.h
View File

@ -446,7 +446,7 @@ private:
// Postcondition: size() == 0
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __vallocate(size_type __n) {
if (__n > max_size())
__throw_length_error();
this->__throw_length_error();
auto __allocation = std::__allocate_at_least(__alloc_, __external_cap_to_internal(__n));
__begin_ = __allocation.ptr;
__size_ = 0;

6
libcxx/include/any
View File

@ -526,7 +526,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _ValueType
"or a CopyConstructible type");
auto __tmp = std::any_cast<add_const_t<_RawValueType>>(&__v);
if (__tmp == nullptr)
__throw_bad_any_cast();
std::__throw_bad_any_cast();
return static_cast<_ValueType>(*__tmp);
}
@ -538,7 +538,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _ValueType
"or a CopyConstructible type");
auto __tmp = std::any_cast<_RawValueType>(&__v);
if (__tmp == nullptr)
__throw_bad_any_cast();
std::__throw_bad_any_cast();
return static_cast<_ValueType>(*__tmp);
}
@ -550,7 +550,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_ANY_CAST _ValueType
"or a CopyConstructible type");
auto __tmp = std::any_cast<_RawValueType>(&__v);
if (__tmp == nullptr)
__throw_bad_any_cast();
std::__throw_bad_any_cast();
return static_cast<_ValueType>(std::move(*__tmp));
}

8
libcxx/include/array
View File

@ -276,13 +276,13 @@ struct _LIBCPP_TEMPLATE_VIS array {
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference at(size_type __n) {
if (__n >= _Size)
__throw_out_of_range("array::at");
std::__throw_out_of_range("array::at");
return __elems_[__n];
}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference at(size_type __n) const {
if (__n >= _Size)
__throw_out_of_range("array::at");
std::__throw_out_of_range("array::at");
return __elems_[__n];
}
@ -407,12 +407,12 @@ struct _LIBCPP_TEMPLATE_VIS array<_Tp, 0> {
}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference at(size_type) {
__throw_out_of_range("array<T, 0>::at");
std::__throw_out_of_range("array<T, 0>::at");
__libcpp_unreachable();
}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference at(size_type) const {
__throw_out_of_range("array<T, 0>::at");
std::__throw_out_of_range("array<T, 0>::at");
__libcpp_unreachable();
}

14
libcxx/include/bitset
View File

@ -343,7 +343,7 @@ __bitset<_N_words, _Size>::to_ulong(false_type) const {
__const_iterator __e = __make_iter(_Size);
__const_iterator __i = std::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true);
if (__i != __e)
__throw_overflow_error("bitset to_ulong overflow error");
std::__throw_overflow_error("bitset to_ulong overflow error");
return __first_[0];
}
@ -360,7 +360,7 @@ __bitset<_N_words, _Size>::to_ullong(false_type) const {
__const_iterator __e = __make_iter(_Size);
__const_iterator __i = std::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true);
if (__i != __e)
__throw_overflow_error("bitset to_ullong overflow error");
std::__throw_overflow_error("bitset to_ullong overflow error");
return to_ullong(true_type());
}
@ -645,7 +645,7 @@ public:
_CharT __zero = _CharT('0'),
_CharT __one = _CharT('1')) {
if (__pos > __str.size())
__throw_out_of_range("bitset string pos out of range");
std::__throw_out_of_range("bitset string pos out of range");
size_t __rlen = std::min(__n, __str.size() - __pos);
__init_from_string_view(basic_string_view<_CharT, _Traits>(__str.data() + __pos, __rlen), __zero, __one);
@ -790,7 +790,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset
template <size_t _Size>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::set(size_t __pos, bool __val) {
if (__pos >= _Size)
__throw_out_of_range("bitset set argument out of range");
std::__throw_out_of_range("bitset set argument out of range");
(*this)[__pos] = __val;
return *this;
@ -805,7 +805,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset
template <size_t _Size>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::reset(size_t __pos) {
if (__pos >= _Size)
__throw_out_of_range("bitset reset argument out of range");
std::__throw_out_of_range("bitset reset argument out of range");
(*this)[__pos] = false;
return *this;
@ -827,7 +827,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset
template <size_t _Size>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>& bitset<_Size>::flip(size_t __pos) {
if (__pos >= _Size)
__throw_out_of_range("bitset flip argument out of range");
std::__throw_out_of_range("bitset flip argument out of range");
reference __r = __base::__make_ref(__pos);
__r = ~__r;
@ -899,7 +899,7 @@ inline _LIBCPP_HIDE_FROM_ABI bool bitset<_Size>::operator!=(const bitset& __rhs)
template <size_t _Size>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool bitset<_Size>::test(size_t __pos) const {
if (__pos >= _Size)
__throw_out_of_range("bitset test argument out of range");
std::__throw_out_of_range("bitset test argument out of range");
return (*this)[__pos];
}

2
libcxx/include/experimental/__simd/utility.h
View File

@ -58,7 +58,7 @@ _LIBCPP_HIDE_FROM_ABI auto __choose_mask_type() {
template <class _Tp>
_LIBCPP_HIDE_FROM_ABI auto constexpr __set_all_bits(bool __v) {
return __v ? (numeric_limits<decltype(__choose_mask_type<_Tp>())>::max()) : 0;
return __v ? (numeric_limits<decltype(experimental::__choose_mask_type<_Tp>())>::max()) : 0;
}
template <class _From, class _To, class = void>

8
libcxx/include/fstream
View File

@ -780,7 +780,7 @@ typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>
size_t __nr = fread((void*)const_cast<char*>(__extbufnext_), 1, __nmemb, __file_);
if (__nr != 0) {
if (!__cv_)
__throw_bad_cast();
std::__throw_bad_cast();
__extbufend_ = __extbufnext_ + __nr;
char_type* __inext;
@ -842,7 +842,7 @@ typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>
codecvt_base::result __r;
do {
if (!__cv_)
__throw_bad_cast();
std::__throw_bad_cast();
const char_type* __e;
__r = __cv_->out(__st_, this->pbase(), this->pptr(), __e, __extbuf_, __extbuf_ + __ebs_, __extbe);
@ -913,7 +913,7 @@ template <class _CharT, class _Traits>
typename basic_filebuf<_CharT, _Traits>::pos_type
basic_filebuf<_CharT, _Traits>::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode) {
if (!__cv_)
__throw_bad_cast();
std::__throw_bad_cast();
int __width = __cv_->encoding();
if (__file_ == nullptr || (__width <= 0 && __off != 0) || sync())
@ -978,7 +978,7 @@ int basic_filebuf<_CharT, _Traits>::sync() {
if (__file_ == nullptr)
return 0;
if (!__cv_)
__throw_bad_cast();
std::__throw_bad_cast();
if (__cm_ & ios_base::out) {
if (this->pptr() != this->pbase())

54
libcxx/include/future
View File

@ -541,7 +541,7 @@ public:
lock_guard<mutex> __lk(__mut_);
bool __has_future_attached = (__state_ & __future_attached) != 0;
if (__has_future_attached)
__throw_future_error(future_errc::future_already_retrieved);
std::__throw_future_error(future_errc::future_already_retrieved);
this->__add_shared();
__state_ |= __future_attached;
}
@ -621,7 +621,7 @@ template <class _Arg>
void __assoc_state<_Rp>::set_value(_Arg&& __arg) {
unique_lock<mutex> __lk(this->__mut_);
if (this->__has_value())
__throw_future_error(future_errc::promise_already_satisfied);
std::__throw_future_error(future_errc::promise_already_satisfied);
::new ((void*)&__value_) _Rp(std::forward<_Arg>(__arg));
this->__state_ |= base::__constructed | base::ready;
__cv_.notify_all();
@ -632,7 +632,7 @@ template <class _Arg>
void __assoc_state<_Rp>::set_value_at_thread_exit(_Arg&& __arg) {
unique_lock<mutex> __lk(this->__mut_);
if (this->__has_value())
__throw_future_error(future_errc::promise_already_satisfied);
std::__throw_future_error(future_errc::promise_already_satisfied);
::new ((void*)&__value_) _Rp(std::forward<_Arg>(__arg));
this->__state_ |= base::__constructed;
__thread_local_data()->__make_ready_at_thread_exit(this);
@ -682,7 +682,7 @@ template <class _Rp>
void __assoc_state<_Rp&>::set_value(_Rp& __arg) {
unique_lock<mutex> __lk(this->__mut_);
if (this->__has_value())
__throw_future_error(future_errc::promise_already_satisfied);
std::__throw_future_error(future_errc::promise_already_satisfied);
__value_ = std::addressof(__arg);
this->__state_ |= base::__constructed | base::ready;
__cv_.notify_all();
@ -692,7 +692,7 @@ template <class _Rp>
void __assoc_state<_Rp&>::set_value_at_thread_exit(_Rp& __arg) {
unique_lock<mutex> __lk(this->__mut_);
if (this->__has_value())
__throw_future_error(future_errc::promise_already_satisfied);
std::__throw_future_error(future_errc::promise_already_satisfied);
__value_ = std::addressof(__arg);
this->__state_ |= base::__constructed;
__thread_local_data()->__make_ready_at_thread_exit(this);
@ -1185,21 +1185,21 @@ promise<_Rp>::~promise() {
template <class _Rp>
future<_Rp> promise<_Rp>::get_future() {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
return future<_Rp>(__state_);
}
template <class _Rp>
void promise<_Rp>::set_value(const _Rp& __r) {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_value(__r);
}
template <class _Rp>
void promise<_Rp>::set_value(_Rp&& __r) {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_value(std::move(__r));
}
@ -1207,21 +1207,21 @@ template <class _Rp>
void promise<_Rp>::set_exception(exception_ptr __p) {
_LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception: received nullptr");
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_exception(__p);
}
template <class _Rp>
void promise<_Rp>::set_value_at_thread_exit(const _Rp& __r) {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_value_at_thread_exit(__r);
}
template <class _Rp>
void promise<_Rp>::set_value_at_thread_exit(_Rp&& __r) {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_value_at_thread_exit(std::move(__r));
}
@ -1229,7 +1229,7 @@ template <class _Rp>
void promise<_Rp>::set_exception_at_thread_exit(exception_ptr __p) {
_LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception_at_thread_exit: received nullptr");
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_exception_at_thread_exit(__p);
}
@ -1300,14 +1300,14 @@ promise<_Rp&>::~promise() {
template <class _Rp>
future<_Rp&> promise<_Rp&>::get_future() {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
return future<_Rp&>(__state_);
}
template <class _Rp>
void promise<_Rp&>::set_value(_Rp& __r) {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_value(__r);
}
@ -1315,14 +1315,14 @@ template <class _Rp>
void promise<_Rp&>::set_exception(exception_ptr __p) {
_LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception: received nullptr");
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_exception(__p);
}
template <class _Rp>
void promise<_Rp&>::set_value_at_thread_exit(_Rp& __r) {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_value_at_thread_exit(__r);
}
@ -1330,7 +1330,7 @@ template <class _Rp>
void promise<_Rp&>::set_exception_at_thread_exit(exception_ptr __p) {
_LIBCPP_ASSERT_NON_NULL(__p != nullptr, "promise::set_exception_at_thread_exit: received nullptr");
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_exception_at_thread_exit(__p);
}
@ -1665,9 +1665,9 @@ public:
template <class _Rp, class... _ArgTypes>
void packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args) {
if (__p_.__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
if (__p_.__state_->__has_value())
__throw_future_error(future_errc::promise_already_satisfied);
std::__throw_future_error(future_errc::promise_already_satisfied);
# if _LIBCPP_HAS_EXCEPTIONS
try {
# endif // _LIBCPP_HAS_EXCEPTIONS
@ -1682,9 +1682,9 @@ void packaged_task<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __args) {
template <class _Rp, class... _ArgTypes>
void packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) {
if (__p_.__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
if (__p_.__state_->__has_value())
__throw_future_error(future_errc::promise_already_satisfied);
std::__throw_future_error(future_errc::promise_already_satisfied);
# if _LIBCPP_HAS_EXCEPTIONS
try {
# endif // _LIBCPP_HAS_EXCEPTIONS
@ -1699,7 +1699,7 @@ void packaged_task<_Rp(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __
template <class _Rp, class... _ArgTypes>
void packaged_task<_Rp(_ArgTypes...)>::reset() {
if (!valid())
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__p_ = promise<_Rp>();
}
@ -1767,9 +1767,9 @@ packaged_task(_Fp) -> packaged_task<_Stripped>;
template <class... _ArgTypes>
void packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args) {
if (__p_.__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
if (__p_.__state_->__has_value())
__throw_future_error(future_errc::promise_already_satisfied);
std::__throw_future_error(future_errc::promise_already_satisfied);
# if _LIBCPP_HAS_EXCEPTIONS
try {
# endif // _LIBCPP_HAS_EXCEPTIONS
@ -1785,9 +1785,9 @@ void packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args) {
template <class... _ArgTypes>
void packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args) {
if (__p_.__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
if (__p_.__state_->__has_value())
__throw_future_error(future_errc::promise_already_satisfied);
std::__throw_future_error(future_errc::promise_already_satisfied);
# if _LIBCPP_HAS_EXCEPTIONS
try {
# endif // _LIBCPP_HAS_EXCEPTIONS
@ -1803,7 +1803,7 @@ void packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... _
template <class... _ArgTypes>
void packaged_task<void(_ArgTypes...)>::reset() {
if (!valid())
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__p_ = promise<void>();
}

24
libcxx/include/locale
View File

@ -292,7 +292,7 @@ _LIBCPP_HIDE_FROM_ABI _ForwardIterator __scan_keyword(
if (__nkw > sizeof(__statbuf)) {
__status = (unsigned char*)malloc(__nkw);
if (__status == nullptr)
__throw_bad_alloc();
std::__throw_bad_alloc();
__stat_hold.reset(__status);
}
size_t __n_might_match = __nkw; // At this point, any keyword might match
@ -1324,7 +1324,7 @@ _LIBCPP_HIDE_FROM_ABI inline _OutputIterator num_put<_CharT, _OutputIterator>::_
else
__nc = __locale::__asprintf(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
if (__nc == -1)
__throw_bad_alloc();
std::__throw_bad_alloc();
__nbh.reset(__nb);
}
_LIBCPP_DIAGNOSTIC_POP
@ -1337,7 +1337,7 @@ _LIBCPP_HIDE_FROM_ABI inline _OutputIterator num_put<_CharT, _OutputIterator>::_
if (__nb != __nar) {
__ob = (char_type*)malloc(2 * static_cast<size_t>(__nc) * sizeof(char_type));
if (__ob == 0)
__throw_bad_alloc();
std::__throw_bad_alloc();
__obh.reset(__ob);
}
char_type* __op; // pad here
@ -2382,7 +2382,7 @@ _LIBCPP_HIDE_FROM_ABI void __double_or_nothing(unique_ptr<_Tp, void (*)(void*)>&
size_t __n_off = static_cast<size_t>(__n - __b.get());
_Tp* __t = (_Tp*)std::realloc(__owns ? __b.get() : 0, __new_cap);
if (__t == 0)
__throw_bad_alloc();
std::__throw_bad_alloc();
if (__owns)
__b.release();
__b = unique_ptr<_Tp, void (*)(void*)>(__t, free);
@ -2585,7 +2585,7 @@ _InputIterator money_get<_CharT, _InputIterator>::do_get(
if (__wn - __wb.get() > __bz - 2) {
__h.reset((char*)malloc(static_cast<size_t>(__wn - __wb.get() + 2)));
if (__h.get() == nullptr)
__throw_bad_alloc();
std::__throw_bad_alloc();
__nc = __h.get();
}
if (__neg)
@ -2594,7 +2594,7 @@ _InputIterator money_get<_CharT, _InputIterator>::do_get(
*__nc = __src[std::find(__atoms, std::end(__atoms), *__w) - __atoms];
*__nc = char();
if (sscanf(__nbuf, "%Lf", &__v) != 1)
__throw_runtime_error("money_get error");
std::__throw_runtime_error("money_get error");
}
if (__b == __e)
__err |= ios_base::eofbit;
@ -2859,11 +2859,11 @@ _OutputIterator money_put<_CharT, _OutputIterator>::do_put(
if (static_cast<size_t>(__n) > __bs - 1) {
__n = __locale::__asprintf(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units);
if (__n == -1)
__throw_bad_alloc();
std::__throw_bad_alloc();
__hn.reset(__bb);
__hd.reset((char_type*)malloc(static_cast<size_t>(__n) * sizeof(char_type)));
if (__hd == nullptr)
__throw_bad_alloc();
std::__throw_bad_alloc();
__db = __hd.get();
}
// gather info
@ -2890,7 +2890,7 @@ _OutputIterator money_put<_CharT, _OutputIterator>::do_put(
__hw.reset((char_type*)malloc(__exn * sizeof(char_type)));
__mb = __hw.get();
if (__mb == 0)
__throw_bad_alloc();
std::__throw_bad_alloc();
}
// format
char_type* __mi;
@ -2928,7 +2928,7 @@ _OutputIterator money_put<_CharT, _OutputIterator>::do_put(
__h.reset((char_type*)malloc(__exn * sizeof(char_type)));
__mb = __h.get();
if (__mb == 0)
__throw_bad_alloc();
std::__throw_bad_alloc();
}
// format
char_type* __mi;
@ -3203,7 +3203,7 @@ wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::from_bytes(const char*
}
if (__wide_err_string_.empty())
__throw_range_error("wstring_convert: from_bytes error");
std::__throw_range_error("wstring_convert: from_bytes error");
return __wide_err_string_;
}
@ -3272,7 +3272,7 @@ wstring_convert<_Codecvt, _Elem, _WideAlloc, _ByteAlloc>::to_bytes(const _Elem*
}
if (__byte_err_string_.empty())
__throw_range_error("wstring_convert: to_bytes error");
std::__throw_range_error("wstring_convert: to_bytes error");
return __byte_err_string_;
}

10
libcxx/include/map
View File

@ -1138,7 +1138,7 @@ public:
insert(__m.begin(), __m.end());
}
_LIBCPP_HIDE_FROM_ABI ~map() { static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), ""); }
_LIBCPP_HIDE_FROM_ABI ~map() { static_assert(sizeof(std::__diagnose_non_const_comparator<_Key, _Compare>()), ""); }
_LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
_LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }
@ -1572,7 +1572,7 @@ _Tp& map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) {
__parent_pointer __parent;
__node_base_pointer& __child = __tree_.__find_equal(__parent, __k);
if (__child == nullptr)
__throw_out_of_range("map::at: key not found");
std::__throw_out_of_range("map::at: key not found");
return static_cast<__node_pointer>(__child)->__value_.__get_value().second;
}
@ -1581,7 +1581,7 @@ const _Tp& map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) const {
__parent_pointer __parent;
__node_base_pointer __child = __tree_.__find_equal(__parent, __k);
if (__child == nullptr)
__throw_out_of_range("map::at: key not found");
std::__throw_out_of_range("map::at: key not found");
return static_cast<__node_pointer>(__child)->__value_.__get_value().second;
}
@ -1826,7 +1826,9 @@ public:
insert(__m.begin(), __m.end());
}
_LIBCPP_HIDE_FROM_ABI ~multimap() { static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), ""); }
_LIBCPP_HIDE_FROM_ABI ~multimap() {
static_assert(sizeof(std::__diagnose_non_const_comparator<_Key, _Compare>()), "");
}
_LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
_LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }

8
libcxx/include/optional
View File

@ -827,25 +827,25 @@ public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr value_type const& value() const& {
if (!this->has_value())
__throw_bad_optional_access();
std::__throw_bad_optional_access();
return this->__get();
}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr value_type& value() & {
if (!this->has_value())
__throw_bad_optional_access();
std::__throw_bad_optional_access();
return this->__get();
}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr value_type&& value() && {
if (!this->has_value())
__throw_bad_optional_access();
std::__throw_bad_optional_access();
return std::move(this->__get());
}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_OPTIONAL_ACCESS constexpr value_type const&& value() const&& {
if (!this->has_value())
__throw_bad_optional_access();
std::__throw_bad_optional_access();
return std::move(this->__get());
}

130
libcxx/include/regex
View File

@ -1681,7 +1681,7 @@ public:
template <class _CharT>
void __back_ref<_CharT>::__exec(__state& __s) const {
if (__mexp_ > __s.__sub_matches_.size())
__throw_regex_error<regex_constants::error_backref>();
std::__throw_regex_error<regex_constants::error_backref>();
sub_match<const _CharT*>& __sm = __s.__sub_matches_[__mexp_ - 1];
if (__sm.matched) {
ptrdiff_t __len = __sm.second - __sm.first;
@ -2117,7 +2117,7 @@ public:
std::make_pair(__traits_.transform(__b.begin(), __b.end()), __traits_.transform(__e.begin(), __e.end())));
} else {
if (__b.size() != 1 || __e.size() != 1)
__throw_regex_error<regex_constants::error_range>();
std::__throw_regex_error<regex_constants::error_range>();
if (__icase_) {
__b[0] = __traits_.translate_nocase(__b[0]);
__e[0] = __traits_.translate_nocase(__e[0]);
@ -2743,7 +2743,7 @@ void basic_regex<_CharT, _Traits>::__init(_ForwardIterator __first, _ForwardIter
__flags_ |= regex_constants::ECMAScript;
_ForwardIterator __temp = __parse(__first, __last);
if (__temp != __last)
__throw_regex_error<regex_constants::__re_err_parse>();
std::__throw_regex_error<regex_constants::__re_err_parse>();
}
template <class _CharT, class _Traits>
@ -2773,7 +2773,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse(_ForwardIterator __first,
__first = __parse_egrep(__first, __last);
break;
default:
__throw_regex_error<regex_constants::__re_err_grammar>();
std::__throw_regex_error<regex_constants::__re_err_grammar>();
}
return __first;
}
@ -2798,7 +2798,7 @@ basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first, _F
}
}
if (__first != __last)
__throw_regex_error<regex_constants::__re_err_empty>();
std::__throw_regex_error<regex_constants::__re_err_empty>();
}
return __first;
}
@ -2810,13 +2810,13 @@ basic_regex<_CharT, _Traits>::__parse_extended_reg_exp(_ForwardIterator __first,
__owns_one_state<_CharT>* __sa = __end_;
_ForwardIterator __temp = __parse_ERE_branch(__first, __last);
if (__temp == __first)
__throw_regex_error<regex_constants::__re_err_empty>();
std::__throw_regex_error<regex_constants::__re_err_empty>();
__first = __temp;
while (__first != __last && *__first == '|') {
__owns_one_state<_CharT>* __sb = __end_;
__temp = __parse_ERE_branch(++__first, __last);
if (__temp == __first)
__throw_regex_error<regex_constants::__re_err_empty>();
std::__throw_regex_error<regex_constants::__re_err_empty>();
__push_alternation(__sa, __sb);
__first = __temp;
}
@ -2828,7 +2828,7 @@ template <class _ForwardIterator>
_ForwardIterator basic_regex<_CharT, _Traits>::__parse_ERE_branch(_ForwardIterator __first, _ForwardIterator __last) {
_ForwardIterator __temp = __parse_ERE_expression(__first, __last);
if (__temp == __first)
__throw_regex_error<regex_constants::__re_err_empty>();
std::__throw_regex_error<regex_constants::__re_err_empty>();
do {
__first = __temp;
__temp = __parse_ERE_expression(__first, __last);
@ -2859,7 +2859,7 @@ basic_regex<_CharT, _Traits>::__parse_ERE_expression(_ForwardIterator __first, _
++__open_count_;
__temp = __parse_extended_reg_exp(++__temp, __last);
if (__temp == __last || *__temp != ')')
__throw_regex_error<regex_constants::error_paren>();
std::__throw_regex_error<regex_constants::error_paren>();
__push_end_marked_subexpression(__temp_count);
--__open_count_;
++__temp;
@ -2911,7 +2911,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_nondupl_RE(_ForwardIterat
__first = __parse_RE_expression(__temp, __last);
__temp = __parse_Back_close_paren(__first, __last);
if (__temp == __first)
__throw_regex_error<regex_constants::error_paren>();
std::__throw_regex_error<regex_constants::error_paren>();
__push_end_marked_subexpression(__temp_count);
__first = __temp;
} else
@ -3154,14 +3154,14 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_RE_dupl_symbol(
__first = __temp;
__temp = __parse_DUP_COUNT(__first, __last, __min);
if (__temp == __first)
__throw_regex_error<regex_constants::error_badbrace>();
std::__throw_regex_error<regex_constants::error_badbrace>();
__first = __temp;
if (__first == __last)
__throw_regex_error<regex_constants::error_brace>();
std::__throw_regex_error<regex_constants::error_brace>();
if (*__first != ',') {
__temp = __parse_Back_close_brace(__first, __last);
if (__temp == __first)
__throw_regex_error<regex_constants::error_brace>();
std::__throw_regex_error<regex_constants::error_brace>();
__push_loop(__min, __min, __s, __mexp_begin, __mexp_end, true);
__first = __temp;
} else {
@ -3170,12 +3170,12 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_RE_dupl_symbol(
__first = __parse_DUP_COUNT(__first, __last, __max);
__temp = __parse_Back_close_brace(__first, __last);
if (__temp == __first)
__throw_regex_error<regex_constants::error_brace>();
std::__throw_regex_error<regex_constants::error_brace>();
if (__max == -1)
__push_greedy_inf_repeat(__min, __s, __mexp_begin, __mexp_end);
else {
if (__max < __min)
__throw_regex_error<regex_constants::error_badbrace>();
std::__throw_regex_error<regex_constants::error_badbrace>();
__push_loop(__min, __max, __s, __mexp_begin, __mexp_end, true);
}
__first = __temp;
@ -3225,10 +3225,10 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(
int __min;
_ForwardIterator __temp = __parse_DUP_COUNT(++__first, __last, __min);
if (__temp == __first)
__throw_regex_error<regex_constants::error_badbrace>();
std::__throw_regex_error<regex_constants::error_badbrace>();
__first = __temp;
if (__first == __last)
__throw_regex_error<regex_constants::error_brace>();
std::__throw_regex_error<regex_constants::error_brace>();
switch (*__first) {
case '}':
++__first;
@ -3241,7 +3241,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(
case ',':
++__first;
if (__first == __last)
__throw_regex_error<regex_constants::error_badbrace>();
std::__throw_regex_error<regex_constants::error_badbrace>();
if (*__first == '}') {
++__first;
if (__grammar == ECMAScript && __first != __last && *__first == '?') {
@ -3253,13 +3253,13 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(
int __max = -1;
__temp = __parse_DUP_COUNT(__first, __last, __max);
if (__temp == __first)
__throw_regex_error<regex_constants::error_brace>();
std::__throw_regex_error<regex_constants::error_brace>();
__first = __temp;
if (__first == __last || *__first != '}')
__throw_regex_error<regex_constants::error_brace>();
std::__throw_regex_error<regex_constants::error_brace>();
++__first;
if (__max < __min)
__throw_regex_error<regex_constants::error_badbrace>();
std::__throw_regex_error<regex_constants::error_badbrace>();
if (__grammar == ECMAScript && __first != __last && *__first == '?') {
++__first;
__push_loop(__min, __max, __s, __mexp_begin, __mexp_end, false);
@ -3268,7 +3268,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_ERE_dupl_symbol(
}
break;
default:
__throw_regex_error<regex_constants::error_badbrace>();
std::__throw_regex_error<regex_constants::error_badbrace>();
}
} break;
}
@ -3283,7 +3283,7 @@ basic_regex<_CharT, _Traits>::__parse_bracket_expression(_ForwardIterator __firs
if (__first != __last && *__first == '[') {
++__first;
if (__first == __last)
__throw_regex_error<regex_constants::error_brack>();
std::__throw_regex_error<regex_constants::error_brack>();
bool __negate = false;
if (*__first == '^') {
++__first;
@ -3292,20 +3292,20 @@ basic_regex<_CharT, _Traits>::__parse_bracket_expression(_ForwardIterator __firs
__bracket_expression<_CharT, _Traits>* __ml = __start_matching_list(__negate);
// __ml owned by *this
if (__first == __last)
__throw_regex_error<regex_constants::error_brack>();
std::__throw_regex_error<regex_constants::error_brack>();
if (__get_grammar(__flags_) != ECMAScript && *__first == ']') {
__ml->__add_char(']');
++__first;
}
__first = __parse_follow_list(__first, __last, __ml);
if (__first == __last)
__throw_regex_error<regex_constants::error_brack>();
std::__throw_regex_error<regex_constants::error_brack>();
if (*__first == '-') {
__ml->__add_char('-');
++__first;
}
if (__first == __last || *__first != ']')
__throw_regex_error<regex_constants::error_brack>();
std::__throw_regex_error<regex_constants::error_brack>();
++__first;
}
return __first;
@ -3398,7 +3398,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_class_escape(
basic_string<_CharT>& __str,
__bracket_expression<_CharT, _Traits>* __ml) {
if (__first == __last)
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
switch (*__first) {
case 0:
__str = *__first;
@ -3436,7 +3436,7 @@ template <class _ForwardIterator>
_ForwardIterator basic_regex<_CharT, _Traits>::__parse_awk_escape(
_ForwardIterator __first, _ForwardIterator __last, basic_string<_CharT>* __str) {
if (__first == __last)
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
switch (*__first) {
case '\\':
case '"':
@ -3501,7 +3501,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_awk_escape(
else
__push_char(_CharT(__val));
} else
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
return __first;
}
@ -3514,11 +3514,11 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_equivalence_class(
value_type __equal_close[2] = {'=', ']'};
_ForwardIterator __temp = std::search(__first, __last, __equal_close, __equal_close + 2);
if (__temp == __last)
__throw_regex_error<regex_constants::error_brack>();
std::__throw_regex_error<regex_constants::error_brack>();
// [__first, __temp) contains all text in [= ... =]
string_type __collate_name = __traits_.lookup_collatename(__first, __temp);
if (__collate_name.empty())
__throw_regex_error<regex_constants::error_collate>();
std::__throw_regex_error<regex_constants::error_collate>();
string_type __equiv_name = __traits_.transform_primary(__collate_name.begin(), __collate_name.end());
if (!__equiv_name.empty())
__ml->__add_equivalence(__equiv_name);
@ -3531,7 +3531,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_equivalence_class(
__ml->__add_digraph(__collate_name[0], __collate_name[1]);
break;
default:
__throw_regex_error<regex_constants::error_collate>();
std::__throw_regex_error<regex_constants::error_collate>();
}
}
__first = std::next(__temp, 2);
@ -3547,12 +3547,12 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_character_class(
value_type __colon_close[2] = {':', ']'};
_ForwardIterator __temp = std::search(__first, __last, __colon_close, __colon_close + 2);
if (__temp == __last)
__throw_regex_error<regex_constants::error_brack>();
std::__throw_regex_error<regex_constants::error_brack>();
// [__first, __temp) contains all text in [: ... :]
typedef typename _Traits::char_class_type char_class_type;
char_class_type __class_type = __traits_.lookup_classname(__first, __temp, __flags_ & icase);
if (__class_type == 0)
__throw_regex_error<regex_constants::error_ctype>();
std::__throw_regex_error<regex_constants::error_ctype>();
__ml->__add_class(__class_type);
__first = std::next(__temp, 2);
return __first;
@ -3567,7 +3567,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_collating_symbol(
value_type __dot_close[2] = {'.', ']'};
_ForwardIterator __temp = std::search(__first, __last, __dot_close, __dot_close + 2);
if (__temp == __last)
__throw_regex_error<regex_constants::error_brack>();
std::__throw_regex_error<regex_constants::error_brack>();
// [__first, __temp) contains all text in [. ... .]
__col_sym = __traits_.lookup_collatename(__first, __temp);
switch (__col_sym.size()) {
@ -3575,7 +3575,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_collating_symbol(
case 2:
break;
default:
__throw_regex_error<regex_constants::error_collate>();
std::__throw_regex_error<regex_constants::error_collate>();
}
__first = std::next(__temp, 2);
return __first;
@ -3591,7 +3591,7 @@ basic_regex<_CharT, _Traits>::__parse_DUP_COUNT(_ForwardIterator __first, _Forwa
__c = __val;
for (++__first; __first != __last && (__val = __traits_.value(*__first, 10)) != -1; ++__first) {
if (__c >= numeric_limits<int>::max() / 10)
__throw_regex_error<regex_constants::error_badbrace>();
std::__throw_regex_error<regex_constants::error_badbrace>();
__c *= 10;
__c += __val;
}
@ -3684,7 +3684,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterato
__push_lookahead(std::move(__exp), false, __marked_count_);
__marked_count_ += __mexp;
if (__temp == __last || *__temp != ')')
__throw_regex_error<regex_constants::error_paren>();
std::__throw_regex_error<regex_constants::error_paren>();
__first = ++__temp;
} break;
case '!': {
@ -3695,7 +3695,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterato
__push_lookahead(std::move(__exp), true, __marked_count_);
__marked_count_ += __mexp;
if (__temp == __last || *__temp != ')')
__throw_regex_error<regex_constants::error_paren>();
std::__throw_regex_error<regex_constants::error_paren>();
__first = ++__temp;
} break;
}
@ -3725,13 +3725,13 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __f
case '(': {
++__first;
if (__first == __last)
__throw_regex_error<regex_constants::error_paren>();
std::__throw_regex_error<regex_constants::error_paren>();
_ForwardIterator __temp = std::next(__first);
if (__temp != __last && *__first == '?' && *__temp == ':') {
++__open_count_;
__first = __parse_ecma_exp(++__temp, __last);
if (__first == __last || *__first != ')')
__throw_regex_error<regex_constants::error_paren>();
std::__throw_regex_error<regex_constants::error_paren>();
--__open_count_;
++__first;
} else {
@ -3740,7 +3740,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __f
++__open_count_;
__first = __parse_ecma_exp(__first, __last);
if (__first == __last || *__first != ')')
__throw_regex_error<regex_constants::error_paren>();
std::__throw_regex_error<regex_constants::error_paren>();
__push_end_marked_subexpression(__temp_count);
--__open_count_;
++__first;
@ -3750,7 +3750,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __f
case '+':
case '?':
case '{':
__throw_regex_error<regex_constants::error_badrepeat>();
std::__throw_regex_error<regex_constants::error_badrepeat>();
break;
default:
__first = __parse_pattern_character(__first, __last);
@ -3766,7 +3766,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardItera
if (__first != __last && *__first == '\\') {
_ForwardIterator __t1 = std::next(__first);
if (__t1 == __last)
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
_ForwardIterator __t2 = __parse_decimal_escape(__t1, __last);
if (__t2 != __t1)
@ -3797,11 +3797,11 @@ basic_regex<_CharT, _Traits>::__parse_decimal_escape(_ForwardIterator __first, _
unsigned __v = *__first - '0';
for (++__first; __first != __last && '0' <= *__first && *__first <= '9'; ++__first) {
if (__v >= numeric_limits<unsigned>::max() / 10)
__throw_regex_error<regex_constants::error_backref>();
std::__throw_regex_error<regex_constants::error_backref>();
__v = 10 * __v + *__first - '0';
}
if (__v == 0 || __v > mark_count())
__throw_regex_error<regex_constants::error_backref>();
std::__throw_regex_error<regex_constants::error_backref>();
__push_back_ref(__v);
}
}
@ -3905,40 +3905,40 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_character_escape(
__push_char(_CharT(*__t % 32));
__first = ++__t;
} else
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
} else
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
break;
case 'u':
++__first;
if (__first == __last)
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
__hd = __traits_.value(*__first, 16);
if (__hd == -1)
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
__sum = 16 * __sum + static_cast<unsigned>(__hd);
++__first;
if (__first == __last)
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
__hd = __traits_.value(*__first, 16);
if (__hd == -1)
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
__sum = 16 * __sum + static_cast<unsigned>(__hd);
_LIBCPP_FALLTHROUGH();
case 'x':
++__first;
if (__first == __last)
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
__hd = __traits_.value(*__first, 16);
if (__hd == -1)
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
__sum = 16 * __sum + static_cast<unsigned>(__hd);
++__first;
if (__first == __last)
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
__hd = __traits_.value(*__first, 16);
if (__hd == -1)
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
__sum = 16 * __sum + static_cast<unsigned>(__hd);
if (__str)
*__str = _CharT(__sum);
@ -3961,7 +3961,7 @@ _ForwardIterator basic_regex<_CharT, _Traits>::__parse_character_escape(
__push_char(*__first);
++__first;
} else
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
break;
}
}
@ -4057,7 +4057,7 @@ bool basic_regex<_CharT, _Traits>::__test_back_ref(_CharT __c) {
unsigned __val = __traits_.value(__c, 10);
if (__val >= 1 && __val <= 9) {
if (__val > mark_count())
__throw_regex_error<regex_constants::error_backref>();
std::__throw_regex_error<regex_constants::error_backref>();
__push_back_ref(__val);
return true;
}
@ -4778,7 +4778,7 @@ _OutputIter match_results<_BidirectionalIterator, _Allocator>::format(
if (__fmt_first + 1 != __fmt_last && '0' <= __fmt_first[1] && __fmt_first[1] <= '9') {
++__fmt_first;
if (__idx >= numeric_limits<size_t>::max() / 10)
__throw_regex_error<regex_constants::error_escape>();
std::__throw_regex_error<regex_constants::error_escape>();
__idx = 10 * __idx + *__fmt_first - '0';
}
__output_iter = std::copy((*this)[__idx].first, (*this)[__idx].second, __output_iter);
@ -4865,7 +4865,7 @@ bool basic_regex<_CharT, _Traits>::__match_at_start_ecma(
do {
++__counter;
if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
__throw_regex_error<regex_constants::error_complexity>();
std::__throw_regex_error<regex_constants::error_complexity>();
__state& __s = __states.back();
if (__s.__node_)
__s.__node_->__exec(__s);
@ -4899,7 +4899,7 @@ bool basic_regex<_CharT, _Traits>::__match_at_start_ecma(
__states.pop_back();
break;
default:
__throw_regex_error<regex_constants::__re_err_unknown>();
std::__throw_regex_error<regex_constants::__re_err_unknown>();
break;
}
} while (!__states.empty());
@ -4935,7 +4935,7 @@ bool basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
do {
++__counter;
if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
__throw_regex_error<regex_constants::error_complexity>();
std::__throw_regex_error<regex_constants::error_complexity>();
__state& __s = __states.back();
if (__s.__node_)
__s.__node_->__exec(__s);
@ -4976,7 +4976,7 @@ bool basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
__states.pop_back();
break;
default:
__throw_regex_error<regex_constants::__re_err_unknown>();
std::__throw_regex_error<regex_constants::__re_err_unknown>();
break;
}
} while (!__states.empty());
@ -5025,7 +5025,7 @@ bool basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
do {
++__counter;
if (__counter % _LIBCPP_REGEX_COMPLEXITY_FACTOR == 0 && __counter / _LIBCPP_REGEX_COMPLEXITY_FACTOR >= __length)
__throw_regex_error<regex_constants::error_complexity>();
std::__throw_regex_error<regex_constants::error_complexity>();
__state& __s = __states.back();
if (__s.__node_)
__s.__node_->__exec(__s);
@ -5063,7 +5063,7 @@ bool basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
__states.pop_back();
break;
default:
__throw_regex_error<regex_constants::__re_err_unknown>();
std::__throw_regex_error<regex_constants::__re_err_unknown>();
break;
}
} while (!__states.empty());

6
libcxx/include/set
View File

@ -709,7 +709,7 @@ public:
}
# endif // _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI ~set() { static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), ""); }
_LIBCPP_HIDE_FROM_ABI ~set() { static_assert(sizeof(std::__diagnose_non_const_comparator<_Key, _Compare>()), ""); }
_LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
_LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }
@ -1174,7 +1174,9 @@ public:
}
# endif // _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI ~multiset() { static_assert(sizeof(__diagnose_non_const_comparator<_Key, _Compare>()), ""); }
_LIBCPP_HIDE_FROM_ABI ~multiset() {
static_assert(sizeof(std::__diagnose_non_const_comparator<_Key, _Compare>()), "");
}
_LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
_LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }

18
libcxx/include/shared_mutex
View File

@ -400,9 +400,9 @@ _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(shared_lock);
template <class _Mutex>
void shared_lock<_Mutex>::lock() {
if (__m_ == nullptr)
__throw_system_error(EPERM, "shared_lock::lock: references null mutex");
std::__throw_system_error(EPERM, "shared_lock::lock: references null mutex");
if (__owns_)
__throw_system_error(EDEADLK, "shared_lock::lock: already locked");
std::__throw_system_error(EDEADLK, "shared_lock::lock: already locked");
__m_->lock_shared();
__owns_ = true;
}
@ -410,9 +410,9 @@ void shared_lock<_Mutex>::lock() {
template <class _Mutex>
bool shared_lock<_Mutex>::try_lock() {
if (__m_ == nullptr)
__throw_system_error(EPERM, "shared_lock::try_lock: references null mutex");
std::__throw_system_error(EPERM, "shared_lock::try_lock: references null mutex");
if (__owns_)
__throw_system_error(EDEADLK, "shared_lock::try_lock: already locked");
std::__throw_system_error(EDEADLK, "shared_lock::try_lock: already locked");
__owns_ = __m_->try_lock_shared();
return __owns_;
}
@ -421,9 +421,9 @@ template <class _Mutex>
template <class _Rep, class _Period>
bool shared_lock<_Mutex>::try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
if (__m_ == nullptr)
__throw_system_error(EPERM, "shared_lock::try_lock_for: references null mutex");
std::__throw_system_error(EPERM, "shared_lock::try_lock_for: references null mutex");
if (__owns_)
__throw_system_error(EDEADLK, "shared_lock::try_lock_for: already locked");
std::__throw_system_error(EDEADLK, "shared_lock::try_lock_for: already locked");
__owns_ = __m_->try_lock_shared_for(__d);
return __owns_;
}
@ -432,9 +432,9 @@ template <class _Mutex>
template <class _Clock, class _Duration>
bool shared_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
if (__m_ == nullptr)
__throw_system_error(EPERM, "shared_lock::try_lock_until: references null mutex");
std::__throw_system_error(EPERM, "shared_lock::try_lock_until: references null mutex");
if (__owns_)
__throw_system_error(EDEADLK, "shared_lock::try_lock_until: already locked");
std::__throw_system_error(EDEADLK, "shared_lock::try_lock_until: already locked");
__owns_ = __m_->try_lock_shared_until(__t);
return __owns_;
}
@ -442,7 +442,7 @@ bool shared_lock<_Mutex>::try_lock_until(const chrono::time_point<_Clock, _Durat
template <class _Mutex>
void shared_lock<_Mutex>::unlock() {
if (!__owns_)
__throw_system_error(EPERM, "shared_lock::unlock: not locked");
std::__throw_system_error(EPERM, "shared_lock::unlock: not locked");
__m_->unlock_shared();
__owns_ = false;
}

56
libcxx/include/string
View File

@ -907,7 +907,7 @@ private:
__uninitialized_size_tag, size_type __size, const allocator_type& __a)
: __alloc_(__a) {
if (__size > max_size())
__throw_length_error();
this->__throw_length_error();
if (__fits_in_sso(__size)) {
__rep_ = __rep();
__set_short_size(__size);
@ -1076,7 +1076,7 @@ public:
basic_string&& __str, size_type __pos, size_type __n, const _Allocator& __alloc = _Allocator())
: __alloc_(__alloc) {
if (__pos > __str.size())
__throw_out_of_range();
this->__throw_out_of_range();
auto __len = std::min<size_type>(__n, __str.size() - __pos);
if (__alloc_traits::is_always_equal::value || __alloc == __str.__alloc_) {
@ -1099,7 +1099,7 @@ public:
: __alloc_(__a) {
size_type __str_sz = __str.size();
if (__pos > __str_sz)
__throw_out_of_range();
this->__throw_out_of_range();
__init(__str.data() + __pos, std::min(__n, __str_sz - __pos));
}
@ -1108,7 +1108,7 @@ public:
: __alloc_(__a) {
size_type __str_sz = __str.size();
if (__pos > __str_sz)
__throw_out_of_range();
this->__throw_out_of_range();
__init(__str.data() + __pos, __str_sz - __pos);
}
@ -2455,7 +2455,7 @@ basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_ty
if (__libcpp_is_constant_evaluated())
__rep_ = __rep();
if (__sz > max_size())
__throw_length_error();
this->__throw_length_error();
pointer __p;
if (__fits_in_sso(__sz)) {
__set_short_size(__sz);
@ -2485,7 +2485,7 @@ basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external(const value
__set_short_size(__sz);
} else {
if (__sz > max_size())
__throw_length_error();
this->__throw_length_error();
auto __allocation = std::__allocate_at_least(__alloc_, __recommend(__sz) + 1);
__p = __allocation.ptr;
__begin_lifetime(__p, __allocation.count);
@ -2503,7 +2503,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::__
__rep_ = __rep();
if (__n > max_size())
__throw_length_error();
this->__throw_length_error();
pointer __p;
if (__fits_in_sso(__n)) {
__set_short_size(__n);
@ -2566,7 +2566,7 @@ basic_string<_CharT, _Traits, _Allocator>::__init_with_size(_InputIterator __fir
__rep_ = __rep();
if (__sz > max_size())
__throw_length_error();
this->__throw_length_error();
pointer __p;
if (__fits_in_sso(__sz)) {
@ -2608,7 +2608,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::__
const value_type* __p_new_stuff) {
size_type __ms = max_size();
if (__delta_cap > __ms - __old_cap - 1)
__throw_length_error();
this->__throw_length_error();
pointer __old_p = __get_pointer();
size_type __cap =
__old_cap < __ms / 2 - __alignment ? __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) : __ms - 1;
@ -2651,7 +2651,7 @@ _LIBCPP_DEPRECATED_("use __grow_by_without_replace") basic_string<_CharT, _Trait
size_type __n_add) {
size_type __ms = max_size();
if (__delta_cap > __ms - __old_cap)
__throw_length_error();
this->__throw_length_error();
pointer __old_p = __get_pointer();
size_type __cap =
__old_cap < __ms / 2 - __alignment ? __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) : __ms - 1;
@ -2921,7 +2921,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n) {
size_type __sz = __str.size();
if (__pos > __sz)
__throw_out_of_range();
this->__throw_out_of_range();
return assign(__str.data() + __pos, std::min(__n, __sz - __pos));
}
@ -2935,7 +2935,7 @@ basic_string<_CharT, _Traits, _Allocator>::assign(const _Tp& __t, size_type __po
__self_view __sv = __t;
size_type __sz = __sv.size();
if (__pos > __sz)
__throw_out_of_range();
this->__throw_out_of_range();
return assign(__sv.data() + __pos, std::min(__n, __sz - __pos));
}
@ -3068,7 +3068,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, size_type __pos, size_type __n) {
size_type __sz = __str.size();
if (__pos > __sz)
__throw_out_of_range();
this->__throw_out_of_range();
return append(__str.data() + __pos, std::min(__n, __sz - __pos));
}
@ -3082,7 +3082,7 @@ basic_string<_CharT, _Traits, _Allocator>::append(const _Tp& __t, size_type __po
__self_view __sv = __t;
size_type __sz = __sv.size();
if (__pos > __sz)
__throw_out_of_range();
this->__throw_out_of_range();
return append(__sv.data() + __pos, std::min(__n, __sz - __pos));
}
@ -3101,7 +3101,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_t
_LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string::insert received nullptr");
size_type __sz = size();
if (__pos > __sz)
__throw_out_of_range();
this->__throw_out_of_range();
size_type __cap = capacity();
if (__cap - __sz >= __n) {
if (__n) {
@ -3128,7 +3128,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n, value_type __c) {
size_type __sz = size();
if (__pos > __sz)
__throw_out_of_range();
this->__throw_out_of_range();
if (__n) {
size_type __cap = capacity();
value_type* __p;
@ -3190,7 +3190,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(
size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n) {
size_type __str_sz = __str.size();
if (__pos2 > __str_sz)
__throw_out_of_range();
this->__throw_out_of_range();
return insert(__pos1, __str.data() + __pos2, std::min(__n, __str_sz - __pos2));
}
@ -3204,7 +3204,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const _Tp& _
__self_view __sv = __t;
size_type __str_sz = __sv.size();
if (__pos2 > __str_sz)
__throw_out_of_range();
this->__throw_out_of_range();
return insert(__pos1, __sv.data() + __pos2, std::min(__n, __str_sz - __pos2));
}
@ -3248,7 +3248,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(
_LIBCPP_ASSERT_NON_NULL(__n2 == 0 || __s != nullptr, "string::replace received nullptr");
size_type __sz = size();
if (__pos > __sz)
__throw_out_of_range();
this->__throw_out_of_range();
__n1 = std::min(__n1, __sz - __pos);
size_type __cap = capacity();
if (__cap - __sz + __n1 >= __n2) {
@ -3290,7 +3290,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __n1, size_type __n2, value_type __c) {
size_type __sz = size();
if (__pos > __sz)
__throw_out_of_range();
this->__throw_out_of_range();
__n1 = std::min(__n1, __sz - __pos);
size_type __cap = capacity();
value_type* __p;
@ -3326,7 +3326,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(
size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2) {
size_type __str_sz = __str.size();
if (__pos2 > __str_sz)
__throw_out_of_range();
this->__throw_out_of_range();
return replace(__pos1, __n1, __str.data() + __pos2, std::min(__n2, __str_sz - __pos2));
}
@ -3341,7 +3341,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(
__self_view __sv = __t;
size_type __str_sz = __sv.size();
if (__pos2 > __str_sz)
__throw_out_of_range();
this->__throw_out_of_range();
return replace(__pos1, __n1, __sv.data() + __pos2, std::min(__n2, __str_sz - __pos2));
}
@ -3374,7 +3374,7 @@ template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, size_type __n) {
if (__pos > size())
__throw_out_of_range();
this->__throw_out_of_range();
if (__n == npos) {
__erase_to_end(__pos);
} else {
@ -3445,7 +3445,7 @@ basic_string<_CharT, _Traits, _Allocator>::__resize_default_init(size_type __n)
template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __requested_capacity) {
if (__requested_capacity > max_size())
__throw_length_error();
this->__throw_length_error();
// Make sure reserve(n) never shrinks. This is technically only required in C++20
// and later (since P0966R1), however we provide consistent behavior in all Standard
@ -3517,7 +3517,7 @@ template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::const_reference
basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) const {
if (__n >= size())
__throw_out_of_range();
this->__throw_out_of_range();
return (*this)[__n];
}
@ -3525,7 +3525,7 @@ template <class _CharT, class _Traits, class _Allocator>
_LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>::reference
basic_string<_CharT, _Traits, _Allocator>::at(size_type __n) {
if (__n >= size())
__throw_out_of_range();
this->__throw_out_of_range();
return (*this)[__n];
}
@ -3534,7 +3534,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 typename basic_string<_CharT, _Traits, _Allocator>
basic_string<_CharT, _Traits, _Allocator>::copy(value_type* __s, size_type __n, size_type __pos) const {
size_type __sz = size();
if (__pos > __sz)
__throw_out_of_range();
this->__throw_out_of_range();
size_type __rlen = std::min(__n, __sz - __pos);
traits_type::copy(__s, data() + __pos, __rlen);
return __rlen;
@ -3588,7 +3588,7 @@ inline _LIBCPP_CONSTEXPR_SINCE_CXX20 int basic_string<_CharT, _Traits, _Allocato
_LIBCPP_ASSERT_NON_NULL(__n2 == 0 || __s != nullptr, "string::compare(): received nullptr");
size_type __sz = size();
if (__pos1 > __sz || __n2 == npos)
__throw_out_of_range();
this->__throw_out_of_range();
size_type __rlen = std::min(__n1, __sz - __pos1);
int __r = traits_type::compare(data() + __pos1, __s, std::min(__rlen, __n2));
if (__r == 0) {

2
libcxx/include/string_view
View File

@ -447,7 +447,7 @@ public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
copy(_CharT* __s, size_type __n, size_type __pos = 0) const {
if (__pos > size())
__throw_out_of_range("string_view::copy");
std::__throw_out_of_range("string_view::copy");
size_type __rlen = std::min(__n, size() - __pos);
_Traits::copy(__s, data() + __pos, __rlen);
return __rlen;

4
libcxx/include/unordered_map
View File

@ -1784,7 +1784,7 @@ template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
_Tp& unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) {
iterator __i = find(__k);
if (__i == end())
__throw_out_of_range("unordered_map::at: key not found");
std::__throw_out_of_range("unordered_map::at: key not found");
return __i->second;
}
@ -1792,7 +1792,7 @@ template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
const _Tp& unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::at(const key_type& __k) const {
const_iterator __i = find(__k);
if (__i == end())
__throw_out_of_range("unordered_map::at: key not found");
std::__throw_out_of_range("unordered_map::at: key not found");
return __i->second;
}

7
libcxx/include/variant
View File

@ -409,7 +409,8 @@ template <>
struct __find_unambiguous_index_sfinae_impl<__ambiguous> {};
template <class _Tp, class... _Types>
struct __find_unambiguous_index_sfinae : __find_unambiguous_index_sfinae_impl<__find_index<_Tp, _Types...>()> {};
struct __find_unambiguous_index_sfinae
: __find_unambiguous_index_sfinae_impl<__find_detail::__find_index<_Tp, _Types...>()> {};
} // namespace __find_detail
@ -1341,7 +1342,7 @@ template <size_t _Ip, class _Vp>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr auto&& __generic_get(_Vp&& __v) {
using __variant_detail::__access::__variant;
if (!std::__holds_alternative<_Ip>(__v)) {
__throw_bad_variant_access();
std::__throw_bad_variant_access();
}
return __variant::__get_alt<_Ip>(std::forward<_Vp>(__v)).__value;
}
@ -1554,7 +1555,7 @@ template <class... _Vs>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS constexpr void __throw_if_valueless(_Vs&&... __vs) {
const bool __valueless = (... || std::__as_variant(__vs).valueless_by_exception());
if (__valueless) {
__throw_bad_variant_access();
std::__throw_bad_variant_access();
}
}

12
libcxx/src/chrono.cpp
View File

@ -124,7 +124,7 @@ static system_clock::time_point __libcpp_system_clock_now() {
static system_clock::time_point __libcpp_system_clock_now() {
struct timespec ts;
if (timespec_get(&ts, TIME_UTC) != TIME_UTC)
__throw_system_error(errno, "timespec_get(TIME_UTC) failed");
std::__throw_system_error(errno, "timespec_get(TIME_UTC) failed");
return system_clock::time_point(seconds(ts.tv_sec) + microseconds(ts.tv_nsec / 1000));
}
@ -133,7 +133,7 @@ static system_clock::time_point __libcpp_system_clock_now() {
static system_clock::time_point __libcpp_system_clock_now() {
struct timespec tp;
if (0 != clock_gettime(CLOCK_REALTIME, &tp))
__throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
std::__throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
return system_clock::time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000));
}
@ -180,7 +180,7 @@ system_clock::time_point system_clock::from_time_t(time_t t) noexcept { return s
static steady_clock::time_point __libcpp_steady_clock_now() {
struct timespec tp;
if (0 != clock_gettime(CLOCK_MONOTONIC_RAW, &tp))
__throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC_RAW) failed");
std::__throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC_RAW) failed");
return steady_clock::time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
}
@ -213,7 +213,7 @@ static steady_clock::time_point __libcpp_steady_clock_now() {
static steady_clock::time_point __libcpp_steady_clock_now() {
struct timespec64 ts;
if (0 != gettimeofdayMonotonic(&ts))
__throw_system_error(errno, "failed to obtain time of day");
std::__throw_system_error(errno, "failed to obtain time of day");
return steady_clock::time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec));
}
@ -234,7 +234,7 @@ static steady_clock::time_point __libcpp_steady_clock_now() noexcept {
static steady_clock::time_point __libcpp_steady_clock_now() {
struct timespec ts;
if (timespec_get(&ts, TIME_MONOTONIC) != TIME_MONOTONIC)
__throw_system_error(errno, "timespec_get(TIME_MONOTONIC) failed");
std::__throw_system_error(errno, "timespec_get(TIME_MONOTONIC) failed");
return steady_clock::time_point(seconds(ts.tv_sec) + microseconds(ts.tv_nsec / 1000));
}
@ -243,7 +243,7 @@ static steady_clock::time_point __libcpp_steady_clock_now() {
static steady_clock::time_point __libcpp_steady_clock_now() {
struct timespec tp;
if (0 != clock_gettime(CLOCK_MONOTONIC, &tp))
__throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed");
std::__throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed");
return steady_clock::time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
}

8
libcxx/src/condition_variable.cpp
View File

@ -26,17 +26,17 @@ void condition_variable::notify_all() noexcept { __libcpp_condvar_broadcast(&__c
void condition_variable::wait(unique_lock<mutex>& lk) noexcept {
if (!lk.owns_lock())
__throw_system_error(EPERM, "condition_variable::wait: mutex not locked");
std::__throw_system_error(EPERM, "condition_variable::wait: mutex not locked");
int ec = __libcpp_condvar_wait(&__cv_, lk.mutex()->native_handle());
if (ec)
__throw_system_error(ec, "condition_variable wait failed");
std::__throw_system_error(ec, "condition_variable wait failed");
}
void condition_variable::__do_timed_wait(unique_lock<mutex>& lk,
chrono::time_point<chrono::system_clock, chrono::nanoseconds> tp) noexcept {
using namespace chrono;
if (!lk.owns_lock())
__throw_system_error(EPERM, "condition_variable::timed wait: mutex not locked");
std::__throw_system_error(EPERM, "condition_variable::timed wait: mutex not locked");
nanoseconds d = tp.time_since_epoch();
if (d > nanoseconds(0x59682F000000E941))
d = nanoseconds(0x59682F000000E941);
@ -53,7 +53,7 @@ void condition_variable::__do_timed_wait(unique_lock<mutex>& lk,
}
int ec = __libcpp_condvar_timedwait(&__cv_, lk.mutex()->native_handle(), &ts);
if (ec != 0 && ec != ETIMEDOUT)
__throw_system_error(ec, "condition_variable timed_wait failed");
std::__throw_system_error(ec, "condition_variable timed_wait failed");
}
void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk) {

12
libcxx/src/filesystem/error.h
View File

@ -96,11 +96,11 @@ struct ErrorHandler {
string what = string("in ") + func_name_;
switch (bool(p1_) + bool(p2_)) {
case 0:
__throw_filesystem_error(what, ec);
filesystem::__throw_filesystem_error(what, ec);
case 1:
__throw_filesystem_error(what, *p1_, ec);
filesystem::__throw_filesystem_error(what, *p1_, ec);
case 2:
__throw_filesystem_error(what, *p1_, *p2_, ec);
filesystem::__throw_filesystem_error(what, *p1_, *p2_, ec);
}
__libcpp_unreachable();
}
@ -114,11 +114,11 @@ struct ErrorHandler {
string what = string("in ") + func_name_ + ": " + detail::vformat_string(msg, ap);
switch (bool(p1_) + bool(p2_)) {
case 0:
__throw_filesystem_error(what, ec);
filesystem::__throw_filesystem_error(what, ec);
case 1:
__throw_filesystem_error(what, *p1_, ec);
filesystem::__throw_filesystem_error(what, *p1_, ec);
case 2:
__throw_filesystem_error(what, *p1_, *p2_, ec);
filesystem::__throw_filesystem_error(what, *p1_, *p2_, ec);
}
__libcpp_unreachable();
}

4
libcxx/src/filesystem/filesystem_clock.cpp
View File

@ -58,13 +58,13 @@ _FilesystemClock::time_point _FilesystemClock::now() noexcept {
typedef chrono::duration<rep, nano> __nsecs;
struct timespec ts;
if (timespec_get(&ts, TIME_UTC) != TIME_UTC)
__throw_system_error(errno, "timespec_get(TIME_UTC) failed");
std::__throw_system_error(errno, "timespec_get(TIME_UTC) failed");
return time_point(__secs(ts.tv_sec) + chrono::duration_cast<duration>(__nsecs(ts.tv_nsec)));
#elif defined(_LIBCPP_HAS_CLOCK_GETTIME)
typedef chrono::duration<rep, nano> __nsecs;
struct timespec tp;
if (0 != clock_gettime(CLOCK_REALTIME, &tp))
__throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
std::__throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
return time_point(__secs(tp.tv_sec) + chrono::duration_cast<duration>(__nsecs(tp.tv_nsec)));
#else
typedef chrono::duration<rep, micro> __microsecs;

20
libcxx/src/future.cpp
View File

@ -62,7 +62,7 @@ void __assoc_sub_state::__on_zero_shared() noexcept { delete this; }
void __assoc_sub_state::set_value() {
unique_lock<mutex> __lk(__mut_);
if (__has_value())
__throw_future_error(future_errc::promise_already_satisfied);
std::__throw_future_error(future_errc::promise_already_satisfied);
__state_ |= __constructed | ready;
__cv_.notify_all();
}
@ -70,7 +70,7 @@ void __assoc_sub_state::set_value() {
void __assoc_sub_state::set_value_at_thread_exit() {
unique_lock<mutex> __lk(__mut_);
if (__has_value())
__throw_future_error(future_errc::promise_already_satisfied);
std::__throw_future_error(future_errc::promise_already_satisfied);
__state_ |= __constructed;
__thread_local_data()->__make_ready_at_thread_exit(this);
}
@ -78,7 +78,7 @@ void __assoc_sub_state::set_value_at_thread_exit() {
void __assoc_sub_state::set_exception(exception_ptr __p) {
unique_lock<mutex> __lk(__mut_);
if (__has_value())
__throw_future_error(future_errc::promise_already_satisfied);
std::__throw_future_error(future_errc::promise_already_satisfied);
__exception_ = __p;
__state_ |= ready;
__cv_.notify_all();
@ -87,7 +87,7 @@ void __assoc_sub_state::set_exception(exception_ptr __p) {
void __assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p) {
unique_lock<mutex> __lk(__mut_);
if (__has_value())
__throw_future_error(future_errc::promise_already_satisfied);
std::__throw_future_error(future_errc::promise_already_satisfied);
__exception_ = __p;
__thread_local_data()->__make_ready_at_thread_exit(this);
}
@ -122,7 +122,7 @@ void __assoc_sub_state::__sub_wait(unique_lock<mutex>& __lk) {
}
}
void __assoc_sub_state::__execute() { __throw_future_error(future_errc::no_state); }
void __assoc_sub_state::__execute() { std::__throw_future_error(future_errc::no_state); }
future<void>::future(__assoc_sub_state* __state) : __state_(__state) { __state_->__attach_future(); }
@ -152,31 +152,31 @@ promise<void>::~promise() {
future<void> promise<void>::get_future() {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
return future<void>(__state_);
}
void promise<void>::set_value() {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_value();
}
void promise<void>::set_exception(exception_ptr __p) {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_exception(__p);
}
void promise<void>::set_value_at_thread_exit() {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_value_at_thread_exit();
}
void promise<void>::set_exception_at_thread_exit(exception_ptr __p) {
if (__state_ == nullptr)
__throw_future_error(future_errc::no_state);
std::__throw_future_error(future_errc::no_state);
__state_->set_exception_at_thread_exit(__p);
}

4
libcxx/src/hash.cpp
View File

@ -55,13 +55,13 @@ const unsigned indices[] = {
template <size_t _Sz = sizeof(size_t)>
inline _LIBCPP_HIDE_FROM_ABI typename enable_if<_Sz == 4, void>::type __check_for_overflow(size_t N) {
if (N > 0xFFFFFFFB)
__throw_overflow_error("__next_prime overflow");
std::__throw_overflow_error("__next_prime overflow");
}
template <size_t _Sz = sizeof(size_t)>
inline _LIBCPP_HIDE_FROM_ABI typename enable_if<_Sz == 8, void>::type __check_for_overflow(size_t N) {
if (N > 0xFFFFFFFFFFFFFFC5ull)
__throw_overflow_error("__next_prime overflow");
std::__throw_overflow_error("__next_prime overflow");
}
size_t __next_prime(size_t n) {

10
libcxx/src/ios.cpp
View File

@ -217,7 +217,7 @@ void ios_base::clear(iostate state) {
__rdstate_ = state | badbit;
if (((state | (__rdbuf_ ? goodbit : badbit)) & __exceptions_) != 0)
__throw_failure("ios_base::clear");
std::__throw_failure("ios_base::clear");
}
// init
@ -253,24 +253,24 @@ void ios_base::copyfmt(const ios_base& rhs) {
size_t newesize = sizeof(event_callback) * rhs.__event_size_;
new_callbacks.reset(static_cast<event_callback*>(malloc(newesize)));
if (!new_callbacks)
__throw_bad_alloc();
std::__throw_bad_alloc();
size_t newisize = sizeof(int) * rhs.__event_size_;
new_ints.reset(static_cast<int*>(malloc(newisize)));
if (!new_ints)
__throw_bad_alloc();
std::__throw_bad_alloc();
}
if (__iarray_cap_ < rhs.__iarray_size_) {
size_t newsize = sizeof(long) * rhs.__iarray_size_;
new_longs.reset(static_cast<long*>(malloc(newsize)));
if (!new_longs)
__throw_bad_alloc();
std::__throw_bad_alloc();
}
if (__parray_cap_ < rhs.__parray_size_) {
size_t newsize = sizeof(void*) * rhs.__parray_size_;
new_pointers.reset(static_cast<void**>(malloc(newsize)));
if (!new_pointers)
__throw_bad_alloc();
std::__throw_bad_alloc();
}
// Got everything we need. Copy everything but __rdstate_, __rdbuf_ and __exceptions_
__fmtflags_ = rhs.__fmtflags_;

68
libcxx/src/locale.cpp
View File

@ -482,7 +482,7 @@ void locale::__imp::install(facet* f, long id) {
const locale::facet* locale::__imp::use_facet(long id) const {
if (!has_facet(id))
__throw_bad_cast();
std::__throw_bad_cast();
return facets_[static_cast<size_t>(id)];
}
@ -602,7 +602,7 @@ long locale::id::__get() {
collate_byname<char>::collate_byname(const char* n, size_t refs)
: collate<char>(refs), __l_(__locale::__newlocale(_LIBCPP_ALL_MASK, n, 0)) {
if (__l_ == 0)
__throw_runtime_error(
std::__throw_runtime_error(
("collate_byname<char>::collate_byname"
" failed to construct for " +
string(n))
@ -612,7 +612,7 @@ collate_byname<char>::collate_byname(const char* n, size_t refs)
collate_byname<char>::collate_byname(const string& name, size_t refs)
: collate<char>(refs), __l_(__locale::__newlocale(_LIBCPP_ALL_MASK, name.c_str(), 0)) {
if (__l_ == 0)
__throw_runtime_error(
std::__throw_runtime_error(
("collate_byname<char>::collate_byname"
" failed to construct for " +
name)
@ -646,7 +646,7 @@ collate_byname<char>::string_type collate_byname<char>::do_transform(const char_
collate_byname<wchar_t>::collate_byname(const char* n, size_t refs)
: collate<wchar_t>(refs), __l_(__locale::__newlocale(_LIBCPP_ALL_MASK, n, 0)) {
if (__l_ == 0)
__throw_runtime_error(
std::__throw_runtime_error(
("collate_byname<wchar_t>::collate_byname(size_t refs)"
" failed to construct for " +
string(n))
@ -656,7 +656,7 @@ collate_byname<wchar_t>::collate_byname(const char* n, size_t refs)
collate_byname<wchar_t>::collate_byname(const string& name, size_t refs)
: collate<wchar_t>(refs), __l_(__locale::__newlocale(_LIBCPP_ALL_MASK, name.c_str(), 0)) {
if (__l_ == 0)
__throw_runtime_error(
std::__throw_runtime_error(
("collate_byname<wchar_t>::collate_byname(size_t refs)"
" failed to construct for " +
name)
@ -1049,7 +1049,7 @@ const unsigned short* ctype<char>::__classic_upper_table() _NOEXCEPT {
ctype_byname<char>::ctype_byname(const char* name, size_t refs)
: ctype<char>(0, false, refs), __l_(__locale::__newlocale(_LIBCPP_ALL_MASK, name, 0)) {
if (__l_ == 0)
__throw_runtime_error(
std::__throw_runtime_error(
("ctype_byname<char>::ctype_byname"
" failed to construct for " +
string(name))
@ -1059,7 +1059,7 @@ ctype_byname<char>::ctype_byname(const char* name, size_t refs)
ctype_byname<char>::ctype_byname(const string& name, size_t refs)
: ctype<char>(0, false, refs), __l_(__locale::__newlocale(_LIBCPP_ALL_MASK, name.c_str(), 0)) {
if (__l_ == 0)
__throw_runtime_error(
std::__throw_runtime_error(
("ctype_byname<char>::ctype_byname"
" failed to construct for " +
name)
@ -1094,7 +1094,7 @@ const char* ctype_byname<char>::do_tolower(char_type* low, const char_type* high
ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
: ctype<wchar_t>(refs), __l_(__locale::__newlocale(_LIBCPP_ALL_MASK, name, 0)) {
if (__l_ == 0)
__throw_runtime_error(
std::__throw_runtime_error(
("ctype_byname<wchar_t>::ctype_byname"
" failed to construct for " +
string(name))
@ -1104,7 +1104,7 @@ ctype_byname<wchar_t>::ctype_byname(const char* name, size_t refs)
ctype_byname<wchar_t>::ctype_byname(const string& name, size_t refs)
: ctype<wchar_t>(refs), __l_(__locale::__newlocale(_LIBCPP_ALL_MASK, name.c_str(), 0)) {
if (__l_ == 0)
__throw_runtime_error(
std::__throw_runtime_error(
("ctype_byname<wchar_t>::ctype_byname"
" failed to construct for " +
name)
@ -1344,7 +1344,7 @@ codecvt<wchar_t, char, mbstate_t>::codecvt(size_t refs) : locale::facet(refs), _
codecvt<wchar_t, char, mbstate_t>::codecvt(const char* nm, size_t refs)
: locale::facet(refs), __l_(__locale::__newlocale(_LIBCPP_ALL_MASK, nm, 0)) {
if (__l_ == 0)
__throw_runtime_error(
std::__throw_runtime_error(
("codecvt_byname<wchar_t, char, mbstate_t>::codecvt_byname"
" failed to construct for " +
string(nm))
@ -4061,7 +4061,7 @@ void numpunct_byname<char>::__init(const char* nm) {
if (strcmp(nm, "C") != 0) {
__libcpp_unique_locale loc(nm);
if (!loc)
__throw_runtime_error(
std::__throw_runtime_error(
("numpunct_byname<char>::numpunct_byname"
" failed to construct for " +
string(nm))
@ -4092,7 +4092,7 @@ void numpunct_byname<wchar_t>::__init(const char* nm) {
if (strcmp(nm, "C") != 0) {
__libcpp_unique_locale loc(nm);
if (!loc)
__throw_runtime_error(
std::__throw_runtime_error(
("numpunct_byname<wchar_t>::numpunct_byname"
" failed to construct for " +
string(nm))
@ -4444,12 +4444,12 @@ const wstring& __time_get_c_storage<wchar_t>::__r() const {
__time_get::__time_get(const char* nm) : __loc_(__locale::__newlocale(_LIBCPP_ALL_MASK, nm, 0)) {
if (__loc_ == 0)
__throw_runtime_error(("time_get_byname failed to construct for " + string(nm)).c_str());
std::__throw_runtime_error(("time_get_byname failed to construct for " + string(nm)).c_str());
}
__time_get::__time_get(const string& nm) : __loc_(__locale::__newlocale(_LIBCPP_ALL_MASK, nm.c_str(), 0)) {
if (__loc_ == 0)
__throw_runtime_error(("time_get_byname failed to construct for " + nm).c_str());
std::__throw_runtime_error(("time_get_byname failed to construct for " + nm).c_str());
}
__time_get::~__time_get() { __locale::__freelocale(__loc_); }
@ -4610,7 +4610,7 @@ wstring __time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& c
const char* bb = buf;
size_t j = __locale::__mbsrtowcs(wbb, &bb, countof(wbuf), &mb, __loc_);
if (j == size_t(-1))
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wchar_t* wbe = wbb + j;
wstring result;
while (wbb != wbe) {
@ -4771,7 +4771,7 @@ void __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct) {
const char* bb = buf;
size_t j = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, __loc_);
if (j == size_t(-1) || j == 0)
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wbe = wbuf + j;
__weeks_[i].assign(wbuf, wbe);
__locale::__strftime(buf, countof(buf), "%a", &t, __loc_);
@ -4779,7 +4779,7 @@ void __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct) {
bb = buf;
j = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, __loc_);
if (j == size_t(-1) || j == 0)
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wbe = wbuf + j;
__weeks_[i + 7].assign(wbuf, wbe);
}
@ -4791,7 +4791,7 @@ void __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct) {
const char* bb = buf;
size_t j = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, __loc_);
if (j == size_t(-1) || j == 0)
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wbe = wbuf + j;
__months_[i].assign(wbuf, wbe);
__locale::__strftime(buf, countof(buf), "%b", &t, __loc_);
@ -4799,7 +4799,7 @@ void __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct) {
bb = buf;
j = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, __loc_);
if (j == size_t(-1) || j == 0)
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wbe = wbuf + j;
__months_[i + 12].assign(wbuf, wbe);
}
@ -4810,7 +4810,7 @@ void __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct) {
const char* bb = buf;
size_t j = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, __loc_);
if (j == size_t(-1))
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wbe = wbuf + j;
__am_pm_[0].assign(wbuf, wbe);
t.tm_hour = 13;
@ -4819,7 +4819,7 @@ void __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct) {
bb = buf;
j = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, __loc_);
if (j == size_t(-1))
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wbe = wbuf + j;
__am_pm_[1].assign(wbuf, wbe);
__c_ = __analyze('c', ct);
@ -5029,12 +5029,12 @@ time_base::dateorder __time_get_storage<wchar_t>::__do_date_order() const {
__time_put::__time_put(const char* nm) : __loc_(__locale::__newlocale(_LIBCPP_ALL_MASK, nm, 0)) {
if (__loc_ == 0)
__throw_runtime_error(("time_put_byname failed to construct for " + string(nm)).c_str());
std::__throw_runtime_error(("time_put_byname failed to construct for " + string(nm)).c_str());
}
__time_put::__time_put(const string& nm) : __loc_(__locale::__newlocale(_LIBCPP_ALL_MASK, nm.c_str(), 0)) {
if (__loc_ == 0)
__throw_runtime_error(("time_put_byname failed to construct for " + nm).c_str());
std::__throw_runtime_error(("time_put_byname failed to construct for " + nm).c_str());
}
__time_put::~__time_put() {
@ -5059,7 +5059,7 @@ void __time_put::__do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm, char __
const char* __nb = __nar;
size_t j = __locale::__mbsrtowcs(__wb, &__nb, countof(__wb, __we), &mb, __loc_);
if (j == size_t(-1))
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
__we = __wb + j;
}
#endif // _LIBCPP_HAS_WIDE_CHARACTERS
@ -5431,7 +5431,7 @@ void moneypunct_byname<char, false>::init(const char* nm) {
typedef moneypunct<char, false> base;
__libcpp_unique_locale loc(nm);
if (!loc)
__throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
std::__throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
__locale::__lconv_t* lc = __locale::__localeconv(loc.get());
if (!checked_string_to_char_convert(__decimal_point_, lc->mon_decimal_point, loc.get()))
@ -5466,7 +5466,7 @@ void moneypunct_byname<char, true>::init(const char* nm) {
typedef moneypunct<char, true> base;
__libcpp_unique_locale loc(nm);
if (!loc)
__throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
std::__throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
__locale::__lconv_t* lc = __locale::__localeconv(loc.get());
if (!checked_string_to_char_convert(__decimal_point_, lc->mon_decimal_point, loc.get()))
@ -5522,7 +5522,7 @@ void moneypunct_byname<wchar_t, false>::init(const char* nm) {
typedef moneypunct<wchar_t, false> base;
__libcpp_unique_locale loc(nm);
if (!loc)
__throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
std::__throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
__locale::__lconv_t* lc = __locale::__localeconv(loc.get());
if (!checked_string_to_wchar_convert(__decimal_point_, lc->mon_decimal_point, loc.get()))
__decimal_point_ = base::do_decimal_point();
@ -5534,7 +5534,7 @@ void moneypunct_byname<wchar_t, false>::init(const char* nm) {
const char* bb = lc->currency_symbol;
size_t j = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, loc.get());
if (j == size_t(-1))
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wchar_t* wbe = wbuf + j;
__curr_symbol_.assign(wbuf, wbe);
if (lc->frac_digits != CHAR_MAX)
@ -5548,7 +5548,7 @@ void moneypunct_byname<wchar_t, false>::init(const char* nm) {
bb = lc->positive_sign;
j = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, loc.get());
if (j == size_t(-1))
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wbe = wbuf + j;
__positive_sign_.assign(wbuf, wbe);
}
@ -5559,7 +5559,7 @@ void moneypunct_byname<wchar_t, false>::init(const char* nm) {
bb = lc->negative_sign;
j = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, loc.get());
if (j == size_t(-1))
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wbe = wbuf + j;
__negative_sign_.assign(wbuf, wbe);
}
@ -5576,7 +5576,7 @@ void moneypunct_byname<wchar_t, true>::init(const char* nm) {
typedef moneypunct<wchar_t, true> base;
__libcpp_unique_locale loc(nm);
if (!loc)
__throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
std::__throw_runtime_error(("moneypunct_byname failed to construct for " + string(nm)).c_str());
__locale::__lconv_t* lc = __locale::__localeconv(loc.get());
if (!checked_string_to_wchar_convert(__decimal_point_, lc->mon_decimal_point, loc.get()))
@ -5589,7 +5589,7 @@ void moneypunct_byname<wchar_t, true>::init(const char* nm) {
const char* bb = lc->int_curr_symbol;
size_t j = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, loc.get());
if (j == size_t(-1))
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wchar_t* wbe = wbuf + j;
__curr_symbol_.assign(wbuf, wbe);
if (lc->int_frac_digits != CHAR_MAX)
@ -5607,7 +5607,7 @@ void moneypunct_byname<wchar_t, true>::init(const char* nm) {
bb = lc->positive_sign;
j = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, loc.get());
if (j == size_t(-1))
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wbe = wbuf + j;
__positive_sign_.assign(wbuf, wbe);
}
@ -5622,7 +5622,7 @@ void moneypunct_byname<wchar_t, true>::init(const char* nm) {
bb = lc->negative_sign;
j = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, loc.get());
if (j == size_t(-1))
__throw_runtime_error("locale not supported");
std::__throw_runtime_error("locale not supported");
wbe = wbuf + j;
__negative_sign_.assign(wbuf, wbe);
}

4
libcxx/src/memory_resource.cpp
View File

@ -48,7 +48,7 @@ class _LIBCPP_HIDDEN __new_delete_memory_resource_imp : public memory_resource {
std::byte* result = std::__libcpp_allocate<std::byte>(__element_count(bytes), align);
if (!is_aligned_to(result, align)) {
std::__libcpp_deallocate<std::byte>(result, __element_count(bytes), align);
__throw_bad_alloc();
std::__throw_bad_alloc();
}
return result;
#endif
@ -64,7 +64,7 @@ class _LIBCPP_HIDDEN __new_delete_memory_resource_imp : public memory_resource {
// null_memory_resource()
class _LIBCPP_HIDDEN __null_memory_resource_imp : public memory_resource {
void* do_allocate(size_t, size_t) override { __throw_bad_alloc(); }
void* do_allocate(size_t, size_t) override { std::__throw_bad_alloc(); }
void do_deallocate(void*, size_t, size_t) override {}
bool do_is_equal(const memory_resource& other) const noexcept override { return &other == this; }
};

8
libcxx/src/mutex.cpp
View File

@ -28,7 +28,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
void mutex::lock() {
int ec = __libcpp_mutex_lock(&__m_);
if (ec)
__throw_system_error(ec, "mutex lock failed");
std::__throw_system_error(ec, "mutex lock failed");
}
bool mutex::try_lock() noexcept { return __libcpp_mutex_trylock(&__m_); }
@ -45,7 +45,7 @@ void mutex::unlock() noexcept {
recursive_mutex::recursive_mutex() {
int ec = __libcpp_recursive_mutex_init(&__m_);
if (ec)
__throw_system_error(ec, "recursive_mutex constructor failed");
std::__throw_system_error(ec, "recursive_mutex constructor failed");
}
recursive_mutex::~recursive_mutex() {
@ -57,7 +57,7 @@ recursive_mutex::~recursive_mutex() {
void recursive_mutex::lock() {
int ec = __libcpp_recursive_mutex_lock(&__m_);
if (ec)
__throw_system_error(ec, "recursive_mutex lock failed");
std::__throw_system_error(ec, "recursive_mutex lock failed");
}
void recursive_mutex::unlock() noexcept {
@ -108,7 +108,7 @@ void recursive_timed_mutex::lock() {
unique_lock<mutex> lk(__m_);
if (id == __id_) {
if (__count_ == numeric_limits<size_t>::max())
__throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached");
std::__throw_system_error(EAGAIN, "recursive_timed_mutex lock limit reached");
++__count_;
return;
}

2
libcxx/src/print.cpp
View File

@ -51,7 +51,7 @@ __write_to_windows_console([[maybe_unused]] FILE* __stream, [[maybe_unused]] wst
__view.size(),
nullptr,
nullptr) == 0) {
__throw_system_error(filesystem::detail::get_last_error(), "failed to write formatted output");
std::__throw_system_error(filesystem::detail::get_last_error(), "failed to write formatted output");
}
}
# endif // _LIBCPP_HAS_WIDE_CHARACTERS

24
libcxx/src/random.cpp
View File

@ -42,7 +42,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
random_device::random_device(const string& __token) {
if (__token != "/dev/urandom")
__throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
std::__throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
}
random_device::~random_device() {}
@ -52,7 +52,7 @@ unsigned random_device::operator()() {
size_t n = sizeof(r);
int err = getentropy(&r, n);
if (err)
__throw_system_error(errno, "random_device getentropy failed");
std::__throw_system_error(errno, "random_device getentropy failed");
return r;
}
@ -68,7 +68,7 @@ unsigned random_device::operator()() { return arc4random(); }
random_device::random_device(const string& __token) : __f_(open(__token.c_str(), O_RDONLY)) {
if (__f_ < 0)
__throw_system_error(errno, ("random_device failed to open " + __token).c_str());
std::__throw_system_error(errno, ("random_device failed to open " + __token).c_str());
}
random_device::~random_device() { close(__f_); }
@ -80,10 +80,10 @@ unsigned random_device::operator()() {
while (n > 0) {
ssize_t s = read(__f_, p, n);
if (s == 0)
__throw_system_error(ENOMSG, "random_device got EOF");
std::__throw_system_error(ENOMSG, "random_device got EOF");
if (s == -1) {
if (errno != EINTR)
__throw_system_error(errno, "random_device got an unexpected error");
std::__throw_system_error(errno, "random_device got an unexpected error");
continue;
}
n -= static_cast<size_t>(s);
@ -96,10 +96,10 @@ unsigned random_device::operator()() {
random_device::random_device(const string& __token) {
if (__token != "/dev/urandom")
__throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
std::__throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
int error = nacl_secure_random_init();
if (error)
__throw_system_error(error, ("random device failed to open " + __token).c_str());
std::__throw_system_error(error, ("random device failed to open " + __token).c_str());
}
random_device::~random_device() {}
@ -110,9 +110,9 @@ unsigned random_device::operator()() {
size_t bytes_written;
int error = nacl_secure_random(&r, n, &bytes_written);
if (error != 0)
__throw_system_error(error, "random_device failed getting bytes");
std::__throw_system_error(error, "random_device failed getting bytes");
else if (bytes_written != n)
__throw_runtime_error("random_device failed to obtain enough bytes");
std::__throw_runtime_error("random_device failed to obtain enough bytes");
return r;
}
@ -120,7 +120,7 @@ unsigned random_device::operator()() {
random_device::random_device(const string& __token) {
if (__token != "/dev/urandom")
__throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
std::__throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
}
random_device::~random_device() {}
@ -129,7 +129,7 @@ unsigned random_device::operator()() {
unsigned r;
errno_t err = rand_s(&r);
if (err)
__throw_system_error(err, "random_device rand_s failed.");
std::__throw_system_error(err, "random_device rand_s failed.");
return r;
}
@ -137,7 +137,7 @@ unsigned random_device::operator()() {
random_device::random_device(const string& __token) {
if (__token != "/dev/urandom")
__throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
std::__throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
}
random_device::~random_device() {}

2
libcxx/src/std_stream.h
View File

@ -86,7 +86,7 @@ void __stdinbuf<_CharT>::imbue(const locale& __loc) {
__encoding_ = __cv_->encoding();
__always_noconv_ = __cv_->always_noconv();
if (__encoding_ > __limit)
__throw_runtime_error("unsupported locale for standard input");
std::__throw_runtime_error("unsupported locale for standard input");
}
template <class _CharT>

4
libcxx/src/thread.cpp
View File

@ -46,7 +46,7 @@ void thread::join() {
}
if (ec)
__throw_system_error(ec, "thread::join failed");
std::__throw_system_error(ec, "thread::join failed");
}
void thread::detach() {
@ -58,7 +58,7 @@ void thread::detach() {
}
if (ec)
__throw_system_error(ec, "thread::detach failed");
std::__throw_system_error(ec, "thread::detach failed");
}
unsigned thread::hardware_concurrency() noexcept {

1
libcxx/test/tools/clang_tidy_checks/CMakeLists.txt
View File

@ -94,7 +94,6 @@ set(SOURCES
internal_ftm_use.cpp
nodebug_on_aliases.cpp
proper_version_checks.cpp
qualify_declval.cpp
robust_against_adl.cpp
uglify_attributes.cpp

2
libcxx/test/tools/clang_tidy_checks/libcpp_module.cpp
View File

@ -15,7 +15,6 @@
#include "internal_ftm_use.hpp"
#include "nodebug_on_aliases.hpp"
#include "proper_version_checks.hpp"
#include "qualify_declval.hpp"
#include "robust_against_adl.hpp"
#include "uglify_attributes.hpp"
@ -31,7 +30,6 @@ public:
check_factories.registerCheck<libcpp::proper_version_checks>("libcpp-cpp-version-check");
check_factories.registerCheck<libcpp::robust_against_adl_check>("libcpp-robust-against-adl");
check_factories.registerCheck<libcpp::uglify_attributes>("libcpp-uglify-attributes");
check_factories.registerCheck<libcpp::qualify_declval>("libcpp-qualify-declval");
}
};
} // namespace

31
libcxx/test/tools/clang_tidy_checks/qualify_declval.cpp
View File

@ -1,31 +0,0 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "qualify_declval.hpp"
namespace {
AST_MATCHER(clang::UnresolvedLookupExpr, requiresADL) { return Node.requiresADL(); }
AST_MATCHER(clang::UnresolvedLookupExpr, isDeclval) { return Node.getName().getAsString() == "declval"; }
} // namespace
namespace libcpp {
qualify_declval::qualify_declval(llvm::StringRef name, clang::tidy::ClangTidyContext* context)
: clang::tidy::ClangTidyCheck(name, context) {}
void qualify_declval::registerMatchers(clang::ast_matchers::MatchFinder* finder) {
using namespace clang::ast_matchers;
finder->addMatcher(callExpr(has(unresolvedLookupExpr(requiresADL(), isDeclval()))).bind("ADLcall"), this);
}
void qualify_declval::check(const clang::ast_matchers::MatchFinder::MatchResult& result) {
if (const auto* call = result.Nodes.getNodeAs<clang::CallExpr>("ADLcall"); call != nullptr) {
diag(call->getBeginLoc(), "declval should be qualified to get better error messages")
<< clang::FixItHint::CreateInsertion(call->getBeginLoc(), "std::");
}
}
} // namespace libcpp

18
libcxx/test/tools/clang_tidy_checks/qualify_declval.hpp
View File

@ -1,18 +0,0 @@
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "clang-tidy/ClangTidyCheck.h"
namespace libcpp {
class qualify_declval : public clang::tidy::ClangTidyCheck {
public:
qualify_declval(llvm::StringRef, clang::tidy::ClangTidyContext*);
void registerMatchers(clang::ast_matchers::MatchFinder*) override;
void check(const clang::ast_matchers::MatchFinder::MatchResult&) override;
};
} // namespace libcpp

1
libcxx/test/tools/clang_tidy_checks/robust_against_adl.cpp
View File

@ -36,7 +36,6 @@ void robust_against_adl_check::registerMatchers(clang::ast_matchers::MatchFinder
using namespace clang::ast_matchers;
finder->addMatcher(
callExpr(unless(isOperator()),
unless(argumentCountIs(0)),
has(unresolvedLookupExpr(requiresADL(), unless(isCustomizationPoint()))),
unless(callee(cxxMethodDecl(isStatic()))))
.bind("ADLcall"),