30#ifndef _GLIBCXX_UNICODE_H
31#define _GLIBCXX_UNICODE_H 1
33#if __cplusplus >= 202002L
44namespace std _GLIBCXX_VISIBILITY(default)
46_GLIBCXX_BEGIN_NAMESPACE_VERSION
51 __is_scalar_value(
char32_t __c)
53 if (__c < 0xD800) [[likely]]
55 return 0xDFFF < __c && __c <= 0x10FFFF;
59 template<
typename _CharT>
61 __is_single_code_unit(
char32_t __c)
66 return __c < __gnu_cxx::__int_traits<_CharT>::__max
67 && __is_scalar_value(__c);
75 operator()() const noexcept
79 struct _Null_sentinel_t
81 template<input_iterator _It>
82 requires default_initializable<iter_value_t<_It>>
83 && equality_comparable_with<iter_reference_t<_It>, iter_value_t<_It>>
85 operator==(_It __it, _Null_sentinel_t)
86 {
return *__it == iter_value_t<_It>{}; }
89 template<
typename _FromFmt,
typename _ToFmt,
90 input_iterator _Iter, sentinel_for<_Iter> _Sent = _Iter,
91 typename _ErrorHandler = _Repl>
92 requires convertible_to<iter_value_t<_Iter>, _FromFmt>
95 static_assert(forward_iterator<_Iter> ||
noexcept(_ErrorHandler()()));
98 using value_type = _ToFmt;
99 using difference_type = iter_difference_t<_Iter>;
100 using reference = value_type;
101 using iterator_concept
102 = std::__detail::__clamp_iter_cat<__iter_category_t<_Iter>,
103 bidirectional_iterator_tag>;
105 constexpr _Utf_iterator() =
default;
108 _Utf_iterator(_Iter __first, _Iter __it, _Sent __last)
109 requires bidirectional_iterator<_Iter>
110 : _M_first_and_curr{__first, __it}, _M_last(__last)
112 if (_M_curr() != _M_last)
119 _Utf_iterator(_Iter __it, _Sent __last)
120 requires (!bidirectional_iterator<_Iter>)
121 : _M_first_and_curr{__it}, _M_last(__last)
123 if (_M_curr() != _M_last)
129 template<
class _Iter2,
class _Sent2>
130 requires convertible_to<_Iter2, _Iter> && convertible_to<_Sent2, _Sent>
132 _Utf_iterator(
const _Utf_iterator<_FromFmt, _ToFmt, _Iter2, _Sent2,
133 _ErrorHandler>& __other)
134 : _M_buf(__other._M_buf), _M_first_and_curr(__other._M_first_and_curr),
135 _M_buf_index(__other._M_buf_index), _M_buf_last(__other._M_buf_last),
136 _M_last(__other._M_last)
141 begin() const requires bidirectional_iterator<_Iter>
142 {
return _M_first(); }
146 end()
const {
return _M_last; }
150 base() const requires forward_iterator<_Iter>
151 {
return _M_curr(); }
154 constexpr iter_difference_t<_Iter>
155 _M_units() const requires forward_iterator<_Iter>
156 {
return _M_to_increment; }
160 operator*()
const {
return _M_buf[_M_buf_index]; }
162 constexpr _Utf_iterator&
165 if (_M_buf_index + 1 == _M_buf_last && _M_curr() != _M_last)
167 if constexpr (forward_iterator<_Iter>)
169 if (_M_curr() == _M_last)
174 else if (_M_buf_index + 1 < _M_buf_last)
179 constexpr _Utf_iterator
187 constexpr _Utf_iterator&
188 operator--()
requires bidirectional_iterator<_Iter>
190 if (!_M_buf_index && _M_curr() != _M_first())
192 else if (_M_buf_index)
197 constexpr _Utf_iterator
206 friend constexpr bool
207 operator==(_Utf_iterator __lhs, _Utf_iterator __rhs)
208 requires forward_iterator<_Iter> ||
requires (_Iter __i) { __i != __i; }
210 if constexpr (forward_iterator<_Iter>)
211 return __lhs._M_curr() == __rhs._M_curr()
212 && __lhs._M_buf_index == __rhs._M_buf_index;
213 else if (__lhs._M_curr() != __rhs._M_curr())
215 else if (__lhs._M_buf_index == __rhs._M_buf_index
216 && __lhs._M_buf_last == __rhs._M_buf_last)
219 return __lhs._M_buf_index == __lhs._M_buf_last
220 && __rhs._M_buf_index == __rhs._M_buf_last;
224 friend constexpr bool
225 operator==(_Utf_iterator __lhs, _Sent __rhs)
227 if constexpr (forward_iterator<_Iter>)
228 return __lhs._M_curr() == __rhs;
230 return __lhs._M_curr() == __rhs
231 && __lhs._M_buf_index == __lhs._M_buf_last;
238 if constexpr (
sizeof(_FromFmt) ==
sizeof(uint8_t))
240 else if constexpr (
sizeof(_FromFmt) ==
sizeof(uint16_t))
244 static_assert(
sizeof(_FromFmt) ==
sizeof(uint32_t));
255 _Guard(
void*, _Iter&) { }
258 template<
typename _It>
requires forward_iterator<_It>
261 constexpr ~_Guard() { _M_this->_M_curr() =
std::move(_M_orig); }
262 _Utf_iterator* _M_this;
269 _Guard<_Iter> __g{
this, _M_curr()};
271 const uint8_t __lo_bound = 0x80, __hi_bound = 0xBF;
272 uint8_t __u = *_M_curr()++;
273 uint8_t __to_incr = 1;
274 auto __incr = [&,
this] {
279 if (__u <= 0x7F) [[likely]]
281 else if (__u < 0xC2) [[unlikely]]
283 else if (_M_curr() == _M_last) [[unlikely]]
285 else if (__u <= 0xDF)
290 if (__u < __lo_bound || __u > __hi_bound) [[unlikely]]
294 __c = (__c << 6) | (__u & 0x3F);
298 else if (__u <= 0xEF)
300 const uint8_t __lo_bound_2 = __u == 0xE0 ? 0xA0 : __lo_bound;
301 const uint8_t __hi_bound_2 = __u == 0xED ? 0x9F : __hi_bound;
306 if (__u < __lo_bound_2 || __u > __hi_bound_2) [[unlikely]]
308 else if (__incr() == _M_last) [[unlikely]]
312 __c = (__c << 6) | (__u & 0x3F);
315 if (__u < __lo_bound || __u > __hi_bound) [[unlikely]]
319 __c = (__c << 6) | (__u & 0x3F);
324 else if (__u <= 0xF4)
326 const uint8_t __lo_bound_2 = __u == 0xF0 ? 0x90 : __lo_bound;
327 const uint8_t __hi_bound_2 = __u == 0xF4 ? 0x8F : __hi_bound;
332 if (__u < __lo_bound_2 || __u > __hi_bound_2) [[unlikely]]
334 else if (__incr() == _M_last) [[unlikely]]
338 __c = (__c << 6) | (__u & 0x3F);
341 if (__u < __lo_bound || __u > __hi_bound) [[unlikely]]
343 else if (__incr() == _M_last) [[unlikely]]
347 __c = (__c << 6) | (__u & 0x3F);
350 if (__u < __lo_bound || __u > __hi_bound) [[unlikely]]
354 __c = (__c << 6) | (__u & 0x3F);
363 _M_update(__c, __to_incr);
369 _Guard<_Iter> __g{
this, _M_curr()};
371 uint16_t __u = *_M_curr()++;
372 uint8_t __to_incr = 1;
374 if (__u < 0xD800 || __u > 0xDFFF) [[likely]]
376 else if (__u < 0xDC00 && _M_curr() != _M_last)
378 uint16_t __u2 = *_M_curr();
379 if (__u2 < 0xDC00 || __u2 > 0xDFFF) [[unlikely]]
385 uint32_t __x = (__u & 0x3F) << 10 | (__u2 & 0x3FF);
386 uint32_t __w = (__u >> 6) & 0x1F;
387 __c = (__w + 1) << 16 | __x;
393 _M_update(__c, __to_incr);
399 _Guard<_Iter> __g{
this, _M_curr()};
400 char32_t __c = *_M_curr()++;
401 if (!__is_scalar_value(__c)) [[unlikely]]
408 _M_update(
char32_t __c, uint8_t __to_incr)
410 _M_to_increment = __to_incr;
412 if constexpr (
sizeof(_ToFmt) ==
sizeof(uint32_t))
417 else if constexpr (
sizeof(_ToFmt) ==
sizeof(uint16_t))
419 if (__is_single_code_unit<_ToFmt>(__c))
428 const char32_t __lead_offset = 0xD800 - (0x10000 >> 10);
429 char16_t __lead = __lead_offset + (__c >> 10);
430 char16_t __trail = 0xDC00 + (__c & 0x3FF);
438 static_assert(
sizeof(_ToFmt) == 1);
439 int __bits = std::bit_width((uint32_t)__c);
440 if (__bits <= 7) [[likely]]
443 _M_buf[1] = _M_buf[2] = _M_buf[3] = 0;
446 else if (__bits <= 11)
448 _M_buf[0] = 0xC0 | (__c >> 6);
449 _M_buf[1] = 0x80 | (__c & 0x3F);
450 _M_buf[2] = _M_buf[3] = 0;
453 else if (__bits <= 16)
455 _M_buf[0] = 0xE0 | (__c >> 12);
456 _M_buf[1] = 0x80 | ((__c >> 6) & 0x3F);
457 _M_buf[2] = 0x80 | (__c & 0x3F);
463 _M_buf[0] = 0xF0 | ((__c >> 18) & 0x07);
464 _M_buf[1] = 0x80 | ((__c >> 12) & 0x3F);
465 _M_buf[2] = 0x80 | ((__c >> 6) & 0x3F);
466 _M_buf[3] = 0x80 | (__c & 0x3F);
475 char32_t __c = _ErrorHandler()();
476 __glibcxx_assert(__is_scalar_value(__c));
481 _M_first() const requires bidirectional_iterator<_Iter>
482 {
return _M_first_and_curr._M_first; }
485 _M_curr() {
return _M_first_and_curr._M_curr; }
488 _M_curr()
const {
return _M_first_and_curr._M_curr; }
490 array<value_type, 4 /
sizeof(_ToFmt)> _M_buf;
492 template<
typename _It>
493 struct _First_and_curr
495 _First_and_curr() =
default;
498 _First_and_curr(_It __curr) : _M_curr(__curr) { }
500 template<convertible_to<_It> _It2>
502 _First_and_curr(
const _First_and_curr<_It2>& __other)
503 : _M_curr(__other._M_curr) { }
508 template<
typename _It>
requires bidirectional_iterator<_It>
509 struct _First_and_curr<_It>
511 _First_and_curr() =
default;
514 _First_and_curr(_It __first, _It __curr)
515 : _M_first(__first), _M_curr(__curr) { }
517 template<convertible_to<_It> _It2>
519 _First_and_curr(
const _First_and_curr<_It2>& __other)
520 : _M_first(__other._M_first), _M_curr(__other._M_curr) { }
526 _First_and_curr<_Iter> _M_first_and_curr;
528 uint8_t _M_buf_index = 0;
529 uint8_t _M_buf_last = 0;
530 uint8_t _M_to_increment = 0;
532 [[no_unique_address]] _Sent _M_last;
534 template<
typename _FromFmt2,
typename _ToFmt2,
535 input_iterator _Iter2, sentinel_for<_Iter2> _Sent2,
536 typename _ErrHandler>
537 requires convertible_to<iter_value_t<_Iter2>, _FromFmt2>
538 friend class _Utf_iterator;
541 template<
typename _ToFormat, ranges::input_range _Range>
543 :
public ranges::view_interface<_Utf_view<_ToFormat, _Range>>
545 using _Iterator = _Utf_iterator<ranges::range_value_t<_Range>,
546 _ToFormat, ranges::iterator_t<_Range>,
547 ranges::sentinel_t<_Range>>;
549 template<
typename _Iter,
typename _Sent>
551 _M_begin(_Iter __first, _Sent __last)
553 if constexpr (bidirectional_iterator<_Iter>)
554 return _Iterator(__first, __first, __last);
556 return _Iterator(__first, __last);
559 template<
typename _Iter,
typename _Sent>
561 _M_end(_Iter __first, _Sent __last)
563 if constexpr (!is_same_v<_Iter, _Sent>)
565 else if constexpr (bidirectional_iterator<_Iter>)
566 return _Iterator(__first, __last, __last);
568 return _Iterator(__last, __last);
575 _Utf_view(_Range&& __r) : _M_base(
std::
forward<_Range>(__r)) { }
577 constexpr auto begin()
578 {
return _M_begin(ranges::begin(_M_base), ranges::end(_M_base)); }
581 {
return _M_end(ranges::begin(_M_base), ranges::end(_M_base)); }
583 constexpr bool empty()
const {
return ranges::empty(_M_base); }
587 template<
typename _View>
588 using _Utf8_view = _Utf_view<char8_t, _View>;
590 template<
typename _View>
591 using _Utf8_view = _Utf_view<char, _View>;
593 template<
typename _View>
594 using _Utf16_view = _Utf_view<char16_t, _View>;
595 template<
typename _View>
596 using _Utf32_view = _Utf_view<char32_t, _View>;
598inline namespace __v16_0_0
600#define _GLIBCXX_GET_UNICODE_DATA 160000
602#ifdef _GLIBCXX_GET_UNICODE_DATA
603# error "Invalid unicode data"
608 __field_width(
char32_t __c)
noexcept
610 if (__c < __width_edges[0]) [[likely]]
613 auto* __p = std::upper_bound(__width_edges,
std::end(__width_edges), __c);
614 return (__p - __width_edges) % 2 + 1;
619 __should_escape_category(
char32_t __c)
noexcept
621 constexpr uint32_t __mask = 0x01;
622 auto* __end =
std::end(__escape_edges);
623 auto* __p = std::lower_bound(__escape_edges, __end,
625 return __p[-1] & __mask;
630 constexpr _Gcb_property
631 __grapheme_cluster_break_property(
char32_t __c)
noexcept
633 constexpr uint32_t __mask = (1 << __gcb_shift_bits) - 1;
634 auto* __end =
std::end(__gcb_edges);
635 auto* __p = std::lower_bound(__gcb_edges, __end,
636 (__c << __gcb_shift_bits) | __mask);
637 return _Gcb_property(__p[-1] & __mask);
641 __is_incb_linker(
char32_t __c)
noexcept
643 const auto __end =
std::end(__incb_linkers);
645 return _GLIBCXX_STD_A::find(__incb_linkers, __end, __c) != __end;
650 __incb_property(
char32_t __c)
noexcept
652 if ((__c << 2) < __incb_edges[0]) [[likely]]
655 constexpr uint32_t __mask = 0x3;
656 auto* __end =
std::end(__incb_edges);
657 auto* __p = std::lower_bound(__incb_edges, __end, (__c << 2) | __mask);
658 return _InCB(__p[-1] & __mask);
662 __is_extended_pictographic(
char32_t __c)
664 if (__c < __xpicto_edges[0]) [[likely]]
667 auto* __p = std::upper_bound(__xpicto_edges,
std::end(__xpicto_edges), __c);
668 return (__p - __xpicto_edges) % 2;
671 struct _Grapheme_cluster_iterator_base
674 _Gcb_property _M_prop;
675 enum class _XPicto :
unsigned char { _Init, _Zwj, _Matched, _Failed };
676 _XPicto _M_xpicto_seq_state = _XPicto::_Init;
677 unsigned char _M_RI_count = 0;
678 bool _M_incb_linker_seen =
false;
681 _M_reset(
char32_t __c, _Gcb_property __p)
685 _M_xpicto_seq_state = _XPicto::_Init;
687 _M_incb_linker_seen =
false;
691 _M_update_xpicto_seq_state(
char32_t __c, _Gcb_property __p)
693 if (_M_xpicto_seq_state == _XPicto::_Failed)
696 auto __next_state = _XPicto::_Failed;
697 if (_M_xpicto_seq_state != _XPicto::_Zwj)
699 if (__p == _Gcb_property::_Gcb_ZWJ)
701 if (_M_xpicto_seq_state == _XPicto::_Matched)
702 __next_state = _XPicto::_Zwj;
705 else if (__is_extended_pictographic(_M_c))
706 __next_state = _XPicto::_Zwj;
708 else if (__p == _Gcb_property::_Gcb_Extend)
709 __next_state = _M_xpicto_seq_state;
715 if (__p == _Gcb_property::_Gcb_Other
716 && __is_extended_pictographic(__c))
717 __next_state = _XPicto::_Matched;
719 _M_xpicto_seq_state = __next_state;
723 _M_update_ri_count(_Gcb_property __p)
725 if (__p == _Gcb_property::_Gcb_Regional_Indicator)
732 _M_update_incb_state(
char32_t __c, _Gcb_property)
734 if (__is_incb_linker(__c))
735 _M_incb_linker_seen =
true;
740 template<ranges::forward_range _View>
requires ranges::view<_View>
741 class _Grapheme_cluster_view
742 :
public ranges::view_interface<_Grapheme_cluster_view<_View>>
747 _Grapheme_cluster_view(_View __v)
751 constexpr auto begin()
const {
return _M_begin; }
752 constexpr auto end()
const {
return _M_begin.end(); }
755 struct _Iterator :
private _Grapheme_cluster_iterator_base
759 using _U32_iterator = ranges::iterator_t<_Utf32_view<_View>>;
767 using value_type = char32_t;
768 using iterator_concept = forward_iterator_tag;
769 using difference_type = ptrdiff_t;
772 _Iterator(_U32_iterator __i)
775 if (__i != __i.end())
778 _M_prop = __grapheme_cluster_break_property(_M_c);
795 const auto __end = _M_base.end();
796 if (_M_base != __end)
798 auto __p_prev = _M_prop;
800 while (++__it != __end)
802 char32_t __c = *__it;
803 auto __p = __grapheme_cluster_break_property(*__it);
804 _M_update_xpicto_seq_state(__c, __p);
805 _M_update_ri_count(__p);
806 _M_update_incb_state(__c, __p);
807 if (_M_is_break(__p_prev, __p, __it))
829 operator==(
const _Iterator& __i)
const
830 {
return _M_base == __i._M_base; }
834 operator==(
const ranges::sentinel_t<_View>& __i)
const
835 {
return _M_base == __i; }
838 constexpr auto base()
const {
return _M_base.base(); }
841 constexpr auto end()
const {
return _M_base.end(); }
845 width() const noexcept
846 {
return __field_width(_M_c); }
849 _U32_iterator _M_base;
857 _M_is_break(_Gcb_property __p1, _Gcb_property __p2,
858 _U32_iterator __curr)
const
860 using enum _Gcb_property;
862 if (__p1 == _Gcb_Control || __p1 == _Gcb_LF)
866 return __p2 != _Gcb_LF;
869 if (__p2 == _Gcb_Control || __p2 == _Gcb_CR || __p2 == _Gcb_LF)
886 if (__p1 == _Gcb_LV || __p1 == _Gcb_V)
897 if (__p1 == _Gcb_LVT || __p1 == _Gcb_T)
898 return __p2 != _Gcb_T;
901 if (__p2 == _Gcb_Extend || __p2 == _Gcb_ZWJ)
908 if (__p2 == _Gcb_SpacingMark)
911 if (__p1 == _Gcb_Prepend)
917 if (_M_incb_linker_seen
918 && __incb_property(_M_c) == _InCB::_Consonant
919 && __incb_property(*__curr) == _InCB::_Consonant)
923 bool __have_linker =
false;
925 while (++__it != __curr)
927 if (__is_incb_linker(*__it))
928 __have_linker =
true;
931 auto __incb = __incb_property(*__it);
932 if (__incb == _InCB::_Consonant)
933 __have_linker =
false;
934 else if (__incb != _InCB::_Extend)
938 if (__it == __curr && __have_linker)
945 if (__p1 == _Gcb_ZWJ && _M_xpicto_seq_state == _XPicto::_Matched)
952 if (__p1 == _Gcb_property::_Gcb_Regional_Indicator && __p1 == __p2)
953 return (_M_RI_count & 1) == 0;
966 template<
typename _CharT>
968 __field_width(basic_string_view<_CharT> __s)
970 if (__s.empty()) [[unlikely]]
972 _Grapheme_cluster_view<basic_string_view<_CharT>> __gc(__s);
973 auto __it = __gc.begin();
974 const auto __end = __gc.end();
975 size_t __n = __it.width();
976 while (++__it != __end)
983 template<
typename _CharT>
985 __truncate(basic_string_view<_CharT>& __s,
size_t __max)
987 if (__s.empty()) [[unlikely]]
990 _Grapheme_cluster_view<basic_string_view<_CharT>> __gc(__s);
991 auto __it = __gc.begin();
992 const auto __end = __gc.end();
993 size_t __n = __it.width();
999 while (++__it != __end)
1001 size_t __n2 = __n + __it.width();
1004 __s = basic_string_view<_CharT>(__s.begin(), __it.base());
1012 template<
typename _CharT>
1014 __literal_encoding_is_unicode()
1016 if constexpr (is_same_v<_CharT, char16_t>)
1018 else if constexpr (is_same_v<_CharT, char32_t>)
1021 else if constexpr (is_same_v<_CharT, char8_t>)
1025 const char* __enc =
"";
1027#ifdef __GNUC_EXECUTION_CHARSET_NAME
1028 auto __remove_iso10646_prefix = [](
const char* __s) {
1030 if (__s[0] ==
'I' || __s[0] ==
'i')
1031 if (__s[1] ==
'S' || __s[1] ==
's')
1032 if (__s[2] ==
'O' || __s[2] ==
'o')
1033 if (string_view(__s + 3).starts_with(
"-10646/"))
1038 if constexpr (is_same_v<_CharT, char>)
1039 __enc = __remove_iso10646_prefix(__GNUC_EXECUTION_CHARSET_NAME);
1040# if defined _GLIBCXX_USE_WCHAR_T && defined __GNUC_WIDE_EXECUTION_CHARSET_NAME
1042 __enc = __remove_iso10646_prefix(__GNUC_WIDE_EXECUTION_CHARSET_NAME);
1045 if ((__enc[0] ==
'U' || __enc[0] ==
'u')
1046 && (__enc[1] ==
'T' || __enc[1] ==
't')
1047 && (__enc[2] ==
'F' || __enc[2] ==
'f'))
1050 if (__enc[0] ==
'-')
1052 if (__enc[0] ==
'8')
1053 return __enc[1] ==
'\0' || string_view(__enc + 1) ==
"//";
1054 else if constexpr (!is_same_v<_CharT, char>)
1056 string_view __s(__enc);
1057 if (__s.ends_with(
"//"))
1058 __s.remove_suffix(2);
1059 if (__s.ends_with(
"LE") || __s.ends_with(
"BE"))
1060 __s.remove_suffix(2);
1061 return __s ==
"16" || __s ==
"32";
1064#elif defined __clang_literal_encoding__
1065 if constexpr (is_same_v<_CharT, char>)
1066 __enc = __clang_literal_encoding__;
1067# if defined _GLIBCXX_USE_WCHAR_T && defined __clang_wide_literal_encoding__
1069 __enc = __clang_wide_literal_encoding__;
1072 string_view __s(__enc);
1075 else if constexpr (!is_same_v<_CharT, char>)
1076 return __s ==
"UTF-16" || __s ==
"UTF-32";
1083 __literal_encoding_is_utf8()
1084 {
return __literal_encoding_is_unicode<char>(); }
1087 __literal_encoding_is_extended_ascii()
1089 return '0' == 0x30 &&
'A' == 0x41 &&
'Z' == 0x5a
1090 &&
'a' == 0x61 &&
'z' == 0x7a;
1095 __charset_alias_match(string_view __a, string_view __b)
1098 auto __map = [](
char __c,
bool& __num) ->
unsigned char {
1099 if (__c ==
'0') [[unlikely]]
1100 return __num ? 0 : 127;
1101 const auto __v = __detail::__from_chars_alnum_to_val(__c);
1106 auto __ptr_a = __a.begin(), __end_a = __a.end();
1107 auto __ptr_b = __b.begin(), __end_b = __b.end();
1108 bool __num_a =
false, __num_b =
false;
1113 unsigned char __val_a{}, __val_b{};
1114 while (__ptr_a != __end_a
1115 && (__val_a = __map(*__ptr_a, __num_a)) == 127)
1117 while (__ptr_b != __end_b
1118 && (__val_b = __map(*__ptr_b, __num_b)) == 127)
1121 if (__ptr_a == __end_a)
1122 return __ptr_b == __end_b;
1123 else if (__ptr_b == __end_b)
1125 else if (__val_a != __val_b)
1137 template<
typename _To,
typename _Range>
1138 inline constexpr bool
1139 enable_borrowed_range<std::__unicode::_Utf_view<_To, _Range>>
1140 = enable_borrowed_range<_Range>;
1142 template<
typename _Range>
1143 inline constexpr bool
1144 enable_borrowed_range<std::__unicode::_Grapheme_cluster_view<_Range>>
1145 = enable_borrowed_range<_Range>;
1148_GLIBCXX_END_NAMESPACE_VERSION
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
_Tp * end(valarray< _Tp > &__va) noexcept
Return an iterator pointing to one past the last element of the valarray.
_Tp * begin(valarray< _Tp > &__va) noexcept
Return an iterator pointing to the first element of the valarray.
ISO C++ entities toplevel namespace is std.
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
__numeric_traits_integer< _Tp > __int_traits
Convenience alias for __numeric_traits<integer-type>.