{

if constexpr (is_same_v<_CharT, wchar_t>)

return __wide;

else

return __narrow;

{

[[__gnu__::__always_inline__]]

_GLIBCXX_CONSTEXPR_FORMAT

_Dynamic_format_string(basic_string_view<_CharT> __s) noexcept

: _M_str(__s) { }

_Dynamic_format_string(const _Dynamic_format_string&) = delete;

void operator=(const _Dynamic_format_string&) = delete;

private:

basic_string_view<_CharT> _M_str;

template<typename, typename...> friend struct std::basic_format_string;

{

template<typename _Tp>

requires convertible_to<const _Tp&, basic_string_view<_CharT>>

consteval

basic_format_string(const _Tp& __s) noexcept;

[[__gnu__::__always_inline__]]

_GLIBCXX_CONSTEXPR_FORMAT

basic_format_string(__format::_Dynamic_format_string<_CharT> __s) noexcept

: _M_str(__s._M_str)

{ }

[[__gnu__::__always_inline__]]

constexpr basic_string_view<_CharT>

get() const noexcept

{ return _M_str; }

private:

basic_string_view<_CharT> _M_str;

{

formatter() = delete; // No std::formatter specialization for this type.

formatter(const formatter&) = delete;

formatter& operator=(const formatter&) = delete;

{

public:

_GLIBCXX_CONSTEXPR_FORMAT

explicit format_error(const string& __what)

: runtime_error(__what) { }

_GLIBCXX_CONSTEXPR_FORMAT explicit

format_error(const char* __what)

: runtime_error(__what) { }

{

public:

using char_type = _CharT;

using const_iterator = typename basic_string_view<_CharT>::const_iterator;

using iterator = const_iterator;

constexpr explicit

basic_format_parse_context(basic_string_view<_CharT> __fmt) noexcept

: _M_begin(__fmt.begin()), _M_end(__fmt.end())

{ }

basic_format_parse_context(const basic_format_parse_context&) = delete;

void operator=(const basic_format_parse_context&) = delete;

constexpr const_iterator begin() const noexcept { return _M_begin; }

constexpr const_iterator end() const noexcept { return _M_end; }

constexpr void

advance_to(const_iterator __it) noexcept

{ _M_begin = __it; }

constexpr size_t

next_arg_id()

{

if (_M_indexing == _Manual)

__format::__conflicting_indexing_in_format_string();

_M_indexing = _Auto;

// _GLIBCXX_RESOLVE_LIB_DEFECTS

// 3825. Missing compile-time argument id check in next_arg_id

if (std::is_constant_evaluated())

if (_M_next_arg_id == _M_num_args)

__format::__invalid_arg_id_in_format_string();

return _M_next_arg_id++;

}

constexpr void

check_arg_id(size_t __id)

{

if (_M_indexing == _Auto)

__format::__conflicting_indexing_in_format_string();

_M_indexing = _Manual;

if (std::is_constant_evaluated())

if (__id >= _M_num_args)

__format::__invalid_arg_id_in_format_string();

}

#if __cpp_lib_format >= 202305L

template<typename... _Ts>

constexpr void

check_dynamic_spec(size_t __id) noexcept

{

static_assert(__valid_types_for_check_dynamic_spec<_Ts...>(),

"template arguments for check_dynamic_spec<Ts...>(id) "

"must be unique and must be one of the allowed types");

if consteval {

__check_dynamic_spec<_Ts...>(__id);

}

}

constexpr void

check_dynamic_spec_integral(size_t __id) noexcept

{

if consteval {

__check_dynamic_spec<int, unsigned, long long,

unsigned long long>(__id);

}

}

constexpr void

check_dynamic_spec_string(size_t __id) noexcept

{

if consteval {

__check_dynamic_spec<const _CharT*, basic_string_view<_CharT>>(__id);

}

}

private:

// True if _Tp occurs exactly once in _Ts.

template<typename _Tp, typename... _Ts>

static constexpr bool __once = (is_same_v<_Tp, _Ts> + ...) == 1;

template<typename... _Ts>

consteval bool

__valid_types_for_check_dynamic_spec()

{

// _GLIBCXX_RESOLVE_LIB_DEFECTS

// 4142. check_dynamic_spec should require at least one type

if constexpr (sizeof...(_Ts) == 0)

return false;

else

{

// The types in Ts... are unique. Each type in Ts... is one of

// bool, char_type, int, unsigned int, long long int,

// unsigned long long int, float, double, long double,

// const char_type*, basic_string_view<char_type>, or const void*.

unsigned __sum

= __once<bool, _Ts...>

+ __once<char_type, _Ts...>

+ __once<int, _Ts...>

+ __once<unsigned int, _Ts...>

+ __once<long long int, _Ts...>

+ __once<unsigned long long int, _Ts...>

+ __once<float, _Ts...>

+ __once<double, _Ts...>

+ __once<long double, _Ts...>

+ __once<const char_type*, _Ts...>

+ __once<basic_string_view<char_type>, _Ts...>

+ __once<const void*, _Ts...>;

return __sum == sizeof...(_Ts);

}

}

template<typename... _Ts>

consteval void

__check_dynamic_spec(size_t __id) noexcept;

// This must not be constexpr.

static void __invalid_dynamic_spec(const char*);

friend __format::_Scanner<_CharT>;

#endif

// This constructor should only be used by the implementation.

constexpr explicit

basic_format_parse_context(basic_string_view<_CharT> __fmt,

size_t __num_args) noexcept

: _M_begin(__fmt.begin()), _M_end(__fmt.end()), _M_num_args(__num_args)

{ }

private:

iterator _M_begin;

iterator _M_end;

enum _Indexing { _Unknown, _Manual, _Auto };

_Indexing _M_indexing = _Unknown;

size_t _M_next_arg_id = 0;

size_t _M_num_args = 0;

{

if (__first == __last)

__builtin_unreachable();

if constexpr (is_same_v<_CharT, char>)

{

const auto __start = __first;

unsigned short __val = 0;

// N.B. std::from_chars is not constexpr in C++20.

if (__detail::__from_chars_alnum<true>(__first, __last, __val, 10)

&& __first != __start) [[likely]]

return {__val, __first};

}

else

{

constexpr int __n = 32;

char __buf[__n]{};

for (int __i = 0; __i < __n && (__first + __i) != __last; ++__i)

__buf[__i] = __first[__i];

auto [__v, __ptr] = __format::__parse_integer(__buf, __buf + __n);

if (__ptr) [[likely]]

return {__v, __first + (__ptr - __buf)};

}

return {0, nullptr};

{

if (__first == __last)

__builtin_unreachable();

if (*__first == '0')

return {0, __first + 1}; // No leading zeros allowed, so '0...' == 0

if ('1' <= *__first && *__first <= '9')

{

const unsigned short __id = *__first - '0';

const auto __next = __first + 1;

// Optimize for most likely case of single digit arg-id.

if (__next == __last || !('0' <= *__next && *__next <= '9'))

return {__id, __next};

else

return __format::__parse_integer(__first, __last);

}

return {0, nullptr};

_Pres_none = 0, // Default type (not valid for integer presentation types).

_Pres_s = 1, // For strings, bool, ranges

// Presentation types for integral types (including bool and charT).

_Pres_c = 2, _Pres_x, _Pres_X, _Pres_d, _Pres_o, _Pres_b, _Pres_B,

// Presentation types for floating-point types

_Pres_g = 1, _Pres_G, _Pres_a, _Pres_A, _Pres_e, _Pres_E, _Pres_f, _Pres_F,

_Pres_p, _Pres_P,

_Pres_max = 0xf,

_Sign_default,

_Sign_plus,

_Sign_minus, // XXX does this need to be distinct from _Sign_default?

_Sign_space,

_WP_none, // No width/prec specified.

_WP_value, // Fixed width/prec specified.

_WP_from_arg // Use a formatting argument for width/prec.

{

unsigned short _M_width;

unsigned short _M_prec;

char32_t _M_fill = ' ';

_Align _M_align : 2;

_Sign _M_sign : 2;

unsigned _M_alt : 1;

unsigned _M_localized : 1;

unsigned _M_zero_fill : 1;

_WidthPrec _M_width_kind : 2;

_WidthPrec _M_prec_kind : 2;

unsigned _M_debug : 1;

_Pres_type _M_type : 4;

unsigned _M_reserved : 8;

// This class has 8 bits of tail padding, that can be used by

// derived classes.

using iterator = typename basic_string_view<_CharT>::iterator;

static constexpr _Align

_S_align(_CharT __c) noexcept

{

switch (__c)

{

case '<': return _Align_left;

case '>': return _Align_right;

case '^': return _Align_centre;

default: return _Align_default;

}

}

// pre: __first != __last

constexpr iterator

_M_parse_fill_and_align(iterator __first, iterator __last) noexcept

{ return _M_parse_fill_and_align(__first, __last, "{"); }

// pre: __first != __last

constexpr iterator

_M_parse_fill_and_align(iterator __first, iterator __last, string_view __not_fill) noexcept

{

for (char __c : __not_fill)

if (*__first == static_cast<_CharT>(__c))

return __first;

using namespace __unicode;

if constexpr (__literal_encoding_is_unicode<_CharT>())

{

// Accept any UCS scalar value as fill character.

_Utf32_view<ranges::subrange<iterator>> __uv({__first, __last});

if (!__uv.empty())

{

auto __beg = __uv.begin();

char32_t __c = *__beg++;

if (__is_scalar_value(__c))

if (auto __next = __beg.base(); __next != __last)

if (_Align __align = _S_align(*__next); __align != _Align_default)

{

_M_fill = __c;

_M_align = __align;

return ++__next;

}

}

}

else if (__last - __first >= 2)

if (_Align __align = _S_align(__first[1]); __align != _Align_default)

{

_M_fill = *__first;

_M_align = __align;

return __first + 2;

}

if (_Align __align = _S_align(__first[0]); __align != _Align_default)

{

_M_fill = ' ';

_M_align = __align;

return __first + 1;

}

return __first;

}

static constexpr _Sign

_S_sign(_CharT __c) noexcept

{

switch (__c)

{

case '+': return _Sign_plus;

case '-': return _Sign_minus;

case ' ': return _Sign_space;

default: return _Sign_default;

}

}

// pre: __first != __last

constexpr iterator

_M_parse_sign(iterator __first, iterator) noexcept

{

if (_Sign __sign = _S_sign(*__first); __sign != _Sign_default)

{

_M_sign = __sign;

return __first + 1;

}

return __first;

}

// pre: *__first is valid

constexpr iterator

_M_parse_alternate_form(iterator __first, iterator) noexcept

{

if (*__first == '#')

{

_M_alt = true;

++__first;

}

return __first;

}

// pre: __first != __last

constexpr iterator

_M_parse_zero_fill(iterator __first, iterator /* __last */) noexcept

{

if (*__first == '0')

{

_M_zero_fill = true;

++__first;

}

return __first;

}

// pre: __first != __last

static constexpr iterator

_S_parse_width_or_precision(iterator __first, iterator __last,

unsigned short& __val, bool& __arg_id,

basic_format_parse_context<_CharT>& __pc)

{

if (__format::__is_digit(*__first))

{

auto [__v, __ptr] = __format::__parse_integer(__first, __last);

if (!__ptr)

__throw_format_error("format error: invalid width or precision "

"in format-spec");

__first = __ptr;

__val = __v;

}

else if (*__first == '{')

{

__arg_id = true;

++__first;

if (__first == __last)

__format::__unmatched_left_brace_in_format_string();

if (*__first == '}')

__val = __pc.next_arg_id();

else

{

auto [__v, __ptr] = __format::__parse_arg_id(__first, __last);

if (__ptr == nullptr || __ptr == __last || *__ptr != '}')

__format::__invalid_arg_id_in_format_string();

__first = __ptr;

__pc.check_arg_id(__v);

__val = __v;

}

#if __cpp_lib_format >= 202305L

__pc.check_dynamic_spec_integral(__val);

#endif

++__first; // past the '}'

}

return __first;

}

// pre: __first != __last

constexpr iterator

_M_parse_width(iterator __first, iterator __last,

basic_format_parse_context<_CharT>& __pc)

{

bool __arg_id = false;

if (*__first == '0')

__throw_format_error("format error: width must be non-zero in "

"format string");

auto __next = _S_parse_width_or_precision(__first, __last, _M_width,

__arg_id, __pc);

if (__next != __first)

_M_width_kind = __arg_id ? _WP_from_arg : _WP_value;

return __next;

}

// pre: __first != __last

constexpr iterator

_M_parse_precision(iterator __first, iterator __last,

basic_format_parse_context<_CharT>& __pc)

{

if (__first[0] != '.')

return __first;

iterator __next = ++__first;

bool __arg_id = false;

if (__next != __last)

__next = _S_parse_width_or_precision(__first, __last, _M_prec,

__arg_id, __pc);

if (__next == __first)

__throw_format_error("format error: missing precision after '.' in "

"format string");

_M_prec_kind = __arg_id ? _WP_from_arg : _WP_value;

return __next;

}

// pre: __first != __last

constexpr iterator

_M_parse_locale(iterator __first, iterator /* __last */) noexcept

{

if (*__first == 'L')

{

_M_localized = true;

++__first;

}

return __first;

}

template<typename _Context>

_GLIBCXX_CONSTEXPR_FORMAT size_t

_M_get_width(_Context& __ctx) const

{

size_t __width = 0;

if (_M_width_kind == _WP_value)

__width = _M_width;

else if (_M_width_kind == _WP_from_arg)

__width = __format::__int_from_arg(__ctx.arg(_M_width));

return __width;

}

template<typename _Context>

_GLIBCXX_CONSTEXPR_FORMAT size_t

_M_get_precision(_Context& __ctx) const

{

size_t __prec = -1;

if (_M_prec_kind == _WP_value)

__prec = _M_prec;

else if (_M_prec_kind == _WP_from_arg)

__prec = __format::__int_from_arg(__ctx.arg(_M_prec));

return __prec;

}

{

if constexpr (is_same_v<_Out, _Sink_iter<_CharT>>)

{

if (__str.size())

__out = __str;

}

else

for (_CharT __c : __str)

*__out++ = __c;

return __out;

_Align __align, size_t __nfill, char32_t __fill_char)

{

const size_t __buflen = 0x20;

_CharT __padding_chars[__buflen];

__padding_chars[0] = _CharT();

basic_string_view<_CharT> __padding{__padding_chars, __buflen};

auto __pad = [&__padding] (size_t __n, _Out& __o) {

if (__n == 0)

return;

while (__n > __padding.size())

{

__o = __format::__write(std::move(__o), __padding);

__n -= __padding.size();

}

if (__n != 0)

__o = __format::__write(std::move(__o), __padding.substr(0, __n));

};

size_t __l, __r, __max;

if (__align == _Align_centre)

{

__l = __nfill / 2;

__r = __l + (__nfill & 1);

__max = __r;

}

else if (__align == _Align_right)

{

__l = __nfill;

__r = 0;

__max = __l;

}

else

{

__l = 0;

__r = __nfill;

__max = __r;

}

using namespace __unicode;

if constexpr (__literal_encoding_is_unicode<_CharT>())

if (!__is_single_code_unit<_CharT>(__fill_char)) [[unlikely]]

{

// Encode fill char as multiple code units of type _CharT.

const char32_t __arr[1]{ __fill_char };

_Utf_view<_CharT, span<const char32_t, 1>> __v(__arr);

basic_string<_CharT> __padstr(__v.begin(), __v.end());

__padding = __padstr;

while (__l-- > 0)

__out = __format::__write(std::move(__out), __padding);

__out = __format::__write(std::move(__out), __str);

while (__r-- > 0)

__out = __format::__write(std::move(__out), __padding);

return __out;

}

if (__max < __buflen)

__padding.remove_suffix(__buflen - __max);

else

__max = __buflen;

char_traits<_CharT>::assign(__padding_chars, __max, __fill_char);

__pad(__l, __out);

__out = __format::__write(std::move(__out), __str);

__pad(__r, __out);

return __out;

size_t __estimated_width,

basic_format_context<_Out, _CharT>& __fc,

const _Spec<_CharT>& __spec,

_Align __align = _Align_left)

{

size_t __width = __spec._M_get_width(__fc);

if (__width <= __estimated_width)

return __format::__write(__fc.out(), __str);

const size_t __nfill = __width - __estimated_width;

if (__spec._M_align != _Align_default)

__align = __spec._M_align;

return __format::__write_padded(__fc.out(), __str, __align, __nfill,

__spec._M_fill);

{

if constexpr (__unicode::__literal_encoding_is_unicode<_CharT>())

{

if (__prec != (size_t)-1)

return __unicode::__truncate(__s, __prec);

else

return __unicode::__field_width(__s);

}

else

{

__s = __s.substr(0, __prec);

return __s.size();

}

_Term_none,

_Term_quote,

_Term_apos,

{

using _Str_view = basic_string_view<_CharT>;

static consteval

_Str_view _S_all()

{ return _GLIBCXX_WIDEN("\t\\t\n\\n\r\\r\\\\\\\"\\\"'\\'\\u\\x"); }

static consteval

_Str_view _S_tab()

{ return _S_all().substr(0, 3); }

static consteval

_Str_view _S_newline()

{ return _S_all().substr(3, 3); }

static consteval

_Str_view _S_return()

{ return _S_all().substr(6, 3); }

static consteval

_Str_view _S_bslash()

{ return _S_all().substr(9, 3); }

static consteval

_Str_view _S_quote()

{ return _S_all().substr(12, 3); }

static consteval

_Str_view _S_apos()

{ return _S_all().substr(15, 3); }

static consteval

_Str_view _S_u()

{ return _S_all().substr(18, 2); }

static consteval

_Str_view _S_x()

{ return _S_all().substr(20, 2); }

static constexpr

_Str_view _S_term(_Term_char __term)

{

switch (__term)

{

case _Term_none:

return _Str_view();

case _Term_quote:

return _S_quote().substr(0, 1);

case _Term_apos:

return _S_apos().substr(0, 1);

}

__builtin_unreachable();

}

{

using _Str_view = basic_string_view<_CharT>;

static consteval

_Str_view _S_all()

{ return _GLIBCXX_WIDEN("[]{}(), : "); }

static consteval

_Str_view _S_squares()

{ return _S_all().substr(0, 2); }