git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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
This commit is contained in:
Jonathan Wakely 2016-06-16 14:47:35 +01:00 committed by Jonathan Wakely
parent 1dc8d15bc6
commit 33ac58d529
26 changed files with 597 additions and 571 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
libstdc++-v3/ChangeLog
View File

@ -1,5 +1,31 @@
2016-06-16 Jonathan Wakely <jwakely@redhat.com> 2016-06-16 Jonathan Wakely <jwakely@redhat.com>
* 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 * include/bits/stl_vector.h (vector::_S_insert_aux_assign): Define
new overloaded functions. new overloaded functions.
* include/bits/vector.tcc (vector::_M_insert_aux): Use new functions * include/bits/vector.tcc (vector::_M_insert_aux): Use new functions

38
libstdc++-v3/include/std/array
View File

@ -134,19 +134,19 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
end() const noexcept end() const noexcept
{ return const_iterator(data() + _Nm); } { return const_iterator(data() + _Nm); }
reverse_iterator reverse_iterator
rbegin() noexcept rbegin() noexcept
{ return reverse_iterator(end()); } { return reverse_iterator(end()); }
const_reverse_iterator const_reverse_iterator
rbegin() const noexcept rbegin() const noexcept
{ return const_reverse_iterator(end()); } { return const_reverse_iterator(end()); }
reverse_iterator reverse_iterator
rend() noexcept rend() noexcept
{ return reverse_iterator(begin()); } { return reverse_iterator(begin()); }
const_reverse_iterator const_reverse_iterator
rend() const noexcept rend() const noexcept
{ return const_reverse_iterator(begin()); } { return const_reverse_iterator(begin()); }
@ -158,22 +158,22 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
cend() const noexcept cend() const noexcept
{ return const_iterator(data() + _Nm); } { return const_iterator(data() + _Nm); }
const_reverse_iterator const_reverse_iterator
crbegin() const noexcept crbegin() const noexcept
{ return const_reverse_iterator(end()); } { return const_reverse_iterator(end()); }
const_reverse_iterator const_reverse_iterator
crend() const noexcept crend() const noexcept
{ return const_reverse_iterator(begin()); } { return const_reverse_iterator(begin()); }
// Capacity. // Capacity.
constexpr size_type constexpr size_type
size() const noexcept { return _Nm; } size() const noexcept { return _Nm; }
constexpr size_type constexpr size_type
max_size() const noexcept { return _Nm; } max_size() const noexcept { return _Nm; }
constexpr bool constexpr bool
empty() const noexcept { return size() == 0; } empty() const noexcept { return size() == 0; }
// Element access. // Element access.
@ -207,22 +207,22 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
_AT_Type::_S_ref(_M_elems, 0)); _AT_Type::_S_ref(_M_elems, 0));
} }
reference reference
front() noexcept front() noexcept
{ return *begin(); } { return *begin(); }
constexpr const_reference constexpr const_reference
front() const noexcept front() const noexcept
{ return _AT_Type::_S_ref(_M_elems, 0); } { return _AT_Type::_S_ref(_M_elems, 0); }
reference reference
back() noexcept back() noexcept
{ return _Nm ? *(end() - 1) : *end(); } { return _Nm ? *(end() - 1) : *end(); }
constexpr const_reference constexpr const_reference
back() const noexcept 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); : _AT_Type::_S_ref(_M_elems, 0);
} }
@ -237,7 +237,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
// Array comparisons. // Array comparisons.
template<typename _Tp, std::size_t _Nm> template<typename _Tp, std::size_t _Nm>
inline bool inline bool
operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two)
{ return std::equal(__one.begin(), __one.end(), __two.begin()); } { return std::equal(__one.begin(), __one.end(), __two.begin()); }
@ -249,9 +249,9 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Tp, std::size_t _Nm> template<typename _Tp, std::size_t _Nm>
inline bool inline bool
operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b)
{ {
return std::lexicographical_compare(__a.begin(), __a.end(), return std::lexicographical_compare(__a.begin(), __a.end(),
__b.begin(), __b.end()); __b.begin(), __b.end());
} }
template<typename _Tp, std::size_t _Nm> template<typename _Tp, std::size_t _Nm>
@ -312,7 +312,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Tuple interface to class template array. // Tuple interface to class template array.
/// tuple_size /// tuple_size
template<typename _Tp> template<typename _Tp>
class tuple_size; class tuple_size;
/// Partial specialization for std::array /// Partial specialization for std::array

22
libstdc++-v3/include/std/atomic
View File

