include/__format/formatter_integral.h - llvm-project/libcxx - Git at Google

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//

 #ifndef _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H
 #define _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H

 #include <__config>
 #include <__format/format_error.h>
 #include <__format/format_fwd.h>
 #include <__format/formatter.h>
 #include <__format/parser_std_format_spec.h>
 #include <__algorithm/copy.h>
 #include <__algorithm/copy_n.h>
 #include <__algorithm/fill_n.h>
 #include <__algorithm/transform.h>
 #include <array>
 #include <charconv>
 #include <concepts>
 #include <limits>
 #include <string>

 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
 #include <locale>
 #endif

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif

 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>

 _LIBCPP_BEGIN_NAMESPACE_STD

 #if _LIBCPP_STD_VER > 17

 // TODO FMT Remove this once we require compilers with proper C++20 support.
 // If the compiler has no concepts support, the format header will be disabled.
 // Without concepts support enable_if needs to be used and that too much effort
 // to support compilers with partial C++20 support.
 #if !defined(_LIBCPP_HAS_NO_CONCEPTS)

 /**
  * Integral formatting classes.
  *
  * There are two types used here:
  * * C++-type, the type as used in C++.
  * * format-type, the output type specified in the std-format-spec.
  *
  * Design of the integral formatters consists of several layers.
  * * @ref __parser_integral The basic std-format-spec parser for all integral
  *   classes. This parser does the basic sanity checks. It also contains some
  *   helper functions that are nice to have available for all parsers.
  * * A C++-type specific parser. These parsers must derive from
  *   @ref __parser_integral. Their task is to validate whether the parsed
  *   std-format-spec is valid for the C++-type and selected format-type. After
  *   validation they need to make sure all members are properly set. For
  *   example, when the alignment hasn't changed it needs to set the proper
  *   default alignment for the format-type. The following parsers are available:
  *   - @ref __parser_integer
  *   - @ref __parser_char
  *   - @ref __parser_bool
  * * A general formatter for all integral types @ref __formatter_integral. This
  *   formatter can handle all formatting of integers and characters. The class
  *   derives from the proper formatter.
  *   Note the boolean string format-type isn't supported in this class.
  * * A typedef C++-type group combining the @ref __formatter_integral with a
  *   parser:
  *   * @ref __formatter_integer
  *   * @ref __formatter_char
  *   * @ref __formatter_bool
  * * Then every C++-type has its own formatter specializations. They inherit
  *   from the C++-type group typedef. Most specializations need nothing else.
  *   Others need some additional specializations in this class.
  */
 namespace __format_spec {

 /** Wrapper around @ref to_chars, returning the output pointer. */
 template <class _Tp>
 _LIBCPP_HIDE_FROM_ABI char* __to_buffer(char* __first, char* __last,
                                         _Tp __value, int __base) {
   // TODO FMT Evaluate code overhead due to not calling the internal function
   // directly. (Should be zero overhead.)
   to_chars_result __r = _VSTD::to_chars(__first, __last, __value, __base);
   _LIBCPP_ASSERT(__r.ec == errc(0), "Internal buffer too small");
   return __r.ptr;
 }

 /**
  * Helper to determine the buffer size to output a integer in Base @em x.
  *
  * There are several overloads for the supported bases. The function uses the
  * base as template argument so it can be used in a constant expression.
  */
 template <unsigned_integral _Tp, size_t _Base>
 _LIBCPP_HIDE_FROM_ABI constexpr size_t __buffer_size() noexcept
     requires(_Base == 2) {
   return numeric_limits<_Tp>::digits // The number of binary digits.
          + 2                         // Reserve space for the '0[Bb]' prefix.
          + 1;                        // Reserve space for the sign.
 }

 template <unsigned_integral _Tp, size_t _Base>
 _LIBCPP_HIDE_FROM_ABI constexpr size_t __buffer_size() noexcept
     requires(_Base == 8) {
   return numeric_limits<_Tp>::digits // The number of binary digits.
              / 3                     // Adjust to octal.
          + 1                         // Turn floor to ceil.
          + 1                         // Reserve space for the '0' prefix.
          + 1;                        // Reserve space for the sign.
 }

 template <unsigned_integral _Tp, size_t _Base>
 _LIBCPP_HIDE_FROM_ABI constexpr size_t __buffer_size() noexcept
     requires(_Base == 10) {
   return numeric_limits<_Tp>::digits10 // The floored value.
          + 1                           // Turn floor to ceil.
          + 1;                          // Reserve space for the sign.
 }

 template <unsigned_integral _Tp, size_t _Base>
 _LIBCPP_HIDE_FROM_ABI constexpr size_t __buffer_size() noexcept
     requires(_Base == 16) {
   return numeric_limits<_Tp>::digits // The number of binary digits.
              / 4                     // Adjust to hexadecimal.
          + 2                         // Reserve space for the '0[Xx]' prefix.
          + 1;                        // Reserve space for the sign.
 }

 /**
  * Determines the required grouping based on the size of the input.
  *
  * The grouping's last element will be repeated. For simplicity this repeating
  * is unwrapped based on the length of the input. (When the input is short some
  * groups are not processed.)
  *
  * @returns The size of the groups to write. This means the number of
  * separator characters written is size() - 1.
  *
  * @note Since zero-sized groups cause issues they are silently ignored.
  *
  * @note The grouping field of the locale is always a @c std::string,
  * regardless whether the @c std::numpunct's type is @c char or @c wchar_t.
  */
 _LIBCPP_HIDE_FROM_ABI inline string
 __determine_grouping(ptrdiff_t __size, const string& __grouping) {
   _LIBCPP_ASSERT(!__grouping.empty() && __size > __grouping[0],
                  "The slow grouping formatting is used while there will be no "
                  "separators written");
   string __r;
   auto __end = __grouping.end() - 1;
   auto __ptr = __grouping.begin();

   while (true) {
     __size -= *__ptr;
     if (__size > 0)
       __r.push_back(*__ptr);
     else {
       // __size <= 0 so the value pushed will be <= *__ptr.
       __r.push_back(*__ptr + __size);
       return __r;
     }

     // Proceed to the next group.
     if (__ptr != __end) {
       do {
         ++__ptr;
         // Skip grouping with a width of 0.
       } while (*__ptr == 0 && __ptr != __end);
     }
   }

   _LIBCPP_UNREACHABLE();
 }

 template <class _Parser>
 requires __formatter::__char_type<typename _Parser::char_type>
 class _LIBCPP_TEMPLATE_VIS __formatter_integral : public _Parser {
 public:
   using _CharT = typename _Parser::char_type;

   template <integral _Tp>
   _LIBCPP_HIDE_FROM_ABI auto format(_Tp __value, auto& __ctx)
       -> decltype(__ctx.out()) {
     if (this->__width_needs_substitution())
       this->__substitute_width_arg_id(__ctx.arg(this->__width));

     if (this->__type == _Flags::_Type::__char)
       return __format_as_char(__value, __ctx);

     if constexpr (unsigned_integral<_Tp>)
       return __format_unsigned_integral(__value, false, __ctx);
     else {
       // Depending on the std-format-spec string the sign and the value
       // might not be outputted together:
       // - alternate form may insert a prefix string.
       // - zero-padding may insert additional '0' characters.
       // Therefore the value is processed as a positive unsigned value.
       // The function @ref __insert_sign will a '-' when the value was negative.
       auto __r = __to_unsigned_like(__value);
       bool __negative = __value < 0;
       if (__negative)
         __r = __complement(__r);

       return __format_unsigned_integral(__r, __negative, __ctx);
     }
   }

 private:
   /** Generic formatting for format-type c. */
   _LIBCPP_HIDE_FROM_ABI auto __format_as_char(integral auto __value,
                                               auto& __ctx)
       -> decltype(__ctx.out()) {
     if (this->__alignment == _Flags::_Alignment::__default)
       this->__alignment = _Flags::_Alignment::__right;

     using _Tp = decltype(__value);
     if constexpr (!same_as<_CharT, _Tp>) {
       // cmp_less and cmp_greater can't be used for character types.
       if constexpr (signed_integral<_CharT> == signed_integral<_Tp>) {
         if (__value < numeric_limits<_CharT>::min() ||
             __value > numeric_limits<_CharT>::max())
           __throw_format_error(
               "Integral value outside the range of the char type");
       } else if constexpr (signed_integral<_CharT>) {
         // _CharT is signed _Tp is unsigned
         if (__value >
             static_cast<make_unsigned_t<_CharT>>(numeric_limits<_CharT>::max()))
           __throw_format_error(
               "Integral value outside the range of the char type");
       } else {
         // _CharT is unsigned _Tp is signed
         if (__value < 0 || static_cast<make_unsigned_t<_Tp>>(__value) >
                                numeric_limits<_CharT>::max())
           __throw_format_error(
               "Integral value outside the range of the char type");
       }
     }

     const auto __c = static_cast<_CharT>(__value);
     return __write(_VSTD::addressof(__c), _VSTD::addressof(__c) + 1,
                    __ctx.out());
   }

   /**
    * Generic formatting for format-type bBdoxX.
    *
    * This small wrapper allocates a buffer with the required size. Then calls
    * the real formatter with the buffer and the prefix for the base.
    */
   _LIBCPP_HIDE_FROM_ABI auto
   __format_unsigned_integral(unsigned_integral auto __value, bool __negative,
                              auto& __ctx) -> decltype(__ctx.out()) {
     switch (this->__type) {
     case _Flags::_Type::__binary_lower_case: {
       array<char, __buffer_size<decltype(__value), 2>()> __array;
       return __format_unsigned_integral(__array.begin(), __array.end(), __value,
                                         __negative, 2, __ctx, "0b");
     }
     case _Flags::_Type::__binary_upper_case: {
       array<char, __buffer_size<decltype(__value), 2>()> __array;
       return __format_unsigned_integral(__array.begin(), __array.end(), __value,
                                         __negative, 2, __ctx, "0B");
     }
     case _Flags::_Type::__octal: {
       // Octal is special; if __value == 0 there's no prefix.
       array<char, __buffer_size<decltype(__value), 8>()> __array;
       return __format_unsigned_integral(__array.begin(), __array.end(), __value,
                                         __negative, 8, __ctx,
                                         __value != 0 ? "0" : nullptr);
     }
     case _Flags::_Type::__decimal: {
       array<char, __buffer_size<decltype(__value), 10>()> __array;
       return __format_unsigned_integral(__array.begin(), __array.end(), __value,
                                         __negative, 10, __ctx, nullptr);
     }
     case _Flags::_Type::__hexadecimal_lower_case: {
       array<char, __buffer_size<decltype(__value), 16>()> __array;
       return __format_unsigned_integral(__array.begin(), __array.end(), __value,
                                         __negative, 16, __ctx, "0x");
     }
     case _Flags::_Type::__hexadecimal_upper_case: {
       array<char, __buffer_size<decltype(__value), 16>()> __array;
       return __format_unsigned_integral(__array.begin(), __array.end(), __value,
                                         __negative, 16, __ctx, "0X");
     }
     default:
       _LIBCPP_ASSERT(false, "The parser should have validated the type");
       _LIBCPP_UNREACHABLE();
     }
   }

   template <class _Tp>
   requires(same_as<char, _Tp> || same_as<wchar_t, _Tp>) _LIBCPP_HIDE_FROM_ABI
       auto __write(const _Tp* __first, const _Tp* __last, auto __out_it)
           -> decltype(__out_it) {

     unsigned __size = __last - __first;
     if (this->__type != _Flags::_Type::__hexadecimal_upper_case) [[likely]] {
       if (__size >= this->__width)
         return _VSTD::copy(__first, __last, _VSTD::move(__out_it));

       return __formatter::__write(_VSTD::move(__out_it), __first, __last,
                                   __size, this->__width, this->__fill,
                                   this->__alignment);
     }

     // this->__type == _Flags::_Type::__hexadecimal_upper_case
     // This means all characters in the range [a-f] need to be changed to their
     // uppercase representation. The transformation is done as transformation
     // in the output routine instead of before. This avoids another pass over
     // the data.
     // TODO FMT See whether it's possible to do this transformation during the
     // conversion. (This probably requires changing std::to_chars' alphabet.)
     if (__size >= this->__width)
       return _VSTD::transform(__first, __last, _VSTD::move(__out_it),
                               __hex_to_upper);

     return __formatter::__write(_VSTD::move(__out_it), __first, __last, __size,
                                 __hex_to_upper, this->__width, this->__fill,
                                 this->__alignment);
   }

   _LIBCPP_HIDE_FROM_ABI auto
   __format_unsigned_integral(char* __begin, char* __end,
                              unsigned_integral auto __value, bool __negative,
                              int __base, auto& __ctx, const char* __prefix)
       -> decltype(__ctx.out()) {
     char* __first = __insert_sign(__begin, __negative, this->__sign);
     if (this->__alternate_form && __prefix)
       while (*__prefix)
         *__first++ = *__prefix++;

     char* __last = __to_buffer(__first, __end, __value, __base);
 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
     if (this->__locale_specific_form) {
       const auto& __np = use_facet<numpunct<_CharT>>(__ctx.locale());
       string __grouping = __np.grouping();
       ptrdiff_t __size = __last - __first;
       // Writing the grouped form has more overhead than the normal output
       // routines. If there will be no separators written the locale-specific
       // form is identical to the normal routine. Test whether to grouped form
       // is required.
       if (!__grouping.empty() && __size > __grouping[0])
         return __format_grouping(__ctx.out(), __begin, __first, __last,
                                  __determine_grouping(__size, __grouping),
                                  __np.thousands_sep());
     }
 #endif
     auto __out_it = __ctx.out();
     if (this->__alignment != _Flags::_Alignment::__default)
       __first = __begin;
     else {
       // __buf contains [sign][prefix]data
       //                              ^ location of __first
       // The zero padding is done like:
       // - Write [sign][prefix]
       // - Write data right aligned with '0' as fill character.
       __out_it = _VSTD::copy(__begin, __first, _VSTD::move(__out_it));
       this->__alignment = _Flags::_Alignment::__right;
       this->__fill = _CharT('0');
       uint32_t __size = __first - __begin;
       this->__width -= _VSTD::min(__size, this->__width);
     }

     return __write(__first, __last, _VSTD::move(__out_it));
   }

 #ifndef _LIBCPP_HAS_NO_LOCALIZATION
   /** Format's the locale-specific form's groupings. */
   template <class _OutIt, class _CharT>
   _LIBCPP_HIDE_FROM_ABI _OutIt
   __format_grouping(_OutIt __out_it, const char* __begin, const char* __first,
                     const char* __last, string&& __grouping, _CharT __sep) {

     // TODO FMT This function duplicates some functionality of the normal
     // output routines. Evaluate whether these parts can be efficiently
     // combined with the existing routines.

     unsigned __size = (__first - __begin) +    // [sign][prefix]
                       (__last - __first) +     // data
                       (__grouping.size() - 1); // number of separator characters

     __formatter::__padding_size_result __padding = {0, 0};
     if (this->__alignment == _Flags::_Alignment::__default) {
       // Write [sign][prefix].
       __out_it = _VSTD::copy(__begin, __first, _VSTD::move(__out_it));

       if (this->__width > __size) {
         // Write zero padding.
         __padding.__before = this->__width - __size;
         __out_it = _VSTD::fill_n(_VSTD::move(__out_it), this->__width - __size,
                                  _CharT('0'));
       }
     } else {
       if (this->__width > __size) {
         // Determine padding and write padding.
         __padding = __formatter::__padding_size(__size, this->__width,
                                                 this->__alignment);

         __out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before,
                                  this->__fill);
       }
       // Write [sign][prefix].
       __out_it = _VSTD::copy(__begin, __first, _VSTD::move(__out_it));
     }

     auto __r = __grouping.rbegin();
     auto __e = __grouping.rend() - 1;
     _LIBCPP_ASSERT(__r != __e, "The slow grouping formatting is used while "
                                "there will be no separators written.");
     // The output is divided in small groups of numbers to write:
     // - A group before the first separator.
     // - A separator and a group, repeated for the number of separators.
     // - A group after the last separator.
     // This loop achieves that process by testing the termination condition
     // midway in the loop.
     //
     // TODO FMT This loop evaluates the loop invariant `this->__type !=
     // _Flags::_Type::__hexadecimal_upper_case` for every iteration. (This test
     // happens in the __write call.) Benchmark whether making two loops and
     // hoisting the invariant is worth the effort.
     while (true) {
       if (this->__type == _Flags::_Type::__hexadecimal_upper_case) {
         __last = __first + *__r;
         __out_it = _VSTD::transform(__first, __last, _VSTD::move(__out_it),
                                     __hex_to_upper);
         __first = __last;
       } else {
         __out_it = _VSTD::copy_n(__first, *__r, _VSTD::move(__out_it));
         __first += *__r;
       }

       if (__r == __e)
         break;

       ++__r;
       *__out_it++ = __sep;
     }

     return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after,
                          this->__fill);
   }
 #endif // _LIBCPP_HAS_NO_LOCALIZATION
 };

 } // namespace __format_spec

 #endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)

 #endif //_LIBCPP_STD_VER > 17

 _LIBCPP_END_NAMESPACE_STD

 _LIBCPP_POP_MACROS

 #endif // _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H
	// -- C++ --
	//===----------------------------------------------------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	#ifndef _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H
	#define _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H

	#include <__config>
	#include <__format/format_error.h>
	#include <__format/format_fwd.h>
	#include <__format/formatter.h>
	#include <__format/parser_std_format_spec.h>
	#include <__algorithm/copy.h>
	#include <__algorithm/copy_n.h>
	#include <__algorithm/fill_n.h>
	#include <__algorithm/transform.h>
	#include <array>
	#include <charconv>
	#include <concepts>
	#include <limits>
	#include <string>

	#ifndef _LIBCPP_HAS_NO_LOCALIZATION
	#include <locale>
	#endif

	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
	#pragma GCC system_header
	#endif

	_LIBCPP_PUSH_MACROS
	#include <__undef_macros>

	_LIBCPP_BEGIN_NAMESPACE_STD

	#if _LIBCPP_STD_VER > 17

	// TODO FMT Remove this once we require compilers with proper C++20 support.
	// If the compiler has no concepts support, the format header will be disabled.
	// Without concepts support enable_if needs to be used and that too much effort
	// to support compilers with partial C++20 support.
	#if !defined(_LIBCPP_HAS_NO_CONCEPTS)

	/**
	* Integral formatting classes.
	*
	* There are two types used here:
	* * C++-type, the type as used in C++.
	* * format-type, the output type specified in the std-format-spec.
	*
	* Design of the integral formatters consists of several layers.
	* * @ref __parser_integral The basic std-format-spec parser for all integral
	* classes. This parser does the basic sanity checks. It also contains some
	* helper functions that are nice to have available for all parsers.
	* * A C++-type specific parser. These parsers must derive from
	* @ref __parser_integral. Their task is to validate whether the parsed
	* std-format-spec is valid for the C++-type and selected format-type. After
	* validation they need to make sure all members are properly set. For
	* example, when the alignment hasn't changed it needs to set the proper
	* default alignment for the format-type. The following parsers are available:
	* - @ref __parser_integer
	* - @ref __parser_char
	* - @ref __parser_bool
	* * A general formatter for all integral types @ref __formatter_integral. This
	* formatter can handle all formatting of integers and characters. The class
	* derives from the proper formatter.
	* Note the boolean string format-type isn't supported in this class.
	* * A typedef C++-type group combining the @ref __formatter_integral with a
	* parser:
	* * @ref __formatter_integer
	* * @ref __formatter_char
	* * @ref __formatter_bool
	* * Then every C++-type has its own formatter specializations. They inherit
	* from the C++-type group typedef. Most specializations need nothing else.
	* Others need some additional specializations in this class.
	*/
	namespace __format_spec {

	/** Wrapper around @ref to_chars, returning the output pointer. */
	template <class _Tp>
	_LIBCPP_HIDE_FROM_ABI char* __to_buffer(char* __first, char* __last,
	_Tp __value, int __base) {
	// TODO FMT Evaluate code overhead due to not calling the internal function
	// directly. (Should be zero overhead.)
	to_chars_result __r = _VSTD::to_chars(__first, __last, __value, __base);
	_LIBCPP_ASSERT(__r.ec == errc(0), "Internal buffer too small");
	return __r.ptr;
	}

	/**
	* Helper to determine the buffer size to output a integer in Base @em x.
	*
	* There are several overloads for the supported bases. The function uses the
	* base as template argument so it can be used in a constant expression.
	*/
	template <unsigned_integral _Tp, size_t _Base>
	_LIBCPP_HIDE_FROM_ABI constexpr size_t __buffer_size() noexcept
	requires(_Base == 2) {
	return numeric_limits<_Tp>::digits // The number of binary digits.
	+ 2 // Reserve space for the '0[Bb]' prefix.
	+ 1; // Reserve space for the sign.
	}

	template <unsigned_integral _Tp, size_t _Base>
	_LIBCPP_HIDE_FROM_ABI constexpr size_t __buffer_size() noexcept
	requires(_Base == 8) {
	return numeric_limits<_Tp>::digits // The number of binary digits.
	/ 3 // Adjust to octal.
	+ 1 // Turn floor to ceil.
	+ 1 // Reserve space for the '0' prefix.
	+ 1; // Reserve space for the sign.
	}

	template <unsigned_integral _Tp, size_t _Base>
	_LIBCPP_HIDE_FROM_ABI constexpr size_t __buffer_size() noexcept
	requires(_Base == 10) {
	return numeric_limits<_Tp>::digits10 // The floored value.
	+ 1 // Turn floor to ceil.
	+ 1; // Reserve space for the sign.
	}

	template <unsigned_integral _Tp, size_t _Base>
	_LIBCPP_HIDE_FROM_ABI constexpr size_t __buffer_size() noexcept
	requires(_Base == 16) {
	return numeric_limits<_Tp>::digits // The number of binary digits.
	/ 4 // Adjust to hexadecimal.
	+ 2 // Reserve space for the '0[Xx]' prefix.
	+ 1; // Reserve space for the sign.
	}

	/**
	* Determines the required grouping based on the size of the input.
	*
	* The grouping's last element will be repeated. For simplicity this repeating
	* is unwrapped based on the length of the input. (When the input is short some
	* groups are not processed.)
	*
	* @returns The size of the groups to write. This means the number of
	* separator characters written is size() - 1.
	*
	* @note Since zero-sized groups cause issues they are silently ignored.
	*
	* @note The grouping field of the locale is always a @c std::string,
	* regardless whether the @c std::numpunct's type is @c char or @c wchar_t.
	*/
	_LIBCPP_HIDE_FROM_ABI inline string
	__determine_grouping(ptrdiff_t __size, const string& __grouping) {
	_LIBCPP_ASSERT(!__grouping.empty() && __size > __grouping[0],
	"The slow grouping formatting is used while there will be no "
	"separators written");
	string __r;
	auto __end = __grouping.end() - 1;
	auto __ptr = __grouping.begin();

	while (true) {
	__size -= *__ptr;
	if (__size > 0)
	__r.push_back(*__ptr);
	else {
	// __size <= 0 so the value pushed will be <= *__ptr.
	__r.push_back(*__ptr + __size);
	return __r;
	}

	// Proceed to the next group.
	if (__ptr != __end) {
	do {
	++__ptr;
	// Skip grouping with a width of 0.
	} while (*__ptr == 0 && __ptr != __end);
	}
	}

	_LIBCPP_UNREACHABLE();
	}

	template <class _Parser>
	requires __formatter::__char_type<typename _Parser::char_type>
	class _LIBCPP_TEMPLATE_VIS __formatter_integral : public _Parser {
	public:
	using _CharT = typename _Parser::char_type;

	template <integral _Tp>
	_LIBCPP_HIDE_FROM_ABI auto format(_Tp __value, auto& __ctx)
	-> decltype(__ctx.out()) {
	if (this->__width_needs_substitution())
	this->__substitute_width_arg_id(__ctx.arg(this->__width));

	if (this->__type == _Flags::_Type::__char)
	return __format_as_char(__value, __ctx);

	if constexpr (unsigned_integral<_Tp>)
	return __format_unsigned_integral(__value, false, __ctx);
	else {
	// Depending on the std-format-spec string the sign and the value
	// might not be outputted together:
	// - alternate form may insert a prefix string.
	// - zero-padding may insert additional '0' characters.
	// Therefore the value is processed as a positive unsigned value.
	// The function @ref __insert_sign will a '-' when the value was negative.
	auto __r = __to_unsigned_like(__value);
	bool __negative = __value < 0;
	if (__negative)
	__r = __complement(__r);

	return __format_unsigned_integral(__r, __negative, __ctx);
	}
	}

	private:
	/** Generic formatting for format-type c. */
	_LIBCPP_HIDE_FROM_ABI auto __format_as_char(integral auto __value,
	auto& __ctx)
	-> decltype(__ctx.out()) {
	if (this->__alignment == _Flags::_Alignment::__default)
	this->__alignment = _Flags::_Alignment::__right;

	using _Tp = decltype(__value);
	if constexpr (!same_as<_CharT, _Tp>) {
	// cmp_less and cmp_greater can't be used for character types.
	if constexpr (signed_integral<_CharT> == signed_integral<_Tp>) {
	if (__value < numeric_limits<_CharT>::min() \|\|
	__value > numeric_limits<_CharT>::max())
	__throw_format_error(
	"Integral value outside the range of the char type");
	} else if constexpr (signed_integral<_CharT>) {
	// _CharT is signed _Tp is unsigned
	if (__value >
	static_cast<make_unsigned_t<_CharT>>(numeric_limits<_CharT>::max()))
	__throw_format_error(
	"Integral value outside the range of the char type");
	} else {
	// _CharT is unsigned _Tp is signed
	if (__value < 0 \|\| static_cast<make_unsigned_t<_Tp>>(__value) >
	numeric_limits<_CharT>::max())
	__throw_format_error(
	"Integral value outside the range of the char type");
	}
	}

	const auto __c = static_cast<_CharT>(__value);
	return __write(_VSTD::addressof(__c), _VSTD::addressof(__c) + 1,
	__ctx.out());
	}

	/**
	* Generic formatting for format-type bBdoxX.
	*
	* This small wrapper allocates a buffer with the required size. Then calls
	* the real formatter with the buffer and the prefix for the base.
	*/
	_LIBCPP_HIDE_FROM_ABI auto
	__format_unsigned_integral(unsigned_integral auto __value, bool __negative,
	auto& __ctx) -> decltype(__ctx.out()) {
	switch (this->__type) {
	case _Flags::_Type::__binary_lower_case: {
	array<char, __buffer_size<decltype(__value), 2>()> __array;
	return __format_unsigned_integral(__array.begin(), __array.end(), __value,
	__negative, 2, __ctx, "0b");
	}
	case _Flags::_Type::__binary_upper_case: {
	array<char, __buffer_size<decltype(__value), 2>()> __array;
	return __format_unsigned_integral(__array.begin(), __array.end(), __value,
	__negative, 2, __ctx, "0B");
	}
	case _Flags::_Type::__octal: {
	// Octal is special; if __value == 0 there's no prefix.
	array<char, __buffer_size<decltype(__value), 8>()> __array;
	return __format_unsigned_integral(__array.begin(), __array.end(), __value,
	__negative, 8, __ctx,
	__value != 0 ? "0" : nullptr);
	}
	case _Flags::_Type::__decimal: {
	array<char, __buffer_size<decltype(__value), 10>()> __array;
	return __format_unsigned_integral(__array.begin(), __array.end(), __value,
	__negative, 10, __ctx, nullptr);
	}
	case _Flags::_Type::__hexadecimal_lower_case: {
	array<char, __buffer_size<decltype(__value), 16>()> __array;
	return __format_unsigned_integral(__array.begin(), __array.end(), __value,
	__negative, 16, __ctx, "0x");
	}
	case _Flags::_Type::__hexadecimal_upper_case: {
	array<char, __buffer_size<decltype(__value), 16>()> __array;
	return __format_unsigned_integral(__array.begin(), __array.end(), __value,
	__negative, 16, __ctx, "0X");
	}
	default:
	_LIBCPP_ASSERT(false, "The parser should have validated the type");
	_LIBCPP_UNREACHABLE();
	}
	}

	template <class _Tp>
	requires(same_as<char, _Tp> \|\| same_as<wchar_t, _Tp>) _LIBCPP_HIDE_FROM_ABI
	auto __write(const _Tp* __first, const _Tp* __last, auto __out_it)
	-> decltype(__out_it) {

	unsigned __size = __last - __first;
	if (this->__type != _Flags::_Type::__hexadecimal_upper_case) [[likely]] {
	if (__size >= this->__width)
	return _VSTD::copy(__first, __last, _VSTD::move(__out_it));

	return __formatter::__write(_VSTD::move(__out_it), __first, __last,
	__size, this->__width, this->__fill,
	this->__alignment);
	}

	// this->__type == _Flags::_Type::__hexadecimal_upper_case
	// This means all characters in the range [a-f] need to be changed to their
	// uppercase representation. The transformation is done as transformation
	// in the output routine instead of before. This avoids another pass over
	// the data.
	// TODO FMT See whether it's possible to do this transformation during the
	// conversion. (This probably requires changing std::to_chars' alphabet.)
	if (__size >= this->__width)
	return _VSTD::transform(__first, __last, _VSTD::move(__out_it),
	__hex_to_upper);

	return __formatter::__write(_VSTD::move(__out_it), __first, __last, __size,
	__hex_to_upper, this->__width, this->__fill,
	this->__alignment);
	}

	_LIBCPP_HIDE_FROM_ABI auto
	__format_unsigned_integral(char* __begin, char* __end,
	unsigned_integral auto __value, bool __negative,
	int __base, auto& __ctx, const char* __prefix)
	-> decltype(__ctx.out()) {
	char* __first = __insert_sign(__begin, __negative, this->__sign);
	if (this->__alternate_form && __prefix)
	while (*__prefix)
	__first++ = __prefix++;

	char* __last = __to_buffer(__first, __end, __value, __base);
	#ifndef _LIBCPP_HAS_NO_LOCALIZATION
	if (this->__locale_specific_form) {
	const auto& __np = use_facet<numpunct<_CharT>>(__ctx.locale());
	string __grouping = __np.grouping();
	ptrdiff_t __size = __last - __first;
	// Writing the grouped form has more overhead than the normal output
	// routines. If there will be no separators written the locale-specific
	// form is identical to the normal routine. Test whether to grouped form
	// is required.
	if (!__grouping.empty() && __size > __grouping[0])
	return __format_grouping(__ctx.out(), __begin, __first, __last,
	__determine_grouping(__size, __grouping),
	__np.thousands_sep());
	}
	#endif
	auto __out_it = __ctx.out();
	if (this->__alignment != _Flags::_Alignment::__default)
	__first = __begin;
	else {
	// __buf contains [sign][prefix]data
	// ^ location of __first
	// The zero padding is done like:
	// - Write [sign][prefix]
	// - Write data right aligned with '0' as fill character.
	__out_it = _VSTD::copy(__begin, __first, _VSTD::move(__out_it));
	this->__alignment = _Flags::_Alignment::__right;
	this->__fill = _CharT('0');
	uint32_t __size = __first - __begin;
	this->__width -= _VSTD::min(__size, this->__width);
	}

	return __write(__first, __last, _VSTD::move(__out_it));
	}

	#ifndef _LIBCPP_HAS_NO_LOCALIZATION
	/** Format's the locale-specific form's groupings. */
	template <class _OutIt, class _CharT>
	_LIBCPP_HIDE_FROM_ABI _OutIt
	__format_grouping(_OutIt __out_it, const char* __begin, const char* __first,
	const char* __last, string&& __grouping, _CharT __sep) {

	// TODO FMT This function duplicates some functionality of the normal
	// output routines. Evaluate whether these parts can be efficiently
	// combined with the existing routines.

	unsigned __size = (__first - __begin) + // [sign][prefix]
	(__last - __first) + // data
	(__grouping.size() - 1); // number of separator characters

	__formatter::__padding_size_result __padding = {0, 0};
	if (this->__alignment == _Flags::_Alignment::__default) {
	// Write [sign][prefix].
	__out_it = _VSTD::copy(__begin, __first, _VSTD::move(__out_it));

	if (this->__width > __size) {
	// Write zero padding.
	__padding.__before = this->__width - __size;
	__out_it = _VSTD::fill_n(_VSTD::move(__out_it), this->__width - __size,
	_CharT('0'));
	}
	} else {
	if (this->__width > __size) {
	// Determine padding and write padding.
	__padding = __formatter::__padding_size(__size, this->__width,
	this->__alignment);

	__out_it = _VSTD::fill_n(_VSTD::move(__out_it), __padding.__before,
	this->__fill);
	}
	// Write [sign][prefix].
	__out_it = _VSTD::copy(__begin, __first, _VSTD::move(__out_it));
	}

	auto __r = __grouping.rbegin();
	auto __e = __grouping.rend() - 1;
	_LIBCPP_ASSERT(__r != __e, "The slow grouping formatting is used while "
	"there will be no separators written.");
	// The output is divided in small groups of numbers to write:
	// - A group before the first separator.
	// - A separator and a group, repeated for the number of separators.
	// - A group after the last separator.
	// This loop achieves that process by testing the termination condition
	// midway in the loop.
	//
	// TODO FMT This loop evaluates the loop invariant `this->__type !=
	// _Flags::_Type::__hexadecimal_upper_case` for every iteration. (This test
	// happens in the __write call.) Benchmark whether making two loops and
	// hoisting the invariant is worth the effort.
	while (true) {
	if (this->__type == _Flags::_Type::__hexadecimal_upper_case) {
	__last = __first + *__r;
	__out_it = _VSTD::transform(__first, __last, _VSTD::move(__out_it),
	__hex_to_upper);
	__first = __last;
	} else {
	__out_it = _VSTD::copy_n(__first, *__r, _VSTD::move(__out_it));
	__first += *__r;
	}

	if (__r == __e)
	break;

	++__r;
	*__out_it++ = __sep;
	}

	return _VSTD::fill_n(_VSTD::move(__out_it), __padding.__after,
	this->__fill);
	}
	#endif // _LIBCPP_HAS_NO_LOCALIZATION
	};

	} // namespace __format_spec

	#endif // !defined(_LIBCPP_HAS_NO_CONCEPTS)

	#endif //_LIBCPP_STD_VER > 17

	_LIBCPP_END_NAMESPACE_STD

	_LIBCPP_POP_MACROS

	#endif // _LIBCPP___FORMAT_FORMATTER_INTEGRAL_H