From 33ac58d5299c7eba6be3c112817fe917bed48043 Mon Sep 17 00:00:00 2001 From: Jonathan Wakely Date: Thu, 16 Jun 2016 14:47:35 +0100 Subject: [PATCH] Remove trailing whitespace from libstdc++ headers * include/std/array: Remove trailing whitespace. * include/std/atomic: Likewise. * include/std/bitset: Likewise. * include/std/chrono: Likewise. * include/std/complex: Likewise. * include/std/condition_variable: Likewise. * include/std/fstream: Likewise. * include/std/functional: Likewise. * include/std/future: Likewise. * include/std/iomanip: Likewise. * include/std/iosfwd: Likewise. * include/std/istream: Likewise. * include/std/limits: Likewise. * include/std/ratio: Likewise. * include/std/scoped_allocator: Likewise. * include/std/sstream: Likewise. * include/std/stdexcept: Likewise. * include/std/string: Likewise. * include/std/system_error: Likewise. * include/std/thread: Likewise. * include/std/tuple: Likewise. * include/std/type_traits: Likewise. * include/std/utility: Likewise. * include/std/valarray: Likewise. * include/std/vector: Likewise. From-SVN: r237528 --- libstdc++-v3/ChangeLog | 26 ++ libstdc++-v3/include/std/array | 38 +- libstdc++-v3/include/std/atomic | 22 +- libstdc++-v3/include/std/bitset | 34 +- libstdc++-v3/include/std/chrono | 16 +- libstdc++-v3/include/std/complex | 134 +++---- libstdc++-v3/include/std/condition_variable | 4 +- libstdc++-v3/include/std/fstream | 2 +- libstdc++-v3/include/std/functional | 2 +- libstdc++-v3/include/std/future | 4 +- libstdc++-v3/include/std/iomanip | 120 +++--- libstdc++-v3/include/std/iosfwd | 2 +- libstdc++-v3/include/std/istream | 2 +- libstdc++-v3/include/std/limits | 416 ++++++++++---------- libstdc++-v3/include/std/ratio | 22 +- libstdc++-v3/include/std/scoped_allocator | 52 +-- libstdc++-v3/include/std/sstream | 6 +- libstdc++-v3/include/std/stdexcept | 26 +- libstdc++-v3/include/std/string | 6 +- libstdc++-v3/include/std/system_error | 44 +-- libstdc++-v3/include/std/thread | 2 +- libstdc++-v3/include/std/tuple | 24 +- libstdc++-v3/include/std/type_traits | 92 ++--- libstdc++-v3/include/std/utility | 4 +- libstdc++-v3/include/std/valarray | 66 ++-- libstdc++-v3/include/std/vector | 2 +- 26 files changed, 597 insertions(+), 571 deletions(-) diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 59fd8c80b35..9d20afe3be7 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,5 +1,31 @@ 2016-06-16 Jonathan Wakely + * include/std/array: Remove trailing whitespace. + * include/std/atomic: Likewise. + * include/std/bitset: Likewise. + * include/std/chrono: Likewise. + * include/std/complex: Likewise. + * include/std/condition_variable: Likewise. + * include/std/fstream: Likewise. + * include/std/functional: Likewise. + * include/std/future: Likewise. + * include/std/iomanip: Likewise. + * include/std/iosfwd: Likewise. + * include/std/istream: Likewise. + * include/std/limits: Likewise. + * include/std/ratio: Likewise. + * include/std/scoped_allocator: Likewise. + * include/std/sstream: Likewise. + * include/std/stdexcept: Likewise. + * include/std/string: Likewise. + * include/std/system_error: Likewise. + * include/std/thread: Likewise. + * include/std/tuple: Likewise. + * include/std/type_traits: Likewise. + * include/std/utility: Likewise. + * include/std/valarray: Likewise. + * include/std/vector: Likewise. + * include/bits/stl_vector.h (vector::_S_insert_aux_assign): Define new overloaded functions. * include/bits/vector.tcc (vector::_M_insert_aux): Use new functions diff --git a/libstdc++-v3/include/std/array b/libstdc++-v3/include/std/array index c45a599a279..ee46f68caf1 100644 --- a/libstdc++-v3/include/std/array +++ b/libstdc++-v3/include/std/array @@ -134,19 +134,19 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER end() const noexcept { return const_iterator(data() + _Nm); } - reverse_iterator + reverse_iterator rbegin() noexcept { return reverse_iterator(end()); } - const_reverse_iterator + const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); } - reverse_iterator + reverse_iterator rend() noexcept { return reverse_iterator(begin()); } - const_reverse_iterator + const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); } @@ -158,22 +158,22 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER cend() const noexcept { return const_iterator(data() + _Nm); } - const_reverse_iterator + const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); } - const_reverse_iterator + const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); } // Capacity. - constexpr size_type + constexpr size_type size() const noexcept { return _Nm; } - constexpr size_type + constexpr size_type max_size() const noexcept { return _Nm; } - constexpr bool + constexpr bool empty() const noexcept { return size() == 0; } // Element access. @@ -207,22 +207,22 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER _AT_Type::_S_ref(_M_elems, 0)); } - reference + reference front() noexcept { return *begin(); } - constexpr const_reference + constexpr const_reference front() const noexcept { return _AT_Type::_S_ref(_M_elems, 0); } - reference + reference back() noexcept { return _Nm ? *(end() - 1) : *end(); } - constexpr const_reference + constexpr const_reference back() const noexcept - { - return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1) + { + return _Nm ? _AT_Type::_S_ref(_M_elems, _Nm - 1) : _AT_Type::_S_ref(_M_elems, 0); } @@ -237,7 +237,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER // Array comparisons. template - inline bool + inline bool operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) { return std::equal(__one.begin(), __one.end(), __two.begin()); } @@ -249,9 +249,9 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER template inline bool operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) - { + { return std::lexicographical_compare(__a.begin(), __a.end(), - __b.begin(), __b.end()); + __b.begin(), __b.end()); } template @@ -312,7 +312,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Tuple interface to class template array. /// tuple_size - template + template class tuple_size; /// Partial specialization for std::array diff --git a/libstdc++-v3/include/std/atomic b/libstdc++-v3/include/std/atomic index 3c8ece85b0b..8cbc91f9347 100644 --- a/libstdc++-v3/include/std/atomic +++ b/libstdc++-v3/include/std/atomic @@ -198,11 +198,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return load(); } _Tp - operator=(_Tp __i) noexcept + operator=(_Tp __i) noexcept { store(__i); return __i; } _Tp - operator=(_Tp __i) volatile noexcept + operator=(_Tp __i) volatile noexcept { store(__i); return __i; } bool @@ -231,7 +231,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Tp load(memory_order __m = memory_order_seq_cst) const noexcept - { + { _Tp tmp; __atomic_load(std::__addressof(_M_i), std::__addressof(tmp), __m); return tmp; @@ -239,7 +239,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Tp load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { + { _Tp tmp; __atomic_load(std::__addressof(_M_i), std::__addressof(tmp), __m); return tmp; @@ -247,7 +247,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Tp exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept - { + { _Tp tmp; __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i), std::__addressof(tmp), __m); @@ -255,9 +255,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } _Tp - exchange(_Tp __i, + exchange(_Tp __i, memory_order __m = memory_order_seq_cst) volatile noexcept - { + { _Tp tmp; __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i), std::__addressof(tmp), __m); @@ -265,7 +265,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } bool - compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, + compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { return __atomic_compare_exchange(std::__addressof(_M_i), @@ -275,7 +275,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } bool - compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, + compare_exchange_weak(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { return __atomic_compare_exchange(std::__addressof(_M_i), @@ -297,7 +297,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __cmpexch_failure_order(__m)); } bool - compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, + compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) noexcept { return __atomic_compare_exchange(std::__addressof(_M_i), @@ -307,7 +307,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } bool - compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, + compare_exchange_strong(_Tp& __e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept { return __atomic_compare_exchange(std::__addressof(_M_i), diff --git a/libstdc++-v3/include/std/bitset b/libstdc++-v3/include/std/bitset index 2ad88605128..0156d1f4d61 100644 --- a/libstdc++-v3/include/std/bitset +++ b/libstdc++-v3/include/std/bitset @@ -245,7 +245,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER _M_w[__n] = _M_w[__n - __wshift]; else { - const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD + const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD - __offset); for (size_t __n = _Nw - 1; __n > __wshift; --__n) _M_w[__n] = ((_M_w[__n - __wshift] << __offset) @@ -279,7 +279,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER | (_M_w[__n + __wshift + 1] << __sub_offset)); _M_w[__limit] = _M_w[_Nw-1] >> __offset; } - + std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0)); } } @@ -556,7 +556,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER _WordT& _M_getword(size_t) _GLIBCXX_NOEXCEPT { - __throw_out_of_range(__N("_Base_bitset::_M_getword")); + __throw_out_of_range(__N("_Base_bitset::_M_getword")); return *new _WordT; } @@ -659,7 +659,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER typedef unsigned long _WordT; static void - _S_do_sanitize(_WordT) _GLIBCXX_NOEXCEPT { } + _S_do_sanitize(_WordT) _GLIBCXX_NOEXCEPT { } }; #if __cplusplus >= 201103L @@ -773,7 +773,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER void _M_do_sanitize() _GLIBCXX_NOEXCEPT - { + { typedef _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD> __sanitize_type; __sanitize_type::_S_do_sanitize(this->_M_hiword()); } @@ -801,10 +801,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER _WordT* _M_wp; size_t _M_bpos; - + // left undefined reference(); - + public: reference(bitset& __b, size_t __pos) _GLIBCXX_NOEXCEPT { @@ -981,7 +981,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER return *this; } //@} - + //@{ /** * Operations on bitsets. @@ -1015,7 +1015,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER return *this; } //@} - + //@{ /** * These versions of single-bit set, reset, flip, and test are @@ -1058,7 +1058,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos)) != static_cast<_WordT>(0)); } //@} - + // Set, reset, and flip. /** * @brief Sets every bit to true. @@ -1107,7 +1107,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER this->_M_check(__position, __N("bitset::reset")); return _Unchecked_reset(__position); } - + /** * @brief Toggles every bit to its opposite value. */ @@ -1130,7 +1130,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER this->_M_check(__position, __N("bitset::flip")); return _Unchecked_flip(__position); } - + /// See the no-argument flip(). bitset<_Nb> operator~() const _GLIBCXX_NOEXCEPT @@ -1159,7 +1159,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER operator[](size_t __position) const { return _Unchecked_test(__position); } //@} - + /** * @brief Returns a numerical interpretation of the %bitset. * @return The integral equivalent of the bits. @@ -1302,7 +1302,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT { return !this->_M_is_equal(__rhs); } //@} - + /** * @brief Tests the value of a bit. * @param __position The index of a bit. @@ -1352,7 +1352,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER operator>>(size_t __position) const _GLIBCXX_NOEXCEPT { return bitset<_Nb>(*this) >>= __position; } //@} - + /** * @brief Finds the index of the first "on" bit. * @return The index of the first bit set, or size() if not found. @@ -1482,7 +1482,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER for (size_t __i = _Nb; __i > 0; --__i) { static typename _Traits::int_type __eof = _Traits::eof(); - + typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc(); if (_Traits::eq_int_type(__c1, __eof)) { @@ -1508,7 +1508,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER } __catch(__cxxabiv1::__forced_unwind&) { - __is._M_setstate(__ios_base::badbit); + __is._M_setstate(__ios_base::badbit); __throw_exception_again; } __catch(...) diff --git a/libstdc++-v3/include/std/chrono b/libstdc++-v3/include/std/chrono index ba492df5624..9104881eb93 100644 --- a/libstdc++-v3/include/std/chrono +++ b/libstdc++-v3/include/std/chrono @@ -72,7 +72,7 @@ namespace std _GLIBCXX_VISIBILITY(default) _GLIBCXX_BEGIN_NAMESPACE_VERSION // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly) - + template struct __duration_common_type_wrapper { @@ -98,7 +98,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { }; // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly) - + template struct __timepoint_common_type_wrapper { @@ -625,11 +625,11 @@ _GLIBCXX_END_NAMESPACE_VERSION typename common_type, _Dur2>::type> operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Dur2>& __rhs) - { + { typedef duration<_Rep1, _Period1> __dur1; typedef typename common_type<__dur1,_Dur2>::type __ct; typedef time_point<_Clock, __ct> __time_point; - return __time_point(__rhs.time_since_epoch() + __lhs); + return __time_point(__rhs.time_since_epoch() + __lhs); } template>::type> operator-(const time_point<_Clock, _Dur1>& __lhs, const duration<_Rep2, _Period2>& __rhs) - { + { typedef duration<_Rep2, _Period2> __dur2; typedef typename common_type<_Dur1,__dur2>::type __ct; typedef time_point<_Clock, __ct> __time_point; - return __time_point(__lhs.time_since_epoch() -__rhs); + return __time_point(__lhs.time_since_epoch() -__rhs); } template @@ -688,9 +688,9 @@ _GLIBCXX_END_NAMESPACE_VERSION { return !(__lhs < __rhs); } - // Clocks. + // Clocks. - // Why nanosecond resolution as the default? + // Why nanosecond resolution as the default? // Why have std::system_clock always count in the higest // resolution (ie nanoseconds), even if on some OSes the low 3 // or 9 decimal digits will be always zero? This allows later diff --git a/libstdc++-v3/include/std/complex b/libstdc++-v3/include/std/complex index 9b7c1d7279e..bb09b7d0aa7 100644 --- a/libstdc++-v3/include/std/complex +++ b/libstdc++-v3/include/std/complex @@ -93,7 +93,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// Return @a x to the @a y'th power. template complex<_Tp> pow(const complex<_Tp>&, const _Tp&); /// Return @a x to the @a y'th power. - template complex<_Tp> pow(const complex<_Tp>&, + template complex<_Tp> pow(const complex<_Tp>&, const complex<_Tp>&); /// Return @a x to the @a y'th power. template complex<_Tp> pow(const _Tp&, const complex<_Tp>&); @@ -107,8 +107,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template complex<_Tp> tan(const complex<_Tp>&); /// Return complex hyperbolic tangent of @a z. template complex<_Tp> tanh(const complex<_Tp>&); - - + + // 26.2.2 Primary template class complex /** * Template to represent complex numbers. @@ -123,7 +123,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { /// Value typedef. typedef _Tp value_type; - + /// Default constructor. First parameter is x, second parameter is y. /// Unspecified parameters default to 0. _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp()) @@ -143,41 +143,41 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. _GLIBCXX_ABI_TAG_CXX11 - constexpr _Tp + constexpr _Tp real() const { return _M_real; } _GLIBCXX_ABI_TAG_CXX11 - constexpr _Tp + constexpr _Tp imag() const { return _M_imag; } #else /// Return real part of complex number. - _Tp& + _Tp& real() { return _M_real; } /// Return real part of complex number. - const _Tp& + const _Tp& real() const { return _M_real; } /// Return imaginary part of complex number. - _Tp& + _Tp& imag() { return _M_imag; } /// Return imaginary part of complex number. - const _Tp& + const _Tp& imag() const { return _M_imag; } #endif // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. - void + void real(_Tp __val) { _M_real = __val; } - void + void imag(_Tp __val) { _M_imag = __val; } /// Assign a scalar to this complex number. complex<_Tp>& operator=(const _Tp&); - + /// Add a scalar to this complex number. // 26.2.5/1 complex<_Tp>& @@ -237,7 +237,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _M_real = __t; _M_imag = _Tp(); return *this; - } + } // 26.2.5/5 template @@ -317,7 +317,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _M_real = __r / __n; return *this; } - + // Operators: //@{ /// Return new complex value @a x plus @a y. @@ -359,7 +359,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __r -= __y; return __r; } - + template inline complex<_Tp> operator-(const complex<_Tp>& __x, const _Tp& __y) @@ -419,7 +419,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __r /= __y; return __r; } - + template inline complex<_Tp> operator/(const complex<_Tp>& __x, const _Tp& __y) @@ -495,23 +495,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Tp __re_x, __im_x; _CharT __ch; __is >> __ch; - if (__ch == '(') + if (__ch == '(') { __is >> __re_x >> __ch; - if (__ch == ',') + if (__ch == ',') { __is >> __im_x >> __ch; - if (__ch == ')') + if (__ch == ')') __x = complex<_Tp>(__re_x, __im_x); else __is.setstate(ios_base::failbit); } - else if (__ch == ')') + else if (__ch == ')') __x = __re_x; else __is.setstate(ios_base::failbit); } - else + else { __is.putback(__ch); __is >> __re_x; @@ -549,17 +549,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION inline _Tp& real(complex<_Tp>& __z) { return __z.real(); } - + template inline const _Tp& real(const complex<_Tp>& __z) { return __z.real(); } - + template inline _Tp& imag(complex<_Tp>& __z) { return __z.imag(); } - + template inline const _Tp& imag(const complex<_Tp>& __z) @@ -576,7 +576,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION const _Tp __s = std::max(abs(__x), abs(__y)); if (__s == _Tp()) // well ... return __s; - __x /= __s; + __x /= __s; __y /= __s; return __s * sqrt(__x * __x + __y * __y); } @@ -599,7 +599,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template inline _Tp abs(const complex<_Tp>& __z) { return __complex_abs(__z); } -#endif +#endif // 26.2.7/4: arg(__z): Returns the phase angle of __z. @@ -655,12 +655,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return __res * __res; } }; - + template inline _Tp norm(const complex<_Tp>& __z) { - return _Norm_helper<__is_floating<_Tp>::__value + return _Norm_helper<__is_floating<_Tp>::__value && !_GLIBCXX_FAST_MATH>::_S_do_it(__z); } @@ -676,7 +676,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION inline complex<_Tp> conj(const complex<_Tp>& __z) { return complex<_Tp>(__z.real(), -__z.imag()); } - + // Transcendentals // 26.2.8/1 cos(__z): Returns the cosine of __z. @@ -804,7 +804,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { const _Tp __x = __z.real(); const _Tp __y = __z.imag(); - return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y)); + return complex<_Tp>(sin(__x) * cosh(__y), cos(__x) * sinh(__y)); } #if _GLIBCXX_USE_C99_COMPLEX @@ -839,14 +839,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #if _GLIBCXX_USE_C99_COMPLEX inline __complex__ float - __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); } + __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); } inline __complex__ double - __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); } + __complex_sinh(__complex__ double __z) { return __builtin_csinh(__z); } inline __complex__ long double __complex_sinh(const __complex__ long double& __z) - { return __builtin_csinhl(__z); } + { return __builtin_csinhl(__z); } template inline complex<_Tp> @@ -902,7 +902,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif // 26.2.8/14 tan(__z): Return the complex tangent of __z. - + template inline complex<_Tp> __complex_tan(const complex<_Tp>& __z) @@ -930,7 +930,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z. - + template inline complex<_Tp> __complex_tanh(const complex<_Tp>& __z) @@ -1066,38 +1066,38 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif explicit _GLIBCXX_CONSTEXPR complex(const complex&); - explicit _GLIBCXX_CONSTEXPR complex(const complex&); + explicit _GLIBCXX_CONSTEXPR complex(const complex&); #if __cplusplus >= 201103L // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. __attribute ((__abi_tag__ ("cxx11"))) - constexpr float + constexpr float real() const { return __real__ _M_value; } __attribute ((__abi_tag__ ("cxx11"))) - constexpr float + constexpr float imag() const { return __imag__ _M_value; } #else - float& + float& real() { return __real__ _M_value; } - const float& - real() const { return __real__ _M_value; } + const float& + real() const { return __real__ _M_value; } - float& + float& imag() { return __imag__ _M_value; } - const float& + const float& imag() const { return __imag__ _M_value; } #endif // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. - void + void real(float __val) { __real__ _M_value = __val; } - void + void imag(float __val) { __imag__ _M_value = __val; } complex& @@ -1217,38 +1217,38 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _GLIBCXX_CONSTEXPR complex(const complex& __z) : _M_value(__z.__rep()) { } - explicit _GLIBCXX_CONSTEXPR complex(const complex&); + explicit _GLIBCXX_CONSTEXPR complex(const complex&); #if __cplusplus >= 201103L // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. __attribute ((__abi_tag__ ("cxx11"))) - constexpr double + constexpr double real() const { return __real__ _M_value; } __attribute ((__abi_tag__ ("cxx11"))) - constexpr double + constexpr double imag() const { return __imag__ _M_value; } #else - double& + double& real() { return __real__ _M_value; } - const double& + const double& real() const { return __real__ _M_value; } - double& + double& imag() { return __imag__ _M_value; } - const double& + const double& imag() const { return __imag__ _M_value; } #endif // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. - void + void real(double __val) { __real__ _M_value = __val; } - void + void imag(double __val) { __imag__ _M_value = __val; } complex& @@ -1264,7 +1264,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _M_value += __d; return *this; } - + complex& operator-=(double __d) { @@ -1354,7 +1354,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } - _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L, + _GLIBCXX_CONSTEXPR complex(long double __r = 0.0L, long double __i = 0.0L) #if __cplusplus >= 201103L : _M_value{ __r, __i } { } @@ -1375,32 +1375,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. __attribute ((__abi_tag__ ("cxx11"))) - constexpr long double + constexpr long double real() const { return __real__ _M_value; } __attribute ((__abi_tag__ ("cxx11"))) - constexpr long double + constexpr long double imag() const { return __imag__ _M_value; } #else - long double& + long double& real() { return __real__ _M_value; } - const long double& + const long double& real() const { return __real__ _M_value; } - long double& + long double& imag() { return __imag__ _M_value; } - const long double& + const long double& imag() const { return __imag__ _M_value; } #endif // _GLIBCXX_RESOLVE_LIB_DEFECTS // DR 387. std::complex over-encapsulated. - void + void real(long double __val) { __real__ _M_value = __val; } - void + void imag(long double __val) { __imag__ _M_value = __val; } complex& @@ -1554,7 +1554,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION public: typedef std::complex::__type> __type; }; - + template struct __promote_2, std::complex<_Up> > { @@ -1653,7 +1653,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION asin(const std::complex<_Tp>& __z) { return __complex_asin(__z); } #endif - + template std::complex<_Tp> __complex_atan(const std::complex<_Tp>& __z) diff --git a/libstdc++-v3/include/std/condition_variable b/libstdc++-v3/include/std/condition_variable index 62a7ee14519..2e975e890ff 100644 --- a/libstdc++-v3/include/std/condition_variable +++ b/libstdc++-v3/include/std/condition_variable @@ -60,7 +60,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// cv_status enum class cv_status { no_timeout, timeout }; - + /// condition_variable class condition_variable { @@ -250,7 +250,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION unique_lock __my_lock2(std::move(__my_lock)); _M_cond.wait(__my_lock2); } - + template void diff --git a/libstdc++-v3/include/std/fstream b/libstdc++-v3/include/std/fstream index 08b496594f9..b0d03edc092 100644 --- a/libstdc++-v3/include/std/fstream +++ b/libstdc++-v3/include/std/fstream @@ -386,7 +386,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Common code for seekoff, seekpos, and overflow pos_type _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state); - + int _M_get_ext_pos(__state_type &__state); diff --git a/libstdc++-v3/include/std/functional b/libstdc++-v3/include/std/functional index 1edd8868cfc..0fdf0436694 100644 --- a/libstdc++-v3/include/std/functional +++ b/libstdc++-v3/include/std/functional @@ -1906,7 +1906,7 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type) * type @c T1, @c T2, ..., @c TN and returns a value convertible * to @c Res. * - * The newly-created %function object will target a copy of + * The newly-created %function object will target a copy of * @a __f. If @a __f is @c reference_wrapper, then this function * object will contain a reference to the function object @c * __f.get(). If @a __f is a NULL function pointer or NULL diff --git a/libstdc++-v3/include/std/future b/libstdc++-v3/include/std/future index 80b7b06a45f..aa866c5906a 100644 --- a/libstdc++-v3/include/std/future +++ b/libstdc++-v3/include/std/future @@ -225,7 +225,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typedef _Res result_type; _Result() noexcept : _M_initialized() { } - + ~_Result() { if (_M_initialized) @@ -263,7 +263,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION explicit _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a) { } - + private: void _M_destroy() { diff --git a/libstdc++-v3/include/std/iomanip b/libstdc++-v3/include/std/iomanip index 45d0f90a808..cb0df866695 100644 --- a/libstdc++-v3/include/std/iomanip +++ b/libstdc++-v3/include/std/iomanip @@ -62,24 +62,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * Sent to a stream object, this manipulator resets the specified flags, * via @e stream.setf(0,__mask). */ - inline _Resetiosflags + inline _Resetiosflags resetiosflags(ios_base::fmtflags __mask) { return { __mask }; } template - inline basic_istream<_CharT, _Traits>& + inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f) - { - __is.setf(ios_base::fmtflags(0), __f._M_mask); - return __is; + { + __is.setf(ios_base::fmtflags(0), __f._M_mask); + return __is; } template - inline basic_ostream<_CharT, _Traits>& + inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f) - { - __os.setf(ios_base::fmtflags(0), __f._M_mask); - return __os; + { + __os.setf(ios_base::fmtflags(0), __f._M_mask); + return __os; } @@ -92,24 +92,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * Sent to a stream object, this manipulator sets the format flags * to @a __mask. */ - inline _Setiosflags + inline _Setiosflags setiosflags(ios_base::fmtflags __mask) { return { __mask }; } template - inline basic_istream<_CharT, _Traits>& + inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f) - { - __is.setf(__f._M_mask); - return __is; + { + __is.setf(__f._M_mask); + return __is; } template - inline basic_ostream<_CharT, _Traits>& + inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f) - { - __os.setf(__f._M_mask); - return __os; + { + __os.setf(__f._M_mask); + return __os; } @@ -123,32 +123,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * @c ios_base::basefield flags to @c oct, @c dec, or @c hex when @a base * is 8, 10, or 16, accordingly, and to 0 if @a __base is any other value. */ - inline _Setbase + inline _Setbase setbase(int __base) { return { __base }; } template - inline basic_istream<_CharT, _Traits>& + inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f) { - __is.setf(__f._M_base == 8 ? ios_base::oct : - __f._M_base == 10 ? ios_base::dec : - __f._M_base == 16 ? ios_base::hex : + __is.setf(__f._M_base == 8 ? ios_base::oct : + __f._M_base == 10 ? ios_base::dec : + __f._M_base == 16 ? ios_base::hex : ios_base::fmtflags(0), ios_base::basefield); - return __is; + return __is; } - + template - inline basic_ostream<_CharT, _Traits>& + inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f) { - __os.setf(__f._M_base == 8 ? ios_base::oct : - __f._M_base == 10 ? ios_base::dec : - __f._M_base == 16 ? ios_base::hex : + __os.setf(__f._M_base == 8 ? ios_base::oct : + __f._M_base == 10 ? ios_base::dec : + __f._M_base == 16 ? ios_base::hex : ios_base::fmtflags(0), ios_base::basefield); - return __os; + return __os; } - + template struct _Setfill { _CharT _M_c; }; @@ -166,19 +166,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return { __c }; } template - inline basic_istream<_CharT, _Traits>& + inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f) - { - __is.fill(__f._M_c); - return __is; + { + __is.fill(__f._M_c); + return __is; } template - inline basic_ostream<_CharT, _Traits>& + inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f) - { - __os.fill(__f._M_c); - return __os; + { + __os.fill(__f._M_c); + return __os; } @@ -191,24 +191,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * Sent to a stream object, this manipulator calls @c precision(__n) for * that object. */ - inline _Setprecision + inline _Setprecision setprecision(int __n) { return { __n }; } template - inline basic_istream<_CharT, _Traits>& + inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f) - { - __is.precision(__f._M_n); - return __is; + { + __is.precision(__f._M_n); + return __is; } template - inline basic_ostream<_CharT, _Traits>& + inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f) - { - __os.precision(__f._M_n); - return __os; + { + __os.precision(__f._M_n); + return __os; } @@ -221,35 +221,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * Sent to a stream object, this manipulator calls @c width(__n) for * that object. */ - inline _Setw + inline _Setw setw(int __n) { return { __n }; } template - inline basic_istream<_CharT, _Traits>& + inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f) { __is.width(__f._M_n); - return __is; + return __is; } template - inline basic_ostream<_CharT, _Traits>& + inline basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f) { __os.width(__f._M_n); - return __os; + return __os; } #if __cplusplus >= 201103L - + template struct _Get_money { _MoneyT& _M_mon; bool _M_intl; }; /** * @brief Extended manipulator for extracting money. * @param __mon Either long double or a specialization of @c basic_string. - * @param __intl A bool indicating whether international format + * @param __intl A bool indicating whether international format * is to be used. * * Sent to a stream object, this manipulator extracts @a __mon. @@ -286,7 +286,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION if (__err) __is.setstate(__err); } - return __is; + return __is; } @@ -296,7 +296,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /** * @brief Extended manipulator for inserting money. * @param __mon Either long double or a specialization of @c basic_string. - * @param __intl A bool indicating whether international format + * @param __intl A bool indicating whether international format * is to be used. * * Sent to a stream object, this manipulator inserts @a __mon. @@ -307,7 +307,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return { __mon, __intl }; } template - basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f) { typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os); @@ -334,7 +334,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION if (__err) __os.setstate(__err); } - return __os; + return __os; } template @@ -490,7 +490,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif // __cplusplus >= 201103L // Inhibit implicit instantiations for required instantiations, - // which are defined via explicit instantiations elsewhere. + // which are defined via explicit instantiations elsewhere. // NB: This syntax is a GNU extension. #if _GLIBCXX_EXTERN_TEMPLATE extern template ostream& operator<<(ostream&, _Setfill); diff --git a/libstdc++-v3/include/std/iosfwd b/libstdc++-v3/include/std/iosfwd index e01a464e686..d81782e63f3 100644 --- a/libstdc++-v3/include/std/iosfwd +++ b/libstdc++-v3/include/std/iosfwd @@ -129,7 +129,7 @@ _GLIBCXX_END_NAMESPACE_CXX11 /// Base class for @c char streams. - typedef basic_ios ios; + typedef basic_ios ios; /// Base class for @c char buffers. typedef basic_streambuf streambuf; diff --git a/libstdc++-v3/include/std/istream b/libstdc++-v3/include/std/istream index f36d2b6c91e..d4cf7bcbfd5 100644 --- a/libstdc++-v3/include/std/istream +++ b/libstdc++-v3/include/std/istream @@ -922,7 +922,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template inline basic_istream<_CharT, _Traits>& operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x) - { + { __is >> __x; return __is; } diff --git a/libstdc++-v3/include/std/limits b/libstdc++-v3/include/std/limits index 53a183f712e..a1224d61aa6 100644 --- a/libstdc++-v3/include/std/limits +++ b/libstdc++-v3/include/std/limits @@ -296,7 +296,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /** See std::float_round_style for more information. This is only meaningful for floating types; integer types will all be round_toward_zero. */ - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -384,10 +384,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR bool + static _GLIBCXX_CONSTEXPR bool min() _GLIBCXX_USE_NOEXCEPT { return false; } - static _GLIBCXX_CONSTEXPR bool + static _GLIBCXX_CONSTEXPR bool max() _GLIBCXX_USE_NOEXCEPT { return true; } #if __cplusplus >= 201103L @@ -404,10 +404,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR bool + static _GLIBCXX_CONSTEXPR bool epsilon() _GLIBCXX_USE_NOEXCEPT { return false; } - static _GLIBCXX_CONSTEXPR bool + static _GLIBCXX_CONSTEXPR bool round_error() _GLIBCXX_USE_NOEXCEPT { return false; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -418,20 +418,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR bool + static _GLIBCXX_CONSTEXPR bool infinity() _GLIBCXX_USE_NOEXCEPT { return false; } - static _GLIBCXX_CONSTEXPR bool + static _GLIBCXX_CONSTEXPR bool quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return false; } - static _GLIBCXX_CONSTEXPR bool + static _GLIBCXX_CONSTEXPR bool signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return false; } - static _GLIBCXX_CONSTEXPR bool + static _GLIBCXX_CONSTEXPR bool denorm_min() _GLIBCXX_USE_NOEXCEPT { return false; } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; @@ -443,7 +443,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // promotion semantics. static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -453,14 +453,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR char + static _GLIBCXX_CONSTEXPR char min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min(char); } - static _GLIBCXX_CONSTEXPR char + static _GLIBCXX_CONSTEXPR char max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max(char); } #if __cplusplus >= 201103L - static constexpr char + static constexpr char lowest() noexcept { return min(); } #endif @@ -474,10 +474,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR char + static _GLIBCXX_CONSTEXPR char epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR char + static _GLIBCXX_CONSTEXPR char round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -488,20 +488,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR + static _GLIBCXX_CONSTEXPR char infinity() _GLIBCXX_USE_NOEXCEPT { return char(); } - static _GLIBCXX_CONSTEXPR char + static _GLIBCXX_CONSTEXPR char quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); } - static _GLIBCXX_CONSTEXPR char + static _GLIBCXX_CONSTEXPR char signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return char(); } - static _GLIBCXX_CONSTEXPR char + static _GLIBCXX_CONSTEXPR char denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; @@ -510,7 +510,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -520,19 +520,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR signed char + static _GLIBCXX_CONSTEXPR signed char min() _GLIBCXX_USE_NOEXCEPT { return -__SCHAR_MAX__ - 1; } - static _GLIBCXX_CONSTEXPR signed char + static _GLIBCXX_CONSTEXPR signed char max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__; } #if __cplusplus >= 201103L - static constexpr signed char + static constexpr signed char lowest() noexcept { return min(); } #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (signed char); - static _GLIBCXX_USE_CONSTEXPR int digits10 + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (signed char); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; @@ -542,10 +542,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR signed char + static _GLIBCXX_CONSTEXPR signed char epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR signed char + static _GLIBCXX_CONSTEXPR signed char round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -556,21 +556,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR signed char + static _GLIBCXX_CONSTEXPR signed char infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR signed char + static _GLIBCXX_CONSTEXPR signed char quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR signed char + static _GLIBCXX_CONSTEXPR signed char signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR signed char + static _GLIBCXX_CONSTEXPR signed char denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } @@ -580,7 +580,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -590,20 +590,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR unsigned char + static _GLIBCXX_CONSTEXPR unsigned char min() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR unsigned char + static _GLIBCXX_CONSTEXPR unsigned char max() _GLIBCXX_USE_NOEXCEPT { return __SCHAR_MAX__ * 2U + 1; } #if __cplusplus >= 201103L - static constexpr unsigned char + static constexpr unsigned char lowest() noexcept { return min(); } #endif - static _GLIBCXX_USE_CONSTEXPR int digits + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (unsigned char); - static _GLIBCXX_USE_CONSTEXPR int digits10 + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (unsigned char); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; @@ -613,10 +613,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR unsigned char + static _GLIBCXX_CONSTEXPR unsigned char epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR unsigned char + static _GLIBCXX_CONSTEXPR unsigned char round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -627,23 +627,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR unsigned char + static _GLIBCXX_CONSTEXPR unsigned char infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned char + static _GLIBCXX_CONSTEXPR unsigned char quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned char + static _GLIBCXX_CONSTEXPR unsigned char signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned char + static _GLIBCXX_CONSTEXPR unsigned char denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } @@ -653,7 +653,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -663,10 +663,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR wchar_t + static _GLIBCXX_CONSTEXPR wchar_t min() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_min (wchar_t); } - static _GLIBCXX_CONSTEXPR wchar_t + static _GLIBCXX_CONSTEXPR wchar_t max() _GLIBCXX_USE_NOEXCEPT { return __glibcxx_max (wchar_t); } #if __cplusplus >= 201103L @@ -675,7 +675,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (wchar_t); - static _GLIBCXX_USE_CONSTEXPR int digits10 + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (wchar_t); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; @@ -685,10 +685,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR wchar_t + static _GLIBCXX_CONSTEXPR wchar_t epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR wchar_t + static _GLIBCXX_CONSTEXPR wchar_t round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -699,20 +699,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR wchar_t + static _GLIBCXX_CONSTEXPR wchar_t infinity() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } - static _GLIBCXX_CONSTEXPR wchar_t + static _GLIBCXX_CONSTEXPR wchar_t quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } - static _GLIBCXX_CONSTEXPR wchar_t + static _GLIBCXX_CONSTEXPR wchar_t signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } - static _GLIBCXX_CONSTEXPR wchar_t + static _GLIBCXX_CONSTEXPR wchar_t denorm_min() _GLIBCXX_USE_NOEXCEPT { return wchar_t(); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; @@ -721,7 +721,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -732,13 +732,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static constexpr bool is_specialized = true; - static constexpr char16_t + static constexpr char16_t min() noexcept { return __glibcxx_min (char16_t); } - static constexpr char16_t + static constexpr char16_t max() noexcept { return __glibcxx_max (char16_t); } - static constexpr char16_t + static constexpr char16_t lowest() noexcept { return min(); } static constexpr int digits = __glibcxx_digits (char16_t); @@ -749,10 +749,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static constexpr bool is_exact = true; static constexpr int radix = 2; - static constexpr char16_t + static constexpr char16_t epsilon() noexcept { return 0; } - static constexpr char16_t + static constexpr char16_t round_error() noexcept { return 0; } static constexpr int min_exponent = 0; @@ -766,16 +766,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; - static constexpr char16_t + static constexpr char16_t infinity() noexcept { return char16_t(); } - static constexpr char16_t + static constexpr char16_t quiet_NaN() noexcept { return char16_t(); } - static constexpr char16_t + static constexpr char16_t signaling_NaN() noexcept { return char16_t(); } - static constexpr char16_t + static constexpr char16_t denorm_min() noexcept { return char16_t(); } static constexpr bool is_iec559 = false; @@ -793,13 +793,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static constexpr bool is_specialized = true; - static constexpr char32_t + static constexpr char32_t min() noexcept { return __glibcxx_min (char32_t); } - static constexpr char32_t + static constexpr char32_t max() noexcept { return __glibcxx_max (char32_t); } - static constexpr char32_t + static constexpr char32_t lowest() noexcept { return min(); } static constexpr int digits = __glibcxx_digits (char32_t); @@ -810,10 +810,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static constexpr bool is_exact = true; static constexpr int radix = 2; - static constexpr char32_t + static constexpr char32_t epsilon() noexcept { return 0; } - static constexpr char32_t + static constexpr char32_t round_error() noexcept { return 0; } static constexpr int min_exponent = 0; @@ -827,16 +827,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static constexpr float_denorm_style has_denorm = denorm_absent; static constexpr bool has_denorm_loss = false; - static constexpr char32_t + static constexpr char32_t infinity() noexcept { return char32_t(); } - static constexpr char32_t + static constexpr char32_t quiet_NaN() noexcept { return char32_t(); } - static constexpr char32_t + static constexpr char32_t signaling_NaN() noexcept { return char32_t(); } - static constexpr char32_t + static constexpr char32_t denorm_min() noexcept { return char32_t(); } static constexpr bool is_iec559 = false; @@ -855,14 +855,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR short + static _GLIBCXX_CONSTEXPR short min() _GLIBCXX_USE_NOEXCEPT { return -__SHRT_MAX__ - 1; } - static _GLIBCXX_CONSTEXPR short + static _GLIBCXX_CONSTEXPR short max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__; } #if __cplusplus >= 201103L - static constexpr short + static constexpr short lowest() noexcept { return min(); } #endif @@ -876,10 +876,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR short + static _GLIBCXX_CONSTEXPR short epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR short + static _GLIBCXX_CONSTEXPR short round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -890,20 +890,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR short + static _GLIBCXX_CONSTEXPR short infinity() _GLIBCXX_USE_NOEXCEPT { return short(); } - static _GLIBCXX_CONSTEXPR short + static _GLIBCXX_CONSTEXPR short quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); } - static _GLIBCXX_CONSTEXPR short + static _GLIBCXX_CONSTEXPR short signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return short(); } - static _GLIBCXX_CONSTEXPR short + static _GLIBCXX_CONSTEXPR short denorm_min() _GLIBCXX_USE_NOEXCEPT { return short(); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; @@ -912,7 +912,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -922,20 +922,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR unsigned short + static _GLIBCXX_CONSTEXPR unsigned short min() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR unsigned short + static _GLIBCXX_CONSTEXPR unsigned short max() _GLIBCXX_USE_NOEXCEPT { return __SHRT_MAX__ * 2U + 1; } #if __cplusplus >= 201103L - static constexpr unsigned short + static constexpr unsigned short lowest() noexcept { return min(); } #endif - static _GLIBCXX_USE_CONSTEXPR int digits + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (unsigned short); - static _GLIBCXX_USE_CONSTEXPR int digits10 + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (unsigned short); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; @@ -945,10 +945,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR unsigned short + static _GLIBCXX_CONSTEXPR unsigned short epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR unsigned short + static _GLIBCXX_CONSTEXPR unsigned short round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -959,23 +959,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR unsigned short + static _GLIBCXX_CONSTEXPR unsigned short infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned short + static _GLIBCXX_CONSTEXPR unsigned short quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned short + static _GLIBCXX_CONSTEXPR unsigned short signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned short + static _GLIBCXX_CONSTEXPR unsigned short denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } @@ -985,7 +985,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -995,14 +995,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR int + static _GLIBCXX_CONSTEXPR int min() _GLIBCXX_USE_NOEXCEPT { return -__INT_MAX__ - 1; } - static _GLIBCXX_CONSTEXPR int + static _GLIBCXX_CONSTEXPR int max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__; } #if __cplusplus >= 201103L - static constexpr int + static constexpr int lowest() noexcept { return min(); } #endif @@ -1016,10 +1016,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR int + static _GLIBCXX_CONSTEXPR int epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR int + static _GLIBCXX_CONSTEXPR int round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -1030,20 +1030,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR int + static _GLIBCXX_CONSTEXPR int infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR int + static _GLIBCXX_CONSTEXPR int quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR int + static _GLIBCXX_CONSTEXPR int signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR int + static _GLIBCXX_CONSTEXPR int denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; @@ -1052,7 +1052,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -1062,20 +1062,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR unsigned int + static _GLIBCXX_CONSTEXPR unsigned int min() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR unsigned int + static _GLIBCXX_CONSTEXPR unsigned int max() _GLIBCXX_USE_NOEXCEPT { return __INT_MAX__ * 2U + 1; } #if __cplusplus >= 201103L - static constexpr unsigned int + static constexpr unsigned int lowest() noexcept { return min(); } #endif - static _GLIBCXX_USE_CONSTEXPR int digits + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (unsigned int); - static _GLIBCXX_USE_CONSTEXPR int digits10 + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (unsigned int); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; @@ -1085,10 +1085,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR unsigned int + static _GLIBCXX_CONSTEXPR unsigned int epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR unsigned int + static _GLIBCXX_CONSTEXPR unsigned int round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -1099,22 +1099,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR unsigned int + static _GLIBCXX_CONSTEXPR unsigned int infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned int + static _GLIBCXX_CONSTEXPR unsigned int quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned int + static _GLIBCXX_CONSTEXPR unsigned int signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned int + static _GLIBCXX_CONSTEXPR unsigned int denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } @@ -1124,7 +1124,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -1137,11 +1137,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_CONSTEXPR long min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_MAX__ - 1; } - static _GLIBCXX_CONSTEXPR long + static _GLIBCXX_CONSTEXPR long max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__; } #if __cplusplus >= 201103L - static constexpr long + static constexpr long lowest() noexcept { return min(); } #endif @@ -1155,10 +1155,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR long + static _GLIBCXX_CONSTEXPR long epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR long + static _GLIBCXX_CONSTEXPR long round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -1169,20 +1169,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR long + static _GLIBCXX_CONSTEXPR long infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR long + static _GLIBCXX_CONSTEXPR long quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR long + static _GLIBCXX_CONSTEXPR long signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR long + static _GLIBCXX_CONSTEXPR long denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; @@ -1191,7 +1191,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -1201,20 +1201,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR unsigned long + static _GLIBCXX_CONSTEXPR unsigned long min() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR unsigned long + static _GLIBCXX_CONSTEXPR unsigned long max() _GLIBCXX_USE_NOEXCEPT { return __LONG_MAX__ * 2UL + 1; } #if __cplusplus >= 201103L - static constexpr unsigned long + static constexpr unsigned long lowest() noexcept { return min(); } #endif - static _GLIBCXX_USE_CONSTEXPR int digits + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (unsigned long); - static _GLIBCXX_USE_CONSTEXPR int digits10 + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (unsigned long); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; @@ -1224,10 +1224,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR unsigned long + static _GLIBCXX_CONSTEXPR unsigned long epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR unsigned long + static _GLIBCXX_CONSTEXPR unsigned long round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -1238,23 +1238,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR unsigned long + static _GLIBCXX_CONSTEXPR unsigned long infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned long + static _GLIBCXX_CONSTEXPR unsigned long quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned long + static _GLIBCXX_CONSTEXPR unsigned long signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned long + static _GLIBCXX_CONSTEXPR unsigned long denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } @@ -1264,7 +1264,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -1274,20 +1274,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR long long + static _GLIBCXX_CONSTEXPR long long min() _GLIBCXX_USE_NOEXCEPT { return -__LONG_LONG_MAX__ - 1; } - static _GLIBCXX_CONSTEXPR long long + static _GLIBCXX_CONSTEXPR long long max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__; } #if __cplusplus >= 201103L - static constexpr long long + static constexpr long long lowest() noexcept { return min(); } #endif - static _GLIBCXX_USE_CONSTEXPR int digits + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (long long); - static _GLIBCXX_USE_CONSTEXPR int digits10 + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (long long); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; @@ -1297,10 +1297,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR long long + static _GLIBCXX_CONSTEXPR long long epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR long long + static _GLIBCXX_CONSTEXPR long long round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -1311,21 +1311,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR long long + static _GLIBCXX_CONSTEXPR long long infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR long long + static _GLIBCXX_CONSTEXPR long long quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR long long + static _GLIBCXX_CONSTEXPR long long signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR long long + static _GLIBCXX_CONSTEXPR long long denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 = false; @@ -1334,7 +1334,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -1344,20 +1344,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR unsigned long long + static _GLIBCXX_CONSTEXPR unsigned long long min() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR unsigned long long + static _GLIBCXX_CONSTEXPR unsigned long long max() _GLIBCXX_USE_NOEXCEPT { return __LONG_LONG_MAX__ * 2ULL + 1; } #if __cplusplus >= 201103L - static constexpr unsigned long long + static constexpr unsigned long long lowest() noexcept { return min(); } #endif - static _GLIBCXX_USE_CONSTEXPR int digits + static _GLIBCXX_USE_CONSTEXPR int digits = __glibcxx_digits (unsigned long long); - static _GLIBCXX_USE_CONSTEXPR int digits10 + static _GLIBCXX_USE_CONSTEXPR int digits10 = __glibcxx_digits10 (unsigned long long); #if __cplusplus >= 201103L static constexpr int max_digits10 = 0; @@ -1367,10 +1367,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = true; static _GLIBCXX_USE_CONSTEXPR int radix = 2; - static _GLIBCXX_CONSTEXPR unsigned long long + static _GLIBCXX_CONSTEXPR unsigned long long epsilon() _GLIBCXX_USE_NOEXCEPT { return 0; } - static _GLIBCXX_CONSTEXPR unsigned long long + static _GLIBCXX_CONSTEXPR unsigned long long round_error() _GLIBCXX_USE_NOEXCEPT { return 0; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = 0; @@ -1381,23 +1381,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_infinity = false; static _GLIBCXX_USE_CONSTEXPR bool has_quiet_NaN = false; static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = false; - static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm + static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = denorm_absent; static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = false; - static _GLIBCXX_CONSTEXPR unsigned long long + static _GLIBCXX_CONSTEXPR unsigned long long infinity() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned long long + static _GLIBCXX_CONSTEXPR unsigned long long quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned long long + static _GLIBCXX_CONSTEXPR unsigned long long signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } - static _GLIBCXX_CONSTEXPR unsigned long long + static _GLIBCXX_CONSTEXPR unsigned long long denorm_min() _GLIBCXX_USE_NOEXCEPT { return static_cast(0); } @@ -1407,7 +1407,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_integral_traps; static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = false; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_toward_zero; }; @@ -1595,14 +1595,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR float + static _GLIBCXX_CONSTEXPR float min() _GLIBCXX_USE_NOEXCEPT { return __FLT_MIN__; } - static _GLIBCXX_CONSTEXPR float + static _GLIBCXX_CONSTEXPR float max() _GLIBCXX_USE_NOEXCEPT { return __FLT_MAX__; } #if __cplusplus >= 201103L - static constexpr float + static constexpr float lowest() noexcept { return -__FLT_MAX__; } #endif @@ -1617,10 +1617,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; - static _GLIBCXX_CONSTEXPR float + static _GLIBCXX_CONSTEXPR float epsilon() _GLIBCXX_USE_NOEXCEPT { return __FLT_EPSILON__; } - static _GLIBCXX_CONSTEXPR float + static _GLIBCXX_CONSTEXPR float round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5F; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = __FLT_MIN_EXP__; @@ -1633,19 +1633,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = bool(__FLT_HAS_DENORM__) ? denorm_present : denorm_absent; - static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = __glibcxx_float_has_denorm_loss; - static _GLIBCXX_CONSTEXPR float + static _GLIBCXX_CONSTEXPR float infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_valf(); } - static _GLIBCXX_CONSTEXPR float + static _GLIBCXX_CONSTEXPR float quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanf(""); } - static _GLIBCXX_CONSTEXPR float + static _GLIBCXX_CONSTEXPR float signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansf(""); } - static _GLIBCXX_CONSTEXPR float + static _GLIBCXX_CONSTEXPR float denorm_min() _GLIBCXX_USE_NOEXCEPT { return __FLT_DENORM_MIN__; } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 @@ -1654,9 +1654,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_float_traps; - static _GLIBCXX_USE_CONSTEXPR bool tinyness_before + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = __glibcxx_float_tinyness_before; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_to_nearest; }; @@ -1670,14 +1670,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR double + static _GLIBCXX_CONSTEXPR double min() _GLIBCXX_USE_NOEXCEPT { return __DBL_MIN__; } - static _GLIBCXX_CONSTEXPR double + static _GLIBCXX_CONSTEXPR double max() _GLIBCXX_USE_NOEXCEPT { return __DBL_MAX__; } #if __cplusplus >= 201103L - static constexpr double + static constexpr double lowest() noexcept { return -__DBL_MAX__; } #endif @@ -1692,10 +1692,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; - static _GLIBCXX_CONSTEXPR double + static _GLIBCXX_CONSTEXPR double epsilon() _GLIBCXX_USE_NOEXCEPT { return __DBL_EPSILON__; } - static _GLIBCXX_CONSTEXPR double + static _GLIBCXX_CONSTEXPR double round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = __DBL_MIN_EXP__; @@ -1708,19 +1708,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_signaling_NaN = has_quiet_NaN; static _GLIBCXX_USE_CONSTEXPR float_denorm_style has_denorm = bool(__DBL_HAS_DENORM__) ? denorm_present : denorm_absent; - static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss + static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = __glibcxx_double_has_denorm_loss; - static _GLIBCXX_CONSTEXPR double + static _GLIBCXX_CONSTEXPR double infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_val(); } - static _GLIBCXX_CONSTEXPR double + static _GLIBCXX_CONSTEXPR double quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nan(""); } - static _GLIBCXX_CONSTEXPR double + static _GLIBCXX_CONSTEXPR double signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nans(""); } - static _GLIBCXX_CONSTEXPR double + static _GLIBCXX_CONSTEXPR double denorm_min() _GLIBCXX_USE_NOEXCEPT { return __DBL_DENORM_MIN__; } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 @@ -1729,9 +1729,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_double_traps; - static _GLIBCXX_USE_CONSTEXPR bool tinyness_before + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = __glibcxx_double_tinyness_before; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_to_nearest; }; @@ -1745,14 +1745,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static _GLIBCXX_USE_CONSTEXPR bool is_specialized = true; - static _GLIBCXX_CONSTEXPR long double + static _GLIBCXX_CONSTEXPR long double min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MIN__; } - static _GLIBCXX_CONSTEXPR long double + static _GLIBCXX_CONSTEXPR long double max() _GLIBCXX_USE_NOEXCEPT { return __LDBL_MAX__; } #if __cplusplus >= 201103L - static constexpr long double + static constexpr long double lowest() noexcept { return -__LDBL_MAX__; } #endif @@ -1767,10 +1767,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_exact = false; static _GLIBCXX_USE_CONSTEXPR int radix = __FLT_RADIX__; - static _GLIBCXX_CONSTEXPR long double + static _GLIBCXX_CONSTEXPR long double epsilon() _GLIBCXX_USE_NOEXCEPT { return __LDBL_EPSILON__; } - static _GLIBCXX_CONSTEXPR long double + static _GLIBCXX_CONSTEXPR long double round_error() _GLIBCXX_USE_NOEXCEPT { return 0.5L; } static _GLIBCXX_USE_CONSTEXPR int min_exponent = __LDBL_MIN_EXP__; @@ -1786,16 +1786,16 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool has_denorm_loss = __glibcxx_long_double_has_denorm_loss; - static _GLIBCXX_CONSTEXPR long double + static _GLIBCXX_CONSTEXPR long double infinity() _GLIBCXX_USE_NOEXCEPT { return __builtin_huge_vall(); } - static _GLIBCXX_CONSTEXPR long double + static _GLIBCXX_CONSTEXPR long double quiet_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nanl(""); } - static _GLIBCXX_CONSTEXPR long double + static _GLIBCXX_CONSTEXPR long double signaling_NaN() _GLIBCXX_USE_NOEXCEPT { return __builtin_nansl(""); } - static _GLIBCXX_CONSTEXPR long double + static _GLIBCXX_CONSTEXPR long double denorm_min() _GLIBCXX_USE_NOEXCEPT { return __LDBL_DENORM_MIN__; } static _GLIBCXX_USE_CONSTEXPR bool is_iec559 @@ -1804,9 +1804,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static _GLIBCXX_USE_CONSTEXPR bool is_modulo = false; static _GLIBCXX_USE_CONSTEXPR bool traps = __glibcxx_long_double_traps; - static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = + static _GLIBCXX_USE_CONSTEXPR bool tinyness_before = __glibcxx_long_double_tinyness_before; - static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = + static _GLIBCXX_USE_CONSTEXPR float_round_style round_style = round_to_nearest; }; diff --git a/libstdc++-v3/include/std/ratio b/libstdc++-v3/include/std/ratio index 6c9a1174d91..9d7b61cd840 100644 --- a/libstdc++-v3/include/std/ratio +++ b/libstdc++-v3/include/std/ratio @@ -3,14 +3,14 @@ // Copyright (C) 2008-2016 Free Software Foundation, Inc. // // This file is part of the GNU ISO C++ Library. This library is free -// software; you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the // Free Software Foundation; either version 3, or (at your option) // any later version. // This library is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // Under Section 7 of GPL version 3, you are granted additional @@ -94,11 +94,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION static const uintmax_t __b0 = __static_abs<_Qn>::value % __c; static const uintmax_t __b1 = __static_abs<_Qn>::value / __c; - static_assert(__a1 == 0 || __b1 == 0, + static_assert(__a1 == 0 || __b1 == 0, "overflow in multiplication"); - static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1), + static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1), "overflow in multiplication"); - static_assert(__b0 * __a0 <= __INTMAX_MAX__, + static_assert(__b0 * __a0 <= __INTMAX_MAX__, "overflow in multiplication"); static_assert((__a0 * __b1 + __b0 * __a1) * __c <= __INTMAX_MAX__ - __b0 * __a0, @@ -257,7 +257,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * std::ratio<7,-21>::num == -1; * std::ratio<7,-21>::den == 3; * @endcode - * + * */ template struct ratio @@ -340,7 +340,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION struct ratio_equal : integral_constant { }; - + /// ratio_not_equal template struct ratio_not_equal @@ -354,7 +354,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION struct __ratio_less_impl_1 : integral_constant::value> - { }; + { }; template::type { }; - + /// ratio_less_equal template struct ratio_less_equal : integral_constant::value> { }; - + /// ratio_greater template struct ratio_greater diff --git a/libstdc++-v3/include/std/scoped_allocator b/libstdc++-v3/include/std/scoped_allocator index aac2dfee664..310c85c6507 100644 --- a/libstdc++-v3/include/std/scoped_allocator +++ b/libstdc++-v3/include/std/scoped_allocator @@ -68,7 +68,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template class scoped_allocator_adaptor; - template + template struct __inner_type_impl; template @@ -81,25 +81,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __inner_type_impl(__inner_type_impl&&) = default; __inner_type_impl& operator=(const __inner_type_impl&) = default; __inner_type_impl& operator=(__inner_type_impl&&) = default; - + template __inner_type_impl(const __inner_type_impl<_Alloc>& __other) { } - + template __inner_type_impl(__inner_type_impl<_Alloc>&& __other) { } - - __type& + + __type& _M_get(__type* __p) noexcept { return *__p; } - const __type& + const __type& _M_get(const __type* __p) const noexcept { return *__p; } - - tuple<> + + tuple<> _M_tie() const noexcept { return tuple<>(); } - - bool + + bool operator==(const __inner_type_impl&) const noexcept { return true; } }; @@ -108,17 +108,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION struct __inner_type_impl<_Outer, _InnerHead, _InnerTail...> { typedef scoped_allocator_adaptor<_InnerHead, _InnerTail...> __type; - + __inner_type_impl() = default; __inner_type_impl(const __inner_type_impl&) = default; __inner_type_impl(__inner_type_impl&&) = default; __inner_type_impl& operator=(const __inner_type_impl&) = default; __inner_type_impl& operator=(__inner_type_impl&&) = default; - + template __inner_type_impl(const __inner_type_impl<_Allocs...>& __other) : _M_inner(__other._M_inner) { } - + template __inner_type_impl(__inner_type_impl<_Allocs...>&& __other) : _M_inner(std::move(__other._M_inner)) { } @@ -128,24 +128,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __inner_type_impl(_Args&&... __args) : _M_inner(std::forward<_Args>(__args)...) { } - __type& + __type& _M_get(void*) noexcept { return _M_inner; } - - const __type& + + const __type& _M_get(const void*) const noexcept { return _M_inner; } - - tuple + + tuple _M_tie() const noexcept { return _M_inner._M_tie(); } - - bool + + bool operator==(const __inner_type_impl& __other) const noexcept { return _M_inner == __other._M_inner; } - + private: template friend class __inner_type_impl; template friend class scoped_allocator_adaptor; - + __type _M_inner; }; @@ -176,9 +176,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template using __outermost_alloc_traits = allocator_traits<__outermost_type<_Alloc>>; - + template - void + void _M_construct(__uses_alloc0, _Tp* __p, _Args&&... __args) { typedef __outermost_alloc_traits _O_traits; @@ -190,7 +190,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typedef __uses_alloc2 __uses_alloc2_; template - void + void _M_construct(__uses_alloc1_, _Tp* __p, _Args&&... __args) { typedef __outermost_alloc_traits _O_traits; @@ -200,7 +200,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } template - void + void _M_construct(__uses_alloc2_, _Tp* __p, _Args&&... __args) { typedef __outermost_alloc_traits _O_traits; diff --git a/libstdc++-v3/include/std/sstream b/libstdc++-v3/include/std/sstream index de6cdf15308..bfe2ca1cdac 100644 --- a/libstdc++-v3/include/std/sstream +++ b/libstdc++-v3/include/std/sstream @@ -209,7 +209,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 virtual streamsize showmanyc() - { + { streamsize __ret = -1; if (_M_mode & ios_base::in) { @@ -248,10 +248,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11 // that an external char_type array of length __n exists // and has been pre-allocated. If this is not the case, // things will quickly blow up. - + // Step 1: Destroy the current internal array. _M_string.clear(); - + // Step 2: Use the external array. _M_sync(__s, __n, 0); } diff --git a/libstdc++-v3/include/std/stdexcept b/libstdc++-v3/include/std/stdexcept index aef27cc3617..459bc02db8f 100644 --- a/libstdc++-v3/include/std/stdexcept +++ b/libstdc++-v3/include/std/stdexcept @@ -110,13 +110,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * program runs (e.g., violations of class invariants). * @brief One of two subclasses of exception. */ - class logic_error : public exception + class logic_error : public exception { __cow_string _M_msg; public: /** Takes a character string describing the error. */ - explicit + explicit logic_error(const string& __arg) _GLIBCXX_TXN_SAFE; #if __cplusplus >= 201103L @@ -133,7 +133,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /** Returns a C-style character string describing the general cause of * the current error (the same string passed to the ctor). */ - virtual const char* + virtual const char* what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT; # ifdef _GLIBCXX_TM_TS_INTERNAL @@ -144,7 +144,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /** Thrown by the library, or by you, to report domain errors (domain in * the mathematical sense). */ - class domain_error : public logic_error + class domain_error : public logic_error { public: explicit domain_error(const string& __arg) _GLIBCXX_TXN_SAFE; @@ -155,7 +155,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION }; /** Thrown to report invalid arguments to functions. */ - class invalid_argument : public logic_error + class invalid_argument : public logic_error { public: explicit invalid_argument(const string& __arg) _GLIBCXX_TXN_SAFE; @@ -167,7 +167,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /** Thrown when an object is constructed that would exceed its maximum * permitted size (e.g., a basic_string instance). */ - class length_error : public logic_error + class length_error : public logic_error { public: explicit length_error(const string& __arg) _GLIBCXX_TXN_SAFE; @@ -179,7 +179,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /** This represents an argument whose value is not within the expected * range (e.g., boundary checks in basic_string). */ - class out_of_range : public logic_error + class out_of_range : public logic_error { public: explicit out_of_range(const string& __arg) _GLIBCXX_TXN_SAFE; @@ -194,13 +194,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * the program executes. * @brief One of two subclasses of exception. */ - class runtime_error : public exception + class runtime_error : public exception { __cow_string _M_msg; public: /** Takes a character string describing the error. */ - explicit + explicit runtime_error(const string& __arg) _GLIBCXX_TXN_SAFE; #if __cplusplus >= 201103L @@ -217,7 +217,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /** Returns a C-style character string describing the general cause of * the current error (the same string passed to the ctor). */ - virtual const char* + virtual const char* what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT; # ifdef _GLIBCXX_TM_TS_INTERNAL @@ -227,7 +227,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION }; /** Thrown to indicate range errors in internal computations. */ - class range_error : public runtime_error + class range_error : public runtime_error { public: explicit range_error(const string& __arg) _GLIBCXX_TXN_SAFE; @@ -238,7 +238,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION }; /** Thrown to indicate arithmetic overflow. */ - class overflow_error : public runtime_error + class overflow_error : public runtime_error { public: explicit overflow_error(const string& __arg) _GLIBCXX_TXN_SAFE; @@ -249,7 +249,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION }; /** Thrown to indicate arithmetic underflow. */ - class underflow_error : public runtime_error + class underflow_error : public runtime_error { public: explicit underflow_error(const string& __arg) _GLIBCXX_TXN_SAFE; diff --git a/libstdc++-v3/include/std/string b/libstdc++-v3/include/std/string index 28c56779079..77f899ab63a 100644 --- a/libstdc++-v3/include/std/string +++ b/libstdc++-v3/include/std/string @@ -46,10 +46,10 @@ #include #include #include // For less -#include -#include +#include +#include #include #include -#include +#include #endif /* _GLIBCXX_STRING */ diff --git a/libstdc++-v3/include/std/system_error b/libstdc++-v3/include/std/system_error index b871c1e4396..79320fac598 100644 --- a/libstdc++-v3/include/std/system_error +++ b/libstdc++-v3/include/std/system_error @@ -56,7 +56,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct is_error_condition_enum : public false_type { }; - template<> + template<> struct is_error_condition_enum : public true_type { }; @@ -73,7 +73,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION error_category(const error_category&) = delete; error_category& operator=(const error_category&) = delete; - virtual const char* + virtual const char* name() const noexcept = 0; // We need two different virtual functions here, one returning a @@ -91,7 +91,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION virtual string message(int) const = 0; #else - virtual string + virtual string message(int) const = 0; private: @@ -103,21 +103,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION virtual error_condition default_error_condition(int __i) const noexcept; - virtual bool + virtual bool equivalent(int __i, const error_condition& __cond) const noexcept; - virtual bool + virtual bool equivalent(const error_code& __code, int __i) const noexcept; - bool + bool operator<(const error_category& __other) const noexcept { return less()(this, &__other); } - bool + bool operator==(const error_category& __other) const noexcept { return this == &__other; } - bool + bool operator!=(const error_category& __other) const noexcept { return this != &__other; } }; @@ -148,14 +148,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION error_code(_ErrorCodeEnum __e) noexcept { *this = make_error_code(__e); } - void + void assign(int __v, const error_category& __cat) noexcept { _M_value = __v; - _M_cat = &__cat; + _M_cat = &__cat; } - void + void clear() noexcept { assign(0, system_category()); } @@ -168,15 +168,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION int value() const noexcept { return _M_value; } - - const error_category& + + const error_category& category() const noexcept { return *_M_cat; } - error_condition + error_condition default_error_condition() const noexcept; _GLIBCXX_DEFAULT_ABI_TAG - string + string message() const { return category().message(value()); } @@ -198,7 +198,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION inline bool operator<(const error_code& __lhs, const error_code& __rhs) noexcept - { + { return (__lhs.category() < __rhs.category() || (__lhs.category() == __rhs.category() && __lhs.value() < __rhs.value())); @@ -213,7 +213,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// error_condition // Portable error identification - struct error_condition + struct error_condition { error_condition() noexcept : _M_value(0), _M_cat(&generic_category()) { } @@ -240,7 +240,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION operator=(_ErrorConditionEnum __e) noexcept { return *this = make_error_condition(__e); } - void + void clear() noexcept { assign(0, generic_category()); } @@ -252,7 +252,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION category() const noexcept { return *_M_cat; } _GLIBCXX_DEFAULT_ABI_TAG - string + string message() const { return category().message(value()); } @@ -270,7 +270,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION make_error_condition(errc __e) noexcept { return error_condition(static_cast(__e), generic_category()); } - inline bool + inline bool operator<(const error_condition& __lhs, const error_condition& __rhs) noexcept { @@ -325,7 +325,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { return !(__lhs == __rhs); } - /** + /** * @brief Thrown to indicate error code of underlying system. * * @ingroup exceptions @@ -358,7 +358,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION virtual ~system_error() noexcept; - const error_code& + const error_code& code() const noexcept { return _M_code; } }; diff --git a/libstdc++-v3/include/std/thread b/libstdc++-v3/include/std/thread index 15aa9a9b577..7e185d310dd 100644 --- a/libstdc++-v3/include/std/thread +++ b/libstdc++-v3/include/std/thread @@ -112,7 +112,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { swap(__t); } template - explicit + explicit thread(_Callable&& __f, _Args&&... __args) { #ifdef GTHR_ACTIVE_PROXY diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple index 6c124048df1..9c425e77562 100644 --- a/libstdc++-v3/include/std/tuple +++ b/libstdc++-v3/include/std/tuple @@ -173,7 +173,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * get() operation. */ template - struct _Tuple_impl; + struct _Tuple_impl; /** * Recursive tuple implementation. Here we store the @c Head element @@ -190,7 +190,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; typedef _Head_base<_Idx, _Head> _Base; - static constexpr _Head& + static constexpr _Head& _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } static constexpr const _Head& @@ -205,12 +205,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr _Tuple_impl() : _Inherited(), _Base() { } - explicit + explicit constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail) : _Inherited(__tail...), _Base(__head) { } template::type> + enable_if::type> explicit constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail) : _Inherited(std::forward<_UTail>(__tail)...), @@ -222,7 +222,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Tuple_impl(_Tuple_impl&& __in) noexcept(__and_, is_nothrow_move_constructible<_Inherited>>::value) - : _Inherited(std::move(_M_tail(__in))), + : _Inherited(std::move(_M_tail(__in))), _Base(std::forward<_Head>(_M_head(__in))) { } template @@ -260,13 +260,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, const _Tuple_impl& __in) - : _Inherited(__tag, __a, _M_tail(__in)), + : _Inherited(__tag, __a, _M_tail(__in)), _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { } template _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _Tuple_impl&& __in) - : _Inherited(__tag, __a, std::move(_M_tail(__in))), + : _Inherited(__tag, __a, std::move(_M_tail(__in))), _Base(__use_alloc<_Head, _Alloc, _Head>(__a), std::forward<_Head>(_M_head(__in))) { } @@ -551,7 +551,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION }; /// Primary class template, tuple - template + template class tuple : public _Tuple_impl<0, _Elements...> { typedef _Tuple_impl<0, _Elements...> _Inherited; @@ -658,7 +658,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr tuple(const tuple&) = default; - constexpr tuple(tuple&&) = default; + constexpr tuple(tuple&&) = default; // Shortcut for the cases where constructors taking tuples // must avoid creating temporaries. @@ -1339,7 +1339,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION return bool(std::get<__i>(__t) == std::get<__i>(__u)) && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); } - + static constexpr bool __less(const _Tp& __t, const _Up& __u) { @@ -1354,7 +1354,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { static constexpr bool __eq(const _Tp&, const _Up&) { return true; } - + static constexpr bool __less(const _Tp&, const _Up&) { return false; } }; @@ -1569,7 +1569,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// swap template - inline void + inline void swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) noexcept(noexcept(__x.swap(__y))) { __x.swap(__y); } diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits index 3a2b546b22f..eac2492904f 100644 --- a/libstdc++-v3/include/std/type_traits +++ b/libstdc++-v3/include/std/type_traits @@ -79,7 +79,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr value_type operator()() const { return value; } #endif }; - + template constexpr _Tp integral_constant<_Tp, __v>::value; @@ -212,7 +212,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template<> struct __is_integral_helper : public true_type { }; - + template<> struct __is_integral_helper : public true_type { }; @@ -648,7 +648,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct is_const<_Tp const> : public true_type { }; - + /// is_volatile template struct is_volatile @@ -766,7 +766,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION struct __is_array_unknown_bounds : public __and_, __not_>> { }; - + // In N3290 is_destructible does not say anything about function // types and abstract types, see LWG 2049. This implementation // describes function types as non-destructible and all complete @@ -889,9 +889,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION struct __is_default_constructible_safe; // The following technique is a workaround for a current core language - // restriction, which does not allow for array types to occur in + // restriction, which does not allow for array types to occur in // functional casts of the form T(). Complete arrays can be default- - // constructed, if the element type is default-constructible, but + // constructed, if the element type is default-constructible, but // arrays with unknown bounds are not. template struct __is_default_constructible_safe<_Tp, true> @@ -919,7 +919,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // This implementation uses different strategies depending on the // target type to reduce the test overhead as much as possible: // - // a) For a reference target type, we use a static_cast expression + // a) For a reference target type, we use a static_cast expression // modulo its extra cases. // // b) For a non-reference target type we use a ::new expression. @@ -990,7 +990,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION struct remove_reference; template, + = __not_<__or_, is_function<_From>>>::value> struct __is_base_to_derived_ref; @@ -1027,7 +1027,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _From>::type>::type __src_t; typedef typename remove_cv::type>::type __dst_t; - typedef __and_<__not_>, + typedef __and_<__not_>, __or_, is_base_of<__dst_t, __src_t>>> type; static constexpr bool value = type::value; @@ -1038,11 +1038,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : public false_type { }; - // Here we handle direct-initialization to a reference type as + // Here we handle direct-initialization to a reference type as // equivalent to a static_cast modulo overshooting conversions. // These are restricted to the following conversions: // a) A base class value to a derived class reference - // b) An lvalue to an rvalue-reference of reference-compatible + // b) An lvalue to an rvalue-reference of reference-compatible // types that are not functions template struct __is_direct_constructible_ref_cast @@ -1350,7 +1350,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : public __and_, integral_constant> { }; - + /// is_trivially_default_constructible template struct is_trivially_default_constructible @@ -1390,15 +1390,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// is_trivially_copy_constructible template struct is_trivially_copy_constructible - : public __and_, + : public __and_, integral_constant> { }; - + /// is_trivially_move_constructible template struct is_trivially_move_constructible - : public __and_, + : public __and_, integral_constant> { }; @@ -1406,7 +1406,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// is_trivially_assignable template struct is_trivially_assignable - : public __and_, + : public __and_, integral_constant> { }; @@ -1414,7 +1414,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// is_trivially_copy_assignable template struct is_trivially_copy_assignable - : public __and_, + : public __and_, integral_constant> { }; @@ -1422,7 +1422,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// is_trivially_move_assignable template struct is_trivially_move_assignable - : public __and_, + : public __and_, integral_constant> { }; @@ -1458,19 +1458,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : public integral_constant { }; - + // type property queries. /// alignment_of template struct alignment_of : public integral_constant { }; - + /// rank template struct rank : public integral_constant { }; - + template struct rank<_Tp[_Size]> : public integral_constant::value> { }; @@ -1483,7 +1483,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct extent : public integral_constant { }; - + template struct extent<_Tp[_Size], _Uint> : public integral_constant struct remove_const<_Tp const> { typedef _Tp type; }; - + /// remove_volatile template struct remove_volatile @@ -1568,7 +1568,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct remove_volatile<_Tp volatile> { typedef _Tp type; }; - + /// remove_cv template struct remove_cv @@ -1576,17 +1576,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typedef typename remove_const::type>::type type; }; - + /// add_const template struct add_const { typedef _Tp const type; }; - + /// add_volatile template struct add_volatile { typedef _Tp volatile type; }; - + /// add_cv template struct add_cv @@ -1711,7 +1711,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; public: - typedef typename __match::__type __type; + typedef typename __match::__type __type; }; // Utility for finding the unsigned versions of signed integral types. @@ -1771,7 +1771,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif // Select between integral and enum: not possible to be both. - template::value, bool _IsEnum = is_enum<_Tp>::value> class __make_unsigned_selector; @@ -1816,7 +1816,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Primary template. /// make_unsigned template - struct make_unsigned + struct make_unsigned { typedef typename __make_unsigned_selector<_Tp>::__type type; }; // Integral, but don't define. @@ -1890,7 +1890,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif // Select between integral and enum: not possible to be both. - template::value, bool _IsEnum = is_enum<_Tp>::value> class __make_signed_selector; @@ -1920,7 +1920,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Primary template. /// make_signed template - struct make_signed + struct make_signed { typedef typename __make_signed_selector<_Tp>::__type type; }; // Integral, but don't define. @@ -2002,7 +2002,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { typedef typename remove_reference<_Tp>::type* type; }; template - struct add_pointer + struct add_pointer : public __add_pointer_helper<_Tp> { }; @@ -2018,11 +2018,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __aligned_storage_msa - { + { union __type { unsigned char __data[_Len]; - struct __attribute__((__aligned__)) { } __align; + struct __attribute__((__aligned__)) { } __align; }; }; @@ -2039,11 +2039,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template::__type)> struct aligned_storage - { + { union type { unsigned char __data[_Len]; - struct __attribute__((__aligned__((_Align)))) { } __align; + struct __attribute__((__aligned__((_Align)))) { } __align; }; }; @@ -2096,28 +2096,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Decay trait for arrays and functions, used for perfect forwarding // in make_pair, make_tuple, etc. - template::value, - bool _IsFunction = is_function<_Up>::value> + bool _IsFunction = is_function<_Up>::value> struct __decay_selector; // NB: DR 705. - template + template struct __decay_selector<_Up, false, false> { typedef typename remove_cv<_Up>::type __type; }; - template + template struct __decay_selector<_Up, true, false> { typedef typename remove_extent<_Up>::type* __type; }; - template + template struct __decay_selector<_Up, false, true> { typedef typename add_pointer<_Up>::type __type; }; /// decay - template - class decay - { + template + class decay + { typedef typename remove_reference<_Tp>::type __remove_type; public: @@ -2151,7 +2151,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Primary template. /// Define a member typedef @c type only if a boolean constant is true. template - struct enable_if + struct enable_if { }; // Partial specialization for true. diff --git a/libstdc++-v3/include/std/utility b/libstdc++-v3/include/std/utility index 480bd5d18ea..1451a91d42a 100644 --- a/libstdc++-v3/include/std/utility +++ b/libstdc++-v3/include/std/utility @@ -49,7 +49,7 @@ */ /** @file include/utility - * This is a Standard C++ Library header. + * This is a Standard C++ Library header. */ #ifndef _GLIBCXX_UTILITY @@ -150,7 +150,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct tuple_element<0, std::pair<_Tp1, _Tp2>> { typedef _Tp1 type; }; - + /// Partial specialization for std::pair template struct tuple_element<1, std::pair<_Tp1, _Tp2>> diff --git a/libstdc++-v3/include/std/valarray b/libstdc++-v3/include/std/valarray index 69d96b440a3..3d8e5d6ee28 100644 --- a/libstdc++-v3/include/std/valarray +++ b/libstdc++-v3/include/std/valarray @@ -23,7 +23,7 @@ // . /** @file include/valarray - * This is a Standard C++ Library header. + * This is a Standard C++ Library header. */ // Written by Gabriel Dos Reis @@ -45,11 +45,11 @@ namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION - template + template class _Expr; - template - class _ValArray; + template + class _ValArray; template class _Meta, class _Dom> struct _UnClos; @@ -57,22 +57,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template class _Meta1, template class _Meta2, - class _Dom1, class _Dom2> + class _Dom1, class _Dom2> class _BinClos; - template class _Meta, class _Dom> + template class _Meta, class _Dom> class _SClos; - template class _Meta, class _Dom> + template class _Meta, class _Dom> class _GClos; - - template class _Meta, class _Dom> + + template class _Meta, class _Dom> class _IClos; - - template class _Meta, class _Dom> + + template class _Meta, class _Dom> class _ValFunClos; - - template class _Meta, class _Dom> + + template class _Meta, class _Dom> class _RefFunClos; template class valarray; // An array of type _Tp @@ -88,7 +88,7 @@ _GLIBCXX_END_NAMESPACE_VERSION #include #include - + namespace std _GLIBCXX_VISIBILITY(default) { _GLIBCXX_BEGIN_NAMESPACE_VERSION @@ -109,21 +109,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION * aliasing that can result from pointer representations. It represents a * one-dimensional array from which different multidimensional subsets can * be accessed and modified. - * + * * @tparam _Tp Type of object in the array. */ - template + template class valarray { template - struct _UnaryOp + struct _UnaryOp { typedef typename __fun<_Op, _Tp>::result_type __rt; typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt; }; public: typedef _Tp value_type; - + // _lib.valarray.cons_ construct/destroy: /// Construct an empty array. valarray(); @@ -254,7 +254,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // _lib.valarray.access_ element access: /** - * Return a reference to the i'th array element. + * Return a reference to the i'th array element. * * @param __i Index of element to return. * @return Reference to the i'th element. @@ -482,10 +482,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION _Tp sum() const; /// Return the minimum element using operator<(). - _Tp min() const; + _Tp min() const; /// Return the maximum element using operator<(). - _Tp max() const; + _Tp max() const; /** * @brief Return a shifted array. @@ -559,14 +559,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION private: size_t _M_size; _Tp* __restrict__ _M_data; - + friend class _Array<_Tp>; }; - + template inline const _Tp& valarray<_Tp>::operator[](size_t __i) const - { + { __glibcxx_requires_subscript(__i); return _M_data[__i]; } @@ -574,7 +574,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template inline _Tp& valarray<_Tp>::operator[](size_t __i) - { + { __glibcxx_requires_subscript(__i); return _M_data[__i]; } @@ -605,8 +605,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {} template - inline - valarray<_Tp>::valarray(size_t __n) + inline + valarray<_Tp>::valarray(size_t __n) : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) { std::__valarray_default_construct(_M_data, _M_data + __n); } @@ -620,9 +620,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION inline valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n) : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) - { + { __glibcxx_assert(__p != 0 || __n == 0); - std::__valarray_copy_construct(__p, __p + __n, _M_data); + std::__valarray_copy_construct(__p, __p + __n, _M_data); } template @@ -917,7 +917,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif template - inline size_t + inline size_t valarray<_Tp>::size() const { return _M_size; } @@ -1027,7 +1027,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION } std::__valarray_fill_construct(_M_data, _M_data + __n, __c); } - + template inline _Tp valarray<_Tp>::min() const @@ -1043,7 +1043,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION __glibcxx_assert(_M_size > 0); return *std::max_element(_M_data, _M_data + _M_size); } - + template inline _Expr<_ValFunClos<_ValArray, _Tp>, _Tp> valarray<_Tp>::apply(_Tp func(_Tp)) const @@ -1130,7 +1130,7 @@ _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, __shift_left) _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right) #undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT - + #define _DEFINE_BINARY_OPERATOR(_Op, _Name) \ template \ diff --git a/libstdc++-v3/include/std/vector b/libstdc++-v3/include/std/vector index a68d892266b..0e9ce754960 100644 --- a/libstdc++-v3/include/std/vector +++ b/libstdc++-v3/include/std/vector @@ -62,7 +62,7 @@ #include #include #include -#include +#include #include #ifndef _GLIBCXX_EXPORT_TEMPLATE -- 2.30.2