maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[libc++] Make parameter names consistent and enforce the naming style using readability-identifier-naming 

Ensure that parameter names have the style `__lower_case`

Reviewed By: ldionne, #libc

Spies: aheejin, sstefan1, libcxx-commits, miyuki

Differential Revision: https://reviews.llvm.org/D129051
This commit is contained in:
Nikolas Klauser 2022-07-08 18:17:26 +02:00
parent 02769f2b3f
commit b48c5010a4
56 changed files with 378 additions and 371 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
libcxx/.clang-tidy
View File

@ -17,6 +17,7 @@ Checks: >
modernize-redundant-void-arg,
readability-duplicate-include,
readability-identifier-naming,
readability-function-cognitive-complexity,
readability-function-size,
readability-misplaced-array-index,
@ -31,6 +32,12 @@ CheckOptions:
value: 143 # TODO: bring that number down
- key: readability-function-size.LineThreshold
value: 194 # TODO: bring that number down
- key: readability-identifier-naming.GetConfigPerFile
value: false
- key: readability-identifier-naming.ParameterCase
value: lower_case
- key: readability-identifier-naming.ParameterPrefix
value: __
# TODO: investigate these checks
# bugprone-branch-clone,

10
libcxx/include/__algorithm/binary_search.h
View File

@ -25,20 +25,20 @@ template <class _ForwardIterator, class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
{
using _Comp_ref = typename __comp_ref_type<_Compare>::type;
__first = std::lower_bound<_ForwardIterator, _Tp, _Comp_ref>(__first, __last, __value_, __comp);
return __first != __last && !__comp(__value_, *__first);
__first = std::lower_bound<_ForwardIterator, _Tp, _Comp_ref>(__first, __last, __value, __comp);
return __first != __last && !__comp(__value, *__first);
}
template <class _ForwardIterator, class _Tp>
_LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
bool
binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
return std::binary_search(__first, __last, __value_,
return std::binary_search(__first, __last, __value,
__less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
}

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

@ -22,10 +22,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _InputIterator, class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
typename iterator_traits<_InputIterator>::difference_type
count(_InputIterator __first, _InputIterator __last, const _Tp& __value_) {
count(_InputIterator __first, _InputIterator __last, const _Tp& __value) {
typename iterator_traits<_InputIterator>::difference_type __r(0);
for (; __first != __last; ++__first)
if (*__first == __value_)
if (*__first == __value)
++__r;
return __r;
}

18
libcxx/include/__algorithm/equal_range.h
View File

@ -30,7 +30,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Compare, class _ForwardIterator, class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 pair<_ForwardIterator, _ForwardIterator>
__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
__equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
{
typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
difference_type __len = _VSTD::distance(__first, __last);
@ -39,12 +39,12 @@ __equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __va
difference_type __l2 = _VSTD::__half_positive(__len);
_ForwardIterator __m = __first;
_VSTD::advance(__m, __l2);
if (__comp(*__m, __value_))
if (__comp(*__m, __value))
{
__first = ++__m;
__len -= __l2 + 1;
}
else if (__comp(__value_, *__m))
else if (__comp(__value, *__m))
{
__last = __m;
__len = __l2;
@ -55,8 +55,8 @@ __equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __va
_ForwardIterator __mp1 = __m;
return pair<_ForwardIterator, _ForwardIterator>
(
_VSTD::__lower_bound_impl<_StdIterOps>(__first, __m, __value_, __comp, __proj),
_VSTD::__upper_bound<_Compare>(++__mp1, __last, __value_, __comp)
_VSTD::__lower_bound_impl<_StdIterOps>(__first, __m, __value, __comp, __proj),
_VSTD::__upper_bound<_Compare>(++__mp1, __last, __value, __comp)
);
}
}
@ -67,19 +67,19 @@ template <class _ForwardIterator, class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
{
typedef typename __comp_ref_type<_Compare>::type _Comp_ref;
return _VSTD::__equal_range<_Comp_ref>(__first, __last, __value_, __comp);
return _VSTD::__equal_range<_Comp_ref>(__first, __last, __value, __comp);
}
template <class _ForwardIterator, class _Tp>
_LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
pair<_ForwardIterator, _ForwardIterator>
equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
return _VSTD::equal_range(__first, __last, __value_,
return _VSTD::equal_range(__first, __last, __value,
__less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
}

12
libcxx/include/__algorithm/fill.h
View File

@ -23,26 +23,26 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _ForwardIterator, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
void
__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, forward_iterator_tag)
__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, forward_iterator_tag)
{
for (; __first != __last; ++__first)
*__first = __value_;
*__first = __value;
}
template <class _RandomAccessIterator, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
void
__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value_, random_access_iterator_tag)
__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value, random_access_iterator_tag)
{
_VSTD::fill_n(__first, __last - __first, __value_);
_VSTD::fill_n(__first, __last - __first, __value);
}
template <class _ForwardIterator, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
void
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
_VSTD::__fill(__first, __last, __value_, typename iterator_traits<_ForwardIterator>::iterator_category());
_VSTD::__fill(__first, __last, __value, typename iterator_traits<_ForwardIterator>::iterator_category());
}
_LIBCPP_END_NAMESPACE_STD

8
libcxx/include/__algorithm/fill_n.h
View File

@ -22,19 +22,19 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _OutputIterator, class _Size, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_OutputIterator
__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
{
for (; __n > 0; ++__first, (void) --__n)
*__first = __value_;
*__first = __value;
return __first;
}
template <class _OutputIterator, class _Size, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_OutputIterator
fill_n(_OutputIterator __first, _Size __n, const _Tp& __value_)
fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
{
return _VSTD::__fill_n(__first, _VSTD::__convert_to_integral(__n), __value_);
return _VSTD::__fill_n(__first, _VSTD::__convert_to_integral(__n), __value);
}
_LIBCPP_END_NAMESPACE_STD

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

