1// <format> Formatting -*- C++ -*-
3// Copyright The GNU Toolchain Authors.
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
25/** @file include/format
26 * This is a Standard C++ Library header.
29#ifndef _GLIBCXX_FORMAT
30#define _GLIBCXX_FORMAT 1
32#pragma GCC system_header
34#include <bits/requires_hosted.h> // for std::string
36#define __glibcxx_want_format
37#define __glibcxx_want_format_ranges
38#define __glibcxx_want_format_uchar
39#include <bits/version.h>
41#ifdef __cpp_lib_format // C++ >= 20 && HOSTED
52#include <variant> // monostate (TODO: move to bits/utility.h?)
53#include <bits/ranges_base.h> // input_range, range_reference_t
54#include <bits/ranges_util.h> // subrange
55#include <bits/ranges_algobase.h> // ranges::copy
56#include <bits/stl_iterator.h> // back_insert_iterator
57#include <bits/stl_pair.h> // __is_pair
58#include <bits/unicode.h> // __is_scalar_value, _Utf_view, etc.
59#include <bits/utility.h> // tuple_size_v
60#include <ext/numeric_traits.h> // __int_traits
62#if !__has_builtin(__builtin_toupper)
66namespace std _GLIBCXX_VISIBILITY(default)
68_GLIBCXX_BEGIN_NAMESPACE_VERSION
70 // [format.context], class template basic_format_context
71 template<typename _Out, typename _CharT> class basic_format_context;
73 // [format.fmt.string], class template basic_format_string
74 template<typename _CharT, typename... _Args> struct basic_format_string;
79 // Type-erased character sink.
80 template<typename _CharT> class _Sink;
81 // Output iterator that writes to a type-erase character 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;
103} // namespace __format
106 using format_context = __format::__format_context<char>;
107#ifdef _GLIBCXX_USE_WCHAR_T
108 using wformat_context = __format::__format_context<wchar_t>;
111 // [format.args], class template basic_format_args
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>;
118 // [format.arguments], arguments
119 // [format.arg], class template basic_format_arg
120 template<typename _Context>
121 class basic_format_arg;
123 /** A compile-time checked format string for the specified argument types.
125 * @since C++23 but available as an extension in C++20.
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
172 // [format.formatter], formatter
174 /// The primary template of std::formatter is disabled.
175 template<typename _Tp, typename _CharT = char>
178 formatter() = delete; // No std::formatter specialization for this type.
179 formatter(const formatter&) = delete;
180 formatter& operator=(const formatter&) = delete;
183 // [format.error], class format_error
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) { }
191 /// @cond undocumented
194 __throw_format_error(const char* __what)
195 { _GLIBCXX_THROW_OR_ABORT(format_error(__what)); }
199 // XXX use named functions for each constexpr error?
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"); }
225} // namespace __format
228 // [format.parse.ctx], class template basic_format_parse_context
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();
266 // _GLIBCXX_RESOLVE_LIB_DEFECTS
267 // 3825. Missing compile-time argument id check in next_arg_id
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;
295/// @cond undocumented
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>
304 // pre: first != last
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;
316 // N.B. std::from_chars is not constexpr in C++20.
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}; // No leading zeros allowed, so '0...' == 0
344 if ('1' <= *__first && *__first <= '9')
346 const unsigned short __id = *__first - '0';
347 const auto __next = __first + 1;
348 // Optimize for most likely case of single digit arg-id.
349 if (__next == __last || !('0' <= *__next && *__next <= '9'))
350 return {__id, __next};
352 return __format::__parse_integer(__first, __last);
358 _Pres_none = 0, // Default type (not valid for integer presentation types).
359 // Presentation types for integral types (including bool and charT).
360 _Pres_d = 1, _Pres_b, _Pres_B, _Pres_o, _Pres_x, _Pres_X, _Pres_c,
361 // Presentation types for floating-point types.
362 _Pres_a = 1, _Pres_A, _Pres_e, _Pres_E, _Pres_f, _Pres_F, _Pres_g, _Pres_G,
363 _Pres_p = 0, _Pres_P, // For pointers.
364 _Pres_s = 0, // For strings and bool.
365 _Pres_esc = 0xf, // For strings and charT.
378 _Sign_minus, // XXX does this need to be distinct from _Sign_default?
383 _WP_none, // No width/prec specified.
384 _WP_value, // Fixed width/prec specified.
385 _WP_from_arg // Use a formatting argument for width/prec.
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;
429 // pre: __first != __last
431 _M_parse_fill_and_align(iterator __first, iterator __last) noexcept
435 using namespace __unicode;
436 if constexpr (__literal_encoding_is_unicode<_CharT>())
438 // Accept any UCS scalar value as fill character.
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;
484 // pre: __first != __last
486 _M_parse_sign(iterator __first, iterator) noexcept
488 if (_Sign __sign = _S_sign(*__first))
496 // pre: *__first is valid
498 _M_parse_alternate_form(iterator __first, iterator) noexcept
508 // pre: __first != __last
510 _M_parse_zero_fill(iterator __first, iterator /* __last */) noexcept
520 // pre: __first != __last
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);
552 ++__first; // past the '}'
557 // pre: __first != __last
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;
573 // pre: __first != __last
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;
593 // pre: __first != __last
595 _M_parse_locale(iterator __first, iterator /* __last */) 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)
645 // Write STR to OUT (and do so efficiently if OUT is a _Sink_iter).
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)
662 // Write STR to OUT with NFILL copies of FILL_CHAR specified by ALIGN.
663 // pre: __align != _Align_default
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]]
710 // Encode fill char as multiple code units of type _CharT.
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);
736 // Write STR to OUT, with alignment and padding as determined by SPEC.
737 // pre: __spec._M_align != _Align_default || __align != _Align_default
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,
760 // A lightweight optional<locale>.
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
804 _M_loc = std::move(__loc);
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)
902 // TODO: C++23 escaped string presentation
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
943 // If no presentation type is specified, meaning of "none" depends
944 // whether we are formatting an integer or a char or a bool.
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;
1009 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1010 // 3586. format should not print bool with 'c'
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; // same value (and meaning) as "none"
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
1076 /* XXX should be invalid? || _M_spec._M_localized */)
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);
1119 // Should not reach here with _Pres_none for bool or charT, so:
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);
1138 *__p = std::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(); // TODO Unicode-aware estimate
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 [[__gnu__::__always_inline__]]
1189 _S_character_width(_CharT __c)
1191 // N.B. single byte cannot encode charcter of width greater than 1
1192 if constexpr (sizeof(_CharT) > 1u &&
1193 __unicode::__literal_encoding_is_unicode<_CharT>())
1194 return __unicode::__field_width(__c);
1199 template<typename _Out>
1200 typename basic_format_context<_Out, _CharT>::iterator
1201 _M_format_character(_CharT __c,
1202 basic_format_context<_Out, _CharT>& __fc) const
1204 return __format::__write_padded_as_spec({&__c, 1u},
1205 _S_character_width(__c),
1209 template<typename _Int>
1211 _S_to_character(_Int __i)
1213 using _Traits = __gnu_cxx::__int_traits<_CharT>;
1214 if constexpr (is_signed_v<_Int> == is_signed_v<_CharT>)
1216 if (_Traits::__min <= __i && __i <= _Traits::__max)
1217 return static_cast<_CharT>(__i);
1219 else if constexpr (is_signed_v<_Int>)
1221 if (__i >= 0 && make_unsigned_t<_Int>(__i) <= _Traits::__max)
1222 return static_cast<_CharT>(__i);
1224 else if (__i <= make_unsigned_t<_CharT>(_Traits::__max))
1225 return static_cast<_CharT>(__i);
1226 __throw_format_error("format error: integer not representable as "
1230 template<typename _Out>
1231 typename basic_format_context<_Out, _CharT>::iterator
1232 _M_format_int(string_view __narrow_str, size_t __prefix_len,
1233 basic_format_context<_Out, _CharT>& __fc) const
1235 size_t __width = _M_spec._M_get_width(__fc);
1237 basic_string_view<_CharT> __str;
1238 if constexpr (is_same_v<char, _CharT>)
1239 __str = __narrow_str;
1240#ifdef _GLIBCXX_USE_WCHAR_T
1243 size_t __n = __narrow_str.size();
1244 auto __p = (_CharT*)__builtin_alloca(__n * sizeof(_CharT));
1245 std::__to_wstring_numeric(__narrow_str.data(), __n, __p);
1250 if (_M_spec._M_localized)
1252 const auto& __l = __fc.locale();
1253 if (__l.name() != "C")
1255 auto& __np = use_facet<numpunct<_CharT>>(__l);
1256 string __grp = __np.grouping();
1259 size_t __n = __str.size() - __prefix_len;
1260 auto __p = (_CharT*)__builtin_alloca(2 * __n
1263 auto __s = __str.data();
1264 char_traits<_CharT>::copy(__p, __s, __prefix_len);
1265 __s += __prefix_len;
1266 auto __end = std::__add_grouping(__p + __prefix_len,
1267 __np.thousands_sep(),
1271 __str = {__p, size_t(__end - __p)};
1276 if (__width <= __str.size())
1277 return __format::__write(__fc.out(), __str);
1279 char32_t __fill_char = _M_spec._M_fill;
1280 _Align __align = _M_spec._M_align;
1282 size_t __nfill = __width - __str.size();
1283 auto __out = __fc.out();
1284 if (__align == _Align_default)
1286 __align = _Align_right;
1287 if (_M_spec._M_zero_fill)
1289 __fill_char = _CharT('0');
1290 // Write sign and base prefix before zero filling.
1291 if (__prefix_len != 0)
1293 __out = __format::__write(std::move(__out),
1294 __str.substr(0, __prefix_len));
1295 __str.remove_prefix(__prefix_len);
1299 __fill_char = _CharT(' ');
1301 return __format::__write_padded(std::move(__out), __str,
1302 __align, __nfill, __fill_char);
1305#if defined __SIZEOF_INT128__ && defined __STRICT_ANSI__
1306 template<typename _Tp>
1307 using make_unsigned_t
1308 = typename __conditional_t<(sizeof(_Tp) <= sizeof(long long)),
1309 std::make_unsigned<_Tp>,
1310 type_identity<unsigned __int128>>::type;
1312 // std::to_chars is not overloaded for int128 in strict mode.
1313 template<typename _Int>
1314 static to_chars_result
1315 to_chars(char* __first, char* __last, _Int __value, int __base)
1316 { return std::__to_chars_i<_Int>(__first, __last, __value, __base); }
1319 _Spec<_CharT> _M_spec{};
1322 // Decide how 128-bit floating-point types should be formatted (or not).
1323 // When supported, the typedef __format::__float128_t is the type that
1324 // format arguments should be converted to for storage in basic_format_arg.
1325 // Define the macro _GLIBCXX_FORMAT_F128 to say they're supported.
1326 // _GLIBCXX_FORMAT_F128=1 means __float128, _Float128 etc. will be formatted
1327 // by converting them to long double (or __ieee128 for powerpc64le).
1328 // _GLIBCXX_FORMAT_F128=2 means basic_format_arg needs to enable explicit
1329 // support for _Float128, rather than formatting it as another type.
1330#undef _GLIBCXX_FORMAT_F128
1332#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
1334 // Format 128-bit floating-point types using __ieee128.
1335 using __float128_t = __ieee128;
1336# define _GLIBCXX_FORMAT_F128 1
1338#ifdef __LONG_DOUBLE_IEEE128__
1339 // These overloads exist in the library, but are not declared.
1340 // Make them available as std::__format::to_chars.
1342 to_chars(char*, char*, __ibm128) noexcept
1343 __asm("_ZSt8to_charsPcS_e");
1346 to_chars(char*, char*, __ibm128, chars_format) noexcept
1347 __asm("_ZSt8to_charsPcS_eSt12chars_format");
1350 to_chars(char*, char*, __ibm128, chars_format, int) noexcept
1351 __asm("_ZSt8to_charsPcS_eSt12chars_formati");
1352#elif __cplusplus == 202002L
1354 to_chars(char*, char*, __ieee128) noexcept
1355 __asm("_ZSt8to_charsPcS_u9__ieee128");
1358 to_chars(char*, char*, __ieee128, chars_format) noexcept
1359 __asm("_ZSt8to_charsPcS_u9__ieee128St12chars_format");
1362 to_chars(char*, char*, __ieee128, chars_format, int) noexcept
1363 __asm("_ZSt8to_charsPcS_u9__ieee128St12chars_formati");
1366#elif defined _GLIBCXX_LDOUBLE_IS_IEEE_BINARY128
1368 // Format 128-bit floating-point types using long double.
1369 using __float128_t = long double;
1370# define _GLIBCXX_FORMAT_F128 1
1372#elif __FLT128_DIG__ && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
1374 // Format 128-bit floating-point types using _Float128.
1375 using __float128_t = _Float128;
1376# define _GLIBCXX_FORMAT_F128 2
1378# if __cplusplus == 202002L
1379 // These overloads exist in the library, but are not declared for C++20.
1380 // Make them available as std::__format::to_chars.
1382 to_chars(char*, char*, _Float128) noexcept
1383# if _GLIBCXX_INLINE_VERSION
1384 __asm("_ZNSt3__88to_charsEPcS0_DF128_");
1386 __asm("_ZSt8to_charsPcS_DF128_");
1390 to_chars(char*, char*, _Float128, chars_format) noexcept
1391# if _GLIBCXX_INLINE_VERSION
1392 __asm("_ZNSt3__88to_charsEPcS0_DF128_NS_12chars_formatE");
1394 __asm("_ZSt8to_charsPcS_DF128_St12chars_format");
1398 to_chars(char*, char*, _Float128, chars_format, int) noexcept
1399# if _GLIBCXX_INLINE_VERSION
1400 __asm("_ZNSt3__88to_charsEPcS0_DF128_NS_12chars_formatEi");
1402 __asm("_ZSt8to_charsPcS_DF128_St12chars_formati");
1407 using std::to_chars;
1409 // We can format a floating-point type iff it is usable with to_chars.
1410 template<typename _Tp>
1411 concept __formattable_float
1412 = is_same_v<remove_cv_t<_Tp>, _Tp> && requires (_Tp __t, char* __p)
1413 { __format::to_chars(__p, __p, __t, chars_format::scientific, 6); };
1415 template<__char _CharT>
1416 struct __formatter_fp
1418 constexpr typename basic_format_parse_context<_CharT>::iterator
1419 parse(basic_format_parse_context<_CharT>& __pc)
1421 _Spec<_CharT> __spec{};
1422 const auto __last = __pc.end();
1423 auto __first = __pc.begin();
1425 auto __finalize = [this, &__spec] {
1429 auto __finished = [&] {
1430 if (__first == __last || *__first == '}')
1441 __first = __spec._M_parse_fill_and_align(__first, __last);
1445 __first = __spec._M_parse_sign(__first, __last);
1449 __first = __spec._M_parse_alternate_form(__first, __last);
1453 __first = __spec._M_parse_zero_fill(__first, __last);
1457 if (__first[0] != '.')
1459 __first = __spec._M_parse_width(__first, __last, __pc);
1464 __first = __spec._M_parse_precision(__first, __last, __pc);
1468 __first = __spec._M_parse_locale(__first, __last);
1475 __spec._M_type = _Pres_a;
1479 __spec._M_type = _Pres_A;
1483 __spec._M_type = _Pres_e;
1487 __spec._M_type = _Pres_E;
1491 __spec._M_type = _Pres_f;
1495 __spec._M_type = _Pres_F;
1499 __spec._M_type = _Pres_g;
1503 __spec._M_type = _Pres_G;
1511 __format::__failed_to_parse_format_spec();
1514 template<typename _Fp, typename _Out>
1515 typename basic_format_context<_Out, _CharT>::iterator
1516 format(_Fp __v, basic_format_context<_Out, _CharT>& __fc) const
1518 std::string __dynbuf;
1520 to_chars_result __res{};
1523 bool __use_prec = _M_spec._M_prec_kind != _WP_none;
1525 __prec = _M_spec._M_get_precision(__fc);
1527 char* __start = __buf + 1; // reserve space for sign
1528 char* __end = __buf + sizeof(__buf);
1530 chars_format __fmt{};
1531 bool __upper = false;
1532 bool __trailing_zeros = false;
1535 switch (_M_spec._M_type)
1542 if (_M_spec._M_type != _Pres_A)
1544 __fmt = chars_format::hex;
1552 __fmt = chars_format::scientific;
1559 __fmt = chars_format::fixed;
1566 __trailing_zeros = true;
1568 __fmt = chars_format::general;
1572 __fmt = chars_format::general;
1575 __builtin_unreachable();
1578 // Write value into buffer using std::to_chars.
1579 auto __to_chars = [&](char* __b, char* __e) {
1581 return __format::to_chars(__b, __e, __v, __fmt, __prec);
1582 else if (__fmt != chars_format{})
1583 return __format::to_chars(__b, __e, __v, __fmt);
1585 return __format::to_chars(__b, __e, __v);
1588 // First try using stack buffer.
1589 __res = __to_chars(__start, __end);
1591 if (__builtin_expect(__res.ec == errc::value_too_large, 0))
1593 // If the buffer is too small it's probably because of a large
1594 // precision, or a very large value in fixed format.
1595 size_t __guess = 8 + __prec;
1596 if (__fmt == chars_format::fixed) // +ddd.prec
1598 if constexpr (is_same_v<_Fp, float> || is_same_v<_Fp, double>
1599 || is_same_v<_Fp, long double>)
1601 // The number of digits to the left of the decimal point
1602 // is floor(log10(max(abs(__v),1)))+1
1604 if constexpr (is_same_v<_Fp, float>)
1605 __builtin_frexpf(__v, &__exp);
1606 else if constexpr (is_same_v<_Fp, double>)
1607 __builtin_frexp(__v, &__exp);
1608 else if constexpr (is_same_v<_Fp, long double>)
1609 __builtin_frexpl(__v, &__exp);
1611 __guess += 1U + __exp * 4004U / 13301U; // log10(2) approx.
1614 __guess += numeric_limits<_Fp>::max_exponent10;
1616 if (__guess <= sizeof(__buf)) [[unlikely]]
1617 __guess = sizeof(__buf) * 2;
1618 __dynbuf.reserve(__guess);
1622 auto __overwrite = [&__to_chars, &__res] (char* __p, size_t __n)
1624 __res = __to_chars(__p + 1, __p + __n - 1);
1625 return __res.ec == errc{} ? __res.ptr - __p : 0;
1628 __dynbuf.__resize_and_overwrite(__dynbuf.capacity() * 2,
1630 __start = __dynbuf.data() + 1; // reserve space for sign
1631 __end = __dynbuf.data() + __dynbuf.size();
1633 while (__builtin_expect(__res.ec == errc::value_too_large, 0));
1636 // Use uppercase for 'A', 'E', and 'G' formats.
1639 for (char* __p = __start; __p != __res.ptr; ++__p)
1640 *__p = std::toupper(*__p);
1643 bool __have_sign = true;
1644 // Add sign for non-negative values.
1645 if (!__builtin_signbit(__v))
1647 if (_M_spec._M_sign == _Sign_plus)
1649 else if (_M_spec._M_sign == _Sign_space)
1652 __have_sign = false;
1655 string_view __narrow_str(__start, __res.ptr - __start);
1657 // Use alternate form. Ensure decimal point is always present,
1658 // and add trailing zeros (up to precision) for g and G forms.
1659 if (_M_spec._M_alt && __builtin_isfinite(__v))
1661 string_view __s = __narrow_str;
1662 size_t __sigfigs; // Number of significant figures.
1663 size_t __z = 0; // Number of trailing zeros to add.
1664 size_t __p; // Position of the exponent character (if any).
1665 size_t __d = __s.find('.'); // Position of decimal point.
1666 if (__d != __s.npos) // Found decimal point.
1668 __p = __s.find(__expc, __d + 1);
1669 if (__p == __s.npos)
1672 // If presentation type is g or G we might need to add zeros.
1673 if (__trailing_zeros)
1675 // Find number of digits after first significant figure.
1676 if (__s[__have_sign] != '0')
1677 // A string like "D.D" or "-D.DDD"
1678 __sigfigs = __p - __have_sign - 1;
1680 // A string like "0.D" or "-0.0DD".
1681 // Safe to assume there is a non-zero digit, because
1682 // otherwise there would be no decimal point.
1683 __sigfigs = __p - __s.find_first_not_of('0', __d + 1);
1686 else // No decimal point, we need to insert one.
1688 __p = __s.find(__expc); // Find the exponent, if present.
1689 if (__p == __s.npos)
1691 __d = __p; // Position where '.' should be inserted.
1692 __sigfigs = __d - __have_sign;
1695 if (__trailing_zeros && __prec != 0)
1697 // For g and G presentation types std::to_chars produces
1698 // no more than prec significant figures. Insert this many
1699 // zeros so the result has exactly prec significant figures.
1700 __z = __prec - __sigfigs;
1703 if (size_t __extras = int(__d == __p) + __z) // How many to add.
1705 if (__dynbuf.empty() && __extras <= size_t(__end - __res.ptr))
1707 // The stack buffer is large enough for the result.
1708 // Move exponent to make space for extra chars.
1709 __builtin_memmove(__start + __p + __extras,
1713 __start[__p++] = '.';
1714 __builtin_memset(__start + __p, '0', __z);
1715 __narrow_str = {__s.data(), __s.size() + __extras};
1717 else // Need to switch to the dynamic buffer.
1719 __dynbuf.reserve(__s.size() + __extras);
1720 if (__dynbuf.empty())
1722 __dynbuf = __s.substr(0, __p);
1726 __dynbuf.append(__z, '0');
1727 __dynbuf.append(__s.substr(__p));
1731 __dynbuf.insert(__p, __extras, '0');
1733 __dynbuf[__p] = '.';
1735 __narrow_str = __dynbuf;
1740 basic_string<_CharT> __wstr;
1741 basic_string_view<_CharT> __str;
1742 if constexpr (is_same_v<_CharT, char>)
1743 __str = __narrow_str;
1744#ifdef _GLIBCXX_USE_WCHAR_T
1747 __wstr = std::__to_wstring_numeric(__narrow_str);
1752 if (_M_spec._M_localized && __builtin_isfinite(__v))
1754 auto __s = _M_localize(__str, __expc, __fc.locale());
1756 __str = __wstr = std::move(__s);
1759 size_t __width = _M_spec._M_get_width(__fc);
1761 if (__width <= __str.size())
1762 return __format::__write(__fc.out(), __str);
1764 char32_t __fill_char = _M_spec._M_fill;
1765 _Align __align = _M_spec._M_align;
1767 size_t __nfill = __width - __str.size();
1768 auto __out = __fc.out();
1769 if (__align == _Align_default)
1771 __align = _Align_right;
1772 if (_M_spec._M_zero_fill && __builtin_isfinite(__v))
1774 __fill_char = _CharT('0');
1775 // Write sign before zero filling.
1776 if (!__format::__is_xdigit(__narrow_str[0]))
1778 *__out++ = __str[0];
1779 __str.remove_prefix(1);
1783 __fill_char = _CharT(' ');
1785 return __format::__write_padded(std::move(__out), __str,
1786 __align, __nfill, __fill_char);
1789 // Locale-specific format.
1790 basic_string<_CharT>
1791 _M_localize(basic_string_view<_CharT> __str, char __expc,
1792 const locale& __loc) const
1794 basic_string<_CharT> __lstr;
1796 if (__loc == locale::classic())
1797 return __lstr; // Nothing to do.
1799 const auto& __np = use_facet<numpunct<_CharT>>(__loc);
1800 const _CharT __point = __np.decimal_point();
1801 const string __grp = __np.grouping();
1803 _CharT __dot, __exp;
1804 if constexpr (is_same_v<_CharT, char>)
1827 __builtin_unreachable();
1831 if (__grp.empty() && __point == __dot)
1832 return __lstr; // Locale uses '.' and no grouping.
1834 size_t __d = __str.find(__dot);
1835 size_t __e = min(__d, __str.find(__exp));
1836 if (__e == __str.npos)
1838 const size_t __r = __str.size() - __e;
1839 auto __overwrite = [&](_CharT* __p, size_t) {
1840 auto __end = std::__add_grouping(__p, __np.thousands_sep(),
1841 __grp.data(), __grp.size(),
1842 __str.data(), __str.data() + __e);
1845 if (__d != __str.npos)
1852 __end += __str.copy(__end, __str.npos, __e);
1854 return (__end - __p);
1856 __lstr.__resize_and_overwrite(__e * 2 + __r, __overwrite);
1860 _Spec<_CharT> _M_spec{};
1863} // namespace __format
1866 /// Format a character.
1867 template<__format::__char _CharT>
1868 struct formatter<_CharT, _CharT>
1870 formatter() = default;
1872 constexpr typename basic_format_parse_context<_CharT>::iterator
1873 parse(basic_format_parse_context<_CharT>& __pc)
1875 return _M_f.template _M_parse<_CharT>(__pc);
1878 template<typename _Out>
1879 typename basic_format_context<_Out, _CharT>::iterator
1880 format(_CharT __u, basic_format_context<_Out, _CharT>& __fc) const
1882 if (_M_f._M_spec._M_type == __format::_Pres_none
1883 || _M_f._M_spec._M_type == __format::_Pres_c)
1884 return _M_f._M_format_character(__u, __fc);
1885 else if (_M_f._M_spec._M_type == __format::_Pres_esc)
1891 return _M_f.format(static_cast<make_unsigned_t<_CharT>>(__u), __fc);
1894#if __cpp_lib_format_ranges
1896 set_debug_format() noexcept
1897 { _M_f._M_spec._M_type = __format::_Pres_esc; }
1901 __format::__formatter_int<_CharT> _M_f;
1904#ifdef _GLIBCXX_USE_WCHAR_T
1905 /// Format a char value for wide character output.
1907 struct formatter<char, wchar_t>
1909 formatter() = default;
1911 constexpr typename basic_format_parse_context<wchar_t>::iterator
1912 parse(basic_format_parse_context<wchar_t>& __pc)
1914 return _M_f._M_parse<char>(__pc);
1917 template<typename _Out>
1918 typename basic_format_context<_Out, wchar_t>::iterator
1919 format(char __u, basic_format_context<_Out, wchar_t>& __fc) const
1921 if (_M_f._M_spec._M_type == __format::_Pres_none
1922 || _M_f._M_spec._M_type == __format::_Pres_c)
1923 return _M_f._M_format_character(__u, __fc);
1924 else if (_M_f._M_spec._M_type == __format::_Pres_esc)
1930 return _M_f.format(static_cast<unsigned char>(__u), __fc);
1933#if __cpp_lib_format_ranges
1935 set_debug_format() noexcept
1936 { _M_f._M_spec._M_type = __format::_Pres_esc; }
1940 __format::__formatter_int<wchar_t> _M_f;
1942#endif // USE_WCHAR_T
1944 /** Format a string.
1947 template<__format::__char _CharT>
1948 struct formatter<_CharT*, _CharT>
1950 formatter() = default;
1952 [[__gnu__::__always_inline__]]
1953 constexpr typename basic_format_parse_context<_CharT>::iterator
1954 parse(basic_format_parse_context<_CharT>& __pc)
1955 { return _M_f.parse(__pc); }
1957 template<typename _Out>
1958 [[__gnu__::__nonnull__]]
1959 typename basic_format_context<_Out, _CharT>::iterator
1960 format(_CharT* __u, basic_format_context<_Out, _CharT>& __fc) const
1961 { return _M_f.format(__u, __fc); }
1963#if __cpp_lib_format_ranges
1964 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
1968 __format::__formatter_str<_CharT> _M_f;
1971 template<__format::__char _CharT>
1972 struct formatter<const _CharT*, _CharT>
1974 formatter() = default;
1976 [[__gnu__::__always_inline__]]
1977 constexpr typename basic_format_parse_context<_CharT>::iterator
1978 parse(basic_format_parse_context<_CharT>& __pc)
1979 { return _M_f.parse(__pc); }
1981 template<typename _Out>
1982 [[__gnu__::__nonnull__]]
1983 typename basic_format_context<_Out, _CharT>::iterator
1984 format(const _CharT* __u,
1985 basic_format_context<_Out, _CharT>& __fc) const
1986 { return _M_f.format(__u, __fc); }
1988#if __cpp_lib_format_ranges
1989 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
1993 __format::__formatter_str<_CharT> _M_f;
1996 template<__format::__char _CharT, size_t _Nm>
1997 struct formatter<_CharT[_Nm], _CharT>
1999 formatter() = default;
2001 [[__gnu__::__always_inline__]]
2002 constexpr typename basic_format_parse_context<_CharT>::iterator
2003 parse(basic_format_parse_context<_CharT>& __pc)
2004 { return _M_f.parse(__pc); }
2006 template<typename _Out>
2007 typename basic_format_context<_Out, _CharT>::iterator
2008 format(const _CharT (&__u)[_Nm],
2009 basic_format_context<_Out, _CharT>& __fc) const
2010 { return _M_f.format({__u, _Nm}, __fc); }
2012#if __cpp_lib_format_ranges
2013 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2017 __format::__formatter_str<_CharT> _M_f;
2020 template<typename _Traits, typename _Alloc>
2021 struct formatter<basic_string<char, _Traits, _Alloc>, char>
2023 formatter() = default;
2025 [[__gnu__::__always_inline__]]
2026 constexpr typename basic_format_parse_context<char>::iterator
2027 parse(basic_format_parse_context<char>& __pc)
2028 { return _M_f.parse(__pc); }
2030 template<typename _Out>
2031 typename basic_format_context<_Out, char>::iterator
2032 format(const basic_string<char, _Traits, _Alloc>& __u,
2033 basic_format_context<_Out, char>& __fc) const
2034 { return _M_f.format(__u, __fc); }
2036#if __cpp_lib_format_ranges
2037 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2041 __format::__formatter_str<char> _M_f;
2044#ifdef _GLIBCXX_USE_WCHAR_T
2045 template<typename _Traits, typename _Alloc>
2046 struct formatter<basic_string<wchar_t, _Traits, _Alloc>, wchar_t>
2048 formatter() = default;
2050 [[__gnu__::__always_inline__]]
2051 constexpr typename basic_format_parse_context<wchar_t>::iterator
2052 parse(basic_format_parse_context<wchar_t>& __pc)
2053 { return _M_f.parse(__pc); }
2055 template<typename _Out>
2056 typename basic_format_context<_Out, wchar_t>::iterator
2057 format(const basic_string<wchar_t, _Traits, _Alloc>& __u,
2058 basic_format_context<_Out, wchar_t>& __fc) const
2059 { return _M_f.format(__u, __fc); }
2061#if __cpp_lib_format_ranges
2062 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2066 __format::__formatter_str<wchar_t> _M_f;
2068#endif // USE_WCHAR_T
2070 template<typename _Traits>
2071 struct formatter<basic_string_view<char, _Traits>, char>
2073 formatter() = default;
2075 [[__gnu__::__always_inline__]]
2076 constexpr typename basic_format_parse_context<char>::iterator
2077 parse(basic_format_parse_context<char>& __pc)
2078 { return _M_f.parse(__pc); }
2080 template<typename _Out>
2081 typename basic_format_context<_Out, char>::iterator
2082 format(basic_string_view<char, _Traits> __u,
2083 basic_format_context<_Out, char>& __fc) const
2084 { return _M_f.format(__u, __fc); }
2086#if __cpp_lib_format_ranges
2087 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2091 __format::__formatter_str<char> _M_f;
2094#ifdef _GLIBCXX_USE_WCHAR_T
2095 template<typename _Traits>
2096 struct formatter<basic_string_view<wchar_t, _Traits>, wchar_t>
2098 formatter() = default;
2100 [[__gnu__::__always_inline__]]
2101 constexpr typename basic_format_parse_context<wchar_t>::iterator
2102 parse(basic_format_parse_context<wchar_t>& __pc)
2103 { return _M_f.parse(__pc); }
2105 template<typename _Out>
2106 typename basic_format_context<_Out, wchar_t>::iterator
2107 format(basic_string_view<wchar_t, _Traits> __u,
2108 basic_format_context<_Out, wchar_t>& __fc) const
2109 { return _M_f.format(__u, __fc); }
2111#if __cpp_lib_format_ranges
2112 constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
2116 __format::__formatter_str<wchar_t> _M_f;
2118#endif // USE_WCHAR_T
2121/// @cond undocumented
2124 // each cv-unqualified arithmetic type ArithmeticT other than
2125 // char, wchar_t, char8_t, char16_t, or char32_t
2126 template<typename _Tp>
2127 constexpr bool __is_formattable_integer = __is_integer<_Tp>::__value;
2129#if defined __SIZEOF_INT128__
2130 template<> inline constexpr bool __is_formattable_integer<__int128> = true;
2131 template<> inline constexpr bool __is_formattable_integer<unsigned __int128>
2135 template<> inline constexpr bool __is_formattable_integer<char> = false;
2136 template<> inline constexpr bool __is_formattable_integer<wchar_t> = false;
2137#ifdef _GLIBCXX_USE_CHAR8_T
2138 template<> inline constexpr bool __is_formattable_integer<char8_t> = false;
2140 template<> inline constexpr bool __is_formattable_integer<char16_t> = false;
2141 template<> inline constexpr bool __is_formattable_integer<char32_t> = false;
2145 /// Format an integer.
2146 template<typename _Tp, __format::__char _CharT>
2147 requires __format::__is_formattable_integer<_Tp>
2148 struct formatter<_Tp, _CharT>
2150 formatter() = default;
2152 [[__gnu__::__always_inline__]]
2153 constexpr typename basic_format_parse_context<_CharT>::iterator
2154 parse(basic_format_parse_context<_CharT>& __pc)
2156 return _M_f.template _M_parse<_Tp>(__pc);
2159 template<typename _Out>
2160 typename basic_format_context<_Out, _CharT>::iterator
2161 format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
2162 { return _M_f.format(__u, __fc); }
2165 __format::__formatter_int<_CharT> _M_f;
2168#if defined __glibcxx_to_chars
2169 /// Format a floating-point value.
2170 template<__format::__formattable_float _Tp, __format::__char _CharT>
2171 struct formatter<_Tp, _CharT>
2173 formatter() = default;
2175 [[__gnu__::__always_inline__]]
2176 constexpr typename basic_format_parse_context<_CharT>::iterator
2177 parse(basic_format_parse_context<_CharT>& __pc)
2178 { return _M_f.parse(__pc); }
2180 template<typename _Out>
2181 typename basic_format_context<_Out, _CharT>::iterator
2182 format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
2183 { return _M_f.format(__u, __fc); }
2186 __format::__formatter_fp<_CharT> _M_f;
2189#if __LDBL_MANT_DIG__ == __DBL_MANT_DIG__
2190 // Reuse __formatter_fp<C>::format<double, Out> for long double.
2191 template<__format::__char _CharT>
2192 struct formatter<long double, _CharT>
2194 formatter() = default;
2196 [[__gnu__::__always_inline__]]
2197 constexpr typename basic_format_parse_context<_CharT>::iterator
2198 parse(basic_format_parse_context<_CharT>& __pc)
2199 { return _M_f.parse(__pc); }
2201 template<typename _Out>
2202 typename basic_format_context<_Out, _CharT>::iterator
2203 format(long double __u, basic_format_context<_Out, _CharT>& __fc) const
2204 { return _M_f.format((double)__u, __fc); }
2207 __format::__formatter_fp<_CharT> _M_f;
2211#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2212 // Reuse __formatter_fp<C>::format<float, Out> for _Float16.
2213 template<__format::__char _CharT>
2214 struct formatter<_Float16, _CharT>
2216 formatter() = default;
2218 [[__gnu__::__always_inline__]]
2219 constexpr typename basic_format_parse_context<_CharT>::iterator
2220 parse(basic_format_parse_context<_CharT>& __pc)
2221 { return _M_f.parse(__pc); }
2223 template<typename _Out>
2224 typename basic_format_context<_Out, _CharT>::iterator
2225 format(_Float16 __u, basic_format_context<_Out, _CharT>& __fc) const
2226 { return _M_f.format((float)__u, __fc); }
2229 __format::__formatter_fp<_CharT> _M_f;
2233#if defined(__FLT32_DIG__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2234 // Reuse __formatter_fp<C>::format<float, Out> for _Float32.
2235 template<__format::__char _CharT>
2236 struct formatter<_Float32, _CharT>
2238 formatter() = default;
2240 [[__gnu__::__always_inline__]]
2241 constexpr typename basic_format_parse_context<_CharT>::iterator
2242 parse(basic_format_parse_context<_CharT>& __pc)
2243 { return _M_f.parse(__pc); }
2245 template<typename _Out>
2246 typename basic_format_context<_Out, _CharT>::iterator
2247 format(_Float32 __u, basic_format_context<_Out, _CharT>& __fc) const
2248 { return _M_f.format((float)__u, __fc); }
2251 __format::__formatter_fp<_CharT> _M_f;
2255#if defined(__FLT64_DIG__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2256 // Reuse __formatter_fp<C>::format<double, Out> for _Float64.
2257 template<__format::__char _CharT>
2258 struct formatter<_Float64, _CharT>
2260 formatter() = default;
2262 [[__gnu__::__always_inline__]]
2263 constexpr typename basic_format_parse_context<_CharT>::iterator
2264 parse(basic_format_parse_context<_CharT>& __pc)
2265 { return _M_f.parse(__pc); }
2267 template<typename _Out>
2268 typename basic_format_context<_Out, _CharT>::iterator
2269 format(_Float64 __u, basic_format_context<_Out, _CharT>& __fc) const
2270 { return _M_f.format((double)__u, __fc); }
2273 __format::__formatter_fp<_CharT> _M_f;
2277#if defined(__FLT128_DIG__) && _GLIBCXX_FORMAT_F128 == 1
2278 // Reuse __formatter_fp<C>::format<__float128_t, Out> for _Float128.
2279 template<__format::__char _CharT>
2280 struct formatter<_Float128, _CharT>
2282 formatter() = default;
2284 [[__gnu__::__always_inline__]]
2285 constexpr typename basic_format_parse_context<_CharT>::iterator
2286 parse(basic_format_parse_context<_CharT>& __pc)
2287 { return _M_f.parse(__pc); }
2289 template<typename _Out>
2290 typename basic_format_context<_Out, _CharT>::iterator
2291 format(_Float128 __u, basic_format_context<_Out, _CharT>& __fc) const
2292 { return _M_f.format((__format::__float128_t)__u, __fc); }
2295 __format::__formatter_fp<_CharT> _M_f;
2299#if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2300 // Reuse __formatter_fp<C>::format<float, Out> for bfloat16_t.
2301 template<__format::__char _CharT>
2302 struct formatter<__gnu_cxx::__bfloat16_t, _CharT>
2304 formatter() = default;
2306 [[__gnu__::__always_inline__]]
2307 constexpr typename basic_format_parse_context<_CharT>::iterator
2308 parse(basic_format_parse_context<_CharT>& __pc)
2309 { return _M_f.parse(__pc); }
2311 template<typename _Out>
2312 typename basic_format_context<_Out, _CharT>::iterator
2313 format(__gnu_cxx::__bfloat16_t __u,
2314 basic_format_context<_Out, _CharT>& __fc) const
2315 { return _M_f.format((float)__u, __fc); }
2318 __format::__formatter_fp<_CharT> _M_f;
2321#endif // __cpp_lib_to_chars
2323 /** Format a pointer.
2326 template<__format::__char _CharT>
2327 struct formatter<const void*, _CharT>
2329 formatter() = default;
2331 constexpr typename basic_format_parse_context<_CharT>::iterator
2332 parse(basic_format_parse_context<_CharT>& __pc)
2334 __format::_Spec<_CharT> __spec{};
2335 const auto __last = __pc.end();
2336 auto __first = __pc.begin();
2338 auto __finalize = [this, &__spec] {
2342 auto __finished = [&] {
2343 if (__first == __last || *__first == '}')
2354 __first = __spec._M_parse_fill_and_align(__first, __last);
2358// _GLIBCXX_RESOLVE_LIB_DEFECTS
2359// P2510R3 Formatting pointers
2360#if __cplusplus > 202302L || ! defined __STRICT_ANSI__
2361#define _GLIBCXX_P2518R3 1
2363#define _GLIBCXX_P2518R3 0
2367 __first = __spec._M_parse_zero_fill(__first, __last);
2372 __first = __spec._M_parse_width(__first, __last, __pc);
2374 if (__first != __last)
2376 if (*__first == 'p')
2379 else if (*__first == 'P')
2381 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2382 // P2510R3 Formatting pointers
2383 __spec._M_type = __format::_Pres_P;
2392 __format::__failed_to_parse_format_spec();
2395 template<typename _Out>
2396 typename basic_format_context<_Out, _CharT>::iterator
2397 format(const void* __v, basic_format_context<_Out, _CharT>& __fc) const
2399 auto __u = reinterpret_cast<__UINTPTR_TYPE__>(__v);
2400 char __buf[2 + sizeof(__v) * 2];
2401 auto [__ptr, __ec] = std::to_chars(__buf + 2, std::end(__buf),
2403 int __n = __ptr - __buf;
2407 if (_M_spec._M_type == __format::_Pres_P)
2410 for (auto __p = __buf + 2; __p != __ptr; ++__p)
2411#if __has_builtin(__builtin_toupper)
2412 *__p = __builtin_toupper(*__p);
2414 *__p = std::toupper(*__p);
2419 basic_string_view<_CharT> __str;
2420 if constexpr (is_same_v<_CharT, char>)
2421 __str = string_view(__buf, __n);
2422#ifdef _GLIBCXX_USE_WCHAR_T
2425 auto __p = (_CharT*)__builtin_alloca(__n * sizeof(_CharT));
2426 std::__to_wstring_numeric(__buf, __n, __p);
2427 __str = wstring_view(__p, __n);
2432 if (_M_spec._M_zero_fill)
2434 size_t __width = _M_spec._M_get_width(__fc);
2435 if (__width <= __str.size())
2436 return __format::__write(__fc.out(), __str);
2438 auto __out = __fc.out();
2439 // Write "0x" or "0X" prefix before zero-filling.
2440 __out = __format::__write(std::move(__out), __str.substr(0, 2));
2441 __str.remove_prefix(2);
2442 size_t __nfill = __width - __n;
2443 return __format::__write_padded(std::move(__out), __str,
2444 __format::_Align_right,
2445 __nfill, _CharT('0'));
2449 return __format::__write_padded_as_spec(__str, __n, __fc, _M_spec,
2450 __format::_Align_right);
2454 __format::_Spec<_CharT> _M_spec{};
2457 template<__format::__char _CharT>
2458 struct formatter<void*, _CharT>
2460 formatter() = default;
2462 [[__gnu__::__always_inline__]]
2463 constexpr typename basic_format_parse_context<_CharT>::iterator
2464 parse(basic_format_parse_context<_CharT>& __pc)
2465 { return _M_f.parse(__pc); }
2467 template<typename _Out>
2468 typename basic_format_context<_Out, _CharT>::iterator
2469 format(void* __v, basic_format_context<_Out, _CharT>& __fc) const
2470 { return _M_f.format(__v, __fc); }
2473 formatter<const void*, _CharT> _M_f;
2476 template<__format::__char _CharT>
2477 struct formatter<nullptr_t, _CharT>
2479 formatter() = default;
2481 [[__gnu__::__always_inline__]]
2482 constexpr typename basic_format_parse_context<_CharT>::iterator
2483 parse(basic_format_parse_context<_CharT>& __pc)
2484 { return _M_f.parse(__pc); }
2486 template<typename _Out>
2487 typename basic_format_context<_Out, _CharT>::iterator
2488 format(nullptr_t, basic_format_context<_Out, _CharT>& __fc) const
2489 { return _M_f.format(nullptr, __fc); }
2492 formatter<const void*, _CharT> _M_f;
2496#if defined _GLIBCXX_USE_WCHAR_T && __cpp_lib_format_ranges
2497 // _GLIBCXX_RESOLVE_LIB_DEFECTS
2498 // 3944. Formatters converting sequences of char to sequences of wchar_t
2500 namespace __format { struct __disabled; }
2502 // std::formatter<__disabled, C> uses the primary template, which is disabled.
2504 struct formatter<char*, wchar_t>
2505 : private formatter<__format::__disabled, wchar_t> { };
2507 struct formatter<const char*, wchar_t>
2508 : private formatter<__format::__disabled, wchar_t> { };
2509 template<size_t _Nm>
2510 struct formatter<char[_Nm], wchar_t>
2511 : private formatter<__format::__disabled, wchar_t> { };
2512 template<class _Traits, class _Allocator>
2513 struct formatter<basic_string<char, _Traits, _Allocator>, wchar_t>
2514 : private formatter<__format::__disabled, wchar_t> { };
2515 template<class _Traits>
2516 struct formatter<basic_string_view<char, _Traits>, wchar_t>
2517 : private formatter<__format::__disabled, wchar_t> { };
2520/// @cond undocumented
2523 template<typename _Tp, typename _Context,
2525 = typename _Context::template formatter_type<remove_const_t<_Tp>>,
2526 typename _ParseContext
2527 = basic_format_parse_context<typename _Context::char_type>>
2528 concept __parsable_with
2529 = semiregular<_Formatter>
2530 && requires (_Formatter __f, _ParseContext __pc)
2532 { __f.parse(__pc) } -> same_as<typename _ParseContext::iterator>;
2535 template<typename _Tp, typename _Context,
2537 = typename _Context::template formatter_type<remove_const_t<_Tp>>,
2538 typename _ParseContext
2539 = basic_format_parse_context<typename _Context::char_type>>
2540 concept __formattable_with
2541 = semiregular<_Formatter>
2542 && requires (const _Formatter __cf, _Tp&& __t, _Context __fc)
2544 { __cf.format(__t, __fc) } -> same_as<typename _Context::iterator>;
2547 // An unspecified output iterator type used in the `formattable` concept.
2548 template<typename _CharT>
2549 using _Iter_for = back_insert_iterator<basic_string<_CharT>>;
2551 template<typename _Tp, typename _CharT,
2552 typename _Context = basic_format_context<_Iter_for<_CharT>, _CharT>>
2553 concept __formattable_impl
2554 = __parsable_with<_Tp, _Context> && __formattable_with<_Tp, _Context>;
2556} // namespace __format
2559// Concept std::formattable was introduced by P2286R8 "Formatting Ranges",
2560// but we can't guard it with __cpp_lib_format_ranges until we define that!
2561#if __cplusplus > 202002L
2562 // [format.formattable], concept formattable
2563 template<typename _Tp, typename _CharT>
2565 = __format::__formattable_impl<remove_reference_t<_Tp>, _CharT>;
2568#if __cpp_lib_format_ranges
2569 /// @cond undocumented
2572 template<typename _Rg, typename _CharT>
2573 concept __const_formattable_range
2574 = ranges::input_range<const _Rg>
2575 && formattable<ranges::range_reference_t<const _Rg>, _CharT>;
2577 template<typename _Rg, typename _CharT>
2578 using __maybe_const_range
2579 = conditional_t<__const_formattable_range<_Rg, _CharT>, const _Rg, _Rg>;
2580} // namespace __format
2582#endif // format_ranges
2584 /// An iterator after the last character written, and the number of
2585 /// characters that would have been written.
2586 template<typename _Out>
2587 struct format_to_n_result
2590 iter_difference_t<_Out> size;
2593_GLIBCXX_BEGIN_NAMESPACE_CONTAINER
2594template<typename, typename> class vector;
2595_GLIBCXX_END_NAMESPACE_CONTAINER
2597/// @cond undocumented
2600 template<typename _CharT>
2603 _Sink<_CharT>* _M_sink = nullptr;
2606 using iterator_category = output_iterator_tag;
2607 using value_type = void;
2608 using difference_type = ptrdiff_t;
2609 using pointer = void;
2610 using reference = void;
2612 _Sink_iter() = default;
2613 _Sink_iter(const _Sink_iter&) = default;
2614 _Sink_iter& operator=(const _Sink_iter&) = default;
2616 [[__gnu__::__always_inline__]]
2618 _Sink_iter(_Sink<_CharT>& __sink) : _M_sink(std::addressof(__sink)) { }
2620 [[__gnu__::__always_inline__]]
2621 constexpr _Sink_iter&
2622 operator=(_CharT __c)
2624 _M_sink->_M_write(__c);
2628 [[__gnu__::__always_inline__]]
2629 constexpr _Sink_iter&
2630 operator=(basic_string_view<_CharT> __s)
2632 _M_sink->_M_write(__s);
2636 [[__gnu__::__always_inline__]]
2637 constexpr _Sink_iter&
2638 operator*() { return *this; }
2640 [[__gnu__::__always_inline__]]
2641 constexpr _Sink_iter&
2642 operator++() { return *this; }
2644 [[__gnu__::__always_inline__]]
2645 constexpr _Sink_iter
2646 operator++(int) { return *this; }
2649 _M_reserve(size_t __n) const
2650 { return _M_sink->_M_reserve(__n); }
2653 // Abstract base class for type-erased character sinks.
2654 // All formatting and output is done via this type's iterator,
2655 // to reduce the number of different template instantiations.
2656 template<typename _CharT>
2659 friend class _Sink_iter<_CharT>;
2661 span<_CharT> _M_span;
2662 typename span<_CharT>::iterator _M_next;
2664 // Called when the span is full, to make more space available.
2665 // Precondition: _M_next != _M_span.begin()
2666 // Postcondition: _M_next != _M_span.end()
2667 // TODO: remove the precondition? could make overflow handle it.
2668 virtual void _M_overflow() = 0;
2671 // Precondition: __span.size() != 0
2672 [[__gnu__::__always_inline__]]
2674 _Sink(span<_CharT> __span) noexcept
2675 : _M_span(__span), _M_next(__span.begin())
2678 // The portion of the span that has been written to.
2679 [[__gnu__::__always_inline__]]
2681 _M_used() const noexcept
2682 { return _M_span.first(_M_next - _M_span.begin()); }
2684 // The portion of the span that has not been written to.
2685 [[__gnu__::__always_inline__]]
2686 constexpr span<_CharT>
2687 _M_unused() const noexcept
2688 { return _M_span.subspan(_M_next - _M_span.begin()); }
2690 // Use the start of the span as the next write position.
2691 [[__gnu__::__always_inline__]]
2693 _M_rewind() noexcept
2694 { _M_next = _M_span.begin(); }
2696 // Replace the current output range.
2698 _M_reset(span<_CharT> __s, size_t __pos = 0) noexcept
2701 _M_next = __s.begin() + __pos;
2704 // Called by the iterator for *it++ = c
2706 _M_write(_CharT __c)
2709 if (_M_next - _M_span.begin() == std::ssize(_M_span)) [[unlikely]]
2714 _M_write(basic_string_view<_CharT> __s)
2716 span __to = _M_unused();
2717 while (__to.size() <= __s.size())
2719 __s.copy(__to.data(), __to.size());
2720 _M_next += __to.size();
2721 __s.remove_prefix(__to.size());
2727 __s.copy(__to.data(), __s.size());
2728 _M_next += __s.size();
2732 // A successful _Reservation can be used to directly write
2733 // up to N characters to the sink to avoid unwanted buffering.
2736 // True if the reservation was successful, false otherwise.
2737 explicit operator bool() const noexcept { return _M_sink; }
2738 // A pointer to write directly to the sink.
2739 _CharT* get() const noexcept { return _M_sink->_M_next.operator->(); }
2740 // Add n to the _M_next iterator for the sink.
2741 void _M_bump(size_t __n) { _M_sink->_M_bump(__n); }
2745 // Attempt to reserve space to write n characters to the sink.
2746 // If anything is written to the reservation then there must be a call
2747 // to _M_bump(N2) before any call to another member function of *this,
2748 // where N2 is the number of characters written.
2749 virtual _Reservation
2750 _M_reserve(size_t __n)
2752 if (__n <= _M_unused().size())
2755 if (__n <= _M_span.size()) // Cannot meet the request.
2757 _M_overflow(); // Make more space available.
2758 if (__n <= _M_unused().size())
2764 // Update the next output position after writing directly to the sink.
2765 // pre: no calls to _M_write or _M_overflow since _M_reserve.
2771 _Sink(const _Sink&) = delete;
2772 _Sink& operator=(const _Sink&) = delete;
2774 [[__gnu__::__always_inline__]]
2775 constexpr _Sink_iter<_CharT>
2777 { return _Sink_iter<_CharT>(*this); }
2780 // A sink with an internal buffer. This is used to implement concrete sinks.
2781 template<typename _CharT>
2782 class _Buf_sink : public _Sink<_CharT>
2785 _CharT _M_buf[32 * sizeof(void*) / sizeof(_CharT)];
2787 [[__gnu__::__always_inline__]]
2789 _Buf_sink() noexcept
2790 : _Sink<_CharT>(_M_buf)
2794 using _GLIBCXX_STD_C::vector;
2796 // A sink that fills a sequence (e.g. std::string, std::vector, std::deque).
2797 // Writes to a buffer then appends that to the sequence when it fills up.
2798 template<typename _Seq>
2799 class _Seq_sink final : public _Buf_sink<typename _Seq::value_type>
2801 using _CharT = typename _Seq::value_type;
2805 // Transfer buffer contents to the sequence, so buffer can be refilled.
2807 _M_overflow() override
2809 auto __s = this->_M_used();
2810 if (__s.empty()) [[unlikely]]
2811 return; // Nothing in the buffer to transfer to _M_seq.
2813 // If _M_reserve was called then _M_bump must have been called too.
2814 _GLIBCXX_DEBUG_ASSERT(__s.data() != _M_seq.data());
2816 if constexpr (__is_specialization_of<_Seq, basic_string>)
2817 _M_seq.append(__s.data(), __s.size());
2819 _M_seq.insert(_M_seq.end(), __s.begin(), __s.end());
2821 // Make the whole of _M_buf available for the next write:
2825 typename _Sink<_CharT>::_Reservation
2826 _M_reserve(size_t __n) override
2828 // We might already have n characters available in this->_M_unused(),
2829 // but the whole point of this function is to be an optimization for
2830 // the std::format("{}", x) case. We want to avoid writing to _M_buf
2831 // and then copying that into a basic_string if possible, so this
2832 // function prefers to create space directly in _M_seq rather than
2835 if constexpr (__is_specialization_of<_Seq, basic_string>
2836 || __is_specialization_of<_Seq, vector>)
2838 // Flush the buffer to _M_seq first (should not be needed).
2839 if (this->_M_used().size()) [[unlikely]]
2840 _Seq_sink::_M_overflow();
2842 // Expand _M_seq to make __n new characters available:
2843 const auto __sz = _M_seq.size();
2844 if constexpr (is_same_v<string, _Seq> || is_same_v<wstring, _Seq>)
2845 _M_seq.__resize_and_overwrite(__sz + __n,
2846 [](auto, auto __n2) {
2850 _M_seq.resize(__sz + __n);
2852 // Set _M_used() to be a span over the original part of _M_seq
2853 // and _M_unused() to be the extra capacity we just created:
2854 this->_M_reset(_M_seq, __sz);
2857 else // Try to use the base class' buffer.
2858 return _Sink<_CharT>::_M_reserve(__n);
2862 _M_bump(size_t __n) override
2864 if constexpr (__is_specialization_of<_Seq, basic_string>
2865 || __is_specialization_of<_Seq, vector>)
2867 auto __s = this->_M_used();
2868 _GLIBCXX_DEBUG_ASSERT(__s.data() == _M_seq.data());
2869 // Truncate the sequence to the part that was actually written to:
2870 _M_seq.resize(__s.size() + __n);
2871 // Switch back to using buffer:
2872 this->_M_reset(this->_M_buf);
2877 // TODO: for SSO string, use SSO buffer as initial span, then switch
2878 // to _M_buf if it overflows? Or even do that for all unused capacity?
2880 [[__gnu__::__always_inline__]]
2881 _Seq_sink() noexcept(is_nothrow_default_constructible_v<_Seq>)
2884 _Seq_sink(_Seq&& __s) noexcept(is_nothrow_move_constructible_v<_Seq>)
2885 : _M_seq(std::move(__s))
2888 using _Sink<_CharT>::out;
2893 if (this->_M_used().size() != 0)
2894 _Seq_sink::_M_overflow();
2895 return std::move(_M_seq);
2898 // A writable span that views everything written to the sink.
2899 // Will be either a view over _M_seq or the used part of _M_buf.
2903 auto __s = this->_M_used();
2906 if (__s.size() != 0)
2907 _Seq_sink::_M_overflow();
2914 template<typename _CharT, typename _Alloc = allocator<_CharT>>
2916 = _Seq_sink<basic_string<_CharT, char_traits<_CharT>, _Alloc>>;
2918 // template<typename _CharT, typename _Alloc = allocator<_CharT>>
2919 // using _Vec_sink = _Seq_sink<vector<_CharT, _Alloc>>;
2921 // A sink that writes to an output iterator.
2922 // Writes to a fixed-size buffer and then flushes to the output iterator
2923 // when the buffer fills up.
2924 template<typename _CharT, typename _OutIter>
2925 class _Iter_sink : public _Buf_sink<_CharT>
2928 iter_difference_t<_OutIter> _M_max;
2931 size_t _M_count = 0;
2934 _M_overflow() override
2936 auto __s = this->_M_used();
2937 if (_M_max < 0) // No maximum.
2938 _M_out = ranges::copy(__s, std::move(_M_out)).out;
2939 else if (_M_count < static_cast<size_t>(_M_max))
2941 auto __max = _M_max - _M_count;
2942 span<_CharT> __first;
2943 if (__max < __s.size())
2944 __first = __s.first(static_cast<size_t>(__max));
2947 _M_out = ranges::copy(__first, std::move(_M_out)).out;
2950 _M_count += __s.size();
2954 [[__gnu__::__always_inline__]]
2956 _Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __max = -1)
2957 : _M_out(std::move(__out)), _M_max(__max)
2960 using _Sink<_CharT>::out;
2962 format_to_n_result<_OutIter>
2965 if (this->_M_used().size() != 0)
2966 _Iter_sink::_M_overflow();
2967 iter_difference_t<_OutIter> __count(_M_count);
2968 return { std::move(_M_out), __count };
2972 // Partial specialization for contiguous iterators.
2973 // No buffer is used, characters are written straight to the iterator.
2974 // We do not know the size of the output range, so the span size just grows
2975 // as needed. The end of the span might be an invalid pointer outside the
2976 // valid range, but we never actually call _M_span.end(). This class does
2977 // not introduce any invalid pointer arithmetic or overflows that would not
2978 // have happened anyway.
2979 template<typename _CharT, contiguous_iterator _OutIter>
2980 requires same_as<iter_value_t<_OutIter>, _CharT>
2981 class _Iter_sink<_CharT, _OutIter> : public _Sink<_CharT>
2984 iter_difference_t<_OutIter> _M_max = -1;
2986 size_t _M_count = 0;
2988 _CharT _M_buf[64]; // Write here after outputting _M_max characters.
2992 _M_overflow() override
2994 if (this->_M_unused().size() != 0)
2995 return; // No need to switch to internal buffer yet.
2997 auto __s = this->_M_used();
3001 _M_count += __s.size();
3002 // Span was already sized for the maximum character count,
3003 // if it overflows then any further output must go to the
3004 // internal buffer, to be discarded.
3005 this->_M_reset(this->_M_buf);
3009 // No maximum character count. Just extend the span to allow
3010 // writing more characters to it.
3011 this->_M_reset({__s.data(), __s.size() + 1024}, __s.size());
3015 typename _Sink<_CharT>::_Reservation
3016 _M_reserve(size_t __n) final
3018 auto __avail = this->_M_unused();
3019 if (__n > __avail.size())
3022 return {}; // cannot grow
3024 auto __s = this->_M_used();
3025 this->_M_reset({__s.data(), __s.size() + __n}, __s.size());
3032 _S_make_span(_CharT* __ptr, iter_difference_t<_OutIter> __n,
3033 span<_CharT> __buf) noexcept
3036 return __buf; // Only write to the internal buffer.
3040 if constexpr (!is_integral_v<iter_difference_t<_OutIter>>
3041 || sizeof(__n) > sizeof(size_t))
3043 // __int128 or __detail::__max_diff_type
3044 auto __m = iter_difference_t<_OutIter>((size_t)-1);
3048 return {__ptr, (size_t)__n};
3051#if __has_builtin(__builtin_dynamic_object_size)
3052 if (size_t __bytes = __builtin_dynamic_object_size(__ptr, 2))
3053 return {__ptr, __bytes / sizeof(_CharT)};
3055 // Avoid forming a pointer to a different memory page.
3056 const auto __off = reinterpret_cast<__UINTPTR_TYPE__>(__ptr) % 1024;
3057 __n = (1024 - __off) / sizeof(_CharT);
3058 if (__n > 0) [[likely]]
3059 return {__ptr, static_cast<size_t>(__n)};
3060 else // Misaligned/packed buffer of wchar_t?
3066 _Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __n = -1) noexcept
3067 : _Sink<_CharT>(_S_make_span(std::to_address(__out), __n, _M_buf)),
3068 _M_first(__out), _M_max(__n)
3071 format_to_n_result<_OutIter>
3074 auto __s = this->_M_used();
3075 if (__s.data() == _M_buf)
3077 // Switched to internal buffer, so must have written _M_max.
3078 iter_difference_t<_OutIter> __count(_M_count + __s.size());
3079 return { _M_first + _M_max, __count };
3081 else // Not using internal buffer yet
3083 iter_difference_t<_OutIter> __count(__s.size());
3084 return { _M_first + __count, __count };
3089 enum _Arg_t : unsigned char {
3090 _Arg_none, _Arg_bool, _Arg_c, _Arg_i, _Arg_u, _Arg_ll, _Arg_ull,
3091 _Arg_flt, _Arg_dbl, _Arg_ldbl, _Arg_str, _Arg_sv, _Arg_ptr, _Arg_handle,
3092 _Arg_i128, _Arg_u128,
3093 _Arg_bf16, _Arg_f16, _Arg_f32, _Arg_f64, // These are unused.
3094#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3096 _Arg_f128 = _Arg_ldbl,
3097 _Arg_ibm128 = _Arg_next_value_,
3104 template<typename _Context>
3107 using _CharT = typename _Context::char_type;
3123 unsigned long long _M_ull;
3126#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT // No long double if it's ambiguous.
3127 long double _M_ldbl;
3129 const _CharT* _M_str;
3130 basic_string_view<_CharT> _M_sv;
3132 _HandleBase _M_handle;
3133#ifdef __SIZEOF_INT128__
3135 unsigned __int128 _M_u128;
3137#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3140#elif _GLIBCXX_FORMAT_F128 == 2
3141 __float128_t _M_f128;
3145 [[__gnu__::__always_inline__]]
3146 _Arg_value() : _M_none() { }
3149 template<typename _Tp>
3150 _Arg_value(in_place_type_t<_Tp>, _Tp __val)
3151 { _S_get<_Tp>() = __val; }
3154 template<typename _Tp, typename _Self>
3155 [[__gnu__::__always_inline__]]
3157 _S_get(_Self& __u) noexcept
3159 if constexpr (is_same_v<_Tp, bool>)
3161 else if constexpr (is_same_v<_Tp, _CharT>)
3163 else if constexpr (is_same_v<_Tp, int>)
3165 else if constexpr (is_same_v<_Tp, unsigned>)
3167 else if constexpr (is_same_v<_Tp, long long>)
3169 else if constexpr (is_same_v<_Tp, unsigned long long>)
3171 else if constexpr (is_same_v<_Tp, float>)
3173 else if constexpr (is_same_v<_Tp, double>)
3175#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3176 else if constexpr (is_same_v<_Tp, long double>)
3179 else if constexpr (is_same_v<_Tp, __ieee128>)
3181 else if constexpr (is_same_v<_Tp, __ibm128>)
3182 return __u._M_ibm128;
3184 else if constexpr (is_same_v<_Tp, const _CharT*>)
3186 else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
3188 else if constexpr (is_same_v<_Tp, const void*>)
3190#ifdef __SIZEOF_INT128__
3191 else if constexpr (is_same_v<_Tp, __int128>)
3193 else if constexpr (is_same_v<_Tp, unsigned __int128>)
3196#if _GLIBCXX_FORMAT_F128 == 2
3197 else if constexpr (is_same_v<_Tp, __float128_t>)
3200 else if constexpr (derived_from<_Tp, _HandleBase>)
3201 return static_cast<_Tp&>(__u._M_handle);
3202 // Otherwise, ill-formed.
3205 template<typename _Tp>
3206 [[__gnu__::__always_inline__]]
3209 { return _S_get<_Tp>(*this); }
3211 template<typename _Tp>
3212 [[__gnu__::__always_inline__]]
3214 _M_get() const noexcept
3215 { return _S_get<_Tp>(*this); }
3217 template<typename _Tp>
3218 [[__gnu__::__always_inline__]]
3220 _M_set(_Tp __v) noexcept
3222 if constexpr (derived_from<_Tp, _HandleBase>)
3223 std::construct_at(&_M_handle, __v);
3225 _S_get<_Tp>(*this) = __v;
3229 // [format.arg.store], class template format-arg-store
3230 template<typename _Context, typename... _Args>
3233} // namespace __format
3236 template<typename _Context>
3237 class basic_format_arg
3239 using _CharT = typename _Context::char_type;
3241 template<typename _Tp>
3242 static constexpr bool __formattable
3243 = __format::__formattable_with<_Tp, _Context>;
3246 class handle : public __format::_Arg_value<_Context>::_HandleBase
3248 using _Base = typename __format::_Arg_value<_Context>::_HandleBase;
3250 // Format as const if possible, to reduce instantiations.
3251 template<typename _Tp>
3252 using __maybe_const_t
3253 = __conditional_t<__formattable<const _Tp>, const _Tp, _Tp>;
3255 template<typename _Tq>
3257 _S_format(basic_format_parse_context<_CharT>& __parse_ctx,
3258 _Context& __format_ctx, const void* __ptr)
3260 using _Td = remove_const_t<_Tq>;
3261 typename _Context::template formatter_type<_Td> __f;
3262 __parse_ctx.advance_to(__f.parse(__parse_ctx));
3263 _Tq& __val = *const_cast<_Tq*>(static_cast<const _Td*>(__ptr));
3264 __format_ctx.advance_to(__f.format(__val, __format_ctx));
3267 template<typename _Tp>
3269 handle(_Tp& __val) noexcept
3271 this->_M_ptr = __builtin_addressof(__val);
3272 auto __func = _S_format<__maybe_const_t<_Tp>>;
3273 this->_M_func = reinterpret_cast<void(*)()>(__func);
3276 friend class basic_format_arg<_Context>;
3279 handle(const handle&) = default;
3280 handle& operator=(const handle&) = default;
3282 [[__gnu__::__always_inline__]]
3284 format(basic_format_parse_context<_CharT>& __pc, _Context& __fc) const
3286 using _Func = void(*)(basic_format_parse_context<_CharT>&,
3287 _Context&, const void*);
3288 auto __f = reinterpret_cast<_Func>(this->_M_func);
3289 __f(__pc, __fc, this->_M_ptr);
3293 [[__gnu__::__always_inline__]]
3294 basic_format_arg() noexcept : _M_type(__format::_Arg_none) { }
3296 [[nodiscard,__gnu__::__always_inline__]]
3297 explicit operator bool() const noexcept
3298 { return _M_type != __format::_Arg_none; }
3301 template<typename _Ctx>
3302 friend class basic_format_args;
3304 template<typename _Ctx, typename... _Args>
3305 friend class __format::_Arg_store;
3307 static_assert(is_trivially_copyable_v<__format::_Arg_value<_Context>>);
3309 __format::_Arg_value<_Context> _M_val;
3310 __format::_Arg_t _M_type;
3312 // Transform incoming argument type to the type stored in _Arg_value.
3313 // e.g. short -> int, std::string -> std::string_view,
3314 // char[3] -> const char*.
3315 template<typename _Tp>
3316 static consteval auto
3319 using _Td = remove_const_t<_Tp>;
3320 if constexpr (is_same_v<_Td, bool>)
3321 return type_identity<bool>();
3322 else if constexpr (is_same_v<_Td, _CharT>)
3323 return type_identity<_CharT>();
3324 else if constexpr (is_same_v<_Td, char> && is_same_v<_CharT, wchar_t>)
3325 return type_identity<_CharT>();
3326#ifdef __SIZEOF_INT128__ // Check before signed/unsigned integer
3327 else if constexpr (is_same_v<_Td, __int128>)
3328 return type_identity<__int128>();
3329 else if constexpr (is_same_v<_Td, unsigned __int128>)
3330 return type_identity<unsigned __int128>();
3332 else if constexpr (__is_signed_integer<_Td>::value)
3334 if constexpr (sizeof(_Td) <= sizeof(int))
3335 return type_identity<int>();
3336 else if constexpr (sizeof(_Td) <= sizeof(long long))
3337 return type_identity<long long>();
3339 else if constexpr (__is_unsigned_integer<_Td>::value)
3341 if constexpr (sizeof(_Td) <= sizeof(unsigned))
3342 return type_identity<unsigned>();
3343 else if constexpr (sizeof(_Td) <= sizeof(unsigned long long))
3344 return type_identity<unsigned long long>();
3346 else if constexpr (is_same_v<_Td, float>)
3347 return type_identity<float>();
3348 else if constexpr (is_same_v<_Td, double>)
3349 return type_identity<double>();
3350#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3351 else if constexpr (is_same_v<_Td, long double>)
3352 return type_identity<long double>();
3354 else if constexpr (is_same_v<_Td, __ibm128>)
3355 return type_identity<__ibm128>();
3356 else if constexpr (is_same_v<_Td, __ieee128>)
3357 return type_identity<__ieee128>();
3360#if defined(__FLT16_DIG__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3361 else if constexpr (is_same_v<_Td, _Float16>)
3362 return type_identity<float>();
3365#if defined(__BFLT16_DIG__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3366 else if constexpr (is_same_v<_Td, decltype(0.0bf16)>)
3367 return type_identity<float>();
3370#if defined(__FLT32_DIG__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3371 else if constexpr (is_same_v<_Td, _Float32>)
3372 return type_identity<float>();
3375#if defined(__FLT64_DIG__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3376 else if constexpr (is_same_v<_Td, _Float64>)
3377 return type_identity<double>();
3380#if _GLIBCXX_FORMAT_F128
3382 else if constexpr (is_same_v<_Td, _Float128>)
3383 return type_identity<__format::__float128_t>();
3385# if __SIZEOF_FLOAT128__
3386 else if constexpr (is_same_v<_Td, __float128>)
3387 return type_identity<__format::__float128_t>();
3390 else if constexpr (__is_specialization_of<_Td, basic_string_view>
3391 || __is_specialization_of<_Td, basic_string>)
3393 if constexpr (is_same_v<typename _Td::value_type, _CharT>)
3394 return type_identity<basic_string_view<_CharT>>();
3396 return type_identity<handle>();
3398 else if constexpr (is_same_v<decay_t<_Td>, const _CharT*>)
3399 return type_identity<const _CharT*>();
3400 else if constexpr (is_same_v<decay_t<_Td>, _CharT*>)
3401 return type_identity<const _CharT*>();
3402 else if constexpr (is_void_v<remove_pointer_t<_Td>>)
3403 return type_identity<const void*>();
3404 else if constexpr (is_same_v<_Td, nullptr_t>)
3405 return type_identity<const void*>();
3407 return type_identity<handle>();
3410 // Transform a formattable type to the appropriate storage type.
3411 template<typename _Tp>
3412 using _Normalize = typename decltype(_S_to_arg_type<_Tp>())::type;
3414 // Get the _Arg_t value corresponding to a normalized type.
3415 template<typename _Tp>
3416 static consteval __format::_Arg_t
3419 using namespace __format;
3420 if constexpr (is_same_v<_Tp, bool>)
3422 else if constexpr (is_same_v<_Tp, _CharT>)
3424 else if constexpr (is_same_v<_Tp, int>)
3426 else if constexpr (is_same_v<_Tp, unsigned>)
3428 else if constexpr (is_same_v<_Tp, long long>)
3430 else if constexpr (is_same_v<_Tp, unsigned long long>)
3432 else if constexpr (is_same_v<_Tp, float>)
3434 else if constexpr (is_same_v<_Tp, double>)
3436#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3437 else if constexpr (is_same_v<_Tp, long double>)
3440 // Don't use _Arg_ldbl for this target, it's ambiguous.
3441 else if constexpr (is_same_v<_Tp, __ibm128>)
3443 else if constexpr (is_same_v<_Tp, __ieee128>)
3446 else if constexpr (is_same_v<_Tp, const _CharT*>)
3448 else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
3450 else if constexpr (is_same_v<_Tp, const void*>)
3452#ifdef __SIZEOF_INT128__
3453 else if constexpr (is_same_v<_Tp, __int128>)
3455 else if constexpr (is_same_v<_Tp, unsigned __int128>)
3459#if _GLIBCXX_FORMAT_F128 == 2
3460 else if constexpr (is_same_v<_Tp, __format::__float128_t>)
3463 else if constexpr (is_same_v<_Tp, handle>)
3467 template<typename _Tp>
3469 _M_set(_Tp __v) noexcept
3471 _M_type = _S_to_enum<_Tp>();
3475 template<typename _Tp>
3476 requires __format::__formattable_with<_Tp, _Context>
3478 basic_format_arg(_Tp& __v) noexcept
3480 using _Td = _Normalize<_Tp>;
3481 if constexpr (is_same_v<_Td, basic_string_view<_CharT>>)
3482 _M_set(_Td{__v.data(), __v.size()});
3483 else if constexpr (is_same_v<remove_const_t<_Tp>, char>
3484 && is_same_v<_CharT, wchar_t>)
3485 _M_set(static_cast<_Td>(static_cast<unsigned char>(__v)));
3487 _M_set(static_cast<_Td>(__v));
3490 template<typename _Ctx, typename... _Argz>
3492 make_format_args(_Argz&...) noexcept;
3494 template<typename _Visitor, typename _Ctx>
3495 friend decltype(auto)
3496 visit_format_arg(_Visitor&& __vis, basic_format_arg<_Ctx>);
3498 template<typename _Visitor>
3500 _M_visit(_Visitor&& __vis, __format::_Arg_t __type)
3502 using namespace __format;
3506 return std::forward<_Visitor>(__vis)(_M_val._M_none);
3508 return std::forward<_Visitor>(__vis)(_M_val._M_bool);
3510 return std::forward<_Visitor>(__vis)(_M_val._M_c);
3512 return std::forward<_Visitor>(__vis)(_M_val._M_i);
3514 return std::forward<_Visitor>(__vis)(_M_val._M_u);
3516 return std::forward<_Visitor>(__vis)(_M_val._M_ll);
3518 return std::forward<_Visitor>(__vis)(_M_val._M_ull);
3519#if __glibcxx_to_chars // FIXME: need to be able to format these types!
3521 return std::forward<_Visitor>(__vis)(_M_val._M_flt);
3523 return std::forward<_Visitor>(__vis)(_M_val._M_dbl);
3524#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
3526 return std::forward<_Visitor>(__vis)(_M_val._M_ldbl);
3529 return std::forward<_Visitor>(__vis)(_M_val._M_f128);
3531 return std::forward<_Visitor>(__vis)(_M_val._M_ibm128);
3535 return std::forward<_Visitor>(__vis)(_M_val._M_str);
3537 return std::forward<_Visitor>(__vis)(_M_val._M_sv);
3539 return std::forward<_Visitor>(__vis)(_M_val._M_ptr);
3542 auto& __h = static_cast<handle&>(_M_val._M_handle);
3543 return std::forward<_Visitor>(__vis)(__h);
3545#ifdef __SIZEOF_INT128__
3547 return std::forward<_Visitor>(__vis)(_M_val._M_i128);
3549 return std::forward<_Visitor>(__vis)(_M_val._M_u128);
3552#if _GLIBCXX_FORMAT_F128 == 2
3554 return std::forward<_Visitor>(__vis)(_M_val._M_f128);
3559 __builtin_unreachable();
3564 template<typename _Visitor, typename _Context>
3565 inline decltype(auto)
3566 visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg)
3568 return __arg._M_visit(std::forward<_Visitor>(__vis), __arg._M_type);
3571/// @cond undocumented
3574 struct _WidthPrecVisitor
3576 template<typename _Tp>
3578 operator()(_Tp& __arg) const
3580 if constexpr (is_same_v<_Tp, monostate>)
3581 __format::__invalid_arg_id_in_format_string();
3582 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3583 // 3720. Restrict the valid types of arg-id for width and precision
3584 // 3721. Allow an arg-id with a value of zero for width
3585 else if constexpr (sizeof(_Tp) <= sizeof(long long))
3587 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3588 // 3720. Restrict the valid types of arg-id for width and precision
3589 if constexpr (__is_unsigned_integer<_Tp>::value)
3591 else if constexpr (__is_signed_integer<_Tp>::value)
3595 __throw_format_error("format error: argument used for width or "
3596 "precision must be a non-negative integer");
3600 template<typename _Context>
3602 __int_from_arg(const basic_format_arg<_Context>& __arg)
3603 { return std::visit_format_arg(_WidthPrecVisitor(), __arg); }
3605 // Pack _Arg_t enum values into a single 60-bit integer.
3606 template<int _Bits, size_t _Nm>
3608 __pack_arg_types(const array<_Arg_t, _Nm>& __types)
3610 __UINT64_TYPE__ __packed_types = 0;
3611 for (auto __i = __types.rbegin(); __i != __types.rend(); ++__i)
3612 __packed_types = (__packed_types << _Bits) | *__i;
3613 return __packed_types;
3615} // namespace __format
3618 template<typename _Context>
3619 class basic_format_args
3621 static constexpr int _S_packed_type_bits = 5; // _Arg_t values [0,20]
3622 static constexpr int _S_packed_type_mask = 0b11111;
3623 static constexpr int _S_max_packed_args = 12;
3625 static_assert( __format::_Arg_max_ <= (1 << _S_packed_type_bits) );
3627 template<typename... _Args>
3628 using _Store = __format::_Arg_store<_Context, _Args...>;
3630 template<typename _Ctx, typename... _Args>
3631 friend class __format::_Arg_store;
3633 using uint64_t = __UINT64_TYPE__;
3634 using _Format_arg = basic_format_arg<_Context>;
3635 using _Format_arg_val = __format::_Arg_value<_Context>;
3637 // If args are packed then the number of args is in _M_packed_size and
3638 // the packed types are in _M_unpacked_size, accessed via _M_type(i).
3639 // If args are not packed then the number of args is in _M_unpacked_size
3640 // and _M_packed_size is zero.
3641 uint64_t _M_packed_size : 4;
3642 uint64_t _M_unpacked_size : 60;
3645 const _Format_arg_val* _M_values; // Active when _M_packed_size != 0
3646 const _Format_arg* _M_args; // Active when _M_packed_size == 0
3650 _M_size() const noexcept
3651 { return _M_packed_size ? _M_packed_size : _M_unpacked_size; }
3653 typename __format::_Arg_t
3654 _M_type(size_t __i) const noexcept
3656 uint64_t __t = _M_unpacked_size >> (__i * _S_packed_type_bits);
3657 return static_cast<__format::_Arg_t>(__t & _S_packed_type_mask);
3660 template<typename _Ctx, typename... _Args>
3662 make_format_args(_Args&...) noexcept;
3664 // An array of _Arg_t enums corresponding to _Args...
3665 template<typename... _Args>
3666 static consteval array<__format::_Arg_t, sizeof...(_Args)>
3668 { return {_Format_arg::template _S_to_enum<_Args>()...}; }
3671 template<typename... _Args>
3672 basic_format_args(const _Store<_Args...>& __store) noexcept;
3674 [[nodiscard,__gnu__::__always_inline__]]
3675 basic_format_arg<_Context>
3676 get(size_t __i) const noexcept
3678 basic_format_arg<_Context> __arg;
3679 if (__i < _M_packed_size)
3681 __arg._M_type = _M_type(__i);
3682 __arg._M_val = _M_values[__i];
3684 else if (_M_packed_size == 0 && __i < _M_unpacked_size)
3685 __arg = _M_args[__i];
3690 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3691 // 3810. CTAD for std::basic_format_args
3692 template<typename _Context, typename... _Args>
3693 basic_format_args(__format::_Arg_store<_Context, _Args...>)
3694 -> basic_format_args<_Context>;
3696 template<typename _Context, typename... _Args>
3698 make_format_args(_Args&... __fmt_args) noexcept;
3700 // An array of type-erased formatting arguments.
3701 template<typename _Context, typename... _Args>
3702 class __format::_Arg_store
3704 friend std::basic_format_args<_Context>;
3706 template<typename _Ctx, typename... _Argz>
3708#if _GLIBCXX_INLINE_VERSION
3709 __8:: // Needed for PR c++/59256
3711 make_format_args(_Argz&...) noexcept;
3713 // For a sufficiently small number of arguments we only store values.
3714 // basic_format_args can get the types from the _Args pack.
3715 static constexpr bool _S_values_only
3716 = sizeof...(_Args) <= basic_format_args<_Context>::_S_max_packed_args;
3719 = __conditional_t<_S_values_only,
3720 __format::_Arg_value<_Context>,
3721 basic_format_arg<_Context>>;
3723 _Element_t _M_args[sizeof...(_Args)];
3725 template<typename _Tp>
3727 _S_make_elt(_Tp& __v)
3729 using _Tq = remove_const_t<_Tp>;
3730 using _CharT = typename _Context::char_type;
3731 static_assert(is_default_constructible_v<formatter<_Tq, _CharT>>,
3732 "std::formatter must be specialized for the type "
3733 "of each format arg");
3734 using __format::__formattable_with;
3735 if constexpr (is_const_v<_Tp>)
3736 if constexpr (!__formattable_with<_Tp, _Context>)
3737 if constexpr (__formattable_with<_Tq, _Context>)
3738 static_assert(__formattable_with<_Tp, _Context>,
3739 "format arg must be non-const because its "
3740 "std::formatter specialization has a "
3741 "non-const reference parameter");
3742 basic_format_arg<_Context> __arg(__v);
3743 if constexpr (_S_values_only)
3744 return __arg._M_val;
3749 template<typename... _Tp>
3750 requires (sizeof...(_Tp) == sizeof...(_Args))
3751 [[__gnu__::__always_inline__]]
3752 _Arg_store(_Tp&... __a) noexcept
3753 : _M_args{_S_make_elt(__a)...}
3757 template<typename _Context>
3758 class __format::_Arg_store<_Context>
3761 template<typename _Context>
3762 template<typename... _Args>
3764 basic_format_args<_Context>::
3765 basic_format_args(const _Store<_Args...>& __store) noexcept
3767 if constexpr (sizeof...(_Args) == 0)
3770 _M_unpacked_size = 0;
3773 else if constexpr (sizeof...(_Args) <= _S_max_packed_args)
3775 // The number of packed arguments:
3776 _M_packed_size = sizeof...(_Args);
3777 // The packed type enums:
3779 = __format::__pack_arg_types<_S_packed_type_bits>(_S_types_to_pack<_Args...>());
3780 // The _Arg_value objects.
3781 _M_values = __store._M_args;
3785 // No packed arguments:
3787 // The number of unpacked arguments:
3788 _M_unpacked_size = sizeof...(_Args);
3789 // The basic_format_arg objects:
3790 _M_args = __store._M_args;
3794 /// Capture formatting arguments for use by `std::vformat`.
3795 template<typename _Context = format_context, typename... _Args>
3796 [[nodiscard,__gnu__::__always_inline__]]
3798 make_format_args(_Args&... __fmt_args) noexcept
3800 using _Fmt_arg = basic_format_arg<_Context>;
3801 using _Store = __format::_Arg_store<_Context, typename _Fmt_arg::template
3802 _Normalize<_Args>...>;
3803 return _Store(__fmt_args...);
3806#ifdef _GLIBCXX_USE_WCHAR_T
3807 /// Capture formatting arguments for use by `std::vformat` (for wide output).
3808 template<typename... _Args>
3809 [[nodiscard,__gnu__::__always_inline__]]
3811 make_wformat_args(_Args&... __args) noexcept
3812 { return std::make_format_args<wformat_context>(__args...); }
3815/// @cond undocumented
3818 template<typename _Out, typename _CharT, typename _Context>
3820 __do_vformat_to(_Out, basic_string_view<_CharT>,
3821 const basic_format_args<_Context>&,
3822 const locale* = nullptr);
3823} // namespace __format
3826 /** Context for std::format and similar functions.
3828 * A formatting context contains an output iterator and locale to use
3829 * for the formatting operations. Most programs will never need to use
3830 * this class template explicitly. For typical uses of `std::format` the
3831 * library will use the specializations `std::format_context` (for `char`)
3832 * and `std::wformat_context` (for `wchar_t`).
3834 template<typename _Out, typename _CharT>
3835 class basic_format_context
3837 static_assert( output_iterator<_Out, const _CharT&> );
3839 basic_format_args<basic_format_context> _M_args;
3841 __format::_Optional_locale _M_loc;
3843 basic_format_context(basic_format_args<basic_format_context> __args,
3845 : _M_args(__args), _M_out(std::move(__out))
3848 basic_format_context(basic_format_args<basic_format_context> __args,
3849 _Out __out, const std::locale& __loc)
3850 : _M_args(__args), _M_out(std::move(__out)), _M_loc(__loc)
3853 // _GLIBCXX_RESOLVE_LIB_DEFECTS
3854 // 4061. Should std::basic_format_context be
3855 // default-constructible/copyable/movable?
3856 basic_format_context(const basic_format_context&) = delete;
3857 basic_format_context& operator=(const basic_format_context&) = delete;
3859 template<typename _Out2, typename _CharT2, typename _Context2>
3861 __format::__do_vformat_to(_Out2, basic_string_view<_CharT2>,
3862 const basic_format_args<_Context2>&,
3866 ~basic_format_context() = default;
3868 using iterator = _Out;
3869 using char_type = _CharT;
3870 template<typename _Tp>
3871 using formatter_type = formatter<_Tp, _CharT>;
3874 basic_format_arg<basic_format_context>
3875 arg(size_t __id) const noexcept
3876 { return _M_args.get(__id); }
3879 std::locale locale() { return _M_loc.value(); }
3882 iterator out() { return std::move(_M_out); }
3884 void advance_to(iterator __it) { _M_out = std::move(__it); }
3888/// @cond undocumented
3891 // Abstract base class defining an interface for scanning format strings.
3892 // Scan the characters in a format string, dividing it up into strings of
3893 // ordinary characters, escape sequences, and replacement fields.
3894 // Call virtual functions for derived classes to parse format-specifiers
3895 // or write formatted output.
3896 template<typename _CharT>
3899 using iterator = typename basic_format_parse_context<_CharT>::iterator;
3901 basic_format_parse_context<_CharT> _M_pc;
3904 _Scanner(basic_string_view<_CharT> __str, size_t __nargs = (size_t)-1)
3905 : _M_pc(__str, __nargs)
3908 constexpr iterator begin() const noexcept { return _M_pc.begin(); }
3909 constexpr iterator end() const noexcept { return _M_pc.end(); }
3914 basic_string_view<_CharT> __fmt = _M_fmt_str();
3916 if (__fmt.size() == 2 && __fmt[0] == '{' && __fmt[1] == '}')
3918 _M_pc.advance_to(begin() + 1);
3919 _M_format_arg(_M_pc.next_arg_id());
3923 size_t __lbr = __fmt.find('{');
3924 size_t __rbr = __fmt.find('}');
3926 while (__fmt.size())
3928 auto __cmp = __lbr <=> __rbr;
3932 _M_pc.advance_to(end());
3937 if (__lbr + 1 == __fmt.size()
3938 || (__rbr == __fmt.npos && __fmt[__lbr + 1] != '{'))
3939 __format::__unmatched_left_brace_in_format_string();
3940 const bool __is_escape = __fmt[__lbr + 1] == '{';
3941 iterator __last = begin() + __lbr + int(__is_escape);
3942 _M_on_chars(__last);
3943 _M_pc.advance_to(__last + 1);
3944 __fmt = _M_fmt_str();
3947 if (__rbr != __fmt.npos)
3949 __lbr = __fmt.find('{');
3953 _M_on_replacement_field();
3954 __fmt = _M_fmt_str();
3955 __lbr = __fmt.find('{');
3956 __rbr = __fmt.find('}');
3961 if (++__rbr == __fmt.size() || __fmt[__rbr] != '}')
3962 __format::__unmatched_right_brace_in_format_string();
3963 iterator __last = begin() + __rbr;
3964 _M_on_chars(__last);
3965 _M_pc.advance_to(__last + 1);
3966 __fmt = _M_fmt_str();
3967 if (__lbr != __fmt.npos)
3969 __rbr = __fmt.find('}');
3974 constexpr basic_string_view<_CharT>
3975 _M_fmt_str() const noexcept
3976 { return {begin(), end()}; }
3978 constexpr virtual void _M_on_chars(iterator) { }
3980 constexpr void _M_on_replacement_field()
3982 auto __next = begin();
3986 __id = _M_pc.next_arg_id();
3987 else if (*__next == ':')
3989 __id = _M_pc.next_arg_id();
3990 _M_pc.advance_to(++__next);
3994 auto [__i, __ptr] = __format::__parse_arg_id(begin(), end());
3995 if (!__ptr || !(*__ptr == '}' || *__ptr == ':'))
3996 __format::__invalid_arg_id_in_format_string();
3997 _M_pc.check_arg_id(__id = __i);
4000 _M_pc.advance_to(++__ptr);
4003 _M_pc.advance_to(__ptr);
4005 _M_format_arg(__id);
4006 if (begin() == end() || *begin() != '}')
4007 __format::__unmatched_left_brace_in_format_string();
4008 _M_pc.advance_to(begin() + 1); // Move past '}'
4011 constexpr virtual void _M_format_arg(size_t __id) = 0;
4014 // Process a format string and format the arguments in the context.
4015 template<typename _Out, typename _CharT>
4016 class _Formatting_scanner : public _Scanner<_CharT>
4019 _Formatting_scanner(basic_format_context<_Out, _CharT>& __fc,
4020 basic_string_view<_CharT> __str)
4021 : _Scanner<_CharT>(__str), _M_fc(__fc)
4025 basic_format_context<_Out, _CharT>& _M_fc;
4027 using iterator = typename _Scanner<_CharT>::iterator;
4030 _M_on_chars(iterator __last) override
4032 basic_string_view<_CharT> __str(this->begin(), __last);
4033 _M_fc.advance_to(__format::__write(_M_fc.out(), __str));
4037 _M_format_arg(size_t __id) override
4039 using _Context = basic_format_context<_Out, _CharT>;
4040 using handle = typename basic_format_arg<_Context>::handle;
4042 std::visit_format_arg([this](auto& __arg) {
4043 using _Type = remove_reference_t<decltype(__arg)>;
4044 using _Formatter = typename _Context::template formatter_type<_Type>;
4045 if constexpr (is_same_v<_Type, monostate>)
4046 __format::__invalid_arg_id_in_format_string();
4047 else if constexpr (is_same_v<_Type, handle>)
4048 __arg.format(this->_M_pc, this->_M_fc);
4049 else if constexpr (is_default_constructible_v<_Formatter>)
4052 this->_M_pc.advance_to(__f.parse(this->_M_pc));
4053 this->_M_fc.advance_to(__f.format(__arg, this->_M_fc));
4056 static_assert(__format::__formattable_with<_Type, _Context>);
4057 }, _M_fc.arg(__id));
4061 // Validate a format string for Args.
4062 template<typename _CharT, typename... _Args>
4063 class _Checking_scanner : public _Scanner<_CharT>
4066 (is_default_constructible_v<formatter<_Args, _CharT>> && ...),
4067 "std::formatter must be specialized for each type being formatted");
4071 _Checking_scanner(basic_string_view<_CharT> __str)
4072 : _Scanner<_CharT>(__str, sizeof...(_Args))
4077 _M_format_arg(size_t __id) override
4079 if constexpr (sizeof...(_Args) != 0)
4081 if (__id < sizeof...(_Args))
4083 _M_parse_format_spec<_Args...>(__id);
4087 __builtin_unreachable();
4090 template<typename _Tp, typename... _OtherArgs>
4092 _M_parse_format_spec(size_t __id)
4096 formatter<_Tp, _CharT> __f;
4097 this->_M_pc.advance_to(__f.parse(this->_M_pc));
4099 else if constexpr (sizeof...(_OtherArgs) != 0)
4100 _M_parse_format_spec<_OtherArgs...>(__id - 1);
4102 __builtin_unreachable();
4106 template<typename _Out, typename _CharT, typename _Context>
4108 __do_vformat_to(_Out __out, basic_string_view<_CharT> __fmt,
4109 const basic_format_args<_Context>& __args,
4110 const locale* __loc)
4112 _Iter_sink<_CharT, _Out> __sink(std::move(__out));
4113 _Sink_iter<_CharT> __sink_out;
4115 if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
4116 __sink_out = __out; // Already a sink iterator, safe to use post-move.
4118 __sink_out = __sink.out();
4120 if constexpr (is_same_v<_CharT, char>)
4121 // Fast path for "{}" format strings and simple format arg types.
4122 if (__fmt.size() == 2 && __fmt[0] == '{' && __fmt[1] == '}')
4124 bool __done = false;
4125 std::visit_format_arg([&](auto& __arg) {
4126 using _Tp = remove_cvref_t<decltype(__arg)>;
4127 if constexpr (is_same_v<_Tp, bool>)
4129 size_t __len = 4 + !__arg;
4130 const char* __chars[] = { "false", "true" };
4131 if (auto __res = __sink_out._M_reserve(__len))
4133 __builtin_memcpy(__res.get(), __chars[__arg], __len);
4134 __res._M_bump(__len);
4138 else if constexpr (is_same_v<_Tp, char>)
4140 if (auto __res = __sink_out._M_reserve(1))
4142 *__res.get() = __arg;
4147 else if constexpr (is_integral_v<_Tp>)
4149 make_unsigned_t<_Tp> __uval;
4150 const bool __neg = __arg < 0;
4152 __uval = make_unsigned_t<_Tp>(~__arg) + 1u;
4155 const auto __n = __detail::__to_chars_len(__uval);
4156 if (auto __res = __sink_out._M_reserve(__n + __neg))
4158 auto __ptr = __res.get();
4160 __detail::__to_chars_10_impl(__ptr + (int)__neg, __n,
4162 __res._M_bump(__n + __neg);
4166 else if constexpr (is_convertible_v<_Tp, string_view>)
4168 string_view __sv = __arg;
4169 if (auto __res = __sink_out._M_reserve(__sv.size()))
4171 __builtin_memcpy(__res.get(), __sv.data(), __sv.size());
4172 __res._M_bump(__sv.size());
4180 if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
4183 return std::move(__sink)._M_finish().out;
4187 auto __ctx = __loc == nullptr
4188 ? _Context(__args, __sink_out)
4189 : _Context(__args, __sink_out, *__loc);
4190 _Formatting_scanner<_Sink_iter<_CharT>, _CharT> __scanner(__ctx, __fmt);
4191 __scanner._M_scan();
4193 if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
4196 return std::move(__sink)._M_finish().out;
4199} // namespace __format
4202 template<typename _CharT, typename... _Args>
4203 template<typename _Tp>
4204 requires convertible_to<const _Tp&, basic_string_view<_CharT>>
4206 basic_format_string<_CharT, _Args...>::
4207 basic_format_string(const _Tp& __s)
4210 __format::_Checking_scanner<_CharT, remove_cvref_t<_Args>...>
4212 __scanner._M_scan();
4215 // [format.functions], formatting functions
4217 template<typename _Out> requires output_iterator<_Out, const char&>
4218 [[__gnu__::__always_inline__]]
4220 vformat_to(_Out __out, string_view __fmt, format_args __args)
4221 { return __format::__do_vformat_to(std::move(__out), __fmt, __args); }
4223#ifdef _GLIBCXX_USE_WCHAR_T
4224 template<typename _Out> requires output_iterator<_Out, const wchar_t&>
4225 [[__gnu__::__always_inline__]]
4227 vformat_to(_Out __out, wstring_view __fmt, wformat_args __args)
4228 { return __format::__do_vformat_to(std::move(__out), __fmt, __args); }
4231 template<typename _Out> requires output_iterator<_Out, const char&>
4232 [[__gnu__::__always_inline__]]
4234 vformat_to(_Out __out, const locale& __loc, string_view __fmt,
4237 return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc);
4240#ifdef _GLIBCXX_USE_WCHAR_T
4241 template<typename _Out> requires output_iterator<_Out, const wchar_t&>
4242 [[__gnu__::__always_inline__]]
4244 vformat_to(_Out __out, const locale& __loc, wstring_view __fmt,
4245 wformat_args __args)
4247 return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc);
4253 vformat(string_view __fmt, format_args __args)
4255 __format::_Str_sink<char> __buf;
4256 std::vformat_to(__buf.out(), __fmt, __args);
4257 return std::move(__buf).get();
4260#ifdef _GLIBCXX_USE_WCHAR_T
4263 vformat(wstring_view __fmt, wformat_args __args)
4265 __format::_Str_sink<wchar_t> __buf;
4266 std::vformat_to(__buf.out(), __fmt, __args);
4267 return std::move(__buf).get();
4273 vformat(const locale& __loc, string_view __fmt, format_args __args)
4275 __format::_Str_sink<char> __buf;
4276 std::vformat_to(__buf.out(), __loc, __fmt, __args);
4277 return std::move(__buf).get();
4280#ifdef _GLIBCXX_USE_WCHAR_T
4283 vformat(const locale& __loc, wstring_view __fmt, wformat_args __args)
4285 __format::_Str_sink<wchar_t> __buf;
4286 std::vformat_to(__buf.out(), __loc, __fmt, __args);
4287 return std::move(__buf).get();
4291 template<typename... _Args>
4294 format(format_string<_Args...> __fmt, _Args&&... __args)
4295 { return std::vformat(__fmt.get(), std::make_format_args(__args...)); }
4297#ifdef _GLIBCXX_USE_WCHAR_T
4298 template<typename... _Args>
4301 format(wformat_string<_Args...> __fmt, _Args&&... __args)
4302 { return std::vformat(__fmt.get(), std::make_wformat_args(__args...)); }
4305 template<typename... _Args>
4308 format(const locale& __loc, format_string<_Args...> __fmt,
4311 return std::vformat(__loc, __fmt.get(),
4312 std::make_format_args(__args...));
4315#ifdef _GLIBCXX_USE_WCHAR_T
4316 template<typename... _Args>
4319 format(const locale& __loc, wformat_string<_Args...> __fmt,
4322 return std::vformat(__loc, __fmt.get(),
4323 std::make_wformat_args(__args...));
4327 template<typename _Out, typename... _Args>
4328 requires output_iterator<_Out, const char&>
4330 format_to(_Out __out, format_string<_Args...> __fmt, _Args&&... __args)
4332 return std::vformat_to(std::move(__out), __fmt.get(),
4333 std::make_format_args(__args...));
4336#ifdef _GLIBCXX_USE_WCHAR_T
4337 template<typename _Out, typename... _Args>
4338 requires output_iterator<_Out, const wchar_t&>
4340 format_to(_Out __out, wformat_string<_Args...> __fmt, _Args&&... __args)
4342 return std::vformat_to(std::move(__out), __fmt.get(),
4343 std::make_wformat_args(__args...));
4347 template<typename _Out, typename... _Args>
4348 requires output_iterator<_Out, const char&>
4350 format_to(_Out __out, const locale& __loc, format_string<_Args...> __fmt,
4353 return std::vformat_to(std::move(__out), __loc, __fmt.get(),
4354 std::make_format_args(__args...));
4357#ifdef _GLIBCXX_USE_WCHAR_T
4358 template<typename _Out, typename... _Args>
4359 requires output_iterator<_Out, const wchar_t&>
4361 format_to(_Out __out, const locale& __loc, wformat_string<_Args...> __fmt,
4364 return std::vformat_to(std::move(__out), __loc, __fmt.get(),
4365 std::make_wformat_args(__args...));
4369 template<typename _Out, typename... _Args>
4370 requires output_iterator<_Out, const char&>
4371 inline format_to_n_result<_Out>
4372 format_to_n(_Out __out, iter_difference_t<_Out> __n,
4373 format_string<_Args...> __fmt, _Args&&... __args)
4375 __format::_Iter_sink<char, _Out> __sink(std::move(__out), __n);
4376 std::vformat_to(__sink.out(), __fmt.get(),
4377 std::make_format_args(__args...));
4378 return std::move(__sink)._M_finish();
4381#ifdef _GLIBCXX_USE_WCHAR_T
4382 template<typename _Out, typename... _Args>
4383 requires output_iterator<_Out, const wchar_t&>
4384 inline format_to_n_result<_Out>
4385 format_to_n(_Out __out, iter_difference_t<_Out> __n,
4386 wformat_string<_Args...> __fmt, _Args&&... __args)
4388 __format::_Iter_sink<wchar_t, _Out> __sink(std::move(__out), __n);
4389 std::vformat_to(__sink.out(), __fmt.get(),
4390 std::make_wformat_args(__args...));
4391 return std::move(__sink)._M_finish();
4395 template<typename _Out, typename... _Args>
4396 requires output_iterator<_Out, const char&>
4397 inline format_to_n_result<_Out>
4398 format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
4399 format_string<_Args...> __fmt, _Args&&... __args)
4401 __format::_Iter_sink<char, _Out> __sink(std::move(__out), __n);
4402 std::vformat_to(__sink.out(), __loc, __fmt.get(),
4403 std::make_format_args(__args...));
4404 return std::move(__sink)._M_finish();
4407#ifdef _GLIBCXX_USE_WCHAR_T
4408 template<typename _Out, typename... _Args>
4409 requires output_iterator<_Out, const wchar_t&>
4410 inline format_to_n_result<_Out>
4411 format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
4412 wformat_string<_Args...> __fmt, _Args&&... __args)
4414 __format::_Iter_sink<wchar_t, _Out> __sink(std::move(__out), __n);
4415 std::vformat_to(__sink.out(), __loc, __fmt.get(),
4416 std::make_wformat_args(__args...));
4417 return std::move(__sink)._M_finish();
4421/// @cond undocumented
4425 template<typename _CharT>
4426 class _Counting_sink final : public _Iter_sink<_CharT, _CharT*>
4429 _Counting_sink() : _Iter_sink<_CharT, _CharT*>(nullptr, 0) { }
4431 [[__gnu__::__always_inline__]]
4434 { return this->_M_count + this->_M_used().size(); }
4437 template<typename _CharT>
4438 class _Counting_sink : public _Buf_sink<_CharT>
4440 size_t _M_count = 0;
4443 _M_overflow() override
4445 if (!std::is_constant_evaluated())
4446 _M_count += this->_M_used().size();
4451 _Counting_sink() = default;
4453 [[__gnu__::__always_inline__]]
4457 _Counting_sink::_M_overflow();
4462} // namespace __format
4465 template<typename... _Args>
4468 formatted_size(format_string<_Args...> __fmt, _Args&&... __args)
4470 __format::_Counting_sink<char> __buf;
4471 std::vformat_to(__buf.out(), __fmt.get(),
4472 std::make_format_args(__args...));
4473 return __buf.count();
4476#ifdef _GLIBCXX_USE_WCHAR_T
4477 template<typename... _Args>
4480 formatted_size(wformat_string<_Args...> __fmt, _Args&&... __args)
4482 __format::_Counting_sink<wchar_t> __buf;
4483 std::vformat_to(__buf.out(), __fmt.get(),
4484 std::make_wformat_args(__args...));
4485 return __buf.count();
4489 template<typename... _Args>
4492 formatted_size(const locale& __loc, format_string<_Args...> __fmt,
4495 __format::_Counting_sink<char> __buf;
4496 std::vformat_to(__buf.out(), __loc, __fmt.get(),
4497 std::make_format_args(__args...));
4498 return __buf.count();
4501#ifdef _GLIBCXX_USE_WCHAR_T
4502 template<typename... _Args>
4505 formatted_size(const locale& __loc, wformat_string<_Args...> __fmt,
4508 __format::_Counting_sink<wchar_t> __buf;
4509 std::vformat_to(__buf.out(), __loc, __fmt.get(),
4510 std::make_wformat_args(__args...));
4511 return __buf.count();
4515#if __cpp_lib_format_ranges
4516 // [format.range], formatting of ranges
4517 // [format.range.fmtkind], variable template format_kind
4518 enum class range_format {
4527 /// @cond undocumented
4528 template<typename _Rg>
4529 constexpr auto format_kind = not defined(format_kind<_Rg>);
4531 template<typename _Tp>
4532 consteval range_format
4535 using _Ref = ranges::range_reference_t<_Tp>;
4536 if constexpr (is_same_v<remove_cvref_t<_Ref>, _Tp>)
4537 return range_format::disabled;
4538 else if constexpr (requires { typename _Tp::key_type; })
4540 if constexpr (requires { typename _Tp::mapped_type; })
4542 using _Up = remove_cvref_t<_Ref>;
4543 if constexpr (__is_pair<_Up>)
4544 return range_format::map;
4545 else if constexpr (__is_specialization_of<_Up, tuple>)
4546 if constexpr (tuple_size_v<_Up> == 2)
4547 return range_format::map;
4549 return range_format::set;
4552 return range_format::sequence;
4556 /// A constant determining how a range should be formatted.
4557 template<ranges::input_range _Rg> requires same_as<_Rg, remove_cvref_t<_Rg>>
4558 constexpr range_format format_kind<_Rg> = __fmt_kind<_Rg>();
4560 // [format.range.formatter], class template range_formatter
4561 template<typename _Tp, typename _CharT = char>
4562 requires same_as<remove_cvref_t<_Tp>, _Tp> && formattable<_Tp, _CharT>
4563 class range_formatter; // TODO
4565/// @cond undocumented
4568 // [format.range.fmtdef], class template range-default-formatter
4569 template<range_format _Kind, ranges::input_range _Rg, typename _CharT>
4570 struct __range_default_formatter; // TODO
4571} // namespace __format
4574 // [format.range.fmtmap], [format.range.fmtset], [format.range.fmtstr],
4575 // specializations for maps, sets, and strings
4576 template<ranges::input_range _Rg, typename _CharT>
4577 requires (format_kind<_Rg> != range_format::disabled)
4578 && formattable<ranges::range_reference_t<_Rg>, _CharT>
4579 struct formatter<_Rg, _CharT>
4580 : __format::__range_default_formatter<format_kind<_Rg>, _Rg, _CharT>
4582#endif // C++23 formatting ranges
4584_GLIBCXX_END_NAMESPACE_VERSION
4586#endif // __cpp_lib_format
4587#endif // _GLIBCXX_FORMAT