modernize-redundant-void-arg,
readability-duplicate-include,
+ readability-identifier-naming,
readability-function-cognitive-complexity,
readability-function-size,
readability-misplaced-array-index,
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,
_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>());
}
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;
}
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);
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;
_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)
);
}
}
_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>());
}
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
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
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;
}
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>());
}
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));
}
};
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;
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;
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;
while (true) {
if (__first == __last) // return __last if no element matches __value_
return __last;
- if (__pred(*__first, __value_))
+ if (__pred(*__first, __value))
break;
++__first;
}
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;
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)
while (true) {
if (__first >= __s) // return __last if no element matches __value_
return __last;
- if (__pred(*__first, __value_))
+ if (__pred(*__first, __value))
break;
++__first;
}
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;
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
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);
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
{
_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>());
}
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));
}
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));
}
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);
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
_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
// 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
: 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; }
};
_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
};
_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
_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);
_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); }
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; }
};
_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
};
_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
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':
case 'f':
return 'F';
}
- return c;
+ return __c;
}
struct _LIBCPP_TYPE_VIS __padding_size_result {
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);
__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. */
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:
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;}
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;}
_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;}
: __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;
#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);
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
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);
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>
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)
{
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();
}
}
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);
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>
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)
{
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();
}
}
_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)...);
}
};
// 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 );
#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
#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
// 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
}
// 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
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>,
#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;
};
"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__))
{
}
[[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);
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
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)
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;
}
}
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, {}};
}
}
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
_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
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:
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:
_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
_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
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:
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:
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:
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:
_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
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:
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:
}
_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
_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.
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>&);
#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
}
struct __release_shared_count
{
- void operator()(__shared_count* p) {p->__release_shared();}
+ void operator()(__shared_count* __p) {__p->__release_shared();}
};
template <class _Rp>
_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
_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;}
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
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
_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:
}
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
}
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
}
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
}
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>
__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();
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())
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<
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<
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<
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
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;
: 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;
};
_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
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
#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);
#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__)
projects / platform / upstream / llvm.git / commitdiff