29#ifndef _GLIBCXX_FORMAT
30#define _GLIBCXX_FORMAT 1
32#pragma GCC system_header
36#define __glibcxx_want_format
37#define __glibcxx_want_format_ranges
38#define __glibcxx_want_format_uchar
41#ifdef __cpp_lib_format
62#if !__has_builtin(__builtin_toupper)
66namespace std _GLIBCXX_VISIBILITY(default)
68_GLIBCXX_BEGIN_NAMESPACE_VERSION
71 template<
typename _Out,
typename _CharT>
class basic_format_context;
74 template<
typename _CharT,
typename... _Args>
struct basic_format_string;
80 template<
typename _CharT>
class _Sink;
82 template<
typename _CharT>
85 template<
typename _CharT>
86 using __format_context = basic_format_context<_Sink_iter<_CharT>, _CharT>;
88 template<
typename _CharT>
89 struct _Runtime_format_string
91 [[__gnu__::__always_inline__]]
92 _Runtime_format_string(basic_string_view<_CharT> __s) noexcept
95 _Runtime_format_string(
const _Runtime_format_string&) =
delete;
96 void operator=(
const _Runtime_format_string&) =
delete;
99 basic_string_view<_CharT> _M_str;
101 template<
typename,
typename...>
friend struct std::basic_format_string;
106 using format_context = __format::__format_context<char>;
107#ifdef _GLIBCXX_USE_WCHAR_T
108 using wformat_context = __format::__format_context<wchar_t>;
112 template<
typename _Context>
class basic_format_args;
113 using format_args = basic_format_args<format_context>;
114#ifdef _GLIBCXX_USE_WCHAR_T
115 using wformat_args = basic_format_args<wformat_context>;
120 template<
typename _Context>
121 class basic_format_arg;
127 template<
typename _CharT,
typename... _Args>
128 struct basic_format_string
130 template<
typename _Tp>
131 requires convertible_to<const _Tp&, basic_string_view<_CharT>>
133 basic_format_string(
const _Tp& __s);
135 [[__gnu__::__always_inline__]]
136 basic_format_string(__format::_Runtime_format_string<_CharT> __s) noexcept
140 [[__gnu__::__always_inline__]]
141 constexpr basic_string_view<_CharT>
146 basic_string_view<_CharT> _M_str;
149 template<
typename... _Args>
150 using format_string = basic_format_string<char, type_identity_t<_Args>...>;
152#ifdef _GLIBCXX_USE_WCHAR_T
153 template<
typename... _Args>
155 = basic_format_string<wchar_t, type_identity_t<_Args>...>;
158#if __cplusplus > 202302L
159 [[__gnu__::__always_inline__]]
160 inline __format::_Runtime_format_string<char>
161 runtime_format(string_view __fmt)
noexcept
164#ifdef _GLIBCXX_USE_WCHAR_T
165 [[__gnu__::__always_inline__]]
166 inline __format::_Runtime_format_string<wchar_t>
167 runtime_format(wstring_view __fmt)
noexcept
175 template<
typename _Tp,
typename _CharT =
char>
178 formatter() =
delete;
179 formatter(
const formatter&) =
delete;
180 formatter& operator=(
const formatter&) =
delete;
184 class format_error :
public runtime_error
187 explicit format_error(
const string& __what) : runtime_error(__what) { }
188 explicit format_error(
const char* __what) : runtime_error(__what) { }
194 __throw_format_error(
const char* __what)
195 { _GLIBCXX_THROW_OR_ABORT(format_error(__what)); }
203 __unmatched_left_brace_in_format_string()
204 { __throw_format_error(
"format error: unmatched '{' in format string"); }
208 __unmatched_right_brace_in_format_string()
209 { __throw_format_error(
"format error: unmatched '}' in format string"); }
213 __conflicting_indexing_in_format_string()
214 { __throw_format_error(
"format error: conflicting indexing style in format string"); }
218 __invalid_arg_id_in_format_string()
219 { __throw_format_error(
"format error: invalid arg-id in format string"); }
223 __failed_to_parse_format_spec()
224 { __throw_format_error(
"format error: failed to parse format-spec"); }
229 template<
typename _CharT>
class basic_format_parse_context;
230 using format_parse_context = basic_format_parse_context<char>;
231#ifdef _GLIBCXX_USE_WCHAR_T
232 using wformat_parse_context = basic_format_parse_context<wchar_t>;
235 template<
typename _CharT>
236 class basic_format_parse_context
239 using char_type = _CharT;
240 using const_iterator =
typename basic_string_view<_CharT>::const_iterator;
241 using iterator = const_iterator;
244 basic_format_parse_context(basic_string_view<_CharT> __fmt,
245 size_t __num_args = 0) noexcept
246 : _M_begin(__fmt.
begin()), _M_end(__fmt.
end()), _M_num_args(__num_args)
249 basic_format_parse_context(
const basic_format_parse_context&) =
delete;
250 void operator=(
const basic_format_parse_context&) =
delete;
252 constexpr const_iterator
begin() const noexcept {
return _M_begin; }
253 constexpr const_iterator
end() const noexcept {
return _M_end; }
256 advance_to(const_iterator __it)
noexcept
262 if (_M_indexing == _Manual)
263 __format::__conflicting_indexing_in_format_string();
268 if (std::is_constant_evaluated())
269 if (_M_next_arg_id == _M_num_args)
270 __format::__invalid_arg_id_in_format_string();
271 return _M_next_arg_id++;
275 check_arg_id(
size_t __id)
277 if (_M_indexing == _Auto)
278 __format::__conflicting_indexing_in_format_string();
279 _M_indexing = _Manual;
281 if (std::is_constant_evaluated())
282 if (__id >= _M_num_args)
283 __format::__invalid_arg_id_in_format_string();
289 enum _Indexing { _Unknown, _Manual, _Auto };
290 _Indexing _M_indexing = _Unknown;
291 size_t _M_next_arg_id = 0;
296 template<
typename _Tp,
template<
typename...>
class _Class>
297 static constexpr bool __is_specialization_of =
false;
298 template<
template<
typename...>
class _Class,
typename... _Args>
299 static constexpr bool __is_specialization_of<_Class<_Args...>, _Class>
305 template<
typename _CharT>
306 constexpr pair<unsigned short, const _CharT*>
307 __parse_integer(
const _CharT* __first,
const _CharT* __last)
309 if (__first == __last)
310 __builtin_unreachable();
312 if constexpr (is_same_v<_CharT, char>)
314 const auto __start = __first;
315 unsigned short __val = 0;
317 if (__detail::__from_chars_alnum<true>(__first, __last, __val, 10)
318 && __first != __start) [[likely]]
319 return {__val, __first};
323 constexpr int __n = 32;
325 for (
int __i = 0; __i < __n && (__first + __i) != __last; ++__i)
326 __buf[__i] = __first[__i];
327 auto [__v, __ptr] = __format::__parse_integer(__buf, __buf + __n);
328 if (__ptr) [[likely]]
329 return {__v, __first + (__ptr - __buf)};
334 template<
typename _CharT>
335 constexpr pair<unsigned short, const _CharT*>
336 __parse_arg_id(
const _CharT* __first,
const _CharT* __last)
338 if (__first == __last)
339 __builtin_unreachable();
342 return {0, __first + 1};
344 if (
'1' <= *__first && *__first <=
'9')
346 const unsigned short __id = *__first -
'0';
347 const auto __next = __first + 1;
349 if (__next == __last || !(
'0' <= *__next && *__next <=
'9'))
350 return {__id, __next};
352 return __format::__parse_integer(__first, __last);
360 _Pres_d = 1, _Pres_b, _Pres_B, _Pres_o, _Pres_x, _Pres_X, _Pres_c,
362 _Pres_a = 1, _Pres_A, _Pres_e, _Pres_E, _Pres_f, _Pres_F, _Pres_g, _Pres_G,
363 _Pres_p = 0, _Pres_P,
388 template<
typename _Context>
390 __int_from_arg(
const basic_format_arg<_Context>& __arg);
392 constexpr bool __is_digit(
char __c)
393 {
return std::__detail::__from_chars_alnum_to_val(__c) < 10; }
395 constexpr bool __is_xdigit(
char __c)
396 {
return std::__detail::__from_chars_alnum_to_val(__c) < 16; }
398 template<
typename _CharT>
404 unsigned _M_localized : 1;
405 unsigned _M_zero_fill : 1;
406 _WidthPrec _M_width_kind : 2;
407 _WidthPrec _M_prec_kind : 2;
408 _Pres_type _M_type : 4;
409 unsigned _M_reserved : 1;
410 unsigned _M_reserved2 : 16;
411 unsigned short _M_width;
412 unsigned short _M_prec;
413 char32_t _M_fill =
' ';
415 using iterator =
typename basic_string_view<_CharT>::iterator;
417 static constexpr _Align
418 _S_align(_CharT __c)
noexcept
422 case '<':
return _Align_left;
423 case '>':
return _Align_right;
424 case '^':
return _Align_centre;
425 default:
return _Align_default;
431 _M_parse_fill_and_align(iterator __first, iterator __last)
noexcept
435 using namespace __unicode;
436 if constexpr (__literal_encoding_is_unicode<_CharT>())
439 _Utf32_view<ranges::subrange<iterator>> __uv({__first, __last});
442 auto __beg = __uv.begin();
443 char32_t __c = *__beg++;
444 if (__is_scalar_value(__c))
445 if (
auto __next = __beg.base(); __next != __last)
446 if (_Align __align = _S_align(*__next))
454 else if (__last - __first >= 2)
455 if (_Align __align = _S_align(__first[1]))
462 if (_Align __align = _S_align(__first[0]))
472 static constexpr _Sign
473 _S_sign(_CharT __c)
noexcept
477 case '+':
return _Sign_plus;
478 case '-':
return _Sign_minus;
479 case ' ':
return _Sign_space;
480 default:
return _Sign_default;
486 _M_parse_sign(iterator __first, iterator)
noexcept
488 if (_Sign __sign = _S_sign(*__first))
498 _M_parse_alternate_form(iterator __first, iterator)
noexcept
510 _M_parse_zero_fill(iterator __first, iterator )
noexcept
521 static constexpr iterator
522 _S_parse_width_or_precision(iterator __first, iterator __last,
523 unsigned short& __val,
bool& __arg_id,
524 basic_format_parse_context<_CharT>& __pc)
526 if (__format::__is_digit(*__first))
528 auto [__v, __ptr] = __format::__parse_integer(__first, __last);
530 __throw_format_error(
"format error: invalid width or precision "
535 else if (*__first ==
'{')
539 if (__first == __last)
540 __format::__unmatched_left_brace_in_format_string();
542 __val = __pc.next_arg_id();
545 auto [__v, __ptr] = __format::__parse_arg_id(__first, __last);
546 if (__ptr ==
nullptr || __ptr == __last || *__ptr !=
'}')
547 __format::__invalid_arg_id_in_format_string();
549 __pc.check_arg_id(__v);
559 _M_parse_width(iterator __first, iterator __last,
560 basic_format_parse_context<_CharT>& __pc)
562 bool __arg_id =
false;
564 __throw_format_error(
"format error: width must be non-zero in "
566 auto __next = _S_parse_width_or_precision(__first, __last, _M_width,
568 if (__next != __first)
569 _M_width_kind = __arg_id ? _WP_from_arg : _WP_value;
575 _M_parse_precision(iterator __first, iterator __last,
576 basic_format_parse_context<_CharT>& __pc)
578 if (__first[0] !=
'.')
581 iterator __next = ++__first;
582 bool __arg_id =
false;
583 if (__next != __last)
584 __next = _S_parse_width_or_precision(__first, __last, _M_prec,
586 if (__next == __first)
587 __throw_format_error(
"format error: missing precision after '.' in "
589 _M_prec_kind = __arg_id ? _WP_from_arg : _WP_value;
595 _M_parse_locale(iterator __first, iterator )
noexcept
605 template<
typename _Context>
607 _M_get_width(_Context& __ctx)
const
610 if (_M_width_kind == _WP_value)
612 else if (_M_width_kind == _WP_from_arg)
613 __width = __format::__int_from_arg(__ctx.arg(_M_width));
617 template<
typename _Context>
619 _M_get_precision(_Context& __ctx)
const
622 if (_M_prec_kind == _WP_value)
624 else if (_M_prec_kind == _WP_from_arg)
625 __prec = __format::__int_from_arg(__ctx.arg(_M_prec));
630 template<
typename _Int>
632 __put_sign(_Int __i, _Sign __sign,
char* __dest)
noexcept
636 else if (__sign == _Sign_plus)
638 else if (__sign == _Sign_space)
646 template<
typename _Out,
typename _CharT>
647 requires output_iterator<_Out, const _CharT&>
649 __write(_Out __out, basic_string_view<_CharT> __str)
651 if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
657 for (_CharT __c : __str)
664 template<
typename _Out,
typename _CharT>
666 __write_padded(_Out __out, basic_string_view<_CharT> __str,
667 _Align __align,
size_t __nfill,
char32_t __fill_char)
669 const size_t __buflen = 0x20;
670 _CharT __padding_chars[__buflen];
671 __padding_chars[0] = _CharT();
672 basic_string_view<_CharT> __padding{__padding_chars, __buflen};
674 auto __pad = [&__padding] (
size_t __n, _Out& __o) {
677 while (__n > __padding.size())
679 __o = __format::__write(
std::move(__o), __padding);
680 __n -= __padding.size();
683 __o = __format::__write(
std::move(__o), __padding.substr(0, __n));
686 size_t __l, __r, __max;
687 if (__align == _Align_centre)
690 __r = __l + (__nfill & 1);
693 else if (__align == _Align_right)
706 using namespace __unicode;
707 if constexpr (__literal_encoding_is_unicode<_CharT>())
708 if (!__is_single_code_unit<_CharT>(__fill_char)) [[unlikely]]
711 const char32_t __arr[1]{ __fill_char };
712 _Utf_view<_CharT,
const char32_t(&)[1]> __v(__arr);
713 basic_string<_CharT> __padstr(__v.begin(), __v.end());
714 __padding = __padstr;
716 __out = __format::__write(
std::move(__out), __padding);
717 __out = __format::__write(
std::move(__out), __str);
719 __out = __format::__write(
std::move(__out), __padding);
723 if (__max < __buflen)
724 __padding.remove_suffix(__buflen - __max);
728 char_traits<_CharT>::assign(__padding_chars, __max, __fill_char);
730 __out = __format::__write(
std::move(__out), __str);
738 template<
typename _CharT,
typename _Out>
740 __write_padded_as_spec(basic_string_view<type_identity_t<_CharT>> __str,
741 size_t __estimated_width,
742 basic_format_context<_Out, _CharT>& __fc,
743 const _Spec<_CharT>& __spec,
744 _Align __align = _Align_left)
746 size_t __width = __spec._M_get_width(__fc);
748 if (__width <= __estimated_width)
749 return __format::__write(__fc.out(), __str);
751 const size_t __nfill = __width - __estimated_width;
754 __align = __spec._M_align;
756 return __format::__write_padded(__fc.out(), __str, __align, __nfill,
761 struct _Optional_locale
763 [[__gnu__::__always_inline__]]
764 _Optional_locale() : _M_dummy(), _M_hasval(false) { }
766 _Optional_locale(
const locale& __loc) noexcept
767 : _M_loc(__loc), _M_hasval(
true)
770 _Optional_locale(
const _Optional_locale& __l) noexcept
771 : _M_dummy(), _M_hasval(__l._M_hasval)
774 std::construct_at(&_M_loc, __l._M_loc);
778 operator=(
const _Optional_locale& __l)
noexcept
790 else if (__l._M_hasval)
792 std::construct_at(&_M_loc, __l._M_loc);
798 ~_Optional_locale() {
if (_M_hasval) _M_loc.~locale(); }
801 operator=(locale&& __loc)
noexcept
807 std::construct_at(&_M_loc,
std::move(__loc));
818 std::construct_at(&_M_loc);
824 bool has_value() const noexcept {
return _M_hasval; }
827 char _M_dummy =
'\0';
830 bool _M_hasval =
false;
833#ifdef _GLIBCXX_USE_WCHAR_T
834 template<
typename _CharT>
835 concept __char = same_as<_CharT, char> || same_as<_CharT, wchar_t>;
837 template<
typename _CharT>
838 concept __char = same_as<_CharT, char>;
841 template<__
char _CharT>
842 struct __formatter_str
844 constexpr typename basic_format_parse_context<_CharT>::iterator
845 parse(basic_format_parse_context<_CharT>& __pc)
847 auto __first = __pc.begin();
848 const auto __last = __pc.end();
849 _Spec<_CharT> __spec{};
851 auto __finalize = [
this, &__spec] {
855 auto __finished = [&] {
856 if (__first == __last || *__first ==
'}')
867 __first = __spec._M_parse_fill_and_align(__first, __last);
871 __first = __spec._M_parse_width(__first, __last, __pc);
875 __first = __spec._M_parse_precision(__first, __last, __pc);
881#if __cpp_lib_format_ranges
882 else if (*__first ==
'?')
884 __spec._M_type = _Pres_esc;
892 __format::__failed_to_parse_format_spec();
895 template<
typename _Out>
897 format(basic_string_view<_CharT> __s,
898 basic_format_context<_Out, _CharT>& __fc)
const
900 if (_M_spec._M_type == _Pres_esc)
905 if (_M_spec._M_width_kind == _WP_none
906 && _M_spec._M_prec_kind == _WP_none)
907 return __format::__write(__fc.out(), __s);
909 size_t __estimated_width;
910 if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())
912 if (_M_spec._M_prec_kind != _WP_none)
914 size_t __prec = _M_spec._M_get_precision(__fc);
915 __estimated_width = __unicode::__truncate(__s, __prec);
918 __estimated_width = __unicode::__field_width(__s);
922 __s = __s.substr(0, _M_spec._M_get_precision(__fc));
923 __estimated_width = __s.size();
926 return __format::__write_padded_as_spec(__s, __estimated_width,
930#if __cpp_lib_format_ranges
932 set_debug_format() noexcept
933 { _M_spec._M_type = _Pres_esc; }
937 _Spec<_CharT> _M_spec{};
940 template<__
char _CharT>
941 struct __formatter_int
945 static constexpr _Pres_type _AsInteger = _Pres_d;
946 static constexpr _Pres_type _AsBool = _Pres_s;
947 static constexpr _Pres_type _AsChar = _Pres_c;
949 constexpr typename basic_format_parse_context<_CharT>::iterator
950 _M_do_parse(basic_format_parse_context<_CharT>& __pc, _Pres_type __type)
952 _Spec<_CharT> __spec{};
953 __spec._M_type = __type;
955 const auto __last = __pc.end();
956 auto __first = __pc.begin();
958 auto __finalize = [
this, &__spec] {
962 auto __finished = [&] {
963 if (__first == __last || *__first ==
'}')
974 __first = __spec._M_parse_fill_and_align(__first, __last);
978 __first = __spec._M_parse_sign(__first, __last);
982 __first = __spec._M_parse_alternate_form(__first, __last);
986 __first = __spec._M_parse_zero_fill(__first, __last);
990 __first = __spec._M_parse_width(__first, __last, __pc);
994 __first = __spec._M_parse_locale(__first, __last);
1001 __spec._M_type = _Pres_b;
1005 __spec._M_type = _Pres_B;
1011 if (__type != _AsBool)
1013 __spec._M_type = _Pres_c;
1018 __spec._M_type = _Pres_d;
1022 __spec._M_type = _Pres_o;
1026 __spec._M_type = _Pres_x;
1030 __spec._M_type = _Pres_X;
1034 if (__type == _AsBool)
1036 __spec._M_type = _Pres_s;
1040#if __cpp_lib_format_ranges
1042 if (__type == _AsChar)
1044 __spec._M_type = _Pres_esc;
1054 __format::__failed_to_parse_format_spec();
1057 template<
typename _Tp>
1058 constexpr typename basic_format_parse_context<_CharT>::iterator
1059 _M_parse(basic_format_parse_context<_CharT>& __pc)
1061 if constexpr (is_same_v<_Tp, bool>)
1063 auto __end = _M_do_parse(__pc, _AsBool);
1064 if (_M_spec._M_type == _Pres_s)
1065 if (_M_spec._M_sign || _M_spec._M_alt || _M_spec._M_zero_fill)
1066 __throw_format_error(
"format error: format-spec contains "
1067 "invalid formatting options for "
1071 else if constexpr (__char<_Tp>)
1073 auto __end = _M_do_parse(__pc, _AsChar);
1074 if (_M_spec._M_type == _Pres_c || _M_spec._M_type == _Pres_esc)
1075 if (_M_spec._M_sign || _M_spec._M_alt || _M_spec._M_zero_fill
1077 __throw_format_error(
"format error: format-spec contains "
1078 "invalid formatting options for "
1083 return _M_do_parse(__pc, _AsInteger);
1086 template<
typename _Int,
typename _Out>
1087 typename basic_format_context<_Out, _CharT>::iterator
1088 format(_Int __i, basic_format_context<_Out, _CharT>& __fc)
const
1090 if (_M_spec._M_type == _Pres_c)
1091 return _M_format_character(_S_to_character(__i), __fc);
1093 char __buf[
sizeof(_Int) * __CHAR_BIT__ + 3];
1094 to_chars_result __res{};
1096 string_view __base_prefix;
1097 make_unsigned_t<_Int> __u;
1099 __u = -
static_cast<make_unsigned_t<_Int>
>(__i);
1103 char* __start = __buf + 3;
1104 char*
const __end = __buf +
sizeof(__buf);
1105 char*
const __start_digits = __start;
1107 switch (_M_spec._M_type)
1111 __base_prefix = _M_spec._M_type == _Pres_b ?
"0b" :
"0B";
1112 __res = to_chars(__start, __end, __u, 2);
1116 return _M_format_character(_S_to_character(__i), __fc);
1122 __res = to_chars(__start, __end, __u, 10);
1126 __base_prefix =
"0";
1127 __res = to_chars(__start, __end, __u, 8);
1131 __base_prefix = _M_spec._M_type == _Pres_x ?
"0x" :
"0X";
1132 __res = to_chars(__start, __end, __u, 16);
1133 if (_M_spec._M_type == _Pres_X)
1134 for (
auto __p = __start; __p != __res.ptr; ++__p)
1135#
if __has_builtin(__builtin_toupper)
1136 *__p = __builtin_toupper(*__p);
1142 __builtin_unreachable();
1145 if (_M_spec._M_alt && __base_prefix.size())
1147 __start -= __base_prefix.size();
1148 __builtin_memcpy(__start, __base_prefix.data(),
1149 __base_prefix.size());
1151 __start = __format::__put_sign(__i, _M_spec._M_sign, __start - 1);
1153 return _M_format_int(string_view(__start, __res.ptr - __start),
1154 __start_digits - __start, __fc);
1157 template<
typename _Out>
1158 typename basic_format_context<_Out, _CharT>::iterator
1159 format(
bool __i, basic_format_context<_Out, _CharT>& __fc)
const
1161 if (_M_spec._M_type == _Pres_c)
1162 return _M_format_character(
static_cast<unsigned char>(__i), __fc);
1163 if (_M_spec._M_type != _Pres_s)
1164 return format(
static_cast<unsigned char>(__i), __fc);
1166 basic_string<_CharT> __s;
1168 if (_M_spec._M_localized) [[unlikely]]
1170 auto& __np = std::use_facet<numpunct<_CharT>>(__fc.locale());
1171 __s = __i ? __np.truename() : __np.falsename();
1172 __est_width = __s.size();
1176 if constexpr (is_same_v<char, _CharT>)
1177 __s = __i ?
"true" :
"false";
1179 __s = __i ? L
"true" : L
"false";
1180 __est_width = __s.size();
1183 return __format::__write_padded_as_spec(__s, __est_width, __fc,
1187 template<
typename _Out>
1188 typename basic_format_context<_Out, _CharT>::iterator
1189 _M_format_character(_CharT __c,
1190 basic_format_context<_Out, _CharT>& __fc)
const
1192 return __format::__write_padded_as_spec({&__c, 1u}, 1, __fc, _M_spec);
1195 template<
typename _Int>
1197 _S_to_character(_Int __i)
1200 if constexpr (is_signed_v<_Int> == is_signed_v<_CharT>)
1202 if (_Traits::__min <= __i && __i <= _Traits::__max)
1203 return static_cast<_CharT
>(__i);
1205 else if constexpr (is_signed_v<_Int>)
1207 if (__i >= 0 && make_unsigned_t<_Int>(__i) <= _Traits::__max)
1208 return static_cast<_CharT
>(__i);
1210 else if (__i <= make_unsigned_t<_CharT>(_Traits::__max))
1211 return static_cast<_CharT
>(__i);
1212 __throw_format_error(
"format error: integer not representable as "
1216 template<
typename _Out>
1217 typename basic_format_context<_Out, _CharT>::iterator
1218 _M_format_int(string_view __narrow_str,
size_t __prefix_len,
1219 basic_format_context<_Out, _CharT>& __fc)
const
1221 size_t __width = _M_spec._M_get_width(__fc);
1223 basic_string_view<_CharT> __str;
1224 if constexpr (is_same_v<char, _CharT>)
1225 __str = __narrow_str;
1226#ifdef _GLIBCXX_USE_WCHAR_T
1229 size_t __n = __narrow_str.size();
1230 auto __p = (_CharT*)__builtin_alloca(__n *
sizeof(_CharT));
1231 std::__to_wstring_numeric(__narrow_str.data(), __n, __p);
1236 if (_M_spec._M_localized)
1238 const auto& __l = __fc.locale();
1239 if (__l.name() !=
"C")
1241 auto& __np = use_facet<numpunct<_CharT>>(__l);
1242 string __grp = __np.grouping();
1245 size_t __n = __str.size() - __prefix_len;
1246 auto __p = (_CharT*)__builtin_alloca(2 * __n
1249 auto __s = __str.data();
1250 char_traits<_CharT>::copy(__p, __s, __prefix_len);
1251 __s += __prefix_len;
1252 auto __end = std::__add_grouping(__p + __prefix_len,
1253 __np.thousands_sep(),
1257 __str = {__p, size_t(__end - __p)};
1262 if (__width <= __str.size())
1263 return __format::__write(__fc.out(), __str);
1265 char32_t __fill_char = _M_spec._M_fill;
1266 _Align __align = _M_spec._M_align;
1268 size_t __nfill = __width - __str.size();
1269 auto __out = __fc.out();
1270 if (__align == _Align_default)
1272 __align = _Align_right;
1273 if (_M_spec._M_zero_fill)
1275 __fill_char = _CharT(
'0');
1277 if (__prefix_len != 0)
1279 __out = __format::__write(
std::move(__out),
1280 __str.substr(0, __prefix_len));
1281 __str.remove_prefix(__prefix_len);
1285 __fill_char = _CharT(
' ');
1287 return __format::__write_padded(
std::move(__out), __str,
1288 __align, __nfill, __fill_char);
1291#if defined __SIZEOF_INT128__ && defined __STRICT_ANSI__
1292 template<
typename _Tp>
1294 =
typename __conditional_t<(
sizeof(_Tp) <=
sizeof(
long long)),
1296 type_identity<unsigned __int128>>::type;
1299 template<
typename _Int>
1300 static to_chars_result
1301 to_chars(
char* __first,
char* __last, _Int __value,
int __base)
1302 {
return std::__to_chars_i<_Int>(__first, __last, __value,
__base); }
1305 _Spec<_CharT> _M_spec{};
1316#undef _GLIBCXX_FORMAT_F128
1318#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
1321 using __float128_t = __ieee128;
1322# define _GLIBCXX_FORMAT_F128 1
1324#ifdef __LONG_DOUBLE_IEEE128__
1328 to_chars(
char*,
char*, __ibm128)
noexcept
1329 __asm(
"_ZSt8to_charsPcS_e");
1332 to_chars(
char*,
char*, __ibm128,
chars_format)
noexcept
1333 __asm(
"_ZSt8to_charsPcS_eSt12chars_format");
1336 to_chars(
char*,
char*, __ibm128,
chars_format,
int)
noexcept
1337 __asm(
"_ZSt8to_charsPcS_eSt12chars_formati");
1338#elif __cplusplus == 202002L
1340 to_chars(
char*,
char*, __ieee128)
noexcept
1341 __asm(
"_ZSt8to_charsPcS_u9__ieee128");
1344 to_chars(
char*,
char*, __ieee128,
chars_format)
noexcept
1345 __asm(
"_ZSt8to_charsPcS_u9__ieee128St12chars_format");
1348 to_chars(
char*,
char*, __ieee128,
chars_format,
int)
noexcept
1349 __asm(
"_ZSt8to_charsPcS_u9__ieee128St12chars_formati");
1352#elif defined _GLIBCXX_LDOUBLE_IS_IEEE_BINARY128
1355 using __float128_t =
long double;
1356# define _GLIBCXX_FORMAT_F128 1
1358#elif __FLT128_DIG__ && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
1361 using __float128_t = _Float128;
1362# define _GLIBCXX_FORMAT_F128 2
1364# if __cplusplus == 202002L
1368 to_chars(
char*,
char*, _Float128)
noexcept
1369# if _GLIBCXX_INLINE_VERSION
1370 __asm(
"_ZNSt3__88to_charsEPcS0_DF128_");
1372 __asm(
"_ZSt8to_charsPcS_DF128_");
1376 to_chars(
char*,
char*, _Float128,
chars_format)
noexcept
1377# if _GLIBCXX_INLINE_VERSION
1378 __asm(
"_ZNSt3__88to_charsEPcS0_DF128_NS_12chars_formatE");
1380 __asm(
"_ZSt8to_charsPcS_DF128_St12chars_format");
1384 to_chars(
char*,
char*, _Float128,
chars_format,
int)
noexcept
1385# if _GLIBCXX_INLINE_VERSION
1386 __asm(
"_ZNSt3__88to_charsEPcS0_DF128_NS_12chars_formatEi");
1388 __asm(
"_ZSt8to_charsPcS_DF128_St12chars_formati");
1393 using std::to_chars;
1396 template<
typename _Tp>
1397 concept __formattable_float
1398 = is_same_v<remove_cv_t<_Tp>, _Tp> &&
requires (_Tp __t,
char* __p)
1399 { __format::to_chars(__p, __p, __t, chars_format::scientific, 6); };
1401 template<__
char _CharT>
1402 struct __formatter_fp
1404 constexpr typename basic_format_parse_context<_CharT>::iterator
1405 parse(basic_format_parse_context<_CharT>& __pc)
1407 _Spec<_CharT> __spec{};
1408 const auto __last = __pc.end();
1409 auto __first = __pc.begin();
1411 auto __finalize = [
this, &__spec] {
1415 auto __finished = [&] {
1416 if (__first == __last || *__first ==
'}')
1427 __first = __spec._M_parse_fill_and_align(__first, __last);
1431 __first = __spec._M_parse_sign(__first, __last);
1435 __first = __spec._M_parse_alternate_form(__first, __last);
1439 __first = __spec._M_parse_zero_fill(__first, __last);
1443 if (__first[0] !=
'.')
1445 __first = __spec._M_parse_width(__first, __last, __pc);
1450 __first = __spec._M_parse_precision(__first, __last, __pc);
1454 __first = __spec._M_parse_locale(__first, __last);
1461 __spec._M_type = _Pres_a;
1465 __spec._M_type = _Pres_A;
1469 __spec._M_type = _Pres_e;
1473 __spec._M_type = _Pres_E;
1477 __spec._M_type = _Pres_f;
1481 __spec._M_type = _Pres_F;
1485 __spec._M_type = _Pres_g;
1489 __spec._M_type = _Pres_G;
1497 __format::__failed_to_parse_format_spec();
1500 template<
typename _Fp,
typename _Out>
1501 typename basic_format_context<_Out, _CharT>::iterator
1502 format(_Fp __v, basic_format_context<_Out, _CharT>& __fc)
const
1506 to_chars_result __res{};
1509 bool __use_prec = _M_spec._M_prec_kind != _WP_none;
1511 __prec = _M_spec._M_get_precision(__fc);
1513 char* __start = __buf + 1;
1514 char* __end = __buf +
sizeof(__buf);
1517 bool __upper =
false;
1518 bool __trailing_zeros =
false;
1521 switch (_M_spec._M_type)
1528 if (_M_spec._M_type != _Pres_A)
1530 __fmt = chars_format::hex;
1538 __fmt = chars_format::scientific;
1545 __fmt = chars_format::fixed;
1552 __trailing_zeros =
true;
1554 __fmt = chars_format::general;
1558 __fmt = chars_format::general;
1561 __builtin_unreachable();
1565 auto __to_chars = [&](
char* __b,
char* __e) {
1567 return __format::to_chars(__b, __e, __v, __fmt, __prec);
1569 return __format::to_chars(__b, __e, __v, __fmt);
1571 return __format::to_chars(__b, __e, __v);
1575 __res = __to_chars(__start, __end);
1577 if (__builtin_expect(__res.ec == errc::value_too_large, 0))
1581 size_t __guess = 8 + __prec;
1582 if (__fmt == chars_format::fixed)
1584 if constexpr (is_same_v<_Fp, float> || is_same_v<_Fp, double>
1585 || is_same_v<_Fp, long double>)
1590 if constexpr (is_same_v<_Fp, float>)
1591 __builtin_frexpf(__v, &__exp);
1592 else if constexpr (is_same_v<_Fp, double>)
1593 __builtin_frexp(__v, &__exp);
1594 else if constexpr (is_same_v<_Fp, long double>)
1595 __builtin_frexpl(__v, &__exp);
1597 __guess += 1U + __exp * 4004U / 13301U;
1602 if (__guess <=
sizeof(__buf)) [[unlikely]]
1603 __guess =
sizeof(__buf) * 2;
1608 auto __overwrite = [&__to_chars, &__res] (
char* __p,
size_t __n)
1610 __res = __to_chars(__p + 1, __p + __n - 1);
1611 return __res.ec == errc{} ? __res.ptr - __p : 0;
1616 __start = __dynbuf.
data() + 1;
1617 __end = __dynbuf.
data() + __dynbuf.
size();
1619 while (__builtin_expect(__res.ec == errc::value_too_large, 0));
1625 for (
char* __p = __start; __p != __res.ptr; ++__p)
1629 bool __have_sign =
true;
1631 if (!__builtin_signbit(__v))
1633 if (_M_spec._M_sign == _Sign_plus)
1635 else if (_M_spec._M_sign == _Sign_space)
1638 __have_sign =
false;
1641 string_view __narrow_str(__start, __res.ptr - __start);
1645 if (_M_spec._M_alt && __builtin_isfinite(__v))
1647 string_view __s = __narrow_str;
1651 size_t __d = __s.find(
'.');
1652 if (__d != __s.npos)
1654 __p = __s.find(__expc, __d + 1);
1655 if (__p == __s.npos)
1659 if (__trailing_zeros)
1662 if (__s[__have_sign] !=
'0')
1664 __sigfigs = __p - __have_sign - 1;
1669 __sigfigs = __p - __s.find_first_not_of(
'0', __d + 1);
1674 __p = __s.find(__expc);
1675 if (__p == __s.npos)
1678 __sigfigs = __d - __have_sign;
1681 if (__trailing_zeros && __prec != 0)
1686 __z = __prec - __sigfigs;
1689 if (
size_t __extras =
int(__d == __p) + __z)
1691 if (__dynbuf.
empty() && __extras <=
size_t(__end - __res.ptr))
1695 __builtin_memmove(__start + __p + __extras,
1699 __start[__p++] =
'.';
1700 __builtin_memset(__start + __p,
'0', __z);
1701 __narrow_str = {__s.data(), __s.size() + __extras};
1705 __dynbuf.
reserve(__s.size() + __extras);
1706 if (__dynbuf.
empty())
1708 __dynbuf = __s.
substr(0, __p);
1712 __dynbuf.
append(__z,
'0');
1713 __dynbuf.
append(__s.substr(__p));
1717 __dynbuf.
insert(__p, __extras,
'0');
1719 __dynbuf[__p] =
'.';
1721 __narrow_str = __dynbuf;
1726 basic_string<_CharT> __wstr;
1727 basic_string_view<_CharT> __str;
1728 if constexpr (is_same_v<_CharT, char>)
1729 __str = __narrow_str;
1730#ifdef _GLIBCXX_USE_WCHAR_T
1733 __wstr = std::__to_wstring_numeric(__narrow_str);
1738 if (_M_spec._M_localized && __builtin_isfinite(__v))
1740 __wstr = _M_localize(__str, __expc, __fc.locale());
1741 if (!__wstr.empty())
1745 size_t __width = _M_spec._M_get_width(__fc);
1747 if (__width <= __str.size())
1748 return __format::__write(__fc.out(), __str);
1750 char32_t __fill_char = _M_spec._M_fill;
1751 _Align __align = _M_spec._M_align;
1753 size_t __nfill = __width - __str.size();
1754 auto __out = __fc.out();
1755 if (__align == _Align_default)
1757 __align = _Align_right;
1758 if (_M_spec._M_zero_fill && __builtin_isfinite(__v))
1760 __fill_char = _CharT(
'0');
1762 if (!__format::__is_xdigit(__narrow_str[0]))
1764 *__out++ = __str[0];
1765 __str.remove_prefix(1);
1769 __fill_char = _CharT(
' ');
1771 return __format::__write_padded(
std::move(__out), __str,
1772 __align, __nfill, __fill_char);
1776 basic_string<_CharT>
1777 _M_localize(basic_string_view<_CharT> __str,
char __expc,
1778 const locale& __loc)
const
1780 basic_string<_CharT> __lstr;
1785 const auto& __np = use_facet<numpunct<_CharT>>(__loc);
1786 const _CharT __point = __np.decimal_point();
1787 const string __grp = __np.grouping();
1789 _CharT __dot, __exp;
1790 if constexpr (is_same_v<_CharT, char>)
1813 __builtin_unreachable();
1817 if (__grp.empty() && __point == __dot)
1820 size_t __d = __str.find(__dot);
1821 size_t __e =
min(__d, __str.find(__exp));
1822 if (__e == __str.npos)
1824 const size_t __r = __str.size() - __e;
1825 auto __overwrite = [&](_CharT* __p, size_t) {
1826 auto __end = std::__add_grouping(__p, __np.thousands_sep(),
1827 __grp.data(), __grp.size(),
1828 __str.data(), __str.data() + __e);
1831 if (__d != __str.npos)
1838 __end += __str.copy(__end, __str.npos, __e);
1840 return (__end - __p);
1842 __lstr.__resize_and_overwrite(__e * 2 + __r, __overwrite);
1846 _Spec<_CharT> _M_spec{};
1853 template<__format::__
char _CharT>
1854 struct formatter<_CharT, _CharT>
1856 formatter() =
default;
1858 constexpr typename basic_format_parse_context<_CharT>::iterator
1859 parse(basic_format_parse_context<_CharT>& __pc)
1861 return _M_f.template _M_parse<_CharT>(__pc);
1864 template<
typename _Out>
1865 typename basic_format_context<_Out, _CharT>::iterator
1866 format(_CharT __u, basic_format_context<_Out, _CharT>& __fc)
const
1868 if (_M_f._M_spec._M_type == __format::_Pres_none
1869 || _M_f._M_spec._M_type == __format::_Pres_c)
1870 return _M_f._M_format_character(__u, __fc);
1871 else if (_M_f._M_spec._M_type == __format::_Pres_esc)
1877 return _M_f.format(
static_cast<make_unsigned_t<_CharT>
>(__u), __fc);
1880#if __cpp_lib_format_ranges
1882 set_debug_format() noexcept
1883 { _M_f._M_spec._M_type = __format::_Pres_esc; }
1887 __format::__formatter_int<_CharT> _M_f;
1890#ifdef _GLIBCXX_USE_WCHAR_T
1893 struct formatter<char, wchar_t>
1895 formatter() =
default;
1897 constexpr typename basic_format_parse_context<wchar_t>::iterator
1898 parse(basic_format_parse_context<wchar_t>& __pc)
1900 return _M_f._M_parse<
char>(__pc);
1903 template<
typename _Out>
1904 typename basic_format_context<_Out, wchar_t>::iterator
1905 format(
char __u, basic_format_context<_Out, wchar_t>& __fc)
const
1907 if (_M_f._M_spec._M_type == __format::_Pres_none
1908 || _M_f._M_spec._M_type == __format::_Pres_c)
1909 return _M_f._M_format_character(__u, __fc);
1910 else if (_M_f._M_spec._M_type == __format::_Pres_esc)
1916 return _M_f.format(
static_cast<unsigned char>(__u), __fc);
1919#if __cpp_lib_format_ranges
1921 set_debug_format() noexcept
1922 { _M_f._M_spec._M_type = __format::_Pres_esc; }
1926 __format::__formatter_int<wchar_t> _M_f;
1933 template<__format::__
char _CharT>
1934 struct formatter<_CharT*, _CharT>
1936 formatter() =
default;
1938 [[__gnu__::__always_inline__]]
1939 constexpr typename basic_format_parse_context<_CharT>::iterator
1940 parse(basic_format_parse_context<_CharT>& __pc)
1941 {
return _M_f.parse(__pc); }
1943 template<
typename _Out>
1944 [[__gnu__::__nonnull__]]
1945 typename basic_format_context<_Out, _CharT>::iterator
1946 format(_CharT* __u, basic_format_context<_Out, _CharT>& __fc)
const
1947 {
return _M_f.format(__u, __fc); }
1949#if __cpp_lib_format_ranges
1950 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
1954 __format::__formatter_str<_CharT> _M_f;
1957 template<__format::__
char _CharT>
1958 struct formatter<const _CharT*, _CharT>
1960 formatter() =
default;
1962 [[__gnu__::__always_inline__]]
1963 constexpr typename basic_format_parse_context<_CharT>::iterator
1964 parse(basic_format_parse_context<_CharT>& __pc)
1965 {
return _M_f.parse(__pc); }
1967 template<
typename _Out>
1968 [[__gnu__::__nonnull__]]
1969 typename basic_format_context<_Out, _CharT>::iterator
1970 format(
const _CharT* __u,
1971 basic_format_context<_Out, _CharT>& __fc)
const
1972 {
return _M_f.format(__u, __fc); }
1974#if __cpp_lib_format_ranges
1975 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
1979 __format::__formatter_str<_CharT> _M_f;
1982 template<__format::__
char _CharT,
size_t _Nm>
1983 struct formatter<_CharT[_Nm], _CharT>
1985 formatter() =
default;
1987 [[__gnu__::__always_inline__]]
1988 constexpr typename basic_format_parse_context<_CharT>::iterator
1989 parse(basic_format_parse_context<_CharT>& __pc)
1990 {
return _M_f.parse(__pc); }
1992 template<
typename _Out>
1993 typename basic_format_context<_Out, _CharT>::iterator
1994 format(
const _CharT (&__u)[_Nm],
1995 basic_format_context<_Out, _CharT>& __fc)
const
1996 {
return _M_f.format({__u, _Nm}, __fc); }
1998#if __cpp_lib_format_ranges
1999 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2003 __format::__formatter_str<_CharT> _M_f;
2006 template<
typename _Traits,
typename _Alloc>
2007 struct formatter<basic_string<char, _Traits, _Alloc>, char>
2009 formatter() =
default;
2011 [[__gnu__::__always_inline__]]
2012 constexpr typename basic_format_parse_context<char>::iterator
2013 parse(basic_format_parse_context<char>& __pc)
2014 {
return _M_f.parse(__pc); }
2016 template<
typename _Out>
2017 typename basic_format_context<_Out, char>::iterator
2018 format(
const basic_string<char, _Traits, _Alloc>& __u,
2019 basic_format_context<_Out, char>& __fc)
const
2020 {
return _M_f.format(__u, __fc); }
2022#if __cpp_lib_format_ranges
2023 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2027 __format::__formatter_str<char> _M_f;
2030#ifdef _GLIBCXX_USE_WCHAR_T
2031 template<
typename _Traits,
typename _Alloc>
2032 struct formatter<basic_string<wchar_t, _Traits, _Alloc>, wchar_t>
2034 formatter() =
default;
2036 [[__gnu__::__always_inline__]]
2037 constexpr typename basic_format_parse_context<wchar_t>::iterator
2038 parse(basic_format_parse_context<wchar_t>& __pc)
2039 {
return _M_f.parse(__pc); }
2041 template<
typename _Out>
2042 typename basic_format_context<_Out, wchar_t>::iterator
2043 format(
const basic_string<wchar_t, _Traits, _Alloc>& __u,
2044 basic_format_context<_Out, wchar_t>& __fc)
const
2045 {
return _M_f.format(__u, __fc); }
2047#if __cpp_lib_format_ranges
2048 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2052 __format::__formatter_str<wchar_t> _M_f;
2056 template<
typename _Traits>
2057 struct formatter<basic_string_view<char, _Traits>, char>
2059 formatter() =
default;
2061 [[__gnu__::__always_inline__]]
2062 constexpr typename basic_format_parse_context<char>::iterator
2063 parse(basic_format_parse_context<char>& __pc)
2064 {
return _M_f.parse(__pc); }
2066 template<
typename _Out>
2067 typename basic_format_context<_Out, char>::iterator
2068 format(basic_string_view<char, _Traits> __u,
2069 basic_format_context<_Out, char>& __fc)
const
2070 {
return _M_f.format(__u, __fc); }
2072#if __cpp_lib_format_ranges
2073 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2077 __format::__formatter_str<char> _M_f;
2080#ifdef _GLIBCXX_USE_WCHAR_T
2081 template<
typename _Traits>
2082 struct formatter<basic_string_view<wchar_t, _Traits>, wchar_t>
2084 formatter() =
default;
2086 [[__gnu__::__always_inline__]]
2087 constexpr typename basic_format_parse_context<wchar_t>::iterator
2088 parse(basic_format_parse_context<wchar_t>& __pc)
2089 {
return _M_f.parse(__pc); }
2091 template<
typename _Out>
2092 typename basic_format_context<_Out, wchar_t>::iterator
2093 format(basic_string_view<wchar_t, _Traits> __u,
2094 basic_format_context<_Out, wchar_t>& __fc)
const
2095 {
return _M_f.format(__u, __fc); }
2097#if __cpp_lib_format_ranges
2098 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2102 __format::__formatter_str<wchar_t> _M_f;
2112 template<
typename _Tp>
2113 constexpr bool __is_formattable_integer = __is_integer<_Tp>::__value;
2115#if defined __SIZEOF_INT128__
2116 template<>
inline constexpr bool __is_formattable_integer<__int128> =
true;
2117 template<>
inline constexpr bool __is_formattable_integer<unsigned __int128>
2121 template<>
inline constexpr bool __is_formattable_integer<char> =
false;
2122 template<>
inline constexpr bool __is_formattable_integer<wchar_t> =
false;
2123#ifdef _GLIBCXX_USE_CHAR8_T
2124 template<>
inline constexpr bool __is_formattable_integer<char8_t> =
false;
2126 template<>
inline constexpr bool __is_formattable_integer<char16_t> =
false;
2127 template<>
inline constexpr bool __is_formattable_integer<char32_t> =
false;
2132 template<
typename _Tp, __format::__
char _CharT>
2133 requires __format::__is_formattable_integer<_Tp>
2134 struct formatter<_Tp, _CharT>
2136 formatter() =
default;
2138 [[__gnu__::__always_inline__]]
2139 constexpr typename basic_format_parse_context<_CharT>::iterator
2140 parse(basic_format_parse_context<_CharT>& __pc)
2142 return _M_f.template _M_parse<_Tp>(__pc);
2145 template<
typename _Out>
2146 typename basic_format_context<_Out, _CharT>::iterator
2147 format(_Tp __u, basic_format_context<_Out, _CharT>& __fc)
const
2148 {
return _M_f.format(__u, __fc); }
2151 __format::__formatter_int<_CharT> _M_f;
2154#if defined __glibcxx_to_chars
2156 template<__format::__formattable_
float _Tp, __format::__
char _CharT>
2157 struct formatter<_Tp, _CharT>
2159 formatter() =
default;
2161 [[__gnu__::__always_inline__]]
2162 constexpr typename basic_format_parse_context<_CharT>::iterator
2163 parse(basic_format_parse_context<_CharT>& __pc)
2164 {
return _M_f.parse(__pc); }
2166 template<
typename _Out>
2167 typename basic_format_context<_Out, _CharT>::iterator
2168 format(_Tp __u, basic_format_context<_Out, _CharT>& __fc)
const
2169 {
return _M_f.format(__u, __fc); }
2172 __format::__formatter_fp<_CharT> _M_f;
2175#if __LDBL_MANT_DIG__ == __DBL_MANT_DIG__
2177 template<__format::__
char _CharT>
2178 struct formatter<long double, _CharT>
2180 formatter() =
default;
2182 [[__gnu__::__always_inline__]]
2183 constexpr typename basic_format_parse_context<_CharT>::iterator
2184 parse(basic_format_parse_context<_CharT>& __pc)
2185 {
return _M_f.parse(__pc); }
2187 template<
typename _Out>
2188 typename basic_format_context<_Out, _CharT>::iterator
2189 format(
long double __u, basic_format_context<_Out, _CharT>& __fc)
const
2190 {
return _M_f.format((
double)__u, __fc); }
2193 __format::__formatter_fp<_CharT> _M_f;
2197#ifdef __STDCPP_FLOAT16_T__
2199 template<__format::__
char _CharT>
2200 struct formatter<_Float16, _CharT>
2202 formatter() =
default;
2204 [[__gnu__::__always_inline__]]
2205 constexpr typename basic_format_parse_context<_CharT>::iterator
2206 parse(basic_format_parse_context<_CharT>& __pc)
2207 {
return _M_f.parse(__pc); }
2209 template<
typename _Out>
2210 typename basic_format_context<_Out, _CharT>::iterator
2211 format(_Float16 __u, basic_format_context<_Out, _CharT>& __fc)
const
2212 {
return _M_f.format((
float)__u, __fc); }
2215 __format::__formatter_fp<_CharT> _M_f;
2219#if defined(__FLT32_DIG__)
2221 template<__format::__
char _CharT>
2222 struct formatter<_Float32, _CharT>
2224 formatter() =
default;
2226 [[__gnu__::__always_inline__]]
2227 constexpr typename basic_format_parse_context<_CharT>::iterator
2228 parse(basic_format_parse_context<_CharT>& __pc)
2229 {
return _M_f.parse(__pc); }
2231 template<
typename _Out>
2232 typename basic_format_context<_Out, _CharT>::iterator
2233 format(_Float32 __u, basic_format_context<_Out, _CharT>& __fc)
const
2234 {
return _M_f.format((
float)__u, __fc); }
2237 __format::__formatter_fp<_CharT> _M_f;
2241#if defined(__FLT64_DIG__)
2243 template<__format::__
char _CharT>
2244 struct formatter<_Float64, _CharT>
2246 formatter() =
default;
2248 [[__gnu__::__always_inline__]]
2249 constexpr typename basic_format_parse_context<_CharT>::iterator
2250 parse(basic_format_parse_context<_CharT>& __pc)
2251 {
return _M_f.parse(__pc); }
2253 template<
typename _Out>
2254 typename basic_format_context<_Out, _CharT>::iterator
2255 format(_Float64 __u, basic_format_context<_Out, _CharT>& __fc)
const
2256 {
return _M_f.format((
double)__u, __fc); }
2259 __format::__formatter_fp<_CharT> _M_f;
2263#if defined(__FLT128_DIG__) && _GLIBCXX_FORMAT_F128 == 1
2265 template<__format::__
char _CharT>
2266 struct formatter<_Float128, _CharT>
2268 formatter() =
default;
2270 [[__gnu__::__always_inline__]]
2271 constexpr typename basic_format_parse_context<_CharT>::iterator
2272 parse(basic_format_parse_context<_CharT>& __pc)
2273 {
return _M_f.parse(__pc); }
2275 template<
typename _Out>
2276 typename basic_format_context<_Out, _CharT>::iterator
2277 format(_Float128 __u, basic_format_context<_Out, _CharT>& __fc)
const
2278 {
return _M_f.format((__format::__float128_t)__u, __fc); }
2281 __format::__formatter_fp<_CharT> _M_f;
2285#ifdef __STDCPP_BFLOAT16_T__
2287 template<__format::__
char _CharT>
2288 struct formatter<
__gnu_cxx::__bfloat16_t, _CharT>
2290 formatter() =
default;
2292 [[__gnu__::__always_inline__]]
2293 constexpr typename basic_format_parse_context<_CharT>::iterator
2294 parse(basic_format_parse_context<_CharT>& __pc)
2295 {
return _M_f.parse(__pc); }
2297 template<
typename _Out>
2298 typename basic_format_context<_Out, _CharT>::iterator
2299 format(__gnu_cxx::__bfloat16_t __u,
2300 basic_format_context<_Out, _CharT>& __fc)
const
2301 {
return _M_f.format((
float)__u, __fc); }
2304 __format::__formatter_fp<_CharT> _M_f;
2312 template<__format::__
char _CharT>
2313 struct formatter<const void*, _CharT>
2315 formatter() =
default;
2317 constexpr typename basic_format_parse_context<_CharT>::iterator
2318 parse(basic_format_parse_context<_CharT>& __pc)
2320 __format::_Spec<_CharT> __spec{};
2321 const auto __last = __pc.end();
2322 auto __first = __pc.begin();
2324 auto __finalize = [
this, &__spec] {
2328 auto __finished = [&] {
2329 if (__first == __last || *__first ==
'}')
2340 __first = __spec._M_parse_fill_and_align(__first, __last);
2346#if __cplusplus > 202302L || ! defined __STRICT_ANSI__
2347#define _GLIBCXX_P2518R3 1
2349#define _GLIBCXX_P2518R3 0
2353 __first = __spec._M_parse_zero_fill(__first, __last);
2358 __first = __spec._M_parse_width(__first, __last, __pc);
2360 if (__first != __last)
2362 if (*__first ==
'p')
2365 else if (*__first ==
'P')
2369 __spec._M_type = __format::_Pres_P;
2378 __format::__failed_to_parse_format_spec();
2381 template<
typename _Out>
2382 typename basic_format_context<_Out, _CharT>::iterator
2383 format(
const void* __v, basic_format_context<_Out, _CharT>& __fc)
const
2385 auto __u =
reinterpret_cast<__UINTPTR_TYPE__
>(__v);
2386 char __buf[2 +
sizeof(__v) * 2];
2387 auto [__ptr, __ec] = std::to_chars(__buf + 2,
std::end(__buf),
2389 int __n = __ptr - __buf;
2393 if (_M_spec._M_type == __format::_Pres_P)
2396 for (
auto __p = __buf + 2; __p != __ptr; ++__p)
2397#
if __has_builtin(__builtin_toupper)
2398 *__p = __builtin_toupper(*__p);
2405 basic_string_view<_CharT> __str;
2406 if constexpr (is_same_v<_CharT, char>)
2407 __str = string_view(__buf, __n);
2408#ifdef _GLIBCXX_USE_WCHAR_T
2411 auto __p = (_CharT*)__builtin_alloca(__n *
sizeof(_CharT));
2412 std::__to_wstring_numeric(__buf, __n, __p);
2413 __str = wstring_view(__p, __n);
2418 if (_M_spec._M_zero_fill)
2420 size_t __width = _M_spec._M_get_width(__fc);
2421 if (__width <= __str.size())
2422 return __format::__write(__fc.out(), __str);
2424 auto __out = __fc.out();
2426 __out = __format::__write(
std::move(__out), __str.substr(0, 2));
2427 __str.remove_prefix(2);
2428 size_t __nfill = __width - __n;
2429 return __format::__write_padded(
std::move(__out), __str,
2430 __format::_Align_right,
2431 __nfill, _CharT(
'0'));
2435 return __format::__write_padded_as_spec(__str, __n, __fc, _M_spec,
2436 __format::_Align_right);
2440 __format::_Spec<_CharT> _M_spec{};
2443 template<__format::__
char _CharT>
2444 struct formatter<void*, _CharT>
2446 formatter() =
default;
2448 [[__gnu__::__always_inline__]]
2449 constexpr typename basic_format_parse_context<_CharT>::iterator
2450 parse(basic_format_parse_context<_CharT>& __pc)
2451 {
return _M_f.parse(__pc); }
2453 template<
typename _Out>
2454 typename basic_format_context<_Out, _CharT>::iterator
2455 format(
void* __v, basic_format_context<_Out, _CharT>& __fc)
const
2456 {
return _M_f.format(__v, __fc); }
2459 formatter<const void*, _CharT> _M_f;
2462 template<__format::__
char _CharT>
2463 struct formatter<nullptr_t, _CharT>
2465 formatter() =
default;
2467 [[__gnu__::__always_inline__]]
2468 constexpr typename basic_format_parse_context<_CharT>::iterator
2469 parse(basic_format_parse_context<_CharT>& __pc)
2470 {
return _M_f.parse(__pc); }
2472 template<
typename _Out>
2473 typename basic_format_context<_Out, _CharT>::iterator
2474 format(nullptr_t, basic_format_context<_Out, _CharT>& __fc)
const
2475 {
return _M_f.format(
nullptr, __fc); }
2478 formatter<const void*, _CharT> _M_f;
2482#if defined _GLIBCXX_USE_WCHAR_T && __cpp_lib_format_ranges
2486 namespace __format {
struct __disabled; }
2490 struct formatter<char*,
wchar_t>
2491 :
private formatter<__format::__disabled, wchar_t> { };
2493 struct formatter<const char*,
wchar_t>
2494 :
private formatter<__format::__disabled, wchar_t> { };
2495 template<
size_t _Nm>
2496 struct formatter<char[_Nm], wchar_t>
2497 :
private formatter<__format::__disabled, wchar_t> { };
2498 template<
class _Traits,
class _Allocator>
2499 struct formatter<basic_string<char, _Traits, _Allocator>, wchar_t>
2500 :
private formatter<__format::__disabled, wchar_t> { };
2501 template<
class _Traits>
2502 struct formatter<basic_string_view<char, _Traits>, wchar_t>
2503 :
private formatter<__format::__disabled, wchar_t> { };
2509 template<
typename _Tp,
typename _Context,
2511 =
typename _Context::template formatter_type<remove_const_t<_Tp>>,
2512 typename _ParseContext
2513 = basic_format_parse_context<typename _Context::char_type>>
2514 concept __parsable_with
2515 = semiregular<_Formatter>
2516 &&
requires (_Formatter __f, _ParseContext __pc)
2518 { __f.parse(__pc) } -> same_as<typename _ParseContext::iterator>;
2521 template<
typename _Tp,
typename _Context,
2523 =
typename _Context::template formatter_type<remove_const_t<_Tp>>,
2524 typename _ParseContext
2525 = basic_format_parse_context<typename _Context::char_type>>
2526 concept __formattable_with
2527 = semiregular<_Formatter>
2528 &&
requires (
const _Formatter __cf, _Tp&& __t, _Context __fc)
2530 { __cf.format(__t, __fc) } -> same_as<typename _Context::iterator>;
2534 template<
typename _CharT>
2535 using _Iter_for = back_insert_iterator<basic_string<_CharT>>;
2537 template<
typename _Tp,
typename _CharT,
2538 typename _Context = basic_format_context<_Iter_for<_CharT>, _CharT>>
2539 concept __formattable_impl
2540 = __parsable_with<_Tp, _Context> && __formattable_with<_Tp, _Context>;
2547#if __cplusplus > 202002L
2549 template<
typename _Tp,
typename _CharT>
2551 = __format::__formattable_impl<remove_reference_t<_Tp>, _CharT>;
2554#if __cpp_lib_format_ranges
2558 template<
typename _Rg,
typename _CharT>
2559 concept __const_formattable_range
2560 = ranges::input_range<const _Rg>
2561 && formattable<ranges::range_reference_t<const _Rg>, _CharT>;
2563 template<
typename _Rg,
typename _CharT>
2564 using __maybe_const_range
2565 = conditional_t<__const_formattable_range<_Rg, _CharT>,
const _Rg, _Rg>;
2572 template<
typename _Out>
2573 struct format_to_n_result
2576 iter_difference_t<_Out>
size;
2579_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
2580template<
typename,
typename>
class vector;
2581_GLIBCXX_END_NAMESPACE_CONTAINER
2586 template<
typename _CharT>
2589 _Sink<_CharT>* _M_sink =
nullptr;
2592 using iterator_category = output_iterator_tag;
2593 using value_type = void;
2594 using difference_type = ptrdiff_t;
2595 using pointer = void;
2596 using reference = void;
2598 _Sink_iter() =
default;
2599 _Sink_iter(
const _Sink_iter&) =
default;
2600 _Sink_iter& operator=(
const _Sink_iter&) =
default;
2602 [[__gnu__::__always_inline__]]
2604 _Sink_iter(_Sink<_CharT>& __sink) : _M_sink(
std::
addressof(__sink)) { }
2606 [[__gnu__::__always_inline__]]
2607 constexpr _Sink_iter&
2608 operator=(_CharT __c)
2610 _M_sink->_M_write(__c);
2614 [[__gnu__::__always_inline__]]
2615 constexpr _Sink_iter&
2616 operator=(basic_string_view<_CharT> __s)
2618 _M_sink->_M_write(__s);
2622 [[__gnu__::__always_inline__]]
2623 constexpr _Sink_iter&
2626 [[__gnu__::__always_inline__]]
2627 constexpr _Sink_iter&
2628 operator++() {
return *
this; }
2630 [[__gnu__::__always_inline__]]
2631 constexpr _Sink_iter
2632 operator++(
int) {
return *
this; }
2635 _M_reserve(
size_t __n)
const
2636 {
return _M_sink->_M_reserve(__n); }
2642 template<
typename _CharT>
2645 friend class _Sink_iter<_CharT>;
2647 span<_CharT> _M_span;
2648 typename span<_CharT>::iterator _M_next;
2654 virtual void _M_overflow() = 0;
2658 [[__gnu__::__always_inline__]]
2660 _Sink(span<_CharT> __span) noexcept
2661 : _M_span(__span), _M_next(__span.begin())
2665 [[__gnu__::__always_inline__]]
2667 _M_used() const noexcept
2668 {
return _M_span.first(_M_next - _M_span.begin()); }
2671 [[__gnu__::__always_inline__]]
2672 constexpr span<_CharT>
2673 _M_unused() const noexcept
2674 {
return _M_span.subspan(_M_next - _M_span.begin()); }
2677 [[__gnu__::__always_inline__]]
2679 _M_rewind() noexcept
2680 { _M_next = _M_span.begin(); }
2684 _M_reset(span<_CharT> __s,
size_t __pos = 0) noexcept
2687 _M_next = __s.begin() + __pos;
2692 _M_write(_CharT __c)
2695 if (_M_next - _M_span.begin() == std::ssize(_M_span)) [[unlikely]]
2700 _M_write(basic_string_view<_CharT> __s)
2702 span __to = _M_unused();
2703 while (__to.size() <= __s.size())
2705 __s.copy(__to.data(), __to.size());
2706 _M_next += __to.size();
2707 __s.remove_prefix(__to.size());
2713 __s.copy(__to.data(), __s.size());
2714 _M_next += __s.size();
2723 explicit operator bool() const noexcept {
return _M_sink; }
2725 _CharT* get() const noexcept {
return _M_sink->_M_next.operator->(); }
2727 void _M_bump(
size_t __n) { _M_sink->_M_bump(__n); }
2735 virtual _Reservation
2736 _M_reserve(
size_t __n)
2738 if (__n <= _M_unused().
size())
2741 if (__n <= _M_span.size())
2744 if (__n <= _M_unused().
size())
2757 _Sink(
const _Sink&) =
delete;
2758 _Sink& operator=(
const _Sink&) =
delete;
2760 [[__gnu__::__always_inline__]]
2761 constexpr _Sink_iter<_CharT>
2763 {
return _Sink_iter<_CharT>(*
this); }
2767 template<
typename _CharT>
2768 class _Buf_sink :
public _Sink<_CharT>
2771 _CharT _M_buf[32 *
sizeof(
void*) /
sizeof(_CharT)];
2773 [[__gnu__::__always_inline__]]
2775 _Buf_sink() noexcept
2776 : _Sink<_CharT>(_M_buf)
2780 using _GLIBCXX_STD_C::vector;
2784 template<
typename _Seq>
2785 class _Seq_sink final :
public _Buf_sink<typename _Seq::value_type>
2787 using _CharT =
typename _Seq::value_type;
2793 _M_overflow()
override
2795 auto __s = this->_M_used();
2796 if (__s.empty()) [[unlikely]]
2800 _GLIBCXX_DEBUG_ASSERT(__s.data() != _M_seq.data());
2802 if constexpr (__is_specialization_of<_Seq, basic_string>)
2803 _M_seq.append(__s.data(), __s.size());
2805 _M_seq.insert(_M_seq.end(), __s.begin(), __s.end());
2811 typename _Sink<_CharT>::_Reservation
2812 _M_reserve(
size_t __n)
override
2821 if constexpr (__is_specialization_of<_Seq, basic_string>
2822 || __is_specialization_of<_Seq, vector>)
2825 if (this->_M_used().size()) [[unlikely]]
2826 _Seq_sink::_M_overflow();
2829 const auto __sz = _M_seq.size();
2830 if constexpr (is_same_v<string, _Seq> || is_same_v<wstring, _Seq>)
2831 _M_seq.__resize_and_overwrite(__sz + __n,
2832 [](
auto,
auto __n2) {
2836 _M_seq.resize(__sz + __n);
2840 this->_M_reset(_M_seq, __sz);
2844 return _Sink<_CharT>::_M_reserve(__n);
2848 _M_bump(
size_t __n)
override
2850 if constexpr (__is_specialization_of<_Seq, basic_string>
2851 || __is_specialization_of<_Seq, vector>)
2853 auto __s = this->_M_used();
2854 _GLIBCXX_DEBUG_ASSERT(__s.data() == _M_seq.data());
2856 _M_seq.resize(__s.size() + __n);
2858 this->_M_reset(this->_M_buf);
2866 [[__gnu__::__always_inline__]]
2867 _Seq_sink() noexcept(is_nothrow_default_constructible_v<_Seq>)
2870 _Seq_sink(_Seq&& __s)
noexcept(is_nothrow_move_constructible_v<_Seq>)
2874 using _Sink<_CharT>::out;
2879 if (this->_M_used().
size() != 0)
2880 _Seq_sink::_M_overflow();
2889 auto __s = this->_M_used();
2892 if (__s.size() != 0)
2893 _Seq_sink::_M_overflow();
2900 template<
typename _CharT,
typename _Alloc = allocator<_CharT>>
2902 = _Seq_sink<basic_string<_CharT, char_traits<_CharT>, _Alloc>>;
2910 template<
typename _CharT,
typename _OutIter>
2911 class _Iter_sink :
public _Buf_sink<_CharT>
2914 iter_difference_t<_OutIter> _M_max;
2917 size_t _M_count = 0;
2920 _M_overflow()
override
2922 auto __s = this->_M_used();
2924 _M_out = ranges::copy(__s,
std::move(_M_out)).out;
2925 else if (_M_count <
static_cast<size_t>(_M_max))
2927 auto __max = _M_max - _M_count;
2928 span<_CharT> __first;
2929 if (__max < __s.size())
2930 __first = __s.first(
static_cast<size_t>(__max));
2933 _M_out = ranges::copy(__first,
std::move(_M_out)).out;
2936 _M_count += __s.size();
2940 [[__gnu__::__always_inline__]]
2942 _Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __max = -1)
2943 : _M_out(
std::
move(__out)), _M_max(__max)
2946 using _Sink<_CharT>::out;
2948 format_to_n_result<_OutIter>
2951 if (this->_M_used().
size() != 0)
2952 _Iter_sink::_M_overflow();
2953 iter_difference_t<_OutIter> __count(_M_count);
2965 template<
typename _CharT, contiguous_iterator _OutIter>
2966 requires same_as<iter_value_t<_OutIter>, _CharT>
2967 class _Iter_sink<_CharT, _OutIter> :
public _Sink<_CharT>
2970 iter_difference_t<_OutIter> _M_max = -1;
2972 size_t _M_count = 0;
2978 _M_overflow()
override
2980 if (this->_M_unused().
size() != 0)
2983 auto __s = this->_M_used();
2987 _M_count += __s.size();
2991 this->_M_reset(this->_M_buf);
2997 this->_M_reset({__s.data(), __s.size() + 1024}, __s.size());
3001 typename _Sink<_CharT>::_Reservation
3002 _M_reserve(
size_t __n)
final
3004 auto __avail = this->_M_unused();
3005 if (__n > __avail.size())
3010 auto __s = this->_M_used();
3011 this->_M_reset({__s.data(), __s.size() + __n}, __s.size());
3018 _S_make_span(_CharT* __ptr, iter_difference_t<_OutIter> __n,
3019 span<_CharT> __buf)
noexcept
3026 if constexpr (!is_integral_v<iter_difference_t<_OutIter>>
3027 ||
sizeof(__n) >
sizeof(
size_t))
3030 auto __m = iter_difference_t<_OutIter>((
size_t)-1);
3034 return {__ptr, (size_t)__n};
3037#if __has_builtin(__builtin_dynamic_object_size)
3038 if (
size_t __bytes = __builtin_dynamic_object_size(__ptr, 2))
3039 return {__ptr, __bytes /
sizeof(_CharT)};
3042 const auto __off =
reinterpret_cast<__UINTPTR_TYPE__
>(__ptr) % 1024;
3043 __n = (1024 - __off) /
sizeof(_CharT);
3044 if (__n > 0) [[likely]]
3045 return {__ptr,
static_cast<size_t>(__n)};
3052 _Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __n = -1) noexcept
3053 : _Sink<_CharT>(_S_make_span(
std::
to_address(__out), __n, _M_buf)),
3054 _M_first(__out), _M_max(__n)
3057 format_to_n_result<_OutIter>
3060 auto __s = this->_M_used();
3061 if (__s.data() == _M_buf)
3064 iter_difference_t<_OutIter> __count(_M_count + __s.size());
3065 return { _M_first + _M_max, __count };
3069 iter_difference_t<_OutIter> __count(__s.size());
3070 return { _M_first + __count, __count };
3075 enum _Arg_t :
unsigned char {
3076 _Arg_none, _Arg_bool, _Arg_c, _Arg_i, _Arg_u, _Arg_ll, _Arg_ull,
3077 _Arg_flt, _Arg_dbl, _Arg_ldbl, _Arg_str, _Arg_sv, _Arg_ptr, _Arg_handle,
3078 _Arg_i128, _Arg_u128,
3079 _Arg_bf16, _Arg_f16, _Arg_f32, _Arg_f64,
3080#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3082 _Arg_f128 = _Arg_ldbl,
3083 _Arg_ibm128 = _Arg_next_value_,
3090 template<
typename _Context>
3093 using _CharT =
typename _Context::char_type;
3109 unsigned long long _M_ull;
3112#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3113 long double _M_ldbl;
3115 const _CharT* _M_str;
3116 basic_string_view<_CharT> _M_sv;
3118 _HandleBase _M_handle;
3119#ifdef __SIZEOF_INT128__
3121 unsigned __int128 _M_u128;
3123#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3126#elif _GLIBCXX_FORMAT_F128 == 2
3127 __float128_t _M_f128;
3131 [[__gnu__::__always_inline__]]
3132 _Arg_value() : _M_none() { }
3135 template<
typename _Tp>
3136 _Arg_value(in_place_type_t<_Tp>, _Tp __val)
3137 { _S_get<_Tp>() = __val; }
3140 template<
typename _Tp,
typename _Self>
3141 [[__gnu__::__always_inline__]]
3143 _S_get(_Self& __u)
noexcept
3145 if constexpr (is_same_v<_Tp, bool>)
3147 else if constexpr (is_same_v<_Tp, _CharT>)
3149 else if constexpr (is_same_v<_Tp, int>)
3151 else if constexpr (is_same_v<_Tp, unsigned>)
3153 else if constexpr (is_same_v<_Tp, long long>)
3155 else if constexpr (is_same_v<_Tp, unsigned long long>)
3157 else if constexpr (is_same_v<_Tp, float>)
3159 else if constexpr (is_same_v<_Tp, double>)
3161#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3162 else if constexpr (is_same_v<_Tp, long double>)
3165 else if constexpr (is_same_v<_Tp, __ieee128>)
3167 else if constexpr (is_same_v<_Tp, __ibm128>)
3168 return __u._M_ibm128;
3170 else if constexpr (is_same_v<_Tp, const _CharT*>)
3172 else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
3174 else if constexpr (is_same_v<_Tp, const void*>)
3176#ifdef __SIZEOF_INT128__
3177 else if constexpr (is_same_v<_Tp, __int128>)
3179 else if constexpr (is_same_v<_Tp, unsigned __int128>)
3182#if _GLIBCXX_FORMAT_F128 == 2
3183 else if constexpr (is_same_v<_Tp, __float128_t>)
3186 else if constexpr (derived_from<_Tp, _HandleBase>)
3187 return static_cast<_Tp&
>(__u._M_handle);
3191 template<
typename _Tp>
3192 [[__gnu__::__always_inline__]]
3195 {
return _S_get<_Tp>(*
this); }
3197 template<
typename _Tp>
3198 [[__gnu__::__always_inline__]]
3200 _M_get() const noexcept
3201 {
return _S_get<_Tp>(*
this); }
3203 template<
typename _Tp>
3204 [[__gnu__::__always_inline__]]
3206 _M_set(_Tp __v)
noexcept
3208 if constexpr (derived_from<_Tp, _HandleBase>)
3209 std::construct_at(&_M_handle, __v);
3211 _S_get<_Tp>(*
this) = __v;
3216 template<
typename _Context,
typename... _Args>
3222 template<
typename _Context>
3223 class basic_format_arg
3225 using _CharT =
typename _Context::char_type;
3227 template<
typename _Tp>
3228 static constexpr bool __formattable
3229 = __format::__formattable_with<_Tp, _Context>;
3232 class handle :
public __format::_Arg_value<_Context>::_HandleBase
3234 using _Base =
typename __format::_Arg_value<_Context>::_HandleBase;
3237 template<
typename _Tp>
3238 using __maybe_const_t
3239 = __conditional_t<__formattable<const _Tp>,
const _Tp, _Tp>;
3241 template<
typename _Tq>
3243 _S_format(basic_format_parse_context<_CharT>& __parse_ctx,
3244 _Context& __format_ctx,
const void* __ptr)
3246 using _Td = remove_const_t<_Tq>;
3247 typename _Context::template formatter_type<_Td> __f;
3248 __parse_ctx.advance_to(__f.parse(__parse_ctx));
3249 _Tq& __val = *
const_cast<_Tq*
>(
static_cast<const _Td*
>(__ptr));
3250 __format_ctx.advance_to(__f.format(__val, __format_ctx));
3253 template<
typename _Tp>
3255 handle(_Tp& __val)
noexcept
3257 this->_M_ptr = __builtin_addressof(__val);
3258 auto __func = _S_format<__maybe_const_t<_Tp>>;
3259 this->_M_func =
reinterpret_cast<void(*)()
>(__func);
3262 friend class basic_format_arg<_Context>;
3265 handle(
const handle&) =
default;
3266 handle& operator=(
const handle&) =
default;
3268 [[__gnu__::__always_inline__]]
3270 format(basic_format_parse_context<_CharT>& __pc, _Context& __fc)
const
3272 using _Func = void(*)(basic_format_parse_context<_CharT>&,
3273 _Context&,
const void*);
3274 auto __f =
reinterpret_cast<_Func
>(this->_M_func);
3275 __f(__pc, __fc, this->_M_ptr);
3279 [[__gnu__::__always_inline__]]
3280 basic_format_arg() noexcept : _M_type(__format::_Arg_none) { }
3282 [[nodiscard,__gnu__::__always_inline__]]
3283 explicit operator bool() const noexcept
3284 {
return _M_type != __format::_Arg_none; }
3287 template<
typename _Ctx>
3288 friend class basic_format_args;
3290 template<
typename _Ctx,
typename... _Args>
3291 friend class __format::_Arg_store;
3293 static_assert(is_trivially_copyable_v<__format::_Arg_value<_Context>>);
3295 __format::_Arg_value<_Context> _M_val;
3296 __format::_Arg_t _M_type;
3301 template<
typename _Tp>
3302 static consteval auto
3305 using _Td = remove_const_t<_Tp>;
3306 if constexpr (is_same_v<_Td, bool>)
3307 return type_identity<bool>();
3308 else if constexpr (is_same_v<_Td, _CharT>)
3309 return type_identity<_CharT>();
3310 else if constexpr (is_same_v<_Td, char> && is_same_v<_CharT, wchar_t>)
3311 return type_identity<_CharT>();
3312#ifdef __SIZEOF_INT128__
3313 else if constexpr (is_same_v<_Td, __int128>)
3314 return type_identity<__int128>();
3315 else if constexpr (is_same_v<_Td, unsigned __int128>)
3316 return type_identity<unsigned __int128>();
3318 else if constexpr (__is_signed_integer<_Td>::value)
3320 if constexpr (
sizeof(_Td) <=
sizeof(
int))
3321 return type_identity<int>();
3322 else if constexpr (
sizeof(_Td) <=
sizeof(
long long))
3323 return type_identity<long long>();
3325 else if constexpr (__is_unsigned_integer<_Td>::value)
3327 if constexpr (
sizeof(_Td) <=
sizeof(
unsigned))
3328 return type_identity<unsigned>();
3329 else if constexpr (
sizeof(_Td) <=
sizeof(
unsigned long long))
3330 return type_identity<unsigned long long>();
3332 else if constexpr (is_same_v<_Td, float>)
3333 return type_identity<float>();
3334 else if constexpr (is_same_v<_Td, double>)
3335 return type_identity<double>();
3336#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3337 else if constexpr (is_same_v<_Td, long double>)
3338 return type_identity<long double>();
3340 else if constexpr (is_same_v<_Td, __ibm128>)
3341 return type_identity<__ibm128>();
3342 else if constexpr (is_same_v<_Td, __ieee128>)
3343 return type_identity<__ieee128>();
3346#if defined(__FLT16_DIG__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3347 else if constexpr (is_same_v<_Td, _Float16>)
3348 return type_identity<float>();
3351#if defined(__BFLT16_DIG__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3352 else if constexpr (is_same_v<_Td,
decltype(0.0bf16)>)
3353 return type_identity<float>();
3357 else if constexpr (is_same_v<_Td, _Float32>)
3358# ifdef _GLIBCXX_FLOAT_IS_IEEE_BINARY32
3359 return type_identity<float>();
3361 return type_identity<_Float32>();
3365 else if constexpr (is_same_v<_Td, _Float64>)
3366# ifdef _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
3367 return type_identity<double>();
3369 return type_identity<_Float64>();
3372#if _GLIBCXX_FORMAT_F128
3374 else if constexpr (is_same_v<_Td, _Float128>)
3375 return type_identity<__format::__float128_t>();
3377# if __SIZEOF_FLOAT128__
3378 else if constexpr (is_same_v<_Td, __float128>)
3379 return type_identity<__format::__float128_t>();
3382 else if constexpr (__is_specialization_of<_Td, basic_string_view>
3383 || __is_specialization_of<_Td, basic_string>)
3385 if constexpr (is_same_v<typename _Td::value_type, _CharT>)
3386 return type_identity<basic_string_view<_CharT>>();
3388 return type_identity<handle>();
3390 else if constexpr (is_same_v<decay_t<_Td>,
const _CharT*>)
3391 return type_identity<const _CharT*>();
3392 else if constexpr (is_same_v<decay_t<_Td>, _CharT*>)
3393 return type_identity<const _CharT*>();
3394 else if constexpr (is_void_v<remove_pointer_t<_Td>>)
3395 return type_identity<const void*>();
3396 else if constexpr (is_same_v<_Td, nullptr_t>)
3397 return type_identity<const void*>();
3399 return type_identity<handle>();
3403 template<
typename _Tp>
3404 using _Normalize =
typename decltype(_S_to_arg_type<_Tp>())::type;
3407 template<
typename _Tp>
3408 static consteval __format::_Arg_t
3411 using namespace __format;
3412 if constexpr (is_same_v<_Tp, bool>)
3414 else if constexpr (is_same_v<_Tp, _CharT>)
3416 else if constexpr (is_same_v<_Tp, int>)
3418 else if constexpr (is_same_v<_Tp, unsigned>)
3420 else if constexpr (is_same_v<_Tp, long long>)
3422 else if constexpr (is_same_v<_Tp, unsigned long long>)
3424 else if constexpr (is_same_v<_Tp, float>)
3426 else if constexpr (is_same_v<_Tp, double>)
3428#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3429 else if constexpr (is_same_v<_Tp, long double>)
3433 else if constexpr (is_same_v<_Tp, __ibm128>)
3435 else if constexpr (is_same_v<_Tp, __ieee128>)
3438 else if constexpr (is_same_v<_Tp, const _CharT*>)
3440 else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
3442 else if constexpr (is_same_v<_Tp, const void*>)
3444#ifdef __SIZEOF_INT128__
3445 else if constexpr (is_same_v<_Tp, __int128>)
3447 else if constexpr (is_same_v<_Tp, unsigned __int128>)
3453#if defined __FLT32_DIG__ && ! _GLIBCXX_FLOAT_IS_IEEE_BINARY32
3454 else if constexpr (is_same_v<_Tp, _Float32>)
3457#if defined __FLT64_DIG__ && ! _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
3458 else if constexpr (is_same_v<_Tp, _Float64>)
3461#if _GLIBCXX_FORMAT_F128 == 2
3462 else if constexpr (is_same_v<_Tp, __format::__float128_t>)
3465 else if constexpr (is_same_v<_Tp, handle>)
3469 template<
typename _Tp>
3471 _M_set(_Tp __v)
noexcept
3473 _M_type = _S_to_enum<_Tp>();
3477 template<
typename _Tp>
3478 requires __format::__formattable_with<_Tp, _Context>
3480 basic_format_arg(_Tp& __v)
noexcept
3482 using _Td = _Normalize<_Tp>;
3483 if constexpr (is_same_v<_Td, basic_string_view<_CharT>>)
3484 _M_set(_Td{__v.data(), __v.size()});
3485 else if constexpr (is_same_v<remove_const_t<_Tp>,
char>
3486 && is_same_v<_CharT, wchar_t>)
3487 _M_set(
static_cast<_Td
>(
static_cast<unsigned char>(__v)));
3489 _M_set(
static_cast<_Td
>(__v));
3492 template<
typename _Ctx,
typename... _Argz>
3494 make_format_args(_Argz&...)
noexcept;
3496 template<
typename _Visitor,
typename _Ctx>
3497 friend decltype(
auto)
3498 visit_format_arg(_Visitor&& __vis, basic_format_arg<_Ctx>);
3500 template<
typename _Visitor>
3502 _M_visit(_Visitor&& __vis, __format::_Arg_t __type)
3504 using namespace __format;
3508 return std::forward<_Visitor>(__vis)(_M_val._M_none);
3510 return std::forward<_Visitor>(__vis)(_M_val._M_bool);
3512 return std::forward<_Visitor>(__vis)(_M_val._M_c);
3514 return std::forward<_Visitor>(__vis)(_M_val._M_i);
3516 return std::forward<_Visitor>(__vis)(_M_val._M_u);
3518 return std::forward<_Visitor>(__vis)(_M_val._M_ll);
3520 return std::forward<_Visitor>(__vis)(_M_val._M_ull);
3521#if __glibcxx_to_chars
3523 return std::forward<_Visitor>(__vis)(_M_val._M_flt);
3525 return std::forward<_Visitor>(__vis)(_M_val._M_dbl);
3526#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3528 return std::forward<_Visitor>(__vis)(_M_val._M_ldbl);
3531 return std::forward<_Visitor>(__vis)(_M_val._M_f128);
3533 return std::forward<_Visitor>(__vis)(_M_val._M_ibm128);
3537 return std::forward<_Visitor>(__vis)(_M_val._M_str);
3539 return std::forward<_Visitor>(__vis)(_M_val._M_sv);
3541 return std::forward<_Visitor>(__vis)(_M_val._M_ptr);
3544 auto& __h =
static_cast<handle&
>(_M_val._M_handle);
3545 return std::forward<_Visitor>(__vis)(__h);
3547#ifdef __SIZEOF_INT128__
3549 return std::forward<_Visitor>(__vis)(_M_val._M_i128);
3551 return std::forward<_Visitor>(__vis)(_M_val._M_u128);
3554#if _GLIBCXX_FORMAT_F128 == 2
3556 return std::forward<_Visitor>(__vis)(_M_val._M_f128);
3561 __builtin_unreachable();
3566 template<
typename _Visitor,
typename _Context>
3567 inline decltype(
auto)
3568 visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg)
3570 return __arg._M_visit(std::forward<_Visitor>(__vis), __arg._M_type);
3576 struct _WidthPrecVisitor
3578 template<
typename _Tp>
3580 operator()(_Tp& __arg)
const
3582 if constexpr (is_same_v<_Tp, monostate>)
3583 __format::__invalid_arg_id_in_format_string();
3587 else if constexpr (
sizeof(_Tp) <=
sizeof(
long long))
3591 if constexpr (__is_unsigned_integer<_Tp>::value)
3593 else if constexpr (__is_signed_integer<_Tp>::value)
3597 __throw_format_error(
"format error: argument used for width or "
3598 "precision must be a non-negative integer");
3602 template<
typename _Context>
3604 __int_from_arg(
const basic_format_arg<_Context>& __arg)
3605 {
return std::visit_format_arg(_WidthPrecVisitor(), __arg); }
3608 template<
int _Bits,
size_t _Nm>
3610 __pack_arg_types(
const array<_Arg_t, _Nm>& __types)
3612 __UINT64_TYPE__ __packed_types = 0;
3613 for (
auto __i = __types.rbegin(); __i != __types.rend(); ++__i)
3614 __packed_types = (__packed_types << _Bits) | *__i;
3615 return __packed_types;
3620 template<
typename _Context>
3621 class basic_format_args
3623 static constexpr int _S_packed_type_bits = 5;
3624 static constexpr int _S_packed_type_mask = 0b11111;
3625 static constexpr int _S_max_packed_args = 12;
3627 static_assert( __format::_Arg_max_ <= (1 << _S_packed_type_bits) );
3629 template<
typename... _Args>
3630 using _Store = __format::_Arg_store<_Context, _Args...>;
3632 template<
typename _Ctx,
typename... _Args>
3633 friend class __format::_Arg_store;
3635 using uint64_t = __UINT64_TYPE__;
3636 using _Format_arg = basic_format_arg<_Context>;
3637 using _Format_arg_val = __format::_Arg_value<_Context>;
3643 uint64_t _M_packed_size : 4;
3644 uint64_t _M_unpacked_size : 60;
3647 const _Format_arg_val* _M_values;
3648 const _Format_arg* _M_args;
3652 _M_size() const noexcept
3653 {
return _M_packed_size ? _M_packed_size : _M_unpacked_size; }
3655 typename __format::_Arg_t
3656 _M_type(
size_t __i)
const noexcept
3658 uint64_t __t = _M_unpacked_size >> (__i * _S_packed_type_bits);
3659 return static_cast<__format::_Arg_t
>(__t & _S_packed_type_mask);
3662 template<
typename _Ctx,
typename... _Args>
3664 make_format_args(_Args&...)
noexcept;
3667 template<
typename... _Args>
3668 static consteval array<__format::_Arg_t,
sizeof...(_Args)>
3670 {
return {_Format_arg::template _S_to_enum<_Args>()...}; }
3673 template<
typename... _Args>
3674 basic_format_args(
const _Store<_Args...>& __store)
noexcept;
3676 [[nodiscard,__gnu__::__always_inline__]]
3677 basic_format_arg<_Context>
3678 get(
size_t __i)
const noexcept
3680 basic_format_arg<_Context> __arg;
3681 if (__i < _M_packed_size)
3683 __arg._M_type = _M_type(__i);
3684 __arg._M_val = _M_values[__i];
3686 else if (_M_packed_size == 0 && __i < _M_unpacked_size)
3687 __arg = _M_args[__i];
3694 template<
typename _Context,
typename... _Args>
3695 basic_format_args(__format::_Arg_store<_Context, _Args...>)
3696 -> basic_format_args<_Context>;
3698 template<
typename _Context,
typename... _Args>
3700 make_format_args(_Args&... __fmt_args)
noexcept;
3703 template<
typename _Context,
typename... _Args>
3704 class __format::_Arg_store
3706 friend std::basic_format_args<_Context>;
3708 template<
typename _Ctx,
typename... _Argz>
3710#if _GLIBCXX_INLINE_VERSION
3713 make_format_args(_Argz&...)
noexcept;
3717 static constexpr bool _S_values_only
3718 =
sizeof...(_Args) <= basic_format_args<_Context>::_S_max_packed_args;
3721 = __conditional_t<_S_values_only,
3722 __format::_Arg_value<_Context>,
3723 basic_format_arg<_Context>>;
3725 _Element_t _M_args[
sizeof...(_Args)];
3727 template<
typename _Tp>
3729 _S_make_elt(_Tp& __v)
3731 using _Tq = remove_const_t<_Tp>;
3732 using _CharT =
typename _Context::char_type;
3733 static_assert(is_default_constructible_v<formatter<_Tq, _CharT>>,
3734 "std::formatter must be specialized for the type "
3735 "of each format arg");
3736 using __format::__formattable_with;
3737 if constexpr (is_const_v<_Tp>)
3738 if constexpr (!__formattable_with<_Tp, _Context>)
3739 if constexpr (__formattable_with<_Tq, _Context>)
3740 static_assert(__formattable_with<_Tp, _Context>,
3741 "format arg must be non-const because its "
3742 "std::formatter specialization has a "
3743 "non-const reference parameter");
3744 basic_format_arg<_Context> __arg(__v);
3745 if constexpr (_S_values_only)
3746 return __arg._M_val;
3751 template<
typename... _Tp>
3752 requires (
sizeof...(_Tp) ==
sizeof...(_Args))
3753 [[__gnu__::__always_inline__]]
3754 _Arg_store(_Tp&... __a) noexcept
3755 : _M_args{_S_make_elt(__a)...}
3759 template<
typename _Context>
3760 class __format::_Arg_store<_Context>
3763 template<
typename _Context>
3764 template<
typename... _Args>
3766 basic_format_args<_Context>::
3767 basic_format_args(
const _Store<_Args...>& __store)
noexcept
3769 if constexpr (
sizeof...(_Args) == 0)
3772 _M_unpacked_size = 0;
3775 else if constexpr (
sizeof...(_Args) <= _S_max_packed_args)
3778 _M_packed_size =
sizeof...(_Args);
3781 = __format::__pack_arg_types<_S_packed_type_bits>(_S_types_to_pack<_Args...>());
3783 _M_values = __store._M_args;
3790 _M_unpacked_size =
sizeof...(_Args);
3792 _M_args = __store._M_args;
3797 template<
typename _Context = format_context,
typename... _Args>
3798 [[nodiscard,__gnu__::__always_inline__]]
3800 make_format_args(_Args&... __fmt_args)
noexcept
3802 using _Fmt_arg = basic_format_arg<_Context>;
3803 using _Store = __format::_Arg_store<_Context,
typename _Fmt_arg::template
3804 _Normalize<_Args>...>;
3805 return _Store(__fmt_args...);
3808#ifdef _GLIBCXX_USE_WCHAR_T
3810 template<
typename... _Args>
3811 [[nodiscard,__gnu__::__always_inline__]]
3813 make_wformat_args(_Args&... __args)
noexcept
3814 {
return std::make_format_args<wformat_context>(__args...); }
3820 template<
typename _Out,
typename _CharT,
typename _Context>
3822 __do_vformat_to(_Out, basic_string_view<_CharT>,
3823 const basic_format_args<_Context>&,
3824 const locale* =
nullptr);
3836 template<
typename _Out,
typename _CharT>
3837 class basic_format_context
3839 static_assert( output_iterator<_Out, const _CharT&> );
3841 basic_format_args<basic_format_context> _M_args;
3843 __format::_Optional_locale _M_loc;
3845 basic_format_context(basic_format_args<basic_format_context> __args,
3847 : _M_args(__args), _M_out(
std::
move(__out))
3850 basic_format_context(basic_format_args<basic_format_context> __args,
3852 : _M_args(__args), _M_out(
std::
move(__out)), _M_loc(__loc)
3858 basic_format_context(
const basic_format_context&) =
delete;
3859 basic_format_context& operator=(
const basic_format_context&) =
delete;
3861 template<
typename _Out2,
typename _CharT2,
typename _Context2>
3863 __format::__do_vformat_to(_Out2, basic_string_view<_CharT2>,
3864 const basic_format_args<_Context2>&,
3868 ~basic_format_context() =
default;
3870 using iterator = _Out;
3871 using char_type = _CharT;
3872 template<
typename _Tp>
3873 using formatter_type = formatter<_Tp, _CharT>;
3876 basic_format_arg<basic_format_context>
3877 arg(
size_t __id)
const noexcept
3878 {
return _M_args.get(__id); }
3884 iterator out() {
return std::move(_M_out); }
3886 void advance_to(iterator __it) { _M_out =
std::move(__it); }
3898 template<
typename _CharT>
3901 using iterator =
typename basic_format_parse_context<_CharT>::iterator;
3903 basic_format_parse_context<_CharT> _M_pc;
3906 _Scanner(basic_string_view<_CharT> __str,
size_t __nargs = -1)
3907 : _M_pc(__str, __nargs)
3910 constexpr iterator
begin() const noexcept {
return _M_pc.begin(); }
3911 constexpr iterator
end() const noexcept {
return _M_pc.end(); }
3916 basic_string_view<_CharT> __fmt = _M_fmt_str();
3918 if (__fmt.size() == 2 && __fmt[0] ==
'{' && __fmt[1] ==
'}')
3920 _M_pc.advance_to(
begin() + 1);
3921 _M_format_arg(_M_pc.next_arg_id());
3925 size_t __lbr = __fmt.find(
'{');
3926 size_t __rbr = __fmt.find(
'}');
3928 while (__fmt.size())
3930 auto __cmp = __lbr <=> __rbr;
3934 _M_pc.advance_to(
end());
3939 if (__lbr + 1 == __fmt.size()
3940 || (__rbr == __fmt.npos && __fmt[__lbr + 1] !=
'{'))
3941 __format::__unmatched_left_brace_in_format_string();
3942 const bool __is_escape = __fmt[__lbr + 1] ==
'{';
3943 iterator __last =
begin() + __lbr + int(__is_escape);
3944 _M_on_chars(__last);
3945 _M_pc.advance_to(__last + 1);
3946 __fmt = _M_fmt_str();
3949 if (__rbr != __fmt.npos)
3951 __lbr = __fmt.find(
'{');
3955 _M_on_replacement_field();
3956 __fmt = _M_fmt_str();
3957 __lbr = __fmt.find(
'{');
3958 __rbr = __fmt.find(
'}');
3963 if (++__rbr == __fmt.size() || __fmt[__rbr] !=
'}')
3964 __format::__unmatched_right_brace_in_format_string();
3965 iterator __last =
begin() + __rbr;
3966 _M_on_chars(__last);
3967 _M_pc.advance_to(__last + 1);
3968 __fmt = _M_fmt_str();
3969 if (__lbr != __fmt.npos)
3971 __rbr = __fmt.find(
'}');
3976 constexpr basic_string_view<_CharT>
3977 _M_fmt_str() const noexcept
3980 constexpr virtual void _M_on_chars(iterator) { }
3982 constexpr void _M_on_replacement_field()
3984 auto __next =
begin();
3988 __id = _M_pc.next_arg_id();
3989 else if (*__next ==
':')
3991 __id = _M_pc.next_arg_id();
3992 _M_pc.advance_to(++__next);
3996 auto [__i, __ptr] = __format::__parse_arg_id(
begin(),
end());
3997 if (!__ptr || !(*__ptr ==
'}' || *__ptr ==
':'))
3998 __format::__invalid_arg_id_in_format_string();
3999 _M_pc.check_arg_id(__id = __i);
4002 _M_pc.advance_to(++__ptr);
4005 _M_pc.advance_to(__ptr);
4007 _M_format_arg(__id);
4009 __format::__unmatched_left_brace_in_format_string();
4010 _M_pc.advance_to(
begin() + 1);
4013 constexpr virtual void _M_format_arg(
size_t __id) = 0;
4017 template<
typename _Out,
typename _CharT>
4018 class _Formatting_scanner :
public _Scanner<_CharT>
4021 _Formatting_scanner(basic_format_context<_Out, _CharT>& __fc,
4022 basic_string_view<_CharT> __str)
4023 : _Scanner<_CharT>(__str), _M_fc(__fc)
4027 basic_format_context<_Out, _CharT>& _M_fc;
4029 using iterator =
typename _Scanner<_CharT>::iterator;
4032 _M_on_chars(iterator __last)
override
4034 basic_string_view<_CharT> __str(this->
begin(), __last);
4035 _M_fc.advance_to(__format::__write(_M_fc.out(), __str));
4039 _M_format_arg(
size_t __id)
override
4041 using _Context = basic_format_context<_Out, _CharT>;
4042 using handle =
typename basic_format_arg<_Context>::handle;
4044 std::visit_format_arg([
this](
auto& __arg) {
4046 using _Formatter =
typename _Context::template formatter_type<_Type>;
4047 if constexpr (is_same_v<_Type, monostate>)
4048 __format::__invalid_arg_id_in_format_string();
4049 else if constexpr (is_same_v<_Type, handle>)
4050 __arg.format(this->_M_pc, this->_M_fc);
4051 else if constexpr (is_default_constructible_v<_Formatter>)
4054 this->_M_pc.advance_to(__f.parse(this->_M_pc));
4055 this->_M_fc.advance_to(__f.format(__arg, this->_M_fc));
4058 static_assert(__format::__formattable_with<_Type, _Context>);
4059 }, _M_fc.arg(__id));
4064 template<
typename _CharT,
typename... _Args>
4065 class _Checking_scanner :
public _Scanner<_CharT>
4068 (is_default_constructible_v<formatter<_Args, _CharT>> && ...),
4069 "std::formatter must be specialized for each type being formatted");
4073 _Checking_scanner(basic_string_view<_CharT> __str)
4074 : _Scanner<_CharT>(__str, sizeof...(_Args))
4079 _M_format_arg(
size_t __id)
override
4081 if constexpr (
sizeof...(_Args) != 0)
4083 if (__id <
sizeof...(_Args))
4085 _M_parse_format_spec<_Args...>(__id);
4089 __builtin_unreachable();
4092 template<
typename _Tp,
typename... _OtherArgs>
4094 _M_parse_format_spec(
size_t __id)
4098 formatter<_Tp, _CharT> __f;
4099 this->_M_pc.advance_to(__f.parse(this->_M_pc));
4101 else if constexpr (
sizeof...(_OtherArgs) != 0)
4102 _M_parse_format_spec<_OtherArgs...>(__id - 1);
4104 __builtin_unreachable();
4108 template<
typename _Out,
typename _CharT,
typename _Context>
4110 __do_vformat_to(_Out __out, basic_string_view<_CharT> __fmt,
4111 const basic_format_args<_Context>& __args,
4112 const locale* __loc)
4114 _Iter_sink<_CharT, _Out> __sink(
std::move(__out));
4115 _Sink_iter<_CharT> __sink_out;
4117 if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
4120 __sink_out = __sink.out();
4122 if constexpr (is_same_v<_CharT, char>)
4124 if (__fmt.size() == 2 && __fmt[0] ==
'{' && __fmt[1] ==
'}')
4126 bool __done =
false;
4127 std::visit_format_arg([&](
auto& __arg) {
4128 using _Tp = remove_cvref_t<
decltype(__arg)>;
4129 if constexpr (is_same_v<_Tp, bool>)
4131 size_t __len = 4 + !__arg;
4132 const char* __chars[] = {
"false",
"true" };
4133 if (
auto __res = __sink_out._M_reserve(__len))
4135 __builtin_memcpy(__res.get(), __chars[__arg], __len);
4136 __res._M_bump(__len);
4140 else if constexpr (is_same_v<_Tp, char>)
4142 if (
auto __res = __sink_out._M_reserve(1))
4144 *__res.get() = __arg;
4149 else if constexpr (is_integral_v<_Tp>)
4151 make_unsigned_t<_Tp> __uval;
4152 const bool __neg = __arg < 0;
4154 __uval = make_unsigned_t<_Tp>(~__arg) + 1u;
4157 const auto __n = __detail::__to_chars_len(__uval);
4158 if (
auto __res = __sink_out._M_reserve(__n + __neg))
4160 auto __ptr = __res.get();
4162 __detail::__to_chars_10_impl(__ptr + (
int)__neg, __n,
4164 __res._M_bump(__n + __neg);
4168 else if constexpr (is_convertible_v<_Tp, string_view>)
4170 string_view __sv = __arg;
4171 if (
auto __res = __sink_out._M_reserve(__sv.size()))
4173 __builtin_memcpy(__res.get(), __sv.data(), __sv.size());
4174 __res._M_bump(__sv.size());
4182 if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
4185 return std::move(__sink)._M_finish().out;
4189 auto __ctx = __loc ==
nullptr
4190 ? _Context(__args, __sink_out)
4191 : _Context(__args, __sink_out, *__loc);
4192 _Formatting_scanner<_Sink_iter<_CharT>, _CharT> __scanner(__ctx, __fmt);
4193 __scanner._M_scan();
4195 if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
4198 return std::move(__sink)._M_finish().out;
4204 template<
typename _CharT,
typename... _Args>
4205 template<
typename _Tp>
4206 requires convertible_to<const _Tp&, basic_string_view<_CharT>>
4208 basic_format_string<_CharT, _Args...>::
4209 basic_format_string(
const _Tp& __s)
4212 __format::_Checking_scanner<_CharT, remove_cvref_t<_Args>...>
4214 __scanner._M_scan();
4219 template<
typename _Out>
requires output_iterator<_Out, const char&>
4220 [[__gnu__::__always_inline__]]
4222 vformat_to(_Out __out, string_view __fmt, format_args __args)
4223 {
return __format::__do_vformat_to(
std::move(__out), __fmt, __args); }
4225#ifdef _GLIBCXX_USE_WCHAR_T
4226 template<
typename _Out>
requires output_iterator<_Out, const wchar_t&>
4227 [[__gnu__::__always_inline__]]
4229 vformat_to(_Out __out, wstring_view __fmt, wformat_args __args)
4230 {
return __format::__do_vformat_to(
std::move(__out), __fmt, __args); }
4233 template<
typename _Out>
requires output_iterator<_Out, const char&>
4234 [[__gnu__::__always_inline__]]
4236 vformat_to(_Out __out,
const locale& __loc, string_view __fmt,
4239 return __format::__do_vformat_to(
std::move(__out), __fmt, __args, &__loc);
4242#ifdef _GLIBCXX_USE_WCHAR_T
4243 template<
typename _Out>
requires output_iterator<_Out, const wchar_t&>
4244 [[__gnu__::__always_inline__]]
4246 vformat_to(_Out __out,
const locale& __loc, wstring_view __fmt,
4247 wformat_args __args)
4249 return __format::__do_vformat_to(
std::move(__out), __fmt, __args, &__loc);
4255 vformat(string_view __fmt, format_args __args)
4257 __format::_Str_sink<char> __buf;
4258 std::vformat_to(__buf.out(), __fmt, __args);
4262#ifdef _GLIBCXX_USE_WCHAR_T
4265 vformat(wstring_view __fmt, wformat_args __args)
4267 __format::_Str_sink<wchar_t> __buf;
4268 std::vformat_to(__buf.out(), __fmt, __args);
4275 vformat(
const locale& __loc, string_view __fmt, format_args __args)
4277 __format::_Str_sink<char> __buf;
4278 std::vformat_to(__buf.out(), __loc, __fmt, __args);
4282#ifdef _GLIBCXX_USE_WCHAR_T
4285 vformat(
const locale& __loc, wstring_view __fmt, wformat_args __args)
4287 __format::_Str_sink<wchar_t> __buf;
4288 std::vformat_to(__buf.out(), __loc, __fmt, __args);
4293 template<
typename... _Args>
4296 format(format_string<_Args...> __fmt, _Args&&... __args)
4297 {
return std::vformat(__fmt.get(), std::make_format_args(__args...)); }
4299#ifdef _GLIBCXX_USE_WCHAR_T
4300 template<
typename... _Args>
4303 format(wformat_string<_Args...> __fmt, _Args&&... __args)
4304 {
return std::vformat(__fmt.get(), std::make_wformat_args(__args...)); }
4307 template<
typename... _Args>
4310 format(
const locale& __loc, format_string<_Args...> __fmt,
4313 return std::vformat(__loc, __fmt.get(),
4314 std::make_format_args(__args...));
4317#ifdef _GLIBCXX_USE_WCHAR_T
4318 template<
typename... _Args>
4321 format(
const locale& __loc, wformat_string<_Args...> __fmt,
4324 return std::vformat(__loc, __fmt.get(),
4325 std::make_wformat_args(__args...));
4329 template<
typename _Out,
typename... _Args>
4330 requires output_iterator<_Out, const char&>
4332 format_to(_Out __out, format_string<_Args...> __fmt, _Args&&... __args)
4334 return std::vformat_to(
std::move(__out), __fmt.get(),
4335 std::make_format_args(__args...));
4338#ifdef _GLIBCXX_USE_WCHAR_T
4339 template<
typename _Out,
typename... _Args>
4340 requires output_iterator<_Out, const wchar_t&>
4342 format_to(_Out __out, wformat_string<_Args...> __fmt, _Args&&... __args)
4344 return std::vformat_to(
std::move(__out), __fmt.get(),
4345 std::make_wformat_args(__args...));
4349 template<
typename _Out,
typename... _Args>
4350 requires output_iterator<_Out, const char&>
4352 format_to(_Out __out,
const locale& __loc, format_string<_Args...> __fmt,
4355 return std::vformat_to(
std::move(__out), __loc, __fmt.get(),
4356 std::make_format_args(__args...));
4359#ifdef _GLIBCXX_USE_WCHAR_T
4360 template<
typename _Out,
typename... _Args>
4361 requires output_iterator<_Out, const wchar_t&>
4363 format_to(_Out __out,
const locale& __loc, wformat_string<_Args...> __fmt,
4366 return std::vformat_to(
std::move(__out), __loc, __fmt.get(),
4367 std::make_wformat_args(__args...));
4371 template<
typename _Out,
typename... _Args>
4372 requires output_iterator<_Out, const char&>
4373 inline format_to_n_result<_Out>
4374 format_to_n(_Out __out, iter_difference_t<_Out> __n,
4375 format_string<_Args...> __fmt, _Args&&... __args)
4377 __format::_Iter_sink<char, _Out> __sink(
std::move(__out), __n);
4378 std::vformat_to(__sink.out(), __fmt.get(),
4379 std::make_format_args(__args...));
4383#ifdef _GLIBCXX_USE_WCHAR_T
4384 template<
typename _Out,
typename... _Args>
4385 requires output_iterator<_Out, const wchar_t&>
4386 inline format_to_n_result<_Out>
4387 format_to_n(_Out __out, iter_difference_t<_Out> __n,
4388 wformat_string<_Args...> __fmt, _Args&&... __args)
4390 __format::_Iter_sink<wchar_t, _Out> __sink(
std::move(__out), __n);
4391 std::vformat_to(__sink.out(), __fmt.get(),
4392 std::make_wformat_args(__args...));
4397 template<
typename _Out,
typename... _Args>
4398 requires output_iterator<_Out, const char&>
4399 inline format_to_n_result<_Out>
4400 format_to_n(_Out __out, iter_difference_t<_Out> __n,
const locale& __loc,
4401 format_string<_Args...> __fmt, _Args&&... __args)
4403 __format::_Iter_sink<char, _Out> __sink(
std::move(__out), __n);
4404 std::vformat_to(__sink.out(), __loc, __fmt.get(),
4405 std::make_format_args(__args...));
4409#ifdef _GLIBCXX_USE_WCHAR_T
4410 template<
typename _Out,
typename... _Args>
4411 requires output_iterator<_Out, const wchar_t&>
4412 inline format_to_n_result<_Out>
4413 format_to_n(_Out __out, iter_difference_t<_Out> __n,
const locale& __loc,
4414 wformat_string<_Args...> __fmt, _Args&&... __args)
4416 __format::_Iter_sink<wchar_t, _Out> __sink(
std::move(__out), __n);
4417 std::vformat_to(__sink.out(), __loc, __fmt.get(),
4418 std::make_wformat_args(__args...));
4427 template<
typename _CharT>
4428 class _Counting_sink final :
public _Iter_sink<_CharT, _CharT*>
4431 _Counting_sink() : _Iter_sink<_CharT, _CharT*>(nullptr, 0) { }
4433 [[__gnu__::__always_inline__]]
4436 {
return this->_M_count + this->_M_used().size(); }
4439 template<
typename _CharT>
4440 class _Counting_sink :
public _Buf_sink<_CharT>
4442 size_t _M_count = 0;
4445 _M_overflow()
override
4447 if (!std::is_constant_evaluated())
4448 _M_count += this->_M_used().size();
4453 _Counting_sink() =
default;
4455 [[__gnu__::__always_inline__]]
4459 _Counting_sink::_M_overflow();
4467 template<
typename... _Args>
4470 formatted_size(format_string<_Args...> __fmt, _Args&&... __args)
4472 __format::_Counting_sink<char> __buf;
4473 std::vformat_to(__buf.out(), __fmt.get(),
4474 std::make_format_args(__args...));
4475 return __buf.count();
4478#ifdef _GLIBCXX_USE_WCHAR_T
4479 template<
typename... _Args>
4482 formatted_size(wformat_string<_Args...> __fmt, _Args&&... __args)
4484 __format::_Counting_sink<wchar_t> __buf;
4485 std::vformat_to(__buf.out(), __fmt.get(),
4486 std::make_wformat_args(__args...));
4487 return __buf.count();
4491 template<
typename... _Args>
4494 formatted_size(
const locale& __loc, format_string<_Args...> __fmt,
4497 __format::_Counting_sink<char> __buf;
4498 std::vformat_to(__buf.out(), __loc, __fmt.get(),
4499 std::make_format_args(__args...));
4500 return __buf.count();
4503#ifdef _GLIBCXX_USE_WCHAR_T
4504 template<
typename... _Args>
4507 formatted_size(
const locale& __loc, wformat_string<_Args...> __fmt,
4510 __format::_Counting_sink<wchar_t> __buf;
4511 std::vformat_to(__buf.out(), __loc, __fmt.get(),
4512 std::make_wformat_args(__args...));
4513 return __buf.count();
4517#if __cpp_lib_format_ranges
4520 enum class range_format {
4530 template<
typename _Rg>
4531 constexpr auto format_kind = not defined(format_kind<_Rg>);
4533 template<
typename _Tp>
4534 consteval range_format
4537 using _Ref = ranges::range_reference_t<_Tp>;
4538 if constexpr (is_same_v<remove_cvref_t<_Ref>, _Tp>)
4539 return range_format::disabled;
4540 else if constexpr (
requires {
typename _Tp::key_type; })
4542 if constexpr (
requires {
typename _Tp::mapped_type; })
4544 using _Up = remove_cvref_t<_Ref>;
4545 if constexpr (__is_pair<_Up>)
4546 return range_format::map;
4547 else if constexpr (__is_specialization_of<_Up, tuple>)
4548 if constexpr (tuple_size_v<_Up> == 2)
4549 return range_format::map;
4551 return range_format::set;
4554 return range_format::sequence;
4559 template<ranges::input_range _Rg>
requires same_as<_Rg, remove_cvref_t<_Rg>>
4560 constexpr range_format format_kind<_Rg> = __fmt_kind<_Rg>();
4563 template<
typename _Tp,
typename _CharT =
char>
4564 requires same_as<remove_cvref_t<_Tp>, _Tp> && formattable<_Tp, _CharT>
4565 class range_formatter;
4571 template<range_format _Kind, ranges::input_range _Rg,
typename _CharT>
4572 struct __range_default_formatter;
4578 template<ranges::input_range _Rg,
typename _CharT>
4579 requires (format_kind<_Rg> != range_format::disabled)
4580 && formattable<ranges::range_reference_t<_Rg>, _CharT>
4581 struct formatter<_Rg, _CharT>
4582 : __format::__range_default_formatter<format_kind<_Rg>, _Rg, _CharT>
4586_GLIBCXX_END_NAMESPACE_VERSION
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
_Tp arg(const complex< _Tp > &)
Return phase angle of z.
constexpr _Tp * to_address(_Tp *__ptr) noexcept
Obtain address referenced by a pointer to an object.
typename remove_reference< _Tp >::type remove_reference_t
Alias template for remove_reference.
typename make_unsigned< _Tp >::type make_unsigned_t
Alias template for make_unsigned.
constexpr _Tp * addressof(_Tp &__r) noexcept
Returns the actual address of the object or function referenced by r, even in the presence of an over...
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
_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.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
basic_string< char > string
A string of char.
basic_string< wchar_t > wstring
A string of wchar_t.
ISO C++ entities toplevel namespace is std.
chars_format
floating-point format for primitive numerical conversion
_CharT toupper(_CharT __c, const locale &__loc)
Convenience interface to ctype.toupper(__c).
constexpr auto size(const _Container &__cont) noexcept(noexcept(__cont.size())) -> decltype(__cont.size())
Return the size of a container.
GNU extensions for public use.
__numeric_traits_integer< _Tp > __int_traits
Convenience alias for __numeric_traits<integer-type>.
constexpr _Iterator __base(_Iterator __it)
static constexpr int max_exponent10
const _CharT * data() const noexcept
Return const pointer to contents.
void __resize_and_overwrite(size_type __n, _Operation __op)
Non-standard version of resize_and_overwrite for C++11 and above.
basic_string substr(size_type __pos=0, size_type __n=npos) const
Get a substring.
void reserve(size_type __res_arg)
Attempt to preallocate enough memory for specified number of characters.
void insert(iterator __p, size_type __n, _CharT __c)
Insert multiple characters.
size_type size() const noexcept
Returns the number of characters in the string, not including any null-termination.
basic_string & append(const basic_string &__str)
Append a string to this string.
bool empty() const noexcept
size_type capacity() const noexcept
Container class for localization functionality.
static const locale & classic()
Return reference to the C locale.