@ -198,11 +198,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return load(); } { return load(); }
_Tp _Tp
operator=(_Tp __i) noexcept operator=(_Tp __i) noexcept
{ store(__i); return __i; } { store(__i); return __i; }
_Tp _Tp
operator=(_Tp __i) volatile noexcept operator=(_Tp __i) volatile noexcept
{ store(__i); return __i; } { store(__i); return __i; }
bool bool
@ -231,7 +231,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Tp _Tp
load(memory_order __m = memory_order_seq_cst) const noexcept load(memory_order __m = memory_order_seq_cst) const noexcept
{ {
_Tp tmp; _Tp tmp;
__atomic_load(std::__addressof(_M_i), std::__addressof(tmp), __m); __atomic_load(std::__addressof(_M_i), std::__addressof(tmp), __m);
return tmp; return tmp;
@ -239,7 +239,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Tp _Tp
load(memory_order __m = memory_order_seq_cst) const volatile noexcept load(memory_order __m = memory_order_seq_cst) const volatile noexcept
{ {
_Tp tmp; _Tp tmp;
__atomic_load(std::__addressof(_M_i), std::__addressof(tmp), __m); __atomic_load(std::__addressof(_M_i), std::__addressof(tmp), __m);
return tmp; return tmp;
@ -247,7 +247,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Tp _Tp
exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept exchange(_Tp __i, memory_order __m = memory_order_seq_cst) noexcept
{ {
_Tp tmp; _Tp tmp;
__atomic_exchange(std::__addressof(_M_i), std::__addressof(__i), __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
std::__addressof(tmp), __m); std::__addressof(tmp), __m);
@ -255,9 +255,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} }
_Tp _Tp
exchange(_Tp __i, exchange(_Tp __i,
memory_order __m = memory_order_seq_cst) volatile noexcept memory_order __m = memory_order_seq_cst) volatile noexcept
{ {
_Tp tmp; _Tp tmp;
__atomic_exchange(std::__addressof(_M_i), std::__addressof(__i), __atomic_exchange(std::__addressof(_M_i), std::__addressof(__i),
std::__addressof(tmp), __m); std::__addressof(tmp), __m);
@ -265,7 +265,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} }
bool 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 memory_order __f) noexcept
{ {
return __atomic_compare_exchange(std::__addressof(_M_i), return __atomic_compare_exchange(std::__addressof(_M_i),
@ -275,7 +275,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} }
bool 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 memory_order __f) volatile noexcept
{ {
return __atomic_compare_exchange(std::__addressof(_M_i), return __atomic_compare_exchange(std::__addressof(_M_i),
@ -297,7 +297,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__cmpexch_failure_order(__m)); } __cmpexch_failure_order(__m)); }
bool 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 memory_order __f) noexcept
{ {
return __atomic_compare_exchange(std::__addressof(_M_i), return __atomic_compare_exchange(std::__addressof(_M_i),
@ -307,7 +307,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} }
bool 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 memory_order __f) volatile noexcept
{ {
return __atomic_compare_exchange(std::__addressof(_M_i), return __atomic_compare_exchange(std::__addressof(_M_i),

34
libstdc++-v3/include/std/bitset
View File

@ -245,7 +245,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
_M_w[__n] = _M_w[__n - __wshift]; _M_w[__n] = _M_w[__n - __wshift];
else else
{ {
const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD const size_t __sub_offset = (_GLIBCXX_BITSET_BITS_PER_WORD
- __offset); - __offset);
for (size_t __n = _Nw - 1; __n > __wshift; --__n) for (size_t __n = _Nw - 1; __n > __wshift; --__n)
_M_w[__n] = ((_M_w[__n - __wshift] << __offset) _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[__n + __wshift + 1] << __sub_offset));
_M_w[__limit] = _M_w[_Nw-1] >> __offset; _M_w[__limit] = _M_w[_Nw-1] >> __offset;
} }
std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0)); std::fill(_M_w + __limit + 1, _M_w + _Nw, static_cast<_WordT>(0));
} }
} }
@ -556,7 +556,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
_WordT& _WordT&
_M_getword(size_t) _GLIBCXX_NOEXCEPT _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; return *new _WordT;
} }
@ -659,7 +659,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
typedef unsigned long _WordT; typedef unsigned long _WordT;
static void static void
_S_do_sanitize(_WordT) _GLIBCXX_NOEXCEPT { } _S_do_sanitize(_WordT) _GLIBCXX_NOEXCEPT { }
}; };
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
@ -773,7 +773,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
void void
_M_do_sanitize() _GLIBCXX_NOEXCEPT _M_do_sanitize() _GLIBCXX_NOEXCEPT
{ {
typedef _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD> __sanitize_type; typedef _Sanitize<_Nb % _GLIBCXX_BITSET_BITS_PER_WORD> __sanitize_type;
__sanitize_type::_S_do_sanitize(this->_M_hiword()); __sanitize_type::_S_do_sanitize(this->_M_hiword());
} }
@ -801,10 +801,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
_WordT* _M_wp; _WordT* _M_wp;
size_t _M_bpos; size_t _M_bpos;
// left undefined // left undefined
reference(); reference();
public: public:
reference(bitset& __b, size_t __pos) _GLIBCXX_NOEXCEPT reference(bitset& __b, size_t __pos) _GLIBCXX_NOEXCEPT
{ {
@ -981,7 +981,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
return *this; return *this;
} }
//@} //@}
//@{ //@{
/** /**
* Operations on bitsets. * Operations on bitsets.
@ -1015,7 +1015,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
return *this; return *this;
} }
//@} //@}
//@{ //@{
/** /**
* These versions of single-bit set, reset, flip, and test are * 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)) { return ((this->_M_getword(__pos) & _Base::_S_maskbit(__pos))
!= static_cast<_WordT>(0)); } != static_cast<_WordT>(0)); }
//@} //@}
// Set, reset, and flip. // Set, reset, and flip.
/** /**
* @brief Sets every bit to true. * @brief Sets every bit to true.
@ -1107,7 +1107,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
this->_M_check(__position, __N("bitset::reset")); this->_M_check(__position, __N("bitset::reset"));
return _Unchecked_reset(__position); return _Unchecked_reset(__position);
} }
/** /**
* @brief Toggles every bit to its opposite value. * @brief Toggles every bit to its opposite value.
*/ */
@ -1130,7 +1130,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
this->_M_check(__position, __N("bitset::flip")); this->_M_check(__position, __N("bitset::flip"));
return _Unchecked_flip(__position); return _Unchecked_flip(__position);
} }
/// See the no-argument flip(). /// See the no-argument flip().
bitset<_Nb> bitset<_Nb>
operator~() const _GLIBCXX_NOEXCEPT operator~() const _GLIBCXX_NOEXCEPT
@ -1159,7 +1159,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
operator[](size_t __position) const operator[](size_t __position) const
{ return _Unchecked_test(__position); } { return _Unchecked_test(__position); }
//@} //@}
/** /**
* @brief Returns a numerical interpretation of the %bitset. * @brief Returns a numerical interpretation of the %bitset.
* @return The integral equivalent of the bits. * @return The integral equivalent of the bits.
@ -1302,7 +1302,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT operator!=(const bitset<_Nb>& __rhs) const _GLIBCXX_NOEXCEPT
{ return !this->_M_is_equal(__rhs); } { return !this->_M_is_equal(__rhs); }
//@} //@}
/** /**
* @brief Tests the value of a bit. * @brief Tests the value of a bit.
* @param __position The index 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 operator>>(size_t __position) const _GLIBCXX_NOEXCEPT
{ return bitset<_Nb>(*this) >>= __position; } { return bitset<_Nb>(*this) >>= __position; }
//@} //@}
/** /**
* @brief Finds the index of the first "on" bit. * @brief Finds the index of the first "on" bit.
* @return The index of the first bit set, or size() if not found. * @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) for (size_t __i = _Nb; __i > 0; --__i)
{ {
static typename _Traits::int_type __eof = _Traits::eof(); static typename _Traits::int_type __eof = _Traits::eof();
typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc(); typename _Traits::int_type __c1 = __is.rdbuf()->sbumpc();
if (_Traits::eq_int_type(__c1, __eof)) if (_Traits::eq_int_type(__c1, __eof))
{ {
@ -1508,7 +1508,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
} }
__catch(__cxxabiv1::__forced_unwind&) __catch(__cxxabiv1::__forced_unwind&)
{ {
__is._M_setstate(__ios_base::badbit); __is._M_setstate(__ios_base::badbit);
__throw_exception_again; __throw_exception_again;
} }
__catch(...) __catch(...)

16
libstdc++-v3/include/std/chrono
View File

@ -72,7 +72,7 @@ namespace std _GLIBCXX_VISIBILITY(default)
_GLIBCXX_BEGIN_NAMESPACE_VERSION _GLIBCXX_BEGIN_NAMESPACE_VERSION
// 20.11.4.3 specialization of common_type (for duration, sfinae-friendly) // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
template<typename _CT, typename _Period1, typename _Period2> template<typename _CT, typename _Period1, typename _Period2>
struct __duration_common_type_wrapper 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) // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
template<typename _CT, typename _Clock> template<typename _CT, typename _Clock>
struct __timepoint_common_type_wrapper struct __timepoint_common_type_wrapper
{ {
@ -625,11 +625,11 @@ _GLIBCXX_END_NAMESPACE_VERSION
typename common_type<duration<_Rep1, _Period1>, _Dur2>::type> typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
operator+(const duration<_Rep1, _Period1>& __lhs, operator+(const duration<_Rep1, _Period1>& __lhs,
const time_point<_Clock, _Dur2>& __rhs) const time_point<_Clock, _Dur2>& __rhs)
{ {
typedef duration<_Rep1, _Period1> __dur1; typedef duration<_Rep1, _Period1> __dur1;
typedef typename common_type<__dur1,_Dur2>::type __ct; typedef typename common_type<__dur1,_Dur2>::type __ct;
typedef time_point<_Clock, __ct> __time_point; typedef time_point<_Clock, __ct> __time_point;
return __time_point(__rhs.time_since_epoch() + __lhs); return __time_point(__rhs.time_since_epoch() + __lhs);
} }
template<typename _Clock, typename _Dur1, template<typename _Clock, typename _Dur1,
@ -638,11 +638,11 @@ _GLIBCXX_END_NAMESPACE_VERSION
typename common_type<_Dur1, duration<_Rep2, _Period2>>::type> typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
operator-(const time_point<_Clock, _Dur1>& __lhs, operator-(const time_point<_Clock, _Dur1>& __lhs,
const duration<_Rep2, _Period2>& __rhs) const duration<_Rep2, _Period2>& __rhs)
{ {
typedef duration<_Rep2, _Period2> __dur2; typedef duration<_Rep2, _Period2> __dur2;
typedef typename common_type<_Dur1,__dur2>::type __ct; typedef typename common_type<_Dur1,__dur2>::type __ct;
typedef time_point<_Clock, __ct> __time_point; typedef time_point<_Clock, __ct> __time_point;
return __time_point(__lhs.time_since_epoch() -__rhs); return __time_point(__lhs.time_since_epoch() -__rhs);
} }
template<typename _Clock, typename _Dur1, typename _Dur2> template<typename _Clock, typename _Dur1, typename _Dur2>
@ -688,9 +688,9 @@ _GLIBCXX_END_NAMESPACE_VERSION
{ return !(__lhs < __rhs); } { 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 // Why have std::system_clock always count in the higest
// resolution (ie nanoseconds), even if on some OSes the low 3 // resolution (ie nanoseconds), even if on some OSes the low 3
// or 9 decimal digits will be always zero? This allows later // or 9 decimal digits will be always zero? This allows later

134
libstdc++-v3/include/std/complex
View File

@ -93,7 +93,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// Return @a x to the @a y'th power. /// Return @a x to the @a y'th power.
template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&); template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, const _Tp&);
/// Return @a x to the @a y'th power. /// Return @a x to the @a y'th power.
template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&, template<typename _Tp> complex<_Tp> pow(const complex<_Tp>&,
const complex<_Tp>&); const complex<_Tp>&);
/// Return @a x to the @a y'th power. /// Return @a x to the @a y'th power.
template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&); template<typename _Tp> complex<_Tp> pow(const _Tp&, const complex<_Tp>&);
@ -107,8 +107,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&); template<typename _Tp> complex<_Tp> tan(const complex<_Tp>&);
/// Return complex hyperbolic tangent of @a z. /// Return complex hyperbolic tangent of @a z.
template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&); template<typename _Tp> complex<_Tp> tanh(const complex<_Tp>&);
// 26.2.2 Primary template class complex // 26.2.2 Primary template class complex
/** /**
* Template to represent complex numbers. * Template to represent complex numbers.
@ -123,7 +123,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ {
/// Value typedef. /// Value typedef.
typedef _Tp value_type; typedef _Tp value_type;
/// Default constructor. First parameter is x, second parameter is y. /// Default constructor. First parameter is x, second parameter is y.
/// Unspecified parameters default to 0. /// Unspecified parameters default to 0.
_GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp()) _GLIBCXX_CONSTEXPR complex(const _Tp& __r = _Tp(), const _Tp& __i = _Tp())
@ -143,41 +143,41 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _GLIBCXX_RESOLVE_LIB_DEFECTS // _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated. // DR 387. std::complex over-encapsulated.
_GLIBCXX_ABI_TAG_CXX11 _GLIBCXX_ABI_TAG_CXX11
constexpr _Tp constexpr _Tp
real() const { return _M_real; } real() const { return _M_real; }
_GLIBCXX_ABI_TAG_CXX11 _GLIBCXX_ABI_TAG_CXX11
constexpr _Tp constexpr _Tp
imag() const { return _M_imag; } imag() const { return _M_imag; }
#else #else
/// Return real part of complex number. /// Return real part of complex number.
_Tp& _Tp&
real() { return _M_real; } real() { return _M_real; }
/// Return real part of complex number. /// Return real part of complex number.
const _Tp& const _Tp&
real() const { return _M_real; } real() const { return _M_real; }
/// Return imaginary part of complex number. /// Return imaginary part of complex number.
_Tp& _Tp&
imag() { return _M_imag; } imag() { return _M_imag; }
/// Return imaginary part of complex number. /// Return imaginary part of complex number.
const _Tp& const _Tp&
imag() const { return _M_imag; } imag() const { return _M_imag; }
#endif #endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS // _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated. // DR 387. std::complex over-encapsulated.
void void
real(_Tp __val) { _M_real = __val; } real(_Tp __val) { _M_real = __val; }
void void
imag(_Tp __val) { _M_imag = __val; } imag(_Tp __val) { _M_imag = __val; }
/// Assign a scalar to this complex number. /// Assign a scalar to this complex number.
complex<_Tp>& operator=(const _Tp&); complex<_Tp>& operator=(const _Tp&);
/// Add a scalar to this complex number. /// Add a scalar to this complex number.
// 26.2.5/1 // 26.2.5/1
complex<_Tp>& complex<_Tp>&
@ -237,7 +237,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_real = __t; _M_real = __t;
_M_imag = _Tp(); _M_imag = _Tp();
return *this; return *this;
} }
// 26.2.5/5 // 26.2.5/5
template<typename _Tp> template<typename _Tp>
@ -317,7 +317,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_real = __r / __n; _M_real = __r / __n;
return *this; return *this;
} }
// Operators: // Operators:
//@{ //@{
/// Return new complex value @a x plus @a y. /// Return new complex value @a x plus @a y.
@ -359,7 +359,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__r -= __y; __r -= __y;
return __r; return __r;
} }
template<typename _Tp> template<typename _Tp>
inline complex<_Tp> inline complex<_Tp>
operator-(const complex<_Tp>& __x, const _Tp& __y) operator-(const complex<_Tp>& __x, const _Tp& __y)
@ -419,7 +419,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__r /= __y; __r /= __y;
return __r; return __r;
} }
template<typename _Tp> template<typename _Tp>
inline complex<_Tp> inline complex<_Tp>
operator/(const complex<_Tp>& __x, const _Tp& __y) operator/(const complex<_Tp>& __x, const _Tp& __y)
@ -495,23 +495,23 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Tp __re_x, __im_x; _Tp __re_x, __im_x;
_CharT __ch; _CharT __ch;
__is >> __ch; __is >> __ch;
if (__ch == '(') if (__ch == '(')
{ {
__is >> __re_x >> __ch; __is >> __re_x >> __ch;
if (__ch == ',') if (__ch == ',')
{ {
__is >> __im_x >> __ch; __is >> __im_x >> __ch;
if (__ch == ')') if (__ch == ')')
__x = complex<_Tp>(__re_x, __im_x); __x = complex<_Tp>(__re_x, __im_x);
else else
__is.setstate(ios_base::failbit); __is.setstate(ios_base::failbit);
} }
else if (__ch == ')') else if (__ch == ')')
__x = __re_x; __x = __re_x;
else else
__is.setstate(ios_base::failbit); __is.setstate(ios_base::failbit);
} }
else else
{ {
__is.putback(__ch); __is.putback(__ch);
__is >> __re_x; __is >> __re_x;
@ -549,17 +549,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
inline _Tp& inline _Tp&
real(complex<_Tp>& __z) real(complex<_Tp>& __z)
{ return __z.real(); } { return __z.real(); }
template<typename _Tp> template<typename _Tp>
inline const _Tp& inline const _Tp&
real(const complex<_Tp>& __z) real(const complex<_Tp>& __z)
{ return __z.real(); } { return __z.real(); }
template<typename _Tp> template<typename _Tp>
inline _Tp& inline _Tp&
imag(complex<_Tp>& __z) imag(complex<_Tp>& __z)
{ return __z.imag(); } { return __z.imag(); }
template<typename _Tp> template<typename _Tp>
inline const _Tp& inline const _Tp&
imag(const complex<_Tp>& __z) imag(const complex<_Tp>& __z)
@ -576,7 +576,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
const _Tp __s = std::max(abs(__x), abs(__y)); const _Tp __s = std::max(abs(__x), abs(__y));
if (__s == _Tp()) // well ... if (__s == _Tp()) // well ...
return __s; return __s;
__x /= __s; __x /= __s;
__y /= __s; __y /= __s;
return __s * sqrt(__x * __x + __y * __y); return __s * sqrt(__x * __x + __y * __y);
} }
@ -599,7 +599,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp> template<typename _Tp>
inline _Tp inline _Tp
abs(const complex<_Tp>& __z) { return __complex_abs(__z); } abs(const complex<_Tp>& __z) { return __complex_abs(__z); }
#endif #endif
// 26.2.7/4: arg(__z): Returns the phase angle of __z. // 26.2.7/4: arg(__z): Returns the phase angle of __z.
@ -655,12 +655,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return __res * __res; return __res * __res;
} }
}; };
template<typename _Tp> template<typename _Tp>
inline _Tp inline _Tp
norm(const complex<_Tp>& __z) 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); && !_GLIBCXX_FAST_MATH>::_S_do_it(__z);
} }
@ -676,7 +676,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
inline complex<_Tp> inline complex<_Tp>
conj(const complex<_Tp>& __z) conj(const complex<_Tp>& __z)
{ return complex<_Tp>(__z.real(), -__z.imag()); } { return complex<_Tp>(__z.real(), -__z.imag()); }
// Transcendentals // Transcendentals
// 26.2.8/1 cos(__z): Returns the cosine of __z. // 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 __x = __z.real();
const _Tp __y = __z.imag(); 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 #if _GLIBCXX_USE_C99_COMPLEX
@ -839,14 +839,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#if _GLIBCXX_USE_C99_COMPLEX #if _GLIBCXX_USE_C99_COMPLEX
inline __complex__ float inline __complex__ float
__complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); } __complex_sinh(__complex__ float __z) { return __builtin_csinhf(__z); }
inline __complex__ double 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 inline __complex__ long double
__complex_sinh(const __complex__ long double& __z) __complex_sinh(const __complex__ long double& __z)
{ return __builtin_csinhl(__z); } { return __builtin_csinhl(__z); }
template<typename _Tp> template<typename _Tp>
inline complex<_Tp> inline complex<_Tp>
@ -902,7 +902,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif #endif
// 26.2.8/14 tan(__z): Return the complex tangent of __z. // 26.2.8/14 tan(__z): Return the complex tangent of __z.
template<typename _Tp> template<typename _Tp>
inline complex<_Tp> inline complex<_Tp>
__complex_tan(const complex<_Tp>& __z) __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. // 26.2.8/15 tanh(__z): Returns the hyperbolic tangent of __z.
template<typename _Tp> template<typename _Tp>
inline complex<_Tp> inline complex<_Tp>
__complex_tanh(const complex<_Tp>& __z) __complex_tanh(const complex<_Tp>& __z)
@ -1066,38 +1066,38 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif #endif
explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&); explicit _GLIBCXX_CONSTEXPR complex(const complex<double>&);
explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&); explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS // _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated. // DR 387. std::complex over-encapsulated.
__attribute ((__abi_tag__ ("cxx11"))) __attribute ((__abi_tag__ ("cxx11")))
constexpr float constexpr float
real() const { return __real__ _M_value; } real() const { return __real__ _M_value; }
__attribute ((__abi_tag__ ("cxx11"))) __attribute ((__abi_tag__ ("cxx11")))
constexpr float constexpr float
imag() const { return __imag__ _M_value; } imag() const { return __imag__ _M_value; }
#else #else
float& float&
real() { return __real__ _M_value; } real() { return __real__ _M_value; }
const float& const float&
real() const { return __real__ _M_value; } real() const { return __real__ _M_value; }
float& float&
imag() { return __imag__ _M_value; } imag() { return __imag__ _M_value; }
const float& const float&
imag() const { return __imag__ _M_value; } imag() const { return __imag__ _M_value; }
#endif #endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS // _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated. // DR 387. std::complex over-encapsulated.
void void
real(float __val) { __real__ _M_value = __val; } real(float __val) { __real__ _M_value = __val; }
void void
imag(float __val) { __imag__ _M_value = __val; } imag(float __val) { __imag__ _M_value = __val; }
complex& complex&
@ -1217,38 +1217,38 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_CONSTEXPR complex(const complex<float>& __z) _GLIBCXX_CONSTEXPR complex(const complex<float>& __z)
: _M_value(__z.__rep()) { } : _M_value(__z.__rep()) { }
explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&); explicit _GLIBCXX_CONSTEXPR complex(const complex<long double>&);
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
// _GLIBCXX_RESOLVE_LIB_DEFECTS // _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated. // DR 387. std::complex over-encapsulated.
__attribute ((__abi_tag__ ("cxx11"))) __attribute ((__abi_tag__ ("cxx11")))
constexpr double constexpr double
real() const { return __real__ _M_value; } real() const { return __real__ _M_value; }
__attribute ((__abi_tag__ ("cxx11"))) __attribute ((__abi_tag__ ("cxx11")))
constexpr double constexpr double
imag() const { return __imag__ _M_value; } imag() const { return __imag__ _M_value; }
#else #else
double& double&
real() { return __real__ _M_value; } real() { return __real__ _M_value; }
const double& const double&
real() const { return __real__ _M_value; } real() const { return __real__ _M_value; }
double& double&
imag() { return __imag__ _M_value; } imag() { return __imag__ _M_value; }
const double& const double&
imag() const { return __imag__ _M_value; } imag() const { return __imag__ _M_value; }
#endif #endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS // _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated. // DR 387. std::complex over-encapsulated.
void void
real(double __val) { __real__ _M_value = __val; } real(double __val) { __real__ _M_value = __val; }
void void
imag(double __val) { __imag__ _M_value = __val; } imag(double __val) { __imag__ _M_value = __val; }
complex& complex&
@ -1264,7 +1264,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_M_value += __d; _M_value += __d;
return *this; return *this;
} }
complex& complex&
operator-=(double __d) operator-=(double __d)
{ {
@ -1354,7 +1354,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_CONSTEXPR complex(_ComplexT __z) : _M_value(__z) { } _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) long double __i = 0.0L)
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
: _M_value{ __r, __i } { } : _M_value{ __r, __i } { }
@ -1375,32 +1375,32 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _GLIBCXX_RESOLVE_LIB_DEFECTS // _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated. // DR 387. std::complex over-encapsulated.
__attribute ((__abi_tag__ ("cxx11"))) __attribute ((__abi_tag__ ("cxx11")))
constexpr long double constexpr long double
real() const { return __real__ _M_value; } real() const { return __real__ _M_value; }
__attribute ((__abi_tag__ ("cxx11"))) __attribute ((__abi_tag__ ("cxx11")))
constexpr long double constexpr long double
imag() const { return __imag__ _M_value; } imag() const { return __imag__ _M_value; }
#else #else
long double& long double&
real() { return __real__ _M_value; } real() { return __real__ _M_value; }
const long double& const long double&
real() const { return __real__ _M_value; } real() const { return __real__ _M_value; }
long double& long double&
imag() { return __imag__ _M_value; } imag() { return __imag__ _M_value; }
const long double& const long double&
imag() const { return __imag__ _M_value; } imag() const { return __imag__ _M_value; }
#endif #endif
// _GLIBCXX_RESOLVE_LIB_DEFECTS // _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 387. std::complex over-encapsulated. // DR 387. std::complex over-encapsulated.
void void
real(long double __val) { __real__ _M_value = __val; } real(long double __val) { __real__ _M_value = __val; }
void void
imag(long double __val) { __imag__ _M_value = __val; } imag(long double __val) { __imag__ _M_value = __val; }
complex& complex&
@ -1554,7 +1554,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
public: public:
typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type; typedef std::complex<typename __promote_2<_Tp, _Up>::__type> __type;
}; };
template<typename _Tp, typename _Up> template<typename _Tp, typename _Up>
struct __promote_2<std::complex<_Tp>, std::complex<_Up> > struct __promote_2<std::complex<_Tp>, std::complex<_Up> >
{ {
@ -1653,7 +1653,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
asin(const std::complex<_Tp>& __z) asin(const std::complex<_Tp>& __z)
{ return __complex_asin(__z); } { return __complex_asin(__z); }
#endif #endif
template<typename _Tp> template<typename _Tp>
std::complex<_Tp> std::complex<_Tp>
__complex_atan(const std::complex<_Tp>& __z) __complex_atan(const std::complex<_Tp>& __z)

4
libstdc++-v3/include/std/condition_variable
View File

@ -60,7 +60,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// cv_status /// cv_status
enum class cv_status { no_timeout, timeout }; enum class cv_status { no_timeout, timeout };
/// condition_variable /// condition_variable
class condition_variable class condition_variable
{ {
@ -250,7 +250,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
unique_lock<mutex> __my_lock2(std::move(__my_lock)); unique_lock<mutex> __my_lock2(std::move(__my_lock));
_M_cond.wait(__my_lock2); _M_cond.wait(__my_lock2);
} }
template<typename _Lock, typename _Predicate> template<typename _Lock, typename _Predicate>
void void

2
libstdc++-v3/include/std/fstream
View File

@ -386,7 +386,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Common code for seekoff, seekpos, and overflow // Common code for seekoff, seekpos, and overflow
pos_type pos_type
_M_seek(off_type __off, ios_base::seekdir __way, __state_type __state); _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state);
int int
_M_get_ext_pos(__state_type &__state); _M_get_ext_pos(__state_type &__state);

2
libstdc++-v3/include/std/functional
View File

@ -1906,7 +1906,7 @@ _GLIBCXX_MEM_FN_TRAITS(&&, false_type, true_type)
* type @c T1, @c T2, ..., @c TN and returns a value convertible * type @c T1, @c T2, ..., @c TN and returns a value convertible
* to @c Res. * 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<F>, then this function * @a __f. If @a __f is @c reference_wrapper<F>, then this function
* object will contain a reference to the function object @c * object will contain a reference to the function object @c
* __f.get(). If @a __f is a NULL function pointer or NULL * __f.get(). If @a __f is a NULL function pointer or NULL

4
libstdc++-v3/include/std/future
View File

@ -225,7 +225,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef _Res result_type; typedef _Res result_type;
_Result() noexcept : _M_initialized() { } _Result() noexcept : _M_initialized() { }
~_Result() ~_Result()
{ {
if (_M_initialized) if (_M_initialized)
@ -263,7 +263,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
explicit explicit
_Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a) _Result_alloc(const _Alloc& __a) : _Result<_Res>(), _Alloc(__a)
{ } { }
private: private:
void _M_destroy() void _M_destroy()
{ {

120
libstdc++-v3/include/std/iomanip
View File

@ -62,24 +62,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* Sent to a stream object, this manipulator resets the specified flags, * Sent to a stream object, this manipulator resets the specified flags,
* via @e stream.setf(0,__mask). * via @e stream.setf(0,__mask).
*/ */
inline _Resetiosflags inline _Resetiosflags
resetiosflags(ios_base::fmtflags __mask) resetiosflags(ios_base::fmtflags __mask)
{ return { __mask }; } { return { __mask }; }
template<typename _CharT, typename _Traits> template<typename _CharT, typename _Traits>
inline basic_istream<_CharT, _Traits>& inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f) operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
{ {
__is.setf(ios_base::fmtflags(0), __f._M_mask); __is.setf(ios_base::fmtflags(0), __f._M_mask);
return __is; return __is;
} }
template<typename _CharT, typename _Traits> template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>& inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f) operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
{ {
__os.setf(ios_base::fmtflags(0), __f._M_mask); __os.setf(ios_base::fmtflags(0), __f._M_mask);
return __os; return __os;
} }
@ -92,24 +92,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* Sent to a stream object, this manipulator sets the format flags * Sent to a stream object, this manipulator sets the format flags
* to @a __mask. * to @a __mask.
*/ */
inline _Setiosflags inline _Setiosflags
setiosflags(ios_base::fmtflags __mask) setiosflags(ios_base::fmtflags __mask)
{ return { __mask }; } { return { __mask }; }
template<typename _CharT, typename _Traits> template<typename _CharT, typename _Traits>
inline basic_istream<_CharT, _Traits>& inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f) operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
{ {
__is.setf(__f._M_mask); __is.setf(__f._M_mask);
return __is; return __is;
} }
template<typename _CharT, typename _Traits> template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>& inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f) operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
{ {
__os.setf(__f._M_mask); __os.setf(__f._M_mask);
return __os; 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 * @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. * is 8, 10, or 16, accordingly, and to 0 if @a __base is any other value.
*/ */
inline _Setbase inline _Setbase
setbase(int __base) setbase(int __base)
{ return { __base }; } { return { __base }; }
template<typename _CharT, typename _Traits> template<typename _CharT, typename _Traits>
inline basic_istream<_CharT, _Traits>& inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f) operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
{ {
__is.setf(__f._M_base == 8 ? ios_base::oct : __is.setf(__f._M_base == 8 ? ios_base::oct :
__f._M_base == 10 ? ios_base::dec : __f._M_base == 10 ? ios_base::dec :
__f._M_base == 16 ? ios_base::hex : __f._M_base == 16 ? ios_base::hex :
ios_base::fmtflags(0), ios_base::basefield); ios_base::fmtflags(0), ios_base::basefield);
return __is; return __is;
} }
template<typename _CharT, typename _Traits> template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>& inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f) operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
{ {
__os.setf(__f._M_base == 8 ? ios_base::oct : __os.setf(__f._M_base == 8 ? ios_base::oct :
__f._M_base == 10 ? ios_base::dec : __f._M_base == 10 ? ios_base::dec :
__f._M_base == 16 ? ios_base::hex : __f._M_base == 16 ? ios_base::hex :
ios_base::fmtflags(0), ios_base::basefield); ios_base::fmtflags(0), ios_base::basefield);
return __os; return __os;
} }
template<typename _CharT> template<typename _CharT>
struct _Setfill { _CharT _M_c; }; struct _Setfill { _CharT _M_c; };
@ -166,19 +166,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return { __c }; } { return { __c }; }
template<typename _CharT, typename _Traits> template<typename _CharT, typename _Traits>
inline basic_istream<_CharT, _Traits>& inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f) operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
{ {
__is.fill(__f._M_c); __is.fill(__f._M_c);
return __is; return __is;
} }
template<typename _CharT, typename _Traits> template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>& inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f) operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
{ {
__os.fill(__f._M_c); __os.fill(__f._M_c);
return __os; return __os;
} }
@ -191,24 +191,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* Sent to a stream object, this manipulator calls @c precision(__n) for * Sent to a stream object, this manipulator calls @c precision(__n) for
* that object. * that object.
*/ */
inline _Setprecision inline _Setprecision
setprecision(int __n) setprecision(int __n)
{ return { __n }; } { return { __n }; }
template<typename _CharT, typename _Traits> template<typename _CharT, typename _Traits>
inline basic_istream<_CharT, _Traits>& inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f) operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
{ {
__is.precision(__f._M_n); __is.precision(__f._M_n);
return __is; return __is;
} }
template<typename _CharT, typename _Traits> template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>& inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f) operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
{ {
__os.precision(__f._M_n); __os.precision(__f._M_n);
return __os; return __os;
} }
@ -221,35 +221,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* Sent to a stream object, this manipulator calls @c width(__n) for * Sent to a stream object, this manipulator calls @c width(__n) for
* that object. * that object.
*/ */
inline _Setw inline _Setw
setw(int __n) setw(int __n)
{ return { __n }; } { return { __n }; }
template<typename _CharT, typename _Traits> template<typename _CharT, typename _Traits>
inline basic_istream<_CharT, _Traits>& inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f) operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
{ {
__is.width(__f._M_n); __is.width(__f._M_n);
return __is; return __is;
} }
template<typename _CharT, typename _Traits> template<typename _CharT, typename _Traits>
inline basic_ostream<_CharT, _Traits>& inline basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f) operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
{ {
__os.width(__f._M_n); __os.width(__f._M_n);
return __os; return __os;
} }
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
template<typename _MoneyT> template<typename _MoneyT>
struct _Get_money { _MoneyT& _M_mon; bool _M_intl; }; struct _Get_money { _MoneyT& _M_mon; bool _M_intl; };
/** /**
* @brief Extended manipulator for extracting money. * @brief Extended manipulator for extracting money.
* @param __mon Either long double or a specialization of @c basic_string. * @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. * is to be used.
* *
* Sent to a stream object, this manipulator extracts @a __mon. * Sent to a stream object, this manipulator extracts @a __mon.
@ -286,7 +286,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
if (__err) if (__err)
__is.setstate(__err); __is.setstate(__err);
} }
return __is; return __is;
} }
@ -296,7 +296,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/** /**
* @brief Extended manipulator for inserting money. * @brief Extended manipulator for inserting money.
* @param __mon Either long double or a specialization of @c basic_string. * @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. * is to be used.
* *
* Sent to a stream object, this manipulator inserts @a __mon. * Sent to a stream object, this manipulator inserts @a __mon.
@ -307,7 +307,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return { __mon, __intl }; } { return { __mon, __intl }; }
template<typename _CharT, typename _Traits, typename _MoneyT> template<typename _CharT, typename _Traits, typename _MoneyT>
basic_ostream<_CharT, _Traits>& basic_ostream<_CharT, _Traits>&
operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f) operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f)
{ {
typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os); typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
@ -334,7 +334,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
if (__err) if (__err)
__os.setstate(__err); __os.setstate(__err);
} }
return __os; return __os;
} }
template<typename _CharT> template<typename _CharT>
@ -490,7 +490,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif // __cplusplus >= 201103L #endif // __cplusplus >= 201103L
// Inhibit implicit instantiations for required instantiations, // 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. // NB: This syntax is a GNU extension.
#if _GLIBCXX_EXTERN_TEMPLATE #if _GLIBCXX_EXTERN_TEMPLATE
extern template ostream& operator<<(ostream&, _Setfill<char>); extern template ostream& operator<<(ostream&, _Setfill<char>);

2
libstdc++-v3/include/std/iosfwd
View File

@ -129,7 +129,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
/// Base class for @c char streams. /// Base class for @c char streams.
typedef basic_ios<char> ios; typedef basic_ios<char> ios;
/// Base class for @c char buffers. /// Base class for @c char buffers.
typedef basic_streambuf<char> streambuf; typedef basic_streambuf<char> streambuf;

2
libstdc++-v3/include/std/istream
View File

@ -922,7 +922,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _CharT, typename _Traits, typename _Tp> template<typename _CharT, typename _Traits, typename _Tp>
inline basic_istream<_CharT, _Traits>& inline basic_istream<_CharT, _Traits>&
operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x) operator>>(basic_istream<_CharT, _Traits>&& __is, _Tp& __x)
{ {
__is >> __x; __is >> __x;
return __is; return __is;
} }

416
libstdc++-v3/include/std/limits
View File

File diff suppressed because it is too large Load Diff

22
libstdc++-v3/include/std/ratio
View File

@ -3,14 +3,14 @@
// Copyright (C) 2008-2016 Free Software Foundation, Inc. // Copyright (C) 2008-2016 Free Software Foundation, Inc.
// //
// This file is part of the GNU ISO C++ Library. This library is free // 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 // software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the // terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option) // Free Software Foundation; either version 3, or (at your option)
// any later version. // any later version.
// This library is distributed in the hope that it will be useful, // This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of // 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. // GNU General Public License for more details.
// Under Section 7 of GPL version 3, you are granted additional // 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 __b0 = __static_abs<_Qn>::value % __c;
static const uintmax_t __b1 = __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"); "overflow in multiplication");
static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1), static_assert(__a0 * __b1 + __b0 * __a1 < (__c >> 1),
"overflow in multiplication"); "overflow in multiplication");
static_assert(__b0 * __a0 <= __INTMAX_MAX__, static_assert(__b0 * __a0 <= __INTMAX_MAX__,
"overflow in multiplication"); "overflow in multiplication");
static_assert((__a0 * __b1 + __b0 * __a1) * __c static_assert((__a0 * __b1 + __b0 * __a1) * __c
<= __INTMAX_MAX__ - __b0 * __a0, <= __INTMAX_MAX__ - __b0 * __a0,
@ -257,7 +257,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* std::ratio<7,-21>::num == -1; * std::ratio<7,-21>::num == -1;
* std::ratio<7,-21>::den == 3; * std::ratio<7,-21>::den == 3;
* @endcode * @endcode
* *
*/ */
template<intmax_t _Num, intmax_t _Den = 1> template<intmax_t _Num, intmax_t _Den = 1>
struct ratio struct ratio
@ -340,7 +340,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct ratio_equal struct ratio_equal
: integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den> : integral_constant<bool, _R1::num == _R2::num && _R1::den == _R2::den>
{ }; { };
/// ratio_not_equal /// ratio_not_equal
template<typename _R1, typename _R2> template<typename _R1, typename _R2>
struct ratio_not_equal struct ratio_not_equal
@ -354,7 +354,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct __ratio_less_impl_1 struct __ratio_less_impl_1
: integral_constant<bool, __big_less<_Left::__hi, _Left::__lo, : integral_constant<bool, __big_less<_Left::__hi, _Left::__lo,
_Right::__hi, _Right::__lo>::value> _Right::__hi, _Right::__lo>::value>
{ }; { };
template<typename _R1, typename _R2, template<typename _R1, typename _R2,
bool = (_R1::num == 0 || _R2::num == 0 bool = (_R1::num == 0 || _R2::num == 0
@ -382,13 +382,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct ratio_less struct ratio_less
: __ratio_less_impl<_R1, _R2>::type : __ratio_less_impl<_R1, _R2>::type
{ }; { };
/// ratio_less_equal /// ratio_less_equal
template<typename _R1, typename _R2> template<typename _R1, typename _R2>
struct ratio_less_equal struct ratio_less_equal
: integral_constant<bool, !ratio_less<_R2, _R1>::value> : integral_constant<bool, !ratio_less<_R2, _R1>::value>
{ }; { };
/// ratio_greater /// ratio_greater
template<typename _R1, typename _R2> template<typename _R1, typename _R2>
struct ratio_greater struct ratio_greater

52
libstdc++-v3/include/std/scoped_allocator
View File

@ -68,7 +68,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _OuterAlloc, typename... _InnerAllocs> template<typename _OuterAlloc, typename... _InnerAllocs>
class scoped_allocator_adaptor; class scoped_allocator_adaptor;
template<typename...> template<typename...>
struct __inner_type_impl; struct __inner_type_impl;
template<typename _Outer> template<typename _Outer>
@ -81,25 +81,25 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__inner_type_impl(__inner_type_impl&&) = default; __inner_type_impl(__inner_type_impl&&) = default;
__inner_type_impl& operator=(const __inner_type_impl&) = default; __inner_type_impl& operator=(const __inner_type_impl&) = default;
__inner_type_impl& operator=(__inner_type_impl&&) = default; __inner_type_impl& operator=(__inner_type_impl&&) = default;
template<typename _Alloc> template<typename _Alloc>
__inner_type_impl(const __inner_type_impl<_Alloc>& __other) __inner_type_impl(const __inner_type_impl<_Alloc>& __other)
{ } { }
template<typename _Alloc> template<typename _Alloc>
__inner_type_impl(__inner_type_impl<_Alloc>&& __other) __inner_type_impl(__inner_type_impl<_Alloc>&& __other)
{ } { }
__type& __type&
_M_get(__type* __p) noexcept { return *__p; } _M_get(__type* __p) noexcept { return *__p; }
const __type& const __type&
_M_get(const __type* __p) const noexcept { return *__p; } _M_get(const __type* __p) const noexcept { return *__p; }
tuple<> tuple<>
_M_tie() const noexcept { return tuple<>(); } _M_tie() const noexcept { return tuple<>(); }
bool bool
operator==(const __inner_type_impl&) const noexcept operator==(const __inner_type_impl&) const noexcept
{ return true; } { return true; }
}; };
@ -108,17 +108,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct __inner_type_impl<_Outer, _InnerHead, _InnerTail...> struct __inner_type_impl<_Outer, _InnerHead, _InnerTail...>
{ {
typedef scoped_allocator_adaptor<_InnerHead, _InnerTail...> __type; typedef scoped_allocator_adaptor<_InnerHead, _InnerTail...> __type;
__inner_type_impl() = default; __inner_type_impl() = default;
__inner_type_impl(const __inner_type_impl&) = default; __inner_type_impl(const __inner_type_impl&) = default;
__inner_type_impl(__inner_type_impl&&) = default; __inner_type_impl(__inner_type_impl&&) = default;
__inner_type_impl& operator=(const __inner_type_impl&) = default; __inner_type_impl& operator=(const __inner_type_impl&) = default;
__inner_type_impl& operator=(__inner_type_impl&&) = default; __inner_type_impl& operator=(__inner_type_impl&&) = default;
template<typename... _Allocs> template<typename... _Allocs>
__inner_type_impl(const __inner_type_impl<_Allocs...>& __other) __inner_type_impl(const __inner_type_impl<_Allocs...>& __other)
: _M_inner(__other._M_inner) { } : _M_inner(__other._M_inner) { }
template<typename... _Allocs> template<typename... _Allocs>
__inner_type_impl(__inner_type_impl<_Allocs...>&& __other) __inner_type_impl(__inner_type_impl<_Allocs...>&& __other)
: _M_inner(std::move(__other._M_inner)) { } : _M_inner(std::move(__other._M_inner)) { }
@ -128,24 +128,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__inner_type_impl(_Args&&... __args) __inner_type_impl(_Args&&... __args)
: _M_inner(std::forward<_Args>(__args)...) { } : _M_inner(std::forward<_Args>(__args)...) { }
__type& __type&
_M_get(void*) noexcept { return _M_inner; } _M_get(void*) noexcept { return _M_inner; }
const __type& const __type&
_M_get(const void*) const noexcept { return _M_inner; } _M_get(const void*) const noexcept { return _M_inner; }
tuple<const _InnerHead&, const _InnerTail&...> tuple<const _InnerHead&, const _InnerTail&...>
_M_tie() const noexcept _M_tie() const noexcept
{ return _M_inner._M_tie(); } { return _M_inner._M_tie(); }
bool bool
operator==(const __inner_type_impl& __other) const noexcept operator==(const __inner_type_impl& __other) const noexcept
{ return _M_inner == __other._M_inner; } { return _M_inner == __other._M_inner; }
private: private:
template<typename...> friend class __inner_type_impl; template<typename...> friend class __inner_type_impl;
template<typename, typename...> friend class scoped_allocator_adaptor; template<typename, typename...> friend class scoped_allocator_adaptor;
__type _M_inner; __type _M_inner;
}; };
@ -176,9 +176,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Alloc> template<typename _Alloc>
using __outermost_alloc_traits using __outermost_alloc_traits
= allocator_traits<__outermost_type<_Alloc>>; = allocator_traits<__outermost_type<_Alloc>>;
template<typename _Tp, typename... _Args> template<typename _Tp, typename... _Args>
void void
_M_construct(__uses_alloc0, _Tp* __p, _Args&&... __args) _M_construct(__uses_alloc0, _Tp* __p, _Args&&... __args)
{ {
typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits; typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits;
@ -190,7 +190,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef __uses_alloc2<typename __inner_type::__type> __uses_alloc2_; typedef __uses_alloc2<typename __inner_type::__type> __uses_alloc2_;
template<typename _Tp, typename... _Args> template<typename _Tp, typename... _Args>
void void
_M_construct(__uses_alloc1_, _Tp* __p, _Args&&... __args) _M_construct(__uses_alloc1_, _Tp* __p, _Args&&... __args)
{ {
typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits; typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits;
@ -200,7 +200,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} }
template<typename _Tp, typename... _Args> template<typename _Tp, typename... _Args>
void void
_M_construct(__uses_alloc2_, _Tp* __p, _Args&&... __args) _M_construct(__uses_alloc2_, _Tp* __p, _Args&&... __args)
{ {
typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits; typedef __outermost_alloc_traits<scoped_allocator_adaptor> _O_traits;

6
libstdc++-v3/include/std/sstream
View File

@ -209,7 +209,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
virtual streamsize virtual streamsize
showmanyc() showmanyc()
{ {
streamsize __ret = -1; streamsize __ret = -1;
if (_M_mode & ios_base::in) if (_M_mode & ios_base::in)
{ {
@ -248,10 +248,10 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
// that an external char_type array of length __n exists // that an external char_type array of length __n exists
// and has been pre-allocated. If this is not the case, // and has been pre-allocated. If this is not the case,
// things will quickly blow up. // things will quickly blow up.
// Step 1: Destroy the current internal array. // Step 1: Destroy the current internal array.
_M_string.clear(); _M_string.clear();
// Step 2: Use the external array. // Step 2: Use the external array.
_M_sync(__s, __n, 0); _M_sync(__s, __n, 0);
} }

26
libstdc++-v3/include/std/stdexcept
View File

@ -110,13 +110,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* program runs (e.g., violations of class invariants). * program runs (e.g., violations of class invariants).
* @brief One of two subclasses of exception. * @brief One of two subclasses of exception.
*/ */
class logic_error : public exception class logic_error : public exception
{ {
__cow_string _M_msg; __cow_string _M_msg;
public: public:
/** Takes a character string describing the error. */ /** Takes a character string describing the error. */
explicit explicit
logic_error(const string& __arg) _GLIBCXX_TXN_SAFE; logic_error(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
@ -133,7 +133,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/** Returns a C-style character string describing the general cause of /** Returns a C-style character string describing the general cause of
* the current error (the same string passed to the ctor). */ * 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; what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
# ifdef _GLIBCXX_TM_TS_INTERNAL # 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 /** Thrown by the library, or by you, to report domain errors (domain in
* the mathematical sense). */ * the mathematical sense). */
class domain_error : public logic_error class domain_error : public logic_error
{ {
public: public:
explicit domain_error(const string& __arg) _GLIBCXX_TXN_SAFE; explicit domain_error(const string& __arg) _GLIBCXX_TXN_SAFE;
@ -155,7 +155,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}; };
/** Thrown to report invalid arguments to functions. */ /** Thrown to report invalid arguments to functions. */
class invalid_argument : public logic_error class invalid_argument : public logic_error
{ {
public: public:
explicit invalid_argument(const string& __arg) _GLIBCXX_TXN_SAFE; 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 /** Thrown when an object is constructed that would exceed its maximum
* permitted size (e.g., a basic_string instance). */ * permitted size (e.g., a basic_string instance). */
class length_error : public logic_error class length_error : public logic_error
{ {
public: public:
explicit length_error(const string& __arg) _GLIBCXX_TXN_SAFE; 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 /** This represents an argument whose value is not within the expected
* range (e.g., boundary checks in basic_string). */ * range (e.g., boundary checks in basic_string). */
class out_of_range : public logic_error class out_of_range : public logic_error
{ {
public: public:
explicit out_of_range(const string& __arg) _GLIBCXX_TXN_SAFE; explicit out_of_range(const string& __arg) _GLIBCXX_TXN_SAFE;
@ -194,13 +194,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* the program executes. * the program executes.
* @brief One of two subclasses of exception. * @brief One of two subclasses of exception.
*/ */
class runtime_error : public exception class runtime_error : public exception
{ {
__cow_string _M_msg; __cow_string _M_msg;
public: public:
/** Takes a character string describing the error. */ /** Takes a character string describing the error. */
explicit explicit
runtime_error(const string& __arg) _GLIBCXX_TXN_SAFE; runtime_error(const string& __arg) _GLIBCXX_TXN_SAFE;
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
@ -217,7 +217,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/** Returns a C-style character string describing the general cause of /** Returns a C-style character string describing the general cause of
* the current error (the same string passed to the ctor). */ * 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; what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_USE_NOEXCEPT;
# ifdef _GLIBCXX_TM_TS_INTERNAL # ifdef _GLIBCXX_TM_TS_INTERNAL
@ -227,7 +227,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}; };
/** Thrown to indicate range errors in internal computations. */ /** Thrown to indicate range errors in internal computations. */
class range_error : public runtime_error class range_error : public runtime_error
{ {
public: public:
explicit range_error(const string& __arg) _GLIBCXX_TXN_SAFE; explicit range_error(const string& __arg) _GLIBCXX_TXN_SAFE;
@ -238,7 +238,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}; };
/** Thrown to indicate arithmetic overflow. */ /** Thrown to indicate arithmetic overflow. */
class overflow_error : public runtime_error class overflow_error : public runtime_error
{ {
public: public:
explicit overflow_error(const string& __arg) _GLIBCXX_TXN_SAFE; explicit overflow_error(const string& __arg) _GLIBCXX_TXN_SAFE;
@ -249,7 +249,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}; };
/** Thrown to indicate arithmetic underflow. */ /** Thrown to indicate arithmetic underflow. */
class underflow_error : public runtime_error class underflow_error : public runtime_error
{ {
public: public:
explicit underflow_error(const string& __arg) _GLIBCXX_TXN_SAFE; explicit underflow_error(const string& __arg) _GLIBCXX_TXN_SAFE;

6
libstdc++-v3/include/std/string
View File

@ -46,10 +46,10 @@
#include <bits/stl_iterator_base_funcs.h> #include <bits/stl_iterator_base_funcs.h>
#include <bits/stl_iterator.h> #include <bits/stl_iterator.h>
#include <bits/stl_function.h> // For less #include <bits/stl_function.h> // For less
#include <ext/numeric_traits.h> #include <ext/numeric_traits.h>
#include <bits/stl_algobase.h> #include <bits/stl_algobase.h>
#include <bits/range_access.h> #include <bits/range_access.h>
#include <bits/basic_string.h> #include <bits/basic_string.h>
#include <bits/basic_string.tcc> #include <bits/basic_string.tcc>
#endif /* _GLIBCXX_STRING */ #endif /* _GLIBCXX_STRING */

44
libstdc++-v3/include/std/system_error
View File

@ -56,7 +56,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp> template<typename _Tp>
struct is_error_condition_enum : public false_type { }; struct is_error_condition_enum : public false_type { };
template<> template<>
struct is_error_condition_enum<errc> struct is_error_condition_enum<errc>
: public true_type { }; : public true_type { };
@ -73,7 +73,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
error_category(const error_category&) = delete; error_category(const error_category&) = delete;
error_category& operator=(const error_category&) = delete; error_category& operator=(const error_category&) = delete;
virtual const char* virtual const char*
name() const noexcept = 0; name() const noexcept = 0;
// We need two different virtual functions here, one returning a // We need two different virtual functions here, one returning a
@ -91,7 +91,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
virtual string virtual string
message(int) const = 0; message(int) const = 0;
#else #else
virtual string virtual string
message(int) const = 0; message(int) const = 0;
private: private:
@ -103,21 +103,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
virtual error_condition virtual error_condition
default_error_condition(int __i) const noexcept; default_error_condition(int __i) const noexcept;
virtual bool virtual bool
equivalent(int __i, const error_condition& __cond) const noexcept; equivalent(int __i, const error_condition& __cond) const noexcept;
virtual bool virtual bool
equivalent(const error_code& __code, int __i) const noexcept; equivalent(const error_code& __code, int __i) const noexcept;
bool bool
operator<(const error_category& __other) const noexcept operator<(const error_category& __other) const noexcept
{ return less<const error_category*>()(this, &__other); } { return less<const error_category*>()(this, &__other); }
bool bool
operator==(const error_category& __other) const noexcept operator==(const error_category& __other) const noexcept
{ return this == &__other; } { return this == &__other; }
bool bool
operator!=(const error_category& __other) const noexcept operator!=(const error_category& __other) const noexcept
{ return this != &__other; } { return this != &__other; }
}; };
@ -148,14 +148,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
error_code(_ErrorCodeEnum __e) noexcept error_code(_ErrorCodeEnum __e) noexcept
{ *this = make_error_code(__e); } { *this = make_error_code(__e); }
void void
assign(int __v, const error_category& __cat) noexcept assign(int __v, const error_category& __cat) noexcept
{ {
_M_value = __v; _M_value = __v;
_M_cat = &__cat; _M_cat = &__cat;
} }
void void
clear() noexcept clear() noexcept
{ assign(0, system_category()); } { assign(0, system_category()); }
@ -168,15 +168,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
int int
value() const noexcept { return _M_value; } value() const noexcept { return _M_value; }
const error_category& const error_category&
category() const noexcept { return *_M_cat; } category() const noexcept { return *_M_cat; }
error_condition error_condition
default_error_condition() const noexcept; default_error_condition() const noexcept;
_GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_DEFAULT_ABI_TAG
string string
message() const message() const
{ return category().message(value()); } { return category().message(value()); }
@ -198,7 +198,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
inline bool inline bool
operator<(const error_code& __lhs, const error_code& __rhs) noexcept operator<(const error_code& __lhs, const error_code& __rhs) noexcept
{ {
return (__lhs.category() < __rhs.category() return (__lhs.category() < __rhs.category()
|| (__lhs.category() == __rhs.category() || (__lhs.category() == __rhs.category()
&& __lhs.value() < __rhs.value())); && __lhs.value() < __rhs.value()));
@ -213,7 +213,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// error_condition /// error_condition
// Portable error identification // Portable error identification
struct error_condition struct error_condition
{ {
error_condition() noexcept error_condition() noexcept
: _M_value(0), _M_cat(&generic_category()) { } : _M_value(0), _M_cat(&generic_category()) { }
@ -240,7 +240,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
operator=(_ErrorConditionEnum __e) noexcept operator=(_ErrorConditionEnum __e) noexcept
{ return *this = make_error_condition(__e); } { return *this = make_error_condition(__e); }
void void
clear() noexcept clear() noexcept
{ assign(0, generic_category()); } { assign(0, generic_category()); }
@ -252,7 +252,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
category() const noexcept { return *_M_cat; } category() const noexcept { return *_M_cat; }
_GLIBCXX_DEFAULT_ABI_TAG _GLIBCXX_DEFAULT_ABI_TAG
string string
message() const message() const
{ return category().message(value()); } { return category().message(value()); }
@ -270,7 +270,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
make_error_condition(errc __e) noexcept make_error_condition(errc __e) noexcept
{ return error_condition(static_cast<int>(__e), generic_category()); } { return error_condition(static_cast<int>(__e), generic_category()); }
inline bool inline bool
operator<(const error_condition& __lhs, operator<(const error_condition& __lhs,
const error_condition& __rhs) noexcept const error_condition& __rhs) noexcept
{ {
@ -325,7 +325,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ return !(__lhs == __rhs); } { return !(__lhs == __rhs); }
/** /**
* @brief Thrown to indicate error code of underlying system. * @brief Thrown to indicate error code of underlying system.
* *
* @ingroup exceptions * @ingroup exceptions
@ -358,7 +358,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
virtual ~system_error() noexcept; virtual ~system_error() noexcept;
const error_code& const error_code&
code() const noexcept { return _M_code; } code() const noexcept { return _M_code; }
}; };

2
libstdc++-v3/include/std/thread
View File

@ -112,7 +112,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ swap(__t); } { swap(__t); }
template<typename _Callable, typename... _Args> template<typename _Callable, typename... _Args>
explicit explicit
thread(_Callable&& __f, _Args&&... __args) thread(_Callable&& __f, _Args&&... __args)
{ {
#ifdef GTHR_ACTIVE_PROXY #ifdef GTHR_ACTIVE_PROXY

24
libstdc++-v3/include/std/tuple
View File

@ -173,7 +173,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* get() operation. * get() operation.
*/ */
template<std::size_t _Idx, typename... _Elements> template<std::size_t _Idx, typename... _Elements>
struct _Tuple_impl; struct _Tuple_impl;
/** /**
* Recursive tuple implementation. Here we store the @c Head element * 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 _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
typedef _Head_base<_Idx, _Head> _Base; typedef _Head_base<_Idx, _Head> _Base;
static constexpr _Head& static constexpr _Head&
_M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); }
static constexpr const _Head& static constexpr const _Head&
@ -205,12 +205,12 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr _Tuple_impl() constexpr _Tuple_impl()
: _Inherited(), _Base() { } : _Inherited(), _Base() { }
explicit explicit
constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail) constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
: _Inherited(__tail...), _Base(__head) { } : _Inherited(__tail...), _Base(__head) { }
template<typename _UHead, typename... _UTail, typename = typename template<typename _UHead, typename... _UTail, typename = typename
enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type> enable_if<sizeof...(_Tail) == sizeof...(_UTail)>::type>
explicit explicit
constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail) constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
: _Inherited(std::forward<_UTail>(__tail)...), : _Inherited(std::forward<_UTail>(__tail)...),
@ -222,7 +222,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Tuple_impl(_Tuple_impl&& __in) _Tuple_impl(_Tuple_impl&& __in)
noexcept(__and_<is_nothrow_move_constructible<_Head>, noexcept(__and_<is_nothrow_move_constructible<_Head>,
is_nothrow_move_constructible<_Inherited>>::value) 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))) { } _Base(std::forward<_Head>(_M_head(__in))) { }
template<typename... _UElements> template<typename... _UElements>
@ -260,13 +260,13 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Alloc> template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
const _Tuple_impl& __in) 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)) { } _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) { }
template<typename _Alloc> template<typename _Alloc>
_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
_Tuple_impl&& __in) _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), _Base(__use_alloc<_Head, _Alloc, _Head>(__a),
std::forward<_Head>(_M_head(__in))) { } std::forward<_Head>(_M_head(__in))) { }
@ -551,7 +551,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
}; };
/// Primary class template, tuple /// Primary class template, tuple
template<typename... _Elements> template<typename... _Elements>
class tuple : public _Tuple_impl<0, _Elements...> class tuple : public _Tuple_impl<0, _Elements...>
{ {
typedef _Tuple_impl<0, _Elements...> _Inherited; typedef _Tuple_impl<0, _Elements...> _Inherited;
@ -658,7 +658,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr tuple(const tuple&) = default; constexpr tuple(const tuple&) = default;
constexpr tuple(tuple&&) = default; constexpr tuple(tuple&&) = default;
// Shortcut for the cases where constructors taking tuples // Shortcut for the cases where constructors taking tuples
// must avoid creating temporaries. // must avoid creating temporaries.
@ -1339,7 +1339,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
return bool(std::get<__i>(__t) == std::get<__i>(__u)) return bool(std::get<__i>(__t) == std::get<__i>(__u))
&& __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u);
} }
static constexpr bool static constexpr bool
__less(const _Tp& __t, const _Up& __u) __less(const _Tp& __t, const _Up& __u)
{ {
@ -1354,7 +1354,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ {
static constexpr bool static constexpr bool
__eq(const _Tp&, const _Up&) { return true; } __eq(const _Tp&, const _Up&) { return true; }
static constexpr bool static constexpr bool
__less(const _Tp&, const _Up&) { return false; } __less(const _Tp&, const _Up&) { return false; }
}; };
@ -1569,7 +1569,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// swap /// swap
template<typename... _Elements> template<typename... _Elements>
inline void inline void
swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y)
noexcept(noexcept(__x.swap(__y))) noexcept(noexcept(__x.swap(__y)))
{ __x.swap(__y); } { __x.swap(__y); }

92
libstdc++-v3/include/std/type_traits
View File

@ -79,7 +79,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
constexpr value_type operator()() const { return value; } constexpr value_type operator()() const { return value; }
#endif #endif
}; };
template<typename _Tp, _Tp __v> template<typename _Tp, _Tp __v>
constexpr _Tp integral_constant<_Tp, __v>::value; constexpr _Tp integral_constant<_Tp, __v>::value;
@ -212,7 +212,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<> template<>
struct __is_integral_helper<bool> struct __is_integral_helper<bool>
: public true_type { }; : public true_type { };
template<> template<>
struct __is_integral_helper<char> struct __is_integral_helper<char>
: public true_type { }; : public true_type { };
@ -648,7 +648,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp> template<typename _Tp>
struct is_const<_Tp const> struct is_const<_Tp const>
: public true_type { }; : public true_type { };
/// is_volatile /// is_volatile
template<typename> template<typename>
struct is_volatile struct is_volatile
@ -766,7 +766,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct __is_array_unknown_bounds struct __is_array_unknown_bounds
: public __and_<is_array<_Tp>, __not_<extent<_Tp>>> : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
{ }; { };
// In N3290 is_destructible does not say anything about function // In N3290 is_destructible does not say anything about function
// types and abstract types, see LWG 2049. This implementation // types and abstract types, see LWG 2049. This implementation
// describes function types as non-destructible and all complete // describes function types as non-destructible and all complete
@ -889,9 +889,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct __is_default_constructible_safe; struct __is_default_constructible_safe;
// The following technique is a workaround for a current core language // 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- // 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. // arrays with unknown bounds are not.
template<typename _Tp> template<typename _Tp>
struct __is_default_constructible_safe<_Tp, true> struct __is_default_constructible_safe<_Tp, true>
@ -919,7 +919,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// This implementation uses different strategies depending on the // This implementation uses different strategies depending on the
// target type to reduce the test overhead as much as possible: // 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. // modulo its extra cases.
// //
// b) For a non-reference target type we use a ::new expression. // b) For a non-reference target type we use a ::new expression.
@ -990,7 +990,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
struct remove_reference; struct remove_reference;
template<typename _From, typename _To, bool template<typename _From, typename _To, bool
= __not_<__or_<is_void<_From>, = __not_<__or_<is_void<_From>,
is_function<_From>>>::value> is_function<_From>>>::value>
struct __is_base_to_derived_ref; struct __is_base_to_derived_ref;
@ -1027,7 +1027,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_From>::type>::type __src_t; _From>::type>::type __src_t;
typedef typename remove_cv<typename remove_reference< typedef typename remove_cv<typename remove_reference<
_To>::type>::type __dst_t; _To>::type>::type __dst_t;
typedef __and_<__not_<is_function<__src_t>>, typedef __and_<__not_<is_function<__src_t>>,
__or_<is_same<__src_t, __dst_t>, __or_<is_same<__src_t, __dst_t>,
is_base_of<__dst_t, __src_t>>> type; is_base_of<__dst_t, __src_t>>> type;
static constexpr bool value = type::value; static constexpr bool value = type::value;
@ -1038,11 +1038,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: public false_type : 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. // equivalent to a static_cast modulo overshooting conversions.
// These are restricted to the following conversions: // These are restricted to the following conversions:
// a) A base class value to a derived class reference // 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 // types that are not functions
template<typename _Tp, typename _Arg> template<typename _Tp, typename _Arg>
struct __is_direct_constructible_ref_cast struct __is_direct_constructible_ref_cast
@ -1350,7 +1350,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: public __and_<is_constructible<_Tp, _Args...>, integral_constant<bool, : public __and_<is_constructible<_Tp, _Args...>, integral_constant<bool,
__is_trivially_constructible(_Tp, _Args...)>> __is_trivially_constructible(_Tp, _Args...)>>
{ }; { };
/// is_trivially_default_constructible /// is_trivially_default_constructible
template<typename _Tp> template<typename _Tp>
struct is_trivially_default_constructible struct is_trivially_default_constructible
@ -1390,15 +1390,15 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// is_trivially_copy_constructible /// is_trivially_copy_constructible
template<typename _Tp> template<typename _Tp>
struct is_trivially_copy_constructible struct is_trivially_copy_constructible
: public __and_<is_copy_constructible<_Tp>, : public __and_<is_copy_constructible<_Tp>,
integral_constant<bool, integral_constant<bool,
__is_trivially_constructible(_Tp, const _Tp&)>> __is_trivially_constructible(_Tp, const _Tp&)>>
{ }; { };
/// is_trivially_move_constructible /// is_trivially_move_constructible
template<typename _Tp> template<typename _Tp>
struct is_trivially_move_constructible struct is_trivially_move_constructible
: public __and_<is_move_constructible<_Tp>, : public __and_<is_move_constructible<_Tp>,
integral_constant<bool, integral_constant<bool,
__is_trivially_constructible(_Tp, _Tp&&)>> __is_trivially_constructible(_Tp, _Tp&&)>>
{ }; { };
@ -1406,7 +1406,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// is_trivially_assignable /// is_trivially_assignable
template<typename _Tp, typename _Up> template<typename _Tp, typename _Up>
struct is_trivially_assignable struct is_trivially_assignable
: public __and_<is_assignable<_Tp, _Up>, : public __and_<is_assignable<_Tp, _Up>,
integral_constant<bool, integral_constant<bool,
__is_trivially_assignable(_Tp, _Up)>> __is_trivially_assignable(_Tp, _Up)>>
{ }; { };
@ -1414,7 +1414,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// is_trivially_copy_assignable /// is_trivially_copy_assignable
template<typename _Tp> template<typename _Tp>
struct is_trivially_copy_assignable struct is_trivially_copy_assignable
: public __and_<is_copy_assignable<_Tp>, : public __and_<is_copy_assignable<_Tp>,
integral_constant<bool, integral_constant<bool,
__is_trivially_assignable(_Tp&, const _Tp&)>> __is_trivially_assignable(_Tp&, const _Tp&)>>
{ }; { };
@ -1422,7 +1422,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
/// is_trivially_move_assignable /// is_trivially_move_assignable
template<typename _Tp> template<typename _Tp>
struct is_trivially_move_assignable struct is_trivially_move_assignable
: public __and_<is_move_assignable<_Tp>, : public __and_<is_move_assignable<_Tp>,
integral_constant<bool, integral_constant<bool,
__is_trivially_assignable(_Tp&, _Tp&&)>> __is_trivially_assignable(_Tp&, _Tp&&)>>
{ }; { };
@ -1458,19 +1458,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
: public integral_constant<bool, __has_virtual_destructor(_Tp)> : public integral_constant<bool, __has_virtual_destructor(_Tp)>
{ }; { };
// type property queries. // type property queries.
/// alignment_of /// alignment_of
template<typename _Tp> template<typename _Tp>
struct alignment_of struct alignment_of
: public integral_constant<std::size_t, __alignof__(_Tp)> { }; : public integral_constant<std::size_t, __alignof__(_Tp)> { };
/// rank /// rank
template<typename> template<typename>
struct rank struct rank
: public integral_constant<std::size_t, 0> { }; : public integral_constant<std::size_t, 0> { };
template<typename _Tp, std::size_t _Size> template<typename _Tp, std::size_t _Size>
struct rank<_Tp[_Size]> struct rank<_Tp[_Size]>
: public integral_constant<std::size_t, 1 + rank<_Tp>::value> { }; : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
@ -1483,7 +1483,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename, unsigned _Uint> template<typename, unsigned _Uint>
struct extent struct extent
: public integral_constant<std::size_t, 0> { }; : public integral_constant<std::size_t, 0> { };
template<typename _Tp, unsigned _Uint, std::size_t _Size> template<typename _Tp, unsigned _Uint, std::size_t _Size>
struct extent<_Tp[_Size], _Uint> struct extent<_Tp[_Size], _Uint>
: public integral_constant<std::size_t, : public integral_constant<std::size_t,
@ -1559,7 +1559,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp> template<typename _Tp>
struct remove_const<_Tp const> struct remove_const<_Tp const>
{ typedef _Tp type; }; { typedef _Tp type; };
/// remove_volatile /// remove_volatile
template<typename _Tp> template<typename _Tp>
struct remove_volatile struct remove_volatile
@ -1568,7 +1568,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp> template<typename _Tp>
struct remove_volatile<_Tp volatile> struct remove_volatile<_Tp volatile>
{ typedef _Tp type; }; { typedef _Tp type; };
/// remove_cv /// remove_cv
template<typename _Tp> template<typename _Tp>
struct remove_cv struct remove_cv
@ -1576,17 +1576,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef typename typedef typename
remove_const<typename remove_volatile<_Tp>::type>::type type; remove_const<typename remove_volatile<_Tp>::type>::type type;
}; };
/// add_const /// add_const
template<typename _Tp> template<typename _Tp>
struct add_const struct add_const
{ typedef _Tp const type; }; { typedef _Tp const type; };
/// add_volatile /// add_volatile
template<typename _Tp> template<typename _Tp>
struct add_volatile struct add_volatile
{ typedef _Tp volatile type; }; { typedef _Tp volatile type; };
/// add_cv /// add_cv
template<typename _Tp> template<typename _Tp>
struct add_cv struct add_cv
@ -1711,7 +1711,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match; typedef __cv_selector<_Unqualified, _IsConst, _IsVol> __match;
public: public:
typedef typename __match::__type __type; typedef typename __match::__type __type;
}; };
// Utility for finding the unsigned versions of signed integral types. // Utility for finding the unsigned versions of signed integral types.
@ -1771,7 +1771,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif #endif
// Select between integral and enum: not possible to be both. // Select between integral and enum: not possible to be both.
template<typename _Tp, template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value, bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value> bool _IsEnum = is_enum<_Tp>::value>
class __make_unsigned_selector; class __make_unsigned_selector;
@ -1816,7 +1816,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Primary template. // Primary template.
/// make_unsigned /// make_unsigned
template<typename _Tp> template<typename _Tp>
struct make_unsigned struct make_unsigned
{ typedef typename __make_unsigned_selector<_Tp>::__type type; }; { typedef typename __make_unsigned_selector<_Tp>::__type type; };
// Integral, but don't define. // Integral, but don't define.
@ -1890,7 +1890,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif #endif
// Select between integral and enum: not possible to be both. // Select between integral and enum: not possible to be both.
template<typename _Tp, template<typename _Tp,
bool _IsInt = is_integral<_Tp>::value, bool _IsInt = is_integral<_Tp>::value,
bool _IsEnum = is_enum<_Tp>::value> bool _IsEnum = is_enum<_Tp>::value>
class __make_signed_selector; class __make_signed_selector;
@ -1920,7 +1920,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Primary template. // Primary template.
/// make_signed /// make_signed
template<typename _Tp> template<typename _Tp>
struct make_signed struct make_signed
{ typedef typename __make_signed_selector<_Tp>::__type type; }; { typedef typename __make_signed_selector<_Tp>::__type type; };
// Integral, but don't define. // Integral, but don't define.
@ -2002,7 +2002,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
{ typedef typename remove_reference<_Tp>::type* type; }; { typedef typename remove_reference<_Tp>::type* type; };
template<typename _Tp> template<typename _Tp>
struct add_pointer struct add_pointer
: public __add_pointer_helper<_Tp> : public __add_pointer_helper<_Tp>
{ }; { };
@ -2018,11 +2018,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<std::size_t _Len> template<std::size_t _Len>
struct __aligned_storage_msa struct __aligned_storage_msa
{ {
union __type union __type
{ {
unsigned char __data[_Len]; unsigned char __data[_Len];
struct __attribute__((__aligned__)) { } __align; struct __attribute__((__aligned__)) { } __align;
}; };
}; };
@ -2039,11 +2039,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<std::size_t _Len, std::size_t _Align = template<std::size_t _Len, std::size_t _Align =
__alignof__(typename __aligned_storage_msa<_Len>::__type)> __alignof__(typename __aligned_storage_msa<_Len>::__type)>
struct aligned_storage struct aligned_storage
{ {
union type union type
{ {
unsigned char __data[_Len]; 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 // Decay trait for arrays and functions, used for perfect forwarding
// in make_pair, make_tuple, etc. // in make_pair, make_tuple, etc.
template<typename _Up, template<typename _Up,
bool _IsArray = is_array<_Up>::value, bool _IsArray = is_array<_Up>::value,
bool _IsFunction = is_function<_Up>::value> bool _IsFunction = is_function<_Up>::value>
struct __decay_selector; struct __decay_selector;
// NB: DR 705. // NB: DR 705.
template<typename _Up> template<typename _Up>
struct __decay_selector<_Up, false, false> struct __decay_selector<_Up, false, false>
{ typedef typename remove_cv<_Up>::type __type; }; { typedef typename remove_cv<_Up>::type __type; };
template<typename _Up> template<typename _Up>
struct __decay_selector<_Up, true, false> struct __decay_selector<_Up, true, false>
{ typedef typename remove_extent<_Up>::type* __type; }; { typedef typename remove_extent<_Up>::type* __type; };
template<typename _Up> template<typename _Up>
struct __decay_selector<_Up, false, true> struct __decay_selector<_Up, false, true>
{ typedef typename add_pointer<_Up>::type __type; }; { typedef typename add_pointer<_Up>::type __type; };
/// decay /// decay
template<typename _Tp> template<typename _Tp>
class decay class decay
{ {
typedef typename remove_reference<_Tp>::type __remove_type; typedef typename remove_reference<_Tp>::type __remove_type;
public: public:
@ -2151,7 +2151,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// Primary template. // Primary template.
/// Define a member typedef @c type only if a boolean constant is true. /// Define a member typedef @c type only if a boolean constant is true.
template<bool, typename _Tp = void> template<bool, typename _Tp = void>
struct enable_if struct enable_if
{ }; { };
// Partial specialization for true. // Partial specialization for true.

4
libstdc++-v3/include/std/utility
View File

@ -49,7 +49,7 @@
*/ */
/** @file include/utility /** @file include/utility
* This is a Standard C++ Library header. * This is a Standard C++ Library header.
*/ */
#ifndef _GLIBCXX_UTILITY #ifndef _GLIBCXX_UTILITY
@ -150,7 +150,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<class _Tp1, class _Tp2> template<class _Tp1, class _Tp2>
struct tuple_element<0, std::pair<_Tp1, _Tp2>> struct tuple_element<0, std::pair<_Tp1, _Tp2>>
{ typedef _Tp1 type; }; { typedef _Tp1 type; };
/// Partial specialization for std::pair /// Partial specialization for std::pair
template<class _Tp1, class _Tp2> template<class _Tp1, class _Tp2>
struct tuple_element<1, std::pair<_Tp1, _Tp2>> struct tuple_element<1, std::pair<_Tp1, _Tp2>>

66
libstdc++-v3/include/std/valarray
View File

@ -23,7 +23,7 @@
// <http://www.gnu.org/licenses/>. // <http://www.gnu.org/licenses/>.
/** @file include/valarray /** @file include/valarray
* This is a Standard C++ Library header. * This is a Standard C++ Library header.
*/ */
// Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr> // Written by Gabriel Dos Reis <Gabriel.Dos-Reis@DPTMaths.ENS-Cachan.Fr>
@ -45,11 +45,11 @@ namespace std _GLIBCXX_VISIBILITY(default)
{ {
_GLIBCXX_BEGIN_NAMESPACE_VERSION _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<class _Clos, typename _Tp> template<class _Clos, typename _Tp>
class _Expr; class _Expr;
template<typename _Tp1, typename _Tp2> template<typename _Tp1, typename _Tp2>
class _ValArray; class _ValArray;
template<class _Oper, template<class, class> class _Meta, class _Dom> template<class _Oper, template<class, class> class _Meta, class _Dom>
struct _UnClos; struct _UnClos;
@ -57,22 +57,22 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<class _Oper, template<class _Oper,
template<class, class> class _Meta1, template<class, class> class _Meta1,
template<class, class> class _Meta2, template<class, class> class _Meta2,
class _Dom1, class _Dom2> class _Dom1, class _Dom2>
class _BinClos; class _BinClos;
template<template<class, class> class _Meta, class _Dom> template<template<class, class> class _Meta, class _Dom>
class _SClos; class _SClos;
template<template<class, class> class _Meta, class _Dom> template<template<class, class> class _Meta, class _Dom>
class _GClos; class _GClos;
template<template<class, class> class _Meta, class _Dom> template<template<class, class> class _Meta, class _Dom>
class _IClos; class _IClos;
template<template<class, class> class _Meta, class _Dom> template<template<class, class> class _Meta, class _Dom>
class _ValFunClos; class _ValFunClos;
template<template<class, class> class _Meta, class _Dom> template<template<class, class> class _Meta, class _Dom>
class _RefFunClos; class _RefFunClos;
template<class _Tp> class valarray; // An array of type _Tp template<class _Tp> class valarray; // An array of type _Tp
@ -88,7 +88,7 @@ _GLIBCXX_END_NAMESPACE_VERSION
#include <bits/valarray_array.h> #include <bits/valarray_array.h>
#include <bits/valarray_before.h> #include <bits/valarray_before.h>
namespace std _GLIBCXX_VISIBILITY(default) namespace std _GLIBCXX_VISIBILITY(default)
{ {
_GLIBCXX_BEGIN_NAMESPACE_VERSION _GLIBCXX_BEGIN_NAMESPACE_VERSION
@ -109,21 +109,21 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
* aliasing that can result from pointer representations. It represents a * aliasing that can result from pointer representations. It represents a
* one-dimensional array from which different multidimensional subsets can * one-dimensional array from which different multidimensional subsets can
* be accessed and modified. * be accessed and modified.
* *
* @tparam _Tp Type of object in the array. * @tparam _Tp Type of object in the array.
*/ */
template<class _Tp> template<class _Tp>
class valarray class valarray
{ {
template<class _Op> template<class _Op>
struct _UnaryOp struct _UnaryOp
{ {
typedef typename __fun<_Op, _Tp>::result_type __rt; typedef typename __fun<_Op, _Tp>::result_type __rt;
typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt; typedef _Expr<_UnClos<_Op, _ValArray, _Tp>, __rt> _Rt;
}; };
public: public:
typedef _Tp value_type; typedef _Tp value_type;
// _lib.valarray.cons_ construct/destroy: // _lib.valarray.cons_ construct/destroy:
/// Construct an empty array. /// Construct an empty array.
valarray(); valarray();
@ -254,7 +254,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
// _lib.valarray.access_ element access: // _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. * @param __i Index of element to return.
* @return Reference to the i'th element. * @return Reference to the i'th element.
@ -482,10 +482,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
_Tp sum() const; _Tp sum() const;
/// Return the minimum element using operator<(). /// Return the minimum element using operator<().
_Tp min() const; _Tp min() const;
/// Return the maximum element using operator<(). /// Return the maximum element using operator<().
_Tp max() const; _Tp max() const;
/** /**
* @brief Return a shifted array. * @brief Return a shifted array.
@ -559,14 +559,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
private: private:
size_t _M_size; size_t _M_size;
_Tp* __restrict__ _M_data; _Tp* __restrict__ _M_data;
friend class _Array<_Tp>; friend class _Array<_Tp>;
}; };
template<typename _Tp> template<typename _Tp>
inline const _Tp& inline const _Tp&
valarray<_Tp>::operator[](size_t __i) const valarray<_Tp>::operator[](size_t __i) const
{ {
__glibcxx_requires_subscript(__i); __glibcxx_requires_subscript(__i);
return _M_data[__i]; return _M_data[__i];
} }
@ -574,7 +574,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp> template<typename _Tp>
inline _Tp& inline _Tp&
valarray<_Tp>::operator[](size_t __i) valarray<_Tp>::operator[](size_t __i)
{ {
__glibcxx_requires_subscript(__i); __glibcxx_requires_subscript(__i);
return _M_data[__i]; return _M_data[__i];
} }
@ -605,8 +605,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {} valarray<_Tp>::valarray() : _M_size(0), _M_data(0) {}
template<typename _Tp> template<typename _Tp>
inline inline
valarray<_Tp>::valarray(size_t __n) valarray<_Tp>::valarray(size_t __n)
: _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
{ std::__valarray_default_construct(_M_data, _M_data + __n); } { std::__valarray_default_construct(_M_data, _M_data + __n); }
@ -620,9 +620,9 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
inline inline
valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n) valarray<_Tp>::valarray(const _Tp* __restrict__ __p, size_t __n)
: _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n)) : _M_size(__n), _M_data(__valarray_get_storage<_Tp>(__n))
{ {
__glibcxx_assert(__p != 0 || __n == 0); __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<typename _Tp> template<typename _Tp>
@ -917,7 +917,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
#endif #endif
template<class _Tp> template<class _Tp>
inline size_t inline size_t
valarray<_Tp>::size() const valarray<_Tp>::size() const
{ return _M_size; } { return _M_size; }
@ -1027,7 +1027,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
} }
std::__valarray_fill_construct(_M_data, _M_data + __n, __c); std::__valarray_fill_construct(_M_data, _M_data + __n, __c);
} }
template<typename _Tp> template<typename _Tp>
inline _Tp inline _Tp
valarray<_Tp>::min() const valarray<_Tp>::min() const
@ -1043,7 +1043,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
__glibcxx_assert(_M_size > 0); __glibcxx_assert(_M_size > 0);
return *std::max_element(_M_data, _M_data + _M_size); return *std::max_element(_M_data, _M_data + _M_size);
} }
template<class _Tp> template<class _Tp>
inline _Expr<_ValFunClos<_ValArray, _Tp>, _Tp> inline _Expr<_ValFunClos<_ValArray, _Tp>, _Tp>
valarray<_Tp>::apply(_Tp func(_Tp)) const 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) _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, __shift_right)
#undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT #undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT
#define _DEFINE_BINARY_OPERATOR(_Op, _Name) \ #define _DEFINE_BINARY_OPERATOR(_Op, _Name) \
template<typename _Tp> \ template<typename _Tp> \

2
libstdc++-v3/include/std/vector
View File

@ -62,7 +62,7 @@
#include <bits/stl_construct.h> #include <bits/stl_construct.h>
#include <bits/stl_uninitialized.h> #include <bits/stl_uninitialized.h>
#include <bits/stl_vector.h> #include <bits/stl_vector.h>
#include <bits/stl_bvector.h> #include <bits/stl_bvector.h>
#include <bits/range_access.h> #include <bits/range_access.h>
#ifndef _GLIBCXX_EXPORT_TEMPLATE #ifndef _GLIBCXX_EXPORT_TEMPLATE