Where Online Learning is simpler!

The C and C++ Include Header Files

/usr/include/c++/13/format


$ cat -n /usr/include/c++/13/format

     1	// <format> Formatting -*- C++ -*-
     2	
     3	// Copyright The GNU Toolchain Authors.
     4	//
     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)
     9	// any later version.
    10	
    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.
    15	
    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.
    19	
    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/>.
    24	
    25	/** @file include/format
    26	 *  This is a Standard C++ Library header.
    27	 */
    28	
    29	#ifndef _GLIBCXX_FORMAT
    30	#define _GLIBCXX_FORMAT 1
    31	
    32	#pragma GCC system_header
    33	
    34	#include <bits/requires_hosted.h> // for std::string
    35	
    36	#if __cplusplus >= 202002L
    37	
    38	#include <array>
    39	#include <charconv>
    40	#include <concepts>
    41	#include <limits>
    42	#include <locale>
    43	#include <optional>
    44	#include <span>
    45	#include <string_view>
    46	#include <string>
    47	#include <variant>	       // monostate (TODO: move to bits/utility.h?)
    48	#include <bits/ranges_base.h>  // input_range, range_reference_t
    49	#include <bits/ranges_algobase.h> // ranges::copy
    50	#include <bits/stl_iterator.h> // back_insert_iterator
    51	#include <bits/stl_pair.h>     // __is_pair
    52	#include <bits/utility.h>      // tuple_size_v
    53	#include <ext/numeric_traits.h> // __int_traits
    54	
    55	#if !__has_builtin(__builtin_toupper)
    56	# include <cctype>
    57	#endif
    58	
    59	namespace std _GLIBCXX_VISIBILITY(default)
    60	{
    61	_GLIBCXX_BEGIN_NAMESPACE_VERSION
    62	
    63	// 201907 Text Formatting, Integration of chrono, printf corner cases.
    64	// 202106 std::format improvements.
    65	// 202110 Fixing locale handling in chrono formatters, generator-like types.
    66	// 202207 Encodings in localized formatting of chrono, basic-format-string.
    67	#define __cpp_lib_format 202110L
    68	
    69	#define __cpp_lib_format_uchar 202311L
    70	
    71	#if __cplusplus > 202002L
    72	// 202207 P2286R8 Formatting Ranges
    73	// 202207 P2585R1 Improving default container formatting
    74	// TODO: #define __cpp_lib_format_ranges 202207L
    75	#endif
    76	
    77	  // [format.context], class template basic_format_context
    78	  template<typename _Out, typename _CharT> class basic_format_context;
    79	
    80	/// @cond undocumented
    81	namespace __format
    82	{
    83	  // Type-erased character sink.
    84	  template<typename _CharT> class _Sink;
    85	  // Output iterator that writes to a type-erase character sink.
    86	  template<typename _CharT>
    87	    class _Sink_iter;
    88	} // namespace __format
    89	/// @endcond
    90	
    91	  using format_context
    92	    = basic_format_context<__format::_Sink_iter<char>, char>;
    93	  using wformat_context
    94	    = basic_format_context<__format::_Sink_iter<wchar_t>, wchar_t>;
    95	
    96	  // [format.args], class template basic_format_args
    97	  template<typename _Context> class basic_format_args;
    98	  using format_args = basic_format_args<format_context>;
    99	  using wformat_args = basic_format_args<wformat_context>;
   100	
   101	  // [format.arguments], arguments
   102	  // [format.arg], class template basic_format_arg
   103	  template<typename _Context>
   104	    class basic_format_arg;
   105	
   106	  // [format.fmt.string], class template basic_format_string
   107	
   108	  /** A compile-time checked format string for the specified argument types.
   109	   *
   110	   * @since C++23 but available as an extension in C++20.
   111	   */
   112	  template<typename _CharT, typename... _Args>
   113	    struct basic_format_string
   114	    {
   115	      template<typename _Tp>
   116		requires convertible_to<const _Tp&, basic_string_view<_CharT>>
   117		consteval
   118		basic_format_string(const _Tp& __s);
   119	
   120	      [[__gnu__::__always_inline__]]
   121	      constexpr basic_string_view<_CharT>
   122	      get() const noexcept
   123	      { return _M_str; }
   124	
   125	    private:
   126	      basic_string_view<_CharT> _M_str;
   127	    };
   128	
   129	  template<typename... _Args>
   130	    using format_string = basic_format_string<char, type_identity_t<_Args>...>;
   131	
   132	  template<typename... _Args>
   133	    using wformat_string
   134	      = basic_format_string<wchar_t, type_identity_t<_Args>...>;
   135	
   136	  // [format.formatter], formatter
   137	
   138	  /// The primary template of std::formatter is disabled.
   139	  template<typename _Tp, typename _CharT = char>
   140	    struct formatter
   141	    {
   142	      formatter() = delete; // No std::formatter specialization for this type.
   143	      formatter(const formatter&) = delete;
   144	      formatter& operator=(const formatter&) = delete;
   145	    };
   146	
   147	  // [format.error], class format_error
   148	  class format_error : public runtime_error
   149	  {
   150	  public:
   151	    explicit format_error(const string& __what) : runtime_error(__what) { }
   152	    explicit format_error(const char* __what) : runtime_error(__what) { }
   153	  };
   154	
   155	  /// @cond undocumented
   156	  [[noreturn]]
   157	  inline void
   158	  __throw_format_error(const char* __what)
   159	  { _GLIBCXX_THROW_OR_ABORT(format_error(__what)); }
   160	
   161	namespace __format
   162	{
   163	  // XXX use named functions for each constexpr error?
   164	
   165	  [[noreturn]]
   166	  inline void
   167	  __unmatched_left_brace_in_format_string()
   168	  { __throw_format_error("format error: unmatched '{' in format string"); }
   169	
   170	  [[noreturn]]
   171	  inline void
   172	  __unmatched_right_brace_in_format_string()
   173	  { __throw_format_error("format error: unmatched '}' in format string"); }
   174	
   175	  [[noreturn]]
   176	  inline void
   177	  __conflicting_indexing_in_format_string()
   178	  { __throw_format_error("format error: conflicting indexing style in format string"); }
   179	
   180	  [[noreturn]]
   181	  inline void
   182	  __invalid_arg_id_in_format_string()
   183	  { __throw_format_error("format error: invalid arg-id in format string"); }
   184	
   185	  [[noreturn]]
   186	  inline void
   187	  __failed_to_parse_format_spec()
   188	  { __throw_format_error("format error: failed to parse format-spec"); }
   189	} // namespace __format
   190	  /// @endcond
   191	
   192	  // [format.parse.ctx], class template basic_format_parse_context
   193	  template<typename _CharT> class basic_format_parse_context;
   194	  using format_parse_context = basic_format_parse_context<char>;
   195	  using wformat_parse_context = basic_format_parse_context<wchar_t>;
   196	
   197	  template<typename _CharT>
   198	    class basic_format_parse_context
   199	    {
   200	    public:
   201	      using char_type = _CharT;
   202	      using const_iterator = typename basic_string_view<_CharT>::const_iterator;
   203	      using iterator = const_iterator;
   204	
   205	      constexpr explicit
   206	      basic_format_parse_context(basic_string_view<_CharT> __fmt,
   207					 size_t __num_args = 0) noexcept
   208	      : _M_begin(__fmt.begin()), _M_end(__fmt.end()), _M_num_args(__num_args)
   209	      { }
   210	
   211	      basic_format_parse_context(const basic_format_parse_context&) = delete;
   212	      void operator=(const basic_format_parse_context&) = delete;
   213	
   214	      constexpr const_iterator begin() const noexcept { return _M_begin; }
   215	      constexpr const_iterator end() const noexcept { return _M_end; }
   216	
   217	      constexpr void
   218	      advance_to(const_iterator __it) noexcept
   219	      { _M_begin = __it; }
   220	
   221	      constexpr size_t
   222	      next_arg_id()
   223	      {
   224		if (_M_indexing == _Manual)
   225		  __format::__conflicting_indexing_in_format_string();
   226		_M_indexing = _Auto;
   227	
   228		// _GLIBCXX_RESOLVE_LIB_DEFECTS
   229		// 3825. Missing compile-time argument id check in next_arg_id
   230		if (std::is_constant_evaluated())
   231		  if (_M_next_arg_id == _M_num_args)
   232		    __format::__invalid_arg_id_in_format_string();
   233		return _M_next_arg_id++;
   234	      }
   235	
   236	      constexpr void
   237	      check_arg_id(size_t __id)
   238	      {
   239		if (_M_indexing == _Auto)
   240		  __format::__conflicting_indexing_in_format_string();
   241		_M_indexing = _Manual;
   242	
   243		if (std::is_constant_evaluated())
   244		  if (__id >= _M_num_args)
   245		    __format::__invalid_arg_id_in_format_string();
   246	      }
   247	
   248	    private:
   249	      iterator _M_begin;
   250	      iterator _M_end;
   251	      enum _Indexing { _Unknown, _Manual, _Auto };
   252	      _Indexing _M_indexing = _Unknown;
   253	      size_t _M_next_arg_id = 0;
   254	      size_t _M_num_args;
   255	    };
   256	
   257	/// @cond undocumented
   258	  template<typename _Tp, template<typename...> class _Class>
   259	    static constexpr bool __is_specialization_of = false;
   260	  template<template<typename...> class _Class, typename... _Args>
   261	    static constexpr bool __is_specialization_of<_Class<_Args...>, _Class>
   262	      = true;
   263	
   264	namespace __format
   265	{
   266	  // pre: first != last
   267	  template<typename _CharT>
   268	    constexpr pair<unsigned short, const _CharT*>
   269	    __parse_integer(const _CharT* __first, const _CharT* __last)
   270	    {
   271	      if (__first == __last)
   272		__builtin_unreachable();
   273	
   274	      if constexpr (is_same_v<_CharT, char>)
   275		{
   276		  const auto __start = __first;
   277		  unsigned short __val = 0;
   278		  // N.B. std::from_chars is not constexpr in C++20.
   279		  if (__detail::__from_chars_alnum<true>(__first, __last, __val, 10)
   280			&& __first != __start) [[likely]]
   281		    return {__val, __first};
   282		}
   283	      else
   284		{
   285		  constexpr int __n = 32;
   286		  char __buf[__n]{};
   287		  for (int __i = 0; __i < __n && (__first + __i) != __last; ++__i)
   288		    __buf[__i] = __first[__i];
   289		  auto [__v, __ptr] = __format::__parse_integer(__buf, __buf + __n);
   290		  if (__ptr) [[likely]]
   291		    return {__v, __first + (__ptr - __buf)};
   292		}
   293	      return {0, nullptr};
   294	    }
   295	
   296	  template<typename _CharT>
   297	    constexpr pair<unsigned short, const _CharT*>
   298	    __parse_arg_id(const _CharT* __first, const _CharT* __last)
   299	    {
   300	      if (__first == __last)
   301		__builtin_unreachable();
   302	
   303	      if (*__first == '0')
   304		return {0, __first + 1}; // No leading zeros allowed, so '0...' == 0
   305	
   306	      if ('1' <= *__first && *__first <= '9')
   307		{
   308		  const unsigned short __id = *__first - '0';
   309		  const auto __next = __first + 1;
   310		  // Optimize for most likely case of single digit arg-id.
   311		  if (__next == __last || !('0' <= *__next && *__next <= '9'))
   312		    return {__id, __next};
   313		  else
   314		    return __format::__parse_integer(__first, __last);
   315		}
   316	      return {0, nullptr};
   317	    }
   318	
   319	  enum _Pres_type {
   320	    _Pres_none = 0, // Default type (not valid for integer presentation types).
   321	    // Presentation types for integral types (including bool and charT).
   322	    _Pres_d = 1, _Pres_b, _Pres_B, _Pres_o, _Pres_x, _Pres_X, _Pres_c,
   323	    // Presentation types for floating-point types.
   324	    _Pres_a = 1, _Pres_A, _Pres_e, _Pres_E, _Pres_f, _Pres_F, _Pres_g, _Pres_G,
   325	    _Pres_p = 0, _Pres_P,   // For pointers.
   326	    _Pres_s = 0,            // For strings and bool.
   327	    _Pres_esc = 0xf,        // For strings and charT.
   328	  };
   329	
   330	  enum _Align {
   331	    _Align_default,
   332	    _Align_left,
   333	    _Align_right,
   334	    _Align_centre,
   335	  };
   336	
   337	  enum _Sign {
   338	    _Sign_default,
   339	    _Sign_plus,
   340	    _Sign_minus,  // XXX does this need to be distinct from _Sign_default?
   341	    _Sign_space,
   342	  };
   343	
   344	  enum _WidthPrec {
   345	    _WP_none,    // No width/prec specified.
   346	    _WP_value,   // Fixed width/prec specified.
   347	    _WP_from_arg // Use a formatting argument for width/prec.
   348	  };
   349	
   350	  template<typename _Context>
   351	    size_t
   352	    __int_from_arg(const basic_format_arg<_Context>& __arg);
   353	
   354	  constexpr bool __is_digit(char __c)
   355	  { return std::__detail::__from_chars_alnum_to_val(__c) < 10; }
   356	
   357	  constexpr bool __is_xdigit(char __c)
   358	  { return std::__detail::__from_chars_alnum_to_val(__c) < 16; }
   359	
   360	  template<typename _CharT>
   361	    struct _Spec
   362	    {
   363	      _Align     _M_align : 2;
   364	      _Sign      _M_sign : 2;
   365	      unsigned   _M_alt : 1;
   366	      unsigned   _M_localized : 1;
   367	      unsigned   _M_zero_fill : 1;
   368	      _WidthPrec _M_width_kind : 2;
   369	      _WidthPrec _M_prec_kind : 2;
   370	      _Pres_type _M_type : 4;
   371	      unsigned short _M_width;
   372	      unsigned short _M_prec;
   373	      _CharT _M_fill = ' ';
   374	
   375	      using iterator = typename basic_string_view<_CharT>::iterator;
   376	
   377	      static constexpr _Align
   378	      _S_align(_CharT __c) noexcept
   379	      {
   380		switch (__c)
   381		{
   382		  case '<': return _Align_left;
   383		  case '>': return _Align_right;
   384		  case '^': return _Align_centre;
   385		  default: return _Align_default;
   386		}
   387	      }
   388	
   389	      // pre: __first != __last
   390	      constexpr iterator
   391	      _M_parse_fill_and_align(iterator __first, iterator __last) noexcept
   392	      {
   393		if (*__first != '{')
   394		  {
   395		    // TODO: accept any UCS scalar value as fill character.
   396		    // If narrow source encoding is UTF-8 then accept multibyte char.
   397		    if (__last - __first >= 2)
   398		      {
   399			if (_Align __align = _S_align(__first[1]))
   400			  {
   401			    _M_fill = *__first;
   402			    _M_align = __align;
   403			    return __first + 2;
   404			  }
   405		      }
   406	
   407		    if (_Align __align = _S_align(__first[0]))
   408		      {
   409			_M_fill = ' ';
   410			_M_align = __align;
   411			return __first + 1;
   412		      }
   413		  }
   414		return __first;
   415	      }
   416	
   417	      static constexpr _Sign
   418	      _S_sign(_CharT __c) noexcept
   419	      {
   420		switch (__c)
   421		{
   422		  case '+': return _Sign_plus;
   423		  case '-': return _Sign_minus;
   424		  case ' ': return _Sign_space;
   425		  default:  return _Sign_default;
   426		}
   427	      }
   428	
   429	      // pre: __first != __last
   430	      constexpr iterator
   431	      _M_parse_sign(iterator __first, iterator) noexcept
   432	      {
   433		if (_Sign __sign = _S_sign(*__first))
   434		  {
   435		    _M_sign = __sign;
   436		    return __first + 1;
   437		  }
   438		return __first;
   439	      }
   440	
   441	      // pre: *__first is valid
   442	      constexpr iterator
   443	      _M_parse_alternate_form(iterator __first, iterator) noexcept
   444	      {
   445		if (*__first == '#')
   446		  {
   447		    _M_alt = true;
   448		    ++__first;
   449		  }
   450		return __first;
   451	      }
   452	
   453	      // pre: __first != __last
   454	      constexpr iterator
   455	      _M_parse_zero_fill(iterator __first, iterator /* __last */) noexcept
   456	      {
   457		if (*__first == '0')
   458		  {
   459		    _M_zero_fill = true;
   460		    ++__first;
   461		  }
   462		return __first;
   463	      }
   464	
   465	      // pre: __first != __last
   466	      static constexpr iterator
   467	      _S_parse_width_or_precision(iterator __first, iterator __last,
   468					  unsigned short& __val, bool& __arg_id,
   469					  basic_format_parse_context<_CharT>& __pc)
   470	      {
   471		if (__format::__is_digit(*__first))
   472		  {
   473		    auto [__v, __ptr] = __format::__parse_integer(__first, __last);
   474		    if (!__ptr)
   475		      __throw_format_error("format error: invalid width or precision "
   476					   "in format-spec");
   477		    __first = __ptr;
   478		    __val = __v;
   479		  }
   480		else if (*__first == '{')
   481		  {
   482		    __arg_id = true;
   483		    ++__first;
   484		    if (__first == __last)
   485		      __format::__unmatched_left_brace_in_format_string();
   486		    if (*__first == '}')
   487		      __val = __pc.next_arg_id();
   488		    else
   489		      {
   490			auto [__v, __ptr] = __format::__parse_arg_id(__first, __last);
   491			if (__ptr == nullptr || __ptr == __last || *__ptr != '}')
   492			  __format::__invalid_arg_id_in_format_string();
   493			__first = __ptr;
   494			__pc.check_arg_id(__v);
   495			__val = __v;
   496		      }
   497		    ++__first; // past the '}'
   498		  }
   499		return __first;
   500	      }
   501	
   502	      // pre: __first != __last
   503	      constexpr iterator
   504	      _M_parse_width(iterator __first, iterator __last,
   505			     basic_format_parse_context<_CharT>& __pc)
   506	      {
   507		bool __arg_id = false;
   508		if (*__first == '0')
   509		  __throw_format_error("format error: width must be non-zero in "
   510				       "format string");
   511		auto __next = _S_parse_width_or_precision(__first, __last, _M_width,
   512							  __arg_id, __pc);
   513		if (__next != __first)
   514		  _M_width_kind = __arg_id ? _WP_from_arg : _WP_value;
   515		return __next;
   516	      }
   517	
   518	      // pre: __first != __last
   519	      constexpr iterator
   520	      _M_parse_precision(iterator __first, iterator __last,
   521				 basic_format_parse_context<_CharT>& __pc)
   522	      {
   523		if (__first[0] != '.')
   524		  return __first;
   525	
   526		iterator __next = ++__first;
   527		bool __arg_id = false;
   528		if (__next != __last)
   529		  __next = _S_parse_width_or_precision(__first, __last, _M_prec,
   530						       __arg_id, __pc);
   531		if (__next == __first)
   532		  __throw_format_error("format error: missing precision after '.' in "
   533				       "format string");
   534		_M_prec_kind = __arg_id ? _WP_from_arg : _WP_value;
   535		return __next;
   536	      }
   537	
   538	      // pre: __first != __last
   539	      constexpr iterator
   540	      _M_parse_locale(iterator __first, iterator /* __last */) noexcept
   541	      {
   542		if (*__first == 'L')
   543		  {
   544		    _M_localized = true;
   545		    ++__first;
   546		  }
   547		return __first;
   548	      }
   549	
   550	      template<typename _Context>
   551		size_t
   552		_M_get_width(_Context& __ctx) const
   553		{
   554		  size_t __width = 0;
   555		  if (_M_width_kind == _WP_value)
   556		    __width = _M_width;
   557		  else if (_M_width_kind == _WP_from_arg)
   558		    __width = __format::__int_from_arg(__ctx.arg(_M_width));
   559		  return __width;
   560		}
   561	
   562	      template<typename _Context>
   563		size_t
   564		_M_get_precision(_Context& __ctx) const
   565		{
   566		  size_t __prec = -1;
   567		  if (_M_prec_kind == _WP_value)
   568		    __prec = _M_prec;
   569		  else if (_M_prec_kind == _WP_from_arg)
   570		    __prec = __format::__int_from_arg(__ctx.arg(_M_prec));
   571		  return __prec;
   572		}
   573	    };
   574	
   575	  template<typename _Int>
   576	    inline char*
   577	    __put_sign(_Int __i, _Sign __sign, char* __dest) noexcept
   578	    {
   579	      if (__i < 0)
   580		*__dest = '-';
   581	      else if (__sign == _Sign_plus)
   582		*__dest = '+';
   583	      else if (__sign == _Sign_space)
   584		*__dest = ' ';
   585	      else
   586		++__dest;
   587	      return __dest;
   588	    }
   589	
   590	  // Write STR to OUT (and do so efficiently if OUT is a _Sink_iter).
   591	  template<typename _Out, typename _CharT>
   592	    requires output_iterator<_Out, const _CharT&>
   593	    inline _Out
   594	    __write(_Out __out, basic_string_view<_CharT> __str)
   595	    {
   596	      if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
   597		{
   598		  if (__str.size())
   599		    __out = __str;
   600		}
   601	      else
   602		for (_CharT __c : __str)
   603		  *__out++ = __c;
   604	      return __out;
   605	    }
   606	
   607	  // Write STR to OUT with NFILL copies of FILL_CHAR specified by ALIGN.
   608	  // pre: __align != _Align_default
   609	  template<typename _Out, typename _CharT>
   610	    _Out
   611	    __write_padded(_Out __out, basic_string_view<_CharT> __str,
   612			   _Align __align, size_t __nfill, _CharT __fill_char)
   613	    {
   614	      const size_t __buflen = 0x20;
   615	      _CharT __padding_chars[__buflen];
   616	      __padding_chars[0] = _CharT();
   617	      basic_string_view<_CharT> __padding{__padding_chars, __buflen};
   618	
   619	      auto __pad = [&__padding] (size_t __n, _Out& __o) {
   620		if (__n == 0)
   621		  return;
   622		while (__n > __padding.size())
   623		  {
   624		    __o = __format::__write(std::move(__o), __padding);
   625		    __n -= __padding.size();
   626		  }
   627		if (__n != 0)
   628		  __o = __format::__write(std::move(__o), __padding.substr(0, __n));
   629	      };
   630	
   631	      size_t __l, __r, __max;
   632	      if (__align == _Align_centre)
   633		{
   634		  __l = __nfill / 2;
   635		  __r = __l + (__nfill & 1);
   636		  __max = __r;
   637		}
   638	      else if (__align == _Align_right)
   639		{
   640		  __l = __nfill;
   641		  __r = 0;
   642		  __max = __l;
   643		}
   644	      else
   645		{
   646		  __l = 0;
   647		  __r = __nfill;
   648		  __max = __r;
   649		}
   650	      if (__max < __buflen)
   651		__padding.remove_suffix(__buflen - __max);
   652	      else
   653		__max = __buflen;
   654	      char_traits<_CharT>::assign(__padding_chars, __max, __fill_char);
   655	
   656	      __pad(__l, __out);
   657	      __out = __format::__write(std::move(__out), __str);
   658	      __pad(__r, __out);
   659	
   660	      return __out;
   661	    }
   662	
   663	  // Write STR to OUT, with alignment and padding as determined by SPEC.
   664	  // pre: __spec._M_align != _Align_default || __align != _Align_default
   665	  template<typename _CharT, typename _Out>
   666	    _Out
   667	    __write_padded_as_spec(basic_string_view<type_identity_t<_CharT>> __str,
   668				   size_t __estimated_width,
   669				   basic_format_context<_Out, _CharT>& __fc,
   670				   const _Spec<_CharT>& __spec,
   671				   _Align __align = _Align_left)
   672	    {
   673	      size_t __width = __spec._M_get_width(__fc);
   674	
   675	      if (__width <= __estimated_width)
   676		return __format::__write(__fc.out(), __str);
   677	
   678	      const size_t __nfill = __width - __estimated_width;
   679	
   680	      if (__spec._M_align)
   681		__align = __spec._M_align;
   682	
   683	      return __format::__write_padded(__fc.out(), __str, __align, __nfill,
   684					      __spec._M_fill);
   685	    }
   686	
   687	  // A lightweight optional<locale>.
   688	  struct _Optional_locale
   689	  {
   690	    [[__gnu__::__always_inline__]]
   691	    _Optional_locale() : _M_dummy(), _M_hasval(false) { }
   692	
   693	    _Optional_locale(const locale& __loc) noexcept
   694	    : _M_loc(__loc), _M_hasval(true)
   695	    { }
   696	
   697	    _Optional_locale(const _Optional_locale& __l) noexcept
   698	    : _M_dummy(), _M_hasval(__l._M_hasval)
   699	    {
   700	      if (_M_hasval)
   701		std::construct_at(&_M_loc, __l._M_loc);
   702	    }
   703	
   704	    _Optional_locale&
   705	    operator=(const _Optional_locale& __l) noexcept
   706	    {
   707	      if (_M_hasval)
   708		{
   709		  if (__l._M_hasval)
   710		    _M_loc = __l._M_loc;
   711		  else
   712		    {
   713		      _M_loc.~locale();
   714		      _M_hasval = false;
   715		    }
   716		}
   717	      else if (__l._M_hasval)
   718		{
   719		  std::construct_at(&_M_loc, __l._M_loc);
   720		  _M_hasval = true;
   721		}
   722	      return *this;
   723	    }
   724	
   725	    ~_Optional_locale() { if (_M_hasval) _M_loc.~locale(); }
   726	
   727	    _Optional_locale&
   728	    operator=(locale&& __loc) noexcept
   729	    {
   730	      if (_M_hasval)
   731		_M_loc = std::move(__loc);
   732	      else
   733		{
   734		  std::construct_at(&_M_loc, std::move(__loc));
   735		  _M_hasval = true;
   736		}
   737	      return *this;
   738	    }
   739	
   740	    const locale&
   741	    value() noexcept
   742	    {
   743	      if (!_M_hasval)
   744		{
   745		  std::construct_at(&_M_loc);
   746		  _M_hasval = true;
   747		}
   748	      return _M_loc;
   749	    }
   750	
   751	    bool has_value() const noexcept { return _M_hasval; }
   752	
   753	    union {
   754	      char _M_dummy = '\0';
   755	      std::locale _M_loc;
   756	    };
   757	    bool _M_hasval = false;
   758	  };
   759	
   760	  template<typename _CharT>
   761	    concept __char = same_as<_CharT, char> || same_as<_CharT, wchar_t>;
   762	
   763	  template<__char _CharT>
   764	    struct __formatter_str
   765	    {
   766	      constexpr typename basic_format_parse_context<_CharT>::iterator
   767	      parse(basic_format_parse_context<_CharT>& __pc)
   768	      {
   769		auto __first = __pc.begin();
   770		const auto __last = __pc.end();
   771		_Spec<_CharT> __spec{};
   772	
   773		auto __finalize = [this, &__spec] {
   774		  _M_spec = __spec;
   775		};
   776	
   777		auto __finished = [&] {
   778		  if (__first == __last || *__first == '}')
   779		    {
   780		      __finalize();
   781		      return true;
   782		    }
   783		  return false;
   784		};
   785	
   786		if (__finished())
   787		  return __first;
   788	
   789		__first = __spec._M_parse_fill_and_align(__first, __last);
   790		if (__finished())
   791		  return __first;
   792	
   793		__first = __spec._M_parse_width(__first, __last, __pc);
   794		if (__finished())
   795		  return __first;
   796	
   797		__first = __spec._M_parse_precision(__first, __last, __pc);
   798		if (__finished())
   799		  return __first;
   800	
   801		if (*__first == 's')
   802		  ++__first;
   803	#if __cpp_lib_format_ranges
   804		else if (*__first == '?')
   805		  {
   806		    __spec._M_type = _Pres_esc;
   807		    ++__first;
   808		  }
   809	#endif
   810	
   811		if (__finished())
   812		  return __first;
   813	
   814		__format::__failed_to_parse_format_spec();
   815	      }
   816	
   817	      template<typename _Out>
   818		_Out
   819		format(basic_string_view<_CharT> __s,
   820		       basic_format_context<_Out, _CharT>& __fc) const
   821		{
   822		  if (_M_spec._M_type == _Pres_esc)
   823		    {
   824		      // TODO: C++23 escaped string presentation
   825		    }
   826	
   827		  if (_M_spec._M_width_kind == _WP_none
   828			&& _M_spec._M_prec_kind == _WP_none)
   829		    return __format::__write(__fc.out(), __s);
   830	
   831		  size_t __estimated_width = __s.size(); // TODO: Unicode-aware estim.
   832	
   833		  if (_M_spec._M_prec_kind != _WP_none)
   834		    {
   835		      size_t __prec = _M_spec._M_get_precision(__fc);
   836		      if (__estimated_width > __prec)
   837			{
   838			  __s = __s.substr(0, __prec); // TODO: do not split code points
   839			  __estimated_width = __prec;
   840			}
   841		    }
   842	
   843		  return __format::__write_padded_as_spec(__s, __estimated_width,
   844							  __fc, _M_spec);
   845		}
   846	
   847	#if __cpp_lib_format_ranges
   848	      constexpr void
   849	      set_debug_format() noexcept
   850	      { _M_spec._M_type = _Pres_esc; }
   851	#endif
   852	
   853	    private:
   854	      _Spec<_CharT> _M_spec{};
   855	    };
   856	
   857	  template<__char _CharT>
   858	    struct __formatter_int
   859	    {
   860	      // If no presentation type is specified, meaning of "none" depends
   861	      // whether we are formatting an integer or a char or a bool.
   862	      static constexpr _Pres_type _AsInteger = _Pres_d;
   863	      static constexpr _Pres_type _AsBool = _Pres_s;
   864	      static constexpr _Pres_type _AsChar = _Pres_c;
   865	
   866	      constexpr typename basic_format_parse_context<_CharT>::iterator
   867	      _M_do_parse(basic_format_parse_context<_CharT>& __pc, _Pres_type __type)
   868	      {
   869		_Spec<_CharT> __spec{};
   870		__spec._M_type = __type;
   871	
   872		const auto __last = __pc.end();
   873		auto __first = __pc.begin();
   874	
   875		auto __finalize = [this, &__spec] {
   876		  _M_spec = __spec;
   877		};
   878	
   879		auto __finished = [&] {
   880		  if (__first == __last || *__first == '}')
   881		    {
   882		      __finalize();
   883		      return true;
   884		    }
   885		  return false;
   886		};
   887	
   888		if (__finished())
   889		  return __first;
   890	
   891		__first = __spec._M_parse_fill_and_align(__first, __last);
   892		if (__finished())
   893		  return __first;
   894	
   895		__first = __spec._M_parse_sign(__first, __last);
   896		if (__finished())
   897		  return __first;
   898	
   899		__first = __spec._M_parse_alternate_form(__first, __last);
   900		if (__finished())
   901		  return __first;
   902	
   903		__first = __spec._M_parse_zero_fill(__first, __last);
   904		if (__finished())
   905		  return __first;
   906	
   907		__first = __spec._M_parse_width(__first, __last, __pc);
   908		if (__finished())
   909		  return __first;
   910	
   911		__first = __spec._M_parse_locale(__first, __last);
   912		if (__finished())
   913		  return __first;
   914	
   915		switch (*__first)
   916		{
   917		  case 'b':
   918		    __spec._M_type = _Pres_b;
   919		    ++__first;
   920		    break;
   921		  case 'B':
   922		    __spec._M_type = _Pres_B;
   923		    ++__first;
   924		    break;
   925		  case 'c':
   926		    // _GLIBCXX_RESOLVE_LIB_DEFECTS
   927		    // 3586. format should not print bool with 'c'
   928		    if (__type != _AsBool)
   929		      {
   930			__spec._M_type = _Pres_c;
   931			++__first;
   932		      }
   933		    break;
   934		  case 'd':
   935		    __spec._M_type = _Pres_d;
   936		    ++__first;
   937		    break;
   938		  case 'o':
   939		    __spec._M_type = _Pres_o;
   940		    ++__first;
   941		    break;
   942		  case 'x':
   943		    __spec._M_type = _Pres_x;
   944		    ++__first;
   945		    break;
   946		  case 'X':
   947		    __spec._M_type = _Pres_X;
   948		    ++__first;
   949		    break;
   950		  case 's':
   951		    if (__type == _AsBool)
   952		      {
   953			__spec._M_type = _Pres_s; // same value (and meaning) as "none"
   954			++__first;
   955		      }
   956		    break;
   957	#if __cpp_lib_format_ranges
   958		  case '?':
   959		    if (__type == _AsChar)
   960		      {
   961			__spec._M_type = _Pres_esc;
   962			++__first;
   963		      }
   964	#endif
   965		    break;
   966		  }
   967	
   968		if (__finished())
   969		  return __first;
   970	
   971		__format::__failed_to_parse_format_spec();
   972	      }
   973	
   974	      template<typename _Tp>
   975		constexpr typename basic_format_parse_context<_CharT>::iterator
   976		_M_parse(basic_format_parse_context<_CharT>& __pc)
   977		{
   978		  if constexpr (is_same_v<_Tp, bool>)
   979		    {
   980		      auto __end = _M_do_parse(__pc, _AsBool);
   981		      if (_M_spec._M_type == _Pres_s)
   982			if (_M_spec._M_sign || _M_spec._M_alt || _M_spec._M_zero_fill)
   983			  __throw_format_error("format error: format-spec contains "
   984					       "invalid formatting options for "
   985					       "'bool'");
   986		      return __end;
   987		    }
   988		  else if constexpr (__char<_Tp>)
   989		    {
   990		      auto __end = _M_do_parse(__pc, _AsChar);
   991		      if (_M_spec._M_type == _Pres_c || _M_spec._M_type == _Pres_esc)
   992			if (_M_spec._M_sign || _M_spec._M_alt || _M_spec._M_zero_fill
   993			      /* XXX should be invalid? || _M_spec._M_localized */)
   994			  __throw_format_error("format error: format-spec contains "
   995					       "invalid formatting options for "
   996					       "'charT'");
   997		      return __end;
   998		    }
   999		  else
  1000		    return _M_do_parse(__pc, _AsInteger);
  1001		}
  1002	
  1003	      template<typename _Int, typename _Out>
  1004		typename basic_format_context<_Out, _CharT>::iterator
  1005		format(_Int __i, basic_format_context<_Out, _CharT>& __fc) const
  1006		{
  1007		  if (_M_spec._M_type == _Pres_c)
  1008		    return _M_format_character(_S_to_character(__i), __fc);
  1009	
  1010		  char __buf[sizeof(_Int) * __CHAR_BIT__ + 3];
  1011		  to_chars_result __res{};
  1012	
  1013		  string_view __base_prefix;
  1014		  make_unsigned_t<_Int> __u;
  1015		  if (__i < 0)
  1016		    __u = -static_cast<make_unsigned_t<_Int>>(__i);
  1017		  else
  1018		    __u = __i;
  1019	
  1020		  char* __start = __buf + 3;
  1021		  char* const __end = __buf + sizeof(__buf);
  1022		  char* const __start_digits = __start;
  1023	
  1024		  switch (_M_spec._M_type)
  1025		  {
  1026		    case _Pres_b:
  1027		    case _Pres_B:
  1028		      __base_prefix = _M_spec._M_type == _Pres_b ? "0b" : "0B";
  1029		      __res = to_chars(__start, __end, __u, 2);
  1030		      break;
  1031	#if 0
  1032		    case _Pres_c:
  1033		      return _M_format_character(_S_to_character(__i), __fc);
  1034	#endif
  1035		    case _Pres_none:
  1036		      // Should not reach here with _Pres_none for bool or charT, so:
  1037		      [[fallthrough]];
  1038		    case _Pres_d:
  1039		      __res = to_chars(__start, __end, __u, 10);
  1040		      break;
  1041		    case _Pres_o:
  1042		      if (__i != 0)
  1043			__base_prefix = "0";
  1044		      __res = to_chars(__start, __end, __u, 8);
  1045		      break;
  1046		    case _Pres_x:
  1047		    case _Pres_X:
  1048		      __base_prefix = _M_spec._M_type == _Pres_x ? "0x" : "0X";
  1049		      __res = to_chars(__start, __end, __u, 16);
  1050		      if (_M_spec._M_type == _Pres_X)
  1051			for (auto __p = __start; __p != __res.ptr; ++__p)
  1052	#if __has_builtin(__builtin_toupper)
  1053			  *__p = __builtin_toupper(*__p);
  1054	#else
  1055			  *__p = std::toupper(*__p);
  1056	#endif
  1057		      break;
  1058		    default:
  1059		      __builtin_unreachable();
  1060		  }
  1061	
  1062		  if (_M_spec._M_alt && __base_prefix.size())
  1063		    {
  1064		      __start -= __base_prefix.size();
  1065		      __builtin_memcpy(__start, __base_prefix.data(),
  1066				       __base_prefix.size());
  1067		    }
  1068		  __start = __format::__put_sign(__i, _M_spec._M_sign, __start - 1);
  1069	
  1070		  return _M_format_int(string_view(__start, __res.ptr - __start),
  1071				       __start_digits - __start, __fc);
  1072		}
  1073	
  1074	      template<typename _Out>
  1075		typename basic_format_context<_Out, _CharT>::iterator
  1076		format(bool __i, basic_format_context<_Out, _CharT>& __fc) const
  1077		{
  1078		  if (_M_spec._M_type == _Pres_c)
  1079		    return _M_format_character(static_cast<unsigned char>(__i), __fc);
  1080		  if (_M_spec._M_type != _Pres_s)
  1081		    return format(static_cast<unsigned char>(__i), __fc);
  1082	
  1083		  basic_string<_CharT> __s;
  1084		  size_t __est_width;
  1085		  if (_M_spec._M_localized) [[unlikely]]
  1086		    {
  1087		      auto& __np = std::use_facet<numpunct<_CharT>>(__fc.locale());
  1088		      __s = __i ? __np.truename() : __np.falsename();
  1089		      __est_width = __s.size(); // TODO Unicode-aware estimate
  1090		    }
  1091		  else
  1092		    {
  1093		      if constexpr (is_same_v<char, _CharT>)
  1094			__s = __i ? "true" : "false";
  1095		      else
  1096			__s = __i ? L"true" : L"false";
  1097		      __est_width = __s.size();
  1098		    }
  1099	
  1100		  return __format::__write_padded_as_spec(__s, __est_width, __fc,
  1101							  _M_spec);
  1102		}
  1103	
  1104	      template<typename _Out>
  1105		typename basic_format_context<_Out, _CharT>::iterator
  1106		_M_format_character(_CharT __c,
  1107			      basic_format_context<_Out, _CharT>& __fc) const
  1108		{
  1109		  return __format::__write_padded_as_spec({&__c, 1u}, 1, __fc, _M_spec);
  1110		}
  1111	
  1112	      template<typename _Int>
  1113		static _CharT
  1114		_S_to_character(_Int __i)
  1115		{
  1116		  using _Traits = __gnu_cxx::__int_traits<_CharT>;
  1117		  if constexpr (is_signed_v<_Int> == is_signed_v<_CharT>)
  1118		    {
  1119		      if (_Traits::__min <= __i && __i <= _Traits::__max)
  1120			return static_cast<_CharT>(__i);
  1121		    }
  1122		  else if constexpr (is_signed_v<_Int>)
  1123		    {
  1124		      if (__i >= 0 && make_unsigned_t<_Int>(__i) <= _Traits::__max)
  1125			return static_cast<_CharT>(__i);
  1126		    }
  1127		  else if (__i <= make_unsigned_t<_CharT>(_Traits::__max))
  1128		    return static_cast<_CharT>(__i);
  1129		  __throw_format_error("format error: integer not representable as "
  1130				       "character");
  1131		}
  1132	
  1133	      template<typename _Out>
  1134		typename basic_format_context<_Out, _CharT>::iterator
  1135		_M_format_int(string_view __narrow_str, size_t __prefix_len,
  1136			      basic_format_context<_Out, _CharT>& __fc) const
  1137		{
  1138		  size_t __width = _M_spec._M_get_width(__fc);
  1139	
  1140		  _Optional_locale __loc;
  1141	
  1142		  basic_string_view<_CharT> __str;
  1143		  if constexpr (is_same_v<char, _CharT>)
  1144		    __str = __narrow_str;
  1145		  else
  1146		    {
  1147		      __loc = __fc.locale();
  1148		      auto& __ct = use_facet<ctype<_CharT>>(__loc.value());
  1149		      size_t __n = __narrow_str.size();
  1150		      auto __p = (_CharT*)__builtin_alloca(__n * sizeof(_CharT));
  1151		      __ct.widen(__narrow_str.data(), __narrow_str.data() + __n, __p);
  1152		      __str = {__p, __n};
  1153		    }
  1154	
  1155		  if (_M_spec._M_localized)
  1156		    {
  1157		      if constexpr (is_same_v<char, _CharT>)
  1158			__loc = __fc.locale();
  1159		      const auto& __l = __loc.value();
  1160		      if (__l.name() != "C")
  1161			{
  1162			  auto& __np = use_facet<numpunct<_CharT>>(__l);
  1163			  string __grp = __np.grouping();
  1164			  if (!__grp.empty())
  1165			    {
  1166			      size_t __n = __str.size() - __prefix_len;
  1167			      auto __p = (_CharT*)__builtin_alloca(2 * __n
  1168								     * sizeof(_CharT)
  1169								     + __prefix_len);
  1170			      auto __s = __str.data();
  1171			      char_traits<_CharT>::copy(__p, __s, __prefix_len);
  1172			      __s += __prefix_len;
  1173			      auto __end = std::__add_grouping(__p + __prefix_len,
  1174							       __np.thousands_sep(),
  1175							       __grp.data(),
  1176							       __grp.size(),
  1177							       __s, __s + __n);
  1178			      __str = {__p, size_t(__end - __p)};
  1179			    }
  1180			}
  1181		    }
  1182	
  1183		  if (__width <= __str.size())
  1184		    return __format::__write(__fc.out(), __str);
  1185	
  1186		  _CharT __fill_char = _M_spec._M_fill;
  1187		  _Align __align = _M_spec._M_align;
  1188	
  1189		  size_t __nfill = __width - __str.size();
  1190		  auto __out = __fc.out();
  1191		  if (__align == _Align_default)
  1192		    {
  1193		      __align = _Align_right;
  1194		      if (_M_spec._M_zero_fill)
  1195			{
  1196			  __fill_char = _CharT('0');
  1197			  // Write sign and base prefix before zero filling.
  1198			  if (__prefix_len != 0)
  1199			    {
  1200			      __out = __format::__write(std::move(__out),
  1201							__str.substr(0, __prefix_len));
  1202			      __str.remove_prefix(__prefix_len);
  1203			    }
  1204			}
  1205		      else
  1206			__fill_char = _CharT(' ');
  1207		    }
  1208		  return __format::__write_padded(std::move(__out), __str,
  1209						  __align, __nfill, __fill_char);
  1210		}
  1211	
  1212	#if defined __SIZEOF_INT128__ && defined __STRICT_ANSI__
  1213	      template<typename _Tp>
  1214		using make_unsigned_t
  1215		  = typename __conditional_t<(sizeof(_Tp) <= sizeof(long long)),
  1216					     std::make_unsigned<_Tp>,
  1217					     type_identity<unsigned __int128>>::type;
  1218	
  1219	      // std::to_chars is not overloaded for int128 in strict mode.
  1220	      template<typename _Int>
  1221		static to_chars_result
  1222		to_chars(char* __first, char* __last, _Int __value, int __base)
  1223		{ return std::__to_chars_i<_Int>(__first, __last, __value, __base); }
  1224	#endif
  1225	
  1226	      _Spec<_CharT> _M_spec{};
  1227	    };
  1228	
  1229	  // Decide how 128-bit floating-point types should be formatted (or not).
  1230	  // When supported, the typedef __format::__float128_t is the type that
  1231	  // format arguments should be converted to for storage in basic_format_arg.
  1232	  // Define the macro _GLIBCXX_FORMAT_F128 to say they're supported.
  1233	  // _GLIBCXX_FORMAT_F128=1 means __float128, _Float128 etc. will be formatted
  1234	  // by converting them to long double (or __ieee128 for powerpc64le).
  1235	  // _GLIBCXX_FORMAT_F128=2 means basic_format_arg needs to enable explicit
  1236	  // support for _Float128, rather than formatting it as another type.
  1237	#undef _GLIBCXX_FORMAT_F128
  1238	
  1239	#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
  1240	
  1241	  // Format 128-bit floating-point types using __ieee128.
  1242	  using __float128_t = __ieee128;
  1243	# define _GLIBCXX_FORMAT_F128 1
  1244	
  1245	#ifdef __LONG_DOUBLE_IEEE128__
  1246	  // These overloads exist in the library, but are not declared.
  1247	  // Make them available as std::__format::to_chars.
  1248	  to_chars_result
  1249	  to_chars(char*, char*, __ibm128) noexcept
  1250	    __asm("_ZSt8to_charsPcS_e");
  1251	
  1252	  to_chars_result
  1253	  to_chars(char*, char*, __ibm128, chars_format) noexcept
  1254	    __asm("_ZSt8to_charsPcS_eSt12chars_format");
  1255	
  1256	  to_chars_result
  1257	  to_chars(char*, char*, __ibm128, chars_format, int) noexcept
  1258	    __asm("_ZSt8to_charsPcS_eSt12chars_formati");
  1259	#elif __cplusplus == 202002L
  1260	  to_chars_result
  1261	  to_chars(char*, char*, __ieee128) noexcept
  1262	    __asm("_ZSt8to_charsPcS_u9__ieee128");
  1263	
  1264	  to_chars_result
  1265	  to_chars(char*, char*, __ieee128, chars_format) noexcept
  1266	    __asm("_ZSt8to_charsPcS_u9__ieee128St12chars_format");
  1267	
  1268	  to_chars_result
  1269	  to_chars(char*, char*, __ieee128, chars_format, int) noexcept
  1270	    __asm("_ZSt8to_charsPcS_u9__ieee128St12chars_formati");
  1271	#endif
  1272	
  1273	#elif defined _GLIBCXX_LDOUBLE_IS_IEEE_BINARY128
  1274	
  1275	  // Format 128-bit floating-point types using long double.
  1276	  using __float128_t = long double;
  1277	# define _GLIBCXX_FORMAT_F128 1
  1278	
  1279	#elif __FLT128_DIG__ && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
  1280	
  1281	  // Format 128-bit floating-point types using _Float128.
  1282	  using __float128_t = _Float128;
  1283	# define _GLIBCXX_FORMAT_F128 2
  1284	
  1285	# if __cplusplus == 202002L
  1286	  // These overloads exist in the library, but are not declared for C++20.
  1287	  // Make them available as std::__format::to_chars.
  1288	  to_chars_result
  1289	  to_chars(char*, char*, _Float128) noexcept
  1290	#  if _GLIBCXX_INLINE_VERSION
  1291	    __asm("_ZNSt3__88to_charsEPcS0_DF128_");
  1292	#  else
  1293	    __asm("_ZSt8to_charsPcS_DF128_");
  1294	#  endif
  1295	
  1296	  to_chars_result
  1297	  to_chars(char*, char*, _Float128, chars_format) noexcept
  1298	#  if _GLIBCXX_INLINE_VERSION
  1299	    __asm("_ZNSt3__88to_charsEPcS0_DF128_NS_12chars_formatE");
  1300	#  else
  1301	    __asm("_ZSt8to_charsPcS_DF128_St12chars_format");
  1302	#  endif
  1303	
  1304	  to_chars_result
  1305	  to_chars(char*, char*, _Float128, chars_format, int) noexcept
  1306	#  if _GLIBCXX_INLINE_VERSION
  1307	    __asm("_ZNSt3__88to_charsEPcS0_DF128_NS_12chars_formatEi");
  1308	#  else
  1309	    __asm("_ZSt8to_charsPcS_DF128_St12chars_formati");
  1310	#  endif
  1311	# endif
  1312	#endif
  1313	
  1314	  using std::to_chars;
  1315	
  1316	  // We can format a floating-point type iff it is usable with to_chars.
  1317	  template<typename _Tp>
  1318	    concept __formattable_float = requires (_Tp __t, char* __p)
  1319	    { __format::to_chars(__p, __p, __t, chars_format::scientific, 6); };
  1320	
  1321	  template<__char _CharT>
  1322	    struct __formatter_fp
  1323	    {
  1324	      constexpr typename basic_format_parse_context<_CharT>::iterator
  1325	      parse(basic_format_parse_context<_CharT>& __pc)
  1326	      {
  1327		_Spec<_CharT> __spec{};
  1328		const auto __last = __pc.end();
  1329		auto __first = __pc.begin();
  1330	
  1331		auto __finalize = [this, &__spec] {
  1332		  _M_spec = __spec;
  1333		};
  1334	
  1335		auto __finished = [&] {
  1336		  if (__first == __last || *__first == '}')
  1337		    {
  1338		      __finalize();
  1339		      return true;
  1340		    }
  1341		  return false;
  1342		};
  1343	
  1344		if (__finished())
  1345		  return __first;
  1346	
  1347		__first = __spec._M_parse_fill_and_align(__first, __last);
  1348		if (__finished())
  1349		  return __first;
  1350	
  1351		__first = __spec._M_parse_sign(__first, __last);
  1352		if (__finished())
  1353		  return __first;
  1354	
  1355		__first = __spec._M_parse_alternate_form(__first, __last);
  1356		if (__finished())
  1357		  return __first;
  1358	
  1359		__first = __spec._M_parse_zero_fill(__first, __last);
  1360		if (__finished())
  1361		  return __first;
  1362	
  1363		if (__first[0] != '.')
  1364		  {
  1365		    __first = __spec._M_parse_width(__first, __last, __pc);
  1366		    if (__finished())
  1367		      return __first;
  1368		  }
  1369	
  1370		__first = __spec._M_parse_precision(__first, __last, __pc);
  1371		if (__finished())
  1372		  return __first;
  1373	
  1374		__first = __spec._M_parse_locale(__first, __last);
  1375		if (__finished())
  1376		  return __first;
  1377	
  1378		switch (*__first)
  1379		{
  1380		  case 'a':
  1381		    __spec._M_type = _Pres_a;
  1382		    ++__first;
  1383		    break;
  1384		  case 'A':
  1385		    __spec._M_type = _Pres_A;
  1386		    ++__first;
  1387		    break;
  1388		  case 'e':
  1389		    __spec._M_type = _Pres_e;
  1390		    ++__first;
  1391		    break;
  1392		  case 'E':
  1393		    __spec._M_type = _Pres_E;
  1394		    ++__first;
  1395		    break;
  1396		  case 'f':
  1397		    __spec._M_type = _Pres_f;
  1398		    ++__first;
  1399		    break;
  1400		  case 'F':
  1401		    __spec._M_type = _Pres_F;
  1402		    ++__first;
  1403		    break;
  1404		  case 'g':
  1405		    __spec._M_type = _Pres_g;
  1406		    ++__first;
  1407		    break;
  1408		  case 'G':
  1409		    __spec._M_type = _Pres_G;
  1410		    ++__first;
  1411		    break;
  1412		  }
  1413	
  1414		if (__finished())
  1415		  return __first;
  1416	
  1417		__format::__failed_to_parse_format_spec();
  1418	      }
  1419	
  1420	      template<typename _Fp, typename _Out>
  1421		typename basic_format_context<_Out, _CharT>::iterator
  1422		format(_Fp __v, basic_format_context<_Out, _CharT>& __fc) const
  1423		{
  1424		  std::string __dynbuf;
  1425		  char __buf[128];
  1426		  to_chars_result __res{};
  1427	
  1428		  size_t __prec = 6;
  1429		  bool __use_prec = _M_spec._M_prec_kind != _WP_none;
  1430		  if (__use_prec)
  1431		    __prec = _M_spec._M_get_precision(__fc);
  1432	
  1433		  char* __start = __buf + 1; // reserve space for sign
  1434		  char* __end = __buf + sizeof(__buf);
  1435	
  1436		  chars_format __fmt{};
  1437		  bool __upper = false;
  1438		  bool __trailing_zeros = false;
  1439		  char __expc = 'e';
  1440	
  1441		  switch (_M_spec._M_type)
  1442		  {
  1443		    case _Pres_A:
  1444		      __upper = true;
  1445		      __expc = 'P';
  1446		      [[fallthrough]];
  1447		    case _Pres_a:
  1448		      if (_M_spec._M_type != _Pres_A)
  1449			__expc = 'p';
  1450		      __fmt = chars_format::hex;
  1451		      break;
  1452		    case _Pres_E:
  1453		      __upper = true;
  1454		      __expc = 'E';
  1455		      [[fallthrough]];
  1456		    case _Pres_e:
  1457		      __use_prec = true;
  1458		      __fmt = chars_format::scientific;
  1459		      break;
  1460		    case _Pres_F:
  1461		      __upper = true;
  1462		      [[fallthrough]];
  1463		    case _Pres_f:
  1464		      __use_prec = true;
  1465		      __fmt = chars_format::fixed;
  1466		      break;
  1467		    case _Pres_G:
  1468		      __upper = true;
  1469		      __expc = 'E';
  1470		      [[fallthrough]];
  1471		    case _Pres_g:
  1472		      __trailing_zeros = true;
  1473		      __use_prec = true;
  1474		      __fmt = chars_format::general;
  1475		      break;
  1476		    case _Pres_none:
  1477		      if (__use_prec)
  1478			__fmt = chars_format::general;
  1479		      break;
  1480		    default:
  1481		      __builtin_unreachable();
  1482		  }
  1483	
  1484		  // Write value into buffer using std::to_chars.
  1485		  auto __to_chars = [&](char* __b, char* __e) {
  1486		    if (__use_prec)
  1487		      return __format::to_chars(__b, __e, __v, __fmt, __prec);
  1488		    else if (__fmt != chars_format{})
  1489		      return __format::to_chars(__b, __e, __v, __fmt);
  1490		    else
  1491		      return __format::to_chars(__b, __e, __v);
  1492		  };
  1493	
  1494		  // First try using stack buffer.
  1495		  __res = __to_chars(__start, __end);
  1496	
  1497		  if (__builtin_expect(__res.ec == errc::value_too_large, 0))
  1498		    {
  1499		      // If the buffer is too small it's probably because of a large
  1500		      // precision, or a very large value in fixed format.
  1501		      size_t __guess = 8 + __prec;
  1502		      if (__fmt == chars_format::fixed) // +ddd.prec
  1503			{
  1504			  if constexpr (is_same_v<_Fp, float> || is_same_v<_Fp, double>
  1505					  || is_same_v<_Fp, long double>)
  1506			    {
  1507			      // The number of digits to the left of the decimal point
  1508			      // is floor(log10(max(abs(__v),1)))+1
  1509			      int __exp{};
  1510			      if constexpr (is_same_v<_Fp, float>)
  1511				__builtin_frexpf(__v, &__exp);
  1512			      else if constexpr (is_same_v<_Fp, double>)
  1513				__builtin_frexp(__v, &__exp);
  1514			      else if constexpr (is_same_v<_Fp, long double>)
  1515				__builtin_frexpl(__v, &__exp);
  1516			      if (__exp > 0)
  1517				__guess += 1U + __exp * 4004U / 13301U; // log10(2) approx.
  1518			    }
  1519			  else
  1520			    __guess += numeric_limits<_Fp>::max_exponent10;
  1521			}
  1522		      if (__guess <= sizeof(__buf)) [[unlikely]]
  1523			__guess = sizeof(__buf) * 2;
  1524		      __dynbuf.reserve(__guess);
  1525	
  1526		      do
  1527			{
  1528			  auto __overwrite = [&__to_chars, &__res] (char* __p, size_t __n)
  1529			  {
  1530			    __res = __to_chars(__p + 1, __p + __n - 1);
  1531			    return __res.ec == errc{} ? __res.ptr - __p : 0;
  1532			  };
  1533	
  1534			  _S_resize_and_overwrite(__dynbuf, __dynbuf.capacity() * 2,
  1535						  __overwrite);
  1536			  __start = __dynbuf.data() + 1; // reserve space for sign
  1537			  __end = __dynbuf.data() + __dynbuf.size();
  1538			}
  1539		      while (__builtin_expect(__res.ec == errc::value_too_large, 0));
  1540		  }
  1541	
  1542		  // Use uppercase for 'A', 'E', and 'G' formats.
  1543		  if (__upper)
  1544		    {
  1545		      for (char* __p = __start; __p != __res.ptr; ++__p)
  1546			*__p = std::toupper(*__p);
  1547		    }
  1548	
  1549		  bool __have_sign = true;
  1550		  // Add sign for non-negative values.
  1551		  if (!__builtin_signbit(__v))
  1552		    {
  1553		      if (_M_spec._M_sign == _Sign_plus)
  1554			*--__start = '+';
  1555		      else if (_M_spec._M_sign == _Sign_space)
  1556			*--__start = ' ';
  1557		      else
  1558			__have_sign = false;
  1559		    }
  1560	
  1561		  string_view __narrow_str(__start, __res.ptr - __start);
  1562	
  1563		  // Use alternate form. Ensure decimal point is always present,
  1564		  // and add trailing zeros (up to precision) for g and G forms.
  1565		  if (_M_spec._M_alt && __builtin_isfinite(__v))
  1566		    {
  1567		      string_view __s = __narrow_str;
  1568		      size_t __sigfigs; // Number of significant figures.
  1569		      size_t __z = 0;   // Number of trailing zeros to add.
  1570		      size_t __p;       // Position of the exponent character (if any).
  1571		      size_t __d = __s.find('.'); // Position of decimal point.
  1572		      if (__d != __s.npos) // Found decimal point.
  1573			{
  1574			  __p = __s.find(__expc, __d + 1);
  1575			  if (__p == __s.npos)
  1576			    __p = __s.size();
  1577	
  1578			  // If presentation type is g or G we might need to add zeros.
  1579			  if (__trailing_zeros)
  1580			    {
  1581			      // Find number of digits after first significant figure.
  1582			      if (__s[__have_sign] != '0')
  1583				// A string like "D.D" or "-D.DDD"
  1584				__sigfigs = __p - __have_sign - 1;
  1585			      else
  1586				// A string like "0.D" or "-0.0DD".
  1587				// Safe to assume there is a non-zero digit, because
  1588				// otherwise there would be no decimal point.
  1589				__sigfigs = __p - __s.find_first_not_of('0', __d + 1);
  1590			    }
  1591			}
  1592		      else // No decimal point, we need to insert one.
  1593			{
  1594			  __p = __s.find(__expc); // Find the exponent, if present.
  1595			  if (__p == __s.npos)
  1596			    __p = __s.size();
  1597			  __d = __p; // Position where '.' should be inserted.
  1598			  __sigfigs = __d - __have_sign;
  1599			}
  1600	
  1601		      if (__trailing_zeros && __prec != 0)
  1602			{
  1603			  // For g and G presentation types std::to_chars produces
  1604			  // no more than prec significant figures. Insert this many
  1605			  // zeros so the result has exactly prec significant figures.
  1606			  __z = __prec - __sigfigs;
  1607			}
  1608	
  1609		      if (size_t __extras = int(__d == __p) + __z) // How many to add.
  1610			{
  1611			  if (__dynbuf.empty() && __extras <= size_t(__end - __res.ptr))
  1612			    {
  1613			      // The stack buffer is large enough for the result.
  1614			      // Move exponent to make space for extra chars.
  1615			      __builtin_memmove(__start + __p + __extras,
  1616						__start + __p,
  1617						__s.size() - __p);
  1618			      if (__d == __p)
  1619				__start[__p++] = '.';
  1620			      __builtin_memset(__start + __p, '0', __z);
  1621			      __narrow_str = {__s.data(), __s.size() + __extras};
  1622			    }
  1623			  else // Need to switch to the dynamic buffer.
  1624			    {
  1625			      __dynbuf.reserve(__s.size() + __extras);
  1626			      if (__dynbuf.empty())
  1627				{
  1628				  __dynbuf = __s.substr(0, __p);
  1629				  if (__d == __p)
  1630				    __dynbuf += '.';
  1631				  if (__z)
  1632				    __dynbuf.append(__z, '0');
  1633				  __dynbuf.append(__s.substr(__p));
  1634				}
  1635			      else
  1636				{
  1637				  __dynbuf.insert(__p, __extras, '0');
  1638				  if (__d == __p)
  1639				    __dynbuf[__p] = '.';
  1640				}
  1641			      __narrow_str = __dynbuf;
  1642			    }
  1643			}
  1644		    }
  1645	
  1646		  // TODO move everything below to a new member function that
  1647		  // doesn't depend on _Fp type.
  1648	
  1649	
  1650		  _Optional_locale __loc;
  1651		  basic_string<_CharT> __wstr;
  1652		  basic_string_view<_CharT> __str;
  1653		  if constexpr (is_same_v<_CharT, char>)
  1654		    __str = __narrow_str;
  1655		  else
  1656		    {
  1657		      __loc = __fc.locale();
  1658		      auto& __ct = use_facet<ctype<_CharT>>(__loc.value());
  1659		      const char* __data = __narrow_str.data();
  1660		      auto __overwrite = [&__data, &__ct](_CharT* __p, size_t __n)
  1661		      {
  1662			__ct.widen(__data, __data + __n, __p);
  1663			return __n;
  1664		      };
  1665		      _S_resize_and_overwrite(__wstr, __narrow_str.size(), __overwrite);
  1666		      __str = __wstr;
  1667		    }
  1668	
  1669		  if (_M_spec._M_localized && __builtin_isfinite(__v))
  1670		    {
  1671		      if constexpr (is_same_v<char, _CharT>)
  1672			__wstr = _M_localize(__str, __expc, __fc.locale());
  1673		      else
  1674			__wstr = _M_localize(__str, __expc, __loc.value());
  1675		      if (!__wstr.empty())
  1676			__str = __wstr;
  1677		    }
  1678	
  1679		  size_t __width = _M_spec._M_get_width(__fc);
  1680	
  1681		  if (__width <= __str.size())
  1682		    return __format::__write(__fc.out(), __str);
  1683	
  1684		  _CharT __fill_char = _M_spec._M_fill;
  1685		  _Align __align = _M_spec._M_align;
  1686	
  1687		  size_t __nfill = __width - __str.size();
  1688		  auto __out = __fc.out();
  1689		  if (__align == _Align_default)
  1690		    {
  1691		      __align = _Align_right;
  1692		      if (_M_spec._M_zero_fill && __builtin_isfinite(__v))
  1693			{
  1694			  __fill_char = _CharT('0');
  1695			  // Write sign before zero filling.
  1696			  if (!__format::__is_xdigit(__narrow_str[0]))
  1697			    {
  1698			      *__out++ = __str[0];
  1699			      __str.remove_prefix(1);
  1700			    }
  1701			}
  1702		      else
  1703			__fill_char = _CharT(' ');
  1704		    }
  1705		  return __format::__write_padded(std::move(__out), __str,
  1706						  __align, __nfill, __fill_char);
  1707		}
  1708	
  1709	      // Locale-specific format.
  1710	      basic_string<_CharT>
  1711	      _M_localize(basic_string_view<_CharT> __str, char __expc,
  1712			  const locale& __loc) const
  1713	      {
  1714		basic_string<_CharT> __lstr;
  1715	
  1716		if (__loc == locale::classic())
  1717		  return __lstr; // Nothing to do.
  1718	
  1719		const auto& __np = use_facet<numpunct<_CharT>>(__loc);
  1720		const _CharT __point = __np.decimal_point();
  1721		const string __grp = __np.grouping();
  1722	
  1723		_CharT __dot, __exp;
  1724		if constexpr (is_same_v<_CharT, char>)
  1725		  {
  1726		    __dot = '.';
  1727		    __exp = __expc;
  1728		  }
  1729		else
  1730		  {
  1731		    const auto& __ct = use_facet<ctype<_CharT>>(__loc);
  1732		    __dot = __ct.widen('.');
  1733		    __exp = __ct.widen(__expc);
  1734		  }
  1735	
  1736		if (__grp.empty() && __point == __dot)
  1737		  return __lstr; // Locale uses '.' and no grouping.
  1738	
  1739		size_t __d = __str.find(__dot);
  1740		size_t __e = min(__d, __str.find(__exp));
  1741		if (__e == __str.npos)
  1742		  __e = __str.size();
  1743		const size_t __r = __str.size() - __e;
  1744		auto __overwrite = [&](_CharT* __p, size_t) {
  1745		  auto __end = std::__add_grouping(__p, __np.thousands_sep(),
  1746						   __grp.data(), __grp.size(),
  1747						   __str.data(), __str.data() + __e);
  1748		  if (__r)
  1749		    {
  1750		      if (__d != __str.npos)
  1751			{
  1752			  *__end = __point;
  1753			  ++__end;
  1754			  ++__e;
  1755			}
  1756		      if (__r > 1)
  1757			__end += __str.copy(__end, __str.npos, __e);
  1758		    }
  1759		  return (__end - __p);
  1760		};
  1761		_S_resize_and_overwrite(__lstr, __e * 2 + __r, __overwrite);
  1762		return __lstr;
  1763	      }
  1764	
  1765	      template<typename _Ch, typename _Func>
  1766		static void
  1767		_S_resize_and_overwrite(basic_string<_Ch>& __str, size_t __n, _Func __f)
  1768		{
  1769	#if __cpp_lib_string_resize_and_overwrite
  1770		  __str.resize_and_overwrite(__n, __f);
  1771	#else
  1772		  __str.resize(__n);
  1773		  __str.resize(__f(__str.data(), __n));
  1774	#endif
  1775		}
  1776	
  1777	      _Spec<_CharT> _M_spec{};
  1778	    };
  1779	
  1780	} // namespace __format
  1781	/// @endcond
  1782	
  1783	  // Format a character.
  1784	  template<__format::__char _CharT>
  1785	    struct formatter<_CharT, _CharT>
  1786	    {
  1787	      formatter() = default;
  1788	
  1789	      constexpr typename basic_format_parse_context<_CharT>::iterator
  1790	      parse(basic_format_parse_context<_CharT>& __pc)
  1791	      {
  1792		return _M_f.template _M_parse<_CharT>(__pc);
  1793	      }
  1794	
  1795	      template<typename _Out>
  1796		typename basic_format_context<_Out, _CharT>::iterator
  1797		format(_CharT __u, basic_format_context<_Out, _CharT>& __fc) const
  1798		{
  1799		  if (_M_f._M_spec._M_type == __format::_Pres_none
  1800		      || _M_f._M_spec._M_type == __format::_Pres_c)
  1801		    return _M_f._M_format_character(__u, __fc);
  1802		  else if (_M_f._M_spec._M_type == __format::_Pres_esc)
  1803		    {
  1804		      // TODO
  1805		      return __fc.out();
  1806		    }
  1807		  else
  1808		    return _M_f.format(static_cast<make_unsigned_t<_CharT>>(__u), __fc);
  1809		}
  1810	
  1811	#if __cpp_lib_format_ranges
  1812	      constexpr void
  1813	      set_debug_format() noexcept
  1814	      { _M_f._M_spec._M_type = __format::_Pres_esc; }
  1815	#endif
  1816	
  1817	    private:
  1818	      __format::__formatter_int<_CharT> _M_f;
  1819	    };
  1820	
  1821	  // Format a char value for wide character output.
  1822	  template<>
  1823	    struct formatter<char, wchar_t>
  1824	    {
  1825	      formatter() = default;
  1826	
  1827	      constexpr typename basic_format_parse_context<wchar_t>::iterator
  1828	      parse(basic_format_parse_context<wchar_t>& __pc)
  1829	      {
  1830		return _M_f._M_parse<char>(__pc);
  1831	      }
  1832	
  1833	      template<typename _Out>
  1834		typename basic_format_context<_Out, wchar_t>::iterator
  1835		format(char __u, basic_format_context<_Out, wchar_t>& __fc) const
  1836		{
  1837		  if (_M_f._M_spec._M_type == __format::_Pres_none
  1838		      || _M_f._M_spec._M_type == __format::_Pres_c)
  1839		    return _M_f._M_format_character(__u, __fc);
  1840		  else if (_M_f._M_spec._M_type == __format::_Pres_esc)
  1841		    {
  1842		      // TODO
  1843		      return __fc.out();
  1844		    }
  1845		  else
  1846		    return _M_f.format(static_cast<unsigned char>(__u), __fc);
  1847		}
  1848	
  1849	#if __cpp_lib_format_ranges
  1850	      constexpr void
  1851	      set_debug_format() noexcept
  1852	      { _M_f._M_spec._M_type = __format::_Pres_esc; }
  1853	#endif
  1854	
  1855	    private:
  1856	      __format::__formatter_int<wchar_t> _M_f;
  1857	    };
  1858	
  1859	  /** Format a string.
  1860	   * @{
  1861	   */
  1862	  template<__format::__char _CharT>
  1863	    struct formatter<_CharT*, _CharT>
  1864	    {
  1865	      formatter() = default;
  1866	
  1867	      [[__gnu__::__always_inline__]]
  1868	      constexpr typename basic_format_parse_context<_CharT>::iterator
  1869	      parse(basic_format_parse_context<_CharT>& __pc)
  1870	      { return _M_f.parse(__pc); }
  1871	
  1872	      template<typename _Out>
  1873		[[__gnu__::__nonnull__]]
  1874		typename basic_format_context<_Out, _CharT>::iterator
  1875		format(_CharT* __u, basic_format_context<_Out, _CharT>& __fc) const
  1876		{ return _M_f.format(__u, __fc); }
  1877	
  1878	#if __cpp_lib_format_ranges
  1879	      constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
  1880	#endif
  1881	
  1882	    private:
  1883	      __format::__formatter_str<_CharT> _M_f;
  1884	    };
  1885	
  1886	  template<__format::__char _CharT>
  1887	    struct formatter<const _CharT*, _CharT>
  1888	    {
  1889	      formatter() = default;
  1890	
  1891	      [[__gnu__::__always_inline__]]
  1892	      constexpr typename basic_format_parse_context<_CharT>::iterator
  1893	      parse(basic_format_parse_context<_CharT>& __pc)
  1894	      { return _M_f.parse(__pc); }
  1895	
  1896	      template<typename _Out>
  1897		[[__gnu__::__nonnull__]]
  1898		typename basic_format_context<_Out, _CharT>::iterator
  1899		format(const _CharT* __u,
  1900		       basic_format_context<_Out, _CharT>& __fc) const
  1901		{ return _M_f.format(__u, __fc); }
  1902	
  1903	#if __cpp_lib_format_ranges
  1904	      constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
  1905	#endif
  1906	
  1907	    private:
  1908	      __format::__formatter_str<_CharT> _M_f;
  1909	    };
  1910	
  1911	  template<__format::__char _CharT, size_t _Nm>
  1912	    struct formatter<_CharT[_Nm], _CharT>
  1913	    {
  1914	      formatter() = default;
  1915	
  1916	      [[__gnu__::__always_inline__]]
  1917	      constexpr typename basic_format_parse_context<_CharT>::iterator
  1918	      parse(basic_format_parse_context<_CharT>& __pc)
  1919	      { return _M_f.parse(__pc); }
  1920	
  1921	      template<typename _Out>
  1922		typename basic_format_context<_Out, _CharT>::iterator
  1923		format(const _CharT (&__u)[_Nm],
  1924		       basic_format_context<_Out, _CharT>& __fc) const
  1925		{ return _M_f.format({__u, _Nm}, __fc); }
  1926	
  1927	#if __cpp_lib_format_ranges
  1928	      constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
  1929	#endif
  1930	
  1931	    private:
  1932	      __format::__formatter_str<_CharT> _M_f;
  1933	    };
  1934	
  1935	  template<typename _Traits, typename _Alloc>
  1936	    struct formatter<basic_string<char, _Traits, _Alloc>, char>
  1937	    {
  1938	      formatter() = default;
  1939	
  1940	      [[__gnu__::__always_inline__]]
  1941	      constexpr typename basic_format_parse_context<char>::iterator
  1942	      parse(basic_format_parse_context<char>& __pc)
  1943	      { return _M_f.parse(__pc); }
  1944	
  1945	      template<typename _Out>
  1946		typename basic_format_context<_Out, char>::iterator
  1947		format(const basic_string<char, _Traits, _Alloc>& __u,
  1948		       basic_format_context<_Out, char>& __fc) const
  1949		{ return _M_f.format(__u, __fc); }
  1950	
  1951	#if __cpp_lib_format_ranges
  1952	      constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
  1953	#endif
  1954	
  1955	    private:
  1956	      __format::__formatter_str<char> _M_f;
  1957	    };
  1958	
  1959	  template<typename _Traits, typename _Alloc>
  1960	    struct formatter<basic_string<wchar_t, _Traits, _Alloc>, wchar_t>
  1961	    {
  1962	      formatter() = default;
  1963	
  1964	      [[__gnu__::__always_inline__]]
  1965	      constexpr typename basic_format_parse_context<wchar_t>::iterator
  1966	      parse(basic_format_parse_context<wchar_t>& __pc)
  1967	      { return _M_f.parse(__pc); }
  1968	
  1969	      template<typename _Out>
  1970		typename basic_format_context<_Out, wchar_t>::iterator
  1971		format(const basic_string<wchar_t, _Traits, _Alloc>& __u,
  1972		       basic_format_context<_Out, wchar_t>& __fc) const
  1973		{ return _M_f.format(__u, __fc); }
  1974	
  1975	#if __cpp_lib_format_ranges
  1976	      constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
  1977	#endif
  1978	
  1979	    private:
  1980	      __format::__formatter_str<wchar_t> _M_f;
  1981	    };
  1982	
  1983	  template<typename _Traits>
  1984	    struct formatter<basic_string_view<char, _Traits>, char>
  1985	    {
  1986	      formatter() = default;
  1987	
  1988	      [[__gnu__::__always_inline__]]
  1989	      constexpr typename basic_format_parse_context<char>::iterator
  1990	      parse(basic_format_parse_context<char>& __pc)
  1991	      { return _M_f.parse(__pc); }
  1992	
  1993	      template<typename _Out>
  1994		typename basic_format_context<_Out, char>::iterator
  1995		format(basic_string_view<char, _Traits> __u,
  1996		       basic_format_context<_Out, char>& __fc) const
  1997		{ return _M_f.format(__u, __fc); }
  1998	
  1999	#if __cpp_lib_format_ranges
  2000	      constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
  2001	#endif
  2002	
  2003	    private:
  2004	      __format::__formatter_str<char> _M_f;
  2005	    };
  2006	
  2007	  template<typename _Traits>
  2008	    struct formatter<basic_string_view<wchar_t, _Traits>, wchar_t>
  2009	    {
  2010	      formatter() = default;
  2011	
  2012	      [[__gnu__::__always_inline__]]
  2013	      constexpr typename basic_format_parse_context<wchar_t>::iterator
  2014	      parse(basic_format_parse_context<wchar_t>& __pc)
  2015	      { return _M_f.parse(__pc); }
  2016	
  2017	      template<typename _Out>
  2018		typename basic_format_context<_Out, wchar_t>::iterator
  2019		format(basic_string_view<wchar_t, _Traits> __u,
  2020		       basic_format_context<_Out, wchar_t>& __fc) const
  2021		{ return _M_f.format(__u, __fc); }
  2022	
  2023	#if __cpp_lib_format_ranges
  2024	      constexpr void set_debug_format() noexcept { _M_f.set_debug_format(); }
  2025	#endif
  2026	
  2027	    private:
  2028	      __format::__formatter_str<wchar_t> _M_f;
  2029	    };
  2030	  /// @}
  2031	
  2032	  /// Format an integer.
  2033	  template<integral _Tp, __format::__char _CharT>
  2034	    requires (!__is_one_of<_Tp, char, wchar_t, char16_t, char32_t>::value)
  2035	    struct formatter<_Tp, _CharT>
  2036	    {
  2037	      formatter() = default;
  2038	
  2039	      [[__gnu__::__always_inline__]]
  2040	      constexpr typename basic_format_parse_context<_CharT>::iterator
  2041	      parse(basic_format_parse_context<_CharT>& __pc)
  2042	      {
  2043		return _M_f.template _M_parse<_Tp>(__pc);
  2044	      }
  2045	
  2046	      template<typename _Out>
  2047		typename basic_format_context<_Out, _CharT>::iterator
  2048		format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
  2049		{ return _M_f.format(__u, __fc); }
  2050	
  2051	    private:
  2052	      __format::__formatter_int<_CharT> _M_f;
  2053	    };
  2054	
  2055	#if defined __SIZEOF_INT128__ && defined __STRICT_ANSI__
  2056	  template<typename _Tp, __format::__char _CharT>
  2057	    requires (__is_one_of<_Tp, __int128, unsigned __int128>::value)
  2058	    struct formatter<_Tp, _CharT>
  2059	    {
  2060	      formatter() = default;
  2061	
  2062	      [[__gnu__::__always_inline__]]
  2063	      constexpr typename basic_format_parse_context<_CharT>::iterator
  2064	      parse(basic_format_parse_context<_CharT>& __pc)
  2065	      {
  2066		return _M_f.template _M_parse<_Tp>(__pc);
  2067	      }
  2068	
  2069	      template<typename _Out>
  2070		typename basic_format_context<_Out, _CharT>::iterator
  2071		format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
  2072		{ return _M_f.format(__u, __fc); }
  2073	
  2074	    private:
  2075	      __format::__formatter_int<_CharT> _M_f;
  2076	    };
  2077	#endif
  2078	
  2079	  /// Format a floating-point value.
  2080	  template<__format::__formattable_float _Tp, __format::__char _CharT>
  2081	    struct formatter<_Tp, _CharT>
  2082	    {
  2083	      formatter() = default;
  2084	
  2085	      [[__gnu__::__always_inline__]]
  2086	      constexpr typename basic_format_parse_context<_CharT>::iterator
  2087	      parse(basic_format_parse_context<_CharT>& __pc)
  2088	      { return _M_f.parse(__pc); }
  2089	
  2090	      template<typename _Out>
  2091		typename basic_format_context<_Out, _CharT>::iterator
  2092		format(_Tp __u, basic_format_context<_Out, _CharT>& __fc) const
  2093		{ return _M_f.format(__u, __fc); }
  2094	
  2095	    private:
  2096	      __format::__formatter_fp<_CharT> _M_f;
  2097	    };
  2098	
  2099	  /** Format a pointer.
  2100	   * @{
  2101	   */
  2102	  template<__format::__char _CharT>
  2103	    struct formatter<const void*, _CharT>
  2104	    {
  2105	      formatter() = default;
  2106	
  2107	      constexpr typename basic_format_parse_context<_CharT>::iterator
  2108	      parse(basic_format_parse_context<_CharT>& __pc)
  2109	      {
  2110		__format::_Spec<_CharT> __spec{};
  2111		const auto __last = __pc.end();
  2112		auto __first = __pc.begin();
  2113	
  2114		auto __finalize = [this, &__spec] {
  2115		  _M_spec = __spec;
  2116		};
  2117	
  2118		auto __finished = [&] {
  2119		  if (__first == __last || *__first == '}')
  2120		    {
  2121		      __finalize();
  2122		      return true;
  2123		    }
  2124		  return false;
  2125		};
  2126	
  2127		if (__finished())
  2128		  return __first;
  2129	
  2130		__first = __spec._M_parse_fill_and_align(__first, __last);
  2131		if (__finished())
  2132		  return __first;
  2133	
  2134	// _GLIBCXX_RESOLVE_LIB_DEFECTS
  2135	// P2510R3 Formatting pointers
  2136	#if __cplusplus > 202302L || ! defined __STRICT_ANSI__
  2137	#define _GLIBCXX_P2518R3 1
  2138	#else
  2139	#define _GLIBCXX_P2518R3 0
  2140	#endif
  2141	
  2142	#if _GLIBCXX_P2518R3
  2143		__first = __spec._M_parse_zero_fill(__first, __last);
  2144		if (__finished())
  2145		  return __first;
  2146	#endif
  2147	
  2148		__first = __spec._M_parse_width(__first, __last, __pc);
  2149	
  2150		if (__first != __last)
  2151		  {
  2152		    if (*__first == 'p')
  2153		      ++__first;
  2154	#if _GLIBCXX_P2518R3
  2155		    else if (*__first == 'P')
  2156		    {
  2157		      // _GLIBCXX_RESOLVE_LIB_DEFECTS
  2158		      // P2510R3 Formatting pointers
  2159		      __spec._M_type = __format::_Pres_P;
  2160		      ++__first;
  2161		    }
  2162	#endif
  2163		  }
  2164	
  2165		if (__finished())
  2166		  return __first;
  2167	
  2168		__format::__failed_to_parse_format_spec();
  2169	      }
  2170	
  2171	      template<typename _Out>
  2172		typename basic_format_context<_Out, _CharT>::iterator
  2173		format(const void* __v, basic_format_context<_Out, _CharT>& __fc) const
  2174		{
  2175		  auto __u = reinterpret_cast<__UINTPTR_TYPE__>(__v);
  2176		  char __buf[2 + sizeof(__v) * 2];
  2177		  auto [__ptr, __ec] = std::to_chars(__buf + 2, std::end(__buf),
  2178						     __u, 16);
  2179		  int __n = __ptr - __buf;
  2180		  __buf[0] = '0';
  2181		  __buf[1] = 'x';
  2182	#if _GLIBCXX_P2518R3
  2183		  if (_M_spec._M_type == __format::_Pres_P)
  2184		    {
  2185		      __buf[1] = 'X';
  2186		      for (auto __p = __buf + 2; __p != __ptr; ++__p)
  2187	#if __has_builtin(__builtin_toupper)
  2188			*__p = __builtin_toupper(*__p);
  2189	#else
  2190			*__p = std::toupper(*__p);
  2191	#endif
  2192		    }
  2193	#endif
  2194	
  2195		  basic_string_view<_CharT> __str;
  2196		  if constexpr (is_same_v<_CharT, char>)
  2197		    __str = string_view(__buf, __n);
  2198		  else
  2199		    {
  2200		      const std::locale& __loc = __fc.locale();
  2201		      auto& __ct = use_facet<ctype<_CharT>>(__loc);
  2202		      auto __p = (_CharT*)__builtin_alloca(__n * sizeof(_CharT));
  2203		      __ct.widen(__buf, __buf + __n, __p);
  2204		      __str = wstring_view(__p, __n);
  2205		    }
  2206	
  2207	#if _GLIBCXX_P2518R3
  2208		  if (_M_spec._M_zero_fill)
  2209		    {
  2210		      size_t __width = _M_spec._M_get_width(__fc);
  2211		      if (__width <= __str.size())
  2212			return __format::__write(__fc.out(), __str);
  2213	
  2214		      auto __out = __fc.out();
  2215		      // Write "0x" or "0X" prefix before zero-filling.
  2216		      __out = __format::__write(std::move(__out), __str.substr(0, 2));
  2217		      __str.remove_prefix(2);
  2218		      size_t __nfill = __width - __n;
  2219		      return __format::__write_padded(std::move(__out), __str,
  2220						      __format::_Align_right,
  2221						      __nfill, _CharT('0'));
  2222		    }
  2223	#endif
  2224	
  2225		  return __format::__write_padded_as_spec(__str, __n, __fc, _M_spec,
  2226							  __format::_Align_right);
  2227		}
  2228	
  2229	    private:
  2230	      __format::_Spec<_CharT> _M_spec{};
  2231	    };
  2232	
  2233	  template<__format::__char _CharT>
  2234	    struct formatter<void*, _CharT>
  2235	    {
  2236	      formatter() = default;
  2237	
  2238	      [[__gnu__::__always_inline__]]
  2239	      constexpr typename basic_format_parse_context<_CharT>::iterator
  2240	      parse(basic_format_parse_context<_CharT>& __pc)
  2241	      { return _M_f.parse(__pc); }
  2242	
  2243	      template<typename _Out>
  2244		typename basic_format_context<_Out, _CharT>::iterator
  2245		format(void* __v, basic_format_context<_Out, _CharT>& __fc) const
  2246		{ return _M_f.format(__v, __fc); }
  2247	
  2248	    private:
  2249	      formatter<const void*, _CharT> _M_f;
  2250	    };
  2251	
  2252	  template<__format::__char _CharT>
  2253	    struct formatter<nullptr_t, _CharT>
  2254	    {
  2255	      formatter() = default;
  2256	
  2257	      [[__gnu__::__always_inline__]]
  2258	      constexpr typename basic_format_parse_context<_CharT>::iterator
  2259	      parse(basic_format_parse_context<_CharT>& __pc)
  2260	      { return _M_f.parse(__pc); }
  2261	
  2262	      template<typename _Out>
  2263		typename basic_format_context<_Out, _CharT>::iterator
  2264		format(nullptr_t, basic_format_context<_Out, _CharT>& __fc) const
  2265		{ return _M_f.format(nullptr, __fc); }
  2266	
  2267	    private:
  2268	      formatter<const void*, _CharT> _M_f;
  2269	    };
  2270	  /// @}
  2271	
  2272	
  2273	/// @cond undocumented
  2274	namespace __format
  2275	{
  2276	  template<typename _Tp, typename _Context,
  2277		   typename _Formatter
  2278		     = typename _Context::template formatter_type<remove_const_t<_Tp>>,
  2279		   typename _ParseContext
  2280		     = basic_format_parse_context<typename _Context::char_type>>
  2281	    concept __parsable_with
  2282	      = semiregular<_Formatter>
  2283		  && requires (_Formatter __f, _ParseContext __pc)
  2284	    {
  2285	      { __f.parse(__pc) } -> same_as<typename _ParseContext::iterator>;
  2286	    };
  2287	
  2288	  template<typename _Tp, typename _Context,
  2289		   typename _Formatter
  2290		     = typename _Context::template formatter_type<remove_const_t<_Tp>>,
  2291		   typename _ParseContext
  2292		     = basic_format_parse_context<typename _Context::char_type>>
  2293	    concept __formattable_with
  2294	      = semiregular<_Formatter>
  2295		  && requires (const _Formatter __cf, _Tp&& __t, _Context __fc)
  2296	    {
  2297	      { __cf.format(__t, __fc) } -> same_as<typename _Context::iterator>;
  2298	    };
  2299	
  2300	  // An unspecified output iterator type used in the `formattable` concept.
  2301	  template<typename _CharT>
  2302	    using _Iter_for = back_insert_iterator<basic_string<_CharT>>;
  2303	
  2304	  template<typename _Tp, typename _CharT,
  2305		   typename _Context = basic_format_context<_Iter_for<_CharT>, _CharT>>
  2306	    concept __formattable_impl
  2307	      = __parsable_with<_Tp, _Context> && __formattable_with<_Tp, _Context>;
  2308	
  2309	} // namespace __format
  2310	/// @endcond
  2311	
  2312	#if __cplusplus > 202002L
  2313	  // [format.formattable], concept formattable
  2314	  template<typename _Tp, typename _CharT>
  2315	    concept formattable
  2316	      = __format::__formattable_impl<remove_reference_t<_Tp>, _CharT>;
  2317	#endif
  2318	
  2319	#if __cpp_lib_format_ranges
  2320	  /// @cond undocumented
  2321	namespace __format
  2322	{
  2323	  template<typename _Rg, typename _CharT>
  2324	    concept __const_formattable_range
  2325	      = ranges::input_range<const _Rg>
  2326		  && formattable<ranges::range_reference_t<const _Rg>, _CharT>;
  2327	
  2328	  template<typename _Rg, typename _CharT>
  2329	    using __maybe_const_range
  2330	      = conditional_t<__const_formattable_range<_Rg, _CharT>, const _Rg, _Rg>;
  2331	} // namespace __format
  2332	  /// @endcond
  2333	#endif // format_ranges
  2334	
  2335	  /// An iterator after the last character written, and the number of
  2336	  /// characters that would have been written.
  2337	  template<typename _Out>
  2338	    struct format_to_n_result
  2339	    {
  2340	      _Out out;
  2341	      iter_difference_t<_Out> size;
  2342	    };
  2343	
  2344	/// @cond undocumented
  2345	namespace __format
  2346	{
  2347	  template<typename _CharT>
  2348	    class _Sink_iter
  2349	    {
  2350	      _Sink<_CharT>* _M_sink = nullptr;
  2351	
  2352	    public:
  2353	      using iterator_category = output_iterator_tag;
  2354	      using value_type = void;
  2355	      using difference_type = ptrdiff_t;
  2356	      using pointer = void;
  2357	      using reference = void;
  2358	
  2359	      _Sink_iter() = default;
  2360	      _Sink_iter(const _Sink_iter&) = default;
  2361	      _Sink_iter& operator=(const _Sink_iter&) = default;
  2362	
  2363	      [[__gnu__::__always_inline__]]
  2364	      explicit constexpr
  2365	      _Sink_iter(_Sink<_CharT>& __sink) : _M_sink(std::addressof(__sink)) { }
  2366	
  2367	      [[__gnu__::__always_inline__]]
  2368	      constexpr _Sink_iter&
  2369	      operator=(_CharT __c)
  2370	      {
  2371		_M_sink->_M_write(__c);
  2372		return *this;
  2373	      }
  2374	
  2375	      [[__gnu__::__always_inline__]]
  2376	      constexpr _Sink_iter&
  2377	      operator=(basic_string_view<_CharT> __s)
  2378	      {
  2379		_M_sink->_M_write(__s);
  2380		return *this;
  2381	      }
  2382	
  2383	      [[__gnu__::__always_inline__]]
  2384	      constexpr _Sink_iter&
  2385	      operator*() { return *this; }
  2386	
  2387	      [[__gnu__::__always_inline__]]
  2388	      constexpr _Sink_iter&
  2389	      operator++() { return *this; }
  2390	
  2391	      [[__gnu__::__always_inline__]]
  2392	      constexpr _Sink_iter
  2393	      operator++(int) { return *this; }
  2394	    };
  2395	
  2396	  // Abstract base class for type-erased character sinks.
  2397	  // All formatting and output is done via this type's iterator,
  2398	  // to reduce the number of different template instantiations.
  2399	  template<typename _CharT>
  2400	    class _Sink
  2401	    {
  2402	      friend class _Sink_iter<_CharT>;
  2403	
  2404	      span<_CharT> _M_span;
  2405	      typename span<_CharT>::iterator _M_next;
  2406	
  2407	      // Called when the span is full, to make more space available.
  2408	      // Precondition: _M_next != _M_span.begin()
  2409	      // Postcondition: _M_next != _M_span.end()
  2410	      virtual void _M_overflow() = 0;
  2411	
  2412	    protected:
  2413	      // Precondition: __span.size() != 0
  2414	      [[__gnu__::__always_inline__]]
  2415	      explicit constexpr
  2416	      _Sink(span<_CharT> __span) noexcept
  2417	      : _M_span(__span), _M_next(__span.begin())
  2418	      { }
  2419	
  2420	      // The portion of the span that has been written to.
  2421	      [[__gnu__::__always_inline__]]
  2422	      span<_CharT>
  2423	      _M_used() const noexcept
  2424	      { return _M_span.first(_M_next - _M_span.begin()); }
  2425	
  2426	      // The portion of the span that has not been written to.
  2427	      [[__gnu__::__always_inline__]]
  2428	      constexpr span<_CharT>
  2429	      _M_unused() const noexcept
  2430	      { return _M_span.subspan(_M_next - _M_span.begin()); }
  2431	
  2432	      // Use the start of the span as the next write position.
  2433	      [[__gnu__::__always_inline__]]
  2434	      constexpr void
  2435	      _M_rewind() noexcept
  2436	      { _M_next = _M_span.begin(); }
  2437	
  2438	      // Replace the current output range.
  2439	      void
  2440	      _M_reset(span<_CharT> __s, size_t __pos = 0) noexcept
  2441	      {
  2442		_M_span = __s;
  2443		_M_next = __s.begin() + __pos;
  2444	      }
  2445	
  2446	      // Called by the iterator for *it++ = c
  2447	      constexpr void
  2448	      _M_write(_CharT __c)
  2449	      {
  2450		*_M_next++ = __c;
  2451		if (_M_next - _M_span.begin() == std::ssize(_M_span)) [[unlikely]]
  2452		  _M_overflow();
  2453	      }
  2454	
  2455	      constexpr void
  2456	      _M_write(basic_string_view<_CharT> __s)
  2457	      {
  2458		span __to = _M_unused();
  2459		while (__to.size() <= __s.size())
  2460		  {
  2461		    __s.copy(__to.data(), __to.size());
  2462		    _M_next += __to.size();
  2463		    __s.remove_prefix(__to.size());
  2464		    _M_overflow();
  2465		    __to = _M_unused();
  2466		  }
  2467		if (__s.size())
  2468		  {
  2469		    __s.copy(__to.data(), __s.size());
  2470		    _M_next += __s.size();
  2471		  }
  2472	      }
  2473	
  2474	    public:
  2475	      _Sink(const _Sink&) = delete;
  2476	      _Sink& operator=(const _Sink&) = delete;
  2477	
  2478	      [[__gnu__::__always_inline__]]
  2479	      constexpr _Sink_iter<_CharT>
  2480	      out() noexcept
  2481	      { return _Sink_iter<_CharT>(*this); }
  2482	    };
  2483	
  2484	  // A sink with an internal buffer. This is used to implement concrete sinks.
  2485	  template<typename _CharT>
  2486	    class _Buf_sink : public _Sink<_CharT>
  2487	    {
  2488	    protected:
  2489	      _CharT _M_buf[32 * sizeof(void*) / sizeof(_CharT)];
  2490	
  2491	      [[__gnu__::__always_inline__]]
  2492	      constexpr
  2493	      _Buf_sink() noexcept
  2494	      : _Sink<_CharT>(_M_buf)
  2495	      { }
  2496	    };
  2497	
  2498	  // A sink that fills a sequence (e.g. std::string, std::vector, std::deque).
  2499	  // Writes to a buffer then appends that to the sequence when it fills up.
  2500	  template<typename _Seq>
  2501	    class _Seq_sink final : public _Buf_sink<typename _Seq::value_type>
  2502	    {
  2503	      using _CharT = typename _Seq::value_type;
  2504	
  2505	      _Seq _M_seq;
  2506	
  2507	      // Transfer buffer contents to the sequence, so buffer can be refilled.
  2508	      void
  2509	      _M_overflow() override
  2510	      {
  2511		auto __s = this->_M_used();
  2512		if (__s.empty())
  2513		  return;
  2514		if constexpr (__is_specialization_of<_Seq, basic_string>)
  2515		  _M_seq.append(__s.data(), __s.size());
  2516		else
  2517		  _M_seq.insert(_M_seq.end(), __s.begin(), __s.end());
  2518		this->_M_rewind();
  2519	      }
  2520	
  2521	    public:
  2522	      // TODO: for SSO string, use SSO buffer as initial span, then switch
  2523	      // to _M_buf if it overflows? Or even do that for all unused capacity?
  2524	
  2525	      [[__gnu__::__always_inline__]]
  2526	      _Seq_sink() noexcept(is_nothrow_default_constructible_v<_Seq>)
  2527	      { }
  2528	
  2529	      _Seq_sink(_Seq&& __s) noexcept(is_nothrow_move_constructible_v<_Seq>)
  2530	      : _M_seq(std::move(__s))
  2531	      { }
  2532	
  2533	      using _Sink<_CharT>::out;
  2534	
  2535	      _Seq
  2536	      get() &&
  2537	      {
  2538		if (this->_M_used().size() != 0)
  2539		  _Seq_sink::_M_overflow();
  2540		return std::move(_M_seq);
  2541	      }
  2542	    };
  2543	
  2544	  template<typename _CharT, typename _Alloc = allocator<_CharT>>
  2545	    using _Str_sink
  2546	      = _Seq_sink<basic_string<_CharT, char_traits<_CharT>, _Alloc>>;
  2547	
  2548	  // template<typename _CharT, typename _Alloc = allocator<_CharT>>
  2549	    // using _Vec_sink = _Seq_sink<vector<_CharT, _Alloc>>;
  2550	
  2551	  // A sink that writes to an output iterator.
  2552	  // Writes to a fixed-size buffer and then flushes to the output iterator
  2553	  // when the buffer fills up.
  2554	  template<typename _CharT, typename _OutIter>
  2555	    class _Iter_sink : public _Buf_sink<_CharT>
  2556	    {
  2557	      _OutIter _M_out;
  2558	      iter_difference_t<_OutIter> _M_max;
  2559	
  2560	    protected:
  2561	      size_t _M_count = 0;
  2562	
  2563	      void
  2564	      _M_overflow() override
  2565	      {
  2566		auto __s = this->_M_used();
  2567		if (_M_max < 0) // No maximum.
  2568		  _M_out = ranges::copy(__s, std::move(_M_out)).out;
  2569		else if (_M_count < static_cast<size_t>(_M_max))
  2570		  {
  2571		    auto __max = _M_max - _M_count;
  2572		    span<_CharT> __first;
  2573		    if (__max < __s.size())
  2574		      __first = __s.first(static_cast<size_t>(__max));
  2575		    else
  2576		      __first = __s;
  2577		    _M_out = ranges::copy(__first, std::move(_M_out)).out;
  2578		  }
  2579		this->_M_rewind();
  2580		_M_count += __s.size();
  2581	      }
  2582	
  2583	    public:
  2584	      [[__gnu__::__always_inline__]]
  2585	      explicit
  2586	      _Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __max = -1)
  2587	      : _M_out(std::move(__out)), _M_max(__max)
  2588	      { }
  2589	
  2590	      using _Sink<_CharT>::out;
  2591	
  2592	      format_to_n_result<_OutIter>
  2593	      _M_finish() &&
  2594	      {
  2595		if (this->_M_used().size() != 0)
  2596		  _Iter_sink::_M_overflow();
  2597		iter_difference_t<_OutIter> __count(_M_count);
  2598		return { std::move(_M_out), __count };
  2599	      }
  2600	    };
  2601	
  2602	  // Partial specialization for contiguous iterators.
  2603	  // No buffer is used, characters are written straight to the iterator.
  2604	  // We do not know the size of the output range, so the span size just grows
  2605	  // as needed. The end of the span might be an invalid pointer outside the
  2606	  // valid range, but we never actually call _M_span.end(). This class does
  2607	  // not introduce any invalid pointer arithmetic or overflows that would not
  2608	  // have happened anyway.
  2609	  template<typename _CharT, contiguous_iterator _OutIter>
  2610	    requires same_as<iter_value_t<_OutIter>, _CharT>
  2611	    class _Iter_sink<_CharT, _OutIter> : public _Sink<_CharT>
  2612	    {
  2613	      _OutIter _M_first;
  2614	      iter_difference_t<_OutIter> _M_max = -1;
  2615	    protected:
  2616	      size_t _M_count = 0;
  2617	    private:
  2618	      _CharT _M_buf[64]; // Write here after outputting _M_max characters.
  2619	
  2620	    protected:
  2621	      void
  2622	      _M_overflow() override
  2623	      {
  2624		if (this->_M_unused().size() != 0)
  2625		  return; // No need to switch to internal buffer yet.
  2626	
  2627		auto __s = this->_M_used();
  2628	
  2629		if (_M_max >= 0)
  2630		  {
  2631		    _M_count += __s.size();
  2632		    // Span was already sized for the maximum character count,
  2633		    // if it overflows then any further output must go to the
  2634		    // internal buffer, to be discarded.
  2635		    this->_M_reset(this->_M_buf);
  2636		  }
  2637		else
  2638		  {
  2639		    // No maximum character count. Just extend the span to allow
  2640		    // writing more characters to it.
  2641		    this->_M_reset({__s.data(), __s.size() + 1024}, __s.size());
  2642		  }
  2643	      }
  2644	
  2645	    private:
  2646	      static span<_CharT>
  2647	      _S_make_span(_CharT* __ptr, iter_difference_t<_OutIter> __n,
  2648			   span<_CharT> __buf) noexcept
  2649	      {
  2650		if (__n == 0)
  2651		  return __buf; // Only write to the internal buffer.
  2652	
  2653		if (__n > 0)
  2654		  {
  2655		    if constexpr (!is_integral_v<iter_difference_t<_OutIter>>
  2656				    || sizeof(__n) > sizeof(size_t))
  2657		      {
  2658			// __int128 or __detail::__max_diff_type
  2659			auto __m = iter_difference_t<_OutIter>((size_t)-1);
  2660			if (__n > __m)
  2661			  __n = __m;
  2662		      }
  2663		    return {__ptr, (size_t)__n};
  2664		  }
  2665	
  2666	#if __has_builtin(__builtin_dynamic_object_size)
  2667		if (size_t __bytes = __builtin_dynamic_object_size(__ptr, 2))
  2668		  return {__ptr, __bytes / sizeof(_CharT)};
  2669	#endif
  2670		// Avoid forming a pointer to a different memory page.
  2671		const auto __off = reinterpret_cast<__UINTPTR_TYPE__>(__ptr) % 1024;
  2672		__n = (1024 - __off) / sizeof(_CharT);
  2673		if (__n > 0) [[likely]]
  2674		return {__ptr, static_cast<size_t>(__n)};
  2675		else // Misaligned/packed buffer of wchar_t?
  2676		  return {__ptr, 1};
  2677	      }
  2678	
  2679	    public:
  2680	      explicit
  2681	      _Iter_sink(_OutIter __out, iter_difference_t<_OutIter> __n = -1) noexcept
  2682	      : _Sink<_CharT>(_S_make_span(std::to_address(__out), __n, _M_buf)),
  2683		_M_first(__out), _M_max(__n)
  2684	      { }
  2685	
  2686	      format_to_n_result<_OutIter>
  2687	      _M_finish() &&
  2688	      {
  2689		auto __s = this->_M_used();
  2690		if (__s.data() == _M_buf)
  2691		  {
  2692		    // Switched to internal buffer, so must have written _M_max.
  2693		    iter_difference_t<_OutIter> __count(_M_count + __s.size());
  2694		    return { _M_first + _M_max, __count };
  2695		  }
  2696		else // Not using internal buffer yet
  2697		  {
  2698		    iter_difference_t<_OutIter> __count(__s.size());
  2699		    return { _M_first + __count, __count };
  2700		  }
  2701	      }
  2702	    };
  2703	
  2704	  enum _Arg_t : unsigned char {
  2705	    _Arg_none, _Arg_bool, _Arg_c, _Arg_i, _Arg_u, _Arg_ll, _Arg_ull,
  2706	    _Arg_flt, _Arg_dbl, _Arg_ldbl, _Arg_str, _Arg_sv, _Arg_ptr, _Arg_handle,
  2707	    _Arg_i128, _Arg_u128,
  2708	    _Arg_bf16, _Arg_f16, _Arg_f32, _Arg_f64, // These are unused.
  2709	#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
  2710	    _Arg_next_value_,
  2711	    _Arg_f128 = _Arg_ldbl,
  2712	    _Arg_ibm128 = _Arg_next_value_,
  2713	#else
  2714	    _Arg_f128,
  2715	#endif
  2716	    _Arg_max_
  2717	  };
  2718	
  2719	  template<typename _Context>
  2720	    struct _Arg_value
  2721	    {
  2722	      using _CharT = typename _Context::char_type;
  2723	
  2724	      struct _HandleBase
  2725	      {
  2726		const void* _M_ptr;
  2727		void (*_M_func)();
  2728	      };
  2729	
  2730	      union
  2731	      {
  2732		monostate _M_none;
  2733		bool _M_bool;
  2734		_CharT _M_c;
  2735		int _M_i;
  2736		unsigned _M_u;
  2737		long long _M_ll;
  2738		unsigned long long _M_ull;
  2739		float _M_flt;
  2740		double _M_dbl;
  2741	#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT // No long double if it's ambiguous.
  2742		long double _M_ldbl;
  2743	#endif
  2744		const _CharT* _M_str;
  2745		basic_string_view<_CharT> _M_sv;
  2746		const void* _M_ptr;
  2747		_HandleBase _M_handle;
  2748	#ifdef __SIZEOF_INT128__
  2749		__int128 _M_i128;
  2750		unsigned __int128 _M_u128;
  2751	#endif
  2752		// TODO _Float16 etc.
  2753	#ifdef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
  2754		__ieee128 _M_f128;
  2755		__ibm128  _M_ibm128;
  2756	#elif _GLIBCXX_FORMAT_F128 == 2
  2757		__float128_t _M_f128;
  2758	#endif
  2759	      };
  2760	
  2761	      [[__gnu__::__always_inline__]]
  2762	      _Arg_value() : _M_none() { }
  2763	
  2764	#if 0
  2765	      template<typename _Tp>
  2766		_Arg_value(in_place_type_t<_Tp>, _Tp __val)
  2767		{ _S_get<_Tp>() = __val; }
  2768	#endif
  2769	
  2770	      template<typename _Tp, typename _Self>
  2771		[[__gnu__::__always_inline__]]
  2772		static auto&
  2773		_S_get(_Self& __u) noexcept
  2774		{
  2775		  if constexpr (is_same_v<_Tp, bool>)
  2776		    return __u._M_bool;
  2777		  else if constexpr (is_same_v<_Tp, _CharT>)
  2778		    return __u._M_c;
  2779		  else if constexpr (is_same_v<_Tp, int>)
  2780		    return __u._M_i;
  2781		  else if constexpr (is_same_v<_Tp, unsigned>)
  2782		    return __u._M_u;
  2783		  else if constexpr (is_same_v<_Tp, long long>)
  2784		    return __u._M_ll;
  2785		  else if constexpr (is_same_v<_Tp, unsigned long long>)
  2786		    return __u._M_ull;
  2787		  else if constexpr (is_same_v<_Tp, float>)
  2788		    return __u._M_flt;
  2789		  else if constexpr (is_same_v<_Tp, double>)
  2790		    return __u._M_dbl;
  2791	#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
  2792		  else if constexpr (is_same_v<_Tp, long double>)
  2793		    return __u._M_ldbl;
  2794	#else
  2795		  else if constexpr (is_same_v<_Tp, __ieee128>)
  2796		    return __u._M_f128;
  2797		  else if constexpr (is_same_v<_Tp, __ibm128>)
  2798		    return __u._M_ibm128;
  2799	#endif
  2800		  else if constexpr (is_same_v<_Tp, const _CharT*>)
  2801		    return __u._M_str;
  2802		  else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
  2803		    return __u._M_sv;
  2804		  else if constexpr (is_same_v<_Tp, const void*>)
  2805		    return __u._M_ptr;
  2806	#ifdef __SIZEOF_INT128__
  2807		  else if constexpr (is_same_v<_Tp, __int128>)
  2808		    return __u._M_i128;
  2809		  else if constexpr (is_same_v<_Tp, unsigned __int128>)
  2810		    return __u._M_u128;
  2811	#endif
  2812	#if _GLIBCXX_FORMAT_F128 == 2
  2813		  else if constexpr (is_same_v<_Tp, __float128_t>)
  2814		    return __u._M_f128;
  2815	#endif
  2816		  else if constexpr (derived_from<_Tp, _HandleBase>)
  2817		    return static_cast<_Tp&>(__u._M_handle);
  2818		  // Otherwise, ill-formed.
  2819		}
  2820	
  2821	      template<typename _Tp>
  2822		[[__gnu__::__always_inline__]]
  2823		auto&
  2824		_M_get() noexcept
  2825		{ return _S_get<_Tp>(*this); }
  2826	
  2827	      template<typename _Tp>
  2828		[[__gnu__::__always_inline__]]
  2829		const auto&
  2830		_M_get() const noexcept
  2831		{ return _S_get<_Tp>(*this); }
  2832	
  2833	      template<typename _Tp>
  2834		[[__gnu__::__always_inline__]]
  2835		void
  2836		_M_set(_Tp __v) noexcept
  2837		{
  2838		  if constexpr (derived_from<_Tp, _HandleBase>)
  2839		    std::construct_at(&_M_handle, __v);
  2840		  else
  2841		    _S_get<_Tp>(*this) = __v;
  2842		}
  2843	      };
  2844	
  2845	  // [format.arg.store], class template format-arg-store
  2846	  template<typename _Context, typename... _Args>
  2847	    class _Arg_store;
  2848	
  2849	} // namespace __format
  2850	/// @endcond
  2851	
  2852	  template<typename _Context>
  2853	    class basic_format_arg
  2854	    {
  2855	      using _CharT = typename _Context::char_type;
  2856	
  2857	      template<typename _Tp>
  2858		static constexpr bool __formattable
  2859		  = __format::__formattable_with<_Tp, _Context>;
  2860	
  2861	    public:
  2862	      class handle : public __format::_Arg_value<_Context>::_HandleBase
  2863	      {
  2864		using _Base = typename __format::_Arg_value<_Context>::_HandleBase;
  2865	
  2866		// Format as const if possible, to reduce instantiations.
  2867		template<typename _Tp>
  2868		  using __maybe_const_t
  2869		    = __conditional_t<__formattable<const _Tp>, const _Tp, _Tp>;
  2870	
  2871		template<typename _Tq>
  2872		  static void
  2873		  _S_format(basic_format_parse_context<_CharT>& __parse_ctx,
  2874			    _Context& __format_ctx, const void* __ptr)
  2875		  {
  2876		    using _Td = remove_const_t<_Tq>;
  2877		    typename _Context::template formatter_type<_Td> __f;
  2878		    __parse_ctx.advance_to(__f.parse(__parse_ctx));
  2879		    _Tq& __val = *const_cast<_Tq*>(static_cast<const _Td*>(__ptr));
  2880		    __format_ctx.advance_to(__f.format(__val, __format_ctx));
  2881		  }
  2882	
  2883		template<typename _Tp>
  2884		  explicit
  2885		  handle(_Tp& __val) noexcept
  2886		  {
  2887		    this->_M_ptr = __builtin_addressof(__val);
  2888		    auto __func = _S_format<__maybe_const_t<_Tp>>;
  2889		    this->_M_func = reinterpret_cast<void(*)()>(__func);
  2890		  }
  2891	
  2892		friend class basic_format_arg<_Context>;
  2893	
  2894	      public:
  2895		handle(const handle&) = default;
  2896		handle& operator=(const handle&) = default;
  2897	
  2898		[[__gnu__::__always_inline__]]
  2899		void
  2900		format(basic_format_parse_context<_CharT>& __pc, _Context& __fc) const
  2901		{
  2902		  using _Func = void(*)(basic_format_parse_context<_CharT>&,
  2903					_Context&, const void*);
  2904		  auto __f = reinterpret_cast<_Func>(this->_M_func);
  2905		  __f(__pc, __fc, this->_M_ptr);
  2906		}
  2907	      };
  2908	
  2909	      [[__gnu__::__always_inline__]]
  2910	      basic_format_arg() noexcept : _M_type(__format::_Arg_none) { }
  2911	
  2912	      [[nodiscard,__gnu__::__always_inline__]]
  2913	      explicit operator bool() const noexcept
  2914	      { return _M_type != __format::_Arg_none; }
  2915	
  2916	    private:
  2917	      template<typename _Ctx>
  2918		friend class basic_format_args;
  2919	
  2920	      template<typename _Ctx, typename... _Args>
  2921		friend class __format::_Arg_store;
  2922	
  2923	      static_assert(is_trivially_copyable_v<__format::_Arg_value<_Context>>);
  2924	
  2925	      __format::_Arg_value<_Context> _M_val;
  2926	      __format::_Arg_t _M_type;
  2927	
  2928	      // Transform incoming argument type to the type stored in _Arg_value.
  2929	      // e.g. short -> int, std::string -> std::string_view,
  2930	      // char[3] -> const char*.
  2931	      template<typename _Tp>
  2932		static consteval auto
  2933		_S_to_arg_type()
  2934		{
  2935		  using _Td = remove_const_t<_Tp>;
  2936		  if constexpr (is_same_v<_Td, bool>)
  2937		    return type_identity<bool>();
  2938		  else if constexpr (is_same_v<_Td, _CharT>)
  2939		    return type_identity<_CharT>();
  2940		  else if constexpr (is_same_v<_Td, char> && is_same_v<_CharT, wchar_t>)
  2941		    return type_identity<_CharT>();
  2942	#ifdef __SIZEOF_INT128__ // Check before signed/unsigned integer
  2943		  else if constexpr (is_same_v<_Td, __int128>)
  2944		    return type_identity<__int128>();
  2945		  else if constexpr (is_same_v<_Td, unsigned __int128>)
  2946		    return type_identity<unsigned __int128>();
  2947	#endif
  2948		  else if constexpr (__is_signed_integer<_Td>::value)
  2949		    {
  2950		      if constexpr (sizeof(_Td) <= sizeof(int))
  2951			return type_identity<int>();
  2952		      else if constexpr (sizeof(_Td) <= sizeof(long long))
  2953			return type_identity<long long>();
  2954		    }
  2955		  else if constexpr (__is_unsigned_integer<_Td>::value)
  2956		    {
  2957		      if constexpr (sizeof(_Td) <= sizeof(unsigned))
  2958			return type_identity<unsigned>();
  2959		      else if constexpr (sizeof(_Td) <= sizeof(unsigned long long))
  2960			return type_identity<unsigned long long>();
  2961		    }
  2962		  else if constexpr (is_same_v<_Td, float>)
  2963		    return type_identity<float>();
  2964		  else if constexpr (is_same_v<_Td, double>)
  2965		    return type_identity<double>();
  2966	#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
  2967		  else if constexpr (is_same_v<_Td, long double>)
  2968		    return type_identity<long double>();
  2969	#else
  2970		  else if constexpr (is_same_v<_Td, __ibm128>)
  2971		    return type_identity<__ibm128>();
  2972		  else if constexpr (is_same_v<_Td, __ieee128>)
  2973		    return type_identity<__ieee128>();
  2974	#endif
  2975	
  2976		  // TODO bfloat16 and float16
  2977	
  2978	#ifdef __FLT32_DIG__
  2979		  else if constexpr (is_same_v<_Td, _Float32>)
  2980	# ifdef _GLIBCXX_FLOAT_IS_IEEE_BINARY32
  2981		    return type_identity<float>();
  2982	# else
  2983		    return type_identity<_Float32>();
  2984	# endif
  2985	#endif
  2986	#ifdef __FLT64_DIG__
  2987		  else if constexpr (is_same_v<_Td, _Float64>)
  2988	# ifdef _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
  2989		    return type_identity<double>();
  2990	# else
  2991		    return type_identity<_Float64>();
  2992	# endif
  2993	#endif
  2994	#if _GLIBCXX_FORMAT_F128
  2995	# if __FLT128_DIG__
  2996		  else if constexpr (is_same_v<_Td, _Float128>)
  2997		    return type_identity<__format::__float128_t>();
  2998	# endif
  2999	# if __SIZEOF_FLOAT128__
  3000		  else if constexpr (is_same_v<_Td, __float128>)
  3001		    return type_identity<__format::__float128_t>();
  3002	# endif
  3003	#endif
  3004		  else if constexpr (__is_specialization_of<_Td, basic_string_view>
  3005				    || __is_specialization_of<_Td, basic_string>)
  3006		    {
  3007		      if constexpr (is_same_v<typename _Td::value_type, _CharT>)
  3008			return type_identity<basic_string_view<_CharT>>();
  3009		      else
  3010			return type_identity<handle>();
  3011		    }
  3012		  else if constexpr (is_same_v<decay_t<_Td>, const _CharT*>)
  3013		    return type_identity<const _CharT*>();
  3014		  else if constexpr (is_same_v<decay_t<_Td>, _CharT*>)
  3015		    return type_identity<const _CharT*>();
  3016		  else if constexpr (is_void_v<remove_pointer_t<_Td>>)
  3017		    return type_identity<const void*>();
  3018		  else if constexpr (is_same_v<_Td, nullptr_t>)
  3019		    return type_identity<const void*>();
  3020		  else
  3021		    return type_identity<handle>();
  3022		}
  3023	
  3024	      // Transform a formattable type to the appropriate storage type.
  3025	      template<typename _Tp>
  3026		using _Normalize = typename decltype(_S_to_arg_type<_Tp>())::type;
  3027	
  3028	      // Get the _Arg_t value corresponding to a normalized type.
  3029	      template<typename _Tp>
  3030		static consteval __format::_Arg_t
  3031		_S_to_enum()
  3032		{
  3033		  using namespace __format;
  3034		  if constexpr (is_same_v<_Tp, bool>)
  3035		    return _Arg_bool;
  3036		  else if constexpr (is_same_v<_Tp, _CharT>)
  3037		    return _Arg_c;
  3038		  else if constexpr (is_same_v<_Tp, int>)
  3039		    return _Arg_i;
  3040		  else if constexpr (is_same_v<_Tp, unsigned>)
  3041		    return _Arg_u;
  3042		  else if constexpr (is_same_v<_Tp, long long>)
  3043		    return _Arg_ll;
  3044		  else if constexpr (is_same_v<_Tp, unsigned long long>)
  3045		    return _Arg_ull;
  3046		  else if constexpr (is_same_v<_Tp, float>)
  3047		    return _Arg_flt;
  3048		  else if constexpr (is_same_v<_Tp, double>)
  3049		    return _Arg_dbl;
  3050	#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
  3051		  else if constexpr (is_same_v<_Tp, long double>)
  3052		    return _Arg_ldbl;
  3053	#else
  3054		  // Don't use _Arg_ldbl for this target, it's ambiguous.
  3055		  else if constexpr (is_same_v<_Tp, __ibm128>)
  3056		    return _Arg_ibm128;
  3057		  else if constexpr (is_same_v<_Tp, __ieee128>)
  3058		    return _Arg_f128;
  3059	#endif
  3060		  else if constexpr (is_same_v<_Tp, const _CharT*>)
  3061		    return _Arg_str;
  3062		  else if constexpr (is_same_v<_Tp, basic_string_view<_CharT>>)
  3063		    return _Arg_sv;
  3064		  else if constexpr (is_same_v<_Tp, const void*>)
  3065		    return _Arg_ptr;
  3066	#ifdef __SIZEOF_INT128__
  3067		  else if constexpr (is_same_v<_Tp, __int128>)
  3068		    return _Arg_i128;
  3069		  else if constexpr (is_same_v<_Tp, unsigned __int128>)
  3070		    return _Arg_u128;
  3071	#endif
  3072	
  3073		  // N.B. some of these types will never actually be used here,
  3074		  // because they get normalized to a standard floating-point type.
  3075	#if defined __FLT32_DIG__ && ! _GLIBCXX_FLOAT_IS_IEEE_BINARY32
  3076		  else if constexpr (is_same_v<_Tp, _Float32>)
  3077		    return _Arg_f32;
  3078	#endif
  3079	#if defined __FLT64_DIG__ && ! _GLIBCXX_DOUBLE_IS_IEEE_BINARY64
  3080		  else if constexpr (is_same_v<_Tp, _Float64>)
  3081		    return _Arg_f64;
  3082	#endif
  3083	#if _GLIBCXX_FORMAT_F128 == 2
  3084		  else if constexpr (is_same_v<_Tp, __format::__float128_t>)
  3085		    return _Arg_f128;
  3086	#endif
  3087		  else if constexpr (is_same_v<_Tp, handle>)
  3088		    return _Arg_handle;
  3089		}
  3090	
  3091	      template<typename _Tp>
  3092		void
  3093		_M_set(_Tp __v) noexcept
  3094		{
  3095		  _M_type = _S_to_enum<_Tp>();
  3096		  _M_val._M_set(__v);
  3097		}
  3098	
  3099	      template<typename _Tp>
  3100		requires __format::__formattable_with<_Tp, _Context>
  3101		explicit
  3102		basic_format_arg(_Tp& __v) noexcept
  3103		{
  3104		  using _Td = _Normalize<_Tp>;
  3105		  if constexpr (is_same_v<_Td, basic_string_view<_CharT>>)
  3106		    _M_set(_Td{__v.data(), __v.size()});
  3107		  else if constexpr (is_same_v<remove_const_t<_Tp>, char>
  3108				       && is_same_v<_CharT, wchar_t>)
  3109		    _M_set(static_cast<_Td>(static_cast<unsigned char>(__v)));
  3110		  else
  3111		    _M_set(static_cast<_Td>(__v));
  3112		}
  3113	
  3114	      template<typename _Ctx, typename... _Argz>
  3115		friend auto
  3116		make_format_args(_Argz&...) noexcept;
  3117	
  3118	      template<typename _Visitor, typename _Ctx>
  3119		friend decltype(auto)
  3120		visit_format_arg(_Visitor&& __vis, basic_format_arg<_Ctx>);
  3121	
  3122	      template<typename _Visitor>
  3123		decltype(auto)
  3124		_M_visit(_Visitor&& __vis, __format::_Arg_t __type)
  3125		{
  3126		  using namespace __format;
  3127		  switch (__type)
  3128		  {
  3129		    case _Arg_none:
  3130		      return std::forward<_Visitor>(__vis)(_M_val._M_none);
  3131		    case _Arg_bool:
  3132		      return std::forward<_Visitor>(__vis)(_M_val._M_bool);
  3133		    case _Arg_c:
  3134		      return std::forward<_Visitor>(__vis)(_M_val._M_c);
  3135		    case _Arg_i:
  3136		      return std::forward<_Visitor>(__vis)(_M_val._M_i);
  3137		    case _Arg_u:
  3138		      return std::forward<_Visitor>(__vis)(_M_val._M_u);
  3139		    case _Arg_ll:
  3140		      return std::forward<_Visitor>(__vis)(_M_val._M_ll);
  3141		    case _Arg_ull:
  3142		      return std::forward<_Visitor>(__vis)(_M_val._M_ull);
  3143	#if __cpp_lib_to_chars // FIXME: need to be able to format these types!
  3144		    case _Arg_flt:
  3145		      return std::forward<_Visitor>(__vis)(_M_val._M_flt);
  3146		    case _Arg_dbl:
  3147		      return std::forward<_Visitor>(__vis)(_M_val._M_dbl);
  3148	#ifndef _GLIBCXX_LONG_DOUBLE_ALT128_COMPAT
  3149		    case _Arg_ldbl:
  3150		      return std::forward<_Visitor>(__vis)(_M_val._M_ldbl);
  3151	#else
  3152		    case _Arg_f128:
  3153		      return std::forward<_Visitor>(__vis)(_M_val._M_f128);
  3154		    case _Arg_ibm128:
  3155		      return std::forward<_Visitor>(__vis)(_M_val._M_ibm128);
  3156	#endif
  3157	#endif
  3158		    case _Arg_str:
  3159		      return std::forward<_Visitor>(__vis)(_M_val._M_str);
  3160		    case _Arg_sv:
  3161		      return std::forward<_Visitor>(__vis)(_M_val._M_sv);
  3162		    case _Arg_ptr:
  3163		      return std::forward<_Visitor>(__vis)(_M_val._M_ptr);
  3164		    case _Arg_handle:
  3165		    {
  3166		      auto& __h = static_cast<handle&>(_M_val._M_handle);
  3167		      return std::forward<_Visitor>(__vis)(__h);
  3168		    }
  3169	#ifdef __SIZEOF_INT128__
  3170		    case _Arg_i128:
  3171		      return std::forward<_Visitor>(__vis)(_M_val._M_i128);
  3172		    case _Arg_u128:
  3173		      return std::forward<_Visitor>(__vis)(_M_val._M_u128);
  3174	#endif
  3175	
  3176	#if _GLIBCXX_FORMAT_F128 == 2
  3177		    case _Arg_f128:
  3178		      return std::forward<_Visitor>(__vis)(_M_val._M_f128);
  3179	#endif
  3180	
  3181		    default:
  3182		      // _Arg_f16 etc.
  3183		      __builtin_unreachable();
  3184		  }
  3185		}
  3186	    };
  3187	
  3188	  template<typename _Visitor, typename _Context>
  3189	    inline decltype(auto)
  3190	    visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg)
  3191	    {
  3192	      return __arg._M_visit(std::forward<_Visitor>(__vis), __arg._M_type);
  3193	    }
  3194	
  3195	/// @cond undocumented
  3196	namespace __format
  3197	{
  3198	  struct _WidthPrecVisitor
  3199	  {
  3200	    template<typename _Tp>
  3201	      size_t
  3202	      operator()(_Tp& __arg) const
  3203	      {
  3204		if constexpr (is_same_v<_Tp, monostate>)
  3205		  __format::__invalid_arg_id_in_format_string();
  3206		// _GLIBCXX_RESOLVE_LIB_DEFECTS
  3207		// 3720. Restrict the valid types of arg-id for width and precision
  3208		// 3721. Allow an arg-id with a value of zero for width
  3209		else if constexpr (sizeof(_Tp) <= sizeof(long long))
  3210		  {
  3211		    // _GLIBCXX_RESOLVE_LIB_DEFECTS
  3212		    // 3720. Restrict the valid types of arg-id for width and precision
  3213		    if constexpr (__is_unsigned_integer<_Tp>::value)
  3214		      return __arg;
  3215		    else if constexpr (__is_signed_integer<_Tp>::value)
  3216		      if (__arg >= 0)
  3217			return __arg;
  3218		  }
  3219		__throw_format_error("format error: argument used for width or "
  3220				     "precision must be a non-negative integer");
  3221	      }
  3222	  };
  3223	
  3224	  template<typename _Context>
  3225	    inline size_t
  3226	    __int_from_arg(const basic_format_arg<_Context>& __arg)
  3227	    { return std::visit_format_arg(_WidthPrecVisitor(), __arg); }
  3228	
  3229	  // Pack _Arg_t enum values into a single 60-bit integer.
  3230	  template<int _Bits, size_t _Nm>
  3231	    constexpr auto
  3232	    __pack_arg_types(const array<_Arg_t, _Nm>& __types)
  3233	    {
  3234	      __UINT64_TYPE__ __packed_types = 0;
  3235	      for (auto __i = __types.rbegin(); __i != __types.rend(); ++__i)
  3236		__packed_types = (__packed_types << _Bits) | *__i;
  3237	      return __packed_types;
  3238	    }
  3239	} // namespace __format
  3240	/// @endcond
  3241	
  3242	  template<typename _Context>
  3243	    class basic_format_args
  3244	    {
  3245	      static constexpr int _S_packed_type_bits = 5; // _Arg_t values [0,20]
  3246	      static constexpr int _S_packed_type_mask = 0b11111;
  3247	      static constexpr int _S_max_packed_args = 12;
  3248	
  3249	      static_assert( __format::_Arg_max_ <= (1 << _S_packed_type_bits) );
  3250	
  3251	      template<typename... _Args>
  3252		using _Store = __format::_Arg_store<_Context, _Args...>;
  3253	
  3254	      template<typename _Ctx, typename... _Args>
  3255		friend class __format::_Arg_store;
  3256	
  3257	      using uint64_t = __UINT64_TYPE__;
  3258	      using _Format_arg = basic_format_arg<_Context>;
  3259	      using _Format_arg_val = __format::_Arg_value<_Context>;
  3260	
  3261	      // If args are packed then the number of args is in _M_packed_size and
  3262	      // the packed types are in _M_unpacked_size, accessed via _M_type(i).
  3263	      // If args are not packed then the number of args is in _M_unpacked_size
  3264	      // and _M_packed_size is zero.
  3265	      uint64_t _M_packed_size : 4;
  3266	      uint64_t _M_unpacked_size : 60;
  3267	
  3268	      union {
  3269		const _Format_arg_val* _M_values; // Active when _M_packed_size != 0
  3270		const _Format_arg* _M_args;       // Active when _M_packed_size == 0
  3271	      };
  3272	
  3273	      size_t
  3274	      _M_size() const noexcept
  3275	      { return _M_packed_size ? _M_packed_size : _M_unpacked_size; }
  3276	
  3277	      typename __format::_Arg_t
  3278	      _M_type(size_t __i) const noexcept
  3279	      {
  3280		uint64_t __t = _M_unpacked_size >> (__i * _S_packed_type_bits);
  3281		return static_cast<__format::_Arg_t>(__t & _S_packed_type_mask);
  3282	      }
  3283	
  3284	      template<typename _Ctx, typename... _Args>
  3285		friend auto
  3286		make_format_args(_Args&...) noexcept;
  3287	
  3288	      // An array of _Arg_t enums corresponding to _Args...
  3289	      template<typename... _Args>
  3290		static consteval array<__format::_Arg_t, sizeof...(_Args)>
  3291		_S_types_to_pack()
  3292		{ return {_Format_arg::template _S_to_enum<_Args>()...}; }
  3293	
  3294	    public:
  3295	      basic_format_args() noexcept = default;
  3296	
  3297	      template<typename... _Args>
  3298		basic_format_args(const _Store<_Args...>& __store) noexcept;
  3299	
  3300	      [[nodiscard,__gnu__::__always_inline__]]
  3301	      basic_format_arg<_Context>
  3302	      get(size_t __i) const noexcept
  3303	      {
  3304		basic_format_arg<_Context> __arg;
  3305		if (__i < _M_packed_size)
  3306		  {
  3307		    __arg._M_type = _M_type(__i);
  3308		    __arg._M_val = _M_values[__i];
  3309		  }
  3310		else if (_M_packed_size == 0 && __i < _M_unpacked_size)
  3311		  __arg = _M_args[__i];
  3312		return __arg;
  3313	      }
  3314	    };
  3315	
  3316	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  3317	  // 3810. CTAD for std::basic_format_args
  3318	  template<typename _Context, typename... _Args>
  3319	    basic_format_args(__format::_Arg_store<_Context, _Args...>)
  3320	      -> basic_format_args<_Context>;
  3321	
  3322	  template<typename _Context, typename... _Args>
  3323	    auto
  3324	    make_format_args(_Args&... __fmt_args) noexcept;
  3325	
  3326	  // An array of type-erased formatting arguments.
  3327	  template<typename _Context, typename... _Args>
  3328	    class __format::_Arg_store
  3329	    {
  3330	      friend std::basic_format_args<_Context>;
  3331	
  3332	      template<typename _Ctx, typename... _Argz>
  3333		friend auto std::
  3334	#if _GLIBCXX_INLINE_VERSION
  3335		__8:: // Needed for PR c++/59256
  3336	#endif
  3337		make_format_args(_Argz&...) noexcept;
  3338	
  3339	      // For a sufficiently small number of arguments we only store values.
  3340	      // basic_format_args can get the types from the _Args pack.
  3341	      static constexpr bool _S_values_only
  3342		= sizeof...(_Args) <= basic_format_args<_Context>::_S_max_packed_args;
  3343	
  3344	      using _Element_t
  3345		= __conditional_t<_S_values_only,
  3346				  __format::_Arg_value<_Context>,
  3347				  basic_format_arg<_Context>>;
  3348	
  3349	      _Element_t _M_args[sizeof...(_Args)];
  3350	
  3351	      template<typename _Tp>
  3352		static _Element_t
  3353		_S_make_elt(_Tp& __v)
  3354		{
  3355		  basic_format_arg<_Context> __arg(__v);
  3356		  if constexpr (_S_values_only)
  3357		    return __arg._M_val;
  3358		  else
  3359		    return __arg;
  3360		}
  3361	
  3362	      template<typename... _Tp>
  3363		requires (sizeof...(_Tp) == sizeof...(_Args))
  3364		[[__gnu__::__always_inline__]]
  3365		_Arg_store(_Tp&... __a) noexcept
  3366		: _M_args{_S_make_elt(__a)...}
  3367		{ }
  3368	    };
  3369	
  3370	  template<typename _Context>
  3371	    class __format::_Arg_store<_Context>
  3372	    { };
  3373	
  3374	  template<typename _Context>
  3375	    template<typename... _Args>
  3376	      inline
  3377	      basic_format_args<_Context>::
  3378	      basic_format_args(const _Store<_Args...>& __store) noexcept
  3379	      {
  3380		if constexpr (sizeof...(_Args) == 0)
  3381		  {
  3382		    _M_packed_size = 0;
  3383		    _M_unpacked_size = 0;
  3384		    _M_args = nullptr;
  3385		  }
  3386		else if constexpr (sizeof...(_Args) <= _S_max_packed_args)
  3387		  {
  3388		    // The number of packed arguments:
  3389		    _M_packed_size = sizeof...(_Args);
  3390		    // The packed type enums:
  3391		    _M_unpacked_size
  3392		      = __format::__pack_arg_types<_S_packed_type_bits>(_S_types_to_pack<_Args...>());
  3393		    // The _Arg_value objects.
  3394		    _M_values = __store._M_args;
  3395		  }
  3396		else
  3397		  {
  3398		    // No packed arguments:
  3399		    _M_packed_size = 0;
  3400		    // The number of unpacked arguments:
  3401		    _M_unpacked_size = sizeof...(_Args);
  3402		    // The basic_format_arg objects:
  3403		    _M_args = __store._M_args;
  3404		  }
  3405	      }
  3406	
  3407	  /// Capture formatting arguments for use by `std::vformat`.
  3408	  template<typename _Context = format_context, typename... _Args>
  3409	    [[nodiscard,__gnu__::__always_inline__]]
  3410	    inline auto
  3411	    make_format_args(_Args&... __fmt_args) noexcept
  3412	    {
  3413	      using _Fmt_arg = basic_format_arg<_Context>;
  3414	      using _Store = __format::_Arg_store<_Context, typename _Fmt_arg::template
  3415			     _Normalize<_Args>...>;
  3416	      return _Store(__fmt_args...);
  3417	    }
  3418	
  3419	  /// Capture formatting arguments for use by `std::vformat` (for wide output).
  3420	  template<typename... _Args>
  3421	    [[nodiscard,__gnu__::__always_inline__]]
  3422	    inline auto
  3423	    make_wformat_args(_Args&... __args) noexcept
  3424	    { return std::make_format_args<wformat_context>(__args...); }
  3425	
  3426	/// @cond undocumented
  3427	namespace __format
  3428	{
  3429	  template<typename _Out, typename _CharT, typename _Context>
  3430	    _Out
  3431	    __do_vformat_to(_Out, basic_string_view<_CharT>,
  3432			    const basic_format_args<_Context>&,
  3433			    const locale* = nullptr);
  3434	} // namespace __format
  3435	/// @endcond
  3436	
  3437	  /** Context for std::format and similar functions.
  3438	   *
  3439	   * A formatting context contains an output iterator and locale to use
  3440	   * for the formatting operations. Most programs will never need to use
  3441	   * this class template explicitly. For typical uses of `std::format` the
  3442	   * library will use the specializations `std::format_context` (for `char`)
  3443	   * and `std::wformat_context` (for `wchar_t`).
  3444	   */
  3445	  template<typename _Out, typename _CharT>
  3446	    class basic_format_context
  3447	    {
  3448	      static_assert( output_iterator<_Out, const _CharT&> );
  3449	
  3450	      basic_format_args<basic_format_context> _M_args;
  3451	      _Out _M_out;
  3452	      __format::_Optional_locale _M_loc;
  3453	
  3454	      basic_format_context(basic_format_args<basic_format_context> __args,
  3455				   _Out __out)
  3456	      : _M_args(__args), _M_out(std::move(__out))
  3457	      { }
  3458	
  3459	      basic_format_context(basic_format_args<basic_format_context> __args,
  3460				   _Out __out, const std::locale& __loc)
  3461	      : _M_args(__args), _M_out(std::move(__out)), _M_loc(__loc)
  3462	      { }
  3463	
  3464	      template<typename _Out2, typename _CharT2, typename _Context2>
  3465		friend _Out2
  3466		__format::__do_vformat_to(_Out2, basic_string_view<_CharT2>,
  3467					  const basic_format_args<_Context2>&,
  3468					  const locale*);
  3469	
  3470	    public:
  3471	      basic_format_context() = default;
  3472	      ~basic_format_context() = default;
  3473	
  3474	      using iterator = _Out;
  3475	      using char_type = _CharT;
  3476	      template<typename _Tp>
  3477		using formatter_type = formatter<_Tp, _CharT>;
  3478	
  3479	      [[nodiscard]]
  3480	      basic_format_arg<basic_format_context>
  3481	      arg(size_t __id) const noexcept
  3482	      { return _M_args.get(__id); }
  3483	
  3484	      [[nodiscard]]
  3485	      std::locale locale() { return _M_loc.value(); }
  3486	
  3487	      [[nodiscard]]
  3488	      iterator out() { return std::move(_M_out); }
  3489	
  3490	      void advance_to(iterator __it) { _M_out = std::move(__it); }
  3491	    };
  3492	
  3493	
  3494	/// @cond undocumented
  3495	namespace __format
  3496	{
  3497	  // Abstract base class defining an interface for scanning format strings.
  3498	  // Scan the characters in a format string, dividing it up into strings of
  3499	  // ordinary characters, escape sequences, and replacement fields.
  3500	  // Call virtual functions for derived classes to parse format-specifiers
  3501	  // or write formatted output.
  3502	  template<typename _CharT>
  3503	    struct _Scanner
  3504	    {
  3505	      using iterator = typename basic_format_parse_context<_CharT>::iterator;
  3506	
  3507	      basic_format_parse_context<_CharT> _M_pc;
  3508	
  3509	      constexpr explicit
  3510	      _Scanner(basic_string_view<_CharT> __str, size_t __nargs = -1)
  3511	      : _M_pc(__str, __nargs)
  3512	      { }
  3513	
  3514	      constexpr iterator begin() const noexcept { return _M_pc.begin(); }
  3515	      constexpr iterator end() const noexcept { return _M_pc.end(); }
  3516	
  3517	      constexpr void
  3518	      _M_scan()
  3519	      {
  3520		basic_string_view<_CharT> __fmt = _M_fmt_str();
  3521	
  3522		if (__fmt.size() == 2 && __fmt[0] == '{' && __fmt[1] == '}')
  3523		  {
  3524		    _M_pc.advance_to(begin() + 1);
  3525		    _M_format_arg(_M_pc.next_arg_id());
  3526		    return;
  3527		  }
  3528	
  3529		size_t __lbr = __fmt.find('{');
  3530		size_t __rbr = __fmt.find('}');
  3531	
  3532		while (__fmt.size())
  3533		  {
  3534		    auto __cmp = __lbr <=> __rbr;
  3535		    if (__cmp == 0)
  3536		      {
  3537			_M_on_chars(end());
  3538			_M_pc.advance_to(end());
  3539			return;
  3540		      }
  3541		    else if (__cmp < 0)
  3542		      {
  3543			if (__lbr + 1 == __fmt.size()
  3544			      || (__rbr == __fmt.npos && __fmt[__lbr + 1] != '{'))
  3545			  __format::__unmatched_left_brace_in_format_string();
  3546			const bool __is_escape = __fmt[__lbr + 1] == '{';
  3547			iterator __last = begin() + __lbr + int(__is_escape);
  3548			_M_on_chars(__last);
  3549			_M_pc.advance_to(__last + 1);
  3550			__fmt = _M_fmt_str();
  3551			if (__is_escape)
  3552			  {
  3553			    if (__rbr != __fmt.npos)
  3554			      __rbr -= __lbr + 2;
  3555			    __lbr = __fmt.find('{');
  3556			  }
  3557			else
  3558			  {
  3559			    _M_on_replacement_field();
  3560			    __fmt = _M_fmt_str();
  3561			    __lbr = __fmt.find('{');
  3562			    __rbr = __fmt.find('}');
  3563			  }
  3564		      }
  3565		    else
  3566		      {
  3567			if (++__rbr == __fmt.size() || __fmt[__rbr] != '}')
  3568			  __format::__unmatched_right_brace_in_format_string();
  3569			iterator __last = begin() + __rbr;
  3570			_M_on_chars(__last);
  3571			_M_pc.advance_to(__last + 1);
  3572			__fmt = _M_fmt_str();
  3573			if (__lbr != __fmt.npos)
  3574			  __lbr -= __rbr + 1;
  3575			__rbr = __fmt.find('}');
  3576		      }
  3577		  }
  3578	      }
  3579	
  3580	      constexpr basic_string_view<_CharT>
  3581	      _M_fmt_str() const noexcept
  3582	      { return {begin(), end()}; }
  3583	
  3584	      constexpr virtual void _M_on_chars(iterator) { }
  3585	
  3586	      constexpr void _M_on_replacement_field()
  3587	      {
  3588		auto __next = begin();
  3589	
  3590		size_t __id;
  3591		if (*__next == '}')
  3592		  __id = _M_pc.next_arg_id();
  3593		else if (*__next == ':')
  3594		  {
  3595		    __id = _M_pc.next_arg_id();
  3596		    _M_pc.advance_to(++__next);
  3597		  }
  3598		else
  3599		  {
  3600		    auto [__i, __ptr] = __format::__parse_arg_id(begin(), end());
  3601		    if (!__ptr || !(*__ptr == '}' || *__ptr == ':'))
  3602		      __format::__invalid_arg_id_in_format_string();
  3603		    _M_pc.check_arg_id(__id = __i);
  3604		    if (*__ptr == ':')
  3605		      {
  3606			_M_pc.advance_to(++__ptr);
  3607		      }
  3608		    else
  3609		      _M_pc.advance_to(__ptr);
  3610		  }
  3611		_M_format_arg(__id);
  3612		if (begin() == end() || *begin() != '}')
  3613		  __format::__unmatched_left_brace_in_format_string();
  3614		_M_pc.advance_to(begin() + 1); // Move past '}'
  3615	      }
  3616	
  3617	      constexpr virtual void _M_format_arg(size_t __id) = 0;
  3618	    };
  3619	
  3620	  // Process a format string and format the arguments in the context.
  3621	  template<typename _Out, typename _CharT>
  3622	    class _Formatting_scanner : public _Scanner<_CharT>
  3623	    {
  3624	    public:
  3625	      _Formatting_scanner(basic_format_context<_Out, _CharT>& __fc,
  3626				  basic_string_view<_CharT> __str)
  3627	      : _Scanner<_CharT>(__str), _M_fc(__fc)
  3628	      { }
  3629	
  3630	    private:
  3631	      basic_format_context<_Out, _CharT>& _M_fc;
  3632	
  3633	      using iterator = typename _Scanner<_CharT>::iterator;
  3634	
  3635	      constexpr void
  3636	      _M_on_chars(iterator __last) override
  3637	      {
  3638		basic_string_view<_CharT> __str(this->begin(), __last);
  3639		_M_fc.advance_to(__format::__write(_M_fc.out(), __str));
  3640	      }
  3641	
  3642	      constexpr void
  3643	      _M_format_arg(size_t __id) override
  3644	      {
  3645		using _Context = basic_format_context<_Out, _CharT>;
  3646		using handle = typename basic_format_arg<_Context>::handle;
  3647	
  3648		std::visit_format_arg([this](auto& __arg) {
  3649		  using _Type = remove_reference_t<decltype(__arg)>;
  3650		  using _Formatter = typename _Context::template formatter_type<_Type>;
  3651		  if constexpr (is_same_v<_Type, monostate>)
  3652		    __format::__invalid_arg_id_in_format_string();
  3653		  else if constexpr (is_same_v<_Type, handle>)
  3654		    __arg.format(this->_M_pc, this->_M_fc);
  3655		  else if constexpr (is_default_constructible_v<_Formatter>)
  3656		    {
  3657		      _Formatter __f;
  3658		      this->_M_pc.advance_to(__f.parse(this->_M_pc));
  3659		      this->_M_fc.advance_to(__f.format(__arg, this->_M_fc));
  3660		    }
  3661		  else
  3662		    static_assert(__format::__formattable_with<_Type, _Context>);
  3663		}, _M_fc.arg(__id));
  3664	      }
  3665	    };
  3666	
  3667	  // Validate a format string for Args.
  3668	  template<typename _CharT, typename... _Args>
  3669	    class _Checking_scanner : public _Scanner<_CharT>
  3670	    {
  3671	      static_assert(
  3672		(is_default_constructible_v<formatter<_Args, _CharT>> && ...),
  3673		"std::formatter must be specialized for each type being formatted");
  3674	
  3675	    public:
  3676	      constexpr
  3677	      _Checking_scanner(basic_string_view<_CharT> __str)
  3678	      : _Scanner<_CharT>(__str, sizeof...(_Args))
  3679	      { }
  3680	
  3681	    private:
  3682	      constexpr void
  3683	      _M_format_arg(size_t __id) override
  3684	      {
  3685		if constexpr (sizeof...(_Args) != 0)
  3686		  {
  3687		    if (__id < sizeof...(_Args))
  3688		      {
  3689			_M_parse_format_spec<_Args...>(__id);
  3690			return;
  3691		      }
  3692		  }
  3693		__builtin_unreachable();
  3694	      }
  3695	
  3696	      template<typename _Tp, typename... _OtherArgs>
  3697		constexpr void
  3698		_M_parse_format_spec(size_t __id)
  3699		{
  3700		  if (__id == 0)
  3701		    {
  3702		      formatter<_Tp, _CharT> __f;
  3703		      this->_M_pc.advance_to(__f.parse(this->_M_pc));
  3704		    }
  3705		  else if constexpr (sizeof...(_OtherArgs) != 0)
  3706		    _M_parse_format_spec<_OtherArgs...>(__id - 1);
  3707		  else
  3708		    __builtin_unreachable();
  3709		}
  3710	    };
  3711	
  3712	  template<typename _Out, typename _CharT, typename _Context>
  3713	    inline _Out
  3714	    __do_vformat_to(_Out __out, basic_string_view<_CharT> __fmt,
  3715			    const basic_format_args<_Context>& __args,
  3716			    const locale* __loc)
  3717	    {
  3718	      _Iter_sink<_CharT, _Out> __sink(std::move(__out));
  3719	      _Sink_iter<_CharT> __sink_out;
  3720	
  3721	      if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
  3722		__sink_out = __out; // Already a sink iterator, safe to use post-move.
  3723	      else
  3724		__sink_out = __sink.out();
  3725	
  3726	      auto __ctx = __loc == nullptr
  3727			     ? _Context(__args, __sink_out)
  3728			     : _Context(__args, __sink_out, *__loc);
  3729	      _Formatting_scanner<_Sink_iter<_CharT>, _CharT> __scanner(__ctx, __fmt);
  3730	      __scanner._M_scan();
  3731	
  3732	      if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)
  3733		return __ctx.out();
  3734	      else
  3735		return std::move(__sink)._M_finish().out;
  3736	    }
  3737	
  3738	} // namespace __format
  3739	/// @endcond
  3740	
  3741	  template<typename _CharT, typename... _Args>
  3742	    template<typename _Tp>
  3743	      requires convertible_to<const _Tp&, basic_string_view<_CharT>>
  3744	      consteval
  3745	      basic_format_string<_CharT, _Args...>::
  3746	      basic_format_string(const _Tp& __s)
  3747	      : _M_str(__s)
  3748	      {
  3749		__format::_Checking_scanner<_CharT, remove_cvref_t<_Args>...>
  3750		  __scanner(_M_str);
  3751		__scanner._M_scan();
  3752	      }
  3753	
  3754	  // [format.functions], formatting functions
  3755	
  3756	  template<typename _Out> requires output_iterator<_Out, const char&>
  3757	    [[__gnu__::__always_inline__]]
  3758	    inline _Out
  3759	    vformat_to(_Out __out, string_view __fmt, format_args __args)
  3760	    { return __format::__do_vformat_to(std::move(__out), __fmt, __args); }
  3761	
  3762	  template<typename _Out> requires output_iterator<_Out, const wchar_t&>
  3763	    [[__gnu__::__always_inline__]]
  3764	    inline _Out
  3765	    vformat_to(_Out __out, wstring_view __fmt, wformat_args __args)
  3766	    { return __format::__do_vformat_to(std::move(__out), __fmt, __args); }
  3767	
  3768	  template<typename _Out> requires output_iterator<_Out, const char&>
  3769	    [[__gnu__::__always_inline__]]
  3770	    inline _Out
  3771	    vformat_to(_Out __out, const locale& __loc, string_view __fmt,
  3772		       format_args __args)
  3773	    { return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc); }
  3774	
  3775	  template<typename _Out> requires output_iterator<_Out, const wchar_t&>
  3776	    [[__gnu__::__always_inline__]]
  3777	    inline _Out
  3778	    vformat_to(_Out __out, const locale& __loc, wstring_view __fmt,
  3779		       wformat_args __args)
  3780	    { return __format::__do_vformat_to(std::move(__out), __fmt, __args, &__loc); }
  3781	
  3782	  [[nodiscard]]
  3783	  inline string
  3784	  vformat(string_view __fmt, format_args __args)
  3785	  {
  3786	    __format::_Str_sink<char> __buf;
  3787	    std::vformat_to(__buf.out(), __fmt, __args);
  3788	    return std::move(__buf).get();
  3789	  }
  3790	
  3791	  [[nodiscard]]
  3792	  inline wstring
  3793	  vformat(wstring_view __fmt, wformat_args __args)
  3794	  {
  3795	    __format::_Str_sink<wchar_t> __buf;
  3796	    std::vformat_to(__buf.out(), __fmt, __args);
  3797	    return std::move(__buf).get();
  3798	  }
  3799	
  3800	  [[nodiscard]]
  3801	  inline string
  3802	  vformat(const locale& __loc, string_view __fmt, format_args __args)
  3803	  {
  3804	    __format::_Str_sink<char> __buf;
  3805	    std::vformat_to(__buf.out(), __loc, __fmt, __args);
  3806	    return std::move(__buf).get();
  3807	  }
  3808	
  3809	  [[nodiscard]]
  3810	  inline wstring
  3811	  vformat(const locale& __loc, wstring_view __fmt, wformat_args __args)
  3812	  {
  3813	    __format::_Str_sink<wchar_t> __buf;
  3814	    std::vformat_to(__buf.out(), __loc, __fmt, __args);
  3815	    return std::move(__buf).get();
  3816	  }
  3817	
  3818	  template<typename... _Args>
  3819	    [[nodiscard]]
  3820	    inline string
  3821	    format(format_string<_Args...> __fmt, _Args&&... __args)
  3822	    { return std::vformat(__fmt.get(), std::make_format_args(__args...)); }
  3823	
  3824	  template<typename... _Args>
  3825	    [[nodiscard]]
  3826	    inline wstring
  3827	    format(wformat_string<_Args...> __fmt, _Args&&... __args)
  3828	    { return std::vformat(__fmt.get(), std::make_wformat_args(__args...)); }
  3829	
  3830	  template<typename... _Args>
  3831	    [[nodiscard]]
  3832	    inline string
  3833	    format(const locale& __loc, format_string<_Args...> __fmt,
  3834		   _Args&&... __args)
  3835	    {
  3836	      return std::vformat(__loc, __fmt.get(),
  3837				  std::make_format_args(__args...));
  3838	    }
  3839	
  3840	  template<typename... _Args>
  3841	    [[nodiscard]]
  3842	    inline wstring
  3843	    format(const locale& __loc, wformat_string<_Args...> __fmt,
  3844		   _Args&&... __args)
  3845	    {
  3846	      return std::vformat(__loc, __fmt.get(),
  3847				  std::make_wformat_args(__args...));
  3848	    }
  3849	
  3850	  template<typename _Out, typename... _Args>
  3851	    requires output_iterator<_Out, const char&>
  3852	    inline _Out
  3853	    format_to(_Out __out, format_string<_Args...> __fmt, _Args&&... __args)
  3854	    {
  3855	      return std::vformat_to(std::move(__out), __fmt.get(),
  3856				     std::make_format_args(__args...));
  3857	    }
  3858	
  3859	  template<typename _Out, typename... _Args>
  3860	    requires output_iterator<_Out, const wchar_t&>
  3861	    inline _Out
  3862	    format_to(_Out __out, wformat_string<_Args...> __fmt, _Args&&... __args)
  3863	    {
  3864	      return std::vformat_to(std::move(__out), __fmt.get(),
  3865				     std::make_wformat_args(__args...));
  3866	    }
  3867	
  3868	  template<typename _Out, typename... _Args>
  3869	    requires output_iterator<_Out, const char&>
  3870	    inline _Out
  3871	    format_to(_Out __out, const locale& __loc, format_string<_Args...> __fmt,
  3872		      _Args&&... __args)
  3873	    {
  3874	      return std::vformat_to(std::move(__out), __loc, __fmt.get(),
  3875				     std::make_format_args(__args...));
  3876	    }
  3877	
  3878	  template<typename _Out, typename... _Args>
  3879	    requires output_iterator<_Out, const wchar_t&>
  3880	    inline _Out
  3881	    format_to(_Out __out, const locale& __loc, wformat_string<_Args...> __fmt,
  3882		      _Args&&... __args)
  3883	    {
  3884	      return std::vformat_to(std::move(__out), __loc, __fmt.get(),
  3885				     std::make_wformat_args(__args...));
  3886	    }
  3887	
  3888	  template<typename _Out, typename... _Args>
  3889	    requires output_iterator<_Out, const char&>
  3890	    inline format_to_n_result<_Out>
  3891	    format_to_n(_Out __out, iter_difference_t<_Out> __n,
  3892			format_string<_Args...> __fmt, _Args&&... __args)
  3893	    {
  3894	      __format::_Iter_sink<char, _Out> __sink(std::move(__out), __n);
  3895	      std::vformat_to(__sink.out(), __fmt.get(),
  3896			      std::make_format_args(__args...));
  3897	      return std::move(__sink)._M_finish();
  3898	    }
  3899	
  3900	  template<typename _Out, typename... _Args>
  3901	    requires output_iterator<_Out, const wchar_t&>
  3902	    inline format_to_n_result<_Out>
  3903	    format_to_n(_Out __out, iter_difference_t<_Out> __n,
  3904			wformat_string<_Args...> __fmt, _Args&&... __args)
  3905	    {
  3906	      __format::_Iter_sink<wchar_t, _Out> __sink(std::move(__out), __n);
  3907	      std::vformat_to(__sink.out(), __fmt.get(),
  3908			      std::make_wformat_args(__args...));
  3909	      return std::move(__sink)._M_finish();
  3910	    }
  3911	
  3912	  template<typename _Out, typename... _Args>
  3913	    requires output_iterator<_Out, const char&>
  3914	    inline format_to_n_result<_Out>
  3915	    format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
  3916			format_string<_Args...> __fmt, _Args&&... __args)
  3917	    {
  3918	      __format::_Iter_sink<char, _Out> __sink(std::move(__out), __n);
  3919	      std::vformat_to(__sink.out(), __loc, __fmt.get(),
  3920			      std::make_format_args(__args...));
  3921	      return std::move(__sink)._M_finish();
  3922	    }
  3923	
  3924	  template<typename _Out, typename... _Args>
  3925	    requires output_iterator<_Out, const wchar_t&>
  3926	    inline format_to_n_result<_Out>
  3927	    format_to_n(_Out __out, iter_difference_t<_Out> __n, const locale& __loc,
  3928			wformat_string<_Args...> __fmt, _Args&&... __args)
  3929	    {
  3930	      __format::_Iter_sink<wchar_t, _Out> __sink(std::move(__out), __n);
  3931	      std::vformat_to(__sink.out(), __loc, __fmt.get(),
  3932			      std::make_wformat_args(__args...));
  3933	      return std::move(__sink)._M_finish();
  3934	    }
  3935	
  3936	/// @cond undocumented
  3937	namespace __format
  3938	{
  3939	#if 1
  3940	  template<typename _CharT>
  3941	    class _Counting_sink final : public _Iter_sink<_CharT, _CharT*>
  3942	    {
  3943	    public:
  3944	      _Counting_sink() : _Iter_sink<_CharT, _CharT*>(nullptr, 0) { }
  3945	
  3946	      [[__gnu__::__always_inline__]]
  3947	      size_t
  3948	      count() const
  3949	      { return this->_M_count + this->_M_used().size(); }
  3950	    };
  3951	#else
  3952	  template<typename _CharT>
  3953	    class _Counting_sink : public _Buf_sink<_CharT>
  3954	    {
  3955	      size_t _M_count = 0;
  3956	
  3957	      void
  3958	      _M_overflow() override
  3959	      {
  3960		if (!std::is_constant_evaluated())
  3961		  _M_count += this->_M_used().size();
  3962		this->_M_rewind();
  3963	      }
  3964	
  3965	    public:
  3966	      _Counting_sink() = default;
  3967	
  3968	      [[__gnu__::__always_inline__]]
  3969	      size_t
  3970	      count() noexcept
  3971	      {
  3972		_Counting_sink::_M_overflow();
  3973		return _M_count;
  3974	      }
  3975	    };
  3976	#endif
  3977	} // namespace __format
  3978	/// @endcond
  3979	
  3980	  template<typename... _Args>
  3981	    [[nodiscard]]
  3982	    inline size_t
  3983	    formatted_size(format_string<_Args...> __fmt, _Args&&... __args)
  3984	    {
  3985	      __format::_Counting_sink<char> __buf;
  3986	      std::vformat_to(__buf.out(), __fmt.get(),
  3987			      std::make_format_args(__args...));
  3988	      return __buf.count();
  3989	    }
  3990	
  3991	  template<typename... _Args>
  3992	    [[nodiscard]]
  3993	    inline size_t
  3994	    formatted_size(wformat_string<_Args...> __fmt, _Args&&... __args)
  3995	    {
  3996	      __format::_Counting_sink<wchar_t> __buf;
  3997	      std::vformat_to(__buf.out(), __fmt.get(),
  3998			      std::make_wformat_args(__args...));
  3999	      return __buf.count();
  4000	    }
  4001	
  4002	  template<typename... _Args>
  4003	    [[nodiscard]]
  4004	    inline size_t
  4005	    formatted_size(const locale& __loc, format_string<_Args...> __fmt,
  4006			   _Args&&... __args)
  4007	    {
  4008	      __format::_Counting_sink<char> __buf;
  4009	      std::vformat_to(__buf.out(), __loc, __fmt.get(),
  4010			      std::make_format_args(__args...));
  4011	      return __buf.count();
  4012	    }
  4013	
  4014	  template<typename... _Args>
  4015	    [[nodiscard]]
  4016	    inline size_t
  4017	    formatted_size(const locale& __loc, wformat_string<_Args...> __fmt,
  4018			   _Args&&... __args)
  4019	    {
  4020	      __format::_Counting_sink<wchar_t> __buf;
  4021	      std::vformat_to(__buf.out(), __loc, __fmt.get(),
  4022			      std::make_wformat_args(__args...));
  4023	      return __buf.count();
  4024	    }
  4025	
  4026	#if __cpp_lib_format_ranges
  4027	  // [format.range], formatting of ranges
  4028	  // [format.range.fmtkind], variable template format_kind
  4029	  enum class range_format {
  4030	    disabled,
  4031	    map,
  4032	    set,
  4033	    sequence,
  4034	    string,
  4035	    debug_string
  4036	  };
  4037	
  4038	  /// @cond undocumented
  4039	  template<typename _Rg>
  4040	    constexpr auto format_kind = not defined(format_kind<_Rg>);
  4041	
  4042	  template<typename _Tp>
  4043	    consteval range_format
  4044	    __fmt_kind()
  4045	    {
  4046	      using _Ref = ranges::range_reference_t<_Tp>;
  4047	      if constexpr (is_same_v<remove_cvref_t<_Ref>, _Tp>)
  4048		return range_format::disabled;
  4049	      else if constexpr (requires { typename _Tp::key_type; })
  4050		{
  4051		  if constexpr (requires { typename _Tp::mapped_type; })
  4052		    {
  4053		      using _Up = remove_cvref_t<_Ref>;
  4054		      if constexpr (__is_pair<_Up>)
  4055			return range_format::map;
  4056		      else if constexpr (__is_specialization_of<_Up, tuple>)
  4057			if constexpr (tuple_size_v<_Up> == 2)
  4058			  return range_format::map;
  4059		    }
  4060		  return range_format::set;
  4061		}
  4062	      else
  4063		return range_format::sequence;
  4064	    }
  4065	  /// @endcond
  4066	
  4067	  /// A constant determining how a range should be formatted.
  4068	  template<ranges::input_range _Rg> requires same_as<_Rg, remove_cvref_t<_Rg>>
  4069	    constexpr range_format format_kind<_Rg> = __fmt_kind<_Rg>();
  4070	
  4071	  // [format.range.formatter], class template range_formatter
  4072	  template<typename _Tp, typename _CharT = char>
  4073	    requires same_as<remove_cvref_t<_Tp>, _Tp> && formattable<_Tp, _CharT>
  4074	    class range_formatter; // TODO
  4075	
  4076	/// @cond undocumented
  4077	namespace __format
  4078	{
  4079	  // [format.range.fmtdef], class template range-default-formatter
  4080	  template<range_format _Kind, ranges::input_range _Rg, typename _CharT>
  4081	    struct __range_default_formatter; // TODO
  4082	} // namespace __format
  4083	/// @endcond
  4084	
  4085	  // [format.range.fmtmap], [format.range.fmtset], [format.range.fmtstr],
  4086	  // specializations for maps, sets, and strings
  4087	  template<ranges::input_range _Rg, typename _CharT>
  4088	    requires (format_kind<_Rg> != range_format::disabled)
  4089	      && formattable<ranges::range_reference_t<_Rg>, _CharT>
  4090	    struct formatter<_Rg, _CharT>
  4091	    : __format::__range_default_formatter<format_kind<_Rg>, _Rg, _CharT>
  4092	    { };
  4093	#endif // C++23 formatting ranges
  4094	
  4095	_GLIBCXX_END_NAMESPACE_VERSION
  4096	} // namespace std
  4097	#endif // C++20
  4098	#endif // _GLIBCXX_FORMAT