[PATCH] libstdc++: Avoid Microsoft SAL 1.0 annotation names
Zephyr Lykos
git@mochaa.ws
Mon Jun 1 18:58:21 GMT 2026
These are legacy names for The Microsoft source-code annotation
language, like their newer counterparts _In_, _Out_, etc.
MinGW avoids the conflict with libstdc++ names by prefixing "SAL" in
their no-op macros, leading some legacy codebases porting from MSVC
toolchain, namely the .NET runtime, to define their own no-op macros,
conflicting with libstdc++.
LLVM libc++ also checks this in their testsuite.
libstdc++-v3/ChangeLog:
* include/bits/atomic_base.h: Rename __success to __success_.
* include/bits/shared_ptr_atomic.h: Likewise.
* include/experimental/bits/shared_ptr.h: Likewise.
* include/std/stop_token: Likewise.
* include/bits/basic_ios.h: Rename __except to __except_.
* include/bits/basic_string.h: Rename __in to __in_.
* include/bits/basic_string.tcc: Likewise.
* include/bits/istream.tcc: Likewise.
* include/bits/locale_facets.h: Likewise.
* include/bits/stl_pair.h: Likewise.
* include/experimental/bits/simd.h: Likewise.
* include/ext/vstring.tcc: Likewise.
* include/std/istream: Likewise.
* include/std/tuple: Likewise.
* include/tr1/tuple: Likewise.
* include/tr1/utility: Likewise.
* include/tr2/bool_set.tcc: Likewise.
* scripts/gen_includers.pl: Likewise.
* src/c++98/istream-string.cc: Likewise.
* src/c++98/istream.cc: Likewise.
* testsuite/performance/27_io/ifstream_extract_chars.cc: Likewise.
* testsuite/performance/27_io/ifstream_getline-2.cc: Likewise.
* include/bits/chrono_io.h: Rename __out to __out_.
* include/bits/locale_conv.h: Likewise.
* include/bits/ostream.h: Likewise.
* include/bits/ostream.tcc: Likewise.
* include/bits/ostream_insert.h: Likewise.
* include/bits/ostream_print.h: Likewise.
* include/bits/print.h: Likewise.
* include/bits/ranges_algo.h: Likewise.
* include/bits/regex.h: Likewise.
* include/bits/std_thread.h: Likewise.
* include/bits/stl_algo.h: Likewise.
* include/bits/stl_uninitialized.h: Likewise.
* include/experimental/algorithm: Likewise.
* include/experimental/internet: Likewise.
* include/ext/algorithm: Likewise.
* include/ext/pb_ds/detail/debug_map_base.hpp: Likewise.
* include/parallel/algo.h: Likewise.
* include/parallel/multiway_merge.h: Likewise.
* include/parallel/set_operations.h: Likewise.
* include/parallel/unique_copy.h: Likewise.
* include/std/thread: Likewise.
* include/tr1/regex: Likewise.
* src/c++11/snprintf_lite.cc: Likewise.
* include/bits/parse_numbers.h: Rename __valid to __valid_.
* include/bits/random.tcc: Rename __range to __range_.
Rename __out to __out_.
* include/bits/ranges_algobase.h: Rename __in to __in_.
Rename __out to __out_.
* include/bits/ranges_uninitialized.h: Likewise.
* include/bits/stl_algobase.h: Likewise.
* include/ext/random.tcc: Likewise.
* include/std/inplace_vector: Likewise.
* include/tr2/bool_set: Likewise.
* include/bits/ranges_base.h: Rename __bound to __bound_.
* include/parallel/for_each.h: Likewise.
* include/parallel/omp_loop.h: Likewise.
* include/parallel/omp_loop_static.h: Likewise.
* include/parallel/par_loop.h: Likewise.
* include/parallel/random_shuffle.h: Likewise.
* include/parallel/workstealing.h: Likewise.
* include/bits/regex.tcc: Rename __pre to __pre_.
Rename __out to __out_.
* include/bits/simd_details.h: Rename __in to __in_.
* include/bits/simd_vec.h: Rename __range to __range_.
* include/bits/uniform_int_dist.h: Likewise.
* include/pstl/parallel_backend_tbb.h: Likewise.
* include/std/span: Likewise.
* include/bits/unicode.h: Rename __gc to __gc_.
* include/experimental/scope: Rename __noop to __noop_.
* include/std/charconv: Rename __valid to __valid_.
* include/std/format: Rename __in to __in_.
Rename __out to __out_.
Rename __reserved to __reserved_.
* include/std/ranges: Rename __box to __box_.
Rename __bound to __bound_.
Rename __inner_range to __inner_range_.
* testsuite/std/ranges/adaptors/detail/copyable_box.cc: Rename
__box to __box_.
* testsuite/17_intro/names.cc: Add checks for SAL 1.0 names.
Signed-off-by: Zephyr Lykos <self@mochaa.ws>
---
libstdc++-v3/include/bits/atomic_base.h | 32 +-
libstdc++-v3/include/bits/basic_ios.h | 6 +-
libstdc++-v3/include/bits/basic_string.h | 4 +-
libstdc++-v3/include/bits/basic_string.tcc | 40 +--
libstdc++-v3/include/bits/chrono_io.h | 278 +++++++-------
libstdc++-v3/include/bits/istream.tcc | 70 ++--
libstdc++-v3/include/bits/locale_conv.h | 20 +-
libstdc++-v3/include/bits/locale_facets.h | 52 +--
libstdc++-v3/include/bits/ostream.h | 66 ++--
libstdc++-v3/include/bits/ostream.tcc | 14 +-
libstdc++-v3/include/bits/ostream_insert.h | 42 +--
libstdc++-v3/include/bits/ostream_print.h | 10 +-
libstdc++-v3/include/bits/parse_numbers.h | 14 +-
libstdc++-v3/include/bits/print.h | 10 +-
libstdc++-v3/include/bits/random.tcc | 26 +-
libstdc++-v3/include/bits/ranges_algo.h | 32 +-
libstdc++-v3/include/bits/ranges_algobase.h | 38 +-
libstdc++-v3/include/bits/ranges_base.h | 34 +-
.../include/bits/ranges_uninitialized.h | 8 +-
libstdc++-v3/include/bits/regex.h | 24 +-
libstdc++-v3/include/bits/regex.tcc | 54 +--
libstdc++-v3/include/bits/shared_ptr_atomic.h | 8 +-
libstdc++-v3/include/bits/simd_details.h | 6 +-
libstdc++-v3/include/bits/simd_vec.h | 12 +-
libstdc++-v3/include/bits/std_thread.h | 2 +-
libstdc++-v3/include/bits/stl_algo.h | 24 +-
libstdc++-v3/include/bits/stl_algobase.h | 6 +-
libstdc++-v3/include/bits/stl_pair.h | 24 +-
libstdc++-v3/include/bits/stl_uninitialized.h | 6 +-
libstdc++-v3/include/bits/unicode.h | 12 +-
libstdc++-v3/include/bits/uniform_int_dist.h | 12 +-
libstdc++-v3/include/experimental/algorithm | 8 +-
.../include/experimental/bits/shared_ptr.h | 8 +-
libstdc++-v3/include/experimental/bits/simd.h | 12 +-
libstdc++-v3/include/experimental/internet | 38 +-
libstdc++-v3/include/experimental/scope | 6 +-
libstdc++-v3/include/ext/algorithm | 32 +-
.../ext/pb_ds/detail/debug_map_base.hpp | 4 +-
libstdc++-v3/include/ext/random.tcc | 36 +-
libstdc++-v3/include/ext/vstring.tcc | 40 +--
libstdc++-v3/include/parallel/algo.h | 110 +++---
libstdc++-v3/include/parallel/for_each.h | 12 +-
.../include/parallel/multiway_merge.h | 4 +-
libstdc++-v3/include/parallel/omp_loop.h | 4 +-
.../include/parallel/omp_loop_static.h | 4 +-
libstdc++-v3/include/parallel/par_loop.h | 4 +-
.../include/parallel/random_shuffle.h | 2 +-
.../include/parallel/set_operations.h | 32 +-
libstdc++-v3/include/parallel/unique_copy.h | 6 +-
libstdc++-v3/include/parallel/workstealing.h | 6 +-
.../include/pstl/parallel_backend_tbb.h | 40 +--
libstdc++-v3/include/std/charconv | 12 +-
libstdc++-v3/include/std/format | 272 +++++++-------
libstdc++-v3/include/std/inplace_vector | 22 +-
libstdc++-v3/include/std/istream | 58 +--
libstdc++-v3/include/std/ranges | 94 ++---
libstdc++-v3/include/std/span | 8 +-
libstdc++-v3/include/std/stop_token | 4 +-
libstdc++-v3/include/std/thread | 6 +-
libstdc++-v3/include/std/tuple | 340 +++++++++---------
libstdc++-v3/include/tr1/regex | 4 +-
libstdc++-v3/include/tr1/tuple | 64 ++--
libstdc++-v3/include/tr1/utility | 8 +-
libstdc++-v3/include/tr2/bool_set | 8 +-
libstdc++-v3/include/tr2/bool_set.tcc | 4 +-
libstdc++-v3/scripts/gen_includers.pl | 8 +-
libstdc++-v3/src/c++11/snprintf_lite.cc | 6 +-
libstdc++-v3/src/c++98/istream-string.cc | 48 +--
libstdc++-v3/src/c++98/istream.cc | 18 +-
libstdc++-v3/testsuite/17_intro/names.cc | 15 +
.../27_io/ifstream_extract_chars.cc | 4 +-
.../performance/27_io/ifstream_getline-2.cc | 2 +-
.../ranges/adaptors/detail/copyable_box.cc | 52 +--
73 files changed, 1233 insertions(+), 1218 deletions(-)
diff --git a/libstdc++-v3/include/bits/atomic_base.h b/libstdc++-v3/include/bits/atomic_base.h
index 3a8e9a7b4c1..7541df752f2 100644
--- a/libstdc++-v3/include/bits/atomic_base.h
+++ b/libstdc++-v3/include/bits/atomic_base.h
@@ -1186,21 +1186,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<bool _AtomicRef = false, typename _Tp>
_GLIBCXX_ALWAYS_INLINE bool
compare_exchange_weak(_Tp* __ptr, _Val<_Tp>& __expected,
- _Val<_Tp> __desired, memory_order __success,
+ _Val<_Tp> __desired, memory_order __success_,
memory_order __failure) noexcept
{
return __atomic_impl::__compare_exchange<_AtomicRef>(
- *__ptr, __expected, __desired, true, __success, __failure);
+ *__ptr, __expected, __desired, true, __success_, __failure);
}
template<bool _AtomicRef = false, typename _Tp>
_GLIBCXX_ALWAYS_INLINE bool
compare_exchange_strong(_Tp* __ptr, _Val<_Tp>& __expected,
- _Val<_Tp> __desired, memory_order __success,
+ _Val<_Tp> __desired, memory_order __success_,
memory_order __failure) noexcept
{
return __atomic_impl::__compare_exchange<_AtomicRef>(
- *__ptr, __expected, __desired, false, __success, __failure);
+ *__ptr, __expected, __desired, false, __success_, __failure);
}
#if __glibcxx_atomic_wait
@@ -1491,42 +1491,42 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
compare_exchange_weak(_Fp& __expected, _Fp __desired,
- memory_order __success,
+ memory_order __success_,
memory_order __failure) noexcept
{
return __atomic_impl::compare_exchange_weak(&_M_fp,
__expected, __desired,
- __success, __failure);
+ __success_, __failure);
}
bool
compare_exchange_weak(_Fp& __expected, _Fp __desired,
- memory_order __success,
+ memory_order __success_,
memory_order __failure) volatile noexcept
{
return __atomic_impl::compare_exchange_weak(&_M_fp,
__expected, __desired,
- __success, __failure);
+ __success_, __failure);
}
bool
compare_exchange_strong(_Fp& __expected, _Fp __desired,
- memory_order __success,
+ memory_order __success_,
memory_order __failure) noexcept
{
return __atomic_impl::compare_exchange_strong(&_M_fp,
__expected, __desired,
- __success, __failure);
+ __success_, __failure);
}
bool
compare_exchange_strong(_Fp& __expected, _Fp __desired,
- memory_order __success,
+ memory_order __success_,
memory_order __failure) volatile noexcept
{
return __atomic_impl::compare_exchange_strong(&_M_fp,
__expected, __desired,
- __success, __failure);
+ __success_, __failure);
}
bool
@@ -1773,20 +1773,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
compare_exchange_weak(value_type& __expected, value_type __desired,
- memory_order __success,
+ memory_order __success_,
memory_order __failure) const noexcept
{
return __atomic_impl::compare_exchange_weak<true>(
- this->_M_ptr, __expected, __desired, __success, __failure);
+ this->_M_ptr, __expected, __desired, __success_, __failure);
}
bool
compare_exchange_strong(value_type& __expected, value_type __desired,
- memory_order __success,
+ memory_order __success_,
memory_order __failure) const noexcept
{
return __atomic_impl::compare_exchange_strong<true>(
- this->_M_ptr, __expected, __desired, __success, __failure);
+ this->_M_ptr, __expected, __desired, __success_, __failure);
}
bool
diff --git a/libstdc++-v3/include/bits/basic_ios.h b/libstdc++-v3/include/bits/basic_ios.h
index 8bc719393bf..ff8bfb19492 100644
--- a/libstdc++-v3/include/bits/basic_ios.h
+++ b/libstdc++-v3/include/bits/basic_ios.h
@@ -239,7 +239,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* @brief Throwing exceptions on errors.
- * @param __except The new exceptions mask.
+ * @param __except_ The new exceptions mask.
*
* By default, error flags are set silently. You can set an
* exceptions mask for each stream; if a bit in the mask becomes set
@@ -269,9 +269,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* @endcode
*/
void
- exceptions(iostate __except)
+ exceptions(iostate __except_)
{
- _M_exception = __except;
+ _M_exception = __except_;
this->clear(_M_streambuf_state);
}
diff --git a/libstdc++-v3/include/bits/basic_string.h b/libstdc++-v3/include/bits/basic_string.h
index 23e6979f03d..b6fead3097b 100644
--- a/libstdc++-v3/include/bits/basic_string.h
+++ b/libstdc++-v3/include/bits/basic_string.h
@@ -4511,13 +4511,13 @@ _GLIBCXX_END_NAMESPACE_CXX11
template<>
basic_istream<char>&
- getline(basic_istream<char>& __in, basic_string<char>& __str,
+ getline(basic_istream<char>& __in_, basic_string<char>& __str,
char __delim);
#ifdef _GLIBCXX_USE_WCHAR_T
template<>
basic_istream<wchar_t>&
- getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
+ getline(basic_istream<wchar_t>& __in_, basic_string<wchar_t>& __str,
wchar_t __delim);
#endif
diff --git a/libstdc++-v3/include/bits/basic_string.tcc b/libstdc++-v3/include/bits/basic_string.tcc
index 64c99fbb9d6..fbd6ca50a10 100644
--- a/libstdc++-v3/include/bits/basic_string.tcc
+++ b/libstdc++-v3/include/bits/basic_string.tcc
@@ -907,7 +907,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// 21.3.7.9 basic_string::getline and operators
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __in,
+ operator>>(basic_istream<_CharT, _Traits>& __in_,
basic_string<_CharT, _Traits, _Alloc>& __str)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
@@ -920,7 +920,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__size_type __extracted = 0;
typename __ios_base::iostate __err = __ios_base::goodbit;
- typename __istream_type::sentry __cerb(__in, false);
+ typename __istream_type::sentry __cerb(__in_, false);
if (__cerb)
{
__try
@@ -929,12 +929,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__str.erase();
_CharT __buf[128];
__size_type __len = 0;
- const streamsize __w = __in.width();
+ const streamsize __w = __in_.width();
const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
: __str.max_size();
- const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+ const __ctype_type& __ct = use_facet<__ctype_type>(__in_.getloc());
const __int_type __eof = _Traits::eof();
- __int_type __c = __in.rdbuf()->sgetc();
+ __int_type __c = __in_.rdbuf()->sgetc();
while (__extracted < __n
&& !_Traits::eq_int_type(__c, __eof)
@@ -948,17 +948,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
__buf[__len++] = _Traits::to_char_type(__c);
++__extracted;
- __c = __in.rdbuf()->snextc();
+ __c = __in_.rdbuf()->snextc();
}
__str.append(__buf, __len);
if (__extracted < __n && _Traits::eq_int_type(__c, __eof))
__err |= __ios_base::eofbit;
- __in.width(0);
+ __in_.width(0);
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __in._M_setstate(__ios_base::badbit);
+ __in_._M_setstate(__ios_base::badbit);
__throw_exception_again;
}
__catch(...)
@@ -966,20 +966,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
- __in._M_setstate(__ios_base::badbit);
+ __in_._M_setstate(__ios_base::badbit);
}
}
// 211. operator>>(istream&, string&) doesn't set failbit
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
- __in.setstate(__err);
- return __in;
+ __in_.setstate(__err);
+ return __in_;
}
template<typename _CharT, typename _Traits, typename _Alloc>
basic_istream<_CharT, _Traits>&
- getline(basic_istream<_CharT, _Traits>& __in,
+ getline(basic_istream<_CharT, _Traits>& __in_,
basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
@@ -991,7 +991,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__size_type __extracted = 0;
const __size_type __n = __str.max_size();
typename __ios_base::iostate __err = __ios_base::goodbit;
- typename __istream_type::sentry __cerb(__in, true);
+ typename __istream_type::sentry __cerb(__in_, true);
if (__cerb)
{
__try
@@ -999,7 +999,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__str.erase();
const __int_type __idelim = _Traits::to_int_type(__delim);
const __int_type __eof = _Traits::eof();
- __int_type __c = __in.rdbuf()->sgetc();
+ __int_type __c = __in_.rdbuf()->sgetc();
while (__extracted < __n
&& !_Traits::eq_int_type(__c, __eof)
@@ -1007,7 +1007,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
__str += _Traits::to_char_type(__c);
++__extracted;
- __c = __in.rdbuf()->snextc();
+ __c = __in_.rdbuf()->snextc();
}
if (_Traits::eq_int_type(__c, __eof))
@@ -1015,14 +1015,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
else if (_Traits::eq_int_type(__c, __idelim))
{
++__extracted;
- __in.rdbuf()->sbumpc();
+ __in_.rdbuf()->sbumpc();
}
else
__err |= __ios_base::failbit;
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __in._M_setstate(__ios_base::badbit);
+ __in_._M_setstate(__ios_base::badbit);
__throw_exception_again;
}
__catch(...)
@@ -1030,14 +1030,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
- __in._M_setstate(__ios_base::badbit);
+ __in_._M_setstate(__ios_base::badbit);
}
}
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
- __in.setstate(__err);
- return __in;
+ __in_.setstate(__err);
+ return __in_;
}
// Inhibit implicit instantiations for required instantiations,
diff --git a/libstdc++-v3/include/bits/chrono_io.h b/libstdc++-v3/include/bits/chrono_io.h
index f8bb485d165..330a4392ad9 100644
--- a/libstdc++-v3/include/bits/chrono_io.h
+++ b/libstdc++-v3/include/bits/chrono_io.h
@@ -104,15 +104,15 @@ namespace __detail
template<typename _Period, typename _CharT, typename _Out>
inline _Out
- __fmt_units_suffix(_Out __out) noexcept
+ __fmt_units_suffix(_Out __out_) noexcept
{
if (auto __s = __detail::__units_suffix<_Period, _CharT>(); __s.size())
- return __format::__write(std::move(__out), __s);
+ return __format::__write(std::move(__out_), __s);
else if constexpr (_Period::den == 1)
- return std::format_to(std::move(__out), _GLIBCXX_WIDEN("[{}]s"),
+ return std::format_to(std::move(__out_), _GLIBCXX_WIDEN("[{}]s"),
(uintmax_t)_Period::num);
else
- return std::format_to(std::move(__out), _GLIBCXX_WIDEN("[{}/{}]s"),
+ return std::format_to(std::move(__out_), _GLIBCXX_WIDEN("[{}/{}]s"),
(uintmax_t)_Period::num,
(uintmax_t)_Period::den);
}
@@ -919,7 +919,7 @@ namespace __format
private:
template<typename _OutIter>
_OutIter
- _M_write(_OutIter __out, [[maybe_unused]] const locale& __loc,
+ _M_write(_OutIter __out_, [[maybe_unused]] const locale& __loc,
__string_view __s) const
{
#if defined _GLIBCXX_USE_NL_LANGINFO_L && __CHAR_BIT__ == 8
@@ -938,7 +938,7 @@ namespace __format
__s = __locale_encoding_to_utf8(__loc, __s, &__buf);
}
#endif
- return __format::__write(std::move(__out), __s);
+ return __format::__write(std::move(__out_), __s);
}
[[__gnu__::__always_inline__]]
@@ -969,7 +969,7 @@ namespace __format
// a locale-specific representation.
template<typename _Iter>
_Iter
- _M_locale_fmt(_Iter __out, const locale& __loc, const struct tm& __tm,
+ _M_locale_fmt(_Iter __out_, const locale& __loc, const struct tm& __tm,
char __fmt, char __mod) const
{
basic_ostringstream<_CharT> __os;
@@ -977,8 +977,8 @@ namespace __format
const auto& __tp = use_facet<time_put<_CharT>>(__loc);
__tp.put(__os, __os, _S_space, &__tm, __fmt, __mod);
if (__os)
- __out = _M_write(std::move(__out), __loc, __os.view());
- return __out;
+ __out_ = _M_write(std::move(__out_), __loc, __os.view());
+ return __out_;
}
__string_view
@@ -1050,19 +1050,19 @@ namespace __format
template<typename _OutIter, typename _FormatContext>
_OutIter
- _M_format_to(const _ChronoData<_CharT>& __t, _OutIter __out,
+ _M_format_to(const _ChronoData<_CharT>& __t, _OutIter __out_,
_FormatContext& __fc) const
{
auto __first = _M_spec._M_chrono_specs.begin();
const auto __last = _M_spec._M_chrono_specs.end();
- auto __print_sign = [__is_neg = __t._M_is_neg, &__out] () mutable {
+ auto __print_sign = [__is_neg = __t._M_is_neg, &__out_] () mutable {
if (__is_neg)
{
- *__out++ = _S_plus_minus[1];
+ *__out_++ = _S_plus_minus[1];
__is_neg = false;
}
- return std::move(__out);
+ return std::move(__out_);
};
struct tm __tm{};
@@ -1110,104 +1110,104 @@ namespace __format
if (__invalid.empty() &&__use_locale_fmt
&& _S_localized_spec(__c, __mod)) [[unlikely]]
- __out = _M_locale_fmt(std::move(__out), __fc.locale(),
+ __out_ = _M_locale_fmt(std::move(__out_), __fc.locale(),
__tm, __c, __mod);
else switch (__c)
{
// %\0 is extension for handling weekday index
case '\0':
- __out = _M_wi(__t._M_weekday_index, std::move(__out));
+ __out_ = _M_wi(__t._M_weekday_index, std::move(__out_));
break;
case 'a':
case 'A':
- __out = _M_a_A(__t._M_weekday, std::move(__out), __c == 'A');
+ __out_ = _M_a_A(__t._M_weekday, std::move(__out_), __c == 'A');
break;
case 'b':
case 'h':
case 'B':
- __out = _M_b_B(__t._M_month, std::move(__out), __c == 'B');
+ __out_ = _M_b_B(__t._M_month, std::move(__out_), __c == 'B');
break;
case 'c':
- __out = _M_c(__t, std::move(__out));
+ __out_ = _M_c(__t, std::move(__out_));
break;
case 'C':
case 'y':
case 'Y':
- __out = _M_C_y_Y(__t._M_year, std::move(__out), __c);
+ __out_ = _M_C_y_Y(__t._M_year, std::move(__out_), __c);
break;
case 'd':
case 'e':
- __out = _M_d_e(__t._M_day, std::move(__out), __c);
+ __out_ = _M_d_e(__t._M_day, std::move(__out_), __c);
break;
case 'D':
case 'x':
- __out = _M_D_x(__t, std::move(__out));
+ __out_ = _M_D_x(__t, std::move(__out_));
break;
case 'F':
- __out = _M_F(__t, std::move(__out));
+ __out_ = _M_F(__t, std::move(__out_));
break;
case 'g':
case 'G':
case 'V':
- __out = _M_g_G_V(__t, std::move(__out), __c);
+ __out_ = _M_g_G_V(__t, std::move(__out_), __c);
break;
case 'H':
case 'I':
- __out = _M_H_I(__t._M_hours, __print_sign(), __c);
+ __out_ = _M_H_I(__t._M_hours, __print_sign(), __c);
break;
case 'j':
- __out = _M_j(__t, __print_sign());
+ __out_ = _M_j(__t, __print_sign());
break;
case 'm':
- __out = _M_m(__t._M_month, std::move(__out));
+ __out_ = _M_m(__t._M_month, std::move(__out_));
break;
case 'M':
- __out = _M_M(__t._M_minutes, __print_sign());
+ __out_ = _M_M(__t._M_minutes, __print_sign());
break;
case 'p':
- __out = _M_p(__t._M_hours, std::move(__out));
+ __out_ = _M_p(__t._M_hours, std::move(__out_));
break;
case 'q':
- __out = _M_q(__t._M_unit_suffix, std::move(__out));
+ __out_ = _M_q(__t._M_unit_suffix, std::move(__out_));
break;
case 'Q':
- __out = _M_Q(__t, __print_sign(), __fc);
+ __out_ = _M_Q(__t, __print_sign(), __fc);
break;
case 'r':
- __out = _M_r(__t, __print_sign());
+ __out_ = _M_r(__t, __print_sign());
break;
case 'R':
case 'X':
- __out = _M_R_X(__t, __print_sign(), __c != 'R');
+ __out_ = _M_R_X(__t, __print_sign(), __c != 'R');
break;
case 'T':
- __out = _M_T(__t, __print_sign(), __fc);
+ __out_ = _M_T(__t, __print_sign(), __fc);
break;
case 'S':
- __out = _M_S(__t, __print_sign(), __fc, __mod != 'O');
+ __out_ = _M_S(__t, __print_sign(), __fc, __mod != 'O');
break;
case 'u':
case 'w':
- __out = _M_u_w(__t._M_weekday, std::move(__out), __c);
+ __out_ = _M_u_w(__t._M_weekday, std::move(__out_), __c);
break;
case 'U':
case 'W':
- __out = _M_U_W(__t, std::move(__out), __c);
+ __out_ = _M_U_W(__t, std::move(__out_), __c);
break;
case 'z':
- __out = _M_z(__t._M_zone_offset, std::move(__out), (bool)__mod);
+ __out_ = _M_z(__t._M_zone_offset, std::move(__out_), (bool)__mod);
break;
case 'Z':
- __out = _M_Z(__t._M_zone_abbrev, std::move(__out));
+ __out_ = _M_Z(__t._M_zone_abbrev, std::move(__out_));
break;
case 'n':
- *__out++ = __literals[0];
+ *__out_++ = __literals[0];
break;
case 't':
- *__out++ = __literals[1];
+ *__out_++ = __literals[1];
break;
case '%':
- *__out++ = __literals[2];
+ *__out_++ = __literals[2];
break;
case 'O':
case 'E':
@@ -1221,8 +1221,8 @@ namespace __format
if (!__invalid.empty())
{
constexpr __string_view __pref = _GLIBCXX_WIDEN(" is not a valid ");
- __out = __format::__write(std::move(__out), __pref);
- __out = __format::__write(std::move(__out), __invalid);
+ __out_ = __format::__write(std::move(__out_), __pref);
+ __out_ = __format::__write(std::move(__out_), __invalid);
}
__mod = _CharT();
@@ -1240,68 +1240,68 @@ namespace __format
__str.remove_suffix(__str.length() - __pos);
__first += __pos + 1;
}
- __out = __format::__write(std::move(__out), __str);
+ __out_ = __format::__write(std::move(__out_), __str);
}
}
while (__first != __last);
- return std::move(__out);
+ return std::move(__out_);
}
template<typename _OutIter>
_OutIter
- _M_wi(unsigned __wi, _OutIter __out) const
+ _M_wi(unsigned __wi, _OutIter __out_) const
{
// %\0 Extension to format weekday index, used only by empty format spec
_CharT __buf[3];
- __out = __format::__write(std::move(__out), _S_str_d1(__buf, __wi));
- return std::move(__out);
+ __out_ = __format::__write(std::move(__out_), _S_str_d1(__buf, __wi));
+ return std::move(__out_);
}
template<typename _OutIter>
_OutIter
- _M_a_A(chrono::weekday __wd, _OutIter __out, bool __full) const
+ _M_a_A(chrono::weekday __wd, _OutIter __out_, bool __full) const
{
// %a Locale's abbreviated weekday name.
// %A Locale's full weekday name.
__string_view __str = _S_weekdays[__wd.c_encoding()];
if (!__full)
__str = __str.substr(0, 3);
- return __format::__write(std::move(__out), __str);
+ return __format::__write(std::move(__out_), __str);
}
template<typename _OutIter>
_OutIter
- _M_b_B(chrono::month __m, _OutIter __out, bool __full) const
+ _M_b_B(chrono::month __m, _OutIter __out_, bool __full) const
{
// %b Locale's abbreviated month name.
// %B Locale's full month name.
__string_view __str = _S_months[(unsigned)__m - 1];
if (!__full)
__str = __str.substr(0, 3);
- return __format::__write(std::move(__out), __str);
+ return __format::__write(std::move(__out_), __str);
}
template<typename _OutIter>
_OutIter
- _M_c(const _ChronoData<_CharT>& __t, _OutIter __out) const
+ _M_c(const _ChronoData<_CharT>& __t, _OutIter __out_) const
{
// %c Locale's date and time representation, for C-locale: %a %b %e %T %Y
// %Ec Locale's alternate date and time representation, for C-locale same as above
- __out = _M_a_A(__t._M_weekday, std::move(__out), false);
- *__out = _S_space;
- __out = _M_b_B(__t._M_month, std::move(++__out), false);
- *__out = _S_space;
- __out = _M_d_e(__t._M_day, std::move(++__out), 'e');
- *__out = _S_space;
- __out = _M_R_X(__t, std::move(++__out), true);
- *__out = _S_space;
- return _M_C_y_Y(__t._M_year, std::move(++__out), 'Y');
+ __out_ = _M_a_A(__t._M_weekday, std::move(__out_), false);
+ *__out_ = _S_space;
+ __out_ = _M_b_B(__t._M_month, std::move(++__out_), false);
+ *__out_ = _S_space;
+ __out_ = _M_d_e(__t._M_day, std::move(++__out_), 'e');
+ *__out_ = _S_space;
+ __out_ = _M_R_X(__t, std::move(++__out_), true);
+ *__out_ = _S_space;
+ return _M_C_y_Y(__t._M_year, std::move(++__out_), 'Y');
}
template<typename _OutIter>
_OutIter
- _M_C_y_Y(chrono::year __y, _OutIter __out, _CharT __conv) const
+ _M_C_y_Y(chrono::year __y, _OutIter __out_, _CharT __conv) const
{
// %C Year divided by 100 using floored division.
// %EC Locale's alternative preresentation of the century (era name).
@@ -1325,7 +1325,7 @@ namespace __format
{
using _FmtStr = _Dynamic_format_string<_CharT>;
__string_view __fs = _S_minus_empty_spec + !__is_neg;
- __out = std::format_to(std::move(__out), _FmtStr(__fs),
+ __out_ = std::format_to(std::move(__out_), _FmtStr(__fs),
__conv == 'C' ? __ci : __yi);
}
else
@@ -1343,14 +1343,14 @@ namespace __format
_S_fill_two_digits(__buf + 3, __yi % 100);
__sv = __string_view(__sv.data(), __buf + 5);
}
- __out = __format::__write(std::move(__out), __sv);
+ __out_ = __format::__write(std::move(__out_), __sv);
}
- return __out;
+ return __out_;
}
template<typename _OutIter>
_OutIter
- _M_D_x(const _ChronoData<_CharT>& __t, _OutIter __out) const
+ _M_D_x(const _ChronoData<_CharT>& __t, _OutIter __out_) const
{
// %D Equivalent to %m/%d/%y
// %x Locale's date rep, for C-locale: %m/%d/%y
@@ -1364,7 +1364,7 @@ namespace __format
{
using _FmtStr = _Dynamic_format_string<_CharT>;
__string_view __fs = _GLIBCXX_WIDEN("{:02d}/{:02d}/{:02d}");
- __out = std::format_to(std::move(__out), _FmtStr(__fs),
+ __out_ = std::format_to(std::move(__out_), _FmtStr(__fs),
__mi, __di, __yi);
}
else
@@ -1377,14 +1377,14 @@ namespace __format
_S_fill_two_digits(__buf, __mi);
_S_fill_two_digits(__buf + 3, __di);
_S_fill_two_digits(__buf + 6, __yi);
- __out = __format::__write(std::move(__out), __sv);
+ __out_ = __format::__write(std::move(__out_), __sv);
}
- return std::move(__out);
+ return std::move(__out_);
}
template<typename _OutIter>
_OutIter
- _M_d_e(chrono::day __d, _OutIter __out, _CharT __conv) const
+ _M_d_e(chrono::day __d, _OutIter __out_, _CharT __conv) const
{
// %d The day of month as a decimal number.
// %Od Locale's alternative representation.
@@ -1402,13 +1402,13 @@ namespace __format
__sv = {__buf, 2};
}
- __out = __format::__write(std::move(__out), __sv);
- return std::move(__out);
+ __out_ = __format::__write(std::move(__out_), __sv);
+ return std::move(__out_);
}
template<typename _OutIter>
_OutIter
- _M_F(const _ChronoData<_CharT>& __t, _OutIter __out) const
+ _M_F(const _ChronoData<_CharT>& __t, _OutIter __out_) const
{
auto __di = (unsigned)__t._M_day;
auto __mi = (unsigned)__t._M_month;
@@ -1421,7 +1421,7 @@ namespace __format
using _FmtStr = _Dynamic_format_string<_CharT>;
__string_view __fs
= _GLIBCXX_WIDEN("-{:04d}-{:02d}-{:02d}") + !__is_neg;
- __out = std::format_to(std::move(__out), _FmtStr(__fs),
+ __out_ = std::format_to(std::move(__out_), _FmtStr(__fs),
__yi, __mi, __di);
}
else
@@ -1436,15 +1436,15 @@ namespace __format
_S_fill_two_digits(__buf + 3, __yi % 100);
_S_fill_two_digits(__buf + 6, __mi);
_S_fill_two_digits(__buf + 9, __di);
- __out = __format::__write(std::move(__out), __sv);
+ __out_ = __format::__write(std::move(__out_), __sv);
}
- return std::move(__out);
+ return std::move(__out_);
}
template<typename _OutIter>
_OutIter
- _M_g_G_V(const _ChronoData<_CharT>& __t, _OutIter __out,
+ _M_g_G_V(const _ChronoData<_CharT>& __t, _OutIter __out_,
_CharT __conv) const
{
// %g last two decimal digits of the ISO week-based year.
@@ -1478,18 +1478,18 @@ namespace __format
__iyear = year_month_day(__ild).year();
if (__conv != 'V')
- return _M_C_y_Y(__iyear, std::move(__out), "yY"[__conv == 'G']);
+ return _M_C_y_Y(__iyear, std::move(__out_), "yY"[__conv == 'G']);
if (__iyear != __t._M_year)
__idoy = __ild - local_days(__iyear/January/0);
const auto __wi = chrono::floor<weeks>(__idoy - days(1)).count() + 1;
- return __format::__write(std::move(__out), _S_two_digits(__wi));
+ return __format::__write(std::move(__out_), _S_two_digits(__wi));
}
template<typename _OutIter>
_OutIter
- _M_H_I(chrono::hours __h, _OutIter __out, _CharT __conv) const
+ _M_H_I(chrono::hours __h, _OutIter __out_, _CharT __conv) const
{
// %H The hour (24-hour clock) as a decimal number.
// %OH Locale's alternative representation.
@@ -1505,87 +1505,87 @@ namespace __format
__i = 12;
}
else if (__i >= 100) [[unlikely]]
- return std::format_to(std::move(__out), _S_empty_fs(), __i);
+ return std::format_to(std::move(__out_), _S_empty_fs(), __i);
- return __format::__write(std::move(__out), _S_two_digits(__i));
+ return __format::__write(std::move(__out_), _S_two_digits(__i));
}
template<typename _OutIter>
_OutIter
- _M_j(const _ChronoData<_CharT>& __t, _OutIter __out) const
+ _M_j(const _ChronoData<_CharT>& __t, _OutIter __out_) const
{
if (!_M_spec._M_needs(_ChronoParts::_DayOfYear))
{
// Decimal number of days, without padding.
auto __d = chrono::floor<chrono::days>(__t._M_hours).count();
- return std::format_to(std::move(__out), _S_empty_fs(), __d);
+ return std::format_to(std::move(__out_), _S_empty_fs(), __d);
}
auto __d = __t._M_day_of_year.count();
if (__d >= 1000) [[unlikely]]
- return std::format_to(std::move(__out), _S_empty_fs(), __d);
+ return std::format_to(std::move(__out_), _S_empty_fs(), __d);
_CharT __buf[3];
- return __format::__write(std::move(__out), _S_str_d3(__buf, __d));
+ return __format::__write(std::move(__out_), _S_str_d3(__buf, __d));
}
template<typename _OutIter>
_OutIter
- _M_m(chrono::month __m, _OutIter __out) const
+ _M_m(chrono::month __m, _OutIter __out_) const
{
// %m month as a decimal number.
// %Om Locale's alternative representation.
auto __i = (unsigned)__m;
if (__i == 0 && _M_spec._M_debug) [[unlikely]]
// 0 should not be padded to two digits
- return __format::__write(std::move(__out), _S_digit(0));
+ return __format::__write(std::move(__out_), _S_digit(0));
_CharT __buf[3];
- return __format::__write(std::move(__out), _S_str_d2(__buf, __i));
+ return __format::__write(std::move(__out_), _S_str_d2(__buf, __i));
}
template<typename _OutIter>
_OutIter
- _M_M(chrono::minutes __m, _OutIter __out) const
+ _M_M(chrono::minutes __m, _OutIter __out_) const
{
// %M The minute as a decimal number.
// %OM Locale's alternative representation.
auto __i = __m.count();
- return __format::__write(std::move(__out), _S_two_digits(__i));
+ return __format::__write(std::move(__out_), _S_two_digits(__i));
}
template<typename _OutIter>
_OutIter
- _M_p(chrono::hours __h, _OutIter __out) const
+ _M_p(chrono::hours __h, _OutIter __out_) const
{
// %p The locale's equivalent of the AM/PM designations.
_CharT __buf[2];
_S_fill_ampm(__buf, __h);
- return __format::__write(std::move(__out), __string_view(__buf, 2));
+ return __format::__write(std::move(__out_), __string_view(__buf, 2));
}
template<typename _OutIter>
_OutIter
- _M_q(__string_view __us, _OutIter __out) const
+ _M_q(__string_view __us, _OutIter __out_) const
{
// %q The duration's unit suffix
- return __format::__write(std::move(__out), __us);
+ return __format::__write(std::move(__out_), __us);
}
template<typename _OutIter, typename _FormatContext>
_OutIter
- _M_Q(const _ChronoData<_CharT>& __t, _OutIter __out,
+ _M_Q(const _ChronoData<_CharT>& __t, _OutIter __out_,
_FormatContext&) const
{
// %Q The duration's numeric value.
- return std::vformat_to(std::move(__out), _S_empty_spec, __t._M_ereps);
+ return std::vformat_to(std::move(__out_), _S_empty_spec, __t._M_ereps);
}
template<typename _OutIter>
_OutIter
- _M_r(const _ChronoData<_CharT>& __t, _OutIter __out) const
+ _M_r(const _ChronoData<_CharT>& __t, _OutIter __out_) const
{
// %r Locale's 12-hour clock time, for C-locale: %I:%M:%S %p
auto __hi = __t._M_hours.count() % 12;
@@ -1601,12 +1601,12 @@ namespace __format
_S_fill_two_digits(__buf + 6, __t._M_seconds.count());
_S_fill_ampm(__buf + 9, __t._M_hours);
- return __format::__write(std::move(__out), __string_view(__buf, 11));
+ return __format::__write(std::move(__out_), __string_view(__buf, 11));
}
template<typename _OutIter>
_OutIter
- _M_R_X(const _ChronoData<_CharT>& __t, _OutIter __out,
+ _M_R_X(const _ChronoData<_CharT>& __t, _OutIter __out_,
bool __secs) const
{
// %R Equivalent to %H:%M
@@ -1622,7 +1622,7 @@ namespace __format
if (__hi >= 100) [[unlikely]]
{
- __out = std::format_to(std::move(__out), _S_empty_fs(), __hi);
+ __out_ = std::format_to(std::move(__out_), _S_empty_fs(), __hi);
__sv.remove_prefix(2);
}
else
@@ -1634,35 +1634,35 @@ namespace __format
else
__sv.remove_suffix(3);
- return __format::__write(std::move(__out), __sv);
+ return __format::__write(std::move(__out_), __sv);
}
template<typename _OutIter, typename _FormatContext>
_OutIter
- _M_S(const _ChronoData<_CharT>& __t, _OutIter __out,
+ _M_S(const _ChronoData<_CharT>& __t, _OutIter __out_,
_FormatContext& __ctx, bool __subs = true) const
{
// %S Seconds as a decimal number.
// %OS The locale's alternative representation.
auto __s = __t._M_seconds;
- __out = __format::__write(std::move(__out),
+ __out_ = __format::__write(std::move(__out_),
_S_two_digits(__s.count()));
if (__subs)
- __out = _M_subsecs(__t, std::move(__out), __ctx);
- return __out;
+ __out_ = _M_subsecs(__t, std::move(__out_), __ctx);
+ return __out_;
}
template<typename _OutIter, typename _FormatContext>
_OutIter
- _M_subsecs(const _ChronoData<_CharT>& __t, _OutIter __out,
+ _M_subsecs(const _ChronoData<_CharT>& __t, _OutIter __out_,
_FormatContext& __ctx) const
{
unsigned __prec = _M_spec._M_prec_kind != _WP_none
? _M_spec._M_get_precision(__ctx)
: _M_spec._M_prec;
if (__prec == 0)
- return __out;
+ return __out_;
_CharT __dot = _S_dot;
if (_M_spec._M_localized) [[unlikely]]
@@ -1671,8 +1671,8 @@ namespace __format
const auto& __np = use_facet<numpunct<_CharT>>(__loc);
__dot = __np.decimal_point();
}
- *__out = __dot;
- ++__out;
+ *__out_ = __dot;
+ ++__out_;
if (_M_spec._M_floating_point_rep)
{
@@ -1687,7 +1687,7 @@ namespace __format
auto __sv = __sink.view();
// Skip leading zero and dot
__sv.remove_prefix(2);
- return __format::__write(std::move(__out), __sv);
+ return __format::__write(std::move(__out_), __sv);
}
constexpr unsigned __max_prec = _ChronoData<_CharT>::_S_max_prec;
@@ -1709,7 +1709,7 @@ namespace __format
__prec = __max_prec;
using _FmtStr = _Dynamic_format_string<_CharT>;
- return std::format_to(__out, _FmtStr(_GLIBCXX_WIDEN("{0:0{1}}")),
+ return std::format_to(__out_, _FmtStr(_GLIBCXX_WIDEN("{0:0{1}}")),
__subs, __prec);
}
@@ -1717,17 +1717,17 @@ namespace __format
template<typename _OutIter, typename _FormatContext>
_OutIter
- _M_T(const _ChronoData<_CharT>& __t, _OutIter __out,
+ _M_T(const _ChronoData<_CharT>& __t, _OutIter __out_,
_FormatContext& __ctx) const
{
// %T Equivalent to %H:%M:%S, with subseconds
- __out = _M_R_X(__t, std::move(__out), true);
- return _M_subsecs(__t, std::move(__out), __ctx);
+ __out_ = _M_R_X(__t, std::move(__out_), true);
+ return _M_subsecs(__t, std::move(__out_), __ctx);
}
template<typename _OutIter>
_OutIter
- _M_u_w(chrono::weekday __wd, _OutIter __out, _CharT __conv) const
+ _M_u_w(chrono::weekday __wd, _OutIter __out_, _CharT __conv) const
{
// %u ISO weekday as a decimal number (1-7), where Monday is 1.
// %Ou Locale's alternative numeric rep.
@@ -1736,12 +1736,12 @@ namespace __format
unsigned __wdi = __conv == 'u' ? __wd.iso_encoding()
: __wd.c_encoding();
_CharT __buf[3];
- return __format::__write(std::move(__out), _S_str_d1(__buf, __wdi));
+ return __format::__write(std::move(__out_), _S_str_d1(__buf, __wdi));
}
template<typename _OutIter>
_OutIter
- _M_U_W(const _ChronoData<_CharT>& __t, _OutIter __out,
+ _M_U_W(const _ChronoData<_CharT>& __t, _OutIter __out_,
_CharT __conv) const
{
// %U Week number of the year as a decimal number, from first Sunday.
@@ -1753,18 +1753,18 @@ namespace __format
const weekday __weekstart = __conv == 'U' ? Sunday : Monday;
const days __offset = __t._M_weekday - __weekstart;
auto __weeks = chrono::floor<weeks>(__t._M_day_of_year - __offset - days(1));
- return __format::__write(std::move(__out), _S_two_digits(__weeks.count() + 1));
+ return __format::__write(std::move(__out_), _S_two_digits(__weeks.count() + 1));
}
template<typename _OutIter>
_OutIter
- _M_z(chrono::seconds __ts, _OutIter __out, bool __mod = false) const
+ _M_z(chrono::seconds __ts, _OutIter __out_, bool __mod = false) const
{
if (__ts == 0s)
{
__string_view __zero
= __mod ? _GLIBCXX_WIDEN("+00:00") : _GLIBCXX_WIDEN("+0000");
- return __format::__write(std::move(__out), __zero);
+ return __format::__write(std::move(__out_), __zero);
}
chrono::hh_mm_ss<chrono::seconds> __hms(__ts);
@@ -1777,13 +1777,13 @@ namespace __format
_S_fill_two_digits(__buf + __mo, __hms.minutes().count());
__string_view __sv(__buf, __mo + 2);
- return __format::__write(std::move(__out), __sv);
+ return __format::__write(std::move(__out_), __sv);
}
template<typename _OutIter>
_OutIter
- _M_Z(__string_view __abbrev, _OutIter __out) const
- { return __format::__write(std::move(__out), __abbrev); }
+ _M_Z(__string_view __abbrev, _OutIter __out_) const
+ { return __format::__write(std::move(__out_), __abbrev); }
// %% handled in _M_format
@@ -2110,7 +2110,7 @@ namespace __format
private:
template<typename _Out>
_Out
- _M_format_to(_Out __out, const chrono::sys_info& __si) const
+ _M_format_to(_Out __out_, const chrono::sys_info& __si) const
{
using _FmtStr = _Dynamic_format_string<_CharT>;
// n.b. only decimal separator is locale dependent for specifiers
@@ -2119,19 +2119,19 @@ namespace __format
constexpr auto* __fs
= _GLIBCXX_WIDEN("[{0:%F %T},{1:%F %T},{2:%T},{3:%Q%q},{0:%Z}]");
const chrono::local_seconds __lb(__si.begin.time_since_epoch());
- return std::format_to(std::move(__out), _FmtStr(__fs),
+ return std::format_to(std::move(__out_), _FmtStr(__fs),
chrono::local_time_format(__lb, &__si.abbrev),
__si.end, __si.offset, __si.save);
}
template<typename _Out>
_Out
- _M_format_to(_Out __out, const chrono::local_info& __li) const
+ _M_format_to(_Out __out_, const chrono::local_info& __li) const
{
- *__out = _Separators<_CharT>::_S_squares()[0];
- ++__out;
+ *__out_ = _Separators<_CharT>::_S_squares()[0];
+ ++__out_;
if (__li.result == chrono::local_info::unique)
- __out = _M_format_to(std::move(__out), __li.first);
+ __out_ = _M_format_to(std::move(__out_), __li.first);
else
{
basic_string_view<_CharT> __sv;
@@ -2139,19 +2139,19 @@ namespace __format
__sv =_GLIBCXX_WIDEN("nonexistent");
else
__sv = _GLIBCXX_WIDEN("ambiguous");
- __out = __format::__write(std::move(__out), __sv);
+ __out_ = __format::__write(std::move(__out_), __sv);
__sv = _GLIBCXX_WIDEN(" local time between ");
- __out = __format::__write(std::move(__out), __sv);
- __out = _M_format_to(std::move(__out), __li.first);
+ __out_ = __format::__write(std::move(__out_), __sv);
+ __out_ = _M_format_to(std::move(__out_), __li.first);
__sv = _GLIBCXX_WIDEN(" and ");
- __out = __format::__write(std::move(__out), __sv);
- __out = _M_format_to(std::move(__out), __li.second);
+ __out_ = __format::__write(std::move(__out_), __sv);
+ __out_ = _M_format_to(std::move(__out_), __li.second);
}
- *__out = _Separators<_CharT>::_S_squares()[1];
- ++__out;
- return std::move(__out);
+ *__out_ = _Separators<_CharT>::_S_squares()[1];
+ ++__out_;
+ return std::move(__out_);
}
__formatter_chrono<_CharT> _M_f;
diff --git a/libstdc++-v3/include/bits/istream.tcc b/libstdc++-v3/include/bits/istream.tcc
index 7cfd97fae82..4e8aaac0aec 100644
--- a/libstdc++-v3/include/bits/istream.tcc
+++ b/libstdc++-v3/include/bits/istream.tcc
@@ -49,22 +49,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>::sentry::
- sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false)
+ sentry(basic_istream<_CharT, _Traits>& __in_, bool __noskip) : _M_ok(false)
{
ios_base::iostate __err = ios_base::goodbit;
- if (__in.good())
+ if (__in_.good())
{
__try
{
- if (__in.tie())
- __in.tie()->flush();
- if (!__noskip && bool(__in.flags() & ios_base::skipws))
+ if (__in_.tie())
+ __in_.tie()->flush();
+ if (!__noskip && bool(__in_.flags() & ios_base::skipws))
{
const __int_type __eof = traits_type::eof();
- __streambuf_type* __sb = __in.rdbuf();
+ __streambuf_type* __sb = __in_.rdbuf();
__int_type __c = __sb->sgetc();
- const __ctype_type& __ct = __check_facet(__in._M_ctype);
+ const __ctype_type& __ct = __check_facet(__in_._M_ctype);
while (!traits_type::eq_int_type(__c, __eof)
&& __ct.is(ctype_base::space,
traits_type::to_char_type(__c)))
@@ -79,19 +79,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __in._M_setstate(ios_base::badbit);
+ __in_._M_setstate(ios_base::badbit);
__throw_exception_again;
}
__catch(...)
- { __in._M_setstate(ios_base::badbit); }
+ { __in_._M_setstate(ios_base::badbit); }
}
- if (__in.good() && __err == ios_base::goodbit)
+ if (__in_.good() && __err == ios_base::goodbit)
_M_ok = true;
else
{
__err |= ios_base::failbit;
- __in.setstate(__err);
+ __in_.setstate(__err);
}
}
@@ -980,18 +980,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// 27.6.1.2.3 Character extraction templates
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c)
+ operator>>(basic_istream<_CharT, _Traits>& __in_, _CharT& __c)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef typename __istream_type::int_type __int_type;
- typename __istream_type::sentry __cerb(__in, false);
+ typename __istream_type::sentry __cerb(__in_, false);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
__try
{
- const __int_type __cb = __in.rdbuf()->sbumpc();
+ const __int_type __cb = __in_.rdbuf()->sbumpc();
if (!_Traits::eq_int_type(__cb, _Traits::eof()))
__c = _Traits::to_char_type(__cb);
else
@@ -999,20 +999,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __in._M_setstate(ios_base::badbit);
+ __in_._M_setstate(ios_base::badbit);
__throw_exception_again;
}
__catch(...)
- { __in._M_setstate(ios_base::badbit); }
+ { __in_._M_setstate(ios_base::badbit); }
if (__err)
- __in.setstate(__err);
+ __in_.setstate(__err);
}
- return __in;
+ return __in_;
}
template<typename _CharT, typename _Traits>
void
- __istream_extract(basic_istream<_CharT, _Traits>& __in, _CharT* __s,
+ __istream_extract(basic_istream<_CharT, _Traits>& __in_, _CharT* __s,
streamsize __num)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
@@ -1023,20 +1023,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
streamsize __extracted = 0;
ios_base::iostate __err = ios_base::goodbit;
- typename __istream_type::sentry __cerb(__in, false);
+ typename __istream_type::sentry __cerb(__in_, false);
if (__cerb)
{
__try
{
// Figure out how many characters to extract.
- streamsize __width = __in.width();
+ streamsize __width = __in_.width();
if (0 < __width && __width < __num)
__num = __width;
- const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+ const __ctype_type& __ct = use_facet<__ctype_type>(__in_.getloc());
const int_type __eof = _Traits::eof();
- __streambuf_type* __sb = __in.rdbuf();
+ __streambuf_type* __sb = __in_.rdbuf();
int_type __c = __sb->sgetc();
while (__extracted < __num - 1
@@ -1056,26 +1056,26 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 68. Extractors for char* should store null at end
*__s = char_type();
- __in.width(0);
+ __in_.width(0);
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __in._M_setstate(ios_base::badbit);
+ __in_._M_setstate(ios_base::badbit);
__throw_exception_again;
}
__catch(...)
- { __in._M_setstate(ios_base::badbit); }
+ { __in_._M_setstate(ios_base::badbit); }
}
if (!__extracted)
__err |= ios_base::failbit;
if (__err)
- __in.setstate(__err);
+ __in_.setstate(__err);
}
// 27.6.1.4 Standard basic_istream manipulators
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
- ws(basic_istream<_CharT, _Traits>& __in)
+ ws(basic_istream<_CharT, _Traits>& __in_)
{
typedef basic_istream<_CharT, _Traits> __istream_type;
typedef basic_streambuf<_CharT, _Traits> __streambuf_type;
@@ -1084,15 +1084,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 451. behavior of std::ws
- typename __istream_type::sentry __cerb(__in, true);
+ typename __istream_type::sentry __cerb(__in_, true);
if (__cerb)
{
ios_base::iostate __err = ios_base::goodbit;
__try
{
- const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+ const __ctype_type& __ct = use_facet<__ctype_type>(__in_.getloc());
const __int_type __eof = _Traits::eof();
- __streambuf_type* __sb = __in.rdbuf();
+ __streambuf_type* __sb = __in_.rdbuf();
__int_type __c = __sb->sgetc();
while (true)
@@ -1109,17 +1109,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
__catch (const __cxxabiv1::__forced_unwind&)
{
- __in._M_setstate(ios_base::badbit);
+ __in_._M_setstate(ios_base::badbit);
__throw_exception_again;
}
__catch (...)
{
- __in._M_setstate(ios_base::badbit);
+ __in_._M_setstate(ios_base::badbit);
}
if (__err)
- __in.setstate(__err);
+ __in_.setstate(__err);
}
- return __in;
+ return __in_;
}
// Inhibit implicit instantiations for required instantiations,
diff --git a/libstdc++-v3/include/bits/locale_conv.h b/libstdc++-v3/include/bits/locale_conv.h
index 1d2f17d3f8e..6bb301ebfb5 100644
--- a/libstdc++-v3/include/bits/locale_conv.h
+++ b/libstdc++-v3/include/bits/locale_conv.h
@@ -343,10 +343,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
{
if (!_M_with_cvtstate)
_M_state = state_type();
- wide_string __out{ _M_wide_err_string.get_allocator() };
- if (__str_codecvt_in(__first, __last, __out, *_M_cvt, _M_state,
+ wide_string __out_{ _M_wide_err_string.get_allocator() };
+ if (__str_codecvt_in(__first, __last, __out_, *_M_cvt, _M_state,
_M_count))
- return __out;
+ return __out_;
if (_M_with_strings)
return _M_wide_err_string;
__throw_range_error("wstring_convert::from_bytes");
@@ -379,10 +379,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
{
if (!_M_with_cvtstate)
_M_state = state_type();
- byte_string __out{ _M_byte_err_string.get_allocator() };
- if (__str_codecvt_out(__first, __last, __out, *_M_cvt, _M_state,
+ byte_string __out_{ _M_byte_err_string.get_allocator() };
+ if (__str_codecvt_out(__first, __last, __out_, *_M_cvt, _M_state,
_M_count))
- return __out;
+ return __out_;
if (_M_with_strings)
return _M_byte_err_string;
__throw_range_error("wstring_convert::to_bytes");
@@ -472,13 +472,13 @@ _GLIBCXX_END_NAMESPACE_CXX11
{ return _M_buf && _M_conv_put() && !_M_buf->pubsync() ? 0 : -1; }
typename _Wide_streambuf::int_type
- overflow(typename _Wide_streambuf::int_type __out)
+ overflow(typename _Wide_streambuf::int_type __out_)
{
if (!_M_buf || !_M_conv_put())
return _Tr::eof();
- else if (!_Tr::eq_int_type(__out, _Tr::eof()))
- return this->sputc(__out);
- return _Tr::not_eof(__out);
+ else if (!_Tr::eq_int_type(__out_, _Tr::eof()))
+ return this->sputc(__out_);
+ return _Tr::not_eof(__out_);
}
typename _Wide_streambuf::int_type
diff --git a/libstdc++-v3/include/bits/locale_facets.h b/libstdc++-v3/include/bits/locale_facets.h
index 902ba047b26..21ba182daaf 100644
--- a/libstdc++-v3/include/bits/locale_facets.h
+++ b/libstdc++-v3/include/bits/locale_facets.h
@@ -1996,7 +1996,7 @@ _GLIBCXX_BEGIN_NAMESPACE_LDBL
* except if the value is 1, sets @a v to true, if the value is 0, sets
* @a v to false, and otherwise set err to ios_base::failbit.
*
- * @param __in Start of input stream.
+ * @param __in_ Start of input stream.
* @param __end End of input stream.
* @param __io Source of locale and flags.
* @param __err Error flags to set.
@@ -2004,9 +2004,9 @@ _GLIBCXX_BEGIN_NAMESPACE_LDBL
* @return Iterator after reading.
*/
iter_type
- get(iter_type __in, iter_type __end, ios_base& __io,
+ get(iter_type __in_, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
- { return this->do_get(__in, __end, __io, __err, __v); }
+ { return this->do_get(__in_, __end, __io, __err, __v); }
///@{
/**
@@ -2033,7 +2033,7 @@ _GLIBCXX_BEGIN_NAMESPACE_LDBL
* Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
* Sets err to ios_base::eofbit if the stream is emptied.
*
- * @param __in Start of input stream.
+ * @param __in_ Start of input stream.
* @param __end End of input stream.
* @param __io Source of locale and flags.
* @param __err Error flags to set.
@@ -2041,37 +2041,37 @@ _GLIBCXX_BEGIN_NAMESPACE_LDBL
* @return Iterator after reading.
*/
iter_type
- get(iter_type __in, iter_type __end, ios_base& __io,
+ get(iter_type __in_, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long& __v) const
- { return this->do_get(__in, __end, __io, __err, __v); }
+ { return this->do_get(__in_, __end, __io, __err, __v); }
iter_type
- get(iter_type __in, iter_type __end, ios_base& __io,
+ get(iter_type __in_, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned short& __v) const
- { return this->do_get(__in, __end, __io, __err, __v); }
+ { return this->do_get(__in_, __end, __io, __err, __v); }
iter_type
- get(iter_type __in, iter_type __end, ios_base& __io,
+ get(iter_type __in_, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned int& __v) const
- { return this->do_get(__in, __end, __io, __err, __v); }
+ { return this->do_get(__in_, __end, __io, __err, __v); }
iter_type
- get(iter_type __in, iter_type __end, ios_base& __io,
+ get(iter_type __in_, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long& __v) const
- { return this->do_get(__in, __end, __io, __err, __v); }
+ { return this->do_get(__in_, __end, __io, __err, __v); }
#ifdef _GLIBCXX_USE_LONG_LONG
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wlong-long"
iter_type
- get(iter_type __in, iter_type __end, ios_base& __io,
+ get(iter_type __in_, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long long& __v) const
- { return this->do_get(__in, __end, __io, __err, __v); }
+ { return this->do_get(__in_, __end, __io, __err, __v); }
iter_type
- get(iter_type __in, iter_type __end, ios_base& __io,
+ get(iter_type __in_, iter_type __end, ios_base& __io,
ios_base::iostate& __err, unsigned long long& __v) const
- { return this->do_get(__in, __end, __io, __err, __v); }
+ { return this->do_get(__in_, __end, __io, __err, __v); }
#pragma GCC diagnostic pop
#endif
///@}
@@ -2096,7 +2096,7 @@ _GLIBCXX_BEGIN_NAMESPACE_LDBL
* Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
* Sets err to ios_base::eofbit if the stream is emptied.
*
- * @param __in Start of input stream.
+ * @param __in_ Start of input stream.
* @param __end End of input stream.
* @param __io Source of locale and flags.
* @param __err Error flags to set.
@@ -2104,19 +2104,19 @@ _GLIBCXX_BEGIN_NAMESPACE_LDBL
* @return Iterator after reading.
*/
iter_type
- get(iter_type __in, iter_type __end, ios_base& __io,
+ get(iter_type __in_, iter_type __end, ios_base& __io,
ios_base::iostate& __err, float& __v) const
- { return this->do_get(__in, __end, __io, __err, __v); }
+ { return this->do_get(__in_, __end, __io, __err, __v); }
iter_type
- get(iter_type __in, iter_type __end, ios_base& __io,
+ get(iter_type __in_, iter_type __end, ios_base& __io,
ios_base::iostate& __err, double& __v) const
- { return this->do_get(__in, __end, __io, __err, __v); }
+ { return this->do_get(__in_, __end, __io, __err, __v); }
iter_type
- get(iter_type __in, iter_type __end, ios_base& __io,
+ get(iter_type __in_, iter_type __end, ios_base& __io,
ios_base::iostate& __err, long double& __v) const
- { return this->do_get(__in, __end, __io, __err, __v); }
+ { return this->do_get(__in_, __end, __io, __err, __v); }
///@}
/**
@@ -2139,7 +2139,7 @@ _GLIBCXX_BEGIN_NAMESPACE_LDBL
* Otherwise, sets err to ios_base::failbit and leaves @a v unaltered.
* Sets err to ios_base::eofbit if the stream is emptied.
*
- * @param __in Start of input stream.
+ * @param __in_ Start of input stream.
* @param __end End of input stream.
* @param __io Source of locale and flags.
* @param __err Error flags to set.
@@ -2147,9 +2147,9 @@ _GLIBCXX_BEGIN_NAMESPACE_LDBL
* @return Iterator after reading.
*/
iter_type
- get(iter_type __in, iter_type __end, ios_base& __io,
+ get(iter_type __in_, iter_type __end, ios_base& __io,
ios_base::iostate& __err, void*& __v) const
- { return this->do_get(__in, __end, __io, __err, __v); }
+ { return this->do_get(__in_, __end, __io, __err, __v); }
protected:
/// Destructor.
diff --git a/libstdc++-v3/include/bits/ostream.h b/libstdc++-v3/include/bits/ostream.h
index 703ebf7890c..b9a072fd58a 100644
--- a/libstdc++-v3/include/bits/ostream.h
+++ b/libstdc++-v3/include/bits/ostream.h
@@ -613,14 +613,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
///@{
/**
* @brief Character inserters
- * @param __out An output stream.
+ * @param __out_ An output stream.
* @param __c A character.
* @return out
*
* Behaves like one of the formatted arithmetic inserters described in
* std::basic_ostream. After constructing a sentry object with good
* status, this function inserts a single character and any required
- * padding (as determined by [22.2.2.2.2]). @c __out.width(0) is then
+ * padding (as determined by [22.2.2.2.2]). @c __out_.width(0) is then
* called.
*
* If @p __c is of type @c char and the character type of the stream is not
@@ -628,40 +628,40 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c)
+ operator<<(basic_ostream<_CharT, _Traits>& __out_, _CharT __c)
{
- if (__out.width() != 0)
- return __ostream_insert(__out, &__c, 1);
- __out.put(__c);
- return __out;
+ if (__out_.width() != 0)
+ return __ostream_insert(__out_, &__c, 1);
+ __out_.put(__c);
+ return __out_;
}
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __out, char __c)
- { return (__out << __out.widen(__c)); }
+ operator<<(basic_ostream<_CharT, _Traits>& __out_, char __c)
+ { return (__out_ << __out_.widen(__c)); }
// Specialization
template<typename _Traits>
inline basic_ostream<char, _Traits>&
- operator<<(basic_ostream<char, _Traits>& __out, char __c)
+ operator<<(basic_ostream<char, _Traits>& __out_, char __c)
{
- if (__out.width() != 0)
- return __ostream_insert(__out, &__c, 1);
- __out.put(__c);
- return __out;
+ if (__out_.width() != 0)
+ return __ostream_insert(__out_, &__c, 1);
+ __out_.put(__c);
+ return __out_;
}
// Signed and unsigned
template<typename _Traits>
inline basic_ostream<char, _Traits>&
- operator<<(basic_ostream<char, _Traits>& __out, signed char __c)
- { return (__out << static_cast<char>(__c)); }
+ operator<<(basic_ostream<char, _Traits>& __out_, signed char __c)
+ { return (__out_ << static_cast<char>(__c)); }
template<typename _Traits>
inline basic_ostream<char, _Traits>&
- operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c)
- { return (__out << static_cast<char>(__c)); }
+ operator<<(basic_ostream<char, _Traits>& __out_, unsigned char __c)
+ { return (__out_ << static_cast<char>(__c)); }
///@}
#if __cplusplus > 201703L
@@ -706,7 +706,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
///@{
/**
* @brief String inserters
- * @param __out An output stream.
+ * @param __out_ An output stream.
* @param __s A character string.
* @return out
* @pre @p __s must be a non-NULL pointer
@@ -715,47 +715,47 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* std::basic_ostream. After constructing a sentry object with good
* status, this function inserts @c traits::length(__s) characters starting
* at @p __s, widened if necessary, followed by any required padding (as
- * determined by [22.2.2.2.2]). @c __out.width(0) is then called.
+ * determined by [22.2.2.2.2]). @c __out_.width(0) is then called.
*/
template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s)
+ operator<<(basic_ostream<_CharT, _Traits>& __out_, const _CharT* __s)
{
if (!__s)
- __out.setstate(ios_base::badbit);
+ __out_.setstate(ios_base::badbit);
else
- __ostream_insert(__out, __s,
+ __ostream_insert(__out_, __s,
static_cast<streamsize>(_Traits::length(__s)));
- return __out;
+ return __out_;
}
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits> &
- operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s);
+ operator<<(basic_ostream<_CharT, _Traits>& __out_, const char* __s);
// Partial specializations
template<typename _Traits>
inline basic_ostream<char, _Traits>&
- operator<<(basic_ostream<char, _Traits>& __out, const char* __s)
+ operator<<(basic_ostream<char, _Traits>& __out_, const char* __s)
{
if (!__s)
- __out.setstate(ios_base::badbit);
+ __out_.setstate(ios_base::badbit);
else
- __ostream_insert(__out, __s,
+ __ostream_insert(__out_, __s,
static_cast<streamsize>(_Traits::length(__s)));
- return __out;
+ return __out_;
}
// Signed and unsigned
template<typename _Traits>
inline basic_ostream<char, _Traits>&
- operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s)
- { return (__out << reinterpret_cast<const char*>(__s)); }
+ operator<<(basic_ostream<char, _Traits>& __out_, const signed char* __s)
+ { return (__out_ << reinterpret_cast<const char*>(__s)); }
template<typename _Traits>
inline basic_ostream<char, _Traits> &
- operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s)
- { return (__out << reinterpret_cast<const char*>(__s)); }
+ operator<<(basic_ostream<char, _Traits>& __out_, const unsigned char* __s)
+ { return (__out_ << reinterpret_cast<const char*>(__s)); }
///@}
#if __cplusplus > 201703L
diff --git a/libstdc++-v3/include/bits/ostream.tcc b/libstdc++-v3/include/bits/ostream.tcc
index 802668235da..bde2a80a061 100644
--- a/libstdc++-v3/include/bits/ostream.tcc
+++ b/libstdc++-v3/include/bits/ostream.tcc
@@ -308,10 +308,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s)
+ operator<<(basic_ostream<_CharT, _Traits>& __out_, const char* __s)
{
if (!__s)
- __out.setstate(ios_base::badbit);
+ __out_.setstate(ios_base::badbit);
else
{
// _GLIBCXX_RESOLVE_LIB_DEFECTS
@@ -329,18 +329,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_CharT *__ws = __pg.__get();
for (size_t __i = 0; __i < __clen; ++__i)
- __ws[__i] = __out.widen(__s[__i]);
- __ostream_insert(__out, __ws, __clen);
+ __ws[__i] = __out_.widen(__s[__i]);
+ __ostream_insert(__out_, __ws, __clen);
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __out._M_setstate(ios_base::badbit);
+ __out_._M_setstate(ios_base::badbit);
__throw_exception_again;
}
__catch(...)
- { __out._M_setstate(ios_base::badbit); }
+ { __out_._M_setstate(ios_base::badbit); }
}
- return __out;
+ return __out_;
}
// Inhibit implicit instantiations for required instantiations,
diff --git a/libstdc++-v3/include/bits/ostream_insert.h b/libstdc++-v3/include/bits/ostream_insert.h
index a512283502e..ccae2b00686 100644
--- a/libstdc++-v3/include/bits/ostream_insert.h
+++ b/libstdc++-v3/include/bits/ostream_insert.h
@@ -49,31 +49,31 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits>
inline void
- __ostream_write(basic_ostream<_CharT, _Traits>& __out,
+ __ostream_write(basic_ostream<_CharT, _Traits>& __out_,
const _CharT* __s, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
- const streamsize __put = __out.rdbuf()->sputn(__s, __n);
+ const streamsize __put = __out_.rdbuf()->sputn(__s, __n);
if (__put != __n)
- __out.setstate(__ios_base::badbit);
+ __out_.setstate(__ios_base::badbit);
}
template<typename _CharT, typename _Traits>
inline void
- __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n)
+ __ostream_fill(basic_ostream<_CharT, _Traits>& __out_, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
- const _CharT __c = __out.fill();
+ const _CharT __c = __out_.fill();
for (; __n > 0; --__n)
{
- const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c);
+ const typename _Traits::int_type __put = __out_.rdbuf()->sputc(__c);
if (_Traits::eq_int_type(__put, _Traits::eof()))
{
- __out.setstate(__ios_base::badbit);
+ __out_.setstate(__ios_base::badbit);
break;
}
}
@@ -81,43 +81,43 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>&
- __ostream_insert(basic_ostream<_CharT, _Traits>& __out,
+ __ostream_insert(basic_ostream<_CharT, _Traits>& __out_,
const _CharT* __s, streamsize __n)
{
typedef basic_ostream<_CharT, _Traits> __ostream_type;
typedef typename __ostream_type::ios_base __ios_base;
- typename __ostream_type::sentry __cerb(__out);
+ typename __ostream_type::sentry __cerb(__out_);
if (__cerb)
{
__try
{
- const streamsize __w = __out.width();
+ const streamsize __w = __out_.width();
if (__w > __n)
{
- const bool __left = ((__out.flags()
+ const bool __left = ((__out_.flags()
& __ios_base::adjustfield)
== __ios_base::left);
if (!__left)
- __ostream_fill(__out, __w - __n);
- if (__out.good())
- __ostream_write(__out, __s, __n);
- if (__left && __out.good())
- __ostream_fill(__out, __w - __n);
+ __ostream_fill(__out_, __w - __n);
+ if (__out_.good())
+ __ostream_write(__out_, __s, __n);
+ if (__left && __out_.good())
+ __ostream_fill(__out_, __w - __n);
}
else
- __ostream_write(__out, __s, __n);
- __out.width(0);
+ __ostream_write(__out_, __s, __n);
+ __out_.width(0);
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __out._M_setstate(__ios_base::badbit);
+ __out_._M_setstate(__ios_base::badbit);
__throw_exception_again;
}
__catch(...)
- { __out._M_setstate(__ios_base::badbit); }
+ { __out_._M_setstate(__ios_base::badbit); }
}
- return __out;
+ return __out_;
}
// Inhibit implicit instantiations for required instantiations,
diff --git a/libstdc++-v3/include/bits/ostream_print.h b/libstdc++-v3/include/bits/ostream_print.h
index 0adf16d4fe3..f0115ab99a4 100644
--- a/libstdc++-v3/include/bits/ostream_print.h
+++ b/libstdc++-v3/include/bits/ostream_print.h
@@ -63,11 +63,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
__format::_Str_sink<char> __buf;
std::vformat_to(__buf.out(), __os.getloc(), __fmt, __args);
- auto __out = __buf.view();
+ auto __out_ = __buf.view();
__try
{
- std::__ostream_write(__os, __out.data(), __out.size());
+ std::__ostream_write(__os, __out_.data(), __out_.size());
}
__catch(const __cxxabiv1::__forced_unwind&)
{
@@ -93,7 +93,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
__format::_Str_sink<char> __buf;
std::vformat_to(__buf.out(), __os.getloc(), __fmt, __args);
- auto __out = __buf._M_span();
+ auto __out_ = __buf._M_span();
void* __open_terminal(streambuf*);
error_code __write_to_terminal(void*, span<char>);
@@ -121,7 +121,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
if (__os.rdbuf()->pubsync() == -1)
__err = ios::badbit;
- else if (auto __e = __write_to_terminal(__term, __out))
+ else if (auto __e = __write_to_terminal(__term, __out_))
if (__e != std::make_error_code(errc::illegal_byte_sequence))
__err = ios::badbit;
}
@@ -141,7 +141,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Otherwise just insert the string as vprint_nonunicode does.
__try
{
- std::__ostream_write(__os, __out.data(), __out.size());
+ std::__ostream_write(__os, __out_.data(), __out_.size());
}
__catch(const __cxxabiv1::__forced_unwind&)
{
diff --git a/libstdc++-v3/include/bits/parse_numbers.h b/libstdc++-v3/include/bits/parse_numbers.h
index e88c88904e5..aab73e5e799 100644
--- a/libstdc++-v3/include/bits/parse_numbers.h
+++ b/libstdc++-v3/include/bits/parse_numbers.h
@@ -53,20 +53,20 @@ namespace __parse_int
template<unsigned _Base>
struct _Digit<_Base, '0'> : integral_constant<unsigned, 0>
{
- using __valid = true_type;
+ using __valid_ = true_type;
};
template<unsigned _Base>
struct _Digit<_Base, '1'> : integral_constant<unsigned, 1>
{
- using __valid = true_type;
+ using __valid_ = true_type;
};
template<unsigned _Base, unsigned _Val>
struct _Digit_impl : integral_constant<unsigned, _Val>
{
static_assert(_Base > _Val, "invalid digit");
- using __valid = true_type;
+ using __valid_ = true_type;
};
template<unsigned _Base>
@@ -153,7 +153,7 @@ namespace __parse_int
template<unsigned _Base>
struct _Digit<_Base, '\''> : integral_constant<unsigned, 0>
{
- using __valid = false_type;
+ using __valid_ = false_type;
};
//------------------------------------------------------------------------------
@@ -165,7 +165,7 @@ namespace __parse_int
struct _Power_help
{
using __next = typename _Power_help<_Base, _Digs...>::type;
- using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
+ using __valid_digit = typename _Digit<_Base, _Dig>::__valid_;
using type
= __ull_constant<__next::value * (__valid_digit{} ? _Base : 1ULL)>;
};
@@ -173,7 +173,7 @@ namespace __parse_int
template<unsigned _Base, char _Dig>
struct _Power_help<_Base, _Dig>
{
- using __valid_digit = typename _Digit<_Base, _Dig>::__valid;
+ using __valid_digit = typename _Digit<_Base, _Dig>::__valid_;
using type = __ull_constant<__valid_digit::value>;
};
@@ -191,7 +191,7 @@ namespace __parse_int
struct _Number_help
{
using __digit = _Digit<_Base, _Dig>;
- using __valid_digit = typename __digit::__valid;
+ using __valid_digit = typename __digit::__valid_;
using __next = _Number_help<_Base,
__valid_digit::value ? _Pow / _Base : _Pow,
_Digs...>;
diff --git a/libstdc++-v3/include/bits/print.h b/libstdc++-v3/include/bits/print.h
index 20724844726..ef05c0c30db 100644
--- a/libstdc++-v3/include/bits/print.h
+++ b/libstdc++-v3/include/bits/print.h
@@ -286,8 +286,8 @@ namespace __format
// 4549. vprint_nonunicode_buffered ignores its stream parameter
__format::_Str_sink<char> __buf;
std::vformat_to(__buf.out(), __fmt, __args);
- auto __out = __buf.view();
- if (std::fwrite(__out.data(), 1, __out.size(), __stream) != __out.size())
+ auto __out_ = __buf.view();
+ if (std::fwrite(__out_.data(), 1, __out_.size(), __stream) != __out_.size())
__throw_system_error(EIO);
}
@@ -302,7 +302,7 @@ namespace __format
#else
__format::_Str_sink<char> __buf;
std::vformat_to(__buf.out(), __fmt, __args);
- auto __out = __buf._M_span();
+ auto __out_ = __buf._M_span();
void* __open_terminal(FILE*);
error_code __write_to_terminal(void*, span<char>);
@@ -312,7 +312,7 @@ namespace __format
error_code __e;
if (!std::fflush(__stream))
{
- __e = __write_to_terminal(__term, __out);
+ __e = __write_to_terminal(__term, __out_);
if (!__e)
return;
if (__e == std::make_error_code(errc::illegal_byte_sequence))
@@ -324,7 +324,7 @@ namespace __format
}
// Otherwise just write the string to the file.
- if (std::fwrite(__out.data(), 1, __out.size(), __stream) != __out.size())
+ if (std::fwrite(__out_.data(), 1, __out_.size(), __stream) != __out_.size())
__throw_system_error(EIO);
#endif
}
diff --git a/libstdc++-v3/include/bits/random.tcc b/libstdc++-v3/include/bits/random.tcc
index a8fab79961d..a6eade66bb6 100644
--- a/libstdc++-v3/include/bits/random.tcc
+++ b/libstdc++-v3/include/bits/random.tcc
@@ -846,16 +846,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
shuffle_order_engine<_RandomNumberEngine, __k>::
operator()()
{
- constexpr result_type __range = max() - min();
+ constexpr result_type __range_ = max() - min();
size_t __j = __k;
const result_type __y = _M_y - min();
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wc++17-extensions" // if constexpr
// Avoid using slower long double arithmetic if possible.
- if constexpr (__detail::__p1_representable_as_double(__range))
- __j *= __y / (__range + 1.0);
+ if constexpr (__detail::__p1_representable_as_double(__range_))
+ __j *= __y / (__range_ + 1.0);
else
- __j *= __y / (__range + 1.0L);
+ __j *= __y / (__range_ + 1.0L);
#pragma GCC diagnostic pop
_M_y = _M_v[__j];
_M_v[__j] = _M_b();
@@ -1087,9 +1087,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
__aurng(__urng);
- auto __range = __p.b() - __p.a();
+ auto __range_ = __p.b() - __p.a();
while (__f != __t)
- *__f++ = __aurng() * __range + __p.a();
+ *__f++ = __aurng() * __range_ + __p.a();
}
template<typename _RealType, typename _CharT, typename _Traits>
@@ -2987,18 +2987,18 @@ namespace __detail
template<typename _InputIterator, typename _RealType>
bool
__load_first2(_InputIterator& __first, _InputIterator __last,
- _RealType* __out)
+ _RealType* __out_)
{
if (__first == __last)
return false;
- *__out = *__first;
+ *__out_ = *__first;
++__first;
if (__first == __last)
return false;
- ++__out;
- *__out = *__first;
+ ++__out_;
+ *__out_ = *__first;
++__first;
return true;
}
@@ -3797,10 +3797,10 @@ namespace __detail
template <> const bool __is_rand_dist_float_v<long double> = true;
#endif
- // Note, this works even when (__range + 1) overflows:
+ // Note, this works even when (__range_ + 1) overflows:
template <typename _Rng>
- constexpr bool __is_power_of_2_less_1(_Rng __range)
- { return ((__range + 1) & __range) == 0; };
+ constexpr bool __is_power_of_2_less_1(_Rng __range_)
+ { return ((__range_ + 1) & __range_) == 0; };
_GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2)
/** Produce a random floating-point value in the range [0..1)
diff --git a/libstdc++-v3/include/bits/ranges_algo.h b/libstdc++-v3/include/bits/ranges_algo.h
index 4330d3e70b8..a6f80a853db 100644
--- a/libstdc++-v3/include/bits/ranges_algo.h
+++ b/libstdc++-v3/include/bits/ranges_algo.h
@@ -1840,7 +1840,7 @@ namespace ranges
&& indirectly_copyable<_Iter, _Out>
&& uniform_random_bit_generator<remove_reference_t<_Gen>>
_Out
- operator()(_Iter __first, _Sent __last, _Out __out,
+ operator()(_Iter __first, _Sent __last, _Out __out_,
iter_difference_t<_Iter> __n, _Gen&& __g) const
{
// FIXME: Correctly handle integer-class difference types.
@@ -1853,7 +1853,7 @@ namespace ranges
using __uc_type = common_type_t<decltype(__g()), _USize>;
if (__first == __last)
- return __out;
+ return __out_;
__distrib_type __d{};
_Size __unsampled_sz = ranges::distance(__first, __last);
@@ -1875,8 +1875,8 @@ namespace ranges
--__unsampled_sz;
if (__p.first < __n)
{
- *__out = *__first;
- ++__out;
+ *__out_ = *__first;
+ ++__out_;
--__n;
}
@@ -1887,8 +1887,8 @@ namespace ranges
--__unsampled_sz;
if (__p.second < __n)
{
- *__out = *__first;
- ++__out;
+ *__out_ = *__first;
+ ++__out_;
--__n;
}
@@ -1901,11 +1901,11 @@ namespace ranges
for (; __n != 0; ++__first)
if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
{
- *__out = *__first;
- ++__out;
+ *__out_ = *__first;
+ ++__out_;
--__n;
}
- return __out;
+ return __out_;
}
else
{
@@ -1916,7 +1916,7 @@ namespace ranges
iter_difference_t<_Iter> __sample_sz = 0;
while (__first != __last && __sample_sz != __n)
{
- __out[__sample_sz++] = *__first;
+ __out_[__sample_sz++] = *__first;
++__first;
}
for (auto __pop_sz = __sample_sz; __first != __last;
@@ -1924,9 +1924,9 @@ namespace ranges
{
const auto __k = __d(__g, __param_type{0, __pop_sz});
if (__k < __n)
- __out[__k] = *__first;
+ __out_[__k] = *__first;
}
- return __out + iter_difference_t<_Out>(__sample_sz);
+ return __out_ + iter_difference_t<_Out>(__sample_sz);
}
}
@@ -1935,11 +1935,11 @@ namespace ranges
&& indirectly_copyable<iterator_t<_Range>, _Out>
&& uniform_random_bit_generator<remove_reference_t<_Gen>>
_Out
- operator()(_Range&& __r, _Out __out,
+ operator()(_Range&& __r, _Out __out_,
range_difference_t<_Range> __n, _Gen&& __g) const
{
return (*this)(ranges::begin(__r), ranges::end(__r),
- std::move(__out), __n,
+ std::move(__out_), __n,
std::forward<_Gen>(__g));
}
};
@@ -2848,11 +2848,11 @@ namespace ranges
projected<iterator_t<_Range2>, _Proj2>>
constexpr partial_sort_copy_result<borrowed_iterator_t<_Range1>,
borrowed_iterator_t<_Range2>>
- operator()(_Range1&& __r, _Range2&& __out, _Comp __comp = {},
+ operator()(_Range1&& __r, _Range2&& __out_, _Comp __comp = {},
_Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const
{
return (*this)(ranges::begin(__r), ranges::end(__r),
- ranges::begin(__out), ranges::end(__out),
+ ranges::begin(__out_), ranges::end(__out_),
std::move(__comp),
std::move(__proj1), std::move(__proj2));
}
diff --git a/libstdc++-v3/include/bits/ranges_algobase.h b/libstdc++-v3/include/bits/ranges_algobase.h
index 84a62820ab4..ada02718e3f 100644
--- a/libstdc++-v3/include/bits/ranges_algobase.h
+++ b/libstdc++-v3/include/bits/ranges_algobase.h
@@ -193,12 +193,12 @@ namespace __detail
template<bool _IsMove, typename _OutIter, typename _InIter>
[[__gnu__::__always_inline__]]
constexpr void
- __assign_one(_OutIter& __out, _InIter& __in)
+ __assign_one(_OutIter& __out_, _InIter& __in_)
{
if constexpr (_IsMove)
- *__out = ranges::iter_move(__in);
+ *__out_ = ranges::iter_move(__in_);
else
- *__out = *__in;
+ *__out_ = *__in_;
}
} // namespace __detail
@@ -264,34 +264,34 @@ namespace __detail
using __detail::__is_normal_iterator;
if constexpr (__is_move_iterator<_Iter> && same_as<_Iter, _Sent>)
{
- auto [__in, __out]
+ auto [__in_, __out_]
= ranges::__copy_or_move<true>(std::move(__first).base(),
std::move(__last).base(),
std::move(__result));
- return {move_iterator{std::move(__in)}, std::move(__out)};
+ return {move_iterator{std::move(__in_)}, std::move(__out_)};
}
else if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
&& __is_reverse_iterator<_Out>)
{
- auto [__in,__out]
+ auto [__in_,__out_]
= ranges::__copy_or_move_backward<_IsMove>(std::move(__last).base(),
std::move(__first).base(),
std::move(__result).base());
- return {reverse_iterator{std::move(__in)},
- reverse_iterator{std::move(__out)}};
+ return {reverse_iterator{std::move(__in_)},
+ reverse_iterator{std::move(__out_)}};
}
else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
{
- auto [__in,__out]
+ auto [__in_,__out_]
= ranges::__copy_or_move<_IsMove>(__first.base(), __last.base(),
std::move(__result));
- return {decltype(__first){__in}, std::move(__out)};
+ return {decltype(__first){__in_}, std::move(__out_)};
}
else if constexpr (__is_normal_iterator<_Out>)
{
- auto [__in,__out]
+ auto [__in_,__out_]
= ranges::__copy_or_move<_IsMove>(std::move(__first), __last, __result.base());
- return {std::move(__in), decltype(__result){__out}};
+ return {std::move(__in_), decltype(__result){__out_}};
}
else if constexpr (sized_sentinel_for<_Sent, _Iter>)
{
@@ -398,28 +398,28 @@ namespace __detail
if constexpr (__is_reverse_iterator<_Iter> && same_as<_Iter, _Sent>
&& __is_reverse_iterator<_Out>)
{
- auto [__in,__out]
+ auto [__in_,__out_]
= ranges::__copy_or_move<_IsMove>(std::move(__last).base(),
std::move(__first).base(),
std::move(__result).base());
- return {reverse_iterator{std::move(__in)},
- reverse_iterator{std::move(__out)}};
+ return {reverse_iterator{std::move(__in_)},
+ reverse_iterator{std::move(__out_)}};
}
else if constexpr (__is_normal_iterator<_Iter> && same_as<_Iter, _Sent>)
{
- auto [__in,__out]
+ auto [__in_,__out_]
= ranges::__copy_or_move_backward<_IsMove>(__first.base(),
__last.base(),
std::move(__result));
- return {decltype(__first){__in}, std::move(__out)};
+ return {decltype(__first){__in_}, std::move(__out_)};
}
else if constexpr (__is_normal_iterator<_Out>)
{
- auto [__in,__out]
+ auto [__in_,__out_]
= ranges::__copy_or_move_backward<_IsMove>(std::move(__first),
std::move(__last),
__result.base());
- return {std::move(__in), decltype(__result){__out}};
+ return {std::move(__in_), decltype(__result){__out_}};
}
else if constexpr (sized_sentinel_for<_Sent, _Iter>)
{
diff --git a/libstdc++-v3/include/bits/ranges_base.h b/libstdc++-v3/include/bits/ranges_base.h
index ce1c40fc17f..f33d9694ffd 100644
--- a/libstdc++-v3/include/bits/ranges_base.h
+++ b/libstdc++-v3/include/bits/ranges_base.h
@@ -899,39 +899,39 @@ namespace ranges
template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
constexpr void
- operator()(_It& __it, _Sent __bound) const
+ operator()(_It& __it, _Sent __bound_) const
{
if constexpr (assignable_from<_It&, _Sent>)
- __it = std::move(__bound);
+ __it = std::move(__bound_);
else if constexpr (sized_sentinel_for<_Sent, _It>)
- (*this)(__it, __bound - __it);
+ (*this)(__it, __bound_ - __it);
else
{
- while (__it != __bound)
+ while (__it != __bound_)
++__it;
}
}
template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
constexpr iter_difference_t<_It>
- operator()(_It& __it, iter_difference_t<_It> __n, _Sent __bound) const
+ operator()(_It& __it, iter_difference_t<_It> __n, _Sent __bound_) const
{
if constexpr (sized_sentinel_for<_Sent, _It>)
{
- const iter_difference_t<_It> __diff = __bound - __it;
+ const iter_difference_t<_It> __diff = __bound_ - __it;
if (__diff == 0)
{
// inline any possible side effects of advance(it, bound)
if constexpr (assignable_from<_It&, _Sent>)
- __it = std::move(__bound);
+ __it = std::move(__bound_);
else if constexpr (random_access_iterator<_It>)
__it += iter_difference_t<_It>(0);
return __n;
}
else if (__diff > 0 ? __n >= __diff : __n <= __diff)
{
- (*this)(__it, __bound);
+ (*this)(__it, __bound_);
return __n - __diff;
}
else if (__n != 0) [[likely]]
@@ -950,7 +950,7 @@ namespace ranges
return 0;
}
}
- else if (__n == 0 || __it == __bound)
+ else if (__n == 0 || __it == __bound_)
return __n;
else if (__n > 0)
{
@@ -960,7 +960,7 @@ namespace ranges
++__it;
++__m;
}
- while (__m != __n && __it != __bound);
+ while (__m != __n && __it != __bound_);
return __n - __m;
}
else if constexpr (bidirectional_iterator<_It> && same_as<_It, _Sent>)
@@ -971,7 +971,7 @@ namespace ranges
--__it;
--__m;
}
- while (__m != __n && __it != __bound);
+ while (__m != __n && __it != __bound_);
return __n - __m;
}
else
@@ -1057,18 +1057,18 @@ namespace ranges
template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
[[nodiscard, __gnu__::__always_inline__]]
constexpr _It
- operator()(_It __x, _Sent __bound) const
+ operator()(_It __x, _Sent __bound_) const
{
- ranges::advance(__x, __bound);
+ ranges::advance(__x, __bound_);
return __x;
}
template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
[[nodiscard, __gnu__::__always_inline__]]
constexpr _It
- operator()(_It __x, iter_difference_t<_It> __n, _Sent __bound) const
+ operator()(_It __x, iter_difference_t<_It> __n, _Sent __bound_) const
{
- ranges::advance(__x, __n, __bound);
+ ranges::advance(__x, __n, __bound_);
return __x;
}
@@ -1100,9 +1100,9 @@ namespace ranges
template<bidirectional_iterator _It>
[[nodiscard, __gnu__::__always_inline__]]
constexpr _It
- operator()(_It __x, iter_difference_t<_It> __n, _It __bound) const
+ operator()(_It __x, iter_difference_t<_It> __n, _It __bound_) const
{
- ranges::advance(__x, -__n, __bound);
+ ranges::advance(__x, -__n, __bound_);
return __x;
}
diff --git a/libstdc++-v3/include/bits/ranges_uninitialized.h b/libstdc++-v3/include/bits/ranges_uninitialized.h
index f7845abd3f3..b94ac4e029b 100644
--- a/libstdc++-v3/include/bits/ranges_uninitialized.h
+++ b/libstdc++-v3/include/bits/ranges_uninitialized.h
@@ -380,10 +380,10 @@ namespace ranges
auto __d = __ilast - __ifirst;
if (auto __d2 = __olast - __ofirst; __d2 < __d)
__d = static_cast<iter_difference_t<_Iter>>(__d2);
- auto [__in, __out]
+ auto [__in_, __out_]
= ranges::copy_n(std::make_move_iterator(std::move(__ifirst)),
__d, __ofirst);
- return {std::move(__in).base(), __out};
+ return {std::move(__in_).base(), __out_};
}
else
{
@@ -435,10 +435,10 @@ namespace ranges
{
if (auto __d = __olast - __ofirst; __d < __n)
__n = static_cast<iter_difference_t<_Iter>>(__d);
- auto [__in, __out]
+ auto [__in_, __out_]
= ranges::copy_n(std::make_move_iterator(std::move(__ifirst)),
__n, __ofirst);
- return {std::move(__in).base(), __out};
+ return {std::move(__in_).base(), __out_};
}
else
{
diff --git a/libstdc++-v3/include/bits/regex.h b/libstdc++-v3/include/bits/regex.h
index 0e815ca086e..8093239b5e9 100644
--- a/libstdc++-v3/include/bits/regex.h
+++ b/libstdc++-v3/include/bits/regex.h
@@ -2051,7 +2051,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
*/
template<typename _Out_iter>
_Out_iter
- format(_Out_iter __out, const char_type* __fmt_first,
+ format(_Out_iter __out_, const char_type* __fmt_first,
const char_type* __fmt_last,
match_flag_type __flags = regex_constants::format_default) const;
@@ -2060,10 +2060,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
*/
template<typename _Out_iter, typename _St, typename _Sa>
_Out_iter
- format(_Out_iter __out, const basic_string<char_type, _St, _Sa>& __fmt,
+ format(_Out_iter __out_, const basic_string<char_type, _St, _Sa>& __fmt,
match_flag_type __flags = regex_constants::format_default) const
{
- return format(__out, __fmt.data(), __fmt.data() + __fmt.size(),
+ return format(__out_, __fmt.data(), __fmt.data() + __fmt.size(),
__flags);
}
@@ -2572,7 +2572,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
template<typename _Out_iter, typename _Bi_iter,
typename _Rx_traits, typename _Ch_type>
_Out_iter
- __regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+ __regex_replace(_Out_iter __out_, _Bi_iter __first, _Bi_iter __last,
const basic_regex<_Ch_type, _Rx_traits>& __e,
const _Ch_type* __fmt, size_t __len,
regex_constants::match_flag_type __flags);
@@ -2581,53 +2581,53 @@ _GLIBCXX_END_NAMESPACE_CXX11
/**
* @brief Search for a regular expression within a range for multiple times,
and replace the matched parts through filling a format string.
- * @param __out [OUT] The output iterator.
+ * @param __out_ [OUT] The output iterator.
* @param __first [IN] The start of the string to search.
* @param __last [IN] One-past-the-end of the string to search.
* @param __e [IN] The regular expression to search for.
* @param __fmt [IN] The format string.
* @param __flags [IN] Search and replace policy flags.
*
- * @returns __out
+ * @returns __out_
* @throws an exception of type regex_error.
*/
template<typename _Out_iter, typename _Bi_iter,
typename _Rx_traits, typename _Ch_type,
typename _St, typename _Sa>
inline _Out_iter
- regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+ regex_replace(_Out_iter __out_, _Bi_iter __first, _Bi_iter __last,
const basic_regex<_Ch_type, _Rx_traits>& __e,
const basic_string<_Ch_type, _St, _Sa>& __fmt,
regex_constants::match_flag_type __flags
= regex_constants::match_default)
{
- return std::__regex_replace(__out, __first, __last, __e, __fmt.c_str(),
+ return std::__regex_replace(__out_, __first, __last, __e, __fmt.c_str(),
__fmt.length(), __flags);
}
/**
* @brief Search for a regular expression within a range for multiple times,
and replace the matched parts through filling a format C-string.
- * @param __out [OUT] The output iterator.
+ * @param __out_ [OUT] The output iterator.
* @param __first [IN] The start of the string to search.
* @param __last [IN] One-past-the-end of the string to search.
* @param __e [IN] The regular expression to search for.
* @param __fmt [IN] The format C-string.
* @param __flags [IN] Search and replace policy flags.
*
- * @returns __out
+ * @returns __out_
* @throws an exception of type regex_error.
*/
template<typename _Out_iter, typename _Bi_iter,
typename _Rx_traits, typename _Ch_type>
_Out_iter
- regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+ regex_replace(_Out_iter __out_, _Bi_iter __first, _Bi_iter __last,
const basic_regex<_Ch_type, _Rx_traits>& __e,
const _Ch_type* __fmt,
regex_constants::match_flag_type __flags
= regex_constants::match_default)
{
- return std::__regex_replace(__out, __first, __last, __e, __fmt,
+ return std::__regex_replace(__out_, __first, __last, __e, __fmt,
char_traits<_Ch_type>::length(__fmt),
__flags);
}
diff --git a/libstdc++-v3/include/bits/regex.tcc b/libstdc++-v3/include/bits/regex.tcc
index 2e784353769..460f9553d14 100644
--- a/libstdc++-v3/include/bits/regex.tcc
+++ b/libstdc++-v3/include/bits/regex.tcc
@@ -79,22 +79,22 @@ namespace __detail
for (auto& __it : __res)
if (!__it.matched)
__it.first = __it.second = __e;
- auto& __pre = __m._M_prefix();
+ auto& __pre_ = __m._M_prefix();
auto& __suf = __m._M_suffix();
if (__match_mode)
{
- __pre.matched = false;
- __pre.first = __s;
- __pre.second = __s;
+ __pre_.matched = false;
+ __pre_.first = __s;
+ __pre_.second = __s;
__suf.matched = false;
__suf.first = __e;
__suf.second = __e;
}
else
{
- __pre.first = __s;
- __pre.second = __res[0].first;
- __pre.matched = (__pre.first != __pre.second);
+ __pre_.first = __s;
+ __pre_.second = __res[0].first;
+ __pre_.matched = (__pre_.first != __pre_.second);
__suf.first = __res[0].second;
__suf.second = __e;
__suf.matched = (__suf.first != __suf.second);
@@ -452,7 +452,7 @@ namespace __detail
template<typename _Out_iter>
_Out_iter
match_results<_Bi_iter, _Alloc>::
- format(_Out_iter __out,
+ format(_Out_iter __out_,
const match_results<_Bi_iter, _Alloc>::char_type* __fmt_first,
const match_results<_Bi_iter, _Alloc>::char_type* __fmt_last,
match_flag_type __flags) const
@@ -467,7 +467,7 @@ namespace __detail
{
auto& __sub = (*this)[__idx];
if (__sub.matched)
- __out = std::copy(__sub.first, __sub.second, __out);
+ __out_ = std::copy(__sub.first, __sub.second, __out_);
};
if (__flags & regex_constants::format_sed)
@@ -481,7 +481,7 @@ namespace __detail
if (__fctyp.is(__ctype_type::digit, *__fmt_first))
__output(__traits.value(*__fmt_first, 10));
else
- *__out++ = *__fmt_first;
+ *__out_++ = *__fmt_first;
continue;
}
if (*__fmt_first == '\\')
@@ -494,10 +494,10 @@ namespace __detail
__output(0);
continue;
}
- *__out++ = *__fmt_first;
+ *__out_++ = *__fmt_first;
}
if (__escaping)
- *__out++ = '\\';
+ *__out_++ = '\\';
}
else
{
@@ -507,7 +507,7 @@ namespace __detail
if (__next == __fmt_last)
break;
- __out = std::copy(__fmt_first, __next, __out);
+ __out_ = std::copy(__fmt_first, __next, __out_);
auto __eat = [&](char __ch) -> bool
{
@@ -520,22 +520,22 @@ namespace __detail
};
if (++__next == __fmt_last)
- *__out++ = '$';
+ *__out_++ = '$';
else if (__eat('$'))
- *__out++ = '$';
+ *__out_++ = '$';
else if (__eat('&'))
__output(0);
else if (__eat('`'))
{
auto& __sub = _M_prefix();
if (__sub.matched)
- __out = std::copy(__sub.first, __sub.second, __out);
+ __out_ = std::copy(__sub.first, __sub.second, __out_);
}
else if (__eat('\''))
{
auto& __sub = _M_suffix();
if (__sub.matched)
- __out = std::copy(__sub.first, __sub.second, __out);
+ __out_ = std::copy(__sub.first, __sub.second, __out_);
}
else if (__fctyp.is(__ctype_type::digit, *__next))
{
@@ -550,18 +550,18 @@ namespace __detail
__output(__num);
}
else
- *__out++ = '$';
+ *__out_++ = '$';
__fmt_first = __next;
}
- __out = std::copy(__fmt_first, __fmt_last, __out);
+ __out_ = std::copy(__fmt_first, __fmt_last, __out_);
}
- return __out;
+ return __out_;
}
template<typename _Out_iter, typename _Bi_iter,
typename _Rx_traits, typename _Ch_type>
_Out_iter
- __regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+ __regex_replace(_Out_iter __out_, _Bi_iter __first, _Bi_iter __last,
const basic_regex<_Ch_type, _Rx_traits>& __e,
const _Ch_type* __fmt, size_t __len,
regex_constants::match_flag_type __flags)
@@ -572,7 +572,7 @@ namespace __detail
if (__i == __end)
{
if (!(__flags & regex_constants::format_no_copy))
- __out = std::copy(__first, __last, __out);
+ __out_ = std::copy(__first, __last, __out_);
}
else
{
@@ -580,17 +580,17 @@ namespace __detail
for (; __i != __end; ++__i)
{
if (!(__flags & regex_constants::format_no_copy))
- __out = std::copy(__i->prefix().first, __i->prefix().second,
- __out);
- __out = __i->format(__out, __fmt, __fmt + __len, __flags);
+ __out_ = std::copy(__i->prefix().first, __i->prefix().second,
+ __out_);
+ __out_ = __i->format(__out_, __fmt, __fmt + __len, __flags);
__last = __i->suffix();
if (__flags & regex_constants::format_first_only)
break;
}
if (!(__flags & regex_constants::format_no_copy))
- __out = std::copy(__last.first, __last.second, __out);
+ __out_ = std::copy(__last.first, __last.second, __out_);
}
- return __out;
+ return __out_;
}
template<typename _Bi_iter,
diff --git a/libstdc++-v3/include/bits/shared_ptr_atomic.h b/libstdc++-v3/include/bits/shared_ptr_atomic.h
index b8c9427d9ec..e9b166925a2 100644
--- a/libstdc++-v3/include/bits/shared_ptr_atomic.h
+++ b/libstdc++-v3/include/bits/shared_ptr_atomic.h
@@ -300,11 +300,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
shared_ptr<_Tp>* __v,
shared_ptr<_Tp> __w,
- memory_order __success,
+ memory_order __success_,
memory_order __failure)
{
return std::atomic_compare_exchange_strong_explicit(__p, __v,
- std::move(__w), __success, __failure);
+ std::move(__w), __success_, __failure);
}
template<typename _Tp>
@@ -357,11 +357,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p,
__shared_ptr<_Tp, _Lp>* __v,
__shared_ptr<_Tp, _Lp> __w,
- memory_order __success,
+ memory_order __success_,
memory_order __failure)
{
return std::atomic_compare_exchange_strong_explicit(__p, __v,
- std::move(__w), __success, __failure);
+ std::move(__w), __success_, __failure);
}
template<typename _Tp, _Lock_policy _Lp>
diff --git a/libstdc++-v3/include/bits/simd_details.h b/libstdc++-v3/include/bits/simd_details.h
index fb4edf5b076..468eb09164a 100644
--- a/libstdc++-v3/include/bits/simd_details.h
+++ b/libstdc++-v3/include/bits/simd_details.h
@@ -106,13 +106,13 @@ namespace simd
};
/** @internal
- * Return @p __in with only bits set that are set in any of @p __to_keep.
+ * Return @p __in_ with only bits set that are set in any of @p __to_keep.
*/
consteval _AbiVariant
- __filter_abi_variant(_AbiVariant __in, same_as<_AbiVariant> auto... __to_keep)
+ __filter_abi_variant(_AbiVariant __in_, same_as<_AbiVariant> auto... __to_keep)
{
using _Up = underlying_type_t<_AbiVariant>;
- return static_cast<_AbiVariant>(static_cast<_Up>(__in) & (static_cast<_Up>(__to_keep) | ...));
+ return static_cast<_AbiVariant>(static_cast<_Up>(__in_) & (static_cast<_Up>(__to_keep) | ...));
}
/** @internal
diff --git a/libstdc++-v3/include/bits/simd_vec.h b/libstdc++-v3/include/bits/simd_vec.h
index 6657587e4d4..5d5bdbecf8a 100644
--- a/libstdc++-v3/include/bits/simd_vec.h
+++ b/libstdc++-v3/include/bits/simd_vec.h
@@ -1212,10 +1212,10 @@ namespace simd
&& __explicitly_convertible_to<ranges::range_value_t<_Rg>, value_type>
[[__gnu__::__always_inline__]]
constexpr
- basic_vec(_Rg&& __range, flags<_Flags...> __flags = {})
- requires (ranges::size(__range) == _S_size)
+ basic_vec(_Rg&& __range_, flags<_Flags...> __flags = {})
+ requires (ranges::size(__range_) == _S_size)
: basic_vec(_LoadCtorTag(), __flags.template _S_adjust_pointer<basic_vec>(
- ranges::data(__range)))
+ ranges::data(__range_)))
{
static_assert(__loadstore_convertible_to<ranges::range_value_t<_Rg>, value_type,
_Flags...>);
@@ -2077,10 +2077,10 @@ namespace simd
&& __vectorizable<ranges::range_value_t<_Rg>>
&& __explicitly_convertible_to<ranges::range_value_t<_Rg>, value_type>
constexpr
- basic_vec(_Rg&& __range, flags<_Flags...> __flags = {})
- requires (ranges::size(__range) == _S_size)
+ basic_vec(_Rg&& __range_, flags<_Flags...> __flags = {})
+ requires (ranges::size(__range_) == _S_size)
: basic_vec(_LoadCtorTag(),
- __flags.template _S_adjust_pointer<basic_vec>(ranges::data(__range)))
+ __flags.template _S_adjust_pointer<basic_vec>(ranges::data(__range_)))
{
static_assert(__loadstore_convertible_to<ranges::range_value_t<_Rg>, value_type,
_Flags...>);
diff --git a/libstdc++-v3/include/bits/std_thread.h b/libstdc++-v3/include/bits/std_thread.h
index 7e529897998..4b7b6216208 100644
--- a/libstdc++-v3/include/bits/std_thread.h
+++ b/libstdc++-v3/include/bits/std_thread.h
@@ -122,7 +122,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<class _CharT, class _Traits>
friend basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __out, id __id);
+ operator<<(basic_ostream<_CharT, _Traits>& __out_, id __id);
#if __glibcxx_formatters
friend formatter<id, char>;
diff --git a/libstdc++-v3/include/bits/stl_algo.h b/libstdc++-v3/include/bits/stl_algo.h
index f15b3e4992f..1194f3fb106 100644
--- a/libstdc++-v3/include/bits/stl_algo.h
+++ b/libstdc++-v3/include/bits/stl_algo.h
@@ -5766,7 +5766,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
typename _Size, typename _UniformRandomBitGenerator>
_RandomAccessIterator
__sample(_InputIterator __first, _InputIterator __last, input_iterator_tag,
- _RandomAccessIterator __out, random_access_iterator_tag,
+ _RandomAccessIterator __out_, random_access_iterator_tag,
_Size __n, _UniformRandomBitGenerator&& __g)
{
using __distrib_type = uniform_int_distribution<_Size>;
@@ -5775,7 +5775,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
_Size __sample_sz = 0;
while (__first != __last && __sample_sz != __n)
{
- __out[__sample_sz++] = *__first;
+ __out_[__sample_sz++] = *__first;
++__first;
}
for (auto __pop_sz = __sample_sz; __first != __last;
@@ -5783,9 +5783,9 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
{
const auto __k = __d(__g, __param_type{0, __pop_sz});
if (__k < __n)
- __out[__k] = *__first;
+ __out_[__k] = *__first;
}
- return __out + __sample_sz;
+ return __out_ + __sample_sz;
}
/// Selection sampling algorithm.
@@ -5794,7 +5794,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
_OutputIterator
__sample(_ForwardIterator __first, _ForwardIterator __last,
forward_iterator_tag,
- _OutputIterator __out, _Cat,
+ _OutputIterator __out_, _Cat,
_Size __n, _UniformRandomBitGenerator&& __g)
{
using __distrib_type = uniform_int_distribution<_Size>;
@@ -5804,7 +5804,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
using __uc_type = common_type_t<typename _Gen::result_type, _USize>;
if (__first == __last)
- return __out;
+ return __out_;
__distrib_type __d{};
_Size __unsampled_sz = std::distance(__first, __last);
@@ -5826,7 +5826,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
--__unsampled_sz;
if (__p.first < __n)
{
- *__out++ = *__first;
+ *__out_++ = *__first;
--__n;
}
@@ -5837,7 +5837,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
--__unsampled_sz;
if (__p.second < __n)
{
- *__out++ = *__first;
+ *__out_++ = *__first;
--__n;
}
@@ -5850,10 +5850,10 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
for (; __n != 0; ++__first)
if (__d(__g, __param_type{0, --__unsampled_sz}) < __n)
{
- *__out++ = *__first;
+ *__out_++ = *__first;
--__n;
}
- return __out;
+ return __out_;
}
#endif // C++14
@@ -5863,7 +5863,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
typename _Distance, typename _UniformRandomBitGenerator>
_SampleIterator
sample(_PopulationIterator __first, _PopulationIterator __last,
- _SampleIterator __out, _Distance __n,
+ _SampleIterator __out_, _Distance __n,
_UniformRandomBitGenerator&& __g)
{
using __pop_cat
@@ -5882,7 +5882,7 @@ _GLIBCXX_BEGIN_NAMESPACE_ALGO
typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
return _GLIBCXX_STD_A::
- __sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
+ __sample(__first, __last, __pop_cat{}, __out_, __samp_cat{}, __d,
std::forward<_UniformRandomBitGenerator>(__g));
}
#endif // __glibcxx_sample
diff --git a/libstdc++-v3/include/bits/stl_algobase.h b/libstdc++-v3/include/bits/stl_algobase.h
index 1350736a8d8..d9afd65703e 100644
--- a/libstdc++-v3/include/bits/stl_algobase.h
+++ b/libstdc++-v3/include/bits/stl_algobase.h
@@ -395,14 +395,14 @@ _GLIBCXX_END_NAMESPACE_CONTAINER
template<bool _IsMove, typename _OutIter, typename _InIter>
__attribute__((__always_inline__)) _GLIBCXX20_CONSTEXPR
inline void
- __assign_one(_OutIter& __out, _InIter& __in)
+ __assign_one(_OutIter& __out_, _InIter& __in_)
{
#if __cplusplus >= 201103L
if constexpr (_IsMove)
- *__out = std::move(*__in);
+ *__out_ = std::move(*__in_);
else
#endif
- *__out = *__in;
+ *__out_ = *__in_;
}
template<bool _IsMove, typename _InIter, typename _Sent, typename _OutIter>
diff --git a/libstdc++-v3/include/bits/stl_pair.h b/libstdc++-v3/include/bits/stl_pair.h
index f08b2714a4f..3452d23f46c 100644
--- a/libstdc++-v3/include/bits/stl_pair.h
+++ b/libstdc++-v3/include/bits/stl_pair.h
@@ -103,19 +103,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
- get(pair<_Tp1, _Tp2>& __in) noexcept;
+ get(pair<_Tp1, _Tp2>& __in_) noexcept;
template<size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
- get(pair<_Tp1, _Tp2>&& __in) noexcept;
+ get(pair<_Tp1, _Tp2>&& __in_) noexcept;
template<size_t _Int, class _Tp1, class _Tp2>
constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
- get(const pair<_Tp1, _Tp2>& __in) noexcept;
+ get(const pair<_Tp1, _Tp2>& __in_) noexcept;
template<size_t _Int, class _Tp1, class _Tp2>
constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
- get(const pair<_Tp1, _Tp2>&& __in) noexcept;
+ get(const pair<_Tp1, _Tp2>&& __in_) noexcept;
template<size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...>>&
@@ -1285,23 +1285,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
- get(pair<_Tp1, _Tp2>& __in) noexcept
- { return __pair_get<_Int>::__get(__in); }
+ get(pair<_Tp1, _Tp2>& __in_) noexcept
+ { return __pair_get<_Int>::__get(__in_); }
template<size_t _Int, class _Tp1, class _Tp2>
constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
- get(pair<_Tp1, _Tp2>&& __in) noexcept
- { return __pair_get<_Int>::__move_get(std::move(__in)); }
+ get(pair<_Tp1, _Tp2>&& __in_) noexcept
+ { return __pair_get<_Int>::__move_get(std::move(__in_)); }
template<size_t _Int, class _Tp1, class _Tp2>
constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
- get(const pair<_Tp1, _Tp2>& __in) noexcept
- { return __pair_get<_Int>::__const_get(__in); }
+ get(const pair<_Tp1, _Tp2>& __in_) noexcept
+ { return __pair_get<_Int>::__const_get(__in_); }
template<size_t _Int, class _Tp1, class _Tp2>
constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
- get(const pair<_Tp1, _Tp2>&& __in) noexcept
- { return __pair_get<_Int>::__const_move_get(std::move(__in)); }
+ get(const pair<_Tp1, _Tp2>&& __in_) noexcept
+ { return __pair_get<_Int>::__const_move_get(std::move(__in_)); }
#ifdef __glibcxx_tuples_by_type // C++ >= 14
diff --git a/libstdc++-v3/include/bits/stl_uninitialized.h b/libstdc++-v3/include/bits/stl_uninitialized.h
index a8791a66ae8..d3769f495d4 100644
--- a/libstdc++-v3/include/bits/stl_uninitialized.h
+++ b/libstdc++-v3/include/bits/stl_uninitialized.h
@@ -1386,9 +1386,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
// Can't use memcpy. Wrap the pointer so that __relocate_a_1
// resolves to the non-trivial overload above.
- __gnu_cxx::__normal_iterator<_Tp*, void> __out(__result);
- __out = std::__relocate_a_1(__first, __last, __out, __alloc);
- return __out.base();
+ __gnu_cxx::__normal_iterator<_Tp*, void> __out_(__result);
+ __out_ = std::__relocate_a_1(__first, __last, __out_, __alloc);
+ return __out_.base();
}
#endif
__builtin_memcpy(__result, __first, __count * sizeof(_Tp));
diff --git a/libstdc++-v3/include/bits/unicode.h b/libstdc++-v3/include/bits/unicode.h
index 8f414f1091e..ed94d878a4c 100644
--- a/libstdc++-v3/include/bits/unicode.h
+++ b/libstdc++-v3/include/bits/unicode.h
@@ -1127,9 +1127,9 @@ inline namespace __v16_0_0
{
if (__s.empty()) [[unlikely]]
return 0;
- _Grapheme_cluster_view<basic_string_view<_CharT>> __gc(__s);
- auto __it = __gc.begin();
- const auto __end = __gc.end();
+ _Grapheme_cluster_view<basic_string_view<_CharT>> __gc_(__s);
+ auto __it = __gc_.begin();
+ const auto __end = __gc_.end();
size_t __n = __it.width();
while (++__it != __end)
__n += __it.width();
@@ -1145,9 +1145,9 @@ inline namespace __v16_0_0
if (__s.empty()) [[unlikely]]
return 0;
- _Grapheme_cluster_view<basic_string_view<_CharT>> __gc(__s);
- auto __it = __gc.begin();
- const auto __end = __gc.end();
+ _Grapheme_cluster_view<basic_string_view<_CharT>> __gc_(__s);
+ auto __it = __gc_.begin();
+ const auto __end = __gc_.end();
size_t __n = __it.width();
if (__n > __max)
{
diff --git a/libstdc++-v3/include/bits/uniform_int_dist.h b/libstdc++-v3/include/bits/uniform_int_dist.h
index 9c5514c7c13..e47441e9c95 100644
--- a/libstdc++-v3/include/bits/uniform_int_dist.h
+++ b/libstdc++-v3/include/bits/uniform_int_dist.h
@@ -250,11 +250,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
param_type _M_param;
// Lemire's nearly divisionless algorithm.
- // Returns an unbiased random number from __g downscaled to [0,__range)
+ // Returns an unbiased random number from __g downscaled to [0,__range_)
// using an unsigned type _Wp twice as wide as unsigned type _Up.
template<typename _Wp, typename _Urbg, typename _Up>
static _Up
- _S_nd(_Urbg& __g, _Up __range)
+ _S_nd(_Urbg& __g, _Up __range_)
{
using _Up_traits = __gnu_cxx::__int_traits<_Up>;
using _Wp_traits = __gnu_cxx::__int_traits<_Wp>;
@@ -266,14 +266,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// reference: Fast Random Integer Generation in an Interval
// ACM Transactions on Modeling and Computer Simulation 29 (1), 2019
// https://arxiv.org/abs/1805.10941
- _Wp __product = _Wp(__g()) * _Wp(__range);
+ _Wp __product = _Wp(__g()) * _Wp(__range_);
_Up __low = _Up(__product);
- if (__low < __range)
+ if (__low < __range_)
{
- _Up __threshold = -__range % __range;
+ _Up __threshold = -__range_ % __range_;
while (__low < __threshold)
{
- __product = _Wp(__g()) * _Wp(__range);
+ __product = _Wp(__g()) * _Wp(__range_);
__low = _Up(__product);
}
}
diff --git a/libstdc++-v3/include/experimental/algorithm b/libstdc++-v3/include/experimental/algorithm
index f197c4cb29e..9b0b042d0ad 100644
--- a/libstdc++-v3/include/experimental/algorithm
+++ b/libstdc++-v3/include/experimental/algorithm
@@ -63,7 +63,7 @@ inline namespace fundamentals_v2
typename _Distance, typename _UniformRandomNumberGenerator>
_SampleIterator
sample(_PopulationIterator __first, _PopulationIterator __last,
- _SampleIterator __out, _Distance __n,
+ _SampleIterator __out_, _Distance __n,
_UniformRandomNumberGenerator&& __g)
{
using __pop_cat = typename
@@ -82,7 +82,7 @@ inline namespace fundamentals_v2
typename iterator_traits<_PopulationIterator>::difference_type __d = __n;
return _GLIBCXX_STD_A::
- __sample(__first, __last, __pop_cat{}, __out, __samp_cat{}, __d,
+ __sample(__first, __last, __pop_cat{}, __out_, __samp_cat{}, __d,
std::forward<_UniformRandomNumberGenerator>(__g));
}
@@ -90,9 +90,9 @@ inline namespace fundamentals_v2
typename _Distance>
inline _SampleIterator
sample(_PopulationIterator __first, _PopulationIterator __last,
- _SampleIterator __out, _Distance __n)
+ _SampleIterator __out_, _Distance __n)
{
- return experimental::sample(__first, __last, __out, __n,
+ return experimental::sample(__first, __last, __out_, __n,
_S_randint_engine());
}
diff --git a/libstdc++-v3/include/experimental/bits/shared_ptr.h b/libstdc++-v3/include/experimental/bits/shared_ptr.h
index db6f890990c..357553e1996 100644
--- a/libstdc++-v3/include/experimental/bits/shared_ptr.h
+++ b/libstdc++-v3/include/experimental/bits/shared_ptr.h
@@ -601,20 +601,20 @@ inline namespace fundamentals_v2
bool atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
shared_ptr<_Tp>* __v,
shared_ptr<_Tp> __w,
- memory_order __success,
+ memory_order __success_,
memory_order __failure)
{ return std::atomic_compare_exchange_weak_explicit<_Tp>(__p, __v, __w,
- __success,
+ __success_,
__failure); }
template<typename _Tp>
bool atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
shared_ptr<_Tp>* __v,
shared_ptr<_Tp> __w,
- memory_order __success,
+ memory_order __success_,
memory_order __failure)
{ return std::atomic_compare_exchange_strong_explicit<_Tp>(__p, __v, __w,
- __success,
+ __success_,
__failure); }
//enable_shared_from_this
diff --git a/libstdc++-v3/include/experimental/bits/simd.h b/libstdc++-v3/include/experimental/bits/simd.h
index 5b3f622c6ea..2a7ce2c7da1 100644
--- a/libstdc++-v3/include/experimental/bits/simd.h
+++ b/libstdc++-v3/include/experimental/bits/simd.h
@@ -2295,20 +2295,20 @@ template <int _Offset,
typename _TVT = _VectorTraits<_Tp>,
typename _R = __vector_type_t<typename _TVT::value_type, _TVT::_S_full_size / _SplitBy>>
_GLIBCXX_SIMD_INTRINSIC constexpr _R
- __extract(_Tp __in)
+ __extract(_Tp __in_)
{
using value_type = typename _TVT::value_type;
#if _GLIBCXX_SIMD_X86INTRIN // {{{
if constexpr (sizeof(_Tp) == 64 && _SplitBy == 4 && _Offset > 0)
{
if constexpr (__have_avx512dq && is_same_v<double, value_type>)
- return _mm512_extractf64x2_pd(__to_intrin(__in), _Offset);
+ return _mm512_extractf64x2_pd(__to_intrin(__in_), _Offset);
else if constexpr (is_floating_point_v<value_type>)
return __vector_bitcast<value_type>(
- _mm512_extractf32x4_ps(__intrin_bitcast<__m512>(__in), _Offset));
+ _mm512_extractf32x4_ps(__intrin_bitcast<__m512>(__in_), _Offset));
else
return reinterpret_cast<_R>(
- _mm512_extracti32x4_epi32(__intrin_bitcast<__m512i>(__in),
+ _mm512_extracti32x4_epi32(__intrin_bitcast<__m512i>(__in_),
_Offset));
}
else
@@ -2321,12 +2321,12 @@ template <int _Offset,
static_assert(sizeof(_R) % sizeof(_W) == 0);
constexpr int __return_width = sizeof(_R) / sizeof(_W);
using _Up = __vector_type_t<_W, __return_width>;
- const auto __x = __vector_bitcast<_W>(__in);
+ const auto __x = __vector_bitcast<_W>(__in_);
#else
constexpr int __return_width = _TVT::_S_full_size / _SplitBy;
using _Up = _R;
const __vector_type_t<value_type, _TVT::_S_full_size>& __x
- = __in; // only needed for _Tp = _SimdWrapper<value_type, _Np>
+ = __in_; // only needed for _Tp = _SimdWrapper<value_type, _Np>
#endif
constexpr int _O = _Offset * __return_width;
return __call_with_subscripts<__return_width, _O>(
diff --git a/libstdc++-v3/include/experimental/internet b/libstdc++-v3/include/experimental/internet
index 666b9759441..a0a9b328602 100644
--- a/libstdc++-v3/include/experimental/internet
+++ b/libstdc++-v3/include/experimental/internet
@@ -836,9 +836,9 @@ namespace ip
if (__p == nullptr)
return __make_address_v6(__str, nullptr, __ec);
char __buf[64];
- char* __out = __buf;
+ char* __out_ = __buf;
bool __skip_leading_zero = true;
- while (__str < __p && __out < std::end(__buf))
+ while (__str < __p && __out_ < std::end(__buf))
{
if (!__skip_leading_zero || *__str != '0')
{
@@ -846,18 +846,18 @@ namespace ip
__skip_leading_zero = true;
else
__skip_leading_zero = false;
- *__out = *__str;
+ *__out_ = *__str;
}
__str++;
}
- if (__out == std::end(__buf))
+ if (__out_ == std::end(__buf))
{
__ec = std::make_error_code(std::errc::invalid_argument);
return {};
}
else
{
- *__out = '\0';
+ *__out_ = '\0';
return __make_address_v6(__buf, __p + 1, __ec);
}
}
@@ -873,10 +873,10 @@ namespace ip
if (__pos == string::npos)
return __make_address_v6(__str.c_str(), nullptr, __ec);
char __buf[64];
- char* __out = __buf;
+ char* __out_ = __buf;
bool __skip_leading_zero = true;
size_t __n = 0;
- while (__n < __pos && __out < std::end(__buf))
+ while (__n < __pos && __out_ < std::end(__buf))
{
if (!__skip_leading_zero || __str[__n] != '0')
{
@@ -884,18 +884,18 @@ namespace ip
__skip_leading_zero = true;
else
__skip_leading_zero = false;
- *__out = __str[__n];
+ *__out_ = __str[__n];
}
__n++;
}
- if (__out == std::end(__buf))
+ if (__out_ == std::end(__buf))
{
__ec = std::make_error_code(std::errc::invalid_argument);
return {};
}
else
{
- *__out = '\0';
+ *__out_ = '\0';
return __make_address_v6(__buf, __str.c_str() + __pos + 1, __ec);
}
}
@@ -908,20 +908,20 @@ namespace ip
make_address_v6(string_view __str, error_code& __ec) noexcept
{
char __buf[64];
- char* __out = __buf;
+ char* __out_ = __buf;
char* __scope = nullptr;
bool __skip_leading_zero = true;
size_t __n = 0;
- while (__n < __str.length() && __out < std::end(__buf))
+ while (__n < __str.length() && __out_ < std::end(__buf))
{
if (__str[__n] == '%')
{
if (__scope)
- __out = std::end(__buf);
+ __out_ = std::end(__buf);
else
{
- *__out = '\0';
- __scope = ++__out;
+ *__out_ = '\0';
+ __scope = ++__out_;
__skip_leading_zero = true;
}
}
@@ -931,19 +931,19 @@ namespace ip
__skip_leading_zero = true;
else
__skip_leading_zero = false;
- *__out = __str[__n];
- __out++;
+ *__out_ = __str[__n];
+ __out_++;
}
__n++;
}
- if (__out == std::end(__buf))
+ if (__out_ == std::end(__buf))
{
__ec = std::make_error_code(std::errc::invalid_argument);
return {};
}
else
{
- *__out = '\0';
+ *__out_ = '\0';
return __make_address_v6(__buf, __scope, __ec);
}
}
diff --git a/libstdc++-v3/include/experimental/scope b/libstdc++-v3/include/experimental/scope
index 6e1d342e1b6..f82cebfb3e0 100644
--- a/libstdc++-v3/include/experimental/scope
+++ b/libstdc++-v3/include/experimental/scope
@@ -472,11 +472,11 @@ namespace experimental::inline fundamentals_v3
&& is_nothrow_constructible_v<decay_t<_Del2>, _Del2>);
template<typename _Res2, typename _Del2>
- unique_resource(_Res2&& __r, _Del2&& __d, _Dummy __noop)
+ unique_resource(_Res2&& __r, _Del2&& __d, _Dummy __noop_)
noexcept(is_nothrow_constructible_v<_Resrc, _Res2>
&& is_nothrow_constructible_v<_Del, _Del2>)
- : _M_res(std::forward<_Res2>(__r), __noop),
- _M_del(std::forward<_Del>(__d), __noop)
+ : _M_res(std::forward<_Res2>(__r), __noop_),
+ _M_del(std::forward<_Del>(__d), __noop_)
{ }
};
diff --git a/libstdc++-v3/include/ext/algorithm b/libstdc++-v3/include/ext/algorithm
index 3f23b5ffcff..6ce84051997 100644
--- a/libstdc++-v3/include/ext/algorithm
+++ b/libstdc++-v3/include/ext/algorithm
@@ -262,7 +262,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename _Distance>
_OutputIterator
random_sample_n(_ForwardIterator __first, _ForwardIterator __last,
- _OutputIterator __out, const _Distance __n)
+ _OutputIterator __out_, const _Distance __n)
{
// concept requirements
__glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
@@ -277,14 +277,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
if ((std::rand() % __remaining) < __m)
{
- *__out = *__first;
- ++__out;
+ *__out_ = *__first;
+ ++__out_;
--__m;
}
--__remaining;
++__first;
}
- return __out;
+ return __out_;
}
/**
@@ -296,7 +296,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typename _Distance, typename _RandomNumberGenerator>
_OutputIterator
random_sample_n(_ForwardIterator __first, _ForwardIterator __last,
- _OutputIterator __out, const _Distance __n,
+ _OutputIterator __out_, const _Distance __n,
_RandomNumberGenerator& __rand)
{
// concept requirements
@@ -314,44 +314,44 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{
if (__rand(__remaining) < __m)
{
- *__out = *__first;
- ++__out;
+ *__out_ = *__first;
+ ++__out_;
--__m;
}
--__remaining;
++__first;
}
- return __out;
+ return __out_;
}
template<typename _InputIterator, typename _RandomAccessIterator,
typename _Distance>
_RandomAccessIterator
__random_sample(_InputIterator __first, _InputIterator __last,
- _RandomAccessIterator __out,
+ _RandomAccessIterator __out_,
const _Distance __n)
{
_Distance __m = 0;
_Distance __t = __n;
for ( ; __first != __last && __m < __n; ++__m, ++__first)
- __out[__m] = *__first;
+ __out_[__m] = *__first;
while (__first != __last)
{
++__t;
_Distance __M = std::rand() % (__t);
if (__M < __n)
- __out[__M] = *__first;
+ __out_[__M] = *__first;
++__first;
}
- return __out + __m;
+ return __out_ + __m;
}
template<typename _InputIterator, typename _RandomAccessIterator,
typename _RandomNumberGenerator, typename _Distance>
_RandomAccessIterator
__random_sample(_InputIterator __first, _InputIterator __last,
- _RandomAccessIterator __out,
+ _RandomAccessIterator __out_,
_RandomNumberGenerator& __rand,
const _Distance __n)
{
@@ -362,17 +362,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Distance __m = 0;
_Distance __t = __n;
for ( ; __first != __last && __m < __n; ++__m, ++__first)
- __out[__m] = *__first;
+ __out_[__m] = *__first;
while (__first != __last)
{
++__t;
_Distance __M = __rand(__t);
if (__M < __n)
- __out[__M] = *__first;
+ __out_[__M] = *__first;
++__first;
}
- return __out + __m;
+ return __out_ + __m;
}
/**
diff --git a/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp b/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp
index 67bdc3c942f..37a81d49b79 100644
--- a/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp
+++ b/libstdc++-v3/include/ext/pb_ds/detail/debug_map_base.hpp
@@ -57,9 +57,9 @@ namespace __gnu_pbds
// Need std::pair ostream extractor.
template<typename _CharT, typename _Traits, typename _Tp1, typename _Tp2>
inline std::basic_ostream<_CharT, _Traits>&
- operator<<(std::basic_ostream<_CharT, _Traits>& __out,
+ operator<<(std::basic_ostream<_CharT, _Traits>& __out_,
const std::pair<_Tp1, _Tp2>& p)
- { return (__out << '(' << p.first << ',' << p.second << ')'); }
+ { return (__out_ << '(' << p.first << ',' << p.second << ')'); }
#define PB_DS_CLASS_T_DEC \
template<typename Key, typename Eq_Fn, typename Const_Key_Reference>
diff --git a/libstdc++-v3/include/ext/random.tcc b/libstdc++-v3/include/ext/random.tcc
index 86535397d3e..a9c0c7cad11 100644
--- a/libstdc++-v3/include/ext/random.tcc
+++ b/libstdc++-v3/include/ext/random.tcc
@@ -212,38 +212,38 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace {
template<size_t __shift>
- inline void __rshift(uint32_t *__out, const uint32_t *__in)
+ inline void __rshift(uint32_t *__out_, const uint32_t *__in_)
{
- uint64_t __th = ((static_cast<uint64_t>(__in[3]) << 32)
- | static_cast<uint64_t>(__in[2]));
- uint64_t __tl = ((static_cast<uint64_t>(__in[1]) << 32)
- | static_cast<uint64_t>(__in[0]));
+ uint64_t __th = ((static_cast<uint64_t>(__in_[3]) << 32)
+ | static_cast<uint64_t>(__in_[2]));
+ uint64_t __tl = ((static_cast<uint64_t>(__in_[1]) << 32)
+ | static_cast<uint64_t>(__in_[0]));
uint64_t __oh = __th >> (__shift * 8);
uint64_t __ol = __tl >> (__shift * 8);
__ol |= __th << (64 - __shift * 8);
- __out[1] = static_cast<uint32_t>(__ol >> 32);
- __out[0] = static_cast<uint32_t>(__ol);
- __out[3] = static_cast<uint32_t>(__oh >> 32);
- __out[2] = static_cast<uint32_t>(__oh);
+ __out_[1] = static_cast<uint32_t>(__ol >> 32);
+ __out_[0] = static_cast<uint32_t>(__ol);
+ __out_[3] = static_cast<uint32_t>(__oh >> 32);
+ __out_[2] = static_cast<uint32_t>(__oh);
}
template<size_t __shift>
- inline void __lshift(uint32_t *__out, const uint32_t *__in)
+ inline void __lshift(uint32_t *__out_, const uint32_t *__in_)
{
- uint64_t __th = ((static_cast<uint64_t>(__in[3]) << 32)
- | static_cast<uint64_t>(__in[2]));
- uint64_t __tl = ((static_cast<uint64_t>(__in[1]) << 32)
- | static_cast<uint64_t>(__in[0]));
+ uint64_t __th = ((static_cast<uint64_t>(__in_[3]) << 32)
+ | static_cast<uint64_t>(__in_[2]));
+ uint64_t __tl = ((static_cast<uint64_t>(__in_[1]) << 32)
+ | static_cast<uint64_t>(__in_[0]));
uint64_t __oh = __th << (__shift * 8);
uint64_t __ol = __tl << (__shift * 8);
__oh |= __tl >> (64 - __shift * 8);
- __out[1] = static_cast<uint32_t>(__ol >> 32);
- __out[0] = static_cast<uint32_t>(__ol);
- __out[3] = static_cast<uint32_t>(__oh >> 32);
- __out[2] = static_cast<uint32_t>(__oh);
+ __out_[1] = static_cast<uint32_t>(__ol >> 32);
+ __out_[0] = static_cast<uint32_t>(__ol);
+ __out_[3] = static_cast<uint32_t>(__oh >> 32);
+ __out_[2] = static_cast<uint32_t>(__oh);
}
diff --git a/libstdc++-v3/include/ext/vstring.tcc b/libstdc++-v3/include/ext/vstring.tcc
index c9058d7af69..8be798b8cbd 100644
--- a/libstdc++-v3/include/ext/vstring.tcc
+++ b/libstdc++-v3/include/ext/vstring.tcc
@@ -553,7 +553,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits, typename _Alloc,
template <typename, typename, typename> class _Base>
basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __in,
+ operator>>(basic_istream<_CharT, _Traits>& __in_,
__gnu_cxx::__versa_string<_CharT, _Traits,
_Alloc, _Base>& __str)
{
@@ -568,7 +568,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__size_type __extracted = 0;
typename __ios_base::iostate __err = __ios_base::goodbit;
- typename __istream_type::sentry __cerb(__in, false);
+ typename __istream_type::sentry __cerb(__in_, false);
if (__cerb)
{
__try
@@ -577,12 +577,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__str.erase();
_CharT __buf[128];
__size_type __len = 0;
- const streamsize __w = __in.width();
+ const streamsize __w = __in_.width();
const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
: __str.max_size();
- const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+ const __ctype_type& __ct = use_facet<__ctype_type>(__in_.getloc());
const __int_type __eof = _Traits::eof();
- __int_type __c = __in.rdbuf()->sgetc();
+ __int_type __c = __in_.rdbuf()->sgetc();
while (__extracted < __n
&& !_Traits::eq_int_type(__c, __eof)
@@ -596,17 +596,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
__buf[__len++] = _Traits::to_char_type(__c);
++__extracted;
- __c = __in.rdbuf()->snextc();
+ __c = __in_.rdbuf()->snextc();
}
__str.append(__buf, __len);
if (_Traits::eq_int_type(__c, __eof))
__err |= __ios_base::eofbit;
- __in.width(0);
+ __in_.width(0);
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __in._M_setstate(__ios_base::badbit);
+ __in_._M_setstate(__ios_base::badbit);
__throw_exception_again;
}
__catch(...)
@@ -614,21 +614,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
- __in._M_setstate(__ios_base::badbit);
+ __in_._M_setstate(__ios_base::badbit);
}
}
// 211. operator>>(istream&, string&) doesn't set failbit
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
- __in.setstate(__err);
- return __in;
+ __in_.setstate(__err);
+ return __in_;
}
template<typename _CharT, typename _Traits, typename _Alloc,
template <typename, typename, typename> class _Base>
basic_istream<_CharT, _Traits>&
- getline(basic_istream<_CharT, _Traits>& __in,
+ getline(basic_istream<_CharT, _Traits>& __in_,
__gnu_cxx::__versa_string<_CharT, _Traits, _Alloc, _Base>& __str,
_CharT __delim)
{
@@ -642,7 +642,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__size_type __extracted = 0;
const __size_type __n = __str.max_size();
typename __ios_base::iostate __err = __ios_base::goodbit;
- typename __istream_type::sentry __cerb(__in, true);
+ typename __istream_type::sentry __cerb(__in_, true);
if (__cerb)
{
__try
@@ -653,7 +653,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__size_type __len = 0;
const __int_type __idelim = _Traits::to_int_type(__delim);
const __int_type __eof = _Traits::eof();
- __int_type __c = __in.rdbuf()->sgetc();
+ __int_type __c = __in_.rdbuf()->sgetc();
while (__extracted < __n
&& !_Traits::eq_int_type(__c, __eof)
@@ -666,7 +666,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
__buf[__len++] = _Traits::to_char_type(__c);
++__extracted;
- __c = __in.rdbuf()->snextc();
+ __c = __in_.rdbuf()->snextc();
}
__str.append(__buf, __len);
@@ -675,14 +675,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
else if (_Traits::eq_int_type(__c, __idelim))
{
++__extracted;
- __in.rdbuf()->sbumpc();
+ __in_.rdbuf()->sbumpc();
}
else
__err |= __ios_base::failbit;
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __in._M_setstate(__ios_base::badbit);
+ __in_._M_setstate(__ios_base::badbit);
__throw_exception_again;
}
__catch(...)
@@ -690,14 +690,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
- __in._M_setstate(__ios_base::badbit);
+ __in_._M_setstate(__ios_base::badbit);
}
}
if (!__extracted)
__err |= __ios_base::failbit;
if (__err)
- __in.setstate(__err);
- return __in;
+ __in_.setstate(__err);
+ return __in_;
}
_GLIBCXX_END_NAMESPACE_VERSION
diff --git a/libstdc++-v3/include/parallel/algo.h b/libstdc++-v3/include/parallel/algo.h
index 5986b10b127..5671231ef1a 100644
--- a/libstdc++-v3/include/parallel/algo.h
+++ b/libstdc++-v3/include/parallel/algo.h
@@ -289,67 +289,67 @@ namespace __parallel
// Sequential fallback
template<typename _IIter, typename _OutputIterator>
inline _OutputIterator
- unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
+ unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out_,
__gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out); }
+ { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out_); }
// Sequential fallback
template<typename _IIter, typename _OutputIterator,
typename _Predicate>
inline _OutputIterator
- unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
+ unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out_,
_Predicate __pred, __gnu_parallel::sequential_tag)
- { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out, __pred); }
+ { return _GLIBCXX_STD_A::unique_copy(__begin1, __end1, __out_, __pred); }
// Sequential fallback for input iterator case
template<typename _IIter, typename _OutputIterator,
typename _Predicate, typename _IteratorTag1, typename _IteratorTag2>
inline _OutputIterator
__unique_copy_switch(_IIter __begin, _IIter __last,
- _OutputIterator __out, _Predicate __pred,
+ _OutputIterator __out_, _Predicate __pred,
_IteratorTag1, _IteratorTag2)
- { return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out, __pred); }
+ { return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out_, __pred); }
// Parallel unique_copy for random access iterators
template<typename _RAIter, typename _RandomAccessOutputIterator,
typename _Predicate>
_RandomAccessOutputIterator
__unique_copy_switch(_RAIter __begin, _RAIter __last,
- _RandomAccessOutputIterator __out, _Predicate __pred,
+ _RandomAccessOutputIterator __out_, _Predicate __pred,
random_access_iterator_tag, random_access_iterator_tag)
{
if (_GLIBCXX_PARALLEL_CONDITION(
static_cast<__gnu_parallel::_SequenceIndex>(__last - __begin)
> __gnu_parallel::_Settings::get().unique_copy_minimal_n))
return __gnu_parallel::__parallel_unique_copy(
- __begin, __last, __out, __pred);
+ __begin, __last, __out_, __pred);
else
- return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out, __pred);
+ return _GLIBCXX_STD_A::unique_copy(__begin, __last, __out_, __pred);
}
// Public interface
template<typename _IIter, typename _OutputIterator>
inline _OutputIterator
- unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out)
+ unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out_)
{
typedef typename std::iterator_traits<_IIter>::value_type _ValueType;
return __unique_copy_switch(
- __begin1, __end1, __out, equal_to<_ValueType>(),
+ __begin1, __end1, __out_, equal_to<_ValueType>(),
std::__iterator_category(__begin1),
- std::__iterator_category(__out));
+ std::__iterator_category(__out_));
}
// Public interface
template<typename _IIter, typename _OutputIterator, typename _Predicate>
inline _OutputIterator
- unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out,
+ unique_copy(_IIter __begin1, _IIter __end1, _OutputIterator __out_,
_Predicate __pred)
{
return __unique_copy_switch(
- __begin1, __end1, __out, __pred,
+ __begin1, __end1, __out_, __pred,
std::__iterator_category(__begin1),
- std::__iterator_category(__out));
+ std::__iterator_category(__out_));
}
// Sequential fallback
@@ -358,9 +358,9 @@ namespace __parallel
inline _OutputIterator
set_union(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out, __gnu_parallel::sequential_tag)
+ _OutputIterator __out_, __gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_A::set_union(
- __begin1, __end1, __begin2, __end2, __out); }
+ __begin1, __end1, __begin2, __end2, __out_); }
// Sequential fallback
template<typename _IIter1, typename _IIter2,
@@ -368,10 +368,10 @@ namespace __parallel
inline _OutputIterator
set_union(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out, _Predicate __pred,
+ _OutputIterator __out_, _Predicate __pred,
__gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_A::set_union(__begin1, __end1,
- __begin2, __end2, __out, __pred); }
+ __begin2, __end2, __out_, __pred); }
// Sequential fallback for input iterator case
template<typename _IIter1, typename _IIter2, typename _Predicate,
@@ -412,17 +412,17 @@ namespace __parallel
typename _OutputIterator>
inline _OutputIterator
set_union(_IIter1 __begin1, _IIter1 __end1,
- _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out)
+ _IIter2 __begin2, _IIter2 __end2, _OutputIterator __out_)
{
typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1;
typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2;
return __set_union_switch(
- __begin1, __end1, __begin2, __end2, __out,
+ __begin1, __end1, __begin2, __end2, __out_,
__gnu_parallel::_Less<_ValueType1, _ValueType2>(),
std::__iterator_category(__begin1),
std::__iterator_category(__begin2),
- std::__iterator_category(__out));
+ std::__iterator_category(__out_));
}
// Public interface
@@ -431,13 +431,13 @@ namespace __parallel
inline _OutputIterator
set_union(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out, _Predicate __pred)
+ _OutputIterator __out_, _Predicate __pred)
{
return __set_union_switch(
- __begin1, __end1, __begin2, __end2, __out, __pred,
+ __begin1, __end1, __begin2, __end2, __out_, __pred,
std::__iterator_category(__begin1),
std::__iterator_category(__begin2),
- std::__iterator_category(__out));
+ std::__iterator_category(__out_));
}
// Sequential fallback.
@@ -446,9 +446,9 @@ namespace __parallel
inline _OutputIterator
set_intersection(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out, __gnu_parallel::sequential_tag)
+ _OutputIterator __out_, __gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_A::set_intersection(__begin1, __end1,
- __begin2, __end2, __out); }
+ __begin2, __end2, __out_); }
// Sequential fallback.
template<typename _IIter1, typename _IIter2,
@@ -456,10 +456,10 @@ namespace __parallel
inline _OutputIterator
set_intersection(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out, _Predicate __pred,
+ _OutputIterator __out_, _Predicate __pred,
__gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_A::set_intersection(
- __begin1, __end1, __begin2, __end2, __out, __pred); }
+ __begin1, __end1, __begin2, __end2, __out_, __pred); }
// Sequential fallback for input iterator case
template<typename _IIter1, typename _IIter2,
@@ -506,17 +506,17 @@ namespace __parallel
inline _OutputIterator
set_intersection(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out)
+ _OutputIterator __out_)
{
typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1;
typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2;
return __set_intersection_switch(
- __begin1, __end1, __begin2, __end2, __out,
+ __begin1, __end1, __begin2, __end2, __out_,
__gnu_parallel::_Less<_ValueType1, _ValueType2>(),
std::__iterator_category(__begin1),
std::__iterator_category(__begin2),
- std::__iterator_category(__out));
+ std::__iterator_category(__out_));
}
template<typename _IIter1, typename _IIter2,
@@ -524,13 +524,13 @@ namespace __parallel
inline _OutputIterator
set_intersection(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out, _Predicate __pred)
+ _OutputIterator __out_, _Predicate __pred)
{
return __set_intersection_switch(
- __begin1, __end1, __begin2, __end2, __out, __pred,
+ __begin1, __end1, __begin2, __end2, __out_, __pred,
std::__iterator_category(__begin1),
std::__iterator_category(__begin2),
- std::__iterator_category(__out));
+ std::__iterator_category(__out_));
}
// Sequential fallback
@@ -539,10 +539,10 @@ namespace __parallel
inline _OutputIterator
set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out,
+ _OutputIterator __out_,
__gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_A::set_symmetric_difference(
- __begin1, __end1, __begin2, __end2, __out); }
+ __begin1, __end1, __begin2, __end2, __out_); }
// Sequential fallback
template<typename _IIter1, typename _IIter2,
@@ -550,10 +550,10 @@ namespace __parallel
inline _OutputIterator
set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out, _Predicate __pred,
+ _OutputIterator __out_, _Predicate __pred,
__gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_A::set_symmetric_difference(
- __begin1, __end1, __begin2, __end2, __out, __pred); }
+ __begin1, __end1, __begin2, __end2, __out_, __pred); }
// Sequential fallback for input iterator case
template<typename _IIter1, typename _IIter2,
@@ -600,17 +600,17 @@ namespace __parallel
inline _OutputIterator
set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out)
+ _OutputIterator __out_)
{
typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1;
typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2;
return __set_symmetric_difference_switch(
- __begin1, __end1, __begin2, __end2, __out,
+ __begin1, __end1, __begin2, __end2, __out_,
__gnu_parallel::_Less<_ValueType1, _ValueType2>(),
std::__iterator_category(__begin1),
std::__iterator_category(__begin2),
- std::__iterator_category(__out));
+ std::__iterator_category(__out_));
}
// Public interface.
@@ -619,13 +619,13 @@ namespace __parallel
inline _OutputIterator
set_symmetric_difference(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out, _Predicate __pred)
+ _OutputIterator __out_, _Predicate __pred)
{
return __set_symmetric_difference_switch(
- __begin1, __end1, __begin2, __end2, __out, __pred,
+ __begin1, __end1, __begin2, __end2, __out_, __pred,
std::__iterator_category(__begin1),
std::__iterator_category(__begin2),
- std::__iterator_category(__out));
+ std::__iterator_category(__out_));
}
// Sequential fallback.
@@ -634,9 +634,9 @@ namespace __parallel
inline _OutputIterator
set_difference(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out, __gnu_parallel::sequential_tag)
+ _OutputIterator __out_, __gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_A::set_difference(
- __begin1,__end1, __begin2, __end2, __out); }
+ __begin1,__end1, __begin2, __end2, __out_); }
// Sequential fallback.
template<typename _IIter1, typename _IIter2,
@@ -644,10 +644,10 @@ namespace __parallel
inline _OutputIterator
set_difference(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out, _Predicate __pred,
+ _OutputIterator __out_, _Predicate __pred,
__gnu_parallel::sequential_tag)
{ return _GLIBCXX_STD_A::set_difference(__begin1, __end1,
- __begin2, __end2, __out, __pred); }
+ __begin2, __end2, __out_, __pred); }
// Sequential fallback for input iterator case.
template<typename _IIter1, typename _IIter2, typename _Predicate,
@@ -692,17 +692,17 @@ namespace __parallel
inline _OutputIterator
set_difference(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out)
+ _OutputIterator __out_)
{
typedef typename std::iterator_traits<_IIter1>::value_type _ValueType1;
typedef typename std::iterator_traits<_IIter2>::value_type _ValueType2;
return __set_difference_switch(
- __begin1, __end1, __begin2, __end2, __out,
+ __begin1, __end1, __begin2, __end2, __out_,
__gnu_parallel::_Less<_ValueType1, _ValueType2>(),
std::__iterator_category(__begin1),
std::__iterator_category(__begin2),
- std::__iterator_category(__out));
+ std::__iterator_category(__out_));
}
// Public interface
@@ -711,13 +711,13 @@ namespace __parallel
inline _OutputIterator
set_difference(_IIter1 __begin1, _IIter1 __end1,
_IIter2 __begin2, _IIter2 __end2,
- _OutputIterator __out, _Predicate __pred)
+ _OutputIterator __out_, _Predicate __pred)
{
return __set_difference_switch(
- __begin1, __end1, __begin2, __end2, __out, __pred,
+ __begin1, __end1, __begin2, __end2, __out_, __pred,
std::__iterator_category(__begin1),
std::__iterator_category(__begin2),
- std::__iterator_category(__out));
+ std::__iterator_category(__out_));
}
// Sequential fallback
diff --git a/libstdc++-v3/include/parallel/for_each.h b/libstdc++-v3/include/parallel/for_each.h
index 5db41c54d34..5b4e958abd7 100644
--- a/libstdc++-v3/include/parallel/for_each.h
+++ b/libstdc++-v3/include/parallel/for_each.h
@@ -53,7 +53,7 @@ namespace __gnu_parallel
* @param __reduction Reduction functor.
* @param __reduction_start Initial value for reduction.
* @param __output Output iterator.
- * @param __bound Maximum number of elements processed.
+ * @param __bound_ Maximum number of elements processed.
* @param __parallelism_tag Parallelization method */
template<typename _IIter, typename _UserOp,
typename _Functionality, typename _Red, typename _Result>
@@ -65,25 +65,25 @@ namespace __gnu_parallel
_Result __reduction_start,
_Result& __output, typename
std::iterator_traits<_IIter>::
- difference_type __bound,
+ difference_type __bound_,
_Parallelism __parallelism_tag)
{
if (__parallelism_tag == parallel_unbalanced)
return __for_each_template_random_access_ed
(__begin, __end, __user_op, __functionality, __reduction,
- __reduction_start, __output, __bound);
+ __reduction_start, __output, __bound_);
else if (__parallelism_tag == parallel_omp_loop)
return __for_each_template_random_access_omp_loop
(__begin, __end, __user_op, __functionality, __reduction,
- __reduction_start, __output, __bound);
+ __reduction_start, __output, __bound_);
else if (__parallelism_tag == parallel_omp_loop_static)
return __for_each_template_random_access_omp_loop
(__begin, __end, __user_op, __functionality, __reduction,
- __reduction_start, __output, __bound);
+ __reduction_start, __output, __bound_);
else //e. g. parallel_balanced
return __for_each_template_random_access_workstealing
(__begin, __end, __user_op, __functionality, __reduction,
- __reduction_start, __output, __bound);
+ __reduction_start, __output, __bound_);
}
}
diff --git a/libstdc++-v3/include/parallel/multiway_merge.h b/libstdc++-v3/include/parallel/multiway_merge.h
index 65ff6dbbbe1..571483e2461 100644
--- a/libstdc++-v3/include/parallel/multiway_merge.h
+++ b/libstdc++-v3/include/parallel/multiway_merge.h
@@ -1372,7 +1372,7 @@ namespace __gnu_parallel
* for (int __j = 0; __i < 10; ++__j)
* sequences[__i][__j] = __j;
*
- * int __out[33];
+ * int __out_[33];
* std::vector<std::pair<int*> > seqs;
* for (int __i = 0; __i < 10; ++__i)
* { seqs.push(std::make_pair<int*>(sequences[__i],
@@ -1733,7 +1733,7 @@ namespace __gnu_parallel
* for (int __j = 0; __i < 11; ++__j)
* sequences[__i][__j] = __j; // __last one is sentinel!
*
- * int __out[33];
+ * int __out_[33];
* std::vector<std::pair<int*> > seqs;
* for (int __i = 0; __i < 10; ++__i)
* { seqs.push(std::make_pair<int*>(sequences[__i],
diff --git a/libstdc++-v3/include/parallel/omp_loop.h b/libstdc++-v3/include/parallel/omp_loop.h
index 1207665222b..24afe24db9e 100644
--- a/libstdc++-v3/include/parallel/omp_loop.h
+++ b/libstdc++-v3/include/parallel/omp_loop.h
@@ -54,7 +54,7 @@ namespace __gnu_parallel
* processed elements (depends on functionality).
* @param __base Base value for reduction.
* @param __output Pointer to position where final result is written to
- * @param __bound Maximum number of elements processed (e. g. for
+ * @param __bound_ Maximum number of elements processed (e. g. for
* std::count_n()).
* @return User-supplied functor (that may contain a part of the result).
*/
@@ -68,7 +68,7 @@ namespace __gnu_parallel
_Op __o, _Fu& __f, _Red __r,
_Result __base,
_Result& __output,
- typename std::iterator_traits<_RAIter>::difference_type __bound)
+ typename std::iterator_traits<_RAIter>::difference_type __bound_)
{
typedef typename std::iterator_traits<_RAIter>::difference_type
_DifferenceType;
diff --git a/libstdc++-v3/include/parallel/omp_loop_static.h b/libstdc++-v3/include/parallel/omp_loop_static.h
index 5186f1ebe81..a978fbe02eb 100644
--- a/libstdc++-v3/include/parallel/omp_loop_static.h
+++ b/libstdc++-v3/include/parallel/omp_loop_static.h
@@ -53,7 +53,7 @@ namespace __gnu_parallel
* __elements (depends on functionality).
* @param __base Base value for reduction.
* @param __output Pointer to position where final result is written to
- * @param __bound Maximum number of elements processed (e. g. for
+ * @param __bound_ Maximum number of elements processed (e. g. for
* std::count_n()).
* @return User-supplied functor (that may contain a part of the result).
*/
@@ -68,7 +68,7 @@ namespace __gnu_parallel
_Fu& __f, _Red __r,
_Result __base,
_Result& __output,
- typename std::iterator_traits<_RAIter>::difference_type __bound)
+ typename std::iterator_traits<_RAIter>::difference_type __bound_)
{
typedef typename std::iterator_traits<_RAIter>::difference_type
_DifferenceType;
diff --git a/libstdc++-v3/include/parallel/par_loop.h b/libstdc++-v3/include/parallel/par_loop.h
index 267cb6ee427..a35becfda4b 100644
--- a/libstdc++-v3/include/parallel/par_loop.h
+++ b/libstdc++-v3/include/parallel/par_loop.h
@@ -54,7 +54,7 @@ namespace __gnu_parallel
* processed elements (depends on functionality).
* @param __base Base value for reduction.
* @param __output Pointer to position where final result is written to
- * @param __bound Maximum number of elements processed (e. g. for
+ * @param __bound_ Maximum number of elements processed (e. g. for
* std::count_n()).
* @return User-supplied functor (that may contain a part of the result).
*/
@@ -67,7 +67,7 @@ namespace __gnu_parallel
__for_each_template_random_access_ed(_RAIter __begin, _RAIter __end,
_Op __o, _Fu& __f, _Red __r,
_Result __base, _Result& __output,
- typename std::iterator_traits<_RAIter>::difference_type __bound)
+ typename std::iterator_traits<_RAIter>::difference_type __bound_)
{
typedef std::iterator_traits<_RAIter> _TraitsType;
typedef typename _TraitsType::difference_type _DifferenceType;
diff --git a/libstdc++-v3/include/parallel/random_shuffle.h b/libstdc++-v3/include/parallel/random_shuffle.h
index db75ef711cb..36ca2feb317 100644
--- a/libstdc++-v3/include/parallel/random_shuffle.h
+++ b/libstdc++-v3/include/parallel/random_shuffle.h
@@ -107,7 +107,7 @@ namespace __gnu_parallel
};
/** @brief Generate a random number in @c [0,2^__logp).
- * @param __logp Logarithm (basis 2) of the upper range __bound.
+ * @param __logp Logarithm (basis 2) of the upper range __bound_.
* @param __rng Random number generator to use.
*/
template<typename _RandomNumberGenerator>
diff --git a/libstdc++-v3/include/parallel/set_operations.h b/libstdc++-v3/include/parallel/set_operations.h
index cf8f3ab893a..6d1ed83d7a2 100644
--- a/libstdc++-v3/include/parallel/set_operations.h
+++ b/libstdc++-v3/include/parallel/set_operations.h
@@ -130,12 +130,12 @@ namespace __gnu_parallel
}
_OutputIterator
- __first_empty(_IIter __c, _IIter __d, _OutputIterator __out) const
- { return std::copy(__c, __d, __out); }
+ __first_empty(_IIter __c, _IIter __d, _OutputIterator __out_) const
+ { return std::copy(__c, __d, __out_); }
_OutputIterator
- __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
- { return std::copy(__a, __b, __out); }
+ __second_empty(_IIter __a, _IIter __b, _OutputIterator __out_) const
+ { return std::copy(__a, __b, __out_); }
};
@@ -198,12 +198,12 @@ namespace __gnu_parallel
}
_OutputIterator
- __first_empty(_IIter, _IIter, _OutputIterator __out) const
- { return __out; }
+ __first_empty(_IIter, _IIter, _OutputIterator __out_) const
+ { return __out_; }
_OutputIterator
- __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
- { return std::copy(__a, __b, __out); }
+ __second_empty(_IIter __a, _IIter __b, _OutputIterator __out_) const
+ { return std::copy(__a, __b, __out_); }
};
@@ -265,12 +265,12 @@ namespace __gnu_parallel
}
_OutputIterator
- __first_empty(_IIter, _IIter, _OutputIterator __out) const
- { return __out; }
+ __first_empty(_IIter, _IIter, _OutputIterator __out_) const
+ { return __out_; }
_OutputIterator
- __second_empty(_IIter, _IIter, _OutputIterator __out) const
- { return __out; }
+ __second_empty(_IIter, _IIter, _OutputIterator __out_) const
+ { return __out_; }
};
template<class _IIter, class _OutputIterator, class _Compare>
@@ -335,12 +335,12 @@ namespace __gnu_parallel
}
_OutputIterator
- __first_empty(_IIter __c, _IIter __d, _OutputIterator __out) const
- { return std::copy(__c, __d, __out); }
+ __first_empty(_IIter __c, _IIter __d, _OutputIterator __out_) const
+ { return std::copy(__c, __d, __out_); }
_OutputIterator
- __second_empty(_IIter __a, _IIter __b, _OutputIterator __out) const
- { return std::copy(__a, __b, __out); }
+ __second_empty(_IIter __a, _IIter __b, _OutputIterator __out_) const
+ { return std::copy(__a, __b, __out_); }
};
template<typename _IIter,
diff --git a/libstdc++-v3/include/parallel/unique_copy.h b/libstdc++-v3/include/parallel/unique_copy.h
index 183548def5d..a90b78d33fd 100644
--- a/libstdc++-v3/include/parallel/unique_copy.h
+++ b/libstdc++-v3/include/parallel/unique_copy.h
@@ -85,7 +85,7 @@ namespace __gnu_parallel
// Check for length without duplicates
// Needed for position in output
_DifferenceType __i = 0;
- _OutputIterator __out = __result;
+ _OutputIterator __out_ = __result;
if (__iam == 0)
{
@@ -93,7 +93,7 @@ namespace __gnu_parallel
__end = __borders[__iam + 1];
++__i;
- *__out++ = *__first;
+ *__out_++ = *__first;
for (_IIter __iter = __first + __begin; __iter < __first + __end;
++__iter)
@@ -101,7 +101,7 @@ namespace __gnu_parallel
if (!__binary_pred(*__iter, *(__iter - 1)))
{
++__i;
- *__out++ = *__iter;
+ *__out_++ = *__iter;
}
}
}
diff --git a/libstdc++-v3/include/parallel/workstealing.h b/libstdc++-v3/include/parallel/workstealing.h
index 05c1a99f5dd..9689759aa33 100644
--- a/libstdc++-v3/include/parallel/workstealing.h
+++ b/libstdc++-v3/include/parallel/workstealing.h
@@ -86,7 +86,7 @@ namespace __gnu_parallel
* processed elements (depends on functionality).
* @param __base Base value for reduction.
* @param __output Pointer to position where final result is written to
- * @param __bound Maximum number of elements processed (e. g. for
+ * @param __bound_ Maximum number of elements processed (e. g. for
* std::count_n()).
* @return User-supplied functor (that may contain a part of the result).
*/
@@ -101,7 +101,7 @@ namespace __gnu_parallel
_Fu& __f, _Red __r,
_Result __base,
_Result& __output,
- typename std::iterator_traits<_RAIter>::difference_type __bound)
+ typename std::iterator_traits<_RAIter>::difference_type __bound_)
{
_GLIBCXX_CALL(__end - __begin)
@@ -114,7 +114,7 @@ namespace __gnu_parallel
static_cast<_DifferenceType>(__s.workstealing_chunk_size);
// How many jobs?
- _DifferenceType __length = (__bound < 0) ? (__end - __begin) : __bound;
+ _DifferenceType __length = (__bound_ < 0) ? (__end - __begin) : __bound_;
// To avoid false sharing in a cache line.
const int __stride = (__s.cache_line_size * 10
diff --git a/libstdc++-v3/include/pstl/parallel_backend_tbb.h b/libstdc++-v3/include/pstl/parallel_backend_tbb.h
index 00a8b9fb635..e304e9066ba 100644
--- a/libstdc++-v3/include/pstl/parallel_backend_tbb.h
+++ b/libstdc++-v3/include/pstl/parallel_backend_tbb.h
@@ -96,9 +96,9 @@ class __parallel_for_body
__parallel_for_body(const _RealBody& __body) : _M_body(__body) {}
__parallel_for_body(const __parallel_for_body& __body) : _M_body(__body._M_body) {}
void
- operator()(const tbb::blocked_range<_Index>& __range) const
+ operator()(const tbb::blocked_range<_Index>& __range_) const
{
- _M_body(__range.begin(), __range.end());
+ _M_body(__range_.begin(), __range_.end());
}
private:
@@ -181,13 +181,13 @@ struct __par_trans_red_body
}
void
- operator()(const tbb::blocked_range<_Index>& __range)
+ operator()(const tbb::blocked_range<_Index>& __range_)
{
- _Index __i = __range.begin();
- _Index __j = __range.end();
+ _Index __i = __range_.begin();
+ _Index __j = __range_.end();
if (!_M_has_sum)
{
- _PSTL_ASSERT_MSG(__range.size() > 1, "there should be at least 2 elements");
+ _PSTL_ASSERT_MSG(__range_.size() > 1, "there should be at least 2 elements");
new (&_M_sum_storage)
_Tp(_M_combine(_M_u(__i), _M_u(__i + 1))); // The condition i+1 < j is provided by the grain size of 3
_M_has_sum = true;
@@ -252,10 +252,10 @@ class __trans_scan_body
}
void
- operator()(const tbb::blocked_range<_Index>& __range, tbb::pre_scan_tag)
+ operator()(const tbb::blocked_range<_Index>& __range_, tbb::pre_scan_tag)
{
- _Index __i = __range.begin();
- _Index __j = __range.end();
+ _Index __i = __range_.begin();
+ _Index __j = __range_.end();
if (!_M_has_sum)
{
new (&_M_sum_storage) _Tp(_M_u(__i));
@@ -268,9 +268,9 @@ class __trans_scan_body
}
void
- operator()(const tbb::blocked_range<_Index>& __range, tbb::final_scan_tag)
+ operator()(const tbb::blocked_range<_Index>& __range_, tbb::final_scan_tag)
{
- sum() = _M_scan(__range.begin(), __range.end(), sum());
+ sum() = _M_scan(__range_.begin(), __range_.end(), sum());
}
void
@@ -408,8 +408,8 @@ __parallel_transform_scan(__pstl::__internal::__tbb_backend_tag, _ExecutionPolic
_Cp __combine, _Rp __brick_reduce, _Sp __scan)
{
__trans_scan_body<_Index, _Up, _Tp, _Cp, _Rp, _Sp> __body(__u, __init, __combine, __brick_reduce, __scan);
- auto __range = tbb::blocked_range<_Index>(0, __n);
- tbb::this_task_arena::isolate([__range, &__body]() { tbb::parallel_scan(__range, __body); });
+ auto __range_ = tbb::blocked_range<_Index>(0, __n);
+ tbb::this_task_arena::isolate([__range_, &__body]() { tbb::parallel_scan(__range_, __body); });
return __body.sum();
}
@@ -786,9 +786,9 @@ class __merge_func
auto __n = __last1 - __first1;
tbb::parallel_for(tbb::blocked_range<_SizeType>(0, __n, __merge_cut_off),
- [__first1, __first2](const tbb::blocked_range<_SizeType>& __range) {
- std::move(__first1 + __range.begin(), __first1 + __range.end(),
- __first2 + __range.begin());
+ [__first1, __first2](const tbb::blocked_range<_SizeType>& __range_) {
+ std::move(__first1 + __range_.begin(), __first1 + __range_.end(),
+ __first2 + __range_.begin());
});
return __first2 + __n;
}
@@ -809,8 +809,8 @@ class __merge_func
auto __n = __last1 - __first1;
tbb::parallel_for(tbb::blocked_range<_SizeType>(0, __n, __merge_cut_off),
- [__first1, __first2](const tbb::blocked_range<_SizeType>& __range) {
- for (auto i = __range.begin(); i != __range.end(); ++i)
+ [__first1, __first2](const tbb::blocked_range<_SizeType>& __range_) {
+ for (auto i = __range_.begin(); i != __range_.end(); ++i)
__move_value_construct()(__first1 + i, __first2 + i);
});
return __first2 + __n;
@@ -829,8 +829,8 @@ class __merge_func
{
auto __n = __last - __first;
tbb::parallel_for(tbb::blocked_range<_SizeType>(0, __n, __merge_cut_off),
- [__first](const tbb::blocked_range<_SizeType>& __range) {
- _Cleanup()(__first + __range.begin(), __first + __range.end());
+ [__first](const tbb::blocked_range<_SizeType>& __range_) {
+ _Cleanup()(__first + __range_.begin(), __first + __range_.end());
});
}
}
diff --git a/libstdc++-v3/include/std/charconv b/libstdc++-v3/include/std/charconv
index 993ceb3f744..c008a695456 100644
--- a/libstdc++-v3/include/std/charconv
+++ b/libstdc++-v3/include/std/charconv
@@ -578,25 +578,25 @@ namespace __detail
_Up __val = 0;
const auto __start = __first;
- bool __valid;
+ bool __valid_;
if ((__base & (__base - 1)) == 0)
{
if (__base <= 8)
- __valid = __detail::__from_chars_pow2_base<true>(__first, __last, __val, __base);
+ __valid_ = __detail::__from_chars_pow2_base<true>(__first, __last, __val, __base);
else
- __valid = __detail::__from_chars_pow2_base<false>(__first, __last, __val, __base);
+ __valid_ = __detail::__from_chars_pow2_base<false>(__first, __last, __val, __base);
}
else if (__base <= 10)
- __valid = __detail::__from_chars_alnum<true>(__first, __last, __val, __base);
+ __valid_ = __detail::__from_chars_alnum<true>(__first, __last, __val, __base);
else
- __valid = __detail::__from_chars_alnum<false>(__first, __last, __val, __base);
+ __valid_ = __detail::__from_chars_alnum<false>(__first, __last, __val, __base);
if (__builtin_expect(__first == __start, 0))
__res.ec = errc::invalid_argument;
else
{
__res.ptr = __first;
- if (!__valid)
+ if (!__valid_)
__res.ec = errc::result_out_of_range;
else
{
diff --git a/libstdc++-v3/include/std/format b/libstdc++-v3/include/std/format
index 0f20fcc8d88..c11c05403f4 100644
--- a/libstdc++-v3/include/std/format
+++ b/libstdc++-v3/include/std/format
@@ -793,24 +793,24 @@ namespace __format
template<typename _Out, typename _CharT>
requires output_iterator<_Out, const _CharT&>
inline _Out
- __write(_Out __out, basic_string_view<_CharT> __str)
+ __write(_Out __out_, basic_string_view<_CharT> __str)
{
if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
{
if (__str.size())
- __out = __str;
+ __out_ = __str;
}
else
for (_CharT __c : __str)
- *__out++ = __c;
- return __out;
+ *__out_++ = __c;
+ return __out_;
}
// Write STR to OUT with NFILL copies of FILL_CHAR specified by ALIGN.
// pre: __align != _Align_default
template<typename _Out, typename _CharT>
_Out
- __write_padded(_Out __out, basic_string_view<_CharT> __str,
+ __write_padded(_Out __out_, basic_string_view<_CharT> __str,
_Align __align, size_t __nfill, char32_t __fill_char)
{
const size_t __buflen = 0x20;
@@ -860,11 +860,11 @@ namespace __format
basic_string<_CharT> __padstr(__v.begin(), __v.end());
__padding = __padstr;
while (__l-- > 0)
- __out = __format::__write(std::move(__out), __padding);
- __out = __format::__write(std::move(__out), __str);
+ __out_ = __format::__write(std::move(__out_), __padding);
+ __out_ = __format::__write(std::move(__out_), __str);
while (__r-- > 0)
- __out = __format::__write(std::move(__out), __padding);
- return __out;
+ __out_ = __format::__write(std::move(__out_), __padding);
+ return __out_;
}
if (__max < __buflen)
@@ -873,11 +873,11 @@ namespace __format
__max = __buflen;
char_traits<_CharT>::assign(__padding_chars, __max, __fill_char);
- __pad(__l, __out);
- __out = __format::__write(std::move(__out), __str);
- __pad(__r, __out);
+ __pad(__l, __out_);
+ __out_ = __format::__write(std::move(__out_), __str);
+ __pad(__r, __out_);
- return __out;
+ return __out_;
}
// Write STR to OUT, with alignment and padding as determined by SPEC.
@@ -1050,7 +1050,7 @@ namespace __format
using uint_least32_t = __UINT_LEAST32_TYPE__;
template<typename _Out, typename _CharT>
_Out
- __write_escape_seq(_Out __out, uint_least32_t __val,
+ __write_escape_seq(_Out __out_, uint_least32_t __val,
basic_string_view<_CharT> __prefix)
{
using _Str_view = basic_string_view<_CharT>;
@@ -1060,64 +1060,64 @@ namespace __format
__buf,
std::__to_chars_i<uint_least32_t>(__buf, __buf + __max, __val, 16).ptr);
- __out = __format::__write(__out, __prefix);
- *__out = _Separators<_CharT>::_S_braces()[0];
- ++__out;
+ __out_ = __format::__write(__out_, __prefix);
+ *__out_ = _Separators<_CharT>::_S_braces()[0];
+ ++__out_;
if constexpr (is_same_v<char, _CharT>)
- __out = __format::__write(__out, __narrow);
+ __out_ = __format::__write(__out_, __narrow);
#ifdef _GLIBCXX_USE_WCHAR_T
else
{
_CharT __wbuf[__max];
const size_t __n = __narrow.size();
std::__to_wstring_numeric(__narrow.data(), __n, __wbuf);
- __out = __format::__write(__out, _Str_view(__wbuf, __n));
+ __out_ = __format::__write(__out_, _Str_view(__wbuf, __n));
}
#endif
- *__out = _Separators<_CharT>::_S_braces()[1];
- return ++__out;
+ *__out_ = _Separators<_CharT>::_S_braces()[1];
+ return ++__out_;
}
template<typename _Out, typename _CharT>
_Out
- __write_escape_seqs(_Out __out, basic_string_view<_CharT> __units)
+ __write_escape_seqs(_Out __out_, basic_string_view<_CharT> __units)
{
using _UChar = make_unsigned_t<_CharT>;
for (_CharT __c : __units)
- __out = __format::__write_escape_seq(
- __out, static_cast<_UChar>(__c), _Escapes<_CharT>::_S_x());
- return __out;
+ __out_ = __format::__write_escape_seq(
+ __out_, static_cast<_UChar>(__c), _Escapes<_CharT>::_S_x());
+ return __out_;
}
template<typename _Out, typename _CharT>
_Out
- __write_escaped_char(_Out __out, _CharT __c)
+ __write_escaped_char(_Out __out_, _CharT __c)
{
using _UChar = make_unsigned_t<_CharT>;
using _Esc = _Escapes<_CharT>;
switch (__c)
{
case _Esc::_S_tab()[0]:
- return __format::__write(__out, _Esc::_S_tab().substr(1, 2));
+ return __format::__write(__out_, _Esc::_S_tab().substr(1, 2));
case _Esc::_S_newline()[0]:
- return __format::__write(__out, _Esc::_S_newline().substr(1, 2));
+ return __format::__write(__out_, _Esc::_S_newline().substr(1, 2));
case _Esc::_S_return()[0]:
- return __format::__write(__out, _Esc::_S_return().substr(1, 2));
+ return __format::__write(__out_, _Esc::_S_return().substr(1, 2));
case _Esc::_S_bslash()[0]:
- return __format::__write(__out, _Esc::_S_bslash().substr(1, 2));
+ return __format::__write(__out_, _Esc::_S_bslash().substr(1, 2));
case _Esc::_S_quote()[0]:
- return __format::__write(__out, _Esc::_S_quote().substr(1, 2));
+ return __format::__write(__out_, _Esc::_S_quote().substr(1, 2));
case _Esc::_S_apos()[0]:
- return __format::__write(__out, _Esc::_S_apos().substr(1, 2));
+ return __format::__write(__out_, _Esc::_S_apos().substr(1, 2));
default:
return __format::__write_escape_seq(
- __out, static_cast<_UChar>(__c), _Esc::_S_u());
+ __out_, static_cast<_UChar>(__c), _Esc::_S_u());
}
}
template<typename _CharT, typename _Out>
_Out
- __write_escaped_ascii(_Out __out,
+ __write_escaped_ascii(_Out __out_,
basic_string_view<_CharT> __str,
_Term_char __term)
{
@@ -1133,21 +1133,21 @@ namespace __format
++__print;
if (__print != __first)
- __out = __format::__write(__out, _Str_view(__first, __print));
+ __out_ = __format::__write(__out_, _Str_view(__first, __print));
if (__print == __last)
- return __out;
+ return __out_;
__first = __print;
- __out = __format::__write_escaped_char(__out, *__first);
+ __out_ = __format::__write_escaped_char(__out_, *__first);
++__first;
}
- return __out;
+ return __out_;
}
template<typename _CharT, typename _Out>
_Out
- __write_escaped_unicode_part(_Out __out, basic_string_view<_CharT>& __str,
+ __write_escaped_unicode_part(_Out __out_, basic_string_view<_CharT>& __str,
bool& __prev_esc, _Term_char __term)
{
using _Str_view = basic_string_view<_CharT>;
@@ -1196,61 +1196,61 @@ namespace __format
}
if (__print != __first)
- __out = __format::__write(__out, _Str_view(__first.base(), __print.base()));
+ __out_ = __format::__write(__out_, _Str_view(__first.base(), __print.base()));
if (__print == __last)
- return __out;
+ return __out_;
__first = __print;
if (__esc_ascii)
- __out = __format::__write_escaped_char(__out, *__first.base());
+ __out_ = __format::__write_escaped_char(__out_, *__first.base());
else if (__esc_unicode)
- __out = __format::__write_escape_seq(__out, *__first, _Esc::_S_u());
+ __out_ = __format::__write_escape_seq(__out_, *__first, _Esc::_S_u());
// __esc_replace
else if (_Str_view __units(__first.base(), __first._M_units());
__units.end() != __last.base())
- __out = __format::__write_escape_seqs(__out, __units);
+ __out_ = __format::__write_escape_seqs(__out_, __units);
else
{
__str = __units;
- return __out;
+ return __out_;
}
__prev_esc = true;
++__first;
}
- return __out;
+ return __out_;
}
template<typename _CharT, typename _Out>
_Out
- __write_escaped_unicode(_Out __out, basic_string_view<_CharT> __str,
+ __write_escaped_unicode(_Out __out_, basic_string_view<_CharT> __str,
_Term_char __term)
{
bool __prev_escape = true;
- __out = __format::__write_escaped_unicode_part(__out, __str,
+ __out_ = __format::__write_escaped_unicode_part(__out_, __str,
__prev_escape, __term);
- __out = __format::__write_escape_seqs(__out, __str);
- return __out;
+ __out_ = __format::__write_escape_seqs(__out_, __str);
+ return __out_;
}
template<typename _CharT, typename _Out>
_Out
- __write_escaped(_Out __out, basic_string_view<_CharT> __str, _Term_char __term)
+ __write_escaped(_Out __out_, basic_string_view<_CharT> __str, _Term_char __term)
{
- __out = __format::__write(__out, _Escapes<_CharT>::_S_term(__term));
+ __out_ = __format::__write(__out_, _Escapes<_CharT>::_S_term(__term));
if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
- __out = __format::__write_escaped_unicode(__out, __str, __term);
+ __out_ = __format::__write_escaped_unicode(__out_, __str, __term);
else if constexpr (is_same_v<char, _CharT>
&& __unicode::__literal_encoding_is_extended_ascii())
- __out = __format::__write_escaped_ascii(__out, __str, __term);
+ __out_ = __format::__write_escaped_ascii(__out_, __str, __term);
else
// TODO Handle non-ascii extended encoding
- __out = __format::__write_escaped_ascii(__out, __str, __term);
+ __out_ = __format::__write_escaped_ascii(__out_, __str, __term);
- return __format::__write(__out, _Escapes<_CharT>::_S_term(__term));
+ return __format::__write(__out_, _Escapes<_CharT>::_S_term(__term));
}
// A lightweight optional<locale>.
@@ -1762,7 +1762,7 @@ namespace __format
_M_format_character(_CharT __c,
basic_format_context<_Out, _CharT>& __fc) const
{
- basic_string_view<_CharT> __in(&__c, 1u);
+ basic_string_view<_CharT> __in_(&__c, 1u);
size_t __width = 1u;
// N.B. single byte cannot encode character of width greater than 1
if constexpr (sizeof(_CharT) > 1u &&
@@ -1770,21 +1770,21 @@ namespace __format
__width = __unicode::__field_width(__c);
if (!_M_spec._M_debug)
- return __format::__write_padded_as_spec(__in, __width,
+ return __format::__write_padded_as_spec(__in_, __width,
__fc, _M_spec);
__width += 2;
if (_M_spec._M_get_width(__fc) <= __width)
- return __format::__write_escaped(__fc.out(), __in, _Term_apos);
+ return __format::__write_escaped(__fc.out(), __in_, _Term_apos);
_CharT __buf[12];
_Fixedbuf_sink<_CharT> __sink(__buf);
- __format::__write_escaped(__sink.out(), __in, _Term_apos);
+ __format::__write_escaped(__sink.out(), __in_, _Term_apos);
- __in = __sink.view();
- if (__in[1] == _Escapes<_CharT>::_S_bslash()[0]) // escape sequence
- __width = __in.size();
- return __format::__write_padded_as_spec(__in, __width,
+ __in_ = __sink.view();
+ if (__in_[1] == _Escapes<_CharT>::_S_bslash()[0]) // escape sequence
+ __width = __in_.size();
+ return __format::__write_padded_as_spec(__in_, __width,
__fc, _M_spec);
}
@@ -1848,7 +1848,7 @@ namespace __format
_Align __align = _M_spec._M_align;
size_t __nfill = __width - __str.size();
- auto __out = __fc.out();
+ auto __out_ = __fc.out();
if (__align == _Align_default)
{
__align = _Align_right;
@@ -1858,7 +1858,7 @@ namespace __format
// Write sign and base prefix before zero filling.
if (__prefix_len != 0)
{
- __out = __format::__write(std::move(__out),
+ __out_ = __format::__write(std::move(__out_),
__str.substr(0, __prefix_len));
__str.remove_prefix(__prefix_len);
}
@@ -1866,7 +1866,7 @@ namespace __format
else
__fill_char = _CharT(' ');
}
- return __format::__write_padded(std::move(__out), __str,
+ return __format::__write_padded(std::move(__out_), __str,
__align, __nfill, __fill_char);
}
@@ -2329,7 +2329,7 @@ namespace __format
_Align __align = _M_spec._M_align;
size_t __nfill = __width - __str.size();
- auto __out = __fc.out();
+ auto __out_ = __fc.out();
if (__align == _Align_default)
{
__align = _Align_right;
@@ -2339,14 +2339,14 @@ namespace __format
// Write sign before zero filling.
if (!__format::__is_xdigit(__narrow_str[0]))
{
- *__out++ = __str[0];
+ *__out_++ = __str[0];
__str.remove_prefix(1);
}
}
else
__fill_char = _CharT(' ');
}
- return __format::__write_padded(std::move(__out), __str,
+ return __format::__write_padded(std::move(__out_), __str,
__align, __nfill, __fill_char);
}
@@ -3643,8 +3643,8 @@ namespace __format
public:
[[__gnu__::__always_inline__]]
explicit
- _Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __max = -1)
- : _M_out(std::move(__out)), _M_max(__max)
+ _Iter_sink(_OutIter __out_, iter_difference_t<_OutIter> __max = -1)
+ : _M_out(std::move(__out_)), _M_max(__max)
{ }
using _Sink<_CharT>::out;
@@ -3774,8 +3774,8 @@ namespace __format
template<contiguous_iterator _OutIter>
explicit
- _Ptr_sink(_OutIter __out, iter_difference_t<_OutIter> __n = -1)
- : _Ptr_sink(std::to_address(__out), _S_trim_max(__n))
+ _Ptr_sink(_OutIter __out_, iter_difference_t<_OutIter> __n = -1)
+ : _Ptr_sink(std::to_address(__out_), _S_trim_max(__n))
{ }
template<contiguous_iterator _OutIter>
@@ -3924,8 +3924,8 @@ namespace __format
if (!this->_M_used().empty())
_M_flush();
// Try to reserve from _M_out sink.
- if (auto __reserved = _M_out._M_reserve(__n))
- return __reserved;
+ if (auto __reserved_ = _M_out._M_reserve(__n))
+ return __reserved_;
}
return _Sink<_CharT>::_M_reserve(__n);
}
@@ -3946,15 +3946,15 @@ namespace __format
public:
[[__gnu__::__always_inline__]]
explicit
- _Padding_sink(_Out __out, size_t __padwidth, size_t __maxwidth)
+ _Padding_sink(_Out __out_, size_t __padwidth, size_t __maxwidth)
: _M_padwidth(__padwidth), _M_maxwidth(__maxwidth),
- _M_out(std::move(__out)), _M_printwidth(0)
+ _M_out(std::move(__out_)), _M_printwidth(0)
{ _M_sync_discarding(); }
[[__gnu__::__always_inline__]]
explicit
- _Padding_sink(_Out __out, size_t __padwidth)
- : _Padding_sink(std::move(__out), __padwidth, (size_t)-1)
+ _Padding_sink(_Out __out_, size_t __padwidth)
+ : _Padding_sink(std::move(__out_), __padwidth, (size_t)-1)
{ }
_Out
@@ -4045,8 +4045,8 @@ namespace __format
public:
[[__gnu__::__always_inline__]]
explicit
- _Escaping_sink(_Out __out, _Term_char __term)
- : _M_out(std::move(__out)), _M_term(__term),
+ _Escaping_sink(_Out __out_, _Term_char __term)
+ : _M_out(std::move(__out_)), _M_term(__term),
_M_prev_escape(true), _M_out_discards(false)
{
_M_out = __format::__write(std::move(_M_out), _Esc::_S_term(_M_term));
@@ -4936,13 +4936,13 @@ namespace __format
__format::_Optional_locale _M_loc;
basic_format_context(basic_format_args<basic_format_context> __args,
- _Out __out)
- : _M_args(__args), _M_out(std::move(__out))
+ _Out __out_)
+ : _M_args(__args), _M_out(std::move(__out_))
{ }
basic_format_context(basic_format_args<basic_format_context> __args,
- _Out __out, const std::locale& __loc)
- : _M_args(__args), _M_out(std::move(__out)), _M_loc(__loc)
+ _Out __out_, const std::locale& __loc)
+ : _M_args(__args), _M_out(std::move(__out_)), _M_loc(__loc)
{ }
// _GLIBCXX_RESOLVE_LIB_DEFECTS
@@ -5225,7 +5225,7 @@ namespace __format
template<typename _CharT, unsigned = __unicode::__literal_encoding_is_unicode<_CharT>()>
_Sink_iter<_CharT>
- __do_vformat_to(_Sink_iter<_CharT> __out, basic_string_view<_CharT> __fmt,
+ __do_vformat_to(_Sink_iter<_CharT> __out_, basic_string_view<_CharT> __fmt,
__format_context<_CharT>& __ctx)
{
if constexpr (is_same_v<_CharT, char>)
@@ -5239,7 +5239,7 @@ namespace __format
{
size_t __len = 4 + !__arg;
const char* __chars[] = { "false", "true" };
- if (auto __res = __out._M_reserve(__len))
+ if (auto __res = __out_._M_reserve(__len))
{
__builtin_memcpy(__res.get(), __chars[__arg], __len);
__res._M_bump(__len);
@@ -5248,7 +5248,7 @@ namespace __format
}
else if constexpr (is_same_v<_Tp, char>)
{
- if (auto __res = __out._M_reserve(1))
+ if (auto __res = __out_._M_reserve(1))
{
*__res.get() = __arg;
__res._M_bump(1);
@@ -5264,7 +5264,7 @@ namespace __format
else
__uval = __arg;
const auto __n = __detail::__to_chars_len(__uval);
- if (auto __res = __out._M_reserve(__n + __neg))
+ if (auto __res = __out_._M_reserve(__n + __neg))
{
auto __ptr = __res.get();
*__ptr = '-';
@@ -5277,7 +5277,7 @@ namespace __format
else if constexpr (is_convertible_v<_Tp, string_view>)
{
string_view __sv = __arg;
- if (auto __res = __out._M_reserve(__sv.size()))
+ if (auto __res = __out_._M_reserve(__sv.size()))
{
__builtin_memcpy(__res.get(), __sv.data(), __sv.size());
__res._M_bump(__sv.size());
@@ -5287,12 +5287,12 @@ namespace __format
}, __ctx.arg(0));
if (__done)
- return __out;
+ return __out_;
}
_Formatting_scanner<_Sink_iter<_CharT>, _CharT> __scanner(__ctx, __fmt);
__scanner._M_scan();
- return __out;
+ return __out_;
}
// The behavior of the formatters (interpretation of fill character) depends
@@ -5313,26 +5313,26 @@ namespace __format
template<typename _Out, typename _CharT, typename _Context>
inline _Out
- __do_vformat_to(_Out __out, basic_string_view<_CharT> __fmt,
+ __do_vformat_to(_Out __out_, basic_string_view<_CharT> __fmt,
const basic_format_args<_Context>& __args,
const locale* __loc)
{
if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
{
auto __ctx = __loc == nullptr
- ? _Context(__args, __out)
- : _Context(__args, __out, *__loc);
- return __format::__do_vformat_to(__out, __fmt, __ctx);
+ ? _Context(__args, __out_)
+ : _Context(__args, __out_, *__loc);
+ return __format::__do_vformat_to(__out_, __fmt, __ctx);
}
else if constexpr (__contiguous_char_iter<_CharT, _Out>)
{
- _Ptr_sink<_CharT> __sink(__out);
+ _Ptr_sink<_CharT> __sink(__out_);
__format::__do_vformat_to(__sink.out(), __fmt, __args, __loc);
- return std::move(__sink)._M_finish(__out).out;
+ return std::move(__sink)._M_finish(__out_).out;
}
else
{
- _Iter_sink<_CharT, _Out> __sink(std::move(__out));
+ _Iter_sink<_CharT, _Out> __sink(std::move(__out_));
__format::__do_vformat_to(__sink.out(), __fmt, __args, __loc);
return std::move(__sink)._M_finish().out;
}
@@ -5340,7 +5340,7 @@ namespace __format
template<typename _Out, typename _CharT>
inline format_to_n_result<_Out>
- __do_vformat_to_n(_Out __out, iter_difference_t<_Out> __n,
+ __do_vformat_to_n(_Out __out_, iter_difference_t<_Out> __n,
basic_string_view<_CharT> __fmt,
const type_identity_t<
basic_format_args<__format_context<_CharT>>>& __args,
@@ -5348,13 +5348,13 @@ namespace __format
{
if constexpr (__contiguous_char_iter<_CharT, _Out>)
{
- _Ptr_sink<_CharT> __sink(__out, __n);
+ _Ptr_sink<_CharT> __sink(__out_, __n);
__format::__do_vformat_to(__sink.out(), __fmt, __args, __loc);
- return std::move(__sink)._M_finish(__out);
+ return std::move(__sink)._M_finish(__out_);
}
else
{
- _Iter_sink<_CharT, _Out> __sink(std::move(__out), __n);
+ _Iter_sink<_CharT, _Out> __sink(std::move(__out_), __n);
__format::__do_vformat_to(__sink.out(), __fmt, __args, __loc);
return std::move(__sink)._M_finish();
}
@@ -5410,34 +5410,34 @@ namespace __format
template<typename _Out> requires output_iterator<_Out, const char&>
[[__gnu__::__always_inline__]]
inline _Out
- vformat_to(_Out __out, string_view __fmt, format_args __args)
- { return __format::__do_vformat_to(std::move(__out), __fmt, __args); }
+ vformat_to(_Out __out_, string_view __fmt, format_args __args)
+ { return __format::__do_vformat_to(std::move(__out_), __fmt, __args); }
#ifdef _GLIBCXX_USE_WCHAR_T
template<typename _Out> requires output_iterator<_Out, const wchar_t&>
[[__gnu__::__always_inline__]]
inline _Out
- vformat_to(_Out __out, wstring_view __fmt, wformat_args __args)
- { return __format::__do_vformat_to(std::move(__out), __fmt, __args); }
+ vformat_to(_Out __out_, wstring_view __fmt, wformat_args __args)
+ { return __format::__do_vformat_to(std::move(__out_), __fmt, __args); }
#endif
template<typename _Out> requires output_iterator<_Out, const char&>
[[__gnu__::__always_inline__]]
inline _Out
- vformat_to(_Out __out, const locale& __loc, string_view __fmt,
+ vformat_to(_Out __out_, const locale& __loc, string_view __fmt,
format_args __args)
{
- return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc);
+ return __format::__do_vformat_to(std::move(__out_), __fmt, __args, &__loc);
}
#ifdef _GLIBCXX_USE_WCHAR_T
template<typename _Out> requires output_iterator<_Out, const wchar_t&>
[[__gnu__::__always_inline__]]
inline _Out
- vformat_to(_Out __out, const locale& __loc, wstring_view __fmt,
+ vformat_to(_Out __out_, const locale& __loc, wstring_view __fmt,
wformat_args __args)
{
- return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc);
+ return __format::__do_vformat_to(std::move(__out_), __fmt, __args, &__loc);
}
#endif
@@ -5520,9 +5520,9 @@ namespace __format
template<typename _Out, typename... _Args>
requires output_iterator<_Out, const char&>
inline _Out
- format_to(_Out __out, format_string<_Args...> __fmt, _Args&&... __args)
+ format_to(_Out __out_, format_string<_Args...> __fmt, _Args&&... __args)
{
- return std::vformat_to(std::move(__out), __fmt.get(),
+ return std::vformat_to(std::move(__out_), __fmt.get(),
std::make_format_args(__args...));
}
@@ -5530,9 +5530,9 @@ namespace __format
template<typename _Out, typename... _Args>
requires output_iterator<_Out, const wchar_t&>
inline _Out
- format_to(_Out __out, wformat_string<_Args...> __fmt, _Args&&... __args)
+ format_to(_Out __out_, wformat_string<_Args...> __fmt, _Args&&... __args)
{
- return std::vformat_to(std::move(__out), __fmt.get(),
+ return std::vformat_to(std::move(__out_), __fmt.get(),
std::make_wformat_args(__args...));
}
#endif
@@ -5540,10 +5540,10 @@ namespace __format
template<typename _Out, typename... _Args>
requires output_iterator<_Out, const char&>
inline _Out
- format_to(_Out __out, const locale& __loc, format_string<_Args...> __fmt,
+ format_to(_Out __out_, const locale& __loc, format_string<_Args...> __fmt,
_Args&&... __args)
{
- return std::vformat_to(std::move(__out), __loc, __fmt.get(),
+ return std::vformat_to(std::move(__out_), __loc, __fmt.get(),
std::make_format_args(__args...));
}
@@ -5551,10 +5551,10 @@ namespace __format
template<typename _Out, typename... _Args>
requires output_iterator<_Out, const wchar_t&>
inline _Out
- format_to(_Out __out, const locale& __loc, wformat_string<_Args...> __fmt,
+ format_to(_Out __out_, const locale& __loc, wformat_string<_Args...> __fmt,
_Args&&... __args)
{
- return std::vformat_to(std::move(__out), __loc, __fmt.get(),
+ return std::vformat_to(std::move(__out_), __loc, __fmt.get(),
std::make_wformat_args(__args...));
}
#endif
@@ -5562,11 +5562,11 @@ namespace __format
template<typename _Out, typename... _Args>
requires output_iterator<_Out, const char&>
inline format_to_n_result<_Out>
- format_to_n(_Out __out, iter_difference_t<_Out> __n,
+ format_to_n(_Out __out_, iter_difference_t<_Out> __n,
format_string<_Args...> __fmt, _Args&&... __args)
{
return __format::__do_vformat_to_n(
- std::move(__out), __n, __fmt.get(),
+ std::move(__out_), __n, __fmt.get(),
std::make_format_args(__args...));
}
@@ -5574,11 +5574,11 @@ namespace __format
template<typename _Out, typename... _Args>
requires output_iterator<_Out, const wchar_t&>
inline format_to_n_result<_Out>
- format_to_n(_Out __out, iter_difference_t<_Out> __n,
+ format_to_n(_Out __out_, iter_difference_t<_Out> __n,
wformat_string<_Args...> __fmt, _Args&&... __args)
{
return __format::__do_vformat_to_n(
- std::move(__out), __n, __fmt.get(),
+ std::move(__out_), __n, __fmt.get(),
std::make_wformat_args(__args...));
}
#endif
@@ -5586,11 +5586,11 @@ namespace __format
template<typename _Out, typename... _Args>
requires output_iterator<_Out, const char&>
inline format_to_n_result<_Out>
- format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
+ format_to_n(_Out __out_, iter_difference_t<_Out> __n, const locale& __loc,
format_string<_Args...> __fmt, _Args&&... __args)
{
return __format::__do_vformat_to_n(
- std::move(__out), __n, __fmt.get(),
+ std::move(__out_), __n, __fmt.get(),
std::make_format_args(__args...), &__loc);
}
@@ -5598,11 +5598,11 @@ namespace __format
template<typename _Out, typename... _Args>
requires output_iterator<_Out, const wchar_t&>
inline format_to_n_result<_Out>
- format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
+ format_to_n(_Out __out_, iter_difference_t<_Out> __n, const locale& __loc,
wformat_string<_Args...> __fmt, _Args&&... __args)
{
return __format::__do_vformat_to_n(
- std::move(__out), __n, __fmt.get(),
+ std::move(__out_), __n, __fmt.get(),
std::make_wformat_args(__args...), &__loc);
}
#endif
@@ -6210,23 +6210,23 @@ namespace __format
_M_format_elems(_Rg& __rg,
basic_format_context<_Out, _CharT>& __fc) const
{
- auto __out = __format::__write(__fc.out(), _M_open);
+ auto __out_ = __format::__write(__fc.out(), _M_open);
auto __first = ranges::begin(__rg);
auto const __last = ranges::end(__rg);
if (__first == __last)
- return __format::__write(__out, _M_close);
+ return __format::__write(__out_, _M_close);
- __fc.advance_to(__out);
- __out = _M_fval.format(*__first, __fc);
+ __fc.advance_to(__out_);
+ __out_ = _M_fval.format(*__first, __fc);
for (++__first; __first != __last; ++__first)
{
- __out = __format::__write(__out, _M_sep);
- __fc.advance_to(__out);
- __out = _M_fval.format(*__first, __fc);
+ __out_ = __format::__write(__out_, _M_sep);
+ __fc.advance_to(__out_);
+ __out_ = _M_fval.format(*__first, __fc);
}
- return __format::__write(__out, _M_close);
+ return __format::__write(__out_, _M_close);
}
__format::_Spec<_CharT> _M_spec{};
diff --git a/libstdc++-v3/include/std/inplace_vector b/libstdc++-v3/include/std/inplace_vector
index caf9c203245..f2ffd87cd52 100644
--- a/libstdc++-v3/include/std/inplace_vector
+++ b/libstdc++-v3/include/std/inplace_vector
@@ -267,24 +267,24 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
}
else
{
- auto [__in, __out] = ranges::copy_n(
+ auto [__in_, __out_] = ranges::copy_n(
ranges::begin(__rg), _M_size,
data());
ranges::uninitialized_copy(
- std::move(__in), ranges::end(__rg),
- __out, unreachable_sentinel);
+ std::move(__in_), ranges::end(__rg),
+ __out_, unreachable_sentinel);
}
_M_size = __sz;
}
else
{
- auto __in = ranges::begin(__rg);
+ auto __in_ = ranges::begin(__rg);
auto __end = ranges::end(__rg);
size_type __n = 0;
- for (; __n < _M_size && __in != __end; ++__in)
- _M_elems[__n++] = *__in;
+ for (; __n < _M_size && __in_ != __end; ++__in_)
+ _M_elems[__n++] = *__in_;
- if (__in == __end)
+ if (__in_ == __end)
{
std::destroy(data() + __n, data() + _M_size);
_M_size = __n;
@@ -293,7 +293,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
else if (__n < _Nm)
{
auto __res = ranges::uninitialized_copy(
- std::move(__in), __end,
+ std::move(__in_), __end,
data() + __n, data() + _Nm);
_M_size = __res.out - data();
if (__res.in == ranges::end(__rg))
@@ -546,9 +546,9 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
else
{
ranges::subrange<pointer> __tail(data() + _M_size, data() + _Nm);
- auto [__in, __out] = ranges::uninitialized_copy(__rg, __tail);
- _M_size = __out - data();
- if (__in != ranges::end(__rg))
+ auto [__in_, __out_] = ranges::uninitialized_copy(__rg, __tail);
+ _M_size = __out_ - data();
+ if (__in_ != ranges::end(__rg))
__throw_bad_alloc();
}
}
diff --git a/libstdc++-v3/include/std/istream b/libstdc++-v3/include/std/istream
index 9b8474a0da8..ce284765049 100644
--- a/libstdc++-v3/include/std/istream
+++ b/libstdc++-v3/include/std/istream
@@ -850,7 +850,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
///@{
/**
* @brief Character extractors
- * @param __in An input stream.
+ * @param __in_ An input stream.
* @param __c A character reference.
* @return in
*
@@ -861,17 +861,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
*/
template<typename _CharT, typename _Traits>
basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c);
+ operator>>(basic_istream<_CharT, _Traits>& __in_, _CharT& __c);
template<class _Traits>
inline basic_istream<char, _Traits>&
- operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c)
- { return (__in >> reinterpret_cast<char&>(__c)); }
+ operator>>(basic_istream<char, _Traits>& __in_, unsigned char& __c)
+ { return (__in_ >> reinterpret_cast<char&>(__c)); }
template<class _Traits>
inline basic_istream<char, _Traits>&
- operator>>(basic_istream<char, _Traits>& __in, signed char& __c)
- { return (__in >> reinterpret_cast<char&>(__c)); }
+ operator>>(basic_istream<char, _Traits>& __in_, signed char& __c)
+ { return (__in_ >> reinterpret_cast<char&>(__c)); }
///@}
@@ -884,9 +884,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
///@{
/**
* @brief Character string extractors
- * @param __in An input stream.
+ * @param __in_ An input stream.
* @param __s A character array (or a pointer to an array before C++20).
- * @return __in
+ * @return __in_
*
* Behaves like one of the formatted arithmetic extractors described in
* `std::basic_istream`. After constructing a sentry object with good
@@ -912,7 +912,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits>
__attribute__((__nonnull__(2), __access__(__write_only__, 2)))
inline basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s)
+ operator>>(basic_istream<_CharT, _Traits>& __in_, _CharT* __s)
{
#ifdef __OPTIMIZE__
// Function inlining might make the buffer size known, allowing us to
@@ -923,22 +923,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// There is not even space for the required null terminator.
__glibcxx_assert(__n >= sizeof(_CharT));
// No point calling __istream_extract, but still need to reset width.
- __in.width(0);
- __in.setstate(ios_base::failbit);
+ __in_.width(0);
+ __in_.setstate(ios_base::failbit);
}
else if (__n != (size_t)-1)
{
__n /= sizeof(_CharT);
- streamsize __w = __in.width();
- std::__istream_extract(__in, __s, __n);
- if (__in.good() && (__w <= 0 || __n < (size_t)__w))
+ streamsize __w = __in_.width();
+ std::__istream_extract(__in_, __s, __n);
+ if (__in_.good() && (__w <= 0 || __n < (size_t)__w))
{
// Stopped extracting early to avoid overflowing the buffer,
// but might have stopped anyway (and set eofbit) if at EOF.
- const typename _Traits::int_type __c = __in.rdbuf()->sgetc();
+ const typename _Traits::int_type __c = __in_.rdbuf()->sgetc();
const bool __eof = _Traits::eq_int_type(__c, _Traits::eof());
if (__builtin_expect(__eof, true)) // Assume EOF, not overflow.
- __in.setstate(ios_base::eofbit);
+ __in_.setstate(ios_base::eofbit);
}
}
else
@@ -947,43 +947,43 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Buffer size is unknown, have to assume it's huge.
streamsize __n = __gnu_cxx::__numeric_traits<streamsize>::__max;
__n /= sizeof(_CharT);
- std::__istream_extract(__in, __s, __n);
+ std::__istream_extract(__in_, __s, __n);
}
- return __in;
+ return __in_;
}
template<class _Traits>
__attribute__((__nonnull__(2), __access__(__write_only__, 2)))
inline basic_istream<char, _Traits>&
- operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s)
- { return __in >> reinterpret_cast<char*>(__s); }
+ operator>>(basic_istream<char, _Traits>& __in_, unsigned char* __s)
+ { return __in_ >> reinterpret_cast<char*>(__s); }
template<class _Traits>
__attribute__((__nonnull__(2), __access__(__write_only__, 2)))
inline basic_istream<char, _Traits>&
- operator>>(basic_istream<char, _Traits>& __in, signed char* __s)
- { return __in >> reinterpret_cast<char*>(__s); }
+ operator>>(basic_istream<char, _Traits>& __in_, signed char* __s)
+ { return __in_ >> reinterpret_cast<char*>(__s); }
#else
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2499. operator>>(istream&, char*) makes it hard to avoid buffer overflows
template<typename _CharT, typename _Traits, size_t _Num>
inline basic_istream<_CharT, _Traits>&
- operator>>(basic_istream<_CharT, _Traits>& __in, _CharT (&__s)[_Num])
+ operator>>(basic_istream<_CharT, _Traits>& __in_, _CharT (&__s)[_Num])
{
static_assert(_Num <= __gnu_cxx::__numeric_traits<streamsize>::__max);
- std::__istream_extract(__in, __s, _Num);
- return __in;
+ std::__istream_extract(__in_, __s, _Num);
+ return __in_;
}
template<class _Traits, size_t _Num>
inline basic_istream<char, _Traits>&
- operator>>(basic_istream<char, _Traits>& __in, unsigned char (&__s)[_Num])
- { return __in >> reinterpret_cast<char(&)[_Num]>(__s); }
+ operator>>(basic_istream<char, _Traits>& __in_, unsigned char (&__s)[_Num])
+ { return __in_ >> reinterpret_cast<char(&)[_Num]>(__s); }
template<class _Traits, size_t _Num>
inline basic_istream<char, _Traits>&
- operator>>(basic_istream<char, _Traits>& __in, signed char (&__s)[_Num])
- { return __in >> reinterpret_cast<char(&)[_Num]>(__s); }
+ operator>>(basic_istream<char, _Traits>& __in_, signed char (&__s)[_Num])
+ { return __in_ >> reinterpret_cast<char(&)[_Num]>(__s); }
#endif
///@}
diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
index 7d8b37f8c5c..c839572fa49 100644
--- a/libstdc++-v3/include/std/ranges
+++ b/libstdc++-v3/include/std/ranges
@@ -130,27 +130,27 @@ namespace ranges
#endif
template<__boxable _Tp>
- struct __box : std::optional<_Tp>
+ struct __box_ : std::optional<_Tp>
{
using std::optional<_Tp>::optional;
constexpr
- __box()
+ __box_()
noexcept(is_nothrow_default_constructible_v<_Tp>)
requires default_initializable<_Tp>
: std::optional<_Tp>{std::in_place}
{ }
- __box(const __box&) = default;
- __box(__box&&) = default;
+ __box_(const __box_&) = default;
+ __box_(__box_&&) = default;
using std::optional<_Tp>::operator=;
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 3477. Simplify constraints for semiregular-box
// 3572. copyable-box should be fully constexpr
- constexpr __box&
- operator=(const __box& __that)
+ constexpr __box_&
+ operator=(const __box_& __that)
noexcept(is_nothrow_copy_constructible_v<_Tp>)
requires (!copyable<_Tp>) && copy_constructible<_Tp>
{
@@ -164,8 +164,8 @@ namespace ranges
return *this;
}
- constexpr __box&
- operator=(__box&& __that)
+ constexpr __box_&
+ operator=(__box_&& __that)
noexcept(is_nothrow_move_constructible_v<_Tp>)
requires (!movable<_Tp>)
{
@@ -196,23 +196,23 @@ namespace ranges
// the primary template's API that we currently use.
template<__boxable _Tp>
requires __boxable_copyable<_Tp> || __boxable_movable<_Tp>
- struct __box<_Tp>
+ struct __box_<_Tp>
{
private:
[[no_unique_address]] _Tp _M_value = _Tp();
public:
- __box() requires default_initializable<_Tp> = default;
+ __box_() requires default_initializable<_Tp> = default;
constexpr explicit
- __box(const _Tp& __t)
+ __box_(const _Tp& __t)
noexcept(is_nothrow_copy_constructible_v<_Tp>)
requires copy_constructible<_Tp>
: _M_value(__t)
{ }
constexpr explicit
- __box(_Tp&& __t)
+ __box_(_Tp&& __t)
noexcept(is_nothrow_move_constructible_v<_Tp>)
: _M_value(std::move(__t))
{ }
@@ -220,20 +220,20 @@ namespace ranges
template<typename... _Args>
requires constructible_from<_Tp, _Args...>
constexpr explicit
- __box(in_place_t, _Args&&... __args)
+ __box_(in_place_t, _Args&&... __args)
noexcept(is_nothrow_constructible_v<_Tp, _Args...>)
: _M_value(std::forward<_Args>(__args)...)
{ }
- __box(const __box&) = default;
- __box(__box&&) = default;
- __box& operator=(const __box&) requires copyable<_Tp> = default;
- __box& operator=(__box&&) requires movable<_Tp> = default;
+ __box_(const __box_&) = default;
+ __box_(__box_&&) = default;
+ __box_& operator=(const __box_&) requires copyable<_Tp> = default;
+ __box_& operator=(__box_&&) requires movable<_Tp> = default;
// When _Tp is nothrow_copy_constructible but not copy_assignable,
// copy assignment is implemented via destroy-then-copy-construct.
- constexpr __box&
- operator=(const __box& __that) noexcept
+ constexpr __box_&
+ operator=(const __box_& __that) noexcept
requires (!copyable<_Tp>) && copy_constructible<_Tp>
{
static_assert(is_nothrow_copy_constructible_v<_Tp>);
@@ -246,8 +246,8 @@ namespace ranges
}
// Likewise for move assignment.
- constexpr __box&
- operator=(__box&& __that) noexcept
+ constexpr __box_&
+ operator=(__box_&& __that) noexcept
requires (!movable<_Tp>)
{
static_assert(is_nothrow_move_constructible_v<_Tp>);
@@ -493,7 +493,7 @@ namespace ranges
{ return _M_value.operator->(); }
private:
- [[no_unique_address]] __detail::__box<_Tp> _M_value;
+ [[no_unique_address]] __detail::__box_<_Tp> _M_value;
};
template<typename _Tp>
@@ -758,8 +758,8 @@ namespace ranges
_Sentinel() = default;
constexpr explicit
- _Sentinel(_Bound __bound)
- : _M_bound(__bound) { }
+ _Sentinel(_Bound __bound_)
+ : _M_bound(__bound_) { }
friend constexpr bool
operator==(const _Iterator& __x, const _Sentinel& __y)
@@ -791,11 +791,11 @@ namespace ranges
constexpr explicit
iota_view(type_identity_t<_Winc> __value,
- type_identity_t<_Bound> __bound)
- : _M_value(__value), _M_bound(__bound)
+ type_identity_t<_Bound> __bound_)
+ : _M_value(__value), _M_bound(__bound_)
{
if constexpr (totally_ordered_with<_Winc, _Bound>)
- __glibcxx_assert( bool(__value <= __bound) );
+ __glibcxx_assert( bool(__value <= __bound_) );
}
constexpr explicit
@@ -1890,7 +1890,7 @@ namespace views::__adaptor
};
_Vp _M_base = _Vp();
- [[no_unique_address]] __detail::__box<_Pred> _M_pred;
+ [[no_unique_address]] __detail::__box_<_Pred> _M_pred;
[[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
public:
@@ -2282,7 +2282,7 @@ namespace views::__adaptor
};
_Vp _M_base = _Vp();
- [[no_unique_address]] __detail::__box<_Fp> _M_fun;
+ [[no_unique_address]] __detail::__box_<_Fp> _M_fun;
public:
transform_view() requires (default_initializable<_Vp>
@@ -2660,7 +2660,7 @@ namespace views::__adaptor
};
_Vp _M_base = _Vp();
- [[no_unique_address]] __detail::__box<_Pred> _M_pred;
+ [[no_unique_address]] __detail::__box_<_Pred> _M_pred;
public:
take_while_view() requires (default_initializable<_Vp>
@@ -2905,7 +2905,7 @@ namespace views::__adaptor
{
private:
_Vp _M_base = _Vp();
- [[no_unique_address]] __detail::__box<_Pred> _M_pred;
+ [[no_unique_address]] __detail::__box_<_Pred> _M_pred;
[[no_unique_address]] __detail::_CachedPosition<_Vp> _M_cached_begin;
public:
@@ -3195,13 +3195,13 @@ namespace views::__adaptor
constexpr _Iterator&
operator++()
{
- auto&& __inner_range = [this] () -> auto&& {
+ auto&& __inner_range_ = [this] () -> auto&& {
if constexpr (_S_ref_is_glvalue)
return *_M_get_outer();
else
return *_M_parent->_M_inner;
}();
- if (++_M_get_inner() == ranges::end(__inner_range))
+ if (++_M_get_inner() == ranges::end(__inner_range_))
{
++_M_get_outer();
_M_satisfy();
@@ -5176,7 +5176,7 @@ namespace views::__adaptor
&& std::__detail::__can_reference<invoke_result_t<_Fp&, range_reference_t<_Vs>...>>
class zip_transform_view : public view_interface<zip_transform_view<_Fp, _Vs...>>
{
- [[no_unique_address]] __detail::__box<_Fp> _M_fun;
+ [[no_unique_address]] __detail::__box_<_Fp> _M_fun;
zip_view<_Vs...> _M_zip;
using _InnerView = zip_view<_Vs...>;
@@ -5896,7 +5896,7 @@ namespace views::__adaptor
range_reference_t<_Vp>>>
class adjacent_transform_view : public view_interface<adjacent_transform_view<_Vp, _Fp, _Nm>>
{
- [[no_unique_address]] __detail::__box<_Fp> _M_fun;
+ [[no_unique_address]] __detail::__box_<_Fp> _M_fun;
adjacent_view<_Vp, _Nm> _M_inner;
using _InnerView = adjacent_view<_Vp, _Nm>;
@@ -7171,7 +7171,7 @@ namespace views::__adaptor
class chunk_by_view : public view_interface<chunk_by_view<_Vp, _Pred>>
{
_Vp _M_base = _Vp();
- __detail::__box<_Pred> _M_pred;
+ __detail::__box_<_Pred> _M_pred;
__detail::_CachedPosition<_Vp> _M_cached_begin;
constexpr iterator_t<_Vp>
@@ -7896,7 +7896,7 @@ namespace views::__adaptor
&& (__detail::__is_integer_like<_Bound> || same_as<_Bound, unreachable_sentinel_t>)
class repeat_view : public view_interface<repeat_view<_Tp, _Bound>>
{
- [[no_unique_address]] __detail::__box<_Tp> _M_value;
+ [[no_unique_address]] __detail::__box_<_Tp> _M_value;
[[no_unique_address]] _Bound _M_bound = _Bound();
class _Iterator;
@@ -7913,17 +7913,17 @@ namespace views::__adaptor
repeat_view() requires default_initializable<_Tp> = default;
constexpr explicit
- repeat_view(const _Tp& __value, _Bound __bound = _Bound())
+ repeat_view(const _Tp& __value, _Bound __bound_ = _Bound())
requires copy_constructible<_Tp>
- : _M_value(__value), _M_bound(__bound)
+ : _M_value(__value), _M_bound(__bound_)
{
if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
- __glibcxx_assert(__bound >= 0);
+ __glibcxx_assert(__bound_ >= 0);
}
constexpr explicit
- repeat_view(_Tp&& __value, _Bound __bound = _Bound())
- : _M_value(std::move(__value)), _M_bound(__bound)
+ repeat_view(_Tp&& __value, _Bound __bound_ = _Bound())
+ : _M_value(std::move(__value)), _M_bound(__bound_)
{ }
template<typename... _Args, typename... _BoundArgs>
@@ -7971,11 +7971,11 @@ namespace views::__adaptor
__index_type _M_current = __index_type();
constexpr explicit
- _Iterator(const _Tp* __value, __index_type __bound = __index_type())
- : _M_value(__value), _M_current(__bound)
+ _Iterator(const _Tp* __value, __index_type __bound_ = __index_type())
+ : _M_value(__value), _M_current(__bound_)
{
if constexpr (!same_as<_Bound, unreachable_sentinel_t>)
- __glibcxx_assert(__bound >= 0);
+ __glibcxx_assert(__bound_ >= 0);
}
friend repeat_view;
@@ -8113,8 +8113,8 @@ namespace views::__adaptor
template<typename _Tp, typename _Bound>
requires __detail::__can_bounded_repeat_view<_Tp, _Bound>
constexpr auto
- operator() [[nodiscard]] (_Tp&& __value, _Bound __bound) const
- { return repeat_view(std::forward<_Tp>(__value), __bound); }
+ operator() [[nodiscard]] (_Tp&& __value, _Bound __bound_) const
+ { return repeat_view(std::forward<_Tp>(__value), __bound_); }
};
inline constexpr _Repeat repeat;
diff --git a/libstdc++-v3/include/std/span b/libstdc++-v3/include/std/span
index aaa7a485be8..940aeb584c7 100644
--- a/libstdc++-v3/include/std/span
+++ b/libstdc++-v3/include/std/span
@@ -224,10 +224,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
&& (ranges::borrowed_range<_Range> || is_const_v<element_type>)
&& __is_compatible_ref<ranges::range_reference_t<_Range>>::value
constexpr explicit(extent != dynamic_extent)
- span(_Range&& __range)
- noexcept(noexcept(ranges::data(__range))
- && noexcept(ranges::size(__range)))
- : _M_ptr(ranges::data(__range)), _M_extent(ranges::size(__range))
+ span(_Range&& __range_)
+ noexcept(noexcept(ranges::data(__range_))
+ && noexcept(ranges::size(__range_)))
+ : _M_ptr(ranges::data(__range_)), _M_extent(ranges::size(__range_))
{ }
constexpr
diff --git a/libstdc++-v3/include/std/stop_token b/libstdc++-v3/include/std/stop_token
index 67c8104f89c..6aa0da4e158 100644
--- a/libstdc++-v3/include/std/stop_token
+++ b/libstdc++-v3/include/std/stop_token
@@ -377,7 +377,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
bool
_M_do_try_lock(value_type& __curval, value_type __newbits,
- memory_order __success, memory_order __failure) noexcept
+ memory_order __success_, memory_order __failure) noexcept
{
if (__curval & _S_locked_bit)
{
@@ -387,7 +387,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
__newbits |= _S_locked_bit;
return _M_value.compare_exchange_weak(__curval, __curval | __newbits,
- __success, __failure);
+ __success_, __failure);
}
};
diff --git a/libstdc++-v3/include/std/thread b/libstdc++-v3/include/std/thread
index a4252321c0f..bbfa414e8b6 100644
--- a/libstdc++-v3/include/std/thread
+++ b/libstdc++-v3/include/std/thread
@@ -104,7 +104,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<class _CharT, class _Traits>
inline basic_ostream<_CharT, _Traits>&
- operator<<(basic_ostream<_CharT, _Traits>& __out, thread::id __id)
+ operator<<(basic_ostream<_CharT, _Traits>& __out_, thread::id __id)
{
// Convert non-void pointers to const void* for formatted output.
using __output_type
@@ -113,9 +113,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
thread::native_handle_type>;
if (__id == thread::id())
- return __out << "thread::id of a non-executing thread";
+ return __out_ << "thread::id of a non-executing thread";
else
- return __out << static_cast<__output_type>(__id._M_thread);
+ return __out_ << static_cast<__output_type>(__id._M_thread);
}
/// @}
diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple
index 64b96fe4f59..de18aea149f 100644
--- a/libstdc++-v3/include/std/tuple
+++ b/libstdc++-v3/include/std/tuple
@@ -286,35 +286,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename... _UElements>
constexpr
- _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
- : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
- _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in))
+ _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in_)
+ : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in_)),
+ _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in_))
{ }
template<typename _UHead, typename... _UTails>
constexpr
- _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+ _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in_)
: _Inherited(std::move
- (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+ (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in_))),
_Base(std::forward<_UHead>
- (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
+ (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in_)))
{ }
#if __cpp_lib_ranges_zip // >= C++23
template<typename... _UElements>
constexpr
- _Tuple_impl(_Tuple_impl<_Idx, _UElements...>& __in)
- : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)),
- _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in))
+ _Tuple_impl(_Tuple_impl<_Idx, _UElements...>& __in_)
+ : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in_)),
+ _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in_))
{ }
template<typename _UHead, typename... _UTails>
constexpr
- _Tuple_impl(const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+ _Tuple_impl(const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in_)
: _Inherited(std::move
- (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+ (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in_))),
_Base(std::forward<const _UHead>
- (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
+ (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in_)))
{ }
#endif // C++23
@@ -354,61 +354,61 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Alloc>
_GLIBCXX20_CONSTEXPR
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
- const _Tuple_impl& __in)
- : _Inherited(__tag, __a, _M_tail(__in)),
- _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in))
+ const _Tuple_impl& __in_)
+ : _Inherited(__tag, __a, _M_tail(__in_)),
+ _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in_))
{ }
template<typename _Alloc>
_GLIBCXX20_CONSTEXPR
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
- _Tuple_impl&& __in)
- : _Inherited(__tag, __a, std::move(_M_tail(__in))),
+ _Tuple_impl&& __in_)
+ : _Inherited(__tag, __a, std::move(_M_tail(__in_))),
_Base(__use_alloc<_Head, _Alloc, _Head>(__a),
- std::forward<_Head>(_M_head(__in)))
+ std::forward<_Head>(_M_head(__in_)))
{ }
template<typename _Alloc, typename _UHead, typename... _UTails>
_GLIBCXX20_CONSTEXPR
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
- const _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
+ const _Tuple_impl<_Idx, _UHead, _UTails...>& __in_)
: _Inherited(__tag, __a,
- _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
+ _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in_)),
_Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
- _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))
+ _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in_))
{ }
template<typename _Alloc, typename _UHead, typename... _UTails>
_GLIBCXX20_CONSTEXPR
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
- _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+ _Tuple_impl<_Idx, _UHead, _UTails...>&& __in_)
: _Inherited(__tag, __a, std::move
- (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+ (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in_))),
_Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
std::forward<_UHead>
- (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
+ (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in_)))
{ }
#if __cpp_lib_ranges_zip // >= C++23
template<typename _Alloc, typename _UHead, typename... _UTails>
constexpr
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
- _Tuple_impl<_Idx, _UHead, _UTails...>& __in)
+ _Tuple_impl<_Idx, _UHead, _UTails...>& __in_)
: _Inherited(__tag, __a,
- _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)),
+ _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in_)),
_Base(__use_alloc<_Head, _Alloc, _UHead&>(__a),
- _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))
+ _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in_))
{ }
template<typename _Alloc, typename _UHead, typename... _UTails>
constexpr
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
- const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+ const _Tuple_impl<_Idx, _UHead, _UTails...>&& __in_)
: _Inherited(__tag, __a, std::move
- (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))),
+ (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in_))),
_Base(__use_alloc<_Head, _Alloc, const _UHead>(__a),
std::forward<const _UHead>
- (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)))
+ (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in_)))
{ }
#endif // C++23
@@ -424,42 +424,42 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename... _UElements>
_GLIBCXX20_CONSTEXPR
void
- _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in)
+ _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in_)
{
- _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
+ _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in_);
_M_tail(*this)._M_assign(
- _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
+ _Tuple_impl<_Idx, _UElements...>::_M_tail(__in_));
}
template<typename _UHead, typename... _UTails>
_GLIBCXX20_CONSTEXPR
void
- _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
+ _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in_)
{
_M_head(*this) = std::forward<_UHead>
- (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
+ (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in_));
_M_tail(*this)._M_assign(
- std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
+ std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in_)));
}
#if __cpp_lib_ranges_zip // >= C++23
template<typename... _UElements>
constexpr void
- _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) const
+ _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in_) const
{
- _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
+ _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in_);
_M_tail(*this)._M_assign(
- _Tuple_impl<_Idx, _UElements...>::_M_tail(__in));
+ _Tuple_impl<_Idx, _UElements...>::_M_tail(__in_));
}
template<typename _UHead, typename... _UTails>
constexpr void
- _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) const
+ _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in_) const
{
_M_head(*this) = std::forward<_UHead>
- (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
+ (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in_));
_M_tail(*this)._M_assign(
- std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)));
+ std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in_)));
}
#endif // C++23
@@ -484,20 +484,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
protected:
_GLIBCXX20_CONSTEXPR
void
- _M_swap(_Tuple_impl& __in)
+ _M_swap(_Tuple_impl& __in_)
{
using std::swap;
- swap(_M_head(*this), _M_head(__in));
- _Inherited::_M_swap(_M_tail(__in));
+ swap(_M_head(*this), _M_head(__in_));
+ _Inherited::_M_swap(_M_tail(__in_));
}
#if __cpp_lib_ranges_zip // >= C++23
constexpr void
- _M_swap(const _Tuple_impl& __in) const
+ _M_swap(const _Tuple_impl& __in_) const
{
using std::swap;
- swap(_M_head(*this), _M_head(__in));
- _Inherited::_M_swap(_M_tail(__in));
+ swap(_M_head(*this), _M_head(__in_));
+ _Inherited::_M_swap(_M_tail(__in_));
}
#endif // C++23
};
@@ -542,35 +542,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Tuple_impl(_Tuple_impl&&) = default;
#else
constexpr
- _Tuple_impl(_Tuple_impl&& __in)
+ _Tuple_impl(_Tuple_impl&& __in_)
noexcept(is_nothrow_move_constructible<_Head>::value)
- : _Base(static_cast<_Base&&>(__in))
+ : _Base(static_cast<_Base&&>(__in_))
{ }
#endif
template<typename _UHead>
constexpr
- _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
- : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in))
+ _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in_)
+ : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in_))
{ }
template<typename _UHead>
constexpr
- _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
- : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+ _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in_)
+ : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in_)))
{ }
#if __cpp_lib_ranges_zip // >= C++23
template<typename _UHead>
constexpr
- _Tuple_impl(_Tuple_impl<_Idx, _UHead>& __in)
- : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in))
+ _Tuple_impl(_Tuple_impl<_Idx, _UHead>& __in_)
+ : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in_))
{ }
template<typename _UHead>
constexpr
- _Tuple_impl(const _Tuple_impl<_Idx, _UHead>&& __in)
- : _Base(std::forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+ _Tuple_impl(const _Tuple_impl<_Idx, _UHead>&& __in_)
+ : _Base(std::forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in_)))
{ }
#endif // C++23
@@ -606,49 +606,49 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Alloc>
_GLIBCXX20_CONSTEXPR
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
- const _Tuple_impl& __in)
- : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in))
+ const _Tuple_impl& __in_)
+ : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in_))
{ }
template<typename _Alloc>
_GLIBCXX20_CONSTEXPR
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
- _Tuple_impl&& __in)
+ _Tuple_impl&& __in_)
: _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
- std::forward<_Head>(_M_head(__in)))
+ std::forward<_Head>(_M_head(__in_)))
{ }
template<typename _Alloc, typename _UHead>
_GLIBCXX20_CONSTEXPR
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
- const _Tuple_impl<_Idx, _UHead>& __in)
+ const _Tuple_impl<_Idx, _UHead>& __in_)
: _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a),
- _Tuple_impl<_Idx, _UHead>::_M_head(__in))
+ _Tuple_impl<_Idx, _UHead>::_M_head(__in_))
{ }
template<typename _Alloc, typename _UHead>
_GLIBCXX20_CONSTEXPR
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
- _Tuple_impl<_Idx, _UHead>&& __in)
+ _Tuple_impl<_Idx, _UHead>&& __in_)
: _Base(__use_alloc<_Head, _Alloc, _UHead>(__a),
- std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+ std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in_)))
{ }
#if __cpp_lib_ranges_zip // >= C++23
template<typename _Alloc, typename _UHead>
constexpr
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
- _Tuple_impl<_Idx, _UHead>& __in)
+ _Tuple_impl<_Idx, _UHead>& __in_)
: _Base(__use_alloc<_Head, _Alloc, _UHead&>(__a),
- _Tuple_impl<_Idx, _UHead>::_M_head(__in))
+ _Tuple_impl<_Idx, _UHead>::_M_head(__in_))
{ }
template<typename _Alloc, typename _UHead>
constexpr
_Tuple_impl(allocator_arg_t, const _Alloc& __a,
- const _Tuple_impl<_Idx, _UHead>&& __in)
+ const _Tuple_impl<_Idx, _UHead>&& __in_)
: _Base(__use_alloc<_Head, _Alloc, const _UHead>(__a),
- std::forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)))
+ std::forward<const _UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in_)))
{ }
#endif // C++23
@@ -664,34 +664,34 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _UHead>
_GLIBCXX20_CONSTEXPR
void
- _M_assign(const _Tuple_impl<_Idx, _UHead>& __in)
+ _M_assign(const _Tuple_impl<_Idx, _UHead>& __in_)
{
- _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
+ _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in_);
}
template<typename _UHead>
_GLIBCXX20_CONSTEXPR
void
- _M_assign(_Tuple_impl<_Idx, _UHead>&& __in)
+ _M_assign(_Tuple_impl<_Idx, _UHead>&& __in_)
{
_M_head(*this)
- = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
+ = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in_));
}
#if __cpp_lib_ranges_zip // >= C++23
template<typename _UHead>
constexpr void
- _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) const
+ _M_assign(const _Tuple_impl<_Idx, _UHead>& __in_) const
{
- _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in);
+ _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in_);
}
template<typename _UHead>
constexpr void
- _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) const
+ _M_assign(_Tuple_impl<_Idx, _UHead>&& __in_) const
{
_M_head(*this)
- = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
+ = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in_));
}
#endif // C++23
@@ -710,18 +710,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
protected:
_GLIBCXX20_CONSTEXPR
void
- _M_swap(_Tuple_impl& __in)
+ _M_swap(_Tuple_impl& __in_)
{
using std::swap;
- swap(_M_head(*this), _M_head(__in));
+ swap(_M_head(*this), _M_head(__in_));
}
#if __cpp_lib_ranges_zip // >= C++23
constexpr void
- _M_swap(const _Tuple_impl& __in) const
+ _M_swap(const _Tuple_impl& __in_) const
{
using std::swap;
- swap(_M_head(*this), _M_head(__in));
+ swap(_M_head(*this), _M_head(__in_));
}
#endif // C++23
};
@@ -1471,9 +1471,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
&& !__use_other_ctor<const tuple<_UElements...>&>(),
_ImplicitCtor<_Valid, const _UElements&...> = true>
constexpr
- tuple(const tuple<_UElements...>& __in)
+ tuple(const tuple<_UElements...>& __in_)
noexcept(__nothrow_constructible<const _UElements&...>())
- : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in_))
{ __glibcxx_no_dangling_refs(const _UElements&); }
template<typename... _UElements,
@@ -1481,9 +1481,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
&& !__use_other_ctor<const tuple<_UElements...>&>(),
_ExplicitCtor<_Valid, const _UElements&...> = false>
explicit constexpr
- tuple(const tuple<_UElements...>& __in)
+ tuple(const tuple<_UElements...>& __in_)
noexcept(__nothrow_constructible<const _UElements&...>())
- : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ : _Inherited(static_cast<const _Tuple_impl<0, _UElements...>&>(__in_))
{ __glibcxx_no_dangling_refs(const _UElements&); }
template<typename... _UElements,
@@ -1491,9 +1491,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
&& !__use_other_ctor<tuple<_UElements...>&&>(),
_ImplicitCtor<_Valid, _UElements...> = true>
constexpr
- tuple(tuple<_UElements...>&& __in)
+ tuple(tuple<_UElements...>&& __in_)
noexcept(__nothrow_constructible<_UElements...>())
- : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+ : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in_))
{ __glibcxx_no_dangling_refs(_UElements&&); }
template<typename... _UElements,
@@ -1501,9 +1501,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
&& !__use_other_ctor<tuple<_UElements...>&&>(),
_ExplicitCtor<_Valid, _UElements...> = false>
explicit constexpr
- tuple(tuple<_UElements...>&& __in)
+ tuple(tuple<_UElements...>&& __in_)
noexcept(__nothrow_constructible<_UElements...>())
- : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+ : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in_))
{ __glibcxx_no_dangling_refs(_UElements&&); }
// Allocator-extended constructors.
@@ -1557,13 +1557,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Alloc>
_GLIBCXX20_CONSTEXPR
- tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
- : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
+ tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in_)
+ : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in_)) { }
template<typename _Alloc>
_GLIBCXX20_CONSTEXPR
- tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
- : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in_)
+ : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in_)) { }
template<typename _Alloc, typename... _UElements,
bool _Valid = (sizeof...(_Elements) == sizeof...(_UElements))
@@ -1571,9 +1571,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_ImplicitCtor<_Valid, const _UElements&...> = true>
_GLIBCXX20_CONSTEXPR
tuple(allocator_arg_t __tag, const _Alloc& __a,
- const tuple<_UElements...>& __in)
+ const tuple<_UElements...>& __in_)
: _Inherited(__tag, __a,
- static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ static_cast<const _Tuple_impl<0, _UElements...>&>(__in_))
{ __glibcxx_no_dangling_refs(const _UElements&); }
template<typename _Alloc, typename... _UElements,
@@ -1583,9 +1583,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX20_CONSTEXPR
explicit
tuple(allocator_arg_t __tag, const _Alloc& __a,
- const tuple<_UElements...>& __in)
+ const tuple<_UElements...>& __in_)
: _Inherited(__tag, __a,
- static_cast<const _Tuple_impl<0, _UElements...>&>(__in))
+ static_cast<const _Tuple_impl<0, _UElements...>&>(__in_))
{ __glibcxx_no_dangling_refs(const _UElements&); }
template<typename _Alloc, typename... _UElements,
@@ -1594,9 +1594,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_ImplicitCtor<_Valid, _UElements...> = true>
_GLIBCXX20_CONSTEXPR
tuple(allocator_arg_t __tag, const _Alloc& __a,
- tuple<_UElements...>&& __in)
+ tuple<_UElements...>&& __in_)
: _Inherited(__tag, __a,
- static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+ static_cast<_Tuple_impl<0, _UElements...>&&>(__in_))
{ __glibcxx_no_dangling_refs(_UElements&&); }
template<typename _Alloc, typename... _UElements,
@@ -1606,9 +1606,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX20_CONSTEXPR
explicit
tuple(allocator_arg_t __tag, const _Alloc& __a,
- tuple<_UElements...>&& __in)
+ tuple<_UElements...>&& __in_)
: _Inherited(__tag, __a,
- static_cast<_Tuple_impl<0, _UElements...>&&>(__in))
+ static_cast<_Tuple_impl<0, _UElements...>&&>(__in_))
{ __glibcxx_no_dangling_refs(_UElements&&); }
#endif // concepts && conditional_explicit
@@ -1868,10 +1868,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
tuple&
operator=(__conditional_t<__assignable<const _Elements&...>(),
const tuple&,
- const __nonesuch&> __in)
+ const __nonesuch&> __in_)
noexcept(__nothrow_assignable<const _Elements&...>())
{
- this->_M_assign(__in);
+ this->_M_assign(__in_);
return *this;
}
@@ -1879,30 +1879,30 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
tuple&
operator=(__conditional_t<__assignable<_Elements...>(),
tuple&&,
- __nonesuch&&> __in)
+ __nonesuch&&> __in_)
noexcept(__nothrow_assignable<_Elements...>())
{
- this->_M_assign(std::move(__in));
+ this->_M_assign(std::move(__in_));
return *this;
}
template<typename... _UElements>
_GLIBCXX20_CONSTEXPR
__enable_if_t<__assignable<const _UElements&...>(), tuple&>
- operator=(const tuple<_UElements...>& __in)
+ operator=(const tuple<_UElements...>& __in_)
noexcept(__nothrow_assignable<const _UElements&...>())
{
- this->_M_assign(__in);
+ this->_M_assign(__in_);
return *this;
}
template<typename... _UElements>
_GLIBCXX20_CONSTEXPR
__enable_if_t<__assignable<_UElements...>(), tuple&>
- operator=(tuple<_UElements...>&& __in)
+ operator=(tuple<_UElements...>&& __in_)
noexcept(__nothrow_assignable<_UElements...>())
{
- this->_M_assign(std::move(__in));
+ this->_M_assign(std::move(__in_));
return *this;
}
#endif // concepts && consteval
@@ -1910,9 +1910,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// tuple swap
_GLIBCXX20_CONSTEXPR
void
- swap(tuple& __in)
+ swap(tuple& __in_)
noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value)
- { _Inherited::_M_swap(__in); }
+ { _Inherited::_M_swap(__in_); }
#if __cpp_lib_ranges_zip // >= C++23
// As an extension, we constrain the const swap member function in order
@@ -1922,10 +1922,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// this function and yield a hard error. This constraint shouldn't
// affect the behavior of valid programs.
constexpr void
- swap(const tuple& __in) const
+ swap(const tuple& __in_) const
noexcept(__and_v<__is_nothrow_swappable<const _Elements>...>)
requires (is_swappable_v<const _Elements> && ...)
- { _Inherited::_M_swap(__in); }
+ { _Inherited::_M_swap(__in_); }
#endif // C++23
};
@@ -2153,67 +2153,67 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _U1, typename _U2,
_ImplicitCtor<true, const _U1&, const _U2&> = true>
constexpr
- tuple(const tuple<_U1, _U2>& __in)
+ tuple(const tuple<_U1, _U2>& __in_)
noexcept(__nothrow_constructible<const _U1&, const _U2&>())
- : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+ : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in_))
{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
template<typename _U1, typename _U2,
_ExplicitCtor<true, const _U1&, const _U2&> = false>
explicit constexpr
- tuple(const tuple<_U1, _U2>& __in)
+ tuple(const tuple<_U1, _U2>& __in_)
noexcept(__nothrow_constructible<const _U1&, const _U2&>())
- : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+ : _Inherited(static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in_))
{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
template<typename _U1, typename _U2,
_ImplicitCtor<true, _U1, _U2> = true>
constexpr
- tuple(tuple<_U1, _U2>&& __in)
+ tuple(tuple<_U1, _U2>&& __in_)
noexcept(__nothrow_constructible<_U1, _U2>())
- : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+ : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in_))
{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
template<typename _U1, typename _U2,
_ExplicitCtor<true, _U1, _U2> = false>
explicit constexpr
- tuple(tuple<_U1, _U2>&& __in)
+ tuple(tuple<_U1, _U2>&& __in_)
noexcept(__nothrow_constructible<_U1, _U2>())
- : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+ : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in_))
{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
template<typename _U1, typename _U2,
_ImplicitCtor<true, const _U1&, const _U2&> = true>
constexpr
- tuple(const pair<_U1, _U2>& __in)
+ tuple(const pair<_U1, _U2>& __in_)
noexcept(__nothrow_constructible<const _U1&, const _U2&>())
- : _Inherited(__in.first, __in.second)
+ : _Inherited(__in_.first, __in_.second)
{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
template<typename _U1, typename _U2,
_ExplicitCtor<true, const _U1&, const _U2&> = false>
explicit constexpr
- tuple(const pair<_U1, _U2>& __in)
+ tuple(const pair<_U1, _U2>& __in_)
noexcept(__nothrow_constructible<const _U1&, const _U2&>())
- : _Inherited(__in.first, __in.second)
+ : _Inherited(__in_.first, __in_.second)
{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
template<typename _U1, typename _U2,
_ImplicitCtor<true, _U1, _U2> = true>
constexpr
- tuple(pair<_U1, _U2>&& __in)
+ tuple(pair<_U1, _U2>&& __in_)
noexcept(__nothrow_constructible<_U1, _U2>())
- : _Inherited(std::forward<_U1>(__in.first),
- std::forward<_U2>(__in.second))
+ : _Inherited(std::forward<_U1>(__in_.first),
+ std::forward<_U2>(__in_.second))
{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
template<typename _U1, typename _U2,
_ExplicitCtor<true, _U1, _U2> = false>
explicit constexpr
- tuple(pair<_U1, _U2>&& __in)
+ tuple(pair<_U1, _U2>&& __in_)
noexcept(__nothrow_constructible<_U1, _U2>())
- : _Inherited(std::forward<_U1>(__in.first),
- std::forward<_U2>(__in.second))
+ : _Inherited(std::forward<_U1>(__in_.first),
+ std::forward<_U2>(__in_.second))
{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
// Allocator-extended constructors.
@@ -2266,21 +2266,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Alloc>
_GLIBCXX20_CONSTEXPR
- tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
- : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in)) { }
+ tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in_)
+ : _Inherited(__tag, __a, static_cast<const _Inherited&>(__in_)) { }
template<typename _Alloc>
_GLIBCXX20_CONSTEXPR
- tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
- : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { }
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in_)
+ : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in_)) { }
template<typename _Alloc, typename _U1, typename _U2,
_ImplicitCtor<true, const _U1&, const _U2&> = true>
_GLIBCXX20_CONSTEXPR
tuple(allocator_arg_t __tag, const _Alloc& __a,
- const tuple<_U1, _U2>& __in)
+ const tuple<_U1, _U2>& __in_)
: _Inherited(__tag, __a,
- static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+ static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in_))
{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
template<typename _Alloc, typename _U1, typename _U2,
@@ -2288,32 +2288,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
explicit
_GLIBCXX20_CONSTEXPR
tuple(allocator_arg_t __tag, const _Alloc& __a,
- const tuple<_U1, _U2>& __in)
+ const tuple<_U1, _U2>& __in_)
: _Inherited(__tag, __a,
- static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in))
+ static_cast<const _Tuple_impl<0, _U1, _U2>&>(__in_))
{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
template<typename _Alloc, typename _U1, typename _U2,
_ImplicitCtor<true, _U1, _U2> = true>
_GLIBCXX20_CONSTEXPR
- tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
- : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in_)
+ : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in_))
{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
template<typename _Alloc, typename _U1, typename _U2,
_ExplicitCtor<true, _U1, _U2> = false>
explicit
_GLIBCXX20_CONSTEXPR
- tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in)
- : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in))
+ tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in_)
+ : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in_))
{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
template<typename _Alloc, typename _U1, typename _U2,
_ImplicitCtor<true, const _U1&, const _U2&> = true>
_GLIBCXX20_CONSTEXPR
tuple(allocator_arg_t __tag, const _Alloc& __a,
- const pair<_U1, _U2>& __in)
- : _Inherited(__tag, __a, __in.first, __in.second)
+ const pair<_U1, _U2>& __in_)
+ : _Inherited(__tag, __a, __in_.first, __in_.second)
{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
template<typename _Alloc, typename _U1, typename _U2,
@@ -2321,25 +2321,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
explicit
_GLIBCXX20_CONSTEXPR
tuple(allocator_arg_t __tag, const _Alloc& __a,
- const pair<_U1, _U2>& __in)
- : _Inherited(__tag, __a, __in.first, __in.second)
+ const pair<_U1, _U2>& __in_)
+ : _Inherited(__tag, __a, __in_.first, __in_.second)
{ __glibcxx_no_dangling_refs(const _U1&, const _U2&); }
template<typename _Alloc, typename _U1, typename _U2,
_ImplicitCtor<true, _U1, _U2> = true>
_GLIBCXX20_CONSTEXPR
- tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
- : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
- std::forward<_U2>(__in.second))
+ tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in_)
+ : _Inherited(__tag, __a, std::forward<_U1>(__in_.first),
+ std::forward<_U2>(__in_.second))
{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
template<typename _Alloc, typename _U1, typename _U2,
_ExplicitCtor<true, _U1, _U2> = false>
explicit
_GLIBCXX20_CONSTEXPR
- tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in)
- : _Inherited(__tag, __a, std::forward<_U1>(__in.first),
- std::forward<_U2>(__in.second))
+ tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in_)
+ : _Inherited(__tag, __a, std::forward<_U1>(__in_.first),
+ std::forward<_U2>(__in_.second))
{ __glibcxx_no_dangling_refs(_U1&&, _U2&&); }
// Tuple assignment.
@@ -2348,10 +2348,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
tuple&
operator=(__conditional_t<__assignable<const _T1&, const _T2&>(),
const tuple&,
- const __nonesuch&> __in)
+ const __nonesuch&> __in_)
noexcept(__nothrow_assignable<const _T1&, const _T2&>())
{
- this->_M_assign(__in);
+ this->_M_assign(__in_);
return *this;
}
@@ -2359,61 +2359,61 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
tuple&
operator=(__conditional_t<__assignable<_T1, _T2>(),
tuple&&,
- __nonesuch&&> __in)
+ __nonesuch&&> __in_)
noexcept(__nothrow_assignable<_T1, _T2>())
{
- this->_M_assign(std::move(__in));
+ this->_M_assign(std::move(__in_));
return *this;
}
template<typename _U1, typename _U2>
_GLIBCXX20_CONSTEXPR
__enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
- operator=(const tuple<_U1, _U2>& __in)
+ operator=(const tuple<_U1, _U2>& __in_)
noexcept(__nothrow_assignable<const _U1&, const _U2&>())
{
- this->_M_assign(__in);
+ this->_M_assign(__in_);
return *this;
}
template<typename _U1, typename _U2>
_GLIBCXX20_CONSTEXPR
__enable_if_t<__assignable<_U1, _U2>(), tuple&>
- operator=(tuple<_U1, _U2>&& __in)
+ operator=(tuple<_U1, _U2>&& __in_)
noexcept(__nothrow_assignable<_U1, _U2>())
{
- this->_M_assign(std::move(__in));
+ this->_M_assign(std::move(__in_));
return *this;
}
template<typename _U1, typename _U2>
_GLIBCXX20_CONSTEXPR
__enable_if_t<__assignable<const _U1&, const _U2&>(), tuple&>
- operator=(const pair<_U1, _U2>& __in)
+ operator=(const pair<_U1, _U2>& __in_)
noexcept(__nothrow_assignable<const _U1&, const _U2&>())
{
- this->_M_head(*this) = __in.first;
- this->_M_tail(*this)._M_head(*this) = __in.second;
+ this->_M_head(*this) = __in_.first;
+ this->_M_tail(*this)._M_head(*this) = __in_.second;
return *this;
}
template<typename _U1, typename _U2>
_GLIBCXX20_CONSTEXPR
__enable_if_t<__assignable<_U1, _U2>(), tuple&>
- operator=(pair<_U1, _U2>&& __in)
+ operator=(pair<_U1, _U2>&& __in_)
noexcept(__nothrow_assignable<_U1, _U2>())
{
- this->_M_head(*this) = std::forward<_U1>(__in.first);
- this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
+ this->_M_head(*this) = std::forward<_U1>(__in_.first);
+ this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in_.second);
return *this;
}
_GLIBCXX20_CONSTEXPR
void
- swap(tuple& __in)
+ swap(tuple& __in_)
noexcept(__and_<__is_nothrow_swappable<_T1>,
__is_nothrow_swappable<_T2>>::value)
- { _Inherited::_M_swap(__in); }
+ { _Inherited::_M_swap(__in_); }
};
#endif // concepts && conditional_explicit
diff --git a/libstdc++-v3/include/tr1/regex b/libstdc++-v3/include/tr1/regex
index 258504712ac..8e9844627c7 100644
--- a/libstdc++-v3/include/tr1/regex
+++ b/libstdc++-v3/include/tr1/regex
@@ -2009,7 +2009,7 @@ namespace regex_constants
*/
template<typename _Out_iter>
_Out_iter
- format(_Out_iter __out, const string_type& __fmt,
+ format(_Out_iter __out_, const string_type& __fmt,
regex_constants::match_flag_type __flags
= regex_constants::format_default) const;
@@ -2405,7 +2405,7 @@ namespace regex_constants
template<typename _Out_iter, typename _Bi_iter,
typename _Rx_traits, typename _Ch_type>
inline _Out_iter
- regex_replace(_Out_iter __out, _Bi_iter __first, _Bi_iter __last,
+ regex_replace(_Out_iter __out_, _Bi_iter __first, _Bi_iter __last,
const basic_regex<_Ch_type, _Rx_traits>& __e,
const basic_string<_Ch_type>& __fmt,
regex_constants::match_flag_type __flags
diff --git a/libstdc++-v3/include/tr1/tuple b/libstdc++-v3/include/tr1/tuple
index b3dccb4fe09..1ce31803b60 100644
--- a/libstdc++-v3/include/tr1/tuple
+++ b/libstdc++-v3/include/tr1/tuple
@@ -109,26 +109,26 @@ namespace tr1
: _Inherited(__tail...), _M_head(__head) { }
template<typename... _UElements>
- _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
- : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+ _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in_)
+ : _Inherited(__in_._M_tail()), _M_head(__in_._M_head) { }
- _Tuple_impl(const _Tuple_impl& __in)
- : _Inherited(__in._M_tail()), _M_head(__in._M_head) { }
+ _Tuple_impl(const _Tuple_impl& __in_)
+ : _Inherited(__in_._M_tail()), _M_head(__in_._M_head) { }
template<typename... _UElements>
_Tuple_impl&
- operator=(const _Tuple_impl<_Idx, _UElements...>& __in)
+ operator=(const _Tuple_impl<_Idx, _UElements...>& __in_)
{
- _M_head = __in._M_head;
- _M_tail() = __in._M_tail();
+ _M_head = __in_._M_head;
+ _M_tail() = __in_._M_tail();
return *this;
}
_Tuple_impl&
- operator=(const _Tuple_impl& __in)
+ operator=(const _Tuple_impl& __in_)
{
- _M_head = __in._M_head;
- _M_tail() = __in._M_tail();
+ _M_head = __in_._M_head;
+ _M_tail() = __in_._M_tail();
return *this;
}
};
@@ -146,24 +146,24 @@ namespace tr1
: _Inherited(__elements...) { }
template<typename... _UElements>
- tuple(const tuple<_UElements...>& __in)
- : _Inherited(__in) { }
+ tuple(const tuple<_UElements...>& __in_)
+ : _Inherited(__in_) { }
- tuple(const tuple& __in)
- : _Inherited(__in) { }
+ tuple(const tuple& __in_)
+ : _Inherited(__in_) { }
template<typename... _UElements>
tuple&
- operator=(const tuple<_UElements...>& __in)
+ operator=(const tuple<_UElements...>& __in_)
{
- static_cast<_Inherited&>(*this) = __in;
+ static_cast<_Inherited&>(*this) = __in_;
return *this;
}
tuple&
- operator=(const tuple& __in)
+ operator=(const tuple& __in_)
{
- static_cast<_Inherited&>(*this) = __in;
+ static_cast<_Inherited&>(*this) = __in_;
return *this;
}
};
@@ -185,41 +185,41 @@ namespace tr1
: _Inherited(__a1, __a2) { }
template<typename _U1, typename _U2>
- tuple(const tuple<_U1, _U2>& __in)
- : _Inherited(__in) { }
+ tuple(const tuple<_U1, _U2>& __in_)
+ : _Inherited(__in_) { }
- tuple(const tuple& __in)
- : _Inherited(__in) { }
+ tuple(const tuple& __in_)
+ : _Inherited(__in_) { }
template<typename _U1, typename _U2>
- tuple(const pair<_U1, _U2>& __in)
+ tuple(const pair<_U1, _U2>& __in_)
: _Inherited(_Tuple_impl<0,
typename __add_c_ref<_U1>::type,
- typename __add_c_ref<_U2>::type>(__in.first,
- __in.second))
+ typename __add_c_ref<_U2>::type>(__in_.first,
+ __in_.second))
{ }
template<typename _U1, typename _U2>
tuple&
- operator=(const tuple<_U1, _U2>& __in)
+ operator=(const tuple<_U1, _U2>& __in_)
{
- static_cast<_Inherited&>(*this) = __in;
+ static_cast<_Inherited&>(*this) = __in_;
return *this;
}
tuple&
- operator=(const tuple& __in)
+ operator=(const tuple& __in_)
{
- static_cast<_Inherited&>(*this) = __in;
+ static_cast<_Inherited&>(*this) = __in_;
return *this;
}
template<typename _U1, typename _U2>
tuple&
- operator=(const pair<_U1, _U2>& __in)
+ operator=(const pair<_U1, _U2>& __in_)
{
- this->_M_head = __in.first;
- this->_M_tail()._M_head = __in.second;
+ this->_M_head = __in_.first;
+ this->_M_tail()._M_head = __in_.second;
return *this;
}
};
diff --git a/libstdc++-v3/include/tr1/utility b/libstdc++-v3/include/tr1/utility
index fd1789e194c..438fe03b0b3 100644
--- a/libstdc++-v3/include/tr1/utility
+++ b/libstdc++-v3/include/tr1/utility
@@ -97,13 +97,13 @@ namespace tr1
template<int _Int, class _Tp1, class _Tp2>
inline typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
- get(std::pair<_Tp1, _Tp2>& __in)
- { return __pair_get<_Int>::__get(__in); }
+ get(std::pair<_Tp1, _Tp2>& __in_)
+ { return __pair_get<_Int>::__get(__in_); }
template<int _Int, class _Tp1, class _Tp2>
inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
- get(const std::pair<_Tp1, _Tp2>& __in)
- { return __pair_get<_Int>::__const_get(__in); }
+ get(const std::pair<_Tp1, _Tp2>& __in_)
+ { return __pair_get<_Int>::__const_get(__in_); }
}
_GLIBCXX_END_NAMESPACE_VERSION
diff --git a/libstdc++-v3/include/tr2/bool_set b/libstdc++-v3/include/tr2/bool_set
index dc78d09d43a..a9bdc338f69 100644
--- a/libstdc++-v3/include/tr2/bool_set
+++ b/libstdc++-v3/include/tr2/bool_set
@@ -133,18 +133,18 @@ namespace tr2
template<typename CharT, typename Traits>
friend std::basic_ostream<CharT, Traits>&
- operator<<(std::basic_ostream<CharT, Traits>& __out, bool_set __b)
+ operator<<(std::basic_ostream<CharT, Traits>& __out_, bool_set __b)
{
int __a = __b._M_b;
- __out << __a;
+ __out_ << __a;
}
template<typename CharT, typename Traits>
friend std::basic_istream<CharT, Traits>&
- operator>>(std::basic_istream<CharT, Traits>& __in, bool_set& __b)
+ operator>>(std::basic_istream<CharT, Traits>& __in_, bool_set& __b)
{
long __c;
- __in >> __c;
+ __in_ >> __c;
if (__c >= _S_false && __c < _S_empty)
__b._M_b = static_cast<_Bool_set_val>(__c);
}
diff --git a/libstdc++-v3/include/tr2/bool_set.tcc b/libstdc++-v3/include/tr2/bool_set.tcc
index ead89f8cd9f..42cbf794428 100644
--- a/libstdc++-v3/include/tr2/bool_set.tcc
+++ b/libstdc++-v3/include/tr2/bool_set.tcc
@@ -102,9 +102,9 @@ _GLIBCXX_END_NAMESPACE_VERSION
* @param v Value to format and insert.
* @return Iterator after reading.
iter_type
- get(iter_type __in, iter_type __end, ios_base& __io,
+ get(iter_type __in_, iter_type __end, ios_base& __io,
ios_base::iostate& __err, bool& __v) const
- { return this->do_get(__in, __end, __io, __err, __v); }
+ { return this->do_get(__in_, __end, __io, __err, __v); }
*/
/*
template<typename _CharT, typename _InIter>
diff --git a/libstdc++-v3/scripts/gen_includers.pl b/libstdc++-v3/scripts/gen_includers.pl
index 477f028408f..4084a0fec3c 100644
--- a/libstdc++-v3/scripts/gen_includers.pl
+++ b/libstdc++-v3/scripts/gen_includers.pl
@@ -15,8 +15,8 @@ $mu_get_tuple_args = "::std::tr1::get<0>(__tuple)";
$bind_v_template_args = "typename result_of<_Mu<_T1> _CV(_T1, tuple<_GLIBCXX_BIND_TEMPLATE_ARGS>)>::type";
$bind_v_args = "_Mu<_T1>()(_M_arg1, ::std::tr1::tie(_GLIBCXX_BIND_ARGS))";
$tuple_add_cref = "typename __add_c_ref<_T1>::type __a1";
-$tuple_copy_init = "_M_arg1(__in._M_arg1)";
-$tuple_assign = "_M_arg1 = __in._M_arg1;";
+$tuple_copy_init = "_M_arg1(__in_._M_arg1)";
+$tuple_assign = "_M_arg1 = __in_._M_arg1;";
$template_params_null_class = "typename _T1 = _NullClass";
$template_args_stripped = "typename __strip_reference_wrapper<_T1>::__type";
$template_params_u = "typename _U1";
@@ -42,8 +42,8 @@ for ($num_args = 2; $num_args <= $max; ++$num_args) {
$bind_v_template_args .= ", typename result_of<_Mu<_T$num_args> _CV(_T$num_args, tuple<_GLIBCXX_BIND_TEMPLATE_ARGS>)>::type";
$bind_v_args .= ", _Mu<_T$num_args>()(_M_arg$num_args, ::std::tr1::tie(_GLIBCXX_BIND_ARGS))";
$tuple_add_cref .= ", typename __add_c_ref<_T$num_args>::type __a$num_args";
- $tuple_copy_init .= ", _M_arg$num_args(__in._M_arg$num_args)";
- $tuple_assign .= " _M_arg$num_args = __in._M_arg$num_args;";
+ $tuple_copy_init .= ", _M_arg$num_args(__in_._M_arg$num_args)";
+ $tuple_assign .= " _M_arg$num_args = __in_._M_arg$num_args;";
$template_params_null_class .= ", typename _T$num_args = _NullClass";
$template_args_stripped .= ", typename __strip_reference_wrapper<_T$num_args>::__type";
$template_params_u .= ", typename _U$num_args";
diff --git a/libstdc++-v3/src/c++11/snprintf_lite.cc b/libstdc++-v3/src/c++11/snprintf_lite.cc
index b5f6357a3f2..360a39ac4e2 100644
--- a/libstdc++-v3/src/c++11/snprintf_lite.cc
+++ b/libstdc++-v3/src/c++11/snprintf_lite.cc
@@ -65,14 +65,14 @@ namespace __gnu_cxx {
// Long enough for decimal representation.
int __ilen = 3 * sizeof(__val);
char *__cs = static_cast<char*>(__builtin_alloca(__ilen));
- char* __out = __cs + __ilen;
+ char* __out_ = __cs + __ilen;
do
{
- *--__out = "0123456789"[__val % 10];
+ *--__out_ = "0123456789"[__val % 10];
__val /= 10;
}
while (__val != 0);
- size_t __len = __cs + __ilen - __out;
+ size_t __len = __cs + __ilen - __out_;
if (__bufsize < __len)
return -1;
diff --git a/libstdc++-v3/src/c++98/istream-string.cc b/libstdc++-v3/src/c++98/istream-string.cc
index 458daf34060..5fb807b54ba 100644
--- a/libstdc++-v3/src/c++98/istream-string.cc
+++ b/libstdc++-v3/src/c++98/istream-string.cc
@@ -40,7 +40,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<>
basic_istream<char>&
- operator>>(basic_istream<char>& __in, basic_string<char>& __str)
+ operator>>(basic_istream<char>& __in_, basic_string<char>& __str)
{
typedef basic_istream<char> __istream_type;
typedef __istream_type::int_type __int_type;
@@ -52,18 +52,18 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__size_type __extracted = 0;
ios_base::iostate __err = ios_base::goodbit;
- __istream_type::sentry __cerb(__in, false);
+ __istream_type::sentry __cerb(__in_, false);
if (__cerb)
{
__try
{
__str.erase();
- const streamsize __w = __in.width();
+ const streamsize __w = __in_.width();
const __size_type __n = __w > 0 ? static_cast<__size_type>(__w)
: __str.max_size();
- const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+ const __ctype_type& __ct = use_facet<__ctype_type>(__in_.getloc());
const __int_type __eof = __traits_type::eof();
- __streambuf_type* __sb = __in.rdbuf();
+ __streambuf_type* __sb = __in_.rdbuf();
__int_type __c = __sb->sgetc();
while (__extracted < __n
@@ -95,11 +95,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
if (__extracted < __n && __traits_type::eq_int_type(__c, __eof))
__err |= ios_base::eofbit;
- __in.width(0);
+ __in_.width(0);
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __in._M_setstate(ios_base::badbit);
+ __in_._M_setstate(ios_base::badbit);
__throw_exception_again;
}
__catch(...)
@@ -107,19 +107,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
- __in._M_setstate(ios_base::badbit);
+ __in_._M_setstate(ios_base::badbit);
}
}
if (!__extracted)
__err |= ios_base::failbit;
if (__err)
- __in.setstate(__err);
- return __in;
+ __in_.setstate(__err);
+ return __in_;
}
template<>
basic_istream<char>&
- getline(basic_istream<char>& __in, basic_string<char>& __str,
+ getline(basic_istream<char>& __in_, basic_string<char>& __str,
char __delim)
{
typedef basic_istream<char> __istream_type;
@@ -133,7 +133,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__size_type __extracted = 0;
const __size_type __n = __str.max_size();
ios_base::iostate __err = ios_base::goodbit;
- __istream_type::sentry __cerb(__in, true);
+ __istream_type::sentry __cerb(__in_, true);
if (__cerb)
{
__try
@@ -141,7 +141,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__str.erase();
const __int_type __idelim = __traits_type::to_int_type(__delim);
const __int_type __eof = __traits_type::eof();
- __streambuf_type* __sb = __in.rdbuf();
+ __streambuf_type* __sb = __in_.rdbuf();
__int_type __c = __sb->sgetc();
while (__extracted < __n
@@ -183,7 +183,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __in._M_setstate(ios_base::badbit);
+ __in_._M_setstate(ios_base::badbit);
__throw_exception_again;
}
__catch(...)
@@ -191,20 +191,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
- __in._M_setstate(ios_base::badbit);
+ __in_._M_setstate(ios_base::badbit);
}
}
if (!__extracted)
__err |= ios_base::failbit;
if (__err)
- __in.setstate(__err);
- return __in;
+ __in_.setstate(__err);
+ return __in_;
}
#ifdef _GLIBCXX_USE_WCHAR_T
template<>
basic_istream<wchar_t>&
- getline(basic_istream<wchar_t>& __in, basic_string<wchar_t>& __str,
+ getline(basic_istream<wchar_t>& __in_, basic_string<wchar_t>& __str,
wchar_t __delim)
{
typedef basic_istream<wchar_t> __istream_type;
@@ -218,7 +218,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__size_type __extracted = 0;
const __size_type __n = __str.max_size();
ios_base::iostate __err = ios_base::goodbit;
- __istream_type::sentry __cerb(__in, true);
+ __istream_type::sentry __cerb(__in_, true);
if (__cerb)
{
__try
@@ -226,7 +226,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__str.erase();
const __int_type __idelim = __traits_type::to_int_type(__delim);
const __int_type __eof = __traits_type::eof();
- __streambuf_type* __sb = __in.rdbuf();
+ __streambuf_type* __sb = __in_.rdbuf();
__int_type __c = __sb->sgetc();
while (__extracted < __n
@@ -268,7 +268,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __in._M_setstate(ios_base::badbit);
+ __in_._M_setstate(ios_base::badbit);
__throw_exception_again;
}
__catch(...)
@@ -276,14 +276,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 91. Description of operator>> and getline() for string<>
// might cause endless loop
- __in._M_setstate(ios_base::badbit);
+ __in_._M_setstate(ios_base::badbit);
}
}
if (!__extracted)
__err |= ios_base::failbit;
if (__err)
- __in.setstate(__err);
- return __in;
+ __in_.setstate(__err);
+ return __in_;
}
#endif
diff --git a/libstdc++-v3/src/c++98/istream.cc b/libstdc++-v3/src/c++98/istream.cc
index c345cbe1505..3953eb71525 100644
--- a/libstdc++-v3/src/c++98/istream.cc
+++ b/libstdc++-v3/src/c++98/istream.cc
@@ -214,7 +214,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}
void
- __istream_extract(istream& __in, char* __s, streamsize __num)
+ __istream_extract(istream& __in_, char* __s, streamsize __num)
{
typedef basic_istream<char> __istream_type;
typedef __istream_type::int_type __int_type;
@@ -225,20 +225,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
streamsize __extracted = 0;
ios_base::iostate __err = ios_base::goodbit;
- __istream_type::sentry __cerb(__in, false);
+ __istream_type::sentry __cerb(__in_, false);
if (__cerb)
{
__try
{
// Figure out how many characters to extract.
- streamsize __width = __in.width();
+ streamsize __width = __in_.width();
if (0 < __width && __width < __num)
__num = __width;
- const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc());
+ const __ctype_type& __ct = use_facet<__ctype_type>(__in_.getloc());
const __int_type __eof = __traits_type::eof();
- __streambuf_type* __sb = __in.rdbuf();
+ __streambuf_type* __sb = __in_.rdbuf();
__int_type __c = __sb->sgetc();
while (__extracted < __num - 1
@@ -277,20 +277,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 68. Extractors for char* should store null at end
*__s = __char_type();
- __in.width(0);
+ __in_.width(0);
}
__catch(__cxxabiv1::__forced_unwind&)
{
- __in._M_setstate(ios_base::badbit);
+ __in_._M_setstate(ios_base::badbit);
__throw_exception_again;
}
__catch(...)
- { __in._M_setstate(ios_base::badbit); }
+ { __in_._M_setstate(ios_base::badbit); }
}
if (!__extracted)
__err |= ios_base::failbit;
if (__err)
- __in.setstate(__err);
+ __in_.setstate(__err);
}
#ifdef _GLIBCXX_USE_WCHAR_T
diff --git a/libstdc++-v3/testsuite/17_intro/names.cc b/libstdc++-v3/testsuite/17_intro/names.cc
index c6fe81c5325..667ff28af62 100644
--- a/libstdc++-v3/testsuite/17_intro/names.cc
+++ b/libstdc++-v3/testsuite/17_intro/names.cc
@@ -251,6 +251,21 @@
#define __inout cannot be used as an identifier
#define __in_opt cannot be used as an identifier
#define __out_opt cannot be used as an identifier
+#define __allocator cannot be used as an identifier
+#define __bound cannot be used as an identifier
+#define __in cannot be used as an identifier
+#define __out cannot be used as an identifier
+#define __inner_range cannot be used as an identifier
+#define __pre cannot be used as an identifier
+#define __range cannot be used as an identifier
+#define __reserved cannot be used as an identifier
+#define __success cannot be used as an identifier
+#define __valid cannot be used as an identifier
+#define __noop cannot be used as an identifier
+#define __except cannot be used as an identifier
+#define __box cannot be used as an identifier
+#define __delegate cannot be used as an identifier
+#define __gc cannot be used as an identifier
#endif
#ifdef _AIX
diff --git a/libstdc++-v3/testsuite/performance/27_io/ifstream_extract_chars.cc b/libstdc++-v3/testsuite/performance/27_io/ifstream_extract_chars.cc
index e3c75406327..56b3141d943 100644
--- a/libstdc++-v3/testsuite/performance/27_io/ifstream_extract_chars.cc
+++ b/libstdc++-v3/testsuite/performance/27_io/ifstream_extract_chars.cc
@@ -47,7 +47,7 @@ int main()
out << line;
}
- // operator>>(basic_istream<char>& __in, basic_string<char>& __str)
+ // operator>>(basic_istream<char>& __in_, basic_string<char>& __str)
{
start_counters(time, resource);
for (int iter = 0; iter < 25; ++iter)
@@ -62,7 +62,7 @@ int main()
clear_counters(time, resource);
}
- // operator>>(basic_istream<char>& __in, char* __s)
+ // operator>>(basic_istream<char>& __in_, char* __s)
{
start_counters(time, resource);
for (int iter = 0; iter < 25; ++iter)
diff --git a/libstdc++-v3/testsuite/performance/27_io/ifstream_getline-2.cc b/libstdc++-v3/testsuite/performance/27_io/ifstream_getline-2.cc
index eec8fadc4bc..2564cdbe6ef 100644
--- a/libstdc++-v3/testsuite/performance/27_io/ifstream_getline-2.cc
+++ b/libstdc++-v3/testsuite/performance/27_io/ifstream_getline-2.cc
@@ -63,7 +63,7 @@ int main()
clear_counters(time, resource);
}
- // getline(basic_istream<_CharT, _Traits>& __in,
+ // getline(basic_istream<_CharT, _Traits>& __in_,
// basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim)
{
ifstream file(filename);
diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/detail/copyable_box.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/detail/copyable_box.cc
index edaabe0fe94..4552dce6b67 100644
--- a/libstdc++-v3/testsuite/std/ranges/adaptors/detail/copyable_box.cc
+++ b/libstdc++-v3/testsuite/std/ranges/adaptors/detail/copyable_box.cc
@@ -19,14 +19,14 @@
#include <ranges>
-using std::ranges::__detail::__box;
+using std::ranges::__detail::__box_;
using T = decltype([] { return 0; });
-static_assert(std::is_empty_v<__box<T>>);
-static_assert(std::is_nothrow_copy_constructible_v<__box<T>>);
-static_assert(std::is_nothrow_move_constructible_v<__box<T>>);
-static_assert(std::is_nothrow_constructible_v<__box<T>, std::in_place_t>);
-static_assert(requires (__box<T> a) {
+static_assert(std::is_empty_v<__box_<T>>);
+static_assert(std::is_nothrow_copy_constructible_v<__box_<T>>);
+static_assert(std::is_nothrow_move_constructible_v<__box_<T>>);
+static_assert(std::is_nothrow_constructible_v<__box_<T>, std::in_place_t>);
+static_assert(requires (__box_<T> a) {
a = a;
a = std::move(a);
a.operator*();
@@ -43,14 +43,14 @@ struct S
S& operator=(const S&);
S& operator=(S&&);
};
-static_assert(std::is_empty_v<__box<S>>);
-static_assert(!std::is_nothrow_copy_constructible_v<__box<S>>
- && std::is_copy_constructible_v<__box<S>>);
-static_assert(!std::is_nothrow_move_constructible_v<__box<S>>
- && std::is_move_constructible_v<__box<S>>);
-static_assert(!std::is_nothrow_constructible_v<__box<S>, std::in_place_t>
- && std::is_constructible_v<__box<S>, std::in_place_t>);
-static_assert(requires (__box<S> a) {
+static_assert(std::is_empty_v<__box_<S>>);
+static_assert(!std::is_nothrow_copy_constructible_v<__box_<S>>
+ && std::is_copy_constructible_v<__box_<S>>);
+static_assert(!std::is_nothrow_move_constructible_v<__box_<S>>
+ && std::is_move_constructible_v<__box_<S>>);
+static_assert(!std::is_nothrow_constructible_v<__box_<S>, std::in_place_t>
+ && std::is_constructible_v<__box_<S>, std::in_place_t>);
+static_assert(requires (__box_<S> a) {
a = a;
a = std::move(a);
a.operator*();
@@ -59,11 +59,11 @@ static_assert(requires (__box<S> a) {
});
using U = decltype([i=0] { return 0; });
-static_assert(!std::is_empty_v<__box<U>>);
-static_assert(std::is_nothrow_copy_constructible_v<__box<U>>);
-static_assert(std::is_nothrow_move_constructible_v<__box<U>>);
-static_assert(!std::is_nothrow_constructible_v<__box<U>, std::in_place_t>);
-static_assert(requires (__box<U> a) {
+static_assert(!std::is_empty_v<__box_<U>>);
+static_assert(std::is_nothrow_copy_constructible_v<__box_<U>>);
+static_assert(std::is_nothrow_move_constructible_v<__box_<U>>);
+static_assert(!std::is_nothrow_constructible_v<__box_<U>, std::in_place_t>);
+static_assert(requires (__box_<U> a) {
a = a;
a = std::move(a);
a.operator*();
@@ -75,7 +75,7 @@ constexpr bool
test01()
{
// Verify the default constructor value-initializes the underlying object.
- __box<int> x;
+ __box_<int> x;
__glibcxx_assert(*x == 0);
return true;
}
@@ -94,17 +94,17 @@ test02()
{
// PR libstdc++/100475
static_assert(std::copyable<A<true>>);
- __box<A<true>> x2(std::in_place, 0, 0);
+ __box_<A<true>> x2(std::in_place, 0, 0);
static_assert(!std::copyable<A<false>>);
- __box<A<false>> x1(std::in_place, 0, 0);
+ __box_<A<false>> x1(std::in_place, 0, 0);
}
constexpr bool
test03()
{
// Verify correctness of the non-defaulted operator= for the partial
- // specialization of __box.
+ // specialization of __box_.
struct B {
constexpr B(int* p) : p(p) { }
constexpr ~B() { ++*p; };
@@ -114,10 +114,10 @@ test03()
};
static_assert(!std::copyable<B>);
static_assert(std::is_nothrow_copy_constructible_v<B>);
- static_assert(sizeof(__box<B>) == sizeof(B));
+ static_assert(sizeof(__box_<B>) == sizeof(B));
int m = 0;
- __box<B> x(std::in_place, &m);
+ __box_<B> x(std::in_place, &m);
__glibcxx_assert(m == 0);
x = x;
__glibcxx_assert(m == 0);
@@ -125,7 +125,7 @@ test03()
__glibcxx_assert(m == 0);
int n = 0;
- __box<B> y(std::in_place, &n);
+ __box_<B> y(std::in_place, &n);
auto z = x;
x = y;
__glibcxx_assert(m == 1);
--
2.54.0
More information about the Libstdc++
mailing list