@ -20,9 +20,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _InputIterator, class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _InputIterator
find(_InputIterator __first, _InputIterator __last, const _Tp& __value_) {
find(_InputIterator __first, _InputIterator __last, const _Tp& __value) {
for (; __first != __last; ++__first)
if (*__first == __value_)
if (*__first == __value)
break;
return __first;
}

8
libcxx/include/__algorithm/lower_bound.h
View File

@ -48,17 +48,17 @@ _Iter __lower_bound_impl(_Iter __first, _Sent __last, const _Type& __value, _Com
template <class _ForwardIterator, class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
_ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp) {
_ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp) {
static_assert(__is_callable<_Compare, decltype(*__first), const _Tp&>::value,
"The comparator has to be callable");
auto __proj = std::__identity();
return std::__lower_bound_impl<_StdIterOps>(__first, __last, __value_, __comp, __proj);
return std::__lower_bound_impl<_StdIterOps>(__first, __last, __value, __comp, __proj);
}
template <class _ForwardIterator, class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
_ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_) {
return std::lower_bound(__first, __last, __value_,
_ForwardIterator lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
return std::lower_bound(__first, __last, __value,
__less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
}

8
libcxx/include/__algorithm/minmax_element.h
View File

@ -24,17 +24,17 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Comp, class _Proj>
class _MinmaxElementLessFunc {
_Comp& __comp;
_Proj& __proj;
_Comp& __comp_;
_Proj& __proj_;
public:
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
_MinmaxElementLessFunc(_Comp& __comp_, _Proj& __proj_) : __comp(__comp_), __proj(__proj_) {}
_MinmaxElementLessFunc(_Comp& __comp, _Proj& __proj) : __comp_(__comp), __proj_(__proj) {}
template <class _Iter>
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
bool operator()(_Iter& __it1, _Iter& __it2) {
return std::__invoke(__comp, std::__invoke(__proj, *__it1), std::__invoke(__proj, *__it2));
return std::__invoke(__comp_, std::__invoke(__proj_, *__it1), std::__invoke(__proj_, *__it2));
}
};

6
libcxx/include/__algorithm/remove.h
View File

@ -22,15 +22,15 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _ForwardIterator, class _Tp>
_LIBCPP_NODISCARD_EXT _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
__first = _VSTD::find(__first, __last, __value_);
__first = _VSTD::find(__first, __last, __value);
if (__first != __last)
{
_ForwardIterator __i = __first;
while (++__i != __last)
{
if (!(*__i == __value_))
if (!(*__i == __value))
{
*__first = _VSTD::move(*__i);
++__first;

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

@ -20,11 +20,11 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _InputIterator, class _OutputIterator, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_OutputIterator
remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value_)
remove_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, const _Tp& __value)
{
for (; __first != __last; ++__first)
{
if (!(*__first == __value_))
if (!(*__first == __value))
{
*__result = *__first;
++__result;

20
libcxx/include/__algorithm/search_n.h
View File

@ -23,7 +23,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _BinaryPredicate, class _ForwardIterator, class _Size, class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator __search_n(_ForwardIterator __first, _ForwardIterator __last,
_Size __count, const _Tp& __value_, _BinaryPredicate __pred,
_Size __count, const _Tp& __value, _BinaryPredicate __pred,
forward_iterator_tag) {
if (__count <= 0)
return __first;
@ -32,7 +32,7 @@ _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator __search_n(_ForwardIterator __fir
while (true) {
if (__first == __last) // return __last if no element matches __value_
return __last;
if (__pred(*__first, __value_))
if (__pred(*__first, __value))
break;
++__first;
}
@ -44,7 +44,7 @@ _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator __search_n(_ForwardIterator __fir
return __first;
if (++__m == __last) // Otherwise if source exhaused, pattern not found
return __last;
if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first
if (!__pred(*__m, __value)) // if there is a mismatch, restart with a new __first
{
__first = __m;
++__first;
@ -57,7 +57,7 @@ _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator __search_n(_ForwardIterator __fir
template <class _BinaryPredicate, class _RandomAccessIterator, class _Size, class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator __search_n(_RandomAccessIterator __first,
_RandomAccessIterator __last, _Size __count,
const _Tp& __value_, _BinaryPredicate __pred,
const _Tp& __value, _BinaryPredicate __pred,
random_access_iterator_tag) {
typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
if (__count <= 0)
@ -71,7 +71,7 @@ _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator __search_n(_RandomAccessIter
while (true) {
if (__first >= __s) // return __last if no element matches __value_
return __last;
if (__pred(*__first, __value_))
if (__pred(*__first, __value))
break;
++__first;
}
@ -82,7 +82,7 @@ _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator __search_n(_RandomAccessIter
if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern)
return __first;
++__m; // no need to check range on __m because __s guarantees we have enough source
if (!__pred(*__m, __value_)) // if there is a mismatch, restart with a new __first
if (!__pred(*__m, __value)) // if there is a mismatch, restart with a new __first
{
__first = __m;
++__first;
@ -94,17 +94,17 @@ _LIBCPP_CONSTEXPR_AFTER_CXX17 _RandomAccessIterator __search_n(_RandomAccessIter
template <class _ForwardIterator, class _Size, class _Tp, class _BinaryPredicate>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator search_n(
_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_, _BinaryPredicate __pred) {
_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value, _BinaryPredicate __pred) {
return _VSTD::__search_n<_BinaryPredicate&>(
__first, __last, _VSTD::__convert_to_integral(__count), __value_, __pred,
__first, __last, _VSTD::__convert_to_integral(__count), __value, __pred,
typename iterator_traits<_ForwardIterator>::iterator_category());
}
template <class _ForwardIterator, class _Size, class _Tp>
_LIBCPP_NODISCARD_EXT inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value_) {
search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value) {
typedef typename iterator_traits<_ForwardIterator>::value_type __v;
return _VSTD::search_n(__first, __last, _VSTD::__convert_to_integral(__count), __value_, __equal_to<__v, _Tp>());
return _VSTD::search_n(__first, __last, _VSTD::__convert_to_integral(__count), __value, __equal_to<__v, _Tp>());
}
_LIBCPP_END_NAMESPACE_STD

12
libcxx/include/__algorithm/upper_bound.h
View File

@ -24,7 +24,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _Compare, class _ForwardIterator, class _Tp>
_LIBCPP_CONSTEXPR_AFTER_CXX17 _ForwardIterator
__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
__upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
{
typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
difference_type __len = _VSTD::distance(__first, __last);
@ -33,7 +33,7 @@ __upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __va
difference_type __l2 = _VSTD::__half_positive(__len);
_ForwardIterator __m = __first;
_VSTD::advance(__m, __l2);
if (__comp(__value_, *__m))
if (__comp(__value, *__m))
__len = __l2;
else
{
@ -48,18 +48,18 @@ template <class _ForwardIterator, class _Tp, class _Compare>
_LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_, _Compare __comp)
upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
{
return _VSTD::__upper_bound<_Compare&>(__first, __last, __value_, __comp);
return _VSTD::__upper_bound<_Compare&>(__first, __last, __value, __comp);
}
template <class _ForwardIterator, class _Tp>
_LIBCPP_NODISCARD_EXT inline
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
_ForwardIterator
upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value_)
upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
{
return _VSTD::upper_bound(__first, __last, __value_,
return _VSTD::upper_bound(__first, __last, __value,
__less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>());
}

16
libcxx/include/__bit_reference
View File

@ -250,9 +250,9 @@ __find_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_type
template <class _Cp, bool _IsConst, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
__bit_iterator<_Cp, _IsConst>
find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)
find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value)
{
if (static_cast<bool>(__value_))
if (static_cast<bool>(__value))
return _VSTD::__find_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
return _VSTD::__find_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
}
@ -324,9 +324,9 @@ __count_bool_false(__bit_iterator<_Cp, _IsConst> __first, typename _Cp::size_typ
template <class _Cp, bool _IsConst, class _Tp>
inline _LIBCPP_INLINE_VISIBILITY
typename __bit_iterator<_Cp, _IsConst>::difference_type
count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value_)
count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value)
{
if (static_cast<bool>(__value_))
if (static_cast<bool>(__value))
return _VSTD::__count_bool_true(__first, static_cast<typename _Cp::size_type>(__last - __first));
return _VSTD::__count_bool_false(__first, static_cast<typename _Cp::size_type>(__last - __first));
}
@ -396,11 +396,11 @@ __fill_n_true(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n)
template <class _Cp>
inline _LIBCPP_INLINE_VISIBILITY
void
fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value_)
fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __value)
{
if (__n > 0)
{
if (__value_)
if (__value)
_VSTD::__fill_n_true(__first, __n);
else
_VSTD::__fill_n_false(__first, __n);
@ -412,9 +412,9 @@ fill_n(__bit_iterator<_Cp, false> __first, typename _Cp::size_type __n, bool __v
template <class _Cp>
inline _LIBCPP_INLINE_VISIBILITY
void
fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value_)
fill(__bit_iterator<_Cp, false> __first, __bit_iterator<_Cp, false> __last, bool __value)
{
_VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value_);
_VSTD::fill_n(__first, static_cast<typename _Cp::size_type>(__last - __first), __value);
}
// copy

8
libcxx/include/__chrono/duration.h
View File

@ -286,10 +286,10 @@ public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator*=(const rep& __rhs) {__rep_ *= __rhs; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& __rhs) {__rep_ /= __rhs; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& __rhs) {__rep_ %= __rhs; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& __rhs) {__rep_ %= __rhs.count(); return *this;}
// special values

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

@ -47,12 +47,12 @@ public:
// conversions
template <class _Duration2>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
time_point(const time_point<clock, _Duration2>& t,
time_point(const time_point<clock, _Duration2>& __t,
typename enable_if
<
is_convertible<_Duration2, duration>::value
>::type* = nullptr)
: __d_(t.time_since_epoch()) {}
: __d_(__t.time_since_epoch()) {}
// observer

8
libcxx/include/__chrono/year_month_weekday.h
View File

@ -47,10 +47,10 @@ public:
: year_month_weekday(__from_days(__sysd.time_since_epoch())) {}
_LIBCPP_HIDE_FROM_ABI inline explicit constexpr year_month_weekday(const local_days& __locd) noexcept
: year_month_weekday(__from_days(__locd.time_since_epoch())) {}
_LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator+=(const months& m) noexcept;
_LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator-=(const months& m) noexcept;
_LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator+=(const years& y) noexcept;
_LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator-=(const years& y) noexcept;
_LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator+=(const months&) noexcept;
_LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator-=(const months&) noexcept;
_LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator+=(const years&) noexcept;
_LIBCPP_HIDE_FROM_ABI constexpr year_month_weekday& operator-=(const years&) noexcept;
_LIBCPP_HIDE_FROM_ABI inline constexpr chrono::year year() const noexcept { return __y; }
_LIBCPP_HIDE_FROM_ABI inline constexpr chrono::month month() const noexcept { return __m; }

34
libcxx/include/__filesystem/copy_options.h
View File

@ -38,41 +38,41 @@ enum class _LIBCPP_ENUM_VIS copy_options : unsigned short {
};
_LIBCPP_INLINE_VISIBILITY
inline constexpr copy_options operator&(copy_options _LHS, copy_options _RHS) {
return static_cast<copy_options>(static_cast<unsigned short>(_LHS) &
static_cast<unsigned short>(_RHS));
inline constexpr copy_options operator&(copy_options __lhs, copy_options __rhs) {
return static_cast<copy_options>(static_cast<unsigned short>(__lhs) &
static_cast<unsigned short>(__rhs));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr copy_options operator|(copy_options _LHS, copy_options _RHS) {
return static_cast<copy_options>(static_cast<unsigned short>(_LHS) |
static_cast<unsigned short>(_RHS));
inline constexpr copy_options operator|(copy_options __lhs, copy_options __rhs) {
return static_cast<copy_options>(static_cast<unsigned short>(__lhs) |
static_cast<unsigned short>(__rhs));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr copy_options operator^(copy_options _LHS, copy_options _RHS) {
return static_cast<copy_options>(static_cast<unsigned short>(_LHS) ^
static_cast<unsigned short>(_RHS));
inline constexpr copy_options operator^(copy_options __lhs, copy_options __rhs) {
return static_cast<copy_options>(static_cast<unsigned short>(__lhs) ^
static_cast<unsigned short>(__rhs));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr copy_options operator~(copy_options _LHS) {
return static_cast<copy_options>(~static_cast<unsigned short>(_LHS));
inline constexpr copy_options operator~(copy_options __lhs) {
return static_cast<copy_options>(~static_cast<unsigned short>(__lhs));
}
_LIBCPP_INLINE_VISIBILITY
inline copy_options& operator&=(copy_options& _LHS, copy_options _RHS) {
return _LHS = _LHS & _RHS;
inline copy_options& operator&=(copy_options& __lhs, copy_options __rhs) {
return __lhs = __lhs & __rhs;
}
_LIBCPP_INLINE_VISIBILITY
inline copy_options& operator|=(copy_options& _LHS, copy_options _RHS) {
return _LHS = _LHS | _RHS;
inline copy_options& operator|=(copy_options& __lhs, copy_options __rhs) {
return __lhs = __lhs | __rhs;
}
_LIBCPP_INLINE_VISIBILITY
inline copy_options& operator^=(copy_options& _LHS, copy_options _RHS) {
return _LHS = _LHS ^ _RHS;
inline copy_options& operator^=(copy_options& __lhs, copy_options __rhs) {
return __lhs = __lhs ^ __rhs;
}
_LIBCPP_AVAILABILITY_FILESYSTEM_POP

46
libcxx/include/__filesystem/directory_options.h
View File

@ -30,47 +30,47 @@ enum class _LIBCPP_ENUM_VIS directory_options : unsigned char {
};
_LIBCPP_INLINE_VISIBILITY
inline constexpr directory_options operator&(directory_options _LHS,
directory_options _RHS) {
return static_cast<directory_options>(static_cast<unsigned char>(_LHS) &
static_cast<unsigned char>(_RHS));
inline constexpr directory_options operator&(directory_options __lhs,
directory_options __rhs) {
return static_cast<directory_options>(static_cast<unsigned char>(__lhs) &
static_cast<unsigned char>(__rhs));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr directory_options operator|(directory_options _LHS,
directory_options _RHS) {
return static_cast<directory_options>(static_cast<unsigned char>(_LHS) |
static_cast<unsigned char>(_RHS));
inline constexpr directory_options operator|(directory_options __lhs,
directory_options __rhs) {
return static_cast<directory_options>(static_cast<unsigned char>(__lhs) |
static_cast<unsigned char>(__rhs));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr directory_options operator^(directory_options _LHS,
directory_options _RHS) {
return static_cast<directory_options>(static_cast<unsigned char>(_LHS) ^
static_cast<unsigned char>(_RHS));
inline constexpr directory_options operator^(directory_options __lhs,
directory_options __rhs) {
return static_cast<directory_options>(static_cast<unsigned char>(__lhs) ^
static_cast<unsigned char>(__rhs));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr directory_options operator~(directory_options _LHS) {
return static_cast<directory_options>(~static_cast<unsigned char>(_LHS));
inline constexpr directory_options operator~(directory_options __lhs) {
return static_cast<directory_options>(~static_cast<unsigned char>(__lhs));
}
_LIBCPP_INLINE_VISIBILITY
inline directory_options& operator&=(directory_options& _LHS,
directory_options _RHS) {
return _LHS = _LHS & _RHS;
inline directory_options& operator&=(directory_options& __lhs,
directory_options __rhs) {
return __lhs = __lhs & __rhs;
}
_LIBCPP_INLINE_VISIBILITY
inline directory_options& operator|=(directory_options& _LHS,
directory_options _RHS) {
return _LHS = _LHS | _RHS;
inline directory_options& operator|=(directory_options& __lhs,
directory_options __rhs) {
return __lhs = __lhs | __rhs;
}
_LIBCPP_INLINE_VISIBILITY
inline directory_options& operator^=(directory_options& _LHS,
directory_options _RHS) {
return _LHS = _LHS ^ _RHS;
inline directory_options& operator^=(directory_options& __lhs,
directory_options __rhs) {
return __lhs = __lhs ^ __rhs;
}
_LIBCPP_AVAILABILITY_FILESYSTEM_POP

22
libcxx/include/__filesystem/operations.h
View File

@ -39,10 +39,10 @@ _LIBCPP_FUNC_VIS path __canonical(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS bool __copy_file(const path& __from, const path& __to, copy_options __opt, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS void __copy_symlink(const path& __existing_symlink, const path& __new_symlink, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS void __copy(const path& __from, const path& __to, copy_options __opt, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS bool __create_directories(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS bool __create_directories(const path&, error_code* = nullptr);
_LIBCPP_FUNC_VIS void __create_directory_symlink(const path& __to, const path& __new_symlink, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS bool __create_directory(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS bool __create_directory(const path& p, const path& attributes, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS bool __create_directory(const path&, error_code* = nullptr);
_LIBCPP_FUNC_VIS bool __create_directory(const path&, const path& __attributes, error_code* = nullptr);
_LIBCPP_FUNC_VIS void __create_hard_link(const path& __to, const path& __new_hard_link, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS void __create_symlink(const path& __to, const path& __new_symlink, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS path __current_path(error_code* __ec = nullptr);
@ -52,14 +52,14 @@ _LIBCPP_FUNC_VIS file_status __status(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS uintmax_t __file_size(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS uintmax_t __hard_link_count(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS file_status __symlink_status(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS file_time_type __last_write_time(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS void __last_write_time(const path& p, file_time_type new_time, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS file_time_type __last_write_time(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS void __last_write_time(const path&, file_time_type __new_time, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS path __weakly_canonical(path const& __p, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS path __read_symlink(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS uintmax_t __remove_all(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS bool __remove(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS void __rename(const path& from, const path& to, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS void __resize_file(const path& p, uintmax_t size, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS path __read_symlink(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS uintmax_t __remove_all(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS bool __remove(const path&, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS void __rename(const path& __from, const path& __to, error_code* __ec = nullptr);
_LIBCPP_FUNC_VIS void __resize_file(const path&, uintmax_t __size, error_code* = nullptr);
_LIBCPP_FUNC_VIS path __temp_directory_path(error_code* __ec = nullptr);
inline _LIBCPP_HIDE_FROM_ABI path absolute(const path& __p) { return __absolute(__p); }
@ -118,7 +118,7 @@ inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(const path& __p, error_code&
inline _LIBCPP_HIDE_FROM_ABI bool is_directory(file_status __s) noexcept { return __s.type() == file_type::directory; }
inline _LIBCPP_HIDE_FROM_ABI bool is_directory(const path& __p) { return is_directory(__status(__p)); }
inline _LIBCPP_HIDE_FROM_ABI bool is_directory(const path& __p, error_code& __ec) noexcept { return is_directory(__status(__p, &__ec)); }
_LIBCPP_FUNC_VIS bool __fs_is_empty(const path& p, error_code* ec = nullptr);
_LIBCPP_FUNC_VIS bool __fs_is_empty(const path& __p, error_code* __ec = nullptr);
inline _LIBCPP_HIDE_FROM_ABI bool is_empty(const path& __p) { return __fs_is_empty(__p); }
inline _LIBCPP_HIDE_FROM_ABI bool is_empty(const path& __p, error_code& __ec) { return __fs_is_empty(__p, &__ec); }
inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(file_status __s) noexcept { return __s.type() == file_type::fifo; }

34
libcxx/include/__filesystem/perm_options.h
View File

@ -31,41 +31,41 @@ enum class _LIBCPP_ENUM_VIS perm_options : unsigned char {
};
_LIBCPP_INLINE_VISIBILITY
inline constexpr perm_options operator&(perm_options _LHS, perm_options _RHS) {
return static_cast<perm_options>(static_cast<unsigned>(_LHS) &
static_cast<unsigned>(_RHS));
inline constexpr perm_options operator&(perm_options __lhs, perm_options __rhs) {
return static_cast<perm_options>(static_cast<unsigned>(__lhs) &
static_cast<unsigned>(__rhs));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr perm_options operator|(perm_options _LHS, perm_options _RHS) {
return static_cast<perm_options>(static_cast<unsigned>(_LHS) |
static_cast<unsigned>(_RHS));
inline constexpr perm_options operator|(perm_options __lhs, perm_options __rhs) {
return static_cast<perm_options>(static_cast<unsigned>(__lhs) |
static_cast<unsigned>(__rhs));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr perm_options operator^(perm_options _LHS, perm_options _RHS) {
return static_cast<perm_options>(static_cast<unsigned>(_LHS) ^
static_cast<unsigned>(_RHS));
inline constexpr perm_options operator^(perm_options __lhs, perm_options __rhs) {
return static_cast<perm_options>(static_cast<unsigned>(__lhs) ^
static_cast<unsigned>(__rhs));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr perm_options operator~(perm_options _LHS) {
return static_cast<perm_options>(~static_cast<unsigned>(_LHS));
inline constexpr perm_options operator~(perm_options __lhs) {
return static_cast<perm_options>(~static_cast<unsigned>(__lhs));
}
_LIBCPP_INLINE_VISIBILITY
inline perm_options& operator&=(perm_options& _LHS, perm_options _RHS) {
return _LHS = _LHS & _RHS;
inline perm_options& operator&=(perm_options& __lhs, perm_options __rhs) {
return __lhs = __lhs & __rhs;
}
_LIBCPP_INLINE_VISIBILITY
inline perm_options& operator|=(perm_options& _LHS, perm_options _RHS) {
return _LHS = _LHS | _RHS;
inline perm_options& operator|=(perm_options& __lhs, perm_options __rhs) {
return __lhs = __lhs | __rhs;
}
_LIBCPP_INLINE_VISIBILITY
inline perm_options& operator^=(perm_options& _LHS, perm_options _RHS) {
return _LHS = _LHS ^ _RHS;
inline perm_options& operator^=(perm_options& __lhs, perm_options __rhs) {
return __lhs = __lhs ^ __rhs;
}
_LIBCPP_AVAILABILITY_FILESYSTEM_POP

28
libcxx/include/__filesystem/perms.h
View File

@ -55,36 +55,36 @@ enum class _LIBCPP_ENUM_VIS perms : unsigned {
};
_LIBCPP_INLINE_VISIBILITY
inline constexpr perms operator&(perms _LHS, perms _RHS) {
return static_cast<perms>(static_cast<unsigned>(_LHS) &
static_cast<unsigned>(_RHS));
inline constexpr perms operator&(perms __lhs, perms __rhs) {
return static_cast<perms>(static_cast<unsigned>(__lhs) &
static_cast<unsigned>(__rhs));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr perms operator|(perms _LHS, perms _RHS) {
return static_cast<perms>(static_cast<unsigned>(_LHS) |
static_cast<unsigned>(_RHS));
inline constexpr perms operator|(perms __lhs, perms __rhs) {
return static_cast<perms>(static_cast<unsigned>(__lhs) |
static_cast<unsigned>(__rhs));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr perms operator^(perms _LHS, perms _RHS) {
return static_cast<perms>(static_cast<unsigned>(_LHS) ^
static_cast<unsigned>(_RHS));
inline constexpr perms operator^(perms __lhs, perms __rhs) {
return static_cast<perms>(static_cast<unsigned>(__lhs) ^
static_cast<unsigned>(__rhs));
}
_LIBCPP_INLINE_VISIBILITY
inline constexpr perms operator~(perms _LHS) {
return static_cast<perms>(~static_cast<unsigned>(_LHS));
inline constexpr perms operator~(perms __lhs) {
return static_cast<perms>(~static_cast<unsigned>(__lhs));
}
_LIBCPP_INLINE_VISIBILITY
inline perms& operator&=(perms& _LHS, perms _RHS) { return _LHS = _LHS & _RHS; }
inline perms& operator&=(perms& __lhs, perms __rhs) { return __lhs = __lhs & __rhs; }
_LIBCPP_INLINE_VISIBILITY
inline perms& operator|=(perms& _LHS, perms _RHS) { return _LHS = _LHS | _RHS; }
inline perms& operator|=(perms& __lhs, perms __rhs) { return __lhs = __lhs | __rhs; }
_LIBCPP_INLINE_VISIBILITY
inline perms& operator^=(perms& _LHS, perms _RHS) { return _LHS = _LHS ^ _RHS; }
inline perms& operator^=(perms& __lhs, perms __rhs) { return __lhs = __lhs ^ __rhs; }
_LIBCPP_AVAILABILITY_FILESYSTEM_POP

6
libcxx/include/__format/formatter_output.h
View File

@ -33,8 +33,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
namespace __formatter {
_LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char c) {
switch (c) {
_LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char __c) {
switch (__c) {
case 'a':
return 'A';
case 'b':
@ -48,7 +48,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr char __hex_to_upper(char c) {
case 'f':
return 'F';
}
return c;
return __c;
}
struct _LIBCPP_TYPE_VIS __padding_size_result {

4
libcxx/include/__format/parser_std_format_spec.h
View File

@ -64,7 +64,7 @@ __parse_arg_id(const _CharT* __begin, const _CharT* __end, auto& __parse_ctx) {
template <class _Context>
_LIBCPP_HIDE_FROM_ABI constexpr uint32_t
__substitute_arg_id(basic_format_arg<_Context> _Arg) {
__substitute_arg_id(basic_format_arg<_Context> __format_arg) {
return visit_format_arg(
[](auto __arg) -> uint32_t {
using _Type = decltype(__arg);
@ -88,7 +88,7 @@ __substitute_arg_id(basic_format_arg<_Context> _Arg) {
__throw_format_error("A format-spec arg-id replacement argument "
"isn't an integral type");
},
_Arg);
__format_arg);
}
/** Helper struct returned from @ref __get_string_alignment. */

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

@ -390,9 +390,9 @@ template <class _Rp, class... _ArgTypes> class __value_func<_Rp(_ArgTypes...)>
typedef __base<_Rp(_ArgTypes...)> __func;
__func* __f_;
_LIBCPP_NO_CFI static __func* __as_base(void* p)
_LIBCPP_NO_CFI static __func* __as_base(void* __p)
{
return reinterpret_cast<__func*>(p);
return reinterpret_cast<__func*>(__p);
}
public:

8
libcxx/include/__iterator/back_insert_iterator.h
View File

@ -46,11 +46,11 @@ public:
typedef _Container container_type;
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(const typename _Container::value_type& __value_)
{container->push_back(__value_); return *this;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(const typename _Container::value_type& __value)
{container->push_back(__value); return *this;}
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(typename _Container::value_type&& __value_)
{container->push_back(_VSTD::move(__value_)); return *this;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(typename _Container::value_type&& __value)
{container->push_back(_VSTD::move(__value)); return *this;}
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator*() {return *this;}
_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator++() {return *this;}

8
libcxx/include/__iterator/front_insert_iterator.h
View File

@ -46,11 +46,11 @@ public:
typedef _Container container_type;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(const typename _Container::value_type& __value_)
{container->push_front(__value_); return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(const typename _Container::value_type& __value)
{container->push_front(__value); return *this;}
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(typename _Container::value_type&& __value_)
{container->push_front(_VSTD::move(__value_)); return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(typename _Container::value_type&& __value)
{container->push_front(_VSTD::move(__value)); return *this;}
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator*() {return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator++() {return *this;}

8
libcxx/include/__iterator/insert_iterator.h
View File

@ -57,11 +57,11 @@ public:
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator(_Container& __x, __insert_iterator_iter_t<_Container> __i)
: container(_VSTD::addressof(__x)), iter(__i) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(const typename _Container::value_type& __value_)
{iter = container->insert(iter, __value_); ++iter; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(const typename _Container::value_type& __value)
{iter = container->insert(iter, __value); ++iter; return *this;}
#ifndef _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(typename _Container::value_type&& __value_)
{iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(typename _Container::value_type&& __value)
{iter = container->insert(iter, _VSTD::move(__value)); ++iter; return *this;}
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator*() {return *this;}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++() {return *this;}

4
libcxx/include/__iterator/ostream_iterator.h
View File

@ -53,9 +53,9 @@ public:
: __out_stream_(_VSTD::addressof(__s)), __delim_(nullptr) {}
_LIBCPP_INLINE_VISIBILITY ostream_iterator(ostream_type& __s, const _CharT* __delimiter) _NOEXCEPT
: __out_stream_(_VSTD::addressof(__s)), __delim_(__delimiter) {}
_LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value_)
_LIBCPP_INLINE_VISIBILITY ostream_iterator& operator=(const _Tp& __value)
{
*__out_stream_ << __value_;
*__out_stream_ << __value;
if (__delim_)
*__out_stream_ << __delim_;
return *this;

2
libcxx/include/__iterator/reverse_iterator.h
View File

@ -136,7 +136,7 @@ public:
#if _LIBCPP_STD_VER > 17
_LIBCPP_INLINE_VISIBILITY
constexpr pointer operator->() const
requires is_pointer_v<_Iter> || requires(const _Iter i) { i.operator->(); }
requires is_pointer_v<_Iter> || requires(const _Iter __i) { __i.operator->(); }
{
if constexpr (is_pointer_v<_Iter>) {
return std::prev(current);

6
libcxx/include/__numeric/iota.h
View File

@ -21,10 +21,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
template <class _ForwardIterator, class _Tp>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
void
iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value_)
iota(_ForwardIterator __first, _ForwardIterator __last, _Tp __value)
{
for (; __first != __last; ++__first, (void) ++__value_)
*__first = __value_;
for (; __first != __last; ++__first, (void) ++__value)
*__first = __value;
}
_LIBCPP_END_NAMESPACE_STD

20
libcxx/include/__random/piecewise_constant_distribution.h
View File

@ -43,8 +43,8 @@ public:
param_type();
template<class _InputIteratorB, class _InputIteratorW>
param_type(_InputIteratorB __fB, _InputIteratorB __lB,
_InputIteratorW __fW);
param_type(_InputIteratorB __f_b, _InputIteratorB __l_b,
_InputIteratorW __f_w);
#ifndef _LIBCPP_CXX03_LANG
template<class _UnaryOperation>
param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
@ -94,10 +94,10 @@ public:
piecewise_constant_distribution() {}
template<class _InputIteratorB, class _InputIteratorW>
_LIBCPP_INLINE_VISIBILITY
piecewise_constant_distribution(_InputIteratorB __fB,
_InputIteratorB __lB,
_InputIteratorW __fW)
: __p_(__fB, __lB, __fW) {}
piecewise_constant_distribution(_InputIteratorB __f_b,
_InputIteratorB __l_b,
_InputIteratorW __f_w)
: __p_(__f_b, __l_b, __f_w) {}
#ifndef _LIBCPP_CXX03_LANG
template<class _UnaryOperation>
@ -215,8 +215,8 @@ piecewise_constant_distribution<_RealType>::param_type::param_type()
template<class _RealType>
template<class _InputIteratorB, class _InputIteratorW>
piecewise_constant_distribution<_RealType>::param_type::param_type(
_InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
: __b_(__fB, __lB)
_InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w)
: __b_(__f_b, __l_b)
{
if (__b_.size() < 2)
{
@ -229,8 +229,8 @@ piecewise_constant_distribution<_RealType>::param_type::param_type(
else
{
__densities_.reserve(__b_.size() - 1);
for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__fW)
__densities_.push_back(*__fW);
for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__f_w)
__densities_.push_back(*__f_w);
__init();
}
}

20
libcxx/include/__random/piecewise_linear_distribution.h
View File

@ -43,8 +43,8 @@ public:
param_type();
template<class _InputIteratorB, class _InputIteratorW>
param_type(_InputIteratorB __fB, _InputIteratorB __lB,
_InputIteratorW __fW);
param_type(_InputIteratorB __f_b, _InputIteratorB __l_b,
_InputIteratorW __f_w);
#ifndef _LIBCPP_CXX03_LANG
template<class _UnaryOperation>
param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
@ -94,10 +94,10 @@ public:
piecewise_linear_distribution() {}
template<class _InputIteratorB, class _InputIteratorW>
_LIBCPP_INLINE_VISIBILITY
piecewise_linear_distribution(_InputIteratorB __fB,
_InputIteratorB __lB,
_InputIteratorW __fW)
: __p_(__fB, __lB, __fW) {}
piecewise_linear_distribution(_InputIteratorB __f_b,
_InputIteratorB __l_b,
_InputIteratorW __f_w)
: __p_(__f_b, __l_b, __f_w) {}
#ifndef _LIBCPP_CXX03_LANG
template<class _UnaryOperation>
@ -219,8 +219,8 @@ piecewise_linear_distribution<_RealType>::param_type::param_type()
template<class _RealType>
template<class _InputIteratorB, class _InputIteratorW>
piecewise_linear_distribution<_RealType>::param_type::param_type(
_InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
: __b_(__fB, __lB)
_InputIteratorB __f_b, _InputIteratorB __l_b, _InputIteratorW __f_w)
: __b_(__f_b, __l_b)
{
if (__b_.size() < 2)
{
@ -233,8 +233,8 @@ piecewise_linear_distribution<_RealType>::param_type::param_type(
else
{
__densities_.reserve(__b_.size());
for (size_t __i = 0; __i < __b_.size(); ++__i, ++__fW)
__densities_.push_back(*__fW);
for (size_t __i = 0; __i < __b_.size(); ++__i, ++__f_w)
__densities_.push_back(*__f_w);
__init();
}
}

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

@ -488,10 +488,10 @@ struct __fn {
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()() const noexcept { return empty_view<tuple<>>{}; }
template <class... _Ranges>
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ranges&&... rs) const
noexcept(noexcept(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(rs)...)))
-> decltype(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(rs)...)) {
return zip_view<all_t<_Ranges>...>(std::forward<_Ranges>(rs)...);
_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Ranges&&... __rs) const
noexcept(noexcept(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(__rs)...)))
-> decltype(zip_view<all_t<_Ranges&&>...>(std::forward<_Ranges>(__rs)...)) {
return zip_view<all_t<_Ranges>...>(std::forward<_Ranges>(__rs)...);
}
};

54
libcxx/include/__support/win32/locale_win32.h
View File

@ -186,28 +186,28 @@ private:
// Locale management functions
#define freelocale _free_locale
// FIXME: base currently unused. Needs manual work to construct the new locale
locale_t newlocale( int mask, const char * locale, locale_t base );
locale_t newlocale( int __mask, const char * __locale, locale_t __base );
// uselocale can't be implemented on Windows because Windows allows partial modification
// of thread-local locale and so _get_current_locale() returns a copy while uselocale does
// not create any copies.
// We can still implement raii even without uselocale though.
lconv *localeconv_l( locale_t &loc );
size_t mbrlen_l( const char *__restrict s, size_t n,
mbstate_t *__restrict ps, locale_t loc);
size_t mbsrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
size_t len, mbstate_t *__restrict ps, locale_t loc );
size_t wcrtomb_l( char *__restrict s, wchar_t wc, mbstate_t *__restrict ps,
locale_t loc);
size_t mbrtowc_l( wchar_t *__restrict pwc, const char *__restrict s,
size_t n, mbstate_t *__restrict ps, locale_t loc);
size_t mbsnrtowcs_l( wchar_t *__restrict dst, const char **__restrict src,
size_t nms, size_t len, mbstate_t *__restrict ps, locale_t loc);
size_t wcsnrtombs_l( char *__restrict dst, const wchar_t **__restrict src,
size_t nwc, size_t len, mbstate_t *__restrict ps, locale_t loc);
wint_t btowc_l( int c, locale_t loc );
int wctob_l( wint_t c, locale_t loc );
lconv *localeconv_l( locale_t & __loc );
size_t mbrlen_l( const char *__restrict __s, size_t __n,
mbstate_t *__restrict __ps, locale_t __loc);
size_t mbsrtowcs_l( wchar_t *__restrict __dst, const char **__restrict __src,
size_t __len, mbstate_t *__restrict __ps, locale_t __loc );
size_t wcrtomb_l( char *__restrict __s, wchar_t __wc, mbstate_t *__restrict __ps,
locale_t __loc);
size_t mbrtowc_l( wchar_t *__restrict __pwc, const char *__restrict __s,
size_t __n, mbstate_t *__restrict __ps, locale_t __loc);
size_t mbsnrtowcs_l( wchar_t *__restrict __dst, const char **__restrict __src,
size_t __nms, size_t __len, mbstate_t *__restrict __ps, locale_t __loc);
size_t wcsnrtombs_l( char *__restrict __dst, const wchar_t **__restrict __src,
size_t __nwc, size_t __len, mbstate_t *__restrict __ps, locale_t __loc);
wint_t btowc_l( int __c, locale_t __loc );
int wctob_l( wint_t __c, locale_t __loc );
decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l );
@ -225,16 +225,16 @@ _LIBCPP_FUNC_VIS long double strtold_l(const char*, char**, locale_t);
#endif
inline _LIBCPP_INLINE_VISIBILITY
int
islower_l(int c, _locale_t loc)
islower_l(int __c, _locale_t __loc)
{
return _islower_l((int)c, loc);
return _islower_l((int)__c, __loc);
}
inline _LIBCPP_INLINE_VISIBILITY
int
isupper_l(int c, _locale_t loc)
isupper_l(int __c, _locale_t __loc)
{
return _isupper_l((int)c, loc);
return _isupper_l((int)__c, __loc);
}
#define isdigit_l _isdigit_l
@ -266,18 +266,18 @@ _LIBCPP_FUNC_VIS size_t strftime_l(char *ret, size_t n, const char *format,
#define sprintf_l( __s, __l, __f, ... ) _sprintf_l( __s, __f, __l, __VA_ARGS__ )
#define vsprintf_l( __s, __l, __f, ... ) _vsprintf_l( __s, __f, __l, __VA_ARGS__ )
#define vsnprintf_l( __s, __n, __l, __f, ... ) _vsnprintf_l( __s, __n, __f, __l, __VA_ARGS__ )
_LIBCPP_FUNC_VIS int snprintf_l(char *ret, size_t n, locale_t loc, const char *format, ...);
_LIBCPP_FUNC_VIS int asprintf_l( char **ret, locale_t loc, const char *format, ... );
_LIBCPP_FUNC_VIS int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap );
_LIBCPP_FUNC_VIS int snprintf_l(char *__ret, size_t __n, locale_t __loc, const char *__format, ...);
_LIBCPP_FUNC_VIS int asprintf_l( char **__ret, locale_t __loc, const char *__format, ... );
_LIBCPP_FUNC_VIS int vasprintf_l( char **__ret, locale_t __loc, const char *__format, va_list __ap );
// not-so-pressing FIXME: use locale to determine blank characters
inline int isblank_l( int c, locale_t /*loc*/ )
inline int isblank_l( int __c, locale_t /*loc*/ )
{
return ( c == ' ' || c == '\t' );
return ( __c == ' ' || __c == '\t' );
}
inline int iswblank_l( wint_t c, locale_t /*loc*/ )
inline int iswblank_l( wint_t __c, locale_t /*loc*/ )
{
return ( c == L' ' || c == L'\t' );
return ( __c == L' ' || __c == L'\t' );
}
#endif // _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H

22
libcxx/include/__threading_support
View File

@ -201,15 +201,15 @@ int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv);
// Execute once
_LIBCPP_THREAD_ABI_VISIBILITY
int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
void (*init_routine)());
int __libcpp_execute_once(__libcpp_exec_once_flag *__flag,
void (*__init_routine)());
// Thread id
_LIBCPP_THREAD_ABI_VISIBILITY
bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2);
bool __libcpp_thread_id_equal(__libcpp_thread_id __t1, __libcpp_thread_id __t2);
_LIBCPP_THREAD_ABI_VISIBILITY
bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2);
bool __libcpp_thread_id_less(__libcpp_thread_id __t1, __libcpp_thread_id __t2);
// Thread
_LIBCPP_THREAD_ABI_VISIBILITY
@ -347,22 +347,22 @@ int __libcpp_condvar_destroy(__libcpp_condvar_t *__cv)
}
// Execute once
int __libcpp_execute_once(__libcpp_exec_once_flag *flag,
void (*init_routine)()) {
return pthread_once(flag, init_routine);
int __libcpp_execute_once(__libcpp_exec_once_flag *__flag,
void (*__init_routine)()) {
return pthread_once(__flag, __init_routine);
}
// Thread id
// Returns non-zero if the thread ids are equal, otherwise 0
bool __libcpp_thread_id_equal(__libcpp_thread_id t1, __libcpp_thread_id t2)
bool __libcpp_thread_id_equal(__libcpp_thread_id __t1, __libcpp_thread_id __t2)
{
return t1 == t2;
return __t1 == __t2;
}
// Returns non-zero if t1 < t2, otherwise 0
bool __libcpp_thread_id_less(__libcpp_thread_id t1, __libcpp_thread_id t2)
bool __libcpp_thread_id_less(__libcpp_thread_id __t1, __libcpp_thread_id __t2)
{
return t1 < t2;
return __t1 < __t2;
}
// Thread

2
libcxx/include/any
View File

@ -271,7 +271,7 @@ public:
is_copy_constructible<_Tp>::value>
>
_LIBCPP_INLINE_VISIBILITY
_Tp& emplace(_Args&&... args);
_Tp& emplace(_Args&&...);
template <class _ValueType, class _Up, class ..._Args,
class _Tp = decay_t<_ValueType>,

8
libcxx/include/atomic
View File

@ -906,8 +906,8 @@ struct __cxx_atomic_base_impl {
#else
__cxx_atomic_base_impl() _NOEXCEPT : __a_value() {}
#endif // _LIBCPP_CXX03_LANG
_LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp value) _NOEXCEPT
: __a_value(value) {}
_LIBCPP_CONSTEXPR explicit __cxx_atomic_base_impl(_Tp __value) _NOEXCEPT
: __a_value(__value) {}
_LIBCPP_DISABLE_EXTENSION_WARNING _Atomic(_Tp) __a_value;
};
@ -1451,8 +1451,8 @@ struct __cxx_atomic_impl : public _Base {
"std::atomic<T> requires that 'T' be a trivially copyable type");
_LIBCPP_INLINE_VISIBILITY __cxx_atomic_impl() _NOEXCEPT = default;
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR explicit __cxx_atomic_impl(_Tp value) _NOEXCEPT
: _Base(value) {}
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR explicit __cxx_atomic_impl(_Tp __value) _NOEXCEPT
: _Base(__value) {}
};
#if defined(__linux__) || (defined(_AIX) && !defined(__64BIT__))

8
libcxx/include/barrier
View File

@ -130,10 +130,10 @@ public:
{
}
[[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
arrival_token arrive(ptrdiff_t update)
arrival_token arrive(ptrdiff_t __update)
{
auto const __old_phase = __phase_.load(memory_order_relaxed);
for(; update; --update)
for(; __update; --__update)
if(__arrive_barrier_algorithm_base(__base_.get(), __old_phase)) {
__completion_();
__expected_ += __expected_adjustment_.load(memory_order_relaxed);
@ -300,9 +300,9 @@ public:
barrier& operator=(barrier const&) = delete;
[[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
arrival_token arrive(ptrdiff_t update = 1)
arrival_token arrive(ptrdiff_t __update = 1)
{
return __b.arrive(update);
return __b.arrive(__update);
}
_LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
void wait(arrival_token&& __phase) const

26
libcxx/include/charconv
View File

@ -688,11 +688,11 @@ __from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
return __subject_seq_combinator(
__first, __last, __value,
[](const char* _First, const char* _Last,
[](const char* __f, const char* __l,
_Tp& __val) -> from_chars_result {
__output_type __a, __b;
auto __p = __tx::__read(_First, _Last, __a, __b);
if (__p == _Last || !__in_pattern(*__p))
auto __p = __tx::__read(__f, __l, __a, __b);
if (__p == __l || !__in_pattern(*__p))
{
__output_type __m = numeric_limits<_Tp>::max();
if (__m >= __a && __m - __a >= __b)
@ -724,22 +724,22 @@ __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
return __subject_seq_combinator(
__first, __last, __value,
[](const char* __p, const char* __lastp, _Tp& __val,
int _Base) -> from_chars_result {
int __b) -> from_chars_result {
using __tl = numeric_limits<_Tp>;
auto __digits = __tl::digits / log2f(float(_Base));
_Tp __a = __in_pattern(*__p++, _Base).__val, __b = 0;
auto __digits = __tl::digits / log2f(float(__b));
_Tp __x = __in_pattern(*__p++, __b).__val, __y = 0;
for (int __i = 1; __p != __lastp; ++__i, ++__p)
{
if (auto __c = __in_pattern(*__p, _Base))
if (auto __c = __in_pattern(*__p, __b))
{
if (__i < __digits - 1)
__a = __a * _Base + __c.__val;
__x = __x * __b + __c.__val;
else
{
if (!__itoa::__mul_overflowed(__a, _Base, __a))
if (!__itoa::__mul_overflowed(__x, __b, __x))
++__p;
__b = __c.__val;
__y = __c.__val;
break;
}
}
@ -747,11 +747,11 @@ __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
break;
}
if (__p == __lastp || !__in_pattern(*__p, _Base))
if (__p == __lastp || !__in_pattern(*__p, __b))
{
if (__tl::max() - __a >= __b)
if (__tl::max() - __x >= __y)
{
__val = __a + __b;
__val = __x + __y;
return {__p, {}};
}
}

6
libcxx/include/cmath
View File

@ -530,9 +530,9 @@ using ::tgammal _LIBCPP_USING_IF_EXISTS;
using ::truncl _LIBCPP_USING_IF_EXISTS;
#if _LIBCPP_STD_VER > 14
inline _LIBCPP_INLINE_VISIBILITY float hypot( float x, float y, float z ) { return sqrt(x*x + y*y + z*z); }
inline _LIBCPP_INLINE_VISIBILITY double hypot( double x, double y, double z ) { return sqrt(x*x + y*y + z*z); }
inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double x, long double y, long double z ) { return sqrt(x*x + y*y + z*z); }
inline _LIBCPP_INLINE_VISIBILITY float hypot( float __x, float __y, float __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
inline _LIBCPP_INLINE_VISIBILITY double hypot( double __x, double __y, double __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double __x, long double __y, long double __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
template <class _A1, class _A2, class _A3>
inline _LIBCPP_INLINE_VISIBILITY

96
libcxx/include/codecvt
View File

@ -92,10 +92,10 @@ public:
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
_LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode)
: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {}
explicit __codecvt_utf8(size_t __refs, unsigned long __maxcode,
codecvt_mode __mode)
: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
_Mode_(__mode) {}
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:
virtual result
@ -130,10 +130,10 @@ public:
typedef mbstate_t state_type;
_LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode)
: codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {}
explicit __codecvt_utf8(size_t __refs, unsigned long __maxcode,
codecvt_mode __mode)
: codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
_Mode_(__mode) {}
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:
@ -168,10 +168,10 @@ public:
typedef mbstate_t state_type;
_LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode)
: codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {}
explicit __codecvt_utf8(size_t __refs, unsigned long __maxcode,
codecvt_mode __mode)
: codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
_Mode_(__mode) {}
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:
@ -229,10 +229,10 @@ public:
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
_LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode)
: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {}
explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
codecvt_mode __mode)
: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
_Mode_(__mode) {}
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:
virtual result
@ -268,10 +268,10 @@ public:
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
_LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode)
: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {}
explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
codecvt_mode __mode)
: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
_Mode_(__mode) {}
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:
virtual result
@ -306,10 +306,10 @@ public:
typedef mbstate_t state_type;
_LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode)
: codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {}
explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
codecvt_mode __mode)
: codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
_Mode_(__mode) {}
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:
@ -344,10 +344,10 @@ public:
typedef mbstate_t state_type;
_LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode)
: codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {}
explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
codecvt_mode __mode)
: codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
_Mode_(__mode) {}
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:
@ -382,10 +382,10 @@ public:
typedef mbstate_t state_type;
_LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode)
: codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {}
explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
codecvt_mode __mode)
: codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
_Mode_(__mode) {}
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:
@ -420,10 +420,10 @@ public:
typedef mbstate_t state_type;
_LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode)
: codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {}
explicit __codecvt_utf16(size_t __refs, unsigned long __maxcode,
codecvt_mode __mode)
: codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
_Mode_(__mode) {}
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:
@ -481,10 +481,10 @@ public:
_LIBCPP_SUPPRESS_DEPRECATED_PUSH
_LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode)
: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {}
explicit __codecvt_utf8_utf16(size_t __refs, unsigned long __maxcode,
codecvt_mode __mode)
: codecvt<wchar_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
_Mode_(__mode) {}
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:
virtual result
@ -519,10 +519,10 @@ public:
typedef mbstate_t state_type;
_LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode)
: codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {}
explicit __codecvt_utf8_utf16(size_t __refs, unsigned long __maxcode,
codecvt_mode __mode)
: codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
_Mode_(__mode) {}
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:
@ -557,10 +557,10 @@ public:
typedef mbstate_t state_type;
_LIBCPP_INLINE_VISIBILITY
explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
codecvt_mode _Mode)
: codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
_Mode_(_Mode) {}
explicit __codecvt_utf8_utf16(size_t __refs, unsigned long __maxcode,
codecvt_mode __mode)
: codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(__maxcode),
_Mode_(__mode) {}
_LIBCPP_SUPPRESS_DEPRECATED_POP
protected:

2
libcxx/include/condition_variable
View File

@ -261,7 +261,7 @@ condition_variable_any::wait_for(_Lock& __lock,
}
_LIBCPP_FUNC_VIS
void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
void notify_all_at_thread_exit(condition_variable&, unique_lock<mutex>);
_LIBCPP_END_NAMESPACE_STD

2
libcxx/include/exception
View File

@ -216,7 +216,7 @@ _LIBCPP_FUNC_VIS void swap(exception_ptr&, exception_ptr&) _NOEXCEPT;
_LIBCPP_FUNC_VIS exception_ptr __copy_exception_ptr(void *__except, const void* __ptr);
_LIBCPP_FUNC_VIS exception_ptr current_exception() _NOEXCEPT;
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr p);
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS void rethrow_exception(exception_ptr);
// This is a built-in template function which automagically extracts the required
// information.

12
libcxx/include/experimental/simd
View File

@ -1242,32 +1242,32 @@ _Tp reduce(const simd<_Tp, _Abi>&, _BinaryOp = _BinaryOp());
template <class _MaskType, class _SimdType, class _BinaryOp>
typename _SimdType::value_type
reduce(const const_where_expression<_MaskType, _SimdType>&,
typename _SimdType::value_type neutral_element, _BinaryOp binary_op);
typename _SimdType::value_type __neutral_element, _BinaryOp);
template <class _MaskType, class _SimdType>
typename _SimdType::value_type
reduce(const const_where_expression<_MaskType, _SimdType>&,
plus<typename _SimdType::value_type> binary_op = {});
plus<typename _SimdType::value_type> = {});
template <class _MaskType, class _SimdType>
typename _SimdType::value_type
reduce(const const_where_expression<_MaskType, _SimdType>&,
multiplies<typename _SimdType::value_type> binary_op);
multiplies<typename _SimdType::value_type>);
template <class _MaskType, class _SimdType>
typename _SimdType::value_type
reduce(const const_where_expression<_MaskType, _SimdType>&,
bit_and<typename _SimdType::value_type> binary_op);
bit_and<typename _SimdType::value_type>);
template <class _MaskType, class _SimdType>
typename _SimdType::value_type
reduce(const const_where_expression<_MaskType, _SimdType>&,
bit_or<typename _SimdType::value_type> binary_op);
bit_or<typename _SimdType::value_type>);
template <class _MaskType, class _SimdType>
typename _SimdType::value_type
reduce(const const_where_expression<_MaskType, _SimdType>&,
bit_xor<typename _SimdType::value_type> binary_op);
bit_xor<typename _SimdType::value_type>);
template <class _Tp, class _Abi>
_Tp hmin(const simd<_Tp, _Abi>&);

8
libcxx/include/future
View File

@ -525,12 +525,12 @@ _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY
#ifndef _LIBCPP_NO_EXCEPTIONS
_LIBCPP_AVAILABILITY_FUTURE_ERROR
#endif
void __throw_future_error(future_errc _Ev)
void __throw_future_error(future_errc __ev)
{
#ifndef _LIBCPP_NO_EXCEPTIONS
throw future_error(make_error_code(_Ev));
throw future_error(make_error_code(__ev));
#else
((void)_Ev);
((void)__ev);
_VSTD::abort();
#endif
}
@ -1106,7 +1106,7 @@ future<_Rp>::future(__assoc_state<_Rp>* __state)
struct __release_shared_count
{
void operator()(__shared_count* p) {p->__release_shared();}
void operator()(__shared_count* __p) {__p->__release_shared();}
};
template <class _Rp>

12
libcxx/include/map
View File

@ -582,9 +582,9 @@ public:
_NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
: _Compare() {}
_LIBCPP_INLINE_VISIBILITY
__map_value_compare(_Compare c)
__map_value_compare(_Compare __c)
_NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
: _Compare(c) {}
: _Compare(__c) {}
_LIBCPP_INLINE_VISIBILITY
const _Compare& key_comp() const _NOEXCEPT {return *this;}
_LIBCPP_INLINE_VISIBILITY
@ -627,9 +627,9 @@ public:
_NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
: comp() {}
_LIBCPP_INLINE_VISIBILITY
__map_value_compare(_Compare c)
__map_value_compare(_Compare __c)
_NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
: comp(c) {}
: comp(__c) {}
_LIBCPP_INLINE_VISIBILITY
const _Compare& key_comp() const _NOEXCEPT {return comp;}
@ -990,7 +990,7 @@ public:
protected:
key_compare comp;
_LIBCPP_INLINE_VISIBILITY value_compare(key_compare c) : comp(c) {}
_LIBCPP_INLINE_VISIBILITY value_compare(key_compare __c) : comp(__c) {}
public:
_LIBCPP_INLINE_VISIBILITY
bool operator()(const value_type& __x, const value_type& __y) const
@ -1767,7 +1767,7 @@ public:
key_compare comp;
_LIBCPP_INLINE_VISIBILITY
value_compare(key_compare c) : comp(c) {}
value_compare(key_compare __c) : comp(__c) {}
public:
_LIBCPP_INLINE_VISIBILITY
bool operator()(const value_type& __x, const value_type& __y) const

4
libcxx/include/memory
View File

@ -1096,8 +1096,8 @@ struct __builtin_new_allocator {
_LIBCPP_CONSTEXPR explicit __builtin_new_deleter(size_t __size, size_t __align)
: __size_(__size), __align_(__align) {}
void operator()(void* p) const _NOEXCEPT {
_VSTD::__libcpp_deallocate(p, __size_, __align_);
void operator()(void* __p) const _NOEXCEPT {
_VSTD::__libcpp_deallocate(__p, __size_, __align_);
}
private:

22
libcxx/include/regex
View File

@ -1330,9 +1330,9 @@ regex_traits<_CharT>::isctype(char_type __c, char_class_type __m) const
}
inline _LIBCPP_INLINE_VISIBILITY
bool __is_07(unsigned char c)
bool __is_07(unsigned char __c)
{
return (c & 0xF8u) ==
return (__c & 0xF8u) ==
#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
0xF0;
#else
@ -1341,9 +1341,9 @@ bool __is_07(unsigned char c)
}
inline _LIBCPP_INLINE_VISIBILITY
bool __is_89(unsigned char c)
bool __is_89(unsigned char __c)
{
return (c & 0xFEu) ==
return (__c & 0xFEu) ==
#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
0xF8;
#else
@ -1352,12 +1352,12 @@ bool __is_89(unsigned char c)
}
inline _LIBCPP_INLINE_VISIBILITY
unsigned char __to_lower(unsigned char c)
unsigned char __to_lower(unsigned char __c)
{
#if defined(__MVS__) && !defined(__NATIVE_ASCII_F)
return c & 0xBF;
#else
return c | 0x20;
return __c | 0x20;
#endif
}
@ -2057,9 +2057,9 @@ __word_boundary<_CharT, _Traits>::__exec(__state& __s) const
template <class _CharT>
_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
bool __is_eol(_CharT c)
bool __is_eol(_CharT __c)
{
return c == '\r' || c == '\n';
return __c == '\r' || __c == '\n';
}
template <class _CharT>
@ -2963,7 +2963,7 @@ private:
__parse_awk_escape(_ForwardIterator __first, _ForwardIterator __last,
basic_string<_CharT>* __str = nullptr);
bool __test_back_ref(_CharT c);
bool __test_back_ref(_CharT);
_LIBCPP_INLINE_VISIBILITY
void __push_l_anchor();
@ -4782,9 +4782,9 @@ basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
template <class _CharT, class _Traits>
bool
basic_regex<_CharT, _Traits>::__test_back_ref(_CharT c)
basic_regex<_CharT, _Traits>::__test_back_ref(_CharT __c)
{
unsigned __val = __traits_.value(c, 10);
unsigned __val = __traits_.value(__c, 10);
if (__val >= 1 && __val <= 9)
{
if (__val > mark_count())

18
libcxx/include/scoped_allocator
View File

@ -219,10 +219,10 @@ protected:
is_constructible<outer_allocator_type, _OuterA2>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(_OuterA2&& __outerAlloc,
const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
: outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)),
__inner_(__innerAllocs...) {}
__scoped_allocator_storage(_OuterA2&& __outer_alloc,
const _InnerAllocs& ...__inner_allocs) _NOEXCEPT
: outer_allocator_type(_VSTD::forward<_OuterA2>(__outer_alloc)),
__inner_(__inner_allocs...) {}
template <class _OuterA2,
class = typename enable_if<
@ -300,8 +300,8 @@ protected:
is_constructible<outer_allocator_type, _OuterA2>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
__scoped_allocator_storage(_OuterA2&& __outerAlloc) _NOEXCEPT
: outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)) {}
__scoped_allocator_storage(_OuterA2&& __outer_alloc) _NOEXCEPT
: outer_allocator_type(_VSTD::forward<_OuterA2>(__outer_alloc)) {}
template <class _OuterA2,
class = typename enable_if<
@ -444,9 +444,9 @@ public:
is_constructible<outer_allocator_type, _OuterA2>::value
>::type>
_LIBCPP_INLINE_VISIBILITY
scoped_allocator_adaptor(_OuterA2&& __outerAlloc,
const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
: base(_VSTD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
scoped_allocator_adaptor(_OuterA2&& __outer_alloc,
const _InnerAllocs& ...__inner_allocs) _NOEXCEPT
: base(_VSTD::forward<_OuterA2>(__outer_alloc), __inner_allocs...) {}
// scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default;
template <class _OuterA2,
class = typename enable_if<

4
libcxx/include/shared_mutex
View File

@ -400,9 +400,9 @@ public:
void lock();
bool try_lock();
template <class Rep, class Period>
bool try_lock_for(const chrono::duration<Rep, Period>& rel_time);
bool try_lock_for(const chrono::duration<Rep, Period>& __rel_time);
template <class Clock, class Duration>
bool try_lock_until(const chrono::time_point<Clock, Duration>& abs_time);
bool try_lock_until(const chrono::time_point<Clock, Duration>& __abs_time);
void unlock();
// Setters

4
libcxx/include/string_view
View File

@ -324,8 +324,8 @@ public:
ranges::sized_range<_Range> &&
is_same_v<ranges::range_value_t<_Range>, _CharT> &&
!is_convertible_v<_Range, const _CharT*> &&
(!requires(remove_cvref_t<_Range>& d) {
d.operator _VSTD::basic_string_view<_CharT, _Traits>();
(!requires(remove_cvref_t<_Range>& __d) {
__d.operator _VSTD::basic_string_view<_CharT, _Traits>();
}) &&
(!requires {
typename remove_reference_t<_Range>::traits_type;

4
libcxx/include/system_error
View File

@ -236,7 +236,7 @@ class _LIBCPP_HIDDEN __do_message
: public error_category
{
public:
virtual string message(int ev) const;
virtual string message(int __ev) const;
};
_LIBCPP_FUNC_VIS const error_category& generic_category() _NOEXCEPT;
@ -482,7 +482,7 @@ private:
};
_LIBCPP_NORETURN _LIBCPP_FUNC_VIS
void __throw_system_error(int ev, const char* what_arg);
void __throw_system_error(int __ev, const char* __what_arg);
_LIBCPP_END_NAMESPACE_STD

4
libcxx/include/variant
View File

@ -777,8 +777,8 @@ public:
using __index_t = __variant_index_t<sizeof...(_Types)>;
inline _LIBCPP_INLINE_VISIBILITY
explicit constexpr __base(__valueless_t tag) noexcept
: __data(tag), __index(__variant_npos<__index_t>) {}
explicit constexpr __base(__valueless_t __tag) noexcept
: __data(__tag), __index(__variant_npos<__index_t>) {}
template <size_t _Ip, class... _Args>
inline _LIBCPP_INLINE_VISIBILITY

4
libcxx/include/vector
View File

@ -2184,8 +2184,8 @@ public:
#if _LIBCPP_STD_VER > 11
template <class... _Args>
_LIBCPP_INLINE_VISIBILITY iterator emplace(const_iterator position, _Args&&... __args)
{ return insert ( position, value_type ( _VSTD::forward<_Args>(__args)... )); }
_LIBCPP_INLINE_VISIBILITY iterator emplace(const_iterator __position, _Args&&... __args)
{ return insert ( __position, value_type ( _VSTD::forward<_Args>(__args)... )); }
#endif
iterator insert(const_iterator __position, const value_type& __x);

8
libcxx/include/wchar.h
View File

@ -176,10 +176,10 @@ inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
#if defined(__cplusplus) && (defined(_LIBCPP_MSVCRT_LIKE) || defined(__MVS__))
extern "C" {
size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src,
size_t nmc, size_t len, mbstate_t *__restrict ps);
size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src,
size_t nwc, size_t len, mbstate_t *__restrict ps);
size_t mbsnrtowcs(wchar_t *__restrict __dst, const char **__restrict __src,
size_t __nmc, size_t __len, mbstate_t *__restrict __ps);
size_t wcsnrtombs(char *__restrict __dst, const wchar_t **__restrict __src,
size_t __nwc, size_t __len, mbstate_t *__restrict __ps);
} // extern "C"
#endif // __cplusplus && (_LIBCPP_MSVCRT || __MVS__)