+2017-07-23 François Dumont <fdumont@gcc.gnu.org>
+
+ PR libstdc++/81064
+ * include/bits/algorithmfwd.h: Reorganize versioned namespace.
+ * include/bits/basic_string.h: Likewise.
+ * include/bits/c++config: Likewise.
+ * include/bits/deque.tcc: Likewise.
+ * include/bits/forward_list.h: Likewise.
+ * include/bits/forward_list.tcc: Likewise.
+ * include/bits/hashtable_policy.h: Likewise.
+ * include/bits/list.tcc: Likewise.
+ * include/bits/move.h: Likewise.
+ * include/bits/quoted_string.h: Likewise.
+ * include/bits/random.h: Likewise.
+ * include/bits/random.tcc: Likewise.
+ * include/bits/regex.h: Likewise.
+ * include/bits/regex.tcc: Likewise.
+ * include/bits/regex_automaton.h: Likewise.
+ * include/bits/regex_automaton.tcc: Likewise.
+ * include/bits/regex_compiler.h: Likewise.
+ * include/bits/regex_compiler.tcc: Likewise.
+ * include/bits/regex_constants.h: Likewise.
+ * include/bits/regex_error.h: Likewise.
+ * include/bits/regex_executor.h: Likewise.
+ * include/bits/regex_executor.tcc: Likewise.
+ * include/bits/regex_scanner.h: Likewise.
+ * include/bits/regex_scanner.tcc: Likewise.
+ * include/bits/specfun.h: Likewise.
+ * include/bits/stl_algo.h: Likewise.
+ * include/bits/stl_algobase.h: Likewise.
+ * include/bits/stl_bvector.h: Likewise.
+ * include/bits/stl_deque.h: Likewise.
+ * include/bits/stl_iterator.h: Likewise.
+ * include/bits/stl_iterator_base_funcs.h: Likewise.
+ * include/bits/stl_list.h: Likewise.
+ * include/bits/stl_map.h: Likewise.
+ * include/bits/stl_multimap.h: Likewise.
+ * include/bits/stl_multiset.h: Likewise.
+ * include/bits/stl_relops.h: Likewise.
+ * include/bits/stl_set.h: Likewise.
+ * include/bits/stl_vector.h: Likewise.
+ * include/bits/uniform_int_dist.h: Likewise.
+ * include/bits/unordered_map.h: Likewise.
+ * include/bits/unordered_set.h: Likewise.
+ * include/bits/vector.tcc: Likewise.
+ * include/c_global/cmath: Likewise.
+ * include/c_std/cmath: Likewise.
+ * include/decimal/decimal: Likewise.
+ * include/decimal/decimal.h: Likewise.
+ * include/experimental/algorithm: Likewise.
+ * include/experimental/any: Likewise.
+ * include/experimental/array: Likewise.
+ * include/experimental/bits/erase_if.h: Likewise.
+ * include/experimental/bits/fs_dir.h: Likewise.
+ * include/experimental/bits/fs_fwd.h: Likewise.
+ * include/experimental/bits/fs_ops.h: Likewise.
+ * include/experimental/bits/fs_path.h: Likewise.
+ * include/experimental/bits/lfts_config.h: Likewise.
+ * include/experimental/bits/shared_ptr.h: Likewise.
+ * include/experimental/bits/string_view.tcc: Likewise.
+ * include/experimental/chrono: Likewise.
+ * include/experimental/deque: Likewise.
+ * include/experimental/filesystem: Likewise.
+ * include/experimental/forward_list: Likewise.
+ * include/experimental/functional: Likewise.
+ * include/experimental/iterator: Likewise.
+ * include/experimental/list: Likewise.
+ * include/experimental/map: Likewise.
+ * include/experimental/memory: Likewise.
+ * include/experimental/memory_resource: Likewise.
+ * include/experimental/numeric: Likewise.
+ * include/experimental/optional: Likewise.
+ * include/experimental/propagate_const: Likewise.
+ * include/experimental/random: Likewise.
+ * include/experimental/ratio: Likewise.
+ * include/experimental/regex: Likewise.
+ * include/experimental/set: Likewise.
+ * include/experimental/source_location: Likewise.
+ * include/experimental/string: Likewise.
+ * include/experimental/string_view: Likewise.
+ * include/experimental/system_error: Likewise.
+ * include/experimental/tuple: Likewise.
+ * include/experimental/type_traits: Likewise.
+ * include/experimental/unordered_map: Likewise.
+ * include/experimental/unordered_set: Likewise.
+ * include/experimental/utility: Likewise.
+ * include/experimental/vector: Likewise.
+ * include/ext/bitmap_allocator.h: Likewise.
+ * include/ext/codecvt_specializations.h: Likewise.
+ * include/ext/rope: Likewise.
+ * include/ext/typelist.h: Likewise.
+ * include/std/chrono: Likewise.
+ * include/std/complex: Likewise.
+ * include/std/functional: Likewise.
+ * include/std/numeric: Likewise.
+ * include/std/string_view: Likewise.
+ * include/std/thread: Likewise.
+ * include/std/variant: Likewise.
+ * include/tr1/array: Likewise.
+ * include/tr1/bessel_function.tcc: Likewise.
+ * include/tr1/beta_function.tcc: Likewise.
+ * include/tr1/cmath: Likewise.
+ * include/tr1/complex: Likewise.
+ * include/tr1/ell_integral.tcc: Likewise.
+ * include/tr1/exp_integral.tcc: Likewise.
+ * include/tr1/functional: Likewise.
+ * include/tr1/functional_hash.h: Likewise.
+ * include/tr1/gamma.tcc: Likewise.
+ * include/tr1/hashtable.h: Likewise.
+ * include/tr1/hashtable_policy.h: Likewise.
+ * include/tr1/hypergeometric.tcc: Likewise.
+ * include/tr1/legendre_function.tcc: Likewise.
+ * include/tr1/modified_bessel_func.tcc: Likewise.
+ * include/tr1/poly_hermite.tcc: Likewise.
+ * include/tr1/poly_laguerre.tcc: Likewise.
+ * include/tr1/random.h: Likewise.
+ * include/tr1/random.tcc: Likewise.
+ * include/tr1/regex: Likewise.
+ * include/tr1/riemann_zeta.tcc: Likewise.
+ * include/tr1/shared_ptr.h: Likewise.
+ * include/tr1/special_function_util.h: Likewise.
+ * include/tr1/tuple: Likewise.
+ * include/tr1/type_traits: Likewise.
+ * include/tr1/unordered_map.h: Likewise.
+ * include/tr1/unordered_set.h: Likewise.
+ * include/tr1/utility: Likewise.
+ * include/tr2/bool_set: Likewise.
+ * include/tr2/bool_set.tcc: Likewise.
+ * include/tr2/dynamic_bitset: Likewise.
+ * include/tr2/dynamic_bitset.tcc: Likewise.
+ * include/tr2/ratio: Likewise.
+ * include/tr2/type_traits: Likewise.
+ * src/c++11/chrono.cc: Likewise.
+ * src/c++11/compatibility-c++0x.cc: Likewise.
+ * src/c++11/compatibility-chrono.cc: Likewise.
+ * src/c++11/cxx11-shim_facets.cc: Likewise.
+ * src/c++11/hashtable_c++0x.cc: Likewise.
+ * src/c++11/placeholders.cc: Likewise.
+ * src/c++11/thread.cc: Likewise.
+ * src/c++98/bitmap_allocator.cc: Likewise.
+ * src/c++98/hashtable_tr1.cc: Likewise.
+ * src/c++98/list.cc: Likewise.
+ * src/shared/hashtable-aux.cc: Likewise.
+ * testsuite/20_util/duration/literals/range.cc: Adapt line number.
+ * testsuite/20_util/duration/requirements/typedefs_neg1.cc: Likewise.
+ * testsuite/20_util/duration/requirements/typedefs_neg2.cc: Likewise.
+ * testsuite/20_util/duration/requirements/typedefs_neg3.cc: Likewise.
+ * testsuite/20_util/forward/c_neg.cc: Likewise.
+ * testsuite/20_util/forward/f_neg.cc: Likewise.
+ * testsuite/26_numerics/gcd/gcd_neg.cc: Likewise.
+ * testsuite/26_numerics/lcm/lcm_neg.cc: Likewise.
+ * testsuite/26_numerics/random/pr60037-neg.cc: Likewise.
+ * python/libstdcxx/v6/printers.py: Adapt.
+
2017-07-20 Jonathan Wakely <jwakely@redhat.com>
* config/allocator/malloc_allocator_base.h [__SANITIZE_ADDRESS__]
_FIter
upper_bound(_FIter, _FIter, const _Tp&, _Compare);
-_GLIBCXX_END_NAMESPACE_VERSION
-
_GLIBCXX_BEGIN_NAMESPACE_ALGO
template<typename _FIter>
unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
_GLIBCXX_END_NAMESPACE_ALGO
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#ifdef _GLIBCXX_PARALLEL
{ };
#endif
-_GLIBCXX_END_NAMESPACE_VERSION
-
#if __cplusplus > 201103L
#define __cpp_lib_string_udls 201304
{
inline namespace string_literals
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
_GLIBCXX_DEFAULT_ABI_TAG
inline basic_string<char>
operator""s(const char* __str, size_t __len)
{ return basic_string<char32_t>{__str, __len}; }
#endif
-_GLIBCXX_END_NAMESPACE_VERSION
} // inline namespace string_literals
} // inline namespace literals
#endif // __cplusplus > 201103L
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++11
# define _GLIBCXX_DEFAULT_ABI_TAG
#endif
-
// Defined if inline namespaces are used for versioning.
#define _GLIBCXX_INLINE_VERSION
// Inline namespace for symbol versioning.
#if _GLIBCXX_INLINE_VERSION
+# define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __8 {
+# define _GLIBCXX_END_NAMESPACE_VERSION }
namespace std
{
- inline namespace __8 { }
-
- namespace rel_ops { inline namespace __8 { } }
-
- namespace tr1
- {
- inline namespace __8 { }
- namespace placeholders { inline namespace __8 { } }
- namespace regex_constants { inline namespace __8 { } }
- namespace __detail { inline namespace __8 { } }
- }
-
- namespace tr2
- { inline namespace __8 { } }
-
- namespace decimal { inline namespace __8 { } }
-
-#if __cplusplus >= 201103L
- namespace chrono { inline namespace __8 { } }
- namespace placeholders { inline namespace __8 { } }
- namespace regex_constants { inline namespace __8 { } }
- namespace this_thread { inline namespace __8 { } }
-
+inline _GLIBCXX_BEGIN_NAMESPACE_VERSION
#if __cplusplus >= 201402L
inline namespace literals {
- inline namespace chrono_literals { inline namespace __8 { } }
- inline namespace complex_literals { inline namespace __8 { } }
- inline namespace string_literals { inline namespace __8 { } }
+ inline namespace chrono_literals { }
+ inline namespace complex_literals { }
+ inline namespace string_literals { }
#if __cplusplus > 201402L
- inline namespace string_view_literals { inline namespace __8 { } }
+ inline namespace string_view_literals { }
#endif // C++17
}
#endif // C++14
-#endif // C++11
-
- namespace __detail {
- inline namespace __8 { }
-#if __cplusplus > 201402L
- namespace __variant { inline namespace __8 { } }
-#endif
- }
+_GLIBCXX_END_NAMESPACE_VERSION
}
namespace __gnu_cxx
{
- inline namespace __8 { }
- namespace __detail { inline namespace __8 { } }
+inline _GLIBCXX_BEGIN_NAMESPACE_VERSION
+_GLIBCXX_END_NAMESPACE_VERSION
}
-# define _GLIBCXX_BEGIN_NAMESPACE_VERSION namespace __8 {
-# define _GLIBCXX_END_NAMESPACE_VERSION }
+
#else
# define _GLIBCXX_BEGIN_NAMESPACE_VERSION
# define _GLIBCXX_END_NAMESPACE_VERSION
#endif
-
// Inline namespaces for special modes: debug, parallel, profile.
#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PARALLEL) \
|| defined(_GLIBCXX_PROFILE)
namespace std
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// Non-inline namespace for components replaced by alternates in active mode.
namespace __cxx1998
{
-# if _GLIBCXX_INLINE_VERSION
- inline namespace __8 { }
-# endif
-
# if _GLIBCXX_USE_CXX11_ABI
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
# endif
}
+_GLIBCXX_END_NAMESPACE_VERSION
+
// Inline namespace for debug mode.
# ifdef _GLIBCXX_DEBUG
inline namespace __debug { }
#if defined(_GLIBCXX_DEBUG) || defined(_GLIBCXX_PROFILE)
# define _GLIBCXX_STD_C __cxx1998
# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER \
- namespace _GLIBCXX_STD_C { _GLIBCXX_BEGIN_NAMESPACE_VERSION
-# define _GLIBCXX_END_NAMESPACE_CONTAINER \
- _GLIBCXX_END_NAMESPACE_VERSION }
+ namespace _GLIBCXX_STD_C {
+# define _GLIBCXX_END_NAMESPACE_CONTAINER }
#else
# define _GLIBCXX_STD_C std
-# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER _GLIBCXX_BEGIN_NAMESPACE_VERSION
-# define _GLIBCXX_END_NAMESPACE_CONTAINER _GLIBCXX_END_NAMESPACE_VERSION
+# define _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
+# define _GLIBCXX_END_NAMESPACE_CONTAINER
#endif
#ifdef _GLIBCXX_PARALLEL
# define _GLIBCXX_STD_A __cxx1998
# define _GLIBCXX_BEGIN_NAMESPACE_ALGO \
- namespace _GLIBCXX_STD_A { _GLIBCXX_BEGIN_NAMESPACE_VERSION
-# define _GLIBCXX_END_NAMESPACE_ALGO \
- _GLIBCXX_END_NAMESPACE_VERSION }
+ namespace _GLIBCXX_STD_A {
+# define _GLIBCXX_END_NAMESPACE_ALGO }
#else
# define _GLIBCXX_STD_A std
-# define _GLIBCXX_BEGIN_NAMESPACE_ALGO _GLIBCXX_BEGIN_NAMESPACE_VERSION
-# define _GLIBCXX_END_NAMESPACE_ALGO _GLIBCXX_END_NAMESPACE_VERSION
+# define _GLIBCXX_BEGIN_NAMESPACE_ALGO
+# define _GLIBCXX_END_NAMESPACE_ALGO
#endif
// GLIBCXX_ABI Deprecated
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
#if __cplusplus >= 201103L
#endif
_GLIBCXX_END_NAMESPACE_CONTAINER
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/**
{ __lx.swap(__ly); }
_GLIBCXX_END_NAMESPACE_CONTAINER
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // _FORWARD_LIST_H
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Tp, typename _Alloc>
}
_GLIBCXX_END_NAMESPACE_CONTAINER
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif /* _FORWARD_LIST_TCC */
typename _RehashPolicy, typename _Traits>
class _Hashtable;
-_GLIBCXX_END_NAMESPACE_VERSION
-
namespace __detail
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @defgroup hashtable-detail Base and Implementation Classes
* @ingroup unordered_associative_containers
}
//@} hashtable-detail
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // _HASHTABLE_POLICY_H
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Tp, typename _Alloc>
}
_GLIBCXX_END_NAMESPACE_CONTAINER
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif /* _LIST_TCC */
__addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
{ return __builtin_addressof(__r); }
+#if __cplusplus >= 201103L
+
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
-#if __cplusplus >= 201103L
#include <type_traits> // Brings in std::declval too.
namespace std _GLIBCXX_VISIBILITY(default)
}
/// @} group utilities
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
#define _GLIBCXX_MOVE(__val) std::move(__val)
#define _GLIBCXX_FORWARD(_Tp, __val) std::forward<_Tp>(__val)
#define _GLIBCXX_FORWARD(_Tp, __val) (__val)
#endif
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @addtogroup utilities
* @{
namespace std _GLIBCXX_VISIBILITY(default)
{
- namespace __detail {
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+ namespace __detail {
/**
* @brief Struct for delimited strings.
*/
return __is;
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++11
_RealType
generate_canonical(_UniformRandomNumberGenerator& __g);
-_GLIBCXX_END_NAMESPACE_VERSION
-
/*
* Implementation-space details.
*/
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _UIntType, size_t __w,
bool = __w < static_cast<size_t>
(std::numeric_limits<_UIntType>::digits)>
_Engine& _M_g;
};
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @addtogroup random_generators Random Number Generators
* @ingroup random
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/*
* (Further) implementation-space details.
*/
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// General case for x = (ax + c) mod m -- use Schrage's algorithm
// to avoid integer overflow.
//
return __result;
}
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
constexpr _UIntType
linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
class match_results;
_GLIBCXX_END_NAMESPACE_CXX11
-_GLIBCXX_END_NAMESPACE_VERSION
namespace __detail
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
enum class _RegexExecutorPolicy : int
{ _S_auto, _S_alternate };
_RegexExecutorPolicy __policy,
bool __match_mode>
bool
- __regex_algo_impl(_BiIter __s,
- _BiIter __e,
+ __regex_algo_impl(_BiIter __s,
+ _BiIter __e,
match_results<_BiIter, _Alloc>& __m,
const basic_regex<_CharT, _TraitsT>& __re,
regex_constants::match_flag_type __flags);
template<typename, typename, typename, bool>
class _Executor;
-
-_GLIBCXX_END_NAMESPACE_VERSION
}
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CXX11
/**
struct regex_traits
{
public:
- typedef _Ch_type char_type;
- typedef std::basic_string<char_type> string_type;
- typedef std::locale locale_type;
+ typedef _Ch_type char_type;
+ typedef std::basic_string<char_type> string_type;
+ typedef std::locale locale_type;
private:
struct _RegexMask
{
"regex traits class must have the same char_type");
// types:
- typedef _Ch_type value_type;
- typedef _Rx_traits traits_type;
+ typedef _Ch_type value_type;
+ typedef _Rx_traits traits_type;
typedef typename traits_type::string_type string_type;
typedef regex_constants::syntax_option_type flag_type;
typedef typename traits_type::locale_type locale_type;
template<typename _Bp, typename _Ap, typename _Cp, typename _Rp,
__detail::_RegexExecutorPolicy, bool>
- friend bool __detail::
-#if _GLIBCXX_INLINE_VERSION
- __8:: // Required due to PR c++/59256
-#endif
- __regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
- const basic_regex<_Cp, _Rp>&,
- regex_constants::match_flag_type);
+ friend bool
+ __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
+ const basic_regex<_Cp, _Rp>&,
+ regex_constants::match_flag_type);
template<typename, typename, typename, bool>
friend class __detail::_Executor;
- flag_type _M_flags;
- locale_type _M_loc;
- _AutomatonPtr _M_automaton;
+ flag_type _M_flags;
+ locale_type _M_loc;
+ _AutomatonPtr _M_automaton;
};
#if __cpp_deduction_guides >= 201606
public:
typedef typename __iter_traits::value_type value_type;
typedef typename __iter_traits::difference_type difference_type;
- typedef _BiIter iterator;
- typedef std::basic_string<value_type> string_type;
+ typedef _BiIter iterator;
+ typedef std::basic_string<value_type> string_type;
bool matched;
/** @brief Standard regex submatch over a C-style null-terminated string. */
- typedef sub_match<const char*> csub_match;
+ typedef sub_match<const char*> csub_match;
/** @brief Standard regex submatch over a standard string. */
typedef sub_match<string::const_iterator> ssub_match;
#ifdef _GLIBCXX_USE_WCHAR_T
/** @brief Regex submatch over a C-style null-terminated wide string. */
- typedef sub_match<const wchar_t*> wcsub_match;
+ typedef sub_match<const wchar_t*> wcsub_match;
/** @brief Regex submatch over a standard wide string. */
typedef sub_match<wstring::const_iterator> wssub_match;
* @name 10.? Public Types
*/
//@{
- typedef sub_match<_Bi_iter> value_type;
- typedef const value_type& const_reference;
- typedef const_reference reference;
- typedef typename _Base_type::const_iterator const_iterator;
- typedef const_iterator iterator;
+ typedef sub_match<_Bi_iter> value_type;
+ typedef const value_type& const_reference;
+ typedef const_reference reference;
+ typedef typename _Base_type::const_iterator const_iterator;
+ typedef const_iterator iterator;
typedef typename __iter_traits::difference_type difference_type;
typedef typename allocator_traits<_Alloc>::size_type size_type;
- typedef _Alloc allocator_type;
+ typedef _Alloc allocator_type;
typedef typename __iter_traits::value_type char_type;
- typedef std::basic_string<char_type> string_type;
+ typedef std::basic_string<char_type> string_type;
//@}
public:
template<typename _Bp, typename _Ap, typename _Cp, typename _Rp,
__detail::_RegexExecutorPolicy, bool>
- friend bool __detail::
-#if _GLIBCXX_INLINE_VERSION
- __8:: // Required due to PR c++/59256
-#endif
- __regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
- const basic_regex<_Cp, _Rp>&,
- regex_constants::match_flag_type);
+ friend bool
+ __detail::__regex_algo_impl(_Bp, _Bp, match_results<_Bp, _Ap>&,
+ const basic_regex<_Cp, _Rp>&,
+ regex_constants::match_flag_type);
void
_M_resize(unsigned int __size)
_Bi_iter _M_begin;
};
- typedef match_results<const char*> cmatch;
- typedef match_results<string::const_iterator> smatch;
+ typedef match_results<const char*> cmatch;
+ typedef match_results<string::const_iterator> smatch;
#ifdef _GLIBCXX_USE_WCHAR_T
- typedef match_results<const wchar_t*> wcmatch;
+ typedef match_results<const wchar_t*> wcmatch;
typedef match_results<wstring::const_iterator> wsmatch;
#endif
template<typename _Bi_iter, typename _Alloc,
typename _Ch_type, typename _Rx_traits>
inline bool
- regex_match(_Bi_iter __s,
- _Bi_iter __e,
- match_results<_Bi_iter, _Alloc>& __m,
+ regex_match(_Bi_iter __s,
+ _Bi_iter __e,
+ match_results<_Bi_iter, _Alloc>& __m,
const basic_regex<_Ch_type, _Rx_traits>& __re,
- regex_constants::match_flag_type __flags
+ regex_constants::match_flag_type __flags
= regex_constants::match_default)
{
return __detail::__regex_algo_impl<_Bi_iter, _Alloc, _Ch_type, _Rx_traits,
{
public:
typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
- typedef match_results<_Bi_iter> value_type;
- typedef std::ptrdiff_t difference_type;
- typedef const value_type* pointer;
- typedef const value_type& reference;
- typedef std::forward_iterator_tag iterator_category;
+ typedef match_results<_Bi_iter> value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef const value_type* pointer;
+ typedef const value_type& reference;
+ typedef std::forward_iterator_tag iterator_category;
/**
* @brief Provides a singular iterator, useful for indicating
}
private:
- _Bi_iter _M_begin;
- _Bi_iter _M_end;
- const regex_type* _M_pregex;
- regex_constants::match_flag_type _M_flags;
- match_results<_Bi_iter> _M_match;
+ _Bi_iter _M_begin;
+ _Bi_iter _M_end;
+ const regex_type* _M_pregex;
+ regex_constants::match_flag_type _M_flags;
+ match_results<_Bi_iter> _M_match;
};
- typedef regex_iterator<const char*> cregex_iterator;
- typedef regex_iterator<string::const_iterator> sregex_iterator;
+ typedef regex_iterator<const char*> cregex_iterator;
+ typedef regex_iterator<string::const_iterator> sregex_iterator;
#ifdef _GLIBCXX_USE_WCHAR_T
- typedef regex_iterator<const wchar_t*> wcregex_iterator;
- typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
+ typedef regex_iterator<const wchar_t*> wcregex_iterator;
+ typedef regex_iterator<wstring::const_iterator> wsregex_iterator;
#endif
// [7.12.2] Class template regex_token_iterator
class regex_token_iterator
{
public:
- typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
- typedef sub_match<_Bi_iter> value_type;
- typedef std::ptrdiff_t difference_type;
- typedef const value_type* pointer;
- typedef const value_type& reference;
- typedef std::forward_iterator_tag iterator_category;
+ typedef basic_regex<_Ch_type, _Rx_traits> regex_type;
+ typedef sub_match<_Bi_iter> value_type;
+ typedef std::ptrdiff_t difference_type;
+ typedef const value_type* pointer;
+ typedef const value_type& reference;
+ typedef std::forward_iterator_tag iterator_category;
public:
/**
_M_result = nullptr;
}
- _Position _M_position;
- std::vector<int> _M_subs;
- value_type _M_suffix;
- std::size_t _M_n;
- const value_type* _M_result;
+ _Position _M_position;
+ std::vector<int> _M_subs;
+ value_type _M_suffix;
+ std::size_t _M_n;
+ const value_type* _M_result;
// Show whether _M_subs contains -1
- bool _M_has_m1;
+ bool _M_has_m1;
};
/** @brief Token iterator for C-style NULL-terminated strings. */
- typedef regex_token_iterator<const char*> cregex_token_iterator;
+ typedef regex_token_iterator<const char*> cregex_token_iterator;
/** @brief Token iterator for standard strings. */
- typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
+ typedef regex_token_iterator<string::const_iterator> sregex_token_iterator;
#ifdef _GLIBCXX_USE_WCHAR_T
/** @brief Token iterator for C-style NULL-terminated wide strings. */
- typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
+ typedef regex_token_iterator<const wchar_t*> wcregex_token_iterator;
/** @brief Token iterator for standard wide-character strings. */
typedef regex_token_iterator<wstring::const_iterator> wsregex_token_iterator;
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace __detail
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace __detail
+{
// Result of merging regex_match and regex_search.
//
// __policy now can be _S_auto (auto dispatch) and _S_alternate (use
}
return __ret;
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
}
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Ch_type>
template<typename _Fwd_iter>
typename regex_traits<_Ch_type>::string_type
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
-
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace __detail
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace __detail
+{
/**
* @defgroup regex-detail Base and Implementation Classes
* @ingroup regex
};
//@} regex-detail
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#include <bits/regex_automaton.tcc>
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace __detail
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace __detail
+{
#ifdef _GLIBCXX_DEBUG
inline std::ostream&
_State_base::_M_print(std::ostream& ostr) const
}
return _StateSeq(_M_nfa, __m[_M_start], __m[_M_end]);
}
+} // namespace __detail
_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace __detail
} // namespace
class regex_traits;
_GLIBCXX_END_NAMESPACE_CXX11
-_GLIBCXX_END_NAMESPACE_VERSION
namespace __detail
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @addtogroup regex-detail
* @{
};
//@} regex-detail
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#include <bits/regex_compiler.tcc>
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace __detail
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace __detail
+{
template<typename _TraitsT>
_Compiler<_TraitsT>::
_Compiler(_IterT __b, _IterT __e,
return false;
}() ^ _M_is_non_matching;
}
+} // namespace __detail
_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace __detail
} // namespace
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @defgroup regex Regular Expressions
*
*/
namespace regex_constants
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @name 5.1 Regular Expression Syntax Options
*/
{ return __a = __a ^ __b; }
//@}
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace regex_constants
-
/* @} */ // group regex
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @addtogroup regex
* @{
namespace regex_constants
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @name 5.3 Error Types
*/
constexpr error_type error_stack(_S_error_stack);
//@}
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace regex_constants
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// [7.8] Class regex_error
/**
* @brief A regular expression exception class.
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace __detail
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace __detail
+{
/**
* @addtogroup regex-detail
* @{
};
//@} regex-detail
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#include <bits/regex_executor.tcc>
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace __detail
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace __detail
+{
template<typename _BiIter, typename _Alloc, typename _TraitsT,
bool __dfs_mode>
bool _Executor<_BiIter, _Alloc, _TraitsT, __dfs_mode>::
return __left_is_word != __right_is_word;
}
+} // namespace __detail
_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace __detail
} // namespace
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace __detail
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace __detail
+{
/**
* @addtogroup regex-detail
* @{
};
//@} regex-detail
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#include <bits/regex_scanner.tcc>
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace __detail
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace __detail
+{
template<typename _CharT>
_Scanner<_CharT>::
_Scanner(typename _Scanner::_IterT __begin,
}
#endif
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Confluent hypergeometric functions
return std::__detail::__hyperg<__type>(__a, __b, __c, __x);
}
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __gnu_cxx
#pragma GCC visibility pop
#endif // C++11
-_GLIBCXX_END_NAMESPACE_VERSION
-
_GLIBCXX_BEGIN_NAMESPACE_ALGO
/**
#endif // C++14
_GLIBCXX_END_NAMESPACE_ALGO
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif /* _STL_ALGO_H */
__lg(unsigned long long __n)
{ return sizeof(long long) * __CHAR_BIT__ - 1 - __builtin_clzll(__n); }
-_GLIBCXX_END_NAMESPACE_VERSION
-
_GLIBCXX_BEGIN_NAMESPACE_ALGO
/**
#endif
_GLIBCXX_END_NAMESPACE_ALGO
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
// NB: This file is included within many other C++ includes, as a way
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
typedef unsigned long _Bit_type;
};
_GLIBCXX_END_NAMESPACE_CONTAINER
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
// Declare a partial specialization of vector<T, Alloc>.
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/**
};
_GLIBCXX_END_NAMESPACE_CONTAINER
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#if __cplusplus >= 201103L
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/**
#undef _GLIBCXX_DEQUE_BUF_SIZE
_GLIBCXX_END_NAMESPACE_CONTAINER
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif /* _STL_DEQUE_H */
__niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
{ return __it.base(); }
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
-
#if __cplusplus >= 201103L
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @addtogroup iterators
* @{
-> decltype(__miter_base(__it.base()))
{ return __miter_base(__it.base()); }
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
-
#define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
std::__make_move_if_noexcept_iterator(_Iter)
#define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
#endif // C++11
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
+
#ifdef _GLIBCXX_DEBUG
# include <debug/stl_iterator.h>
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
// Forward declaration for the overloads of __distance.
template <typename> struct _List_iterator;
template <typename> struct _List_const_iterator;
_GLIBCXX_END_NAMESPACE_CONTAINER
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _InputIterator>
inline _GLIBCXX14_CONSTEXPR
typename iterator_traits<_InputIterator>::difference_type
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// Supporting structures are split into common and templated
// types; the latter publicly inherits from the former in an
// effort to reduce code duplication. This results in some
private:
_List_node_base* _M_base() { return this; }
};
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace detail
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
_GLIBCXX_END_NAMESPACE_CONTAINER
#if _GLIBCXX_USE_CXX11_ABI
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Detect when distance is used to compute the size of the whole list.
template<typename _Tp>
}
return __n;
}
+#endif
_GLIBCXX_END_NAMESPACE_VERSION
-#endif
} // namespace std
#endif /* _STL_LIST_H */
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
_GLIBCXX_END_NAMESPACE_CONTAINER
#if __cplusplus > 201402L
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Allow std::map access to internals of compatible maps.
template<typename _Key, typename _Val, typename _Cmp1, typename _Alloc,
typename _Cmp2>
_S_get_tree(_GLIBCXX_STD_C::multimap<_Key, _Val, _Cmp2, _Alloc>& __map)
{ return __map._M_t; }
};
-_GLIBCXX_END_NAMESPACE_VERSION
#endif // C++17
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif /* _STL_MAP_H */
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template <typename _Key, typename _Tp, typename _Compare, typename _Alloc>
_GLIBCXX_END_NAMESPACE_CONTAINER
#if __cplusplus > 201402L
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Allow std::multimap access to internals of compatible maps.
template<typename _Key, typename _Val, typename _Cmp1, typename _Alloc,
typename _Cmp2>
_S_get_tree(_GLIBCXX_STD_C::multimap<_Key, _Val, _Cmp2, _Alloc>& __map)
{ return __map._M_t; }
};
-_GLIBCXX_END_NAMESPACE_VERSION
#endif // C++17
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif /* _STL_MULTIMAP_H */
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Key, typename _Compare, typename _Alloc>
_GLIBCXX_END_NAMESPACE_CONTAINER
#if __cplusplus > 201402L
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Allow std::multiset access to internals of compatible sets.
template<typename _Val, typename _Cmp1, typename _Alloc, typename _Cmp2>
struct
_S_get_tree(_GLIBCXX_STD_C::multiset<_Val, _Cmp2, _Alloc>& __set)
{ return __set._M_t; }
};
-_GLIBCXX_END_NAMESPACE_VERSION
#endif // C++17
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif /* _STL_MULTISET_H */
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace rel_ops
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/** @namespace std::rel_ops
* @brief The generated relational operators are sequestered here.
*/
inline bool
operator>=(const _Tp& __x, const _Tp& __y)
{ return !(__x < __y); }
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace rel_ops
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif /* _STL_RELOPS_H */
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Key, typename _Compare, typename _Alloc>
_GLIBCXX_END_NAMESPACE_CONTAINER
#if __cplusplus > 201402L
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Allow std::set access to internals of compatible sets.
template<typename _Val, typename _Cmp1, typename _Alloc, typename _Cmp2>
struct
_S_get_tree(_GLIBCXX_STD_C::multiset<_Val, _Cmp2, _Alloc>& __set)
{ return __set._M_t; }
};
-_GLIBCXX_END_NAMESPACE_VERSION
#endif // C++17
+_GLIBCXX_END_NAMESPACE_VERSION
} //namespace std
#endif /* _STL_SET_H */
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/// See bits/stl_deque.h's _Deque_base for an explanation.
}
};
-
/**
* @brief A standard container which offers fixed time access to
* individual elements in any order.
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE_CONTAINER
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif /* _STL_VECTOR_H */
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
namespace __detail
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
/* Determine whether number is a power of 2. */
template<typename _Tp>
inline bool
{
return ((__x - 1) & __x) == 0;
};
-_GLIBCXX_END_NAMESPACE_VERSION
}
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @brief Uniform discrete distribution for random numbers.
* A discrete random distribution on the range @f$[min, max]@f$ with equal
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/// Base types for unordered_map.
_GLIBCXX_END_NAMESPACE_CONTAINER
#if __cplusplus > 201402L
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Allow std::unordered_map access to internals of compatible maps.
template<typename _Key, typename _Val, typename _Hash1, typename _Eq1,
typename _Alloc, typename _Hash2, typename _Eq2>
_S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map)
{ return __map._M_h; }
};
-_GLIBCXX_END_NAMESPACE_VERSION
#endif // C++17
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif /* _UNORDERED_MAP_H */
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
/// Base types for unordered_set.
_GLIBCXX_END_NAMESPACE_CONTAINER
#if __cplusplus > 201402L
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Allow std::unordered_set access to internals of compatible sets.
template<typename _Val, typename _Hash1, typename _Eq1, typename _Alloc,
typename _Hash2, typename _Eq2>
_S_get_table(unordered_multiset<_Val, _Hash2, _Eq2, _Alloc>& __set)
{ return __set._M_h; }
};
-_GLIBCXX_END_NAMESPACE_VERSION
#endif // C++17
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif /* _UNORDERED_SET_H */
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
template<typename _Tp, typename _Alloc>
#endif
_GLIBCXX_END_NAMESPACE_CONTAINER
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#if __cplusplus >= 201103L
tanh(_Tp __x)
{ return __builtin_tanh(__x); }
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
-
#if _GLIBCXX_USE_C99_MATH
#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
#undef islessgreater
#undef isunordered
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#if __cplusplus >= 201103L
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
return __builtin_isunordered(__type(__f1), __type(__f2));
}
-#endif
-
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
-
+#endif // C++11
#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
-#endif
+#endif /* _GLIBCXX_USE_C99_MATH */
#if __cplusplus >= 201103L
#undef truncf
#undef truncl
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// types
using ::double_t;
using ::float_t;
{ return __builtin_trunc(__x); }
#endif
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
-
#endif // _GLIBCXX_USE_C99_MATH_TR1
-
#endif // C++11
#if __cplusplus > 201402L
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// [c.math.hypot3], three-dimensional hypotenuse
#define __cpp_lib_hypot 201603
using __type = typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type;
return std::__hypot3<__type>(__x, __y, __z);
}
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
#endif // C++17
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace
#if _GLIBCXX_USE_STD_SPEC_FUNCS
# include <bits/specfun.h>
tanh(_Tp __x)
{ return __builtin_tanh(__x); }
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
-
#if _GLIBCXX_USE_C99_MATH
#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
#undef islessgreater
#undef isunordered
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Tp>
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
int>::__type
return __builtin_isunordered(__type(__f1), __type(__f2));
}
+#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
+#endif /* _GLIBCXX_USE_C99_MATH */
+
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
-#endif
-
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @defgroup decimal Decimal Floating-Point Arithmetic
* @ingroup numerics
*/
namespace decimal
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
class decimal32;
class decimal64;
class decimal128;
};
#define _GLIBCXX_USE_DECIMAL_ 1
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace decimal
// @} group decimal
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#include <decimal/decimal.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace decimal
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// ISO/IEC TR 24733 3.2.[234].1 Construct/copy/destroy.
inline decimal32::decimal32(decimal64 __r) : __val(__r.__getval()) {}
#undef _DEFINE_DECIMAL_COMPARISON_LHS
#undef _DEFINE_DECIMAL_COMPARISON_RHS
#undef _DEFINE_DECIMAL_COMPARISONS
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace decimal
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif /* _GLIBCXX_DECIMAL_IMPL */
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _ForwardIterator, typename _Searcher>
inline _ForwardIterator
search(_ForwardIterator __first, _ForwardIterator __last,
__d,
std::forward<_UniformRandomNumberGenerator>(__g));
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v1
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @defgroup any Type-safe container of any type
* @ingroup experimental
}
// @} group any
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v1
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#define __cpp_lib_experimental_make_array 201505
/**
* @defgroup make_array Array creation functions
}
// @} group make_array
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v2
} // namespace experimental
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
namespace __detail
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Container, typename _Predicate>
void
__erase_nodes_if(_Container& __cont, _Predicate __pred)
++__iter;
}
}
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
} // inline namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
namespace filesystem
{
inline namespace v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @ingroup filesystem
* @{
_GLIBCXX_END_NAMESPACE_CXX11
// @} group filesystem
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace v1
} // namespace filesystem
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++11
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
namespace filesystem
{
inline namespace v1
{
-#if _GLIBCXX_INLINE_VERSION
-inline namespace __8 { }
-#endif
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#if _GLIBCXX_USE_CXX11_ABI
inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
#endif
bool is_symlink(file_status) noexcept;
// @} group filesystem
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace v1
} // namespace filesystem
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++11
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
namespace filesystem
{
inline namespace v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @ingroup filesystem
* @{
path temp_directory_path(error_code& __ec);
// @} group filesystem
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace v1
} // namespace filesystem
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++11
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
namespace filesystem
{
inline namespace v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CXX11
#if __cplusplus == 201402L
// @} group filesystem
_GLIBCXX_END_NAMESPACE_CXX11
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace v1
} // namespace filesystem
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++11
#if _GLIBCXX_INLINE_VERSION
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace chrono
{
namespace experimental
{
-inline namespace fundamentals_v1 { inline namespace __8 { } }
-inline namespace fundamentals_v2 { inline namespace __8 { } }
+inline namespace fundamentals_v1 { }
+inline namespace fundamentals_v2 { }
} // namespace experimental
} // namespace chrono
namespace experimental
{
-inline namespace fundamentals_v1 {
- inline namespace __8 { }
- namespace __detail { inline namespace __8 { } }
-}
-inline namespace fundamentals_v2 {
- inline namespace __8 { }
- namespace pmr { inline namespace __8 { } }
- namespace __detail { inline namespace __8 { } }
-} // namespace fundamentals_v2
-inline namespace literals { inline namespace string_view_literals {
- inline namespace __8 { }
-} } // namespace literals::string_view_literals
+inline namespace fundamentals_v1 { }
+inline namespace fundamentals_v2 { }
+inline namespace literals { inline namespace string_view_literals { } }
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// 8.2.1
template<typename _Tp> class shared_ptr;
mutable weak_ptr<_Tp> _M_weak_this;
};
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v2
} // namespace experimental
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/// std::hash specialization for shared_ptr.
template<typename _Tp>
struct hash<experimental::shared_ptr<_Tp>>
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _CharT, typename _Traits>
typename basic_string_view<_CharT, _Traits>::size_type
basic_string_view<_CharT, _Traits>::
}
return npos;
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v1
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // __cplusplus <= 201103L
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace chrono {
namespace experimental
{
inline namespace fundamentals_v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// See C++14 §20.12.4, customization traits
template <typename _Rep>
constexpr bool treat_as_floating_point_v =
treat_as_floating_point<_Rep>::value;
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v1
} // namespace experimental
} // namespace chrono
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // __cplusplus <= 201103L
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Tp, typename _Alloc, typename _Predicate>
void
erase_if(deque<_Tp, _Alloc>& __cont, _Predicate __pred)
__cont.end());
}
-_GLIBCXX_END_NAMESPACE_VERSION
-
-namespace pmr {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
- template<typename _Tp>
- using deque = std::deque<_Tp, polymorphic_allocator<_Tp>>;
-
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace pmr
+ namespace pmr {
+ template<typename _Tp>
+ using deque = std::deque<_Tp, polymorphic_allocator<_Tp>>;
+ } // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
namespace filesystem
{
inline namespace v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @ingroup filesystem
*/
__what += " [" + _M_path2.string() + ']';
return __what;
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace v1
} // namespace filesystem
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++11
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Tp, typename _Alloc, typename _Predicate>
inline void
erase_if(forward_list<_Tp, _Alloc>& __cont, _Predicate __pred)
erase_if(__cont, [&](__elem_type& __elem) { return __elem == __value; });
}
-_GLIBCXX_END_NAMESPACE_VERSION
-
-namespace pmr {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
- template<typename _Tp>
- using forward_list = std::forward_list<_Tp, polymorphic_allocator<_Tp>>;
-
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace pmr
+ namespace pmr {
+ template<typename _Tp>
+ using forward_list = std::forward_list<_Tp, polymorphic_allocator<_Tp>>;
+ } // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// See C++14 §20.9.9, Function object binders
/// Variable template for std::is_bind_expression
}
return __last;
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v1
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#define __cpp_lib_experimental_not_fn 201406
/// [func.not_fn] Function template not_fn
{
return std::_Not_fn<std::decay_t<_Fn>>{std::forward<_Fn>(__fn), 0};
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#define __cpp_lib_experimental_ostream_joiner 201411
/// Output iterator that inserts a delimiter between elements.
make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os,
_DelimT&& __delimiter)
{ return { __os, std::forward<_DelimT>(__delimiter) }; }
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // __cplusplus <= 201103L
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Tp, typename _Alloc, typename _Predicate>
inline void
erase_if(list<_Tp, _Alloc>& __cont, _Predicate __pred)
erase_if(__cont, [&](__elem_type& __elem) { return __elem == __value; });
}
-_GLIBCXX_END_NAMESPACE_VERSION
-
namespace pmr {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Tp>
using list = std::list<_Tp, polymorphic_allocator<_Tp>>;
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Key, typename _Tp, typename _Compare, typename _Alloc,
typename _Predicate>
inline void
erase_if(multimap<_Key, _Tp, _Compare, _Alloc>& __cont, _Predicate __pred)
{ __detail::__erase_nodes_if(__cont, __pred); }
-_GLIBCXX_END_NAMESPACE_VERSION
-
-namespace pmr {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
- template<typename _Key, typename _Tp, typename _Compare = less<_Key>>
- using map
+ namespace pmr {
+ template<typename _Key, typename _Tp, typename _Compare = less<_Key>>
+ using map
= std::map<_Key, _Tp, _Compare,
polymorphic_allocator<pair<const _Key, _Tp>>>;
- template<typename _Key, typename _Tp, typename _Compare = less<_Key>>
- using multimap
+ template<typename _Key, typename _Tp, typename _Compare = less<_Key>>
+ using multimap
= std::multimap<_Key, _Tp, _Compare,
polymorphic_allocator<pair<const _Key, _Tp>>>;
-
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace pmr
-
+ } // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#define __cpp_lib_experimental_observer_ptr 201411
template <typename _Tp>
{
return !(__p1 < __p2);
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v2
} // namespace experimental
}
};
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // __cplusplus <= 201103L
#include <experimental/bits/lfts_config.h>
namespace std {
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental {
inline namespace fundamentals_v2 {
namespace pmr {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#define __cpp_lib_experimental_memory_resources 201402L
class memory_resource;
__r = new_delete_resource();
return __get_default_resource().exchange(__r);
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#define __cpp_lib_experimental_gcd_lcm 201411
/// Greatest common divisor
static_assert(!is_same<_Nn, bool>::value, "lcm arguments are not bools");
return std::__detail::__lcm(__m, __n);
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // __cplusplus <= 201103L
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @defgroup optional Optional values
* @ingroup experimental
{ return optional<decay_t<_Tp>> { std::forward<_Tp>(__t) }; }
// @} group optional
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v1
-}
+} // namespace experimental
// [X.Y.12]
template<typename _Tp>
return __t ? hash<_Tp> {}(*__t) : __magic_disengaged_hash;
}
};
-}
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @defgroup propagate_const Const-propagating wrapper
* @ingroup experimental
}
// @} group propagate_const
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v2
} // namespace experimental
typedef experimental::propagate_const<_Tp> second_argument_type;
typedef bool result_type;
};
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
#include <experimental/bits/lfts_config.h>
namespace std {
-namespace experimental {
-inline namespace fundamentals_v2 {
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace experimental {
+inline namespace fundamentals_v2 {
#define __cpp_lib_experimental_randint 201511
inline std::default_random_engine&
{
_S_randint_engine().seed(__value);
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// See C++14 §20.11.5, ratio comparison
template <typename _R1, typename _R2>
constexpr bool ratio_equal_v = ratio_equal<_R1, _R2>::value;
constexpr bool ratio_greater_v = ratio_greater<_R1, _R2>::value;
template <typename _R1, typename _R2>
constexpr bool ratio_greater_equal_v = ratio_greater_equal<_R1, _R2>::value;
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v1
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // __cplusplus <= 201103L
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
namespace pmr
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
_GLIBCXX_BEGIN_NAMESPACE_CXX11
template<typename _BidirectionalIterator>
typedef match_results<wstring::const_iterator> wsmatch;
_GLIBCXX_END_NAMESPACE_CXX11
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Key, typename _Compare, typename _Alloc,
typename _Predicate>
inline void
erase_if(multiset<_Key, _Compare, _Alloc>& __cont, _Predicate __pred)
{ __detail::__erase_nodes_if(__cont, __pred); }
-_GLIBCXX_END_NAMESPACE_VERSION
-
-namespace pmr {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
- template<typename _Key, typename _Compare = less<_Key>>
- using set = std::set<_Key, _Compare, polymorphic_allocator<_Key>>;
-
- template<typename _Key, typename _Compare = less<_Key>>
- using multiset = std::multiset<_Key, _Compare,
- polymorphic_allocator<_Key>>;
+ namespace pmr {
+ template<typename _Key, typename _Compare = less<_Key>>
+ using set = std::set<_Key, _Compare, polymorphic_allocator<_Key>>;
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace pmr
+ template<typename _Key, typename _Compare = less<_Key>>
+ using multiset = std::multiset<_Key, _Compare,
+ polymorphic_allocator<_Key>>;
+ } // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
#include <cstdint>
namespace std {
-namespace experimental {
-inline namespace fundamentals_v2 {
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace experimental {
+inline namespace fundamentals_v2 {
#define __cpp_lib_experimental_source_location 201505
struct source_location
uint_least32_t _M_line;
uint_least32_t _M_col;
};
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _CharT, typename _Traits, typename _Alloc,
typename _Predicate>
inline void
__cont.end());
}
-_GLIBCXX_END_NAMESPACE_VERSION
+ namespace pmr {
+ _GLIBCXX_BEGIN_NAMESPACE_CXX11
-namespace pmr {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-_GLIBCXX_BEGIN_NAMESPACE_CXX11
+ // basic_string using polymorphic allocator in namespace pmr
+ template<typename _CharT, typename _Traits = char_traits<_CharT>>
+ using basic_string =
+ std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
- // basic_string using polymorphic allocator in namespace pmr
- template<typename _CharT, typename _Traits = char_traits<_CharT>>
- using basic_string =
- std::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
-
- // basic_string typedef names using polymorphic allocator in namespace
- // std::experimental::pmr
- typedef basic_string<char> string;
- typedef basic_string<char16_t> u16string;
- typedef basic_string<char32_t> u32string;
- typedef basic_string<wchar_t> wstring;
-
-_GLIBCXX_END_NAMESPACE_CXX11
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace pmr
+ // basic_string typedef names using polymorphic allocator in namespace
+ // std::experimental::pmr
+ typedef basic_string<char> string;
+ typedef basic_string<char16_t> u16string;
+ typedef basic_string<char32_t> u32string;
+ typedef basic_string<wchar_t> wstring;
+ _GLIBCXX_END_NAMESPACE_CXX11
+ } // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#define __cpp_lib_experimental_string_view 201411
/**
const _CharT* _M_str;
};
-_GLIBCXX_END_NAMESPACE_VERSION
-
// [string.view.comparison], non-member basic_string_view comparison functions
namespace __detail
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Identity transform to create a non-deduced context, so that only one
// argument participates in template argument deduction and the other
// argument gets implicitly converted to the deduced type. See n3766.html.
template<typename _Tp>
using __idt = common_type_t<_Tp>;
-_GLIBCXX_END_NAMESPACE_VERSION
}
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _CharT, typename _Traits>
inline bool
operator==(basic_string_view<_CharT, _Traits> __x,
using u16string_view = basic_string_view<char16_t>;
using u32string_view = basic_string_view<char32_t>;
#endif
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v1
} // namespace experimental
// [string.view.hash], hash support:
-
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename _Tp>
struct hash;
struct __is_fast_hash<hash<experimental::u32string_view>> : std::false_type
{ };
#endif
-_GLIBCXX_END_NAMESPACE_VERSION
namespace experimental
{
{
inline namespace string_view_literals
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
inline constexpr basic_string_view<char>
operator""sv(const char* __str, size_t __len)
{ return basic_string_view<char>{__str, __len}; }
operator""sv(const char32_t* __str, size_t __len)
{ return basic_string_view<char32_t>{__str, __len}; }
#endif
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace string_literals
} // namespace literals
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#include <experimental/bits/string_view.tcc>
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// See C++14 §19.5, System error support
template <typename _Tp>
constexpr bool is_error_code_enum_v = is_error_code_enum<_Tp>::value;
template <typename _Tp>
constexpr bool is_error_condition_enum_v =
is_error_condition_enum<_Tp>::value;
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v1
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // __cplusplus <= 201103L
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// See C++14 §20.4.2.5, tuple helper classes
template <typename _Tp>
constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
std::forward<_Tuple>(__t),
_Indices{});
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v1
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#define __cpp_lib_experimental_type_trait_variable_templates 201402
// See C++14 §20.10.4.1, primary type categories
// raw_invocation_type (still unimplemented)
// invocation_type_t (still unimplemented)
// raw_invocation_type_t (still unimplemented)
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v1
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#define __cpp_lib_experimental_detect 201505
// [meta.detect]
template<typename _Pp>
constexpr bool negation_v
= negation<_Pp>::value;
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // __cplusplus <= 201103L
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Key, typename _Tp, typename _Hash, typename _CPred,
typename _Alloc, typename _Predicate>
inline void
_Predicate __pred)
{ __detail::__erase_nodes_if(__cont, __pred); }
-_GLIBCXX_END_NAMESPACE_VERSION
-
-namespace pmr {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
- template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
- typename _Pred = equal_to<_Key>>
- using unordered_map
+ namespace pmr {
+ template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
+ typename _Pred = equal_to<_Key>>
+ using unordered_map
= std::unordered_map<_Key, _Tp, _Hash, _Pred,
polymorphic_allocator<pair<const _Key, _Tp>>>;
- template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
- typename _Pred = equal_to<_Key>>
- using unordered_multimap
+ template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
+ typename _Pred = equal_to<_Key>>
+ using unordered_multimap
= std::unordered_multimap<_Key, _Tp, _Hash, _Pred,
polymorphic_allocator<pair<const _Key, _Tp>>>;
-
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace pmr
+ } // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Key, typename _Hash, typename _CPred, typename _Alloc,
typename _Predicate>
inline void
_Predicate __pred)
{ __detail::__erase_nodes_if(__cont, __pred); }
-_GLIBCXX_END_NAMESPACE_VERSION
-
-namespace pmr {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
- template<typename _Key, typename _Hash = hash<_Key>,
- typename _Pred = equal_to<_Key>>
- using unordered_set
+ namespace pmr {
+ template<typename _Key, typename _Hash = hash<_Key>,
+ typename _Pred = equal_to<_Key>>
+ using unordered_set
= std::unordered_set<_Key, _Hash, _Pred, polymorphic_allocator<_Key>>;
- template<typename _Key, typename _Hash = hash<_Key>,
- typename _Pred = equal_to<_Key>>
- using unordered_multiset
+ template<typename _Key, typename _Hash = hash<_Key>,
+ typename _Pred = equal_to<_Key>>
+ using unordered_multiset
= std::unordered_multiset<_Key, _Hash, _Pred,
polymorphic_allocator<_Key>>;
-
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace pmr
+ } // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
#include <experimental/bits/lfts_config.h>
namespace std {
-namespace experimental {
-inline namespace fundamentals_v2 {
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace experimental {
+inline namespace fundamentals_v2 {
// 3.1.2, erased-type placeholder
using erased_type = std::__erased_type;
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace experimental
{
inline namespace fundamentals_v2
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#define __cpp_lib_experimental_erase_if 201411
template<typename _Tp, typename _Alloc, typename _Predicate>
__cont.end());
}
-_GLIBCXX_END_NAMESPACE_VERSION
-
-namespace pmr {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
- template<typename _Tp>
- using vector = std::vector<_Tp, polymorphic_allocator<_Tp>>;
-
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace pmr
+ namespace pmr {
+ template<typename _Tp>
+ using vector = std::vector<_Tp, polymorphic_allocator<_Tp>>;
+ } // namespace pmr
} // namespace fundamentals_v2
} // namespace experimental
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // C++14
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
using std::size_t;
using std::ptrdiff_t;
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
/** @class __mini_vector bitmap_allocator.h bitmap_allocator.h
*
* @brief __mini_vector<> is a stripped down version of the
size_t __mask = 1 << __pos;
*__pbmap |= __mask;
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/** @brief Generic Version of the bsf instruction.
*/
inline size_t
} // namespace __gnu_cxx
#endif
-
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
-_GLIBCXX_BEGIN_NAMESPACE_CXX11
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+_GLIBCXX_BEGIN_NAMESPACE_CXX11
/// Extension to use iconv for dealing with character encodings.
// This includes conversions and comparisons between various character
typedef typename std::fpos<state_type> pos_type;
};
-_GLIBCXX_END_NAMESPACE_VERSION
_GLIBCXX_END_NAMESPACE_CXX11
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace __detail
{
enum { _S_max_rope_depth = 45 };
using std::allocator;
using std::_Destroy;
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// See libstdc++/36832.
template<typename _ForwardIterator, typename _Allocator>
void
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
template<>
struct hash<__gnu_cxx::crope>
{
return 13 * __str[0] + 5 * __str[__size - 1] + __size;
}
};
+} // namespace tr1
_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace tr1
} // namespace std
# include <ext/ropeimpl.h>
template<typename T1, typename T2, typename T3,
typename T4, typename T5, typename T6>
struct create6;
-} // namespace typelist
-
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
-
-namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
-namespace typelist
-{
namespace detail
{
template<typename Fn, typename Typelist_Chain>
typedef typename append_type::type::root type;
};
} // namespace detail
-} // namespace typelist
-
-_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace
#define _GLIBCXX_TYPELIST_CHAIN1(X0) __gnu_cxx::typelist::chain<X0, __gnu_cxx::typelist::null_type>
#define _GLIBCXX_TYPELIST_CHAIN2(X0, X1) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN1(X1) >
#define _GLIBCXX_TYPELIST_CHAIN19(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN18(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18) >
#define _GLIBCXX_TYPELIST_CHAIN20(X0, X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19) __gnu_cxx::typelist::chain<X0, _GLIBCXX_TYPELIST_CHAIN19(X1, X2, X3, X4, X5, X6, X7, X8, X9, X10, X11, X12, X13, X14, X15, X16, X17, X18, X19) >
-namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
-namespace typelist
-{
template<typename Fn, typename Typelist>
void
apply(Fn& fn, Typelist)
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @defgroup chrono Time
* @ingroup utilities
*/
namespace chrono
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Rep, typename _Period = ratio<1>>
struct duration;
template<typename _Clock, typename _Dur = typename _Clock::duration>
struct time_point;
-
- _GLIBCXX_END_NAMESPACE_VERSION
}
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
template<typename _CT, typename _Period1, typename _Period2>
common_type<_Duration1, _Duration2>>::type, _Clock>::type
{ };
-_GLIBCXX_END_NAMESPACE_VERSION
-
namespace chrono
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// Primary template for duration_cast impl.
template<typename _ToDur, typename _CF, typename _CR,
bool _NumIsOne = false, bool _DenIsOne = false>
using high_resolution_clock = system_clock;
} // end inline namespace _V2
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace chrono
#if __cplusplus > 201103L
{
inline namespace chrono_literals
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Rep, unsigned long long _Val>
struct _Checked_integral_constant
: integral_constant<_Rep, static_cast<_Rep>(_Val)>
operator""ns()
{ return __check_overflow<chrono::nanoseconds, _Digits...>(); }
- _GLIBCXX_END_NAMESPACE_VERSION
} // inline namespace chrono_literals
} // inline namespace literals
namespace chrono
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
- using namespace literals::chrono_literals;
-
- _GLIBCXX_END_NAMESPACE_VERSION
+ using namespace literals::chrono_literals;
} // namespace chrono
#endif // __cplusplus > 201103L
// @} group chrono
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif //_GLIBCXX_USE_C99_STDINT_TR1
return std::complex<__type>(__x, -__type());
}
-_GLIBCXX_END_NAMESPACE_VERSION
-
#if __cplusplus > 201103L
inline namespace literals {
inline namespace complex_literals {
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
#define __cpp_lib_complex_udls 201309
constexpr std::complex<float>
operator""il(unsigned long long __num)
{ return std::complex<long double>{0.0L, static_cast<long double>(__num)}; }
-_GLIBCXX_END_NAMESPACE_VERSION
} // inline namespace complex_literals
} // inline namespace literals
#endif // C++14
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
#endif // C++11
*/
template<int _Num> struct _Placeholder { };
- _GLIBCXX_END_NAMESPACE_VERSION
-
/** @namespace std::placeholders
* @brief ISO C++11 entities sub-namespace for functional.
* @ingroup binders
*/
namespace placeholders
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
/* Define a large number of placeholders. There is no way to
* simplify this with variadic templates, because we're introducing
* unique names for each.
extern const _Placeholder<27> _27;
extern const _Placeholder<28> _28;
extern const _Placeholder<29> _29;
- _GLIBCXX_END_NAMESPACE_VERSION
}
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* Partial specialization of is_placeholder that provides the placeholder
* number for the placeholder objects defined by libstdc++.
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace __detail
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace __detail
+{
// std::abs is not constexpr and doesn't support unsigned integers.
template<typename _Tp>
constexpr
* __detail::__abs_integral(__n)
: 0;
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
-}
-
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
+} // namespace __detail
#if __cplusplus > 201402L
size_t _M_len;
const _CharT* _M_str;
};
-_GLIBCXX_END_NAMESPACE_VERSION
// [string.view.comparison], non-member basic_string_view comparison function
namespace __detail
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Identity transform to create a non-deduced context, so that only one
// argument participates in template argument deduction and the other
// argument gets implicitly converted to the deduced type. See n3766.html.
template<typename _Tp>
using __idt = common_type_t<_Tp>;
-_GLIBCXX_END_NAMESPACE_VERSION
}
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _CharT, typename _Traits>
inline bool
operator==(basic_string_view<_CharT, _Traits> __x,
struct __is_fast_hash<hash<u32string_view>> : std::false_type
{ };
#endif
-_GLIBCXX_END_NAMESPACE_VERSION
inline namespace literals
{
inline namespace string_view_literals
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
inline constexpr basic_string_view<char>
operator""sv(const char* __str, size_t __len)
{ return basic_string_view<char>{__str, __len}; }
operator""sv(const char32_t* __str, size_t __len)
{ return basic_string_view<char32_t>{__str, __len}; }
#endif
-
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace string_literals
} // namespace literals
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#include <bits/string_view.tcc>
return __out << __id._M_thread;
}
-_GLIBCXX_END_NAMESPACE_VERSION
-
/** @namespace std::this_thread
* @brief ISO C++ 2011 entities sub-namespace for thread.
* 30.3.2 Namespace this_thread.
*/
namespace this_thread
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/// get_id
inline thread::id
get_id() noexcept
__now = _Clock::now();
}
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
}
// @} group threads
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace
#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace __detail
{
namespace __variant
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<size_t _Np, typename... _Types>
struct _Nth_type;
struct _Nth_type<0, _First, _Rest...>
{ using type = _First; };
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __variant
} // namespace __detail
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename... _Types> class tuple;
template<typename... _Types> class variant;
template <typename> struct hash;
constexpr variant_alternative_t<_Np, variant<_Types...>> const&&
get(const variant<_Types...>&&);
-_GLIBCXX_END_NAMESPACE_VERSION
-
namespace __detail
{
namespace __variant
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Returns the first apparence of _Tp in _Types.
// Returns sizeof...(_Types) if _Tp is not in _Types.
template<typename _Tp, typename... _Types>
struct _Traits
{
static constexpr bool _S_default_ctor =
- is_default_constructible_v<typename _Nth_type<0, _Types...>::type>;
+ is_default_constructible_v<typename _Nth_type<0, _Types...>::type>;
static constexpr bool _S_copy_ctor =
- (is_copy_constructible_v<_Types> && ...);
+ (is_copy_constructible_v<_Types> && ...);
static constexpr bool _S_move_ctor =
- (is_move_constructible_v<_Types> && ...);
+ (is_move_constructible_v<_Types> && ...);
static constexpr bool _S_copy_assign =
- _S_copy_ctor && _S_move_ctor
- && (is_copy_assignable_v<_Types> && ...);
+ _S_copy_ctor && _S_move_ctor
+ && (is_copy_assignable_v<_Types> && ...);
static constexpr bool _S_move_assign =
- _S_move_ctor
- && (is_move_assignable_v<_Types> && ...);
+ _S_move_ctor
+ && (is_move_assignable_v<_Types> && ...);
static constexpr bool _S_trivial_dtor =
- (is_trivially_destructible_v<_Types> && ...);
+ (is_trivially_destructible_v<_Types> && ...);
static constexpr bool _S_trivial_copy_ctor =
- (is_trivially_copy_constructible_v<_Types> && ...);
+ (is_trivially_copy_constructible_v<_Types> && ...);
static constexpr bool _S_trivial_move_ctor =
- (is_trivially_move_constructible_v<_Types> && ...);
+ (is_trivially_move_constructible_v<_Types> && ...);
static constexpr bool _S_trivial_copy_assign =
- _S_trivial_dtor && (is_trivially_copy_assignable_v<_Types> && ...);
+ _S_trivial_dtor && (is_trivially_copy_assignable_v<_Types> && ...);
static constexpr bool _S_trivial_move_assign =
- _S_trivial_dtor && (is_trivially_move_assignable_v<_Types> && ...);
+ _S_trivial_dtor && (is_trivially_move_assignable_v<_Types> && ...);
// The following nothrow traits are for non-trivial SMFs. Trivial SMFs
// are always nothrow.
static constexpr bool _S_nothrow_default_ctor =
- is_nothrow_default_constructible_v<
- typename _Nth_type<0, _Types...>::type>;
+ is_nothrow_default_constructible_v<
+ typename _Nth_type<0, _Types...>::type>;
static constexpr bool _S_nothrow_copy_ctor = false;
static constexpr bool _S_nothrow_move_ctor =
- (is_nothrow_move_constructible_v<_Types> && ...);
+ (is_nothrow_move_constructible_v<_Types> && ...);
static constexpr bool _S_nothrow_copy_assign = false;
static constexpr bool _S_nothrow_move_assign =
- _S_nothrow_move_ctor && (is_nothrow_move_assignable_v<_Types> && ...);
+ _S_nothrow_move_ctor && (is_nothrow_move_assignable_v<_Types> && ...);
};
// Defines members and ctors.
template<typename... _Types>
using _Variant_storage_alias =
- _Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>;
+ _Variant_storage<_Traits<_Types...>::_S_trivial_dtor, _Types...>;
// The following are (Copy|Move) (ctor|assign) layers for forwarding
// triviality and handling non-trivial SMF behaviors.
using _Base::_Base;
_Copy_ctor_base(const _Copy_ctor_base& __rhs)
- noexcept(_Traits<_Types...>::_S_nothrow_copy_ctor)
+ noexcept(_Traits<_Types...>::_S_nothrow_copy_ctor)
{
if (__rhs._M_valid())
{
template<typename... _Types>
using _Copy_ctor_alias =
- _Copy_ctor_base<_Traits<_Types...>::_S_trivial_copy_ctor, _Types...>;
+ _Copy_ctor_base<_Traits<_Types...>::_S_trivial_copy_ctor, _Types...>;
template<bool, typename... _Types>
struct _Move_ctor_base : _Copy_ctor_alias<_Types...>
using _Base::_Base;
_Move_ctor_base(_Move_ctor_base&& __rhs)
- noexcept(_Traits<_Types...>::_S_nothrow_move_ctor)
+ noexcept(_Traits<_Types...>::_S_nothrow_move_ctor)
{
if (__rhs._M_valid())
{
template<typename... _Types>
using _Move_ctor_alias =
- _Move_ctor_base<_Traits<_Types...>::_S_trivial_move_ctor, _Types...>;
+ _Move_ctor_base<_Traits<_Types...>::_S_trivial_move_ctor, _Types...>;
template<bool, typename... _Types>
struct _Copy_assign_base : _Move_ctor_alias<_Types...>
_Copy_assign_base&
operator=(const _Copy_assign_base& __rhs)
- noexcept(_Traits<_Types...>::_S_nothrow_copy_assign)
+ noexcept(_Traits<_Types...>::_S_nothrow_copy_assign)
{
if (this->_M_index == __rhs._M_index)
{
template<typename... _Types>
using _Copy_assign_alias =
- _Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign,
- _Types...>;
+ _Copy_assign_base<_Traits<_Types...>::_S_trivial_copy_assign,
+ _Types...>;
template<bool, typename... _Types>
struct _Move_assign_base : _Copy_assign_alias<_Types...>
_Move_assign_base&
operator=(_Move_assign_base&& __rhs)
- noexcept(_Traits<_Types...>::_S_nothrow_move_assign)
+ noexcept(_Traits<_Types...>::_S_nothrow_move_assign)
{
if (this->_M_index == __rhs._M_index)
{
template<typename... _Types>
using _Move_assign_alias =
- _Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign,
- _Types...>;
+ _Move_assign_base<_Traits<_Types...>::_S_trivial_move_assign,
+ _Types...>;
template<typename... _Types>
struct _Variant_base : _Move_assign_alias<_Types...>
constexpr
_Variant_base()
- noexcept(_Traits<_Types...>::_S_nothrow_default_ctor)
+ noexcept(_Traits<_Types...>::_S_nothrow_default_ctor)
: _Variant_base(in_place_index<0>) { }
template<size_t _Np, typename... _Args>
std::index_sequence<__indices...>>
: _Base_dedup<__indices, __poison_hash<remove_const_t<_Types>>>... { };
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __variant
} // namespace __detail
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Tp, typename... _Types>
inline constexpr bool holds_alternative(const variant<_Types...>& __v)
noexcept
class variant
: private __detail::__variant::_Variant_base<_Types...>,
private _Enable_default_constructor<
- __detail::__variant::_Traits<_Types...>::_S_default_ctor,
+ __detail::__variant::_Traits<_Types...>::_S_default_ctor,
variant<_Types...>>,
private _Enable_copy_move<
- __detail::__variant::_Traits<_Types...>::_S_copy_ctor,
- __detail::__variant::_Traits<_Types...>::_S_copy_assign,
- __detail::__variant::_Traits<_Types...>::_S_move_ctor,
- __detail::__variant::_Traits<_Types...>::_S_move_assign,
+ __detail::__variant::_Traits<_Types...>::_S_copy_ctor,
+ __detail::__variant::_Traits<_Types...>::_S_copy_assign,
+ __detail::__variant::_Traits<_Types...>::_S_move_ctor,
+ __detail::__variant::_Traits<_Types...>::_S_move_assign,
variant<_Types...>>
{
private:
using _Base = __detail::__variant::_Variant_base<_Types...>;
using _Default_ctor_enabler =
- _Enable_default_constructor<
- __detail::__variant::_Traits<_Types...>::_S_default_ctor,
- variant<_Types...>>;
+ _Enable_default_constructor<
+ __detail::__variant::_Traits<_Types...>::_S_default_ctor,
+ variant<_Types...>>;
template<typename _Tp>
static constexpr bool
variant(_Tp&& __t)
noexcept(is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp&&>)
: variant(in_place_index<__accepted_index<_Tp&&>>,
- std::forward<_Tp>(__t))
+ std::forward<_Tp>(__t))
{ __glibcxx_assert(holds_alternative<__accepted_type<_Tp&&>>(*this)); }
template<typename _Tp, typename... _Args,
constexpr explicit
variant(in_place_type_t<_Tp>, _Args&&... __args)
: variant(in_place_index<__index_of<_Tp>>,
- std::forward<_Args>(__args)...)
+ std::forward<_Args>(__args)...)
{ __glibcxx_assert(holds_alternative<_Tp>(*this)); }
template<typename _Tp, typename _Up, typename... _Args,
static constexpr bool \
(*_S_erased_##__NAME[])(const variant&, const variant&) = \
{ &__detail::__variant::__erased_##__NAME< \
- const variant&, __indices>... }; \
+ const variant&, __indices>... }; \
template<size_t... __indices> \
constexpr inline bool \
_M_##__NAME(const variant& __rhs, \
#undef _VARIANT_RELATION_FUNCTION_TEMPLATE
template<size_t _Np, typename _Vp>
- friend constexpr decltype(auto) __detail::__variant::
-#if _GLIBCXX_INLINE_VERSION
- __8:: // Required due to PR c++/59256
-#endif
- __get(_Vp&& __v);
+ friend constexpr decltype(auto) __detail::__variant::__get(_Vp&& __v);
template<typename _Vp>
- friend void* __detail::__variant::
-#if _GLIBCXX_INLINE_VERSION
- __8:: // Required due to PR c++/59256
-#endif
- __get_storage(_Vp&& __v);
+ friend void* __detail::__variant::__get_storage(_Vp&& __v);
#define _VARIANT_RELATION_FUNCTION_TEMPLATE(__OP) \
template<typename... _Tp> \
template<typename... _Types>
struct hash<variant<_Types...>>
: private __detail::__variant::_Variant_hash_base<
- variant<_Types...>, std::index_sequence_for<_Types...>>,
+ variant<_Types...>, std::index_sequence_for<_Types...>>,
public __variant_hash_call_base<_Types...>
{
using result_type = size_t;
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
/**
* @brief A standard container for storing a fixed size sequence of elements.
*
inline const _Tp&
get(const array<_Tp, _Nm>& __arr)
{ return __arr[_Int]; }
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
#endif // _GLIBCXX_TR1_ARRAY
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_STD_SPEC_FUNCS
# define _GLIBCXX_MATH_NS ::std
#elif defined(_GLIBCXX_TR1_CMATH)
// Implementation-space details.
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @brief Compute the gamma functions required by the Temme series
* expansions of @f$ N_\nu(x) @f$ and @f$ K_\nu(x) @f$.
return __n_n;
}
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
#undef _GLIBCXX_MATH_NS
#if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH)
} // namespace tr1
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif // _GLIBCXX_TR1_BESSEL_FUNCTION_TCC
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_STD_SPEC_FUNCS
# define _GLIBCXX_MATH_NS ::std
#elif defined(_GLIBCXX_TR1_CMATH)
// Implementation-space details.
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @brief Return the beta function: \f$B(x,y)\f$.
*
else
return __beta_lgamma(__x, __y);
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
#undef _GLIBCXX_MATH_NS
#if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH)
} // namespace tr1
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif // _GLIBCXX_TR1_BETA_FUNCTION_TCC
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
#if _GLIBCXX_USE_C99_MATH_TR1
// Using declarations to bring names from libc's <math.h> into std::tr1.
// @}
-#endif
-_GLIBCXX_END_NAMESPACE_VERSION
-}
-}
-
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-namespace tr1
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
+#endif /* _GLIBCXX_USE_C99_MATH_TR1 */
// DR 550. What should the return type of pow(float,int) be?
// NB: C++11 and TR1 != C++03.
#endif // C++11
-
-
-_GLIBCXX_END_NAMESPACE_VERSION
-}
-}
-
#if _GLIBCXX_USE_STD_SPEC_FUNCS
-namespace std _GLIBCXX_VISIBILITY(default)
-{
-namespace tr1
-{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @defgroup tr1_math_spec_func Mathematical Special Functions
* @ingroup numerics
using std::sph_neumann;
/* @} */ // tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE_VERSION
-}
-}
#else // ! _GLIBCXX_USE_STD_SPEC_FUNCS
+} // namespace tr1
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
#include <bits/stl_algobase.h>
#include <limits>
#include <tr1/type_traits>
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
/**
* @defgroup tr1_math_spec_func Mathematical Special Functions
* @ingroup numerics
}
/* @} */ // tr1_math_spec_func
-_GLIBCXX_END_NAMESPACE_VERSION
-}
-}
#endif // _GLIBCXX_USE_STD_SPEC_FUNCS
+} // namespace tr1
+
+_GLIBCXX_END_NAMESPACE_VERSION
+} // namespace std
+
#endif // _GLIBCXX_TR1_CMATH
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
/**
* @addtogroup complex_numbers
* @{
{ return std::pow(__x, __y); }
// @} group complex_numbers
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
#endif // _GLIBCXX_TR1_COMPLEX
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_STD_SPEC_FUNCS
#elif defined(_GLIBCXX_TR1_CMATH)
namespace tr1
// Implementation-space details.
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @brief Return the Carlson elliptic function @f$ R_F(x,y,z) @f$
* of the first kind.
return __Pi + _Tp(2) * __n * __comp_ellint_3(__k, __nu);
}
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
#if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH)
} // namespace tr1
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif // _GLIBCXX_TR1_ELL_INTEGRAL_TCC
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_STD_SPEC_FUNCS
#elif defined(_GLIBCXX_TR1_CMATH)
namespace tr1
// Implementation-space details.
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _Tp> _Tp __expint_E1(_Tp);
/**
else
return __expint_Ei(__x);
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
#if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH)
} // namespace tr1
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif // _GLIBCXX_TR1_EXP_INTEGRAL_TCC
namespace std _GLIBCXX_VISIBILITY(default)
{
-#if __cplusplus >= 201103L
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+#if __cplusplus >= 201103L
template<int> struct _Placeholder;
template<typename> class _Bind;
template<typename, typename> class _Bind_result;
-_GLIBCXX_END_NAMESPACE_VERSION
#endif
namespace tr1
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _MemberPointer>
class _Mem_fn;
template<typename _Tp, typename _Class>
/// The type of placeholder objects defined by libstdc++.
template<int _Num> struct _Placeholder { };
-_GLIBCXX_END_NAMESPACE_VERSION
-
/** @namespace std::tr1::placeholders
* @brief Sub-namespace for tr1/functional.
*/
namespace placeholders
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
/* Define a large number of placeholders. There is no way to
* simplify this with variadic templates, because we're introducing
* unique names for each.
_Placeholder<28> _28;
_Placeholder<29> _29;
}
- _GLIBCXX_END_NAMESPACE_VERSION
}
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
/**
* Partial specialization of is_placeholder that provides the placeholder
* number for the placeholder objects defined by libstdc++.
inline void
swap(function<_Signature>& __x, function<_Signature>& __y)
{ __x.swap(__y); }
-
-_GLIBCXX_END_NAMESPACE_VERSION
}
#if __cplusplus >= 201103L
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
template<typename> struct is_placeholder;
_Signature>>
: true_type { };
+#endif // C++11
_GLIBCXX_END_NAMESPACE_VERSION
-#endif
}
#endif // _GLIBCXX_TR1_FUNCTIONAL
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
/// Class template hash.
// Declaration of default hash functor std::tr1::hash. The types for
// which std::tr1::hash<T> is well-defined is in clause 6.3.3. of the PDTR.
_GLIBCXX_PURE size_t
hash<const wstring&>::operator()(const wstring&) const;
#endif
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
#endif // _GLIBCXX_TR1_FUNCTIONAL_HASH_H
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_STD_SPEC_FUNCS
# define _GLIBCXX_MATH_NS ::std
#elif defined(_GLIBCXX_TR1_CMATH)
// Implementation-space details.
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @brief This returns Bernoulli numbers from a table or by summation
* for larger values.
return __result;
}
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
#undef _GLIBCXX_MATH_NS
#if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH)
} // namespace tr1
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // _GLIBCXX_TR1_GAMMA_TCC
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
// Class template _Hashtable, class definition.
// Meaning of class template _Hashtable's template parameters
__throw_exception_again;
}
}
+} // namespace tr1
_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace tr1
} // namespace std
#endif // _GLIBCXX_TR1_HASHTABLE_H
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace tr1
{
namespace __detail
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// Helper function: return distance(first, last) for forward
// iterators, or 0 for input iterators.
template<class _Iterator>
_H1 _M_h1;
_H2 _M_h2;
};
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
}
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_STD_SPEC_FUNCS
# define _GLIBCXX_MATH_NS ::std
#elif defined(_GLIBCXX_TR1_CMATH)
// Implementation-space details.
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @brief This routine returns the confluent hypergeometric function
* by series expansion.
else
return __hyperg_luke(__a, __b, __c, __x);
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
#undef _GLIBCXX_MATH_NS
#if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH)
} // namespace tr1
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif // _GLIBCXX_TR1_HYPERGEOMETRIC_TCC
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_STD_SPEC_FUNCS
# define _GLIBCXX_MATH_NS ::std
#elif defined(_GLIBCXX_TR1_CMATH)
// Implementation-space details.
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @brief Return the Legendre polynomial by recursion on order
* @f$ l @f$.
}
}
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
#undef _GLIBCXX_MATH_NS
#if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH)
} // namespace tr1
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif // _GLIBCXX_TR1_LEGENDRE_FUNCTION_TCC
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_STD_SPEC_FUNCS
#elif defined(_GLIBCXX_TR1_CMATH)
namespace tr1
// Implementation-space details.
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @brief Compute the modified Bessel functions @f$ I_\nu(x) @f$ and
* @f$ K_\nu(x) @f$ and their first derivatives
return;
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
#if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH)
} // namespace tr1
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif // _GLIBCXX_TR1_MODIFIED_BESSEL_FUNC_TCC
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_STD_SPEC_FUNCS
#elif defined(_GLIBCXX_TR1_CMATH)
namespace tr1
// Implementation-space details.
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @brief This routine returns the Hermite polynomial
* of order n: \f$ H_n(x) \f$ by recursion on n.
else
return __poly_hermite_recursion(__n, __x);
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
#if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH)
} // namespace tr1
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif // _GLIBCXX_TR1_POLY_HERMITE_TCC
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_STD_SPEC_FUNCS
# define _GLIBCXX_MATH_NS ::std
#elif defined(_GLIBCXX_TR1_CMATH)
// Implementation-space details.
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @brief This routine returns the associated Laguerre polynomial
* of order @f$ n @f$, degree @f$ \alpha @f$ for large n.
inline _Tp
__laguerre(unsigned int __n, _Tp __x)
{ return __poly_laguerre<unsigned int, _Tp>(__n, 0, __x); }
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
#undef _GLIBCXX_MATH_NS
#if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH)
} // namespace tr1
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif // _GLIBCXX_TR1_POLY_LAGUERRE_TCC
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace tr1
{
// [5.1] Random number generation
*/
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<typename _UIntType, int __w,
bool = __w < std::numeric_limits<_UIntType>::digits>
struct _Shift
private:
_Engine* _M_g;
};
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* Produces random numbers on a given distribution function using a
* non-uniform random number generation engine.
/* @} */ // group tr1_random_distributions_continuous
/* @} */ // group tr1_random_distributions
/* @} */ // group tr1_random
-_GLIBCXX_END_NAMESPACE_VERSION
}
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif // _GLIBCXX_TR1_RANDOM_H
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace tr1
{
/*
*/
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// General case for x = (ax + c) mod m -- use Schrage's algorithm to avoid
// integer overflow.
//
__calc(_Tp __x)
{ return __a * __x + __c; }
};
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
template<class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
const _UIntType
linear_congruential<_UIntType, __a, __c, __m>::multiplier;
__os.precision(__precision);
return __os;
}
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace tr1
{
/**
*/
namespace regex_constants
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @name 5.1 Regular Expression Syntax Options
*/
static const error_type error_stack(_S_error_stack);
//@}
-_GLIBCXX_END_NAMESPACE_VERSION
}
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// [7.8] Class regex_error
/**
* @brief A regular expression exception class.
#endif
//@}
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
#endif // _GLIBCXX_TR1_REGEX
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_STD_SPEC_FUNCS
# define _GLIBCXX_MATH_NS ::std
#elif defined(_GLIBCXX_TR1_CMATH)
// Implementation-space details.
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/**
* @brief Compute the Riemann zeta function @f$ \zeta(s) @f$
* by summation for s > 1.
inline _Tp
__hurwitz_zeta(_Tp __a, _Tp __s)
{ return __hurwitz_zeta_glob(__a, __s); }
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
#undef _GLIBCXX_MATH_NS
#if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH)
} // namespace tr1
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif // _GLIBCXX_TR1_RIEMANN_ZETA_TCC
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
/**
* @brief Exception possibly thrown by @c shared_ptr.
* @ingroup exceptions
mutable weak_ptr<_Tp> _M_weak_this;
};
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
#endif // _TR1_SHARED_PTR_H
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#if _GLIBCXX_USE_STD_SPEC_FUNCS
#elif defined(_GLIBCXX_TR1_CMATH)
namespace tr1
#endif
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
/// A class to encapsulate type dependent floating point
/// constants. Not everything will be able to be expressed as
/// type logic.
{ return __builtin_isnanl(__x); }
#endif
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
#if ! _GLIBCXX_USE_STD_SPEC_FUNCS && defined(_GLIBCXX_TR1_CMATH)
} // namespace tr1
#endif
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif // _GLIBCXX_TR1_SPECIAL_FUNCTION_UTIL_H
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
// Adds a const reference to a non-reference type.
template<typename _Tp>
struct __add_c_ref
{
_Swallow_assign ignore;
}; // anonymous namespace
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
#endif // _GLIBCXX_TR1_TUPLE
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
/**
* @addtogroup metaprogramming
* @{
#undef _DEFINE_SPEC
/// @} group metaprogramming
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
#endif // _GLIBCXX_TR1_TYPE_TRAITS
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
// NB: When we get typedef templates these class definitions
// will be unnecessary.
template<class _Key, class _Tp,
swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
{ __x.swap(__y); }
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
// NB: When we get typedef templates these class definitions
// will be unnecessary.
template<class _Value,
swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
{ __x.swap(__y); }
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr1
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr1
+{
template<class _Tp>
class tuple_size;
inline const typename tuple_element<_Int, std::pair<_Tp1, _Tp2> >::type&
get(const std::pair<_Tp1, _Tp2>& __in)
{ return __pair_get<_Int>::__const_get(__in); }
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
#endif // _GLIBCXX_TR1_UTILITY
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr2
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr2
+{
/**
* bool_set
*
inline bool_set
operator!=(bool_set __s, bool_set __t)
{ return ! (__s == __t); }
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
#include <tr2/bool_set.tcc>
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr2
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr2
+{
bool_set::_Bool_set_val
bool_set::_S_not[4] =
{ _S_true_, _S_false, _S_indet, _S_empty };
{ _S_false, _S_true_, _S_indet, _S_empty },
{ _S_indet, _S_indet, _S_indet, _S_empty },
{ _S_empty, _S_empty, _S_empty, _S_empty } };
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
// I object to these things.
// The stuff in locale facets are for basic types.
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr2
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr2
+{
/**
* @defgroup dynamic_bitset Dynamic Bitset.
* @ingroup extensions
/**
* @}
*/
+} // tr2
_GLIBCXX_END_NAMESPACE_VERSION
-} // tr2
} // std
#include <tr2/dynamic_bitset.tcc>
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr2
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr2
+{
// Definitions of non-inline functions from __dynamic_bitset_base.
template<typename _WordT, typename _Alloc>
void
__is.setstate(__state);
return __is;
}
+} // tr2
_GLIBCXX_END_NAMESPACE_VERSION
-} // tr2
} // std
#endif /* _GLIBCXX_TR2_DYNAMIC_BITSET_TCC */
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr2
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr2
+{
template<intmax_t _Pn, size_t _Bit,
bool = _Bit < static_cast<size_t>
(std::numeric_limits<intmax_t>::digits)>
typedef ratio<__safe_lshift<1, 60>::__value, 1> exbi;
//typedef ratio<__safe_lshift<1, 70>::__value, 1> zebi;
//typedef ratio<__safe_lshift<1, 80>::__value, 1> yobi;
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
namespace std _GLIBCXX_VISIBILITY(default)
{
-namespace tr2
-{
_GLIBCXX_BEGIN_NAMESPACE_VERSION
+namespace tr2
+{
/**
* @addtogroup metaprogramming
* @{
};
/// @} group metaprogramming
+}
_GLIBCXX_END_NAMESPACE_VERSION
}
-}
#endif // _GLIBCXX_TR2_TYPE_TRAITS
libstdcxx_printer.add_container('std::', 'forward_list',
StdForwardListPrinter)
- libstdcxx_printer.add_version('std::tr1::', 'shared_ptr', SharedPointerPrinter)
- libstdcxx_printer.add_version('std::tr1::', 'weak_ptr', SharedPointerPrinter)
- libstdcxx_printer.add_version('std::tr1::', 'unordered_map',
+ libstdcxx_printer.add_version('std::', 'tr1::shared_ptr', SharedPointerPrinter)
+ libstdcxx_printer.add_version('std::', 'tr1::weak_ptr', SharedPointerPrinter)
+ libstdcxx_printer.add_version('std::', 'tr1::unordered_map',
Tr1UnorderedMapPrinter)
- libstdcxx_printer.add_version('std::tr1::', 'unordered_set',
+ libstdcxx_printer.add_version('std::', 'tr1::unordered_set',
Tr1UnorderedSetPrinter)
- libstdcxx_printer.add_version('std::tr1::', 'unordered_multimap',
+ libstdcxx_printer.add_version('std::', 'tr1::unordered_multimap',
Tr1UnorderedMapPrinter)
- libstdcxx_printer.add_version('std::tr1::', 'unordered_multiset',
+ libstdcxx_printer.add_version('std::', 'tr1::unordered_multiset',
Tr1UnorderedSetPrinter)
# These are the C++11 printer registrations for -D_GLIBCXX_DEBUG cases.
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace chrono
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// XXX GLIBCXX_ABI Deprecated
inline namespace _V2 {
}
} // end inline namespace _V2
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace chrono
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // _GLIBCXX_USE_C99_STDINT_TR1
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// gcc-4.4.0
// <mutex> exported std::lock_error
#if defined(_GLIBCXX_HAS_GTHREADS) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
constexpr bool system_clock::is_monotonic;
} // namespace chrono
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// gcc-5 replaces this with _V2::error_category
class error_category
{
operator!=(const error_category& __other) const noexcept
{ return this != &__other; }
};
-_GLIBCXX_END_NAMESPACE_VERSION
// gcc-4.9.0
// LWG 2145 changes this constructor to constexpr i.e. inline
const system_error_category system_category_instance{};
}
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
const error_category&
system_category() noexcept { return system_category_instance; }
_GLIBCXX_CONST const error_categoryxx& system_category() noexcept;
_GLIBCXX_CONST const error_categoryxx& generic_category() noexcept;
}
-_GLIBCXX_END_NAMESPACE_VERSION
error_condition
error_category::default_error_condition(int __i) const noexcept
return false;
}
+_GLIBCXX_END_NAMESPACE_VERSION
}
#endif
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace chrono
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// NB: Default configuration was no realtime.
struct system_clock
{
(__from(chrono::seconds(__sec)));
#endif
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace chrono
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // _GLIBCXX_USE_C99_STDINT_TR1
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
// Base class of facet shims, holds a reference to the underlying facet
// that the shim forwards to.
class locale::facet::__shim
namespace __facet_shims
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
namespace // unnamed
{
template<typename C>
bool, ios_base&, wchar_t, long double, const __any_string*);
#endif
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __facet_shims
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// Create a new shim facet of type WHICH that forwards calls to F.
// F is the replacement facet provided by the user, WHICH is the ID of
// F's "other ABI twin" which we are replacing with a shim.
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
#include "../shared/hashtable-aux.cc"
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
// Return a prime no smaller than n.
std::size_t
_Prime_rehash_policy::_M_next_bkt(std::size_t __n) const
else
return std::make_pair(false, 0);
}
+} // namespace __detail
_GLIBCXX_END_NAMESPACE_VERSION
-} // namespace __detail
} // namespace std
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace placeholders
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
extern const _Placeholder<1> _1{};
extern const _Placeholder<2> _2{};
extern const _Placeholder<3> _3{};
extern const _Placeholder<27> _27{};
extern const _Placeholder<28> _28{};
extern const _Placeholder<29> _29{};
- _GLIBCXX_END_NAMESPACE_VERSION
}
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
return __n;
}
-_GLIBCXX_END_NAMESPACE_VERSION
-
namespace this_thread
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
void
__sleep_for(chrono::seconds __s, chrono::nanoseconds __ns)
{
::Sleep(chrono::milliseconds(__s).count() + ms);
#endif
}
-
-_GLIBCXX_END_NAMESPACE_VERSION
}
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // _GLIBCXX_HAS_GTHREADS && _GLIBCXX_USE_C99_STDINT_TR1
namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
template class __mini_vector<
std::pair<bitmap_allocator<char>::_Alloc_block*,
bitmap_allocator<char>::_Alloc_block*> >;
template size_t** __lower_bound(size_t**, size_t**, size_t const&,
free_list::_LT_pointer_compare);
- _GLIBCXX_END_NAMESPACE_VERSION
}
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
-
size_t*
free_list::
_M_get(size_t __sz) throw(std::bad_alloc)
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace tr1
{
#include "../shared/hashtable-aux.cc"
}
+
+_GLIBCXX_END_NAMESPACE_VERSION
}
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
namespace __detail
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
-
void
_List_node_base::swap(_List_node_base& __x,
_List_node_base& __y) _GLIBCXX_USE_NOEXCEPT
__prev_node->_M_next = __next_node;
__next_node->_M_prev = __prev_node;
}
-
- _GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
namespace __detail
{
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
// The sentinel value is kept only for abi backward compatibility.
extern const unsigned long __prime_list[] = // 256 + 1 or 256 + 48 + 1
{
18446744073709551557ul, 18446744073709551557ul
#endif
};
-_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __detail
// std::numeric_limits<int64_t>::max() == 9223372036854775807;
auto h = 9223372036854775808h;
- // { dg-error "cannot be represented" "" { target *-*-* } 892 }
+ // { dg-error "cannot be represented" "" { target *-*-* } 880 }
}
// { dg-prune-output "in constexpr expansion" } // needed for -O0
test_type d; // { dg-error "required from here" }
}
-// { dg-error "rep cannot be a duration" "" { target *-*-* } 308 }
+// { dg-error "rep cannot be a duration" "" { target *-*-* } 300 }
test_type d; // { dg-error "required from here" }
}
-// { dg-error "must be a specialization of ratio" "" { target *-*-* } 309 }
+// { dg-error "must be a specialization of ratio" "" { target *-*-* } 301 }
// { dg-prune-output "not a member" }
test_type d; // { dg-error "required from here" }
}
-// { dg-error "period must be positive" "" { target *-*-* } 311 }
+// { dg-error "period must be positive" "" { target *-*-* } 303 }
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
-// { dg-error "static assertion failed" "" { target *-*-* } 86 }
+// { dg-error "static assertion failed" "" { target *-*-* } 87 }
#include <list>
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
-// { dg-error "static assertion failed" "" { target *-*-* } 86 }
+// { dg-error "static assertion failed" "" { target *-*-* } 87 }
#include <utility>
std::gcd(0.1, 0.1); // { dg-error "from here" }
}
-// { dg-error "integers" "" { target *-*-* } 134 }
-// { dg-error "integers" "" { target *-*-* } 135 }
-// { dg-error "not bools" "" { target *-*-* } 136 }
-// { dg-error "not bools" "" { target *-*-* } 137 }
+// { dg-error "integers" "" { target *-*-* } 130 }
+// { dg-error "integers" "" { target *-*-* } 131 }
+// { dg-error "not bools" "" { target *-*-* } 132 }
+// { dg-error "not bools" "" { target *-*-* } 133 }
// { dg-prune-output "deleted function" }
// { dg-prune-output "invalid operands" }
std::lcm(0.1, 0.1); // { dg-error "from here" }
}
-// { dg-error "integers" "" { target *-*-* } 147 }
-// { dg-error "integers" "" { target *-*-* } 148 }
-// { dg-error "not bools" "" { target *-*-* } 149 }
-// { dg-error "not bools" "" { target *-*-* } 150 }
+// { dg-error "integers" "" { target *-*-* } 143 }
+// { dg-error "integers" "" { target *-*-* } 144 }
+// { dg-error "not bools" "" { target *-*-* } 145 }
+// { dg-error "not bools" "" { target *-*-* } 146 }
// { dg-prune-output "deleted function" }
// { dg-prune-output "invalid operands" }
auto x = std::generate_canonical<std::size_t,
std::numeric_limits<std::size_t>::digits>(urng);
-// { dg-error "static assertion failed: template argument must be a floating point type" "" { target *-*-* } 160 }
+// { dg-error "static assertion failed: template argument must be a floating point type" "" { target *-*-* } 156 }
-// { dg-error "static assertion failed: template argument must be a floating point type" "" { target *-*-* } 3314 }
+// { dg-error "static assertion failed: template argument must be a floating point type" "" { target *-*-* } 3311 }
projects / gcc.git / commitdiff